blob: 28908c534f43477809135fcdda9078e93090a7a2 [file] [log] [blame]
/*
* 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 <proto/arg.h>
#include <proto/map.h>
#include <proto/pattern.h>
#include <proto/sample.h>
struct list maps = LIST_HEAD_INIT(maps); /* list of struct map_reference */
/* This function return existing map reference or return NULL. */
struct map_reference *map_get_reference(const char *reference)
{
struct map_reference *ref;
/* process the lookup */
list_for_each_entry(ref, &maps, list)
if (strcmp(ref->reference, reference) == 0)
return ref;
return NULL;
}
/* 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 CSTR.
*/
int map_parse_str(const char *text, struct sample_storage *smp)
{
/* The loose of the "const" is balanced by the SMP_T_CSTR type */
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_CSTR;
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 function creates and initializes a new map_reference entry. This
* function only fails in case of a memory allocation issue, in which case
* it returns NULL. <reference> here is a unique identifier for the map's
* contents, typically the name of the file used to build the map.
*/
static struct map_reference *map_create_reference(const char *reference)
{
struct map_reference *ref;
/* create new entry */
ref = calloc(1, sizeof(*ref));
if (!ref)
return NULL;
ref->reference = strdup(reference);
if (!ref->reference)
return NULL;
LIST_INIT(&ref->entries);
LIST_INIT(&ref->maps);
LIST_ADDQ(&maps, &ref->list);
return ref;
}
/* This function just create new entry */
static struct map_entry *map_create_entry(int line, char *key, char *value)
{
struct map_entry *ent;
ent = calloc(1, sizeof(*ent));
if (!ent)
return NULL;
ent->line = line;
ent->key = strdup(key);
if (!ent->key) {
free(ent);
return NULL;
}
ent->value = strdup(value);
if (!ent->value) {
free(ent->key);
free(ent);
return NULL;
}
return ent;
}
/* This crete and initialize map descriptor.
* Return NULL if out of memory error
*/
static struct map_descriptor *map_create_descriptor(struct map_reference *ref,
struct sample_conv *conv)
{
struct map_descriptor *desc;
desc = calloc(1, sizeof(*desc));
if (!desc)
return NULL;
desc->conv = conv;
desc->ref = ref;
LIST_ADDQ(&ref->maps, &desc->list);
return desc;
}
/* This function just add entry into the list of pattern.
* It can return false only in memory problem case
*/
static int map_add_entry(struct map_reference *map, int line, char *key, char *value)
{
struct map_entry *ent;
ent = map_create_entry(line, key, value);
if (!ent)
return 0;
LIST_ADDQ(&map->entries, &ent->list);
return 1;
}
/* Reads patterns from a file. If <err_msg> is non-NULL, an error message will
* be returned there on errors and the caller will have to free it.
*
* The file contains one key + value per line. Lines which start with '#' are
* ignored, just like empty lines. Leading tabs/spaces are stripped. The key is
* then the first "word" (series of non-space/tabs characters), and the value is
* what follows this series of space/tab till the end of the line excluding
* trailing spaces/tabs.
*
* Example :
*
* # this is a comment and is ignored
* 62.212.114.60 1wt.eu \n
* <-><-----------><---><----><---->
* | | | | `--- trailing spaces ignored
* | | | `-------- value
* | | `--------------- middle spaces ignored
* | `------------------------ key
* `-------------------------------- leading spaces ignored
*
* Return non-zero in case of succes, otherwise 0.
*/
static int map_read_entries_from_file(const char *filename,
struct map_reference *ref,
char **err)
{
FILE *file;
char *c;
int ret = 0;
int line = 0;
char *key_beg;
char *key_end;
char *value_beg;
char *value_end;
file = fopen(filename, "r");
if (!file) {
memprintf(err, "failed to open pattern file <%s>", filename);
return 0;
}
/* now parse all patterns. The file may contain only one pattern
* followed by one value per line. The start spaces, separator spaces
* and and spaces are stripped. Each can contain comment started by '#'
*/
while (fgets(trash.str, trash.size, file) != NULL) {
line++;
c = trash.str;
/* ignore lines beginning with a dash */
if (*c == '#')
continue;
/* strip leading spaces and tabs */
while (*c == ' ' || *c == '\t')
c++;
/* empty lines are ignored too */
if (*c == '\0')
continue;
/* look for the end of the key */
key_beg = c;
while (*c && *c != ' ' && *c != '\t' && *c != '\n' && *c != '\r')
c++;
key_end = c;
/* strip middle spaces and tabs */
while (*c == ' ' || *c == '\t')
c++;
/* look for the end of the value, it is the end of the line */
value_beg = c;
while (*c && *c != '\n' && *c != '\r')
c++;
value_end = c;
/* trim possibly trailing spaces and tabs */
while (value_end > value_beg && (value_end[-1] == ' ' || value_end[-1] == '\t'))
value_end--;
/* set final \0 and check entries */
*key_end = '\0';
*value_end = '\0';
/* insert values */
if (!map_add_entry(ref, line, key_beg, value_beg)) {
memprintf(err, "out of memory");
goto out_close;
}
}
/* succes */
ret = 1;
out_close:
fclose(file);
return ret;
}
/* This function read the string entries of <ent>, parse it with
* the <desc> methods, and strore the result into <desc> dummy ACL.
* return 1 in succes case, else return 0 and <err> is filled.
*
* The acm parser use <pattern> for creating new pattern (list
* of values case) or using the same pattern (tree index case).
*
* <patflags> must be PAT_F_*.
*/
static int map_parse_and_index(struct map_descriptor *desc,
struct pattern **pattern,
struct map_entry *ent,
int patflags,
char **err)
{
struct sample_storage *smp;
const char *args[2];
/* use new smp for storing value */
smp = calloc(1, sizeof(*smp));
if (!smp)
return 0;
/* first read and convert value */
if (!desc->parse(ent->value, smp)) {
memprintf(err, "parse value failed at line %d of file <%s>",
ent->line, desc->ref->reference);
return 0;
}
/* register key */
args[0] = ent->key;
args[1] = "";
if (!pattern_register(desc->pat, args, smp, pattern, patflags, err))
return 0;
return 1;
}
/* 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.
*/
static int sample_load_map(struct arg *arg, struct sample_conv *conv, char **err)
{
struct map_reference *ref;
struct map_descriptor *desc;
struct pattern *pattern;
struct map_entry *ent;
struct pattern_expr *pat = NULL;
/* look for existing map reference. The reference is the
* file encountered in the first argument. arg[0] with string
* type is guaranteed by the parser.
*/
ref = map_get_reference(arg[0].data.str.str);
/* The reference doesn't exist */
if (!ref) {
/* create new reference entry */
ref = map_create_reference(arg[0].data.str.str);
if (!ref) {
memprintf(err, "out of memory");
return 0;
}
/* load the file */
if (!map_read_entries_from_file(arg[0].data.str.str, ref, err))
return 0;
}
/* look for identical existing map. Two maps are identical if
* their in_type and out_type are the same. If is not found, pat
* is NULL.
*/
else {
list_for_each_entry(desc, &ref->maps, list)
if (desc->conv->in_type == conv->in_type &&
desc->conv->out_type == conv->out_type &&
desc->conv->private == conv->private)
break;
if (&desc->list != &ref->maps)
pat = desc->pat;
}
/* create new map descriptor */
desc = map_create_descriptor(ref, conv);
if (!desc) {
memprintf(err, "out of memory");
return 0;
}
/* check the output parse method */
switch (desc->conv->out_type) {
case SMP_T_STR: desc->parse = map_parse_str; break;
case SMP_T_UINT: desc->parse = map_parse_int; break;
case SMP_T_IPV4: desc->parse = map_parse_ip; break;
case SMP_T_IPV6: desc->parse = 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;
}
/* If identical pattern is not found, initialize his own pattern */
if (!pat) {
desc->pat = calloc(1, sizeof(*desc->pat));
if (!desc->pat) {
memprintf(err, "out of memory");
return 0;
}
pattern_init_expr(desc->pat);
/* This is original pattern, must free */
desc->do_free = 1;
/* set the match method */
desc->pat->match = pat_match_fcts[conv->private];
desc->pat->parse = pat_parse_fcts[conv->private];
/* parse each line of the file */
pattern = NULL;
list_for_each_entry(ent, &ref->entries, list)
if (!map_parse_and_index(desc, &pattern, ent, 0, err))
return 0;
}
/* identical pattern found. Use reference to this pattern, and mark
* the map_descriptor pattern as non freeable
*/
else {
desc->pat = pat;
desc->do_free = 0;
}
/* The second argument is the default value */
if (arg[1].type == ARGT_STR) {
desc->default_value = strdup(arg[1].data.str.str);
if (!desc->default_value) {
memprintf(err, "out of memory");
return 0;
}
desc->def = calloc(1, sizeof(*desc->def));
if (!desc->def) {
memprintf(err, "out of memory");
return 0;
}
if (!desc->parse(desc->default_value, desc->def)) {
memprintf(err, "Cannot parse default value");
return 0;
}
}
else
desc->def = NULL;
/* replace the first argument by this definition */
arg[0].type = ARGT_MAP;
arg[0].data.map = desc;
return 1;
}
static int sample_conv_map(const struct arg *arg_p, struct sample *smp)
{
struct map_descriptor *desc;
struct sample_storage *sample;
enum pat_match_res ret;
/* get config */
desc = arg_p[0].data.map;
/* Execute the match function. */
ret = pattern_exec_match(desc->pat, smp, &sample, NULL, NULL);
if (ret != PAT_MATCH) {
if (!desc->def)
return 0;
sample = desc->def;
}
/* copy new data */
smp->type = sample->type;
memcpy(&smp->data, &sample->data, sizeof(smp->data));
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, PAT_MATCH_STR },
{ "map_str", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, PAT_MATCH_STR },
{ "map_beg", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, PAT_MATCH_BEG },
{ "map_sub", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, PAT_MATCH_SUB },
{ "map_dir", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, PAT_MATCH_DIR },
{ "map_dom", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, PAT_MATCH_DOM },
{ "map_end", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, PAT_MATCH_END },
{ "map_reg", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_STR, PAT_MATCH_REG },
{ "map_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_UINT, SMP_T_STR, PAT_MATCH_INT },
{ "map_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_ADDR, SMP_T_STR, PAT_MATCH_IP },
{ "map_str_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_UINT, PAT_MATCH_STR },
{ "map_beg_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_UINT, PAT_MATCH_BEG },
{ "map_sub_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_UINT, PAT_MATCH_SUB },
{ "map_dir_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_UINT, PAT_MATCH_DIR },
{ "map_dom_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_UINT, PAT_MATCH_DOM },
{ "map_end_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_UINT, PAT_MATCH_END },
{ "map_reg_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_UINT, PAT_MATCH_REG },
{ "map_int_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_UINT, SMP_T_UINT, PAT_MATCH_INT },
{ "map_ip_int", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_ADDR, SMP_T_UINT, PAT_MATCH_IP },
{ "map_str_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_IPV4, PAT_MATCH_STR },
{ "map_beg_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_IPV4, PAT_MATCH_BEG },
{ "map_sub_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_IPV4, PAT_MATCH_SUB },
{ "map_dir_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_IPV4, PAT_MATCH_DIR },
{ "map_dom_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_IPV4, PAT_MATCH_DOM },
{ "map_end_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_IPV4, PAT_MATCH_END },
{ "map_reg_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_STR, SMP_T_IPV4, PAT_MATCH_REG },
{ "map_int_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_UINT, SMP_T_IPV4, PAT_MATCH_INT },
{ "map_ip_ip", sample_conv_map, ARG2(1,STR,STR), sample_load_map, SMP_T_ADDR, SMP_T_IPV4, PAT_MATCH_IP },
{ /* END */ },
}};
__attribute__((constructor))
static void __map_init(void)
{
/* register format conversion keywords */
sample_register_convs(&sample_conv_kws);
}