blob: a74642eb139e4f4c52b2b74fc38779904fda6664 [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 */
Willy Tarreau6204cd92016-03-10 16:33:04 +010068static void 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
Dragan Dosenbdea3952021-02-22 17:20:01 +0100588/* This function fills a sample with the variable content.
589 *
590 * Keep in mind that a sample content is duplicated by using smp_dup()
591 * and it therefore uses a pre-allocated trash chunk as returned by
592 * get_trash_chunk().
593 *
594 * Returns 1 if the sample is filled, otherwise it returns 0.
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200595 */
Willy Tarreau6204cd92016-03-10 16:33:04 +0100596int vars_get_by_name(const char *name, size_t len, struct sample *smp)
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200597{
598 struct vars *vars;
599 struct var *var;
600 enum vars_scope scope;
601
602 /* Resolve name and scope. */
Willy Tarreau0d554fd2021-05-13 13:30:12 +0200603 name = register_name(name, len, &scope, 0, NULL);
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200604 if (!name)
605 return 0;
606
607 /* Select "vars" pool according with the scope. */
Willy Tarreauf37b1402019-06-04 16:27:36 +0200608 vars = get_vars(smp->sess, smp->strm, scope);
609 if (!vars || vars->scope != scope)
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200610 return 0;
611
612 /* Get the variable entry. */
Dragan Dosenbdea3952021-02-22 17:20:01 +0100613 HA_RWLOCK_RDLOCK(VARS_LOCK, &vars->rwlock);
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200614 var = var_get(vars, name);
Dragan Dosenbdea3952021-02-22 17:20:01 +0100615 if (!var) {
616 HA_RWLOCK_RDUNLOCK(VARS_LOCK, &vars->rwlock);
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200617 return 0;
Dragan Dosenbdea3952021-02-22 17:20:01 +0100618 }
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200619
620 /* Copy sample. */
Thierry FOURNIER5cc18d42015-08-19 09:02:36 +0200621 smp->data = var->data;
Dragan Dosenbdea3952021-02-22 17:20:01 +0100622 smp_dup(smp);
623
624 HA_RWLOCK_RDUNLOCK(VARS_LOCK, &vars->rwlock);
Thierry FOURNIERc365d992015-06-09 12:27:17 +0200625 return 1;
626}
627
Dragan Dosenbdea3952021-02-22 17:20:01 +0100628/* This function fills a sample with the content of the variable described
629 * by <var_desc>.
630 *
631 * Keep in mind that a sample content is duplicated by using smp_dup()
632 * and it therefore uses a pre-allocated trash chunk as returned by
633 * get_trash_chunk().
634 *
635 * Returns 1 if the sample is filled, otherwise it returns 0.
Thierry FOURNIERfd77e052015-07-07 21:20:42 +0200636 */
Willy Tarreau6204cd92016-03-10 16:33:04 +0100637int vars_get_by_desc(const struct var_desc *var_desc, struct sample *smp)
Thierry FOURNIERfd77e052015-07-07 21:20:42 +0200638{
639 struct vars *vars;
640 struct var *var;
641
642 /* Select "vars" pool according with the scope. */
Willy Tarreauf37b1402019-06-04 16:27:36 +0200643 vars = get_vars(smp->sess, smp->strm, var_desc->scope);
Thierry FOURNIERfd77e052015-07-07 21:20:42 +0200644
Joseph Herlant07676892018-11-15 09:19:50 -0800645 /* Check if the scope is available a this point of processing. */
Willy Tarreauf37b1402019-06-04 16:27:36 +0200646 if (!vars || vars->scope != var_desc->scope)
Thierry FOURNIERfd77e052015-07-07 21:20:42 +0200647 return 0;
648
649 /* Get the variable entry. */
Dragan Dosenbdea3952021-02-22 17:20:01 +0100650 HA_RWLOCK_RDLOCK(VARS_LOCK, &vars->rwlock);
Thierry FOURNIERfd77e052015-07-07 21:20:42 +0200651 var = var_get(vars, var_desc->name);
Dragan Dosenbdea3952021-02-22 17:20:01 +0100652 if (!var) {
653 HA_RWLOCK_RDUNLOCK(VARS_LOCK, &vars->rwlock);
Thierry FOURNIERfd77e052015-07-07 21:20:42 +0200654 return 0;
Dragan Dosenbdea3952021-02-22 17:20:01 +0100655 }
Thierry FOURNIERfd77e052015-07-07 21:20:42 +0200656
657 /* Copy sample. */
Thierry FOURNIER5cc18d42015-08-19 09:02:36 +0200658 smp->data = var->data;
Dragan Dosenbdea3952021-02-22 17:20:01 +0100659 smp_dup(smp);
660
661 HA_RWLOCK_RDUNLOCK(VARS_LOCK, &vars->rwlock);
Thierry FOURNIERfd77e052015-07-07 21:20:42 +0200662 return 1;
663}
664
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200665/* Always returns ACT_RET_CONT even if an error occurs. */
666static enum act_return action_store(struct act_rule *rule, struct proxy *px,
Willy Tarreau658b85b2015-09-27 10:00:49 +0200667 struct session *sess, struct stream *s, int flags)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200668{
669 struct sample smp;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200670 int dir;
671
672 switch (rule->from) {
Willy Tarreau620408f2016-10-21 16:37:51 +0200673 case ACT_F_TCP_REQ_SES: dir = SMP_OPT_DIR_REQ; break;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200674 case ACT_F_TCP_REQ_CNT: dir = SMP_OPT_DIR_REQ; break;
675 case ACT_F_TCP_RES_CNT: dir = SMP_OPT_DIR_RES; break;
676 case ACT_F_HTTP_REQ: dir = SMP_OPT_DIR_REQ; break;
677 case ACT_F_HTTP_RES: dir = SMP_OPT_DIR_RES; break;
Gaetan Rivet0c39ecc2020-02-24 17:34:11 +0100678 case ACT_F_TCP_CHK: dir = SMP_OPT_DIR_REQ; break;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200679 default:
680 send_log(px, LOG_ERR, "Vars: internal error while execute action store.");
681 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE))
Christopher Faulet767a84b2017-11-24 16:50:31 +0100682 ha_alert("Vars: internal error while execute action store.\n");
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200683 return ACT_RET_CONT;
684 }
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200685
686 /* Process the expression. */
687 memset(&smp, 0, sizeof(smp));
Willy Tarreau108a8fd2016-10-21 17:13:24 +0200688 if (!sample_process(px, sess, s, dir|SMP_OPT_FINAL,
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200689 rule->arg.vars.expr, &smp))
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +0200690 return ACT_RET_CONT;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200691
692 /* Store the sample, and ignore errors. */
Willy Tarreau6204cd92016-03-10 16:33:04 +0100693 sample_store_stream(rule->arg.vars.name, rule->arg.vars.scope, &smp);
Thierry FOURNIER24ff6c62015-08-06 08:52:53 +0200694 return ACT_RET_CONT;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200695}
696
Christopher Faulet85d79c92016-11-09 16:54:56 +0100697/* Always returns ACT_RET_CONT even if an error occurs. */
698static enum act_return action_clear(struct act_rule *rule, struct proxy *px,
699 struct session *sess, struct stream *s, int flags)
700{
701 struct sample smp;
702
703 memset(&smp, 0, sizeof(smp));
704 smp_set_owner(&smp, px, sess, s, SMP_OPT_FINAL);
705
706 /* Clear the variable using the sample context, and ignore errors. */
707 sample_clear_stream(rule->arg.vars.name, rule->arg.vars.scope, &smp);
708 return ACT_RET_CONT;
709}
710
Tim Duesterhus01a0ce32020-06-14 17:27:36 +0200711static void release_store_rule(struct act_rule *rule)
712{
713 release_sample_expr(rule->arg.vars.expr);
714}
715
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200716/* This two function checks the variable name and replace the
717 * configuration string name by the global string name. its
718 * the same string, but the global pointer can be easy to
719 * compare.
720 *
721 * The first function checks a sample-fetch and the second
722 * checks a converter.
723 */
724static int smp_check_var(struct arg *args, char **err)
725{
726 return vars_check_arg(&args[0], err);
727}
728
729static int conv_check_var(struct arg *args, struct sample_conv *conv,
730 const char *file, int line, char **err_msg)
731{
732 return vars_check_arg(&args[0], err_msg);
733}
734
735/* This function is a common parser for using variables. It understands
736 * the format:
737 *
738 * set-var(<variable-name>) <expression>
Willy Tarreau4b7531f2019-06-04 16:43:29 +0200739 * unset-var(<variable-name>)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200740 *
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200741 * It returns ACT_RET_PRS_ERR if fails and <err> is filled with an error
742 * message. Otherwise, it returns ACT_RET_PRS_OK and the variable <expr>
743 * is filled with the pointer to the expression to execute.
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200744 */
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200745static enum act_parse_ret parse_store(const char **args, int *arg, struct proxy *px,
746 struct act_rule *rule, char **err)
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200747{
748 const char *var_name = args[*arg-1];
749 int var_len;
Thierry FOURNIER48a9cd12015-07-28 19:00:28 +0200750 const char *kw_name;
Willy Tarreaue3658152016-11-24 21:23:28 +0100751 int flags, set_var = 0;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200752
Christopher Faulet85d79c92016-11-09 16:54:56 +0100753 if (!strncmp(var_name, "set-var", 7)) {
754 var_name += 7;
755 set_var = 1;
756 }
757 if (!strncmp(var_name, "unset-var", 9)) {
758 var_name += 9;
759 set_var = 0;
760 }
761
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200762 if (*var_name != '(') {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100763 memprintf(err, "invalid variable '%s'. Expects 'set-var(<var-name>)' or 'unset-var(<var-name>)'",
764 args[*arg-1]);
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200765 return ACT_RET_PRS_ERR;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200766 }
767 var_name++; /* jump the '(' */
768 var_len = strlen(var_name);
769 var_len--; /* remove the ')' */
770 if (var_name[var_len] != ')') {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100771 memprintf(err, "invalid variable '%s'. Expects 'set-var(<var-name>)' or 'unset-var(<var-name>)'",
772 args[*arg-1]);
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200773 return ACT_RET_PRS_ERR;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200774 }
775
Christopher Faulet09c9df22016-10-31 11:05:37 +0100776 rule->arg.vars.name = register_name(var_name, var_len, &rule->arg.vars.scope, 1, err);
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200777 if (!rule->arg.vars.name)
778 return ACT_RET_PRS_ERR;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200779
Christopher Faulet85d79c92016-11-09 16:54:56 +0100780 /* There is no fetch method when variable is unset. Just set the right
781 * action and return. */
782 if (!set_var) {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100783 rule->action = ACT_CUSTOM;
784 rule->action_ptr = action_clear;
Tim Duesterhus01a0ce32020-06-14 17:27:36 +0200785 rule->release_ptr = release_store_rule;
Christopher Faulet85d79c92016-11-09 16:54:56 +0100786 return ACT_RET_PRS_OK;
787 }
788
Thierry FOURNIER48a9cd12015-07-28 19:00:28 +0200789 kw_name = args[*arg-1];
790
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200791 rule->arg.vars.expr = sample_parse_expr((char **)args, arg, px->conf.args.file,
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100792 px->conf.args.line, err, &px->conf.args, NULL);
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200793 if (!rule->arg.vars.expr)
Thierry FOURNIERafa80492015-08-19 09:04:15 +0200794 return ACT_RET_PRS_ERR;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200795
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200796 switch (rule->from) {
Willy Tarreau620408f2016-10-21 16:37:51 +0200797 case ACT_F_TCP_REQ_SES: flags = SMP_VAL_FE_SES_ACC; break;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200798 case ACT_F_TCP_REQ_CNT: flags = SMP_VAL_FE_REQ_CNT; break;
799 case ACT_F_TCP_RES_CNT: flags = SMP_VAL_BE_RES_CNT; break;
800 case ACT_F_HTTP_REQ: flags = SMP_VAL_FE_HRQ_HDR; break;
801 case ACT_F_HTTP_RES: flags = SMP_VAL_BE_HRS_HDR; break;
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100802 case ACT_F_TCP_CHK: flags = SMP_VAL_BE_CHK_RUL; break;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200803 default:
804 memprintf(err,
805 "internal error, unexpected rule->from=%d, please report this bug!",
806 rule->from);
Thierry FOURNIERafa80492015-08-19 09:04:15 +0200807 return ACT_RET_PRS_ERR;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200808 }
809 if (!(rule->arg.vars.expr->fetch->val & flags)) {
810 memprintf(err,
811 "fetch method '%s' extracts information from '%s', none of which is available here",
812 kw_name, sample_src_names(rule->arg.vars.expr->fetch->use));
813 free(rule->arg.vars.expr);
Thierry FOURNIERafa80492015-08-19 09:04:15 +0200814 return ACT_RET_PRS_ERR;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200815 }
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200816
Thierry FOURNIER42148732015-09-02 17:17:33 +0200817 rule->action = ACT_CUSTOM;
Thierry FOURNIER4dc15d12015-08-06 18:25:56 +0200818 rule->action_ptr = action_store;
Tim Duesterhus01a0ce32020-06-14 17:27:36 +0200819 rule->release_ptr = release_store_rule;
Thierry FOURNIERafa80492015-08-19 09:04:15 +0200820 return ACT_RET_PRS_OK;
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200821}
822
823static int vars_max_size(char **args, int section_type, struct proxy *curpx,
824 struct proxy *defpx, const char *file, int line,
825 char **err, unsigned int *limit)
826{
827 char *error;
828
829 *limit = strtol(args[1], &error, 10);
830 if (*error != 0) {
831 memprintf(err, "%s: '%s' is an invalid size", args[0], args[1]);
832 return -1;
833 }
834 return 0;
835}
836
837static int vars_max_size_global(char **args, int section_type, struct proxy *curpx,
838 struct proxy *defpx, const char *file, int line,
839 char **err)
840{
841 return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_global_limit);
842}
843
Christopher Fauletff2613e2016-11-09 11:36:17 +0100844static int vars_max_size_proc(char **args, int section_type, struct proxy *curpx,
845 struct proxy *defpx, const char *file, int line,
846 char **err)
847{
848 return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_proc_limit);
849}
850
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200851static int vars_max_size_sess(char **args, int section_type, struct proxy *curpx,
852 struct proxy *defpx, const char *file, int line,
853 char **err)
854{
855 return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_sess_limit);
856}
857
858static int vars_max_size_txn(char **args, int section_type, struct proxy *curpx,
859 struct proxy *defpx, const char *file, int line,
860 char **err)
861{
862 return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_txn_limit);
863}
864
865static int vars_max_size_reqres(char **args, int section_type, struct proxy *curpx,
866 struct proxy *defpx, const char *file, int line,
867 char **err)
868{
869 return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_reqres_limit);
870}
871
Gaetan Rivet13a50432020-02-21 18:13:44 +0100872static int vars_max_size_check(char **args, int section_type, struct proxy *curpx,
873 struct proxy *defpx, const char *file, int line,
874 char **err)
875{
876 return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_check_limit);
877}
878
Tim Duesterhusbbdd5b82020-07-04 11:53:25 +0200879static void vars_deinit()
880{
881 while (var_names_nb-- > 0)
882 free(var_names[var_names_nb]);
883 free(var_names);
884}
885
886REGISTER_POST_DEINIT(vars_deinit);
887
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200888static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, {
889
Christopher Fauletff2613e2016-11-09 11:36:17 +0100890 { "var", smp_fetch_var, ARG1(1,STR), smp_check_var, SMP_T_STR, SMP_USE_L4CLI },
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200891 { /* END */ },
892}};
893
Willy Tarreau0108d902018-11-25 19:14:37 +0100894INITCALL1(STG_REGISTER, sample_register_fetches, &sample_fetch_keywords);
895
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200896static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100897 { "set-var", smp_conv_store, ARG1(1,STR), conv_check_var, SMP_T_ANY, SMP_T_ANY },
898 { "unset-var", smp_conv_clear, ARG1(1,STR), conv_check_var, SMP_T_ANY, SMP_T_ANY },
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200899 { /* END */ },
900}};
901
Willy Tarreau0108d902018-11-25 19:14:37 +0100902INITCALL1(STG_REGISTER, sample_register_convs, &sample_conv_kws);
903
Willy Tarreau620408f2016-10-21 16:37:51 +0200904static struct action_kw_list tcp_req_sess_kws = { { }, {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100905 { "set-var", parse_store, 1 },
906 { "unset-var", parse_store, 1 },
Willy Tarreau620408f2016-10-21 16:37:51 +0200907 { /* END */ }
908}};
909
Willy Tarreau0108d902018-11-25 19:14:37 +0100910INITCALL1(STG_REGISTER, tcp_req_sess_keywords_register, &tcp_req_sess_kws);
911
Willy Tarreau620408f2016-10-21 16:37:51 +0200912static struct action_kw_list tcp_req_cont_kws = { { }, {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100913 { "set-var", parse_store, 1 },
914 { "unset-var", parse_store, 1 },
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200915 { /* END */ }
916}};
917
Willy Tarreau0108d902018-11-25 19:14:37 +0100918INITCALL1(STG_REGISTER, tcp_req_cont_keywords_register, &tcp_req_cont_kws);
919
Thierry FOURNIER36481b82015-08-19 09:01:53 +0200920static struct action_kw_list tcp_res_kws = { { }, {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100921 { "set-var", parse_store, 1 },
922 { "unset-var", parse_store, 1 },
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200923 { /* END */ }
924}};
925
Willy Tarreau0108d902018-11-25 19:14:37 +0100926INITCALL1(STG_REGISTER, tcp_res_cont_keywords_register, &tcp_res_kws);
927
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100928static struct action_kw_list tcp_check_kws = {ILH, {
929 { "set-var", parse_store, 1 },
930 { "unset-var", parse_store, 1 },
931 { /* END */ }
932}};
933
934INITCALL1(STG_REGISTER, tcp_check_keywords_register, &tcp_check_kws);
935
Thierry FOURNIER36481b82015-08-19 09:01:53 +0200936static struct action_kw_list http_req_kws = { { }, {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100937 { "set-var", parse_store, 1 },
938 { "unset-var", parse_store, 1 },
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200939 { /* END */ }
940}};
941
Willy Tarreau0108d902018-11-25 19:14:37 +0100942INITCALL1(STG_REGISTER, http_req_keywords_register, &http_req_kws);
943
Thierry FOURNIER36481b82015-08-19 09:01:53 +0200944static struct action_kw_list http_res_kws = { { }, {
Christopher Faulet85d79c92016-11-09 16:54:56 +0100945 { "set-var", parse_store, 1 },
946 { "unset-var", parse_store, 1 },
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200947 { /* END */ }
948}};
949
Willy Tarreau0108d902018-11-25 19:14:37 +0100950INITCALL1(STG_REGISTER, http_res_keywords_register, &http_res_kws);
951
Christopher Faulet6d0c3df2020-01-22 09:26:35 +0100952static struct action_kw_list http_after_res_kws = { { }, {
953 { "set-var", parse_store, 1 },
954 { "unset-var", parse_store, 1 },
955 { /* END */ }
956}};
957
958INITCALL1(STG_REGISTER, http_after_res_keywords_register, &http_after_res_kws);
959
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200960static struct cfg_kw_list cfg_kws = {{ },{
961 { CFG_GLOBAL, "tune.vars.global-max-size", vars_max_size_global },
Christopher Fauletff2613e2016-11-09 11:36:17 +0100962 { CFG_GLOBAL, "tune.vars.proc-max-size", vars_max_size_proc },
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200963 { CFG_GLOBAL, "tune.vars.sess-max-size", vars_max_size_sess },
964 { CFG_GLOBAL, "tune.vars.txn-max-size", vars_max_size_txn },
965 { CFG_GLOBAL, "tune.vars.reqres-max-size", vars_max_size_reqres },
Gaetan Rivet13a50432020-02-21 18:13:44 +0100966 { CFG_GLOBAL, "tune.vars.check-max-size", vars_max_size_check },
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200967 { /* END */ }
968}};
969
Willy Tarreau0108d902018-11-25 19:14:37 +0100970INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);