socket-function 0.56.0 → 0.58.0

package/package.json

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

package/src/callHTTPHandler.ts

@@ -58,6 +58,8 @@ export async function httpCallHandler(request: http.IncomingMessage, response: h
     try {
         // Always set x-frame-options, to prevent iframe embedding click hijacking
         response.setHeader("X-Frame-Options", "SAMEORIGIN");
+        // Don't keep alive, to prevent issues with zombie sockets.
+        response.setHeader("Connection", "close");
 
         let urlBase = request.url;
         if (!urlBase) {

package/src/webSocketServer.ts

@@ -188,54 +188,56 @@ export async function startSocketServer(
     });
 
     let realServer = net.createServer(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;
-            }
+        mainHTTPSServer.emit("connection", socket);
 
-            // 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}`);
-        });
+        // //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;
+        //     }
+
+        //     // 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}`);
+        // });
     });