quico 0.2.0 → 0.4.0

package/src/h3_client.js

@@ -12,10 +12,10 @@
  *     https://github.com/colocohen/quico
  */
 
-import dgram from 'node:dgram';
 import dns from 'node:dns';
-import { QUICConnection } from './quic_connection.js';
+import { DEBUG } from './utils.js';
 import { H3Connection } from './h3.js';
+import { createQuicClientSocket } from './quic_socket.js';
 
 
 // ============================================================
@@ -34,15 +34,27 @@ function request(options, callback) {
   }
 
   var hostname = options.hostname || options.host || 'localhost';
+  // Certificate verification options, forwarded to the QUIC/TLS layer.
+  // Defaults to verifying (node:tls semantics); without this passthrough the
+  // option dies here and H3 connections can never opt out — which makes the
+  // one transport this library exists for the only one that can't reach a
+  // self-signed or private-CA server (H2/H1.1 fallbacks honour the option).
+  var rejectUnauthorized = options.rejectUnauthorized !== false;
+  var ca = options.ca || null;
   var port = options.port || 443;
   var path = options.path || '/';
   var method = (options.method || 'GET').toUpperCase();
   var headers = options.headers || {};
-  var rejectUnauthorized = options.rejectUnauthorized !== false;
 
   // Connection reuse: pass _connection = { quic, h3, udpSocket, nextStreamId }
   var existingConn = options._connection || null;
-  var autoClose = existingConn ? false : true;
+  // Auto-close the QUIC connection when this request finishes ONLY when we own
+  // it — i.e. a fresh, standalone connection. Reused connections (existingConn)
+  // and connections whose lifecycle is managed by an external pool
+  // (options._managed, set by the unified client/agent) are left open; closing
+  // them here would tear down a connection still pooled for reuse. Managed
+  // connections are reaped by the agent (sweep/destroy) and the QUIC idle timer.
+  var autoClose = !existingConn && !options._managed;
 
   // ---- Client Request object ----
   var reqBody = [];
@@ -104,9 +116,12 @@ function request(options, callback) {
 
   // ---- Resolve hostname and connect (or reuse existing) ----
   if (existingConn) {
-    // Reuse existing connection — allocate stream ID and send when ready
+    // Reuse existing connection — allocate stream ID and send when ready.
+    // The shared dispatch listeners were installed when the connection was
+    // first created; installSharedHandlers() is idempotent.
     streamId = allocateStreamId(existingConn);
-    setupResponseHandlers();
+    installSharedHandlers(existingConn);
+    setupResponseHandlers(existingConn);
     if (reqFinished) sendRequest();
   } else {
     resolveAndConnect(hostname, port);
@@ -132,60 +147,42 @@ function request(options, callback) {
 
 
   function startConnection(remoteIp, remotePort) {
-    // Create UDP socket
-    var isIPv6 = remoteIp.indexOf(':') >= 0;
-    udpSocket = dgram.createSocket(isIPv6 ? 'udp6' : 'udp4');
-
-    udpSocket.on('message', function (msg, rinfo) {
-      if (quic) quic.feedDatagram(rinfo.address, rinfo.port, new Uint8Array(msg));
-    });
-
-    udpSocket.on('error', function (err) {
-      emit(reqListeners, 'error', err);
-    });
+    udpSocket = createQuicClientSocket({
+      remoteIp: remoteIp,
+      remotePort: remotePort,
+      hostname: hostname,
+      rejectUnauthorized: rejectUnauthorized,
+      ca: ca,
+
+      onError: function (err) {
+        emit(reqListeners, 'error', err);
+      },
 
-    // Bind to random port
-    udpSocket.bind(0, function () {
-      // Create QUIC connection (client mode)
-      quic = new QUICConnection({
-        isServer: false,
-        SNICallback: null,
-        hostname: hostname
-      });
-
-      // Send packets via UDP
-      quic.on('packet', function (data) {
-        udpSocket.send(data, remotePort, remoteIp, function (err) {
-          if (err) emit(reqListeners, 'error', err);
-        });
-      });
-
-      // QUIC connected → set up H3
-      quic.on('connect', function () {
-        console.log('[client] QUIC connected');
+      onConnect: function (q, s) {
+        quic = q;
+        udpSocket = s;
+        if (DEBUG) console.log('[client] QUIC connected');
 
         h3 = new H3Connection({ quicConnection: quic, isServer: false });
         connected = true;
 
         // Build connection object for reuse
         var conn = { quic: quic, h3: h3, udpSocket: udpSocket, _nextStreamId: 0 };
+
+        // Install the shared per-connection dispatch listeners ONCE, then
+        // register this request in the connection's stream-handler map.
+        installSharedHandlers(conn);
         streamId = allocateStreamId(conn);
 
         // Store on clientReq so caller (unified client) can reuse
         clientReq._connection = conn;
 
-        setupResponseHandlers();
+        setupResponseHandlers(conn);
 
         // Send request if body is ready
         if (reqFinished) sendRequest();
-      });
-
-      quic.on('close', function () {
-        if (udpSocket) { try { udpSocket.close(); } catch (e) {} }
-      });
-
-      // Start QUIC handshake
-      quic.connect();
+      }
+      // onClose: the helper closes the UDP socket; nothing extra needed here.
     });
   }
 
@@ -202,51 +199,78 @@ function request(options, callback) {
 
 
   /**
-   * Set up HTTP/3 response handlers for this request's streamId.
-   * Works for both new and reused connections.
+   * Install the three HTTP/3 event listeners ONCE per connection. They dispatch
+   * each event to the right request via the connection's stream-handler map
+   * (keyed by stream id), so multiplexing many requests over a single
+   * connection does NOT pile up listeners on the H3 emitter (previously every
+   * request added another set of listeners that were never removed).
+   * Idempotent per connection.
    */
-  function setupResponseHandlers() {
-    // HTTP response headers
-    h3.on('http_headers', function (sid, hdrs) {
-      if (sid !== streamId) return;
-      clientRes.headers = hdrs;
-      clientRes.statusCode = parseInt(hdrs[':status']) || 0;
-      clientRes._headersReceived = true;
-
-      // Fire callback with response
-      if (typeof callback === 'function') {
-        callback(clientRes);
-        callback = null; // only once
-      }
-      emit(reqListeners, 'response', clientRes);
+  function installSharedHandlers(conn) {
+    if (conn._streamHandlers) return;  // already installed for this connection
+    conn._streamHandlers = {};
+    var h3c = conn.h3;
+
+    h3c.on('http_headers', function (sid, hdrs) {
+      var h = conn._streamHandlers[sid];
+      if (h) h.onHeaders(hdrs);
     });
-
-    // HTTP response body
-    h3.on('http_body', function (sid, data) {
-      if (sid !== streamId) return;
-      emit(clientRes, 'data', data);
+    h3c.on('http_body', function (sid, data) {
+      var h = conn._streamHandlers[sid];
+      if (h) h.onBody(data);
     });
+    h3c.on('http_end', function (sid) {
+      var h = conn._streamHandlers[sid];
+      if (!h) return;
+      delete conn._streamHandlers[sid];  // free per-stream state before dispatch
+      h.onEnd();
+    });
+  }
 
-    // HTTP response end
-    h3.on('http_end', function (sid) {
-      if (sid !== streamId) return;
-      emit(clientRes, 'end');
-
-      // Auto-close only if we own the connection (not reusing)
-      if (autoClose) {
-        setTimeout(function () {
-          if (quic) quic.close(0, 'done');
-          if (udpSocket) { try { udpSocket.close(); } catch (e) {} }
-        }, 100);
+
+  /**
+   * Register this request's response handlers in the connection's stream map,
+   * keyed by its streamId. Replaces per-request h3.on(...) registration —
+   * routing is now by map key, so no per-listener streamId check is needed.
+   */
+  function setupResponseHandlers(conn) {
+    conn._streamHandlers[streamId] = {
+      onHeaders: function (hdrs) {
+        clientRes.headers = hdrs;
+        clientRes.statusCode = parseInt(hdrs[':status']) || 0;
+        clientRes._headersReceived = true;
+
+        // Fire callback with response (once)
+        if (typeof callback === 'function') {
+          callback(clientRes);
+          callback = null;
+        }
+        emit(reqListeners, 'response', clientRes);
+      },
+
+      onBody: function (data) {
+        emit(clientRes, 'data', data);
+      },
+
+      onEnd: function () {
+        emit(clientRes, 'end');
+
+        // Auto-close only if we own the connection (see `autoClose` above).
+        if (autoClose) {
+          setTimeout(function () {
+            if (quic) quic.close(0, 'done');
+            if (udpSocket) { try { udpSocket.close(); } catch (e) {} }
+          }, 100);
+        }
       }
-    });
+    };
   }
 
 
   function sendRequest() {
     if (!h3 || !connected) return;
 
-    console.log('[client] sendRequest method=' + method + ' path=' + path + ' stream=' + streamId);
+    if (DEBUG) console.log('[client] sendRequest method=' + method + ' path=' + path + ' stream=' + streamId);
 
     // MUST send control streams (SETTINGS) before any request
     h3.sendControlStreams();

package/src/h3_server.js

@@ -12,13 +12,10 @@
  *     https://github.com/colocohen/quico
  */
 
-import dgram from 'node:dgram';
 import { Duplex, Readable, Writable } from 'node:stream';
-import { Emitter, readVarInt, writeVarInt } from './utils.js';
-import { parse_quic_datagram } from './transport.js';
-import { QUICConnection } from './quic_connection.js';
+import { Emitter, readVarInt, wt_datagram_payload } from './utils.js';
+import { createQuicServer } from './quic_server.js';
 import { H3Connection } from './h3.js';
-import { createSecureContext } from './tls_bridge.js';
 
 
 // ============================================================
@@ -29,23 +26,26 @@ function createServer(options, handler) {
   options = options || {};
 
   var ev = Emitter();
-  var udp4 = null;
-  var udp6 = null;
-  var port = null;
 
-  // Build SNICallback
-  var sniCallback = options.SNICallback || null;
-
-  if (!sniCallback && options.key && options.cert) {
-    var defaultCtx = createSecureContext({ key: options.key, cert: options.cert, ca: options.ca });
-    sniCallback = function (servername, cb) { cb(null, defaultCtx); };
-  }
-
-  // ---- Connection tracking ----
-  var connections = {};     // connId → { quic, h3, http_streams }
-  var addressMap = {};      // "ip:port" → connId
-  var maxConnections = options.maxConnections || 10000;
-  var sweepTimer = null;
+  // Transport-only QUIC server owns the UDP socket(s), demux, connection
+  // map and lifecycle. h3_server layers HTTP/3 on top by listening for its
+  // 'connection' event (see below) and wrapping each raw QUICConnection in
+  // an H3Connection. ALPN is 'h3'. External-socket (shared-port) mode and
+  // the handlePacket/hasConnection demux hooks are provided by the
+  // transport server and re-exported on this server's API.
+  var qserver = createQuicServer({
+    alpn: 'h3',
+    SNICallback: options.SNICallback || null,
+    key: options.key,
+    cert: options.cert,
+    ca: options.ca,
+    maxConnections: options.maxConnections || 10000,
+    socket: options.socket || null,
+    socket6: options.socket6 || null
+  });
+
+  // Surface transport-level (UDP socket / send) errors on this server.
+  qserver.on('error', function (err) { ev.emit('error', err); });
 
 
   // ============================================================
@@ -105,8 +105,7 @@ function createServer(options, handler) {
   //  Same pattern as old quico h3_server.js
   // ============================================================
 
-  function set_http_stream(connId, streamId, params) {
-    var conn = connections[connId];
+  function set_http_stream(conn, streamId, params) {
     if (!conn) return;
 
     var is_new = false;
@@ -200,12 +199,7 @@ function createServer(options, handler) {
           if (!req._isWebTransport) return;
           if (typeof data === 'string') data = Buffer.from(data);
           if (Buffer.isBuffer(data)) data = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-          var quarterSid = Math.floor(Number(streamId) / 4);
-          var prefix = writeVarInt(quarterSid);
-          var frame = new Uint8Array(prefix.length + data.byteLength);
-          frame.set(prefix, 0);
-          frame.set(data, prefix.length);
-          conn.quic.sendDatagram(frame);
+          conn.quic.sendDatagram(wt_datagram_payload(Number(streamId), data));
         },
 
         createBidirectionalStream: function () {
@@ -284,93 +278,41 @@ function createServer(options, handler) {
 
 
   // ============================================================
-  //  UDP → connection routing
+  //  HTTP/3 over each accepted QUIC connection
+  //  The transport server hands us a raw QUICConnection per peer; we wrap
+  //  it in an H3Connection once the handshake completes and bridge HTTP/3 +
+  //  WebTransport events to req/res via set_http_stream. Per-connection
+  //  state lives in this closure — the transport server owns the UDP
+  //  socket, demux and connection lifecycle.
   // ============================================================
 
-  function onUdpMessage(msg, rinfo) {
-    var data = new Uint8Array(msg);
-    var fromIp = rinfo.address;
-    var fromPort = rinfo.port;
-    console.log('[server] UDP from ' + fromIp + ':' + fromPort + ' len=' + data.length);
-
-    var addressKey = fromIp + ':' + fromPort;
-    var packets = parse_quic_datagram(data);
-    if (packets.length === 0) return;
-
-    for (var i = 0; i < packets.length; i++) {
-      var pkt = packets[i];
-      if (!pkt) continue;
-
-      var connId = findConnectionId(pkt, addressKey);
-
-      if (!(connId in connections)) {
-        // Reject new connections when at capacity
-        if (Object.keys(connections).length >= maxConnections) return;
-        createConnection(connId, fromIp, fromPort, addressKey);
-      }
-
-      connections[connId].quic.feedDatagram(fromIp, fromPort, pkt.raw);
-    }
-  }
-
-
-  function findConnectionId(pkt, addressKey) {
-    var dcidStr = null;
-    if (pkt.dcid && pkt.dcid.byteLength > 0) {
-      dcidStr = Array.from(pkt.dcid).join('');
-    }
-
-    if (dcidStr && dcidStr in connections) return dcidStr;
-    if (addressKey in addressMap && addressMap[addressKey] in connections) return addressMap[addressKey];
-
-    var id = dcidStr || String(Math.floor(Math.random() * 9007199254740991));
-    addressMap[addressKey] = id;
-    return id;
-  }
-
-
-  function createConnection(connId, fromIp, fromPort, addressKey) {
-    var quic = new QUICConnection({ SNICallback: sniCallback });
-
-    connections[connId] = {
-      quic: quic,
-      h3: null,
-      http_streams: {}
-    };
-
-    addressMap[addressKey] = connId;
-
-    // Send packets back via UDP
-    quic.on('packet', function (data) {
-      sendUdp(fromIp, fromPort, data);
-    });
+  qserver.on('connection', function (quic, peer) {
+    var conn = { quic: quic, h3: null, http_streams: {} };
 
     // QUIC handshake complete → set up H3
     quic.on('connect', function () {
       var h3 = new H3Connection({ quicConnection: quic, enableWebTransport: true });
-      connections[connId].h3 = h3;
+      conn.h3 = h3;
 
       // HTTP request headers received → set_http_stream (reactive)
       h3.on('http_headers', function (streamId, headers) {
-        set_http_stream(connId, streamId, { request_headers: headers });
+        set_http_stream(conn, streamId, { request_headers: headers });
       });
 
       // HTTP request body chunk → set_http_stream
       h3.on('http_body', function (streamId, data) {
-        set_http_stream(connId, streamId, { request_body_chunk: data });
+        set_http_stream(conn, streamId, { request_body_chunk: data });
       });
 
       // HTTP request complete → fire req.on('end')
       h3.on('http_end', function (streamId) {
-        set_http_stream(connId, streamId, { request_end: true });
+        set_http_stream(conn, streamId, { request_end: true });
       });
 
       // ---- WebTransport stream events ----
 
       // New WT stream (bidi or uni from client)
       h3.on('wt_stream', function (sessionId, wtStreamId, data, fin, isBidi) {
-        var conn = connections[connId];
-        if (!conn) return;
         var session = conn.http_streams[sessionId];
         if (!session || !session.req._isWebTransport) return;
 
@@ -395,8 +337,7 @@ function createServer(options, handler) {
 
       // Subsequent data on WT stream
       h3.on('wt_data', function (sessionId, wtStreamId, data, fin) {
-        var conn = connections[connId];
-        if (!conn || !conn._wtStreamObjects) return;
+        if (!conn._wtStreamObjects) return;
         var wtStream = conn._wtStreamObjects[wtStreamId];
         if (!wtStream) return;
         if (data.byteLength > 0) wtStream._pushData(data);
@@ -404,7 +345,7 @@ function createServer(options, handler) {
       });
 
       // Datagrams
-      quic.on('datagram', function (_contextId, rawData) {
+      quic.on('datagram', function (rawData) {
         if (!rawData || rawData.byteLength === 0) return;
         var result = readVarInt(rawData, 0);
         if (!result) return;
@@ -412,8 +353,6 @@ function createServer(options, handler) {
         var payload = rawData.slice(result.byteLength);
 
         // Find the session: quarter_stream_id = session_stream_id / 4
-        var conn = connections[connId];
-        if (!conn) return;
         for (var sid in conn.http_streams) {
           var session = conn.http_streams[sid];
           if (session.req._isWebTransport && Math.floor(Number(sid) / 4) === quarterSid) {
@@ -423,99 +362,29 @@ function createServer(options, handler) {
         }
       });
     });
-
-    quic.on('close', function () {
-      delete connections[connId];
-      if (addressMap[addressKey] === connId) delete addressMap[addressKey];
-    });
-  }
-
-
-  // ============================================================
-  //  UDP send
-  // ============================================================
-
-  function sendUdp(toIp, toPort, data) {
-    var socket = toIp.indexOf(':') >= 0 ? udp6 : udp4;
-    if (!socket) return;
-    socket.send(data, toPort, toIp, function (err) {
-      if (err) ev.emit('error', err);
-    });
-  }
-
-
-  // ============================================================
-  //  listen / close
-  // ============================================================
-
-  function listen(listenPort, host, callback) {
-    if (typeof host === 'function') { callback = host; host = null; }
-    port = listenPort || 443;
-    host = host || '::';
-
-    udp4 = dgram.createSocket('udp4');
-    udp4.on('message', onUdpMessage);
-    udp4.on('error', function (err) { ev.emit('error', err); });
-    var host4 = host.indexOf('.') !== -1 ? host : '0.0.0.0';
-    udp4.bind(port, host4);
-
-    udp6 = dgram.createSocket({ type: 'udp6', ipv6Only: true });
-    udp6.on('message', onUdpMessage);
-    udp6.on('error', function (err) { ev.emit('error', err); });
-    var host6 = host.indexOf(':') !== -1 ? host : '::';
-    udp6.bind(port, host6, function () {
-      if (typeof callback === 'function') callback();
-    });
-
-    // Periodic sweep for dead connections (safety net)
-    sweepTimer = setInterval(function () {
-      for (var id in connections) {
-        var st = connections[id].quic.state;
-        if (st === 'closed') {
-          delete connections[id];
-          // Clean address map
-          for (var addr in addressMap) {
-            if (addressMap[addr] === id) delete addressMap[addr];
-          }
-        }
-      }
-    }, 30000);
-  }
-
-  function close(callback) {
-    // Stop sweep
-    if (sweepTimer) { clearInterval(sweepTimer); sweepTimer = null; }
-
-    // Close all connections
-    for (var id in connections) {
-      try { connections[id].quic.close(0, 'server closing'); } catch (e) { }
-    }
-    connections = {};
-    addressMap = {};
-
-    var closed = 0;
-    var total = (udp4 ? 1 : 0) + (udp6 ? 1 : 0);
-    if (total === 0) { if (callback) callback(); return; }
-
-    function onClose() {
-      closed++;
-      if (closed >= total && typeof callback === 'function') callback();
-    }
-
-    if (udp4) { udp4.close(onClose); udp4 = null; }
-    if (udp6) { udp6.close(onClose); udp6 = null; }
-  }
+  });
 
 
   // ============================================================
   //  Server API
+  //  Transport concerns (UDP sockets, demux, connection lifecycle,
+  //  shared-port handlePacket/hasConnection) are delegated to the QUIC
+  //  server. This layer adds HTTP/3 request events on top.
   // ============================================================
 
   return {
-    listen: listen,
-    close: close,
+    listen: qserver.listen,
+    close: qserver.close,
     on: function (name, fn) { ev.on(name, fn); },
-    setTimeout: function () { /* TODO */ }
+    setTimeout: function () { /* TODO */ },
+
+    /** Feed an incoming UDP packet when running in external-socket mode.
+     *  rinfo must be in Node's dgram format: { address, port, family, size }. */
+    handlePacket: qserver.handlePacket,
+
+    /** Returns true if the 5-tuple matches an active QUIC connection.
+     *  Used by demuxers for routing decisions on shared UDP ports. */
+    hasConnection: qserver.hasConnection
   };
 }