quico 0.7.0 → 0.8.0

package/src/h3_server.js

@@ -28,7 +28,8 @@ import { createQuicServer } from './quic_server.js';
 import { pickTlsOptions } from './tls_options.js';
 import { _makeSocketStub } from './streams.js';
 import { H3Connection, H3_ERR, wtCloseCapsule, wtDrainCapsule, createCapsuleReader, h3SettingsContext } from './h3.js';
-import { createWtStream, openWtStream, createSendGroup, wtScheduling, createDatagrams, sessionStats } from './wt_stream.js';
+import { createWtStream, openWtStream, createSendGroup, wtScheduling, createDatagrams, sessionStats,
+         exporterArgs, exportSessionKeyingMaterial } from './wt_stream.js';
 import { contextZero, datagramCapsule, STREAM_QUEUE_MAX } from './connect_udp.js';
 
 
@@ -132,6 +133,7 @@ function createServer(options, handler) {
     ech: options.ech || null,
     ocspRequest: options.ocspRequest || null,
     resetTokenSecret: options.resetTokenSecret || null,
+    tokenSecret: options.tokenSecret || null,
     validateAddress: options.validateAddress === true,
     handshakeLoadThreshold: options.handshakeLoadThreshold,
     earlyData: options.earlyData, earlyDataMaxAge: options.earlyDataMaxAge, earlyDataReplay: options.earlyDataReplay,
@@ -607,10 +609,15 @@ function createServer(options, handler) {
         // writeHead, when the status is known.
         _bodyAllowed: true,
 
+        // A list is kept a list, and goes as one field line per value, as
+        // HTTP/1.1 and HTTP/2 send it here and as Node's http does. It was
+        // String(list): two cookies became one "a=1,b=2", which a browser
+        // reads as a single cookie a with the value "1,b=2" (Set-Cookie
+        // never combines, RFC 9110 §5.3).
         setHeader: function (name, value) {
           validateHeaderName(name);
           validateHeaderValue(name, value);
-          res.headers[name.toLowerCase()] = String(value);
+          res.headers[name.toLowerCase()] = Array.isArray(value) ? value.map(String) : String(value);
         },
 
         getHeader: function (name) {
@@ -640,7 +647,7 @@ function createServer(options, handler) {
           }
           // Date (RFC 9110 §6.6.1), as HTTP/2 and HTTP/1.1 send it — HTTP/3's
           // responses had none.
-          if (!('date' in h3Headers) && statusCode >= 200) h3Headers['date'] = httpDate();
+          if (!('date' in h3Headers) && statusCode >= 200 && !(res._wrapper && res._wrapper.sendDate === false)) h3Headers['date'] = httpDate();
 
           if (conn.h3) {
             // Send headers WITHOUT FIN for WT (session stays open)
@@ -703,6 +710,12 @@ function createServer(options, handler) {
           if (typeof callback === 'function') process.nextTick(callback);
         },
 
+        // 102 Processing (node:http's writeProcessing): as Early Hints go.
+        writeProcessing: function () {
+          if (res.headersSent || res._finished || !conn.h3) return;
+          try { conn.h3.sendHeaders(streamId, { ':status': '102' }, false); } catch (e) { /* stream gone */ }
+        },
+
         write: function (chunk) {
           if (!res.headersSent) res.writeHead(res.statusCode);
           if (!res._bodyAllowed) return true;
@@ -868,6 +881,17 @@ function createServer(options, handler) {
         // datagram's.
         createSendGroup: function () { return createSendGroup(); },
 
+        // The browser's exportKeyingMaterial, as the client's: this session's
+        // keying material from the TLS exporter — the same bytes the client
+        // gets for the same label and context.
+        exportKeyingMaterial: function (label, context, outputLength) {
+          var a;
+          try { a = exporterArgs(arguments); } catch (e) { return Promise.reject(e); }
+          if (!req._isWebTransport || req._wtClosed) return Promise.reject(new DOMException('the session is closed', 'InvalidStateError'));
+          try { return Promise.resolve(exportSessionKeyingMaterial(conn.quic, Number(streamId), a)); }
+          catch (e) { return Promise.reject(e); }
+        },
+
         // A stream of ours: a Duplex, or a Writable — recorded with its
         // session, so the session's end destroys it. options { sendOrder,
         // sendGroup, waitUntilAvailable }, the browser's (wt_stream's
@@ -929,6 +953,13 @@ function createServer(options, handler) {
         for (var name in params.request_headers) {
           stream.req.headers[name] = params.request_headers[name];
         }
+        // The field lines as they came (validateFieldSection), which the
+        // copy above leaves behind — not enumerable: req.rawHeaders and
+        // headersDistinct are built from them. Without it they were rebuilt
+        // from the joined values, two x-a lines one "1, 2".
+        if (params.request_headers._rawHeaders && !stream.req.headers._rawHeaders) {
+          Object.defineProperty(stream.req.headers, '_rawHeaders', { value: params.request_headers._rawHeaders, enumerable: false });
+        }
 
         // Extract :method and :path
         if (stream.req.method === null && ':method' in stream.req.headers) {
@@ -1023,6 +1054,7 @@ function createServer(options, handler) {
           releaseHttpStream(conn, streamId, false);
           return;
         }
+        stream.req.upgrade = true;
         ev.emit('upgrade', stream.req, duplex, Buffer.alloc(0));
         return;
       }
@@ -1188,6 +1220,10 @@ function createServer(options, handler) {
     return sock;
   }
 
+  // Every connection, for closing them (closeIdleConnections, close()).
+  var conns = new Set();
+  var closingServer = null;     // close()'s callback, once every connection is gone
+
   qserver.on('connection', function (quic, peer) {
     var conn = { quic: quic, h3: null, http_streams: {}, _wtStreamObjects: {}, served: 0,
                  headerDeadlines: {},   // request streams whose HEADERS is still arriving
@@ -1208,7 +1244,12 @@ function createServer(options, handler) {
     // 'aborted' on the request and 'close' on the response, a tunnel
     // destroyed, a session closed with its streams. Requests that had
     // finished in both directions are already gone (releaseIfDone).
+    conns.add(conn);
+    // Over for the application ('closing'), or its draining done ('close').
+    var gone = function () { if (conns.delete(conn)) connGone(); };
+    quic.on('closing', gone);
     quic.on('close', function () {
+      gone();
       for (var hid in conn.headerDeadlines) clearHeadersDeadline(conn, hid);
       for (var sid in conn.http_streams) releaseHttpStream(conn, sid, true);
       for (var wid in conn._wtStreamObjects) releaseHttpStream(conn, wid, true);
@@ -1615,9 +1656,61 @@ function createServer(options, handler) {
   //  server. This layer adds HTTP/3 request events on top.
   // ============================================================
 
+  // ---- Closing, as node:http (see h1_server) ----
+  //
+  // Idle: no request open on it — before its handshake too, as node:http
+  // counts a connection that has not sent a request. GOAWAY, and closed at
+  // once (closeAfterGoaway: nothing to wait for); before the handshake,
+  // refused (goaway() does that).
+  function isIdle(conn) { return Object.keys(conn.http_streams).length === 0; }
+  // GOAWAY and CONNECTION_CLOSE together (§5.2 allows closing at once when
+  // nothing is in flight): waiting for the GOAWAY's acknowledgement, a
+  // client that had gone held the close until its idle timeout.
+  function closeIdle(conn) {
+    if (!conn.handle) return;
+    conn.handle.goaway();
+    conn.handle.destroy();
+  }
+  function closeIdleConnections() {
+    for (var conn of conns) if (isIdle(conn)) closeIdle(conn);
+  }
+  function closeAllConnections() {
+    for (var conn of conns) if (conn.handle) conn.handle.destroy();
+  }
+  // No new connections; GOAWAY on each — the requests in flight finish, then
+  // the connection closes (closeAfterGoaway) — and once none is left, the
+  // UDP sockets. It closed every connection on the spot: a response being
+  // sent was cut off, and its client waited for the rest until a timeout.
+  function close(callback) {
+    qserver.stopAccepting();
+    closingServer = typeof callback === 'function' ? callback : function () {};
+    for (var conn of conns) {
+      if (isIdle(conn)) closeIdle(conn);
+      else if (conn.handle) conn.handle.goaway();
+    }
+    connGone();
+  }
+  function connGone() {
+    if (!closingServer || conns.size > 0) return;
+    var cb = closingServer;
+    closingServer = null;
+    qserver.close(cb);
+  }
+  function setLimits(o) {
+    if (o.headersTimeout !== undefined) headersTimeout = o.headersTimeout;
+    if (o.requestTimeout !== undefined) requestTimeout = o.requestTimeout;
+    if (o.maxRequestsPerSocket !== undefined) maxRequests = maxRequestsPerSocket(o.maxRequestsPerSocket);
+  }
+
   return {
-    listen: qserver.listen,
-    close: qserver.close,
+    listen: function (p, h, cb) { closingServer = null; return qserver.listen(p, h, cb); },
+    close: close,
+    closeIdleConnections: closeIdleConnections,
+    closeAllConnections: closeAllConnections,
+    setLimits: setLimits,
+    get connectionCount() { return conns.size; },
+    ref: qserver.ref,
+    unref: qserver.unref,
     on: function (name, fn) { if (name === 'upgrade') upgradeListeners++; ev.on(name, fn); },
     setTimeout: function () { /* TODO */ },
 
@@ -1639,7 +1732,9 @@ function createServer(options, handler) {
     getOptions: qserver.getOptions,
     setOptions: qserver.setOptions,
     getResetTokenSecret: qserver.getResetTokenSecret,
-    setResetTokenSecret: qserver.setResetTokenSecret
+    setResetTokenSecret: qserver.setResetTokenSecret,
+    getTokenSecret: qserver.getTokenSecret,
+    setTokenSecret: qserver.setTokenSecret
   };
 }
 

package/src/hpack_primitives.js

@@ -84,6 +84,7 @@ var HUFF_BITS = new Uint8Array([
 ]);
 
 var HUFF_EOS = 256;   // index of the EOS symbol; decoding it is an error
+var _HD_HAS_SYM = 1 << 17, _HD_INVALID = 1 << 18;   // huffDecode table flags
 
 var _huffRoot = (function () {
   var root = {};
@@ -100,6 +101,51 @@ var _huffRoot = (function () {
 })();
 
 
+// Table-driven decoding, four bits at a time.
+//
+// The decoder used to walk the code tree one bit per step: eight object
+// lookups per input byte. Here every internal node of that same tree is a
+// state, and for each state and each 4-bit nibble a table holds what four
+// steps of the walk would have done — the node it ends on, the symbol it
+// completed (at most one: the shortest code is 5 bits), and whether it fell
+// off the tree. Two lookups per byte, same walk, same results.
+//
+// The padding checks at the end need only the state the input stopped in:
+// the bits since the last complete symbol are that node's depth, and they
+// are all ones exactly when its path from the root is.
+var _huffDec = (function () {
+  var nodes = [_huffRoot], depth = [0], ones = [1];
+  var idOf = new Map([[_huffRoot, 0]]);
+  for (var q = 0; q < nodes.length; q++) {
+    for (var b = 0; b <= 1; b++) {
+      var child = nodes[q][b];
+      if (child && child.sym === undefined && !idOf.has(child)) {
+        idOf.set(child, nodes.length);
+        nodes.push(child);
+        depth.push(depth[q] + 1);
+        ones.push(ones[q] && b === 1 ? 1 : 0);
+      }
+    }
+  }
+  // entry = next | sym << 8 | HAS_SYM | INVALID ; sym is 0..256
+  var table = new Int32Array(nodes.length * 16);
+  for (var st = 0; st < nodes.length; st++) {
+    for (var nib = 0; nib < 16; nib++) {
+      var node = nodes[st], entry = 0;
+      for (var k = 3; k >= 0; k--) {
+        node = node[(nib >> k) & 1];
+        if (!node) { entry |= _HD_INVALID; node = _huffRoot; break; }
+        if (node.sym !== undefined) {
+          entry |= _HD_HAS_SYM | (node.sym << 8);
+          node = _huffRoot;
+        }
+      }
+      table[st * 16 + nib] = entry | idOf.get(node);
+    }
+  }
+  return { table: table, depth: Uint8Array.from(depth), ones: Uint8Array.from(ones) };
+})();
+
 /**
  * Decode a Huffman-coded byte string (RFC 7541 §5.2). Returns the raw
  * Uint8Array, NOT a string.
@@ -117,42 +163,35 @@ var _huffRoot = (function () {
  * decoders that must answer a malformed peer with COMPRESSION_ERROR pass true.
  */
 function huffDecode(buf, strict) {
-  var out = [];
-  var node = _huffRoot;
-  var nbits = 0, current = 0;
-  var sincePadStart = 0;   // bits consumed since the last complete symbol
-  var padIsOnes = true;    // were all of those bits 1?
+  var table = _huffDec.table;
+  var out = new Uint8Array(((buf.length * 8) / 5) | 0);
+  var n = 0, state = 0;
 
   for (var i = 0; i < buf.length; i++) {
-    current = (current << 8) | buf[i];
-    nbits += 8;
-    while (nbits > 0) {
-      var bit = (current >> (nbits - 1)) & 1;
-      node = node[bit];
-      if (!node) throw new Error('Invalid Huffman code');
-      nbits--;
-      sincePadStart++;
-      if (bit === 0) padIsOnes = false;
-      if (node.sym !== undefined) {
-        if (strict && node.sym === HUFF_EOS) {
+    var byte = buf[i];
+    for (var half = 0; half < 2; half++) {
+      var e = table[(state << 4) | (half === 0 ? byte >> 4 : byte & 15)];
+      if (e & _HD_INVALID) throw new Error('Invalid Huffman code');
+      if (e & _HD_HAS_SYM) {
+        var sym = (e >> 8) & 0x1FF;
+        if (strict && sym === HUFF_EOS) {
           throw new Error('Huffman: EOS symbol in input');
         }
-        out.push(node.sym);
-        node = _huffRoot;
-        sincePadStart = 0;
-        padIsOnes = true;
+        out[n++] = sym;   // EOS (256) stores as 0, as Uint8Array.from did
       }
+      state = e & 0xFF;
     }
   }
 
-  if (strict && node !== _huffRoot) {
+  if (strict && state !== 0) {
     // Trailing bits that did not complete a symbol are padding. They must be
     // at most 7 bits and must be the most-significant bits of the EOS code.
-    if (sincePadStart > 7) throw new Error('Huffman: padding longer than 7 bits');
-    if (!padIsOnes) throw new Error('Huffman: padding is not the EOS prefix');
+    if (_huffDec.depth[state] > 7) throw new Error('Huffman: padding longer than 7 bits');
+    if (!_huffDec.ones[state]) throw new Error('Huffman: padding is not the EOS prefix');
   }
 
-  return Uint8Array.from(out);
+  // A view, not a copy: every caller turns the bytes into a string at once.
+  return out.subarray(0, n);
 }
 
 
@@ -517,4 +556,4 @@ export {
 
   // Text
   bytesToLatin1
-};
+};

package/src/http_common.js

@@ -458,6 +458,10 @@ function validateFieldSection(list, opts) {
   // m,p,a,s, Safari m,s,p,a. See h2_fingerprint.js. Collected here because
   // this loop is the only place that sees the list in its original sequence.
   var pseudoOrder = [];
+  // The fields as they came, one name and value per field line, pseudo-headers
+  // first: for rawHeaders, which node:http2 keeps that way (the map combines
+  // repeated ones).
+  var raw = [];
   var bad = function (m) { var e = new Error(m); e.malformed = true; return e; };
 
   for (var i = 0; i < list.length; i++) {
@@ -477,6 +481,7 @@ function validateFieldSection(list, opts) {
       if (!pseudo[name]) throw bad('unknown or misdirected pseudo-header ' + name);
       if (hasOwn.call(headers, name)) throw bad('duplicate pseudo-header ' + name);
       headers[name] = value;
+      raw.push(name, value);   // node:http2 keeps them in rawHeaders too
       continue;
     }
     seenRegular = true;
@@ -491,6 +496,7 @@ function validateFieldSection(list, opts) {
     // Repeat-combining is RFC 9110 §5.3: set-cookie never joins, cookie joins
     // with "; " (which h2 and h3 rely on: a sender may split it to compress).
     addHeader(headers, name, value);
+    raw.push(name, value);
   }
 
   var protocol = null;
@@ -543,6 +549,7 @@ function validateFieldSection(list, opts) {
   }
   if (!isServer && !trailers && !headers[':status']) throw bad('response is missing :status');
 
+  Object.defineProperty(headers, '_rawHeaders', { value: raw, enumerable: false });
   return { headers: headers, pseudoOrder: pseudoOrder, protocol: protocol };
 }