@apocaliss92/nodelink-js 0.6.1 → 0.6.3

package/dist/cli/rtsp-server.cjs

@@ -2574,6 +2574,41 @@ var init_BaichuanVideoStream = __esm({
 });
 
 // src/protocol/xml.ts
+function xmlTextRe(tag) {
+  let re = xmlTextReCache.get(tag);
+  if (re === void 0) {
+    re = new RegExp(`<${tag}>([^<]*)</${tag}>`);
+    xmlTextReCache.set(tag, re);
+  }
+  return re;
+}
+function xmlTagRe(tag) {
+  let re = xmlTagReCache.get(tag);
+  if (re === void 0) {
+    re = new RegExp(`<${tag}>[^<]*</${tag}>`);
+    xmlTagReCache.set(tag, re);
+  }
+  return re;
+}
+function xmlNestedRe(parent, child) {
+  const key = `${parent}\0${child}`;
+  let re = xmlNestedReCache.get(key);
+  if (re === void 0) {
+    re = new RegExp(
+      `(<${parent}[^>]*>[\\s\\S]*?<${child}>)[^<]*(</${child}>[\\s\\S]*?</${parent}>)`
+    );
+    xmlNestedReCache.set(key, re);
+  }
+  return re;
+}
+function xmlStreamBlockRe(streamTag) {
+  let re = xmlStreamBlockReCache.get(streamTag);
+  if (re === void 0) {
+    re = new RegExp(`(<${streamTag}[^>]*>)([\\s\\S]*?)(</${streamTag}>)`);
+    xmlStreamBlockReCache.set(streamTag, re);
+  }
+  return re;
+}
 function xmlEscape(text) {
   if (text === void 0 || text === null || typeof text !== "string") {
     const error = new Error(
@@ -2694,8 +2729,7 @@ function buildPreviewStopXmlV11(params) {
 </body>`;
 }
 function getXmlText(xml, tagName) {
-  const re = new RegExp(`<${tagName}>([^<]*)</${tagName}>`);
-  const m = re.exec(xml);
+  const m = xmlTextRe(tagName).exec(xml);
   return m?.[1];
 }
 function buildPtzControlXml(channelId, command, speed) {
@@ -2796,13 +2830,12 @@ ${xml}`;
 function applyXmlTagPatch(xml, tag, value) {
   if (value === void 0) return xml;
   const v = typeof value === "boolean" ? value ? 1 : 0 : value;
-  const re = new RegExp(`<${tag}>[^<]*</${tag}>`);
-  return xml.replace(re, `<${tag}>${v}</${tag}>`);
+  return xml.replace(xmlTagRe(tag), `<${tag}>${v}</${tag}>`);
 }
 function upsertXmlTag(xml, tag, value) {
   if (value === void 0) return xml;
   const v = typeof value === "boolean" ? value ? 1 : 0 : value;
-  const re = new RegExp(`<${tag}>[^<]*</${tag}>`);
+  const re = xmlTagRe(tag);
   if (re.test(xml)) {
     return xml.replace(re, `<${tag}>${v}</${tag}>`);
   }
@@ -2811,16 +2844,11 @@ function upsertXmlTag(xml, tag, value) {
 function patchNestedTag(xml, parent, child, value) {
   if (value === void 0) return xml;
   const v = typeof value === "boolean" ? value ? 1 : 0 : value;
-  const re = new RegExp(
-    `(<${parent}[^>]*>[\\s\\S]*?<${child}>)[^<]*(</${child}>[\\s\\S]*?</${parent}>)`
-  );
-  return xml.replace(re, `$1${v}$2`);
+  return xml.replace(xmlNestedRe(parent, child), `$1${v}$2`);
 }
 function applyStreamPatch(xml, streamTag, patch) {
   if (!patch) return xml;
-  const re = new RegExp(
-    `(<${streamTag}[^>]*>)([\\s\\S]*?)(</${streamTag}>)`
-  );
+  const re = xmlStreamBlockRe(streamTag);
   return xml.replace(re, (_match, open, body, close) => {
     let next = body;
     if (patch.audio !== void 0) {
@@ -2850,10 +2878,9 @@ function applyStreamPatch(xml, streamTag, patch) {
       next = upsertXmlTag(next, "encoderProfile", patch.encoderProfile);
     }
     if (patch.gop !== void 0) {
-      const gopBlockRe = /(<gop[^>]*>)([\s\S]*?)(<\/gop>)/;
-      if (gopBlockRe.test(next)) {
+      if (GOP_BLOCK_RE.test(next)) {
         next = next.replace(
-          gopBlockRe,
+          GOP_BLOCK_RE,
           (_m, gOpen, gBody, gClose) => `${gOpen}${applyXmlTagPatch(gBody, "cur", patch.gop)}${gClose}`
         );
       } else {
@@ -2882,10 +2909,15 @@ function buildAbilityInfoExtensionXml(username) {
 <token>system, streaming, PTZ, IO, security, replay, disk, network, alarm, record, video, image</token>
 </Extension>`;
 }
-var XML_HEADER;
+var xmlTextReCache, xmlTagReCache, xmlNestedReCache, GOP_BLOCK_RE, xmlStreamBlockReCache, XML_HEADER;
 var init_xml = __esm({
   "src/protocol/xml.ts"() {
     "use strict";
+    xmlTextReCache = /* @__PURE__ */ new Map();
+    xmlTagReCache = /* @__PURE__ */ new Map();
+    xmlNestedReCache = /* @__PURE__ */ new Map();
+    GOP_BLOCK_RE = /(<gop[^>]*>)([\s\S]*?)(<\/gop>)/;
+    xmlStreamBlockReCache = /* @__PURE__ */ new Map();
     XML_HEADER = `<?xml version="1.0" encoding="UTF-8" ?>`;
   }
 });
@@ -11350,8 +11382,14 @@ async function getServerBinding(uid, options = {}) {
       headers: { Accept: "application/json" }
     });
     if (!res.ok) {
+      let bodyPreview;
+      try {
+        const text = await res.text();
+        bodyPreview = text.slice(0, 512).replace(/\s+/g, " ").trim();
+      } catch {
+      }
       logger?.log?.(
-        `[server-binding] ${uid}: HTTP ${res.status} ${res.statusText} from ${url}`
+        `[server-binding] ${uid}: HTTP ${res.status} ${res.statusText} from ${url}` + (bodyPreview ? ` \u2014 body=${bodyPreview}` : "")
       );
       cache.set(uid, { kind: "err", expires: now + NEGATIVE_TTL_MS });
       return void 0;
@@ -11467,6 +11505,68 @@ function parseServerBindingResponse(raw) {
 }
 
 // src/bcudp/BcUdpStream.ts
+async function probeEgressForHost(destHost, destPort) {
+  return await new Promise((resolve, reject) => {
+    const probe = import_node_dgram.default.createSocket("udp4");
+    let settled = false;
+    const finish = (err, out) => {
+      if (settled) return;
+      settled = true;
+      try {
+        probe.close();
+      } catch {
+      }
+      if (err || !out) reject(err ?? new Error("egress probe failed"));
+      else resolve(out);
+    };
+    probe.on("error", (e) => finish(e));
+    try {
+      probe.connect(destPort, destHost, () => {
+        try {
+          const a = probe.address();
+          if (typeof a === "string") return finish(new Error("probe address is string"));
+          finish(void 0, {
+            localAddress: a.address,
+            localPort: a.port
+          });
+        } catch (e) {
+          finish(e);
+        }
+      });
+    } catch (e) {
+      finish(e);
+    }
+  });
+}
+function isSameSubnetAsAnyLocalIface(destHost, srcInfo) {
+  if (!/^\d+\.\d+\.\d+\.\d+$/.test(destHost)) return "unknown";
+  const dest = destHost.split(".").map((s) => Number(s));
+  if (dest.some((n) => !Number.isFinite(n) || n < 0 || n > 255))
+    return "unknown";
+  const ifaces = (0, import_node_os.networkInterfaces)();
+  let ownerSubnet;
+  for (const name of Object.keys(ifaces)) {
+    const entries = ifaces[name];
+    if (!entries) continue;
+    for (const e of entries) {
+      if (e.family !== "IPv4" || e.internal) continue;
+      if (e.address !== srcInfo.localAddress) continue;
+      const addr = e.address.split(".").map((s) => Number(s));
+      const mask = e.netmask.split(".").map((s) => Number(s));
+      if (addr.length !== 4 || mask.length !== 4 || addr.some((n) => !Number.isFinite(n)) || mask.some((n) => !Number.isFinite(n)))
+        continue;
+      ownerSubnet = { addr, mask };
+      break;
+    }
+    if (ownerSubnet) break;
+  }
+  if (!ownerSubnet) return "unknown";
+  for (let i = 0; i < 4; i++) {
+    if ((ownerSubnet.addr[i] & ownerSubnet.mask[i]) !== (dest[i] & ownerSubnet.mask[i]))
+      return "mismatch";
+  }
+  return "same";
+}
 var AckLatency = class {
   currentValues = [];
   lastReceiveTime = null;
@@ -11545,6 +11645,11 @@ function isUnroutableForP2P(ip) {
 var P2P_LOOKUP_PORT = 9999;
 var P2P_MAX_WAIT_MS = 15e3;
 var P2P_RESEND_WAIT_MS = 500;
+var inflightP2pLookups = /* @__PURE__ */ new Map();
+var cachedP2pLookups = /* @__PURE__ */ new Map();
+var negCachedP2pLookups = /* @__PURE__ */ new Map();
+var P2P_LOOKUP_CACHE_TTL_MS = 3e4;
+var P2P_LOOKUP_NEG_CACHE_TTL_MS = 15e3;
 var BcUdpStream = class extends import_node_events3.EventEmitter {
   opts;
   /**
@@ -11633,31 +11738,14 @@ var BcUdpStream = class extends import_node_events3.EventEmitter {
     });
     sock.on("error", (e) => this.emit("error", e));
     sock.on("close", () => this.emit("close"));
-    const portRange = Array.from({ length: 500 }, (_, i) => 53500 + i);
-    for (let i = portRange.length - 1; i > 0; i--) {
-      const j = Math.floor(Math.random() * (i + 1));
-      [portRange[i], portRange[j]] = [portRange[j], portRange[i]];
-    }
-    let bound = false;
-    for (const port of portRange) {
-      try {
-        await new Promise((resolve, reject) => {
-          sock.once("error", reject);
-          sock.bind(port, "0.0.0.0", () => {
-            sock.removeListener("error", reject);
-            resolve();
-          });
-        });
-        bound = true;
-        break;
-      } catch {
-      }
-    }
-    if (!bound) {
-      await new Promise(
-        (resolve) => sock.bind(0, "0.0.0.0", () => resolve())
-      );
-    }
+    await new Promise((resolve, reject) => {
+      const onErr = (e) => reject(e);
+      sock.once("error", onErr);
+      sock.bind(0, "0.0.0.0", () => {
+        sock.removeListener("error", onErr);
+        resolve();
+      });
+    });
     if (this.opts.mode === "direct") {
       this.remote = { host: this.opts.host, port: this.opts.port };
       this.clientId = this.opts.clientId;
@@ -11728,6 +11816,49 @@ var BcUdpStream = class extends import_node_events3.EventEmitter {
     this.remote = { host: connected.rhost, port: connected.rport };
   }
   async p2pUidLookup(sock, uid) {
+    const log = (msg) => this.discoveryLogger?.log?.(`[P2P] ${msg}`);
+    const shortUid = uid.length > 7 ? `${uid.slice(0, 5)}\u2026${uid.slice(-2)}` : uid;
+    const cached = cachedP2pLookups.get(uid);
+    if (cached && cached.expires > Date.now()) {
+      log(
+        `UID=${shortUid} cached lookup hit (relay=${cached.result.relay.ip}:${cached.result.relay.port})`
+      );
+      return cached.result;
+    }
+    const negCached = negCachedP2pLookups.get(uid);
+    if (negCached && negCached.expires > Date.now()) {
+      const remaining = negCached.expires - Date.now();
+      log(
+        `UID=${shortUid} negative-cache hit (fail-fast, retry in ${Math.ceil(remaining / 1e3)}s)`
+      );
+      throw negCached.error;
+    }
+    const inflight = inflightP2pLookups.get(uid);
+    if (inflight) {
+      log(`UID=${shortUid} sharing in-flight lookup with concurrent race lane`);
+      return await inflight;
+    }
+    const work = this._doP2pUidLookupWork(sock, uid);
+    inflightP2pLookups.set(uid, work);
+    try {
+      const result = await work;
+      cachedP2pLookups.set(uid, {
+        result,
+        expires: Date.now() + P2P_LOOKUP_CACHE_TTL_MS
+      });
+      return result;
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      negCachedP2pLookups.set(uid, {
+        error: err,
+        expires: Date.now() + P2P_LOOKUP_NEG_CACHE_TTL_MS
+      });
+      throw err;
+    } finally {
+      inflightP2pLookups.delete(uid);
+    }
+  }
+  async _doP2pUidLookupWork(sock, uid) {
     const log = (msg) => this.discoveryLogger?.log?.(`[P2P] ${msg}`);
     const shortUid = uid.length > 7 ? `${uid.slice(0, 5)}\u2026${uid.slice(-2)}` : uid;
     const t0 = Date.now();
@@ -12195,6 +12326,23 @@ var BcUdpStream = class extends import_node_events3.EventEmitter {
     log(
       `local discovery: mode=${localMode} uid=${shortUid} ports=[${ports.join(", ")}] broadcasts=[${broadcastHosts.join(", ")}]${directHost ? ` direct=${directHost}` : ""} localBindPort=${localPort} timeout=${discoveryTimeout}ms`
     );
+    if (directHost && localMode === "local-direct") {
+      try {
+        const egress = await probeEgressForHost(directHost, ports[0] ?? 2015);
+        const sameSubnet = isSameSubnetAsAnyLocalIface(directHost, egress);
+        if (sameSubnet === "mismatch") {
+          log(
+            `WARN: kernel-chosen source IP ${egress.localAddress} is NOT in the same subnet as ${directHost}. Some Reolink battery cams silently drop discovery packets with off-subnet source IPs. If discovery fails, check your routing table \u2014 likely a Tailscale / VPN / secondary NIC stealing the default route.`
+          );
+        } else {
+          log(
+            `egress for ${directHost} \u2192 src=${egress.localAddress}` + (sameSubnet === "same" ? ` (same subnet \u2713)` : ` (subnet relationship unknown)`)
+          );
+        }
+      } catch (e) {
+        this.emit("debug", "egress_probe_failed", e);
+      }
+    }
     let bytesSent = 0;
     let pktsRecv = 0;
     sock.on("message", () => {
@@ -12861,35 +13009,88 @@ function decodeHeader(buf) {
   return { header, headerLen, messageKey };
 }
 var BaichuanFrameParser = class {
+  /** Retained-but-unconsumed contiguous bytes from previous push() calls. */
   buffer = Buffer.alloc(0);
+  /** Chunks received since the last materialization, not yet concatenated. */
+  pending = [];
+  /** Total bytes held in `pending` (kept in sync to avoid re-summing). */
+  pendingLen = 0;
+  /**
+   * Total contiguous bytes (`buffer` + `pending`) required before the next
+   * parse attempt can make progress. While buffered bytes stay below this,
+   * incoming chunks are merely stashed in `pending` with no copy. This is
+   * the mechanism that turns the worst case (a large frame fragmented over
+   * many small TCP chunks) from O(n²) into O(n): we concatenate once, when
+   * enough bytes have arrived, instead of on every chunk.
+   *
+   * Starts at 4 — the minimum needed to inspect the magic header.
+   */
+  needed = 4;
+  /**
+   * Collapse `this.buffer` + all `pending` chunks into a single contiguous
+   * buffer. The retained leftover is copied at most once per materialize(),
+   * and materialize() only runs when `needed` bytes are available — so a
+   * fragmented frame is assembled with a single concat, not one per chunk.
+   */
+  materialize() {
+    if (this.pendingLen === 0) return;
+    if (this.buffer.length === 0 && this.pending.length === 1) {
+      this.buffer = this.pending[0];
+    } else {
+      const parts = this.buffer.length === 0 ? this.pending : [this.buffer, ...this.pending];
+      this.buffer = Buffer.concat(parts);
+    }
+    this.pending = [];
+    this.pendingLen = 0;
+  }
+  /** Total buffered bytes, whether materialized or still pending. */
+  get available() {
+    return this.buffer.length + this.pendingLen;
+  }
   push(chunk) {
     if (chunk.length === 0) return [];
-    const c = chunk;
-    this.buffer = this.buffer.length === 0 ? c : Buffer.concat([this.buffer, c]);
+    this.pending.push(chunk);
+    this.pendingLen += chunk.length;
+    if (this.available < this.needed) return [];
+    this.materialize();
     const out = [];
     while (true) {
-      if (this.buffer.length < 4) break;
+      if (this.buffer.length < 4) {
+        this.needed = 4;
+        break;
+      }
       if (!this.buffer.subarray(0, 4).equals(BC_MAGIC) && !this.buffer.subarray(0, 4).equals(BC_MAGIC_REV)) {
         const idx = this.buffer.indexOf(BC_MAGIC);
         const idxRev = this.buffer.indexOf(BC_MAGIC_REV);
         const next = idx === -1 ? idxRev : idxRev === -1 ? idx : Math.min(idx, idxRev);
         if (next === -1) {
           this.buffer = this.buffer.subarray(Math.max(0, this.buffer.length - 3));
+          this.needed = 4;
           break;
         }
         this.buffer = this.buffer.subarray(next);
-        if (this.buffer.length < 20) break;
+        if (this.buffer.length < 20) {
+          this.needed = 20;
+          break;
+        }
+      }
+      if (this.buffer.length < 20) {
+        this.needed = 20;
+        break;
       }
-      if (this.buffer.length < 20) break;
       let headerInfo;
       try {
         headerInfo = decodeHeader(this.buffer);
       } catch {
+        this.needed = 24;
         break;
       }
       const { header, headerLen, messageKey } = headerInfo;
       const frameLen = headerLen + header.bodyLen;
-      if (this.buffer.length < frameLen) break;
+      if (this.buffer.length < frameLen) {
+        this.needed = frameLen;
+        break;
+      }
       const raw = this.buffer.subarray(0, frameLen);
       const body = raw.subarray(headerLen);
       let extLen = 0;
@@ -12901,6 +13102,7 @@ var BaichuanFrameParser = class {
       const payload = body.subarray(extLen);
       out.push({ header, body, extension, payload, messageKey, raw });
       this.buffer = this.buffer.subarray(frameLen);
+      this.needed = 4;
     }
     return out;
   }