@swf2es/player 0.0.0-stage → 0.1.1

package/src/playerglobal/flash/net/SharedObject.ts

@@ -0,0 +1,356 @@
+// flash.net.SharedObject, the local kind: its data kept in the host's
+// storage (Scripting.storage) as Flash's .sol file has it, written when it
+// is flushed, read when getLocal first asks for it, one object for a name
+// and path. Remote ones, getRemote's, are not here.
+//
+// A .sol file: 0x00BF, the length of what follows, "TCSO", 00 04 00 00 00
+// 00, the name (u16 length, UTF-8), the AMF version as a u32 (0 or 3),
+// then each of the data's properties: its name (AMF3: a string's U29
+// header; AMF0: u16 length), its value as writeObject writes it, and a 0.
+// Flash's size is the file's, 0 for none, as the shared-objects case has it.
+import { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+// SharedObject's private invoke codes, as its AS3 numbers them.
+const FLUSH = 2;
+const CLOSE = 3;
+const GET_SIZE = 4;
+const CLEAR = 6;
+
+/** What a name may not hold, as Flash refuses it (Error #2134); % it allows. */
+const BAD_NAME = /[~&\\;:"',<>?#\s]/;
+
+export function sharedObjectNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  /** The shared objects getLocal made, by key: one for each, as Flash's. */
+  const open = new Map<string, AsObject>();
+  let defaultEncoding = 3;
+  let preventBackup = false;
+
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  const byteArray = (encoding: number): AsObject => {
+    const array = s.rt.construct(s.rt.classNamed("flash.utils::ByteArray")) as AsObject;
+    s.rt.setProperty(array, avm2.qname(avm2.publicNs, "objectEncoding"), encoding);
+    return array;
+  };
+
+  /** What `o` serializes to now, for destroy to tell a change by; null where it cannot. */
+  const saved = (o: AsObject): Uint8Array | null => {
+    try {
+      return serialize(o);
+    } catch {
+      return null;
+    }
+  };
+
+  /** Write `o`'s .sol file, or remove it for no data: false where storage refuses, as a full quota, which flush reports as #2130. */
+  const write = (o: AsObject): boolean => {
+    const file = serialize(o);
+    try {
+      if (file.length) {
+        s.storage.set(o.$key, file);
+      } else {
+        s.storage.remove(o.$key);
+      }
+    } catch {
+      return false;
+    }
+
+    o.$saved = file;
+    return true;
+  };
+
+  /**
+   * The .sol file of `o`'s data, in its encoding; none, empty, for no
+   * properties. AMF0 is the runtime's to write, which has none yet.
+   */
+  const serialize = (o: AsObject): Uint8Array => {
+    if (o.$encoding !== 3) {
+      throw s.rt.unsupported("an AMF0 SharedObject");
+    }
+
+    // Chunks joined once at the end: a value can be large enough that
+    // spreading its bytes into one call would overflow the stack.
+    const chunks: Uint8Array[] = [];
+    for (const [key, value] of o.$data.$d ?? new Map()) {
+      const name = encoder.encode(String(key));
+      chunks.push(u29((name.length << 1) | 1), name);
+      const array = byteArray(o.$encoding);
+      s.rt.callProperty(array, avm2.qname(avm2.publicNs, "writeObject"), value);
+      const b = avm2.bytesOf(s.rt, array);
+      chunks.push(b.buffer.subarray(0, b.length), END);
+    }
+
+    if (chunks.length === 0) {
+      return new Uint8Array(0);
+    }
+
+    const name = encoder.encode(o.$name);
+    const header = new Uint8Array(6 + 10 + 2 + name.length + 4);
+    header.set([0x00, 0xbf], 0);
+    header.set([0x54, 0x43, 0x53, 0x4f, 0, 4, 0, 0, 0, 0], 6);
+    header.set([name.length >> 8, name.length & 0xff], 16);
+    header.set(name, 18);
+    header[header.length - 1] = 3;
+    let n = header.length;
+    for (const chunk of chunks) {
+      n += chunk.length;
+    }
+
+    const file = new Uint8Array(n);
+    file.set(header);
+    new DataView(file.buffer).setUint32(2, n - 6);
+    let at = header.length;
+    for (const chunk of chunks) {
+      file.set(chunk, at);
+      at += chunk.length;
+    }
+
+    return file;
+  };
+
+  /** The data a .sol file holds, or null for one it cannot read. */
+  const deserialize = (bytes: Uint8Array): AsObject | null => {
+    if (bytes.length < 18 || bytes[0] !== 0x00 || bytes[1] !== 0xbf) {
+      return null;
+    }
+
+    let at = 16;
+    const nameLength = (bytes[at] << 8) | bytes[at + 1];
+    at += 2 + nameLength;
+    const encoding = bytes[at + 3] === 3 ? 3 : 0;
+    at += 4;
+    const array = byteArray(encoding);
+    const b = avm2.bytesOf(s.rt, array);
+    b.write(bytes);
+    const data = s.rt.newObject([]);
+    try {
+      while (at < bytes.length) {
+        let length: number;
+        if (encoding === 3) {
+          const [n, next] = readU29(bytes, at);
+          length = n >> 1;
+          at = next;
+        } else {
+          length = (bytes[at] << 8) | bytes[at + 1];
+          at += 2;
+        }
+
+        const key = decoder.decode(bytes.subarray(at, at + length));
+        b.position = (at + length) >>> 0;
+        const value = s.rt.callProperty(array, avm2.qname(avm2.publicNs, "readObject"));
+        s.rt.setProperty(data, avm2.qname(avm2.publicNs, key), value);
+        // The 0 after each value.
+        at = b.position + 1;
+      }
+    } catch {
+      return null;
+    }
+
+    return data;
+  };
+
+  const unavailable = (url: Value): never => {
+    if (url === null || url === undefined) {
+      throw s.rt.error("TypeError", 2007, "url");
+    }
+
+    throw s.rt.error("Error", 2014);
+  };
+
+  class SharedObjectNatives {
+    declare $data: AsObject;
+    declare $key: string;
+    declare $name: string;
+    declare $encoding: number;
+    declare $client: Value;
+    // What it serialized to when last read or written: a change from it is what destroy writes.
+    declare $saved: Uint8Array | null;
+
+    static getLocal(name: Value, localPath: Value, secure: Value): Value {
+      if (name === null || name === undefined) {
+        throw s.rt.error("TypeError", 2007, "name");
+      }
+
+      const text = s.rt.toString(name);
+      if (text === "" || BAD_NAME.test(text)) {
+        throw s.rt.error("Error", 2134);
+      }
+
+      // The SWF whose code asks, which a loaded one's is, not the main SWF.
+      const url = new URL(s.code.codeUrl(), "file:///");
+      // A secure one only for a SWF that came over HTTPS; adl, whose SWFs
+      // never do, refuses it so.
+      if (secure && url.protocol !== "https:") {
+        throw s.rt.error("Error", 2134);
+      }
+
+      // By default the SWF's own path, file name and all, which is never a
+      // directory's; one known by no file name is kept apart from its
+      // directory's as well. A path it names must lead to the SWF: "/" or
+      // one of the directories above it, as adl refuses any other.
+      const own = url.pathname.endsWith("/") ? `${url.pathname}[swf]` : url.pathname;
+      let path = own;
+      if (localPath !== null && localPath !== undefined) {
+        path = s.rt.toString(localPath);
+        const directory = path.endsWith("/") ? path : `${path}/`;
+        if (path !== own && !own.startsWith(directory)) {
+          throw s.rt.error("Error", 2134);
+        }
+      }
+
+      // Secure ones apart: a SWF that comes over HTTP never sees them.
+      const key = `${url.host}${path.startsWith("/") ? "" : "/"}${path}/${text}${secure ? "#secure" : ""}`;
+      const known = open.get(key);
+      if (known) {
+        return known;
+      }
+
+      const o = s.rt.construct(s.rt.classNamed("flash.net::SharedObject")) as AsObject;
+      o.$key = key;
+      o.$name = text;
+      o.$encoding = defaultEncoding;
+      o.$client = o;
+      const stored = s.storage.get(key);
+      o.$data = (stored && deserialize(stored)) ?? s.rt.newObject([]);
+      o.$saved = saved(o);
+      open.set(key, o);
+      return o;
+    }
+
+    // Hidden from authoring tools, and refused to content: a SWF in the
+    // browser's Flash Player 32 or in adl gets Error #2014 whatever it
+    // names, its own site included, and nothing is deleted. Taking them
+    // as named would let any SWF on a page's origin measure or wipe every
+    // other SWF's saves there.
+    static deleteAll(url: Value): number {
+      return unavailable(url);
+    }
+
+    static getDiskUsage(url: Value): number {
+      return unavailable(url);
+    }
+
+    static get defaultObjectEncoding(): number {
+      return defaultEncoding;
+    }
+
+    static set defaultObjectEncoding(v: Value) {
+      defaultEncoding = s.rt.toUint(v) === 0 ? 0 : 3;
+    }
+
+    static get "flash.net:SharedObject::preventBackupImpl"(): boolean {
+      return preventBackup;
+    }
+
+    static set "flash.net:SharedObject::preventBackupImpl"(v: Value) {
+      preventBackup = !!v;
+    }
+
+    get data(): Value {
+      return this.$data;
+    }
+
+    get objectEncoding(): number {
+      return this.$encoding;
+    }
+
+    set objectEncoding(v: Value) {
+      this.$encoding = s.rt.toUint(v) === 0 ? 0 : 3;
+    }
+
+    get client(): Value {
+      return this.$client;
+    }
+
+    set client(v: Value) {
+      this.$client = v;
+    }
+
+    setDirty(_name: Value): void {}
+
+    // Flush returns true, which flush reports as FLUSHED, or false for #2130.
+    "flash.net:SharedObject::invoke"(code: Value, ..._args: Value[]): Value {
+      switch (s.rt.toUint(code)) {
+        case FLUSH:
+          return write(this);
+        case GET_SIZE:
+          return serialize(this).length;
+        case CLEAR:
+          this.$data = s.rt.newObject([]);
+          this.$saved = new Uint8Array(0);
+          s.storage.remove(this.$key);
+          return undefined;
+        case CLOSE:
+          return undefined;
+        default:
+          throw s.rt.unsupported("SharedObject's remote calls");
+      }
+    }
+  }
+
+  // Flash wrote each open object as its SWF went: a destroyed player
+  // writes those a script changed since they were read or written. Never
+  // a removal: an object whose stored file it could not read starts empty,
+  // and an unchanged one would take the file away.
+  s.flushSharedObjects = () => {
+    for (const o of open.values()) {
+      try {
+        const file = serialize(o);
+        if (file.length && !sameBytes(file, o.$saved)) {
+          s.storage.set(o.$key, file);
+        }
+      } catch {
+        // One that cannot be written, AMF0's or a full quota's, keeps the others from nothing.
+      }
+    }
+  };
+
+  avm2.registerNativeClass(natives, "flash.net::SharedObject", SharedObjectNatives);
+  return natives;
+}
+
+function sameBytes(a: Uint8Array, b: Uint8Array | null): boolean {
+  return b !== null && a.length === b.length && a.every((byte, i) => byte === b[i]);
+}
+
+/** The 0 after each value. */
+const END = new Uint8Array(1);
+
+/** An AMF3 U29: 1 to 4 bytes, 7 bits each but the fourth's 8. */
+function u29(n: number): Uint8Array {
+  if (n < 0x80) {
+    return Uint8Array.of(n);
+  }
+  if (n < 0x4000) {
+    return Uint8Array.of((n >> 7) | 0x80, n & 0x7f);
+  }
+  if (n < 0x200000) {
+    return Uint8Array.of((n >> 14) | 0x80, ((n >> 7) & 0x7f) | 0x80, n & 0x7f);
+  }
+
+  return Uint8Array.of(
+    (n >> 22) | 0x80,
+    ((n >> 15) & 0x7f) | 0x80,
+    ((n >> 8) & 0x7f) | 0x80,
+    n & 0xff,
+  );
+}
+
+/** The U29 at `at`, and where what follows it starts. */
+function readU29(bytes: Uint8Array, at: number): [number, number] {
+  let n = 0;
+  for (let i = 0; i < 3; i++) {
+    const b = bytes[at++];
+    n = (n << 7) | (b & 0x7f);
+    if (!(b & 0x80)) {
+      return [n, at];
+    }
+  }
+
+  return [(n << 8) | bytes[at], at + 1];
+}

package/src/playerglobal/flash/net/Socket.ts

@@ -0,0 +1,360 @@
+// flash.net.Socket: DataInput/DataOutput over a host-provided TCP transport.
+import { avm2 } from "@swf2es/runtime";
+import type { SocketEndpoints, SocketTransport } from "../../../hosts.js";
+import { dispatchEvent } from "../../../scripting/events.js";
+import type { Scripting } from "../../../scripting.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+interface Connection {
+  input: AsObject;
+  output: AsObject;
+  transport: SocketTransport | null;
+  generation: number;
+  connected: boolean;
+  connecting: boolean;
+  failed: boolean;
+  /** Null before a connection and after close(); UNKNOWN while one opens, or open where the host does not know them. */
+  endpoints: SocketEndpoints | null;
+}
+
+const UNKNOWN: SocketEndpoints = {
+  localAddress: "",
+  localPort: 0,
+  remoteAddress: "",
+  remotePort: 0,
+};
+
+export function socketNatives(s: Scripting): avm2.Natives {
+  const natives: avm2.Natives = {};
+  const connections = new WeakMap<AsObject, Connection>();
+  const byteArray = () => s.rt.classNamed("flash.utils::ByteArray");
+  const connection = (o: AsObject): Connection => {
+    let c = connections.get(o);
+    if (!c) {
+      c = {
+        input: s.rt.construct(byteArray()),
+        output: s.rt.construct(byteArray()),
+        transport: null,
+        generation: 0,
+        connected: false,
+        connecting: false,
+        failed: false,
+        endpoints: null,
+      };
+      connections.set(o, c);
+    }
+
+    return c;
+  };
+  // The runtime's message, which is the debugger player's text or the release player's number alone.
+  const invalid = (): never => {
+    throw s.rt.error("flash.errors::IOError", 2002);
+  };
+  const active = (o: AsObject): Connection => {
+    const c = connection(o);
+    if (!c.connected) {
+      invalid();
+    }
+
+    return c;
+  };
+  const input = (o: AsObject, method: string, ...args: Value[]): Value =>
+    s.rt.callProperty(active(o).input, s.rt.publicName(method), ...args);
+  const output = (o: AsObject, method: string, ...args: Value[]): Value =>
+    s.rt.callProperty(active(o).output, s.rt.publicName(method), ...args);
+  const event = (o: AsObject, type: string): void => {
+    dispatchEvent(s, o, s.event(type));
+  };
+
+  class SocketNatives {
+    "flash.net:Socket::internalGetSecurityErrorMessage"(host: Value, port: Value): string {
+      return `Error #2048: Security sandbox violation: ${String(host)}:${Number(port)}`;
+    }
+
+    "flash.net:Socket::internalConnect"(host: Value, port: Value): void {
+      const c = connection(this);
+      c.transport?.close();
+      c.generation++;
+      c.transport = null;
+      c.connected = false;
+      c.connecting = true;
+      c.failed = false;
+      c.endpoints = UNKNOWN;
+      avm2.bytesOf(s.rt, c.input).clear();
+      avm2.bytesOf(s.rt, c.output).clear();
+      const generation = c.generation;
+      const current = () => c.generation === generation;
+      const fail = (message: string) => {
+        if (!current()) {
+          return;
+        }
+
+        c.generation++;
+        c.connecting = false;
+        c.connected = false;
+        c.transport?.close();
+        c.transport = null;
+        c.failed = true;
+        dispatchEvent(
+          s,
+          this,
+          s.rt.construct(
+            s.rt.classNamed("flash.events::IOErrorEvent"),
+            "ioError",
+            false,
+            false,
+            message,
+          ),
+        );
+      };
+      if (!s.socket) {
+        s.loads.deferHostEvent(() => fail("Error #2031: Socket Error."));
+        return;
+      }
+
+      try {
+        c.transport = s.socket.connect(
+          host === null ? "localhost" : s.rt.toString(host),
+          s.rt.toInt(port),
+          {
+            open: (endpoints) =>
+              s.loads.deferHostEvent(() => {
+                if (!current()) {
+                  return;
+                }
+
+                c.connecting = false;
+                c.connected = true;
+                c.endpoints = endpoints ? { ...endpoints } : UNKNOWN;
+                event(this, "connect");
+              }),
+            data: (bytes) => {
+              const copy = bytes.slice();
+              s.loads.deferHostEvent(() => {
+                if (!current() || !c.connected) {
+                  return;
+                }
+
+                const buffer = avm2.bytesOf(s.rt, c.input);
+                if (buffer.position >= 65536 && buffer.position * 2 >= buffer.length) {
+                  const unread = buffer.available;
+                  buffer.buffer.copyWithin(0, buffer.position, buffer.length);
+                  buffer.setLength(unread);
+                  buffer.position = 0;
+                }
+
+                const position = buffer.position;
+                buffer.position = buffer.length;
+                buffer.write(copy);
+                buffer.position = position;
+                dispatchEvent(
+                  s,
+                  this,
+                  s.rt.construct(
+                    s.rt.classNamed("flash.events::ProgressEvent"),
+                    "socketData",
+                    false,
+                    false,
+                    copy.length,
+                    0,
+                  ),
+                );
+              });
+            },
+            close: () =>
+              s.loads.deferHostEvent(() => {
+                if (!current()) {
+                  return;
+                }
+
+                if (c.connecting) {
+                  fail("Error #2031: Socket Error.");
+                  return;
+                }
+
+                c.connected = false;
+                c.connecting = false;
+                c.transport = null;
+                event(this, "close");
+              }),
+            error: (message) => s.loads.deferHostEvent(() => fail(message)),
+          },
+        );
+      } catch (e) {
+        s.loads.deferHostEvent(() => fail(String(e)));
+      }
+    }
+
+    "flash.net:Socket::didFailureOccur"(): boolean {
+      return connection(this).failed;
+    }
+
+    "flash.net:Socket::internalClose"(): void {
+      const c = connection(this);
+      if (!c.connected && !c.connecting) {
+        invalid();
+      }
+
+      c.generation++;
+      c.transport?.close();
+      c.transport = null;
+      c.connected = false;
+      c.connecting = false;
+      c.endpoints = null;
+    }
+
+    "flash.net:Socket::OnError"(): void {}
+
+    "flash.net:Socket::wasCalledByAppContent"(): boolean {
+      return false;
+    }
+
+    /**
+     * AIR's, as adl reads them: null and 0 before a connection and after
+     * close(), "" and 0 while one opens or after it fails, and the ends,
+     * resolved, once open, kept after the peer closes.
+     */
+    get localAddress(): string | null {
+      return connection(this).endpoints?.localAddress ?? null;
+    }
+
+    get localPort(): number {
+      return connection(this).endpoints?.localPort ?? 0;
+    }
+
+    get remoteAddress(): string | null {
+      return connection(this).endpoints?.remoteAddress ?? null;
+    }
+
+    get remotePort(): number {
+      return connection(this).endpoints?.remotePort ?? 0;
+    }
+
+    get connected(): boolean {
+      return connection(this).connected;
+    }
+
+    get bytesAvailable(): number {
+      return avm2.bytesOf(s.rt, connection(this).input).available;
+    }
+
+    get bytesPending(): number {
+      return avm2.bytesOf(s.rt, connection(this).output).length;
+    }
+
+    flush(): void {
+      const c = active(this);
+      const bytes = avm2.bytesOf(s.rt, c.output);
+      if (bytes.length !== 0) {
+        c.transport?.send(bytes.buffer.slice(0, bytes.length));
+        bytes.setLength(0);
+        bytes.position = 0;
+      }
+    }
+
+    readBytes(bytes: Value, offset: Value, length: Value): void {
+      input(this, "readBytes", bytes, offset, length);
+    }
+    readBoolean(): Value {
+      return input(this, "readBoolean");
+    }
+    readByte(): Value {
+      return input(this, "readByte");
+    }
+    readUnsignedByte(): Value {
+      return input(this, "readUnsignedByte");
+    }
+    readShort(): Value {
+      return input(this, "readShort");
+    }
+    readUnsignedShort(): Value {
+      return input(this, "readUnsignedShort");
+    }
+    readInt(): Value {
+      return input(this, "readInt");
+    }
+    readUnsignedInt(): Value {
+      return input(this, "readUnsignedInt");
+    }
+    readFloat(): Value {
+      return input(this, "readFloat");
+    }
+    readDouble(): Value {
+      return input(this, "readDouble");
+    }
+    readUTF(): Value {
+      return input(this, "readUTF");
+    }
+    readUTFBytes(length: Value): Value {
+      return input(this, "readUTFBytes", length);
+    }
+    readMultiByte(length: Value, charset: Value): Value {
+      return input(this, "readMultiByte", length, charset);
+    }
+    readObject(): Value {
+      return input(this, "readObject");
+    }
+
+    writeBytes(bytes: Value, offset: Value, length: Value): void {
+      output(this, "writeBytes", bytes, offset, length);
+    }
+    writeBoolean(value: Value): void {
+      output(this, "writeBoolean", value);
+    }
+    writeByte(value: Value): void {
+      output(this, "writeByte", value);
+    }
+    writeShort(value: Value): void {
+      output(this, "writeShort", value);
+    }
+    writeInt(value: Value): void {
+      output(this, "writeInt", value);
+    }
+    writeUnsignedInt(value: Value): void {
+      output(this, "writeUnsignedInt", value);
+    }
+    writeFloat(value: Value): void {
+      output(this, "writeFloat", value);
+    }
+    writeDouble(value: Value): void {
+      output(this, "writeDouble", value);
+    }
+    writeMultiByte(value: Value, charset: Value): void {
+      output(this, "writeMultiByte", value, charset);
+    }
+    writeUTF(value: Value): void {
+      output(this, "writeUTF", value);
+    }
+    writeUTFBytes(value: Value): void {
+      output(this, "writeUTFBytes", value);
+    }
+    writeObject(value: Value): void {
+      output(this, "writeObject", value);
+    }
+
+    get objectEncoding(): Value {
+      return s.rt.getProperty(connection(this).input, s.rt.publicName("objectEncoding"));
+    }
+
+    set objectEncoding(value: Value) {
+      const c = connection(this);
+      s.rt.setProperty(c.input, s.rt.publicName("objectEncoding"), value);
+      s.rt.setProperty(c.output, s.rt.publicName("objectEncoding"), value);
+    }
+
+    get endian(): Value {
+      return s.rt.getProperty(connection(this).input, s.rt.publicName("endian"));
+    }
+
+    set endian(value: Value) {
+      const c = connection(this);
+      s.rt.setProperty(c.input, s.rt.publicName("endian"), value);
+      s.rt.setProperty(c.output, s.rt.publicName("endian"), value);
+    }
+  }
+
+  avm2.registerNativeClass(natives, "flash.net::Socket", SocketNatives);
+  return natives;
+}