From 2ea5aabbdec44e4e7f0bb9aa00aed33f947a18bf Mon Sep 17 00:00:00 2001 From: "Jeffrey C. Ollie" Date: Sat, 6 Sep 2025 15:55:20 -0500 Subject: [PATCH] major interface update --- src/Logger.zig | 106 ++++++++++++++++++++ src/Message.zig | 215 ++++++++++++++++++++++++++++++++++++++++ src/cmsghdr.zig | 26 ++--- src/constants.zig | 33 ++++++ src/root.zig | 248 ++-------------------------------------------- 5 files changed, 374 insertions(+), 254 deletions(-) create mode 100644 src/Logger.zig create mode 100644 src/Message.zig create mode 100644 src/constants.zig diff --git a/src/Logger.zig b/src/Logger.zig new file mode 100644 index 0000000..18c2df5 --- /dev/null +++ b/src/Logger.zig @@ -0,0 +1,106 @@ +const Logger = @This(); + +const std = @import("std"); +const Allocator = std.mem.Allocator; +const assert = std.debug.assert; + +const Message = @import("Message.zig"); +const constants = @import("constants.zig"); +const Facility = constants.Facility; +const Priority = constants.Priority; + +const JOURNAL_SOCKET: [:0]const u8 = "/run/systemd/journal/socket"; + +identifier: ?[]const u8, +facility: ?Facility, +socket: std.os.linux.socket_t, +path: std.os.linux.sockaddr.un = undefined, + +pub fn init(identifier: ?[]const u8, facility: ?Facility) error{Failed}!Logger { + var logger: Logger = .{ + .identifier = identifier, + .facility = facility, + .socket = socket: { + const rc = std.os.linux.socket( + std.os.linux.AF.UNIX, + std.os.linux.SOCK.DGRAM | std.os.linux.SOCK.CLOEXEC, + 0, + ); + switch (std.os.linux.E.init(rc)) { + .SUCCESS => break :socket @intCast(rc), + else => return error.Failed, + } + }, + }; + + std.debug.assert(logger.path.path.len > JOURNAL_SOCKET.len); + + errdefer _ = std.os.linux.close(logger.socket); + + logger.path.family = std.os.linux.AF.UNIX; + @memcpy(logger.path.path[0..JOURNAL_SOCKET.len], JOURNAL_SOCKET); + logger.path.path[JOURNAL_SOCKET.len] = 0; + + return logger; +} + +pub fn deinit(self: *const Logger) void { + _ = std.os.linux.close(self.socket); +} + +pub fn message(self: *const Logger, priority: Priority) !Message { + const msg: Message = try .init(self); + errdefer msg.cancel(); + + if (self.identifier) |i| try msg.addIdentifier(i); + if (self.facility) |f| try msg.addFacility(f); + try msg.addKV("PRIORITY", priority); + + return msg; +} + +fn _msg(self: *const Logger, priority: Priority, comptime fmt: []const u8, args: anytype) !void { + var buf: [4096]u8 = undefined; + + var writer = std.Io.Writer.fixed(&buf); + writer.print(fmt, args) catch { + const msg = try self.message(.ERROR); + errdefer msg.cancel(); + try msg.addKV("MESSAGE", std.fmt.comptimePrint("formatted message exceeded {d} bytes", .{buf.len})); + try msg.send(); + }; + + const msg = try self.message(priority); + errdefer msg.cancel(); + try msg.addKV("MESSAGE", writer.buffered()); + try msg.send(); +} + +pub fn err(self: *const Logger, comptime fmt: []const u8, args: anytype) void { + self._msg(self, .ERROR, fmt, args) catch {}; +} + +pub fn warn(self: *const Logger, comptime fmt: []const u8, args: anytype) void { + self._msg(self, .WARNING, fmt, args) catch {}; +} + +pub fn info(self: *const Logger, comptime fmt: []const u8, args: anytype) void { + self._msg(self, .INFO, fmt, args) catch {}; +} + +pub fn debug(self: *const Logger, comptime fmt: []const u8, args: anytype) void { + self._msg(self, .DEBUG, fmt, args) catch {}; +} + +test "test" { + const logger = try Logger.init("library test", .USER); + defer logger.deinit(); + + const msg = try logger.message(.INFO); + errdefer msg.cancel(); + + try msg.addKV("MESSAGE", "hello"); + try msg.addSrc(@src()); + + try msg.send(); +} diff --git a/src/Message.zig b/src/Message.zig new file mode 100644 index 0000000..f812da4 --- /dev/null +++ b/src/Message.zig @@ -0,0 +1,215 @@ +const Message = @This(); + +const std = @import("std"); +const assert = std.debug.assert; + +const ControlMessage = @import("cmsghdr.zig").ControlMessage; +const Logger = @import("Logger.zig"); +const constants = @import("constants.zig"); +const Facility = constants.Facility; +const Priority = constants.Priority; + +const F_ADD_SEALS = 1033; + +const F_SEAL_SEAL = 0x0001; +const F_SEAL_SHRINK = 0x0002; +const F_SEAL_GROW = 0x0004; +const F_SEAL_WRITE = 0x0008; +const F_SEAL_FUTURE_WRITE = 0x0010; +const F_SEAL_EXEC = 0x0020; + +const SCM_RIGHTS = 1; + +const MFD_NOEXEC_SEAL = 0x0008; + +pub const WriteError = error{ ShortWrite, WriteFailed }; + +logger: *const Logger, +memfd: std.os.linux.fd_t, + +pub fn init(logger: *const Logger) error{Failed}!Message { + const memfd: std.os.linux.fd_t = memfd: { + const rc = std.os.linux.memfd_create( + "journalz", + std.os.linux.MFD.CLOEXEC | std.os.linux.MFD.ALLOW_SEALING | MFD_NOEXEC_SEAL, + ); + switch (std.os.linux.E.init(rc)) { + .SUCCESS => break :memfd @intCast(rc), + else => return error.Failed, + } + }; + + return .{ + .logger = logger, + .memfd = memfd, + }; +} + +fn writeBytes(self: *const Message, value: anytype) WriteError!void { + const T = @TypeOf(value); + const info = @typeInfo(T); + + const data: []const u8 = data: { + switch (info) { + .array => |a| { + if (a.child == u8) break :data &value; + @compileError("array" ++ @typeName(T) ++ " is not supported"); + }, + .pointer => |p| { + if (p.size == .slice and p.child == u8) break :data value; + if (p.size == .one) { + switch (@typeInfo(p.child)) { + .array => |a| { + if (a.child == u8) break :data value; + @compileError(@typeName(T) ++ " is not supported"); + }, + else => @compileError(@typeName(T) ++ " is not supported"), + } + break :data value; + } + @compileError("pointer " ++ @tagName(p.size) ++ " " ++ @typeName(T) ++ " is not supported"); + }, + .int => |i| { + if (@mod(i.bits, 8) != 0) @compileError("integers must be multiples of 8 bits"); + + const le = std.mem.nativeToLittle(T, value); + break :data std.mem.asBytes(&le); + }, + else => @compileError(@typeName(T) ++ " is not supported"), + } + }; + + const rc = std.os.linux.write(self.memfd, data.ptr, data.len); + switch (std.os.linux.E.init(rc)) { + .SUCCESS => { + if (rc != data.len) return error.ShortWrite; + }, + else => return error.WriteFailed, + } +} + +pub fn addKV(self: *const Message, key: []const u8, value: anytype) WriteError!void { + const T = @TypeOf(value); + const info = @typeInfo(T); + + for (key) |c| { + assert(c != '\n'); + assert(c != '='); + assert(c != 0); + } + + var buf: [256]u8 = undefined; + + try self.writeBytes(key); + try self.writeBytes("\n"); + + const data: []const u8 = data: { + switch (info) { + .array => |a| { + if (a.child == u8) break :data &value; + @compileError("array" ++ @typeName(T) ++ " is not supported"); + }, + .pointer => |p| { + if (p.size == .slice and p.child == u8) break :data value; + if (p.size == .one) { + switch (@typeInfo(p.child)) { + .array => |a| { + if (a.child == u8) break :data value; + @compileError(@typeName(T) ++ " is not supported"); + }, + else => @compileError(@typeName(T) ++ " is not supported"), + } + break :data value; + } + @compileError("pointer " ++ @tagName(p.size) ++ " " ++ @typeName(T) ++ " is not supported"); + }, + .int => { + var writer = std.Io.Writer.fixed(&buf); + writer.print("{d}", .{value}) catch return error.WriteFailed; + break :data writer.buffered(); + }, + .@"enum" => { + var writer = std.Io.Writer.fixed(&buf); + writer.print("{d}", .{@intFromEnum(value)}) catch return error.WriteFailed; + break :data writer.buffered(); + }, + else => @compileError(@typeName(T) ++ " is not supported"), + } + }; + + try self.writeBytes(data.len); + try self.writeBytes(data); + + try self.writeBytes("\n"); +} + +pub fn addIdentifier(self: *const Message, value: []const u8) WriteError!void { + try self.addKV("SYSLOG_IDENTIFIER", value); +} + +pub fn addFacility(self: *const Message, value: Facility) WriteError!void { + try self.addKV("SYSLOG_FACILITY", value); +} + +pub fn addPriority(self: *const Message, value: Priority) WriteError!void { + try self.addKV("PRIORITY", value); +} + +pub fn addSrc(self: *const Message, loc: std.builtin.SourceLocation) WriteError!void { + try self.addKV("CODE_MODULE", loc.module); + try self.addKV("CODE_FILE", loc.file); + try self.addKV("CODE_FUNC", loc.fn_name); + try self.addKV("CODE_LINE", loc.line); + try self.addKV("CODE_COLUMN", loc.column); +} + +pub fn send(self: *const Message) WriteError!void { + { + const rc = std.os.linux.fcntl( + self.memfd, + F_ADD_SEALS, + F_SEAL_SEAL | F_SEAL_SHRINK | F_SEAL_GROW | F_SEAL_WRITE | F_SEAL_EXEC, + ); + switch (std.os.linux.E.init(rc)) { + .SUCCESS => {}, + else => return error.WriteFailed, + } + } + + var control: ControlMessage(std.os.linux.fd_t) = .init( + std.os.linux.SOL.SOCKET, + SCM_RIGHTS, + self.memfd, + ); + + var msghdr = std.os.linux.msghdr_const{ + .name = @ptrCast(&self.logger.path), + .namelen = @sizeOf(@TypeOf(self.logger.path)), + .iov = undefined, + .iovlen = 0, + .control = &control, + .controllen = @sizeOf(@TypeOf(control)), + .flags = 0, + }; + + { + const rc = std.os.linux.sendmsg( + self.logger.socket, + &msghdr, + 0, + ); + + switch (std.os.linux.E.init(rc)) { + .SUCCESS => {}, + else => return error.WriteFailed, + } + } + + errdefer comptime unreachable; + + _ = std.os.linux.close(self.memfd); +} + +pub fn cancel(self: Message) void { + _ = std.os.linux.close(self.memfd); +} diff --git a/src/cmsghdr.zig b/src/cmsghdr.zig index 5b33f9b..e5474ab 100644 --- a/src/cmsghdr.zig +++ b/src/cmsghdr.zig @@ -2,7 +2,7 @@ const std = @import("std"); // "Borrowed" from https://github.com/tupleapp/tuple-launch/blob/master/cmsghdr.zig -pub fn cmsghdr(comptime T: type) type { +pub fn ControlMessage(comptime T: type) type { const Header = extern struct { len: usize, level: c_int, @@ -17,31 +17,31 @@ pub fn cmsghdr(comptime T: type) type { bytes: [data_offset + @sizeOf(T)]u8 align(@alignOf(Header)), - pub fn init(args: struct { + pub fn init( level: c_int, - type: c_int, - data: T, - }) Self { + @"type": c_int, + value: T, + ) Self { var self: Self = undefined; - self.headerPtr().* = .{ + self.header().* = .{ .len = data_offset + @sizeOf(T), - .level = args.level, - .type = args.type, + .level = level, + .type = @"type", }; - self.dataPtr().* = args.data; + self.data().* = value; return self; } - pub fn headerPtr(self: *Self) *Header { + pub fn header(self: *Self) *Header { return @as(*Header, @ptrCast(self)); } - pub fn dataPtr(self: *Self) *T { - return @as(*T, @alignCast(@ptrCast(self.bytes[data_offset..]))); + pub fn data(self: *Self) *T { + return @as(*T, @ptrCast(@alignCast(self.bytes[data_offset..]))); } }; } test { - std.testing.refAllDecls(cmsghdr([3]std.os.linux.fd_t)); + std.testing.refAllDecls(ControlMessage([3]std.os.linux.fd_t)); } diff --git a/src/constants.zig b/src/constants.zig new file mode 100644 index 0000000..5d4f513 --- /dev/null +++ b/src/constants.zig @@ -0,0 +1,33 @@ +pub const Facility = enum(u5) { + KERN = 0, + USER = 1, + MAIL = 2, + DAEMON = 3, + AUTH = 4, + SYSLOG = 5, + LPR = 6, + NEWS = 7, + UUCP = 8, + CRON = 9, + AUTHPRIV = 10, + FTP = 11, + LOCAL0 = 16, + LOCAL1 = 17, + LOCAL2 = 18, + LOCAL3 = 19, + LOCAL4 = 20, + LOCAL5 = 21, + LOCAL6 = 22, + LOCAL7 = 23, +}; + +pub const Priority = enum(u3) { + EMERG = 0, + ALERT = 1, + CRIT = 2, + ERROR = 3, + WARNING = 4, + NOTICE = 5, + INFO = 6, + DEBUG = 7, +}; diff --git a/src/root.zig b/src/root.zig index c74aad6..cf055ca 100644 --- a/src/root.zig +++ b/src/root.zig @@ -1,245 +1,11 @@ -const Logger = @This(); - const std = @import("std"); -const Allocator = std.mem.Allocator; -const assert = std.debug.assert; - -const cmsghdr = @import("cmsghdr.zig"); - -pub const Facility = enum(u5) { - KERN = 0, - USER = 1, - MAIL = 2, - DAEMON = 3, - AUTH = 4, - SYSLOG = 5, - LPR = 6, - NEWS = 7, - UUCP = 8, - CRON = 9, - AUTHPRIV = 10, - FTP = 11, - LOCAL0 = 16, - LOCAL1 = 17, - LOCAL2 = 18, - LOCAL3 = 19, - LOCAL4 = 20, - LOCAL5 = 21, - LOCAL6 = 22, - LOCAL7 = 23, -}; - -pub const Priority = enum(u3) { - EMERG = 0, - ALERT = 1, - CRIT = 2, - ERROR = 3, - WARNING = 4, - NOTICE = 5, - INFO = 6, - DEBUG = 7, -}; - -const JOURNAL_SOCKET: [:0]const u8 = "/run/systemd/journal/socket"; - -const SCM_RIGHTS = 1; - -const F_ADD_SEALS = 1033; - -const F_SEAL_SEAL = 0x0001; -const F_SEAL_SHRINK = 0x0002; -const F_SEAL_GROW = 0x0004; -const F_SEAL_WRITE = 0x0008; -const F_SEAL_FUTURE_WRITE = 0x0010; -const F_SEAL_EXEC = 0x0020; - -const MFD_NOEXEC_SEAL = 0x0008; - -identifier: ?[]const u8, -socket: std.os.linux.socket_t, -path: std.os.linux.sockaddr.un = undefined, - -pub fn init(alloc: Allocator, identifier: ?[]const u8) (Allocator.Error || error{Failed})!*Logger { - const logger = try alloc.create(Logger); - errdefer alloc.destroy(logger); - - logger.* = Logger{ - .identifier = identifier, - .socket = socket: { - const rc = std.os.linux.socket( - std.os.linux.AF.UNIX, - std.os.linux.SOCK.DGRAM | std.os.linux.SOCK.CLOEXEC, - 0, - ); - switch (std.os.linux.E.init(rc)) { - .SUCCESS => break :socket @intCast(rc), - else => return error.Failed, - } - }, - }; - - std.debug.assert(logger.path.path.len > JOURNAL_SOCKET.len); - - errdefer _ = std.os.linux.close(logger.socket); - - logger.path.family = std.os.linux.AF.UNIX; - @memcpy(logger.path.path[0..JOURNAL_SOCKET.len], JOURNAL_SOCKET); - logger.path.path[JOURNAL_SOCKET.len] = 0; - - return logger; -} - -pub fn deinit(self: *const Logger, alloc: Allocator) void { - _ = std.os.linux.close(self.socket); - alloc.destroy(self); -} - -pub const Message = struct { - pub const WriteError = error{ ShortWrite, WriteFailed }; - - logger: *const Logger, - priority: Priority, - memfd: std.os.linux.fd_t, - - fn writeBytes(self: *const Message, str: []const u8) WriteError!void { - const rc = std.os.linux.write(self.memfd, str.ptr, str.len); - switch (std.os.linux.E.init(rc)) { - .SUCCESS => { - if (rc != str.len) return error.ShortWrite; - }, - else => return error.WriteFailed, - } - } - - fn writeInt(self: *const Message, comptime T: type, value: T) WriteError!void { - const info = @typeInfo(T); - assert(info == .int); - assert(@mod(info.int.bits, 8) == 0); - - const le = std.mem.nativeToLittle(T, value); - const bytes = std.mem.asBytes(&le); - try self.writeBytes(bytes); - } - - pub fn string(self: *const Message, key: []const u8, value: []const u8) WriteError!void { - try self.writeBytes(key); - try self.writeBytes("\n"); - try self.writeInt(u64, value.len); - try self.writeBytes(value); - try self.writeBytes("\n"); - } - - pub fn int(self: Message, key: []const u8, value: anytype) (WriteError || error{NoSpaceLeft})!void { - if (@typeInfo(@TypeOf(value)) != .int) - @compileError("type " ++ @typeName(@TypeOf(value)) ++ " is not an integer type"); - - var buf: [64]u8 = undefined; - var fbs = std.io.fixedBufferStream(&buf); - const writer = fbs.writer(); - try writer.print("{d}", .{value}); - try self.string(key, fbs.getWritten()); - } - - pub fn identifier(self: *const Message, value: []const u8) WriteError!void { - try self.string("SYSLOG_IDENTIFIER", value); - } - - pub fn facility(self: *const Message, value: Facility) WriteError!void { - try self.int("SYSLOG_FACILITY", @intFromEnum(value)); - } - - pub fn src(self: *const Message, loc: std.builtin.SourceLocation) WriteError!void { - try self.string("CODE_FILE", loc.file); - try self.string("CODE_FUNC", loc.fn_name); - try self.int("CODE_LINE", loc.line); - } - - pub fn send(self: *const Message) WriteError!void { - { - const rc = std.os.linux.fcntl( - self.memfd, - F_ADD_SEALS, - F_SEAL_SEAL | F_SEAL_SHRINK | F_SEAL_GROW | F_SEAL_WRITE | F_SEAL_EXEC, - ); - switch (std.os.linux.E.init(rc)) { - .SUCCESS => {}, - else => return error.WriteFailed, - } - } - - var cmsg = cmsghdr.cmsghdr(std.os.linux.fd_t).init( - .{ - .level = std.os.linux.SOL.SOCKET, - .type = SCM_RIGHTS, - .data = self.memfd, - }, - ); - - var msghdr = std.os.linux.msghdr_const{ - .name = @ptrCast(&self.logger.path), - .namelen = @sizeOf(@TypeOf(self.logger.path)), - .iov = undefined, - .iovlen = 0, - .control = &cmsg, - .controllen = @sizeOf(@TypeOf(cmsg)), - .flags = 0, - }; - - { - const rc = std.os.linux.sendmsg( - self.logger.socket, - &msghdr, - 0, - ); - - switch (std.os.linux.E.init(rc)) { - .SUCCESS => {}, - else => return error.WriteFailed, - } - } - - _ = std.os.linux.close(self.memfd); - } - - pub fn cancel(self: Message) void { - _ = std.os.linux.close(self.memfd); - } -}; - -pub fn message(self: *const Logger, priority: Priority) !Message { - const memfd: std.os.linux.fd_t = memfd: { - const rc = std.os.linux.memfd_create( - "zig", - std.os.linux.MFD.CLOEXEC | std.os.linux.MFD.ALLOW_SEALING | MFD_NOEXEC_SEAL, - ); - switch (std.os.linux.E.init(rc)) { - .SUCCESS => break :memfd @intCast(rc), - else => return error.Failed, - } - }; - - const msg = Message{ - .logger = self, - .priority = priority, - .memfd = memfd, - }; - - if (self.identifier) |i| try msg.identifier(i); - try msg.int("PRIORITY", @intFromEnum(priority)); - - return msg; -} - -test "test" { - const logger = try Logger.init(std.testing.allocator, "library test"); - defer logger.deinit(std.testing.allocator); - - const msg = try logger.message(.INFO); - errdefer msg.cancel(); - try msg.facility(.LOCAL0); - try msg.string("MESSAGE", "hello"); - try msg.src(@src()); +pub const Logger = @import("Logger.zig"); +pub const Message = @import("Message.zig"); +const constants = @import("constants.zig"); +pub const Facility = constants.Facility; +pub const Priority = constants.Priority; - try msg.send(); +test { + _ = std.testing.refAllDeclsRecursive(@This()); } -- knotmirror 0.0.1