RepoMirrors
/
haproxy
mirror of http://git.haproxy.org/git/haproxy.git/
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
haproxy/include/proto/sample.h

166 lines
5.5 KiB
C
Raw Normal View History

[MEDIUM] Add pattern fetch management types and functions
2010-01-04 15:16:05 +00:00
/*
REORG: rename "pattern" files They're now called "sample" everywhere to match their description.
2012-04-27 19:52:18 +00:00
* include/proto/sample.h
* Functions for samples management.
[MEDIUM] Add pattern fetch management types and functions
2010-01-04 15:16:05 +00:00
*
* Copyright (C) 2009-2010 EXCELIANCE, Emeric Brun <ebrun@exceliance.fr>
REORG: rename "pattern" files They're now called "sample" everywhere to match their description.
2012-04-27 19:52:18 +00:00
* Copyright (C) 2012 Willy Tarreau <w@1wt.eu>
[MEDIUM] Add pattern fetch management types and functions
2010-01-04 15:16:05 +00:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, version 2.1
* exclusively.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
REORG: rename "pattern" files They're now called "sample" everywhere to match their description.
2012-04-27 19:52:18 +00:00
#ifndef _PROTO_SAMPLE_H
#define _PROTO_SAMPLE_H
[MEDIUM] Add pattern fetch management types and functions
2010-01-04 15:16:05 +00:00
REORG: rename "pattern" files They're now called "sample" everywhere to match their description.
2012-04-27 19:52:18 +00:00
#include <types/sample.h>
[MEDIUM] Add pattern fetch management types and functions
2010-01-04 15:16:05 +00:00
#include <types/stick_table.h>
MINOR: sample: move smp_to_type to sample.c This way it can be exported and reused anywhere else to report type names.
2014-02-07 11:14:54 +00:00
extern const char *smp_to_type[SMP_TYPES];
MINOR: configuration: File and line propagation This patch permits to communicate file and line of the configuration file at the configuration parser.
2014-02-11 13:00:19 +00:00
struct sample_expr *sample_parse_expr(char **str, int *idx, const char *file, int line, char **err, struct arg_list *al);
MINOR: sample: export the generic sample conversion parser just export function "find_sample_conv()" to prepare the generic sample conversion parser.
2013-11-21 09:51:50 +00:00
struct sample_conv *find_sample_conv(const char *kw, int len);
MAJOR: sample: pass a pointer to the session to each sample fetch function Many such function need a session, and till now they used to dereference the stream. Once we remove the stream from the embryonic session, this will not be possible anymore. So as of now, sample fetch functions will be called with this : - sess = NULL, strm = NULL : never - sess = valid, strm = NULL : tcp-req connection - sess = valid, strm = valid, strm->txn = NULL : tcp-req content - sess = valid, strm = valid, strm->txn = valid : http-req / http-res
2015-04-03 23:47:55 +00:00
struct sample *sample_process(struct proxy *px, struct session *sess,
struct stream *strm, unsigned int opt,
struct sample_expr *expr, struct sample *p);
CLEANUP: sample: generalize sample_fetch_string() as sample_fetch_as_type() This modification makes possible to use sample_fetch_string() in more places, where we might need to fetch sample values which are not plain strings. This way we don't need to fetch string, and convert it into another type afterwards. When using aliased types, the caller should explicitly check which exact type was returned (e.g. SMP_T_IPV4 or SMP_T_IPV6 for SMP_T_ADDR). All usages of sample_fetch_string() are converted to use new function.
2015-07-06 13:41:02 +00:00
struct sample *sample_fetch_as_type(struct proxy *px, struct session *sess,
MAJOR: sample: pass a pointer to the session to each sample fetch function Many such function need a session, and till now they used to dereference the stream. Once we remove the stream from the embryonic session, this will not be possible anymore. So as of now, sample fetch functions will be called with this : - sess = NULL, strm = NULL : never - sess = valid, strm = NULL : tcp-req connection - sess = valid, strm = valid, strm->txn = NULL : tcp-req content - sess = valid, strm = valid, strm->txn = valid : http-req / http-res
2015-04-03 23:47:55 +00:00
struct stream *strm, unsigned int opt,
CLEANUP: sample: generalize sample_fetch_string() as sample_fetch_as_type() This modification makes possible to use sample_fetch_string() in more places, where we might need to fetch sample values which are not plain strings. This way we don't need to fetch string, and convert it into another type afterwards. When using aliased types, the caller should explicitly check which exact type was returned (e.g. SMP_T_IPV4 or SMP_T_IPV6 for SMP_T_ADDR). All usages of sample_fetch_string() are converted to use new function.
2015-07-06 13:41:02 +00:00
struct sample_expr *expr, int smp_type);
REORG: use the name "sample" instead of "pattern" to designate extracted data This is mainly a massive renaming in the code to get it in line with the calling convention. Next patch will rename a few files to complete this operation.
2012-04-27 19:37:17 +00:00
void sample_register_fetches(struct sample_fetch_kw_list *psl);
void sample_register_convs(struct sample_conv_kw_list *psl);
MEDIUM: samples: use new flags to describe compatibility between fetches and their usages Samples fetches were relying on two flags SMP_CAP_REQ/SMP_CAP_RES to describe whether they were compatible with requests rules or with response rules. This was never reliable because we need a finer granularity (eg: an HTTP request method needs to parse an HTTP request, and is available past this point). Some fetches are also dependant on the context (eg: "hdr" uses request or response depending where it's involved, causing some abiguity). In order to solve this, we need to precisely indicate in fetches what they use, and their users will have to compare with what they have. So now we have a bunch of bits indicating where the sample is fetched in the processing chain, with a few variants indicating for some of them if it is permanent or volatile (eg: an HTTP status is stored into the transaction so it is permanent, despite being caught in the response contents). The fetches also have a second mask indicating their validity domain. This one is computed from a conversion table at registration time, so there is no need for doing it by hand. This validity domain consists in a bitmask with one bit set for each usage point in the processing chain. Some provisions were made for upcoming controls such as connection-based TCP rules which apply on top of the connection layer but before instantiating the session. Then everywhere a fetch is used, the bit for the control point is checked in the fetch's validity domain, and it becomes possible to finely ensure that a fetch will work or not. Note that we need these two separate bitfields because some fetches are usable both in request and response (eg: "hdr", "payload"). So the keyword will have a "use" field made of a combination of several SMP_USE_* values, which will be converted into a wider list of SMP_VAL_* flags. The knowledge of permanent vs dynamic information has disappeared for now, as it was never used. Later we'll probably reintroduce it differently when dealing with variables. Its only use at the moment could have been to avoid caching a dynamic rate measurement, but nothing is cached as of now.
2013-01-07 14:42:20 +00:00
const char *sample_src_names(unsigned int use);
MAJOR: acl: convert all ACL requires to SMP use+val instead of ->requires The ACLs now use the fetch's ->use and ->val to decide upon compatibility between the place where they are used and where the information are fetched. The code is capable of reporting warnings about very fine incompatibilities between certain fetches and an exact usage location, so it is expected that some new warnings will be emitted on some existing configurations. Two degrees of detection are provided : - detecting ACLs that never match - detecting keywords that are ignored All tests show that this seems to work well, though bugs are still possible.
2013-03-25 07:12:18 +00:00
const char *sample_ckp_names(unsigned int use);
MAJOR: acl: make all ACLs reference the fetch function via a sample. ACL fetch functions used to directly reference a fetch function. Now that all ACL fetches have their sample fetches equivalent, we can make ACLs reference a sample fetch keyword instead. In order to simplify the code, a sample keyword name may be NULL if it is the same as the ACL's, which is the most common case. A minor change appeared, http_auth always expects one argument though the ACL allowed it to be missing and reported as such afterwards, so fix the ACL to match this. This is not really a bug.
2013-01-11 14:49:37 +00:00
struct sample_fetch *find_sample_fetch(const char *kw, int len);
MINOR: sample: add function for browsing samples. This function is useful with the incoming lua functions.
2014-12-08 13:49:19 +00:00
struct sample_fetch *sample_fetch_getnext(struct sample_fetch *current, int *idx);
MINOR: converters: add function to browse converters This patch adds a fucntion to browse each converter. This is used with Lua for using the converters with a wrapper.
2015-03-10 22:56:48 +00:00
struct sample_conv *sample_conv_getnext(struct sample_conv *current, int *idx);
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 14:34:32 +00:00
int smp_resolve_args(struct proxy *p);
MEDIUM: acl: use the fetch syntax 'fetch(args),conv(),conv()' into the ACL keyword If the acl keyword is a "fetch", the dedicated parsing function "sample_parse_expr()" is used. Otherwise, the acl parsing function "parse_acl_expr()" is extended to understand the syntax of a series of converters placed after the "fetch" keyword. Before this patch, each acl uses a "struct sample_fetch" and executes it with the "<fetch>->process()" function. Now, the dedicated function "sample_process()" is called. These syntax are now avalaible: acl bad req.hdr(host),lower -m str www http-request redirect prefix /go-away if bad acl bad hdr_beg(host),lower www http-request redirect prefix /go-away if bad
2013-11-21 09:50:10 +00:00
int smp_expr_output_type(struct sample_expr *expr);
MINOR: sample: dont call the sample cast function "c_none" If the cast function to execute is c_none, dont execute it and return true. The function c_none, do nothing. This save a call.
2013-12-14 13:55:04 +00:00
int c_none(struct sample *smp);
MEDIUM: sample: Remove types SMP_T_CSTR and SMP_T_CBIN, replace it by SMP_F_CONST flags The operations applied on types SMP_T_CSTR and SMP_T_STR are the same, but the check code and the declarations are double, because it must declare action for SMP_T_C* and SMP_T_*. The declared actions and checks are the same. this complexify the code. Only the "conv" functions can change from "C*" to "*" Now, if a function needs to modify input string, it can call the new function smp_dup(). This one duplicate data in a trash buffer.
2013-12-16 23:20:33 +00:00
int smp_dup(struct sample *smp);
REORG: rename "pattern" files They're now called "sample" everywhere to match their description.
2012-04-27 19:52:18 +00:00
MEDIUM: acl: Last patch change the output type This patch remove the compatibility check from the input type and the match method. Now, it checks if a casts from the input type to output type exists and the pattern_exec_match() function apply casts before each pattern matching.
2013-12-06 14:36:54 +00:00
/*
* This function just apply a cast on sample. It returns 0 if the cast is not
* avalaible or if the cast fails, otherwise returns 1. It does not modify the
* input sample on failure.
*/
static inline
int sample_convert(struct sample *sample, int req_type)
{
MEDIUM: samples: Use the "struct sample_data" in the "struct sample" This patch remove the struct information stored both in the struct sample_data and in the striuct sample. Now, only thestruct sample_data contains data, and the struct sample use the struct sample_data for storing his own data.
2015-08-19 07:00:18 +00:00
if (!sample_casts[sample->data.type][req_type])
MEDIUM: acl: Last patch change the output type This patch remove the compatibility check from the input type and the match method. Now, it checks if a casts from the input type to output type exists and the pattern_exec_match() function apply casts before each pattern matching.
2013-12-06 14:36:54 +00:00
return 0;
MEDIUM: samples: Use the "struct sample_data" in the "struct sample" This patch remove the struct information stored both in the struct sample_data and in the striuct sample. Now, only thestruct sample_data contains data, and the struct sample use the struct sample_data for storing his own data.
2015-08-19 07:00:18 +00:00
if (sample_casts[sample->data.type][req_type] == c_none)
MINOR: sample: dont call the sample cast function "c_none" If the cast function to execute is c_none, dont execute it and return true. The function c_none, do nothing. This save a call.
2013-12-14 13:55:04 +00:00
return 1;
MEDIUM: samples: Use the "struct sample_data" in the "struct sample" This patch remove the struct information stored both in the struct sample_data and in the striuct sample. Now, only thestruct sample_data contains data, and the struct sample use the struct sample_data for storing his own data.
2015-08-19 07:00:18 +00:00
return sample_casts[sample->data.type][req_type](sample);
MEDIUM: acl: Last patch change the output type This patch remove the compatibility check from the input type and the match method. Now, it checks if a casts from the input type to output type exists and the pattern_exec_match() function apply casts before each pattern matching.
2013-12-06 14:36:54 +00:00
}
MINOR: sample: add a new helper to initialize the owner of a sample Since commit 6879ad3 ("MEDIUM: sample: fill the struct sample with the session, proxy and stream pointers") merged in 1.6-dev2, the sample contains the pointer to the stream and sample fetch functions as well as converters use it heavily. This requires from a lot of call places to initialize 4 fields, and it was even forgotten at a few places. This patch provides a convenient helper to initialize all these fields at once, making it easy to prepare a new sample from a previous one for example. A few call places were cleaned up to make use of it. It will be needed by further fixes. At one place in the Lua code, it was moved earlier because we used to call sample casts with a non completely initialized sample, which is not clean eventhough at the moment there are no consequences.
2016-03-10 15:15:46 +00:00
static inline
struct sample *smp_set_owner(struct sample *smp, struct proxy *px,
struct session *sess, struct stream *strm, int opt)
{
smp->px = px;
smp->sess = sess;
smp->strm = strm;
smp->opt = opt;
return smp;
}
MINOR: sample: implement smp_is_safe() and smp_make_safe() These functions ensure that the designated sample is "safe for use", which means that its size is known, its length is correct regarding its size, and that strings are properly zero-terminated. smp_is_safe() only checks (and optionally sets the trailing zero when needed and possible). smp_make_safe() will call smp_dup() after smp_is_safe() fails.
2016-08-09 09:37:54 +00:00
/* Returns 1 if a sample may be safely used. It performs a few checks on the
* string length versus size, same for the binary version, and ensures that
* strings are properly terminated by a zero. If this last point is not granted
* but the string is not const, then the \0 is appended. Otherwise it returns 0,
* meaning the caller may need to call smp_dup() before going further.
*/
static inline
int smp_is_safe(struct sample *smp)
{
switch (smp->data.type) {
case SMP_T_STR:
if ((smp->data.u.str.len < 0) ||
(smp->data.u.str.size && smp->data.u.str.len >= smp->data.u.str.size))
return 0;
if (smp->data.u.str.str[smp->data.u.str.len] == 0)
return 1;
if (!smp->data.u.str.size || (smp->flags & SMP_F_CONST))
return 0;
smp->data.u.str.str[smp->data.u.str.len] = 0;
return 1;
case SMP_T_BIN:
return (smp->data.u.str.len >= 0) &&
(!smp->data.u.str.size || smp->data.u.str.len <= smp->data.u.str.size);
default:
return 1;
}
}
/* checks that a sample may freely be used, or duplicates it to normalize it.
* Returns 1 on success, 0 if the sample must not be used. The function also
* checks for NULL to simplify the calling code.
*/
static inline
int smp_make_safe(struct sample *smp)
{
return smp && (smp_is_safe(smp) || smp_dup(smp));
}
MINOR: sample: provide smp_is_rw() and smp_make_rw() At some places, smp_dup() is inappropriately called to ensure a modification is possible while in fact we only need to ensure the sample may be modified in place. Let's provide smp_is_rw() to check for this capability and smp_make_rw() to perform the smp_dup() when it is not the case. Note that smp_is_rw() will also try to add the trailing zero on strings when needed if possible, to avoid a useless duplication.
2016-08-09 09:49:20 +00:00
/* Returns 1 if a sample may be safely modified in place. It performs a few
* checks on the string length versus size, same for the binary version, and
* ensures that strings are properly terminated by a zero, and of course that
* the size is allocate and that the SMP_F_CONST flag is not set. If only the
* trailing zero is missing, it is appended. Otherwise it returns 0, meaning
* the caller may need to call smp_dup() before going further.
*/
static inline
int smp_is_rw(struct sample *smp)
{
if (smp->flags & SMP_F_CONST)
return 0;
switch (smp->data.type) {
case SMP_T_STR:
if (!smp->data.u.str.size ||
smp->data.u.str.len < 0 ||
smp->data.u.str.len >= smp->data.u.str.size)
return 0;
if (smp->data.u.str.str[smp->data.u.str.len] != 0)
smp->data.u.str.str[smp->data.u.str.len] = 0;
return 1;
case SMP_T_BIN:
return smp->data.u.str.size &&
smp->data.u.str.len >= 0 &&
smp->data.u.str.len <= smp->data.u.str.size;
default:
return 1;
}
}
/* checks that a sample may freely be modified, or duplicates it to normalize
* it and make it R/W. Returns 1 on success, 0 if the sample must not be used.
* The function also checks for NULL to simplify the calling code.
*/
static inline
int smp_make_rw(struct sample *smp)
{
return smp && (smp_is_rw(smp) || smp_dup(smp));
}
REORG: rename "pattern" files They're now called "sample" everywhere to match their description.
2012-04-27 19:52:18 +00:00
#endif /* _PROTO_SAMPLE_H */