blob: 99ea33425ee58abb74d1c4fd3479f011f308fca5 [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 */
Emeric Brunb5997f72017-07-03 11:34:05 +0200328 SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200329 LIST_INIT(&appctx->ctx.map.bref.users);
330 appctx->ctx.map.bref.ref = appctx->ctx.map.ref->head.n;
Emeric Brunb5997f72017-07-03 11:34:05 +0200331 SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100332 appctx->st2 = STAT_ST_LIST;
333 /* fall through */
334
335 case STAT_ST_LIST:
Emeric Brunb5997f72017-07-03 11:34:05 +0200336
337 SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
338
Emeric Brun8d85aa42017-06-29 15:40:33 +0200339 if (!LIST_ISEMPTY(&appctx->ctx.map.bref.users)) {
340 LIST_DEL(&appctx->ctx.map.bref.users);
341 LIST_INIT(&appctx->ctx.map.bref.users);
342 }
343
344 while (appctx->ctx.map.bref.ref != &appctx->ctx.map.ref->head) {
William Lallemandad8be612016-11-18 19:26:17 +0100345 chunk_reset(&trash);
346
Emeric Brun8d85aa42017-06-29 15:40:33 +0200347 elt = LIST_ELEM(appctx->ctx.map.bref.ref, struct pat_ref_elt *, list);
348
William Lallemandad8be612016-11-18 19:26:17 +0100349 /* build messages */
Emeric Brun8d85aa42017-06-29 15:40:33 +0200350 if (elt->sample)
William Lallemandad8be612016-11-18 19:26:17 +0100351 chunk_appendf(&trash, "%p %s %s\n",
Emeric Brun8d85aa42017-06-29 15:40:33 +0200352 elt, elt->pattern,
353 elt->sample);
William Lallemandad8be612016-11-18 19:26:17 +0100354 else
355 chunk_appendf(&trash, "%p %s\n",
Emeric Brun8d85aa42017-06-29 15:40:33 +0200356 elt, elt->pattern);
William Lallemandad8be612016-11-18 19:26:17 +0100357
Willy Tarreau06d80a92017-10-19 14:32:15 +0200358 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100359 /* let's try again later from this stream. We add ourselves into
360 * this stream's users so that it can remove us upon termination.
361 */
Emeric Brun8d85aa42017-06-29 15:40:33 +0200362 LIST_ADDQ(&elt->back_refs, &appctx->ctx.map.bref.users);
Emeric Brunb5997f72017-07-03 11:34:05 +0200363 SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
364 si_applet_cant_put(si);
William Lallemandad8be612016-11-18 19:26:17 +0100365 return 0;
366 }
367
368 /* get next list entry and check the end of the list */
Emeric Brun8d85aa42017-06-29 15:40:33 +0200369 appctx->ctx.map.bref.ref = elt->list.n;
William Lallemandad8be612016-11-18 19:26:17 +0100370 }
Emeric Brunb5997f72017-07-03 11:34:05 +0200371 SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100372 appctx->st2 = STAT_ST_FIN;
373 /* fall through */
374
375 default:
376 appctx->st2 = STAT_ST_FIN;
377 return 1;
378 }
379}
380
381static int cli_io_handler_pats_list(struct appctx *appctx)
382{
383 struct stream_interface *si = appctx->owner;
384
385 switch (appctx->st2) {
386 case STAT_ST_INIT:
387 /* Display the column headers. If the message cannot be sent,
388 * quit the fucntion with returning 0. The function is called
389 * later and restart at the state "STAT_ST_INIT".
390 */
391 chunk_reset(&trash);
392 chunk_appendf(&trash, "# id (file) description\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +0200393 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100394 si_applet_cant_put(si);
395 return 0;
396 }
397
398 /* Now, we start the browsing of the references lists.
399 * Note that the following call to LIST_ELEM return bad pointer. The only
400 * available field of this pointer is <list>. It is used with the function
401 * pat_list_get_next() for retruning the first available entry
402 */
403 appctx->ctx.map.ref = LIST_ELEM(&pattern_reference, struct pat_ref *, list);
404 appctx->ctx.map.ref = pat_list_get_next(appctx->ctx.map.ref, &pattern_reference,
405 appctx->ctx.map.display_flags);
406 appctx->st2 = STAT_ST_LIST;
407 /* fall through */
408
409 case STAT_ST_LIST:
410 while (appctx->ctx.map.ref) {
411 chunk_reset(&trash);
412
413 /* Build messages. If the reference is used by another category than
414 * the listed categorie, display the information in the massage.
415 */
416 chunk_appendf(&trash, "%d (%s) %s\n", appctx->ctx.map.ref->unique_id,
417 appctx->ctx.map.ref->reference ? appctx->ctx.map.ref->reference : "",
418 appctx->ctx.map.ref->display);
419
Willy Tarreau06d80a92017-10-19 14:32:15 +0200420 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100421 /* let's try again later from this stream. We add ourselves into
422 * this stream's users so that it can remove us upon termination.
423 */
424 si_applet_cant_put(si);
425 return 0;
426 }
427
428 /* get next list entry and check the end of the list */
429 appctx->ctx.map.ref = pat_list_get_next(appctx->ctx.map.ref, &pattern_reference,
430 appctx->ctx.map.display_flags);
431 }
432
433 appctx->st2 = STAT_ST_FIN;
434 /* fall through */
435
436 default:
437 appctx->st2 = STAT_ST_FIN;
438 return 1;
439 }
440 return 0;
441}
442
443static int cli_io_handler_map_lookup(struct appctx *appctx)
444{
445 struct stream_interface *si = appctx->owner;
446 struct sample sample;
447 struct pattern *pat;
448 int match_method;
449
450 switch (appctx->st2) {
451 case STAT_ST_INIT:
452 /* Init to the first entry. The list cannot be change */
453 appctx->ctx.map.expr = LIST_ELEM(&appctx->ctx.map.ref->pat, struct pattern_expr *, list);
454 appctx->ctx.map.expr = pat_expr_get_next(appctx->ctx.map.expr, &appctx->ctx.map.ref->pat);
455 appctx->st2 = STAT_ST_LIST;
456 /* fall through */
457
458 case STAT_ST_LIST:
Emeric Brunb5997f72017-07-03 11:34:05 +0200459 SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100460 /* for each lookup type */
461 while (appctx->ctx.map.expr) {
462 /* initialise chunk to build new message */
463 chunk_reset(&trash);
464
465 /* execute pattern matching */
466 sample.data.type = SMP_T_STR;
467 sample.flags = SMP_F_CONST;
468 sample.data.u.str.len = appctx->ctx.map.chunk.len;
469 sample.data.u.str.str = appctx->ctx.map.chunk.str;
Emeric Brunb5997f72017-07-03 11:34:05 +0200470
William Lallemandad8be612016-11-18 19:26:17 +0100471 if (appctx->ctx.map.expr->pat_head->match &&
472 sample_convert(&sample, appctx->ctx.map.expr->pat_head->expect_type))
473 pat = appctx->ctx.map.expr->pat_head->match(&sample, appctx->ctx.map.expr, 1);
474 else
475 pat = NULL;
476
477 /* build return message: set type of match */
478 for (match_method=0; match_method<PAT_MATCH_NUM; match_method++)
479 if (appctx->ctx.map.expr->pat_head->match == pat_match_fcts[match_method])
480 break;
481 if (match_method >= PAT_MATCH_NUM)
482 chunk_appendf(&trash, "type=unknown(%p)", appctx->ctx.map.expr->pat_head->match);
483 else
484 chunk_appendf(&trash, "type=%s", pat_match_names[match_method]);
485
486 /* case sensitive */
487 if (appctx->ctx.map.expr->mflags & PAT_MF_IGNORE_CASE)
488 chunk_appendf(&trash, ", case=insensitive");
489 else
490 chunk_appendf(&trash, ", case=sensitive");
491
492 /* Display no match, and set default value */
493 if (!pat) {
494 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
495 chunk_appendf(&trash, ", found=no");
496 else
497 chunk_appendf(&trash, ", match=no");
498 }
499
500 /* Display match and match info */
501 else {
502 /* display match */
503 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
504 chunk_appendf(&trash, ", found=yes");
505 else
506 chunk_appendf(&trash, ", match=yes");
507
508 /* display index mode */
509 if (pat->sflags & PAT_SF_TREE)
510 chunk_appendf(&trash, ", idx=tree");
511 else
512 chunk_appendf(&trash, ", idx=list");
513
514 /* display pattern */
515 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
516 if (pat->ref && pat->ref->pattern)
517 chunk_appendf(&trash, ", key=\"%s\"", pat->ref->pattern);
518 else
519 chunk_appendf(&trash, ", key=unknown");
520 }
521 else {
522 if (pat->ref && pat->ref->pattern)
523 chunk_appendf(&trash, ", pattern=\"%s\"", pat->ref->pattern);
524 else
525 chunk_appendf(&trash, ", pattern=unknown");
526 }
527
528 /* display return value */
529 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
530 if (pat->data && pat->ref && pat->ref->sample)
531 chunk_appendf(&trash, ", value=\"%s\", type=\"%s\"", pat->ref->sample,
532 smp_to_type[pat->data->type]);
533 else
534 chunk_appendf(&trash, ", value=none");
535 }
536 }
537
538 chunk_appendf(&trash, "\n");
539
540 /* display response */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200541 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100542 /* let's try again later from this stream. We add ourselves into
543 * this stream's users so that it can remove us upon termination.
544 */
Emeric Brunb5997f72017-07-03 11:34:05 +0200545 SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100546 si_applet_cant_put(si);
547 return 0;
548 }
549
550 /* get next entry */
551 appctx->ctx.map.expr = pat_expr_get_next(appctx->ctx.map.expr,
552 &appctx->ctx.map.ref->pat);
553 }
Emeric Brunb5997f72017-07-03 11:34:05 +0200554 SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100555 appctx->st2 = STAT_ST_FIN;
556 /* fall through */
557
558 default:
559 appctx->st2 = STAT_ST_FIN;
William Lallemandad8be612016-11-18 19:26:17 +0100560 return 1;
561 }
562}
563
564static void cli_release_mlook(struct appctx *appctx)
565{
566 free(appctx->ctx.map.chunk.str);
567 appctx->ctx.map.chunk.str = NULL;
568}
569
570
571static int cli_parse_get_map(char **args, struct appctx *appctx, void *private)
572{
573 if (strcmp(args[1], "map") == 0 || strcmp(args[1], "acl") == 0) {
574 /* Set flags. */
575 if (args[1][0] == 'm')
576 appctx->ctx.map.display_flags = PAT_REF_MAP;
577 else
578 appctx->ctx.map.display_flags = PAT_REF_ACL;
579
580 /* No parameter. */
581 if (!*args[2] || !*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200582 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
583 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100584 appctx->ctx.cli.msg = "Missing map identifier and/or key.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200585 }
586 else {
587 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100588 appctx->ctx.cli.msg = "Missing ACL identifier and/or key.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200589 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100590 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100591 return 1;
592 }
593
594 /* lookup into the maps */
595 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
596 if (!appctx->ctx.map.ref) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200597 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
598 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100599 appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200600 }
601 else {
602 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100603 appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <file>.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200604 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100605 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100606 return 1;
607 }
608
609 /* copy input string. The string must be allocated because
610 * it may be used over multiple iterations. It's released
611 * at the end and upon abort anyway.
612 */
613 appctx->ctx.map.chunk.len = strlen(args[3]);
614 appctx->ctx.map.chunk.size = appctx->ctx.map.chunk.len + 1;
615 appctx->ctx.map.chunk.str = strdup(args[3]);
616 if (!appctx->ctx.map.chunk.str) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200617 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100618 appctx->ctx.cli.msg = "Out of memory error.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100619 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100620 return 1;
621 }
622
623 return 0;
624 }
625 return 1;
626}
627
Emeric Brun8d85aa42017-06-29 15:40:33 +0200628static void cli_release_show_map(struct appctx *appctx)
629{
630 if (appctx->st2 == STAT_ST_LIST) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200631 SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200632 if (!LIST_ISEMPTY(&appctx->ctx.map.bref.users))
633 LIST_DEL(&appctx->ctx.map.bref.users);
Emeric Brunb5997f72017-07-03 11:34:05 +0200634 SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200635 }
636}
637
William Lallemandad8be612016-11-18 19:26:17 +0100638static int cli_parse_show_map(char **args, struct appctx *appctx, void *private)
639{
640 if (strcmp(args[1], "map") == 0 ||
641 strcmp(args[1], "acl") == 0) {
642
643 /* Set ACL or MAP flags. */
644 if (args[1][0] == 'm')
645 appctx->ctx.map.display_flags = PAT_REF_MAP;
646 else
647 appctx->ctx.map.display_flags = PAT_REF_ACL;
648
649 /* no parameter: display all map available */
650 if (!*args[2]) {
William Lallemandad8be612016-11-18 19:26:17 +0100651 appctx->io_handler = cli_io_handler_pats_list;
652 return 0;
653 }
654
655 /* lookup into the refs and check the map flag */
656 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
657 if (!appctx->ctx.map.ref ||
658 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200659 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
660 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100661 appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200662 }
663 else {
664 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100665 appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <file>.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200666 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100667 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100668 return 1;
669 }
William Lallemandad8be612016-11-18 19:26:17 +0100670 appctx->io_handler = cli_io_handler_pat_list;
Emeric Brun8d85aa42017-06-29 15:40:33 +0200671 appctx->io_release = cli_release_show_map;
William Lallemandad8be612016-11-18 19:26:17 +0100672 return 0;
673 }
674
675 return 0;
676}
677
678static int cli_parse_set_map(char **args, struct appctx *appctx, void *private)
679{
680 if (strcmp(args[1], "map") == 0) {
681 char *err;
682
683 /* Set flags. */
684 appctx->ctx.map.display_flags = PAT_REF_MAP;
685
686 /* Expect three parameters: map name, key and new value. */
687 if (!*args[2] || !*args[3] || !*args[4]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200688 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100689 appctx->ctx.cli.msg = "'set map' expects three parameters: map identifier, key and value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100690 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100691 return 1;
692 }
693
694 /* Lookup the reference in the maps. */
695 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
696 if (!appctx->ctx.map.ref) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200697 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100698 appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100699 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100700 return 1;
701 }
702
703 /* If the entry identifier start with a '#', it is considered as
704 * pointer id
705 */
706 if (args[3][0] == '#' && args[3][1] == '0' && args[3][2] == 'x') {
707 struct pat_ref_elt *ref;
708 long long int conv;
709 char *error;
710
711 /* Convert argument to integer value. */
712 conv = strtoll(&args[3][1], &error, 16);
713 if (*error != '\0') {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200714 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100715 appctx->ctx.cli.msg = "Malformed identifier. Please use #<id> or <file>.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100716 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100717 return 1;
718 }
719
720 /* Convert and check integer to pointer. */
721 ref = (struct pat_ref_elt *)(long)conv;
722 if ((long long int)(long)ref != conv) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200723 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100724 appctx->ctx.cli.msg = "Malformed identifier. Please use #<id> or <file>.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100725 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100726 return 1;
727 }
728
729 /* Try to delete the entry. */
730 err = NULL;
Emeric Brunb5997f72017-07-03 11:34:05 +0200731 SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100732 if (!pat_ref_set_by_id(appctx->ctx.map.ref, ref, args[4], &err)) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200733 SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100734 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 }
Emeric Brunb5997f72017-07-03 11:34:05 +0200740 SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100741 }
742 else {
743 /* Else, use the entry identifier as pattern
744 * string, and update the value.
745 */
746 err = NULL;
Emeric Brunb5997f72017-07-03 11:34:05 +0200747 SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100748 if (!pat_ref_set(appctx->ctx.map.ref, args[3], args[4], &err)) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200749 SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100750 if (err)
751 memprintf(&err, "%s.\n", err);
752 appctx->ctx.cli.err = err;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100753 appctx->st0 = CLI_ST_PRINT_FREE;
William Lallemandad8be612016-11-18 19:26:17 +0100754 return 1;
755 }
Emeric Brunb5997f72017-07-03 11:34:05 +0200756 SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100757 }
758
759 /* The set is done, send message. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100760 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100761 return 0;
762 }
763 return 1;
764}
765
766static int cli_parse_add_map(char **args, struct appctx *appctx, void *private)
767{
768 if (strcmp(args[1], "map") == 0 ||
769 strcmp(args[1], "acl") == 0) {
770 int ret;
771 char *err;
772
773 /* Set flags. */
774 if (args[1][0] == 'm')
775 appctx->ctx.map.display_flags = PAT_REF_MAP;
776 else
777 appctx->ctx.map.display_flags = PAT_REF_ACL;
778
779 /* If the keywork is "map", we expect three parameters, if it
780 * is "acl", we expect only two parameters
781 */
782 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
783 if (!*args[2] || !*args[3] || !*args[4]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200784 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100785 appctx->ctx.cli.msg = "'add map' expects three parameters: map identifier, key and value.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100786 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100787 return 1;
788 }
789 }
790 else {
791 if (!*args[2] || !*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200792 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100793 appctx->ctx.cli.msg = "'add acl' expects two parameters: ACL identifier and pattern.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100794 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100795 return 1;
796 }
797 }
798
799 /* Lookup for the reference. */
800 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
801 if (!appctx->ctx.map.ref) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200802 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
803 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100804 appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200805 }
806 else {
807 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100808 appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <file>.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200809 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100810 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100811 return 1;
812 }
813
814 /* The command "add acl" is prohibited if the reference
815 * use samples.
816 */
817 if ((appctx->ctx.map.display_flags & PAT_REF_ACL) &&
818 (appctx->ctx.map.ref->flags & PAT_REF_SMP)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200819 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100820 appctx->ctx.cli.msg = "This ACL is shared with a map containing samples. "
821 "You must use the command 'add map' to add values.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100822 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100823 return 1;
824 }
825
826 /* Add value. */
827 err = NULL;
Emeric Brunb5997f72017-07-03 11:34:05 +0200828 SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100829 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
830 ret = pat_ref_add(appctx->ctx.map.ref, args[3], args[4], &err);
831 else
832 ret = pat_ref_add(appctx->ctx.map.ref, args[3], NULL, &err);
Emeric Brunb5997f72017-07-03 11:34:05 +0200833 SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100834 if (!ret) {
835 if (err)
836 memprintf(&err, "%s.\n", err);
837 appctx->ctx.cli.err = err;
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100838 appctx->st0 = CLI_ST_PRINT_FREE;
William Lallemandad8be612016-11-18 19:26:17 +0100839 return 1;
840 }
841
842 /* The add is done, send message. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100843 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100844 return 1;
845 }
846
847 return 0;
848}
849
850static int cli_parse_del_map(char **args, struct appctx *appctx, void *private)
851{
852 if (args[1][0] == 'm')
853 appctx->ctx.map.display_flags = PAT_REF_MAP;
854 else
855 appctx->ctx.map.display_flags = PAT_REF_ACL;
856
857 /* Expect two parameters: map name and key. */
858 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
859 if (!*args[2] || !*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200860 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100861 appctx->ctx.cli.msg = "This command expects two parameters: map identifier and key.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100862 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100863 return 1;
864 }
865 }
866
867 else {
868 if (!*args[2] || !*args[3]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200869 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100870 appctx->ctx.cli.msg = "This command expects two parameters: ACL identifier and key.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100871 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100872 return 1;
873 }
874 }
875
876 /* Lookup the reference in the maps. */
877 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
878 if (!appctx->ctx.map.ref ||
879 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200880 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100881 appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100882 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100883 return 1;
884 }
885
886 /* If the entry identifier start with a '#', it is considered as
887 * pointer id
888 */
889 if (args[3][0] == '#' && args[3][1] == '0' && args[3][2] == 'x') {
890 struct pat_ref_elt *ref;
891 long long int conv;
892 char *error;
893
894 /* Convert argument to integer value. */
895 conv = strtoll(&args[3][1], &error, 16);
896 if (*error != '\0') {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200897 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100898 appctx->ctx.cli.msg = "Malformed identifier. Please use #<id> or <file>.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100899 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100900 return 1;
901 }
902
903 /* Convert and check integer to pointer. */
904 ref = (struct pat_ref_elt *)(long)conv;
905 if ((long long int)(long)ref != conv) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200906 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100907 appctx->ctx.cli.msg = "Malformed identifier. Please use #<id> or <file>.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100908 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100909 return 1;
910 }
911
912 /* Try to delete the entry. */
Emeric Brunb5997f72017-07-03 11:34:05 +0200913 SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100914 if (!pat_ref_delete_by_id(appctx->ctx.map.ref, ref)) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200915 SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100916 /* The entry is not found, send message. */
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200917 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100918 appctx->ctx.cli.msg = "Key not found.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100919 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100920 return 1;
921 }
Emeric Brunb5997f72017-07-03 11:34:05 +0200922 SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100923 }
924 else {
925 /* Else, use the entry identifier as pattern
926 * string and try to delete the entry.
927 */
Emeric Brunb5997f72017-07-03 11:34:05 +0200928 SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100929 if (!pat_ref_delete(appctx->ctx.map.ref, args[3])) {
Emeric Brunb5997f72017-07-03 11:34:05 +0200930 SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100931 /* The entry is not found, send message. */
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200932 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100933 appctx->ctx.cli.msg = "Key not found.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100934 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100935 return 1;
936 }
Emeric Brunb5997f72017-07-03 11:34:05 +0200937 SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100938 }
939
940 /* The deletion is done, send message. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100941 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100942 return 1;
943}
944
945
946static int cli_parse_clear_map(char **args, struct appctx *appctx, void *private)
947{
948 if (strcmp(args[1], "map") == 0 || strcmp(args[1], "acl") == 0) {
949 /* Set ACL or MAP flags. */
950 if (args[1][0] == 'm')
951 appctx->ctx.map.display_flags = PAT_REF_MAP;
952 else
953 appctx->ctx.map.display_flags = PAT_REF_ACL;
954
955 /* no parameter */
956 if (!*args[2]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200957 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
958 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100959 appctx->ctx.cli.msg = "Missing map identifier.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200960 }
961 else {
962 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100963 appctx->ctx.cli.msg = "Missing ACL identifier.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200964 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100965 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100966 return 1;
967 }
968
969 /* lookup into the refs and check the map flag */
970 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
971 if (!appctx->ctx.map.ref ||
972 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200973 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
974 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100975 appctx->ctx.cli.msg = "Unknown map identifier. Please use #<id> or <file>.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200976 }
977 else {
978 appctx->ctx.cli.severity = LOG_ERR;
William Lallemandad8be612016-11-18 19:26:17 +0100979 appctx->ctx.cli.msg = "Unknown ACL identifier. Please use #<id> or <file>.\n";
Andjelko Iharosc3680ec2017-07-20 16:49:14 +0200980 }
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100981 appctx->st0 = CLI_ST_PRINT;
William Lallemandad8be612016-11-18 19:26:17 +0100982 return 1;
983 }
984
985 /* Clear all. */
Emeric Brunb5997f72017-07-03 11:34:05 +0200986 SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100987 pat_ref_prune(appctx->ctx.map.ref);
Emeric Brunb5997f72017-07-03 11:34:05 +0200988 SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100989
990 /* return response */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100991 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100992 return 1;
993 }
994 return 0;
995}
996
997/* register cli keywords */
998
999static struct cli_kw_list cli_kws = {{ },{
1000 { { "add", "acl", NULL }, "add acl : add acl entry", cli_parse_add_map, NULL },
1001 { { "clear", "acl", NULL }, "clear acl <id> : clear the content of this acl", cli_parse_clear_map, NULL },
1002 { { "del", "acl", NULL }, "del acl : delete acl entry", cli_parse_del_map, NULL },
1003 { { "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 },
1004 { { "show", "acl", NULL }, "show acl [id] : report available acls or dump an acl's contents", cli_parse_show_map, NULL },
1005 { { "add", "map", NULL }, "add map : add map entry", cli_parse_add_map, NULL },
1006 { { "clear", "map", NULL }, "clear map <id> : clear the content of this map", cli_parse_clear_map, NULL },
1007 { { "del", "map", NULL }, "del map : delete map entry", cli_parse_del_map, NULL },
Nenad Merdanovic96c15712017-03-12 22:01:36 +01001008 { { "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 +01001009 { { "set", "map", NULL }, "set map : modify map entry", cli_parse_set_map, NULL },
1010 { { "show", "map", NULL }, "show map [id] : report available maps or dump a map's contents", cli_parse_show_map, NULL },
1011 { { NULL }, NULL, NULL, NULL }
1012}};
1013
1014
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +01001015/* Note: must not be declared <const> as its list will be overwritten
1016 *
1017 * For the map_*_int keywords, the output is declared as SMP_T_UINT, but the converter function
1018 * can provide SMP_T_UINT, SMP_T_SINT or SMP_T_BOOL depending on how the patterns found in the
1019 * file can be parsed.
1020 *
1021 * For the map_*_ip keyword, the output is declared as SMP_T_IPV4, but the converter function
1022 * can provide SMP_T_IPV4 or SMP_T_IPV6 depending on the patterns found in the file.
1023 *
1024 * The map_* keywords only emit strings.
1025 *
1026 * The output type is only used during the configuration parsing. It is used for detecting
1027 * compatibility problems.
1028 *
1029 * The arguments are: <file>[,<default value>]
1030 */
1031static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Thierry FOURNIER1edc9712014-12-15 16:18:39 +01001032 { "map", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_STR },
1033 { "map_str", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_STR },
1034 { "map_beg", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_BEG },
1035 { "map_sub", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_SUB },
1036 { "map_dir", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_DIR },
1037 { "map_dom", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_DOM },
1038 { "map_end", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_END },
1039 { "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 +01001040 { "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 +02001041 { "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 +01001042 { "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 +01001043
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001044 { "map_str_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_STR },
1045 { "map_beg_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_BEG },
1046 { "map_sub_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_SUB },
1047 { "map_dir_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_DIR },
1048 { "map_dom_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_DOM },
1049 { "map_end_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_END },
1050 { "map_reg_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_REG },
1051 { "map_int_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_SINT, SMP_T_SINT, (void *)PAT_MATCH_INT },
1052 { "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 +01001053
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +02001054 { "map_str_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_STR },
1055 { "map_beg_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_BEG },
1056 { "map_sub_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_SUB },
1057 { "map_dir_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_DIR },
1058 { "map_dom_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_DOM },
1059 { "map_end_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_END },
1060 { "map_reg_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_REG },
1061 { "map_int_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_SINT, SMP_T_ADDR, (void *)PAT_MATCH_INT },
1062 { "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 +01001063
1064 { /* END */ },
1065}};
1066
1067__attribute__((constructor))
1068static void __map_init(void)
1069{
1070 /* register format conversion keywords */
1071 sample_register_convs(&sample_conv_kws);
William Lallemandad8be612016-11-18 19:26:17 +01001072 cli_register_kw(&cli_kws);
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +01001073}