@yume-chan/adb 2.6.2 → 3.0.0-beta.0

package/src/service/sync/socket.ts

@@ -0,0 +1,201 @@
+import { getUint32LittleEndian } from "@yume-chan/no-data-view";
+import type {
+    MaybeConsumable,
+    WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+import {
+    BufferCombiner,
+    BufferedReadableStream,
+    clearTimeout,
+    Consumable,
+    setTimeout,
+    tryCancel,
+} from "@yume-chan/stream-extra";
+import type { AsyncExactReadable, StructDeserializer } from "@yume-chan/struct";
+import { decodeUtf8, string, struct, u32 } from "@yume-chan/struct";
+
+import type { Adb } from "../../adb.js";
+import { AutoResetEvent, encodeUtf8, unreachable } from "../../utils/index.js";
+
+import { ResponseId } from "./id/index.js";
+
+const NumberRequest = struct({ id: u32, arg: u32 }, { littleEndian: true });
+
+class AdbSyncError extends Error {}
+export { AdbSyncError as Error };
+
+const FailResponse = struct(
+    { message: string(u32) },
+    {
+        littleEndian: true,
+        postDeserialize(value) {
+            throw new AdbSyncError(value.message);
+        },
+    },
+);
+
+function i32ToHex(i: number) {
+    return "0x" + i.toString(16).padStart(8, "0");
+}
+
+export class Socket implements AsyncExactReadable {
+    static readonly NumberRequest = NumberRequest;
+    static readonly FailResponse = FailResponse;
+
+    readonly #socket: Adb.Socket;
+    readonly #writer: WritableStreamDefaultWriter<MaybeConsumable<Uint8Array>>;
+    readonly #readable: BufferedReadableStream;
+    readonly #writeLock = new AutoResetEvent();
+    readonly #combiner: BufferCombiner;
+    #idleTimeoutId: ReturnType<typeof setTimeout> | null = null;
+
+    get position() {
+        return this.#readable.position;
+    }
+
+    get closed(): Promise<undefined> {
+        return this.#socket.closed;
+    }
+
+    constructor(socket: Adb.Socket, bufferSize: number) {
+        this.#socket = socket;
+        this.#writer = socket.writable.getWriter();
+        this.#readable = new BufferedReadableStream(socket.readable);
+        this.#combiner = new BufferCombiner(bufferSize);
+    }
+
+    /**
+     * Start an idle timer that will close the socket after the specified duration.
+     * The timer is automatically cancelled when the socket is used.
+     * @param timeout The timeout in milliseconds
+     * @param callback The callback to invoke when the timeout expires
+     */
+    startIdleTimer(timeout: number, callback: () => void) {
+        this.clearIdleTimer();
+        this.#idleTimeoutId = setTimeout(callback, timeout);
+    }
+
+    /**
+     * Clear the idle timer.
+     */
+    clearIdleTimer() {
+        if (this.#idleTimeoutId !== null) {
+            clearTimeout(this.#idleTimeoutId);
+            this.#idleTimeoutId = null;
+        }
+    }
+
+    /**
+     * Write a packet to the socket.
+     * @param packet The packet to write. Must be smaller than the buffer size.
+     */
+    #writeOne(packet: Uint8Array) {
+        // `#combiner` will reuse the buffer, so we need to use the Consumable pattern
+        return Consumable.WritableStream.write(this.#writer, packet);
+    }
+
+    async #withWriteLock(callback: () => Promise<void>) {
+        try {
+            await this.#writeLock.wait();
+            await callback();
+        } finally {
+            this.#writeLock.notifyOne();
+        }
+    }
+
+    async flush() {
+        const buffer = this.#combiner.flush();
+        if (buffer) {
+            await this.#withWriteLock(() => this.#writeOne(buffer));
+        }
+    }
+
+    async #write(data: Uint8Array) {
+        for (const buffer of this.#combiner.push(data)) {
+            await this.#writeOne(buffer);
+        }
+    }
+
+    write(data: Uint8Array) {
+        return this.#withWriteLock(() => this.#write(data));
+    }
+
+    async writeRequest(id: number, value: number | string | Uint8Array) {
+        return this.#withWriteLock(async () => {
+            if (typeof value === "number") {
+                await this.#write(NumberRequest.serialize({ id, arg: value }));
+                return;
+            }
+
+            if (typeof value === "string") {
+                value = encodeUtf8(value);
+            }
+
+            await this.#write(
+                NumberRequest.serialize({ id, arg: value.length }),
+            );
+            await this.#write(value);
+        });
+    }
+
+    async readExactly(length: number) {
+        // The request may still be in the internal buffer.
+        // Call `flush` to send it before starting reading
+        await this.flush();
+        return await this.#readable.readExactly(length);
+    }
+
+    async readResponse<T>(id: number, type: StructDeserializer<T>) {
+        const buffer = await this.readExactly(4);
+        switch (getUint32LittleEndian(buffer, 0)) {
+            case ResponseId.Fail:
+                await FailResponse.deserialize(this.#readable);
+                unreachable();
+            case id:
+                return await type.deserialize(this.#readable);
+            default:
+                // non-recoverable
+                throw new Error(
+                    `Expected '${id}', but got '${decodeUtf8(buffer)}'`,
+                );
+        }
+    }
+
+    async *readResponses<T>(
+        expectedId: number,
+        type: StructDeserializer<T>,
+    ): AsyncGenerator<T, void, void> {
+        await this.flush();
+
+        while (true) {
+            const buffer = await this.#readable.readExactly(4);
+            const actualId = getUint32LittleEndian(buffer, 0);
+            switch (actualId) {
+                case ResponseId.Fail:
+                    await FailResponse.deserialize(this.#readable);
+                    unreachable();
+                case ResponseId.Done:
+                    // `DONE` responses' size are always same as the request's normal response.
+                    //
+                    // For example, `DONE` responses for `LIST` requests are 16 bytes (same as `DENT` responses),
+                    // but `DONE` responses for `STAT` requests are 12 bytes (same as `STAT` responses).
+                    await this.#readable.readExactly(type.size);
+                    return;
+                case expectedId:
+                    yield await type.deserialize(this.#readable);
+                    break;
+                default:
+                    // non-recoverable
+                    throw new Error(
+                        `Expected ${i32ToHex(expectedId)} or ${i32ToHex(ResponseId.Done)}, but got ${i32ToHex(actualId)}`,
+                    );
+            }
+        }
+    }
+
+    async close() {
+        this.clearIdleTimer();
+        await tryCancel(this.#readable);
+        await this.#socket.close();
+    }
+}

package/src/{commands → service}/tcpip.ts

@@ -1,4 +1,4 @@
-import { AdbServiceBase } from "./base.js";
+import type { Adb } from "../adb.js";
 
 /**
  * ADB daemon checks for the following properties in the order of
@@ -27,13 +27,19 @@ function parsePort(value: string): number | undefined {
     return Number.parseInt(value, 10);
 }
 
-export class AdbTcpIpService extends AdbServiceBase {
+export class AdbTcpIpService {
+    readonly #adb: Adb;
+
+    constructor(adb: Adb) {
+        this.#adb = adb;
+    }
+
     async getListenAddresses(): Promise<AdbTcpIpListenAddresses> {
-        const serviceListenAddresses = await this.adb.getProp(
+        const serviceListenAddresses = await this.#adb.getProp(
             "service.adb.listen_addrs",
         );
-        const servicePort = await this.adb.getProp("service.adb.tcp.port");
-        const persistPort = await this.adb.getProp("persist.adb.tcp.port");
+        const servicePort = await this.#adb.getProp("service.adb.tcp.port");
+        const persistPort = await this.#adb.getProp("persist.adb.tcp.port");
 
         return {
             serviceListenAddresses:
@@ -50,7 +56,7 @@ export class AdbTcpIpService extends AdbServiceBase {
             throw new TypeError(`Invalid port ${port}`);
         }
 
-        const output = await this.adb.createSocketAndWait(`tcpip:${port}`);
+        const output = await this.#adb.createSocketAndWait(`tcpip:${port}`);
         if (output !== `restarting in TCP mode port: ${port}\n`) {
             throw new Error(output);
         }
@@ -58,7 +64,7 @@ export class AdbTcpIpService extends AdbServiceBase {
     }
 
     async disable(): Promise<string> {
-        const output = await this.adb.createSocketAndWait("usb:");
+        const output = await this.#adb.createSocketAndWait("usb:");
         if (output !== "restarting in USB mode\n") {
             throw new Error(output);
         }

package/src/utils/array-buffer.ts

@@ -3,7 +3,6 @@ export function toLocalUint8Array(value: Uint8Array): Uint8Array<ArrayBuffer> {
         return value as Uint8Array<ArrayBuffer>;
     }
 
-    const copy = new Uint8Array(value.length);
-    copy.set(value);
-    return copy;
+    // This invokes the `constructor(Iterable<number>)` overload and copies the data
+    return new Uint8Array(value);
 }

package/src/utils/base64.ts

@@ -293,7 +293,20 @@ function encodeBackward(
     }
 }
 
+function getCharIndex(input: string, offset: number) {
+    const charCode = input.charCodeAt(offset);
+    const index = charToIndex[charCode];
+    if (index === undefined) {
+        throw new Error("Invalid Base64 character: " + input[offset]);
+    }
+    return index;
+}
+
 export function decodeBase64(input: string): Uint8Array<ArrayBuffer> {
+    if (input.length % 4 !== 0) {
+        throw new Error("Invalid Base64 length: " + input.length);
+    }
+
     let padding: number;
     if (input[input.length - 2] === "=") {
         padding = 2;
@@ -307,17 +320,18 @@ export function decodeBase64(input: string): Uint8Array<ArrayBuffer> {
     let sIndex = 0;
     let dIndex = 0;
 
-    while (sIndex < input.length - (padding !== 0 ? 4 : 0)) {
-        const a = charToIndex[input.charCodeAt(sIndex)]!;
+    const loopEnd = input.length - (padding !== 0 ? 4 : 0);
+    while (sIndex < loopEnd) {
+        const a = getCharIndex(input, sIndex);
         sIndex += 1;
 
-        const b = charToIndex[input.charCodeAt(sIndex)]!;
+        const b = getCharIndex(input, sIndex);
         sIndex += 1;
 
-        const c = charToIndex[input.charCodeAt(sIndex)]!;
+        const c = getCharIndex(input, sIndex);
         sIndex += 1;
 
-        const d = charToIndex[input.charCodeAt(sIndex)]!;
+        const d = getCharIndex(input, sIndex);
         sIndex += 1;
 
         result[dIndex] = (a << 2) | ((b & 0b11_0000) >> 4);
@@ -331,23 +345,23 @@ export function decodeBase64(input: string): Uint8Array<ArrayBuffer> {
     }
 
     if (padding === 1) {
-        const a = charToIndex[input.charCodeAt(sIndex)]!;
+        const a = getCharIndex(input, sIndex);
         sIndex += 1;
 
-        const b = charToIndex[input.charCodeAt(sIndex)]!;
+        const b = getCharIndex(input, sIndex);
         sIndex += 1;
 
-        const c = charToIndex[input.charCodeAt(sIndex)]!;
+        const c = getCharIndex(input, sIndex);
 
         result[dIndex] = (a << 2) | ((b & 0b11_0000) >> 4);
         dIndex += 1;
 
         result[dIndex] = ((b & 0b1111) << 4) | ((c & 0b11_1100) >> 2);
     } else if (padding === 2) {
-        const a = charToIndex[input.charCodeAt(sIndex)]!;
+        const a = getCharIndex(input, sIndex);
         sIndex += 1;
 
-        const b = charToIndex[input.charCodeAt(sIndex)]!;
+        const b = getCharIndex(input, sIndex);
 
         result[dIndex] = (a << 2) | ((b & 0b11_0000) >> 4);
     }

package/src/utils/index.ts

@@ -3,6 +3,7 @@ export * from "./array-buffer.js";
 export * from "./auto-reset-event.js";
 export * from "./base64.js";
 export * from "./hex.js";
+export * from "./md5.js";
 export * from "./no-op.js";
 export * from "./ref.js";
 export * from "./sequence-equal.js";

package/src/utils/md5.ts

@@ -0,0 +1,185 @@
+import {
+    getUint32LittleEndian,
+    setUint32LittleEndian,
+    setUint64LittleEndian,
+} from "@yume-chan/no-data-view";
+
+// Taken from https://github.com/digitalbazaar/forge/blob/e3c68e9695607702587583cda291d74e5369f21c/tests/unit/md5.js#L103
+// LICENSE: https://github.com/digitalbazaar/forge/blob/2c37d0bd2864199409edbb520f674d1c93652b23/LICENSE
+
+// g values
+// prettier-ignore
+const gs = [
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12,
+    5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2,
+    0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9];
+
+// rounds table
+// prettier-ignore
+const rs = [
+    7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,
+    5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20,
+    4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23,
+    6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21];
+
+const k = /* @__PURE__ */ (() => {
+    const k = new Uint32Array(64);
+    for (let i = 0; i < 64; i += 1) {
+        // get the result of abs(sin(i + 1)) as a 32-bit integer
+        k[i] = Math.floor(Math.abs(Math.sin(i + 1)) * 0x100000000);
+    }
+    return k;
+})();
+
+export class Md5 {
+    #state = new Uint32Array([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476]);
+    #length = 0n;
+
+    #buffer = new Uint8Array(64);
+    #bufferLength = 0;
+
+    #w = new Uint32Array(16);
+
+    update(input: Uint8Array) {
+        this.#length += BigInt(input.length);
+
+        let offset = 0;
+
+        if (this.#bufferLength) {
+            const remaining = 64 - this.#bufferLength;
+            this.#buffer.set(input.subarray(0, remaining), this.#bufferLength);
+
+            if (input.length < remaining) {
+                this.#bufferLength += input.length;
+                return this;
+            }
+
+            this.#update(this.#buffer);
+            this.#bufferLength = 0;
+            offset = remaining;
+        }
+
+        const end = input.length - 64;
+        for (; offset <= end; offset += 64) {
+            this.#update(input, offset);
+        }
+
+        if (offset < input.length) {
+            this.#buffer.set(input.subarray(offset));
+            this.#bufferLength = input.length - offset;
+        }
+
+        return this;
+    }
+
+    #update(input: Uint8Array, offset = 0) {
+        let a = this.#state[0]!;
+        let b = this.#state[1]!;
+        let c = this.#state[2]!;
+        let d = this.#state[3]!;
+
+        let t: number;
+        let f: number;
+        let r: number;
+        let i = 0;
+
+        // round 1
+        for (; i < 16; i += 1) {
+            this.#w[i] = getUint32LittleEndian(input, offset + i * 4);
+            f = d ^ (b & (c ^ d));
+            t = a + f + k[i]! + this.#w[i]!;
+            r = rs[i]!;
+            a = d;
+            d = c;
+            c = b;
+            b += (t << r) | (t >>> (32 - r));
+        }
+
+        // round 2
+        for (; i < 32; i += 1) {
+            f = c ^ (d & (b ^ c));
+            t = a + f + k[i]! + this.#w[gs[i]!]!;
+            r = rs[i]!;
+            a = d;
+            d = c;
+            c = b;
+            b += (t << r) | (t >>> (32 - r));
+        }
+
+        // round 3
+        for (; i < 48; i += 1) {
+            f = b ^ c ^ d;
+            t = a + f + k[i]! + this.#w[gs[i]!]!;
+            r = rs[i]!;
+            a = d;
+            d = c;
+            c = b;
+            b += (t << r) | (t >>> (32 - r));
+        }
+
+        // round 4
+        for (; i < 64; i += 1) {
+            f = c ^ (b | ~d);
+            t = a + f + k[i]! + this.#w[gs[i]!]!;
+            r = rs[i]!;
+            a = d;
+            d = c;
+            c = b;
+            b += (t << r) | (t >>> (32 - r));
+        }
+
+        this.#state[0]! += a;
+        this.#state[1]! += b;
+        this.#state[2]! += c;
+        this.#state[3]! += d;
+    }
+
+    digest() {
+        this.#buffer[this.#bufferLength] = 0x80;
+        this.#buffer.subarray(this.#bufferLength + 1).fill(0);
+
+        if (64 - this.#bufferLength < 8) {
+            this.#update(this.#buffer);
+
+            this.#buffer.fill(0);
+            this.#bufferLength = 0;
+        }
+
+        setUint64LittleEndian(
+            this.#buffer,
+            this.#buffer.length - 8,
+            this.#length << 3n,
+        );
+        this.#update(this.#buffer);
+
+        const result = new Uint8Array(16);
+        setUint32LittleEndian(result, 0, this.#state[0]!);
+        setUint32LittleEndian(result, 4, this.#state[1]!);
+        setUint32LittleEndian(result, 8, this.#state[2]!);
+        setUint32LittleEndian(result, 12, this.#state[3]!);
+        return result;
+    }
+
+    reset() {
+        this.#state[0] = 0x67452301;
+        this.#state[1] = 0xefcdab89;
+        this.#state[2] = 0x98badcfe;
+        this.#state[3] = 0x10325476;
+        this.#bufferLength = 0;
+        this.#length = 0n;
+        return this;
+    }
+}
+
+let instance: Md5 | undefined;
+
+export function md5Digest(input: Uint8Array) {
+    if (!instance) {
+        instance = new Md5();
+    }
+
+    const result = instance.update(input).digest();
+    instance.reset();
+    return result;
+}