socket-function 1.2.21 → 1.2.23

package/index.d.ts

@@ -984,6 +984,9 @@ declare module "socket-function/src/forwardPort" {
         externalPort: number;
         internalPort: number;
         duration?: number;
+        /** Keep the lease alive by re-creating the mapping at 80% of `duration`, forever. On by
+         *      default, which is what you want — an un-maintained forward silently expires. */
+        autoRenew?: boolean;
     }): Promise<void>;
     /** Our machine's LAN IP, as the router sees it — used to tell whether an existing port
      *      mapping points at us or at a different machine on the network. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "1.2.21",
+	"version": "1.2.23",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/forwardPort.d.ts

@@ -19,6 +19,9 @@ export declare function forwardPort(config: {
     externalPort: number;
     internalPort: number;
     duration?: number;
+    /** Keep the lease alive by re-creating the mapping at 80% of `duration`, forever. On by
+     *      default, which is what you want — an un-maintained forward silently expires. */
+    autoRenew?: boolean;
 }): Promise<void>;
 /** Our machine's LAN IP, as the router sees it — used to tell whether an existing port
  *      mapping points at us or at a different machine on the network. */

package/src/forwardPort.ts

@@ -74,36 +74,58 @@ export async function listPortMappings(): Promise<PortMapping[]> {
     throw new Error(`Failed to list port mappings, could not find a working controlURL. Last error: ${(lastError as Error)?.stack ?? lastError}`);
 }
 
+// A UPnP lease expires on its own, so a forward left un-renewed silently dies partway through.
+//  Renew at 80% of the duration: enough margin to cover a failed attempt (we retry on the next
+//  tick) while the previous lease is still live, so the mapping never actually lapses.
+const LEASE_RENEW_FRACTION = 0.8;
+
 export async function forwardPort(config: {
     externalPort: number;
     internalPort: number;
     duration?: number;
+    /** Keep the lease alive by re-creating the mapping at 80% of `duration`, forever. On by
+     *      default, which is what you want — an un-maintained forward silently expires. */
+    autoRenew?: boolean;
 }) {
-    try {
-        const { externalPort, internalPort } = config;
-        let duration = config.duration ?? timeInHour;
-
-        const { internalIP, gatewayIP, controlPort, controlURLs } = await resolveGateway();
+    let duration = config.duration ?? timeInHour;
+    let autoRenew = config.autoRenew ?? true;
 
-        for (let controlURL of controlURLs) {
-            try {
-                await createPortMapping({
-                    externalPort, internalPort,
-                    gatewayIP,
-                    controlPort,
-                    controlPath: controlURL,
-                    internalIP,
-                    duration,
-                });
-                console.log(`Port mapping created on ${gatewayIP}:${externalPort} -> ${internalIP}:${internalPort}`);
-                return;
-            } catch (e) {
-                console.error(`Failed to create port mapping using controlURL ${controlURL}`, e);
+    async function createMapping() {
+        try {
+            const { externalPort, internalPort } = config;
+            const { internalIP, gatewayIP, controlPort, controlURLs } = await resolveGateway();
+
+            for (let controlURL of controlURLs) {
+                try {
+                    await createPortMapping({
+                        externalPort, internalPort,
+                        gatewayIP,
+                        controlPort,
+                        controlPath: controlURL,
+                        internalIP,
+                        duration,
+                    });
+                    console.log(`Port mapping created on ${gatewayIP}:${externalPort} -> ${internalIP}:${internalPort}`);
+                    return;
+                } catch (e) {
+                    console.error(`Failed to create port mapping using controlURL ${controlURL}`, e);
+                }
             }
+            console.error("Failed to create port mapping, could not find controlURL");
+        } catch (e) {
+            console.error("Error in forwardPort", e);
         }
-        console.error("Failed to create port mapping, could not find controlURL");
-    } catch (e) {
-        console.error("Error in forwardPort", e);
+    }
+
+    await createMapping();
+
+    if (autoRenew) {
+        // unref so a script that only wants a one-off forward (and then exits) isn't held open by
+        //  the renewal timer; a running server stays alive on its own and the renewals keep firing.
+        let timer = setInterval(() => {
+            void createMapping();
+        }, Math.max(1, Math.floor(duration * LEASE_RENEW_FRACTION)));
+        timer.unref?.();
     }
 }
 

package/src/protocolNegotiation.ts

@@ -35,6 +35,17 @@ function encodeFlagBit(b: boolean): string { return b ? "1" : "0"; }
 // connecting through a Let's Encrypt cert on a public domain.
 const WILDCARD_TARGET = "";
 
+// The target match is on the host portion only, not the exact listening port. A
+// server can restart (or rebind) on a new port while keeping the same host identity,
+// and a client still holding the old nodeId (host:oldPort) should be accepted rather
+// than rejected as a stale thread. Strip only the trailing :port (last colon segment),
+// so hosts that themselves contain colons survive.
+function stripPort(nodeId: string): string {
+    let idx = nodeId.lastIndexOf(":");
+    if (idx < 0) return nodeId;
+    return nodeId.slice(0, idx);
+}
+
 function encodeOne(target: string, flags: ConnectionFlags): string {
     let plain = `${PROTOCOL_VERSION}|${target}|clz4=${encodeFlagBit(flags.clientLZ4)}|slz4=${encodeFlagBit(flags.serverLZ4)}`;
     return hexEncode(plain);
@@ -105,7 +116,8 @@ export function chooseProtocol(
     for (let hex of proposed) {
         let decoded = decodeProtocol(hex);
         if (!decoded) continue;
-        if (decoded.target !== WILDCARD_TARGET && decoded.target !== serverNodeId) continue;
+        // NOTE: We allow the pork to be different. This doesn't degrade security as we're still using TLS, so proxies don't reduce our security, However, it does make it a lot easier for a server to listen on multiple ports and redirect them all to the single-mounted port (As socket function doesn't support mounting on multiple ports because it makes it complicated for code that wants to say where we mounted to if we could be mounted to multiple ports at once).
+        if (decoded.target !== WILDCARD_TARGET && stripPort(decoded.target) !== stripPort(serverNodeId)) continue;
         // Server capability check: if the proposal asks the server to receive
         // LZ4 (slz4=1) but the server doesn't support it, skip.
         if (decoded.flags.serverLZ4 && !serverCapabilities.lz4) continue;

package/src/webSocketServer.ts

@@ -11,8 +11,8 @@ import { parseSNIExtension, parseTLSHello, SNIType } from "./tlsParsing";
 import debugbreak from "debugbreak";
 import { getNodeId } from "./nodeCache";
 import crypto from "crypto";
-import { Watchable, getRootDomain, timeInHour, timeInMinute } from "./misc";
-import { delay, runInfinitePoll } from "./batching";
+import { Watchable, getRootDomain } from "./misc";
+import { delay } from "./batching";
 import { magenta, red } from "./formatting/logColors";
 import { yellow } from "./formatting/logColors";
 import { green } from "./formatting/logColors";
@@ -439,12 +439,9 @@ export async function startSocketServer(
     port = (realServer.address() as net.AddressInfo).port;
 
     if (doForward) {
-        // The mapping is claimed above; keep refreshing the lease so it doesn't expire.
-        async function refreshForward() {
-            await forwardPort({ externalPort: port, internalPort: port });
-            console.log(magenta(`Refreshed port forward ${port} to our machine`));
-        }
-        runInfinitePoll(timeInMinute * 30, refreshForward);
+        // The mapping is claimed above; this establishes the maintained forward, which
+        //  auto-renews its own lease (at 80% of the duration) so it doesn't expire.
+        await forwardPort({ externalPort: port, internalPort: port });
     }
 
     let nodeId = getNodeId(getCommonName(config.cert), port);