Use FAIL as the default dest if unable to parse

build.zig

@@ -1,5 +1,4 @@
 const std = @import("std");
-const Step = std.Build.Step;
 
 // Although this function looks imperative, note that its job is to
 // declaratively construct a build graph that will be executed by an external
@@ -38,29 +37,13 @@ pub fn build(b: *std.Build) void {
     exe_mod.addImport("zaprus", lib_mod);
     exe_mod.addImport("clap", b.dependency("clap", .{}).module("clap"));
 
-    const static_lib = b.addLibrary(.{
+    const lib = b.addLibrary(.{
         .linkage = .static,
         .name = "zaprus",
         .root_module = lib_mod,
     });
-    static_lib.addIncludePath(.{ .cwd_relative = "include" });
-    static_lib.linkLibC();
 
-    b.installArtifact(static_lib);
+    b.installArtifact(lib);
-
-    const dynamic_lib = b.addLibrary(.{
-        .linkage = .dynamic,
-        .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");
-    b.getInstallStep().dependOn(&c_header.step);
 
     // This creates another `std.Build.Step.Compile`, but this one builds an executable
     // rather than a static library.

include/zaprus.h

@@ -1,46 +0,0 @@
-// 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_initial_connection(const char* payload, size_t len, uint16_t initial_port);
-
-struct SaprusMessage* zaprus_connect(const char* payload, size_t len);
-
-// message
-#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 {
-      char dest[4];
-    } relay;
-    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, size_t* len);
-
-// Return value should be destroyed with zaprus_message_deinit.
-struct SaprusMessage* zaprus_message_from_bytes(const char* bytes, size_t 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,126 +0,0 @@
-const c = @cImport({
-    @cInclude("zaprus.h");
-});
-
-fn zigToCMessage(msg: zaprus.Message) !c.SaprusMessage {
-    return switch (msg) {
-        .relay => |r| .{
-            .packet_type = @intFromEnum(msg),
-            .payload_len = @intCast(r.payload.len),
-            .headers = .{ .relay = .{
-                .dest = r.header.dest,
-            } },
-            .payload = @constCast(r.payload.ptr),
-        },
-        .connection => |con| .{
-            .packet_type = @intFromEnum(msg),
-            .payload_len = @intCast(con.payload.len),
-            .headers = .{ .connection = .{
-                .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),
-            } },
-            .payload = @constCast(con.payload.ptr),
-        },
-        .file_transfer => return zaprus.Error.NotImplementedSaprusType,
-        else => return zaprus.Error.UnknownSaprusType,
-    };
-}
-
-fn cToZigMessage(msg: c.SaprusMessage) !zaprus.Message {
-    const msg_type: zaprus.PacketType = @enumFromInt(msg.packet_type);
-    return switch (msg_type) {
-        .relay => .{
-            .relay = .{
-                .header = .{
-                    .dest = msg.headers.relay.dest[0..4].*,
-                },
-                .payload = msg.payload[0..msg.payload_len],
-            },
-        },
-        .connection => .{
-            .connection = .{
-                .header = .{
-                    .src_port = msg.headers.connection.src_port,
-                    .dest_port = msg.headers.connection.dest_port,
-                    .seq_num = msg.headers.connection.seq_num,
-                    .msg_id = msg.headers.connection.msg_id,
-                    .reserved = msg.headers.connection._reserved,
-                    .options = @bitCast(msg.headers.connection.options),
-                },
-                .payload = msg.payload[0..msg.payload_len],
-            },
-        },
-        .file_transfer => return zaprus.Error.NotImplementedSaprusType,
-        else => return zaprus.Error.UnknownSaprusType,
-    };
-}
-
-// client
-export fn zaprus_init() c_int {
-    SaprusClient.init() catch return 1;
-    return 0;
-}
-
-export fn zaprus_deinit() c_int {
-    SaprusClient.deinit();
-    return 0;
-}
-
-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;
-    return 0;
-}
-
-export fn zaprus_connect(payload: [*]const u8, len: usize) ?*c.SaprusMessage {
-    if (SaprusClient.connect(payload[0..len], allocator)) |msg| {
-        var m = zigToCMessage(msg) catch return null;
-        return &m;
-    } else |_| {
-        return null;
-    }
-}
-
-// message
-
-/// ptr should be freed by the caller.
-export fn zaprus_message_to_bytes(msg: c.SaprusMessage, ptr: *[*]u8, len: *usize) c_int {
-    var m = cToZigMessage(msg) catch return 1;
-    const bytes = m.toBytes(allocator) catch return 1;
-    ptr.* = bytes.ptr;
-    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) ?*c.SaprusMessage {
-    if (zaprus.Message.fromBytes(bytes[0..len], allocator)) |msg| {
-        var m = zigToCMessage(msg) catch return null;
-        return &m;
-    } else |_| return null;
-}
-
-export fn zaprus_message_deinit(msg: *c.SaprusMessage) void {
-    if (cToZigMessage(msg.*)) |m| {
-        m.deinit(allocator);
-    } else |_| unreachable;
-}
-
-const std = @import("std");
-
-const zaprus = @import("./root.zig");
-const SaprusClient = zaprus.Client;
-
-const allocator = std.heap.c_allocator;
-
-test {
-    std.testing.refAllDeclsRecursively(@This());
-}

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 = try std.net.Ip4Address.parse(dest, 0);
+        const addr = std.net.Ip4Address.parse(dest, 0) catch return "FAIL".*;
         return @bitCast(addr.sa.addr);
     }
-    return "FAIL".*;
+    return "zap".*;
 }
 
 const builtin = @import("builtin");

src/root.zig

@@ -1,4 +1,2 @@
 pub const Client = @import("Client.zig");
 pub usingnamespace @import("message.zig");
-
-pub usingnamespace @import("c_api.zig");