@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/lib/ice/turn/protocol.js

@@ -0,0 +1,630 @@
+import { isIP } from 'node:net';
+import { setTimeout } from 'node:timers/promises';
+import { makeTurnIntegrityKey } from '../../turn/turn/auth.js';
+import { TransactionFailed } from '../exceptions.js';
+import { cancelable, randomTransactionId } from '../helper.js';
+import { Event, EventDisposer, TcpTransport, TlsTransport, UdpTransport, debug, int } from '../imports/common.js';
+import { classes, methods } from '../stun/const.js';
+import { Message, parseMessage } from '../stun/message.js';
+import { Transaction, addressEquals, buildTransactionOptions, isChallenge, resolveRequestAddress } from '../stun/transaction.js';
+import { decodeChannelData, encodeChannelData, isChannelData, padTurnFrame, splitTurnTcpFrames } from './frame.js';
+const log = debug('webrtc/ice/turn/protocol');
+const DEFAULT_CHANNEL_REFRESH_TIME = 500;
+/**How long closing waits for the server to delete the allocation (ms) */
+const DELETE_TIMEOUT = 1000;
+const DEFAULT_ALLOCATION_LIFETIME = 600;
+const UDP_TRANSPORT = 0x11000000;
+function isStreamTransport(transport) {
+    return transport.type === 'tcp' || transport.type === 'tls';
+}
+/** Permission is peer-IP scoped (RFC 8656). */
+function permissionKey(addr) {
+    return addr[0];
+}
+/** ChannelBind is peer transport-address scoped (IP + port). */
+function channelKey(addr) {
+    return JSON.stringify(addr);
+}
+export class StunOverTurnProtocol {
+    static { this.type = 'turn'; }
+    constructor(turn) {
+        this.turn = turn;
+        this.type = StunOverTurnProtocol.type;
+        this.disposer = new EventDisposer();
+        this.onRequestReceived = new Event();
+        this.onDataReceived = new Event();
+        this.handleStunMessage = (data, addr) => {
+            try {
+                const message = parseMessage(data);
+                if (!message) {
+                    this.onDataReceived.execute(data);
+                    return;
+                }
+                if (message.messageClass === classes.RESPONSE ||
+                    message.messageClass === classes.ERROR) {
+                    const transaction = this.turn.transactions[message.transactionIdHex];
+                    if (transaction) {
+                        const verified = transaction.integrityKey
+                            ? parseMessage(data, transaction.integrityKey)
+                            : message;
+                        if (!verified) {
+                            log('STUN over TURN response failed MESSAGE-INTEGRITY check');
+                            return;
+                        }
+                        transaction.responseReceived(verified, addr);
+                    }
+                }
+                else if (message.messageClass === classes.REQUEST) {
+                    this.onRequestReceived.execute(message, addr, data);
+                }
+            }
+            catch (error) {
+                log('datagramReceived error', error);
+            }
+        };
+        turn.onData
+            .subscribe((data, addr) => {
+            this.handleStunMessage(data, addr);
+        })
+            .disposer(this.disposer);
+    }
+    async request(request, addr, integrityKey, retransmissionsOrOptions, onRequestSent) {
+        if (this.turn.transactions[request.transactionIdHex]) {
+            throw new Error('exist');
+        }
+        if (integrityKey) {
+            request.addMessageIntegrity(integrityKey);
+            request.addFingerprint();
+        }
+        // Peer-facing STUN over TURN must honor retransmissions/responseTimeout
+        // (consent uses retransmissions: 0). Do not confuse with TURN server
+        // allocation/refresh policy on TurnProtocol.
+        // Peer addresses are already IPs from candidates; resolve for safety.
+        const resolvedAddr = await resolveRequestAddress(addr);
+        const options = buildTransactionOptions(integrityKey, retransmissionsOrOptions, onRequestSent);
+        const transaction = new Transaction(request, resolvedAddr, this, options);
+        this.turn.transactions[request.transactionIdHex] = transaction;
+        try {
+            return await transaction.run();
+        }
+        finally {
+            delete this.turn.transactions[request.transactionIdHex];
+        }
+    }
+    async connectionMade() { }
+    async sendData(data, addr) {
+        await this.turn.sendData(data, addr);
+    }
+    async sendStun(message, addr) {
+        await this.turn.sendData(message.bytes, addr);
+    }
+    async close() {
+        this.disposer.dispose();
+        return this.turn.close();
+    }
+}
+export class TurnProtocol {
+    static { this.type = 'turn'; }
+    constructor(
+    /** TURN server as configured; the host may be a hostname. */
+    server, username, password, lifetime, transport, options = {}) {
+        this.server = server;
+        this.username = username;
+        this.password = password;
+        this.lifetime = lifetime;
+        this.transport = transport;
+        this.options = options;
+        this.type = TurnProtocol.type;
+        this.onData = new Event();
+        this.onRequestReceived = new Event();
+        this.onDataReceived = new Event();
+        this.transactions = {};
+        /**When the allocation expires unless refreshed (ms since epoch), 0 when there is none */
+        this.expiresAt = 0;
+        this.channelNumber = 0x4000;
+        this.channelByAddr = {};
+        this.addrByChannel = {};
+        /**
+       * Serializes ChannelBind requests so allocation-wide auth state
+       * (nonce/realm/integrityKey) is not updated concurrently. Rejections
+       * must not poison this tail — see channelBindQueue assignment sites.
+       */
+        this.channelBindQueue = Promise.resolve();
+        /** In-flight ChannelBind per peer transport address (dedupe concurrent). */
+        this.channelBindingByAddr = new Map();
+        this.tcpBuffer = Buffer.alloc(0);
+        /** Permission cache keyed by peer IP only (RFC 8656). */
+        this.permissionByAddr = {};
+        /**
+       * Serializes CreatePermission requests (auth state race avoidance).
+       * Rejections must not poison this tail.
+       */
+        this.permissionQueue = Promise.resolve();
+        /** In-flight CreatePermission per peer IP (dedupe concurrent). */
+        this.creatingPermissionByAddr = new Map();
+        this.refresh = (exp) => {
+            this.refreshHandle = cancelable(async (_, __, onCancel) => {
+                const abort = new AbortController();
+                onCancel.once(() => {
+                    abort.abort();
+                });
+                while (!abort.signal.aborted) {
+                    // refresh before expire
+                    const delay = (5 / 6) * exp * 1000;
+                    log('refresh delay', delay, { exp });
+                    try {
+                        await setTimeout(delay, undefined, { signal: abort.signal });
+                    }
+                    catch (error) {
+                        if (abort.signal.aborted) {
+                            return;
+                        }
+                        throw error;
+                    }
+                    if (abort.signal.aborted) {
+                        return;
+                    }
+                    const request = new Message(methods.REFRESH, classes.REQUEST);
+                    request.setAttribute('LIFETIME', exp);
+                    try {
+                        const [message] = await this.requestWithRetry(request, this.server, abort.signal);
+                        exp = message.getAttributeValue('LIFETIME');
+                        log('refresh', { exp });
+                        this.expiresAt = Date.now() + exp * 1000;
+                    }
+                    catch (error) {
+                        if (abort.signal.aborted) {
+                            return;
+                        }
+                        log('refresh error', error);
+                    }
+                }
+            });
+        };
+        this.channelRefreshTime =
+            this.options.channelRefreshTime ?? DEFAULT_CHANNEL_REFRESH_TIME;
+    }
+    async connectionMade() {
+        this.transport.onData = (data, addr) => {
+            this.dataReceived(data, addr);
+        };
+        const request = new Message(methods.ALLOCATE, 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.expiresAt = Date.now() + exp * 1000;
+        this.refresh(exp);
+    }
+    handleChannelData(data) {
+        const decoded = decodeChannelData(data);
+        const addr = decoded && this.addrByChannel[decoded.channelNumber];
+        if (addr && decoded) {
+            this.onData.execute(decoded.data, addr);
+        }
+    }
+    handleSTUNMessage(data, addr) {
+        try {
+            const message = parseMessage(data);
+            if (!message) {
+                throw new Error('not stun message');
+            }
+            if (message.messageClass === classes.RESPONSE ||
+                message.messageClass === classes.ERROR) {
+                const transaction = this.transactions[message.transactionIdHex];
+                if (transaction) {
+                    //A challenge (a new nonce) comes without MESSAGE-INTEGRITY
+                    const verified = transaction.integrityKey && !isChallenge(message)
+                        ? parseMessage(data, transaction.integrityKey)
+                        : message;
+                    if (!verified) {
+                        log('TURN STUN response failed MESSAGE-INTEGRITY check');
+                        return;
+                    }
+                    transaction.responseReceived(verified, addr);
+                }
+            }
+            else if (message.messageClass === classes.REQUEST) {
+                this.onData.execute(data, addr);
+            }
+            if (message.getAttributeValue('DATA')) {
+                const buf = message.getAttributeValue('DATA');
+                const peerAddress = message.getAttributeValue('XOR-PEER-ADDRESS') ?? addr;
+                this.onData.execute(buf, peerAddress);
+            }
+        }
+        catch (error) {
+            log('parse error', data.toString());
+        }
+    }
+    dataReceived(data, addr) {
+        const datagramReceived = (data, addr) => {
+            if (data.length >= 4 && isChannelData(data)) {
+                this.handleChannelData(data);
+            }
+            else {
+                this.handleSTUNMessage(data, addr);
+            }
+        };
+        if (isStreamTransport(this.transport)) {
+            this.tcpBuffer = Buffer.concat([this.tcpBuffer, data]);
+            const { frames, rest } = splitTurnTcpFrames(this.tcpBuffer);
+            this.tcpBuffer = rest;
+            for (const frame of frames) {
+                datagramReceived(frame, addr);
+            }
+        }
+        else {
+            datagramReceived(data, addr);
+        }
+    }
+    async send(data, addr) {
+        if (this.transport.closed) {
+            return;
+        }
+        await this.transport.send(isStreamTransport(this.transport) ? padTurnFrame(data) : data, addr);
+    }
+    async createPermission(peerAddress) {
+        const request = new Message(methods.CREATE_PERMISSION, classes.REQUEST);
+        request
+            .setAttribute('XOR-PEER-ADDRESS', peerAddress)
+            .setAttribute('USERNAME', this.username)
+            .setAttribute('REALM', this.realm)
+            .setAttribute('NONCE', this.nonce);
+        // Use requestWithRetry for stale-nonce (438) consistency with ChannelBind.
+        await this.requestWithRetry(request, this.server);
+    }
+    async request(request, addr, _integrityKey, retransmissionsOrOptions, onRequestSent) {
+        if (this.transactions[request.transactionIdHex]) {
+            throw new Error('exist');
+        }
+        if (this.integrityKey) {
+            request
+                .setAttribute('USERNAME', this.username)
+                .setAttribute('REALM', this.realm)
+                .setAttribute('NONCE', this.nonce)
+                .addMessageIntegrity(this.integrityKey)
+                .addFingerprint();
+        }
+        // TURN server allocation/refresh uses default STUN retry policy unless
+        // callers pass explicit options. Peer consent goes through StunOverTurnProtocol.
+        // Prefer the TURN session integrity key for response verification.
+        const resolvedAddr = await this.resolveRequestTarget(addr);
+        const options = buildTransactionOptions(this.integrityKey, retransmissionsOrOptions, onRequestSent);
+        const transaction = new Transaction(request, resolvedAddr, this, options);
+        this.transactions[request.transactionIdHex] = transaction;
+        try {
+            return await transaction.run();
+        }
+        finally {
+            delete this.transactions[request.transactionIdHex];
+        }
+    }
+    /**
+   * The concrete TURN server address, selected on the first request and
+   * pinned for the rest of the allocation, so a later DNS answer can never
+   * move REFRESH, CREATE_PERMISSION, CHANNEL_BIND or data to another server.
+   */
+    get serverEndpoint() {
+        return this.pinnedServerEndpoint;
+    }
+    /**
+   * Address a request to `addr` is sent to, and the address its response
+   * must come from. A stream carries every request to the peer it is
+   * connected to, so it always uses the server endpoint.
+   */
+    async resolveRequestTarget(addr) {
+        if (isStreamTransport(this.transport) || addressEquals(addr, this.server)) {
+            return this.selectServerEndpoint();
+        }
+        return resolveRequestAddress(addr, this.transport.addressFamily ?? 0);
+    }
+    async serverDestination() {
+        return this.pinnedServerEndpoint ?? this.selectServerEndpoint();
+    }
+    selectServerEndpoint() {
+        this.serverEndpointSelection ??= this.resolveServerEndpoint().then((endpoint) => {
+            this.pinnedServerEndpoint = endpoint;
+            return endpoint;
+        }, (error) => {
+            // Let a later request try again, e.g. after a transient DNS failure.
+            this.serverEndpointSelection = undefined;
+            throw error;
+        });
+        return this.serverEndpointSelection;
+    }
+    /**
+   * UDP: resolve the configured server in the bound socket's family; a udp4
+   * socket cannot send to an IPv6 answer. TCP/TLS: use the peer the socket
+   * actually connected to. Looking the hostname up again could return a
+   * different A/AAAA record, and responses from the real peer would then be
+   * dropped as coming from an unexpected address.
+   */
+    async resolveServerEndpoint() {
+        const transport = this.transport;
+        if (!isStreamTransport(transport)) {
+            return resolveRequestAddress(this.server, transport.addressFamily ?? 0);
+        }
+        if (transport.remoteAddress) {
+            return transport.remoteAddress;
+        }
+        if (transport instanceof TcpTransport ||
+            transport instanceof TlsTransport) {
+            throw new Error(`${transport.type} transport has no remote address`);
+        }
+        // A custom stream transport that does not report its peer: fall back to
+        // a lookup with no family preference.
+        return resolveRequestAddress(this.server);
+    }
+    async requestWithRetry(request, addr, signal) {
+        let message, address;
+        try {
+            [message, address] = await this.request(request, addr, undefined, {
+                signal
+            });
+        }
+        catch (error) {
+            if (error instanceof TransactionFailed == false) {
+                log('requestWithRetry error', error);
+                throw error;
+            }
+            const [errorCode] = error.response.getAttributeValue('ERROR-CODE');
+            const nonce = error.response.getAttributeValue('NONCE');
+            const realm = error.response.getAttributeValue('REALM');
+            if (((errorCode === 401 && realm) || (errorCode === 438 && this.realm)) &&
+                nonce) {
+                log('retry with nonce', errorCode);
+                this.nonce = nonce;
+                if (errorCode === 401) {
+                    this.realm = realm;
+                }
+                this.integrityKey = makeIntegrityKey(this.username, this.realm, this.password);
+                request.transactionId = randomTransactionId();
+                [message, address] = await this.request(request, this.server, undefined, { signal });
+            }
+            else {
+                throw error;
+            }
+        }
+        return [message, address];
+    }
+    async sendData(data, addr) {
+        let channel;
+        try {
+            channel = await this.getChannel(addr);
+        }
+        catch (e) {
+            // Keep original ChannelBind error for diagnostics (403/438/timeout).
+            log('channelBind error; falling back to Send Indication', e);
+        }
+        if (!channel) {
+            await this.getPermission(addr);
+            const indicate = new Message(methods.SEND, classes.INDICATION)
+                .setAttribute('DATA', data)
+                .setAttribute('XOR-PEER-ADDRESS', addr);
+            await this.sendStun(indicate, await this.serverDestination());
+            return;
+        }
+        await this.send(encodeChannelData(channel.number, data), await this.serverDestination());
+    }
+    /**
+   * Ensure a CreatePermission exists for the peer IP.
+   * Peer failures are isolated: a rejection for peer A does not poison peer B.
+   */
+    async getPermission(addr) {
+        const key = permissionKey(addr);
+        if (this.permissionByAddr[key]) {
+            return;
+        }
+        const existing = this.creatingPermissionByAddr.get(key);
+        if (existing) {
+            return existing;
+        }
+        const operation = this.permissionQueue.then(async () => {
+            // Another caller may have succeeded while we waited on the queue.
+            if (this.permissionByAddr[key]) {
+                return;
+            }
+            await this.createPermission(addr);
+            // Cache only after successful CreatePermission.
+            this.permissionByAddr[key] = true;
+        });
+        // Do not let rejection poison subsequent peers on the shared queue.
+        this.permissionQueue = operation.then(() => undefined, () => undefined);
+        this.creatingPermissionByAddr.set(key, operation);
+        try {
+            await operation;
+        }
+        catch (error) {
+            log('createPermission error', error);
+            throw error;
+        }
+        finally {
+            if (this.creatingPermissionByAddr.get(key) === operation) {
+                this.creatingPermissionByAddr.delete(key);
+            }
+        }
+    }
+    /**
+   * Ensure a ChannelBind exists for the peer transport address.
+   * Peer failures are isolated; concurrent same-peer calls share one Promise.
+   */
+    async getChannel(addr) {
+        const key = channelKey(addr);
+        const existing = this.channelBindingByAddr.get(key);
+        if (existing) {
+            return existing;
+        }
+        // Fast path: bound and not due for refresh.
+        const cached = this.channelByAddr[key];
+        const now = int(Date.now() / 1000);
+        if (cached && cached.refreshAt > now) {
+            return cached;
+        }
+        const operation = this.channelBindQueue.then(() => this.ensureChannel(addr));
+        // Do not let rejection poison subsequent peers on the shared queue.
+        this.channelBindQueue = operation.then(() => undefined, () => undefined);
+        this.channelBindingByAddr.set(key, operation);
+        try {
+            return await operation;
+        }
+        catch (error) {
+            log('channelBind error', error);
+            throw error;
+        }
+        finally {
+            if (this.channelBindingByAddr.get(key) === operation) {
+                this.channelBindingByAddr.delete(key);
+            }
+        }
+    }
+    /**
+   * Create or refresh a channel for addr. Provisional mapping is installed
+   * before the request so early ChannelData can be decoded; only a failed
+   * *initial* bind rolls the mapping back. Failed channel numbers are never
+   * reused.
+   */
+    async ensureChannel(addr) {
+        const key = channelKey(addr);
+        const now = int(Date.now() / 1000);
+        let channel = this.channelByAddr[key];
+        if (channel && channel.refreshAt > now) {
+            return channel;
+        }
+        const isNew = !channel;
+        if (!channel) {
+            channel = {
+                number: this.channelNumber++,
+                address: addr,
+                refreshAt: 0
+            };
+            // Provisional mapping for ChannelData that may arrive before success.
+            this.channelByAddr[key] = channel;
+            this.addrByChannel[channel.number] = addr;
+        }
+        try {
+            await this.channelBind(channel.number, addr);
+            channel.refreshAt = int(Date.now() / 1000) + this.channelRefreshTime;
+            log(isNew ? 'channelBind' : 'channelBind refresh', channel);
+            return channel;
+        }
+        catch (error) {
+            if (isNew) {
+                // Roll back provisional mapping only for a failed initial bind.
+                delete this.channelByAddr[key];
+                delete this.addrByChannel[channel.number];
+                // Do not reuse the channel number (no channelNumber--).
+            }
+            throw error;
+        }
+    }
+    async channelBind(channelNumber, addr) {
+        const request = new Message(methods.CHANNEL_BIND, classes.REQUEST);
+        request
+            .setAttribute('CHANNEL-NUMBER', channelNumber)
+            .setAttribute('XOR-PEER-ADDRESS', addr);
+        const [response] = await this.requestWithRetry(request, this.server);
+        if (response.messageMethod !== methods.CHANNEL_BIND) {
+            throw new Error('should be CHANNEL_BIND');
+        }
+    }
+    async sendStun(message, addr) {
+        await this.send(message.bytes, addr);
+    }
+    /**
+   * Refresh the allocation now.
+   * @returns Whether the server still has it.
+   */
+    async refreshAllocation() {
+        if (!this.expiresAt || this.transport.closed) {
+            return false;
+        }
+        const request = new Message(methods.REFRESH, classes.REQUEST);
+        request.setAttribute('LIFETIME', this.lifetime);
+        try {
+            const [message] = await this.requestWithRetry(request, this.server);
+            this.expiresAt = Date.now() + message.getAttributeValue('LIFETIME') * 1000;
+            return true;
+        }
+        catch (error) {
+            log('refresh failed', error);
+            this.expiresAt = 0;
+            return false;
+        }
+    }
+    async close() {
+        this.refreshHandle?.resolve?.();
+        //Delete the allocation on the server (a refresh with a lifetime of 0, RFC 8656 section 7), waiting a second at
+        //most for the answer
+        if (this.expiresAt > Date.now() && !this.transport.closed) {
+            this.expiresAt = 0;
+            const request = new Message(methods.REFRESH, classes.REQUEST);
+            request.setAttribute('LIFETIME', 0);
+            await this.requestWithRetry(request, this.server, AbortSignal.timeout(DELETE_TIMEOUT)).catch((error) => {
+                log('delete allocation', error);
+            });
+        }
+        await this.transport.close();
+    }
+}
+/**
+ * Select the UDP socket type for a TURN server.
+ * Precedence: IP literal family > udpFamily > 4.
+ * An IP literal fixes the destination family, so a conflicting udpFamily is
+ * ignored (and logged) rather than making the server unreachable.
+ */
+function selectTurnUdpSocketType(address, udpFamily) {
+    const literalFamily = isIP(address[0]);
+    if (literalFamily === 4 || literalFamily === 6) {
+        if (udpFamily && udpFamily !== literalFamily) {
+            log('udpFamily ignored for IP literal TURN server', {
+                address,
+                udpFamily,
+                literalFamily
+            });
+        }
+        return literalFamily === 6 ? 'udp6' : 'udp4';
+    }
+    return (udpFamily ?? 4) === 6 ? 'udp6' : 'udp4';
+}
+export async function createTurnClient({ address, username, password }, { lifetime, portRange, interfaceAddresses, ssl, tlsOptions, transport: transportType, connectTimeoutMs, udpFamily } = {}) {
+    lifetime ??= DEFAULT_ALLOCATION_LIFETIME;
+    transportType ??= ssl ? 'tls' : 'udp';
+    const transport = transportType === 'udp'
+        ? await UdpTransport.init(selectTurnUdpSocketType(address, udpFamily), {
+            portRange,
+            interfaceAddresses
+        })
+        : transportType === 'tcp'
+            ? await TcpTransport.init(address, { connectTimeoutMs })
+            : await TlsTransport.init(address, tlsOptions, { connectTimeoutMs });
+    const turn = new TurnProtocol(address, username, password, lifetime, transport);
+    try {
+        await turn.connectionMade();
+    }
+    catch (error) {
+        try {
+            await turn.close();
+        }
+        catch (closeError) {
+            log('failed to close TURN client after allocation failure', closeError);
+        }
+        throw error;
+    }
+    return turn;
+}
+export async function createStunOverTurnClient(config, options = {}) {
+    const turn = await createTurnClient(config, options);
+    const turnTransport = new StunOverTurnProtocol(turn);
+    return turnTransport;
+}
+export function makeIntegrityKey(username, realm, password) {
+    return makeTurnIntegrityKey(username, realm, password);
+}

package/dist/esm/lib/ice/types/model.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/lib/ice/utils.js

@@ -0,0 +1,43 @@
+import * as os from 'node:os';
+import { debug, normalizeFamilyNodeV18 } from './imports/common.js';
+import { selectAddressesFromInterfaces } from './internal/selectAddresses.js';
+import { classes, methods } from './stun/const.js';
+import { Message } from './stun/message.js';
+import { StunProtocol } from './stun/protocol.js';
+const logger = debug('webrtc/ice/utils');
+export async function getGlobalIp(stunServer, interfaceAddresses) {
+    const protocol = new StunProtocol();
+    await protocol.connectionMade(true, undefined, interfaceAddresses);
+    const request = new Message(methods.BINDING, classes.REQUEST);
+    const [response] = await protocol.request(request, stunServer);
+    await protocol.close();
+    const address = response.getAttributeValue('XOR-MAPPED-ADDRESS');
+    return address[0];
+}
+export function isLinkLocalAddress(info) {
+    return ((normalizeFamilyNodeV18(info.family) === 4 &&
+        info.address?.startsWith('169.254.')) ||
+        (normalizeFamilyNodeV18(info.family) === 6 &&
+            info.address?.startsWith('fe80::')));
+}
+export function nodeIpAddress(family, { useLinkLocalAddress } = {}) {
+    const interfaces = os.networkInterfaces();
+    logger(interfaces);
+    return selectAddressesFromInterfaces(interfaces, family, { useLinkLocalAddress }, isLinkLocalAddress);
+}
+export function getHostAddresses(useIpv4, useIpv6, options = {}) {
+    const address = [];
+    if (useIpv4) {
+        address.push(...nodeIpAddress(4, options));
+    }
+    if (useIpv6) {
+        address.push(...nodeIpAddress(6, options));
+    }
+    return address;
+}
+export const url2Address = (url) => {
+    if (!url)
+        return;
+    const [address, port] = url.split(':');
+    return [address, Number.parseInt(port)];
+};