upstream/haproxy
1
0
Fork 0
mirror of https://github.com/haproxy/haproxy.git synced 2026-03-01 21:01:26 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
haproxy/include/types/arg.h

144 lines
4.8 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
/*
* include/types/arg.h
* This file contains structure declarations for generaic argument parsing.
*
* Copyright 2012 Willy Tarreau <w@1wt.eu>
*
* 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
*/
#ifndef _TYPES_ARG_H
#define _TYPES_ARG_H
#include <sys/socket.h>
#include <netinet/in.h>
REORG: buffers: split buffers into chunk,buffer,channel Many parts of the channel definition still make use of the "buffer" word.
2012-08-24 13:22:53 -04:00
#include <common/chunk.h>
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
#include <common/mini-clist.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
MEDIUM: vars: adds support of variables This patch adds support of variables during the processing of each stream. The variables scope can be set as 'session', 'transaction', 'request' or 'response'. The variable type is the type returned by the assignment expression. The type can change while the processing. The allocated memory can be controlled for each scope and each request, and for the global process.
2015-06-06 13:29:07 -04:00
#include <types/vars.h>
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
#include <types/protocol_buffers.h>
MEDIUM: stick-table: Stop handling stick-tables as proxies. This patch adds the support for the "table" line parsing in "peers" sections to declare stick-table in such sections. This also prevents the user from having to declare dummy backends sections with a unique stick-table inside. Even if still supported, this usage will become deprecated. To do so, the ->table member of proxy struct which is a stktable struct is replaced by a pointer to a stktable struct allocated at parsing time in src/cfgparse-listen.c for the dummy stick-table backends and in src/cfgparse.c for "peers" sections. This has an impact on the code for stick-table sample converters and on the stickiness rules parsers which first store the name of the dummy before resolving the rules. This patch replaces proxy_tbl_by_name() calls by stktable_find_by_name() calls to lookup for stick-tables stored in "stktable_by_name" ebtree at parsing time. There is only one remaining place where proxy_tbl_by_name() is used: src/hlua.c. At several places in the code we relied on the fact that ->size member of stick-table was equal to zero to consider the stick-table was present by not configured, this do not make sense anymore as ->table member of struct proxyis fow now on a pointer. These tests are replaced by a test on ->table value itself. In "peers" section we do not have to temporary store the name of the section the stick-table are attached to because this name is obviously already known just after having entered this "peers" section. About the CLI stick-table I/O handler, the pointer to proxy struct is replaced by a pointer to a stktable struct.
2019-03-14 02:07:41 -04:00
#include <types/stick_table.h>
MEDIUM: vars: adds support of variables This patch adds support of variables during the processing of each stream. The variables scope can be set as 'session', 'transaction', 'request' or 'response'. The variable type is the type returned by the assignment expression. The type can change while the processing. The allocated memory can be controlled for each scope and each request, and for the global process.
2015-06-06 13:29:07 -04:00
MEDIUM: args: increase arg type to 5 bits and limit arg count to 5 We'll soon need to add new argument types, and we don't use the current limit of 7 arguments, so let's increase the arg type size to 5 bits and reduce the arg count to 5 (3 max are used today).
2015-01-19 12:54:49 -05:00
/* encoding of each arg type : up to 31 types are supported */
#define ARGT_BITS 5
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
#define ARGT_NBTYPES (1 << ARGT_BITS)
#define ARGT_MASK (ARGT_NBTYPES - 1)
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
/* encoding of the arg count : up to 12 args are possible. 4 bits are left
MEDIUM: args: increase arg type to 5 bits and limit arg count to 5 We'll soon need to add new argument types, and we don't use the current limit of 7 arguments, so let's increase the arg type size to 5 bits and reduce the arg count to 5 (3 max are used today).
2015-01-19 12:54:49 -05:00
* unused at the top.
*/
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
#define ARGM_MASK ((1 << ARGM_BITS) - 1)
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
#define ARGM_BITS 4
#define ARGM_NBARGS (sizeof(uint64_t) * 8 - ARGM_BITS) / ARGT_BITS
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
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
enum {
ARGT_STOP = 0, /* end of the arg list */
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, /* signed 64 bit 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, /* an IPv4 address */
ARGT_MSK4, /* an IPv4 address mask (integer or dotted), stored as ARGT_IPV4 */
ARGT_IPV6, /* an IPv6 address */
CLEANUP: Fix typo in ARGT_MSK6 comment The incorrect comment was introduced in commit: 2ac5718dbd4ec722ece228e9f613d2be74eee9da v1.5-dev9 is the first tag containing this comment, the fix should be backported to haproxy 1.5 and newer.
2018-01-25 10:24:47 -05:00
ARGT_MSK6, /* an IPv6 address mask (integer or dotted), stored as ARGT_IPV6 */
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_TIME, /* a delay in ms by default, stored as ARGT_UINT */
ARGT_SIZE, /* a size in bytes by default, stored as ARGT_UINT */
ARGT_FE, /* a pointer to a frontend only */
ARGT_BE, /* a pointer to a backend only */
ARGT_TAB, /* a pointer to a stick table */
ARGT_SRV, /* a pointer to a server */
ARGT_USR, /* a pointer to a user list */
MINOR: map: Define map types Define the types used with maps, and add new argument type that can reference the map. This pointer contains the map configuration entries.
2013-11-22 11:40:18 -05:00
ARGT_MAP, /* a pointer to a map descriptor */
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, /* a pointer to a regex */
MEDIUM: vars: adds support of variables This patch adds support of variables during the processing of each stream. The variables scope can be set as 'session', 'transaction', 'request' or 'response'. The variable type is the type returned by the assignment expression. The type can change while the processing. The allocated memory can be controlled for each scope and each request, and for the global process.
2015-06-06 13:29:07 -04:00
ARGT_VAR, /* contains a variable description. */
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, /* a protocol buffer field number */
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
/* please update arg_type_names[] in args.c if you add entries here */
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
/* context where arguments are used, in order to help error reporting */
enum {
ARGC_ACL = 0, /* ACL */
ARGC_STK, /* sticking rule */
ARGC_TRK, /* tracking rule */
ARGC_LOG, /* log-format */
MEDIUM: logs: add a new RFC5424 log-format for the structured-data This patch adds a new RFC5424-specific log-format for the structured-data that is automatically send by __send_log() when the sender is in RFC5424 mode. A new statement "log-format-sd" should be used in order to set log-format for the structured-data part in RFC5424 formatted syslog messages. Example: log-format-sd [exampleSDID@1234\ bytes=\"%B\"\ status=\"%ST\"]
2015-09-25 13:17:44 -04:00
ARGC_LOGSD, /* log-format-sd */
BUG/MINOR: arg: fix error reporting for add-header/set-header sample fetch arguments The 'add-header %[samples]' parsing errors associated to http-request and http-response are displayed with the wrong keyword. Configuration entry: http-request set-header mon-header %[res.hdr(user-agent)] Original error message: [WARNING] 323/150920 (16559) : parsing [haproxy.conf:36] : 'log-format' : sample fetch <res.hdr ... After commit error message: [WARNING] 323/150929 (16580) : parsing [haproxy.conf:36] : 'http-request' : sample fetch <res.hdr ...
2013-11-20 09:09:52 -05:00
ARGC_HRQ, /* http-request */
ARGC_HRS, /* http-response */
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
ARGC_UIF, /* unique-id-format */
MEDIUM: http: The redirect strings follows the log format rules. We handle "http-request redirect" with a log-format string now, but we leave "redirect" unaffected. Note that the control of the special "/" case is move from the runtime execution to the configuration parsing. If the format rule list is empty, the build_logline() function does nothing.
2013-11-29 06:15:45 -05:00
ARGC_RDR, /* redirect */
MINOR: tcp: prepare support for the "capture" action A few minor entries will be needed to capture sample fetches in requests or responses. This patch just prepares the code for this.
2014-06-13 10:17:14 -04:00
ARGC_CAP, /* capture rule */
MINOR: args: add new context for servers We'll have to support fetch expressions and args on server lines for "usesrc", "usedst", "sni", etc...
2015-07-09 05:39:33 -04:00
ARGC_SRV, /* server line */
MAJOR: spoe: Add an experimental Stream Processing Offload Engine SPOE makes possible the communication with external components to retrieve some info using an in-house binary protocol, the Stream Processing Offload Protocol (SPOP). In the long term, its aim is to allow any kind of offloading on the streams. This first version, besides being experimental, won't do lot of things. The most important today is to validate the protocol design and lay the foundations of what will, one day, be a full offload engine for the stream processing. So, for now, the SPOE can offload the stream processing before "tcp-request content", "tcp-response content", "http-request" and "http-response" rules. And it only supports variables creation/suppression. But, in spite of these limited features, we can easily imagine to implement a SSO solution, an ip reputation service or an ip geolocation service. Internally, the SPOE is implemented as a filter. So, to use it, you must use following line in a proxy proxy section: frontend my-front ... filter spoe [engine <name>] config <file> ... It uses its own configuration file to keep the HAProxy configuration clean. It is also a easy way to disable it by commenting out the filter line. See "doc/SPOE.txt" for all details about the SPOE configuration.
2016-10-27 16:29:49 -04:00
ARGC_SPOE, /* spoe message args */
MINOR: http/conf: store the use_backend configuration file and line for logs The error log of the directive use_backend doesn't provide the file and line containing the declaration. This patch stores theses informations.
2016-11-24 17:57:54 -05:00
ARGC_UBK, /* use_backend message */
MEDIUM: stream: support use-server rules with dynamic names With server-template was introduced the possibility to scale the number of servers in a backend without needing a configuration change and associated reload. On the other hand it became impractical to write use-server rules for these servers as they would only accept existing server labels as argument. This patch allows the use of log-format notation to describe targets of a use-server rules, such as in the example below: listen test bind *:1234 use-server %[hdr(srv)] if { hdr(srv) -m found } use-server s1 if { path / } server s1 127.0.0.1:18080 server s2 127.0.0.1:18081 If a use-server rule is applied because it was conditionned by an ACL returning true, but the target of the use-server rule cannot be resolved, no other use-server rule is evaluated and we fall back to load balancing. This feature was requested on the ML, and bumped with issue #563.
2020-03-29 03:37:12 -04:00
ARGC_USRV, /* use-server message */
MINOR: http-htx/proxy: Add http-error directive using http return syntax The http-error directive can now be used instead of errorfile to define an error message in a proxy section (including default sections). This directive uses the same syntax that http return rules. The only real difference is the limitation on status code that may be specified. Only status codes supported by errorfile directives are supported for this new directive. Parsing of errorfile directive remains independent from http-error parsing. But functionally, it may be expressed in terms of http-errors : errorfile <status> <file> ==> http-errror status <status> errorfile <file>
2020-05-15 09:47:44 -04:00
ARGC_HERR, /* http-error */
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
};
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
/* flags used when compiling and executing regex */
#define ARGF_REG_ICASE 1
#define ARGF_REG_GLOB 2
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
/* some types that are externally defined */
struct proxy;
struct server;
struct userlist;
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
struct my_regex;
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
union arg_data {
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
long long int sint;
MAJOR: chunks: replace struct chunk with struct buffer Now all the code used to manipulate chunks uses a struct buffer instead. The functions are still called "chunk*", and some of them will progressively move to the generic buffer handling code as they are cleaned up.
2018-07-13 05:56:34 -04:00
struct buffer str;
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
struct in_addr ipv4;
struct in6_addr ipv6;
struct proxy *prx; /* used for fe, be, tables */
struct server *srv;
MEDIUM: stick-table: Stop handling stick-tables as proxies. This patch adds the support for the "table" line parsing in "peers" sections to declare stick-table in such sections. This also prevents the user from having to declare dummy backends sections with a unique stick-table inside. Even if still supported, this usage will become deprecated. To do so, the ->table member of proxy struct which is a stktable struct is replaced by a pointer to a stktable struct allocated at parsing time in src/cfgparse-listen.c for the dummy stick-table backends and in src/cfgparse.c for "peers" sections. This has an impact on the code for stick-table sample converters and on the stickiness rules parsers which first store the name of the dummy before resolving the rules. This patch replaces proxy_tbl_by_name() calls by stktable_find_by_name() calls to lookup for stick-tables stored in "stktable_by_name" ebtree at parsing time. There is only one remaining place where proxy_tbl_by_name() is used: src/hlua.c. At several places in the code we relied on the fact that ->size member of stick-table was equal to zero to consider the stick-table was present by not configured, this do not make sense anymore as ->table member of struct proxyis fow now on a pointer. These tests are replaced by a test on ->table value itself. In "peers" section we do not have to temporary store the name of the section the stick-table are attached to because this name is obviously already known just after having entered this "peers" section. About the CLI stick-table I/O handler, the pointer to proxy struct is replaced by a pointer to a stktable struct.
2019-03-14 02:07:41 -04:00
struct stktable *t;
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
struct userlist *usr;
MINOR: map: Define map types Define the types used with maps, and add new argument type that can reference the map. This pointer contains the map configuration entries.
2013-11-22 11:40:18 -05:00
struct map_descriptor *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
struct my_regex *reg;
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
struct pbuf_fid fid;
MEDIUM: vars: adds support of variables This patch adds support of variables during the processing of each stream. The variables scope can be set as 'session', 'transaction', 'request' or 'response'. The variable type is the type returned by the assignment expression. The type can change while the processing. The allocated memory can be controlled for each scope and each request, and for the global process.
2015-06-06 13:29:07 -04:00
struct var_desc var;
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
};
struct arg {
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
unsigned char type; /* argument type, ARGT_* */
unsigned char unresolved; /* argument contains a string in <str> that must be resolved and freed */
MINOR: args: add type-specific flags for each arg in a list These flags are meant to be used by arg checkers to pass out-of-band information related to some args. A typical use is to indicate how a regex is expected to be compiled/matched based on other arguments. These flags are initialized to zero by default and it is up to the args checkers to set them if needed.
2015-01-21 09:51:47 -05:00
unsigned char type_flags; /* type-specific extra flags (eg: case sensitivity for regex), ARGF_* */
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
union arg_data data; /* argument data */
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
/* arg lists are used to store information about arguments that could not be
* resolved when parsing the configuration. The head is an arg_list which
* serves as a template to create new entries. Nothing here is allocated,
* so plain copies are OK.
*/
struct arg_list {
struct list list; /* chaining with other arg_list, or list head */
struct arg *arg; /* pointer to the arg, NULL on list head */
int arg_pos; /* argument position */
int ctx; /* context where the arg is used (ARGC_*) */
const char *kw; /* keyword making use of these args */
const char *conv; /* conv keyword when in conv, otherwise NULL */
const char *file; /* file name where the args are referenced */
int line; /* line number where the args are referenced */
};
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
#endif /* _TYPES_ARG_H */
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/
Reference in a new issue Copy permalink