wip: handling connections draining before closing socket

tegefaulkes · tegefaulkes · commit 0ff5fb3bcd14 · 2023-04-19T13:06:22.000+10:00
* Related #9 [ci skip]
diff --git a/src/QUICClient.ts b/src/QUICClient.ts
@@ -192,7 +192,7 @@ class QUICClient extends EventTarget {
         await socket.stop();
       }
       // Wrapping error to contain both stack traces
-      throw new errors.ErrorQUICClient(e.message, {cause: e});
+      throw e;
     }
 
     // Remove the temporary socket error handler
diff --git a/src/QUICConnection.ts b/src/QUICConnection.ts
@@ -265,11 +265,6 @@ class QUICConnection extends EventTarget {
     } = {}
   ) {
     this.logger.info(`Destroy ${this.constructor.name}`);
-    const localError = this.conn.localError();
-    const peerError = this.conn.peerError();
-    if (localError != null) console.log(localError);
-    if (peerError != null) console.log(peerError);
-    console.log(this.conn.peerError());
     for (const stream of this.streamMap.values())  {
       await stream.destroy();
     }
@@ -293,21 +288,23 @@ class QUICConnection extends EventTarget {
         utils.never();
       }
     }
-    console.log(this.conn.isClosed(), this.conn.isDraining());
     // If it is not closed, it could still be draining
     if (this.conn.isDraining()) {
       // The `recv`, `send`, `timeout`, and `on_timeout` should continue to be called
       const { p: closeP, resolveP: resolveCloseP } = utils.promise();
       this.resolveCloseP = resolveCloseP;
-      // FIXME: we need to process `send` AND `recv` until the connection is closed.
       await Promise.all([
         this.send(),
         closeP
       ]);
-      console.log('asd')
     }
     this.connectionMap.delete(this.connectionId);
     this.dispatchEvent(new events.QUICConnectionDestroyEvent());
+    // Clean up timeout
+    if (this.timer != null) {
+      clearTimeout(this.timer);
+      delete this.timer;
+    }
     this.logger.info(`Destroyed ${this.constructor.name}`);
   }
 
diff --git a/tests/QUICClient.test.ts b/tests/QUICClient.test.ts
@@ -7,10 +7,8 @@ import * as utils from '@/utils';
 import * as testsUtils from './utils';
 import * as errors from '@/errors';
 import { fc } from '@fast-check/jest';
-import * as tlsUtils from './tlsUtils';
 import * as certFixtures from './fixtures/certFixtures';
 import { promise } from "@/utils";
-import { sleep } from './utils';
 
 const tlsArb = fc.oneof(
   certFixtures.tlsConfigExampleArb,
@@ -270,22 +268,81 @@ describe(QUICClient.name, () => {
     });
   })
   describe('graceful tls handshake', () => {
-    test('handshake succeeds', async () => {
+    test('server verification succeeds', async () => {
       const server = new QUICServer({
         crypto,
         logger: logger.getChild(QUICServer.name),
         config: {
-          tlsConfig: certFixtures.tlsConfigFileRSA2,
+          tlsConfig: certFixtures.tlsConfigFileRSA1,
+          verifyPeer: false,
+        }
+      });
+      const handleConnectionEventProm = promise<any>()
+      server.addEventListener('connection', handleConnectionEventProm.resolveP);
+      await server.start({
+        host: '127.0.0.1' as Host,
+      });
+      // Connection should succeed
+      const client = await QUICClient.createQUICClient({
+        host: '::ffff:127.0.0.1' as Host,
+        port: server.port,
+        localHost: '::' as Host,
+        crypto,
+        logger: logger.getChild(QUICClient.name),
+        config: {
+          verifyPeer: true,
+          verifyFromPemFile: certFixtures.tlsConfigFileRSA1.certChainFromPemFile,
+        }
+      });
+      await handleConnectionEventProm.p
+      await client.destroy();
+      await server.stop();
+    })
+    test('client verification succeeds', async () => {
+      const server = new QUICServer({
+        crypto,
+        logger: logger.getChild(QUICServer.name),
+        config: {
+          tlsConfig: certFixtures.tlsConfigFileRSA1,
+          verifyPeer: true,
+          verifyFromPemFile: certFixtures.tlsConfigFileRSA2.certChainFromPemFile,
+        }
+      });
+      const handleConnectionEventProm = promise<any>()
+      server.addEventListener('connection', handleConnectionEventProm.resolveP);
+      await server.start({
+        host: '127.0.0.1' as Host,
+      });
+      // Connection should succeed
+      const client = await QUICClient.createQUICClient({
+        host: '::ffff:127.0.0.1' as Host,
+        port: server.port,
+        localHost: '::' as Host,
+        crypto,
+        logger: logger.getChild(QUICClient.name),
+        config: {
           verifyPeer: false,
+          tlsConfig: certFixtures.tlsConfigFileRSA2,
+        }
+      });
+      await handleConnectionEventProm.p
+      await client.destroy();
+      await server.stop();
+    })
+    test('client and server verification succeeds', async () => {
+      const server = new QUICServer({
+        crypto,
+        logger: logger.getChild(QUICServer.name),
+        config: {
+          tlsConfig: certFixtures.tlsConfigFileRSA1,
+          verifyPeer: true,
           verifyFromPemFile: certFixtures.tlsConfigFileRSA2.certChainFromPemFile,
-          logKeys: "tmp/key.log",
         }
       });
       const handleConnectionEventProm = promise<any>()
       server.addEventListener('connection', handleConnectionEventProm.resolveP);
       await server.start({
         host: '127.0.0.1' as Host,
-        port: 55555 as Port,
       });
       // Connection should succeed
       const client = await QUICClient.createQUICClient({
@@ -297,17 +354,102 @@ describe(QUICClient.name, () => {
         config: {
           verifyPeer: true,
           tlsConfig: certFixtures.tlsConfigFileRSA2,
-          verifyFromPemFile: certFixtures.tlsConfigFileRSA2.certChainFromPemFile
+          verifyFromPemFile: certFixtures.tlsConfigFileRSA1.certChainFromPemFile,
+
         }
       });
-      console.log('wait for connection');
       await handleConnectionEventProm.p
       await client.destroy();
       await server.stop();
     })
-    test.todo('handshake fails validation for server')
-    test.todo('handshake fails validation for client')
-    test.todo('handshake fails validation for both')
+    test('graceful failure verifying server', async () => {
+      const server = new QUICServer({
+        crypto,
+        logger: logger.getChild(QUICServer.name),
+        config: {
+          tlsConfig: certFixtures.tlsConfigFileRSA1,
+          verifyPeer: false,
+        }
+      });
+      const handleConnectionEventProm = promise<any>()
+      server.addEventListener('connection', handleConnectionEventProm.resolveP);
+      await server.start({
+        host: '127.0.0.1' as Host,
+      });
+      // Connection should succeed
+      await expect(QUICClient.createQUICClient({
+        host: '::ffff:127.0.0.1' as Host,
+        port: server.port,
+        localHost: '::' as Host,
+        crypto,
+        logger: logger.getChild(QUICClient.name),
+        config: {
+          verifyPeer: true,
+        }
+      })).toReject();
+      await handleConnectionEventProm.p
+      await server.stop();
+    })
+    test('graceful failure verifying client', async () => {
+      const server = new QUICServer({
+        crypto,
+        logger: logger.getChild(QUICServer.name),
+        config: {
+          tlsConfig: certFixtures.tlsConfigFileRSA1,
+          verifyPeer: true,
+        }
+      });
+      const handleConnectionEventProm = promise<any>()
+      server.addEventListener('connection', handleConnectionEventProm.resolveP);
+      await server.start({
+        host: '127.0.0.1' as Host,
+      });
+      // Connection should succeed
+      await expect(QUICClient.createQUICClient({
+        host: '::ffff:127.0.0.1' as Host,
+        port: server.port,
+        localHost: '::' as Host,
+        crypto,
+        logger: logger.getChild(QUICClient.name),
+        config: {
+          verifyPeer: false,
+          tlsConfig: certFixtures.tlsConfigFileRSA2,
+        }
+      })).toReject();
+      await handleConnectionEventProm.p
+      await server.stop();
+    })
+    test('graceful failure verifying client amd server', async () => {
+      const server = new QUICServer({
+        crypto,
+        logger: logger.getChild(QUICServer.name),
+        config: {
+          tlsConfig: certFixtures.tlsConfigFileRSA1,
+          verifyPeer: true,
+          verifyFromPemFile: certFixtures.tlsConfigFileRSA2.certChainFromPemFile,
+        }
+      });
+      const handleConnectionEventProm = promise<any>()
+      server.addEventListener('connection', handleConnectionEventProm.resolveP);
+      await server.start({
+        host: '127.0.0.1' as Host,
+      });
+      // Connection should succeed
+      await expect(QUICClient.createQUICClient({
+        host: '::ffff:127.0.0.1' as Host,
+        port: server.port,
+        localHost: '::' as Host,
+        crypto,
+        logger: logger.getChild(QUICClient.name),
+        config: {
+          verifyPeer: true,
+          tlsConfig: certFixtures.tlsConfigFileRSA2,
+          verifyFromPemFile: certFixtures.tlsConfigFileRSA1.certChainFromPemFile,
+        }
+      })).toReject();
+      await handleConnectionEventProm.p
+      await server.stop();
+    })
   })
 
   // test('dual stack to dual stack', async () => {

Original file line number	Diff line number	Diff line change
`@@ -192,7 +192,7 @@ class QUICClient extends EventTarget {`
`192`	`192`	`await socket.stop();`
`193`	`193`	`}`
`194`	`194`	`// Wrapping error to contain both stack traces`
`195`		`- throw new errors.ErrorQUICClient(e.message, {cause: e});`
	`195`	`+ throw e;`
`196`	`196`	`}`
`197`	`197`
`198`	`198`	`// Remove the temporary socket error handler`