quic: add ipv6-only handshake test and fix

Author: jasnell

lib/internal/quic/quic.js

@@ -2079,21 +2079,13 @@ class QuicEndpoint {
  */
 function processEndpointOption(endpoint) {
   if (endpoint === undefined) {
-    return {
-      endpoint: new QuicEndpoint(),
-      created: true,
-    };
+    // No endpoint or endpoint options were given. Create a default.
+    return new QuicEndpoint();
   } else if (endpoint instanceof QuicEndpoint) {
-    return {
-      endpoint,
-      created: false,
-    };
+    // We were given an existing endpoint. Use it as-is.
+    return endpoint;
   }
-  validateObject(endpoint, 'options.endpoint');
-  return {
-    endpoint: new QuicEndpoint(endpoint),
-    created: true,
-  };
+  return new QuicEndpoint(endpoint);
 }
 
 /**
@@ -2226,10 +2218,10 @@ function getPreferredAddressPolicy(policy = 'default') {
 
 /**
  * @param {SessionOptions} options
- * @param {boolean} [forServer]
+ * @param {{forServer: boolean, addressFamily: string}} [config]
  * @returns {SessionOptions}
  */
-function processSessionOptions(options, forServer = false) {
+function processSessionOptions(options, config = {}) {
   validateObject(options, 'options');
   const {
     endpoint,
@@ -2248,6 +2240,10 @@ function processSessionOptions(options, forServer = false) {
     [kApplicationProvider]: provider,
   } = options;
 
+  const {
+    forServer = false,
+  } = config;
+
   if (provider !== undefined) {
     validateObject(provider, 'options[kApplicationProvider]');
   }
@@ -2256,15 +2252,11 @@ function processSessionOptions(options, forServer = false) {
     validateOneOf(cc, 'options.cc', [CC_ALGO_RENO, CC_ALGO_BBR, CC_ALGO_CUBIC]);
   }
 
-  const {
-    endpoint: actualEndpoint,
-    created: endpointCreated,
-  } = processEndpointOption(endpoint);
+  const actualEndpoint = processEndpointOption(endpoint);
 
   return {
     __proto__: null,
     endpoint: actualEndpoint,
-    endpointCreated,
     version,
     minVersion,
     preferredAddressPolicy: getPreferredAddressPolicy(preferredAddressPolicy),
@@ -2294,7 +2286,7 @@ async function listen(callback, options = kEmptyObject) {
   const {
     endpoint,
     ...sessionOptions
-  } = processSessionOptions(options, true /* for server */);
+  } = processSessionOptions(options, { forServer: true });
   endpoint[kListen](callback, sessionOptions);
 
   if (onEndpointListeningChannel.hasSubscribers) {

test/parallel/test-quic-handshake-ipv6-only.mjs

@@ -0,0 +1,67 @@
+// Flags: --experimental-quic --no-warnings
+
+import { hasQuic, hasIPv6, skip } from '../common/index.mjs';
+import { ok, partialDeepStrictEqual } from 'node:assert';
+import { readKey } from '../common/fixtures.mjs';
+
+if (!hasQuic) {
+  skip('QUIC is not enabled');
+}
+
+if (!hasIPv6) {
+  skip('IPv6 is not supported');
+}
+
+// Import after the hasQuic check
+const { listen, connect } = await import('node:quic');
+const { createPrivateKey } = await import('node:crypto');
+
+const keys = createPrivateKey(readKey('agent1-key.pem'));
+const certs = readKey('agent1-cert.pem');
+
+const check = {
+  // The SNI value
+  servername: 'localhost',
+  // The selected ALPN protocol
+  protocol: 'h3',
+  // The negotiated cipher suite
+  cipher: 'TLS_AES_128_GCM_SHA256',
+  cipherVersion: 'TLSv1.3',
+};
+
+// The opened promise should resolve when the handshake is complete.
+
+const serverOpened = Promise.withResolvers();
+const clientOpened = Promise.withResolvers();
+
+const serverEndpoint = await listen(async (serverSession) => {
+  const info = await serverSession.opened;
+  partialDeepStrictEqual(info, check);
+  serverOpened.resolve();
+  serverSession.close();
+}, { keys, certs, endpoint: {
+  address: {
+    address: '::1',
+    family: 'ipv6',
+  },
+  ipv6Only: true,
+} });
+
+// The server must have an address to connect to after listen resolves.
+ok(serverEndpoint.address !== undefined);
+
+const clientSession = await connect(serverEndpoint.address, {
+  endpoint: {
+    address: {
+      address: '::',
+      family: 'ipv6',
+    },
+  }
+});
+clientSession.opened.then((info) => {
+  partialDeepStrictEqual(info, check);
+  clientOpened.resolve();
+});
+
+await Promise.all([serverOpened.promise, clientOpened.promise]);
+clientSession.close();