socket-function 0.58.0 → 0.60.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.58.0",
+	"version": "0.60.0",
 	"main": "index.js",
 	"license": "MIT",
 	"note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/src/webSocketServer.ts

@@ -188,56 +188,56 @@ export async function startSocketServer(
     });
 
     let realServer = net.createServer(socket => {
-        mainHTTPSServer.emit("connection", socket);
-
-        // //console.log("Received TCP connection from " + socket.remoteAddress);
-        // const debug = socket.remoteAddress + ":" + socket.remotePort;
-        // function handleTLSHello(buffer: Buffer, packetCount: number): void | "more" {
-        //     if (!SocketFunction.silent) {
-        //         console.log(`Received TCP header packet from ${debug}, have ${buffer.length} bytes so far, ${packetCount} packets`);
-        //     }
-        //     // All HTTPS requests start with 22, and no HTTP requests start with 22,
-        //     //  so we just need to read the first byte.
-        //     let server: https.Server | http.Server;
-        //     if (buffer[0] !== 22) {
-        //         server = httpServer;
-        //     } else {
-        //         let data = parseTLSHello(buffer);
-        //         if (data.missingBytes > 0) {
-        //             return "more";
-        //         }
-        //         let sni = data.extensions.filter(x => x.type === SNIType).flatMap(x => parseSNIExtension(x.data))[0];
-        //         if (!SocketFunction.silent) {
-        //             console.log(`Received TCP connection with SNI ${JSON.stringify(sni)}`);
-        //         }
-        //         if (!sni) {
-        //             console.warn(`No SNI found in TLS hello from ${debug}, using main server. Packets ${packetCount}`);
-        //             console.log(buffer.toString("base64"));
-        //         }
-        //         server = sniServers.get(sni) || mainHTTPSServer;
-        //     }
+        const debug = socket.remoteAddress + ":" + socket.remotePort;
+        if (!SocketFunction.silent) {
+            console.log(`Received TCP connection from ${debug}`);
+        }
+        function handleTLSHello(buffer: Buffer, packetCount: number): void | "more" {
+            if (!SocketFunction.silent) {
+                console.log(`Received TCP header packet from ${debug}, have ${buffer.length} bytes so far, ${packetCount} packets`);
+            }
+            // All HTTPS requests start with 22, and no HTTP requests start with 22,
+            //  so we just need to read the first byte.
+            let server: https.Server | http.Server;
+            if (buffer[0] !== 22) {
+                server = httpServer;
+            } else {
+                let data = parseTLSHello(buffer);
+                if (data.missingBytes > 0) {
+                    return "more";
+                }
+                let sni = data.extensions.filter(x => x.type === SNIType).flatMap(x => parseSNIExtension(x.data))[0];
+                if (!SocketFunction.silent) {
+                    console.log(`Received TCP connection with SNI ${JSON.stringify(sni)}`);
+                }
+                if (!sni) {
+                    console.warn(`No SNI found in TLS hello from ${debug}, using main server. Packets ${packetCount}`);
+                    console.log(buffer.toString("base64"));
+                }
+                server = sniServers.get(sni) || mainHTTPSServer;
+            }
 
-        //     // 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);
-        // }
-        // let buffers: Buffer[] = [];
-        // function getNextData() {
-        //     // 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
-        //     //  (100s of MB/s, easily, even on a terrible machine).
-        //     socket.once("data", buffer => {
-        //         buffers.push(buffer);
-        //         let result = handleTLSHello(Buffer.concat(buffers), buffers.length);
-        //         if (result === "more") {
-        //             getNextData();
-        //         }
-        //     });
-        // }
-        // getNextData();
-        // socket.on("error", (e) => {
-        //     console.error(`Socket error for ${debug}, ${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);
+        }
+        let buffers: Buffer[] = [];
+        function getNextData() {
+            // 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
+            //  (100s of MB/s, easily, even on a terrible machine).
+            socket.once("data", buffer => {
+                buffers.push(buffer);
+                let result = handleTLSHello(Buffer.concat(buffers), buffers.length);
+                if (result === "more") {
+                    getNextData();
+                }
+            });
+        }
+        getNextData();
+        socket.on("error", (e) => {
+            console.error(`Socket error for ${debug}, ${e.stack}`);
+        });
     });