Initial C api

build.zig

@@ -43,8 +43,6 @@ 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);
 
@@ -53,13 +51,16 @@ 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.addInstallHeaderFile(b.path("include/zaprus.h"), "zaprus.h");
+    const c_header = b.addInstallFileWithDir(
+        b.path("include/zaprus.h"),
+        .header,
+        "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,15 +1,24 @@
 // client
 
-#include<stdint.h>
-#include<stdlib.h>
-
 int zaprus_init(void);
 
 int zaprus_deinit(void);
 
-int zaprus_send_relay(const char* payload, size_t len, char dest[4]);
+int zaprus_send_relay(const char* payload, usize len, char[4] dest);
 
-int zaprus_send_initial_connection(const char* payload, size_t len, uint16_t initial_port);
+int zaprus_send_initial_connection(const char* payload, usize len, uint16_t initial_port);
 
-void* zaprus_connect(const char* payload, size_t len);
+struct SaprusMessage* zaprus_connect(const char* payload, usize len);
 
+// message
+struct SaprusMessage {
+  
+};
+
+// ptr should be freed by the caller.
+int zaprus_message_to_bytes(struct SaprusMessage msg, char** ptr, usize* len);
+
+// Return value should be destroyed with zaprus_message_deinit.
+struct SaprusMessage* zaprus_message_from_bytes(const char* bytes, usize len);
+
+void zaprus_message_deinit(struct SaprusMessage* msg);

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

@@ -1,4 +1,5 @@
 // client
+
 export fn zaprus_init() c_int {
     SaprusClient.init() catch return 1;
     return 0;
@@ -9,21 +10,44 @@ export fn zaprus_deinit() c_int {
     return 0;
 }
 
-export fn zaprus_send_relay(payload: [*]const u8, len: usize, dest: [*]u8) c_int {
+export fn zaprus_send_relay(payload: [*]const u8, len: usize, dest: [4]u8) c_int {
-    SaprusClient.sendRelay(payload[0..len], dest[0..4].*, allocator) catch return 1;
+    SaprusClient.sendRelay(payload[0..len], dest, allocator) catch return 1;
     return 0;
 }
 
-export fn zaprus_connect(payload: [*]const u8, len: usize, output: *SaprusConnection) c_int {
+export fn zaprus_send_initial_connection(payload: [*]const u8, len: usize, initial_port: u16) c_int {
-    output.* = (SaprusClient.connect(payload[0..len], 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;
+}
+
+// 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;
+}
+
+/// 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_deinit(msg: *SaprusMessage) void {
+    msg.deinit(allocator);
+}
+
 const std = @import("std");
 
 const zaprus = @import("./root.zig");
 const SaprusClient = zaprus.Client;
-const SaprusConnection = zaprus.Connection;
+const SaprusMessage = zaprus.Message;
 
 const allocator = std.heap.c_allocator;
 

src/main.zig

@@ -75,7 +75,7 @@ pub fn main() !void {
     return clap.help(std.io.getStdErr().writer(), clap.Help, &params, .{});
 }
 
-fn parseDest(in: ?[]const u8) [4]u8 {
+fn parseDest(in: ?[]const u8) ![4]u8 {
     if (in) |dest| {
         if (dest.len <= 4) {
             var res: [4]u8 = @splat(0);
@@ -83,10 +83,10 @@ fn parseDest(in: ?[]const u8) [4]u8 {
             return res;
         }
 
-        const addr = std.net.Ip4Address.parse(dest, 0) catch return "FAIL".*;
+        const addr = try std.net.Ip4Address.parse(dest, 0);
         return @bitCast(addr.sa.addr);
     }
-    return "zap".*;
+    return .{ 70, 70, 70, 70 };
 }
 
 const builtin = @import("builtin");