Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 1 | /* |
Willy Tarreau | b0c9bc4 | 2009-10-04 15:56:38 +0200 | [diff] [blame] | 2 | * include/proto/proto_http.h |
| 3 | * This file contains HTTP protocol definitions. |
| 4 | * |
Willy Tarreau | ff011f2 | 2011-01-06 17:51:27 +0100 | [diff] [blame] | 5 | * Copyright (C) 2000-2011 Willy Tarreau - w@1wt.eu |
Willy Tarreau | b0c9bc4 | 2009-10-04 15:56:38 +0200 | [diff] [blame] | 6 | * |
| 7 | * This library is free software; you can redistribute it and/or |
| 8 | * modify it under the terms of the GNU Lesser General Public |
| 9 | * License as published by the Free Software Foundation, version 2.1 |
| 10 | * exclusively. |
| 11 | * |
| 12 | * This library is distributed in the hope that it will be useful, |
| 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 15 | * Lesser General Public License for more details. |
| 16 | * |
| 17 | * You should have received a copy of the GNU Lesser General Public |
| 18 | * License along with this library; if not, write to the Free Software |
| 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| 20 | */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 21 | |
| 22 | #ifndef _PROTO_PROTO_HTTP_H |
| 23 | #define _PROTO_PROTO_HTTP_H |
| 24 | |
Willy Tarreau | e3ba5f0 | 2006-06-29 18:54:54 +0200 | [diff] [blame] | 25 | #include <common/config.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 26 | #include <types/proto_http.h> |
| 27 | #include <types/session.h> |
| 28 | #include <types/task.h> |
| 29 | |
Willy Tarreau | 58f10d7 | 2006-12-04 02:26:12 +0100 | [diff] [blame] | 30 | /* |
| 31 | * some macros used for the request parsing. |
| 32 | * from RFC2616: |
| 33 | * CTL = <any US-ASCII control character (octets 0 - 31) and DEL (127)> |
Willy Tarreau | 8d5d7f2 | 2007-01-21 19:16:41 +0100 | [diff] [blame] | 34 | * SEP = one of the 17 defined separators or SP or HT |
| 35 | * LWS = CR, LF, SP or HT |
| 36 | * SPHT = SP or HT. Use this macro and not a boolean expression for best speed. |
| 37 | * CRLF = CR or LF. Use this macro and not a boolean expression for best speed. |
| 38 | * token = any CHAR except CTL or SEP. Use this macro and not a boolean expression for best speed. |
Willy Tarreau | 4b89ad4 | 2007-03-04 18:13:58 +0100 | [diff] [blame] | 39 | * |
| 40 | * added for ease of use: |
| 41 | * ver_token = 'H', 'P', 'T', '/', '.', and digits. |
Willy Tarreau | 58f10d7 | 2006-12-04 02:26:12 +0100 | [diff] [blame] | 42 | */ |
Willy Tarreau | 58f10d7 | 2006-12-04 02:26:12 +0100 | [diff] [blame] | 43 | |
Willy Tarreau | 8d5d7f2 | 2007-01-21 19:16:41 +0100 | [diff] [blame] | 44 | extern const char http_is_ctl[256]; |
| 45 | extern const char http_is_sep[256]; |
| 46 | extern const char http_is_lws[256]; |
| 47 | extern const char http_is_spht[256]; |
| 48 | extern const char http_is_crlf[256]; |
| 49 | extern const char http_is_token[256]; |
Willy Tarreau | 4b89ad4 | 2007-03-04 18:13:58 +0100 | [diff] [blame] | 50 | extern const char http_is_ver_token[256]; |
Willy Tarreau | 8d5d7f2 | 2007-01-21 19:16:41 +0100 | [diff] [blame] | 51 | |
Willy Tarreau | 436d9ed | 2011-05-11 16:10:11 +0200 | [diff] [blame] | 52 | extern const int http_err_codes[HTTP_ERR_SIZE]; |
| 53 | extern struct chunk http_err_chunks[HTTP_ERR_SIZE]; |
| 54 | extern const char *HTTP_302; |
| 55 | extern const char *HTTP_303; |
Willy Tarreau | 7e2c647 | 2012-10-29 20:44:36 +0100 | [diff] [blame] | 56 | extern char *get_http_auth_buff; |
Willy Tarreau | 436d9ed | 2011-05-11 16:10:11 +0200 | [diff] [blame] | 57 | |
Willy Tarreau | 8d5d7f2 | 2007-01-21 19:16:41 +0100 | [diff] [blame] | 58 | #define HTTP_IS_CTL(x) (http_is_ctl[(unsigned char)(x)]) |
| 59 | #define HTTP_IS_SEP(x) (http_is_sep[(unsigned char)(x)]) |
| 60 | #define HTTP_IS_LWS(x) (http_is_lws[(unsigned char)(x)]) |
| 61 | #define HTTP_IS_SPHT(x) (http_is_spht[(unsigned char)(x)]) |
| 62 | #define HTTP_IS_CRLF(x) (http_is_crlf[(unsigned char)(x)]) |
| 63 | #define HTTP_IS_TOKEN(x) (http_is_token[(unsigned char)(x)]) |
Willy Tarreau | 4b89ad4 | 2007-03-04 18:13:58 +0100 | [diff] [blame] | 64 | #define HTTP_IS_VER_TOKEN(x) (http_is_ver_token[(unsigned char)(x)]) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 65 | |
Willy Tarreau | f1fd9dc | 2014-04-24 20:47:57 +0200 | [diff] [blame] | 66 | int process_cli(struct session *s); |
| 67 | int process_srv_data(struct session *s); |
| 68 | int process_srv_conn(struct session *s); |
Willy Tarreau | 7421efb | 2012-07-02 15:11:27 +0200 | [diff] [blame] | 69 | int http_wait_for_request(struct session *s, struct channel *req, int an_bit); |
| 70 | int http_process_req_common(struct session *s, struct channel *req, int an_bit, struct proxy *px); |
Willy Tarreau | f1fd9dc | 2014-04-24 20:47:57 +0200 | [diff] [blame] | 71 | int http_process_request(struct session *s, struct channel *req, int an_bit); |
Willy Tarreau | 7421efb | 2012-07-02 15:11:27 +0200 | [diff] [blame] | 72 | int http_process_tarpit(struct session *s, struct channel *req, int an_bit); |
Willy Tarreau | 5a8f947 | 2014-04-10 11:16:06 +0200 | [diff] [blame] | 73 | int http_wait_for_request_body(struct session *s, struct channel *req, int an_bit); |
Willy Tarreau | 45c0d98 | 2012-03-09 12:11:57 +0100 | [diff] [blame] | 74 | int http_send_name_header(struct http_txn *txn, struct proxy* be, const char* svr_name); |
Willy Tarreau | 7421efb | 2012-07-02 15:11:27 +0200 | [diff] [blame] | 75 | int http_wait_for_response(struct session *s, struct channel *rep, int an_bit); |
Willy Tarreau | f1fd9dc | 2014-04-24 20:47:57 +0200 | [diff] [blame] | 76 | int http_process_res_common(struct session *s, struct channel *rep, int an_bit, struct proxy *px); |
Willy Tarreau | 7421efb | 2012-07-02 15:11:27 +0200 | [diff] [blame] | 77 | int http_request_forward_body(struct session *s, struct channel *req, int an_bit); |
| 78 | int http_response_forward_body(struct session *s, struct channel *res, int an_bit); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 79 | |
Willy Tarreau | f1fd9dc | 2014-04-24 20:47:57 +0200 | [diff] [blame] | 80 | void debug_hdr(const char *dir, struct session *s, const char *start, const char *end); |
| 81 | void get_srv_from_appsession(struct session *s, const char *begin, int len); |
| 82 | int apply_filter_to_req_headers(struct session *s, struct channel *req, struct hdr_exp *exp); |
| 83 | int apply_filter_to_req_line(struct session *s, struct channel *req, struct hdr_exp *exp); |
Willy Tarreau | 7421efb | 2012-07-02 15:11:27 +0200 | [diff] [blame] | 84 | int apply_filters_to_request(struct session *s, struct channel *req, struct proxy *px); |
Willy Tarreau | f1fd9dc | 2014-04-24 20:47:57 +0200 | [diff] [blame] | 85 | int apply_filters_to_response(struct session *s, struct channel *rtr, struct proxy *px); |
| 86 | void manage_client_side_appsession(struct session *s, const char *buf, int len); |
| 87 | void manage_client_side_cookies(struct session *s, struct channel *req); |
| 88 | void manage_server_side_cookies(struct session *s, struct channel *rtr); |
| 89 | void check_response_for_cacheability(struct session *s, struct channel *rtr); |
Willy Tarreau | 295a837 | 2011-03-10 11:25:07 +0100 | [diff] [blame] | 90 | int stats_check_uri(struct stream_interface *si, struct http_txn *txn, struct proxy *backend); |
Willy Tarreau | 8058743 | 2006-12-24 17:47:20 +0100 | [diff] [blame] | 91 | void init_proto_http(); |
Willy Tarreau | 04ff9f1 | 2013-06-10 18:39:42 +0200 | [diff] [blame] | 92 | int http_find_full_header2(const char *name, int len, |
| 93 | char *sol, struct hdr_idx *idx, |
| 94 | struct hdr_ctx *ctx); |
matt.farnsworth@nokia.com | 1c2ab96 | 2008-04-14 20:47:37 +0200 | [diff] [blame] | 95 | int http_find_header2(const char *name, int len, |
Willy Tarreau | 68085d8 | 2010-01-18 14:54:04 +0100 | [diff] [blame] | 96 | char *sol, struct hdr_idx *idx, |
matt.farnsworth@nokia.com | 1c2ab96 | 2008-04-14 20:47:37 +0200 | [diff] [blame] | 97 | struct hdr_ctx *ctx); |
Thierry FOURNIER | de6617b | 2013-10-15 11:43:19 +0200 | [diff] [blame] | 98 | char *find_hdr_value_end(char *s, const char *e); |
| 99 | int http_header_match2(const char *hdr, const char *end, const char *name, int len); |
| 100 | int http_remove_header2(struct http_msg *msg, struct hdr_idx *idx, struct hdr_ctx *ctx); |
| 101 | int http_header_add_tail2(struct http_msg *msg, struct hdr_idx *hdr_idx, const char *text, int len); |
Willy Tarreau | 55a8d0e | 2008-11-30 18:47:21 +0100 | [diff] [blame] | 102 | void http_sess_log(struct session *s); |
Willy Tarreau | 71241ab | 2012-12-27 11:30:54 +0100 | [diff] [blame] | 103 | void http_perform_server_redirect(struct session *s, struct stream_interface *si); |
Willy Tarreau | 0cac36f | 2008-11-30 20:44:17 +0100 | [diff] [blame] | 104 | void http_return_srv_error(struct session *s, struct stream_interface *si); |
Willy Tarreau | 4076a15 | 2009-04-02 15:18:36 +0200 | [diff] [blame] | 105 | void http_capture_bad_message(struct error_snapshot *es, struct session *s, |
Willy Tarreau | 8a0cef2 | 2012-03-09 13:39:23 +0100 | [diff] [blame] | 106 | struct http_msg *msg, |
Willy Tarreau | 3770f23 | 2013-12-07 00:01:53 +0100 | [diff] [blame] | 107 | enum ht_state state, struct proxy *other_end); |
Willy Tarreau | 185b5c4 | 2012-04-26 15:11:51 +0200 | [diff] [blame] | 108 | unsigned int http_get_hdr(const struct http_msg *msg, const char *hname, int hlen, |
Willy Tarreau | 294c473 | 2011-12-16 21:35:50 +0100 | [diff] [blame] | 109 | struct hdr_idx *idx, int occ, |
| 110 | struct hdr_ctx *ctx, char **vptr, int *vlen); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 111 | |
Willy Tarreau | 0937bc4 | 2009-12-22 15:03:09 +0100 | [diff] [blame] | 112 | void http_init_txn(struct session *s); |
| 113 | void http_end_txn(struct session *s); |
| 114 | void http_reset_txn(struct session *s); |
Willy Tarreau | 4e21ff9 | 2014-09-30 18:44:22 +0200 | [diff] [blame] | 115 | void http_adjust_conn_mode(struct session *s, struct http_txn *txn, struct http_msg *msg); |
Willy Tarreau | 0937bc4 | 2009-12-22 15:03:09 +0100 | [diff] [blame] | 116 | |
Willy Tarreau | ff011f2 | 2011-01-06 17:51:27 +0100 | [diff] [blame] | 117 | struct http_req_rule *parse_http_req_cond(const char **args, const char *file, int linenum, struct proxy *proxy); |
Willy Tarreau | e365c0b | 2013-06-11 16:06:12 +0200 | [diff] [blame] | 118 | struct http_res_rule *parse_http_res_cond(const char **args, const char *file, int linenum, struct proxy *proxy); |
Willy Tarreau | ff011f2 | 2011-01-06 17:51:27 +0100 | [diff] [blame] | 119 | void free_http_req_rules(struct list *r); |
Sasha Pachev | 218f064 | 2014-06-16 12:05:59 -0600 | [diff] [blame] | 120 | void free_http_res_rules(struct list *r); |
Willy Tarreau | 783f258 | 2012-09-04 12:19:04 +0200 | [diff] [blame] | 121 | struct chunk *http_error_message(struct session *s, int msgnum); |
Thierry FOURNIER | d18cd0f | 2013-11-29 12:15:45 +0100 | [diff] [blame] | 122 | struct redirect_rule *http_parse_redirect_rule(const char *file, int linenum, struct proxy *curproxy, |
| 123 | const char **args, char **errmsg, int use_fmt); |
William Lallemand | 07c8b24 | 2014-05-02 17:11:07 +0200 | [diff] [blame] | 124 | int smp_fetch_cookie(struct proxy *px, struct session *l4, void *l7, unsigned int opt, |
Thierry FOURNIER | f41a809 | 2014-12-07 18:37:57 +0100 | [diff] [blame] | 125 | const struct arg *args, struct sample *smp, const char *kw, void *private); |
Thierry FOURNIER | 055b9d5 | 2014-07-15 16:11:07 +0200 | [diff] [blame] | 126 | int |
| 127 | smp_fetch_base32(struct proxy *px, struct session *l4, void *l7, unsigned int opt, |
Thierry FOURNIER | f41a809 | 2014-12-07 18:37:57 +0100 | [diff] [blame] | 128 | const struct arg *args, struct sample *smp, const char *kw, void *private); |
Willy Tarreau | ff011f2 | 2011-01-06 17:51:27 +0100 | [diff] [blame] | 129 | |
Thierry FOURNIER | d437314 | 2013-12-17 01:10:10 +0100 | [diff] [blame] | 130 | enum http_meth_t find_http_meth(const char *str, const int len); |
| 131 | |
William Lallemand | 73025dd | 2014-04-24 14:38:37 +0200 | [diff] [blame] | 132 | struct http_req_action_kw *action_http_req_custom(const char *kw); |
| 133 | struct http_res_action_kw *action_http_res_custom(const char *kw); |
| 134 | |
| 135 | static inline void http_req_keywords_register(struct http_req_action_kw_list *kw_list) |
| 136 | { |
| 137 | LIST_ADDQ(&http_req_keywords.list, &kw_list->list); |
| 138 | } |
| 139 | |
| 140 | static inline void http_res_keywords_register(struct http_res_action_kw_list *kw_list) |
| 141 | { |
| 142 | LIST_ADDQ(&http_res_keywords.list, &kw_list->list); |
| 143 | } |
| 144 | |
| 145 | |
Willy Tarreau | fa355d4 | 2009-11-29 18:12:29 +0100 | [diff] [blame] | 146 | /* to be used when contents change in an HTTP message */ |
| 147 | #define http_msg_move_end(msg, bytes) do { \ |
| 148 | unsigned int _bytes = (bytes); \ |
Willy Tarreau | a458b67 | 2012-03-05 11:17:50 +0100 | [diff] [blame] | 149 | (msg)->next += (_bytes); \ |
Willy Tarreau | fa355d4 | 2009-11-29 18:12:29 +0100 | [diff] [blame] | 150 | (msg)->sov += (_bytes); \ |
| 151 | (msg)->eoh += (_bytes); \ |
| 152 | } while (0) |
| 153 | |
Willy Tarreau | 2d8e485 | 2014-04-17 20:08:17 +0200 | [diff] [blame] | 154 | |
Willy Tarreau | 211cdec | 2014-04-17 20:18:08 +0200 | [diff] [blame] | 155 | /* Return the amount of bytes that need to be rewound before buf->p to access |
| 156 | * the current message's headers. The purpose is to be able to easily fetch |
| 157 | * the message's beginning before headers are forwarded, as well as after. |
Willy Tarreau | 1234f4a | 2014-04-17 21:14:47 +0200 | [diff] [blame] | 158 | * The principle is that msg->eoh and msg->eol are immutable while msg->sov |
| 159 | * equals the sum of the two before forwarding and is zero after forwarding, |
| 160 | * so the difference cancels the rewinding. |
Willy Tarreau | 211cdec | 2014-04-17 20:18:08 +0200 | [diff] [blame] | 161 | */ |
| 162 | static inline int http_hdr_rewind(const struct http_msg *msg) |
| 163 | { |
Willy Tarreau | 1234f4a | 2014-04-17 21:14:47 +0200 | [diff] [blame] | 164 | return msg->eoh + msg->eol - msg->sov; |
Willy Tarreau | 211cdec | 2014-04-17 20:18:08 +0200 | [diff] [blame] | 165 | } |
| 166 | |
Willy Tarreau | da6eed6 | 2014-04-17 20:24:24 +0200 | [diff] [blame] | 167 | /* Return the amount of bytes that need to be rewound before buf->p to access |
| 168 | * the current message's URI. The purpose is to be able to easily fetch |
| 169 | * the message's beginning before headers are forwarded, as well as after. |
| 170 | */ |
| 171 | static inline int http_uri_rewind(const struct http_msg *msg) |
| 172 | { |
| 173 | return http_hdr_rewind(msg) - msg->sl.rq.u; |
| 174 | } |
| 175 | |
Willy Tarreau | 0d09050 | 2014-04-17 20:31:44 +0200 | [diff] [blame] | 176 | /* Return the amount of bytes that need to be rewound before buf->p to access |
| 177 | * the current message's BODY. The purpose is to be able to easily fetch |
| 178 | * the message's beginning before headers are forwarded, as well as after. |
| 179 | */ |
| 180 | static inline int http_body_rewind(const struct http_msg *msg) |
| 181 | { |
| 182 | return http_hdr_rewind(msg) - msg->eoh - msg->eol; |
| 183 | } |
| 184 | |
| 185 | /* Return the amount of bytes that need to be rewound before buf->p to access |
| 186 | * the current message's DATA. The difference with the function above is that |
| 187 | * if a chunk is present and has already been parsed, its size is skipped so |
| 188 | * that the byte pointed to is the first byte of actual data. The function is |
| 189 | * safe for use in state HTTP_MSG_DATA regardless of whether the headers were |
| 190 | * already forwarded or not. |
| 191 | */ |
| 192 | static inline int http_data_rewind(const struct http_msg *msg) |
| 193 | { |
| 194 | return http_body_rewind(msg) - msg->sol; |
| 195 | } |
| 196 | |
Willy Tarreau | 2d8e485 | 2014-04-17 20:08:17 +0200 | [diff] [blame] | 197 | /* Return the maximum amount of bytes that may be read after the beginning of |
| 198 | * the message body, according to the advertised length. The function is safe |
| 199 | * for use between HTTP_MSG_BODY and HTTP_MSG_DATA regardless of whether the |
| 200 | * headers were already forwarded or not. |
| 201 | */ |
| 202 | static inline int http_body_bytes(const struct http_msg *msg) |
| 203 | { |
| 204 | int len; |
| 205 | |
Willy Tarreau | 1234f4a | 2014-04-17 21:14:47 +0200 | [diff] [blame] | 206 | len = msg->chn->buf->i - msg->sov - msg->sol; |
Willy Tarreau | 2d8e485 | 2014-04-17 20:08:17 +0200 | [diff] [blame] | 207 | if (len > msg->body_len) |
| 208 | len = msg->body_len; |
| 209 | return len; |
| 210 | } |
| 211 | |
Willy Tarreau | 09448f7 | 2014-06-25 18:12:15 +0200 | [diff] [blame] | 212 | /* for an http-request action HTTP_REQ_ACT_TRK_*, return a tracking index |
| 213 | * starting at zero for SC0. Unknown actions also return zero. |
| 214 | */ |
| 215 | static inline int http_req_trk_idx(int trk_action) |
| 216 | { |
| 217 | return trk_action - HTTP_REQ_ACT_TRK_SC0; |
| 218 | } |
| 219 | |
Willy Tarreau | 88c6d81 | 2012-11-21 21:50:04 +0100 | [diff] [blame] | 220 | /* for debugging, reports the HTTP message state name */ |
| 221 | static inline const char *http_msg_state_str(int msg_state) |
| 222 | { |
| 223 | switch (msg_state) { |
| 224 | case HTTP_MSG_RQBEFORE: return "MSG_RQBEFORE"; |
| 225 | case HTTP_MSG_RQBEFORE_CR: return "MSG_RQBEFORE_CR"; |
| 226 | case HTTP_MSG_RQMETH: return "MSG_RQMETH"; |
| 227 | case HTTP_MSG_RQMETH_SP: return "MSG_RQMETH_SP"; |
| 228 | case HTTP_MSG_RQURI: return "MSG_RQURI"; |
| 229 | case HTTP_MSG_RQURI_SP: return "MSG_RQURI_SP"; |
| 230 | case HTTP_MSG_RQVER: return "MSG_RQVER"; |
| 231 | case HTTP_MSG_RQLINE_END: return "MSG_RQLINE_END"; |
| 232 | case HTTP_MSG_RPBEFORE: return "MSG_RPBEFORE"; |
| 233 | case HTTP_MSG_RPBEFORE_CR: return "MSG_RPBEFORE_CR"; |
| 234 | case HTTP_MSG_RPVER: return "MSG_RPVER"; |
| 235 | case HTTP_MSG_RPVER_SP: return "MSG_RPVER_SP"; |
| 236 | case HTTP_MSG_RPCODE: return "MSG_RPCODE"; |
| 237 | case HTTP_MSG_RPCODE_SP: return "MSG_RPCODE_SP"; |
| 238 | case HTTP_MSG_RPREASON: return "MSG_RPREASON"; |
| 239 | case HTTP_MSG_RPLINE_END: return "MSG_RPLINE_END"; |
| 240 | case HTTP_MSG_HDR_FIRST: return "MSG_HDR_FIRST"; |
| 241 | case HTTP_MSG_HDR_NAME: return "MSG_HDR_NAME"; |
| 242 | case HTTP_MSG_HDR_COL: return "MSG_HDR_COL"; |
| 243 | case HTTP_MSG_HDR_L1_SP: return "MSG_HDR_L1_SP"; |
| 244 | case HTTP_MSG_HDR_L1_LF: return "MSG_HDR_L1_LF"; |
| 245 | case HTTP_MSG_HDR_L1_LWS: return "MSG_HDR_L1_LWS"; |
| 246 | case HTTP_MSG_HDR_VAL: return "MSG_HDR_VAL"; |
| 247 | case HTTP_MSG_HDR_L2_LF: return "MSG_HDR_L2_LF"; |
| 248 | case HTTP_MSG_HDR_L2_LWS: return "MSG_HDR_L2_LWS"; |
| 249 | case HTTP_MSG_LAST_LF: return "MSG_LAST_LF"; |
| 250 | case HTTP_MSG_ERROR: return "MSG_ERROR"; |
| 251 | case HTTP_MSG_BODY: return "MSG_BODY"; |
| 252 | case HTTP_MSG_100_SENT: return "MSG_100_SENT"; |
| 253 | case HTTP_MSG_CHUNK_SIZE: return "MSG_CHUNK_SIZE"; |
| 254 | case HTTP_MSG_DATA: return "MSG_DATA"; |
| 255 | case HTTP_MSG_CHUNK_CRLF: return "MSG_CHUNK_CRLF"; |
| 256 | case HTTP_MSG_TRAILERS: return "MSG_TRAILERS"; |
| 257 | case HTTP_MSG_DONE: return "MSG_DONE"; |
| 258 | case HTTP_MSG_CLOSING: return "MSG_CLOSING"; |
| 259 | case HTTP_MSG_CLOSED: return "MSG_CLOSED"; |
| 260 | case HTTP_MSG_TUNNEL: return "MSG_TUNNEL"; |
| 261 | default: return "MSG_??????"; |
| 262 | } |
| 263 | } |
| 264 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 265 | #endif /* _PROTO_PROTO_HTTP_H */ |
| 266 | |
| 267 | /* |
| 268 | * Local variables: |
| 269 | * c-indent-level: 8 |
| 270 | * c-basic-offset: 8 |
| 271 | * End: |
| 272 | */ |