@swf2es/desktop 0.0.0-stage → 0.1.14

package/src/main/connections.ts

@@ -0,0 +1,125 @@
+// One page's flash.net.Socket connections, made with node:net: what the
+// socket bridge (sockets.ts) holds for each page, apart from Electron so
+// that node runs it in the tests (tests/desktop/connections.test.ts).
+import { connect, type Socket } from "node:net";
+import type { SocketEvent } from "../shared/api.js";
+
+/** As many as a page may hold open at once; past it a connection is refused. */
+const MAX_OPEN = 64;
+
+/**
+ * The bytes a connection may hold unsent. A peer that stops reading would
+ * otherwise have the main process buffer all a SWF writes: 100 writes of
+ * 8 MB took it from 238 to 1038 MB. Past this the connection fails, as
+ * Flash's did when a write could not go.
+ */
+export const MAX_BUFFERED = 4 * 1024 * 1024;
+
+const SOCKET_ERROR = "Error #2031: Socket Error.";
+
+/** Whether the page asked for a host name of DNS's length and a TCP port. */
+export function validEndpoint(host: unknown, port: unknown): host is string {
+  return (
+    typeof host === "string" &&
+    host.length > 0 &&
+    host.length <= 255 &&
+    typeof port === "number" &&
+    Number.isInteger(port) &&
+    port > 0 &&
+    port < 65536
+  );
+}
+
+export class Connections {
+  private readonly sockets = new Map<number, Socket>();
+  private readonly tell: (id: number, event: SocketEvent) => void;
+
+  /** `tell` carries each connection's events to its page. */
+  constructor(tell: (id: number, event: SocketEvent) => void) {
+    this.tell = tell;
+  }
+
+  get size(): number {
+    return this.sockets.size;
+  }
+
+  /** Counts closeAll's: a connection decided on before one belongs to a page that is gone. */
+  generation = 0;
+
+  /**
+   * Connect `id` to `host`:`port`, each checked, as the page asks, at `address` where the host's
+   * was pinned (a remote SWF's socket policy came from there); a refusal is an error, then a close.
+   */
+  connect(id: number, host: unknown, port: unknown, address?: string): void {
+    if (!validEndpoint(host, port) || this.sockets.has(id) || this.sockets.size >= MAX_OPEN) {
+      this.refuse(id);
+      return;
+    }
+
+    const socket = connect({ host: address ?? host, port: port as number });
+    this.sockets.set(id, socket);
+    socket.on("connect", () =>
+      this.tell(id, {
+        type: "open",
+        localAddress: socket.localAddress ?? "",
+        localPort: socket.localPort ?? 0,
+        remoteAddress: socket.remoteAddress ?? "",
+        remotePort: socket.remotePort ?? 0,
+      }),
+    );
+    socket.on("data", (bytes) => this.tell(id, { type: "data", bytes: new Uint8Array(bytes) }));
+    socket.on("error", () => this.tell(id, { type: "error", message: SOCKET_ERROR }));
+    socket.on("close", () => {
+      // Only the socket under this id: a page that reused it has another by now.
+      if (this.sockets.get(id) === socket) {
+        this.sockets.delete(id);
+      }
+
+      this.tell(id, { type: "close" });
+    });
+  }
+
+  /**
+   * Write `bytes`, unless the peer has left more than MAX_BUFFERED unread: then the connection
+   * fails.
+   */
+  send(id: number, bytes: Uint8Array): void {
+    const socket = this.sockets.get(id);
+    if (!socket || socket.destroyed) {
+      return;
+    }
+
+    if (socket.writableLength + bytes.length > MAX_BUFFERED) {
+      this.tell(id, { type: "error", message: SOCKET_ERROR });
+      socket.destroy();
+      return;
+    }
+
+    socket.write(bytes);
+  }
+
+  /** Refuse `id`, as a server that took no connection: an error, then a close. */
+  refuse(id: number): void {
+    this.tell(id, { type: "error", message: SOCKET_ERROR });
+    this.tell(id, { type: "close" });
+  }
+
+  close(id: number): void {
+    this.sockets.get(id)?.destroy();
+  }
+
+  /**
+   * Close every connection without a word: the page that held them is gone, and the next numbers
+   * its own from 1.
+   */
+  closeAll(): void {
+    for (const socket of this.sockets.values()) {
+      socket.removeAllListeners();
+      socket.on("error", () => {});
+      socket.destroy();
+    }
+
+    this.sockets.clear();
+    this.generation++;
+  }
+}

package/src/main/decompress.ts

@@ -0,0 +1,219 @@
+// A response body a server sent compressed, unasked, decompressed as it
+// streams in, as Chromium decompresses it (network.ts). Without Electron,
+// so that node tests it (tests/desktop/network.test.ts).
+import type { Transform } from "node:stream";
+import { createBrotliDecompress, createInflate, createInflateRaw } from "node:zlib";
+
+/** What a server may send compressed, unasked, that is decompressed; any other goes as it came. */
+export const DECODED = new Set(["gzip", "x-gzip", "br", "deflate"]);
+
+/** The longest gzip header read, its name and comment included. */
+export const GZIP_HEADER_MAX = 64 * 1024;
+
+/**
+ * A gzip header read as its bytes come: kept in an array that doubles as
+ * it fills, and parsed on from where the last chunk left off, so that a
+ * header sent a byte at a time costs no more than one sent whole. One
+ * whose end lies past GZIP_HEADER_MAX is refused, however it is chunked.
+ */
+export class GzipHeader {
+  private bytes = new Uint8Array(64);
+  private length = 0;
+  /** Where parsing goes on from, and in which part: fixed bytes, extra, name, comment, CRC. */
+  private at = 0;
+  private part = 0;
+
+  /** What came so far. */
+  get buffered(): Uint8Array {
+    return this.bytes.subarray(0, this.length);
+  }
+
+  /** Add `chunk`: the header's length once whole, 0 while more is needed, -1 if it is none. */
+  add(chunk: Uint8Array): number {
+    if (this.length + chunk.length > this.bytes.length) {
+      let capacity = this.bytes.length * 2;
+      while (capacity < this.length + chunk.length) {
+        capacity *= 2;
+      }
+
+      const grown = new Uint8Array(capacity);
+      grown.set(this.buffered);
+      this.bytes = grown;
+    }
+
+    this.bytes.set(chunk, this.length);
+    this.length += chunk.length;
+    const end = this.parse();
+    return end > GZIP_HEADER_MAX || (end === 0 && this.at > GZIP_HEADER_MAX) ? -1 : end;
+  }
+
+  private parse(): number {
+    const bytes = this.buffered;
+    const flags = bytes[3];
+    for (;;) {
+      switch (this.part) {
+        case 0: {
+          const magic = [0x1f, 0x8b, 8];
+          for (let i = 0; i < Math.min(3, bytes.length); i++) {
+            if (bytes[i] !== magic[i]) {
+              return -1;
+            }
+          }
+
+          if (bytes.length < 10) {
+            return 0;
+          }
+
+          this.at = 10;
+          this.part = 1;
+          break;
+        }
+        case 1:
+          if (flags & 4) {
+            if (bytes.length < this.at + 2) {
+              return 0;
+            }
+
+            this.at += 2 + (bytes[this.at] | (bytes[this.at + 1] << 8));
+          }
+
+          this.part = 2;
+          break;
+        case 2:
+        case 3: {
+          // FNAME, then FCOMMENT: each up to its NUL, sought only in what is new.
+          if (flags & (this.part === 2 ? 8 : 16)) {
+            if (this.at > bytes.length) {
+              return 0;
+            }
+
+            const nul = bytes.indexOf(0, this.at);
+            if (nul < 0) {
+              this.at = bytes.length;
+              return 0;
+            }
+
+            this.at = nul + 1;
+          }
+
+          this.part++;
+          break;
+        }
+        default:
+          return bytes.length >= this.at + (flags & 2 ? 2 : 0) ? this.at + (flags & 2 ? 2 : 0) : 0;
+      }
+    }
+  }
+}
+
+/**
+ * Decompresses one body of gzip, deflate or br, choosing its inflater
+ * once its first bytes are in: gzip's header is read here and its deflate
+ * stream inflated raw, so that what follows the stream (its footer, and
+ * whatever a server put after it) is ignored, as Chromium ignores it;
+ * deflate is zlib's stream or a raw one, as its first two bytes tell.
+ */
+export class Decompressor {
+  /** The first bytes, while they do not yet tell deflate's kind (no more than two). */
+  private head = new Uint8Array(0);
+  private gzip: GzipHeader | null = null;
+  private inflater: Transform | null = null;
+  /** Called once the inflater wants more after a write said to wait. */
+  onDrain: () => void = () => {};
+
+  private readonly coding: string;
+  private readonly data: (chunk: Buffer) => void;
+  private readonly done: () => void;
+  private readonly failed: () => void;
+
+  constructor(coding: string, data: (chunk: Buffer) => void, done: () => void, failed: () => void) {
+    this.coding = coding;
+    this.data = data;
+    this.done = done;
+    this.failed = failed;
+  }
+
+  /** Whether more may be written now. */
+  write(chunk: Buffer): boolean {
+    if (this.inflater) {
+      return this.inflater.write(chunk);
+    }
+
+    if (this.coding !== "br" && this.coding !== "deflate") {
+      this.gzip ??= new GzipHeader();
+      const end = this.gzip.add(chunk);
+      if (end === 0) {
+        return true;
+      }
+
+      if (end < 0) {
+        this.failed();
+        return false;
+      }
+
+      return this.start(createInflateRaw(), this.gzip.buffered.subarray(end));
+    }
+
+    const head = new Uint8Array(this.head.length + chunk.length);
+    head.set(this.head);
+    head.set(chunk, this.head.length);
+    this.head = head;
+    return this.choose(false);
+  }
+
+  end(): void {
+    if (!this.inflater && this.gzip) {
+      // A gzip header that never ended.
+      this.failed();
+      return;
+    }
+
+    if (!this.inflater && !this.choose(true)) {
+      return;
+    }
+
+    if (this.inflater) {
+      this.inflater.end();
+    } else {
+      // Nothing came: nothing to undo.
+      this.done();
+    }
+  }
+
+  destroy(): void {
+    this.inflater?.destroy();
+  }
+
+  /** Make the inflater once the bytes so far tell which (`last`: no more come); false: failed. */
+  private choose(last: boolean): boolean {
+    const head = this.head;
+    if (head.length === 0) {
+      return true;
+    }
+
+    if (this.coding === "br") {
+      return this.start(createBrotliDecompress(), head);
+    }
+
+    // Deflate: zlib's stream or a raw one, as its first two bytes tell.
+    if (head.length < 2 && !last) {
+      return true;
+    }
+
+    const zlib =
+      head.length >= 2 && (head[0] & 0x0f) === 8 && ((head[0] << 8) | head[1]) % 31 === 0;
+    return this.start(zlib ? createInflate() : createInflateRaw(), head);
+  }
+
+  /** Inflate with `inflater` from `first` on. */
+  private start(inflater: Transform, first: Uint8Array): boolean {
+    this.inflater = inflater;
+    this.head = new Uint8Array(0);
+    this.gzip = null;
+    inflater.on("data", this.data);
+    inflater.on("end", this.done);
+    inflater.on("error", this.failed);
+    inflater.on("drain", () => this.onDrain());
+    return first.length === 0 || inflater.write(first);
+  }
+}

package/src/main/files.ts

@@ -0,0 +1,147 @@
+// A dialog grants an opaque capability, never a renderer-supplied path.
+import { readFile, stat, writeFile } from "node:fs/promises";
+import { basename } from "node:path";
+import type {
+  BrowserWindow,
+  Dialog,
+  IpcMain,
+  IpcMainEvent,
+  IpcMainInvokeEvent,
+  WebContents,
+} from "electron";
+
+type Event = IpcMainEvent | IpcMainInvokeEvent;
+type FileBridgeHost = {
+  ipcMain: Pick<IpcMain, "handle" | "on">;
+  dialog: Pick<Dialog, "showOpenDialog" | "showSaveDialog">;
+};
+
+export function bridgeFiles(
+  trusted: (event: Event) => boolean,
+  window: () => BrowserWindow | null,
+  gesture: () => boolean,
+  { ipcMain, dialog }: FileBridgeHost,
+): void {
+  const grants = new Map<number, { path: string; write: boolean }>();
+  let next = 1;
+  let dialogOpen = false;
+  let generation = 0;
+  const revoke = () => {
+    generation++;
+    grants.clear();
+  };
+  const watched = new WeakSet<WebContents>();
+  const watch = (owner: BrowserWindow) => {
+    const contents = owner.webContents;
+    if (watched.has(contents)) {
+      return;
+    }
+
+    watched.add(contents);
+    contents.on("did-start-navigation", (details) => {
+      if (details.isMainFrame && !details.isSameDocument) {
+        revoke();
+      }
+    });
+    contents.once("destroyed", revoke);
+  };
+  ipcMain.on("files:release", (event, id: unknown) => {
+    if (trusted(event) && typeof id === "number") {
+      grants.delete(id);
+    }
+  });
+  const check = (event: Event, id: unknown, write: boolean): string => {
+    const grant = typeof id === "number" ? grants.get(id) : undefined;
+    if (!trusted(event) || !grant || grant.write !== write) {
+      throw new Error("invalid file capability");
+    }
+    return grant.path;
+  };
+  ipcMain.handle("files:read", (event, id: unknown) => readFile(check(event, id, false)));
+  ipcMain.handle("files:write", async (event, id: unknown, bytes: unknown) => {
+    const path = check(event, id, true);
+    if (!(bytes instanceof Uint8Array)) {
+      throw new Error("invalid file bytes");
+    }
+    grants.delete(id as number);
+    await writeFile(path, bytes);
+  });
+  ipcMain.handle("files:browse", async (event, filters: unknown, multiple: unknown) => {
+    const owner = window();
+    if (!trusted(event) || !owner || dialogOpen || !gesture()) {
+      return [];
+    }
+
+    watch(owner);
+    const opened = generation;
+    const current = () => trusted(event) && owner === window() && generation === opened;
+    dialogOpen = true;
+    try {
+      const result = await dialog.showOpenDialog(owner, {
+        properties: multiple === true ? ["openFile", "multiSelections"] : ["openFile"],
+        filters: Array.isArray(filters)
+          ? filters.slice(0, 100).flatMap((filter) => {
+              if (
+                typeof filter?.description !== "string" ||
+                typeof filter?.extension !== "string"
+              ) {
+                return [];
+              }
+              const extensions = filter.extension
+                .split(";")
+                .map((ext: string) => ext.trim().replace(/^\*\./, ""))
+                .filter((ext: string) => /^[\w-]+$/.test(ext));
+              return extensions.length ? [{ name: filter.description, extensions }] : [];
+            })
+          : [],
+      });
+      if (result.canceled || !current()) {
+        return [];
+      }
+
+      const selected = await Promise.all(
+        result.filePaths.map(async (path) => ({ path, info: await stat(path) })),
+      );
+      if (!current()) {
+        return [];
+      }
+
+      return selected.map(({ path, info }) => {
+        const id = next++;
+        grants.set(id, { path, write: false });
+        return {
+          id,
+          name: basename(path),
+          size: info.size,
+          modificationDate: info.mtimeMs,
+          creationDate: info.birthtimeMs,
+        };
+      });
+    } finally {
+      dialogOpen = false;
+    }
+  });
+  ipcMain.handle("files:save", async (event, name: unknown) => {
+    const owner = window();
+    if (!trusted(event) || !owner || typeof name !== "string" || dialogOpen || !gesture()) {
+      return null;
+    }
+
+    watch(owner);
+    const opened = generation;
+    const current = () => trusted(event) && owner === window() && generation === opened;
+    dialogOpen = true;
+    try {
+      const result = await dialog.showSaveDialog(owner, { defaultPath: basename(name) });
+      if (result.canceled || !result.filePath || !current()) {
+        return null;
+      }
+
+      const id = next++;
+      grants.set(id, { path: result.filePath, write: true });
+      return { id, name: basename(result.filePath) };
+    } finally {
+      dialogOpen = false;
+    }
+  });
+}