blob: fbb5ae671087fdf036d54fce55a86cf947c8661a [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>
Jerome Magninb8bd6d72020-01-17 18:01:20 +010015#include <errno.h>
Thierry FOURNIERed66c292013-11-28 11:05:19 +010016
Willy Tarreaub2551052020-06-09 09:07:15 +020017#include <import/ebsttree.h>
18#include <import/lru.h>
19#include <import/xxhash.h>
20
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020021#include <haproxy/api.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020022#include <haproxy/global.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020023#include <haproxy/log.h>
Willy Tarreau6131d6a2020-06-02 16:48:09 +020024#include <haproxy/net_helper.h>
Willy Tarreau225a90a2020-06-04 15:06:28 +020025#include <haproxy/pattern.h>
Willy Tarreau7cd8b6e2020-06-02 17:32:26 +020026#include <haproxy/regex.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020027#include <haproxy/sample.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020028#include <haproxy/tools.h>
Thierry FOURNIERed66c292013-11-28 11:05:19 +010029
Thierry FOURNIERed66c292013-11-28 11:05:19 +010030
Thierry FOURNIERa65b3432013-11-28 18:22:00 +010031char *pat_match_names[PAT_MATCH_NUM] = {
32 [PAT_MATCH_FOUND] = "found",
33 [PAT_MATCH_BOOL] = "bool",
34 [PAT_MATCH_INT] = "int",
35 [PAT_MATCH_IP] = "ip",
36 [PAT_MATCH_BIN] = "bin",
37 [PAT_MATCH_LEN] = "len",
38 [PAT_MATCH_STR] = "str",
39 [PAT_MATCH_BEG] = "beg",
40 [PAT_MATCH_SUB] = "sub",
41 [PAT_MATCH_DIR] = "dir",
42 [PAT_MATCH_DOM] = "dom",
43 [PAT_MATCH_END] = "end",
44 [PAT_MATCH_REG] = "reg",
Thierry Fournier8feaa662016-02-10 22:55:20 +010045 [PAT_MATCH_REGM] = "regm",
Thierry FOURNIERed66c292013-11-28 11:05:19 +010046};
47
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +020048int (*pat_parse_fcts[PAT_MATCH_NUM])(const char *, struct pattern *, int, char **) = {
Thierry FOURNIERa65b3432013-11-28 18:22:00 +010049 [PAT_MATCH_FOUND] = pat_parse_nothing,
50 [PAT_MATCH_BOOL] = pat_parse_nothing,
51 [PAT_MATCH_INT] = pat_parse_int,
52 [PAT_MATCH_IP] = pat_parse_ip,
53 [PAT_MATCH_BIN] = pat_parse_bin,
Thierry FOURNIER5d344082014-01-27 14:19:53 +010054 [PAT_MATCH_LEN] = pat_parse_int,
Thierry FOURNIERa65b3432013-11-28 18:22:00 +010055 [PAT_MATCH_STR] = pat_parse_str,
56 [PAT_MATCH_BEG] = pat_parse_str,
57 [PAT_MATCH_SUB] = pat_parse_str,
58 [PAT_MATCH_DIR] = pat_parse_str,
59 [PAT_MATCH_DOM] = pat_parse_str,
60 [PAT_MATCH_END] = pat_parse_str,
61 [PAT_MATCH_REG] = pat_parse_reg,
Thierry Fournier8feaa662016-02-10 22:55:20 +010062 [PAT_MATCH_REGM] = pat_parse_reg,
Thierry FOURNIERed66c292013-11-28 11:05:19 +010063};
64
Thierry FOURNIERb9b08462013-12-13 15:12:32 +010065int (*pat_index_fcts[PAT_MATCH_NUM])(struct pattern_expr *, struct pattern *, char **) = {
66 [PAT_MATCH_FOUND] = pat_idx_list_val,
67 [PAT_MATCH_BOOL] = pat_idx_list_val,
68 [PAT_MATCH_INT] = pat_idx_list_val,
69 [PAT_MATCH_IP] = pat_idx_tree_ip,
70 [PAT_MATCH_BIN] = pat_idx_list_ptr,
71 [PAT_MATCH_LEN] = pat_idx_list_val,
72 [PAT_MATCH_STR] = pat_idx_tree_str,
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +020073 [PAT_MATCH_BEG] = pat_idx_tree_pfx,
Thierry FOURNIERb9b08462013-12-13 15:12:32 +010074 [PAT_MATCH_SUB] = pat_idx_list_str,
75 [PAT_MATCH_DIR] = pat_idx_list_str,
76 [PAT_MATCH_DOM] = pat_idx_list_str,
77 [PAT_MATCH_END] = pat_idx_list_str,
78 [PAT_MATCH_REG] = pat_idx_list_reg,
Thierry Fournier8feaa662016-02-10 22:55:20 +010079 [PAT_MATCH_REGM] = pat_idx_list_regm,
Thierry FOURNIERb9b08462013-12-13 15:12:32 +010080};
81
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +010082void (*pat_delete_fcts[PAT_MATCH_NUM])(struct pattern_expr *, struct pat_ref_elt *) = {
Thierry FOURNIERb1136502014-01-15 11:38:49 +010083 [PAT_MATCH_FOUND] = pat_del_list_val,
84 [PAT_MATCH_BOOL] = pat_del_list_val,
85 [PAT_MATCH_INT] = pat_del_list_val,
86 [PAT_MATCH_IP] = pat_del_tree_ip,
87 [PAT_MATCH_BIN] = pat_del_list_ptr,
88 [PAT_MATCH_LEN] = pat_del_list_val,
89 [PAT_MATCH_STR] = pat_del_tree_str,
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +020090 [PAT_MATCH_BEG] = pat_del_tree_str,
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +010091 [PAT_MATCH_SUB] = pat_del_list_ptr,
92 [PAT_MATCH_DIR] = pat_del_list_ptr,
93 [PAT_MATCH_DOM] = pat_del_list_ptr,
94 [PAT_MATCH_END] = pat_del_list_ptr,
Thierry FOURNIERb1136502014-01-15 11:38:49 +010095 [PAT_MATCH_REG] = pat_del_list_reg,
Thierry Fournier8feaa662016-02-10 22:55:20 +010096 [PAT_MATCH_REGM] = pat_del_list_reg,
Thierry FOURNIERb1136502014-01-15 11:38:49 +010097};
98
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +010099void (*pat_prune_fcts[PAT_MATCH_NUM])(struct pattern_expr *) = {
100 [PAT_MATCH_FOUND] = pat_prune_val,
101 [PAT_MATCH_BOOL] = pat_prune_val,
102 [PAT_MATCH_INT] = pat_prune_val,
103 [PAT_MATCH_IP] = pat_prune_val,
104 [PAT_MATCH_BIN] = pat_prune_ptr,
105 [PAT_MATCH_LEN] = pat_prune_val,
106 [PAT_MATCH_STR] = pat_prune_ptr,
107 [PAT_MATCH_BEG] = pat_prune_ptr,
108 [PAT_MATCH_SUB] = pat_prune_ptr,
109 [PAT_MATCH_DIR] = pat_prune_ptr,
110 [PAT_MATCH_DOM] = pat_prune_ptr,
111 [PAT_MATCH_END] = pat_prune_ptr,
112 [PAT_MATCH_REG] = pat_prune_reg,
Thierry Fournier8feaa662016-02-10 22:55:20 +0100113 [PAT_MATCH_REGM] = pat_prune_reg,
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +0100114};
115
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100116struct pattern *(*pat_match_fcts[PAT_MATCH_NUM])(struct sample *, struct pattern_expr *, int) = {
Thierry FOURNIERa65b3432013-11-28 18:22:00 +0100117 [PAT_MATCH_FOUND] = NULL,
118 [PAT_MATCH_BOOL] = pat_match_nothing,
119 [PAT_MATCH_INT] = pat_match_int,
120 [PAT_MATCH_IP] = pat_match_ip,
121 [PAT_MATCH_BIN] = pat_match_bin,
122 [PAT_MATCH_LEN] = pat_match_len,
123 [PAT_MATCH_STR] = pat_match_str,
124 [PAT_MATCH_BEG] = pat_match_beg,
125 [PAT_MATCH_SUB] = pat_match_sub,
126 [PAT_MATCH_DIR] = pat_match_dir,
127 [PAT_MATCH_DOM] = pat_match_dom,
128 [PAT_MATCH_END] = pat_match_end,
129 [PAT_MATCH_REG] = pat_match_reg,
Thierry Fournier8feaa662016-02-10 22:55:20 +0100130 [PAT_MATCH_REGM] = pat_match_regm,
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100131};
132
Thierry FOURNIERe3ded592013-12-06 15:36:54 +0100133/* Just used for checking configuration compatibility */
134int pat_match_types[PAT_MATCH_NUM] = {
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200135 [PAT_MATCH_FOUND] = SMP_T_SINT,
136 [PAT_MATCH_BOOL] = SMP_T_SINT,
137 [PAT_MATCH_INT] = SMP_T_SINT,
Thierry FOURNIERe3ded592013-12-06 15:36:54 +0100138 [PAT_MATCH_IP] = SMP_T_ADDR,
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100139 [PAT_MATCH_BIN] = SMP_T_BIN,
140 [PAT_MATCH_LEN] = SMP_T_STR,
141 [PAT_MATCH_STR] = SMP_T_STR,
142 [PAT_MATCH_BEG] = SMP_T_STR,
143 [PAT_MATCH_SUB] = SMP_T_STR,
144 [PAT_MATCH_DIR] = SMP_T_STR,
145 [PAT_MATCH_DOM] = SMP_T_STR,
146 [PAT_MATCH_END] = SMP_T_STR,
147 [PAT_MATCH_REG] = SMP_T_STR,
Thierry Fournier8feaa662016-02-10 22:55:20 +0100148 [PAT_MATCH_REGM] = SMP_T_STR,
Thierry FOURNIERe3ded592013-12-06 15:36:54 +0100149};
150
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100151/* this struct is used to return information */
Emeric Brunb5997f72017-07-03 11:34:05 +0200152static THREAD_LOCAL struct pattern static_pattern;
153static THREAD_LOCAL struct sample_data static_sample_data;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100154
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100155/* This is the root of the list of all pattern_ref avalaibles. */
156struct list pattern_reference = LIST_HEAD_INIT(pattern_reference);
157
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200158static THREAD_LOCAL struct lru64_head *pat_lru_tree;
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
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200490 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreauf3045d22015-04-29 16:24:50 +0200491 pat_lru_tree, expr, expr->revision);
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200492 if (lru && lru->domain) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200493 ret = lru->data;
Emeric Brunb5997f72017-07-03 11:34:05 +0200494 return ret;
495 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200496 }
497
Emeric Brunb5997f72017-07-03 11:34:05 +0200498
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100499 list_for_each_entry(lst, &expr->patterns, list) {
500 pattern = &lst->pat;
501
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200502 if (pattern->len != smp->data.u.str.data)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100503 continue;
504
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200505 icase = expr->mflags & PAT_MF_IGNORE_CASE;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200506 if ((icase && strncasecmp(pattern->ptr.str, smp->data.u.str.area, smp->data.u.str.data) == 0) ||
507 (!icase && strncmp(pattern->ptr.str, smp->data.u.str.area, smp->data.u.str.data) == 0)) {
Willy Tarreauf3045d22015-04-29 16:24:50 +0200508 ret = pattern;
509 break;
510 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100511 }
512
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200513 if (lru)
Emeric Brunb5997f72017-07-03 11:34:05 +0200514 lru64_commit(lru, ret, expr, expr->revision, NULL);
Willy Tarreauf3045d22015-04-29 16:24:50 +0200515
516 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100517}
518
519/* NB: For two binaries buf to be identical, it is required that their lengths match */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100520struct pattern *pat_match_bin(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100521{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100522 struct pattern_list *lst;
523 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200524 struct pattern *ret = NULL;
525 struct lru64 *lru = NULL;
526
527 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200528 unsigned long long seed = pat_lru_seed ^ (long)expr;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100529
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200530 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreauf3045d22015-04-29 16:24:50 +0200531 pat_lru_tree, expr, expr->revision);
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200532 if (lru && lru->domain) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200533 ret = lru->data;
Emeric Brunb5997f72017-07-03 11:34:05 +0200534 return ret;
535 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200536 }
537
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100538 list_for_each_entry(lst, &expr->patterns, list) {
539 pattern = &lst->pat;
540
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200541 if (pattern->len != smp->data.u.str.data)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100542 continue;
543
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200544 if (memcmp(pattern->ptr.str, smp->data.u.str.area, smp->data.u.str.data) == 0) {
Willy Tarreauf3045d22015-04-29 16:24:50 +0200545 ret = pattern;
546 break;
547 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100548 }
549
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200550 if (lru)
Emeric Brunb5997f72017-07-03 11:34:05 +0200551 lru64_commit(lru, ret, expr, expr->revision, NULL);
Willy Tarreauf3045d22015-04-29 16:24:50 +0200552
553 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100554}
555
556/* Executes a regex. It temporarily changes the data to add a trailing zero,
Thierry Fournier8feaa662016-02-10 22:55:20 +0100557 * and restores the previous character when leaving. This function fills
558 * a matching array.
559 */
560struct pattern *pat_match_regm(struct sample *smp, struct pattern_expr *expr, int fill)
561{
562 struct pattern_list *lst;
563 struct pattern *pattern;
564 struct pattern *ret = NULL;
565
566 list_for_each_entry(lst, &expr->patterns, list) {
567 pattern = &lst->pat;
568
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200569 if (regex_exec_match2(pattern->ptr.reg, smp->data.u.str.area, smp->data.u.str.data,
Thierry Fournier8feaa662016-02-10 22:55:20 +0100570 MAX_MATCH, pmatch, 0)) {
571 ret = pattern;
572 smp->ctx.a[0] = pmatch;
573 break;
574 }
575 }
576
577 return ret;
578}
579
580/* Executes a regex. It temporarily changes the data to add a trailing zero,
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100581 * and restores the previous character when leaving.
582 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100583struct pattern *pat_match_reg(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100584{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100585 struct pattern_list *lst;
586 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200587 struct pattern *ret = NULL;
588 struct lru64 *lru = NULL;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100589
Willy Tarreauf3045d22015-04-29 16:24:50 +0200590 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200591 unsigned long long seed = pat_lru_seed ^ (long)expr;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200592
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200593 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreauf3045d22015-04-29 16:24:50 +0200594 pat_lru_tree, expr, expr->revision);
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200595 if (lru && lru->domain) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200596 ret = lru->data;
Emeric Brunb5997f72017-07-03 11:34:05 +0200597 return ret;
598 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200599 }
600
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100601 list_for_each_entry(lst, &expr->patterns, list) {
602 pattern = &lst->pat;
603
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200604 if (regex_exec2(pattern->ptr.reg, smp->data.u.str.area, smp->data.u.str.data)) {
Willy Tarreauf3045d22015-04-29 16:24:50 +0200605 ret = pattern;
606 break;
607 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100608 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200609
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200610 if (lru)
Emeric Brunb5997f72017-07-03 11:34:05 +0200611 lru64_commit(lru, ret, expr, expr->revision, NULL);
Willy Tarreauf3045d22015-04-29 16:24:50 +0200612
613 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100614}
615
616/* Checks that the pattern matches the beginning of the tested string. */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100617struct pattern *pat_match_beg(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100618{
619 int icase;
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200620 struct ebmb_node *node;
621 char prev;
622 struct pattern_tree *elt;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100623 struct pattern_list *lst;
624 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200625 struct pattern *ret = NULL;
626 struct lru64 *lru = NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100627
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200628 /* Lookup a string in the expression's pattern tree. */
629 if (!eb_is_empty(&expr->pattern_tree)) {
630 /* we may have to force a trailing zero on the test pattern */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200631 prev = smp->data.u.str.area[smp->data.u.str.data];
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200632 if (prev)
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200633 smp->data.u.str.area[smp->data.u.str.data] = '\0';
634 node = ebmb_lookup_longest(&expr->pattern_tree,
635 smp->data.u.str.area);
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200636 if (prev)
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200637 smp->data.u.str.area[smp->data.u.str.data] = prev;
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200638
639 if (node) {
640 if (fill) {
641 elt = ebmb_entry(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200642 static_pattern.data = elt->data;
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200643 static_pattern.ref = elt->ref;
644 static_pattern.sflags = PAT_SF_TREE;
645 static_pattern.type = SMP_T_STR;
646 static_pattern.ptr.str = (char *)elt->node.key;
647 }
648 return &static_pattern;
649 }
650 }
651
652 /* look in the list */
Willy Tarreauf3045d22015-04-29 16:24:50 +0200653 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200654 unsigned long long seed = pat_lru_seed ^ (long)expr;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200655
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200656 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreauf3045d22015-04-29 16:24:50 +0200657 pat_lru_tree, expr, expr->revision);
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200658 if (lru && lru->domain) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200659 ret = lru->data;
Emeric Brunb5997f72017-07-03 11:34:05 +0200660 return ret;
661 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200662 }
663
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100664 list_for_each_entry(lst, &expr->patterns, list) {
665 pattern = &lst->pat;
666
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200667 if (pattern->len > smp->data.u.str.data)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100668 continue;
669
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200670 icase = expr->mflags & PAT_MF_IGNORE_CASE;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200671 if ((icase && strncasecmp(pattern->ptr.str, smp->data.u.str.area, pattern->len) != 0) ||
672 (!icase && strncmp(pattern->ptr.str, smp->data.u.str.area, pattern->len) != 0))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100673 continue;
674
Willy Tarreauf3045d22015-04-29 16:24:50 +0200675 ret = pattern;
676 break;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100677 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200678
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200679 if (lru)
Emeric Brunb5997f72017-07-03 11:34:05 +0200680 lru64_commit(lru, ret, expr, expr->revision, NULL);
Willy Tarreauf3045d22015-04-29 16:24:50 +0200681
682 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100683}
684
685/* Checks that the pattern matches the end of the tested string. */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100686struct pattern *pat_match_end(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100687{
688 int icase;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100689 struct pattern_list *lst;
690 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200691 struct pattern *ret = NULL;
692 struct lru64 *lru = NULL;
693
694 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200695 unsigned long long seed = pat_lru_seed ^ (long)expr;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200696
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200697 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreauf3045d22015-04-29 16:24:50 +0200698 pat_lru_tree, expr, expr->revision);
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200699 if (lru && lru->domain) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200700 ret = lru->data;
Emeric Brunb5997f72017-07-03 11:34:05 +0200701 return ret;
702 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200703 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100704
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100705 list_for_each_entry(lst, &expr->patterns, list) {
706 pattern = &lst->pat;
707
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200708 if (pattern->len > smp->data.u.str.data)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100709 continue;
710
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200711 icase = expr->mflags & PAT_MF_IGNORE_CASE;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200712 if ((icase && strncasecmp(pattern->ptr.str, smp->data.u.str.area + smp->data.u.str.data - pattern->len, pattern->len) != 0) ||
713 (!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 +0100714 continue;
715
Willy Tarreauf3045d22015-04-29 16:24:50 +0200716 ret = pattern;
717 break;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100718 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200719
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200720 if (lru)
Emeric Brunb5997f72017-07-03 11:34:05 +0200721 lru64_commit(lru, ret, expr, expr->revision, NULL);
Willy Tarreauf3045d22015-04-29 16:24:50 +0200722
723 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100724}
725
726/* Checks that the pattern is included inside the tested string.
727 * NB: Suboptimal, should be rewritten using a Boyer-Moore method.
728 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100729struct pattern *pat_match_sub(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100730{
731 int icase;
732 char *end;
733 char *c;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100734 struct pattern_list *lst;
735 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200736 struct pattern *ret = NULL;
737 struct lru64 *lru = NULL;
738
739 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200740 unsigned long long seed = pat_lru_seed ^ (long)expr;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200741
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200742 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreauf3045d22015-04-29 16:24:50 +0200743 pat_lru_tree, expr, expr->revision);
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200744 if (lru && lru->domain) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200745 ret = lru->data;
Emeric Brunb5997f72017-07-03 11:34:05 +0200746 return ret;
747 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200748 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100749
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100750 list_for_each_entry(lst, &expr->patterns, list) {
751 pattern = &lst->pat;
752
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200753 if (pattern->len > smp->data.u.str.data)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100754 continue;
755
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200756 end = smp->data.u.str.area + smp->data.u.str.data - pattern->len;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200757 icase = expr->mflags & PAT_MF_IGNORE_CASE;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100758 if (icase) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200759 for (c = smp->data.u.str.area; c <= end; c++) {
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100760 if (tolower(*c) != tolower(*pattern->ptr.str))
761 continue;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200762 if (strncasecmp(pattern->ptr.str, c, pattern->len) == 0) {
763 ret = pattern;
764 goto leave;
765 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100766 }
767 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200768 for (c = smp->data.u.str.area; c <= end; c++) {
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100769 if (*c != *pattern->ptr.str)
770 continue;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200771 if (strncmp(pattern->ptr.str, c, pattern->len) == 0) {
772 ret = pattern;
773 goto leave;
774 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100775 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100776 }
777 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200778 leave:
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200779 if (lru)
Emeric Brunb5997f72017-07-03 11:34:05 +0200780 lru64_commit(lru, ret, expr, expr->revision, NULL);
Willy Tarreauf3045d22015-04-29 16:24:50 +0200781
782 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100783}
784
785/* This one is used by other real functions. It checks that the pattern is
786 * included inside the tested string, but enclosed between the specified
787 * delimiters or at the beginning or end of the string. The delimiters are
788 * provided as an unsigned int made by make_4delim() and match up to 4 different
789 * delimiters. Delimiters are stripped at the beginning and end of the pattern.
790 */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200791static int match_word(struct sample *smp, struct pattern *pattern, int mflags, unsigned int delimiters)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100792{
793 int may_match, icase;
794 char *c, *end;
795 char *ps;
796 int pl;
797
798 pl = pattern->len;
799 ps = pattern->ptr.str;
800
801 while (pl > 0 && is_delimiter(*ps, delimiters)) {
802 pl--;
803 ps++;
804 }
805
806 while (pl > 0 && is_delimiter(ps[pl - 1], delimiters))
807 pl--;
808
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200809 if (pl > smp->data.u.str.data)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100810 return PAT_NOMATCH;
811
812 may_match = 1;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200813 icase = mflags & PAT_MF_IGNORE_CASE;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200814 end = smp->data.u.str.area + smp->data.u.str.data - pl;
815 for (c = smp->data.u.str.area; c <= end; c++) {
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100816 if (is_delimiter(*c, delimiters)) {
817 may_match = 1;
818 continue;
819 }
820
821 if (!may_match)
822 continue;
823
824 if (icase) {
825 if ((tolower(*c) == tolower(*ps)) &&
826 (strncasecmp(ps, c, pl) == 0) &&
827 (c == end || is_delimiter(c[pl], delimiters)))
828 return PAT_MATCH;
829 } else {
830 if ((*c == *ps) &&
831 (strncmp(ps, c, pl) == 0) &&
832 (c == end || is_delimiter(c[pl], delimiters)))
833 return PAT_MATCH;
834 }
835 may_match = 0;
836 }
837 return PAT_NOMATCH;
838}
839
840/* Checks that the pattern is included inside the tested string, but enclosed
841 * between the delimiters '?' or '/' or at the beginning or end of the string.
842 * Delimiters at the beginning or end of the pattern are ignored.
843 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100844struct pattern *pat_match_dir(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100845{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100846 struct pattern_list *lst;
847 struct pattern *pattern;
848
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100849 list_for_each_entry(lst, &expr->patterns, list) {
850 pattern = &lst->pat;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200851 if (match_word(smp, pattern, expr->mflags, make_4delim('/', '?', '?', '?')))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100852 return pattern;
853 }
854 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100855}
856
857/* Checks that the pattern is included inside the tested string, but enclosed
858 * between the delmiters '/', '?', '.' or ":" or at the beginning or end of
859 * the string. Delimiters at the beginning or end of the pattern are ignored.
860 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100861struct pattern *pat_match_dom(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100862{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100863 struct pattern_list *lst;
864 struct pattern *pattern;
865
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100866 list_for_each_entry(lst, &expr->patterns, list) {
867 pattern = &lst->pat;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200868 if (match_word(smp, pattern, expr->mflags, make_4delim('/', '?', '.', ':')))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100869 return pattern;
870 }
871 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100872}
873
874/* Checks that the integer in <test> is included between min and max */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100875struct pattern *pat_match_int(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100876{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100877 struct pattern_list *lst;
878 struct pattern *pattern;
879
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100880 list_for_each_entry(lst, &expr->patterns, list) {
881 pattern = &lst->pat;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200882 if ((!pattern->val.range.min_set || pattern->val.range.min <= smp->data.u.sint) &&
883 (!pattern->val.range.max_set || smp->data.u.sint <= pattern->val.range.max))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100884 return pattern;
885 }
886 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100887}
888
889/* Checks that the length of the pattern in <test> is included between min and max */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100890struct pattern *pat_match_len(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100891{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100892 struct pattern_list *lst;
893 struct pattern *pattern;
894
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100895 list_for_each_entry(lst, &expr->patterns, list) {
896 pattern = &lst->pat;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200897 if ((!pattern->val.range.min_set || pattern->val.range.min <= smp->data.u.str.data) &&
898 (!pattern->val.range.max_set || smp->data.u.str.data <= pattern->val.range.max))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100899 return pattern;
900 }
901 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100902}
903
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100904struct pattern *pat_match_ip(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100905{
906 unsigned int v4; /* in network byte order */
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100907 struct in6_addr tmp6;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100908 struct in_addr *s;
909 struct ebmb_node *node;
910 struct pattern_tree *elt;
911 struct pattern_list *lst;
912 struct pattern *pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100913
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100914 /* The input sample is IPv4. Try to match in the trees. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200915 if (smp->data.type == SMP_T_IPV4) {
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100916 /* Lookup an IPv4 address in the expression's pattern tree using
917 * the longest match method.
918 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200919 s = &smp->data.u.ipv4;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100920 node = ebmb_lookup_longest(&expr->pattern_tree, &s->s_addr);
921 if (node) {
922 if (fill) {
923 elt = ebmb_entry(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200924 static_pattern.data = elt->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +0100925 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200926 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100927 static_pattern.type = SMP_T_IPV4;
Willy Tarreau296cfd12020-02-25 09:58:41 +0100928 static_pattern.val.ipv4.addr.s_addr = read_u32(elt->node.key);
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100929 if (!cidr2dotted(elt->node.node.pfx, &static_pattern.val.ipv4.mask))
930 return NULL;
931 }
932 return &static_pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100933 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100934
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100935 /* The IPv4 sample dont match the IPv4 tree. Convert the IPv4
936 * sample address to IPv6 with the mapping method using the ::ffff:
937 * prefix, and try to lookup in the IPv6 tree.
938 */
939 memset(&tmp6, 0, 10);
Willy Tarreau296cfd12020-02-25 09:58:41 +0100940 write_u16(&tmp6.s6_addr[10], htons(0xffff));
941 write_u32(&tmp6.s6_addr[12], smp->data.u.ipv4.s_addr);
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100942 node = ebmb_lookup_longest(&expr->pattern_tree_2, &tmp6);
943 if (node) {
944 if (fill) {
945 elt = ebmb_entry(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200946 static_pattern.data = elt->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +0100947 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200948 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100949 static_pattern.type = SMP_T_IPV6;
Willy Tarreau296cfd12020-02-25 09:58:41 +0100950 memcpy(&static_pattern.val.ipv6.addr, elt->node.key, 16);
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100951 static_pattern.val.ipv6.mask = elt->node.node.pfx;
952 }
953 return &static_pattern;
954 }
955 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100956
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100957 /* The input sample is IPv6. Try to match in the trees. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200958 if (smp->data.type == SMP_T_IPV6) {
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100959 /* Lookup an IPv6 address in the expression's pattern tree using
960 * the longest match method.
961 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200962 node = ebmb_lookup_longest(&expr->pattern_tree_2, &smp->data.u.ipv6);
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100963 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 FOURNIER33a74332013-12-19 23:54:54 +0100969 static_pattern.type = SMP_T_IPV6;
Willy Tarreau296cfd12020-02-25 09:58:41 +0100970 memcpy(&static_pattern.val.ipv6.addr, elt->node.key, 16);
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100971 static_pattern.val.ipv6.mask = elt->node.node.pfx;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100972 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100973 return &static_pattern;
974 }
975
976 /* Try to convert 6 to 4 when the start of the ipv6 address match the
977 * following forms :
978 * - ::ffff:ip:v4 (ipv4 mapped)
979 * - ::0000:ip:v4 (old ipv4 mapped)
980 * - 2002:ip:v4:: (6to4)
981 */
Willy Tarreau296cfd12020-02-25 09:58:41 +0100982 if ((read_u64(&smp->data.u.ipv6.s6_addr[0]) == 0 &&
983 (read_u32(&smp->data.u.ipv6.s6_addr[8]) == 0 ||
984 read_u32(&smp->data.u.ipv6.s6_addr[8]) == htonl(0xFFFF))) ||
985 read_u16(&smp->data.u.ipv6.s6_addr[0]) == htons(0x2002)) {
986 if (read_u32(&smp->data.u.ipv6.s6_addr[0]) == 0)
987 v4 = read_u32(&smp->data.u.ipv6.s6_addr[12]);
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100988 else
Willy Tarreau296cfd12020-02-25 09:58:41 +0100989 v4 = htonl((ntohs(read_u16(&smp->data.u.ipv6.s6_addr[2])) << 16) +
990 ntohs(read_u16(&smp->data.u.ipv6.s6_addr[4])));
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100991
992 /* Lookup an IPv4 address in the expression's pattern tree using the longest
993 * match method.
994 */
995 node = ebmb_lookup_longest(&expr->pattern_tree, &v4);
996 if (node) {
997 if (fill) {
998 elt = ebmb_entry(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200999 static_pattern.data = elt->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001000 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001001 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001002 static_pattern.type = SMP_T_IPV4;
Willy Tarreau296cfd12020-02-25 09:58:41 +01001003 static_pattern.val.ipv4.addr.s_addr = read_u32(elt->node.key);
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001004 if (!cidr2dotted(elt->node.node.pfx, &static_pattern.val.ipv4.mask))
1005 return NULL;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001006 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001007 return &static_pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001008 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001009 }
1010 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001011
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001012 /* Lookup in the list. the list contain only IPv4 patterns */
1013 list_for_each_entry(lst, &expr->patterns, list) {
1014 pattern = &lst->pat;
1015
1016 /* The input sample is IPv4, use it as is. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001017 if (smp->data.type == SMP_T_IPV4) {
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001018 v4 = smp->data.u.ipv4.s_addr;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001019 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001020 else if (smp->data.type == SMP_T_IPV6) {
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001021 /* v4 match on a V6 sample. We want to check at least for
1022 * the following forms :
1023 * - ::ffff:ip:v4 (ipv4 mapped)
1024 * - ::0000:ip:v4 (old ipv4 mapped)
1025 * - 2002:ip:v4:: (6to4)
1026 */
Willy Tarreau296cfd12020-02-25 09:58:41 +01001027 if (read_u64(&smp->data.u.ipv6.s6_addr[0]) == 0 &&
1028 (read_u32(&smp->data.u.ipv6.s6_addr[8]) == 0 ||
1029 read_u32(&smp->data.u.ipv6.s6_addr[8]) == htonl(0xFFFF))) {
1030 v4 = read_u32(&smp->data.u.ipv6.s6_addr[12]);
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001031 }
Willy Tarreau296cfd12020-02-25 09:58:41 +01001032 else if (read_u16(&smp->data.u.ipv6.s6_addr[0]) == htons(0x2002)) {
1033 v4 = htonl((ntohs(read_u16(&smp->data.u.ipv6.s6_addr[2])) << 16) +
1034 ntohs(read_u16(&smp->data.u.ipv6.s6_addr[4])));
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001035 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001036 else
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001037 continue;
Andreas Seltenreichf0653192016-03-03 20:08:35 +01001038 } else {
1039 /* impossible */
1040 continue;
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001041 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001042
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001043 /* Check if the input sample match the current pattern. */
1044 if (((v4 ^ pattern->val.ipv4.addr.s_addr) & pattern->val.ipv4.mask.s_addr) == 0)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001045 return pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001046 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001047 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001048}
1049
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001050void free_pattern_tree(struct eb_root *root)
1051{
1052 struct eb_node *node, *next;
Thierry FOURNIERe1bcac52013-12-13 16:09:50 +01001053 struct pattern_tree *elt;
Thierry FOURNIER3ce88c72013-12-09 11:29:46 +01001054
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001055 node = eb_first(root);
1056 while (node) {
1057 next = eb_next(node);
1058 eb_delete(node);
Thierry FOURNIERe1bcac52013-12-13 16:09:50 +01001059 elt = container_of(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001060 free(elt->data);
Thierry FOURNIER3ce88c72013-12-09 11:29:46 +01001061 free(elt);
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001062 node = next;
1063 }
1064}
1065
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001066void pat_prune_val(struct pattern_expr *expr)
Thierry FOURNIERd163e1c2013-11-28 11:41:23 +01001067{
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001068 struct pattern_list *pat, *tmp;
1069
1070 list_for_each_entry_safe(pat, tmp, &expr->patterns, list) {
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001071 free(pat->pat.data);
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001072 free(pat);
1073 }
1074
Thierry FOURNIERd163e1c2013-11-28 11:41:23 +01001075 free_pattern_tree(&expr->pattern_tree);
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001076 free_pattern_tree(&expr->pattern_tree_2);
Thierry FOURNIERd163e1c2013-11-28 11:41:23 +01001077 LIST_INIT(&expr->patterns);
1078}
1079
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001080void pat_prune_ptr(struct pattern_expr *expr)
1081{
1082 struct pattern_list *pat, *tmp;
1083
1084 list_for_each_entry_safe(pat, tmp, &expr->patterns, list) {
1085 free(pat->pat.ptr.ptr);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001086 free(pat->pat.data);
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001087 free(pat);
1088 }
1089
1090 free_pattern_tree(&expr->pattern_tree);
1091 free_pattern_tree(&expr->pattern_tree_2);
1092 LIST_INIT(&expr->patterns);
1093}
1094
1095void pat_prune_reg(struct pattern_expr *expr)
1096{
1097 struct pattern_list *pat, *tmp;
1098
1099 list_for_each_entry_safe(pat, tmp, &expr->patterns, list) {
1100 regex_free(pat->pat.ptr.ptr);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001101 free(pat->pat.data);
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001102 free(pat);
1103 }
1104
1105 free_pattern_tree(&expr->pattern_tree);
1106 free_pattern_tree(&expr->pattern_tree_2);
1107 LIST_INIT(&expr->patterns);
1108}
1109
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001110/*
1111 *
1112 * The following functions are used for the pattern indexation
1113 *
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001114 */
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001115
1116int pat_idx_list_val(struct pattern_expr *expr, struct pattern *pat, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001117{
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001118 struct pattern_list *patl;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001119
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001120 /* allocate pattern */
1121 patl = calloc(1, sizeof(*patl));
1122 if (!patl) {
1123 memprintf(err, "out of memory while indexing pattern");
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001124 return 0;
1125 }
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001126
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001127 /* duplicate pattern */
1128 memcpy(&patl->pat, pat, sizeof(*pat));
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001129
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001130 /* chain pattern in the expression */
1131 LIST_ADDQ(&expr->patterns, &patl->list);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001132 expr->revision = rdtsc();
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001133
1134 /* that's ok */
1135 return 1;
1136}
1137
1138int pat_idx_list_ptr(struct pattern_expr *expr, struct pattern *pat, char **err)
1139{
1140 struct pattern_list *patl;
1141
1142 /* allocate pattern */
1143 patl = calloc(1, sizeof(*patl));
Thierry FOURNIER8aa83842015-02-06 17:50:55 +01001144 if (!patl) {
1145 memprintf(err, "out of memory while indexing pattern");
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001146 return 0;
Thierry FOURNIER8aa83842015-02-06 17:50:55 +01001147 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001148
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001149 /* duplicate pattern */
1150 memcpy(&patl->pat, pat, sizeof(*pat));
1151 patl->pat.ptr.ptr = malloc(patl->pat.len);
1152 if (!patl->pat.ptr.ptr) {
1153 free(patl);
1154 memprintf(err, "out of memory while indexing pattern");
1155 return 0;
1156 }
1157 memcpy(patl->pat.ptr.ptr, pat->ptr.ptr, pat->len);
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001158
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001159 /* chain pattern in the expression */
1160 LIST_ADDQ(&expr->patterns, &patl->list);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001161 expr->revision = rdtsc();
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001162
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001163 /* that's ok */
1164 return 1;
1165}
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001166
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001167int pat_idx_list_str(struct pattern_expr *expr, struct pattern *pat, char **err)
1168{
1169 struct pattern_list *patl;
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001170
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001171 /* allocate pattern */
1172 patl = calloc(1, sizeof(*patl));
1173 if (!patl) {
1174 memprintf(err, "out of memory while indexing pattern");
1175 return 0;
1176 }
1177
1178 /* duplicate pattern */
1179 memcpy(&patl->pat, pat, sizeof(*pat));
1180 patl->pat.ptr.str = malloc(patl->pat.len + 1);
1181 if (!patl->pat.ptr.str) {
1182 free(patl);
1183 memprintf(err, "out of memory while indexing pattern");
1184 return 0;
1185 }
1186 memcpy(patl->pat.ptr.ptr, pat->ptr.ptr, pat->len);
1187 patl->pat.ptr.str[patl->pat.len] = '\0';
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001188
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001189 /* chain pattern in the expression */
1190 LIST_ADDQ(&expr->patterns, &patl->list);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001191 expr->revision = rdtsc();
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001192
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001193 /* that's ok */
1194 return 1;
1195}
1196
Thierry Fournier8feaa662016-02-10 22:55:20 +01001197int pat_idx_list_reg_cap(struct pattern_expr *expr, struct pattern *pat, int cap, char **err)
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001198{
1199 struct pattern_list *patl;
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001200
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001201 /* allocate pattern */
1202 patl = calloc(1, sizeof(*patl));
1203 if (!patl) {
1204 memprintf(err, "out of memory while indexing pattern");
1205 return 0;
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001206 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001207
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001208 /* duplicate pattern */
1209 memcpy(&patl->pat, pat, sizeof(*pat));
1210
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001211 /* compile regex */
Dragan Dosen26743032019-04-30 15:54:36 +02001212 if (!(patl->pat.ptr.reg = regex_comp(pat->ptr.str, !(expr->mflags & PAT_MF_IGNORE_CASE),
1213 cap, err))) {
Dirkjan Bussink07fcaaa2014-04-28 22:57:16 +00001214 free(patl);
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001215 return 0;
1216 }
1217
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001218 /* chain pattern in the expression */
1219 LIST_ADDQ(&expr->patterns, &patl->list);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001220 expr->revision = rdtsc();
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001221
1222 /* that's ok */
1223 return 1;
1224}
1225
Thierry Fournier8feaa662016-02-10 22:55:20 +01001226int pat_idx_list_reg(struct pattern_expr *expr, struct pattern *pat, char **err)
1227{
1228 return pat_idx_list_reg_cap(expr, pat, 0, err);
1229}
1230
1231int pat_idx_list_regm(struct pattern_expr *expr, struct pattern *pat, char **err)
1232{
1233 return pat_idx_list_reg_cap(expr, pat, 1, err);
1234}
1235
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001236int pat_idx_tree_ip(struct pattern_expr *expr, struct pattern *pat, char **err)
1237{
1238 unsigned int mask;
Thierry FOURNIERe1bcac52013-12-13 16:09:50 +01001239 struct pattern_tree *node;
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001240
1241 /* Only IPv4 can be indexed */
1242 if (pat->type == SMP_T_IPV4) {
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001243 /* in IPv4 case, check if the mask is contiguous so that we can
1244 * insert the network into the tree. A continuous mask has only
1245 * ones on the left. This means that this mask + its lower bit
1246 * added once again is null.
1247 */
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001248 mask = ntohl(pat->val.ipv4.mask.s_addr);
1249 if (mask + (mask & -mask) == 0) {
1250 mask = mask ? 33 - flsnz(mask & -mask) : 0; /* equals cidr value */
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001251
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001252 /* node memory allocation */
1253 node = calloc(1, sizeof(*node) + 4);
1254 if (!node) {
1255 memprintf(err, "out of memory while loading pattern");
1256 return 0;
1257 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001258
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001259 /* copy the pointer to sample associated to this node */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001260 node->data = pat->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001261 node->ref = pat->ref;
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001262
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001263 /* FIXME: insert <addr>/<mask> into the tree here */
1264 memcpy(node->node.key, &pat->val.ipv4.addr, 4); /* network byte order */
1265 node->node.node.pfx = mask;
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001266
1267 /* Insert the entry. */
1268 ebmb_insert_prefix(&expr->pattern_tree, &node->node, 4);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001269 expr->revision = rdtsc();
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001270
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001271 /* that's ok */
1272 return 1;
1273 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001274 else {
1275 /* If the mask is not contiguous, just add the pattern to the list */
1276 return pat_idx_list_val(expr, pat, err);
1277 }
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001278 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001279 else if (pat->type == SMP_T_IPV6) {
1280 /* IPv6 also can be indexed */
1281 node = calloc(1, sizeof(*node) + 16);
1282 if (!node) {
1283 memprintf(err, "out of memory while loading pattern");
1284 return 0;
1285 }
1286
1287 /* copy the pointer to sample associated to this node */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001288 node->data = pat->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001289 node->ref = pat->ref;
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001290
1291 /* FIXME: insert <addr>/<mask> into the tree here */
1292 memcpy(node->node.key, &pat->val.ipv6.addr, 16); /* network byte order */
1293 node->node.node.pfx = pat->val.ipv6.mask;
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001294
1295 /* Insert the entry. */
1296 ebmb_insert_prefix(&expr->pattern_tree_2, &node->node, 16);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001297 expr->revision = rdtsc();
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001298
1299 /* that's ok */
1300 return 1;
1301 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001302
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001303 return 0;
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001304}
1305
1306int pat_idx_tree_str(struct pattern_expr *expr, struct pattern *pat, char **err)
1307{
1308 int len;
Thierry FOURNIERe1bcac52013-12-13 16:09:50 +01001309 struct pattern_tree *node;
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001310
1311 /* Only string can be indexed */
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001312 if (pat->type != SMP_T_STR) {
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001313 memprintf(err, "internal error: string expected, but the type is '%s'",
1314 smp_to_type[pat->type]);
1315 return 0;
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001316 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001317
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001318 /* If the flag PAT_F_IGNORE_CASE is set, we cannot use trees */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001319 if (expr->mflags & PAT_MF_IGNORE_CASE)
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001320 return pat_idx_list_str(expr, pat, err);
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001321
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001322 /* Process the key len */
1323 len = strlen(pat->ptr.str) + 1;
1324
1325 /* node memory allocation */
1326 node = calloc(1, sizeof(*node) + len);
1327 if (!node) {
1328 memprintf(err, "out of memory while loading pattern");
1329 return 0;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001330 }
1331
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001332 /* copy the pointer to sample associated to this node */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001333 node->data = pat->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001334 node->ref = pat->ref;
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001335
1336 /* copy the string */
1337 memcpy(node->node.key, pat->ptr.str, len);
1338
1339 /* index the new node */
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001340 ebst_insert(&expr->pattern_tree, &node->node);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001341 expr->revision = rdtsc();
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001342
1343 /* that's ok */
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001344 return 1;
1345}
1346
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +02001347int pat_idx_tree_pfx(struct pattern_expr *expr, struct pattern *pat, char **err)
1348{
1349 int len;
1350 struct pattern_tree *node;
1351
1352 /* Only string can be indexed */
1353 if (pat->type != SMP_T_STR) {
1354 memprintf(err, "internal error: string expected, but the type is '%s'",
1355 smp_to_type[pat->type]);
1356 return 0;
1357 }
1358
1359 /* If the flag PAT_F_IGNORE_CASE is set, we cannot use trees */
1360 if (expr->mflags & PAT_MF_IGNORE_CASE)
1361 return pat_idx_list_str(expr, pat, err);
1362
1363 /* Process the key len */
1364 len = strlen(pat->ptr.str);
1365
1366 /* node memory allocation */
1367 node = calloc(1, sizeof(*node) + len + 1);
1368 if (!node) {
1369 memprintf(err, "out of memory while loading pattern");
1370 return 0;
1371 }
1372
1373 /* copy the pointer to sample associated to this node */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001374 node->data = pat->data;
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +02001375 node->ref = pat->ref;
1376
1377 /* copy the string and the trailing zero */
1378 memcpy(node->node.key, pat->ptr.str, len + 1);
1379 node->node.node.pfx = len * 8;
1380
1381 /* index the new node */
1382 ebmb_insert_prefix(&expr->pattern_tree, &node->node, len);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001383 expr->revision = rdtsc();
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +02001384
1385 /* that's ok */
1386 return 1;
1387}
1388
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001389void pat_del_list_val(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001390{
1391 struct pattern_list *pat;
1392 struct pattern_list *safe;
1393
1394 list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
1395 /* Check equality. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001396 if (pat->pat.ref != ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001397 continue;
1398
1399 /* Delete and free entry. */
1400 LIST_DEL(&pat->list);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001401 free(pat->pat.data);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001402 free(pat);
1403 }
Willy Tarreau72f073b2015-04-29 17:53:47 +02001404 expr->revision = rdtsc();
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001405}
1406
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001407void pat_del_tree_ip(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001408{
1409 struct ebmb_node *node, *next_node;
1410 struct pattern_tree *elt;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001411
1412 /* browse each node of the tree for IPv4 addresses. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001413 for (node = ebmb_first(&expr->pattern_tree), next_node = node ? ebmb_next(node) : NULL;
1414 node;
1415 node = next_node, next_node = node ? ebmb_next(node) : NULL) {
1416 /* Extract container of the tree node. */
1417 elt = container_of(node, struct pattern_tree, node);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001418
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001419 /* Check equality. */
1420 if (elt->ref != ref)
1421 continue;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001422
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001423 /* Delete and free entry. */
1424 ebmb_delete(node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001425 free(elt->data);
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001426 free(elt);
1427 }
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001428
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001429 /* Browse each node of the list for IPv4 addresses. */
1430 pat_del_list_val(expr, ref);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001431
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001432 /* browse each node of the tree for IPv6 addresses. */
1433 for (node = ebmb_first(&expr->pattern_tree_2), next_node = node ? ebmb_next(node) : NULL;
1434 node;
1435 node = next_node, next_node = node ? ebmb_next(node) : NULL) {
1436 /* Extract container of the tree node. */
1437 elt = container_of(node, struct pattern_tree, node);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001438
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001439 /* Check equality. */
1440 if (elt->ref != ref)
1441 continue;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001442
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001443 /* Delete and free entry. */
1444 ebmb_delete(node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001445 free(elt->data);
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001446 free(elt);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001447 }
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_list_ptr(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001452{
1453 struct pattern_list *pat;
1454 struct pattern_list *safe;
1455
1456 list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
1457 /* Check equality. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001458 if (pat->pat.ref != ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001459 continue;
1460
1461 /* Delete and free entry. */
1462 LIST_DEL(&pat->list);
1463 free(pat->pat.ptr.ptr);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001464 free(pat->pat.data);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001465 free(pat);
1466 }
Willy Tarreau72f073b2015-04-29 17:53:47 +02001467 expr->revision = rdtsc();
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001468}
1469
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001470void pat_del_tree_str(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001471{
1472 struct ebmb_node *node, *next_node;
1473 struct pattern_tree *elt;
1474
Thierry FOURNIER73bc2852015-02-06 17:53:54 +01001475 /* If the flag PAT_F_IGNORE_CASE is set, we cannot use trees */
1476 if (expr->mflags & PAT_MF_IGNORE_CASE)
1477 return pat_del_list_ptr(expr, ref);
1478
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001479 /* browse each node of the tree. */
1480 for (node = ebmb_first(&expr->pattern_tree), next_node = node ? ebmb_next(node) : NULL;
1481 node;
1482 node = next_node, next_node = node ? ebmb_next(node) : NULL) {
1483 /* Extract container of the tree node. */
1484 elt = container_of(node, struct pattern_tree, node);
1485
1486 /* Check equality. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001487 if (elt->ref != ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001488 continue;
1489
1490 /* Delete and free entry. */
1491 ebmb_delete(node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001492 free(elt->data);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001493 free(elt);
1494 }
Willy Tarreau72f073b2015-04-29 17:53:47 +02001495 expr->revision = rdtsc();
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001496}
1497
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001498void pat_del_list_reg(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001499{
1500 struct pattern_list *pat;
1501 struct pattern_list *safe;
1502
1503 list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
1504 /* Check equality. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001505 if (pat->pat.ref != ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001506 continue;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001507
1508 /* Delete and free entry. */
1509 LIST_DEL(&pat->list);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001510 regex_free(pat->pat.ptr.ptr);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001511 free(pat->pat.data);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001512 free(pat);
1513 }
Willy Tarreau72f073b2015-04-29 17:53:47 +02001514 expr->revision = rdtsc();
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001515}
1516
1517void pattern_init_expr(struct pattern_expr *expr)
1518{
1519 LIST_INIT(&expr->patterns);
Willy Tarreau72f073b2015-04-29 17:53:47 +02001520 expr->revision = 0;
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001521 expr->pattern_tree = EB_ROOT;
1522 expr->pattern_tree_2 = EB_ROOT;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001523}
1524
1525void pattern_init_head(struct pattern_head *head)
1526{
1527 LIST_INIT(&head->head);
1528}
1529
1530/* The following functions are relative to the management of the reference
1531 * lists. These lists are used to store the original pattern and associated
1532 * value as string form.
1533 *
1534 * This is used with modifiable ACL and MAPS
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001535 *
1536 * The pattern reference are stored with two identifiers: the unique_id and
1537 * the reference.
1538 *
1539 * The reference identify a file. Each file with the same name point to the
1540 * same reference. We can register many times one file. If the file is modified,
1541 * all his dependencies are also modified. The reference can be used with map or
1542 * acl.
1543 *
1544 * The unique_id identify inline acl. The unique id is unique for each acl.
1545 * You cannot force the same id in the configuration file, because this repoort
1546 * an error.
1547 *
1548 * A particular case appears if the filename is a number. In this case, the
1549 * unique_id is set with the number represented by the filename and the
1550 * reference is also set. This method prevent double unique_id.
1551 *
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001552 */
1553
1554/* This function lookup for reference. If the reference is found, they return
1555 * pointer to the struct pat_ref, else return NULL.
1556 */
1557struct pat_ref *pat_ref_lookup(const char *reference)
1558{
1559 struct pat_ref *ref;
1560
1561 list_for_each_entry(ref, &pattern_reference, list)
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001562 if (ref->reference && strcmp(reference, ref->reference) == 0)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001563 return ref;
1564 return NULL;
1565}
1566
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001567/* This function lookup for unique id. If the reference is found, they return
1568 * pointer to the struct pat_ref, else return NULL.
1569 */
1570struct pat_ref *pat_ref_lookupid(int unique_id)
1571{
1572 struct pat_ref *ref;
1573
1574 list_for_each_entry(ref, &pattern_reference, list)
1575 if (ref->unique_id == unique_id)
1576 return ref;
1577 return NULL;
1578}
1579
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001580/* This function remove all pattern matching the pointer <refelt> from
1581 * the the reference and from each expr member of the reference. This
1582 * function returns 1 if the deletion is done and return 0 is the entry
1583 * is not found.
1584 */
1585int pat_ref_delete_by_id(struct pat_ref *ref, struct pat_ref_elt *refelt)
1586{
1587 struct pattern_expr *expr;
1588 struct pat_ref_elt *elt, *safe;
Emeric Brun8d85aa42017-06-29 15:40:33 +02001589 struct bref *bref, *back;
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001590
1591 /* delete pattern from reference */
1592 list_for_each_entry_safe(elt, safe, &ref->head, list) {
1593 if (elt == refelt) {
Emeric Brun8d85aa42017-06-29 15:40:33 +02001594 list_for_each_entry_safe(bref, back, &elt->back_refs, users) {
1595 /*
1596 * we have to unlink all watchers. We must not relink them if
1597 * this elt was the last one in the list.
1598 */
1599 LIST_DEL(&bref->users);
1600 LIST_INIT(&bref->users);
1601 if (elt->list.n != &ref->head)
Willy Tarreau49ee3b22019-04-30 11:43:43 +02001602 LIST_ADDQ(&LIST_ELEM(elt->list.n, typeof(elt), list)->back_refs, &bref->users);
Emeric Brun8d85aa42017-06-29 15:40:33 +02001603 bref->ref = elt->list.n;
1604 }
peter caiaede6dd2015-10-07 00:07:43 -07001605 list_for_each_entry(expr, &ref->pat, list)
1606 pattern_delete(expr, elt);
1607
Emeric Brunb5997f72017-07-03 11:34:05 +02001608 /* pat_ref_elt is trashed once all expr
1609 are cleaned and there is no ref remaining */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001610 LIST_DEL(&elt->list);
1611 free(elt->sample);
1612 free(elt->pattern);
1613 free(elt);
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001614 return 1;
1615 }
1616 }
1617 return 0;
1618}
1619
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001620/* This function remove all pattern match <key> from the the reference
Joseph Herlant4189d672018-11-15 10:22:31 -08001621 * and from each expr member of the reference. This function returns 1
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001622 * if the deletion is done and return 0 is the entry is not found.
1623 */
1624int pat_ref_delete(struct pat_ref *ref, const char *key)
1625{
1626 struct pattern_expr *expr;
1627 struct pat_ref_elt *elt, *safe;
Emeric Brun8d85aa42017-06-29 15:40:33 +02001628 struct bref *bref, *back;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001629 int found = 0;
1630
1631 /* delete pattern from reference */
1632 list_for_each_entry_safe(elt, safe, &ref->head, list) {
1633 if (strcmp(key, elt->pattern) == 0) {
Emeric Brun8d85aa42017-06-29 15:40:33 +02001634 list_for_each_entry_safe(bref, back, &elt->back_refs, users) {
1635 /*
1636 * we have to unlink all watchers. We must not relink them if
1637 * this elt was the last one in the list.
1638 */
1639 LIST_DEL(&bref->users);
1640 LIST_INIT(&bref->users);
1641 if (elt->list.n != &ref->head)
Willy Tarreau49ee3b22019-04-30 11:43:43 +02001642 LIST_ADDQ(&LIST_ELEM(elt->list.n, typeof(elt), list)->back_refs, &bref->users);
Emeric Brun8d85aa42017-06-29 15:40:33 +02001643 bref->ref = elt->list.n;
1644 }
Dirkjan Bussink07fcaaa2014-04-28 22:57:16 +00001645 list_for_each_entry(expr, &ref->pat, list)
1646 pattern_delete(expr, elt);
1647
Emeric Brunb5997f72017-07-03 11:34:05 +02001648 /* pat_ref_elt is trashed once all expr
1649 are cleaned and there is no ref remaining */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001650 LIST_DEL(&elt->list);
1651 free(elt->sample);
1652 free(elt->pattern);
1653 free(elt);
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001654
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001655 found = 1;
1656 }
1657 }
1658
1659 if (!found)
1660 return 0;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001661 return 1;
1662}
1663
Baptiste Assmann953f74d2014-04-25 16:57:03 +02001664/*
1665 * find and return an element <elt> matching <key> in a reference <ref>
1666 * return NULL if not found
1667 */
1668struct pat_ref_elt *pat_ref_find_elt(struct pat_ref *ref, const char *key)
1669{
1670 struct pat_ref_elt *elt;
1671
1672 list_for_each_entry(elt, &ref->head, list) {
1673 if (strcmp(key, elt->pattern) == 0)
1674 return elt;
1675 }
1676
1677 return NULL;
1678}
1679
1680
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001681 /* This function modify the sample of the first pattern that match the <key>. */
1682static inline int pat_ref_set_elt(struct pat_ref *ref, struct pat_ref_elt *elt,
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001683 const char *value, char **err)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001684{
1685 struct pattern_expr *expr;
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001686 struct sample_data **data;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001687 char *sample;
Thierry FOURNIER12ba0c22015-08-14 00:02:11 +02001688 struct sample_data test;
Thierry FOURNIER149e0fe2014-01-29 19:35:06 +01001689
1690 /* Try all needed converters. */
1691 list_for_each_entry(expr, &ref->pat, list) {
1692 if (!expr->pat_head->parse_smp)
1693 continue;
1694
1695 if (!expr->pat_head->parse_smp(value, &test)) {
1696 memprintf(err, "unable to parse '%s'", value);
1697 return 0;
1698 }
1699 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001700
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001701 /* Modify pattern from reference. */
1702 sample = strdup(value);
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001703 if (!sample) {
1704 memprintf(err, "out of memory error");
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001705 return 0;
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001706 }
Thierry FOURNIER149e0fe2014-01-29 19:35:06 +01001707 /* Load sample in each reference. All the conversion are tested
1708 * below, normally these calls dosn't fail.
1709 */
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01001710 list_for_each_entry(expr, &ref->pat, list) {
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001711 if (!expr->pat_head->parse_smp)
1712 continue;
1713
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001714 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001715 data = pattern_find_smp(expr, elt);
1716 if (data && *data && !expr->pat_head->parse_smp(sample, *data))
1717 *data = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001718 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001719 }
1720
Emeric Brunb5997f72017-07-03 11:34:05 +02001721 /* free old sample only when all exprs are updated */
1722 free(elt->sample);
1723 elt->sample = sample;
1724
1725
Thierry FOURNIER149e0fe2014-01-29 19:35:06 +01001726 return 1;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001727}
1728
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001729/* This function modify the sample of the first pattern that match the <key>. */
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001730int 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 +01001731{
1732 struct pat_ref_elt *elt;
1733
1734 /* Look for pattern in the reference. */
1735 list_for_each_entry(elt, &ref->head, list) {
1736 if (elt == refelt) {
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001737 if (!pat_ref_set_elt(ref, elt, value, err))
1738 return 0;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001739 return 1;
1740 }
1741 }
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001742
1743 memprintf(err, "key or pattern not found");
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001744 return 0;
1745}
1746
1747/* This function modify the sample of the first pattern that match the <key>. */
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001748int pat_ref_set(struct pat_ref *ref, const char *key, const char *value, char **err)
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001749{
1750 struct pat_ref_elt *elt;
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001751 int found = 0;
1752 char *_merr;
1753 char **merr;
1754
1755 if (err) {
1756 merr = &_merr;
1757 *merr = NULL;
1758 }
1759 else
1760 merr = NULL;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001761
1762 /* Look for pattern in the reference. */
1763 list_for_each_entry(elt, &ref->head, list) {
1764 if (strcmp(key, elt->pattern) == 0) {
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001765 if (!pat_ref_set_elt(ref, elt, value, merr)) {
William Lallemand579fb252018-06-11 10:53:46 +02001766 if (err && merr) {
1767 if (!found) {
1768 *err = *merr;
1769 } else {
1770 memprintf(err, "%s, %s", *err, *merr);
1771 free(*merr);
1772 *merr = NULL;
1773 }
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001774 }
1775 }
1776 found = 1;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001777 }
1778 }
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001779
1780 if (!found) {
1781 memprintf(err, "entry not found");
1782 return 0;
1783 }
1784 return 1;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001785}
1786
Joseph Herlant4189d672018-11-15 10:22:31 -08001787/* This function creates a new reference. <ref> is the reference name.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001788 * <flags> are PAT_REF_*. /!\ The reference is not checked, and must
1789 * be unique. The user must check the reference with "pat_ref_lookup()"
Joseph Herlant4189d672018-11-15 10:22:31 -08001790 * before calling this function. If the function fail, it return NULL,
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001791 * else return new struct pat_ref.
1792 */
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001793struct pat_ref *pat_ref_new(const char *reference, const char *display, unsigned int flags)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001794{
1795 struct pat_ref *ref;
1796
1797 ref = malloc(sizeof(*ref));
1798 if (!ref)
1799 return NULL;
1800
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001801 if (display) {
1802 ref->display = strdup(display);
1803 if (!ref->display) {
1804 free(ref);
1805 return NULL;
1806 }
1807 }
1808 else
1809 ref->display = NULL;
1810
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001811 ref->reference = strdup(reference);
1812 if (!ref->reference) {
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001813 free(ref->display);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001814 free(ref);
1815 return NULL;
1816 }
1817
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001818 ref->flags = flags;
1819 ref->unique_id = -1;
1820
1821 LIST_INIT(&ref->head);
1822 LIST_INIT(&ref->pat);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001823 HA_SPIN_INIT(&ref->lock);
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001824 LIST_ADDQ(&pattern_reference, &ref->list);
1825
1826 return ref;
1827}
1828
1829/* This function create new reference. <unique_id> is the unique id. If
1830 * the value of <unique_id> is -1, the unique id is calculated later.
1831 * <flags> are PAT_REF_*. /!\ The reference is not checked, and must
1832 * be unique. The user must check the reference with "pat_ref_lookup()"
1833 * or pat_ref_lookupid before calling this function. If the function
1834 * fail, it return NULL, else return new struct pat_ref.
1835 */
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001836struct pat_ref *pat_ref_newid(int unique_id, const char *display, unsigned int flags)
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001837{
1838 struct pat_ref *ref;
1839
1840 ref = malloc(sizeof(*ref));
1841 if (!ref)
1842 return NULL;
1843
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001844 if (display) {
1845 ref->display = strdup(display);
1846 if (!ref->display) {
1847 free(ref);
1848 return NULL;
1849 }
1850 }
1851 else
1852 ref->display = NULL;
1853
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001854 ref->reference = NULL;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001855 ref->flags = flags;
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001856 ref->unique_id = unique_id;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001857 LIST_INIT(&ref->head);
1858 LIST_INIT(&ref->pat);
Aurélien Nephtali564d15a2018-04-19 16:56:07 +02001859 HA_SPIN_INIT(&ref->lock);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001860 LIST_ADDQ(&pattern_reference, &ref->list);
1861
1862 return ref;
1863}
1864
1865/* This function adds entry to <ref>. It can failed with memory error.
1866 * If the function fails, it returns 0.
1867 */
1868int pat_ref_append(struct pat_ref *ref, char *pattern, char *sample, int line)
1869{
1870 struct pat_ref_elt *elt;
1871
1872 elt = malloc(sizeof(*elt));
1873 if (!elt)
1874 return 0;
1875
1876 elt->line = line;
1877
1878 elt->pattern = strdup(pattern);
1879 if (!elt->pattern) {
1880 free(elt);
1881 return 0;
1882 }
1883
1884 if (sample) {
1885 elt->sample = strdup(sample);
1886 if (!elt->sample) {
1887 free(elt->pattern);
1888 free(elt);
1889 return 0;
1890 }
1891 }
1892 else
1893 elt->sample = NULL;
1894
Emeric Brun8d85aa42017-06-29 15:40:33 +02001895 LIST_INIT(&elt->back_refs);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001896 LIST_ADDQ(&ref->head, &elt->list);
1897
1898 return 1;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001899}
1900
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001901/* This function create sample found in <elt>, parse the pattern also
1902 * found in <elt> and insert it in <expr>. The function copy <patflags>
1903 * in <expr>. If the function fails, it returns0 and <err> is filled.
1904 * In succes case, the function returns 1.
1905 */
1906static inline
1907int pat_ref_push(struct pat_ref_elt *elt, struct pattern_expr *expr,
1908 int patflags, char **err)
1909{
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001910 struct sample_data *data;
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001911 struct pattern pattern;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001912
1913 /* Create sample */
1914 if (elt->sample && expr->pat_head->parse_smp) {
1915 /* New sample. */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001916 data = malloc(sizeof(*data));
1917 if (!data)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001918 return 0;
1919
1920 /* Parse value. */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001921 if (!expr->pat_head->parse_smp(elt->sample, data)) {
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001922 memprintf(err, "unable to parse '%s'", elt->sample);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001923 free(data);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001924 return 0;
1925 }
1926
1927 }
1928 else
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001929 data = NULL;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001930
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001931 /* initialise pattern */
1932 memset(&pattern, 0, sizeof(pattern));
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001933 pattern.data = data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001934 pattern.ref = elt;
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001935
1936 /* parse pattern */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001937 if (!expr->pat_head->parse(elt->pattern, &pattern, expr->mflags, err)) {
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001938 free(data);
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001939 return 0;
1940 }
1941
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001942 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001943 /* index pattern */
1944 if (!expr->pat_head->index(expr, &pattern, err)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001945 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001946 free(data);
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001947 return 0;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001948 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001949 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001950
1951 return 1;
1952}
1953
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001954/* This function adds entry to <ref>. It can failed with memory error. The new
1955 * entry is added at all the pattern_expr registered in this reference. The
1956 * function stop on the first error encountered. It returns 0 and err is
1957 * filled. If an error is encountered, the complete add operation is cancelled.
1958 * If the insertion is a success the function returns 1.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001959 */
1960int pat_ref_add(struct pat_ref *ref,
1961 const char *pattern, const char *sample,
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001962 char **err)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001963{
1964 struct pat_ref_elt *elt;
1965 struct pattern_expr *expr;
1966
1967 elt = malloc(sizeof(*elt));
1968 if (!elt) {
1969 memprintf(err, "out of memory error");
1970 return 0;
1971 }
1972
1973 elt->line = -1;
1974
1975 elt->pattern = strdup(pattern);
1976 if (!elt->pattern) {
1977 free(elt);
1978 memprintf(err, "out of memory error");
1979 return 0;
1980 }
1981
1982 if (sample) {
1983 elt->sample = strdup(sample);
1984 if (!elt->sample) {
1985 free(elt->pattern);
1986 free(elt);
1987 memprintf(err, "out of memory error");
1988 return 0;
1989 }
1990 }
1991 else
1992 elt->sample = NULL;
1993
Emeric Brun8d85aa42017-06-29 15:40:33 +02001994 LIST_INIT(&elt->back_refs);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001995 LIST_ADDQ(&ref->head, &elt->list);
1996
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01001997 list_for_each_entry(expr, &ref->pat, list) {
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001998 if (!pat_ref_push(elt, expr, 0, err)) {
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001999 /* If the insertion fails, try to delete all the added entries. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01002000 pat_ref_delete_by_id(ref, elt);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002001 return 0;
2002 }
2003 }
Emeric Brunb5997f72017-07-03 11:34:05 +02002004
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002005 return 1;
2006}
2007
Joseph Herlant4189d672018-11-15 10:22:31 -08002008/* This function prunes <ref>, replaces all references by the references
2009 * of <replace>, and reindexes all the news values.
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002010 *
Joseph Herlant4189d672018-11-15 10:22:31 -08002011 * The patterns are loaded in best effort and the errors are ignored,
2012 * but written in the logs.
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002013 */
2014void pat_ref_reload(struct pat_ref *ref, struct pat_ref *replace)
2015{
2016 struct pattern_expr *expr;
Emeric Brunb5997f72017-07-03 11:34:05 +02002017 struct pat_ref_elt *elt, *safe;
2018 struct bref *bref, *back;
Emeric Brunb5997f72017-07-03 11:34:05 +02002019 struct pattern pattern;
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002020
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002021
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002022 HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
Emeric Brunb5997f72017-07-03 11:34:05 +02002023 list_for_each_entry(expr, &ref->pat, list) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002024 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
Emeric Brunb5997f72017-07-03 11:34:05 +02002025 }
2026
2027 /* all expr are locked, we can safely remove all pat_ref */
2028 list_for_each_entry_safe(elt, safe, &ref->head, list) {
2029 list_for_each_entry_safe(bref, back, &elt->back_refs, users) {
2030 /*
2031 * we have to unlink all watchers. We must not relink them if
2032 * this elt was the last one in the list.
2033 */
2034 LIST_DEL(&bref->users);
2035 LIST_INIT(&bref->users);
2036 if (elt->list.n != &ref->head)
Willy Tarreau49ee3b22019-04-30 11:43:43 +02002037 LIST_ADDQ(&LIST_ELEM(elt->list.n, typeof(elt), list)->back_refs, &bref->users);
Emeric Brunb5997f72017-07-03 11:34:05 +02002038 bref->ref = elt->list.n;
2039 }
2040 LIST_DEL(&elt->list);
2041 free(elt->pattern);
2042 free(elt->sample);
2043 free(elt);
2044 }
2045
2046 /* switch pat_ret_elt lists */
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002047 LIST_ADD(&replace->head, &ref->head);
2048 LIST_DEL(&replace->head);
2049
Emeric Brunb5997f72017-07-03 11:34:05 +02002050 list_for_each_entry(expr, &ref->pat, list) {
2051 expr->pat_head->prune(expr);
2052 list_for_each_entry(elt, &ref->head, list) {
Dragan Dosenf1474792018-09-18 20:18:09 +02002053 char *err = NULL;
2054 struct sample_data *data = NULL;
2055
Emeric Brunb5997f72017-07-03 11:34:05 +02002056 /* Create sample */
2057 if (elt->sample && expr->pat_head->parse_smp) {
2058 /* New sample. */
2059 data = malloc(sizeof(*data));
2060 if (!data)
2061 continue;
2062
2063 /* Parse value. */
2064 if (!expr->pat_head->parse_smp(elt->sample, data)) {
2065 memprintf(&err, "unable to parse '%s'", elt->sample);
2066 send_log(NULL, LOG_NOTICE, "%s", err);
2067 free(err);
2068 free(data);
2069 continue;
2070 }
2071
2072 }
Emeric Brunb5997f72017-07-03 11:34:05 +02002073
2074 /* initialise pattern */
2075 memset(&pattern, 0, sizeof(pattern));
2076 pattern.data = data;
2077 pattern.ref = elt;
2078
2079 /* parse pattern */
2080 if (!expr->pat_head->parse(elt->pattern, &pattern, expr->mflags, &err)) {
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002081 send_log(NULL, LOG_NOTICE, "%s", err);
2082 free(err);
Emeric Brunb5997f72017-07-03 11:34:05 +02002083 free(data);
2084 continue;
2085 }
2086
2087 /* index pattern */
2088 if (!expr->pat_head->index(expr, &pattern, &err)) {
2089 send_log(NULL, LOG_NOTICE, "%s", err);
2090 free(err);
2091 free(data);
2092 continue;
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002093 }
2094 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002095 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002096 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002097 HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002098}
2099
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002100/* This function prune all entries of <ref>. This function
Willy Tarreaud1d005d2019-12-20 18:22:02 +01002101 * prunes the associated pattern_expr. It may return before the end of
2102 * the list is reached, returning 0, to yield. The caller must call it
2103 * again. Otherwise it returns 1 once done.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002104 */
Willy Tarreaud1d005d2019-12-20 18:22:02 +01002105int pat_ref_prune(struct pat_ref *ref)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002106{
2107 struct pat_ref_elt *elt, *safe;
2108 struct pattern_expr *expr;
Emeric Brun8d85aa42017-06-29 15:40:33 +02002109 struct bref *bref, *back;
Willy Tarreaud1d005d2019-12-20 18:22:02 +01002110 int loops = 0;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002111
Emeric Brunb5997f72017-07-03 11:34:05 +02002112 list_for_each_entry(expr, &ref->pat, list) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002113 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
Emeric Brunb5997f72017-07-03 11:34:05 +02002114 expr->pat_head->prune(expr);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002115 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Willy Tarreaud1d005d2019-12-20 18:22:02 +01002116 loops++;
2117 /* yield often, some lists may be huge, especially those
2118 * having to be freed through free_pattern_tree()
2119 */
2120 if (loops > 10)
2121 return 0;
Emeric Brunb5997f72017-07-03 11:34:05 +02002122 }
2123
2124 /* we trash pat_ref_elt in a second time to ensure that data is
2125 free once there is no ref on it */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002126 list_for_each_entry_safe(elt, safe, &ref->head, list) {
Emeric Brun8d85aa42017-06-29 15:40:33 +02002127 list_for_each_entry_safe(bref, back, &elt->back_refs, users) {
2128 /*
2129 * we have to unlink all watchers. We must not relink them if
2130 * this elt was the last one in the list.
2131 */
2132 LIST_DEL(&bref->users);
2133 LIST_INIT(&bref->users);
2134 if (elt->list.n != &ref->head)
Willy Tarreau49ee3b22019-04-30 11:43:43 +02002135 LIST_ADDQ(&LIST_ELEM(elt->list.n, typeof(elt), list)->back_refs, &bref->users);
Emeric Brun8d85aa42017-06-29 15:40:33 +02002136 bref->ref = elt->list.n;
2137 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002138 LIST_DEL(&elt->list);
2139 free(elt->pattern);
2140 free(elt->sample);
2141 free(elt);
Willy Tarreaud1d005d2019-12-20 18:22:02 +01002142 loops++;
2143 if (loops > 100000)
2144 return 0;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002145 }
Willy Tarreaud1d005d2019-12-20 18:22:02 +01002146 return 1;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002147}
2148
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002149/* This function lookup for existing reference <ref> in pattern_head <head>. */
2150struct pattern_expr *pattern_lookup_expr(struct pattern_head *head, struct pat_ref *ref)
2151{
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002152 struct pattern_expr_list *expr;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002153
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002154 list_for_each_entry(expr, &head->head, list)
2155 if (expr->expr->ref == ref)
2156 return expr->expr;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002157 return NULL;
2158}
2159
Joseph Herlant4189d672018-11-15 10:22:31 -08002160/* This function creates new pattern_expr associated to the reference <ref>.
2161 * <ref> can be NULL. If an error occurs, the function returns NULL and
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002162 * <err> is filled. Otherwise, the function returns new pattern_expr linked
2163 * with <head> and <ref>.
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002164 *
Joseph Herlant4189d672018-11-15 10:22:31 -08002165 * The returned value can be an already filled pattern list, in this case the
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002166 * flag <reuse> is set.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002167 */
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002168struct pattern_expr *pattern_new_expr(struct pattern_head *head, struct pat_ref *ref,
Emeric Brun7d27f3c2017-07-03 17:54:23 +02002169 int patflags, char **err, int *reuse)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002170{
2171 struct pattern_expr *expr;
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002172 struct pattern_expr_list *list;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002173
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002174 if (reuse)
2175 *reuse = 0;
2176
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002177 /* Memory and initialization of the chain element. */
2178 list = malloc(sizeof(*list));
2179 if (!list) {
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002180 memprintf(err, "out of memory");
2181 return NULL;
2182 }
2183
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002184 /* Look for existing similar expr. No that only the index, parse and
2185 * parse_smp function must be identical for having similar pattern.
Joseph Herlant4189d672018-11-15 10:22:31 -08002186 * The other function depends of these first.
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002187 */
2188 if (ref) {
2189 list_for_each_entry(expr, &ref->pat, list)
2190 if (expr->pat_head->index == head->index &&
2191 expr->pat_head->parse == head->parse &&
Emeric Brun7d27f3c2017-07-03 17:54:23 +02002192 expr->pat_head->parse_smp == head->parse_smp &&
2193 expr->mflags == patflags)
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002194 break;
2195 if (&expr->list == &ref->pat)
2196 expr = NULL;
2197 }
2198 else
2199 expr = NULL;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002200
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002201 /* If no similar expr was found, we create new expr. */
2202 if (!expr) {
2203 /* Get a lot of memory for the expr struct. */
2204 expr = malloc(sizeof(*expr));
2205 if (!expr) {
Andreas Seltenreiche6e22e82016-03-03 20:20:23 +01002206 free(list);
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002207 memprintf(err, "out of memory");
2208 return NULL;
2209 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002210
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002211 /* Initialize this new expr. */
2212 pattern_init_expr(expr);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002213
Emeric Brun7d27f3c2017-07-03 17:54:23 +02002214 /* Copy the pattern matching and indexing flags. */
2215 expr->mflags = patflags;
2216
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002217 /* This new pattern expression reference one of his heads. */
2218 expr->pat_head = head;
2219
2220 /* Link with ref, or to self to facilitate LIST_DEL() */
2221 if (ref)
2222 LIST_ADDQ(&ref->pat, &expr->list);
2223 else
2224 LIST_INIT(&expr->list);
2225
2226 expr->ref = ref;
2227
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002228 HA_RWLOCK_INIT(&expr->lock);
Emeric Brunb5997f72017-07-03 11:34:05 +02002229
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002230 /* We must free this pattern if it is no more used. */
2231 list->do_free = 1;
2232 }
2233 else {
2234 /* If the pattern used already exists, it is already linked
2235 * with ref and we must not free it.
2236 */
2237 list->do_free = 0;
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002238 if (reuse)
2239 *reuse = 1;
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002240 }
2241
2242 /* The new list element reference the pattern_expr. */
2243 list->expr = expr;
2244
2245 /* Link the list element with the pattern_head. */
2246 LIST_ADDQ(&head->head, &list->list);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002247 return expr;
2248}
2249
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002250/* Reads patterns from a file. If <err_msg> is non-NULL, an error message will
2251 * be returned there on errors and the caller will have to free it.
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002252 *
2253 * The file contains one key + value per line. Lines which start with '#' are
2254 * ignored, just like empty lines. Leading tabs/spaces are stripped. The key is
2255 * then the first "word" (series of non-space/tabs characters), and the value is
2256 * what follows this series of space/tab till the end of the line excluding
2257 * trailing spaces/tabs.
2258 *
2259 * Example :
2260 *
2261 * # this is a comment and is ignored
2262 * 62.212.114.60 1wt.eu \n
2263 * <-><-----------><---><----><---->
2264 * | | | | `--- trailing spaces ignored
2265 * | | | `-------- value
2266 * | | `--------------- middle spaces ignored
2267 * | `------------------------ key
2268 * `-------------------------------- leading spaces ignored
2269 *
2270 * Return non-zero in case of succes, otherwise 0.
2271 */
2272int pat_ref_read_from_file_smp(struct pat_ref *ref, const char *filename, char **err)
2273{
2274 FILE *file;
2275 char *c;
2276 int ret = 0;
2277 int line = 0;
2278 char *key_beg;
2279 char *key_end;
2280 char *value_beg;
2281 char *value_end;
2282
2283 file = fopen(filename, "r");
2284 if (!file) {
2285 memprintf(err, "failed to open pattern file <%s>", filename);
2286 return 0;
2287 }
2288
2289 /* now parse all patterns. The file may contain only one pattern
2290 * followed by one value per line. The start spaces, separator spaces
2291 * and and spaces are stripped. Each can contain comment started by '#'
2292 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002293 while (fgets(trash.area, trash.size, file) != NULL) {
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002294 line++;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002295 c = trash.area;
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002296
2297 /* ignore lines beginning with a dash */
2298 if (*c == '#')
2299 continue;
2300
2301 /* strip leading spaces and tabs */
2302 while (*c == ' ' || *c == '\t')
2303 c++;
2304
2305 /* empty lines are ignored too */
2306 if (*c == '\0' || *c == '\r' || *c == '\n')
2307 continue;
2308
2309 /* look for the end of the key */
2310 key_beg = c;
2311 while (*c && *c != ' ' && *c != '\t' && *c != '\n' && *c != '\r')
2312 c++;
2313
2314 key_end = c;
2315
2316 /* strip middle spaces and tabs */
2317 while (*c == ' ' || *c == '\t')
2318 c++;
2319
2320 /* look for the end of the value, it is the end of the line */
2321 value_beg = c;
2322 while (*c && *c != '\n' && *c != '\r')
2323 c++;
2324 value_end = c;
2325
2326 /* trim possibly trailing spaces and tabs */
2327 while (value_end > value_beg && (value_end[-1] == ' ' || value_end[-1] == '\t'))
2328 value_end--;
2329
2330 /* set final \0 and check entries */
2331 *key_end = '\0';
2332 *value_end = '\0';
2333
2334 /* insert values */
2335 if (!pat_ref_append(ref, key_beg, value_beg, line)) {
2336 memprintf(err, "out of memory");
2337 goto out_close;
2338 }
2339 }
2340
Jerome Magnin3c79d4b2020-01-17 16:09:33 +01002341 if (ferror(file)) {
2342 memprintf(err, "error encountered while reading <%s> : %s",
2343 filename, strerror(errno));
2344 goto out_close;
2345 }
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002346 /* succes */
2347 ret = 1;
2348
2349 out_close:
2350 fclose(file);
2351 return ret;
2352}
2353
2354/* Reads patterns from a file. If <err_msg> is non-NULL, an error message will
2355 * be returned there on errors and the caller will have to free it.
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002356 */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002357int pat_ref_read_from_file(struct pat_ref *ref, const char *filename, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002358{
2359 FILE *file;
2360 char *c;
2361 char *arg;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002362 int ret = 0;
2363 int line = 0;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002364
2365 file = fopen(filename, "r");
2366 if (!file) {
2367 memprintf(err, "failed to open pattern file <%s>", filename);
2368 return 0;
2369 }
2370
2371 /* now parse all patterns. The file may contain only one pattern per
2372 * line. If the line contains spaces, they will be part of the pattern.
2373 * The pattern stops at the first CR, LF or EOF encountered.
2374 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002375 while (fgets(trash.area, trash.size, file) != NULL) {
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002376 line++;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002377 c = trash.area;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002378
2379 /* ignore lines beginning with a dash */
2380 if (*c == '#')
2381 continue;
2382
2383 /* strip leading spaces and tabs */
2384 while (*c == ' ' || *c == '\t')
2385 c++;
2386
2387
2388 arg = c;
2389 while (*c && *c != '\n' && *c != '\r')
2390 c++;
2391 *c = 0;
2392
2393 /* empty lines are ignored too */
2394 if (c == arg)
2395 continue;
2396
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002397 if (!pat_ref_append(ref, arg, NULL, line)) {
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002398 memprintf(err, "out of memory when loading patterns from file <%s>", filename);
2399 goto out_close;
2400 }
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002401 }
2402
Jerome Magnin3c79d4b2020-01-17 16:09:33 +01002403 if (ferror(file)) {
2404 memprintf(err, "error encountered while reading <%s> : %s",
2405 filename, strerror(errno));
2406 goto out_close;
2407 }
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002408 ret = 1; /* success */
2409
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002410 out_close:
2411 fclose(file);
2412 return ret;
2413}
2414
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002415int pattern_read_from_file(struct pattern_head *head, unsigned int refflags,
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002416 const char *filename, int patflags, int load_smp,
Thierry FOURNIER94580c92014-02-11 14:36:45 +01002417 char **err, const char *file, int line)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002418{
2419 struct pat_ref *ref;
2420 struct pattern_expr *expr;
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002421 struct pat_ref_elt *elt;
Willy Tarreau4deaf392014-11-26 13:17:03 +01002422 int reuse = 0;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002423
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002424 /* Lookup for the existing reference. */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002425 ref = pat_ref_lookup(filename);
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002426
2427 /* If the reference doesn't exists, create it and load associated file. */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002428 if (!ref) {
Thierry FOURNIER94580c92014-02-11 14:36:45 +01002429 chunk_printf(&trash,
2430 "pattern loaded from file '%s' used by %s at file '%s' line %d",
2431 filename, refflags & PAT_REF_MAP ? "map" : "acl", file, line);
2432
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002433 ref = pat_ref_new(filename, trash.area, refflags);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002434 if (!ref) {
2435 memprintf(err, "out of memory");
2436 return 0;
2437 }
2438
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002439 if (load_smp) {
Thierry FOURNIERc0bd9102014-01-29 12:32:58 +01002440 ref->flags |= PAT_REF_SMP;
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002441 if (!pat_ref_read_from_file_smp(ref, filename, err))
2442 return 0;
2443 }
2444 else {
2445 if (!pat_ref_read_from_file(ref, filename, err))
2446 return 0;
2447 }
2448 }
2449 else {
Thierry FOURNIERc0bd9102014-01-29 12:32:58 +01002450 /* The reference already exists, check the map compatibility. */
2451
2452 /* If the load require samples and the flag PAT_REF_SMP is not set,
2453 * the reference doesn't contain sample, and cannot be used.
2454 */
2455 if (load_smp) {
2456 if (!(ref->flags & PAT_REF_SMP)) {
2457 memprintf(err, "The file \"%s\" is already used as one column file "
2458 "and cannot be used by as two column file.",
2459 filename);
2460 return 0;
2461 }
2462 }
2463 else {
2464 /* The load doesn't require samples. If the flag PAT_REF_SMP is
2465 * set, the reference contains a sample, and cannot be used.
2466 */
2467 if (ref->flags & PAT_REF_SMP) {
2468 memprintf(err, "The file \"%s\" is already used as two column file "
2469 "and cannot be used by as one column file.",
2470 filename);
2471 return 0;
2472 }
2473 }
2474
Thierry FOURNIER94580c92014-02-11 14:36:45 +01002475 /* Extends display */
2476 chunk_printf(&trash, "%s", ref->display);
2477 chunk_appendf(&trash, ", by %s at file '%s' line %d",
2478 refflags & PAT_REF_MAP ? "map" : "acl", file, line);
2479 free(ref->display);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002480 ref->display = strdup(trash.area);
Thierry FOURNIER94580c92014-02-11 14:36:45 +01002481 if (!ref->display) {
2482 memprintf(err, "out of memory");
2483 return 0;
2484 }
2485
Thierry FOURNIERc0bd9102014-01-29 12:32:58 +01002486 /* Merge flags. */
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002487 ref->flags |= refflags;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002488 }
2489
2490 /* Now, we can loading patterns from the reference. */
2491
2492 /* Lookup for existing reference in the head. If the reference
2493 * doesn't exists, create it.
2494 */
2495 expr = pattern_lookup_expr(head, ref);
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02002496 if (!expr || (expr->mflags != patflags)) {
Emeric Brun7d27f3c2017-07-03 17:54:23 +02002497 expr = pattern_new_expr(head, ref, patflags, err, &reuse);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002498 if (!expr)
2499 return 0;
2500 }
2501
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002502 /* The returned expression may be not empty, because the function
2503 * "pattern_new_expr" lookup for similar pattern list and can
2504 * reuse a already filled pattern list. In this case, we can not
2505 * reload the patterns.
2506 */
2507 if (reuse)
2508 return 1;
2509
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002510 /* Load reference content in the pattern expression. */
2511 list_for_each_entry(elt, &ref->head, list) {
2512 if (!pat_ref_push(elt, expr, patflags, err)) {
2513 if (elt->line > 0)
2514 memprintf(err, "%s at line %d of file '%s'",
2515 *err, elt->line, filename);
2516 return 0;
2517 }
2518 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002519
2520 return 1;
2521}
2522
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +01002523/* This function executes a pattern match on a sample. It applies pattern <expr>
2524 * to sample <smp>. The function returns NULL if the sample dont match. It returns
2525 * non-null if the sample match. If <fill> is true and the sample match, the
2526 * function returns the matched pattern. In many cases, this pattern can be a
2527 * static buffer.
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002528 */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002529struct pattern *pattern_exec_match(struct pattern_head *head, struct sample *smp, int fill)
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002530{
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002531 struct pattern_expr_list *list;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002532 struct pattern *pat;
2533
2534 if (!head->match) {
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +01002535 if (fill) {
Thierry FOURNIER503bb092015-08-19 08:35:43 +02002536 static_pattern.data = NULL;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01002537 static_pattern.ref = NULL;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02002538 static_pattern.sflags = 0;
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002539 static_pattern.type = SMP_T_SINT;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01002540 static_pattern.val.i = 1;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +01002541 }
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +01002542 return &static_pattern;
2543 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002544
Thierry FOURNIER5d344082014-01-27 14:19:53 +01002545 /* convert input to string */
2546 if (!sample_convert(smp, head->expect_type))
2547 return NULL;
2548
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002549 list_for_each_entry(list, &head->head, list) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002550 HA_RWLOCK_RDLOCK(PATEXP_LOCK, &list->expr->lock);
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002551 pat = head->match(smp, list->expr, fill);
Emeric Brunb5997f72017-07-03 11:34:05 +02002552 if (pat) {
2553 /* We duplicate the pattern cause it could be modified
2554 by another thread */
2555 if (pat != &static_pattern) {
2556 memcpy(&static_pattern, pat, sizeof(struct pattern));
2557 pat = &static_pattern;
2558 }
2559
2560 /* We also duplicate the sample data for
2561 same reason */
2562 if (pat->data && (pat->data != &static_sample_data)) {
Christopher Faulet09fdf4b2017-11-09 16:14:16 +01002563 switch(pat->data->type) {
Emeric Brunb5997f72017-07-03 11:34:05 +02002564 case SMP_T_STR:
2565 static_sample_data.type = SMP_T_STR;
2566 static_sample_data.u.str = *get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002567 static_sample_data.u.str.data = pat->data->u.str.data;
2568 if (static_sample_data.u.str.data >= static_sample_data.u.str.size)
2569 static_sample_data.u.str.data = static_sample_data.u.str.size - 1;
2570 memcpy(static_sample_data.u.str.area,
Willy Tarreau2fc761e2020-06-11 16:37:35 +02002571 pat->data->u.str.area, static_sample_data.u.str.data);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002572 static_sample_data.u.str.area[static_sample_data.u.str.data] = 0;
Willy Tarreau2fc761e2020-06-11 16:37:35 +02002573 pat->data = &static_sample_data;
2574 break;
2575
Emeric Brunb5997f72017-07-03 11:34:05 +02002576 case SMP_T_IPV4:
2577 case SMP_T_IPV6:
2578 case SMP_T_SINT:
2579 memcpy(&static_sample_data, pat->data, sizeof(struct sample_data));
Willy Tarreau2fc761e2020-06-11 16:37:35 +02002580 pat->data = &static_sample_data;
2581 break;
Emeric Brunb5997f72017-07-03 11:34:05 +02002582 default:
Willy Tarreau2fc761e2020-06-11 16:37:35 +02002583 /* unimplemented pattern type */
Emeric Brunb5997f72017-07-03 11:34:05 +02002584 pat->data = NULL;
Willy Tarreau2fc761e2020-06-11 16:37:35 +02002585 break;
Emeric Brunb5997f72017-07-03 11:34:05 +02002586 }
Emeric Brunb5997f72017-07-03 11:34:05 +02002587 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002588 HA_RWLOCK_RDUNLOCK(PATEXP_LOCK, &list->expr->lock);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002589 return pat;
Emeric Brunb5997f72017-07-03 11:34:05 +02002590 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002591 HA_RWLOCK_RDUNLOCK(PATEXP_LOCK, &list->expr->lock);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002592 }
2593 return NULL;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002594}
2595
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01002596/* This function prune the pattern expression. */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002597void pattern_prune(struct pattern_head *head)
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01002598{
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002599 struct pattern_expr_list *list, *safe;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002600
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002601 list_for_each_entry_safe(list, safe, &head->head, list) {
2602 LIST_DEL(&list->list);
2603 if (list->do_free) {
2604 LIST_DEL(&list->expr->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002605 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &list->expr->lock);
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002606 head->prune(list->expr);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002607 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &list->expr->lock);
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002608 free(list->expr);
2609 }
2610 free(list);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002611 }
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01002612}
2613
Thierry FOURNIER55d0b102014-01-15 11:25:26 +01002614/* This function lookup for a pattern matching the <key> and return a
2615 * pointer to a pointer of the sample stoarge. If the <key> dont match,
2616 * the function returns NULL. If the key cannot be parsed, the function
2617 * fill <err>.
2618 */
Thierry FOURNIER12ba0c22015-08-14 00:02:11 +02002619struct sample_data **pattern_find_smp(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIER55d0b102014-01-15 11:25:26 +01002620{
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002621 struct ebmb_node *node;
2622 struct pattern_tree *elt;
2623 struct pattern_list *pat;
Thierry FOURNIER55d0b102014-01-15 11:25:26 +01002624
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002625 for (node = ebmb_first(&expr->pattern_tree);
2626 node;
2627 node = ebmb_next(node)) {
2628 elt = container_of(node, struct pattern_tree, node);
2629 if (elt->ref == ref)
Thierry FOURNIER503bb092015-08-19 08:35:43 +02002630 return &elt->data;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002631 }
2632
2633 for (node = ebmb_first(&expr->pattern_tree_2);
2634 node;
2635 node = ebmb_next(node)) {
2636 elt = container_of(node, struct pattern_tree, node);
2637 if (elt->ref == ref)
Thierry FOURNIER503bb092015-08-19 08:35:43 +02002638 return &elt->data;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002639 }
2640
2641 list_for_each_entry(pat, &expr->patterns, list)
2642 if (pat->pat.ref == ref)
Thierry FOURNIER503bb092015-08-19 08:35:43 +02002643 return &pat->pat.data;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002644
2645 return NULL;
Thierry FOURNIER55d0b102014-01-15 11:25:26 +01002646}
2647
Thierry FOURNIERb1136502014-01-15 11:38:49 +01002648/* This function search all the pattern matching the <key> and delete it.
2649 * If the parsing of the input key fails, the function returns 0 and the
2650 * <err> is filled, else return 1;
2651 */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01002652int pattern_delete(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01002653{
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002654 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01002655 expr->pat_head->delete(expr, ref);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002656 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01002657 return 1;
2658}
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002659
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002660/* This function compares two pat_ref** on unique_id */
2661static int cmp_pat_ref(const void *_a, const void *_b)
2662{
2663 struct pat_ref * const *a = _a;
2664 struct pat_ref * const *b = _b;
2665
2666 if ((*a)->unique_id < (*b)->unique_id)
2667 return -1;
2668 else if ((*a)->unique_id > (*b)->unique_id)
2669 return 1;
2670 return 0;
2671}
2672
2673/* This function finalize the configuration parsing. It sets all the
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002674 * automatic ids
2675 */
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002676int pattern_finalize_config(void)
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002677{
Tim Duesterhusb584b442020-03-17 21:08:24 +01002678 size_t len = 0;
2679 size_t unassigned_pos = 0;
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002680 int next_unique_id = 0;
Tim Duesterhusb584b442020-03-17 21:08:24 +01002681 size_t i, j;
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002682 struct pat_ref *ref, **arr;
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002683 struct list pr = LIST_HEAD_INIT(pr);
2684
Willy Tarreau52bf8392020-03-08 00:42:37 +01002685 pat_lru_seed = ha_random();
Willy Tarreauf3045d22015-04-29 16:24:50 +02002686
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002687 /* Count pat_refs with user defined unique_id and totalt count */
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002688 list_for_each_entry(ref, &pattern_reference, list) {
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002689 len++;
2690 if (ref->unique_id != -1)
2691 unassigned_pos++;
2692 }
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002693
Tim Duesterhusb584b442020-03-17 21:08:24 +01002694 if (len == 0) {
2695 return 0;
2696 }
2697
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002698 arr = calloc(len, sizeof(*arr));
2699 if (arr == NULL) {
2700 ha_alert("Out of memory error.\n");
2701 return ERR_ALERT | ERR_FATAL;
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002702 }
2703
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002704 i = 0;
2705 j = unassigned_pos;
2706 list_for_each_entry(ref, &pattern_reference, list) {
2707 if (ref->unique_id != -1)
2708 arr[i++] = ref;
2709 else
2710 arr[j++] = ref;
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002711 }
2712
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002713 /* Sort first segment of array with user-defined unique ids for
2714 * fast lookup when generating unique ids
2715 */
2716 qsort(arr, unassigned_pos, sizeof(*arr), cmp_pat_ref);
2717
2718 /* Assign unique ids to the rest of the elements */
2719 for (i = unassigned_pos; i < len; i++) {
2720 do {
2721 arr[i]->unique_id = next_unique_id++;
2722 } while (bsearch(&arr[i], arr, unassigned_pos, sizeof(*arr), cmp_pat_ref));
2723 }
2724
2725 /* Sort complete array */
2726 qsort(arr, len, sizeof(*arr), cmp_pat_ref);
2727
2728 /* Convert back to linked list */
2729 for (i = 0; i < len; i++)
2730 LIST_ADDQ(&pr, &arr[i]->list);
2731
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002732 /* swap root */
2733 LIST_ADD(&pr, &pattern_reference);
2734 LIST_DEL(&pr);
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002735
2736 free(arr);
2737 return 0;
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002738}
Willy Tarreau403bfbb2019-10-23 06:59:31 +02002739
2740static int pattern_per_thread_lru_alloc()
2741{
2742 if (!global.tune.pattern_cache)
2743 return 1;
2744 pat_lru_tree = lru64_new(global.tune.pattern_cache);
2745 return !!pat_lru_tree;
2746}
2747
2748static void pattern_per_thread_lru_free()
2749{
2750 lru64_destroy(pat_lru_tree);
2751}
2752
2753REGISTER_PER_THREAD_ALLOC(pattern_per_thread_lru_alloc);
2754REGISTER_PER_THREAD_FREE(pattern_per_thread_lru_free);