socket-function 0.22.0 → 0.24.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.22.0",
+	"version": "0.24.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,5 +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`;
@@ -7,13 +9,16 @@ 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;
+    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);
@@ -26,30 +31,72 @@ export async function forwardPort(config: {
                 controlPort,
                 controlPath: controlURL,
                 internalIP,
+                duration,
             });
+            console.log(`Port mapping created on ${gatewayIP}:${externalPort} -> ${internalIP}:${internalPort}`);
             return;
         } catch (e) {
-            console.error(e);
+            console.error(`Failed to create port mapping using controlURL ${controlURL}`, e);
         }
     }
     console.error("Failed to create port mapping, could not find controlURL");
 }
 
 function getLocalInterfaceAddress(): { internalIP: string; gatewayIP: string; } | undefined {
-    const interfaces = os.networkInterfaces() as any;
-    for (const name of Object.keys(interfaces)) {
-        for (const iface of interfaces[name]) {
-            if (iface.family === "IPv4" && !iface.internal) {
-                // TOOD: Correctly resolve the cidr?
-                let gatewayIP = iface.cidr.split(".").slice(0, 3).join(".") + ".1";
-                // TOOD: We try discovery on all gateways, so we can know for sure which one it is
-                //  (and maybe even port forward all gateway, if multiple respond?)
-                if (gatewayIP.startsWith("10.0.0") || gatewayIP.startsWith("10.0.1") || gatewayIP.startsWith("192.168.0")) {
-                    return { internalIP: iface.address, gatewayIP };
+    let looksLikeRouter = (ip: string) => ip.startsWith("10.0.0") || ip.startsWith("10.0.1") || ip.startsWith("192.168.0");
+
+    // On windows, run `ipconfig` and parse the output
+    // Otherwise, ifconfig
+    if (os.platform() === "win32") {
+        let output = require("child_process").execSync("ipconfig").toString();
+        let sections = output.split("\r\n\r\n");
+
+        for (let section of sections) {
+            if (section.includes("IPv4 Address")) {
+                let ipv4Match = section.match(/IPv4 Address[.\s]*: ([\d.]+)/);
+                let gatewayMatch = section.match(/Default Gateway[.\s]*: ([\d.]+)/);
+
+                if (ipv4Match && gatewayMatch && looksLikeRouter(gatewayMatch[1])) {
+                    return {
+                        internalIP: ipv4Match[1],
+                        gatewayIP: gatewayMatch[1]
+                    };
                 }
             }
         }
+    } 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+)/);
+
+        if (!gatewayMatch) {
+            // Fallback for macOS
+            routeOutput = require("child_process").execSync("netstat -nr").toString();
+            gatewayMatch = routeOutput.match(/default\s+(\d+\.\d+\.\d+\.\d+)/);
+        }
+
+        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 (ipMatch) {
+                return {
+                    internalIP: ipMatch[1],
+                    gatewayIP: gatewayMatch[1]
+                };
+            }
+        }
     }
+
     return undefined;
 }
 
@@ -117,7 +164,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\"";
@@ -134,7 +181,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.