Use slice for init, and add better error sets.

The slice sets us avoid allocating within the init function.
This means init can't fail, and it also makes it easier to stack allocate messages (slice an array buffer, instead of creating a stack allocator).

1 files changed, 21 insertions, 11 deletions

diff --git a/src/Client.zig b/src/Client.zig
index 0a1cd99..2a7eaaf 100644
--- a/src/Client.zig
+++ b/src/Client.zig
@@ -48,12 +48,17 @@ fn broadcastSaprusMessage(msg: *SaprusMessage, udp_port: u16) !void {
 }
 
 pub fn sendRelay(payload: []const u8, dest: [4]u8, allocator: Allocator) !void {
-    const msg: *SaprusMessage = try .init(
-        allocator,
-        .relay,
-        @intCast(base64Enc.calcSize(payload.len)),
+    const msg_bytes = try allocator.alignedAlloc(
+        u8,
+        @alignOf(SaprusMessage),
+        try SaprusMessage.lengthForPayloadLength(
+            .relay,
+            base64Enc.calcSize(payload.len),
+        ),
     );
-    defer msg.deinit(allocator);
+    defer allocator.free(msg_bytes);
+    const msg: *SaprusMessage = .init(.relay, msg_bytes);
+
     const relay = (try msg.getSaprusTypePayload()).relay;
     relay.dest = dest;
     _ = base64Enc.encode(relay.getPayload(), payload);
@@ -72,8 +77,14 @@ fn randomPort() u16 {
 
 pub fn sendInitialConnection(payload: []const u8, initial_port: u16, allocator: Allocator) !*SaprusMessage {
     const dest_port = randomPort();
-    const msg: *SaprusMessage = try .init(allocator, .connection, @intCast(payload.len));
-    defer msg.deinit(allocator);
+    const msg_bytes = try allocator.alignedAlloc(
+        u8,
+        @alignOf(SaprusMessage),
+        try SaprusMessage.lengthForPayloadLength(.connection, payload.len),
+    );
+    defer allocator.free(msg_bytes);
+    const msg: *SaprusMessage = .init(.connection, msg_bytes);
+
     const connection = (try msg.getSaprusTypePayload()).connection;
     connection.src_port = initial_port;
     connection.dest_port = dest_port;
@@ -90,8 +101,7 @@ pub fn connect(payload: []const u8, allocator: Allocator) !?SaprusConnection {
         initial_port = r.intRangeAtMost(u16, 1024, 65000);
     } else unreachable;
 
-    var initial_conn_res: ?SaprusMessage = null;
-    errdefer if (initial_conn_res) |*c| c.deinit(allocator);
+    var initial_conn_res: ?*SaprusMessage = null;
 
     var sock = try network.Socket.create(.ipv4, .udp);
     defer sock.close();
@@ -112,8 +122,8 @@ pub fn connect(payload: []const u8, allocator: Allocator) !?SaprusConnection {
     _ = try sock.receive(&response_buf); // Ignore message that I sent.
     const len = try sock.receive(&response_buf);
 
-    std.debug.print("response bytes: {x}\n", .{response_buf});
-    initial_conn_res = (try SaprusMessage.bytesAsValue(response_buf[0..len])).*;
+    std.debug.print("response bytes: {x}\n", .{response_buf[0..len]});
+    initial_conn_res = SaprusMessage.init(.connection, response_buf[0..len]);
 
     // Complete handshake after awaiting response
     try broadcastSaprusMessage(msg, randomPort());