blob: f1b2be90c815467ad312c0d3381c157d970fc324 [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>
Willy Tarreau97218ce2021-04-30 14:57:03 +020014#include <syslog.h>
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010015
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020016#include <haproxy/api.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020017#include <haproxy/applet-t.h>
18#include <haproxy/arg.h>
Willy Tarreau83487a82020-06-04 20:19:54 +020019#include <haproxy/cli.h>
Willy Tarreau2cd58092020-06-04 15:10:43 +020020#include <haproxy/map.h>
Willy Tarreau225a90a2020-06-04 15:06:28 +020021#include <haproxy/pattern.h>
Willy Tarreau7cd8b6e2020-06-02 17:32:26 +020022#include <haproxy/regex.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020023#include <haproxy/sample.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020024#include <haproxy/stats-t.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020025#include <haproxy/stream_interface.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020026#include <haproxy/tools.h>
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010027
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010028
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +020029/* Parse an IPv4 or IPv6 address and store it into the sample.
30 * The output type is IPv4 or IPv6.
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010031 */
Thierry FOURNIER503bb092015-08-19 08:35:43 +020032int map_parse_ip(const char *text, struct sample_data *data)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010033{
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +020034 int len = strlen(text);
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010035
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +020036 if (buf2ip(text, len, &data->u.ipv4)) {
37 data->type = SMP_T_IPV4;
38 return 1;
39 }
40 if (buf2ip6(text, len, &data->u.ipv6)) {
41 data->type = SMP_T_IPV6;
42 return 1;
43 }
44 return 0;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010045}
46
47/* Parse a string and store a pointer to it into the sample. The original
48 * string must be left in memory because we return a direct memory reference.
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +010049 * The output type is SMP_T_STR. There is no risk that the data will be
50 * overwritten because sample_conv_map() makes a const sample with this
51 * output.
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010052 */
Thierry FOURNIER503bb092015-08-19 08:35:43 +020053int map_parse_str(const char *text, struct sample_data *data)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010054{
Willy Tarreau843b7cb2018-07-13 10:54:26 +020055 data->u.str.area = (char *)text;
56 data->u.str.data = strlen(text);
57 data->u.str.size = data->u.str.data + 1;
Thierry FOURNIER503bb092015-08-19 08:35:43 +020058 data->type = SMP_T_STR;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010059 return 1;
60}
61
62/* Parse an integer and convert it to a sample. The output type is SINT if the
63 * number is negative, or UINT if it is positive or null. The function returns
64 * zero (error) if the number is too large.
65 */
Thierry FOURNIER503bb092015-08-19 08:35:43 +020066int map_parse_int(const char *text, struct sample_data *data)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010067{
Thierry FOURNIER503bb092015-08-19 08:35:43 +020068 data->type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +020069 data->u.sint = read_int64(&text, text + strlen(text));
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +020070 if (*text != '\0')
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010071 return 0;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010072 return 1;
73}
74
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010075/* This crete and initialize map descriptor.
76 * Return NULL if out of memory error
77 */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +010078static struct map_descriptor *map_create_descriptor(struct sample_conv *conv)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010079{
80 struct map_descriptor *desc;
81
82 desc = calloc(1, sizeof(*desc));
83 if (!desc)
84 return NULL;
85
86 desc->conv = conv;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010087
88 return desc;
89}
90
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010091/* This function load the map file according with data type declared into
92 * the "struct sample_conv".
93 *
94 * This function choose the indexation type (ebtree or list) according with
95 * the type of match needed.
96 */
Thierry FOURNIER3def3932015-04-07 11:27:54 +020097int sample_load_map(struct arg *arg, struct sample_conv *conv,
98 const char *file, int line, char **err)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +010099{
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100100 struct map_descriptor *desc;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100101
Christopher Faulet0eb967d2020-08-05 23:23:37 +0200102 if (!(global.mode & MODE_STARTING)) {
103 memprintf(err, "map: cannot load map at runtime");
104 return 0;
105 }
106
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100107 /* 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];
Thierry FOURNIER1edc9712014-12-15 16:18:39 +0100124 desc->pat.prune = pat_prune_fcts[(long)conv->private];
125 desc->pat.expect_type = pat_match_types[(long)conv->private];
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100126
127 /* Set the output parse method. */
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100128 switch (desc->conv->out_type) {
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100129 case SMP_T_STR: desc->pat.parse_smp = map_parse_str; break;
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200130 case SMP_T_SINT: desc->pat.parse_smp = map_parse_int; break;
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +0200131 case SMP_T_ADDR: desc->pat.parse_smp = map_parse_ip; break;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100132 default:
133 memprintf(err, "map: internal haproxy error: no default parse case for the input type <%d>.",
134 conv->out_type);
Andreas Seltenreich78f35952016-03-03 20:32:23 +0100135 free(desc);
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100136 return 0;
137 }
138
Thierry FOURNIER39bef452014-01-29 13:29:45 +0100139 /* Load map. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200140 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 +0100141 1, err, file, line))
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100142 return 0;
Thierry FOURNIER0ffe78c2013-12-05 14:40:25 +0100143
Willy Tarreauaa5801b2019-04-19 11:35:22 +0200144 /* the maps of type IP support a string as default value. This
145 * string can be an ipv4 or an ipv6, we must convert it.
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +0200146 */
Willy Tarreauaa5801b2019-04-19 11:35:22 +0200147 if (arg[1].type != ARGT_STOP && desc->conv->out_type == SMP_T_ADDR) {
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +0200148 struct sample_data data;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200149 if (!map_parse_ip(arg[1].data.str.area, &data)) {
150 memprintf(err, "map: cannot parse default ip <%s>.",
151 arg[1].data.str.area);
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +0200152 return 0;
153 }
Christopher Faulet6ad7df42020-08-07 11:45:18 +0200154 chunk_destroy(&arg[1].data.str);
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +0200155 if (data.type == SMP_T_IPV4) {
156 arg[1].type = ARGT_IPV4;
157 arg[1].data.ipv4 = data.u.ipv4;
158 } else {
159 arg[1].type = ARGT_IPV6;
160 arg[1].data.ipv6 = data.u.ipv6;
161 }
162 }
163
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100164 /* replace the first argument by this definition */
Christopher Faulet6ad7df42020-08-07 11:45:18 +0200165 chunk_destroy(&arg[0].data.str);
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100166 arg[0].type = ARGT_MAP;
167 arg[0].data.map = desc;
168
169 return 1;
170}
171
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +0200172static int sample_conv_map(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100173{
174 struct map_descriptor *desc;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100175 struct pattern *pat;
Willy Tarreau83061a82018-07-13 11:56:34 +0200176 struct buffer *str;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100177
178 /* get config */
179 desc = arg_p[0].data.map;
180
181 /* Execute the match function. */
Thierry FOURNIER1e00d382014-02-11 11:31:40 +0100182 pat = pattern_exec_match(&desc->pat, smp, 1);
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100183
184 /* Match case. */
185 if (pat) {
Thierry FOURNIER503bb092015-08-19 08:35:43 +0200186 if (pat->data) {
Thierry Fournier8feaa662016-02-10 22:55:20 +0100187 /* In the regm case, merge the sample with the input. */
188 if ((long)private == PAT_MATCH_REGM) {
Emeric Brun27102212018-07-17 09:47:07 -0400189 struct buffer *tmptrash;
Willy Tarreau2842e052018-08-22 04:55:43 +0200190 int len;
Emeric Brun27102212018-07-17 09:47:07 -0400191
192 /* Copy the content of the sample because it could
193 be scratched by incoming get_trash_chunk */
194 tmptrash = alloc_trash_chunk();
195 if (!tmptrash)
196 return 0;
197
198 tmptrash->data = smp->data.u.str.data;
199 if (tmptrash->data > (tmptrash->size-1))
200 tmptrash->data = tmptrash->size-1;
201
202 memcpy(tmptrash->area, smp->data.u.str.area, tmptrash->data);
203 tmptrash->area[tmptrash->data] = 0;
204
Thierry Fournier8feaa662016-02-10 22:55:20 +0100205 str = get_trash_chunk();
Willy Tarreau2842e052018-08-22 04:55:43 +0200206 len = exp_replace(str->area, str->size,
207 tmptrash->area,
208 pat->data->u.str.area,
209 (regmatch_t *)smp->ctx.a[0]);
Nenad Merdanovic646b7742019-04-12 22:54:28 +0200210 free_trash_chunk(tmptrash);
211
Willy Tarreau2842e052018-08-22 04:55:43 +0200212 if (len == -1)
Thierry Fournier8feaa662016-02-10 22:55:20 +0100213 return 0;
Willy Tarreau2842e052018-08-22 04:55:43 +0200214
215 str->data = len;
Thierry Fournier8feaa662016-02-10 22:55:20 +0100216 smp->data.u.str = *str;
217 return 1;
218 }
219 /* Copy sample. */
Thierry FOURNIER5cc18d42015-08-19 09:02:36 +0200220 smp->data = *pat->data;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100221 smp->flags |= SMP_F_CONST;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100222 return 1;
223 }
224
225 /* Return just int sample containing 1. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200226 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200227 smp->data.u.sint = 1;
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100228 return 1;
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100229 }
230
Joseph Herlantf43b88b2018-11-25 11:48:18 -0800231 /* If no default value available, the converter fails. */
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100232 if (arg_p[1].type == ARGT_STOP)
Thierry FOURNIER1794fdf2014-01-17 15:25:13 +0100233 return 0;
234
235 /* Return the default value. */
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100236 switch (desc->conv->out_type) {
237
238 case SMP_T_STR:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200239 smp->data.type = SMP_T_STR;
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100240 smp->flags |= SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200241 smp->data.u.str = arg_p[1].data.str;
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100242 break;
243
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200244 case SMP_T_SINT:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200245 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200246 smp->data.u.sint = arg_p[1].data.sint;
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100247 break;
248
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +0200249 case SMP_T_ADDR:
250 if (arg_p[1].type == ARGT_IPV4) {
251 smp->data.type = SMP_T_IPV4;
252 smp->data.u.ipv4 = arg_p[1].data.ipv4;
253 } else {
254 smp->data.type = SMP_T_IPV6;
255 smp->data.u.ipv6 = arg_p[1].data.ipv6;
256 }
Thierry FOURNIER933e5de2015-03-13 00:10:16 +0100257 break;
258 }
259
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +0100260 return 1;
261}
262
William Lallemandad8be612016-11-18 19:26:17 +0100263/* This function is used with map and acl management. It permits to browse
264 * each reference. The variable <getnext> must contain the current node,
265 * <end> point to the root node and the <flags> permit to filter required
266 * nodes.
267 */
268static inline
269struct pat_ref *pat_list_get_next(struct pat_ref *getnext, struct list *end,
270 unsigned int flags)
271{
272 struct pat_ref *ref = getnext;
273
274 while (1) {
275
276 /* Get next list entry. */
277 ref = LIST_NEXT(&ref->list, struct pat_ref *, list);
278
279 /* If the entry is the last of the list, return NULL. */
280 if (&ref->list == end)
281 return NULL;
282
283 /* If the entry match the flag, return it. */
284 if (ref->flags & flags)
285 return ref;
286 }
287}
288
289static inline
290struct pat_ref *pat_ref_lookup_ref(const char *reference)
291{
292 int id;
293 char *error;
294
295 /* If the reference starts by a '#', this is numeric id. */
296 if (reference[0] == '#') {
297 /* Try to convert the numeric id. If the conversion fails, the lookup fails. */
298 id = strtol(reference + 1, &error, 10);
299 if (*error != '\0')
300 return NULL;
301
302 /* Perform the unique id lookup. */
303 return pat_ref_lookupid(id);
304 }
305
306 /* Perform the string lookup. */
307 return pat_ref_lookup(reference);
308}
309
310/* This function is used with map and acl management. It permits to browse
311 * each reference.
312 */
313static inline
314struct pattern_expr *pat_expr_get_next(struct pattern_expr *getnext, struct list *end)
315{
316 struct pattern_expr *expr;
317 expr = LIST_NEXT(&getnext->list, struct pattern_expr *, list);
318 if (&expr->list == end)
319 return NULL;
320 return expr;
321}
322
Willy Tarreau95f753e2021-04-30 12:09:54 +0200323/* expects the current generation ID in appctx->cli.cli.i0 */
William Lallemandad8be612016-11-18 19:26:17 +0100324static int cli_io_handler_pat_list(struct appctx *appctx)
325{
326 struct stream_interface *si = appctx->owner;
Emeric Brun8d85aa42017-06-29 15:40:33 +0200327 struct pat_ref_elt *elt;
328
329 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW))) {
330 /* If we're forced to shut down, we might have to remove our
331 * reference to the last ref_elt being dumped.
332 */
333 if (appctx->st2 == STAT_ST_LIST) {
Dragan Dosen336a11f2018-05-04 16:27:15 +0200334 if (!LIST_ISEMPTY(&appctx->ctx.map.bref.users)) {
Willy Tarreau2b718102021-04-21 07:32:39 +0200335 LIST_DELETE(&appctx->ctx.map.bref.users);
Dragan Dosen336a11f2018-05-04 16:27:15 +0200336 LIST_INIT(&appctx->ctx.map.bref.users);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200337 }
338 }
339 return 1;
340 }
William Lallemandad8be612016-11-18 19:26:17 +0100341
342 switch (appctx->st2) {
343
344 case STAT_ST_INIT:
Emeric Brun8d85aa42017-06-29 15:40:33 +0200345 /* the function had not been called yet, let's prepare the
346 * buffer for a response. We initialize the current stream
347 * pointer to the first in the global list. When a target
348 * stream is being destroyed, it is responsible for updating
349 * this pointer. We know we have reached the end when this
350 * pointer points back to the head of the streams list.
351 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100352 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200353 LIST_INIT(&appctx->ctx.map.bref.users);
354 appctx->ctx.map.bref.ref = appctx->ctx.map.ref->head.n;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100355 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100356 appctx->st2 = STAT_ST_LIST;
357 /* fall through */
358
359 case STAT_ST_LIST:
Emeric Brunb5997f72017-07-03 11:34:05 +0200360
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100361 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200362
Emeric Brun8d85aa42017-06-29 15:40:33 +0200363 if (!LIST_ISEMPTY(&appctx->ctx.map.bref.users)) {
Willy Tarreau2b718102021-04-21 07:32:39 +0200364 LIST_DELETE(&appctx->ctx.map.bref.users);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200365 LIST_INIT(&appctx->ctx.map.bref.users);
366 }
367
368 while (appctx->ctx.map.bref.ref != &appctx->ctx.map.ref->head) {
William Lallemandad8be612016-11-18 19:26:17 +0100369 chunk_reset(&trash);
370
Emeric Brun8d85aa42017-06-29 15:40:33 +0200371 elt = LIST_ELEM(appctx->ctx.map.bref.ref, struct pat_ref_elt *, list);
372
Willy Tarreau95f753e2021-04-30 12:09:54 +0200373 if (elt->gen_id != appctx->ctx.cli.i0)
Willy Tarreauc93da692020-10-29 09:41:34 +0100374 goto skip;
375
William Lallemandad8be612016-11-18 19:26:17 +0100376 /* build messages */
Emeric Brun8d85aa42017-06-29 15:40:33 +0200377 if (elt->sample)
William Lallemandad8be612016-11-18 19:26:17 +0100378 chunk_appendf(&trash, "%p %s %s\n",
Emeric Brun8d85aa42017-06-29 15:40:33 +0200379 elt, elt->pattern,
380 elt->sample);
William Lallemandad8be612016-11-18 19:26:17 +0100381 else
382 chunk_appendf(&trash, "%p %s\n",
Emeric Brun8d85aa42017-06-29 15:40:33 +0200383 elt, elt->pattern);
William Lallemandad8be612016-11-18 19:26:17 +0100384
Willy Tarreau06d80a92017-10-19 14:32:15 +0200385 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100386 /* let's try again later from this stream. We add ourselves into
387 * this stream's users so that it can remove us upon termination.
388 */
Willy Tarreau2b718102021-04-21 07:32:39 +0200389 LIST_APPEND(&elt->back_refs, &appctx->ctx.map.bref.users);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100390 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Willy Tarreaudb398432018-11-15 11:08:52 +0100391 si_rx_room_blk(si);
William Lallemandad8be612016-11-18 19:26:17 +0100392 return 0;
393 }
Willy Tarreauc93da692020-10-29 09:41:34 +0100394 skip:
William Lallemandad8be612016-11-18 19:26:17 +0100395 /* get next list entry and check the end of the list */
Emeric Brun8d85aa42017-06-29 15:40:33 +0200396 appctx->ctx.map.bref.ref = elt->list.n;
William Lallemandad8be612016-11-18 19:26:17 +0100397 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100398 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100399 /* fall through */
400
401 default:
402 appctx->st2 = STAT_ST_FIN;
403 return 1;
404 }
405}
406
407static int cli_io_handler_pats_list(struct appctx *appctx)
408{
409 struct stream_interface *si = appctx->owner;
410
411 switch (appctx->st2) {
412 case STAT_ST_INIT:
413 /* Display the column headers. If the message cannot be sent,
Joseph Herlantf43b88b2018-11-25 11:48:18 -0800414 * quit the function with returning 0. The function is called
415 * later and restarted at the state "STAT_ST_INIT".
William Lallemandad8be612016-11-18 19:26:17 +0100416 */
417 chunk_reset(&trash);
418 chunk_appendf(&trash, "# id (file) description\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +0200419 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100420 si_rx_room_blk(si);
William Lallemandad8be612016-11-18 19:26:17 +0100421 return 0;
422 }
423
424 /* Now, we start the browsing of the references lists.
Joseph Herlantf43b88b2018-11-25 11:48:18 -0800425 * Note that the following call to LIST_ELEM returns a bad pointer. The only
William Lallemandad8be612016-11-18 19:26:17 +0100426 * available field of this pointer is <list>. It is used with the function
Joseph Herlantf43b88b2018-11-25 11:48:18 -0800427 * pat_list_get_next() for returning the first available entry
William Lallemandad8be612016-11-18 19:26:17 +0100428 */
429 appctx->ctx.map.ref = LIST_ELEM(&pattern_reference, struct pat_ref *, list);
430 appctx->ctx.map.ref = pat_list_get_next(appctx->ctx.map.ref, &pattern_reference,
431 appctx->ctx.map.display_flags);
432 appctx->st2 = STAT_ST_LIST;
433 /* fall through */
434
435 case STAT_ST_LIST:
436 while (appctx->ctx.map.ref) {
437 chunk_reset(&trash);
438
439 /* Build messages. If the reference is used by another category than
Joseph Herlantf43b88b2018-11-25 11:48:18 -0800440 * the listed categories, display the information in the message.
William Lallemandad8be612016-11-18 19:26:17 +0100441 */
Willy Tarreaue3a42a62021-04-30 10:55:53 +0200442 chunk_appendf(&trash, "%d (%s) %s. curr_ver=%u next_ver=%u\n", appctx->ctx.map.ref->unique_id,
William Lallemandad8be612016-11-18 19:26:17 +0100443 appctx->ctx.map.ref->reference ? appctx->ctx.map.ref->reference : "",
Willy Tarreaue3a42a62021-04-30 10:55:53 +0200444 appctx->ctx.map.ref->display, appctx->ctx.map.ref->curr_gen, appctx->ctx.map.ref->next_gen);
William Lallemandad8be612016-11-18 19:26:17 +0100445
Willy Tarreau06d80a92017-10-19 14:32:15 +0200446 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100447 /* let's try again later from this stream. We add ourselves into
448 * this stream's users so that it can remove us upon termination.
449 */
Willy Tarreaudb398432018-11-15 11:08:52 +0100450 si_rx_room_blk(si);
William Lallemandad8be612016-11-18 19:26:17 +0100451 return 0;
452 }
453
454 /* get next list entry and check the end of the list */
455 appctx->ctx.map.ref = pat_list_get_next(appctx->ctx.map.ref, &pattern_reference,
456 appctx->ctx.map.display_flags);
457 }
458
William Lallemandad8be612016-11-18 19:26:17 +0100459 /* fall through */
460
461 default:
462 appctx->st2 = STAT_ST_FIN;
463 return 1;
464 }
465 return 0;
466}
467
468static int cli_io_handler_map_lookup(struct appctx *appctx)
469{
470 struct stream_interface *si = appctx->owner;
471 struct sample sample;
472 struct pattern *pat;
473 int match_method;
474
475 switch (appctx->st2) {
476 case STAT_ST_INIT:
477 /* Init to the first entry. The list cannot be change */
478 appctx->ctx.map.expr = LIST_ELEM(&appctx->ctx.map.ref->pat, struct pattern_expr *, list);
479 appctx->ctx.map.expr = pat_expr_get_next(appctx->ctx.map.expr, &appctx->ctx.map.ref->pat);
480 appctx->st2 = STAT_ST_LIST;
481 /* fall through */
482
483 case STAT_ST_LIST:
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100484 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100485 /* for each lookup type */
486 while (appctx->ctx.map.expr) {
487 /* initialise chunk to build new message */
488 chunk_reset(&trash);
489
490 /* execute pattern matching */
491 sample.data.type = SMP_T_STR;
492 sample.flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200493 sample.data.u.str.data = appctx->ctx.map.chunk.data;
494 sample.data.u.str.area = appctx->ctx.map.chunk.area;
Emeric Brunb5997f72017-07-03 11:34:05 +0200495
William Lallemandad8be612016-11-18 19:26:17 +0100496 if (appctx->ctx.map.expr->pat_head->match &&
497 sample_convert(&sample, appctx->ctx.map.expr->pat_head->expect_type))
498 pat = appctx->ctx.map.expr->pat_head->match(&sample, appctx->ctx.map.expr, 1);
499 else
500 pat = NULL;
501
502 /* build return message: set type of match */
503 for (match_method=0; match_method<PAT_MATCH_NUM; match_method++)
504 if (appctx->ctx.map.expr->pat_head->match == pat_match_fcts[match_method])
505 break;
506 if (match_method >= PAT_MATCH_NUM)
507 chunk_appendf(&trash, "type=unknown(%p)", appctx->ctx.map.expr->pat_head->match);
508 else
509 chunk_appendf(&trash, "type=%s", pat_match_names[match_method]);
510
511 /* case sensitive */
512 if (appctx->ctx.map.expr->mflags & PAT_MF_IGNORE_CASE)
513 chunk_appendf(&trash, ", case=insensitive");
514 else
515 chunk_appendf(&trash, ", case=sensitive");
516
517 /* Display no match, and set default value */
518 if (!pat) {
519 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
520 chunk_appendf(&trash, ", found=no");
521 else
522 chunk_appendf(&trash, ", match=no");
523 }
524
525 /* Display match and match info */
526 else {
527 /* display match */
528 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
529 chunk_appendf(&trash, ", found=yes");
530 else
531 chunk_appendf(&trash, ", match=yes");
532
533 /* display index mode */
534 if (pat->sflags & PAT_SF_TREE)
535 chunk_appendf(&trash, ", idx=tree");
536 else
537 chunk_appendf(&trash, ", idx=list");
538
539 /* display pattern */
540 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
541 if (pat->ref && pat->ref->pattern)
542 chunk_appendf(&trash, ", key=\"%s\"", pat->ref->pattern);
543 else
544 chunk_appendf(&trash, ", key=unknown");
545 }
546 else {
547 if (pat->ref && pat->ref->pattern)
548 chunk_appendf(&trash, ", pattern=\"%s\"", pat->ref->pattern);
549 else
550 chunk_appendf(&trash, ", pattern=unknown");
551 }
552
553 /* display return value */
554 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
555 if (pat->data && pat->ref && pat->ref->sample)
556 chunk_appendf(&trash, ", value=\"%s\", type=\"%s\"", pat->ref->sample,
557 smp_to_type[pat->data->type]);
558 else
559 chunk_appendf(&trash, ", value=none");
560 }
561 }
562
563 chunk_appendf(&trash, "\n");
564
565 /* display response */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200566 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100567 /* let's try again later from this stream. We add ourselves into
568 * this stream's users so that it can remove us upon termination.
569 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100570 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Willy Tarreaudb398432018-11-15 11:08:52 +0100571 si_rx_room_blk(si);
William Lallemandad8be612016-11-18 19:26:17 +0100572 return 0;
573 }
574
575 /* get next entry */
576 appctx->ctx.map.expr = pat_expr_get_next(appctx->ctx.map.expr,
577 &appctx->ctx.map.ref->pat);
578 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100579 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100580 /* fall through */
581
582 default:
583 appctx->st2 = STAT_ST_FIN;
William Lallemandad8be612016-11-18 19:26:17 +0100584 return 1;
585 }
586}
587
588static void cli_release_mlook(struct appctx *appctx)
589{
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100590 ha_free(&appctx->ctx.map.chunk.area);
William Lallemandad8be612016-11-18 19:26:17 +0100591}
592
593
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200594static int cli_parse_get_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +0100595{
596 if (strcmp(args[1], "map") == 0 || strcmp(args[1], "acl") == 0) {
597 /* Set flags. */
598 if (args[1][0] == 'm')
599 appctx->ctx.map.display_flags = PAT_REF_MAP;
600 else
601 appctx->ctx.map.display_flags = PAT_REF_ACL;
602
603 /* No parameter. */
604 if (!*args[2] || !*args[3]) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200605 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
606 return cli_err(appctx, "Missing map identifier and/or key.\n");
607 else
608 return cli_err(appctx, "Missing ACL identifier and/or key.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100609 }
610
611 /* lookup into the maps */
612 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
613 if (!appctx->ctx.map.ref) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200614 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
615 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
616 else
617 return cli_err(appctx, "Unknown ACL identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100618 }
619
620 /* copy input string. The string must be allocated because
621 * it may be used over multiple iterations. It's released
622 * at the end and upon abort anyway.
623 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200624 appctx->ctx.map.chunk.data = strlen(args[3]);
625 appctx->ctx.map.chunk.size = appctx->ctx.map.chunk.data + 1;
626 appctx->ctx.map.chunk.area = strdup(args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +0200627 if (!appctx->ctx.map.chunk.area)
628 return cli_err(appctx, "Out of memory error.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100629
630 return 0;
631 }
632 return 1;
633}
634
Willy Tarreau97218ce2021-04-30 14:57:03 +0200635static int cli_parse_prepare_map(char **args, char *payload, struct appctx *appctx, void *private)
636{
637 if (strcmp(args[1], "map") == 0 ||
638 strcmp(args[1], "acl") == 0) {
639 uint next_gen;
640 char *msg = NULL;
641
642 /* Set ACL or MAP flags. */
643 if (args[1][0] == 'm')
644 appctx->ctx.map.display_flags = PAT_REF_MAP;
645 else
646 appctx->ctx.map.display_flags = PAT_REF_ACL;
647
648 /* lookup into the refs and check the map flag */
649 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
650 if (!appctx->ctx.map.ref ||
651 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
652 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
653 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
654 else
655 return cli_err(appctx, "Unknown ACL identifier. Please use #<id> or <file>.\n");
656 }
657 next_gen = pat_ref_newgen(appctx->ctx.map.ref);
658 return cli_dynmsg(appctx, LOG_INFO, memprintf(&msg, "New version created: %u\n", next_gen));
659 }
660
661 return 0;
662}
663
Emeric Brun8d85aa42017-06-29 15:40:33 +0200664static void cli_release_show_map(struct appctx *appctx)
665{
666 if (appctx->st2 == STAT_ST_LIST) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100667 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200668 if (!LIST_ISEMPTY(&appctx->ctx.map.bref.users))
Willy Tarreau2b718102021-04-21 07:32:39 +0200669 LIST_DELETE(&appctx->ctx.map.bref.users);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100670 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200671 }
672}
673
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200674static int cli_parse_show_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +0100675{
676 if (strcmp(args[1], "map") == 0 ||
677 strcmp(args[1], "acl") == 0) {
Willy Tarreau95f753e2021-04-30 12:09:54 +0200678 const char *gen = NULL;
William Lallemandad8be612016-11-18 19:26:17 +0100679
680 /* Set ACL or MAP flags. */
681 if (args[1][0] == 'm')
682 appctx->ctx.map.display_flags = PAT_REF_MAP;
683 else
684 appctx->ctx.map.display_flags = PAT_REF_ACL;
685
686 /* no parameter: display all map available */
687 if (!*args[2]) {
William Lallemandad8be612016-11-18 19:26:17 +0100688 appctx->io_handler = cli_io_handler_pats_list;
689 return 0;
690 }
691
Willy Tarreau95f753e2021-04-30 12:09:54 +0200692 /* For both "map" and "acl" we may have an optional generation
693 * number specified using a "@" character before the pattern
694 * file name.
695 */
696 if (*args[2] == '@') {
697 gen = args[2] + 1;
698 args++;
699 }
700
William Lallemandad8be612016-11-18 19:26:17 +0100701 /* lookup into the refs and check the map flag */
702 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
703 if (!appctx->ctx.map.ref ||
704 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200705 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
706 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
707 else
708 return cli_err(appctx, "Unknown ACL identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100709 }
Willy Tarreau95f753e2021-04-30 12:09:54 +0200710
711 /* set the desired generation id in cli.i0 */
712 if (gen)
713 appctx->ctx.cli.i0 = str2uic(gen);
714 else
715 appctx->ctx.cli.i0 = appctx->ctx.map.ref->curr_gen;
716
William Lallemandad8be612016-11-18 19:26:17 +0100717 appctx->io_handler = cli_io_handler_pat_list;
Emeric Brun8d85aa42017-06-29 15:40:33 +0200718 appctx->io_release = cli_release_show_map;
William Lallemandad8be612016-11-18 19:26:17 +0100719 return 0;
720 }
721
722 return 0;
723}
724
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200725static int cli_parse_set_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +0100726{
727 if (strcmp(args[1], "map") == 0) {
728 char *err;
729
730 /* Set flags. */
731 appctx->ctx.map.display_flags = PAT_REF_MAP;
732
733 /* Expect three parameters: map name, key and new value. */
Willy Tarreau9d008692019-08-09 11:21:01 +0200734 if (!*args[2] || !*args[3] || !*args[4])
735 return cli_err(appctx, "'set map' expects three parameters: map identifier, key and value.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100736
737 /* Lookup the reference in the maps. */
738 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
Willy Tarreau9d008692019-08-09 11:21:01 +0200739 if (!appctx->ctx.map.ref)
740 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100741
742 /* If the entry identifier start with a '#', it is considered as
743 * pointer id
744 */
745 if (args[3][0] == '#' && args[3][1] == '0' && args[3][2] == 'x') {
746 struct pat_ref_elt *ref;
747 long long int conv;
748 char *error;
749
750 /* Convert argument to integer value. */
751 conv = strtoll(&args[3][1], &error, 16);
Willy Tarreau9d008692019-08-09 11:21:01 +0200752 if (*error != '\0')
753 return cli_err(appctx, "Malformed identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100754
755 /* Convert and check integer to pointer. */
756 ref = (struct pat_ref_elt *)(long)conv;
Willy Tarreau9d008692019-08-09 11:21:01 +0200757 if ((long long int)(long)ref != conv)
758 return cli_err(appctx, "Malformed identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100759
Aurélien Nephtali9a4da682018-04-16 19:02:42 +0200760 /* Try to modify the entry. */
William Lallemandad8be612016-11-18 19:26:17 +0100761 err = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100762 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100763 if (!pat_ref_set_by_id(appctx->ctx.map.ref, ref, args[4], &err)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100764 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Willy Tarreau9d008692019-08-09 11:21:01 +0200765 if (err)
766 return cli_dynerr(appctx, memprintf(&err, "%s.\n", err));
767 else
768 return cli_err(appctx, "Failed to update an entry.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100769 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100770 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100771 }
772 else {
773 /* Else, use the entry identifier as pattern
774 * string, and update the value.
775 */
776 err = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100777 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100778 if (!pat_ref_set(appctx->ctx.map.ref, args[3], args[4], &err)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100779 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Willy Tarreau9d008692019-08-09 11:21:01 +0200780 if (err)
781 return cli_dynerr(appctx, memprintf(&err, "%s.\n", err));
782 else
783 return cli_err(appctx, "Failed to update an entry.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100784 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100785 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100786 }
787
788 /* The set is done, send message. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100789 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100790 return 0;
791 }
792 return 1;
793}
794
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200795static int cli_parse_add_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +0100796{
797 if (strcmp(args[1], "map") == 0 ||
798 strcmp(args[1], "acl") == 0) {
Willy Tarreaubb51c442021-04-30 15:23:36 +0200799 const char *gen = NULL;
800 uint genid = 0;
William Lallemandad8be612016-11-18 19:26:17 +0100801 int ret;
802 char *err;
803
804 /* Set flags. */
805 if (args[1][0] == 'm')
806 appctx->ctx.map.display_flags = PAT_REF_MAP;
807 else
808 appctx->ctx.map.display_flags = PAT_REF_ACL;
809
Willy Tarreaubb51c442021-04-30 15:23:36 +0200810 /* For both "map" and "acl" we may have an optional generation
811 * number specified using a "@" character before the pattern
812 * file name.
813 */
814 if (*args[2] == '@') {
815 gen = args[2] + 1;
816 args++;
817 }
818
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200819 /* If the keyword is "map", we expect:
820 * - three parameters if there is no payload
821 * - one parameter if there is a payload
822 * If it is "acl", we expect only two parameters
William Lallemandad8be612016-11-18 19:26:17 +0100823 */
824 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200825 if ((!payload && (!*args[2] || !*args[3] || !*args[4])) ||
Willy Tarreau9d008692019-08-09 11:21:01 +0200826 (payload && !*args[2]))
827 return cli_err(appctx,
828 "'add map' expects three parameters (map identifier, key and value)"
829 " or one parameter (map identifier) and a payload\n");
William Lallemandad8be612016-11-18 19:26:17 +0100830 }
Willy Tarreau9d008692019-08-09 11:21:01 +0200831 else if (!*args[2] || !*args[3])
832 return cli_err(appctx, "'add acl' expects two parameters: ACL identifier and pattern.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100833
834 /* Lookup for the reference. */
835 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
836 if (!appctx->ctx.map.ref) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200837 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
838 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
839 else
840 return cli_err(appctx, "Unknown ACL identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100841 }
842
Willy Tarreaubb51c442021-04-30 15:23:36 +0200843 if (gen) {
844 genid = str2uic(gen);
845 if ((int)(genid - appctx->ctx.map.ref->next_gen) > 0) {
846 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
847 return cli_err(appctx, "Version number in the future, please use 'prepare map' before.\n");
848 else
849 return cli_err(appctx, "Version number in the future, please use 'prepare acl' before.\n");
850 }
851 }
852
William Lallemandad8be612016-11-18 19:26:17 +0100853 /* The command "add acl" is prohibited if the reference
854 * use samples.
855 */
856 if ((appctx->ctx.map.display_flags & PAT_REF_ACL) &&
857 (appctx->ctx.map.ref->flags & PAT_REF_SMP)) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200858 return cli_err(appctx,
859 "This ACL is shared with a map containing samples. "
860 "You must use the command 'add map' to add values.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100861 }
Willy Tarreauf7dd0e82021-04-29 16:02:48 +0200862
863 /* Add value(s). If no payload is used, key and value are read
864 * from the command line and only one key is set. If a payload
865 * is passed, one key/value pair is read per line till the end
866 * of the payload is reached.
867 */
William Lallemandad8be612016-11-18 19:26:17 +0100868 err = NULL;
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200869
Willy Tarreauf7dd0e82021-04-29 16:02:48 +0200870 do {
871 char *key = args[3];
872 char *value = args[4];
873 size_t l;
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200874
Willy Tarreauf7dd0e82021-04-29 16:02:48 +0200875 if (payload) {
876 /* key and value passed as payload, one pair per line */
877 if (!*payload)
878 break;
879
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200880 key = payload;
881 l = strcspn(key, " \t");
882 payload += l;
883
Willy Tarreau9d008692019-08-09 11:21:01 +0200884 if (!*payload && appctx->ctx.map.display_flags == PAT_REF_MAP)
885 return cli_dynerr(appctx, memprintf(&err, "Missing value for key '%s'.\n", key));
886
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200887 key[l] = 0;
888 payload++;
889
890 /* value */
891 payload += strspn(payload, " \t");
892 value = payload;
893 l = strcspn(value, "\n");
894 payload += l;
895 if (*payload)
896 payload++;
897 value[l] = 0;
Willy Tarreauf7dd0e82021-04-29 16:02:48 +0200898 }
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200899
Willy Tarreau4053b032021-04-29 16:55:17 +0200900 if (appctx->ctx.map.display_flags != PAT_REF_MAP)
901 value = NULL;
902
903 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Willy Tarreaubb51c442021-04-30 15:23:36 +0200904 ret = !!pat_ref_load(appctx->ctx.map.ref, gen ? genid : appctx->ctx.map.ref->curr_gen, key, value, -1, &err);
Willy Tarreau4053b032021-04-29 16:55:17 +0200905 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
906
Willy Tarreauf7dd0e82021-04-29 16:02:48 +0200907 if (!ret) {
908 if (err)
909 return cli_dynerr(appctx, memprintf(&err, "%s.\n", err));
910 else
911 return cli_err(appctx, "Failed to add a key.\n");
Aurélien Nephtali9a4da682018-04-16 19:02:42 +0200912 }
Willy Tarreauf7dd0e82021-04-29 16:02:48 +0200913 } while (payload && *payload);
William Lallemandad8be612016-11-18 19:26:17 +0100914
915 /* The add is done, send message. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100916 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100917 return 1;
918 }
919
920 return 0;
921}
922
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200923static int cli_parse_del_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +0100924{
925 if (args[1][0] == 'm')
926 appctx->ctx.map.display_flags = PAT_REF_MAP;
927 else
928 appctx->ctx.map.display_flags = PAT_REF_ACL;
929
930 /* Expect two parameters: map name and key. */
Willy Tarreau9d008692019-08-09 11:21:01 +0200931 if (!*args[2] || !*args[3]) {
932 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
933 return cli_err(appctx, "This command expects two parameters: map identifier and key.\n");
934 else
935 return cli_err(appctx, "This command expects two parameters: ACL identifier and key.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100936 }
937
938 /* Lookup the reference in the maps. */
939 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
940 if (!appctx->ctx.map.ref ||
Willy Tarreau9d008692019-08-09 11:21:01 +0200941 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags))
942 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100943
944 /* If the entry identifier start with a '#', it is considered as
945 * pointer id
946 */
947 if (args[3][0] == '#' && args[3][1] == '0' && args[3][2] == 'x') {
948 struct pat_ref_elt *ref;
949 long long int conv;
950 char *error;
951
952 /* Convert argument to integer value. */
953 conv = strtoll(&args[3][1], &error, 16);
Willy Tarreau9d008692019-08-09 11:21:01 +0200954 if (*error != '\0')
955 return cli_err(appctx, "Malformed identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100956
957 /* Convert and check integer to pointer. */
958 ref = (struct pat_ref_elt *)(long)conv;
Willy Tarreau9d008692019-08-09 11:21:01 +0200959 if ((long long int)(long)ref != conv)
960 return cli_err(appctx, "Malformed identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100961
962 /* Try to delete the entry. */
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100963 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100964 if (!pat_ref_delete_by_id(appctx->ctx.map.ref, ref)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100965 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100966 /* The entry is not found, send message. */
Willy Tarreau9d008692019-08-09 11:21:01 +0200967 return cli_err(appctx, "Key not found.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100968 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100969 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100970 }
971 else {
972 /* Else, use the entry identifier as pattern
973 * string and try to delete the entry.
974 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100975 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100976 if (!pat_ref_delete(appctx->ctx.map.ref, args[3])) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100977 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100978 /* The entry is not found, send message. */
Willy Tarreau9d008692019-08-09 11:21:01 +0200979 return cli_err(appctx, "Key not found.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100980 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100981 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100982 }
983
984 /* The deletion is done, send message. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100985 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100986 return 1;
987}
988
Willy Tarreauff3feeb2021-04-30 13:31:43 +0200989/* continue to clear a map which was started in the parser. The range of
990 * generations this applies to is taken from appctx->ctx.cli.i0 for the oldest
991 * and appctx->ctx.cli.i1 for the latest.
992 */
Willy Tarreaud1d005d2019-12-20 18:22:02 +0100993static int cli_io_handler_clear_map(struct appctx *appctx)
994{
995 struct stream_interface *si = appctx->owner;
996 int finished;
997
998 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Willy Tarreauff3feeb2021-04-30 13:31:43 +0200999 finished = pat_ref_purge_range(appctx->ctx.map.ref, appctx->ctx.cli.i0, appctx->ctx.cli.i1, 100);
Willy Tarreaud1d005d2019-12-20 18:22:02 +01001000 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
1001
1002 if (!finished) {
1003 /* let's come back later */
1004 si_rx_endp_more(si);
1005 return 0;
1006 }
1007 return 1;
1008}
1009
Willy Tarreauff3feeb2021-04-30 13:31:43 +02001010/* note: sets appctx->ctx.cli.i0 and appctx->ctx.cli.i1 to the oldest and
1011 * latest generations to clear, respectively, and will call the clear_map
1012 * handler.
1013 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001014static int cli_parse_clear_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +01001015{
1016 if (strcmp(args[1], "map") == 0 || strcmp(args[1], "acl") == 0) {
Willy Tarreauff3feeb2021-04-30 13:31:43 +02001017 const char *gen = NULL;
1018
William Lallemandad8be612016-11-18 19:26:17 +01001019 /* Set ACL or MAP flags. */
1020 if (args[1][0] == 'm')
1021 appctx->ctx.map.display_flags = PAT_REF_MAP;
1022 else
1023 appctx->ctx.map.display_flags = PAT_REF_ACL;
1024
Willy Tarreauff3feeb2021-04-30 13:31:43 +02001025 /* For both "map" and "acl" we may have an optional generation
1026 * number specified using a "@" character before the pattern
1027 * file name.
1028 */
1029 if (*args[2] == '@') {
1030 gen = args[2] + 1;
1031 args++;
1032 }
1033
William Lallemandad8be612016-11-18 19:26:17 +01001034 /* no parameter */
1035 if (!*args[2]) {
Willy Tarreau9d008692019-08-09 11:21:01 +02001036 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
1037 return cli_err(appctx, "Missing map identifier.\n");
1038 else
1039 return cli_err(appctx, "Missing ACL identifier.\n");
William Lallemandad8be612016-11-18 19:26:17 +01001040 }
1041
1042 /* lookup into the refs and check the map flag */
1043 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
1044 if (!appctx->ctx.map.ref ||
1045 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02001046 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
1047 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
1048 else
1049 return cli_err(appctx, "Unknown ACL identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +01001050 }
1051
Willy Tarreauff3feeb2021-04-30 13:31:43 +02001052 /* set the desired generation id in cli.i0/i1 */
1053 if (gen)
1054 appctx->ctx.cli.i1 = appctx->ctx.cli.i0 = str2uic(gen);
1055 else
1056 appctx->ctx.cli.i1 = appctx->ctx.cli.i0 = appctx->ctx.map.ref->curr_gen;
1057
Willy Tarreaud1d005d2019-12-20 18:22:02 +01001058 /* delegate the clearing to the I/O handler which can yield */
1059 return 0;
William Lallemandad8be612016-11-18 19:26:17 +01001060 }
Willy Tarreaud1d005d2019-12-20 18:22:02 +01001061 return 1;
William Lallemandad8be612016-11-18 19:26:17 +01001062}
1063
Willy Tarreau7a562ca2021-04-30 15:10:01 +02001064/* note: sets appctx->ctx.cli.i0 and appctx->ctx.cli.i1 to the oldest and
1065 * latest generations to clear, respectively, and will call the clear_map
1066 * handler.
1067 */
1068static int cli_parse_commit_map(char **args, char *payload, struct appctx *appctx, void *private)
1069{
1070 if (strcmp(args[1], "map") == 0 || strcmp(args[1], "acl") == 0) {
1071 const char *gen = NULL;
1072 uint genid;
1073 uint ret;
1074
1075 /* Set ACL or MAP flags. */
1076 if (args[1][0] == 'm')
1077 appctx->ctx.map.display_flags = PAT_REF_MAP;
1078 else
1079 appctx->ctx.map.display_flags = PAT_REF_ACL;
1080
1081 if (*args[2] != '@')
1082 return cli_err(appctx, "Missing version number.\n");
1083
1084 /* The generation number is mandatory for a commit. The range
1085 * of generations that get trashed by a commit starts from the
1086 * opposite of the current one and ends at the previous one.
1087 */
1088 gen = args[2] + 1;
1089 genid = str2uic(gen);
1090 appctx->ctx.cli.i1 = genid - 1;
1091 appctx->ctx.cli.i0 = appctx->ctx.cli.i1 - ((~0U) >> 1);
1092
1093 /* no parameter */
1094 if (!*args[3]) {
1095 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
1096 return cli_err(appctx, "Missing map identifier.\n");
1097 else
1098 return cli_err(appctx, "Missing ACL identifier.\n");
1099 }
1100
1101 /* lookup into the refs and check the map flag */
1102 appctx->ctx.map.ref = pat_ref_lookup_ref(args[3]);
1103 if (!appctx->ctx.map.ref ||
1104 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
1105 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
1106 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
1107 else
1108 return cli_err(appctx, "Unknown ACL identifier. Please use #<id> or <file>.\n");
1109 }
1110
1111 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
1112 if (genid - (appctx->ctx.map.ref->curr_gen + 1) <
1113 appctx->ctx.map.ref->next_gen - appctx->ctx.map.ref->curr_gen)
1114 ret = pat_ref_commit(appctx->ctx.map.ref, genid);
1115 else
1116 ret = 1;
1117 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
1118
1119 if (ret != 0)
1120 return cli_err(appctx, "Version number out of range.\n");
1121
1122 /* delegate the clearing to the I/O handler which can yield */
1123 return 0;
1124 }
1125 return 1;
1126}
1127
William Lallemandad8be612016-11-18 19:26:17 +01001128/* register cli keywords */
1129
1130static struct cli_kw_list cli_kws = {{ },{
Willy Tarreaub205bfd2021-05-07 11:38:37 +02001131 { { "add", "acl", NULL }, "add acl [@<ver>] <acl> <pattern> : add an acl entry", cli_parse_add_map, NULL },
1132 { { "clear", "acl", NULL }, "clear acl [@<ver>] <acl> : clear the contents of this acl", cli_parse_clear_map, cli_io_handler_clear_map, NULL },
1133 { { "commit","acl", NULL }, "commit acl @<ver> <acl> : commit the ACL at this version", cli_parse_commit_map, cli_io_handler_clear_map, NULL },
1134 { { "del", "acl", NULL }, "del acl <acl> [<key>|#<ref>] : delete acl entries matching <key>", cli_parse_del_map, NULL },
1135 { { "get", "acl", NULL }, "get acl <acl> <value> : report the patterns matching a sample for an ACL", cli_parse_get_map, cli_io_handler_map_lookup, cli_release_mlook },
1136 { { "prepare","acl",NULL }, "prepare acl <acl> : prepare a new version for atomic ACL replacement", cli_parse_prepare_map, NULL },
1137 { { "show", "acl", NULL }, "show acl [@<ver>] <acl>] : report available acls or dump an acl's contents", cli_parse_show_map, NULL },
1138 { { "add", "map", NULL }, "add map [@<ver>] <map> <key> <val> : add a map entry (payload supported instead of key/val)", cli_parse_add_map, NULL },
1139 { { "clear", "map", NULL }, "clear map [@<ver>] <map> : clear the contents of this map", cli_parse_clear_map, cli_io_handler_clear_map, NULL },
1140 { { "commit","map", NULL }, "commit map @<ver> <map> : commit the map at this version", cli_parse_commit_map, cli_io_handler_clear_map, NULL },
1141 { { "del", "map", NULL }, "del map <map> [<key>|#<ref>] : delete map entries matching <key>", cli_parse_del_map, NULL },
1142 { { "get", "map", NULL }, "get map <acl> <value> : report the keys and values matching a sample for a map", cli_parse_get_map, cli_io_handler_map_lookup, cli_release_mlook },
1143 { { "prepare","map",NULL }, "prepare map <acl> : prepare a new version for atomic map replacement", cli_parse_prepare_map, NULL },
1144 { { "set", "map", NULL }, "set map <map> [<key>|#<ref>] <value> : modify a map entry", cli_parse_set_map, NULL },
1145 { { "show", "map", NULL }, "show map [@ver] [map] : report available maps or dump a map's contents", cli_parse_show_map, NULL },
William Lallemandad8be612016-11-18 19:26:17 +01001146 { { NULL }, NULL, NULL, NULL }
1147}};
1148
Willy Tarreau0108d902018-11-25 19:14:37 +01001149INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
William Lallemandad8be612016-11-18 19:26:17 +01001150
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +01001151/* Note: must not be declared <const> as its list will be overwritten
1152 *
1153 * For the map_*_int keywords, the output is declared as SMP_T_UINT, but the converter function
1154 * can provide SMP_T_UINT, SMP_T_SINT or SMP_T_BOOL depending on how the patterns found in the
1155 * file can be parsed.
1156 *
1157 * For the map_*_ip keyword, the output is declared as SMP_T_IPV4, but the converter function
1158 * can provide SMP_T_IPV4 or SMP_T_IPV6 depending on the patterns found in the file.
1159 *
1160 * The map_* keywords only emit strings.
1161 *
1162 * The output type is only used during the configuration parsing. It is used for detecting
1163 * compatibility problems.
1164 *
1165 * The arguments are: <file>[,<default value>]
1166 */
1167static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Thierry FOURNIER1edc9712014-12-15 16:18:39 +01001168 { "map", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_STR },
1169 { "map_str", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_STR },
1170 { "map_beg", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_BEG },
1171 { "map_sub", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_SUB },
1172 { "map_dir", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_DIR },
1173 { "map_dom", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_DOM },
1174 { "map_end", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_END },
1175 { "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 +01001176 { "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 +02001177 { "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 +01001178 { "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 +01001179
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001180 { "map_str_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_STR },
1181 { "map_beg_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_BEG },
1182 { "map_sub_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_SUB },
1183 { "map_dir_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_DIR },
1184 { "map_dom_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_DOM },
1185 { "map_end_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_END },
1186 { "map_reg_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_REG },
1187 { "map_int_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_SINT, SMP_T_SINT, (void *)PAT_MATCH_INT },
1188 { "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 +01001189
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +02001190 { "map_str_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_STR },
1191 { "map_beg_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_BEG },
1192 { "map_sub_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_SUB },
1193 { "map_dir_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_DIR },
1194 { "map_dom_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_DOM },
1195 { "map_end_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_END },
1196 { "map_reg_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_REG },
1197 { "map_int_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_SINT, SMP_T_ADDR, (void *)PAT_MATCH_INT },
1198 { "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 +01001199
1200 { /* END */ },
1201}};
1202
Willy Tarreau0108d902018-11-25 19:14:37 +01001203INITCALL1(STG_REGISTER, sample_register_convs, &sample_conv_kws);