@livedesk/hub 0.1.12 → 0.1.14

package/src/transport/udp-hub-transport.js

@@ -1,5 +1,6 @@
-import crypto from 'node:crypto';
-import dgram from 'node:dgram';
+import crypto from 'node:crypto';
+import { lookup } from 'node:dns/promises';
+import dgram from 'node:dgram';
 import {
     UDP_MAX_DATAGRAM_BYTES,
     UDP_P2P_PROTOCOL,
@@ -26,10 +27,15 @@ function numberEnv(value, min, max, fallback) {
     return Number.isFinite(number) ? Math.max(min, Math.min(max, Math.floor(number))) : fallback;
 }
 
-function sameEndpoint(left, right) {
-    return !!left && !!right && String(left.address) === String(right.address) && Number(left.port) === Number(right.port);
-}
-
+function sameEndpoint(left, right) {
+    return !!left && !!right && String(left.address) === String(right.address) && Number(left.port) === Number(right.port);
+}
+
+function normalizedAddress(value) {
+    const address = safeText(value, 128).toLowerCase();
+    return address.startsWith('::ffff:') ? address.slice(7) : address;
+}
+
 export function createHubUdpTransport({ env = process.env, logEvent = () => {}, logWarn = () => {} } = {}) {
     const enabled = isEnabled(env.LIVEDESK_UDP_ENABLED, true);
     const preferP2p = isEnabled(env.LIVEDESK_UDP_PREFER_P2P, false);
@@ -37,7 +43,8 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
     const requestedPort = numberEnv(env.LIVEDESK_UDP_PORT, 0, 65535, 0);
     const advertiseHost = safeText(env.LIVEDESK_UDP_ADVERTISE_HOST || env.LIVEDESK_REMOTE_PUBLIC_HOST || '', 128);
     const rendezvousHost = safeText(env.LIVEDESK_UDP_RENDEZVOUS_HOST || 'www.gnsoftech.com', 128);
-    const rendezvousPort = numberEnv(env.LIVEDESK_UDP_RENDEZVOUS_PORT, 1, 65535, 5199);
+    const rendezvousPort = numberEnv(env.LIVEDESK_UDP_RENDEZVOUS_PORT, 1, 65535, 5199);
+    const rendezvousRefreshMs = numberEnv(env.LIVEDESK_UDP_RENDEZVOUS_REFRESH_MS, 1000, 50_000, 25_000);
     const punchTimeoutMs = numberEnv(env.LIVEDESK_UDP_PUNCH_TIMEOUT_MS, 500, 10_000, 3000);
     const frameTimeoutMs = numberEnv(env.LIVEDESK_UDP_FRAME_TIMEOUT_MS, 20, 2000, 500);
     const maxPendingFrames = numberEnv(env.LIVEDESK_UDP_MAX_PENDING_FRAMES, 1, 16, 2);
@@ -46,9 +53,12 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
     const sessions = new Map();
     let frameHandler = () => {};
     let eventHandler = () => {};
-    let started = false;
-    let boundPort = requestedPort;
-    let sequence = crypto.randomInt(1, 0x7fffffff);
+    let started = false;
+    let boundPort = requestedPort;
+    let sequence = crypto.randomInt(1, 0x7fffffff);
+    let rendezvousAddresses = new Set();
+    let rendezvousRefreshTimer = null;
+    let rendezvousRefreshPromise = null;
 
     function emit(type, event = {}) {
         eventHandler(type, event);
@@ -60,8 +70,8 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
         return sequence;
     }
 
-    function sendPacket(session, type, header = {}, payload = Buffer.alloc(0), address = session.peerEndpoint || session.clientEndpoint) {
-        if (!address || !session) return false;
+    function sendPacket(session, type, header = {}, payload = Buffer.alloc(0), address = session.clientEndpoint || session.peerEndpoint) {
+        if (!address || !session) return false;
         let packet;
         try {
             packet = encodeUdpPacket({ type, sessionId: session.sessionId, key: session.key, sequence: nextSequence(), header, payload });
@@ -73,34 +83,105 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
         return true;
     }
 
-    function sendRendezvousRegister(session) {
-        if (!rendezvousHost) return;
-        const message = encodeRendezvousMessage({
-            type: 'rendezvous.register',
+    function sendRendezvousRegister(session) {
+        if (!rendezvousHost || rendezvousAddresses.size === 0 || !started) return false;
+        const message = encodeRendezvousMessage({
+            type: 'rendezvous.register',
             protocol: UDP_P2P_PROTOCOL,
             roomId: session.sessionId,
-            role: 'hub',
-            token: session.rendezvousToken
-        });
-        socket.send(message, rendezvousPort, rendezvousHost);
-    }
-
-    function sessionForPacket(packet, rinfo) {
-        if (!Buffer.isBuffer(packet) || packet.length < 7) return null;
-        const sessionLength = packet[6];
-        if (!sessionLength || packet.length < 27 + sessionLength) return null;
-        const sessionId = packet.subarray(27, 27 + sessionLength).toString('utf8');
-        const session = [...sessions.values()].find(item => item.sessionId === sessionId);
-        if (!session) return null;
-        if (!session.clientEndpoint) session.clientEndpoint = { address: rinfo.address, port: rinfo.port };
-        if (!sameEndpoint(session.clientEndpoint, rinfo)) return null;
-        return session;
-    }
-
-    function onRendezvousPeer(message, rinfo) {
-        const session = [...sessions.values()].find(item => item.sessionId === safeText(message.roomId, 160));
-        if (!session || !rendezvousHost || Number(rinfo.port) !== rendezvousPort) return;
-        const address = safeText(message.host, 128);
+            role: 'hub',
+            token: session.rendezvousToken
+        });
+        let sent = false;
+        for (const address of rendezvousAddresses) {
+            try {
+                socket.send(message, rendezvousPort, address, error => {
+                    if (error) logWarn('udp', `UDP rendezvous registration failed: ${error?.message || error}`);
+                });
+                sent = true;
+            } catch (error) {
+                logWarn('udp', `UDP rendezvous registration failed: ${error?.message || error}`);
+            }
+        }
+        return sent;
+    }
+
+    async function resolveRendezvousAddresses() {
+        if (!rendezvousHost) return false;
+        try {
+            const records = await lookup(rendezvousHost, { all: true, family: 4, verbatim: true });
+            const resolved = new Set(records.map(record => normalizedAddress(record.address)).filter(Boolean));
+            if (resolved.size === 0) throw new Error('no-ipv4-address');
+            rendezvousAddresses = resolved;
+            return true;
+        } catch (error) {
+            logWarn('udp', `UDP rendezvous host resolution failed: ${error?.message || error}`);
+            return false;
+        }
+    }
+
+    function refreshRendezvousRegistrations(reason = 'periodic') {
+        if (!started || !rendezvousHost) return Promise.resolve(false);
+        if (rendezvousRefreshPromise) return rendezvousRefreshPromise;
+        rendezvousRefreshPromise = (async () => {
+            await resolveRendezvousAddresses();
+            if (!started) return false;
+            let refreshed = false;
+            for (const session of sessions.values()) {
+                refreshed = sendRendezvousRegister(session) || refreshed;
+            }
+            if (trace && refreshed) emit('UdpRendezvousRegistrationRefreshed', { reason });
+            return refreshed;
+        })().finally(() => {
+            rendezvousRefreshPromise = null;
+        });
+        return rendezvousRefreshPromise;
+    }
+
+    function startRendezvousRefreshTimer() {
+        if (!rendezvousHost || rendezvousRefreshTimer) return;
+        rendezvousRefreshTimer = setInterval(() => {
+            void refreshRendezvousRegistrations('periodic');
+        }, rendezvousRefreshMs);
+        rendezvousRefreshTimer.unref?.();
+    }
+
+    function stopRendezvousRefreshTimer() {
+        if (rendezvousRefreshTimer) clearInterval(rendezvousRefreshTimer);
+        rendezvousRefreshTimer = null;
+    }
+
+    function isTrustedRendezvousSource(rinfo) {
+        return Number(rinfo?.port) === rendezvousPort
+            && rendezvousAddresses.has(normalizedAddress(rinfo?.address));
+    }
+
+    function sessionForPacket(packet) {
+        if (!Buffer.isBuffer(packet) || packet.length < 7) return null;
+        const sessionLength = packet[6];
+        if (!sessionLength || packet.length < 27 + sessionLength) return null;
+        const sessionId = packet.subarray(27, 27 + sessionLength).toString('utf8');
+        return [...sessions.values()].find(item => item.sessionId === sessionId) || null;
+    }
+
+    function bindAuthenticatedClientEndpoint(session, rinfo) {
+        const endpoint = { address: rinfo.address, port: rinfo.port };
+        if (sameEndpoint(session.clientEndpoint, endpoint)) return false;
+        session.clientEndpoint = endpoint;
+        session.lastPeerAt = Date.now();
+        sendRendezvousRegister(session);
+        void refreshRendezvousRegistrations('authenticated-endpoint-change');
+        emit('UdpAuthenticatedEndpointObserved', {
+            deviceId: session.deviceId,
+            endpoint: `${endpoint.address}:${endpoint.port}`
+        });
+        return true;
+    }
+
+    function onRendezvousPeer(message, rinfo) {
+        const session = [...sessions.values()].find(item => item.sessionId === safeText(message.roomId, 160));
+        if (!session || message.protocol !== UDP_P2P_PROTOCOL || !isTrustedRendezvousSource(rinfo)) return;
+        const address = safeText(message.host, 128);
         const port = Number(message.port);
         if (!address || !Number.isInteger(port) || port < 1 || port > 65535) return;
         session.peerEndpoint = { address, port };
@@ -112,24 +193,23 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
     socket.on('message', (payload, rinfo) => {
         const rendezvous = decodeRendezvousMessage(payload);
         if (rendezvous?.type === 'rendezvous.peer') {
-            onRendezvousPeer(rendezvous, rinfo);
-            return;
-        }
-        const session = sessionForPacket(payload, rinfo);
-        if (!session) return;
-        const packet = decodeUdpPacket(payload, session.key);
-        if (!packet || packet.sessionId !== session.sessionId || !session.replay.accept(packet.sequence)) return;
-        session.lastPacketAt = Date.now();
-        if (packet.type === 'probe') {
-            session.clientEndpoint = { address: rinfo.address, port: rinfo.port };
-            sendPacket(session, 'probe-ack', { observedHost: rinfo.address, observedPort: rinfo.port });
+            onRendezvousPeer(rendezvous, rinfo);
+            return;
+        }
+        const session = sessionForPacket(payload);
+        if (!session) return;
+        const packet = decodeUdpPacket(payload, session.key);
+        if (!packet || packet.sessionId !== session.sessionId || !session.replay.accept(packet.sequence)) return;
+        bindAuthenticatedClientEndpoint(session, rinfo);
+        session.lastPacketAt = Date.now();
+        if (packet.type === 'probe') {
+            sendPacket(session, 'probe-ack', { observedHost: rinfo.address, observedPort: rinfo.port });
             emit('UdpProbeReceived', { deviceId: session.deviceId });
             return;
         }
-        if (packet.type === 'ready') {
-            session.ready = true;
-            session.clientEndpoint = { address: rinfo.address, port: rinfo.port };
-            sendPacket(session, 'pong', { state: 'ready' });
+        if (packet.type === 'ready') {
+            session.ready = true;
+            sendPacket(session, 'pong', { state: 'ready' });
             session.sendControl?.({
                 type: 'udp.session.ready',
                 protocol: UDP_P2P_PROTOCOL,
@@ -189,7 +269,9 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
             logWarn('udp', `UDP socket buffer tuning was unavailable: ${error?.message || error}`);
         }
         logEvent('udp', `UDP P2P socket listening on udp://${bindHost}:${boundPort}`);
-        return getStatus();
+        void refreshRendezvousRegistrations('startup');
+        startRendezvousRefreshTimer();
+        return getStatus();
     }
 
     function registerDevice({ deviceId, sessionId: tcpSessionId, sendControl, capabilities } = {}) {
@@ -260,11 +342,12 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
         };
     }
 
-    async function close() {
-        sessions.clear();
-        if (!started) return;
-        await new Promise(resolve => socket.close(() => resolve()));
-        started = false;
+    async function close() {
+        stopRendezvousRefreshTimer();
+        sessions.clear();
+        if (!started) return;
+        started = false;
+        await new Promise(resolve => socket.close(() => resolve()));
     }
 
     return {
@@ -286,8 +369,10 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
             bindHost,
             port: boundPort,
             advertiseHost,
-            rendezvousHost,
-            rendezvousPort,
+            rendezvousHost,
+            rendezvousPort,
+            rendezvousRefreshMs,
+            rendezvousResolvedAddressCount: rendezvousAddresses.size,
             maxDatagramBytes: UDP_MAX_DATAGRAM_BYTES,
             sessionCount: sessions.size,
             readySessionCount: [...sessions.values()].filter(session => session.ready).length

package/src/transport/udp-rendezvous.js

@@ -296,6 +296,7 @@ export function createUdpRendezvousServer({
         if (!hub || !client) return;
         send({
             type: 'rendezvous.peer',
+            protocol: UDP_P2P_PROTOCOL,
             roomId,
             role: 'client',
             host: client.address,
@@ -303,6 +304,7 @@ export function createUdpRendezvousServer({
         }, hub.address, hub.port);
         send({
             type: 'rendezvous.peer',
+            protocol: UDP_P2P_PROTOCOL,
             roomId,
             role: 'hub',
             host: hub.address,