quico 0.7.0 → 0.9.0

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 };
 }
 

package/src/qpack.js

@@ -270,6 +270,9 @@ var DECODER_INSERT_COUNT  = 0x00;   // 00xxxxxx
 function parseDecoderInstructions(buf, offset) {
   var increments = 0;
   var i = offset || 0;
+  // Each instruction in order, for the encoder to check (RFC 9204 §4.4):
+  // { type: 'section_ack' | 'stream_cancel' | 'increment', value }.
+  var instructions = [];
 
   // readPrefixedInt(buf, prefixBits, pos) — prefix width SECOND, position
   // THIRD, and it returns { value, next } rather than a byte length. Getting
@@ -284,19 +287,22 @@ function parseDecoderInstructions(buf, offset) {
       r = readPrefixedInt(buf, 7, i);
       if (!r) break;
       i = r.next;
+      instructions.push({ type: 'section_ack', value: r.value });
     } else if (b & DECODER_STREAM_CANCEL) {
       r = readPrefixedInt(buf, 6, i);
       if (!r) break;
       i = r.next;
+      instructions.push({ type: 'stream_cancel', value: r.value });
     } else {
       r = readPrefixedInt(buf, 6, i);
       if (!r) break;
       increments += r.value;
       i = r.next;
+      instructions.push({ type: 'increment', value: r.value });
     }
   }
 
-  return { increments: increments, consumed: i - (offset || 0) };
+  return { increments: increments, consumed: i - (offset || 0), instructions: instructions };
 }
 
 
@@ -439,7 +445,10 @@ function encodeHeaderBlock(headerList, table, options) {
 
   return {
     block: Buffer.from(prefix.concat(out)),
-    inserts: inserts
+    inserts: inserts,
+    // The section's Required Insert Count: non-zero, the peer acknowledges
+    // the section (Section Acknowledgment), which the encoder holds it to.
+    requiredInsertCount: maxRef
   };
 }