path: root/src/session_test.zig

const std = @import("std");
const testing = std.testing;
const c9 = @import("root.zig");
const Pair = struct {
    client_in: [4096]u8 = undefined,
    client_out: [4096]u8 = undefined,
    server_in: [4096]u8 = undefined,
    server_out: [8192]u8 = undefined,
    client: c9.Client = undefined,
    server: c9.Server = undefined,

    fn init(p: *Pair) !void {
        p.client = .init(.{ .in = &p.client_in, .out = &p.client_out });
        p.server = .init(.{ .in = &p.server_in, .out = &p.server_out });
        _ = try p.client.submit(.{ .version = .{} });
        const request = try p.nextRequest();
        try p.server.negotiate(request.msg.tversion.msize, request.msg.tversion.version);
        p.server.release();
        try testing.expectEqual(c9.Client.Op.version, (try p.nextResult()).op);
    }

    fn nextRequest(p: *Pair) !c9.Decoded {
        // Exercise every frame boundary through single-byte delivery.
        while (p.client.output().len != 0) {
            try testing.expectEqual(@as(usize, 1), p.server.push(p.client.output()[0..1]));
            p.client.wrote(1);
            if (try p.server.receive()) |request| return request;
        }
        return (try p.server.receive()) orelse error.NoRequest;
    }

    fn nextResult(p: *Pair) !c9.Client.Done {
        while (p.server.output().len != 0) {
            try testing.expectEqual(@as(usize, 1), p.client.push(p.server.output()[0..1]));
            p.server.wrote(1);
            if (p.client.take()) |result| return result;
        }
        return p.client.take() orelse error.NoResult;
    }

    fn exchange(p: *Pair, req: c9.Client.Request, response: c9.Msg) !void {
        const tag = try p.client.submit(req);
        const request = try p.nextRequest();
        try testing.expectEqual(tag, request.tag);
        try p.server.reply(tag, response);
        p.server.release();
        const result = try p.nextResult();
        try testing.expectEqual(std.meta.activeTag(req), result.op);
        try testing.expectEqualStrings(@tagName(req), @tagName(result.result));
    }
};

const qid: c9.Qid = .{ .type = 0, .version = 1, .path = 2 };
const stat: c9.Stat = .{
    .type = 0,
    .dev = 0,
    .qid = qid,
    .mode = 0o600,
    .atime = 0,
    .mtime = 0,
    .length = 0,
    .name = "file",
    .uid = "user",
    .gid = "group",
    .muid = "user",
};

test "all base 9P2000 client operations through fragmented server transport" {
    var p: Pair = .{};
    try p.init();
    try p.exchange(.{ .auth = .{ .afid = 1, .uname = "user" } }, .{ .rauth = .{ .aqid = qid } });
    try p.exchange(.{ .attach = .{ .fid = 2, .afid = 1, .uname = "user" } }, .{ .rattach = .{ .qid = qid } });
    try p.exchange(.{ .walk = .{ .fid = 2, .newfid = 3, .names = &.{"file"} } }, .{ .rwalk = .{ .nwqid = 1, .wqid = @splat(qid) } });
    try p.exchange(.{ .open = .{ .fid = 3, .mode = 2 } }, .{ .ropen = .{ .qid = qid, .iounit = 0 } });
    try p.exchange(.{ .create = .{ .fid = 2, .name = "new", .perm = 0o600, .mode = 2 } }, .{ .rcreate = .{ .qid = qid, .iounit = 0 } });
    try p.exchange(.{ .read = .{ .fid = 3, .offset = 0, .count = 3 } }, .{ .rread = .{ .data = "abc" } });
    try p.exchange(.{ .write = .{ .fid = 3, .offset = 0, .data = "abc" } }, .{ .rwrite = .{ .count = 2 } });
    try p.exchange(.{ .stat = .{ .fid = 3 } }, .{ .rstat = .{ .stat = stat } });
    try p.exchange(.{ .wstat = .{ .fid = 3, .stat = stat } }, .rwstat);
    try p.exchange(.{ .clunk = .{ .fid = 3 } }, .rclunk);
    try p.exchange(.{ .remove = .{ .fid = 2 } }, .rremove);
    try p.exchange(.{ .flush = .{ .oldtag = 42 } }, .rflush);
}

test "flush holds oldtag until Rflush, including a completed original request" {
    for ([_]bool{ false, true }) |complete| {
        var p: Pair = .{};
        try p.init();
        const oldtag = try p.client.submit(.{ .read = .{ .fid = 1, .offset = 0, .count = 1 } });
        _ = try p.nextRequest();
        p.server.release();
        const flush = try p.client.submit(.{ .flush = .{ .oldtag = oldtag } });
        _ = try p.nextRequest();
        p.server.release();
        if (complete) {
            try p.server.reply(oldtag, .{ .rread = .{ .data = "x" } });
            try testing.expectEqual(oldtag, (try p.nextResult()).tag);
            try testing.expectEqual(@as(usize, 2), p.client.pending());
        }
        const other = try p.client.submit(.{ .stat = .{ .fid = 1 } });
        try testing.expect(other != oldtag and other != flush);
        try p.server.reply(flush, .rflush);
        try testing.expectEqual(flush, (try p.nextResult()).tag);
        try testing.expectEqual(@as(usize, 1), p.client.pending());
        try testing.expectError(error.UnknownTag, p.server.reply(oldtag, .{ .rread = .{ .data = "x" } }));
        const reused = try p.client.submit(.{ .stat = .{ .fid = 1 } });
        try testing.expectEqual(oldtag, reused);
    }
}

test "response bounds and reply types are checked before output is changed" {
    var p: Pair = .{};
    try p.init();
    const tag = try p.client.submit(.{ .write = .{ .fid = 1, .offset = 0, .data = "a" } });
    _ = try p.nextRequest();
    p.server.release();
    try testing.expectError(error.WrongReply, p.server.reply(tag, .{ .rwrite = .{ .count = 2 } }));
    try testing.expectError(error.WrongReply, p.server.reply(tag, .rclunk));
    try testing.expectEqual(@as(usize, 0), p.server.output().len);
    try p.server.reply(tag, .{ .rwrite = .{ .count = 1 } });
    _ = try p.nextResult();
}

test "stat outer length overflow is rejected without writing output" {
    var name: [65535 - 48]u8 = @splat('a');
    var entry = stat;
    entry.name = &name;
    entry.uid = "";
    entry.gid = "";
    entry.muid = "";
    var buffer: [65550]u8 = @splat(0xaa);
    try testing.expectError(error.Overlong, c9.encode(.{ .rstat = .{ .stat = entry } }, 1, &buffer));
    try testing.expect(std.mem.allEqual(u8, &buffer, 0xaa));
}

test "arbitrary input decoder round trip" {
    try testing.fuzz({}, fuzzDecode, .{});
}

fn fuzzDecode(_: void, smith: *testing.Smith) !void {
    var input_buffer: [65536]u8 = undefined;
    const input = input_buffer[0..smith.slice(&input_buffer)];
    const decoded = c9.decode(input) catch return;
    var buffer: [65536]u8 = undefined;
    const encoded = try c9.encode(decoded.msg, decoded.tag, &buffer);
    try testing.expectEqualSlices(u8, input, encoded);
}

test "flush can cancel a full request window and reserves unused oldtags" {
    var p: Pair = .{};
    try p.init();
    _ = try p.client.submit(.{ .flush = .{ .oldtag = 2 } });
    const next = try p.client.submit(.{ .stat = .{ .fid = 0 } });
    try testing.expect(next != 2);
    const third = try p.client.submit(.{ .stat = .{ .fid = 0 } });
    try testing.expect(third != 2);
    p.client.hangup();
    try p.init();
    for (0..c9.max_tags) |_| _ = try p.client.submit(.{ .stat = .{ .fid = 0 } });
    try testing.expectError(error.NoTags, p.client.submit(.{ .stat = .{ .fid = 0 } }));
    const flush = try p.client.submit(.{ .flush = .{ .oldtag = 0 } });
    try testing.expectEqual(@as(u16, c9.max_tags), flush);
}

test "multiple flushes retain reservations until each response and can themselves be flushed" {
    var p: Pair = .{};
    try p.init();
    const oldtag = try p.client.submit(.{ .read = .{ .fid = 1, .offset = 0, .count = 1 } });
    _ = try p.nextRequest();
    p.server.release();
    const first = try p.client.submit(.{ .flush = .{ .oldtag = oldtag } });
    _ = try p.nextRequest();
    p.server.release();
    const second = try p.client.submit(.{ .flush = .{ .oldtag = oldtag } });
    _ = try p.nextRequest();
    p.server.release();
    try p.server.reply(first, .rflush);
    _ = try p.nextResult();
    const held = try p.client.submit(.{ .stat = .{ .fid = 1 } });
    try testing.expect(held != oldtag);
    try p.server.reply(second, .rflush);
    _ = try p.nextResult();
    try testing.expectEqual(oldtag, try p.client.submit(.{ .stat = .{ .fid = 1 } }));

    try p.init();
    const read_tag = try p.client.submit(.{ .read = .{ .fid = 1, .offset = 0, .count = 1 } });
    _ = try p.nextRequest();
    p.server.release();
    const flush_tag = try p.client.submit(.{ .flush = .{ .oldtag = read_tag } });
    _ = try p.nextRequest();
    p.server.release();
    const cancel_flush = try p.client.submit(.{ .flush = .{ .oldtag = flush_tag } });
    _ = try p.nextRequest();
    p.server.release();
    try p.server.reply(read_tag, .{ .rread = .{ .data = "x" } });
    _ = try p.nextResult();
    try p.server.reply(cancel_flush, .rflush);
    _ = try p.nextResult();
    try testing.expectEqual(@as(usize, 0), p.client.pending());
}

test "server reserves cancellation capacity and rejects duplicate pending tags" {
    var input: [4096]u8 = undefined;
    var output: [4096]u8 = undefined;
    var server: c9.Server = .init(.{ .in = &input, .out = &output });
    server.msize = 4096;
    var frame: [64]u8 = undefined;
    for (0..64) |i| {
        const bytes = try c9.encode(.{ .tstat = .{ .fid = 1 } }, @intCast(i), &frame);
        _ = server.push(bytes);
        _ = (try server.receive()).?;
        server.release();
    }
    _ = server.push(try c9.encode(.{ .tflush = .{ .oldtag = 0 } }, 100, &frame));
    _ = (try server.receive()).?;
    server.release();
    try server.reply(100, .rflush);
    server.wrote(server.output().len);
    _ = server.push(try c9.encode(.{ .tstat = .{ .fid = 1 } }, 1, &frame));
    try testing.expectError(error.Protocol, server.receive());
    try testing.expect(server.dead);
}

test "client: an msize below the floor, and one the server tried to raise" {
    var in: [512]u8 = undefined;
    var out: [512]u8 = undefined;
    var buf: [64]u8 = undefined;

    var c = c9.Client.init(.{ .in = &in, .out = &out });
    try testing.expectError(error.BadRequest, c.submit(.{ .version = .{ .msize = c9.Server.msize_min - 1 } }));
    _ = try c.submit(.{ .version = .{} });
    try testing.expectEqual(@as(u32, 512), c.asked);

    _ = c.push(try c9.encode(.{ .rversion = .{ .msize = 1024, .version = "9P2000" } }, c9.notag, &buf));
    try testing.expect(c.take() == null);
    try testing.expect(c.dead);

    var c2 = c9.Client.init(.{ .in = &in, .out = &out });
    _ = try c2.submit(.{ .version = .{} });
    _ = c2.push(try c9.encode(.{ .rversion = .{ .msize = 512, .version = "unknown" } }, c9.notag, &buf));
    const done = c2.take() orelse return error.NoReply;
    try testing.expectEqualStrings("unknown", done.result.version.version);
    try testing.expect(!c2.dead);
    try testing.expectEqual(@as(u32, 0), c2.msize);
    try testing.expectError(error.Handshake, c2.submit(.{ .stat = .{ .fid = 0 } }));

    var c3 = c9.Client.init(.{ .in = &in, .out = &out });
    _ = try c3.submit(.{ .version = .{} });
    _ = c3.push(try c9.encode(.{ .rversion = .{ .msize = 512, .version = "9P2000.u" } }, c9.notag, &buf));
    try testing.expect(c3.take() == null);
    try testing.expect(c3.dead);
}

test "client: what is not an answer to one of our requests ends the connection" {
    var buf: [64]u8 = undefined;
    const Case = struct {
        fn armed(in: []u8, out: []u8, scratch: []u8) !c9.Client {
            var c = c9.Client.init(.{ .in = in, .out = out });
            _ = try c.submit(.{ .version = .{} });
            c.wrote(c.output().len);
            _ = c.push(try c9.encode(.{ .rversion = .{ .msize = 512, .version = "9P2000" } }, c9.notag, scratch));
            _ = c.take() orelse return error.NoReply;
            _ = try c.submit(.{ .stat = .{ .fid = 0 } });
            c.wrote(c.output().len);
            return c;
        }
    };
    var in: [512]u8 = undefined;
    var out: [512]u8 = undefined;

    {
        var c = try Case.armed(&in, &out, &buf);
        _ = c.push(try c9.encode(.{ .tstat = .{ .fid = 0 } }, 0, &buf));
        try testing.expect(c.take() == null);
        try testing.expect(c.dead);
    }
    {
        var c = try Case.armed(&in, &out, &buf);
        _ = c.push(try c9.encode(.rclunk, 3, &buf));
        try testing.expect(c.take() == null);
        try testing.expect(c.dead);
    }
    {
        var c = try Case.armed(&in, &out, &buf);
        _ = c.push(try c9.encode(.rclunk, 900, &buf));
        try testing.expect(c.take() == null);
        try testing.expect(c.dead);
    }
    {
        var c = try Case.armed(&in, &out, &buf);
        _ = c.push(try c9.encode(.rclunk, 0, &buf));
        try testing.expect(c.take() == null);
        try testing.expect(c.dead);
    }
    {
        var c = try Case.armed(&in, &out, &buf);
        _ = c.push(try c9.encode(.rwstat, 0, &buf));
        try testing.expect(c.take() == null);
        try testing.expect(c.dead);
    }
    {
        var c = try Case.armed(&in, &out, &buf);
        _ = c.push(&.{ 3, 0, 0, 0 });
        try testing.expect(c.take() == null);
        try testing.expect(c.dead);
    }
    {
        var c = try Case.armed(&in, &out, &buf);
        _ = c.push(&.{ 0, 4, 0, 0 });
        try testing.expect(c.take() == null);
        try testing.expect(c.dead);
    }
    {
        var c = try Case.armed(&in, &out, &buf);
        _ = c.push(&.{ 8, 0, 0, 0, @intFromEnum(c9.Type.rstat), 0, 0, 0 });
        try testing.expect(c.take() == null);
        try testing.expect(c.dead);
    }
}

test "client: session memory is bounded independently of input" {
    try testing.expect(@sizeOf(c9.Client) <= 512);
    try testing.expect(2 * 8192 + @sizeOf(c9.Client) <= 17 * 1024);
    try testing.expect(2 * c9.Server.msize_min + @sizeOf(c9.Client) <= 700);
}