@yume-chan/adb 0.0.18 → 0.0.20

package/src/{socket → daemon}/dispatcher.ts

@@ -1,22 +1,22 @@
 import { AsyncOperationManager, PromiseResolver } from "@yume-chan/async";
-import { type RemoveEventListener } from "@yume-chan/event";
+import type {
+    Consumable,
+    ReadableWritablePair,
+    WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
 import {
     AbortController,
+    ConsumableWritableStream,
     WritableStream,
-    type ReadableWritablePair,
-    type WritableStreamDefaultWriter,
 } from "@yume-chan/stream-extra";
-import { EMPTY_UINT8_ARRAY, type ValueOrPromise } from "@yume-chan/struct";
+import { EMPTY_UINT8_ARRAY } from "@yume-chan/struct";
 
-import {
-    AdbCommand,
-    calculateChecksum,
-    type AdbPacketData,
-    type AdbPacketInit,
-} from "../packet.js";
-import { decodeUtf8, encodeUtf8 } from "../utils/index.js";
+import type { AdbIncomingSocketHandler, AdbSocket, Closeable } from "../adb.js";
+import { decodeUtf8, encodeUtf8, unreachable } from "../utils/index.js";
 
-import { AdbSocketController, type AdbSocket } from "./socket.js";
+import type { AdbPacketData, AdbPacketInit } from "./packet.js";
+import { AdbCommand, calculateChecksum } from "./packet.js";
+import { AdbDaemonSocketController } from "./socket.js";
 
 export interface AdbPacketDispatcherOptions {
     calculateChecksum: boolean;
@@ -30,14 +30,6 @@ export interface AdbPacketDispatcherOptions {
     maxPayloadSize: number;
 }
 
-export type AdbIncomingSocketHandler = (
-    socket: AdbSocket
-) => ValueOrPromise<boolean>;
-
-export interface Closeable {
-    close(): ValueOrPromise<void>;
-}
-
 /**
  * The dispatcher is the "dumb" part of the connection handling logic.
  *
@@ -51,28 +43,30 @@ export interface Closeable {
 export class AdbPacketDispatcher implements Closeable {
     // ADB socket id starts from 1
     // (0 means open failed)
-    private readonly initializers = new AsyncOperationManager(1);
+    readonly #initializers = new AsyncOperationManager(1);
     /**
      * Socket local ID to the socket controller.
      */
-    private readonly sockets = new Map<number, AdbSocketController>();
+    readonly #sockets = new Map<number, AdbDaemonSocketController>();
 
-    private _writer!: WritableStreamDefaultWriter<AdbPacketInit>;
+    #writer: WritableStreamDefaultWriter<Consumable<AdbPacketInit>>;
 
     public readonly options: AdbPacketDispatcherOptions;
 
-    private _closed = false;
-    private _disconnected = new PromiseResolver<void>();
+    #closed = false;
+    #disconnected = new PromiseResolver<void>();
     public get disconnected() {
-        return this._disconnected.promise;
+        return this.#disconnected.promise;
     }
 
-    private _incomingSocketHandlers: Set<AdbIncomingSocketHandler> = new Set();
-
-    private _abortController = new AbortController();
+    #incomingSocketHandlers = new Map<string, AdbIncomingSocketHandler>();
+    #readAbortController = new AbortController();
 
     public constructor(
-        connection: ReadableWritablePair<AdbPacketData, AdbPacketInit>,
+        connection: ReadableWritablePair<
+            AdbPacketData,
+            Consumable<AdbPacketInit>
+        >,
         options: AdbPacketDispatcherOptions
     ) {
         this.options = options;
@@ -89,8 +83,8 @@ export class AdbPacketDispatcher implements Closeable {
                                 await this.handleClose(packet);
                                 break;
                             case AdbCommand.Write:
-                                if (this.sockets.has(packet.arg1)) {
-                                    await this.sockets
+                                if (this.#sockets.has(packet.arg1)) {
+                                    await this.#sockets
                                         .get(packet.arg1)!
                                         .enqueue(packet.payload);
                                     await this.sendPacket(
@@ -126,7 +120,7 @@ export class AdbPacketDispatcher implements Closeable {
                     // it's still possible to create another ADB connection.
                     // So don't close `readable` here.
                     preventCancel: true,
-                    signal: this._abortController.signal,
+                    signal: this.#readAbortController.signal,
                 }
             )
             .then(
@@ -134,23 +128,23 @@ export class AdbPacketDispatcher implements Closeable {
                     this.dispose();
                 },
                 (e) => {
-                    if (!this._closed) {
-                        this._disconnected.reject(e);
+                    if (!this.#closed) {
+                        this.#disconnected.reject(e);
                     }
                     this.dispose();
                 }
             );
 
-        this._writer = connection.writable.getWriter();
+        this.#writer = connection.writable.getWriter();
     }
 
     private handleOk(packet: AdbPacketData) {
-        if (this.initializers.resolve(packet.arg1, packet.arg0)) {
+        if (this.#initializers.resolve(packet.arg1, packet.arg0)) {
             // Device successfully created the socket
             return;
         }
 
-        const socket = this.sockets.get(packet.arg1);
+        const socket = this.#sockets.get(packet.arg1);
         if (socket) {
             // Device has received last `WRTE` to the socket
             socket.ack();
@@ -166,7 +160,7 @@ export class AdbPacketDispatcher implements Closeable {
         // If the socket is still pending
         if (
             packet.arg0 === 0 &&
-            this.initializers.reject(
+            this.#initializers.reject(
                 packet.arg1,
                 new Error("Socket open failed")
             )
@@ -187,7 +181,7 @@ export class AdbPacketDispatcher implements Closeable {
          */
 
         // Ignore `arg0` and search for the socket
-        const socket = this.sockets.get(packet.arg1);
+        const socket = this.#sockets.get(packet.arg1);
         if (socket) {
             // The device want to close the socket
             if (!socket.closed) {
@@ -198,7 +192,7 @@ export class AdbPacketDispatcher implements Closeable {
                 );
             }
             await socket.dispose();
-            this.sockets.delete(packet.arg1);
+            this.#sockets.delete(packet.arg1);
             return;
         }
 
@@ -207,141 +201,125 @@ export class AdbPacketDispatcher implements Closeable {
         // the device may also respond with two `CLSE` packets.
     }
 
-    /**
-     * Add a handler for incoming socket.
-     * @param handler A function to call with new incoming sockets. It must return `true` if it accepts the socket.
-     * @returns A function to remove the handler.
-     */
-    public onIncomingSocket(
+    public addReverseTunnel(
+        service: string,
         handler: AdbIncomingSocketHandler
-    ): RemoveEventListener {
-        this._incomingSocketHandlers.add(handler);
-        const remove = () => {
-            this._incomingSocketHandlers.delete(handler);
-        };
-        remove.dispose = remove;
-        return remove;
+    ) {
+        this.#incomingSocketHandlers.set(service, handler);
+    }
+
+    public removeReverseTunnel(address: string) {
+        this.#incomingSocketHandlers.delete(address);
+    }
+
+    public clearReverseTunnels() {
+        this.#incomingSocketHandlers.clear();
     }
 
     private async handleOpen(packet: AdbPacketData) {
         // `AsyncOperationManager` doesn't support skipping IDs
         // Use `add` + `resolve` to simulate this behavior
-        const [localId] = this.initializers.add<number>();
-        this.initializers.resolve(localId, undefined);
+        const [localId] = this.#initializers.add<number>();
+        this.#initializers.resolve(localId, undefined);
 
         const remoteId = packet.arg0;
-        const serviceString = decodeUtf8(packet.payload);
+        let service = decodeUtf8(packet.payload);
+        if (service.endsWith("\0")) {
+            service = service.substring(0, service.length - 1);
+        }
 
-        const controller = new AdbSocketController({
+        const handler = this.#incomingSocketHandlers.get(service);
+        if (!handler) {
+            await this.sendPacket(AdbCommand.Close, 0, remoteId);
+            return;
+        }
+
+        const controller = new AdbDaemonSocketController({
             dispatcher: this,
             localId,
             remoteId,
             localCreated: false,
-            serviceString,
+            service,
         });
 
-        for (const handler of this._incomingSocketHandlers) {
-            if (await handler(controller.socket)) {
-                this.sockets.set(localId, controller);
-                await this.sendPacket(AdbCommand.OK, localId, remoteId);
-                return;
-            }
+        try {
+            await handler(controller.socket);
+            this.#sockets.set(localId, controller);
+            await this.sendPacket(AdbCommand.OK, localId, remoteId);
+        } catch (e) {
+            await this.sendPacket(AdbCommand.Close, 0, remoteId);
         }
-
-        await this.sendPacket(AdbCommand.Close, 0, remoteId);
     }
 
-    public async createSocket(serviceString: string): Promise<AdbSocket> {
+    public async createSocket(service: string): Promise<AdbSocket> {
         if (this.options.appendNullToServiceString) {
-            serviceString += "\0";
+            service += "\0";
         }
 
-        const [localId, initializer] = this.initializers.add<number>();
-        await this.sendPacket(AdbCommand.Open, localId, 0, serviceString);
+        const [localId, initializer] = this.#initializers.add<number>();
+        await this.sendPacket(AdbCommand.Open, localId, 0, service);
 
         // Fulfilled by `handleOk`
         const remoteId = await initializer;
-        const controller = new AdbSocketController({
+        const controller = new AdbDaemonSocketController({
             dispatcher: this,
             localId,
             remoteId,
             localCreated: true,
-            serviceString,
+            service,
         });
-        this.sockets.set(localId, controller);
+        this.#sockets.set(localId, controller);
 
         return controller.socket;
     }
 
-    public sendPacket(packet: AdbPacketInit): Promise<void>;
-    public sendPacket(
+    public async sendPacket(
         command: AdbCommand,
         arg0: number,
         arg1: number,
-        payload?: string | Uint8Array
-    ): Promise<void>;
-    public async sendPacket(
-        packetOrCommand: AdbPacketInit | AdbCommand,
-        arg0?: number,
-        arg1?: number,
         payload: string | Uint8Array = EMPTY_UINT8_ARRAY
     ): Promise<void> {
-        let init: AdbPacketData;
-        if (arg0 === undefined) {
-            init = packetOrCommand as AdbPacketInit;
-        } else {
-            if (typeof payload === "string") {
-                payload = encodeUtf8(payload);
-            }
-
-            init = {
-                command: packetOrCommand as AdbCommand,
-                arg0: arg0,
-                arg1: arg1 as number,
-                payload,
-            };
+        if (typeof payload === "string") {
+            payload = encodeUtf8(payload);
         }
 
-        if (
-            init.payload &&
-            init.payload.byteLength > this.options.maxPayloadSize
-        ) {
+        if (payload.byteLength > this.options.maxPayloadSize) {
             throw new Error("payload too large");
         }
 
-        if (this.options.calculateChecksum) {
-            calculateChecksum(init);
-        } else {
-            (init as AdbPacketInit).checksum = 0;
-        }
-
-        await this._writer.ready;
-        await this._writer.write(init as AdbPacketInit);
+        await ConsumableWritableStream.write(this.#writer, {
+            command,
+            arg0,
+            arg1,
+            payload,
+            checksum: this.options.calculateChecksum
+                ? calculateChecksum(payload)
+                : 0,
+            magic: command ^ 0xffffffff,
+        });
     }
 
     public async close() {
         // Send `CLSE` packets for all sockets
         await Promise.all(
-            Array.from(this.sockets.values(), (socket) => socket.close())
+            Array.from(this.#sockets.values(), (socket) => socket.close())
         );
 
         // Stop receiving
         // It's possible that we haven't received all `CLSE` confirm packets,
         // but it doesn't matter, the next connection can cope with them.
-        this._closed = true;
-        this._abortController.abort();
-        this._writer.releaseLock();
+        this.#closed = true;
+        this.#readAbortController.abort();
+        this.#writer.releaseLock();
 
         // `pipe().then()` will call `dispose`
     }
 
     private dispose() {
-        for (const socket of this.sockets.values()) {
-            socket.dispose().catch((e) => {
-                void e;
-            });
+        for (const socket of this.#sockets.values()) {
+            socket.dispose().catch(unreachable);
         }
 
-        this._disconnected.resolve();
+        this.#disconnected.resolve();
     }
 }

package/src/daemon/index.ts

@@ -0,0 +1,7 @@
+export * from "./auth.js";
+export * from "./crypto.js";
+export * from "./device.js";
+export * from "./dispatcher.js";
+export * from "./packet.js";
+export * from "./socket.js";
+export * from "./transport.js";

package/src/daemon/packet.ts

@@ -0,0 +1,75 @@
+import { ConsumableTransformStream } from "@yume-chan/stream-extra";
+import Struct from "@yume-chan/struct";
+
+export enum AdbCommand {
+    Auth = 0x48545541, // 'AUTH'
+    Close = 0x45534c43, // 'CLSE'
+    Connect = 0x4e584e43, // 'CNXN'
+    OK = 0x59414b4f, // 'OKAY'
+    Open = 0x4e45504f, // 'OPEN'
+    Write = 0x45545257, // 'WRTE'
+}
+
+export const AdbPacketHeader = new Struct({ littleEndian: true })
+    .uint32("command")
+    .uint32("arg0")
+    .uint32("arg1")
+    .uint32("payloadLength")
+    .uint32("checksum")
+    .int32("magic");
+
+export type AdbPacketHeader = (typeof AdbPacketHeader)["TDeserializeResult"];
+
+type AdbPacketHeaderInit = (typeof AdbPacketHeader)["TInit"];
+
+export const AdbPacket = new Struct({ littleEndian: true })
+    .concat(AdbPacketHeader)
+    .uint8Array("payload", { lengthField: "payloadLength" });
+
+export type AdbPacket = (typeof AdbPacket)["TDeserializeResult"];
+
+/**
+ * `AdbPacketData` contains all the useful fields of `AdbPacket`.
+ *
+ * `AdvDaemonConnection#connect` will return a `ReadableStream<AdbPacketData>`,
+ * allow each connection to encode `AdbPacket` in different methods.
+ *
+ * `AdbDaemonConnection#connect` will return a `WritableStream<AdbPacketInit>`,
+ * however, `AdbDaemonTransport` will transform `AdbPacketData` to `AdbPacketInit` for you,
+ * so `AdbSocket#writable#write` only needs `AdbPacketData`.
+ */
+export type AdbPacketData = Omit<
+    (typeof AdbPacket)["TInit"],
+    "checksum" | "magic"
+>;
+
+export type AdbPacketInit = (typeof AdbPacket)["TInit"];
+
+export function calculateChecksum(payload: Uint8Array): number {
+    return payload.reduce((result, item) => result + item, 0);
+}
+
+export class AdbPacketSerializeStream extends ConsumableTransformStream<
+    AdbPacketInit,
+    Uint8Array
+> {
+    public constructor() {
+        const headerBuffer = new Uint8Array(AdbPacketHeader.size);
+        super({
+            transform: async (chunk, controller) => {
+                const init = chunk as AdbPacketInit & AdbPacketHeaderInit;
+                init.payloadLength = init.payload.byteLength;
+
+                AdbPacketHeader.serialize(init, headerBuffer);
+                await controller.enqueue(headerBuffer);
+
+                if (init.payload.byteLength) {
+                    // USB protocol preserves packet boundaries,
+                    // so we must write payload separately as native ADB does,
+                    // otherwise the read operation on device will fail.
+                    await controller.enqueue(init.payload);
+                }
+            },
+        });
+    }
+}