| /* |
| * QPACK header table management (draft-ietf-quic-qpack-20) |
| * |
| * Copyright 2020 HAProxy Technologies, Frédéric Lécaille <flecaille@haproxy.com> |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining |
| * a copy of this software and associated documentation files (the |
| * "Software"), to deal in the Software without restriction, including |
| * without limitation the rights to use, copy, modify, merge, publish, |
| * distribute, sublicense, and/or sell copies of the Software, and to |
| * permit persons to whom the Software is furnished to do so, subject to |
| * the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be |
| * included in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES |
| * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
| * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
| * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| * OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| |
| #include <inttypes.h> |
| #include <stdio.h> |
| |
| #include <import/ist.h> |
| #include <haproxy/http-hdr-t.h> |
| #include <haproxy/qpack-tbl.h> |
| |
| /* static header table as in draft-ietf-quic-qpack-20 Appendix A. */ |
| const struct http_hdr qpack_sht[QPACK_SHT_SIZE] = { |
| [ 0] = { .n = IST(":authority"), .v = IST("") }, |
| [ 1] = { .n = IST(":path"), .v = IST("/") }, |
| [ 2] = { .n = IST("age"), .v = IST("0") }, |
| [ 3] = { .n = IST("content-disposition"), .v = IST("") }, |
| [ 4] = { .n = IST("content-length"), .v = IST("0") }, |
| [ 5] = { .n = IST("cookie"), .v = IST("") }, |
| [ 6] = { .n = IST("date"), .v = IST("") }, |
| [ 7] = { .n = IST("etag"), .v = IST("") }, |
| [ 8] = { .n = IST("if-modified-since"), .v = IST("") }, |
| [ 9] = { .n = IST("if-none-match"), .v = IST("") }, |
| [10] = { .n = IST("last-modified"), .v = IST("") }, |
| [11] = { .n = IST("link"), .v = IST("") }, |
| [12] = { .n = IST("location"), .v = IST("") }, |
| [13] = { .n = IST("referer"), .v = IST("") }, |
| [14] = { .n = IST("set-cookie"), .v = IST("") }, |
| [15] = { .n = IST(":method"), .v = IST("CONNECT") }, |
| [16] = { .n = IST(":method"), .v = IST("DELETE") }, |
| [17] = { .n = IST(":method"), .v = IST("GET") }, |
| [18] = { .n = IST(":method"), .v = IST("HEAD") }, |
| [19] = { .n = IST(":method"), .v = IST("OPTIONS") }, |
| [20] = { .n = IST(":method"), .v = IST("POST") }, |
| [21] = { .n = IST(":method"), .v = IST("PUT") }, |
| [22] = { .n = IST(":scheme"), .v = IST("http") }, |
| [23] = { .n = IST(":scheme"), .v = IST("https") }, |
| [24] = { .n = IST(":status"), .v = IST("103") }, |
| [25] = { .n = IST(":status"), .v = IST("200") }, |
| [26] = { .n = IST(":status"), .v = IST("304") }, |
| [27] = { .n = IST(":status"), .v = IST("404") }, |
| [28] = { .n = IST(":status"), .v = IST("503") }, |
| [29] = { .n = IST("accept"), .v = IST("*/*") }, |
| [30] = { .n = IST("accept"), .v = IST("application/dns-message") }, |
| [31] = { .n = IST("accept-encoding"), .v = IST("gzip, deflate, br") }, |
| [32] = { .n = IST("accept-ranges"), .v = IST("bytes") }, |
| [33] = { .n = IST("access-control-allow-headers"), .v = IST("cache-control") }, |
| [34] = { .n = IST("access-control-allow-headers"), .v = IST("content-type") }, |
| [35] = { .n = IST("access-control-allow-origin"), .v = IST("*") }, |
| [36] = { .n = IST("cache-control"), .v = IST("max-age=0") }, |
| [37] = { .n = IST("cache-control"), .v = IST("max-age=2592000") }, |
| [38] = { .n = IST("cache-control"), .v = IST("max-age=604800") }, |
| [39] = { .n = IST("cache-control"), .v = IST("no-cache") }, |
| [40] = { .n = IST("cache-control"), .v = IST("no-store") }, |
| [41] = { .n = IST("cache-control"), .v = IST("public, max-age=31536000") }, |
| [42] = { .n = IST("content-encoding"), .v = IST("br") }, |
| [43] = { .n = IST("content-encoding"), .v = IST("gzip") }, |
| [44] = { .n = IST("content-type"), .v = IST("application/dns-message") }, |
| [45] = { .n = IST("content-type"), .v = IST("application/javascript") }, |
| [46] = { .n = IST("content-type"), .v = IST("application/json") }, |
| [47] = { .n = IST("content-type"), .v = IST("application/" |
| "x-www-form-urlencoded") }, |
| [48] = { .n = IST("content-type"), .v = IST("image/gif") }, |
| [49] = { .n = IST("content-type"), .v = IST("image/jpeg") }, |
| [50] = { .n = IST("content-type"), .v = IST("image/png") }, |
| [51] = { .n = IST("content-type"), .v = IST("text/css") }, |
| [52] = { .n = IST("content-type"), .v = IST("text/html;" |
| " charset=utf-8") }, |
| [53] = { .n = IST("content-type"), .v = IST("text/plain") }, |
| [54] = { .n = IST("content-type"), .v = IST("text/plain;" |
| "charset=utf-8") }, |
| [55] = { .n = IST("range"), .v = IST("bytes=0-") }, |
| [56] = { .n = IST("strict-transport-security"), .v = IST("max-age=31536000") }, |
| [57] = { .n = IST("strict-transport-security"), .v = IST("max-age=31536000;" |
| " includesubdomains") }, |
| [58] = { .n = IST("strict-transport-security"), .v = IST("max-age=31536000;" |
| " includesubdomains;" |
| " preload") }, |
| [59] = { .n = IST("vary"), .v = IST("accept-encoding") }, |
| [60] = { .n = IST("vary"), .v = IST("origin") }, |
| [61] = { .n = IST("x-content-type-options"), .v = IST("nosniff") }, |
| [62] = { .n = IST("x-xss-protection"), .v = IST("1; mode=block") }, |
| [63] = { .n = IST(":status"), .v = IST("100") }, |
| [64] = { .n = IST(":status"), .v = IST("204") }, |
| [65] = { .n = IST(":status"), .v = IST("206") }, |
| [66] = { .n = IST(":status"), .v = IST("302") }, |
| [67] = { .n = IST(":status"), .v = IST("400") }, |
| [68] = { .n = IST(":status"), .v = IST("403") }, |
| [69] = { .n = IST(":status"), .v = IST("421") }, |
| [70] = { .n = IST(":status"), .v = IST("425") }, |
| [71] = { .n = IST(":status"), .v = IST("500") }, |
| [72] = { .n = IST("accept-language"), .v = IST("") }, |
| [73] = { .n = IST("access-control-allow-credentials"), .v = IST("FALSE") }, |
| [74] = { .n = IST("access-control-allow-credentials"), .v = IST("TRUE") }, |
| [75] = { .n = IST("access-control-allow-headers"), .v = IST("*") }, |
| [76] = { .n = IST("access-control-allow-methods"), .v = IST("get") }, |
| [77] = { .n = IST("access-control-allow-methods"), .v = IST("get, post, options") }, |
| [78] = { .n = IST("access-control-allow-methods"), .v = IST("options") }, |
| [79] = { .n = IST("access-control-expose-headers"), .v = IST("content-length") }, |
| [80] = { .n = IST("access-control-request-headers"), .v = IST("content-type") }, |
| [81] = { .n = IST("access-control-request-method"), .v = IST("get") }, |
| [82] = { .n = IST("access-control-request-method"), .v = IST("post") }, |
| [83] = { .n = IST("alt-svc"), .v = IST("clear") }, |
| [84] = { .n = IST("authorization"), .v = IST("") }, |
| [85] = { .n = IST("content-security-policy"), .v = IST("script-src 'none';" |
| " object-src 'none';" |
| " base-uri 'none'") }, |
| [86] = { .n = IST("early-data"), .v = IST("1") }, |
| [87] = { .n = IST("expect-ct"), .v = IST("") }, |
| [88] = { .n = IST("forwarded"), .v = IST("") }, |
| [89] = { .n = IST("if-range"), .v = IST("") }, |
| [90] = { .n = IST("origin"), .v = IST("") }, |
| [91] = { .n = IST("purpose"), .v = IST("prefetch") }, |
| [92] = { .n = IST("server"), .v = IST("") }, |
| [93] = { .n = IST("timing-allow-origin"), .v = IST("*") }, |
| [94] = { .n = IST("upgrade-insecure-requests"), .v = IST("1") }, |
| [95] = { .n = IST("user-agent"), .v = IST("") }, |
| [96] = { .n = IST("x-forwarded-for"), .v = IST("") }, |
| [97] = { .n = IST("x-frame-options"), .v = IST("deny") }, |
| [98] = { .n = IST("x-frame-options"), .v = IST("sameorigin") }, |
| }; |
| |
| struct pool_head *pool_head_qpack_tbl = NULL; |
| |
| #ifdef DEBUG_HPACK |
| /* dump the whole dynamic header table */ |
| void qpack_dht_dump(FILE *out, const struct qpack_dht *dht) |
| { |
| unsigned int i; |
| unsigned int slot; |
| char name[4096], value[4096]; |
| |
| for (i = HPACK_SHT_SIZE; i < HPACK_SHT_SIZE + dht->used; i++) { |
| slot = (qpack_get_dte(dht, i - HPACK_SHT_SIZE + 1) - dht->dte); |
| fprintf(out, "idx=%d slot=%u name=<%s> value=<%s> addr=%u-%u\n", |
| i, slot, |
| istpad(name, qpack_idx_to_name(dht, i)).ptr, |
| istpad(value, qpack_idx_to_value(dht, i)).ptr, |
| dht->dte[slot].addr, dht->dte[slot].addr+dht->dte[slot].nlen+dht->dte[slot].vlen-1); |
| } |
| } |
| |
| /* check for the whole dynamic header table consistency, abort on failures */ |
| void qpack_dht_check_consistency(const struct qpack_dht *dht) |
| { |
| unsigned slot = qpack_dht_get_tail(dht); |
| unsigned used2 = dht->used; |
| unsigned total = 0; |
| |
| if (!dht->used) |
| return; |
| |
| if (dht->front >= dht->wrap) |
| abort(); |
| |
| if (dht->used > dht->wrap) |
| abort(); |
| |
| if (dht->head >= dht->wrap) |
| abort(); |
| |
| while (used2--) { |
| total += dht->dte[slot].nlen + dht->dte[slot].vlen; |
| slot++; |
| if (slot >= dht->wrap) |
| slot = 0; |
| } |
| |
| if (total != dht->total) { |
| fprintf(stderr, "%d: total=%u dht=%u\n", __LINE__, total, dht->total); |
| abort(); |
| } |
| } |
| #endif // DEBUG_HPACK |
| |
| /* rebuild a new dynamic header table from <dht> with an unwrapped index and |
| * contents at the end. The new table is returned, the caller must not use the |
| * previous one anymore. NULL may be returned if no table could be allocated. |
| */ |
| static struct qpack_dht *qpack_dht_defrag(struct qpack_dht *dht) |
| { |
| struct qpack_dht *alt_dht; |
| uint16_t old, new; |
| uint32_t addr; |
| |
| /* Note: for small tables we could use alloca() instead but |
| * portability especially for large tables can be problematic. |
| */ |
| alt_dht = qpack_dht_alloc(); |
| if (!alt_dht) |
| return NULL; |
| |
| alt_dht->total = dht->total; |
| alt_dht->used = dht->used; |
| alt_dht->wrap = dht->used; |
| |
| new = 0; |
| addr = alt_dht->size; |
| |
| if (dht->used) { |
| /* start from the tail */ |
| old = qpack_dht_get_tail(dht); |
| do { |
| alt_dht->dte[new].nlen = dht->dte[old].nlen; |
| alt_dht->dte[new].vlen = dht->dte[old].vlen; |
| addr -= dht->dte[old].nlen + dht->dte[old].vlen; |
| alt_dht->dte[new].addr = addr; |
| |
| memcpy((void *)alt_dht + alt_dht->dte[new].addr, |
| (void *)dht + dht->dte[old].addr, |
| dht->dte[old].nlen + dht->dte[old].vlen); |
| |
| old++; |
| if (old >= dht->wrap) |
| old = 0; |
| new++; |
| } while (new < dht->used); |
| } |
| |
| alt_dht->front = alt_dht->head = new - 1; |
| |
| memcpy(dht, alt_dht, dht->size); |
| qpack_dht_free(alt_dht); |
| |
| return dht; |
| } |
| |
| /* Purges table dht until a header field of <needed> bytes fits according to |
| * the protocol (adding 32 bytes overhead). Returns non-zero on success, zero |
| * on failure (ie: table empty but still not sufficient). It must only be |
| * called when the table is not large enough to suit the new entry and there |
| * are some entries left. In case of doubt, use dht_make_room() instead. |
| */ |
| int __qpack_dht_make_room(struct qpack_dht *dht, unsigned int needed) |
| { |
| unsigned int used = dht->used; |
| unsigned int wrap = dht->wrap; |
| unsigned int tail; |
| |
| do { |
| tail = ((dht->head + 1U < used) ? wrap : 0) + dht->head + 1U - used; |
| dht->total -= dht->dte[tail].nlen + dht->dte[tail].vlen; |
| if (tail == dht->front) |
| dht->front = dht->head; |
| used--; |
| } while (used && used * 32 + dht->total + needed + 32 > dht->size); |
| |
| dht->used = used; |
| |
| /* realign if empty */ |
| if (!used) |
| dht->front = dht->head = 0; |
| |
| /* pack the table if it doesn't wrap anymore */ |
| if (dht->head + 1U >= used) |
| dht->wrap = dht->head + 1; |
| |
| /* no need to check for 'used' here as if it doesn't fit, used==0 */ |
| return needed + 32 <= dht->size; |
| } |
| |
| /* tries to insert a new header <name>:<value> in front of the current head. A |
| * negative value is returned on error. |
| */ |
| int qpack_dht_insert(struct qpack_dht *dht, struct ist name, struct ist value) |
| { |
| unsigned int used; |
| unsigned int head; |
| unsigned int prev; |
| unsigned int wrap; |
| unsigned int tail; |
| uint32_t headroom, tailroom; |
| |
| if (!qpack_dht_make_room(dht, name.len + value.len)) |
| return 0; |
| |
| /* Now there is enough room in the table, that's guaranteed by the |
| * protocol, but not necessarily where we need it. |
| */ |
| |
| used = dht->used; |
| if (!used) { |
| /* easy, the table was empty */ |
| dht->front = dht->head = 0; |
| dht->wrap = dht->used = 1; |
| dht->total = 0; |
| head = 0; |
| dht->dte[head].addr = dht->size - (name.len + value.len); |
| goto copy; |
| } |
| |
| /* compute the new head, used and wrap position */ |
| prev = head = dht->head; |
| wrap = dht->wrap; |
| tail = qpack_dht_get_tail(dht); |
| |
| used++; |
| head++; |
| |
| if (head >= wrap) { |
| /* head is leading the entries, we either need to push the |
| * table further or to loop back to released entries. We could |
| * force to loop back when at least half of the allocatable |
| * entries are free but in practice it never happens. |
| */ |
| if ((sizeof(*dht) + (wrap + 1) * sizeof(dht->dte[0]) <= dht->dte[dht->front].addr)) |
| wrap++; |
| else if (head >= used) /* there's a hole at the beginning */ |
| head = 0; |
| else { |
| /* no more room, head hits tail and the index cannot be |
| * extended, we have to realign the whole table. |
| */ |
| if (!qpack_dht_defrag(dht)) |
| return -1; |
| |
| wrap = dht->wrap + 1; |
| head = dht->head + 1; |
| prev = head - 1; |
| tail = 0; |
| } |
| } |
| else if (used >= wrap) { |
| /* we've hit the tail, we need to reorganize the index so that |
| * the head is at the end (but not necessarily move the data). |
| */ |
| if (!qpack_dht_defrag(dht)) |
| return -1; |
| |
| wrap = dht->wrap + 1; |
| head = dht->head + 1; |
| prev = head - 1; |
| tail = 0; |
| } |
| |
| /* Now we have updated head, used and wrap, we know that there is some |
| * available room at least from the protocol's perspective. This space |
| * is split in two areas : |
| * |
| * 1: if the previous head was the front cell, the space between the |
| * end of the index table and the front cell's address. |
| * 2: if the previous head was the front cell, the space between the |
| * end of the tail and the end of the table ; or if the previous |
| * head was not the front cell, the space between the end of the |
| * tail and the head's address. |
| */ |
| if (prev == dht->front) { |
| /* the area was contiguous */ |
| headroom = dht->dte[dht->front].addr - (sizeof(*dht) + wrap * sizeof(dht->dte[0])); |
| tailroom = dht->size - dht->dte[tail].addr - dht->dte[tail].nlen - dht->dte[tail].vlen; |
| } |
| else { |
| /* it's already wrapped so we can't store anything in the headroom */ |
| headroom = 0; |
| tailroom = dht->dte[prev].addr - dht->dte[tail].addr - dht->dte[tail].nlen - dht->dte[tail].vlen; |
| } |
| |
| /* We can decide to stop filling the headroom as soon as there's enough |
| * room left in the tail to suit the protocol, but tests show that in |
| * practice it almost never happens in other situations so the extra |
| * test is useless and we simply fill the headroom as long as it's |
| * available and we don't wrap. |
| */ |
| if (prev == dht->front && headroom >= name.len + value.len) { |
| /* install upfront and update ->front */ |
| dht->dte[head].addr = dht->dte[dht->front].addr - (name.len + value.len); |
| dht->front = head; |
| } |
| else if (tailroom >= name.len + value.len) { |
| dht->dte[head].addr = dht->dte[tail].addr + dht->dte[tail].nlen + dht->dte[tail].vlen + tailroom - (name.len + value.len); |
| } |
| else { |
| /* need to defragment the table before inserting upfront */ |
| dht = qpack_dht_defrag(dht); |
| wrap = dht->wrap + 1; |
| head = dht->head + 1; |
| dht->dte[head].addr = dht->dte[dht->front].addr - (name.len + value.len); |
| dht->front = head; |
| } |
| |
| dht->wrap = wrap; |
| dht->head = head; |
| dht->used = used; |
| |
| copy: |
| dht->total += name.len + value.len; |
| dht->dte[head].nlen = name.len; |
| dht->dte[head].vlen = value.len; |
| |
| memcpy((void *)dht + dht->dte[head].addr, name.ptr, name.len); |
| memcpy((void *)dht + dht->dte[head].addr + name.len, value.ptr, value.len); |
| return 0; |
| } |