upstream/haproxy
1
0
Fork 0
mirror of https://github.com/haproxy/haproxy.git synced 2026-03-27 12:56:09 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 16
haproxy/src/arg.c

449 lines
12 KiB
C
Raw Normal View History

MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
/*
* Functions used to parse typed argument lists
*
* Copyright 2012 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 <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
CLEANUP: include: tree-wide alphabetical sort of include files This patch fixes all the leftovers from the include cleanup campaign. There were not that many (~400 entries in ~150 files) but it was definitely worth doing it as it revealed a few duplicates.
2020-06-09 03:07:15 -04:00
#include <haproxy/arg.h>
REORG: include: move common/chunk.h to haproxy/chunk.h No change was necessary, it was already properly split.
2020-06-02 04:22:45 -04:00
#include <haproxy/chunk.h>
REORG: include: split global.h into haproxy/global{,-t}.h global.h was one of the messiest files, it has accumulated tons of implicit dependencies and declares many globals that make almost all other file include it. It managed to silence a dependency loop between server.h and proxy.h by being well placed to pre-define the required structs, forcing struct proxy and struct server to be forward-declared in a significant number of files. It was split in to, one which is the global struct definition and the few macros and flags, and the rest containing the functions prototypes. The UNIX_MAX_PATH definition was moved to compat.h.
2020-06-04 11:05:57 -04:00
#include <haproxy/global.h>
CLEANUP: include: tree-wide alphabetical sort of include files This patch fixes all the leftovers from the include cleanup campaign. There were not that many (~400 entries in ~150 files) but it was definitely worth doing it as it revealed a few duplicates.
2020-06-09 03:07:15 -04:00
#include <haproxy/tools.h>
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
MINOR: global: export many symbols. The functions "val_payload_lv" and "val_hdr" are useful with lua. The lua automatic binding for sample fetchs needs to compare check functions. The "arg_type_names" permit to display error messages.
2014-12-08 13:50:43 -05:00
const char *arg_type_names[ARGT_NBTYPES] = {
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
[ARGT_STOP] = "end of arguments",
MAJOR: arg: converts uint and sint in sint This patch removes the 32 bits unsigned integer and the 32 bit signed integer. It replaces these types by a unique type 64 bit signed.
2015-07-20 11:45:02 -04:00
[ARGT_SINT] = "integer",
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
[ARGT_STR] = "string",
[ARGT_IPV4] = "IPv4 address",
[ARGT_MSK4] = "IPv4 mask",
[ARGT_IPV6] = "IPv6 address",
[ARGT_MSK6] = "IPv6 mask",
[ARGT_TIME] = "delay",
[ARGT_SIZE] = "size",
[ARGT_FE] = "frontend",
[ARGT_BE] = "backend",
[ARGT_TAB] = "table",
[ARGT_SRV] = "server",
[ARGT_USR] = "user list",
BUG/MINOR: args: add missing entry for ARGT_MAP in arg_type_names This type is currently not used in an argument so it's harmles. But better correctly fill the name.
2015-01-19 12:58:20 -05:00
[ARGT_MAP] = "map",
MINOR: args: implement a new arg type for regex : ARGT_REG This one will be used when a regex is expected. It is automatically resolved after the parsing and compiled into a regex. Some optional flags are supported in the type-specific flags that should be set by the optional arg checker. One is used during the regex compilation : ARGF_REG_ICASE to ignore case.
2015-01-19 13:00:58 -05:00
[ARGT_REG] = "regex",
BUG/MINOR: args: add name for ARGT_VAR Commit 4834bc7 ("MEDIUM: vars: adds support of variables") introduced ARGT_VAR but forgot to put it in the names array. No backport needed.
2015-09-21 14:57:12 -04:00
[ARGT_VAR] = "variable",
MINOR: arg: Add support for ARGT_PBUF_FNUM arg type. This new argument type is used to parse Protocol Buffers field number with dotted notation (e.g: 1.2.3.4).
2019-02-25 09:20:35 -05:00
[ARGT_PBUF_FNUM] = "Protocol buffers field number",
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
/* Unassigned types must never happen. Better crash during parsing if they do. */
};
MEDIUM: sample: pass an empty list instead of a null for fetch args ACL and sample fetches use args list and it is really not convenient to check for null args everywhere. Now for empty args we pass a constant list of end of lists. It will allow us to remove many useless checks.
2012-10-19 13:49:09 -04:00
/* This dummy arg list may be used by default when no arg is found, it helps
* parsers by removing pointer checks.
*/
MEDIUM: args: use #define to specify the number of bits used by arg types and counts This is in order to add new types. This patch does not change anything else. Two remaining (harmless) occurrences of a count of 8 instead of 7 were fixed by this patch : empty_arg_list[] and the for() loop counting args.
2015-01-19 12:44:07 -05:00
struct arg empty_arg_list[ARGM_NBARGS] = { };
MEDIUM: sample: pass an empty list instead of a null for fetch args ACL and sample fetches use args list and it is really not convenient to check for null args everywhere. Now for empty args we pass a constant list of end of lists. It will allow us to remove many useless checks.
2012-10-19 13:49:09 -04:00
MAJOR: sample: maintain a per-proxy list of the fetch args to resolve While ACL args were resolved after all the config was parsed, it was not the case with sample fetch args because they're almost everywhere now. The issue is that ACLs now solely rely on sample fetches, so their args resolving doesn't work anymore. And many fetches involving a server, a proxy or a userlist don't work at all. The real issue is that at the bottom layers we have no information about proxies, line numbers, even ACLs in order to report understandable errors, and that at the top layers we have no visibility over the locations where fetches are referenced (think log node). After failing multiple unsatisfying solutions attempts, we now have a new concept of args list. The principle is that every proxy has a list head which contains a number of indications such as the config keyword, the context where it's used, the file and line number, etc... and a list of arguments. This list head is of the same type as the elements, so it serves as a template for adding new elements. This way, it is filled from top to bottom by the callers with the information they have (eg: line numbers, ACL name, ...) and the lower layers just have to duplicate it and add an element when they face an argument they cannot resolve yet. Then at the end of the configuration parsing, a loop passes over each proxy's list and resolves all the args in sequence. And this way there is all necessary information to report verbose errors. The first immediate benefit is that for the first time we got very precise location of issues (arg number in a keyword in its context, ...). Second, in order to do this we had to parse log-format and unique-id-format a bit earlier, so that was a great opportunity for doing so when the directives are encountered (unless it's a default section). This way, the recorded line numbers for these args are the ones of the place where the log format is declared, not the end of the file. Userlists report slightly more information now. They're the only remaining ones in the ACL resolving function.
2013-04-02 10:34:32 -04:00
/* This function clones a struct arg_list template into a new one which is
* returned.
*/
struct arg_list *arg_list_clone(const struct arg_list *orig)
{
struct arg_list *new;
if ((new = calloc(1, sizeof(*new))) != NULL) {
/* ->list will be set by the caller when inserting the element.
* ->arg and ->arg_pos will be set by the caller.
*/
new->ctx = orig->ctx;
new->kw = orig->kw;
new->conv = orig->conv;
new->file = orig->file;
new->line = orig->line;
}
return new;
}
/* This function clones a struct <arg_list> template into a new one which is
* set to point to arg <arg> at pos <pos>, and which is returned if the caller
* wants to apply further changes.
*/
struct arg_list *arg_list_add(struct arg_list *orig, struct arg *arg, int pos)
{
struct arg_list *new;
new = arg_list_clone(orig);
BUG/MINOR: arg: don't try to add an argument on failed memory allocation Take care of arg_list_clone() returning NULL in arg_list_add() since the former does it too. It's only used during parsing so the impact is very low. Can be backported to 1.7, 1.6 and 1.5.
2017-04-12 16:28:52 -04:00
if (new) {
new->arg = arg;
new->arg_pos = pos;
CLEANUP: lists/tree-wide: rename some list operations to avoid some confusion The current "ADD" vs "ADDQ" is confusing because when thinking in terms of appending at the end of a list, "ADD" naturally comes to mind, but here it does the opposite, it inserts. Several times already it's been incorrectly used where ADDQ was expected, the latest of which was a fortunate accident explained in 6fa922562 ("CLEANUP: stream: explain why we queue the stream at the head of the server list"). Let's use more explicit (but slightly longer) names now: LIST_ADD -> LIST_INSERT LIST_ADDQ -> LIST_APPEND LIST_ADDED -> LIST_INLIST LIST_DEL -> LIST_DELETE The same is true for MT_LISTs, including their "TRY" variant. LIST_DEL_INIT keeps its short name to encourage to use it instead of the lazier LIST_DELETE which is often less safe. The change is large (~674 non-comment entries) but is mechanical enough to remain safe. No permutation was performed, so any out-of-tree code can easily map older names to new ones. The list doc was updated.
2021-04-21 01:32:39 -04:00
LIST_APPEND(&orig->list, &new->list);
BUG/MINOR: arg: don't try to add an argument on failed memory allocation Take care of arg_list_clone() returning NULL in arg_list_add() since the former does it too. It's only used during parsing so the impact is very low. Can be backported to 1.7, 1.6 and 1.5.
2017-04-12 16:28:52 -04:00
}
MAJOR: sample: maintain a per-proxy list of the fetch args to resolve While ACL args were resolved after all the config was parsed, it was not the case with sample fetch args because they're almost everywhere now. The issue is that ACLs now solely rely on sample fetches, so their args resolving doesn't work anymore. And many fetches involving a server, a proxy or a userlist don't work at all. The real issue is that at the bottom layers we have no information about proxies, line numbers, even ACLs in order to report understandable errors, and that at the top layers we have no visibility over the locations where fetches are referenced (think log node). After failing multiple unsatisfying solutions attempts, we now have a new concept of args list. The principle is that every proxy has a list head which contains a number of indications such as the config keyword, the context where it's used, the file and line number, etc... and a list of arguments. This list head is of the same type as the elements, so it serves as a template for adding new elements. This way, it is filled from top to bottom by the callers with the information they have (eg: line numbers, ACL name, ...) and the lower layers just have to duplicate it and add an element when they face an argument they cannot resolve yet. Then at the end of the configuration parsing, a loop passes over each proxy's list and resolves all the args in sequence. And this way there is all necessary information to report verbose errors. The first immediate benefit is that for the first time we got very precise location of issues (arg number in a keyword in its context, ...). Second, in order to do this we had to parse log-format and unique-id-format a bit earlier, so that was a great opportunity for doing so when the directives are encountered (unless it's a default section). This way, the recorded line numbers for these args are the ones of the place where the log format is declared, not the end of the file. Userlists report slightly more information now. They're the only remaining ones in the ACL resolving function.
2013-04-02 10:34:32 -04:00
return new;
}
MEDIUM: arg: make make_arg_list() stop after its own arguments The main problem we're having with argument parsing is that at the moment the caller looks for the first character looking like an end of arguments (')') and calls make_arg_list() on the sub-string inside the parenthesis. Let's first change the way it works so that make_arg_list() also consumes the parenthesis and returns the pointer to the first char not consumed. This will later permit to refine each argument parsing. For now there is no functional change.
2020-02-14 02:40:37 -05:00
/* This function builds an argument list from a config line, and stops at the
* first non-matching character, which is pointed to in <end_ptr>. A valid arg
* list starts with an opening parenthesis '(', contains a number of comma-
* delimited words, and ends with the closing parenthesis ')'. An empty list
* (with or without the parenthesis) will lead to a valid empty argument if the
* keyword has a mandatory one. The function returns the number of arguments
* emitted, or <0 in case of any error. Everything needed it automatically
* allocated. A pointer to an error message might be returned in err_msg if not
* NULL, in which case it would be allocated and the caller will have to check
* it and free it. The output arg list is returned in argp which must be valid.
* The returned array is always terminated by an arg of type ARGT_STOP (0),
* unless the mask indicates that no argument is supported. Unresolved arguments
* are appended to arg list <al>, which also serves as a template to create new
* entries. The mask is composed of a number of mandatory arguments in its lower
* ARGM_BITS bits, and a concatenation of each argument type in each subsequent
* ARGT_BITS-bit sblock. If <err_msg> is not NULL, it must point to a freeable
* or NULL pointer. The caller is expected to restart the parsing from the new
* pointer set in <end_ptr>, which is the first character considered as not
* being part of the arg list. The input string ends on the first between <len>
* characters (when len is positive) or the first NUL character. Placing -1 in
* <len> will make it virtually unbounded (~2GB long strings).
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
*/
MINOR: sample: Moves ARGS underlying type from 32 to 64 bits. ARG# macros allow to create a list up to 7 in theory but 5 in practice. The change to a guaranteed 64 bits type increase to up to 12.
2016-03-15 15:00:35 -04:00
int make_arg_list(const char *in, int len, uint64_t mask, struct arg **argp,
MEDIUM: arg: make make_arg_list() stop after its own arguments The main problem we're having with argument parsing is that at the moment the caller looks for the first character looking like an end of arguments (')') and calls make_arg_list() on the sub-string inside the parenthesis. Let's first change the way it works so that make_arg_list() also consumes the parenthesis and returns the pointer to the first char not consumed. This will later permit to refine each argument parsing. For now there is no functional change.
2020-02-14 02:40:37 -05:00
char **err_msg, const char **end_ptr, int *err_arg,
MAJOR: sample: maintain a per-proxy list of the fetch args to resolve While ACL args were resolved after all the config was parsed, it was not the case with sample fetch args because they're almost everywhere now. The issue is that ACLs now solely rely on sample fetches, so their args resolving doesn't work anymore. And many fetches involving a server, a proxy or a userlist don't work at all. The real issue is that at the bottom layers we have no information about proxies, line numbers, even ACLs in order to report understandable errors, and that at the top layers we have no visibility over the locations where fetches are referenced (think log node). After failing multiple unsatisfying solutions attempts, we now have a new concept of args list. The principle is that every proxy has a list head which contains a number of indications such as the config keyword, the context where it's used, the file and line number, etc... and a list of arguments. This list head is of the same type as the elements, so it serves as a template for adding new elements. This way, it is filled from top to bottom by the callers with the information they have (eg: line numbers, ACL name, ...) and the lower layers just have to duplicate it and add an element when they face an argument they cannot resolve yet. Then at the end of the configuration parsing, a loop passes over each proxy's list and resolves all the args in sequence. And this way there is all necessary information to report verbose errors. The first immediate benefit is that for the first time we got very precise location of issues (arg number in a keyword in its context, ...). Second, in order to do this we had to parse log-format and unique-id-format a bit earlier, so that was a great opportunity for doing so when the directives are encountered (unless it's a default section). This way, the recorded line numbers for these args are the ones of the place where the log format is declared, not the end of the file. Userlists report slightly more information now. They're the only remaining ones in the ACL resolving function.
2013-04-02 10:34:32 -04:00
struct arg_list *al)
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
{
int nbarg;
int pos;
MAJOR: sample: maintain a per-proxy list of the fetch args to resolve While ACL args were resolved after all the config was parsed, it was not the case with sample fetch args because they're almost everywhere now. The issue is that ACLs now solely rely on sample fetches, so their args resolving doesn't work anymore. And many fetches involving a server, a proxy or a userlist don't work at all. The real issue is that at the bottom layers we have no information about proxies, line numbers, even ACLs in order to report understandable errors, and that at the top layers we have no visibility over the locations where fetches are referenced (think log node). After failing multiple unsatisfying solutions attempts, we now have a new concept of args list. The principle is that every proxy has a list head which contains a number of indications such as the config keyword, the context where it's used, the file and line number, etc... and a list of arguments. This list head is of the same type as the elements, so it serves as a template for adding new elements. This way, it is filled from top to bottom by the callers with the information they have (eg: line numbers, ACL name, ...) and the lower layers just have to duplicate it and add an element when they face an argument they cannot resolve yet. Then at the end of the configuration parsing, a loop passes over each proxy's list and resolves all the args in sequence. And this way there is all necessary information to report verbose errors. The first immediate benefit is that for the first time we got very precise location of issues (arg number in a keyword in its context, ...). Second, in order to do this we had to parse log-format and unique-id-format a bit earlier, so that was a great opportunity for doing so when the directives are encountered (unless it's a default section). This way, the recorded line numbers for these args are the ones of the place where the log format is declared, not the end of the file. Userlists report slightly more information now. They're the only remaining ones in the ACL resolving function.
2013-04-02 10:34:32 -04:00
struct arg *arg;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
const char *beg;
const char *ptr_err = NULL;
int min_arg;
MEDIUM: arg: make make_arg_list() stop after its own arguments The main problem we're having with argument parsing is that at the moment the caller looks for the first character looking like an end of arguments (')') and calls make_arg_list() on the sub-string inside the parenthesis. Let's first change the way it works so that make_arg_list() also consumes the parenthesis and returns the pointer to the first char not consumed. This will later permit to refine each argument parsing. For now there is no functional change.
2020-02-14 02:40:37 -05:00
int empty;
BUG/MEDIUM: arg: ensure that we properly unlink unresolved arguments on error If make_arg_list() fails to process an argument after having queued an unresolvable one, it frees the allocated argument list but doesn't remove the referenced args from the arg list. This causes a use after free or a double free if the same location was reused, during the deinit phase upon exit after reporting the error. Since it's not easy to properly unlinked all elements, we only release the args block if none of them was queued in the list.
2017-04-12 16:32:04 -04:00
struct arg_list *new_al = al;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
MAJOR: sample: maintain a per-proxy list of the fetch args to resolve While ACL args were resolved after all the config was parsed, it was not the case with sample fetch args because they're almost everywhere now. The issue is that ACLs now solely rely on sample fetches, so their args resolving doesn't work anymore. And many fetches involving a server, a proxy or a userlist don't work at all. The real issue is that at the bottom layers we have no information about proxies, line numbers, even ACLs in order to report understandable errors, and that at the top layers we have no visibility over the locations where fetches are referenced (think log node). After failing multiple unsatisfying solutions attempts, we now have a new concept of args list. The principle is that every proxy has a list head which contains a number of indications such as the config keyword, the context where it's used, the file and line number, etc... and a list of arguments. This list head is of the same type as the elements, so it serves as a template for adding new elements. This way, it is filled from top to bottom by the callers with the information they have (eg: line numbers, ACL name, ...) and the lower layers just have to duplicate it and add an element when they face an argument they cannot resolve yet. Then at the end of the configuration parsing, a loop passes over each proxy's list and resolves all the args in sequence. And this way there is all necessary information to report verbose errors. The first immediate benefit is that for the first time we got very precise location of issues (arg number in a keyword in its context, ...). Second, in order to do this we had to parse log-format and unique-id-format a bit earlier, so that was a great opportunity for doing so when the directives are encountered (unless it's a default section). This way, the recorded line numbers for these args are the ones of the place where the log format is declared, not the end of the file. Userlists report slightly more information now. They're the only remaining ones in the ACL resolving function.
2013-04-02 10:34:32 -04:00
*argp = NULL;
MEDIUM: arg: make make_arg_list() stop after its own arguments The main problem we're having with argument parsing is that at the moment the caller looks for the first character looking like an end of arguments (')') and calls make_arg_list() on the sub-string inside the parenthesis. Let's first change the way it works so that make_arg_list() also consumes the parenthesis and returns the pointer to the first char not consumed. This will later permit to refine each argument parsing. For now there is no functional change.
2020-02-14 02:40:37 -05:00
empty = 0;
if (!len || *in != '(') {
/* it's already not for us, stop here */
empty = 1;
len = 0;
} else {
/* skip opening parenthesis */
len--;
in++;
}
MEDIUM: args: use #define to specify the number of bits used by arg types and counts This is in order to add new types. This patch does not change anything else. Two remaining (harmless) occurrences of a count of 8 instead of 7 were fixed by this patch : empty_arg_list[] and the for() loop counting args.
2015-01-19 12:44:07 -05:00
min_arg = mask & ARGM_MASK;
mask >>= ARGM_BITS;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
pos = 0;
MEDIUM: args: use #define to specify the number of bits used by arg types and counts This is in order to add new types. This patch does not change anything else. Two remaining (harmless) occurrences of a count of 8 instead of 7 were fixed by this patch : empty_arg_list[] and the for() loop counting args.
2015-01-19 12:44:07 -05:00
/* find between 0 and NBARGS the max number of args supported by the mask */
for (nbarg = 0; nbarg < ARGM_NBARGS && ((mask >> (nbarg * ARGT_BITS)) & ARGT_MASK); nbarg++);
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
if (!nbarg)
goto end_parse;
/* Note: an empty input string contains an empty argument if this argument
* is marked mandatory. Otherwise we can ignore it.
*/
MEDIUM: arg: make make_arg_list() stop after its own arguments The main problem we're having with argument parsing is that at the moment the caller looks for the first character looking like an end of arguments (')') and calls make_arg_list() on the sub-string inside the parenthesis. Let's first change the way it works so that make_arg_list() also consumes the parenthesis and returns the pointer to the first char not consumed. This will later permit to refine each argument parsing. For now there is no functional change.
2020-02-14 02:40:37 -05:00
if (empty && !min_arg)
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
goto end_parse;
CLEANUP: Do not use a fixed type for 'sizeof' in 'calloc' Changes performed using the following coccinelle patch: @@ type T; expression E; expression t; @@ ( t = calloc(E, sizeof(*t)) | - t = calloc(E, sizeof(T)) + t = calloc(E, sizeof(*t)) ) Looking through the commit history, grepping for coccinelle shows that the same replacement with a different patch was already performed in the past in commit 02779b6263a177b1e462e53db6eaf57bcda574bc.
2020-09-12 14:26:43 -04:00
arg = *argp = calloc(nbarg + 1, sizeof(**argp));
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
BUG/MINOR: http: Missing calloc return value check in make_arg_list A memory allocation failure happening in make_arg_list when trying to allocate the argument list would have resulted in a crash. This function is only called during configuration parsing. It was raised in GitHub issue #1233. It could be backported to all stable branches.
2021-05-19 06:00:54 -04:00
if (!arg)
goto alloc_err;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
/* Note: empty arguments after a comma always exist. */
while (pos < nbarg) {
MAJOR: arg: converts uint and sint in sint This patch removes the 32 bits unsigned integer and the 32 bit signed integer. It replaces these types by a unique type 64 bit signed.
2015-07-20 11:45:02 -04:00
unsigned int uint;
MEDIUM: arg: make make_arg_list() support quotes in arguments Now it becomes possible to reuse the quotes within arguments, allowing the parser to distinguish a ',' or ')' that is part of the value from one which delimits the argument. In addition, ',' and ')' may be escaped using a backslash. However, it is also important to keep in mind that just like in shell, quotes are first resolved by the word tokenizer, so in order to pass quotes that are visible to the argument parser, a second level is needed, either using backslash escaping, or by using an alternate type. For example, it's possible to write this to append a comma: http-request add-header paren-comma-paren "%[str('(--,--)')]" or this: http-request add-header paren-comma-paren '%[str("(--,--)")]' or this: http-request add-header paren-comma-paren %[str(\'(--,--)\')] or this: http-request add-header paren-comma-paren %[str(\"(--,--)\")] or this: http-request add-header paren-comma-paren %[str(\"(\"--\',\'--\")\")] Note that due to the wide use of '\' in front of parenthesis in regex, the backslash character will purposely *not* escape parenthesis, so that '\)' placed in quotes is passed verbatim to a regex engine.
2020-02-14 07:37:20 -05:00
int squote = 0, dquote = 0;
char *out;
chunk_reset(&trash);
out = trash.area;
while (len && *in && trash.data < trash.size - 1) {
if (*in == '"' && !squote) { /* double quote outside single quotes */
if (dquote)
dquote = 0;
else
dquote = 1;
in++; len--;
continue;
}
else if (*in == '\'' && !dquote) { /* single quote outside double quotes */
if (squote)
squote = 0;
else
squote = 1;
in++; len--;
continue;
}
else if (*in == '\\' && !squote && len != 1) {
/* '\', ', ' ', '"' support being escaped by '\' */
if (len == 1 || in[1] == 0)
goto unquote_err;
if (in[1] == '\\' || in[1] == ' ' || in[1] == '"' || in[1] == '\'') {
in++; len--;
*out++ = *in;
}
else if (in[1] == 'r') {
in++; len--;
*out++ = '\r';
}
else if (in[1] == 'n') {
in++; len--;
*out++ = '\n';
}
else if (in[1] == 't') {
in++; len--;
*out++ = '\t';
}
else {
/* just a lone '\' */
*out++ = *in;
}
in++; len--;
}
else {
if (!squote && !dquote && (*in == ',' || *in == ')')) {
/* end of argument */
break;
}
/* verbatim copy */
*out++ = *in++;
len--;
}
trash.data = out - trash.area;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
}
BUG/MINOR: arg: report an error if an argument is larger than bufsize Commit ef21facd99 ("MEDIUM: arg: make make_arg_list() support quotes in arguments") removed the chunk_strncpy() to fill the trash buffer as the input is being parsed, and accidently dropped the jump to the error path in case the argument is too large, which is now fixed. No backport is needed, this is for 2.2. This addresses issue #502.
2020-02-15 08:54:28 -05:00
BUG/MINOR: arg: fix again incorrect argument length check Recent commit 807aef8a14 ("BUG/MINOR: arg: report an error if an argument is larger than bufsize") aimed at fixing the argument length check but relied on the fact that the end of string was not reached, except that it forgot to consider the delimiters (comma and parenthesis) which are valid conditions to break out of the loop. This used to break simple expressions like "hdr(xff,1)". Thanks to Jrme for reporting this. No backport is needed.
2020-02-16 04:46:37 -05:00
if (len && *in && *in != ',' && *in != ')')
BUG/MINOR: arg: report an error if an argument is larger than bufsize Commit ef21facd99 ("MEDIUM: arg: make make_arg_list() support quotes in arguments") removed the chunk_strncpy() to fill the trash buffer as the input is being parsed, and accidently dropped the jump to the error path in case the argument is too large, which is now fixed. No backport is needed, this is for 2.2. This addresses issue #502.
2020-02-15 08:54:28 -05:00
goto buffer_err;
MEDIUM: arg: make make_arg_list() support quotes in arguments Now it becomes possible to reuse the quotes within arguments, allowing the parser to distinguish a ',' or ')' that is part of the value from one which delimits the argument. In addition, ',' and ')' may be escaped using a backslash. However, it is also important to keep in mind that just like in shell, quotes are first resolved by the word tokenizer, so in order to pass quotes that are visible to the argument parser, a second level is needed, either using backslash escaping, or by using an alternate type. For example, it's possible to write this to append a comma: http-request add-header paren-comma-paren "%[str('(--,--)')]" or this: http-request add-header paren-comma-paren '%[str("(--,--)")]' or this: http-request add-header paren-comma-paren %[str(\'(--,--)\')] or this: http-request add-header paren-comma-paren %[str(\"(--,--)\")] or this: http-request add-header paren-comma-paren %[str(\"(\"--\',\'--\")\")] Note that due to the wide use of '\' in front of parenthesis in regex, the backslash character will purposely *not* escape parenthesis, so that '\)' placed in quotes is passed verbatim to a regex engine.
2020-02-14 07:37:20 -05:00
trash.area[trash.data] = 0;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
MEDIUM: args: use #define to specify the number of bits used by arg types and counts This is in order to add new types. This patch does not change anything else. Two remaining (harmless) occurrences of a count of 8 instead of 7 were fixed by this patch : empty_arg_list[] and the for() loop counting args.
2015-01-19 12:44:07 -05:00
arg->type = (mask >> (pos * ARGT_BITS)) & ARGT_MASK;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
switch (arg->type) {
case ARGT_SINT:
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
if (!trash.data) // empty number
MINOR: arg: improve error reporting on invalid arguments It's important to report the faulty argument position and to distinguish between empty arguments and wrong ones. Integers were not properly tested either, now their parsing has been improved to report use of incorrect characters.
2012-04-27 10:32:26 -04:00
goto empty_err;
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
beg = trash.area;
arg->data.sint = read_int64(&beg, trash.area + trash.data);
if (beg < trash.area + trash.data)
MINOR: arg: improve error reporting on invalid arguments It's important to report the faulty argument position and to distinguish between empty arguments and wrong ones. Integers were not properly tested either, now their parsing has been improved to report use of incorrect characters.
2012-04-27 10:32:26 -04:00
goto parse_err;
MAJOR: arg: converts uint and sint in sint This patch removes the 32 bits unsigned integer and the 32 bit signed integer. It replaces these types by a unique type 64 bit signed.
2015-07-20 11:45:02 -04:00
arg->type = ARGT_SINT;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
break;
case ARGT_FE:
case ARGT_BE:
case ARGT_TAB:
case ARGT_SRV:
case ARGT_USR:
MINOR: args: implement a new arg type for regex : ARGT_REG This one will be used when a regex is expected. It is automatically resolved after the parsing and compiled into a regex. Some optional flags are supported in the type-specific flags that should be set by the optional arg checker. One is used during the regex compilation : ARGF_REG_ICASE to ignore case.
2015-01-19 13:00:58 -05:00
case ARGT_REG:
BUG/MEDIUM: ensure that unresolved arguments are freed exactly once When passing arguments to ACLs and samples, some types are stored as strings then resolved later after config parsing is done. Upon exit, the arguments need to be freed only if the string was not resolved yet. At the moment we can encounter double free during deinit() because some arguments (eg: userlists) are freed once as their own type and once as a string. The solution consists in adding an "unresolved" flag to the args to say whether the value is still held in the <str> part or is final. This could be debugged thanks to a useful bug report from Sander Klein.
2012-06-01 04:38:29 -04:00
/* These argument types need to be stored as strings during
* parsing then resolved later.
*/
arg->unresolved = 1;
BUG/MEDIUM: arg: ensure that we properly unlink unresolved arguments on error If make_arg_list() fails to process an argument after having queued an unresolvable one, it frees the allocated argument list but doesn't remove the referenced args from the arg list. This causes a use after free or a double free if the same location was reused, during the deinit phase upon exit after reporting the error. Since it's not easy to properly unlinked all elements, we only release the args block if none of them was queued in the list.
2017-04-12 16:32:04 -04:00
new_al = arg_list_add(al, arg, pos);
MAJOR: sample: maintain a per-proxy list of the fetch args to resolve While ACL args were resolved after all the config was parsed, it was not the case with sample fetch args because they're almost everywhere now. The issue is that ACLs now solely rely on sample fetches, so their args resolving doesn't work anymore. And many fetches involving a server, a proxy or a userlist don't work at all. The real issue is that at the bottom layers we have no information about proxies, line numbers, even ACLs in order to report understandable errors, and that at the top layers we have no visibility over the locations where fetches are referenced (think log node). After failing multiple unsatisfying solutions attempts, we now have a new concept of args list. The principle is that every proxy has a list head which contains a number of indications such as the config keyword, the context where it's used, the file and line number, etc... and a list of arguments. This list head is of the same type as the elements, so it serves as a template for adding new elements. This way, it is filled from top to bottom by the callers with the information they have (eg: line numbers, ACL name, ...) and the lower layers just have to duplicate it and add an element when they face an argument they cannot resolve yet. Then at the end of the configuration parsing, a loop passes over each proxy's list and resolves all the args in sequence. And this way there is all necessary information to report verbose errors. The first immediate benefit is that for the first time we got very precise location of issues (arg number in a keyword in its context, ...). Second, in order to do this we had to parse log-format and unique-id-format a bit earlier, so that was a great opportunity for doing so when the directives are encountered (unless it's a default section). This way, the recorded line numbers for these args are the ones of the place where the log format is declared, not the end of the file. Userlists report slightly more information now. They're the only remaining ones in the ACL resolving function.
2013-04-02 10:34:32 -04:00
BUG/MEDIUM: ensure that unresolved arguments are freed exactly once When passing arguments to ACLs and samples, some types are stored as strings then resolved later after config parsing is done. Upon exit, the arguments need to be freed only if the string was not resolved yet. At the moment we can encounter double free during deinit() because some arguments (eg: userlists) are freed once as their own type and once as a string. The solution consists in adding an "unresolved" flag to the args to say whether the value is still held in the <str> part or is final. This could be debugged thanks to a useful bug report from Sander Klein.
2012-06-01 04:38:29 -04:00
/* fall through */
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
case ARGT_STR:
/* all types that must be resolved are stored as strings
* during the parsing. The caller must at one point resolve
* them and free the string.
*/
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
arg->data.str.area = my_strndup(trash.area, trash.data);
arg->data.str.data = trash.data;
arg->data.str.size = trash.data + 1;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
break;
case ARGT_IPV4:
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
if (!trash.data) // empty address
MINOR: arg: improve error reporting on invalid arguments It's important to report the faulty argument position and to distinguish between empty arguments and wrong ones. Integers were not properly tested either, now their parsing has been improved to report use of incorrect characters.
2012-04-27 10:32:26 -04:00
goto empty_err;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
if (inet_pton(AF_INET, trash.area, &arg->data.ipv4) <= 0)
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
goto parse_err;
break;
case ARGT_MSK4:
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
if (!trash.data) // empty mask
MINOR: arg: improve error reporting on invalid arguments It's important to report the faulty argument position and to distinguish between empty arguments and wrong ones. Integers were not properly tested either, now their parsing has been improved to report use of incorrect characters.
2012-04-27 10:32:26 -04:00
goto empty_err;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
if (!str2mask(trash.area, &arg->data.ipv4))
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
goto parse_err;
arg->type = ARGT_IPV4;
break;
case ARGT_IPV6:
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
if (!trash.data) // empty address
MINOR: arg: improve error reporting on invalid arguments It's important to report the faulty argument position and to distinguish between empty arguments and wrong ones. Integers were not properly tested either, now their parsing has been improved to report use of incorrect characters.
2012-04-27 10:32:26 -04:00
goto empty_err;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
if (inet_pton(AF_INET6, trash.area, &arg->data.ipv6) <= 0)
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
goto parse_err;
break;
MINOR: config: Add support for ARGT_MSK6 This commit adds support for ARGT_MSK6 to make_arg_list().
2018-01-25 10:24:50 -05:00
case ARGT_MSK6:
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
if (!trash.data) // empty mask
MINOR: config: Add support for ARGT_MSK6 This commit adds support for ARGT_MSK6 to make_arg_list().
2018-01-25 10:24:50 -05:00
goto empty_err;
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
if (!str2mask6(trash.area, &arg->data.ipv6))
MINOR: config: Add support for ARGT_MSK6 This commit adds support for ARGT_MSK6 to make_arg_list().
2018-01-25 10:24:50 -05:00
goto parse_err;
arg->type = ARGT_IPV6;
break;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
case ARGT_TIME:
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
if (!trash.data) // empty time
MINOR: arg: improve error reporting on invalid arguments It's important to report the faulty argument position and to distinguish between empty arguments and wrong ones. Integers were not properly tested either, now their parsing has been improved to report use of incorrect characters.
2012-04-27 10:32:26 -04:00
goto empty_err;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
ptr_err = parse_time_err(trash.area, &uint, TIME_UNIT_MS);
MEDIUM: tools: improve time format error detection As reported in GH issue #109 and in discourse issue https://discourse.haproxy.org/t/haproxy-returns-408-or-504-error-when-timeout-client-value-is-every-25d the time parser doesn't error on overflows nor underflows. This is a recurring problem which additionally has the bad taste of taking a long time before hitting the user. This patch makes parse_time_err() return special error codes for overflows and underflows, and adds the control in the call places to report suitable errors depending on the requested unit. In practice, underflows are almost never returned as the parsing function takes care of rounding values up, so this might possibly happen on 64-bit overflows returning exactly zero after rounding though. It is not really possible to cut the patch into pieces as it changes the function's API, hence all callers. Tests were run on about every relevant part (cookie maxlife/maxidle, server inter, stats timeout, timeout*, cli's set timeout command, tcp-request/response inspect-delay).
2019-06-07 13:00:37 -04:00
if (ptr_err) {
if (ptr_err == PARSE_TIME_OVER || ptr_err == PARSE_TIME_UNDER)
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
ptr_err = trash.area;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
goto parse_err;
MEDIUM: tools: improve time format error detection As reported in GH issue #109 and in discourse issue https://discourse.haproxy.org/t/haproxy-returns-408-or-504-error-when-timeout-client-value-is-every-25d the time parser doesn't error on overflows nor underflows. This is a recurring problem which additionally has the bad taste of taking a long time before hitting the user. This patch makes parse_time_err() return special error codes for overflows and underflows, and adds the control in the call places to report suitable errors depending on the requested unit. In practice, underflows are almost never returned as the parsing function takes care of rounding values up, so this might possibly happen on 64-bit overflows returning exactly zero after rounding though. It is not really possible to cut the patch into pieces as it changes the function's API, hence all callers. Tests were run on about every relevant part (cookie maxlife/maxidle, server inter, stats timeout, timeout*, cli's set timeout command, tcp-request/response inspect-delay).
2019-06-07 13:00:37 -04:00
}
MAJOR: arg: converts uint and sint in sint This patch removes the 32 bits unsigned integer and the 32 bit signed integer. It replaces these types by a unique type 64 bit signed.
2015-07-20 11:45:02 -04:00
arg->data.sint = uint;
arg->type = ARGT_SINT;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
break;
case ARGT_SIZE:
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
if (!trash.data) // empty size
MINOR: arg: improve error reporting on invalid arguments It's important to report the faulty argument position and to distinguish between empty arguments and wrong ones. Integers were not properly tested either, now their parsing has been improved to report use of incorrect characters.
2012-04-27 10:32:26 -04:00
goto empty_err;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
ptr_err = parse_size_err(trash.area, &uint);
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
if (ptr_err)
goto parse_err;
MAJOR: arg: converts uint and sint in sint This patch removes the 32 bits unsigned integer and the 32 bit signed integer. It replaces these types by a unique type 64 bit signed.
2015-07-20 11:45:02 -04:00
arg->data.sint = uint;
arg->type = ARGT_SINT;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
break;
MINOR: arg: Add support for ARGT_PBUF_FNUM arg type. This new argument type is used to parse Protocol Buffers field number with dotted notation (e.g: 1.2.3.4).
2019-02-25 09:20:35 -05:00
case ARGT_PBUF_FNUM:
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
if (!trash.data)
MINOR: sample: Rework gRPC converter code. For now on, "ungrpc" may take a second optional argument to provide the protocol buffers types used to encode the field value to be extracted. When absent the field value is extracted as a binary sample which may then followed by others converters like "hex" which takes binary as input sample. When this second argument is a type which does not match the one found by "ungrpc", this field is considered as not found even if present. With this patch we also remove the useless "varint" and "svarint" converters. Update the documentation about "ungrpc" converters.
2019-03-04 13:03:48 -05:00
goto empty_err;
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
if (!parse_dotted_uints(trash.area, &arg->data.fid.ids, &arg->data.fid.sz))
MINOR: arg: Add support for ARGT_PBUF_FNUM arg type. This new argument type is used to parse Protocol Buffers field number with dotted notation (e.g: 1.2.3.4).
2019-02-25 09:20:35 -05:00
goto parse_err;
break;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
/* FIXME: other types need to be implemented here */
default:
MINOR: arg: improve error reporting on invalid arguments It's important to report the faulty argument position and to distinguish between empty arguments and wrong ones. Integers were not properly tested either, now their parsing has been improved to report use of incorrect characters.
2012-04-27 10:32:26 -04:00
goto not_impl;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
}
pos++;
arg++;
/* don't go back to parsing if we reached end */
MEDIUM: arg: make make_arg_list() stop after its own arguments The main problem we're having with argument parsing is that at the moment the caller looks for the first character looking like an end of arguments (')') and calls make_arg_list() on the sub-string inside the parenthesis. Let's first change the way it works so that make_arg_list() also consumes the parenthesis and returns the pointer to the first char not consumed. This will later permit to refine each argument parsing. For now there is no functional change.
2020-02-14 02:40:37 -05:00
if (!len || !*in || *in == ')' || pos >= nbarg)
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
break;
/* skip comma */
in++; len--;
}
end_parse:
if (pos < min_arg) {
/* not enough arguments */
MINOR: standard: make memprintf() support a NULL destination Doing so removes many checks that were systematically made because the callees don't know if the caller passed a valid pointer.
2012-09-20 13:43:14 -04:00
memprintf(err_msg,
MINOR: arg: improve wording on error reporting We make the distinction between missing too many arguments and no arguments supported.
2013-12-12 18:38:47 -05:00
"missing arguments (got %d/%d), type '%s' expected",
MEDIUM: args: use #define to specify the number of bits used by arg types and counts This is in order to add new types. This patch does not change anything else. Two remaining (harmless) occurrences of a count of 8 instead of 7 were fixed by this patch : empty_arg_list[] and the for() loop counting args.
2015-01-19 12:44:07 -05:00
pos, min_arg, arg_type_names[(mask >> (pos * ARGT_BITS)) & ARGT_MASK]);
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
goto err;
}
MEDIUM: arg: make make_arg_list() stop after its own arguments The main problem we're having with argument parsing is that at the moment the caller looks for the first character looking like an end of arguments (')') and calls make_arg_list() on the sub-string inside the parenthesis. Let's first change the way it works so that make_arg_list() also consumes the parenthesis and returns the pointer to the first char not consumed. This will later permit to refine each argument parsing. For now there is no functional change.
2020-02-14 02:40:37 -05:00
if (empty) {
/* nothing to do */
} else if (*in == ')') {
/* skip the expected closing parenthesis */
in++;
} else {
MINOR: standard: make memprintf() support a NULL destination Doing so removes many checks that were systematically made because the callees don't know if the caller passed a valid pointer.
2012-09-20 13:43:14 -04:00
/* the caller is responsible for freeing this message */
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
char *word = (len > 0) ? my_strndup(in, len) : (char *)in;
MINOR: arg: improve the error message on missing closing parenthesis When the closing brace is missing after an argument (acl, ...), the error may report something like "expected ')' before ''". Let's just drop "before ''" when the final word is empty to make the message a bit clearer.
2021-05-06 08:50:30 -04:00
if (*word)
memprintf(err_msg, "expected ')' before '%s'", word);
else
memprintf(err_msg, "expected ')'");
MEDIUM: arg: make make_arg_list() stop after its own arguments The main problem we're having with argument parsing is that at the moment the caller looks for the first character looking like an end of arguments (')') and calls make_arg_list() on the sub-string inside the parenthesis. Let's first change the way it works so that make_arg_list() also consumes the parenthesis and returns the pointer to the first char not consumed. This will later permit to refine each argument parsing. For now there is no functional change.
2020-02-14 02:40:37 -05:00
if (len > 0)
free(word);
CLEANUP: assorted typo fixes in the code and comments This is 11th iteration of typo fixes
2020-07-05 07:36:08 -04:00
/* when we're missing a right paren, the empty part preceding
MEDIUM: arg: make make_arg_list() stop after its own arguments The main problem we're having with argument parsing is that at the moment the caller looks for the first character looking like an end of arguments (')') and calls make_arg_list() on the sub-string inside the parenthesis. Let's first change the way it works so that make_arg_list() also consumes the parenthesis and returns the pointer to the first char not consumed. This will later permit to refine each argument parsing. For now there is no functional change.
2020-02-14 02:40:37 -05:00
* already created an empty arg, adding one to the position, so
* let's fix the reporting to avoid being confusing.
*/
if (pos > 1)
pos--;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
goto err;
}
/* note that pos might be < nbarg and this is not an error, it's up to the
* caller to decide what to do with optional args.
*/
if (err_arg)
*err_arg = pos;
MEDIUM: arg: make make_arg_list() stop after its own arguments The main problem we're having with argument parsing is that at the moment the caller looks for the first character looking like an end of arguments (')') and calls make_arg_list() on the sub-string inside the parenthesis. Let's first change the way it works so that make_arg_list() also consumes the parenthesis and returns the pointer to the first char not consumed. This will later permit to refine each argument parsing. For now there is no functional change.
2020-02-14 02:40:37 -05:00
if (end_ptr)
*end_ptr = in;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
return pos;
err:
BUG/MEDIUM: arg: ensure that we properly unlink unresolved arguments on error If make_arg_list() fails to process an argument after having queued an unresolvable one, it frees the allocated argument list but doesn't remove the referenced args from the arg list. This causes a use after free or a double free if the same location was reused, during the deinit phase upon exit after reporting the error. Since it's not easy to properly unlinked all elements, we only release the args block if none of them was queued in the list.
2017-04-12 16:32:04 -04:00
if (new_al == al) {
/* only free the arg area if we have not queued unresolved args
* still pointing to it.
*/
free(*argp);
}
BUG/MEDIUM: args: fix double free on error path in argument expression parser William Lallemand reported a double free on the args parser used in fetches and ACLs. The cause is that the arg expression is not fully initialized nor deinitialized when killed and that one of the pointers was already freed once in certain error conditions. Simply set it to NULL after the first call to free(). The bug was apparently introduced in 1.5-dev9 with commit 2ac5718 (MEDIUM: add a new typed argument list parsing framework).
2013-12-06 09:30:05 -05:00
*argp = NULL;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
if (err_arg)
*err_arg = pos;
MEDIUM: arg: make make_arg_list() stop after its own arguments The main problem we're having with argument parsing is that at the moment the caller looks for the first character looking like an end of arguments (')') and calls make_arg_list() on the sub-string inside the parenthesis. Let's first change the way it works so that make_arg_list() also consumes the parenthesis and returns the pointer to the first char not consumed. This will later permit to refine each argument parsing. For now there is no functional change.
2020-02-14 02:40:37 -05:00
if (end_ptr)
*end_ptr = in;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
return -1;
MINOR: arg: improve error reporting on invalid arguments It's important to report the faulty argument position and to distinguish between empty arguments and wrong ones. Integers were not properly tested either, now their parsing has been improved to report use of incorrect characters.
2012-04-27 10:32:26 -04:00
empty_err:
BUG/MEDIUM: arg: empty args list must be dropped Before commit 80b53ffb1 ("MEDIUM: arg: make make_arg_list() stop after its own arguments"), consumers of arguments would measure the length of the string between the first opening and closing parenthesis before calling make_arg_list(), and this latter one would detect an empty string early by len==0 and would not allocate an argument list. Since that commit, this has a changed a bit because the argument parser is now the one in charge for delimiting the argument string, so the early test cannot be used anymore. But the argument list is still allocated, and despite the number of arguments being returned, consumers do not necessarily rely on it but instead they rely on the non-null arg_p pointer that used to be allocated only if at least one argument was present. But as it's now always allocated, the first argument always carries the first argument's type with an empty value, which confuses all functions that take a unique optional argument (such as uuid()). The proper long term solution would be to always use the returned argument count, but at least we can make sure the function always returns an empty argument list when fed with an empty set of parenthesis, as it always used to do. This is what this patch does. This fix must be backported to 2.2 and fixes github issue #763. Thanks to Luke Seelenbinder for reporting the problem.
2020-07-21 09:44:38 -04:00
/* If we've only got an empty set of parenthesis with nothing
* in between, there is no arg at all.
*/
if (!pos) {
CLEANUP: tree-wide: replace free(x);x=NULL with ha_free(&x) This makes the code more readable and less prone to copy-paste errors. In addition, it allows to place some __builtin_constant_p() predicates to trigger a link-time error in case the compiler knows that the freed area is constant. It will also produce compile-time error if trying to free something that is not a regular pointer (e.g. a function). The DEBUG_MEM_STATS macro now also defines an instance for ha_free() so that all these calls can be checked. 178 occurrences were converted. The vast majority of them were handled by the following Coccinelle script, some slightly refined to better deal with "&*x" or with long lines: @ rule @ expression E; @@ - free(E); - E = NULL; + ha_free(&E); It was verified that the resulting code is the same, more or less a handful of cases where the compiler optimized slightly differently the temporary variable that holds the copy of the pointer. A non-negligible amount of {free(str);str=NULL;str_len=0;} are still present in the config part (mostly header names in proxies). These ones should also be cleaned for the same reasons, and probably be turned into ist strings.
2021-02-20 04:46:51 -05:00
ha_free(argp);
BUG/MEDIUM: arg: empty args list must be dropped Before commit 80b53ffb1 ("MEDIUM: arg: make make_arg_list() stop after its own arguments"), consumers of arguments would measure the length of the string between the first opening and closing parenthesis before calling make_arg_list(), and this latter one would detect an empty string early by len==0 and would not allocate an argument list. Since that commit, this has a changed a bit because the argument parser is now the one in charge for delimiting the argument string, so the early test cannot be used anymore. But the argument list is still allocated, and despite the number of arguments being returned, consumers do not necessarily rely on it but instead they rely on the non-null arg_p pointer that used to be allocated only if at least one argument was present. But as it's now always allocated, the first argument always carries the first argument's type with an empty value, which confuses all functions that take a unique optional argument (such as uuid()). The proper long term solution would be to always use the returned argument count, but at least we can make sure the function always returns an empty argument list when fed with an empty set of parenthesis, as it always used to do. This is what this patch does. This fix must be backported to 2.2 and fixes github issue #763. Thanks to Luke Seelenbinder for reporting the problem.
2020-07-21 09:44:38 -04:00
}
BUG/MINOR: arg: don't reject missing optional args Commit 80b53ffb1c ("MEDIUM: arg: make make_arg_list() stop after its own arguments") changed the way we detect the empty list because we cannot stop by looking up the closing parenthesis anymore, thus for the first missing arg we have to enter the parsing loop again. And there, finding an empty arg means we go to the empty_err label, where it was not initially planned to handle this condition. This results in %[date()] to fail while %[date] works. Let's simply check if we've reached the minimally supported args there (it used to be done during the function entry). Thanks to Jrme for reporting this issue. No backport is needed, this is 2.2-dev2+ only.
2020-02-28 10:41:29 -05:00
if (pos >= min_arg)
goto end_parse;
MINOR: standard: make memprintf() support a NULL destination Doing so removes many checks that were systematically made because the callees don't know if the caller passed a valid pointer.
2012-09-20 13:43:14 -04:00
memprintf(err_msg, "expected type '%s' at position %d, but got nothing",
MEDIUM: args: use #define to specify the number of bits used by arg types and counts This is in order to add new types. This patch does not change anything else. Two remaining (harmless) occurrences of a count of 8 instead of 7 were fixed by this patch : empty_arg_list[] and the for() loop counting args.
2015-01-19 12:44:07 -05:00
arg_type_names[(mask >> (pos * ARGT_BITS)) & ARGT_MASK], pos + 1);
MINOR: arg: improve error reporting on invalid arguments It's important to report the faulty argument position and to distinguish between empty arguments and wrong ones. Integers were not properly tested either, now their parsing has been improved to report use of incorrect characters.
2012-04-27 10:32:26 -04:00
goto err;
parse_err:
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
/* come here with the word attempted to parse in trash */
MINOR: standard: make memprintf() support a NULL destination Doing so removes many checks that were systematically made because the callees don't know if the caller passed a valid pointer.
2012-09-20 13:43:14 -04:00
memprintf(err_msg, "failed to parse '%s' as type '%s' at position %d",
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
trash.area, arg_type_names[(mask >> (pos * ARGT_BITS)) & ARGT_MASK], pos + 1);
MINOR: arg: improve error reporting on invalid arguments It's important to report the faulty argument position and to distinguish between empty arguments and wrong ones. Integers were not properly tested either, now their parsing has been improved to report use of incorrect characters.
2012-04-27 10:32:26 -04:00
goto err;
not_impl:
MINOR: standard: make memprintf() support a NULL destination Doing so removes many checks that were systematically made because the callees don't know if the caller passed a valid pointer.
2012-09-20 13:43:14 -04:00
memprintf(err_msg, "parsing for type '%s' was not implemented, please report this bug",
MEDIUM: args: use #define to specify the number of bits used by arg types and counts This is in order to add new types. This patch does not change anything else. Two remaining (harmless) occurrences of a count of 8 instead of 7 were fixed by this patch : empty_arg_list[] and the for() loop counting args.
2015-01-19 12:44:07 -05:00
arg_type_names[(mask >> (pos * ARGT_BITS)) & ARGT_MASK]);
MINOR: arg: improve error reporting on invalid arguments It's important to report the faulty argument position and to distinguish between empty arguments and wrong ones. Integers were not properly tested either, now their parsing has been improved to report use of incorrect characters.
2012-04-27 10:32:26 -04:00
goto err;
MEDIUM: arg: copy parsed arguments into the trash instead of allocating them For each and every argument parsed by make_arg_list(), there was an strndup() call, just so that we have a trailing zero for most functions, and this temporary buffer is released afterwards except for strings where it is kept. Proceeding like this is not convenient because 1) it performs a huge malloc/free dance, and 2) it forces to decide upfront where the argument ends, which is what prevents commas and right parenthesis from being used. This patch makes the function copy the temporary argument into the trash instead, so that we avoid the malloc/free dance for most all non-string args (e.g. integers, addresses, time, size etc), and that we can later produce the contents on the fly while parsing the input. It adds a length check to make sure that the argument is not longer than the buffer size, which should obviously never be the case but who knows what people put in their configuration.
2020-02-14 05:34:35 -05:00
buffer_err:
memprintf(err_msg, "too small buffer size to store decoded argument %d, increase bufsize ?",
pos + 1);
goto err;
MEDIUM: arg: make make_arg_list() support quotes in arguments Now it becomes possible to reuse the quotes within arguments, allowing the parser to distinguish a ',' or ')' that is part of the value from one which delimits the argument. In addition, ',' and ')' may be escaped using a backslash. However, it is also important to keep in mind that just like in shell, quotes are first resolved by the word tokenizer, so in order to pass quotes that are visible to the argument parser, a second level is needed, either using backslash escaping, or by using an alternate type. For example, it's possible to write this to append a comma: http-request add-header paren-comma-paren "%[str('(--,--)')]" or this: http-request add-header paren-comma-paren '%[str("(--,--)")]' or this: http-request add-header paren-comma-paren %[str(\'(--,--)\')] or this: http-request add-header paren-comma-paren %[str(\"(--,--)\")] or this: http-request add-header paren-comma-paren %[str(\"(\"--\',\'--\")\")] Note that due to the wide use of '\' in front of parenthesis in regex, the backslash character will purposely *not* escape parenthesis, so that '\)' placed in quotes is passed verbatim to a regex engine.
2020-02-14 07:37:20 -05:00
unquote_err:
/* come here with the parsed part in <trash.area>:<trash.data> and the
* unparsable part in <in>.
*/
trash.area[trash.data] = 0;
memprintf(err_msg, "failed to parse '%s' after '%s' as type '%s' at position %d",
in, trash.area, arg_type_names[(mask >> (pos * ARGT_BITS)) & ARGT_MASK], pos + 1);
goto err;
BUG/MINOR: http: Missing calloc return value check in make_arg_list A memory allocation failure happening in make_arg_list when trying to allocate the argument list would have resulted in a crash. This function is only called during configuration parsing. It was raised in GitHub issue #1233. It could be backported to all stable branches.
2021-05-19 06:00:54 -04:00
alloc_err:
memprintf(err_msg, "out of memory");
goto err;
MEDIUM: add a new typed argument list parsing framework make_arg_list() builds an array of typed arguments with their values, that the caller describes how to parse. This will be used to support multiple arguments for ACLs and patterns, which is currently problematic and prevents ACLs and patterns from being merged. Up to 7 arguments types may be enumerated in a single 32-bit word, including their number of mandatory parts. At the moment, these files are not used yet, they're only built. Note that the 4-bit encoding for the type has left only one unused type!
2012-04-19 09:24:50 -04:00
}
Reference in a new issue Copy permalink