RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2024-12-18 09:24:31 +00:00
Code Issues Packages Projects Releases Wiki Activity
b8ce8905cf
haproxy/src/h2.c

708 lines
23 KiB
C
Raw Normal View History

MEDIUM: h2: add a function to emit an HTTP/1 request from a headers list 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. Here we introduce a function which performs half of what hpack_decode_header() used to do, which is to take a list of headers on input and emit the corresponding request in HTTP/1.1 format. The code is the same and functions were renamed to be prefixed with "h2" instead of "hpack", though it ends up being simpler as the various HPACK-specific cases could be fused into a single one (ie: add header). Moving this part here makes a lot of sense as now this code is specific to what is documented in HTTP/2 RFC 7540 and will be able to deal with special cases related to H2 to H1 conversion enumerated in section 8.1. Various error codes which were previously assigned to HPACK were never used (aside being negative) and were all replaced by -1 with a comment indicating what error was detected. The code could be further factored thanks to this but this commit focuses on compatibility first. This code is not yet used but builds fine.
2017-11-21 18:55:27 +00:00
/*
* HTTP/2 protocol processing
*
* Copyright 2017 Willy Tarreau <w@1wt.eu>
* 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>
MEDIUM: h2: add a function to emit an HTTP/1 request from a headers list 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. Here we introduce a function which performs half of what hpack_decode_header() used to do, which is to take a list of headers on input and emit the corresponding request in HTTP/1.1 format. The code is the same and functions were renamed to be prefixed with "h2" instead of "hpack", though it ends up being simpler as the various HPACK-specific cases could be fused into a single one (ie: add header). Moving this part here makes a lot of sense as now this code is specific to what is documented in HTTP/2 RFC 7540 and will be able to deal with special cases related to H2 to H1 conversion enumerated in section 8.1. Various error codes which were previously assigned to HPACK were never used (aside being negative) and were all replaced by -1 with a comment indicating what error was detected. The code could be further factored thanks to this but this commit focuses on compatibility first. This code is not yet used but builds fine.
2017-11-21 18:55:27 +00:00
#include <common/config.h>
#include <common/h2.h>
#include <common/http-hdr.h>
#include <common/ist.h>
MEDIUM: h2: make the request parser rebuild a complete URI Till now we've been producing path components of the URI and using the :authority header only to be placed into the host part. But this practice is not correct, as if we're used to convey H1 proxy requests over H2 then over H1, the absolute URI is presented as a path on output, which is not valid. In addition the scheme on output is not updated from the absolute URI either. Now the request parser will continue to deliver origin-form for request received using the http/https schemes, but will use the absolute-form when dealing with other schemes, by concatenating the scheme, the authority and the path if it's not '*'.
2019-10-08 14:53:07 +00:00
#include <types/global.h>
MEDIUM: h2: add a function to emit an HTTP/1 request from a headers list 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. Here we introduce a function which performs half of what hpack_decode_header() used to do, which is to take a list of headers on input and emit the corresponding request in HTTP/1.1 format. The code is the same and functions were renamed to be prefixed with "h2" instead of "hpack", though it ends up being simpler as the various HPACK-specific cases could be fused into a single one (ie: add header). Moving this part here makes a lot of sense as now this code is specific to what is documented in HTTP/2 RFC 7540 and will be able to deal with special cases related to H2 to H1 conversion enumerated in section 8.1. Various error codes which were previously assigned to HPACK were never used (aside being negative) and were all replaced by -1 with a comment indicating what error was detected. The code could be further factored thanks to this but this commit focuses on compatibility first. This code is not yet used but builds fine.
2017-11-21 18:55:27 +00:00
MINOR: h2: add a generic frame checker The new function h2_frame_check() checks the protocol limits for the received frame (length, ID, direction) and returns a verdict made of a connection error code. The purpose is to be able to validate any frame regardless of the state and the ability to call the frame handler, and to emit a GOAWAY early in this case.
2019-01-30 14:09:21 +00:00
struct h2_frame_definition h2_frame_definition[H2_FT_ENTRIES] = {
[H2_FT_DATA ] = { .dir = 3, .min_id = 1, .max_id = H2_MAX_STREAM_ID, .min_len = 0, .max_len = H2_MAX_FRAME_LEN, },
[H2_FT_HEADERS ] = { .dir = 3, .min_id = 1, .max_id = H2_MAX_STREAM_ID, .min_len = 1, .max_len = H2_MAX_FRAME_LEN, },
[H2_FT_PRIORITY ] = { .dir = 3, .min_id = 1, .max_id = H2_MAX_STREAM_ID, .min_len = 5, .max_len = 5, },
[H2_FT_RST_STREAM ] = { .dir = 3, .min_id = 1, .max_id = H2_MAX_STREAM_ID, .min_len = 4, .max_len = 4, },
[H2_FT_SETTINGS ] = { .dir = 3, .min_id = 0, .max_id = 0, .min_len = 0, .max_len = H2_MAX_FRAME_LEN, },
[H2_FT_PUSH_PROMISE ] = { .dir = 0, .min_id = 1, .max_id = H2_MAX_STREAM_ID, .min_len = 4, .max_len = H2_MAX_FRAME_LEN, },
[H2_FT_PING ] = { .dir = 3, .min_id = 0, .max_id = 0, .min_len = 8, .max_len = 8, },
[H2_FT_GOAWAY ] = { .dir = 3, .min_id = 0, .max_id = 0, .min_len = 8, .max_len = H2_MAX_FRAME_LEN, },
[H2_FT_WINDOW_UPDATE] = { .dir = 3, .min_id = 0, .max_id = H2_MAX_STREAM_ID, .min_len = 4, .max_len = 4, },
[H2_FT_CONTINUATION ] = { .dir = 3, .min_id = 1, .max_id = H2_MAX_STREAM_ID, .min_len = 0, .max_len = H2_MAX_FRAME_LEN, },
};
MEDIUM: h2: add a function to emit an HTTP/1 request from a headers list 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. Here we introduce a function which performs half of what hpack_decode_header() used to do, which is to take a list of headers on input and emit the corresponding request in HTTP/1.1 format. The code is the same and functions were renamed to be prefixed with "h2" instead of "hpack", though it ends up being simpler as the various HPACK-specific cases could be fused into a single one (ie: add header). Moving this part here makes a lot of sense as now this code is specific to what is documented in HTTP/2 RFC 7540 and will be able to deal with special cases related to H2 to H1 conversion enumerated in section 8.1. Various error codes which were previously assigned to HPACK were never used (aside being negative) and were all replaced by -1 with a comment indicating what error was detected. The code could be further factored thanks to this but this commit focuses on compatibility first. This code is not yet used but builds fine.
2017-11-21 18:55:27 +00:00
MEDIUM: h2: properly check and deduplicate the content-length header in HTX When producing an HTX message, we can't rely on the next-level H1 parser to check and deduplicate the content-length header, so we have to do it while parsing a message. The algorithm is the exact same as used for H1 messages.
2018-12-19 12:08:08 +00:00
/* Parse the Content-Length header field of an HTTP/2 request. The function
* checks all possible occurrences of a comma-delimited value, and verifies
* if any of them doesn't match a previous value. It returns <0 if a value
* differs, 0 if the whole header can be dropped (i.e. already known), or >0
* if the value can be indexed (first one). In the last case, the value might
* be adjusted and the caller must only add the updated value.
*/
int h2_parse_cont_len_header(unsigned int *msgf, struct ist *value, unsigned long long *body_len)
{
char *e, *n;
unsigned long long cl;
int not_first = !!(*msgf & H2_MSGF_BODY_CL);
struct ist word;
word.ptr = value->ptr - 1; // -1 for next loop's pre-increment
e = value->ptr + value->len;
while (++word.ptr < e) {
/* skip leading delimitor and blanks */
if (unlikely(HTTP_IS_LWS(*word.ptr)))
continue;
/* digits only now */
for (cl = 0, n = word.ptr; n < e; n++) {
unsigned int c = *n - '0';
if (unlikely(c > 9)) {
/* non-digit */
if (unlikely(n == word.ptr)) // spaces only
goto fail;
break;
}
if (unlikely(cl > ULLONG_MAX / 10ULL))
goto fail; /* multiply overflow */
cl = cl * 10ULL;
if (unlikely(cl + c < cl))
goto fail; /* addition overflow */
cl = cl + c;
}
/* keep a copy of the exact cleaned value */
word.len = n - word.ptr;
/* skip trailing LWS till next comma or EOL */
for (; n < e; n++) {
if (!HTTP_IS_LWS(*n)) {
if (unlikely(*n != ','))
goto fail;
break;
}
}
/* if duplicate, must be equal */
if (*msgf & H2_MSGF_BODY_CL && cl != *body_len)
goto fail;
/* OK, store this result as the one to be indexed */
*msgf |= H2_MSGF_BODY_CL;
*body_len = cl;
*value = word;
word.ptr = n;
}
/* here we've reached the end with a single value or a series of
* identical values, all matching previous series if any. The last
* parsed value was sent back into <value>. We just have to decide
* if this occurrence has to be indexed (it's the first one) or
* silently skipped (it's not the first one)
*/
return !not_first;
fail:
return -1;
}
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
/* Prepare the request line into <htx> from pseudo headers stored in <phdr[]>.
* <fields> indicates what was found so far. This should be called once at the
* detection of the first general header field or at the end of the request if
* no general header field was found yet. Returns the created start line on
* success, or NULL on failure. Upon success, <msgf> is updated with a few
* H2_MSGF_* flags indicating what was found while parsing.
MINOR: h2: clarify the rules for how to convert an H2 request to HTX The H2 request parsing is not trivial given that we have multiple possible syntaxes. Mainly we can have :authority or not, and when a CONNECT method is seen, :scheme and :path are missing. This mostly updates the functions' comments and header index assignments to make them less confusing. Functionally there is no change.
2019-10-08 09:59:37 +00:00
*
* The rules below deserve a bit of explanation. There tends to be some
* confusion regarding H2's authority vs the Host header. They are different
* though may sometimes be exchanged. In H2, the request line is broken into :
* - :method
* - :scheme
* - :authority
* - :path
*
* An equivalent HTTP/1.x absolute-form request would then look like :
* <:method> <:scheme>://<:authority><:path> HTTP/x.y
*
* Except for CONNECT which doesn't have scheme nor path and looks like :
* <:method> <:authority> HTTP/x.y
*
* It's worth noting that H2 still supports an encoding to map H1 origin-form
* and asterisk-form requests. These ones do not specify the authority. However
* in H2 they must still specify the scheme, which is not present in H1. Also,
* when encoding an absolute-form H1 request without a path, the path
* automatically becomes "/" except for the OPTIONS method where it
* becomes "*".
*
* As such it is explicitly permitted for an H2 client to send a request
* featuring a Host header and no :authority, though it's not the recommended
* way to use H2 for a client. It is however the only permitted way to encode
* an origin-form H1 request over H2. Thus we need to respect such differences
* as much as possible when re-encoding the H2 request into HTX.
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
*/
static struct htx_sl *h2_prepare_htx_reqline(uint32_t fields, struct ist *phdr, struct htx *htx, unsigned int *msgf)
{
MEDIUM: h2: make the request parser rebuild a complete URI Till now we've been producing path components of the URI and using the :authority header only to be placed into the host part. But this practice is not correct, as if we're used to convey H1 proxy requests over H2 then over H1, the absolute URI is presented as a path on output, which is not valid. In addition the scheme on output is not updated from the absolute URI either. Now the request parser will continue to deliver origin-form for request received using the http/https schemes, but will use the absolute-form when dealing with other schemes, by concatenating the scheme, the authority and the path if it's not '*'.
2019-10-08 14:53:07 +00:00
struct ist uri;
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
unsigned int flags = HTX_SL_F_NONE;
struct htx_sl *sl;
BUG/MEDIUM: h2/htx: verify that :path doesn't contain invalid chars While the legacy code converts h2 to h1 and provides some control over what is passed, in htx mode there is no such control and it is possible to pass control chars and linear white spaces in the path, which are possibly reencoded differently once passed to the H1 side. HTX supports parse error reporting using a special flag. Let's check the correctness of the :path pseudo header and report any anomaly in the HTX flag. Thanks to Jrme Magnin for reporting this bug with a working reproducer. This fix must be backported to 1.9 along with the two previous patches ("MINOR: htx: unconditionally handle parsing errors in requests or responses" and "MINOR: mux-h2: always pass HTX_FL_PARSING_ERROR between h2s and buf on RX").
2019-03-05 09:47:37 +00:00
size_t i;
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
if ((fields & H2_PHDR_FND_METH) && isteq(phdr[H2_PHDR_IDX_METH], ist("CONNECT"))) {
/* RFC 7540 #8.2.6 regarding CONNECT: ":scheme" and ":path"
* MUST be omitted ; ":authority" contains the host and port
* to connect to.
*/
if (fields & H2_PHDR_FND_SCHM) {
/* scheme not allowed */
goto fail;
}
else if (fields & H2_PHDR_FND_PATH) {
/* path not allowed */
goto fail;
}
else if (!(fields & H2_PHDR_FND_AUTH)) {
/* missing authority */
goto fail;
}
*msgf |= H2_MSGF_BODY_TUNNEL;
}
else if ((fields & (H2_PHDR_FND_METH|H2_PHDR_FND_SCHM|H2_PHDR_FND_PATH)) !=
(H2_PHDR_FND_METH|H2_PHDR_FND_SCHM|H2_PHDR_FND_PATH)) {
/* RFC 7540 #8.1.2.3 : all requests MUST include exactly one
* valid value for the ":method", ":scheme" and ":path" phdr
* unless it is a CONNECT request.
*/
if (!(fields & H2_PHDR_FND_METH)) {
/* missing method */
goto fail;
}
else if (!(fields & H2_PHDR_FND_SCHM)) {
/* missing scheme */
goto fail;
}
else {
/* missing path */
goto fail;
}
}
MINOR: h2: clarify the rules for how to convert an H2 request to HTX The H2 request parsing is not trivial given that we have multiple possible syntaxes. Mainly we can have :authority or not, and when a CONNECT method is seen, :scheme and :path are missing. This mostly updates the functions' comments and header index assignments to make them less confusing. Functionally there is no change.
2019-10-08 09:59:37 +00:00
else { /* regular methods */
MEDIUM: h2: make the request parser rebuild a complete URI Till now we've been producing path components of the URI and using the :authority header only to be placed into the host part. But this practice is not correct, as if we're used to convey H1 proxy requests over H2 then over H1, the absolute URI is presented as a path on output, which is not valid. In addition the scheme on output is not updated from the absolute URI either. Now the request parser will continue to deliver origin-form for request received using the http/https schemes, but will use the absolute-form when dealing with other schemes, by concatenating the scheme, the authority and the path if it's not '*'.
2019-10-08 14:53:07 +00:00
/* RFC3986#6.2.2.1: scheme is case-insensitive. We need to
* classify the scheme as "present/http", "present/https",
* "present/other", "absent" so as to decide whether or not
* we're facing a normalized URI that will have to be encoded
* in origin or absolute form. Indeed, 7540#8.1.2.3 says that
* clients should use the absolute form, thus we cannot infer
* whether or not the client wanted to use a proxy here.
*/
flags |= HTX_SL_F_HAS_SCHM;
if (isteqi(phdr[H2_PHDR_IDX_SCHM], ist("http")))
flags |= HTX_SL_F_SCHM_HTTP;
else if (isteqi(phdr[H2_PHDR_IDX_SCHM], ist("https")))
flags |= HTX_SL_F_SCHM_HTTPS;
}
if (!(flags & HTX_SL_F_HAS_SCHM)) {
/* no scheme, use authority only (CONNECT) */
uri = phdr[H2_PHDR_IDX_AUTH];
MINOR: h2: report in the HTX flags when the request has an authority The other side will need to know when to emit an authority or not. We need to pass this information in the HTX flags.
2019-10-08 15:34:50 +00:00
flags |= HTX_SL_F_HAS_AUTHORITY;
MEDIUM: h2: make the request parser rebuild a complete URI Till now we've been producing path components of the URI and using the :authority header only to be placed into the host part. But this practice is not correct, as if we're used to convey H1 proxy requests over H2 then over H1, the absolute URI is presented as a path on output, which is not valid. In addition the scheme on output is not updated from the absolute URI either. Now the request parser will continue to deliver origin-form for request received using the http/https schemes, but will use the absolute-form when dealing with other schemes, by concatenating the scheme, the authority and the path if it's not '*'.
2019-10-08 14:53:07 +00:00
}
else if (!(flags & (HTX_SL_F_SCHM_HTTP|HTX_SL_F_SCHM_HTTPS)) && (fields & H2_PHDR_FND_AUTH)) {
/* non-http/https scheme + authority, let's use the absolute
* form. We simply use the trash to concatenate them since all
* of them MUST fit in a bufsize since it's where they come
* from.
*/
uri = ist2bin(trash.area, phdr[H2_PHDR_IDX_SCHM]);
istcat(&uri, ist("://"), trash.size);
istcat(&uri, phdr[H2_PHDR_IDX_AUTH], trash.size);
if (!isteq(phdr[H2_PHDR_IDX_PATH], ist("*")))
istcat(&uri, phdr[H2_PHDR_IDX_PATH], trash.size);
MINOR: h2: report in the HTX flags when the request has an authority The other side will need to know when to emit an authority or not. We need to pass this information in the HTX flags.
2019-10-08 15:34:50 +00:00
flags |= HTX_SL_F_HAS_AUTHORITY;
MEDIUM: h2: make the request parser rebuild a complete URI Till now we've been producing path components of the URI and using the :authority header only to be placed into the host part. But this practice is not correct, as if we're used to convey H1 proxy requests over H2 then over H1, the absolute URI is presented as a path on output, which is not valid. In addition the scheme on output is not updated from the absolute URI either. Now the request parser will continue to deliver origin-form for request received using the http/https schemes, but will use the absolute-form when dealing with other schemes, by concatenating the scheme, the authority and the path if it's not '*'.
2019-10-08 14:53:07 +00:00
}
else {
/* usual schemes with or without authority, use origin form */
uri = phdr[H2_PHDR_IDX_PATH];
MINOR: h2: report in the HTX flags when the request has an authority The other side will need to know when to emit an authority or not. We need to pass this information in the HTX flags.
2019-10-08 15:34:50 +00:00
if (fields & H2_PHDR_FND_AUTH)
flags |= HTX_SL_F_HAS_AUTHORITY;
MINOR: h2: clarify the rules for how to convert an H2 request to HTX The H2 request parsing is not trivial given that we have multiple possible syntaxes. Mainly we can have :authority or not, and when a CONNECT method is seen, :scheme and :path are missing. This mostly updates the functions' comments and header index assignments to make them less confusing. Functionally there is no change.
2019-10-08 09:59:37 +00:00
}
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
MINOR: h2: clarify the rules for how to convert an H2 request to HTX The H2 request parsing is not trivial given that we have multiple possible syntaxes. Mainly we can have :authority or not, and when a CONNECT method is seen, :scheme and :path are missing. This mostly updates the functions' comments and header index assignments to make them less confusing. Functionally there is no change.
2019-10-08 09:59:37 +00:00
/* make sure the final URI isn't empty. Note that 7540#8.1.2.3 states
* that :path must not be empty.
*/
MEDIUM: h2: make the request parser rebuild a complete URI Till now we've been producing path components of the URI and using the :authority header only to be placed into the host part. But this practice is not correct, as if we're used to convey H1 proxy requests over H2 then over H1, the absolute URI is presented as a path on output, which is not valid. In addition the scheme on output is not updated from the absolute URI either. Now the request parser will continue to deliver origin-form for request received using the http/https schemes, but will use the absolute-form when dealing with other schemes, by concatenating the scheme, the authority and the path if it's not '*'.
2019-10-08 14:53:07 +00:00
if (!uri.len)
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
goto fail;
MINOR: h2: clarify the rules for how to convert an H2 request to HTX The H2 request parsing is not trivial given that we have multiple possible syntaxes. Mainly we can have :authority or not, and when a CONNECT method is seen, :scheme and :path are missing. This mostly updates the functions' comments and header index assignments to make them less confusing. Functionally there is no change.
2019-10-08 09:59:37 +00:00
/* The final URI must not contain LWS nor CTL characters */
MEDIUM: h2: make the request parser rebuild a complete URI Till now we've been producing path components of the URI and using the :authority header only to be placed into the host part. But this practice is not correct, as if we're used to convey H1 proxy requests over H2 then over H1, the absolute URI is presented as a path on output, which is not valid. In addition the scheme on output is not updated from the absolute URI either. Now the request parser will continue to deliver origin-form for request received using the http/https schemes, but will use the absolute-form when dealing with other schemes, by concatenating the scheme, the authority and the path if it's not '*'.
2019-10-08 14:53:07 +00:00
for (i = 0; i < uri.len; i++) {
unsigned char c = uri.ptr[i];
BUG/MEDIUM: h2/htx: verify that :path doesn't contain invalid chars While the legacy code converts h2 to h1 and provides some control over what is passed, in htx mode there is no such control and it is possible to pass control chars and linear white spaces in the path, which are possibly reencoded differently once passed to the H1 side. HTX supports parse error reporting using a special flag. Let's check the correctness of the :path pseudo header and report any anomaly in the HTX flag. Thanks to Jrme Magnin for reporting this bug with a working reproducer. This fix must be backported to 1.9 along with the two previous patches ("MINOR: htx: unconditionally handle parsing errors in requests or responses" and "MINOR: mux-h2: always pass HTX_FL_PARSING_ERROR between h2s and buf on RX").
2019-03-05 09:47:37 +00:00
if (HTTP_IS_LWS(c) || HTTP_IS_CTL(c))
htx->flags |= HTX_FL_PARSING_ERROR;
}
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
/* Set HTX start-line flags */
flags |= HTX_SL_F_VER_11; // V2 in fact
flags |= HTX_SL_F_XFER_LEN; // xfer len always known with H2
MEDIUM: h2: make the request parser rebuild a complete URI Till now we've been producing path components of the URI and using the :authority header only to be placed into the host part. But this practice is not correct, as if we're used to convey H1 proxy requests over H2 then over H1, the absolute URI is presented as a path on output, which is not valid. In addition the scheme on output is not updated from the absolute URI either. Now the request parser will continue to deliver origin-form for request received using the http/https schemes, but will use the absolute-form when dealing with other schemes, by concatenating the scheme, the authority and the path if it's not '*'.
2019-10-08 14:53:07 +00:00
sl = htx_add_stline(htx, HTX_BLK_REQ_SL, flags, phdr[H2_PHDR_IDX_METH], uri, ist("HTTP/2.0"));
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
if (!sl)
goto fail;
sl->info.req.meth = find_http_meth(phdr[H2_PHDR_IDX_METH].ptr, phdr[H2_PHDR_IDX_METH].len);
return sl;
fail:
return NULL;
}
/* Takes an H2 request present in the headers list <list> terminated by a name
* being <NULL,0> and emits the equivalent HTX request according to the rules
* documented in RFC7540 #8.1.2. The output contents are emitted in <htx>, and
* non-zero is returned if some bytes were emitted. In case of error, a
* negative error code is returned.
*
* Upon success, <msgf> is filled with a few H2_MSGF_* flags indicating what
* was found while parsing. The caller must set it to zero in or H2_MSGF_BODY
* if a body is detected (!ES).
*
* The headers list <list> must be composed of :
* - n.name != NULL, n.len > 0 : literal header name
* - n.name == NULL, n.len > 0 : indexed pseudo header name number <n.len>
* among H2_PHDR_IDX_*
* - n.name ignored, n.len == 0 : end of list
* - in all cases except the end of list, v.name and v.len must designate a
* valid value.
*
* The Cookie header will be reassembled at the end, and for this, the <list>
* will be used to create a linked list, so its contents may be destroyed.
*/
MEDIUM: h2: always parse and deduplicate the content-length header The header used to be parsed only in HTX but not in legacy. And even in HTX mode, the value was dropped. Let's always parse it and report the parsed value back so that we'll be able to store it in the streams.
2019-01-24 10:33:02 +00:00
int h2_make_htx_request(struct http_hdr *list, struct htx *htx, unsigned int *msgf, unsigned long long *body_len)
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
{
struct ist phdr_val[H2_PHDR_NUM_ENTRIES];
uint32_t fields; /* bit mask of H2_PHDR_FND_* */
uint32_t idx;
int ck, lck; /* cookie index and last cookie index */
int phdr;
int ret;
int i;
MINOR: h2/htx: Set hdrs_bytes on the SL when an HTX message is produced
2019-05-15 13:53:20 +00:00
uint32_t used = htx_used_space(htx);
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
struct htx_sl *sl = NULL;
unsigned int sl_flags = 0;
lck = ck = -1; // no cookie for now
fields = 0;
for (idx = 0; list[idx].n.len != 0; idx++) {
if (!list[idx].n.ptr) {
/* this is an indexed pseudo-header */
phdr = list[idx].n.len;
}
else {
/* this can be any type of header */
/* RFC7540#8.1.2: upper case not allowed in header field names */
for (i = 0; i < list[idx].n.len; i++)
if ((uint8_t)(list[idx].n.ptr[i] - 'A') < 'Z' - 'A')
goto fail;
phdr = h2_str_to_phdr(list[idx].n);
}
if (phdr > 0 && phdr < H2_PHDR_NUM_ENTRIES) {
/* insert a pseudo header by its index (in phdr) and value (in value) */
if (fields & ((1 << phdr) | H2_PHDR_FND_NONE)) {
if (fields & H2_PHDR_FND_NONE) {
/* pseudo header field after regular headers */
goto fail;
}
else {
/* repeated pseudo header field */
goto fail;
}
}
fields |= 1 << phdr;
phdr_val[phdr] = list[idx].v;
continue;
}
else if (phdr != 0) {
/* invalid pseudo header -- should never happen here */
goto fail;
}
/* regular header field in (name,value) */
if (unlikely(!(fields & H2_PHDR_FND_NONE))) {
/* no more pseudo-headers, time to build the request line */
sl = h2_prepare_htx_reqline(fields, phdr_val, htx, msgf);
if (!sl)
goto fail;
fields |= H2_PHDR_FND_NONE;
}
if (isteq(list[idx].n, ist("host")))
fields |= H2_PHDR_FND_HOST;
MEDIUM: h2: properly check and deduplicate the content-length header in HTX When producing an HTX message, we can't rely on the next-level H1 parser to check and deduplicate the content-length header, so we have to do it while parsing a message. The algorithm is the exact same as used for H1 messages.
2018-12-19 12:08:08 +00:00
if (isteq(list[idx].n, ist("content-length"))) {
MEDIUM: h2: always parse and deduplicate the content-length header The header used to be parsed only in HTX but not in legacy. And even in HTX mode, the value was dropped. Let's always parse it and report the parsed value back so that we'll be able to store it in the streams.
2019-01-24 10:33:02 +00:00
ret = h2_parse_cont_len_header(msgf, &list[idx].v, body_len);
MEDIUM: h2: properly check and deduplicate the content-length header in HTX When producing an HTX message, we can't rely on the next-level H1 parser to check and deduplicate the content-length header, so we have to do it while parsing a message. The algorithm is the exact same as used for H1 messages.
2018-12-19 12:08:08 +00:00
if (ret < 0)
goto fail;
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
sl_flags |= HTX_SL_F_CLEN;
MEDIUM: h2: properly check and deduplicate the content-length header in HTX When producing an HTX message, we can't rely on the next-level H1 parser to check and deduplicate the content-length header, so we have to do it while parsing a message. The algorithm is the exact same as used for H1 messages.
2018-12-19 12:08:08 +00:00
if (ret == 0)
continue; // skip this duplicate
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
}
/* these ones are forbidden in requests (RFC7540#8.1.2.2) */
if (isteq(list[idx].n, ist("connection")) ||
isteq(list[idx].n, ist("proxy-connection")) ||
isteq(list[idx].n, ist("keep-alive")) ||
isteq(list[idx].n, ist("upgrade")) ||
isteq(list[idx].n, ist("transfer-encoding")))
goto fail;
if (isteq(list[idx].n, ist("te")) && !isteq(list[idx].v, ist("trailers")))
goto fail;
/* cookie requires special processing at the end */
if (isteq(list[idx].n, ist("cookie"))) {
list[idx].n.len = -1;
if (ck < 0)
ck = idx;
else
list[lck].n.len = idx;
lck = idx;
continue;
}
if (!htx_add_header(htx, list[idx].n, list[idx].v))
goto fail;
}
/* RFC7540#8.1.2.1 mandates to reject response pseudo-headers (:status) */
if (fields & H2_PHDR_FND_STAT)
goto fail;
/* Let's dump the request now if not yet emitted. */
if (!(fields & H2_PHDR_FND_NONE)) {
sl = h2_prepare_htx_reqline(fields, phdr_val, htx, msgf);
if (!sl)
goto fail;
}
MINOR: h2/htx: Set the flag HTX_SL_F_BODYLESS for messages without body This information is usefull to know if a body is expected or not, regardless the presence or not of the header "Content-Length" and its value. Once the ES flag is set on the header frame or when the content length is 0, we can safely add the flag HTX_SL_F_BODYLESS on the HTX start-line. Among other things, it will help the mux-h1 to know if it should add TE header or not. It will also help the HTTP compression filter. This patch must be backported to 1.9 because a bug fix depends on it.
2019-02-18 09:12:56 +00:00
if (!(*msgf & H2_MSGF_BODY) || ((*msgf & H2_MSGF_BODY_CL) && *body_len == 0))
sl_flags |= HTX_SL_F_BODYLESS;
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
/* update the start line with last detected header info */
sl->flags |= sl_flags;
/* complete with missing Host if needed */
if ((fields & (H2_PHDR_FND_HOST|H2_PHDR_FND_AUTH)) == H2_PHDR_FND_AUTH) {
/* missing Host field, use :authority instead */
if (!htx_add_header(htx, ist("host"), phdr_val[H2_PHDR_IDX_AUTH]))
goto fail;
}
/* now we may have to build a cookie list. We'll dump the values of all
* visited headers.
*/
if (ck >= 0) {
uint32_t fs; // free space
uint32_t bs; // block size
uint32_t vl; // value len
BUG/MEDIUM: h2: fix aggregated cookie length computation in HTX mode Cyril Bont reported a bug in the way the cookie length is computed when aggregating multiple cookies : the first cookie name was counted as part of the value length, causing random contents to be placed there, possibly leading to bad requests. No backport is needed.
2018-12-18 10:00:41 +00:00
uint32_t tl; // total length
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
struct htx_blk *blk;
blk = htx_add_header(htx, ist("cookie"), list[ck].v);
if (!blk)
goto fail;
BUG/MEDIUM: h2: fix aggregated cookie length computation in HTX mode Cyril Bont reported a bug in the way the cookie length is computed when aggregating multiple cookies : the first cookie name was counted as part of the value length, causing random contents to be placed there, possibly leading to bad requests. No backport is needed.
2018-12-18 10:00:41 +00:00
tl = list[ck].v.len;
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
fs = htx_free_data_space(htx);
bs = htx_get_blksz(blk);
/* for each extra cookie, we'll extend the cookie's value and
* insert "; " before the new value.
*/
BUG/MEDIUM: h2: fix aggregated cookie length computation in HTX mode Cyril Bont reported a bug in the way the cookie length is computed when aggregating multiple cookies : the first cookie name was counted as part of the value length, causing random contents to be placed there, possibly leading to bad requests. No backport is needed.
2018-12-18 10:00:41 +00:00
fs += tl; // first one is already counted
for (; (ck = list[ck].n.len) >= 0 ; ) {
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
vl = list[ck].v.len;
BUG/MEDIUM: h2: fix aggregated cookie length computation in HTX mode Cyril Bont reported a bug in the way the cookie length is computed when aggregating multiple cookies : the first cookie name was counted as part of the value length, causing random contents to be placed there, possibly leading to bad requests. No backport is needed.
2018-12-18 10:00:41 +00:00
tl += vl + 2;
if (tl > fs)
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
goto fail;
BUG/MEDIUM: htx: Fully update HTX message when the block value is changed Everywhere the value length of a block is changed, calling the function htx_set_blk_value_len(), the HTX message must be updated. But at many places, because of the recent changes in the HTX structure, this update was only partially done. tail_addr and head_addr values were not systematically updated. In fact, the function htx_set_blk_value_len() was designed as an internal function to the HTX API. And we used it from outside by convenience. But it is really painfull and error prone to let the caller update the HTX message. So now, we use the function htx_change_blk_value_len() wherever is possible. It changes the value length of a block and updates the HTX message accordingly. This patch must be backported to 2.0.
2019-06-18 07:49:16 +00:00
htx_change_blk_value_len(htx, blk, tl);
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
*(char *)(htx_get_blk_ptr(htx, blk) + bs + 0) = ';';
*(char *)(htx_get_blk_ptr(htx, blk) + bs + 1) = ' ';
memcpy(htx_get_blk_ptr(htx, blk) + bs + 2, list[ck].v.ptr, vl);
bs += vl + 2;
}
}
/* now send the end of headers marker */
htx_add_endof(htx, HTX_BLK_EOH);
MINOR: h2/htx: Set hdrs_bytes on the SL when an HTX message is produced
2019-05-15 13:53:20 +00:00
/* Set bytes used in the HTX mesage for the headers now */
sl->hdrs_bytes = htx_used_space(htx) - used;
MINOR: h2: implement H2->HTX request header frame transcoding Till now we could only produce an HTTP/1 request from a list of H2 request headers. Now the new function h2_make_htx_request() does the same but using the HTX encoding instead, while respecting the H2 semantics. The code is not much different from the first version, only the encoding differs. For now it's not used.
2018-11-27 14:34:18 +00:00
ret = 1;
return ret;
fail:
return -1;
}
MINOR: h2: add new functions to produce an HTX message from an H2 response The new function h2_prepare_htx_stsline() produces an HTX response message from an H2 response presented as a list of header fields.
2018-10-08 12:49:20 +00:00
/* Prepare the status line into <htx> from pseudo headers stored in <phdr[]>.
* <fields> indicates what was found so far. This should be called once at the
* detection of the first general header field or at the end of the message if
* no general header field was found yet. Returns the created start line on
* success, or NULL on failure. Upon success, <msgf> is updated with a few
* H2_MSGF_* flags indicating what was found while parsing.
*/
static struct htx_sl *h2_prepare_htx_stsline(uint32_t fields, struct ist *phdr, struct htx *htx, unsigned int *msgf)
{
unsigned int flags = HTX_SL_F_NONE;
struct htx_sl *sl;
unsigned char h, t, u;
/* only :status is allowed as a pseudo header */
if (!(fields & H2_PHDR_FND_STAT))
goto fail;
if (phdr[H2_PHDR_IDX_STAT].len != 3)
goto fail;
/* Set HTX start-line flags */
flags |= HTX_SL_F_VER_11; // V2 in fact
flags |= HTX_SL_F_XFER_LEN; // xfer len always known with H2
sl = htx_add_stline(htx, HTX_BLK_RES_SL, flags, ist("HTTP/2.0"), phdr[H2_PHDR_IDX_STAT], ist(""));
if (!sl)
goto fail;
h = phdr[H2_PHDR_IDX_STAT].ptr[0] - '0';
t = phdr[H2_PHDR_IDX_STAT].ptr[1] - '0';
u = phdr[H2_PHDR_IDX_STAT].ptr[2] - '0';
if (h > 9 || t > 9 || u > 9)
goto fail;
sl->info.res.status = h * 100 + t * 10 + u;
BUG/MEDIUM: h2/htx: Correctly handle interim responses when HTX is enabled 1xx responses does not work in HTTP2 when the HTX is enabled. First of all, when a response is parsed, only one HEADERS frame is expected. So when an interim response is received, the flag H2_SF_HEADERS_RCVD is set and the next HEADERS frame (for another interim repsonse or the final one) is parsed as a trailers one. Then when the response is sent, because an EOM block is found at the end of the interim HTX response, the ES flag is added on the frame, closing too early the stream. Here, it is a design problem of the HTX. Iterim responses are considered as full messages, leading to some ambiguities when HTX messages are processed. This will not be fixed now, but we need to keep it in mind for future improvements. To fix the parsing bug, the flag H2_MSGF_RSP_1XX is added when the response headers are decoded. When this flag is set, an EOM block is added into the HTX message, despite the fact that there is no ES flag on the frame. And we don't set the flag H2_SF_HEADERS_RCVD on the corresponding H2S. So the next HEADERS frame will not be parsed as a trailers one. To fix the sending bug, the ES flag is not set on the frame when an interim response is processed and the flag H2_SF_HEADERS_SENT is not set on the corresponding H2S. This patch must be backported to 1.9.
2019-02-19 14:14:23 +00:00
/* On 1xx responses (except 101) there is no ES on the HEADERS frame but
* there is no body. So remove the flag H2_MSGF_BODY and add
* H2_MSGF_RSP_1XX to notify the decoder another HEADERS frame is
* expected.
*/
if (sl->info.res.status < 200 &&
(sl->info.res.status == 100 || sl->info.res.status >= 102)) {
*msgf |= H2_MSGF_RSP_1XX;
*msgf &= ~H2_MSGF_BODY;
}
MINOR: h2: add new functions to produce an HTX message from an H2 response The new function h2_prepare_htx_stsline() produces an HTX response message from an H2 response presented as a list of header fields.
2018-10-08 12:49:20 +00:00
return sl;
fail:
return NULL;
}
/* Takes an H2 response present in the headers list <list> terminated by a name
* being <NULL,0> and emits the equivalent HTX response according to the rules
* documented in RFC7540 #8.1.2. The output contents are emitted in <htx>, and
* a positive value is returned if some bytes were emitted. In case of error, a
* negative error code is returned.
*
* Upon success, <msgf> is filled with a few H2_MSGF_* flags indicating what
* was found while parsing. The caller must set it to zero in or H2_MSGF_BODY
* if a body is detected (!ES).
*
* The headers list <list> must be composed of :
* - n.name != NULL, n.len > 0 : literal header name
* - n.name == NULL, n.len > 0 : indexed pseudo header name number <n.len>
* among H2_PHDR_IDX_*
* - n.name ignored, n.len == 0 : end of list
* - in all cases except the end of list, v.name and v.len must designate a
* valid value.
*/
MEDIUM: h2: always parse and deduplicate the content-length header The header used to be parsed only in HTX but not in legacy. And even in HTX mode, the value was dropped. Let's always parse it and report the parsed value back so that we'll be able to store it in the streams.
2019-01-24 10:33:02 +00:00
int h2_make_htx_response(struct http_hdr *list, struct htx *htx, unsigned int *msgf, unsigned long long *body_len)
MINOR: h2: add new functions to produce an HTX message from an H2 response The new function h2_prepare_htx_stsline() produces an HTX response message from an H2 response presented as a list of header fields.
2018-10-08 12:49:20 +00:00
{
struct ist phdr_val[H2_PHDR_NUM_ENTRIES];
uint32_t fields; /* bit mask of H2_PHDR_FND_* */
uint32_t idx;
int phdr;
int ret;
int i;
MINOR: h2/htx: Set hdrs_bytes on the SL when an HTX message is produced
2019-05-15 13:53:20 +00:00
uint32_t used = htx_used_space(htx);
MINOR: h2: add new functions to produce an HTX message from an H2 response The new function h2_prepare_htx_stsline() produces an HTX response message from an H2 response presented as a list of header fields.
2018-10-08 12:49:20 +00:00
struct htx_sl *sl = NULL;
unsigned int sl_flags = 0;
fields = 0;
for (idx = 0; list[idx].n.len != 0; idx++) {
if (!list[idx].n.ptr) {
/* this is an indexed pseudo-header */
phdr = list[idx].n.len;
}
else {
/* this can be any type of header */
/* RFC7540#8.1.2: upper case not allowed in header field names */
for (i = 0; i < list[idx].n.len; i++)
if ((uint8_t)(list[idx].n.ptr[i] - 'A') < 'Z' - 'A')
goto fail;
phdr = h2_str_to_phdr(list[idx].n);
}
if (phdr > 0 && phdr < H2_PHDR_NUM_ENTRIES) {
/* insert a pseudo header by its index (in phdr) and value (in value) */
if (fields & ((1 << phdr) | H2_PHDR_FND_NONE)) {
if (fields & H2_PHDR_FND_NONE) {
/* pseudo header field after regular headers */
goto fail;
}
else {
/* repeated pseudo header field */
goto fail;
}
}
fields |= 1 << phdr;
phdr_val[phdr] = list[idx].v;
continue;
}
else if (phdr != 0) {
/* invalid pseudo header -- should never happen here */
goto fail;
}
/* regular header field in (name,value) */
if (!(fields & H2_PHDR_FND_NONE)) {
/* no more pseudo-headers, time to build the status line */
sl = h2_prepare_htx_stsline(fields, phdr_val, htx, msgf);
if (!sl)
goto fail;
fields |= H2_PHDR_FND_NONE;
}
MEDIUM: h2: properly check and deduplicate the content-length header in HTX When producing an HTX message, we can't rely on the next-level H1 parser to check and deduplicate the content-length header, so we have to do it while parsing a message. The algorithm is the exact same as used for H1 messages.
2018-12-19 12:08:08 +00:00
if (isteq(list[idx].n, ist("content-length"))) {
MEDIUM: h2: always parse and deduplicate the content-length header The header used to be parsed only in HTX but not in legacy. And even in HTX mode, the value was dropped. Let's always parse it and report the parsed value back so that we'll be able to store it in the streams.
2019-01-24 10:33:02 +00:00
ret = h2_parse_cont_len_header(msgf, &list[idx].v, body_len);
MEDIUM: h2: properly check and deduplicate the content-length header in HTX When producing an HTX message, we can't rely on the next-level H1 parser to check and deduplicate the content-length header, so we have to do it while parsing a message. The algorithm is the exact same as used for H1 messages.
2018-12-19 12:08:08 +00:00
if (ret < 0)
goto fail;
MINOR: h2: add new functions to produce an HTX message from an H2 response The new function h2_prepare_htx_stsline() produces an HTX response message from an H2 response presented as a list of header fields.
2018-10-08 12:49:20 +00:00
sl_flags |= HTX_SL_F_CLEN;
MEDIUM: h2: properly check and deduplicate the content-length header in HTX When producing an HTX message, we can't rely on the next-level H1 parser to check and deduplicate the content-length header, so we have to do it while parsing a message. The algorithm is the exact same as used for H1 messages.
2018-12-19 12:08:08 +00:00
if (ret == 0)
continue; // skip this duplicate
MINOR: h2: add new functions to produce an HTX message from an H2 response The new function h2_prepare_htx_stsline() produces an HTX response message from an H2 response presented as a list of header fields.
2018-10-08 12:49:20 +00:00
}
/* these ones are forbidden in responses (RFC7540#8.1.2.2) */
if (isteq(list[idx].n, ist("connection")) ||
isteq(list[idx].n, ist("proxy-connection")) ||
isteq(list[idx].n, ist("keep-alive")) ||
isteq(list[idx].n, ist("upgrade")) ||
isteq(list[idx].n, ist("transfer-encoding")))
goto fail;
if (!htx_add_header(htx, list[idx].n, list[idx].v))
goto fail;
}
/* RFC7540#8.1.2.1 mandates to reject request pseudo-headers */
if (fields & (H2_PHDR_FND_AUTH|H2_PHDR_FND_METH|H2_PHDR_FND_PATH|H2_PHDR_FND_SCHM))
goto fail;
/* Let's dump the request now if not yet emitted. */
if (!(fields & H2_PHDR_FND_NONE)) {
sl = h2_prepare_htx_stsline(fields, phdr_val, htx, msgf);
if (!sl)
goto fail;
}
MINOR: h2/htx: Set the flag HTX_SL_F_BODYLESS for messages without body This information is usefull to know if a body is expected or not, regardless the presence or not of the header "Content-Length" and its value. Once the ES flag is set on the header frame or when the content length is 0, we can safely add the flag HTX_SL_F_BODYLESS on the HTX start-line. Among other things, it will help the mux-h1 to know if it should add TE header or not. It will also help the HTTP compression filter. This patch must be backported to 1.9 because a bug fix depends on it.
2019-02-18 09:12:56 +00:00
if (!(*msgf & H2_MSGF_BODY) || ((*msgf & H2_MSGF_BODY_CL) && *body_len == 0))
sl_flags |= HTX_SL_F_BODYLESS;
MINOR: h2: add new functions to produce an HTX message from an H2 response The new function h2_prepare_htx_stsline() produces an HTX response message from an H2 response presented as a list of header fields.
2018-10-08 12:49:20 +00:00
/* update the start line with last detected header info */
sl->flags |= sl_flags;
if ((*msgf & (H2_MSGF_BODY|H2_MSGF_BODY_TUNNEL|H2_MSGF_BODY_CL)) == H2_MSGF_BODY) {
/* FIXME: Do we need to signal anything when we have a body and
* no content-length, to have the equivalent of H1's chunked
* encoding?
*/
}
/* now send the end of headers marker */
htx_add_endof(htx, HTX_BLK_EOH);
MINOR: h2/htx: Set hdrs_bytes on the SL when an HTX message is produced
2019-05-15 13:53:20 +00:00
/* Set bytes used in the HTX mesage for the headers now */
sl->hdrs_bytes = htx_used_space(htx) - used;
MINOR: h2: add new functions to produce an HTX message from an H2 response The new function h2_prepare_htx_stsline() produces an HTX response message from an H2 response presented as a list of header fields.
2018-10-08 12:49:20 +00:00
ret = 1;
return ret;
fail:
return -1;
}
MINOR: h2: add h2_make_htx_trailers to turn H2 headers to HTX trailers This function is usable to transform a list of H2 header fields to a HTX trailers block. It takes care of rejecting forbidden headers and pseudo-headers when performing the conversion. It also emits the trailing CRLF that is currently needed in the HTX trailers block.
2019-01-03 17:39:54 +00:00
MEDIUM: htx: Add the parsing of trailers of chunked messages HTTP trailers are now parsed in the same way headers are. It means trailers are converted to K/V blocks followed by an end-of-trailer marker. For now, to make things simple, the type for trailer blocks are not the same than for header blocks. But the aim is to make no difference between headers and trailers by using the same type. Probably for the end-of marker too.
2019-06-03 08:41:26 +00:00
/* Takes an H2 headers list <list> terminated by a name being <NULL,0> and emits
* the equivalent HTX trailers blocks. The output contents are emitted in <htx>,
* and a positive value is returned if some bytes were emitted. In case of
* error, a negative error code is returned. The caller must have verified that
* the message in the buffer is compatible with receipt of trailers.
MINOR: h2: add h2_make_htx_trailers to turn H2 headers to HTX trailers This function is usable to transform a list of H2 header fields to a HTX trailers block. It takes care of rejecting forbidden headers and pseudo-headers when performing the conversion. It also emits the trailing CRLF that is currently needed in the HTX trailers block.
2019-01-03 17:39:54 +00:00
*
* The headers list <list> must be composed of :
* - n.name != NULL, n.len > 0 : literal header name
* - n.name == NULL, n.len > 0 : indexed pseudo header name number <n.len>
* among H2_PHDR_IDX_* (illegal here)
* - n.name ignored, n.len == 0 : end of list
* - in all cases except the end of list, v.name and v.len must designate a
* valid value.
*/
int h2_make_htx_trailers(struct http_hdr *list, struct htx *htx)
{
uint32_t idx;
int i;
for (idx = 0; list[idx].n.len != 0; idx++) {
if (!list[idx].n.ptr) {
/* This is an indexed pseudo-header (RFC7540#8.1.2.1) */
goto fail;
}
/* RFC7540#8.1.2: upper case not allowed in header field names */
for (i = 0; i < list[idx].n.len; i++)
if ((uint8_t)(list[idx].n.ptr[i] - 'A') < 'Z' - 'A')
goto fail;
if (h2_str_to_phdr(list[idx].n) != 0) {
/* This is a pseudo-header (RFC7540#8.1.2.1) */
goto fail;
}
/* these ones are forbidden in trailers (RFC7540#8.1.2.2) */
if (isteq(list[idx].n, ist("host")) ||
isteq(list[idx].n, ist("content-length")) ||
isteq(list[idx].n, ist("connection")) ||
isteq(list[idx].n, ist("proxy-connection")) ||
isteq(list[idx].n, ist("keep-alive")) ||
isteq(list[idx].n, ist("upgrade")) ||
isteq(list[idx].n, ist("te")) ||
isteq(list[idx].n, ist("transfer-encoding")))
goto fail;
MEDIUM: htx: Add the parsing of trailers of chunked messages HTTP trailers are now parsed in the same way headers are. It means trailers are converted to K/V blocks followed by an end-of-trailer marker. For now, to make things simple, the type for trailer blocks are not the same than for header blocks. But the aim is to make no difference between headers and trailers by using the same type. Probably for the end-of marker too.
2019-06-03 08:41:26 +00:00
if (!htx_add_trailer(htx, list[idx].n, list[idx].v))
goto fail;
MINOR: h2: add h2_make_htx_trailers to turn H2 headers to HTX trailers This function is usable to transform a list of H2 header fields to a HTX trailers block. It takes care of rejecting forbidden headers and pseudo-headers when performing the conversion. It also emits the trailing CRLF that is currently needed in the HTX trailers block.
2019-01-03 17:39:54 +00:00
}
MEDIUM: htx: Add the parsing of trailers of chunked messages HTTP trailers are now parsed in the same way headers are. It means trailers are converted to K/V blocks followed by an end-of-trailer marker. For now, to make things simple, the type for trailer blocks are not the same than for header blocks. But the aim is to make no difference between headers and trailers by using the same type. Probably for the end-of marker too.
2019-06-03 08:41:26 +00:00
if (!htx_add_endof(htx, HTX_BLK_EOT))
MINOR: h2: add h2_make_htx_trailers to turn H2 headers to HTX trailers This function is usable to transform a list of H2 header fields to a HTX trailers block. It takes care of rejecting forbidden headers and pseudo-headers when performing the conversion. It also emits the trailing CRLF that is currently needed in the HTX trailers block.
2019-01-03 17:39:54 +00:00
goto fail;
return 1;
fail:
return -1;
}
Reference in New Issue Copy Permalink