Make C struct match the binary API more closely

Also make the internal conversion function return errors properly

build.zig

@@ -43,6 +43,8 @@ pub fn build(b: *std.Build) void {
         .name = "zaprus",
         .root_module = lib_mod,
     });
+    static_lib.addIncludePath(.{ .cwd_relative = "include" });
+    static_lib.linkLibC();
 
     b.installArtifact(static_lib);
 
@@ -51,16 +53,13 @@ pub fn build(b: *std.Build) void {
         .name = "zaprus",
         .root_module = lib_mod,
     });
+    dynamic_lib.addIncludePath(.{ .cwd_relative = "include" });
+    dynamic_lib.linkLibC();
 
     b.installArtifact(dynamic_lib);
 
     // C Headers
-    const c_header = b.addInstallFileWithDir(
-        b.path("include/zaprus.h"),
-        .header,
-        "zaprus.h",
-    );
-
+    const c_header = b.addInstallHeaderFile(b.path("include/zaprus.h"), "zaprus.h");
     b.getInstallStep().dependOn(&c_header.step);
 
     // This creates another `std.Build.Step.Compile`, but this one builds an executable

include/zaprus.h

@@ -1,24 +1,51 @@
 // client
 
+#include<stdint.h>
+#include<stdlib.h>
+
 int zaprus_init(void);
 
 int zaprus_deinit(void);
 
-int zaprus_send_relay(const char* payload, usize len, char[4] dest);
+int zaprus_send_relay(const char* payload, size_t len, char dest[4]);
 
-int zaprus_send_initial_connection(const char* payload, usize len, uint16_t initial_port);
+int zaprus_send_initial_connection(const char* payload, size_t len, uint16_t initial_port);
 
-struct SaprusMessage* zaprus_connect(const char* payload, usize len);
+struct SaprusMessage* zaprus_connect(const char* payload, size_t len);
 
 // message
-struct SaprusMessage {
+#define SAPRUS_RELAY_MESSAGE_TYPE 0x003C
+#define SAPRUS_FILE_TRANSFER_MESSAGE_TYPE 0x8888
+#define SAPRUS_CONNECTION_MESSAGE_TYPE 0x00E9
 
+struct SaprusMessage {
+  uint16_t packet_type;
+  uint16_t payload_len;
+  union {
+    struct {
+      struct {
+	char dest[4];
+      };
+    } relay;
+    struct {
+      struct {
+	uint16_t src_port;
+	uint16_t dest_port;
+	uint32_t seq_num;
+	uint32_t msg_id;
+	char _reserved;
+	char options;
+      };
+      
+    } connection;
+  } headers;
+  char *payload;
 };
 
 // ptr should be freed by the caller.
-int zaprus_message_to_bytes(struct SaprusMessage msg, char** ptr, usize* len);
+int zaprus_message_to_bytes(struct SaprusMessage msg, char** ptr, size_t* len);
 
 // Return value should be destroyed with zaprus_message_deinit.
-struct SaprusMessage* zaprus_message_from_bytes(const char* bytes, usize len);
+struct SaprusMessage* zaprus_message_from_bytes(const char* bytes, size_t len);
 
 void zaprus_message_deinit(struct SaprusMessage* msg);

src/c_api.zig

@@ -1,5 +1,55 @@
-// client
+const c = @cImport({
+    @cInclude("zaprus.h");
+});
 
+fn zigToCMessage(msg: ?*zaprus.Message) !?*c.SaprusMessage {
+    if (msg) |m| {
+        var res = c.SaprusMessage{
+            .packet_type = @intFromEnum(m.*),
+        };
+        switch (m.*) {
+            .relay => |r| {
+                res.headers.relay = .{
+                    .unnamed_0 = .{
+                        .dest = r.header.dest,
+                    },
+                };
+                res.payload_len = @intCast(r.payload.len);
+                res.payload = (try allocator.alloc(u8, r.payload.len)).ptr;
+            },
+            .connection => |con| {
+                res.headers.connection = .{
+                    .unnamed_0 = .{
+                        .src_port = con.header.src_port,
+                        .dest_port = con.header.dest_port,
+                        .seq_num = con.header.seq_num,
+                        .msg_id = con.header.msg_id,
+                        ._reserved = con.header.reserved,
+                        .options = @bitCast(con.header.options),
+                    },
+                };
+
+                res.payload_len = @intCast(con.payload.len);
+                res.payload = (try allocator.alloc(u8, con.payload.len)).ptr;
+            },
+            .file_transfer => return zaprus.Error.NotImplementedSaprusType,
+            else => return zaprus.Error.UnknownSaprusType,
+        }
+        return &res;
+    } else return null;
+}
+
+fn cToZigMessage(msg: ?*c.SaprusMessage) ?*zaprus.Message {
+    _ = msg;
+    return @constCast(&zaprus.Message{
+        .relay = .{
+            .header = .{ .dest = @splat(0) },
+            .payload = &.{0},
+        },
+    });
+}
+
+// client
 export fn zaprus_init() c_int {
     SaprusClient.init() catch return 1;
     return 0;
@@ -10,44 +60,53 @@ export fn zaprus_deinit() c_int {
     return 0;
 }
 
-export fn zaprus_send_relay(payload: [*]const u8, len: usize, dest: [4]u8) c_int {
-    SaprusClient.sendRelay(payload[0..len], dest, allocator) catch return 1;
+export fn zaprus_send_relay(payload: [*]const u8, len: usize, dest: [*]u8) c_int {
+    SaprusClient.sendRelay(payload[0..len], dest[0..4].*, allocator) catch return 1;
     return 0;
 }
 
 export fn zaprus_send_initial_connection(payload: [*]const u8, len: usize, initial_port: u16) c_int {
-    SaprusClient.sendInitialConnection(payload[0..len], initial_port, allocator) catch return 1;
+    _ = SaprusClient.sendInitialConnection(payload[0..len], initial_port, allocator) catch return 1;
     return 0;
 }
 
-export fn zaprus_connect(payload: [*]const u8, len: usize) ?*SaprusMessage {
-    return SaprusClient.connect(payload[0..len], allocator) catch null;
+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;
+    } else |_| {
+        return null;
+    }
 }
 
 // message
 
 /// ptr should be freed by the caller.
-export fn zaprus_message_to_bytes(msg: SaprusMessage, ptr: *[*]u8, len: *usize) c_int {
-    const bytes = msg.toBytes(allocator) catch return 1;
-    ptr.* = bytes[0..].*;
-    len.* = bytes.len;
-    return 0;
+export fn zaprus_message_to_bytes(msg: c.SaprusMessage, ptr: *[*]u8, len: *usize) c_int {
+    if (cToZigMessage(@constCast(&msg))) |m| {
+        const bytes = m.toBytes(allocator) catch return 1;
+        ptr.* = bytes.ptr;
+        len.* = bytes.len;
+        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) ?*SaprusMessage {
-    return SaprusMessage.fromBytes(bytes[0..len], allocator) catch null;
+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;
+    } else |_| return null;
 }
 
-export fn zaprus_message_deinit(msg: *SaprusMessage) void {
-    msg.deinit(allocator);
+export fn zaprus_message_deinit(msg: *c.SaprusMessage) void {
+    // noop
+    _ = msg;
+    // msg.*.deinit(allocator);
 }
 
 const std = @import("std");
 
 const zaprus = @import("./root.zig");
 const SaprusClient = zaprus.Client;
-const SaprusMessage = zaprus.Message;
 
 const allocator = std.heap.c_allocator;