upstream/haproxy
1
0
Fork 0
mirror of https://github.com/haproxy/haproxy.git synced 2026-04-22 14:49:45 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 9
haproxy/include/haproxy/sample.h

186 lines
6.4 KiB
C
Raw Normal View History

[MEDIUM] Add pattern fetch management types and functions
2010-01-04 10:16:05 -05:00
/*
REORG: include: move sample.h to haproxy/sample{,-t}.h This one is particularly tricky to move because everyone uses it and it depends on a lot of other types. For example it cannot include arg-t.h and must absolutely only rely on forward declarations to avoid dependency loops between vars -> sample_data -> arg. In order to address this one, it would be nice to split the sample_data part out of sample.h.
2020-06-04 09:33:47 -04:00
* include/haproxy/sample.h
REORG: rename "pattern" files They're now called "sample" everywhere to match their description.
2012-04-27 15:52:18 -04:00
* Functions for samples management.
[MEDIUM] Add pattern fetch management types and functions
2010-01-04 10:16:05 -05: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 15:52:18 -04:00
* Copyright (C) 2012 Willy Tarreau <w@1wt.eu>
[MEDIUM] Add pattern fetch management types and functions
2010-01-04 10:16:05 -05: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: include: move sample.h to haproxy/sample{,-t}.h This one is particularly tricky to move because everyone uses it and it depends on a lot of other types. For example it cannot include arg-t.h and must absolutely only rely on forward declarations to avoid dependency loops between vars -> sample_data -> arg. In order to address this one, it would be nice to split the sample_data part out of sample.h.
2020-06-04 09:33:47 -04:00
#ifndef _HAPROXY_SAMPLE_H
#define _HAPROXY_SAMPLE_H
[MEDIUM] Add pattern fetch management types and functions
2010-01-04 10:16:05 -05:00
REORG: include: move sample.h to haproxy/sample{,-t}.h This one is particularly tricky to move because everyone uses it and it depends on a lot of other types. For example it cannot include arg-t.h and must absolutely only rely on forward declarations to avoid dependency loops between vars -> sample_data -> arg. In order to address this one, it would be nice to split the sample_data part out of sample.h.
2020-06-04 09:33:47 -04:00
#include <haproxy/api.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-t.h>
REORG: include: move sample.h to haproxy/sample{,-t}.h This one is particularly tricky to move because everyone uses it and it depends on a lot of other types. For example it cannot include arg-t.h and must absolutely only rely on forward declarations to avoid dependency loops between vars -> sample_data -> arg. In order to address this one, it would be nice to split the sample_data part out of sample.h.
2020-06-04 09:33:47 -04:00
#include <haproxy/sample-t.h>
REORG: include: move stick_table.h to haproxy/stick_table{,-t}.h The stktable_types[] array declaration was moved to the main file as it had nothing to do in the types. A few declarations were reordered in the types file so that defines were before the structs. Thread-t was added since there are a few __decl_thread(). The loss of peers.h revealed that cfgparse-listen needed it.
2020-06-04 12:46:44 -04:00
#include <haproxy/stick_table-t.h>
[MEDIUM] Add pattern fetch management types and functions
2010-01-04 10:16:05 -05:00
REORG: include: move sample.h to haproxy/sample{,-t}.h This one is particularly tricky to move because everyone uses it and it depends on a lot of other types. For example it cannot include arg-t.h and must absolutely only rely on forward declarations to avoid dependency loops between vars -> sample_data -> arg. In order to address this one, it would be nice to split the sample_data part out of sample.h.
2020-06-04 09:33:47 -04:00
extern sample_cast_fct sample_casts[SMP_TYPES][SMP_TYPES];
extern const unsigned int fetch_cap[SMP_SRC_ENTRIES];
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 06:14:54 -05:00
extern const char *smp_to_type[SMP_TYPES];
MINOR: sample: make sample_parse_expr() able to return an end pointer When an end pointer is passed, instead of complaining that a comma is missing after a keyword, sample_parse_expr() will silently return the pointer to the current location into this return pointer so that the caller can continue its parsing. This will be used by more complex expressions which embed sample expressions, and may even permit to embed sample expressions into arguments of other expressions.
2020-02-14 10:50:14 -05:00
struct sample_expr *sample_parse_expr(char **str, int *idx, const char *file, int line, char **err, struct arg_list *al, char **endptr);
MEDIUM: acl/sample: unify sample conv parsing in a single function Both sample_parse_expr() and parse_acl_expr() implement some code logic to parse sample conv list after respective fetch or acl keyword. (Seems like the acl one was inspired by the sample one historically) But there is clearly code duplication between the two functions, making them hard to maintain. Hopefully, the parsing logic between them has stayed pretty much the same, thus the sample conv parsing part may be moved in a dedicated helper parsing function. This is what's being done in this commit, we're adding the new function sample_parse_expr_cnv() which does a single thing: parse the converters that are listed right after a sample fetch keyword and inject them into an already existing sample expression. Both sample_parse_expr() and parse_acl_expr() were adapted to now make use of this specific parsing function and duplicated code parts were cleaned up. Although sample_parse_expr() remains quite complicated (numerous function arguments due to contextual parsing data) the first goal was to get rid of code duplication without impacting the current behavior, with the added benefit that it may allow further code cleanups / simplification in the future.
2023-06-05 08:30:45 -04:00
int sample_parse_expr_cnv(char **str, int *idx, char **endptr, char **err_msg, struct arg_list *al, const char *file, int line,
struct sample_expr *expr, const char *start);
MINOR: sample: export the generic sample conversion parser just export function "find_sample_conv()" to prepare the generic sample conversion parser.
2013-11-21 04:51:50 -05: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 19:47:55 -04: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 09:41:02 -04: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 19:47:55 -04: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 09:41:02 -04:00
struct sample_expr *expr, int smp_type);
MINOR: sample: provide a generic var-to-sample conversion function We're using variable-to-sample conversion at least 4 times in the code, two of which are bogus. Let's introduce a generic conversion function that performs the required checks.
2021-10-06 09:29:00 -04:00
int sample_conv_var2smp(const struct var_desc *var, struct sample *smp, int type);
CLEANUP: sample: rename sample_conv_var2smp() to *_sint This one only handles integers, contrary to its sibling with the suffix _str that only handles strings. Let's rename it and uninline it since it may well be used from outside.
2021-10-06 09:19:05 -04:00
int sample_conv_var2smp_sint(const struct arg *arg, struct sample *smp);
CLEANUP: sample: uninline sample_conv_var2smp_str() There's no reason to limit this one to this file, it could be used in other contexts.
2021-10-06 09:20:18 -04:00
int sample_conv_var2smp_str(const struct arg *arg, struct sample *smp);
REORG: sample: move code to release a sample expression in sample.c This code has been moved from haproxy.c to sample.c and the function release_sample_expr can now be called from anywhere to release a sample expression. This function will be used by the stream processing offload engine (SPOE).
2016-10-26 05:34:47 -04:00
void release_sample_expr(struct sample_expr *expr);
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 15:37:17 -04: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 09:42:20 -05: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 03:12:18 -04: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 09:49:37 -05:00
struct sample_fetch *find_sample_fetch(const char *kw, int len);
MINOR: samples: add a function to list register sample fetch keywords New function smp_dump_fetch_kw lists registered sample fetch keywords with their compatibility matrix, mandatory and optional argument types, and output types. It's called from dump_registered_keywords() with class "smp".
2022-03-29 10:51:29 -04:00
void smp_dump_fetch_kw(void);
MINOR: sample: list registered sample converter functions Similar to the sample fetch keywords, let's also list the converter keywords. They're much simpler since there's no compatibility matrix. Instead the input and output types are listed. This is called by dump_registered_keywords() for the "cnv" keywords class.
2022-03-29 10:59:49 -04:00
void smp_dump_conv_kw(void);
MINOR: sample: add function for browsing samples. This function is useful with the incoming lua functions.
2014-12-08 08:49:19 -05: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 18:56:48 -04:00
struct sample_conv *sample_conv_getnext(struct sample_conv *current, int *idx);
MINOR: sample: make smp_resolve_args() return an allocate error message For now smp_resolve_args() complains on stderr via ha_alert(), but if we want to make it a bit more dynamic, we need it to return errors in an allocated message. Let's pass it an error pointer and have it fill it. On return we indent the output if it contains more than one line.
2021-03-26 11:11:55 -04:00
int smp_resolve_args(struct proxy *p, char **err);
MINOR: sample: add us/ms support to date/http_date It can be sometimes interesting to have a timestamp with a resolution of less than a second. It is currently painful to obtain this, because concatenation of date and date_us lead to a shorter timestamp during first 100ms of a second, which is not parseable and needs ugly ACLs in configuration to prepend 0s when needed. To improve this, add an optional <unit> parameter to date sample to report an integer with desired unit. Also support this unit in http_date converter to report a date string with sub-second precision.
2019-10-30 11:57:28 -04:00
int smp_check_date_unit(struct arg *args, char **err);
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 04:50:10 -05: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 08:55:04 -05:00
int c_none(struct sample *smp);
MINOR: sample: introduce c_pseudo() conv function This function is used for ANY=>!ANY conversions in the compatibility matrix to help differentiate between real NOOP (c_none) and pseudo conversions that are theorically supported at config parse time but can never occur at runtime,. That is, to explicit the fact that actual related runtime operations (e.g.: ANY->IPV4) are not NOOP since they might require some conversion to be performed depending on the input type. When checking the conf we don't know the effective out types so cast[pseudo type][pseudo type] is allowed in the compatibility matrix, but at runtime we only expect cast[real type][(real type || pseudo type)] because fetches and converters may not emit pseudo types, thus using c_none() everywhere was too ambiguous. The process will crash if c_pseudo() is invoked to help catch bugs: crashing here means that a pseudo type has been encountered on a converter's input at runtime (because it was emitted earlier in the chain), which is not supported and results from a broken sample fetch or converter implementation. (pseudo types may only be used as out_type in sample definitions for compatibility checks at parsing time)
2023-06-06 13:03:45 -04:00
int c_pseudo(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 18:20:33 -05:00
int smp_dup(struct sample *smp);
REORG: rename "pattern" files They're now called "sample" everywhere to match their description.
2012-04-27 15:52:18 -04: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 09:36:54 -05:00
/*
* This function just apply a cast on sample. It returns 0 if the cast is not
CLEANUP: Fix typos in the sample subsystem Fix some typos in the code comment of the sample subsystem.
2018-11-15 15:14:56 -05:00
* available or if the cast fails, otherwise returns 1. It does not modify the
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 09:36:54 -05:00
* 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 03:00:18 -04: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 09:36:54 -05: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 03:00:18 -04: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 08:55:04 -05: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 03:00:18 -04: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 09:36:54 -05: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 10:15:46 -05: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 05:37:54 -04: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) {
MINOR: samples: Handle the type SMP_T_METH in smp_is_safe and smp_is_rw For all known methods, samples are considered as safe and rewritable. For unknowns, we handle them like strings (SMP_T_STR).
2017-07-24 10:07:12 -04:00
case SMP_T_METH:
if (smp->data.u.meth.meth != HTTP_METH_OTHER)
return 1;
BUILD: sample: use __fallthrough in smp_is_rw() and smp_dup() This avoids three build warnings when preprocessing happens before compiling with gcc >= 7.
2022-11-14 00:59:59 -05:00
__fallthrough;
MINOR: samples: Handle the type SMP_T_METH in smp_is_safe and smp_is_rw For all known methods, samples are considered as safe and rewritable. For unknowns, we handle them like strings (SMP_T_STR).
2017-07-24 10:07:12 -04:00
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 05:37:54 -04:00
case SMP_T_STR:
BUG/MINOR: sample: Always consider zero size string samples as unsafe smp_is_safe() function is used to be sure a sample may be safely modified. For string samples, a test is performed to verify if there is a null-terminated byte. If not, one is added, if possible. It means if the sample is not const and if there is some free space in the buffer, after data. However, we must not try to read the null-terminated byte if the string sample is too long (data >= size) or if the size is equal to zero. This last test was not performed. Thus it was possible to consider a string sample as safe by testing a byte outside the buffer. Now, a zero size string sample is always considered as unsafe and is duplicated when smp_make_safe() is called. This patch must be backported in all stable versions.
2021-02-18 04:22:48 -05:00
if (!smp->data.u.str.size || smp->data.u.str.data >= smp->data.u.str.size)
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 05:37:54 -04:00
return 0;
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 04:54:26 -04:00
if (smp->data.u.str.area[smp->data.u.str.data] == 0)
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 05:37:54 -04:00
return 1;
BUG/MINOR: sample: Always consider zero size string samples as unsafe smp_is_safe() function is used to be sure a sample may be safely modified. For string samples, a test is performed to verify if there is a null-terminated byte. If not, one is added, if possible. It means if the sample is not const and if there is some free space in the buffer, after data. However, we must not try to read the null-terminated byte if the string sample is too long (data >= size) or if the size is equal to zero. This last test was not performed. Thus it was possible to consider a string sample as safe by testing a byte outside the buffer. Now, a zero size string sample is always considered as unsafe and is duplicated when smp_make_safe() is called. This patch must be backported in all stable versions.
2021-02-18 04:22:48 -05:00
if (smp->flags & SMP_F_CONST)
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 05:37:54 -04:00
return 0;
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 04:54:26 -04:00
smp->data.u.str.area[smp->data.u.str.data] = 0;
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 05:37:54 -04:00
return 1;
case SMP_T_BIN:
MINOR: sample: remove impossible tests on negative smp->data.u.str.data Since commit 843b7cb ("MEDIUM: chunks: make the chunk struct's fields match the buffer struct") a chunk length is unsigned so we can remove negative size checks.
2018-08-21 23:07:14 -04:00
return !smp->data.u.str.size || smp->data.u.str.data <= smp->data.u.str.size;
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 05:37:54 -04:00
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 05:49:20 -04: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) {
MINOR: samples: Handle the type SMP_T_METH in smp_is_safe and smp_is_rw For all known methods, samples are considered as safe and rewritable. For unknowns, we handle them like strings (SMP_T_STR).
2017-07-24 10:07:12 -04:00
case SMP_T_METH:
if (smp->data.u.meth.meth != HTTP_METH_OTHER)
return 1;
BUILD: sample: use __fallthrough in smp_is_rw() and smp_dup() This avoids three build warnings when preprocessing happens before compiling with gcc >= 7.
2022-11-14 00:59:59 -05:00
__fallthrough;
MINOR: samples: Handle the type SMP_T_METH in smp_is_safe and smp_is_rw For all known methods, samples are considered as safe and rewritable. For unknowns, we handle them like strings (SMP_T_STR).
2017-07-24 10:07:12 -04:00
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 05:49:20 -04:00
case SMP_T_STR:
if (!smp->data.u.str.size ||
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 04:54:26 -04:00
smp->data.u.str.data >= smp->data.u.str.size)
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 05:49:20 -04:00
return 0;
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 04:54:26 -04:00
if (smp->data.u.str.area[smp->data.u.str.data] != 0)
smp->data.u.str.area[smp->data.u.str.data] = 0;
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 05:49:20 -04:00
return 1;
case SMP_T_BIN:
return smp->data.u.str.size &&
MEDIUM: chunks: make the chunk struct's fields match the buffer struct Chunks are only a subset of a buffer (a non-wrapping version with no head offset). Despite this we still carry a lot of duplicated code between buffers and chunks. Replacing chunks with buffers would significantly reduce the maintenance efforts. This first patch renames the chunk's fields to match the name and types used by struct buffers, with the goal of isolating the code changes from the declaration changes. Most of the changes were made with spatch using this coccinelle script : @rule_d1@ typedef chunk; struct chunk chunk; @@ - chunk.str + chunk.area @rule_d2@ typedef chunk; struct chunk chunk; @@ - chunk.len + chunk.data @rule_i1@ typedef chunk; struct chunk *chunk; @@ - chunk->str + chunk->area @rule_i2@ typedef chunk; struct chunk *chunk; @@ - chunk->len + chunk->data Some minor updates to 3 http functions had to be performed to take size_t ints instead of ints in order to match the unsigned length here.
2018-07-13 04:54:26 -04:00
smp->data.u.str.data <= smp->data.u.str.size;
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 05:49:20 -04:00
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: include: move sample.h to haproxy/sample{,-t}.h This one is particularly tricky to move because everyone uses it and it depends on a lot of other types. For example it cannot include arg-t.h and must absolutely only rely on forward declarations to avoid dependency loops between vars -> sample_data -> arg. In order to address this one, it would be nice to split the sample_data part out of sample.h.
2020-06-04 09:33:47 -04:00
#endif /* _HAPROXY_SAMPLE_H */
Reference in a new issue Copy permalink