1 files changed, 39 insertions, 0 deletions

diff --git a/src/ninep/pty.zig b/src/ninep/pty.zig
index d32c35fd..8ba9f4df 100644
--- a/src/ninep/pty.zig
+++ b/src/ninep/pty.zig
@@ -61,6 +61,10 @@ pub fn writeCtl(p: *Pardes, req: Req, id: usize) Reply {
         while (it.next()) |raw| {
             const line = std.mem.trim(u8, raw, " \t\r");
             if (line.len == 0) continue;
+            // A command pane's child is its command, done or running: exec
+            // would run its line again with no header, footer or records.
+            if (!apply and std.mem.eql(u8, line, "exec")) if (p.panes[id]) |pane| if (pane.command != null)
+                return tree.failText(req.tag, E.INVAL, "invalid exec: a command pane does not restart");
             // A shell restarted where the directory is gone would not start:
             // refused before anything runs, as Tty there is.
             if (!apply and std.mem.eql(u8, line, "exec")) if (p.panes[id]) |pane| if (pardes.exec.missingDir(p, pane.cwdSlice())) {
@@ -204,6 +208,12 @@ fn answer(p: *Pardes, slot: *Run, comptime fmt: []const u8, args: anytype) void
 pub fn writeRun(p: *Pardes, req: Req, id: usize, pane: *Pane) Reply {
     const slot = &(tree.openOf(p, req) orelse return Reply.fail(req.tag, E.INVAL)).what.run;
     if (slot.phase == .sent or slot.phase == .waiting) return tree.failText(req.tag, E.BUSY, tree.e_in_use);
+    // One line a run, its answer read before the next: a second line (bash
+    // writes printf 'a\nb\n' a line at a time) would run and lose the
+    // first's answer.
+    const one = std.mem.trimEnd(u8, req.data, "\r\n");
+    if (std.mem.indexOfScalar(u8, one, '\n') != null or (slot.phase == .done and slot.read == 0))
+        return tree.failText(req.tag, E.INVAL, e_one_line);
     // A new line on this open: a new answer.
     p.gpa.free(slot.output);
     p.gpa.free(slot.line);
@@ -421,6 +431,7 @@ fn waitingRun(p: *Pardes, pane: *Pane) ?*Run {
 }
 
 const e_bad_line = "bad command line";
+const e_one_line = "invalid run: one line a run, its answer read before the next";
 const e_bad_pty_ctl = tree.e_bad_ctl ++ "; takes winsize COLS ROWS, sig INT|TERM|HUP|QUIT|KILL, or exec";
 
 pub fn readData(p: *Pardes, req: Req, pf: *pane_files.State) Reply {
@@ -1087,3 +1098,31 @@ test "a run's answer longer than its room is cut, its newline kept" {
     try testing.expectEqual(slot.answer.len, slot.len);
     try testing.expectEqual(@as(u8, '\n'), slot.answer[slot.len - 1]);
 }
+
+test "exec on a command pane is refused: a command pane does not restart" {
+    const p = try th.withTerm(testing.allocator);
+    defer p.deinit();
+    const serial = th.serialOf(p);
+    const pane = p.panes[p.paneBySerial(serial).?].?;
+    pane.command = try p.gpa.dupe(u8, "echo hi");
+    const r = th.wr(p, tree.Node.of(serial, .pty_ctl), "exec\n");
+    try testing.expectEqual(tree.E.INVAL, r.errno());
+    try testing.expectEqualStrings("invalid exec: a command pane does not restart", r.reply.ename);
+}
+
+test "pty/run takes one line a run: two in one write, or a second before the first's answer is read, are refused" {
+    const p = try th.withTerm(testing.allocator);
+    defer p.deinit();
+    const serial = th.serialOf(p);
+    const run = tree.Node.of(serial, .pty_run);
+    const h = th.call(p, .{ .tag = 1, .op = .open, .node = run, .omode = 2 }).reply.handle;
+    const two = th.call(p, .{ .tag = 2, .op = .write, .node = run, .handle = h, .data = "true\nfalse\n" });
+    try testing.expectEqual(tree.E.INVAL, two.errno());
+    try testing.expectEqualStrings(e_one_line, two.reply.ename);
+    // A finished run whose answer nobody read takes no next line.
+    const slot = &tree.openOf(p, .{ .tag = 0, .op = .read, .node = run, .handle = h }).?.what.run;
+    slot.phase = .done;
+    slot.len = 7;
+    try testing.expectEqual(tree.E.INVAL, th.call(p, .{ .tag = 3, .op = .write, .node = run, .handle = h, .data = "true\n" }).errno());
+    _ = th.call(p, .{ .tag = 4, .op = .release, .node = run, .handle = h, .opened = true });
+}