summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--README.md9
-rw-r--r--src/Fsys.zig582
-rw-r--r--src/TestTree.zig232
-rw-r--r--src/root.zig2
4 files changed, 825 insertions, 0 deletions
diff --git a/README.md b/README.md
index 6e0d488..a474147 100644
--- a/README.md
+++ b/README.md
@@ -71,6 +71,15 @@ Submit `.version` first. Drain `output()` through your transport and report the
number sent with `wrote()`. Feed received bytes using `push()` and collect tagged
results with `take()`. All base requests are available through `Client.Request`.
+`Fsys` is that client on a socket, blocking, one call at a time (plan9port's
+lib9pclient): `dial(io, env, "pardes/main", user)` takes a name posted in the
+registry, `unix!PATH` or `tcp!HOST!PORT`; then `open`, `create`, `remove`,
+`stat`, `read`, `write` and `clunk` by path and fid, and `readFile`,
+`writeFile` and `ask` (write, then read the answer on that open from 0) for
+the common shapes, streaming into a `std.Io.Writer`. A refusal is
+`error.Refused` and `said()` holds the server's words. Its buffers are in the
+struct: no allocator.
+
For a server, call `Server.receive()` after `push()`. A request borrows the input
until `release()`. After releasing backend fids and canceling outstanding work,
answer Tversion with `negotiate()`. Answer other requests with `reply()`. The
diff --git a/src/Fsys.zig b/src/Fsys.zig
new file mode 100644
index 0000000..224087b
--- /dev/null
+++ b/src/Fsys.zig
@@ -0,0 +1,582 @@
+//! A blocking 9P2000 client: one connection to one tree, its calls made
+//! one at a time from one thread, each waiting for its answer
+//! (plan9port's lib9pclient `CFsys`). `Client` speaks the protocol; this
+//! adds the socket, the fids and the server's words. A refusal is
+//! `error.Refused` and `said()` is what the server said: the string a
+//! mount would have turned into an errno.
+//!
+//! Paths are slash-separated names from the tree's root ("pane/3/body").
+//! The walk to a path goes out with the request that uses it, in one
+//! write (a walk never parks, so the request always follows it), and a
+//! fid is let go of without waiting for the answer: an open, a stat or a
+//! remove costs one round trip. The buffers are in the struct
+//! (2 × `msize`): an `Fsys` stays where it is while it is used.
+const std = @import("std");
+const Io = std.Io;
+const c9 = @import("root.zig");
+const wire = @import("wire.zig");
+const client = @import("client.zig");
+const transport = @import("transport.zig");
+const post = @import("post.zig");
+const fs = @import("fs.zig");
+const Client = client.Client;
+const Stat = wire.Stat;
+const Qid = wire.Qid;
+const max_welem = wire.max_welem;
+
+const Fsys = @This();
+
+/// The largest message asked for; the server may answer less.
+pub const msize: u32 = 65536;
+
+pub const Error = error{
+ /// The server refused: `said()` holds its words.
+ Refused,
+ /// The connection ended.
+ Hangup,
+ /// The server broke the protocol, or a request could not be made
+ /// (a name with a slash or longer than a message).
+ Botch,
+};
+
+io: Io,
+stream: Io.net.Stream,
+cl: Client,
+in: [msize]u8,
+out: [msize]u8,
+next_fid: u32,
+/// Clunks sent and not waited for, a bit per tag: their answers are
+/// dropped as they come.
+unwaited: u32,
+/// The walk sent ahead of the request that uses its fid, and the names
+/// it asked for: `rpc` checks its answer on the way to the request's.
+walk_tag: u16,
+walk_asked: usize,
+words: [fs.errmax]u8,
+words_len: usize,
+
+/// Speaks 9P on `stream`, which is this one's from here (`close`), on a
+/// refusal too: the version, then an attach as `uname` to the tree's root.
+pub fn init(f: *Fsys, io: Io, stream: Io.net.Stream, uname: []const u8) Error!void {
+ f.io = io;
+ f.stream = stream;
+ f.cl = .init(.{ .in = &f.in, .out = &f.out });
+ f.next_fid = 1;
+ f.unwaited = 0;
+ f.walk_tag = wire.notag;
+ f.walk_asked = 0;
+ f.words_len = 0;
+ errdefer f.close();
+ const v = (try f.rpc(.{ .version = .{ .msize = msize } })).version;
+ if (!std.mem.eql(u8, v.version, "9P2000")) return f.refuse("the server does not speak 9P2000");
+ _ = try f.rpc(.{ .attach = .{ .fid = 0, .uname = uname } });
+}
+
+pub const DialError = error{
+ /// Not `unix!PATH`, `tcp!HOST!PORT`, an absolute path or a legal name.
+ BadAddress,
+ /// $XDG_RUNTIME_DIR is unset, so there is no registry to find a name in.
+ NotRuntimeDir,
+} || Error || Io.net.IpAddress.ConnectError || Io.net.UnixAddress.ConnectError || Io.net.UnixAddress.InitError;
+
+/// Dials `dest` and attaches (`init`). `unix!PATH`, or a path starting
+/// with a slash, is a Unix socket; `tcp!HOST!PORT` a numeric address;
+/// anything else a name posted in the registry (`post`), which may name
+/// an entry of a subdirectory: `pardes/main` is
+/// `$XDG_RUNTIME_DIR/9p/pardes/main`.
+pub fn dial(f: *Fsys, io: Io, env: post.Env, dest: []const u8, uname: []const u8) DialError!void {
+ var buf: [transport.sun_path_len]u8 = undefined;
+ const address: transport.Address = if (std.mem.startsWith(u8, dest, "tcp!")) blk: {
+ const bang = std.mem.lastIndexOfScalar(u8, dest, '!').?;
+ if (bang < 5) return error.BadAddress;
+ const port = std.fmt.parseInt(u16, dest[bang + 1 ..], 10) catch return error.BadAddress;
+ break :blk .{ .tcp = Io.net.IpAddress.parse(dest[4..bang], port) catch return error.BadAddress };
+ } else if (std.mem.startsWith(u8, dest, "unix!") or std.mem.startsWith(u8, dest, "/")) blk: {
+ const path = if (dest[0] == '/') dest else dest["unix!".len..];
+ break :blk .{ .unix = std.fmt.bufPrintSentinel(&buf, "{s}", .{path}, 0) catch return error.BadAddress };
+ } else blk: {
+ var it = std.mem.splitScalar(u8, dest, '/');
+ while (it.next()) |name| if (!post.legalName(name)) return error.BadAddress;
+ var dir_buf: [transport.sun_path_len]u8 = undefined;
+ const dir = post.registryDir(env, &dir_buf) catch |err| switch (err) {
+ error.NotRuntimeDir => return error.NotRuntimeDir,
+ else => return error.BadAddress,
+ };
+ break :blk .{ .unix = std.fmt.bufPrintSentinel(&buf, "{s}/{s}", .{ dir, dest }, 0) catch return error.BadAddress };
+ };
+ try f.init(io, try transport.connect(io, address), uname);
+}
+
+/// Hangs up: the server lets go of every fid.
+pub fn close(f: *Fsys) void {
+ f.stream.close(f.io);
+}
+
+/// The server's words for the last `error.Refused`.
+pub fn said(f: *const Fsys) []const u8 {
+ return f.words[0..f.words_len];
+}
+
+pub const Opened = struct { fid: u32, qid: Qid, iounit: u32 };
+
+/// Opens `path` with `mode` (`cloud9.oread`, `owrite`, `ordwr`, with
+/// `otrunc` and the rest): its fid, which `clunk` lets go of.
+pub fn open(f: *Fsys, path: []const u8, mode: u8) Error!Opened {
+ const fid = try f.walkAhead(path);
+ errdefer f.clunk(fid);
+ const o = (try f.rpc(.{ .open = .{ .fid = fid, .mode = mode } })).open;
+ return .{ .fid = fid, .qid = o.qid, .iounit = o.iounit };
+}
+
+/// Creates `path` in its directory with `perm` (`cloud9.dmdir` for a
+/// directory) and opens it with `mode`.
+pub fn create(f: *Fsys, path: []const u8, perm: u32, mode: u8) Error!Opened {
+ const trimmed = std.mem.trim(u8, path, "/");
+ const slash = std.mem.lastIndexOfScalar(u8, trimmed, '/');
+ const fid = try f.walkAhead(if (slash) |s| trimmed[0..s] else "");
+ errdefer f.clunk(fid);
+ const name = if (slash) |s| trimmed[s + 1 ..] else trimmed;
+ const c = (try f.rpc(.{ .create = .{ .fid = fid, .name = name, .perm = perm, .mode = mode } })).create;
+ return .{ .fid = fid, .qid = c.qid, .iounit = c.iounit };
+}
+
+/// Removes `path`.
+pub fn remove(f: *Fsys, path: []const u8) Error!void {
+ // The fid is gone whatever the answer.
+ _ = try f.rpc(.{ .remove = .{ .fid = try f.walkAhead(path) } });
+}
+
+/// The stat of `path`; its strings are good until the next call.
+pub fn stat(f: *Fsys, path: []const u8) Error!Stat {
+ const fid = try f.walkAhead(path);
+ defer f.clunk(fid);
+ return (try f.rpc(.{ .stat = .{ .fid = fid } })).stat;
+}
+
+/// One Tread of up to `count` bytes (and the message size) at `offset`:
+/// the bytes, good until the next call; none at the end.
+pub fn read(f: *Fsys, fid: u32, offset: u64, count: u32) Error![]const u8 {
+ return (try f.rpc(.{ .read = .{ .fid = fid, .offset = offset, .count = @min(count, f.cl.maxRead()) } })).read;
+}
+
+/// One Twrite of as much of `bytes` as a message holds: the count written.
+pub fn write(f: *Fsys, fid: u32, offset: u64, bytes: []const u8) Error!u32 {
+ const n = @min(bytes.len, f.cl.maxWrite());
+ return (try f.rpc(.{ .write = .{ .fid = fid, .offset = offset, .data = bytes[0..n] } })).write;
+}
+
+/// Lets go of `fid`, without waiting for the answer.
+pub fn clunk(f: *Fsys, fid: u32) void {
+ const tag = f.cl.submit(.{ .clunk = .{ .fid = fid } }) catch return;
+ if (tag < 32) f.unwaited |= @as(u32, 1) << @intCast(tag);
+ f.ship() catch {};
+}
+
+/// The file at `path`, read from the start until a read comes back
+/// empty, into `out`, flushed after each answer: a file whose reads the
+/// server parks (an event file) streams as it comes.
+pub fn readFile(f: *Fsys, path: []const u8, out: *Io.Writer) (Error || Io.Writer.Error)!void {
+ const o = try f.open(path, c9.oread);
+ defer f.clunk(o.fid);
+ try f.drain(o, out);
+}
+
+/// `bytes` as the whole of the file at `path`, as `>` would put them:
+/// opened truncated, written in as many writes as it takes.
+pub fn writeFile(f: *Fsys, path: []const u8, bytes: []const u8) Error!void {
+ const o = try f.open(path, c9.owrite | c9.otrunc);
+ defer f.clunk(o.fid);
+ try f.put(o, bytes);
+}
+
+/// Writes `request` to `path` and reads the answer on the same open from
+/// the start, into `out` (as `readFile`): Plan 9's write, seek 0, read of
+/// /net/cs. An answer that never ends (a log written `follow`) streams
+/// until the server hangs up.
+pub fn ask(f: *Fsys, path: []const u8, request: []const u8, out: *Io.Writer) (Error || Io.Writer.Error)!void {
+ const o = try f.open(path, c9.ordwr);
+ defer f.clunk(o.fid);
+ try f.put(o, request);
+ try f.drain(o, out);
+}
+
+/// Directory entries as a directory read answers them: `next` decodes
+/// them one at a time (their strings borrow the bytes).
+pub const Entries = struct {
+ bytes: []const u8,
+ pos: usize = 0,
+
+ pub fn next(e: *Entries) Error!?Stat {
+ if (e.pos == e.bytes.len) return null;
+ if (e.bytes.len - e.pos < 2) return error.Botch;
+ const len = 2 + @as(usize, std.mem.readInt(u16, e.bytes[e.pos..][0..2], .little));
+ if (len > e.bytes.len - e.pos) return error.Botch;
+ defer e.pos += len;
+ return Stat.decode(e.bytes[e.pos..][0..len]) catch error.Botch;
+ }
+};
+
+// ---- internals ----
+
+/// Writes all of `bytes` from the start, in writes no larger than the
+/// open's iounit.
+fn put(f: *Fsys, o: Opened, bytes: []const u8) Error!void {
+ var done: usize = 0;
+ while (done < bytes.len) {
+ const chunk = bytes[done..][0..@min(bytes.len - done, if (o.iounit != 0) o.iounit else bytes.len)];
+ const n = try f.write(o.fid, done, chunk);
+ if (n == 0) return f.refuse("short write");
+ done += n;
+ }
+}
+
+/// Reads from the start until a read comes back empty, each answer into
+/// `out` and flushed.
+fn drain(f: *Fsys, o: Opened, out: *Io.Writer) (Error || Io.Writer.Error)!void {
+ var at: u64 = 0;
+ while (true) {
+ const data = try f.read(o.fid, at, if (o.iounit != 0) o.iounit else msize);
+ if (data.len == 0) return;
+ try out.writeAll(data);
+ try out.flush();
+ at += data.len;
+ }
+}
+
+/// A new fid for `path`. Its walk (the last 16 names of it) is sent and
+/// not waited for: the next `rpc` sends its request behind it and checks
+/// its answer first. Names before the last 16 are walked a round trip
+/// each, the fid stepping from itself.
+fn walkAhead(f: *Fsys, path: []const u8) Error!u32 {
+ f.words_len = 0;
+ const fid = f.next_fid;
+ f.next_fid = if (fid == std.math.maxInt(u32) - 1) 1 else fid + 1;
+ var it = std.mem.tokenizeScalar(u8, path, '/');
+ var from: u32 = 0;
+ while (true) {
+ var names: [max_welem][]const u8 = undefined;
+ var n: usize = 0;
+ while (n < names.len) : (n += 1) names[n] = it.next() orelse break;
+ if (it.peek() == null) {
+ f.walk_tag = f.cl.submit(.{ .walk = .{ .fid = from, .newfid = fid, .names = names[0..n] } }) catch return error.Botch;
+ f.walk_asked = n;
+ return fid;
+ }
+ const w = f.rpc(.{ .walk = .{ .fid = from, .newfid = fid, .names = names[0..n] } }) catch |err| {
+ if (from != 0) f.clunk(fid);
+ return err;
+ };
+ if (w.walk.nwqid < n) {
+ if (from != 0) f.clunk(fid);
+ return f.refuse(fs.errString(fs.E.NOENT));
+ }
+ from = fid;
+ }
+}
+
+/// Sends what the client holds, then reads until `req` is answered. On
+/// the way, the answer of a walk sent ahead is checked (a refusal or a
+/// walk short of its names is this call's refusal: the request behind it
+/// had no fid) and those of unwaited clunks are dropped.
+fn rpc(f: *Fsys, req: Client.Request) Error!Client.Result {
+ if (f.walk_tag == wire.notag) f.words_len = 0;
+ const tag = f.cl.submit(req) catch {
+ // A request that cannot be made (a name too long for a message):
+ // the walk ahead of it still goes, its answer not waited for.
+ if (f.walk_tag < 32) f.unwaited |= @as(u32, 1) << @intCast(f.walk_tag);
+ f.walk_tag = wire.notag;
+ return error.Botch;
+ };
+ try f.ship();
+ while (true) {
+ const done = try f.next();
+ if (f.walk_tag != wire.notag and done.tag == f.walk_tag) {
+ f.walk_tag = wire.notag;
+ switch (done.result) {
+ .fail => |words| f.keep(words),
+ .walk => |w| if (w.nwqid < f.walk_asked) f.keep(fs.errString(fs.E.NOENT)),
+ else => return error.Botch,
+ }
+ continue;
+ }
+ if (done.tag == tag) {
+ if (f.words_len != 0) return error.Refused;
+ return switch (done.result) {
+ .fail => |words| f.refuse(words),
+ else => done.result,
+ };
+ }
+ if (done.tag < 32 and f.unwaited & @as(u32, 1) << @intCast(done.tag) != 0) {
+ f.unwaited &= ~(@as(u32, 1) << @intCast(done.tag));
+ continue;
+ }
+ return error.Botch;
+ }
+}
+
+/// The next answer, read from the socket as it takes; its slices are
+/// good until the next.
+fn next(f: *Fsys) Error!Client.Done {
+ while (true) {
+ if (f.cl.take()) |done| return done;
+ if (f.cl.dead) return error.Botch;
+ // take() found no whole frame and the client has dropped the last
+ // one, so the free end of its input is where the next bytes go
+ // (what `push` would copy them to).
+ var room = [1][]u8{f.cl.in[f.cl.in_len..]};
+ if (room[0].len == 0) return error.Botch;
+ const n = f.stream.read(f.io, &room) catch return error.Hangup;
+ if (n == 0) return error.Hangup;
+ f.cl.in_len += n;
+ }
+}
+
+fn ship(f: *Fsys) Error!void {
+ var w = f.stream.writer(f.io, &.{});
+ const bytes = f.cl.output();
+ w.interface.writeAll(bytes) catch return error.Hangup;
+ f.cl.wrote(bytes.len);
+}
+
+/// Keeps `words` as the refusal, unless one is kept already (the walk's,
+/// before the request it failed).
+fn keep(f: *Fsys, words: []const u8) void {
+ if (f.words_len != 0) return;
+ f.words_len = @min(words.len, f.words.len);
+ @memcpy(f.words[0..f.words_len], words[0..f.words_len]);
+}
+
+fn refuse(f: *Fsys, words: []const u8) error{Refused} {
+ f.keep(words);
+ return error.Refused;
+}
+
+// ---- tests: against cloud9's own engine, served by `serve.Runner` ----
+
+const testing = std.testing;
+const TestTree = @import("TestTree.zig");
+
+const no_env = [_:null]?[*:0]const u8{};
+
+const Dest = enum { unix, tcp };
+
+fn dialed(t: *TestTree, dest: Dest) !*Fsys {
+ const f = try testing.allocator.create(Fsys);
+ errdefer testing.allocator.destroy(f);
+ var buf: [128]u8 = undefined;
+ const address = switch (dest) {
+ .unix => try std.fmt.bufPrint(&buf, "unix!{s}", .{t.unix}),
+ .tcp => try std.fmt.bufPrint(&buf, "tcp!127.0.0.1!{d}", .{t.tcp.getPort()}),
+ };
+ try f.dial(testing.io, &no_env, address, "glenda");
+ return f;
+}
+
+fn hangUp(f: *Fsys) void {
+ f.close();
+ testing.allocator.destroy(f);
+}
+
+fn readAll(f: *Fsys, path: []const u8) ![]u8 {
+ var out: Io.Writer.Allocating = .init(testing.allocator);
+ errdefer out.deinit();
+ try f.readFile(path, &out.writer);
+ return out.toOwnedSlice();
+}
+
+test "fsys: whole files, stats and walks over a Unix socket and TCP" {
+ const t = try testing.allocator.create(TestTree);
+ defer testing.allocator.destroy(t);
+ try t.start();
+ defer t.stop();
+ for ([_]Dest{ .unix, .tcp }) |dest| {
+ const f = try dialed(t, dest);
+ defer hangUp(f);
+ const readme = try readAll(f, "README");
+ defer testing.allocator.free(readme);
+ try testing.expectEqualStrings(TestTree.readme, readme);
+ // Longer than a message (the server's is 8192): read on to the end.
+ const big = try readAll(f, "/big");
+ defer testing.allocator.free(big);
+ try testing.expectEqual(TestTree.big_len, big.len);
+ for (big, 0..) |b, i| if (b != TestTree.bigByte(i)) return error.TestUnexpectedResult;
+ try testing.expectEqualStrings("deep", (try f.stat("sub/deep")).name);
+ try testing.expectEqual(@as(u64, TestTree.readme.len), (try f.stat("README")).length);
+ // More names than a walk carries: the first 16 a round trip of their own.
+ try testing.expectEqualStrings("deep", (try f.stat("sub/../sub/../sub/../sub/../sub/../sub/../sub/../sub/../sub/../sub/deep")).name);
+ try testing.expectError(error.Refused, f.stat("nowhere"));
+ try testing.expectEqualStrings("No such file or directory", f.said());
+ // A walk short of its names is refused in the same words.
+ try testing.expectError(error.Refused, f.stat("sub/nowhere"));
+ try testing.expectEqualStrings("No such file or directory", f.said());
+ try testing.expectError(error.Refused, f.stat("sub/../sub/../sub/../sub/../sub/../sub/../sub/../sub/../sub/../nowhere/deep"));
+ // Refusals leave the connection as good as before.
+ try testing.expectEqualStrings("README", (try f.stat("README")).name);
+ }
+}
+
+test "fsys: a refused write's words reach the caller" {
+ const t = try testing.allocator.create(TestTree);
+ defer testing.allocator.destroy(t);
+ try t.start();
+ defer t.stop();
+ const f = try dialed(t, .unix);
+ defer hangUp(f);
+ try testing.expectError(error.Refused, f.writeFile("ctl", "bogus\n"));
+ try testing.expectEqualStrings("unknown command: bogus", f.said());
+ try f.writeFile("ctl", "ok\n");
+ const ctl = try readAll(f, "ctl");
+ defer testing.allocator.free(ctl);
+ try testing.expectEqualStrings("ok\n", ctl);
+ try testing.expectError(error.Refused, f.writeFile("README", "x"));
+ try testing.expectEqualStrings("permission denied", f.said());
+}
+
+test "fsys: a short read is not the end of the file" {
+ const t = try testing.allocator.create(TestTree);
+ defer testing.allocator.destroy(t);
+ try t.start();
+ defer t.stop();
+ const f = try dialed(t, .unix);
+ defer hangUp(f);
+ const short = try readAll(f, "short");
+ defer testing.allocator.free(short);
+ try testing.expectEqualStrings("a short answer, three bytes a read", short);
+ // One Tread is one answer, a short one included.
+ const o = try f.open("short", c9.oread);
+ defer f.clunk(o.fid);
+ try testing.expectEqualStrings("a s", try f.read(o.fid, 0, 100));
+}
+
+test "fsys: ask reads the answer on the open it wrote, from the start" {
+ const t = try testing.allocator.create(TestTree);
+ defer testing.allocator.destroy(t);
+ try t.start();
+ defer t.stop();
+ const f = try dialed(t, .unix);
+ defer hangUp(f);
+ var out: Io.Writer.Allocating = .init(testing.allocator);
+ defer out.deinit();
+ try f.ask("echo", "hello\n", &out.writer);
+ try testing.expectEqualStrings("heard hello\n", out.written());
+}
+
+test "fsys: a read the server holds streams three chunks, then its end" {
+ const t = try testing.allocator.create(TestTree);
+ defer testing.allocator.destroy(t);
+ try t.start();
+ defer t.stop();
+ const f = try dialed(t, .unix);
+ defer hangUp(f);
+ const Feeder = struct {
+ fn run(tree: *TestTree) anyerror!void {
+ for ([_][]const u8{ "new 1\n", "del 2\n", "new 3\n", "" }) |chunk| try tree.feed(chunk);
+ }
+ };
+ var feeder = try testing.io.concurrent(Feeder.run, .{t});
+ defer _ = feeder.cancel(testing.io) catch {};
+ // Each chunk is flushed as it comes: a writer that marks its flushes.
+ const Marked = struct {
+ w: Io.Writer,
+ marks: [8]usize = undefined,
+ n: usize = 0,
+ fn flush(w: *Io.Writer) Io.Writer.Error!void {
+ const m: *@This() = @fieldParentPtr("w", w);
+ m.marks[m.n] = w.end;
+ m.n += 1;
+ }
+ };
+ var store: [64]u8 = undefined;
+ var marked: Marked = .{ .w = .{ .vtable = &.{ .drain = Io.Writer.fixedDrain, .flush = Marked.flush }, .buffer = &store } };
+ const out = &marked.w;
+ try f.ask("event", "follow\n", out);
+ try testing.expectEqualStrings("new 1\ndel 2\nnew 3\n", out.buffered());
+ try testing.expectEqualSlices(usize, &.{ 6, 12, 18 }, marked.marks[0..marked.n]);
+ try feeder.await(testing.io);
+}
+
+test "fsys: a server that goes away mid-read is a hangup" {
+ const t = try testing.allocator.create(TestTree);
+ defer testing.allocator.destroy(t);
+ try t.start();
+ defer t.stop();
+ const f = try dialed(t, .unix);
+ defer hangUp(f);
+ const Feeder = struct {
+ fn run(tree: *TestTree) anyerror!void {
+ try tree.feed("first\n");
+ try tree.feed(null);
+ }
+ };
+ var feeder = try testing.io.concurrent(Feeder.run, .{t});
+ defer _ = feeder.cancel(testing.io) catch {};
+ var store: [64]u8 = undefined;
+ var out: Io.Writer = .fixed(&store);
+ try testing.expectError(error.Hangup, f.readFile("event", &out));
+ try testing.expectEqualStrings("first\n", out.buffered());
+ try feeder.await(testing.io);
+}
+
+test "fsys: create, write, remove" {
+ const t = try testing.allocator.create(TestTree);
+ defer testing.allocator.destroy(t);
+ try t.start();
+ defer t.stop();
+ const f = try dialed(t, .unix);
+ defer hangUp(f);
+ const o = try f.create("/new", 0o600, c9.owrite);
+ try testing.expectEqual(@as(u32, 3), try f.write(o.fid, 0, "abc"));
+ f.clunk(o.fid);
+ try testing.expectError(error.Refused, f.create("new", 0o600, c9.owrite));
+ try testing.expectEqualStrings("File exists", f.said());
+ try f.remove("new");
+ try testing.expectError(error.Refused, f.stat("new"));
+ try testing.expectError(error.Refused, f.remove("README"));
+ // A name no message holds is not sent, and the walk sent ahead of it
+ // does not stand in the way of the next call.
+ const long: [9000]u8 = @splat('x');
+ try testing.expectError(error.Botch, f.create(&long, 0o600, c9.owrite));
+ try testing.expectEqualStrings("README", (try f.stat("README")).name);
+}
+
+test "fsys: a directory read decodes as entries" {
+ const t = try testing.allocator.create(TestTree);
+ defer testing.allocator.destroy(t);
+ try t.start();
+ defer t.stop();
+ const f = try dialed(t, .unix);
+ defer hangUp(f);
+ const o = try f.open("", c9.oread);
+ defer f.clunk(o.fid);
+ try testing.expect(o.qid.type & wire.qtdir != 0);
+ var names: [8][]const u8 = undefined;
+ var n: usize = 0;
+ var entries: Entries = .{ .bytes = try f.read(o.fid, 0, msize) };
+ while (try entries.next()) |st| : (n += 1) names[n] = st.name;
+ try testing.expectEqual(@as(usize, 7), n);
+ try testing.expectEqualStrings("README", names[0]);
+ try testing.expectEqualStrings("sub", names[6]);
+}
+
+test "fsys: dial by a name posted in the registry, and refuse a name that climbs out of it" {
+ var dir = testing.tmpDir(.{});
+ defer dir.cleanup();
+ var real: [std.fs.max_path_bytes]u8 = undefined;
+ const len = try dir.dir.realPath(testing.io, &real);
+ var var_buf: [std.fs.max_path_bytes + 32]u8 = undefined;
+ const runtime = try std.fmt.bufPrintSentinel(&var_buf, "XDG_RUNTIME_DIR={s}", .{real[0..len]}, 0);
+ const env = [_:null]?[*:0]const u8{runtime.ptr};
+ const t = try testing.allocator.create(TestTree);
+ defer testing.allocator.destroy(t);
+ try t.start();
+ defer t.stop();
+ try t.runner.listenPosted(&env, "c9test", 4);
+ const f = try testing.allocator.create(Fsys);
+ defer testing.allocator.destroy(f);
+ try f.dial(testing.io, &env, "c9test", "glenda");
+ defer f.close();
+ try testing.expectEqualStrings("README", (try f.stat("README")).name);
+ var g: Fsys = undefined;
+ try testing.expectError(error.BadAddress, g.dial(testing.io, &env, "../c9test", "glenda"));
+ try testing.expectError(error.NotRuntimeDir, g.dial(testing.io, &no_env, "c9test", "glenda"));
+}
diff --git a/src/TestTree.zig b/src/TestTree.zig
new file mode 100644
index 0000000..ad75c1f
--- /dev/null
+++ b/src/TestTree.zig
@@ -0,0 +1,232 @@
+//! A small tree served by `serve.Runner`, for the tests of Fsys.zig and
+//! verbs.zig: a README in the house shape, a ctl that refuses in words, a
+//! file longer than a message, one that answers a few bytes a read, one
+//! that answers what was written to it, an event file whose reads are
+//! held until the test feeds them, a directory, and room for one created
+//! file.
+const std = @import("std");
+const Io = std.Io;
+const testing = std.testing;
+const fs = @import("fs.zig");
+const serve = @import("serve.zig");
+const transport = @import("transport.zig");
+const post = @import("post.zig");
+
+const TestTree = @This();
+
+pub const Req = fs.Req;
+pub const Reply = fs.Reply;
+pub const features: fs.Features = .{ .create = true, .remove = true };
+pub const Runner = serve.Runner(TestTree, .{ .fid_capacity = 32, .slot_capacity = 4 }, .{ .msize = 8192, .connections = 2, .listeners = 3 });
+
+pub const readme =
+ \\A tree for tests.
+ \\
+ \\README this file
+ \\ctl write ok; anything else is refused in words
+ \\echo write a line, read it back heard
+ \\event reads wait for news
+ \\sub/ a directory
+ \\ of one file
+ \\sub/deep the file in it
+ \\
+ \\ cat ctl an example, not a file
+ \\
+;
+
+pub const big_len = 200_000;
+
+pub fn bigByte(i: usize) u8 {
+ return @intCast('a' + i % 23);
+}
+
+const Node = struct { name: []const u8, parent: u64, dir: bool = false, mode: u16 = 0o600 };
+const nodes = [_]Node{
+ .{ .name = "/", .parent = 1, .dir = true, .mode = 0o700 },
+ .{ .name = "README", .parent = 1, .mode = 0o400 },
+ .{ .name = "ctl", .parent = 1 },
+ .{ .name = "big", .parent = 1, .mode = 0o400 },
+ .{ .name = "short", .parent = 1, .mode = 0o400 },
+ .{ .name = "echo", .parent = 1 },
+ .{ .name = "event", .parent = 1 },
+ .{ .name = "sub", .parent = 1, .dir = true, .mode = 0o700 },
+ .{ .name = "deep", .parent = 8 },
+ .{ .name = "new", .parent = 1 },
+};
+const root = 1;
+const readme_node = 2;
+const ctl_node = 3;
+const big_node = 4;
+const short_node = 5;
+const echo_node = 6;
+const event_node = 7;
+const new_node = 10;
+const short_text = "a short answer, three bytes a read";
+
+mutex: Io.Mutex = .init,
+/// Whether `new` exists (made by a create, gone with a remove).
+made: bool = false,
+ctl: [64]u8 = undefined,
+ctl_len: usize = 0,
+heard: [128]u8 = undefined,
+heard_len: usize = 0,
+words: [fs.errmax]u8 = undefined,
+/// The read of `event` held, until `feed` answers it.
+held: ?struct { *Runner.Conn, fs.Ticket } = null,
+dir: testing.TmpDir = undefined,
+path_buf: [transport.sun_path_len]u8 = undefined,
+/// The listener's socket and the TCP address, once `start` returns.
+unix: [:0]const u8 = undefined,
+tcp: Io.net.IpAddress = undefined,
+runner: Runner = undefined,
+
+/// Serves the tree on a Unix socket in a temporary directory and on TCP
+/// at the loopback address.
+pub fn start(t: *TestTree) !void {
+ t.* = .{};
+ t.dir = testing.tmpDir(.{});
+ errdefer t.dir.cleanup();
+ var real: [std.fs.max_path_bytes]u8 = undefined;
+ const len = try t.dir.dir.realPath(testing.io, &real);
+ t.unix = try std.fmt.bufPrintSentinel(&t.path_buf, "{s}/9p", .{real[0..len]}, 0);
+ t.runner.init(.{ .io = testing.io, .root = root, .handler = .{ .ctx = t, .serve = serveFn } });
+ _ = try t.runner.listen(.{ .unix = t.unix }, 4);
+ t.tcp = try t.runner.listen(.{ .tcp = .{ .ip4 = .loopback(0) } }, 4);
+}
+
+pub fn stop(t: *TestTree) void {
+ t.runner.stop();
+ t.dir.cleanup();
+}
+
+/// Answers the held read of `event` with `chunk` once it is held (an empty
+/// chunk is the end of the file), or with null hangs its connection up.
+pub fn feed(t: *TestTree, chunk: ?[]const u8) !void {
+ var tries: usize = 0;
+ while (true) : (tries += 1) {
+ if (tries == 5000) return error.Timeout;
+ t.mutex.lockUncancelable(testing.io);
+ const got = t.held;
+ t.held = null;
+ t.mutex.unlock(testing.io);
+ const conn, const ticket = got orelse {
+ try testing.io.sleep(.fromMilliseconds(1), .awake);
+ continue;
+ };
+ const bytes = chunk orelse return conn.close();
+ const Make = struct {
+ fn make(b: *const []const u8) ?Runner.Conn.Answer {
+ return .{ .reply = .{ .tag = 0 }, .bytes = b.* };
+ }
+ };
+ _ = conn.answerWith(ticket, &bytes, Make.make);
+ return;
+ }
+}
+
+fn attrOf(t: *const TestTree, node: u64) fs.Attr {
+ const n = nodes[node - 1];
+ const size: u64 = switch (node) {
+ readme_node => readme.len,
+ big_node => big_len,
+ ctl_node => t.ctl_len,
+ else => 0,
+ };
+ return .{ .name = n.name, .node = node, .dir = n.dir, .mode = n.mode, .size = size };
+}
+
+fn serveFn(ctx: ?*anyopaque, conn: *Runner.Conn, req: fs.Req) void {
+ const t: *TestTree = @ptrCast(@alignCast(ctx.?));
+ if (req.op == .read and req.node == event_node) {
+ const ticket = conn.hold(&.{ .tag = req.tag, .status = .again }) orelse return;
+ t.mutex.lockUncancelable(testing.io);
+ defer t.mutex.unlock(testing.io);
+ t.held = .{ conn, ticket };
+ return;
+ }
+ var buf: [8192]u8 = undefined;
+ var bytes: []const u8 = "";
+ const reply = t.answer(req, &buf, &bytes);
+ conn.reply(&reply, bytes);
+}
+
+fn answer(t: *TestTree, req: fs.Req, buf: []u8, bytes: *[]const u8) fs.Reply {
+ const ok: fs.Reply = .{ .tag = req.tag };
+ switch (req.op) {
+ .lookup => {
+ if (std.mem.eql(u8, req.data, "..")) return .{ .tag = req.tag, .attr = t.attrOf(nodes[req.node - 1].parent) };
+ for (nodes, 1..) |n, node| {
+ if (node == new_node and !t.made) continue;
+ if (node != root and n.parent == req.node and std.mem.eql(u8, n.name, req.data))
+ return .{ .tag = req.tag, .attr = t.attrOf(node) };
+ }
+ return .fail(req.tag, fs.E.NOENT);
+ },
+ .getattr, .setattr => return .{ .tag = req.tag, .attr = t.attrOf(req.node) },
+ .open => {
+ if (!req.create) return ok;
+ if (req.node != root or !std.mem.eql(u8, req.data, "new") or t.made) return .fail(req.tag, fs.E.EXIST);
+ t.made = true;
+ return .{ .tag = req.tag, .attr = t.attrOf(new_node) };
+ },
+ .release => {
+ if (req.remove) {
+ if (req.node != new_node) return .fail(req.tag, fs.E.PERM);
+ t.made = false;
+ }
+ return ok;
+ },
+ .readdir => {
+ var w: Io.Writer = .fixed(buf);
+ var index: u64 = 0;
+ for (nodes, 1..) |n, node| {
+ if (node == root or n.parent != req.node or (node == new_node and !t.made)) continue;
+ defer index += 1;
+ if (index < req.off) continue;
+ w.writeInt(u64, node, .little) catch break;
+ w.writeByte(@intFromBool(n.dir)) catch break;
+ w.writeByte(@intCast(n.name.len)) catch break;
+ w.writeAll(n.name) catch break;
+ }
+ bytes.* = w.buffered();
+ return ok;
+ },
+ .read => {
+ const off: usize = @intCast(req.off);
+ bytes.* = switch (req.node) {
+ readme_node => readme[@min(off, readme.len)..],
+ ctl_node => t.ctl[@min(off, t.ctl_len)..t.ctl_len],
+ // A few bytes a read: a short read is not the end.
+ short_node => short_text[@min(off, short_text.len)..][0..@min(3, short_text.len -| off)],
+ echo_node => t.heard[@min(off, t.heard_len)..t.heard_len],
+ big_node => blk: {
+ const n = @min(big_len -| off, buf.len);
+ for (buf[0..n], off..) |*b, i| b.* = bigByte(i);
+ break :blk buf[0..n];
+ },
+ else => "",
+ };
+ bytes.* = bytes.*[0..@min(bytes.len, req.size)];
+ return ok;
+ },
+ .write => switch (req.node) {
+ ctl_node => {
+ const line = std.mem.trimEnd(u8, req.data, "\n");
+ if (!std.mem.eql(u8, line, "ok")) {
+ const words = std.fmt.bufPrint(&t.words, "unknown command: {s}", .{line}) catch &t.words;
+ return .{ .tag = req.tag, .status = .err, .errno = fs.E.INVAL, .ename = words };
+ }
+ t.ctl_len = @min(req.data.len, t.ctl.len);
+ @memcpy(t.ctl[0..t.ctl_len], req.data[0..t.ctl_len]);
+ return .{ .tag = req.tag, .written = @intCast(req.data.len) };
+ },
+ echo_node => {
+ const heard = std.fmt.bufPrint(&t.heard, "heard {s}", .{req.data}) catch return .fail(req.tag, fs.E.NOSPC);
+ t.heard_len = heard.len;
+ return .{ .tag = req.tag, .written = @intCast(req.data.len) };
+ },
+ event_node, new_node => return .{ .tag = req.tag, .written = @intCast(req.data.len) },
+ else => return .fail(req.tag, fs.E.PERM),
+ },
+ }
+}
diff --git a/src/root.zig b/src/root.zig
index 950fc26..8dc6132 100644
--- a/src/root.zig
+++ b/src/root.zig
@@ -52,8 +52,10 @@ pub const http = @import("http.zig");
pub const transport = @import("transport.zig");
pub const serve = @import("serve.zig");
pub const post = @import("post.zig");
+pub const Fsys = @import("Fsys.zig");
test {
_ = @import("post.zig");
+ _ = @import("Fsys.zig");
}
pub const Quic = @import("quic.zig").Quic;
test {