feat: expose more connectionId information

Changes:
* Exposed connection destination ID
* Created a common ID that is identical for both sides of the connection. Derived from the source and destination ID.
* The `quiche` connection is now the Source Of Truth for these IDs. The destinationId is only know after establishing and is only valid while running.
* Added test demonstrating the new Ids and how they relate to each other.

Related: MatrixAI/Polykey#609

[ci skip]

Author: tegefaulkes

src/QUICConnection.ts

@@ -1,7 +1,6 @@
 import type { PromiseCancellable } from '@matrixai/async-cancellable';
 import type { ContextTimed, ContextTimedInput } from '@matrixai/contexts';
 import type QUICSocket from './QUICSocket';
-import type QUICConnectionId from './QUICConnectionId';
 import type {
   Host,
   Port,
@@ -25,6 +24,7 @@ import {
 } from '@matrixai/async-init/dist/StartStop';
 import { timedCancellable, context } from '@matrixai/contexts/dist/decorators';
 import { buildQuicheConfig, minIdleTimeout } from './config';
+import QUICConnectionId from './QUICConnectionId';
 import QUICStream from './QUICStream';
 import { quiche, ConnectionErrorCode } from './native';
 import * as utils from './utils';
@@ -44,11 +44,6 @@ class QUICConnection {
    */
   public readonly type: 'client' | 'server';
 
-  /**
-   * This is the source connection ID.
-   */
-  public readonly connectionId: QUICConnectionId;
-
   /**
    * Resolves once the connection has closed.
    */
@@ -381,7 +376,6 @@ class QUICConnection {
     }
     this.type = type;
     this.conn = conn!;
-    this.connectionId = scid;
     this.socket = socket;
     this.config = config;
     if (this.config.cert != null) {
@@ -413,6 +407,37 @@ class QUICConnection {
     this.resolveClosedP = resolveClosedP;
   }
 
+  /**
+   * This is the source connection ID.
+   */
+  public get connectionId() {
+    return new QUICConnectionId(this.conn.sourceId());
+  }
+
+  /**
+   * This is the destination connection ID.
+   * This is only fully known after establishing the connection
+   */
+  @ready(new errors.ErrorQUICConnectionNotRunning())
+  public get connectionIdPeer() {
+    return new QUICConnectionId(this.conn.destinationId());
+  }
+
+  /**
+   * A common ID between the client and server connection.
+   * Used to identify connection pairs more easily.
+   */
+  @ready(new errors.ErrorQUICConnectionNotRunning())
+  public get connectionIdShared() {
+    const sourceId = this.conn.sourceId();
+    const destinationId = this.conn.destinationId();
+    if (Buffer.compare(sourceId, destinationId) <= 0) {
+      return new QUICConnectionId(Buffer.concat([sourceId, destinationId]));
+    } else {
+      return new QUICConnectionId(Buffer.concat([destinationId, sourceId]));
+    }
+  }
+
   public get remoteHost(): Host {
     return this._remoteHost;
   }

tests/QUICClient.test.ts

@@ -1654,7 +1654,7 @@ describe(QUICClient.name, () => {
       await server.stop();
     });
   });
-  test('Connections are established and secured quickly', async () => {
+  test('connections are established and secured quickly', async () => {
     const tlsConfigServer = await testsUtils.generateTLSConfig(defaultType);
 
     const connectionEventProm = promise<events.EventQUICServerConnection>();
@@ -1808,6 +1808,73 @@ describe(QUICClient.name, () => {
       errors.ErrorQUICConnectionIdleTimeout,
     );
 
+    await client.destroy({ force: true });
+    await server.stop({ force: true });
+  });
+  test('connections share the same id information', async () => {
+    const tlsConfigServer = await testsUtils.generateTLSConfig(defaultType);
+
+    const { p: serverConnectionP, resolveP: serverConnectionResolveP } =
+      promise<QUICConnection>();
+    const server = new QUICServer({
+      crypto: {
+        key,
+        ops: serverCryptoOps,
+      },
+      logger: logger.getChild(QUICServer.name),
+      config: {
+        key: tlsConfigServer.leafKeyPairPEM.privateKey,
+        cert: tlsConfigServer.leafCertPEM,
+        verifyPeer: false,
+      },
+    });
+    socketCleanMethods.extractSocket(server);
+    server.addEventListener(
+      events.EventQUICServerConnection.name,
+      (evt: events.EventQUICServerConnection) => {
+        serverConnectionResolveP(evt.detail);
+      },
+    );
+    await server.start({
+      host: localhost,
+    });
+    // If the server is slow to respond then this will time out.
+    //  Then main cause of this was the server not processing the initial packet
+    //  that creates the `QUICConnection`, as a result, the whole creation waited
+    //  an extra 1 second for the client to retry the initial packet.
+    const client = await QUICClient.createQUICClient(
+      {
+        host: localhost,
+        port: server.port,
+        localHost: localhost,
+        crypto: {
+          ops: clientCryptoOps,
+        },
+        logger: logger.getChild(QUICClient.name),
+        config: {
+          verifyPeer: false,
+        },
+      },
+      { timer: 500 },
+    );
+    socketCleanMethods.extractSocket(client);
+
+    const clientConn = client.connection;
+    const serverConn = await serverConnectionP;
+
+    expect(
+      Buffer.compare(clientConn.connectionId, serverConn.connectionIdPeer),
+    ).toBe(0);
+    expect(
+      Buffer.compare(clientConn.connectionIdPeer, serverConn.connectionId),
+    ).toBe(0);
+    expect(
+      Buffer.compare(
+        clientConn.connectionIdShared,
+        serverConn.connectionIdShared,
+      ),
+    ).toBe(0);
+
     await client.destroy({ force: true });
     await server.stop({ force: true });
   });