RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2025-02-22 13:46:52 +00:00
Code Issues Packages Projects Releases Wiki Activity
c5396bd673
haproxy/src/hpack-dec.c

466 lines
13 KiB
C
Raw Normal View History

MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
/*
* HPACK decompressor (RFC7541)
*
* Copyright (C) 2014-2017 Willy Tarreau <willy@haproxy.org>
* Copyright (C) 2017 HAProxy Technologies
*
* 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.
*/
BUILD: use inttypes.h instead of stdint.h I found on an (old) AIX 5.1 machine that stdint.h didn't exist while inttypes.h which is expected to include it does exist and provides the desired functionalities. As explained here, stdint being just a subset of inttypes for use in freestanding environments, it's probably always OK to switch to inttypes instead: https://pubs.opengroup.org/onlinepubs/009696799/basedefs/stdint.h.html Also it's even clearer here in the autoconf doc : https://www.gnu.org/software/autoconf/manual/autoconf-2.61/html_node/Header-Portability.html "The C99 standard says that inttypes.h includes stdint.h, so there's no need to include stdint.h separately in a standard environment. Some implementations have inttypes.h but not stdint.h (e.g., Solaris 7), but we don't know of any implementation that has stdint.h but not inttypes.h"
2019-03-29 16:26:33 +00:00
#include <inttypes.h>
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
CLEANUP: include: tree-wide alphabetical sort of include files This patch fixes all the leftovers from the include cleanup campaign. There were not that many (~400 entries in ~150 files) but it was definitely worth doing it as it revealed a few duplicates.
2020-06-09 07:07:15 +00:00
#include <import/ist.h>
#include <haproxy/chunk.h>
#include <haproxy/h2.h>
REORG: include: move hpack*.h to haproxy/ and split hpack-tbl The various hpack files are self-contained, but hpack-tbl was one of those showing difficulties when pools were added because that began to add quite some dependencies. Now when built in standalone mode, it still uses the bare minimum pool definitions and doesn't require to know the prototypes anymore when only the structures are needed. Thus the files were moved verbatim except for hpack-tbl which was split between types and prototypes.
2020-06-03 07:09:57 +00:00
#include <haproxy/hpack-dec.h>
#include <haproxy/hpack-huff.h>
#include <haproxy/hpack-tbl.h>
CLEANUP: include: tree-wide alphabetical sort of include files This patch fixes all the leftovers from the include cleanup campaign. There were not that many (~400 entries in ~150 files) but it was definitely worth doing it as it revealed a few duplicates.
2020-06-09 07:07:15 +00:00
#include <haproxy/tools.h>
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
#if defined(DEBUG_HPACK)
#define hpack_debug_printf printf
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
#define hpack_debug_hexdump debug_hexdump
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
#else
#define hpack_debug_printf(...) do { } while (0)
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
#define hpack_debug_hexdump(...) do { } while (0)
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
#endif
/* reads a varint from <raw>'s lowest <b> bits and <len> bytes max (raw included).
* returns the 32-bit value on success after updating raw_in and len_in. Forces
* len_in to (uint32_t)-1 on truncated input.
*/
static uint32_t get_var_int(const uint8_t **raw_in, uint32_t *len_in, int b)
{
uint32_t ret = 0;
int len = *len_in;
const uint8_t *raw = *raw_in;
uint8_t shift = 0;
len--;
ret = *(raw++) & ((1 << b) - 1);
if (ret != (uint32_t)((1 << b) - 1))
goto end;
CLEANUP: hpack: remove a redundant test in the decoder As reported in issue #485 the test for !len at the end of the loop in get_var_int() is useless since it was already done inside the loop. Actually the code is more readable if we remove the first one so let's do this instead. The resulting code is exactly the same since the compiler already optimized the test away.
2020-02-05 14:28:55 +00:00
while (len && (*raw & 128)) {
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
ret += ((uint32_t)(*raw++) & 127) << shift;
shift += 7;
len--;
}
/* last 7 bits */
if (!len)
goto too_short;
len--;
ret += ((uint32_t)(*raw++) & 127) << shift;
end:
*raw_in = raw;
*len_in = len;
return ret;
too_short:
*len_in = (uint32_t)-1;
return 0;
}
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
/* returns the pseudo-header <idx> corresponds to among the following values :
* - 0 = unknown, the header's string needs to be used instead
* - 1 = ":authority"
* - 2 = ":method"
* - 3 = ":path"
* - 4 = ":scheme"
* - 5 = ":status"
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
*/
static inline int hpack_idx_to_phdr(uint32_t idx)
{
if (idx > 14)
return 0;
idx >>= 1;
idx <<= 2;
return (0x55554321U >> idx) & 0xF;
}
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
/* If <idx> designates a static header, returns <in>. Otherwise allocates some
* room from chunk <store> to duplicate <in> into it and returns the string
* allocated there. In case of allocation failure, returns a string whose
* pointer is NULL.
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
*/
BUG/CRITICAL: hpack: fix improper sign check on the header index value Tim Dsterhus found using afl-fuzz that some parts of the HPACK decoder use incorrect bounds checking which do not catch negative values after a type cast. The first culprit is hpack_valid_idx() which takes a signed int and is fed with an unsigned one, but a few others are affected as well due to being designed to work with an uint16_t as in the table header, thus not being able to detect the high offset bits, though they are not exposed if hpack_valid_idx() is fixed. The impact is that the HPACK decoder can be crashed by an out-of-bounds read. The only work-around without this patch is to disable H2 in the configuration. CVE-2018-14645 was assigned to this bug. This patch addresses all of these issues at once. It must be backported to 1.8.
2018-09-17 12:07:33 +00:00
static inline struct ist hpack_alloc_string(struct buffer *store, uint32_t idx,
MAJOR: chunks: replace struct chunk with struct buffer Now all the code used to manipulate chunks uses a struct buffer instead. The functions are still called "chunk*", and some of them will progressively move to the generic buffer handling code as they are cleaned up.
2018-07-13 09:56:34 +00:00
struct ist in)
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
{
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
struct ist out;
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
if (idx < HPACK_SHT_SIZE)
return in;
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
out.len = in.len;
out.ptr = chunk_newstr(store);
CLEANUP: Use isttest(const struct ist) whenever possible Refactoring performed with the following Coccinelle patch: @@ struct ist i; @@ - i.ptr != NULL + isttest(i)
2021-03-02 17:57:28 +00:00
if (unlikely(!isttest(out)))
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
return out;
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 08:54:26 +00:00
if (unlikely(store->data + out.len > store->size)) {
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
out.ptr = NULL;
return out;
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
}
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 08:54:26 +00:00
store->data += out.len;
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
memcpy(out.ptr, in.ptr, out.len);
return out;
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
}
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
/* decode an HPACK frame starting at <raw> for <len> bytes, using the dynamic
* headers table <dht>, produces the output into list <list> of <list_size>
* entries max, and uses pre-allocated buffer <tmp> for temporary storage (some
* list elements will point to it). Some <list> name entries may be made of a
* NULL pointer and a len, in which case they will designate a pseudo header
* index according to the values returned by hpack_idx_to_phdr() above. The
* number of <list> entries used is returned on success, or <0 on failure, with
* the opposite one of the HPACK_ERR_* codes. A last element is always zeroed
* and is not counted in the number of returned entries. This way the caller
* can use list[].n.len == 0 as a marker for the end of list.
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
*/
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
int hpack_decode_frame(struct hpack_dht *dht, const uint8_t *raw, uint32_t len,
MAJOR: chunks: replace struct chunk with struct buffer Now all the code used to manipulate chunks uses a struct buffer instead. The functions are still called "chunk*", and some of them will progressively move to the generic buffer handling code as they are cleaned up.
2018-07-13 09:56:34 +00:00
struct http_hdr *list, int list_size,
struct buffer *tmp)
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
{
uint32_t idx;
uint32_t nlen;
uint32_t vlen;
uint8_t huff;
struct ist name;
struct ist value;
int must_index;
int ret;
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_hexdump(stderr, "[HPACK-DEC] ", (const char *)raw, 0, len);
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
chunk_reset(tmp);
ret = 0;
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
while (len) {
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
int __maybe_unused code = *raw; /* first byte, only for debugging */
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
must_index = 0;
if (*raw >= 0x80) {
/* indexed header field */
if (*raw == 0x80) {
hpack_debug_printf("unhandled code 0x%02x (raw=%p, len=%d)\n", *raw, raw, len);
ret = -HPACK_ERR_UNKNOWN_OPCODE;
goto leave;
}
hpack_debug_printf("%02x: p14: indexed header field : ", code);
idx = get_var_int(&raw, &len, 7);
if (len == (uint32_t)-1) { // truncated
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d##\n", __LINE__);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
ret = -HPACK_ERR_TRUNCATED;
goto leave;
}
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf(" idx=%u ", idx);
BUG/MINOR: hpack: reject invalid header index If the hpack decoder sees an invalid header index, it emits value "### ERR ###" that was used during debugging instead of rejecting the block. This is harmless, and was detected by h2spec. To backport to 1.8.
2017-12-03 11:12:17 +00:00
if (!hpack_valid_idx(dht, idx)) {
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d##\n", __LINE__);
BUG/MINOR: hpack: reject invalid header index If the hpack decoder sees an invalid header index, it emits value "### ERR ###" that was used during debugging instead of rejecting the block. This is harmless, and was detected by h2spec. To backport to 1.8.
2017-12-03 11:12:17 +00:00
ret = -HPACK_ERR_TOO_LARGE;
goto leave;
}
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
value = hpack_alloc_string(tmp, idx, hpack_idx_to_value(dht, idx));
CLEANUP: Use `isttest()` and `istfree()` This adjusts a few locations to make use of `isttest()` and `istfree()`.
2020-03-05 16:56:33 +00:00
if (!isttest(value)) {
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d##\n", __LINE__);
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
ret = -HPACK_ERR_TOO_LARGE;
goto leave;
}
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
/* here we don't index so we can always keep the pseudo header number */
name = ist2(NULL, hpack_idx_to_phdr(idx));
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
if (!name.len) {
name = hpack_alloc_string(tmp, idx, hpack_idx_to_name(dht, idx));
CLEANUP: Use `isttest()` and `istfree()` This adjusts a few locations to make use of `isttest()` and `istfree()`.
2020-03-05 16:56:33 +00:00
if (!isttest(name)) {
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d##\n", __LINE__);
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
ret = -HPACK_ERR_TOO_LARGE;
goto leave;
}
}
/* <name> and <value> are now set and point to stable values */
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
}
else if (*raw >= 0x20 && *raw <= 0x3f) {
/* max dyn table size change */
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("%02x: p18: dynamic table size update : ", code);
BUG/MINOR: hpack: dynamic table size updates are only allowed before headers h2spec reports that we used to support a dynamic table size update anywhere in the header block but it's only allowed before other headers (cf RFC7541#4.2.1). In practice we don't use these for now since we only use literals in responses. To backport to 1.8.
2017-12-03 17:09:21 +00:00
if (ret) {
/* 7541#4.2.1 : DHT size update must only be at the beginning */
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d##\n", __LINE__);
BUG/MINOR: hpack: dynamic table size updates are only allowed before headers h2spec reports that we used to support a dynamic table size update anywhere in the header block but it's only allowed before other headers (cf RFC7541#4.2.1). In practice we don't use these for now since we only use literals in responses. To backport to 1.8.
2017-12-03 17:09:21 +00:00
ret = -HPACK_ERR_TOO_LARGE;
goto leave;
}
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
idx = get_var_int(&raw, &len, 5);
if (len == (uint32_t)-1) { // truncated
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d##\n", __LINE__);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
ret = -HPACK_ERR_TRUNCATED;
goto leave;
}
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf(" new len=%u\n", idx);
BUG/MINOR: hpack: return a compression error on invalid table size updates RFC7541#6.3 mandates that an error is reported when a dynamic table size update announces a size larger than the one configured with settings. This is tested by h2spec using test "hpack/6.3/1". This must be backported to 1.9 and possibly 1.8 as well.
2019-01-24 09:47:10 +00:00
if (idx > dht->size) {
hpack_debug_printf("##ERR@%d##\n", __LINE__);
ret = -HPACK_ERR_INVALID_ARGUMENT;
goto leave;
}
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
continue;
}
else if (!(*raw & (*raw - 0x10))) {
/* 0x00, 0x10, and 0x40 (0x20 and 0x80 were already handled above) */
/* literal header field without/never/with incremental indexing -- literal name */
if (*raw == 0x00)
hpack_debug_printf("%02x: p17: literal without indexing : ", code);
else if (*raw == 0x10)
hpack_debug_printf("%02x: p18: literal never indexed : ", code);
else if (*raw == 0x40)
hpack_debug_printf("%02x: p16: literal with indexing : ", code);
if (*raw == 0x40)
must_index = 1;
raw++; len--;
/* retrieve name */
if (!len) { // truncated
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d##\n", __LINE__);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
ret = -HPACK_ERR_TRUNCATED;
goto leave;
}
huff = *raw & 0x80;
nlen = get_var_int(&raw, &len, 7);
if (len == (uint32_t)-1 || len < nlen) { // truncated
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d## (truncated): nlen=%d len=%d\n",
__LINE__, (int)nlen, (int)len);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
ret = -HPACK_ERR_TRUNCATED;
goto leave;
}
name = ist2(raw, nlen);
raw += nlen;
len -= nlen;
if (huff) {
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
char *ntrash = chunk_newstr(tmp);
if (!ntrash) {
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d##\n", __LINE__);
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
ret = -HPACK_ERR_TOO_LARGE;
goto leave;
}
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 08:54:26 +00:00
nlen = huff_dec((const uint8_t *)name.ptr, name.len, ntrash,
tmp->size - tmp->data);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
if (nlen == (uint32_t)-1) {
hpack_debug_printf("2: can't decode huffman.\n");
ret = -HPACK_ERR_HUFFMAN;
goto leave;
}
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf(" [name huff %d->%d] ", (int)name.len, (int)nlen);
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 08:54:26 +00:00
tmp->data += nlen; // make room for the value
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
name = ist2(ntrash, nlen);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
}
/* retrieve value */
if (!len) { // truncated
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d##\n", __LINE__);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
ret = -HPACK_ERR_TRUNCATED;
goto leave;
}
huff = *raw & 0x80;
vlen = get_var_int(&raw, &len, 7);
if (len == (uint32_t)-1 || len < vlen) { // truncated
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d## : vlen=%d len=%d\n",
__LINE__, (int)vlen, (int)len);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
ret = -HPACK_ERR_TRUNCATED;
goto leave;
}
value = ist2(raw, vlen);
raw += vlen;
len -= vlen;
if (huff) {
char *vtrash = chunk_newstr(tmp);
if (!vtrash) {
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d##\n", __LINE__);
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
ret = -HPACK_ERR_TOO_LARGE;
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
goto leave;
}
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 08:54:26 +00:00
vlen = huff_dec((const uint8_t *)value.ptr, value.len, vtrash,
tmp->size - tmp->data);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
if (vlen == (uint32_t)-1) {
hpack_debug_printf("3: can't decode huffman.\n");
ret = -HPACK_ERR_HUFFMAN;
goto leave;
}
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf(" [value huff %d->%d] ", (int)value.len, (int)vlen);
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 08:54:26 +00:00
tmp->data += vlen; // make room for the value
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
value = ist2(vtrash, vlen);
}
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
/* <name> and <value> are correctly filled here */
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
}
else {
/* 0x01..0x0f : literal header field without indexing -- indexed name */
/* 0x11..0x1f : literal header field never indexed -- indexed name */
/* 0x41..0x7f : literal header field with incremental indexing -- indexed name */
if (*raw <= 0x0f)
hpack_debug_printf("%02x: p16: literal without indexing -- indexed name : ", code);
else if (*raw >= 0x41)
hpack_debug_printf("%02x: p15: literal with indexing -- indexed name : ", code);
else
hpack_debug_printf("%02x: p16: literal never indexed -- indexed name : ", code);
/* retrieve name index */
if (*raw >= 0x41) {
must_index = 1;
idx = get_var_int(&raw, &len, 6);
}
else
idx = get_var_int(&raw, &len, 4);
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf(" idx=%u ", idx);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
if (len == (uint32_t)-1 || !len) { // truncated
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d##\n", __LINE__);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
ret = -HPACK_ERR_TRUNCATED;
goto leave;
}
BUG/MINOR: hpack: reject invalid header index If the hpack decoder sees an invalid header index, it emits value "### ERR ###" that was used during debugging instead of rejecting the block. This is harmless, and was detected by h2spec. To backport to 1.8.
2017-12-03 11:12:17 +00:00
if (!hpack_valid_idx(dht, idx)) {
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d##\n", __LINE__);
BUG/MINOR: hpack: reject invalid header index If the hpack decoder sees an invalid header index, it emits value "### ERR ###" that was used during debugging instead of rejecting the block. This is harmless, and was detected by h2spec. To backport to 1.8.
2017-12-03 11:12:17 +00:00
ret = -HPACK_ERR_TOO_LARGE;
goto leave;
}
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
/* retrieve value */
huff = *raw & 0x80;
vlen = get_var_int(&raw, &len, 7);
if (len == (uint32_t)-1 || len < vlen) { // truncated
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d##\n", __LINE__);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
ret = -HPACK_ERR_TRUNCATED;
goto leave;
}
value = ist2(raw, vlen);
raw += vlen;
len -= vlen;
if (huff) {
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
char *vtrash = chunk_newstr(tmp);
if (!vtrash) {
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d##\n", __LINE__);
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
ret = -HPACK_ERR_TOO_LARGE;
goto leave;
}
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 08:54:26 +00:00
vlen = huff_dec((const uint8_t *)value.ptr, value.len, vtrash,
tmp->size - tmp->data);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
if (vlen == (uint32_t)-1) {
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d## can't decode huffman : ilen=%d osize=%d\n",
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 08:54:26 +00:00
__LINE__, (int)value.len,
(int)(tmp->size - tmp->data));
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_hexdump(stderr, "[HUFFMAN] ", value.ptr, 0, value.len);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
ret = -HPACK_ERR_HUFFMAN;
goto leave;
}
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 08:54:26 +00:00
tmp->data += vlen; // make room for the value
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
value = ist2(vtrash, vlen);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
}
MINOR: ist: Add `IST_NULL` macro `IST_NULL` is equivalent to an `struct ist` with `.ptr = NULL` and `.len = 0`.
2020-03-05 16:56:30 +00:00
name = IST_NULL;
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
if (!must_index)
name.len = hpack_idx_to_phdr(idx);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
BUG/MAJOR: hpack: don't return direct references to the dynamic headers table Maximilian Bhm and Lucas Rolff both reported some random failed requests with HTTP/2. Upon deep investigation on detailed traces provided by Lucas, it turned out that some header names were occasionally corrupted and used to point to random strings within the dynamic headers table. The HPACK decoder must always return copies of header names that point to the dynamic headers table. Otherwise, the insertion of a header after the current one leading to a reorganization of the table will change the data the pointer designates. Unfortunately, one such copy was missing for indexed names, leading to random request failures due to invalid header names. Many thanks to Lucas who ran a large number of tests with full traces helping to capture a reproduceable sequence exhibiting this issue. This patch must be backported to 1.8.
2017-12-30 15:56:28 +00:00
if (!name.len) {
name = hpack_alloc_string(tmp, idx, hpack_idx_to_name(dht, idx));
CLEANUP: Use `isttest()` and `istfree()` This adjusts a few locations to make use of `isttest()` and `istfree()`.
2020-03-05 16:56:33 +00:00
if (!isttest(name)) {
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d##\n", __LINE__);
BUG/MAJOR: hpack: don't return direct references to the dynamic headers table Maximilian Bhm and Lucas Rolff both reported some random failed requests with HTTP/2. Upon deep investigation on detailed traces provided by Lucas, it turned out that some header names were occasionally corrupted and used to point to random strings within the dynamic headers table. The HPACK decoder must always return copies of header names that point to the dynamic headers table. Otherwise, the insertion of a header after the current one leading to a reorganization of the table will change the data the pointer designates. Unfortunately, one such copy was missing for indexed names, leading to random request failures due to invalid header names. Many thanks to Lucas who ran a large number of tests with full traces helping to capture a reproduceable sequence exhibiting this issue. This patch must be backported to 1.8.
2017-12-30 15:56:28 +00:00
ret = -HPACK_ERR_TOO_LARGE;
goto leave;
}
}
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
/* <name> and <value> are correctly filled here */
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
}
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
/* here's what we have here :
* - name.len > 0
* - value is filled with either const data or data allocated from tmp
* - name.ptr == NULL && !must_index : known pseudo-header #name.len
* - name.ptr != NULL || must_index : general header, unknown pseudo-header or index needed
*/
if (ret >= list_size) {
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("##ERR@%d##\n", __LINE__);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
ret = -HPACK_ERR_TOO_LARGE;
goto leave;
}
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
list[ret].n = name;
list[ret].v = value;
ret++;
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
if (must_index && hpack_dht_insert(dht, name, value) < 0) {
hpack_debug_printf("failed to find some room in the dynamic table\n");
ret = -HPACK_ERR_DHT_INSERT_FAIL;
goto leave;
}
hpack_debug_printf("\e[1;34m%s\e[0m: ",
CLEANUP: Use `isttest()` and `istfree()` This adjusts a few locations to make use of `isttest()` and `istfree()`.
2020-03-05 16:56:33 +00:00
isttest(name) ? istpad(trash.area, name).ptr : h2_phdr_to_str(name.len));
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("\e[1;35m%s\e[0m [mustidx=%d, used=%d] [n=(%p,%d) v=(%p,%d)]\n",
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 08:54:26 +00:00
istpad(trash.area, value).ptr, must_index,
dht->used,
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
name.ptr, (int)name.len, value.ptr, (int)value.len);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
}
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
if (ret >= list_size) {
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
ret = -HPACK_ERR_TOO_LARGE;
goto leave;
}
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
/* put an end marker */
MINOR: ist: Add `IST_NULL` macro `IST_NULL` is equivalent to an `struct ist` with `.ptr = NULL` and `.len = 0`.
2020-03-05 16:56:30 +00:00
list[ret].n = list[ret].v = IST_NULL;
MEDIUM: h2: change hpack_decode_headers() to only provide a list of headers The current H2 to H1 protocol conversion presents some issues which will require to perform some processing on certain headers before writing them so it's not possible to convert HPACK to H1 on the fly. This commit modifies the headers decoding so that it now works in two phases : hpack_decode_headers() only decodes the HPACK stream in the HEADERS frame and puts the result into a list. Headers which require storage (huffman-compressed or from the dynamic table) are stored in a chunk allocated by the H2 demuxer. Then once the headers are properly decoded into this list, h2_make_h1_request() is called with this list to produce the HTTP/1.1 request into the destination buffer. The list necessarily enforces a limit. Here we use 2*MAX_HTTP_HDR, which means that we can have as many individual cookies as we have regular headers if a client decides to break their cookies into multiple values. This seams reasonable and will allow the H1 parser to decide whether it's too much or not. Thus the output stream is not produced on the fly anymore and this will permit to deal with certain corner cases like reparing the Cookie header (which for now is not done). In order to limit header duplication and parsing, the known pseudo headers continue to be passed by their index : the name element in the list then has a NULL pointer and the value is the pseudo header's index. Given that these ones represent about half of the incoming requests and need to be found quickly, it maintains an acceptable level of performance. The code was significantly reduced by doing this because the orignal code had to deal with HPACK and H1 combinations (eg: index vs not indexed, etc) and now the HPACK decoding is totally focused on the decompression, and the H1 encoding doesn't have to deal with the issue of wrapping input for example. One bug was addressed here (though it couldn't happen at the moment). The H2 demuxer used to detect a failure to write the request into the H1 buffer and would then detect if the output buffer wraps, realign it and try again. The problem by doing so was that the HPACK context was already modified and not rewindable. Thus the size check is now performed first and a failure is reported if it doesn't fit.
2017-11-21 19:03:02 +00:00
ret++;
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
leave:
DEBUG: hpack: add more traces to the hpack decoder These ones are only enabled when DEBUG_HPACK is defined so they have no effect on the production code.
2017-12-30 12:17:37 +00:00
hpack_debug_printf("-- done: ret=%d list_size=%d --\n", (int)ret, (int)list_size);
MINOR: hpack: implement the decoder The decoder is now fully functional. It makes use of the dynamic header table. Dynamic header table size updates are currently ignored, as our initially advertised value is the highest we support. Strictly speaking, the impact is that a client referencing a header field after such an update wouldn't observe an error instead of the connection being dropped if it was implemented. Decoded header fields are copied into a target buffer in HTTP/1 format using HTTP/1.1 as the version. The Host header field is automatically appended if a ":authority" header field is present. All decoded header fields can be displayed if the file is compiled with DEBUG_HPACK.
2017-05-30 17:09:44 +00:00
return ret;
}
Reference in New Issue Copy Permalink