A 9P error past 128 bytes keeps its reason: the path in it gives up its middle to …

An Rerror carries 128 bytes (Plan 9's ERRMAX) and the engine cut longer text there, and a builtin's failure was first clipped between words to 256 with ...: either way the end, which says why, was what went. tree.handle now fits a long reason by cutting the middle of its longest path, else of the whole text, on a character boundary, and reportFailure fills its buffer the same way.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

1 files changed, 50 insertions, 0 deletions

diff --git a/src/ninep/tree.zig b/src/ninep/tree.zig
index 30bf073d..f6cb115a 100644
--- a/src/ninep/tree.zig
+++ b/src/ninep/tree.zig
@@ -456,9 +456,59 @@ pub fn stagedReply(p: *Pardes, req: Req) Reply {
 pub fn handle(p: *Pardes, req: Req) Reply {
     var reply = serve(p, req);
     if (reply.status == .err and reply.ename.len == 0) reply.ename = errWords(reply.errno);
+    if (reply.status == .err and reply.ename.len > cloud9.fs.errmax)
+        if (p.scratch.allocator().alloc(u8, cloud9.fs.errmax)) |room| {
+            reply.ename = fitErr(reply.ename, room);
+        } else |_| {};
     return reply;
 }
 
+/// A reason longer than an Rerror carries (Plan 9's ERRMAX, 128 bytes)
+/// keeps its end, which says why: the longest path in it -- else the whole
+/// text -- gives up its middle to `…`.
+pub fn fitErr(text: []const u8, out: []u8) []const u8 {
+    const ell = "…";
+    if (text.len <= out.len) return text;
+    const over = text.len - out.len + ell.len;
+    var from: usize = 0;
+    var to: usize = text.len;
+    var words = std.mem.tokenizeAny(u8, text, " \t");
+    var longest: usize = 0;
+    while (words.next()) |w| if (std.mem.indexOfScalar(u8, w, '/') != null and w.len > longest and w.len > over + 2) {
+        longest = w.len;
+        from = @intFromPtr(w.ptr) - @intFromPtr(text.ptr);
+        to = from + w.len;
+    };
+    var a = from + (to - from - over) / 2;
+    var b = a + over;
+    while (a > from and text[a] & 0xC0 == 0x80) a -= 1;
+    while (b < to and text[b] & 0xC0 == 0x80) b += 1;
+    return std.fmt.bufPrint(out, "{s}" ++ ell ++ "{s}", .{ text[0..a], text[b..] }) catch text[0..out.len];
+}
+
+test "a reason past 128 bytes keeps its end: the path in it gives up its middle" {
+    var out: [128]u8 = undefined;
+    const long = "Save /home/someone/projects/" ++ "deep/" ** 30 ++ "file.txt: no such directory";
+    const fit = fitErr(long, &out);
+    try testing.expect(fit.len <= 128);
+    try testing.expect(std.mem.startsWith(u8, fit, "Save /home/someone/"));
+    try testing.expect(std.mem.endsWith(u8, fit, "file.txt: no such directory"));
+    try testing.expect(std.mem.indexOf(u8, fit, "…") != null);
+    try testing.expect(std.unicode.utf8ValidateSlice(fit));
+    // No path: the whole text's middle goes, the end stays.
+    const words = "why " ** 40 ++ "the reason";
+    try testing.expect(std.mem.endsWith(u8, fitErr(words, &out), "the reason"));
+    try testing.expectEqualStrings("short", fitErr("short", &out));
+    // Through the tree: a look at a long ./ name not there says why at the end.
+    const p = try th.withFile(testing.allocator, "x\n");
+    defer p.deinit();
+    var line: [512]u8 = undefined;
+    const r = th.wr(p, Node.of(serialOf(p), .look), try std.fmt.bufPrint(&line, "./{s}x.txt\n", .{"no-such-dir/" ** 20}));
+    try testing.expectEqual(Status.err, r.reply.status);
+    try testing.expect(r.reply.ename.len <= 128);
+    try testing.expect(std.mem.endsWith(u8, r.reply.ename, "no such file") or std.mem.endsWith(u8, r.reply.ename, "no such directory"));
+}
+
 /// A refusal with no reason of its own said in Plan 9's words, not the C
 /// library's (`Operation not permitted`); each maps back to its errno in
 /// 9ns (enameToErrno), EPERM's to EACCES as Plan 9's does.