blob: dc4dd9533f0f56cf8d49a535e9e784ce06d1dc70 [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
William Lallemandad8be612016-11-18 19:26:17 +010018#include <types/applet.h>
19#include <types/cli.h>
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010020#include <types/global.h>
21#include <types/map.h>
Thierry FOURNIER1e00d382014-02-11 11:31:40 +010022#include <types/pattern.h>
William Lallemandad8be612016-11-18 19:26:17 +010023#include <types/stats.h>
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010024
William Lallemandad8be612016-11-18 19:26:17 +010025#include <proto/applet.h>
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010026#include <proto/arg.h>
William Lallemandad8be612016-11-18 19:26:17 +010027#include <proto/cli.h>
Andjelko Iharosc3680ec2017-07-20 16:49:14 +020028#include <proto/log.h>
Thierry FOURNIERb0c0a0f2013-12-10 15:05:34 +010029#include <proto/map.h>
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010030#include <proto/pattern.h>
William Lallemandad8be612016-11-18 19:26:17 +010031#include <proto/stream_interface.h>
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010032#include <proto/sample.h>
33
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +020034/* Parse an IPv4 or IPv6 address and store it into the sample.
35 * The output type is IPv4 or IPv6.
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010036 */
Thierry FOURNIER503bb092015-08-19 08:35:43 +020037int map_parse_ip(const char *text, struct sample_data *data)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010038{
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +020039 int len = strlen(text);
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010040
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +020041 if (buf2ip(text, len, &data->u.ipv4)) {
42 data->type = SMP_T_IPV4;
43 return 1;
44 }
45 if (buf2ip6(text, len, &data->u.ipv6)) {
46 data->type = SMP_T_IPV6;
47 return 1;
48 }
49 return 0;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010050}
51
52/* Parse a string and store a pointer to it into the sample. The original
53 * string must be left in memory because we return a direct memory reference.
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +010054 * The output type is SMP_T_STR. There is no risk that the data will be
55 * overwritten because sample_conv_map() makes a const sample with this
56 * output.
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010057 */
Thierry FOURNIER503bb092015-08-19 08:35:43 +020058int map_parse_str(const char *text, struct sample_data *data)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010059{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +020060 data->u.str.str = (char *)text;
61 data->u.str.len = strlen(text);
62 data->u.str.size = data->u.str.len + 1;
Thierry FOURNIER503bb092015-08-19 08:35:43 +020063 data->type = SMP_T_STR;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010064 return 1;
65}
66
67/* Parse an integer and convert it to a sample. The output type is SINT if the
68 * number is negative, or UINT if it is positive or null. The function returns
69 * zero (error) if the number is too large.
70 */
Thierry FOURNIER503bb092015-08-19 08:35:43 +020071int map_parse_int(const char *text, struct sample_data *data)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010072{
Thierry FOURNIER503bb092015-08-19 08:35:43 +020073 data->type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +020074 data->u.sint = read_int64(&text, text + strlen(text));
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +020075 if (*text != '\0')
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010076 return 0;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010077 return 1;
78}
79
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010080/* This crete and initialize map descriptor.
81 * Return NULL if out of memory error
82 */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +010083static struct map_descriptor *map_create_descriptor(struct sample_conv *conv)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010084{
85 struct map_descriptor *desc;
86
87 desc = calloc(1, sizeof(*desc));
88 if (!desc)
89 return NULL;
90
91 desc->conv = conv;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010092
93 return desc;
94}
95
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010096/* This function load the map file according with data type declared into
97 * the "struct sample_conv".
98 *
99 * This function choose the indexation type (ebtree or list) according with
100 * the type of match needed.
101 */
Thierry FOURNIER3def3932015-04-07 11:27:54 +0200102int sample_load_map(struct arg *arg, struct sample_conv *conv,
103 const char *file, int line, char **err)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100104{
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100105 struct map_descriptor *desc;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100106
107 /* create new map descriptor */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100108 desc = map_create_descriptor(conv);
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100109 if (!desc) {
110 memprintf(err, "out of memory");
111 return 0;
112 }
113
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100114 /* Initialize pattern */
115 pattern_init_head(&desc->pat);
116
117 /* This is original pattern, must free */
118 desc->do_free = 1;
119
120 /* Set the match method. */
Thierry FOURNIER1edc9712014-12-15 16:18:39 +0100121 desc->pat.match = pat_match_fcts[(long)conv->private];
122 desc->pat.parse = pat_parse_fcts[(long)conv->private];
123 desc->pat.index = pat_index_fcts[(long)conv->private];
124 desc->pat.delete = pat_delete_fcts[(long)conv->private];
125 desc->pat.prune = pat_prune_fcts[(long)conv->private];
126 desc->pat.expect_type = pat_match_types[(long)conv->private];
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100127
128 /* Set the output parse method. */
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100129 switch (desc->conv->out_type) {
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100130 case SMP_T_STR: desc->pat.parse_smp = map_parse_str; break;
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200131 case SMP_T_SINT: desc->pat.parse_smp = map_parse_int; break;
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +0200132 case SMP_T_ADDR: desc->pat.parse_smp = map_parse_ip; break;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100133 default:
134 memprintf(err, "map: internal haproxy error: no default parse case for the input type <%d>.",
135 conv->out_type);
Andreas Seltenreich78f35952016-03-03 20:32:23 +0100136 free(desc);
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100137 return 0;
138 }
139
Thierry FOURNIER39bef452014-01-29 13:29:45 +0100140 /* Load map. */
Thierry FOURNIERe47e4e22014-04-28 11:18:57 +0200141 if (!pattern_read_from_file(&desc->pat, PAT_REF_MAP, arg[0].data.str.str, PAT_MF_NO_DNS,
Thierry FOURNIER94580c92014-02-11 14:36:45 +0100142 1, err, file, line))
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100143 return 0;
Thierry FOURNIER0ffe78c2013-12-05 14:40:25 +0100144
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +0200145 /* the maps of type IP have a string as defaultvalue. This
146 * string canbe anipv4 or an ipv6, we must convert it.
147 */
148 if (desc->conv->out_type == SMP_T_ADDR) {
149 struct sample_data data;
150 if (!map_parse_ip(arg[1].data.str.str, &data)) {
151 memprintf(err, "map: cannot parse default ip <%s>.", arg[1].data.str.str);
152 return 0;
153 }
154 if (data.type == SMP_T_IPV4) {
155 arg[1].type = ARGT_IPV4;
156 arg[1].data.ipv4 = data.u.ipv4;
157 } else {
158 arg[1].type = ARGT_IPV6;
159 arg[1].data.ipv6 = data.u.ipv6;
160 }
161 }
162
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100163 /* replace the first argument by this definition */
164 arg[0].type = ARGT_MAP;
165 arg[0].data.map = desc;
166
167 return 1;
168}
169
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +0200170static int sample_conv_map(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100171{
172 struct map_descriptor *desc;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100173 struct pattern *pat;
Thierry Fournier8feaa662016-02-10 22:55:20 +0100174 struct chunk *str;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100175
176 /* get config */
177 desc = arg_p[0].data.map;
178
179 /* Execute the match function. */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100180 pat = pattern_exec_match(&desc->pat, smp, 1);
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100181
182 /* Match case. */
183 if (pat) {
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200184 if (pat->data) {
Thierry Fournier8feaa662016-02-10 22:55:20 +0100185 /* In the regm case, merge the sample with the input. */
186 if ((long)private == PAT_MATCH_REGM) {
187 str = get_trash_chunk();
188 str->len = exp_replace(str->str, str->size, smp->data.u.str.str,
189 pat->data->u.str.str,
190 (regmatch_t *)smp->ctx.a[0]);
191 if (str->len == -1)
192 return 0;
193 smp->data.u.str = *str;
194 return 1;
195 }
196 /* Copy sample. */
Thierry FOURNIER5cc18d42015-08-19 09:02:36 +0200197 smp->data = *pat->data;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100198 smp->flags |= SMP_F_CONST;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100199 return 1;
200 }
201
202 /* Return just int sample containing 1. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200203 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200204 smp->data.u.sint = 1;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100205 return 1;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100206 }
207
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100208 /* If no default value avalaible, the converter fails. */
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100209 if (arg_p[1].type == ARGT_STOP)
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100210 return 0;
211
212 /* Return the default value. */
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100213 switch (desc->conv->out_type) {
214
215 case SMP_T_STR:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200216 smp->data.type = SMP_T_STR;
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100217 smp->flags |= SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200218 smp->data.u.str = arg_p[1].data.str;
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100219 break;
220
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200221 case SMP_T_SINT:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200222 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200223 smp->data.u.sint = arg_p[1].data.sint;
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100224 break;
225
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +0200226 case SMP_T_ADDR:
227 if (arg_p[1].type == ARGT_IPV4) {
228 smp->data.type = SMP_T_IPV4;
229 smp->data.u.ipv4 = arg_p[1].data.ipv4;
230 } else {
231 smp->data.type = SMP_T_IPV6;
232 smp->data.u.ipv6 = arg_p[1].data.ipv6;
233 }
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100234 break;
235 }
236
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100237 return 1;
238}
239
William Lallemandad8be612016-11-18 19:26:17 +0100240/* This function is used with map and acl management. It permits to browse
241 * each reference. The variable <getnext> must contain the current node,
242 * <end> point to the root node and the <flags> permit to filter required
243 * nodes.
244 */
245static inline
246struct pat_ref *pat_list_get_next(struct pat_ref *getnext, struct list *end,
247 unsigned int flags)
248{
249 struct pat_ref *ref = getnext;
250
251 while (1) {
252
253 /* Get next list entry. */
254 ref = LIST_NEXT(&ref->list, struct pat_ref *, list);
255
256 /* If the entry is the last of the list, return NULL. */
257 if (&ref->list == end)
258 return NULL;
259
260 /* If the entry match the flag, return it. */
261 if (ref->flags & flags)
262 return ref;
263 }
264}
265
266static inline
267struct pat_ref *pat_ref_lookup_ref(const char *reference)
268{
269 int id;
270 char *error;
271
272 /* If the reference starts by a '#', this is numeric id. */
273 if (reference[0] == '#') {
274 /* Try to convert the numeric id. If the conversion fails, the lookup fails. */
275 id = strtol(reference + 1, &error, 10);
276 if (*error != '\0')
277 return NULL;
278
279 /* Perform the unique id lookup. */
280 return pat_ref_lookupid(id);
281 }
282
283 /* Perform the string lookup. */
284 return pat_ref_lookup(reference);
285}
286
287/* This function is used with map and acl management. It permits to browse
288 * each reference.
289 */
290static inline
291struct pattern_expr *pat_expr_get_next(struct pattern_expr *getnext, struct list *end)
292{
293 struct pattern_expr *expr;
294 expr = LIST_NEXT(&getnext->list, struct pattern_expr *, list);
295 if (&expr->list == end)
296 return NULL;
297 return expr;
298}
299
300static int cli_io_handler_pat_list(struct appctx *appctx)
301{
302 struct stream_interface *si = appctx->owner;
Emeric Brun8d85aa42017-06-29 15:40:33 +0200303 struct pat_ref_elt *elt;
304
305 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW))) {
306 /* If we're forced to shut down, we might have to remove our
307 * reference to the last ref_elt being dumped.
308 */
309 if (appctx->st2 == STAT_ST_LIST) {
310 if (!LIST_ISEMPTY(&appctx->ctx.sess.bref.users)) {
311 LIST_DEL(&appctx->ctx.sess.bref.users);
312 LIST_INIT(&appctx->ctx.sess.bref.users);
313 }
314 }
315 return 1;
316 }
William Lallemandad8be612016-11-18 19:26:17 +0100317
318 switch (appctx->st2) {
319
320 case STAT_ST_INIT:
Emeric Brun8d85aa42017-06-29 15:40:33 +0200321 /* the function had not been called yet, let's prepare the
322 * buffer for a response. We initialize the current stream
323 * pointer to the first in the global list. When a target
324 * stream is being destroyed, it is responsible for updating
325 * this pointer. We know we have reached the end when this
326 * pointer points back to the head of the streams list.
327 */
328 LIST_INIT(&appctx->ctx.map.bref.users);
329 appctx->ctx.map.bref.ref = appctx->ctx.map.ref->head.n;
William Lallemandad8be612016-11-18 19:26:17 +0100330 appctx->st2 = STAT_ST_LIST;
331 /* fall through */
332
333 case STAT_ST_LIST:
Emeric Brun8d85aa42017-06-29 15:40:33 +0200334 if (!LIST_ISEMPTY(&appctx->ctx.map.bref.users)) {
335 LIST_DEL(&appctx->ctx.map.bref.users);
336 LIST_INIT(&appctx->ctx.map.bref.users);
337 }
338
339 while (appctx->ctx.map.bref.ref != &appctx->ctx.map.ref->head) {
William Lallemandad8be612016-11-18 19:26:17 +0100340 chunk_reset(&trash);
341
Emeric Brun8d85aa42017-06-29 15:40:33 +0200342 elt = LIST_ELEM(appctx->ctx.map.bref.ref, struct pat_ref_elt *, list);
343
William Lallemandad8be612016-11-18 19:26:17 +0100344 /* build messages */
Emeric Brun8d85aa42017-06-29 15:40:33 +0200345 if (elt->sample)
William Lallemandad8be612016-11-18 19:26:17 +0100346 chunk_appendf(&trash, "%p %s %s\n",
Emeric Brun8d85aa42017-06-29 15:40:33 +0200347 elt, elt->pattern,
348 elt->sample);
William Lallemandad8be612016-11-18 19:26:17 +0100349 else
350 chunk_appendf(&trash, "%p %s\n",
Emeric Brun8d85aa42017-06-29 15:40:33 +0200351 elt, elt->pattern);
William Lallemandad8be612016-11-18 19:26:17 +0100352
Willy Tarreau06d80a92017-10-19 14:32:15 +0200353 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100354 /* let's try again later from this stream. We add ourselves into
355 * this stream's users so that it can remove us upon termination.
356 */
357 si_applet_cant_put(si);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200358 LIST_ADDQ(&elt->back_refs, &appctx->ctx.map.bref.users);
William Lallemandad8be612016-11-18 19:26:17 +0100359 return 0;
360 }
361
362 /* get next list entry and check the end of the list */
Emeric Brun8d85aa42017-06-29 15:40:33 +0200363 appctx->ctx.map.bref.ref = elt->list.n;
William Lallemandad8be612016-11-18 19:26:17 +0100364 }
365
366 appctx->st2 = STAT_ST_FIN;
367 /* fall through */
368
369 default:
370 appctx->st2 = STAT_ST_FIN;
371 return 1;
372 }
373}
374
375static int cli_io_handler_pats_list(struct appctx *appctx)
376{
377 struct stream_interface *si = appctx->owner;
378
379 switch (appctx->st2) {
380 case STAT_ST_INIT:
381 /* Display the column headers. If the message cannot be sent,
382 * quit the fucntion with returning 0. The function is called
383 * later and restart at the state "STAT_ST_INIT".
384 */
385 chunk_reset(&trash);
386 chunk_appendf(&trash, "# id (file) description\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +0200387 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100388 si_applet_cant_put(si);
389 return 0;
390 }
391
392 /* Now, we start the browsing of the references lists.
393 * Note that the following call to LIST_ELEM return bad pointer. The only
394 * available field of this pointer is <list>. It is used with the function
395 * pat_list_get_next() for retruning the first available entry
396 */
397 appctx->ctx.map.ref = LIST_ELEM(&pattern_reference, struct pat_ref *, list);
398 appctx->ctx.map.ref = pat_list_get_next(appctx->ctx.map.ref, &pattern_reference,
399 appctx->ctx.map.display_flags);
400 appctx->st2 = STAT_ST_LIST;
401 /* fall through */
402
403 case STAT_ST_LIST:
404 while (appctx->ctx.map.ref) {
405 chunk_reset(&trash);
406
407 /* Build messages. If the reference is used by another category than
408 * the listed categorie, display the information in the massage.
409 */
410 chunk_appendf(&trash, "%d (%s) %s\n", appctx->ctx.map.ref->unique_id,
411 appctx->ctx.map.ref->reference ? appctx->ctx.map.ref->reference : "",
412 appctx->ctx.map.ref->display);
413
Willy Tarreau06d80a92017-10-19 14:32:15 +0200414 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100415 /* let's try again later from this stream. We add ourselves into
416 * this stream's users so that it can remove us upon termination.
417 */
418 si_applet_cant_put(si);
419 return 0;
420 }
421
422 /* get next list entry and check the end of the list */
423 appctx->ctx.map.ref = pat_list_get_next(appctx->ctx.map.ref, &pattern_reference,
424 appctx->ctx.map.display_flags);
425 }
426
427 appctx->st2 = STAT_ST_FIN;
428 /* fall through */
429
430 default:
431 appctx->st2 = STAT_ST_FIN;
432 return 1;
433 }
434 return 0;
435}
436
437static int cli_io_handler_map_lookup(struct appctx *appctx)
438{
439 struct stream_interface *si = appctx->owner;
440 struct sample sample;
441 struct pattern *pat;
442 int match_method;
443
444 switch (appctx->st2) {
445 case STAT_ST_INIT:
446 /* Init to the first entry. The list cannot be change */
447 appctx->ctx.map.expr = LIST_ELEM(&appctx->ctx.map.ref->pat, struct pattern_expr *, list);
448 appctx->ctx.map.expr = pat_expr_get_next(appctx->ctx.map.expr, &appctx->ctx.map.ref->pat);
449 appctx->st2 = STAT_ST_LIST;
450 /* fall through */
451
452 case STAT_ST_LIST:
453 /* for each lookup type */
454 while (appctx->ctx.map.expr) {
455 /* initialise chunk to build new message */
456 chunk_reset(&trash);
457
458 /* execute pattern matching */
459 sample.data.type = SMP_T_STR;
460 sample.flags = SMP_F_CONST;
461 sample.data.u.str.len = appctx->ctx.map.chunk.len;
462 sample.data.u.str.str = appctx->ctx.map.chunk.str;
463 if (appctx->ctx.map.expr->pat_head->match &&
464 sample_convert(&sample, appctx->ctx.map.expr->pat_head->expect_type))
465 pat = appctx->ctx.map.expr->pat_head->match(&sample, appctx->ctx.map.expr, 1);
466 else
467 pat = NULL;
468
469 /* build return message: set type of match */
470 for (match_method=0; match_method<PAT_MATCH_NUM; match_method++)
471 if (appctx->ctx.map.expr->pat_head->match == pat_match_fcts[match_method])
472 break;
473 if (match_method >= PAT_MATCH_NUM)
474 chunk_appendf(&trash, "type=unknown(%p)", appctx->ctx.map.expr->pat_head->match);
475 else
476 chunk_appendf(&trash, "type=%s", pat_match_names[match_method]);
477
478 /* case sensitive */
479 if (appctx->ctx.map.expr->mflags & PAT_MF_IGNORE_CASE)
480 chunk_appendf(&trash, ", case=insensitive");
481 else
482 chunk_appendf(&trash, ", case=sensitive");
483
484 /* Display no match, and set default value */
485 if (!pat) {
486 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
487 chunk_appendf(&trash, ", found=no");
488 else
489 chunk_appendf(&trash, ", match=no");
490 }
491
492 /* Display match and match info */
493 else {
494 /* display match */
495 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
496 chunk_appendf(&trash, ", found=yes");
497 else
498 chunk_appendf(&trash, ", match=yes");
499
500 /* display index mode */
501 if (pat->sflags & PAT_SF_TREE)
502 chunk_appendf(&trash, ", idx=tree");
503 else
504 chunk_appendf(&trash, ", idx=list");
505
506 /* display pattern */
507 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
508 if (pat->ref && pat->ref->pattern)
509 chunk_appendf(&trash, ", key=\"%s\"", pat->ref->pattern);
510 else
511 chunk_appendf(&trash, ", key=unknown");
512 }
513 else {
514 if (pat->ref && pat->ref->pattern)
515 chunk_appendf(&trash, ", pattern=\"%s\"", pat->ref->pattern);
516 else
517 chunk_appendf(&trash, ", pattern=unknown");
518 }
519
520 /* display return value */
521 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
522 if (pat->data && pat->ref && pat->ref->sample)
523 chunk_appendf(&trash, ", value=\"%s\", type=\"%s\"", pat->ref->sample,
524 smp_to_type[pat->data->type]);
525 else
526 chunk_appendf(&trash, ", value=none");
527 }
528 }
529
530 chunk_appendf(&trash, "\n");
531
532 /* display response */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200533 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100534 /* let's try again later from this stream. We add ourselves into
535 * this stream's users so that it can remove us upon termination.
536 */
537 si_applet_cant_put(si);
538 return 0;
539 }
540
541 /* get next entry */
542 appctx->ctx.map.expr = pat_expr_get_next(appctx->ctx.map.expr,
543 &appctx->ctx.map.ref->pat);
544 }
545
546 appctx->st2 = STAT_ST_FIN;
547 /* fall through */
548
549 default:
550 appctx->st2 = STAT_ST_FIN;
William Lallemandad8be612016-11-18 19:26:17 +0100551 return 1;
552 }
553}
554
555static void cli_release_mlook(struct appctx *appctx)
556{
557 free(appctx->ctx.map.chunk.str);
558 appctx->ctx.map.chunk.str = NULL;
559}
560
561
562static int cli_parse_get_map(char **args, struct appctx *appctx, void *private)
563{
564 if (strcmp(args[1], "map") == 0 || strcmp(args[1], "acl") == 0) {
565 /* Set flags. */
566 if (args[1][0] == 'm')
567 appctx->ctx.map.display_flags = PAT_REF_MAP;
568 else
569 appctx->ctx.map.display_flags = PAT_REF_ACL;
570
571 /* No parameter. */
572 if (!*args[2] || !*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200573 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
574 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100575 appctx->ctx.cli.msg = "Missing map identifier and/or key.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200576 }
577 else {
578 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100579 appctx->ctx.cli.msg = "Missing ACL identifier and/or key.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200580 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100581 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100582 return 1;
583 }
584
585 /* lookup into the maps */
586 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
587 if (!appctx->ctx.map.ref) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200588 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
589 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100590 appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200591 }
592 else {
593 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100594 appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <file>.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200595 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100596 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100597 return 1;
598 }
599
600 /* copy input string. The string must be allocated because
601 * it may be used over multiple iterations. It's released
602 * at the end and upon abort anyway.
603 */
604 appctx->ctx.map.chunk.len = strlen(args[3]);
605 appctx->ctx.map.chunk.size = appctx->ctx.map.chunk.len + 1;
606 appctx->ctx.map.chunk.str = strdup(args[3]);
607 if (!appctx->ctx.map.chunk.str) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200608 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100609 appctx->ctx.cli.msg = "Out of memory error.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100610 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100611 return 1;
612 }
613
614 return 0;
615 }
616 return 1;
617}
618
Emeric Brun8d85aa42017-06-29 15:40:33 +0200619static void cli_release_show_map(struct appctx *appctx)
620{
621 if (appctx->st2 == STAT_ST_LIST) {
622 if (!LIST_ISEMPTY(&appctx->ctx.map.bref.users))
623 LIST_DEL(&appctx->ctx.map.bref.users);
624 }
625}
626
William Lallemandad8be612016-11-18 19:26:17 +0100627static int cli_parse_show_map(char **args, struct appctx *appctx, void *private)
628{
629 if (strcmp(args[1], "map") == 0 ||
630 strcmp(args[1], "acl") == 0) {
631
632 /* Set ACL or MAP flags. */
633 if (args[1][0] == 'm')
634 appctx->ctx.map.display_flags = PAT_REF_MAP;
635 else
636 appctx->ctx.map.display_flags = PAT_REF_ACL;
637
638 /* no parameter: display all map available */
639 if (!*args[2]) {
William Lallemandad8be612016-11-18 19:26:17 +0100640 appctx->io_handler = cli_io_handler_pats_list;
641 return 0;
642 }
643
644 /* lookup into the refs and check the map flag */
645 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
646 if (!appctx->ctx.map.ref ||
647 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200648 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
649 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100650 appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200651 }
652 else {
653 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100654 appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <file>.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200655 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100656 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100657 return 1;
658 }
William Lallemandad8be612016-11-18 19:26:17 +0100659 appctx->io_handler = cli_io_handler_pat_list;
Emeric Brun8d85aa42017-06-29 15:40:33 +0200660 appctx->io_release = cli_release_show_map;
William Lallemandad8be612016-11-18 19:26:17 +0100661 return 0;
662 }
663
664 return 0;
665}
666
667static int cli_parse_set_map(char **args, struct appctx *appctx, void *private)
668{
669 if (strcmp(args[1], "map") == 0) {
670 char *err;
671
672 /* Set flags. */
673 appctx->ctx.map.display_flags = PAT_REF_MAP;
674
675 /* Expect three parameters: map name, key and new value. */
676 if (!*args[2] || !*args[3] || !*args[4]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200677 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100678 appctx->ctx.cli.msg = "'set map' expects three parameters: map identifier, key and value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100679 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100680 return 1;
681 }
682
683 /* Lookup the reference in the maps. */
684 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
685 if (!appctx->ctx.map.ref) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200686 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100687 appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100688 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100689 return 1;
690 }
691
692 /* If the entry identifier start with a '#', it is considered as
693 * pointer id
694 */
695 if (args[3][0] == '#' && args[3][1] == '0' && args[3][2] == 'x') {
696 struct pat_ref_elt *ref;
697 long long int conv;
698 char *error;
699
700 /* Convert argument to integer value. */
701 conv = strtoll(&args[3][1], &error, 16);
702 if (*error != '\0') {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200703 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100704 appctx->ctx.cli.msg = "Malformed identifier. Please use #<id> or <file>.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100705 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100706 return 1;
707 }
708
709 /* Convert and check integer to pointer. */
710 ref = (struct pat_ref_elt *)(long)conv;
711 if ((long long int)(long)ref != conv) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200712 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100713 appctx->ctx.cli.msg = "Malformed identifier. Please use #<id> or <file>.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100714 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100715 return 1;
716 }
717
718 /* Try to delete the entry. */
719 err = NULL;
720 if (!pat_ref_set_by_id(appctx->ctx.map.ref, ref, args[4], &err)) {
721 if (err)
722 memprintf(&err, "%s.\n", err);
723 appctx->ctx.cli.err = err;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100724 appctx->st0 = CLI_ST_PRINT_FREE;
William Lallemandad8be612016-11-18 19:26:17 +0100725 return 1;
726 }
727 }
728 else {
729 /* Else, use the entry identifier as pattern
730 * string, and update the value.
731 */
732 err = NULL;
733 if (!pat_ref_set(appctx->ctx.map.ref, args[3], args[4], &err)) {
734 if (err)
735 memprintf(&err, "%s.\n", err);
736 appctx->ctx.cli.err = err;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100737 appctx->st0 = CLI_ST_PRINT_FREE;
William Lallemandad8be612016-11-18 19:26:17 +0100738 return 1;
739 }
740 }
741
742 /* The set is done, send message. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100743 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100744 return 0;
745 }
746 return 1;
747}
748
749static int cli_parse_add_map(char **args, struct appctx *appctx, void *private)
750{
751 if (strcmp(args[1], "map") == 0 ||
752 strcmp(args[1], "acl") == 0) {
753 int ret;
754 char *err;
755
756 /* Set flags. */
757 if (args[1][0] == 'm')
758 appctx->ctx.map.display_flags = PAT_REF_MAP;
759 else
760 appctx->ctx.map.display_flags = PAT_REF_ACL;
761
762 /* If the keywork is "map", we expect three parameters, if it
763 * is "acl", we expect only two parameters
764 */
765 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
766 if (!*args[2] || !*args[3] || !*args[4]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200767 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100768 appctx->ctx.cli.msg = "'add map' expects three parameters: map identifier, key and value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100769 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100770 return 1;
771 }
772 }
773 else {
774 if (!*args[2] || !*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200775 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100776 appctx->ctx.cli.msg = "'add acl' expects two parameters: ACL identifier and pattern.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100777 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100778 return 1;
779 }
780 }
781
782 /* Lookup for the reference. */
783 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
784 if (!appctx->ctx.map.ref) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200785 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
786 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100787 appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200788 }
789 else {
790 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100791 appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <file>.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200792 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100793 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100794 return 1;
795 }
796
797 /* The command "add acl" is prohibited if the reference
798 * use samples.
799 */
800 if ((appctx->ctx.map.display_flags & PAT_REF_ACL) &&
801 (appctx->ctx.map.ref->flags & PAT_REF_SMP)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200802 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100803 appctx->ctx.cli.msg = "This ACL is shared with a map containing samples. "
804 "You must use the command 'add map' to add values.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100805 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100806 return 1;
807 }
808
809 /* Add value. */
810 err = NULL;
811 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
812 ret = pat_ref_add(appctx->ctx.map.ref, args[3], args[4], &err);
813 else
814 ret = pat_ref_add(appctx->ctx.map.ref, args[3], NULL, &err);
815 if (!ret) {
816 if (err)
817 memprintf(&err, "%s.\n", err);
818 appctx->ctx.cli.err = err;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100819 appctx->st0 = CLI_ST_PRINT_FREE;
William Lallemandad8be612016-11-18 19:26:17 +0100820 return 1;
821 }
822
823 /* The add is done, send message. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100824 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100825 return 1;
826 }
827
828 return 0;
829}
830
831static int cli_parse_del_map(char **args, struct appctx *appctx, void *private)
832{
833 if (args[1][0] == 'm')
834 appctx->ctx.map.display_flags = PAT_REF_MAP;
835 else
836 appctx->ctx.map.display_flags = PAT_REF_ACL;
837
838 /* Expect two parameters: map name and key. */
839 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
840 if (!*args[2] || !*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200841 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100842 appctx->ctx.cli.msg = "This command expects two parameters: map identifier and key.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100843 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100844 return 1;
845 }
846 }
847
848 else {
849 if (!*args[2] || !*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200850 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100851 appctx->ctx.cli.msg = "This command expects two parameters: ACL identifier and key.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100852 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100853 return 1;
854 }
855 }
856
857 /* Lookup the reference in the maps. */
858 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
859 if (!appctx->ctx.map.ref ||
860 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200861 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100862 appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100863 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100864 return 1;
865 }
866
867 /* If the entry identifier start with a '#', it is considered as
868 * pointer id
869 */
870 if (args[3][0] == '#' && args[3][1] == '0' && args[3][2] == 'x') {
871 struct pat_ref_elt *ref;
872 long long int conv;
873 char *error;
874
875 /* Convert argument to integer value. */
876 conv = strtoll(&args[3][1], &error, 16);
877 if (*error != '\0') {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200878 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100879 appctx->ctx.cli.msg = "Malformed identifier. Please use #<id> or <file>.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100880 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100881 return 1;
882 }
883
884 /* Convert and check integer to pointer. */
885 ref = (struct pat_ref_elt *)(long)conv;
886 if ((long long int)(long)ref != conv) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200887 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100888 appctx->ctx.cli.msg = "Malformed identifier. Please use #<id> or <file>.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100889 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100890 return 1;
891 }
892
893 /* Try to delete the entry. */
894 if (!pat_ref_delete_by_id(appctx->ctx.map.ref, ref)) {
895 /* The entry is not found, send message. */
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200896 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100897 appctx->ctx.cli.msg = "Key not found.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100898 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100899 return 1;
900 }
901 }
902 else {
903 /* Else, use the entry identifier as pattern
904 * string and try to delete the entry.
905 */
906 if (!pat_ref_delete(appctx->ctx.map.ref, args[3])) {
907 /* The entry is not found, send message. */
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200908 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100909 appctx->ctx.cli.msg = "Key not found.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100910 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100911 return 1;
912 }
913 }
914
915 /* The deletion is done, send message. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100916 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100917 return 1;
918}
919
920
921static int cli_parse_clear_map(char **args, struct appctx *appctx, void *private)
922{
923 if (strcmp(args[1], "map") == 0 || strcmp(args[1], "acl") == 0) {
924 /* Set ACL or MAP flags. */
925 if (args[1][0] == 'm')
926 appctx->ctx.map.display_flags = PAT_REF_MAP;
927 else
928 appctx->ctx.map.display_flags = PAT_REF_ACL;
929
930 /* no parameter */
931 if (!*args[2]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200932 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
933 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100934 appctx->ctx.cli.msg = "Missing map identifier.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200935 }
936 else {
937 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100938 appctx->ctx.cli.msg = "Missing ACL identifier.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200939 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100940 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100941 return 1;
942 }
943
944 /* lookup into the refs and check the map flag */
945 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
946 if (!appctx->ctx.map.ref ||
947 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200948 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
949 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100950 appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200951 }
952 else {
953 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100954 appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <file>.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200955 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100956 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100957 return 1;
958 }
959
960 /* Clear all. */
961 pat_ref_prune(appctx->ctx.map.ref);
962
963 /* return response */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100964 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100965 return 1;
966 }
967 return 0;
968}
969
970/* register cli keywords */
971
972static struct cli_kw_list cli_kws = {{ },{
973 { { "add", "acl", NULL }, "add acl : add acl entry", cli_parse_add_map, NULL },
974 { { "clear", "acl", NULL }, "clear acl <id> : clear the content of this acl", cli_parse_clear_map, NULL },
975 { { "del", "acl", NULL }, "del acl : delete acl entry", cli_parse_del_map, NULL },
976 { { "get", "acl", NULL }, "get acl : report the patterns matching a sample for an ACL", cli_parse_get_map, cli_io_handler_map_lookup, cli_release_mlook },
977 { { "show", "acl", NULL }, "show acl [id] : report available acls or dump an acl's contents", cli_parse_show_map, NULL },
978 { { "add", "map", NULL }, "add map : add map entry", cli_parse_add_map, NULL },
979 { { "clear", "map", NULL }, "clear map <id> : clear the content of this map", cli_parse_clear_map, NULL },
980 { { "del", "map", NULL }, "del map : delete map entry", cli_parse_del_map, NULL },
Nenad Merdanovic96c15712017-03-12 22:01:36 +0100981 { { "get", "map", NULL }, "get map : report the keys and values matching a sample for a map", cli_parse_get_map, cli_io_handler_map_lookup, cli_release_mlook },
William Lallemandad8be612016-11-18 19:26:17 +0100982 { { "set", "map", NULL }, "set map : modify map entry", cli_parse_set_map, NULL },
983 { { "show", "map", NULL }, "show map [id] : report available maps or dump a map's contents", cli_parse_show_map, NULL },
984 { { NULL }, NULL, NULL, NULL }
985}};
986
987
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100988/* Note: must not be declared <const> as its list will be overwritten
989 *
990 * For the map_*_int keywords, the output is declared as SMP_T_UINT, but the converter function
991 * can provide SMP_T_UINT, SMP_T_SINT or SMP_T_BOOL depending on how the patterns found in the
992 * file can be parsed.
993 *
994 * For the map_*_ip keyword, the output is declared as SMP_T_IPV4, but the converter function
995 * can provide SMP_T_IPV4 or SMP_T_IPV6 depending on the patterns found in the file.
996 *
997 * The map_* keywords only emit strings.
998 *
999 * The output type is only used during the configuration parsing. It is used for detecting
1000 * compatibility problems.
1001 *
1002 * The arguments are: <file>[,<default value>]
1003 */
1004static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Thierry FOURNIER1edc9712014-12-15 16:18:39 +01001005 { "map", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_STR },
1006 { "map_str", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_STR },
1007 { "map_beg", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_BEG },
1008 { "map_sub", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_SUB },
1009 { "map_dir", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_DIR },
1010 { "map_dom", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_DOM },
1011 { "map_end", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_END },
1012 { "map_reg", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_REG },
Thierry Fournier8feaa662016-02-10 22:55:20 +01001013 { "map_regm", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_REGM},
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001014 { "map_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_SINT, SMP_T_STR, (void *)PAT_MATCH_INT },
Thierry FOURNIER1edc9712014-12-15 16:18:39 +01001015 { "map_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_ADDR, SMP_T_STR, (void *)PAT_MATCH_IP },
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +01001016
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001017 { "map_str_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_STR },
1018 { "map_beg_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_BEG },
1019 { "map_sub_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_SUB },
1020 { "map_dir_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_DIR },
1021 { "map_dom_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_DOM },
1022 { "map_end_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_END },
1023 { "map_reg_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_REG },
1024 { "map_int_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_SINT, SMP_T_SINT, (void *)PAT_MATCH_INT },
1025 { "map_ip_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_ADDR, SMP_T_SINT, (void *)PAT_MATCH_IP },
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +01001026
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +02001027 { "map_str_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_STR },
1028 { "map_beg_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_BEG },
1029 { "map_sub_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_SUB },
1030 { "map_dir_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_DIR },
1031 { "map_dom_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_DOM },
1032 { "map_end_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_END },
1033 { "map_reg_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_REG },
1034 { "map_int_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_SINT, SMP_T_ADDR, (void *)PAT_MATCH_INT },
1035 { "map_ip_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_ADDR, SMP_T_ADDR, (void *)PAT_MATCH_IP },
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +01001036
1037 { /* END */ },
1038}};
1039
1040__attribute__((constructor))
1041static void __map_init(void)
1042{
1043 /* register format conversion keywords */
1044 sample_register_convs(&sample_conv_kws);
William Lallemandad8be612016-11-18 19:26:17 +01001045 cli_register_kw(&cli_kws);
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +01001046}