Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1 | #include <ctype.h> |
| 2 | |
Willy Tarreau | 4c7e4b7 | 2020-05-27 12:58:42 +0200 | [diff] [blame] | 3 | #include <haproxy/api.h> |
Willy Tarreau | b255105 | 2020-06-09 09:07:15 +0200 | [diff] [blame] | 4 | #include <haproxy/arg.h> |
Willy Tarreau | c35eb38 | 2021-03-26 14:51:31 +0100 | [diff] [blame] | 5 | #include <haproxy/buf.h> |
Willy Tarreau | 6be7849 | 2020-06-05 00:00:29 +0200 | [diff] [blame] | 6 | #include <haproxy/cfgparse.h> |
Willy Tarreau | 4aa573d | 2020-06-04 18:21:56 +0200 | [diff] [blame] | 7 | #include <haproxy/check.h> |
Willy Tarreau | c35eb38 | 2021-03-26 14:51:31 +0100 | [diff] [blame] | 8 | #include <haproxy/cli.h> |
Willy Tarreau | dfd3de8 | 2020-06-04 23:46:14 +0200 | [diff] [blame] | 9 | #include <haproxy/global.h> |
Willy Tarreau | cd72d8c | 2020-06-02 19:11:26 +0200 | [diff] [blame] | 10 | #include <haproxy/http.h> |
Willy Tarreau | c761f84 | 2020-06-04 11:40:28 +0200 | [diff] [blame] | 11 | #include <haproxy/http_rules.h> |
Willy Tarreau | 853b297 | 2020-05-27 18:01:47 +0200 | [diff] [blame] | 12 | #include <haproxy/list.h> |
Willy Tarreau | 36979d9 | 2020-06-05 17:27:29 +0200 | [diff] [blame] | 13 | #include <haproxy/log.h> |
Willy Tarreau | e6ce10b | 2020-06-04 15:33:47 +0200 | [diff] [blame] | 14 | #include <haproxy/sample.h> |
Willy Tarreau | dfd3de8 | 2020-06-04 23:46:14 +0200 | [diff] [blame] | 15 | #include <haproxy/stream-t.h> |
Willy Tarreau | 8b550af | 2020-06-04 17:42:48 +0200 | [diff] [blame] | 16 | #include <haproxy/tcp_rules.h> |
Willy Tarreau | b255105 | 2020-06-09 09:07:15 +0200 | [diff] [blame] | 17 | #include <haproxy/tcpcheck.h> |
Willy Tarreau | a171892 | 2020-06-04 16:25:31 +0200 | [diff] [blame] | 18 | #include <haproxy/vars.h> |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 19 | |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 20 | |
| 21 | /* This contains a pool of struct vars */ |
Willy Tarreau | 8ceae72 | 2018-11-26 11:58:30 +0100 | [diff] [blame] | 22 | DECLARE_STATIC_POOL(var_pool, "vars", sizeof(struct var)); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 23 | |
Willy Tarreau | cfc4f24 | 2021-05-08 11:41:28 +0200 | [diff] [blame] | 24 | /* list of variables for the process scope. */ |
| 25 | struct vars proc_vars THREAD_ALIGNED(64); |
| 26 | |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 27 | /* This array contain all the names of all the HAProxy vars. |
| 28 | * This permits to identify two variables name with |
| 29 | * only one pointer. It permits to not using strdup() for |
| 30 | * each variable name used during the runtime. |
| 31 | */ |
| 32 | static char **var_names = NULL; |
| 33 | static int var_names_nb = 0; |
| 34 | |
| 35 | /* This array of int contains the system limits per context. */ |
| 36 | static unsigned int var_global_limit = 0; |
| 37 | static unsigned int var_global_size = 0; |
Christopher Faulet | ff2613e | 2016-11-09 11:36:17 +0100 | [diff] [blame] | 38 | static unsigned int var_proc_limit = 0; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 39 | static unsigned int var_sess_limit = 0; |
| 40 | static unsigned int var_txn_limit = 0; |
| 41 | static unsigned int var_reqres_limit = 0; |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 42 | static unsigned int var_check_limit = 0; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 43 | |
Willy Tarreau | 86abe44 | 2018-11-25 20:12:18 +0100 | [diff] [blame] | 44 | __decl_rwlock(var_names_rwlock); |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 45 | |
Willy Tarreau | f37b140 | 2019-06-04 16:27:36 +0200 | [diff] [blame] | 46 | /* returns the struct vars pointer for a session, stream and scope, or NULL if |
| 47 | * it does not exist. |
| 48 | */ |
| 49 | static inline struct vars *get_vars(struct session *sess, struct stream *strm, enum vars_scope scope) |
| 50 | { |
| 51 | switch (scope) { |
| 52 | case SCOPE_PROC: |
Willy Tarreau | cfc4f24 | 2021-05-08 11:41:28 +0200 | [diff] [blame] | 53 | return &proc_vars; |
Willy Tarreau | f37b140 | 2019-06-04 16:27:36 +0200 | [diff] [blame] | 54 | case SCOPE_SESS: |
Willy Tarreau | a07d61b | 2021-03-26 11:27:59 +0100 | [diff] [blame] | 55 | return sess ? &sess->vars : NULL; |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 56 | case SCOPE_CHECK: { |
Christopher Faulet | 0fca7ed | 2020-04-21 11:53:32 +0200 | [diff] [blame] | 57 | struct check *check = objt_check(sess->origin); |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 58 | |
Christopher Faulet | 0fca7ed | 2020-04-21 11:53:32 +0200 | [diff] [blame] | 59 | return check ? &check->vars : NULL; |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 60 | } |
Willy Tarreau | f37b140 | 2019-06-04 16:27:36 +0200 | [diff] [blame] | 61 | case SCOPE_TXN: |
| 62 | return strm ? &strm->vars_txn : NULL; |
| 63 | case SCOPE_REQ: |
| 64 | case SCOPE_RES: |
| 65 | default: |
| 66 | return strm ? &strm->vars_reqres : NULL; |
| 67 | } |
| 68 | } |
| 69 | |
Willy Tarreau | 7233098 | 2015-06-19 11:21:56 +0200 | [diff] [blame] | 70 | /* This function adds or remove memory size from the accounting. The inner |
| 71 | * pointers may be null when setting the outer ones only. |
| 72 | */ |
Miroslav Zagorac | 6deab79 | 2020-12-09 16:34:29 +0100 | [diff] [blame] | 73 | void var_accounting_diff(struct vars *vars, struct session *sess, struct stream *strm, int size) |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 74 | { |
| 75 | switch (vars->scope) { |
| 76 | case SCOPE_REQ: |
| 77 | case SCOPE_RES: |
Willy Tarreau | f37b140 | 2019-06-04 16:27:36 +0200 | [diff] [blame] | 78 | if (strm) |
| 79 | _HA_ATOMIC_ADD(&strm->vars_reqres.size, size); |
Willy Tarreau | 6204cd9 | 2016-03-10 16:33:04 +0100 | [diff] [blame] | 80 | /* fall through */ |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 81 | case SCOPE_TXN: |
Willy Tarreau | f37b140 | 2019-06-04 16:27:36 +0200 | [diff] [blame] | 82 | if (strm) |
| 83 | _HA_ATOMIC_ADD(&strm->vars_txn.size, size); |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 84 | goto scope_sess; |
| 85 | case SCOPE_CHECK: { |
Christopher Faulet | 0fca7ed | 2020-04-21 11:53:32 +0200 | [diff] [blame] | 86 | struct check *check = objt_check(sess->origin); |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 87 | |
Christopher Faulet | 0fca7ed | 2020-04-21 11:53:32 +0200 | [diff] [blame] | 88 | if (check) |
| 89 | _HA_ATOMIC_ADD(&check->vars.size, size); |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 90 | } |
Willy Tarreau | 6204cd9 | 2016-03-10 16:33:04 +0100 | [diff] [blame] | 91 | /* fall through */ |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 92 | scope_sess: |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 93 | case SCOPE_SESS: |
Olivier Houchard | 25ad13f | 2019-03-08 18:55:38 +0100 | [diff] [blame] | 94 | _HA_ATOMIC_ADD(&sess->vars.size, size); |
Christopher Faulet | ff2613e | 2016-11-09 11:36:17 +0100 | [diff] [blame] | 95 | /* fall through */ |
| 96 | case SCOPE_PROC: |
Willy Tarreau | cfc4f24 | 2021-05-08 11:41:28 +0200 | [diff] [blame] | 97 | _HA_ATOMIC_ADD(&proc_vars.size, size); |
Olivier Houchard | 25ad13f | 2019-03-08 18:55:38 +0100 | [diff] [blame] | 98 | _HA_ATOMIC_ADD(&var_global_size, size); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 99 | } |
| 100 | } |
| 101 | |
| 102 | /* This function returns 1 if the <size> is available in the var |
Joseph Herlant | 0767689 | 2018-11-15 09:19:50 -0800 | [diff] [blame] | 103 | * pool <vars>, otherwise returns 0. If the space is available, |
Willy Tarreau | 7233098 | 2015-06-19 11:21:56 +0200 | [diff] [blame] | 104 | * the size is reserved. The inner pointers may be null when setting |
Willy Tarreau | 6204cd9 | 2016-03-10 16:33:04 +0100 | [diff] [blame] | 105 | * the outer ones only. The accounting uses either <sess> or <strm> |
| 106 | * depending on the scope. <strm> may be NULL when no stream is known |
| 107 | * and only the session exists (eg: tcp-request connection). |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 108 | */ |
Willy Tarreau | 6204cd9 | 2016-03-10 16:33:04 +0100 | [diff] [blame] | 109 | static int var_accounting_add(struct vars *vars, struct session *sess, struct stream *strm, int size) |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 110 | { |
| 111 | switch (vars->scope) { |
| 112 | case SCOPE_REQ: |
| 113 | case SCOPE_RES: |
Willy Tarreau | f37b140 | 2019-06-04 16:27:36 +0200 | [diff] [blame] | 114 | if (var_reqres_limit && strm && strm->vars_reqres.size + size > var_reqres_limit) |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 115 | return 0; |
Willy Tarreau | 6204cd9 | 2016-03-10 16:33:04 +0100 | [diff] [blame] | 116 | /* fall through */ |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 117 | case SCOPE_TXN: |
Willy Tarreau | f37b140 | 2019-06-04 16:27:36 +0200 | [diff] [blame] | 118 | if (var_txn_limit && strm && strm->vars_txn.size + size > var_txn_limit) |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 119 | return 0; |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 120 | goto scope_sess; |
| 121 | case SCOPE_CHECK: { |
Christopher Faulet | 0fca7ed | 2020-04-21 11:53:32 +0200 | [diff] [blame] | 122 | struct check *check = objt_check(sess->origin); |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 123 | |
Christopher Faulet | 0fca7ed | 2020-04-21 11:53:32 +0200 | [diff] [blame] | 124 | if (var_check_limit && check && check->vars.size + size > var_check_limit) |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 125 | return 0; |
| 126 | } |
Willy Tarreau | 6204cd9 | 2016-03-10 16:33:04 +0100 | [diff] [blame] | 127 | /* fall through */ |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 128 | scope_sess: |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 129 | case SCOPE_SESS: |
Willy Tarreau | 6204cd9 | 2016-03-10 16:33:04 +0100 | [diff] [blame] | 130 | if (var_sess_limit && sess->vars.size + size > var_sess_limit) |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 131 | return 0; |
Christopher Faulet | ff2613e | 2016-11-09 11:36:17 +0100 | [diff] [blame] | 132 | /* fall through */ |
| 133 | case SCOPE_PROC: |
Willy Tarreau | cfc4f24 | 2021-05-08 11:41:28 +0200 | [diff] [blame] | 134 | if (var_proc_limit && proc_vars.size + size > var_proc_limit) |
Christopher Faulet | ff2613e | 2016-11-09 11:36:17 +0100 | [diff] [blame] | 135 | return 0; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 136 | if (var_global_limit && var_global_size + size > var_global_limit) |
| 137 | return 0; |
| 138 | } |
Willy Tarreau | 6204cd9 | 2016-03-10 16:33:04 +0100 | [diff] [blame] | 139 | var_accounting_diff(vars, sess, strm, size); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 140 | return 1; |
| 141 | } |
| 142 | |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 143 | /* This fnuction remove a variable from the list and free memory it used */ |
| 144 | unsigned int var_clear(struct var *var) |
| 145 | { |
| 146 | unsigned int size = 0; |
| 147 | |
| 148 | if (var->data.type == SMP_T_STR || var->data.type == SMP_T_BIN) { |
Willy Tarreau | 5b52b00 | 2021-02-26 21:19:53 +0100 | [diff] [blame] | 149 | ha_free(&var->data.u.str.area); |
Willy Tarreau | 843b7cb | 2018-07-13 10:54:26 +0200 | [diff] [blame] | 150 | size += var->data.u.str.data; |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 151 | } |
Christopher Faulet | d02210c | 2017-07-24 16:24:39 +0200 | [diff] [blame] | 152 | else if (var->data.type == SMP_T_METH && var->data.u.meth.meth == HTTP_METH_OTHER) { |
Willy Tarreau | 5b52b00 | 2021-02-26 21:19:53 +0100 | [diff] [blame] | 153 | ha_free(&var->data.u.meth.str.area); |
Willy Tarreau | 843b7cb | 2018-07-13 10:54:26 +0200 | [diff] [blame] | 154 | size += var->data.u.meth.str.data; |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 155 | } |
Willy Tarreau | 2b71810 | 2021-04-21 07:32:39 +0200 | [diff] [blame] | 156 | LIST_DELETE(&var->l); |
Willy Tarreau | bafbe01 | 2017-11-24 17:34:44 +0100 | [diff] [blame] | 157 | pool_free(var_pool, var); |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 158 | size += sizeof(struct var); |
| 159 | return size; |
| 160 | } |
| 161 | |
Joseph Herlant | 0767689 | 2018-11-15 09:19:50 -0800 | [diff] [blame] | 162 | /* This function free all the memory used by all the variables |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 163 | * in the list. |
| 164 | */ |
Willy Tarreau | 6204cd9 | 2016-03-10 16:33:04 +0100 | [diff] [blame] | 165 | void vars_prune(struct vars *vars, struct session *sess, struct stream *strm) |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 166 | { |
| 167 | struct var *var, *tmp; |
Willy Tarreau | 7233098 | 2015-06-19 11:21:56 +0200 | [diff] [blame] | 168 | unsigned int size = 0; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 169 | |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 170 | HA_RWLOCK_WRLOCK(VARS_LOCK, &vars->rwlock); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 171 | list_for_each_entry_safe(var, tmp, &vars->head, l) { |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 172 | size += var_clear(var); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 173 | } |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 174 | HA_RWLOCK_WRUNLOCK(VARS_LOCK, &vars->rwlock); |
Willy Tarreau | 6204cd9 | 2016-03-10 16:33:04 +0100 | [diff] [blame] | 175 | var_accounting_diff(vars, sess, strm, -size); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 176 | } |
| 177 | |
Willy Tarreau | ebcd484 | 2015-06-19 11:59:02 +0200 | [diff] [blame] | 178 | /* This function frees all the memory used by all the session variables in the |
| 179 | * list starting at <vars>. |
| 180 | */ |
| 181 | void vars_prune_per_sess(struct vars *vars) |
| 182 | { |
| 183 | struct var *var, *tmp; |
| 184 | unsigned int size = 0; |
| 185 | |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 186 | HA_RWLOCK_WRLOCK(VARS_LOCK, &vars->rwlock); |
Willy Tarreau | ebcd484 | 2015-06-19 11:59:02 +0200 | [diff] [blame] | 187 | list_for_each_entry_safe(var, tmp, &vars->head, l) { |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 188 | size += var_clear(var); |
Willy Tarreau | ebcd484 | 2015-06-19 11:59:02 +0200 | [diff] [blame] | 189 | } |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 190 | HA_RWLOCK_WRUNLOCK(VARS_LOCK, &vars->rwlock); |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 191 | |
Olivier Houchard | 25ad13f | 2019-03-08 18:55:38 +0100 | [diff] [blame] | 192 | _HA_ATOMIC_SUB(&vars->size, size); |
Willy Tarreau | cfc4f24 | 2021-05-08 11:41:28 +0200 | [diff] [blame] | 193 | _HA_ATOMIC_SUB(&proc_vars.size, size); |
Olivier Houchard | 25ad13f | 2019-03-08 18:55:38 +0100 | [diff] [blame] | 194 | _HA_ATOMIC_SUB(&var_global_size, size); |
Willy Tarreau | ebcd484 | 2015-06-19 11:59:02 +0200 | [diff] [blame] | 195 | } |
| 196 | |
Ilya Shipitsin | 46a030c | 2020-07-05 16:36:08 +0500 | [diff] [blame] | 197 | /* This function init a list of variables. */ |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 198 | void vars_init(struct vars *vars, enum vars_scope scope) |
| 199 | { |
| 200 | LIST_INIT(&vars->head); |
| 201 | vars->scope = scope; |
| 202 | vars->size = 0; |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 203 | HA_RWLOCK_INIT(&vars->rwlock); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 204 | } |
| 205 | |
| 206 | /* This function declares a new variable name. It returns a pointer |
| 207 | * on the string identifying the name. This function assures that |
| 208 | * the same name exists only once. |
| 209 | * |
| 210 | * This function check if the variable name is acceptable. |
| 211 | * |
| 212 | * The function returns NULL if an error occurs, and <err> is filled. |
| 213 | * In this case, the HAProxy must be stopped because the structs are |
| 214 | * left inconsistent. Otherwise, it returns the pointer on the global |
| 215 | * name. |
| 216 | */ |
Christopher Faulet | 09c9df2 | 2016-10-31 11:05:37 +0100 | [diff] [blame] | 217 | static char *register_name(const char *name, int len, enum vars_scope *scope, |
| 218 | int alloc, char **err) |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 219 | { |
| 220 | int i; |
Hubert Verstraete | 831962e | 2016-06-28 22:44:26 +0200 | [diff] [blame] | 221 | char **var_names2; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 222 | const char *tmp; |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 223 | char *res = NULL; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 224 | |
| 225 | /* Check length. */ |
| 226 | if (len == 0) { |
| 227 | memprintf(err, "Empty variable name cannot be accepted"); |
Christopher Faulet | eb3e276 | 2017-12-08 09:17:39 +0100 | [diff] [blame] | 228 | return res; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 229 | } |
| 230 | |
| 231 | /* Check scope. */ |
Christopher Faulet | ff2613e | 2016-11-09 11:36:17 +0100 | [diff] [blame] | 232 | if (len > 5 && strncmp(name, "proc.", 5) == 0) { |
| 233 | name += 5; |
| 234 | len -= 5; |
| 235 | *scope = SCOPE_PROC; |
| 236 | } |
| 237 | else if (len > 5 && strncmp(name, "sess.", 5) == 0) { |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 238 | name += 5; |
| 239 | len -= 5; |
| 240 | *scope = SCOPE_SESS; |
| 241 | } |
| 242 | else if (len > 4 && strncmp(name, "txn.", 4) == 0) { |
| 243 | name += 4; |
| 244 | len -= 4; |
| 245 | *scope = SCOPE_TXN; |
| 246 | } |
| 247 | else if (len > 4 && strncmp(name, "req.", 4) == 0) { |
| 248 | name += 4; |
| 249 | len -= 4; |
| 250 | *scope = SCOPE_REQ; |
| 251 | } |
| 252 | else if (len > 4 && strncmp(name, "res.", 4) == 0) { |
| 253 | name += 4; |
| 254 | len -= 4; |
| 255 | *scope = SCOPE_RES; |
| 256 | } |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 257 | else if (len > 6 && strncmp(name, "check.", 6) == 0) { |
| 258 | name += 6; |
| 259 | len -= 6; |
| 260 | *scope = SCOPE_CHECK; |
| 261 | } |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 262 | else { |
| 263 | memprintf(err, "invalid variable name '%s'. A variable name must be start by its scope. " |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 264 | "The scope can be 'proc', 'sess', 'txn', 'req', 'res' or 'check'", name); |
Christopher Faulet | eb3e276 | 2017-12-08 09:17:39 +0100 | [diff] [blame] | 265 | return res; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 266 | } |
| 267 | |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 268 | if (alloc) |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 269 | HA_RWLOCK_WRLOCK(VARS_LOCK, &var_names_rwlock); |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 270 | else |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 271 | HA_RWLOCK_RDLOCK(VARS_LOCK, &var_names_rwlock); |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 272 | |
| 273 | |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 274 | /* Look for existing variable name. */ |
| 275 | for (i = 0; i < var_names_nb; i++) |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 276 | if (strncmp(var_names[i], name, len) == 0 && var_names[i][len] == '\0') { |
| 277 | res = var_names[i]; |
| 278 | goto end; |
| 279 | } |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 280 | |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 281 | if (!alloc) { |
| 282 | res = NULL; |
| 283 | goto end; |
| 284 | } |
Christopher Faulet | 09c9df2 | 2016-10-31 11:05:37 +0100 | [diff] [blame] | 285 | |
Hubert Verstraete | 831962e | 2016-06-28 22:44:26 +0200 | [diff] [blame] | 286 | /* Store variable name. If realloc fails, var_names remains valid */ |
| 287 | var_names2 = realloc(var_names, (var_names_nb + 1) * sizeof(*var_names)); |
| 288 | if (!var_names2) { |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 289 | memprintf(err, "out of memory error"); |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 290 | res = NULL; |
| 291 | goto end; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 292 | } |
Hubert Verstraete | 831962e | 2016-06-28 22:44:26 +0200 | [diff] [blame] | 293 | var_names_nb++; |
| 294 | var_names = var_names2; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 295 | var_names[var_names_nb - 1] = malloc(len + 1); |
| 296 | if (!var_names[var_names_nb - 1]) { |
| 297 | memprintf(err, "out of memory error"); |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 298 | res = NULL; |
| 299 | goto end; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 300 | } |
| 301 | memcpy(var_names[var_names_nb - 1], name, len); |
| 302 | var_names[var_names_nb - 1][len] = '\0'; |
| 303 | |
| 304 | /* Check variable name syntax. */ |
| 305 | tmp = var_names[var_names_nb - 1]; |
| 306 | while (*tmp) { |
Willy Tarreau | 9080711 | 2020-02-25 08:16:33 +0100 | [diff] [blame] | 307 | if (!isalnum((unsigned char)*tmp) && *tmp != '_' && *tmp != '.') { |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 308 | memprintf(err, "invalid syntax at char '%s'", tmp); |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 309 | res = NULL; |
| 310 | goto end; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 311 | } |
| 312 | tmp++; |
| 313 | } |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 314 | res = var_names[var_names_nb - 1]; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 315 | |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 316 | end: |
| 317 | if (alloc) |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 318 | HA_RWLOCK_WRUNLOCK(VARS_LOCK, &var_names_rwlock); |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 319 | else |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 320 | HA_RWLOCK_RDUNLOCK(VARS_LOCK, &var_names_rwlock); |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 321 | |
| 322 | return res; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 323 | } |
| 324 | |
| 325 | /* This function returns an existing variable or returns NULL. */ |
| 326 | static inline struct var *var_get(struct vars *vars, const char *name) |
| 327 | { |
| 328 | struct var *var; |
| 329 | |
| 330 | list_for_each_entry(var, &vars->head, l) |
| 331 | if (var->name == name) |
| 332 | return var; |
| 333 | return NULL; |
| 334 | } |
| 335 | |
| 336 | /* Returns 0 if fails, else returns 1. */ |
| 337 | static int smp_fetch_var(const struct arg *args, struct sample *smp, const char *kw, void *private) |
| 338 | { |
| 339 | const struct var_desc *var_desc = &args[0].data.var; |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 340 | |
Dragan Dosen | ec0a604 | 2021-02-22 17:39:02 +0100 | [diff] [blame] | 341 | return vars_get_by_desc(var_desc, smp); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 342 | } |
| 343 | |
| 344 | /* This function search in the <head> a variable with the same |
| 345 | * pointer value that the <name>. If the variable doesn't exists, |
| 346 | * create it. The function stores a copy of smp> if the variable. |
| 347 | * It returns 0 if fails, else returns 1. |
| 348 | */ |
Willy Tarreau | 6204cd9 | 2016-03-10 16:33:04 +0100 | [diff] [blame] | 349 | static int sample_store(struct vars *vars, const char *name, struct sample *smp) |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 350 | { |
| 351 | struct var *var; |
| 352 | |
| 353 | /* Look for existing variable name. */ |
| 354 | var = var_get(vars, name); |
| 355 | |
| 356 | if (var) { |
| 357 | /* free its used memory. */ |
| 358 | if (var->data.type == SMP_T_STR || |
| 359 | var->data.type == SMP_T_BIN) { |
Willy Tarreau | 5b52b00 | 2021-02-26 21:19:53 +0100 | [diff] [blame] | 360 | ha_free(&var->data.u.str.area); |
Willy Tarreau | 843b7cb | 2018-07-13 10:54:26 +0200 | [diff] [blame] | 361 | var_accounting_diff(vars, smp->sess, smp->strm, |
| 362 | -var->data.u.str.data); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 363 | } |
Christopher Faulet | d02210c | 2017-07-24 16:24:39 +0200 | [diff] [blame] | 364 | else if (var->data.type == SMP_T_METH && var->data.u.meth.meth == HTTP_METH_OTHER) { |
Willy Tarreau | 5b52b00 | 2021-02-26 21:19:53 +0100 | [diff] [blame] | 365 | ha_free(&var->data.u.meth.str.area); |
Willy Tarreau | 843b7cb | 2018-07-13 10:54:26 +0200 | [diff] [blame] | 366 | var_accounting_diff(vars, smp->sess, smp->strm, |
| 367 | -var->data.u.meth.str.data); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 368 | } |
| 369 | } else { |
| 370 | |
Joseph Herlant | 0767689 | 2018-11-15 09:19:50 -0800 | [diff] [blame] | 371 | /* Check memory available. */ |
Willy Tarreau | 6204cd9 | 2016-03-10 16:33:04 +0100 | [diff] [blame] | 372 | if (!var_accounting_add(vars, smp->sess, smp->strm, sizeof(struct var))) |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 373 | return 0; |
| 374 | |
| 375 | /* Create new entry. */ |
Willy Tarreau | bafbe01 | 2017-11-24 17:34:44 +0100 | [diff] [blame] | 376 | var = pool_alloc(var_pool); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 377 | if (!var) |
| 378 | return 0; |
Willy Tarreau | 2b71810 | 2021-04-21 07:32:39 +0200 | [diff] [blame] | 379 | LIST_APPEND(&vars->head, &var->l); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 380 | var->name = name; |
| 381 | } |
| 382 | |
| 383 | /* Set type. */ |
Thierry FOURNIER | 8c542ca | 2015-08-19 09:00:18 +0200 | [diff] [blame] | 384 | var->data.type = smp->data.type; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 385 | |
| 386 | /* Copy data. If the data needs memory, the function can fail. */ |
| 387 | switch (var->data.type) { |
| 388 | case SMP_T_BOOL: |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 389 | case SMP_T_SINT: |
Thierry FOURNIER | 136f9d3 | 2015-08-19 09:07:19 +0200 | [diff] [blame] | 390 | var->data.u.sint = smp->data.u.sint; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 391 | break; |
| 392 | case SMP_T_IPV4: |
Thierry FOURNIER | 136f9d3 | 2015-08-19 09:07:19 +0200 | [diff] [blame] | 393 | var->data.u.ipv4 = smp->data.u.ipv4; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 394 | break; |
| 395 | case SMP_T_IPV6: |
Thierry FOURNIER | 136f9d3 | 2015-08-19 09:07:19 +0200 | [diff] [blame] | 396 | var->data.u.ipv6 = smp->data.u.ipv6; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 397 | break; |
| 398 | case SMP_T_STR: |
| 399 | case SMP_T_BIN: |
Willy Tarreau | 843b7cb | 2018-07-13 10:54:26 +0200 | [diff] [blame] | 400 | if (!var_accounting_add(vars, smp->sess, smp->strm, smp->data.u.str.data)) { |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 401 | var->data.type = SMP_T_BOOL; /* This type doesn't use additional memory. */ |
| 402 | return 0; |
| 403 | } |
Willy Tarreau | 843b7cb | 2018-07-13 10:54:26 +0200 | [diff] [blame] | 404 | var->data.u.str.area = malloc(smp->data.u.str.data); |
| 405 | if (!var->data.u.str.area) { |
| 406 | var_accounting_diff(vars, smp->sess, smp->strm, |
| 407 | -smp->data.u.str.data); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 408 | var->data.type = SMP_T_BOOL; /* This type doesn't use additional memory. */ |
| 409 | return 0; |
| 410 | } |
Willy Tarreau | 843b7cb | 2018-07-13 10:54:26 +0200 | [diff] [blame] | 411 | var->data.u.str.data = smp->data.u.str.data; |
| 412 | memcpy(var->data.u.str.area, smp->data.u.str.area, |
| 413 | var->data.u.str.data); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 414 | break; |
| 415 | case SMP_T_METH: |
Christopher Faulet | d02210c | 2017-07-24 16:24:39 +0200 | [diff] [blame] | 416 | var->data.u.meth.meth = smp->data.u.meth.meth; |
| 417 | if (smp->data.u.meth.meth != HTTP_METH_OTHER) |
| 418 | break; |
| 419 | |
Willy Tarreau | 843b7cb | 2018-07-13 10:54:26 +0200 | [diff] [blame] | 420 | if (!var_accounting_add(vars, smp->sess, smp->strm, smp->data.u.meth.str.data)) { |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 421 | var->data.type = SMP_T_BOOL; /* This type doesn't use additional memory. */ |
| 422 | return 0; |
| 423 | } |
Willy Tarreau | 843b7cb | 2018-07-13 10:54:26 +0200 | [diff] [blame] | 424 | var->data.u.meth.str.area = malloc(smp->data.u.meth.str.data); |
| 425 | if (!var->data.u.meth.str.area) { |
| 426 | var_accounting_diff(vars, smp->sess, smp->strm, |
| 427 | -smp->data.u.meth.str.data); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 428 | var->data.type = SMP_T_BOOL; /* This type doesn't use additional memory. */ |
| 429 | return 0; |
| 430 | } |
Willy Tarreau | 843b7cb | 2018-07-13 10:54:26 +0200 | [diff] [blame] | 431 | var->data.u.meth.str.data = smp->data.u.meth.str.data; |
| 432 | var->data.u.meth.str.size = smp->data.u.meth.str.data; |
| 433 | memcpy(var->data.u.meth.str.area, smp->data.u.meth.str.area, |
| 434 | var->data.u.meth.str.data); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 435 | break; |
| 436 | } |
| 437 | return 1; |
| 438 | } |
| 439 | |
Willy Tarreau | 620408f | 2016-10-21 16:37:51 +0200 | [diff] [blame] | 440 | /* Returns 0 if fails, else returns 1. Note that stream may be null for SCOPE_SESS. */ |
Willy Tarreau | 6204cd9 | 2016-03-10 16:33:04 +0100 | [diff] [blame] | 441 | static inline int sample_store_stream(const char *name, enum vars_scope scope, struct sample *smp) |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 442 | { |
| 443 | struct vars *vars; |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 444 | int ret; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 445 | |
Willy Tarreau | f37b140 | 2019-06-04 16:27:36 +0200 | [diff] [blame] | 446 | vars = get_vars(smp->sess, smp->strm, scope); |
| 447 | if (!vars || vars->scope != scope) |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 448 | return 0; |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 449 | |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 450 | HA_RWLOCK_WRLOCK(VARS_LOCK, &vars->rwlock); |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 451 | ret = sample_store(vars, name, smp); |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 452 | HA_RWLOCK_WRUNLOCK(VARS_LOCK, &vars->rwlock); |
Christopher Faulet | e95f2c3 | 2017-07-24 16:30:34 +0200 | [diff] [blame] | 453 | return ret; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 454 | } |
| 455 | |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 456 | /* Returns 0 if fails, else returns 1. Note that stream may be null for SCOPE_SESS. */ |
| 457 | static inline int sample_clear_stream(const char *name, enum vars_scope scope, struct sample *smp) |
| 458 | { |
| 459 | struct vars *vars; |
| 460 | struct var *var; |
| 461 | unsigned int size = 0; |
| 462 | |
Willy Tarreau | f37b140 | 2019-06-04 16:27:36 +0200 | [diff] [blame] | 463 | vars = get_vars(smp->sess, smp->strm, scope); |
| 464 | if (!vars || vars->scope != scope) |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 465 | return 0; |
| 466 | |
| 467 | /* Look for existing variable name. */ |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 468 | HA_RWLOCK_WRLOCK(VARS_LOCK, &vars->rwlock); |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 469 | var = var_get(vars, name); |
| 470 | if (var) { |
| 471 | size = var_clear(var); |
| 472 | var_accounting_diff(vars, smp->sess, smp->strm, -size); |
| 473 | } |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 474 | HA_RWLOCK_WRUNLOCK(VARS_LOCK, &vars->rwlock); |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 475 | return 1; |
| 476 | } |
| 477 | |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 478 | /* Returns 0 if fails, else returns 1. */ |
| 479 | static int smp_conv_store(const struct arg *args, struct sample *smp, void *private) |
| 480 | { |
Christopher Faulet | 0099a8c | 2016-11-09 16:15:32 +0100 | [diff] [blame] | 481 | return sample_store_stream(args[0].data.var.name, args[0].data.var.scope, smp); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 482 | } |
| 483 | |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 484 | /* Returns 0 if fails, else returns 1. */ |
| 485 | static int smp_conv_clear(const struct arg *args, struct sample *smp, void *private) |
| 486 | { |
| 487 | return sample_clear_stream(args[0].data.var.name, args[0].data.var.scope, smp); |
| 488 | } |
| 489 | |
Joseph Herlant | 0767689 | 2018-11-15 09:19:50 -0800 | [diff] [blame] | 490 | /* This functions check an argument entry and fill it with a variable |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 491 | * type. The argumen must be a string. If the variable lookup fails, |
Joseph Herlant | 0767689 | 2018-11-15 09:19:50 -0800 | [diff] [blame] | 492 | * the function returns 0 and fill <err>, otherwise it returns 1. |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 493 | */ |
| 494 | int vars_check_arg(struct arg *arg, char **err) |
| 495 | { |
| 496 | char *name; |
| 497 | enum vars_scope scope; |
| 498 | |
| 499 | /* Check arg type. */ |
| 500 | if (arg->type != ARGT_STR) { |
| 501 | memprintf(err, "unexpected argument type"); |
| 502 | return 0; |
| 503 | } |
| 504 | |
| 505 | /* Register new variable name. */ |
Willy Tarreau | 843b7cb | 2018-07-13 10:54:26 +0200 | [diff] [blame] | 506 | name = register_name(arg->data.str.area, arg->data.str.data, &scope, |
| 507 | 1, |
| 508 | err); |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 509 | if (!name) |
| 510 | return 0; |
| 511 | |
Tim Duesterhus | a6cc7e8 | 2019-05-13 10:53:29 +0200 | [diff] [blame] | 512 | /* properly destroy the chunk */ |
| 513 | chunk_destroy(&arg->data.str); |
| 514 | |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 515 | /* Use the global variable name pointer. */ |
| 516 | arg->type = ARGT_VAR; |
| 517 | arg->data.var.name = name; |
| 518 | arg->data.var.scope = scope; |
| 519 | return 1; |
| 520 | } |
| 521 | |
Christopher Faulet | 09c9df2 | 2016-10-31 11:05:37 +0100 | [diff] [blame] | 522 | /* This function store a sample in a variable if it was already defined. |
Tim Duesterhus | b4fac1e | 2020-05-19 13:49:40 +0200 | [diff] [blame] | 523 | * Returns zero on failure and non-zero otherwise. The variable not being |
| 524 | * defined is treated as a failure. |
Christopher Faulet | 09c9df2 | 2016-10-31 11:05:37 +0100 | [diff] [blame] | 525 | */ |
Tim Duesterhus | b4fac1e | 2020-05-19 13:49:40 +0200 | [diff] [blame] | 526 | int vars_set_by_name_ifexist(const char *name, size_t len, struct sample *smp) |
Christopher Faulet | 09c9df2 | 2016-10-31 11:05:37 +0100 | [diff] [blame] | 527 | { |
| 528 | enum vars_scope scope; |
| 529 | |
| 530 | /* Resolve name and scope. */ |
| 531 | name = register_name(name, len, &scope, 0, NULL); |
| 532 | if (!name) |
Tim Duesterhus | b4fac1e | 2020-05-19 13:49:40 +0200 | [diff] [blame] | 533 | return 0; |
Christopher Faulet | 09c9df2 | 2016-10-31 11:05:37 +0100 | [diff] [blame] | 534 | |
Tim Duesterhus | b4fac1e | 2020-05-19 13:49:40 +0200 | [diff] [blame] | 535 | return sample_store_stream(name, scope, smp); |
Christopher Faulet | 09c9df2 | 2016-10-31 11:05:37 +0100 | [diff] [blame] | 536 | } |
| 537 | |
| 538 | |
Thierry FOURNIER | c365d99 | 2015-06-09 12:27:17 +0200 | [diff] [blame] | 539 | /* This function store a sample in a variable. |
Tim Duesterhus | b4fac1e | 2020-05-19 13:49:40 +0200 | [diff] [blame] | 540 | * Returns zero on failure and non-zero otherwise. |
Thierry FOURNIER | c365d99 | 2015-06-09 12:27:17 +0200 | [diff] [blame] | 541 | */ |
Tim Duesterhus | b4fac1e | 2020-05-19 13:49:40 +0200 | [diff] [blame] | 542 | int vars_set_by_name(const char *name, size_t len, struct sample *smp) |
Thierry FOURNIER | c365d99 | 2015-06-09 12:27:17 +0200 | [diff] [blame] | 543 | { |
| 544 | enum vars_scope scope; |
| 545 | |
| 546 | /* Resolve name and scope. */ |
Christopher Faulet | 09c9df2 | 2016-10-31 11:05:37 +0100 | [diff] [blame] | 547 | name = register_name(name, len, &scope, 1, NULL); |
Thierry FOURNIER | c365d99 | 2015-06-09 12:27:17 +0200 | [diff] [blame] | 548 | if (!name) |
Tim Duesterhus | b4fac1e | 2020-05-19 13:49:40 +0200 | [diff] [blame] | 549 | return 0; |
Thierry FOURNIER | c365d99 | 2015-06-09 12:27:17 +0200 | [diff] [blame] | 550 | |
Tim Duesterhus | b4fac1e | 2020-05-19 13:49:40 +0200 | [diff] [blame] | 551 | return sample_store_stream(name, scope, smp); |
Thierry FOURNIER | c365d99 | 2015-06-09 12:27:17 +0200 | [diff] [blame] | 552 | } |
| 553 | |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 554 | /* This function unset a variable if it was already defined. |
Tim Duesterhus | b4fac1e | 2020-05-19 13:49:40 +0200 | [diff] [blame] | 555 | * Returns zero on failure and non-zero otherwise. |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 556 | */ |
Tim Duesterhus | b4fac1e | 2020-05-19 13:49:40 +0200 | [diff] [blame] | 557 | int vars_unset_by_name_ifexist(const char *name, size_t len, struct sample *smp) |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 558 | { |
| 559 | enum vars_scope scope; |
| 560 | |
| 561 | /* Resolve name and scope. */ |
| 562 | name = register_name(name, len, &scope, 0, NULL); |
| 563 | if (!name) |
Tim Duesterhus | b4fac1e | 2020-05-19 13:49:40 +0200 | [diff] [blame] | 564 | return 0; |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 565 | |
Tim Duesterhus | b4fac1e | 2020-05-19 13:49:40 +0200 | [diff] [blame] | 566 | return sample_clear_stream(name, scope, smp); |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 567 | } |
| 568 | |
| 569 | |
Dragan Dosen | 14518f2 | 2021-02-22 17:20:01 +0100 | [diff] [blame] | 570 | /* This function fills a sample with the variable content. |
| 571 | * |
| 572 | * Keep in mind that a sample content is duplicated by using smp_dup() |
| 573 | * and it therefore uses a pre-allocated trash chunk as returned by |
| 574 | * get_trash_chunk(). |
| 575 | * |
| 576 | * Returns 1 if the sample is filled, otherwise it returns 0. |
Thierry FOURNIER | c365d99 | 2015-06-09 12:27:17 +0200 | [diff] [blame] | 577 | */ |
Willy Tarreau | 6204cd9 | 2016-03-10 16:33:04 +0100 | [diff] [blame] | 578 | int vars_get_by_name(const char *name, size_t len, struct sample *smp) |
Thierry FOURNIER | c365d99 | 2015-06-09 12:27:17 +0200 | [diff] [blame] | 579 | { |
| 580 | struct vars *vars; |
| 581 | struct var *var; |
| 582 | enum vars_scope scope; |
| 583 | |
| 584 | /* Resolve name and scope. */ |
Christopher Faulet | 09c9df2 | 2016-10-31 11:05:37 +0100 | [diff] [blame] | 585 | name = register_name(name, len, &scope, 1, NULL); |
Thierry FOURNIER | c365d99 | 2015-06-09 12:27:17 +0200 | [diff] [blame] | 586 | if (!name) |
| 587 | return 0; |
| 588 | |
| 589 | /* Select "vars" pool according with the scope. */ |
Willy Tarreau | f37b140 | 2019-06-04 16:27:36 +0200 | [diff] [blame] | 590 | vars = get_vars(smp->sess, smp->strm, scope); |
| 591 | if (!vars || vars->scope != scope) |
Thierry FOURNIER | c365d99 | 2015-06-09 12:27:17 +0200 | [diff] [blame] | 592 | return 0; |
| 593 | |
| 594 | /* Get the variable entry. */ |
Dragan Dosen | 14518f2 | 2021-02-22 17:20:01 +0100 | [diff] [blame] | 595 | HA_RWLOCK_RDLOCK(VARS_LOCK, &vars->rwlock); |
Thierry FOURNIER | c365d99 | 2015-06-09 12:27:17 +0200 | [diff] [blame] | 596 | var = var_get(vars, name); |
Dragan Dosen | 14518f2 | 2021-02-22 17:20:01 +0100 | [diff] [blame] | 597 | if (!var) { |
| 598 | HA_RWLOCK_RDUNLOCK(VARS_LOCK, &vars->rwlock); |
Thierry FOURNIER | c365d99 | 2015-06-09 12:27:17 +0200 | [diff] [blame] | 599 | return 0; |
Dragan Dosen | 14518f2 | 2021-02-22 17:20:01 +0100 | [diff] [blame] | 600 | } |
Thierry FOURNIER | c365d99 | 2015-06-09 12:27:17 +0200 | [diff] [blame] | 601 | |
| 602 | /* Copy sample. */ |
Thierry FOURNIER | 5cc18d4 | 2015-08-19 09:02:36 +0200 | [diff] [blame] | 603 | smp->data = var->data; |
Dragan Dosen | 14518f2 | 2021-02-22 17:20:01 +0100 | [diff] [blame] | 604 | smp_dup(smp); |
| 605 | |
| 606 | HA_RWLOCK_RDUNLOCK(VARS_LOCK, &vars->rwlock); |
Thierry FOURNIER | c365d99 | 2015-06-09 12:27:17 +0200 | [diff] [blame] | 607 | return 1; |
| 608 | } |
| 609 | |
Dragan Dosen | 14518f2 | 2021-02-22 17:20:01 +0100 | [diff] [blame] | 610 | /* This function fills a sample with the content of the variable described |
| 611 | * by <var_desc>. |
| 612 | * |
| 613 | * Keep in mind that a sample content is duplicated by using smp_dup() |
| 614 | * and it therefore uses a pre-allocated trash chunk as returned by |
| 615 | * get_trash_chunk(). |
| 616 | * |
| 617 | * Returns 1 if the sample is filled, otherwise it returns 0. |
Thierry FOURNIER | fd77e05 | 2015-07-07 21:20:42 +0200 | [diff] [blame] | 618 | */ |
Willy Tarreau | 6204cd9 | 2016-03-10 16:33:04 +0100 | [diff] [blame] | 619 | int vars_get_by_desc(const struct var_desc *var_desc, struct sample *smp) |
Thierry FOURNIER | fd77e05 | 2015-07-07 21:20:42 +0200 | [diff] [blame] | 620 | { |
| 621 | struct vars *vars; |
| 622 | struct var *var; |
| 623 | |
| 624 | /* Select "vars" pool according with the scope. */ |
Willy Tarreau | f37b140 | 2019-06-04 16:27:36 +0200 | [diff] [blame] | 625 | vars = get_vars(smp->sess, smp->strm, var_desc->scope); |
Thierry FOURNIER | fd77e05 | 2015-07-07 21:20:42 +0200 | [diff] [blame] | 626 | |
Joseph Herlant | 0767689 | 2018-11-15 09:19:50 -0800 | [diff] [blame] | 627 | /* Check if the scope is available a this point of processing. */ |
Willy Tarreau | f37b140 | 2019-06-04 16:27:36 +0200 | [diff] [blame] | 628 | if (!vars || vars->scope != var_desc->scope) |
Thierry FOURNIER | fd77e05 | 2015-07-07 21:20:42 +0200 | [diff] [blame] | 629 | return 0; |
| 630 | |
| 631 | /* Get the variable entry. */ |
Dragan Dosen | 14518f2 | 2021-02-22 17:20:01 +0100 | [diff] [blame] | 632 | HA_RWLOCK_RDLOCK(VARS_LOCK, &vars->rwlock); |
Thierry FOURNIER | fd77e05 | 2015-07-07 21:20:42 +0200 | [diff] [blame] | 633 | var = var_get(vars, var_desc->name); |
Dragan Dosen | 14518f2 | 2021-02-22 17:20:01 +0100 | [diff] [blame] | 634 | if (!var) { |
| 635 | HA_RWLOCK_RDUNLOCK(VARS_LOCK, &vars->rwlock); |
Thierry FOURNIER | fd77e05 | 2015-07-07 21:20:42 +0200 | [diff] [blame] | 636 | return 0; |
Dragan Dosen | 14518f2 | 2021-02-22 17:20:01 +0100 | [diff] [blame] | 637 | } |
Thierry FOURNIER | fd77e05 | 2015-07-07 21:20:42 +0200 | [diff] [blame] | 638 | |
| 639 | /* Copy sample. */ |
Thierry FOURNIER | 5cc18d4 | 2015-08-19 09:02:36 +0200 | [diff] [blame] | 640 | smp->data = var->data; |
Dragan Dosen | 14518f2 | 2021-02-22 17:20:01 +0100 | [diff] [blame] | 641 | smp_dup(smp); |
| 642 | |
| 643 | HA_RWLOCK_RDUNLOCK(VARS_LOCK, &vars->rwlock); |
Thierry FOURNIER | fd77e05 | 2015-07-07 21:20:42 +0200 | [diff] [blame] | 644 | return 1; |
| 645 | } |
| 646 | |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 647 | /* Always returns ACT_RET_CONT even if an error occurs. */ |
| 648 | static enum act_return action_store(struct act_rule *rule, struct proxy *px, |
Willy Tarreau | 658b85b | 2015-09-27 10:00:49 +0200 | [diff] [blame] | 649 | struct session *sess, struct stream *s, int flags) |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 650 | { |
| 651 | struct sample smp; |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 652 | int dir; |
| 653 | |
| 654 | switch (rule->from) { |
Willy Tarreau | 620408f | 2016-10-21 16:37:51 +0200 | [diff] [blame] | 655 | case ACT_F_TCP_REQ_SES: dir = SMP_OPT_DIR_REQ; break; |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 656 | case ACT_F_TCP_REQ_CNT: dir = SMP_OPT_DIR_REQ; break; |
| 657 | case ACT_F_TCP_RES_CNT: dir = SMP_OPT_DIR_RES; break; |
| 658 | case ACT_F_HTTP_REQ: dir = SMP_OPT_DIR_REQ; break; |
| 659 | case ACT_F_HTTP_RES: dir = SMP_OPT_DIR_RES; break; |
Gaetan Rivet | 0c39ecc | 2020-02-24 17:34:11 +0100 | [diff] [blame] | 660 | case ACT_F_TCP_CHK: dir = SMP_OPT_DIR_REQ; break; |
Willy Tarreau | 01d580a | 2021-03-26 11:11:34 +0100 | [diff] [blame] | 661 | case ACT_F_CFG_PARSER: dir = SMP_OPT_DIR_REQ; break; /* not used anyway */ |
Willy Tarreau | 2f836de | 2021-03-26 15:36:44 +0100 | [diff] [blame] | 662 | case ACT_F_CLI_PARSER: dir = SMP_OPT_DIR_REQ; break; /* not used anyway */ |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 663 | default: |
| 664 | send_log(px, LOG_ERR, "Vars: internal error while execute action store."); |
| 665 | if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) |
Christopher Faulet | 767a84b | 2017-11-24 16:50:31 +0100 | [diff] [blame] | 666 | ha_alert("Vars: internal error while execute action store.\n"); |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 667 | return ACT_RET_CONT; |
| 668 | } |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 669 | |
| 670 | /* Process the expression. */ |
| 671 | memset(&smp, 0, sizeof(smp)); |
Willy Tarreau | 108a8fd | 2016-10-21 17:13:24 +0200 | [diff] [blame] | 672 | if (!sample_process(px, sess, s, dir|SMP_OPT_FINAL, |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 673 | rule->arg.vars.expr, &smp)) |
Thierry FOURNIER | 24ff6c6 | 2015-08-06 08:52:53 +0200 | [diff] [blame] | 674 | return ACT_RET_CONT; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 675 | |
| 676 | /* Store the sample, and ignore errors. */ |
Willy Tarreau | 6204cd9 | 2016-03-10 16:33:04 +0100 | [diff] [blame] | 677 | sample_store_stream(rule->arg.vars.name, rule->arg.vars.scope, &smp); |
Thierry FOURNIER | 24ff6c6 | 2015-08-06 08:52:53 +0200 | [diff] [blame] | 678 | return ACT_RET_CONT; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 679 | } |
| 680 | |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 681 | /* Always returns ACT_RET_CONT even if an error occurs. */ |
| 682 | static enum act_return action_clear(struct act_rule *rule, struct proxy *px, |
| 683 | struct session *sess, struct stream *s, int flags) |
| 684 | { |
| 685 | struct sample smp; |
| 686 | |
| 687 | memset(&smp, 0, sizeof(smp)); |
| 688 | smp_set_owner(&smp, px, sess, s, SMP_OPT_FINAL); |
| 689 | |
| 690 | /* Clear the variable using the sample context, and ignore errors. */ |
| 691 | sample_clear_stream(rule->arg.vars.name, rule->arg.vars.scope, &smp); |
| 692 | return ACT_RET_CONT; |
| 693 | } |
| 694 | |
Tim Duesterhus | 01a0ce3 | 2020-06-14 17:27:36 +0200 | [diff] [blame] | 695 | static void release_store_rule(struct act_rule *rule) |
| 696 | { |
| 697 | release_sample_expr(rule->arg.vars.expr); |
| 698 | } |
| 699 | |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 700 | /* This two function checks the variable name and replace the |
| 701 | * configuration string name by the global string name. its |
| 702 | * the same string, but the global pointer can be easy to |
| 703 | * compare. |
| 704 | * |
| 705 | * The first function checks a sample-fetch and the second |
| 706 | * checks a converter. |
| 707 | */ |
| 708 | static int smp_check_var(struct arg *args, char **err) |
| 709 | { |
| 710 | return vars_check_arg(&args[0], err); |
| 711 | } |
| 712 | |
| 713 | static int conv_check_var(struct arg *args, struct sample_conv *conv, |
| 714 | const char *file, int line, char **err_msg) |
| 715 | { |
| 716 | return vars_check_arg(&args[0], err_msg); |
| 717 | } |
| 718 | |
| 719 | /* This function is a common parser for using variables. It understands |
| 720 | * the format: |
| 721 | * |
| 722 | * set-var(<variable-name>) <expression> |
Willy Tarreau | 4b7531f | 2019-06-04 16:43:29 +0200 | [diff] [blame] | 723 | * unset-var(<variable-name>) |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 724 | * |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 725 | * It returns ACT_RET_PRS_ERR if fails and <err> is filled with an error |
| 726 | * message. Otherwise, it returns ACT_RET_PRS_OK and the variable <expr> |
Willy Tarreau | 13d2ba2 | 2021-03-26 11:38:08 +0100 | [diff] [blame] | 727 | * is filled with the pointer to the expression to execute. The proxy is |
| 728 | * only used to retrieve the ->conf entries. |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 729 | */ |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 730 | static enum act_parse_ret parse_store(const char **args, int *arg, struct proxy *px, |
| 731 | struct act_rule *rule, char **err) |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 732 | { |
| 733 | const char *var_name = args[*arg-1]; |
| 734 | int var_len; |
Thierry FOURNIER | 48a9cd1 | 2015-07-28 19:00:28 +0200 | [diff] [blame] | 735 | const char *kw_name; |
Willy Tarreau | e365815 | 2016-11-24 21:23:28 +0100 | [diff] [blame] | 736 | int flags, set_var = 0; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 737 | |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 738 | if (!strncmp(var_name, "set-var", 7)) { |
| 739 | var_name += 7; |
| 740 | set_var = 1; |
| 741 | } |
| 742 | if (!strncmp(var_name, "unset-var", 9)) { |
| 743 | var_name += 9; |
| 744 | set_var = 0; |
| 745 | } |
| 746 | |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 747 | if (*var_name != '(') { |
Willy Tarreau | 3d1d178 | 2021-03-12 11:53:19 +0100 | [diff] [blame] | 748 | memprintf(err, "invalid or incomplete action '%s'. Expects 'set-var(<var-name>)' or 'unset-var(<var-name>)'", |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 749 | args[*arg-1]); |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 750 | return ACT_RET_PRS_ERR; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 751 | } |
| 752 | var_name++; /* jump the '(' */ |
| 753 | var_len = strlen(var_name); |
| 754 | var_len--; /* remove the ')' */ |
| 755 | if (var_name[var_len] != ')') { |
Willy Tarreau | 3d1d178 | 2021-03-12 11:53:19 +0100 | [diff] [blame] | 756 | memprintf(err, "incomplete expression after action '%s'. Expects 'set-var(<var-name>)' or 'unset-var(<var-name>)'", |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 757 | args[*arg-1]); |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 758 | return ACT_RET_PRS_ERR; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 759 | } |
| 760 | |
Christopher Faulet | 09c9df2 | 2016-10-31 11:05:37 +0100 | [diff] [blame] | 761 | rule->arg.vars.name = register_name(var_name, var_len, &rule->arg.vars.scope, 1, err); |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 762 | if (!rule->arg.vars.name) |
| 763 | return ACT_RET_PRS_ERR; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 764 | |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 765 | /* There is no fetch method when variable is unset. Just set the right |
| 766 | * action and return. */ |
| 767 | if (!set_var) { |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 768 | rule->action = ACT_CUSTOM; |
| 769 | rule->action_ptr = action_clear; |
Tim Duesterhus | 01a0ce3 | 2020-06-14 17:27:36 +0200 | [diff] [blame] | 770 | rule->release_ptr = release_store_rule; |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 771 | return ACT_RET_PRS_OK; |
| 772 | } |
| 773 | |
Thierry FOURNIER | 48a9cd1 | 2015-07-28 19:00:28 +0200 | [diff] [blame] | 774 | kw_name = args[*arg-1]; |
| 775 | |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 776 | rule->arg.vars.expr = sample_parse_expr((char **)args, arg, px->conf.args.file, |
Willy Tarreau | e3b57bf | 2020-02-14 16:50:14 +0100 | [diff] [blame] | 777 | px->conf.args.line, err, &px->conf.args, NULL); |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 778 | if (!rule->arg.vars.expr) |
Thierry FOURNIER | afa8049 | 2015-08-19 09:04:15 +0200 | [diff] [blame] | 779 | return ACT_RET_PRS_ERR; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 780 | |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 781 | switch (rule->from) { |
Willy Tarreau | 620408f | 2016-10-21 16:37:51 +0200 | [diff] [blame] | 782 | case ACT_F_TCP_REQ_SES: flags = SMP_VAL_FE_SES_ACC; break; |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 783 | case ACT_F_TCP_REQ_CNT: flags = SMP_VAL_FE_REQ_CNT; break; |
| 784 | case ACT_F_TCP_RES_CNT: flags = SMP_VAL_BE_RES_CNT; break; |
| 785 | case ACT_F_HTTP_REQ: flags = SMP_VAL_FE_HRQ_HDR; break; |
| 786 | case ACT_F_HTTP_RES: flags = SMP_VAL_BE_HRS_HDR; break; |
Gaetan Rivet | 707b52f | 2020-02-21 18:14:59 +0100 | [diff] [blame] | 787 | case ACT_F_TCP_CHK: flags = SMP_VAL_BE_CHK_RUL; break; |
Willy Tarreau | 01d580a | 2021-03-26 11:11:34 +0100 | [diff] [blame] | 788 | case ACT_F_CFG_PARSER: flags = SMP_VAL_CFG_PARSER; break; |
Willy Tarreau | 2f836de | 2021-03-26 15:36:44 +0100 | [diff] [blame] | 789 | case ACT_F_CLI_PARSER: flags = SMP_VAL_CLI_PARSER; break; |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 790 | default: |
| 791 | memprintf(err, |
| 792 | "internal error, unexpected rule->from=%d, please report this bug!", |
| 793 | rule->from); |
Thierry FOURNIER | afa8049 | 2015-08-19 09:04:15 +0200 | [diff] [blame] | 794 | return ACT_RET_PRS_ERR; |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 795 | } |
| 796 | if (!(rule->arg.vars.expr->fetch->val & flags)) { |
| 797 | memprintf(err, |
| 798 | "fetch method '%s' extracts information from '%s', none of which is available here", |
| 799 | kw_name, sample_src_names(rule->arg.vars.expr->fetch->use)); |
| 800 | free(rule->arg.vars.expr); |
Thierry FOURNIER | afa8049 | 2015-08-19 09:04:15 +0200 | [diff] [blame] | 801 | return ACT_RET_PRS_ERR; |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 802 | } |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 803 | |
Thierry FOURNIER | 4214873 | 2015-09-02 17:17:33 +0200 | [diff] [blame] | 804 | rule->action = ACT_CUSTOM; |
Thierry FOURNIER | 4dc15d1 | 2015-08-06 18:25:56 +0200 | [diff] [blame] | 805 | rule->action_ptr = action_store; |
Tim Duesterhus | 01a0ce3 | 2020-06-14 17:27:36 +0200 | [diff] [blame] | 806 | rule->release_ptr = release_store_rule; |
Thierry FOURNIER | afa8049 | 2015-08-19 09:04:15 +0200 | [diff] [blame] | 807 | return ACT_RET_PRS_OK; |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 808 | } |
| 809 | |
Willy Tarreau | 13d2ba2 | 2021-03-26 11:38:08 +0100 | [diff] [blame] | 810 | |
| 811 | /* parses a global "set-var" directive. It will create a temporary rule and |
| 812 | * expression that are parsed, processed, and released on the fly so that we |
| 813 | * respect the real set-var syntax. These directives take the following format: |
| 814 | * set-var <name> <expression> |
| 815 | * Note that parse_store() expects "set-var(name) <expression>" so we have to |
| 816 | * temporarily replace the keyword here. |
| 817 | */ |
| 818 | static int vars_parse_global_set_var(char **args, int section_type, struct proxy *curpx, |
| 819 | const struct proxy *defpx, const char *file, int line, |
| 820 | char **err) |
| 821 | { |
| 822 | struct proxy px = { |
| 823 | .id = "CLI", |
| 824 | .conf.args.file = file, |
| 825 | .conf.args.line = line, |
| 826 | }; |
| 827 | struct act_rule rule = { |
| 828 | .arg.vars.scope = SCOPE_PROC, |
| 829 | .from = ACT_F_CFG_PARSER, |
| 830 | }; |
| 831 | enum act_parse_ret p_ret; |
| 832 | char *old_arg1; |
| 833 | char *tmp_arg1; |
| 834 | int arg = 2; // variable name |
| 835 | int ret = -1; |
| 836 | |
| 837 | LIST_INIT(&px.conf.args.list); |
| 838 | |
| 839 | if (!*args[1] || !*args[2]) { |
| 840 | memprintf(err, "'%s' requires a process-wide variable name ('proc.<name>') and a sample expression.", args[0]); |
| 841 | goto end; |
| 842 | } |
| 843 | |
| 844 | tmp_arg1 = NULL; |
| 845 | if (!memprintf(&tmp_arg1, "set-var(%s)", args[1])) |
| 846 | goto end; |
| 847 | |
| 848 | /* parse_store() will always return a message in <err> on error */ |
| 849 | old_arg1 = args[1]; args[1] = tmp_arg1; |
| 850 | p_ret = parse_store((const char **)args, &arg, &px, &rule, err); |
| 851 | free(args[1]); args[1] = old_arg1; |
| 852 | |
| 853 | if (p_ret != ACT_RET_PRS_OK) |
| 854 | goto end; |
| 855 | |
| 856 | if (rule.arg.vars.scope != SCOPE_PROC) { |
| 857 | memprintf(err, "'%s': cannot set variable '%s', only scope 'proc' is permitted in the global section.", args[0], args[1]); |
| 858 | goto end; |
| 859 | } |
| 860 | |
| 861 | if (smp_resolve_args(&px, err) != 0) { |
| 862 | release_sample_expr(rule.arg.vars.expr); |
| 863 | indent_msg(err, 2); |
| 864 | goto end; |
| 865 | } |
| 866 | |
| 867 | action_store(&rule, &px, NULL, NULL, 0); |
| 868 | release_sample_expr(rule.arg.vars.expr); |
| 869 | |
| 870 | ret = 0; |
| 871 | end: |
| 872 | return ret; |
| 873 | } |
| 874 | |
Willy Tarreau | c35eb38 | 2021-03-26 14:51:31 +0100 | [diff] [blame] | 875 | /* parse CLI's "get var <name>" */ |
| 876 | static int vars_parse_cli_get_var(char **args, char *payload, struct appctx *appctx, void *private) |
| 877 | { |
| 878 | struct vars *vars; |
Willy Tarreau | 374edc7 | 2021-04-01 17:01:43 +0200 | [diff] [blame] | 879 | struct sample smp = { }; |
Willy Tarreau | c35eb38 | 2021-03-26 14:51:31 +0100 | [diff] [blame] | 880 | int i; |
| 881 | |
| 882 | if (!cli_has_level(appctx, ACCESS_LVL_OPER)) |
| 883 | return 1; |
| 884 | |
| 885 | if (!*args[2]) |
| 886 | return cli_err(appctx, "Missing process-wide variable identifier.\n"); |
| 887 | |
| 888 | vars = get_vars(NULL, NULL, SCOPE_PROC); |
| 889 | if (!vars || vars->scope != SCOPE_PROC) |
| 890 | return 0; |
| 891 | |
| 892 | if (!vars_get_by_name(args[2], strlen(args[2]), &smp)) |
| 893 | return cli_err(appctx, "Variable not found.\n"); |
| 894 | |
| 895 | /* the sample returned by vars_get_by_name() is allocated into a trash |
| 896 | * chunk so we have no constraint to manipulate it. |
| 897 | */ |
| 898 | chunk_printf(&trash, "%s: type=%s value=", args[2], smp_to_type[smp.data.type]); |
| 899 | |
| 900 | if (!sample_casts[smp.data.type][SMP_T_STR] || |
| 901 | !sample_casts[smp.data.type][SMP_T_STR](&smp)) { |
| 902 | chunk_appendf(&trash, "(undisplayable)"); |
| 903 | } else { |
| 904 | /* Display the displayable chars*. */ |
| 905 | b_putchr(&trash, '<'); |
| 906 | for (i = 0; i < smp.data.u.str.data; i++) { |
| 907 | if (isprint((unsigned char)smp.data.u.str.area[i])) |
| 908 | b_putchr(&trash, smp.data.u.str.area[i]); |
| 909 | else |
| 910 | b_putchr(&trash, '.'); |
| 911 | } |
| 912 | b_putchr(&trash, '>'); |
| 913 | b_putchr(&trash, 0); |
| 914 | } |
| 915 | return cli_msg(appctx, LOG_INFO, trash.area); |
| 916 | } |
| 917 | |
Willy Tarreau | b8bd1ee | 2021-03-26 15:19:50 +0100 | [diff] [blame] | 918 | /* parse CLI's "set var <name> <expression>" */ |
| 919 | static int vars_parse_cli_set_var(char **args, char *payload, struct appctx *appctx, void *private) |
| 920 | { |
| 921 | struct proxy px = { |
| 922 | .id = "CLI", |
| 923 | .conf.args.file = "CLI", |
| 924 | .conf.args.line = 0, |
| 925 | }; |
| 926 | struct act_rule rule = { |
| 927 | .arg.vars.scope = SCOPE_PROC, |
| 928 | .from = ACT_F_CLI_PARSER, |
| 929 | }; |
| 930 | enum act_parse_ret p_ret; |
| 931 | char *old_arg2; |
| 932 | char *tmp_arg2; |
| 933 | char *err = NULL; |
| 934 | int arg = 2; // variable name |
| 935 | int nberr; |
| 936 | |
| 937 | LIST_INIT(&px.conf.args.list); |
| 938 | |
| 939 | if (!cli_has_level(appctx, ACCESS_LVL_OPER)) |
| 940 | return 1; |
| 941 | |
| 942 | if (!*args[2] || !*args[3]) |
| 943 | return cli_err(appctx, "Missing process-wide variable identifier and expression.\n"); |
| 944 | |
| 945 | tmp_arg2 = NULL; |
| 946 | if (!memprintf(&tmp_arg2, "set-var(%s)", args[2])) { |
| 947 | memprintf(&err, "memory allocation error."); |
| 948 | goto fail; |
| 949 | } |
| 950 | |
| 951 | /* parse_store() will always return a message in <err> on error */ |
| 952 | old_arg2 = args[2]; args[2] = tmp_arg2; |
| 953 | p_ret = parse_store((const char **)(args + 1), &arg, &px, &rule, &err); |
| 954 | free(args[2]); args[2] = old_arg2; |
| 955 | |
| 956 | if (p_ret != ACT_RET_PRS_OK) |
| 957 | goto fail; |
| 958 | |
| 959 | if (rule.arg.vars.scope != SCOPE_PROC) { |
| 960 | memprintf(&err, "'%s %s': cannot set variable '%s', only scope 'proc' is permitted in the global section.", args[0], args[1], args[2]); |
| 961 | goto fail; |
| 962 | } |
| 963 | |
| 964 | err = NULL; |
| 965 | nberr = smp_resolve_args(&px, &err); |
| 966 | if (nberr) { |
| 967 | release_sample_expr(rule.arg.vars.expr); |
| 968 | indent_msg(&err, 2); |
| 969 | goto fail; |
| 970 | } |
| 971 | |
| 972 | action_store(&rule, &px, NULL, NULL, 0); |
| 973 | release_sample_expr(rule.arg.vars.expr); |
| 974 | appctx->st0 = CLI_ST_PROMPT; |
| 975 | return 0; |
| 976 | fail: |
| 977 | return cli_dynerr(appctx, err); |
| 978 | } |
| 979 | |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 980 | static int vars_max_size(char **args, int section_type, struct proxy *curpx, |
Willy Tarreau | 0182516 | 2021-03-09 09:53:46 +0100 | [diff] [blame] | 981 | const struct proxy *defpx, const char *file, int line, |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 982 | char **err, unsigned int *limit) |
| 983 | { |
| 984 | char *error; |
| 985 | |
| 986 | *limit = strtol(args[1], &error, 10); |
| 987 | if (*error != 0) { |
| 988 | memprintf(err, "%s: '%s' is an invalid size", args[0], args[1]); |
| 989 | return -1; |
| 990 | } |
| 991 | return 0; |
| 992 | } |
| 993 | |
| 994 | static int vars_max_size_global(char **args, int section_type, struct proxy *curpx, |
Willy Tarreau | 0182516 | 2021-03-09 09:53:46 +0100 | [diff] [blame] | 995 | const struct proxy *defpx, const char *file, int line, |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 996 | char **err) |
| 997 | { |
| 998 | return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_global_limit); |
| 999 | } |
| 1000 | |
Christopher Faulet | ff2613e | 2016-11-09 11:36:17 +0100 | [diff] [blame] | 1001 | static int vars_max_size_proc(char **args, int section_type, struct proxy *curpx, |
Willy Tarreau | 0182516 | 2021-03-09 09:53:46 +0100 | [diff] [blame] | 1002 | const struct proxy *defpx, const char *file, int line, |
Christopher Faulet | ff2613e | 2016-11-09 11:36:17 +0100 | [diff] [blame] | 1003 | char **err) |
| 1004 | { |
| 1005 | return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_proc_limit); |
| 1006 | } |
| 1007 | |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1008 | static int vars_max_size_sess(char **args, int section_type, struct proxy *curpx, |
Willy Tarreau | 0182516 | 2021-03-09 09:53:46 +0100 | [diff] [blame] | 1009 | const struct proxy *defpx, const char *file, int line, |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1010 | char **err) |
| 1011 | { |
| 1012 | return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_sess_limit); |
| 1013 | } |
| 1014 | |
| 1015 | static int vars_max_size_txn(char **args, int section_type, struct proxy *curpx, |
Willy Tarreau | 0182516 | 2021-03-09 09:53:46 +0100 | [diff] [blame] | 1016 | const struct proxy *defpx, const char *file, int line, |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1017 | char **err) |
| 1018 | { |
| 1019 | return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_txn_limit); |
| 1020 | } |
| 1021 | |
| 1022 | static int vars_max_size_reqres(char **args, int section_type, struct proxy *curpx, |
Willy Tarreau | 0182516 | 2021-03-09 09:53:46 +0100 | [diff] [blame] | 1023 | const struct proxy *defpx, const char *file, int line, |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1024 | char **err) |
| 1025 | { |
| 1026 | return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_reqres_limit); |
| 1027 | } |
| 1028 | |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 1029 | static int vars_max_size_check(char **args, int section_type, struct proxy *curpx, |
Willy Tarreau | 0182516 | 2021-03-09 09:53:46 +0100 | [diff] [blame] | 1030 | const struct proxy *defpx, const char *file, int line, |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 1031 | char **err) |
| 1032 | { |
| 1033 | return vars_max_size(args, section_type, curpx, defpx, file, line, err, &var_check_limit); |
| 1034 | } |
| 1035 | |
Tim Duesterhus | bbdd5b8 | 2020-07-04 11:53:25 +0200 | [diff] [blame] | 1036 | static void vars_deinit() |
| 1037 | { |
| 1038 | while (var_names_nb-- > 0) |
| 1039 | free(var_names[var_names_nb]); |
| 1040 | free(var_names); |
| 1041 | } |
| 1042 | |
| 1043 | REGISTER_POST_DEINIT(vars_deinit); |
| 1044 | |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1045 | static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, { |
| 1046 | |
Willy Tarreau | 0209c97 | 2021-03-26 12:03:11 +0100 | [diff] [blame] | 1047 | { "var", smp_fetch_var, ARG1(1,STR), smp_check_var, SMP_T_STR, SMP_USE_CONST }, |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1048 | { /* END */ }, |
| 1049 | }}; |
| 1050 | |
Willy Tarreau | 0108d90 | 2018-11-25 19:14:37 +0100 | [diff] [blame] | 1051 | INITCALL1(STG_REGISTER, sample_register_fetches, &sample_fetch_keywords); |
| 1052 | |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1053 | static struct sample_conv_kw_list sample_conv_kws = {ILH, { |
Christopher Faulet | 85d79c9 | 2016-11-09 16:54:56 +0100 | [diff] [blame] | 1054 | { "set-var", smp_conv_store, ARG1(1,STR), conv_check_var, SMP_T_ANY, SMP_T_ANY }, |
| 1055 | { "unset-var", smp_conv_clear, ARG1(1,STR), conv_check_var, SMP_T_ANY, SMP_T_ANY }, |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1056 | { /* END */ }, |
| 1057 | }}; |
| 1058 | |
Willy Tarreau | 0108d90 | 2018-11-25 19:14:37 +0100 | [diff] [blame] | 1059 | INITCALL1(STG_REGISTER, sample_register_convs, &sample_conv_kws); |
| 1060 | |
Willy Tarreau | 620408f | 2016-10-21 16:37:51 +0200 | [diff] [blame] | 1061 | static struct action_kw_list tcp_req_sess_kws = { { }, { |
Amaury Denoyelle | e4a617c | 2021-05-06 15:33:09 +0200 | [diff] [blame] | 1062 | { "set-var", parse_store, KWF_MATCH_PREFIX }, |
| 1063 | { "unset-var", parse_store, KWF_MATCH_PREFIX }, |
Willy Tarreau | 620408f | 2016-10-21 16:37:51 +0200 | [diff] [blame] | 1064 | { /* END */ } |
| 1065 | }}; |
| 1066 | |
Willy Tarreau | 0108d90 | 2018-11-25 19:14:37 +0100 | [diff] [blame] | 1067 | INITCALL1(STG_REGISTER, tcp_req_sess_keywords_register, &tcp_req_sess_kws); |
| 1068 | |
Willy Tarreau | 620408f | 2016-10-21 16:37:51 +0200 | [diff] [blame] | 1069 | static struct action_kw_list tcp_req_cont_kws = { { }, { |
Amaury Denoyelle | e4a617c | 2021-05-06 15:33:09 +0200 | [diff] [blame] | 1070 | { "set-var", parse_store, KWF_MATCH_PREFIX }, |
| 1071 | { "unset-var", parse_store, KWF_MATCH_PREFIX }, |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1072 | { /* END */ } |
| 1073 | }}; |
| 1074 | |
Willy Tarreau | 0108d90 | 2018-11-25 19:14:37 +0100 | [diff] [blame] | 1075 | INITCALL1(STG_REGISTER, tcp_req_cont_keywords_register, &tcp_req_cont_kws); |
| 1076 | |
Thierry FOURNIER | 36481b8 | 2015-08-19 09:01:53 +0200 | [diff] [blame] | 1077 | static struct action_kw_list tcp_res_kws = { { }, { |
Amaury Denoyelle | e4a617c | 2021-05-06 15:33:09 +0200 | [diff] [blame] | 1078 | { "set-var", parse_store, KWF_MATCH_PREFIX }, |
| 1079 | { "unset-var", parse_store, KWF_MATCH_PREFIX }, |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1080 | { /* END */ } |
| 1081 | }}; |
| 1082 | |
Willy Tarreau | 0108d90 | 2018-11-25 19:14:37 +0100 | [diff] [blame] | 1083 | INITCALL1(STG_REGISTER, tcp_res_cont_keywords_register, &tcp_res_kws); |
| 1084 | |
Gaetan Rivet | 707b52f | 2020-02-21 18:14:59 +0100 | [diff] [blame] | 1085 | static struct action_kw_list tcp_check_kws = {ILH, { |
Amaury Denoyelle | e4a617c | 2021-05-06 15:33:09 +0200 | [diff] [blame] | 1086 | { "set-var", parse_store, KWF_MATCH_PREFIX }, |
| 1087 | { "unset-var", parse_store, KWF_MATCH_PREFIX }, |
Gaetan Rivet | 707b52f | 2020-02-21 18:14:59 +0100 | [diff] [blame] | 1088 | { /* END */ } |
| 1089 | }}; |
| 1090 | |
| 1091 | INITCALL1(STG_REGISTER, tcp_check_keywords_register, &tcp_check_kws); |
| 1092 | |
Thierry FOURNIER | 36481b8 | 2015-08-19 09:01:53 +0200 | [diff] [blame] | 1093 | static struct action_kw_list http_req_kws = { { }, { |
Amaury Denoyelle | e4a617c | 2021-05-06 15:33:09 +0200 | [diff] [blame] | 1094 | { "set-var", parse_store, KWF_MATCH_PREFIX }, |
| 1095 | { "unset-var", parse_store, KWF_MATCH_PREFIX }, |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1096 | { /* END */ } |
| 1097 | }}; |
| 1098 | |
Willy Tarreau | 0108d90 | 2018-11-25 19:14:37 +0100 | [diff] [blame] | 1099 | INITCALL1(STG_REGISTER, http_req_keywords_register, &http_req_kws); |
| 1100 | |
Thierry FOURNIER | 36481b8 | 2015-08-19 09:01:53 +0200 | [diff] [blame] | 1101 | static struct action_kw_list http_res_kws = { { }, { |
Amaury Denoyelle | e4a617c | 2021-05-06 15:33:09 +0200 | [diff] [blame] | 1102 | { "set-var", parse_store, KWF_MATCH_PREFIX }, |
| 1103 | { "unset-var", parse_store, KWF_MATCH_PREFIX }, |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1104 | { /* END */ } |
| 1105 | }}; |
| 1106 | |
Willy Tarreau | 0108d90 | 2018-11-25 19:14:37 +0100 | [diff] [blame] | 1107 | INITCALL1(STG_REGISTER, http_res_keywords_register, &http_res_kws); |
| 1108 | |
Christopher Faulet | 6d0c3df | 2020-01-22 09:26:35 +0100 | [diff] [blame] | 1109 | static struct action_kw_list http_after_res_kws = { { }, { |
Amaury Denoyelle | e4a617c | 2021-05-06 15:33:09 +0200 | [diff] [blame] | 1110 | { "set-var", parse_store, KWF_MATCH_PREFIX }, |
| 1111 | { "unset-var", parse_store, KWF_MATCH_PREFIX }, |
Christopher Faulet | 6d0c3df | 2020-01-22 09:26:35 +0100 | [diff] [blame] | 1112 | { /* END */ } |
| 1113 | }}; |
| 1114 | |
| 1115 | INITCALL1(STG_REGISTER, http_after_res_keywords_register, &http_after_res_kws); |
| 1116 | |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1117 | static struct cfg_kw_list cfg_kws = {{ },{ |
Willy Tarreau | 13d2ba2 | 2021-03-26 11:38:08 +0100 | [diff] [blame] | 1118 | { CFG_GLOBAL, "set-var", vars_parse_global_set_var }, |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1119 | { CFG_GLOBAL, "tune.vars.global-max-size", vars_max_size_global }, |
Christopher Faulet | ff2613e | 2016-11-09 11:36:17 +0100 | [diff] [blame] | 1120 | { CFG_GLOBAL, "tune.vars.proc-max-size", vars_max_size_proc }, |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1121 | { CFG_GLOBAL, "tune.vars.sess-max-size", vars_max_size_sess }, |
| 1122 | { CFG_GLOBAL, "tune.vars.txn-max-size", vars_max_size_txn }, |
| 1123 | { CFG_GLOBAL, "tune.vars.reqres-max-size", vars_max_size_reqres }, |
Gaetan Rivet | 13a5043 | 2020-02-21 18:13:44 +0100 | [diff] [blame] | 1124 | { CFG_GLOBAL, "tune.vars.check-max-size", vars_max_size_check }, |
Thierry FOURNIER | 4834bc7 | 2015-06-06 19:29:07 +0200 | [diff] [blame] | 1125 | { /* END */ } |
| 1126 | }}; |
| 1127 | |
Willy Tarreau | 0108d90 | 2018-11-25 19:14:37 +0100 | [diff] [blame] | 1128 | INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws); |
Willy Tarreau | c35eb38 | 2021-03-26 14:51:31 +0100 | [diff] [blame] | 1129 | |
| 1130 | |
| 1131 | /* register cli keywords */ |
| 1132 | static struct cli_kw_list cli_kws = {{ },{ |
Willy Tarreau | b205bfd | 2021-05-07 11:38:37 +0200 | [diff] [blame] | 1133 | { { "get", "var", NULL }, "get var <name> : retrieve contents of a process-wide variable", vars_parse_cli_get_var, NULL }, |
| 1134 | { { "set", "var", NULL }, "set var <name> <expr> : set variable from an expression", vars_parse_cli_set_var, NULL, NULL, NULL, ACCESS_EXPERIMENTAL }, |
Willy Tarreau | c35eb38 | 2021-03-26 14:51:31 +0100 | [diff] [blame] | 1135 | { { NULL }, NULL, NULL, NULL } |
| 1136 | }}; |
| 1137 | INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws); |