blob: 9d9a7466a643024d5406613a2e5ce63cdb98a418 [file] [log] [blame]
Willy Tarreaua84d3742007-05-07 00:36:48 +02001/*
2 * ACL management functions.
3 *
Willy Tarreau06457872010-05-23 12:24:38 +02004 * Copyright 2000-2010 Willy Tarreau <w@1wt.eu>
Willy Tarreaua84d3742007-05-07 00:36:48 +02005 *
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
Willy Tarreauae8b7962007-06-09 23:10:04 +020013#include <ctype.h>
Willy Tarreaua84d3742007-05-07 00:36:48 +020014#include <stdio.h>
15#include <string.h>
16
17#include <common/config.h>
18#include <common/mini-clist.h>
19#include <common/standard.h>
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +010020#include <common/uri_auth.h>
Willy Tarreaua84d3742007-05-07 00:36:48 +020021
Willy Tarreau2b5285d2010-05-09 23:45:24 +020022#include <types/global.h>
23
Willy Tarreaua84d3742007-05-07 00:36:48 +020024#include <proto/acl.h>
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +010025#include <proto/auth.h>
Willy Tarreau44b90cc2010-05-24 20:27:29 +020026#include <proto/buffers.h>
Willy Tarreau404e8ab2009-07-26 19:40:40 +020027#include <proto/log.h>
Willy Tarreau0b1cd942010-05-16 22:18:27 +020028#include <proto/proxy.h>
Willy Tarreaua84d3742007-05-07 00:36:48 +020029
Willy Tarreauc4262962010-05-10 23:42:40 +020030#include <ebsttree.h>
31
Willy Tarreaua9802632008-07-25 19:13:19 +020032/* The capabilities of filtering hooks describe the type of information
33 * available to each of them.
34 */
35const unsigned int filt_cap[] = {
36 [ACL_HOOK_REQ_FE_TCP] = ACL_USE_TCP4_ANY|ACL_USE_TCP6_ANY|ACL_USE_TCP_ANY,
Willy Tarreau06457872010-05-23 12:24:38 +020037 [ACL_HOOK_REQ_FE_TCP_CONTENT] = ACL_USE_TCP4_ANY|ACL_USE_TCP6_ANY|ACL_USE_TCP_ANY|ACL_USE_L6REQ_ANY,
38 [ACL_HOOK_REQ_FE_HTTP_IN] = ACL_USE_TCP4_ANY|ACL_USE_TCP6_ANY|ACL_USE_TCP_ANY|ACL_USE_L6REQ_ANY|ACL_USE_L7REQ_ANY|ACL_USE_HDR_ANY,
39 [ACL_HOOK_REQ_FE_SWITCH] = ACL_USE_TCP4_ANY|ACL_USE_TCP6_ANY|ACL_USE_TCP_ANY|ACL_USE_L6REQ_ANY|ACL_USE_L7REQ_ANY|ACL_USE_HDR_ANY,
40 [ACL_HOOK_REQ_BE_TCP_CONTENT] = ACL_USE_TCP4_ANY|ACL_USE_TCP6_ANY|ACL_USE_TCP_ANY|ACL_USE_L6REQ_ANY|ACL_USE_L7REQ_ANY|ACL_USE_HDR_ANY,
41 [ACL_HOOK_REQ_BE_HTTP_IN] = ACL_USE_TCP4_ANY|ACL_USE_TCP6_ANY|ACL_USE_TCP_ANY|ACL_USE_L6REQ_ANY|ACL_USE_L7REQ_ANY|ACL_USE_HDR_ANY,
42 [ACL_HOOK_REQ_BE_SWITCH] = ACL_USE_TCP4_ANY|ACL_USE_TCP6_ANY|ACL_USE_TCP_ANY|ACL_USE_L6REQ_ANY|ACL_USE_L7REQ_ANY|ACL_USE_HDR_ANY,
43 [ACL_HOOK_REQ_FE_HTTP_OUT] = ACL_USE_TCP4_ANY|ACL_USE_TCP6_ANY|ACL_USE_TCP_ANY|ACL_USE_L6REQ_ANY|ACL_USE_L7REQ_ANY|ACL_USE_HDR_ANY,
44 [ACL_HOOK_REQ_BE_HTTP_OUT] = ACL_USE_TCP4_ANY|ACL_USE_TCP6_ANY|ACL_USE_TCP_ANY|ACL_USE_L6REQ_ANY|ACL_USE_L7REQ_ANY|ACL_USE_HDR_ANY,
Willy Tarreaua9802632008-07-25 19:13:19 +020045
Willy Tarreau06457872010-05-23 12:24:38 +020046 [ACL_HOOK_RTR_BE_TCP_CONTENT] = ACL_USE_REQ_PERMANENT|ACL_USE_REQ_CACHEABLE|ACL_USE_L6RTR_ANY,
47 [ACL_HOOK_RTR_BE_HTTP_IN] = ACL_USE_REQ_PERMANENT|ACL_USE_REQ_CACHEABLE|ACL_USE_L6RTR_ANY|ACL_USE_L7RTR_ANY,
48 [ACL_HOOK_RTR_FE_TCP_CONTENT] = ACL_USE_REQ_PERMANENT|ACL_USE_REQ_CACHEABLE|ACL_USE_L6RTR_ANY|ACL_USE_L7RTR_ANY,
49 [ACL_HOOK_RTR_FE_HTTP_IN] = ACL_USE_REQ_PERMANENT|ACL_USE_REQ_CACHEABLE|ACL_USE_L6RTR_ANY|ACL_USE_L7RTR_ANY,
50 [ACL_HOOK_RTR_BE_HTTP_OUT] = ACL_USE_REQ_PERMANENT|ACL_USE_REQ_CACHEABLE|ACL_USE_L6RTR_ANY|ACL_USE_L7RTR_ANY,
51 [ACL_HOOK_RTR_FE_HTTP_OUT] = ACL_USE_REQ_PERMANENT|ACL_USE_REQ_CACHEABLE|ACL_USE_L6RTR_ANY|ACL_USE_L7RTR_ANY,
Willy Tarreaua9802632008-07-25 19:13:19 +020052};
53
Willy Tarreaua84d3742007-05-07 00:36:48 +020054/* List head of all known ACL keywords */
55static struct acl_kw_list acl_keywords = {
56 .list = LIST_HEAD_INIT(acl_keywords.list)
57};
58
59
Willy Tarreaua5909832007-06-17 20:40:25 +020060/*
61 * These functions are only used for debugging complex configurations.
Willy Tarreaua84d3742007-05-07 00:36:48 +020062 */
Willy Tarreaua5909832007-06-17 20:40:25 +020063
Willy Tarreau58393e12008-07-20 10:39:22 +020064/* force TRUE to be returned at the fetch level */
Willy Tarreaua5909832007-06-17 20:40:25 +020065static int
Willy Tarreau58393e12008-07-20 10:39:22 +020066acl_fetch_true(struct proxy *px, struct session *l4, void *l7, int dir,
67 struct acl_expr *expr, struct acl_test *test)
Willy Tarreaua5909832007-06-17 20:40:25 +020068{
Willy Tarreau58393e12008-07-20 10:39:22 +020069 test->flags |= ACL_TEST_F_SET_RES_PASS;
Willy Tarreaua5909832007-06-17 20:40:25 +020070 return 1;
71}
72
Willy Tarreaub6fb4202008-07-20 11:18:28 +020073/* wait for more data as long as possible, then return TRUE. This should be
74 * used with content inspection.
75 */
76static int
77acl_fetch_wait_end(struct proxy *px, struct session *l4, void *l7, int dir,
78 struct acl_expr *expr, struct acl_test *test)
79{
80 if (dir & ACL_PARTIAL) {
81 test->flags |= ACL_TEST_F_MAY_CHANGE;
82 return 0;
83 }
84 test->flags |= ACL_TEST_F_SET_RES_PASS;
85 return 1;
86}
87
Willy Tarreau58393e12008-07-20 10:39:22 +020088/* force FALSE to be returned at the fetch level */
Willy Tarreaua5909832007-06-17 20:40:25 +020089static int
Willy Tarreau58393e12008-07-20 10:39:22 +020090acl_fetch_false(struct proxy *px, struct session *l4, void *l7, int dir,
91 struct acl_expr *expr, struct acl_test *test)
Willy Tarreaua84d3742007-05-07 00:36:48 +020092{
Willy Tarreau58393e12008-07-20 10:39:22 +020093 test->flags |= ACL_TEST_F_SET_RES_FAIL;
Willy Tarreaua84d3742007-05-07 00:36:48 +020094 return 1;
95}
96
Willy Tarreau44b90cc2010-05-24 20:27:29 +020097/* return the number of bytes in the request buffer */
98static int
99acl_fetch_req_len(struct proxy *px, struct session *l4, void *l7, int dir,
100 struct acl_expr *expr, struct acl_test *test)
101{
102 if (!l4 || !l4->req)
103 return 0;
104
105 test->i = l4->req->l;
106 test->flags = ACL_TEST_F_VOLATILE | ACL_TEST_F_MAY_CHANGE;
107 return 1;
108}
109
Emeric Brun38e71762010-09-23 17:59:18 +0200110
111static int
112acl_fetch_ssl_hello_type(struct proxy *px, struct session *l4, void *l7, int dir,
113 struct acl_expr *expr, struct acl_test *test)
114{
115 int hs_len;
116 int hs_type, bleft;
117 struct buffer *b;
118 const unsigned char *data;
119
120 if (!l4)
121 goto not_ssl_hello;
122
123 b = ((dir & ACL_DIR_MASK) == ACL_DIR_RTR) ? l4->rep : l4->req;
124
125 bleft = b->l;
126 data = (const unsigned char *)b->w;
127
128 if (!bleft)
129 goto too_short;
130
131 if ((*data >= 0x14 && *data <= 0x17) || (*data == 0xFF)) {
132 /* SSLv3 header format */
133 if (bleft < 9)
134 goto too_short;
135
136 /* ssl version 3 */
137 if ((data[1] << 16) + data[2] < 0x00030000)
138 goto not_ssl_hello;
139
140 /* ssl message len must present handshake type and len */
141 if ((data[3] << 8) + data[4] < 4)
142 goto not_ssl_hello;
143
144 /* format introduced with SSLv3 */
145
146 hs_type = (int)data[5];
147 hs_len = ( data[6] << 16 ) + ( data[7] << 8 ) + data[8];
148
149 /* not a full handshake */
150 if (bleft < (9 + hs_len))
151 goto too_short;
152
153 }
154 else {
155 goto not_ssl_hello;
156 }
157
158 test->i = hs_type;
159 test->flags = ACL_TEST_F_VOLATILE;
160
161 return 1;
162
163 too_short:
164 test->flags = ACL_TEST_F_MAY_CHANGE;
165
166 not_ssl_hello:
167
168 return 0;
169}
170
Willy Tarreau44b90cc2010-05-24 20:27:29 +0200171/* Return the version of the SSL protocol in the request. It supports both
172 * SSLv3 (TLSv1) header format for any message, and SSLv2 header format for
173 * the hello message. The SSLv3 format is described in RFC 2246 p49, and the
174 * SSLv2 format is described here, and completed p67 of RFC 2246 :
175 * http://wp.netscape.com/eng/security/SSL_2.html
176 *
177 * Note: this decoder only works with non-wrapping data.
178 */
179static int
180acl_fetch_req_ssl_ver(struct proxy *px, struct session *l4, void *l7, int dir,
181 struct acl_expr *expr, struct acl_test *test)
182{
183 int version, bleft, msg_len;
184 const unsigned char *data;
185
186 if (!l4 || !l4->req)
187 return 0;
188
189 msg_len = 0;
190 bleft = l4->req->l;
191 if (!bleft)
192 goto too_short;
193
194 data = (const unsigned char *)l4->req->w;
195 if ((*data >= 0x14 && *data <= 0x17) || (*data == 0xFF)) {
196 /* SSLv3 header format */
197 if (bleft < 5)
198 goto too_short;
199
200 version = (data[1] << 16) + data[2]; /* version: major, minor */
201 msg_len = (data[3] << 8) + data[4]; /* record length */
202
203 /* format introduced with SSLv3 */
204 if (version < 0x00030000)
205 goto not_ssl;
206
207 /* message length between 1 and 2^14 + 2048 */
208 if (msg_len < 1 || msg_len > ((1<<14) + 2048))
209 goto not_ssl;
210
211 bleft -= 5; data += 5;
212 } else {
213 /* SSLv2 header format, only supported for hello (msg type 1) */
214 int rlen, plen, cilen, silen, chlen;
215
216 if (*data & 0x80) {
217 if (bleft < 3)
218 goto too_short;
219 /* short header format : 15 bits for length */
220 rlen = ((data[0] & 0x7F) << 8) | data[1];
221 plen = 0;
222 bleft -= 2; data += 2;
223 } else {
224 if (bleft < 4)
225 goto too_short;
226 /* long header format : 14 bits for length + pad length */
227 rlen = ((data[0] & 0x3F) << 8) | data[1];
228 plen = data[2];
229 bleft -= 3; data += 2;
230 }
231
232 if (*data != 0x01)
233 goto not_ssl;
234 bleft--; data++;
235
236 if (bleft < 8)
237 goto too_short;
238 version = (data[0] << 16) + data[1]; /* version: major, minor */
239 cilen = (data[2] << 8) + data[3]; /* cipher len, multiple of 3 */
240 silen = (data[4] << 8) + data[5]; /* session_id_len: 0 or 16 */
241 chlen = (data[6] << 8) + data[7]; /* 16<=challenge length<=32 */
242
243 bleft -= 8; data += 8;
244 if (cilen % 3 != 0)
245 goto not_ssl;
246 if (silen && silen != 16)
247 goto not_ssl;
248 if (chlen < 16 || chlen > 32)
249 goto not_ssl;
250 if (rlen != 9 + cilen + silen + chlen)
251 goto not_ssl;
252
253 /* focus on the remaining data length */
254 msg_len = cilen + silen + chlen + plen;
255 }
256 /* We could recursively check that the buffer ends exactly on an SSL
257 * fragment boundary and that a possible next segment is still SSL,
258 * but that's a bit pointless. However, we could still check that
259 * all the part of the request which fits in a buffer is already
260 * there.
261 */
262 if (msg_len > buffer_max_len(l4->req) + l4->req->data - l4->req->w)
263 msg_len = buffer_max_len(l4->req) + l4->req->data - l4->req->w;
264
265 if (bleft < msg_len)
266 goto too_short;
267
268 /* OK that's enough. We have at least the whole message, and we have
269 * the protocol version.
270 */
271 test->i = version;
272 test->flags = ACL_TEST_F_VOLATILE;
273 return 1;
274
275 too_short:
276 test->flags = ACL_TEST_F_MAY_CHANGE;
277 not_ssl:
278 return 0;
279}
280
281/* Fetch the RDP cookie identified in the expression.
282 * Note: this decoder only works with non-wrapping data.
283 */
284int
285acl_fetch_rdp_cookie(struct proxy *px, struct session *l4, void *l7, int dir,
286 struct acl_expr *expr, struct acl_test *test)
287{
288 int bleft;
289 const unsigned char *data;
290
291 if (!l4 || !l4->req)
292 return 0;
293
294 test->flags = 0;
295
296 bleft = l4->req->l;
297 if (bleft <= 11)
298 goto too_short;
299
300 data = (const unsigned char *)l4->req->w + 11;
301 bleft -= 11;
302
303 if (bleft <= 7)
304 goto too_short;
305
306 if (strncasecmp((const char *)data, "Cookie:", 7) != 0)
307 goto not_cookie;
308
309 data += 7;
310 bleft -= 7;
311
312 while (bleft > 0 && *data == ' ') {
313 data++;
314 bleft--;
315 }
316
317 if (expr->arg_len) {
318
319 if (bleft <= expr->arg_len)
320 goto too_short;
321
322 if ((data[expr->arg_len] != '=') ||
323 strncasecmp(expr->arg.str, (const char *)data, expr->arg_len) != 0)
324 goto not_cookie;
325
326 data += expr->arg_len + 1;
327 bleft -= expr->arg_len + 1;
328 } else {
329 while (bleft > 0 && *data != '=') {
330 if (*data == '\r' || *data == '\n')
331 goto not_cookie;
332 data++;
333 bleft--;
334 }
335
336 if (bleft < 1)
337 goto too_short;
338
339 if (*data != '=')
340 goto not_cookie;
341
342 data++;
343 bleft--;
344 }
345
346 /* data points to cookie value */
347 test->ptr = (char *)data;
348 test->len = 0;
349
350 while (bleft > 0 && *data != '\r') {
351 data++;
352 bleft--;
353 }
354
355 if (bleft < 2)
356 goto too_short;
357
358 if (data[0] != '\r' || data[1] != '\n')
359 goto not_cookie;
360
361 test->len = (char *)data - test->ptr;
362 test->flags = ACL_TEST_F_VOLATILE;
363 return 1;
364
365 too_short:
366 test->flags = ACL_TEST_F_MAY_CHANGE;
367 not_cookie:
368 return 0;
369}
370
371static int
372acl_fetch_rdp_cookie_cnt(struct proxy *px, struct session *l4, void *l7, int dir,
373 struct acl_expr *expr, struct acl_test *test)
374{
375 int ret;
376
377 ret = acl_fetch_rdp_cookie(px, l4, l7, dir, expr, test);
378
379 test->ptr = NULL;
380 test->len = 0;
381
382 if (test->flags & ACL_TEST_F_MAY_CHANGE)
383 return 0;
384
385 test->flags = ACL_TEST_F_VOLATILE;
386 test->i = ret;
387
388 return 1;
389}
390
Willy Tarreau58393e12008-07-20 10:39:22 +0200391
392/*
393 * These functions are exported and may be used by any other component.
394 */
395
396/* ignore the current line */
397int acl_parse_nothing(const char **text, struct acl_pattern *pattern, int *opaque)
Willy Tarreaua5909832007-06-17 20:40:25 +0200398{
Willy Tarreau58393e12008-07-20 10:39:22 +0200399 return 1;
400}
401
402/* always fake a data retrieval */
403int acl_fetch_nothing(struct proxy *px, struct session *l4, void *l7, int dir,
404 struct acl_expr *expr, struct acl_test *test)
405{
406 return 1;
Willy Tarreaua5909832007-06-17 20:40:25 +0200407}
408
409/* always return false */
Willy Tarreau58393e12008-07-20 10:39:22 +0200410int acl_match_nothing(struct acl_test *test, struct acl_pattern *pattern)
Willy Tarreaua5909832007-06-17 20:40:25 +0200411{
Willy Tarreau11382812008-07-09 16:18:21 +0200412 return ACL_PAT_FAIL;
Willy Tarreaua5909832007-06-17 20:40:25 +0200413}
414
415
Willy Tarreaua84d3742007-05-07 00:36:48 +0200416/* NB: For two strings to be identical, it is required that their lengths match */
417int acl_match_str(struct acl_test *test, struct acl_pattern *pattern)
418{
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200419 int icase;
420
Willy Tarreaua84d3742007-05-07 00:36:48 +0200421 if (pattern->len != test->len)
Willy Tarreau11382812008-07-09 16:18:21 +0200422 return ACL_PAT_FAIL;
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200423
424 icase = pattern->flags & ACL_PAT_F_IGNORE_CASE;
425 if ((icase && strncasecmp(pattern->ptr.str, test->ptr, test->len) == 0) ||
426 (!icase && strncmp(pattern->ptr.str, test->ptr, test->len) == 0))
Willy Tarreau11382812008-07-09 16:18:21 +0200427 return ACL_PAT_PASS;
428 return ACL_PAT_FAIL;
Willy Tarreaua84d3742007-05-07 00:36:48 +0200429}
430
Willy Tarreauc4262962010-05-10 23:42:40 +0200431/* Lookup a string in the expression's pattern tree. The node is returned if it
432 * exists, otherwise NULL.
433 */
434void *acl_lookup_str(struct acl_test *test, struct acl_expr *expr)
435{
436 /* data are stored in a tree */
437 struct ebmb_node *node;
438 char prev;
439
440 /* we may have to force a trailing zero on the test pattern */
441 prev = test->ptr[test->len];
442 if (prev)
443 test->ptr[test->len] = '\0';
444 node = ebst_lookup(&expr->pattern_tree, test->ptr);
445 if (prev)
446 test->ptr[test->len] = prev;
447 return node;
448}
449
Willy Tarreauf3d25982007-05-08 22:45:09 +0200450/* Executes a regex. It needs to change the data. If it is marked READ_ONLY
451 * then it will be allocated and duplicated in place so that others may use
452 * it later on. Note that this is embarrassing because we always try to avoid
453 * allocating memory at run time.
454 */
455int acl_match_reg(struct acl_test *test, struct acl_pattern *pattern)
456{
457 char old_char;
458 int ret;
459
460 if (unlikely(test->flags & ACL_TEST_F_READ_ONLY)) {
461 char *new_str;
462
463 new_str = calloc(1, test->len + 1);
464 if (!new_str)
Willy Tarreau11382812008-07-09 16:18:21 +0200465 return ACL_PAT_FAIL;
Willy Tarreauf3d25982007-05-08 22:45:09 +0200466
467 memcpy(new_str, test->ptr, test->len);
468 new_str[test->len] = 0;
469 if (test->flags & ACL_TEST_F_MUST_FREE)
470 free(test->ptr);
471 test->ptr = new_str;
472 test->flags |= ACL_TEST_F_MUST_FREE;
473 test->flags &= ~ACL_TEST_F_READ_ONLY;
474 }
475
476 old_char = test->ptr[test->len];
477 test->ptr[test->len] = 0;
478
479 if (regexec(pattern->ptr.reg, test->ptr, 0, NULL, 0) == 0)
Willy Tarreau11382812008-07-09 16:18:21 +0200480 ret = ACL_PAT_PASS;
Willy Tarreauf3d25982007-05-08 22:45:09 +0200481 else
Willy Tarreau11382812008-07-09 16:18:21 +0200482 ret = ACL_PAT_FAIL;
Willy Tarreauf3d25982007-05-08 22:45:09 +0200483
484 test->ptr[test->len] = old_char;
485 return ret;
486}
487
Willy Tarreaua84d3742007-05-07 00:36:48 +0200488/* Checks that the pattern matches the beginning of the tested string. */
489int acl_match_beg(struct acl_test *test, struct acl_pattern *pattern)
490{
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200491 int icase;
492
Willy Tarreaua84d3742007-05-07 00:36:48 +0200493 if (pattern->len > test->len)
Willy Tarreau11382812008-07-09 16:18:21 +0200494 return ACL_PAT_FAIL;
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200495
496 icase = pattern->flags & ACL_PAT_F_IGNORE_CASE;
497 if ((icase && strncasecmp(pattern->ptr.str, test->ptr, pattern->len) != 0) ||
498 (!icase && strncmp(pattern->ptr.str, test->ptr, pattern->len) != 0))
Willy Tarreau11382812008-07-09 16:18:21 +0200499 return ACL_PAT_FAIL;
500 return ACL_PAT_PASS;
Willy Tarreaua84d3742007-05-07 00:36:48 +0200501}
502
503/* Checks that the pattern matches the end of the tested string. */
504int acl_match_end(struct acl_test *test, struct acl_pattern *pattern)
505{
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200506 int icase;
507
Willy Tarreaua84d3742007-05-07 00:36:48 +0200508 if (pattern->len > test->len)
Willy Tarreau11382812008-07-09 16:18:21 +0200509 return ACL_PAT_FAIL;
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200510 icase = pattern->flags & ACL_PAT_F_IGNORE_CASE;
511 if ((icase && strncasecmp(pattern->ptr.str, test->ptr + test->len - pattern->len, pattern->len) != 0) ||
512 (!icase && strncmp(pattern->ptr.str, test->ptr + test->len - pattern->len, pattern->len) != 0))
Willy Tarreau11382812008-07-09 16:18:21 +0200513 return ACL_PAT_FAIL;
514 return ACL_PAT_PASS;
Willy Tarreaua84d3742007-05-07 00:36:48 +0200515}
516
517/* Checks that the pattern is included inside the tested string.
518 * NB: Suboptimal, should be rewritten using a Boyer-Moore method.
519 */
520int acl_match_sub(struct acl_test *test, struct acl_pattern *pattern)
521{
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200522 int icase;
Willy Tarreaua84d3742007-05-07 00:36:48 +0200523 char *end;
524 char *c;
525
526 if (pattern->len > test->len)
Willy Tarreau11382812008-07-09 16:18:21 +0200527 return ACL_PAT_FAIL;
Willy Tarreaua84d3742007-05-07 00:36:48 +0200528
529 end = test->ptr + test->len - pattern->len;
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200530 icase = pattern->flags & ACL_PAT_F_IGNORE_CASE;
531 if (icase) {
532 for (c = test->ptr; c <= end; c++) {
533 if (tolower(*c) != tolower(*pattern->ptr.str))
534 continue;
535 if (strncasecmp(pattern->ptr.str, c, pattern->len) == 0)
Willy Tarreau11382812008-07-09 16:18:21 +0200536 return ACL_PAT_PASS;
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200537 }
538 } else {
539 for (c = test->ptr; c <= end; c++) {
540 if (*c != *pattern->ptr.str)
541 continue;
542 if (strncmp(pattern->ptr.str, c, pattern->len) == 0)
Willy Tarreau11382812008-07-09 16:18:21 +0200543 return ACL_PAT_PASS;
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200544 }
Willy Tarreaua84d3742007-05-07 00:36:48 +0200545 }
Willy Tarreau11382812008-07-09 16:18:21 +0200546 return ACL_PAT_FAIL;
Willy Tarreaua84d3742007-05-07 00:36:48 +0200547}
548
549/* This one is used by other real functions. It checks that the pattern is
550 * included inside the tested string, but enclosed between the specified
551 * delimitor, or a '/' or a '?' or at the beginning or end of the string.
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200552 * The delimitor is stripped at the beginning or end of the pattern.
Willy Tarreaua84d3742007-05-07 00:36:48 +0200553 */
554static int match_word(struct acl_test *test, struct acl_pattern *pattern, char delim)
555{
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200556 int may_match, icase;
Willy Tarreaua84d3742007-05-07 00:36:48 +0200557 char *c, *end;
558 char *ps;
559 int pl;
560
561 pl = pattern->len;
562 ps = pattern->ptr.str;
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200563 while (pl > 0 && (*ps == delim || *ps == '/' || *ps == '?')) {
Willy Tarreaua84d3742007-05-07 00:36:48 +0200564 pl--;
565 ps++;
566 }
567
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200568 while (pl > 0 &&
569 (ps[pl - 1] == delim || ps[pl - 1] == '/' || ps[pl - 1] == '?'))
Willy Tarreaua84d3742007-05-07 00:36:48 +0200570 pl--;
571
572 if (pl > test->len)
Willy Tarreau11382812008-07-09 16:18:21 +0200573 return ACL_PAT_FAIL;
Willy Tarreaua84d3742007-05-07 00:36:48 +0200574
575 may_match = 1;
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200576 icase = pattern->flags & ACL_PAT_F_IGNORE_CASE;
Willy Tarreaua84d3742007-05-07 00:36:48 +0200577 end = test->ptr + test->len - pl;
578 for (c = test->ptr; c <= end; c++) {
579 if (*c == '/' || *c == delim || *c == '?') {
580 may_match = 1;
581 continue;
582 }
Willy Tarreaua84d3742007-05-07 00:36:48 +0200583
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200584 if (!may_match)
585 continue;
586
587 if (icase) {
588 if ((tolower(*c) == tolower(*ps)) &&
589 (strncasecmp(ps, c, pl) == 0) &&
590 (c == end || c[pl] == '/' || c[pl] == delim || c[pl] == '?'))
Willy Tarreau11382812008-07-09 16:18:21 +0200591 return ACL_PAT_PASS;
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200592 } else {
593 if ((*c == *ps) &&
594 (strncmp(ps, c, pl) == 0) &&
595 (c == end || c[pl] == '/' || c[pl] == delim || c[pl] == '?'))
Willy Tarreau11382812008-07-09 16:18:21 +0200596 return ACL_PAT_PASS;
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200597 }
Willy Tarreaua84d3742007-05-07 00:36:48 +0200598 may_match = 0;
599 }
Willy Tarreau11382812008-07-09 16:18:21 +0200600 return ACL_PAT_FAIL;
Willy Tarreaua84d3742007-05-07 00:36:48 +0200601}
602
603/* Checks that the pattern is included inside the tested string, but enclosed
604 * between slashes or at the beginning or end of the string. Slashes at the
605 * beginning or end of the pattern are ignored.
606 */
607int acl_match_dir(struct acl_test *test, struct acl_pattern *pattern)
608{
609 return match_word(test, pattern, '/');
610}
611
612/* Checks that the pattern is included inside the tested string, but enclosed
613 * between dots or at the beginning or end of the string. Dots at the beginning
614 * or end of the pattern are ignored.
615 */
616int acl_match_dom(struct acl_test *test, struct acl_pattern *pattern)
617{
618 return match_word(test, pattern, '.');
619}
620
621/* Checks that the integer in <test> is included between min and max */
Willy Tarreauae8b7962007-06-09 23:10:04 +0200622int acl_match_int(struct acl_test *test, struct acl_pattern *pattern)
Willy Tarreaua84d3742007-05-07 00:36:48 +0200623{
Willy Tarreauae8b7962007-06-09 23:10:04 +0200624 if ((!pattern->val.range.min_set || pattern->val.range.min <= test->i) &&
625 (!pattern->val.range.max_set || test->i <= pattern->val.range.max))
Willy Tarreau11382812008-07-09 16:18:21 +0200626 return ACL_PAT_PASS;
627 return ACL_PAT_FAIL;
Willy Tarreaua84d3742007-05-07 00:36:48 +0200628}
629
Willy Tarreaua67fad92007-05-08 19:50:09 +0200630int acl_match_ip(struct acl_test *test, struct acl_pattern *pattern)
631{
632 struct in_addr *s;
633
634 if (test->i != AF_INET)
Willy Tarreau11382812008-07-09 16:18:21 +0200635 return ACL_PAT_FAIL;
Willy Tarreaua67fad92007-05-08 19:50:09 +0200636
637 s = (void *)test->ptr;
638 if (((s->s_addr ^ pattern->val.ipv4.addr.s_addr) & pattern->val.ipv4.mask.s_addr) == 0)
Willy Tarreau11382812008-07-09 16:18:21 +0200639 return ACL_PAT_PASS;
640 return ACL_PAT_FAIL;
Willy Tarreaua67fad92007-05-08 19:50:09 +0200641}
642
Willy Tarreaub337b532010-05-13 20:03:41 +0200643/* Lookup an IPv4 address in the expression's pattern tree using the longest
644 * match method. The node is returned if it exists, otherwise NULL.
645 */
646void *acl_lookup_ip(struct acl_test *test, struct acl_expr *expr)
647{
648 struct in_addr *s;
649
650 if (test->i != AF_INET)
651 return ACL_PAT_FAIL;
652
653 s = (void *)test->ptr;
654
655 return ebmb_lookup_longest(&expr->pattern_tree, &s->s_addr);
656}
657
Willy Tarreaua84d3742007-05-07 00:36:48 +0200658/* Parse a string. It is allocated and duplicated. */
Willy Tarreauae8b7962007-06-09 23:10:04 +0200659int acl_parse_str(const char **text, struct acl_pattern *pattern, int *opaque)
Willy Tarreaua84d3742007-05-07 00:36:48 +0200660{
661 int len;
662
Willy Tarreauae8b7962007-06-09 23:10:04 +0200663 len = strlen(*text);
Willy Tarreauc4262962010-05-10 23:42:40 +0200664
665 if (pattern->flags & ACL_PAT_F_TREE_OK) {
666 /* we're allowed to put the data in a tree whose root is pointed
667 * to by val.tree.
668 */
669 struct ebmb_node *node;
670
671 node = calloc(1, sizeof(*node) + len + 1);
672 if (!node)
673 return 0;
674 memcpy(node->key, *text, len + 1);
675 if (ebst_insert(pattern->val.tree, node) != node)
676 free(node); /* was a duplicate */
677 pattern->flags |= ACL_PAT_F_TREE; /* this pattern now contains a tree */
678 return 1;
679 }
680
Willy Tarreauae8b7962007-06-09 23:10:04 +0200681 pattern->ptr.str = strdup(*text);
Willy Tarreaua84d3742007-05-07 00:36:48 +0200682 if (!pattern->ptr.str)
683 return 0;
684 pattern->len = len;
685 return 1;
686}
687
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +0100688/* Parse and concatenate all further strings into one. */
689int
690acl_parse_strcat(const char **text, struct acl_pattern *pattern, int *opaque)
691{
692
693 int len = 0, i;
694 char *s;
695
696 for (i = 0; *text[i]; i++)
697 len += strlen(text[i])+1;
698
699 pattern->ptr.str = s = calloc(1, len);
700 if (!pattern->ptr.str)
701 return 0;
702
703 for (i = 0; *text[i]; i++)
704 s += sprintf(s, i?" %s":"%s", text[i]);
705
706 pattern->len = len;
707
708 return i;
709}
710
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +0200711/* Free data allocated by acl_parse_reg */
712static void acl_free_reg(void *ptr) {
713
714 regfree((regex_t *)ptr);
715}
716
Willy Tarreauf3d25982007-05-08 22:45:09 +0200717/* Parse a regex. It is allocated. */
Willy Tarreauae8b7962007-06-09 23:10:04 +0200718int acl_parse_reg(const char **text, struct acl_pattern *pattern, int *opaque)
Willy Tarreauf3d25982007-05-08 22:45:09 +0200719{
720 regex_t *preg;
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200721 int icase;
Willy Tarreauf3d25982007-05-08 22:45:09 +0200722
723 preg = calloc(1, sizeof(regex_t));
724
725 if (!preg)
726 return 0;
727
Willy Tarreauc8d7c962007-06-17 08:20:33 +0200728 icase = (pattern->flags & ACL_PAT_F_IGNORE_CASE) ? REG_ICASE : 0;
729 if (regcomp(preg, *text, REG_EXTENDED | REG_NOSUB | icase) != 0) {
Willy Tarreauf3d25982007-05-08 22:45:09 +0200730 free(preg);
731 return 0;
732 }
733
734 pattern->ptr.reg = preg;
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +0200735 pattern->freeptrbuf = &acl_free_reg;
Willy Tarreauf3d25982007-05-08 22:45:09 +0200736 return 1;
737}
738
Willy Tarreauae8b7962007-06-09 23:10:04 +0200739/* Parse a range of positive integers delimited by either ':' or '-'. If only
740 * one integer is read, it is set as both min and max. An operator may be
741 * specified as the prefix, among this list of 5 :
742 *
743 * 0:eq, 1:gt, 2:ge, 3:lt, 4:le
744 *
745 * The default operator is "eq". It supports range matching. Ranges are
746 * rejected for other operators. The operator may be changed at any time.
747 * The operator is stored in the 'opaque' argument.
748 *
Willy Tarreaua84d3742007-05-07 00:36:48 +0200749 */
Willy Tarreauae8b7962007-06-09 23:10:04 +0200750int acl_parse_int(const char **text, struct acl_pattern *pattern, int *opaque)
Willy Tarreaua84d3742007-05-07 00:36:48 +0200751{
Willy Tarreauae8b7962007-06-09 23:10:04 +0200752 signed long long i;
753 unsigned int j, last, skip = 0;
754 const char *ptr = *text;
755
756
Willy Tarreau8f8e6452007-06-17 21:51:38 +0200757 while (!isdigit((unsigned char)*ptr)) {
Willy Tarreau1c7cc5b2010-07-18 10:46:33 +0200758 switch (get_std_op(ptr)) {
759 case STD_OP_EQ: *opaque = 0; break;
760 case STD_OP_GT: *opaque = 1; break;
761 case STD_OP_GE: *opaque = 2; break;
762 case STD_OP_LT: *opaque = 3; break;
763 case STD_OP_LE: *opaque = 4; break;
764 default:
Willy Tarreauae8b7962007-06-09 23:10:04 +0200765 return 0;
Willy Tarreau1c7cc5b2010-07-18 10:46:33 +0200766 }
Willy Tarreauae8b7962007-06-09 23:10:04 +0200767
768 skip++;
769 ptr = text[skip];
770 }
Willy Tarreaua84d3742007-05-07 00:36:48 +0200771
772 last = i = 0;
773 while (1) {
Willy Tarreauae8b7962007-06-09 23:10:04 +0200774 j = *ptr++;
Willy Tarreaua84d3742007-05-07 00:36:48 +0200775 if ((j == '-' || j == ':') && !last) {
776 last++;
777 pattern->val.range.min = i;
778 i = 0;
779 continue;
780 }
781 j -= '0';
782 if (j > 9)
783 // also catches the terminating zero
784 break;
785 i *= 10;
786 i += j;
787 }
Willy Tarreauae8b7962007-06-09 23:10:04 +0200788
789 if (last && *opaque >= 1 && *opaque <= 4)
790 /* having a range with a min or a max is absurd */
791 return 0;
792
Willy Tarreaua84d3742007-05-07 00:36:48 +0200793 if (!last)
794 pattern->val.range.min = i;
795 pattern->val.range.max = i;
Willy Tarreauae8b7962007-06-09 23:10:04 +0200796
797 switch (*opaque) {
798 case 0: /* eq */
799 pattern->val.range.min_set = 1;
800 pattern->val.range.max_set = 1;
801 break;
802 case 1: /* gt */
803 pattern->val.range.min++; /* gt = ge + 1 */
804 case 2: /* ge */
805 pattern->val.range.min_set = 1;
806 pattern->val.range.max_set = 0;
807 break;
808 case 3: /* lt */
809 pattern->val.range.max--; /* lt = le - 1 */
810 case 4: /* le */
811 pattern->val.range.min_set = 0;
812 pattern->val.range.max_set = 1;
813 break;
814 }
815 return skip + 1;
Willy Tarreaua84d3742007-05-07 00:36:48 +0200816}
817
Willy Tarreau4a26d2f2008-07-15 16:05:33 +0200818/* Parse a range of positive 2-component versions delimited by either ':' or
819 * '-'. The version consists in a major and a minor, both of which must be
820 * smaller than 65536, because internally they will be represented as a 32-bit
821 * integer.
822 * If only one version is read, it is set as both min and max. Just like for
823 * pure integers, an operator may be specified as the prefix, among this list
824 * of 5 :
825 *
826 * 0:eq, 1:gt, 2:ge, 3:lt, 4:le
827 *
828 * The default operator is "eq". It supports range matching. Ranges are
829 * rejected for other operators. The operator may be changed at any time.
830 * The operator is stored in the 'opaque' argument. This allows constructs
831 * such as the following one :
832 *
833 * acl obsolete_ssl ssl_req_proto lt 3
834 * acl unsupported_ssl ssl_req_proto gt 3.1
835 * acl valid_ssl ssl_req_proto 3.0-3.1
836 *
837 */
838int acl_parse_dotted_ver(const char **text, struct acl_pattern *pattern, int *opaque)
839{
840 signed long long i;
841 unsigned int j, last, skip = 0;
842 const char *ptr = *text;
843
844
845 while (!isdigit((unsigned char)*ptr)) {
Willy Tarreau1c7cc5b2010-07-18 10:46:33 +0200846 switch (get_std_op(ptr)) {
847 case STD_OP_EQ: *opaque = 0; break;
848 case STD_OP_GT: *opaque = 1; break;
849 case STD_OP_GE: *opaque = 2; break;
850 case STD_OP_LT: *opaque = 3; break;
851 case STD_OP_LE: *opaque = 4; break;
852 default:
Willy Tarreau4a26d2f2008-07-15 16:05:33 +0200853 return 0;
Willy Tarreau1c7cc5b2010-07-18 10:46:33 +0200854 }
Willy Tarreau4a26d2f2008-07-15 16:05:33 +0200855
856 skip++;
857 ptr = text[skip];
858 }
859
860 last = i = 0;
861 while (1) {
862 j = *ptr++;
863 if (j == '.') {
864 /* minor part */
865 if (i >= 65536)
866 return 0;
867 i <<= 16;
868 continue;
869 }
870 if ((j == '-' || j == ':') && !last) {
871 last++;
872 if (i < 65536)
873 i <<= 16;
874 pattern->val.range.min = i;
875 i = 0;
876 continue;
877 }
878 j -= '0';
879 if (j > 9)
880 // also catches the terminating zero
881 break;
882 i = (i & 0xFFFF0000) + (i & 0xFFFF) * 10;
883 i += j;
884 }
885
886 /* if we only got a major version, let's shift it now */
887 if (i < 65536)
888 i <<= 16;
889
890 if (last && *opaque >= 1 && *opaque <= 4)
891 /* having a range with a min or a max is absurd */
892 return 0;
893
894 if (!last)
895 pattern->val.range.min = i;
896 pattern->val.range.max = i;
897
898 switch (*opaque) {
899 case 0: /* eq */
900 pattern->val.range.min_set = 1;
901 pattern->val.range.max_set = 1;
902 break;
903 case 1: /* gt */
904 pattern->val.range.min++; /* gt = ge + 1 */
905 case 2: /* ge */
906 pattern->val.range.min_set = 1;
907 pattern->val.range.max_set = 0;
908 break;
909 case 3: /* lt */
910 pattern->val.range.max--; /* lt = le - 1 */
911 case 4: /* le */
912 pattern->val.range.min_set = 0;
913 pattern->val.range.max_set = 1;
914 break;
915 }
916 return skip + 1;
917}
918
Willy Tarreaua67fad92007-05-08 19:50:09 +0200919/* Parse an IP address and an optional mask in the form addr[/mask].
920 * The addr may either be an IPv4 address or a hostname. The mask
921 * may either be a dotted mask or a number of bits. Returns 1 if OK,
922 * otherwise 0.
923 */
Willy Tarreauae8b7962007-06-09 23:10:04 +0200924int acl_parse_ip(const char **text, struct acl_pattern *pattern, int *opaque)
Willy Tarreaua67fad92007-05-08 19:50:09 +0200925{
Willy Tarreaub337b532010-05-13 20:03:41 +0200926 struct eb_root *tree = NULL;
927 if (pattern->flags & ACL_PAT_F_TREE_OK)
928 tree = pattern->val.tree;
929
930 if (str2net(*text, &pattern->val.ipv4.addr, &pattern->val.ipv4.mask)) {
931 unsigned int mask = ntohl(pattern->val.ipv4.mask.s_addr);
932 struct ebmb_node *node;
933 /* check if the mask is contiguous so that we can insert the
934 * network into the tree. A continuous mask has only ones on
935 * the left. This means that this mask + its lower bit added
936 * once again is null.
937 */
938 if (mask + (mask & -mask) == 0 && tree) {
939 mask = mask ? 33 - flsnz(mask & -mask) : 0; /* equals cidr value */
940 /* FIXME: insert <addr>/<mask> into the tree here */
941 node = calloc(1, sizeof(*node) + 4); /* reserve 4 bytes for IPv4 address */
942 if (!node)
943 return 0;
944 memcpy(node->key, &pattern->val.ipv4.addr, 4); /* network byte order */
945 node->node.pfx = mask;
946 if (ebmb_insert_prefix(tree, node, 4) != node)
947 free(node); /* was a duplicate */
948 pattern->flags |= ACL_PAT_F_TREE;
949 return 1;
950 }
Willy Tarreauae8b7962007-06-09 23:10:04 +0200951 return 1;
Willy Tarreaub337b532010-05-13 20:03:41 +0200952 }
Willy Tarreauae8b7962007-06-09 23:10:04 +0200953 else
954 return 0;
Willy Tarreaua67fad92007-05-08 19:50:09 +0200955}
956
Willy Tarreaua84d3742007-05-07 00:36:48 +0200957/*
958 * Registers the ACL keyword list <kwl> as a list of valid keywords for next
959 * parsing sessions.
960 */
961void acl_register_keywords(struct acl_kw_list *kwl)
962{
963 LIST_ADDQ(&acl_keywords.list, &kwl->list);
964}
965
966/*
967 * Unregisters the ACL keyword list <kwl> from the list of valid keywords.
968 */
969void acl_unregister_keywords(struct acl_kw_list *kwl)
970{
971 LIST_DEL(&kwl->list);
972 LIST_INIT(&kwl->list);
973}
974
975/* Return a pointer to the ACL <name> within the list starting at <head>, or
976 * NULL if not found.
977 */
978struct acl *find_acl_by_name(const char *name, struct list *head)
979{
980 struct acl *acl;
981 list_for_each_entry(acl, head, list) {
982 if (strcmp(acl->name, name) == 0)
983 return acl;
984 }
985 return NULL;
986}
987
988/* Return a pointer to the ACL keyword <kw>, or NULL if not found. Note that if
989 * <kw> contains an opening parenthesis, only the left part of it is checked.
990 */
991struct acl_keyword *find_acl_kw(const char *kw)
992{
993 int index;
994 const char *kwend;
995 struct acl_kw_list *kwl;
996
997 kwend = strchr(kw, '(');
998 if (!kwend)
999 kwend = kw + strlen(kw);
1000
1001 list_for_each_entry(kwl, &acl_keywords.list, list) {
1002 for (index = 0; kwl->kw[index].kw != NULL; index++) {
1003 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
1004 kwl->kw[index].kw[kwend-kw] == 0)
1005 return &kwl->kw[index];
1006 }
1007 }
1008 return NULL;
1009}
1010
Willy Tarreaudfd7fca2011-03-09 07:27:02 +01001011/* NB: does nothing if <pat> is NULL */
Willy Tarreaua84d3742007-05-07 00:36:48 +02001012static void free_pattern(struct acl_pattern *pat)
1013{
Willy Tarreaudfd7fca2011-03-09 07:27:02 +01001014 if (!pat)
1015 return;
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02001016
1017 if (pat->ptr.ptr) {
1018 if (pat->freeptrbuf)
1019 pat->freeptrbuf(pat->ptr.ptr);
1020
Willy Tarreaua84d3742007-05-07 00:36:48 +02001021 free(pat->ptr.ptr);
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02001022 }
1023
Willy Tarreaua84d3742007-05-07 00:36:48 +02001024 free(pat);
1025}
1026
1027static void free_pattern_list(struct list *head)
1028{
1029 struct acl_pattern *pat, *tmp;
1030 list_for_each_entry_safe(pat, tmp, head, list)
1031 free_pattern(pat);
1032}
1033
Willy Tarreaue56cda92010-05-11 23:25:05 +02001034static void free_pattern_tree(struct eb_root *root)
1035{
1036 struct eb_node *node, *next;
1037 node = eb_first(root);
1038 while (node) {
1039 next = eb_next(node);
1040 free(node);
1041 node = next;
1042 }
1043}
1044
Willy Tarreaua84d3742007-05-07 00:36:48 +02001045static struct acl_expr *prune_acl_expr(struct acl_expr *expr)
1046{
1047 free_pattern_list(&expr->patterns);
Willy Tarreaue56cda92010-05-11 23:25:05 +02001048 free_pattern_tree(&expr->pattern_tree);
Willy Tarreaua84d3742007-05-07 00:36:48 +02001049 LIST_INIT(&expr->patterns);
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01001050 if (expr->arg_len && expr->arg.str)
Willy Tarreaua84d3742007-05-07 00:36:48 +02001051 free(expr->arg.str);
1052 expr->kw->use_cnt--;
1053 return expr;
1054}
1055
Willy Tarreau2b5285d2010-05-09 23:45:24 +02001056static int acl_read_patterns_from_file( struct acl_keyword *aclkw,
1057 struct acl_expr *expr,
1058 const char *filename, int patflags)
1059{
1060 FILE *file;
1061 char *c;
1062 const char *args[2];
1063 struct acl_pattern *pattern;
1064 int opaque;
Willy Tarreau6a8097f2011-02-26 15:14:15 +01001065 int ret = 0;
Willy Tarreau2b5285d2010-05-09 23:45:24 +02001066
1067 file = fopen(filename, "r");
1068 if (!file)
1069 return 0;
1070
1071 /* now parse all patterns. The file may contain only one pattern per
1072 * line. If the line contains spaces, they will be part of the pattern.
1073 * The pattern stops at the first CR, LF or EOF encountered.
1074 */
1075 opaque = 0;
Willy Tarreaue56cda92010-05-11 23:25:05 +02001076 pattern = NULL;
Willy Tarreau2b5285d2010-05-09 23:45:24 +02001077 args[1] = "";
1078 while (fgets(trash, sizeof(trash), file) != NULL) {
1079
1080 c = trash;
Willy Tarreau58215a02010-05-13 22:07:43 +02001081
1082 /* ignore lines beginning with a dash */
1083 if (*c == '#')
1084 continue;
1085
1086 /* strip leading spaces and tabs */
1087 while (*c == ' ' || *c == '\t')
1088 c++;
1089
Willy Tarreau58215a02010-05-13 22:07:43 +02001090
1091 args[0] = c;
Willy Tarreau2b5285d2010-05-09 23:45:24 +02001092 while (*c && *c != '\n' && *c != '\r')
1093 c++;
1094 *c = 0;
1095
Willy Tarreau51091962011-01-03 21:04:10 +01001096 /* empty lines are ignored too */
1097 if (c == args[0])
1098 continue;
1099
Willy Tarreaue56cda92010-05-11 23:25:05 +02001100 /* we keep the previous pattern along iterations as long as it's not used */
1101 if (!pattern)
1102 pattern = (struct acl_pattern *)malloc(sizeof(*pattern));
Willy Tarreau2b5285d2010-05-09 23:45:24 +02001103 if (!pattern)
1104 goto out_close;
Willy Tarreaue56cda92010-05-11 23:25:05 +02001105
1106 memset(pattern, 0, sizeof(*pattern));
Willy Tarreau2b5285d2010-05-09 23:45:24 +02001107 pattern->flags = patflags;
1108
Willy Tarreaue56cda92010-05-11 23:25:05 +02001109 if ((aclkw->requires & ACL_MAY_LOOKUP) && !(pattern->flags & ACL_PAT_F_IGNORE_CASE)) {
1110 /* we pre-set the data pointer to the tree's head so that functions
1111 * which are able to insert in a tree know where to do that.
1112 */
1113 pattern->flags |= ACL_PAT_F_TREE_OK;
1114 pattern->val.tree = &expr->pattern_tree;
1115 }
1116
Willy Tarreau2b5285d2010-05-09 23:45:24 +02001117 if (!aclkw->parse(args, pattern, &opaque))
1118 goto out_free_pattern;
Willy Tarreaue56cda92010-05-11 23:25:05 +02001119
1120 /* if the parser did not feed the tree, let's chain the pattern to the list */
1121 if (!(pattern->flags & ACL_PAT_F_TREE)) {
1122 LIST_ADDQ(&expr->patterns, &pattern->list);
1123 pattern = NULL; /* get a new one */
1124 }
Willy Tarreau2b5285d2010-05-09 23:45:24 +02001125 }
Willy Tarreau6a8097f2011-02-26 15:14:15 +01001126
1127 ret = 1; /* success */
Willy Tarreau2b5285d2010-05-09 23:45:24 +02001128
1129 out_free_pattern:
1130 free_pattern(pattern);
1131 out_close:
1132 fclose(file);
Willy Tarreau6a8097f2011-02-26 15:14:15 +01001133 return ret;
Willy Tarreau2b5285d2010-05-09 23:45:24 +02001134}
1135
Willy Tarreaua84d3742007-05-07 00:36:48 +02001136/* Parse an ACL expression starting at <args>[0], and return it.
1137 * Right now, the only accepted syntax is :
1138 * <subject> [<value>...]
1139 */
1140struct acl_expr *parse_acl_expr(const char **args)
1141{
1142 __label__ out_return, out_free_expr, out_free_pattern;
1143 struct acl_expr *expr;
1144 struct acl_keyword *aclkw;
1145 struct acl_pattern *pattern;
Willy Tarreauc8d7c962007-06-17 08:20:33 +02001146 int opaque, patflags;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001147 const char *arg;
1148
1149 aclkw = find_acl_kw(args[0]);
1150 if (!aclkw || !aclkw->parse)
1151 goto out_return;
1152
1153 expr = (struct acl_expr *)calloc(1, sizeof(*expr));
1154 if (!expr)
1155 goto out_return;
1156
1157 expr->kw = aclkw;
1158 aclkw->use_cnt++;
1159 LIST_INIT(&expr->patterns);
Willy Tarreaue56cda92010-05-11 23:25:05 +02001160 expr->pattern_tree = EB_ROOT_UNIQUE;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001161 expr->arg.str = NULL;
Willy Tarreaubb768912007-06-10 11:17:01 +02001162 expr->arg_len = 0;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001163
1164 arg = strchr(args[0], '(');
1165 if (arg != NULL) {
1166 char *end, *arg2;
1167 /* there is an argument in the form "subject(arg)" */
1168 arg++;
1169 end = strchr(arg, ')');
1170 if (!end)
1171 goto out_free_expr;
Willy Tarreauac778f52010-01-26 19:02:46 +01001172 arg2 = my_strndup(arg, end - arg);
Willy Tarreau1edb1442010-01-27 20:13:38 +01001173 if (!arg2)
Willy Tarreaua84d3742007-05-07 00:36:48 +02001174 goto out_free_expr;
Willy Tarreaubb768912007-06-10 11:17:01 +02001175 expr->arg_len = end - arg;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001176 expr->arg.str = arg2;
1177 }
1178
Willy Tarreaua84d3742007-05-07 00:36:48 +02001179 args++;
Willy Tarreauc8d7c962007-06-17 08:20:33 +02001180
1181 /* check for options before patterns. Supported options are :
1182 * -i : ignore case for all patterns by default
1183 * -f : read patterns from those files
1184 * -- : everything after this is not an option
1185 */
1186 patflags = 0;
1187 while (**args == '-') {
1188 if ((*args)[1] == 'i')
1189 patflags |= ACL_PAT_F_IGNORE_CASE;
Willy Tarreau2b5285d2010-05-09 23:45:24 +02001190 else if ((*args)[1] == 'f') {
1191 if (!acl_read_patterns_from_file(aclkw, expr, args[1], patflags | ACL_PAT_F_FROM_FILE))
1192 goto out_free_expr;
1193 args++;
1194 }
Willy Tarreauc8d7c962007-06-17 08:20:33 +02001195 else if ((*args)[1] == '-') {
1196 args++;
1197 break;
1198 }
1199 else
1200 break;
1201 args++;
1202 }
1203
1204 /* now parse all patterns */
Willy Tarreauae8b7962007-06-09 23:10:04 +02001205 opaque = 0;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001206 while (**args) {
Willy Tarreauae8b7962007-06-09 23:10:04 +02001207 int ret;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001208 pattern = (struct acl_pattern *)calloc(1, sizeof(*pattern));
1209 if (!pattern)
1210 goto out_free_expr;
Willy Tarreauc8d7c962007-06-17 08:20:33 +02001211 pattern->flags = patflags;
1212
Willy Tarreauae8b7962007-06-09 23:10:04 +02001213 ret = aclkw->parse(args, pattern, &opaque);
1214 if (!ret)
Willy Tarreaua84d3742007-05-07 00:36:48 +02001215 goto out_free_pattern;
1216 LIST_ADDQ(&expr->patterns, &pattern->list);
Willy Tarreauae8b7962007-06-09 23:10:04 +02001217 args += ret;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001218 }
1219
1220 return expr;
1221
1222 out_free_pattern:
1223 free_pattern(pattern);
1224 out_free_expr:
1225 prune_acl_expr(expr);
1226 free(expr);
1227 out_return:
1228 return NULL;
1229}
1230
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +02001231/* Purge everything in the acl <acl>, then return <acl>. */
1232struct acl *prune_acl(struct acl *acl) {
1233
1234 struct acl_expr *expr, *exprb;
1235
1236 free(acl->name);
1237
1238 list_for_each_entry_safe(expr, exprb, &acl->expr, list) {
1239 LIST_DEL(&expr->list);
1240 prune_acl_expr(expr);
1241 free(expr);
1242 }
1243
1244 return acl;
1245}
1246
Willy Tarreaua84d3742007-05-07 00:36:48 +02001247/* Parse an ACL with the name starting at <args>[0], and with a list of already
1248 * known ACLs in <acl>. If the ACL was not in the list, it will be added.
Willy Tarreau2a56c5e2010-03-15 16:13:29 +01001249 * A pointer to that ACL is returned. If the ACL has an empty name, then it's
1250 * an anonymous one and it won't be merged with any other one.
Willy Tarreaua84d3742007-05-07 00:36:48 +02001251 *
1252 * args syntax: <aclname> <acl_expr>
1253 */
1254struct acl *parse_acl(const char **args, struct list *known_acl)
1255{
1256 __label__ out_return, out_free_acl_expr, out_free_name;
1257 struct acl *cur_acl;
1258 struct acl_expr *acl_expr;
1259 char *name;
1260
Willy Tarreau2a56c5e2010-03-15 16:13:29 +01001261 if (**args && invalid_char(*args))
Willy Tarreau2e74c3f2007-12-02 18:45:09 +01001262 goto out_return;
1263
Willy Tarreaua84d3742007-05-07 00:36:48 +02001264 acl_expr = parse_acl_expr(args + 1);
1265 if (!acl_expr)
1266 goto out_return;
1267
Willy Tarreau404e8ab2009-07-26 19:40:40 +02001268 /* Check for args beginning with an opening parenthesis just after the
1269 * subject, as this is almost certainly a typo. Right now we can only
1270 * emit a warning, so let's do so.
1271 */
Krzysztof Piotr Oledzki4cdd8312009-10-05 00:23:35 +02001272 if (!strchr(args[1], '(') && *args[2] == '(')
Willy Tarreau404e8ab2009-07-26 19:40:40 +02001273 Warning("parsing acl '%s' :\n"
1274 " matching '%s' for pattern '%s' is likely a mistake and probably\n"
1275 " not what you want. Maybe you need to remove the extraneous space before '('.\n"
1276 " If you are really sure this is not an error, please insert '--' between the\n"
1277 " match and the pattern to make this warning message disappear.\n",
1278 args[0], args[1], args[2]);
1279
Willy Tarreau2a56c5e2010-03-15 16:13:29 +01001280 if (*args[0])
1281 cur_acl = find_acl_by_name(args[0], known_acl);
1282 else
1283 cur_acl = NULL;
1284
Willy Tarreaua84d3742007-05-07 00:36:48 +02001285 if (!cur_acl) {
1286 name = strdup(args[0]);
1287 if (!name)
1288 goto out_free_acl_expr;
1289 cur_acl = (struct acl *)calloc(1, sizeof(*cur_acl));
1290 if (cur_acl == NULL)
1291 goto out_free_name;
1292
1293 LIST_INIT(&cur_acl->expr);
1294 LIST_ADDQ(known_acl, &cur_acl->list);
1295 cur_acl->name = name;
1296 }
1297
Willy Tarreaua9802632008-07-25 19:13:19 +02001298 cur_acl->requires |= acl_expr->kw->requires;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001299 LIST_ADDQ(&cur_acl->expr, &acl_expr->list);
1300 return cur_acl;
1301
1302 out_free_name:
1303 free(name);
1304 out_free_acl_expr:
1305 prune_acl_expr(acl_expr);
1306 free(acl_expr);
1307 out_return:
1308 return NULL;
1309}
1310
Willy Tarreau16fbe822007-06-17 11:54:31 +02001311/* Some useful ACLs provided by default. Only those used are allocated. */
1312
1313const struct {
1314 const char *name;
1315 const char *expr[4]; /* put enough for longest expression */
1316} default_acl_list[] = {
Willy Tarreau58393e12008-07-20 10:39:22 +02001317 { .name = "TRUE", .expr = {"always_true",""}},
1318 { .name = "FALSE", .expr = {"always_false",""}},
Willy Tarreau16fbe822007-06-17 11:54:31 +02001319 { .name = "LOCALHOST", .expr = {"src","127.0.0.1/8",""}},
Willy Tarreau2492d5b2009-07-11 00:06:00 +02001320 { .name = "HTTP", .expr = {"req_proto_http",""}},
Willy Tarreau16fbe822007-06-17 11:54:31 +02001321 { .name = "HTTP_1.0", .expr = {"req_ver","1.0",""}},
1322 { .name = "HTTP_1.1", .expr = {"req_ver","1.1",""}},
1323 { .name = "METH_CONNECT", .expr = {"method","CONNECT",""}},
1324 { .name = "METH_GET", .expr = {"method","GET","HEAD",""}},
1325 { .name = "METH_HEAD", .expr = {"method","HEAD",""}},
1326 { .name = "METH_OPTIONS", .expr = {"method","OPTIONS",""}},
1327 { .name = "METH_POST", .expr = {"method","POST",""}},
1328 { .name = "METH_TRACE", .expr = {"method","TRACE",""}},
1329 { .name = "HTTP_URL_ABS", .expr = {"url_reg","^[^/:]*://",""}},
1330 { .name = "HTTP_URL_SLASH", .expr = {"url_beg","/",""}},
1331 { .name = "HTTP_URL_STAR", .expr = {"url","*",""}},
1332 { .name = "HTTP_CONTENT", .expr = {"hdr_val(content-length)","gt","0",""}},
Emeric Brunbede3d02009-06-30 17:54:00 +02001333 { .name = "RDP_COOKIE", .expr = {"req_rdp_cookie_cnt","gt","0",""}},
Willy Tarreauc6317702008-07-20 09:29:50 +02001334 { .name = "REQ_CONTENT", .expr = {"req_len","gt","0",""}},
Willy Tarreaub6fb4202008-07-20 11:18:28 +02001335 { .name = "WAIT_END", .expr = {"wait_end",""}},
Willy Tarreau16fbe822007-06-17 11:54:31 +02001336 { .name = NULL, .expr = {""}}
1337};
1338
1339/* Find a default ACL from the default_acl list, compile it and return it.
1340 * If the ACL is not found, NULL is returned. In theory, it cannot fail,
1341 * except when default ACLs are broken, in which case it will return NULL.
1342 * If <known_acl> is not NULL, the ACL will be queued at its tail.
1343 */
1344struct acl *find_acl_default(const char *acl_name, struct list *known_acl)
1345{
1346 __label__ out_return, out_free_acl_expr, out_free_name;
1347 struct acl *cur_acl;
1348 struct acl_expr *acl_expr;
1349 char *name;
1350 int index;
1351
1352 for (index = 0; default_acl_list[index].name != NULL; index++) {
1353 if (strcmp(acl_name, default_acl_list[index].name) == 0)
1354 break;
1355 }
1356
1357 if (default_acl_list[index].name == NULL)
1358 return NULL;
1359
1360 acl_expr = parse_acl_expr((const char **)default_acl_list[index].expr);
1361 if (!acl_expr)
1362 goto out_return;
1363
1364 name = strdup(acl_name);
1365 if (!name)
1366 goto out_free_acl_expr;
1367 cur_acl = (struct acl *)calloc(1, sizeof(*cur_acl));
1368 if (cur_acl == NULL)
1369 goto out_free_name;
1370
1371 cur_acl->name = name;
Willy Tarreaua55b7dc2009-07-12 09:21:30 +02001372 cur_acl->requires |= acl_expr->kw->requires;
Willy Tarreau16fbe822007-06-17 11:54:31 +02001373 LIST_INIT(&cur_acl->expr);
1374 LIST_ADDQ(&cur_acl->expr, &acl_expr->list);
1375 if (known_acl)
1376 LIST_ADDQ(known_acl, &cur_acl->list);
1377
1378 return cur_acl;
1379
1380 out_free_name:
1381 free(name);
1382 out_free_acl_expr:
1383 prune_acl_expr(acl_expr);
1384 free(acl_expr);
1385 out_return:
1386 return NULL;
1387}
Willy Tarreaua84d3742007-05-07 00:36:48 +02001388
1389/* Purge everything in the acl_cond <cond>, then return <cond>. */
1390struct acl_cond *prune_acl_cond(struct acl_cond *cond)
1391{
1392 struct acl_term_suite *suite, *tmp_suite;
1393 struct acl_term *term, *tmp_term;
1394
1395 /* iterate through all term suites and free all terms and all suites */
1396 list_for_each_entry_safe(suite, tmp_suite, &cond->suites, list) {
1397 list_for_each_entry_safe(term, tmp_term, &suite->terms, list)
1398 free(term);
1399 free(suite);
1400 }
1401 return cond;
1402}
1403
1404/* Parse an ACL condition starting at <args>[0], relying on a list of already
1405 * known ACLs passed in <known_acl>. The new condition is returned (or NULL in
1406 * case of low memory). Supports multiple conditions separated by "or".
1407 */
1408struct acl_cond *parse_acl_cond(const char **args, struct list *known_acl, int pol)
1409{
1410 __label__ out_return, out_free_suite, out_free_term;
Willy Tarreau74b98a82007-06-16 19:35:18 +02001411 int arg, neg;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001412 const char *word;
1413 struct acl *cur_acl;
1414 struct acl_term *cur_term;
1415 struct acl_term_suite *cur_suite;
1416 struct acl_cond *cond;
1417
1418 cond = (struct acl_cond *)calloc(1, sizeof(*cond));
1419 if (cond == NULL)
1420 goto out_return;
1421
1422 LIST_INIT(&cond->list);
1423 LIST_INIT(&cond->suites);
1424 cond->pol = pol;
1425
1426 cur_suite = NULL;
Willy Tarreau74b98a82007-06-16 19:35:18 +02001427 neg = 0;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001428 for (arg = 0; *args[arg]; arg++) {
1429 word = args[arg];
1430
1431 /* remove as many exclamation marks as we can */
1432 while (*word == '!') {
1433 neg = !neg;
1434 word++;
1435 }
1436
1437 /* an empty word is allowed because we cannot force the user to
1438 * always think about not leaving exclamation marks alone.
1439 */
1440 if (!*word)
1441 continue;
1442
Willy Tarreau16fbe822007-06-17 11:54:31 +02001443 if (strcasecmp(word, "or") == 0 || strcmp(word, "||") == 0) {
Willy Tarreaua84d3742007-05-07 00:36:48 +02001444 /* new term suite */
1445 cur_suite = NULL;
1446 neg = 0;
1447 continue;
1448 }
1449
Willy Tarreau95fa4692010-02-01 13:05:50 +01001450 if (strcmp(word, "{") == 0) {
1451 /* we may have a complete ACL expression between two braces,
1452 * find the last one.
1453 */
1454 int arg_end = arg + 1;
1455 const char **args_new;
1456
1457 while (*args[arg_end] && strcmp(args[arg_end], "}") != 0)
1458 arg_end++;
1459
1460 if (!*args[arg_end])
1461 goto out_free_suite;
1462
1463 args_new = calloc(1, (arg_end - arg + 1) * sizeof(*args_new));
1464 if (!args_new)
1465 goto out_free_suite;
1466
Willy Tarreau2a56c5e2010-03-15 16:13:29 +01001467 args_new[0] = "";
Willy Tarreau95fa4692010-02-01 13:05:50 +01001468 memcpy(args_new + 1, args + arg + 1, (arg_end - arg) * sizeof(*args_new));
1469 args_new[arg_end - arg] = "";
1470 cur_acl = parse_acl(args_new, known_acl);
1471 free(args_new);
1472
1473 if (!cur_acl)
Willy Tarreau16fbe822007-06-17 11:54:31 +02001474 goto out_free_suite;
Willy Tarreau95fa4692010-02-01 13:05:50 +01001475 arg = arg_end;
1476 }
1477 else {
1478 /* search for <word> in the known ACL names. If we do not find
1479 * it, let's look for it in the default ACLs, and if found, add
1480 * it to the list of ACLs of this proxy. This makes it possible
1481 * to override them.
1482 */
1483 cur_acl = find_acl_by_name(word, known_acl);
1484 if (cur_acl == NULL) {
1485 cur_acl = find_acl_default(word, known_acl);
1486 if (cur_acl == NULL)
1487 goto out_free_suite;
1488 }
Willy Tarreau16fbe822007-06-17 11:54:31 +02001489 }
Willy Tarreaua84d3742007-05-07 00:36:48 +02001490
1491 cur_term = (struct acl_term *)calloc(1, sizeof(*cur_term));
1492 if (cur_term == NULL)
1493 goto out_free_suite;
1494
1495 cur_term->acl = cur_acl;
1496 cur_term->neg = neg;
Willy Tarreaua9802632008-07-25 19:13:19 +02001497 cond->requires |= cur_acl->requires;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001498
1499 if (!cur_suite) {
1500 cur_suite = (struct acl_term_suite *)calloc(1, sizeof(*cur_suite));
1501 if (cur_term == NULL)
1502 goto out_free_term;
1503 LIST_INIT(&cur_suite->terms);
1504 LIST_ADDQ(&cond->suites, &cur_suite->list);
1505 }
1506 LIST_ADDQ(&cur_suite->terms, &cur_term->list);
Willy Tarreau74b98a82007-06-16 19:35:18 +02001507 neg = 0;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001508 }
1509
1510 return cond;
1511
1512 out_free_term:
1513 free(cur_term);
1514 out_free_suite:
1515 prune_acl_cond(cond);
1516 free(cond);
1517 out_return:
1518 return NULL;
1519}
1520
Willy Tarreau2bbba412010-01-28 16:48:33 +01001521/* Builds an ACL condition starting at the if/unless keyword. The complete
1522 * condition is returned. NULL is returned in case of error or if the first
1523 * word is neither "if" nor "unless". It automatically sets the file name and
1524 * the line number in the condition for better error reporting, and adds the
1525 * ACL requirements to the proxy's acl_requires.
1526 */
1527struct acl_cond *build_acl_cond(const char *file, int line, struct proxy *px, const char **args)
1528{
1529 int pol = ACL_COND_NONE;
1530 struct acl_cond *cond = NULL;
1531
1532 if (!strcmp(*args, "if")) {
1533 pol = ACL_COND_IF;
1534 args++;
1535 }
1536 else if (!strcmp(*args, "unless")) {
1537 pol = ACL_COND_UNLESS;
1538 args++;
1539 }
1540 else
1541 return NULL;
1542
1543 cond = parse_acl_cond(args, &px->acl, pol);
1544 if (!cond)
1545 return NULL;
1546
1547 cond->file = file;
1548 cond->line = line;
1549 px->acl_requires |= cond->requires;
1550
1551 return cond;
1552}
1553
Willy Tarreau11382812008-07-09 16:18:21 +02001554/* Execute condition <cond> and return either ACL_PAT_FAIL, ACL_PAT_MISS or
Willy Tarreaub6866442008-07-14 23:54:42 +02001555 * ACL_PAT_PASS depending on the test results. ACL_PAT_MISS may only be
1556 * returned if <dir> contains ACL_PARTIAL, indicating that incomplete data
1557 * is being examined.
1558 * This function only computes the condition, it does not apply the polarity
1559 * required by IF/UNLESS, it's up to the caller to do this using something like
1560 * this :
Willy Tarreau11382812008-07-09 16:18:21 +02001561 *
1562 * res = acl_pass(res);
Willy Tarreaub6866442008-07-14 23:54:42 +02001563 * if (res == ACL_PAT_MISS)
1564 * return 0;
Willy Tarreau11382812008-07-09 16:18:21 +02001565 * if (cond->pol == ACL_COND_UNLESS)
1566 * res = !res;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001567 */
Willy Tarreaud41f8d82007-06-10 10:06:18 +02001568int acl_exec_cond(struct acl_cond *cond, struct proxy *px, struct session *l4, void *l7, int dir)
Willy Tarreaua84d3742007-05-07 00:36:48 +02001569{
1570 __label__ fetch_next;
1571 struct acl_term_suite *suite;
1572 struct acl_term *term;
1573 struct acl_expr *expr;
1574 struct acl *acl;
1575 struct acl_pattern *pattern;
1576 struct acl_test test;
Willy Tarreau11382812008-07-09 16:18:21 +02001577 int acl_res, suite_res, cond_res;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001578
Willy Tarreau11382812008-07-09 16:18:21 +02001579 /* We're doing a logical OR between conditions so we initialize to FAIL.
1580 * The MISS status is propagated down from the suites.
1581 */
Willy Tarreaua84d3742007-05-07 00:36:48 +02001582 cond_res = ACL_PAT_FAIL;
1583 list_for_each_entry(suite, &cond->suites, list) {
Willy Tarreau11382812008-07-09 16:18:21 +02001584 /* Evaluate condition suite <suite>. We stop at the first term
1585 * which returns ACL_PAT_FAIL. The MISS status is still propagated
1586 * in case of uncertainty in the result.
Willy Tarreaua84d3742007-05-07 00:36:48 +02001587 */
1588
1589 /* we're doing a logical AND between terms, so we must set the
1590 * initial value to PASS.
1591 */
1592 suite_res = ACL_PAT_PASS;
1593 list_for_each_entry(term, &suite->terms, list) {
1594 acl = term->acl;
1595
1596 /* FIXME: use cache !
1597 * check acl->cache_idx for this.
1598 */
1599
1600 /* ACL result not cached. Let's scan all the expressions
1601 * and use the first one to match.
1602 */
1603 acl_res = ACL_PAT_FAIL;
1604 list_for_each_entry(expr, &acl->expr, list) {
Willy Tarreaud41f8d82007-06-10 10:06:18 +02001605 /* we need to reset context and flags */
1606 memset(&test, 0, sizeof(test));
Willy Tarreaua84d3742007-05-07 00:36:48 +02001607 fetch_next:
Willy Tarreaub6866442008-07-14 23:54:42 +02001608 if (!expr->kw->fetch(px, l4, l7, dir, expr, &test)) {
1609 /* maybe we could not fetch because of missing data */
1610 if (test.flags & ACL_TEST_F_MAY_CHANGE && dir & ACL_PARTIAL)
1611 acl_res |= ACL_PAT_MISS;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001612 continue;
Willy Tarreaub6866442008-07-14 23:54:42 +02001613 }
Willy Tarreaua84d3742007-05-07 00:36:48 +02001614
Willy Tarreaua79534f2008-07-20 10:13:37 +02001615 if (test.flags & ACL_TEST_F_RES_SET) {
1616 if (test.flags & ACL_TEST_F_RES_PASS)
1617 acl_res |= ACL_PAT_PASS;
1618 else
1619 acl_res |= ACL_PAT_FAIL;
1620 }
1621 else {
Willy Tarreau020534d2010-05-16 21:45:45 +02001622 if (!eb_is_empty(&expr->pattern_tree)) {
Willy Tarreauc4262962010-05-10 23:42:40 +02001623 /* a tree is present, let's check what type it is */
1624 if (expr->kw->match == acl_match_str)
1625 acl_res |= acl_lookup_str(&test, expr) ? ACL_PAT_PASS : ACL_PAT_FAIL;
Willy Tarreaub337b532010-05-13 20:03:41 +02001626 else if (expr->kw->match == acl_match_ip)
1627 acl_res |= acl_lookup_ip(&test, expr) ? ACL_PAT_PASS : ACL_PAT_FAIL;
Willy Tarreauc4262962010-05-10 23:42:40 +02001628 }
1629
Willy Tarreaua79534f2008-07-20 10:13:37 +02001630 /* call the match() function for all tests on this value */
1631 list_for_each_entry(pattern, &expr->patterns, list) {
Willy Tarreaua79534f2008-07-20 10:13:37 +02001632 if (acl_res == ACL_PAT_PASS)
1633 break;
Willy Tarreaue56cda92010-05-11 23:25:05 +02001634 acl_res |= expr->kw->match(&test, pattern);
Willy Tarreaua79534f2008-07-20 10:13:37 +02001635 }
Krzysztof Piotr Oledzkid7528e52010-01-29 17:55:53 +01001636
Willy Tarreaue56cda92010-05-11 23:25:05 +02001637 if ((test.flags & ACL_TEST_F_NULL_MATCH) &&
Willy Tarreau020534d2010-05-16 21:45:45 +02001638 LIST_ISEMPTY(&expr->patterns) && eb_is_empty(&expr->pattern_tree))
Krzysztof Piotr Oledzkid7528e52010-01-29 17:55:53 +01001639 acl_res |= expr->kw->match(&test, NULL);
Willy Tarreaua84d3742007-05-07 00:36:48 +02001640 }
1641 /*
Willy Tarreau11382812008-07-09 16:18:21 +02001642 * OK now acl_res holds the result of this expression
1643 * as one of ACL_PAT_FAIL, ACL_PAT_MISS or ACL_PAT_PASS.
Willy Tarreaua84d3742007-05-07 00:36:48 +02001644 *
Willy Tarreau11382812008-07-09 16:18:21 +02001645 * Then if (!MISS) we can cache the result, and put
Willy Tarreaua84d3742007-05-07 00:36:48 +02001646 * (test.flags & ACL_TEST_F_VOLATILE) in the cache flags.
1647 *
1648 * FIXME: implement cache.
1649 *
1650 */
1651
1652 /* now we may have some cleanup to do */
1653 if (test.flags & ACL_TEST_F_MUST_FREE) {
1654 free(test.ptr);
1655 test.len = 0;
1656 }
1657
Willy Tarreau11382812008-07-09 16:18:21 +02001658 /* we're ORing these terms, so a single PASS is enough */
1659 if (acl_res == ACL_PAT_PASS)
Willy Tarreaua84d3742007-05-07 00:36:48 +02001660 break;
1661
Willy Tarreaua84d3742007-05-07 00:36:48 +02001662 if (test.flags & ACL_TEST_F_FETCH_MORE)
1663 goto fetch_next;
Willy Tarreaub6866442008-07-14 23:54:42 +02001664
1665 /* sometimes we know the fetched data is subject to change
1666 * later and give another chance for a new match (eg: request
1667 * size, time, ...)
1668 */
1669 if (test.flags & ACL_TEST_F_MAY_CHANGE && dir & ACL_PARTIAL)
1670 acl_res |= ACL_PAT_MISS;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001671 }
1672 /*
1673 * Here we have the result of an ACL (cached or not).
1674 * ACLs are combined, negated or not, to form conditions.
1675 */
1676
Willy Tarreaua84d3742007-05-07 00:36:48 +02001677 if (term->neg)
Willy Tarreau11382812008-07-09 16:18:21 +02001678 acl_res = acl_neg(acl_res);
Willy Tarreaua84d3742007-05-07 00:36:48 +02001679
1680 suite_res &= acl_res;
Willy Tarreau11382812008-07-09 16:18:21 +02001681
1682 /* we're ANDing these terms, so a single FAIL is enough */
1683 if (suite_res == ACL_PAT_FAIL)
Willy Tarreaua84d3742007-05-07 00:36:48 +02001684 break;
1685 }
1686 cond_res |= suite_res;
Willy Tarreau11382812008-07-09 16:18:21 +02001687
1688 /* we're ORing these terms, so a single PASS is enough */
1689 if (cond_res == ACL_PAT_PASS)
Willy Tarreaua84d3742007-05-07 00:36:48 +02001690 break;
1691 }
Willy Tarreau11382812008-07-09 16:18:21 +02001692 return cond_res;
Willy Tarreaua84d3742007-05-07 00:36:48 +02001693}
1694
1695
Willy Tarreaudd64f8d2008-07-27 22:02:32 +02001696/* Reports a pointer to the first ACL used in condition <cond> which requires
1697 * at least one of the USE_FLAGS in <require>. Returns NULL if none matches.
1698 * The construct is almost the same as for acl_exec_cond() since we're walking
1699 * down the ACL tree as well. It is important that the tree is really walked
1700 * through and never cached, because that way, this function can be used as a
1701 * late check.
1702 */
Willy Tarreauf1e98b82010-01-28 17:59:39 +01001703struct acl *cond_find_require(const struct acl_cond *cond, unsigned int require)
Willy Tarreaudd64f8d2008-07-27 22:02:32 +02001704{
1705 struct acl_term_suite *suite;
1706 struct acl_term *term;
1707 struct acl *acl;
1708
1709 list_for_each_entry(suite, &cond->suites, list) {
1710 list_for_each_entry(term, &suite->terms, list) {
1711 acl = term->acl;
1712 if (acl->requires & require)
1713 return acl;
1714 }
1715 }
1716 return NULL;
1717}
1718
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01001719/*
1720 * Find targets for userlist and groups in acl. Function returns the number
1721 * of errors or OK if everything is fine.
1722 */
1723int
1724acl_find_targets(struct proxy *p)
1725{
1726
1727 struct acl *acl;
1728 struct acl_expr *expr;
1729 struct acl_pattern *pattern;
1730 struct userlist *ul;
1731 int cfgerr = 0;
1732
1733 list_for_each_entry(acl, &p->acl, list) {
1734 list_for_each_entry(expr, &acl->expr, list) {
Hervé COMMOWICKdaa824e2011-08-05 12:09:44 +02001735 if (strcmp(expr->kw->kw, "srv_is_up") == 0 ||
1736 strcmp(expr->kw->kw, "srv_conn") == 0) {
Willy Tarreau0b1cd942010-05-16 22:18:27 +02001737 struct proxy *px;
1738 struct server *srv;
1739 char *pname, *sname;
1740
1741 if (!expr->arg.str || !*expr->arg.str) {
1742 Alert("proxy %s: acl %s %s(): missing server name.\n",
1743 p->id, acl->name, expr->kw->kw);
1744 cfgerr++;
1745 continue;
1746 }
1747
1748 pname = expr->arg.str;
1749 sname = strrchr(pname, '/');
1750
1751 if (sname)
1752 *sname++ = '\0';
1753 else {
1754 sname = pname;
1755 pname = NULL;
1756 }
1757
1758 px = p;
1759 if (pname) {
1760 px = findproxy(pname, PR_CAP_BE);
1761 if (!px) {
1762 Alert("proxy %s: acl %s %s(): unable to find proxy '%s'.\n",
1763 p->id, acl->name, expr->kw->kw, pname);
1764 cfgerr++;
1765 continue;
1766 }
1767 }
1768
1769 srv = findserver(px, sname);
1770 if (!srv) {
1771 Alert("proxy %s: acl %s %s(): unable to find server '%s'.\n",
1772 p->id, acl->name, expr->kw->kw, sname);
1773 cfgerr++;
1774 continue;
1775 }
1776
1777 free(expr->arg.str);
1778 expr->arg_len = 0;
1779 expr->arg.srv = srv;
1780 continue;
1781 }
1782
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01001783 if (strstr(expr->kw->kw, "http_auth") == expr->kw->kw) {
1784
1785 if (!expr->arg.str || !*expr->arg.str) {
1786 Alert("proxy %s: acl %s %s(): missing userlist name.\n",
1787 p->id, acl->name, expr->kw->kw);
1788 cfgerr++;
1789 continue;
1790 }
1791
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01001792 if (p->uri_auth && p->uri_auth->userlist &&
1793 !strcmp(p->uri_auth->userlist->name, expr->arg.str))
1794 ul = p->uri_auth->userlist;
1795 else
1796 ul = auth_find_userlist(expr->arg.str);
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01001797
1798 if (!ul) {
1799 Alert("proxy %s: acl %s %s(%s): unable to find userlist.\n",
1800 p->id, acl->name, expr->kw->kw, expr->arg.str);
1801 cfgerr++;
1802 continue;
1803 }
1804
1805 expr->arg_len = 0;
1806 expr->arg.ul = ul;
1807 }
1808
1809
1810 if (!strcmp(expr->kw->kw, "http_auth_group")) {
1811
1812 if (LIST_ISEMPTY(&expr->patterns)) {
1813 Alert("proxy %s: acl %s %s(): no groups specified.\n",
1814 p->id, acl->name, expr->kw->kw);
1815 cfgerr++;
1816 continue;
1817 }
1818
1819 list_for_each_entry(pattern, &expr->patterns, list) {
1820 pattern->val.group_mask = auth_resolve_groups(expr->arg.ul, pattern->ptr.str);
1821
1822 free(pattern->ptr.str);
1823 pattern->ptr.str = NULL;
1824 pattern->len = 0;
1825
1826 if (!pattern->val.group_mask) {
1827 Alert("proxy %s: acl %s %s(): invalid group(s).\n",
1828 p->id, acl->name, expr->kw->kw);
1829 cfgerr++;
1830 continue;
1831 }
1832 }
1833 }
1834 }
1835 }
1836
1837 return cfgerr;
1838}
Willy Tarreaudd64f8d2008-07-27 22:02:32 +02001839
Willy Tarreaua84d3742007-05-07 00:36:48 +02001840/************************************************************************/
1841/* All supported keywords must be declared here. */
1842/************************************************************************/
1843
1844/* Note: must not be declared <const> as its list will be overwritten */
1845static struct acl_kw_list acl_kws = {{ },{
Emeric Brun38e71762010-09-23 17:59:18 +02001846 { "always_true", acl_parse_nothing, acl_fetch_true, acl_match_nothing, ACL_USE_NOTHING },
1847 { "always_false", acl_parse_nothing, acl_fetch_false, acl_match_nothing, ACL_USE_NOTHING },
1848 { "wait_end", acl_parse_nothing, acl_fetch_wait_end, acl_match_nothing, ACL_USE_NOTHING },
1849 { "req_len", acl_parse_int, acl_fetch_req_len, acl_match_int, ACL_USE_L6REQ_VOLATILE },
1850 { "req_ssl_hello_type", acl_parse_int, acl_fetch_ssl_hello_type, acl_match_int, ACL_USE_L6REQ_VOLATILE },
1851 { "rep_ssl_hello_type", acl_parse_int, acl_fetch_ssl_hello_type, acl_match_int, ACL_USE_L6RTR_VOLATILE },
1852 { "req_ssl_ver", acl_parse_dotted_ver, acl_fetch_req_ssl_ver, acl_match_int, ACL_USE_L6REQ_VOLATILE },
1853 { "req_rdp_cookie", acl_parse_str, acl_fetch_rdp_cookie, acl_match_str, ACL_USE_L6REQ_VOLATILE|ACL_MAY_LOOKUP },
1854 { "req_rdp_cookie_cnt", acl_parse_int, acl_fetch_rdp_cookie_cnt, acl_match_int, ACL_USE_L6REQ_VOLATILE },
Willy Tarreaua84d3742007-05-07 00:36:48 +02001855#if 0
1856 { "time", acl_parse_time, acl_fetch_time, acl_match_time },
1857#endif
1858 { NULL, NULL, NULL, NULL }
1859}};
1860
1861
1862__attribute__((constructor))
1863static void __acl_init(void)
1864{
1865 acl_register_keywords(&acl_kws);
1866}
1867
1868
1869/*
1870 * Local variables:
1871 * c-indent-level: 8
1872 * c-basic-offset: 8
1873 * End:
1874 */