socket-function 0.23.0 → 0.25.0

package/SocketFunctionTypes.ts

@@ -38,6 +38,7 @@ export type SocketExposedShape<ExposedType extends SocketExposedInterface = Sock
         hooks?: SocketFunctionHook<ExposedType>[];
         clientHooks?: SocketFunctionClientHook<ExposedType>[];
         noDefaultHooks?: boolean;
+        /** BUG: I think this is broken if it is on the default hooks function? */
         noClientHooks?: boolean;
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.23.0",
+	"version": "0.25.0",
 	"main": "index.js",
 	"license": "MIT",
 	"note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/src/callManager.ts

@@ -122,13 +122,13 @@ export const runClientHooks = measureWrap(async function runClientHooks(
 ): Promise<ClientHookContext> {
     let context: ClientHookContext = { call: callType, connectionId };
 
-    let clientHooks = (
-        globalClientHooks
-            .concat(hooks.clientHooks || [])
-    );
-    for (let otherClientHook of globalHooks.concat(hooks.hooks || []).map(x => x.clientHook)) {
-        if (otherClientHook) {
-            clientHooks.push(otherClientHook);
+    let clientHooks = hooks.clientHooks?.slice() || [];
+    if (!hooks.noClientHooks) {
+        clientHooks = globalClientHooks.concat(clientHooks);
+        for (let otherClientHook of globalHooks.concat(hooks.hooks || []).map(x => x.clientHook)) {
+            if (otherClientHook) {
+                clientHooks.push(otherClientHook);
+            }
         }
     }
     for (let hook of clientHooks) {

package/src/forwardPort.ts

@@ -1,6 +1,7 @@
 import debugbreak from "debugbreak";
 import * as dgram from "dgram";
 import os from "os";
+import { timeInHour } from "./misc";
 
 const SSDP_DISCOVER_MX = 2;
 const SSDP_DISCOVER_MSG = `M-SEARCH * HTTP/1.1\r\nHOST: 239.255.255.250:1900\r\nMAN: "ssdp:discover"\r\nMX: ${SSDP_DISCOVER_MX}\r\nST: urn:schemas-upnp-org:device:InternetGatewayDevice:1\r\n\r\n`;
@@ -8,34 +9,41 @@ const SSDP_DISCOVER_MSG = `M-SEARCH * HTTP/1.1\r\nHOST: 239.255.255.250:1900\r\n
 export async function forwardPort(config: {
     externalPort: number;
     internalPort: number;
+    duration?: number;
 }) {
-    const { externalPort, internalPort } = config;
-
-    const localObj = getLocalInterfaceAddress();
-    if (!localObj) throw new Error("Could not find the local address / gateway");
-
-    const { internalIP, gatewayIP } = localObj;
-    console.log(`Local IP: ${internalIP}, Gateway IP: ${gatewayIP}`);
-    let gateway = await discoverGateway(internalIP);
-    let controlURLs = await getControlPaths(gateway);
-    let controlPort = Number(new URL(gateway).port);
-
-    for (let controlURL of controlURLs) {
-        try {
-            await createPortMapping({
-                externalPort, internalPort,
-                gatewayIP,
-                controlPort,
-                controlPath: controlURL,
-                internalIP,
-            });
-            console.log(`Port mapping created on ${gatewayIP}:${externalPort} -> ${internalIP}:${internalPort}`);
-            return;
-        } catch (e) {
-            console.error(`Failed to create port mapping using controlURL ${controlURL}`, e);
+    try {
+        const { externalPort, internalPort } = config;
+        let duration = config.duration ?? timeInHour;
+
+        const localObj = getLocalInterfaceAddress();
+        if (!localObj) throw new Error("Could not find the local address / gateway");
+
+        const { internalIP, gatewayIP } = localObj;
+        console.log(`Local IP: ${internalIP}, Gateway IP: ${gatewayIP}`);
+        let gateway = await discoverGateway(internalIP);
+        let controlURLs = await getControlPaths(gateway);
+        let controlPort = Number(new URL(gateway).port);
+
+        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");
 }
 
 function getLocalInterfaceAddress(): { internalIP: string; gatewayIP: string; } | undefined {
@@ -61,34 +69,41 @@ function getLocalInterfaceAddress(): { internalIP: string; gatewayIP: string; }
             }
         }
     } else {
-        // For Unix-like systems (Linux, macOS)
-        // Try to get gateway from route command first
-        let routeOutput = require("child_process").execSync("route -n").toString();
-        let gatewayMatch = routeOutput.match(/0\.0\.0\.0\s+(\d+\.\d+\.\d+\.\d+)/);
+        let gatewayMatch: RegExpMatchArray | undefined;
+        try {
+            // Attempt to get the gateway using "ip route" command (more universal)
+            const routeOutput = require("child_process")("ip route show default").toString();
+            gatewayMatch = routeOutput.match(/default via (\d+\.\d+\.\d+\.\d+)/);
+        } catch (err) {
+            console.error("Failed to execute 'ip route show default', trying fallback", err);
+        }
 
         if (!gatewayMatch) {
-            // Fallback for macOS
-            routeOutput = require("child_process").execSync("netstat -nr").toString();
-            gatewayMatch = routeOutput.match(/default\s+(\d+\.\d+\.\d+\.\d+)/);
+            try {
+                // Fallback to "netstat -rn" for older systems
+                const netstatOutput = require("child_process")("netstat -rn").toString();
+                gatewayMatch = netstatOutput.match(/default\s+(\d+\.\d+\.\d+\.\d+)/);
+            } catch (err) {
+                console.error("Failed to execute 'netstat -rn', unable to find gateway", err);
+            }
         }
 
-        if (gatewayMatch && looksLikeRouter(gatewayMatch[1])) {
-            // Now get the internal IP from ifconfig/ip addr
-            let ipCommand = os.platform() === "darwin" ? "ifconfig" : "ip addr";
-            let ipOutput = require("child_process").execSync(ipCommand).toString();
-
-            let ipMatch;
-            if (os.platform() === "darwin") {
-                ipMatch = ipOutput.match(/inet ((?!127\.0\.0\.1)\d+\.\d+\.\d+\.\d+)/);
-            } else {
-                ipMatch = ipOutput.match(/inet ((?!127\.0\.0\.1)\d+\.\d+\.\d+\.\d+)\/\d+/);
-            }
+        if (gatewayMatch) {
+            try {
+                // Use "ip addr" to get internal IP (more universal)
+                const ipOutput = require("child_process")("ip addr").toString();
+                const ipMatch = ipOutput.match(/inet (?!127\.0\.0\.1)(\d+\.\d+\.\d+\.\d+)\//);
 
-            if (ipMatch) {
-                return {
-                    internalIP: ipMatch[1],
-                    gatewayIP: gatewayMatch[1]
-                };
+                if (ipMatch) {
+                    return {
+                        internalIP: ipMatch[1],
+                        gatewayIP: gatewayMatch[1]
+                    };
+                } else {
+                    console.error("Failed to match internal IP");
+                }
+            } catch (err) {
+                console.error("Failed to execute 'ip addr'", err);
             }
         }
     }
@@ -160,7 +175,7 @@ async function createPortMapping(config: {
     controlPort: number;
     controlPath: string;
     internalIP: string;
-
+    duration: number;
 }): Promise<void> {
     const { externalPort, internalPort, internalIP, controlPath, controlPort, gatewayIP } = config;
     const action = "\"urn:schemas-upnp-org:service:WANIPConnection:1#AddPortMapping\"";
@@ -177,7 +192,7 @@ async function createPortMapping(config: {
                     <NewInternalClient>${internalIP}</NewInternalClient>
                     <NewEnabled>1</NewEnabled>
                     <NewPortMappingDescription>My Port Mapping</NewPortMappingDescription>
-                    <NewLeaseDuration>0</NewLeaseDuration>
+                    <NewLeaseDuration>${Math.ceil(config.duration / 1000)}</NewLeaseDuration>
                 </u:AddPortMapping>
             </s:Body>
         </s:Envelope>

package/src/networking.ts

@@ -33,7 +33,7 @@ const ipServers = [
 export const getExternalIP = lazy(measureWrap(async function getExternalIP(): Promise<string> {
     for (let server of ipServers) {
         try {
-            return (await httpsRequest(server)).toString();
+            return (await httpsRequest(server, undefined, undefined, false)).toString();
         } catch (e) {
             console.warn(`Failed to get external ip from ${server}: ${e}`);
         }

package/src/webSocketServer.ts

@@ -11,7 +11,7 @@ import { parseSNIExtension, parseTLSHello, SNIType } from "./tlsParsing";
 import debugbreak from "debugbreak";
 import { getNodeId } from "./nodeCache";
 import crypto from "crypto";
-import { Watchable, timeInHour } from "./misc";
+import { Watchable, timeInHour, timeInMinute } from "./misc";
 import { delay, runInfinitePoll, runInfinitePollCallAtStart } from "./batching";
 import { magenta, red } from "./formatting/logColors";
 import { yellow } from "./formatting/logColors";
@@ -35,7 +35,8 @@ export type SocketServerConfig = (
         /** Tries forwarding ports (using UPnP), if we detect they aren't externally reachable.
          *      - This causes an extra request and delay during startup, so should only be used
          *          during development.
-         *      - Ignored if public is false
+         *      - Ignored if public is false (in which case we mount on 127.0.0.1, so port forwarding
+         *          wouldn't matter anyways).
         */
         autoForwardPort?: boolean;
         ip?: string;
@@ -180,6 +181,7 @@ export async function startSocketServer(
     });
 
     let realServer = net.createServer(socket => {
+        //console.log("Received TCP connection from " + socket.remoteAddress);
         const remoteAddress = socket.remoteAddress;
         function handleTLSHello(buffer: Buffer, packetCount: number): void | "more" {
             // All HTTPS requests start with 22, and no HTTP requests start with 22,
@@ -296,7 +298,7 @@ export async function startSocketServer(
             console.log(magenta(`Forwarded port ${port} to our machine`));
         }
         // Every hour, in case our network configuration changes
-        runInfinitePollCallAtStart(timeInHour * 1, forward).catch(e => console.error(red(`Error in port forwarding ${e.stack}`)));
+        runInfinitePollCallAtStart(timeInMinute * 30, forward).catch(e => console.error(red(`Error in port forwarding ${e.stack}`)));
     }
 
     let nodeId = getNodeId(getCommonName(config.cert), port);

package/time/trueTimeShim.ts

@@ -200,10 +200,15 @@ const TimeController = SocketFunction.register(
     "TimeController-ddf4753e-fc8a-413f-8cc2-b927dd449976",
     new TimeControllerBase(),
     () => ({
-        getTrueTime: {},
-    }),
-    () => ({
+        getTrueTime: {
+            // No hooks, as this needs to run very early on. Also, it is basically just a ping,
+            //  so it should be safe for anyone to use (we might even make it just a regular HTTPS endpoint,
+            //  or even just set up a dedicated domain for this).
+            noDefaultHooks: true,
+            noClientHooks: true,
+        },
     }),
+    () => ({}),
     {
         // NOTE: Autoexpose, because our exposed endpoints are incredibly lightweight
         //  (just a ping), and don't expose really expose any data.