@decentnetwork/peer 0.1.65 → 0.1.67

package/dist/peer.js

@@ -1647,15 +1647,19 @@ export class Peer {
                 }
                 else {
                     // Adopt the source as our send endpoint — but NEVER downgrade from a
-                    // same-LAN (physical) path to a non-LAN source (a hairpin packet via
-                    // the peer's public / Tailscale-exit endpoint must not knock us off
+                    // locked same-LAN (physical) path to a non-LAN source (a hairpin packet
+                    // via the peer's public / Tailscale-exit endpoint must not knock us off
                     // the direct LAN path, which is strictly better).
-                    const cur = state.remote?.host;
-                    const onSameLanAlready = !!cur && !cur.startsWith("tcp:") && isPrivateAddress(cur) && !isCgnatAddress(cur) &&
-                        getPhysicalLanSubnets().some((s) => isInIpv4Subnet(cur, s));
-                    const incomingSameLan = isPrivateAddress(remote.address) && !isCgnatAddress(remote.address) &&
-                        getPhysicalLanSubnets().some((s) => isInIpv4Subnet(remote.address, s));
-                    if (incomingSameLan || !onSameLanAlready) {
+                    //
+                    // CCTV-safe: the LAN decision (which needs a networkInterfaces() syscall)
+                    // is made ONLY in the periodic offer/maintenance paths, which record the
+                    // locked peer LAN host in state.lanRemoteHost. Here in the per-packet hot
+                    // path we do a single string compare — NO interface syscall — so a
+                    // high-rate stream (CCTV: thousands of packets/sec) never pays for it.
+                    // (The per-packet getPhysicalLanSubnets() call this replaces was the
+                    // CCTV CPU regression.)
+                    const lockedOnLan = !!state.lanRemoteHost && state.remote?.host === state.lanRemoteHost;
+                    if (!lockedOnLan || remote.address === state.lanRemoteHost) {
                         state.remote = { host: remote.address, port: remote.port };
                     }
                     if (!state.lastUdpRecvMs) {
@@ -3423,6 +3427,9 @@ export class Peer {
                 if (!onSameLanAlready) {
                     session.remote = { host: lanHost, port: lanPort };
                 }
+                // Record the locked LAN host so the per-packet receive path can refuse a
+                // public/hairpin downgrade with a plain string compare (no syscall).
+                session.lanRemoteHost = lanHost;
                 if (session.established) {
                     void this.#sendMessengerPacket(friendId, PACKET_ID_ALIVE, new Uint8Array()).catch(() => undefined);
                 }
@@ -4057,6 +4064,12 @@ export class Peer {
                 const r = session.remote;
                 const remoteIsSameLan = !!r && isPrivateAddress(r.host) && !isCgnatAddress(r.host) &&
                     getPhysicalLanSubnets().some((s) => isInIpv4Subnet(r.host, s));
+                if (remoteIsSameLan) {
+                    // Already on a physical-LAN path (e.g. the session established directly
+                    // over LAN). Lock it so the per-packet hot path's cheap string-compare
+                    // guard refuses any later public/hairpin downgrade — no syscall there.
+                    session.lanRemoteHost = r.host;
+                }
                 if (!remoteIsSameLan) {
                     // If we ALREADY hold a same-LAN candidate for this peer (learned from
                     // an earlier offer), switch the session onto it NOW — don't wait to
@@ -4069,6 +4082,7 @@ export class Peer {
                         getPhysicalLanSubnets().some((s) => isInIpv4Subnet(c.host, s)));
                     if (lanCand) {
                         session.remote = { host: lanCand.host, port: lanCand.port };
+                        session.lanRemoteHost = lanCand.host;
                         void this.#sendMessengerPacket(friendId, PACKET_ID_ALIVE, new Uint8Array()).catch(() => undefined);
                     }
                     void this.#sendUdpEndpointOffer(friendId).catch(() => undefined);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.65",
+  "version": "0.1.67",
   "description": "Pure TypeScript port of Elastos Carrier (toxcore-derived) P2P messaging. DHT, onion routing, TCP relay, FlatBuffers app payloads, Express offline relay. Wire-compatible with iOS Beagle and the Carrier C SDK.",
   "type": "module",
   "main": "./dist/index.js",