← Back to branch summary

~ubuntu-branches/debian/stretch/haproxy/stretch

« back to all changes in this revision

Viewing changes to include/proto/proto_http.h

  • Committer: Package Import Robot
  • Author(s): Apollon Oikonomopoulos
  • Date: 2014-06-20 11:05:17 UTC
  • mfrom: (1.1.15) (15.1.12 experimental)
  • Revision ID: package-import@ubuntu.com-20140620110517-u6q5p9kyy2f3ozw9
Tags: 1.5.0-1
* New upstream stable series. Notable changes since the 1.4 series:
  + Native SSL support on both sides with SNI/NPN/ALPN and OCSP stapling.
  + IPv6 and UNIX sockets are supported everywhere
  + End-to-end HTTP keep-alive for better support of NTLM and improved
    efficiency in static farms
  + HTTP/1.1 response compression (deflate, gzip) to save bandwidth
  + PROXY protocol versions 1 and 2 on both sides
  + Data sampling on everything in request or response, including payload
  + ACLs can use any matching method with any input sample
  + Maps and dynamic ACLs updatable from the CLI
  + Stick-tables support counters to track activity on any input sample
  + Custom format for logs, unique-id, header rewriting, and redirects
  + Improved health checks (SSL, scripted TCP, check agent, ...)
  + Much more scalable configuration supports hundreds of thousands of
    backends and certificates without sweating

* Upload to unstable, merge all 1.5 work from experimental. Most important
  packaging changes since 1.4.25-1 include:
  + systemd support.
  + A more sane default config file.
  + Zero-downtime upgrades between 1.5 releases by gracefully reloading
    HAProxy during upgrades.
  + HTML documentation shipped in the haproxy-doc package.
  + kqueue support for kfreebsd.

* Packaging changes since 1.5~dev26-2:
  + Drop patches merged upstream:
    o Fix-reference-location-in-manpage.patch
    o 0001-BUILD-stats-workaround-stupid-and-bogus-Werror-forma.patch
  + d/watch: look for stable 1.5 releases
  + systemd: respect CONFIG and EXTRAOPTS when specified in
    /etc/default/haproxy.
  + initscript: test the configuration before start or reload.
  + initscript: remove the ENABLED flag and logic.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/proto/proto_http.h
2
2
 * include/proto/proto_http.h
3
3
 * This file contains HTTP protocol definitions.
4
4
 *
5
 
 * Copyright (C) 2000-2010 Willy Tarreau - w@1wt.eu
 
5
 * Copyright (C) 2000-2011 Willy Tarreau - w@1wt.eu
6
6
 *
7
7
 * This library is free software; you can redistribute it and/or
8
8
 * modify it under the terms of the GNU Lesser General Public
49
49
extern const char http_is_token[256];
50
50
extern const char http_is_ver_token[256];
51
51
 
 
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;
 
56
extern char *get_http_auth_buff;
 
57
 
52
58
#define HTTP_IS_CTL(x)   (http_is_ctl[(unsigned char)(x)])
53
59
#define HTTP_IS_SEP(x)   (http_is_sep[(unsigned char)(x)])
54
60
#define HTTP_IS_LWS(x)   (http_is_lws[(unsigned char)(x)])
57
63
#define HTTP_IS_TOKEN(x) (http_is_token[(unsigned char)(x)])
58
64
#define HTTP_IS_VER_TOKEN(x) (http_is_ver_token[(unsigned char)(x)])
59
65
 
60
 
int event_accept(int fd);
61
 
int process_cli(struct session *t);
62
 
int process_srv_data(struct session *t);
63
 
int process_srv_conn(struct session *t);
64
 
int http_wait_for_request(struct session *s, struct buffer *req, int an_bit);
65
 
int http_process_req_common(struct session *s, struct buffer *req, int an_bit, struct proxy *px);
66
 
int http_process_request(struct session *t, struct buffer *req, int an_bit);
67
 
int http_process_tarpit(struct session *s, struct buffer *req, int an_bit);
68
 
int http_process_request_body(struct session *s, struct buffer *req, int an_bit);
69
 
int http_send_name_header(struct http_txn *txn, struct http_msg *msg, struct buffer *buf, struct proxy* be, const char* svr_name);
70
 
int http_wait_for_response(struct session *s, struct buffer *rep, int an_bit);
71
 
int http_process_res_common(struct session *t, struct buffer *rep, int an_bit, struct proxy *px);
72
 
int http_request_forward_body(struct session *s, struct buffer *req, int an_bit);
73
 
int http_response_forward_body(struct session *s, struct buffer *res, int an_bit);
 
66
int process_cli(struct session *s);
 
67
int process_srv_data(struct session *s);
 
68
int process_srv_conn(struct session *s);
 
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);
 
71
int http_process_request(struct session *s, struct channel *req, int an_bit);
 
72
int http_process_tarpit(struct session *s, struct channel *req, int an_bit);
 
73
int http_wait_for_request_body(struct session *s, struct channel *req, int an_bit);
 
74
int http_send_name_header(struct http_txn *txn, struct proxy* be, const char* svr_name);
 
75
int http_wait_for_response(struct session *s, struct channel *rep, int an_bit);
 
76
int http_process_res_common(struct session *s, struct channel *rep, int an_bit, struct proxy *px);
 
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);
74
79
 
75
 
void debug_hdr(const char *dir, struct session *t, const char *start, const char *end);
76
 
void get_srv_from_appsession(struct session *t, const char *begin, int len);
77
 
int apply_filter_to_req_headers(struct session *t, struct buffer *req, struct hdr_exp *exp);
78
 
int apply_filter_to_req_line(struct session *t, struct buffer *req, struct hdr_exp *exp);
79
 
int apply_filters_to_request(struct session *s, struct buffer *req, struct proxy *px);
80
 
int apply_filters_to_response(struct session *t, struct buffer *rtr, struct proxy *px);
81
 
void manage_client_side_appsession(struct session *t, const char *buf, int len);
82
 
void manage_client_side_cookies(struct session *t, struct buffer *req);
83
 
void manage_server_side_cookies(struct session *t, struct buffer *rtr);
84
 
void check_response_for_cacheability(struct session *t, struct buffer *rtr);
85
 
int stats_check_uri(struct session *s, struct proxy *backend);
 
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);
 
84
int apply_filters_to_request(struct session *s, struct channel *req, struct proxy *px);
 
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);
 
90
int stats_check_uri(struct stream_interface *si, struct http_txn *txn, struct proxy *backend);
86
91
void init_proto_http();
 
92
int http_find_full_header2(const char *name, int len,
 
93
                           char *sol, struct hdr_idx *idx,
 
94
                           struct hdr_ctx *ctx);
87
95
int http_find_header2(const char *name, int len,
88
96
                      char *sol, struct hdr_idx *idx,
89
97
                      struct hdr_ctx *ctx);
 
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);
90
102
void http_sess_log(struct session *s);
91
 
void perform_http_redirect(struct session *s, struct stream_interface *si);
 
103
void http_perform_server_redirect(struct session *s, struct stream_interface *si);
92
104
void http_return_srv_error(struct session *s, struct stream_interface *si);
93
105
void http_capture_bad_message(struct error_snapshot *es, struct session *s,
94
 
                              struct buffer *buf, struct http_msg *msg,
95
 
                              int state, struct proxy *other_end);
96
 
unsigned int get_ip_from_hdr2(struct http_msg *msg, const char *hname, int hlen,
97
 
                              struct hdr_idx *idx, int occ);
 
106
                              struct http_msg *msg,
 
107
                              enum ht_state state, struct proxy *other_end);
 
108
unsigned int http_get_hdr(const struct http_msg *msg, const char *hname, int hlen,
 
109
                          struct hdr_idx *idx, int occ,
 
110
                          struct hdr_ctx *ctx, char **vptr, int *vlen);
98
111
 
99
112
void http_init_txn(struct session *s);
100
113
void http_end_txn(struct session *s);
101
114
void http_reset_txn(struct session *s);
102
115
 
 
116
struct http_req_rule *parse_http_req_cond(const char **args, const char *file, int linenum, struct proxy *proxy);
 
117
struct http_res_rule *parse_http_res_cond(const char **args, const char *file, int linenum, struct proxy *proxy);
 
118
void free_http_req_rules(struct list *r);
 
119
void free_http_res_rules(struct list *r);
 
120
struct chunk *http_error_message(struct session *s, int msgnum);
 
121
struct redirect_rule *http_parse_redirect_rule(const char *file, int linenum, struct proxy *curproxy,
 
122
                                               const char **args, char **errmsg, int use_fmt);
 
123
int smp_fetch_cookie(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
 
124
                 const struct arg *args, struct sample *smp, const char *kw);
 
125
 
 
126
enum http_meth_t find_http_meth(const char *str, const int len);
 
127
 
 
128
struct http_req_action_kw *action_http_req_custom(const char *kw);
 
129
struct http_res_action_kw *action_http_res_custom(const char *kw);
 
130
 
 
131
static inline void http_req_keywords_register(struct http_req_action_kw_list *kw_list)
 
132
{
 
133
        LIST_ADDQ(&http_req_keywords.list, &kw_list->list);
 
134
}
 
135
 
 
136
static inline void http_res_keywords_register(struct http_res_action_kw_list *kw_list)
 
137
{
 
138
        LIST_ADDQ(&http_res_keywords.list, &kw_list->list);
 
139
}
 
140
 
 
141
 
103
142
/* to be used when contents change in an HTTP message */
104
143
#define http_msg_move_end(msg, bytes) do { \
105
144
                unsigned int _bytes = (bytes);  \
 
145
                (msg)->next += (_bytes);        \
106
146
                (msg)->sov += (_bytes);         \
107
147
                (msg)->eoh += (_bytes);         \
108
148
        } while (0)
109
149
 
 
150
 
 
151
/* Return the amount of bytes that need to be rewound before buf->p to access
 
152
 * the current message's headers. The purpose is to be able to easily fetch
 
153
 * the message's beginning before headers are forwarded, as well as after.
 
154
 * The principle is that msg->eoh and msg->eol are immutable while msg->sov
 
155
 * equals the sum of the two before forwarding and is zero after forwarding,
 
156
 * so the difference cancels the rewinding.
 
157
 */
 
158
static inline int http_hdr_rewind(const struct http_msg *msg)
 
159
{
 
160
        return msg->eoh + msg->eol - msg->sov;
 
161
}
 
162
 
 
163
/* Return the amount of bytes that need to be rewound before buf->p to access
 
164
 * the current message's URI. The purpose is to be able to easily fetch
 
165
 * the message's beginning before headers are forwarded, as well as after.
 
166
 */
 
167
static inline int http_uri_rewind(const struct http_msg *msg)
 
168
{
 
169
        return http_hdr_rewind(msg) - msg->sl.rq.u;
 
170
}
 
171
 
 
172
/* Return the amount of bytes that need to be rewound before buf->p to access
 
173
 * the current message's BODY. The purpose is to be able to easily fetch
 
174
 * the message's beginning before headers are forwarded, as well as after.
 
175
 */
 
176
static inline int http_body_rewind(const struct http_msg *msg)
 
177
{
 
178
        return http_hdr_rewind(msg) - msg->eoh - msg->eol;
 
179
}
 
180
 
 
181
/* Return the amount of bytes that need to be rewound before buf->p to access
 
182
 * the current message's DATA. The difference with the function above is that
 
183
 * if a chunk is present and has already been parsed, its size is skipped so
 
184
 * that the byte pointed to is the first byte of actual data. The function is
 
185
 * safe for use in state HTTP_MSG_DATA regardless of whether the headers were
 
186
 * already forwarded or not.
 
187
 */
 
188
static inline int http_data_rewind(const struct http_msg *msg)
 
189
{
 
190
        return http_body_rewind(msg) - msg->sol;
 
191
}
 
192
 
 
193
/* Return the maximum amount of bytes that may be read after the beginning of
 
194
 * the message body, according to the advertised length. The function is safe
 
195
 * for use between HTTP_MSG_BODY and HTTP_MSG_DATA regardless of whether the
 
196
 * headers were already forwarded or not.
 
197
 */
 
198
static inline int http_body_bytes(const struct http_msg *msg)
 
199
{
 
200
        int len;
 
201
 
 
202
        len = msg->chn->buf->i - msg->sov - msg->sol;
 
203
        if (len > msg->body_len)
 
204
                len = msg->body_len;
 
205
        return len;
 
206
}
 
207
 
 
208
/* for debugging, reports the HTTP message state name */
 
209
static inline const char *http_msg_state_str(int msg_state)
 
210
{
 
211
        switch (msg_state) {
 
212
        case HTTP_MSG_RQBEFORE:    return "MSG_RQBEFORE";
 
213
        case HTTP_MSG_RQBEFORE_CR: return "MSG_RQBEFORE_CR";
 
214
        case HTTP_MSG_RQMETH:      return "MSG_RQMETH";
 
215
        case HTTP_MSG_RQMETH_SP:   return "MSG_RQMETH_SP";
 
216
        case HTTP_MSG_RQURI:       return "MSG_RQURI";
 
217
        case HTTP_MSG_RQURI_SP:    return "MSG_RQURI_SP";
 
218
        case HTTP_MSG_RQVER:       return "MSG_RQVER";
 
219
        case HTTP_MSG_RQLINE_END:  return "MSG_RQLINE_END";
 
220
        case HTTP_MSG_RPBEFORE:    return "MSG_RPBEFORE";
 
221
        case HTTP_MSG_RPBEFORE_CR: return "MSG_RPBEFORE_CR";
 
222
        case HTTP_MSG_RPVER:       return "MSG_RPVER";
 
223
        case HTTP_MSG_RPVER_SP:    return "MSG_RPVER_SP";
 
224
        case HTTP_MSG_RPCODE:      return "MSG_RPCODE";
 
225
        case HTTP_MSG_RPCODE_SP:   return "MSG_RPCODE_SP";
 
226
        case HTTP_MSG_RPREASON:    return "MSG_RPREASON";
 
227
        case HTTP_MSG_RPLINE_END:  return "MSG_RPLINE_END";
 
228
        case HTTP_MSG_HDR_FIRST:   return "MSG_HDR_FIRST";
 
229
        case HTTP_MSG_HDR_NAME:    return "MSG_HDR_NAME";
 
230
        case HTTP_MSG_HDR_COL:     return "MSG_HDR_COL";
 
231
        case HTTP_MSG_HDR_L1_SP:   return "MSG_HDR_L1_SP";
 
232
        case HTTP_MSG_HDR_L1_LF:   return "MSG_HDR_L1_LF";
 
233
        case HTTP_MSG_HDR_L1_LWS:  return "MSG_HDR_L1_LWS";
 
234
        case HTTP_MSG_HDR_VAL:     return "MSG_HDR_VAL";
 
235
        case HTTP_MSG_HDR_L2_LF:   return "MSG_HDR_L2_LF";
 
236
        case HTTP_MSG_HDR_L2_LWS:  return "MSG_HDR_L2_LWS";
 
237
        case HTTP_MSG_LAST_LF:     return "MSG_LAST_LF";
 
238
        case HTTP_MSG_ERROR:       return "MSG_ERROR";
 
239
        case HTTP_MSG_BODY:        return "MSG_BODY";
 
240
        case HTTP_MSG_100_SENT:    return "MSG_100_SENT";
 
241
        case HTTP_MSG_CHUNK_SIZE:  return "MSG_CHUNK_SIZE";
 
242
        case HTTP_MSG_DATA:        return "MSG_DATA";
 
243
        case HTTP_MSG_CHUNK_CRLF:  return "MSG_CHUNK_CRLF";
 
244
        case HTTP_MSG_TRAILERS:    return "MSG_TRAILERS";
 
245
        case HTTP_MSG_DONE:        return "MSG_DONE";
 
246
        case HTTP_MSG_CLOSING:     return "MSG_CLOSING";
 
247
        case HTTP_MSG_CLOSED:      return "MSG_CLOSED";
 
248
        case HTTP_MSG_TUNNEL:      return "MSG_TUNNEL";
 
249
        default:                   return "MSG_??????";
 
250
        }
 
251
}
 
252
 
110
253
#endif /* _PROTO_PROTO_HTTP_H */
111
254
 
112
255
/*