lib/hpack.c

   1 /*
   2  * lib/hpack.c
   3  *
   4  * Copyright (C) 2014 Andy Green <andy@warmcat.com>
   5  *
   6  *  This library is free software; you can redistribute it and/or
   7  *  modify it under the terms of the GNU Lesser General Public
   8  *  License as published by the Free Software Foundation:
   9  *  version 2.1 of the License.
  10  *
  11  *  This library is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  *  Lesser General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU Lesser General Public
  17  *  License along with this library; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  19  *  MA  02110-1301  USA
  20  */
  21
  22 #include "private-libwebsockets.h"
  23
  24 /*
  25  * Official static header table for HPACK
  26  *        +-------+-----------------------------+---------------+
  27           | 1     | :authority                  |               |
  28           | 2     | :method                     | GET           |
  29           | 3     | :method                     | POST          |
  30           | 4     | :path                       | /             |
  31           | 5     | :path                       | /index.html   |
  32           | 6     | :scheme                     | http          |
  33           | 7     | :scheme                     | https         |
  34           | 8     | :status                     | 200           |
  35           | 9     | :status                     | 204           |
  36           | 10    | :status                     | 206           |
  37           | 11    | :status                     | 304           |
  38           | 12    | :status                     | 400           |
  39           | 13    | :status                     | 404           |
  40           | 14    | :status                     | 500           |
  41           | 15    | accept-charset              |               |
  42           | 16    | accept-encoding             | gzip, deflate |
  43           | 17    | accept-language             |               |
  44           | 18    | accept-ranges               |               |
  45           | 19    | accept                      |               |
  46           | 20    | access-control-allow-origin |               |
  47           | 21    | age                         |               |
  48           | 22    | allow                       |               |
  49           | 23    | authorization               |               |
  50           | 24    | cache-control               |               |
  51           | 25    | content-disposition         |               |
  52           | 26    | content-encoding            |               |
  53           | 27    | content-language            |               |
  54           | 28    | content-length              |               |
  55           | 29    | content-location            |               |
  56           | 30    | content-range               |               |
  57           | 31    | content-type                |               |
  58           | 32    | cookie                      |               |
  59           | 33    | date                        |               |
  60           | 34    | etag                        |               |
  61           | 35    | expect                      |               |
  62           | 36    | expires                     |               |
  63           | 37    | from                        |               |
  64           | 38    | host                        |               |
  65           | 39    | if-match                    |               |
  66           | 40    | if-modified-since           |               |
  67           | 41    | if-none-match               |               |
  68           | 42    | if-range                    |               |
  69           | 43    | if-unmodified-since         |               |
  70           | 44    | last-modified               |               |
  71           | 45    | link                        |               |
  72           | 46    | location                    |               |
  73           | 47    | max-forwards                |               |
  74           | 48    | proxy-authenticate          |               |
  75           | 49    | proxy-authorization         |               |
  76           | 50    | range                       |               |
  77           | 51    | referer                     |               |
  78           | 52    | refresh                     |               |
  79           | 53    | retry-after                 |               |
  80           | 54    | server                      |               |
  81           | 55    | set-cookie                  |               |
  82           | 56    | strict-transport-security   |               |
  83           | 57    | transfer-encoding           |               |
  84           | 58    | user-agent                  |               |
  85           | 59    | vary                        |               |
  86           | 60    | via                         |               |
  87           | 61    | www-authenticate            |               |
  88           +-------+-----------------------------+---------------+
  89 */
  90
  91 static const unsigned char static_token[] = {
  92         0,
  93         WSI_TOKEN_HTTP_COLON_AUTHORITY,
  94         WSI_TOKEN_HTTP_COLON_METHOD,
  95         WSI_TOKEN_HTTP_COLON_METHOD,
  96         WSI_TOKEN_HTTP_COLON_PATH,
  97         WSI_TOKEN_HTTP_COLON_PATH,
  98         WSI_TOKEN_HTTP_COLON_SCHEME,
  99         WSI_TOKEN_HTTP_COLON_SCHEME,
 100         WSI_TOKEN_HTTP_COLON_STATUS,
 101         WSI_TOKEN_HTTP_COLON_STATUS,
 102         WSI_TOKEN_HTTP_COLON_STATUS,
 103         WSI_TOKEN_HTTP_COLON_STATUS,
 104         WSI_TOKEN_HTTP_COLON_STATUS,
 105         WSI_TOKEN_HTTP_COLON_STATUS,
 106         WSI_TOKEN_HTTP_COLON_STATUS,
 107         WSI_TOKEN_HTTP_ACCEPT_CHARSET,
 108         WSI_TOKEN_HTTP_ACCEPT_ENCODING,
 109         WSI_TOKEN_HTTP_ACCEPT_LANGUAGE,
 110         WSI_TOKEN_HTTP_ACCEPT_RANGES,
 111         WSI_TOKEN_HTTP_ACCEPT,
 112         WSI_TOKEN_HTTP_ACCESS_CONTROL_ALLOW_ORIGIN,
 113         WSI_TOKEN_HTTP_AGE,
 114         WSI_TOKEN_HTTP_ALLOW,
 115         WSI_TOKEN_HTTP_AUTHORIZATION,
 116         WSI_TOKEN_HTTP_CACHE_CONTROL,
 117         WSI_TOKEN_HTTP_CONTENT_DISPOSITION,
 118         WSI_TOKEN_HTTP_CONTENT_ENCODING,
 119         WSI_TOKEN_HTTP_CONTENT_LANGUAGE,
 120         WSI_TOKEN_HTTP_CONTENT_LENGTH,
 121         WSI_TOKEN_HTTP_CONTENT_LOCATION,
 122         WSI_TOKEN_HTTP_CONTENT_RANGE,
 123         WSI_TOKEN_HTTP_CONTENT_TYPE,
 124         WSI_TOKEN_HTTP_COOKIE,
 125         WSI_TOKEN_HTTP_DATE,
 126         WSI_TOKEN_HTTP_ETAG,
 127         WSI_TOKEN_HTTP_EXPECT,
 128         WSI_TOKEN_HTTP_EXPIRES,
 129         WSI_TOKEN_HTTP_FROM,
 130         WSI_TOKEN_HOST,
 131         WSI_TOKEN_HTTP_IF_MATCH,
 132         WSI_TOKEN_HTTP_IF_MODIFIED_SINCE,
 133         WSI_TOKEN_HTTP_IF_NONE_MATCH,
 134         WSI_TOKEN_HTTP_IF_RANGE,
 135         WSI_TOKEN_HTTP_IF_UNMODIFIED_SINCE,
 136         WSI_TOKEN_HTTP_LAST_MODIFIED,
 137         WSI_TOKEN_HTTP_LINK,
 138         WSI_TOKEN_HTTP_LOCATION,
 139         WSI_TOKEN_HTTP_MAX_FORWARDS,
 140         WSI_TOKEN_HTTP_PROXY_AUTHENTICATE,
 141         WSI_TOKEN_HTTP_PROXY_AUTHORIZATION,
 142         WSI_TOKEN_HTTP_RANGE,
 143         WSI_TOKEN_HTTP_REFERER,
 144         WSI_TOKEN_HTTP_REFRESH,
 145         WSI_TOKEN_HTTP_RETRY_AFTER,
 146         WSI_TOKEN_HTTP_SERVER,
 147         WSI_TOKEN_HTTP_SET_COOKIE,
 148         WSI_TOKEN_HTTP_STRICT_TRANSPORT_SECURITY,
 149         WSI_TOKEN_HTTP_TRANSFER_ENCODING,
 150         WSI_TOKEN_HTTP_USER_AGENT,
 151         WSI_TOKEN_HTTP_VARY,
 152         WSI_TOKEN_HTTP_VIA,
 153         WSI_TOKEN_HTTP_WWW_AUTHENTICATE,
 154 };
 155
 156 /* some of the entries imply values as well as header names */
 157
 158 static const char * const http2_canned[] = {
 159         "",
 160         "",
 161         "GET",
 162         "POST",
 163         "/",
 164         "/index.html",
 165         "http",
 166         "https",
 167         "200",
 168         "204",
 169         "206",
 170         "304",
 171         "400",
 172         "404",
 173         "500",
 174         "",
 175         "gzip, deflate"
 176 };
 177
 178 /* see minihuf.c */
 179
 180 #include "huftable.h"
 181
 182 static int huftable_decode(int pos, char c)
 183 {
 184         int q = pos + !!c;
 185
 186         if (lextable_terms[q >> 3] & (1 << (q & 7))) /* terminal */
 187                 return lextable[q] | 0x8000;
 188
 189         return pos + (lextable[q] << 1);
 190 }
 191
 192 static int lws_hpack_update_table_size(struct lws *wsi, int idx)
 193 {
 194         lwsl_info("hpack set table size %d\n", idx);
 195         return 0;
 196 }
 197
 198 static int lws_frag_start(struct lws *wsi, int hdr_token_idx)
 199 {
 200         struct allocated_headers * ah = wsi->u.http2.http.ah;
 201
 202         if (!hdr_token_idx)
 203                 return 1;
 204
 205         if (ah->nfrag >= ARRAY_SIZE(ah->frag_index))
 206                 return 1;
 207
 208         ah->frags[ah->nfrag].offset = ah->pos;
 209         ah->frags[ah->nfrag].len = 0;
 210         ah->frags[ah->nfrag].nfrag = 0;
 211
 212         ah->frag_index[hdr_token_idx] = ah->nfrag;
 213
 214         return 0;
 215 }
 216
 217 static int lws_frag_append(struct lws *wsi, unsigned char c)
 218 {
 219         struct allocated_headers * ah = wsi->u.http2.http.ah;
 220
 221         ah->data[ah->pos++] = c;
 222         ah->frags[ah->nfrag].len++;
 223
 224         return ah->pos >= wsi->context->max_http_header_data;
 225 }
 226
 227 static int lws_frag_end(struct lws *wsi)
 228 {
 229         if (lws_frag_append(wsi, 0))
 230                 return 1;
 231
 232         wsi->u.http2.http.ah->nfrag++;
 233         return 0;
 234 }
 235
 236 static void lws_dump_header(struct lws *wsi, int hdr)
 237 {
 238         char s[200];
 239         int len = lws_hdr_copy(wsi, s, sizeof(s) - 1, hdr);
 240         s[len] = '\0';
 241         lwsl_info("  hdr tok %d (%s) = '%s'\n", hdr, lws_token_to_string(hdr), s);
 242 }
 243
 244 static int
 245 lws_token_from_index(struct lws *wsi, int index, char **arg, int *len)
 246 {
 247         struct hpack_dynamic_table *dyn;
 248
 249         /* dynamic table only belongs to network wsi */
 250
 251         wsi = lws_http2_get_network_wsi(wsi);
 252
 253         dyn = wsi->u.http2.hpack_dyn_table;
 254
 255         if (index < ARRAY_SIZE(static_token))
 256                 return static_token[index];
 257
 258         if (!dyn)
 259                 return 0;
 260
 261         index -= ARRAY_SIZE(static_token);
 262         if (index >= dyn->num_entries)
 263                 return 0;
 264
 265         if (arg && len) {
 266                 *arg = dyn->args + dyn->entries[index].arg_offset;
 267                 *len = dyn->entries[index].arg_len;
 268         }
 269
 270         return dyn->entries[index].token;
 271 }
 272
 273 static int
 274 lws_hpack_add_dynamic_header(struct lws *wsi, int token, char *arg, int len)
 275 {
 276         struct hpack_dynamic_table *dyn;
 277         int ret = 1;
 278
 279         wsi = lws_http2_get_network_wsi(wsi);
 280         dyn = wsi->u.http2.hpack_dyn_table;
 281
 282         if (!dyn) {
 283                 dyn = lws_zalloc(sizeof(*dyn));
 284                 if (!dyn)
 285                         return 1;
 286                 wsi->u.http2.hpack_dyn_table = dyn;
 287
 288                 dyn->args = lws_malloc(1024);
 289                 if (!dyn->args)
 290                         goto bail1;
 291                 dyn->args_length = 1024;
 292                 dyn->entries = lws_malloc(sizeof(dyn->entries[0]) * 20);
 293                 if (!dyn->entries)
 294                         goto bail2;
 295                 dyn->num_entries = 20;
 296         }
 297
 298         if (dyn->next == dyn->num_entries)
 299                 return 1;
 300
 301         if (dyn->args_length - dyn->pos < len)
 302                 return 1;
 303
 304         dyn->entries[dyn->next].token = token;
 305         dyn->entries[dyn->next].arg_offset = dyn->pos;
 306         if (len)
 307                 memcpy(dyn->args + dyn->pos, arg, len);
 308         dyn->entries[dyn->next].arg_len = len;
 309
 310         lwsl_info("%s: added dynamic hdr %d, token %d (%s), len %d\n",
 311                   __func__, dyn->next, token, lws_token_to_string(token), len);
 312
 313         dyn->pos += len;
 314         dyn->next++;
 315
 316         return 0;
 317
 318 bail2:
 319         lws_free(dyn->args);
 320 bail1:
 321         lws_free(dyn);
 322         wsi->u.http2.hpack_dyn_table = NULL;
 323
 324         return ret;
 325 }
 326
 327 static int lws_write_indexed_hdr(struct lws *wsi, int idx)
 328 {
 329         const char *p;
 330         int tok = lws_token_from_index(wsi, idx, NULL, 0);
 331
 332         lwsl_info("writing indexed hdr %d (tok %d '%s')\n", idx, tok,
 333                   lws_token_to_string(tok));
 334
 335         if (lws_frag_start(wsi, tok))
 336                 return 1;
 337
 338         if (idx < ARRAY_SIZE(http2_canned)) {
 339                 p = http2_canned[idx];
 340                 while (*p)
 341                         if (lws_frag_append(wsi, *p++))
 342                                 return 1;
 343         }
 344         if (lws_frag_end(wsi))
 345                 return 1;
 346
 347         lws_dump_header(wsi, tok);
 348
 349         return 0;
 350 }
 351
 352 int lws_hpack_interpret(struct lws *wsi, unsigned char c)
 353 {
 354         unsigned int prev;
 355         unsigned char c1;
 356         int n;
 357
 358         switch (wsi->u.http2.hpack) {
 359         case HPKS_OPT_PADDING:
 360                 wsi->u.http2.padding = c;
 361                 lwsl_info("padding %d\n", c);
 362                 if (wsi->u.http2.flags & LWS_HTTP2_FLAG_PRIORITY) {
 363                         wsi->u.http2.hpack = HKPS_OPT_E_DEPENDENCY;
 364                         wsi->u.http2.hpack_m = 4;
 365                 } else
 366                         wsi->u.http2.hpack = HPKS_TYPE;
 367                 break;
 368         case HKPS_OPT_E_DEPENDENCY:
 369                 wsi->u.http2.hpack_e_dep <<= 8;
 370                 wsi->u.http2.hpack_e_dep |= c;
 371                 if (! --wsi->u.http2.hpack_m) {
 372                         lwsl_info("hpack_e_dep = 0x%x\n", wsi->u.http2.hpack_e_dep);
 373                         wsi->u.http2.hpack = HKPS_OPT_WEIGHT;
 374                 }
 375                 break;
 376         case HKPS_OPT_WEIGHT:
 377                 /* weight */
 378                 wsi->u.http2.hpack = HPKS_TYPE;
 379                 break;
 380
 381         case HPKS_TYPE:
 382
 383                 if (wsi->u.http2.count > (wsi->u.http2.length - wsi->u.http2.padding)) {
 384                         lwsl_info("padding eat\n");
 385                         break;
 386                 }
 387
 388                 if (c & 0x80) { /* indexed header field only */
 389                         /* just a possibly-extended integer */
 390                         wsi->u.http2.hpack_type = HPKT_INDEXED_HDR_7;
 391                         wsi->u.http2.header_index = c & 0x7f;
 392                         if ((c & 0x7f) == 0x7f) {
 393                                 wsi->u.http2.hpack_len = c & 0x7f;
 394                                 wsi->u.http2.hpack_m = 0;
 395                                 wsi->u.http2.hpack = HPKS_IDX_EXT;
 396                                 break;
 397                         }
 398                         if (lws_write_indexed_hdr(wsi, c & 0x7f))
 399                                 return 1;
 400                         /* stay at same state */
 401                         break;
 402                 }
 403                 if (c & 0x40) { /* literal header incr idx */
 404                         /*
 405                          * [possibly-extended hdr idx (6) | new literal hdr name]
 406                          * H + possibly-extended value length
 407                          * literal value
 408                          */
 409                         wsi->u.http2.header_index = 0;
 410                         if (c == 0x40) { /* literal name */
 411                                 wsi->u.http2.hpack_type = HPKT_LITERAL_HDR_VALUE_INCR;
 412                                 wsi->u.http2.value = 0;
 413                                 wsi->u.http2.hpack = HPKS_HLEN;
 414                                 break;
 415                         }
 416                         /* indexed name */
 417                         wsi->u.http2.hpack_type = HPKT_INDEXED_HDR_6_VALUE_INCR;
 418                         if ((c & 0x3f) == 0x3f) {
 419                                 wsi->u.http2.hpack_len = c & 0x3f;
 420                                 wsi->u.http2.hpack_m = 0;
 421                                 wsi->u.http2.hpack = HPKS_IDX_EXT;
 422                                 break;
 423                         }
 424                         wsi->u.http2.header_index = c & 0x3f;
 425                         wsi->u.http2.value = 1;
 426                         wsi->u.http2.hpack = HPKS_HLEN;
 427                         break;
 428                 }
 429                 switch(c & 0xf0) {
 430                 case 0x10: /* literal header never index */
 431                 case 0: /* literal header without indexing */
 432                         /*
 433                          * follows 0x40 except 4-bit hdr idx
 434                          * and don't add to index
 435                          */
 436                         if (c == 0) { /* literal name */
 437                                 wsi->u.http2.hpack_type = HPKT_LITERAL_HDR_VALUE;
 438                                 wsi->u.http2.hpack = HPKS_HLEN;
 439                                 wsi->u.http2.value = 0;
 440                                 break;
 441                         }
 442                         /* indexed name */
 443                         wsi->u.http2.hpack_type = HPKT_INDEXED_HDR_4_VALUE;
 444                         wsi->u.http2.header_index = 0;
 445                         if ((c & 0xf) == 0xf) {
 446                                 wsi->u.http2.hpack_len = c & 0xf;
 447                                 wsi->u.http2.hpack_m = 0;
 448                                 wsi->u.http2.hpack = HPKS_IDX_EXT;
 449                                 break;
 450                         }
 451                         wsi->u.http2.header_index = c & 0xf;
 452                         wsi->u.http2.value = 1;
 453                         wsi->u.http2.hpack = HPKS_HLEN;
 454                         break;
 455
 456                 case 0x20:
 457                 case 0x30: /* header table size update */
 458                         /* possibly-extended size value (5) */
 459                         wsi->u.http2.hpack_type = HPKT_SIZE_5;
 460                         if ((c & 0x1f) == 0x1f) {
 461                                 wsi->u.http2.hpack_len = c & 0x1f;
 462                                 wsi->u.http2.hpack_m = 0;
 463                                 wsi->u.http2.hpack = HPKS_IDX_EXT;
 464                                 break;
 465                         }
 466                         lws_hpack_update_table_size(wsi, c & 0x1f);
 467                         /* stay at HPKS_TYPE state */
 468                         break;
 469                 }
 470                 break;
 471
 472         case HPKS_IDX_EXT:
 473                 wsi->u.http2.hpack_len += (c & 0x7f) << wsi->u.http2.hpack_m;
 474                 wsi->u.http2.hpack_m += 7;
 475                 if (!(c & 0x80)) {
 476                         switch (wsi->u.http2.hpack_type) {
 477                         case HPKT_INDEXED_HDR_7:
 478                                 if (lws_write_indexed_hdr(wsi, wsi->u.http2.hpack_len))
 479                                         return 1;
 480                                 wsi->u.http2.hpack = HPKS_TYPE;
 481                                 break;
 482                         default:
 483                                 wsi->u.http2.header_index = wsi->u.http2.hpack_len;
 484                                 wsi->u.http2.value = 1;
 485                                 wsi->u.http2.hpack = HPKS_HLEN;
 486                                 break;
 487                         }
 488                 }
 489                 break;
 490
 491         case HPKS_HLEN: /* [ H | 7+ ] */
 492                 wsi->u.http2.huff = !!(c & 0x80);
 493                 wsi->u.http2.hpack_pos = 0;
 494                 wsi->u.http2.hpack_len = c & 0x7f;
 495                 if (wsi->u.http2.hpack_len < 0x7f) {
 496 pre_data:
 497                         if (wsi->u.http2.value) {
 498                                 if (lws_frag_start(wsi, lws_token_from_index(wsi,
 499                                                    wsi->u.http2.header_index,
 500                                                    NULL, NULL)))
 501                                         return 1;
 502                         } else
 503                                 wsi->u.hdr.parser_state = WSI_TOKEN_NAME_PART;
 504                         wsi->u.http2.hpack = HPKS_DATA;
 505                         break;
 506                 }
 507                 wsi->u.http2.hpack_m = 0;
 508                 wsi->u.http2.hpack = HPKS_HLEN_EXT;
 509                 break;
 510
 511         case HPKS_HLEN_EXT:
 512                 wsi->u.http2.hpack_len += (c & 0x7f) <<
 513                                         wsi->u.http2.hpack_m;
 514                 wsi->u.http2.hpack_m += 7;
 515                 if (!(c & 0x80))
 516                         goto pre_data;
 517
 518                 break;
 519
 520         case HPKS_DATA:
 521                 for (n = 0; n < 8; n++) {
 522                         if (wsi->u.http2.huff) {
 523                                 prev = wsi->u.http2.hpack_pos;
 524                                 wsi->u.http2.hpack_pos = huftable_decode(
 525                                                 wsi->u.http2.hpack_pos,
 526                                                 (c >> 7) & 1);
 527                                 c <<= 1;
 528                                 if (wsi->u.http2.hpack_pos == 0xffff)
 529                                         return 1;
 530                                 if (!(wsi->u.http2.hpack_pos & 0x8000))
 531                                         continue;
 532                                 c1 = wsi->u.http2.hpack_pos & 0x7fff;
 533                                 wsi->u.http2.hpack_pos = 0;
 534
 535                                 if (!c1 && prev == HUFTABLE_0x100_PREV)
 536                                         ; /* EOT */
 537                         } else {
 538                                 n = 8;
 539                                 c1 = c;
 540                         }
 541                         if (wsi->u.http2.value) { /* value */
 542                                 if (lws_frag_append(wsi, c1))
 543                                         return 1;
 544                         } else { /* name */
 545                                 if (lws_parse(wsi, c1))
 546                                         return 1;
 547
 548                         }
 549                 }
 550                 if (--wsi->u.http2.hpack_len == 0) {
 551
 552                         switch (wsi->u.http2.hpack_type) {
 553                         case HPKT_LITERAL_HDR_VALUE_INCR:
 554                         case HPKT_INDEXED_HDR_6_VALUE_INCR: // !!!
 555                                 if (lws_hpack_add_dynamic_header(wsi,
 556                                      lws_token_from_index(wsi,
 557                                                  wsi->u.http2.header_index,
 558                                                          NULL, NULL), NULL, 0))
 559                                         return 1;
 560                                 break;
 561                         default:
 562                                 break;
 563                         }
 564
 565                         n = 8;
 566                         if (wsi->u.http2.value) {
 567                                 if (lws_frag_end(wsi))
 568                                         return 1;
 569
 570                                 lws_dump_header(wsi, lws_token_from_index(
 571                                                 wsi, wsi->u.http2.header_index,
 572                                                 NULL, NULL));
 573                                 if (wsi->u.http2.count + wsi->u.http2.padding ==
 574                                     wsi->u.http2.length)
 575                                         wsi->u.http2.hpack = HKPS_OPT_DISCARD_PADDING;
 576                                 else
 577                                         wsi->u.http2.hpack = HPKS_TYPE;
 578                         } else { /* name */
 579                                 if (wsi->u.hdr.parser_state < WSI_TOKEN_COUNT)
 580
 581                                 wsi->u.http2.value = 1;
 582                                 wsi->u.http2.hpack = HPKS_HLEN;
 583                         }
 584                 }
 585                 break;
 586         case HKPS_OPT_DISCARD_PADDING:
 587                 lwsl_info("eating padding %x\n", c);
 588                 if (! --wsi->u.http2.padding)
 589                         wsi->u.http2.hpack = HPKS_TYPE;
 590                 break;
 591         }
 592
 593         return 0;
 594 }
 595
 596 static int lws_http2_num(int starting_bits, unsigned long num,
 597                          unsigned char **p, unsigned char *end)
 598 {
 599         int mask = (1 << starting_bits) - 1;
 600
 601         if (num < mask) {
 602                 *((*p)++) |= num;
 603                 return *p >= end;
 604         }
 605
 606         *((*p)++) |= mask;
 607         if (*p >= end)
 608                 return 1;
 609
 610         num -= mask;
 611         while (num >= 128) {
 612                 *((*p)++) = 0x80 | (num & 0x7f);
 613                 if (*p >= end)
 614                         return 1;
 615                 num >>= 7;
 616         }
 617
 618         return 0;
 619 }
 620
 621 int lws_add_http2_header_by_name(struct lws *wsi,
 622                                  const unsigned char *name,
 623                                  const unsigned char *value, int length,
 624                                  unsigned char **p, unsigned char *end)
 625 {
 626         int len;
 627
 628         lwsl_info("%s: %p  %s:%s\n", __func__, *p, name, value);
 629
 630         len = strlen((char *)name);
 631         if (len)
 632                 if (name[len - 1] == ':')
 633                         len--;
 634
 635         if (end - *p < len + length + 8)
 636                 return 1;
 637
 638         *((*p)++) = 0; /* not indexed, literal name */
 639
 640         **p = 0; /* non-HUF */
 641         if (lws_http2_num(7, len, p, end))
 642                 return 1;
 643         memcpy(*p, name, len);
 644         *p += len;
 645
 646         *(*p) = 0; /* non-HUF */
 647         if (lws_http2_num(7, length, p, end))
 648                 return 1;
 649
 650         memcpy(*p, value, length);
 651         *p += length;
 652
 653         return 0;
 654 }
 655
 656 int lws_add_http2_header_by_token(struct lws *wsi, enum lws_token_indexes token,
 657                                   const unsigned char *value, int length,
 658                                   unsigned char **p, unsigned char *end)
 659 {
 660         const unsigned char *name;
 661
 662         name = lws_token_to_string(token);
 663         if (!name)
 664                 return 1;
 665
 666         return lws_add_http2_header_by_name(wsi, name, value, length, p, end);
 667 }
 668
 669 int lws_add_http2_header_status(struct lws *wsi,
 670                                 unsigned int code, unsigned char **p,
 671                                 unsigned char *end)
 672 {
 673         unsigned char status[10];
 674         int n;
 675
 676         wsi->u.http2.send_END_STREAM = !!(code >= 400);
 677
 678         n = sprintf((char *)status, "%u", code);
 679         if (lws_add_http2_header_by_token(wsi, WSI_TOKEN_HTTP_COLON_STATUS,
 680                                           status, n, p, end))
 681
 682                 return 1;
 683
 684         return 0;
 685 }