socket-function 0.23.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.23.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,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,8 +9,10 @@ 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");
@@ -28,6 +31,7 @@ export async function forwardPort(config: {
                 controlPort,
                 controlPath: controlURL,
                 internalIP,
+                duration,
             });
             console.log(`Port mapping created on ${gatewayIP}:${externalPort} -> ${internalIP}:${internalPort}`);
             return;
@@ -160,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\"";
@@ -177,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.