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.
diff --git a/include/common/h1.h b/include/common/h1.h
new file mode 100644
index 0000000..b77eb32
--- /dev/null
+++ b/include/common/h1.h
@@ -0,0 +1,353 @@
+/*
+ * include/common/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 _COMMON_H1_H
+#define _COMMON_H1_H
+
+#include <common/buffer.h>
+#include <common/compiler.h>
+#include <common/config.h>
+#include <common/http.h>
+#include <common/http-hdr.h>
+#include <common/ist.h>
+#include <common/standard.h>
+
+
+/* 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
+
+/* 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 */
+};
+
+int h1_headers_to_hdr_list(char *start, const char *stop,
+ struct http_hdr *hdr, unsigned int hdr_num,
+ struct h1m *h1m, union h1_sl *slp);
+int h1_measure_trailers(const struct buffer *buf, unsigned int ofs, unsigned int max);
+
+int h1_parse_cont_len_header(struct h1m *h1m, struct ist *value);
+void h1_parse_xfer_enc_header(struct h1m *h1m, struct ist value);
+void h1_parse_connection_header(struct h1m *h1m, struct ist value);
+
+/* for debugging, reports the HTTP/1 message state name */
+static inline const char *h1m_state_str(enum h1m_state msg_state)
+{
+ 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_??????";
+ }
+}
+
+/* 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
+ * 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
+ * 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.
+ */
+static inline int h1_skip_chunk_crlf(const struct buffer *buf, int start, int stop)
+{
+ const char *ptr = b_peek(buf, start);
+ int bytes = 1;
+
+ /* NB: we'll check data availability 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++;
+ if (ptr >= b_wrap(buf))
+ ptr = b_orig(buf);
+ }
+
+ if (bytes > stop - start)
+ return 0;
+
+ if (*ptr != '\n') // negative position to stop
+ return ptr - __b_peek(buf, stop);
+
+ return bytes;
+}
+
+/* Parse the chunk size start at buf + start and stops before buf + stop. The
+ * positions are relative to the buffer's head.
+ * 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.
+ */
+static inline int h1_parse_chunk_size(const struct buffer *buf, int start, int stop, unsigned int *res)
+{
+ const char *ptr = b_peek(buf, start);
+ const char *ptr_old = ptr;
+ const char *end = b_wrap(buf);
+ unsigned int chunk = 0;
+
+ stop -= start; // bytes left
+ start = stop; // bytes to transfer
+
+ /* 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;
+ if (!stop)
+ return 0;
+ c = hex2i(*ptr);
+ if (c < 0) /* not a hex digit anymore */
+ break;
+ if (unlikely(++ptr >= end))
+ ptr = b_orig(buf);
+ if (unlikely(chunk & 0xF8000000)) /* integer overflow will occur if result >= 2GB */
+ goto error;
+ chunk = (chunk << 4) + c;
+ stop--;
+ }
+
+ /* empty size not allowed */
+ if (unlikely(ptr == ptr_old))
+ goto error;
+
+ while (HTTP_IS_SPHT(*ptr)) {
+ if (++ptr >= end)
+ ptr = b_orig(buf);
+ if (--stop == 0)
+ 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)
+ ptr = b_orig(buf);
+ if (--stop == 0)
+ return 0;
+ }
+
+ if (*ptr != '\n')
+ goto error;
+ if (++ptr >= end)
+ ptr = b_orig(buf);
+ --stop;
+ /* done */
+ break;
+ }
+ else if (likely(*ptr == ';')) {
+ /* chunk extension, ends at next CRLF */
+ if (++ptr >= end)
+ ptr = b_orig(buf);
+ if (--stop == 0)
+ return 0;
+
+ while (!HTTP_IS_CRLF(*ptr)) {
+ if (++ptr >= end)
+ ptr = b_orig(buf);
+ if (--stop == 0)
+ 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
+ * or may not be present. Let's return the number of bytes parsed.
+ */
+ *res = chunk;
+ return start - stop;
+ error:
+ *res = 0; // just to stop gcc's -Wuninitialized warning :-(
+ return -stop;
+}
+
+/* initializes an H1 message for a request */
+static inline struct h1m *h1m_init_req(struct h1m *h1m)
+{
+ h1m->state = H1_MSG_RQBEFORE;
+ h1m->next = 0;
+ h1m->flags = H1_MF_NONE;
+ h1m->curr_len = 0;
+ h1m->body_len = 0;
+ h1m->err_pos = -2;
+ h1m->err_state = 0;
+ return h1m;
+}
+
+/* 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;
+ h1m->flags = H1_MF_RESP;
+ h1m->curr_len = 0;
+ h1m->body_len = 0;
+ h1m->err_pos = -2;
+ h1m->err_state = 0;
+ return h1m;
+}
+
+#endif /* _COMMON_H1_H */
diff --git a/include/proto/h1.h b/include/proto/h1.h
deleted file mode 100644
index 7d8ea61..0000000
--- a/include/proto/h1.h
+++ /dev/null
@@ -1,247 +0,0 @@
-/*
- * 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
-
-#include <common/buffer.h>
-#include <common/compiler.h>
-#include <common/config.h>
-#include <common/http.h>
-#include <common/http-hdr.h>
-#include <common/standard.h>
-#include <types/h1.h>
-
-int h1_headers_to_hdr_list(char *start, const char *stop,
- struct http_hdr *hdr, unsigned int hdr_num,
- struct h1m *h1m, union h1_sl *slp);
-int h1_measure_trailers(const struct buffer *buf, unsigned int ofs, unsigned int max);
-
-int h1_parse_cont_len_header(struct h1m *h1m, struct ist *value);
-void h1_parse_xfer_enc_header(struct h1m *h1m, struct ist value);
-void h1_parse_connection_header(struct h1m *h1m, struct ist value);
-
-/* for debugging, reports the HTTP/1 message state name */
-static inline const char *h1m_state_str(enum h1m_state msg_state)
-{
- 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_??????";
- }
-}
-
-/* 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
- * 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
- * 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.
- */
-static inline int h1_skip_chunk_crlf(const struct buffer *buf, int start, int stop)
-{
- const char *ptr = b_peek(buf, start);
- int bytes = 1;
-
- /* NB: we'll check data availability 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++;
- if (ptr >= b_wrap(buf))
- ptr = b_orig(buf);
- }
-
- if (bytes > stop - start)
- return 0;
-
- if (*ptr != '\n') // negative position to stop
- return ptr - __b_peek(buf, stop);
-
- return bytes;
-}
-
-/* Parse the chunk size start at buf + start and stops before buf + stop. The
- * positions are relative to the buffer's head.
- * 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.
- */
-static inline int h1_parse_chunk_size(const struct buffer *buf, int start, int stop, unsigned int *res)
-{
- const char *ptr = b_peek(buf, start);
- const char *ptr_old = ptr;
- const char *end = b_wrap(buf);
- unsigned int chunk = 0;
-
- stop -= start; // bytes left
- start = stop; // bytes to transfer
-
- /* 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;
- if (!stop)
- return 0;
- c = hex2i(*ptr);
- if (c < 0) /* not a hex digit anymore */
- break;
- if (unlikely(++ptr >= end))
- ptr = b_orig(buf);
- if (unlikely(chunk & 0xF8000000)) /* integer overflow will occur if result >= 2GB */
- goto error;
- chunk = (chunk << 4) + c;
- stop--;
- }
-
- /* empty size not allowed */
- if (unlikely(ptr == ptr_old))
- goto error;
-
- while (HTTP_IS_SPHT(*ptr)) {
- if (++ptr >= end)
- ptr = b_orig(buf);
- if (--stop == 0)
- 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)
- ptr = b_orig(buf);
- if (--stop == 0)
- return 0;
- }
-
- if (*ptr != '\n')
- goto error;
- if (++ptr >= end)
- ptr = b_orig(buf);
- --stop;
- /* done */
- break;
- }
- else if (likely(*ptr == ';')) {
- /* chunk extension, ends at next CRLF */
- if (++ptr >= end)
- ptr = b_orig(buf);
- if (--stop == 0)
- return 0;
-
- while (!HTTP_IS_CRLF(*ptr)) {
- if (++ptr >= end)
- ptr = b_orig(buf);
- if (--stop == 0)
- 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
- * or may not be present. Let's return the number of bytes parsed.
- */
- *res = chunk;
- return start - stop;
- error:
- *res = 0; // just to stop gcc's -Wuninitialized warning :-(
- return -stop;
-}
-
-/* initializes an H1 message for a request */
-static inline struct h1m *h1m_init_req(struct h1m *h1m)
-{
- h1m->state = H1_MSG_RQBEFORE;
- h1m->next = 0;
- h1m->flags = H1_MF_NONE;
- h1m->curr_len = 0;
- h1m->body_len = 0;
- h1m->err_pos = -2;
- h1m->err_state = 0;
- return h1m;
-}
-
-/* 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;
- h1m->flags = H1_MF_RESP;
- h1m->curr_len = 0;
- h1m->body_len = 0;
- h1m->err_pos = -2;
- h1m->err_state = 0;
- return h1m;
-}
-
-#endif /* _PROTO_H1_H */
diff --git a/include/types/h1.h b/include/types/h1.h
deleted file mode 100644
index 840c889..0000000
--- a/include/types/h1.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * include/types/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 _TYPES_H1_H
-#define _TYPES_H1_H
-
-#include <common/http.h>
-#include <common/ist.h>
-
-/* 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
-
-/* 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 */
-};
-
-#endif /* _TYPES_H1_H */
diff --git a/src/h1.c b/src/h1.c
index c2195bc..37a1442 100644
--- a/src/h1.c
+++ b/src/h1.c
@@ -12,10 +12,10 @@
#include <ctype.h>
#include <common/config.h>
+#include <common/h1.h>
#include <common/http-hdr.h>
#include <proto/channel.h>
-#include <proto/h1.h>
#include <proto/hdr_idx.h>
/* Parse the Content-Length header field of an HTTP/1 request. The function
diff --git a/src/http_fetch.c b/src/http_fetch.c
index 5f6cb6c..68c455c 100644
--- a/src/http_fetch.c
+++ b/src/http_fetch.c
@@ -21,6 +21,7 @@
#include <common/compat.h>
#include <common/config.h>
#include <common/debug.h>
+#include <common/h1.h>
#include <common/http.h>
#include <common/htx.h>
#include <common/initcall.h>
@@ -32,7 +33,6 @@
#include <proto/arg.h>
#include <proto/auth.h>
-#include <proto/h1.h>
#include <proto/hdr_idx.h>
#include <proto/http_fetch.h>
#include <proto/http_htx.h>
diff --git a/src/http_htx.c b/src/http_htx.c
index 401e7f1..eb71354 100644
--- a/src/http_htx.c
+++ b/src/http_htx.c
@@ -12,10 +12,10 @@
#include <common/config.h>
#include <common/cfgparse.h>
+#include <common/h1.h>
#include <common/http.h>
#include <common/htx.h>
-#include <proto/h1.h>
#include <proto/http_htx.h>
struct buffer htx_err_chunks[HTTP_ERR_SIZE];
diff --git a/src/mux_h1.c b/src/mux_h1.c
index 037b239..a602b21 100644
--- a/src/mux_h1.c
+++ b/src/mux_h1.c
@@ -11,6 +11,7 @@
*/
#include <common/cfgparse.h>
#include <common/config.h>
+#include <common/h1.h>
#include <common/htx.h>
#include <common/initcall.h>
@@ -19,7 +20,6 @@
#include <types/session.h>
#include <proto/connection.h>
-#include <proto/h1.h>
#include <proto/http_htx.h>
#include <proto/log.h>
#include <proto/stream.h>
diff --git a/src/mux_h2.c b/src/mux_h2.c
index 8962be8..9a2f8c7 100644
--- a/src/mux_h2.c
+++ b/src/mux_h2.c
@@ -12,6 +12,7 @@
#include <common/cfgparse.h>
#include <common/config.h>
+#include <common/h1.h>
#include <common/h2.h>
#include <common/hpack-dec.h>
#include <common/hpack-enc.h>
@@ -20,7 +21,6 @@
#include <common/initcall.h>
#include <common/net_helper.h>
#include <proto/connection.h>
-#include <proto/h1.h>
#include <proto/http_htx.h>
#include <proto/stream.h>
#include <types/session.h>
diff --git a/src/proto_http.c b/src/proto_http.c
index a6492b6..a89ce1d 100644
--- a/src/proto_http.c
+++ b/src/proto_http.c
@@ -29,6 +29,7 @@
#include <common/compat.h>
#include <common/config.h>
#include <common/debug.h>
+#include <common/h1.h>
#include <common/memory.h>
#include <common/mini-clist.h>
#include <common/standard.h>
@@ -57,7 +58,6 @@
#include <proto/fd.h>
#include <proto/filters.h>
#include <proto/frontend.h>
-#include <proto/h1.h>
#include <proto/log.h>
#include <proto/hdr_idx.h>
#include <proto/hlua.h>