socket-function 1.2.12 → 1.2.14

package/index.d.ts

@@ -1149,6 +1149,7 @@ declare module "socket-function/src/misc" {
     export declare function watchSlowPromise<T>(title: string, promise: Promise<T>, config?: {
         interval?: number;
     }): Promise<T>;
+    export declare function isIpDomain(nodeIdOrHost: string): boolean;
 
 }
 

package/package.json

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

package/src/CallFactory.ts

@@ -488,7 +488,7 @@ export async function createCallFactory(
             let alternates = await SocketFunction.GET_ALTERNATE_NODE_IDS(nodeId);
             if (alternates) {
                 for (let alternateNodeId of alternates) {
-                    let newWebSocket = createWebsocket(alternateNodeId, proposeProtocols(isNode() ? nodeId : undefined, { lz4: true }));
+                    let newWebSocket = createWebsocket(alternateNodeId, proposeProtocols(nodeId, { lz4: true }));
                     await initializeWebsocket(newWebSocket, true);
 
                     if (callFactory.isConnected) {
@@ -500,7 +500,7 @@ export async function createCallFactory(
             console.error("Error getting alternate node IDs", e);
         }
 
-        let newWebSocket = createWebsocket(nodeId, proposeProtocols(!SocketFunction.isClient() ? nodeId : undefined, { lz4: true }));
+        let newWebSocket = createWebsocket(nodeId, proposeProtocols(nodeId, { lz4: true }));
         await initializeWebsocket(newWebSocket);
 
         return newWebSocket;

package/src/misc.d.ts

@@ -98,3 +98,4 @@ export declare function errorToWarning<T>(promise: Promise<T>): void;
 export declare function watchSlowPromise<T>(title: string, promise: Promise<T>, config?: {
     interval?: number;
 }): Promise<T>;
+export declare function isIpDomain(nodeIdOrHost: string): boolean;

package/src/misc.ts

@@ -476,4 +476,21 @@ export function watchSlowPromise<T>(title: string, promise: Promise<T>, config?:
         }
     })();
     return promise;
+}
+
+// An ip domain (127-0-0-1.example.com, or a raw ip) is an address alias for a machine, not a node identity — a server's real nodeId will never equal it.
+export function isIpDomain(nodeIdOrHost: string): boolean {
+    let host = nodeIdOrHost.split(":")[0];
+    return isIpParts(host.split(".")[0].split("-")) || isIpParts(host.split("."));
+}
+function isIpParts(parts: string[]): boolean {
+    if (parts.length !== 4) return false;
+    for (let part of parts) {
+        if (!part || part.length > 3) return false;
+        for (let char of part) {
+            if (char < "0" || char > "9") return false;
+        }
+        if (parseInt(part) > 255) return false;
+    }
+    return true;
 }

package/src/protocolNegotiation.ts

@@ -5,6 +5,8 @@
 // the server returns no protocol and the handshake fails — which is exactly the
 // rejection semantics we want (indistinguishable from "node not reachable").
 
+import { isIpDomain } from "./misc";
+
 const PROTOCOL_VERSION = "v1";
 
 export type ConnectionFlags = {
@@ -70,6 +72,10 @@ export function decodeProtocol(hex: string): DecodedProtocol | undefined {
 // cert). The server then accepts the connection regardless of its identity,
 // while still negotiating flags.
 export function proposeProtocols(target: string | undefined, clientCapabilities: { lz4: boolean }): string[] {
+    // An ip domain is an address alias, not a node identity — the server's real nodeId can never match it, so connect as a wildcard client (exactly like browsers do).
+    if (target && isIpDomain(target)) {
+        target = undefined;
+    }
     let out: string[] = [];
     let clientLZ4Options = clientCapabilities.lz4 ? [true, false] : [false];
     let serverLZ4Options = [true, false];