update

test/test.connection-stability.ts

@@ -0,0 +1,286 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as smartproxy from '../ts/index.js';
+import * as net from 'net';
+import * as crypto from 'crypto';
+
+tap.test('Connection Stability - Fragment Cleanup', async () => {
+  // Create a simple TCP server
+  const server = net.createServer();
+  await new Promise<void>((resolve) => {
+    server.listen(0, '127.0.0.1', () => resolve());
+  });
+  const serverPort = (server.address() as net.AddressInfo).port;
+
+  // Configure a route
+  const routes: smartproxy.IRouteConfig[] = [{
+    match: {
+      ports: 9000,
+      domains: '*'
+    },
+    action: {
+      type: 'forward',
+      target: {
+        host: '127.0.0.1',
+        port: serverPort
+      }
+    }
+  }];
+  
+  // Create SmartProxy instance with routes
+  const proxy = new smartproxy.SmartProxy({ 
+    keepAliveTimeoutMs: 5000,
+    routes 
+  });
+  
+  await proxy.start();
+
+  // Test 1: Send fragmented TLS hello
+  const tlsHello = Buffer.concat([
+    Buffer.from([0x16, 0x03, 0x03]), // TLS handshake, version 1.2
+    Buffer.from([0x00, 0x50]), // Length: 80 bytes
+    Buffer.from([0x01]), // ClientHello
+    Buffer.from([0x00, 0x00, 0x4c]), // Handshake length
+    Buffer.from([0x03, 0x03]), // TLS 1.2
+    crypto.randomBytes(32), // Random
+    Buffer.from([0x00]), // Session ID length
+    Buffer.from([0x00, 0x04]), // Cipher suites length
+    Buffer.from([0xc0, 0x2f, 0xc0, 0x30]), // Cipher suites
+    Buffer.from([0x01, 0x00]), // Compression methods
+    Buffer.from([0x00, 0x1f]), // Extensions length
+    // SNI extension
+    Buffer.from([0x00, 0x00]), // Server name extension
+    Buffer.from([0x00, 0x1b]), // Extension length
+    Buffer.from([0x00, 0x19]), // Server name list length
+    Buffer.from([0x00]), // Host name type
+    Buffer.from([0x00, 0x16]), // Name length
+    Buffer.from('test.example.com') // Server name
+  ]);
+
+  // Function to check fragment manager size
+  const getFragmentCount = () => {
+    // Access the fragment manager through the singleton
+    const detector = (smartproxy.detection.ProtocolDetector as any).getInstance();
+    const tlsFragments = detector.fragmentManager.getHandler('tls');
+    const httpFragments = detector.fragmentManager.getHandler('http');
+    return tlsFragments.size + httpFragments.size;
+  };
+
+  // Test fragmented connections
+  const connections: net.Socket[] = [];
+  
+  // Create multiple fragmented connections
+  for (let i = 0; i < 5; i++) {
+    const client = new net.Socket();
+    connections.push(client);
+    
+    await new Promise<void>((resolve, reject) => {
+      client.connect(9000, '127.0.0.1', () => {
+        // Send first fragment
+        client.write(tlsHello.subarray(0, 20));
+        resolve();
+      });
+      client.on('error', reject);
+    });
+  }
+
+  // Give time for fragments to accumulate
+  await new Promise(resolve => setTimeout(resolve, 100));
+
+  // Check that fragments are being tracked
+  const fragmentCount = getFragmentCount();
+  expect(fragmentCount).toBeGreaterThan(0);
+
+  // Send remaining fragments and close connections
+  for (const client of connections) {
+    client.write(tlsHello.subarray(20));
+    client.end();
+  }
+
+  // Wait for connections to close
+  await new Promise(resolve => setTimeout(resolve, 500));
+
+  // Check that fragments are cleaned up
+  const finalFragmentCount = getFragmentCount();
+  expect(finalFragmentCount).toEqual(0);
+
+  // Cleanup
+  await proxy.stop();
+  server.close();
+});
+
+tap.test('Connection Stability - Memory Leak Prevention', async () => {
+  // Create a simple echo server
+  const server = net.createServer((socket) => {
+    socket.pipe(socket);
+  });
+  
+  await new Promise<void>((resolve) => {
+    server.listen(0, '127.0.0.1', () => resolve());
+  });
+  const serverPort = (server.address() as net.AddressInfo).port;
+
+  // Configure a route
+  const routes: smartproxy.IRouteConfig[] = [{
+    match: {
+      ports: 9001,
+      domains: '*'
+    },
+    action: {
+      type: 'forward',
+      target: {
+        host: '127.0.0.1',
+        port: serverPort
+      }
+    }
+  }];
+  
+  // Create SmartProxy instance with routes
+  const proxy = new smartproxy.SmartProxy({ 
+    keepAliveTimeoutMs: 5000,
+    routes 
+  });
+  
+  await proxy.start();
+
+  // Function to get active connection count
+  const getConnectionCount = () => {
+    const connectionManager = (proxy as any).connectionManager;
+    return connectionManager.getActiveConnectionCount();
+  };
+
+  // Create many short-lived connections
+  const connectionPromises: Promise<void>[] = [];
+  
+  for (let i = 0; i < 20; i++) {
+    const promise = new Promise<void>((resolve, reject) => {
+      const client = new net.Socket();
+      
+      client.connect(9001, '127.0.0.1', () => {
+        // Send some data
+        client.write('Hello World');
+        
+        // Close after a short delay
+        setTimeout(() => {
+          client.end();
+        }, 50);
+      });
+      
+      client.on('close', () => resolve());
+      client.on('error', reject);
+    });
+    
+    connectionPromises.push(promise);
+    
+    // Stagger connection creation
+    await new Promise(resolve => setTimeout(resolve, 10));
+  }
+
+  // Wait for all connections to complete
+  await Promise.all(connectionPromises);
+
+  // Give time for cleanup
+  await new Promise(resolve => setTimeout(resolve, 1000));
+
+  // Check that all connections are cleaned up
+  const finalConnectionCount = getConnectionCount();
+  expect(finalConnectionCount).toEqual(0);
+
+  // Check fragment cleanup
+  const fragmentCount = (() => {
+    const detector = (smartproxy.detection.ProtocolDetector as any).getInstance();
+    const tlsFragments = detector.fragmentManager.getHandler('tls');
+    const httpFragments = detector.fragmentManager.getHandler('http');
+    return tlsFragments.size + httpFragments.size;
+  })();
+  
+  expect(fragmentCount).toEqual(0);
+
+  // Cleanup
+  await proxy.stop();
+  server.close();
+});
+
+tap.test('Connection Stability - Rapid Connect/Disconnect', async () => {
+  // Create a server that immediately closes connections
+  const server = net.createServer((socket) => {
+    socket.end();
+  });
+  
+  await new Promise<void>((resolve) => {
+    server.listen(0, '127.0.0.1', () => resolve());
+  });
+  const serverPort = (server.address() as net.AddressInfo).port;
+
+  // Configure a route
+  const routes: smartproxy.IRouteConfig[] = [{
+    match: {
+      ports: 9002,
+      domains: '*'
+    },
+    action: {
+      type: 'forward',
+      target: {
+        host: '127.0.0.1',
+        port: serverPort
+      }
+    }
+  }];
+  
+  // Create SmartProxy instance with routes
+  const proxy = new smartproxy.SmartProxy({ 
+    keepAliveTimeoutMs: 5000,
+    routes 
+  });
+  
+  await proxy.start();
+
+  let errors = 0;
+  const connections: Promise<void>[] = [];
+
+  // Create many rapid connections
+  for (let i = 0; i < 50; i++) {
+    const promise = new Promise<void>((resolve) => {
+      const client = new net.Socket();
+      
+      client.on('error', () => {
+        errors++;
+        resolve();
+      });
+      
+      client.on('close', () => {
+        resolve();
+      });
+      
+      client.connect(9002, '127.0.0.1');
+    });
+    
+    connections.push(promise);
+  }
+
+  // Wait for all to complete
+  await Promise.all(connections);
+
+  // Give time for cleanup
+  await new Promise(resolve => setTimeout(resolve, 500));
+
+  // Check that connections are cleaned up despite rapid connect/disconnect
+  const connectionManager = (proxy as any).connectionManager;
+  const finalConnectionCount = connectionManager.getActiveConnectionCount();
+  expect(finalConnectionCount).toEqual(0);
+
+  // Check fragment cleanup
+  const fragmentCount = (() => {
+    const detector = (smartproxy.detection.ProtocolDetector as any).getInstance();
+    const tlsFragments = detector.fragmentManager.getHandler('tls');
+    const httpFragments = detector.fragmentManager.getHandler('http');
+    return tlsFragments.size + httpFragments.size;
+  })();
+  
+  expect(fragmentCount).toEqual(0);
+
+  // Cleanup
+  await proxy.stop();
+  server.close();
+});
+
+tap.start();

test/test.detection.ts

@@ -80,28 +80,38 @@ tap.test('Protocol Detection - Unknown Protocol', async () => {
 });
 
 tap.test('Protocol Detection - Fragmented HTTP', async () => {
-  const connectionId = 'test-connection-1';
+  // Create connection context
+  const context = smartproxy.detection.ProtocolDetector.createConnectionContext({
+    sourceIp: '127.0.0.1',
+    sourcePort: 12345,
+    destIp: '127.0.0.1',
+    destPort: 80,
+    socketId: 'test-connection-1'
+  });
   
   // First fragment
   const fragment1 = Buffer.from('GET /test HT');
-  let result = await smartproxy.detection.ProtocolDetector.detectWithConnectionTracking(
+  let result = await smartproxy.detection.ProtocolDetector.detectWithContext(
     fragment1,
-    connectionId
+    context
   );
   expect(result.protocol).toEqual('http');
   expect(result.isComplete).toEqual(false);
   
   // Second fragment
   const fragment2 = Buffer.from('TP/1.1\r\nHost: example.com\r\n\r\n');
-  result = await smartproxy.detection.ProtocolDetector.detectWithConnectionTracking(
+  result = await smartproxy.detection.ProtocolDetector.detectWithContext(
     fragment2,
-    connectionId
+    context
   );
   expect(result.protocol).toEqual('http');
   expect(result.isComplete).toEqual(true);
   expect(result.connectionInfo.method).toEqual('GET');
   expect(result.connectionInfo.path).toEqual('/test');
   expect(result.connectionInfo.domain).toEqual('example.com');
+  
+  // Clean up fragments
+  smartproxy.detection.ProtocolDetector.cleanupConnection(context);
 });
 
 tap.test('Protocol Detection - HTTP Methods', async () => {