RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2024-12-13 06:54:37 +00:00
Code Issues Packages Projects Releases Wiki Activity
66943a4903
haproxy/include/proto/h1.h

329 lines
12 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
/*
* include/proto/h1.h
* 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
*/
#ifndef _PROTO_H1_H
#define _PROTO_H1_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/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: 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: 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 <types/h1.h>
REORG: http: move the HTTP/1 header block parser to h1.c Since it still depends on http_msg, it was not renamed yet.
2017-09-21 08:22:25 +00:00
#include <proto/hdr_idx.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 header block parser to h1.c Since it still depends on http_msg, it was not renamed yet.
2017-09-21 08:22:25 +00:00
const char *http_parse_reqline(struct http_msg *msg,
enum h1_state state, const char *ptr, const char *end,
unsigned int *ret_ptr, enum h1_state *ret_state);
const char *http_parse_stsline(struct http_msg *msg,
enum h1_state state, const char *ptr, const char *end,
unsigned int *ret_ptr, enum h1_state *ret_state);
void http_msg_analyzer(struct http_msg *msg, struct hdr_idx *idx);
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
int http_forward_trailers(struct http_msg *msg);
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
/* Macros used in the HTTP/1 parser, to check for the expected presence of
* certain bytes (ef: LF) or to skip to next byte and yield in case of failure.
*/
/* Expects to find an LF at <ptr>. If not, set <state> to <where> and jump to
* <bad>.
*/
#define EXPECT_LF_HERE(ptr, bad, state, where) \
do { \
if (unlikely(*(ptr) != '\n')) { \
state = (where); \
goto bad; \
} \
} while (0)
/* Increments pointer <ptr>, continues to label <more> if it's still below
* pointer <end>, or goes to <stop> and sets <state> to <where> if the end
* of buffer was reached.
*/
#define EAT_AND_JUMP_OR_RETURN(ptr, end, more, stop, state, where) \
do { \
if (likely(++(ptr) < (end))) \
goto more; \
else { \
state = (where); \
goto stop; \
} \
} while (0)
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 (legacy version) */
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
static inline const char *h1_msg_state_str(enum h1_state msg_state)
{
switch (msg_state) {
case HTTP_MSG_RQBEFORE: return "MSG_RQBEFORE";
case HTTP_MSG_RQBEFORE_CR: return "MSG_RQBEFORE_CR";
case HTTP_MSG_RQMETH: return "MSG_RQMETH";
case HTTP_MSG_RQMETH_SP: return "MSG_RQMETH_SP";
case HTTP_MSG_RQURI: return "MSG_RQURI";
case HTTP_MSG_RQURI_SP: return "MSG_RQURI_SP";
case HTTP_MSG_RQVER: return "MSG_RQVER";
case HTTP_MSG_RQLINE_END: return "MSG_RQLINE_END";
case HTTP_MSG_RPBEFORE: return "MSG_RPBEFORE";
case HTTP_MSG_RPBEFORE_CR: return "MSG_RPBEFORE_CR";
case HTTP_MSG_RPVER: return "MSG_RPVER";
case HTTP_MSG_RPVER_SP: return "MSG_RPVER_SP";
case HTTP_MSG_RPCODE: return "MSG_RPCODE";
case HTTP_MSG_RPCODE_SP: return "MSG_RPCODE_SP";
case HTTP_MSG_RPREASON: return "MSG_RPREASON";
case HTTP_MSG_RPLINE_END: return "MSG_RPLINE_END";
case HTTP_MSG_HDR_FIRST: return "MSG_HDR_FIRST";
case HTTP_MSG_HDR_NAME: return "MSG_HDR_NAME";
case HTTP_MSG_HDR_COL: return "MSG_HDR_COL";
case HTTP_MSG_HDR_L1_SP: return "MSG_HDR_L1_SP";
case HTTP_MSG_HDR_L1_LF: return "MSG_HDR_L1_LF";
case HTTP_MSG_HDR_L1_LWS: return "MSG_HDR_L1_LWS";
case HTTP_MSG_HDR_VAL: return "MSG_HDR_VAL";
case HTTP_MSG_HDR_L2_LF: return "MSG_HDR_L2_LF";
case HTTP_MSG_HDR_L2_LWS: return "MSG_HDR_L2_LWS";
case HTTP_MSG_LAST_LF: return "MSG_LAST_LF";
case HTTP_MSG_ERROR: return "MSG_ERROR";
case HTTP_MSG_BODY: return "MSG_BODY";
case HTTP_MSG_100_SENT: return "MSG_100_SENT";
case HTTP_MSG_CHUNK_SIZE: return "MSG_CHUNK_SIZE";
case HTTP_MSG_DATA: return "MSG_DATA";
case HTTP_MSG_CHUNK_CRLF: return "MSG_CHUNK_CRLF";
case HTTP_MSG_TRAILERS: return "MSG_TRAILERS";
case HTTP_MSG_ENDING: return "MSG_ENDING";
case HTTP_MSG_DONE: return "MSG_DONE";
case HTTP_MSG_CLOSING: return "MSG_CLOSING";
case HTTP_MSG_CLOSED: return "MSG_CLOSED";
case HTTP_MSG_TUNNEL: return "MSG_TUNNEL";
default: return "MSG_??????";
}
}
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
/* NB: we'll check data availabilty at the end. It's not a
* 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: 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
#endif /* _PROTO_H1_H */
Reference in New Issue Copy Permalink