zambyte/zaprus
1
0
Fork 0
mirror of https://git.robbyzambito.me/zaprus synced 2026-02-04 08:24:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Mostly done with parsing and serializing messages

Browse Source
This commit is contained in:
Robby Zambito
2026-01-17 16:05:31 -05:00
parent 0d9c0c33fa
commit 1a817df18d
2 changed files with 137 additions and 322 deletions
Download Patch File Download Diff File Expand all files Collapse all files

458
src/message.zig
View File

@@ -2,24 +2,10 @@
/// This is the first value in the actual packet sent over the network.
pub const PacketType = enum(u16) {
relay = 0x003C,
file_transfer = 0x8888,
connection = 0x00E9,
_,
};
/// Reserved option values.
/// Currently unused.
pub const ConnectionOptions = packed struct(u8) {
opt1: bool = false,
opt2: bool = false,
opt3: bool = false,
opt4: bool = false,
opt5: bool = false,
opt6: bool = false,
opt7: bool = false,
opt8: bool = false,
};
pub const MessageTypeError = error{
NotImplementedSaprusType,
UnknownSaprusType,
@@ -28,13 +14,91 @@ pub const MessageParseError = MessageTypeError || error{
InvalidMessage,
};
pub const RelayMessage = struct {
const message = @This();
pub const Message = union(PacketType) {
relay: Message.Relay,
connection: Message.Connection,
pub const Relay = message.Relay;
pub const Connection = message.Connection;
};
pub const relay_dest_len = 4;
pub fn parse(bytes: []const u8) MessageParseError!Message {
var in: Reader = .fixed(bytes);
const @"type" = in.takeEnum(PacketType, .big) catch |err| switch (err) {
error.InvalidEnumTag => return error.UnknownSaprusType,
else => return error.InvalidMessage,
};
const checksum = in.takeArray(2) catch return error.InvalidMessage;
switch (@"type") {
.relay => {
const dest: Relay.Dest = .fromBytes(
in.takeArray(relay_dest_len) catch return error.InvalidMessage,
);
const payload = in.buffered();
return .{
.relay = .{
.dest = dest,
.checksum = checksum.*,
.payload = payload,
},
};
},
.connection => {
const src = in.takeInt(u16, .big) catch return error.InvalidMessage;
const dest = in.takeInt(u16, .big) catch return error.InvalidMessage;
const seq = in.takeInt(u32, .big) catch return error.InvalidMessage;
const id = in.takeInt(u32, .big) catch return error.InvalidMessage;
const reserved = in.takeByte() catch return error.InvalidMessage;
const options = in.takeStruct(Connection.Options, .big) catch return error.InvalidMessage;
const payload = in.buffered();
return .{
.connection = .{
.src = src,
.dest = dest,
.seq = seq,
.id = id,
.reserved = reserved,
.options = options,
.payload = payload,
},
};
},
else => return error.NotImplementedSaprusType,
}
}
test parse {
_ = try parse(&[_]u8{ 0x00, 0x3c, 0x00, 0x17, 0xac, 0x12, 0x01, 0x1e, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x20, 0x6c, 0x6f, 0x67, 0x67, 0x65, 0x64 });
{
const expected: Message = .{
.connection = .{
.src = 12416,
.dest = 61680,
.seq = 0,
.id = 0,
.reserved = 0,
.options = @bitCast(@as(u8, 100)),
.payload = &[_]u8{ 0x69, 0x61, 0x6d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74 },
},
};
const actual = try parse(&[_]u8{ 0x00, 0xe9, 0x00, 0x18, 0x30, 0x80, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x69, 0x61, 0x6d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74 });
try std.testing.expectEqualDeep(expected, actual);
}
}
const Relay = struct {
dest: Dest,
checksum: [2]u8 = undefined,
payload: []const u8,
pub const @"type": PacketType = .relay;
pub const Dest = struct {
bytes: [4]u8,
bytes: [relay_dest_len]u8,
/// Asserts bytes is less than or equal to 4 bytes
pub fn fromBytes(bytes: []const u8) Dest {
@@ -45,27 +109,23 @@ pub const RelayMessage = struct {
}
};
pub fn init(dest: Dest, payload: []const u8) RelayMessage {
pub fn init(dest: Dest, payload: []const u8) Relay {
return .{ .dest = dest, .payload = payload };
}
/// Asserts that buf is large enough to fit the relay message.
pub fn toBytes(self: RelayMessage, buf: []u8) []u8 {
pub fn toBytes(self: Relay, buf: []u8) []u8 {
var out: Writer = .fixed(buf);
out.writeInt(u16, @intFromEnum(RelayMessage.type), .big) catch unreachable;
out.writeInt(u16, @intCast(self.payload.len + self.dest.bytes.len), .big) catch unreachable;
out.writeInt(u16, @intFromEnum(PacketType.relay), .big) catch unreachable;
out.writeInt(u16, undefined, .big) catch unreachable; // Length field, but unread. Will switch to checksum
out.writeAll(&self.dest.bytes) catch unreachable;
out.writeAll(self.payload) catch unreachable;
return out.buffered();
}
pub fn fromBytes(buf: []const u8) RelayMessage {
var in: Reader = .fixed(buf);
}
test toBytes {
var buf: [1024]u8 = undefined;
const relay: RelayMessage = .init(
const relay: Relay = .init(
.fromBytes(&.{ 172, 18, 1, 30 }),
// zig fmt: off
&[_]u8{
@@ -81,312 +141,68 @@ pub const RelayMessage = struct {
0x6e, 0x74, 0x20, 0x6c, 0x6f, 0x67, 0x67, 0x65, 0x64
};
// zig fmt: on
try std.testing.expectEqualSlices(u8, &expected, relay.toBytes(&buf));
try expectEqualMessageBuffers(&expected, relay.toBytes(&buf));
}
};
// pub const ConnectionMessage = struct {
// length: u16,
// src_port: u16,
// dest_port: u16,
// seq_num: u32 = 0,
// msg_id: u32 = 0,
// // _reserved: u8 = 0,
// options: ConnectionOptions = .{},
// payload: []u8,
const Connection = struct {
src: u16,
dest: u16,
seq: u32,
id: u32,
reserved: u8 = undefined,
options: Options = undefined,
payload: []const u8,
// pub const type: PacketType = .connection;
/// Reserved option values.
/// Currently unused.
pub const Options = packed struct(u8) {
opt1: bool = false,
opt2: bool = false,
opt3: bool = false,
opt4: bool = false,
opt5: bool = false,
opt6: bool = false,
opt7: bool = false,
opt8: bool = false,
};
// /// Asserts that buf is large enough to fit the connection message.
// fn toBytes(self: ConnectionMessage, buf: []u8) []u8 {
// var out: Writer = .fixed(buf);
// out.writeInt(u16, ConnectionMessage.type, .big) catch unreachable;
// return w.buffered();
// }
// };
/// Asserts that buf is large enough to fit the connection message.
pub fn toBytes(self: Connection, buf: []u8) []u8 {
var out: Writer = .fixed(buf);
out.writeInt(u16, @intFromEnum(PacketType.connection), .big) catch unreachable;
out.writeInt(u16, undefined, .big) catch unreachable; // Saprus length field, unread.
out.writeInt(u16, self.src, .big) catch unreachable;
out.writeInt(u16, self.dest, .big) catch unreachable;
out.writeInt(u32, self.seq, .big) catch unreachable;
out.writeInt(u32, self.id, .big) catch unreachable;
out.writeByte(self.reserved) catch unreachable;
out.writeStruct(self.options, .big) catch unreachable;
out.writeAll(self.payload) catch unreachable;
return out.buffered();
}
};
// // ZERO COPY STUFF
// // &payload could be a void value that is treated as a pointer to a [*]u8
// /// All Saprus messages
// pub const Message = packed struct {
// pub const Relay = packed struct {
// dest: @Vector(4, u8),
// payload: void,
test "Round trip" {
{
const expected = [_]u8{ 0x0, 0xe9, 0x0, 0x15, 0x30, 0x80, 0xf0, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x64, 0x36, 0x3a, 0x3a, 0x64, 0x61, 0x74, 0x61 };
const msg = (try parse(&expected)).connection;
var res_buf: [expected.len + 1]u8 = undefined; // + 1 to test subslice result.
const res = msg.toBytes(&res_buf);
try expectEqualMessageBuffers(&expected, res);
}
}
// pub fn getPayload(self: *align(1) Relay) []u8 {
// const len: *u16 = @ptrFromInt(@intFromPtr(self) - @sizeOf(u16));
// return @as([*]u8, @ptrCast(&self.payload))[0 .. len.* - @bitSizeOf(Relay) / 8];
// }
// };
// pub const Connection = packed struct {
// src_port: u16, // random number > 1024
// dest_port: u16, // random number > 1024
// seq_num: u32 = 0,
// msg_id: u32 = 0,
// reserved: u8 = 0,
// options: ConnectionOptions = .{},
// payload: void,
// pub fn getPayload(self: *align(1) Connection) []u8 {
// const len: *u16 = @ptrFromInt(@intFromPtr(self) - @sizeOf(u16));
// return @as([*]u8, @ptrCast(&self.payload))[0 .. len.* - @bitSizeOf(Connection) / 8];
// }
// fn nativeFromNetworkEndian(self: *align(1) Connection) void {
// self.src_port = bigToNative(@TypeOf(self.src_port), self.src_port);
// self.dest_port = bigToNative(@TypeOf(self.dest_port), self.dest_port);
// self.seq_num = bigToNative(@TypeOf(self.seq_num), self.seq_num);
// self.msg_id = bigToNative(@TypeOf(self.msg_id), self.msg_id);
// }
// fn networkFromNativeEndian(self: *align(1) Connection) void {
// self.src_port = nativeToBig(@TypeOf(self.src_port), self.src_port);
// self.dest_port = nativeToBig(@TypeOf(self.dest_port), self.dest_port);
// self.seq_num = nativeToBig(@TypeOf(self.seq_num), self.seq_num);
// self.msg_id = nativeToBig(@TypeOf(self.msg_id), self.msg_id);
// }
// };
// const Self = @This();
// const SelfBytes = []align(1) u8;
// type: PacketType,
// length: u16,
// bytes: void = {},
// /// Takes a byte slice, and returns a Message struct backed by the slice.
// /// This properly initializes the top level headers within the slice.
// /// This is used for creating new messages. For reading messages from the network,
// /// see: networkBytesAsValue.
// pub fn init(@"type": PacketType, bytes: []u8) *align(1) Self {
// std.debug.assert(bytes.len >= @sizeOf(Self));
// const res: *align(1) Self = @ptrCast(bytes.ptr);
// res.type = @"type";
// res.length = @intCast(bytes.len - @sizeOf(Self));
// return res;
// }
// /// Compute the number of bytes required to store a given payload size for a given message type.
// pub fn calcSize(comptime @"type": PacketType, payload_len: usize) MessageTypeError!u16 {
// const header_size = @bitSizeOf(switch (@"type") {
// .relay => Relay,
// .connection => Connection,
// .file_transfer => return MessageTypeError.NotImplementedSaprusType,
// else => return MessageTypeError.UnknownSaprusType,
// }) / 8;
// return @intCast(payload_len + @sizeOf(Self) + header_size);
// }
// fn getRelay(self: *align(1) Self) *align(1) Relay {
// return std.mem.bytesAsValue(Relay, &self.bytes);
// }
// fn getConnection(self: *align(1) Self) *align(1) Connection {
// return std.mem.bytesAsValue(Connection, &self.bytes);
// }
// /// Access the message Saprus payload.
// pub fn getSaprusTypePayload(self: *align(1) Self) MessageTypeError!(union(PacketType) {
// relay: *align(1) Relay,
// file_transfer: void,
// connection: *align(1) Connection,
// }) {
// return switch (self.type) {
// .relay => .{ .relay = self.getRelay() },
// .connection => .{ .connection = self.getConnection() },
// .file_transfer => MessageTypeError.NotImplementedSaprusType,
// else => MessageTypeError.UnknownSaprusType,
// };
// }
// /// Convert the message to native endianness from network endianness in-place.
// pub fn nativeFromNetworkEndian(self: *align(1) Self) MessageTypeError!void {
// self.type = @enumFromInt(bigToNative(
// @typeInfo(@TypeOf(self.type)).@"enum".tag_type,
// @intFromEnum(self.type),
// ));
// self.length = bigToNative(@TypeOf(self.length), self.length);
// errdefer {
// // If the payload specific headers fail, revert the top level header values
// self.type = @enumFromInt(nativeToBig(
// @typeInfo(@TypeOf(self.type)).@"enum".tag_type,
// @intFromEnum(self.type),
// ));
// self.length = nativeToBig(@TypeOf(self.length), self.length);
// }
// switch (try self.getSaprusTypePayload()) {
// .relay => {},
// .connection => |*con| con.*.nativeFromNetworkEndian(),
// // We know other values are unreachable,
// // because they would have returned an error from the switch condition.
// else => unreachable,
// }
// }
// /// Convert the message to network endianness from native endianness in-place.
// pub fn networkFromNativeEndian(self: *align(1) Self) MessageTypeError!void {
// try switch (try self.getSaprusTypePayload()) {
// .relay => {},
// .connection => |*con| con.*.networkFromNativeEndian(),
// .file_transfer => MessageTypeError.NotImplementedSaprusType,
// else => MessageTypeError.UnknownSaprusType,
// };
// self.type = @enumFromInt(nativeToBig(
// @typeInfo(@TypeOf(self.type)).@"enum".tag_type,
// @intFromEnum(self.type),
// ));
// self.length = nativeToBig(@TypeOf(self.length), self.length);
// }
// /// Convert network endian bytes to a native endian value in-place.
// pub fn networkBytesAsValue(bytes: SelfBytes) MessageParseError!*align(1) Self {
// const res = std.mem.bytesAsValue(Self, bytes);
// try res.nativeFromNetworkEndian();
// return .bytesAsValue(bytes);
// }
// /// Create a structured view of the bytes without initializing the length or type,
// /// and without converting the endianness.
// pub fn bytesAsValue(bytes: SelfBytes) MessageParseError!*align(1) Self {
// const res = std.mem.bytesAsValue(Self, bytes);
// return switch (res.type) {
// .relay, .connection => if (bytes.len == res.length + @sizeOf(Self))
// res
// else
// MessageParseError.InvalidMessage,
// .file_transfer => MessageParseError.NotImplementedSaprusType,
// else => MessageParseError.UnknownSaprusType,
// };
// }
// /// Deprecated.
// /// If I need the bytes, I should just pass around the slice that is backing this to begin with.
// pub fn asBytes(self: *align(1) Self) SelfBytes {
// const size = @sizeOf(Self) + self.length;
// return @as([*]align(1) u8, @ptrCast(self))[0..size];
// }
// };
// test "testing variable length zero copy struct" {
// {
// // Relay test
// const payload = "Hello darkness my old friend";
// var msg_bytes: [try Message.calcSize(.relay, payload.len)]u8 align(@alignOf(Message)) = undefined;
// // Create a view of the byte slice as a Message
// const msg: *align(1) Message = .init(.relay, &msg_bytes);
// {
// // Set the message values
// {
// // These are both set by the init call.
// // msg.type = .relay;
// // msg.length = payload_len;
// }
// const relay = (try msg.getSaprusTypePayload()).relay;
// relay.dest = .{ 1, 2, 3, 4 };
// @memcpy(relay.getPayload(), payload);
// }
// {
// // Print the message as hex using the network byte order
// try msg.networkFromNativeEndian();
// // We know the error from nativeFromNetworkEndian is unreachable because
// // it would have returned an error from networkFromNativeEndian.
// defer msg.nativeFromNetworkEndian() catch unreachable;
// std.debug.print("relay network bytes: {x}\n", .{msg_bytes});
// std.debug.print("bytes len: {d}\n", .{msg_bytes.len});
// }
// if (false) {
// // Illegal behavior
// std.debug.print("{any}\n", .{(try msg.getSaprusTypePayload()).connection});
// }
// try std.testing.expectEqualDeep(msg, try Message.bytesAsValue(msg.asBytes()));
// }
// {
// // Connection test
// const payload = "Hello darkness my old friend";
// var msg_bytes: [try Message.calcSize(.connection, payload.len)]u8 align(@alignOf(Message)) = undefined;
// // Create a view of the byte slice as a Message
// const msg: *align(1) Message = .init(.connection, &msg_bytes);
// {
// // Initializing connection header values
// const connection = (try msg.getSaprusTypePayload()).connection;
// connection.src_port = 1;
// connection.dest_port = 2;
// connection.seq_num = 3;
// connection.msg_id = 4;
// connection.reserved = 5;
// connection.options = @bitCast(@as(u8, 6));
// @memcpy(connection.getPayload(), payload);
// }
// {
// // Print the message as hex using the network byte order
// try msg.networkFromNativeEndian();
// // We know the error from nativeFromNetworkEndian is unreachable because
// // it would have returned an error from networkFromNativeEndian.
// defer msg.nativeFromNetworkEndian() catch unreachable;
// std.debug.print("connection network bytes: {x}\n", .{msg_bytes});
// std.debug.print("bytes len: {d}\n", .{msg_bytes.len});
// }
// }
// }
// Skip checking the length / checksum, because that is undefined.
fn expectEqualMessageBuffers(expected: []const u8, actual: []const u8) !void {
try std.testing.expectEqualSlices(u8, expected[0..2], actual[0..2]);
try std.testing.expectEqualSlices(u8, expected[4..], actual[4..]);
}
const std = @import("std");
const Allocator = std.mem.Allocator;
const Writer = std.Io.Writer;
// const asBytes = std.mem.asBytes;
// const nativeToBig = std.mem.nativeToBig;
// const bigToNative = std.mem.bigToNative;
// test "Round trip Relay toBytes and fromBytes" {
// if (true) return error.SkipZigTest;
// const gpa = std.testing.allocator;
// const msg = Message{
// .relay = .{
// .header = .{ .dest = .{ 255, 255, 255, 255 } },
// .payload = "Hello darkness my old friend",
// },
// };
// const to_bytes = try msg.toBytes(gpa);
// defer gpa.free(to_bytes);
// const from_bytes = try Message.fromBytes(to_bytes, gpa);
// defer from_bytes.deinit(gpa);
// try std.testing.expectEqualDeep(msg, from_bytes);
// }
// test "Round trip Connection toBytes and fromBytes" {
// if (false) {
// const gpa = std.testing.allocator;
// const msg = Message{
// .connection = .{
// .header = .{
// .src_port = 0,
// .dest_port = 0,
// },
// .payload = "Hello darkness my old friend",
// },
// };
// const to_bytes = try msg.toBytes(gpa);
// defer gpa.free(to_bytes);
// const from_bytes = try Message.fromBytes(to_bytes, gpa);
// defer from_bytes.deinit(gpa);
// try std.testing.expectEqualDeep(msg, from_bytes);
// }
// return error.SkipZigTest;
// }
const Reader = std.Io.Reader;
test {
std.testing.refAllDeclsRecursive(@This());