socket-function 1.1.37 → 1.1.38

package/index.d.ts

@@ -642,6 +642,48 @@ declare module "socket-function/src/batching" {
 
 }
 
+declare module "socket-function/src/bits" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    /** Subtracts the smallest possible value from a number (a double). This makes it possible to convert an exclusive range end
+     *      to an inclusive range end, which is sometimes required (as in, < x is the same as <= minusEpsilon(x)).
+     */
+    export declare function minusEpsilon(value: number): number;
+    export declare function addEpsilons(value: number, count: number): number;
+    export declare function getHighUint32(num: number): number;
+    export declare function getLowUint32(num: number): number;
+    /** IMPORTANT! Beware of comparisons with 64 bit numbers. getFloat64_fromBytes(4294136438, 168) !== getFloat64_fromBytes(4294136438, 168).
+     *      USE is64BitEqual instead, OR, ensure the 2 highest bits are always 0.
+     */
+    export declare function setLowHighUint32(low: number, high: number): number;
+    /** Adds protection against NaN values, changing the result if it would be NaN. This is because NaN values will compare to be not equal even if they are equal in certain cases, and in other cases, they'll always be equal, even if their bits are not equal.
+        - This means this is not a reversible operation. However, in a lot of cases, that doesn't matter.
+    */
+    export declare function setLowHighUint32Safe(low: number, high: number): number;
+    export declare function xor64BitsSafe(a: number, b: number): number;
+    export declare function getShortNumber(buffer: Buffer): number;
+    export declare function getBufferInt(buffer: Buffer): number;
+    /** Returns a number between 0 (inclusive) and 1 (exclusive) */
+    export declare function getBufferFraction(buffer: Buffer): number;
+    export declare function getTimeUnique(): number;
+
+}
+
+declare module "socket-function/src/buffers" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    export type ArrayBufferViewTypes = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | Float64Array | Float32Array | Uint8ClampedArray;
+    export type BufferType = ArrayBuffer | SharedArrayBuffer | ArrayBufferViewTypes;
+    export declare function cloneBuffer(data: Buffer): Buffer;
+    export declare function asBuffer(data: BufferType): Buffer;
+    export declare function asFloat64(data: Buffer): Float64Array;
+    export declare function asFloat32(data: Buffer): Float32Array;
+    export declare function asUint32(data: Buffer): Uint32Array;
+    export declare function asInt32(data: Buffer): Int32Array;
+    export declare function asFloat64MaybeCopy(data: Buffer): Float64Array;
+
+}
+
 declare module "socket-function/src/caching" {
     import { AnyFunction, Args } from "socket-function/src/types";
     export declare function lazy<T>(factory: () => T): {
@@ -874,6 +916,10 @@ declare module "socket-function/src/forwardPort" {
 
 }
 
+declare module "socket-function/src/getUniqueTime" {
+
+}
+
 declare module "socket-function/src/https" {
     /// <reference types="node" />
     /// <reference types="node" />

package/package.json

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

package/src/bits.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/** Subtracts the smallest possible value from a number (a double). This makes it possible to convert an exclusive range end
+ *      to an inclusive range end, which is sometimes required (as in, < x is the same as <= minusEpsilon(x)).
+ */
+export declare function minusEpsilon(value: number): number;
+export declare function addEpsilons(value: number, count: number): number;
+export declare function getHighUint32(num: number): number;
+export declare function getLowUint32(num: number): number;
+/** IMPORTANT! Beware of comparisons with 64 bit numbers. getFloat64_fromBytes(4294136438, 168) !== getFloat64_fromBytes(4294136438, 168).
+ *      USE is64BitEqual instead, OR, ensure the 2 highest bits are always 0.
+ */
+export declare function setLowHighUint32(low: number, high: number): number;
+/** Adds protection against NaN values, changing the result if it would be NaN. This is because NaN values will compare to be not equal even if they are equal in certain cases, and in other cases, they'll always be equal, even if their bits are not equal.
+    - This means this is not a reversible operation. However, in a lot of cases, that doesn't matter.
+*/
+export declare function setLowHighUint32Safe(low: number, high: number): number;
+export declare function xor64BitsSafe(a: number, b: number): number;
+export declare function getShortNumber(buffer: Buffer): number;
+export declare function getBufferInt(buffer: Buffer): number;
+/** Returns a number between 0 (inclusive) and 1 (exclusive) */
+export declare function getBufferFraction(buffer: Buffer): number;
+export declare function getTimeUnique(): number;

package/src/bits.ts

@@ -0,0 +1,116 @@
+
+/** Subtracts the smallest possible value from a number (a double). This makes it possible to convert an exclusive range end
+ *      to an inclusive range end, which is sometimes required (as in, < x is the same as <= minusEpsilon(x)).
+ */
+export function minusEpsilon(value: number) {
+    let high = getHighUint32(value);
+    let low = getLowUint32(value);
+
+    if (low === 0) {
+        low = 2 ** 32 - 1;
+        high--;
+    } else {
+        low--;
+    }
+
+    return setLowHighUint32(low, high);
+}
+const maxUint32 = 2 ** 32 - 1;
+export function addEpsilons(value: number, count: number) {
+    let high = getHighUint32(value);
+    let low = getLowUint32(value);
+
+    low += count;
+    if (low < 0) {
+        low += maxUint32;
+        high++;
+    } else if (low > maxUint32) {
+        low -= maxUint32;
+        high--;
+    }
+
+    return setLowHighUint32(low, high);
+}
+
+let conversionBuffer = new Float64Array(1);
+let conversionUint8Buffer = new Uint8Array(conversionBuffer.buffer);
+let conversionUint32Buffer = new Uint32Array(conversionBuffer.buffer);
+export function getHighUint32(num: number): number {
+    conversionBuffer[0] = num;
+    return conversionUint32Buffer[1];
+}
+export function getLowUint32(num: number): number {
+    conversionBuffer[0] = num;
+    return conversionUint32Buffer[0];
+}
+
+/** IMPORTANT! Beware of comparisons with 64 bit numbers. getFloat64_fromBytes(4294136438, 168) !== getFloat64_fromBytes(4294136438, 168).
+ *      USE is64BitEqual instead, OR, ensure the 2 highest bits are always 0.
+ */
+export function setLowHighUint32(low: number, high: number): number {
+    conversionUint32Buffer[0] = low;
+    conversionUint32Buffer[1] = high;
+    return conversionBuffer[0];
+}
+
+/** Adds protection against NaN values, changing the result if it would be NaN. This is because NaN values will compare to be not equal even if they are equal in certain cases, and in other cases, they'll always be equal, even if their bits are not equal.
+    - This means this is not a reversible operation. However, in a lot of cases, that doesn't matter. 
+*/
+export function setLowHighUint32Safe(low: number, high: number): number {
+    conversionUint32Buffer[0] = low;
+    // Prevent NaN by not setting all the exponent bits to 1
+    conversionUint32Buffer[1] = high & 0xBFFFFFFF;
+    return conversionBuffer[0];
+}
+
+// NOTE: Not reversible, see setLowHighUint32Safe
+export function xor64BitsSafe(a: number, b: number): number {
+    let high = getHighUint32(a);
+    let low = getLowUint32(a);
+    let high2 = getHighUint32(b);
+    let low2 = getLowUint32(b);
+    return setLowHighUint32Safe(low ^ low2, high ^ high2);
+}
+
+// Gets bits that can be stored in a number. Specifically, the first 62 bits,
+//  as 64 bits will not compare correctly when treated as a double.
+export function getShortNumber(buffer: Buffer): number {
+    let high = buffer.readUInt32BE(0) & 0x3FFFFFFF;
+    let low = buffer.readUInt32BE(4);
+    return setLowHighUint32(low, high);
+}
+/* Returns a number between 0 and 2**48 */
+export function getBufferInt(buffer: Buffer): number {
+    let num = 0;
+    for (let i = 0; i < Math.min(buffer.length, 6); i++) {
+        num = num * 256 + buffer[i];
+    }
+    return num;
+}
+const intMax = 2 ** 48;
+/** Returns a number between 0 (inclusive) and 1 (exclusive) */
+export function getBufferFraction(buffer: Buffer): number {
+    let int = getBufferInt(buffer);
+    return int / intMax;
+}
+
+/*
+export function numberToBase64(num: number): string {
+    conversionBuffer[0] = num;
+    return Buffer.from(conversionBuffer.buffer).toString("base64");
+}
+export function numberFromBase64(base64: string) {
+    return new Float64Array(Buffer.from(base64, "base64"))[0];
+}
+*/
+
+
+let prevTime = 0;
+export function getTimeUnique() {
+    let time = Date.now();
+    if (time <= prevTime) {
+        time = addEpsilons(prevTime, 1);
+    }
+    prevTime = time;
+    return time;
+}

package/src/buffers.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export type ArrayBufferViewTypes = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | Float64Array | Float32Array | Uint8ClampedArray;
+export type BufferType = ArrayBuffer | SharedArrayBuffer | ArrayBufferViewTypes;
+export declare function cloneBuffer(data: Buffer): Buffer;
+export declare function asBuffer(data: BufferType): Buffer;
+export declare function asFloat64(data: Buffer): Float64Array;
+export declare function asFloat32(data: Buffer): Float32Array;
+export declare function asUint32(data: Buffer): Uint32Array;
+export declare function asInt32(data: Buffer): Int32Array;
+export declare function asFloat64MaybeCopy(data: Buffer): Float64Array;

package/src/buffers.ts

@@ -0,0 +1,69 @@
+import { canHaveChildren } from "socket-function/src/types";
+
+export type ArrayBufferViewTypes = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | BigUint64Array | BigInt64Array | Float64Array | Float32Array | Uint8ClampedArray;
+export type BufferType = ArrayBuffer | SharedArrayBuffer | ArrayBufferViewTypes;
+
+export function cloneBuffer(data: Buffer): Buffer {
+    let newBuffer = Buffer.alloc(data.length);
+    data.copy(newBuffer);
+    return newBuffer;
+}
+
+
+export function asBuffer(data: BufferType): Buffer {
+    if (!data) return data;
+    if (data instanceof Buffer) return data;
+    if (!canHaveChildren(data)) return data as any;
+    if (!("buffer" in data) || !("byteOffset" in data) || !("byteLength" in data)) {
+        return Buffer.from(data);
+    }
+    let result = Buffer.from((data as any).buffer, (data as any).byteOffset, (data as any).byteLength);
+    return result;
+}
+export function asFloat64(data: Buffer): Float64Array {
+    if (data.length % 8 !== 0) {
+        throw new Error(`Data is not 8 count aligned, received length of ${data.length}`);
+    }
+    if (data.byteOffset % 8 !== 0) {
+        throw new Error(`Data is not 8 byte aligned, received offset of ${data.byteOffset}`);
+    }
+    return new Float64Array(data.buffer, data.byteOffset, Math.floor(data.length / 8));
+}
+export function asFloat32(data: Buffer): Float32Array {
+    if (data.length % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received length of ${data.length}`);
+    }
+    if (data.byteOffset % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received offset of ${data.byteOffset}`);
+    }
+    return new Float32Array(data.buffer, data.byteOffset, Math.floor(data.length / 4));
+}
+export function asUint32(data: Buffer): Uint32Array {
+    if (data.length % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received length of ${data.length}`);
+    }
+    if (data.byteOffset % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received offset of ${data.byteOffset}`);
+    }
+    return new Uint32Array(data.buffer, data.byteOffset, Math.floor(data.length / 4));
+}
+export function asInt32(data: Buffer): Int32Array {
+    if (data.length % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received length of ${data.length}`);
+    }
+    if (data.byteOffset % 4 !== 0) {
+        throw new Error(`Data is not 4 byte aligned, received offset of ${data.byteOffset}`);
+    }
+    return new Int32Array(data.buffer, data.byteOffset, Math.floor(data.length / 4));
+}
+
+
+export function asFloat64MaybeCopy(data: Buffer) {
+    if (data.length % 8 !== 0) {
+        throw new Error(`Data is not 8 count aligned, received length of ${data.length}`);
+    }
+    if (data.byteOffset % 8 !== 0) {
+        return asFloat64(cloneBuffer(data));
+    }
+    return new Float64Array(data.buffer, data.byteOffset, Math.floor(data.length / 8));
+}

package/src/webSocketServer.ts

@@ -78,8 +78,14 @@ export async function startSocketServer(
             const proposed = Array.from(protocols);
             const chosen = chooseProtocol(proposed, ourNodeId, { lz4: true });
             if (!chosen) {
-                const proposedDecoded = proposed.map(p => decodeProtocol(p) ?? `<undecodable: ${p}>`);
-                console.log(`Rejecting handshake on ${ourNodeId}: none of the ${proposed.length} proposed protocols target us`, { ourNodeId, proposedDecoded });
+                const proposedDecoded = proposed.map(p => decodeProtocol(p));
+                let target = proposedDecoded[0]?.target;
+                let getMachineId = (x: string) => x.split(".").slice(-3).join(".");
+                if (target && getMachineId(target) === getMachineId(ourNodeId)) {
+                    console.log(`Rejecting handshake from old thread, ${target} !== ${ourNodeId}`);
+                } else {
+                    console.log(`Rejecting handshake on ${ourNodeId}: none of the ${proposed.length} proposed protocols target us`, { ourNodeId, proposedDecoded });
+                }
                 return false;
             }
             return chosen;