RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2024-12-21 11:58:03 +00:00
Code Issues Packages Projects Releases Wiki Activity
f8c1b648c0
haproxy/include/common/h2.h

336 lines
12 KiB
C
Raw Normal View History

MINOR: h2: centralize all HTTP/2 protocol elements and constants These constants from RFC7540 will be centralized into common/h2.h for use by the future h2 mux and other places.
2016-12-13 17:25:15 +00:00
/*
* include/common/h2.h
* This file contains types and macros used for the HTTP/2 protocol
*
* Copyright (C) 2000-2017 Willy Tarreau - w@1wt.eu
* Copyright (C) 2017 HAProxy Technologies
*
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
* 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:
MINOR: h2: centralize all HTTP/2 protocol elements and constants These constants from RFC7540 will be centralized into common/h2.h for use by the future h2 mux and other places.
2016-12-13 17:25:15 +00:00
*
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
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
MINOR: h2: centralize all HTTP/2 protocol elements and constants These constants from RFC7540 will be centralized into common/h2.h for use by the future h2 mux and other places.
2016-12-13 17:25:15 +00:00
*
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
* 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.
MINOR: h2: centralize all HTTP/2 protocol elements and constants These constants from RFC7540 will be centralized into common/h2.h for use by the future h2 mux and other places.
2016-12-13 17:25:15 +00:00
*/
#ifndef _COMMON_H2_H
#define _COMMON_H2_H
REORG: include: update all files to use haproxy/api.h or api-t.h if needed All files that were including one of the following include files have been updated to only include haproxy/api.h or haproxy/api-t.h once instead: - common/config.h - common/compat.h - common/compiler.h - common/defaults.h - common/initcall.h - common/tools.h The choice is simple: if the file only requires type definitions, it includes api-t.h, otherwise it includes the full api.h. In addition, in these files, explicit includes for inttypes.h and limits.h were dropped since these are now covered by api.h and api-t.h. No other change was performed, given that this patch is large and affects 201 files. At least one (tools.h) was already freestanding and didn't get the new one added.
2020-05-27 10:58:42 +00:00
#include <haproxy/api.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/http-hdr.h>
REORG: htx: merge types+proto into common/htx.h All the HTX definition is self-contained and doesn't really depend on anything external since it's a mostly protocol. In addition, some external similar files (like h2) also placed in common used to rely on it, making it a bit awkward. This patch moves the two htx.h files into a single self-contained one. The historical dependency on sample.h could be also removed since it used to be there only for http_meth_t which is now in http.h.
2018-12-11 09:22:41 +00:00
#include <common/htx.h>
REORG: include: move ist.h from common/ to import/ Fortunately that file wasn't made dependent upon haproxy since it was integrated, better isolate it before it's too late. Its dependency on api.h was the result of the change from config.h, which in turn wasn't correct. It was changed back to stddef.h for size_t and sys/types.h for ssize_t. The recently added reference to MAX() was changed as it was placed only to avoid a zero length in the non-free-standing version and was causing a build warning in the hpack encoder.
2020-05-27 14:21:26 +00:00
#include <import/ist.h>
MINOR: h2: centralize all HTTP/2 protocol elements and constants These constants from RFC7540 will be centralized into common/h2.h for use by the future h2 mux and other places.
2016-12-13 17:25:15 +00:00
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
/* indexes of most important pseudo headers can be simplified to an almost
* linear array by dividing the index by 2 for all values from 1 to 9, and
* caping to 4 for values up to 14 ; thus it fits in a single 24-bit array
* shifted by 3 times the index value/2, or a 32-bit array shifted by 4x.
* Don't change these values, they are assumed by hpack_idx_to_phdr(). There
* is an entry for the Host header field which is not a pseudo-header but
* needs to be tracked as we should only use :authority if it's absent.
*/
enum {
H2_PHDR_IDX_NONE = 0,
H2_PHDR_IDX_AUTH = 1, /* :authority = 1 */
H2_PHDR_IDX_METH = 2, /* :method = 2..3 */
H2_PHDR_IDX_PATH = 3, /* :path = 4..5 */
H2_PHDR_IDX_SCHM = 4, /* :scheme = 6..7 */
H2_PHDR_IDX_STAT = 5, /* :status = 8..14 */
H2_PHDR_IDX_HOST = 6, /* Host, never returned, just a place-holder */
H2_PHDR_NUM_ENTRIES /* must be last */
};
/* bit fields indicating the pseudo-headers found. It also covers the HOST
* header field as well as any non-pseudo-header field (NONE).
*/
enum {
H2_PHDR_FND_NONE = 1 << H2_PHDR_IDX_NONE, /* found a regular header */
H2_PHDR_FND_AUTH = 1 << H2_PHDR_IDX_AUTH,
H2_PHDR_FND_METH = 1 << H2_PHDR_IDX_METH,
H2_PHDR_FND_PATH = 1 << H2_PHDR_IDX_PATH,
H2_PHDR_FND_SCHM = 1 << H2_PHDR_IDX_SCHM,
H2_PHDR_FND_STAT = 1 << H2_PHDR_IDX_STAT,
H2_PHDR_FND_HOST = 1 << H2_PHDR_IDX_HOST,
};
MINOR: h2: centralize all HTTP/2 protocol elements and constants These constants from RFC7540 will be centralized into common/h2.h for use by the future h2 mux and other places.
2016-12-13 17:25:15 +00:00
/* frame types, from the standard */
enum h2_ft {
H2_FT_DATA = 0x00, // RFC7540 #6.1
H2_FT_HEADERS = 0x01, // RFC7540 #6.2
H2_FT_PRIORITY = 0x02, // RFC7540 #6.3
H2_FT_RST_STREAM = 0x03, // RFC7540 #6.4
H2_FT_SETTINGS = 0x04, // RFC7540 #6.5
H2_FT_PUSH_PROMISE = 0x05, // RFC7540 #6.6
H2_FT_PING = 0x06, // RFC7540 #6.7
H2_FT_GOAWAY = 0x07, // RFC7540 #6.8
H2_FT_WINDOW_UPDATE = 0x08, // RFC7540 #6.9
H2_FT_CONTINUATION = 0x09, // RFC7540 #6.10
H2_FT_ENTRIES /* must be last */
} __attribute__((packed));
MINOR: h2: add a bit-based frame type representation This will ease checks among sets of frames.
2018-12-21 13:56:57 +00:00
/* frame types, turned to bits or bit fields */
enum {
/* one bit per frame type */
H2_FT_DATA_BIT = 1U << H2_FT_DATA,
H2_FT_HEADERS_BIT = 1U << H2_FT_HEADERS,
H2_FT_PRIORITY_BIT = 1U << H2_FT_PRIORITY,
H2_FT_RST_STREAM_BIT = 1U << H2_FT_RST_STREAM,
H2_FT_SETTINGS_BIT = 1U << H2_FT_SETTINGS,
H2_FT_PUSH_PROMISE_BIT = 1U << H2_FT_PUSH_PROMISE,
H2_FT_PING_BIT = 1U << H2_FT_PING,
H2_FT_GOAWAY_BIT = 1U << H2_FT_GOAWAY,
H2_FT_WINDOW_UPDATE_BIT = 1U << H2_FT_WINDOW_UPDATE,
H2_FT_CONTINUATION_BIT = 1U << H2_FT_CONTINUATION,
/* padded frames */
MINOR: h2: declare new sets of frame types This patch adds H2_FT_HDR_MASK to group all frame types carrying headers information, and H2_FT_LATE_MASK to group frame types allowed to arrive after a stream was closed.
2019-01-24 08:31:40 +00:00
H2_FT_PADDED_MASK = H2_FT_DATA_BIT | H2_FT_HEADERS_BIT | H2_FT_PUSH_PROMISE_BIT,
MINOR: h2: add a bit-based frame type representation This will ease checks among sets of frames.
2018-12-21 13:56:57 +00:00
/* flow controlled frames */
MINOR: h2: declare new sets of frame types This patch adds H2_FT_HDR_MASK to group all frame types carrying headers information, and H2_FT_LATE_MASK to group frame types allowed to arrive after a stream was closed.
2019-01-24 08:31:40 +00:00
H2_FT_FC_MASK = H2_FT_DATA_BIT,
/* header frames */
H2_FT_HDR_MASK = H2_FT_HEADERS_BIT | H2_FT_PUSH_PROMISE_BIT | H2_FT_CONTINUATION_BIT,
/* frames allowed to arrive late on a stream */
H2_FT_LATE_MASK = H2_FT_WINDOW_UPDATE_BIT | H2_FT_RST_STREAM_BIT | H2_FT_PRIORITY_BIT,
MINOR: h2: add a bit-based frame type representation This will ease checks among sets of frames.
2018-12-21 13:56:57 +00:00
};
MINOR: h2: centralize all HTTP/2 protocol elements and constants These constants from RFC7540 will be centralized into common/h2.h for use by the future h2 mux and other places.
2016-12-13 17:25:15 +00:00
/* flags defined for each frame type */
// RFC7540 #6.1
#define H2_F_DATA_END_STREAM 0x01
#define H2_F_DATA_PADDED 0x08
// RFC7540 #6.2
#define H2_F_HEADERS_END_STREAM 0x01
#define H2_F_HEADERS_END_HEADERS 0x04
#define H2_F_HEADERS_PADDED 0x08
#define H2_F_HEADERS_PRIORITY 0x20
// RFC7540 #6.3 : PRIORITY defines no flags
// RFC7540 #6.4 : RST_STREAM defines no flags
// RFC7540 #6.5
#define H2_F_SETTINGS_ACK 0x01
// RFC7540 #6.6
#define H2_F_PUSH_PROMISE_END_HEADERS 0x04
#define H2_F_PUSH_PROMISE_PADDED 0x08
// RFC7540 #6.7
#define H2_F_PING_ACK 0x01
// RFC7540 #6.8 : GOAWAY defines no flags
// RFC7540 #6.9 : WINDOW_UPDATE defines no flags
MINOR: h2: add a bit-based frame type representation This will ease checks among sets of frames.
2018-12-21 13:56:57 +00:00
// PADDED is the exact same among DATA, HEADERS and PUSH_PROMISE (8)
#define H2_F_PADDED 0x08
MINOR: h2: centralize all HTTP/2 protocol elements and constants These constants from RFC7540 will be centralized into common/h2.h for use by the future h2 mux and other places.
2016-12-13 17:25:15 +00:00
/* HTTP/2 error codes - RFC7540 #7 */
enum h2_err {
H2_ERR_NO_ERROR = 0x0,
H2_ERR_PROTOCOL_ERROR = 0x1,
H2_ERR_INTERNAL_ERROR = 0x2,
H2_ERR_FLOW_CONTROL_ERROR = 0x3,
H2_ERR_SETTINGS_TIMEOUT = 0x4,
H2_ERR_STREAM_CLOSED = 0x5,
H2_ERR_FRAME_SIZE_ERROR = 0x6,
H2_ERR_REFUSED_STREAM = 0x7,
H2_ERR_CANCEL = 0x8,
H2_ERR_COMPRESSION_ERROR = 0x9,
H2_ERR_CONNECT_ERROR = 0xa,
H2_ERR_ENHANCE_YOUR_CALM = 0xb,
H2_ERR_INADEQUATE_SECURITY = 0xc,
H2_ERR_HTTP_1_1_REQUIRED = 0xd,
} __attribute__((packed));
// RFC7540 #11.3 : Settings Registry
#define H2_SETTINGS_HEADER_TABLE_SIZE 0x0001
#define H2_SETTINGS_ENABLE_PUSH 0x0002
#define H2_SETTINGS_MAX_CONCURRENT_STREAMS 0x0003
#define H2_SETTINGS_INITIAL_WINDOW_SIZE 0x0004
#define H2_SETTINGS_MAX_FRAME_SIZE 0x0005
#define H2_SETTINGS_MAX_HEADER_LIST_SIZE 0x0006
/* some protocol constants */
// PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n
#define H2_CONN_PREFACE \
"\x50\x52\x49\x20\x2a\x20\x48\x54" \
"\x54\x50\x2f\x32\x2e\x30\x0d\x0a" \
"\x0d\x0a\x53\x4d\x0d\x0a\x0d\x0a"
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: detect presence of CONNECT and/or content-length We'll need this in order to support uploading chunks. The h2 to h1 converter checks for the presence of the content-length header field as well as the CONNECT method and returns these information to the caller. The caller indicates whether or not a body is detected for the message (presence of END_STREAM or not). No transfer-encoding header is emitted yet.
2018-04-25 16:13:58 +00:00
/* some flags related to protocol parsing */
#define H2_MSGF_BODY 0x0001 // a body is present
#define H2_MSGF_BODY_CL 0x0002 // content-length is present
#define H2_MSGF_BODY_TUNNEL 0x0004 // a tunnel is in use (CONNECT)
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
#define H2_MSGF_RSP_1XX 0x0010 // a 1xx ( != 101) HEADERS frame was received
MINOR: h2: detect presence of CONNECT and/or content-length We'll need this in order to support uploading chunks. The h2 to h1 converter checks for the presence of the content-length header field as well as the CONNECT method and returns these information to the caller. The caller indicates whether or not a body is detected for the message (presence of END_STREAM or not). No transfer-encoding header is emitted yet.
2018-04-25 16:13:58 +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
#define H2_MAX_STREAM_ID ((1U << 31) - 1)
#define H2_MAX_FRAME_LEN ((1U << 24) - 1)
#define H2_DIR_REQ 1
#define H2_DIR_RES 2
#define H2_DIR_BOTH 3
/* constraints imposed by the protocol on each frame type, in terms of stream
* ID values, frame sizes, and direction so that most connection-level checks
* can be centralized regardless of the frame's acceptance.
*/
struct h2_frame_definition {
int32_t dir; /* 0=none, 1=request, 2=response, 3=both */
int32_t min_id; /* minimum allowed stream ID */
int32_t max_id; /* maximum allowed stream ID */
int32_t min_len; /* minimum frame length */
int32_t max_len; /* maximum frame length */
};
extern struct h2_frame_definition h2_frame_definition[H2_FT_ENTRIES];
MINOR: h2: detect presence of CONNECT and/or content-length We'll need this in order to support uploading chunks. The h2 to h1 converter checks for the presence of the content-length header field as well as the CONNECT method and returns these information to the caller. The caller indicates whether or not a body is detected for the message (presence of END_STREAM or not). No transfer-encoding header is emitted yet.
2018-04-25 16:13:58 +00:00
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
/* various protocol processing functions */
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
int h2_parse_cont_len_header(unsigned int *msgf, struct ist *value, unsigned long long *body_len);
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);
int h2_make_htx_response(struct http_hdr *list, struct htx *htx, unsigned int *msgf, unsigned long long *body_len);
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
int h2_make_htx_trailers(struct http_hdr *list, struct htx *htx);
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: centralize all HTTP/2 protocol elements and constants These constants from RFC7540 will be centralized into common/h2.h for use by the future h2 mux and other places.
2016-12-13 17:25:15 +00:00
/*
* Some helpful debugging functions.
*/
MINOR: h2: add a bit-based frame type representation This will ease checks among sets of frames.
2018-12-21 13:56:57 +00:00
/* returns a bit corresponding to the frame type */
static inline unsigned int h2_ft_bit(enum h2_ft ft)
{
return 1U << ft;
}
MINOR: h2: centralize all HTTP/2 protocol elements and constants These constants from RFC7540 will be centralized into common/h2.h for use by the future h2 mux and other places.
2016-12-13 17:25:15 +00:00
/* returns the frame type as a string */
static inline const char *h2_ft_str(int type)
{
switch (type) {
case H2_FT_DATA : return "DATA";
case H2_FT_HEADERS : return "HEADERS";
case H2_FT_PRIORITY : return "PRIORITY";
case H2_FT_RST_STREAM : return "RST_STREAM";
case H2_FT_SETTINGS : return "SETTINGS";
case H2_FT_PUSH_PROMISE : return "PUSH_PROMISE";
case H2_FT_PING : return "PING";
case H2_FT_GOAWAY : return "GOAWAY";
case H2_FT_WINDOW_UPDATE : return "WINDOW_UPDATE";
default : return "_UNKNOWN_";
}
}
MINOR: h2: add a function to report H2 error codes as strings Just like we have frame type to string, let's have error to string to improve debugging and traces.
2019-11-24 13:56:03 +00:00
/* returns the error code as a string */
static inline const char *h2_err_str(enum h2_err err)
{
switch (err) {
case H2_ERR_NO_ERROR : return "NO_ERROR";
case H2_ERR_PROTOCOL_ERROR : return "PROTOCOL_ERROR";
case H2_ERR_INTERNAL_ERROR : return "INTERNAL_ERROR";
case H2_ERR_FLOW_CONTROL_ERROR : return "FLOW_CONTROL_ERROR";
case H2_ERR_SETTINGS_TIMEOUT : return "SETTINGS_TIMEOUT";
case H2_ERR_STREAM_CLOSED : return "STREAM_CLOSED";
case H2_ERR_FRAME_SIZE_ERROR : return "FRAME_SIZE_ERROR";
case H2_ERR_REFUSED_STREAM : return "REFUSED_STREAM";
case H2_ERR_CANCEL : return "CANCEL";
case H2_ERR_COMPRESSION_ERROR : return "COMPRESSION_ERROR";
case H2_ERR_CONNECT_ERROR : return "CONNECT_ERROR";
case H2_ERR_ENHANCE_YOUR_CALM : return "ENHANCE_YOUR_CALM";
case H2_ERR_INADEQUATE_SECURITY : return "INADEQUATE_SECURITY";
case H2_ERR_HTTP_1_1_REQUIRED : return "HTTP_1_1_REQUIRED";
default : return "_UNKNOWN_";
}
}
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
/* Returns an error code if the frame is valid protocol-wise, otherwise 0. <ft>
* is the frame type (H2_FT_*), <dir> is the direction (1=req, 2=res), <id> is
* the stream ID from the frame header, <len> is the frame length from the
* header. The purpose is to be able to quickly return a PROTOCOL_ERROR or
* FRAME_SIZE_ERROR connection error even for situations where the frame will
* be ignored. <mfs> must be the max frame size currently in place for the
* protocol.
*/
static inline int h2_frame_check(enum h2_ft ft, int dir, int32_t id, int32_t len, int32_t mfs)
{
struct h2_frame_definition *fd;
if (ft >= H2_FT_ENTRIES)
return H2_ERR_NO_ERROR; // ignore unhandled frame types
fd = &h2_frame_definition[ft];
if (!(dir & fd->dir))
return H2_ERR_PROTOCOL_ERROR;
if (id < fd->min_id || id > fd->max_id)
return H2_ERR_PROTOCOL_ERROR;
if (len < fd->min_len || len > fd->max_len)
return H2_ERR_FRAME_SIZE_ERROR;
if (len > mfs)
return H2_ERR_FRAME_SIZE_ERROR;
if (ft == H2_FT_SETTINGS && (len % 6) != 0)
return H2_ERR_FRAME_SIZE_ERROR; // RFC7540#6.5
return H2_ERR_NO_ERROR;
}
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
/* returns the pseudo-header <str> corresponds to among H2_PHDR_IDX_*, 0 if not a
* pseudo-header, or -1 if not a valid pseudo-header.
*/
static inline int h2_str_to_phdr(const struct ist str)
{
if (*str.ptr == ':') {
if (isteq(str, ist(":path"))) return H2_PHDR_IDX_PATH;
else if (isteq(str, ist(":method"))) return H2_PHDR_IDX_METH;
else if (isteq(str, ist(":scheme"))) return H2_PHDR_IDX_SCHM;
else if (isteq(str, ist(":status"))) return H2_PHDR_IDX_STAT;
else if (isteq(str, ist(":authority"))) return H2_PHDR_IDX_AUTH;
/* all other names starting with ':' */
return -1;
}
/* not a pseudo header */
return 0;
}
MINOR: h2: add a function to report pseudo-header names For debugging we need to be able to dump pseudo headers when we know their name, let's put this there as we already have the other way around.
2017-12-30 13:39:09 +00:00
/* returns the pseudo-header name <num> as a string, or ":UNKNOWN" if unknown */
static inline const char *h2_phdr_to_str(int phdr)
{
switch (phdr) {
case H2_PHDR_IDX_NONE: return ":NONE";
case H2_PHDR_IDX_AUTH: return ":authority";
case H2_PHDR_IDX_METH: return ":method";
case H2_PHDR_IDX_PATH: return ":path";
case H2_PHDR_IDX_SCHM: return ":scheme";
case H2_PHDR_IDX_STAT: return ":status";
case H2_PHDR_IDX_HOST: return "Host";
default: return ":UNKNOWN";
}
}
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: centralize all HTTP/2 protocol elements and constants These constants from RFC7540 will be centralized into common/h2.h for use by the future h2 mux and other places.
2016-12-13 17:25:15 +00:00
#endif /* _COMMON_H2_H */
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/
Reference in New Issue Copy Permalink