From c3c45287396569a96107c9b1413ac181f7197a6e Mon Sep 17 00:00:00 2001 From: Martin Ashby Date: Sat, 23 Sep 2023 07:32:30 +0100 Subject: Add password_message --- src/authentication_cleartext_password.zig | 47 +++++++++++++++++++++++++++++++ src/authentication_ok.zig | 5 ++-- src/main.zig | 5 ++++ src/password_message.zig | 44 +++++++++++++++++++++++++++++ 4 files changed, 99 insertions(+), 2 deletions(-) create mode 100644 src/authentication_cleartext_password.zig create mode 100644 src/password_message.zig diff --git a/src/authentication_cleartext_password.zig b/src/authentication_cleartext_password.zig new file mode 100644 index 0000000..e72f28d --- /dev/null +++ b/src/authentication_cleartext_password.zig @@ -0,0 +1,47 @@ +const std = @import("std"); +const ProtocolError = @import("main.zig").ProtocolError; +const AuthType = @import("main.zig").AuthType; +const enum_from_int = @import("main.zig").enum_from_int; +const ClientError = @import("main.zig").ClientError; +const AuthenticationCleartextPassword = @This(); +const ByteArrayList = std.ArrayList(u8); + +pub const Tag: u8 = 'R'; +pub const Type: AuthType = AuthType.AuthTypeCleartextPassword; + +pub fn read(_: std.mem.Allocator, b: []const u8) !AuthenticationCleartextPassword { + if (b.len != 4) return ProtocolError.InvalidMessageLength; + + const auth_type = enum_from_int(AuthType, std.mem.readIntBig(u32, b[0..4])) orelse return ClientError.UnsupportedAuthType; + if (auth_type != Type) return ProtocolError.InvalidAuthType; + return .{}; +} + +pub fn write(_: AuthenticationCleartextPassword, _: std.mem.Allocator, stream_writer: anytype) !void { + try stream_writer.writeByte(Tag); + try stream_writer.writeIntBig(u32, 8); + try stream_writer.writeIntBig(u32, @intFromEnum(Type)); +} + +pub fn deinit(_: *AuthenticationCleartextPassword, _: std.mem.Allocator) void {} + +test "round trip" { + const allocator = std.testing.allocator; + var sm = AuthenticationCleartextPassword{}; + defer sm.deinit(allocator); + + var bal = ByteArrayList.init(allocator); + defer bal.deinit(); + try sm.write(allocator, bal.writer()); + + var fbs = std.io.fixedBufferStream(bal.items); + var reader = fbs.reader(); + const tag = try reader.readByte(); + try std.testing.expectEqual(Tag, tag); + const len = try reader.readIntBig(u32); + const buf = try allocator.alloc(u8, len - 4); + defer allocator.free(buf); + try reader.readNoEof(buf); + var sm2 = try AuthenticationCleartextPassword.read(allocator, buf); + defer sm2.deinit(allocator); +} diff --git a/src/authentication_ok.zig b/src/authentication_ok.zig index 3c31375..0f0702b 100644 --- a/src/authentication_ok.zig +++ b/src/authentication_ok.zig @@ -7,19 +7,20 @@ const AuthenticationOk = @This(); const ByteArrayList = std.ArrayList(u8); pub const Tag: u8 = 'R'; +pub const Type: AuthType = AuthType.AuthTypeCleartextPassword; pub fn read(_: std.mem.Allocator, b: []const u8) !AuthenticationOk { if (b.len != 4) return ProtocolError.InvalidMessageLength; const auth_type = enum_from_int(AuthType, std.mem.readIntBig(u32, b[0..4])) orelse return ClientError.UnsupportedAuthType; - if (auth_type != AuthType.AuthTypeOk) return ProtocolError.InvalidAuthType; + if (auth_type != Type) return ProtocolError.InvalidAuthType; return .{}; } pub fn write(_: AuthenticationOk, _: std.mem.Allocator, stream_writer: anytype) !void { try stream_writer.writeByte(Tag); try stream_writer.writeIntBig(u32, 8); - try stream_writer.writeIntBig(u32, @intFromEnum(AuthType.AuthTypeOk)); + try stream_writer.writeIntBig(u32, @intFromEnum(Type)); } pub fn deinit(_: *AuthenticationOk, _: std.mem.Allocator) void {} diff --git a/src/main.zig b/src/main.zig index 4bed468..24e86c4 100644 --- a/src/main.zig +++ b/src/main.zig @@ -2,6 +2,8 @@ const std = @import("std"); const testing = std.testing; const StartupMessage = @import("startup_message.zig"); const AuthenticationOk = @import("authentication_ok.zig"); +const AuthenticationCleartextPassword = @import("authentication_cleartext_password.zig"); +const PasswordMessage = @import("password_message.zig"); pub const ProtocolError = error{ InvalidProtocolVersion, @@ -16,6 +18,7 @@ pub const ClientError = error{ pub const AuthType = enum(u32) { AuthTypeOk = 0, + AuthTypeCleartextPassword = 3, }; // Fallible version of enumFromInt @@ -36,4 +39,6 @@ pub fn enum_from_int(comptime e: type, i: anytype) ?e { test { _ = StartupMessage; _ = AuthenticationOk; + _ = AuthenticationCleartextPassword; + _ = PasswordMessage; } diff --git a/src/password_message.zig b/src/password_message.zig new file mode 100644 index 0000000..33214bf --- /dev/null +++ b/src/password_message.zig @@ -0,0 +1,44 @@ +const std = @import("std"); +const ByteArrayList = std.ArrayList(u8); +const PasswordMessage = @This(); + +pub const Tag: u8 = 'p'; +password: []const u8, +password_owned: bool = false, + + +pub fn read(allocator: std.mem.Allocator, b: []const u8) !PasswordMessage { + return .{ .password = try allocator.dupe(u8, b), .password_owned = true }; +} +pub fn write(self: PasswordMessage, _: std.mem.Allocator, stream_writer: anytype) !void { + try stream_writer.writeByte(Tag); + try stream_writer.writeIntBig(u32, 5 + @as(u32, @intCast(self.password.len))); + try stream_writer.writeAll(self.password); + try stream_writer.writeByte(0); +} +pub fn deinit(self: *PasswordMessage, allocator: std.mem.Allocator) void { + if (self.password_owned) allocator.free(self.password); +} + +test "round trip" { + const allocator = std.testing.allocator; + var sm = PasswordMessage{ + .password = "foobar", + }; + defer sm.deinit(allocator); + + var bal = ByteArrayList.init(allocator); + defer bal.deinit(); + try sm.write(allocator, bal.writer()); + + var fbs = std.io.fixedBufferStream(bal.items); + var reader = fbs.reader(); + const tag = try reader.readByte(); + try std.testing.expectEqual(Tag, tag); + const len = try reader.readIntBig(u32); + const buf = try allocator.alloc(u8, len - 4); + defer allocator.free(buf); + try reader.readNoEof(buf); + var sm2 = try PasswordMessage.read(allocator, buf); + defer sm2.deinit(allocator); +} -- cgit v1.2.3-ZIG