blob: e3289996bde5decf82fadfcc37143b09c3fc14f7 [file] [log] [blame]
Thierry FOURNIER4834bc72015-06-06 19:29:07 +02001#include <ctype.h>
2
Willy Tarreau4c7e4b72020-05-27 12:58:42 +02003#include <haproxy/api.h>
Willy Tarreaub2551052020-06-09 09:07:15 +02004#include <haproxy/arg.h>
Willy Tarreau6be78492020-06-05 00:00:29 +02005#include <haproxy/cfgparse.h>
Willy Tarreau4aa573d2020-06-04 18:21:56 +02006#include <haproxy/check.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +02007#include <haproxy/global.h>
Willy Tarreaucd72d8c2020-06-02 19:11:26 +02008#include <haproxy/http.h>
Willy Tarreauc761f842020-06-04 11:40:28 +02009#include <haproxy/http_rules.h>
Willy Tarreau853b2972020-05-27 18:01:47 +020010#include <haproxy/list.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020011#include <haproxy/log.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020012#include <haproxy/sample.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020013#include <haproxy/stream-t.h>
Willy Tarreau8b550af2020-06-04 17:42:48 +020014#include <haproxy/tcp_rules.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020015#include <haproxy/tcpcheck.h>
Willy Tarreaua1718922020-06-04 16:25:31 +020016#include <haproxy/vars.h>
Thierry FOURNIER4834bc72015-06-06 19:29:07 +020017
Thierry FOURNIER4834bc72015-06-06 19:29:07 +020018
19/* This contains a pool of struct vars */
Willy Tarreau8ceae722018-11-26 11:58:30 +010020DECLARE_STATIC_POOL(var_pool, "vars", sizeof(struct var));
Thierry FOURNIER4834bc72015-06-06 19:29:07 +020021
22/* This array contain all the names of all the HAProxy vars.
23 * This permits to identify two variables name with
24 * only one pointer. It permits to not using strdup() for
25 * each variable name used during the runtime.
26 */
27static char **var_names = NULL;
28static int var_names_nb = 0;
29
30/* This array of int contains the system limits per context. */
31static unsigned int var_global_limit = 0;
32static unsigned int var_global_size = 0;
Christopher Fauletff2613e2016-11-09 11:36:17 +010033static unsigned int var_proc_limit = 0;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +020034static unsigned int var_sess_limit = 0;
35static unsigned int var_txn_limit = 0;
36static unsigned int var_reqres_limit = 0;
Gaetan Rivet13a50432020-02-21 18:13:44 +010037static unsigned int var_check_limit = 0;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +020038
Willy Tarreau86abe442018-11-25 20:12:18 +010039__decl_rwlock(var_names_rwlock);
Christopher Faulete95f2c32017-07-24 16:30:34 +020040
Willy Tarreauf37b1402019-06-04 16:27:36 +020041/* returns the struct vars pointer for a session, stream and scope, or NULL if
42 * it does not exist.
43 */
44static inline struct vars *get_vars(struct session *sess, struct stream *strm, enum vars_scope scope)
45{
46 switch (scope) {
47 case SCOPE_PROC:
48 return &global.vars;
49 case SCOPE_SESS:
50 return &sess->vars;
Gaetan Rivet13a50432020-02-21 18:13:44 +010051 case SCOPE_CHECK: {
Christopher Faulet0fca7ed2020-04-21 11:53:32 +020052 struct check *check = objt_check(sess->origin);
Gaetan Rivet13a50432020-02-21 18:13:44 +010053
Christopher Faulet0fca7ed2020-04-21 11:53:32 +020054 return check ? &check->vars : NULL;
Gaetan Rivet13a50432020-02-21 18:13:44 +010055 }
Willy Tarreauf37b1402019-06-04 16:27:36 +020056 case SCOPE_TXN:
57 return strm ? &strm->vars_txn : NULL;
58 case SCOPE_REQ:
59 case SCOPE_RES:
60 default:
61 return strm ? &strm->vars_reqres : NULL;
62 }
63}
64
Willy Tarreau72330982015-06-19 11:21:56 +020065/* This function adds or remove memory size from the accounting. The inner
66 * pointers may be null when setting the outer ones only.
67 */
Miroslav Zagorac6deab792020-12-09 16:34:29 +010068void var_accounting_diff(struct vars *vars, struct session *sess, struct stream *strm, int size)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +020069{
70 switch (vars->scope) {
71 case SCOPE_REQ:
72 case SCOPE_RES:
Willy Tarreauf37b1402019-06-04 16:27:36 +020073 if (strm)
74 _HA_ATOMIC_ADD(&strm->vars_reqres.size, size);
Willy Tarreau6204cd92016-03-10 16:33:04 +010075 /* fall through */
Thierry FOURNIER4834bc72015-06-06 19:29:07 +020076 case SCOPE_TXN:
Willy Tarreauf37b1402019-06-04 16:27:36 +020077 if (strm)
78 _HA_ATOMIC_ADD(&strm->vars_txn.size, size);
Gaetan Rivet13a50432020-02-21 18:13:44 +010079 goto scope_sess;
80 case SCOPE_CHECK: {
Christopher Faulet0fca7ed2020-04-21 11:53:32 +020081 struct check *check = objt_check(sess->origin);
Gaetan Rivet13a50432020-02-21 18:13:44 +010082
Christopher Faulet0fca7ed2020-04-21 11:53:32 +020083 if (check)
84 _HA_ATOMIC_ADD(&check->vars.size, size);
Gaetan Rivet13a50432020-02-21 18:13:44 +010085 }
Willy Tarreau6204cd92016-03-10 16:33:04 +010086 /* fall through */
Gaetan Rivet13a50432020-02-21 18:13:44 +010087scope_sess:
Thierry FOURNIER4834bc72015-06-06 19:29:07 +020088 case SCOPE_SESS:
Olivier Houchard25ad13f2019-03-08 18:55:38 +010089 _HA_ATOMIC_ADD(&sess->vars.size, size);
Christopher Fauletff2613e2016-11-09 11:36:17 +010090 /* fall through */
91 case SCOPE_PROC:
Olivier Houchard25ad13f2019-03-08 18:55:38 +010092 _HA_ATOMIC_ADD(&global.vars.size, size);
93 _HA_ATOMIC_ADD(&var_global_size, size);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +020094 }
95}
96
97/* This function returns 1 if the <size> is available in the var
Joseph Herlant07676892018-11-15 09:19:50 -080098 * pool <vars>, otherwise returns 0. If the space is available,
Willy Tarreau72330982015-06-19 11:21:56 +020099 * the size is reserved. The inner pointers may be null when setting
Willy Tarreau6204cd92016-03-10 16:33:04 +0100100 * the outer ones only. The accounting uses either <sess> or <strm>
101 * depending on the scope. <strm> may be NULL when no stream is known
102 * and only the session exists (eg: tcp-request connection).
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200103 */
Willy Tarreau6204cd92016-03-10 16:33:04 +0100104static int var_accounting_add(struct vars *vars, struct session *sess, struct stream *strm, int size)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200105{
106 switch (vars->scope) {
107 case SCOPE_REQ:
108 case SCOPE_RES:
Willy Tarreauf37b1402019-06-04 16:27:36 +0200109 if (var_reqres_limit && strm && strm->vars_reqres.size + size > var_reqres_limit)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200110 return 0;
Willy Tarreau6204cd92016-03-10 16:33:04 +0100111 /* fall through */
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200112 case SCOPE_TXN:
Willy Tarreauf37b1402019-06-04 16:27:36 +0200113 if (var_txn_limit && strm && strm->vars_txn.size + size > var_txn_limit)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200114 return 0;
Gaetan Rivet13a50432020-02-21 18:13:44 +0100115 goto scope_sess;
116 case SCOPE_CHECK: {
Christopher Faulet0fca7ed2020-04-21 11:53:32 +0200117 struct check *check = objt_check(sess->origin);
Gaetan Rivet13a50432020-02-21 18:13:44 +0100118
Christopher Faulet0fca7ed2020-04-21 11:53:32 +0200119 if (var_check_limit && check && check->vars.size + size > var_check_limit)
Gaetan Rivet13a50432020-02-21 18:13:44 +0100120 return 0;
121 }
Willy Tarreau6204cd92016-03-10 16:33:04 +0100122 /* fall through */
Gaetan Rivet13a50432020-02-21 18:13:44 +0100123scope_sess:
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200124 case SCOPE_SESS:
Willy Tarreau6204cd92016-03-10 16:33:04 +0100125 if (var_sess_limit && sess->vars.size + size > var_sess_limit)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200126 return 0;
Christopher Fauletff2613e2016-11-09 11:36:17 +0100127 /* fall through */
128 case SCOPE_PROC:
129 if (var_proc_limit && global.vars.size + size > var_proc_limit)
130 return 0;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200131 if (var_global_limit && var_global_size + size > var_global_limit)
132 return 0;
133 }
Willy Tarreau6204cd92016-03-10 16:33:04 +0100134 var_accounting_diff(vars, sess, strm, size);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200135 return 1;
136}
137
Christopher Faulet85d79c92016-11-09 16:54:56 +0100138/* This fnuction remove a variable from the list and free memory it used */
139unsigned int var_clear(struct var *var)
140{
141 unsigned int size = 0;
142
143 if (var->data.type == SMP_T_STR || var->data.type == SMP_T_BIN) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200144 free(var->data.u.str.area);
145 size += var->data.u.str.data;
Christopher Faulet85d79c92016-11-09 16:54:56 +0100146 }
Christopher Fauletd02210c2017-07-24 16:24:39 +0200147 else if (var->data.type == SMP_T_METH && var->data.u.meth.meth == HTTP_METH_OTHER) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200148 free(var->data.u.meth.str.area);
149 size += var->data.u.meth.str.data;
Christopher Faulet85d79c92016-11-09 16:54:56 +0100150 }
151 LIST_DEL(&var->l);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100152 pool_free(var_pool, var);
Christopher Faulet85d79c92016-11-09 16:54:56 +0100153 size += sizeof(struct var);
154 return size;
155}
156
Joseph Herlant07676892018-11-15 09:19:50 -0800157/* This function free all the memory used by all the variables
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200158 * in the list.
159 */
Willy Tarreau6204cd92016-03-10 16:33:04 +0100160void vars_prune(struct vars *vars, struct session *sess, struct stream *strm)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200161{
162 struct var *var, *tmp;
Willy Tarreau72330982015-06-19 11:21:56 +0200163 unsigned int size = 0;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200164
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100165 HA_RWLOCK_WRLOCK(VARS_LOCK, &vars->rwlock);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200166 list_for_each_entry_safe(var, tmp, &vars->head, l) {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100167 size += var_clear(var);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200168 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100169 HA_RWLOCK_WRUNLOCK(VARS_LOCK, &vars->rwlock);
Willy Tarreau6204cd92016-03-10 16:33:04 +0100170 var_accounting_diff(vars, sess, strm, -size);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200171}
172
Willy Tarreauebcd4842015-06-19 11:59:02 +0200173/* This function frees all the memory used by all the session variables in the
174 * list starting at <vars>.
175 */
176void vars_prune_per_sess(struct vars *vars)
177{
178 struct var *var, *tmp;
179 unsigned int size = 0;
180
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100181 HA_RWLOCK_WRLOCK(VARS_LOCK, &vars->rwlock);
Willy Tarreauebcd4842015-06-19 11:59:02 +0200182 list_for_each_entry_safe(var, tmp, &vars->head, l) {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100183 size += var_clear(var);
Willy Tarreauebcd4842015-06-19 11:59:02 +0200184 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100185 HA_RWLOCK_WRUNLOCK(VARS_LOCK, &vars->rwlock);
Christopher Faulete95f2c32017-07-24 16:30:34 +0200186
Olivier Houchard25ad13f2019-03-08 18:55:38 +0100187 _HA_ATOMIC_SUB(&vars->size, size);
188 _HA_ATOMIC_SUB(&global.vars.size, size);
189 _HA_ATOMIC_SUB(&var_global_size, size);
Willy Tarreauebcd4842015-06-19 11:59:02 +0200190}
191
Ilya Shipitsin46a030c2020-07-05 16:36:08 +0500192/* This function init a list of variables. */
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200193void vars_init(struct vars *vars, enum vars_scope scope)
194{
195 LIST_INIT(&vars->head);
196 vars->scope = scope;
197 vars->size = 0;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100198 HA_RWLOCK_INIT(&vars->rwlock);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200199}
200
201/* This function declares a new variable name. It returns a pointer
202 * on the string identifying the name. This function assures that
203 * the same name exists only once.
204 *
205 * This function check if the variable name is acceptable.
206 *
207 * The function returns NULL if an error occurs, and <err> is filled.
208 * In this case, the HAProxy must be stopped because the structs are
209 * left inconsistent. Otherwise, it returns the pointer on the global
210 * name.
211 */
Christopher Faulet09c9df22016-10-31 11:05:37 +0100212static char *register_name(const char *name, int len, enum vars_scope *scope,
213 int alloc, char **err)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200214{
215 int i;
Hubert Verstraete831962e2016-06-28 22:44:26 +0200216 char **var_names2;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200217 const char *tmp;
Christopher Faulete95f2c32017-07-24 16:30:34 +0200218 char *res = NULL;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200219
220 /* Check length. */
221 if (len == 0) {
222 memprintf(err, "Empty variable name cannot be accepted");
Christopher Fauleteb3e2762017-12-08 09:17:39 +0100223 return res;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200224 }
225
226 /* Check scope. */
Christopher Fauletff2613e2016-11-09 11:36:17 +0100227 if (len > 5 && strncmp(name, "proc.", 5) == 0) {
228 name += 5;
229 len -= 5;
230 *scope = SCOPE_PROC;
231 }
232 else if (len > 5 && strncmp(name, "sess.", 5) == 0) {
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200233 name += 5;
234 len -= 5;
235 *scope = SCOPE_SESS;
236 }
237 else if (len > 4 && strncmp(name, "txn.", 4) == 0) {
238 name += 4;
239 len -= 4;
240 *scope = SCOPE_TXN;
241 }
242 else if (len > 4 && strncmp(name, "req.", 4) == 0) {
243 name += 4;
244 len -= 4;
245 *scope = SCOPE_REQ;
246 }
247 else if (len > 4 && strncmp(name, "res.", 4) == 0) {
248 name += 4;
249 len -= 4;
250 *scope = SCOPE_RES;
251 }
Gaetan Rivet13a50432020-02-21 18:13:44 +0100252 else if (len > 6 && strncmp(name, "check.", 6) == 0) {
253 name += 6;
254 len -= 6;
255 *scope = SCOPE_CHECK;
256 }
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200257 else {
258 memprintf(err, "invalid variable name '%s'. A variable name must be start by its scope. "
Gaetan Rivet13a50432020-02-21 18:13:44 +0100259 "The scope can be 'proc', 'sess', 'txn', 'req', 'res' or 'check'", name);
Christopher Fauleteb3e2762017-12-08 09:17:39 +0100260 return res;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200261 }
262
Christopher Faulete95f2c32017-07-24 16:30:34 +0200263 if (alloc)
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100264 HA_RWLOCK_WRLOCK(VARS_LOCK, &var_names_rwlock);
Christopher Faulete95f2c32017-07-24 16:30:34 +0200265 else
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100266 HA_RWLOCK_RDLOCK(VARS_LOCK, &var_names_rwlock);
Christopher Faulete95f2c32017-07-24 16:30:34 +0200267
268
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200269 /* Look for existing variable name. */
270 for (i = 0; i < var_names_nb; i++)
Christopher Faulete95f2c32017-07-24 16:30:34 +0200271 if (strncmp(var_names[i], name, len) == 0 && var_names[i][len] == '\0') {
272 res = var_names[i];
273 goto end;
274 }
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200275
Christopher Faulete95f2c32017-07-24 16:30:34 +0200276 if (!alloc) {
277 res = NULL;
278 goto end;
279 }
Christopher Faulet09c9df22016-10-31 11:05:37 +0100280
Hubert Verstraete831962e2016-06-28 22:44:26 +0200281 /* Store variable name. If realloc fails, var_names remains valid */
282 var_names2 = realloc(var_names, (var_names_nb + 1) * sizeof(*var_names));
283 if (!var_names2) {
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200284 memprintf(err, "out of memory error");
Christopher Faulete95f2c32017-07-24 16:30:34 +0200285 res = NULL;
286 goto end;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200287 }
Hubert Verstraete831962e2016-06-28 22:44:26 +0200288 var_names_nb++;
289 var_names = var_names2;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200290 var_names[var_names_nb - 1] = malloc(len + 1);
291 if (!var_names[var_names_nb - 1]) {
292 memprintf(err, "out of memory error");
Christopher Faulete95f2c32017-07-24 16:30:34 +0200293 res = NULL;
294 goto end;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200295 }
296 memcpy(var_names[var_names_nb - 1], name, len);
297 var_names[var_names_nb - 1][len] = '\0';
298
299 /* Check variable name syntax. */
300 tmp = var_names[var_names_nb - 1];
301 while (*tmp) {
Willy Tarreau90807112020-02-25 08:16:33 +0100302 if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') {
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200303 memprintf(err, "invalid syntax at char '%s'", tmp);
Christopher Faulete95f2c32017-07-24 16:30:34 +0200304 res = NULL;
305 goto end;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200306 }
307 tmp++;
308 }
Christopher Faulete95f2c32017-07-24 16:30:34 +0200309 res = var_names[var_names_nb - 1];
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200310
Christopher Faulete95f2c32017-07-24 16:30:34 +0200311 end:
312 if (alloc)
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100313 HA_RWLOCK_WRUNLOCK(VARS_LOCK, &var_names_rwlock);
Christopher Faulete95f2c32017-07-24 16:30:34 +0200314 else
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100315 HA_RWLOCK_RDUNLOCK(VARS_LOCK, &var_names_rwlock);
Christopher Faulete95f2c32017-07-24 16:30:34 +0200316
317 return res;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200318}
319
320/* This function returns an existing variable or returns NULL. */
321static inline struct var *var_get(struct vars *vars, const char *name)
322{
323 struct var *var;
324
325 list_for_each_entry(var, &vars->head, l)
326 if (var->name == name)
327 return var;
328 return NULL;
329}
330
331/* Returns 0 if fails, else returns 1. */
332static int smp_fetch_var(const struct arg *args, struct sample *smp, const char *kw, void *private)
333{
334 const struct var_desc *var_desc = &args[0].data.var;
335 struct var *var;
336 struct vars *vars;
337
338 /* Check the availibity of the variable. */
Willy Tarreauf37b1402019-06-04 16:27:36 +0200339 vars = get_vars(smp->sess, smp->strm, var_desc->scope);
340 if (!vars || vars->scope != var_desc->scope)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200341 return 0;
Christopher Faulete95f2c32017-07-24 16:30:34 +0200342
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100343 HA_RWLOCK_RDLOCK(VARS_LOCK, &vars->rwlock);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200344 var = var_get(vars, var_desc->name);
345
346 /* check for the variable avalaibility */
Christopher Faulete95f2c32017-07-24 16:30:34 +0200347 if (!var) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100348 HA_RWLOCK_RDUNLOCK(VARS_LOCK, &vars->rwlock);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200349 return 0;
Christopher Faulete95f2c32017-07-24 16:30:34 +0200350 }
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200351
Christopher Faulete95f2c32017-07-24 16:30:34 +0200352 /* Duplicate the sample data because it could modified by another
353 * thread */
Thierry FOURNIER5cc18d42015-08-19 09:02:36 +0200354 smp->data = var->data;
Christopher Faulete95f2c32017-07-24 16:30:34 +0200355 smp_dup(smp);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200356 smp->flags |= SMP_F_CONST;
Christopher Faulete95f2c32017-07-24 16:30:34 +0200357
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100358 HA_RWLOCK_RDUNLOCK(VARS_LOCK, &vars->rwlock);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200359 return 1;
360}
361
362/* This function search in the <head> a variable with the same
363 * pointer value that the <name>. If the variable doesn't exists,
364 * create it. The function stores a copy of smp> if the variable.
365 * It returns 0 if fails, else returns 1.
366 */
Willy Tarreau6204cd92016-03-10 16:33:04 +0100367static int sample_store(struct vars *vars, const char *name, struct sample *smp)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200368{
369 struct var *var;
370
371 /* Look for existing variable name. */
372 var = var_get(vars, name);
373
374 if (var) {
375 /* free its used memory. */
376 if (var->data.type == SMP_T_STR ||
377 var->data.type == SMP_T_BIN) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200378 free(var->data.u.str.area);
379 var_accounting_diff(vars, smp->sess, smp->strm,
380 -var->data.u.str.data);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200381 }
Christopher Fauletd02210c2017-07-24 16:24:39 +0200382 else if (var->data.type == SMP_T_METH && var->data.u.meth.meth == HTTP_METH_OTHER) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200383 free(var->data.u.meth.str.area);
384 var_accounting_diff(vars, smp->sess, smp->strm,
385 -var->data.u.meth.str.data);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200386 }
387 } else {
388
Joseph Herlant07676892018-11-15 09:19:50 -0800389 /* Check memory available. */
Willy Tarreau6204cd92016-03-10 16:33:04 +0100390 if (!var_accounting_add(vars, smp->sess, smp->strm, sizeof(struct var)))
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200391 return 0;
392
393 /* Create new entry. */
Willy Tarreaubafbe012017-11-24 17:34:44 +0100394 var = pool_alloc(var_pool);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200395 if (!var)
396 return 0;
397 LIST_ADDQ(&vars->head, &var->l);
398 var->name = name;
399 }
400
401 /* Set type. */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200402 var->data.type = smp->data.type;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200403
404 /* Copy data. If the data needs memory, the function can fail. */
405 switch (var->data.type) {
406 case SMP_T_BOOL:
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200407 case SMP_T_SINT:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200408 var->data.u.sint = smp->data.u.sint;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200409 break;
410 case SMP_T_IPV4:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200411 var->data.u.ipv4 = smp->data.u.ipv4;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200412 break;
413 case SMP_T_IPV6:
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200414 var->data.u.ipv6 = smp->data.u.ipv6;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200415 break;
416 case SMP_T_STR:
417 case SMP_T_BIN:
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200418 if (!var_accounting_add(vars, smp->sess, smp->strm, smp->data.u.str.data)) {
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200419 var->data.type = SMP_T_BOOL; /* This type doesn't use additional memory. */
420 return 0;
421 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200422 var->data.u.str.area = malloc(smp->data.u.str.data);
423 if (!var->data.u.str.area) {
424 var_accounting_diff(vars, smp->sess, smp->strm,
425 -smp->data.u.str.data);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200426 var->data.type = SMP_T_BOOL; /* This type doesn't use additional memory. */
427 return 0;
428 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200429 var->data.u.str.data = smp->data.u.str.data;
430 memcpy(var->data.u.str.area, smp->data.u.str.area,
431 var->data.u.str.data);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200432 break;
433 case SMP_T_METH:
Christopher Fauletd02210c2017-07-24 16:24:39 +0200434 var->data.u.meth.meth = smp->data.u.meth.meth;
435 if (smp->data.u.meth.meth != HTTP_METH_OTHER)
436 break;
437
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200438 if (!var_accounting_add(vars, smp->sess, smp->strm, smp->data.u.meth.str.data)) {
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200439 var->data.type = SMP_T_BOOL; /* This type doesn't use additional memory. */
440 return 0;
441 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200442 var->data.u.meth.str.area = malloc(smp->data.u.meth.str.data);
443 if (!var->data.u.meth.str.area) {
444 var_accounting_diff(vars, smp->sess, smp->strm,
445 -smp->data.u.meth.str.data);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200446 var->data.type = SMP_T_BOOL; /* This type doesn't use additional memory. */
447 return 0;
448 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200449 var->data.u.meth.str.data = smp->data.u.meth.str.data;
450 var->data.u.meth.str.size = smp->data.u.meth.str.data;
451 memcpy(var->data.u.meth.str.area, smp->data.u.meth.str.area,
452 var->data.u.meth.str.data);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200453 break;
454 }
455 return 1;
456}
457
Willy Tarreau620408f2016-10-21 16:37:51 +0200458/* Returns 0 if fails, else returns 1. Note that stream may be null for SCOPE_SESS. */
Willy Tarreau6204cd92016-03-10 16:33:04 +0100459static inline int sample_store_stream(const char *name, enum vars_scope scope, struct sample *smp)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200460{
461 struct vars *vars;
Christopher Faulete95f2c32017-07-24 16:30:34 +0200462 int ret;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200463
Willy Tarreauf37b1402019-06-04 16:27:36 +0200464 vars = get_vars(smp->sess, smp->strm, scope);
465 if (!vars || vars->scope != scope)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200466 return 0;
Christopher Faulete95f2c32017-07-24 16:30:34 +0200467
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100468 HA_RWLOCK_WRLOCK(VARS_LOCK, &vars->rwlock);
Christopher Faulete95f2c32017-07-24 16:30:34 +0200469 ret = sample_store(vars, name, smp);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100470 HA_RWLOCK_WRUNLOCK(VARS_LOCK, &vars->rwlock);
Christopher Faulete95f2c32017-07-24 16:30:34 +0200471 return ret;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200472}
473
Christopher Faulet85d79c92016-11-09 16:54:56 +0100474/* Returns 0 if fails, else returns 1. Note that stream may be null for SCOPE_SESS. */
475static inline int sample_clear_stream(const char *name, enum vars_scope scope, struct sample *smp)
476{
477 struct vars *vars;
478 struct var *var;
479 unsigned int size = 0;
480
Willy Tarreauf37b1402019-06-04 16:27:36 +0200481 vars = get_vars(smp->sess, smp->strm, scope);
482 if (!vars || vars->scope != scope)
Christopher Faulet85d79c92016-11-09 16:54:56 +0100483 return 0;
484
485 /* Look for existing variable name. */
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100486 HA_RWLOCK_WRLOCK(VARS_LOCK, &vars->rwlock);
Christopher Faulet85d79c92016-11-09 16:54:56 +0100487 var = var_get(vars, name);
488 if (var) {
489 size = var_clear(var);
490 var_accounting_diff(vars, smp->sess, smp->strm, -size);
491 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100492 HA_RWLOCK_WRUNLOCK(VARS_LOCK, &vars->rwlock);
Christopher Faulet85d79c92016-11-09 16:54:56 +0100493 return 1;
494}
495
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200496/* Returns 0 if fails, else returns 1. */
497static int smp_conv_store(const struct arg *args, struct sample *smp, void *private)
498{
Christopher Faulet0099a8c2016-11-09 16:15:32 +0100499 return sample_store_stream(args[0].data.var.name, args[0].data.var.scope, smp);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200500}
501
Christopher Faulet85d79c92016-11-09 16:54:56 +0100502/* Returns 0 if fails, else returns 1. */
503static int smp_conv_clear(const struct arg *args, struct sample *smp, void *private)
504{
505 return sample_clear_stream(args[0].data.var.name, args[0].data.var.scope, smp);
506}
507
Joseph Herlant07676892018-11-15 09:19:50 -0800508/* This functions check an argument entry and fill it with a variable
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200509 * type. The argumen must be a string. If the variable lookup fails,
Joseph Herlant07676892018-11-15 09:19:50 -0800510 * the function returns 0 and fill <err>, otherwise it returns 1.
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200511 */
512int vars_check_arg(struct arg *arg, char **err)
513{
514 char *name;
515 enum vars_scope scope;
516
517 /* Check arg type. */
518 if (arg->type != ARGT_STR) {
519 memprintf(err, "unexpected argument type");
520 return 0;
521 }
522
523 /* Register new variable name. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200524 name = register_name(arg->data.str.area, arg->data.str.data, &scope,
525 1,
526 err);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200527 if (!name)
528 return 0;
529
Tim Duesterhusa6cc7e82019-05-13 10:53:29 +0200530 /* properly destroy the chunk */
531 chunk_destroy(&arg->data.str);
532
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200533 /* Use the global variable name pointer. */
534 arg->type = ARGT_VAR;
535 arg->data.var.name = name;
536 arg->data.var.scope = scope;
537 return 1;
538}
539
Christopher Faulet09c9df22016-10-31 11:05:37 +0100540/* This function store a sample in a variable if it was already defined.
Tim Duesterhusb4fac1e2020-05-19 13:49:40 +0200541 * Returns zero on failure and non-zero otherwise. The variable not being
542 * defined is treated as a failure.
Christopher Faulet09c9df22016-10-31 11:05:37 +0100543 */
Tim Duesterhusb4fac1e2020-05-19 13:49:40 +0200544int vars_set_by_name_ifexist(const char *name, size_t len, struct sample *smp)
Christopher Faulet09c9df22016-10-31 11:05:37 +0100545{
546 enum vars_scope scope;
547
548 /* Resolve name and scope. */
549 name = register_name(name, len, &scope, 0, NULL);
550 if (!name)
Tim Duesterhusb4fac1e2020-05-19 13:49:40 +0200551 return 0;
Christopher Faulet09c9df22016-10-31 11:05:37 +0100552
Tim Duesterhusb4fac1e2020-05-19 13:49:40 +0200553 return sample_store_stream(name, scope, smp);
Christopher Faulet09c9df22016-10-31 11:05:37 +0100554}
555
556
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200557/* This function store a sample in a variable.
Tim Duesterhusb4fac1e2020-05-19 13:49:40 +0200558 * Returns zero on failure and non-zero otherwise.
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200559 */
Tim Duesterhusb4fac1e2020-05-19 13:49:40 +0200560int vars_set_by_name(const char *name, size_t len, struct sample *smp)
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200561{
562 enum vars_scope scope;
563
564 /* Resolve name and scope. */
Christopher Faulet09c9df22016-10-31 11:05:37 +0100565 name = register_name(name, len, &scope, 1, NULL);
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200566 if (!name)
Tim Duesterhusb4fac1e2020-05-19 13:49:40 +0200567 return 0;
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200568
Tim Duesterhusb4fac1e2020-05-19 13:49:40 +0200569 return sample_store_stream(name, scope, smp);
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200570}
571
Christopher Faulet85d79c92016-11-09 16:54:56 +0100572/* This function unset a variable if it was already defined.
Tim Duesterhusb4fac1e2020-05-19 13:49:40 +0200573 * Returns zero on failure and non-zero otherwise.
Christopher Faulet85d79c92016-11-09 16:54:56 +0100574 */
Tim Duesterhusb4fac1e2020-05-19 13:49:40 +0200575int vars_unset_by_name_ifexist(const char *name, size_t len, struct sample *smp)
Christopher Faulet85d79c92016-11-09 16:54:56 +0100576{
577 enum vars_scope scope;
578
579 /* Resolve name and scope. */
580 name = register_name(name, len, &scope, 0, NULL);
581 if (!name)
Tim Duesterhusb4fac1e2020-05-19 13:49:40 +0200582 return 0;
Christopher Faulet85d79c92016-11-09 16:54:56 +0100583
Tim Duesterhusb4fac1e2020-05-19 13:49:40 +0200584 return sample_clear_stream(name, scope, smp);
Christopher Faulet85d79c92016-11-09 16:54:56 +0100585}
586
587
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200588/* this function fills a sample with the
589 * variable content. Returns 1 if the sample
590 * is filled, otherwise it returns 0.
591 */
Willy Tarreau6204cd92016-03-10 16:33:04 +0100592int vars_get_by_name(const char *name, size_t len, struct sample *smp)
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200593{
594 struct vars *vars;
595 struct var *var;
596 enum vars_scope scope;
597
598 /* Resolve name and scope. */
Christopher Faulet09c9df22016-10-31 11:05:37 +0100599 name = register_name(name, len, &scope, 1, NULL);
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200600 if (!name)
601 return 0;
602
603 /* Select "vars" pool according with the scope. */
Willy Tarreauf37b1402019-06-04 16:27:36 +0200604 vars = get_vars(smp->sess, smp->strm, scope);
605 if (!vars || vars->scope != scope)
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200606 return 0;
607
608 /* Get the variable entry. */
609 var = var_get(vars, name);
610 if (!var)
611 return 0;
612
613 /* Copy sample. */
Thierry FOURNIER5cc18d42015-08-19 09:02:36 +0200614 smp->data = var->data;
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200615 smp->flags = SMP_F_CONST;
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200616 return 1;
617}
618
Thierry FOURNIERfd77e052015-07-07 21:20:42 +0200619/* this function fills a sample with the
Joseph Herlant07676892018-11-15 09:19:50 -0800620 * content of the variable described by <var_desc>. Returns 1
Thierry FOURNIERfd77e052015-07-07 21:20:42 +0200621 * if the sample is filled, otherwise it returns 0.
622 */
Willy Tarreau6204cd92016-03-10 16:33:04 +0100623int vars_get_by_desc(const struct var_desc *var_desc, struct sample *smp)
Thierry FOURNIERfd77e052015-07-07 21:20:42 +0200624{
625 struct vars *vars;
626 struct var *var;
627
628 /* Select "vars" pool according with the scope. */
Willy Tarreauf37b1402019-06-04 16:27:36 +0200629 vars = get_vars(smp->sess, smp->strm, var_desc->scope);
Thierry FOURNIERfd77e052015-07-07 21:20:42 +0200630
Joseph Herlant07676892018-11-15 09:19:50 -0800631 /* Check if the scope is available a this point of processing. */
Willy Tarreauf37b1402019-06-04 16:27:36 +0200632 if (!vars || vars->scope != var_desc->scope)
Thierry FOURNIERfd77e052015-07-07 21:20:42 +0200633 return 0;
634
635 /* Get the variable entry. */
636 var = var_get(vars, var_desc->name);
637 if (!var)
638 return 0;
639
640 /* Copy sample. */
Thierry FOURNIER5cc18d42015-08-19 09:02:36 +0200641 smp->data = var->data;
Thierry FOURNIERfd77e052015-07-07 21:20:42 +0200642 smp->flags = SMP_F_CONST;
Thierry FOURNIERfd77e052015-07-07 21:20:42 +0200643 return 1;
644}
645
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200646/* Always returns ACT_RET_CONT even if an error occurs. */
647static enum act_return action_store(struct act_rule *rule, struct proxy *px,
Willy Tarreau658b85b2015-09-27 10:00:49 +0200648 struct session *sess, struct stream *s, int flags)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200649{
650 struct sample smp;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200651 int dir;
652
653 switch (rule->from) {
Willy Tarreau620408f2016-10-21 16:37:51 +0200654 case ACT_F_TCP_REQ_SES: dir = SMP_OPT_DIR_REQ; break;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200655 case ACT_F_TCP_REQ_CNT: dir = SMP_OPT_DIR_REQ; break;
656 case ACT_F_TCP_RES_CNT: dir = SMP_OPT_DIR_RES; break;
657 case ACT_F_HTTP_REQ: dir = SMP_OPT_DIR_REQ; break;
658 case ACT_F_HTTP_RES: dir = SMP_OPT_DIR_RES; break;
Gaetan Rivet0c39ecc2020-02-24 17:34:11 +0100659 case ACT_F_TCP_CHK: dir = SMP_OPT_DIR_REQ; break;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200660 default:
661 send_log(px, LOG_ERR, "Vars: internal error while execute action store.");
662 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE))
Christopher Faulet767a84b2017-11-24 16:50:31 +0100663 ha_alert("Vars: internal error while execute action store.\n");
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200664 return ACT_RET_CONT;
665 }
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200666
667 /* Process the expression. */
668 memset(&smp, 0, sizeof(smp));
Willy Tarreau108a8fd2016-10-21 17:13:24 +0200669 if (!sample_process(px, sess, s, dir|SMP_OPT_FINAL,
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200670 rule->arg.vars.expr, &smp))
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +0200671 return ACT_RET_CONT;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200672
673 /* Store the sample, and ignore errors. */
Willy Tarreau6204cd92016-03-10 16:33:04 +0100674 sample_store_stream(rule->arg.vars.name, rule->arg.vars.scope, &smp);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +0200675 return ACT_RET_CONT;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200676}
677
Christopher Faulet85d79c92016-11-09 16:54:56 +0100678/* Always returns ACT_RET_CONT even if an error occurs. */
679static enum act_return action_clear(struct act_rule *rule, struct proxy *px,
680 struct session *sess, struct stream *s, int flags)
681{
682 struct sample smp;
683
684 memset(&smp, 0, sizeof(smp));
685 smp_set_owner(&smp, px, sess, s, SMP_OPT_FINAL);
686
687 /* Clear the variable using the sample context, and ignore errors. */
688 sample_clear_stream(rule->arg.vars.name, rule->arg.vars.scope, &smp);
689 return ACT_RET_CONT;
690}
691
Tim Duesterhus01a0ce32020-06-14 17:27:36 +0200692static void release_store_rule(struct act_rule *rule)
693{
694 release_sample_expr(rule->arg.vars.expr);
695}
696
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200697/* This two function checks the variable name and replace the
698 * configuration string name by the global string name. its
699 * the same string, but the global pointer can be easy to
700 * compare.
701 *
702 * The first function checks a sample-fetch and the second
703 * checks a converter.
704 */
705static int smp_check_var(struct arg *args, char **err)
706{
707 return vars_check_arg(&args[0], err);
708}
709
710static int conv_check_var(struct arg *args, struct sample_conv *conv,
711 const char *file, int line, char **err_msg)
712{
713 return vars_check_arg(&args[0], err_msg);
714}
715
716/* This function is a common parser for using variables. It understands
717 * the format:
718 *
719 * set-var(<variable-name>) <expression>
Willy Tarreau4b7531f2019-06-04 16:43:29 +0200720 * unset-var(<variable-name>)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200721 *
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200722 * It returns ACT_RET_PRS_ERR if fails and <err> is filled with an error
723 * message. Otherwise, it returns ACT_RET_PRS_OK and the variable <expr>
724 * is filled with the pointer to the expression to execute.
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200725 */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200726static enum act_parse_ret parse_store(const char **args, int *arg, struct proxy *px,
727 struct act_rule *rule, char **err)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200728{
729 const char *var_name = args[*arg-1];
730 int var_len;
Thierry FOURNIER48a9cd12015-07-28 19:00:28 +0200731 const char *kw_name;
Willy Tarreaue3658152016-11-24 21:23:28 +0100732 int flags, set_var = 0;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200733
Christopher Faulet85d79c92016-11-09 16:54:56 +0100734 if (!strncmp(var_name, "set-var", 7)) {
735 var_name += 7;
736 set_var = 1;
737 }
738 if (!strncmp(var_name, "unset-var", 9)) {
739 var_name += 9;
740 set_var = 0;
741 }
742
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200743 if (*var_name != '(') {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100744 memprintf(err, "invalid variable '%s'. Expects 'set-var(<var-name>)' or 'unset-var(<var-name>)'",
745 args[*arg-1]);
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200746 return ACT_RET_PRS_ERR;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200747 }
748 var_name++; /* jump the '(' */
749 var_len = strlen(var_name);
750 var_len--; /* remove the ')' */
751 if (var_name[var_len] != ')') {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100752 memprintf(err, "invalid variable '%s'. Expects 'set-var(<var-name>)' or 'unset-var(<var-name>)'",
753 args[*arg-1]);
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200754 return ACT_RET_PRS_ERR;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200755 }
756
Christopher Faulet09c9df22016-10-31 11:05:37 +0100757 rule->arg.vars.name = register_name(var_name, var_len, &rule->arg.vars.scope, 1, err);
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200758 if (!rule->arg.vars.name)
759 return ACT_RET_PRS_ERR;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200760
Christopher Faulet85d79c92016-11-09 16:54:56 +0100761 /* There is no fetch method when variable is unset. Just set the right
762 * action and return. */
763 if (!set_var) {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100764 rule->action = ACT_CUSTOM;
765 rule->action_ptr = action_clear;
Tim Duesterhus01a0ce32020-06-14 17:27:36 +0200766 rule->release_ptr = release_store_rule;
Christopher Faulet85d79c92016-11-09 16:54:56 +0100767 return ACT_RET_PRS_OK;
768 }
769
Thierry FOURNIER48a9cd12015-07-28 19:00:28 +0200770 kw_name = args[*arg-1];
771
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200772 rule->arg.vars.expr = sample_parse_expr((char **)args, arg, px->conf.args.file,
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100773 px->conf.args.line, err, &px->conf.args, NULL);
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200774 if (!rule->arg.vars.expr)
Thierry FOURNIERafa80492015-08-19 09:04:15 +0200775 return ACT_RET_PRS_ERR;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200776
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200777 switch (rule->from) {
Willy Tarreau620408f2016-10-21 16:37:51 +0200778 case ACT_F_TCP_REQ_SES: flags = SMP_VAL_FE_SES_ACC; break;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200779 case ACT_F_TCP_REQ_CNT: flags = SMP_VAL_FE_REQ_CNT; break;
780 case ACT_F_TCP_RES_CNT: flags = SMP_VAL_BE_RES_CNT; break;
781 case ACT_F_HTTP_REQ: flags = SMP_VAL_FE_HRQ_HDR; break;
782 case ACT_F_HTTP_RES: flags = SMP_VAL_BE_HRS_HDR; break;
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100783 case ACT_F_TCP_CHK: flags = SMP_VAL_BE_CHK_RUL; break;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200784 default:
785 memprintf(err,
786 "internal error, unexpected rule->from=%d, please report this bug!",
787 rule->from);
Thierry FOURNIERafa80492015-08-19 09:04:15 +0200788 return ACT_RET_PRS_ERR;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200789 }
790 if (!(rule->arg.vars.expr->fetch->val & flags)) {
791 memprintf(err,
792 "fetch method '%s' extracts information from '%s', none of which is available here",
793 kw_name, sample_src_names(rule->arg.vars.expr->fetch->use));
794 free(rule->arg.vars.expr);
Thierry FOURNIERafa80492015-08-19 09:04:15 +0200795 return ACT_RET_PRS_ERR;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200796 }
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200797
Thierry FOURNIER42148732015-09-02 17:17:33 +0200798 rule->action = ACT_CUSTOM;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200799 rule->action_ptr = action_store;
Tim Duesterhus01a0ce32020-06-14 17:27:36 +0200800 rule->release_ptr = release_store_rule;
Thierry FOURNIERafa80492015-08-19 09:04:15 +0200801 return ACT_RET_PRS_OK;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200802}
803
804static int vars_max_size(char **args, int section_type, struct proxy *curpx,
805 struct proxy *defpx, const char *file, int line,
806 char **err, unsigned int *limit)
807{
808 char *error;
809
810 *limit = strtol(args[1], &error, 10);
811 if (*error != 0) {
812 memprintf(err, "%s: '%s' is an invalid size", args[0], args[1]);
813 return -1;
814 }
815 return 0;
816}
817
818static int vars_max_size_global(char **args, int section_type, struct proxy *curpx,
819 struct proxy *defpx, const char *file, int line,
820 char **err)
821{
822 return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_global_limit);
823}
824
Christopher Fauletff2613e2016-11-09 11:36:17 +0100825static int vars_max_size_proc(char **args, int section_type, struct proxy *curpx,
826 struct proxy *defpx, const char *file, int line,
827 char **err)
828{
829 return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_proc_limit);
830}
831
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200832static int vars_max_size_sess(char **args, int section_type, struct proxy *curpx,
833 struct proxy *defpx, const char *file, int line,
834 char **err)
835{
836 return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_sess_limit);
837}
838
839static int vars_max_size_txn(char **args, int section_type, struct proxy *curpx,
840 struct proxy *defpx, const char *file, int line,
841 char **err)
842{
843 return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_txn_limit);
844}
845
846static int vars_max_size_reqres(char **args, int section_type, struct proxy *curpx,
847 struct proxy *defpx, const char *file, int line,
848 char **err)
849{
850 return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_reqres_limit);
851}
852
Gaetan Rivet13a50432020-02-21 18:13:44 +0100853static int vars_max_size_check(char **args, int section_type, struct proxy *curpx,
854 struct proxy *defpx, const char *file, int line,
855 char **err)
856{
857 return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_check_limit);
858}
859
Tim Duesterhusbbdd5b82020-07-04 11:53:25 +0200860static void vars_deinit()
861{
862 while (var_names_nb-- > 0)
863 free(var_names[var_names_nb]);
864 free(var_names);
865}
866
867REGISTER_POST_DEINIT(vars_deinit);
868
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200869static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, {
870
Christopher Fauletff2613e2016-11-09 11:36:17 +0100871 { "var", smp_fetch_var, ARG1(1,STR), smp_check_var, SMP_T_STR, SMP_USE_L4CLI },
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200872 { /* END */ },
873}};
874
Willy Tarreau0108d902018-11-25 19:14:37 +0100875INITCALL1(STG_REGISTER, sample_register_fetches, &sample_fetch_keywords);
876
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200877static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100878 { "set-var", smp_conv_store, ARG1(1,STR), conv_check_var, SMP_T_ANY, SMP_T_ANY },
879 { "unset-var", smp_conv_clear, ARG1(1,STR), conv_check_var, SMP_T_ANY, SMP_T_ANY },
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200880 { /* END */ },
881}};
882
Willy Tarreau0108d902018-11-25 19:14:37 +0100883INITCALL1(STG_REGISTER, sample_register_convs, &sample_conv_kws);
884
Willy Tarreau620408f2016-10-21 16:37:51 +0200885static struct action_kw_list tcp_req_sess_kws = { { }, {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100886 { "set-var", parse_store, 1 },
887 { "unset-var", parse_store, 1 },
Willy Tarreau620408f2016-10-21 16:37:51 +0200888 { /* END */ }
889}};
890
Willy Tarreau0108d902018-11-25 19:14:37 +0100891INITCALL1(STG_REGISTER, tcp_req_sess_keywords_register, &tcp_req_sess_kws);
892
Willy Tarreau620408f2016-10-21 16:37:51 +0200893static struct action_kw_list tcp_req_cont_kws = { { }, {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100894 { "set-var", parse_store, 1 },
895 { "unset-var", parse_store, 1 },
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200896 { /* END */ }
897}};
898
Willy Tarreau0108d902018-11-25 19:14:37 +0100899INITCALL1(STG_REGISTER, tcp_req_cont_keywords_register, &tcp_req_cont_kws);
900
Thierry FOURNIER36481b82015-08-19 09:01:53 +0200901static struct action_kw_list tcp_res_kws = { { }, {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100902 { "set-var", parse_store, 1 },
903 { "unset-var", parse_store, 1 },
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200904 { /* END */ }
905}};
906
Willy Tarreau0108d902018-11-25 19:14:37 +0100907INITCALL1(STG_REGISTER, tcp_res_cont_keywords_register, &tcp_res_kws);
908
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100909static struct action_kw_list tcp_check_kws = {ILH, {
910 { "set-var", parse_store, 1 },
911 { "unset-var", parse_store, 1 },
912 { /* END */ }
913}};
914
915INITCALL1(STG_REGISTER, tcp_check_keywords_register, &tcp_check_kws);
916
Thierry FOURNIER36481b82015-08-19 09:01:53 +0200917static struct action_kw_list http_req_kws = { { }, {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100918 { "set-var", parse_store, 1 },
919 { "unset-var", parse_store, 1 },
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200920 { /* END */ }
921}};
922
Willy Tarreau0108d902018-11-25 19:14:37 +0100923INITCALL1(STG_REGISTER, http_req_keywords_register, &http_req_kws);
924
Thierry FOURNIER36481b82015-08-19 09:01:53 +0200925static struct action_kw_list http_res_kws = { { }, {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100926 { "set-var", parse_store, 1 },
927 { "unset-var", parse_store, 1 },
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200928 { /* END */ }
929}};
930
Willy Tarreau0108d902018-11-25 19:14:37 +0100931INITCALL1(STG_REGISTER, http_res_keywords_register, &http_res_kws);
932
Christopher Faulet6d0c3df2020-01-22 09:26:35 +0100933static struct action_kw_list http_after_res_kws = { { }, {
934 { "set-var", parse_store, 1 },
935 { "unset-var", parse_store, 1 },
936 { /* END */ }
937}};
938
939INITCALL1(STG_REGISTER, http_after_res_keywords_register, &http_after_res_kws);
940
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200941static struct cfg_kw_list cfg_kws = {{ },{
942 { CFG_GLOBAL, "tune.vars.global-max-size", vars_max_size_global },
Christopher Fauletff2613e2016-11-09 11:36:17 +0100943 { CFG_GLOBAL, "tune.vars.proc-max-size", vars_max_size_proc },
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200944 { CFG_GLOBAL, "tune.vars.sess-max-size", vars_max_size_sess },
945 { CFG_GLOBAL, "tune.vars.txn-max-size", vars_max_size_txn },
946 { CFG_GLOBAL, "tune.vars.reqres-max-size", vars_max_size_reqres },
Gaetan Rivet13a50432020-02-21 18:13:44 +0100947 { CFG_GLOBAL, "tune.vars.check-max-size", vars_max_size_check },
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200948 { /* END */ }
949}};
950
Willy Tarreau0108d902018-11-25 19:14:37 +0100951INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);