fix the memleak

build.zig

@@ -24,6 +24,12 @@ pub fn build(b: *std.Build) void {
         .optimize = optimize,
     });
 
+    exe.linkLibC();
+    exe.addIncludePath(.{ .cwd_relative = "/usr/include/glib-2.0" });
+    exe.addIncludePath(.{ .cwd_relative = "/usr/lib/glib-2.0/include" });
+    exe.addIncludePath(.{ .cwd_relative = "/usr/include/gdk-pixbuf-2.0" });
+    exe.linkSystemLibrary("notify");
+
     // This declares intent for the executable to be installed into the
     // standard location when the user invokes the "install" step (the default
     // step when running `zig build`).

src/main.zig

@@ -1,84 +1,111 @@
 const std = @import("std");
+const c = @cImport({
+    @cInclude("libnotify/notify.h");
+});
 
 pub const std_options = struct {
     pub const log_level = .info;
 };
 
-pub fn main() !void {
+const NOTIFICATION_TITLE: [:0]const u8 = "bat-alert";
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+const NOTIFICATION_BODY: [:0]const u8 = "battery running low!";
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
 
-    const args = try std.process.argsAlloc(allocator);
+const ParseMode = enum { none, target, battery };
-    defer std.process.argsFree(allocator, args);
+
+pub fn main() !void {
+    if (c.notify_init("bat-alert") == c.FALSE) {
+        std.log.err("notify_init failed", .{});
+        std.process.exit(1);
+    }
 
     var target: u8 = 15;
     var battery: []const u8 = "BAT0";
 
-    for (args, 0..) |arg, i| {
+    var argsIter = std.process.args();
-        if (std.mem.eql(u8, arg, "--help")) {
+
-            const stdout = std.io.getStdOut().writer();
+    var parse_mode = ParseMode.none;
-            try stdout.print(
+    while (argsIter.next()) |arg| {
-                \\Usage: bat-alert [options]
+        switch (parse_mode) {
-                \\
+            ParseMode.none => {
-                \\Options:
+                if (std.mem.eql(u8, arg, "--help")) {
-                \\  -t, --target NUM	Target battery level (default: 15)
+                    const stdout = std.io.getStdOut().writer();
-                \\  --battery NAME		Battery name (default: BAT0)
+                    try stdout.print(
-                \\
+                        \\Usage: bat-alert [options]
-            , .{});
+                        \\
-            std.process.exit(0);
+                        \\Options:
-        }
+                        \\  -t, --target NUM	Target battery level (default: 15)
-
+                        \\  --battery NAME		Battery name (default: BAT0)
-        if (std.mem.eql(u8, arg, "--target") or std.mem.eql(u8, arg, "-t")) {
+                        \\
-            if (i + 1 == args.len) {
+                    , .{});
-                std.log.err("--target requires an argument", .{});
+                    std.process.exit(0);
-                std.process.exit(1);
+                }
-            }
+                if (std.mem.eql(u8, arg, "--target") or std.mem.eql(u8, arg, "-t")) {
-
+                    parse_mode = ParseMode.target;
-            const parsedTarget = std.fmt.parseInt(u8, args[i + 1], 10) catch |err| {
+                }
-                std.log.err("invalid target '{s}': {}", .{ args[i + 1], err });
+                if (std.mem.eql(u8, arg, "--battery")) {
-                std.process.exit(1);
+                    parse_mode = ParseMode.battery;
-            };
+                }
-            target = parsedTarget;
+            },
-        }
+            ParseMode.battery => {
-
+                battery = arg;
-        if (std.mem.eql(u8, arg, "--battery")) {
+                parse_mode = ParseMode.none;
-            if (i + 1 == args.len) {
+            },
-                std.log.err("--battery requires an argument", .{});
+            ParseMode.target => {
-                std.process.exit(1);
+                const parsedTarget = std.fmt.parseInt(u8, arg, 10) catch {
-            }
+                    std.log.err("cannot parse target '{s}' as int", .{arg});
-
+                    std.process.exit(1);
-            battery = args[i + 1];
+                };
+                target = parsedTarget;
+                parse_mode = ParseMode.none;
+            },
         }
     }
+    if (parse_mode != ParseMode.none) {
+        std.log.err("option requires an argument: --{s}", .{@tagName(parse_mode)});
+        std.process.exit(1);
+    }
 
     var sent = false;
-    const batteryPath = try std.fmt.allocPrint(allocator, "/sys/class/power_supply/{s}/capacity", .{battery});
+    var batBuf: [256]u8 = undefined;
+    var capBuf: [8]u8 = undefined;
+
+    const batteryPath = try std.fmt.bufPrint(&batBuf, "/sys/class/power_supply/{s}/capacity", .{battery});
 
     while (true) {
-        const capacityFile = try std.fs.openFileAbsolute(batteryPath, .{});
+        const capacityFile = std.fs.openFileAbsolute(batteryPath, .{}) catch |err| {
-        var capacityStr = std.ArrayList(u8).init(allocator);
+            std.log.err("open {s}: {}", .{ batteryPath, err });
-        try capacityFile.reader().streamUntilDelimiter(capacityStr.writer(), '\n', null);
+            std.process.exit(1);
+        };
+        _ = try capacityFile.reader().readAll(&capBuf);
         capacityFile.close();
+        var splat = std.mem.splitScalar(u8, &capBuf, '\n');
 
-        // std.log.info("battery: {s}", .{capacityStr.items});
+        // std.log.info("battery: {s}", .{splat.first()});
 
-        const capacity = try std.fmt.parseInt(u8, capacityStr.items, 10);
+        const capacity = try std.fmt.parseInt(u8, splat.first(), 10);
         // std.log.info("battery (but parsed): {}", .{capacity});
 
         if (capacity <= target) {
             if (!sent) {
                 sent = true;
-                _ = try std.process.Child.exec(.{
+                // _ = try std.process.Child.exec(.{
-                    .allocator = allocator,
+                //     .allocator = allocator,
-                    .argv = &[_][]const u8{ "notify-send", "-t", "5000", "-u", "critical", "bat-alert", "battery running low!" },
+                //     .argv = &[_][]const u8{ "notify-send", "-t", "5000", "-u", "critical", NOTIFICATION_TITLE, NOTIFICATION_BODY },
-                });
+                // });
+
+                const notif = c.notify_notification_new(NOTIFICATION_TITLE, NOTIFICATION_BODY, null);
+                var g_err: [*c]c.GError = null;
+                const ret = c.notify_notification_show(notif, &g_err);
+                if (ret == c.FALSE) {
+                    std.log.err("failed to send a notification: {s}", .{g_err.*.message});
+                }
+                c.g_object_unref(c.G_OBJECT(notif));
+
                 std.log.info("[NOTIFY] battery running low!", .{});
             }
         } else {
             sent = false;
         }
-        capacityStr.deinit();
 
         std.time.sleep(10 * 1e9);
     }