@apocaliss92/nodelink-js 0.5.1-beta.8 → 0.5.1

package/dist/{chunk-27IU7NXS.js → chunk-OJQLZETO.js}

@@ -292,6 +292,7 @@ var BCUDP_DEFAULT_MTU = 1350;
 var BCUDP_DATA_HEADER_SIZE = 20;
 var BCUDP_DISCOVERY_PORT_LOCAL_ANY = 2015;
 var BCUDP_DISCOVERY_PORT_LOCAL_UID = 2018;
+var BCUDP_DISCOVERY_PORT_P2P_SCAN = 9999;
 
 // src/bcudp/crc.ts
 var table;
@@ -656,6 +657,10 @@ function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 var P2P_RELAY_HOSTNAMES = [
+  // Master anycast routers — try first.
+  "p2pm-abr.reolink.com",
+  "p2pm-ali.reolink.com",
+  // Numbered regional relays.
   "p2p.reolink.com",
   "p2p1.reolink.com",
   "p2p2.reolink.com",
@@ -667,8 +672,29 @@ var P2P_RELAY_HOSTNAMES = [
   "p2p8.reolink.com",
   "p2p9.reolink.com",
   "p2p10.reolink.com",
-  "p2p11.reolink.com"
+  "p2p11.reolink.com",
+  // China-region fallbacks (intentionally last).
+  "p2p.reolink.com.cn",
+  "p2p1.reolink.com.cn",
+  "p2p2.reolink.com.cn",
+  "p2p3.reolink.com.cn",
+  "p2p4.reolink.com.cn",
+  "p2p5.reolink.com.cn",
+  "p2p6.reolink.com.cn",
+  "p2p7.reolink.com.cn",
+  "p2p8.reolink.com.cn",
+  "p2p9.reolink.com.cn"
 ];
+function isUnroutableForP2P(ip) {
+  if (!ip) return true;
+  if (ip === "0.0.0.0") return true;
+  if (ip.startsWith("127.")) return true;
+  if (ip.startsWith("10.")) return true;
+  if (ip.startsWith("192.168.")) return true;
+  if (/^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(ip)) return true;
+  if (/^100\.(6[4-9]|[7-9][0-9]|1[01][0-9]|12[0-7])\./.test(ip)) return true;
+  return false;
+}
 var P2P_LOOKUP_PORT = 9999;
 var P2P_MAX_WAIT_MS = 15e3;
 var P2P_RESEND_WAIT_MS = 500;
@@ -835,19 +861,30 @@ var BcUdpStream = class extends EventEmitter {
   }
   async p2pUidLookup(sock, uid) {
     const resolved = [];
+    const sinkholed = [];
     for (const host of P2P_RELAY_HOSTNAMES) {
       try {
         const answers = await dns.lookup(host, { family: 4, all: true });
         for (const a of answers) {
-          if (a.address && !resolved.includes(a.address))
-            resolved.push(a.address);
+          if (!a.address) continue;
+          if (isUnroutableForP2P(a.address)) {
+            sinkholed.push({ host, ip: a.address });
+            continue;
+          }
+          if (!resolved.includes(a.address)) resolved.push(a.address);
         }
       } catch {
       }
     }
     if (resolved.length === 0) {
+      if (sinkholed.length > 0) {
+        const samples = sinkholed.slice(0, 3).map((s) => `${s.host} \u2192 ${s.ip}`).join(", ");
+        throw new Error(
+          `P2P UID lookup failed: DNS resolves Reolink P2P hostnames to non-routable IPs (${samples}). This is almost certainly an /etc/hosts rewrite or a DNS filter (Pi-hole, AdGuard, NextDNS) blocking *.reolink.com. Battery cameras cannot connect without P2P \u2014 whitelist *.reolink.com (at least p2p*.reolink.com on UDP/9999) or remove the override. Verify with \`getent hosts p2p.reolink.com\` inside your container \u2014 if it differs from \`nslookup p2p.reolink.com\`, the offender is /etc/hosts.`
+        );
+      }
       throw new Error(
-        "P2P UID lookup failed: no p2p.reolink.com addresses resolved"
+        "P2P UID lookup failed: no p2p.reolink.com addresses resolved (DNS failure)"
       );
     }
     const start = Date.now();
@@ -1181,7 +1218,8 @@ var BcUdpStream = class extends EventEmitter {
       throw new Error("Internal: discoveryUidLocal called for non-uid mode");
     const ports = [
       BCUDP_DISCOVERY_PORT_LOCAL_ANY,
-      BCUDP_DISCOVERY_PORT_LOCAL_UID
+      BCUDP_DISCOVERY_PORT_LOCAL_UID,
+      BCUDP_DISCOVERY_PORT_P2P_SCAN
     ];
     const broadcastHosts = ["255.255.255.255"];
     const ifaces = networkInterfaces();
@@ -23478,7 +23516,11 @@ async function discoverViaUdpDirect(host, options) {
     });
     socket.bind(() => {
       const localPort = socket.address().port;
-      const discoveryPorts = [BCUDP_DISCOVERY_PORT_LOCAL_ANY, BCUDP_DISCOVERY_PORT_LOCAL_UID];
+      const discoveryPorts = [
+        BCUDP_DISCOVERY_PORT_LOCAL_ANY,
+        BCUDP_DISCOVERY_PORT_LOCAL_UID,
+        BCUDP_DISCOVERY_PORT_P2P_SCAN
+      ];
       for (const port of discoveryPorts) {
         try {
           const tid = Math.floor(Math.random() * 255) || 1;
@@ -23767,7 +23809,11 @@ async function discoverViaUdpBroadcast(options) {
     socket.bind(() => {
       socket.setBroadcast(true);
       const localPort = socket.address().port;
-      const discoveryPorts = [BCUDP_DISCOVERY_PORT_LOCAL_ANY, BCUDP_DISCOVERY_PORT_LOCAL_UID];
+      const discoveryPorts = [
+        BCUDP_DISCOVERY_PORT_LOCAL_ANY,
+        BCUDP_DISCOVERY_PORT_LOCAL_UID,
+        BCUDP_DISCOVERY_PORT_P2P_SCAN
+      ];
       for (const port of discoveryPorts) {
         try {
           const tid = Math.floor(Math.random() * 255) || 1;
@@ -24262,19 +24308,95 @@ function isTcpFailureThatShouldFallbackToUdp(e) {
   return message.includes("ECONNREFUSED") || message.includes("ETIMEDOUT") || message.includes("EHOSTUNREACH") || message.includes("ENETUNREACH") || message.includes("socket hang up") || message.includes("TCP connection timeout") || message.includes("Baichuan socket closed") || message.includes("timeout waiting for nonce") || message.includes("expected encryption info") || message.includes("ECONNRESET") || message.includes("EPIPE");
 }
 async function pingHost(host, timeoutMs = 3e3) {
-  const { exec } = await import("child_process");
+  if (!host || typeof host !== "string") return false;
   const platform2 = process.platform;
-  const pingCmd = platform2 === "win32" ? `ping -n 1 -w ${timeoutMs} ${host}` : platform2 === "darwin" ? (
-    // macOS: -W is in milliseconds (Linux: seconds)
-    `ping -c 1 -W ${timeoutMs} ${host}`
-  ) : (
-    // Linux/BSD-ish: -W is in seconds on most distros
-    `ping -c 1 -W ${Math.max(1, Math.floor(timeoutMs / 1e3))} ${host}`
-  );
+  const pingCandidates = platform2 === "win32" ? ["ping"] : platform2 === "darwin" ? ["/sbin/ping", "/usr/sbin/ping", "ping"] : ["/bin/ping", "/usr/bin/ping", "ping"];
+  const pingArgs = (bin) => {
+    void bin;
+    if (platform2 === "win32") {
+      return ["-n", "1", "-w", String(timeoutMs), host];
+    }
+    if (platform2 === "darwin") {
+      return ["-c", "1", "-W", String(timeoutMs), host];
+    }
+    return ["-c", "1", "-W", String(Math.max(1, Math.floor(timeoutMs / 1e3))), host];
+  };
+  const { spawn: spawn3 } = await import("child_process");
+  for (const bin of pingCandidates) {
+    const ranOk = await new Promise((resolve) => {
+      let settled = false;
+      let child;
+      try {
+        child = spawn3(bin, pingArgs(bin), { stdio: "ignore" });
+      } catch {
+        resolve("spawn-failed");
+        return;
+      }
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        try {
+          child?.kill("SIGKILL");
+        } catch {
+        }
+        resolve(false);
+      }, timeoutMs + 500);
+      child.on("error", () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve("spawn-failed");
+      });
+      child.on("exit", (code) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve(code === 0);
+      });
+    });
+    if (ranOk === true) return true;
+    if (ranOk === "spawn-failed") continue;
+    break;
+  }
+  for (const port of [9e3, 443, 80]) {
+    if (await tcpReachabilityProbe(host, port, 800)) return true;
+  }
+  return false;
+}
+async function tcpReachabilityProbe(host, port, timeoutMs) {
+  const net4 = await import("net");
   return new Promise((resolve) => {
-    exec(pingCmd, (error) => {
-      resolve(!error);
+    let settled = false;
+    const socket = new net4.Socket();
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      try {
+        socket.destroy();
+      } catch {
+      }
+      resolve(false);
+    }, timeoutMs);
+    const finish = (reachable) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        socket.destroy();
+      } catch {
+      }
+      resolve(reachable);
+    };
+    socket.once("connect", () => finish(true));
+    socket.once("error", (err) => {
+      if (err?.code === "ECONNREFUSED") finish(true);
+      else finish(false);
     });
+    try {
+      socket.connect(port, host);
+    } catch {
+      finish(false);
+    }
   });
 }
 function createBaichuanApi(inputs, transport) {
@@ -24347,6 +24469,7 @@ async function autoDetectDeviceType(inputs) {
   const sleepMs2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
   const shouldRetryTcp = (e) => {
     const msg = fmtErr(e);
+    if (msg.includes("ECONNREFUSED")) return false;
     return isTcpFailureThatShouldFallbackToUdp(e) || msg.includes("timeout waiting for nonce") || msg.includes("expected encryption info") || msg.includes("Baichuan socket closed") || msg.includes("ECONNRESET") || msg.includes("EPIPE");
   };
   const shouldRetryUdp = (e) => {
@@ -24401,6 +24524,11 @@ async function autoDetectDeviceType(inputs) {
     }
   };
   const effectiveUid = normalizeUid(uid);
+  const speculativeUidPromise = effectiveUid !== void 0 ? Promise.resolve(effectiveUid) : mode === "tcp" ? Promise.resolve(void 0) : discoverUidForHost(host, logger).then((d) => normalizeUid(d) ?? void 0).catch(() => void 0);
+  speculativeUidPromise.then(
+    () => void 0,
+    () => void 0
+  );
   logger?.log?.(`[AutoDetect] Pinging ${host}...`);
   const isReachable = await pingHost(host);
   if (!isReachable) {
@@ -24414,19 +24542,11 @@ async function autoDetectDeviceType(inputs) {
     logger?.log?.(
       `[AutoDetect] Forced mode=udp, skipping TCP and starting UDP discovery/login...`
     );
-    let normalizedUid = effectiveUid;
+    let normalizedUid = await speculativeUidPromise;
     if (!normalizedUid) {
-      logger?.log?.(
-        `[AutoDetect] UID not provided; attempting UDP discovery for UID...`
+      throw new Error(
+        `Forced UDP autodetect requires UID (or successful UDP UID discovery), but none was provided/discovered (ip=${host}).`
       );
-      const discovered = await discoverUidForHost(host, logger);
-      const normalizedDiscovered = normalizeUid(discovered);
-      if (!normalizedDiscovered) {
-        throw new Error(
-          `Forced UDP autodetect requires UID (or successful UDP UID discovery), but none was provided/discovered (ip=${host}).`
-        );
-      }
-      normalizedUid = normalizedDiscovered;
     }
     const methodsToTry = inputs.udpDiscoveryMethod ? [inputs.udpDiscoveryMethod] : ["local-direct", "local-broadcast", "remote", "relay", "map"];
     return await runUdpMethodsParallel(
@@ -24673,26 +24793,15 @@ async function autoDetectDeviceType(inputs) {
       throw tcpError;
     }
     logger?.log?.(`[AutoDetect] TCP failed, trying UDP...`);
-    let normalizedUid = effectiveUid;
+    let normalizedUid = await speculativeUidPromise;
     if (!normalizedUid) {
       logger?.log?.(
-        `[AutoDetect] UID not provided; attempting UDP broadcast discovery for UID...`
+        `[AutoDetect] UID discovery failed; only local-direct can run without a UID. If the camera is sleeping or on a different subnet, supply its UID to enable BCUDP P2P fallback (remote/relay/map) which can wake it via Reolink's servers.`
+      );
+    } else if (effectiveUid === void 0) {
+      logger?.log?.(
+        `[AutoDetect] UID resolved via concurrent broadcast discovery: ${normalizedUid}`
       );
-      const discovered = await discoverUidForHost(host, logger);
-      if (discovered) {
-        const normalizedDiscovered = normalizeUid(discovered);
-        if (normalizedDiscovered) {
-          normalizedUid = normalizedDiscovered;
-          logger?.log?.(
-            `[AutoDetect] UID discovered via broadcast: ${normalizedUid}`
-          );
-        }
-      }
-      if (!normalizedUid) {
-        logger?.log?.(
-          `[AutoDetect] UID discovery failed; only local-direct can run without a UID. If the camera is sleeping or on a different subnet, supply its UID to enable BCUDP P2P fallback (remote/relay/map) which can wake it via Reolink's servers.`
-        );
-      }
     }
     try {
       const detectOverUdpApi = async (udpApi, udpDiscoveryMethod) => {
@@ -24790,6 +24899,7 @@ export {
   encodeHeader,
   decodeHeader,
   BaichuanFrameParser,
+  isUnroutableForP2P,
   BcUdpStream,
   asLogger,
   createNullLogger,
@@ -24854,6 +24964,7 @@ export {
   normalizeUid,
   maskUid,
   isTcpFailureThatShouldFallbackToUdp,
+  tcpReachabilityProbe,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-27IU7NXS.js.map
+//# sourceMappingURL=chunk-OJQLZETO.js.map