blob: c63365d74bf797767fade69fb09c7829459251a4 [file] [log] [blame]
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001/*
2 * Pattern management functions.
3 *
4 * Copyright 2000-2013 Willy Tarreau <w@1wt.eu>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13#include <ctype.h>
14#include <stdio.h>
15
16#include <common/config.h>
17#include <common/standard.h>
18
19#include <types/global.h>
20#include <types/pattern.h>
21
Thierry FOURNIER46006bd2014-03-21 21:45:15 +010022#include <proto/log.h>
Thierry FOURNIERed66c292013-11-28 11:05:19 +010023#include <proto/pattern.h>
Thierry FOURNIERe3ded592013-12-06 15:36:54 +010024#include <proto/sample.h>
Thierry FOURNIERed66c292013-11-28 11:05:19 +010025
26#include <ebsttree.h>
27
Thierry FOURNIERa65b3432013-11-28 18:22:00 +010028char *pat_match_names[PAT_MATCH_NUM] = {
29 [PAT_MATCH_FOUND] = "found",
30 [PAT_MATCH_BOOL] = "bool",
31 [PAT_MATCH_INT] = "int",
32 [PAT_MATCH_IP] = "ip",
33 [PAT_MATCH_BIN] = "bin",
34 [PAT_MATCH_LEN] = "len",
35 [PAT_MATCH_STR] = "str",
36 [PAT_MATCH_BEG] = "beg",
37 [PAT_MATCH_SUB] = "sub",
38 [PAT_MATCH_DIR] = "dir",
39 [PAT_MATCH_DOM] = "dom",
40 [PAT_MATCH_END] = "end",
41 [PAT_MATCH_REG] = "reg",
Thierry FOURNIERed66c292013-11-28 11:05:19 +010042};
43
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +020044int (*pat_parse_fcts[PAT_MATCH_NUM])(const char *, struct pattern *, int, char **) = {
Thierry FOURNIERa65b3432013-11-28 18:22:00 +010045 [PAT_MATCH_FOUND] = pat_parse_nothing,
46 [PAT_MATCH_BOOL] = pat_parse_nothing,
47 [PAT_MATCH_INT] = pat_parse_int,
48 [PAT_MATCH_IP] = pat_parse_ip,
49 [PAT_MATCH_BIN] = pat_parse_bin,
Thierry FOURNIER5d344082014-01-27 14:19:53 +010050 [PAT_MATCH_LEN] = pat_parse_int,
Thierry FOURNIERa65b3432013-11-28 18:22:00 +010051 [PAT_MATCH_STR] = pat_parse_str,
52 [PAT_MATCH_BEG] = pat_parse_str,
53 [PAT_MATCH_SUB] = pat_parse_str,
54 [PAT_MATCH_DIR] = pat_parse_str,
55 [PAT_MATCH_DOM] = pat_parse_str,
56 [PAT_MATCH_END] = pat_parse_str,
57 [PAT_MATCH_REG] = pat_parse_reg,
Thierry FOURNIERed66c292013-11-28 11:05:19 +010058};
59
Thierry FOURNIERb9b08462013-12-13 15:12:32 +010060int (*pat_index_fcts[PAT_MATCH_NUM])(struct pattern_expr *, struct pattern *, char **) = {
61 [PAT_MATCH_FOUND] = pat_idx_list_val,
62 [PAT_MATCH_BOOL] = pat_idx_list_val,
63 [PAT_MATCH_INT] = pat_idx_list_val,
64 [PAT_MATCH_IP] = pat_idx_tree_ip,
65 [PAT_MATCH_BIN] = pat_idx_list_ptr,
66 [PAT_MATCH_LEN] = pat_idx_list_val,
67 [PAT_MATCH_STR] = pat_idx_tree_str,
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +020068 [PAT_MATCH_BEG] = pat_idx_tree_pfx,
Thierry FOURNIERb9b08462013-12-13 15:12:32 +010069 [PAT_MATCH_SUB] = pat_idx_list_str,
70 [PAT_MATCH_DIR] = pat_idx_list_str,
71 [PAT_MATCH_DOM] = pat_idx_list_str,
72 [PAT_MATCH_END] = pat_idx_list_str,
73 [PAT_MATCH_REG] = pat_idx_list_reg,
74};
75
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +010076void (*pat_delete_fcts[PAT_MATCH_NUM])(struct pattern_expr *, struct pat_ref_elt *) = {
Thierry FOURNIERb1136502014-01-15 11:38:49 +010077 [PAT_MATCH_FOUND] = pat_del_list_val,
78 [PAT_MATCH_BOOL] = pat_del_list_val,
79 [PAT_MATCH_INT] = pat_del_list_val,
80 [PAT_MATCH_IP] = pat_del_tree_ip,
81 [PAT_MATCH_BIN] = pat_del_list_ptr,
82 [PAT_MATCH_LEN] = pat_del_list_val,
83 [PAT_MATCH_STR] = pat_del_tree_str,
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +020084 [PAT_MATCH_BEG] = pat_del_tree_str,
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +010085 [PAT_MATCH_SUB] = pat_del_list_ptr,
86 [PAT_MATCH_DIR] = pat_del_list_ptr,
87 [PAT_MATCH_DOM] = pat_del_list_ptr,
88 [PAT_MATCH_END] = pat_del_list_ptr,
Thierry FOURNIERb1136502014-01-15 11:38:49 +010089 [PAT_MATCH_REG] = pat_del_list_reg,
90};
91
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +010092void (*pat_prune_fcts[PAT_MATCH_NUM])(struct pattern_expr *) = {
93 [PAT_MATCH_FOUND] = pat_prune_val,
94 [PAT_MATCH_BOOL] = pat_prune_val,
95 [PAT_MATCH_INT] = pat_prune_val,
96 [PAT_MATCH_IP] = pat_prune_val,
97 [PAT_MATCH_BIN] = pat_prune_ptr,
98 [PAT_MATCH_LEN] = pat_prune_val,
99 [PAT_MATCH_STR] = pat_prune_ptr,
100 [PAT_MATCH_BEG] = pat_prune_ptr,
101 [PAT_MATCH_SUB] = pat_prune_ptr,
102 [PAT_MATCH_DIR] = pat_prune_ptr,
103 [PAT_MATCH_DOM] = pat_prune_ptr,
104 [PAT_MATCH_END] = pat_prune_ptr,
105 [PAT_MATCH_REG] = pat_prune_reg,
106};
107
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100108struct pattern *(*pat_match_fcts[PAT_MATCH_NUM])(struct sample *, struct pattern_expr *, int) = {
Thierry FOURNIERa65b3432013-11-28 18:22:00 +0100109 [PAT_MATCH_FOUND] = NULL,
110 [PAT_MATCH_BOOL] = pat_match_nothing,
111 [PAT_MATCH_INT] = pat_match_int,
112 [PAT_MATCH_IP] = pat_match_ip,
113 [PAT_MATCH_BIN] = pat_match_bin,
114 [PAT_MATCH_LEN] = pat_match_len,
115 [PAT_MATCH_STR] = pat_match_str,
116 [PAT_MATCH_BEG] = pat_match_beg,
117 [PAT_MATCH_SUB] = pat_match_sub,
118 [PAT_MATCH_DIR] = pat_match_dir,
119 [PAT_MATCH_DOM] = pat_match_dom,
120 [PAT_MATCH_END] = pat_match_end,
121 [PAT_MATCH_REG] = pat_match_reg,
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100122};
123
Thierry FOURNIERe3ded592013-12-06 15:36:54 +0100124/* Just used for checking configuration compatibility */
125int pat_match_types[PAT_MATCH_NUM] = {
126 [PAT_MATCH_FOUND] = SMP_T_UINT,
127 [PAT_MATCH_BOOL] = SMP_T_UINT,
128 [PAT_MATCH_INT] = SMP_T_UINT,
129 [PAT_MATCH_IP] = SMP_T_ADDR,
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100130 [PAT_MATCH_BIN] = SMP_T_BIN,
131 [PAT_MATCH_LEN] = SMP_T_STR,
132 [PAT_MATCH_STR] = SMP_T_STR,
133 [PAT_MATCH_BEG] = SMP_T_STR,
134 [PAT_MATCH_SUB] = SMP_T_STR,
135 [PAT_MATCH_DIR] = SMP_T_STR,
136 [PAT_MATCH_DOM] = SMP_T_STR,
137 [PAT_MATCH_END] = SMP_T_STR,
138 [PAT_MATCH_REG] = SMP_T_STR,
Thierry FOURNIERe3ded592013-12-06 15:36:54 +0100139};
140
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100141/* this struct is used to return information */
142static struct pattern static_pattern;
143
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100144/* This is the root of the list of all pattern_ref avalaibles. */
145struct list pattern_reference = LIST_HEAD_INIT(pattern_reference);
146
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100147/*
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100148 *
149 * The following functions are not exported and are used by internals process
150 * of pattern matching
151 *
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100152 */
153
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100154/* Background: Fast way to find a zero byte in a word
155 * http://graphics.stanford.edu/~seander/bithacks.html#ZeroInWord
156 * hasZeroByte = (v - 0x01010101UL) & ~v & 0x80808080UL;
157 *
158 * To look for 4 different byte values, xor the word with those bytes and
159 * then check for zero bytes:
160 *
161 * v = (((unsigned char)c * 0x1010101U) ^ delimiter)
162 * where <delimiter> is the 4 byte values to look for (as an uint)
163 * and <c> is the character that is being tested
164 */
165static inline unsigned int is_delimiter(unsigned char c, unsigned int mask)
166{
167 mask ^= (c * 0x01010101); /* propagate the char to all 4 bytes */
168 return (mask - 0x01010101) & ~mask & 0x80808080U;
169}
170
171static inline unsigned int make_4delim(unsigned char d1, unsigned char d2, unsigned char d3, unsigned char d4)
172{
173 return d1 << 24 | d2 << 16 | d3 << 8 | d4;
174}
175
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100176
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100177/*
178 *
179 * These functions are exported and may be used by any other component.
180 *
Willy Tarreau5def8ef2014-08-29 15:19:33 +0200181 * The following functions are used for parsing pattern matching input value.
182 * The <text> contain the string to be parsed. <pattern> must be a preallocated
183 * pattern. The pat_parse_* functions fill this structure with the parsed value.
184 * <err> is filled with an error message built with memprintf() function. It is
185 * allowed to use a trash as a temporary storage for the returned pattern, as
186 * the next call after these functions will be pat_idx_*.
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100187 *
Willy Tarreau5def8ef2014-08-29 15:19:33 +0200188 * In success case, the pat_parse_* function returns 1. If the function
189 * fails, it returns 0 and <err> is filled.
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100190 */
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100191
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100192/* ignore the current line */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200193int pat_parse_nothing(const char *text, struct pattern *pattern, int mflags, char **err)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100194{
195 return 1;
196}
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100197
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100198/* Parse a string. It is allocated and duplicated. */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200199int pat_parse_str(const char *text, struct pattern *pattern, int mflags, char **err)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100200{
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100201 pattern->type = SMP_T_STR;
Thierry FOURNIERedc15c32013-12-13 15:36:59 +0100202 pattern->ptr.str = (char *)text;
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100203 pattern->len = strlen(text);
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100204 return 1;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100205}
206
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100207/* Parse a binary written in hexa. It is allocated. */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200208int pat_parse_bin(const char *text, struct pattern *pattern, int mflags, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100209{
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100210 struct chunk *trash;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100211
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100212 pattern->type = SMP_T_BIN;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100213 trash = get_trash_chunk();
214 pattern->len = trash->size;
215 pattern->ptr.str = trash->str;
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100216 return !!parse_binary(text, &pattern->ptr.str, &pattern->len, err);
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100217}
218
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100219/* Parse a regex. It is allocated. */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200220int pat_parse_reg(const char *text, struct pattern *pattern, int mflags, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100221{
Thierry FOURNIER0b6d15f2014-01-29 19:35:16 +0100222 pattern->ptr.str = (char *)text;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100223 return 1;
224}
225
226/* Parse a range of positive integers delimited by either ':' or '-'. If only
227 * one integer is read, it is set as both min and max. An operator may be
228 * specified as the prefix, among this list of 5 :
229 *
230 * 0:eq, 1:gt, 2:ge, 3:lt, 4:le
231 *
232 * The default operator is "eq". It supports range matching. Ranges are
233 * rejected for other operators. The operator may be changed at any time.
234 * The operator is stored in the 'opaque' argument.
235 *
236 * If err is non-NULL, an error message will be returned there on errors and
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100237 * the caller will have to free it. The function returns zero on error, and
238 * non-zero on success.
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100239 *
240 */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200241int pat_parse_int(const char *text, struct pattern *pattern, int mflags, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100242{
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100243 const char *ptr = text;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100244
245 pattern->type = SMP_T_UINT;
Thierry FOURNIER7148ce62013-12-06 19:06:43 +0100246
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100247 /* Empty string is not valid */
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100248 if (!*text)
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100249 goto not_valid_range;
250
251 /* Search ':' or '-' separator. */
252 while (*ptr != '\0' && *ptr != ':' && *ptr != '-')
253 ptr++;
254
255 /* If separator not found. */
256 if (!*ptr) {
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100257 if (strl2llrc(text, ptr - text, &pattern->val.range.min) != 0) {
258 memprintf(err, "'%s' is not a number", text);
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100259 return 0;
260 }
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100261 pattern->val.range.max = pattern->val.range.min;
262 pattern->val.range.min_set = 1;
263 pattern->val.range.max_set = 1;
264 return 1;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100265 }
266
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100267 /* If the separator is the first character. */
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100268 if (ptr == text && *(ptr + 1) != '\0') {
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100269 if (strl2llrc(ptr + 1, strlen(ptr + 1), &pattern->val.range.max) != 0)
270 goto not_valid_range;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100271
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100272 pattern->val.range.min_set = 0;
273 pattern->val.range.max_set = 1;
274 return 1;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100275 }
276
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100277 /* If separator is the last character. */
278 if (*(ptr + 1) == '\0') {
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100279 if (strl2llrc(text, ptr - text, &pattern->val.range.min) != 0)
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100280 goto not_valid_range;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100281
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100282 pattern->val.range.min_set = 1;
283 pattern->val.range.max_set = 0;
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100284 return 1;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100285 }
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100286
287 /* Else, parse two numbers. */
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100288 if (strl2llrc(text, ptr - text, &pattern->val.range.min) != 0)
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100289 goto not_valid_range;
290
291 if (strl2llrc(ptr + 1, strlen(ptr + 1), &pattern->val.range.max) != 0)
292 goto not_valid_range;
293
294 if (pattern->val.range.min > pattern->val.range.max)
295 goto not_valid_range;
296
297 pattern->val.range.min_set = 1;
298 pattern->val.range.max_set = 1;
299 return 1;
300
301 not_valid_range:
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100302 memprintf(err, "'%s' is not a valid number range", text);
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100303 return 0;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100304}
305
306/* Parse a range of positive 2-component versions delimited by either ':' or
307 * '-'. The version consists in a major and a minor, both of which must be
308 * smaller than 65536, because internally they will be represented as a 32-bit
309 * integer.
310 * If only one version is read, it is set as both min and max. Just like for
311 * pure integers, an operator may be specified as the prefix, among this list
312 * of 5 :
313 *
314 * 0:eq, 1:gt, 2:ge, 3:lt, 4:le
315 *
316 * The default operator is "eq". It supports range matching. Ranges are
317 * rejected for other operators. The operator may be changed at any time.
318 * The operator is stored in the 'opaque' argument. This allows constructs
319 * such as the following one :
320 *
321 * acl obsolete_ssl ssl_req_proto lt 3
322 * acl unsupported_ssl ssl_req_proto gt 3.1
323 * acl valid_ssl ssl_req_proto 3.0-3.1
324 *
325 */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200326int pat_parse_dotted_ver(const char *text, struct pattern *pattern, int mflags, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100327{
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100328 const char *ptr = text;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100329
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100330 pattern->type = SMP_T_UINT;
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100331
332 /* Search ':' or '-' separator. */
333 while (*ptr != '\0' && *ptr != ':' && *ptr != '-')
334 ptr++;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100335
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100336 /* If separator not found. */
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100337 if (*ptr == '\0' && ptr > text) {
338 if (strl2llrc_dotted(text, ptr-text, &pattern->val.range.min) != 0) {
339 memprintf(err, "'%s' is not a dotted number", text);
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100340 return 0;
341 }
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100342 pattern->val.range.max = pattern->val.range.min;
343 pattern->val.range.min_set = 1;
344 pattern->val.range.max_set = 1;
345 return 1;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100346 }
347
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100348 /* If the separator is the first character. */
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100349 if (ptr == text && *(ptr+1) != '\0') {
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100350 if (strl2llrc_dotted(ptr+1, strlen(ptr+1), &pattern->val.range.max) != 0) {
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100351 memprintf(err, "'%s' is not a valid dotted number range", text);
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100352 return 0;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100353 }
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100354 pattern->val.range.min_set = 0;
355 pattern->val.range.max_set = 1;
356 return 1;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100357 }
358
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100359 /* If separator is the last character. */
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100360 if (ptr == &text[strlen(text)-1]) {
361 if (strl2llrc_dotted(text, ptr-text, &pattern->val.range.min) != 0) {
362 memprintf(err, "'%s' is not a valid dotted number range", text);
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100363 return 0;
364 }
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100365 pattern->val.range.min_set = 1;
366 pattern->val.range.max_set = 0;
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100367 return 1;
368 }
369
370 /* Else, parse two numbers. */
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100371 if (strl2llrc_dotted(text, ptr-text, &pattern->val.range.min) != 0) {
372 memprintf(err, "'%s' is not a valid dotted number range", text);
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100373 return 0;
374 }
375 if (strl2llrc_dotted(ptr+1, strlen(ptr+1), &pattern->val.range.max) != 0) {
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100376 memprintf(err, "'%s' is not a valid dotted number range", text);
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100377 return 0;
378 }
379 if (pattern->val.range.min > pattern->val.range.max) {
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100380 memprintf(err, "'%s' is not a valid dotted number range", text);
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100381 return 0;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100382 }
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100383 pattern->val.range.min_set = 1;
384 pattern->val.range.max_set = 1;
385 return 1;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100386}
387
388/* Parse an IP address and an optional mask in the form addr[/mask].
389 * The addr may either be an IPv4 address or a hostname. The mask
390 * may either be a dotted mask or a number of bits. Returns 1 if OK,
391 * otherwise 0. NOTE: IP address patterns are typed (IPV4/IPV6).
392 */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200393int pat_parse_ip(const char *text, struct pattern *pattern, int mflags, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100394{
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200395 if (str2net(text, !(mflags & PAT_MF_NO_DNS) && (global.mode & MODE_STARTING),
Thierry FOURNIERfc7ac7b2014-02-11 15:23:04 +0100396 &pattern->val.ipv4.addr, &pattern->val.ipv4.mask)) {
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100397 pattern->type = SMP_T_IPV4;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100398 return 1;
399 }
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100400 else if (str62net(text, &pattern->val.ipv6.addr, &pattern->val.ipv6.mask)) {
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100401 pattern->type = SMP_T_IPV6;
402 return 1;
403 }
404 else {
Thierry FOURNIER580c32c2014-01-24 10:58:12 +0100405 memprintf(err, "'%s' is not a valid IPv4 or IPv6 address", text);
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100406 return 0;
407 }
408}
409
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100410/*
411 *
412 * These functions are exported and may be used by any other component.
413 *
414 * This fucntion just take a sample <smp> and check if this sample match
415 * with the pattern <pattern>. This fucntion return just PAT_MATCH or
416 * PAT_NOMATCH.
417 *
418 */
419
420/* always return false */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100421struct pattern *pat_match_nothing(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100422{
Thierry FOURNIERe5978bf2014-03-17 19:53:10 +0100423 if (smp->data.uint) {
424 if (fill) {
425 static_pattern.smp = NULL;
426 static_pattern.ref = NULL;
Thierry FOURNIERe5978bf2014-03-17 19:53:10 +0100427 static_pattern.type = 0;
428 static_pattern.ptr.str = NULL;
429 }
430 return &static_pattern;
431 }
432 else
433 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100434}
435
436
437/* NB: For two strings to be identical, it is required that their lengths match */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100438struct pattern *pat_match_str(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100439{
440 int icase;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100441 struct ebmb_node *node;
442 char prev;
443 struct pattern_tree *elt;
444 struct pattern_list *lst;
445 struct pattern *pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100446
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100447 /* Lookup a string in the expression's pattern tree. */
448 if (!eb_is_empty(&expr->pattern_tree)) {
449 /* we may have to force a trailing zero on the test pattern */
450 prev = smp->data.str.str[smp->data.str.len];
451 if (prev)
452 smp->data.str.str[smp->data.str.len] = '\0';
453 node = ebst_lookup(&expr->pattern_tree, smp->data.str.str);
454 if (prev)
455 smp->data.str.str[smp->data.str.len] = prev;
456
457 if (node) {
458 if (fill) {
459 elt = ebmb_entry(node, struct pattern_tree, node);
460 static_pattern.smp = elt->smp;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +0100461 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200462 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100463 static_pattern.type = SMP_T_STR;
464 static_pattern.ptr.str = (char *)elt->node.key;
465 }
466 return &static_pattern;
467 }
468 }
469
470 /* look in the list */
471 list_for_each_entry(lst, &expr->patterns, list) {
472 pattern = &lst->pat;
473
474 if (pattern->len != smp->data.str.len)
475 continue;
476
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200477 icase = expr->mflags & PAT_MF_IGNORE_CASE;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100478 if ((icase && strncasecmp(pattern->ptr.str, smp->data.str.str, smp->data.str.len) == 0) ||
479 (!icase && strncmp(pattern->ptr.str, smp->data.str.str, smp->data.str.len) == 0))
480 return pattern;
481 }
482
483 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100484}
485
486/* NB: For two binaries buf to be identical, it is required that their lengths match */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100487struct pattern *pat_match_bin(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100488{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100489 struct pattern_list *lst;
490 struct pattern *pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100491
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100492 /* Look in the list. */
493 list_for_each_entry(lst, &expr->patterns, list) {
494 pattern = &lst->pat;
495
496 if (pattern->len != smp->data.str.len)
497 continue;
498
499 if (memcmp(pattern->ptr.str, smp->data.str.str, smp->data.str.len) == 0)
500 return pattern;
501 }
502
503 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100504}
505
506/* Executes a regex. It temporarily changes the data to add a trailing zero,
507 * and restores the previous character when leaving.
508 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100509struct pattern *pat_match_reg(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100510{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100511 struct pattern_list *lst;
512 struct pattern *pattern;
513
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100514 /* look in the list */
515 list_for_each_entry(lst, &expr->patterns, list) {
516 pattern = &lst->pat;
517
Thierry FOURNIERb8f980c2014-06-11 13:59:05 +0200518 if (regex_exec2(pattern->ptr.reg, smp->data.str.str, smp->data.str.len))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100519 return pattern;
520 }
521 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100522}
523
524/* Checks that the pattern matches the beginning of the tested string. */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100525struct pattern *pat_match_beg(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100526{
527 int icase;
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200528 struct ebmb_node *node;
529 char prev;
530 struct pattern_tree *elt;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100531 struct pattern_list *lst;
532 struct pattern *pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100533
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +0200534 /* Lookup a string in the expression's pattern tree. */
535 if (!eb_is_empty(&expr->pattern_tree)) {
536 /* we may have to force a trailing zero on the test pattern */
537 prev = smp->data.str.str[smp->data.str.len];
538 if (prev)
539 smp->data.str.str[smp->data.str.len] = '\0';
540 node = ebmb_lookup_longest(&expr->pattern_tree, smp->data.str.str);
541 if (prev)
542 smp->data.str.str[smp->data.str.len] = prev;
543
544 if (node) {
545 if (fill) {
546 elt = ebmb_entry(node, struct pattern_tree, node);
547 static_pattern.smp = elt->smp;
548 static_pattern.ref = elt->ref;
549 static_pattern.sflags = PAT_SF_TREE;
550 static_pattern.type = SMP_T_STR;
551 static_pattern.ptr.str = (char *)elt->node.key;
552 }
553 return &static_pattern;
554 }
555 }
556
557 /* look in the list */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100558 list_for_each_entry(lst, &expr->patterns, list) {
559 pattern = &lst->pat;
560
561 if (pattern->len > smp->data.str.len)
562 continue;
563
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200564 icase = expr->mflags & PAT_MF_IGNORE_CASE;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100565 if ((icase && strncasecmp(pattern->ptr.str, smp->data.str.str, pattern->len) != 0) ||
566 (!icase && strncmp(pattern->ptr.str, smp->data.str.str, pattern->len) != 0))
567 continue;
568
569 return pattern;
570 }
571 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100572}
573
574/* Checks that the pattern matches the end of the tested string. */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100575struct pattern *pat_match_end(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100576{
577 int icase;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100578 struct pattern_list *lst;
579 struct pattern *pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100580
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100581 list_for_each_entry(lst, &expr->patterns, list) {
582 pattern = &lst->pat;
583
584 if (pattern->len > smp->data.str.len)
585 continue;
586
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200587 icase = expr->mflags & PAT_MF_IGNORE_CASE;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100588 if ((icase && strncasecmp(pattern->ptr.str, smp->data.str.str + smp->data.str.len - pattern->len, pattern->len) != 0) ||
589 (!icase && strncmp(pattern->ptr.str, smp->data.str.str + smp->data.str.len - pattern->len, pattern->len) != 0))
590 continue;
591
592 return pattern;
593 }
594 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100595}
596
597/* Checks that the pattern is included inside the tested string.
598 * NB: Suboptimal, should be rewritten using a Boyer-Moore method.
599 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100600struct pattern *pat_match_sub(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100601{
602 int icase;
603 char *end;
604 char *c;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100605 struct pattern_list *lst;
606 struct pattern *pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100607
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100608 list_for_each_entry(lst, &expr->patterns, list) {
609 pattern = &lst->pat;
610
611 if (pattern->len > smp->data.str.len)
612 continue;
613
614 end = smp->data.str.str + smp->data.str.len - pattern->len;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200615 icase = expr->mflags & PAT_MF_IGNORE_CASE;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100616 if (icase) {
617 for (c = smp->data.str.str; c <= end; c++) {
618 if (tolower(*c) != tolower(*pattern->ptr.str))
619 continue;
620 if (strncasecmp(pattern->ptr.str, c, pattern->len) == 0)
621 return pattern;
622 }
623 } else {
624 for (c = smp->data.str.str; c <= end; c++) {
625 if (*c != *pattern->ptr.str)
626 continue;
627 if (strncmp(pattern->ptr.str, c, pattern->len) == 0)
628 return pattern;
629 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100630 }
631 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100632 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100633}
634
635/* This one is used by other real functions. It checks that the pattern is
636 * included inside the tested string, but enclosed between the specified
637 * delimiters or at the beginning or end of the string. The delimiters are
638 * provided as an unsigned int made by make_4delim() and match up to 4 different
639 * delimiters. Delimiters are stripped at the beginning and end of the pattern.
640 */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200641static int match_word(struct sample *smp, struct pattern *pattern, int mflags, unsigned int delimiters)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100642{
643 int may_match, icase;
644 char *c, *end;
645 char *ps;
646 int pl;
647
648 pl = pattern->len;
649 ps = pattern->ptr.str;
650
651 while (pl > 0 && is_delimiter(*ps, delimiters)) {
652 pl--;
653 ps++;
654 }
655
656 while (pl > 0 && is_delimiter(ps[pl - 1], delimiters))
657 pl--;
658
659 if (pl > smp->data.str.len)
660 return PAT_NOMATCH;
661
662 may_match = 1;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200663 icase = mflags & PAT_MF_IGNORE_CASE;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100664 end = smp->data.str.str + smp->data.str.len - pl;
665 for (c = smp->data.str.str; c <= end; c++) {
666 if (is_delimiter(*c, delimiters)) {
667 may_match = 1;
668 continue;
669 }
670
671 if (!may_match)
672 continue;
673
674 if (icase) {
675 if ((tolower(*c) == tolower(*ps)) &&
676 (strncasecmp(ps, c, pl) == 0) &&
677 (c == end || is_delimiter(c[pl], delimiters)))
678 return PAT_MATCH;
679 } else {
680 if ((*c == *ps) &&
681 (strncmp(ps, c, pl) == 0) &&
682 (c == end || is_delimiter(c[pl], delimiters)))
683 return PAT_MATCH;
684 }
685 may_match = 0;
686 }
687 return PAT_NOMATCH;
688}
689
690/* Checks that the pattern is included inside the tested string, but enclosed
691 * between the delimiters '?' or '/' or at the beginning or end of the string.
692 * Delimiters at the beginning or end of the pattern are ignored.
693 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100694struct pattern *pat_match_dir(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100695{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100696 struct pattern_list *lst;
697 struct pattern *pattern;
698
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100699 list_for_each_entry(lst, &expr->patterns, list) {
700 pattern = &lst->pat;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200701 if (match_word(smp, pattern, expr->mflags, make_4delim('/', '?', '?', '?')))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100702 return pattern;
703 }
704 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100705}
706
707/* Checks that the pattern is included inside the tested string, but enclosed
708 * between the delmiters '/', '?', '.' or ":" or at the beginning or end of
709 * the string. Delimiters at the beginning or end of the pattern are ignored.
710 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100711struct pattern *pat_match_dom(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100712{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100713 struct pattern_list *lst;
714 struct pattern *pattern;
715
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100716 list_for_each_entry(lst, &expr->patterns, list) {
717 pattern = &lst->pat;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200718 if (match_word(smp, pattern, expr->mflags, make_4delim('/', '?', '.', ':')))
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100719 return pattern;
720 }
721 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100722}
723
724/* Checks that the integer in <test> is included between min and max */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100725struct pattern *pat_match_int(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100726{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100727 struct pattern_list *lst;
728 struct pattern *pattern;
729
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100730 list_for_each_entry(lst, &expr->patterns, list) {
731 pattern = &lst->pat;
732 if ((!pattern->val.range.min_set || pattern->val.range.min <= smp->data.uint) &&
733 (!pattern->val.range.max_set || smp->data.uint <= pattern->val.range.max))
734 return pattern;
735 }
736 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100737}
738
739/* Checks that the length of the pattern in <test> is included between min and max */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100740struct pattern *pat_match_len(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100741{
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100742 struct pattern_list *lst;
743 struct pattern *pattern;
744
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100745 list_for_each_entry(lst, &expr->patterns, list) {
746 pattern = &lst->pat;
747 if ((!pattern->val.range.min_set || pattern->val.range.min <= smp->data.str.len) &&
748 (!pattern->val.range.max_set || smp->data.str.len <= pattern->val.range.max))
749 return pattern;
750 }
751 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100752}
753
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100754struct pattern *pat_match_ip(struct sample *smp, struct pattern_expr *expr, int fill)
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100755{
756 unsigned int v4; /* in network byte order */
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100757 struct in6_addr tmp6;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100758 struct in_addr *s;
759 struct ebmb_node *node;
760 struct pattern_tree *elt;
761 struct pattern_list *lst;
762 struct pattern *pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100763
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100764 /* The input sample is IPv4. Try to match in the trees. */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100765 if (smp->type == SMP_T_IPV4) {
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100766 /* Lookup an IPv4 address in the expression's pattern tree using
767 * the longest match method.
768 */
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100769 s = &smp->data.ipv4;
770 node = ebmb_lookup_longest(&expr->pattern_tree, &s->s_addr);
771 if (node) {
772 if (fill) {
773 elt = ebmb_entry(node, struct pattern_tree, node);
774 static_pattern.smp = elt->smp;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +0100775 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200776 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100777 static_pattern.type = SMP_T_IPV4;
778 memcpy(&static_pattern.val.ipv4.addr.s_addr, elt->node.key, 4);
779 if (!cidr2dotted(elt->node.node.pfx, &static_pattern.val.ipv4.mask))
780 return NULL;
781 }
782 return &static_pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100783 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100784
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100785 /* The IPv4 sample dont match the IPv4 tree. Convert the IPv4
786 * sample address to IPv6 with the mapping method using the ::ffff:
787 * prefix, and try to lookup in the IPv6 tree.
788 */
789 memset(&tmp6, 0, 10);
790 *(uint16_t*)&tmp6.s6_addr[10] = htons(0xffff);
791 *(uint32_t*)&tmp6.s6_addr[12] = smp->data.ipv4.s_addr;
792 node = ebmb_lookup_longest(&expr->pattern_tree_2, &tmp6);
793 if (node) {
794 if (fill) {
795 elt = ebmb_entry(node, struct pattern_tree, node);
796 static_pattern.smp = elt->smp;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +0100797 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200798 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100799 static_pattern.type = SMP_T_IPV6;
800 memcpy(&static_pattern.val.ipv6.addr, elt->node.key, 16);
801 static_pattern.val.ipv6.mask = elt->node.node.pfx;
802 }
803 return &static_pattern;
804 }
805 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100806
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100807 /* The input sample is IPv6. Try to match in the trees. */
808 if (smp->type == SMP_T_IPV6) {
809 /* Lookup an IPv6 address in the expression's pattern tree using
810 * the longest match method.
811 */
812 node = ebmb_lookup_longest(&expr->pattern_tree_2, &smp->data.ipv6);
813 if (node) {
814 if (fill) {
815 elt = ebmb_entry(node, struct pattern_tree, node);
816 static_pattern.smp = elt->smp;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +0100817 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200818 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100819 static_pattern.type = SMP_T_IPV6;
820 memcpy(&static_pattern.val.ipv6.addr, elt->node.key, 16);
821 static_pattern.val.ipv6.mask = elt->node.node.pfx;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100822 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100823 return &static_pattern;
824 }
825
826 /* Try to convert 6 to 4 when the start of the ipv6 address match the
827 * following forms :
828 * - ::ffff:ip:v4 (ipv4 mapped)
829 * - ::0000:ip:v4 (old ipv4 mapped)
830 * - 2002:ip:v4:: (6to4)
831 */
832 if ((*(uint32_t*)&smp->data.ipv6.s6_addr[0] == 0 &&
833 *(uint32_t*)&smp->data.ipv6.s6_addr[4] == 0 &&
834 (*(uint32_t*)&smp->data.ipv6.s6_addr[8] == 0 ||
835 *(uint32_t*)&smp->data.ipv6.s6_addr[8] == htonl(0xFFFF))) ||
836 *(uint16_t*)&smp->data.ipv6.s6_addr[0] == htons(0x2002)) {
837 if (*(uint32_t*)&smp->data.ipv6.s6_addr[0] == 0)
838 v4 = *(uint32_t*)&smp->data.ipv6.s6_addr[12];
839 else
840 v4 = htonl((ntohs(*(uint16_t*)&smp->data.ipv6.s6_addr[2]) << 16) +
841 ntohs(*(uint16_t*)&smp->data.ipv6.s6_addr[4]));
842
843 /* Lookup an IPv4 address in the expression's pattern tree using the longest
844 * match method.
845 */
846 node = ebmb_lookup_longest(&expr->pattern_tree, &v4);
847 if (node) {
848 if (fill) {
849 elt = ebmb_entry(node, struct pattern_tree, node);
850 static_pattern.smp = elt->smp;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +0100851 static_pattern.ref = elt->ref;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200852 static_pattern.sflags = PAT_SF_TREE;
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100853 static_pattern.type = SMP_T_IPV4;
854 memcpy(&static_pattern.val.ipv4.addr.s_addr, elt->node.key, 4);
855 if (!cidr2dotted(elt->node.node.pfx, &static_pattern.val.ipv4.mask))
856 return NULL;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100857 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100858 return &static_pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100859 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100860 }
861 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100862
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100863 /* Lookup in the list. the list contain only IPv4 patterns */
864 list_for_each_entry(lst, &expr->patterns, list) {
865 pattern = &lst->pat;
866
867 /* The input sample is IPv4, use it as is. */
868 if (smp->type == SMP_T_IPV4) {
869 v4 = smp->data.ipv4.s_addr;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100870 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100871 else if (smp->type == SMP_T_IPV6) {
872 /* v4 match on a V6 sample. We want to check at least for
873 * the following forms :
874 * - ::ffff:ip:v4 (ipv4 mapped)
875 * - ::0000:ip:v4 (old ipv4 mapped)
876 * - 2002:ip:v4:: (6to4)
877 */
878 if (*(uint32_t*)&smp->data.ipv6.s6_addr[0] == 0 &&
879 *(uint32_t*)&smp->data.ipv6.s6_addr[4] == 0 &&
880 (*(uint32_t*)&smp->data.ipv6.s6_addr[8] == 0 ||
881 *(uint32_t*)&smp->data.ipv6.s6_addr[8] == htonl(0xFFFF))) {
882 v4 = *(uint32_t*)&smp->data.ipv6.s6_addr[12];
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100883 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100884 else if (*(uint16_t*)&smp->data.ipv6.s6_addr[0] == htons(0x2002)) {
885 v4 = htonl((ntohs(*(uint16_t*)&smp->data.ipv6.s6_addr[2]) << 16) +
886 ntohs(*(uint16_t*)&smp->data.ipv6.s6_addr[4]));
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100887 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100888 else
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100889 continue;
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100890 }
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100891
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100892 /* Check if the input sample match the current pattern. */
893 if (((v4 ^ pattern->val.ipv4.addr.s_addr) & pattern->val.ipv4.mask.s_addr) == 0)
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100894 return pattern;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100895 }
Thierry FOURNIER5338eea2013-12-16 14:22:13 +0100896 return NULL;
Thierry FOURNIERe7ba2362014-01-21 11:25:41 +0100897}
898
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100899void free_pattern_tree(struct eb_root *root)
900{
901 struct eb_node *node, *next;
Thierry FOURNIERe1bcac52013-12-13 16:09:50 +0100902 struct pattern_tree *elt;
Thierry FOURNIER3ce88c72013-12-09 11:29:46 +0100903
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100904 node = eb_first(root);
905 while (node) {
906 next = eb_next(node);
907 eb_delete(node);
Thierry FOURNIERe1bcac52013-12-13 16:09:50 +0100908 elt = container_of(node, struct pattern_tree, node);
Thierry FOURNIERc64de3f2013-12-10 15:08:39 +0100909 free(elt->smp);
Thierry FOURNIER3ce88c72013-12-09 11:29:46 +0100910 free(elt);
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100911 node = next;
912 }
913}
914
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +0100915void pat_prune_val(struct pattern_expr *expr)
Thierry FOURNIERd163e1c2013-11-28 11:41:23 +0100916{
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +0100917 struct pattern_list *pat, *tmp;
918
919 list_for_each_entry_safe(pat, tmp, &expr->patterns, list) {
920 free(pat->pat.smp);
921 free(pat);
922 }
923
Thierry FOURNIERd163e1c2013-11-28 11:41:23 +0100924 free_pattern_tree(&expr->pattern_tree);
Thierry FOURNIER33a74332013-12-19 23:54:54 +0100925 free_pattern_tree(&expr->pattern_tree_2);
Thierry FOURNIERd163e1c2013-11-28 11:41:23 +0100926 LIST_INIT(&expr->patterns);
927}
928
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +0100929void pat_prune_ptr(struct pattern_expr *expr)
930{
931 struct pattern_list *pat, *tmp;
932
933 list_for_each_entry_safe(pat, tmp, &expr->patterns, list) {
934 free(pat->pat.ptr.ptr);
935 free(pat->pat.smp);
936 free(pat);
937 }
938
939 free_pattern_tree(&expr->pattern_tree);
940 free_pattern_tree(&expr->pattern_tree_2);
941 LIST_INIT(&expr->patterns);
942}
943
944void pat_prune_reg(struct pattern_expr *expr)
945{
946 struct pattern_list *pat, *tmp;
947
948 list_for_each_entry_safe(pat, tmp, &expr->patterns, list) {
949 regex_free(pat->pat.ptr.ptr);
950 free(pat->pat.smp);
951 free(pat);
952 }
953
954 free_pattern_tree(&expr->pattern_tree);
955 free_pattern_tree(&expr->pattern_tree_2);
956 LIST_INIT(&expr->patterns);
957}
958
Thierry FOURNIERb9b08462013-12-13 15:12:32 +0100959/*
960 *
961 * The following functions are used for the pattern indexation
962 *
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100963 */
Thierry FOURNIERb9b08462013-12-13 15:12:32 +0100964
965int pat_idx_list_val(struct pattern_expr *expr, struct pattern *pat, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100966{
Thierry FOURNIERb9b08462013-12-13 15:12:32 +0100967 struct pattern_list *patl;
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100968
Thierry FOURNIERb9b08462013-12-13 15:12:32 +0100969 /* allocate pattern */
970 patl = calloc(1, sizeof(*patl));
971 if (!patl) {
972 memprintf(err, "out of memory while indexing pattern");
Thierry FOURNIER972028f2014-01-23 17:53:31 +0100973 return 0;
974 }
Thierry FOURNIERed66c292013-11-28 11:05:19 +0100975
Thierry FOURNIERb9b08462013-12-13 15:12:32 +0100976 /* duplicate pattern */
977 memcpy(&patl->pat, pat, sizeof(*pat));
Thierry FOURNIER7148ce62013-12-06 19:06:43 +0100978
Thierry FOURNIERb9b08462013-12-13 15:12:32 +0100979 /* chain pattern in the expression */
980 LIST_ADDQ(&expr->patterns, &patl->list);
981
982 /* that's ok */
983 return 1;
984}
985
986int pat_idx_list_ptr(struct pattern_expr *expr, struct pattern *pat, char **err)
987{
988 struct pattern_list *patl;
989
990 /* allocate pattern */
991 patl = calloc(1, sizeof(*patl));
992 if (!patl)
Thierry FOURNIER972028f2014-01-23 17:53:31 +0100993 return 0;
Thierry FOURNIER7148ce62013-12-06 19:06:43 +0100994
Thierry FOURNIERb9b08462013-12-13 15:12:32 +0100995 /* duplicate pattern */
996 memcpy(&patl->pat, pat, sizeof(*pat));
997 patl->pat.ptr.ptr = malloc(patl->pat.len);
998 if (!patl->pat.ptr.ptr) {
999 free(patl);
1000 memprintf(err, "out of memory while indexing pattern");
1001 return 0;
1002 }
1003 memcpy(patl->pat.ptr.ptr, pat->ptr.ptr, pat->len);
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001004
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001005 /* chain pattern in the expression */
1006 LIST_ADDQ(&expr->patterns, &patl->list);
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001007
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001008 /* that's ok */
1009 return 1;
1010}
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001011
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001012int pat_idx_list_str(struct pattern_expr *expr, struct pattern *pat, char **err)
1013{
1014 struct pattern_list *patl;
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001015
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001016 /* allocate pattern */
1017 patl = calloc(1, sizeof(*patl));
1018 if (!patl) {
1019 memprintf(err, "out of memory while indexing pattern");
1020 return 0;
1021 }
1022
1023 /* duplicate pattern */
1024 memcpy(&patl->pat, pat, sizeof(*pat));
1025 patl->pat.ptr.str = malloc(patl->pat.len + 1);
1026 if (!patl->pat.ptr.str) {
1027 free(patl);
1028 memprintf(err, "out of memory while indexing pattern");
1029 return 0;
1030 }
1031 memcpy(patl->pat.ptr.ptr, pat->ptr.ptr, pat->len);
1032 patl->pat.ptr.str[patl->pat.len] = '\0';
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001033
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001034 /* chain pattern in the expression */
1035 LIST_ADDQ(&expr->patterns, &patl->list);
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001036
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001037 /* that's ok */
1038 return 1;
1039}
1040
1041int pat_idx_list_reg(struct pattern_expr *expr, struct pattern *pat, char **err)
1042{
1043 struct pattern_list *patl;
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001044
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001045 /* allocate pattern */
1046 patl = calloc(1, sizeof(*patl));
1047 if (!patl) {
1048 memprintf(err, "out of memory while indexing pattern");
1049 return 0;
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001050 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001051
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001052 /* duplicate pattern */
1053 memcpy(&patl->pat, pat, sizeof(*pat));
1054
1055 /* allocate regex */
1056 patl->pat.ptr.reg = calloc(1, sizeof(*patl->pat.ptr.reg));
1057 if (!patl->pat.ptr.reg) {
1058 free(patl);
1059 memprintf(err, "out of memory while indexing pattern");
1060 return 0;
1061 }
1062
1063 /* compile regex */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001064 if (!regex_comp(pat->ptr.str, patl->pat.ptr.reg, !(expr->mflags & PAT_MF_IGNORE_CASE), 0, err)) {
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001065 free(patl->pat.ptr.reg);
Dirkjan Bussink07fcaaa2014-04-28 22:57:16 +00001066 free(patl);
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001067 return 0;
1068 }
1069
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001070 /* chain pattern in the expression */
1071 LIST_ADDQ(&expr->patterns, &patl->list);
1072
1073 /* that's ok */
1074 return 1;
1075}
1076
1077int pat_idx_tree_ip(struct pattern_expr *expr, struct pattern *pat, char **err)
1078{
1079 unsigned int mask;
Thierry FOURNIERe1bcac52013-12-13 16:09:50 +01001080 struct pattern_tree *node;
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001081
1082 /* Only IPv4 can be indexed */
1083 if (pat->type == SMP_T_IPV4) {
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001084 /* in IPv4 case, check if the mask is contiguous so that we can
1085 * insert the network into the tree. A continuous mask has only
1086 * ones on the left. This means that this mask + its lower bit
1087 * added once again is null.
1088 */
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001089 mask = ntohl(pat->val.ipv4.mask.s_addr);
1090 if (mask + (mask & -mask) == 0) {
1091 mask = mask ? 33 - flsnz(mask & -mask) : 0; /* equals cidr value */
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001092
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001093 /* node memory allocation */
1094 node = calloc(1, sizeof(*node) + 4);
1095 if (!node) {
1096 memprintf(err, "out of memory while loading pattern");
1097 return 0;
1098 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001099
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001100 /* copy the pointer to sample associated to this node */
1101 node->smp = pat->smp;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001102 node->ref = pat->ref;
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001103
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001104 /* FIXME: insert <addr>/<mask> into the tree here */
1105 memcpy(node->node.key, &pat->val.ipv4.addr, 4); /* network byte order */
1106 node->node.node.pfx = mask;
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001107
1108 /* Insert the entry. */
1109 ebmb_insert_prefix(&expr->pattern_tree, &node->node, 4);
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001110
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001111 /* that's ok */
1112 return 1;
1113 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001114 else {
1115 /* If the mask is not contiguous, just add the pattern to the list */
1116 return pat_idx_list_val(expr, pat, err);
1117 }
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001118 }
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001119 else if (pat->type == SMP_T_IPV6) {
1120 /* IPv6 also can be indexed */
1121 node = calloc(1, sizeof(*node) + 16);
1122 if (!node) {
1123 memprintf(err, "out of memory while loading pattern");
1124 return 0;
1125 }
1126
1127 /* copy the pointer to sample associated to this node */
1128 node->smp = pat->smp;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001129 node->ref = pat->ref;
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001130
1131 /* FIXME: insert <addr>/<mask> into the tree here */
1132 memcpy(node->node.key, &pat->val.ipv6.addr, 16); /* network byte order */
1133 node->node.node.pfx = pat->val.ipv6.mask;
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001134
1135 /* Insert the entry. */
1136 ebmb_insert_prefix(&expr->pattern_tree_2, &node->node, 16);
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001137
1138 /* that's ok */
1139 return 1;
1140 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001141
Thierry FOURNIER33a74332013-12-19 23:54:54 +01001142 return 0;
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001143}
1144
1145int pat_idx_tree_str(struct pattern_expr *expr, struct pattern *pat, char **err)
1146{
1147 int len;
Thierry FOURNIERe1bcac52013-12-13 16:09:50 +01001148 struct pattern_tree *node;
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001149
1150 /* Only string can be indexed */
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01001151 if (pat->type != SMP_T_STR) {
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001152 memprintf(err, "internal error: string expected, but the type is '%s'",
1153 smp_to_type[pat->type]);
1154 return 0;
Thierry FOURNIER972028f2014-01-23 17:53:31 +01001155 }
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001156
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001157 /* If the flag PAT_F_IGNORE_CASE is set, we cannot use trees */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001158 if (expr->mflags & PAT_MF_IGNORE_CASE)
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001159 return pat_idx_list_str(expr, pat, err);
Thierry FOURNIER7148ce62013-12-06 19:06:43 +01001160
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001161 /* Process the key len */
1162 len = strlen(pat->ptr.str) + 1;
1163
1164 /* node memory allocation */
1165 node = calloc(1, sizeof(*node) + len);
1166 if (!node) {
1167 memprintf(err, "out of memory while loading pattern");
1168 return 0;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001169 }
1170
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001171 /* copy the pointer to sample associated to this node */
1172 node->smp = pat->smp;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001173 node->ref = pat->ref;
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001174
1175 /* copy the string */
1176 memcpy(node->node.key, pat->ptr.str, len);
1177
1178 /* index the new node */
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001179 ebst_insert(&expr->pattern_tree, &node->node);
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001180
1181 /* that's ok */
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001182 return 1;
1183}
1184
Willy Tarreaub1dd9bf2014-05-10 08:53:48 +02001185int pat_idx_tree_pfx(struct pattern_expr *expr, struct pattern *pat, char **err)
1186{
1187 int len;
1188 struct pattern_tree *node;
1189
1190 /* Only string can be indexed */
1191 if (pat->type != SMP_T_STR) {
1192 memprintf(err, "internal error: string expected, but the type is '%s'",
1193 smp_to_type[pat->type]);
1194 return 0;
1195 }
1196
1197 /* If the flag PAT_F_IGNORE_CASE is set, we cannot use trees */
1198 if (expr->mflags & PAT_MF_IGNORE_CASE)
1199 return pat_idx_list_str(expr, pat, err);
1200
1201 /* Process the key len */
1202 len = strlen(pat->ptr.str);
1203
1204 /* node memory allocation */
1205 node = calloc(1, sizeof(*node) + len + 1);
1206 if (!node) {
1207 memprintf(err, "out of memory while loading pattern");
1208 return 0;
1209 }
1210
1211 /* copy the pointer to sample associated to this node */
1212 node->smp = pat->smp;
1213 node->ref = pat->ref;
1214
1215 /* copy the string and the trailing zero */
1216 memcpy(node->node.key, pat->ptr.str, len + 1);
1217 node->node.node.pfx = len * 8;
1218
1219 /* index the new node */
1220 ebmb_insert_prefix(&expr->pattern_tree, &node->node, len);
1221
1222 /* that's ok */
1223 return 1;
1224}
1225
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001226void pat_del_list_val(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001227{
1228 struct pattern_list *pat;
1229 struct pattern_list *safe;
1230
1231 list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
1232 /* Check equality. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001233 if (pat->pat.ref != ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001234 continue;
1235
1236 /* Delete and free entry. */
1237 LIST_DEL(&pat->list);
1238 free(pat->pat.smp);
1239 free(pat);
1240 }
1241}
1242
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001243void pat_del_tree_ip(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001244{
1245 struct ebmb_node *node, *next_node;
1246 struct pattern_tree *elt;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001247
1248 /* browse each node of the tree for IPv4 addresses. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001249 for (node = ebmb_first(&expr->pattern_tree), next_node = node ? ebmb_next(node) : NULL;
1250 node;
1251 node = next_node, next_node = node ? ebmb_next(node) : NULL) {
1252 /* Extract container of the tree node. */
1253 elt = container_of(node, struct pattern_tree, node);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001254
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001255 /* Check equality. */
1256 if (elt->ref != ref)
1257 continue;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001258
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001259 /* Delete and free entry. */
1260 ebmb_delete(node);
1261 free(elt->smp);
1262 free(elt);
1263 }
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001264
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001265 /* Browse each node of the list for IPv4 addresses. */
1266 pat_del_list_val(expr, ref);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001267
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001268 /* browse each node of the tree for IPv6 addresses. */
1269 for (node = ebmb_first(&expr->pattern_tree_2), next_node = node ? ebmb_next(node) : NULL;
1270 node;
1271 node = next_node, next_node = node ? ebmb_next(node) : NULL) {
1272 /* Extract container of the tree node. */
1273 elt = container_of(node, struct pattern_tree, node);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001274
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001275 /* Check equality. */
1276 if (elt->ref != ref)
1277 continue;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001278
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001279 /* Delete and free entry. */
1280 ebmb_delete(node);
1281 free(elt->smp);
1282 free(elt);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001283 }
1284}
1285
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001286void pat_del_list_ptr(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001287{
1288 struct pattern_list *pat;
1289 struct pattern_list *safe;
1290
1291 list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
1292 /* Check equality. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001293 if (pat->pat.ref != ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001294 continue;
1295
1296 /* Delete and free entry. */
1297 LIST_DEL(&pat->list);
1298 free(pat->pat.ptr.ptr);
1299 free(pat->pat.smp);
1300 free(pat);
1301 }
1302}
1303
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001304void pat_del_tree_str(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001305{
1306 struct ebmb_node *node, *next_node;
1307 struct pattern_tree *elt;
1308
1309 /* browse each node of the tree. */
1310 for (node = ebmb_first(&expr->pattern_tree), next_node = node ? ebmb_next(node) : NULL;
1311 node;
1312 node = next_node, next_node = node ? ebmb_next(node) : NULL) {
1313 /* Extract container of the tree node. */
1314 elt = container_of(node, struct pattern_tree, node);
1315
1316 /* Check equality. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001317 if (elt->ref != ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001318 continue;
1319
1320 /* Delete and free entry. */
1321 ebmb_delete(node);
1322 free(elt->smp);
1323 free(elt);
1324 }
1325}
1326
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001327void pat_del_list_reg(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001328{
1329 struct pattern_list *pat;
1330 struct pattern_list *safe;
1331
1332 list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
1333 /* Check equality. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001334 if (pat->pat.ref != ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001335 continue;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001336
1337 /* Delete and free entry. */
1338 LIST_DEL(&pat->list);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001339 regex_free(pat->pat.ptr.ptr);
1340 free(pat->pat.smp);
1341 free(pat);
1342 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001343}
1344
1345void pattern_init_expr(struct pattern_expr *expr)
1346{
1347 LIST_INIT(&expr->patterns);
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001348 expr->pattern_tree = EB_ROOT;
1349 expr->pattern_tree_2 = EB_ROOT;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001350}
1351
1352void pattern_init_head(struct pattern_head *head)
1353{
1354 LIST_INIT(&head->head);
1355}
1356
1357/* The following functions are relative to the management of the reference
1358 * lists. These lists are used to store the original pattern and associated
1359 * value as string form.
1360 *
1361 * This is used with modifiable ACL and MAPS
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001362 *
1363 * The pattern reference are stored with two identifiers: the unique_id and
1364 * the reference.
1365 *
1366 * The reference identify a file. Each file with the same name point to the
1367 * same reference. We can register many times one file. If the file is modified,
1368 * all his dependencies are also modified. The reference can be used with map or
1369 * acl.
1370 *
1371 * The unique_id identify inline acl. The unique id is unique for each acl.
1372 * You cannot force the same id in the configuration file, because this repoort
1373 * an error.
1374 *
1375 * A particular case appears if the filename is a number. In this case, the
1376 * unique_id is set with the number represented by the filename and the
1377 * reference is also set. This method prevent double unique_id.
1378 *
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001379 */
1380
1381/* This function lookup for reference. If the reference is found, they return
1382 * pointer to the struct pat_ref, else return NULL.
1383 */
1384struct pat_ref *pat_ref_lookup(const char *reference)
1385{
1386 struct pat_ref *ref;
1387
1388 list_for_each_entry(ref, &pattern_reference, list)
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001389 if (ref->reference && strcmp(reference, ref->reference) == 0)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001390 return ref;
1391 return NULL;
1392}
1393
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001394/* This function lookup for unique id. If the reference is found, they return
1395 * pointer to the struct pat_ref, else return NULL.
1396 */
1397struct pat_ref *pat_ref_lookupid(int unique_id)
1398{
1399 struct pat_ref *ref;
1400
1401 list_for_each_entry(ref, &pattern_reference, list)
1402 if (ref->unique_id == unique_id)
1403 return ref;
1404 return NULL;
1405}
1406
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001407/* This function remove all pattern matching the pointer <refelt> from
1408 * the the reference and from each expr member of the reference. This
1409 * function returns 1 if the deletion is done and return 0 is the entry
1410 * is not found.
1411 */
1412int pat_ref_delete_by_id(struct pat_ref *ref, struct pat_ref_elt *refelt)
1413{
1414 struct pattern_expr *expr;
1415 struct pat_ref_elt *elt, *safe;
1416
1417 /* delete pattern from reference */
1418 list_for_each_entry_safe(elt, safe, &ref->head, list) {
1419 if (elt == refelt) {
1420 LIST_DEL(&elt->list);
1421 free(elt->sample);
1422 free(elt->pattern);
1423 free(elt);
1424
1425 list_for_each_entry(expr, &ref->pat, list)
1426 pattern_delete(expr, elt);
1427
1428 return 1;
1429 }
1430 }
1431 return 0;
1432}
1433
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001434/* This function remove all pattern match <key> from the the reference
1435 * and from each expr member of the reference. This fucntion returns 1
1436 * if the deletion is done and return 0 is the entry is not found.
1437 */
1438int pat_ref_delete(struct pat_ref *ref, const char *key)
1439{
1440 struct pattern_expr *expr;
1441 struct pat_ref_elt *elt, *safe;
1442 int found = 0;
1443
1444 /* delete pattern from reference */
1445 list_for_each_entry_safe(elt, safe, &ref->head, list) {
1446 if (strcmp(key, elt->pattern) == 0) {
Dirkjan Bussink07fcaaa2014-04-28 22:57:16 +00001447 list_for_each_entry(expr, &ref->pat, list)
1448 pattern_delete(expr, elt);
1449
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001450 LIST_DEL(&elt->list);
1451 free(elt->sample);
1452 free(elt->pattern);
1453 free(elt);
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001454
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001455 found = 1;
1456 }
1457 }
1458
1459 if (!found)
1460 return 0;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001461 return 1;
1462}
1463
Baptiste Assmann953f74d2014-04-25 16:57:03 +02001464/*
1465 * find and return an element <elt> matching <key> in a reference <ref>
1466 * return NULL if not found
1467 */
1468struct pat_ref_elt *pat_ref_find_elt(struct pat_ref *ref, const char *key)
1469{
1470 struct pat_ref_elt *elt;
1471
1472 list_for_each_entry(elt, &ref->head, list) {
1473 if (strcmp(key, elt->pattern) == 0)
1474 return elt;
1475 }
1476
1477 return NULL;
1478}
1479
1480
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001481 /* This function modify the sample of the first pattern that match the <key>. */
1482static inline int pat_ref_set_elt(struct pat_ref *ref, struct pat_ref_elt *elt,
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001483 const char *value, char **err)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001484{
1485 struct pattern_expr *expr;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001486 struct sample_storage **smp;
1487 char *sample;
Thierry FOURNIER149e0fe2014-01-29 19:35:06 +01001488 struct sample_storage test;
1489
1490 /* Try all needed converters. */
1491 list_for_each_entry(expr, &ref->pat, list) {
1492 if (!expr->pat_head->parse_smp)
1493 continue;
1494
1495 if (!expr->pat_head->parse_smp(value, &test)) {
1496 memprintf(err, "unable to parse '%s'", value);
1497 return 0;
1498 }
1499 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001500
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001501 /* Modify pattern from reference. */
1502 sample = strdup(value);
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001503 if (!sample) {
1504 memprintf(err, "out of memory error");
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001505 return 0;
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001506 }
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001507 free(elt->sample);
1508 elt->sample = sample;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001509
Thierry FOURNIER149e0fe2014-01-29 19:35:06 +01001510 /* Load sample in each reference. All the conversion are tested
1511 * below, normally these calls dosn't fail.
1512 */
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01001513 list_for_each_entry(expr, &ref->pat, list) {
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001514 if (!expr->pat_head->parse_smp)
1515 continue;
1516
1517 smp = pattern_find_smp(expr, elt);
Thierry FOURNIER149e0fe2014-01-29 19:35:06 +01001518 if (smp && *smp && !expr->pat_head->parse_smp(sample, *smp))
1519 *smp = NULL;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001520 }
1521
Thierry FOURNIER149e0fe2014-01-29 19:35:06 +01001522 return 1;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001523}
1524
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001525/* This function modify the sample of the first pattern that match the <key>. */
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001526int 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 +01001527{
1528 struct pat_ref_elt *elt;
1529
1530 /* Look for pattern in the reference. */
1531 list_for_each_entry(elt, &ref->head, list) {
1532 if (elt == refelt) {
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001533 if (!pat_ref_set_elt(ref, elt, value, err))
1534 return 0;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001535 return 1;
1536 }
1537 }
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001538
1539 memprintf(err, "key or pattern not found");
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001540 return 0;
1541}
1542
1543/* This function modify the sample of the first pattern that match the <key>. */
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001544int pat_ref_set(struct pat_ref *ref, const char *key, const char *value, char **err)
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001545{
1546 struct pat_ref_elt *elt;
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001547 int found = 0;
1548 char *_merr;
1549 char **merr;
1550
1551 if (err) {
1552 merr = &_merr;
1553 *merr = NULL;
1554 }
1555 else
1556 merr = NULL;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001557
1558 /* Look for pattern in the reference. */
1559 list_for_each_entry(elt, &ref->head, list) {
1560 if (strcmp(key, elt->pattern) == 0) {
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001561 if (!pat_ref_set_elt(ref, elt, value, merr)) {
1562 if (!found)
1563 *err = *merr;
1564 else {
1565 memprintf(err, "%s, %s", *err, *merr);
1566 free(*merr);
1567 *merr = NULL;
1568 }
1569 }
1570 found = 1;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001571 }
1572 }
Thierry FOURNIER364cfdf2014-01-29 19:08:49 +01001573
1574 if (!found) {
1575 memprintf(err, "entry not found");
1576 return 0;
1577 }
1578 return 1;
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01001579}
1580
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001581/* This function create new reference. <ref> is the reference name.
1582 * <flags> are PAT_REF_*. /!\ The reference is not checked, and must
1583 * be unique. The user must check the reference with "pat_ref_lookup()"
1584 * before calling this function. If the fucntion fail, it return NULL,
1585 * else return new struct pat_ref.
1586 */
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001587struct pat_ref *pat_ref_new(const char *reference, const char *display, unsigned int flags)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001588{
1589 struct pat_ref *ref;
1590
1591 ref = malloc(sizeof(*ref));
1592 if (!ref)
1593 return NULL;
1594
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001595 if (display) {
1596 ref->display = strdup(display);
1597 if (!ref->display) {
1598 free(ref);
1599 return NULL;
1600 }
1601 }
1602 else
1603 ref->display = NULL;
1604
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001605 ref->reference = strdup(reference);
1606 if (!ref->reference) {
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001607 free(ref->display);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001608 free(ref);
1609 return NULL;
1610 }
1611
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001612 ref->flags = flags;
1613 ref->unique_id = -1;
1614
1615 LIST_INIT(&ref->head);
1616 LIST_INIT(&ref->pat);
1617
1618 LIST_ADDQ(&pattern_reference, &ref->list);
1619
1620 return ref;
1621}
1622
1623/* This function create new reference. <unique_id> is the unique id. If
1624 * the value of <unique_id> is -1, the unique id is calculated later.
1625 * <flags> are PAT_REF_*. /!\ The reference is not checked, and must
1626 * be unique. The user must check the reference with "pat_ref_lookup()"
1627 * or pat_ref_lookupid before calling this function. If the function
1628 * fail, it return NULL, else return new struct pat_ref.
1629 */
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001630struct pat_ref *pat_ref_newid(int unique_id, const char *display, unsigned int flags)
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001631{
1632 struct pat_ref *ref;
1633
1634 ref = malloc(sizeof(*ref));
1635 if (!ref)
1636 return NULL;
1637
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +01001638 if (display) {
1639 ref->display = strdup(display);
1640 if (!ref->display) {
1641 free(ref);
1642 return NULL;
1643 }
1644 }
1645 else
1646 ref->display = NULL;
1647
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001648 ref->reference = NULL;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001649 ref->flags = flags;
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01001650 ref->unique_id = unique_id;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001651 LIST_INIT(&ref->head);
1652 LIST_INIT(&ref->pat);
1653
1654 LIST_ADDQ(&pattern_reference, &ref->list);
1655
1656 return ref;
1657}
1658
1659/* This function adds entry to <ref>. It can failed with memory error.
1660 * If the function fails, it returns 0.
1661 */
1662int pat_ref_append(struct pat_ref *ref, char *pattern, char *sample, int line)
1663{
1664 struct pat_ref_elt *elt;
1665
1666 elt = malloc(sizeof(*elt));
1667 if (!elt)
1668 return 0;
1669
1670 elt->line = line;
1671
1672 elt->pattern = strdup(pattern);
1673 if (!elt->pattern) {
1674 free(elt);
1675 return 0;
1676 }
1677
1678 if (sample) {
1679 elt->sample = strdup(sample);
1680 if (!elt->sample) {
1681 free(elt->pattern);
1682 free(elt);
1683 return 0;
1684 }
1685 }
1686 else
1687 elt->sample = NULL;
1688
1689 LIST_ADDQ(&ref->head, &elt->list);
1690
1691 return 1;
Thierry FOURNIERb1136502014-01-15 11:38:49 +01001692}
1693
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001694/* This function create sample found in <elt>, parse the pattern also
1695 * found in <elt> and insert it in <expr>. The function copy <patflags>
1696 * in <expr>. If the function fails, it returns0 and <err> is filled.
1697 * In succes case, the function returns 1.
1698 */
1699static inline
1700int pat_ref_push(struct pat_ref_elt *elt, struct pattern_expr *expr,
1701 int patflags, char **err)
1702{
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001703 struct sample_storage *smp;
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001704 struct pattern pattern;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001705
1706 /* Create sample */
1707 if (elt->sample && expr->pat_head->parse_smp) {
1708 /* New sample. */
1709 smp = malloc(sizeof(*smp));
1710 if (!smp)
1711 return 0;
1712
1713 /* Parse value. */
1714 if (!expr->pat_head->parse_smp(elt->sample, smp)) {
1715 memprintf(err, "unable to parse '%s'", elt->sample);
1716 free(smp);
1717 return 0;
1718 }
1719
1720 }
1721 else
1722 smp = NULL;
1723
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001724 /* initialise pattern */
1725 memset(&pattern, 0, sizeof(pattern));
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001726 pattern.smp = smp;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01001727 pattern.ref = elt;
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001728
1729 /* parse pattern */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001730 if (!expr->pat_head->parse(elt->pattern, &pattern, expr->mflags, err)) {
Thierry FOURNIERd25c8422014-01-28 15:34:35 +01001731 free(smp);
1732 return 0;
1733 }
1734
1735 /* index pattern */
1736 if (!expr->pat_head->index(expr, &pattern, err)) {
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001737 free(smp);
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001738 return 0;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001739 }
Thierry FOURNIERb9b08462013-12-13 15:12:32 +01001740
1741 return 1;
1742}
1743
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001744/* This function adds entry to <ref>. It can failed with memory error. The new
1745 * entry is added at all the pattern_expr registered in this reference. The
1746 * function stop on the first error encountered. It returns 0 and err is
1747 * filled. If an error is encountered, the complete add operation is cancelled.
1748 * If the insertion is a success the function returns 1.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001749 */
1750int pat_ref_add(struct pat_ref *ref,
1751 const char *pattern, const char *sample,
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001752 char **err)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001753{
1754 struct pat_ref_elt *elt;
1755 struct pattern_expr *expr;
1756
1757 elt = malloc(sizeof(*elt));
1758 if (!elt) {
1759 memprintf(err, "out of memory error");
1760 return 0;
1761 }
1762
1763 elt->line = -1;
1764
1765 elt->pattern = strdup(pattern);
1766 if (!elt->pattern) {
1767 free(elt);
1768 memprintf(err, "out of memory error");
1769 return 0;
1770 }
1771
1772 if (sample) {
1773 elt->sample = strdup(sample);
1774 if (!elt->sample) {
1775 free(elt->pattern);
1776 free(elt);
1777 memprintf(err, "out of memory error");
1778 return 0;
1779 }
1780 }
1781 else
1782 elt->sample = NULL;
1783
1784 LIST_ADDQ(&ref->head, &elt->list);
1785
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01001786 list_for_each_entry(expr, &ref->pat, list) {
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02001787 if (!pat_ref_push(elt, expr, 0, err)) {
Thierry FOURNIER31db4ae2014-01-30 00:27:15 +01001788 /* If the insertion fails, try to delete all the added entries. */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01001789 pat_ref_delete_by_id(ref, elt);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001790 return 0;
1791 }
1792 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001793 return 1;
1794}
1795
Thierry FOURNIER46006bd2014-03-21 21:45:15 +01001796/* This function prune <ref>, replace all reference by the references
1797 * of <replace>, and reindex all the news values.
1798 *
1799 * The pattern are loaded in best effort and the errors are ignored,
1800 * but writed in the logs.
1801 */
1802void pat_ref_reload(struct pat_ref *ref, struct pat_ref *replace)
1803{
1804 struct pattern_expr *expr;
1805 struct pat_ref_elt *elt;
1806 char *err = NULL;
1807
1808 pat_ref_prune(ref);
1809
1810 LIST_ADD(&replace->head, &ref->head);
1811 LIST_DEL(&replace->head);
1812
1813 list_for_each_entry(elt, &ref->head, list) {
1814 list_for_each_entry(expr, &ref->pat, list) {
1815 if (!pat_ref_push(elt, expr, 0, &err)) {
1816 send_log(NULL, LOG_NOTICE, "%s", err);
1817 free(err);
1818 err = NULL;
1819 }
1820 }
1821 }
1822}
1823
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001824/* This function prune all entries of <ref>. This function
1825 * prune the associated pattern_expr.
1826 */
1827void pat_ref_prune(struct pat_ref *ref)
1828{
1829 struct pat_ref_elt *elt, *safe;
1830 struct pattern_expr *expr;
1831
1832 list_for_each_entry_safe(elt, safe, &ref->head, list) {
1833 LIST_DEL(&elt->list);
1834 free(elt->pattern);
1835 free(elt->sample);
1836 free(elt);
1837 }
1838
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01001839 list_for_each_entry(expr, &ref->pat, list)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001840 expr->pat_head->prune(expr);
1841}
1842
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001843/* This function lookup for existing reference <ref> in pattern_head <head>. */
1844struct pattern_expr *pattern_lookup_expr(struct pattern_head *head, struct pat_ref *ref)
1845{
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01001846 struct pattern_expr_list *expr;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001847
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01001848 list_for_each_entry(expr, &head->head, list)
1849 if (expr->expr->ref == ref)
1850 return expr->expr;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001851 return NULL;
1852}
1853
1854/* This function create new pattern_expr associated to the reference <ref>.
1855 * <ref> can be NULL. If an error is occured, the function returns NULL and
1856 * <err> is filled. Otherwise, the function returns new pattern_expr linked
1857 * with <head> and <ref>.
1858 */
1859struct pattern_expr *pattern_new_expr(struct pattern_head *head, struct pat_ref *ref, char **err)
1860{
1861 struct pattern_expr *expr;
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01001862 struct pattern_expr_list *list;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001863
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01001864 /* Memory and initialization of the chain element. */
1865 list = malloc(sizeof(*list));
1866 if (!list) {
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001867 memprintf(err, "out of memory");
1868 return NULL;
1869 }
1870
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01001871 /* Look for existing similar expr. No that only the index, parse and
1872 * parse_smp function must be identical for having similar pattern.
1873 * The other function depends of theses first.
1874 */
1875 if (ref) {
1876 list_for_each_entry(expr, &ref->pat, list)
1877 if (expr->pat_head->index == head->index &&
1878 expr->pat_head->parse == head->parse &&
1879 expr->pat_head->parse_smp == head->parse_smp)
1880 break;
1881 if (&expr->list == &ref->pat)
1882 expr = NULL;
1883 }
1884 else
1885 expr = NULL;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001886
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01001887 /* If no similar expr was found, we create new expr. */
1888 if (!expr) {
1889 /* Get a lot of memory for the expr struct. */
1890 expr = malloc(sizeof(*expr));
1891 if (!expr) {
1892 memprintf(err, "out of memory");
1893 return NULL;
1894 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001895
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01001896 /* Initialize this new expr. */
1897 pattern_init_expr(expr);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001898
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01001899 /* This new pattern expression reference one of his heads. */
1900 expr->pat_head = head;
1901
1902 /* Link with ref, or to self to facilitate LIST_DEL() */
1903 if (ref)
1904 LIST_ADDQ(&ref->pat, &expr->list);
1905 else
1906 LIST_INIT(&expr->list);
1907
1908 expr->ref = ref;
1909
1910 /* We must free this pattern if it is no more used. */
1911 list->do_free = 1;
1912 }
1913 else {
1914 /* If the pattern used already exists, it is already linked
1915 * with ref and we must not free it.
1916 */
1917 list->do_free = 0;
1918 }
1919
1920 /* The new list element reference the pattern_expr. */
1921 list->expr = expr;
1922
1923 /* Link the list element with the pattern_head. */
1924 LIST_ADDQ(&head->head, &list->list);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01001925 return expr;
1926}
1927
Thierry FOURNIERed66c292013-11-28 11:05:19 +01001928/* Reads patterns from a file. If <err_msg> is non-NULL, an error message will
1929 * be returned there on errors and the caller will have to free it.
Thierry FOURNIER39bef452014-01-29 13:29:45 +01001930 *
1931 * The file contains one key + value per line. Lines which start with '#' are
1932 * ignored, just like empty lines. Leading tabs/spaces are stripped. The key is
1933 * then the first "word" (series of non-space/tabs characters), and the value is
1934 * what follows this series of space/tab till the end of the line excluding
1935 * trailing spaces/tabs.
1936 *
1937 * Example :
1938 *
1939 * # this is a comment and is ignored
1940 * 62.212.114.60 1wt.eu \n
1941 * <-><-----------><---><----><---->
1942 * | | | | `--- trailing spaces ignored
1943 * | | | `-------- value
1944 * | | `--------------- middle spaces ignored
1945 * | `------------------------ key
1946 * `-------------------------------- leading spaces ignored
1947 *
1948 * Return non-zero in case of succes, otherwise 0.
1949 */
1950int pat_ref_read_from_file_smp(struct pat_ref *ref, const char *filename, char **err)
1951{
1952 FILE *file;
1953 char *c;
1954 int ret = 0;
1955 int line = 0;
1956 char *key_beg;
1957 char *key_end;
1958 char *value_beg;
1959 char *value_end;
1960
1961 file = fopen(filename, "r");
1962 if (!file) {
1963 memprintf(err, "failed to open pattern file <%s>", filename);
1964 return 0;
1965 }
1966
1967 /* now parse all patterns. The file may contain only one pattern
1968 * followed by one value per line. The start spaces, separator spaces
1969 * and and spaces are stripped. Each can contain comment started by '#'
1970 */
1971 while (fgets(trash.str, trash.size, file) != NULL) {
1972 line++;
1973 c = trash.str;
1974
1975 /* ignore lines beginning with a dash */
1976 if (*c == '#')
1977 continue;
1978
1979 /* strip leading spaces and tabs */
1980 while (*c == ' ' || *c == '\t')
1981 c++;
1982
1983 /* empty lines are ignored too */
1984 if (*c == '\0' || *c == '\r' || *c == '\n')
1985 continue;
1986
1987 /* look for the end of the key */
1988 key_beg = c;
1989 while (*c && *c != ' ' && *c != '\t' && *c != '\n' && *c != '\r')
1990 c++;
1991
1992 key_end = c;
1993
1994 /* strip middle spaces and tabs */
1995 while (*c == ' ' || *c == '\t')
1996 c++;
1997
1998 /* look for the end of the value, it is the end of the line */
1999 value_beg = c;
2000 while (*c && *c != '\n' && *c != '\r')
2001 c++;
2002 value_end = c;
2003
2004 /* trim possibly trailing spaces and tabs */
2005 while (value_end > value_beg && (value_end[-1] == ' ' || value_end[-1] == '\t'))
2006 value_end--;
2007
2008 /* set final \0 and check entries */
2009 *key_end = '\0';
2010 *value_end = '\0';
2011
2012 /* insert values */
2013 if (!pat_ref_append(ref, key_beg, value_beg, line)) {
2014 memprintf(err, "out of memory");
2015 goto out_close;
2016 }
2017 }
2018
2019 /* succes */
2020 ret = 1;
2021
2022 out_close:
2023 fclose(file);
2024 return ret;
2025}
2026
2027/* Reads patterns from a file. If <err_msg> is non-NULL, an error message will
2028 * be returned there on errors and the caller will have to free it.
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002029 */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002030int pat_ref_read_from_file(struct pat_ref *ref, const char *filename, char **err)
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002031{
2032 FILE *file;
2033 char *c;
2034 char *arg;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002035 int ret = 0;
2036 int line = 0;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002037
2038 file = fopen(filename, "r");
2039 if (!file) {
2040 memprintf(err, "failed to open pattern file <%s>", filename);
2041 return 0;
2042 }
2043
2044 /* now parse all patterns. The file may contain only one pattern per
2045 * line. If the line contains spaces, they will be part of the pattern.
2046 * The pattern stops at the first CR, LF or EOF encountered.
2047 */
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002048 while (fgets(trash.str, trash.size, file) != NULL) {
2049 line++;
2050 c = trash.str;
2051
2052 /* ignore lines beginning with a dash */
2053 if (*c == '#')
2054 continue;
2055
2056 /* strip leading spaces and tabs */
2057 while (*c == ' ' || *c == '\t')
2058 c++;
2059
2060
2061 arg = c;
2062 while (*c && *c != '\n' && *c != '\r')
2063 c++;
2064 *c = 0;
2065
2066 /* empty lines are ignored too */
2067 if (c == arg)
2068 continue;
2069
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002070 if (!pat_ref_append(ref, arg, NULL, line)) {
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002071 memprintf(err, "out of memory when loading patterns from file <%s>", filename);
2072 goto out_close;
2073 }
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002074 }
2075
2076 ret = 1; /* success */
2077
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002078 out_close:
2079 fclose(file);
2080 return ret;
2081}
2082
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002083int pattern_read_from_file(struct pattern_head *head, unsigned int refflags,
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002084 const char *filename, int patflags, int load_smp,
Thierry FOURNIER94580c92014-02-11 14:36:45 +01002085 char **err, const char *file, int line)
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002086{
2087 struct pat_ref *ref;
2088 struct pattern_expr *expr;
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002089 struct pat_ref_elt *elt;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002090
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002091 /* Lookup for the existing reference. */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002092 ref = pat_ref_lookup(filename);
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002093
2094 /* If the reference doesn't exists, create it and load associated file. */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002095 if (!ref) {
Thierry FOURNIER94580c92014-02-11 14:36:45 +01002096 chunk_printf(&trash,
2097 "pattern loaded from file '%s' used by %s at file '%s' line %d",
2098 filename, refflags & PAT_REF_MAP ? "map" : "acl", file, line);
2099
2100 ref = pat_ref_new(filename, trash.str, refflags);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002101 if (!ref) {
2102 memprintf(err, "out of memory");
2103 return 0;
2104 }
2105
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002106 if (load_smp) {
Thierry FOURNIERc0bd9102014-01-29 12:32:58 +01002107 ref->flags |= PAT_REF_SMP;
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002108 if (!pat_ref_read_from_file_smp(ref, filename, err))
2109 return 0;
2110 }
2111 else {
2112 if (!pat_ref_read_from_file(ref, filename, err))
2113 return 0;
2114 }
2115 }
2116 else {
Thierry FOURNIERc0bd9102014-01-29 12:32:58 +01002117 /* The reference already exists, check the map compatibility. */
2118
2119 /* If the load require samples and the flag PAT_REF_SMP is not set,
2120 * the reference doesn't contain sample, and cannot be used.
2121 */
2122 if (load_smp) {
2123 if (!(ref->flags & PAT_REF_SMP)) {
2124 memprintf(err, "The file \"%s\" is already used as one column file "
2125 "and cannot be used by as two column file.",
2126 filename);
2127 return 0;
2128 }
2129 }
2130 else {
2131 /* The load doesn't require samples. If the flag PAT_REF_SMP is
2132 * set, the reference contains a sample, and cannot be used.
2133 */
2134 if (ref->flags & PAT_REF_SMP) {
2135 memprintf(err, "The file \"%s\" is already used as two column file "
2136 "and cannot be used by as one column file.",
2137 filename);
2138 return 0;
2139 }
2140 }
2141
Thierry FOURNIER94580c92014-02-11 14:36:45 +01002142 /* Extends display */
2143 chunk_printf(&trash, "%s", ref->display);
2144 chunk_appendf(&trash, ", by %s at file '%s' line %d",
2145 refflags & PAT_REF_MAP ? "map" : "acl", file, line);
2146 free(ref->display);
2147 ref->display = strdup(trash.str);
2148 if (!ref->display) {
2149 memprintf(err, "out of memory");
2150 return 0;
2151 }
2152
Thierry FOURNIERc0bd9102014-01-29 12:32:58 +01002153 /* Merge flags. */
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002154 ref->flags |= refflags;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002155 }
2156
2157 /* Now, we can loading patterns from the reference. */
2158
2159 /* Lookup for existing reference in the head. If the reference
2160 * doesn't exists, create it.
2161 */
2162 expr = pattern_lookup_expr(head, ref);
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02002163 if (!expr || (expr->mflags != patflags)) {
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002164 expr = pattern_new_expr(head, ref, err);
2165 if (!expr)
2166 return 0;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02002167 expr->mflags = patflags;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002168 }
2169
Thierry FOURNIER39bef452014-01-29 13:29:45 +01002170 /* Load reference content in the pattern expression. */
2171 list_for_each_entry(elt, &ref->head, list) {
2172 if (!pat_ref_push(elt, expr, patflags, err)) {
2173 if (elt->line > 0)
2174 memprintf(err, "%s at line %d of file '%s'",
2175 *err, elt->line, filename);
2176 return 0;
2177 }
2178 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002179
2180 return 1;
2181}
2182
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +01002183/* This function executes a pattern match on a sample. It applies pattern <expr>
2184 * to sample <smp>. The function returns NULL if the sample dont match. It returns
2185 * non-null if the sample match. If <fill> is true and the sample match, the
2186 * function returns the matched pattern. In many cases, this pattern can be a
2187 * static buffer.
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002188 */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002189struct pattern *pattern_exec_match(struct pattern_head *head, struct sample *smp, int fill)
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002190{
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002191 struct pattern_expr_list *list;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002192 struct pattern *pat;
2193
2194 if (!head->match) {
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +01002195 if (fill) {
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01002196 static_pattern.smp = NULL;
Thierry FOURNIER6bb53ff2014-01-28 15:54:36 +01002197 static_pattern.ref = NULL;
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +02002198 static_pattern.sflags = 0;
Thierry FOURNIER5338eea2013-12-16 14:22:13 +01002199 static_pattern.type = SMP_T_UINT;
2200 static_pattern.val.i = 1;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +01002201 }
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +01002202 return &static_pattern;
2203 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002204
Thierry FOURNIER5d344082014-01-27 14:19:53 +01002205 /* convert input to string */
2206 if (!sample_convert(smp, head->expect_type))
2207 return NULL;
2208
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002209 list_for_each_entry(list, &head->head, list) {
2210 pat = head->match(smp, list->expr, fill);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002211 if (pat)
2212 return pat;
2213 }
2214 return NULL;
Thierry FOURNIERed66c292013-11-28 11:05:19 +01002215}
2216
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01002217/* This function prune the pattern expression. */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002218void pattern_prune(struct pattern_head *head)
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01002219{
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002220 struct pattern_expr_list *list, *safe;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002221
Thierry FOURNIERc5959fd2014-01-20 14:29:33 +01002222 list_for_each_entry_safe(list, safe, &head->head, list) {
2223 LIST_DEL(&list->list);
2224 if (list->do_free) {
2225 LIST_DEL(&list->expr->list);
2226 head->prune(list->expr);
2227 free(list->expr);
2228 }
2229 free(list);
Thierry FOURNIER1e00d382014-02-11 11:31:40 +01002230 }
Thierry FOURNIER6f7203d2014-01-14 16:24:51 +01002231}
2232
Thierry FOURNIER55d0b102014-01-15 11:25:26 +01002233/* This function lookup for a pattern matching the <key> and return a
2234 * pointer to a pointer of the sample stoarge. If the <key> dont match,
2235 * the function returns NULL. If the key cannot be parsed, the function
2236 * fill <err>.
2237 */
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002238struct sample_storage **pattern_find_smp(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIER55d0b102014-01-15 11:25:26 +01002239{
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002240 struct ebmb_node *node;
2241 struct pattern_tree *elt;
2242 struct pattern_list *pat;
Thierry FOURNIER55d0b102014-01-15 11:25:26 +01002243
Thierry FOURNIERe369ca22014-01-29 16:24:55 +01002244 for (node = ebmb_first(&expr->pattern_tree);
2245 node;
2246 node = ebmb_next(node)) {
2247 elt = container_of(node, struct pattern_tree, node);
2248 if (elt->ref == ref)
2249 return &elt->smp;
2250 }
2251
2252 for (node = ebmb_first(&expr->pattern_tree_2);
2253 node;
2254 node = ebmb_next(node)) {
2255 elt = container_of(node, struct pattern_tree, node);
2256 if (elt->ref == ref)
2257 return &elt->smp;
2258 }
2259
2260 list_for_each_entry(pat, &expr->patterns, list)
2261 if (pat->pat.ref == ref)
2262 return &pat->pat.smp;
2263
2264 return NULL;
Thierry FOURNIER55d0b102014-01-15 11:25:26 +01002265}
2266
Thierry FOURNIERb1136502014-01-15 11:38:49 +01002267/* This function search all the pattern matching the <key> and delete it.
2268 * If the parsing of the input key fails, the function returns 0 and the
2269 * <err> is filled, else return 1;
2270 */
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01002271int pattern_delete(struct pattern_expr *expr, struct pat_ref_elt *ref)
Thierry FOURNIERb1136502014-01-15 11:38:49 +01002272{
Thierry FOURNIER7acca4b2014-01-28 16:43:36 +01002273 expr->pat_head->delete(expr, ref);
Thierry FOURNIERb1136502014-01-15 11:38:49 +01002274 return 1;
2275}
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002276
2277/* This function finalize the configuration parsing. Its set all the
2278 * automatic ids
2279 */
2280void pattern_finalize_config(void)
2281{
2282 int i = 0;
2283 struct pat_ref *ref, *ref2, *ref3;
2284 struct list pr = LIST_HEAD_INIT(pr);
2285
2286 list_for_each_entry(ref, &pattern_reference, list) {
2287 if (ref->unique_id == -1) {
2288 /* Look for the first free id. */
2289 while (1) {
2290 list_for_each_entry(ref2, &pattern_reference, list) {
2291 if (ref2->unique_id == i) {
2292 i++;
2293 break;
2294 }
2295 }
Willy Tarreau3b786962014-04-26 12:37:25 +02002296 if (&ref2->list == &pattern_reference)
Thierry FOURNIERaf5a29d2014-03-11 14:29:22 +01002297 break;
2298 }
2299
2300 /* Uses the unique id and increment it for the next entry. */
2301 ref->unique_id = i;
2302 i++;
2303 }
2304 }
2305
2306 /* This sort the reference list by id. */
2307 list_for_each_entry_safe(ref, ref2, &pattern_reference, list) {
2308 LIST_DEL(&ref->list);
2309 list_for_each_entry(ref3, &pr, list) {
2310 if (ref->unique_id < ref3->unique_id) {
2311 LIST_ADDQ(&ref3->list, &ref->list);
2312 break;
2313 }
2314 }
2315 if (&ref3->list == &pr)
2316 LIST_ADDQ(&pr, &ref->list);
2317 }
2318
2319 /* swap root */
2320 LIST_ADD(&pr, &pattern_reference);
2321 LIST_DEL(&pr);
2322}