mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-20 15:19:16 +00:00
1985 lines
61 KiB
JavaScript
1985 lines
61 KiB
JavaScript
const test = require("node:test");
|
|
const assert = require("node:assert/strict");
|
|
const fs = require("node:fs");
|
|
const os = require("node:os");
|
|
const path = require("node:path");
|
|
const {
|
|
createZmodemSentry,
|
|
buildUploadPlan,
|
|
buildModeRestores,
|
|
handleUpload,
|
|
handleDownload,
|
|
waitForWritableDrain,
|
|
createZmodemUploadDrainWaiter,
|
|
awaitUploadDrainWithProgress,
|
|
UPLOAD_CHUNK_SIZE,
|
|
UPLOAD_DRAIN_TIMEOUT_MS,
|
|
} = require("./zmodemHelper.cjs");
|
|
|
|
const never = () => { throw new Error("resolver should not be called"); };
|
|
|
|
test("no conflicts: all indices offered, none removed, resolver untouched", async () => {
|
|
const plan = await buildUploadPlan(["a.txt", "b.txt"], [], never);
|
|
assert.deepEqual(plan, { offerIndices: [0, 1], removeIndices: [], aborted: false });
|
|
});
|
|
|
|
test("overwrite a conflict: index both removed and offered", async () => {
|
|
const plan = await buildUploadPlan(["a.txt", "b.txt"], ["b.txt"], async () => ({ action: "overwrite" }));
|
|
assert.deepEqual(plan, { offerIndices: [0, 1], removeIndices: [1], aborted: false });
|
|
});
|
|
|
|
test("skip a conflict: index omitted from offer and remove", async () => {
|
|
const plan = await buildUploadPlan(["a.txt", "b.txt"], ["b.txt"], async () => ({ action: "skip" }));
|
|
assert.deepEqual(plan, { offerIndices: [0], removeIndices: [], aborted: false });
|
|
});
|
|
|
|
test("cancel aborts the whole transfer", async () => {
|
|
const plan = await buildUploadPlan(["a.txt", "b.txt"], ["b.txt"], async () => ({ action: "cancel" }));
|
|
assert.deepEqual(plan, { offerIndices: [], removeIndices: [], aborted: true });
|
|
});
|
|
|
|
test("applyToRest reuses the action and stops prompting", async () => {
|
|
let calls = 0;
|
|
const plan = await buildUploadPlan(["a", "b", "c"], ["a", "b", "c"],
|
|
async () => { calls++; return { action: "overwrite", applyToRest: true }; });
|
|
assert.equal(calls, 1);
|
|
assert.deepEqual(plan, { offerIndices: [0, 1, 2], removeIndices: [0, 1, 2], aborted: false });
|
|
});
|
|
|
|
test("only conflicting files invoke the resolver; order preserved", async () => {
|
|
const seen = [];
|
|
const plan = await buildUploadPlan(["a", "b", "c"], ["b"],
|
|
async (n) => { seen.push(n); return { action: "skip" }; });
|
|
assert.deepEqual(seen, ["b"]);
|
|
assert.deepEqual(plan.offerIndices, [0, 2]);
|
|
});
|
|
|
|
test("duplicate basenames keep independent per-file decisions", async () => {
|
|
// Two different local files share a basename; skip the first, overwrite the second.
|
|
const actions = ["skip", "overwrite"];
|
|
let i = 0;
|
|
const plan = await buildUploadPlan(["x.txt", "x.txt"], ["x.txt"],
|
|
async () => ({ action: actions[i++] }));
|
|
assert.deepEqual(plan, { offerIndices: [1], removeIndices: [1], aborted: false });
|
|
});
|
|
|
|
// Issue #1079: overwriting (rm + rz re-create) drops the original permission
|
|
// bits. buildModeRestores resolves which overwritten files to chmod back.
|
|
|
|
test("buildModeRestores maps overwritten files to their captured modes", () => {
|
|
assert.deepEqual(
|
|
buildModeRestores("/home/u", ["a.sh", "b.txt"], [0], { "a.sh": "755" }),
|
|
[{ path: "/home/u/a.sh", mode: "755" }],
|
|
);
|
|
});
|
|
|
|
test("buildModeRestores skips files whose mode was not captured", () => {
|
|
assert.deepEqual(
|
|
buildModeRestores("/srv", ["a", "b"], [0, 1], { a: "644" }),
|
|
[{ path: "/srv/a", mode: "644" }],
|
|
);
|
|
});
|
|
|
|
test("buildModeRestores strips trailing slashes and dedupes duplicate basenames", () => {
|
|
assert.deepEqual(
|
|
buildModeRestores("/srv//", ["x", "x"], [0, 1], { x: "600" }),
|
|
[{ path: "/srv/x", mode: "600" }],
|
|
);
|
|
});
|
|
|
|
test("queued drag-drop upload keeps temp files until cancel", () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const tempPath = path.join(tempDir, "upload.txt");
|
|
fs.writeFileSync(tempPath, "payload");
|
|
|
|
const sentry = createZmodemSentry({
|
|
sessionId: "session-1",
|
|
onData: () => {},
|
|
writeToRemote: () => true,
|
|
getWebContents: () => null,
|
|
});
|
|
|
|
sentry.queueDragDropUpload({
|
|
filePaths: [tempPath],
|
|
remoteNames: ["upload.txt"],
|
|
tempPaths: [tempPath],
|
|
});
|
|
|
|
assert.equal(fs.existsSync(tempPath), true);
|
|
sentry.cancel();
|
|
assert.equal(fs.existsSync(tempPath), false);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("queued drag-drop upload interrupts the remote command when cancelled before detect", () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const tempPath = path.join(tempDir, "upload.txt");
|
|
fs.writeFileSync(tempPath, "payload");
|
|
const writes = [];
|
|
let interrupted = false;
|
|
|
|
const sentry = createZmodemSentry({
|
|
sessionId: "session-1",
|
|
onData: () => {},
|
|
writeToRemote: (buf) => {
|
|
writes.push(Buffer.from(buf));
|
|
return true;
|
|
},
|
|
interruptRemote: () => {
|
|
interrupted = true;
|
|
},
|
|
getWebContents: () => null,
|
|
dragDropStartTimeoutMs: 0,
|
|
});
|
|
|
|
sentry.queueDragDropUpload({
|
|
filePaths: [tempPath],
|
|
remoteNames: ["upload.txt"],
|
|
tempPaths: [tempPath],
|
|
});
|
|
sentry.cancel();
|
|
|
|
assert.equal(fs.existsSync(tempPath), false);
|
|
assert.equal(interrupted, true);
|
|
assert.equal(writes[0].toString("utf8"), "rz -y\r");
|
|
assert.deepEqual([...writes[1]], [0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18]);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("queued drag-drop upload cleans temp files when rz never starts", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const tempPath = path.join(tempDir, "upload.txt");
|
|
fs.writeFileSync(tempPath, "payload");
|
|
const writes = [];
|
|
|
|
const sentry = createZmodemSentry({
|
|
sessionId: "session-1",
|
|
onData: () => {},
|
|
writeToRemote: (buf) => {
|
|
writes.push(Buffer.from(buf));
|
|
return true;
|
|
},
|
|
getWebContents: () => null,
|
|
dragDropStartTimeoutMs: 1,
|
|
});
|
|
|
|
sentry.queueDragDropUpload({
|
|
filePaths: [tempPath],
|
|
remoteNames: ["upload.txt"],
|
|
tempPaths: [tempPath],
|
|
});
|
|
|
|
await new Promise((resolve) => setTimeout(resolve, 20));
|
|
assert.equal(fs.existsSync(tempPath), false);
|
|
assert.equal(writes[0].toString("utf8"), "rz -y\r");
|
|
assert.deepEqual([...writes[1]], [0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18]);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("queued drag-drop upload rejects a second pending upload", () => {
|
|
const sentry = createZmodemSentry({
|
|
sessionId: "session-1",
|
|
onData: () => {},
|
|
writeToRemote: () => true,
|
|
getWebContents: () => null,
|
|
});
|
|
|
|
sentry.queueDragDropUpload({
|
|
filePaths: ["/tmp/first.txt"],
|
|
remoteNames: ["first.txt"],
|
|
});
|
|
|
|
assert.throws(
|
|
() => sentry.queueDragDropUpload({
|
|
filePaths: ["/tmp/second.txt"],
|
|
remoteNames: ["second.txt"],
|
|
}),
|
|
/already pending/,
|
|
);
|
|
sentry.cancel({ interrupt: false });
|
|
});
|
|
|
|
test("queued drag-drop upload cleans temp files when command write fails", () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const firstTempPath = path.join(tempDir, "first.txt");
|
|
const secondTempPath = path.join(tempDir, "second.txt");
|
|
fs.writeFileSync(firstTempPath, "first");
|
|
fs.writeFileSync(secondTempPath, "second");
|
|
|
|
const sentry = createZmodemSentry({
|
|
sessionId: "session-1",
|
|
onData: () => {},
|
|
writeToRemote: () => {
|
|
throw new Error("socket closed");
|
|
},
|
|
getWebContents: () => null,
|
|
});
|
|
|
|
assert.throws(
|
|
() => sentry.queueDragDropUpload({
|
|
filePaths: [firstTempPath],
|
|
remoteNames: ["first.txt"],
|
|
tempPaths: [firstTempPath],
|
|
}),
|
|
/socket closed/,
|
|
);
|
|
assert.equal(fs.existsSync(firstTempPath), false);
|
|
|
|
assert.throws(
|
|
() => sentry.queueDragDropUpload({
|
|
filePaths: [secondTempPath],
|
|
remoteNames: ["second.txt"],
|
|
tempPaths: [secondTempPath],
|
|
}),
|
|
/socket closed/,
|
|
);
|
|
assert.equal(fs.existsSync(secondTempPath), false);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
// Issue #3423: after a drag-drop upload falls back to SFTP (rz missing, no
|
|
// ZMODEM detection), a stale command-echo suppression must not strip matched
|
|
// prefixes from the user's next typed command echo — the reporter's
|
|
// "su - username -s /bin/bash" rendered as "u - username -s /bin/bas".
|
|
test("stale drag-drop echo suppression is dropped when the pending upload is cancelled", () => {
|
|
const seen = [];
|
|
const sentry = createZmodemSentry({
|
|
sessionId: "session-1",
|
|
onData: (buf) => seen.push(Buffer.from(buf).toString("utf8")),
|
|
writeToRemote: () => true,
|
|
getWebContents: () => null,
|
|
});
|
|
const uploadCommand =
|
|
"sh -lc 'if command -v rz >/dev/null 2>&1; then exec rz -y; else printf marker; fi'\r";
|
|
|
|
sentry.queueDragDropUpload({
|
|
filePaths: ["/tmp/a.txt"],
|
|
remoteNames: ["a.txt"],
|
|
uploadCommand,
|
|
});
|
|
|
|
// The shell echo of the long upload command is split across two transport
|
|
// chunks with the prompt glued in front, so neither the full match nor the
|
|
// chunk-prefix partial match can consume the suppression — it leaks.
|
|
sentry.consume(Buffer.from("root@host:~# sh -lc 'if command -v rz >/dev/null"));
|
|
sentry.consume(Buffer.from(" 2>&1; then exec rz -y; else printf marker; fi'\r\n"));
|
|
seen.length = 0;
|
|
|
|
// rz missing → renderer watches the marker, falls back to SFTP, cancels.
|
|
sentry.cancel({ interrupt: false });
|
|
|
|
// User types the next command after the upload finishes.
|
|
sentry.consume(Buffer.from("su - username -s /bin/bas"));
|
|
sentry.consume(Buffer.from("h"));
|
|
assert.deepEqual(seen, ["su - username -s /bin/bas", "h"]);
|
|
});
|
|
|
|
test("drag-drop echo suppression expires instead of eating later user echo", async (t) => {
|
|
const seen = [];
|
|
const sentry = createZmodemSentry({
|
|
sessionId: "session-1",
|
|
onData: (buf) => seen.push(Buffer.from(buf).toString("utf8")),
|
|
writeToRemote: () => true,
|
|
getWebContents: () => null,
|
|
pendingTerminalSuppressionTtlMs: 0,
|
|
});
|
|
t.after(() => sentry.cancel({ interrupt: false }));
|
|
|
|
sentry.queueDragDropUpload({
|
|
filePaths: ["/tmp/a.txt"],
|
|
remoteNames: ["a.txt"],
|
|
uploadCommand: "sh -lc 'if command -v rz >/dev/null 2>&1; then exec rz -y; fi'\r",
|
|
});
|
|
// Split echo is never fully matched, so the suppression stays armed.
|
|
sentry.consume(Buffer.from("root@host:~# sh -lc 'if command -v rz >/dev/null"));
|
|
sentry.consume(Buffer.from(" 2>&1; then exec rz -y; fi'"));
|
|
|
|
await new Promise((resolve) => setTimeout(resolve, 5));
|
|
|
|
seen.length = 0;
|
|
sentry.consume(Buffer.from("su - username -s /bin/bash"));
|
|
assert.deepEqual(seen, ["su - username -s /bin/bash"]);
|
|
});
|
|
|
|
test("drag-drop echo suppression still hides the upload command echo", () => {
|
|
const seen = [];
|
|
const sentry = createZmodemSentry({
|
|
sessionId: "session-1",
|
|
onData: (buf) => seen.push(Buffer.from(buf).toString("utf8")),
|
|
writeToRemote: () => true,
|
|
getWebContents: () => null,
|
|
});
|
|
|
|
sentry.queueDragDropUpload({
|
|
filePaths: ["/tmp/a.txt"],
|
|
remoteNames: ["a.txt"],
|
|
uploadCommand: "rz -y\r",
|
|
});
|
|
// Echo flushed as its own chunk right after the write — must be suppressed.
|
|
sentry.consume(Buffer.from("rz -y"));
|
|
assert.deepEqual(seen, []);
|
|
|
|
// Later user input is untouched.
|
|
sentry.consume(Buffer.from("ls -l"));
|
|
assert.deepEqual(seen, ["ls -l"]);
|
|
sentry.cancel({ interrupt: false });
|
|
});
|
|
|
|
test("handleUpload completes when the remote confirms after progress reaches 100 percent", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const filePath = path.join(tempDir, "upload.txt");
|
|
fs.writeFileSync(filePath, "payload");
|
|
const events = [];
|
|
let closed = false;
|
|
let endCalled = false;
|
|
|
|
const zsession = {
|
|
async send_offer() {
|
|
return {
|
|
send() {},
|
|
async end() {
|
|
endCalled = true;
|
|
},
|
|
};
|
|
},
|
|
async close() {
|
|
closed = true;
|
|
},
|
|
};
|
|
|
|
await handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => ({
|
|
isDestroyed: () => false,
|
|
send: (channel, data) => events.push({ channel, data }),
|
|
}),
|
|
takeDragDropUpload: () => ({
|
|
filePaths: [filePath],
|
|
remoteNames: ["upload.txt"],
|
|
}),
|
|
});
|
|
|
|
assert.equal(endCalled, true);
|
|
assert.equal(closed, true);
|
|
assert.equal(
|
|
events.some((event) => event.channel === "netcatty:zmodem:progress" && event.data.finalizing === true),
|
|
true,
|
|
);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("handleUpload does not read the next chunk until transport backpressure clears", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-drain-"));
|
|
const filePath = path.join(tempDir, "large-upload.bin");
|
|
fs.writeFileSync(filePath, Buffer.alloc(UPLOAD_CHUNK_SIZE + 1, 0x5a));
|
|
const sentChunkSizes = [];
|
|
const progress = [];
|
|
let releaseFirstDrain;
|
|
const firstDrain = new Promise((resolve) => {
|
|
releaseFirstDrain = resolve;
|
|
});
|
|
let drainCalls = 0;
|
|
|
|
const zsession = {
|
|
async send_offer() {
|
|
return {
|
|
send(chunk) {
|
|
sentChunkSizes.push(chunk.byteLength);
|
|
},
|
|
async end() {},
|
|
};
|
|
},
|
|
async close() {},
|
|
};
|
|
|
|
const upload = handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => ({
|
|
isDestroyed: () => false,
|
|
send(channel, data) {
|
|
if (channel === "netcatty:zmodem:progress") progress.push(data);
|
|
},
|
|
}),
|
|
takeDragDropUpload: () => ({
|
|
filePaths: [filePath],
|
|
remoteNames: ["large-upload.bin"],
|
|
}),
|
|
async waitForDrain() {
|
|
drainCalls += 1;
|
|
if (drainCalls === 1) await firstDrain;
|
|
},
|
|
});
|
|
|
|
while (drainCalls === 0) {
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
}
|
|
assert.deepEqual(sentChunkSizes, [UPLOAD_CHUNK_SIZE]);
|
|
assert.equal(progress.at(-1).transferred, UPLOAD_CHUNK_SIZE);
|
|
|
|
releaseFirstDrain();
|
|
await upload;
|
|
assert.deepEqual(sentChunkSizes, [UPLOAD_CHUNK_SIZE, 1]);
|
|
assert.equal(progress.at(-1).finalizing, true);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("handleUpload reports transport-accepted bytes instead of the queued backlog", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-delivered-"));
|
|
const filePath = path.join(tempDir, "upload.bin");
|
|
const size = UPLOAD_CHUNK_SIZE * 2;
|
|
fs.writeFileSync(filePath, Buffer.alloc(size, 0x5a));
|
|
const progress = [];
|
|
|
|
const zsession = {
|
|
async send_offer() {
|
|
return {
|
|
send() {},
|
|
async end() {},
|
|
};
|
|
},
|
|
async close() {},
|
|
};
|
|
|
|
await handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => ({
|
|
isDestroyed: () => false,
|
|
send(channel, data) {
|
|
if (channel === "netcatty:zmodem:progress") progress.push(data);
|
|
},
|
|
}),
|
|
takeDragDropUpload: () => ({
|
|
filePaths: [filePath],
|
|
remoteNames: ["upload.bin"],
|
|
}),
|
|
progressThrottleMs: 0,
|
|
// 4096 bytes of every queued amount are still outstanding in the transport.
|
|
getTransportPendingBytes: () => 4096,
|
|
});
|
|
|
|
assert.deepEqual(
|
|
progress.map((event) => [event.transferred, Boolean(event.finalizing)]),
|
|
[
|
|
[0, false],
|
|
[UPLOAD_CHUNK_SIZE - 4096, false],
|
|
[size - 4096, false],
|
|
[size, true],
|
|
],
|
|
);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("handleUpload emits delivered-byte progress while parked on transport drain", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-park-"));
|
|
const filePath = path.join(tempDir, "upload.bin");
|
|
const size = UPLOAD_CHUNK_SIZE * 2 + 1;
|
|
fs.writeFileSync(filePath, Buffer.alloc(size, 0x5a));
|
|
const progress = [];
|
|
// Bytes queued into the transport (never consumed; delivery is simulated
|
|
// below on the pending-byte readout).
|
|
let outstanding = 0;
|
|
let drainStartedAt = null;
|
|
let releaseFirstDrain;
|
|
const firstDrain = new Promise((resolve) => {
|
|
releaseFirstDrain = resolve;
|
|
});
|
|
let drainCalls = 0;
|
|
|
|
const zsession = {
|
|
async send_offer() {
|
|
return {
|
|
send(chunk) {
|
|
outstanding += chunk.byteLength;
|
|
},
|
|
async end() {},
|
|
};
|
|
},
|
|
async close() {},
|
|
};
|
|
|
|
const upload = handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => ({
|
|
isDestroyed: () => false,
|
|
send(channel, data) {
|
|
if (channel === "netcatty:zmodem:progress") progress.push(data);
|
|
},
|
|
}),
|
|
takeDragDropUpload: () => ({
|
|
filePaths: [filePath],
|
|
remoteNames: ["upload.bin"],
|
|
}),
|
|
progressThrottleMs: 0,
|
|
getTransportPendingBytes: () => {
|
|
if (drainStartedAt === null) return outstanding;
|
|
// The backlog drains at 512 B/ms once the parked wait begins.
|
|
const delivered = Math.min(outstanding, (Date.now() - drainStartedAt) * 512);
|
|
return outstanding - delivered;
|
|
},
|
|
async waitForDrain() {
|
|
drainCalls += 1;
|
|
if (drainCalls === 1) {
|
|
drainStartedAt = Date.now();
|
|
await firstDrain;
|
|
}
|
|
},
|
|
});
|
|
|
|
while (drainCalls === 0) {
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
}
|
|
const progressedBefore = progress.length;
|
|
await new Promise((resolve) => setTimeout(resolve, 250));
|
|
const parkedEvents = progress.slice(progressedBefore);
|
|
releaseFirstDrain();
|
|
await upload;
|
|
|
|
// While parked, delivered-byte progress must keep flowing (previously the
|
|
// indicator stayed frozen until the whole backlog drained).
|
|
assert.ok(
|
|
parkedEvents.some((event) => event.transferred > 0 && !event.finalizing),
|
|
`expected delivered-byte emissions while parked, got ${JSON.stringify(parkedEvents.map((e) => [e.transferred, Boolean(e.finalizing)]))}`,
|
|
);
|
|
|
|
const values = progress.map((event) => event.transferred);
|
|
for (let k = 1; k < values.length; k++) {
|
|
assert.ok(
|
|
values[k] >= values[k - 1],
|
|
`progress must never move backwards: ${values.join(",")}`,
|
|
);
|
|
assert.ok(values[k] <= size, `progress must not exceed the file size: ${values.join(",")}`);
|
|
}
|
|
assert.equal(progress.at(-1).finalizing, true);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("awaitUploadDrainWithProgress falls back to a plain drain wait without pending-byte accounting", async () => {
|
|
let drainCalls = 0;
|
|
await awaitUploadDrainWithProgress(
|
|
{
|
|
waitForDrain: () => {
|
|
drainCalls += 1;
|
|
return Promise.resolve();
|
|
},
|
|
},
|
|
() => {
|
|
throw new Error("no progress emissions without pending-byte accounting");
|
|
},
|
|
);
|
|
assert.equal(drainCalls, 1);
|
|
});
|
|
|
|
test("awaitUploadDrainWithProgress adds no polling delay when drain resolves immediately", async () => {
|
|
const startedAt = Date.now();
|
|
await awaitUploadDrainWithProgress(
|
|
{
|
|
waitForDrain: () => Promise.resolve(),
|
|
getTransportPendingBytes: () => 0,
|
|
},
|
|
() => {
|
|
throw new Error("no emissions without parked backpressure");
|
|
},
|
|
);
|
|
assert.ok(Date.now() - startedAt < 50);
|
|
});
|
|
|
|
test("awaitUploadDrainWithProgress returns promptly when drain settles during the poll interval", async () => {
|
|
let releaseDrain;
|
|
const drainGate = new Promise((resolve) => {
|
|
releaseDrain = resolve;
|
|
});
|
|
let parked = false;
|
|
const done = awaitUploadDrainWithProgress(
|
|
{
|
|
waitForDrain: () => drainGate,
|
|
getTransportPendingBytes: () => 2048,
|
|
},
|
|
() => {
|
|
parked = true;
|
|
},
|
|
);
|
|
|
|
const waitStarted = Date.now();
|
|
while (!parked) {
|
|
if (Date.now() - waitStarted > 1000) {
|
|
throw new Error("upload drain wait never parked");
|
|
}
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
}
|
|
// The immediate park emission has run and the poll timer (~100ms) is armed.
|
|
// Settle on the next turn, still inside that interval.
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
const releasedAt = Date.now();
|
|
releaseDrain();
|
|
await done;
|
|
const elapsed = Date.now() - releasedAt;
|
|
assert.ok(
|
|
elapsed < 50,
|
|
`drain settlement during a poll interval resumed in ${elapsed}ms`,
|
|
);
|
|
});
|
|
|
|
test("awaitUploadDrainWithProgress propagates a rejection that arrives during the poll interval", async () => {
|
|
let rejectDrain;
|
|
const drainGate = new Promise((_, reject) => {
|
|
rejectDrain = reject;
|
|
});
|
|
const err = new Error("Transport drain timeout");
|
|
err.code = "NETCATTY_ZMODEM_TIMEOUT";
|
|
let parked = false;
|
|
const done = awaitUploadDrainWithProgress(
|
|
{
|
|
waitForDrain: () => drainGate,
|
|
getTransportPendingBytes: () => 2048,
|
|
},
|
|
() => {
|
|
parked = true;
|
|
},
|
|
);
|
|
|
|
const waitStarted = Date.now();
|
|
while (!parked) {
|
|
if (Date.now() - waitStarted > 1000) {
|
|
throw new Error("upload drain wait never parked");
|
|
}
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
}
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
const releasedAt = Date.now();
|
|
rejectDrain(err);
|
|
await assert.rejects(done, (caught) => caught === err);
|
|
const elapsed = Date.now() - releasedAt;
|
|
assert.ok(
|
|
elapsed < 50,
|
|
`drain rejection during a poll interval resumed in ${elapsed}ms`,
|
|
);
|
|
});
|
|
|
|
test("awaitUploadDrainWithProgress emits progress while parked until drain settles", async () => {
|
|
let releaseDrain;
|
|
const drainGate = new Promise((resolve) => {
|
|
releaseDrain = resolve;
|
|
});
|
|
let displayed = 0;
|
|
const emitted = [];
|
|
const deliverTimer = setInterval(() => {
|
|
displayed += 512;
|
|
}, 40);
|
|
|
|
try {
|
|
const parked = awaitUploadDrainWithProgress(
|
|
{
|
|
waitForDrain: () => drainGate,
|
|
getTransportPendingBytes: () => 1024,
|
|
},
|
|
() => emitted.push(displayed),
|
|
);
|
|
await new Promise((resolve) => setTimeout(resolve, 280));
|
|
assert.ok(emitted.length >= 2, `expected poll emissions, got ${emitted.length}`);
|
|
assert.ok(emitted.every((v) => v === 0 || v % 512 === 0));
|
|
releaseDrain();
|
|
await parked;
|
|
} finally {
|
|
clearInterval(deliverTimer);
|
|
}
|
|
});
|
|
|
|
test("awaitUploadDrainWithProgress propagates drain-wait rejections", async () => {
|
|
const err = new Error("Transport drain timeout");
|
|
err.code = "NETCATTY_ZMODEM_TIMEOUT";
|
|
await assert.rejects(
|
|
awaitUploadDrainWithProgress(
|
|
{
|
|
waitForDrain: () => Promise.reject(err),
|
|
getTransportPendingBytes: () => 0,
|
|
},
|
|
() => {},
|
|
),
|
|
(caught) => caught === err,
|
|
);
|
|
});
|
|
|
|
test("handleUpload throttles progress IPC by default for every transport", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-progress-"));
|
|
const filePath = path.join(tempDir, "large-upload.bin");
|
|
const size = UPLOAD_CHUNK_SIZE + 1;
|
|
fs.writeFileSync(filePath, Buffer.alloc(size, 0x5a));
|
|
const progress = [];
|
|
const originalNow = Date.now;
|
|
Date.now = () => 1000;
|
|
|
|
try {
|
|
const zsession = {
|
|
async send_offer() {
|
|
return {
|
|
send() {},
|
|
async end() {},
|
|
};
|
|
},
|
|
async close() {},
|
|
};
|
|
|
|
await handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => ({
|
|
isDestroyed: () => false,
|
|
send(channel, data) {
|
|
if (channel === "netcatty:zmodem:progress") progress.push(data);
|
|
},
|
|
}),
|
|
takeDragDropUpload: () => ({
|
|
filePaths: [filePath],
|
|
remoteNames: ["large-upload.bin"],
|
|
}),
|
|
});
|
|
|
|
assert.deepEqual(
|
|
progress.map((event) => [event.transferred, Boolean(event.finalizing)]),
|
|
[[0, false], [UPLOAD_CHUNK_SIZE, false], [size, true]],
|
|
);
|
|
} finally {
|
|
Date.now = originalNow;
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("handleUpload progress follows a display rebind during transfer", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-rebind-"));
|
|
const filePath = path.join(tempDir, "upload.txt");
|
|
fs.writeFileSync(filePath, "payload");
|
|
const events = [];
|
|
const contents = {
|
|
home: {
|
|
isDestroyed: () => false,
|
|
send: (channel, data) => events.push({ target: "home", channel, data }),
|
|
},
|
|
popup: {
|
|
isDestroyed: () => false,
|
|
send: (channel, data) => events.push({ target: "popup", channel, data }),
|
|
},
|
|
};
|
|
let target = "home";
|
|
const zsession = {
|
|
async send_offer() {
|
|
return {
|
|
send() { target = "popup"; },
|
|
async end() {},
|
|
};
|
|
},
|
|
async close() {},
|
|
};
|
|
|
|
await handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => contents[target],
|
|
takeDragDropUpload: () => ({
|
|
filePaths: [filePath],
|
|
remoteNames: ["upload.txt"],
|
|
}),
|
|
});
|
|
|
|
const progressTargets = events
|
|
.filter((event) => event.channel === "netcatty:zmodem:progress")
|
|
.map((event) => event.target);
|
|
assert.equal(progressTargets[0], "home");
|
|
assert.deepEqual(progressTargets.slice(1), ["popup", "popup"]);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("handleUpload uses injected file picker when no drag-drop upload is queued", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const filePath = path.join(tempDir, "picker-upload.txt");
|
|
fs.writeFileSync(filePath, "payload");
|
|
let pickerCalled = false;
|
|
let endCalled = false;
|
|
|
|
const zsession = {
|
|
async send_offer() {
|
|
return {
|
|
send() {},
|
|
async end() {
|
|
endCalled = true;
|
|
},
|
|
};
|
|
},
|
|
async close() {},
|
|
};
|
|
|
|
await handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => ({
|
|
isDestroyed: () => false,
|
|
send() {},
|
|
}),
|
|
selectUploadFiles: async () => {
|
|
pickerCalled = true;
|
|
return { canceled: false, filePaths: [filePath] };
|
|
},
|
|
});
|
|
|
|
assert.equal(pickerCalled, true);
|
|
assert.equal(endCalled, true);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("handleDownload uses injected directory picker before accepting remote files", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-download-"));
|
|
let pickerCalled = false;
|
|
const handlers = new Map();
|
|
let startCalled = false;
|
|
|
|
const zsession = {
|
|
on(event, handler) {
|
|
handlers.set(event, handler);
|
|
},
|
|
start() {
|
|
startCalled = true;
|
|
setImmediate(() => handlers.get("session_end")?.());
|
|
},
|
|
};
|
|
|
|
await handleDownload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => ({
|
|
isDestroyed: () => false,
|
|
send() {},
|
|
}),
|
|
selectDownloadDirectory: async () => {
|
|
pickerCalled = true;
|
|
return { canceled: false, filePaths: [tempDir] };
|
|
},
|
|
});
|
|
|
|
assert.equal(startCalled, true);
|
|
assert.equal(pickerCalled, true);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("handleUpload times out when the remote never confirms after progress reaches 100 percent", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const filePath = path.join(tempDir, "upload.txt");
|
|
fs.writeFileSync(filePath, "payload");
|
|
let releaseEnd;
|
|
const writes = [];
|
|
let timeoutNotified = false;
|
|
|
|
const zsession = {
|
|
async send_offer() {
|
|
return {
|
|
send() {},
|
|
end() {
|
|
return new Promise((resolve) => {
|
|
releaseEnd = resolve;
|
|
});
|
|
},
|
|
};
|
|
},
|
|
async close() {},
|
|
};
|
|
|
|
const uploadPromise = handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => null,
|
|
writeToRemote: (buf) => {
|
|
writes.push(Buffer.from(buf));
|
|
return true;
|
|
},
|
|
takeDragDropUpload: () => ({
|
|
filePaths: [filePath],
|
|
remoteNames: ["upload.txt"],
|
|
}),
|
|
uploadFileEndTimeoutMs: 10,
|
|
uploadSessionCloseTimeoutMs: 10,
|
|
onUploadTimeout: () => {
|
|
timeoutNotified = true;
|
|
},
|
|
});
|
|
|
|
const outcome = await Promise.race([
|
|
uploadPromise.then(
|
|
() => "resolved",
|
|
(err) => String(err.message || err),
|
|
),
|
|
new Promise((resolve) => setTimeout(() => resolve("still waiting"), 50)),
|
|
]);
|
|
|
|
assert.match(outcome, /Remote did not confirm receiving upload\.txt/);
|
|
assert.equal(timeoutNotified, true);
|
|
assert.deepEqual([...writes[0]], [0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18]);
|
|
releaseEnd();
|
|
await uploadPromise.catch(() => {});
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("handleUpload does not run timeout recovery when the remote rejects the final confirmation", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const filePath = path.join(tempDir, "upload.txt");
|
|
fs.writeFileSync(filePath, "payload");
|
|
const writes = [];
|
|
let timeoutNotified = false;
|
|
|
|
const zsession = {
|
|
async send_offer() {
|
|
return {
|
|
send() {},
|
|
async end() {
|
|
throw new Error("remote cancelled upload");
|
|
},
|
|
};
|
|
},
|
|
async close() {},
|
|
};
|
|
|
|
await assert.rejects(
|
|
handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => null,
|
|
writeToRemote: (buf) => {
|
|
writes.push(Buffer.from(buf));
|
|
return true;
|
|
},
|
|
takeDragDropUpload: () => ({
|
|
filePaths: [filePath],
|
|
remoteNames: ["upload.txt"],
|
|
}),
|
|
uploadFileEndTimeoutMs: 50,
|
|
uploadSessionCloseTimeoutMs: 50,
|
|
onUploadTimeout: () => {
|
|
timeoutNotified = true;
|
|
},
|
|
}),
|
|
/remote cancelled upload/,
|
|
);
|
|
|
|
assert.equal(timeoutNotified, false);
|
|
assert.equal(writes.length, 0);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("handleUpload times out when the remote never answers the offer", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const filePath = path.join(tempDir, "upload.txt");
|
|
fs.writeFileSync(filePath, "payload");
|
|
const writes = [];
|
|
let timeoutNotified = false;
|
|
|
|
// rz died before answering ZFILE: send_offer never resolves. The upload
|
|
// loop must not park here forever — bound it like xfer.end()/close().
|
|
const zsession = {
|
|
send_offer: () => new Promise(() => {}),
|
|
async abort() {},
|
|
async close() {},
|
|
};
|
|
|
|
await assert.rejects(
|
|
handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => null,
|
|
writeToRemote: (buf) => {
|
|
writes.push(Buffer.from(buf));
|
|
return true;
|
|
},
|
|
takeDragDropUpload: () => ({
|
|
filePaths: [filePath],
|
|
remoteNames: ["upload.txt"],
|
|
}),
|
|
uploadFileEndTimeoutMs: 50,
|
|
onUploadTimeout: () => {
|
|
timeoutNotified = true;
|
|
},
|
|
}),
|
|
/Remote did not respond to the offer for upload\.txt/,
|
|
);
|
|
|
|
assert.equal(timeoutNotified, true);
|
|
assert.ok(writes.length > 0, "CAN abort bytes were sent to the remote");
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("handleUpload stops an unresolved offer promptly when cancelled", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const filePath = path.join(tempDir, "upload.txt");
|
|
fs.writeFileSync(filePath, "payload");
|
|
const controller = new AbortController();
|
|
|
|
const upload = handleUpload(
|
|
{
|
|
send_offer: () => new Promise(() => {}),
|
|
async close() {},
|
|
},
|
|
{
|
|
sessionId: "session-1",
|
|
signal: controller.signal,
|
|
getWebContents: () => null,
|
|
takeDragDropUpload: () => ({
|
|
filePaths: [filePath],
|
|
remoteNames: ["upload.txt"],
|
|
}),
|
|
},
|
|
);
|
|
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
controller.abort();
|
|
await assert.rejects(
|
|
() => upload,
|
|
(err) => err && err.code === "NETCATTY_ZMODEM_CANCELLED",
|
|
);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("handleUpload does not delete an overwrite target after cancellation", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-cancel-overwrite-"));
|
|
const filePath = path.join(tempDir, "upload.txt");
|
|
fs.writeFileSync(filePath, "payload");
|
|
const controller = new AbortController();
|
|
let removeCalls = 0;
|
|
let sendOfferCalls = 0;
|
|
let releaseDecision;
|
|
|
|
const upload = handleUpload(
|
|
{
|
|
send_offer() {
|
|
sendOfferCalls += 1;
|
|
return Promise.reject(new Error("send_offer should not run after cancellation"));
|
|
},
|
|
async close() {},
|
|
},
|
|
{
|
|
sessionId: "session-1",
|
|
signal: controller.signal,
|
|
getWebContents: () => null,
|
|
selectUploadFiles: async () => ({ canceled: false, filePaths: [filePath] }),
|
|
probeReceiveConflicts: async () => ({
|
|
dir: "/home/u",
|
|
existing: ["upload.txt"],
|
|
modes: { "upload.txt": "644" },
|
|
}),
|
|
requestOverwriteDecision: () => new Promise((resolve) => {
|
|
releaseDecision = resolve;
|
|
}),
|
|
removeRemoteFiles: async () => {
|
|
removeCalls += 1;
|
|
},
|
|
},
|
|
);
|
|
|
|
while (!releaseDecision) await new Promise((resolve) => setImmediate(resolve));
|
|
controller.abort();
|
|
releaseDecision({ action: "overwrite", applyToRest: false });
|
|
await assert.rejects(
|
|
() => upload,
|
|
(err) => err && err.code === "NETCATTY_ZMODEM_CANCELLED",
|
|
);
|
|
assert.equal(removeCalls, 0);
|
|
assert.equal(sendOfferCalls, 0);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("handleUpload aborts an in-flight remote overwrite cleanup", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-cancel-remove-"));
|
|
const filePath = path.join(tempDir, "upload.txt");
|
|
fs.writeFileSync(filePath, "payload");
|
|
const controller = new AbortController();
|
|
let releaseRemove;
|
|
let removeSignal;
|
|
|
|
const upload = handleUpload(
|
|
{
|
|
async send_offer() {
|
|
throw new Error("send_offer should not run after cancellation");
|
|
},
|
|
async close() {},
|
|
},
|
|
{
|
|
sessionId: "session-1",
|
|
signal: controller.signal,
|
|
getWebContents: () => null,
|
|
selectUploadFiles: async () => ({ canceled: false, filePaths: [filePath] }),
|
|
probeReceiveConflicts: async () => ({ dir: "/home/u", existing: ["upload.txt"] }),
|
|
requestOverwriteDecision: async () => ({ action: "overwrite", applyToRest: false }),
|
|
removeRemoteFiles: (_paths, { signal } = {}) => {
|
|
removeSignal = signal;
|
|
return new Promise((resolve) => { releaseRemove = resolve; });
|
|
},
|
|
},
|
|
);
|
|
|
|
while (!releaseRemove) await new Promise((resolve) => setImmediate(resolve));
|
|
controller.abort();
|
|
await assert.rejects(
|
|
() => upload,
|
|
(err) => err && err.code === "NETCATTY_ZMODEM_CANCELLED",
|
|
);
|
|
assert.equal(removeSignal, controller.signal);
|
|
assert.equal(removeSignal.aborted, true);
|
|
releaseRemove();
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("handleUpload allows a longer final wait after upload backpressure", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const filePath = path.join(tempDir, "upload.txt");
|
|
fs.writeFileSync(filePath, "payload");
|
|
let closed = false;
|
|
|
|
const zsession = {
|
|
async send_offer() {
|
|
return {
|
|
send() {},
|
|
end() {
|
|
return new Promise((resolve) => setTimeout(resolve, 30));
|
|
},
|
|
};
|
|
},
|
|
async close() {
|
|
closed = true;
|
|
},
|
|
};
|
|
|
|
await handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => null,
|
|
writeToRemote: () => true,
|
|
takeDragDropUpload: () => ({
|
|
filePaths: [filePath],
|
|
remoteNames: ["upload.txt"],
|
|
}),
|
|
hasUploadBackpressure: () => true,
|
|
resetUploadBackpressure: () => {},
|
|
uploadFileEndTimeoutMs: 10,
|
|
slowUploadFileEndTimeoutMs: 80,
|
|
uploadSessionCloseTimeoutMs: 10,
|
|
});
|
|
|
|
assert.equal(closed, true);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
// Issue #2863: rz protect/skip must not look like a successful upload.
|
|
test("handleUpload fails when the remote skips an offered file", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const filePath = path.join(tempDir, "upload.txt");
|
|
fs.writeFileSync(filePath, "payload");
|
|
let closed = false;
|
|
|
|
const zsession = {
|
|
async send_offer() {
|
|
return undefined; // ZSKIP / protect mode
|
|
},
|
|
async close() {
|
|
closed = true;
|
|
},
|
|
};
|
|
|
|
await assert.rejects(
|
|
handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => null,
|
|
writeToRemote: () => true,
|
|
takeDragDropUpload: () => ({
|
|
filePaths: [filePath],
|
|
remoteNames: ["upload.txt"],
|
|
}),
|
|
}),
|
|
/skipped|not overwritten|protect/i,
|
|
);
|
|
|
|
assert.equal(closed, false);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("drag-drop upload relies on rz overwrite without probing, prompting, or pre-deleting", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const filePath = path.join(tempDir, "upload.txt");
|
|
fs.writeFileSync(filePath, "payload");
|
|
let probed = false;
|
|
let prompted = false;
|
|
let removed = [];
|
|
let offerNames = [];
|
|
|
|
const zsession = {
|
|
async send_offer(params) {
|
|
offerNames.push(params.name);
|
|
return {
|
|
send() {},
|
|
async end() {},
|
|
};
|
|
},
|
|
async close() {},
|
|
};
|
|
|
|
await handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => null,
|
|
writeToRemote: () => true,
|
|
takeDragDropUpload: () => ({
|
|
filePaths: [filePath],
|
|
remoteNames: ["upload.txt"],
|
|
}),
|
|
probeReceiveConflicts: async () => {
|
|
probed = true;
|
|
return {
|
|
dir: "/home/u",
|
|
existing: ["upload.txt"],
|
|
modes: { "upload.txt": "644" },
|
|
};
|
|
},
|
|
requestOverwriteDecision: async () => {
|
|
prompted = true;
|
|
return { action: "skip", applyToRest: false };
|
|
},
|
|
removeRemoteFiles: async (paths) => {
|
|
removed.push(...paths);
|
|
},
|
|
});
|
|
|
|
assert.equal(probed, false);
|
|
assert.equal(prompted, false);
|
|
assert.deepEqual(removed, []);
|
|
assert.deepEqual(offerNames, ["upload.txt"]);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("drag-drop offers duplicate remote names independently without pre-deleting", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const firstPath = path.join(tempDir, "first.txt");
|
|
const secondPath = path.join(tempDir, "second.txt");
|
|
fs.writeFileSync(firstPath, "first");
|
|
fs.writeFileSync(secondPath, "second");
|
|
const offered = [];
|
|
const removed = [];
|
|
|
|
const zsession = {
|
|
async send_offer(params) {
|
|
offered.push(params.name);
|
|
return {
|
|
send() {},
|
|
async end() {},
|
|
};
|
|
},
|
|
async close() {},
|
|
};
|
|
|
|
await handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => null,
|
|
writeToRemote: () => true,
|
|
takeDragDropUpload: () => ({
|
|
filePaths: [firstPath, secondPath],
|
|
remoteNames: ["x.txt", "x.txt"],
|
|
}),
|
|
probeReceiveConflicts: async () => {
|
|
throw new Error("drag-drop should not probe conflicts");
|
|
},
|
|
requestOverwriteDecision: async () => {
|
|
throw new Error("drag-drop should not prompt for conflicts");
|
|
},
|
|
removeRemoteFiles: async (paths) => {
|
|
removed.push(...paths);
|
|
},
|
|
});
|
|
|
|
assert.deepEqual(offered, ["x.txt", "x.txt"]);
|
|
assert.deepEqual(removed, []);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("failed drag-drop offer does not delete any existing conflict targets", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const firstPath = path.join(tempDir, "a.txt");
|
|
const secondPath = path.join(tempDir, "b.txt");
|
|
fs.writeFileSync(firstPath, "a");
|
|
fs.writeFileSync(secondPath, "b");
|
|
const removed = [];
|
|
|
|
const zsession = {
|
|
async send_offer(params) {
|
|
if (params.name === "a.txt") {
|
|
throw new Error("simulated early failure");
|
|
}
|
|
return {
|
|
send() {},
|
|
async end() {},
|
|
};
|
|
},
|
|
abort() {},
|
|
async close() {},
|
|
};
|
|
|
|
await assert.rejects(
|
|
handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => null,
|
|
writeToRemote: () => true,
|
|
takeDragDropUpload: () => ({
|
|
filePaths: [firstPath, secondPath],
|
|
remoteNames: ["a.txt", "b.txt"],
|
|
}),
|
|
probeReceiveConflicts: async () => ({
|
|
dir: "/home/u",
|
|
existing: ["a.txt", "b.txt"],
|
|
modes: { "a.txt": "644", "b.txt": "600" },
|
|
}),
|
|
requestOverwriteDecision: async () => ({ action: "skip", applyToRest: false }),
|
|
removeRemoteFiles: async (paths) => {
|
|
removed.push(...paths);
|
|
},
|
|
}),
|
|
/simulated early failure/,
|
|
);
|
|
|
|
assert.deepEqual(removed, []);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("handleUpload restores modes for accepted overwrites before partial ZSKIP failure", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const acceptedPath = path.join(tempDir, "a.sh");
|
|
const skippedPath = path.join(tempDir, "b.txt");
|
|
fs.writeFileSync(acceptedPath, "a");
|
|
fs.writeFileSync(skippedPath, "b");
|
|
let offerCount = 0;
|
|
let restored = [];
|
|
|
|
const zsession = {
|
|
async send_offer(params) {
|
|
offerCount += 1;
|
|
if (params.name === "b.txt") return undefined;
|
|
return {
|
|
send() {},
|
|
async end() {},
|
|
};
|
|
},
|
|
abort() {},
|
|
async close() {},
|
|
};
|
|
|
|
await assert.rejects(
|
|
handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => null,
|
|
writeToRemote: () => true,
|
|
selectUploadFiles: async () => ({
|
|
canceled: false,
|
|
filePaths: [acceptedPath, skippedPath],
|
|
}),
|
|
probeReceiveConflicts: async () => ({
|
|
dir: "/home/u",
|
|
existing: ["a.sh", "b.txt"],
|
|
modes: { "a.sh": "755", "b.txt": "644" },
|
|
}),
|
|
requestOverwriteDecision: async () => ({ action: "overwrite", applyToRest: true }),
|
|
removeRemoteFiles: async () => {},
|
|
restoreRemoteModes: async (entries) => {
|
|
restored = entries;
|
|
},
|
|
}),
|
|
/Remote skipped some files/,
|
|
);
|
|
|
|
assert.equal(offerCount, 2);
|
|
assert.deepEqual(restored, [{ path: "/home/u/a.sh", mode: "755" }]);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
test("mode restore tracks skipped offers by index for duplicate basenames", async () => {
|
|
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
|
|
const firstDir = path.join(tempDir, "first");
|
|
const secondDir = path.join(tempDir, "second");
|
|
fs.mkdirSync(firstDir);
|
|
fs.mkdirSync(secondDir);
|
|
const firstPath = path.join(firstDir, "x.txt");
|
|
const secondPath = path.join(secondDir, "x.txt");
|
|
fs.writeFileSync(firstPath, "first");
|
|
fs.writeFileSync(secondPath, "second");
|
|
let offerCount = 0;
|
|
let restored = [];
|
|
|
|
const zsession = {
|
|
async send_offer() {
|
|
offerCount += 1;
|
|
// Accept the first duplicate-name offer; ZSKIP the second.
|
|
if (offerCount > 1) return undefined;
|
|
return {
|
|
send() {},
|
|
async end() {},
|
|
};
|
|
},
|
|
abort() {},
|
|
async close() {},
|
|
};
|
|
|
|
await assert.rejects(
|
|
handleUpload(zsession, {
|
|
sessionId: "session-1",
|
|
getWebContents: () => null,
|
|
writeToRemote: () => true,
|
|
selectUploadFiles: async () => ({
|
|
canceled: false,
|
|
filePaths: [firstPath, secondPath],
|
|
}),
|
|
probeReceiveConflicts: async () => ({
|
|
dir: "/home/u",
|
|
existing: ["x.txt"],
|
|
modes: { "x.txt": "600" },
|
|
}),
|
|
requestOverwriteDecision: async () => ({ action: "overwrite", applyToRest: true }),
|
|
removeRemoteFiles: async () => {},
|
|
restoreRemoteModes: async (entries) => {
|
|
restored = entries;
|
|
},
|
|
}),
|
|
/Remote skipped some files/,
|
|
);
|
|
|
|
assert.equal(offerCount, 2);
|
|
// Filename-based skip filtering would drop this restore; index-based keeps it.
|
|
assert.deepEqual(restored, [{ path: "/home/u/x.txt", mode: "600" }]);
|
|
fs.rmSync(tempDir, { recursive: true, force: true });
|
|
});
|
|
|
|
// Issue #2967: large rz uploads must wait for real transport drain, not one
|
|
// setImmediate tick. Flooding the SSH channel completes UI progress early,
|
|
// drops the session, and leaves a truncated remote file.
|
|
|
|
test("waitForWritableDrain resolves immediately when the stream does not need drain", async () => {
|
|
const stream = {
|
|
writableNeedDrain: false,
|
|
once() {
|
|
throw new Error("should not wait for drain");
|
|
},
|
|
off() {},
|
|
};
|
|
await waitForWritableDrain(stream);
|
|
});
|
|
|
|
test("waitForWritableDrain waits until the stream emits drain", async () => {
|
|
const listeners = new Map();
|
|
const stream = {
|
|
writableNeedDrain: true,
|
|
once(event, cb) {
|
|
if (!listeners.has(event)) listeners.set(event, []);
|
|
listeners.get(event).push(cb);
|
|
},
|
|
off(event, cb) {
|
|
const list = listeners.get(event) || [];
|
|
listeners.set(event, list.filter((fn) => fn !== cb));
|
|
},
|
|
};
|
|
|
|
let resolved = false;
|
|
const pending = waitForWritableDrain(stream).then(() => {
|
|
resolved = true;
|
|
});
|
|
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(resolved, false);
|
|
assert.equal((listeners.get("drain") || []).length, 1);
|
|
|
|
stream.writableNeedDrain = false;
|
|
for (const cb of listeners.get("drain") || []) cb();
|
|
await pending;
|
|
assert.equal(resolved, true);
|
|
});
|
|
|
|
test("waitForWritableDrain rejects when the transport never drains", async () => {
|
|
const listeners = new Map();
|
|
const stream = {
|
|
writableNeedDrain: true,
|
|
once(event, cb) {
|
|
if (!listeners.has(event)) listeners.set(event, []);
|
|
listeners.get(event).push(cb);
|
|
},
|
|
off(event, cb) {
|
|
const list = listeners.get(event) || [];
|
|
listeners.set(event, list.filter((fn) => fn !== cb));
|
|
},
|
|
};
|
|
|
|
await assert.rejects(
|
|
() => waitForWritableDrain(stream, { timeoutMs: 20 }),
|
|
(err) => err && err.code === "NETCATTY_ZMODEM_TIMEOUT",
|
|
);
|
|
assert.equal((listeners.get("drain") || []).length, 0);
|
|
});
|
|
|
|
test("waitForWritableDrain keeps waiting while a slow SSH channel makes progress", async () => {
|
|
const listeners = new Map();
|
|
const stream = {
|
|
writableNeedDrain: true,
|
|
writableLength: 2 * 1024 * 1024,
|
|
pendingChunkLength: 8 * 1024,
|
|
once(event, cb) {
|
|
if (!listeners.has(event)) listeners.set(event, []);
|
|
listeners.get(event).push(cb);
|
|
},
|
|
off(event, cb) {
|
|
const list = listeners.get(event) || [];
|
|
listeners.set(event, list.filter((fn) => fn !== cb));
|
|
},
|
|
};
|
|
|
|
let settled = false;
|
|
const pending = waitForWritableDrain(stream, {
|
|
timeoutMs: 20,
|
|
progressIntervalMs: 5,
|
|
getProgressValue: () => stream.writableLength + stream.pendingChunkLength,
|
|
}).then(() => {
|
|
settled = true;
|
|
});
|
|
for (let i = 0; i < 5; i++) {
|
|
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
// ssh2 can advance part of its current frame without completing the
|
|
// corresponding Node write, so writableLength remains unchanged.
|
|
stream.pendingChunkLength -= 1024;
|
|
}
|
|
assert.equal(settled, false);
|
|
|
|
stream.writableNeedDrain = false;
|
|
for (const cb of listeners.get("drain") || []) cb();
|
|
await pending;
|
|
assert.equal(settled, true);
|
|
});
|
|
|
|
test("waitForWritableDrain rejects when an SSH channel stops making progress", async () => {
|
|
const listeners = new Map();
|
|
const stream = {
|
|
writableNeedDrain: true,
|
|
writableLength: 2 * 1024 * 1024,
|
|
once(event, cb) {
|
|
if (!listeners.has(event)) listeners.set(event, []);
|
|
listeners.get(event).push(cb);
|
|
},
|
|
off(event, cb) {
|
|
const list = listeners.get(event) || [];
|
|
listeners.set(event, list.filter((fn) => fn !== cb));
|
|
},
|
|
};
|
|
|
|
await assert.rejects(
|
|
() => waitForWritableDrain(stream, { timeoutMs: 20, progressIntervalMs: 5 }),
|
|
(err) => err && err.code === "NETCATTY_ZMODEM_TIMEOUT",
|
|
);
|
|
});
|
|
|
|
test("waitForWritableDrain rejects when the transport closes before drain", async () => {
|
|
const listeners = new Map();
|
|
const stream = {
|
|
writableNeedDrain: true,
|
|
once(event, cb) {
|
|
if (!listeners.has(event)) listeners.set(event, []);
|
|
listeners.get(event).push(cb);
|
|
},
|
|
off(event, cb) {
|
|
const list = listeners.get(event) || [];
|
|
listeners.set(event, list.filter((fn) => fn !== cb));
|
|
},
|
|
};
|
|
|
|
const pending = waitForWritableDrain(stream, { timeoutMs: 5_000 });
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
for (const cb of listeners.get("close") || []) cb();
|
|
await assert.rejects(
|
|
() => pending,
|
|
(err) => err && err.code === "NETCATTY_ZMODEM_TRANSPORT_CLOSED",
|
|
);
|
|
assert.equal((listeners.get("drain") || []).length, 0);
|
|
});
|
|
|
|
test("waitForWritableDrain rejects with the transport error event", async () => {
|
|
const listeners = new Map();
|
|
const stream = {
|
|
writableNeedDrain: true,
|
|
once(event, cb) {
|
|
if (!listeners.has(event)) listeners.set(event, []);
|
|
listeners.get(event).push(cb);
|
|
},
|
|
off(event, cb) {
|
|
const list = listeners.get(event) || [];
|
|
listeners.set(event, list.filter((fn) => fn !== cb));
|
|
},
|
|
};
|
|
|
|
const pending = waitForWritableDrain(stream, { timeoutMs: 5_000 });
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
const boom = new Error("socket hang up");
|
|
boom.code = "ECONNRESET";
|
|
for (const cb of listeners.get("error") || []) cb(boom);
|
|
await assert.rejects(
|
|
() => pending,
|
|
(err) => err === boom,
|
|
);
|
|
});
|
|
|
|
test("waitForWritableDrain rejects promptly when the transfer AbortSignal aborts", async () => {
|
|
const listeners = new Map();
|
|
const stream = {
|
|
writableNeedDrain: true,
|
|
once(event, cb) {
|
|
if (!listeners.has(event)) listeners.set(event, []);
|
|
listeners.get(event).push(cb);
|
|
},
|
|
off(event, cb) {
|
|
const list = listeners.get(event) || [];
|
|
listeners.set(event, list.filter((fn) => fn !== cb));
|
|
},
|
|
};
|
|
const controller = new AbortController();
|
|
|
|
const pending = waitForWritableDrain(stream, {
|
|
timeoutMs: 60_000,
|
|
signal: controller.signal,
|
|
});
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal((listeners.get("drain") || []).length, 1);
|
|
|
|
controller.abort();
|
|
await assert.rejects(
|
|
() => pending,
|
|
(err) => err && err.code === "NETCATTY_ZMODEM_CANCELLED",
|
|
);
|
|
assert.equal((listeners.get("drain") || []).length, 0);
|
|
});
|
|
|
|
test("createZmodemUploadDrainWaiter waits on transport drain after backpressure", async () => {
|
|
let needsDrain = true;
|
|
let transportWaits = 0;
|
|
let releaseTransport;
|
|
const transportPending = new Promise((resolve) => {
|
|
releaseTransport = resolve;
|
|
});
|
|
|
|
const waitForDrain = createZmodemUploadDrainWaiter({
|
|
getNeedsDrain: () => needsDrain,
|
|
clearNeedsDrain: () => {
|
|
needsDrain = false;
|
|
},
|
|
waitForTransportDrain: async () => {
|
|
transportWaits += 1;
|
|
await transportPending;
|
|
},
|
|
});
|
|
|
|
let resolved = false;
|
|
const pending = waitForDrain().then(() => {
|
|
resolved = true;
|
|
});
|
|
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.equal(resolved, false);
|
|
assert.equal(transportWaits, 1);
|
|
assert.equal(needsDrain, true);
|
|
|
|
releaseTransport();
|
|
await pending;
|
|
assert.equal(resolved, true);
|
|
assert.equal(needsDrain, false);
|
|
});
|
|
|
|
test("createZmodemUploadDrainWaiter recovers remote rz on transport drain timeout", async () => {
|
|
let needsDrain = true;
|
|
let timeoutNotified = false;
|
|
const writes = [];
|
|
|
|
const waitForDrain = createZmodemUploadDrainWaiter({
|
|
getNeedsDrain: () => needsDrain,
|
|
clearNeedsDrain: () => {
|
|
needsDrain = false;
|
|
},
|
|
waitForTransportDrain: async () => {
|
|
const err = new Error("Transport drain timeout");
|
|
err.code = "NETCATTY_ZMODEM_TIMEOUT";
|
|
throw err;
|
|
},
|
|
onUploadTimeout: () => {
|
|
timeoutNotified = true;
|
|
},
|
|
writeToRemote: (buf) => {
|
|
writes.push(Buffer.from(buf));
|
|
},
|
|
});
|
|
|
|
await assert.rejects(
|
|
() => waitForDrain(),
|
|
(err) => err && err.code === "NETCATTY_ZMODEM_TIMEOUT",
|
|
);
|
|
|
|
assert.equal(timeoutNotified, true);
|
|
assert.equal(needsDrain, false);
|
|
assert.deepEqual([...writes[0]], [0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18]);
|
|
});
|
|
|
|
test("createZmodemUploadDrainWaiter rejects on transfer cancel without timeout recovery", async () => {
|
|
let needsDrain = true;
|
|
let timeoutNotified = false;
|
|
let releaseTransport;
|
|
const transportPending = new Promise((resolve) => {
|
|
releaseTransport = resolve;
|
|
});
|
|
const controller = new AbortController();
|
|
|
|
const waitForDrain = createZmodemUploadDrainWaiter({
|
|
getNeedsDrain: () => needsDrain,
|
|
clearNeedsDrain: () => {
|
|
needsDrain = false;
|
|
},
|
|
signal: controller.signal,
|
|
waitForTransportDrain: async ({ signal } = {}) => waitForWritableDrain({
|
|
writableNeedDrain: true,
|
|
once(event, cb) {
|
|
if (event === "drain") {
|
|
transportPending.then(() => cb());
|
|
}
|
|
},
|
|
off() {},
|
|
}, { timeoutMs: 60_000, signal }),
|
|
onUploadTimeout: () => {
|
|
timeoutNotified = true;
|
|
},
|
|
writeToRemote: () => {
|
|
throw new Error("cancel must not abort remote via timeout recovery");
|
|
},
|
|
});
|
|
|
|
const pending = waitForDrain();
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
controller.abort();
|
|
|
|
await assert.rejects(
|
|
() => pending,
|
|
(err) => err && err.code === "NETCATTY_ZMODEM_CANCELLED",
|
|
);
|
|
assert.equal(timeoutNotified, false);
|
|
assert.equal(needsDrain, false);
|
|
releaseTransport();
|
|
});
|
|
|
|
test("createZmodemUploadDrainWaiter falls back to a single yield without transport drain", async () => {
|
|
let needsDrain = true;
|
|
const waitForDrain = createZmodemUploadDrainWaiter({
|
|
getNeedsDrain: () => needsDrain,
|
|
clearNeedsDrain: () => {
|
|
needsDrain = false;
|
|
},
|
|
});
|
|
|
|
await waitForDrain();
|
|
assert.equal(needsDrain, false);
|
|
});
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Split hex-header preamble (#3651): the ZRQINIT/ZRINIT hex header that opens
|
|
// every sz/rz session can be fragmented across transport chunks; it must
|
|
// never reach the terminal as garble, and withheld bytes must never be lost.
|
|
// ---------------------------------------------------------------------------
|
|
|
|
const ZmodemLib = require("zmodem.js");
|
|
|
|
const DOWNLOAD_PREAMBLE_TEXT = "sz: Sending test.bin\r\nrz\r";
|
|
|
|
function buildHexHeaderBytes(name, args) {
|
|
return Buffer.from(ZmodemLib.Header.build(name, ...(args || [])).to_hex());
|
|
}
|
|
|
|
function createProbeSentry(extra) {
|
|
const terminal = [];
|
|
const sentry = createZmodemSentry({
|
|
sessionId: "probe",
|
|
onData: (buf) => terminal.push(Buffer.from(buf)),
|
|
writeToRemote: () => true,
|
|
getWebContents: () => null,
|
|
selectDownloadDirectory: async () => ({ canceled: true }),
|
|
selectUploadFiles: async () => null,
|
|
hexHeaderFragmentTtlMs: 30,
|
|
...extra,
|
|
});
|
|
return { sentry, terminal };
|
|
}
|
|
|
|
function joinedText(terminal) {
|
|
return Buffer.concat(terminal).toString("latin1");
|
|
}
|
|
|
|
function assertNoZmodemHeaderBytes(terminal, context) {
|
|
const joined = Buffer.concat(terminal);
|
|
assert.equal(
|
|
joined.indexOf(Buffer.from([0x2a, 0x2a, 0x18, 0x42])),
|
|
-1,
|
|
`${context}: ZRQINIT/ZRINIT preamble leaked to the terminal`,
|
|
);
|
|
assert.equal(
|
|
joined.includes(Buffer.from([0x18])),
|
|
false,
|
|
`${context}: ZDLE/CAN byte leaked to the terminal`,
|
|
);
|
|
}
|
|
|
|
test("ordinary star echoes wait at most one frame for a possible ZMODEM prefix", (t) => {
|
|
t.mock.timers.enable({ apis: ["setTimeout"] });
|
|
for (const text of ["*", "**", "ls *", "**/*.txt*"]) {
|
|
const { sentry, terminal } = createProbeSentry({ hexHeaderFragmentTtlMs: undefined });
|
|
sentry.consume(Buffer.from(text));
|
|
t.mock.timers.tick(16);
|
|
assert.equal(joinedText(terminal), text, `echo delayed: ${text}`);
|
|
t.mock.timers.tick(1000);
|
|
assert.equal(joinedText(terminal), text, "the fragment must not be emitted twice");
|
|
}
|
|
});
|
|
|
|
test("a following parenthesis and repeated stars preserve echo order", (t) => {
|
|
t.mock.timers.enable({ apis: ["setTimeout"] });
|
|
const { sentry, terminal } = createProbeSentry({ hexHeaderFragmentTtlMs: undefined });
|
|
for (const text of ["*", "(", "*", "*", "*", "!"]) {
|
|
sentry.consume(Buffer.from(text));
|
|
t.mock.timers.tick(16);
|
|
}
|
|
assert.equal(joinedText(terminal), "*(***!");
|
|
t.mock.timers.tick(1000);
|
|
assert.equal(joinedText(terminal), "*(***!");
|
|
});
|
|
|
|
test("expired printable prefixes preserve ordinary bytes across chunk boundaries", (t) => {
|
|
t.mock.timers.enable({ apis: ["setTimeout"] });
|
|
const input = Buffer.from("a***(b)**/*.txt *\x18X **\x18Bxy more *\uFF0A");
|
|
for (const gap of [0, 16, 200]) {
|
|
for (let chunkSize = 1; chunkSize <= input.length; chunkSize += 1) {
|
|
const { sentry, terminal } = createProbeSentry({ hexHeaderFragmentTtlMs: undefined });
|
|
for (let i = 0; i < input.length; i += chunkSize) {
|
|
sentry.consume(input.subarray(i, i + chunkSize));
|
|
t.mock.timers.tick(gap);
|
|
}
|
|
t.mock.timers.tick(1000);
|
|
assert.deepEqual(Buffer.concat(terminal), input, `chunkSize=${chunkSize}, gap=${gap}`);
|
|
}
|
|
}
|
|
});
|
|
|
|
test("a prefix containing ZDLE keeps the full fragmented-header timeout", (t) => {
|
|
t.mock.timers.enable({ apis: ["setTimeout"] });
|
|
const { sentry, terminal } = createProbeSentry({ hexHeaderFragmentTtlMs: undefined });
|
|
const header = buildHexHeaderBytes("ZRQINIT");
|
|
sentry.consume(header.subarray(0, 3));
|
|
t.mock.timers.tick(200);
|
|
assert.equal(joinedText(terminal), "");
|
|
sentry.consume(header.subarray(3));
|
|
t.mock.timers.tick(1000);
|
|
assert.equal(joinedText(terminal), "");
|
|
assertNoZmodemHeaderBytes(terminal, "delayed ZDLE prefix");
|
|
});
|
|
|
|
test("a slow split header after printable-prefix expiry still detects and hides control bytes", async (t) => {
|
|
t.mock.timers.enable({ apis: ["setTimeout"] });
|
|
for (const prefixLength of [1, 2]) {
|
|
let detected = false;
|
|
const { sentry, terminal } = createProbeSentry({
|
|
hexHeaderFragmentTtlMs: undefined,
|
|
selectDownloadDirectory: async () => { detected = true; return { canceled: true }; },
|
|
});
|
|
const header = buildHexHeaderBytes("ZRQINIT");
|
|
sentry.consume(header.subarray(0, prefixLength));
|
|
t.mock.timers.tick(200);
|
|
assert.equal(joinedText(terminal), "*".repeat(prefixLength));
|
|
sentry.consume(header.subarray(prefixLength, 3));
|
|
t.mock.timers.tick(200);
|
|
sentry.consume(header.subarray(3));
|
|
await Promise.resolve();
|
|
assert.equal(detected, true, "the printable echo timeout must not reset protocol detection");
|
|
assert.equal(joinedText(terminal), "*".repeat(prefixLength));
|
|
assertNoZmodemHeaderBytes(terminal, "slow split after printable prefix");
|
|
}
|
|
});
|
|
|
|
test("stripping a slow header does not skip ordinary output after it", (t) => {
|
|
t.mock.timers.enable({ apis: ["setTimeout"] });
|
|
const { sentry, terminal } = createProbeSentry({ hexHeaderFragmentTtlMs: undefined });
|
|
const header = buildHexHeaderBytes("ZRQINIT");
|
|
sentry.consume(header.subarray(0, 2));
|
|
t.mock.timers.tick(200);
|
|
sentry.consume(Buffer.concat([header.subarray(2), Buffer.from("* next prompt")]));
|
|
t.mock.timers.tick(1000);
|
|
assert.equal(joinedText(terminal), "*** next prompt");
|
|
assertNoZmodemHeaderBytes(terminal, "ordinary output after slow header");
|
|
});
|
|
|
|
test("fragmented sz ZRQINIT preamble never reaches the terminal", () => {
|
|
const { sentry, terminal } = createProbeSentry();
|
|
const stream = Buffer.concat([
|
|
Buffer.from(DOWNLOAD_PREAMBLE_TEXT),
|
|
buildHexHeaderBytes("ZRQINIT"),
|
|
Buffer.from("$ "),
|
|
]);
|
|
|
|
for (const byte of stream) sentry.consume(Buffer.from([byte]));
|
|
|
|
assert.equal(
|
|
joinedText(terminal),
|
|
`${DOWNLOAD_PREAMBLE_TEXT}$ `,
|
|
"only the human-readable sz preamble text should be shown",
|
|
);
|
|
assertNoZmodemHeaderBytes(terminal, "byte-at-a-time");
|
|
});
|
|
|
|
test("split sz preamble leaks nothing at any chunk boundary", () => {
|
|
const header = buildHexHeaderBytes("ZRQINIT");
|
|
// Header.build().to_hex() already includes the trailing XON byte.
|
|
const stream = Buffer.concat([
|
|
Buffer.from(DOWNLOAD_PREAMBLE_TEXT),
|
|
header,
|
|
Buffer.from("$ "),
|
|
]);
|
|
|
|
for (let chunkSize = 1; chunkSize <= 24; chunkSize += 1) {
|
|
const { sentry, terminal } = createProbeSentry();
|
|
for (let i = 0; i < stream.length; i += chunkSize) {
|
|
sentry.consume(stream.subarray(i, i + chunkSize));
|
|
}
|
|
assert.equal(joinedText(terminal), `${DOWNLOAD_PREAMBLE_TEXT}$ `);
|
|
assertNoZmodemHeaderBytes(terminal, `chunkSize=${chunkSize}`);
|
|
}
|
|
});
|
|
|
|
test("fragmented rz ZRINIT preamble never reaches the terminal", () => {
|
|
const header = buildHexHeaderBytes("ZRINIT", [["CANFDX", "CANOVIO", "CANFC32"]]);
|
|
const stream = Buffer.concat([Buffer.from("root@host:~$ "), header]);
|
|
|
|
for (let chunkSize = 1; chunkSize <= 24; chunkSize += 1) {
|
|
const { sentry, terminal } = createProbeSentry();
|
|
for (let i = 0; i < stream.length; i += chunkSize) {
|
|
sentry.consume(stream.subarray(i, i + chunkSize));
|
|
}
|
|
assert.equal(
|
|
joinedText(terminal),
|
|
"root@host:~$ ",
|
|
`split ZRINIT preamble leaked for chunkSize=${chunkSize}`,
|
|
);
|
|
assertNoZmodemHeaderBytes(terminal, `rz chunkSize=${chunkSize}`);
|
|
}
|
|
});
|
|
|
|
test("bytes withheld as a header fragment are flushed after the TTL", async () => {
|
|
const { sentry, terminal } = createProbeSentry();
|
|
const stream = Buffer.from("hello *");
|
|
for (const byte of stream) sentry.consume(Buffer.from([byte]));
|
|
|
|
// The trailing "*" may be the start of a hex header, so it is withheld.
|
|
assert.equal(joinedText(terminal), "hello ");
|
|
|
|
await new Promise((resolve) => setTimeout(resolve, 80));
|
|
assert.equal(joinedText(terminal), "hello *", "TTL flush must not lose terminal output");
|
|
});
|
|
|
|
test("output that disproves a header fragment is emitted without delay", () => {
|
|
const stream = Buffer.from("text **\x18Bxy more");
|
|
for (let chunkSize = 1; chunkSize <= 6; chunkSize += 1) {
|
|
const { sentry, terminal } = createProbeSentry();
|
|
for (let i = 0; i < stream.length; i += chunkSize) {
|
|
sentry.consume(stream.subarray(i, i + chunkSize));
|
|
}
|
|
assert.equal(
|
|
joinedText(terminal),
|
|
"text **\x18Bxy more",
|
|
"a non-hex byte after the pattern stops the deferral",
|
|
);
|
|
}
|
|
});
|