mirror of
https://git.haproxy.org/git/haproxy.git/
synced 2025-11-06 19:41:02 +01:00
3def393f8d
This patch cretes a new Map class that permits to do some lookup in HAProxy maps. This Map class is integration in the HAProxy update system, so we can modify the map throught the socket.
284 lines
9.6 KiB
C
284 lines
9.6 KiB
C
/*
|
|
* MAP management functions.
|
|
*
|
|
* Copyright 2000-2013 Willy Tarreau <w@1wt.eu>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the License, or (at your option) any later version.
|
|
*
|
|
*/
|
|
|
|
#include <limits.h>
|
|
#include <stdio.h>
|
|
|
|
#include <common/standard.h>
|
|
|
|
#include <types/global.h>
|
|
#include <types/map.h>
|
|
#include <types/pattern.h>
|
|
|
|
#include <proto/arg.h>
|
|
#include <proto/map.h>
|
|
#include <proto/pattern.h>
|
|
#include <proto/sample.h>
|
|
|
|
/* Parse an IPv4 address and store it into the sample.
|
|
* The output type is IPV4.
|
|
*/
|
|
int map_parse_ip(const char *text, struct sample_storage *smp)
|
|
{
|
|
if (!buf2ip(text, strlen(text), &smp->data.ipv4))
|
|
return 0;
|
|
smp->type = SMP_T_IPV4;
|
|
return 1;
|
|
}
|
|
|
|
/* Parse an IPv6 address and store it into the sample.
|
|
* The output type is IPV6.
|
|
*/
|
|
int map_parse_ip6(const char *text, struct sample_storage *smp)
|
|
{
|
|
if (!buf2ip6(text, strlen(text), &smp->data.ipv6))
|
|
return 0;
|
|
smp->type = SMP_T_IPV6;
|
|
return 1;
|
|
}
|
|
|
|
/* Parse a string and store a pointer to it into the sample. The original
|
|
* string must be left in memory because we return a direct memory reference.
|
|
* The output type is SMP_T_STR. There is no risk that the data will be
|
|
* overwritten because sample_conv_map() makes a const sample with this
|
|
* output.
|
|
*/
|
|
int map_parse_str(const char *text, struct sample_storage *smp)
|
|
{
|
|
smp->data.str.str = (char *)text;
|
|
smp->data.str.len = strlen(text);
|
|
smp->data.str.size = smp->data.str.len + 1;
|
|
smp->type = SMP_T_STR;
|
|
return 1;
|
|
}
|
|
|
|
/* Parse an integer and convert it to a sample. The output type is SINT if the
|
|
* number is negative, or UINT if it is positive or null. The function returns
|
|
* zero (error) if the number is too large.
|
|
*/
|
|
int map_parse_int(const char *text, struct sample_storage *smp)
|
|
{
|
|
long long int value;
|
|
char *error;
|
|
|
|
/* parse interger and convert it. Return the value in 64 format. */
|
|
value = strtoll(text, &error, 10);
|
|
if (*error != '\0')
|
|
return 0;
|
|
|
|
/* check sign iand limits */
|
|
if (value < 0) {
|
|
if (value < INT_MIN)
|
|
return 0;
|
|
smp->type = SMP_T_SINT;
|
|
smp->data.sint = value;
|
|
}
|
|
else {
|
|
if (value > UINT_MAX)
|
|
return 0;
|
|
smp->type = SMP_T_UINT;
|
|
smp->data.uint = value;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* This crete and initialize map descriptor.
|
|
* Return NULL if out of memory error
|
|
*/
|
|
static struct map_descriptor *map_create_descriptor(struct sample_conv *conv)
|
|
{
|
|
struct map_descriptor *desc;
|
|
|
|
desc = calloc(1, sizeof(*desc));
|
|
if (!desc)
|
|
return NULL;
|
|
|
|
desc->conv = conv;
|
|
|
|
return desc;
|
|
}
|
|
|
|
/* This function load the map file according with data type declared into
|
|
* the "struct sample_conv".
|
|
*
|
|
* This function choose the indexation type (ebtree or list) according with
|
|
* the type of match needed.
|
|
*/
|
|
int sample_load_map(struct arg *arg, struct sample_conv *conv,
|
|
const char *file, int line, char **err)
|
|
{
|
|
struct map_descriptor *desc;
|
|
|
|
/* create new map descriptor */
|
|
desc = map_create_descriptor(conv);
|
|
if (!desc) {
|
|
memprintf(err, "out of memory");
|
|
return 0;
|
|
}
|
|
|
|
/* Initialize pattern */
|
|
pattern_init_head(&desc->pat);
|
|
|
|
/* This is original pattern, must free */
|
|
desc->do_free = 1;
|
|
|
|
/* Set the match method. */
|
|
desc->pat.match = pat_match_fcts[(long)conv->private];
|
|
desc->pat.parse = pat_parse_fcts[(long)conv->private];
|
|
desc->pat.index = pat_index_fcts[(long)conv->private];
|
|
desc->pat.delete = pat_delete_fcts[(long)conv->private];
|
|
desc->pat.prune = pat_prune_fcts[(long)conv->private];
|
|
desc->pat.expect_type = pat_match_types[(long)conv->private];
|
|
|
|
/* Set the output parse method. */
|
|
switch (desc->conv->out_type) {
|
|
case SMP_T_STR: desc->pat.parse_smp = map_parse_str; break;
|
|
case SMP_T_UINT: desc->pat.parse_smp = map_parse_int; break;
|
|
case SMP_T_IPV4: desc->pat.parse_smp = map_parse_ip; break;
|
|
case SMP_T_IPV6: desc->pat.parse_smp = map_parse_ip6; break;
|
|
default:
|
|
memprintf(err, "map: internal haproxy error: no default parse case for the input type <%d>.",
|
|
conv->out_type);
|
|
return 0;
|
|
}
|
|
|
|
/* Load map. */
|
|
if (!pattern_read_from_file(&desc->pat, PAT_REF_MAP, arg[0].data.str.str, PAT_MF_NO_DNS,
|
|
1, err, file, line))
|
|
return 0;
|
|
|
|
/* replace the first argument by this definition */
|
|
arg[0].type = ARGT_MAP;
|
|
arg[0].data.map = desc;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int sample_conv_map(struct stream *stream, const struct arg *arg_p,
|
|
struct sample *smp, void *private)
|
|
{
|
|
struct map_descriptor *desc;
|
|
struct pattern *pat;
|
|
|
|
/* get config */
|
|
desc = arg_p[0].data.map;
|
|
|
|
/* Execute the match function. */
|
|
pat = pattern_exec_match(&desc->pat, smp, 1);
|
|
|
|
/* Match case. */
|
|
if (pat) {
|
|
/* Copy sample. */
|
|
if (pat->smp) {
|
|
smp->type = pat->smp->type;
|
|
smp->flags |= SMP_F_CONST;
|
|
memcpy(&smp->data, &pat->smp->data, sizeof(smp->data));
|
|
return 1;
|
|
}
|
|
|
|
/* Return just int sample containing 1. */
|
|
smp->type = SMP_T_UINT;
|
|
smp->data.uint= 1;
|
|
return 1;
|
|
}
|
|
|
|
/* If no default value avalaible, the converter fails. */
|
|
if (arg_p[1].type == ARGT_STOP)
|
|
return 0;
|
|
|
|
/* Return the default value. */
|
|
switch (desc->conv->out_type) {
|
|
|
|
case SMP_T_STR:
|
|
smp->type = SMP_T_STR;
|
|
smp->flags |= SMP_F_CONST;
|
|
smp->data.str = arg_p[1].data.str;
|
|
break;
|
|
|
|
case SMP_T_UINT:
|
|
smp->type = SMP_T_UINT;
|
|
smp->data.uint = arg_p[1].data.uint;
|
|
break;
|
|
|
|
case SMP_T_IPV4:
|
|
smp->type = SMP_T_IPV4;
|
|
smp->data.ipv4 = arg_p[1].data.ipv4;
|
|
break;
|
|
|
|
case SMP_T_IPV6:
|
|
smp->type = SMP_T_IPV6;
|
|
smp->data.ipv6 = arg_p[1].data.ipv6;
|
|
break;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* Note: must not be declared <const> as its list will be overwritten
|
|
*
|
|
* For the map_*_int keywords, the output is declared as SMP_T_UINT, but the converter function
|
|
* can provide SMP_T_UINT, SMP_T_SINT or SMP_T_BOOL depending on how the patterns found in the
|
|
* file can be parsed.
|
|
*
|
|
* For the map_*_ip keyword, the output is declared as SMP_T_IPV4, but the converter function
|
|
* can provide SMP_T_IPV4 or SMP_T_IPV6 depending on the patterns found in the file.
|
|
*
|
|
* The map_* keywords only emit strings.
|
|
*
|
|
* The output type is only used during the configuration parsing. It is used for detecting
|
|
* compatibility problems.
|
|
*
|
|
* The arguments are: <file>[,<default value>]
|
|
*/
|
|
static struct sample_conv_kw_list sample_conv_kws = {ILH, {
|
|
{ "map", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_STR },
|
|
{ "map_str", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_STR },
|
|
{ "map_beg", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_BEG },
|
|
{ "map_sub", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_SUB },
|
|
{ "map_dir", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_DIR },
|
|
{ "map_dom", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_DOM },
|
|
{ "map_end", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_END },
|
|
{ "map_reg", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, (void *)PAT_MATCH_REG },
|
|
{ "map_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_UINT, SMP_T_STR, (void *)PAT_MATCH_INT },
|
|
{ "map_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_ADDR, SMP_T_STR, (void *)PAT_MATCH_IP },
|
|
|
|
{ "map_str_int", sample_conv_map, ARG2(1,STR,UINT), sample_load_map, SMP_T_STR, SMP_T_UINT, (void *)PAT_MATCH_STR },
|
|
{ "map_beg_int", sample_conv_map, ARG2(1,STR,UINT), sample_load_map, SMP_T_STR, SMP_T_UINT, (void *)PAT_MATCH_BEG },
|
|
{ "map_sub_int", sample_conv_map, ARG2(1,STR,UINT), sample_load_map, SMP_T_STR, SMP_T_UINT, (void *)PAT_MATCH_SUB },
|
|
{ "map_dir_int", sample_conv_map, ARG2(1,STR,UINT), sample_load_map, SMP_T_STR, SMP_T_UINT, (void *)PAT_MATCH_DIR },
|
|
{ "map_dom_int", sample_conv_map, ARG2(1,STR,UINT), sample_load_map, SMP_T_STR, SMP_T_UINT, (void *)PAT_MATCH_DOM },
|
|
{ "map_end_int", sample_conv_map, ARG2(1,STR,UINT), sample_load_map, SMP_T_STR, SMP_T_UINT, (void *)PAT_MATCH_END },
|
|
{ "map_reg_int", sample_conv_map, ARG2(1,STR,UINT), sample_load_map, SMP_T_STR, SMP_T_UINT, (void *)PAT_MATCH_REG },
|
|
{ "map_int_int", sample_conv_map, ARG2(1,STR,UINT), sample_load_map, SMP_T_UINT, SMP_T_UINT, (void *)PAT_MATCH_INT },
|
|
{ "map_ip_int", sample_conv_map, ARG2(1,STR,UINT), sample_load_map, SMP_T_ADDR, SMP_T_UINT, (void *)PAT_MATCH_IP },
|
|
|
|
{ "map_str_ip", sample_conv_map, ARG2(1,STR,IPV4), sample_load_map, SMP_T_STR, SMP_T_IPV4, (void *)PAT_MATCH_STR },
|
|
{ "map_beg_ip", sample_conv_map, ARG2(1,STR,IPV4), sample_load_map, SMP_T_STR, SMP_T_IPV4, (void *)PAT_MATCH_BEG },
|
|
{ "map_sub_ip", sample_conv_map, ARG2(1,STR,IPV4), sample_load_map, SMP_T_STR, SMP_T_IPV4, (void *)PAT_MATCH_SUB },
|
|
{ "map_dir_ip", sample_conv_map, ARG2(1,STR,IPV4), sample_load_map, SMP_T_STR, SMP_T_IPV4, (void *)PAT_MATCH_DIR },
|
|
{ "map_dom_ip", sample_conv_map, ARG2(1,STR,IPV4), sample_load_map, SMP_T_STR, SMP_T_IPV4, (void *)PAT_MATCH_DOM },
|
|
{ "map_end_ip", sample_conv_map, ARG2(1,STR,IPV4), sample_load_map, SMP_T_STR, SMP_T_IPV4, (void *)PAT_MATCH_END },
|
|
{ "map_reg_ip", sample_conv_map, ARG2(1,STR,IPV4), sample_load_map, SMP_T_STR, SMP_T_IPV4, (void *)PAT_MATCH_REG },
|
|
{ "map_int_ip", sample_conv_map, ARG2(1,STR,IPV4), sample_load_map, SMP_T_UINT, SMP_T_IPV4, (void *)PAT_MATCH_INT },
|
|
{ "map_ip_ip", sample_conv_map, ARG2(1,STR,IPV4), sample_load_map, SMP_T_ADDR, SMP_T_IPV4, (void *)PAT_MATCH_IP },
|
|
|
|
{ /* END */ },
|
|
}};
|
|
|
|
__attribute__((constructor))
|
|
static void __map_init(void)
|
|
{
|
|
/* register format conversion keywords */
|
|
sample_register_convs(&sample_conv_kws);
|
|
}
|