blob: f482b77ba410f288491e99437e9cac2af21718c3 [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) {
Willy Tarreauf1c627d2022-05-03 15:19:49 +0200334 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Dragan Dosen336a11f2018-05-04 16:27:15 +0200335 if (!LIST_ISEMPTY(&appctx->ctx.map.bref.users)) {
Willy Tarreau2b718102021-04-21 07:32:39 +0200336 LIST_DELETE(&appctx->ctx.map.bref.users);
Dragan Dosen336a11f2018-05-04 16:27:15 +0200337 LIST_INIT(&appctx->ctx.map.bref.users);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200338 }
Willy Tarreauf1c627d2022-05-03 15:19:49 +0200339 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200340 }
341 return 1;
342 }
William Lallemandad8be612016-11-18 19:26:17 +0100343
344 switch (appctx->st2) {
345
346 case STAT_ST_INIT:
William Lallemandad8be612016-11-18 19:26:17 +0100347 appctx->st2 = STAT_ST_LIST;
348 /* fall through */
349
350 case STAT_ST_LIST:
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100351 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Emeric Brunb5997f72017-07-03 11:34:05 +0200352
Emeric Brun8d85aa42017-06-29 15:40:33 +0200353 if (!LIST_ISEMPTY(&appctx->ctx.map.bref.users)) {
Willy Tarreau2b718102021-04-21 07:32:39 +0200354 LIST_DELETE(&appctx->ctx.map.bref.users);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200355 LIST_INIT(&appctx->ctx.map.bref.users);
Willy Tarreaub3604402022-05-03 15:26:27 +0200356 } else {
357 appctx->ctx.map.bref.ref = appctx->ctx.map.ref->head.n;
Emeric Brun8d85aa42017-06-29 15:40:33 +0200358 }
359
360 while (appctx->ctx.map.bref.ref != &appctx->ctx.map.ref->head) {
William Lallemandad8be612016-11-18 19:26:17 +0100361 chunk_reset(&trash);
362
Emeric Brun8d85aa42017-06-29 15:40:33 +0200363 elt = LIST_ELEM(appctx->ctx.map.bref.ref, struct pat_ref_elt *, list);
364
Willy Tarreau95f753e2021-04-30 12:09:54 +0200365 if (elt->gen_id != appctx->ctx.cli.i0)
Willy Tarreauc93da692020-10-29 09:41:34 +0100366 goto skip;
367
William Lallemandad8be612016-11-18 19:26:17 +0100368 /* build messages */
Emeric Brun8d85aa42017-06-29 15:40:33 +0200369 if (elt->sample)
William Lallemandad8be612016-11-18 19:26:17 +0100370 chunk_appendf(&trash, "%p %s %s\n",
Emeric Brun8d85aa42017-06-29 15:40:33 +0200371 elt, elt->pattern,
372 elt->sample);
William Lallemandad8be612016-11-18 19:26:17 +0100373 else
374 chunk_appendf(&trash, "%p %s\n",
Emeric Brun8d85aa42017-06-29 15:40:33 +0200375 elt, elt->pattern);
William Lallemandad8be612016-11-18 19:26:17 +0100376
Willy Tarreau06d80a92017-10-19 14:32:15 +0200377 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100378 /* let's try again later from this stream. We add ourselves into
379 * this stream's users so that it can remove us upon termination.
380 */
Willy Tarreau2b718102021-04-21 07:32:39 +0200381 LIST_APPEND(&elt->back_refs, &appctx->ctx.map.bref.users);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100382 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Willy Tarreaudb398432018-11-15 11:08:52 +0100383 si_rx_room_blk(si);
William Lallemandad8be612016-11-18 19:26:17 +0100384 return 0;
385 }
Willy Tarreauc93da692020-10-29 09:41:34 +0100386 skip:
William Lallemandad8be612016-11-18 19:26:17 +0100387 /* get next list entry and check the end of the list */
Emeric Brun8d85aa42017-06-29 15:40:33 +0200388 appctx->ctx.map.bref.ref = elt->list.n;
William Lallemandad8be612016-11-18 19:26:17 +0100389 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100390 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100391 /* fall through */
392
393 default:
394 appctx->st2 = STAT_ST_FIN;
395 return 1;
396 }
397}
398
399static int cli_io_handler_pats_list(struct appctx *appctx)
400{
401 struct stream_interface *si = appctx->owner;
402
403 switch (appctx->st2) {
404 case STAT_ST_INIT:
405 /* Display the column headers. If the message cannot be sent,
Joseph Herlantf43b88b2018-11-25 11:48:18 -0800406 * quit the function with returning 0. The function is called
407 * later and restarted at the state "STAT_ST_INIT".
William Lallemandad8be612016-11-18 19:26:17 +0100408 */
409 chunk_reset(&trash);
410 chunk_appendf(&trash, "# id (file) description\n");
Willy Tarreau06d80a92017-10-19 14:32:15 +0200411 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +0100412 si_rx_room_blk(si);
William Lallemandad8be612016-11-18 19:26:17 +0100413 return 0;
414 }
415
416 /* Now, we start the browsing of the references lists.
Joseph Herlantf43b88b2018-11-25 11:48:18 -0800417 * Note that the following call to LIST_ELEM returns a bad pointer. The only
William Lallemandad8be612016-11-18 19:26:17 +0100418 * available field of this pointer is <list>. It is used with the function
Joseph Herlantf43b88b2018-11-25 11:48:18 -0800419 * pat_list_get_next() for returning the first available entry
William Lallemandad8be612016-11-18 19:26:17 +0100420 */
421 appctx->ctx.map.ref = LIST_ELEM(&pattern_reference, struct pat_ref *, list);
422 appctx->ctx.map.ref = pat_list_get_next(appctx->ctx.map.ref, &pattern_reference,
423 appctx->ctx.map.display_flags);
424 appctx->st2 = STAT_ST_LIST;
425 /* fall through */
426
427 case STAT_ST_LIST:
428 while (appctx->ctx.map.ref) {
429 chunk_reset(&trash);
430
431 /* Build messages. If the reference is used by another category than
Joseph Herlantf43b88b2018-11-25 11:48:18 -0800432 * the listed categories, display the information in the message.
William Lallemandad8be612016-11-18 19:26:17 +0100433 */
Willy Tarreaue3a42a62021-04-30 10:55:53 +0200434 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 +0100435 appctx->ctx.map.ref->reference ? appctx->ctx.map.ref->reference : "",
Willy Tarreaue3a42a62021-04-30 10:55:53 +0200436 appctx->ctx.map.ref->display, appctx->ctx.map.ref->curr_gen, appctx->ctx.map.ref->next_gen);
William Lallemandad8be612016-11-18 19:26:17 +0100437
Willy Tarreau06d80a92017-10-19 14:32:15 +0200438 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100439 /* let's try again later from this stream. We add ourselves into
440 * this stream's users so that it can remove us upon termination.
441 */
Willy Tarreaudb398432018-11-15 11:08:52 +0100442 si_rx_room_blk(si);
William Lallemandad8be612016-11-18 19:26:17 +0100443 return 0;
444 }
445
446 /* get next list entry and check the end of the list */
447 appctx->ctx.map.ref = pat_list_get_next(appctx->ctx.map.ref, &pattern_reference,
448 appctx->ctx.map.display_flags);
449 }
450
William Lallemandad8be612016-11-18 19:26:17 +0100451 /* fall through */
452
453 default:
454 appctx->st2 = STAT_ST_FIN;
455 return 1;
456 }
457 return 0;
458}
459
460static int cli_io_handler_map_lookup(struct appctx *appctx)
461{
462 struct stream_interface *si = appctx->owner;
463 struct sample sample;
464 struct pattern *pat;
465 int match_method;
466
467 switch (appctx->st2) {
468 case STAT_ST_INIT:
469 /* Init to the first entry. The list cannot be change */
470 appctx->ctx.map.expr = LIST_ELEM(&appctx->ctx.map.ref->pat, struct pattern_expr *, list);
471 appctx->ctx.map.expr = pat_expr_get_next(appctx->ctx.map.expr, &appctx->ctx.map.ref->pat);
472 appctx->st2 = STAT_ST_LIST;
473 /* fall through */
474
475 case STAT_ST_LIST:
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100476 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100477 /* for each lookup type */
478 while (appctx->ctx.map.expr) {
479 /* initialise chunk to build new message */
480 chunk_reset(&trash);
481
482 /* execute pattern matching */
483 sample.data.type = SMP_T_STR;
484 sample.flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200485 sample.data.u.str.data = appctx->ctx.map.chunk.data;
486 sample.data.u.str.area = appctx->ctx.map.chunk.area;
Emeric Brunb5997f72017-07-03 11:34:05 +0200487
William Lallemandad8be612016-11-18 19:26:17 +0100488 if (appctx->ctx.map.expr->pat_head->match &&
489 sample_convert(&sample, appctx->ctx.map.expr->pat_head->expect_type))
490 pat = appctx->ctx.map.expr->pat_head->match(&sample, appctx->ctx.map.expr, 1);
491 else
492 pat = NULL;
493
494 /* build return message: set type of match */
495 for (match_method=0; match_method<PAT_MATCH_NUM; match_method++)
496 if (appctx->ctx.map.expr->pat_head->match == pat_match_fcts[match_method])
497 break;
498 if (match_method >= PAT_MATCH_NUM)
499 chunk_appendf(&trash, "type=unknown(%p)", appctx->ctx.map.expr->pat_head->match);
500 else
501 chunk_appendf(&trash, "type=%s", pat_match_names[match_method]);
502
503 /* case sensitive */
504 if (appctx->ctx.map.expr->mflags & PAT_MF_IGNORE_CASE)
505 chunk_appendf(&trash, ", case=insensitive");
506 else
507 chunk_appendf(&trash, ", case=sensitive");
508
509 /* Display no match, and set default value */
510 if (!pat) {
511 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
512 chunk_appendf(&trash, ", found=no");
513 else
514 chunk_appendf(&trash, ", match=no");
515 }
516
517 /* Display match and match info */
518 else {
519 /* display match */
520 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
521 chunk_appendf(&trash, ", found=yes");
522 else
523 chunk_appendf(&trash, ", match=yes");
524
525 /* display index mode */
526 if (pat->sflags & PAT_SF_TREE)
527 chunk_appendf(&trash, ", idx=tree");
528 else
529 chunk_appendf(&trash, ", idx=list");
530
531 /* display pattern */
532 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
533 if (pat->ref && pat->ref->pattern)
534 chunk_appendf(&trash, ", key=\"%s\"", pat->ref->pattern);
535 else
536 chunk_appendf(&trash, ", key=unknown");
537 }
538 else {
539 if (pat->ref && pat->ref->pattern)
540 chunk_appendf(&trash, ", pattern=\"%s\"", pat->ref->pattern);
541 else
542 chunk_appendf(&trash, ", pattern=unknown");
543 }
544
545 /* display return value */
546 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
547 if (pat->data && pat->ref && pat->ref->sample)
548 chunk_appendf(&trash, ", value=\"%s\", type=\"%s\"", pat->ref->sample,
549 smp_to_type[pat->data->type]);
550 else
551 chunk_appendf(&trash, ", value=none");
552 }
553 }
554
555 chunk_appendf(&trash, "\n");
556
557 /* display response */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200558 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemandad8be612016-11-18 19:26:17 +0100559 /* let's try again later from this stream. We add ourselves into
560 * this stream's users so that it can remove us upon termination.
561 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100562 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Willy Tarreaudb398432018-11-15 11:08:52 +0100563 si_rx_room_blk(si);
William Lallemandad8be612016-11-18 19:26:17 +0100564 return 0;
565 }
566
567 /* get next entry */
568 appctx->ctx.map.expr = pat_expr_get_next(appctx->ctx.map.expr,
569 &appctx->ctx.map.ref->pat);
570 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100571 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100572 /* fall through */
573
574 default:
575 appctx->st2 = STAT_ST_FIN;
William Lallemandad8be612016-11-18 19:26:17 +0100576 return 1;
577 }
578}
579
580static void cli_release_mlook(struct appctx *appctx)
581{
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100582 ha_free(&appctx->ctx.map.chunk.area);
William Lallemandad8be612016-11-18 19:26:17 +0100583}
584
585
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200586static int cli_parse_get_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +0100587{
588 if (strcmp(args[1], "map") == 0 || strcmp(args[1], "acl") == 0) {
589 /* Set flags. */
590 if (args[1][0] == 'm')
591 appctx->ctx.map.display_flags = PAT_REF_MAP;
592 else
593 appctx->ctx.map.display_flags = PAT_REF_ACL;
594
595 /* No parameter. */
596 if (!*args[2] || !*args[3]) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200597 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
598 return cli_err(appctx, "Missing map identifier and/or key.\n");
599 else
600 return cli_err(appctx, "Missing ACL identifier and/or key.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100601 }
602
603 /* lookup into the maps */
604 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
605 if (!appctx->ctx.map.ref) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200606 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
607 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
608 else
609 return cli_err(appctx, "Unknown ACL identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100610 }
611
612 /* copy input string. The string must be allocated because
613 * it may be used over multiple iterations. It's released
614 * at the end and upon abort anyway.
615 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200616 appctx->ctx.map.chunk.data = strlen(args[3]);
617 appctx->ctx.map.chunk.size = appctx->ctx.map.chunk.data + 1;
618 appctx->ctx.map.chunk.area = strdup(args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +0200619 if (!appctx->ctx.map.chunk.area)
620 return cli_err(appctx, "Out of memory error.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100621
622 return 0;
623 }
624 return 1;
625}
626
Willy Tarreau97218ce2021-04-30 14:57:03 +0200627static int cli_parse_prepare_map(char **args, char *payload, struct appctx *appctx, void *private)
628{
629 if (strcmp(args[1], "map") == 0 ||
630 strcmp(args[1], "acl") == 0) {
631 uint next_gen;
632 char *msg = NULL;
633
634 /* Set ACL or MAP flags. */
635 if (args[1][0] == 'm')
636 appctx->ctx.map.display_flags = PAT_REF_MAP;
637 else
638 appctx->ctx.map.display_flags = PAT_REF_ACL;
639
640 /* lookup into the refs and check the map flag */
641 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
642 if (!appctx->ctx.map.ref ||
643 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
644 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
645 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
646 else
647 return cli_err(appctx, "Unknown ACL identifier. Please use #<id> or <file>.\n");
648 }
649 next_gen = pat_ref_newgen(appctx->ctx.map.ref);
650 return cli_dynmsg(appctx, LOG_INFO, memprintf(&msg, "New version created: %u\n", next_gen));
651 }
652
653 return 0;
654}
655
Emeric Brun8d85aa42017-06-29 15:40:33 +0200656static void cli_release_show_map(struct appctx *appctx)
657{
658 if (appctx->st2 == STAT_ST_LIST) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100659 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200660 if (!LIST_ISEMPTY(&appctx->ctx.map.bref.users))
Willy Tarreau2b718102021-04-21 07:32:39 +0200661 LIST_DELETE(&appctx->ctx.map.bref.users);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100662 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Emeric Brun8d85aa42017-06-29 15:40:33 +0200663 }
664}
665
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200666static int cli_parse_show_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +0100667{
668 if (strcmp(args[1], "map") == 0 ||
669 strcmp(args[1], "acl") == 0) {
Willy Tarreau95f753e2021-04-30 12:09:54 +0200670 const char *gen = NULL;
William Lallemandad8be612016-11-18 19:26:17 +0100671
672 /* Set ACL or MAP flags. */
673 if (args[1][0] == 'm')
674 appctx->ctx.map.display_flags = PAT_REF_MAP;
675 else
676 appctx->ctx.map.display_flags = PAT_REF_ACL;
677
678 /* no parameter: display all map available */
679 if (!*args[2]) {
William Lallemandad8be612016-11-18 19:26:17 +0100680 appctx->io_handler = cli_io_handler_pats_list;
681 return 0;
682 }
683
Willy Tarreau95f753e2021-04-30 12:09:54 +0200684 /* For both "map" and "acl" we may have an optional generation
685 * number specified using a "@" character before the pattern
686 * file name.
687 */
688 if (*args[2] == '@') {
689 gen = args[2] + 1;
690 args++;
691 }
692
William Lallemandad8be612016-11-18 19:26:17 +0100693 /* lookup into the refs and check the map flag */
694 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
695 if (!appctx->ctx.map.ref ||
696 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200697 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
698 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
699 else
700 return cli_err(appctx, "Unknown ACL identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100701 }
Willy Tarreau95f753e2021-04-30 12:09:54 +0200702
703 /* set the desired generation id in cli.i0 */
704 if (gen)
705 appctx->ctx.cli.i0 = str2uic(gen);
706 else
707 appctx->ctx.cli.i0 = appctx->ctx.map.ref->curr_gen;
708
Willy Tarreaub3604402022-05-03 15:26:27 +0200709 LIST_INIT(&appctx->ctx.map.bref.users);
William Lallemandad8be612016-11-18 19:26:17 +0100710 appctx->io_handler = cli_io_handler_pat_list;
Emeric Brun8d85aa42017-06-29 15:40:33 +0200711 appctx->io_release = cli_release_show_map;
William Lallemandad8be612016-11-18 19:26:17 +0100712 return 0;
713 }
714
715 return 0;
716}
717
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200718static int cli_parse_set_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +0100719{
720 if (strcmp(args[1], "map") == 0) {
721 char *err;
722
723 /* Set flags. */
724 appctx->ctx.map.display_flags = PAT_REF_MAP;
725
726 /* Expect three parameters: map name, key and new value. */
Willy Tarreau9d008692019-08-09 11:21:01 +0200727 if (!*args[2] || !*args[3] || !*args[4])
728 return cli_err(appctx, "'set map' expects three parameters: map identifier, key and value.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100729
730 /* Lookup the reference in the maps. */
731 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
Willy Tarreau9d008692019-08-09 11:21:01 +0200732 if (!appctx->ctx.map.ref)
733 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100734
735 /* If the entry identifier start with a '#', it is considered as
736 * pointer id
737 */
738 if (args[3][0] == '#' && args[3][1] == '0' && args[3][2] == 'x') {
739 struct pat_ref_elt *ref;
740 long long int conv;
741 char *error;
742
743 /* Convert argument to integer value. */
744 conv = strtoll(&args[3][1], &error, 16);
Willy Tarreau9d008692019-08-09 11:21:01 +0200745 if (*error != '\0')
746 return cli_err(appctx, "Malformed identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100747
748 /* Convert and check integer to pointer. */
749 ref = (struct pat_ref_elt *)(long)conv;
Willy Tarreau9d008692019-08-09 11:21:01 +0200750 if ((long long int)(long)ref != conv)
751 return cli_err(appctx, "Malformed identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100752
Aurélien Nephtali9a4da682018-04-16 19:02:42 +0200753 /* Try to modify the entry. */
William Lallemandad8be612016-11-18 19:26:17 +0100754 err = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100755 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100756 if (!pat_ref_set_by_id(appctx->ctx.map.ref, ref, args[4], &err)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100757 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Willy Tarreau9d008692019-08-09 11:21:01 +0200758 if (err)
759 return cli_dynerr(appctx, memprintf(&err, "%s.\n", err));
760 else
761 return cli_err(appctx, "Failed to update an entry.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100762 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100763 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100764 }
765 else {
766 /* Else, use the entry identifier as pattern
767 * string, and update the value.
768 */
769 err = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100770 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100771 if (!pat_ref_set(appctx->ctx.map.ref, args[3], args[4], &err)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100772 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Willy Tarreau9d008692019-08-09 11:21:01 +0200773 if (err)
774 return cli_dynerr(appctx, memprintf(&err, "%s.\n", err));
775 else
776 return cli_err(appctx, "Failed to update an entry.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100777 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100778 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100779 }
780
781 /* The set is done, send message. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100782 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100783 return 0;
784 }
785 return 1;
786}
787
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200788static int cli_parse_add_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +0100789{
790 if (strcmp(args[1], "map") == 0 ||
791 strcmp(args[1], "acl") == 0) {
Willy Tarreaubb51c442021-04-30 15:23:36 +0200792 const char *gen = NULL;
793 uint genid = 0;
William Lallemandad8be612016-11-18 19:26:17 +0100794 int ret;
795 char *err;
796
797 /* Set flags. */
798 if (args[1][0] == 'm')
799 appctx->ctx.map.display_flags = PAT_REF_MAP;
800 else
801 appctx->ctx.map.display_flags = PAT_REF_ACL;
802
Willy Tarreaubb51c442021-04-30 15:23:36 +0200803 /* For both "map" and "acl" we may have an optional generation
804 * number specified using a "@" character before the pattern
805 * file name.
806 */
807 if (*args[2] == '@') {
808 gen = args[2] + 1;
809 args++;
810 }
811
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200812 /* If the keyword is "map", we expect:
813 * - three parameters if there is no payload
814 * - one parameter if there is a payload
815 * If it is "acl", we expect only two parameters
William Lallemandad8be612016-11-18 19:26:17 +0100816 */
817 if (appctx->ctx.map.display_flags == PAT_REF_MAP) {
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200818 if ((!payload && (!*args[2] || !*args[3] || !*args[4])) ||
Willy Tarreau9d008692019-08-09 11:21:01 +0200819 (payload && !*args[2]))
820 return cli_err(appctx,
821 "'add map' expects three parameters (map identifier, key and value)"
822 " or one parameter (map identifier) and a payload\n");
William Lallemandad8be612016-11-18 19:26:17 +0100823 }
Willy Tarreau9d008692019-08-09 11:21:01 +0200824 else if (!*args[2] || !*args[3])
825 return cli_err(appctx, "'add acl' expects two parameters: ACL identifier and pattern.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100826
827 /* Lookup for the reference. */
828 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
829 if (!appctx->ctx.map.ref) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200830 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
831 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
832 else
833 return cli_err(appctx, "Unknown ACL identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100834 }
835
Willy Tarreaubb51c442021-04-30 15:23:36 +0200836 if (gen) {
837 genid = str2uic(gen);
838 if ((int)(genid - appctx->ctx.map.ref->next_gen) > 0) {
839 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
840 return cli_err(appctx, "Version number in the future, please use 'prepare map' before.\n");
841 else
842 return cli_err(appctx, "Version number in the future, please use 'prepare acl' before.\n");
843 }
844 }
845
William Lallemandad8be612016-11-18 19:26:17 +0100846 /* The command "add acl" is prohibited if the reference
847 * use samples.
848 */
849 if ((appctx->ctx.map.display_flags & PAT_REF_ACL) &&
850 (appctx->ctx.map.ref->flags & PAT_REF_SMP)) {
Willy Tarreau9d008692019-08-09 11:21:01 +0200851 return cli_err(appctx,
852 "This ACL is shared with a map containing samples. "
853 "You must use the command 'add map' to add values.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100854 }
Willy Tarreauf7dd0e82021-04-29 16:02:48 +0200855
856 /* Add value(s). If no payload is used, key and value are read
857 * from the command line and only one key is set. If a payload
858 * is passed, one key/value pair is read per line till the end
859 * of the payload is reached.
860 */
William Lallemandad8be612016-11-18 19:26:17 +0100861 err = NULL;
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200862
Willy Tarreauf7dd0e82021-04-29 16:02:48 +0200863 do {
864 char *key = args[3];
865 char *value = args[4];
866 size_t l;
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200867
Willy Tarreauf7dd0e82021-04-29 16:02:48 +0200868 if (payload) {
869 /* key and value passed as payload, one pair per line */
870 if (!*payload)
871 break;
872
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200873 key = payload;
874 l = strcspn(key, " \t");
875 payload += l;
876
Willy Tarreau9d008692019-08-09 11:21:01 +0200877 if (!*payload && appctx->ctx.map.display_flags == PAT_REF_MAP)
878 return cli_dynerr(appctx, memprintf(&err, "Missing value for key '%s'.\n", key));
879
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200880 key[l] = 0;
881 payload++;
882
883 /* value */
884 payload += strspn(payload, " \t");
885 value = payload;
886 l = strcspn(value, "\n");
887 payload += l;
888 if (*payload)
889 payload++;
890 value[l] = 0;
Willy Tarreauf7dd0e82021-04-29 16:02:48 +0200891 }
Aurélien Nephtali25650ce2018-04-18 14:04:47 +0200892
Willy Tarreau4053b032021-04-29 16:55:17 +0200893 if (appctx->ctx.map.display_flags != PAT_REF_MAP)
894 value = NULL;
895
896 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Willy Tarreaubb51c442021-04-30 15:23:36 +0200897 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 +0200898 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
899
Willy Tarreauf7dd0e82021-04-29 16:02:48 +0200900 if (!ret) {
901 if (err)
902 return cli_dynerr(appctx, memprintf(&err, "%s.\n", err));
903 else
904 return cli_err(appctx, "Failed to add a key.\n");
Aurélien Nephtali9a4da682018-04-16 19:02:42 +0200905 }
Willy Tarreauf7dd0e82021-04-29 16:02:48 +0200906 } while (payload && *payload);
William Lallemandad8be612016-11-18 19:26:17 +0100907
908 /* The add is done, send message. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100909 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100910 return 1;
911 }
912
913 return 0;
914}
915
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +0200916static int cli_parse_del_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +0100917{
918 if (args[1][0] == 'm')
919 appctx->ctx.map.display_flags = PAT_REF_MAP;
920 else
921 appctx->ctx.map.display_flags = PAT_REF_ACL;
922
923 /* Expect two parameters: map name and key. */
Willy Tarreau9d008692019-08-09 11:21:01 +0200924 if (!*args[2] || !*args[3]) {
925 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
926 return cli_err(appctx, "This command expects two parameters: map identifier and key.\n");
927 else
928 return cli_err(appctx, "This command expects two parameters: ACL identifier and key.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100929 }
930
931 /* Lookup the reference in the maps. */
932 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
933 if (!appctx->ctx.map.ref ||
Willy Tarreau9d008692019-08-09 11:21:01 +0200934 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags))
935 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100936
937 /* If the entry identifier start with a '#', it is considered as
938 * pointer id
939 */
940 if (args[3][0] == '#' && args[3][1] == '0' && args[3][2] == 'x') {
941 struct pat_ref_elt *ref;
942 long long int conv;
943 char *error;
944
945 /* Convert argument to integer value. */
946 conv = strtoll(&args[3][1], &error, 16);
Willy Tarreau9d008692019-08-09 11:21:01 +0200947 if (*error != '\0')
948 return cli_err(appctx, "Malformed identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100949
950 /* Convert and check integer to pointer. */
951 ref = (struct pat_ref_elt *)(long)conv;
Willy Tarreau9d008692019-08-09 11:21:01 +0200952 if ((long long int)(long)ref != conv)
953 return cli_err(appctx, "Malformed identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100954
955 /* Try to delete the entry. */
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100956 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100957 if (!pat_ref_delete_by_id(appctx->ctx.map.ref, ref)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100958 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100959 /* The entry is not found, send message. */
Willy Tarreau9d008692019-08-09 11:21:01 +0200960 return cli_err(appctx, "Key not found.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100961 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100962 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100963 }
964 else {
965 /* Else, use the entry identifier as pattern
966 * string and try to delete the entry.
967 */
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100968 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100969 if (!pat_ref_delete(appctx->ctx.map.ref, args[3])) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100970 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100971 /* The entry is not found, send message. */
Willy Tarreau9d008692019-08-09 11:21:01 +0200972 return cli_err(appctx, "Key not found.\n");
William Lallemandad8be612016-11-18 19:26:17 +0100973 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100974 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
William Lallemandad8be612016-11-18 19:26:17 +0100975 }
976
977 /* The deletion is done, send message. */
Willy Tarreau3b6e5472016-11-24 15:53:53 +0100978 appctx->st0 = CLI_ST_PROMPT;
William Lallemandad8be612016-11-18 19:26:17 +0100979 return 1;
980}
981
Willy Tarreauff3feeb2021-04-30 13:31:43 +0200982/* continue to clear a map which was started in the parser. The range of
983 * generations this applies to is taken from appctx->ctx.cli.i0 for the oldest
984 * and appctx->ctx.cli.i1 for the latest.
985 */
Willy Tarreaud1d005d2019-12-20 18:22:02 +0100986static int cli_io_handler_clear_map(struct appctx *appctx)
987{
988 struct stream_interface *si = appctx->owner;
989 int finished;
990
991 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
Willy Tarreauff3feeb2021-04-30 13:31:43 +0200992 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 +0100993 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
994
995 if (!finished) {
996 /* let's come back later */
997 si_rx_endp_more(si);
998 return 0;
999 }
1000 return 1;
1001}
1002
Willy Tarreauff3feeb2021-04-30 13:31:43 +02001003/* note: sets appctx->ctx.cli.i0 and appctx->ctx.cli.i1 to the oldest and
1004 * latest generations to clear, respectively, and will call the clear_map
1005 * handler.
1006 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02001007static int cli_parse_clear_map(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemandad8be612016-11-18 19:26:17 +01001008{
1009 if (strcmp(args[1], "map") == 0 || strcmp(args[1], "acl") == 0) {
Willy Tarreauff3feeb2021-04-30 13:31:43 +02001010 const char *gen = NULL;
1011
William Lallemandad8be612016-11-18 19:26:17 +01001012 /* Set ACL or MAP flags. */
1013 if (args[1][0] == 'm')
1014 appctx->ctx.map.display_flags = PAT_REF_MAP;
1015 else
1016 appctx->ctx.map.display_flags = PAT_REF_ACL;
1017
Willy Tarreauff3feeb2021-04-30 13:31:43 +02001018 /* For both "map" and "acl" we may have an optional generation
1019 * number specified using a "@" character before the pattern
1020 * file name.
1021 */
1022 if (*args[2] == '@') {
1023 gen = args[2] + 1;
1024 args++;
1025 }
1026
William Lallemandad8be612016-11-18 19:26:17 +01001027 /* no parameter */
1028 if (!*args[2]) {
Willy Tarreau9d008692019-08-09 11:21:01 +02001029 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
1030 return cli_err(appctx, "Missing map identifier.\n");
1031 else
1032 return cli_err(appctx, "Missing ACL identifier.\n");
William Lallemandad8be612016-11-18 19:26:17 +01001033 }
1034
1035 /* lookup into the refs and check the map flag */
1036 appctx->ctx.map.ref = pat_ref_lookup_ref(args[2]);
1037 if (!appctx->ctx.map.ref ||
1038 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
Willy Tarreau9d008692019-08-09 11:21:01 +02001039 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
1040 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
1041 else
1042 return cli_err(appctx, "Unknown ACL identifier. Please use #<id> or <file>.\n");
William Lallemandad8be612016-11-18 19:26:17 +01001043 }
1044
Willy Tarreauff3feeb2021-04-30 13:31:43 +02001045 /* set the desired generation id in cli.i0/i1 */
1046 if (gen)
1047 appctx->ctx.cli.i1 = appctx->ctx.cli.i0 = str2uic(gen);
1048 else
1049 appctx->ctx.cli.i1 = appctx->ctx.cli.i0 = appctx->ctx.map.ref->curr_gen;
1050
Willy Tarreaud1d005d2019-12-20 18:22:02 +01001051 /* delegate the clearing to the I/O handler which can yield */
1052 return 0;
William Lallemandad8be612016-11-18 19:26:17 +01001053 }
Willy Tarreaud1d005d2019-12-20 18:22:02 +01001054 return 1;
William Lallemandad8be612016-11-18 19:26:17 +01001055}
1056
Willy Tarreau7a562ca2021-04-30 15:10:01 +02001057/* note: sets appctx->ctx.cli.i0 and appctx->ctx.cli.i1 to the oldest and
1058 * latest generations to clear, respectively, and will call the clear_map
1059 * handler.
1060 */
1061static int cli_parse_commit_map(char **args, char *payload, struct appctx *appctx, void *private)
1062{
1063 if (strcmp(args[1], "map") == 0 || strcmp(args[1], "acl") == 0) {
1064 const char *gen = NULL;
1065 uint genid;
1066 uint ret;
1067
1068 /* Set ACL or MAP flags. */
1069 if (args[1][0] == 'm')
1070 appctx->ctx.map.display_flags = PAT_REF_MAP;
1071 else
1072 appctx->ctx.map.display_flags = PAT_REF_ACL;
1073
1074 if (*args[2] != '@')
1075 return cli_err(appctx, "Missing version number.\n");
1076
1077 /* The generation number is mandatory for a commit. The range
1078 * of generations that get trashed by a commit starts from the
1079 * opposite of the current one and ends at the previous one.
1080 */
1081 gen = args[2] + 1;
1082 genid = str2uic(gen);
1083 appctx->ctx.cli.i1 = genid - 1;
1084 appctx->ctx.cli.i0 = appctx->ctx.cli.i1 - ((~0U) >> 1);
1085
1086 /* no parameter */
1087 if (!*args[3]) {
1088 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
1089 return cli_err(appctx, "Missing map identifier.\n");
1090 else
1091 return cli_err(appctx, "Missing ACL identifier.\n");
1092 }
1093
1094 /* lookup into the refs and check the map flag */
1095 appctx->ctx.map.ref = pat_ref_lookup_ref(args[3]);
1096 if (!appctx->ctx.map.ref ||
1097 !(appctx->ctx.map.ref->flags & appctx->ctx.map.display_flags)) {
1098 if (appctx->ctx.map.display_flags == PAT_REF_MAP)
1099 return cli_err(appctx, "Unknown map identifier. Please use #<id> or <file>.\n");
1100 else
1101 return cli_err(appctx, "Unknown ACL identifier. Please use #<id> or <file>.\n");
1102 }
1103
1104 HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
1105 if (genid - (appctx->ctx.map.ref->curr_gen + 1) <
1106 appctx->ctx.map.ref->next_gen - appctx->ctx.map.ref->curr_gen)
1107 ret = pat_ref_commit(appctx->ctx.map.ref, genid);
1108 else
1109 ret = 1;
1110 HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
1111
1112 if (ret != 0)
1113 return cli_err(appctx, "Version number out of range.\n");
1114
1115 /* delegate the clearing to the I/O handler which can yield */
1116 return 0;
1117 }
1118 return 1;
1119}
1120
William Lallemandad8be612016-11-18 19:26:17 +01001121/* register cli keywords */
1122
1123static struct cli_kw_list cli_kws = {{ },{
Willy Tarreaub205bfd2021-05-07 11:38:37 +02001124 { { "add", "acl", NULL }, "add acl [@<ver>] <acl> <pattern> : add an acl entry", cli_parse_add_map, NULL },
1125 { { "clear", "acl", NULL }, "clear acl [@<ver>] <acl> : clear the contents of this acl", cli_parse_clear_map, cli_io_handler_clear_map, NULL },
1126 { { "commit","acl", NULL }, "commit acl @<ver> <acl> : commit the ACL at this version", cli_parse_commit_map, cli_io_handler_clear_map, NULL },
1127 { { "del", "acl", NULL }, "del acl <acl> [<key>|#<ref>] : delete acl entries matching <key>", cli_parse_del_map, NULL },
1128 { { "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 },
1129 { { "prepare","acl",NULL }, "prepare acl <acl> : prepare a new version for atomic ACL replacement", cli_parse_prepare_map, NULL },
1130 { { "show", "acl", NULL }, "show acl [@<ver>] <acl>] : report available acls or dump an acl's contents", cli_parse_show_map, NULL },
1131 { { "add", "map", NULL }, "add map [@<ver>] <map> <key> <val> : add a map entry (payload supported instead of key/val)", cli_parse_add_map, NULL },
1132 { { "clear", "map", NULL }, "clear map [@<ver>] <map> : clear the contents of this map", cli_parse_clear_map, cli_io_handler_clear_map, NULL },
1133 { { "commit","map", NULL }, "commit map @<ver> <map> : commit the map at this version", cli_parse_commit_map, cli_io_handler_clear_map, NULL },
1134 { { "del", "map", NULL }, "del map <map> [<key>|#<ref>] : delete map entries matching <key>", cli_parse_del_map, NULL },
1135 { { "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 },
1136 { { "prepare","map",NULL }, "prepare map <acl> : prepare a new version for atomic map replacement", cli_parse_prepare_map, NULL },
1137 { { "set", "map", NULL }, "set map <map> [<key>|#<ref>] <value> : modify a map entry", cli_parse_set_map, NULL },
1138 { { "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 +01001139 { { NULL }, NULL, NULL, NULL }
1140}};
1141
Willy Tarreau0108d902018-11-25 19:14:37 +01001142INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
William Lallemandad8be612016-11-18 19:26:17 +01001143
Thierry FOURNIERd5f624d2013-11-26 11:52:33 +01001144/* Note: must not be declared <const> as its list will be overwritten
1145 *
1146 * For the map_*_int keywords, the output is declared as SMP_T_UINT, but the converter function
1147 * can provide SMP_T_UINT, SMP_T_SINT or SMP_T_BOOL depending on how the patterns found in the
1148 * file can be parsed.
1149 *
1150 * For the map_*_ip keyword, the output is declared as SMP_T_IPV4, but the converter function
1151 * can provide SMP_T_IPV4 or SMP_T_IPV6 depending on the patterns found in the file.
1152 *
1153 * The map_* keywords only emit strings.
1154 *
1155 * The output type is only used during the configuration parsing. It is used for detecting
1156 * compatibility problems.
1157 *
1158 * The arguments are: <file>[,<default value>]
1159 */
1160static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Thierry FOURNIER1edc9712014-12-15 16:18:39 +01001161 { "map", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_STR },
1162 { "map_str", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_STR },
1163 { "map_beg", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_BEG },
1164 { "map_sub", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_SUB },
1165 { "map_dir", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_DIR },
1166 { "map_dom", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_DOM },
1167 { "map_end", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_END },
1168 { "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 +01001169 { "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 +02001170 { "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 +01001171 { "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 +01001172
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02001173 { "map_str_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_STR },
1174 { "map_beg_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_BEG },
1175 { "map_sub_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_SUB },
1176 { "map_dir_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_DIR },
1177 { "map_dom_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_DOM },
1178 { "map_end_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_END },
1179 { "map_reg_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_STR, SMP_T_SINT, (void *)PAT_MATCH_REG },
1180 { "map_int_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, SMP_T_SINT, SMP_T_SINT, (void *)PAT_MATCH_INT },
1181 { "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 +01001182
Thierry FOURNIERb2f8f082015-08-04 19:35:46 +02001183 { "map_str_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_STR },
1184 { "map_beg_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_BEG },
1185 { "map_sub_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_SUB },
1186 { "map_dir_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_DIR },
1187 { "map_dom_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_DOM },
1188 { "map_end_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_END },
1189 { "map_reg_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_ADDR, (void *)PAT_MATCH_REG },
1190 { "map_int_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_SINT, SMP_T_ADDR, (void *)PAT_MATCH_INT },
1191 { "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 +01001192
1193 { /* END */ },
1194}};
1195
Willy Tarreau0108d902018-11-25 19:14:37 +01001196INITCALL1(STG_REGISTER, sample_register_convs, &sample_conv_kws);