werift 0.20.0 → 0.20.1

package/lib/ice/src/turn/protocol.d.ts

@@ -1,26 +1,27 @@
-import PCancelable from "p-cancelable";
-import Event from "rx.mini";
+import { Event } from "../imports/common";
 import type { InterfaceAddresses } from "../../../common/src/network";
 import type { Candidate } from "../candidate";
-import { type Future } from "../helper";
 import type { Connection } from "../ice";
 import { Message } from "../stun/message";
 import { Transaction } from "../stun/transaction";
 import { type Transport } from "../transport";
 import type { Address, Protocol } from "../types/model";
-declare class TurnTransport implements Protocol {
-    turn: TurnClient;
-    readonly type = "turn";
+export declare class StunOverTurnProtocol implements Protocol {
+    turn: TurnProtocol;
+    private ice;
+    static type: string;
+    readonly type: string;
     localCandidate: Candidate;
-    receiver?: Connection;
-    constructor(turn: TurnClient);
-    private datagramReceived;
+    private disposer;
+    constructor(turn: TurnProtocol, ice: Connection);
+    private handleStunMessage;
     request(request: Message, addr: Address, integrityKey?: Buffer): Promise<[Message, readonly [string, number]]>;
     connectionMade(): Promise<void>;
     sendData(data: Buffer, addr: Address): Promise<void>;
     sendStun(message: Message, addr: Address): Promise<void>;
+    close(): Promise<void>;
 }
-declare class TurnClient implements Protocol {
+export declare class TurnProtocol implements Protocol {
     server: Address;
     username: string;
     password: string;
@@ -30,33 +31,29 @@ declare class TurnClient implements Protocol {
         /**sec */
         channelRefreshTime?: number;
     };
-    type: string;
+    static type: string;
+    readonly type: string;
     readonly onData: Event<[Buffer, readonly [string, number]]>;
-    transactions: {
-        [hexId: string]: Transaction;
-    };
     integrityKey?: Buffer;
     nonce?: Buffer;
     realm?: string;
     relayedAddress: Address;
     mappedAddress: Address;
-    refreshHandle?: Future;
-    channelNumber: number;
-    channelByAddr: {
-        [addr: string]: {
-            number: number;
-            address: Address;
-        };
-    };
-    addrByChannel: {
-        [channel: number]: Address;
-    };
     localCandidate: Candidate;
+    transactions: {
+        [hexId: string]: Transaction;
+    };
+    private refreshHandle?;
+    private channelNumber;
+    private channelByAddr;
+    private addrByChannel;
     /**sec */
-    channelRefreshTime: number;
-    onDatagramReceived: (data: Buffer, addr: Address) => void;
+    private channelRefreshTime;
     private channelBinding?;
-    channelRefreshAt: number;
+    private channelRefreshAt;
+    private tcpBuffer;
+    private permissionByAddr;
+    private creatingPermission;
     constructor(server: Address, username: string, password: string, lifetime: number, transport: Transport, options?: {
         /**sec */
         channelRefreshTime?: number;
@@ -64,26 +61,45 @@ declare class TurnClient implements Protocol {
     connectionMade(): Promise<void>;
     private handleChannelData;
     private handleSTUNMessage;
-    private datagramReceived;
-    connect(): Promise<void>;
-    createPermission(peerAddress: Address): Promise<Message>;
-    refresh: (exp: number) => PCancelable<unknown>;
+    private dataReceived;
+    private send;
+    private createPermission;
+    private refresh;
     request(request: Message, addr: Address): Promise<[Message, Address]>;
     requestWithRetry(request: Message, addr: Address): Promise<[Message, Address]>;
     sendData(data: Buffer, addr: Address): Promise<void>;
+    getPermission(addr: Address): Promise<void>;
     getChannel(addr: Address): Promise<{
         number: number;
         address: Address;
     }>;
     private channelBind;
     sendStun(message: Message, addr: Address): Promise<void>;
+    close(): Promise<void>;
+}
+export interface TurnClientConfig {
+    address: Address;
+    username: string;
+    password: string;
 }
-export declare function createTurnEndpoint(serverAddr: Address, username: string, password: string, { lifetime, portRange, interfaceAddresses, }: {
+export interface TurnClientOptions {
+    lifetime?: number;
+    ssl?: boolean;
+    transport?: "udp" | "tcp";
+    portRange?: [number, number];
+    interfaceAddresses?: InterfaceAddresses;
+}
+export declare function createTurnClient({ address, username, password }: TurnClientConfig, { lifetime, portRange, interfaceAddresses, transport: transportType, }?: TurnClientOptions): Promise<TurnProtocol>;
+export declare function createStunOverTurnClient({ address, username, password, ice, }: {
+    address: Address;
+    username: string;
+    password: string;
+    ice: Connection;
+}, { lifetime, portRange, interfaceAddresses, transport: transportType, }?: {
     lifetime?: number;
     ssl?: boolean;
-    transport?: "udp";
+    transport?: "udp" | "tcp";
     portRange?: [number, number];
     interfaceAddresses?: InterfaceAddresses;
-}): Promise<TurnTransport>;
+}): Promise<StunOverTurnProtocol>;
 export declare function makeIntegrityKey(username: string, realm: string, password: string): Buffer;
-export {};

package/lib/ice/src/turn/protocol.js

@@ -3,14 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTurnEndpoint = createTurnEndpoint;
+exports.TurnProtocol = exports.StunOverTurnProtocol = void 0;
+exports.createTurnClient = createTurnClient;
+exports.createStunOverTurnClient = createStunOverTurnClient;
 exports.makeIntegrityKey = makeIntegrityKey;
 const crypto_1 = require("crypto");
 const jspack_1 = require("@shinyoshiaki/jspack");
 const debug_1 = __importDefault(require("debug"));
 const p_cancelable_1 = __importDefault(require("p-cancelable"));
-const rx_mini_1 = __importDefault(require("rx.mini"));
 const promises_1 = require("timers/promises");
+const common_1 = require("../imports/common");
 const src_1 = require("../../../common/src");
 const exceptions_1 = require("../exceptions");
 const helper_1 = require("../helper");
@@ -21,21 +23,26 @@ const transport_1 = require("../transport");
 const log = (0, debug_1.default)("werift-ice:packages/ice/src/turn/protocol.ts");
 const DEFAULT_CHANNEL_REFRESH_TIME = 500;
 const DEFAULT_ALLOCATION_LIFETIME = 600;
-const TCP_TRANSPORT = 0x06000000;
 const UDP_TRANSPORT = 0x11000000;
-class TurnTransport {
-    constructor(turn) {
+class StunOverTurnProtocol {
+    constructor(turn, ice) {
         Object.defineProperty(this, "turn", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: turn
         });
+        Object.defineProperty(this, "ice", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ice
+        });
         Object.defineProperty(this, "type", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "turn"
+            value: StunOverTurnProtocol.type
         });
         Object.defineProperty(this, "localCandidate", {
             enumerable: true,
@@ -43,13 +50,13 @@ class TurnTransport {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "receiver", {
+        Object.defineProperty(this, "disposer", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: new common_1.EventDisposer()
         });
-        Object.defineProperty(this, "datagramReceived", {
+        Object.defineProperty(this, "handleStunMessage", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -57,17 +64,18 @@ class TurnTransport {
                 try {
                     const message = (0, message_1.parseMessage)(data);
                     if (!message) {
-                        this.receiver?.dataReceived(data, this.localCandidate.component);
+                        this.ice.dataReceived(data, this.localCandidate.component);
                         return;
                     }
-                    if ((message?.messageClass === const_1.classes.RESPONSE ||
-                        message?.messageClass === const_1.classes.ERROR) &&
-                        this.turn.transactions[message.transactionIdHex]) {
+                    if (message.messageClass === const_1.classes.RESPONSE ||
+                        message.messageClass === const_1.classes.ERROR) {
                         const transaction = this.turn.transactions[message.transactionIdHex];
-                        transaction.responseReceived(message, addr);
+                        if (transaction) {
+                            transaction.responseReceived(message, addr);
+                        }
                     }
-                    else if (message?.messageClass === const_1.classes.REQUEST) {
-                        this.receiver?.requestReceived(message, addr, this, data);
+                    else if (message.messageClass === const_1.classes.REQUEST) {
+                        this.ice.requestReceived(message, addr, this, data);
                     }
                 }
                 catch (error) {
@@ -75,11 +83,16 @@ class TurnTransport {
                 }
             }
         });
-        turn.onDatagramReceived = this.datagramReceived;
+        turn.onData
+            .subscribe((data, addr) => {
+            this.handleStunMessage(data, addr);
+        })
+            .disposer(this.disposer);
     }
     async request(request, addr, integrityKey) {
-        if (this.turn.transactions[request.transactionIdHex])
+        if (this.turn.transactions[request.transactionIdHex]) {
             throw new Error("exist");
+        }
         if (integrityKey) {
             request.addMessageIntegrity(integrityKey);
             request.addFingerprint();
@@ -103,8 +116,19 @@ class TurnTransport {
     async sendStun(message, addr) {
         await this.turn.sendData(message.bytes, addr);
     }
+    async close() {
+        this.disposer.dispose();
+        return this.turn.close();
+    }
 }
-class TurnClient {
+exports.StunOverTurnProtocol = StunOverTurnProtocol;
+Object.defineProperty(StunOverTurnProtocol, "type", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: "turn"
+});
+class TurnProtocol {
     constructor(server, username, password, lifetime, transport, options = {}) {
         Object.defineProperty(this, "server", {
             enumerable: true,
@@ -146,19 +170,13 @@ class TurnClient {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "inner_turn"
+            value: TurnProtocol.type
         });
         Object.defineProperty(this, "onData", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new rx_mini_1.default()
-        });
-        Object.defineProperty(this, "transactions", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
+            value: new common_1.Event()
         });
         Object.defineProperty(this, "integrityKey", {
             enumerable: true,
@@ -190,6 +208,18 @@ class TurnClient {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "localCandidate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "transactions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
         Object.defineProperty(this, "refreshHandle", {
             enumerable: true,
             configurable: true,
@@ -214,36 +244,42 @@ class TurnClient {
             writable: true,
             value: {}
         });
-        Object.defineProperty(this, "localCandidate", {
+        /**sec */
+        Object.defineProperty(this, "channelRefreshTime", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        /**sec */
-        Object.defineProperty(this, "channelRefreshTime", {
+        Object.defineProperty(this, "channelBinding", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "onDatagramReceived", {
+        Object.defineProperty(this, "channelRefreshAt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "tcpBuffer", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: () => { }
+            value: Buffer.alloc(0)
         });
-        Object.defineProperty(this, "channelBinding", {
+        Object.defineProperty(this, "permissionByAddr", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: {}
         });
-        Object.defineProperty(this, "channelRefreshAt", {
+        Object.defineProperty(this, "creatingPermission", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 0
+            value: Promise.resolve()
         });
         Object.defineProperty(this, "refresh", {
             enumerable: true,
@@ -278,23 +314,36 @@ class TurnClient {
     }
     async connectionMade() {
         this.transport.onData = (data, addr) => {
-            this.datagramReceived(data, addr);
+            this.dataReceived(data, addr);
         };
+        const request = new message_1.Message(const_1.methods.ALLOCATE, const_1.classes.REQUEST);
+        request
+            .setAttribute("LIFETIME", this.lifetime)
+            .setAttribute("REQUESTED-TRANSPORT", UDP_TRANSPORT);
+        const [response] = await this.requestWithRetry(request, this.server).catch((e) => {
+            log("connect error", e);
+            throw e;
+        });
+        this.relayedAddress = response.getAttributeValue("XOR-RELAYED-ADDRESS");
+        this.mappedAddress = response.getAttributeValue("XOR-MAPPED-ADDRESS");
+        const exp = response.getAttributeValue("LIFETIME");
+        log("connect", this.relayedAddress, this.mappedAddress, { exp });
+        this.refreshHandle = (0, helper_1.future)(this.refresh(exp));
     }
     handleChannelData(data) {
         const [channel, length] = jspack_1.jspack.Unpack("!HH", data.slice(0, 4));
         const addr = this.addrByChannel[channel];
         if (addr) {
             const payload = data.subarray(4, 4 + length);
-            this.onDatagramReceived(payload, addr);
             this.onData.execute(payload, addr);
         }
     }
     handleSTUNMessage(data, addr) {
         try {
             const message = (0, message_1.parseMessage)(data);
-            if (!message)
+            if (!message) {
                 throw new Error("not stun message");
+            }
             if (message.messageClass === const_1.classes.RESPONSE ||
                 message.messageClass === const_1.classes.ERROR) {
                 const transaction = this.transactions[message.transactionIdHex];
@@ -303,11 +352,10 @@ class TurnClient {
                 }
             }
             else if (message.messageClass === const_1.classes.REQUEST) {
-                this.onDatagramReceived(data, addr);
+                this.onData.execute(data, addr);
             }
             if (message.getAttributeValue("DATA")) {
                 const buf = message.getAttributeValue("DATA");
-                this.onDatagramReceived(buf, addr);
                 this.onData.execute(buf, addr);
             }
         }
@@ -315,28 +363,42 @@ class TurnClient {
             log("parse error", data.toString());
         }
     }
-    datagramReceived(data, addr) {
-        if (data.length >= 4 && isChannelData(data)) {
-            this.handleChannelData(data);
+    dataReceived(data, addr) {
+        const datagramReceived = (data, addr) => {
+            if (data.length >= 4 && isChannelData(data)) {
+                this.handleChannelData(data);
+            }
+            else {
+                this.handleSTUNMessage(data, addr);
+            }
+        };
+        if (this.transport.type === "tcp") {
+            this.tcpBuffer = Buffer.concat([this.tcpBuffer, data]);
+            while (this.tcpBuffer.length >= 4) {
+                let [, length] = (0, src_1.bufferReader)(this.tcpBuffer.subarray(0, 4), [2, 2]);
+                length += (0, message_1.paddingLength)(length);
+                const fullLength = isChannelData(this.tcpBuffer)
+                    ? 4 + length
+                    : 20 + length;
+                if (this.tcpBuffer.length < fullLength) {
+                    break;
+                }
+                datagramReceived(this.tcpBuffer.subarray(0, fullLength), addr);
+                this.tcpBuffer = this.tcpBuffer.subarray(fullLength);
+            }
         }
         else {
-            this.handleSTUNMessage(data, addr);
+            datagramReceived(data, addr);
         }
     }
-    async connect() {
-        const request = new message_1.Message(const_1.methods.ALLOCATE, const_1.classes.REQUEST);
-        request
-            .setAttribute("LIFETIME", this.lifetime)
-            .setAttribute("REQUESTED-TRANSPORT", UDP_TRANSPORT);
-        const [response] = await this.requestWithRetry(request, this.server).catch((e) => {
-            log("connect error", e);
-            throw e;
-        });
-        this.relayedAddress = response.getAttributeValue("XOR-RELAYED-ADDRESS");
-        this.mappedAddress = response.getAttributeValue("XOR-MAPPED-ADDRESS");
-        const exp = response.getAttributeValue("LIFETIME");
-        log("connect", this.relayedAddress, this.mappedAddress, { exp });
-        this.refreshHandle = (0, helper_1.future)(this.refresh(exp));
+    async send(data, addr) {
+        if (this.transport.type === "tcp") {
+            const padding = (0, message_1.paddingLength)(data.length);
+            await this.transport.send(padding > 0 ? Buffer.concat([data, Buffer.alloc(padding)]) : data, addr);
+        }
+        else {
+            await this.transport.send(data, addr);
+        }
     }
     async createPermission(peerAddress) {
         const request = new message_1.Message(const_1.methods.CREATE_PERMISSION, const_1.classes.REQUEST);
@@ -345,11 +407,10 @@ class TurnClient {
             .setAttribute("USERNAME", this.username)
             .setAttribute("REALM", this.realm)
             .setAttribute("NONCE", this.nonce);
-        const [response] = await this.request(request, this.server).catch((e) => {
+        await this.request(request, this.server).catch((e) => {
             request;
             throw e;
         });
-        return response;
     }
     async request(request, addr) {
         if (this.transactions[request.transactionIdHex]) {
@@ -408,21 +469,43 @@ class TurnClient {
         return [message, address];
     }
     async sendData(data, addr) {
-        const channel = await this.getChannel(addr);
+        const channel = await this.getChannel(addr).catch((e) => {
+            return new Error("channelBind error");
+        });
+        if (channel instanceof Error) {
+            await this.getPermission(addr);
+            const indicate = new message_1.Message(const_1.methods.SEND, const_1.classes.INDICATION)
+                .setAttribute("DATA", data)
+                .setAttribute("XOR-PEER-ADDRESS", addr);
+            await this.sendStun(indicate, this.server);
+            return;
+        }
         const header = jspack_1.jspack.Pack("!HH", [channel.number, data.length]);
-        this.transport.send(Buffer.concat([Buffer.from(header), data]), this.server);
+        await this.send(Buffer.concat([Buffer.from(header), data]), this.server);
+    }
+    async getPermission(addr) {
+        await this.creatingPermission;
+        const permitted = this.permissionByAddr[addr.join(":")];
+        if (!permitted) {
+            this.creatingPermission = this.createPermission(addr);
+            this.permissionByAddr[addr.join(":")] = true;
+            await this.creatingPermission.catch((e) => {
+                log("createPermission error", e);
+                throw e;
+            });
+        }
     }
     async getChannel(addr) {
         if (this.channelBinding) {
             await this.channelBinding;
         }
-        let channel = this.channelByAddr[addr.join("")];
+        let channel = this.channelByAddr[addr.join(":")];
         if (!channel) {
-            this.channelByAddr[addr.join("")] = {
+            this.channelByAddr[addr.join(":")] = {
                 number: this.channelNumber++,
                 address: addr,
             };
-            channel = this.channelByAddr[addr.join("")];
+            channel = this.channelByAddr[addr.join(":")];
             this.addrByChannel[channel.number] = addr;
             this.channelBinding = this.channelBind(channel.number, addr);
             await this.channelBinding.catch((e) => {
@@ -456,18 +539,42 @@ class TurnClient {
         }
     }
     async sendStun(message, addr) {
-        await this.transport.send(message.bytes, addr);
+        await this.send(message.bytes, addr);
     }
-}
-async function createTurnEndpoint(serverAddr, username, password, { lifetime, portRange, interfaceAddresses, }) {
-    if (lifetime == undefined) {
-        lifetime = DEFAULT_ALLOCATION_LIFETIME;
+    async close() {
+        this.refreshHandle?.cancel();
+        await this.transport.close();
     }
-    const transport = await transport_1.UdpTransport.init("udp4", portRange, interfaceAddresses);
-    const turnClient = new TurnClient(serverAddr, username, password, lifetime, transport);
-    await turnClient.connectionMade();
-    await turnClient.connect();
-    const turnTransport = new TurnTransport(turnClient);
+}
+exports.TurnProtocol = TurnProtocol;
+Object.defineProperty(TurnProtocol, "type", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: "turn"
+});
+async function createTurnClient({ address, username, password }, { lifetime, portRange, interfaceAddresses, transport: transportType, } = {}) {
+    lifetime ?? (lifetime = DEFAULT_ALLOCATION_LIFETIME);
+    transportType ?? (transportType = "udp");
+    const transport = transportType === "udp"
+        ? await transport_1.UdpTransport.init("udp4", portRange, interfaceAddresses)
+        : await transport_1.TcpTransport.init(address);
+    const turn = new TurnProtocol(address, username, password, lifetime, transport);
+    await turn.connectionMade();
+    return turn;
+}
+async function createStunOverTurnClient({ address, username, password, ice, }, { lifetime, portRange, interfaceAddresses, transport: transportType, } = {}) {
+    const turn = await createTurnClient({
+        address,
+        username,
+        password,
+    }, {
+        lifetime,
+        portRange,
+        interfaceAddresses,
+        transport: transportType,
+    });
+    const turnTransport = new StunOverTurnProtocol(turn, ice);
     return turnTransport;
 }
 function makeIntegrityKey(username, realm, password) {