1b10e0de

fix: hosts rm is one read-modify-write for every spelling, and forgets every match

a73x 2026-08-28 19:53

Commit message

fix: hosts rm is one read-modify-write for every spelling, and forgets every match

src/cli/mux_main.zig

Old		New
@@ -704,16 +704,20 @@ fn hostsEdit(
704		704
705	if (adding) return hostsAdd(arena, spellings.items, path);	705	if (adding) return hostsAdd(arena, spellings.items, path);
706		706
		707	// One read-modify-write for the whole line, like `add`: an IO error on
		708	// the third of four must not leave the first two applied.
		709	const gone = try arena.alloc(bool, spellings.items.len);
		710	@memset(gone, false);
		711	hosts.forgetMany(arena, path, spellings.items, gone) catch \|err\| {
		712	std.debug.print("mux hosts rm: {s}: {s}\n", .{ path, hosts.reason(err) });
		713	return 1;
		714	};
707	var rc: u8 = 0;	715	var rc: u8 = 0;
708	for (spellings.items) \|s\| {	716	for (spellings.items, gone) \|s, g\| {
709	const gone = hosts.forget(arena, path, s) catch \|err\| {
710	std.debug.print("mux hosts rm: {s}: {s}\n", .{ path, hosts.reason(err) });
711	return 1;
712	};
713	// Removing what is not there is reported and non-zero — a script	717	// Removing what is not there is reported and non-zero — a script
714	// that thinks it dropped a host should learn it was spelled	718	// that thinks it dropped a host should learn it was spelled
715	// differently. The rest of the line still applies.	719	// differently. The rest of the line still applies.
716	if (!gone) {	720	if (!g) {
717	std.debug.print("mux hosts rm: not on the wall: {s}\n", .{s});	721	std.debug.print("mux hosts rm: not on the wall: {s}\n", .{s});
718	rc = 1;	722	rc = 1;
719	}	723	}

src/hosts.zig

+    return true;
+/// One spelling; `forgetMany` owns the rules.
+pub fn forget(alloc: std.mem.Allocator, path: []const u8, spelling: []const u8) !bool {
+    var gone = [_]bool{false};
+    try forgetMany(alloc, path, &.{spelling}, &gone);
+    return gone[0];
+}
+/// Out of the file, marking `gone[i]` for each spelling that matched.
+pub fn forgetMany(
+    alloc: std.mem.Allocator,
+    path: []const u8,
+    spellings: []const []const u8,
+    gone: []bool,
+) !void {
+    // `gone` is the caller's, one slot per spelling, and is only ever set.
+    std.debug.assert(gone.len == spellings.len);
+    // Verbatim, not through `load`: the one command whose job is removing a
+    // line has to reach a hand-edited line the grammar refuses. `record`
+    // keeps reading strictly — growing a file whose content is not
+    // understood re-saves the garbage as if it had been read.
+    //
+    // ONE read-modify-write, because `hostsAdd`'s rule is the file's rule:
+    // an IO error on the third of four must not leave the first two
+    // applied. EVERY copy, because `load` folds duplicate lines into one
+    // wall entry — stopping at the first match let a `rm` exit 0, print
+    // nothing, and leave the host still polled.
+    var lines = try wall.loadLines(alloc, path);
+    defer wall.freeLines(alloc, &lines);
+    var removed = false;
+    var i: usize = 0;
+    while (i < lines.items.len) {
+        var hit = false;
+        for (spellings, gone) |s, *g| {
+            if (!std.mem.eql(u8, lines.items[i], s)) continue;
+            g.* = true;
+            hit = true;
+        }
+        if (!hit) {
+            i += 1;
+            continue;
+        }
+        alloc.free(lines.orderedRemove(i));
+        removed = true;
+    // A save that changes nothing is still a write someone else could lose
+    // an update to — see the unlocked read-modify-write this file lives with.
+    if (removed) try wall.saveLines(lines.items, path);
+pub fn statePath(alloc: std.mem.Allocator) ![]const u8 {
+    try std.testing.expect(try record(alloc, path, "other"));
+test "hosts.forget removes EVERY copy, so a rm cannot report success and change nothing" {
+    // `load` folds duplicate lines into one wall entry, so a hand-edited
+    // file with `box` twice is ONE host. A forget that stopped at the first
+    // match exited 0, printed nothing, and left `mux` still polling box.
+    const alloc = std.testing.allocator;
+    var tmp = try TmpDir.make();
+    defer tmp.cleanup();
+    const path = try std.fmt.allocPrint(alloc, "{s}/hosts", .{tmp.path()});
+    defer alloc.free(path);
+    try wall.saveBytes(path, "box\nkeep\nbox\n");
+    try std.testing.expect(try forget(alloc, path, "box"));
+    var lines = try wall.loadLines(alloc, path);
+    defer wall.freeLines(alloc, &lines);
+    try std.testing.expectEqual(@as(usize, 1), lines.items.len);
+    try std.testing.expectEqualStrings("keep", lines.items[0]);
+    try std.testing.expect(!try forget(alloc, path, "box"));
+}
+test "hosts.forgetMany: several names leave in ONE read-modify-write" {
+    // `hostsAdd`'s rule, which the `rm` loop broke by calling `forget` once
+    // per spelling: an IO error on the third of four must not leave the
+    // first two applied. One load, one save, and every name's verdict comes
+    // back from the same pass.
+    const alloc = std.testing.allocator;
+    var tmp = try TmpDir.make();
+    defer tmp.cleanup();
+    const path = try std.fmt.allocPrint(alloc, "{s}/hosts", .{tmp.path()});
+    defer alloc.free(path);
+    try wall.saveBytes(path, "a\nb\nkeep\na\n");
+    var gone = [_]bool{ false, false, false };
+    try forgetMany(alloc, path, &.{ "a", "absent", "b" }, &gone);
+    try std.testing.expectEqualSlices(bool, &.{ true, false, true }, &gone);
+    var lines = try wall.loadLines(alloc, path);
+    defer wall.freeLines(alloc, &lines);
+    try std.testing.expectEqual(@as(usize, 1), lines.items.len);
+    try std.testing.expectEqualStrings("keep", lines.items[0]);
+}
+test "hosts.statePathFrom: XDG_STATE_HOME wins, HOME falls back, file is mux/hosts" {
+    const alloc = std.testing.allocator;
+    const a = try statePathFrom(alloc, "/x", "/h");