Rewrite static header table handling

We rewrite static header table handling in nghttp2_hd.c.  We expand
nghttp2_token to include all static header table entries, and fully
use them in header compression and decompression.  The lookup function
is now located in nghttp2_hd.c.  We add new nghttp2_hd_inflate_hd2()
function to export token value for header name, then we pass it to
nghttp2_http_on_header function, so that we don't have to look up
token there.  We carefully set enum value of token to static table
index, so looking up static table is now O(1), assuming we have token.

genlibtokenlookup.py

 #!/usr/bin/env python
 
 HEADERS = [
-    ':authority',
-    ':method',
-    ':path',
-    ':scheme',
-    ':status',
-    "content-length",
-    "host",
-    "te",
-    'connection',
-    'keep-alive',
-    'proxy-connection',
-    'transfer-encoding',
-    'upgrade'
+    (':authority', 0),
+    (':method', 1),
+    (':method', 2),
+    (':path', 3),
+    (':path', 4),
+    (':scheme', 5),
+    (':scheme', 6),
+    (':status', 7),
+    (':status', 8),
+    (':status', 9),
+    (':status', 10),
+    (':status', 11),
+    (':status', 12),
+    (':status', 13),
+    ('accept-charset', 14),
+    ('accept-encoding', 15),
+    ('accept-language', 16),
+    ('accept-ranges', 17),
+    ('accept', 18),
+    ('access-control-allow-origin', 19),
+    ('age', 20),
+    ('allow', 21),
+    ('authorization', 22),
+    ('cache-control', 23),
+    ('content-disposition', 24),
+    ('content-encoding', 25),
+    ('content-language', 26),
+    ('content-length', 27),
+    ('content-location', 28),
+    ('content-range', 29),
+    ('content-type', 30),
+    ('cookie', 31),
+    ('date', 32),
+    ('etag', 33),
+    ('expect', 34),
+    ('expires', 35),
+    ('from', 36),
+    ('host', 37),
+    ('if-match', 38),
+    ('if-modified-since', 39),
+    ('if-none-match', 40),
+    ('if-range', 41),
+    ('if-unmodified-since', 42),
+    ('last-modified', 43),
+    ('link', 44),
+    ('location', 45),
+    ('max-forwards', 46),
+    ('proxy-authenticate', 47),
+    ('proxy-authorization', 48),
+    ('range', 49),
+    ('referer', 50),
+    ('refresh', 51),
+    ('retry-after', 52),
+    ('server', 53),
+    ('set-cookie', 54),
+    ('strict-transport-security', 55),
+    ('transfer-encoding', 56),
+    ('user-agent', 57),
+    ('vary', 58),
+    ('via', 59),
+    ('www-authenticate', 60),
+    ('te', None),
+    ('connection', None),
+    ('keep-alive',None),
+    ('proxy-connection', None),
+    ('upgrade', None),
 ]
 
 def to_enum_hd(k):
@@ -27,7 +80,7 @@ def to_enum_hd(k):
 
 def build_header(headers):
     res = {}
-    for k in headers:
+    for k, _ in headers:
         size = len(k)
         if size not in res:
             res[size] = {}
@@ -40,18 +93,20 @@ def build_header(headers):
     return res
 
 def gen_enum():
-    print '''\
-typedef enum {'''
-    for k in sorted(HEADERS):
-        print '''\
-  {},'''.format(to_enum_hd(k))
-    print '''\
-  NGHTTP2_TOKEN_MAXIDX,
-} nghttp2_token;'''
+    name = ''
+    print 'typedef enum {'
+    for k, token in HEADERS:
+        if token is None:
+            print '  {},'.format(to_enum_hd(k))
+        else:
+            if name != k:
+                name = k
+                print '  {} = {},'.format(to_enum_hd(k), token)
+    print '} nghttp2_token;'
 
 def gen_index_header():
     print '''\
-static int lookup_token(const uint8_t *name, size_t namelen) {
+static inline int lookup_token(const uint8_t *name, size_t namelen) {
   switch (namelen) {'''
     b = build_header(HEADERS)
     for size in sorted(b.keys()):
@@ -66,7 +121,7 @@ static int lookup_token(const uint8_t *name, size_t namelen) {
     case '{}':'''.format(c)
             for k in headers:
                 print '''\
-      if (streq("{}", name, {})) {{
+      if (lstreq("{}", name, {})) {{
         return {};
       }}'''.format(k[:-1], size - 1, to_enum_hd(k))
             print '''\

lib/nghttp2_hd.h

@@ -49,7 +49,67 @@
 #define NGHTTP2_HD_DEFAULT_MAX_DEFLATE_BUFFER_SIZE (1 << 12)
 
 /* Exported for unit test */
-extern const size_t NGHTTP2_STATIC_TABLE_LENGTH;
+#define NGHTTP2_STATIC_TABLE_LENGTH 61
+
+typedef enum {
+  NGHTTP2_TOKEN__AUTHORITY = 0,
+  NGHTTP2_TOKEN__METHOD = 1,
+  NGHTTP2_TOKEN__PATH = 3,
+  NGHTTP2_TOKEN__SCHEME = 5,
+  NGHTTP2_TOKEN__STATUS = 7,
+  NGHTTP2_TOKEN_ACCEPT_CHARSET = 14,
+  NGHTTP2_TOKEN_ACCEPT_ENCODING = 15,
+  NGHTTP2_TOKEN_ACCEPT_LANGUAGE = 16,
+  NGHTTP2_TOKEN_ACCEPT_RANGES = 17,
+  NGHTTP2_TOKEN_ACCEPT = 18,
+  NGHTTP2_TOKEN_ACCESS_CONTROL_ALLOW_ORIGIN = 19,
+  NGHTTP2_TOKEN_AGE = 20,
+  NGHTTP2_TOKEN_ALLOW = 21,
+  NGHTTP2_TOKEN_AUTHORIZATION = 22,
+  NGHTTP2_TOKEN_CACHE_CONTROL = 23,
+  NGHTTP2_TOKEN_CONTENT_DISPOSITION = 24,
+  NGHTTP2_TOKEN_CONTENT_ENCODING = 25,
+  NGHTTP2_TOKEN_CONTENT_LANGUAGE = 26,
+  NGHTTP2_TOKEN_CONTENT_LENGTH = 27,
+  NGHTTP2_TOKEN_CONTENT_LOCATION = 28,
+  NGHTTP2_TOKEN_CONTENT_RANGE = 29,
+  NGHTTP2_TOKEN_CONTENT_TYPE = 30,
+  NGHTTP2_TOKEN_COOKIE = 31,
+  NGHTTP2_TOKEN_DATE = 32,
+  NGHTTP2_TOKEN_ETAG = 33,
+  NGHTTP2_TOKEN_EXPECT = 34,
+  NGHTTP2_TOKEN_EXPIRES = 35,
+  NGHTTP2_TOKEN_FROM = 36,
+  NGHTTP2_TOKEN_HOST = 37,
+  NGHTTP2_TOKEN_IF_MATCH = 38,
+  NGHTTP2_TOKEN_IF_MODIFIED_SINCE = 39,
+  NGHTTP2_TOKEN_IF_NONE_MATCH = 40,
+  NGHTTP2_TOKEN_IF_RANGE = 41,
+  NGHTTP2_TOKEN_IF_UNMODIFIED_SINCE = 42,
+  NGHTTP2_TOKEN_LAST_MODIFIED = 43,
+  NGHTTP2_TOKEN_LINK = 44,
+  NGHTTP2_TOKEN_LOCATION = 45,
+  NGHTTP2_TOKEN_MAX_FORWARDS = 46,
+  NGHTTP2_TOKEN_PROXY_AUTHENTICATE = 47,
+  NGHTTP2_TOKEN_PROXY_AUTHORIZATION = 48,
+  NGHTTP2_TOKEN_RANGE = 49,
+  NGHTTP2_TOKEN_REFERER = 50,
+  NGHTTP2_TOKEN_REFRESH = 51,
+  NGHTTP2_TOKEN_RETRY_AFTER = 52,
+  NGHTTP2_TOKEN_SERVER = 53,
+  NGHTTP2_TOKEN_SET_COOKIE = 54,
+  NGHTTP2_TOKEN_STRICT_TRANSPORT_SECURITY = 55,
+  NGHTTP2_TOKEN_TRANSFER_ENCODING = 56,
+  NGHTTP2_TOKEN_USER_AGENT = 57,
+  NGHTTP2_TOKEN_VARY = 58,
+  NGHTTP2_TOKEN_VIA = 59,
+  NGHTTP2_TOKEN_WWW_AUTHENTICATE = 60,
+  NGHTTP2_TOKEN_TE,
+  NGHTTP2_TOKEN_CONNECTION,
+  NGHTTP2_TOKEN_KEEP_ALIVE,
+  NGHTTP2_TOKEN_PROXY_CONNECTION,
+  NGHTTP2_TOKEN_UPGRADE,
+} nghttp2_token;
 
 typedef enum {
   NGHTTP2_HD_FLAG_NONE = 0,
@@ -67,18 +127,14 @@ typedef enum {
 
 typedef struct {
   nghttp2_nv nv;
-  uint32_t name_hash;
-  uint32_t value_hash;
+  /* nghttp2_token value for nv.name.  It could be -1 if we have no
+     token for that header field name. */
+  int token;
   /* Reference count */
   uint8_t ref;
   uint8_t flags;
 } nghttp2_hd_entry;
 
-typedef struct {
-  nghttp2_hd_entry ent;
-  size_t index;
-} nghttp2_hd_static_entry;
-
 typedef struct {
   nghttp2_hd_entry **buffer;
   size_t mask;
@@ -182,9 +238,8 @@ struct nghttp2_hd_inflater {
  * set in the |flags|, the content pointed by the |name| with length
  * |namelen| is copied. Likewise, if NGHTTP2_HD_FLAG_VALUE_ALLOC bit
  * set in the |flags|, the content pointed by the |value| with length
- * |valuelen| is copied.  The |name_hash| and |value_hash| are hash
- * value for |name| and |value| respectively.  The hash function is
- * defined in nghttp2_hd.c.
+ * |valuelen| is copied.  The |token| is enum number looked up by
+ * |name|.  It could be -1 if we don't have that enum value.
  *
  * This function returns 0 if it succeeds, or one of the following
  * negative error codes:
@@ -194,8 +249,7 @@ struct nghttp2_hd_inflater {
  */
 int nghttp2_hd_entry_init(nghttp2_hd_entry *ent, uint8_t flags, uint8_t *name,
                           size_t namelen, uint8_t *value, size_t valuelen,
-                          uint32_t name_hash, uint32_t value_hash,
-                          nghttp2_mem *mem);
+                          int token, nghttp2_mem *mem);
 
 void nghttp2_hd_entry_free(nghttp2_hd_entry *ent, nghttp2_mem *mem);
 
@@ -277,6 +331,18 @@ int nghttp2_hd_inflate_init(nghttp2_hd_inflater *inflater, nghttp2_mem *mem);
  */
 void nghttp2_hd_inflate_free(nghttp2_hd_inflater *inflater);
 
+/*
+ * Similar to nghttp2_hd_inflate_hd(), but this takes additional
+ * output parameter |token|.  On successful header emission, it
+ * contains nghttp2_token value for nv_out->name.  It could be -1 if
+ * we don't have enum value for the name.  Other than that return
+ * values and semantics are the same as nghttp2_hd_inflate_hd().
+ */
+ssize_t nghttp2_hd_inflate_hd2(nghttp2_hd_inflater *inflater,
+                               nghttp2_nv *nv_out, int *inflate_flags,
+                               int *token, uint8_t *in, size_t inlen,
+                               int in_final);
+
 /* For unittesting purpose */
 int nghttp2_hd_emit_indname_block(nghttp2_bufs *bufs, size_t index,
                                   nghttp2_nv *nv, int indexing_mode);

lib/nghttp2_helper.h

@@ -29,12 +29,16 @@
 #include <config.h>
 #endif /* HAVE_CONFIG_H */
 
+#include <string.h>
+
 #include <nghttp2/nghttp2.h>
 #include "nghttp2_mem.h"
 
 #define nghttp2_min(A, B) ((A) < (B) ? (A) : (B))
 #define nghttp2_max(A, B) ((A) > (B) ? (A) : (B))
 
+#define lstreq(A, B, N) ((sizeof((A)) - 1) == (N) && memcmp((A), (B), (N)) == 0)
+
 /*
  * Copies 2 byte unsigned integer |n| in host byte order to |buf| in
  * network byte order.

lib/nghttp2_http.c

@@ -28,11 +28,8 @@
 #include <assert.h>
 #include <stdio.h>
 
-static int memeq(const void *a, const void *b, size_t n) {
-  return memcmp(a, b, n) == 0;
-}
-
-#define streq(A, B, N) ((sizeof((A)) - 1) == (N) && memeq((A), (B), (N)))
+#include "nghttp2_hd.h"
+#include "nghttp2_helper.h"
 
 static char downcase(char c) {
   return 'A' <= c && c <= 'Z' ? (c - 'A' + 'a') : c;
@@ -50,129 +47,7 @@ static int memieq(const void *a, const void *b, size_t n) {
   return 1;
 }
 
-#define strieq(A, B, N) ((sizeof((A)) - 1) == (N) && memieq((A), (B), (N)))
-
-typedef enum {
-  NGHTTP2_TOKEN__AUTHORITY,
-  NGHTTP2_TOKEN__METHOD,
-  NGHTTP2_TOKEN__PATH,
-  NGHTTP2_TOKEN__SCHEME,
-  NGHTTP2_TOKEN__STATUS,
-  NGHTTP2_TOKEN_CONNECTION,
-  NGHTTP2_TOKEN_CONTENT_LENGTH,
-  NGHTTP2_TOKEN_HOST,
-  NGHTTP2_TOKEN_KEEP_ALIVE,
-  NGHTTP2_TOKEN_PROXY_CONNECTION,
-  NGHTTP2_TOKEN_TE,
-  NGHTTP2_TOKEN_TRANSFER_ENCODING,
-  NGHTTP2_TOKEN_UPGRADE,
-  NGHTTP2_TOKEN_MAXIDX,
-} nghttp2_token;
-
-/*
- * This function was generated by genlibtokenlookup.py.  Inspired by
- * h2o header lookup.  https://github.com/h2o/h2o
- */
-static int lookup_token(const uint8_t *name, size_t namelen) {
-  switch (namelen) {
-  case 2:
-    switch (name[1]) {
-    case 'e':
-      if (streq("t", name, 1)) {
-        return NGHTTP2_TOKEN_TE;
-      }
-      break;
-    }
-    break;
-  case 4:
-    switch (name[3]) {
-    case 't':
-      if (streq("hos", name, 3)) {
-        return NGHTTP2_TOKEN_HOST;
-      }
-      break;
-    }
-    break;
-  case 5:
-    switch (name[4]) {
-    case 'h':
-      if (streq(":pat", name, 4)) {
-        return NGHTTP2_TOKEN__PATH;
-      }
-      break;
-    }
-    break;
-  case 7:
-    switch (name[6]) {
-    case 'd':
-      if (streq(":metho", name, 6)) {
-        return NGHTTP2_TOKEN__METHOD;
-      }
-      break;
-    case 'e':
-      if (streq(":schem", name, 6)) {
-        return NGHTTP2_TOKEN__SCHEME;
-      }
-      if (streq("upgrad", name, 6)) {
-        return NGHTTP2_TOKEN_UPGRADE;
-      }
-      break;
-    case 's':
-      if (streq(":statu", name, 6)) {
-        return NGHTTP2_TOKEN__STATUS;
-      }
-      break;
-    }
-    break;
-  case 10:
-    switch (name[9]) {
-    case 'e':
-      if (streq("keep-aliv", name, 9)) {
-        return NGHTTP2_TOKEN_KEEP_ALIVE;
-      }
-      break;
-    case 'n':
-      if (streq("connectio", name, 9)) {
-        return NGHTTP2_TOKEN_CONNECTION;
-      }
-      break;
-    case 'y':
-      if (streq(":authorit", name, 9)) {
-        return NGHTTP2_TOKEN__AUTHORITY;
-      }
-      break;
-    }
-    break;
-  case 14:
-    switch (name[13]) {
-    case 'h':
-      if (streq("content-lengt", name, 13)) {
-        return NGHTTP2_TOKEN_CONTENT_LENGTH;
-      }
-      break;
-    }
-    break;
-  case 16:
-    switch (name[15]) {
-    case 'n':
-      if (streq("proxy-connectio", name, 15)) {
-        return NGHTTP2_TOKEN_PROXY_CONNECTION;
-      }
-      break;
-    }
-    break;
-  case 17:
-    switch (name[16]) {
-    case 'g':
-      if (streq("transfer-encodin", name, 16)) {
-        return NGHTTP2_TOKEN_TRANSFER_ENCODING;
-      }
-      break;
-    }
-    break;
-  }
-  return -1;
-}
+#define lstrieq(A, B, N) ((sizeof((A)) - 1) == (N) && memieq((A), (B), (N)))
 
 static int64_t parse_uint(const uint8_t *s, size_t len) {
   int64_t n = 0;
@@ -238,9 +113,7 @@ static int check_path(nghttp2_stream *stream) {
 }
 
 static int http_request_on_header(nghttp2_stream *stream, nghttp2_nv *nv,
-                                  int trailer) {
-  int token;
-
+                                  int token, int trailer) {
   if (nv->name[0] == ':') {
     if (trailer ||
         (stream->http_flags & NGHTTP2_HTTP_FLAG_PSEUDO_HEADER_DISALLOWED)) {
@@ -248,8 +121,6 @@ static int http_request_on_header(nghttp2_stream *stream, nghttp2_nv *nv,
     }
   }
 
-  token = lookup_token(nv->name, nv->namelen);
-
   switch (token) {
   case NGHTTP2_TOKEN__AUTHORITY:
     if (!check_pseudo_header(stream, nv, NGHTTP2_HTTP_FLAG__AUTHORITY)) {
@@ -262,14 +133,14 @@ static int http_request_on_header(nghttp2_stream *stream, nghttp2_nv *nv,
     }
     switch (nv->valuelen) {
     case 4:
-      if (streq("HEAD", nv->value, nv->valuelen)) {
+      if (lstreq("HEAD", nv->value, nv->valuelen)) {
         stream->http_flags |= NGHTTP2_HTTP_FLAG_METH_HEAD;
       }
       break;
     case 7:
       switch (nv->value[6]) {
       case 'T':
-        if (streq("CONNECT", nv->value, nv->valuelen)) {
+        if (lstreq("CONNECT", nv->value, nv->valuelen)) {
           if (stream->stream_id % 2 == 0) {
             /* we won't allow CONNECT for push */
             return NGHTTP2_ERR_HTTP_HEADER;
@@ -282,7 +153,7 @@ static int http_request_on_header(nghttp2_stream *stream, nghttp2_nv *nv,
         }
         break;
       case 'S':
-        if (streq("OPTIONS", nv->value, nv->valuelen)) {
+        if (lstreq("OPTIONS", nv->value, nv->valuelen)) {
           stream->http_flags |= NGHTTP2_HTTP_FLAG_METH_OPTIONS;
         }
         break;
@@ -338,7 +209,7 @@ static int http_request_on_header(nghttp2_stream *stream, nghttp2_nv *nv,
   case NGHTTP2_TOKEN_UPGRADE:
     return NGHTTP2_ERR_HTTP_HEADER;
   case NGHTTP2_TOKEN_TE:
-    if (!strieq("trailers", nv->value, nv->valuelen)) {
+    if (!lstrieq("trailers", nv->value, nv->valuelen)) {
       return NGHTTP2_ERR_HTTP_HEADER;
     }
     break;
@@ -356,9 +227,7 @@ static int http_request_on_header(nghttp2_stream *stream, nghttp2_nv *nv,
 }
 
 static int http_response_on_header(nghttp2_stream *stream, nghttp2_nv *nv,
-                                   int trailer) {
-  int token;
-
+                                   int token, int trailer) {
   if (nv->name[0] == ':') {
     if (trailer ||
         (stream->http_flags & NGHTTP2_HTTP_FLAG_PSEUDO_HEADER_DISALLOWED)) {
@@ -366,8 +235,6 @@ static int http_response_on_header(nghttp2_stream *stream, nghttp2_nv *nv,
     }
   }
 
-  token = lookup_token(nv->name, nv->namelen);
-
   switch (token) {
   case NGHTTP2_TOKEN__STATUS: {
     if (!check_pseudo_header(stream, nv, NGHTTP2_HTTP_FLAG__STATUS)) {
@@ -400,7 +267,7 @@ static int http_response_on_header(nghttp2_stream *stream, nghttp2_nv *nv,
   case NGHTTP2_TOKEN_UPGRADE:
     return NGHTTP2_ERR_HTTP_HEADER;
   case NGHTTP2_TOKEN_TE:
-    if (!strieq("trailers", nv->value, nv->valuelen)) {
+    if (!lstrieq("trailers", nv->value, nv->valuelen)) {
       return NGHTTP2_ERR_HTTP_HEADER;
     }
     break;
@@ -418,7 +285,8 @@ static int http_response_on_header(nghttp2_stream *stream, nghttp2_nv *nv,
 }
 
 int nghttp2_http_on_header(nghttp2_session *session, nghttp2_stream *stream,
-                           nghttp2_frame *frame, nghttp2_nv *nv, int trailer) {
+                           nghttp2_frame *frame, nghttp2_nv *nv, int token,
+                           int trailer) {
   /* We are strict for pseudo header field.  One bad character should
      lead to fail.  OTOH, we should be a bit forgiving for regular
      headers, since existing public internet has so much illegal
@@ -458,10 +326,10 @@ int nghttp2_http_on_header(nghttp2_session *session, nghttp2_stream *stream,
   }
 
   if (session->server || frame->hd.type == NGHTTP2_PUSH_PROMISE) {
-    return http_request_on_header(stream, nv, trailer);
+    return http_request_on_header(stream, nv, token, trailer);
   }
 
-  return http_response_on_header(stream, nv, trailer);
+  return http_response_on_header(stream, nv, token, trailer);
 }
 
 int nghttp2_http_on_request_headers(nghttp2_stream *stream,
@@ -574,14 +442,15 @@ void nghttp2_http_record_request_method(nghttp2_stream *stream,
   /* TODO we should do this strictly. */
   for (i = 0; i < nvlen; ++i) {
     const nghttp2_nv *nv = &nva[i];
-    if (lookup_token(nv->name, nv->namelen) != NGHTTP2_TOKEN__METHOD) {
+    if (!(nv->namelen == 7 && nv->name[6] == 'd' &&
+          memcmp(":metho", nv->name, nv->namelen - 1) == 0)) {
       continue;
     }
-    if (streq("CONNECT", nv->value, nv->valuelen)) {
+    if (lstreq("CONNECT", nv->value, nv->valuelen)) {
       stream->http_flags |= NGHTTP2_HTTP_FLAG_METH_CONNECT;
       return;
     }
-    if (streq("HEAD", nv->value, nv->valuelen)) {
+    if (lstreq("HEAD", nv->value, nv->valuelen)) {
       stream->http_flags |= NGHTTP2_HTTP_FLAG_METH_HEAD;
       return;
     }

lib/nghttp2_http.h

@@ -36,7 +36,8 @@
 /*
  * This function is called when HTTP header field |nv| in |frame| is
  * received for |stream|.  This function will validate |nv| against
- * the current state of stream.
+ * the current state of stream.  The |token| is nghttp2_token value
+ * for nv->name, or -1 if we don't have enum value for the name.
  *
  * This function returns 0 if it succeeds, or one of the following
  * negative error codes:
@@ -48,7 +49,8 @@
  *     if it was not received because of compatibility reasons.
  */
 int nghttp2_http_on_header(nghttp2_session *session, nghttp2_stream *stream,
-                           nghttp2_frame *frame, nghttp2_nv *nv, int trailer);
+                           nghttp2_frame *frame, nghttp2_nv *nv, int token,
+                           int trailer);
 
 /*
  * This function is called when request header is received.  This

lib/nghttp2_session.c

@@ -3230,6 +3230,7 @@ static int inflate_header_block(nghttp2_session *session, nghttp2_frame *frame,
   nghttp2_stream *stream;
   nghttp2_stream *subject_stream;
   int trailer = 0;
+  int token;
 
   *readlen_ptr = 0;
   stream = nghttp2_session_get_stream(session, frame->hd.stream_id);
@@ -3245,8 +3246,8 @@ static int inflate_header_block(nghttp2_session *session, nghttp2_frame *frame,
   DEBUGF(fprintf(stderr, "recv: decoding header block %zu bytes\n", inlen));
   for (;;) {
     inflate_flags = 0;
-    proclen = nghttp2_hd_inflate_hd(&session->hd_inflater, &nv, &inflate_flags,
-                                    in, inlen, final);
+    proclen = nghttp2_hd_inflate_hd2(&session->hd_inflater, &nv, &inflate_flags,
+                                     &token, in, inlen, final);
     if (nghttp2_is_fatal((int)proclen)) {
       return (int)proclen;
     }
@@ -3281,7 +3282,7 @@ static int inflate_header_block(nghttp2_session *session, nghttp2_frame *frame,
     if (call_header_cb && (inflate_flags & NGHTTP2_HD_INFLATE_EMIT)) {
       rv = 0;
       if (subject_stream && session_enforce_http_messaging(session)) {
-        rv = nghttp2_http_on_header(session, subject_stream, frame, &nv,
+        rv = nghttp2_http_on_header(session, subject_stream, frame, &nv, token,
                                     trailer);
         if (rv == NGHTTP2_ERR_HTTP_HEADER) {
           DEBUGF(fprintf(

mkstatichdtbl.py

@@ -10,39 +10,17 @@
 from __future__ import unicode_literals
 import re, sys
 
-def hash(s):
-    h = 0
-    for c in s:
-        h = h * 31 + ord(c)
-    return h & ((1 << 32) - 1)
-
 entries = []
 for line in sys.stdin:
     m = re.match(r'(\d+)\s+(\S+)\s+(\S.*)?', line)
     val = m.group(3).strip() if m.group(3) else ''
-    entries.append((hash(m.group(2)), int(m.group(1)), m.group(2), val))
-
-entries.sort()
-
-print '/* Sorted by hash(name) and its table index */'
-print 'static nghttp2_hd_static_entry static_table[] = {'
-for ent in entries:
-    print 'MAKE_STATIC_ENT({}, "{}", "{}", {}u, {}u),'\
-        .format(ent[1] - 1, ent[2], ent[3], ent[0], hash(ent[3]))
-print '};'
-
-print ''
-
-print '/* Index to the position in static_table */'
-print 'const size_t static_table_index[] = {'
-for i in range(len(entries)):
-    for j, ent in enumerate(entries):
-        if ent[1] - 1 == i:
-            sys.stdout.write('{: <2d},'.format(j))
-            break
-    if (i + 1) % 16 == 0:
-        sys.stdout.write('\n')
-    else:
-        sys.stdout.write(' ')
-
+    entries.append((int(m.group(1)), m.group(2), val))
+
+print 'static nghttp2_hd_entry static_table[] = {'
+idx = 0
+for i, ent in enumerate(entries):
+    if entries[idx][1] != ent[1]:
+        idx = i
+    print 'MAKE_STATIC_ENT("{}", "{}", {}),'\
+        .format(ent[1], ent[2], entries[idx][0] - 1)
 print '};'