feat(socket-utils): implement socket cleanup utilities and enhance socket handling in forwarding handlers

ts/forwarding/handlers/https-terminate-to-http-handler.ts

@@ -2,6 +2,7 @@ import * as plugins from '../../plugins.js';
 import { ForwardingHandler } from './base-handler.js';
 import type { IForwardConfig } from '../config/forwarding-types.js';
 import { ForwardingHandlerEvents } from '../config/forwarding-types.js';
+import { createSocketCleanupHandler, setupSocketHandlers } from '../../core/utils/socket-utils.js';
 
 /**
  * Handler for HTTPS termination with HTTP backend
@@ -95,62 +96,24 @@ export class HttpsTerminateToHttpHandler extends ForwardingHandler {
       tls: true
     });
     
-    // Handle TLS errors
-    tlsSocket.on('error', (error) => {
-      this.emit(ForwardingHandlerEvents.ERROR, {
-        remoteAddress,
-        error: `TLS error: ${error.message}`
-      });
-      
-      if (!tlsSocket.destroyed) {
-        tlsSocket.destroy();
-      }
-    });
-    
-    // The TLS socket will now emit HTTP traffic that can be processed
-    // In a real implementation, we would create an HTTP parser and handle
-    // the requests here, but for simplicity, we'll just log the data
-    
+    // Variables to track connections
+    let backendSocket: plugins.net.Socket | null = null;
     let dataBuffer = Buffer.alloc(0);
+    let connectionEstablished = false;
     
-    tlsSocket.on('data', (data) => {
-      // Append to buffer
-      dataBuffer = Buffer.concat([dataBuffer, data]);
-      
-      // Very basic HTTP parsing - in a real implementation, use http-parser
-      if (dataBuffer.includes(Buffer.from('\r\n\r\n'))) {
-        const target = this.getTargetFromConfig();
-        
-        // Simple example: forward the data to an HTTP server
-        const socket = plugins.net.connect(target.port, target.host, () => {
-          socket.write(dataBuffer);
-          dataBuffer = Buffer.alloc(0);
-          
-          // Set up bidirectional data flow
-          tlsSocket.pipe(socket);
-          socket.pipe(tlsSocket);
-        });
-        
-        socket.on('error', (error) => {
-          this.emit(ForwardingHandlerEvents.ERROR, {
-            remoteAddress,
-            error: `Target connection error: ${error.message}`
-          });
-          
-          if (!tlsSocket.destroyed) {
-            tlsSocket.destroy();
-          }
-        });
-      }
-    });
-    
-    // Handle close
-    tlsSocket.on('close', () => {
+    // Create cleanup handler for all sockets
+    const handleClose = createSocketCleanupHandler(tlsSocket, backendSocket, (reason) => {
       this.emit(ForwardingHandlerEvents.DISCONNECTED, {
-        remoteAddress
+        remoteAddress,
+        reason
       });
+      dataBuffer = Buffer.alloc(0);
+      connectionEstablished = false;
     });
     
+    // Set up error handling with our cleanup utility
+    setupSocketHandlers(tlsSocket, handleClose, 'tls');
+    
     // Set timeout
     const timeout = this.getTimeout();
     tlsSocket.setTimeout(timeout);
@@ -160,9 +123,58 @@ export class HttpsTerminateToHttpHandler extends ForwardingHandler {
         remoteAddress,
         error: 'TLS connection timeout'
       });
+      handleClose('timeout');
+    });
+    
+    // Handle TLS data
+    tlsSocket.on('data', (data) => {
+      // If backend connection already established, just forward the data
+      if (connectionEstablished && backendSocket && !backendSocket.destroyed) {
+        backendSocket.write(data);
+        return;
+      }
       
-      if (!tlsSocket.destroyed) {
-        tlsSocket.destroy();
+      // Append to buffer
+      dataBuffer = Buffer.concat([dataBuffer, data]);
+      
+      // Very basic HTTP parsing - in a real implementation, use http-parser
+      if (dataBuffer.includes(Buffer.from('\r\n\r\n')) && !connectionEstablished) {
+        const target = this.getTargetFromConfig();
+        
+        // Create backend connection
+        backendSocket = plugins.net.connect(target.port, target.host, () => {
+          connectionEstablished = true;
+          
+          // Send buffered data
+          if (dataBuffer.length > 0) {
+            backendSocket!.write(dataBuffer);
+            dataBuffer = Buffer.alloc(0);
+          }
+          
+          // Set up bidirectional data flow
+          tlsSocket.pipe(backendSocket!);
+          backendSocket!.pipe(tlsSocket);
+        });
+        
+        // Update the cleanup handler with the backend socket
+        const newHandleClose = createSocketCleanupHandler(tlsSocket, backendSocket, (reason) => {
+          this.emit(ForwardingHandlerEvents.DISCONNECTED, {
+            remoteAddress,
+            reason
+          });
+          dataBuffer = Buffer.alloc(0);
+          connectionEstablished = false;
+        });
+        
+        // Set up handlers for backend socket
+        setupSocketHandlers(backendSocket, newHandleClose, 'backend');
+        
+        backendSocket.on('error', (error) => {
+          this.emit(ForwardingHandlerEvents.ERROR, {
+            remoteAddress,
+            error: `Target connection error: ${error.message}`
+          });
+        });
       }
     });
   }