Big changes to the C api implementations

Should map directly to the zig struct instead of mallocing

src/Client.zig

@@ -76,7 +76,7 @@ pub fn sendInitialConnection(payload: []const u8, initial_port: u16, allocator:
     return msg;
 }
 
-pub fn connect(payload: []const u8, allocator: Allocator) !?SaprusMessage {
+pub fn connect(payload: []const u8, allocator: Allocator) !SaprusMessage {
     var initial_port: u16 = 0;
     if (rand) |r| {
         initial_port = r.intRangeAtMost(u16, 1024, 65000);
@@ -109,7 +109,7 @@ pub fn connect(payload: []const u8, allocator: Allocator) !?SaprusMessage {
     // Complete handshake after awaiting response
     try broadcastSaprusMessage(msg, randomPort(), allocator);
 
-    return initial_conn_res;
+    return initial_conn_res.?;
 }
 
 const SaprusMessage = @import("message.zig").Message;

src/c_api.zig

@@ -2,78 +2,61 @@ const c = @cImport({
     @cInclude("zaprus.h");
 });
 
-fn zigToCMessage(msg: ?*zaprus.Message) !?*c.SaprusMessage {
+fn zigToCMessage(msg: zaprus.Message) !c.SaprusMessage {
-    if (msg) |m| {
+    return switch (msg) {
-        var res = c.SaprusMessage{
+        .relay => |r| .{
-            .packet_type = @intFromEnum(m.*),
+            .packet_type = @intFromEnum(msg),
-        };
+            .payload_len = @intCast(r.payload.len),
-        switch (m.*) {
+            .headers = .{ .relay = .{
-            .relay => |r| {
+                .dest = r.header.dest,
-                res.headers.relay = .{
+            } },
-                    .dest = r.header.dest,
+            .payload = @constCast(r.payload.ptr),
-                };
+        },
-                res.payload_len = @intCast(r.payload.len);
+        .connection => |con| .{
-                res.payload = (try allocator.alloc(u8, r.payload.len)).ptr;
+            .packet_type = @intFromEnum(msg),
-            },
+            .payload_len = @intCast(con.payload.len),
-            .connection => |con| {
+            .headers = .{ .connection = .{
-                res.headers.connection = .{
+                .src_port = con.header.src_port,
-                    .src_port = con.header.src_port,
+                .dest_port = con.header.dest_port,
-                    .dest_port = con.header.dest_port,
+                .seq_num = con.header.seq_num,
-                    .seq_num = con.header.seq_num,
+                .msg_id = con.header.msg_id,
-                    .msg_id = con.header.msg_id,
+                ._reserved = con.header.reserved,
-                    ._reserved = con.header.reserved,
+                .options = @bitCast(con.header.options),
-                    .options = @bitCast(con.header.options),
+            } },
-                };
+            .payload = @constCast(con.payload.ptr),
-
+        },
-                res.payload_len = @intCast(con.payload.len);
+        .file_transfer => return zaprus.Error.NotImplementedSaprusType,
-                res.payload = (try allocator.alloc(u8, con.payload.len)).ptr;
+        else => return zaprus.Error.UnknownSaprusType,
-            },
+    };
-            .file_transfer => return zaprus.Error.NotImplementedSaprusType,
-            else => return zaprus.Error.UnknownSaprusType,
-        }
-        return &res;
-    } else return null;
 }
 
-fn cToZigMessage(msg: ?*c.SaprusMessage) !?*zaprus.Message {
+fn cToZigMessage(msg: c.SaprusMessage) !zaprus.Message {
-    if (msg) |m| {
+    const msg_type: zaprus.PacketType = @enumFromInt(msg.packet_type);
-        const msg_type: zaprus.PacketType = @enumFromInt(m.*.packet_type);
+    return switch (msg_type) {
-        var res: zaprus.Message = switch (msg_type) {
+        .relay => .{
-            .relay => .{
+            .relay = .{
-                .relay = .{
+                .header = .{
-                    .header = .{
+                    .dest = msg.headers.relay.dest[0..4].*,
-                        .dest = m.*.headers.relay.dest[0..4].*,
-                    },
-                    .payload = blk: {
-                        const p = try allocator.alloc(u8, m.payload_len);
-                        @memcpy(p, m.payload[0..m.payload_len]);
-                        break :blk p;
-                    },
                 },
+                .payload = msg.payload[0..msg.payload_len],
             },
-            .connection => .{
+        },
-                .connection = .{
+        .connection => .{
-                    .header = .{
+            .connection = .{
-                        .src_port = m.*.headers.connection.src_port,
+                .header = .{
-                        .dest_port = m.*.headers.connection.dest_port,
+                    .src_port = msg.headers.connection.src_port,
-                        .seq_num = m.*.headers.connection.seq_num,
+                    .dest_port = msg.headers.connection.dest_port,
-                        .msg_id = m.*.headers.connection.msg_id,
+                    .seq_num = msg.headers.connection.seq_num,
-                        .reserved = m.*.headers.connection._reserved,
+                    .msg_id = msg.headers.connection.msg_id,
-                        .options = @bitCast(m.*.headers.connection.options),
+                    .reserved = msg.headers.connection._reserved,
-                    },
+                    .options = @bitCast(msg.headers.connection.options),
-                    .payload = blk: {
-                        const p = try allocator.alloc(u8, m.payload_len);
-                        @memcpy(p, m.payload[0..m.payload_len]);
-                        break :blk p;
-                    },
                 },
+                .payload = msg.payload[0..msg.payload_len],
             },
-            .file_transfer => return zaprus.Error.NotImplementedSaprusType,
+        },
-            else => return zaprus.Error.UnknownSaprusType,
+        .file_transfer => return zaprus.Error.NotImplementedSaprusType,
-        };
+        else => return zaprus.Error.UnknownSaprusType,
-
+    };
-        return &res;
-    } else return null;
 }
 
 // client
@@ -99,7 +82,8 @@ export fn zaprus_send_initial_connection(payload: [*]const u8, len: usize, initi
 
 export fn zaprus_connect(payload: [*]const u8, len: usize) ?*c.SaprusMessage {
     if (SaprusClient.connect(payload[0..len], allocator)) |msg| {
-        return zigToCMessage(@constCast(&(msg.?))) catch null;
+        var m = zigToCMessage(msg) catch return null;
+        return &m;
     } else |_| {
         return null;
     }
@@ -109,25 +93,25 @@ export fn zaprus_connect(payload: [*]const u8, len: usize) ?*c.SaprusMessage {
 
 /// ptr should be freed by the caller.
 export fn zaprus_message_to_bytes(msg: c.SaprusMessage, ptr: *[*]u8, len: *usize) c_int {
-    if (cToZigMessage(@constCast(&msg)) catch return 1) |m| {
+    var m = cToZigMessage(msg) catch return 1;
-        const bytes = m.toBytes(allocator) catch return 1;
+    const bytes = m.toBytes(allocator) catch return 1;
-        ptr.* = bytes.ptr;
+    ptr.* = bytes.ptr;
-        len.* = bytes.len;
+    len.* = bytes.len;
-        return 0;
+    return 0;
-    } else return 1;
 }
 
 /// Return value should be destroyed with zaprus_message_deinit.
 export fn zaprus_message_from_bytes(bytes: [*]const u8, len: usize) ?*c.SaprusMessage {
     if (zaprus.Message.fromBytes(bytes[0..len], allocator)) |msg| {
-        return zigToCMessage(@constCast(&msg)) catch null;
+        var m = zigToCMessage(msg) catch return null;
+        return &m;
     } else |_| return null;
 }
 
 export fn zaprus_message_deinit(msg: *c.SaprusMessage) void {
-    // noop
+    if (cToZigMessage(msg.*)) |m| {
-    _ = msg;
+        m.deinit(allocator);
-    // msg.*.deinit(allocator);
+    } else |_| unreachable;
 }
 
 const std = @import("std");