Gitiles
Code Review Sign In
git01.mediatek.com / haproxy / 7c96f678fa822d7f7dfc1fc053396c1dff547b11 / . / src / proto_http.c
blob: bcb02129e98b812ce5c92f7f906165cfa9b49890 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]1/*
2 * HTTP protocol analyzer
3 *
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]4 * Copyright 2000-2009 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13#include <ctype.h>
14#include <errno.h>
15#include <fcntl.h>
16#include <stdio.h>
17#include <stdlib.h>
18#include <string.h>
19#include <syslog.h>
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]20#include <time.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]21
22#include <sys/socket.h>
23#include <sys/stat.h>
24#include <sys/types.h>
25
Willy Tarreau2dd0d472006-06-29 17:53:05 +0200[diff] [blame]26#include <common/appsession.h>
27#include <common/compat.h>
28#include <common/config.h>
Willy Tarreaua4cd1f52006-12-16 19:57:26 +0100[diff] [blame]29#include <common/debug.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +0200[diff] [blame]30#include <common/memory.h>
31#include <common/mini-clist.h>
32#include <common/standard.h>
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200[diff] [blame]33#include <common/ticks.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +0200[diff] [blame]34#include <common/time.h>
35#include <common/uri_auth.h>
36#include <common/version.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]37
38#include <types/capture.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]39#include <types/global.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]40
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]41#include <proto/acl.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]42#include <proto/backend.h>
43#include <proto/buffers.h>
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100[diff] [blame]44#include <proto/checks.h>
Maik Broemme2850cb42009-04-17 18:53:21 +0200[diff] [blame]45#include <proto/client.h>
Willy Tarreau91861262007-10-17 17:06:05 +0200[diff] [blame]46#include <proto/dumpstats.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]47#include <proto/fd.h>
48#include <proto/log.h>
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]49#include <proto/hdr_idx.h>
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]50#include <proto/proto_tcp.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]51#include <proto/proto_http.h>
Willy Tarreau7f062c42009-03-05 18:43:00 +0100[diff] [blame]52#include <proto/proxy.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]53#include <proto/queue.h>
Willy Tarreau7f062c42009-03-05 18:43:00 +0100[diff] [blame]54#include <proto/server.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]55#include <proto/session.h>
Willy Tarreaucff64112008-11-03 06:26:53 +0100[diff] [blame]56#include <proto/stream_interface.h>
Willy Tarreau2d212792008-08-27 21:41:35 +0200[diff] [blame]57#include <proto/stream_sock.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]58#include <proto/task.h>
59
Willy Tarreau522d6c02009-12-06 18:49:18 +0100[diff] [blame]60const char HTTP_100[] =
61 "HTTP/1.1 100 Continue\r\n\r\n";
62
63const struct chunk http_100_chunk = {
64 .str = (char *)&HTTP_100,
65 .len = sizeof(HTTP_100)-1
66};
67
Willy Tarreau1c47f852006-07-09 08:22:27 +0200[diff] [blame]68/* This is used by remote monitoring */
Willy Tarreau0f772532006-12-23 20:51:41 +0100[diff] [blame]69const char HTTP_200[] =
Willy Tarreau1c47f852006-07-09 08:22:27 +0200[diff] [blame]70 "HTTP/1.0 200 OK\r\n"
71 "Cache-Control: no-cache\r\n"
72 "Connection: close\r\n"
73 "Content-Type: text/html\r\n"
74 "\r\n"
75 "<html><body><h1>200 OK</h1>\nHAProxy: service ready.\n</body></html>\n";
76
Willy Tarreau0f772532006-12-23 20:51:41 +0100[diff] [blame]77const struct chunk http_200_chunk = {
78 .str = (char *)&HTTP_200,
79 .len = sizeof(HTTP_200)-1
80};
81
Willy Tarreaub463dfb2008-06-07 23:08:56 +0200[diff] [blame]82const char *HTTP_301 =
83 "HTTP/1.0 301 Moved Permantenly\r\n"
84 "Cache-Control: no-cache\r\n"
85 "Connection: close\r\n"
86 "Location: "; /* not terminated since it will be concatenated with the URL */
87
Willy Tarreau0f772532006-12-23 20:51:41 +0100[diff] [blame]88const char *HTTP_302 =
89 "HTTP/1.0 302 Found\r\n"
90 "Cache-Control: no-cache\r\n"
91 "Connection: close\r\n"
92 "Location: "; /* not terminated since it will be concatenated with the URL */
93
94/* same as 302 except that the browser MUST retry with the GET method */
95const char *HTTP_303 =
96 "HTTP/1.0 303 See Other\r\n"
97 "Cache-Control: no-cache\r\n"
98 "Connection: close\r\n"
99 "Location: "; /* not terminated since it will be concatenated with the URL */
100
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]101/* Warning: this one is an sprintf() fmt string, with <realm> as its only argument */
102const char *HTTP_401_fmt =
103 "HTTP/1.0 401 Unauthorized\r\n"
104 "Cache-Control: no-cache\r\n"
105 "Connection: close\r\n"
Willy Tarreau791d66d2006-07-08 16:53:38 +0200[diff] [blame]106 "Content-Type: text/html\r\n"
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]107 "WWW-Authenticate: Basic realm=\"%s\"\r\n"
108 "\r\n"
109 "<html><body><h1>401 Unauthorized</h1>\nYou need a valid user and password to access this content.\n</body></html>\n";
110
Willy Tarreau0f772532006-12-23 20:51:41 +0100[diff] [blame]111
112const int http_err_codes[HTTP_ERR_SIZE] = {
113 [HTTP_ERR_400] = 400,
114 [HTTP_ERR_403] = 403,
115 [HTTP_ERR_408] = 408,
116 [HTTP_ERR_500] = 500,
117 [HTTP_ERR_502] = 502,
118 [HTTP_ERR_503] = 503,
119 [HTTP_ERR_504] = 504,
120};
121
Willy Tarreau80587432006-12-24 17:47:20 +0100[diff] [blame]122static const char *http_err_msgs[HTTP_ERR_SIZE] = {
Willy Tarreau0f772532006-12-23 20:51:41 +0100[diff] [blame]123 [HTTP_ERR_400] =
Willy Tarreau80587432006-12-24 17:47:20 +0100[diff] [blame]124 "HTTP/1.0 400 Bad request\r\n"
Willy Tarreau0f772532006-12-23 20:51:41 +0100[diff] [blame]125 "Cache-Control: no-cache\r\n"
126 "Connection: close\r\n"
127 "Content-Type: text/html\r\n"
128 "\r\n"
129 "<html><body><h1>400 Bad request</h1>\nYour browser sent an invalid request.\n</body></html>\n",
130
131 [HTTP_ERR_403] =
132 "HTTP/1.0 403 Forbidden\r\n"
133 "Cache-Control: no-cache\r\n"
134 "Connection: close\r\n"
135 "Content-Type: text/html\r\n"
136 "\r\n"
137 "<html><body><h1>403 Forbidden</h1>\nRequest forbidden by administrative rules.\n</body></html>\n",
138
139 [HTTP_ERR_408] =
140 "HTTP/1.0 408 Request Time-out\r\n"
141 "Cache-Control: no-cache\r\n"
142 "Connection: close\r\n"
143 "Content-Type: text/html\r\n"
144 "\r\n"
145 "<html><body><h1>408 Request Time-out</h1>\nYour browser didn't send a complete request in time.\n</body></html>\n",
146
147 [HTTP_ERR_500] =
148 "HTTP/1.0 500 Server Error\r\n"
149 "Cache-Control: no-cache\r\n"
150 "Connection: close\r\n"
151 "Content-Type: text/html\r\n"
152 "\r\n"
153 "<html><body><h1>500 Server Error</h1>\nAn internal server error occured.\n</body></html>\n",
154
155 [HTTP_ERR_502] =
156 "HTTP/1.0 502 Bad Gateway\r\n"
157 "Cache-Control: no-cache\r\n"
158 "Connection: close\r\n"
159 "Content-Type: text/html\r\n"
160 "\r\n"
161 "<html><body><h1>502 Bad Gateway</h1>\nThe server returned an invalid or incomplete response.\n</body></html>\n",
162
163 [HTTP_ERR_503] =
164 "HTTP/1.0 503 Service Unavailable\r\n"
165 "Cache-Control: no-cache\r\n"
166 "Connection: close\r\n"
167 "Content-Type: text/html\r\n"
168 "\r\n"
169 "<html><body><h1>503 Service Unavailable</h1>\nNo server is available to handle this request.\n</body></html>\n",
170
171 [HTTP_ERR_504] =
172 "HTTP/1.0 504 Gateway Time-out\r\n"
173 "Cache-Control: no-cache\r\n"
174 "Connection: close\r\n"
175 "Content-Type: text/html\r\n"
176 "\r\n"
177 "<html><body><h1>504 Gateway Time-out</h1>\nThe server didn't respond in time.\n</body></html>\n",
178
179};
180
Willy Tarreau80587432006-12-24 17:47:20 +0100[diff] [blame]181/* We must put the messages here since GCC cannot initialize consts depending
182 * on strlen().
183 */
184struct chunk http_err_chunks[HTTP_ERR_SIZE];
185
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]186#define FD_SETS_ARE_BITFIELDS
187#ifdef FD_SETS_ARE_BITFIELDS
188/*
189 * This map is used with all the FD_* macros to check whether a particular bit
190 * is set or not. Each bit represents an ACSII code. FD_SET() sets those bytes
191 * which should be encoded. When FD_ISSET() returns non-zero, it means that the
192 * byte should be encoded. Be careful to always pass bytes from 0 to 255
193 * exclusively to the macros.
194 */
195fd_set hdr_encode_map[(sizeof(fd_set) > (256/8)) ? 1 : ((256/8) / sizeof(fd_set))];
196fd_set url_encode_map[(sizeof(fd_set) > (256/8)) ? 1 : ((256/8) / sizeof(fd_set))];
197
198#else
199#error "Check if your OS uses bitfields for fd_sets"
200#endif
201
Willy Tarreau80587432006-12-24 17:47:20 +0100[diff] [blame]202void init_proto_http()
203{
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]204 int i;
205 char *tmp;
Willy Tarreau80587432006-12-24 17:47:20 +0100[diff] [blame]206 int msg;
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]207
Willy Tarreau80587432006-12-24 17:47:20 +0100[diff] [blame]208 for (msg = 0; msg < HTTP_ERR_SIZE; msg++) {
209 if (!http_err_msgs[msg]) {
210 Alert("Internal error: no message defined for HTTP return code %d. Aborting.\n", msg);
211 abort();
212 }
213
214 http_err_chunks[msg].str = (char *)http_err_msgs[msg];
215 http_err_chunks[msg].len = strlen(http_err_msgs[msg]);
216 }
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]217
218 /* initialize the log header encoding map : '{|}"#' should be encoded with
219 * '#' as prefix, as well as non-printable characters ( <32 or >= 127 ).
220 * URL encoding only requires '"', '#' to be encoded as well as non-
221 * printable characters above.
222 */
223 memset(hdr_encode_map, 0, sizeof(hdr_encode_map));
224 memset(url_encode_map, 0, sizeof(url_encode_map));
225 for (i = 0; i < 32; i++) {
226 FD_SET(i, hdr_encode_map);
227 FD_SET(i, url_encode_map);
228 }
229 for (i = 127; i < 256; i++) {
230 FD_SET(i, hdr_encode_map);
231 FD_SET(i, url_encode_map);
232 }
233
234 tmp = "\"#{|}";
235 while (*tmp) {
236 FD_SET(*tmp, hdr_encode_map);
237 tmp++;
238 }
239
240 tmp = "\"#";
241 while (*tmp) {
242 FD_SET(*tmp, url_encode_map);
243 tmp++;
244 }
Willy Tarreau332f8bf2007-05-13 21:36:56 +0200[diff] [blame]245
246 /* memory allocations */
247 pool2_requri = create_pool("requri", REQURI_LEN, MEM_F_SHARED);
Willy Tarreau086b3b42007-05-13 21:45:51 +0200[diff] [blame]248 pool2_capture = create_pool("capture", CAPTURE_LEN, MEM_F_SHARED);
Willy Tarreau80587432006-12-24 17:47:20 +0100[diff] [blame]249}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]250
Willy Tarreau53b6c742006-12-17 13:37:46 +0100[diff] [blame]251/*
252 * We have 26 list of methods (1 per first letter), each of which can have
253 * up to 3 entries (2 valid, 1 null).
254 */
255struct http_method_desc {
256 http_meth_t meth;
257 int len;
258 const char text[8];
259};
260
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]261const struct http_method_desc http_methods[26][3] = {
Willy Tarreau53b6c742006-12-17 13:37:46 +0100[diff] [blame]262 ['C' - 'A'] = {
263 [0] = { .meth = HTTP_METH_CONNECT , .len=7, .text="CONNECT" },
264 },
265 ['D' - 'A'] = {
266 [0] = { .meth = HTTP_METH_DELETE , .len=6, .text="DELETE" },
267 },
268 ['G' - 'A'] = {
269 [0] = { .meth = HTTP_METH_GET , .len=3, .text="GET" },
270 },
271 ['H' - 'A'] = {
272 [0] = { .meth = HTTP_METH_HEAD , .len=4, .text="HEAD" },
273 },
274 ['P' - 'A'] = {
275 [0] = { .meth = HTTP_METH_POST , .len=4, .text="POST" },
276 [1] = { .meth = HTTP_METH_PUT , .len=3, .text="PUT" },
277 },
278 ['T' - 'A'] = {
279 [0] = { .meth = HTTP_METH_TRACE , .len=5, .text="TRACE" },
280 },
281 /* rest is empty like this :
282 * [1] = { .meth = HTTP_METH_NONE , .len=0, .text="" },
283 */
284};
285
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]286/* It is about twice as fast on recent architectures to lookup a byte in a
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200[diff] [blame]287 * table than to perform a boolean AND or OR between two tests. Refer to
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]288 * RFC2616 for those chars.
289 */
290
291const char http_is_spht[256] = {
292 [' '] = 1, ['\t'] = 1,
293};
294
295const char http_is_crlf[256] = {
296 ['\r'] = 1, ['\n'] = 1,
297};
298
299const char http_is_lws[256] = {
300 [' '] = 1, ['\t'] = 1,
301 ['\r'] = 1, ['\n'] = 1,
302};
303
304const char http_is_sep[256] = {
305 ['('] = 1, [')'] = 1, ['<'] = 1, ['>'] = 1,
306 ['@'] = 1, [','] = 1, [';'] = 1, [':'] = 1,
307 ['"'] = 1, ['/'] = 1, ['['] = 1, [']'] = 1,
308 ['{'] = 1, ['}'] = 1, ['?'] = 1, ['='] = 1,
309 [' '] = 1, ['\t'] = 1, ['\\'] = 1,
310};
311
312const char http_is_ctl[256] = {
313 [0 ... 31] = 1,
314 [127] = 1,
315};
316
317/*
318 * A token is any ASCII char that is neither a separator nor a CTL char.
319 * Do not overwrite values in assignment since gcc-2.95 will not handle
320 * them correctly. Instead, define every non-CTL char's status.
321 */
322const char http_is_token[256] = {
323 [' '] = 0, ['!'] = 1, ['"'] = 0, ['#'] = 1,
324 ['$'] = 1, ['%'] = 1, ['&'] = 1, ['\''] = 1,
325 ['('] = 0, [')'] = 0, ['*'] = 1, ['+'] = 1,
326 [','] = 0, ['-'] = 1, ['.'] = 1, ['/'] = 0,
327 ['0'] = 1, ['1'] = 1, ['2'] = 1, ['3'] = 1,
328 ['4'] = 1, ['5'] = 1, ['6'] = 1, ['7'] = 1,
329 ['8'] = 1, ['9'] = 1, [':'] = 0, [';'] = 0,
330 ['<'] = 0, ['='] = 0, ['>'] = 0, ['?'] = 0,
331 ['@'] = 0, ['A'] = 1, ['B'] = 1, ['C'] = 1,
332 ['D'] = 1, ['E'] = 1, ['F'] = 1, ['G'] = 1,
333 ['H'] = 1, ['I'] = 1, ['J'] = 1, ['K'] = 1,
334 ['L'] = 1, ['M'] = 1, ['N'] = 1, ['O'] = 1,
335 ['P'] = 1, ['Q'] = 1, ['R'] = 1, ['S'] = 1,
336 ['T'] = 1, ['U'] = 1, ['V'] = 1, ['W'] = 1,
337 ['X'] = 1, ['Y'] = 1, ['Z'] = 1, ['['] = 0,
338 ['\\'] = 0, [']'] = 0, ['^'] = 1, ['_'] = 1,
339 ['`'] = 1, ['a'] = 1, ['b'] = 1, ['c'] = 1,
340 ['d'] = 1, ['e'] = 1, ['f'] = 1, ['g'] = 1,
341 ['h'] = 1, ['i'] = 1, ['j'] = 1, ['k'] = 1,
342 ['l'] = 1, ['m'] = 1, ['n'] = 1, ['o'] = 1,
343 ['p'] = 1, ['q'] = 1, ['r'] = 1, ['s'] = 1,
344 ['t'] = 1, ['u'] = 1, ['v'] = 1, ['w'] = 1,
345 ['x'] = 1, ['y'] = 1, ['z'] = 1, ['{'] = 0,
346 ['|'] = 1, ['}'] = 0, ['~'] = 1,
347};
348
349
Willy Tarreau4b89ad42007-03-04 18:13:58 +0100[diff] [blame]350/*
351 * An http ver_token is any ASCII which can be found in an HTTP version,
352 * which includes 'H', 'T', 'P', '/', '.' and any digit.
353 */
354const char http_is_ver_token[256] = {
355 ['.'] = 1, ['/'] = 1,
356 ['0'] = 1, ['1'] = 1, ['2'] = 1, ['3'] = 1, ['4'] = 1,
357 ['5'] = 1, ['6'] = 1, ['7'] = 1, ['8'] = 1, ['9'] = 1,
358 ['H'] = 1, ['P'] = 1, ['T'] = 1,
359};
360
361
Willy Tarreau4af6f3a2007-03-18 22:36:26 +0100[diff] [blame]362/*
363 * Adds a header and its CRLF at the tail of buffer <b>, just before the last
364 * CRLF. Text length is measured first, so it cannot be NULL.
365 * The header is also automatically added to the index <hdr_idx>, and the end
366 * of headers is automatically adjusted. The number of bytes added is returned
367 * on success, otherwise <0 is returned indicating an error.
368 */
369int http_header_add_tail(struct buffer *b, struct http_msg *msg,
370 struct hdr_idx *hdr_idx, const char *text)
371{
372 int bytes, len;
373
374 len = strlen(text);
375 bytes = buffer_insert_line2(b, b->data + msg->eoh, text, len);
376 if (!bytes)
377 return -1;
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]378 http_msg_move_end(msg, bytes);
Willy Tarreau4af6f3a2007-03-18 22:36:26 +0100[diff] [blame]379 return hdr_idx_add(len, 1, hdr_idx, hdr_idx->tail);
380}
381
382/*
383 * Adds a header and its CRLF at the tail of buffer <b>, just before the last
384 * CRLF. <len> bytes are copied, not counting the CRLF. If <text> is NULL, then
385 * the buffer is only opened and the space reserved, but nothing is copied.
386 * The header is also automatically added to the index <hdr_idx>, and the end
387 * of headers is automatically adjusted. The number of bytes added is returned
388 * on success, otherwise <0 is returned indicating an error.
389 */
390int http_header_add_tail2(struct buffer *b, struct http_msg *msg,
391 struct hdr_idx *hdr_idx, const char *text, int len)
392{
393 int bytes;
394
395 bytes = buffer_insert_line2(b, b->data + msg->eoh, text, len);
396 if (!bytes)
397 return -1;
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]398 http_msg_move_end(msg, bytes);
Willy Tarreau4af6f3a2007-03-18 22:36:26 +0100[diff] [blame]399 return hdr_idx_add(len, 1, hdr_idx, hdr_idx->tail);
400}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]401
402/*
Willy Tarreauaa9dce32007-03-18 23:50:16 +0100[diff] [blame]403 * Checks if <hdr> is exactly <name> for <len> chars, and ends with a colon.
404 * If so, returns the position of the first non-space character relative to
405 * <hdr>, or <end>-<hdr> if not found before. If no value is found, it tries
406 * to return a pointer to the place after the first space. Returns 0 if the
407 * header name does not match. Checks are case-insensitive.
408 */
409int http_header_match2(const char *hdr, const char *end,
410 const char *name, int len)
411{
412 const char *val;
413
414 if (hdr + len >= end)
415 return 0;
416 if (hdr[len] != ':')
417 return 0;
418 if (strncasecmp(hdr, name, len) != 0)
419 return 0;
420 val = hdr + len + 1;
421 while (val < end && HTTP_IS_SPHT(*val))
422 val++;
423 if ((val >= end) && (len + 2 <= end - hdr))
424 return len + 2; /* we may replace starting from second space */
425 return val - hdr;
426}
427
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]428/* Find the end of the header value contained between <s> and <e>.
429 * See RFC2616, par 2.2 for more information. Note that it requires
430 * a valid header to return a valid result.
431 */
432const char *find_hdr_value_end(const char *s, const char *e)
433{
434 int quoted, qdpair;
435
436 quoted = qdpair = 0;
437 for (; s < e; s++) {
438 if (qdpair) qdpair = 0;
439 else if (quoted && *s == '\\') qdpair = 1;
440 else if (quoted && *s == '"') quoted = 0;
441 else if (*s == '"') quoted = 1;
442 else if (*s == ',') return s;
443 }
444 return s;
445}
446
447/* Find the first or next occurrence of header <name> in message buffer <sol>
448 * using headers index <idx>, and return it in the <ctx> structure. This
449 * structure holds everything necessary to use the header and find next
450 * occurrence. If its <idx> member is 0, the header is searched from the
451 * beginning. Otherwise, the next occurrence is returned. The function returns
452 * 1 when it finds a value, and 0 when there is no more.
453 */
454int http_find_header2(const char *name, int len,
455 const char *sol, struct hdr_idx *idx,
456 struct hdr_ctx *ctx)
457{
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]458 const char *eol, *sov;
459 int cur_idx;
460
461 if (ctx->idx) {
462 /* We have previously returned a value, let's search
463 * another one on the same line.
464 */
465 cur_idx = ctx->idx;
466 sol = ctx->line;
467 sov = sol + ctx->val + ctx->vlen;
468 eol = sol + idx->v[cur_idx].len;
469
470 if (sov >= eol)
471 /* no more values in this header */
472 goto next_hdr;
473
474 /* values remaining for this header, skip the comma */
475 sov++;
476 while (sov < eol && http_is_lws[(unsigned char)*sov])
477 sov++;
478
479 goto return_hdr;
480 }
481
482 /* first request for this header */
483 sol += hdr_idx_first_pos(idx);
484 cur_idx = hdr_idx_first_idx(idx);
485
486 while (cur_idx) {
487 eol = sol + idx->v[cur_idx].len;
488
Willy Tarreau1ad7c6d2007-06-10 21:42:55 +0200[diff] [blame]489 if (len == 0) {
490 /* No argument was passed, we want any header.
491 * To achieve this, we simply build a fake request. */
492 while (sol + len < eol && sol[len] != ':')
493 len++;
494 name = sol;
495 }
496
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]497 if ((len < eol - sol) &&
498 (sol[len] == ':') &&
499 (strncasecmp(sol, name, len) == 0)) {
500
501 sov = sol + len + 1;
502 while (sov < eol && http_is_lws[(unsigned char)*sov])
503 sov++;
504 return_hdr:
505 ctx->line = sol;
506 ctx->idx = cur_idx;
507 ctx->val = sov - sol;
508
509 eol = find_hdr_value_end(sov, eol);
510 ctx->vlen = eol - sov;
511 return 1;
512 }
513 next_hdr:
514 sol = eol + idx->v[cur_idx].cr + 1;
515 cur_idx = idx->v[cur_idx].next;
516 }
517 return 0;
518}
519
520int http_find_header(const char *name,
521 const char *sol, struct hdr_idx *idx,
522 struct hdr_ctx *ctx)
523{
524 return http_find_header2(name, strlen(name), sol, idx, ctx);
525}
526
Willy Tarreau2d3d94c2008-11-30 20:20:08 +0100[diff] [blame]527/* This function handles a server error at the stream interface level. The
528 * stream interface is assumed to be already in a closed state. An optional
529 * message is copied into the input buffer, and an HTTP status code stored.
530 * The error flags are set to the values in arguments. Any pending request
Willy Tarreau6f0aa472009-03-08 20:33:29 +0100[diff] [blame]531 * in this buffer will be lost.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]532 */
Willy Tarreau2d3d94c2008-11-30 20:20:08 +0100[diff] [blame]533static void http_server_error(struct session *t, struct stream_interface *si,
534 int err, int finst, int status, const struct chunk *msg)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]535{
Willy Tarreau6f0aa472009-03-08 20:33:29 +0100[diff] [blame]536 buffer_erase(si->ob);
537 buffer_erase(si->ib);
Willy Tarreau520d95e2009-09-19 21:04:57 +0200[diff] [blame]538 buffer_auto_close(si->ib);
Willy Tarreau0f772532006-12-23 20:51:41 +0100[diff] [blame]539 if (status > 0 && msg) {
Willy Tarreau3bac9ff2007-03-18 17:31:28 +0100[diff] [blame]540 t->txn.status = status;
Willy Tarreau2d3d94c2008-11-30 20:20:08 +0100[diff] [blame]541 buffer_write(si->ib, msg->str, msg->len);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]542 }
543 if (!(t->flags & SN_ERR_MASK))
544 t->flags |= err;
545 if (!(t->flags & SN_FINST_MASK))
546 t->flags |= finst;
547}
548
Willy Tarreau80587432006-12-24 17:47:20 +0100[diff] [blame]549/* This function returns the appropriate error location for the given session
550 * and message.
551 */
552
553struct chunk *error_message(struct session *s, int msgnum)
554{
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]555 if (s->be->errmsg[msgnum].str)
556 return &s->be->errmsg[msgnum];
Willy Tarreau80587432006-12-24 17:47:20 +0100[diff] [blame]557 else if (s->fe->errmsg[msgnum].str)
558 return &s->fe->errmsg[msgnum];
559 else
560 return &http_err_chunks[msgnum];
561}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]562
Willy Tarreau53b6c742006-12-17 13:37:46 +0100[diff] [blame]563/*
564 * returns HTTP_METH_NONE if there is nothing valid to read (empty or non-text
565 * string), HTTP_METH_OTHER for unknown methods, or the identified method.
566 */
567static http_meth_t find_http_meth(const char *str, const int len)
568{
569 unsigned char m;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]570 const struct http_method_desc *h;
Willy Tarreau53b6c742006-12-17 13:37:46 +0100[diff] [blame]571
572 m = ((unsigned)*str - 'A');
573
574 if (m < 26) {
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]575 for (h = http_methods[m]; h->len > 0; h++) {
576 if (unlikely(h->len != len))
Willy Tarreau53b6c742006-12-17 13:37:46 +0100[diff] [blame]577 continue;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]578 if (likely(memcmp(str, h->text, h->len) == 0))
Willy Tarreau53b6c742006-12-17 13:37:46 +0100[diff] [blame]579 return h->meth;
Willy Tarreau53b6c742006-12-17 13:37:46 +0100[diff] [blame]580 };
581 return HTTP_METH_OTHER;
582 }
583 return HTTP_METH_NONE;
584
585}
586
Willy Tarreau21d2af32008-02-14 20:25:24 +0100[diff] [blame]587/* Parse the URI from the given transaction (which is assumed to be in request
588 * phase) and look for the "/" beginning the PATH. If not found, return NULL.
589 * It is returned otherwise.
590 */
591static char *
592http_get_path(struct http_txn *txn)
593{
594 char *ptr, *end;
595
596 ptr = txn->req.sol + txn->req.sl.rq.u;
597 end = ptr + txn->req.sl.rq.u_l;
598
599 if (ptr >= end)
600 return NULL;
601
602 /* RFC2616, par. 5.1.2 :
603 * Request-URI = "*" | absuri | abspath | authority
604 */
605
606 if (*ptr == '*')
607 return NULL;
608
609 if (isalpha((unsigned char)*ptr)) {
610 /* this is a scheme as described by RFC3986, par. 3.1 */
611 ptr++;
612 while (ptr < end &&
613 (isalnum((unsigned char)*ptr) || *ptr == '+' || *ptr == '-' || *ptr == '.'))
614 ptr++;
615 /* skip '://' */
616 if (ptr == end || *ptr++ != ':')
617 return NULL;
618 if (ptr == end || *ptr++ != '/')
619 return NULL;
620 if (ptr == end || *ptr++ != '/')
621 return NULL;
622 }
623 /* skip [user[:passwd]@]host[:[port]] */
624
625 while (ptr < end && *ptr != '/')
626 ptr++;
627
628 if (ptr == end)
629 return NULL;
630
631 /* OK, we got the '/' ! */
632 return ptr;
633}
634
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]635/* Returns a 302 for a redirectable request. This may only be called just after
636 * the stream interface has moved to SI_ST_ASS. Unprocessable requests are
637 * left unchanged and will follow normal proxy processing.
638 */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100[diff] [blame]639void perform_http_redirect(struct session *s, struct stream_interface *si)
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]640{
641 struct http_txn *txn;
642 struct chunk rdr;
643 char *path;
644 int len;
645
646 /* 1: create the response header */
647 rdr.len = strlen(HTTP_302);
648 rdr.str = trash;
649 memcpy(rdr.str, HTTP_302, rdr.len);
650
651 /* 2: add the server's prefix */
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200[diff] [blame]652 if (rdr.len + s->srv->rdr_len > rdr.size)
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]653 return;
654
655 memcpy(rdr.str + rdr.len, s->srv->rdr_pfx, s->srv->rdr_len);
656 rdr.len += s->srv->rdr_len;
657
658 /* 3: add the request URI */
659 txn = &s->txn;
660 path = http_get_path(txn);
661 if (!path)
662 return;
663
664 len = txn->req.sl.rq.u_l + (txn->req.sol+txn->req.sl.rq.u) - path;
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200[diff] [blame]665 if (rdr.len + len > rdr.size - 4) /* 4 for CRLF-CRLF */
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]666 return;
667
668 memcpy(rdr.str + rdr.len, path, len);
669 rdr.len += len;
670 memcpy(rdr.str + rdr.len, "\r\n\r\n", 4);
671 rdr.len += 4;
672
673 /* prepare to return without error. */
Willy Tarreau99126c32008-11-27 10:30:51 +0100[diff] [blame]674 si->shutr(si);
675 si->shutw(si);
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]676 si->err_type = SI_ET_NONE;
677 si->err_loc = NULL;
678 si->state = SI_ST_CLO;
679
680 /* send the message */
Willy Tarreau2d3d94c2008-11-30 20:20:08 +0100[diff] [blame]681 http_server_error(s, si, SN_ERR_PRXCOND, SN_FINST_C, 302, &rdr);
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]682
683 /* FIXME: we should increase a counter of redirects per server and per backend. */
684 if (s->srv)
Willy Tarreau7f062c42009-03-05 18:43:00 +0100[diff] [blame]685 srv_inc_sess_ctr(s->srv);
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]686}
687
Willy Tarreau0cac36f2008-11-30 20:44:17 +0100[diff] [blame]688/* Return the error message corresponding to si->err_type. It is assumed
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]689 * that the server side is closed. Note that err_type is actually a
690 * bitmask, where almost only aborts may be cumulated with other
691 * values. We consider that aborted operations are more important
692 * than timeouts or errors due to the fact that nobody else in the
693 * logs might explain incomplete retries. All others should avoid
694 * being cumulated. It should normally not be possible to have multiple
695 * aborts at once, but just in case, the first one in sequence is reported.
696 */
Willy Tarreau0cac36f2008-11-30 20:44:17 +0100[diff] [blame]697void http_return_srv_error(struct session *s, struct stream_interface *si)
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]698{
Willy Tarreau0cac36f2008-11-30 20:44:17 +0100[diff] [blame]699 int err_type = si->err_type;
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]700
701 if (err_type & SI_ET_QUEUE_ABRT)
Willy Tarreau2d3d94c2008-11-30 20:20:08 +0100[diff] [blame]702 http_server_error(s, si, SN_ERR_CLICL, SN_FINST_Q,
703 503, error_message(s, HTTP_ERR_503));
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]704 else if (err_type & SI_ET_CONN_ABRT)
Willy Tarreau2d3d94c2008-11-30 20:20:08 +0100[diff] [blame]705 http_server_error(s, si, SN_ERR_CLICL, SN_FINST_C,
706 503, error_message(s, HTTP_ERR_503));
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]707 else if (err_type & SI_ET_QUEUE_TO)
Willy Tarreau2d3d94c2008-11-30 20:20:08 +0100[diff] [blame]708 http_server_error(s, si, SN_ERR_SRVTO, SN_FINST_Q,
709 503, error_message(s, HTTP_ERR_503));
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]710 else if (err_type & SI_ET_QUEUE_ERR)
Willy Tarreau2d3d94c2008-11-30 20:20:08 +0100[diff] [blame]711 http_server_error(s, si, SN_ERR_SRVCL, SN_FINST_Q,
712 503, error_message(s, HTTP_ERR_503));
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]713 else if (err_type & SI_ET_CONN_TO)
Willy Tarreau2d3d94c2008-11-30 20:20:08 +0100[diff] [blame]714 http_server_error(s, si, SN_ERR_SRVTO, SN_FINST_C,
715 503, error_message(s, HTTP_ERR_503));
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]716 else if (err_type & SI_ET_CONN_ERR)
Willy Tarreau2d3d94c2008-11-30 20:20:08 +0100[diff] [blame]717 http_server_error(s, si, SN_ERR_SRVCL, SN_FINST_C,
718 503, error_message(s, HTTP_ERR_503));
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]719 else /* SI_ET_CONN_OTHER and others */
Willy Tarreau2d3d94c2008-11-30 20:20:08 +0100[diff] [blame]720 http_server_error(s, si, SN_ERR_INTERNAL, SN_FINST_C,
721 500, error_message(s, HTTP_ERR_500));
Willy Tarreauefb453c2008-10-26 20:49:47 +0100[diff] [blame]722}
723
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]724extern const char sess_term_cond[8];
725extern const char sess_fin_state[8];
726extern const char *monthname[12];
727const char sess_cookie[4] = "NIDV"; /* No cookie, Invalid cookie, cookie for a Down server, Valid cookie */
728const char sess_set_cookie[8] = "N1I3PD5R"; /* No set-cookie, unknown, Set-Cookie Inserted, unknown,
729 Set-cookie seen and left unchanged (passive), Set-cookie Deleted,
730 unknown, Set-cookie Rewritten */
Willy Tarreau332f8bf2007-05-13 21:36:56 +0200[diff] [blame]731struct pool_head *pool2_requri;
Willy Tarreau086b3b42007-05-13 21:45:51 +0200[diff] [blame]732struct pool_head *pool2_capture;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]733
Emeric Brun3a058f32009-06-30 18:26:00 +0200[diff] [blame]734void http_sess_clflog(struct session *s)
735{
736 char pn[INET6_ADDRSTRLEN + strlen(":65535")];
737 struct proxy *fe = s->fe;
738 struct proxy *be = s->be;
739 struct proxy *prx_log;
740 struct http_txn *txn = &s->txn;
741 int tolog, level, err;
742 char *uri, *h;
743 char *svid;
744 struct tm tm;
745 static char tmpline[MAX_SYSLOG_LEN];
746 int hdr;
747 size_t w;
748 int t_request;
749
750 prx_log = fe;
751 err = (s->flags & (SN_ERR_MASK | SN_REDISP)) ||
752 (s->conn_retries != be->conn_retries) ||
753 txn->status >= 500;
754
755 if (s->cli_addr.ss_family == AF_INET)
756 inet_ntop(AF_INET,
757 (const void *)&((struct sockaddr_in *)&s->cli_addr)->sin_addr,
758 pn, sizeof(pn));
759 else
760 inet_ntop(AF_INET6,
761 (const void *)&((struct sockaddr_in6 *)(&s->cli_addr))->sin6_addr,
762 pn, sizeof(pn));
763
764 get_gmtime(s->logs.accept_date.tv_sec, &tm);
765
766 /* FIXME: let's limit ourselves to frontend logging for now. */
767 tolog = fe->to_log;
768
769 h = tmpline;
770
771 w = snprintf(h, sizeof(tmpline),
772 "%s - - [%02d/%s/%04d:%02d:%02d:%02d +0000]",
773 pn,
774 tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
775 tm.tm_hour, tm.tm_min, tm.tm_sec);
776 if (w < 0 || w >= sizeof(tmpline) - (h - tmpline))
777 goto trunc;
778 h += w;
779
780 if (h >= tmpline + sizeof(tmpline) - 4)
781 goto trunc;
782
783 *(h++) = ' ';
784 *(h++) = '\"';
785 uri = txn->uri ? txn->uri : "<BADREQ>";
786 h = encode_string(h, tmpline + sizeof(tmpline) - 1,
787 '#', url_encode_map, uri);
788 *(h++) = '\"';
789
790 w = snprintf(h, sizeof(tmpline) - (h - tmpline), " %d %lld", txn->status, s->logs.bytes_out);
791 if (w < 0 || w >= sizeof(tmpline) - (h - tmpline))
792 goto trunc;
793 h += w;
794
795 if (h >= tmpline + sizeof(tmpline) - 9)
796 goto trunc;
797 memcpy(h, " \"-\" \"-\"", 8);
798 h += 8;
799
800 w = snprintf(h, sizeof(tmpline) - (h - tmpline),
801 " %d %03d",
802 (s->cli_addr.ss_family == AF_INET) ?
803 ntohs(((struct sockaddr_in *)&s->cli_addr)->sin_port) :
804 ntohs(((struct sockaddr_in6 *)&s->cli_addr)->sin6_port),
805 (int)s->logs.accept_date.tv_usec/1000);
806 if (w < 0 || w >= sizeof(tmpline) - (h - tmpline))
807 goto trunc;
808 h += w;
809
810 w = strlen(fe->id);
811 if (h >= tmpline + sizeof(tmpline) - 4 - w)
812 goto trunc;
813 *(h++) = ' ';
814 *(h++) = '\"';
815 memcpy(h, fe->id, w);
816 h += w;
817 *(h++) = '\"';
818
819 w = strlen(be->id);
820 if (h >= tmpline + sizeof(tmpline) - 4 - w)
821 goto trunc;
822 *(h++) = ' ';
823 *(h++) = '\"';
824 memcpy(h, be->id, w);
825 h += w;
826 *(h++) = '\"';
827
828 svid = (tolog & LW_SVID) ?
829 (s->data_source != DATA_SRC_STATS) ?
830 (s->srv != NULL) ? s->srv->id : "<NOSRV>" : "<STATS>" : "-";
831
832 w = strlen(svid);
833 if (h >= tmpline + sizeof(tmpline) - 4 - w)
834 goto trunc;
835 *(h++) = ' ';
836 *(h++) = '\"';
837 memcpy(h, svid, w);
838 h += w;
839 *(h++) = '\"';
840
841 t_request = -1;
842 if (tv_isge(&s->logs.tv_request, &s->logs.tv_accept))
843 t_request = tv_ms_elapsed(&s->logs.tv_accept, &s->logs.tv_request);
844 w = snprintf(h, sizeof(tmpline) - (h - tmpline),
845 " %d %ld %ld %ld %ld",
846 t_request,
847 (s->logs.t_queue >= 0) ? s->logs.t_queue - t_request : -1,
848 (s->logs.t_connect >= 0) ? s->logs.t_connect - s->logs.t_queue : -1,
849 (s->logs.t_data >= 0) ? s->logs.t_data - s->logs.t_connect : -1,
850 s->logs.t_close);
851 if (w < 0 || w >= sizeof(tmpline) - (h - tmpline))
852 goto trunc;
853 h += w;
854
855 if (h >= tmpline + sizeof(tmpline) - 8)
856 goto trunc;
857 *(h++) = ' ';
858 *(h++) = '\"';
859 *(h++) = sess_term_cond[(s->flags & SN_ERR_MASK) >> SN_ERR_SHIFT];
860 *(h++) = sess_fin_state[(s->flags & SN_FINST_MASK) >> SN_FINST_SHIFT];
861 *(h++) = (be->options & PR_O_COOK_ANY) ? sess_cookie[(txn->flags & TX_CK_MASK) >> TX_CK_SHIFT] : '-',
862 *(h++) = (be->options & PR_O_COOK_ANY) ? sess_set_cookie[(txn->flags & TX_SCK_MASK) >> TX_SCK_SHIFT] : '-';
863 *(h++) = '\"';
864
865 w = snprintf(h, sizeof(tmpline) - (h - tmpline),
866 " %d %d %d %d %d %ld %ld",
867 actconn, fe->feconn, be->beconn, s->srv ? s->srv->cur_sess : 0,
868 (s->conn_retries > 0) ? (be->conn_retries - s->conn_retries) : be->conn_retries,
869 s->logs.srv_queue_size, s->logs.prx_queue_size);
870
871 if (w < 0 || w >= sizeof(tmpline) - (h - tmpline))
872 goto trunc;
873 h += w;
874
875 if (txn->cli_cookie) {
876 w = strlen(txn->cli_cookie);
877 if (h >= tmpline + sizeof(tmpline) - 4 - w)
878 goto trunc;
879 *(h++) = ' ';
880 *(h++) = '\"';
881 memcpy(h, txn->cli_cookie, w);
882 h += w;
883 *(h++) = '\"';
884 } else {
885 if (h >= tmpline + sizeof(tmpline) - 5)
886 goto trunc;
887 memcpy(h, " \"-\"", 4);
888 h += 4;
889 }
890
891 if (txn->srv_cookie) {
892 w = strlen(txn->srv_cookie);
893 if (h >= tmpline + sizeof(tmpline) - 4 - w)
894 goto trunc;
895 *(h++) = ' ';
896 *(h++) = '\"';
897 memcpy(h, txn->srv_cookie, w);
898 h += w;
899 *(h++) = '\"';
900 } else {
901 if (h >= tmpline + sizeof(tmpline) - 5)
902 goto trunc;
903 memcpy(h, " \"-\"", 4);
904 h += 4;
905 }
906
907 if ((fe->to_log & LW_REQHDR) && txn->req.cap) {
908 for (hdr = 0; hdr < fe->nb_req_cap; hdr++) {
909 if (h >= sizeof (tmpline) + tmpline - 4)
910 goto trunc;
911 *(h++) = ' ';
912 *(h++) = '\"';
913 h = encode_string(h, tmpline + sizeof(tmpline) - 2,
914 '#', hdr_encode_map, txn->req.cap[hdr]);
915 *(h++) = '\"';
916 }
917 }
918
919 if ((fe->to_log & LW_RSPHDR) && txn->rsp.cap) {
920 for (hdr = 0; hdr < fe->nb_rsp_cap; hdr++) {
921 if (h >= sizeof (tmpline) + tmpline - 4)
922 goto trunc;
923 *(h++) = ' ';
924 *(h++) = '\"';
925 h = encode_string(h, tmpline + sizeof(tmpline) - 2,
926 '#', hdr_encode_map, txn->rsp.cap[hdr]);
927 *(h++) = '\"';
928 }
929 }
930
931trunc:
932 *h = '\0';
933
934 level = LOG_INFO;
935 if (err && (fe->options2 & PR_O2_LOGERRORS))
936 level = LOG_ERR;
937
938 send_log(prx_log, level, "%s\n", tmpline);
939
940 s->logs.logwait = 0;
941}
942
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]943/*
944 * send a log for the session when we have enough info about it.
945 * Will not log if the frontend has no log defined.
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]946 */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100[diff] [blame]947void http_sess_log(struct session *s)
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]948{
949 char pn[INET6_ADDRSTRLEN + strlen(":65535")];
950 struct proxy *fe = s->fe;
951 struct proxy *be = s->be;
952 struct proxy *prx_log;
953 struct http_txn *txn = &s->txn;
Willy Tarreauc9bd0cc2009-05-10 11:57:02 +0200[diff] [blame]954 int tolog, level, err;
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]955 char *uri, *h;
956 char *svid;
Willy Tarreaufe944602007-10-25 10:34:16 +0200[diff] [blame]957 struct tm tm;
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]958 static char tmpline[MAX_SYSLOG_LEN];
Willy Tarreau70089872008-06-13 21:12:51 +0200[diff] [blame]959 int t_request;
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]960 int hdr;
961
Willy Tarreauc9bd0cc2009-05-10 11:57:02 +0200[diff] [blame]962 /* if we don't want to log normal traffic, return now */
963 err = (s->flags & (SN_ERR_MASK | SN_REDISP)) ||
964 (s->conn_retries != be->conn_retries) ||
965 txn->status >= 500;
966 if (!err && (fe->options2 & PR_O2_NOLOGNORM))
967 return;
968
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]969 if (fe->logfac1 < 0 && fe->logfac2 < 0)
970 return;
971 prx_log = fe;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]972
Emeric Brun3a058f32009-06-30 18:26:00 +0200[diff] [blame]973 if (prx_log->options2 & PR_O2_CLFLOG)
974 return http_sess_clflog(s);
975
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]976 if (s->cli_addr.ss_family == AF_INET)
977 inet_ntop(AF_INET,
978 (const void *)&((struct sockaddr_in *)&s->cli_addr)->sin_addr,
979 pn, sizeof(pn));
980 else
981 inet_ntop(AF_INET6,
982 (const void *)&((struct sockaddr_in6 *)(&s->cli_addr))->sin6_addr,
983 pn, sizeof(pn));
984
Willy Tarreaub7f694f2008-06-22 17:18:02 +0200[diff] [blame]985 get_localtime(s->logs.accept_date.tv_sec, &tm);
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]986
987 /* FIXME: let's limit ourselves to frontend logging for now. */
988 tolog = fe->to_log;
989
990 h = tmpline;
991 if (fe->to_log & LW_REQHDR &&
992 txn->req.cap &&
993 (h < tmpline + sizeof(tmpline) - 10)) {
994 *(h++) = ' ';
995 *(h++) = '{';
996 for (hdr = 0; hdr < fe->nb_req_cap; hdr++) {
997 if (hdr)
998 *(h++) = '|';
999 if (txn->req.cap[hdr] != NULL)
1000 h = encode_string(h, tmpline + sizeof(tmpline) - 7,
1001 '#', hdr_encode_map, txn->req.cap[hdr]);
1002 }
1003 *(h++) = '}';
1004 }
1005
1006 if (fe->to_log & LW_RSPHDR &&
1007 txn->rsp.cap &&
1008 (h < tmpline + sizeof(tmpline) - 7)) {
1009 *(h++) = ' ';
1010 *(h++) = '{';
1011 for (hdr = 0; hdr < fe->nb_rsp_cap; hdr++) {
1012 if (hdr)
1013 *(h++) = '|';
1014 if (txn->rsp.cap[hdr] != NULL)
1015 h = encode_string(h, tmpline + sizeof(tmpline) - 4,
1016 '#', hdr_encode_map, txn->rsp.cap[hdr]);
1017 }
1018 *(h++) = '}';
1019 }
1020
1021 if (h < tmpline + sizeof(tmpline) - 4) {
1022 *(h++) = ' ';
1023 *(h++) = '"';
1024 uri = txn->uri ? txn->uri : "<BADREQ>";
1025 h = encode_string(h, tmpline + sizeof(tmpline) - 1,
1026 '#', url_encode_map, uri);
1027 *(h++) = '"';
1028 }
1029 *h = '\0';
1030
1031 svid = (tolog & LW_SVID) ?
1032 (s->data_source != DATA_SRC_STATS) ?
1033 (s->srv != NULL) ? s->srv->id : "<NOSRV>" : "<STATS>" : "-";
1034
Willy Tarreau70089872008-06-13 21:12:51 +0200[diff] [blame]1035 t_request = -1;
1036 if (tv_isge(&s->logs.tv_request, &s->logs.tv_accept))
1037 t_request = tv_ms_elapsed(&s->logs.tv_accept, &s->logs.tv_request);
1038
Willy Tarreauc9bd0cc2009-05-10 11:57:02 +0200[diff] [blame]1039 level = LOG_INFO;
1040 if (err && (fe->options2 & PR_O2_LOGERRORS))
1041 level = LOG_ERR;
1042
1043 send_log(prx_log, level,
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]1044 "%s:%d [%02d/%s/%04d:%02d:%02d:%02d.%03d]"
Willy Tarreau1772ece2009-04-03 14:49:12 +0200[diff] [blame]1045 " %s %s/%s %d/%ld/%ld/%ld/%s%ld %d %s%lld"
1046 " %s %s %c%c%c%c %d/%d/%d/%d/%s%u %ld/%ld%s\n",
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]1047 pn,
1048 (s->cli_addr.ss_family == AF_INET) ?
1049 ntohs(((struct sockaddr_in *)&s->cli_addr)->sin_port) :
1050 ntohs(((struct sockaddr_in6 *)&s->cli_addr)->sin6_port),
Willy Tarreaufe944602007-10-25 10:34:16 +0200[diff] [blame]1051 tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
Willy Tarreau1772ece2009-04-03 14:49:12 +0200[diff] [blame]1052 tm.tm_hour, tm.tm_min, tm.tm_sec, (int)s->logs.accept_date.tv_usec/1000,
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]1053 fe->id, be->id, svid,
Willy Tarreau70089872008-06-13 21:12:51 +0200[diff] [blame]1054 t_request,
1055 (s->logs.t_queue >= 0) ? s->logs.t_queue - t_request : -1,
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]1056 (s->logs.t_connect >= 0) ? s->logs.t_connect - s->logs.t_queue : -1,
1057 (s->logs.t_data >= 0) ? s->logs.t_data - s->logs.t_connect : -1,
1058 (tolog & LW_BYTES) ? "" : "+", s->logs.t_close,
1059 txn->status,
Willy Tarreau8b3977f2008-01-18 11:16:32 +0100[diff] [blame]1060 (tolog & LW_BYTES) ? "" : "+", s->logs.bytes_out,
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]1061 txn->cli_cookie ? txn->cli_cookie : "-",
1062 txn->srv_cookie ? txn->srv_cookie : "-",
1063 sess_term_cond[(s->flags & SN_ERR_MASK) >> SN_ERR_SHIFT],
1064 sess_fin_state[(s->flags & SN_FINST_MASK) >> SN_FINST_SHIFT],
1065 (be->options & PR_O_COOK_ANY) ? sess_cookie[(txn->flags & TX_CK_MASK) >> TX_CK_SHIFT] : '-',
1066 (be->options & PR_O_COOK_ANY) ? sess_set_cookie[(txn->flags & TX_SCK_MASK) >> TX_SCK_SHIFT] : '-',
1067 actconn, fe->feconn, be->beconn, s->srv ? s->srv->cur_sess : 0,
Krzysztof Piotr Oledzki25b501a2008-01-06 16:36:16 +0100[diff] [blame]1068 (s->flags & SN_REDISP)?"+":"",
1069 (s->conn_retries>0)?(be->conn_retries - s->conn_retries):be->conn_retries,
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]1070 s->logs.srv_queue_size, s->logs.prx_queue_size, tmpline);
1071
1072 s->logs.logwait = 0;
1073}
1074
Willy Tarreau117f59e2007-03-04 18:17:17 +0100[diff] [blame]1075
1076/*
1077 * Capture headers from message starting at <som> according to header list
1078 * <cap_hdr>, and fill the <idx> structure appropriately.
1079 */
1080void capture_headers(char *som, struct hdr_idx *idx,
1081 char **cap, struct cap_hdr *cap_hdr)
1082{
1083 char *eol, *sol, *col, *sov;
1084 int cur_idx;
1085 struct cap_hdr *h;
1086 int len;
1087
1088 sol = som + hdr_idx_first_pos(idx);
1089 cur_idx = hdr_idx_first_idx(idx);
1090
1091 while (cur_idx) {
1092 eol = sol + idx->v[cur_idx].len;
1093
1094 col = sol;
1095 while (col < eol && *col != ':')
1096 col++;
1097
1098 sov = col + 1;
1099 while (sov < eol && http_is_lws[(unsigned char)*sov])
1100 sov++;
1101
1102 for (h = cap_hdr; h; h = h->next) {
1103 if ((h->namelen == col - sol) &&
1104 (strncasecmp(sol, h->name, h->namelen) == 0)) {
1105 if (cap[h->index] == NULL)
1106 cap[h->index] =
Willy Tarreaucf7f3202007-05-13 22:46:04 +0200[diff] [blame]1107 pool_alloc2(h->pool);
Willy Tarreau117f59e2007-03-04 18:17:17 +0100[diff] [blame]1108
1109 if (cap[h->index] == NULL) {
1110 Alert("HTTP capture : out of memory.\n");
1111 continue;
1112 }
1113
1114 len = eol - sov;
1115 if (len > h->len)
1116 len = h->len;
1117
1118 memcpy(cap[h->index], sov, len);
1119 cap[h->index][len]=0;
1120 }
1121 }
1122 sol = eol + idx->v[cur_idx].cr + 1;
1123 cur_idx = idx->v[cur_idx].next;
1124 }
1125}
1126
1127
Willy Tarreau42250582007-04-01 01:30:43 +0200[diff] [blame]1128/* either we find an LF at <ptr> or we jump to <bad>.
1129 */
1130#define EXPECT_LF_HERE(ptr, bad) do { if (unlikely(*(ptr) != '\n')) goto bad; } while (0)
1131
1132/* plays with variables <ptr>, <end> and <state>. Jumps to <good> if OK,
1133 * otherwise to <http_msg_ood> with <state> set to <st>.
1134 */
1135#define EAT_AND_JUMP_OR_RETURN(good, st) do { \
1136 ptr++; \
1137 if (likely(ptr < end)) \
1138 goto good; \
1139 else { \
1140 state = (st); \
1141 goto http_msg_ood; \
1142 } \
1143 } while (0)
1144
1145
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]1146/*
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]1147 * This function parses a status line between <ptr> and <end>, starting with
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1148 * parser state <state>. Only states HTTP_MSG_RPVER, HTTP_MSG_RPVER_SP,
1149 * HTTP_MSG_RPCODE, HTTP_MSG_RPCODE_SP and HTTP_MSG_RPREASON are handled. Others
1150 * will give undefined results.
1151 * Note that it is upon the caller's responsibility to ensure that ptr < end,
1152 * and that msg->sol points to the beginning of the response.
1153 * If a complete line is found (which implies that at least one CR or LF is
1154 * found before <end>, the updated <ptr> is returned, otherwise NULL is
1155 * returned indicating an incomplete line (which does not mean that parts have
1156 * not been updated). In the incomplete case, if <ret_ptr> or <ret_state> are
1157 * non-NULL, they are fed with the new <ptr> and <state> values to be passed
1158 * upon next call.
1159 *
Willy Tarreau9cdde232007-05-02 20:58:19 +0200[diff] [blame]1160 * This function was intentionally designed to be called from
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1161 * http_msg_analyzer() with the lowest overhead. It should integrate perfectly
1162 * within its state machine and use the same macros, hence the need for same
Willy Tarreau9cdde232007-05-02 20:58:19 +0200[diff] [blame]1163 * labels and variable names. Note that msg->sol is left unchanged.
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1164 */
Willy Tarreaue69eada2008-01-27 00:34:10 +0100[diff] [blame]1165const char *http_parse_stsline(struct http_msg *msg, const char *msg_buf,
1166 unsigned int state, const char *ptr, const char *end,
1167 char **ret_ptr, unsigned int *ret_state)
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1168{
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1169 switch (state) {
1170 http_msg_rpver:
1171 case HTTP_MSG_RPVER:
Willy Tarreau4b89ad42007-03-04 18:13:58 +0100[diff] [blame]1172 if (likely(HTTP_IS_VER_TOKEN(*ptr)))
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1173 EAT_AND_JUMP_OR_RETURN(http_msg_rpver, HTTP_MSG_RPVER);
1174
1175 if (likely(HTTP_IS_SPHT(*ptr))) {
Willy Tarreaub326fcc2007-03-03 13:54:32 +0100[diff] [blame]1176 msg->sl.st.v_l = (ptr - msg_buf) - msg->som;
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1177 EAT_AND_JUMP_OR_RETURN(http_msg_rpver_sp, HTTP_MSG_RPVER_SP);
1178 }
Willy Tarreau7552c032009-03-01 11:10:40 +0100[diff] [blame]1179 state = HTTP_MSG_ERROR;
1180 break;
1181
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1182 http_msg_rpver_sp:
1183 case HTTP_MSG_RPVER_SP:
1184 if (likely(!HTTP_IS_LWS(*ptr))) {
1185 msg->sl.st.c = ptr - msg_buf;
1186 goto http_msg_rpcode;
1187 }
1188 if (likely(HTTP_IS_SPHT(*ptr)))
1189 EAT_AND_JUMP_OR_RETURN(http_msg_rpver_sp, HTTP_MSG_RPVER_SP);
1190 /* so it's a CR/LF, this is invalid */
Willy Tarreau7552c032009-03-01 11:10:40 +0100[diff] [blame]1191 state = HTTP_MSG_ERROR;
1192 break;
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1193
1194 http_msg_rpcode:
1195 case HTTP_MSG_RPCODE:
1196 if (likely(!HTTP_IS_LWS(*ptr)))
1197 EAT_AND_JUMP_OR_RETURN(http_msg_rpcode, HTTP_MSG_RPCODE);
1198
1199 if (likely(HTTP_IS_SPHT(*ptr))) {
1200 msg->sl.st.c_l = (ptr - msg_buf) - msg->sl.st.c;
1201 EAT_AND_JUMP_OR_RETURN(http_msg_rpcode_sp, HTTP_MSG_RPCODE_SP);
1202 }
1203
1204 /* so it's a CR/LF, so there is no reason phrase */
1205 msg->sl.st.c_l = (ptr - msg_buf) - msg->sl.st.c;
1206 http_msg_rsp_reason:
1207 /* FIXME: should we support HTTP responses without any reason phrase ? */
1208 msg->sl.st.r = ptr - msg_buf;
1209 msg->sl.st.r_l = 0;
1210 goto http_msg_rpline_eol;
1211
1212 http_msg_rpcode_sp:
1213 case HTTP_MSG_RPCODE_SP:
1214 if (likely(!HTTP_IS_LWS(*ptr))) {
1215 msg->sl.st.r = ptr - msg_buf;
1216 goto http_msg_rpreason;
1217 }
1218 if (likely(HTTP_IS_SPHT(*ptr)))
1219 EAT_AND_JUMP_OR_RETURN(http_msg_rpcode_sp, HTTP_MSG_RPCODE_SP);
1220 /* so it's a CR/LF, so there is no reason phrase */
1221 goto http_msg_rsp_reason;
1222
1223 http_msg_rpreason:
1224 case HTTP_MSG_RPREASON:
1225 if (likely(!HTTP_IS_CRLF(*ptr)))
1226 EAT_AND_JUMP_OR_RETURN(http_msg_rpreason, HTTP_MSG_RPREASON);
1227 msg->sl.st.r_l = (ptr - msg_buf) - msg->sl.st.r;
1228 http_msg_rpline_eol:
1229 /* We have seen the end of line. Note that we do not
1230 * necessarily have the \n yet, but at least we know that we
1231 * have EITHER \r OR \n, otherwise the response would not be
1232 * complete. We can then record the response length and return
1233 * to the caller which will be able to register it.
1234 */
1235 msg->sl.st.l = ptr - msg->sol;
1236 return ptr;
1237
1238#ifdef DEBUG_FULL
1239 default:
1240 fprintf(stderr, "FIXME !!!! impossible state at %s:%d = %d\n", __FILE__, __LINE__, state);
1241 exit(1);
1242#endif
1243 }
1244
1245 http_msg_ood:
Willy Tarreau7552c032009-03-01 11:10:40 +0100[diff] [blame]1246 /* out of valid data */
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1247 if (ret_state)
1248 *ret_state = state;
1249 if (ret_ptr)
1250 *ret_ptr = (char *)ptr;
1251 return NULL;
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1252}
1253
1254
1255/*
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1256 * This function parses a request line between <ptr> and <end>, starting with
1257 * parser state <state>. Only states HTTP_MSG_RQMETH, HTTP_MSG_RQMETH_SP,
1258 * HTTP_MSG_RQURI, HTTP_MSG_RQURI_SP and HTTP_MSG_RQVER are handled. Others
1259 * will give undefined results.
1260 * Note that it is upon the caller's responsibility to ensure that ptr < end,
1261 * and that msg->sol points to the beginning of the request.
1262 * If a complete line is found (which implies that at least one CR or LF is
1263 * found before <end>, the updated <ptr> is returned, otherwise NULL is
1264 * returned indicating an incomplete line (which does not mean that parts have
1265 * not been updated). In the incomplete case, if <ret_ptr> or <ret_state> are
1266 * non-NULL, they are fed with the new <ptr> and <state> values to be passed
1267 * upon next call.
1268 *
Willy Tarreau9cdde232007-05-02 20:58:19 +0200[diff] [blame]1269 * This function was intentionally designed to be called from
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1270 * http_msg_analyzer() with the lowest overhead. It should integrate perfectly
1271 * within its state machine and use the same macros, hence the need for same
Willy Tarreau9cdde232007-05-02 20:58:19 +0200[diff] [blame]1272 * labels and variable names. Note that msg->sol is left unchanged.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]1273 */
Willy Tarreaue69eada2008-01-27 00:34:10 +0100[diff] [blame]1274const char *http_parse_reqline(struct http_msg *msg, const char *msg_buf,
1275 unsigned int state, const char *ptr, const char *end,
1276 char **ret_ptr, unsigned int *ret_state)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]1277{
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1278 switch (state) {
1279 http_msg_rqmeth:
1280 case HTTP_MSG_RQMETH:
1281 if (likely(HTTP_IS_TOKEN(*ptr)))
1282 EAT_AND_JUMP_OR_RETURN(http_msg_rqmeth, HTTP_MSG_RQMETH);
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1283
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1284 if (likely(HTTP_IS_SPHT(*ptr))) {
Willy Tarreaub326fcc2007-03-03 13:54:32 +0100[diff] [blame]1285 msg->sl.rq.m_l = (ptr - msg_buf) - msg->som;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1286 EAT_AND_JUMP_OR_RETURN(http_msg_rqmeth_sp, HTTP_MSG_RQMETH_SP);
1287 }
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1288
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1289 if (likely(HTTP_IS_CRLF(*ptr))) {
1290 /* HTTP 0.9 request */
Willy Tarreaub326fcc2007-03-03 13:54:32 +0100[diff] [blame]1291 msg->sl.rq.m_l = (ptr - msg_buf) - msg->som;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1292 http_msg_req09_uri:
1293 msg->sl.rq.u = ptr - msg_buf;
1294 http_msg_req09_uri_e:
1295 msg->sl.rq.u_l = (ptr - msg_buf) - msg->sl.rq.u;
1296 http_msg_req09_ver:
1297 msg->sl.rq.v = ptr - msg_buf;
1298 msg->sl.rq.v_l = 0;
1299 goto http_msg_rqline_eol;
1300 }
Willy Tarreau7552c032009-03-01 11:10:40 +0100[diff] [blame]1301 state = HTTP_MSG_ERROR;
1302 break;
1303
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1304 http_msg_rqmeth_sp:
1305 case HTTP_MSG_RQMETH_SP:
1306 if (likely(!HTTP_IS_LWS(*ptr))) {
1307 msg->sl.rq.u = ptr - msg_buf;
1308 goto http_msg_rquri;
1309 }
1310 if (likely(HTTP_IS_SPHT(*ptr)))
1311 EAT_AND_JUMP_OR_RETURN(http_msg_rqmeth_sp, HTTP_MSG_RQMETH_SP);
1312 /* so it's a CR/LF, meaning an HTTP 0.9 request */
1313 goto http_msg_req09_uri;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1314
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1315 http_msg_rquri:
1316 case HTTP_MSG_RQURI:
1317 if (likely(!HTTP_IS_LWS(*ptr)))
1318 EAT_AND_JUMP_OR_RETURN(http_msg_rquri, HTTP_MSG_RQURI);
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1319
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1320 if (likely(HTTP_IS_SPHT(*ptr))) {
1321 msg->sl.rq.u_l = (ptr - msg_buf) - msg->sl.rq.u;
1322 EAT_AND_JUMP_OR_RETURN(http_msg_rquri_sp, HTTP_MSG_RQURI_SP);
1323 }
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1324
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1325 /* so it's a CR/LF, meaning an HTTP 0.9 request */
1326 goto http_msg_req09_uri_e;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1327
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1328 http_msg_rquri_sp:
1329 case HTTP_MSG_RQURI_SP:
1330 if (likely(!HTTP_IS_LWS(*ptr))) {
1331 msg->sl.rq.v = ptr - msg_buf;
1332 goto http_msg_rqver;
1333 }
1334 if (likely(HTTP_IS_SPHT(*ptr)))
1335 EAT_AND_JUMP_OR_RETURN(http_msg_rquri_sp, HTTP_MSG_RQURI_SP);
1336 /* so it's a CR/LF, meaning an HTTP 0.9 request */
1337 goto http_msg_req09_ver;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1338
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1339 http_msg_rqver:
1340 case HTTP_MSG_RQVER:
Willy Tarreau4b89ad42007-03-04 18:13:58 +0100[diff] [blame]1341 if (likely(HTTP_IS_VER_TOKEN(*ptr)))
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1342 EAT_AND_JUMP_OR_RETURN(http_msg_rqver, HTTP_MSG_RQVER);
Willy Tarreau4b89ad42007-03-04 18:13:58 +0100[diff] [blame]1343
1344 if (likely(HTTP_IS_CRLF(*ptr))) {
1345 msg->sl.rq.v_l = (ptr - msg_buf) - msg->sl.rq.v;
1346 http_msg_rqline_eol:
1347 /* We have seen the end of line. Note that we do not
1348 * necessarily have the \n yet, but at least we know that we
1349 * have EITHER \r OR \n, otherwise the request would not be
1350 * complete. We can then record the request length and return
1351 * to the caller which will be able to register it.
1352 */
1353 msg->sl.rq.l = ptr - msg->sol;
1354 return ptr;
1355 }
1356
1357 /* neither an HTTP_VER token nor a CRLF */
Willy Tarreau7552c032009-03-01 11:10:40 +0100[diff] [blame]1358 state = HTTP_MSG_ERROR;
1359 break;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1360
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1361#ifdef DEBUG_FULL
1362 default:
1363 fprintf(stderr, "FIXME !!!! impossible state at %s:%d = %d\n", __FILE__, __LINE__, state);
1364 exit(1);
1365#endif
1366 }
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1367
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1368 http_msg_ood:
Willy Tarreau7552c032009-03-01 11:10:40 +0100[diff] [blame]1369 /* out of valid data */
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1370 if (ret_state)
1371 *ret_state = state;
1372 if (ret_ptr)
1373 *ret_ptr = (char *)ptr;
1374 return NULL;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1375}
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1376
1377
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1378/*
1379 * This function parses an HTTP message, either a request or a response,
Willy Tarreaub326fcc2007-03-03 13:54:32 +0100[diff] [blame]1380 * depending on the initial msg->msg_state. It can be preempted everywhere
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1381 * when data are missing and recalled at the exact same location with no
1382 * information loss. The header index is re-initialized when switching from
Willy Tarreau9cdde232007-05-02 20:58:19 +0200[diff] [blame]1383 * MSG_R[PQ]BEFORE to MSG_RPVER|MSG_RQMETH. It modifies msg->sol among other
1384 * fields.
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1385 */
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1386void http_msg_analyzer(struct buffer *buf, struct http_msg *msg, struct hdr_idx *idx)
1387{
Willy Tarreaue69eada2008-01-27 00:34:10 +0100[diff] [blame]1388 unsigned int state; /* updated only when leaving the FSM */
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1389 register char *ptr, *end; /* request pointers, to avoid dereferences */
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1390
Willy Tarreaub326fcc2007-03-03 13:54:32 +0100[diff] [blame]1391 state = msg->msg_state;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1392 ptr = buf->lr;
1393 end = buf->r;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1394
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1395 if (unlikely(ptr >= end))
1396 goto http_msg_ood;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1397
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1398 switch (state) {
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1399 /*
1400 * First, states that are specific to the response only.
1401 * We check them first so that request and headers are
1402 * closer to each other (accessed more often).
1403 */
1404 http_msg_rpbefore:
1405 case HTTP_MSG_RPBEFORE:
1406 if (likely(HTTP_IS_TOKEN(*ptr))) {
Willy Tarreau1d3bcce2009-12-27 15:50:06 +0100[diff] [blame]1407 if (likely(ptr != buf->data + msg->som)) {
1408 /* Remove empty leading lines, as recommended by RFC2616. */
1409 buffer_ignore(buf, ptr - buf->data - msg->som);
1410 msg->som = ptr - buf->data;
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1411 }
Willy Tarreau816b9792009-09-15 21:25:21 +0200[diff] [blame]1412 msg->sol = ptr;
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1413 hdr_idx_init(idx);
1414 state = HTTP_MSG_RPVER;
1415 goto http_msg_rpver;
1416 }
1417
1418 if (unlikely(!HTTP_IS_CRLF(*ptr)))
1419 goto http_msg_invalid;
1420
1421 if (unlikely(*ptr == '\n'))
1422 EAT_AND_JUMP_OR_RETURN(http_msg_rpbefore, HTTP_MSG_RPBEFORE);
1423 EAT_AND_JUMP_OR_RETURN(http_msg_rpbefore_cr, HTTP_MSG_RPBEFORE_CR);
1424 /* stop here */
1425
1426 http_msg_rpbefore_cr:
1427 case HTTP_MSG_RPBEFORE_CR:
1428 EXPECT_LF_HERE(ptr, http_msg_invalid);
1429 EAT_AND_JUMP_OR_RETURN(http_msg_rpbefore, HTTP_MSG_RPBEFORE);
1430 /* stop here */
1431
1432 http_msg_rpver:
1433 case HTTP_MSG_RPVER:
1434 case HTTP_MSG_RPVER_SP:
1435 case HTTP_MSG_RPCODE:
1436 case HTTP_MSG_RPCODE_SP:
1437 case HTTP_MSG_RPREASON:
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]1438 ptr = (char *)http_parse_stsline(msg, buf->data, state, ptr, end,
Willy Tarreaub326fcc2007-03-03 13:54:32 +0100[diff] [blame]1439 &buf->lr, &msg->msg_state);
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1440 if (unlikely(!ptr))
1441 return;
1442
1443 /* we have a full response and we know that we have either a CR
1444 * or an LF at <ptr>.
1445 */
Willy Tarreaub326fcc2007-03-03 13:54:32 +0100[diff] [blame]1446 //fprintf(stderr,"som=%d rq.l=%d *ptr=0x%02x\n", msg->som, msg->sl.st.l, *ptr);
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1447 hdr_idx_set_start(idx, msg->sl.st.l, *ptr == '\r');
1448
1449 msg->sol = ptr;
1450 if (likely(*ptr == '\r'))
1451 EAT_AND_JUMP_OR_RETURN(http_msg_rpline_end, HTTP_MSG_RPLINE_END);
1452 goto http_msg_rpline_end;
1453
1454 http_msg_rpline_end:
1455 case HTTP_MSG_RPLINE_END:
1456 /* msg->sol must point to the first of CR or LF. */
1457 EXPECT_LF_HERE(ptr, http_msg_invalid);
1458 EAT_AND_JUMP_OR_RETURN(http_msg_hdr_first, HTTP_MSG_HDR_FIRST);
1459 /* stop here */
1460
1461 /*
1462 * Second, states that are specific to the request only
1463 */
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1464 http_msg_rqbefore:
1465 case HTTP_MSG_RQBEFORE:
1466 if (likely(HTTP_IS_TOKEN(*ptr))) {
Willy Tarreau1d3bcce2009-12-27 15:50:06 +0100[diff] [blame]1467 if (likely(ptr != buf->data + msg->som)) {
1468 /* Remove empty leading lines, as recommended by RFC2616. */
1469 buffer_ignore(buf, ptr - buf->data - msg->som);
Willy Tarreaub326fcc2007-03-03 13:54:32 +0100[diff] [blame]1470 msg->som = ptr - buf->data;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1471 }
Willy Tarreau1d3bcce2009-12-27 15:50:06 +0100[diff] [blame]1472 msg->sol = ptr;
Willy Tarreauf0d058e2007-01-25 12:03:42 +0100[diff] [blame]1473 /* we will need this when keep-alive will be supported
1474 hdr_idx_init(idx);
1475 */
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1476 state = HTTP_MSG_RQMETH;
1477 goto http_msg_rqmeth;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1478 }
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1479
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1480 if (unlikely(!HTTP_IS_CRLF(*ptr)))
1481 goto http_msg_invalid;
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1482
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1483 if (unlikely(*ptr == '\n'))
1484 EAT_AND_JUMP_OR_RETURN(http_msg_rqbefore, HTTP_MSG_RQBEFORE);
1485 EAT_AND_JUMP_OR_RETURN(http_msg_rqbefore_cr, HTTP_MSG_RQBEFORE_CR);
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1486 /* stop here */
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1487
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1488 http_msg_rqbefore_cr:
1489 case HTTP_MSG_RQBEFORE_CR:
1490 EXPECT_LF_HERE(ptr, http_msg_invalid);
1491 EAT_AND_JUMP_OR_RETURN(http_msg_rqbefore, HTTP_MSG_RQBEFORE);
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1492 /* stop here */
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1493
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1494 http_msg_rqmeth:
1495 case HTTP_MSG_RQMETH:
1496 case HTTP_MSG_RQMETH_SP:
1497 case HTTP_MSG_RQURI:
1498 case HTTP_MSG_RQURI_SP:
1499 case HTTP_MSG_RQVER:
1500 ptr = (char *)http_parse_reqline(msg, buf->data, state, ptr, end,
Willy Tarreaub326fcc2007-03-03 13:54:32 +0100[diff] [blame]1501 &buf->lr, &msg->msg_state);
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1502 if (unlikely(!ptr))
1503 return;
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1504
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1505 /* we have a full request and we know that we have either a CR
1506 * or an LF at <ptr>.
1507 */
Willy Tarreaub326fcc2007-03-03 13:54:32 +0100[diff] [blame]1508 //fprintf(stderr,"som=%d rq.l=%d *ptr=0x%02x\n", msg->som, msg->sl.rq.l, *ptr);
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1509 hdr_idx_set_start(idx, msg->sl.rq.l, *ptr == '\r');
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1510
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1511 msg->sol = ptr;
1512 if (likely(*ptr == '\r'))
1513 EAT_AND_JUMP_OR_RETURN(http_msg_rqline_end, HTTP_MSG_RQLINE_END);
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1514 goto http_msg_rqline_end;
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1515
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1516 http_msg_rqline_end:
1517 case HTTP_MSG_RQLINE_END:
1518 /* check for HTTP/0.9 request : no version information available.
1519 * msg->sol must point to the first of CR or LF.
1520 */
1521 if (unlikely(msg->sl.rq.v_l == 0))
1522 goto http_msg_last_lf;
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1523
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1524 EXPECT_LF_HERE(ptr, http_msg_invalid);
1525 EAT_AND_JUMP_OR_RETURN(http_msg_hdr_first, HTTP_MSG_HDR_FIRST);
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1526 /* stop here */
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1527
Willy Tarreau8973c702007-01-21 23:58:29 +0100[diff] [blame]1528 /*
1529 * Common states below
1530 */
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1531 http_msg_hdr_first:
1532 case HTTP_MSG_HDR_FIRST:
1533 msg->sol = ptr;
1534 if (likely(!HTTP_IS_CRLF(*ptr))) {
1535 goto http_msg_hdr_name;
1536 }
1537
1538 if (likely(*ptr == '\r'))
1539 EAT_AND_JUMP_OR_RETURN(http_msg_last_lf, HTTP_MSG_LAST_LF);
1540 goto http_msg_last_lf;
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1541
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1542 http_msg_hdr_name:
1543 case HTTP_MSG_HDR_NAME:
1544 /* assumes msg->sol points to the first char */
1545 if (likely(HTTP_IS_TOKEN(*ptr)))
1546 EAT_AND_JUMP_OR_RETURN(http_msg_hdr_name, HTTP_MSG_HDR_NAME);
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1547
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1548 if (likely(*ptr == ':')) {
1549 msg->col = ptr - buf->data;
1550 EAT_AND_JUMP_OR_RETURN(http_msg_hdr_l1_sp, HTTP_MSG_HDR_L1_SP);
1551 }
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1552
Willy Tarreau32a4ec02009-04-02 11:35:18 +0200[diff] [blame]1553 if (likely(msg->err_pos < -1) || *ptr == '\n')
1554 goto http_msg_invalid;
1555
1556 if (msg->err_pos == -1) /* capture error pointer */
1557 msg->err_pos = ptr - buf->data; /* >= 0 now */
1558
1559 /* and we still accept this non-token character */
1560 EAT_AND_JUMP_OR_RETURN(http_msg_hdr_name, HTTP_MSG_HDR_NAME);
Willy Tarreau230fd0b2006-12-17 12:05:00 +0100[diff] [blame]1561
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1562 http_msg_hdr_l1_sp:
1563 case HTTP_MSG_HDR_L1_SP:
1564 /* assumes msg->sol points to the first char and msg->col to the colon */
1565 if (likely(HTTP_IS_SPHT(*ptr)))
1566 EAT_AND_JUMP_OR_RETURN(http_msg_hdr_l1_sp, HTTP_MSG_HDR_L1_SP);
Willy Tarreau230fd0b2006-12-17 12:05:00 +0100[diff] [blame]1567
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1568 /* header value can be basically anything except CR/LF */
1569 msg->sov = ptr - buf->data;
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1570
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1571 if (likely(!HTTP_IS_CRLF(*ptr))) {
1572 goto http_msg_hdr_val;
1573 }
1574
1575 if (likely(*ptr == '\r'))
1576 EAT_AND_JUMP_OR_RETURN(http_msg_hdr_l1_lf, HTTP_MSG_HDR_L1_LF);
1577 goto http_msg_hdr_l1_lf;
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1578
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1579 http_msg_hdr_l1_lf:
1580 case HTTP_MSG_HDR_L1_LF:
1581 EXPECT_LF_HERE(ptr, http_msg_invalid);
1582 EAT_AND_JUMP_OR_RETURN(http_msg_hdr_l1_lws, HTTP_MSG_HDR_L1_LWS);
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1583
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1584 http_msg_hdr_l1_lws:
1585 case HTTP_MSG_HDR_L1_LWS:
1586 if (likely(HTTP_IS_SPHT(*ptr))) {
1587 /* replace HT,CR,LF with spaces */
1588 for (; buf->data+msg->sov < ptr; msg->sov++)
1589 buf->data[msg->sov] = ' ';
1590 goto http_msg_hdr_l1_sp;
1591 }
Willy Tarreauaa9dce32007-03-18 23:50:16 +0100[diff] [blame]1592 /* we had a header consisting only in spaces ! */
1593 msg->eol = buf->data + msg->sov;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1594 goto http_msg_complete_header;
1595
1596 http_msg_hdr_val:
1597 case HTTP_MSG_HDR_VAL:
1598 /* assumes msg->sol points to the first char, msg->col to the
1599 * colon, and msg->sov points to the first character of the
1600 * value.
1601 */
1602 if (likely(!HTTP_IS_CRLF(*ptr)))
1603 EAT_AND_JUMP_OR_RETURN(http_msg_hdr_val, HTTP_MSG_HDR_VAL);
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1604
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1605 msg->eol = ptr;
1606 /* Note: we could also copy eol into ->eoh so that we have the
1607 * real header end in case it ends with lots of LWS, but is this
1608 * really needed ?
1609 */
1610 if (likely(*ptr == '\r'))
1611 EAT_AND_JUMP_OR_RETURN(http_msg_hdr_l2_lf, HTTP_MSG_HDR_L2_LF);
1612 goto http_msg_hdr_l2_lf;
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1613
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1614 http_msg_hdr_l2_lf:
1615 case HTTP_MSG_HDR_L2_LF:
1616 EXPECT_LF_HERE(ptr, http_msg_invalid);
1617 EAT_AND_JUMP_OR_RETURN(http_msg_hdr_l2_lws, HTTP_MSG_HDR_L2_LWS);
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1618
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1619 http_msg_hdr_l2_lws:
1620 case HTTP_MSG_HDR_L2_LWS:
1621 if (unlikely(HTTP_IS_SPHT(*ptr))) {
1622 /* LWS: replace HT,CR,LF with spaces */
1623 for (; msg->eol < ptr; msg->eol++)
1624 *msg->eol = ' ';
1625 goto http_msg_hdr_val;
1626 }
1627 http_msg_complete_header:
1628 /*
1629 * It was a new header, so the last one is finished.
1630 * Assumes msg->sol points to the first char, msg->col to the
1631 * colon, msg->sov points to the first character of the value
1632 * and msg->eol to the first CR or LF so we know how the line
1633 * ends. We insert last header into the index.
1634 */
1635 /*
1636 fprintf(stderr,"registering %-2d bytes : ", msg->eol - msg->sol);
1637 write(2, msg->sol, msg->eol-msg->sol);
1638 fprintf(stderr,"\n");
1639 */
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1640
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1641 if (unlikely(hdr_idx_add(msg->eol - msg->sol, *msg->eol == '\r',
1642 idx, idx->tail) < 0))
1643 goto http_msg_invalid;
Willy Tarreau230fd0b2006-12-17 12:05:00 +0100[diff] [blame]1644
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1645 msg->sol = ptr;
1646 if (likely(!HTTP_IS_CRLF(*ptr))) {
1647 goto http_msg_hdr_name;
1648 }
1649
1650 if (likely(*ptr == '\r'))
1651 EAT_AND_JUMP_OR_RETURN(http_msg_last_lf, HTTP_MSG_LAST_LF);
1652 goto http_msg_last_lf;
Willy Tarreau230fd0b2006-12-17 12:05:00 +0100[diff] [blame]1653
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1654 http_msg_last_lf:
1655 case HTTP_MSG_LAST_LF:
1656 /* Assumes msg->sol points to the first of either CR or LF */
1657 EXPECT_LF_HERE(ptr, http_msg_invalid);
1658 ptr++;
1659 buf->lr = ptr;
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]1660 msg->col = msg->sov = buf->lr - buf->data;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1661 msg->eoh = msg->sol - buf->data;
Willy Tarreaub326fcc2007-03-03 13:54:32 +0100[diff] [blame]1662 msg->msg_state = HTTP_MSG_BODY;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1663 return;
1664#ifdef DEBUG_FULL
1665 default:
1666 fprintf(stderr, "FIXME !!!! impossible state at %s:%d = %d\n", __FILE__, __LINE__, state);
1667 exit(1);
Willy Tarreau230fd0b2006-12-17 12:05:00 +0100[diff] [blame]1668#endif
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1669 }
1670 http_msg_ood:
1671 /* out of data */
Willy Tarreaub326fcc2007-03-03 13:54:32 +0100[diff] [blame]1672 msg->msg_state = state;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1673 buf->lr = ptr;
1674 return;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1675
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1676 http_msg_invalid:
1677 /* invalid message */
Willy Tarreaub326fcc2007-03-03 13:54:32 +0100[diff] [blame]1678 msg->msg_state = HTTP_MSG_ERROR;
Willy Tarreau7552c032009-03-01 11:10:40 +0100[diff] [blame]1679 buf->lr = ptr;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1680 return;
1681}
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100[diff] [blame]1682
Willy Tarreau2492d5b2009-07-11 00:06:00 +0200[diff] [blame]1683/* convert an HTTP/0.9 request into an HTTP/1.0 request. Returns 1 if the
1684 * conversion succeeded, 0 in case of error. If the request was already 1.X,
1685 * nothing is done and 1 is returned.
1686 */
1687static int http_upgrade_v09_to_v10(struct buffer *req, struct http_msg *msg, struct http_txn *txn)
1688{
1689 int delta;
1690 char *cur_end;
1691
1692 if (msg->sl.rq.v_l != 0)
1693 return 1;
1694
1695 msg->sol = req->data + msg->som;
1696 cur_end = msg->sol + msg->sl.rq.l;
1697 delta = 0;
1698
1699 if (msg->sl.rq.u_l == 0) {
1700 /* if no URI was set, add "/" */
1701 delta = buffer_replace2(req, cur_end, cur_end, " /", 2);
1702 cur_end += delta;
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]1703 http_msg_move_end(msg, delta);
Willy Tarreau2492d5b2009-07-11 00:06:00 +0200[diff] [blame]1704 }
1705 /* add HTTP version */
1706 delta = buffer_replace2(req, cur_end, cur_end, " HTTP/1.0\r\n", 11);
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]1707 http_msg_move_end(msg, delta);
Willy Tarreau2492d5b2009-07-11 00:06:00 +0200[diff] [blame]1708 cur_end += delta;
1709 cur_end = (char *)http_parse_reqline(msg, req->data,
1710 HTTP_MSG_RQMETH,
1711 msg->sol, cur_end + 1,
1712 NULL, NULL);
1713 if (unlikely(!cur_end))
1714 return 0;
1715
1716 /* we have a full HTTP/1.0 request now and we know that
1717 * we have either a CR or an LF at <ptr>.
1718 */
1719 hdr_idx_set_start(&txn->hdr_idx, msg->sl.rq.l, *cur_end == '\r');
1720 return 1;
1721}
1722
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]1723/* Parse the Connection: headaer of an HTTP request, and set the transaction
1724 * flag TX_REQ_CONN_CLO if a "close" mode is expected. The TX_CON_HDR_PARS flag
1725 * is also set so that we don't parse a second time. If some dangerous values
1726 * are encountered, we leave the status to indicate that the request might be
1727 * interpreted as keep-alive, but we also set the connection flags to indicate
1728 * that we WANT it to be a close, so that the header will be fixed. This
1729 * function should only be called when we know we're interested in checking
1730 * the request (not a CONNECT, and FE or BE mangles the header).
1731 */
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]1732void http_req_parse_connection_header(struct http_txn *txn)
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]1733{
1734 struct http_msg *msg = &txn->req;
1735 struct hdr_ctx ctx;
1736 int conn_cl, conn_ka;
1737
1738 if (txn->flags & TX_CON_HDR_PARS)
1739 return;
1740
1741 conn_cl = 0;
1742 conn_ka = 0;
1743 ctx.idx = 0;
1744
1745 while (http_find_header2("Connection", 10, msg->sol, &txn->hdr_idx, &ctx)) {
1746 if (ctx.vlen == 5 && strncasecmp(ctx.line + ctx.val, "close", 5) == 0)
1747 conn_cl = 1;
1748 else if (ctx.vlen == 10 && strncasecmp(ctx.line + ctx.val, "keep-alive", 10) == 0)
1749 conn_ka = 1;
1750 }
1751
1752 /* Determine if the client wishes keep-alive or close.
1753 * RFC2616 #8.1.2 and #14.10 state that HTTP/1.1 and above connections
1754 * are persistent unless "Connection: close" is explicitly specified.
1755 * RFC2616 #19.6.2 refers to RFC2068 for HTTP/1.0 persistent connections.
1756 * RFC2068 #19.7.1 states that HTTP/1.0 clients are not persistent unless
1757 * they explicitly specify "Connection: Keep-Alive", regardless of any
1758 * optional "Keep-Alive" header.
1759 * Note that if we find a request with both "Connection: close" and
1760 * "Connection: Keep-Alive", we indicate we want a close but don't have
1761 * it, so that it can be enforced later.
1762 */
1763
1764 if (txn->flags & TX_REQ_VER_11) { /* HTTP/1.1 */
1765 if (conn_cl) {
1766 txn->flags = (txn->flags & ~TX_CON_WANT_MSK) | TX_CON_WANT_CLO;
1767 if (!conn_ka)
1768 txn->flags |= TX_REQ_CONN_CLO;
1769 }
1770 } else { /* HTTP/1.0 */
1771 if (!conn_ka)
1772 txn->flags = (txn->flags & ~TX_CON_WANT_MSK) | TX_CON_WANT_CLO | TX_REQ_CONN_CLO;
1773 else if (conn_cl)
1774 txn->flags = (txn->flags & ~TX_CON_WANT_MSK) | TX_CON_WANT_CLO;
1775 }
1776 txn->flags |= TX_CON_HDR_PARS;
1777}
1778
Willy Tarreau115acb92009-12-26 13:56:06 +0100[diff] [blame]1779/* Parse the chunk size at msg->col.
1780 * Return >0 on success, 0 when some data is missing, <0 on error.
1781 */
1782int http_parse_chunk_size(struct buffer *req, struct http_msg *msg)
1783{
1784 unsigned long body = msg->col;
1785 unsigned int chunk = 0;
1786
1787 /* The chunk size is in the following form, though we are only
1788 * interested in the size and CRLF :
1789 * 1*HEXDIGIT *WSP *[ ';' extensions ] CRLF
1790 */
1791 while (1) {
1792 int c;
1793 if (body >= req->l)
1794 return 0;
1795 c = hex2i(msg->sol[body]);
1796 if (c < 0) /* not a hex digit anymore */
1797 break;
1798 body++;
1799 if (chunk & 0xF000000) /* overflow will occur */
1800 return -1;
1801 chunk = (chunk << 4) + c;
1802 }
1803
1804 while (1) {
1805 if (body >= req->l)
1806 return 0;
1807 if (!http_is_spht[(unsigned char)msg->sol[body]])
1808 break;
1809 body++;
1810 }
1811
1812 /* Up to there, we know that at least one byte is present at [body]. */
1813 switch (msg->sol[body]) {
1814 case ';': /* chunk extension, ends at next CRLF */
1815 if (++body >= req->l)
1816 return 0;
1817
1818 while (msg->sol[body] != '\r') {
1819 if (++body >= req->l)
1820 return 0;
1821 }
1822 /* we now have a CR at <body>, fall through */
1823 case '\r':
1824 if (++body >= req->l)
1825 return 0;
1826 if (msg->sol[body] != '\n')
1827 return -1;
1828 body++;
1829 break;
1830
1831 default:
1832 return -1;
1833 }
1834
1835 /* OK we found our CRLF and now <body> points to the next byte,
1836 * which may or may not be present.
1837 */
1838 msg->sov = body;
1839 msg->hdr_content_len = chunk;
1840 msg->msg_state = HTTP_MSG_DATA;
1841 return 1;
1842}
1843
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]1844
Willy Tarreaud787e662009-07-07 10:14:51 +0200[diff] [blame]1845/* This stream analyser waits for a complete HTTP request. It returns 1 if the
1846 * processing can continue on next analysers, or zero if it either needs more
1847 * data or wants to immediately abort the request (eg: timeout, error, ...). It
1848 * is tied to AN_REQ_WAIT_HTTP and may may remove itself from s->req->analysers
1849 * when it has nothing left to do, and may remove any analyser when it wants to
1850 * abort.
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1851 */
Willy Tarreau3a816292009-07-07 10:55:49 +0200[diff] [blame]1852int http_wait_for_request(struct session *s, struct buffer *req, int an_bit)
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1853{
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1854 /*
1855 * We will parse the partial (or complete) lines.
1856 * We will check the request syntax, and also join multi-line
1857 * headers. An index of all the lines will be elaborated while
1858 * parsing.
1859 *
1860 * For the parsing, we use a 28 states FSM.
1861 *
1862 * Here is the information we currently have :
Willy Tarreauf073a832009-03-01 23:21:47 +0100[diff] [blame]1863 * req->data + msg->som = beginning of request
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1864 * req->data + req->eoh = end of processed headers / start of current one
1865 * req->data + req->eol = end of current header or line (LF or CRLF)
1866 * req->lr = first non-visited byte
1867 * req->r = end of data
Willy Tarreaud787e662009-07-07 10:14:51 +0200[diff] [blame]1868 *
1869 * At end of parsing, we may perform a capture of the error (if any), and
1870 * we will set a few fields (msg->sol, txn->meth, sn->flags/SN_REDIRECTABLE).
1871 * We also check for monitor-uri, logging, HTTP/0.9 to 1.0 conversion, and
1872 * finally headers capture.
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1873 */
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1874
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1875 int cur_idx;
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]1876 int use_close_only;
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1877 struct http_txn *txn = &s->txn;
1878 struct http_msg *msg = &txn->req;
Willy Tarreau32b47f42009-10-18 20:55:02 +0200[diff] [blame]1879 struct hdr_ctx ctx;
Willy Tarreau976f1ee2006-12-17 10:06:03 +0100[diff] [blame]1880
Willy Tarreau6bf17362009-02-24 10:48:35 +0100[diff] [blame]1881 DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
1882 now_ms, __FUNCTION__,
1883 s,
1884 req,
1885 req->rex, req->wex,
1886 req->flags,
1887 req->l,
1888 req->analysers);
1889
Willy Tarreau52a0c602009-08-16 22:45:38 +0200[diff] [blame]1890 /* we're speaking HTTP here, so let's speak HTTP to the client */
1891 s->srv_error = http_return_srv_error;
1892
Willy Tarreauaec571c2009-12-27 17:18:11 +0100[diff] [blame]1893 http_parse_again:
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1894 if (likely(req->lr < req->r))
1895 http_msg_analyzer(req, msg, &txn->hdr_idx);
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1896
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1897 /* 1: we might have to print this header in debug mode */
1898 if (unlikely((global.mode & MODE_DEBUG) &&
1899 (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) &&
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]1900 (msg->msg_state >= HTTP_MSG_BODY || msg->msg_state == HTTP_MSG_ERROR))) {
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1901 char *eol, *sol;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1902
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1903 sol = req->data + msg->som;
1904 eol = sol + msg->sl.rq.l;
1905 debug_hdr("clireq", s, sol, eol);
Willy Tarreau45e73e32006-12-17 00:05:15 +0100[diff] [blame]1906
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1907 sol += hdr_idx_first_pos(&txn->hdr_idx);
1908 cur_idx = hdr_idx_first_idx(&txn->hdr_idx);
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1909
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1910 while (cur_idx) {
1911 eol = sol + txn->hdr_idx.v[cur_idx].len;
1912 debug_hdr("clihdr", s, sol, eol);
1913 sol = eol + txn->hdr_idx.v[cur_idx].cr + 1;
1914 cur_idx = txn->hdr_idx.v[cur_idx].next;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]1915 }
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1916 }
1917
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1918
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1919 /*
1920 * Now we quickly check if we have found a full valid request.
1921 * If not so, we check the FD and buffer states before leaving.
1922 * A full request is indicated by the fact that we have seen
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]1923 * the double LF/CRLF, so the state is >= HTTP_MSG_BODY. Invalid
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1924 * requests are checked first.
1925 *
1926 */
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1927
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]1928 if (unlikely(msg->msg_state < HTTP_MSG_BODY)) {
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1929 /*
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1930 * First, let's catch bad requests.
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1931 */
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1932 if (unlikely(msg->msg_state == HTTP_MSG_ERROR))
1933 goto return_bad_req;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1934
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1935 /* 1: Since we are in header mode, if there's no space
1936 * left for headers, we won't be able to free more
1937 * later, so the session will never terminate. We
1938 * must terminate it now.
1939 */
1940 if (unlikely(req->flags & BF_FULL)) {
Willy Tarreauaec571c2009-12-27 17:18:11 +0100[diff] [blame]1941 /* It is possible the analyser has stopped because of
1942 * lack of space at the end of the buffer, while the
1943 * beginning is free (skipped blanks or previous
1944 * requests vanished). In this case, we try to re-aling
1945 * the buffer, and update the few relevant pointers.
1946 * Since we're copying via the trash, it's important that
1947 * it is always as large as a buffer.
1948 */
1949 if (req->l < buffer_max_len(req)) {
1950 /* let's move what remains */
1951 int max, done;
1952 unsigned offset = req->w - req->data;
1953
1954 done = 0;
1955 while (done < req->l) {
1956 if (req->r > req->w)
1957 max = req->r - req->w;
1958 else
1959 max = req->data + req->size - req->w;
1960 memcpy(trash + done, req->w, max);
1961 done += max;
1962 req->w += max;
1963 if (req->w >= req->data + req->size)
1964 req->w -= req->size;
1965 }
1966 if (done)
1967 memcpy(req->data, trash, done);
1968 msg->eoh = msg->som = 0;
1969
1970 /* move all known pointers */
1971 req->w = req->data;
1972 req->lr -= offset; if (req->lr < req->data) req->lr += req->size;
1973 req->r -= offset; if (req->r < req->data) req->r += req->size;
1974 msg->sol -= offset; if (msg->sol < req->data) msg->sol += req->size;
1975 msg->eol -= offset; if (msg->eol < req->data) msg->eol += req->size;
1976
1977 /* adjust relative pointers */
1978 msg->col += req->size - offset; if (msg->col >= req->size) msg->col -= req->size;
1979 msg->sov += req->size - offset; if (msg->sov >= req->size) msg->sov -= req->size;
1980 msg->sl.rq.u += req->size - offset; if (msg->sl.rq.u >= req->size) msg->sl.rq.u -= req->size;
1981 msg->sl.rq.v += req->size - offset; if (msg->sl.rq.v >= req->size) msg->sl.rq.v -= req->size;
1982
1983 if (msg->err_pos >= 0) {
1984 msg->err_pos += req->size - offset;
1985 if (msg->err_pos >= req->size)
1986 msg->err_pos -= req->size;
1987 }
1988
1989 req->flags &= ~BF_FULL;
1990 goto http_parse_again;
1991 }
1992
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1993 /* FIXME: check if URI is set and return Status
1994 * 414 Request URI too long instead.
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1995 */
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1996 goto return_bad_req;
1997 }
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]1998
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]1999 /* 2: have we encountered a read error ? */
2000 else if (req->flags & BF_READ_ERROR) {
2001 /* we cannot return any message on error */
Willy Tarreau4076a152009-04-02 15:18:36 +0200[diff] [blame]2002 if (msg->err_pos >= 0)
2003 http_capture_bad_message(&s->fe->invalid_req, s, req, msg, s->fe);
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2004 msg->msg_state = HTTP_MSG_ERROR;
2005 req->analysers = 0;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]2006
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]2007 s->fe->counters.failed_req++;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]2008 if (s->listener->counters)
2009 s->listener->counters->failed_req++;
2010
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2011 if (!(s->flags & SN_ERR_MASK))
2012 s->flags |= SN_ERR_CLICL;
2013 if (!(s->flags & SN_FINST_MASK))
2014 s->flags |= SN_FINST_R;
2015 return 0;
2016 }
Willy Tarreauf9839bd2008-08-27 23:57:16 +0200[diff] [blame]2017
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2018 /* 3: has the read timeout expired ? */
2019 else if (req->flags & BF_READ_TIMEOUT || tick_is_expired(req->analyse_exp, now_ms)) {
2020 /* read timeout : give up with an error message. */
Willy Tarreau4076a152009-04-02 15:18:36 +0200[diff] [blame]2021 if (msg->err_pos >= 0)
2022 http_capture_bad_message(&s->fe->invalid_req, s, req, msg, s->fe);
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2023 txn->status = 408;
2024 stream_int_retnclose(req->prod, error_message(s, HTTP_ERR_408));
2025 msg->msg_state = HTTP_MSG_ERROR;
2026 req->analysers = 0;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]2027
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]2028 s->fe->counters.failed_req++;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]2029 if (s->listener->counters)
2030 s->listener->counters->failed_req++;
2031
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2032 if (!(s->flags & SN_ERR_MASK))
2033 s->flags |= SN_ERR_CLITO;
2034 if (!(s->flags & SN_FINST_MASK))
2035 s->flags |= SN_FINST_R;
2036 return 0;
2037 }
Willy Tarreauc65a3ba2008-08-11 23:42:50 +0200[diff] [blame]2038
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2039 /* 4: have we encountered a close ? */
2040 else if (req->flags & BF_SHUTR) {
Willy Tarreau4076a152009-04-02 15:18:36 +0200[diff] [blame]2041 if (msg->err_pos >= 0)
2042 http_capture_bad_message(&s->fe->invalid_req, s, req, msg, s->fe);
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2043 txn->status = 400;
2044 stream_int_retnclose(req->prod, error_message(s, HTTP_ERR_400));
2045 msg->msg_state = HTTP_MSG_ERROR;
2046 req->analysers = 0;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]2047
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]2048 s->fe->counters.failed_req++;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]2049 if (s->listener->counters)
2050 s->listener->counters->failed_req++;
2051
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2052 if (!(s->flags & SN_ERR_MASK))
2053 s->flags |= SN_ERR_CLICL;
2054 if (!(s->flags & SN_FINST_MASK))
2055 s->flags |= SN_FINST_R;
Willy Tarreaudafde432008-08-17 01:00:46 +0200[diff] [blame]2056 return 0;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]2057 }
2058
Willy Tarreau520d95e2009-09-19 21:04:57 +0200[diff] [blame]2059 buffer_dont_connect(req);
Willy Tarreau1b194fe2009-03-21 21:10:04 +0100[diff] [blame]2060 req->flags |= BF_READ_DONTWAIT; /* try to get back here ASAP */
2061
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2062 /* just set the request timeout once at the beginning of the request */
2063 if (!tick_isset(req->analyse_exp))
Willy Tarreaucd7afc02009-07-12 10:03:17 +0200[diff] [blame]2064 req->analyse_exp = tick_add_ifset(now_ms, s->be->timeout.httpreq);
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]2065
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2066 /* we're not ready yet */
2067 return 0;
2068 }
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]2069
Willy Tarreaud787e662009-07-07 10:14:51 +0200[diff] [blame]2070 /* OK now we have a complete HTTP request with indexed headers. Let's
2071 * complete the request parsing by setting a few fields we will need
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]2072 * later. At this point, we have the last CRLF at req->data + msg->eoh.
2073 * If the request is in HTTP/0.9 form, the rule is still true, and eoh
2074 * points to the CRLF of the request line. req->lr points to the first
2075 * byte after the last LF. msg->col and msg->sov point to the first
2076 * byte of data. msg->eol cannot be trusted because it may have been
2077 * left uninitialized (for instance in the absence of headers).
Willy Tarreaud787e662009-07-07 10:14:51 +0200[diff] [blame]2078 */
Willy Tarreau9cdde232007-05-02 20:58:19 +0200[diff] [blame]2079
Willy Tarreaud787e662009-07-07 10:14:51 +0200[diff] [blame]2080 /* Maybe we found in invalid header name while we were configured not
2081 * to block on that, so we have to capture it now.
2082 */
2083 if (unlikely(msg->err_pos >= 0))
Willy Tarreau4076a152009-04-02 15:18:36 +0200[diff] [blame]2084 http_capture_bad_message(&s->fe->invalid_req, s, req, msg, s->fe);
2085
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2086 /* ensure we keep this pointer to the beginning of the message */
2087 msg->sol = req->data + msg->som;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]2088
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2089 /*
2090 * 1: identify the method
2091 */
2092 txn->meth = find_http_meth(&req->data[msg->som], msg->sl.rq.m_l);
2093
2094 /* we can make use of server redirect on GET and HEAD */
2095 if (txn->meth == HTTP_METH_GET || txn->meth == HTTP_METH_HEAD)
2096 s->flags |= SN_REDIRECTABLE;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200[diff] [blame]2097
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2098 /*
2099 * 2: check if the URI matches the monitor_uri.
2100 * We have to do this for every request which gets in, because
2101 * the monitor-uri is defined by the frontend.
2102 */
2103 if (unlikely((s->fe->monitor_uri_len != 0) &&
2104 (s->fe->monitor_uri_len == msg->sl.rq.u_l) &&
2105 !memcmp(&req->data[msg->sl.rq.u],
2106 s->fe->monitor_uri,
2107 s->fe->monitor_uri_len))) {
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]2108 /*
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2109 * We have found the monitor URI
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]2110 */
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2111 struct acl_cond *cond;
Willy Tarreaub80c2302007-11-30 20:51:32 +0100[diff] [blame]2112
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2113 s->flags |= SN_MONITOR;
Willy Tarreaub80c2302007-11-30 20:51:32 +0100[diff] [blame]2114
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2115 /* Check if we want to fail this monitor request or not */
Willy Tarreaud787e662009-07-07 10:14:51 +0200[diff] [blame]2116 list_for_each_entry(cond, &s->fe->mon_fail_cond, list) {
2117 int ret = acl_exec_cond(cond, s->fe, s, txn, ACL_DIR_REQ);
Willy Tarreau11382812008-07-09 16:18:21 +0200[diff] [blame]2118
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2119 ret = acl_pass(ret);
2120 if (cond->pol == ACL_COND_UNLESS)
2121 ret = !ret;
Willy Tarreaub80c2302007-11-30 20:51:32 +0100[diff] [blame]2122
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2123 if (ret) {
2124 /* we fail this request, let's return 503 service unavail */
2125 txn->status = 503;
2126 stream_int_retnclose(req->prod, error_message(s, HTTP_ERR_503));
2127 goto return_prx_cond;
Willy Tarreaub80c2302007-11-30 20:51:32 +0100[diff] [blame]2128 }
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]2129 }
Willy Tarreaua5555ec2008-11-30 19:02:32 +0100[diff] [blame]2130
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2131 /* nothing to fail, let's reply normaly */
2132 txn->status = 200;
2133 stream_int_retnclose(req->prod, &http_200_chunk);
2134 goto return_prx_cond;
2135 }
2136
2137 /*
2138 * 3: Maybe we have to copy the original REQURI for the logs ?
2139 * Note: we cannot log anymore if the request has been
2140 * classified as invalid.
2141 */
2142 if (unlikely(s->logs.logwait & LW_REQ)) {
2143 /* we have a complete HTTP request that we must log */
2144 if ((txn->uri = pool_alloc2(pool2_requri)) != NULL) {
2145 int urilen = msg->sl.rq.l;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]2146
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2147 if (urilen >= REQURI_LEN)
2148 urilen = REQURI_LEN - 1;
2149 memcpy(txn->uri, &req->data[msg->som], urilen);
2150 txn->uri[urilen] = 0;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]2151
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2152 if (!(s->logs.logwait &= ~LW_REQ))
2153 s->do_log(s);
2154 } else {
2155 Alert("HTTP logging : out of memory.\n");
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]2156 }
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2157 }
Willy Tarreau06619262006-12-17 08:37:22 +0100[diff] [blame]2158
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2159 /* 4. We may have to convert HTTP/0.9 requests to HTTP/1.0 */
Willy Tarreau2492d5b2009-07-11 00:06:00 +0200[diff] [blame]2160 if (unlikely(msg->sl.rq.v_l == 0) && !http_upgrade_v09_to_v10(req, msg, txn))
2161 goto return_bad_req;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]2162
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2163 /* ... and check if the request is HTTP/1.1 or above */
2164 if ((msg->sl.rq.v_l == 8) &&
Willy Tarreau1d3bcce2009-12-27 15:50:06 +0100[diff] [blame]2165 ((req->data[msg->sl.rq.v + 5] > '1') ||
2166 ((req->data[msg->sl.rq.v + 5] == '1') &&
2167 (req->data[msg->sl.rq.v + 7] >= '1'))))
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2168 txn->flags |= TX_REQ_VER_11;
2169
2170 /* "connection" has not been parsed yet */
2171 txn->flags &= ~TX_CON_HDR_PARS;
2172
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]2173 /* transfer length unknown*/
2174 txn->flags &= ~TX_REQ_XFER_LEN;
2175
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2176 /* 5: we may need to capture headers */
2177 if (unlikely((s->logs.logwait & LW_REQHDR) && s->fe->req_cap))
2178 capture_headers(req->data + msg->som, &txn->hdr_idx,
2179 txn->req.cap, s->fe->req_cap);
Willy Tarreau11382812008-07-09 16:18:21 +0200[diff] [blame]2180
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]2181 /* 6: determine the transfer-length.
2182 * According to RFC2616 #4.4, amended by the HTTPbis working group,
2183 * the presence of a message-body in a REQUEST and its transfer length
2184 * must be determined that way (in order of precedence) :
2185 * 1. The presence of a message-body in a request is signaled by the
2186 * inclusion of a Content-Length or Transfer-Encoding header field
2187 * in the request's header fields. When a request message contains
2188 * both a message-body of non-zero length and a method that does
2189 * not define any semantics for that request message-body, then an
2190 * origin server SHOULD either ignore the message-body or respond
2191 * with an appropriate error message (e.g., 413). A proxy or
2192 * gateway, when presented the same request, SHOULD either forward
2193 * the request inbound with the message- body or ignore the
2194 * message-body when determining a response.
2195 *
2196 * 2. If a Transfer-Encoding header field (Section 9.7) is present
2197 * and the "chunked" transfer-coding (Section 6.2) is used, the
2198 * transfer-length is defined by the use of this transfer-coding.
2199 * If a Transfer-Encoding header field is present and the "chunked"
2200 * transfer-coding is not present, the transfer-length is defined
2201 * by the sender closing the connection.
Willy Tarreau32b47f42009-10-18 20:55:02 +0200[diff] [blame]2202 *
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]2203 * 3. If a Content-Length header field is present, its decimal value in
2204 * OCTETs represents both the entity-length and the transfer-length.
2205 * If a message is received with both a Transfer-Encoding header
2206 * field and a Content-Length header field, the latter MUST be ignored.
Willy Tarreau32b47f42009-10-18 20:55:02 +0200[diff] [blame]2207 *
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]2208 * 4. By the server closing the connection. (Closing the connection
2209 * cannot be used to indicate the end of a request body, since that
2210 * would leave no possibility for the server to send back a response.)
2211 *
2212 * Whenever a transfer-coding is applied to a message-body, the set of
2213 * transfer-codings MUST include "chunked", unless the message indicates
2214 * it is terminated by closing the connection. When the "chunked"
2215 * transfer-coding is used, it MUST be the last transfer-coding applied
2216 * to the message-body.
Willy Tarreau32b47f42009-10-18 20:55:02 +0200[diff] [blame]2217 */
2218
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]2219 /* CONNECT sets a tunnel and ignores everything else */
2220 if (txn->meth == HTTP_METH_CONNECT)
2221 goto skip_xfer_len;
2222
2223 use_close_only = 0;
Willy Tarreau32b47f42009-10-18 20:55:02 +0200[diff] [blame]2224 ctx.idx = 0;
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]2225 /* set TE_CHNK and XFER_LEN only if "chunked" is seen last */
Willy Tarreau9e13c3c2009-12-22 09:59:58 +0100[diff] [blame]2226 while ((txn->flags & TX_REQ_VER_11) &&
2227 http_find_header2("Transfer-Encoding", 17, msg->sol, &txn->hdr_idx, &ctx)) {
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]2228 if (ctx.vlen == 7 && strncasecmp(ctx.line + ctx.val, "chunked", 7) == 0)
2229 txn->flags |= (TX_REQ_TE_CHNK | TX_REQ_XFER_LEN);
2230 else if (txn->flags & TX_REQ_TE_CHNK) {
2231 /* bad transfer-encoding (chunked followed by something else) */
2232 use_close_only = 1;
2233 txn->flags &= ~(TX_REQ_TE_CHNK | TX_REQ_XFER_LEN);
2234 break;
2235 }
Willy Tarreau32b47f42009-10-18 20:55:02 +0200[diff] [blame]2236 }
2237
Willy Tarreau32b47f42009-10-18 20:55:02 +0200[diff] [blame]2238 ctx.idx = 0;
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]2239 while (!(txn->flags & TX_REQ_TE_CHNK) && !use_close_only &&
Willy Tarreau32b47f42009-10-18 20:55:02 +0200[diff] [blame]2240 http_find_header2("Content-Length", 14, msg->sol, &txn->hdr_idx, &ctx)) {
2241 signed long long cl;
2242
2243 if (!ctx.vlen)
2244 goto return_bad_req;
2245
2246 if (strl2llrc(ctx.line + ctx.val, ctx.vlen, &cl))
2247 goto return_bad_req; /* parse failure */
2248
2249 if (cl < 0)
2250 goto return_bad_req;
2251
2252 if ((txn->flags & TX_REQ_CNT_LEN) && (msg->hdr_content_len != cl))
2253 goto return_bad_req; /* already specified, was different */
2254
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]2255 txn->flags |= TX_REQ_CNT_LEN | TX_REQ_XFER_LEN;
Willy Tarreau32b47f42009-10-18 20:55:02 +0200[diff] [blame]2256 msg->hdr_content_len = cl;
2257 }
2258
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]2259 /* bodyless requests have a known length */
2260 if (!use_close_only)
2261 txn->flags |= TX_REQ_XFER_LEN;
2262
2263 skip_xfer_len:
Willy Tarreaud787e662009-07-07 10:14:51 +0200[diff] [blame]2264 /* end of job, return OK */
Willy Tarreau3a816292009-07-07 10:55:49 +0200[diff] [blame]2265 req->analysers &= ~an_bit;
Willy Tarreaud787e662009-07-07 10:14:51 +0200[diff] [blame]2266 req->analyse_exp = TICK_ETERNITY;
2267 return 1;
2268
2269 return_bad_req:
2270 /* We centralize bad requests processing here */
2271 if (unlikely(msg->msg_state == HTTP_MSG_ERROR) || msg->err_pos >= 0) {
2272 /* we detected a parsing error. We want to archive this request
2273 * in the dedicated proxy area for later troubleshooting.
2274 */
2275 http_capture_bad_message(&s->fe->invalid_req, s, req, msg, s->fe);
2276 }
2277
2278 txn->req.msg_state = HTTP_MSG_ERROR;
2279 txn->status = 400;
2280 stream_int_retnclose(req->prod, error_message(s, HTTP_ERR_400));
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]2281
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]2282 s->fe->counters.failed_req++;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]2283 if (s->listener->counters)
2284 s->listener->counters->failed_req++;
Willy Tarreaud787e662009-07-07 10:14:51 +0200[diff] [blame]2285
2286 return_prx_cond:
2287 if (!(s->flags & SN_ERR_MASK))
2288 s->flags |= SN_ERR_PRXCOND;
2289 if (!(s->flags & SN_FINST_MASK))
2290 s->flags |= SN_FINST_R;
2291
2292 req->analysers = 0;
2293 req->analyse_exp = TICK_ETERNITY;
2294 return 0;
2295}
2296
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2297/* This stream analyser runs all HTTP request processing which is common to
2298 * frontends and backends, which means blocking ACLs, filters, connection-close,
2299 * reqadd, stats and redirects. This is performed for the designated proxy.
Willy Tarreaud787e662009-07-07 10:14:51 +0200[diff] [blame]2300 * It returns 1 if the processing can continue on next analysers, or zero if it
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2301 * either needs more data or wants to immediately abort the request (eg: deny,
2302 * error, ...).
Willy Tarreaud787e662009-07-07 10:14:51 +0200[diff] [blame]2303 */
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2304int http_process_req_common(struct session *s, struct buffer *req, int an_bit, struct proxy *px)
Willy Tarreaud787e662009-07-07 10:14:51 +0200[diff] [blame]2305{
Willy Tarreaud787e662009-07-07 10:14:51 +0200[diff] [blame]2306 struct http_txn *txn = &s->txn;
2307 struct http_msg *msg = &txn->req;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2308 struct acl_cond *cond;
2309 struct redirect_rule *rule;
2310 int cur_idx;
Willy Tarreaud787e662009-07-07 10:14:51 +0200[diff] [blame]2311
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]2312 if (unlikely(msg->msg_state < HTTP_MSG_BODY)) {
Willy Tarreau51aecc72009-07-12 09:47:04 +0200[diff] [blame]2313 /* we need more data */
Willy Tarreau520d95e2009-09-19 21:04:57 +0200[diff] [blame]2314 buffer_dont_connect(req);
Willy Tarreau51aecc72009-07-12 09:47:04 +0200[diff] [blame]2315 return 0;
2316 }
2317
Willy Tarreau3a816292009-07-07 10:55:49 +0200[diff] [blame]2318 req->analysers &= ~an_bit;
Willy Tarreaud787e662009-07-07 10:14:51 +0200[diff] [blame]2319 req->analyse_exp = TICK_ETERNITY;
2320
2321 DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
2322 now_ms, __FUNCTION__,
2323 s,
2324 req,
2325 req->rex, req->wex,
2326 req->flags,
2327 req->l,
2328 req->analysers);
2329
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2330 /* first check whether we have some ACLs set to block this request */
2331 list_for_each_entry(cond, &px->block_cond, list) {
2332 int ret = acl_exec_cond(cond, px, s, txn, ACL_DIR_REQ);
Willy Tarreaub463dfb2008-06-07 23:08:56 +0200[diff] [blame]2333
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2334 ret = acl_pass(ret);
2335 if (cond->pol == ACL_COND_UNLESS)
2336 ret = !ret;
Willy Tarreau53b6c742006-12-17 13:37:46 +0100[diff] [blame]2337
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2338 if (ret) {
2339 txn->status = 403;
2340 /* let's log the request time */
2341 s->logs.tv_request = now;
2342 stream_int_retnclose(req->prod, error_message(s, HTTP_ERR_403));
2343 goto return_prx_cond;
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2344 }
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2345 }
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2346
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2347 /* try headers filters */
2348 if (px->req_exp != NULL) {
2349 if (apply_filters_to_request(s, req, px->req_exp) < 0)
2350 goto return_bad_req;
Willy Tarreau06619262006-12-17 08:37:22 +0100[diff] [blame]2351
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2352 /* has the request been denied ? */
2353 if (txn->flags & TX_CLDENY) {
2354 /* no need to go further */
2355 txn->status = 403;
2356 /* let's log the request time */
2357 s->logs.tv_request = now;
2358 stream_int_retnclose(req->prod, error_message(s, HTTP_ERR_403));
2359 goto return_prx_cond;
2360 }
Willy Tarreauc465fd72009-08-31 00:17:18 +0200[diff] [blame]2361
2362 /* When a connection is tarpitted, we use the tarpit timeout,
2363 * which may be the same as the connect timeout if unspecified.
2364 * If unset, then set it to zero because we really want it to
2365 * eventually expire. We build the tarpit as an analyser.
2366 */
2367 if (txn->flags & TX_CLTARPIT) {
2368 buffer_erase(s->req);
2369 /* wipe the request out so that we can drop the connection early
2370 * if the client closes first.
2371 */
Willy Tarreau520d95e2009-09-19 21:04:57 +0200[diff] [blame]2372 buffer_dont_connect(req);
Willy Tarreauc465fd72009-08-31 00:17:18 +0200[diff] [blame]2373 req->analysers = 0; /* remove switching rules etc... */
2374 req->analysers |= AN_REQ_HTTP_TARPIT;
2375 req->analyse_exp = tick_add_ifset(now_ms, s->be->timeout.tarpit);
2376 if (!req->analyse_exp)
2377 req->analyse_exp = tick_add(now_ms, 0);
2378 return 1;
2379 }
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2380 }
Willy Tarreau06619262006-12-17 08:37:22 +0100[diff] [blame]2381
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2382 /* Until set to anything else, the connection mode is set as TUNNEL. It will
2383 * only change if both the request and the config reference something else.
Willy Tarreau42736642009-10-18 21:04:35 +0200[diff] [blame]2384 */
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2385
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]2386 if ((txn->meth != HTTP_METH_CONNECT) &&
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2387 ((s->fe->options|s->be->options) & (PR_O_KEEPALIVE|PR_O_HTTP_CLOSE|PR_O_FORCE_CLO))) {
2388 int tmp = TX_CON_WANT_TUN;
2389 if ((s->fe->options|s->be->options) & PR_O_KEEPALIVE)
2390 tmp = TX_CON_WANT_KAL;
2391 /* FIXME: for now, we don't support server-close mode */
2392 if ((s->fe->options|s->be->options) & (PR_O_HTTP_CLOSE|PR_O_FORCE_CLO))
2393 tmp = TX_CON_WANT_CLO;
2394
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]2395 if (!(txn->flags & TX_REQ_XFER_LEN))
2396 tmp = TX_CON_WANT_CLO;
2397
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2398 if (!(txn->flags & TX_CON_HDR_PARS))
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]2399 http_req_parse_connection_header(txn);
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2400
2401 if ((txn->flags & TX_CON_WANT_MSK) < tmp)
2402 txn->flags = (txn->flags & ~TX_CON_WANT_MSK) | tmp;
2403 }
2404
2405 /* We're really certain of the connection mode (tunnel, close, keep-alive)
2406 * once we know the backend, because the tunnel mode can be implied by the
2407 * lack of any close/keepalive options in both the FE and the BE. Since
2408 * this information can evolve with time, we proceed by trying to make the
2409 * header status match the desired status. For this, we'll have to adjust
2410 * the "Connection" header. The test for persistent connections has already
2411 * been performed, so we only enter here if there is a risk the connection
2412 * is considered as persistent and we want it to be closed on the server
2413 * side. It would be nice if we could enter this place only when a
2414 * Connection header exists. Note that a CONNECT method will not enter
2415 * here.
2416 */
2417 if (!(txn->flags & TX_REQ_CONN_CLO) && ((txn->flags & TX_CON_WANT_MSK) >= TX_CON_WANT_SCL)) {
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2418 char *cur_ptr, *cur_end, *cur_next;
2419 int old_idx, delta, val;
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2420 int must_delete;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2421 struct hdr_idx_elem *cur_hdr;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]2422
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2423 must_delete = !(txn->flags & TX_REQ_VER_11);
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2424 cur_next = req->data + txn->req.som + hdr_idx_first_pos(&txn->hdr_idx);
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]2425
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2426 for (old_idx = 0; (cur_idx = txn->hdr_idx.v[old_idx].next); old_idx = cur_idx) {
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2427 cur_hdr = &txn->hdr_idx.v[cur_idx];
2428 cur_ptr = cur_next;
2429 cur_end = cur_ptr + cur_hdr->len;
2430 cur_next = cur_end + cur_hdr->cr + 1;
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2431
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2432 val = http_header_match2(cur_ptr, cur_end, "Connection", 10);
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2433 if (!val)
2434 continue;
2435
2436 /* 3 possibilities :
2437 * - we have already set "Connection: close" or we're in
2438 * HTTP/1.0, so we remove this line.
2439 * - we have not yet set "Connection: close", but this line
2440 * indicates close. We leave it untouched and set the flag.
2441 * - we have not yet set "Connection: close", and this line
2442 * indicates non-close. We replace it and set the flag.
2443 */
2444 if (must_delete) {
2445 delta = buffer_replace2(req, cur_ptr, cur_next, NULL, 0);
2446 http_msg_move_end(&txn->req, delta);
2447 cur_next += delta;
2448 txn->hdr_idx.v[old_idx].next = cur_hdr->next;
2449 txn->hdr_idx.used--;
2450 cur_hdr->len = 0;
2451 txn->flags |= TX_REQ_CONN_CLO;
2452 } else {
2453 if (cur_end - cur_ptr - val != 5 ||
2454 strncasecmp(cur_ptr + val, "close", 5) != 0) {
2455 delta = buffer_replace2(req, cur_ptr + val, cur_end,
2456 "close", 5);
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2457 cur_next += delta;
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2458 cur_hdr->len += delta;
2459 http_msg_move_end(&txn->req, delta);
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]2460 }
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2461 txn->flags |= TX_REQ_CONN_CLO;
2462 must_delete = 1;
Willy Tarreau06619262006-12-17 08:37:22 +0100[diff] [blame]2463 }
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2464 } /* for loop */
2465 } /* if must close keep-alive */
Willy Tarreau78599912009-10-17 20:12:21 +0200[diff] [blame]2466
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2467 /* add request headers from the rule sets in the same order */
2468 for (cur_idx = 0; cur_idx < px->nb_reqadd; cur_idx++) {
2469 if (unlikely(http_header_add_tail(req,
2470 &txn->req,
2471 &txn->hdr_idx,
2472 px->req_add[cur_idx])) < 0)
2473 goto return_bad_req;
2474 }
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]2475
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2476 /* check if stats URI was requested, and if an auth is needed */
2477 if (px->uri_auth != NULL &&
2478 (txn->meth == HTTP_METH_GET || txn->meth == HTTP_METH_HEAD)) {
2479 /* we have to check the URI and auth for this request.
2480 * FIXME!!! that one is rather dangerous, we want to
2481 * make it follow standard rules (eg: clear req->analysers).
2482 */
2483 if (stats_check_uri_auth(s, px)) {
2484 req->analysers = 0;
2485 return 0;
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2486 }
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2487 }
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]2488
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2489 /* check whether we have some ACLs set to redirect this request */
2490 list_for_each_entry(rule, &px->redirect_rules, list) {
2491 int ret = acl_exec_cond(rule->cond, px, s, txn, ACL_DIR_REQ);
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2492
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2493 ret = acl_pass(ret);
2494 if (rule->cond->pol == ACL_COND_UNLESS)
2495 ret = !ret;
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2496
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2497 if (ret) {
2498 struct chunk rdr = { trash, 0 };
2499 const char *msg_fmt;
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2500
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2501 /* build redirect message */
2502 switch(rule->code) {
2503 case 303:
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2504 msg_fmt = HTTP_303;
2505 break;
2506 case 301:
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2507 msg_fmt = HTTP_301;
2508 break;
2509 case 302:
2510 default:
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2511 msg_fmt = HTTP_302;
2512 break;
2513 }
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2514
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200[diff] [blame]2515 if (unlikely(chunk_strcpy(&rdr, msg_fmt)))
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2516 goto return_bad_req;
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2517
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2518 switch(rule->type) {
2519 case REDIRECT_TYPE_PREFIX: {
2520 const char *path;
2521 int pathlen;
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2522
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2523 path = http_get_path(txn);
2524 /* build message using path */
2525 if (path) {
2526 pathlen = txn->req.sl.rq.u_l + (txn->req.sol+txn->req.sl.rq.u) - path;
2527 if (rule->flags & REDIRECT_FLAG_DROP_QS) {
2528 int qs = 0;
2529 while (qs < pathlen) {
2530 if (path[qs] == '?') {
2531 pathlen = qs;
2532 break;
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2533 }
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2534 qs++;
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2535 }
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2536 }
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2537 } else {
2538 path = "/";
2539 pathlen = 1;
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2540 }
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2541
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200[diff] [blame]2542 if (rdr.len + rule->rdr_len + pathlen > rdr.size - 4)
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2543 goto return_bad_req;
2544
2545 /* add prefix. Note that if prefix == "/", we don't want to
2546 * add anything, otherwise it makes it hard for the user to
2547 * configure a self-redirection.
2548 */
2549 if (rule->rdr_len != 1 || *rule->rdr_str != '/') {
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2550 memcpy(rdr.str + rdr.len, rule->rdr_str, rule->rdr_len);
2551 rdr.len += rule->rdr_len;
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2552 }
2553
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2554 /* add path */
2555 memcpy(rdr.str + rdr.len, path, pathlen);
2556 rdr.len += pathlen;
2557 break;
2558 }
2559 case REDIRECT_TYPE_LOCATION:
2560 default:
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200[diff] [blame]2561 if (rdr.len + rule->rdr_len > rdr.size - 4)
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2562 goto return_bad_req;
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2563
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2564 /* add location */
2565 memcpy(rdr.str + rdr.len, rule->rdr_str, rule->rdr_len);
2566 rdr.len += rule->rdr_len;
2567 break;
2568 }
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2569
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2570 if (rule->cookie_len) {
2571 memcpy(rdr.str + rdr.len, "\r\nSet-Cookie: ", 14);
2572 rdr.len += 14;
2573 memcpy(rdr.str + rdr.len, rule->cookie_str, rule->cookie_len);
2574 rdr.len += rule->cookie_len;
2575 memcpy(rdr.str + rdr.len, "\r\n", 2);
2576 rdr.len += 2;
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2577 }
Willy Tarreau06b917c2009-07-06 16:34:52 +0200[diff] [blame]2578
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2579 /* add end of headers */
2580 memcpy(rdr.str + rdr.len, "\r\n\r\n", 4);
2581 rdr.len += 4;
Willy Tarreau55ea7572007-06-17 19:56:27 +0200[diff] [blame]2582
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2583 txn->status = rule->code;
2584 /* let's log the request time */
2585 s->logs.tv_request = now;
2586 stream_int_retnclose(req->prod, &rdr);
2587 goto return_prx_cond;
2588 }
2589 }
Willy Tarreau55ea7572007-06-17 19:56:27 +0200[diff] [blame]2590
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2591 /* We can shut read side if "connection: close" && no-data && !tunnel && !abort_on_close */
2592 if ((txn->flags & TX_CON_WANT_MSK) == TX_CON_WANT_CLO &&
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]2593 (txn->flags & TX_REQ_XFER_LEN) &&
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2594 !(txn->flags & TX_REQ_TE_CHNK) && !txn->req.hdr_content_len &&
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2595 !(s->be->options & PR_O_ABRT_CLOSE))
Willy Tarreau349a0f62009-10-18 21:17:42 +0200[diff] [blame]2596 req->flags |= BF_DONT_READ;
Willy Tarreauf1ba4b32009-10-17 14:37:52 +0200[diff] [blame]2597
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2598 /* that's OK for us now, let's move on to next analysers */
2599 return 1;
Willy Tarreau11382812008-07-09 16:18:21 +0200[diff] [blame]2600
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2601 return_bad_req:
2602 /* We centralize bad requests processing here */
2603 if (unlikely(msg->msg_state == HTTP_MSG_ERROR) || msg->err_pos >= 0) {
2604 /* we detected a parsing error. We want to archive this request
2605 * in the dedicated proxy area for later troubleshooting.
2606 */
2607 http_capture_bad_message(&s->fe->invalid_req, s, req, msg, s->fe);
2608 }
Willy Tarreau55ea7572007-06-17 19:56:27 +0200[diff] [blame]2609
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2610 txn->req.msg_state = HTTP_MSG_ERROR;
2611 txn->status = 400;
2612 stream_int_retnclose(req->prod, error_message(s, HTTP_ERR_400));
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]2613
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]2614 s->fe->counters.failed_req++;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]2615 if (s->listener->counters)
2616 s->listener->counters->failed_req++;
Willy Tarreau6e4261e2007-09-18 18:36:05 +0200[diff] [blame]2617
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2618 return_prx_cond:
2619 if (!(s->flags & SN_ERR_MASK))
2620 s->flags |= SN_ERR_PRXCOND;
2621 if (!(s->flags & SN_FINST_MASK))
2622 s->flags |= SN_FINST_R;
Willy Tarreauf1221aa2006-12-17 22:14:12 +0100[diff] [blame]2623
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2624 req->analysers = 0;
2625 req->analyse_exp = TICK_ETERNITY;
2626 return 0;
2627}
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]2628
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2629/* This function performs all the processing enabled for the current request.
2630 * It returns 1 if the processing can continue on next analysers, or zero if it
2631 * needs more data, encounters an error, or wants to immediately abort the
2632 * request. It relies on buffers flags, and updates s->req->analysers.
2633 */
2634int http_process_request(struct session *s, struct buffer *req, int an_bit)
2635{
2636 struct http_txn *txn = &s->txn;
2637 struct http_msg *msg = &txn->req;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]2638
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]2639 if (unlikely(msg->msg_state < HTTP_MSG_BODY)) {
Willy Tarreau51aecc72009-07-12 09:47:04 +0200[diff] [blame]2640 /* we need more data */
Willy Tarreau520d95e2009-09-19 21:04:57 +0200[diff] [blame]2641 buffer_dont_connect(req);
Willy Tarreau51aecc72009-07-12 09:47:04 +0200[diff] [blame]2642 return 0;
2643 }
2644
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]2645 DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
2646 now_ms, __FUNCTION__,
2647 s,
2648 req,
2649 req->rex, req->wex,
2650 req->flags,
2651 req->l,
2652 req->analysers);
Willy Tarreau06619262006-12-17 08:37:22 +0100[diff] [blame]2653
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2654 /*
2655 * Right now, we know that we have processed the entire headers
2656 * and that unwanted requests have been filtered out. We can do
2657 * whatever we want with the remaining request. Also, now we
2658 * may have separate values for ->fe, ->be.
2659 */
Willy Tarreau06619262006-12-17 08:37:22 +0100[diff] [blame]2660
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2661 /*
2662 * If HTTP PROXY is set we simply get remote server address
2663 * parsing incoming request.
2664 */
2665 if ((s->be->options & PR_O_HTTP_PROXY) && !(s->flags & SN_ADDR_SET)) {
2666 url2sa(req->data + msg->sl.rq.u, msg->sl.rq.u_l, &s->srv_addr);
2667 }
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]2668
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2669 /*
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]2670 * 7: Now we can work with the cookies.
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2671 * Note that doing so might move headers in the request, but
2672 * the fields will stay coherent and the URI will not move.
2673 * This should only be performed in the backend.
2674 */
Willy Tarreaufd39dda2008-10-17 12:01:58 +0200[diff] [blame]2675 if ((s->be->cookie_name || s->be->appsession_name || s->fe->capture_name)
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2676 && !(txn->flags & (TX_CLDENY|TX_CLTARPIT)))
2677 manage_client_side_cookies(s, req);
Willy Tarreau7ac51f62007-03-25 16:00:04 +0200[diff] [blame]2678
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2679 /*
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]2680 * 8: the appsession cookie was looked up very early in 1.2,
2681 * so let's do the same now.
2682 */
2683
2684 /* It needs to look into the URI */
2685 if ((s->sessid == NULL) && s->be->appsession_name) {
Willy Tarreau1d3bcce2009-12-27 15:50:06 +0100[diff] [blame]2686 get_srv_from_appsession(s, &req->data[msg->sl.rq.u], msg->sl.rq.u_l);
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]2687 }
2688
2689 /*
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2690 * 9: add X-Forwarded-For if either the frontend or the backend
2691 * asks for it.
2692 */
2693 if ((s->fe->options | s->be->options) & PR_O_FWDFOR) {
2694 if (s->cli_addr.ss_family == AF_INET) {
2695 /* Add an X-Forwarded-For header unless the source IP is
2696 * in the 'except' network range.
2697 */
2698 if ((!s->fe->except_mask.s_addr ||
2699 (((struct sockaddr_in *)&s->cli_addr)->sin_addr.s_addr & s->fe->except_mask.s_addr)
2700 != s->fe->except_net.s_addr) &&
2701 (!s->be->except_mask.s_addr ||
2702 (((struct sockaddr_in *)&s->cli_addr)->sin_addr.s_addr & s->be->except_mask.s_addr)
2703 != s->be->except_net.s_addr)) {
Willy Tarreau2a324282006-12-05 00:05:46 +0100[diff] [blame]2704 int len;
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2705 unsigned char *pn;
2706 pn = (unsigned char *)&((struct sockaddr_in *)&s->cli_addr)->sin_addr;
Ross Westaf72a1d2008-08-03 10:51:45 +0200[diff] [blame]2707
2708 /* Note: we rely on the backend to get the header name to be used for
2709 * x-forwarded-for, because the header is really meant for the backends.
2710 * However, if the backend did not specify any option, we have to rely
2711 * on the frontend's header name.
2712 */
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2713 if (s->be->fwdfor_hdr_len) {
2714 len = s->be->fwdfor_hdr_len;
2715 memcpy(trash, s->be->fwdfor_hdr_name, len);
Ross Westaf72a1d2008-08-03 10:51:45 +0200[diff] [blame]2716 } else {
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2717 len = s->fe->fwdfor_hdr_len;
2718 memcpy(trash, s->fe->fwdfor_hdr_name, len);
Willy Tarreaub86db342009-11-30 11:50:16 +0100[diff] [blame]2719 }
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2720 len += sprintf(trash + len, ": %d.%d.%d.%d", pn[0], pn[1], pn[2], pn[3]);
Willy Tarreauedcf6682008-11-30 23:15:34 +0100[diff] [blame]2721
Willy Tarreau4af6f3a2007-03-18 22:36:26 +0100[diff] [blame]2722 if (unlikely(http_header_add_tail2(req, &txn->req,
2723 &txn->hdr_idx, trash, len)) < 0)
Willy Tarreau06619262006-12-17 08:37:22 +0100[diff] [blame]2724 goto return_bad_req;
Willy Tarreau2a324282006-12-05 00:05:46 +0100[diff] [blame]2725 }
2726 }
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2727 else if (s->cli_addr.ss_family == AF_INET6) {
2728 /* FIXME: for the sake of completeness, we should also support
2729 * 'except' here, although it is mostly useless in this case.
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200[diff] [blame]2730 */
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2731 int len;
2732 char pn[INET6_ADDRSTRLEN];
2733 inet_ntop(AF_INET6,
2734 (const void *)&((struct sockaddr_in6 *)(&s->cli_addr))->sin6_addr,
2735 pn, sizeof(pn));
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200[diff] [blame]2736
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2737 /* Note: we rely on the backend to get the header name to be used for
2738 * x-forwarded-for, because the header is really meant for the backends.
2739 * However, if the backend did not specify any option, we have to rely
2740 * on the frontend's header name.
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200[diff] [blame]2741 */
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2742 if (s->be->fwdfor_hdr_len) {
2743 len = s->be->fwdfor_hdr_len;
2744 memcpy(trash, s->be->fwdfor_hdr_name, len);
2745 } else {
2746 len = s->fe->fwdfor_hdr_len;
2747 memcpy(trash, s->fe->fwdfor_hdr_name, len);
matt.farnsworth@nokia.com1c2ab962008-04-14 20:47:37 +0200[diff] [blame]2748 }
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2749 len += sprintf(trash + len, ": %s", pn);
Willy Tarreauadfb8562008-08-11 15:24:42 +0200[diff] [blame]2750
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2751 if (unlikely(http_header_add_tail2(req, &txn->req,
2752 &txn->hdr_idx, trash, len)) < 0)
2753 goto return_bad_req;
2754 }
2755 }
2756
2757 /*
Maik Broemme2850cb42009-04-17 18:53:21 +0200[diff] [blame]2758 * 10: add X-Original-To if either the frontend or the backend
2759 * asks for it.
2760 */
2761 if ((s->fe->options | s->be->options) & PR_O_ORGTO) {
2762
2763 /* FIXME: don't know if IPv6 can handle that case too. */
2764 if (s->cli_addr.ss_family == AF_INET) {
2765 /* Add an X-Original-To header unless the destination IP is
2766 * in the 'except' network range.
2767 */
2768 if (!(s->flags & SN_FRT_ADDR_SET))
2769 get_frt_addr(s);
2770
2771 if ((!s->fe->except_mask_to.s_addr ||
2772 (((struct sockaddr_in *)&s->frt_addr)->sin_addr.s_addr & s->fe->except_mask_to.s_addr)
2773 != s->fe->except_to.s_addr) &&
2774 (!s->be->except_mask_to.s_addr ||
2775 (((struct sockaddr_in *)&s->frt_addr)->sin_addr.s_addr & s->be->except_mask_to.s_addr)
2776 != s->be->except_to.s_addr)) {
2777 int len;
2778 unsigned char *pn;
2779 pn = (unsigned char *)&((struct sockaddr_in *)&s->frt_addr)->sin_addr;
2780
2781 /* Note: we rely on the backend to get the header name to be used for
2782 * x-original-to, because the header is really meant for the backends.
2783 * However, if the backend did not specify any option, we have to rely
2784 * on the frontend's header name.
2785 */
2786 if (s->be->orgto_hdr_len) {
2787 len = s->be->orgto_hdr_len;
2788 memcpy(trash, s->be->orgto_hdr_name, len);
2789 } else {
2790 len = s->fe->orgto_hdr_len;
2791 memcpy(trash, s->fe->orgto_hdr_name, len);
Willy Tarreaub86db342009-11-30 11:50:16 +0100[diff] [blame]2792 }
Maik Broemme2850cb42009-04-17 18:53:21 +0200[diff] [blame]2793 len += sprintf(trash + len, ": %d.%d.%d.%d", pn[0], pn[1], pn[2], pn[3]);
2794
2795 if (unlikely(http_header_add_tail2(req, &txn->req,
2796 &txn->hdr_idx, trash, len)) < 0)
2797 goto return_bad_req;
2798 }
2799 }
2800 }
2801
Willy Tarreau78599912009-10-17 20:12:21 +0200[diff] [blame]2802 /* 11: add "Connection: close" if needed and not yet set. */
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2803 if (!(txn->flags & TX_REQ_CONN_CLO) && ((txn->flags & TX_CON_WANT_MSK) >= TX_CON_WANT_SCL)) {
Willy Tarreau78599912009-10-17 20:12:21 +0200[diff] [blame]2804 if (unlikely(http_header_add_tail2(req, &txn->req, &txn->hdr_idx,
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2805 "Connection: close", 17)) < 0)
2806 goto return_bad_req;
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]2807 txn->flags |= TX_REQ_CONN_CLO;
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2808 }
Willy Tarreau522d6c02009-12-06 18:49:18 +0100[diff] [blame]2809
2810 /* If we have no server assigned yet and we're balancing on url_param
2811 * with a POST request, we may be interested in checking the body for
2812 * that parameter. This will be done in another analyser.
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2813 */
2814 if (!(s->flags & (SN_ASSIGNED|SN_DIRECT)) &&
2815 s->txn.meth == HTTP_METH_POST && s->be->url_param_name != NULL &&
Willy Tarreau522d6c02009-12-06 18:49:18 +0100[diff] [blame]2816 s->be->url_param_post_limit != 0 &&
2817 (txn->flags & (TX_REQ_CNT_LEN|TX_REQ_TE_CHNK)) &&
Willy Tarreau1d3bcce2009-12-27 15:50:06 +0100[diff] [blame]2818 memchr(req->data + msg->sl.rq.u, '?', msg->sl.rq.u_l) == NULL) {
Willy Tarreau522d6c02009-12-06 18:49:18 +0100[diff] [blame]2819 buffer_dont_connect(req);
2820 req->analysers |= AN_REQ_HTTP_BODY;
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2821 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]2822
Willy Tarreau03945942009-12-22 16:50:27 +0100[diff] [blame]2823 /* if we're not expecting anything else, we're done with this request */
2824 if (!(txn->flags & (TX_REQ_TE_CHNK|TX_REQ_CNT_LEN)) &&
2825 (txn->flags & TX_CON_WANT_MSK) != TX_CON_WANT_TUN)
2826 msg->msg_state = HTTP_MSG_DONE;
2827
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2828 /*************************************************************
2829 * OK, that's finished for the headers. We have done what we *
2830 * could. Let's switch to the DATA state. *
2831 ************************************************************/
Willy Tarreau522d6c02009-12-06 18:49:18 +0100[diff] [blame]2832 req->analyse_exp = TICK_ETERNITY;
2833 req->analysers &= ~an_bit;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]2834
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2835 s->logs.tv_request = now;
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2836 /* OK let's go on with the BODY now */
2837 return 1;
Willy Tarreau06619262006-12-17 08:37:22 +0100[diff] [blame]2838
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2839 return_bad_req: /* let's centralize all bad requests */
Willy Tarreau4076a152009-04-02 15:18:36 +0200[diff] [blame]2840 if (unlikely(msg->msg_state == HTTP_MSG_ERROR) || msg->err_pos >= 0) {
Willy Tarreauf073a832009-03-01 23:21:47 +0100[diff] [blame]2841 /* we detected a parsing error. We want to archive this request
2842 * in the dedicated proxy area for later troubleshooting.
2843 */
Willy Tarreau4076a152009-04-02 15:18:36 +0200[diff] [blame]2844 http_capture_bad_message(&s->fe->invalid_req, s, req, msg, s->fe);
Willy Tarreauf073a832009-03-01 23:21:47 +0100[diff] [blame]2845 }
Willy Tarreau4076a152009-04-02 15:18:36 +0200[diff] [blame]2846
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2847 txn->req.msg_state = HTTP_MSG_ERROR;
2848 txn->status = 400;
2849 req->analysers = 0;
2850 stream_int_retnclose(req->prod, error_message(s, HTTP_ERR_400));
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]2851
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]2852 s->fe->counters.failed_req++;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]2853 if (s->listener->counters)
2854 s->listener->counters->failed_req++;
Willy Tarreauadfb8562008-08-11 15:24:42 +0200[diff] [blame]2855
Willy Tarreau59234e92008-11-30 23:51:27 +0100[diff] [blame]2856 if (!(s->flags & SN_ERR_MASK))
2857 s->flags |= SN_ERR_PRXCOND;
2858 if (!(s->flags & SN_FINST_MASK))
2859 s->flags |= SN_FINST_R;
Willy Tarreaudafde432008-08-17 01:00:46 +0200[diff] [blame]2860 return 0;
Willy Tarreauc65a3ba2008-08-11 23:42:50 +0200[diff] [blame]2861}
Willy Tarreauadfb8562008-08-11 15:24:42 +0200[diff] [blame]2862
Willy Tarreau60b85b02008-11-30 23:28:40 +0100[diff] [blame]2863/* This function is an analyser which processes the HTTP tarpit. It always
2864 * returns zero, at the beginning because it prevents any other processing
2865 * from occurring, and at the end because it terminates the request.
2866 */
Willy Tarreau3a816292009-07-07 10:55:49 +0200[diff] [blame]2867int http_process_tarpit(struct session *s, struct buffer *req, int an_bit)
Willy Tarreau60b85b02008-11-30 23:28:40 +0100[diff] [blame]2868{
2869 struct http_txn *txn = &s->txn;
2870
2871 /* This connection is being tarpitted. The CLIENT side has
2872 * already set the connect expiration date to the right
2873 * timeout. We just have to check that the client is still
2874 * there and that the timeout has not expired.
2875 */
Willy Tarreau520d95e2009-09-19 21:04:57 +0200[diff] [blame]2876 buffer_dont_connect(req);
Willy Tarreau60b85b02008-11-30 23:28:40 +0100[diff] [blame]2877 if ((req->flags & (BF_SHUTR|BF_READ_ERROR)) == 0 &&
2878 !tick_is_expired(req->analyse_exp, now_ms))
2879 return 0;
2880
2881 /* We will set the queue timer to the time spent, just for
2882 * logging purposes. We fake a 500 server error, so that the
2883 * attacker will not suspect his connection has been tarpitted.
2884 * It will not cause trouble to the logs because we can exclude
2885 * the tarpitted connections by filtering on the 'PT' status flags.
2886 */
Willy Tarreau60b85b02008-11-30 23:28:40 +0100[diff] [blame]2887 s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
2888
2889 txn->status = 500;
2890 if (req->flags != BF_READ_ERROR)
2891 stream_int_retnclose(req->prod, error_message(s, HTTP_ERR_500));
2892
2893 req->analysers = 0;
2894 req->analyse_exp = TICK_ETERNITY;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]2895
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]2896 s->fe->counters.failed_req++;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]2897 if (s->listener->counters)
2898 s->listener->counters->failed_req++;
Willy Tarreau60b85b02008-11-30 23:28:40 +0100[diff] [blame]2899
Willy Tarreau60b85b02008-11-30 23:28:40 +0100[diff] [blame]2900 if (!(s->flags & SN_ERR_MASK))
2901 s->flags |= SN_ERR_PRXCOND;
2902 if (!(s->flags & SN_FINST_MASK))
2903 s->flags |= SN_FINST_T;
2904 return 0;
2905}
2906
Willy Tarreaud34af782008-11-30 23:36:37 +0100[diff] [blame]2907/* This function is an analyser which processes the HTTP request body. It looks
2908 * for parameters to be used for the load balancing algorithm (url_param). It
2909 * must only be called after the standard HTTP request processing has occurred,
2910 * because it expects the request to be parsed. It returns zero if it needs to
2911 * read more data, or 1 once it has completed its analysis.
2912 */
Willy Tarreau3a816292009-07-07 10:55:49 +0200[diff] [blame]2913int http_process_request_body(struct session *s, struct buffer *req, int an_bit)
Willy Tarreaud34af782008-11-30 23:36:37 +0100[diff] [blame]2914{
Willy Tarreau522d6c02009-12-06 18:49:18 +0100[diff] [blame]2915 struct http_txn *txn = &s->txn;
Willy Tarreaud34af782008-11-30 23:36:37 +0100[diff] [blame]2916 struct http_msg *msg = &s->txn.req;
Willy Tarreaud34af782008-11-30 23:36:37 +0100[diff] [blame]2917 long long limit = s->be->url_param_post_limit;
Willy Tarreaud34af782008-11-30 23:36:37 +0100[diff] [blame]2918
2919 /* We have to parse the HTTP request body to find any required data.
2920 * "balance url_param check_post" should have been the only way to get
2921 * into this. We were brought here after HTTP header analysis, so all
2922 * related structures are ready.
2923 */
2924
Willy Tarreau522d6c02009-12-06 18:49:18 +0100[diff] [blame]2925 if (unlikely(msg->msg_state < HTTP_MSG_BODY))
2926 goto missing_data;
2927
2928 if (msg->msg_state < HTTP_MSG_100_SENT) {
2929 /* If we have HTTP/1.1 and Expect: 100-continue, then we must
2930 * send an HTTP/1.1 100 Continue intermediate response.
2931 */
Willy Tarreau9e13c3c2009-12-22 09:59:58 +0100[diff] [blame]2932 if (txn->flags & TX_REQ_VER_11) {
Willy Tarreau522d6c02009-12-06 18:49:18 +0100[diff] [blame]2933 struct hdr_ctx ctx;
2934 ctx.idx = 0;
2935 /* Expect is allowed in 1.1, look for it */
2936 if (http_find_header2("Expect", 6, msg->sol, &txn->hdr_idx, &ctx) &&
2937 unlikely(ctx.vlen == 12 && strncasecmp(ctx.line+ctx.val, "100-continue", 12) == 0)) {
2938 buffer_write(s->rep, http_100_chunk.str, http_100_chunk.len);
2939 }
2940 }
2941 msg->msg_state = HTTP_MSG_100_SENT;
2942 }
2943
2944 if (msg->msg_state < HTTP_MSG_CHUNK_SIZE) {
2945 if (txn->flags & TX_REQ_TE_CHNK)
2946 msg->msg_state = HTTP_MSG_CHUNK_SIZE;
2947 else
2948 msg->msg_state = HTTP_MSG_DATA;
2949 }
2950
2951 if (msg->msg_state == HTTP_MSG_CHUNK_SIZE) {
Willy Tarreau115acb92009-12-26 13:56:06 +0100[diff] [blame]2952 /* read the chunk size and assign it to ->hdr_content_len, then
2953 * set ->sov to point to the body and switch to DATA state.
2954 */
2955 int ret = http_parse_chunk_size(req, msg);
Willy Tarreaud34af782008-11-30 23:36:37 +0100[diff] [blame]2956
Willy Tarreau115acb92009-12-26 13:56:06 +0100[diff] [blame]2957 if (!ret)
2958 goto missing_data;
2959 else if (ret < 0)
Willy Tarreau522d6c02009-12-06 18:49:18 +0100[diff] [blame]2960 goto return_bad_req;
Willy Tarreaud34af782008-11-30 23:36:37 +0100[diff] [blame]2961 }
2962
Willy Tarreau522d6c02009-12-06 18:49:18 +0100[diff] [blame]2963 /* Now we're in HTTP_MSG_DATA state.
2964 * We have the first non-header byte in msg->col, which is either the
2965 * beginning of the chunk size or of the data. The first data byte is in
2966 * msg->sov, which is equal to msg->col when not using transfer-encoding.
2967 * We're waiting for at least <url_param_post_limit> bytes after msg->sov.
Willy Tarreaud34af782008-11-30 23:36:37 +0100[diff] [blame]2968 */
Willy Tarreau522d6c02009-12-06 18:49:18 +0100[diff] [blame]2969
2970 if (msg->hdr_content_len < limit)
2971 limit = msg->hdr_content_len;
2972
Willy Tarreau7c96f672009-12-27 22:47:25 +0100[diff] [blame^]2973 if (req->l - (msg->sov - msg->som) >= limit) /* we have enough bytes now */
Willy Tarreau522d6c02009-12-06 18:49:18 +0100[diff] [blame]2974 goto http_end;
2975
2976 missing_data:
2977 /* we get here if we need to wait for more data */
Willy Tarreau115acb92009-12-26 13:56:06 +0100[diff] [blame]2978 if (req->flags & BF_FULL)
2979 goto return_bad_req;
2980
Willy Tarreau522d6c02009-12-06 18:49:18 +0100[diff] [blame]2981 if ((req->flags & BF_READ_TIMEOUT) || tick_is_expired(req->analyse_exp, now_ms)) {
2982 txn->status = 408;
2983 stream_int_retnclose(req->prod, error_message(s, HTTP_ERR_408));
2984 goto return_err_msg;
Willy Tarreaud34af782008-11-30 23:36:37 +0100[diff] [blame]2985 }
Willy Tarreau522d6c02009-12-06 18:49:18 +0100[diff] [blame]2986
2987 /* we get here if we need to wait for more data */
2988 if (!(req->flags & (BF_FULL | BF_READ_ERROR | BF_SHUTR))) {
Willy Tarreaud34af782008-11-30 23:36:37 +0100[diff] [blame]2989 /* Not enough data. We'll re-use the http-request
2990 * timeout here. Ideally, we should set the timeout
2991 * relative to the accept() date. We just set the
2992 * request timeout once at the beginning of the
2993 * request.
2994 */
Willy Tarreau520d95e2009-09-19 21:04:57 +0200[diff] [blame]2995 buffer_dont_connect(req);
Willy Tarreaud34af782008-11-30 23:36:37 +0100[diff] [blame]2996 if (!tick_isset(req->analyse_exp))
Willy Tarreaucd7afc02009-07-12 10:03:17 +0200[diff] [blame]2997 req->analyse_exp = tick_add_ifset(now_ms, s->be->timeout.httpreq);
Willy Tarreaud34af782008-11-30 23:36:37 +0100[diff] [blame]2998 return 0;
2999 }
Willy Tarreau522d6c02009-12-06 18:49:18 +0100[diff] [blame]3000
3001 http_end:
3002 /* The situation will not evolve, so let's give up on the analysis. */
3003 s->logs.tv_request = now; /* update the request timer to reflect full request */
3004 req->analysers &= ~an_bit;
3005 req->analyse_exp = TICK_ETERNITY;
3006 return 1;
3007
3008 return_bad_req: /* let's centralize all bad requests */
3009 txn->req.msg_state = HTTP_MSG_ERROR;
3010 txn->status = 400;
3011 stream_int_retnclose(req->prod, error_message(s, HTTP_ERR_400));
3012
3013 return_err_msg:
3014 req->analysers = 0;
3015 s->fe->counters.failed_req++;
3016 if (s->listener->counters)
3017 s->listener->counters->failed_req++;
3018
3019 if (!(s->flags & SN_ERR_MASK))
3020 s->flags |= SN_ERR_PRXCOND;
3021 if (!(s->flags & SN_FINST_MASK))
3022 s->flags |= SN_FINST_R;
3023 return 0;
Willy Tarreaud34af782008-11-30 23:36:37 +0100[diff] [blame]3024}
3025
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3026/* This stream analyser waits for a complete HTTP response. It returns 1 if the
3027 * processing can continue on next analysers, or zero if it either needs more
3028 * data or wants to immediately abort the response (eg: timeout, error, ...). It
3029 * is tied to AN_RES_WAIT_HTTP and may may remove itself from s->rep->analysers
3030 * when it has nothing left to do, and may remove any analyser when it wants to
3031 * abort.
Willy Tarreauc65a3ba2008-08-11 23:42:50 +0200[diff] [blame]3032 */
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3033int http_wait_for_response(struct session *s, struct buffer *rep, int an_bit)
Willy Tarreauc65a3ba2008-08-11 23:42:50 +0200[diff] [blame]3034{
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3035 struct http_txn *txn = &s->txn;
3036 struct http_msg *msg = &txn->rsp;
Willy Tarreaub8c82c22009-10-18 23:45:12 +0200[diff] [blame]3037 struct hdr_ctx ctx;
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]3038 int use_close_only;
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3039 int cur_idx;
Krzysztof Piotr Oledzki5fb18822009-10-13 21:14:09 +0200[diff] [blame]3040 int n;
Willy Tarreauadfb8562008-08-11 15:24:42 +0200[diff] [blame]3041
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200[diff] [blame]3042 DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200[diff] [blame]3043 now_ms, __FUNCTION__,
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3044 s,
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200[diff] [blame]3045 rep,
3046 rep->rex, rep->wex,
3047 rep->flags,
3048 rep->l,
3049 rep->analysers);
Willy Tarreau67f0eea2008-08-10 22:55:22 +0200[diff] [blame]3050
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3051 /*
3052 * Now parse the partial (or complete) lines.
3053 * We will check the response syntax, and also join multi-line
3054 * headers. An index of all the lines will be elaborated while
3055 * parsing.
3056 *
3057 * For the parsing, we use a 28 states FSM.
3058 *
3059 * Here is the information we currently have :
3060 * rep->data + rep->som = beginning of response
3061 * rep->data + rep->eoh = end of processed headers / start of current one
3062 * rep->data + rep->eol = end of current header or line (LF or CRLF)
3063 * rep->lr = first non-visited byte
3064 * rep->r = end of data
3065 */
3066
3067 if (likely(rep->lr < rep->r))
3068 http_msg_analyzer(rep, msg, &txn->hdr_idx);
Willy Tarreau7f875f62008-08-11 17:35:01 +0200[diff] [blame]3069
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3070 /* 1: we might have to print this header in debug mode */
3071 if (unlikely((global.mode & MODE_DEBUG) &&
3072 (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) &&
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]3073 (msg->msg_state >= HTTP_MSG_BODY || msg->msg_state == HTTP_MSG_ERROR))) {
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3074 char *eol, *sol;
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3075
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3076 sol = rep->data + msg->som;
3077 eol = sol + msg->sl.rq.l;
3078 debug_hdr("srvrep", s, sol, eol);
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3079
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3080 sol += hdr_idx_first_pos(&txn->hdr_idx);
3081 cur_idx = hdr_idx_first_idx(&txn->hdr_idx);
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3082
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3083 while (cur_idx) {
3084 eol = sol + txn->hdr_idx.v[cur_idx].len;
3085 debug_hdr("srvhdr", s, sol, eol);
3086 sol = eol + txn->hdr_idx.v[cur_idx].cr + 1;
3087 cur_idx = txn->hdr_idx.v[cur_idx].next;
3088 }
3089 }
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3090
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3091 /*
3092 * Now we quickly check if we have found a full valid response.
3093 * If not so, we check the FD and buffer states before leaving.
3094 * A full response is indicated by the fact that we have seen
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]3095 * the double LF/CRLF, so the state is >= HTTP_MSG_BODY. Invalid
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3096 * responses are checked first.
3097 *
3098 * Depending on whether the client is still there or not, we
3099 * may send an error response back or not. Note that normally
3100 * we should only check for HTTP status there, and check I/O
3101 * errors somewhere else.
3102 */
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3103
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]3104 if (unlikely(msg->msg_state < HTTP_MSG_BODY)) {
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3105 /* Invalid response */
3106 if (unlikely(msg->msg_state == HTTP_MSG_ERROR)) {
3107 /* we detected a parsing error. We want to archive this response
3108 * in the dedicated proxy area for later troubleshooting.
3109 */
3110 hdr_response_bad:
3111 if (msg->msg_state == HTTP_MSG_ERROR || msg->err_pos >= 0)
3112 http_capture_bad_message(&s->be->invalid_rep, s, rep, msg, s->fe);
3113
3114 s->be->counters.failed_resp++;
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100[diff] [blame]3115 if (s->srv) {
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3116 s->srv->counters.failed_resp++;
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100[diff] [blame]3117 health_adjust(s->srv, HANA_STATUS_HTTP_HDRRSP);
3118 }
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3119
3120 rep->analysers = 0;
3121 txn->status = 502;
3122 stream_int_retnclose(rep->cons, error_message(s, HTTP_ERR_502));
3123
3124 if (!(s->flags & SN_ERR_MASK))
3125 s->flags |= SN_ERR_PRXCOND;
3126 if (!(s->flags & SN_FINST_MASK))
3127 s->flags |= SN_FINST_H;
3128
3129 return 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]3130 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]3131
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3132 /* too large response does not fit in buffer. */
3133 else if (rep->flags & BF_FULL) {
3134 goto hdr_response_bad;
3135 }
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3136
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3137 /* read error */
3138 else if (rep->flags & BF_READ_ERROR) {
3139 if (msg->err_pos >= 0)
3140 http_capture_bad_message(&s->be->invalid_rep, s, rep, msg, s->fe);
Willy Tarreau4076a152009-04-02 15:18:36 +0200[diff] [blame]3141
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3142 s->be->counters.failed_resp++;
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100[diff] [blame]3143 if (s->srv) {
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3144 s->srv->counters.failed_resp++;
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100[diff] [blame]3145 health_adjust(s->srv, HANA_STATUS_HTTP_READ_ERROR);
3146 }
Willy Tarreau461f6622008-08-15 23:43:19 +0200[diff] [blame]3147
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3148 rep->analysers = 0;
3149 txn->status = 502;
3150 stream_int_retnclose(rep->cons, error_message(s, HTTP_ERR_502));
Willy Tarreau816b9792009-09-15 21:25:21 +0200[diff] [blame]3151
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3152 if (!(s->flags & SN_ERR_MASK))
3153 s->flags |= SN_ERR_SRVCL;
3154 if (!(s->flags & SN_FINST_MASK))
3155 s->flags |= SN_FINST_H;
Willy Tarreaucebf57e2008-08-15 18:16:37 +0200[diff] [blame]3156 return 0;
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3157 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]3158
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3159 /* read timeout : return a 504 to the client. */
3160 else if (rep->flags & BF_READ_TIMEOUT) {
3161 if (msg->err_pos >= 0)
3162 http_capture_bad_message(&s->be->invalid_rep, s, rep, msg, s->fe);
Willy Tarreau21d2af32008-02-14 20:25:24 +0100[diff] [blame]3163
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3164 s->be->counters.failed_resp++;
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100[diff] [blame]3165 if (s->srv) {
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3166 s->srv->counters.failed_resp++;
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100[diff] [blame]3167 health_adjust(s->srv, HANA_STATUS_HTTP_READ_TIMEOUT);
3168 }
Willy Tarreau21d2af32008-02-14 20:25:24 +0100[diff] [blame]3169
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3170 rep->analysers = 0;
3171 txn->status = 504;
3172 stream_int_retnclose(rep->cons, error_message(s, HTTP_ERR_504));
Willy Tarreau4076a152009-04-02 15:18:36 +0200[diff] [blame]3173
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3174 if (!(s->flags & SN_ERR_MASK))
3175 s->flags |= SN_ERR_SRVTO;
3176 if (!(s->flags & SN_FINST_MASK))
3177 s->flags |= SN_FINST_H;
3178 return 0;
3179 }
Willy Tarreaua7c52762008-08-16 18:40:18 +0200[diff] [blame]3180
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3181 /* close from server */
3182 else if (rep->flags & BF_SHUTR) {
3183 if (msg->err_pos >= 0)
3184 http_capture_bad_message(&s->be->invalid_rep, s, rep, msg, s->fe);
Willy Tarreau21d2af32008-02-14 20:25:24 +0100[diff] [blame]3185
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3186 s->be->counters.failed_resp++;
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100[diff] [blame]3187 if (s->srv) {
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3188 s->srv->counters.failed_resp++;
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100[diff] [blame]3189 health_adjust(s->srv, HANA_STATUS_HTTP_BROKEN_PIPE);
3190 }
Willy Tarreau21d2af32008-02-14 20:25:24 +0100[diff] [blame]3191
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3192 rep->analysers = 0;
3193 txn->status = 502;
3194 stream_int_retnclose(rep->cons, error_message(s, HTTP_ERR_502));
Willy Tarreau21d2af32008-02-14 20:25:24 +0100[diff] [blame]3195
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3196 if (!(s->flags & SN_ERR_MASK))
3197 s->flags |= SN_ERR_SRVCL;
3198 if (!(s->flags & SN_FINST_MASK))
3199 s->flags |= SN_FINST_H;
3200 return 0;
3201 }
Krzysztof Piotr Oledzki5fb18822009-10-13 21:14:09 +0200[diff] [blame]3202
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3203 /* write error to client (we don't send any message then) */
3204 else if (rep->flags & BF_WRITE_ERROR) {
3205 if (msg->err_pos >= 0)
3206 http_capture_bad_message(&s->be->invalid_rep, s, rep, msg, s->fe);
Krzysztof Piotr Oledzki5fb18822009-10-13 21:14:09 +0200[diff] [blame]3207
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3208 s->be->counters.failed_resp++;
3209 rep->analysers = 0;
3210
3211 if (!(s->flags & SN_ERR_MASK))
3212 s->flags |= SN_ERR_CLICL;
3213 if (!(s->flags & SN_FINST_MASK))
3214 s->flags |= SN_FINST_H;
3215
3216 /* process_session() will take care of the error */
3217 return 0;
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3218 }
Willy Tarreau21d2af32008-02-14 20:25:24 +0100[diff] [blame]3219
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3220 buffer_dont_close(rep);
3221 return 0;
3222 }
3223
3224 /* More interesting part now : we know that we have a complete
3225 * response which at least looks like HTTP. We have an indicator
3226 * of each header's length, so we can parse them quickly.
3227 */
3228
3229 if (unlikely(msg->err_pos >= 0))
3230 http_capture_bad_message(&s->be->invalid_rep, s, rep, msg, s->fe);
3231
3232 /* ensure we keep this pointer to the beginning of the message */
3233 msg->sol = rep->data + msg->som;
3234
3235 /*
3236 * 1: get the status code
3237 */
3238 n = rep->data[msg->sl.st.c] - '0';
3239 if (n < 1 || n > 5)
3240 n = 0;
3241 s->srv->counters.p.http.rsp[n]++;
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3242
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]3243 /* check if the response is HTTP/1.1 or above */
3244 if ((msg->sl.st.v_l == 8) &&
3245 ((rep->data[msg->som + 5] > '1') ||
3246 ((rep->data[msg->som + 5] == '1') &&
3247 (rep->data[msg->som + 7] >= '1'))))
3248 txn->flags |= TX_RES_VER_11;
3249
3250 /* "connection" has not been parsed yet */
3251 txn->flags &= ~TX_CON_HDR_PARS;
3252
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]3253 /* transfer length unknown*/
3254 txn->flags &= ~TX_RES_XFER_LEN;
3255
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3256 txn->status = strl2ui(rep->data + msg->sl.st.c, msg->sl.st.c_l);
3257
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100[diff] [blame]3258 if (txn->status >= 100 && txn->status < 500)
3259 health_adjust(s->srv, HANA_STATUS_HTTP_OK);
3260 else
3261 health_adjust(s->srv, HANA_STATUS_HTTP_STS);
3262
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3263 /*
3264 * 2: check for cacheability.
3265 */
3266
3267 switch (txn->status) {
3268 case 200:
3269 case 203:
3270 case 206:
3271 case 300:
3272 case 301:
3273 case 410:
3274 /* RFC2616 @13.4:
3275 * "A response received with a status code of
3276 * 200, 203, 206, 300, 301 or 410 MAY be stored
3277 * by a cache (...) unless a cache-control
3278 * directive prohibits caching."
3279 *
3280 * RFC2616 @9.5: POST method :
3281 * "Responses to this method are not cacheable,
3282 * unless the response includes appropriate
3283 * Cache-Control or Expires header fields."
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3284 */
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3285 if (likely(txn->meth != HTTP_METH_POST) &&
3286 (s->be->options & (PR_O_CHK_CACHE|PR_O_COOK_NOC)))
3287 txn->flags |= TX_CACHEABLE | TX_CACHE_COOK;
3288 break;
3289 default:
3290 break;
3291 }
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3292
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3293 /*
3294 * 3: we may need to capture headers
3295 */
3296 s->logs.logwait &= ~LW_RESP;
3297 if (unlikely((s->logs.logwait & LW_RSPHDR) && s->fe->rsp_cap))
3298 capture_headers(rep->data + msg->som, &txn->hdr_idx,
3299 txn->rsp.cap, s->fe->rsp_cap);
3300
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]3301 /* 4: determine the transfer-length.
3302 * According to RFC2616 #4.4, amended by the HTTPbis working group,
3303 * the presence of a message-body in a RESPONSE and its transfer length
3304 * must be determined that way :
Willy Tarreaub8c82c22009-10-18 23:45:12 +0200[diff] [blame]3305 *
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]3306 * All responses to the HEAD request method MUST NOT include a
3307 * message-body, even though the presence of entity-header fields
3308 * might lead one to believe they do. All 1xx (informational), 204
3309 * (No Content), and 304 (Not Modified) responses MUST NOT include a
3310 * message-body. All other responses do include a message-body,
3311 * although it MAY be of zero length.
Willy Tarreaub8c82c22009-10-18 23:45:12 +0200[diff] [blame]3312 *
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]3313 * 1. Any response which "MUST NOT" include a message-body (such as the
3314 * 1xx, 204 and 304 responses and any response to a HEAD request) is
3315 * always terminated by the first empty line after the header fields,
3316 * regardless of the entity-header fields present in the message.
3317 *
3318 * 2. If a Transfer-Encoding header field (Section 9.7) is present and
3319 * the "chunked" transfer-coding (Section 6.2) is used, the
3320 * transfer-length is defined by the use of this transfer-coding.
3321 * If a Transfer-Encoding header field is present and the "chunked"
3322 * transfer-coding is not present, the transfer-length is defined by
3323 * the sender closing the connection.
3324 *
3325 * 3. If a Content-Length header field is present, its decimal value in
3326 * OCTETs represents both the entity-length and the transfer-length.
3327 * If a message is received with both a Transfer-Encoding header
3328 * field and a Content-Length header field, the latter MUST be ignored.
3329 *
3330 * 4. If the message uses the media type "multipart/byteranges", and
3331 * the transfer-length is not otherwise specified, then this self-
3332 * delimiting media type defines the transfer-length. This media
3333 * type MUST NOT be used unless the sender knows that the recipient
3334 * can parse it; the presence in a request of a Range header with
3335 * multiple byte-range specifiers from a 1.1 client implies that the
3336 * client can parse multipart/byteranges responses.
3337 *
3338 * 5. By the server closing the connection.
Willy Tarreaub8c82c22009-10-18 23:45:12 +0200[diff] [blame]3339 */
3340
3341 /* Skip parsing if no content length is possible. The response flags
3342 * remain 0 as well as the hdr_content_len, which may or may not mirror
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]3343 * the real header value, and we note that we know the response's length.
Willy Tarreaub8c82c22009-10-18 23:45:12 +0200[diff] [blame]3344 * FIXME: should we parse anyway and return an error on chunked encoding ?
3345 */
3346 if (txn->meth == HTTP_METH_HEAD ||
3347 (txn->status >= 100 && txn->status < 200) ||
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]3348 txn->status == 204 || txn->status == 304) {
3349 txn->flags |= TX_RES_XFER_LEN;
3350 goto skip_content_length;
3351 }
3352
3353 if (txn->meth == HTTP_METH_CONNECT)
Willy Tarreaub8c82c22009-10-18 23:45:12 +0200[diff] [blame]3354 goto skip_content_length;
3355
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]3356 use_close_only = 0;
Willy Tarreaub8c82c22009-10-18 23:45:12 +0200[diff] [blame]3357 ctx.idx = 0;
Willy Tarreau9e13c3c2009-12-22 09:59:58 +0100[diff] [blame]3358 while ((txn->flags & TX_RES_VER_11) &&
3359 http_find_header2("Transfer-Encoding", 17, msg->sol, &txn->hdr_idx, &ctx)) {
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]3360 if (ctx.vlen == 7 && strncasecmp(ctx.line + ctx.val, "chunked", 7) == 0)
3361 txn->flags |= (TX_RES_TE_CHNK | TX_RES_XFER_LEN);
3362 else if (txn->flags & TX_RES_TE_CHNK) {
3363 /* bad transfer-encoding (chunked followed by something else) */
3364 use_close_only = 1;
3365 txn->flags &= ~(TX_RES_TE_CHNK | TX_RES_XFER_LEN);
3366 break;
3367 }
Willy Tarreaub8c82c22009-10-18 23:45:12 +0200[diff] [blame]3368 }
3369
3370 /* FIXME: below we should remove the content-length header(s) in case of chunked encoding */
3371 ctx.idx = 0;
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]3372 while (!(txn->flags & TX_RES_TE_CHNK) && !use_close_only &&
Willy Tarreaub8c82c22009-10-18 23:45:12 +0200[diff] [blame]3373 http_find_header2("Content-Length", 14, msg->sol, &txn->hdr_idx, &ctx)) {
3374 signed long long cl;
3375
3376 if (!ctx.vlen)
3377 goto hdr_response_bad;
3378
3379 if (strl2llrc(ctx.line + ctx.val, ctx.vlen, &cl))
3380 goto hdr_response_bad; /* parse failure */
3381
3382 if (cl < 0)
3383 goto hdr_response_bad;
3384
3385 if ((txn->flags & TX_RES_CNT_LEN) && (msg->hdr_content_len != cl))
3386 goto hdr_response_bad; /* already specified, was different */
3387
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]3388 txn->flags |= TX_RES_CNT_LEN | TX_RES_XFER_LEN;
Willy Tarreaub8c82c22009-10-18 23:45:12 +0200[diff] [blame]3389 msg->hdr_content_len = cl;
3390 }
3391
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]3392 /* FIXME: we should also implement the multipart/byterange method.
3393 * For now on, we resort to close mode in this case (unknown length).
3394 */
Willy Tarreaub8c82c22009-10-18 23:45:12 +0200[diff] [blame]3395skip_content_length:
Willy Tarreaub8c82c22009-10-18 23:45:12 +0200[diff] [blame]3396
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3397 /* end of job, return OK */
3398 rep->analysers &= ~an_bit;
3399 rep->analyse_exp = TICK_ETERNITY;
3400 return 1;
3401}
3402
3403/* This function performs all the processing enabled for the current response.
3404 * It normally returns zero, but may return 1 if it absolutely needs to be
3405 * called again after other functions. It relies on buffers flags, and updates
3406 * t->rep->analysers. It might make sense to explode it into several other
3407 * functions. It works like process_request (see indications above).
3408 */
3409int http_process_res_common(struct session *t, struct buffer *rep, int an_bit, struct proxy *px)
3410{
3411 struct http_txn *txn = &t->txn;
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3412 struct http_msg *msg = &txn->rsp;
3413 struct proxy *cur_proxy;
3414 int cur_idx;
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]3415 int conn_ka = 0, conn_cl = 0;
3416 int must_close = 0;
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3417
3418 DPRINTF(stderr,"[%u] %s: session=%p b=%p, exp(r,w)=%u,%u bf=%08x bl=%d analysers=%02x\n",
3419 now_ms, __FUNCTION__,
3420 t,
3421 rep,
3422 rep->rex, rep->wex,
3423 rep->flags,
3424 rep->l,
3425 rep->analysers);
3426
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]3427 if (unlikely(msg->msg_state < HTTP_MSG_BODY)) /* we need more data */
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3428 return 0;
3429
3430 rep->analysers &= ~an_bit;
3431 rep->analyse_exp = TICK_ETERNITY;
3432
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]3433 /* Now we have to check if we need to modify the Connection header.
3434 * This is more difficult on the response than it is on the request,
3435 * because we can have two different HTTP versions and we don't know
3436 * how the client will interprete a response. For instance, let's say
3437 * that the client sends a keep-alive request in HTTP/1.0 and gets an
3438 * HTTP/1.1 response without any header. Maybe it will bound itself to
3439 * HTTP/1.0 because it only knows about it, and will consider the lack
3440 * of header as a close, or maybe it knows HTTP/1.1 and can consider
3441 * the lack of header as a keep-alive. Thus we will use two flags
3442 * indicating how a request MAY be understood by the client. In case
3443 * of multiple possibilities, we'll fix the header to be explicit. If
3444 * ambiguous cases such as both close and keepalive are seen, then we
3445 * will fall back to explicit close. Note that we won't take risks with
3446 * HTTP/1.0 clients which may not necessarily understand keep-alive.
3447 */
3448
3449 if ((txn->meth != HTTP_METH_CONNECT) &&
3450 (txn->status >= 200) &&
3451 (txn->flags & TX_CON_WANT_MSK) != TX_CON_WANT_TUN &&
3452 !(txn->flags & TX_CON_HDR_PARS)) {
3453 int may_keep = 0, may_close = 0; /* how it may be understood */
3454 struct hdr_ctx ctx;
3455
3456 ctx.idx = 0;
3457 while (http_find_header2("Connection", 10, msg->sol, &txn->hdr_idx, &ctx)) {
3458 if (ctx.vlen == 5 && strncasecmp(ctx.line + ctx.val, "close", 5) == 0)
3459 conn_cl = 1;
3460 else if (ctx.vlen == 10 && strncasecmp(ctx.line + ctx.val, "keep-alive", 10) == 0)
3461 conn_ka = 1;
3462 }
3463
3464 if (conn_cl) {
3465 /* close header present */
3466 may_close = 1;
3467 if (conn_ka) /* we have both close and keep-alive */
3468 may_keep = 1;
3469 }
3470 else if (conn_ka) {
3471 /* keep-alive alone */
3472 may_keep = 1;
3473 }
3474 else {
3475 /* no close nor keep-alive header */
3476 if (txn->flags & TX_RES_VER_11)
3477 may_keep = 1;
3478 else
3479 may_close = 1;
3480
3481 if (txn->flags & TX_REQ_VER_11)
3482 may_keep = 1;
3483 else
3484 may_close = 1;
3485 }
3486
3487 /* let's update the transaction status to reflect any close.
3488 * Note that ambiguous cases with keep & close will also be
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]3489 * handled. We also explicitly state that we will close in
3490 * case of an ambiguous response having no content-length.
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]3491 */
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]3492 if (may_close || !(txn->flags & TX_RES_XFER_LEN))
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]3493 txn->flags = (txn->flags & ~TX_CON_WANT_MSK) | TX_CON_WANT_CLO;
3494
3495 /* Now we must adjust the response header :
3496 * - set "close" if may_keep and WANT_CLO
3497 * - remove "close" if WANT_SCL and REQ_1.1 and may_close and (content-length or TE_CHNK)
3498 * - add "keep-alive" if WANT_SCL and REQ_1.0 and may_close and content-length
3499 *
3500 * Until we support the server-close mode, we'll only support the set "close".
3501 */
3502 if (may_keep && (txn->flags & TX_CON_WANT_MSK) == TX_CON_WANT_CLO)
3503 must_close = 1;
3504
3505 txn->flags |= TX_CON_HDR_PARS;
3506 }
3507
3508 /* We might have to check for "Connection:" if the server
3509 * returns a connection status that is not compatible with
3510 * the client's or with the config.
3511 */
3512 if ((txn->status >= 200) && must_close && (conn_cl|conn_ka)) {
3513 char *cur_ptr, *cur_end, *cur_next;
3514 int cur_idx, old_idx, delta, val;
3515 int must_delete;
3516 struct hdr_idx_elem *cur_hdr;
3517
3518 /* we just have to remove the headers if both sides are 1.0 */
3519 must_delete = !(txn->flags & TX_REQ_VER_11) && !(txn->flags & TX_RES_VER_11);
3520 cur_next = rep->data + txn->rsp.som + hdr_idx_first_pos(&txn->hdr_idx);
3521
3522 for (old_idx = 0; (cur_idx = txn->hdr_idx.v[old_idx].next); old_idx = cur_idx) {
3523 cur_hdr = &txn->hdr_idx.v[cur_idx];
3524 cur_ptr = cur_next;
3525 cur_end = cur_ptr + cur_hdr->len;
3526 cur_next = cur_end + cur_hdr->cr + 1;
3527
3528 val = http_header_match2(cur_ptr, cur_end, "Connection", 10);
3529 if (!val)
3530 continue;
3531
3532 /* 3 possibilities :
3533 * - we have already set "Connection: close" or we're in
3534 * HTTP/1.0, so we remove this line.
3535 * - we have not yet set "Connection: close", but this line
3536 * indicates close. We leave it untouched and set the flag.
3537 * - we have not yet set "Connection: close", and this line
3538 * indicates non-close. We replace it and set the flag.
3539 */
3540 if (must_delete) {
3541 delta = buffer_replace2(rep, cur_ptr, cur_next, NULL, 0);
3542 http_msg_move_end(&txn->rsp, delta);
3543 cur_next += delta;
3544 txn->hdr_idx.v[old_idx].next = cur_hdr->next;
3545 txn->hdr_idx.used--;
3546 cur_hdr->len = 0;
3547 must_close = 0;
3548 } else {
3549 if (cur_end - cur_ptr - val != 5 ||
3550 strncasecmp(cur_ptr + val, "close", 5) != 0) {
3551 delta = buffer_replace2(rep, cur_ptr + val, cur_end,
3552 "close", 5);
3553 cur_next += delta;
3554 cur_hdr->len += delta;
3555 http_msg_move_end(&txn->rsp, delta);
3556 }
3557 must_delete = 1;
3558 must_close = 0;
3559 }
3560 } /* for loop */
3561 } /* if must close keep-alive */
3562
Willy Tarreaub37c27e2009-10-18 22:53:08 +0200[diff] [blame]3563 if (1) {
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3564 /*
3565 * 3: we will have to evaluate the filters.
3566 * As opposed to version 1.2, now they will be evaluated in the
3567 * filters order and not in the header order. This means that
3568 * each filter has to be validated among all headers.
3569 *
3570 * Filters are tried with ->be first, then with ->fe if it is
3571 * different from ->be.
3572 */
3573
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3574 cur_proxy = t->be;
3575 while (1) {
3576 struct proxy *rule_set = cur_proxy;
3577
3578 /* try headers filters */
3579 if (rule_set->rsp_exp != NULL) {
3580 if (apply_filters_to_response(t, rep, rule_set->rsp_exp) < 0) {
3581 return_bad_resp:
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100[diff] [blame]3582 if (t->srv) {
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]3583 t->srv->counters.failed_resp++;
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100[diff] [blame]3584 health_adjust(t->srv, HANA_STATUS_HTTP_RSP);
3585 }
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]3586 cur_proxy->counters.failed_resp++;
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3587 return_srv_prx_502:
Willy Tarreau2df28e82008-08-17 15:20:19 +0200[diff] [blame]3588 rep->analysers = 0;
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3589 txn->status = 502;
Willy Tarreau8e89b842009-10-18 23:56:35 +0200[diff] [blame]3590 stream_int_retnclose(rep->cons, error_message(t, HTTP_ERR_502));
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3591 if (!(t->flags & SN_ERR_MASK))
3592 t->flags |= SN_ERR_PRXCOND;
3593 if (!(t->flags & SN_FINST_MASK))
3594 t->flags |= SN_FINST_H;
Willy Tarreaudafde432008-08-17 01:00:46 +0200[diff] [blame]3595 return 0;
Willy Tarreau21d2af32008-02-14 20:25:24 +0100[diff] [blame]3596 }
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3597 }
Willy Tarreau21d2af32008-02-14 20:25:24 +0100[diff] [blame]3598
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3599 /* has the response been denied ? */
3600 if (txn->flags & TX_SVDENY) {
Willy Tarreau8365f932009-03-15 23:11:49 +0100[diff] [blame]3601 if (t->srv)
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]3602 t->srv->counters.failed_secu++;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]3603
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]3604 cur_proxy->counters.denied_resp++;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]3605 if (t->listener->counters)
3606 t->listener->counters->denied_resp++;
3607
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3608 goto return_srv_prx_502;
Willy Tarreau51406232008-03-10 22:04:20 +0100[diff] [blame]3609 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]3610
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3611 /* add response headers from the rule sets in the same order */
3612 for (cur_idx = 0; cur_idx < rule_set->nb_rspadd; cur_idx++) {
Willy Tarreau816b9792009-09-15 21:25:21 +0200[diff] [blame]3613 if (txn->status < 200)
3614 break;
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3615 if (unlikely(http_header_add_tail(rep, &txn->rsp, &txn->hdr_idx,
3616 rule_set->rsp_add[cur_idx])) < 0)
3617 goto return_bad_resp;
Willy Tarreau0bbc3cf2006-10-15 14:26:02 +0200[diff] [blame]3618 }
3619
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3620 /* check whether we're already working on the frontend */
3621 if (cur_proxy == t->fe)
3622 break;
3623 cur_proxy = t->fe;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]3624 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]3625
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3626 /*
Willy Tarreau63c9e5f2009-12-22 16:01:27 +0100[diff] [blame]3627 * We may be facing a 1xx response (100 continue, 101 switching protocols),
3628 * in which case this is not the right response, and we're waiting for the
3629 * next one. Let's allow this response to go to the client and wait for the
3630 * next one.
3631 */
3632 if (txn->status < 200) {
3633 hdr_idx_init(&txn->hdr_idx);
3634 buffer_forward(rep, rep->lr - (rep->data + msg->som));
3635 msg->msg_state = HTTP_MSG_RPBEFORE;
3636 txn->status = 0;
3637 rep->analysers |= AN_RES_WAIT_HTTP | an_bit;
3638 return 1;
3639 }
3640
3641 /* we don't have any 1xx status code now */
3642
3643 /*
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3644 * 4: check for server cookie.
3645 */
Willy Tarreau63c9e5f2009-12-22 16:01:27 +0100[diff] [blame]3646 if (t->be->cookie_name || t->be->appsession_name || t->fe->capture_name ||
3647 (t->be->options & PR_O_CHK_CACHE))
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3648 manage_server_side_cookies(t, rep);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]3649
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]3650
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]3651 /*
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3652 * 5: check for cache-control or pragma headers if required.
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]3653 */
Willy Tarreau63c9e5f2009-12-22 16:01:27 +0100[diff] [blame]3654 if ((t->be->options & (PR_O_COOK_NOC | PR_O_CHK_CACHE)) != 0)
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3655 check_response_for_cacheability(t, rep);
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]3656
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3657 /*
3658 * 6: add server cookie in the response if needed
3659 */
3660 if ((t->srv) && !(t->flags & SN_DIRECT) && (t->be->options & PR_O_COOK_INS) &&
Willy Tarreau63c9e5f2009-12-22 16:01:27 +0100[diff] [blame]3661 (!(t->be->options & PR_O_COOK_POST) || (txn->meth == HTTP_METH_POST))) {
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3662 int len;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]3663
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3664 /* the server is known, it's not the one the client requested, we have to
3665 * insert a set-cookie here, except if we want to insert only on POST
3666 * requests and this one isn't. Note that servers which don't have cookies
3667 * (eg: some backup servers) will return a full cookie removal request.
3668 */
3669 len = sprintf(trash, "Set-Cookie: %s=%s; path=/",
3670 t->be->cookie_name,
3671 t->srv->cookie ? t->srv->cookie : "; Expires=Thu, 01-Jan-1970 00:00:01 GMT");
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]3672
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3673 if (t->be->cookie_domain)
3674 len += sprintf(trash+len, "; domain=%s", t->be->cookie_domain);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]3675
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3676 if (unlikely(http_header_add_tail2(rep, &txn->rsp, &txn->hdr_idx,
3677 trash, len)) < 0)
3678 goto return_bad_resp;
3679 txn->flags |= TX_SCK_INSERTED;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]3680
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3681 /* Here, we will tell an eventual cache on the client side that we don't
3682 * want it to cache this reply because HTTP/1.0 caches also cache cookies !
3683 * Some caches understand the correct form: 'no-cache="set-cookie"', but
3684 * others don't (eg: apache <= 1.3.26). So we use 'private' instead.
3685 */
3686 if ((t->be->options & PR_O_COOK_NOC) && (txn->flags & TX_CACHEABLE)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]3687
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3688 txn->flags &= ~TX_CACHEABLE & ~TX_CACHE_COOK;
3689
3690 if (unlikely(http_header_add_tail2(rep, &txn->rsp, &txn->hdr_idx,
3691 "Cache-control: private", 22)) < 0)
3692 goto return_bad_resp;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]3693 }
3694 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]3695
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3696 /*
3697 * 7: check if result will be cacheable with a cookie.
3698 * We'll block the response if security checks have caught
3699 * nasty things such as a cacheable cookie.
3700 */
3701 if (((txn->flags & (TX_CACHEABLE | TX_CACHE_COOK | TX_SCK_ANY)) ==
3702 (TX_CACHEABLE | TX_CACHE_COOK | TX_SCK_ANY)) &&
Willy Tarreau63c9e5f2009-12-22 16:01:27 +0100[diff] [blame]3703 (t->be->options & PR_O_CHK_CACHE)) {
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3704
3705 /* we're in presence of a cacheable response containing
3706 * a set-cookie header. We'll block it as requested by
3707 * the 'checkcache' option, and send an alert.
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]3708 */
Willy Tarreau8365f932009-03-15 23:11:49 +0100[diff] [blame]3709 if (t->srv)
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]3710 t->srv->counters.failed_secu++;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]3711
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]3712 cur_proxy->counters.denied_resp++;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]3713 if (t->listener->counters)
3714 t->listener->counters->denied_resp++;
3715
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3716 Alert("Blocking cacheable cookie in response from instance %s, server %s.\n",
3717 t->be->id, t->srv?t->srv->id:"<dispatch>");
3718 send_log(t->be, LOG_ALERT,
3719 "Blocking cacheable cookie in response from instance %s, server %s.\n",
3720 t->be->id, t->srv?t->srv->id:"<dispatch>");
3721 goto return_srv_prx_502;
3722 }
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]3723
3724 /*
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]3725 * 8: add "Connection: close" if needed and not yet set. This is
3726 * only needed for 1.1 responses since we know there is no other
3727 * Connection header.
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]3728 */
Willy Tarreau63c9e5f2009-12-22 16:01:27 +0100[diff] [blame]3729 if (must_close && (txn->flags & TX_RES_VER_11)) {
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]3730 if (unlikely(http_header_add_tail2(rep, &txn->rsp, &txn->hdr_idx,
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3731 "Connection: close", 17)) < 0)
3732 goto return_bad_resp;
Willy Tarreau5b154472009-12-21 20:11:07 +0100[diff] [blame]3733 must_close = 0;
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3734 }
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]3735
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]3736 /* If we're not expecting anything else, we're done with this request */
Willy Tarreau03945942009-12-22 16:50:27 +0100[diff] [blame]3737 if (((txn->flags & TX_CON_WANT_MSK) != TX_CON_WANT_TUN) &&
Willy Tarreaue8e785b2009-12-26 15:34:26 +0100[diff] [blame]3738 (txn->flags & TX_RES_XFER_LEN) &&
3739 !(txn->flags & TX_RES_TE_CHNK) && !msg->hdr_content_len)
Willy Tarreau03945942009-12-22 16:50:27 +0100[diff] [blame]3740 msg->msg_state = HTTP_MSG_DONE;
3741
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3742 /*************************************************************
3743 * OK, that's finished for the headers. We have done what we *
3744 * could. Let's switch to the DATA state. *
3745 ************************************************************/
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]3746
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3747 t->logs.t_data = tv_ms_elapsed(&t->logs.tv_accept, &now);
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]3748
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3749 /* if the user wants to log as soon as possible, without counting
3750 * bytes from the server, then this is the right moment. We have
3751 * to temporarily assign bytes_out to log what we currently have.
3752 */
3753 if (t->fe->to_log && !(t->logs.logwait & LW_BYTES)) {
3754 t->logs.t_close = t->logs.t_data; /* to get a valid end date */
3755 t->logs.bytes_out = txn->rsp.eoh;
Willy Tarreaua5555ec2008-11-30 19:02:32 +0100[diff] [blame]3756 t->do_log(t);
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3757 t->logs.bytes_out = 0;
3758 }
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]3759
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3760 /* Note: we must not try to cheat by jumping directly to DATA,
3761 * otherwise we would not let the client side wake up.
3762 */
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]3763
Willy Tarreaudafde432008-08-17 01:00:46 +0200[diff] [blame]3764 return 0;
Willy Tarreauf5483bf2008-08-14 18:35:40 +0200[diff] [blame]3765 }
3766 return 0;
3767}
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]3768
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3769/* Iterate the same filter through all request headers.
3770 * Returns 1 if this filter can be stopped upon return, otherwise 0.
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]3771 * Since it can manage the switch to another backend, it updates the per-proxy
3772 * DENY stats.
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]3773 */
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3774int apply_filter_to_req_headers(struct session *t, struct buffer *req, struct hdr_exp *exp)
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]3775{
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3776 char term;
3777 char *cur_ptr, *cur_end, *cur_next;
3778 int cur_idx, old_idx, last_hdr;
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]3779 struct http_txn *txn = &t->txn;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3780 struct hdr_idx_elem *cur_hdr;
3781 int len, delta;
Willy Tarreau0f7562b2007-01-07 15:46:13 +0100[diff] [blame]3782
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3783 last_hdr = 0;
3784
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]3785 cur_next = req->data + txn->req.som + hdr_idx_first_pos(&txn->hdr_idx);
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3786 old_idx = 0;
3787
3788 while (!last_hdr) {
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]3789 if (unlikely(txn->flags & (TX_CLDENY | TX_CLTARPIT)))
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3790 return 1;
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]3791 else if (unlikely(txn->flags & TX_CLALLOW) &&
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3792 (exp->action == ACT_ALLOW ||
3793 exp->action == ACT_DENY ||
3794 exp->action == ACT_TARPIT))
3795 return 0;
3796
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]3797 cur_idx = txn->hdr_idx.v[old_idx].next;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3798 if (!cur_idx)
3799 break;
3800
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]3801 cur_hdr = &txn->hdr_idx.v[cur_idx];
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3802 cur_ptr = cur_next;
3803 cur_end = cur_ptr + cur_hdr->len;
3804 cur_next = cur_end + cur_hdr->cr + 1;
3805
3806 /* Now we have one header between cur_ptr and cur_end,
3807 * and the next header starts at cur_next.
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]3808 */
3809
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3810 /* The annoying part is that pattern matching needs
3811 * that we modify the contents to null-terminate all
3812 * strings before testing them.
3813 */
3814
3815 term = *cur_end;
3816 *cur_end = '\0';
3817
3818 if (regexec(exp->preg, cur_ptr, MAX_MATCH, pmatch, 0) == 0) {
3819 switch (exp->action) {
3820 case ACT_SETBE:
3821 /* It is not possible to jump a second time.
3822 * FIXME: should we return an HTTP/500 here so that
3823 * the admin knows there's a problem ?
3824 */
3825 if (t->be != t->fe)
3826 break;
3827
3828 /* Swithing Proxy */
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]3829 session_set_backend(t, (struct proxy *)exp->replace);
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3830 last_hdr = 1;
3831 break;
3832
3833 case ACT_ALLOW:
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]3834 txn->flags |= TX_CLALLOW;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3835 last_hdr = 1;
3836 break;
3837
3838 case ACT_DENY:
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]3839 txn->flags |= TX_CLDENY;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3840 last_hdr = 1;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]3841
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]3842 t->be->counters.denied_req++;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]3843 if (t->listener->counters)
3844 t->listener->counters->denied_resp++;
3845
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3846 break;
3847
3848 case ACT_TARPIT:
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]3849 txn->flags |= TX_CLTARPIT;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3850 last_hdr = 1;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]3851
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]3852 t->be->counters.denied_req++;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]3853 if (t->listener->counters)
3854 t->listener->counters->denied_resp++;
3855
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3856 break;
3857
3858 case ACT_REPLACE:
3859 len = exp_replace(trash, cur_ptr, exp->replace, pmatch);
3860 delta = buffer_replace2(req, cur_ptr, cur_end, trash, len);
3861 /* FIXME: if the user adds a newline in the replacement, the
3862 * index will not be recalculated for now, and the new line
3863 * will not be counted as a new header.
3864 */
3865
3866 cur_end += delta;
3867 cur_next += delta;
3868 cur_hdr->len += delta;
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]3869 http_msg_move_end(&txn->req, delta);
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3870 break;
3871
3872 case ACT_REMOVE:
3873 delta = buffer_replace2(req, cur_ptr, cur_next, NULL, 0);
3874 cur_next += delta;
3875
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]3876 http_msg_move_end(&txn->req, delta);
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]3877 txn->hdr_idx.v[old_idx].next = cur_hdr->next;
3878 txn->hdr_idx.used--;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3879 cur_hdr->len = 0;
3880 cur_end = NULL; /* null-term has been rewritten */
3881 break;
3882
3883 }
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]3884 }
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3885 if (cur_end)
3886 *cur_end = term; /* restore the string terminator */
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]3887
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3888 /* keep the link from this header to next one in case of later
3889 * removal of next header.
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]3890 */
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3891 old_idx = cur_idx;
3892 }
3893 return 0;
3894}
3895
3896
3897/* Apply the filter to the request line.
3898 * Returns 0 if nothing has been done, 1 if the filter has been applied,
3899 * or -1 if a replacement resulted in an invalid request line.
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]3900 * Since it can manage the switch to another backend, it updates the per-proxy
3901 * DENY stats.
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3902 */
3903int apply_filter_to_req_line(struct session *t, struct buffer *req, struct hdr_exp *exp)
3904{
3905 char term;
3906 char *cur_ptr, *cur_end;
3907 int done;
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]3908 struct http_txn *txn = &t->txn;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3909 int len, delta;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]3910
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]3911
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]3912 if (unlikely(txn->flags & (TX_CLDENY | TX_CLTARPIT)))
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3913 return 1;
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]3914 else if (unlikely(txn->flags & TX_CLALLOW) &&
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3915 (exp->action == ACT_ALLOW ||
3916 exp->action == ACT_DENY ||
3917 exp->action == ACT_TARPIT))
3918 return 0;
3919 else if (exp->action == ACT_REMOVE)
3920 return 0;
3921
3922 done = 0;
3923
Willy Tarreau9cdde232007-05-02 20:58:19 +0200[diff] [blame]3924 cur_ptr = req->data + txn->req.som; /* should be equal to txn->sol */
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]3925 cur_end = cur_ptr + txn->req.sl.rq.l;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3926
3927 /* Now we have the request line between cur_ptr and cur_end */
3928
3929 /* The annoying part is that pattern matching needs
3930 * that we modify the contents to null-terminate all
3931 * strings before testing them.
3932 */
3933
3934 term = *cur_end;
3935 *cur_end = '\0';
3936
3937 if (regexec(exp->preg, cur_ptr, MAX_MATCH, pmatch, 0) == 0) {
3938 switch (exp->action) {
3939 case ACT_SETBE:
3940 /* It is not possible to jump a second time.
3941 * FIXME: should we return an HTTP/500 here so that
3942 * the admin knows there's a problem ?
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]3943 */
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3944 if (t->be != t->fe)
3945 break;
3946
3947 /* Swithing Proxy */
Willy Tarreau1d0dfb12009-07-07 15:10:31 +0200[diff] [blame]3948 session_set_backend(t, (struct proxy *)exp->replace);
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3949 done = 1;
3950 break;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]3951
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3952 case ACT_ALLOW:
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]3953 txn->flags |= TX_CLALLOW;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3954 done = 1;
3955 break;
Willy Tarreaua496b602006-12-17 23:15:24 +0100[diff] [blame]3956
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3957 case ACT_DENY:
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]3958 txn->flags |= TX_CLDENY;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]3959
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]3960 t->be->counters.denied_req++;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]3961 if (t->listener->counters)
3962 t->listener->counters->denied_resp++;
3963
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3964 done = 1;
3965 break;
Willy Tarreaua496b602006-12-17 23:15:24 +0100[diff] [blame]3966
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3967 case ACT_TARPIT:
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]3968 txn->flags |= TX_CLTARPIT;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]3969
Krzysztof Piotr Oledzki052d4fd2009-10-04 14:52:57 +0200[diff] [blame]3970 t->be->counters.denied_req++;
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200[diff] [blame]3971 if (t->listener->counters)
3972 t->listener->counters->denied_resp++;
3973
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3974 done = 1;
3975 break;
Willy Tarreaua496b602006-12-17 23:15:24 +0100[diff] [blame]3976
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3977 case ACT_REPLACE:
3978 *cur_end = term; /* restore the string terminator */
3979 len = exp_replace(trash, cur_ptr, exp->replace, pmatch);
3980 delta = buffer_replace2(req, cur_ptr, cur_end, trash, len);
3981 /* FIXME: if the user adds a newline in the replacement, the
3982 * index will not be recalculated for now, and the new line
3983 * will not be counted as a new header.
3984 */
Willy Tarreaua496b602006-12-17 23:15:24 +0100[diff] [blame]3985
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]3986 http_msg_move_end(&txn->req, delta);
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3987 cur_end += delta;
Willy Tarreaua496b602006-12-17 23:15:24 +0100[diff] [blame]3988
Willy Tarreau9cdde232007-05-02 20:58:19 +0200[diff] [blame]3989 txn->req.sol = req->data + txn->req.som; /* should be equal to txn->sol */
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]3990 cur_end = (char *)http_parse_reqline(&txn->req, req->data,
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3991 HTTP_MSG_RQMETH,
3992 cur_ptr, cur_end + 1,
3993 NULL, NULL);
3994 if (unlikely(!cur_end))
3995 return -1;
Willy Tarreaua496b602006-12-17 23:15:24 +0100[diff] [blame]3996
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]3997 /* we have a full request and we know that we have either a CR
3998 * or an LF at <ptr>.
3999 */
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]4000 txn->meth = find_http_meth(cur_ptr, txn->req.sl.rq.m_l);
4001 hdr_idx_set_start(&txn->hdr_idx, txn->req.sl.rq.l, *cur_end == '\r');
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]4002 /* there is no point trying this regex on headers */
4003 return 1;
4004 }
4005 }
4006 *cur_end = term; /* restore the string terminator */
4007 return done;
4008}
Willy Tarreau97de6242006-12-27 17:18:38 +0100[diff] [blame]4009
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4010
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4011
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]4012/*
4013 * Apply all the req filters <exp> to all headers in buffer <req> of session <t>.
4014 * Returns 0 if everything is alright, or -1 in case a replacement lead to an
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4015 * unparsable request. Since it can manage the switch to another backend, it
4016 * updates the per-proxy DENY stats.
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]4017 */
4018int apply_filters_to_request(struct session *t, struct buffer *req, struct hdr_exp *exp)
4019{
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4020 struct http_txn *txn = &t->txn;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]4021 /* iterate through the filters in the outer loop */
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4022 while (exp && !(txn->flags & (TX_CLDENY|TX_CLTARPIT))) {
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]4023 int ret;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4024
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]4025 /*
4026 * The interleaving of transformations and verdicts
4027 * makes it difficult to decide to continue or stop
4028 * the evaluation.
4029 */
4030
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4031 if ((txn->flags & TX_CLALLOW) &&
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]4032 (exp->action == ACT_ALLOW || exp->action == ACT_DENY ||
4033 exp->action == ACT_TARPIT || exp->action == ACT_PASS)) {
4034 exp = exp->next;
4035 continue;
4036 }
4037
4038 /* Apply the filter to the request line. */
4039 ret = apply_filter_to_req_line(t, req, exp);
4040 if (unlikely(ret < 0))
4041 return -1;
4042
4043 if (likely(ret == 0)) {
4044 /* The filter did not match the request, it can be
4045 * iterated through all headers.
4046 */
4047 apply_filter_to_req_headers(t, req, exp);
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4048 }
4049 exp = exp->next;
4050 }
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]4051 return 0;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4052}
4053
4054
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4055
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4056/*
Cyril Bontébf47aeb2009-10-15 00:15:40 +0200[diff] [blame]4057 * Try to retrieve the server associated to the appsession.
4058 * If the server is found, it's assigned to the session.
4059 */
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4060void manage_client_side_appsession(struct session *t, const char *buf, int len) {
Cyril Bontébf47aeb2009-10-15 00:15:40 +0200[diff] [blame]4061 struct http_txn *txn = &t->txn;
4062 appsess *asession = NULL;
4063 char *sessid_temp = NULL;
4064
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4065 if (len > t->be->appsession_len) {
4066 len = t->be->appsession_len;
4067 }
4068
Cyril Bontébf47aeb2009-10-15 00:15:40 +0200[diff] [blame]4069 if (t->be->options2 & PR_O2_AS_REQL) {
4070 /* request-learn option is enabled : store the sessid in the session for future use */
4071 if (t->sessid != NULL) {
4072 /* free previously allocated memory as we don't need the session id found in the URL anymore */
4073 pool_free2(apools.sessid, t->sessid);
4074 }
4075
4076 if ((t->sessid = pool_alloc2(apools.sessid)) == NULL) {
4077 Alert("Not enough memory process_cli():asession->sessid:malloc().\n");
4078 send_log(t->be, LOG_ALERT, "Not enough memory process_cli():asession->sessid:malloc().\n");
4079 return;
4080 }
4081
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4082 memcpy(t->sessid, buf, len);
4083 t->sessid[len] = 0;
Cyril Bontébf47aeb2009-10-15 00:15:40 +0200[diff] [blame]4084 }
4085
4086 if ((sessid_temp = pool_alloc2(apools.sessid)) == NULL) {
4087 Alert("Not enough memory process_cli():asession->sessid:malloc().\n");
4088 send_log(t->be, LOG_ALERT, "Not enough memory process_cli():asession->sessid:malloc().\n");
4089 return;
4090 }
4091
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4092 memcpy(sessid_temp, buf, len);
4093 sessid_temp[len] = 0;
Cyril Bontébf47aeb2009-10-15 00:15:40 +0200[diff] [blame]4094
4095 asession = appsession_hash_lookup(&(t->be->htbl_proxy), sessid_temp);
4096 /* free previously allocated memory */
4097 pool_free2(apools.sessid, sessid_temp);
4098
4099 if (asession != NULL) {
4100 asession->expire = tick_add_ifset(now_ms, t->be->timeout.appsession);
4101 if (!(t->be->options2 & PR_O2_AS_REQL))
4102 asession->request_count++;
4103
4104 if (asession->serverid != NULL) {
4105 struct server *srv = t->be->srv;
4106 while (srv) {
4107 if (strcmp(srv->id, asession->serverid) == 0) {
4108 if (srv->state & SRV_RUNNING || t->be->options & PR_O_PERSIST) {
4109 /* we found the server and it's usable */
4110 txn->flags &= ~TX_CK_MASK;
4111 txn->flags |= TX_CK_VALID;
4112 t->flags |= SN_DIRECT | SN_ASSIGNED;
4113 t->srv = srv;
4114 break;
4115 } else {
4116 txn->flags &= ~TX_CK_MASK;
4117 txn->flags |= TX_CK_DOWN;
4118 }
4119 }
4120 srv = srv->next;
4121 }
4122 }
4123 }
4124}
4125
4126/*
Willy Tarreau396d2c62007-11-04 19:30:00 +0100[diff] [blame]4127 * Manage client-side cookie. It can impact performance by about 2% so it is
4128 * desirable to call it only when needed.
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4129 */
4130void manage_client_side_cookies(struct session *t, struct buffer *req)
4131{
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]4132 struct http_txn *txn = &t->txn;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4133 char *p1, *p2, *p3, *p4;
4134 char *del_colon, *del_cookie, *colon;
4135 int app_cookies;
4136
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4137 char *cur_ptr, *cur_end, *cur_next;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]4138 int cur_idx, old_idx;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4139
Willy Tarreau2a324282006-12-05 00:05:46 +0100[diff] [blame]4140 /* Iterate through the headers.
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4141 * we start with the start line.
4142 */
Willy Tarreau83969f42007-01-22 08:55:47 +0100[diff] [blame]4143 old_idx = 0;
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]4144 cur_next = req->data + txn->req.som + hdr_idx_first_pos(&txn->hdr_idx);
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4145
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]4146 while ((cur_idx = txn->hdr_idx.v[old_idx].next)) {
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4147 struct hdr_idx_elem *cur_hdr;
Willy Tarreauaa9dce32007-03-18 23:50:16 +0100[diff] [blame]4148 int val;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4149
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]4150 cur_hdr = &txn->hdr_idx.v[cur_idx];
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4151 cur_ptr = cur_next;
4152 cur_end = cur_ptr + cur_hdr->len;
4153 cur_next = cur_end + cur_hdr->cr + 1;
4154
4155 /* We have one full header between cur_ptr and cur_end, and the
4156 * next header starts at cur_next. We're only interested in
4157 * "Cookie:" headers.
4158 */
4159
Willy Tarreauaa9dce32007-03-18 23:50:16 +0100[diff] [blame]4160 val = http_header_match2(cur_ptr, cur_end, "Cookie", 6);
4161 if (!val) {
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4162 old_idx = cur_idx;
4163 continue;
4164 }
4165
4166 /* Now look for cookies. Conforming to RFC2109, we have to support
4167 * attributes whose name begin with a '$', and associate them with
4168 * the right cookie, if we want to delete this cookie.
4169 * So there are 3 cases for each cookie read :
4170 * 1) it's a special attribute, beginning with a '$' : ignore it.
4171 * 2) it's a server id cookie that we *MAY* want to delete : save
4172 * some pointers on it (last semi-colon, beginning of cookie...)
4173 * 3) it's an application cookie : we *MAY* have to delete a previous
4174 * "special" cookie.
4175 * At the end of loop, if a "special" cookie remains, we may have to
4176 * remove it. If no application cookie persists in the header, we
4177 * *MUST* delete it
4178 */
4179
Willy Tarreauaa9dce32007-03-18 23:50:16 +0100[diff] [blame]4180 colon = p1 = cur_ptr + val; /* first non-space char after 'Cookie:' */
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4181
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4182 /* del_cookie == NULL => nothing to be deleted */
4183 del_colon = del_cookie = NULL;
4184 app_cookies = 0;
4185
4186 while (p1 < cur_end) {
4187 /* skip spaces and colons, but keep an eye on these ones */
4188 while (p1 < cur_end) {
4189 if (*p1 == ';' || *p1 == ',')
4190 colon = p1;
Willy Tarreau8f8e6452007-06-17 21:51:38 +0200[diff] [blame]4191 else if (!isspace((unsigned char)*p1))
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4192 break;
4193 p1++;
4194 }
4195
4196 if (p1 == cur_end)
4197 break;
4198
4199 /* p1 is at the beginning of the cookie name */
4200 p2 = p1;
4201 while (p2 < cur_end && *p2 != '=')
4202 p2++;
4203
4204 if (p2 == cur_end)
4205 break;
4206
4207 p3 = p2 + 1; /* skips the '=' sign */
4208 if (p3 == cur_end)
4209 break;
4210
4211 p4 = p3;
Willy Tarreau8f8e6452007-06-17 21:51:38 +0200[diff] [blame]4212 while (p4 < cur_end && !isspace((unsigned char)*p4) && *p4 != ';' && *p4 != ',')
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4213 p4++;
4214
4215 /* here, we have the cookie name between p1 and p2,
4216 * and its value between p3 and p4.
4217 * we can process it :
4218 *
4219 * Cookie: NAME=VALUE;
4220 * | || || |
4221 * | || || +--> p4
4222 * | || |+-------> p3
4223 * | || +--------> p2
4224 * | |+------------> p1
4225 * | +-------------> colon
4226 * +--------------------> cur_ptr
4227 */
4228
4229 if (*p1 == '$') {
4230 /* skip this one */
4231 }
4232 else {
4233 /* first, let's see if we want to capture it */
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]4234 if (t->fe->capture_name != NULL &&
Willy Tarreau3bac9ff2007-03-18 17:31:28 +0100[diff] [blame]4235 txn->cli_cookie == NULL &&
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]4236 (p4 - p1 >= t->fe->capture_namelen) &&
4237 memcmp(p1, t->fe->capture_name, t->fe->capture_namelen) == 0) {
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4238 int log_len = p4 - p1;
4239
Willy Tarreau086b3b42007-05-13 21:45:51 +0200[diff] [blame]4240 if ((txn->cli_cookie = pool_alloc2(pool2_capture)) == NULL) {
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4241 Alert("HTTP logging : out of memory.\n");
4242 } else {
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]4243 if (log_len > t->fe->capture_len)
4244 log_len = t->fe->capture_len;
Willy Tarreau3bac9ff2007-03-18 17:31:28 +0100[diff] [blame]4245 memcpy(txn->cli_cookie, p1, log_len);
4246 txn->cli_cookie[log_len] = 0;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4247 }
4248 }
4249
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]4250 if ((p2 - p1 == t->be->cookie_len) && (t->be->cookie_name != NULL) &&
4251 (memcmp(p1, t->be->cookie_name, p2 - p1) == 0)) {
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4252 /* Cool... it's the right one */
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]4253 struct server *srv = t->be->srv;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4254 char *delim;
4255
4256 /* if we're in cookie prefix mode, we'll search the delimitor so that we
4257 * have the server ID betweek p3 and delim, and the original cookie between
4258 * delim+1 and p4. Otherwise, delim==p4 :
4259 *
4260 * Cookie: NAME=SRV~VALUE;
4261 * | || || | |
4262 * | || || | +--> p4
4263 * | || || +--------> delim
4264 * | || |+-----------> p3
4265 * | || +------------> p2
4266 * | |+----------------> p1
4267 * | +-----------------> colon
4268 * +------------------------> cur_ptr
4269 */
4270
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]4271 if (t->be->options & PR_O_COOK_PFX) {
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4272 for (delim = p3; delim < p4; delim++)
4273 if (*delim == COOKIE_DELIM)
4274 break;
4275 }
4276 else
4277 delim = p4;
4278
4279
4280 /* Here, we'll look for the first running server which supports the cookie.
4281 * This allows to share a same cookie between several servers, for example
4282 * to dedicate backup servers to specific servers only.
4283 * However, to prevent clients from sticking to cookie-less backup server
4284 * when they have incidentely learned an empty cookie, we simply ignore
4285 * empty cookies and mark them as invalid.
4286 */
4287 if (delim == p3)
4288 srv = NULL;
4289
4290 while (srv) {
Willy Tarreau92f2ab12007-02-02 22:14:47 +0100[diff] [blame]4291 if (srv->cookie && (srv->cklen == delim - p3) &&
4292 !memcmp(p3, srv->cookie, delim - p3)) {
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]4293 if (srv->state & SRV_RUNNING || t->be->options & PR_O_PERSIST) {
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4294 /* we found the server and it's usable */
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4295 txn->flags &= ~TX_CK_MASK;
4296 txn->flags |= TX_CK_VALID;
4297 t->flags |= SN_DIRECT | SN_ASSIGNED;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4298 t->srv = srv;
4299 break;
4300 } else {
4301 /* we found a server, but it's down */
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4302 txn->flags &= ~TX_CK_MASK;
4303 txn->flags |= TX_CK_DOWN;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4304 }
4305 }
4306 srv = srv->next;
4307 }
4308
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4309 if (!srv && !(txn->flags & TX_CK_DOWN)) {
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4310 /* no server matched this cookie */
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4311 txn->flags &= ~TX_CK_MASK;
4312 txn->flags |= TX_CK_INVALID;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4313 }
4314
4315 /* depending on the cookie mode, we may have to either :
4316 * - delete the complete cookie if we're in insert+indirect mode, so that
4317 * the server never sees it ;
4318 * - remove the server id from the cookie value, and tag the cookie as an
4319 * application cookie so that it does not get accidentely removed later,
4320 * if we're in cookie prefix mode
4321 */
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]4322 if ((t->be->options & PR_O_COOK_PFX) && (delim != p4)) {
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4323 int delta; /* negative */
4324
4325 delta = buffer_replace2(req, p3, delim + 1, NULL, 0);
4326 p4 += delta;
4327 cur_end += delta;
4328 cur_next += delta;
4329 cur_hdr->len += delta;
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]4330 http_msg_move_end(&txn->req, delta);
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4331
4332 del_cookie = del_colon = NULL;
4333 app_cookies++; /* protect the header from deletion */
4334 }
4335 else if (del_cookie == NULL &&
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]4336 (t->be->options & (PR_O_COOK_INS | PR_O_COOK_IND)) == (PR_O_COOK_INS | PR_O_COOK_IND)) {
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4337 del_cookie = p1;
4338 del_colon = colon;
4339 }
4340 } else {
4341 /* now we know that we must keep this cookie since it's
4342 * not ours. But if we wanted to delete our cookie
4343 * earlier, we cannot remove the complete header, but we
4344 * can remove the previous block itself.
4345 */
4346 app_cookies++;
4347
4348 if (del_cookie != NULL) {
4349 int delta; /* negative */
4350
4351 delta = buffer_replace2(req, del_cookie, p1, NULL, 0);
4352 p4 += delta;
4353 cur_end += delta;
4354 cur_next += delta;
4355 cur_hdr->len += delta;
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]4356 http_msg_move_end(&txn->req, delta);
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4357 del_cookie = del_colon = NULL;
4358 }
4359 }
4360
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4361 if (t->be->appsession_name != NULL) {
4362 int cmp_len, value_len;
4363 char *value_begin;
Aleksandar Lazic697bbb02008-08-13 19:57:02 +0200[diff] [blame]4364
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4365 if (t->be->options2 & PR_O2_AS_PFX) {
4366 cmp_len = MIN(p4 - p1, t->be->appsession_name_len);
4367 value_begin = p1 + t->be->appsession_name_len;
4368 value_len = p4 - p1 - t->be->appsession_name_len;
4369 } else {
4370 cmp_len = p2 - p1;
4371 value_begin = p3;
4372 value_len = p4 - p3;
4373 }
4374
4375 /* let's see if the cookie is our appcookie */
4376 if (memcmp(p1, t->be->appsession_name, cmp_len) == 0) {
4377 /* Cool... it's the right one */
4378 manage_client_side_appsession(t, value_begin, value_len);
4379 }
Aleksandar Lazic697bbb02008-08-13 19:57:02 +0200[diff] [blame]4380#if defined(DEBUG_HASH)
4381 Alert("manage_client_side_cookies\n");
4382 appsession_hash_dump(&(t->be->htbl_proxy));
4383#endif
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4384 }/* end if ((t->proxy->appsession_name != NULL) ... */
4385 }
4386
4387 /* we'll have to look for another cookie ... */
4388 p1 = p4;
4389 } /* while (p1 < cur_end) */
4390
4391 /* There's no more cookie on this line.
4392 * We may have marked the last one(s) for deletion.
4393 * We must do this now in two ways :
4394 * - if there is no app cookie, we simply delete the header ;
4395 * - if there are app cookies, we must delete the end of the
4396 * string properly, including the colon/semi-colon before
4397 * the cookie name.
4398 */
4399 if (del_cookie != NULL) {
4400 int delta;
4401 if (app_cookies) {
4402 delta = buffer_replace2(req, del_colon, cur_end, NULL, 0);
4403 cur_end = del_colon;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4404 cur_hdr->len += delta;
4405 } else {
4406 delta = buffer_replace2(req, cur_ptr, cur_next, NULL, 0);
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4407
4408 /* FIXME: this should be a separate function */
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]4409 txn->hdr_idx.v[old_idx].next = cur_hdr->next;
4410 txn->hdr_idx.used--;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4411 cur_hdr->len = 0;
4412 }
Willy Tarreau45e73e32006-12-17 00:05:15 +0100[diff] [blame]4413 cur_next += delta;
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]4414 http_msg_move_end(&txn->req, delta);
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4415 }
4416
4417 /* keep the link from this header to next one */
4418 old_idx = cur_idx;
4419 } /* end of cookie processing on this header */
4420}
4421
4422
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4423/* Iterate the same filter through all response headers contained in <rtr>.
4424 * Returns 1 if this filter can be stopped upon return, otherwise 0.
4425 */
4426int apply_filter_to_resp_headers(struct session *t, struct buffer *rtr, struct hdr_exp *exp)
4427{
4428 char term;
4429 char *cur_ptr, *cur_end, *cur_next;
4430 int cur_idx, old_idx, last_hdr;
4431 struct http_txn *txn = &t->txn;
4432 struct hdr_idx_elem *cur_hdr;
4433 int len, delta;
4434
4435 last_hdr = 0;
4436
4437 cur_next = rtr->data + txn->rsp.som + hdr_idx_first_pos(&txn->hdr_idx);
4438 old_idx = 0;
4439
4440 while (!last_hdr) {
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4441 if (unlikely(txn->flags & TX_SVDENY))
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4442 return 1;
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4443 else if (unlikely(txn->flags & TX_SVALLOW) &&
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4444 (exp->action == ACT_ALLOW ||
4445 exp->action == ACT_DENY))
4446 return 0;
4447
4448 cur_idx = txn->hdr_idx.v[old_idx].next;
4449 if (!cur_idx)
4450 break;
4451
4452 cur_hdr = &txn->hdr_idx.v[cur_idx];
4453 cur_ptr = cur_next;
4454 cur_end = cur_ptr + cur_hdr->len;
4455 cur_next = cur_end + cur_hdr->cr + 1;
4456
4457 /* Now we have one header between cur_ptr and cur_end,
4458 * and the next header starts at cur_next.
4459 */
4460
4461 /* The annoying part is that pattern matching needs
4462 * that we modify the contents to null-terminate all
4463 * strings before testing them.
4464 */
4465
4466 term = *cur_end;
4467 *cur_end = '\0';
4468
4469 if (regexec(exp->preg, cur_ptr, MAX_MATCH, pmatch, 0) == 0) {
4470 switch (exp->action) {
4471 case ACT_ALLOW:
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4472 txn->flags |= TX_SVALLOW;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4473 last_hdr = 1;
4474 break;
4475
4476 case ACT_DENY:
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4477 txn->flags |= TX_SVDENY;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4478 last_hdr = 1;
4479 break;
4480
4481 case ACT_REPLACE:
4482 len = exp_replace(trash, cur_ptr, exp->replace, pmatch);
4483 delta = buffer_replace2(rtr, cur_ptr, cur_end, trash, len);
4484 /* FIXME: if the user adds a newline in the replacement, the
4485 * index will not be recalculated for now, and the new line
4486 * will not be counted as a new header.
4487 */
4488
4489 cur_end += delta;
4490 cur_next += delta;
4491 cur_hdr->len += delta;
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]4492 http_msg_move_end(&txn->rsp, delta);
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4493 break;
4494
4495 case ACT_REMOVE:
4496 delta = buffer_replace2(rtr, cur_ptr, cur_next, NULL, 0);
4497 cur_next += delta;
4498
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]4499 http_msg_move_end(&txn->rsp, delta);
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4500 txn->hdr_idx.v[old_idx].next = cur_hdr->next;
4501 txn->hdr_idx.used--;
4502 cur_hdr->len = 0;
4503 cur_end = NULL; /* null-term has been rewritten */
4504 break;
4505
4506 }
4507 }
4508 if (cur_end)
4509 *cur_end = term; /* restore the string terminator */
4510
4511 /* keep the link from this header to next one in case of later
4512 * removal of next header.
4513 */
4514 old_idx = cur_idx;
4515 }
4516 return 0;
4517}
4518
4519
4520/* Apply the filter to the status line in the response buffer <rtr>.
4521 * Returns 0 if nothing has been done, 1 if the filter has been applied,
4522 * or -1 if a replacement resulted in an invalid status line.
4523 */
4524int apply_filter_to_sts_line(struct session *t, struct buffer *rtr, struct hdr_exp *exp)
4525{
4526 char term;
4527 char *cur_ptr, *cur_end;
4528 int done;
4529 struct http_txn *txn = &t->txn;
4530 int len, delta;
4531
4532
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4533 if (unlikely(txn->flags & TX_SVDENY))
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4534 return 1;
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4535 else if (unlikely(txn->flags & TX_SVALLOW) &&
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4536 (exp->action == ACT_ALLOW ||
4537 exp->action == ACT_DENY))
4538 return 0;
4539 else if (exp->action == ACT_REMOVE)
4540 return 0;
4541
4542 done = 0;
4543
Willy Tarreau9cdde232007-05-02 20:58:19 +0200[diff] [blame]4544 cur_ptr = rtr->data + txn->rsp.som; /* should be equal to txn->sol */
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4545 cur_end = cur_ptr + txn->rsp.sl.rq.l;
4546
4547 /* Now we have the status line between cur_ptr and cur_end */
4548
4549 /* The annoying part is that pattern matching needs
4550 * that we modify the contents to null-terminate all
4551 * strings before testing them.
4552 */
4553
4554 term = *cur_end;
4555 *cur_end = '\0';
4556
4557 if (regexec(exp->preg, cur_ptr, MAX_MATCH, pmatch, 0) == 0) {
4558 switch (exp->action) {
4559 case ACT_ALLOW:
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4560 txn->flags |= TX_SVALLOW;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4561 done = 1;
4562 break;
4563
4564 case ACT_DENY:
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4565 txn->flags |= TX_SVDENY;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4566 done = 1;
4567 break;
4568
4569 case ACT_REPLACE:
4570 *cur_end = term; /* restore the string terminator */
4571 len = exp_replace(trash, cur_ptr, exp->replace, pmatch);
4572 delta = buffer_replace2(rtr, cur_ptr, cur_end, trash, len);
4573 /* FIXME: if the user adds a newline in the replacement, the
4574 * index will not be recalculated for now, and the new line
4575 * will not be counted as a new header.
4576 */
4577
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]4578 http_msg_move_end(&txn->rsp, delta);
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4579 cur_end += delta;
4580
Willy Tarreau9cdde232007-05-02 20:58:19 +0200[diff] [blame]4581 txn->rsp.sol = rtr->data + txn->rsp.som; /* should be equal to txn->sol */
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4582 cur_end = (char *)http_parse_stsline(&txn->rsp, rtr->data,
Willy Tarreau02785762007-04-03 14:45:44 +0200[diff] [blame]4583 HTTP_MSG_RPVER,
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4584 cur_ptr, cur_end + 1,
4585 NULL, NULL);
4586 if (unlikely(!cur_end))
4587 return -1;
4588
4589 /* we have a full respnse and we know that we have either a CR
4590 * or an LF at <ptr>.
4591 */
Willy Tarreau3bac9ff2007-03-18 17:31:28 +0100[diff] [blame]4592 txn->status = strl2ui(rtr->data + txn->rsp.sl.st.c, txn->rsp.sl.st.c_l);
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4593 hdr_idx_set_start(&txn->hdr_idx, txn->rsp.sl.rq.l, *cur_end == '\r');
4594 /* there is no point trying this regex on headers */
4595 return 1;
4596 }
4597 }
4598 *cur_end = term; /* restore the string terminator */
4599 return done;
4600}
4601
4602
4603
4604/*
4605 * Apply all the resp filters <exp> to all headers in buffer <rtr> of session <t>.
4606 * Returns 0 if everything is alright, or -1 in case a replacement lead to an
4607 * unparsable response.
4608 */
4609int apply_filters_to_response(struct session *t, struct buffer *rtr, struct hdr_exp *exp)
4610{
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4611 struct http_txn *txn = &t->txn;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4612 /* iterate through the filters in the outer loop */
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4613 while (exp && !(txn->flags & TX_SVDENY)) {
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4614 int ret;
4615
4616 /*
4617 * The interleaving of transformations and verdicts
4618 * makes it difficult to decide to continue or stop
4619 * the evaluation.
4620 */
4621
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4622 if ((txn->flags & TX_SVALLOW) &&
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4623 (exp->action == ACT_ALLOW || exp->action == ACT_DENY ||
4624 exp->action == ACT_PASS)) {
4625 exp = exp->next;
4626 continue;
4627 }
4628
4629 /* Apply the filter to the status line. */
4630 ret = apply_filter_to_sts_line(t, rtr, exp);
4631 if (unlikely(ret < 0))
4632 return -1;
4633
4634 if (likely(ret == 0)) {
4635 /* The filter did not match the response, it can be
4636 * iterated through all headers.
4637 */
4638 apply_filter_to_resp_headers(t, rtr, exp);
4639 }
4640 exp = exp->next;
4641 }
4642 return 0;
4643}
4644
4645
4646
4647/*
Willy Tarreau396d2c62007-11-04 19:30:00 +0100[diff] [blame]4648 * Manage server-side cookies. It can impact performance by about 2% so it is
4649 * desirable to call it only when needed.
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4650 */
4651void manage_server_side_cookies(struct session *t, struct buffer *rtr)
4652{
4653 struct http_txn *txn = &t->txn;
4654 char *p1, *p2, *p3, *p4;
4655
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4656 char *cur_ptr, *cur_end, *cur_next;
4657 int cur_idx, old_idx, delta;
4658
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4659 /* Iterate through the headers.
4660 * we start with the start line.
4661 */
4662 old_idx = 0;
4663 cur_next = rtr->data + txn->rsp.som + hdr_idx_first_pos(&txn->hdr_idx);
4664
4665 while ((cur_idx = txn->hdr_idx.v[old_idx].next)) {
4666 struct hdr_idx_elem *cur_hdr;
Willy Tarreauaa9dce32007-03-18 23:50:16 +0100[diff] [blame]4667 int val;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4668
4669 cur_hdr = &txn->hdr_idx.v[cur_idx];
4670 cur_ptr = cur_next;
4671 cur_end = cur_ptr + cur_hdr->len;
4672 cur_next = cur_end + cur_hdr->cr + 1;
4673
4674 /* We have one full header between cur_ptr and cur_end, and the
4675 * next header starts at cur_next. We're only interested in
4676 * "Cookie:" headers.
4677 */
4678
Willy Tarreauaa9dce32007-03-18 23:50:16 +0100[diff] [blame]4679 val = http_header_match2(cur_ptr, cur_end, "Set-Cookie", 10);
4680 if (!val) {
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4681 old_idx = cur_idx;
4682 continue;
4683 }
4684
4685 /* OK, right now we know we have a set-cookie at cur_ptr */
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4686 txn->flags |= TX_SCK_ANY;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4687
4688
Willy Tarreaufd39dda2008-10-17 12:01:58 +0200[diff] [blame]4689 /* maybe we only wanted to see if there was a set-cookie. Note that
4690 * the cookie capture is declared in the fronend.
4691 */
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]4692 if (t->be->cookie_name == NULL &&
4693 t->be->appsession_name == NULL &&
Willy Tarreaufd39dda2008-10-17 12:01:58 +0200[diff] [blame]4694 t->fe->capture_name == NULL)
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4695 return;
4696
Willy Tarreauaa9dce32007-03-18 23:50:16 +0100[diff] [blame]4697 p1 = cur_ptr + val; /* first non-space char after 'Set-Cookie:' */
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4698
4699 while (p1 < cur_end) { /* in fact, we'll break after the first cookie */
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4700 if (p1 == cur_end || *p1 == ';') /* end of cookie */
4701 break;
4702
4703 /* p1 is at the beginning of the cookie name */
4704 p2 = p1;
4705
4706 while (p2 < cur_end && *p2 != '=' && *p2 != ';')
4707 p2++;
4708
4709 if (p2 == cur_end || *p2 == ';') /* next cookie */
4710 break;
4711
4712 p3 = p2 + 1; /* skip the '=' sign */
4713 if (p3 == cur_end)
4714 break;
4715
4716 p4 = p3;
Willy Tarreau8f8e6452007-06-17 21:51:38 +0200[diff] [blame]4717 while (p4 < cur_end && !isspace((unsigned char)*p4) && *p4 != ';')
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4718 p4++;
4719
4720 /* here, we have the cookie name between p1 and p2,
4721 * and its value between p3 and p4.
4722 * we can process it.
4723 */
4724
4725 /* first, let's see if we want to capture it */
Willy Tarreaufd39dda2008-10-17 12:01:58 +0200[diff] [blame]4726 if (t->fe->capture_name != NULL &&
Willy Tarreau3bac9ff2007-03-18 17:31:28 +0100[diff] [blame]4727 txn->srv_cookie == NULL &&
Willy Tarreaufd39dda2008-10-17 12:01:58 +0200[diff] [blame]4728 (p4 - p1 >= t->fe->capture_namelen) &&
4729 memcmp(p1, t->fe->capture_name, t->fe->capture_namelen) == 0) {
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4730 int log_len = p4 - p1;
4731
Willy Tarreau086b3b42007-05-13 21:45:51 +0200[diff] [blame]4732 if ((txn->srv_cookie = pool_alloc2(pool2_capture)) == NULL) {
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4733 Alert("HTTP logging : out of memory.\n");
4734 }
4735
Willy Tarreaufd39dda2008-10-17 12:01:58 +0200[diff] [blame]4736 if (log_len > t->fe->capture_len)
4737 log_len = t->fe->capture_len;
Willy Tarreau3bac9ff2007-03-18 17:31:28 +0100[diff] [blame]4738 memcpy(txn->srv_cookie, p1, log_len);
4739 txn->srv_cookie[log_len] = 0;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4740 }
4741
4742 /* now check if we need to process it for persistence */
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]4743 if ((p2 - p1 == t->be->cookie_len) && (t->be->cookie_name != NULL) &&
4744 (memcmp(p1, t->be->cookie_name, p2 - p1) == 0)) {
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4745 /* Cool... it's the right one */
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4746 txn->flags |= TX_SCK_SEEN;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4747
4748 /* If the cookie is in insert mode on a known server, we'll delete
4749 * this occurrence because we'll insert another one later.
4750 * We'll delete it too if the "indirect" option is set and we're in
4751 * a direct access. */
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]4752 if (((t->srv) && (t->be->options & PR_O_COOK_INS)) ||
4753 ((t->flags & SN_DIRECT) && (t->be->options & PR_O_COOK_IND))) {
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4754 /* this header must be deleted */
4755 delta = buffer_replace2(rtr, cur_ptr, cur_next, NULL, 0);
4756 txn->hdr_idx.v[old_idx].next = cur_hdr->next;
4757 txn->hdr_idx.used--;
4758 cur_hdr->len = 0;
4759 cur_next += delta;
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]4760 http_msg_move_end(&txn->rsp, delta);
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4761
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4762 txn->flags |= TX_SCK_DELETED;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4763 }
4764 else if ((t->srv) && (t->srv->cookie) &&
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]4765 (t->be->options & PR_O_COOK_RW)) {
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4766 /* replace bytes p3->p4 with the cookie name associated
4767 * with this server since we know it.
4768 */
4769 delta = buffer_replace2(rtr, p3, p4, t->srv->cookie, t->srv->cklen);
4770 cur_hdr->len += delta;
4771 cur_next += delta;
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]4772 http_msg_move_end(&txn->rsp, delta);
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4773
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4774 txn->flags |= TX_SCK_INSERTED | TX_SCK_DELETED;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4775 }
4776 else if ((t->srv) && (t->srv->cookie) &&
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]4777 (t->be->options & PR_O_COOK_PFX)) {
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4778 /* insert the cookie name associated with this server
4779 * before existing cookie, and insert a delimitor between them..
4780 */
4781 delta = buffer_replace2(rtr, p3, p3, t->srv->cookie, t->srv->cklen + 1);
4782 cur_hdr->len += delta;
4783 cur_next += delta;
Willy Tarreaufa355d42009-11-29 18:12:29 +0100[diff] [blame]4784 http_msg_move_end(&txn->rsp, delta);
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4785
4786 p3[t->srv->cklen] = COOKIE_DELIM;
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4787 txn->flags |= TX_SCK_INSERTED | TX_SCK_DELETED;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4788 }
4789 }
4790 /* next, let's see if the cookie is our appcookie */
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4791 else if (t->be->appsession_name != NULL) {
4792 int cmp_len, value_len;
4793 char *value_begin;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4794
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4795 if (t->be->options2 & PR_O2_AS_PFX) {
4796 cmp_len = MIN(p4 - p1, t->be->appsession_name_len);
4797 value_begin = p1 + t->be->appsession_name_len;
4798 value_len = MIN(t->be->appsession_len, p4 - p1 - t->be->appsession_name_len);
4799 } else {
4800 cmp_len = p2 - p1;
4801 value_begin = p3;
4802 value_len = MIN(t->be->appsession_len, p4 - p3);
Cyril Bontébf47aeb2009-10-15 00:15:40 +0200[diff] [blame]4803 }
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4804
4805 if (memcmp(p1, t->be->appsession_name, cmp_len) == 0) {
4806 /* Cool... it's the right one */
4807 if (t->sessid != NULL) {
4808 /* free previously allocated memory as we don't need it anymore */
4809 pool_free2(apools.sessid, t->sessid);
4810 }
4811 /* Store the sessid in the session for future use */
4812 if ((t->sessid = pool_alloc2(apools.sessid)) == NULL) {
4813 Alert("Not enough Memory process_srv():asession->sessid:malloc().\n");
4814 send_log(t->be, LOG_ALERT, "Not enough Memory process_srv():asession->sessid:malloc().\n");
4815 return;
4816 }
4817 memcpy(t->sessid, value_begin, value_len);
4818 t->sessid[value_len] = 0;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4819 }
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4820 } /* end if ((t->be->appsession_name != NULL) ... */
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4821 break; /* we don't want to loop again since there cannot be another cookie on the same line */
4822 } /* we're now at the end of the cookie value */
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4823 /* keep the link from this header to next one */
4824 old_idx = cur_idx;
4825 } /* end of cookie processing on this header */
Cyril Bontébf47aeb2009-10-15 00:15:40 +0200[diff] [blame]4826
4827 if (t->sessid != NULL) {
4828 appsess *asession = NULL;
4829 /* only do insert, if lookup fails */
4830 asession = appsession_hash_lookup(&(t->be->htbl_proxy), t->sessid);
4831 if (asession == NULL) {
4832 if ((asession = pool_alloc2(pool2_appsess)) == NULL) {
4833 Alert("Not enough Memory process_srv():asession:calloc().\n");
4834 send_log(t->be, LOG_ALERT, "Not enough Memory process_srv():asession:calloc().\n");
4835 return;
4836 }
4837 if ((asession->sessid = pool_alloc2(apools.sessid)) == NULL) {
4838 Alert("Not enough Memory process_srv():asession->sessid:malloc().\n");
4839 send_log(t->be, LOG_ALERT, "Not enough Memory process_srv():asession->sessid:malloc().\n");
4840 return;
4841 }
4842 memcpy(asession->sessid, t->sessid, t->be->appsession_len);
4843 asession->sessid[t->be->appsession_len] = 0;
4844
4845 size_t server_id_len = strlen(t->srv->id) + 1;
4846 if ((asession->serverid = pool_alloc2(apools.serverid)) == NULL) {
4847 Alert("Not enough Memory process_srv():asession->sessid:malloc().\n");
4848 send_log(t->be, LOG_ALERT, "Not enough Memory process_srv():asession->sessid:malloc().\n");
4849 return;
4850 }
4851 asession->serverid[0] = '\0';
4852 memcpy(asession->serverid, t->srv->id, server_id_len);
4853
4854 asession->request_count = 0;
4855 appsession_hash_insert(&(t->be->htbl_proxy), asession);
4856 }
4857
4858 asession->expire = tick_add_ifset(now_ms, t->be->timeout.appsession);
4859 asession->request_count++;
4860 }
4861
4862#if defined(DEBUG_HASH)
4863 Alert("manage_server_side_cookies\n");
4864 appsession_hash_dump(&(t->be->htbl_proxy));
4865#endif
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4866}
4867
4868
4869
4870/*
4871 * Check if response is cacheable or not. Updates t->flags.
4872 */
4873void check_response_for_cacheability(struct session *t, struct buffer *rtr)
4874{
4875 struct http_txn *txn = &t->txn;
4876 char *p1, *p2;
4877
4878 char *cur_ptr, *cur_end, *cur_next;
4879 int cur_idx;
4880
Willy Tarreau5df51872007-11-25 16:20:08 +0100[diff] [blame]4881 if (!(txn->flags & TX_CACHEABLE))
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4882 return;
4883
4884 /* Iterate through the headers.
4885 * we start with the start line.
4886 */
4887 cur_idx = 0;
4888 cur_next = rtr->data + txn->rsp.som + hdr_idx_first_pos(&txn->hdr_idx);
4889
4890 while ((cur_idx = txn->hdr_idx.v[cur_idx].next)) {
4891 struct hdr_idx_elem *cur_hdr;
Willy Tarreauaa9dce32007-03-18 23:50:16 +0100[diff] [blame]4892 int val;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4893
4894 cur_hdr = &txn->hdr_idx.v[cur_idx];
4895 cur_ptr = cur_next;
4896 cur_end = cur_ptr + cur_hdr->len;
4897 cur_next = cur_end + cur_hdr->cr + 1;
4898
4899 /* We have one full header between cur_ptr and cur_end, and the
4900 * next header starts at cur_next. We're only interested in
4901 * "Cookie:" headers.
4902 */
4903
Willy Tarreauaa9dce32007-03-18 23:50:16 +0100[diff] [blame]4904 val = http_header_match2(cur_ptr, cur_end, "Pragma", 6);
4905 if (val) {
4906 if ((cur_end - (cur_ptr + val) >= 8) &&
4907 strncasecmp(cur_ptr + val, "no-cache", 8) == 0) {
4908 txn->flags &= ~TX_CACHEABLE & ~TX_CACHE_COOK;
4909 return;
4910 }
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4911 }
4912
Willy Tarreauaa9dce32007-03-18 23:50:16 +0100[diff] [blame]4913 val = http_header_match2(cur_ptr, cur_end, "Cache-control", 13);
4914 if (!val)
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4915 continue;
4916
4917 /* OK, right now we know we have a cache-control header at cur_ptr */
4918
Willy Tarreauaa9dce32007-03-18 23:50:16 +0100[diff] [blame]4919 p1 = cur_ptr + val; /* first non-space char after 'cache-control:' */
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4920
4921 if (p1 >= cur_end) /* no more info */
4922 continue;
4923
4924 /* p1 is at the beginning of the value */
4925 p2 = p1;
4926
Willy Tarreau8f8e6452007-06-17 21:51:38 +0200[diff] [blame]4927 while (p2 < cur_end && *p2 != '=' && *p2 != ',' && !isspace((unsigned char)*p2))
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4928 p2++;
4929
4930 /* we have a complete value between p1 and p2 */
4931 if (p2 < cur_end && *p2 == '=') {
4932 /* we have something of the form no-cache="set-cookie" */
4933 if ((cur_end - p1 >= 21) &&
4934 strncasecmp(p1, "no-cache=\"set-cookie", 20) == 0
4935 && (p1[20] == '"' || p1[20] == ','))
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4936 txn->flags &= ~TX_CACHE_COOK;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4937 continue;
4938 }
4939
4940 /* OK, so we know that either p2 points to the end of string or to a comma */
4941 if (((p2 - p1 == 7) && strncasecmp(p1, "private", 7) == 0) ||
4942 ((p2 - p1 == 8) && strncasecmp(p1, "no-store", 8) == 0) ||
4943 ((p2 - p1 == 9) && strncasecmp(p1, "max-age=0", 9) == 0) ||
4944 ((p2 - p1 == 10) && strncasecmp(p1, "s-maxage=0", 10) == 0)) {
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4945 txn->flags &= ~TX_CACHEABLE & ~TX_CACHE_COOK;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4946 return;
4947 }
4948
4949 if ((p2 - p1 == 6) && strncasecmp(p1, "public", 6) == 0) {
Willy Tarreau3d300592007-03-18 18:34:41 +0100[diff] [blame]4950 txn->flags |= TX_CACHEABLE | TX_CACHE_COOK;
Willy Tarreaua15645d2007-03-18 16:22:39 +0100[diff] [blame]4951 continue;
4952 }
4953 }
4954}
4955
4956
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4957/*
4958 * Try to retrieve a known appsession in the URI, then the associated server.
4959 * If the server is found, it's assigned to the session.
4960 */
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]4961void get_srv_from_appsession(struct session *t, const char *begin, int len)
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4962{
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4963 char *end_params, *first_param, *cur_param, *next_param;
4964 char separator;
4965 int value_len;
4966
4967 int mode = t->be->options2 & PR_O2_AS_M_ANY;
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4968
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]4969 if (t->be->appsession_name == NULL ||
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4970 (t->txn.meth != HTTP_METH_GET && t->txn.meth != HTTP_METH_POST)) {
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4971 return;
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4972 }
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4973
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4974 first_param = NULL;
4975 switch (mode) {
4976 case PR_O2_AS_M_PP:
4977 first_param = memchr(begin, ';', len);
4978 break;
4979 case PR_O2_AS_M_QS:
4980 first_param = memchr(begin, '?', len);
4981 break;
4982 }
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4983
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4984 if (first_param == NULL) {
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4985 return;
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4986 }
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]4987
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]4988 switch (mode) {
4989 case PR_O2_AS_M_PP:
4990 if ((end_params = memchr(first_param, '?', len - (begin - first_param))) == NULL) {
4991 end_params = (char *) begin + len;
4992 }
4993 separator = ';';
4994 break;
4995 case PR_O2_AS_M_QS:
4996 end_params = (char *) begin + len;
4997 separator = '&';
4998 break;
4999 default:
5000 /* unknown mode, shouldn't happen */
5001 return;
5002 }
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]5003
Cyril Bontéb21570a2009-11-29 20:04:48 +0100[diff] [blame]5004 cur_param = next_param = end_params;
5005 while (cur_param > first_param) {
5006 cur_param--;
5007 if ((cur_param[0] == separator) || (cur_param == first_param)) {
5008 /* let's see if this is the appsession parameter */
5009 if ((cur_param + t->be->appsession_name_len + 1 < next_param) &&
5010 ((t->be->options2 & PR_O2_AS_PFX) || cur_param[t->be->appsession_name_len + 1] == '=') &&
5011 (strncasecmp(cur_param + 1, t->be->appsession_name, t->be->appsession_name_len) == 0)) {
5012 /* Cool... it's the right one */
5013 cur_param += t->be->appsession_name_len + (t->be->options2 & PR_O2_AS_PFX ? 1 : 2);
5014 value_len = MIN(t->be->appsession_len, next_param - cur_param);
5015 if (value_len > 0) {
5016 manage_client_side_appsession(t, cur_param, value_len);
5017 }
5018 break;
5019 }
5020 next_param = cur_param;
5021 }
5022 }
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]5023#if defined(DEBUG_HASH)
Aleksandar Lazic697bbb02008-08-13 19:57:02 +0200[diff] [blame]5024 Alert("get_srv_from_appsession\n");
Willy Tarreau51041c72007-09-09 21:56:53 +0200[diff] [blame]5025 appsession_hash_dump(&(t->be->htbl_proxy));
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]5026#endif
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]5027}
5028
5029
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5030/*
Willy Tarreau0214c3a2007-01-07 13:47:30 +0100[diff] [blame]5031 * In a GET or HEAD request, check if the requested URI matches the stats uri
5032 * for the current backend, and if an authorization has been passed and is valid.
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5033 *
Willy Tarreau0214c3a2007-01-07 13:47:30 +0100[diff] [blame]5034 * It is assumed that the request is either a HEAD or GET and that the
Willy Tarreaue2e27a52007-04-01 00:01:37 +0200[diff] [blame]5035 * t->be->uri_auth field is valid. An HTTP/401 response may be sent, or
Willy Tarreaub0c9bc42009-10-04 15:56:38 +0200[diff] [blame]5036 * the stats I/O handler will be registered to start sending data.
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5037 *
5038 * Returns 1 if the session's state changes, otherwise 0.
5039 */
5040int stats_check_uri_auth(struct session *t, struct proxy *backend)
5041{
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]5042 struct http_txn *txn = &t->txn;
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5043 struct uri_auth *uri_auth = backend->uri_auth;
5044 struct user_auth *user;
5045 int authenticated, cur_idx;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]5046 char *h;
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5047
Willy Tarreau39f7e6d2008-03-17 21:38:24 +0100[diff] [blame]5048 memset(&t->data_ctx.stats, 0, sizeof(t->data_ctx.stats));
5049
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]5050 /* check URI size */
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]5051 if (uri_auth->uri_len > txn->req.sl.rq.u_l)
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5052 return 0;
5053
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]5054 h = t->req->data + txn->req.sl.rq.u;
Willy Tarreau8d5d7f22007-01-21 19:16:41 +0100[diff] [blame]5055
Willy Tarreau0214c3a2007-01-07 13:47:30 +0100[diff] [blame]5056 /* the URI is in h */
5057 if (memcmp(h, uri_auth->uri_prefix, uri_auth->uri_len) != 0)
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5058 return 0;
5059
Willy Tarreaue7150cd2007-07-25 14:43:32 +0200[diff] [blame]5060 h += uri_auth->uri_len;
5061 while (h <= t->req->data + txn->req.sl.rq.u + txn->req.sl.rq.u_l - 3) {
5062 if (memcmp(h, ";up", 3) == 0) {
Willy Tarreau39f7e6d2008-03-17 21:38:24 +0100[diff] [blame]5063 t->data_ctx.stats.flags |= STAT_HIDE_DOWN;
Willy Tarreaue7150cd2007-07-25 14:43:32 +0200[diff] [blame]5064 break;
5065 }
5066 h++;
5067 }
5068
5069 if (uri_auth->refresh) {
5070 h = t->req->data + txn->req.sl.rq.u + uri_auth->uri_len;
5071 while (h <= t->req->data + txn->req.sl.rq.u + txn->req.sl.rq.u_l - 10) {
5072 if (memcmp(h, ";norefresh", 10) == 0) {
Willy Tarreau39f7e6d2008-03-17 21:38:24 +0100[diff] [blame]5073 t->data_ctx.stats.flags |= STAT_NO_REFRESH;
Willy Tarreaue7150cd2007-07-25 14:43:32 +0200[diff] [blame]5074 break;
5075 }
5076 h++;
5077 }
5078 }
5079
Willy Tarreau55bb8452007-10-17 18:44:57 +0200[diff] [blame]5080 h = t->req->data + txn->req.sl.rq.u + uri_auth->uri_len;
5081 while (h <= t->req->data + txn->req.sl.rq.u + txn->req.sl.rq.u_l - 4) {
5082 if (memcmp(h, ";csv", 4) == 0) {
Willy Tarreau39f7e6d2008-03-17 21:38:24 +0100[diff] [blame]5083 t->data_ctx.stats.flags |= STAT_FMT_CSV;
Willy Tarreau55bb8452007-10-17 18:44:57 +0200[diff] [blame]5084 break;
5085 }
5086 h++;
5087 }
5088
Willy Tarreau39f7e6d2008-03-17 21:38:24 +0100[diff] [blame]5089 t->data_ctx.stats.flags |= STAT_SHOW_STAT | STAT_SHOW_INFO;
5090
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5091 /* we are in front of a interceptable URI. Let's check
5092 * if there's an authentication and if it's valid.
5093 */
5094 user = uri_auth->users;
5095 if (!user) {
5096 /* no user auth required, it's OK */
5097 authenticated = 1;
5098 } else {
5099 authenticated = 0;
5100
5101 /* a user list is defined, we have to check.
5102 * skip 21 chars for "Authorization: Basic ".
5103 */
5104
5105 /* FIXME: this should move to an earlier place */
5106 cur_idx = 0;
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]5107 h = t->req->data + txn->req.som + hdr_idx_first_pos(&txn->hdr_idx);
5108 while ((cur_idx = txn->hdr_idx.v[cur_idx].next)) {
5109 int len = txn->hdr_idx.v[cur_idx].len;
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5110 if (len > 14 &&
5111 !strncasecmp("Authorization:", h, 14)) {
Krzysztof Piotr Oledzki6f61b212009-10-04 23:34:15 +0200[diff] [blame]5112 chunk_initlen(&txn->auth_hdr, h, 0, len);
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5113 break;
5114 }
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]5115 h += len + txn->hdr_idx.v[cur_idx].cr + 1;
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5116 }
5117
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]5118 if (txn->auth_hdr.len < 21 ||
5119 memcmp(txn->auth_hdr.str + 14, " Basic ", 7))
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5120 user = NULL;
5121
5122 while (user) {
Willy Tarreau4dbc4a22007-03-03 16:23:22 +0100[diff] [blame]5123 if ((txn->auth_hdr.len == user->user_len + 14 + 7)
5124 && !memcmp(txn->auth_hdr.str + 14 + 7,
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5125 user->user_pwd, user->user_len)) {
5126 authenticated = 1;
5127 break;
5128 }
5129 user = user->next;
5130 }
5131 }
5132
5133 if (!authenticated) {
Willy Tarreau0f772532006-12-23 20:51:41 +0100[diff] [blame]5134 struct chunk msg;
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5135
5136 /* no need to go further */
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200[diff] [blame]5137 sprintf(trash, HTTP_401_fmt, uri_auth->auth_realm);
5138 chunk_initlen(&msg, trash, sizeof(trash), strlen(trash));
Willy Tarreau3bac9ff2007-03-18 17:31:28 +0100[diff] [blame]5139 txn->status = 401;
Willy Tarreaudded32d2008-11-30 19:48:07 +0100[diff] [blame]5140 stream_int_retnclose(t->req->prod, &msg);
Willy Tarreau2df28e82008-08-17 15:20:19 +0200[diff] [blame]5141 t->req->analysers = 0;
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5142 if (!(t->flags & SN_ERR_MASK))
5143 t->flags |= SN_ERR_PRXCOND;
5144 if (!(t->flags & SN_FINST_MASK))
5145 t->flags |= SN_FINST_R;
5146 return 1;
5147 }
5148
Willy Tarreau39f7e6d2008-03-17 21:38:24 +0100[diff] [blame]5149 /* The request is valid, the user is authenticated. Let's start sending
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5150 * data.
5151 */
Willy Tarreau70089872008-06-13 21:12:51 +0200[diff] [blame]5152 t->logs.tv_request = now;
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5153 t->data_source = DATA_SRC_STATS;
5154 t->data_state = DATA_ST_INIT;
Willy Tarreau91e99932008-06-30 07:51:00 +0200[diff] [blame]5155 t->task->nice = -32; /* small boost for HTTP statistics */
Willy Tarreaub0c9bc42009-10-04 15:56:38 +0200[diff] [blame]5156 stream_int_register_handler(t->rep->prod, http_stats_io_handler);
5157 t->rep->prod->private = t;
5158 t->rep->prod->st0 = t->rep->prod->st1 = 0;
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5159 return 1;
5160}
5161
Willy Tarreau4076a152009-04-02 15:18:36 +0200[diff] [blame]5162/*
5163 * Capture a bad request or response and archive it in the proxy's structure.
5164 */
5165void http_capture_bad_message(struct error_snapshot *es, struct session *s,
5166 struct buffer *buf, struct http_msg *msg,
5167 struct proxy *other_end)
5168{
Willy Tarreau2df8d712009-05-01 11:33:17 +0200[diff] [blame]5169 es->len = buf->r - (buf->data + msg->som);
5170 memcpy(es->buf, buf->data + msg->som, MIN(es->len, sizeof(es->buf)));
Willy Tarreau4076a152009-04-02 15:18:36 +0200[diff] [blame]5171 if (msg->err_pos >= 0)
Willy Tarreau2df8d712009-05-01 11:33:17 +0200[diff] [blame]5172 es->pos = msg->err_pos - msg->som;
Willy Tarreau4076a152009-04-02 15:18:36 +0200[diff] [blame]5173 else
Willy Tarreau2df8d712009-05-01 11:33:17 +0200[diff] [blame]5174 es->pos = buf->lr - (buf->data + msg->som);
Willy Tarreau4076a152009-04-02 15:18:36 +0200[diff] [blame]5175 es->when = date; // user-visible date
5176 es->sid = s->uniq_id;
5177 es->srv = s->srv;
5178 es->oe = other_end;
5179 es->src = s->cli_addr;
5180}
Willy Tarreaub2513902006-12-17 14:52:38 +0100[diff] [blame]5181
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]5182/*
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]5183 * Print a debug line with a header
5184 */
5185void debug_hdr(const char *dir, struct session *t, const char *start, const char *end)
5186{
5187 int len, max;
5188 len = sprintf(trash, "%08x:%s.%s[%04x:%04x]: ", t->uniq_id, t->be->id,
Willy Tarreau3a16b2c2008-08-28 08:54:27 +0200[diff] [blame]5189 dir, (unsigned short)t->req->prod->fd, (unsigned short)t->req->cons->fd);
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]5190 max = end - start;
5191 UBOUND(max, sizeof(trash) - len - 1);
5192 len += strlcpy2(trash + len, start, max + 1);
5193 trash[len++] = '\n';
5194 write(1, trash, len);
5195}
5196
Willy Tarreau0937bc42009-12-22 15:03:09 +0100[diff] [blame]5197/*
5198 * Initialize a new HTTP transaction for session <s>. It is assumed that all
5199 * the required fields are properly allocated and that we only need to (re)init
5200 * them. This should be used before processing any new request.
5201 */
5202void http_init_txn(struct session *s)
5203{
5204 struct http_txn *txn = &s->txn;
5205 struct proxy *fe = s->fe;
5206
5207 txn->flags = 0;
5208 txn->status = -1;
5209
5210 txn->req.sol = txn->req.eol = NULL;
5211 txn->req.som = txn->req.eoh = 0; /* relative to the buffer */
5212 txn->rsp.sol = txn->rsp.eol = NULL;
5213 txn->rsp.som = txn->rsp.eoh = 0; /* relative to the buffer */
5214 txn->req.hdr_content_len = 0LL;
5215 txn->rsp.hdr_content_len = 0LL;
5216 txn->req.msg_state = HTTP_MSG_RQBEFORE; /* at the very beginning of the request */
5217 txn->rsp.msg_state = HTTP_MSG_RPBEFORE; /* at the very beginning of the response */
5218 chunk_reset(&txn->auth_hdr);
5219
5220 txn->req.err_pos = txn->rsp.err_pos = -2; /* block buggy requests/responses */
5221 if (fe->options2 & PR_O2_REQBUG_OK)
5222 txn->req.err_pos = -1; /* let buggy requests pass */
5223
5224 if (txn->req.cap)
5225 memset(txn->req.cap, 0, fe->nb_req_cap * sizeof(void *));
5226
5227 if (txn->rsp.cap)
5228 memset(txn->rsp.cap, 0, fe->nb_rsp_cap * sizeof(void *));
5229
5230 if (txn->hdr_idx.v)
5231 hdr_idx_init(&txn->hdr_idx);
5232}
5233
5234/* to be used at the end of a transaction */
5235void http_end_txn(struct session *s)
5236{
5237 struct http_txn *txn = &s->txn;
5238
5239 /* these ones will have been dynamically allocated */
5240 pool_free2(pool2_requri, txn->uri);
5241 pool_free2(pool2_capture, txn->cli_cookie);
5242 pool_free2(pool2_capture, txn->srv_cookie);
5243 txn->uri = NULL;
5244 txn->srv_cookie = NULL;
5245 txn->cli_cookie = NULL;
5246}
5247
5248/* to be used at the end of a transaction to prepare a new one */
5249void http_reset_txn(struct session *s)
5250{
5251 http_end_txn(s);
5252 http_init_txn(s);
5253
5254 s->be = s->fe;
5255 s->req->analysers = s->listener->analysers;
5256 s->logs.logwait = s->fe->to_log;
5257 s->srv = s->prev_srv = s->srv_conn = NULL;
5258 s->pend_pos = NULL;
5259 s->conn_retries = s->be->conn_retries;
5260
5261 s->req->flags |= BF_READ_DONTWAIT; /* one read is usually enough */
5262
5263 s->req->rto = s->fe->timeout.client;
5264 s->req->wto = s->be->timeout.server;
5265 s->req->cto = s->be->timeout.connect;
5266
5267 s->rep->rto = s->be->timeout.server;
5268 s->rep->wto = s->fe->timeout.client;
5269 s->rep->cto = TICK_ETERNITY;
5270
5271 s->req->rex = TICK_ETERNITY;
5272 s->req->wex = TICK_ETERNITY;
5273 s->req->analyse_exp = TICK_ETERNITY;
5274 s->rep->rex = TICK_ETERNITY;
5275 s->rep->wex = TICK_ETERNITY;
5276 s->rep->analyse_exp = TICK_ETERNITY;
5277}
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]5278
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5279/************************************************************************/
5280/* The code below is dedicated to ACL parsing and matching */
5281/************************************************************************/
5282
5283
5284
5285
5286/* 1. Check on METHOD
5287 * We use the pre-parsed method if it is known, and store its number as an
5288 * integer. If it is unknown, we use the pointer and the length.
5289 */
Willy Tarreauae8b7962007-06-09 23:10:04 +0200[diff] [blame]5290static int acl_parse_meth(const char **text, struct acl_pattern *pattern, int *opaque)
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5291{
5292 int len, meth;
5293
Willy Tarreauae8b7962007-06-09 23:10:04 +0200[diff] [blame]5294 len = strlen(*text);
5295 meth = find_http_meth(*text, len);
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5296
5297 pattern->val.i = meth;
5298 if (meth == HTTP_METH_OTHER) {
Willy Tarreauae8b7962007-06-09 23:10:04 +0200[diff] [blame]5299 pattern->ptr.str = strdup(*text);
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5300 if (!pattern->ptr.str)
5301 return 0;
5302 pattern->len = len;
5303 }
5304 return 1;
5305}
5306
Willy Tarreaud41f8d82007-06-10 10:06:18 +0200[diff] [blame]5307static int
Willy Tarreau97be1452007-06-10 11:47:14 +0200[diff] [blame]5308acl_fetch_meth(struct proxy *px, struct session *l4, void *l7, int dir,
5309 struct acl_expr *expr, struct acl_test *test)
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5310{
5311 int meth;
5312 struct http_txn *txn = l7;
5313
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5314 if (!txn)
5315 return 0;
5316
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5317 if (txn->req.msg_state < HTTP_MSG_BODY)
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5318 return 0;
5319
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5320 meth = txn->meth;
5321 test->i = meth;
5322 if (meth == HTTP_METH_OTHER) {
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5323 if (txn->rsp.msg_state != HTTP_MSG_RPBEFORE)
5324 /* ensure the indexes are not affected */
5325 return 0;
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5326 test->len = txn->req.sl.rq.m_l;
5327 test->ptr = txn->req.sol;
5328 }
5329 test->flags = ACL_TEST_F_READ_ONLY | ACL_TEST_F_VOL_1ST;
5330 return 1;
5331}
5332
5333static int acl_match_meth(struct acl_test *test, struct acl_pattern *pattern)
5334{
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200[diff] [blame]5335 int icase;
5336
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5337 if (test->i != pattern->val.i)
Willy Tarreau11382812008-07-09 16:18:21 +0200[diff] [blame]5338 return ACL_PAT_FAIL;
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5339
5340 if (test->i != HTTP_METH_OTHER)
Willy Tarreau11382812008-07-09 16:18:21 +0200[diff] [blame]5341 return ACL_PAT_PASS;
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5342
5343 /* Other method, we must compare the strings */
5344 if (pattern->len != test->len)
Willy Tarreau11382812008-07-09 16:18:21 +0200[diff] [blame]5345 return ACL_PAT_FAIL;
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200[diff] [blame]5346
5347 icase = pattern->flags & ACL_PAT_F_IGNORE_CASE;
5348 if ((icase && strncasecmp(pattern->ptr.str, test->ptr, test->len) != 0) ||
5349 (!icase && strncmp(pattern->ptr.str, test->ptr, test->len) != 0))
Willy Tarreau11382812008-07-09 16:18:21 +0200[diff] [blame]5350 return ACL_PAT_FAIL;
5351 return ACL_PAT_PASS;
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5352}
5353
5354/* 2. Check on Request/Status Version
5355 * We simply compare strings here.
5356 */
Willy Tarreauae8b7962007-06-09 23:10:04 +0200[diff] [blame]5357static int acl_parse_ver(const char **text, struct acl_pattern *pattern, int *opaque)
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5358{
Willy Tarreauae8b7962007-06-09 23:10:04 +0200[diff] [blame]5359 pattern->ptr.str = strdup(*text);
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5360 if (!pattern->ptr.str)
5361 return 0;
Willy Tarreauae8b7962007-06-09 23:10:04 +0200[diff] [blame]5362 pattern->len = strlen(*text);
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5363 return 1;
5364}
5365
Willy Tarreaud41f8d82007-06-10 10:06:18 +0200[diff] [blame]5366static int
Willy Tarreau97be1452007-06-10 11:47:14 +0200[diff] [blame]5367acl_fetch_rqver(struct proxy *px, struct session *l4, void *l7, int dir,
5368 struct acl_expr *expr, struct acl_test *test)
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5369{
5370 struct http_txn *txn = l7;
5371 char *ptr;
5372 int len;
5373
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5374 if (!txn)
5375 return 0;
5376
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5377 if (txn->req.msg_state < HTTP_MSG_BODY)
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5378 return 0;
5379
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5380 len = txn->req.sl.rq.v_l;
5381 ptr = txn->req.sol + txn->req.sl.rq.v - txn->req.som;
5382
5383 while ((len-- > 0) && (*ptr++ != '/'));
5384 if (len <= 0)
5385 return 0;
5386
5387 test->ptr = ptr;
5388 test->len = len;
5389
5390 test->flags = ACL_TEST_F_READ_ONLY | ACL_TEST_F_VOL_1ST;
5391 return 1;
5392}
5393
Willy Tarreaud41f8d82007-06-10 10:06:18 +0200[diff] [blame]5394static int
Willy Tarreau97be1452007-06-10 11:47:14 +0200[diff] [blame]5395acl_fetch_stver(struct proxy *px, struct session *l4, void *l7, int dir,
5396 struct acl_expr *expr, struct acl_test *test)
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5397{
5398 struct http_txn *txn = l7;
5399 char *ptr;
5400 int len;
5401
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5402 if (!txn)
5403 return 0;
5404
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5405 if (txn->rsp.msg_state < HTTP_MSG_BODY)
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5406 return 0;
5407
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5408 len = txn->rsp.sl.st.v_l;
5409 ptr = txn->rsp.sol;
5410
5411 while ((len-- > 0) && (*ptr++ != '/'));
5412 if (len <= 0)
5413 return 0;
5414
5415 test->ptr = ptr;
5416 test->len = len;
5417
5418 test->flags = ACL_TEST_F_READ_ONLY | ACL_TEST_F_VOL_1ST;
5419 return 1;
5420}
5421
5422/* 3. Check on Status Code. We manipulate integers here. */
Willy Tarreaud41f8d82007-06-10 10:06:18 +0200[diff] [blame]5423static int
Willy Tarreau97be1452007-06-10 11:47:14 +0200[diff] [blame]5424acl_fetch_stcode(struct proxy *px, struct session *l4, void *l7, int dir,
5425 struct acl_expr *expr, struct acl_test *test)
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5426{
5427 struct http_txn *txn = l7;
5428 char *ptr;
5429 int len;
5430
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5431 if (!txn)
5432 return 0;
5433
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5434 if (txn->rsp.msg_state < HTTP_MSG_BODY)
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5435 return 0;
5436
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5437 len = txn->rsp.sl.st.c_l;
5438 ptr = txn->rsp.sol + txn->rsp.sl.st.c - txn->rsp.som;
5439
5440 test->i = __strl2ui(ptr, len);
5441 test->flags = ACL_TEST_F_VOL_1ST;
5442 return 1;
5443}
5444
5445/* 4. Check on URL/URI. A pointer to the URI is stored. */
Willy Tarreaud41f8d82007-06-10 10:06:18 +0200[diff] [blame]5446static int
Willy Tarreau97be1452007-06-10 11:47:14 +0200[diff] [blame]5447acl_fetch_url(struct proxy *px, struct session *l4, void *l7, int dir,
5448 struct acl_expr *expr, struct acl_test *test)
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5449{
5450 struct http_txn *txn = l7;
5451
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5452 if (!txn)
5453 return 0;
5454
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5455 if (txn->req.msg_state < HTTP_MSG_BODY)
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5456 return 0;
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5457
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5458 if (txn->rsp.msg_state != HTTP_MSG_RPBEFORE)
5459 /* ensure the indexes are not affected */
5460 return 0;
5461
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5462 test->len = txn->req.sl.rq.u_l;
5463 test->ptr = txn->req.sol + txn->req.sl.rq.u;
5464
Willy Tarreauf3d25982007-05-08 22:45:09 +0200[diff] [blame]5465 /* we do not need to set READ_ONLY because the data is in a buffer */
5466 test->flags = ACL_TEST_F_VOL_1ST;
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5467 return 1;
5468}
5469
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100[diff] [blame]5470static int
5471acl_fetch_url_ip(struct proxy *px, struct session *l4, void *l7, int dir,
5472 struct acl_expr *expr, struct acl_test *test)
5473{
5474 struct http_txn *txn = l7;
5475
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5476 if (!txn)
5477 return 0;
5478
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5479 if (txn->req.msg_state < HTTP_MSG_BODY)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100[diff] [blame]5480 return 0;
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5481
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100[diff] [blame]5482 if (txn->rsp.msg_state != HTTP_MSG_RPBEFORE)
5483 /* ensure the indexes are not affected */
5484 return 0;
5485
5486 /* Parse HTTP request */
5487 url2sa(txn->req.sol + txn->req.sl.rq.u, txn->req.sl.rq.u_l, &l4->srv_addr);
5488 test->ptr = (void *)&((struct sockaddr_in *)&l4->srv_addr)->sin_addr;
5489 test->i = AF_INET;
5490
5491 /*
5492 * If we are parsing url in frontend space, we prepare backend stage
5493 * to not parse again the same url ! optimization lazyness...
5494 */
5495 if (px->options & PR_O_HTTP_PROXY)
5496 l4->flags |= SN_ADDR_SET;
5497
5498 test->flags = ACL_TEST_F_READ_ONLY;
5499 return 1;
5500}
5501
5502static int
5503acl_fetch_url_port(struct proxy *px, struct session *l4, void *l7, int dir,
5504 struct acl_expr *expr, struct acl_test *test)
5505{
5506 struct http_txn *txn = l7;
5507
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5508 if (!txn)
5509 return 0;
5510
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5511 if (txn->req.msg_state < HTTP_MSG_BODY)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100[diff] [blame]5512 return 0;
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5513
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100[diff] [blame]5514 if (txn->rsp.msg_state != HTTP_MSG_RPBEFORE)
5515 /* ensure the indexes are not affected */
5516 return 0;
5517
5518 /* Same optimization as url_ip */
5519 url2sa(txn->req.sol + txn->req.sl.rq.u, txn->req.sl.rq.u_l, &l4->srv_addr);
5520 test->i = ntohs(((struct sockaddr_in *)&l4->srv_addr)->sin_port);
5521
5522 if (px->options & PR_O_HTTP_PROXY)
5523 l4->flags |= SN_ADDR_SET;
5524
5525 test->flags = ACL_TEST_F_READ_ONLY;
5526 return 1;
5527}
5528
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5529/* 5. Check on HTTP header. A pointer to the beginning of the value is returned.
5530 * This generic function is used by both acl_fetch_chdr() and acl_fetch_shdr().
5531 */
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]5532static int
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5533acl_fetch_hdr(struct proxy *px, struct session *l4, void *l7, char *sol,
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]5534 struct acl_expr *expr, struct acl_test *test)
5535{
5536 struct http_txn *txn = l7;
5537 struct hdr_idx *idx = &txn->hdr_idx;
5538 struct hdr_ctx *ctx = (struct hdr_ctx *)test->ctx.a;
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]5539
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5540 if (!txn)
5541 return 0;
5542
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]5543 if (!(test->flags & ACL_TEST_F_FETCH_MORE))
5544 /* search for header from the beginning */
5545 ctx->idx = 0;
5546
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]5547 if (http_find_header2(expr->arg.str, expr->arg_len, sol, idx, ctx)) {
5548 test->flags |= ACL_TEST_F_FETCH_MORE;
5549 test->flags |= ACL_TEST_F_VOL_HDR;
5550 test->len = ctx->vlen;
5551 test->ptr = (char *)ctx->line + ctx->val;
5552 return 1;
5553 }
5554
5555 test->flags &= ~ACL_TEST_F_FETCH_MORE;
5556 test->flags |= ACL_TEST_F_VOL_HDR;
5557 return 0;
5558}
5559
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]5560static int
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5561acl_fetch_chdr(struct proxy *px, struct session *l4, void *l7, int dir,
5562 struct acl_expr *expr, struct acl_test *test)
5563{
5564 struct http_txn *txn = l7;
5565
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5566 if (!txn)
5567 return 0;
5568
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5569 if (txn->req.msg_state < HTTP_MSG_BODY)
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5570 return 0;
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5571
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5572 if (txn->rsp.msg_state != HTTP_MSG_RPBEFORE)
5573 /* ensure the indexes are not affected */
5574 return 0;
5575
5576 return acl_fetch_hdr(px, l4, txn, txn->req.sol, expr, test);
5577}
5578
5579static int
5580acl_fetch_shdr(struct proxy *px, struct session *l4, void *l7, int dir,
5581 struct acl_expr *expr, struct acl_test *test)
5582{
5583 struct http_txn *txn = l7;
5584
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5585 if (!txn)
5586 return 0;
5587
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5588 if (txn->rsp.msg_state < HTTP_MSG_BODY)
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5589 return 0;
5590
5591 return acl_fetch_hdr(px, l4, txn, txn->rsp.sol, expr, test);
5592}
5593
5594/* 6. Check on HTTP header count. The number of occurrences is returned.
5595 * This generic function is used by both acl_fetch_chdr* and acl_fetch_shdr*.
5596 */
5597static int
5598acl_fetch_hdr_cnt(struct proxy *px, struct session *l4, void *l7, char *sol,
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]5599 struct acl_expr *expr, struct acl_test *test)
5600{
5601 struct http_txn *txn = l7;
5602 struct hdr_idx *idx = &txn->hdr_idx;
5603 struct hdr_ctx ctx;
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]5604 int cnt;
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5605
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5606 if (!txn)
5607 return 0;
5608
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]5609 ctx.idx = 0;
5610 cnt = 0;
5611 while (http_find_header2(expr->arg.str, expr->arg_len, sol, idx, &ctx))
5612 cnt++;
5613
5614 test->i = cnt;
5615 test->flags = ACL_TEST_F_VOL_HDR;
5616 return 1;
5617}
5618
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5619static int
5620acl_fetch_chdr_cnt(struct proxy *px, struct session *l4, void *l7, int dir,
5621 struct acl_expr *expr, struct acl_test *test)
5622{
5623 struct http_txn *txn = l7;
5624
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5625 if (!txn)
5626 return 0;
5627
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5628 if (txn->req.msg_state < HTTP_MSG_BODY)
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5629 return 0;
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5630
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5631 if (txn->rsp.msg_state != HTTP_MSG_RPBEFORE)
5632 /* ensure the indexes are not affected */
5633 return 0;
5634
5635 return acl_fetch_hdr_cnt(px, l4, txn, txn->req.sol, expr, test);
5636}
5637
5638static int
5639acl_fetch_shdr_cnt(struct proxy *px, struct session *l4, void *l7, int dir,
5640 struct acl_expr *expr, struct acl_test *test)
5641{
5642 struct http_txn *txn = l7;
5643
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5644 if (!txn)
5645 return 0;
5646
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5647 if (txn->rsp.msg_state < HTTP_MSG_BODY)
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5648 return 0;
5649
5650 return acl_fetch_hdr_cnt(px, l4, txn, txn->rsp.sol, expr, test);
5651}
5652
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]5653/* 7. Check on HTTP header's integer value. The integer value is returned.
5654 * FIXME: the type is 'int', it may not be appropriate for everything.
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5655 * This generic function is used by both acl_fetch_chdr* and acl_fetch_shdr*.
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]5656 */
5657static int
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5658acl_fetch_hdr_val(struct proxy *px, struct session *l4, void *l7, char *sol,
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]5659 struct acl_expr *expr, struct acl_test *test)
5660{
5661 struct http_txn *txn = l7;
5662 struct hdr_idx *idx = &txn->hdr_idx;
5663 struct hdr_ctx *ctx = (struct hdr_ctx *)test->ctx.a;
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]5664
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5665 if (!txn)
5666 return 0;
5667
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]5668 if (!(test->flags & ACL_TEST_F_FETCH_MORE))
5669 /* search for header from the beginning */
5670 ctx->idx = 0;
5671
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]5672 if (http_find_header2(expr->arg.str, expr->arg_len, sol, idx, ctx)) {
5673 test->flags |= ACL_TEST_F_FETCH_MORE;
5674 test->flags |= ACL_TEST_F_VOL_HDR;
5675 test->i = strl2ic((char *)ctx->line + ctx->val, ctx->vlen);
5676 return 1;
5677 }
5678
5679 test->flags &= ~ACL_TEST_F_FETCH_MORE;
5680 test->flags |= ACL_TEST_F_VOL_HDR;
5681 return 0;
5682}
5683
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5684static int
5685acl_fetch_chdr_val(struct proxy *px, struct session *l4, void *l7, int dir,
5686 struct acl_expr *expr, struct acl_test *test)
5687{
5688 struct http_txn *txn = l7;
5689
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5690 if (!txn)
5691 return 0;
5692
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5693 if (txn->req.msg_state < HTTP_MSG_BODY)
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5694 return 0;
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5695
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5696 if (txn->rsp.msg_state != HTTP_MSG_RPBEFORE)
5697 /* ensure the indexes are not affected */
5698 return 0;
5699
5700 return acl_fetch_hdr_val(px, l4, txn, txn->req.sol, expr, test);
5701}
5702
5703static int
5704acl_fetch_shdr_val(struct proxy *px, struct session *l4, void *l7, int dir,
5705 struct acl_expr *expr, struct acl_test *test)
5706{
5707 struct http_txn *txn = l7;
5708
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5709 if (!txn)
5710 return 0;
5711
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5712 if (txn->rsp.msg_state < HTTP_MSG_BODY)
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5713 return 0;
5714
5715 return acl_fetch_hdr_val(px, l4, txn, txn->rsp.sol, expr, test);
5716}
5717
Willy Tarreau106f9792009-09-19 07:54:16 +0200[diff] [blame]5718/* 7. Check on HTTP header's IPv4 address value. The IPv4 address is returned.
5719 * This generic function is used by both acl_fetch_chdr* and acl_fetch_shdr*.
5720 */
5721static int
5722acl_fetch_hdr_ip(struct proxy *px, struct session *l4, void *l7, char *sol,
5723 struct acl_expr *expr, struct acl_test *test)
5724{
5725 struct http_txn *txn = l7;
5726 struct hdr_idx *idx = &txn->hdr_idx;
5727 struct hdr_ctx *ctx = (struct hdr_ctx *)test->ctx.a;
5728
5729 if (!txn)
5730 return 0;
5731
5732 if (!(test->flags & ACL_TEST_F_FETCH_MORE))
5733 /* search for header from the beginning */
5734 ctx->idx = 0;
5735
5736 if (http_find_header2(expr->arg.str, expr->arg_len, sol, idx, ctx)) {
5737 test->flags |= ACL_TEST_F_FETCH_MORE;
5738 test->flags |= ACL_TEST_F_VOL_HDR;
5739 /* Same optimization as url_ip */
5740 memset(&l4->srv_addr.sin_addr, 0, sizeof(l4->srv_addr.sin_addr));
5741 url2ip((char *)ctx->line + ctx->val, &l4->srv_addr.sin_addr);
5742 test->ptr = (void *)&l4->srv_addr.sin_addr;
5743 test->i = AF_INET;
5744 return 1;
5745 }
5746
5747 test->flags &= ~ACL_TEST_F_FETCH_MORE;
5748 test->flags |= ACL_TEST_F_VOL_HDR;
5749 return 0;
5750}
5751
5752static int
5753acl_fetch_chdr_ip(struct proxy *px, struct session *l4, void *l7, int dir,
5754 struct acl_expr *expr, struct acl_test *test)
5755{
5756 struct http_txn *txn = l7;
5757
5758 if (!txn)
5759 return 0;
5760
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5761 if (txn->req.msg_state < HTTP_MSG_BODY)
Willy Tarreau106f9792009-09-19 07:54:16 +0200[diff] [blame]5762 return 0;
5763
5764 if (txn->rsp.msg_state != HTTP_MSG_RPBEFORE)
5765 /* ensure the indexes are not affected */
5766 return 0;
5767
5768 return acl_fetch_hdr_ip(px, l4, txn, txn->req.sol, expr, test);
5769}
5770
5771static int
5772acl_fetch_shdr_ip(struct proxy *px, struct session *l4, void *l7, int dir,
5773 struct acl_expr *expr, struct acl_test *test)
5774{
5775 struct http_txn *txn = l7;
5776
5777 if (!txn)
5778 return 0;
5779
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5780 if (txn->rsp.msg_state < HTTP_MSG_BODY)
Willy Tarreau106f9792009-09-19 07:54:16 +0200[diff] [blame]5781 return 0;
5782
5783 return acl_fetch_hdr_ip(px, l4, txn, txn->rsp.sol, expr, test);
5784}
5785
Willy Tarreau737b0c12007-06-10 21:28:46 +0200[diff] [blame]5786/* 8. Check on URI PATH. A pointer to the PATH is stored. The path starts at
5787 * the first '/' after the possible hostname, and ends before the possible '?'.
5788 */
5789static int
5790acl_fetch_path(struct proxy *px, struct session *l4, void *l7, int dir,
5791 struct acl_expr *expr, struct acl_test *test)
5792{
5793 struct http_txn *txn = l7;
5794 char *ptr, *end;
Willy Tarreau33a7e692007-06-10 19:45:56 +0200[diff] [blame]5795
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5796 if (!txn)
5797 return 0;
5798
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5799 if (txn->req.msg_state < HTTP_MSG_BODY)
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5800 return 0;
Willy Tarreaub6866442008-07-14 23:54:42 +0200[diff] [blame]5801
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5802 if (txn->rsp.msg_state != HTTP_MSG_RPBEFORE)
5803 /* ensure the indexes are not affected */
5804 return 0;
5805
Willy Tarreau21d2af32008-02-14 20:25:24 +0100[diff] [blame]5806 end = txn->req.sol + txn->req.sl.rq.u + txn->req.sl.rq.u_l;
5807 ptr = http_get_path(txn);
5808 if (!ptr)
Willy Tarreau737b0c12007-06-10 21:28:46 +0200[diff] [blame]5809 return 0;
5810
5811 /* OK, we got the '/' ! */
5812 test->ptr = ptr;
5813
5814 while (ptr < end && *ptr != '?')
5815 ptr++;
5816
5817 test->len = ptr - test->ptr;
5818
5819 /* we do not need to set READ_ONLY because the data is in a buffer */
5820 test->flags = ACL_TEST_F_VOL_1ST;
5821 return 1;
5822}
5823
Willy Tarreau2492d5b2009-07-11 00:06:00 +0200[diff] [blame]5824static int
5825acl_fetch_proto_http(struct proxy *px, struct session *s, void *l7, int dir,
5826 struct acl_expr *expr, struct acl_test *test)
5827{
5828 struct buffer *req = s->req;
5829 struct http_txn *txn = &s->txn;
5830 struct http_msg *msg = &txn->req;
Willy Tarreau737b0c12007-06-10 21:28:46 +0200[diff] [blame]5831
Willy Tarreau2492d5b2009-07-11 00:06:00 +0200[diff] [blame]5832 /* Note: hdr_idx.v cannot be NULL in this ACL because the ACL is tagged
5833 * as a layer7 ACL, which involves automatic allocation of hdr_idx.
5834 */
5835
5836 if (!s || !req)
5837 return 0;
5838
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5839 if (unlikely(msg->msg_state >= HTTP_MSG_BODY)) {
Willy Tarreau2492d5b2009-07-11 00:06:00 +0200[diff] [blame]5840 /* Already decoded as OK */
5841 test->flags |= ACL_TEST_F_SET_RES_PASS;
5842 return 1;
5843 }
5844
5845 /* Try to decode HTTP request */
5846 if (likely(req->lr < req->r))
5847 http_msg_analyzer(req, msg, &txn->hdr_idx);
5848
Willy Tarreau655dce92009-11-08 13:10:58 +0100[diff] [blame]5849 if (unlikely(msg->msg_state < HTTP_MSG_BODY)) {
Willy Tarreau2492d5b2009-07-11 00:06:00 +0200[diff] [blame]5850 if ((msg->msg_state == HTTP_MSG_ERROR) || (req->flags & BF_FULL)) {
5851 test->flags |= ACL_TEST_F_SET_RES_FAIL;
5852 return 1;
5853 }
5854 /* wait for final state */
5855 test->flags |= ACL_TEST_F_MAY_CHANGE;
5856 return 0;
5857 }
5858
5859 /* OK we got a valid HTTP request. We have some minor preparation to
5860 * perform so that further checks can rely on HTTP tests.
5861 */
5862 msg->sol = req->data + msg->som;
5863 txn->meth = find_http_meth(&req->data[msg->som], msg->sl.rq.m_l);
5864 if (txn->meth == HTTP_METH_GET || txn->meth == HTTP_METH_HEAD)
5865 s->flags |= SN_REDIRECTABLE;
5866
5867 if (unlikely(msg->sl.rq.v_l == 0) && !http_upgrade_v09_to_v10(req, msg, txn)) {
5868 test->flags |= ACL_TEST_F_SET_RES_FAIL;
5869 return 1;
5870 }
5871
5872 test->flags |= ACL_TEST_F_SET_RES_PASS;
5873 return 1;
5874}
5875
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5876
5877/************************************************************************/
5878/* All supported keywords must be declared here. */
5879/************************************************************************/
5880
5881/* Note: must not be declared <const> as its list will be overwritten */
5882static struct acl_kw_list acl_kws = {{ },{
Willy Tarreau2492d5b2009-07-11 00:06:00 +0200[diff] [blame]5883 { "req_proto_http", acl_parse_nothing, acl_fetch_proto_http, acl_match_nothing, ACL_USE_L7REQ_PERMANENT },
5884
Willy Tarreau0ceba5a2008-07-25 19:31:03 +0200[diff] [blame]5885 { "method", acl_parse_meth, acl_fetch_meth, acl_match_meth, ACL_USE_L7REQ_PERMANENT },
5886 { "req_ver", acl_parse_ver, acl_fetch_rqver, acl_match_str, ACL_USE_L7REQ_VOLATILE },
5887 { "resp_ver", acl_parse_ver, acl_fetch_stver, acl_match_str, ACL_USE_L7RTR_VOLATILE },
5888 { "status", acl_parse_int, acl_fetch_stcode, acl_match_int, ACL_USE_L7RTR_PERMANENT },
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5889
Willy Tarreau0ceba5a2008-07-25 19:31:03 +0200[diff] [blame]5890 { "url", acl_parse_str, acl_fetch_url, acl_match_str, ACL_USE_L7REQ_VOLATILE },
5891 { "url_beg", acl_parse_str, acl_fetch_url, acl_match_beg, ACL_USE_L7REQ_VOLATILE },
5892 { "url_end", acl_parse_str, acl_fetch_url, acl_match_end, ACL_USE_L7REQ_VOLATILE },
5893 { "url_sub", acl_parse_str, acl_fetch_url, acl_match_sub, ACL_USE_L7REQ_VOLATILE },
5894 { "url_dir", acl_parse_str, acl_fetch_url, acl_match_dir, ACL_USE_L7REQ_VOLATILE },
5895 { "url_dom", acl_parse_str, acl_fetch_url, acl_match_dom, ACL_USE_L7REQ_VOLATILE },
5896 { "url_reg", acl_parse_reg, acl_fetch_url, acl_match_reg, ACL_USE_L7REQ_VOLATILE },
5897 { "url_ip", acl_parse_ip, acl_fetch_url_ip, acl_match_ip, ACL_USE_L7REQ_VOLATILE },
5898 { "url_port", acl_parse_int, acl_fetch_url_port, acl_match_int, ACL_USE_L7REQ_VOLATILE },
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5899
Willy Tarreau0ceba5a2008-07-25 19:31:03 +0200[diff] [blame]5900 /* note: we should set hdr* to use ACL_USE_HDR_VOLATILE, and chdr* to use L7REQ_VOLATILE */
5901 { "hdr", acl_parse_str, acl_fetch_chdr, acl_match_str, ACL_USE_L7REQ_VOLATILE },
5902 { "hdr_reg", acl_parse_reg, acl_fetch_chdr, acl_match_reg, ACL_USE_L7REQ_VOLATILE },
5903 { "hdr_beg", acl_parse_str, acl_fetch_chdr, acl_match_beg, ACL_USE_L7REQ_VOLATILE },
5904 { "hdr_end", acl_parse_str, acl_fetch_chdr, acl_match_end, ACL_USE_L7REQ_VOLATILE },
5905 { "hdr_sub", acl_parse_str, acl_fetch_chdr, acl_match_sub, ACL_USE_L7REQ_VOLATILE },
5906 { "hdr_dir", acl_parse_str, acl_fetch_chdr, acl_match_dir, ACL_USE_L7REQ_VOLATILE },
5907 { "hdr_dom", acl_parse_str, acl_fetch_chdr, acl_match_dom, ACL_USE_L7REQ_VOLATILE },
5908 { "hdr_cnt", acl_parse_int, acl_fetch_chdr_cnt,acl_match_int, ACL_USE_L7REQ_VOLATILE },
5909 { "hdr_val", acl_parse_int, acl_fetch_chdr_val,acl_match_int, ACL_USE_L7REQ_VOLATILE },
Willy Tarreau106f9792009-09-19 07:54:16 +0200[diff] [blame]5910 { "hdr_ip", acl_parse_ip, acl_fetch_chdr_ip, acl_match_ip, ACL_USE_L7REQ_VOLATILE },
Willy Tarreauc11416f2007-06-17 16:58:38 +0200[diff] [blame]5911
Willy Tarreau0ceba5a2008-07-25 19:31:03 +0200[diff] [blame]5912 { "shdr", acl_parse_str, acl_fetch_shdr, acl_match_str, ACL_USE_L7RTR_VOLATILE },
5913 { "shdr_reg", acl_parse_reg, acl_fetch_shdr, acl_match_reg, ACL_USE_L7RTR_VOLATILE },
5914 { "shdr_beg", acl_parse_str, acl_fetch_shdr, acl_match_beg, ACL_USE_L7RTR_VOLATILE },
5915 { "shdr_end", acl_parse_str, acl_fetch_shdr, acl_match_end, ACL_USE_L7RTR_VOLATILE },
5916 { "shdr_sub", acl_parse_str, acl_fetch_shdr, acl_match_sub, ACL_USE_L7RTR_VOLATILE },
5917 { "shdr_dir", acl_parse_str, acl_fetch_shdr, acl_match_dir, ACL_USE_L7RTR_VOLATILE },
5918 { "shdr_dom", acl_parse_str, acl_fetch_shdr, acl_match_dom, ACL_USE_L7RTR_VOLATILE },
5919 { "shdr_cnt", acl_parse_int, acl_fetch_shdr_cnt,acl_match_int, ACL_USE_L7RTR_VOLATILE },
5920 { "shdr_val", acl_parse_int, acl_fetch_shdr_val,acl_match_int, ACL_USE_L7RTR_VOLATILE },
Willy Tarreau106f9792009-09-19 07:54:16 +0200[diff] [blame]5921 { "shdr_ip", acl_parse_ip, acl_fetch_shdr_ip, acl_match_ip, ACL_USE_L7RTR_VOLATILE },
Willy Tarreau737b0c12007-06-10 21:28:46 +0200[diff] [blame]5922
Willy Tarreau0ceba5a2008-07-25 19:31:03 +0200[diff] [blame]5923 { "path", acl_parse_str, acl_fetch_path, acl_match_str, ACL_USE_L7REQ_VOLATILE },
5924 { "path_reg", acl_parse_reg, acl_fetch_path, acl_match_reg, ACL_USE_L7REQ_VOLATILE },
5925 { "path_beg", acl_parse_str, acl_fetch_path, acl_match_beg, ACL_USE_L7REQ_VOLATILE },
5926 { "path_end", acl_parse_str, acl_fetch_path, acl_match_end, ACL_USE_L7REQ_VOLATILE },
5927 { "path_sub", acl_parse_str, acl_fetch_path, acl_match_sub, ACL_USE_L7REQ_VOLATILE },
5928 { "path_dir", acl_parse_str, acl_fetch_path, acl_match_dir, ACL_USE_L7REQ_VOLATILE },
5929 { "path_dom", acl_parse_str, acl_fetch_path, acl_match_dom, ACL_USE_L7REQ_VOLATILE },
Willy Tarreau737b0c12007-06-10 21:28:46 +0200[diff] [blame]5930
Willy Tarreauf3d25982007-05-08 22:45:09 +0200[diff] [blame]5931 { NULL, NULL, NULL, NULL },
5932
5933#if 0
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5934 { "line", acl_parse_str, acl_fetch_line, acl_match_str },
5935 { "line_reg", acl_parse_reg, acl_fetch_line, acl_match_reg },
5936 { "line_beg", acl_parse_str, acl_fetch_line, acl_match_beg },
5937 { "line_end", acl_parse_str, acl_fetch_line, acl_match_end },
5938 { "line_sub", acl_parse_str, acl_fetch_line, acl_match_sub },
5939 { "line_dir", acl_parse_str, acl_fetch_line, acl_match_dir },
5940 { "line_dom", acl_parse_str, acl_fetch_line, acl_match_dom },
5941
Willy Tarreau8797c062007-05-07 00:55:35 +0200[diff] [blame]5942 { "cook", acl_parse_str, acl_fetch_cook, acl_match_str },
5943 { "cook_reg", acl_parse_reg, acl_fetch_cook, acl_match_reg },
5944 { "cook_beg", acl_parse_str, acl_fetch_cook, acl_match_beg },
5945 { "cook_end", acl_parse_str, acl_fetch_cook, acl_match_end },
5946 { "cook_sub", acl_parse_str, acl_fetch_cook, acl_match_sub },
5947 { "cook_dir", acl_parse_str, acl_fetch_cook, acl_match_dir },
5948 { "cook_dom", acl_parse_str, acl_fetch_cook, acl_match_dom },
5949 { "cook_pst", acl_parse_none, acl_fetch_cook, acl_match_pst },
5950
5951 { "auth_user", acl_parse_str, acl_fetch_user, acl_match_str },
5952 { "auth_regex", acl_parse_reg, acl_fetch_user, acl_match_reg },
5953 { "auth_clear", acl_parse_str, acl_fetch_auth, acl_match_str },
5954 { "auth_md5", acl_parse_str, acl_fetch_auth, acl_match_md5 },
5955 { NULL, NULL, NULL, NULL },
5956#endif
5957}};
5958
5959
5960__attribute__((constructor))
5961static void __http_protocol_init(void)
5962{
5963 acl_register_keywords(&acl_kws);
5964}
5965
5966
Willy Tarreau58f10d72006-12-04 02:26:12 +0100[diff] [blame]5967/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200[diff] [blame]5968 * Local variables:
5969 * c-indent-level: 8
5970 * c-basic-offset: 8
5971 * End:
5972 */