Need to flush io in release mode

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
@@ -16,12 +15,6 @@ pub fn build(b: *std.Build) void {
     // set a preferred release mode, allowing the user to decide how to optimize.
     const optimize = b.standardOptimizeOption(.{});
 
-    const lib_mod = b.createModule(.{
-        .root_source_file = b.path("src/root.zig"),
-        .target = target,
-        .optimize = optimize,
-    });
-
     // We will also create a module for our other entry point, 'main.zig'.
     const exe_mod = b.createModule(.{
         // `root_source_file` is the Zig "entry point" of the module. If a module
@@ -33,35 +26,9 @@ pub fn build(b: *std.Build) void {
         .optimize = optimize,
     });
 
-    lib_mod.addImport("network", b.dependency("network", .{}).module("network"));
+    exe_mod.addImport("network", b.dependency("network", .{}).module("network"));
-
-    exe_mod.addImport("zaprus", lib_mod);
     exe_mod.addImport("clap", b.dependency("clap", .{}).module("clap"));
 
-    const static_lib = b.addLibrary(.{
-        .linkage = .static,
-        .name = "zaprus",
-        .root_module = lib_mod,
-    });
-    static_lib.addIncludePath(.{ .cwd_relative = "include" });
-    static_lib.linkLibC();
-
-    b.installArtifact(static_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.
     const exe = b.addExecutable(.{

include/zaprus.h

@@ -1,51 +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 {
-      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, 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/c_api.zig

@@ -1,115 +0,0 @@
-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;
-}
-
-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| {
-        return zigToCMessage(@constCast(&(msg.?))) catch null;
-    } 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 {
-    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) ?*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: *c.SaprusMessage) void {
-    // noop
-    _ = msg;
-    // msg.*.deinit(allocator);
-}
-
-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

@@ -23,7 +23,6 @@ pub fn main() !void {
     const params = comptime clap.parseParamsComptime(
         \\-h, --help           Display this help and exit.
         \\-r, --relay <str>    A relay message to send.
-        \\-d, --dest <str>     An IPv4 or <= 4 ASCII byte string.
         \\-c, --connect <str>  A connection message to send.
         \\
     );
@@ -42,24 +41,21 @@ pub fn main() !void {
     };
     defer res.deinit();
 
-    try SaprusClient.init();
+    try Saprus.init();
-    defer SaprusClient.deinit();
+    defer Saprus.deinit();
 
     if (res.args.help != 0) {
         return clap.help(std.io.getStdErr().writer(), clap.Help, &params, .{});
     }
 
+    std.debug.print("main\n", .{});
+
     if (res.args.relay) |r| {
-        const dest = parseDest(res.args.dest) catch .{ 70, 70, 70, 70 };
+        try Saprus.sendRelay(if (r.len > 0) r else "Hello darkness my old friend", gpa);
-        try SaprusClient.sendRelay(
+        std.debug.print("Sent: {s}\n", .{r});
-            if (r.len > 0) r else "Hello darkness my old friend",
-            dest,
-            gpa,
-        );
-        // std.debug.print("Sent: {s}\n", .{r});
         return;
     } else if (res.args.connect) |c| {
-        const conn_res: ?SaprusMessage = SaprusClient.connect(if (c.len > 0) c else "Hello darkness my old friend", gpa) catch |err| switch (err) {
+        const conn_res: ?SaprusMessage = Saprus.connect(if (c.len > 0) c else "Hello darkness my old friend", gpa) catch |err| switch (err) {
             error.WouldBlock => null,
             else => return err,
         };
@@ -75,27 +71,12 @@ pub fn main() !void {
     return clap.help(std.io.getStdErr().writer(), clap.Help, &params, .{});
 }
 
-fn parseDest(in: ?[]const u8) ![4]u8 {
-    if (in) |dest| {
-        if (dest.len <= 4) {
-            var res: [4]u8 = @splat(0);
-            @memcpy(res[0..dest.len], dest);
-            return res;
-        }
-
-        const addr = try std.net.Ip4Address.parse(dest, 0);
-        return @bitCast(addr.sa.addr);
-    }
-    return .{ 70, 70, 70, 70 };
-}
-
 const builtin = @import("builtin");
 const std = @import("std");
 const DebugAllocator = std.heap.DebugAllocator(.{});
 const ArrayList = std.ArrayList;
 
-const zaprus = @import("zaprus");
+const Saprus = @import("./saprus.zig");
-const SaprusClient = zaprus.Client;
+const SaprusMessage = Saprus.SaprusMessage;
-const SaprusMessage = zaprus.Message;
 
 const clap = @import("clap");

src/root.zig

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

src/saprus.zig

@@ -39,10 +39,10 @@ fn broadcastSaprusMessage(msg: SaprusMessage, udp_port: u16, allocator: Allocato
     _ = try sock.sendTo(dest_addr, msg_bytes);
 }
 
-pub fn sendRelay(payload: []const u8, dest: [4]u8, allocator: Allocator) !void {
+pub fn sendRelay(payload: []const u8, allocator: Allocator) !void {
     const msg = SaprusMessage{
         .relay = .{
-            .header = .{ .dest = dest },
+            .header = .{ .dest = .{ 255, 255, 255, 255 } },
             .payload = payload,
         },
     };
@@ -85,9 +85,11 @@ pub fn connect(payload: []const u8, allocator: Allocator) !?SaprusMessage {
     var initial_conn_res: ?SaprusMessage = null;
     errdefer if (initial_conn_res) |c| c.deinit(allocator);
 
+    std.debug.print("creating socket\n", .{});
     var sock = try network.Socket.create(.ipv4, .udp);
     defer sock.close();
 
+    std.debug.print("creating endpoint\n", .{});
     // Bind to 255.255.255.255:8888
     const bind_addr = network.EndPoint{
         .address = network.Address{ .ipv4 = network.Address.IPv4.broadcast },
@@ -96,8 +98,10 @@ pub fn connect(payload: []const u8, allocator: Allocator) !?SaprusMessage {
 
     // timeout 1s
     try sock.setReadTimeout(1 * std.time.us_per_s);
+    std.debug.print("binding to socket\n", .{});
     try sock.bind(bind_addr);
 
+    std.debug.print("sending initial connection payload\n", .{});
     const msg = try sendInitialConnection(payload, initial_port, allocator);
 
     var response_buf: [4096]u8 = undefined;
@@ -112,7 +116,7 @@ pub fn connect(payload: []const u8, allocator: Allocator) !?SaprusMessage {
     return initial_conn_res;
 }
 
-const SaprusMessage = @import("message.zig").Message;
+pub const SaprusMessage = @import("./saprus_message.zig").SaprusMessage;
 
 const std = @import("std");
 const Random = std.Random;

src/saprus_message.zig

@@ -1,9 +1,9 @@
 const base64Enc = std.base64.Base64Encoder.init(std.base64.standard_alphabet_chars, '=');
 const base64Dec = std.base64.Base64Decoder.init(std.base64.standard_alphabet_chars, '=');
 
-/// Type tag for Message union.
+/// Type tag for SaprusMessage union.
 /// This is the first value in the actual packet sent over the network.
-pub const PacketType = enum(u16) {
+pub const SaprusPacketType = enum(u16) {
     relay = 0x003C,
     file_transfer = 0x8888,
     connection = 0x00E9,
@@ -12,7 +12,7 @@ pub const PacketType = enum(u16) {
 
 /// Reserved option values.
 /// Currently unused.
-pub const ConnectionOptions = packed struct(u8) {
+pub const SaprusConnectionOptions = packed struct(u8) {
     opt1: bool = false,
     opt2: bool = false,
     opt3: bool = false,
@@ -23,13 +23,13 @@ pub const ConnectionOptions = packed struct(u8) {
     opt8: bool = false,
 };
 
-pub const Error = error{
+pub const SaprusError = error{
     NotImplementedSaprusType,
     UnknownSaprusType,
 };
 
 /// All Saprus messages
-pub const Message = union(PacketType) {
+pub const SaprusMessage = union(SaprusPacketType) {
     pub const Relay = struct {
         pub const Header = packed struct {
             dest: @Vector(4, u8),
@@ -44,7 +44,7 @@ pub const Message = union(PacketType) {
             seq_num: u32 = 0,
             msg_id: u32 = 0,
             reserved: u8 = 0,
-            options: ConnectionOptions = .{},
+            options: SaprusConnectionOptions = .{},
         };
         header: Header,
         payload: []const u8,
@@ -53,8 +53,8 @@ pub const Message = union(PacketType) {
     file_transfer: void, // unimplemented
     connection: Connection,
 
-    /// Should be called for any Message that was declared using a function that you pass an allocator to.
+    /// Should be called for any SaprusMessage that was declared using a function that you pass an allocator to.
-    pub fn deinit(self: Message, allocator: Allocator) void {
+    pub fn deinit(self: SaprusMessage, allocator: Allocator) void {
         switch (self) {
             .relay => |r| allocator.free(r.payload),
             .connection => |c| allocator.free(c.payload),
@@ -96,7 +96,7 @@ pub const Message = union(PacketType) {
     }
 
     /// Caller is responsible for freeing the returned bytes.
-    pub fn toBytes(self: Message, allocator: Allocator) ![]u8 {
+    pub fn toBytes(self: SaprusMessage, allocator: Allocator) ![]u8 {
         // Create a growable list of bytes to store the output in.
         var buf = std.ArrayList(u8).init(allocator);
         errdefer buf.deinit();
@@ -108,7 +108,7 @@ pub const Message = union(PacketType) {
         switch (self) {
             .relay => |r| try toBytesAux(r.header, r.payload, &buf, allocator),
             .connection => |c| try toBytesAux(c.header, c.payload, &buf, allocator),
-            .file_transfer => return Error.NotImplementedSaprusType,
+            .file_transfer => return SaprusError.NotImplementedSaprusType,
         }
 
         // Collect the growable list as a slice and return it.
@@ -116,12 +116,12 @@ pub const Message = union(PacketType) {
     }
 
     fn fromBytesAux(
-        comptime packet: PacketType,
+        comptime packet: SaprusPacketType,
         len: u16,
         r: std.io.FixedBufferStream([]const u8).Reader,
         allocator: Allocator,
-    ) !Message {
+    ) !SaprusMessage {
-        const Header = @field(@FieldType(Message, @tagName(packet)), "Header");
+        const Header = @field(@FieldType(SaprusMessage, @tagName(packet)), "Header");
 
         // Read the header for the current message type.
         var header_bytes: [@sizeOf(Header)]u8 = undefined;
@@ -138,20 +138,20 @@ pub const Message = union(PacketType) {
         const payload = try allocator.alloc(u8, try base64Dec.calcSizeForSlice(payload_buf));
         try base64Dec.decode(payload, payload_buf);
 
-        // Return the type of Message specified by the `packet` argument.
+        // Return the type of SaprusMessage specified by the `packet` argument.
-        return @unionInit(Message, @tagName(packet), .{
+        return @unionInit(SaprusMessage, @tagName(packet), .{
             .header = header,
             .payload = payload,
         });
     }
 
     /// Caller is responsible for calling .deinit on the returned value.
-    pub fn fromBytes(bytes: []const u8, allocator: Allocator) !Message {
+    pub fn fromBytes(bytes: []const u8, allocator: Allocator) !SaprusMessage {
         var s = std.io.fixedBufferStream(bytes);
         const r = s.reader();
 
         // Read packet type
-        const packet_type = @as(PacketType, @enumFromInt(try r.readInt(u16, .big)));
+        const packet_type = @as(SaprusPacketType, @enumFromInt(try r.readInt(u16, .big)));
 
         // Read the length of the header + base64 encoded payload.
         const len = try r.readInt(u16, .big);
@@ -159,8 +159,8 @@ pub const Message = union(PacketType) {
         switch (packet_type) {
             .relay => return fromBytesAux(.relay, len, r, allocator),
             .connection => return fromBytesAux(.connection, len, r, allocator),
-            .file_transfer => return Error.NotImplementedSaprusType,
+            .file_transfer => return SaprusError.NotImplementedSaprusType,
-            else => return Error.UnknownSaprusType,
+            else => return SaprusError.UnknownSaprusType,
         }
     }
 };
@@ -173,7 +173,7 @@ const nativeToBig = std.mem.nativeToBig;
 
 test "Round trip Relay toBytes and fromBytes" {
     const gpa = std.testing.allocator;
-    const msg = Message{
+    const msg = SaprusMessage{
         .relay = .{
             .header = .{ .dest = .{ 255, 255, 255, 255 } },
             .payload = "Hello darkness my old friend",
@@ -183,7 +183,7 @@ test "Round trip Relay toBytes and fromBytes" {
     const to_bytes = try msg.toBytes(gpa);
     defer gpa.free(to_bytes);
 
-    const from_bytes = try Message.fromBytes(to_bytes, gpa);
+    const from_bytes = try SaprusMessage.fromBytes(to_bytes, gpa);
     defer from_bytes.deinit(gpa);
 
     try std.testing.expectEqualDeep(msg, from_bytes);
@@ -191,7 +191,7 @@ test "Round trip Relay toBytes and fromBytes" {
 
 test "Round trip Connection toBytes and fromBytes" {
     const gpa = std.testing.allocator;
-    const msg = Message{
+    const msg = SaprusMessage{
         .connection = .{
             .header = .{
                 .src_port = 0,
@@ -204,7 +204,7 @@ test "Round trip Connection toBytes and fromBytes" {
     const to_bytes = try msg.toBytes(gpa);
     defer gpa.free(to_bytes);
 
-    const from_bytes = try Message.fromBytes(to_bytes, gpa);
+    const from_bytes = try SaprusMessage.fromBytes(to_bytes, gpa);
     defer from_bytes.deinit(gpa);
 
     try std.testing.expectEqualDeep(msg, from_bytes);