deps: update nghttp2 to 1.40.0

PR-URL: #30493
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Yongsheng Zhang <zyszys98@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>

Author: gengjiawen

deps/nghttp2/lib/CMakeLists.txt

@@ -62,7 +62,7 @@ if(HAVE_CUNIT OR ENABLE_STATIC_LIB)
 set_target_properties(nghttp2_static PROPERTIES
 COMPILE_FLAGS"${WARNCFLAGS}"
 VERSION${LT_VERSION}SOVERSION${LT_SOVERSION}
-ARCHIVE_OUTPUT_NAMEnghttp2
+ARCHIVE_OUTPUT_NAMEnghttp2_static
  )
 target_compile_definitions(nghttp2_staticPUBLIC"-DNGHTTP2_STATICLIB")
 if(ENABLE_STATIC_LIB)

deps/nghttp2/lib/includes/nghttp2/nghttp2.h

@@ -4769,6 +4769,19 @@ NGHTTP2_EXTERN int nghttp2_check_header_name(const uint8_t *name, size_t len);
  */
 NGHTTP2_EXTERNintnghttp2_check_header_value(constuint8_t*value, size_tlen);
 
+/**
+ * @function
+ *
+ * Returns nonzero if the |value| which is supposed to the value of
+ * :authority or host header field is valid according to
+ * https://tools.ietf.org/html/rfc3986#section-3.2
+ *
+ * |value| is valid if it merely consists of the allowed characters.
+ * In particular, it does not check whether |value| follows the syntax
+ * of authority.
+ */
+NGHTTP2_EXTERNintnghttp2_check_authority(constuint8_t*value, size_tlen);
+
 /* HPACK API */
 
 structnghttp2_hd_deflater;

deps/nghttp2/lib/includes/nghttp2/nghttp2ver.h

@@ -29,14 +29,14 @@
  * @macro
  * Version number of the nghttp2 library release
  */
-#defineNGHTTP2_VERSION "1.39.2"
+#defineNGHTTP2_VERSION "1.40.0"
 
 /**
  * @macro
  * Numerical representation of the version number of the nghttp2 library
  * release. This is a 24 bit number with 8 bits for major number, 8 bits
  * for minor and 8 bits for patch. Version 1.2.3 becomes 0x010203.
  */
-#defineNGHTTP2_VERSION_NUM0x012702
+#defineNGHTTP2_VERSION_NUM0x012800
 
 #endif/* NGHTTP2VER_H */

deps/nghttp2/lib/nghttp2_hd.c

@@ -1694,6 +1694,11 @@ static ssize_t hd_inflate_read_huff(nghttp2_hd_inflater *inflater,
 DEBUGF("inflatehd: huffman decoding failed\n");
 returnreadlen;
  }
+if (nghttp2_hd_huff_decode_failure_state(&inflater->huff_decode_ctx)) {
+DEBUGF("inflatehd: huffman decoding failed\n");
+returnNGHTTP2_ERR_HEADER_COMP;
+ }
+
 inflater->left-= (size_t)readlen;
 returnreadlen;
 }

deps/nghttp2/lib/nghttp2_hd.h

@@ -430,4 +430,10 @@ ssize_t nghttp2_hd_huff_decode(nghttp2_hd_huff_decode_context *ctx,
 nghttp2_buf*buf, constuint8_t*src,
 size_tsrclen, intfin);
 
+/*
+ * nghttp2_hd_huff_decode_failure_state returns nonzero if |ctx|
+ * indicates that huffman decoding context is in failure state.
+ */
+intnghttp2_hd_huff_decode_failure_state(nghttp2_hd_huff_decode_context*ctx);
+
 #endif/* NGHTTP2_HD_H */

deps/nghttp2/lib/nghttp2_hd_huffman.c

@@ -29,114 +29,7 @@
 #include<stdio.h>
 
 #include"nghttp2_hd.h"
-
-/*
- * Encodes huffman code |sym| into |*dest_ptr|, whose least |rembits|
- * bits are not filled yet. The |rembits| must be in range [1, 8],
- * inclusive. At the end of the process, the |*dest_ptr| is updated
- * and points where next output should be placed. The number of
- * unfilled bits in the pointed location is returned.
- */
-staticssize_thuff_encode_sym(nghttp2_bufs*bufs, size_t*avail_ptr,
-size_trembits, constnghttp2_huff_sym*sym) {
-intrv;
-size_tnbits=sym->nbits;
-uint32_tcode=sym->code;
-
-/* We assume that sym->nbits <= 32 */
-if (rembits>nbits) {
-nghttp2_bufs_fast_orb_hold(bufs, (uint8_t)(code << (rembits-nbits)));
-return (ssize_t)(rembits-nbits);
- }
-
-if (rembits==nbits) {
-nghttp2_bufs_fast_orb(bufs, (uint8_t)code);
---*avail_ptr;
-return8;
- }
-
-nghttp2_bufs_fast_orb(bufs, (uint8_t)(code >> (nbits-rembits)));
---*avail_ptr;
-
-nbits-=rembits;
-if (nbits&0x7) {
-/* align code to MSB byte boundary */
-code <<= 8- (nbits&0x7);
- }
-
-if (*avail_ptr< (nbits+7) / 8) {
-/* slow path */
-if (nbits>24) {
-rv=nghttp2_bufs_addb(bufs, (uint8_t)(code >> 24));
-if (rv!=0) {
-returnrv;
- }
-nbits-=8;
- }
-if (nbits>16) {
-rv=nghttp2_bufs_addb(bufs, (uint8_t)(code >> 16));
-if (rv!=0) {
-returnrv;
- }
-nbits-=8;
- }
-if (nbits>8) {
-rv=nghttp2_bufs_addb(bufs, (uint8_t)(code >> 8));
-if (rv!=0) {
-returnrv;
- }
-nbits-=8;
- }
-if (nbits==8) {
-rv=nghttp2_bufs_addb(bufs, (uint8_t)code);
-if (rv!=0) {
-returnrv;
- }
-*avail_ptr=nghttp2_bufs_cur_avail(bufs);
-return8;
- }
-
-rv=nghttp2_bufs_addb_hold(bufs, (uint8_t)code);
-if (rv!=0) {
-returnrv;
- }
-*avail_ptr=nghttp2_bufs_cur_avail(bufs);
-return (ssize_t)(8-nbits);
- }
-
-/* fast path, since most code is less than 8 */
-if (nbits<8) {
-nghttp2_bufs_fast_addb_hold(bufs, (uint8_t)code);
-*avail_ptr=nghttp2_bufs_cur_avail(bufs);
-return (ssize_t)(8-nbits);
- }
-
-/* handle longer code path */
-if (nbits>24) {
-nghttp2_bufs_fast_addb(bufs, (uint8_t)(code >> 24));
-nbits-=8;
- }
-
-if (nbits>16) {
-nghttp2_bufs_fast_addb(bufs, (uint8_t)(code >> 16));
-nbits-=8;
- }
-
-if (nbits>8) {
-nghttp2_bufs_fast_addb(bufs, (uint8_t)(code >> 8));
-nbits-=8;
- }
-
-if (nbits==8) {
-nghttp2_bufs_fast_addb(bufs, (uint8_t)code);
-*avail_ptr=nghttp2_bufs_cur_avail(bufs);
-return8;
- }
-
-nghttp2_bufs_fast_addb_hold(bufs, (uint8_t)code);
-*avail_ptr=nghttp2_bufs_cur_avail(bufs);
-return (ssize_t)(8-nbits);
-}
+#include"nghttp2_net.h"
 
 size_tnghttp2_hd_huff_encode_count(constuint8_t*src, size_tlen) {
 size_ti;
@@ -151,81 +44,101 @@ size_t nghttp2_hd_huff_encode_count(const uint8_t *src, size_t len) {
 
 intnghttp2_hd_huff_encode(nghttp2_bufs*bufs, constuint8_t*src,
 size_tsrclen) {
-intrv;
-ssize_trembits=8;
-size_ti;
+constnghttp2_huff_sym*sym;
+constuint8_t*end=src+srclen;
+uint64_tcode=0;
+uint32_tx;
+size_tnbits=0;
 size_tavail;
+intrv;
 
 avail=nghttp2_bufs_cur_avail(bufs);
 
-for (i=0; i<srclen; ++i) {
-constnghttp2_huff_sym*sym=&huff_sym_table[src[i]];
-if (rembits==8) {
-if (avail) {
-nghttp2_bufs_fast_addb_hold(bufs, 0);
- } else {
-rv=nghttp2_bufs_addb_hold(bufs, 0);
-if (rv!=0) {
-returnrv;
- }
-avail=nghttp2_bufs_cur_avail(bufs);
+for (; src!=end;) {
+sym=&huff_sym_table[*src++];
+code |= (uint64_t)sym->code << (32-nbits);
+nbits+=sym->nbits;
+if (nbits<32) {
+continue;
+ }
+if (avail >= 4) {
+x=htonl((uint32_t)(code >> 32));
+memcpy(bufs->cur->buf.last, &x, 4);
+bufs->cur->buf.last+=4;
+avail-=4;
+code <<= 32;
+nbits-=32;
+continue;
+ }
+
+for (; nbits >= 8;) {
+rv=nghttp2_bufs_addb(bufs, (uint8_t)(code >> 56));
+if (rv!=0) {
+returnrv;
  }
+code <<= 8;
+nbits-=8;
  }
-rembits=huff_encode_sym(bufs, &avail, (size_t)rembits, sym);
-if (rembits<0) {
-return (int)rembits;
+
+avail=nghttp2_bufs_cur_avail(bufs);
+ }
+
+for (; nbits >= 8;) {
+rv=nghttp2_bufs_addb(bufs, (uint8_t)(code >> 56));
+if (rv!=0) {
+returnrv;
  }
+code <<= 8;
+nbits-=8;
  }
-/* 256 is special terminal symbol, pad with its prefix */
-if (rembits<8) {
-/* if rembits < 8, we should have at least 1 buffer space
- available */
-constnghttp2_huff_sym*sym=&huff_sym_table[256];
-assert(avail);
-/* Caution we no longer adjust avail here */
-nghttp2_bufs_fast_orb(
-bufs, (uint8_t)(sym->code >> (sym->nbits- (size_t)rembits)));
+
+if (nbits) {
+rv=nghttp2_bufs_addb(
+bufs, (uint8_t)((uint8_t)(code >> 56) | ((1 << (8-nbits)) -1)));
+if (rv!=0) {
+returnrv;
+ }
  }
 
 return0;
 }
 
 voidnghttp2_hd_huff_decode_context_init(nghttp2_hd_huff_decode_context*ctx) {
-ctx->state=0;
-ctx->accept=1;
+ctx->fstate=NGHTTP2_HUFF_ACCEPTED;
 }
 
 ssize_tnghttp2_hd_huff_decode(nghttp2_hd_huff_decode_context*ctx,
 nghttp2_buf*buf, constuint8_t*src,
 size_tsrclen, intfinal) {
-size_ti;
+constuint8_t*end=src+srclen;
+nghttp2_huff_decodenode= {ctx->fstate, 0};
+constnghttp2_huff_decode*t=&node;
+uint8_tc;
 
 /* We use the decoding algorithm described in
  http://graphics.ics.uci.edu/pub/Prefix.pdf */
-for (i=0; i<srclen; ++i) {
-constnghttp2_huff_decode*t;
-
-t=&huff_decode_table[ctx->state][src[i] >> 4];
-if (t->flags&NGHTTP2_HUFF_FAIL) {
-returnNGHTTP2_ERR_HEADER_COMP;
- }
-if (t->flags&NGHTTP2_HUFF_SYM) {
+for (; src!=end;) {
+c=*src++;
+t=&huff_decode_table[t->fstate&0x1ff][c >> 4];
+if (t->fstate&NGHTTP2_HUFF_SYM) {
 *buf->last++=t->sym;
  }
 
-t=&huff_decode_table[t->state][src[i] &0xf];
-if (t->flags&NGHTTP2_HUFF_FAIL) {
-returnNGHTTP2_ERR_HEADER_COMP;
- }
-if (t->flags&NGHTTP2_HUFF_SYM) {
+t=&huff_decode_table[t->fstate&0x1ff][c&0xf];
+if (t->fstate&NGHTTP2_HUFF_SYM) {
 *buf->last++=t->sym;
  }
-
-ctx->state=t->state;
-ctx->accept= (t->flags&NGHTTP2_HUFF_ACCEPTED) !=0;
  }
-if (final&& !ctx->accept) {
+
+ctx->fstate=t->fstate;
+
+if (final&& !(ctx->fstate&NGHTTP2_HUFF_ACCEPTED)) {
 returnNGHTTP2_ERR_HEADER_COMP;
  }
-return (ssize_t)i;
+
+return (ssize_t)srclen;
+}
+
+intnghttp2_hd_huff_decode_failure_state(nghttp2_hd_huff_decode_context*ctx) {
+returnctx->fstate==0x100;
 }

deps/nghttp2/lib/nghttp2_hd_huffman.h

@@ -34,34 +34,29 @@
 typedefenum {
 /* FSA accepts this state as the end of huffman encoding
  sequence. */
-NGHTTP2_HUFF_ACCEPTED=1,
+NGHTTP2_HUFF_ACCEPTED=1 << 14,
 /* This state emits symbol */
-NGHTTP2_HUFF_SYM= (1 << 1),
-/* If state machine reaches this state, decoding fails. */
-NGHTTP2_HUFF_FAIL= (1 << 2)
+NGHTTP2_HUFF_SYM=1 << 15,
 } nghttp2_huff_decode_flag;
 
 typedefstruct {
-/* huffman decoding state, which is actually the node ID of internal
- huffman tree. We have 257 leaf nodes, but they are identical to
- root node other than emitting a symbol, so we have 256 internal
- nodes [1..255], inclusive. */
-uint8_tstate;
-/* bitwise OR of zero or more of the nghttp2_huff_decode_flag */
-uint8_tflags;
+/* fstate is the current huffman decoding state, which is actually
+ the node ID of internal huffman tree with
+ nghttp2_huff_decode_flag OR-ed. We have 257 leaf nodes, but they
+ are identical to root node other than emitting a symbol, so we
+ have 256 internal nodes [1..255], inclusive. The node ID 256 is
+ a special node and it is a terminal state that means decoding
+ failed. */
+uint16_tfstate;
 /* symbol if NGHTTP2_HUFF_SYM flag set */
 uint8_tsym;
 } nghttp2_huff_decode;
 
 typedefnghttp2_huff_decodehuff_decode_table_type[16];
 
 typedefstruct {
-/* Current huffman decoding state. We stripped leaf nodes, so the
- value range is [0..255], inclusive. */
-uint8_tstate;
-/* nonzero if we can say that the decoding process succeeds at this
- state */
-uint8_taccept;
+/* fstate is the current huffman decoding state. */
+uint16_tfstate;
 } nghttp2_hd_huff_decode_context;
 
 typedefstruct {