blob: e4a1e2785b5bdc49e60450a688b45d1e44ba64ad [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;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100456 struct pattern_tree *elt;
457 struct pattern_list *lst;
458 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200459 struct pattern *ret = NULL;
460 struct lru64 *lru = NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100461
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100462 /* Lookup a string in the expression's pattern tree. */
463 if (!eb_is_empty(&expr->pattern_tree)) {
Christopher Fauletb4cf7ab2020-06-30 18:52:32 +0200464 char prev = 0;
465
466 if (smp->data.u.str.data < smp->data.u.str.size) {
467 /* we may have to force a trailing zero on the test pattern and
468 * the buffer is large enough to accommodate it.
469 */
470 prev = smp->data.u.str.area[smp->data.u.str.data];
471 if (prev)
472 smp->data.u.str.area[smp->data.u.str.data] = '\0';
473 }
474 else {
475 /* Otherwise, the sample is duplicated. A trailing zero
476 * is automatically added to the string.
477 */
478 if (!smp_dup(smp))
479 return NULL;
480 }
481
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200482 node = ebst_lookup(&expr->pattern_tree, smp->data.u.str.area);
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100483 if (prev)
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200484 smp->data.u.str.area[smp->data.u.str.data] = prev;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100485 if (node) {
486 if (fill) {
487 elt = ebmb_entry(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200488 static_pattern.data = elt->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +0100489 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200490 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100491 static_pattern.type = SMP_T_STR;
492 static_pattern.ptr.str = (char *)elt->node.key;
493 }
494 return &static_pattern;
495 }
496 }
497
498 /* look in the list */
Willy Tarreauf3045d22015-04-29 16:24:50 +0200499 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200500 unsigned long long seed = pat_lru_seed ^ (long)expr;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200501
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200502 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreau3ee0de12020-11-02 15:26:51 +0100503 pat_lru_tree, expr, expr->ref->revision);
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200504 if (lru && lru->domain) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200505 ret = lru->data;
Emeric Brunb5997f72017-07-03 11:34:05 +0200506 return ret;
507 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200508 }
509
Emeric Brunb5997f72017-07-03 11:34:05 +0200510
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100511 list_for_each_entry(lst, &expr->patterns, list) {
512 pattern = &lst->pat;
513
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200514 if (pattern->len != smp->data.u.str.data)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100515 continue;
516
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200517 icase = expr->mflags & PAT_MF_IGNORE_CASE;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200518 if ((icase && strncasecmp(pattern->ptr.str, smp->data.u.str.area, smp->data.u.str.data) == 0) ||
519 (!icase && strncmp(pattern->ptr.str, smp->data.u.str.area, smp->data.u.str.data) == 0)) {
Willy Tarreauf3045d22015-04-29 16:24:50 +0200520 ret = pattern;
521 break;
522 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100523 }
524
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200525 if (lru)
Willy Tarreau3ee0de12020-11-02 15:26:51 +0100526 lru64_commit(lru, ret, expr, expr->ref->revision, NULL);
Willy Tarreauf3045d22015-04-29 16:24:50 +0200527
528 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100529}
530
531/* NB: For two binaries buf to be identical, it is required that their lengths match */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100532struct pattern *pat_match_bin(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100533{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100534 struct pattern_list *lst;
535 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200536 struct pattern *ret = NULL;
537 struct lru64 *lru = NULL;
538
539 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200540 unsigned long long seed = pat_lru_seed ^ (long)expr;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100541
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200542 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreau3ee0de12020-11-02 15:26:51 +0100543 pat_lru_tree, expr, expr->ref->revision);
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200544 if (lru && lru->domain) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200545 ret = lru->data;
Emeric Brunb5997f72017-07-03 11:34:05 +0200546 return ret;
547 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200548 }
549
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100550 list_for_each_entry(lst, &expr->patterns, list) {
551 pattern = &lst->pat;
552
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200553 if (pattern->len != smp->data.u.str.data)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100554 continue;
555
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200556 if (memcmp(pattern->ptr.str, smp->data.u.str.area, smp->data.u.str.data) == 0) {
Willy Tarreauf3045d22015-04-29 16:24:50 +0200557 ret = pattern;
558 break;
559 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100560 }
561
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200562 if (lru)
Willy Tarreau3ee0de12020-11-02 15:26:51 +0100563 lru64_commit(lru, ret, expr, expr->ref->revision, NULL);
Willy Tarreauf3045d22015-04-29 16:24:50 +0200564
565 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100566}
567
568/* Executes a regex. It temporarily changes the data to add a trailing zero,
Thierry Fournier8feaa662016-02-10 22:55:20 +0100569 * and restores the previous character when leaving. This function fills
570 * a matching array.
571 */
572struct pattern *pat_match_regm(struct sample *smp, struct pattern_expr *expr, int fill)
573{
574 struct pattern_list *lst;
575 struct pattern *pattern;
576 struct pattern *ret = NULL;
577
578 list_for_each_entry(lst, &expr->patterns, list) {
579 pattern = &lst->pat;
580
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200581 if (regex_exec_match2(pattern->ptr.reg, smp->data.u.str.area, smp->data.u.str.data,
Thierry Fournier8feaa662016-02-10 22:55:20 +0100582 MAX_MATCH, pmatch, 0)) {
583 ret = pattern;
584 smp->ctx.a[0] = pmatch;
585 break;
586 }
587 }
588
589 return ret;
590}
591
592/* Executes a regex. It temporarily changes the data to add a trailing zero,
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100593 * and restores the previous character when leaving.
594 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100595struct pattern *pat_match_reg(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100596{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100597 struct pattern_list *lst;
598 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200599 struct pattern *ret = NULL;
600 struct lru64 *lru = NULL;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100601
Willy Tarreauf3045d22015-04-29 16:24:50 +0200602 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200603 unsigned long long seed = pat_lru_seed ^ (long)expr;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200604
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200605 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreau3ee0de12020-11-02 15:26:51 +0100606 pat_lru_tree, expr, expr->ref->revision);
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200607 if (lru && lru->domain) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200608 ret = lru->data;
Emeric Brunb5997f72017-07-03 11:34:05 +0200609 return ret;
610 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200611 }
612
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100613 list_for_each_entry(lst, &expr->patterns, list) {
614 pattern = &lst->pat;
615
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200616 if (regex_exec2(pattern->ptr.reg, smp->data.u.str.area, smp->data.u.str.data)) {
Willy Tarreauf3045d22015-04-29 16:24:50 +0200617 ret = pattern;
618 break;
619 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100620 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200621
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200622 if (lru)
Willy Tarreau3ee0de12020-11-02 15:26:51 +0100623 lru64_commit(lru, ret, expr, expr->ref->revision, NULL);
Willy Tarreauf3045d22015-04-29 16:24:50 +0200624
625 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100626}
627
628/* Checks that the pattern matches the beginning of the tested string. */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100629struct pattern *pat_match_beg(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100630{
631 int icase;
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200632 struct ebmb_node *node;
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200633 struct pattern_tree *elt;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100634 struct pattern_list *lst;
635 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200636 struct pattern *ret = NULL;
637 struct lru64 *lru = NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100638
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200639 /* Lookup a string in the expression's pattern tree. */
640 if (!eb_is_empty(&expr->pattern_tree)) {
Christopher Fauletb4cf7ab2020-06-30 18:52:32 +0200641 char prev = 0;
642
643 if (smp->data.u.str.data < smp->data.u.str.size) {
644 /* we may have to force a trailing zero on the test pattern and
645 * the buffer is large enough to accommodate it.
646 */
647 prev = smp->data.u.str.area[smp->data.u.str.data];
648 if (prev)
649 smp->data.u.str.area[smp->data.u.str.data] = '\0';
650 }
651 else {
652 /* Otherwise, the sample is duplicated. A trailing zero
653 * is automatically added to the string.
654 */
655 if (!smp_dup(smp))
656 return NULL;
657 }
658
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200659 node = ebmb_lookup_longest(&expr->pattern_tree,
660 smp->data.u.str.area);
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200661 if (prev)
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200662 smp->data.u.str.area[smp->data.u.str.data] = prev;
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200663
664 if (node) {
665 if (fill) {
666 elt = ebmb_entry(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200667 static_pattern.data = elt->data;
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200668 static_pattern.ref = elt->ref;
669 static_pattern.sflags = PAT_SF_TREE;
670 static_pattern.type = SMP_T_STR;
671 static_pattern.ptr.str = (char *)elt->node.key;
672 }
673 return &static_pattern;
674 }
675 }
676
677 /* look in the list */
Willy Tarreauf3045d22015-04-29 16:24:50 +0200678 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200679 unsigned long long seed = pat_lru_seed ^ (long)expr;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200680
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200681 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreau3ee0de12020-11-02 15:26:51 +0100682 pat_lru_tree, expr, expr->ref->revision);
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200683 if (lru && lru->domain) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200684 ret = lru->data;
Emeric Brunb5997f72017-07-03 11:34:05 +0200685 return ret;
686 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200687 }
688
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100689 list_for_each_entry(lst, &expr->patterns, list) {
690 pattern = &lst->pat;
691
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200692 if (pattern->len > smp->data.u.str.data)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100693 continue;
694
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200695 icase = expr->mflags & PAT_MF_IGNORE_CASE;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200696 if ((icase && strncasecmp(pattern->ptr.str, smp->data.u.str.area, pattern->len) != 0) ||
697 (!icase && strncmp(pattern->ptr.str, smp->data.u.str.area, pattern->len) != 0))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100698 continue;
699
Willy Tarreauf3045d22015-04-29 16:24:50 +0200700 ret = pattern;
701 break;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100702 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200703
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200704 if (lru)
Willy Tarreau3ee0de12020-11-02 15:26:51 +0100705 lru64_commit(lru, ret, expr, expr->ref->revision, NULL);
Willy Tarreauf3045d22015-04-29 16:24:50 +0200706
707 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100708}
709
710/* Checks that the pattern matches the end of the tested string. */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100711struct pattern *pat_match_end(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100712{
713 int icase;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100714 struct pattern_list *lst;
715 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200716 struct pattern *ret = NULL;
717 struct lru64 *lru = NULL;
718
719 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200720 unsigned long long seed = pat_lru_seed ^ (long)expr;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200721
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200722 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreau3ee0de12020-11-02 15:26:51 +0100723 pat_lru_tree, expr, expr->ref->revision);
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200724 if (lru && lru->domain) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200725 ret = lru->data;
Emeric Brunb5997f72017-07-03 11:34:05 +0200726 return ret;
727 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200728 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100729
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100730 list_for_each_entry(lst, &expr->patterns, list) {
731 pattern = &lst->pat;
732
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200733 if (pattern->len > smp->data.u.str.data)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100734 continue;
735
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200736 icase = expr->mflags & PAT_MF_IGNORE_CASE;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200737 if ((icase && strncasecmp(pattern->ptr.str, smp->data.u.str.area + smp->data.u.str.data - pattern->len, pattern->len) != 0) ||
738 (!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 +0100739 continue;
740
Willy Tarreauf3045d22015-04-29 16:24:50 +0200741 ret = pattern;
742 break;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100743 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200744
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200745 if (lru)
Willy Tarreau3ee0de12020-11-02 15:26:51 +0100746 lru64_commit(lru, ret, expr, expr->ref->revision, NULL);
Willy Tarreauf3045d22015-04-29 16:24:50 +0200747
748 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100749}
750
751/* Checks that the pattern is included inside the tested string.
752 * NB: Suboptimal, should be rewritten using a Boyer-Moore method.
753 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100754struct pattern *pat_match_sub(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100755{
756 int icase;
757 char *end;
758 char *c;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100759 struct pattern_list *lst;
760 struct pattern *pattern;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200761 struct pattern *ret = NULL;
762 struct lru64 *lru = NULL;
763
764 if (pat_lru_tree) {
Willy Tarreauaee93142015-05-04 17:18:42 +0200765 unsigned long long seed = pat_lru_seed ^ (long)expr;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200766
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200767 lru = lru64_get(XXH64(smp->data.u.str.area, smp->data.u.str.data, seed),
Willy Tarreau3ee0de12020-11-02 15:26:51 +0100768 pat_lru_tree, expr, expr->ref->revision);
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200769 if (lru && lru->domain) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200770 ret = lru->data;
Emeric Brunb5997f72017-07-03 11:34:05 +0200771 return ret;
772 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200773 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100774
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100775 list_for_each_entry(lst, &expr->patterns, list) {
776 pattern = &lst->pat;
777
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200778 if (pattern->len > smp->data.u.str.data)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100779 continue;
780
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200781 end = smp->data.u.str.area + smp->data.u.str.data - pattern->len;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200782 icase = expr->mflags & PAT_MF_IGNORE_CASE;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100783 if (icase) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200784 for (c = smp->data.u.str.area; c <= end; c++) {
Willy Tarreauf278eec2020-07-05 21:46:32 +0200785 if (tolower((unsigned char)*c) != tolower((unsigned char)*pattern->ptr.str))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100786 continue;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200787 if (strncasecmp(pattern->ptr.str, c, pattern->len) == 0) {
788 ret = pattern;
789 goto leave;
790 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100791 }
792 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200793 for (c = smp->data.u.str.area; c <= end; c++) {
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100794 if (*c != *pattern->ptr.str)
795 continue;
Willy Tarreauf3045d22015-04-29 16:24:50 +0200796 if (strncmp(pattern->ptr.str, c, pattern->len) == 0) {
797 ret = pattern;
798 goto leave;
799 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100800 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100801 }
802 }
Willy Tarreauf3045d22015-04-29 16:24:50 +0200803 leave:
Willy Tarreau403bfbb2019-10-23 06:59:31 +0200804 if (lru)
Willy Tarreau3ee0de12020-11-02 15:26:51 +0100805 lru64_commit(lru, ret, expr, expr->ref->revision, NULL);
Willy Tarreauf3045d22015-04-29 16:24:50 +0200806
807 return ret;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100808}
809
810/* This one is used by other real functions. It checks that the pattern is
811 * included inside the tested string, but enclosed between the specified
812 * delimiters or at the beginning or end of the string. The delimiters are
813 * provided as an unsigned int made by make_4delim() and match up to 4 different
814 * delimiters. Delimiters are stripped at the beginning and end of the pattern.
815 */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200816static int match_word(struct sample *smp, struct pattern *pattern, int mflags, unsigned int delimiters)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100817{
818 int may_match, icase;
819 char *c, *end;
820 char *ps;
821 int pl;
822
823 pl = pattern->len;
824 ps = pattern->ptr.str;
825
826 while (pl > 0 && is_delimiter(*ps, delimiters)) {
827 pl--;
828 ps++;
829 }
830
831 while (pl > 0 && is_delimiter(ps[pl - 1], delimiters))
832 pl--;
833
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200834 if (pl > smp->data.u.str.data)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100835 return PAT_NOMATCH;
836
837 may_match = 1;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200838 icase = mflags & PAT_MF_IGNORE_CASE;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200839 end = smp->data.u.str.area + smp->data.u.str.data - pl;
840 for (c = smp->data.u.str.area; c <= end; c++) {
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100841 if (is_delimiter(*c, delimiters)) {
842 may_match = 1;
843 continue;
844 }
845
846 if (!may_match)
847 continue;
848
849 if (icase) {
Willy Tarreauf278eec2020-07-05 21:46:32 +0200850 if ((tolower((unsigned char)*c) == tolower((unsigned char)*ps)) &&
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100851 (strncasecmp(ps, c, pl) == 0) &&
852 (c == end || is_delimiter(c[pl], delimiters)))
853 return PAT_MATCH;
854 } else {
855 if ((*c == *ps) &&
856 (strncmp(ps, c, pl) == 0) &&
857 (c == end || is_delimiter(c[pl], delimiters)))
858 return PAT_MATCH;
859 }
860 may_match = 0;
861 }
862 return PAT_NOMATCH;
863}
864
865/* Checks that the pattern is included inside the tested string, but enclosed
866 * between the delimiters '?' or '/' or at the beginning or end of the string.
867 * Delimiters at the beginning or end of the pattern are ignored.
868 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100869struct pattern *pat_match_dir(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100870{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100871 struct pattern_list *lst;
872 struct pattern *pattern;
873
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100874 list_for_each_entry(lst, &expr->patterns, list) {
875 pattern = &lst->pat;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200876 if (match_word(smp, pattern, expr->mflags, make_4delim('/', '?', '?', '?')))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100877 return pattern;
878 }
879 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100880}
881
882/* Checks that the pattern is included inside the tested string, but enclosed
883 * between the delmiters '/', '?', '.' or ":" or at the beginning or end of
884 * the string. Delimiters at the beginning or end of the pattern are ignored.
885 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100886struct pattern *pat_match_dom(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100887{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100888 struct pattern_list *lst;
889 struct pattern *pattern;
890
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100891 list_for_each_entry(lst, &expr->patterns, list) {
892 pattern = &lst->pat;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200893 if (match_word(smp, pattern, expr->mflags, make_4delim('/', '?', '.', ':')))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100894 return pattern;
895 }
896 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100897}
898
899/* Checks that the integer in <test> is included between min and max */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100900struct pattern *pat_match_int(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100901{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100902 struct pattern_list *lst;
903 struct pattern *pattern;
904
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100905 list_for_each_entry(lst, &expr->patterns, list) {
906 pattern = &lst->pat;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200907 if ((!pattern->val.range.min_set || pattern->val.range.min <= smp->data.u.sint) &&
908 (!pattern->val.range.max_set || smp->data.u.sint <= pattern->val.range.max))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100909 return pattern;
910 }
911 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100912}
913
914/* Checks that the length of the pattern in <test> is included between min and max */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100915struct pattern *pat_match_len(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100916{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100917 struct pattern_list *lst;
918 struct pattern *pattern;
919
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100920 list_for_each_entry(lst, &expr->patterns, list) {
921 pattern = &lst->pat;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200922 if ((!pattern->val.range.min_set || pattern->val.range.min <= smp->data.u.str.data) &&
923 (!pattern->val.range.max_set || smp->data.u.str.data <= pattern->val.range.max))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100924 return pattern;
925 }
926 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100927}
928
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100929struct pattern *pat_match_ip(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100930{
931 unsigned int v4; /* in network byte order */
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100932 struct in6_addr tmp6;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100933 struct in_addr *s;
934 struct ebmb_node *node;
935 struct pattern_tree *elt;
936 struct pattern_list *lst;
937 struct pattern *pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100938
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100939 /* The input sample is IPv4. Try to match in the trees. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200940 if (smp->data.type == SMP_T_IPV4) {
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100941 /* Lookup an IPv4 address in the expression's pattern tree using
942 * the longest match method.
943 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200944 s = &smp->data.u.ipv4;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100945 node = ebmb_lookup_longest(&expr->pattern_tree, &s->s_addr);
946 if (node) {
947 if (fill) {
948 elt = ebmb_entry(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200949 static_pattern.data = elt->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +0100950 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200951 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100952 static_pattern.type = SMP_T_IPV4;
Willy Tarreau296cfd12020-02-25 09:58:41 +0100953 static_pattern.val.ipv4.addr.s_addr = read_u32(elt->node.key);
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100954 if (!cidr2dotted(elt->node.node.pfx, &static_pattern.val.ipv4.mask))
955 return NULL;
956 }
957 return &static_pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100958 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100959
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100960 /* The IPv4 sample dont match the IPv4 tree. Convert the IPv4
961 * sample address to IPv6 with the mapping method using the ::ffff:
962 * prefix, and try to lookup in the IPv6 tree.
963 */
964 memset(&tmp6, 0, 10);
Willy Tarreau296cfd12020-02-25 09:58:41 +0100965 write_u16(&tmp6.s6_addr[10], htons(0xffff));
966 write_u32(&tmp6.s6_addr[12], smp->data.u.ipv4.s_addr);
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100967 node = ebmb_lookup_longest(&expr->pattern_tree_2, &tmp6);
968 if (node) {
969 if (fill) {
970 elt = ebmb_entry(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200971 static_pattern.data = elt->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +0100972 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200973 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100974 static_pattern.type = SMP_T_IPV6;
Willy Tarreau296cfd12020-02-25 09:58:41 +0100975 memcpy(&static_pattern.val.ipv6.addr, elt->node.key, 16);
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100976 static_pattern.val.ipv6.mask = elt->node.node.pfx;
977 }
978 return &static_pattern;
979 }
980 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100981
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100982 /* The input sample is IPv6. Try to match in the trees. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200983 if (smp->data.type == SMP_T_IPV6) {
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100984 /* Lookup an IPv6 address in the expression's pattern tree using
985 * the longest match method.
986 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200987 node = ebmb_lookup_longest(&expr->pattern_tree_2, &smp->data.u.ipv6);
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100988 if (node) {
989 if (fill) {
990 elt = ebmb_entry(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200991 static_pattern.data = elt->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +0100992 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200993 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100994 static_pattern.type = SMP_T_IPV6;
Willy Tarreau296cfd12020-02-25 09:58:41 +0100995 memcpy(&static_pattern.val.ipv6.addr, elt->node.key, 16);
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100996 static_pattern.val.ipv6.mask = elt->node.node.pfx;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100997 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100998 return &static_pattern;
999 }
1000
1001 /* Try to convert 6 to 4 when the start of the ipv6 address match the
1002 * following forms :
1003 * - ::ffff:ip:v4 (ipv4 mapped)
1004 * - ::0000:ip:v4 (old ipv4 mapped)
1005 * - 2002:ip:v4:: (6to4)
1006 */
Willy Tarreau296cfd12020-02-25 09:58:41 +01001007 if ((read_u64(&smp->data.u.ipv6.s6_addr[0]) == 0 &&
1008 (read_u32(&smp->data.u.ipv6.s6_addr[8]) == 0 ||
1009 read_u32(&smp->data.u.ipv6.s6_addr[8]) == htonl(0xFFFF))) ||
1010 read_u16(&smp->data.u.ipv6.s6_addr[0]) == htons(0x2002)) {
1011 if (read_u32(&smp->data.u.ipv6.s6_addr[0]) == 0)
1012 v4 = read_u32(&smp->data.u.ipv6.s6_addr[12]);
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001013 else
Willy Tarreau296cfd12020-02-25 09:58:41 +01001014 v4 = htonl((ntohs(read_u16(&smp->data.u.ipv6.s6_addr[2])) << 16) +
1015 ntohs(read_u16(&smp->data.u.ipv6.s6_addr[4])));
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001016
1017 /* Lookup an IPv4 address in the expression's pattern tree using the longest
1018 * match method.
1019 */
1020 node = ebmb_lookup_longest(&expr->pattern_tree, &v4);
1021 if (node) {
1022 if (fill) {
1023 elt = ebmb_entry(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001024 static_pattern.data = elt->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001025 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001026 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001027 static_pattern.type = SMP_T_IPV4;
Willy Tarreau296cfd12020-02-25 09:58:41 +01001028 static_pattern.val.ipv4.addr.s_addr = read_u32(elt->node.key);
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001029 if (!cidr2dotted(elt->node.node.pfx, &static_pattern.val.ipv4.mask))
1030 return NULL;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001031 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001032 return &static_pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001033 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001034 }
1035 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001036
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001037 /* Lookup in the list. the list contain only IPv4 patterns */
1038 list_for_each_entry(lst, &expr->patterns, list) {
1039 pattern = &lst->pat;
1040
1041 /* The input sample is IPv4, use it as is. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001042 if (smp->data.type == SMP_T_IPV4) {
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001043 v4 = smp->data.u.ipv4.s_addr;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001044 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001045 else if (smp->data.type == SMP_T_IPV6) {
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001046 /* v4 match on a V6 sample. We want to check at least for
1047 * the following forms :
1048 * - ::ffff:ip:v4 (ipv4 mapped)
1049 * - ::0000:ip:v4 (old ipv4 mapped)
1050 * - 2002:ip:v4:: (6to4)
1051 */
Willy Tarreau296cfd12020-02-25 09:58:41 +01001052 if (read_u64(&smp->data.u.ipv6.s6_addr[0]) == 0 &&
1053 (read_u32(&smp->data.u.ipv6.s6_addr[8]) == 0 ||
1054 read_u32(&smp->data.u.ipv6.s6_addr[8]) == htonl(0xFFFF))) {
1055 v4 = read_u32(&smp->data.u.ipv6.s6_addr[12]);
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001056 }
Willy Tarreau296cfd12020-02-25 09:58:41 +01001057 else if (read_u16(&smp->data.u.ipv6.s6_addr[0]) == htons(0x2002)) {
1058 v4 = htonl((ntohs(read_u16(&smp->data.u.ipv6.s6_addr[2])) << 16) +
1059 ntohs(read_u16(&smp->data.u.ipv6.s6_addr[4])));
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001060 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001061 else
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001062 continue;
Andreas Seltenreichf0653192016-03-03 20:08:35 +01001063 } else {
1064 /* impossible */
1065 continue;
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001066 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001067
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001068 /* Check if the input sample match the current pattern. */
1069 if (((v4 ^ pattern->val.ipv4.addr.s_addr) & pattern->val.ipv4.mask.s_addr) == 0)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001070 return pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001071 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01001072 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +01001073}
1074
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001075void free_pattern_tree(struct eb_root *root)
1076{
1077 struct eb_node *node, *next;
Thierry FOURNIERe1bcac52013-12-13 16:09:50 +01001078 struct pattern_tree *elt;
Thierry FOURNIER3ce88c72013-12-09 11:29:46 +01001079
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001080 node = eb_first(root);
1081 while (node) {
1082 next = eb_next(node);
1083 eb_delete(node);
Thierry FOURNIERe1bcac52013-12-13 16:09:50 +01001084 elt = container_of(node, struct pattern_tree, node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001085 free(elt->data);
Thierry FOURNIER3ce88c72013-12-09 11:29:46 +01001086 free(elt);
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001087 node = next;
1088 }
1089}
1090
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001091void pat_prune_val(struct pattern_expr *expr)
Thierry FOURNIERd163e1c2013-11-28 11:41:23 +01001092{
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001093 struct pattern_list *pat, *tmp;
1094
1095 list_for_each_entry_safe(pat, tmp, &expr->patterns, list) {
Christopher Faulet6cfc8512020-09-09 16:09:44 +02001096 LIST_DEL(&pat->list);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001097 free(pat->pat.data);
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001098 free(pat);
1099 }
1100
Thierry FOURNIERd163e1c2013-11-28 11:41:23 +01001101 free_pattern_tree(&expr->pattern_tree);
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001102 free_pattern_tree(&expr->pattern_tree_2);
Thierry FOURNIERd163e1c2013-11-28 11:41:23 +01001103 LIST_INIT(&expr->patterns);
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001104 expr->ref->revision = rdtsc();
Thierry FOURNIERd163e1c2013-11-28 11:41:23 +01001105}
1106
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001107void pat_prune_ptr(struct pattern_expr *expr)
1108{
1109 struct pattern_list *pat, *tmp;
1110
1111 list_for_each_entry_safe(pat, tmp, &expr->patterns, list) {
Christopher Faulet6cfc8512020-09-09 16:09:44 +02001112 LIST_DEL(&pat->list);
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001113 free(pat->pat.ptr.ptr);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001114 free(pat->pat.data);
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001115 free(pat);
1116 }
1117
1118 free_pattern_tree(&expr->pattern_tree);
1119 free_pattern_tree(&expr->pattern_tree_2);
1120 LIST_INIT(&expr->patterns);
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001121 expr->ref->revision = rdtsc();
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001122}
1123
1124void pat_prune_reg(struct pattern_expr *expr)
1125{
1126 struct pattern_list *pat, *tmp;
1127
1128 list_for_each_entry_safe(pat, tmp, &expr->patterns, list) {
Christopher Faulet6cfc8512020-09-09 16:09:44 +02001129 LIST_DEL(&pat->list);
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001130 regex_free(pat->pat.ptr.ptr);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001131 free(pat->pat.data);
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001132 free(pat);
1133 }
1134
1135 free_pattern_tree(&expr->pattern_tree);
1136 free_pattern_tree(&expr->pattern_tree_2);
1137 LIST_INIT(&expr->patterns);
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001138 expr->ref->revision = rdtsc();
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01001139}
1140
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001141/*
1142 *
1143 * The following functions are used for the pattern indexation
1144 *
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001145 */
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001146
1147int pat_idx_list_val(struct pattern_expr *expr, struct pattern *pat, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001148{
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001149 struct pattern_list *patl;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001150
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001151 /* allocate pattern */
1152 patl = calloc(1, sizeof(*patl));
1153 if (!patl) {
1154 memprintf(err, "out of memory while indexing pattern");
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001155 return 0;
1156 }
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001157
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001158 /* duplicate pattern */
1159 memcpy(&patl->pat, pat, sizeof(*pat));
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001160
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001161 /* chain pattern in the expression */
1162 LIST_ADDQ(&expr->patterns, &patl->list);
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001163 expr->ref->revision = rdtsc();
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001164
1165 /* that's ok */
1166 return 1;
1167}
1168
1169int pat_idx_list_ptr(struct pattern_expr *expr, struct pattern *pat, char **err)
1170{
1171 struct pattern_list *patl;
1172
1173 /* allocate pattern */
1174 patl = calloc(1, sizeof(*patl));
Thierry FOURNIER8aa83842015-02-06 17:50:55 +01001175 if (!patl) {
1176 memprintf(err, "out of memory while indexing pattern");
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001177 return 0;
Thierry FOURNIER8aa83842015-02-06 17:50:55 +01001178 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001179
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001180 /* duplicate pattern */
1181 memcpy(&patl->pat, pat, sizeof(*pat));
1182 patl->pat.ptr.ptr = malloc(patl->pat.len);
1183 if (!patl->pat.ptr.ptr) {
1184 free(patl);
1185 memprintf(err, "out of memory while indexing pattern");
1186 return 0;
1187 }
1188 memcpy(patl->pat.ptr.ptr, pat->ptr.ptr, pat->len);
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001189
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001190 /* chain pattern in the expression */
1191 LIST_ADDQ(&expr->patterns, &patl->list);
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001192 expr->ref->revision = rdtsc();
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001193
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001194 /* that's ok */
1195 return 1;
1196}
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001197
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001198int pat_idx_list_str(struct pattern_expr *expr, struct pattern *pat, char **err)
1199{
1200 struct pattern_list *patl;
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001201
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001202 /* allocate pattern */
1203 patl = calloc(1, sizeof(*patl));
1204 if (!patl) {
1205 memprintf(err, "out of memory while indexing pattern");
1206 return 0;
1207 }
1208
1209 /* duplicate pattern */
1210 memcpy(&patl->pat, pat, sizeof(*pat));
1211 patl->pat.ptr.str = malloc(patl->pat.len + 1);
1212 if (!patl->pat.ptr.str) {
1213 free(patl);
1214 memprintf(err, "out of memory while indexing pattern");
1215 return 0;
1216 }
1217 memcpy(patl->pat.ptr.ptr, pat->ptr.ptr, pat->len);
1218 patl->pat.ptr.str[patl->pat.len] = '\0';
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001219
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001220 /* chain pattern in the expression */
1221 LIST_ADDQ(&expr->patterns, &patl->list);
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001222 expr->ref->revision = rdtsc();
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001223
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001224 /* that's ok */
1225 return 1;
1226}
1227
Thierry Fournier8feaa662016-02-10 22:55:20 +01001228int pat_idx_list_reg_cap(struct pattern_expr *expr, struct pattern *pat, int cap, char **err)
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001229{
1230 struct pattern_list *patl;
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001231
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001232 /* allocate pattern */
1233 patl = calloc(1, sizeof(*patl));
1234 if (!patl) {
1235 memprintf(err, "out of memory while indexing pattern");
1236 return 0;
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001237 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001238
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001239 /* duplicate pattern */
1240 memcpy(&patl->pat, pat, sizeof(*pat));
1241
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001242 /* compile regex */
Dragan Dosen26743032019-04-30 15:54:36 +02001243 if (!(patl->pat.ptr.reg = regex_comp(pat->ptr.str, !(expr->mflags & PAT_MF_IGNORE_CASE),
1244 cap, err))) {
Dirkjan Bussink07fcaaa2014-04-28 22:57:16 +00001245 free(patl);
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001246 return 0;
1247 }
1248
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001249 /* chain pattern in the expression */
1250 LIST_ADDQ(&expr->patterns, &patl->list);
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001251 expr->ref->revision = rdtsc();
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001252
1253 /* that's ok */
1254 return 1;
1255}
1256
Thierry Fournier8feaa662016-02-10 22:55:20 +01001257int pat_idx_list_reg(struct pattern_expr *expr, struct pattern *pat, char **err)
1258{
1259 return pat_idx_list_reg_cap(expr, pat, 0, err);
1260}
1261
1262int pat_idx_list_regm(struct pattern_expr *expr, struct pattern *pat, char **err)
1263{
1264 return pat_idx_list_reg_cap(expr, pat, 1, err);
1265}
1266
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001267int pat_idx_tree_ip(struct pattern_expr *expr, struct pattern *pat, char **err)
1268{
1269 unsigned int mask;
Thierry FOURNIERe1bcac52013-12-13 16:09:50 +01001270 struct pattern_tree *node;
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001271
1272 /* Only IPv4 can be indexed */
1273 if (pat->type == SMP_T_IPV4) {
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001274 /* in IPv4 case, check if the mask is contiguous so that we can
1275 * insert the network into the tree. A continuous mask has only
1276 * ones on the left. This means that this mask + its lower bit
1277 * added once again is null.
1278 */
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001279 mask = ntohl(pat->val.ipv4.mask.s_addr);
1280 if (mask + (mask & -mask) == 0) {
1281 mask = mask ? 33 - flsnz(mask & -mask) : 0; /* equals cidr value */
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001282
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001283 /* node memory allocation */
1284 node = calloc(1, sizeof(*node) + 4);
1285 if (!node) {
1286 memprintf(err, "out of memory while loading pattern");
1287 return 0;
1288 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001289
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001290 /* copy the pointer to sample associated to this node */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001291 node->data = pat->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001292 node->ref = pat->ref;
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001293
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001294 /* FIXME: insert <addr>/<mask> into the tree here */
1295 memcpy(node->node.key, &pat->val.ipv4.addr, 4); /* network byte order */
1296 node->node.node.pfx = mask;
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001297
1298 /* Insert the entry. */
1299 ebmb_insert_prefix(&expr->pattern_tree, &node->node, 4);
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001300 expr->ref->revision = rdtsc();
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001301
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001302 /* that's ok */
1303 return 1;
1304 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001305 else {
1306 /* If the mask is not contiguous, just add the pattern to the list */
1307 return pat_idx_list_val(expr, pat, err);
1308 }
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001309 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001310 else if (pat->type == SMP_T_IPV6) {
1311 /* IPv6 also can be indexed */
1312 node = calloc(1, sizeof(*node) + 16);
1313 if (!node) {
1314 memprintf(err, "out of memory while loading pattern");
1315 return 0;
1316 }
1317
1318 /* copy the pointer to sample associated to this node */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001319 node->data = pat->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001320 node->ref = pat->ref;
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001321
1322 /* FIXME: insert <addr>/<mask> into the tree here */
1323 memcpy(node->node.key, &pat->val.ipv6.addr, 16); /* network byte order */
1324 node->node.node.pfx = pat->val.ipv6.mask;
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001325
1326 /* Insert the entry. */
1327 ebmb_insert_prefix(&expr->pattern_tree_2, &node->node, 16);
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001328 expr->ref->revision = rdtsc();
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001329
1330 /* that's ok */
1331 return 1;
1332 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001333
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001334 return 0;
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001335}
1336
1337int pat_idx_tree_str(struct pattern_expr *expr, struct pattern *pat, char **err)
1338{
1339 int len;
Thierry FOURNIERe1bcac52013-12-13 16:09:50 +01001340 struct pattern_tree *node;
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001341
1342 /* Only string can be indexed */
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001343 if (pat->type != SMP_T_STR) {
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001344 memprintf(err, "internal error: string expected, but the type is '%s'",
1345 smp_to_type[pat->type]);
1346 return 0;
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001347 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001348
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001349 /* If the flag PAT_F_IGNORE_CASE is set, we cannot use trees */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001350 if (expr->mflags & PAT_MF_IGNORE_CASE)
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001351 return pat_idx_list_str(expr, pat, err);
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001352
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001353 /* Process the key len */
1354 len = strlen(pat->ptr.str) + 1;
1355
1356 /* node memory allocation */
1357 node = calloc(1, sizeof(*node) + len);
1358 if (!node) {
1359 memprintf(err, "out of memory while loading pattern");
1360 return 0;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001361 }
1362
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001363 /* copy the pointer to sample associated to this node */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001364 node->data = pat->data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001365 node->ref = pat->ref;
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001366
1367 /* copy the string */
1368 memcpy(node->node.key, pat->ptr.str, len);
1369
1370 /* index the new node */
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001371 ebst_insert(&expr->pattern_tree, &node->node);
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001372 expr->ref->revision = rdtsc();
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001373
1374 /* that's ok */
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001375 return 1;
1376}
1377
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +02001378int pat_idx_tree_pfx(struct pattern_expr *expr, struct pattern *pat, char **err)
1379{
1380 int len;
1381 struct pattern_tree *node;
1382
1383 /* Only string can be indexed */
1384 if (pat->type != SMP_T_STR) {
1385 memprintf(err, "internal error: string expected, but the type is '%s'",
1386 smp_to_type[pat->type]);
1387 return 0;
1388 }
1389
1390 /* If the flag PAT_F_IGNORE_CASE is set, we cannot use trees */
1391 if (expr->mflags & PAT_MF_IGNORE_CASE)
1392 return pat_idx_list_str(expr, pat, err);
1393
1394 /* Process the key len */
1395 len = strlen(pat->ptr.str);
1396
1397 /* node memory allocation */
1398 node = calloc(1, sizeof(*node) + len + 1);
1399 if (!node) {
1400 memprintf(err, "out of memory while loading pattern");
1401 return 0;
1402 }
1403
1404 /* copy the pointer to sample associated to this node */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001405 node->data = pat->data;
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +02001406 node->ref = pat->ref;
1407
1408 /* copy the string and the trailing zero */
1409 memcpy(node->node.key, pat->ptr.str, len + 1);
1410 node->node.node.pfx = len * 8;
1411
1412 /* index the new node */
1413 ebmb_insert_prefix(&expr->pattern_tree, &node->node, len);
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001414 expr->ref->revision = rdtsc();
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +02001415
1416 /* that's ok */
1417 return 1;
1418}
1419
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001420void pat_del_list_val(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001421{
1422 struct pattern_list *pat;
1423 struct pattern_list *safe;
1424
1425 list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
1426 /* Check equality. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001427 if (pat->pat.ref != ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001428 continue;
1429
1430 /* Delete and free entry. */
1431 LIST_DEL(&pat->list);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001432 free(pat->pat.data);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001433 free(pat);
1434 }
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001435 expr->ref->revision = rdtsc();
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001436}
1437
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001438void pat_del_tree_ip(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001439{
1440 struct ebmb_node *node, *next_node;
1441 struct pattern_tree *elt;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001442
1443 /* browse each node of the tree for IPv4 addresses. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001444 for (node = ebmb_first(&expr->pattern_tree), next_node = node ? ebmb_next(node) : NULL;
1445 node;
1446 node = next_node, next_node = node ? ebmb_next(node) : NULL) {
1447 /* Extract container of the tree node. */
1448 elt = container_of(node, struct pattern_tree, node);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001449
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001450 /* Check equality. */
1451 if (elt->ref != ref)
1452 continue;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001453
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001454 /* Delete and free entry. */
1455 ebmb_delete(node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001456 free(elt->data);
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001457 free(elt);
1458 }
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001459
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001460 /* Browse each node of the list for IPv4 addresses. */
1461 pat_del_list_val(expr, ref);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001462
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001463 /* browse each node of the tree for IPv6 addresses. */
1464 for (node = ebmb_first(&expr->pattern_tree_2), next_node = node ? ebmb_next(node) : NULL;
1465 node;
1466 node = next_node, next_node = node ? ebmb_next(node) : NULL) {
1467 /* Extract container of the tree node. */
1468 elt = container_of(node, struct pattern_tree, node);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001469
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001470 /* Check equality. */
1471 if (elt->ref != ref)
1472 continue;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001473
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001474 /* Delete and free entry. */
1475 ebmb_delete(node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001476 free(elt->data);
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001477 free(elt);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001478 }
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001479 expr->ref->revision = rdtsc();
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001480}
1481
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001482void pat_del_list_ptr(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001483{
1484 struct pattern_list *pat;
1485 struct pattern_list *safe;
1486
1487 list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
1488 /* Check equality. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001489 if (pat->pat.ref != ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001490 continue;
1491
1492 /* Delete and free entry. */
1493 LIST_DEL(&pat->list);
1494 free(pat->pat.ptr.ptr);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001495 free(pat->pat.data);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001496 free(pat);
1497 }
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001498 expr->ref->revision = rdtsc();
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001499}
1500
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001501void pat_del_tree_str(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001502{
1503 struct ebmb_node *node, *next_node;
1504 struct pattern_tree *elt;
1505
Thierry FOURNIER73bc2852015-02-06 17:53:54 +01001506 /* If the flag PAT_F_IGNORE_CASE is set, we cannot use trees */
1507 if (expr->mflags & PAT_MF_IGNORE_CASE)
1508 return pat_del_list_ptr(expr, ref);
1509
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001510 /* browse each node of the tree. */
1511 for (node = ebmb_first(&expr->pattern_tree), next_node = node ? ebmb_next(node) : NULL;
1512 node;
1513 node = next_node, next_node = node ? ebmb_next(node) : NULL) {
1514 /* Extract container of the tree node. */
1515 elt = container_of(node, struct pattern_tree, node);
1516
1517 /* Check equality. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001518 if (elt->ref != ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001519 continue;
1520
1521 /* Delete and free entry. */
1522 ebmb_delete(node);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001523 free(elt->data);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001524 free(elt);
1525 }
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001526 expr->ref->revision = rdtsc();
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001527}
1528
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001529void pat_del_list_reg(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001530{
1531 struct pattern_list *pat;
1532 struct pattern_list *safe;
1533
1534 list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
1535 /* Check equality. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001536 if (pat->pat.ref != ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001537 continue;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001538
1539 /* Delete and free entry. */
1540 LIST_DEL(&pat->list);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001541 regex_free(pat->pat.ptr.ptr);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001542 free(pat->pat.data);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001543 free(pat);
1544 }
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001545 expr->ref->revision = rdtsc();
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001546}
1547
1548void pattern_init_expr(struct pattern_expr *expr)
1549{
1550 LIST_INIT(&expr->patterns);
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001551 expr->pattern_tree = EB_ROOT;
1552 expr->pattern_tree_2 = EB_ROOT;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001553}
1554
1555void pattern_init_head(struct pattern_head *head)
1556{
1557 LIST_INIT(&head->head);
1558}
1559
1560/* The following functions are relative to the management of the reference
1561 * lists. These lists are used to store the original pattern and associated
1562 * value as string form.
1563 *
1564 * This is used with modifiable ACL and MAPS
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001565 *
1566 * The pattern reference are stored with two identifiers: the unique_id and
1567 * the reference.
1568 *
1569 * The reference identify a file. Each file with the same name point to the
1570 * same reference. We can register many times one file. If the file is modified,
1571 * all his dependencies are also modified. The reference can be used with map or
1572 * acl.
1573 *
1574 * The unique_id identify inline acl. The unique id is unique for each acl.
1575 * You cannot force the same id in the configuration file, because this repoort
1576 * an error.
1577 *
1578 * A particular case appears if the filename is a number. In this case, the
1579 * unique_id is set with the number represented by the filename and the
1580 * reference is also set. This method prevent double unique_id.
1581 *
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001582 */
1583
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01001584/* This function looks up a reference by name. If the reference is found, a
1585 * pointer to the struct pat_ref is returned, otherwise NULL is returned.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001586 */
1587struct pat_ref *pat_ref_lookup(const char *reference)
1588{
1589 struct pat_ref *ref;
1590
1591 list_for_each_entry(ref, &pattern_reference, list)
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001592 if (ref->reference && strcmp(reference, ref->reference) == 0)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001593 return ref;
1594 return NULL;
1595}
1596
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01001597/* This function looks up a reference's unique id. If the reference is found, a
1598 * pointer to the struct pat_ref is returned, otherwise NULL is returned.
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001599 */
1600struct pat_ref *pat_ref_lookupid(int unique_id)
1601{
1602 struct pat_ref *ref;
1603
1604 list_for_each_entry(ref, &pattern_reference, list)
1605 if (ref->unique_id == unique_id)
1606 return ref;
1607 return NULL;
1608}
1609
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01001610/* This function removes all the patterns matching the pointer <refelt> from
1611 * the reference and from each expr member of this reference. This function
1612 * returns 1 if the entry was found and deleted, otherwise zero.
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001613 */
1614int pat_ref_delete_by_id(struct pat_ref *ref, struct pat_ref_elt *refelt)
1615{
1616 struct pattern_expr *expr;
1617 struct pat_ref_elt *elt, *safe;
Emeric Brun8d85aa42017-06-29 15:40:33 +02001618 struct bref *bref, *back;
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001619
1620 /* delete pattern from reference */
1621 list_for_each_entry_safe(elt, safe, &ref->head, list) {
1622 if (elt == refelt) {
Emeric Brun8d85aa42017-06-29 15:40:33 +02001623 list_for_each_entry_safe(bref, back, &elt->back_refs, users) {
1624 /*
1625 * we have to unlink all watchers. We must not relink them if
1626 * this elt was the last one in the list.
1627 */
1628 LIST_DEL(&bref->users);
1629 LIST_INIT(&bref->users);
1630 if (elt->list.n != &ref->head)
Willy Tarreau49ee3b22019-04-30 11:43:43 +02001631 LIST_ADDQ(&LIST_ELEM(elt->list.n, typeof(elt), list)->back_refs, &bref->users);
Emeric Brun8d85aa42017-06-29 15:40:33 +02001632 bref->ref = elt->list.n;
1633 }
peter caiaede6dd2015-10-07 00:07:43 -07001634 list_for_each_entry(expr, &ref->pat, list)
1635 pattern_delete(expr, elt);
1636
Emeric Brunb5997f72017-07-03 11:34:05 +02001637 /* pat_ref_elt is trashed once all expr
1638 are cleaned and there is no ref remaining */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001639 LIST_DEL(&elt->list);
1640 free(elt->sample);
1641 free(elt->pattern);
1642 free(elt);
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001643 return 1;
1644 }
1645 }
1646 return 0;
1647}
1648
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001649/* This function remove all pattern match <key> from the the reference
Joseph Herlant4189d672018-11-15 10:22:31 -08001650 * and from each expr member of the reference. This function returns 1
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001651 * if the deletion is done and return 0 is the entry is not found.
1652 */
1653int pat_ref_delete(struct pat_ref *ref, const char *key)
1654{
1655 struct pattern_expr *expr;
1656 struct pat_ref_elt *elt, *safe;
Emeric Brun8d85aa42017-06-29 15:40:33 +02001657 struct bref *bref, *back;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001658 int found = 0;
1659
1660 /* delete pattern from reference */
1661 list_for_each_entry_safe(elt, safe, &ref->head, list) {
1662 if (strcmp(key, elt->pattern) == 0) {
Emeric Brun8d85aa42017-06-29 15:40:33 +02001663 list_for_each_entry_safe(bref, back, &elt->back_refs, users) {
1664 /*
1665 * we have to unlink all watchers. We must not relink them if
1666 * this elt was the last one in the list.
1667 */
1668 LIST_DEL(&bref->users);
1669 LIST_INIT(&bref->users);
1670 if (elt->list.n != &ref->head)
Willy Tarreau49ee3b22019-04-30 11:43:43 +02001671 LIST_ADDQ(&LIST_ELEM(elt->list.n, typeof(elt), list)->back_refs, &bref->users);
Emeric Brun8d85aa42017-06-29 15:40:33 +02001672 bref->ref = elt->list.n;
1673 }
Dirkjan Bussink07fcaaa2014-04-28 22:57:16 +00001674 list_for_each_entry(expr, &ref->pat, list)
1675 pattern_delete(expr, elt);
1676
Emeric Brunb5997f72017-07-03 11:34:05 +02001677 /* pat_ref_elt is trashed once all expr
1678 are cleaned and there is no ref remaining */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001679 LIST_DEL(&elt->list);
1680 free(elt->sample);
1681 free(elt->pattern);
1682 free(elt);
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001683
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001684 found = 1;
1685 }
1686 }
1687
1688 if (!found)
1689 return 0;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001690 return 1;
1691}
1692
Baptiste Assmann953f74d2014-04-25 16:57:03 +02001693/*
1694 * find and return an element <elt> matching <key> in a reference <ref>
1695 * return NULL if not found
1696 */
1697struct pat_ref_elt *pat_ref_find_elt(struct pat_ref *ref, const char *key)
1698{
1699 struct pat_ref_elt *elt;
1700
1701 list_for_each_entry(elt, &ref->head, list) {
1702 if (strcmp(key, elt->pattern) == 0)
1703 return elt;
1704 }
1705
1706 return NULL;
1707}
1708
1709
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01001710/* This function modifies the sample of pat_ref_elt <elt> in all expressions
1711 * found under <ref> to become <value>. It is assumed that the caller has
1712 * already verified that <elt> belongs to <ref>.
1713 */
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001714static inline int pat_ref_set_elt(struct pat_ref *ref, struct pat_ref_elt *elt,
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001715 const char *value, char **err)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001716{
1717 struct pattern_expr *expr;
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001718 struct sample_data **data;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001719 char *sample;
Thierry FOURNIER12ba0c22015-08-14 00:02:11 +02001720 struct sample_data test;
Thierry FOURNIER149e0fe2014-01-29 19:35:06 +01001721
1722 /* Try all needed converters. */
1723 list_for_each_entry(expr, &ref->pat, list) {
1724 if (!expr->pat_head->parse_smp)
1725 continue;
1726
1727 if (!expr->pat_head->parse_smp(value, &test)) {
1728 memprintf(err, "unable to parse '%s'", value);
1729 return 0;
1730 }
1731 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001732
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001733 /* Modify pattern from reference. */
1734 sample = strdup(value);
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001735 if (!sample) {
1736 memprintf(err, "out of memory error");
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001737 return 0;
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001738 }
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01001739 /* Load sample in each reference. All the conversions are tested
1740 * below, normally these calls don't fail.
Thierry FOURNIER149e0fe2014-01-29 19:35:06 +01001741 */
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01001742 list_for_each_entry(expr, &ref->pat, list) {
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001743 if (!expr->pat_head->parse_smp)
1744 continue;
1745
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001746 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001747 data = pattern_find_smp(expr, elt);
1748 if (data && *data && !expr->pat_head->parse_smp(sample, *data))
1749 *data = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001750 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001751 }
1752
Emeric Brunb5997f72017-07-03 11:34:05 +02001753 /* free old sample only when all exprs are updated */
1754 free(elt->sample);
1755 elt->sample = sample;
1756
1757
Thierry FOURNIER149e0fe2014-01-29 19:35:06 +01001758 return 1;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001759}
1760
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01001761/* This function modifies the sample of pat_ref_elt <refelt> in all expressions
1762 * found under <ref> to become <value>, after checking that <refelt> really
1763 * belongs to <ref>.
1764 */
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001765int 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 +01001766{
1767 struct pat_ref_elt *elt;
1768
1769 /* Look for pattern in the reference. */
1770 list_for_each_entry(elt, &ref->head, list) {
1771 if (elt == refelt) {
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001772 if (!pat_ref_set_elt(ref, elt, value, err))
1773 return 0;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001774 return 1;
1775 }
1776 }
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001777
1778 memprintf(err, "key or pattern not found");
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001779 return 0;
1780}
1781
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01001782/* This function modifies to <value> the sample of all patterns matching <key>
1783 * under <ref>.
1784 */
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001785int pat_ref_set(struct pat_ref *ref, const char *key, const char *value, char **err)
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001786{
1787 struct pat_ref_elt *elt;
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001788 int found = 0;
1789 char *_merr;
1790 char **merr;
1791
1792 if (err) {
1793 merr = &_merr;
1794 *merr = NULL;
1795 }
1796 else
1797 merr = NULL;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001798
1799 /* Look for pattern in the reference. */
1800 list_for_each_entry(elt, &ref->head, list) {
1801 if (strcmp(key, elt->pattern) == 0) {
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001802 if (!pat_ref_set_elt(ref, elt, value, merr)) {
William Lallemand579fb252018-06-11 10:53:46 +02001803 if (err && merr) {
1804 if (!found) {
1805 *err = *merr;
1806 } else {
1807 memprintf(err, "%s, %s", *err, *merr);
1808 free(*merr);
1809 *merr = NULL;
1810 }
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001811 }
1812 }
1813 found = 1;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001814 }
1815 }
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001816
1817 if (!found) {
1818 memprintf(err, "entry not found");
1819 return 0;
1820 }
1821 return 1;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001822}
1823
Joseph Herlant4189d672018-11-15 10:22:31 -08001824/* This function creates a new reference. <ref> is the reference name.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001825 * <flags> are PAT_REF_*. /!\ The reference is not checked, and must
1826 * be unique. The user must check the reference with "pat_ref_lookup()"
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01001827 * before calling this function. If the function fails, it returns NULL,
1828 * otherwise it returns the new struct pat_ref.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001829 */
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001830struct pat_ref *pat_ref_new(const char *reference, const char *display, unsigned int flags)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001831{
1832 struct pat_ref *ref;
1833
Willy Tarreau8135d9b2020-10-30 15:35:11 +01001834 ref = calloc(1, sizeof(*ref));
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001835 if (!ref)
1836 return NULL;
1837
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001838 if (display) {
1839 ref->display = strdup(display);
1840 if (!ref->display) {
1841 free(ref);
1842 return NULL;
1843 }
1844 }
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001845
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001846 ref->reference = strdup(reference);
1847 if (!ref->reference) {
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001848 free(ref->display);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001849 free(ref);
1850 return NULL;
1851 }
1852
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001853 ref->flags = flags;
1854 ref->unique_id = -1;
Willy Tarreau3ee0de12020-11-02 15:26:51 +01001855 ref->revision = 0;
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001856
1857 LIST_INIT(&ref->head);
1858 LIST_INIT(&ref->pat);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001859 HA_SPIN_INIT(&ref->lock);
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001860 LIST_ADDQ(&pattern_reference, &ref->list);
1861
1862 return ref;
1863}
1864
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01001865/* This function creates a new reference. <unique_id> is the unique id. If
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001866 * the value of <unique_id> is -1, the unique id is calculated later.
1867 * <flags> are PAT_REF_*. /!\ The reference is not checked, and must
1868 * be unique. The user must check the reference with "pat_ref_lookup()"
1869 * or pat_ref_lookupid before calling this function. If the function
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01001870 * fails, it returns NULL, otherwise it returns the new struct pat_ref.
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001871 */
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001872struct pat_ref *pat_ref_newid(int unique_id, const char *display, unsigned int flags)
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001873{
1874 struct pat_ref *ref;
1875
Willy Tarreau8135d9b2020-10-30 15:35:11 +01001876 ref = calloc(1, sizeof(*ref));
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001877 if (!ref)
1878 return NULL;
1879
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001880 if (display) {
1881 ref->display = strdup(display);
1882 if (!ref->display) {
1883 free(ref);
1884 return NULL;
1885 }
1886 }
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001887
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001888 ref->reference = NULL;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001889 ref->flags = flags;
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001890 ref->unique_id = unique_id;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001891 LIST_INIT(&ref->head);
1892 LIST_INIT(&ref->pat);
Aurélien Nephtali564d15a2018-04-19 16:56:07 +02001893 HA_SPIN_INIT(&ref->lock);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001894 LIST_ADDQ(&pattern_reference, &ref->list);
1895
1896 return ref;
1897}
1898
Willy Tarreauf4edb722020-10-28 10:52:46 +01001899/* This function adds entry to <ref>. It can fail on memory error. It returns
1900 * the newly added element on success, or NULL on failure. The PATREF_LOCK on
1901 * <ref> must be held.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001902 */
Willy Tarreauf4edb722020-10-28 10:52:46 +01001903struct pat_ref_elt *pat_ref_append(struct pat_ref *ref, const char *pattern, const char *sample, int line)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001904{
1905 struct pat_ref_elt *elt;
1906
Willy Tarreau8135d9b2020-10-30 15:35:11 +01001907 elt = calloc(1, sizeof(*elt));
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001908 if (!elt)
Willy Tarreauf4edb722020-10-28 10:52:46 +01001909 goto fail;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001910
1911 elt->line = line;
1912
1913 elt->pattern = strdup(pattern);
Willy Tarreauf4edb722020-10-28 10:52:46 +01001914 if (!elt->pattern)
1915 goto fail;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001916
1917 if (sample) {
1918 elt->sample = strdup(sample);
Willy Tarreauf4edb722020-10-28 10:52:46 +01001919 if (!elt->sample)
1920 goto fail;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001921 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001922
Emeric Brun8d85aa42017-06-29 15:40:33 +02001923 LIST_INIT(&elt->back_refs);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001924 LIST_ADDQ(&ref->head, &elt->list);
Willy Tarreauf4edb722020-10-28 10:52:46 +01001925 return elt;
1926 fail:
1927 if (elt)
1928 free(elt->pattern);
1929 free(elt);
1930 return NULL;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001931}
1932
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01001933/* This function creates sample found in <elt>, parses the pattern also
1934 * found in <elt> and inserts it in <expr>. The function copies <patflags>
1935 * into <expr>. If the function fails, it returns 0 and <err> is filled.
Ilya Shipitsin47d17182020-06-21 21:42:57 +05001936 * In success case, the function returns 1.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001937 */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001938int pat_ref_push(struct pat_ref_elt *elt, struct pattern_expr *expr,
1939 int patflags, char **err)
1940{
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001941 struct sample_data *data;
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001942 struct pattern pattern;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001943
1944 /* Create sample */
1945 if (elt->sample && expr->pat_head->parse_smp) {
1946 /* New sample. */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001947 data = malloc(sizeof(*data));
1948 if (!data)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001949 return 0;
1950
1951 /* Parse value. */
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001952 if (!expr->pat_head->parse_smp(elt->sample, data)) {
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001953 memprintf(err, "unable to parse '%s'", elt->sample);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001954 free(data);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001955 return 0;
1956 }
1957
1958 }
1959 else
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001960 data = NULL;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001961
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001962 /* initialise pattern */
1963 memset(&pattern, 0, sizeof(pattern));
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001964 pattern.data = data;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001965 pattern.ref = elt;
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001966
1967 /* parse pattern */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001968 if (!expr->pat_head->parse(elt->pattern, &pattern, expr->mflags, err)) {
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001969 free(data);
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001970 return 0;
1971 }
1972
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001973 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001974 /* index pattern */
1975 if (!expr->pat_head->index(expr, &pattern, err)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001976 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIER503bb092015-08-19 08:35:43 +02001977 free(data);
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001978 return 0;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001979 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001980 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001981
1982 return 1;
1983}
1984
Willy Tarreau6a174072020-10-28 10:58:05 +01001985/* This function adds entry to <ref>. It can fail on memory error. The new
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001986 * entry is added at all the pattern_expr registered in this reference. The
Willy Tarreau6a174072020-10-28 10:58:05 +01001987 * function stops on the first error encountered. It returns 0 and <err> is
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001988 * filled. If an error is encountered, the complete add operation is cancelled.
1989 * If the insertion is a success the function returns 1.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001990 */
1991int pat_ref_add(struct pat_ref *ref,
1992 const char *pattern, const char *sample,
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001993 char **err)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001994{
1995 struct pat_ref_elt *elt;
1996 struct pattern_expr *expr;
1997
Willy Tarreau6a174072020-10-28 10:58:05 +01001998 elt = pat_ref_append(ref, pattern, sample, -1);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001999 if (!elt) {
2000 memprintf(err, "out of memory error");
2001 return 0;
2002 }
2003
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002004 list_for_each_entry(expr, &ref->pat, list) {
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02002005 if (!pat_ref_push(elt, expr, 0, err)) {
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01002006 /* If the insertion fails, try to delete all the added entries. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01002007 pat_ref_delete_by_id(ref, elt);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002008 return 0;
2009 }
2010 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002011 return 1;
2012}
2013
Joseph Herlant4189d672018-11-15 10:22:31 -08002014/* This function prunes <ref>, replaces all references by the references
2015 * of <replace>, and reindexes all the news values.
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002016 *
Joseph Herlant4189d672018-11-15 10:22:31 -08002017 * The patterns are loaded in best effort and the errors are ignored,
2018 * but written in the logs.
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002019 */
2020void pat_ref_reload(struct pat_ref *ref, struct pat_ref *replace)
2021{
2022 struct pattern_expr *expr;
Emeric Brunb5997f72017-07-03 11:34:05 +02002023 struct pat_ref_elt *elt, *safe;
2024 struct bref *bref, *back;
Emeric Brunb5997f72017-07-03 11:34:05 +02002025 struct pattern pattern;
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002026
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002027
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002028 HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
Emeric Brunb5997f72017-07-03 11:34:05 +02002029 list_for_each_entry(expr, &ref->pat, list) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002030 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
Emeric Brunb5997f72017-07-03 11:34:05 +02002031 }
2032
2033 /* all expr are locked, we can safely remove all pat_ref */
2034 list_for_each_entry_safe(elt, safe, &ref->head, list) {
2035 list_for_each_entry_safe(bref, back, &elt->back_refs, users) {
Willy Tarreaud4164dc2020-10-27 18:55:20 +01002036 /* we have to unlink all watchers. */
2037 LIST_DEL_INIT(&bref->users);
2038 bref->ref = NULL;
Emeric Brunb5997f72017-07-03 11:34:05 +02002039 }
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);
Willy Tarreau114d6982020-11-03 15:55:35 +01002098
2099#if defined(HA_HAVE_MALLOC_TRIM)
2100 malloc_trim(0);
2101#endif
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01002102}
2103
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01002104/* This function prunes all entries of <ref>. This function
Willy Tarreaud1d005d2019-12-20 18:22:02 +01002105 * prunes the associated pattern_expr. It may return before the end of
2106 * the list is reached, returning 0, to yield. The caller must call it
2107 * again. Otherwise it returns 1 once done.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002108 */
Willy Tarreaud1d005d2019-12-20 18:22:02 +01002109int pat_ref_prune(struct pat_ref *ref)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002110{
2111 struct pat_ref_elt *elt, *safe;
2112 struct pattern_expr *expr;
Emeric Brun8d85aa42017-06-29 15:40:33 +02002113 struct bref *bref, *back;
Willy Tarreaud1d005d2019-12-20 18:22:02 +01002114 int loops = 0;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002115
Emeric Brunb5997f72017-07-03 11:34:05 +02002116 list_for_each_entry(expr, &ref->pat, list) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002117 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
Emeric Brunb5997f72017-07-03 11:34:05 +02002118 expr->pat_head->prune(expr);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002119 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Willy Tarreaud1d005d2019-12-20 18:22:02 +01002120 loops++;
2121 /* yield often, some lists may be huge, especially those
2122 * having to be freed through free_pattern_tree()
2123 */
2124 if (loops > 10)
2125 return 0;
Emeric Brunb5997f72017-07-03 11:34:05 +02002126 }
2127
2128 /* we trash pat_ref_elt in a second time to ensure that data is
2129 free once there is no ref on it */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002130 list_for_each_entry_safe(elt, safe, &ref->head, list) {
Emeric Brun8d85aa42017-06-29 15:40:33 +02002131 list_for_each_entry_safe(bref, back, &elt->back_refs, users) {
2132 /*
2133 * we have to unlink all watchers. We must not relink them if
2134 * this elt was the last one in the list.
2135 */
2136 LIST_DEL(&bref->users);
2137 LIST_INIT(&bref->users);
2138 if (elt->list.n != &ref->head)
Willy Tarreau49ee3b22019-04-30 11:43:43 +02002139 LIST_ADDQ(&LIST_ELEM(elt->list.n, typeof(elt), list)->back_refs, &bref->users);
Emeric Brun8d85aa42017-06-29 15:40:33 +02002140 bref->ref = elt->list.n;
2141 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002142 LIST_DEL(&elt->list);
2143 free(elt->pattern);
2144 free(elt->sample);
2145 free(elt);
Willy Tarreaud1d005d2019-12-20 18:22:02 +01002146 loops++;
2147 if (loops > 100000)
2148 return 0;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002149 }
Willy Tarreaud1d005d2019-12-20 18:22:02 +01002150 return 1;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002151}
2152
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01002153/* This function looks up any existing reference <ref> in pattern_head <head>, and
2154 * returns the associated pattern_expr pointer if found, otherwise NULL.
2155 */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002156struct pattern_expr *pattern_lookup_expr(struct pattern_head *head, struct pat_ref *ref)
2157{
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002158 struct pattern_expr_list *expr;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002159
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002160 list_for_each_entry(expr, &head->head, list)
2161 if (expr->expr->ref == ref)
2162 return expr->expr;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002163 return NULL;
2164}
2165
Joseph Herlant4189d672018-11-15 10:22:31 -08002166/* This function creates new pattern_expr associated to the reference <ref>.
2167 * <ref> can be NULL. If an error occurs, the function returns NULL and
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002168 * <err> is filled. Otherwise, the function returns new pattern_expr linked
2169 * with <head> and <ref>.
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002170 *
Joseph Herlant4189d672018-11-15 10:22:31 -08002171 * The returned value can be an already filled pattern list, in this case the
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002172 * flag <reuse> is set.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002173 */
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002174struct pattern_expr *pattern_new_expr(struct pattern_head *head, struct pat_ref *ref,
Emeric Brun7d27f3c2017-07-03 17:54:23 +02002175 int patflags, char **err, int *reuse)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002176{
2177 struct pattern_expr *expr;
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002178 struct pattern_expr_list *list;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002179
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002180 if (reuse)
2181 *reuse = 0;
2182
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002183 /* Memory and initialization of the chain element. */
Willy Tarreau8135d9b2020-10-30 15:35:11 +01002184 list = calloc(1, sizeof(*list));
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002185 if (!list) {
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002186 memprintf(err, "out of memory");
2187 return NULL;
2188 }
2189
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002190 /* Look for existing similar expr. No that only the index, parse and
2191 * parse_smp function must be identical for having similar pattern.
Joseph Herlant4189d672018-11-15 10:22:31 -08002192 * The other function depends of these first.
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002193 */
2194 if (ref) {
2195 list_for_each_entry(expr, &ref->pat, list)
2196 if (expr->pat_head->index == head->index &&
2197 expr->pat_head->parse == head->parse &&
Emeric Brun7d27f3c2017-07-03 17:54:23 +02002198 expr->pat_head->parse_smp == head->parse_smp &&
2199 expr->mflags == patflags)
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002200 break;
2201 if (&expr->list == &ref->pat)
2202 expr = NULL;
2203 }
2204 else
2205 expr = NULL;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002206
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002207 /* If no similar expr was found, we create new expr. */
2208 if (!expr) {
2209 /* Get a lot of memory for the expr struct. */
Willy Tarreau8135d9b2020-10-30 15:35:11 +01002210 expr = calloc(1, sizeof(*expr));
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002211 if (!expr) {
Andreas Seltenreiche6e22e82016-03-03 20:20:23 +01002212 free(list);
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002213 memprintf(err, "out of memory");
2214 return NULL;
2215 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002216
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002217 /* Initialize this new expr. */
2218 pattern_init_expr(expr);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002219
Emeric Brun7d27f3c2017-07-03 17:54:23 +02002220 /* Copy the pattern matching and indexing flags. */
2221 expr->mflags = patflags;
2222
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002223 /* This new pattern expression reference one of his heads. */
2224 expr->pat_head = head;
2225
2226 /* Link with ref, or to self to facilitate LIST_DEL() */
2227 if (ref)
2228 LIST_ADDQ(&ref->pat, &expr->list);
2229 else
2230 LIST_INIT(&expr->list);
2231
2232 expr->ref = ref;
2233
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002234 HA_RWLOCK_INIT(&expr->lock);
Emeric Brunb5997f72017-07-03 11:34:05 +02002235
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002236 /* We must free this pattern if it is no more used. */
2237 list->do_free = 1;
2238 }
2239 else {
2240 /* If the pattern used already exists, it is already linked
2241 * with ref and we must not free it.
2242 */
2243 list->do_free = 0;
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002244 if (reuse)
2245 *reuse = 1;
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002246 }
2247
2248 /* The new list element reference the pattern_expr. */
2249 list->expr = expr;
2250
2251 /* Link the list element with the pattern_head. */
2252 LIST_ADDQ(&head->head, &list->list);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002253 return expr;
2254}
2255
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002256/* Reads patterns from a file. If <err_msg> is non-NULL, an error message will
2257 * be returned there on errors and the caller will have to free it.
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002258 *
2259 * The file contains one key + value per line. Lines which start with '#' are
2260 * ignored, just like empty lines. Leading tabs/spaces are stripped. The key is
2261 * then the first "word" (series of non-space/tabs characters), and the value is
2262 * what follows this series of space/tab till the end of the line excluding
2263 * trailing spaces/tabs.
2264 *
2265 * Example :
2266 *
2267 * # this is a comment and is ignored
2268 * 62.212.114.60 1wt.eu \n
2269 * <-><-----------><---><----><---->
2270 * | | | | `--- trailing spaces ignored
2271 * | | | `-------- value
2272 * | | `--------------- middle spaces ignored
2273 * | `------------------------ key
2274 * `-------------------------------- leading spaces ignored
2275 *
Ilya Shipitsin47d17182020-06-21 21:42:57 +05002276 * Return non-zero in case of success, otherwise 0.
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002277 */
2278int pat_ref_read_from_file_smp(struct pat_ref *ref, const char *filename, char **err)
2279{
2280 FILE *file;
2281 char *c;
2282 int ret = 0;
2283 int line = 0;
2284 char *key_beg;
2285 char *key_end;
2286 char *value_beg;
2287 char *value_end;
2288
2289 file = fopen(filename, "r");
2290 if (!file) {
2291 memprintf(err, "failed to open pattern file <%s>", filename);
2292 return 0;
2293 }
2294
2295 /* now parse all patterns. The file may contain only one pattern
2296 * followed by one value per line. The start spaces, separator spaces
2297 * and and spaces are stripped. Each can contain comment started by '#'
2298 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002299 while (fgets(trash.area, trash.size, file) != NULL) {
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002300 line++;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002301 c = trash.area;
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002302
2303 /* ignore lines beginning with a dash */
2304 if (*c == '#')
2305 continue;
2306
2307 /* strip leading spaces and tabs */
2308 while (*c == ' ' || *c == '\t')
2309 c++;
2310
2311 /* empty lines are ignored too */
2312 if (*c == '\0' || *c == '\r' || *c == '\n')
2313 continue;
2314
2315 /* look for the end of the key */
2316 key_beg = c;
2317 while (*c && *c != ' ' && *c != '\t' && *c != '\n' && *c != '\r')
2318 c++;
2319
2320 key_end = c;
2321
2322 /* strip middle spaces and tabs */
2323 while (*c == ' ' || *c == '\t')
2324 c++;
2325
2326 /* look for the end of the value, it is the end of the line */
2327 value_beg = c;
2328 while (*c && *c != '\n' && *c != '\r')
2329 c++;
2330 value_end = c;
2331
2332 /* trim possibly trailing spaces and tabs */
2333 while (value_end > value_beg && (value_end[-1] == ' ' || value_end[-1] == '\t'))
2334 value_end--;
2335
2336 /* set final \0 and check entries */
2337 *key_end = '\0';
2338 *value_end = '\0';
2339
2340 /* insert values */
2341 if (!pat_ref_append(ref, key_beg, value_beg, line)) {
2342 memprintf(err, "out of memory");
2343 goto out_close;
2344 }
2345 }
2346
Jerome Magnin3c79d4b2020-01-17 16:09:33 +01002347 if (ferror(file)) {
2348 memprintf(err, "error encountered while reading <%s> : %s",
2349 filename, strerror(errno));
2350 goto out_close;
2351 }
Ilya Shipitsin47d17182020-06-21 21:42:57 +05002352 /* success */
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002353 ret = 1;
2354
2355 out_close:
2356 fclose(file);
2357 return ret;
2358}
2359
2360/* Reads patterns from a file. If <err_msg> is non-NULL, an error message will
2361 * be returned there on errors and the caller will have to free it.
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002362 */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002363int pat_ref_read_from_file(struct pat_ref *ref, const char *filename, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002364{
2365 FILE *file;
2366 char *c;
2367 char *arg;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002368 int ret = 0;
2369 int line = 0;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002370
2371 file = fopen(filename, "r");
2372 if (!file) {
2373 memprintf(err, "failed to open pattern file <%s>", filename);
2374 return 0;
2375 }
2376
2377 /* now parse all patterns. The file may contain only one pattern per
2378 * line. If the line contains spaces, they will be part of the pattern.
2379 * The pattern stops at the first CR, LF or EOF encountered.
2380 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002381 while (fgets(trash.area, trash.size, file) != NULL) {
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002382 line++;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002383 c = trash.area;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002384
2385 /* ignore lines beginning with a dash */
2386 if (*c == '#')
2387 continue;
2388
2389 /* strip leading spaces and tabs */
2390 while (*c == ' ' || *c == '\t')
2391 c++;
2392
2393
2394 arg = c;
2395 while (*c && *c != '\n' && *c != '\r')
2396 c++;
2397 *c = 0;
2398
2399 /* empty lines are ignored too */
2400 if (c == arg)
2401 continue;
2402
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002403 if (!pat_ref_append(ref, arg, NULL, line)) {
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002404 memprintf(err, "out of memory when loading patterns from file <%s>", filename);
2405 goto out_close;
2406 }
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002407 }
2408
Jerome Magnin3c79d4b2020-01-17 16:09:33 +01002409 if (ferror(file)) {
2410 memprintf(err, "error encountered while reading <%s> : %s",
2411 filename, strerror(errno));
2412 goto out_close;
2413 }
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002414 ret = 1; /* success */
2415
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002416 out_close:
2417 fclose(file);
2418 return ret;
2419}
2420
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002421int pattern_read_from_file(struct pattern_head *head, unsigned int refflags,
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002422 const char *filename, int patflags, int load_smp,
Thierry FOURNIER94580c92014-02-11 14:36:45 +01002423 char **err, const char *file, int line)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002424{
2425 struct pat_ref *ref;
2426 struct pattern_expr *expr;
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002427 struct pat_ref_elt *elt;
Willy Tarreau4deaf392014-11-26 13:17:03 +01002428 int reuse = 0;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002429
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002430 /* Lookup for the existing reference. */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002431 ref = pat_ref_lookup(filename);
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002432
2433 /* If the reference doesn't exists, create it and load associated file. */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002434 if (!ref) {
Thierry FOURNIER94580c92014-02-11 14:36:45 +01002435 chunk_printf(&trash,
2436 "pattern loaded from file '%s' used by %s at file '%s' line %d",
2437 filename, refflags & PAT_REF_MAP ? "map" : "acl", file, line);
2438
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002439 ref = pat_ref_new(filename, trash.area, refflags);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002440 if (!ref) {
2441 memprintf(err, "out of memory");
2442 return 0;
2443 }
2444
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002445 if (load_smp) {
Thierry FOURNIERc0bd9102014-01-29 12:32:58 +01002446 ref->flags |= PAT_REF_SMP;
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002447 if (!pat_ref_read_from_file_smp(ref, filename, err))
2448 return 0;
2449 }
2450 else {
2451 if (!pat_ref_read_from_file(ref, filename, err))
2452 return 0;
2453 }
2454 }
2455 else {
Thierry FOURNIERc0bd9102014-01-29 12:32:58 +01002456 /* The reference already exists, check the map compatibility. */
2457
2458 /* If the load require samples and the flag PAT_REF_SMP is not set,
2459 * the reference doesn't contain sample, and cannot be used.
2460 */
2461 if (load_smp) {
2462 if (!(ref->flags & PAT_REF_SMP)) {
2463 memprintf(err, "The file \"%s\" is already used as one column file "
2464 "and cannot be used by as two column file.",
2465 filename);
2466 return 0;
2467 }
2468 }
2469 else {
2470 /* The load doesn't require samples. If the flag PAT_REF_SMP is
2471 * set, the reference contains a sample, and cannot be used.
2472 */
2473 if (ref->flags & PAT_REF_SMP) {
2474 memprintf(err, "The file \"%s\" is already used as two column file "
2475 "and cannot be used by as one column file.",
2476 filename);
2477 return 0;
2478 }
2479 }
2480
Thierry FOURNIER94580c92014-02-11 14:36:45 +01002481 /* Extends display */
2482 chunk_printf(&trash, "%s", ref->display);
2483 chunk_appendf(&trash, ", by %s at file '%s' line %d",
2484 refflags & PAT_REF_MAP ? "map" : "acl", file, line);
2485 free(ref->display);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002486 ref->display = strdup(trash.area);
Thierry FOURNIER94580c92014-02-11 14:36:45 +01002487 if (!ref->display) {
2488 memprintf(err, "out of memory");
2489 return 0;
2490 }
2491
Thierry FOURNIERc0bd9102014-01-29 12:32:58 +01002492 /* Merge flags. */
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002493 ref->flags |= refflags;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002494 }
2495
2496 /* Now, we can loading patterns from the reference. */
2497
2498 /* Lookup for existing reference in the head. If the reference
2499 * doesn't exists, create it.
2500 */
2501 expr = pattern_lookup_expr(head, ref);
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02002502 if (!expr || (expr->mflags != patflags)) {
Emeric Brun7d27f3c2017-07-03 17:54:23 +02002503 expr = pattern_new_expr(head, ref, patflags, err, &reuse);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002504 if (!expr)
2505 return 0;
2506 }
2507
Thierry FOURNIER315ec422014-11-24 11:14:42 +01002508 /* The returned expression may be not empty, because the function
2509 * "pattern_new_expr" lookup for similar pattern list and can
2510 * reuse a already filled pattern list. In this case, we can not
2511 * reload the patterns.
2512 */
2513 if (reuse)
2514 return 1;
2515
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002516 /* Load reference content in the pattern expression. */
2517 list_for_each_entry(elt, &ref->head, list) {
2518 if (!pat_ref_push(elt, expr, patflags, err)) {
2519 if (elt->line > 0)
2520 memprintf(err, "%s at line %d of file '%s'",
2521 *err, elt->line, filename);
2522 return 0;
2523 }
2524 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002525
2526 return 1;
2527}
2528
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +01002529/* This function executes a pattern match on a sample. It applies pattern <expr>
2530 * to sample <smp>. The function returns NULL if the sample dont match. It returns
2531 * non-null if the sample match. If <fill> is true and the sample match, the
2532 * function returns the matched pattern. In many cases, this pattern can be a
2533 * static buffer.
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002534 */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002535struct pattern *pattern_exec_match(struct pattern_head *head, struct sample *smp, int fill)
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002536{
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002537 struct pattern_expr_list *list;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002538 struct pattern *pat;
2539
2540 if (!head->match) {
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +01002541 if (fill) {
Thierry FOURNIER503bb092015-08-19 08:35:43 +02002542 static_pattern.data = NULL;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01002543 static_pattern.ref = NULL;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02002544 static_pattern.sflags = 0;
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002545 static_pattern.type = SMP_T_SINT;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01002546 static_pattern.val.i = 1;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +01002547 }
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +01002548 return &static_pattern;
2549 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002550
Thierry FOURNIER5d344082014-01-27 14:19:53 +01002551 /* convert input to string */
2552 if (!sample_convert(smp, head->expect_type))
2553 return NULL;
2554
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002555 list_for_each_entry(list, &head->head, list) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002556 HA_RWLOCK_RDLOCK(PATEXP_LOCK, &list->expr->lock);
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002557 pat = head->match(smp, list->expr, fill);
Emeric Brunb5997f72017-07-03 11:34:05 +02002558 if (pat) {
2559 /* We duplicate the pattern cause it could be modified
2560 by another thread */
2561 if (pat != &static_pattern) {
2562 memcpy(&static_pattern, pat, sizeof(struct pattern));
2563 pat = &static_pattern;
2564 }
2565
2566 /* We also duplicate the sample data for
2567 same reason */
2568 if (pat->data && (pat->data != &static_sample_data)) {
Christopher Faulet09fdf4b2017-11-09 16:14:16 +01002569 switch(pat->data->type) {
Emeric Brunb5997f72017-07-03 11:34:05 +02002570 case SMP_T_STR:
2571 static_sample_data.type = SMP_T_STR;
2572 static_sample_data.u.str = *get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002573 static_sample_data.u.str.data = pat->data->u.str.data;
2574 if (static_sample_data.u.str.data >= static_sample_data.u.str.size)
2575 static_sample_data.u.str.data = static_sample_data.u.str.size - 1;
2576 memcpy(static_sample_data.u.str.area,
Willy Tarreau2fc761e2020-06-11 16:37:35 +02002577 pat->data->u.str.area, static_sample_data.u.str.data);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002578 static_sample_data.u.str.area[static_sample_data.u.str.data] = 0;
Willy Tarreau2fc761e2020-06-11 16:37:35 +02002579 pat->data = &static_sample_data;
2580 break;
2581
Emeric Brunb5997f72017-07-03 11:34:05 +02002582 case SMP_T_IPV4:
2583 case SMP_T_IPV6:
2584 case SMP_T_SINT:
2585 memcpy(&static_sample_data, pat->data, sizeof(struct sample_data));
Willy Tarreau2fc761e2020-06-11 16:37:35 +02002586 pat->data = &static_sample_data;
2587 break;
Emeric Brunb5997f72017-07-03 11:34:05 +02002588 default:
Willy Tarreau2fc761e2020-06-11 16:37:35 +02002589 /* unimplemented pattern type */
Emeric Brunb5997f72017-07-03 11:34:05 +02002590 pat->data = NULL;
Willy Tarreau2fc761e2020-06-11 16:37:35 +02002591 break;
Emeric Brunb5997f72017-07-03 11:34:05 +02002592 }
Emeric Brunb5997f72017-07-03 11:34:05 +02002593 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002594 HA_RWLOCK_RDUNLOCK(PATEXP_LOCK, &list->expr->lock);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002595 return pat;
Emeric Brunb5997f72017-07-03 11:34:05 +02002596 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002597 HA_RWLOCK_RDUNLOCK(PATEXP_LOCK, &list->expr->lock);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002598 }
2599 return NULL;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002600}
2601
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01002602/* This function prunes the pattern expressions starting at pattern_head <head>. */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002603void pattern_prune(struct pattern_head *head)
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01002604{
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002605 struct pattern_expr_list *list, *safe;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002606
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002607 list_for_each_entry_safe(list, safe, &head->head, list) {
2608 LIST_DEL(&list->list);
2609 if (list->do_free) {
2610 LIST_DEL(&list->expr->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002611 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &list->expr->lock);
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002612 head->prune(list->expr);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002613 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &list->expr->lock);
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002614 free(list->expr);
2615 }
2616 free(list);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002617 }
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01002618}
2619
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01002620/* This function searches occurrences of pattern reference element <ref> in
2621 * expression <expr> and returns a pointer to a pointer of the sample storage.
2622 * If <ref> is not found, NULL is returned.
Thierry FOURNIER55d0b102014-01-15 11:25:26 +01002623 */
Thierry FOURNIER12ba0c22015-08-14 00:02:11 +02002624struct sample_data **pattern_find_smp(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIER55d0b102014-01-15 11:25:26 +01002625{
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002626 struct ebmb_node *node;
2627 struct pattern_tree *elt;
2628 struct pattern_list *pat;
Thierry FOURNIER55d0b102014-01-15 11:25:26 +01002629
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002630 for (node = ebmb_first(&expr->pattern_tree);
2631 node;
2632 node = ebmb_next(node)) {
2633 elt = container_of(node, struct pattern_tree, node);
2634 if (elt->ref == ref)
Thierry FOURNIER503bb092015-08-19 08:35:43 +02002635 return &elt->data;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002636 }
2637
2638 for (node = ebmb_first(&expr->pattern_tree_2);
2639 node;
2640 node = ebmb_next(node)) {
2641 elt = container_of(node, struct pattern_tree, node);
2642 if (elt->ref == ref)
Thierry FOURNIER503bb092015-08-19 08:35:43 +02002643 return &elt->data;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002644 }
2645
2646 list_for_each_entry(pat, &expr->patterns, list)
2647 if (pat->pat.ref == ref)
Thierry FOURNIER503bb092015-08-19 08:35:43 +02002648 return &pat->pat.data;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002649
2650 return NULL;
Thierry FOURNIER55d0b102014-01-15 11:25:26 +01002651}
2652
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01002653/* This function delets from expression <expr> all occurrences of patterns
2654 * corresponding to pattern reference element <ref>. The function always
2655 * returns 1.
Thierry FOURNIERb1136502014-01-15 11:38:49 +01002656 */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01002657int pattern_delete(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01002658{
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002659 HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01002660 expr->pat_head->delete(expr, ref);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002661 HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01002662 return 1;
2663}
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002664
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01002665/* This function compares two pat_ref** on their unique_id, and returns -1/0/1
2666 * depending on their order (suitable for sorting).
2667 */
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002668static int cmp_pat_ref(const void *_a, const void *_b)
2669{
2670 struct pat_ref * const *a = _a;
2671 struct pat_ref * const *b = _b;
2672
2673 if ((*a)->unique_id < (*b)->unique_id)
2674 return -1;
2675 else if ((*a)->unique_id > (*b)->unique_id)
2676 return 1;
2677 return 0;
2678}
2679
Willy Tarreaua5bbaaf2020-10-30 16:03:50 +01002680/* This function finalizes the configuration parsing. It sets all the
2681 * automatic ids.
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002682 */
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002683int pattern_finalize_config(void)
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002684{
Tim Duesterhusb584b442020-03-17 21:08:24 +01002685 size_t len = 0;
2686 size_t unassigned_pos = 0;
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002687 int next_unique_id = 0;
Tim Duesterhusb584b442020-03-17 21:08:24 +01002688 size_t i, j;
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002689 struct pat_ref *ref, **arr;
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002690 struct list pr = LIST_HEAD_INIT(pr);
2691
Willy Tarreau52bf8392020-03-08 00:42:37 +01002692 pat_lru_seed = ha_random();
Willy Tarreauf3045d22015-04-29 16:24:50 +02002693
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002694 /* Count pat_refs with user defined unique_id and totalt count */
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002695 list_for_each_entry(ref, &pattern_reference, list) {
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002696 len++;
2697 if (ref->unique_id != -1)
2698 unassigned_pos++;
2699 }
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002700
Tim Duesterhusb584b442020-03-17 21:08:24 +01002701 if (len == 0) {
2702 return 0;
2703 }
2704
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002705 arr = calloc(len, sizeof(*arr));
2706 if (arr == NULL) {
2707 ha_alert("Out of memory error.\n");
2708 return ERR_ALERT | ERR_FATAL;
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002709 }
2710
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002711 i = 0;
2712 j = unassigned_pos;
2713 list_for_each_entry(ref, &pattern_reference, list) {
2714 if (ref->unique_id != -1)
2715 arr[i++] = ref;
2716 else
2717 arr[j++] = ref;
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002718 }
2719
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002720 /* Sort first segment of array with user-defined unique ids for
2721 * fast lookup when generating unique ids
2722 */
2723 qsort(arr, unassigned_pos, sizeof(*arr), cmp_pat_ref);
2724
2725 /* Assign unique ids to the rest of the elements */
2726 for (i = unassigned_pos; i < len; i++) {
2727 do {
2728 arr[i]->unique_id = next_unique_id++;
2729 } while (bsearch(&arr[i], arr, unassigned_pos, sizeof(*arr), cmp_pat_ref));
2730 }
2731
2732 /* Sort complete array */
2733 qsort(arr, len, sizeof(*arr), cmp_pat_ref);
2734
2735 /* Convert back to linked list */
2736 for (i = 0; i < len; i++)
2737 LIST_ADDQ(&pr, &arr[i]->list);
2738
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002739 /* swap root */
2740 LIST_ADD(&pr, &pattern_reference);
2741 LIST_DEL(&pr);
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01002742
2743 free(arr);
2744 return 0;
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002745}
Willy Tarreau403bfbb2019-10-23 06:59:31 +02002746
2747static int pattern_per_thread_lru_alloc()
2748{
2749 if (!global.tune.pattern_cache)
2750 return 1;
2751 pat_lru_tree = lru64_new(global.tune.pattern_cache);
2752 return !!pat_lru_tree;
2753}
2754
2755static void pattern_per_thread_lru_free()
2756{
2757 lru64_destroy(pat_lru_tree);
2758}
2759
2760REGISTER_PER_THREAD_ALLOC(pattern_per_thread_lru_alloc);
2761REGISTER_PER_THREAD_FREE(pattern_per_thread_lru_free);