socket-function 0.7.7 → 0.7.8

package/SocketFunction.ts

@@ -1,6 +1,6 @@
 import { SocketExposedInterface, CallContextType, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, NetworkLocation, CallerContext, SocketExposedInterfaceClass, CallType } from "./SocketFunctionTypes";
 import { exposeClass, registerClass, registerGlobalClientHook, registerGlobalHook, runClientHooks } from "./src/callManager";
-import { SocketServerConfig, startSocketServer } from "./src/socketServer";
+import { SocketServerConfig, startSocketServer } from "./src/webSocketServer";
 import { getCallFactoryNodeId, getCreateCallFactoryLocation, getNetworkLocationHash } from "./src/nodeCache";
 import { getCallProxy } from "./src/nodeProxy";
 import { Args } from "./src/types";
@@ -113,22 +113,20 @@ export class SocketFunction {
     }
 
     public static async connect(location: NetworkLocation | { address: string; port: number }): Promise<string> {
-        if (!("localPort" in location)) {
+        if (!("listeningPorts" in location)) {
             location = {
                 address: location.address,
-                listeningPorts: [location.port],
-                localPort: 0,
+                listeningPorts: [location.port]
             };
         }
         return await getCreateCallFactoryLocation(location);
     }
 
     public static connectSync(location: NetworkLocation | { address: string; port: number }): string {
-        if (!("localPort" in location)) {
+        if (!("listeningPorts" in location)) {
             location = {
                 address: location.address,
-                listeningPorts: [location.port],
-                localPort: 0,
+                listeningPorts: [location.port]
             };
         }
         let tempNodeId = "syncTempNodeId_" + getNetworkLocationHash(location);

package/SocketFunctionTypes.ts

@@ -65,17 +65,16 @@ export type CallerContext = {
     //  them call functions directly using nodeId. Instead pass location, and have them use connect.
     //  - nodeId SHOULD be used to identify users though, as it cannot be impersonated
     nodeId: string;
+    fromPort: number;
     location: NetworkLocation;
+    // The location of the server. It helps if it is told, due to the fact that one server
+    //  can serve multiple domains.
+    serverLocation: NetworkLocation;
 };
 
 // IMPORTANT! Nodes at the same network location may vary, so you cannot store NetworkLocation
 //  in a list of allowed users, otherwise they can be impersonated!
 export interface NetworkLocation {
     address: string;
-    /** localPort is the port the connection was made from, which is often uninteresting.
-     *      It is useful internally, to help reduce collisions when a process restarts and
-     *      reconnects (as it may have the same source address, but the localPort will likely change).
-     */
-    localPort: number;
     listeningPorts: number[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.7.7",
+	"version": "0.7.8",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {
@@ -13,7 +13,7 @@
 		"ws": "^8.8.0"
 	},
 	"scripts": {
-		"test": "yarn typenode ./nodeAuthentication.ts --server",
+		"test": "yarn typenode ./test/server.ts",
 		"type": "yarn tsc --noEmit"
 	}
 }

package/src/CallFactory.ts

@@ -1,5 +1,5 @@
 import { CallerContext, CallType, NetworkLocation } from "../SocketFunctionTypes";
-import type * as ws from "ws";
+import * as ws from "ws";
 import type * as net from "net";
 import { performLocalCall } from "./callManager";
 import { convertErrorStackToError, isNode } from "./misc";
@@ -34,20 +34,24 @@ export interface CallFactory {
 export async function callFactoryFromLocation(
     location: NetworkLocation
 ): Promise<CallFactory> {
-    if (location.localPort !== 0) {
-        throw new Error(`Expected localPort to be 0, but it was ${location.localPort}`);
-    }
-
     let listeningPort = location.listeningPorts[0];
     if (typeof listeningPort !== "number") {
         throw new Error(`Expected listeningPorts to be provided, but it was empty`);
     }
 
-    return await createCallFactory(undefined, location);
+    // Because we are the client, we don't get to know our NetworkLocation (but we shouldn't
+    //  need to anyway).
+    let serverLocation: NetworkLocation = {
+        address: "localhost",
+        listeningPorts: [],
+    };
+
+    return await createCallFactory(undefined, location, serverLocation);
 }
 
 export async function callFactoryFromWS(
     webSocket: ws.WebSocket & { nodeId?: string },
+    serverLocation: NetworkLocation,
 ): Promise<CallFactory> {
     let socket = getTLSSocket(webSocket);
     let remoteAddress = socket.remoteAddress;
@@ -63,11 +67,10 @@ export async function callFactoryFromWS(
     //  their process is dead, and is going to stay dead.
     let location: NetworkLocation = {
         address: remoteAddress,
-        localPort: remotePort,
         listeningPorts: [],
     };
 
-    return await createCallFactory(webSocket, location);
+    return await createCallFactory(webSocket, location, serverLocation);
 }
 
 export interface SenderInterface {
@@ -84,11 +87,20 @@ export interface SenderInterface {
 async function createCallFactory(
     webSocketBase: SenderInterface | undefined,
     location: NetworkLocation,
+    serverLocation: NetworkLocation,
 ): Promise<CallFactory> {
 
     let closedForever = false;
 
-    let niceConnectionName = `${location.address}:${location.localPort}`;
+    let fromPort = 0;
+    if (webSocketBase && webSocketBase instanceof ws.WebSocket) {
+        let socket = getTLSSocket(webSocketBase);
+        fromPort = socket.remotePort ?? fromPort;
+    }
+    let niceConnectionName = `${location.address}:${location.listeningPorts.join("|")}`;
+    if (fromPort && location.listeningPorts.length === 0) {
+        niceConnectionName += `(${fromPort})`;
+    }
 
     let retriesEnabled = location.listeningPorts.length === 0;
 
@@ -110,7 +122,7 @@ async function createCallFactory(
     let nextSeqNum = Math.random();
 
     const pendingNodeId = "PENDING";
-    let callerContext: CallerContext = { location, nodeId: pendingNodeId };
+    let callerContext: CallerContext = { location, nodeId: pendingNodeId, serverLocation, fromPort };
     let webSocket!: SenderInterface;
     if (!webSocketBase) {
         await tryToReconnect();
@@ -176,7 +188,7 @@ async function createCallFactory(
                         call.callback({
                             isReturn: true,
                             result: undefined,
-                            error: `Connection lost to ${location.address}:${location.localPort}`,
+                            error: `Connection lost to ${niceConnectionName}`,
                             seqNum: call.call.seqNum,
                         });
                     }
@@ -317,7 +329,7 @@ async function createCallFactory(
         location,
         async performCall(call: CallType) {
             if (closedForever) {
-                throw new Error(`Connection lost to ${location.address}:${location.localPort}`);
+                throw new Error(`Connection lost to ${niceConnectionName}`);
             }
 
             let seqNum = nextSeqNum++;

package/src/callHTTPHandler.ts

@@ -2,13 +2,13 @@ import https from "https";
 import http from "http";
 import net from "net";
 import tls from "tls";
-import { CallerContext, CallType } from "../SocketFunctionTypes";
+import { CallerContext, CallType, NetworkLocation } from "../SocketFunctionTypes";
 import { performLocalCall } from "./callManager";
 import { getNodeIdRaw } from "./nodeAuthentication";
 import debugbreak from "debugbreak";
 import * as cookie from "cookie";
 
-const nodeIdCookie = "node-id3";
+const nodeIdCookie = "node-id4";
 
 let defaultHTTPCall: CallType | undefined;
 
@@ -24,6 +24,23 @@ export function getNodeIdFromRequest(request: http.IncomingMessage): string | un
     if (!value.startsWith(cookieNodeIdPrefix)) return undefined;
     return value;
 }
+export function getServerLocationFromRequest(request: http.IncomingMessage): NetworkLocation {
+    let host = request.headers.host;
+    if (!host) {
+        throw new Error(`Missing host in request headers`);
+    }
+    let port = 443;
+    if (host.includes(":")) {
+        port = +host.split(":")[1];
+        host = host.split(":")[0];
+    }
+    return {
+        address: host,
+        // This is OUR location, so whatever they connected to us... we must be listening on!
+        //  (and the localPort doesn't matter in this case)
+        listeningPorts: [port],
+    };
+}
 
 export async function httpCallHandler(request: http.IncomingMessage, response: http.ServerResponse) {
     try {
@@ -85,11 +102,12 @@ export async function httpCallHandler(request: http.IncomingMessage, response: h
 
         let caller: CallerContext = {
             nodeId,
+            fromPort: port,
             location: {
                 address,
-                localPort: port,
                 listeningPorts: [],
-            }
+            },
+            serverLocation: getServerLocationFromRequest(request),
         };
 
         let classGuid = urlObj.searchParams.get("classGuid");

package/src/nodeAuthentication.ts

@@ -67,7 +67,7 @@ export const getNodeId = cacheWeak(function (webSocket: SenderInterface | ws.Web
         if (webSocket.nodeId) {
             return webSocket.nodeId;
         }
-        throw new Error(`Peer certificate must use an RSA key or EC key (which should have a .pubkey property)`);
+        throw new Error(`Missing nodeId. If it is from the browser, this likely means your websocket and HTTP request are using different domains (so the cookies are lost). If it is from NodeJs peer certificate must use an RSA key or EC key (which should have a .pubkey property)`);
     }
     return nodeId;
 });

package/src/nodeCache.ts

@@ -19,7 +19,7 @@ const nodeCache = new Map<string, {
 const locationLookup = new Map<string, MaybePromise<string>>();
 
 export function getNetworkLocationHash(location: NetworkLocation): string {
-    return location.address + ":" + location.localPort + "=" + location.listeningPorts.join("|");
+    return location.address + ":" + location.listeningPorts.join("|");
 }
 
 // NOTE: For client connections, at which point we have the nodeId, location and callFactory.

package/src/{socketServer.ts → webSocketServer.ts}

@@ -10,7 +10,7 @@ import { registerNodeClient } from "./nodeCache";
 import { getCertKeyPair, getNodeId, getNodeIdRaw } from "./nodeAuthentication";
 import debugbreak from "debugbreak";
 import { cache } from "./caching";
-import { getNodeIdFromRequest, httpCallHandler } from "./callHTTPHandler";
+import { getNodeIdFromRequest, getServerLocationFromRequest, httpCallHandler } from "./callHTTPHandler";
 
 // TODO: Support conditional peer certificate requests, as it the certificate prompt
 //  seems suspicious in the browser (the user can just click cancel though).
@@ -59,7 +59,7 @@ export async function startSocketServer(
             let requestNodeId = getNodeIdFromRequest(request);
             Object.assign(ws, { nodeId: requestNodeId });
 
-            let clientCallFactory = await callFactoryFromWS(ws);
+            let clientCallFactory = await callFactoryFromWS(ws, getServerLocationFromRequest(request));
             registerNodeClient(clientCallFactory);
         });
     });

package/test/client.ts

@@ -7,6 +7,7 @@ import { setFlag } from "../require/compileFlags";
 import { SocketFunction } from "../SocketFunction";
 import { Test } from "./shared";
 
+import "../require/CSSShim";
 import "./client.css";
 import { isNode } from "../src/misc";
 
@@ -28,7 +29,7 @@ async function main() {
 
     const port = 2542;
 
-    let serverId = await SocketFunction.connect({ port, address: "letx.ca" });
+    let serverId = await SocketFunction.connect({ port, address: "localhost" });
     let test = await Test.nodes[serverId].add(1, 2);
     console.log(`${test}=${1 + 2}`);