blob: 141cdf4370a0a8e3229a207db4234876f48c689c [file] [log] [blame]
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +01001/*
2 * MAP 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 <limits.h>
14#include <stdio.h>
15
16#include <common/standard.h>
17
18#include <types/global.h>
19#include <types/map.h>
Thierry FOURNIER1e00d382014-02-11 11:31:40 +010020#include <types/pattern.h>
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010021
22#include <proto/arg.h>
Thierry FOURNIERb0c0a0f2013-12-10 15:05:34 +010023#include <proto/map.h>
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010024#include <proto/pattern.h>
25#include <proto/sample.h>
26
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010027/* Parse an IPv4 address and store it into the sample.
28 * The output type is IPV4.
29 */
Thierry FOURNIERb0c0a0f2013-12-10 15:05:34 +010030int map_parse_ip(const char *text, struct sample_storage *smp)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010031{
32 if (!buf2ip(text, strlen(text), &smp->data.ipv4))
33 return 0;
34 smp->type = SMP_T_IPV4;
35 return 1;
36}
37
38/* Parse an IPv6 address and store it into the sample.
39 * The output type is IPV6.
40 */
Thierry FOURNIERb0c0a0f2013-12-10 15:05:34 +010041int map_parse_ip6(const char *text, struct sample_storage *smp)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010042{
43 if (!buf2ip6(text, strlen(text), &smp->data.ipv6))
44 return 0;
45 smp->type = SMP_T_IPV6;
46 return 1;
47}
48
49/* Parse a string and store a pointer to it into the sample. The original
50 * string must be left in memory because we return a direct memory reference.
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +010051 * The output type is SMP_T_STR. There is no risk that the data will be
52 * overwritten because sample_conv_map() makes a const sample with this
53 * output.
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010054 */
Thierry FOURNIERb0c0a0f2013-12-10 15:05:34 +010055int map_parse_str(const char *text, struct sample_storage *smp)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010056{
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010057 smp->data.str.str = (char *)text;
58 smp->data.str.len = strlen(text);
59 smp->data.str.size = smp->data.str.len + 1;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +010060 smp->type = SMP_T_STR;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010061 return 1;
62}
63
64/* Parse an integer and convert it to a sample. The output type is SINT if the
65 * number is negative, or UINT if it is positive or null. The function returns
66 * zero (error) if the number is too large.
67 */
Thierry FOURNIERb0c0a0f2013-12-10 15:05:34 +010068int map_parse_int(const char *text, struct sample_storage *smp)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010069{
70 long long int value;
71 char *error;
72
73 /* parse interger and convert it. Return the value in 64 format. */
74 value = strtoll(text, &error, 10);
75 if (*error != '\0')
76 return 0;
77
78 /* check sign iand limits */
79 if (value < 0) {
80 if (value < INT_MIN)
81 return 0;
82 smp->type = SMP_T_SINT;
83 smp->data.sint = value;
84 }
85 else {
86 if (value > UINT_MAX)
87 return 0;
88 smp->type = SMP_T_UINT;
89 smp->data.uint = value;
90 }
91
92 return 1;
93}
94
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010095/* This crete and initialize map descriptor.
96 * Return NULL if out of memory error
97 */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +010098static struct map_descriptor *map_create_descriptor(struct sample_conv *conv)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010099{
100 struct map_descriptor *desc;
101
102 desc = calloc(1, sizeof(*desc));
103 if (!desc)
104 return NULL;
105
106 desc->conv = conv;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100107
108 return desc;
109}
110
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100111/* Reads patterns from a file. If <err_msg> is non-NULL, an error message will
112 * be returned there on errors and the caller will have to free it.
113 *
114 * The file contains one key + value per line. Lines which start with '#' are
115 * ignored, just like empty lines. Leading tabs/spaces are stripped. The key is
116 * then the first "word" (series of non-space/tabs characters), and the value is
117 * what follows this series of space/tab till the end of the line excluding
118 * trailing spaces/tabs.
119 *
120 * Example :
121 *
122 * # this is a comment and is ignored
123 * 62.212.114.60 1wt.eu \n
124 * <-><-----------><---><----><---->
125 * | | | | `--- trailing spaces ignored
126 * | | | `-------- value
127 * | | `--------------- middle spaces ignored
128 * | `------------------------ key
129 * `-------------------------------- leading spaces ignored
130 *
131 * Return non-zero in case of succes, otherwise 0.
132 */
133static int map_read_entries_from_file(const char *filename,
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100134 struct pat_ref *ref,
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100135 char **err)
136{
137 FILE *file;
138 char *c;
139 int ret = 0;
140 int line = 0;
141 char *key_beg;
142 char *key_end;
143 char *value_beg;
144 char *value_end;
145
146 file = fopen(filename, "r");
147 if (!file) {
148 memprintf(err, "failed to open pattern file <%s>", filename);
149 return 0;
150 }
151
152 /* now parse all patterns. The file may contain only one pattern
153 * followed by one value per line. The start spaces, separator spaces
154 * and and spaces are stripped. Each can contain comment started by '#'
155 */
156 while (fgets(trash.str, trash.size, file) != NULL) {
157 line++;
158 c = trash.str;
159
160 /* ignore lines beginning with a dash */
161 if (*c == '#')
162 continue;
163
164 /* strip leading spaces and tabs */
165 while (*c == ' ' || *c == '\t')
166 c++;
167
168 /* empty lines are ignored too */
Thierry FOURNIER338a0312014-02-26 18:30:13 +0100169 if (*c == '\0' || *c == '\r' || *c == '\n')
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100170 continue;
171
172 /* look for the end of the key */
173 key_beg = c;
174 while (*c && *c != ' ' && *c != '\t' && *c != '\n' && *c != '\r')
175 c++;
176
177 key_end = c;
178
179 /* strip middle spaces and tabs */
180 while (*c == ' ' || *c == '\t')
181 c++;
182
183 /* look for the end of the value, it is the end of the line */
184 value_beg = c;
185 while (*c && *c != '\n' && *c != '\r')
186 c++;
187 value_end = c;
188
189 /* trim possibly trailing spaces and tabs */
190 while (value_end > value_beg && (value_end[-1] == ' ' || value_end[-1] == '\t'))
191 value_end--;
192
193 /* set final \0 and check entries */
194 *key_end = '\0';
195 *value_end = '\0';
196
197 /* insert values */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100198 if (!pat_ref_append(ref, key_beg, value_beg, line)) {
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100199 memprintf(err, "out of memory");
200 goto out_close;
201 }
202 }
203
204 /* succes */
205 ret = 1;
206
207 out_close:
208 fclose(file);
209 return ret;
210}
211
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100212/* This function load the map file according with data type declared into
213 * the "struct sample_conv".
214 *
215 * This function choose the indexation type (ebtree or list) according with
216 * the type of match needed.
217 */
218static int sample_load_map(struct arg *arg, struct sample_conv *conv, char **err)
219{
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100220 struct pat_ref *ref;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100221 struct map_descriptor *desc;
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100222 struct pattern_expr *expr;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100223
224 /* look for existing map reference. The reference is the
225 * file encountered in the first argument. arg[0] with string
226 * type is guaranteed by the parser.
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100227 *
228 * If the reference dosn't exists, create it and load file.
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100229 */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100230 ref = pat_ref_lookup(arg[0].data.str.str);
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100231 if (!ref) {
Thierry FOURNIER0d6ba512014-02-11 03:31:34 +0100232 snprintf(trash.str, trash.size, "map(s) loaded from file '%s'", arg[0].data.str.str);
233 trash.str[trash.size - 1] = '\0';
234 ref = pat_ref_new(arg[0].data.str.str, trash.str, PAT_REF_MAP);
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100235 if (!ref) {
236 memprintf(err, "out of memory");
237 return 0;
238 }
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100239 if (!map_read_entries_from_file(arg[0].data.str.str, ref, err))
240 return 0;
241 }
242
243 /* create new map descriptor */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100244 desc = map_create_descriptor(conv);
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100245 if (!desc) {
246 memprintf(err, "out of memory");
247 return 0;
248 }
249
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100250 /* Initialize pattern */
251 pattern_init_head(&desc->pat);
252
253 /* This is original pattern, must free */
254 desc->do_free = 1;
255
256 /* Set the match method. */
257 desc->pat.match = pat_match_fcts[conv->private];
258 desc->pat.parse = pat_parse_fcts[conv->private];
259 desc->pat.index = pat_index_fcts[conv->private];
260 desc->pat.delete = pat_delete_fcts[conv->private];
261 desc->pat.prune = pat_prune_fcts[conv->private];
262 desc->pat.find_smp = pat_find_smp_fcts[conv->private];
Thierry FOURNIER5d344082014-01-27 14:19:53 +0100263 desc->pat.expect_type = pat_match_types[conv->private];
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100264
265 /* Set the output parse method. */
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100266 switch (desc->conv->out_type) {
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100267 case SMP_T_STR: desc->pat.parse_smp = map_parse_str; break;
268 case SMP_T_UINT: desc->pat.parse_smp = map_parse_int; break;
269 case SMP_T_IPV4: desc->pat.parse_smp = map_parse_ip; break;
270 case SMP_T_IPV6: desc->pat.parse_smp = map_parse_ip6; break;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100271 default:
272 memprintf(err, "map: internal haproxy error: no default parse case for the input type <%d>.",
273 conv->out_type);
274 return 0;
275 }
276
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100277 /* Create new pattern expression for this reference. */
278 expr = pattern_new_expr(&desc->pat, ref, err);
279 if (!expr)
280 return 0;
Thierry FOURNIER0ffe78c2013-12-05 14:40:25 +0100281
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100282 /* Load the reference content in the pattern expression. */
283 if (!pat_ref_load(ref, expr, 0, 1, err))
284 return 0;
Thierry FOURNIER0ffe78c2013-12-05 14:40:25 +0100285
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100286 /* The second argument is the default value */
287 if (arg[1].type == ARGT_STR) {
288 desc->default_value = strdup(arg[1].data.str.str);
289 if (!desc->default_value) {
290 memprintf(err, "out of memory");
291 return 0;
292 }
293 desc->def = calloc(1, sizeof(*desc->def));
294 if (!desc->def) {
295 memprintf(err, "out of memory");
296 return 0;
297 }
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100298 if (!desc->pat.parse_smp(desc->default_value, desc->def)) {
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100299 memprintf(err, "Cannot parse default value");
300 return 0;
301 }
302 }
303 else
304 desc->def = NULL;
305
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100306 /* replace the first argument by this definition */
307 arg[0].type = ARGT_MAP;
308 arg[0].data.map = desc;
309
310 return 1;
311}
312
313static int sample_conv_map(const struct arg *arg_p, struct sample *smp)
314{
315 struct map_descriptor *desc;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100316 struct pattern *pat;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100317
318 /* get config */
319 desc = arg_p[0].data.map;
320
321 /* Execute the match function. */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100322 pat = pattern_exec_match(&desc->pat, smp, 1);
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100323
324 /* Match case. */
325 if (pat) {
326 /* Copy sample. */
327 if (pat->smp) {
328 smp->type = pat->smp->type;
329 smp->flags |= SMP_F_CONST;
330 memcpy(&smp->data, &pat->smp->data, sizeof(smp->data));
331 return 1;
332 }
333
334 /* Return just int sample containing 1. */
335 smp->type = SMP_T_UINT;
336 smp->data.uint= 1;
337 return 1;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100338 }
339
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100340 /* If no default value avalaible, the converter fails. */
341 if (!desc->def)
342 return 0;
343
344 /* Return the default value. */
345 smp->type = desc->def->type;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100346 smp->flags |= SMP_F_CONST;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100347 memcpy(&smp->data, &desc->def->data, sizeof(smp->data));
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100348 return 1;
349}
350
351/* Note: must not be declared <const> as its list will be overwritten
352 *
353 * For the map_*_int keywords, the output is declared as SMP_T_UINT, but the converter function
354 * can provide SMP_T_UINT, SMP_T_SINT or SMP_T_BOOL depending on how the patterns found in the
355 * file can be parsed.
356 *
357 * For the map_*_ip keyword, the output is declared as SMP_T_IPV4, but the converter function
358 * can provide SMP_T_IPV4 or SMP_T_IPV6 depending on the patterns found in the file.
359 *
360 * The map_* keywords only emit strings.
361 *
362 * The output type is only used during the configuration parsing. It is used for detecting
363 * compatibility problems.
364 *
365 * The arguments are: <file>[,<default value>]
366 */
367static struct sample_conv_kw_list sample_conv_kws = {ILH, {
368 { "map", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, PAT_MATCH_STR },
369 { "map_str", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, PAT_MATCH_STR },
370 { "map_beg", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, PAT_MATCH_BEG },
371 { "map_sub", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, PAT_MATCH_SUB },
372 { "map_dir", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, PAT_MATCH_DIR },
373 { "map_dom", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, PAT_MATCH_DOM },
374 { "map_end", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, PAT_MATCH_END },
375 { "map_reg", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, PAT_MATCH_REG },
376 { "map_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_UINT, SMP_T_STR, PAT_MATCH_INT },
377 { "map_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_ADDR, SMP_T_STR, PAT_MATCH_IP },
378
379 { "map_str_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_UINT, PAT_MATCH_STR },
380 { "map_beg_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_UINT, PAT_MATCH_BEG },
381 { "map_sub_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_UINT, PAT_MATCH_SUB },
382 { "map_dir_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_UINT, PAT_MATCH_DIR },
383 { "map_dom_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_UINT, PAT_MATCH_DOM },
384 { "map_end_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_UINT, PAT_MATCH_END },
385 { "map_reg_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_UINT, PAT_MATCH_REG },
386 { "map_int_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_UINT, SMP_T_UINT, PAT_MATCH_INT },
387 { "map_ip_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_ADDR, SMP_T_UINT, PAT_MATCH_IP },
388
389 { "map_str_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_IPV4, PAT_MATCH_STR },
390 { "map_beg_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_IPV4, PAT_MATCH_BEG },
391 { "map_sub_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_IPV4, PAT_MATCH_SUB },
392 { "map_dir_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_IPV4, PAT_MATCH_DIR },
393 { "map_dom_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_IPV4, PAT_MATCH_DOM },
394 { "map_end_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_IPV4, PAT_MATCH_END },
395 { "map_reg_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_IPV4, PAT_MATCH_REG },
396 { "map_int_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_UINT, SMP_T_IPV4, PAT_MATCH_INT },
397 { "map_ip_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_ADDR, SMP_T_IPV4, PAT_MATCH_IP },
398
399 { /* END */ },
400}};
401
402__attribute__((constructor))
403static void __map_init(void)
404{
405 /* register format conversion keywords */
406 sample_register_convs(&sample_conv_kws);
407}