socket-function 0.7.13 → 0.7.16

package/package.json

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

package/src/CallFactory.ts

@@ -283,10 +283,10 @@ async function createCallFactory(
 
     async function onMessage(message: ws.RawData | ws.MessageEvent | string) {
         try {
+            if (typeof message === "object" && "data" in message) {
+                message = message.data;
+            }
             if (!isNode()) {
-                if (typeof message === "object" && "data" in message) {
-                    message = message.data;
-                }
                 if (message instanceof Blob) {
                     message = Buffer.from(await message.arrayBuffer());
                 }

package/src/webSocketServer.ts

@@ -52,6 +52,16 @@ export async function startSocketServer(
         noServer: true,
     });
     httpsServer.on("upgrade", (request, socket, upgradeHead) => {
+        try {
+            let host = new URL("ws://" + request.headers["host"]).hostname;
+            let origin = new URL(request.headers["origin"] ?? "").hostname;
+            console.log({ host, origin });
+            if (host !== origin) {
+                throw new Error(`Invalid cross thread request, ${JSON.stringify(host)} !== ${JSON.stringify(origin)}`);
+            }
+        } catch (e) {
+            console.error(e);
+        }
         webSocketServer.handleUpgrade(request, socket, upgradeHead, async (ws) => {
             // NOTE: For the browser, the request will likely have a nodeId, from making an HTTP request.
             //  We would prefer peer certificates, so this isn't the default (in getNodeId), but it will
@@ -73,20 +83,6 @@ export async function startSocketServer(
         res.end();
     });
 
-    httpServer.listen(0, "127.0.0.1");
-    httpsServer.listen(0, "127.0.0.1");
-
-    // TODO: We should really add error handling here, but... we should always be able to listen
-    //  on ANY port on localhost, as why couldn't we?
-    let httpServerReady = new Promise(resolve => httpServer.once("listening", resolve));
-    let httpsServerReady = new Promise(resolve => httpsServer.once("listening", resolve));
-    await httpServerReady;
-    await httpsServerReady;
-
-    let httpAddress = httpServer.address() as net.AddressInfo;
-    let httpsAddress = httpsServer.address() as net.AddressInfo;
-
-
     let realServer = net.createServer(socket => {
         // NOTE: ONCE is used, so we only look at the first buffer, and then after that
         //  we pipe. This should be very efficient, as pipe has insane throughput
@@ -94,21 +90,11 @@ export async function startSocketServer(
         socket.once("data", buffer => {
             // All HTTPS requests start with 22, and no HTTP requests start with 22,
             //  so we just need to read the first byte.
-            let byte = buffer[0];
-            let isHTTPS = byte === 22;
-            let address = httpAddress;
-            if (isHTTPS) {
-                address = httpsAddress;
-            }
-            let baseSocket = net.connect(address.port);
-
-            baseSocket.write(buffer);
-            socket.pipe(baseSocket);
-            baseSocket.pipe(socket);
+            let server = buffer[0] === 22 ? httpsServer : httpServer;
 
-            baseSocket.on("error", (e) => {
-                console.error(`Base socket error, ${e.stack}`);
-            });
+            // NOTE: Messages aren't dequeued until the current handler finishes, so we don't need to pause the socket or anything.
+            server.emit("connection", socket);
+            socket.unshift(buffer);
         });
         socket.on("error", (e) => {
             console.error(`Exposed socket error, ${e.stack}`);