blob: c93be9b59947865856fb755ee98077b9b775aa03 [file] [log] [blame]
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001/*
2 * Pattern management functions.
3 *
4 * Copyright 2000-2013 Willy Tarreau <w@1wt.eu>
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 <stdio.h>
15
16#include <common/config.h>
17#include <common/standard.h>
18
19#include <types/global.h>
20#include <types/pattern.h>
21
Thierry FOURNIER46006bd2014-03-21 21:45:15 +010022#include <proto/log.h>
Thierry FOURNIERed66c292013-11-28 11:05:19 +010023#include <proto/pattern.h>
Thierry FOURNIERe3ded592013-12-06 15:36:54 +010024#include <proto/sample.h>
Thierry FOURNIERed66c292013-11-28 11:05:19 +010025
26#include <ebsttree.h>
Willy Tarreauf3045d22015-04-29 16:24:50 +020027#include <import/lru.h>
28#include <import/xxhash.h>
Thierry FOURNIERed66c292013-11-28 11:05:19 +010029
Thierry FOURNIERa65b3432013-11-28 18:22:00 +010030char *pat_match_names[PAT_MATCH_NUM] = {
31 [PAT_MATCH_FOUND] = "found",
32 [PAT_MATCH_BOOL] = "bool",
33 [PAT_MATCH_INT] = "int",
34 [PAT_MATCH_IP] = "ip",
35 [PAT_MATCH_BIN] = "bin",
36 [PAT_MATCH_LEN] = "len",
37 [PAT_MATCH_STR] = "str",
38 [PAT_MATCH_BEG] = "beg",
39 [PAT_MATCH_SUB] = "sub",
40 [PAT_MATCH_DIR] = "dir",
41 [PAT_MATCH_DOM] = "dom",
42 [PAT_MATCH_END] = "end",
43 [PAT_MATCH_REG] = "reg",
Thierry Fournier8feaa662016-02-10 22:55:20 +010044 [PAT_MATCH_REGM] = "regm",
Thierry FOURNIERed66c292013-11-28 11:05:19 +010045};
46
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +020047int (*pat_parse_fcts[PAT_MATCH_NUM])(const char *, struct pattern *, int, char **) = {
Thierry FOURNIERa65b3432013-11-28 18:22:00 +010048 [PAT_MATCH_FOUND] = pat_parse_nothing,
49 [PAT_MATCH_BOOL] = pat_parse_nothing,
50 [PAT_MATCH_INT] = pat_parse_int,
51 [PAT_MATCH_IP] = pat_parse_ip,
52 [PAT_MATCH_BIN] = pat_parse_bin,
Thierry FOURNIER5d344082014-01-27 14:19:53 +010053 [PAT_MATCH_LEN] = pat_parse_int,
Thierry FOURNIERa65b3432013-11-28 18:22:00 +010054 [PAT_MATCH_STR] = pat_parse_str,
55 [PAT_MATCH_BEG] = pat_parse_str,
56 [PAT_MATCH_SUB] = pat_parse_str,
57 [PAT_MATCH_DIR] = pat_parse_str,
58 [PAT_MATCH_DOM] = pat_parse_str,
59 [PAT_MATCH_END] = pat_parse_str,
60 [PAT_MATCH_REG] = pat_parse_reg,
Thierry Fournier8feaa662016-02-10 22:55:20 +010061 [PAT_MATCH_REGM] = pat_parse_reg,
Thierry FOURNIERed66c292013-11-28 11:05:19 +010062};
63
Thierry FOURNIERb9b08462013-12-13 15:12:32 +010064int (*pat_index_fcts[PAT_MATCH_NUM])(struct pattern_expr *, struct pattern *, char **) = {
65 [PAT_MATCH_FOUND] = pat_idx_list_val,
66 [PAT_MATCH_BOOL] = pat_idx_list_val,
67 [PAT_MATCH_INT] = pat_idx_list_val,
68 [PAT_MATCH_IP] = pat_idx_tree_ip,
69 [PAT_MATCH_BIN] = pat_idx_list_ptr,
70 [PAT_MATCH_LEN] = pat_idx_list_val,
71 [PAT_MATCH_STR] = pat_idx_tree_str,
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +020072 [PAT_MATCH_BEG] = pat_idx_tree_pfx,
Thierry FOURNIERb9b08462013-12-13 15:12:32 +010073 [PAT_MATCH_SUB] = pat_idx_list_str,
74 [PAT_MATCH_DIR] = pat_idx_list_str,
75 [PAT_MATCH_DOM] = pat_idx_list_str,
76 [PAT_MATCH_END] = pat_idx_list_str,
77 [PAT_MATCH_REG] = pat_idx_list_reg,
Thierry Fournier8feaa662016-02-10 22:55:20 +010078 [PAT_MATCH_REGM] = pat_idx_list_regm,
Thierry FOURNIERb9b08462013-12-13 15:12:32 +010079};
80
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +010081void (*pat_delete_fcts[PAT_MATCH_NUM])(struct pattern_expr *, struct pat_ref_elt *) = {
Thierry FOURNIERb1136502014-01-15 11:38:49 +010082 [PAT_MATCH_FOUND] = pat_del_list_val,
83 [PAT_MATCH_BOOL] = pat_del_list_val,
84 [PAT_MATCH_INT] = pat_del_list_val,
85 [PAT_MATCH_IP] = pat_del_tree_ip,
86 [PAT_MATCH_BIN] = pat_del_list_ptr,
87 [PAT_MATCH_LEN] = pat_del_list_val,
88 [PAT_MATCH_STR] = pat_del_tree_str,
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +020089 [PAT_MATCH_BEG] = pat_del_tree_str,
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +010090 [PAT_MATCH_SUB] = pat_del_list_ptr,
91 [PAT_MATCH_DIR] = pat_del_list_ptr,
92 [PAT_MATCH_DOM] = pat_del_list_ptr,
93 [PAT_MATCH_END] = pat_del_list_ptr,
Thierry FOURNIERb1136502014-01-15 11:38:49 +010094 [PAT_MATCH_REG] = pat_del_list_reg,
Thierry Fournier8feaa662016-02-10 22:55:20 +010095 [PAT_MATCH_REGM] = pat_del_list_reg,
Thierry FOURNIERb1136502014-01-15 11:38:49 +010096};
97
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +010098void (*pat_prune_fcts[PAT_MATCH_NUM])(struct pattern_expr *) = {
99 [PAT_MATCH_FOUND] = pat_prune_val,
100 [PAT_MATCH_BOOL] = pat_prune_val,
101 [PAT_MATCH_INT] = pat_prune_val,
102 [PAT_MATCH_IP] = pat_prune_val,
103 [PAT_MATCH_BIN] = pat_prune_ptr,
104 [PAT_MATCH_LEN] = pat_prune_val,
105 [PAT_MATCH_STR] = pat_prune_ptr,
106 [PAT_MATCH_BEG] = pat_prune_ptr,
107 [PAT_MATCH_SUB] = pat_prune_ptr,
108 [PAT_MATCH_DIR] = pat_prune_ptr,
109 [PAT_MATCH_DOM] = pat_prune_ptr,
110 [PAT_MATCH_END] = pat_prune_ptr,
111 [PAT_MATCH_REG] = pat_prune_reg,
Thierry Fournier8feaa662016-02-10 22:55:20 +0100112 [PAT_MATCH_REGM] = pat_prune_reg,
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +0100113};
114
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100115struct pattern *(*pat_match_fcts[PAT_MATCH_NUM])(struct sample *, struct pattern_expr *, int) = {
Thierry FOURNIERa65b3432013-11-28 18:22:00 +0100116 [PAT_MATCH_FOUND] = NULL,
117 [PAT_MATCH_BOOL] = pat_match_nothing,
118 [PAT_MATCH_INT] = pat_match_int,
119 [PAT_MATCH_IP] = pat_match_ip,
120 [PAT_MATCH_BIN] = pat_match_bin,
121 [PAT_MATCH_LEN] = pat_match_len,
122 [PAT_MATCH_STR] = pat_match_str,
123 [PAT_MATCH_BEG] = pat_match_beg,
124 [PAT_MATCH_SUB] = pat_match_sub,
125 [PAT_MATCH_DIR] = pat_match_dir,
126 [PAT_MATCH_DOM] = pat_match_dom,
127 [PAT_MATCH_END] = pat_match_end,
128 [PAT_MATCH_REG] = pat_match_reg,
Thierry Fournier8feaa662016-02-10 22:55:20 +0100129 [PAT_MATCH_REGM] = pat_match_regm,
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100130};
131
Thierry FOURNIERe3ded592013-12-06 15:36:54 +0100132/* Just used for checking configuration compatibility */
133int pat_match_types[PAT_MATCH_NUM] = {
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200134 [PAT_MATCH_FOUND] = SMP_T_SINT,
135 [PAT_MATCH_BOOL] = SMP_T_SINT,
136 [PAT_MATCH_INT] = SMP_T_SINT,
Thierry FOURNIERe3ded592013-12-06 15:36:54 +0100137 [PAT_MATCH_IP] = SMP_T_ADDR,
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100138 [PAT_MATCH_BIN] = SMP_T_BIN,
139 [PAT_MATCH_LEN] = SMP_T_STR,
140 [PAT_MATCH_STR] = SMP_T_STR,
141 [PAT_MATCH_BEG] = SMP_T_STR,
142 [PAT_MATCH_SUB] = SMP_T_STR,
143 [PAT_MATCH_DIR] = SMP_T_STR,
144 [PAT_MATCH_DOM] = SMP_T_STR,
145 [PAT_MATCH_END] = SMP_T_STR,
146 [PAT_MATCH_REG] = SMP_T_STR,
Thierry Fournier8feaa662016-02-10 22:55:20 +0100147 [PAT_MATCH_REGM] = SMP_T_STR,
Thierry FOURNIERe3ded592013-12-06 15:36:54 +0100148};
149
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100150/* this struct is used to return information */
Emeric Brunb5997f72017-07-03 11:34:05 +0200151static THREAD_LOCAL struct pattern static_pattern;
152static THREAD_LOCAL struct sample_data static_sample_data;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100153
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100154/* This is the root of the list of all pattern_ref avalaibles. */
155struct list pattern_reference = LIST_HEAD_INIT(pattern_reference);
156
Willy Tarreauf3045d22015-04-29 16:24:50 +0200157static struct lru64_head *pat_lru_tree;
Willy Tarreau86abe442018-11-25 20:12:18 +0100158__decl_spinlock(pat_lru_tree_lock);
Willy Tarreauf3045d22015-04-29 16:24:50 +0200159static unsigned long long pat_lru_seed;
160
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100161/*
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100162 *
163 * The following functions are not exported and are used by internals process
164 * of pattern matching
165 *
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100166 */
167
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100168/* Background: Fast way to find a zero byte in a word
169 * http://graphics.stanford.edu/~seander/bithacks.html#ZeroInWord
170 * hasZeroByte = (v - 0x01010101UL) & ~v & 0x80808080UL;
171 *
172 * To look for 4 different byte values, xor the word with those bytes and
173 * then check for zero bytes:
174 *
175 * v = (((unsigned char)c * 0x1010101U) ^ delimiter)
176 * where <delimiter> is the 4 byte values to look for (as an uint)
177 * and <c> is the character that is being tested
178 */
179static inline unsigned int is_delimiter(unsigned char c, unsigned int mask)
180{
181 mask ^= (c * 0x01010101); /* propagate the char to all 4 bytes */
182 return (mask - 0x01010101) & ~mask & 0x80808080U;
183}
184
185static inline unsigned int make_4delim(unsigned char d1, unsigned char d2, unsigned char d3, unsigned char d4)
186{
187 return d1 << 24 | d2 << 16 | d3 << 8 | d4;
188}
189
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100190
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100191/*
192 *
193 * These functions are exported and may be used by any other component.
194 *
Willy Tarreau5def8ef2014-08-29 15:19:33 +0200195 * The following functions are used for parsing pattern matching input value.
196 * The <text> contain the string to be parsed. <pattern> must be a preallocated
197 * pattern. The pat_parse_* functions fill this structure with the parsed value.
198 * <err> is filled with an error message built with memprintf() function. It is
199 * allowed to use a trash as a temporary storage for the returned pattern, as
200 * the next call after these functions will be pat_idx_*.
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100201 *
Willy Tarreau5def8ef2014-08-29 15:19:33 +0200202 * In success case, the pat_parse_* function returns 1. If the function
203 * fails, it returns 0 and <err> is filled.
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100204 */
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100205
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100206/* ignore the current line */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200207int pat_parse_nothing(const char *text, struct pattern *pattern, int mflags, char **err)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100208{
209 return 1;
210}
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100211
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100212/* Parse a string. It is allocated and duplicated. */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200213int pat_parse_str(const char *text, struct pattern *pattern, int mflags, char **err)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100214{
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100215 pattern->type = SMP_T_STR;
Thierry FOURNIERedc15c32013-12-13 15:36:59 +0100216 pattern->ptr.str = (char *)text;
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100217 pattern->len = strlen(text);
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100218 return 1;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100219}
220
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100221/* Parse a binary written in hexa. It is allocated. */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200222int pat_parse_bin(const char *text, struct pattern *pattern, int mflags, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100223{
Willy Tarreau83061a82018-07-13 11:56:34 +0200224 struct buffer *trash;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100225
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100226 pattern->type = SMP_T_BIN;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100227 trash = get_trash_chunk();
228 pattern->len = trash->size;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200229 pattern->ptr.str = trash->area;
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100230 return !!parse_binary(text, &pattern->ptr.str, &pattern->len, err);
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100231}
232
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100233/* Parse a regex. It is allocated. */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200234int pat_parse_reg(const char *text, struct pattern *pattern, int mflags, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100235{
Thierry FOURNIER0b6d15f2014-01-29 19:35:16 +0100236 pattern->ptr.str = (char *)text;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100237 return 1;
238}
239
240/* Parse a range of positive integers delimited by either ':' or '-'. If only
241 * one integer is read, it is set as both min and max. An operator may be
242 * specified as the prefix, among this list of 5 :
243 *
244 * 0:eq, 1:gt, 2:ge, 3:lt, 4:le
245 *
246 * The default operator is "eq". It supports range matching. Ranges are
247 * rejected for other operators. The operator may be changed at any time.
248 * The operator is stored in the 'opaque' argument.
249 *
250 * If err is non-NULL, an error message will be returned there on errors and
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100251 * the caller will have to free it. The function returns zero on error, and
252 * non-zero on success.
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100253 *
254 */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200255int pat_parse_int(const char *text, struct pattern *pattern, int mflags, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100256{
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100257 const char *ptr = text;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100258
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200259 pattern->type = SMP_T_SINT;
Thierry FOURNIER7148ce62013-12-06 19:06:43 +0100260
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100261 /* Empty string is not valid */
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100262 if (!*text)
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100263 goto not_valid_range;
264
265 /* Search ':' or '-' separator. */
266 while (*ptr != '\0' && *ptr != ':' && *ptr != '-')
267 ptr++;
268
269 /* If separator not found. */
270 if (!*ptr) {
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100271 if (strl2llrc(text, ptr - text, &pattern->val.range.min) != 0) {
272 memprintf(err, "'%s' is not a number", text);
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100273 return 0;
274 }
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100275 pattern->val.range.max = pattern->val.range.min;
276 pattern->val.range.min_set = 1;
277 pattern->val.range.max_set = 1;
278 return 1;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100279 }
280
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100281 /* If the separator is the first character. */
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100282 if (ptr == text && *(ptr + 1) != '\0') {
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100283 if (strl2llrc(ptr + 1, strlen(ptr + 1), &pattern->val.range.max) != 0)
284 goto not_valid_range;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100285
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100286 pattern->val.range.min_set = 0;
287 pattern->val.range.max_set = 1;
288 return 1;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100289 }
290
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100291 /* If separator is the last character. */
292 if (*(ptr + 1) == '\0') {
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100293 if (strl2llrc(text, ptr - text, &pattern->val.range.min) != 0)
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100294 goto not_valid_range;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100295
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100296 pattern->val.range.min_set = 1;
297 pattern->val.range.max_set = 0;
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100298 return 1;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100299 }
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100300
301 /* Else, parse two numbers. */
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100302 if (strl2llrc(text, ptr - text, &pattern->val.range.min) != 0)
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100303 goto not_valid_range;
304
305 if (strl2llrc(ptr + 1, strlen(ptr + 1), &pattern->val.range.max) != 0)
306 goto not_valid_range;
307
308 if (pattern->val.range.min > pattern->val.range.max)
309 goto not_valid_range;
310
311 pattern->val.range.min_set = 1;
312 pattern->val.range.max_set = 1;
313 return 1;
314
315 not_valid_range:
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100316 memprintf(err, "'%s' is not a valid number range", text);
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100317 return 0;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100318}
319
320/* Parse a range of positive 2-component versions delimited by either ':' or
321 * '-'. The version consists in a major and a minor, both of which must be
322 * smaller than 65536, because internally they will be represented as a 32-bit
323 * integer.
324 * If only one version is read, it is set as both min and max. Just like for
325 * pure integers, an operator may be specified as the prefix, among this list
326 * of 5 :
327 *
328 * 0:eq, 1:gt, 2:ge, 3:lt, 4:le
329 *
330 * The default operator is "eq". It supports range matching. Ranges are
331 * rejected for other operators. The operator may be changed at any time.
332 * The operator is stored in the 'opaque' argument. This allows constructs
333 * such as the following one :
334 *
335 * acl obsolete_ssl ssl_req_proto lt 3
336 * acl unsupported_ssl ssl_req_proto gt 3.1
337 * acl valid_ssl ssl_req_proto 3.0-3.1
338 *
339 */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200340int pat_parse_dotted_ver(const char *text, struct pattern *pattern, int mflags, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100341{
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100342 const char *ptr = text;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100343
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200344 pattern->type = SMP_T_SINT;
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100345
346 /* Search ':' or '-' separator. */
347 while (*ptr != '\0' && *ptr != ':' && *ptr != '-')
348 ptr++;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100349
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100350 /* If separator not found. */
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100351 if (*ptr == '\0' && ptr > text) {
352 if (strl2llrc_dotted(text, ptr-text, &pattern->val.range.min) != 0) {
353 memprintf(err, "'%s' is not a dotted number", text);
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100354 return 0;
355 }
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100356 pattern->val.range.max = pattern->val.range.min;
357 pattern->val.range.min_set = 1;
358 pattern->val.range.max_set = 1;
359 return 1;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100360 }
361
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100362 /* If the separator is the first character. */
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100363 if (ptr == text && *(ptr+1) != '\0') {
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100364 if (strl2llrc_dotted(ptr+1, strlen(ptr+1), &pattern->val.range.max) != 0) {
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100365 memprintf(err, "'%s' is not a valid dotted number range", text);
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100366 return 0;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100367 }
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100368 pattern->val.range.min_set = 0;
369 pattern->val.range.max_set = 1;
370 return 1;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100371 }
372
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100373 /* If separator is the last character. */
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100374 if (ptr == &text[strlen(text)-1]) {
375 if (strl2llrc_dotted(text, ptr-text, &pattern->val.range.min) != 0) {
376 memprintf(err, "'%s' is not a valid dotted number range", text);
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100377 return 0;
378 }
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100379 pattern->val.range.min_set = 1;
380 pattern->val.range.max_set = 0;
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100381 return 1;
382 }
383
384 /* Else, parse two numbers. */
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100385 if (strl2llrc_dotted(text, ptr-text, &pattern->val.range.min) != 0) {
386 memprintf(err, "'%s' is not a valid dotted number range", text);
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100387 return 0;
388 }
389 if (strl2llrc_dotted(ptr+1, strlen(ptr+1), &pattern->val.range.max) != 0) {
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100390 memprintf(err, "'%s' is not a valid dotted number range", text);
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100391 return 0;
392 }
393 if (pattern->val.range.min > pattern->val.range.max) {
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100394 memprintf(err, "'%s' is not a valid dotted number range", text);
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100395 return 0;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100396 }
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100397 pattern->val.range.min_set = 1;
398 pattern->val.range.max_set = 1;
399 return 1;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100400}
401
402/* Parse an IP address and an optional mask in the form addr[/mask].
403 * The addr may either be an IPv4 address or a hostname. The mask
404 * may either be a dotted mask or a number of bits. Returns 1 if OK,
405 * otherwise 0. NOTE: IP address patterns are typed (IPV4/IPV6).
406 */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200407int pat_parse_ip(const char *text, struct pattern *pattern, int mflags, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100408{
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200409 if (str2net(text, !(mflags & PAT_MF_NO_DNS) && (global.mode & MODE_STARTING),
Thierry FOURNIERfc7ac7b2014-02-11 15:23:04 +0100410 &pattern->val.ipv4.addr, &pattern->val.ipv4.mask)) {
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100411 pattern->type = SMP_T_IPV4;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100412 return 1;
413 }
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100414 else if (str62net(text, &pattern->val.ipv6.addr, &pattern->val.ipv6.mask)) {
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100415 pattern->type = SMP_T_IPV6;
416 return 1;
417 }
418 else {
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100419 memprintf(err, "'%s' is not a valid IPv4 or IPv6 address", text);
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100420 return 0;
421 }
422}
423
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100424/*
425 *
426 * These functions are exported and may be used by any other component.
427 *
Joseph Herlant4189d672018-11-15 10:22:31 -0800428 * This function just takes a sample <smp> and checks if this sample matches
429 * with the pattern <pattern>. This function returns only PAT_MATCH or
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100430 * PAT_NOMATCH.
431 *
432 */
433
434/* always return false */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100435struct pattern *pat_match_nothing(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100436{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200437 if (smp->data.u.sint) {
Thierry FOURNIERe5978bf2014-03-17 19:53:10 +0100438 if (fill) {
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200439 static_pattern.data = NULL;
Thierry FOURNIERe5978bf2014-03-17 19:53:10 +0100440 static_pattern.ref = NULL;
Thierry FOURNIERe5978bf2014-03-17 19:53:10 +0100441 static_pattern.type = 0;
442 static_pattern.ptr.str = NULL;
443 }
444 return &static_pattern;
445 }
446 else
447 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100448}
449
450
Joseph Herlant4189d672018-11-15 10:22:31 -0800451/* NB: For two strings to be identical, it is required that their length match */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100452struct pattern *pat_match_str(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100453{
454 int icase;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100455 struct ebmb_node *node;
456 char prev;
457 struct pattern_tree *elt;
458 struct pattern_list *lst;
459 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200460 struct pattern *ret = NULL;
461 struct lru64 *lru = NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100462
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100463 /* Lookup a string in the expression's pattern tree. */
464 if (!eb_is_empty(&expr->pattern_tree)) {
465 /* we may have to force a trailing zero on the test pattern */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200466 prev = smp->data.u.str.area[smp->data.u.str.data];
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100467 if (prev)
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200468 smp->data.u.str.area[smp->data.u.str.data] = '\0';
469 node = ebst_lookup(&expr->pattern_tree, smp->data.u.str.area);
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100470 if (prev)
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200471 smp->data.u.str.area[smp->data.u.str.data] = prev;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100472
473 if (node) {
474 if (fill) {
475 elt = ebmb_entry(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200476 static_pattern.data = elt->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +0100477 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200478 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100479 static_pattern.type = SMP_T_STR;
480 static_pattern.ptr.str = (char *)elt->node.key;
481 }
482 return &static_pattern;
483 }
484 }
485
486 /* look in the list */
Willy Tarreauf3045d22015-04-29 16:24:50 +0200487 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200488 unsigned long long seed = pat_lru_seed ^ (long)expr;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200489
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100490 HA_SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200491 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreauf3045d22015-04-29 16:24:50 +0200492 pat_lru_tree, expr, expr->revision);
Emeric Brunb5997f72017-07-03 11:34:05 +0200493 if (!lru) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100494 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200495 }
496 else if (lru->domain) {
497 ret = lru->data;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100498 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200499 return ret;
500 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200501 }
502
Emeric Brunb5997f72017-07-03 11:34:05 +0200503
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100504 list_for_each_entry(lst, &expr->patterns, list) {
505 pattern = &lst->pat;
506
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200507 if (pattern->len != smp->data.u.str.data)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100508 continue;
509
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200510 icase = expr->mflags & PAT_MF_IGNORE_CASE;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200511 if ((icase && strncasecmp(pattern->ptr.str, smp->data.u.str.area, smp->data.u.str.data) == 0) ||
512 (!icase && strncmp(pattern->ptr.str, smp->data.u.str.area, smp->data.u.str.data) == 0)) {
Willy Tarreauf3045d22015-04-29 16:24:50 +0200513 ret = pattern;
514 break;
515 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100516 }
517
Emeric Brunb5997f72017-07-03 11:34:05 +0200518 if (lru) {
519 lru64_commit(lru, ret, expr, expr->revision, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100520 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200521 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200522
523 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100524}
525
526/* NB: For two binaries buf to be identical, it is required that their lengths match */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100527struct pattern *pat_match_bin(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100528{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100529 struct pattern_list *lst;
530 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200531 struct pattern *ret = NULL;
532 struct lru64 *lru = NULL;
533
534 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200535 unsigned long long seed = pat_lru_seed ^ (long)expr;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100536
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100537 HA_SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200538 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreauf3045d22015-04-29 16:24:50 +0200539 pat_lru_tree, expr, expr->revision);
Emeric Brunb5997f72017-07-03 11:34:05 +0200540 if (!lru) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100541 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200542 }
543 else if (lru->domain) {
544 ret = lru->data;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100545 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200546 return ret;
547 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200548 }
549
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100550 list_for_each_entry(lst, &expr->patterns, list) {
551 pattern = &lst->pat;
552
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200553 if (pattern->len != smp->data.u.str.data)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100554 continue;
555
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200556 if (memcmp(pattern->ptr.str, smp->data.u.str.area, smp->data.u.str.data) == 0) {
Willy Tarreauf3045d22015-04-29 16:24:50 +0200557 ret = pattern;
558 break;
559 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100560 }
561
Emeric Brunb5997f72017-07-03 11:34:05 +0200562 if (lru) {
563 lru64_commit(lru, ret, expr, expr->revision, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100564 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200565 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200566
567 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100568}
569
570/* Executes a regex. It temporarily changes the data to add a trailing zero,
Thierry Fournier8feaa662016-02-10 22:55:20 +0100571 * and restores the previous character when leaving. This function fills
572 * a matching array.
573 */
574struct pattern *pat_match_regm(struct sample *smp, struct pattern_expr *expr, int fill)
575{
576 struct pattern_list *lst;
577 struct pattern *pattern;
578 struct pattern *ret = NULL;
579
580 list_for_each_entry(lst, &expr->patterns, list) {
581 pattern = &lst->pat;
582
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200583 if (regex_exec_match2(pattern->ptr.reg, smp->data.u.str.area, smp->data.u.str.data,
Thierry Fournier8feaa662016-02-10 22:55:20 +0100584 MAX_MATCH, pmatch, 0)) {
585 ret = pattern;
586 smp->ctx.a[0] = pmatch;
587 break;
588 }
589 }
590
591 return ret;
592}
593
594/* Executes a regex. It temporarily changes the data to add a trailing zero,
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100595 * and restores the previous character when leaving.
596 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100597struct pattern *pat_match_reg(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100598{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100599 struct pattern_list *lst;
600 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200601 struct pattern *ret = NULL;
602 struct lru64 *lru = NULL;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100603
Willy Tarreauf3045d22015-04-29 16:24:50 +0200604 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200605 unsigned long long seed = pat_lru_seed ^ (long)expr;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200606
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100607 HA_SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200608 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreauf3045d22015-04-29 16:24:50 +0200609 pat_lru_tree, expr, expr->revision);
Emeric Brunb5997f72017-07-03 11:34:05 +0200610 if (!lru) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100611 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200612 }
613 else if (lru->domain) {
614 ret = lru->data;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100615 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200616 return ret;
617 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200618 }
619
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100620 list_for_each_entry(lst, &expr->patterns, list) {
621 pattern = &lst->pat;
622
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200623 if (regex_exec2(pattern->ptr.reg, smp->data.u.str.area, smp->data.u.str.data)) {
Willy Tarreauf3045d22015-04-29 16:24:50 +0200624 ret = pattern;
625 break;
626 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100627 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200628
Emeric Brunb5997f72017-07-03 11:34:05 +0200629 if (lru) {
630 lru64_commit(lru, ret, expr, expr->revision, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100631 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200632 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200633
634 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100635}
636
637/* Checks that the pattern matches the beginning of the tested string. */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100638struct pattern *pat_match_beg(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100639{
640 int icase;
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200641 struct ebmb_node *node;
642 char prev;
643 struct pattern_tree *elt;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100644 struct pattern_list *lst;
645 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200646 struct pattern *ret = NULL;
647 struct lru64 *lru = NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100648
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200649 /* Lookup a string in the expression's pattern tree. */
650 if (!eb_is_empty(&expr->pattern_tree)) {
651 /* we may have to force a trailing zero on the test pattern */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200652 prev = smp->data.u.str.area[smp->data.u.str.data];
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200653 if (prev)
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200654 smp->data.u.str.area[smp->data.u.str.data] = '\0';
655 node = ebmb_lookup_longest(&expr->pattern_tree,
656 smp->data.u.str.area);
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200657 if (prev)
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200658 smp->data.u.str.area[smp->data.u.str.data] = prev;
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200659
660 if (node) {
661 if (fill) {
662 elt = ebmb_entry(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200663 static_pattern.data = elt->data;
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200664 static_pattern.ref = elt->ref;
665 static_pattern.sflags = PAT_SF_TREE;
666 static_pattern.type = SMP_T_STR;
667 static_pattern.ptr.str = (char *)elt->node.key;
668 }
669 return &static_pattern;
670 }
671 }
672
673 /* look in the list */
Willy Tarreauf3045d22015-04-29 16:24:50 +0200674 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200675 unsigned long long seed = pat_lru_seed ^ (long)expr;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200676
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100677 HA_SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200678 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreauf3045d22015-04-29 16:24:50 +0200679 pat_lru_tree, expr, expr->revision);
Emeric Brunb5997f72017-07-03 11:34:05 +0200680 if (!lru) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100681 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200682 }
683 else if (lru->domain) {
684 ret = lru->data;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100685 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200686 return ret;
687 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200688 }
689
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100690 list_for_each_entry(lst, &expr->patterns, list) {
691 pattern = &lst->pat;
692
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200693 if (pattern->len > smp->data.u.str.data)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100694 continue;
695
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200696 icase = expr->mflags & PAT_MF_IGNORE_CASE;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200697 if ((icase && strncasecmp(pattern->ptr.str, smp->data.u.str.area, pattern->len) != 0) ||
698 (!icase && strncmp(pattern->ptr.str, smp->data.u.str.area, pattern->len) != 0))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100699 continue;
700
Willy Tarreauf3045d22015-04-29 16:24:50 +0200701 ret = pattern;
702 break;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100703 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200704
Emeric Brunb5997f72017-07-03 11:34:05 +0200705 if (lru) {
706 lru64_commit(lru, ret, expr, expr->revision, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100707 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200708 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200709
710 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100711}
712
713/* Checks that the pattern matches the end of the tested string. */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100714struct pattern *pat_match_end(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100715{
716 int icase;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100717 struct pattern_list *lst;
718 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200719 struct pattern *ret = NULL;
720 struct lru64 *lru = NULL;
721
722 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200723 unsigned long long seed = pat_lru_seed ^ (long)expr;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200724
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100725 HA_SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200726 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreauf3045d22015-04-29 16:24:50 +0200727 pat_lru_tree, expr, expr->revision);
Emeric Brunb5997f72017-07-03 11:34:05 +0200728 if (!lru) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100729 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200730 }
731 else if (lru->domain) {
732 ret = lru->data;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100733 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200734 return ret;
735 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200736 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100737
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100738 list_for_each_entry(lst, &expr->patterns, list) {
739 pattern = &lst->pat;
740
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200741 if (pattern->len > smp->data.u.str.data)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100742 continue;
743
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200744 icase = expr->mflags & PAT_MF_IGNORE_CASE;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200745 if ((icase && strncasecmp(pattern->ptr.str, smp->data.u.str.area + smp->data.u.str.data - pattern->len, pattern->len) != 0) ||
746 (!icase && strncmp(pattern->ptr.str, smp->data.u.str.area + smp->data.u.str.data - pattern->len, pattern->len) != 0))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100747 continue;
748
Willy Tarreauf3045d22015-04-29 16:24:50 +0200749 ret = pattern;
750 break;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100751 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200752
Emeric Brunb5997f72017-07-03 11:34:05 +0200753 if (lru) {
754 lru64_commit(lru, ret, expr, expr->revision, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100755 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200756 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200757
758 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100759}
760
761/* Checks that the pattern is included inside the tested string.
762 * NB: Suboptimal, should be rewritten using a Boyer-Moore method.
763 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100764struct pattern *pat_match_sub(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100765{
766 int icase;
767 char *end;
768 char *c;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100769 struct pattern_list *lst;
770 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200771 struct pattern *ret = NULL;
772 struct lru64 *lru = NULL;
773
774 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200775 unsigned long long seed = pat_lru_seed ^ (long)expr;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200776
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100777 HA_SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200778 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreauf3045d22015-04-29 16:24:50 +0200779 pat_lru_tree, expr, expr->revision);
Emeric Brunb5997f72017-07-03 11:34:05 +0200780 if (!lru) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100781 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200782 }
783 else if (lru->domain) {
784 ret = lru->data;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100785 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200786 return ret;
787 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200788 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100789
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100790 list_for_each_entry(lst, &expr->patterns, list) {
791 pattern = &lst->pat;
792
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200793 if (pattern->len > smp->data.u.str.data)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100794 continue;
795
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200796 end = smp->data.u.str.area + smp->data.u.str.data - pattern->len;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200797 icase = expr->mflags & PAT_MF_IGNORE_CASE;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100798 if (icase) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200799 for (c = smp->data.u.str.area; c <= end; c++) {
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100800 if (tolower(*c) != tolower(*pattern->ptr.str))
801 continue;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200802 if (strncasecmp(pattern->ptr.str, c, pattern->len) == 0) {
803 ret = pattern;
804 goto leave;
805 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100806 }
807 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200808 for (c = smp->data.u.str.area; c <= end; c++) {
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100809 if (*c != *pattern->ptr.str)
810 continue;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200811 if (strncmp(pattern->ptr.str, c, pattern->len) == 0) {
812 ret = pattern;
813 goto leave;
814 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100815 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100816 }
817 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200818 leave:
Emeric Brunb5997f72017-07-03 11:34:05 +0200819 if (lru) {
820 lru64_commit(lru, ret, expr, expr->revision, NULL);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100821 HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200822 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200823
824 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100825}
826
827/* This one is used by other real functions. It checks that the pattern is
828 * included inside the tested string, but enclosed between the specified
829 * delimiters or at the beginning or end of the string. The delimiters are
830 * provided as an unsigned int made by make_4delim() and match up to 4 different
831 * delimiters. Delimiters are stripped at the beginning and end of the pattern.
832 */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200833static int match_word(struct sample *smp, struct pattern *pattern, int mflags, unsigned int delimiters)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100834{
835 int may_match, icase;
836 char *c, *end;
837 char *ps;
838 int pl;
839
840 pl = pattern->len;
841 ps = pattern->ptr.str;
842
843 while (pl > 0 && is_delimiter(*ps, delimiters)) {
844 pl--;
845 ps++;
846 }
847
848 while (pl > 0 && is_delimiter(ps[pl - 1], delimiters))
849 pl--;
850
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200851 if (pl > smp->data.u.str.data)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100852 return PAT_NOMATCH;
853
854 may_match = 1;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200855 icase = mflags & PAT_MF_IGNORE_CASE;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200856 end = smp->data.u.str.area + smp->data.u.str.data - pl;
857 for (c = smp->data.u.str.area; c <= end; c++) {
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100858 if (is_delimiter(*c, delimiters)) {
859 may_match = 1;
860 continue;
861 }
862
863 if (!may_match)
864 continue;
865
866 if (icase) {
867 if ((tolower(*c) == tolower(*ps)) &&
868 (strncasecmp(ps, c, pl) == 0) &&
869 (c == end || is_delimiter(c[pl], delimiters)))
870 return PAT_MATCH;
871 } else {
872 if ((*c == *ps) &&
873 (strncmp(ps, c, pl) == 0) &&
874 (c == end || is_delimiter(c[pl], delimiters)))
875 return PAT_MATCH;
876 }
877 may_match = 0;
878 }
879 return PAT_NOMATCH;
880}
881
882/* Checks that the pattern is included inside the tested string, but enclosed
883 * between the delimiters '?' or '/' or at the beginning or end of the string.
884 * Delimiters at the beginning or end of the pattern are ignored.
885 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100886struct pattern *pat_match_dir(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100887{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100888 struct pattern_list *lst;
889 struct pattern *pattern;
890
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100891 list_for_each_entry(lst, &expr->patterns, list) {
892 pattern = &lst->pat;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200893 if (match_word(smp, pattern, expr->mflags, make_4delim('/', '?', '?', '?')))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100894 return pattern;
895 }
896 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100897}
898
899/* Checks that the pattern is included inside the tested string, but enclosed
900 * between the delmiters '/', '?', '.' or ":" or at the beginning or end of
901 * the string. Delimiters at the beginning or end of the pattern are ignored.
902 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100903struct pattern *pat_match_dom(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100904{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100905 struct pattern_list *lst;
906 struct pattern *pattern;
907
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100908 list_for_each_entry(lst, &expr->patterns, list) {
909 pattern = &lst->pat;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200910 if (match_word(smp, pattern, expr->mflags, make_4delim('/', '?', '.', ':')))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100911 return pattern;
912 }
913 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100914}
915
916/* Checks that the integer in <test> is included between min and max */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100917struct pattern *pat_match_int(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100918{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100919 struct pattern_list *lst;
920 struct pattern *pattern;
921
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100922 list_for_each_entry(lst, &expr->patterns, list) {
923 pattern = &lst->pat;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200924 if ((!pattern->val.range.min_set || pattern->val.range.min <= smp->data.u.sint) &&
925 (!pattern->val.range.max_set || smp->data.u.sint <= pattern->val.range.max))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100926 return pattern;
927 }
928 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100929}
930
931/* Checks that the length of the pattern in <test> is included between min and max */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100932struct pattern *pat_match_len(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100933{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100934 struct pattern_list *lst;
935 struct pattern *pattern;
936
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100937 list_for_each_entry(lst, &expr->patterns, list) {
938 pattern = &lst->pat;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200939 if ((!pattern->val.range.min_set || pattern->val.range.min <= smp->data.u.str.data) &&
940 (!pattern->val.range.max_set || smp->data.u.str.data <= pattern->val.range.max))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100941 return pattern;
942 }
943 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100944}
945
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100946struct pattern *pat_match_ip(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100947{
948 unsigned int v4; /* in network byte order */
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100949 struct in6_addr tmp6;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100950 struct in_addr *s;
951 struct ebmb_node *node;
952 struct pattern_tree *elt;
953 struct pattern_list *lst;
954 struct pattern *pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100955
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100956 /* The input sample is IPv4. Try to match in the trees. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200957 if (smp->data.type == SMP_T_IPV4) {
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100958 /* Lookup an IPv4 address in the expression's pattern tree using
959 * the longest match method.
960 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200961 s = &smp->data.u.ipv4;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100962 node = ebmb_lookup_longest(&expr->pattern_tree, &s->s_addr);
963 if (node) {
964 if (fill) {
965 elt = ebmb_entry(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200966 static_pattern.data = elt->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +0100967 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200968 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100969 static_pattern.type = SMP_T_IPV4;
970 memcpy(&static_pattern.val.ipv4.addr.s_addr, elt->node.key, 4);
971 if (!cidr2dotted(elt->node.node.pfx, &static_pattern.val.ipv4.mask))
972 return NULL;
973 }
974 return &static_pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100975 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100976
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100977 /* The IPv4 sample dont match the IPv4 tree. Convert the IPv4
978 * sample address to IPv6 with the mapping method using the ::ffff:
979 * prefix, and try to lookup in the IPv6 tree.
980 */
981 memset(&tmp6, 0, 10);
982 *(uint16_t*)&tmp6.s6_addr[10] = htons(0xffff);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200983 *(uint32_t*)&tmp6.s6_addr[12] = smp->data.u.ipv4.s_addr;
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100984 node = ebmb_lookup_longest(&expr->pattern_tree_2, &tmp6);
985 if (node) {
986 if (fill) {
987 elt = ebmb_entry(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200988 static_pattern.data = elt->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +0100989 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200990 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100991 static_pattern.type = SMP_T_IPV6;
992 memcpy(&static_pattern.val.ipv6.addr, elt->node.key, 16);
993 static_pattern.val.ipv6.mask = elt->node.node.pfx;
994 }
995 return &static_pattern;
996 }
997 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100998
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100999 /* The input sample is IPv6. Try to match in the trees. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001000 if (smp->data.type == SMP_T_IPV6) {
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001001 /* Lookup an IPv6 address in the expression's pattern tree using
1002 * the longest match method.
1003 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001004 node = ebmb_lookup_longest(&expr->pattern_tree_2, &smp->data.u.ipv6);
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001005 if (node) {
1006 if (fill) {
1007 elt = ebmb_entry(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001008 static_pattern.data = elt->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001009 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001010 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001011 static_pattern.type = SMP_T_IPV6;
1012 memcpy(&static_pattern.val.ipv6.addr, elt->node.key, 16);
1013 static_pattern.val.ipv6.mask = elt->node.node.pfx;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001014 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001015 return &static_pattern;
1016 }
1017
1018 /* Try to convert 6 to 4 when the start of the ipv6 address match the
1019 * following forms :
1020 * - ::ffff:ip:v4 (ipv4 mapped)
1021 * - ::0000:ip:v4 (old ipv4 mapped)
1022 * - 2002:ip:v4:: (6to4)
1023 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001024 if ((*(uint32_t*)&smp->data.u.ipv6.s6_addr[0] == 0 &&
1025 *(uint32_t*)&smp->data.u.ipv6.s6_addr[4] == 0 &&
1026 (*(uint32_t*)&smp->data.u.ipv6.s6_addr[8] == 0 ||
1027 *(uint32_t*)&smp->data.u.ipv6.s6_addr[8] == htonl(0xFFFF))) ||
1028 *(uint16_t*)&smp->data.u.ipv6.s6_addr[0] == htons(0x2002)) {
1029 if (*(uint32_t*)&smp->data.u.ipv6.s6_addr[0] == 0)
1030 v4 = *(uint32_t*)&smp->data.u.ipv6.s6_addr[12];
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001031 else
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001032 v4 = htonl((ntohs(*(uint16_t*)&smp->data.u.ipv6.s6_addr[2]) << 16) +
1033 ntohs(*(uint16_t*)&smp->data.u.ipv6.s6_addr[4]));
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001034
1035 /* Lookup an IPv4 address in the expression's pattern tree using the longest
1036 * match method.
1037 */
1038 node = ebmb_lookup_longest(&expr->pattern_tree, &v4);
1039 if (node) {
1040 if (fill) {
1041 elt = ebmb_entry(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001042 static_pattern.data = elt->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001043 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001044 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001045 static_pattern.type = SMP_T_IPV4;
1046 memcpy(&static_pattern.val.ipv4.addr.s_addr, elt->node.key, 4);
1047 if (!cidr2dotted(elt->node.node.pfx, &static_pattern.val.ipv4.mask))
1048 return NULL;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001049 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001050 return &static_pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001051 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001052 }
1053 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001054
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001055 /* Lookup in the list. the list contain only IPv4 patterns */
1056 list_for_each_entry(lst, &expr->patterns, list) {
1057 pattern = &lst->pat;
1058
1059 /* The input sample is IPv4, use it as is. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001060 if (smp->data.type == SMP_T_IPV4) {
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001061 v4 = smp->data.u.ipv4.s_addr;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001062 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001063 else if (smp->data.type == SMP_T_IPV6) {
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001064 /* v4 match on a V6 sample. We want to check at least for
1065 * the following forms :
1066 * - ::ffff:ip:v4 (ipv4 mapped)
1067 * - ::0000:ip:v4 (old ipv4 mapped)
1068 * - 2002:ip:v4:: (6to4)
1069 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001070 if (*(uint32_t*)&smp->data.u.ipv6.s6_addr[0] == 0 &&
1071 *(uint32_t*)&smp->data.u.ipv6.s6_addr[4] == 0 &&
1072 (*(uint32_t*)&smp->data.u.ipv6.s6_addr[8] == 0 ||
1073 *(uint32_t*)&smp->data.u.ipv6.s6_addr[8] == htonl(0xFFFF))) {
1074 v4 = *(uint32_t*)&smp->data.u.ipv6.s6_addr[12];
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001075 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001076 else if (*(uint16_t*)&smp->data.u.ipv6.s6_addr[0] == htons(0x2002)) {
1077 v4 = htonl((ntohs(*(uint16_t*)&smp->data.u.ipv6.s6_addr[2]) << 16) +
1078 ntohs(*(uint16_t*)&smp->data.u.ipv6.s6_addr[4]));
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001079 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001080 else
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001081 continue;
Andreas Seltenreichf0653192016-03-03 20:08:35 +01001082 } else {
1083 /* impossible */
1084 continue;
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001085 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001086
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001087 /* Check if the input sample match the current pattern. */
1088 if (((v4 ^ pattern->val.ipv4.addr.s_addr) & pattern->val.ipv4.mask.s_addr) == 0)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001089 return pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001090 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001091 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001092}
1093
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001094void free_pattern_tree(struct eb_root *root)
1095{
1096 struct eb_node *node, *next;
Thierry FOURNIERe1bcac52013-12-13 16:09:50 +01001097 struct pattern_tree *elt;
Thierry FOURNIER3ce88c72013-12-09 11:29:46 +01001098
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001099 node = eb_first(root);
1100 while (node) {
1101 next = eb_next(node);
1102 eb_delete(node);
Thierry FOURNIERe1bcac52013-12-13 16:09:50 +01001103 elt = container_of(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001104 free(elt->data);
Thierry FOURNIER3ce88c72013-12-09 11:29:46 +01001105 free(elt);
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001106 node = next;
1107 }
1108}
1109
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001110void pat_prune_val(struct pattern_expr *expr)
Thierry FOURNIERd163e1c2013-11-28 11:41:23 +01001111{
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001112 struct pattern_list *pat, *tmp;
1113
1114 list_for_each_entry_safe(pat, tmp, &expr->patterns, list) {
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001115 free(pat->pat.data);
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001116 free(pat);
1117 }
1118
Thierry FOURNIERd163e1c2013-11-28 11:41:23 +01001119 free_pattern_tree(&expr->pattern_tree);
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001120 free_pattern_tree(&expr->pattern_tree_2);
Thierry FOURNIERd163e1c2013-11-28 11:41:23 +01001121 LIST_INIT(&expr->patterns);
1122}
1123
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001124void pat_prune_ptr(struct pattern_expr *expr)
1125{
1126 struct pattern_list *pat, *tmp;
1127
1128 list_for_each_entry_safe(pat, tmp, &expr->patterns, list) {
1129 free(pat->pat.ptr.ptr);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001130 free(pat->pat.data);
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001131 free(pat);
1132 }
1133
1134 free_pattern_tree(&expr->pattern_tree);
1135 free_pattern_tree(&expr->pattern_tree_2);
1136 LIST_INIT(&expr->patterns);
1137}
1138
1139void pat_prune_reg(struct pattern_expr *expr)
1140{
1141 struct pattern_list *pat, *tmp;
1142
1143 list_for_each_entry_safe(pat, tmp, &expr->patterns, list) {
1144 regex_free(pat->pat.ptr.ptr);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001145 free(pat->pat.data);
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001146 free(pat);
1147 }
1148
1149 free_pattern_tree(&expr->pattern_tree);
1150 free_pattern_tree(&expr->pattern_tree_2);
1151 LIST_INIT(&expr->patterns);
1152}
1153
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001154/*
1155 *
1156 * The following functions are used for the pattern indexation
1157 *
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001158 */
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001159
1160int pat_idx_list_val(struct pattern_expr *expr, struct pattern *pat, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001161{
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001162 struct pattern_list *patl;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001163
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001164 /* allocate pattern */
1165 patl = calloc(1, sizeof(*patl));
1166 if (!patl) {
1167 memprintf(err, "out of memory while indexing pattern");
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001168 return 0;
1169 }
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001170
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001171 /* duplicate pattern */
1172 memcpy(&patl->pat, pat, sizeof(*pat));
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001173
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001174 /* chain pattern in the expression */
1175 LIST_ADDQ(&expr->patterns, &patl->list);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001176 expr->revision = rdtsc();
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001177
1178 /* that's ok */
1179 return 1;
1180}
1181
1182int pat_idx_list_ptr(struct pattern_expr *expr, struct pattern *pat, char **err)
1183{
1184 struct pattern_list *patl;
1185
1186 /* allocate pattern */
1187 patl = calloc(1, sizeof(*patl));
Thierry FOURNIER8aa83842015-02-06 17:50:55 +01001188 if (!patl) {
1189 memprintf(err, "out of memory while indexing pattern");
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001190 return 0;
Thierry FOURNIER8aa83842015-02-06 17:50:55 +01001191 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001192
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001193 /* duplicate pattern */
1194 memcpy(&patl->pat, pat, sizeof(*pat));
1195 patl->pat.ptr.ptr = malloc(patl->pat.len);
1196 if (!patl->pat.ptr.ptr) {
1197 free(patl);
1198 memprintf(err, "out of memory while indexing pattern");
1199 return 0;
1200 }
1201 memcpy(patl->pat.ptr.ptr, pat->ptr.ptr, pat->len);
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001202
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001203 /* chain pattern in the expression */
1204 LIST_ADDQ(&expr->patterns, &patl->list);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001205 expr->revision = rdtsc();
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001206
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001207 /* that's ok */
1208 return 1;
1209}
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001210
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001211int pat_idx_list_str(struct pattern_expr *expr, struct pattern *pat, char **err)
1212{
1213 struct pattern_list *patl;
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001214
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001215 /* allocate pattern */
1216 patl = calloc(1, sizeof(*patl));
1217 if (!patl) {
1218 memprintf(err, "out of memory while indexing pattern");
1219 return 0;
1220 }
1221
1222 /* duplicate pattern */
1223 memcpy(&patl->pat, pat, sizeof(*pat));
1224 patl->pat.ptr.str = malloc(patl->pat.len + 1);
1225 if (!patl->pat.ptr.str) {
1226 free(patl);
1227 memprintf(err, "out of memory while indexing pattern");
1228 return 0;
1229 }
1230 memcpy(patl->pat.ptr.ptr, pat->ptr.ptr, pat->len);
1231 patl->pat.ptr.str[patl->pat.len] = '\0';
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001232
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001233 /* chain pattern in the expression */
1234 LIST_ADDQ(&expr->patterns, &patl->list);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001235 expr->revision = rdtsc();
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001236
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001237 /* that's ok */
1238 return 1;
1239}
1240
Thierry Fournier8feaa662016-02-10 22:55:20 +01001241int pat_idx_list_reg_cap(struct pattern_expr *expr, struct pattern *pat, int cap, char **err)
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001242{
1243 struct pattern_list *patl;
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001244
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001245 /* allocate pattern */
1246 patl = calloc(1, sizeof(*patl));
1247 if (!patl) {
1248 memprintf(err, "out of memory while indexing pattern");
1249 return 0;
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001250 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001251
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001252 /* duplicate pattern */
1253 memcpy(&patl->pat, pat, sizeof(*pat));
1254
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001255 /* compile regex */
Dragan Dosen26743032019-04-30 15:54:36 +02001256 if (!(patl->pat.ptr.reg = regex_comp(pat->ptr.str, !(expr->mflags & PAT_MF_IGNORE_CASE),
1257 cap, err))) {
Dirkjan Bussink07fcaaa2014-04-28 22:57:16 +00001258 free(patl);
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001259 return 0;
1260 }
1261
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001262 /* chain pattern in the expression */
1263 LIST_ADDQ(&expr->patterns, &patl->list);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001264 expr->revision = rdtsc();
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001265
1266 /* that's ok */
1267 return 1;
1268}
1269
Thierry Fournier8feaa662016-02-10 22:55:20 +01001270int pat_idx_list_reg(struct pattern_expr *expr, struct pattern *pat, char **err)
1271{
1272 return pat_idx_list_reg_cap(expr, pat, 0, err);
1273}
1274
1275int pat_idx_list_regm(struct pattern_expr *expr, struct pattern *pat, char **err)
1276{
1277 return pat_idx_list_reg_cap(expr, pat, 1, err);
1278}
1279
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001280int pat_idx_tree_ip(struct pattern_expr *expr, struct pattern *pat, char **err)
1281{
1282 unsigned int mask;
Thierry FOURNIERe1bcac52013-12-13 16:09:50 +01001283 struct pattern_tree *node;
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001284
1285 /* Only IPv4 can be indexed */
1286 if (pat->type == SMP_T_IPV4) {
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001287 /* in IPv4 case, check if the mask is contiguous so that we can
1288 * insert the network into the tree. A continuous mask has only
1289 * ones on the left. This means that this mask + its lower bit
1290 * added once again is null.
1291 */
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001292 mask = ntohl(pat->val.ipv4.mask.s_addr);
1293 if (mask + (mask & -mask) == 0) {
1294 mask = mask ? 33 - flsnz(mask & -mask) : 0; /* equals cidr value */
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001295
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001296 /* node memory allocation */
1297 node = calloc(1, sizeof(*node) + 4);
1298 if (!node) {
1299 memprintf(err, "out of memory while loading pattern");
1300 return 0;
1301 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001302
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001303 /* copy the pointer to sample associated to this node */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001304 node->data = pat->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001305 node->ref = pat->ref;
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001306
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001307 /* FIXME: insert <addr>/<mask> into the tree here */
1308 memcpy(node->node.key, &pat->val.ipv4.addr, 4); /* network byte order */
1309 node->node.node.pfx = mask;
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001310
1311 /* Insert the entry. */
1312 ebmb_insert_prefix(&expr->pattern_tree, &node->node, 4);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001313 expr->revision = rdtsc();
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001314
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001315 /* that's ok */
1316 return 1;
1317 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001318 else {
1319 /* If the mask is not contiguous, just add the pattern to the list */
1320 return pat_idx_list_val(expr, pat, err);
1321 }
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001322 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001323 else if (pat->type == SMP_T_IPV6) {
1324 /* IPv6 also can be indexed */
1325 node = calloc(1, sizeof(*node) + 16);
1326 if (!node) {
1327 memprintf(err, "out of memory while loading pattern");
1328 return 0;
1329 }
1330
1331 /* copy the pointer to sample associated to this node */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001332 node->data = pat->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001333 node->ref = pat->ref;
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001334
1335 /* FIXME: insert <addr>/<mask> into the tree here */
1336 memcpy(node->node.key, &pat->val.ipv6.addr, 16); /* network byte order */
1337 node->node.node.pfx = pat->val.ipv6.mask;
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001338
1339 /* Insert the entry. */
1340 ebmb_insert_prefix(&expr->pattern_tree_2, &node->node, 16);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001341 expr->revision = rdtsc();
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001342
1343 /* that's ok */
1344 return 1;
1345 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001346
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001347 return 0;
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001348}
1349
1350int pat_idx_tree_str(struct pattern_expr *expr, struct pattern *pat, char **err)
1351{
1352 int len;
Thierry FOURNIERe1bcac52013-12-13 16:09:50 +01001353 struct pattern_tree *node;
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001354
1355 /* Only string can be indexed */
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001356 if (pat->type != SMP_T_STR) {
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001357 memprintf(err, "internal error: string expected, but the type is '%s'",
1358 smp_to_type[pat->type]);
1359 return 0;
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001360 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001361
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001362 /* If the flag PAT_F_IGNORE_CASE is set, we cannot use trees */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001363 if (expr->mflags & PAT_MF_IGNORE_CASE)
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001364 return pat_idx_list_str(expr, pat, err);
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001365
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001366 /* Process the key len */
1367 len = strlen(pat->ptr.str) + 1;
1368
1369 /* node memory allocation */
1370 node = calloc(1, sizeof(*node) + len);
1371 if (!node) {
1372 memprintf(err, "out of memory while loading pattern");
1373 return 0;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001374 }
1375
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001376 /* copy the pointer to sample associated to this node */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001377 node->data = pat->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001378 node->ref = pat->ref;
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001379
1380 /* copy the string */
1381 memcpy(node->node.key, pat->ptr.str, len);
1382
1383 /* index the new node */
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001384 ebst_insert(&expr->pattern_tree, &node->node);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001385 expr->revision = rdtsc();
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001386
1387 /* that's ok */
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001388 return 1;
1389}
1390
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +02001391int pat_idx_tree_pfx(struct pattern_expr *expr, struct pattern *pat, char **err)
1392{
1393 int len;
1394 struct pattern_tree *node;
1395
1396 /* Only string can be indexed */
1397 if (pat->type != SMP_T_STR) {
1398 memprintf(err, "internal error: string expected, but the type is '%s'",
1399 smp_to_type[pat->type]);
1400 return 0;
1401 }
1402
1403 /* If the flag PAT_F_IGNORE_CASE is set, we cannot use trees */
1404 if (expr->mflags & PAT_MF_IGNORE_CASE)
1405 return pat_idx_list_str(expr, pat, err);
1406
1407 /* Process the key len */
1408 len = strlen(pat->ptr.str);
1409
1410 /* node memory allocation */
1411 node = calloc(1, sizeof(*node) + len + 1);
1412 if (!node) {
1413 memprintf(err, "out of memory while loading pattern");
1414 return 0;
1415 }
1416
1417 /* copy the pointer to sample associated to this node */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001418 node->data = pat->data;
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +02001419 node->ref = pat->ref;
1420
1421 /* copy the string and the trailing zero */
1422 memcpy(node->node.key, pat->ptr.str, len + 1);
1423 node->node.node.pfx = len * 8;
1424
1425 /* index the new node */
1426 ebmb_insert_prefix(&expr->pattern_tree, &node->node, len);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001427 expr->revision = rdtsc();
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +02001428
1429 /* that's ok */
1430 return 1;
1431}
1432
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001433void pat_del_list_val(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001434{
1435 struct pattern_list *pat;
1436 struct pattern_list *safe;
1437
1438 list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
1439 /* Check equality. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001440 if (pat->pat.ref != ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001441 continue;
1442
1443 /* Delete and free entry. */
1444 LIST_DEL(&pat->list);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001445 free(pat->pat.data);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001446 free(pat);
1447 }
Willy Tarreau72f073b2015-04-29 17:53:47 +02001448 expr->revision = rdtsc();
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001449}
1450
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001451void pat_del_tree_ip(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001452{
1453 struct ebmb_node *node, *next_node;
1454 struct pattern_tree *elt;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001455
1456 /* browse each node of the tree for IPv4 addresses. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001457 for (node = ebmb_first(&expr->pattern_tree), next_node = node ? ebmb_next(node) : NULL;
1458 node;
1459 node = next_node, next_node = node ? ebmb_next(node) : NULL) {
1460 /* Extract container of the tree node. */
1461 elt = container_of(node, struct pattern_tree, node);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001462
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001463 /* Check equality. */
1464 if (elt->ref != ref)
1465 continue;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001466
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001467 /* Delete and free entry. */
1468 ebmb_delete(node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001469 free(elt->data);
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001470 free(elt);
1471 }
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001472
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001473 /* Browse each node of the list for IPv4 addresses. */
1474 pat_del_list_val(expr, ref);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001475
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001476 /* browse each node of the tree for IPv6 addresses. */
1477 for (node = ebmb_first(&expr->pattern_tree_2), next_node = node ? ebmb_next(node) : NULL;
1478 node;
1479 node = next_node, next_node = node ? ebmb_next(node) : NULL) {
1480 /* Extract container of the tree node. */
1481 elt = container_of(node, struct pattern_tree, node);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001482
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001483 /* Check equality. */
1484 if (elt->ref != ref)
1485 continue;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001486
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001487 /* Delete and free entry. */
1488 ebmb_delete(node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001489 free(elt->data);
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001490 free(elt);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001491 }
Willy Tarreau72f073b2015-04-29 17:53:47 +02001492 expr->revision = rdtsc();
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001493}
1494
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001495void pat_del_list_ptr(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001496{
1497 struct pattern_list *pat;
1498 struct pattern_list *safe;
1499
1500 list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
1501 /* Check equality. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001502 if (pat->pat.ref != ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001503 continue;
1504
1505 /* Delete and free entry. */
1506 LIST_DEL(&pat->list);
1507 free(pat->pat.ptr.ptr);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001508 free(pat->pat.data);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001509 free(pat);
1510 }
Willy Tarreau72f073b2015-04-29 17:53:47 +02001511 expr->revision = rdtsc();
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001512}
1513
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001514void pat_del_tree_str(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001515{
1516 struct ebmb_node *node, *next_node;
1517 struct pattern_tree *elt;
1518
Thierry FOURNIER73bc2852015-02-06 17:53:54 +01001519 /* If the flag PAT_F_IGNORE_CASE is set, we cannot use trees */
1520 if (expr->mflags & PAT_MF_IGNORE_CASE)
1521 return pat_del_list_ptr(expr, ref);
1522
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001523 /* browse each node of the tree. */
1524 for (node = ebmb_first(&expr->pattern_tree), next_node = node ? ebmb_next(node) : NULL;
1525 node;
1526 node = next_node, next_node = node ? ebmb_next(node) : NULL) {
1527 /* Extract container of the tree node. */
1528 elt = container_of(node, struct pattern_tree, node);
1529
1530 /* Check equality. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001531 if (elt->ref != ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001532 continue;
1533
1534 /* Delete and free entry. */
1535 ebmb_delete(node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001536 free(elt->data);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001537 free(elt);
1538 }
Willy Tarreau72f073b2015-04-29 17:53:47 +02001539 expr->revision = rdtsc();
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001540}
1541
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001542void pat_del_list_reg(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001543{
1544 struct pattern_list *pat;
1545 struct pattern_list *safe;
1546
1547 list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
1548 /* Check equality. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001549 if (pat->pat.ref != ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001550 continue;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001551
1552 /* Delete and free entry. */
1553 LIST_DEL(&pat->list);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001554 regex_free(pat->pat.ptr.ptr);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001555 free(pat->pat.data);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001556 free(pat);
1557 }
Willy Tarreau72f073b2015-04-29 17:53:47 +02001558 expr->revision = rdtsc();
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001559}
1560
1561void pattern_init_expr(struct pattern_expr *expr)
1562{
1563 LIST_INIT(&expr->patterns);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001564 expr->revision = 0;
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001565 expr->pattern_tree = EB_ROOT;
1566 expr->pattern_tree_2 = EB_ROOT;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001567}
1568
1569void pattern_init_head(struct pattern_head *head)
1570{
1571 LIST_INIT(&head->head);
1572}
1573
1574/* The following functions are relative to the management of the reference
1575 * lists. These lists are used to store the original pattern and associated
1576 * value as string form.
1577 *
1578 * This is used with modifiable ACL and MAPS
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001579 *
1580 * The pattern reference are stored with two identifiers: the unique_id and
1581 * the reference.
1582 *
1583 * The reference identify a file. Each file with the same name point to the
1584 * same reference. We can register many times one file. If the file is modified,
1585 * all his dependencies are also modified. The reference can be used with map or
1586 * acl.
1587 *
1588 * The unique_id identify inline acl. The unique id is unique for each acl.
1589 * You cannot force the same id in the configuration file, because this repoort
1590 * an error.
1591 *
1592 * A particular case appears if the filename is a number. In this case, the
1593 * unique_id is set with the number represented by the filename and the
1594 * reference is also set. This method prevent double unique_id.
1595 *
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001596 */
1597
1598/* This function lookup for reference. If the reference is found, they return
1599 * pointer to the struct pat_ref, else return NULL.
1600 */
1601struct pat_ref *pat_ref_lookup(const char *reference)
1602{
1603 struct pat_ref *ref;
1604
1605 list_for_each_entry(ref, &pattern_reference, list)
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001606 if (ref->reference && strcmp(reference, ref->reference) == 0)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001607 return ref;
1608 return NULL;
1609}
1610
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001611/* This function lookup for unique id. If the reference is found, they return
1612 * pointer to the struct pat_ref, else return NULL.
1613 */
1614struct pat_ref *pat_ref_lookupid(int unique_id)
1615{
1616 struct pat_ref *ref;
1617
1618 list_for_each_entry(ref, &pattern_reference, list)
1619 if (ref->unique_id == unique_id)
1620 return ref;
1621 return NULL;
1622}
1623
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001624/* This function remove all pattern matching the pointer <refelt> from
1625 * the the reference and from each expr member of the reference. This
1626 * function returns 1 if the deletion is done and return 0 is the entry
1627 * is not found.
1628 */
1629int pat_ref_delete_by_id(struct pat_ref *ref, struct pat_ref_elt *refelt)
1630{
1631 struct pattern_expr *expr;
1632 struct pat_ref_elt *elt, *safe;
Emeric Brun8d85aa42017-06-29 15:40:33 +02001633 struct bref *bref, *back;
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001634
1635 /* delete pattern from reference */
1636 list_for_each_entry_safe(elt, safe, &ref->head, list) {
1637 if (elt == refelt) {
Emeric Brun8d85aa42017-06-29 15:40:33 +02001638 list_for_each_entry_safe(bref, back, &elt->back_refs, users) {
1639 /*
1640 * we have to unlink all watchers. We must not relink them if
1641 * this elt was the last one in the list.
1642 */
1643 LIST_DEL(&bref->users);
1644 LIST_INIT(&bref->users);
1645 if (elt->list.n != &ref->head)
Willy Tarreau49ee3b22019-04-30 11:43:43 +02001646 LIST_ADDQ(&LIST_ELEM(elt->list.n, typeof(elt), list)->back_refs, &bref->users);
Emeric Brun8d85aa42017-06-29 15:40:33 +02001647 bref->ref = elt->list.n;
1648 }
peter caiaede6dd2015-10-07 00:07:43 -07001649 list_for_each_entry(expr, &ref->pat, list)
1650 pattern_delete(expr, elt);
1651
Emeric Brunb5997f72017-07-03 11:34:05 +02001652 /* pat_ref_elt is trashed once all expr
1653 are cleaned and there is no ref remaining */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001654 LIST_DEL(&elt->list);
1655 free(elt->sample);
1656 free(elt->pattern);
1657 free(elt);
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001658 return 1;
1659 }
1660 }
1661 return 0;
1662}
1663
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001664/* This function remove all pattern match <key> from the the reference
Joseph Herlant4189d672018-11-15 10:22:31 -08001665 * and from each expr member of the reference. This function returns 1
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001666 * if the deletion is done and return 0 is the entry is not found.
1667 */
1668int pat_ref_delete(struct pat_ref *ref, const char *key)
1669{
1670 struct pattern_expr *expr;
1671 struct pat_ref_elt *elt, *safe;
Emeric Brun8d85aa42017-06-29 15:40:33 +02001672 struct bref *bref, *back;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001673 int found = 0;
1674
1675 /* delete pattern from reference */
1676 list_for_each_entry_safe(elt, safe, &ref->head, list) {
1677 if (strcmp(key, elt->pattern) == 0) {
Emeric Brun8d85aa42017-06-29 15:40:33 +02001678 list_for_each_entry_safe(bref, back, &elt->back_refs, users) {
1679 /*
1680 * we have to unlink all watchers. We must not relink them if
1681 * this elt was the last one in the list.
1682 */
1683 LIST_DEL(&bref->users);
1684 LIST_INIT(&bref->users);
1685 if (elt->list.n != &ref->head)
Willy Tarreau49ee3b22019-04-30 11:43:43 +02001686 LIST_ADDQ(&LIST_ELEM(elt->list.n, typeof(elt), list)->back_refs, &bref->users);
Emeric Brun8d85aa42017-06-29 15:40:33 +02001687 bref->ref = elt->list.n;
1688 }
Dirkjan Bussink07fcaaa2014-04-28 22:57:16 +00001689 list_for_each_entry(expr, &ref->pat, list)
1690 pattern_delete(expr, elt);
1691
Emeric Brunb5997f72017-07-03 11:34:05 +02001692 /* pat_ref_elt is trashed once all expr
1693 are cleaned and there is no ref remaining */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001694 LIST_DEL(&elt->list);
1695 free(elt->sample);
1696 free(elt->pattern);
1697 free(elt);
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001698
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001699 found = 1;
1700 }
1701 }
1702
1703 if (!found)
1704 return 0;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001705 return 1;
1706}
1707
Baptiste Assmann953f74d2014-04-25 16:57:03 +02001708/*
1709 * find and return an element <elt> matching <key> in a reference <ref>
1710 * return NULL if not found
1711 */
1712struct pat_ref_elt *pat_ref_find_elt(struct pat_ref *ref, const char *key)
1713{
1714 struct pat_ref_elt *elt;
1715
1716 list_for_each_entry(elt, &ref->head, list) {
1717 if (strcmp(key, elt->pattern) == 0)
1718 return elt;
1719 }
1720
1721 return NULL;
1722}
1723
1724
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001725 /* This function modify the sample of the first pattern that match the <key>. */
1726static inline int pat_ref_set_elt(struct pat_ref *ref, struct pat_ref_elt *elt,
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001727 const char *value, char **err)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001728{
1729 struct pattern_expr *expr;
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001730 struct sample_data **data;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001731 char *sample;
Thierry FOURNIER12ba0c22015-08-14 00:02:11 +02001732 struct sample_data test;
Thierry FOURNIER149e0fe2014-01-29 19:35:06 +01001733
1734 /* Try all needed converters. */
1735 list_for_each_entry(expr, &ref->pat, list) {
1736 if (!expr->pat_head->parse_smp)
1737 continue;
1738
1739 if (!expr->pat_head->parse_smp(value, &test)) {
1740 memprintf(err, "unable to parse '%s'", value);
1741 return 0;
1742 }
1743 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001744
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001745 /* Modify pattern from reference. */
1746 sample = strdup(value);
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001747 if (!sample) {
1748 memprintf(err, "out of memory error");
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001749 return 0;
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001750 }
Thierry FOURNIER149e0fe2014-01-29 19:35:06 +01001751 /* Load sample in each reference. All the conversion are tested
1752 * below, normally these calls dosn't fail.
1753 */
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01001754 list_for_each_entry(expr, &ref->pat, list) {
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001755 if (!expr->pat_head->parse_smp)
1756 continue;
1757
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001758 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001759 data = pattern_find_smp(expr, elt);
1760 if (data && *data && !expr->pat_head->parse_smp(sample, *data))
1761 *data = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001762 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001763 }
1764
Emeric Brunb5997f72017-07-03 11:34:05 +02001765 /* free old sample only when all exprs are updated */
1766 free(elt->sample);
1767 elt->sample = sample;
1768
1769
Thierry FOURNIER149e0fe2014-01-29 19:35:06 +01001770 return 1;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001771}
1772
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001773/* This function modify the sample of the first pattern that match the <key>. */
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001774int pat_ref_set_by_id(struct pat_ref *ref, struct pat_ref_elt *refelt, const char *value, char **err)
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001775{
1776 struct pat_ref_elt *elt;
1777
1778 /* Look for pattern in the reference. */
1779 list_for_each_entry(elt, &ref->head, list) {
1780 if (elt == refelt) {
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001781 if (!pat_ref_set_elt(ref, elt, value, err))
1782 return 0;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001783 return 1;
1784 }
1785 }
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001786
1787 memprintf(err, "key or pattern not found");
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001788 return 0;
1789}
1790
1791/* This function modify the sample of the first pattern that match the <key>. */
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001792int pat_ref_set(struct pat_ref *ref, const char *key, const char *value, char **err)
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001793{
1794 struct pat_ref_elt *elt;
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001795 int found = 0;
1796 char *_merr;
1797 char **merr;
1798
1799 if (err) {
1800 merr = &_merr;
1801 *merr = NULL;
1802 }
1803 else
1804 merr = NULL;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001805
1806 /* Look for pattern in the reference. */
1807 list_for_each_entry(elt, &ref->head, list) {
1808 if (strcmp(key, elt->pattern) == 0) {
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001809 if (!pat_ref_set_elt(ref, elt, value, merr)) {
William Lallemand579fb252018-06-11 10:53:46 +02001810 if (err && merr) {
1811 if (!found) {
1812 *err = *merr;
1813 } else {
1814 memprintf(err, "%s, %s", *err, *merr);
1815 free(*merr);
1816 *merr = NULL;
1817 }
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001818 }
1819 }
1820 found = 1;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001821 }
1822 }
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001823
1824 if (!found) {
1825 memprintf(err, "entry not found");
1826 return 0;
1827 }
1828 return 1;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001829}
1830
Joseph Herlant4189d672018-11-15 10:22:31 -08001831/* This function creates a new reference. <ref> is the reference name.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001832 * <flags> are PAT_REF_*. /!\ The reference is not checked, and must
1833 * be unique. The user must check the reference with "pat_ref_lookup()"
Joseph Herlant4189d672018-11-15 10:22:31 -08001834 * before calling this function. If the function fail, it return NULL,
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001835 * else return new struct pat_ref.
1836 */
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001837struct pat_ref *pat_ref_new(const char *reference, const char *display, unsigned int flags)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001838{
1839 struct pat_ref *ref;
1840
1841 ref = malloc(sizeof(*ref));
1842 if (!ref)
1843 return NULL;
1844
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001845 if (display) {
1846 ref->display = strdup(display);
1847 if (!ref->display) {
1848 free(ref);
1849 return NULL;
1850 }
1851 }
1852 else
1853 ref->display = NULL;
1854
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001855 ref->reference = strdup(reference);
1856 if (!ref->reference) {
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001857 free(ref->display);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001858 free(ref);
1859 return NULL;
1860 }
1861
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001862 ref->flags = flags;
1863 ref->unique_id = -1;
1864
1865 LIST_INIT(&ref->head);
1866 LIST_INIT(&ref->pat);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001867 HA_SPIN_INIT(&ref->lock);
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001868 LIST_ADDQ(&pattern_reference, &ref->list);
1869
1870 return ref;
1871}
1872
1873/* This function create new reference. <unique_id> is the unique id. If
1874 * the value of <unique_id> is -1, the unique id is calculated later.
1875 * <flags> are PAT_REF_*. /!\ The reference is not checked, and must
1876 * be unique. The user must check the reference with "pat_ref_lookup()"
1877 * or pat_ref_lookupid before calling this function. If the function
1878 * fail, it return NULL, else return new struct pat_ref.
1879 */
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001880struct pat_ref *pat_ref_newid(int unique_id, const char *display, unsigned int flags)
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001881{
1882 struct pat_ref *ref;
1883
1884 ref = malloc(sizeof(*ref));
1885 if (!ref)
1886 return NULL;
1887
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001888 if (display) {
1889 ref->display = strdup(display);
1890 if (!ref->display) {
1891 free(ref);
1892 return NULL;
1893 }
1894 }
1895 else
1896 ref->display = NULL;
1897
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001898 ref->reference = NULL;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001899 ref->flags = flags;
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001900 ref->unique_id = unique_id;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001901 LIST_INIT(&ref->head);
1902 LIST_INIT(&ref->pat);
Aurélien Nephtali564d15a2018-04-19 16:56:07 +02001903 HA_SPIN_INIT(&ref->lock);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001904 LIST_ADDQ(&pattern_reference, &ref->list);
1905
1906 return ref;
1907}
1908
1909/* This function adds entry to <ref>. It can failed with memory error.
1910 * If the function fails, it returns 0.
1911 */
1912int pat_ref_append(struct pat_ref *ref, char *pattern, char *sample, int line)
1913{
1914 struct pat_ref_elt *elt;
1915
1916 elt = malloc(sizeof(*elt));
1917 if (!elt)
1918 return 0;
1919
1920 elt->line = line;
1921
1922 elt->pattern = strdup(pattern);
1923 if (!elt->pattern) {
1924 free(elt);
1925 return 0;
1926 }
1927
1928 if (sample) {
1929 elt->sample = strdup(sample);
1930 if (!elt->sample) {
1931 free(elt->pattern);
1932 free(elt);
1933 return 0;
1934 }
1935 }
1936 else
1937 elt->sample = NULL;
1938
Emeric Brun8d85aa42017-06-29 15:40:33 +02001939 LIST_INIT(&elt->back_refs);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001940 LIST_ADDQ(&ref->head, &elt->list);
1941
1942 return 1;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001943}
1944
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001945/* This function create sample found in <elt>, parse the pattern also
1946 * found in <elt> and insert it in <expr>. The function copy <patflags>
1947 * in <expr>. If the function fails, it returns0 and <err> is filled.
1948 * In succes case, the function returns 1.
1949 */
1950static inline
1951int pat_ref_push(struct pat_ref_elt *elt, struct pattern_expr *expr,
1952 int patflags, char **err)
1953{
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001954 struct sample_data *data;
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001955 struct pattern pattern;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001956
1957 /* Create sample */
1958 if (elt->sample && expr->pat_head->parse_smp) {
1959 /* New sample. */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001960 data = malloc(sizeof(*data));
1961 if (!data)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001962 return 0;
1963
1964 /* Parse value. */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001965 if (!expr->pat_head->parse_smp(elt->sample, data)) {
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001966 memprintf(err, "unable to parse '%s'", elt->sample);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001967 free(data);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001968 return 0;
1969 }
1970
1971 }
1972 else
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001973 data = NULL;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001974
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001975 /* initialise pattern */
1976 memset(&pattern, 0, sizeof(pattern));
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001977 pattern.data = data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001978 pattern.ref = elt;
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001979
1980 /* parse pattern */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001981 if (!expr->pat_head->parse(elt->pattern, &pattern, expr->mflags, err)) {
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001982 free(data);
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001983 return 0;
1984 }
1985
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001986 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001987 /* index pattern */
1988 if (!expr->pat_head->index(expr, &pattern, err)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001989 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001990 free(data);
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001991 return 0;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001992 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001993 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001994
1995 return 1;
1996}
1997
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001998/* This function adds entry to <ref>. It can failed with memory error. The new
1999 * entry is added at all the pattern_expr registered in this reference. The
2000 * function stop on the first error encountered. It returns 0 and err is
2001 * filled. If an error is encountered, the complete add operation is cancelled.
2002 * If the insertion is a success the function returns 1.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002003 */
2004int pat_ref_add(struct pat_ref *ref,
2005 const char *pattern, const char *sample,
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02002006 char **err)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002007{
2008 struct pat_ref_elt *elt;
2009 struct pattern_expr *expr;
2010
2011 elt = malloc(sizeof(*elt));
2012 if (!elt) {
2013 memprintf(err, "out of memory error");
2014 return 0;
2015 }
2016
2017 elt->line = -1;
2018
2019 elt->pattern = strdup(pattern);
2020 if (!elt->pattern) {
2021 free(elt);
2022 memprintf(err, "out of memory error");
2023 return 0;
2024 }
2025
2026 if (sample) {
2027 elt->sample = strdup(sample);
2028 if (!elt->sample) {
2029 free(elt->pattern);
2030 free(elt);
2031 memprintf(err, "out of memory error");
2032 return 0;
2033 }
2034 }
2035 else
2036 elt->sample = NULL;
2037
Emeric Brun8d85aa42017-06-29 15:40:33 +02002038 LIST_INIT(&elt->back_refs);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002039 LIST_ADDQ(&ref->head, &elt->list);
2040
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002041 list_for_each_entry(expr, &ref->pat, list) {
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02002042 if (!pat_ref_push(elt, expr, 0, err)) {
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01002043 /* If the insertion fails, try to delete all the added entries. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01002044 pat_ref_delete_by_id(ref, elt);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002045 return 0;
2046 }
2047 }
Emeric Brunb5997f72017-07-03 11:34:05 +02002048
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002049 return 1;
2050}
2051
Joseph Herlant4189d672018-11-15 10:22:31 -08002052/* This function prunes <ref>, replaces all references by the references
2053 * of <replace>, and reindexes all the news values.
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002054 *
Joseph Herlant4189d672018-11-15 10:22:31 -08002055 * The patterns are loaded in best effort and the errors are ignored,
2056 * but written in the logs.
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002057 */
2058void pat_ref_reload(struct pat_ref *ref, struct pat_ref *replace)
2059{
2060 struct pattern_expr *expr;
Emeric Brunb5997f72017-07-03 11:34:05 +02002061 struct pat_ref_elt *elt, *safe;
2062 struct bref *bref, *back;
Emeric Brunb5997f72017-07-03 11:34:05 +02002063 struct pattern pattern;
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002064
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002065
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002066 HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
Emeric Brunb5997f72017-07-03 11:34:05 +02002067 list_for_each_entry(expr, &ref->pat, list) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002068 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
Emeric Brunb5997f72017-07-03 11:34:05 +02002069 }
2070
2071 /* all expr are locked, we can safely remove all pat_ref */
2072 list_for_each_entry_safe(elt, safe, &ref->head, list) {
2073 list_for_each_entry_safe(bref, back, &elt->back_refs, users) {
2074 /*
2075 * we have to unlink all watchers. We must not relink them if
2076 * this elt was the last one in the list.
2077 */
2078 LIST_DEL(&bref->users);
2079 LIST_INIT(&bref->users);
2080 if (elt->list.n != &ref->head)
Willy Tarreau49ee3b22019-04-30 11:43:43 +02002081 LIST_ADDQ(&LIST_ELEM(elt->list.n, typeof(elt), list)->back_refs, &bref->users);
Emeric Brunb5997f72017-07-03 11:34:05 +02002082 bref->ref = elt->list.n;
2083 }
2084 LIST_DEL(&elt->list);
2085 free(elt->pattern);
2086 free(elt->sample);
2087 free(elt);
2088 }
2089
2090 /* switch pat_ret_elt lists */
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002091 LIST_ADD(&replace->head, &ref->head);
2092 LIST_DEL(&replace->head);
2093
Emeric Brunb5997f72017-07-03 11:34:05 +02002094 list_for_each_entry(expr, &ref->pat, list) {
2095 expr->pat_head->prune(expr);
2096 list_for_each_entry(elt, &ref->head, list) {
Dragan Dosenf1474792018-09-18 20:18:09 +02002097 char *err = NULL;
2098 struct sample_data *data = NULL;
2099
Emeric Brunb5997f72017-07-03 11:34:05 +02002100 /* Create sample */
2101 if (elt->sample && expr->pat_head->parse_smp) {
2102 /* New sample. */
2103 data = malloc(sizeof(*data));
2104 if (!data)
2105 continue;
2106
2107 /* Parse value. */
2108 if (!expr->pat_head->parse_smp(elt->sample, data)) {
2109 memprintf(&err, "unable to parse '%s'", elt->sample);
2110 send_log(NULL, LOG_NOTICE, "%s", err);
2111 free(err);
2112 free(data);
2113 continue;
2114 }
2115
2116 }
Emeric Brunb5997f72017-07-03 11:34:05 +02002117
2118 /* initialise pattern */
2119 memset(&pattern, 0, sizeof(pattern));
2120 pattern.data = data;
2121 pattern.ref = elt;
2122
2123 /* parse pattern */
2124 if (!expr->pat_head->parse(elt->pattern, &pattern, expr->mflags, &err)) {
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002125 send_log(NULL, LOG_NOTICE, "%s", err);
2126 free(err);
Emeric Brunb5997f72017-07-03 11:34:05 +02002127 free(data);
2128 continue;
2129 }
2130
2131 /* index pattern */
2132 if (!expr->pat_head->index(expr, &pattern, &err)) {
2133 send_log(NULL, LOG_NOTICE, "%s", err);
2134 free(err);
2135 free(data);
2136 continue;
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002137 }
2138 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002139 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002140 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002141 HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002142}
2143
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002144/* This function prune all entries of <ref>. This function
2145 * prune the associated pattern_expr.
2146 */
2147void pat_ref_prune(struct pat_ref *ref)
2148{
2149 struct pat_ref_elt *elt, *safe;
2150 struct pattern_expr *expr;
Emeric Brun8d85aa42017-06-29 15:40:33 +02002151 struct bref *bref, *back;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002152
Emeric Brunb5997f72017-07-03 11:34:05 +02002153 list_for_each_entry(expr, &ref->pat, list) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002154 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
Emeric Brunb5997f72017-07-03 11:34:05 +02002155 expr->pat_head->prune(expr);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002156 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Emeric Brunb5997f72017-07-03 11:34:05 +02002157 }
2158
2159 /* we trash pat_ref_elt in a second time to ensure that data is
2160 free once there is no ref on it */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002161 list_for_each_entry_safe(elt, safe, &ref->head, list) {
Emeric Brun8d85aa42017-06-29 15:40:33 +02002162 list_for_each_entry_safe(bref, back, &elt->back_refs, users) {
2163 /*
2164 * we have to unlink all watchers. We must not relink them if
2165 * this elt was the last one in the list.
2166 */
2167 LIST_DEL(&bref->users);
2168 LIST_INIT(&bref->users);
2169 if (elt->list.n != &ref->head)
Willy Tarreau49ee3b22019-04-30 11:43:43 +02002170 LIST_ADDQ(&LIST_ELEM(elt->list.n, typeof(elt), list)->back_refs, &bref->users);
Emeric Brun8d85aa42017-06-29 15:40:33 +02002171 bref->ref = elt->list.n;
2172 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002173 LIST_DEL(&elt->list);
2174 free(elt->pattern);
2175 free(elt->sample);
2176 free(elt);
2177 }
2178
Emeric Brunb5997f72017-07-03 11:34:05 +02002179
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002180}
2181
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002182/* This function lookup for existing reference <ref> in pattern_head <head>. */
2183struct pattern_expr *pattern_lookup_expr(struct pattern_head *head, struct pat_ref *ref)
2184{
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002185 struct pattern_expr_list *expr;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002186
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002187 list_for_each_entry(expr, &head->head, list)
2188 if (expr->expr->ref == ref)
2189 return expr->expr;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002190 return NULL;
2191}
2192
Joseph Herlant4189d672018-11-15 10:22:31 -08002193/* This function creates new pattern_expr associated to the reference <ref>.
2194 * <ref> can be NULL. If an error occurs, the function returns NULL and
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002195 * <err> is filled. Otherwise, the function returns new pattern_expr linked
2196 * with <head> and <ref>.
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002197 *
Joseph Herlant4189d672018-11-15 10:22:31 -08002198 * The returned value can be an already filled pattern list, in this case the
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002199 * flag <reuse> is set.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002200 */
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002201struct pattern_expr *pattern_new_expr(struct pattern_head *head, struct pat_ref *ref,
Emeric Brun7d27f3c2017-07-03 17:54:23 +02002202 int patflags, char **err, int *reuse)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002203{
2204 struct pattern_expr *expr;
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002205 struct pattern_expr_list *list;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002206
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002207 if (reuse)
2208 *reuse = 0;
2209
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002210 /* Memory and initialization of the chain element. */
2211 list = malloc(sizeof(*list));
2212 if (!list) {
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002213 memprintf(err, "out of memory");
2214 return NULL;
2215 }
2216
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002217 /* Look for existing similar expr. No that only the index, parse and
2218 * parse_smp function must be identical for having similar pattern.
Joseph Herlant4189d672018-11-15 10:22:31 -08002219 * The other function depends of these first.
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002220 */
2221 if (ref) {
2222 list_for_each_entry(expr, &ref->pat, list)
2223 if (expr->pat_head->index == head->index &&
2224 expr->pat_head->parse == head->parse &&
Emeric Brun7d27f3c2017-07-03 17:54:23 +02002225 expr->pat_head->parse_smp == head->parse_smp &&
2226 expr->mflags == patflags)
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002227 break;
2228 if (&expr->list == &ref->pat)
2229 expr = NULL;
2230 }
2231 else
2232 expr = NULL;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002233
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002234 /* If no similar expr was found, we create new expr. */
2235 if (!expr) {
2236 /* Get a lot of memory for the expr struct. */
2237 expr = malloc(sizeof(*expr));
2238 if (!expr) {
Andreas Seltenreiche6e22e82016-03-03 20:20:23 +01002239 free(list);
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002240 memprintf(err, "out of memory");
2241 return NULL;
2242 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002243
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002244 /* Initialize this new expr. */
2245 pattern_init_expr(expr);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002246
Emeric Brun7d27f3c2017-07-03 17:54:23 +02002247 /* Copy the pattern matching and indexing flags. */
2248 expr->mflags = patflags;
2249
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002250 /* This new pattern expression reference one of his heads. */
2251 expr->pat_head = head;
2252
2253 /* Link with ref, or to self to facilitate LIST_DEL() */
2254 if (ref)
2255 LIST_ADDQ(&ref->pat, &expr->list);
2256 else
2257 LIST_INIT(&expr->list);
2258
2259 expr->ref = ref;
2260
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002261 HA_RWLOCK_INIT(&expr->lock);
Emeric Brunb5997f72017-07-03 11:34:05 +02002262
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002263 /* We must free this pattern if it is no more used. */
2264 list->do_free = 1;
2265 }
2266 else {
2267 /* If the pattern used already exists, it is already linked
2268 * with ref and we must not free it.
2269 */
2270 list->do_free = 0;
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002271 if (reuse)
2272 *reuse = 1;
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002273 }
2274
2275 /* The new list element reference the pattern_expr. */
2276 list->expr = expr;
2277
2278 /* Link the list element with the pattern_head. */
2279 LIST_ADDQ(&head->head, &list->list);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002280 return expr;
2281}
2282
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002283/* Reads patterns from a file. If <err_msg> is non-NULL, an error message will
2284 * be returned there on errors and the caller will have to free it.
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002285 *
2286 * The file contains one key + value per line. Lines which start with '#' are
2287 * ignored, just like empty lines. Leading tabs/spaces are stripped. The key is
2288 * then the first "word" (series of non-space/tabs characters), and the value is
2289 * what follows this series of space/tab till the end of the line excluding
2290 * trailing spaces/tabs.
2291 *
2292 * Example :
2293 *
2294 * # this is a comment and is ignored
2295 * 62.212.114.60 1wt.eu \n
2296 * <-><-----------><---><----><---->
2297 * | | | | `--- trailing spaces ignored
2298 * | | | `-------- value
2299 * | | `--------------- middle spaces ignored
2300 * | `------------------------ key
2301 * `-------------------------------- leading spaces ignored
2302 *
2303 * Return non-zero in case of succes, otherwise 0.
2304 */
2305int pat_ref_read_from_file_smp(struct pat_ref *ref, const char *filename, char **err)
2306{
2307 FILE *file;
2308 char *c;
2309 int ret = 0;
2310 int line = 0;
2311 char *key_beg;
2312 char *key_end;
2313 char *value_beg;
2314 char *value_end;
2315
2316 file = fopen(filename, "r");
2317 if (!file) {
2318 memprintf(err, "failed to open pattern file <%s>", filename);
2319 return 0;
2320 }
2321
2322 /* now parse all patterns. The file may contain only one pattern
2323 * followed by one value per line. The start spaces, separator spaces
2324 * and and spaces are stripped. Each can contain comment started by '#'
2325 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002326 while (fgets(trash.area, trash.size, file) != NULL) {
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002327 line++;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002328 c = trash.area;
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002329
2330 /* ignore lines beginning with a dash */
2331 if (*c == '#')
2332 continue;
2333
2334 /* strip leading spaces and tabs */
2335 while (*c == ' ' || *c == '\t')
2336 c++;
2337
2338 /* empty lines are ignored too */
2339 if (*c == '\0' || *c == '\r' || *c == '\n')
2340 continue;
2341
2342 /* look for the end of the key */
2343 key_beg = c;
2344 while (*c && *c != ' ' && *c != '\t' && *c != '\n' && *c != '\r')
2345 c++;
2346
2347 key_end = c;
2348
2349 /* strip middle spaces and tabs */
2350 while (*c == ' ' || *c == '\t')
2351 c++;
2352
2353 /* look for the end of the value, it is the end of the line */
2354 value_beg = c;
2355 while (*c && *c != '\n' && *c != '\r')
2356 c++;
2357 value_end = c;
2358
2359 /* trim possibly trailing spaces and tabs */
2360 while (value_end > value_beg && (value_end[-1] == ' ' || value_end[-1] == '\t'))
2361 value_end--;
2362
2363 /* set final \0 and check entries */
2364 *key_end = '\0';
2365 *value_end = '\0';
2366
2367 /* insert values */
2368 if (!pat_ref_append(ref, key_beg, value_beg, line)) {
2369 memprintf(err, "out of memory");
2370 goto out_close;
2371 }
2372 }
2373
2374 /* succes */
2375 ret = 1;
2376
2377 out_close:
2378 fclose(file);
2379 return ret;
2380}
2381
2382/* Reads patterns from a file. If <err_msg> is non-NULL, an error message will
2383 * be returned there on errors and the caller will have to free it.
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002384 */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002385int pat_ref_read_from_file(struct pat_ref *ref, const char *filename, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002386{
2387 FILE *file;
2388 char *c;
2389 char *arg;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002390 int ret = 0;
2391 int line = 0;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002392
2393 file = fopen(filename, "r");
2394 if (!file) {
2395 memprintf(err, "failed to open pattern file <%s>", filename);
2396 return 0;
2397 }
2398
2399 /* now parse all patterns. The file may contain only one pattern per
2400 * line. If the line contains spaces, they will be part of the pattern.
2401 * The pattern stops at the first CR, LF or EOF encountered.
2402 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002403 while (fgets(trash.area, trash.size, file) != NULL) {
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002404 line++;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002405 c = trash.area;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002406
2407 /* ignore lines beginning with a dash */
2408 if (*c == '#')
2409 continue;
2410
2411 /* strip leading spaces and tabs */
2412 while (*c == ' ' || *c == '\t')
2413 c++;
2414
2415
2416 arg = c;
2417 while (*c && *c != '\n' && *c != '\r')
2418 c++;
2419 *c = 0;
2420
2421 /* empty lines are ignored too */
2422 if (c == arg)
2423 continue;
2424
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002425 if (!pat_ref_append(ref, arg, NULL, line)) {
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002426 memprintf(err, "out of memory when loading patterns from file <%s>", filename);
2427 goto out_close;
2428 }
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002429 }
2430
2431 ret = 1; /* success */
2432
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002433 out_close:
2434 fclose(file);
2435 return ret;
2436}
2437
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002438int pattern_read_from_file(struct pattern_head *head, unsigned int refflags,
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002439 const char *filename, int patflags, int load_smp,
Thierry FOURNIER94580c92014-02-11 14:36:45 +01002440 char **err, const char *file, int line)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002441{
2442 struct pat_ref *ref;
2443 struct pattern_expr *expr;
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002444 struct pat_ref_elt *elt;
Willy Tarreau4deaf392014-11-26 13:17:03 +01002445 int reuse = 0;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002446
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002447 /* Lookup for the existing reference. */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002448 ref = pat_ref_lookup(filename);
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002449
2450 /* If the reference doesn't exists, create it and load associated file. */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002451 if (!ref) {
Thierry FOURNIER94580c92014-02-11 14:36:45 +01002452 chunk_printf(&trash,
2453 "pattern loaded from file '%s' used by %s at file '%s' line %d",
2454 filename, refflags & PAT_REF_MAP ? "map" : "acl", file, line);
2455
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002456 ref = pat_ref_new(filename, trash.area, refflags);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002457 if (!ref) {
2458 memprintf(err, "out of memory");
2459 return 0;
2460 }
2461
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002462 if (load_smp) {
Thierry FOURNIERc0bd9102014-01-29 12:32:58 +01002463 ref->flags |= PAT_REF_SMP;
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002464 if (!pat_ref_read_from_file_smp(ref, filename, err))
2465 return 0;
2466 }
2467 else {
2468 if (!pat_ref_read_from_file(ref, filename, err))
2469 return 0;
2470 }
2471 }
2472 else {
Thierry FOURNIERc0bd9102014-01-29 12:32:58 +01002473 /* The reference already exists, check the map compatibility. */
2474
2475 /* If the load require samples and the flag PAT_REF_SMP is not set,
2476 * the reference doesn't contain sample, and cannot be used.
2477 */
2478 if (load_smp) {
2479 if (!(ref->flags & PAT_REF_SMP)) {
2480 memprintf(err, "The file \"%s\" is already used as one column file "
2481 "and cannot be used by as two column file.",
2482 filename);
2483 return 0;
2484 }
2485 }
2486 else {
2487 /* The load doesn't require samples. If the flag PAT_REF_SMP is
2488 * set, the reference contains a sample, and cannot be used.
2489 */
2490 if (ref->flags & PAT_REF_SMP) {
2491 memprintf(err, "The file \"%s\" is already used as two column file "
2492 "and cannot be used by as one column file.",
2493 filename);
2494 return 0;
2495 }
2496 }
2497
Thierry FOURNIER94580c92014-02-11 14:36:45 +01002498 /* Extends display */
2499 chunk_printf(&trash, "%s", ref->display);
2500 chunk_appendf(&trash, ", by %s at file '%s' line %d",
2501 refflags & PAT_REF_MAP ? "map" : "acl", file, line);
2502 free(ref->display);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002503 ref->display = strdup(trash.area);
Thierry FOURNIER94580c92014-02-11 14:36:45 +01002504 if (!ref->display) {
2505 memprintf(err, "out of memory");
2506 return 0;
2507 }
2508
Thierry FOURNIERc0bd9102014-01-29 12:32:58 +01002509 /* Merge flags. */
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002510 ref->flags |= refflags;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002511 }
2512
2513 /* Now, we can loading patterns from the reference. */
2514
2515 /* Lookup for existing reference in the head. If the reference
2516 * doesn't exists, create it.
2517 */
2518 expr = pattern_lookup_expr(head, ref);
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02002519 if (!expr || (expr->mflags != patflags)) {
Emeric Brun7d27f3c2017-07-03 17:54:23 +02002520 expr = pattern_new_expr(head, ref, patflags, err, &reuse);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002521 if (!expr)
2522 return 0;
2523 }
2524
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002525 /* The returned expression may be not empty, because the function
2526 * "pattern_new_expr" lookup for similar pattern list and can
2527 * reuse a already filled pattern list. In this case, we can not
2528 * reload the patterns.
2529 */
2530 if (reuse)
2531 return 1;
2532
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002533 /* Load reference content in the pattern expression. */
2534 list_for_each_entry(elt, &ref->head, list) {
2535 if (!pat_ref_push(elt, expr, patflags, err)) {
2536 if (elt->line > 0)
2537 memprintf(err, "%s at line %d of file '%s'",
2538 *err, elt->line, filename);
2539 return 0;
2540 }
2541 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002542
2543 return 1;
2544}
2545
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +01002546/* This function executes a pattern match on a sample. It applies pattern <expr>
2547 * to sample <smp>. The function returns NULL if the sample dont match. It returns
2548 * non-null if the sample match. If <fill> is true and the sample match, the
2549 * function returns the matched pattern. In many cases, this pattern can be a
2550 * static buffer.
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002551 */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002552struct pattern *pattern_exec_match(struct pattern_head *head, struct sample *smp, int fill)
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002553{
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002554 struct pattern_expr_list *list;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002555 struct pattern *pat;
2556
2557 if (!head->match) {
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +01002558 if (fill) {
Thierry FOURNIER503bb092015-08-19 08:35:43 +02002559 static_pattern.data = NULL;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01002560 static_pattern.ref = NULL;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02002561 static_pattern.sflags = 0;
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002562 static_pattern.type = SMP_T_SINT;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01002563 static_pattern.val.i = 1;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +01002564 }
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +01002565 return &static_pattern;
2566 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002567
Thierry FOURNIER5d344082014-01-27 14:19:53 +01002568 /* convert input to string */
2569 if (!sample_convert(smp, head->expect_type))
2570 return NULL;
2571
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002572 list_for_each_entry(list, &head->head, list) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002573 HA_RWLOCK_RDLOCK(PATEXP_LOCK, &list->expr->lock);
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002574 pat = head->match(smp, list->expr, fill);
Emeric Brunb5997f72017-07-03 11:34:05 +02002575 if (pat) {
2576 /* We duplicate the pattern cause it could be modified
2577 by another thread */
2578 if (pat != &static_pattern) {
2579 memcpy(&static_pattern, pat, sizeof(struct pattern));
2580 pat = &static_pattern;
2581 }
2582
2583 /* We also duplicate the sample data for
2584 same reason */
2585 if (pat->data && (pat->data != &static_sample_data)) {
Christopher Faulet09fdf4b2017-11-09 16:14:16 +01002586 switch(pat->data->type) {
Emeric Brunb5997f72017-07-03 11:34:05 +02002587 case SMP_T_STR:
2588 static_sample_data.type = SMP_T_STR;
2589 static_sample_data.u.str = *get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002590 static_sample_data.u.str.data = pat->data->u.str.data;
2591 if (static_sample_data.u.str.data >= static_sample_data.u.str.size)
2592 static_sample_data.u.str.data = static_sample_data.u.str.size - 1;
2593 memcpy(static_sample_data.u.str.area,
2594 pat->data->u.str.area,
2595 static_sample_data.u.str.data);
2596 static_sample_data.u.str.area[static_sample_data.u.str.data] = 0;
Emeric Brunb5997f72017-07-03 11:34:05 +02002597 case SMP_T_IPV4:
2598 case SMP_T_IPV6:
2599 case SMP_T_SINT:
2600 memcpy(&static_sample_data, pat->data, sizeof(struct sample_data));
2601 default:
2602 pat->data = NULL;
2603 }
2604 pat->data = &static_sample_data;
2605 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002606 HA_RWLOCK_RDUNLOCK(PATEXP_LOCK, &list->expr->lock);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002607 return pat;
Emeric Brunb5997f72017-07-03 11:34:05 +02002608 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002609 HA_RWLOCK_RDUNLOCK(PATEXP_LOCK, &list->expr->lock);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002610 }
2611 return NULL;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002612}
2613
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01002614/* This function prune the pattern expression. */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002615void pattern_prune(struct pattern_head *head)
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01002616{
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002617 struct pattern_expr_list *list, *safe;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002618
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002619 list_for_each_entry_safe(list, safe, &head->head, list) {
2620 LIST_DEL(&list->list);
2621 if (list->do_free) {
2622 LIST_DEL(&list->expr->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002623 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &list->expr->lock);
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002624 head->prune(list->expr);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002625 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &list->expr->lock);
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002626 free(list->expr);
2627 }
2628 free(list);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002629 }
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01002630}
2631
Thierry FOURNIER55d0b102014-01-15 11:25:26 +01002632/* This function lookup for a pattern matching the <key> and return a
2633 * pointer to a pointer of the sample stoarge. If the <key> dont match,
2634 * the function returns NULL. If the key cannot be parsed, the function
2635 * fill <err>.
2636 */
Thierry FOURNIER12ba0c22015-08-14 00:02:11 +02002637struct sample_data **pattern_find_smp(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIER55d0b102014-01-15 11:25:26 +01002638{
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002639 struct ebmb_node *node;
2640 struct pattern_tree *elt;
2641 struct pattern_list *pat;
Thierry FOURNIER55d0b102014-01-15 11:25:26 +01002642
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002643 for (node = ebmb_first(&expr->pattern_tree);
2644 node;
2645 node = ebmb_next(node)) {
2646 elt = container_of(node, struct pattern_tree, node);
2647 if (elt->ref == ref)
Thierry FOURNIER503bb092015-08-19 08:35:43 +02002648 return &elt->data;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002649 }
2650
2651 for (node = ebmb_first(&expr->pattern_tree_2);
2652 node;
2653 node = ebmb_next(node)) {
2654 elt = container_of(node, struct pattern_tree, node);
2655 if (elt->ref == ref)
Thierry FOURNIER503bb092015-08-19 08:35:43 +02002656 return &elt->data;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002657 }
2658
2659 list_for_each_entry(pat, &expr->patterns, list)
2660 if (pat->pat.ref == ref)
Thierry FOURNIER503bb092015-08-19 08:35:43 +02002661 return &pat->pat.data;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002662
2663 return NULL;
Thierry FOURNIER55d0b102014-01-15 11:25:26 +01002664}
2665
Thierry FOURNIERb1136502014-01-15 11:38:49 +01002666/* This function search all the pattern matching the <key> and delete it.
2667 * If the parsing of the input key fails, the function returns 0 and the
2668 * <err> is filled, else return 1;
2669 */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01002670int pattern_delete(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01002671{
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002672 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01002673 expr->pat_head->delete(expr, ref);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002674 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01002675 return 1;
2676}
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002677
2678/* This function finalize the configuration parsing. Its set all the
2679 * automatic ids
2680 */
2681void pattern_finalize_config(void)
2682{
2683 int i = 0;
2684 struct pat_ref *ref, *ref2, *ref3;
2685 struct list pr = LIST_HEAD_INIT(pr);
2686
Willy Tarreauf3045d22015-04-29 16:24:50 +02002687 pat_lru_seed = random();
Emeric Brunb5997f72017-07-03 11:34:05 +02002688 if (global.tune.pattern_cache) {
Willy Tarreauf3045d22015-04-29 16:24:50 +02002689 pat_lru_tree = lru64_new(global.tune.pattern_cache);
Emeric Brunb5997f72017-07-03 11:34:05 +02002690 }
Willy Tarreauf3045d22015-04-29 16:24:50 +02002691
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002692 list_for_each_entry(ref, &pattern_reference, list) {
2693 if (ref->unique_id == -1) {
2694 /* Look for the first free id. */
2695 while (1) {
2696 list_for_each_entry(ref2, &pattern_reference, list) {
2697 if (ref2->unique_id == i) {
2698 i++;
2699 break;
2700 }
2701 }
Willy Tarreau3b786962014-04-26 12:37:25 +02002702 if (&ref2->list == &pattern_reference)
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002703 break;
2704 }
2705
2706 /* Uses the unique id and increment it for the next entry. */
2707 ref->unique_id = i;
2708 i++;
2709 }
2710 }
2711
2712 /* This sort the reference list by id. */
2713 list_for_each_entry_safe(ref, ref2, &pattern_reference, list) {
2714 LIST_DEL(&ref->list);
2715 list_for_each_entry(ref3, &pr, list) {
2716 if (ref->unique_id < ref3->unique_id) {
2717 LIST_ADDQ(&ref3->list, &ref->list);
2718 break;
2719 }
2720 }
2721 if (&ref3->list == &pr)
2722 LIST_ADDQ(&pr, &ref->list);
2723 }
2724
2725 /* swap root */
2726 LIST_ADD(&pr, &pattern_reference);
2727 LIST_DEL(&pr);
2728}