RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2024-12-24 13:42:16 +00:00
Code Issues Packages Projects Releases Wiki Activity
341fac1eb2
haproxy/include/common/h1.h

359 lines
13 KiB
C
Raw Normal View History

REORG: http: move some very http1-specific parts to h1.{c,h} Certain types and enums are very specific to the HTTP/1 parser, and we'll need to share them with the HTTP/2 to HTTP/1 translation code. Let's move them to h1.c/h1.h. Those with very few occurrences or only used locally were renamed to explicitly mention the relevant HTTP version : enum ht_state -> h1_state. http_msg_state_str -> h1_msg_state_str HTTP_FLG_* -> H1_FLG_* http_char_classes -> h1_char_classes Others like HTTP_IS_*, HTTP_MSG_* are left to be done later.
2017-09-21 07:30:46 +00:00
/*
REORG: h1: merge types+proto into common/h1.h These two files are self-contained and do not depend on other layers, so let's remerge them together for easier manipulation.
2018-12-11 12:44:24 +00:00
* include/common/h1.h
REORG: http: move some very http1-specific parts to h1.{c,h} Certain types and enums are very specific to the HTTP/1 parser, and we'll need to share them with the HTTP/2 to HTTP/1 translation code. Let's move them to h1.c/h1.h. Those with very few occurrences or only used locally were renamed to explicitly mention the relevant HTTP version : enum ht_state -> h1_state. http_msg_state_str -> h1_msg_state_str HTTP_FLG_* -> H1_FLG_* http_char_classes -> h1_char_classes Others like HTTP_IS_*, HTTP_MSG_* are left to be done later.
2017-09-21 07:30:46 +00:00
* This file contains HTTP/1 protocol definitions.
*
* Copyright (C) 2000-2017 Willy Tarreau - w@1wt.eu
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, version 2.1
* exclusively.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
REORG: h1: merge types+proto into common/h1.h These two files are self-contained and do not depend on other layers, so let's remerge them together for easier manipulation.
2018-12-11 12:44:24 +00:00
#ifndef _COMMON_H1_H
#define _COMMON_H1_H
REORG: http: move some very http1-specific parts to h1.{c,h} Certain types and enums are very specific to the HTTP/1 parser, and we'll need to share them with the HTTP/2 to HTTP/1 translation code. Let's move them to h1.c/h1.h. Those with very few occurrences or only used locally were renamed to explicitly mention the relevant HTTP version : enum ht_state -> h1_state. http_msg_state_str -> h1_msg_state_str HTTP_FLG_* -> H1_FLG_* http_char_classes -> h1_char_classes Others like HTTP_IS_*, HTTP_MSG_* are left to be done later.
2017-09-21 07:30:46 +00:00
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
#include <common/buffer.h>
REORG: http: move some very http1-specific parts to h1.{c,h} Certain types and enums are very specific to the HTTP/1 parser, and we'll need to share them with the HTTP/2 to HTTP/1 translation code. Let's move them to h1.c/h1.h. Those with very few occurrences or only used locally were renamed to explicitly mention the relevant HTTP version : enum ht_state -> h1_state. http_msg_state_str -> h1_msg_state_str HTTP_FLG_* -> H1_FLG_* http_char_classes -> h1_char_classes Others like HTTP_IS_*, HTTP_MSG_* are left to be done later.
2017-09-21 07:30:46 +00:00
#include <common/compiler.h>
#include <common/config.h>
REORG: http: move the HTTP semantics definitions to http.h/http.c It's a bit painful to have to deal with HTTP semantics for each protocol version (H1 and H2), and working on the version-agnostic code further emphasizes the problem. This patch creates http.h and http.c which are agnostic to the version in use, and which borrow a few parts from proto_http and from h1. For example the once thought h1-specific h1_char_classes array is in fact dictated by RFC7231 and is used to parse HTTP headers. A few changes were made to a few files which were including proto_http.h while they only needed http.h. Certain string definitions pre-dated the introduction of indirect strings (ist) so some were used to simplify the definition of the known HTTP methods. The current lookup code saves 2 kB of a heavily used table and is faster than the previous table based lookup (typ. 14 ns vs 16 before).
2018-09-10 13:38:55 +00:00
#include <common/http.h>
MEDIUM: h1: reimplement the http/1 response parser for the gateway The HTTP/2->HTTP/1 gateway will need to process HTTP/1 responses. We cannot sanely rely on the HTTP/1 txn to parse a response because : 1) responses generated by haproxy such as error messages, redirects, stats or Lua are neither parsed nor indexed ; this could be addressed over the long term but will take time. 2) the http txn is useless to parse the body : the states present there are only meaningful to received bytes (ie next bytes to parse) and not at all to sent bytes. Thus chunks cannot be followed at all. Even when implementing this later, it's unsure whether it will be possible when dealing with compression. So using the HTTP txn is now out of the equation and the only remaining solution is to call an HTTP/1 message parser. We already have one, it was slightly modified to avoid keeping states by benefitting from the fact that the response was produced by haproxy and this is entirely available. It assumes the following rules are true, or that incuring an extra cost to work around them is acceptable : - the response buffer is read-write and supports modifications in place - headers sent through / by haproxy are not folded. Folding is still implemented by replacing CR/LF/tabs/spaces with spaces if encountered - HTTP/0.9 responses are never sent by haproxy and have never been supported at all - haproxy will not send partial responses, the whole headers block will be sent at once ; this means that we don't need to keep expensive states and can afford to restart the parsing from the beginning when facing a partial response ; - response is contiguous (does not wrap). This was already the case with the original parser and ensures we can safely dereference all fields with (ptr,len) The parser replaces all of the http_msg fields that were necessary with local variables. The parser is not called on an http_msg but on a string with a start and an end. The HTTP/1 states were reused for ease of use, though the request-specific ones have not been implemented for now. The error position and error state are supported and optional ; these ones may be used later for bug hunting. The parser issues the list of all the headers into a caller-allocated array of struct ist. The content-length/transfer-encoding header are checked and the relevant info fed the h1 message state (flags + body_len).
2017-07-26 07:07:47 +00:00
#include <common/http-hdr.h>
REORG: h1: merge types+proto into common/h1.h These two files are self-contained and do not depend on other layers, so let's remerge them together for easier manipulation.
2018-12-11 12:44:24 +00:00
#include <common/ist.h>
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
#include <common/standard.h>
REORG: h1: merge types+proto into common/h1.h These two files are self-contained and do not depend on other layers, so let's remerge them together for easier manipulation.
2018-12-11 12:44:24 +00:00
/* Possible states while parsing HTTP/1 messages (request|response) */
enum h1m_state {
H1_MSG_RQBEFORE = 0, // request: leading LF, before start line
H1_MSG_RQBEFORE_CR = 1, // request: leading CRLF, before start line
/* these ones define a request start line */
H1_MSG_RQMETH = 2, // parsing the Method
H1_MSG_RQMETH_SP = 3, // space(s) after the Method
H1_MSG_RQURI = 4, // parsing the Request URI
H1_MSG_RQURI_SP = 5, // space(s) after the Request URI
H1_MSG_RQVER = 6, // parsing the Request Version
H1_MSG_RQLINE_END = 7, // end of request line (CR or LF)
H1_MSG_RPBEFORE = 8, // response: leading LF, before start line
H1_MSG_RPBEFORE_CR = 9, // response: leading CRLF, before start line
/* these ones define a response start line */
H1_MSG_RPVER = 10, // parsing the Response Version
H1_MSG_RPVER_SP = 11, // space(s) after the Response Version
H1_MSG_RPCODE = 12, // response code
H1_MSG_RPCODE_SP = 13, // space(s) after the response code
H1_MSG_RPREASON = 14, // response reason
H1_MSG_RPLINE_END = 15, // end of response line (CR or LF)
/* common header processing */
H1_MSG_HDR_FIRST = 16, // waiting for first header or last CRLF (no LWS possible)
H1_MSG_HDR_NAME = 17, // parsing header name
H1_MSG_HDR_COL = 18, // parsing header colon
H1_MSG_HDR_L1_SP = 19, // parsing header LWS (SP|HT) before value
H1_MSG_HDR_L1_LF = 20, // parsing header LWS (LF) before value
H1_MSG_HDR_L1_LWS = 21, // checking whether it's a new header or an LWS
H1_MSG_HDR_VAL = 22, // parsing header value
H1_MSG_HDR_L2_LF = 23, // parsing header LWS (LF) inside/after value
H1_MSG_HDR_L2_LWS = 24, // checking whether it's a new header or an LWS
H1_MSG_LAST_LF = 25, // parsing last LF, last state for headers
/* Body processing. */
H1_MSG_CHUNK_SIZE = 26, // parsing the chunk size (RFC7230 #4.1)
H1_MSG_DATA = 27, // skipping data chunk / content-length data
H1_MSG_CHUNK_CRLF = 28, // skipping CRLF after data chunk
H1_MSG_TRAILERS = 29, // trailers (post-data entity headers)
/* we enter this state when we've received the end of the current message */
H1_MSG_DONE = 30, // message end received, waiting for resync or close
H1_MSG_TUNNEL = 31, // tunneled data after DONE
} __attribute__((packed));
/* HTTP/1 message flags (32 bit), for use in h1m->flags only */
#define H1_MF_NONE 0x00000000
#define H1_MF_CLEN 0x00000001 // content-length present
#define H1_MF_CHNK 0x00000002 // chunk present, exclusive with c-l
#define H1_MF_RESP 0x00000004 // this message is the response message
#define H1_MF_TOLOWER 0x00000008 // turn the header names to lower case
#define H1_MF_VER_11 0x00000010 // message indicates version 1.1 or above
#define H1_MF_CONN_CLO 0x00000020 // message contains "connection: close"
#define H1_MF_CONN_KAL 0x00000040 // message contains "connection: keep-alive"
#define H1_MF_CONN_UPG 0x00000080 // message contains "connection: upgrade"
#define H1_MF_XFER_LEN 0x00000100 // message xfer size can be determined
#define H1_MF_XFER_ENC 0x00000200 // transfer-encoding is present
#define H1_MF_NO_PHDR 0x00000400 // don't add pseudo-headers in the header list
MINOR: h1: make the H1 headers block parser able to parse headers only Currently the H1 headers parser works for either a request or a response because it starts from the start line. It is also able to resume its processing when it was interrupted, but in this case it doesn't update the list. Make it support a new flag, H1_MF_HDRS_ONLY so that the caller can indicate it's only interested in the headers list and not the start line. This will be convenient to parse H1 trailers.
2019-01-04 09:48:03 +00:00
#define H1_MF_HDRS_ONLY 0x00000800 // parse headers only
MEDIUM: h1: Add an option to sanitize connection headers during parsing The flag H1_MF_CLEAN_CONN_HDR has been added to let the H1 parser sanitize connection headers. It means it will remove all "close" and "keep-alive" values during the parsing. One noticeable effect is that connection headers may be unfolded. In practice, this is not a problem because it is not frequent to have multiple values for the connection headers. If this flag is set, during the parsing The function h1_parse_next_connection_header() is called in a loop instead of h1_parse_conection_header(). No need to backport this patch
2019-03-29 14:03:13 +00:00
#define H1_MF_CLEAN_CONN_HDR 0x00001000 // skip close/keep-alive values of connection headers during parsing
REORG: h1: merge types+proto into common/h1.h These two files are self-contained and do not depend on other layers, so let's remerge them together for easier manipulation.
2018-12-11 12:44:24 +00:00
/* Note: for a connection to be persistent, we need this for the request :
* - one of CLEN or CHNK
* - version 1.0 and KAL and not CLO
* - or version 1.1 and not CLO
* For the response it's the same except that UPG must not appear either.
* So in short, for a request it's (CLEN|CHNK) > 0 && !CLO && (VER_11 || KAL)
* and for a response it's (CLEN|CHNK) > 0 && !(CLO|UPG) && (VER_11 || KAL)
*/
/* basic HTTP/1 message state for use in parsers. The err_pos field is special,
* it is pre-set to a negative value (-1 or -2), and once non-negative it contains
* the relative position in the message of the first parse error. -2 is used to tell
* the parser that we want to block the invalid message. -1 is used to only perform
* a silent capture.
*/
struct h1m {
enum h1m_state state; // H1 message state (H1_MSG_*)
/* 24 bits available here */
uint32_t flags; // H1 message flags (H1_MF_*)
uint64_t curr_len; // content-length or last chunk length
uint64_t body_len; // total known size of the body length
uint32_t next; // next byte to parse, relative to buffer's head
int err_pos; // position in the byte stream of the first error (H1 or H2)
int err_state; // state where the first error was met (H1 or H2)
};
/* basic H1 start line, describes either the request and the response */
union h1_sl { /* useful start line pointers, relative to ->sol */
struct {
struct ist m; /* METHOD */
struct ist u; /* URI */
struct ist v; /* VERSION */
enum http_meth_t meth; /* method */
} rq; /* request line : field, length */
struct {
struct ist v; /* VERSION */
struct ist c; /* CODE */
struct ist r; /* REASON */
uint16_t status; /* status code */
} st; /* status line : field, length */
};
REORG: http: move some very http1-specific parts to h1.{c,h} Certain types and enums are very specific to the HTTP/1 parser, and we'll need to share them with the HTTP/2 to HTTP/1 translation code. Let's move them to h1.c/h1.h. Those with very few occurrences or only used locally were renamed to explicitly mention the relevant HTTP version : enum ht_state -> h1_state. http_msg_state_str -> h1_msg_state_str HTTP_FLG_* -> H1_FLG_* http_char_classes -> h1_char_classes Others like HTTP_IS_*, HTTP_MSG_* are left to be done later.
2017-09-21 07:30:46 +00:00
MEDIUM: h1: reimplement the http/1 response parser for the gateway The HTTP/2->HTTP/1 gateway will need to process HTTP/1 responses. We cannot sanely rely on the HTTP/1 txn to parse a response because : 1) responses generated by haproxy such as error messages, redirects, stats or Lua are neither parsed nor indexed ; this could be addressed over the long term but will take time. 2) the http txn is useless to parse the body : the states present there are only meaningful to received bytes (ie next bytes to parse) and not at all to sent bytes. Thus chunks cannot be followed at all. Even when implementing this later, it's unsure whether it will be possible when dealing with compression. So using the HTTP txn is now out of the equation and the only remaining solution is to call an HTTP/1 message parser. We already have one, it was slightly modified to avoid keeping states by benefitting from the fact that the response was produced by haproxy and this is entirely available. It assumes the following rules are true, or that incuring an extra cost to work around them is acceptable : - the response buffer is read-write and supports modifications in place - headers sent through / by haproxy are not folded. Folding is still implemented by replacing CR/LF/tabs/spaces with spaces if encountered - HTTP/0.9 responses are never sent by haproxy and have never been supported at all - haproxy will not send partial responses, the whole headers block will be sent at once ; this means that we don't need to keep expensive states and can afford to restart the parsing from the beginning when facing a partial response ; - response is contiguous (does not wrap). This was already the case with the original parser and ensures we can safely dereference all fields with (ptr,len) The parser replaces all of the http_msg fields that were necessary with local variables. The parser is not called on an http_msg but on a string with a start and an end. The HTTP/1 states were reused for ease of use, though the request-specific ones have not been implemented for now. The error position and error state are supported and optional ; these ones may be used later for bug hunting. The parser issues the list of all the headers into a caller-allocated array of struct ist. The content-length/transfer-encoding header are checked and the relevant info fed the h1 message state (flags + body_len).
2017-07-26 07:07:47 +00:00
int h1_headers_to_hdr_list(char *start, const char *stop,
struct http_hdr *hdr, unsigned int hdr_num,
MEDIUM: h1: make the parser support a pointer to a start line This will allow the parser to fill some extra fields like the method or status without having to store them permanently in the HTTP message. At this point however the parser cannot restart from an interrupted read.
2018-09-11 13:34:50 +00:00
struct h1m *h1m, union h1_sl *slp);
MINOR: h1: make h1_measure_trailers() use an offset and a count This will be needed by the H2 encoder to restart after wrapping.
2018-06-14 14:52:02 +00:00
int h1_measure_trailers(const struct buffer *buf, unsigned int ofs, unsigned int max);
REORG: http: move some very http1-specific parts to h1.{c,h} Certain types and enums are very specific to the HTTP/1 parser, and we'll need to share them with the HTTP/2 to HTTP/1 translation code. Let's move them to h1.c/h1.h. Those with very few occurrences or only used locally were renamed to explicitly mention the relevant HTTP version : enum ht_state -> h1_state. http_msg_state_str -> h1_msg_state_str HTTP_FLG_* -> H1_FLG_* http_char_classes -> h1_char_classes Others like HTTP_IS_*, HTTP_MSG_* are left to be done later.
2017-09-21 07:30:46 +00:00
MINOR: h1: Export some functions parsing the value of some HTTP headers Functions parsing the value of "Connection:", "Transfer-encoding:" and "Content-length:" headers are now exported to be used by the mux-h1.
2018-10-17 09:05:51 +00:00
int h1_parse_cont_len_header(struct h1m *h1m, struct ist *value);
void h1_parse_xfer_enc_header(struct h1m *h1m, struct ist value);
MEDIUM: h1: Add an option to sanitize connection headers during parsing The flag H1_MF_CLEAN_CONN_HDR has been added to let the H1 parser sanitize connection headers. It means it will remove all "close" and "keep-alive" values during the parsing. One noticeable effect is that connection headers may be unfolded. In practice, this is not a problem because it is not frequent to have multiple values for the connection headers. If this flag is set, during the parsing The function h1_parse_next_connection_header() is called in a loop instead of h1_parse_conection_header(). No need to backport this patch
2019-03-29 14:03:13 +00:00
void h1_parse_connection_header(struct h1m *h1m, struct ist *value);
MINOR: h1: Export some functions parsing the value of some HTTP headers Functions parsing the value of "Connection:", "Transfer-encoding:" and "Content-length:" headers are now exported to be used by the mux-h1.
2018-10-17 09:05:51 +00:00
REORG: h1: create a new h1m_state This is the *parsing* state of an HTTP/1 message. Currently the h1_state is composite as it's made both of parsing and control (100SENT, BODY, DONE, TUNNEL, ENDING etc). The purpose here is to have a purely H1 state that can be used by H1 parsers. For now it's equivalent to h1_state.
2018-09-11 09:45:04 +00:00
/* for debugging, reports the HTTP/1 message state name */
CLEANUP: h1: Fix debug warnings for h1 headers The wrong method was used to debug the h1m state here. This fixes both the signature of the h1m method and also fixes the invocation to be correct.
2018-09-14 12:30:25 +00:00
static inline const char *h1m_state_str(enum h1m_state msg_state)
REORG: h1: create a new h1m_state This is the *parsing* state of an HTTP/1 message. Currently the h1_state is composite as it's made both of parsing and control (100SENT, BODY, DONE, TUNNEL, ENDING etc). The purpose here is to have a purely H1 state that can be used by H1 parsers. For now it's equivalent to h1_state.
2018-09-11 09:45:04 +00:00
{
switch (msg_state) {
case H1_MSG_RQBEFORE: return "MSG_RQBEFORE";
case H1_MSG_RQBEFORE_CR: return "MSG_RQBEFORE_CR";
case H1_MSG_RQMETH: return "MSG_RQMETH";
case H1_MSG_RQMETH_SP: return "MSG_RQMETH_SP";
case H1_MSG_RQURI: return "MSG_RQURI";
case H1_MSG_RQURI_SP: return "MSG_RQURI_SP";
case H1_MSG_RQVER: return "MSG_RQVER";
case H1_MSG_RQLINE_END: return "MSG_RQLINE_END";
case H1_MSG_RPBEFORE: return "MSG_RPBEFORE";
case H1_MSG_RPBEFORE_CR: return "MSG_RPBEFORE_CR";
case H1_MSG_RPVER: return "MSG_RPVER";
case H1_MSG_RPVER_SP: return "MSG_RPVER_SP";
case H1_MSG_RPCODE: return "MSG_RPCODE";
case H1_MSG_RPCODE_SP: return "MSG_RPCODE_SP";
case H1_MSG_RPREASON: return "MSG_RPREASON";
case H1_MSG_RPLINE_END: return "MSG_RPLINE_END";
case H1_MSG_HDR_FIRST: return "MSG_HDR_FIRST";
case H1_MSG_HDR_NAME: return "MSG_HDR_NAME";
case H1_MSG_HDR_COL: return "MSG_HDR_COL";
case H1_MSG_HDR_L1_SP: return "MSG_HDR_L1_SP";
case H1_MSG_HDR_L1_LF: return "MSG_HDR_L1_LF";
case H1_MSG_HDR_L1_LWS: return "MSG_HDR_L1_LWS";
case H1_MSG_HDR_VAL: return "MSG_HDR_VAL";
case H1_MSG_HDR_L2_LF: return "MSG_HDR_L2_LF";
case H1_MSG_HDR_L2_LWS: return "MSG_HDR_L2_LWS";
case H1_MSG_LAST_LF: return "MSG_LAST_LF";
case H1_MSG_CHUNK_SIZE: return "MSG_CHUNK_SIZE";
case H1_MSG_DATA: return "MSG_DATA";
case H1_MSG_CHUNK_CRLF: return "MSG_CHUNK_CRLF";
case H1_MSG_TRAILERS: return "MSG_TRAILERS";
case H1_MSG_DONE: return "MSG_DONE";
case H1_MSG_TUNNEL: return "MSG_TUNNEL";
default: return "MSG_??????";
}
}
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
/* This function may be called only in HTTP_MSG_CHUNK_CRLF. It reads the CRLF or
* a possible LF alone at the end of a chunk. The caller should adjust msg->next
* in order to include this part into the next forwarding phase. Note that the
MINOR: h1: make h1_skip_chunk_crlf() not depend on b_ptr() anymore It now takes offsets relative to the buffer's head. It's up to the callers to add this offset which corresponds to the buffer's output size.
2018-06-14 13:53:21 +00:00
* caller must ensure that head+start points to the first byte to parse. It
* returns the number of bytes parsed on success, so the caller can set msg_state
* to HTTP_MSG_CHUNK_SIZE. If not enough data are available, the function does not
MEDIUM: http: make the chunk crlf parser only depend on the buffer The chunk crlf parser used to depend on the channel and on the HTTP message, eventhough it's not really needed. Let's remove this dependency so that it can be used within the H2 to H1 gateway. As part of this small API change, it was renamed to h1_skip_chunk_crlf() to mention that it doesn't depend on http_msg anymore.
2017-09-21 09:33:54 +00:00
* change anything and returns zero. Otherwise it returns a negative value
* indicating the error positionn relative to <stop>. Note: this function is
* designed to parse wrapped CRLF at the end of the buffer.
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
*/
MEDIUM: http: make the chunk crlf parser only depend on the buffer The chunk crlf parser used to depend on the channel and on the HTTP message, eventhough it's not really needed. Let's remove this dependency so that it can be used within the H2 to H1 gateway. As part of this small API change, it was renamed to h1_skip_chunk_crlf() to mention that it doesn't depend on http_msg anymore.
2017-09-21 09:33:54 +00:00
static inline int h1_skip_chunk_crlf(const struct buffer *buf, int start, int stop)
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
{
MINOR: h1: make h1_skip_chunk_crlf() not depend on b_ptr() anymore It now takes offsets relative to the buffer's head. It's up to the callers to add this offset which corresponds to the buffer's output size.
2018-06-14 13:53:21 +00:00
const char *ptr = b_peek(buf, start);
MEDIUM: http: make the chunk crlf parser only depend on the buffer The chunk crlf parser used to depend on the channel and on the HTTP message, eventhough it's not really needed. Let's remove this dependency so that it can be used within the H2 to H1 gateway. As part of this small API change, it was renamed to h1_skip_chunk_crlf() to mention that it doesn't depend on http_msg anymore.
2017-09-21 09:33:54 +00:00
int bytes = 1;
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
BUG/MEDIUM: h1: Don't parse chunks CRLF if not enough data are available As specified in the function comment, the function h1_skip_chunk_crlf() must not change anything and return zero if not enough data are available. This must include the case where there is no data at all. On this point, it must do the same that other h1 parsing functions. This bug is made visible since the commit 91f77d599 ("BUG/MINOR: mux-h1: Process input even if the input buffer is empty"). This patch must be backported to 1.9.
2019-04-19 12:12:27 +00:00
if (stop <= start)
return 0;
CLEANUP: Fix typos in the h1 subsystem Fixes typos in the code comments of the h1 subsystem.
2018-11-25 18:52:20 +00:00
/* NB: we'll check data availability at the end. It's not a
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
* problem because whatever we match first will be checked
* against the correct length.
*/
if (*ptr == '\r') {
bytes++;
ptr++;
MINOR: h1: make h1_skip_chunk_crlf() not depend on b_ptr() anymore It now takes offsets relative to the buffer's head. It's up to the callers to add this offset which corresponds to the buffer's output size.
2018-06-14 13:53:21 +00:00
if (ptr >= b_wrap(buf))
MINOR: buffer: use b_orig() to replace most references to b->data This patch updates most users of b->data to use b_orig().
2018-06-15 15:21:00 +00:00
ptr = b_orig(buf);
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
}
MEDIUM: http: make the chunk crlf parser only depend on the buffer The chunk crlf parser used to depend on the channel and on the HTTP message, eventhough it's not really needed. Let's remove this dependency so that it can be used within the H2 to H1 gateway. As part of this small API change, it was renamed to h1_skip_chunk_crlf() to mention that it doesn't depend on http_msg anymore.
2017-09-21 09:33:54 +00:00
if (bytes > stop - start)
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
return 0;
MINOR: h1: make h1_skip_chunk_crlf() not depend on b_ptr() anymore It now takes offsets relative to the buffer's head. It's up to the callers to add this offset which corresponds to the buffer's output size.
2018-06-14 13:53:21 +00:00
if (*ptr != '\n') // negative position to stop
return ptr - __b_peek(buf, stop);
MEDIUM: http: make the chunk crlf parser only depend on the buffer The chunk crlf parser used to depend on the channel and on the HTTP message, eventhough it's not really needed. Let's remove this dependency so that it can be used within the H2 to H1 gateway. As part of this small API change, it was renamed to h1_skip_chunk_crlf() to mention that it doesn't depend on http_msg anymore.
2017-09-21 09:33:54 +00:00
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
return bytes;
}
MINOR: h1: make h1_parse_chunk_size() not depend on b_ptr() anymore It's similar to the previous commit so that the function doesn't rely on buf->p anymore.
2018-06-14 13:59:05 +00:00
/* Parse the chunk size start at buf + start and stops before buf + stop. The
* positions are relative to the buffer's head.
MEDIUM: http: make the chunk size parser only depend on the buffer The chunk parser used to depend on the channel and on the HTTP message but it's not really needed as they're only used to retrieve the buffer as well as to return the number of bytes parsed and the chunk size. Here instead we pass the (few) relevant information in arguments so that the function may be reused without a channel nor an HTTP message (ie from the H2 to H1 gateway). As part of this API change, it was renamed to h1_parse_chunk_size() to mention that it doesn't depend on http_msg anymore.
2017-09-21 06:36:33 +00:00
* It returns the chunk size in <res> and the amount of bytes read this way :
* < 0 : error at this position relative to <stop>
* = 0 : not enough bytes to read a complete chunk size
* > 0 : number of bytes successfully read that the caller can skip
* On success, the caller should adjust its msg->next to point to the first
* byte of data after the chunk size, so that we know we can forward exactly
* msg->next bytes, and msg->sol to contain the exact number of bytes forming
* the chunk size. That way it is always possible to differentiate between the
* start of the body and the start of the data. Note: this function is designed
* to parse wrapped CRLF at the end of the buffer.
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
*/
MEDIUM: http: make the chunk size parser only depend on the buffer The chunk parser used to depend on the channel and on the HTTP message but it's not really needed as they're only used to retrieve the buffer as well as to return the number of bytes parsed and the chunk size. Here instead we pass the (few) relevant information in arguments so that the function may be reused without a channel nor an HTTP message (ie from the H2 to H1 gateway). As part of this API change, it was renamed to h1_parse_chunk_size() to mention that it doesn't depend on http_msg anymore.
2017-09-21 06:36:33 +00:00
static inline int h1_parse_chunk_size(const struct buffer *buf, int start, int stop, unsigned int *res)
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
{
MINOR: h1: make h1_parse_chunk_size() not depend on b_ptr() anymore It's similar to the previous commit so that the function doesn't rely on buf->p anymore.
2018-06-14 13:59:05 +00:00
const char *ptr = b_peek(buf, start);
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
const char *ptr_old = ptr;
MINOR: h1: make h1_parse_chunk_size() not depend on b_ptr() anymore It's similar to the previous commit so that the function doesn't rely on buf->p anymore.
2018-06-14 13:59:05 +00:00
const char *end = b_wrap(buf);
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
unsigned int chunk = 0;
BUG/MEDIUM: h1: ensure the chunk size parser can deal with full buffers The HTTP/1 code always has the reserve left available so the buffer is never full there. But with HTTP/2 we have to deal with full buffers, and it happens that the chunk size parser cannot tell the difference between a full buffer and an empty one since it compares the start and the stop pointer. Let's change this to instead deal with the number of bytes left to process. As a side effect, this code ends up being about 10% faster than the previous one, even on HTTP/1.
2017-11-10 10:17:08 +00:00
stop -= start; // bytes left
start = stop; // bytes to transfer
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
/* The chunk size is in the following form, though we are only
* interested in the size and CRLF :
* 1*HEXDIGIT *WSP *[ ';' extensions ] CRLF
*/
while (1) {
int c;
BUG/MEDIUM: h1: ensure the chunk size parser can deal with full buffers The HTTP/1 code always has the reserve left available so the buffer is never full there. But with HTTP/2 we have to deal with full buffers, and it happens that the chunk size parser cannot tell the difference between a full buffer and an empty one since it compares the start and the stop pointer. Let's change this to instead deal with the number of bytes left to process. As a side effect, this code ends up being about 10% faster than the previous one, even on HTTP/1.
2017-11-10 10:17:08 +00:00
if (!stop)
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
return 0;
c = hex2i(*ptr);
if (c < 0) /* not a hex digit anymore */
break;
if (unlikely(++ptr >= end))
MINOR: buffer: use b_orig() to replace most references to b->data This patch updates most users of b->data to use b_orig().
2018-06-15 15:21:00 +00:00
ptr = b_orig(buf);
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
if (unlikely(chunk & 0xF8000000)) /* integer overflow will occur if result >= 2GB */
goto error;
chunk = (chunk << 4) + c;
BUG/MEDIUM: h1: ensure the chunk size parser can deal with full buffers The HTTP/1 code always has the reserve left available so the buffer is never full there. But with HTTP/2 we have to deal with full buffers, and it happens that the chunk size parser cannot tell the difference between a full buffer and an empty one since it compares the start and the stop pointer. Let's change this to instead deal with the number of bytes left to process. As a side effect, this code ends up being about 10% faster than the previous one, even on HTTP/1.
2017-11-10 10:17:08 +00:00
stop--;
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
}
/* empty size not allowed */
if (unlikely(ptr == ptr_old))
goto error;
while (HTTP_IS_SPHT(*ptr)) {
if (++ptr >= end)
MINOR: buffer: use b_orig() to replace most references to b->data This patch updates most users of b->data to use b_orig().
2018-06-15 15:21:00 +00:00
ptr = b_orig(buf);
BUG/MEDIUM: h1: ensure the chunk size parser can deal with full buffers The HTTP/1 code always has the reserve left available so the buffer is never full there. But with HTTP/2 we have to deal with full buffers, and it happens that the chunk size parser cannot tell the difference between a full buffer and an empty one since it compares the start and the stop pointer. Let's change this to instead deal with the number of bytes left to process. As a side effect, this code ends up being about 10% faster than the previous one, even on HTTP/1.
2017-11-10 10:17:08 +00:00
if (--stop == 0)
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
return 0;
}
/* Up to there, we know that at least one byte is present at *ptr. Check
* for the end of chunk size.
*/
while (1) {
if (likely(HTTP_IS_CRLF(*ptr))) {
/* we now have a CR or an LF at ptr */
if (likely(*ptr == '\r')) {
if (++ptr >= end)
MINOR: buffer: use b_orig() to replace most references to b->data This patch updates most users of b->data to use b_orig().
2018-06-15 15:21:00 +00:00
ptr = b_orig(buf);
BUG/MEDIUM: h1: ensure the chunk size parser can deal with full buffers The HTTP/1 code always has the reserve left available so the buffer is never full there. But with HTTP/2 we have to deal with full buffers, and it happens that the chunk size parser cannot tell the difference between a full buffer and an empty one since it compares the start and the stop pointer. Let's change this to instead deal with the number of bytes left to process. As a side effect, this code ends up being about 10% faster than the previous one, even on HTTP/1.
2017-11-10 10:17:08 +00:00
if (--stop == 0)
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
return 0;
}
BUG/MEDIUM: h1: ensure the chunk size parser can deal with full buffers The HTTP/1 code always has the reserve left available so the buffer is never full there. But with HTTP/2 we have to deal with full buffers, and it happens that the chunk size parser cannot tell the difference between a full buffer and an empty one since it compares the start and the stop pointer. Let's change this to instead deal with the number of bytes left to process. As a side effect, this code ends up being about 10% faster than the previous one, even on HTTP/1.
2017-11-10 10:17:08 +00:00
if (*ptr != '\n')
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
goto error;
if (++ptr >= end)
MINOR: buffer: use b_orig() to replace most references to b->data This patch updates most users of b->data to use b_orig().
2018-06-15 15:21:00 +00:00
ptr = b_orig(buf);
BUG/MEDIUM: h1: ensure the chunk size parser can deal with full buffers The HTTP/1 code always has the reserve left available so the buffer is never full there. But with HTTP/2 we have to deal with full buffers, and it happens that the chunk size parser cannot tell the difference between a full buffer and an empty one since it compares the start and the stop pointer. Let's change this to instead deal with the number of bytes left to process. As a side effect, this code ends up being about 10% faster than the previous one, even on HTTP/1.
2017-11-10 10:17:08 +00:00
--stop;
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
/* done */
break;
}
else if (likely(*ptr == ';')) {
/* chunk extension, ends at next CRLF */
if (++ptr >= end)
MINOR: buffer: use b_orig() to replace most references to b->data This patch updates most users of b->data to use b_orig().
2018-06-15 15:21:00 +00:00
ptr = b_orig(buf);
BUG/MEDIUM: h1: ensure the chunk size parser can deal with full buffers The HTTP/1 code always has the reserve left available so the buffer is never full there. But with HTTP/2 we have to deal with full buffers, and it happens that the chunk size parser cannot tell the difference between a full buffer and an empty one since it compares the start and the stop pointer. Let's change this to instead deal with the number of bytes left to process. As a side effect, this code ends up being about 10% faster than the previous one, even on HTTP/1.
2017-11-10 10:17:08 +00:00
if (--stop == 0)
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
return 0;
while (!HTTP_IS_CRLF(*ptr)) {
if (++ptr >= end)
MINOR: buffer: use b_orig() to replace most references to b->data This patch updates most users of b->data to use b_orig().
2018-06-15 15:21:00 +00:00
ptr = b_orig(buf);
BUG/MEDIUM: h1: ensure the chunk size parser can deal with full buffers The HTTP/1 code always has the reserve left available so the buffer is never full there. But with HTTP/2 we have to deal with full buffers, and it happens that the chunk size parser cannot tell the difference between a full buffer and an empty one since it compares the start and the stop pointer. Let's change this to instead deal with the number of bytes left to process. As a side effect, this code ends up being about 10% faster than the previous one, even on HTTP/1.
2017-11-10 10:17:08 +00:00
if (--stop == 0)
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
return 0;
}
/* we have a CRLF now, loop above */
continue;
}
else
goto error;
}
/* OK we found our CRLF and now <ptr> points to the next byte, which may
MEDIUM: http: make the chunk size parser only depend on the buffer The chunk parser used to depend on the channel and on the HTTP message but it's not really needed as they're only used to retrieve the buffer as well as to return the number of bytes parsed and the chunk size. Here instead we pass the (few) relevant information in arguments so that the function may be reused without a channel nor an HTTP message (ie from the H2 to H1 gateway). As part of this API change, it was renamed to h1_parse_chunk_size() to mention that it doesn't depend on http_msg anymore.
2017-09-21 06:36:33 +00:00
* or may not be present. Let's return the number of bytes parsed.
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
*/
MEDIUM: http: make the chunk size parser only depend on the buffer The chunk parser used to depend on the channel and on the HTTP message but it's not really needed as they're only used to retrieve the buffer as well as to return the number of bytes parsed and the chunk size. Here instead we pass the (few) relevant information in arguments so that the function may be reused without a channel nor an HTTP message (ie from the H2 to H1 gateway). As part of this API change, it was renamed to h1_parse_chunk_size() to mention that it doesn't depend on http_msg anymore.
2017-09-21 06:36:33 +00:00
*res = chunk;
BUG/MEDIUM: h1: ensure the chunk size parser can deal with full buffers The HTTP/1 code always has the reserve left available so the buffer is never full there. But with HTTP/2 we have to deal with full buffers, and it happens that the chunk size parser cannot tell the difference between a full buffer and an empty one since it compares the start and the stop pointer. Let's change this to instead deal with the number of bytes left to process. As a side effect, this code ends up being about 10% faster than the previous one, even on HTTP/1.
2017-11-10 10:17:08 +00:00
return start - stop;
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
error:
MEDIUM: http: make the chunk size parser only depend on the buffer The chunk parser used to depend on the channel and on the HTTP message but it's not really needed as they're only used to retrieve the buffer as well as to return the number of bytes parsed and the chunk size. Here instead we pass the (few) relevant information in arguments so that the function may be reused without a channel nor an HTTP message (ie from the H2 to H1 gateway). As part of this API change, it was renamed to h1_parse_chunk_size() to mention that it doesn't depend on http_msg anymore.
2017-09-21 06:36:33 +00:00
*res = 0; // just to stop gcc's -Wuninitialized warning :-(
BUG/MEDIUM: h1: ensure the chunk size parser can deal with full buffers The HTTP/1 code always has the reserve left available so the buffer is never full there. But with HTTP/2 we have to deal with full buffers, and it happens that the chunk size parser cannot tell the difference between a full buffer and an empty one since it compares the start and the stop pointer. Let's change this to instead deal with the number of bytes left to process. As a side effect, this code ends up being about 10% faster than the previous one, even on HTTP/1.
2017-11-10 10:17:08 +00:00
return -stop;
REORG: http: move the HTTP/1 chunk parser to h1.{c,h} Functions http_parse_chunk_size(), http_skip_chunk_crlf() and http_forward_trailers() were moved to h1.h and h1.c respectively so that they can be called from outside. The parts that were inline remained inline as it's critical for performance (+41% perf difference reported in an earlier test). For now the "http_" prefix remains in their name since they still depend on the http_msg type.
2017-09-21 06:40:02 +00:00
}
MINOR: h1: provide a distinct init() function for request and response h1m_init() used to handle response only since it was used by the H1 client code. Let's have one init per direction.
2018-09-11 11:51:19 +00:00
/* initializes an H1 message for a request */
static inline struct h1m *h1m_init_req(struct h1m *h1m)
MINOR: h1: add struct h1m for basic HTTP/1 messages This one is much simpler than http_msg and will be used in the HTTP parsers involved in the H2 to H1 gateway.
2017-09-21 09:46:43 +00:00
{
REORG: h1: create a new h1m_state This is the *parsing* state of an HTTP/1 message. Currently the h1_state is composite as it's made both of parsing and control (100SENT, BODY, DONE, TUNNEL, ENDING etc). The purpose here is to have a purely H1 state that can be used by H1 parsers. For now it's equivalent to h1_state.
2018-09-11 09:45:04 +00:00
h1m->state = H1_MSG_RQBEFORE;
MINOR: h1: add the restart offsets into struct h1m Currently the only user of struct h1m is the h2 mux when it has to parse an H1 message coming from the channel. Unfortunately this is not enough to efficiently parse HTTP/1 messages like those coming from the network as we don't want to restart from scratch at every byte received. This patch reintroduces the "next" offset into the H1 message so that any H1 parser can use it to restart when called with a state that is not the initial state.
2018-09-11 09:51:31 +00:00
h1m->next = 0;
MINOR: h1: add a message flag to indicate that a message carries a response This flag is H1_MF_RESP. It will be used by the parser during restarts when it supports requests.
2018-09-11 14:47:23 +00:00
h1m->flags = H1_MF_NONE;
MINOR: h1: add struct h1m for basic HTTP/1 messages This one is much simpler than http_msg and will be used in the HTTP parsers involved in the H2 to H1 gateway.
2017-09-21 09:46:43 +00:00
h1m->curr_len = 0;
h1m->body_len = 0;
MINOR: h1: properly pre-initialize err_pos to -2 This way we maintain the old mechanism stating that -2 means we block on errors, -1 means we only capture them, and a positive value indicates the position of the first error.
2018-09-12 07:08:54 +00:00
h1m->err_pos = -2;
MINOR: h1: add struct h1m for basic HTTP/1 messages This one is much simpler than http_msg and will be used in the HTTP parsers involved in the H2 to H1 gateway.
2017-09-21 09:46:43 +00:00
h1m->err_state = 0;
return h1m;
}
REORG: http: move some very http1-specific parts to h1.{c,h} Certain types and enums are very specific to the HTTP/1 parser, and we'll need to share them with the HTTP/2 to HTTP/1 translation code. Let's move them to h1.c/h1.h. Those with very few occurrences or only used locally were renamed to explicitly mention the relevant HTTP version : enum ht_state -> h1_state. http_msg_state_str -> h1_msg_state_str HTTP_FLG_* -> H1_FLG_* http_char_classes -> h1_char_classes Others like HTTP_IS_*, HTTP_MSG_* are left to be done later.
2017-09-21 07:30:46 +00:00
MINOR: h1: provide a distinct init() function for request and response h1m_init() used to handle response only since it was used by the H1 client code. Let's have one init per direction.
2018-09-11 11:51:19 +00:00
/* initializes an H1 message for a response */
static inline struct h1m *h1m_init_res(struct h1m *h1m)
{
h1m->state = H1_MSG_RPBEFORE;
h1m->next = 0;
MINOR: h1: add a message flag to indicate that a message carries a response This flag is H1_MF_RESP. It will be used by the parser during restarts when it supports requests.
2018-09-11 14:47:23 +00:00
h1m->flags = H1_MF_RESP;
MINOR: h1: provide a distinct init() function for request and response h1m_init() used to handle response only since it was used by the H1 client code. Let's have one init per direction.
2018-09-11 11:51:19 +00:00
h1m->curr_len = 0;
h1m->body_len = 0;
MINOR: h1: properly pre-initialize err_pos to -2 This way we maintain the old mechanism stating that -2 means we block on errors, -1 means we only capture them, and a positive value indicates the position of the first error.
2018-09-12 07:08:54 +00:00
h1m->err_pos = -2;
MINOR: h1: provide a distinct init() function for request and response h1m_init() used to handle response only since it was used by the H1 client code. Let's have one init per direction.
2018-09-11 11:51:19 +00:00
h1m->err_state = 0;
return h1m;
}
REORG: h1: merge types+proto into common/h1.h These two files are self-contained and do not depend on other layers, so let's remerge them together for easier manipulation.
2018-12-11 12:44:24 +00:00
#endif /* _COMMON_H1_H */
Reference in New Issue Copy Permalink