blob: 041c339f448605c91f70384038b933c395bffadc [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
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010013#include <stdio.h>
14
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020015#include <haproxy/api.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020016#include <haproxy/applet-t.h>
17#include <haproxy/arg.h>
Willy Tarreau83487a82020-06-04 20:19:54 +020018#include <haproxy/cli.h>
Willy Tarreau2cd58092020-06-04 15:10:43 +020019#include <haproxy/map.h>
Willy Tarreau225a90a2020-06-04 15:06:28 +020020#include <haproxy/pattern.h>
Willy Tarreau7cd8b6e2020-06-02 17:32:26 +020021#include <haproxy/regex.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020022#include <haproxy/sample.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020023#include <haproxy/stats-t.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020024#include <haproxy/stream_interface.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020025#include <haproxy/tools.h>
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010026
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010027
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +020028/* Parse an IPv4 or IPv6 address and store it into the sample.
29 * The output type is IPv4 or IPv6.
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010030 */
Thierry FOURNIER503bb092015-08-19 08:35:43 +020031int map_parse_ip(const char *text, struct sample_data *data)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010032{
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +020033 int len = strlen(text);
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010034
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +020035 if (buf2ip(text, len, &data->u.ipv4)) {
36 data->type = SMP_T_IPV4;
37 return 1;
38 }
39 if (buf2ip6(text, len, &data->u.ipv6)) {
40 data->type = SMP_T_IPV6;
41 return 1;
42 }
43 return 0;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010044}
45
46/* Parse a string and store a pointer to it into the sample. The original
47 * string must be left in memory because we return a direct memory reference.
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +010048 * The output type is SMP_T_STR. There is no risk that the data will be
49 * overwritten because sample_conv_map() makes a const sample with this
50 * output.
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010051 */
Thierry FOURNIER503bb092015-08-19 08:35:43 +020052int map_parse_str(const char *text, struct sample_data *data)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010053{
Willy Tarreau843b7cb2018-07-13 10:54:26 +020054 data->u.str.area = (char *)text;
55 data->u.str.data = strlen(text);
56 data->u.str.size = data->u.str.data + 1;
Thierry FOURNIER503bb092015-08-19 08:35:43 +020057 data->type = SMP_T_STR;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010058 return 1;
59}
60
61/* Parse an integer and convert it to a sample. The output type is SINT if the
62 * number is negative, or UINT if it is positive or null. The function returns
63 * zero (error) if the number is too large.
64 */
Thierry FOURNIER503bb092015-08-19 08:35:43 +020065int map_parse_int(const char *text, struct sample_data *data)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010066{
Thierry FOURNIER503bb092015-08-19 08:35:43 +020067 data->type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +020068 data->u.sint = read_int64(&text, text + strlen(text));
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +020069 if (*text != '\0')
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010070 return 0;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010071 return 1;
72}
73
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010074/* This crete and initialize map descriptor.
75 * Return NULL if out of memory error
76 */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +010077static struct map_descriptor *map_create_descriptor(struct sample_conv *conv)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010078{
79 struct map_descriptor *desc;
80
81 desc = calloc(1, sizeof(*desc));
82 if (!desc)
83 return NULL;
84
85 desc->conv = conv;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010086
87 return desc;
88}
89
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010090/* This function load the map file according with data type declared into
91 * the "struct sample_conv".
92 *
93 * This function choose the indexation type (ebtree or list) according with
94 * the type of match needed.
95 */
Thierry FOURNIER3def3932015-04-07 11:27:54 +020096int sample_load_map(struct arg *arg, struct sample_conv *conv,
97 const char *file, int line, char **err)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010098{
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010099 struct map_descriptor *desc;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100100
Christopher Faulet0eb967d2020-08-05 23:23:37 +0200101 if (!(global.mode & MODE_STARTING)) {
102 memprintf(err, "map: cannot load map at runtime");
103 return 0;
104 }
105
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100106 /* create new map descriptor */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100107 desc = map_create_descriptor(conv);
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100108 if (!desc) {
109 memprintf(err, "out of memory");
110 return 0;
111 }
112
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100113 /* Initialize pattern */
114 pattern_init_head(&desc->pat);
115
116 /* This is original pattern, must free */
117 desc->do_free = 1;
118
119 /* Set the match method. */
Thierry FOURNIER1edc9712014-12-15 16:18:39 +0100120 desc->pat.match = pat_match_fcts[(long)conv->private];
121 desc->pat.parse = pat_parse_fcts[(long)conv->private];
122 desc->pat.index = pat_index_fcts[(long)conv->private];
Thierry FOURNIER1edc9712014-12-15 16:18:39 +0100123 desc->pat.prune = pat_prune_fcts[(long)conv->private];
124 desc->pat.expect_type = pat_match_types[(long)conv->private];
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100125
126 /* Set the output parse method. */
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100127 switch (desc->conv->out_type) {
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100128 case SMP_T_STR: desc->pat.parse_smp = map_parse_str; break;
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200129 case SMP_T_SINT: desc->pat.parse_smp = map_parse_int; break;
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +0200130 case SMP_T_ADDR: desc->pat.parse_smp = map_parse_ip; break;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100131 default:
132 memprintf(err, "map: internal haproxy error: no default parse case for the input type <%d>.",
133 conv->out_type);
Andreas Seltenreich78f35952016-03-03 20:32:23 +0100134 free(desc);
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100135 return 0;
136 }
137
Thierry FOURNIER39bef452014-01-29 13:29:45 +0100138 /* Load map. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200139 if (!pattern_read_from_file(&desc->pat, PAT_REF_MAP, arg[0].data.str.area, PAT_MF_NO_DNS,
Thierry FOURNIER94580c92014-02-11 14:36:45 +0100140 1, err, file, line))
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100141 return 0;
Thierry FOURNIER0ffe78c2013-12-05 14:40:25 +0100142
Willy Tarreauaa5801b2019-04-19 11:35:22 +0200143 /* the maps of type IP support a string as default value. This
144 * string can be an ipv4 or an ipv6, we must convert it.
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +0200145 */
Willy Tarreauaa5801b2019-04-19 11:35:22 +0200146 if (arg[1].type != ARGT_STOP && desc->conv->out_type == SMP_T_ADDR) {
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +0200147 struct sample_data data;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200148 if (!map_parse_ip(arg[1].data.str.area, &data)) {
149 memprintf(err, "map: cannot parse default ip <%s>.",
150 arg[1].data.str.area);
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +0200151 return 0;
152 }
Christopher Faulet6ad7df42020-08-07 11:45:18 +0200153 chunk_destroy(&arg[1].data.str);
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +0200154 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 */
Christopher Faulet6ad7df42020-08-07 11:45:18 +0200164 chunk_destroy(&arg[0].data.str);
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100165 arg[0].type = ARGT_MAP;
166 arg[0].data.map = desc;
167
168 return 1;
169}
170
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +0200171static int sample_conv_map(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100172{
173 struct map_descriptor *desc;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100174 struct pattern *pat;
Willy Tarreau83061a82018-07-13 11:56:34 +0200175 struct buffer *str;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100176
177 /* get config */
178 desc = arg_p[0].data.map;
179
180 /* Execute the match function. */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100181 pat = pattern_exec_match(&desc->pat, smp, 1);
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100182
183 /* Match case. */
184 if (pat) {
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200185 if (pat->data) {
Thierry Fournier8feaa662016-02-10 22:55:20 +0100186 /* In the regm case, merge the sample with the input. */
187 if ((long)private == PAT_MATCH_REGM) {
Emeric Brun27102212018-07-17 09:47:07 -0400188 struct buffer *tmptrash;
Willy Tarreau2842e052018-08-22 04:55:43 +0200189 int len;
Emeric Brun27102212018-07-17 09:47:07 -0400190
191 /* Copy the content of the sample because it could
192 be scratched by incoming get_trash_chunk */
193 tmptrash = alloc_trash_chunk();
194 if (!tmptrash)
195 return 0;
196
197 tmptrash->data = smp->data.u.str.data;
198 if (tmptrash->data > (tmptrash->size-1))
199 tmptrash->data = tmptrash->size-1;
200
201 memcpy(tmptrash->area, smp->data.u.str.area, tmptrash->data);
202 tmptrash->area[tmptrash->data] = 0;
203
Thierry Fournier8feaa662016-02-10 22:55:20 +0100204 str = get_trash_chunk();
Willy Tarreau2842e052018-08-22 04:55:43 +0200205 len = exp_replace(str->area, str->size,
206 tmptrash->area,
207 pat->data->u.str.area,
208 (regmatch_t *)smp->ctx.a[0]);
Nenad Merdanovic646b7742019-04-12 22:54:28 +0200209 free_trash_chunk(tmptrash);
210
Willy Tarreau2842e052018-08-22 04:55:43 +0200211 if (len == -1)
Thierry Fournier8feaa662016-02-10 22:55:20 +0100212 return 0;
Willy Tarreau2842e052018-08-22 04:55:43 +0200213
214 str->data = len;
Thierry Fournier8feaa662016-02-10 22:55:20 +0100215 smp->data.u.str = *str;
216 return 1;
217 }
218 /* Copy sample. */
Thierry FOURNIER5cc18d42015-08-19 09:02:36 +0200219 smp->data = *pat->data;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100220 smp->flags |= SMP_F_CONST;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100221 return 1;
222 }
223
224 /* Return just int sample containing 1. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200225 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200226 smp->data.u.sint = 1;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100227 return 1;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100228 }
229
Joseph Herlantf43b88b2018-11-25 11:48:18 -0800230 /* If no default value available, the converter fails. */
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100231 if (arg_p[1].type == ARGT_STOP)
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100232 return 0;
233
234 /* Return the default value. */
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100235 switch (desc->conv->out_type) {
236
237 case SMP_T_STR:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200238 smp->data.type = SMP_T_STR;
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100239 smp->flags |= SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200240 smp->data.u.str = arg_p[1].data.str;
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100241 break;
242
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200243 case SMP_T_SINT:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200244 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200245 smp->data.u.sint = arg_p[1].data.sint;
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100246 break;
247
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +0200248 case SMP_T_ADDR:
249 if (arg_p[1].type == ARGT_IPV4) {
250 smp->data.type = SMP_T_IPV4;
251 smp->data.u.ipv4 = arg_p[1].data.ipv4;
252 } else {
253 smp->data.type = SMP_T_IPV6;
254 smp->data.u.ipv6 = arg_p[1].data.ipv6;
255 }
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100256 break;
257 }
258
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100259 return 1;
260}
261
William Lallemandad8be612016-11-18 19:26:17 +0100262/* This function is used with map and acl management. It permits to browse
263 * each reference. The variable <getnext> must contain the current node,
264 * <end> point to the root node and the <flags> permit to filter required
265 * nodes.
266 */
267static inline
268struct pat_ref *pat_list_get_next(struct pat_ref *getnext, struct list *end,
269 unsigned int flags)
270{
271 struct pat_ref *ref = getnext;
272
273 while (1) {
274
275 /* Get next list entry. */
276 ref = LIST_NEXT(&ref->list, struct pat_ref *, list);
277
278 /* If the entry is the last of the list, return NULL. */
279 if (&ref->list == end)
280 return NULL;
281
282 /* If the entry match the flag, return it. */
283 if (ref->flags & flags)
284 return ref;
285 }
286}
287
288static inline
289struct pat_ref *pat_ref_lookup_ref(const char *reference)
290{
291 int id;
292 char *error;
293
294 /* If the reference starts by a '#', this is numeric id. */
295 if (reference[0] == '#') {
296 /* Try to convert the numeric id. If the conversion fails, the lookup fails. */
297 id = strtol(reference + 1, &error, 10);
298 if (*error != '\0')
299 return NULL;
300
301 /* Perform the unique id lookup. */
302 return pat_ref_lookupid(id);
303 }
304
305 /* Perform the string lookup. */
306 return pat_ref_lookup(reference);
307}
308
309/* This function is used with map and acl management. It permits to browse
310 * each reference.
311 */
312static inline
313struct pattern_expr *pat_expr_get_next(struct pattern_expr *getnext, struct list *end)
314{
315 struct pattern_expr *expr;
316 expr = LIST_NEXT(&getnext->list, struct pattern_expr *, list);
317 if (&expr->list == end)
318 return NULL;
319 return expr;
320}
321
322static int cli_io_handler_pat_list(struct appctx *appctx)
323{
324 struct stream_interface *si = appctx->owner;
Emeric Brun8d85aa42017-06-29 15:40:33 +0200325 struct pat_ref_elt *elt;
326
327 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW))) {
328 /* If we're forced to shut down, we might have to remove our
329 * reference to the last ref_elt being dumped.
330 */
331 if (appctx->st2 == STAT_ST_LIST) {
Dragan Dosen336a11f2018-05-04 16:27:15 +0200332 if (!LIST_ISEMPTY(&appctx->ctx.map.bref.users)) {
Willy Tarreau2b718102021-04-21 07:32:39 +0200333 LIST_DELETE(&appctx->ctx.map.bref.users);
Dragan Dosen336a11f2018-05-04 16:27:15 +0200334 LIST_INIT(&appctx->ctx.map.bref.users);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200335 }
336 }
337 return 1;
338 }
William Lallemandad8be612016-11-18 19:26:17 +0100339
340 switch (appctx->st2) {
341
342 case STAT_ST_INIT:
Emeric Brun8d85aa42017-06-29 15:40:33 +0200343 /* the function had not been called yet, let's prepare the
344 * buffer for a response. We initialize the current stream
345 * pointer to the first in the global list. When a target
346 * stream is being destroyed, it is responsible for updating
347 * this pointer. We know we have reached the end when this
348 * pointer points back to the head of the streams list.
349 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100350 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200351 LIST_INIT(&appctx->ctx.map.bref.users);
352 appctx->ctx.map.bref.ref = appctx->ctx.map.ref->head.n;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100353 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100354 appctx->st2 = STAT_ST_LIST;
355 /* fall through */
356
357 case STAT_ST_LIST:
Emeric Brunb5997f72017-07-03 11:34:05 +0200358
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100359 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200360
Emeric Brun8d85aa42017-06-29 15:40:33 +0200361 if (!LIST_ISEMPTY(&appctx->ctx.map.bref.users)) {
Willy Tarreau2b718102021-04-21 07:32:39 +0200362 LIST_DELETE(&appctx->ctx.map.bref.users);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200363 LIST_INIT(&appctx->ctx.map.bref.users);
364 }
365
366 while (appctx->ctx.map.bref.ref != &appctx->ctx.map.ref->head) {
William Lallemandad8be612016-11-18 19:26:17 +0100367 chunk_reset(&trash);
368
Emeric Brun8d85aa42017-06-29 15:40:33 +0200369 elt = LIST_ELEM(appctx->ctx.map.bref.ref, struct pat_ref_elt *, list);
370
Willy Tarreauc93da692020-10-29 09:41:34 +0100371 if (elt->gen_id != appctx->ctx.map.ref->curr_gen)
372 goto skip;
373
William Lallemandad8be612016-11-18 19:26:17 +0100374 /* build messages */
Emeric Brun8d85aa42017-06-29 15:40:33 +0200375 if (elt->sample)
William Lallemandad8be612016-11-18 19:26:17 +0100376 chunk_appendf(&trash, "%p %s %s\n",
Emeric Brun8d85aa42017-06-29 15:40:33 +0200377 elt, elt->pattern,
378 elt->sample);
William Lallemandad8be612016-11-18 19:26:17 +0100379 else
380 chunk_appendf(&trash, "%p %s\n",
Emeric Brun8d85aa42017-06-29 15:40:33 +0200381 elt, elt->pattern);
William Lallemandad8be612016-11-18 19:26:17 +0100382
Willy Tarreau06d80a92017-10-19 14:32:15 +0200383 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100384 /* let's try again later from this stream. We add ourselves into
385 * this stream's users so that it can remove us upon termination.
386 */
Willy Tarreau2b718102021-04-21 07:32:39 +0200387 LIST_APPEND(&elt->back_refs, &appctx->ctx.map.bref.users);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100388 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Willy Tarreaudb398432018-11-15 11:08:52 +0100389 si_rx_room_blk(si);
William Lallemandad8be612016-11-18 19:26:17 +0100390 return 0;
391 }
Willy Tarreauc93da692020-10-29 09:41:34 +0100392 skip:
William Lallemandad8be612016-11-18 19:26:17 +0100393 /* get next list entry and check the end of the list */
Emeric Brun8d85aa42017-06-29 15:40:33 +0200394 appctx->ctx.map.bref.ref = elt->list.n;
William Lallemandad8be612016-11-18 19:26:17 +0100395 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100396 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100397 /* fall through */
398
399 default:
400 appctx->st2 = STAT_ST_FIN;
401 return 1;
402 }
403}
404
405static int cli_io_handler_pats_list(struct appctx *appctx)
406{
407 struct stream_interface *si = appctx->owner;
408
409 switch (appctx->st2) {
410 case STAT_ST_INIT:
411 /* Display the column headers. If the message cannot be sent,
Joseph Herlantf43b88b2018-11-25 11:48:18 -0800412 * quit the function with returning 0. The function is called
413 * later and restarted at the state "STAT_ST_INIT".
William Lallemandad8be612016-11-18 19:26:17 +0100414 */
415 chunk_reset(&trash);
416 chunk_appendf(&trash, "# id (file) description\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +0200417 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100418 si_rx_room_blk(si);
William Lallemandad8be612016-11-18 19:26:17 +0100419 return 0;
420 }
421
422 /* Now, we start the browsing of the references lists.
Joseph Herlantf43b88b2018-11-25 11:48:18 -0800423 * Note that the following call to LIST_ELEM returns a bad pointer. The only
William Lallemandad8be612016-11-18 19:26:17 +0100424 * available field of this pointer is <list>. It is used with the function
Joseph Herlantf43b88b2018-11-25 11:48:18 -0800425 * pat_list_get_next() for returning the first available entry
William Lallemandad8be612016-11-18 19:26:17 +0100426 */
427 appctx->ctx.map.ref = LIST_ELEM(&pattern_reference, struct pat_ref *, list);
428 appctx->ctx.map.ref = pat_list_get_next(appctx->ctx.map.ref, &pattern_reference,
429 appctx->ctx.map.display_flags);
430 appctx->st2 = STAT_ST_LIST;
431 /* fall through */
432
433 case STAT_ST_LIST:
434 while (appctx->ctx.map.ref) {
435 chunk_reset(&trash);
436
437 /* Build messages. If the reference is used by another category than
Joseph Herlantf43b88b2018-11-25 11:48:18 -0800438 * the listed categories, display the information in the message.
William Lallemandad8be612016-11-18 19:26:17 +0100439 */
440 chunk_appendf(&trash, "%d (%s) %s\n", appctx->ctx.map.ref->unique_id,
441 appctx->ctx.map.ref->reference ? appctx->ctx.map.ref->reference : "",
442 appctx->ctx.map.ref->display);
443
Willy Tarreau06d80a92017-10-19 14:32:15 +0200444 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100445 /* let's try again later from this stream. We add ourselves into
446 * this stream's users so that it can remove us upon termination.
447 */
Willy Tarreaudb398432018-11-15 11:08:52 +0100448 si_rx_room_blk(si);
William Lallemandad8be612016-11-18 19:26:17 +0100449 return 0;
450 }
451
452 /* get next list entry and check the end of the list */
453 appctx->ctx.map.ref = pat_list_get_next(appctx->ctx.map.ref, &pattern_reference,
454 appctx->ctx.map.display_flags);
455 }
456
William Lallemandad8be612016-11-18 19:26:17 +0100457 /* fall through */
458
459 default:
460 appctx->st2 = STAT_ST_FIN;
461 return 1;
462 }
463 return 0;
464}
465
466static int cli_io_handler_map_lookup(struct appctx *appctx)
467{
468 struct stream_interface *si = appctx->owner;
469 struct sample sample;
470 struct pattern *pat;
471 int match_method;
472
473 switch (appctx->st2) {
474 case STAT_ST_INIT:
475 /* Init to the first entry. The list cannot be change */
476 appctx->ctx.map.expr = LIST_ELEM(&appctx->ctx.map.ref->pat, struct pattern_expr *, list);
477 appctx->ctx.map.expr = pat_expr_get_next(appctx->ctx.map.expr, &appctx->ctx.map.ref->pat);
478 appctx->st2 = STAT_ST_LIST;
479 /* fall through */
480
481 case STAT_ST_LIST:
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100482 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100483 /* for each lookup type */
484 while (appctx->ctx.map.expr) {
485 /* initialise chunk to build new message */
486 chunk_reset(&trash);
487
488 /* execute pattern matching */
489 sample.data.type = SMP_T_STR;
490 sample.flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200491 sample.data.u.str.data = appctx->ctx.map.chunk.data;
492 sample.data.u.str.area = appctx->ctx.map.chunk.area;
Emeric Brunb5997f72017-07-03 11:34:05 +0200493
William Lallemandad8be612016-11-18 19:26:17 +0100494 if (appctx->ctx.map.expr->pat_head->match &&
495 sample_convert(&sample, appctx->ctx.map.expr->pat_head->expect_type))
496 pat = appctx->ctx.map.expr->pat_head->match(&sample, appctx->ctx.map.expr, 1);
497 else
498 pat = NULL;
499
500 /* build return message: set type of match */
501 for (match_method=0; match_method<PAT_MATCH_NUM; match_method++)
502 if (appctx->ctx.map.expr->pat_head->match == pat_match_fcts[match_method])
503 break;
504 if (match_method >= PAT_MATCH_NUM)
505 chunk_appendf(&trash, "type=unknown(%p)", appctx->ctx.map.expr->pat_head->match);
506 else
507 chunk_appendf(&trash, "type=%s", pat_match_names[match_method]);
508
509 /* case sensitive */
510 if (appctx->ctx.map.expr->mflags & PAT_MF_IGNORE_CASE)
511 chunk_appendf(&trash, ", case=insensitive");
512 else
513 chunk_appendf(&trash, ", case=sensitive");
514
515 /* Display no match, and set default value */
516 if (!pat) {
517 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
518 chunk_appendf(&trash, ", found=no");
519 else
520 chunk_appendf(&trash, ", match=no");
521 }
522
523 /* Display match and match info */
524 else {
525 /* display match */
526 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
527 chunk_appendf(&trash, ", found=yes");
528 else
529 chunk_appendf(&trash, ", match=yes");
530
531 /* display index mode */
532 if (pat->sflags & PAT_SF_TREE)
533 chunk_appendf(&trash, ", idx=tree");
534 else
535 chunk_appendf(&trash, ", idx=list");
536
537 /* display pattern */
538 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
539 if (pat->ref && pat->ref->pattern)
540 chunk_appendf(&trash, ", key=\"%s\"", pat->ref->pattern);
541 else
542 chunk_appendf(&trash, ", key=unknown");
543 }
544 else {
545 if (pat->ref && pat->ref->pattern)
546 chunk_appendf(&trash, ", pattern=\"%s\"", pat->ref->pattern);
547 else
548 chunk_appendf(&trash, ", pattern=unknown");
549 }
550
551 /* display return value */
552 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
553 if (pat->data && pat->ref && pat->ref->sample)
554 chunk_appendf(&trash, ", value=\"%s\", type=\"%s\"", pat->ref->sample,
555 smp_to_type[pat->data->type]);
556 else
557 chunk_appendf(&trash, ", value=none");
558 }
559 }
560
561 chunk_appendf(&trash, "\n");
562
563 /* display response */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200564 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100565 /* let's try again later from this stream. We add ourselves into
566 * this stream's users so that it can remove us upon termination.
567 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100568 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Willy Tarreaudb398432018-11-15 11:08:52 +0100569 si_rx_room_blk(si);
William Lallemandad8be612016-11-18 19:26:17 +0100570 return 0;
571 }
572
573 /* get next entry */
574 appctx->ctx.map.expr = pat_expr_get_next(appctx->ctx.map.expr,
575 &appctx->ctx.map.ref->pat);
576 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100577 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100578 /* fall through */
579
580 default:
581 appctx->st2 = STAT_ST_FIN;
William Lallemandad8be612016-11-18 19:26:17 +0100582 return 1;
583 }
584}
585
586static void cli_release_mlook(struct appctx *appctx)
587{
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100588 ha_free(&appctx->ctx.map.chunk.area);
William Lallemandad8be612016-11-18 19:26:17 +0100589}
590
591
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200592static int cli_parse_get_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +0100593{
594 if (strcmp(args[1], "map") == 0 || strcmp(args[1], "acl") == 0) {
595 /* Set flags. */
596 if (args[1][0] == 'm')
597 appctx->ctx.map.display_flags = PAT_REF_MAP;
598 else
599 appctx->ctx.map.display_flags = PAT_REF_ACL;
600
601 /* No parameter. */
602 if (!*args[2] || !*args[3]) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200603 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
604 return cli_err(appctx, "Missing map identifier and/or key.\n");
605 else
606 return cli_err(appctx, "Missing ACL identifier and/or key.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100607 }
608
609 /* lookup into the maps */
610 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
611 if (!appctx->ctx.map.ref) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200612 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
613 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
614 else
615 return cli_err(appctx, "Unknown ACL identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100616 }
617
618 /* copy input string. The string must be allocated because
619 * it may be used over multiple iterations. It's released
620 * at the end and upon abort anyway.
621 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200622 appctx->ctx.map.chunk.data = strlen(args[3]);
623 appctx->ctx.map.chunk.size = appctx->ctx.map.chunk.data + 1;
624 appctx->ctx.map.chunk.area = strdup(args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +0200625 if (!appctx->ctx.map.chunk.area)
626 return cli_err(appctx, "Out of memory error.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100627
628 return 0;
629 }
630 return 1;
631}
632
Emeric Brun8d85aa42017-06-29 15:40:33 +0200633static void cli_release_show_map(struct appctx *appctx)
634{
635 if (appctx->st2 == STAT_ST_LIST) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100636 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200637 if (!LIST_ISEMPTY(&appctx->ctx.map.bref.users))
Willy Tarreau2b718102021-04-21 07:32:39 +0200638 LIST_DELETE(&appctx->ctx.map.bref.users);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100639 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200640 }
641}
642
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200643static int cli_parse_show_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +0100644{
645 if (strcmp(args[1], "map") == 0 ||
646 strcmp(args[1], "acl") == 0) {
647
648 /* Set ACL or MAP flags. */
649 if (args[1][0] == 'm')
650 appctx->ctx.map.display_flags = PAT_REF_MAP;
651 else
652 appctx->ctx.map.display_flags = PAT_REF_ACL;
653
654 /* no parameter: display all map available */
655 if (!*args[2]) {
William Lallemandad8be612016-11-18 19:26:17 +0100656 appctx->io_handler = cli_io_handler_pats_list;
657 return 0;
658 }
659
660 /* lookup into the refs and check the map flag */
661 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
662 if (!appctx->ctx.map.ref ||
663 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200664 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
665 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
666 else
667 return cli_err(appctx, "Unknown ACL identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100668 }
William Lallemandad8be612016-11-18 19:26:17 +0100669 appctx->io_handler = cli_io_handler_pat_list;
Emeric Brun8d85aa42017-06-29 15:40:33 +0200670 appctx->io_release = cli_release_show_map;
William Lallemandad8be612016-11-18 19:26:17 +0100671 return 0;
672 }
673
674 return 0;
675}
676
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200677static int cli_parse_set_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +0100678{
679 if (strcmp(args[1], "map") == 0) {
680 char *err;
681
682 /* Set flags. */
683 appctx->ctx.map.display_flags = PAT_REF_MAP;
684
685 /* Expect three parameters: map name, key and new value. */
Willy Tarreau9d008692019-08-09 11:21:01 +0200686 if (!*args[2] || !*args[3] || !*args[4])
687 return cli_err(appctx, "'set map' expects three parameters: map identifier, key and value.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100688
689 /* Lookup the reference in the maps. */
690 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
Willy Tarreau9d008692019-08-09 11:21:01 +0200691 if (!appctx->ctx.map.ref)
692 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100693
694 /* If the entry identifier start with a '#', it is considered as
695 * pointer id
696 */
697 if (args[3][0] == '#' && args[3][1] == '0' && args[3][2] == 'x') {
698 struct pat_ref_elt *ref;
699 long long int conv;
700 char *error;
701
702 /* Convert argument to integer value. */
703 conv = strtoll(&args[3][1], &error, 16);
Willy Tarreau9d008692019-08-09 11:21:01 +0200704 if (*error != '\0')
705 return cli_err(appctx, "Malformed identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100706
707 /* Convert and check integer to pointer. */
708 ref = (struct pat_ref_elt *)(long)conv;
Willy Tarreau9d008692019-08-09 11:21:01 +0200709 if ((long long int)(long)ref != conv)
710 return cli_err(appctx, "Malformed identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100711
Aurélien Nephtali9a4da682018-04-16 19:02:42 +0200712 /* Try to modify the entry. */
William Lallemandad8be612016-11-18 19:26:17 +0100713 err = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100714 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100715 if (!pat_ref_set_by_id(appctx->ctx.map.ref, ref, args[4], &err)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100716 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Willy Tarreau9d008692019-08-09 11:21:01 +0200717 if (err)
718 return cli_dynerr(appctx, memprintf(&err, "%s.\n", err));
719 else
720 return cli_err(appctx, "Failed to update an entry.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100721 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100722 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100723 }
724 else {
725 /* Else, use the entry identifier as pattern
726 * string, and update the value.
727 */
728 err = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100729 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100730 if (!pat_ref_set(appctx->ctx.map.ref, args[3], args[4], &err)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100731 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Willy Tarreau9d008692019-08-09 11:21:01 +0200732 if (err)
733 return cli_dynerr(appctx, memprintf(&err, "%s.\n", err));
734 else
735 return cli_err(appctx, "Failed to update an entry.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100736 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100737 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100738 }
739
740 /* The set is done, send message. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100741 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100742 return 0;
743 }
744 return 1;
745}
746
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200747static int map_add_key_value(struct appctx *appctx, const char *key, const char *value, char **err)
748{
749 int ret;
750
751 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
752 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
753 ret = pat_ref_add(appctx->ctx.map.ref, key, value, err);
754 else
755 ret = pat_ref_add(appctx->ctx.map.ref, key, NULL, err);
756 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
757
758 return ret;
759}
760
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200761static int cli_parse_add_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +0100762{
763 if (strcmp(args[1], "map") == 0 ||
764 strcmp(args[1], "acl") == 0) {
765 int ret;
766 char *err;
767
768 /* Set flags. */
769 if (args[1][0] == 'm')
770 appctx->ctx.map.display_flags = PAT_REF_MAP;
771 else
772 appctx->ctx.map.display_flags = PAT_REF_ACL;
773
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200774 /* If the keyword is "map", we expect:
775 * - three parameters if there is no payload
776 * - one parameter if there is a payload
777 * If it is "acl", we expect only two parameters
William Lallemandad8be612016-11-18 19:26:17 +0100778 */
779 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200780 if ((!payload && (!*args[2] || !*args[3] || !*args[4])) ||
Willy Tarreau9d008692019-08-09 11:21:01 +0200781 (payload && !*args[2]))
782 return cli_err(appctx,
783 "'add map' expects three parameters (map identifier, key and value)"
784 " or one parameter (map identifier) and a payload\n");
William Lallemandad8be612016-11-18 19:26:17 +0100785 }
Willy Tarreau9d008692019-08-09 11:21:01 +0200786 else if (!*args[2] || !*args[3])
787 return cli_err(appctx, "'add acl' expects two parameters: ACL identifier and pattern.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100788
789 /* Lookup for the reference. */
790 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
791 if (!appctx->ctx.map.ref) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200792 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
793 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
794 else
795 return cli_err(appctx, "Unknown ACL identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100796 }
797
798 /* The command "add acl" is prohibited if the reference
799 * use samples.
800 */
801 if ((appctx->ctx.map.display_flags & PAT_REF_ACL) &&
802 (appctx->ctx.map.ref->flags & PAT_REF_SMP)) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200803 return cli_err(appctx,
804 "This ACL is shared with a map containing samples. "
805 "You must use the command 'add map' to add values.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100806 }
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200807 /* Add value(s). */
William Lallemandad8be612016-11-18 19:26:17 +0100808 err = NULL;
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200809 if (!payload) {
810 ret = map_add_key_value(appctx, args[3], args[4], &err);
811 if (!ret) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200812 if (err)
813 return cli_dynerr(appctx, memprintf(&err, "%s.\n", err));
814 else
815 return cli_err(appctx, "Failed to add an entry.\n");
Aurélien Nephtali9a4da682018-04-16 19:02:42 +0200816 }
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200817 }
818 else {
819 const char *end = payload + strlen(payload);
820
821 while (payload < end) {
822 char *key, *value;
823 size_t l;
824
825 /* key */
826 key = payload;
827 l = strcspn(key, " \t");
828 payload += l;
829
Willy Tarreau9d008692019-08-09 11:21:01 +0200830 if (!*payload && appctx->ctx.map.display_flags == PAT_REF_MAP)
831 return cli_dynerr(appctx, memprintf(&err, "Missing value for key '%s'.\n", key));
832
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200833 key[l] = 0;
834 payload++;
835
836 /* value */
837 payload += strspn(payload, " \t");
838 value = payload;
839 l = strcspn(value, "\n");
840 payload += l;
841 if (*payload)
842 payload++;
843 value[l] = 0;
844
845 ret = map_add_key_value(appctx, key, value, &err);
846 if (!ret) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200847 if (err)
848 return cli_dynerr(appctx, memprintf(&err, "%s.\n", err));
849 else
850 return cli_err(appctx, "Failed to add a key.\n");
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200851 }
Aurélien Nephtali9a4da682018-04-16 19:02:42 +0200852 }
William Lallemandad8be612016-11-18 19:26:17 +0100853 }
854
855 /* The add is done, send message. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100856 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100857 return 1;
858 }
859
860 return 0;
861}
862
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200863static int cli_parse_del_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +0100864{
865 if (args[1][0] == 'm')
866 appctx->ctx.map.display_flags = PAT_REF_MAP;
867 else
868 appctx->ctx.map.display_flags = PAT_REF_ACL;
869
870 /* Expect two parameters: map name and key. */
Willy Tarreau9d008692019-08-09 11:21:01 +0200871 if (!*args[2] || !*args[3]) {
872 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
873 return cli_err(appctx, "This command expects two parameters: map identifier and key.\n");
874 else
875 return cli_err(appctx, "This command expects two parameters: ACL identifier and key.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100876 }
877
878 /* Lookup the reference in the maps. */
879 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
880 if (!appctx->ctx.map.ref ||
Willy Tarreau9d008692019-08-09 11:21:01 +0200881 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags))
882 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100883
884 /* If the entry identifier start with a '#', it is considered as
885 * pointer id
886 */
887 if (args[3][0] == '#' && args[3][1] == '0' && args[3][2] == 'x') {
888 struct pat_ref_elt *ref;
889 long long int conv;
890 char *error;
891
892 /* Convert argument to integer value. */
893 conv = strtoll(&args[3][1], &error, 16);
Willy Tarreau9d008692019-08-09 11:21:01 +0200894 if (*error != '\0')
895 return cli_err(appctx, "Malformed identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100896
897 /* Convert and check integer to pointer. */
898 ref = (struct pat_ref_elt *)(long)conv;
Willy Tarreau9d008692019-08-09 11:21:01 +0200899 if ((long long int)(long)ref != conv)
900 return cli_err(appctx, "Malformed identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100901
902 /* Try to delete the entry. */
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100903 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100904 if (!pat_ref_delete_by_id(appctx->ctx.map.ref, ref)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100905 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100906 /* The entry is not found, send message. */
Willy Tarreau9d008692019-08-09 11:21:01 +0200907 return cli_err(appctx, "Key not found.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100908 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100909 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100910 }
911 else {
912 /* Else, use the entry identifier as pattern
913 * string and try to delete the entry.
914 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100915 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100916 if (!pat_ref_delete(appctx->ctx.map.ref, args[3])) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100917 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100918 /* The entry is not found, send message. */
Willy Tarreau9d008692019-08-09 11:21:01 +0200919 return cli_err(appctx, "Key not found.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100920 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100921 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100922 }
923
924 /* The deletion is done, send message. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100925 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100926 return 1;
927}
928
929
Willy Tarreaud1d005d2019-12-20 18:22:02 +0100930/* continue to clear a map which was started in the parser */
931static int cli_io_handler_clear_map(struct appctx *appctx)
932{
933 struct stream_interface *si = appctx->owner;
934 int finished;
935
936 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
937 finished = pat_ref_prune(appctx->ctx.map.ref);
938 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
939
940 if (!finished) {
941 /* let's come back later */
942 si_rx_endp_more(si);
943 return 0;
944 }
945 return 1;
946}
947
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200948static int cli_parse_clear_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +0100949{
950 if (strcmp(args[1], "map") == 0 || strcmp(args[1], "acl") == 0) {
951 /* Set ACL or MAP flags. */
952 if (args[1][0] == 'm')
953 appctx->ctx.map.display_flags = PAT_REF_MAP;
954 else
955 appctx->ctx.map.display_flags = PAT_REF_ACL;
956
957 /* no parameter */
958 if (!*args[2]) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200959 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
960 return cli_err(appctx, "Missing map identifier.\n");
961 else
962 return cli_err(appctx, "Missing ACL identifier.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100963 }
964
965 /* lookup into the refs and check the map flag */
966 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
967 if (!appctx->ctx.map.ref ||
968 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200969 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
970 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
971 else
972 return cli_err(appctx, "Unknown ACL identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100973 }
974
Willy Tarreaud1d005d2019-12-20 18:22:02 +0100975 /* delegate the clearing to the I/O handler which can yield */
976 return 0;
William Lallemandad8be612016-11-18 19:26:17 +0100977 }
Willy Tarreaud1d005d2019-12-20 18:22:02 +0100978 return 1;
William Lallemandad8be612016-11-18 19:26:17 +0100979}
980
981/* register cli keywords */
982
983static struct cli_kw_list cli_kws = {{ },{
984 { { "add", "acl", NULL }, "add acl : add acl entry", cli_parse_add_map, NULL },
Willy Tarreaud1d005d2019-12-20 18:22:02 +0100985 { { "clear", "acl", NULL }, "clear acl <id> : clear the content of this acl", cli_parse_clear_map, cli_io_handler_clear_map, NULL },
William Lallemandad8be612016-11-18 19:26:17 +0100986 { { "del", "acl", NULL }, "del acl : delete acl entry", cli_parse_del_map, NULL },
987 { { "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 },
988 { { "show", "acl", NULL }, "show acl [id] : report available acls or dump an acl's contents", cli_parse_show_map, NULL },
989 { { "add", "map", NULL }, "add map : add map entry", cli_parse_add_map, NULL },
Willy Tarreaud1d005d2019-12-20 18:22:02 +0100990 { { "clear", "map", NULL }, "clear map <id> : clear the content of this map", cli_parse_clear_map, cli_io_handler_clear_map, NULL },
William Lallemandad8be612016-11-18 19:26:17 +0100991 { { "del", "map", NULL }, "del map : delete map entry", cli_parse_del_map, NULL },
Nenad Merdanovic96c15712017-03-12 22:01:36 +0100992 { { "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 +0100993 { { "set", "map", NULL }, "set map : modify map entry", cli_parse_set_map, NULL },
994 { { "show", "map", NULL }, "show map [id] : report available maps or dump a map's contents", cli_parse_show_map, NULL },
995 { { NULL }, NULL, NULL, NULL }
996}};
997
Willy Tarreau0108d902018-11-25 19:14:37 +0100998INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
William Lallemandad8be612016-11-18 19:26:17 +0100999
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +01001000/* Note: must not be declared <const> as its list will be overwritten
1001 *
1002 * For the map_*_int keywords, the output is declared as SMP_T_UINT, but the converter function
1003 * can provide SMP_T_UINT, SMP_T_SINT or SMP_T_BOOL depending on how the patterns found in the
1004 * file can be parsed.
1005 *
1006 * For the map_*_ip keyword, the output is declared as SMP_T_IPV4, but the converter function
1007 * can provide SMP_T_IPV4 or SMP_T_IPV6 depending on the patterns found in the file.
1008 *
1009 * The map_* keywords only emit strings.
1010 *
1011 * The output type is only used during the configuration parsing. It is used for detecting
1012 * compatibility problems.
1013 *
1014 * The arguments are: <file>[,<default value>]
1015 */
1016static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Thierry FOURNIER1edc9712014-12-15 16:18:39 +01001017 { "map", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_STR },
1018 { "map_str", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_STR },
1019 { "map_beg", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_BEG },
1020 { "map_sub", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_SUB },
1021 { "map_dir", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_DIR },
1022 { "map_dom", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_DOM },
1023 { "map_end", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_END },
1024 { "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 +01001025 { "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 +02001026 { "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 +01001027 { "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 +01001028
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001029 { "map_str_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_STR },
1030 { "map_beg_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_BEG },
1031 { "map_sub_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_SUB },
1032 { "map_dir_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_DIR },
1033 { "map_dom_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_DOM },
1034 { "map_end_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_END },
1035 { "map_reg_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_REG },
1036 { "map_int_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_SINT, SMP_T_SINT, (void *)PAT_MATCH_INT },
1037 { "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 +01001038
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +02001039 { "map_str_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_STR },
1040 { "map_beg_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_BEG },
1041 { "map_sub_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_SUB },
1042 { "map_dir_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_DIR },
1043 { "map_dom_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_DOM },
1044 { "map_end_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_END },
1045 { "map_reg_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_REG },
1046 { "map_int_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_SINT, SMP_T_ADDR, (void *)PAT_MATCH_INT },
1047 { "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 +01001048
1049 { /* END */ },
1050}};
1051
Willy Tarreau0108d902018-11-25 19:14:37 +01001052INITCALL1(STG_REGISTER, sample_register_convs, &sample_conv_kws);