src/Client.zig

@@ -1,5 +1,5 @@
-const base64Enc = std.base64.Base64Encoder.init(std.base64.standard_alphabet_chars, '=');
+const base64_enc = std.base64.Base64Encoder.init(std.base64.standard_alphabet_chars, '=');
-const base64Dec = std.base64.Base64Decoder.init(std.base64.standard_alphabet_chars, '=');
+const base64_dec = std.base64.Base64Decoder.init(std.base64.standard_alphabet_chars, '=');
 
 writer: *std.Io.Writer,
 
@@ -17,61 +17,21 @@ pub fn deinit(self: *Self) void {
     self.writer.flush() catch {};
 }
 
-/// Used for relay messages and connection handshake.
+pub fn sendRelay(self: *Self, payload: []const u8, dest: [4]u8) !void {
-/// Assumes Client .init has been called.
+    const payload_len = base64_enc.calcSize(payload.len);
-fn broadcastInitialInterestMessage(self: *Self, msg_bytes: []u8) !void {
-    const writer = self.writer;
 
     // Ensure the writer is in a valid state
-    std.debug.assert(writer.buffer.len - writer.end >= msg_bytes.len);
+    std.debug.assert(self.writer.buffer.len - self.writer.end >= payload_len);
-
-    // Saprus
-    const msg_target_bytes = try writer.writableSlice(msg_bytes.len);
-    @memcpy(msg_target_bytes, msg_bytes);
-    var msg_target: *align(1) SaprusMessage = try .bytesAsValue(msg_target_bytes);
-    try msg_target.networkFromNativeEndian();
-    try writer.flush();
-}
-
-fn broadcastSaprusMessage(msg_bytes: []u8, udp_port: u16) !void {
-    const msg: *align(1) SaprusMessage = try .bytesAsValue(msg_bytes);
-    try msg.networkFromNativeEndian();
-    defer msg.nativeFromNetworkEndian() catch unreachable;
-
-    var sock = try network.Socket.create(.ipv4, .udp);
-    defer sock.close();
-
-    try sock.setBroadcast(true);
-
-    // Bind to 0.0.0.0:0
-    const bind_addr = network.EndPoint{
-        .address = network.Address{ .ipv4 = network.Address.IPv4.any },
-        .port = 0,
-    };
-
-    const dest_addr = network.EndPoint{
-        .address = network.Address{ .ipv4 = network.Address.IPv4.broadcast },
-        .port = udp_port,
-    };
-
-    try sock.bind(bind_addr);
-
-    _ = try sock.sendTo(dest_addr, msg_bytes);
-}
-
-pub fn sendRelay(self: *Self, payload: []const u8, dest: [4]u8) !void {
-    var buf: [max_message_size]u8 align(@alignOf(SaprusMessage)) = undefined;
-    const msg_bytes = buf[0..try SaprusMessage.calcSize(
-        .relay,
-        base64Enc.calcSize(payload.len),
-    )];
-    const msg: *align(1) SaprusMessage = .init(.relay, msg_bytes);
 
+    const headers_buf = try self.writer.writableSlice(@sizeOf(SaprusMessage) + @sizeOf(SaprusMessage.Relay));
+    const msg: *align(1) SaprusMessage = .init(.relay, headers_buf);
+    msg.length = @intCast(payload_len);
     const relay = (try msg.getSaprusTypePayload()).relay;
     relay.dest = dest;
-    _ = base64Enc.encode(relay.getPayload(), payload);
 
-    try self.broadcastInitialInterestMessage(msg_bytes);
+    try base64_enc.encodeWriter(self.writer, payload);
+    try msg.networkFromNativeEndian();
+    try self.writer.flush();
 }
 
 // pub fn sendInitialConnection(
@@ -83,14 +43,14 @@ pub fn sendRelay(self: *Self, payload: []const u8, dest: [4]u8) !void {
 //     const dest_port = self.randomPort();
 //     const msg_bytes = output_bytes[0..try SaprusMessage.calcSize(
 //         .connection,
-//         base64Enc.calcSize(payload.len),
+//         base64_enc.calcSize(payload.len),
 //     )];
 //     const msg: *align(1) SaprusMessage = .init(.connection, msg_bytes);
 
 //     const connection = (try msg.getSaprusTypePayload()).connection;
 //     connection.src_port = initial_port;
 //     connection.dest_port = dest_port;
-//     _ = base64Enc.encode(connection.getPayload(), payload);
+//     _ = base64_enc.encode(connection.getPayload(), payload);
 
 //     try broadcastSaprusMessage(msg_bytes, 8888);
 

src/message.zig

@@ -32,7 +32,7 @@ pub const MessageParseError = MessageTypeError || error{
 // &payload could be a void value that is treated as a pointer to a [*]u8
 /// All Saprus messages
 pub const Message = packed struct {
-    const Relay = packed struct {
+    pub const Relay = packed struct {
         dest: @Vector(4, u8),
         payload: void,
 
@@ -41,7 +41,7 @@ pub const Message = packed struct {
             return @as([*]u8, @ptrCast(&self.payload))[0 .. len.* - @bitSizeOf(Relay) / 8];
         }
     };
-    const Connection = packed struct {
+    pub const Connection = packed struct {
         src_port: u16, // random number > 1024
         dest_port: u16, // random number > 1024
         seq_num: u32 = 0,