In preparation for val_args_flags, introduce a macro that is used to
populate the val_args field in sample_conv_kw_list and
sample_fetch_kw_list.

This commit produces code that has zero changes after preprocessor
expansion.

All sample registration can be found with:
$ git grep -n -e 'sample.*kw_list.*ILH' -A5000 \
  | sed -r -n '/struct sample_(conv|fetch)_kw_list\>/,/};/p'

Initial-Discovery: Yue Zhu <[email protected]>
Signed-off-by: Robin H. Johnson <[email protected]>
Signed-off-by: Robin H. Johnson <[email protected]>
---
 include/types/sample.h |   6 +
 src/51d.c              |   4 +-
 src/backend.c          |  28 ++---
 src/connection.c       |   4 +-
 src/da.c               |   4 +-
 src/flt_http_comp.c    |   4 +-
 src/frontend.c         |  10 +-
 src/listener.c         |   4 +-
 src/map.c              |  62 +++++------
 src/payload.c          |  54 ++++-----
 src/proto_http.c       | 164 +++++++++++++--------------
 src/proto_tcp.c        |  28 ++---
 src/sample.c           | 110 +++++++++----------
 src/ssl_sock.c         | 102 ++++++++---------
 src/stick_table.c      | 244 ++++++++++++++++++++---------------------
 src/vars.c             |   7 +-
 src/wurfl.c            |   4 +-
 17 files changed, 422 insertions(+), 417 deletions(-)

diff --git a/include/types/sample.h b/include/types/sample.h
index cf0528edc..a0a440512 100644
--- a/include/types/sample.h
+++ b/include/types/sample.h
@@ -342,4 +342,10 @@ struct sample_conv_kw_list {
 typedef int (*sample_cast_fct)(struct sample *smp);
 extern sample_cast_fct sample_casts[SMP_TYPES][SMP_TYPES];
 
+/* Macros for easier to use val_args list usage
+ * All sample_conv_kw_list/sample_fetch_kw_list should use the SMP_VAL_ARGS 
macro to populate the
+ * val_args field.
+ */
+#define SMP_VAL_ARGS(func)        func
+
 #endif /* _TYPES_SAMPLE_H */
diff --git a/src/51d.c b/src/51d.c
index a36333ef5..f415fac26 100644
--- a/src/51d.c
+++ b/src/51d.c
@@ -668,13 +668,13 @@ static struct cfg_kw_list _51dcfg_kws = {{ }, {
 
 /* Note: must not be declared <const> as its list will be overwritten */
 static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, {
-       { "51d.all", _51d_fetch, ARG5(1,STR,STR,STR,STR,STR), _51d_fetch_check, 
SMP_T_STR, SMP_USE_HRQHV },
+       { "51d.all", _51d_fetch, ARG5(1,STR,STR,STR,STR,STR), 
SMP_VAL_ARGS(_51d_fetch_check), SMP_T_STR, SMP_USE_HRQHV },
        { NULL, NULL, 0, 0, 0 },
 }};
 
 /* Note: must not be declared <const> as its list will be overwritten */
 static struct sample_conv_kw_list conv_kws = {ILH, {
-       { "51d.single", _51d_conv, ARG5(1,STR,STR,STR,STR,STR), 
_51d_conv_check, SMP_T_STR, SMP_T_STR },
+       { "51d.single", _51d_conv, ARG5(1,STR,STR,STR,STR,STR), 
SMP_VAL_ARGS(_51d_conv_check), SMP_T_STR, SMP_T_STR },
        { NULL, NULL, 0, 0, 0 },
 }};
 
diff --git a/src/backend.c b/src/backend.c
index b3fd6c677..a2bc13d68 100644
--- a/src/backend.c
+++ b/src/backend.c
@@ -1877,25 +1877,25 @@ static int sample_conv_nbsrv(const struct arg *args, 
struct sample *smp, void *p
  * Please take care of keeping this list alphabetically sorted.
  */
 static struct sample_fetch_kw_list smp_kws = {ILH, {
-       { "avg_queue",     smp_fetch_avg_queue_size, ARG1(1,BE),  NULL, 
SMP_T_SINT, SMP_USE_INTRN, },
-       { "be_conn",       smp_fetch_be_conn,        ARG1(1,BE),  NULL, 
SMP_T_SINT, SMP_USE_INTRN, },
-       { "be_id",         smp_fetch_be_id,          0,           NULL, 
SMP_T_SINT, SMP_USE_BKEND, },
-       { "be_name",       smp_fetch_be_name,        0,           NULL, 
SMP_T_STR,  SMP_USE_BKEND, },
-       { "be_sess_rate",  smp_fetch_be_sess_rate,   ARG1(1,BE),  NULL, 
SMP_T_SINT, SMP_USE_INTRN, },
-       { "connslots",     smp_fetch_connslots,      ARG1(1,BE),  NULL, 
SMP_T_SINT, SMP_USE_INTRN, },
-       { "nbsrv",         smp_fetch_nbsrv,          ARG1(1,BE),  NULL, 
SMP_T_SINT, SMP_USE_INTRN, },
-       { "queue",         smp_fetch_queue_size,     ARG1(1,BE),  NULL, 
SMP_T_SINT, SMP_USE_INTRN, },
-       { "srv_conn",      smp_fetch_srv_conn,       ARG1(1,SRV), NULL, 
SMP_T_SINT, SMP_USE_INTRN, },
-       { "srv_id",        smp_fetch_srv_id,         0,           NULL, 
SMP_T_SINT, SMP_USE_SERVR, },
-       { "srv_is_up",     smp_fetch_srv_is_up,      ARG1(1,SRV), NULL, 
SMP_T_BOOL, SMP_USE_INTRN, },
-       { "srv_queue",     smp_fetch_srv_queue,      ARG1(1,SRV), NULL, 
SMP_T_SINT, SMP_USE_INTRN, },
-       { "srv_sess_rate", smp_fetch_srv_sess_rate,  ARG1(1,SRV), NULL, 
SMP_T_SINT, SMP_USE_INTRN, },
+       { "avg_queue",     smp_fetch_avg_queue_size, ARG1(1,BE),  
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "be_conn",       smp_fetch_be_conn,        ARG1(1,BE),  
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "be_id",         smp_fetch_be_id,          0,           
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_BKEND, },
+       { "be_name",       smp_fetch_be_name,        0,           
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_BKEND, },
+       { "be_sess_rate",  smp_fetch_be_sess_rate,   ARG1(1,BE),  
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "connslots",     smp_fetch_connslots,      ARG1(1,BE),  
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "nbsrv",         smp_fetch_nbsrv,          ARG1(1,BE),  
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "queue",         smp_fetch_queue_size,     ARG1(1,BE),  
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "srv_conn",      smp_fetch_srv_conn,       ARG1(1,SRV), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "srv_id",        smp_fetch_srv_id,         0,           
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_SERVR, },
+       { "srv_is_up",     smp_fetch_srv_is_up,      ARG1(1,SRV), 
SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_INTRN, },
+       { "srv_queue",     smp_fetch_srv_queue,      ARG1(1,SRV), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "srv_sess_rate", smp_fetch_srv_sess_rate,  ARG1(1,SRV), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
        { /* END */ },
 }};
 
 /* Note: must not be declared <const> as its list will be overwritten */
 static struct sample_conv_kw_list sample_conv_kws = {ILH, {
-       { "nbsrv", sample_conv_nbsrv, 0, NULL, SMP_T_STR, SMP_T_SINT },
+       { "nbsrv", sample_conv_nbsrv, 0, SMP_VAL_ARGS(NULL), SMP_T_STR, 
SMP_T_SINT },
        { /* END */ },
 }};
 
diff --git a/src/connection.c b/src/connection.c
index 7403e8ae0..d40ec7e53 100644
--- a/src/connection.c
+++ b/src/connection.c
@@ -1156,8 +1156,8 @@ int smp_fetch_fc_rcvd_proxy(const struct arg *args, 
struct sample *smp, const ch
  * instance v4/v6 must be declared v4.
  */
 static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, {
-       { "fc_http_major", smp_fetch_fc_http_major, 0, NULL, SMP_T_SINT, 
SMP_USE_L4CLI },
-       { "fc_rcvd_proxy", smp_fetch_fc_rcvd_proxy, 0, NULL, SMP_T_BOOL, 
SMP_USE_L4CLI },
+       { "fc_http_major", smp_fetch_fc_http_major, 0, SMP_VAL_ARGS(NULL), 
SMP_T_SINT, SMP_USE_L4CLI },
+       { "fc_rcvd_proxy", smp_fetch_fc_rcvd_proxy, 0, SMP_VAL_ARGS(NULL), 
SMP_T_BOOL, SMP_USE_L4CLI },
        { /* END */ },
 }};
 
diff --git a/src/da.c b/src/da.c
index 685a79d19..5ef8dbee5 100644
--- a/src/da.c
+++ b/src/da.c
@@ -375,13 +375,13 @@ static struct cfg_kw_list dacfg_kws = {{ }, {
 
 /* Note: must not be declared <const> as its list will be overwritten */
 static struct sample_fetch_kw_list fetch_kws = {ILH, {
-       { "da-csv-fetch", da_haproxy_fetch, 
ARG12(1,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR), NULL, SMP_T_STR, 
SMP_USE_HRQHV },
+       { "da-csv-fetch", da_haproxy_fetch, 
ARG12(1,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR), SMP_VAL_ARGS(NULL), 
SMP_T_STR, SMP_USE_HRQHV },
        { NULL, NULL, 0, 0, 0 },
 }};
 
 /* Note: must not be declared <const> as its list will be overwritten */
 static struct sample_conv_kw_list conv_kws = {ILH, {
-       { "da-csv-conv", da_haproxy_conv, 
ARG12(1,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR), NULL, SMP_T_STR, 
SMP_T_STR },
+       { "da-csv-conv", da_haproxy_conv, 
ARG12(1,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR), SMP_VAL_ARGS(NULL), 
SMP_T_STR, SMP_T_STR },
        { NULL, NULL, 0, 0, 0 },
 }};
 
diff --git a/src/flt_http_comp.c b/src/flt_http_comp.c
index b93ff69e8..ba7f1f7ec 100644
--- a/src/flt_http_comp.c
+++ b/src/flt_http_comp.c
@@ -986,8 +986,8 @@ static struct flt_kw_list filter_kws = { "COMP", { }, {
 
 /* Note: must not be declared <const> as its list will be overwritten */
 static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, {
-               { "res.comp",      smp_fetch_res_comp,      0, NULL, 
SMP_T_BOOL, SMP_USE_HRSHP },
-               { "res.comp_algo", smp_fetch_res_comp_algo, 0, NULL, SMP_T_STR, 
SMP_USE_HRSHP },
+               { "res.comp",      smp_fetch_res_comp,      0, 
SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_HRSHP },
+               { "res.comp_algo", smp_fetch_res_comp_algo, 0, 
SMP_VAL_ARGS(NULL), SMP_T_STR, SMP_USE_HRSHP },
                { /* END */ },
        }
 };
diff --git a/src/frontend.c b/src/frontend.c
index 94d90f59b..46e31699b 100644
--- a/src/frontend.c
+++ b/src/frontend.c
@@ -238,11 +238,11 @@ smp_fetch_fe_conn(const struct arg *args, struct sample 
*smp, const char *kw, vo
  * Please take care of keeping this list alphabetically sorted.
  */
 static struct sample_fetch_kw_list smp_kws = {ILH, {
-       { "fe_conn",      smp_fetch_fe_conn,      ARG1(1,FE), NULL, SMP_T_SINT, 
SMP_USE_INTRN, },
-       { "fe_id",        smp_fetch_fe_id,        0,          NULL, SMP_T_SINT, 
SMP_USE_FTEND, },
-       { "fe_name",      smp_fetch_fe_name,      0,          NULL, SMP_T_STR,  
SMP_USE_FTEND, },
-       { "fe_req_rate",  smp_fetch_fe_req_rate,  ARG1(1,FE), NULL, SMP_T_SINT, 
SMP_USE_INTRN, },
-       { "fe_sess_rate", smp_fetch_fe_sess_rate, ARG1(1,FE), NULL, SMP_T_SINT, 
SMP_USE_INTRN, },
+       { "fe_conn",      smp_fetch_fe_conn,      ARG1(1,FE), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "fe_id",        smp_fetch_fe_id,        0,          
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_FTEND, },
+       { "fe_name",      smp_fetch_fe_name,      0,          
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_FTEND, },
+       { "fe_req_rate",  smp_fetch_fe_req_rate,  ARG1(1,FE), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "fe_sess_rate", smp_fetch_fe_sess_rate, ARG1(1,FE), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
        { /* END */ },
 }};
 
diff --git a/src/listener.c b/src/listener.c
index a30efe03d..340629664 100644
--- a/src/listener.c
+++ b/src/listener.c
@@ -968,8 +968,8 @@ static int bind_parse_process(char **args, int cur_arg, 
struct proxy *px, struct
  * Please take care of keeping this list alphabetically sorted.
  */
 static struct sample_fetch_kw_list smp_kws = {ILH, {
-       { "dst_conn", smp_fetch_dconn, 0, NULL, SMP_T_SINT, SMP_USE_FTEND, },
-       { "so_id",    smp_fetch_so_id, 0, NULL, SMP_T_SINT, SMP_USE_FTEND, },
+       { "dst_conn", smp_fetch_dconn, 0, SMP_VAL_ARGS(NULL), SMP_T_SINT, 
SMP_USE_FTEND, },
+       { "so_id",    smp_fetch_so_id, 0, SMP_VAL_ARGS(NULL), SMP_T_SINT, 
SMP_USE_FTEND, },
        { /* END */ },
 }};
 
diff --git a/src/map.c b/src/map.c
index da399088a..0b86e809c 100644
--- a/src/map.c
+++ b/src/map.c
@@ -1064,37 +1064,37 @@ static struct cli_kw_list cli_kws = {{ },{
  * The arguments are: <file>[,<default value>]
  */
 static struct sample_conv_kw_list sample_conv_kws = {ILH, {
-       { "map",         sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_STR },
-       { "map_str",     sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_STR },
-       { "map_beg",     sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_BEG },
-       { "map_sub",     sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_SUB },
-       { "map_dir",     sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_DIR },
-       { "map_dom",     sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_DOM },
-       { "map_end",     sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_END },
-       { "map_reg",     sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_REG },
-       { "map_regm",    sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_REGM},
-       { "map_int",     sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_SINT, SMP_T_STR,  (void *)PAT_MATCH_INT },
-       { "map_ip",      sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_ADDR, SMP_T_STR,  (void *)PAT_MATCH_IP  },
-
-       { "map_str_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, 
SMP_T_STR,  SMP_T_SINT, (void *)PAT_MATCH_STR },
-       { "map_beg_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, 
SMP_T_STR,  SMP_T_SINT, (void *)PAT_MATCH_BEG },
-       { "map_sub_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, 
SMP_T_STR,  SMP_T_SINT, (void *)PAT_MATCH_SUB },
-       { "map_dir_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, 
SMP_T_STR,  SMP_T_SINT, (void *)PAT_MATCH_DIR },
-       { "map_dom_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, 
SMP_T_STR,  SMP_T_SINT, (void *)PAT_MATCH_DOM },
-       { "map_end_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, 
SMP_T_STR,  SMP_T_SINT, (void *)PAT_MATCH_END },
-       { "map_reg_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, 
SMP_T_STR,  SMP_T_SINT, (void *)PAT_MATCH_REG },
-       { "map_int_int", sample_conv_map, ARG2(1,STR,SINT), sample_load_map, 
SMP_T_SINT, SMP_T_SINT, (void *)PAT_MATCH_INT },
-       { "map_ip_int",  sample_conv_map, ARG2(1,STR,SINT), sample_load_map, 
SMP_T_ADDR, SMP_T_SINT, (void *)PAT_MATCH_IP  },
-
-       { "map_str_ip",  sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_STR,  SMP_T_ADDR, (void *)PAT_MATCH_STR },
-       { "map_beg_ip",  sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_STR,  SMP_T_ADDR, (void *)PAT_MATCH_BEG },
-       { "map_sub_ip",  sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_STR,  SMP_T_ADDR, (void *)PAT_MATCH_SUB },
-       { "map_dir_ip",  sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_STR,  SMP_T_ADDR, (void *)PAT_MATCH_DIR },
-       { "map_dom_ip",  sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_STR,  SMP_T_ADDR, (void *)PAT_MATCH_DOM },
-       { "map_end_ip",  sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_STR,  SMP_T_ADDR, (void *)PAT_MATCH_END },
-       { "map_reg_ip",  sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_STR,  SMP_T_ADDR, (void *)PAT_MATCH_REG },
-       { "map_int_ip",  sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_SINT, SMP_T_ADDR, (void *)PAT_MATCH_INT },
-       { "map_ip_ip",   sample_conv_map, ARG2(1,STR,STR), sample_load_map, 
SMP_T_ADDR, SMP_T_ADDR, (void *)PAT_MATCH_IP  },
+       { "map",         sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_STR },
+       { "map_str",     sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_STR },
+       { "map_beg",     sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_BEG },
+       { "map_sub",     sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_SUB },
+       { "map_dir",     sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_DIR },
+       { "map_dom",     sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_DOM },
+       { "map_end",     sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_END },
+       { "map_reg",     sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_REG },
+       { "map_regm",    sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_STR,  (void *)PAT_MATCH_REGM},
+       { "map_int",     sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_SINT, SMP_T_STR,  (void *)PAT_MATCH_INT },
+       { "map_ip",      sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_ADDR, SMP_T_STR,  (void *)PAT_MATCH_IP  },
+
+       { "map_str_int", sample_conv_map, ARG2(1,STR,SINT), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_SINT, (void *)PAT_MATCH_STR },
+       { "map_beg_int", sample_conv_map, ARG2(1,STR,SINT), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_SINT, (void *)PAT_MATCH_BEG },
+       { "map_sub_int", sample_conv_map, ARG2(1,STR,SINT), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_SINT, (void *)PAT_MATCH_SUB },
+       { "map_dir_int", sample_conv_map, ARG2(1,STR,SINT), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_SINT, (void *)PAT_MATCH_DIR },
+       { "map_dom_int", sample_conv_map, ARG2(1,STR,SINT), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_SINT, (void *)PAT_MATCH_DOM },
+       { "map_end_int", sample_conv_map, ARG2(1,STR,SINT), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_SINT, (void *)PAT_MATCH_END },
+       { "map_reg_int", sample_conv_map, ARG2(1,STR,SINT), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_SINT, (void *)PAT_MATCH_REG },
+       { "map_int_int", sample_conv_map, ARG2(1,STR,SINT), 
SMP_VAL_ARGS(sample_load_map), SMP_T_SINT, SMP_T_SINT, (void *)PAT_MATCH_INT },
+       { "map_ip_int",  sample_conv_map, ARG2(1,STR,SINT), 
SMP_VAL_ARGS(sample_load_map), SMP_T_ADDR, SMP_T_SINT, (void *)PAT_MATCH_IP  },
+
+       { "map_str_ip",  sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_ADDR, (void *)PAT_MATCH_STR },
+       { "map_beg_ip",  sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_ADDR, (void *)PAT_MATCH_BEG },
+       { "map_sub_ip",  sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_ADDR, (void *)PAT_MATCH_SUB },
+       { "map_dir_ip",  sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_ADDR, (void *)PAT_MATCH_DIR },
+       { "map_dom_ip",  sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_ADDR, (void *)PAT_MATCH_DOM },
+       { "map_end_ip",  sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_ADDR, (void *)PAT_MATCH_END },
+       { "map_reg_ip",  sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_STR,  SMP_T_ADDR, (void *)PAT_MATCH_REG },
+       { "map_int_ip",  sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_SINT, SMP_T_ADDR, (void *)PAT_MATCH_INT },
+       { "map_ip_ip",   sample_conv_map, ARG2(1,STR,STR), 
SMP_VAL_ARGS(sample_load_map), SMP_T_ADDR, SMP_T_ADDR, (void *)PAT_MATCH_IP  },
 
        { /* END */ },
 }};
diff --git a/src/payload.c b/src/payload.c
index 492c72f6e..9416fa6ef 100644
--- a/src/payload.c
+++ b/src/payload.c
@@ -1118,33 +1118,33 @@ int val_distcc(struct arg *arg, char **err_msg)
  * instance IPv4/IPv6 must be declared IPv4.
  */
 static struct sample_fetch_kw_list smp_kws = {ILH, {
-       { "distcc_body",         smp_fetch_distcc_body,    ARG2(1,STR,SINT),    
   val_distcc,     SMP_T_BIN,  SMP_USE_L6REQ|SMP_USE_L6RES },
-       { "distcc_param",        smp_fetch_distcc_param,   ARG2(1,STR,SINT),    
   val_distcc,     SMP_T_SINT, SMP_USE_L6REQ|SMP_USE_L6RES },
-       { "payload",             smp_fetch_payload,        ARG2(2,SINT,SINT),   
   NULL,           SMP_T_BIN,  SMP_USE_L6REQ|SMP_USE_L6RES },
-       { "payload_lv",          smp_fetch_payload_lv,     
ARG3(2,SINT,SINT,STR),  val_payload_lv, SMP_T_BIN,  SMP_USE_L6REQ|SMP_USE_L6RES 
},
-       { "rdp_cookie",          smp_fetch_rdp_cookie,     ARG1(0,STR),         
   NULL,           SMP_T_STR,  SMP_USE_L6REQ },
-       { "rdp_cookie_cnt",      smp_fetch_rdp_cookie_cnt, ARG1(0,STR),         
   NULL,           SMP_T_SINT, SMP_USE_L6REQ },
-       { "rep_ssl_hello_type",  smp_fetch_ssl_hello_type, 0,                   
   NULL,           SMP_T_SINT, SMP_USE_L6RES },
-       { "req_len",             smp_fetch_len,            0,                   
   NULL,           SMP_T_SINT, SMP_USE_L6REQ },
-       { "req_ssl_hello_type",  smp_fetch_ssl_hello_type, 0,                   
   NULL,           SMP_T_SINT, SMP_USE_L6REQ },
-       { "req_ssl_sni",         smp_fetch_ssl_hello_sni,  0,                   
   NULL,           SMP_T_STR,  SMP_USE_L6REQ },
-       { "req_ssl_ver",         smp_fetch_req_ssl_ver,    0,                   
   NULL,           SMP_T_SINT, SMP_USE_L6REQ },
-
-       { "req.len",             smp_fetch_len,            0,                   
   NULL,           SMP_T_SINT, SMP_USE_L6REQ },
-       { "req.payload",         smp_fetch_payload,        ARG2(2,SINT,SINT),   
   NULL,           SMP_T_BIN,  SMP_USE_L6REQ },
-       { "req.payload_lv",      smp_fetch_payload_lv,     
ARG3(2,SINT,SINT,STR),  val_payload_lv, SMP_T_BIN,  SMP_USE_L6REQ },
-       { "req.rdp_cookie",      smp_fetch_rdp_cookie,     ARG1(0,STR),         
   NULL,           SMP_T_STR,  SMP_USE_L6REQ },
-       { "req.rdp_cookie_cnt",  smp_fetch_rdp_cookie_cnt, ARG1(0,STR),         
   NULL,           SMP_T_SINT, SMP_USE_L6REQ },
-       { "req.ssl_ec_ext",      smp_fetch_req_ssl_ec_ext, 0,                   
   NULL,           SMP_T_BOOL, SMP_USE_L6REQ },
-       { "req.ssl_st_ext",      smp_fetch_req_ssl_st_ext, 0,                   
   NULL,           SMP_T_SINT, SMP_USE_L6REQ },
-       { "req.ssl_hello_type",  smp_fetch_ssl_hello_type, 0,                   
   NULL,           SMP_T_SINT, SMP_USE_L6REQ },
-       { "req.ssl_sni",         smp_fetch_ssl_hello_sni,  0,                   
   NULL,           SMP_T_STR,  SMP_USE_L6REQ },
-       { "req.ssl_ver",         smp_fetch_req_ssl_ver,    0,                   
   NULL,           SMP_T_SINT, SMP_USE_L6REQ },
-       { "res.len",             smp_fetch_len,            0,                   
   NULL,           SMP_T_SINT, SMP_USE_L6RES },
-       { "res.payload",         smp_fetch_payload,        ARG2(2,SINT,SINT),   
   NULL,           SMP_T_BIN,  SMP_USE_L6RES },
-       { "res.payload_lv",      smp_fetch_payload_lv,     
ARG3(2,SINT,SINT,STR),  val_payload_lv, SMP_T_BIN,  SMP_USE_L6RES },
-       { "res.ssl_hello_type",  smp_fetch_ssl_hello_type, 0,                   
   NULL,           SMP_T_SINT, SMP_USE_L6RES },
-       { "wait_end",            smp_fetch_wait_end,       0,                   
   NULL,           SMP_T_BOOL, SMP_USE_INTRN },
+       { "distcc_body",         smp_fetch_distcc_body,    ARG2(1,STR,SINT),    
   SMP_VAL_ARGS(val_distcc),      SMP_T_BIN,  SMP_USE_L6REQ|SMP_USE_L6RES },
+       { "distcc_param",        smp_fetch_distcc_param,   ARG2(1,STR,SINT),    
   SMP_VAL_ARGS(val_distcc),      SMP_T_SINT, SMP_USE_L6REQ|SMP_USE_L6RES },
+       { "payload",             smp_fetch_payload,        ARG2(2,SINT,SINT),   
   SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_L6REQ|SMP_USE_L6RES },
+       { "payload_lv",          smp_fetch_payload_lv,     
ARG3(2,SINT,SINT,STR),  SMP_VAL_ARGS(val_payload_lv),  SMP_T_BIN,  
SMP_USE_L6REQ|SMP_USE_L6RES },
+       { "rdp_cookie",          smp_fetch_rdp_cookie,     ARG1(0,STR),         
   SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L6REQ },
+       { "rdp_cookie_cnt",      smp_fetch_rdp_cookie_cnt, ARG1(0,STR),         
   SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L6REQ },
+       { "rep_ssl_hello_type",  smp_fetch_ssl_hello_type, 0,                   
   SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L6RES },
+       { "req_len",             smp_fetch_len,            0,                   
   SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L6REQ },
+       { "req_ssl_hello_type",  smp_fetch_ssl_hello_type, 0,                   
   SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L6REQ },
+       { "req_ssl_sni",         smp_fetch_ssl_hello_sni,  0,                   
   SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L6REQ },
+       { "req_ssl_ver",         smp_fetch_req_ssl_ver,    0,                   
   SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L6REQ },
+
+       { "req.len",             smp_fetch_len,            0,                   
   SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L6REQ },
+       { "req.payload",         smp_fetch_payload,        ARG2(2,SINT,SINT),   
   SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_L6REQ },
+       { "req.payload_lv",      smp_fetch_payload_lv,     
ARG3(2,SINT,SINT,STR),  SMP_VAL_ARGS(val_payload_lv),  SMP_T_BIN,  
SMP_USE_L6REQ },
+       { "req.rdp_cookie",      smp_fetch_rdp_cookie,     ARG1(0,STR),         
   SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L6REQ },
+       { "req.rdp_cookie_cnt",  smp_fetch_rdp_cookie_cnt, ARG1(0,STR),         
   SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L6REQ },
+       { "req.ssl_ec_ext",      smp_fetch_req_ssl_ec_ext, 0,                   
   SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_L6REQ },
+       { "req.ssl_st_ext",      smp_fetch_req_ssl_st_ext, 0,                   
   SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L6REQ },
+       { "req.ssl_hello_type",  smp_fetch_ssl_hello_type, 0,                   
   SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L6REQ },
+       { "req.ssl_sni",         smp_fetch_ssl_hello_sni,  0,                   
   SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L6REQ },
+       { "req.ssl_ver",         smp_fetch_req_ssl_ver,    0,                   
   SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L6REQ },
+       { "res.len",             smp_fetch_len,            0,                   
   SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L6RES },
+       { "res.payload",         smp_fetch_payload,        ARG2(2,SINT,SINT),   
   SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_L6RES },
+       { "res.payload_lv",      smp_fetch_payload_lv,     
ARG3(2,SINT,SINT,STR),  SMP_VAL_ARGS(val_payload_lv),  SMP_T_BIN,  
SMP_USE_L6RES },
+       { "res.ssl_hello_type",  smp_fetch_ssl_hello_type, 0,                   
   SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L6RES },
+       { "wait_end",            smp_fetch_wait_end,       0,                   
   SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_INTRN },
        { /* END */ },
 }};
 
diff --git a/src/proto_http.c b/src/proto_http.c
index 7e4a83515..0136f505b 100644
--- a/src/proto_http.c
+++ b/src/proto_http.c
@@ -12821,114 +12821,114 @@ static struct acl_kw_list acl_kws = {ILH, {
 /************************************************************************/
 /* Note: must not be declared <const> as its list will be overwritten */
 static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, {
-       { "base",            smp_fetch_base,           0,                NULL,  
  SMP_T_STR,  SMP_USE_HRQHV },
-       { "base32",          smp_fetch_base32,         0,                NULL,  
  SMP_T_SINT, SMP_USE_HRQHV },
-       { "base32+src",      smp_fetch_base32_src,     0,                NULL,  
  SMP_T_BIN,  SMP_USE_HRQHV },
+       { "base",            smp_fetch_base,           0,                
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHV },
+       { "base32",          smp_fetch_base32,         0,                
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRQHV },
+       { "base32+src",      smp_fetch_base32_src,     0,                
SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_HRQHV },
 
        /* capture are allocated and are permanent in the stream */
-       { "capture.req.hdr", smp_fetch_capture_header_req, ARG1(1,SINT), NULL,  
 SMP_T_STR,  SMP_USE_HRQHP },
+       { "capture.req.hdr", smp_fetch_capture_header_req, ARG1(1,SINT), 
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHP },
 
        /* retrieve these captures from the HTTP logs */
-       { "capture.req.method", smp_fetch_capture_req_method, 0,         NULL,  
 SMP_T_STR,  SMP_USE_HRQHP },
-       { "capture.req.uri",    smp_fetch_capture_req_uri,    0,         NULL,  
 SMP_T_STR,  SMP_USE_HRQHP },
-       { "capture.req.ver",    smp_fetch_capture_req_ver,    0,         NULL,  
 SMP_T_STR,  SMP_USE_HRQHP },
+       { "capture.req.method", smp_fetch_capture_req_method, 0,         
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHP },
+       { "capture.req.uri",    smp_fetch_capture_req_uri,    0,         
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHP },
+       { "capture.req.ver",    smp_fetch_capture_req_ver,    0,         
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHP },
 
-       { "capture.res.hdr", smp_fetch_capture_header_res, ARG1(1,SINT), NULL,  
 SMP_T_STR,  SMP_USE_HRSHP },
-       { "capture.res.ver", smp_fetch_capture_res_ver,       0,         NULL,  
 SMP_T_STR,  SMP_USE_HRQHP },
+       { "capture.res.hdr", smp_fetch_capture_header_res, ARG1(1,SINT), 
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRSHP },
+       { "capture.res.ver", smp_fetch_capture_res_ver,       0,         
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHP },
 
        /* cookie is valid in both directions (eg: for "stick ...") but cook*
         * are only here to match the ACL's name, are request-only and are used
         * for ACL compatibility only.
         */
-       { "cook",            smp_fetch_cookie,         ARG1(0,STR),      NULL,  
  SMP_T_STR,  SMP_USE_HRQHV },
-       { "cookie",          smp_fetch_cookie,         ARG1(0,STR),      NULL,  
  SMP_T_STR,  SMP_USE_HRQHV|SMP_USE_HRSHV },
-       { "cook_cnt",        smp_fetch_cookie_cnt,     ARG1(0,STR),      NULL,  
  SMP_T_SINT, SMP_USE_HRQHV },
-       { "cook_val",        smp_fetch_cookie_val,     ARG1(0,STR),      NULL,  
  SMP_T_SINT, SMP_USE_HRQHV },
+       { "cook",            smp_fetch_cookie,         ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHV },
+       { "cookie",          smp_fetch_cookie,         ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHV|SMP_USE_HRSHV },
+       { "cook_cnt",        smp_fetch_cookie_cnt,     ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRQHV },
+       { "cook_val",        smp_fetch_cookie_val,     ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRQHV },
 
        /* hdr is valid in both directions (eg: for "stick ...") but hdr_* are
         * only here to match the ACL's name, are request-only and are used for
         * ACL compatibility only.
         */
-       { "hdr",             smp_fetch_hdr,            ARG2(0,STR,SINT), 
val_hdr, SMP_T_STR,  SMP_USE_HRQHV|SMP_USE_HRSHV },
-       { "hdr_cnt",         smp_fetch_hdr_cnt,        ARG1(0,STR),      NULL,  
  SMP_T_SINT, SMP_USE_HRQHV },
-       { "hdr_ip",          smp_fetch_hdr_ip,         ARG2(0,STR,SINT), 
val_hdr, SMP_T_IPV4, SMP_USE_HRQHV },
-       { "hdr_val",         smp_fetch_hdr_val,        ARG2(0,STR,SINT), 
val_hdr, SMP_T_SINT, SMP_USE_HRQHV },
-
-       { "http_auth",       smp_fetch_http_auth,      ARG1(1,USR),      NULL,  
  SMP_T_BOOL, SMP_USE_HRQHV },
-       { "http_auth_group", smp_fetch_http_auth_grp,  ARG1(1,USR),      NULL,  
  SMP_T_STR,  SMP_USE_HRQHV },
-       { "http_first_req",  smp_fetch_http_first_req, 0,                NULL,  
  SMP_T_BOOL, SMP_USE_HRQHP },
-       { "method",          smp_fetch_meth,           0,                NULL,  
  SMP_T_METH, SMP_USE_HRQHP },
-       { "path",            smp_fetch_path,           0,                NULL,  
  SMP_T_STR,  SMP_USE_HRQHV },
-       { "query",           smp_fetch_query,          0,                NULL,  
  SMP_T_STR,  SMP_USE_HRQHV },
+       { "hdr",             smp_fetch_hdr,            ARG2(0,STR,SINT), 
SMP_VAL_ARGS(val_hdr),  SMP_T_STR,  SMP_USE_HRQHV|SMP_USE_HRSHV },
+       { "hdr_cnt",         smp_fetch_hdr_cnt,        ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRQHV },
+       { "hdr_ip",          smp_fetch_hdr_ip,         ARG2(0,STR,SINT), 
SMP_VAL_ARGS(val_hdr),  SMP_T_IPV4, SMP_USE_HRQHV },
+       { "hdr_val",         smp_fetch_hdr_val,        ARG2(0,STR,SINT), 
SMP_VAL_ARGS(val_hdr),  SMP_T_SINT, SMP_USE_HRQHV },
+
+       { "http_auth",       smp_fetch_http_auth,      ARG1(1,USR),      
SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_HRQHV },
+       { "http_auth_group", smp_fetch_http_auth_grp,  ARG1(1,USR),      
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHV },
+       { "http_first_req",  smp_fetch_http_first_req, 0,                
SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_HRQHP },
+       { "method",          smp_fetch_meth,           0,                
SMP_VAL_ARGS(NULL), SMP_T_METH, SMP_USE_HRQHP },
+       { "path",            smp_fetch_path,           0,                
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHV },
+       { "query",           smp_fetch_query,          0,                
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHV },
 
        /* HTTP protocol on the request path */
-       { "req.proto_http",  smp_fetch_proto_http,     0,                NULL,  
  SMP_T_BOOL, SMP_USE_HRQHP },
-       { "req_proto_http",  smp_fetch_proto_http,     0,                NULL,  
  SMP_T_BOOL, SMP_USE_HRQHP },
+       { "req.proto_http",  smp_fetch_proto_http,     0,                
SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_HRQHP },
+       { "req_proto_http",  smp_fetch_proto_http,     0,                
SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_HRQHP },
 
        /* HTTP version on the request path */
-       { "req.ver",         smp_fetch_rqver,          0,                NULL,  
  SMP_T_STR,  SMP_USE_HRQHV },
-       { "req_ver",         smp_fetch_rqver,          0,                NULL,  
  SMP_T_STR,  SMP_USE_HRQHV },
+       { "req.ver",         smp_fetch_rqver,          0,                
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHV },
+       { "req_ver",         smp_fetch_rqver,          0,                
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHV },
 
-       { "req.body",        smp_fetch_body,           0,                NULL,  
  SMP_T_BIN,  SMP_USE_HRQHV },
-       { "req.body_len",    smp_fetch_body_len,       0,                NULL,  
  SMP_T_SINT, SMP_USE_HRQHV },
-       { "req.body_size",   smp_fetch_body_size,      0,                NULL,  
  SMP_T_SINT, SMP_USE_HRQHV },
-       { "req.body_param",  smp_fetch_body_param,     ARG1(0,STR),      NULL,  
  SMP_T_BIN,  SMP_USE_HRQHV },
+       { "req.body",        smp_fetch_body,           0,                
SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_HRQHV },
+       { "req.body_len",    smp_fetch_body_len,       0,                
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRQHV },
+       { "req.body_size",   smp_fetch_body_size,      0,                
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRQHV },
+       { "req.body_param",  smp_fetch_body_param,     ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_HRQHV },
 
-       { "req.hdrs",        smp_fetch_hdrs,           0,                NULL,  
  SMP_T_BIN,  SMP_USE_HRQHV },
-       { "req.hdrs_bin",    smp_fetch_hdrs_bin,       0,                NULL,  
  SMP_T_BIN,  SMP_USE_HRQHV },
+       { "req.hdrs",        smp_fetch_hdrs,           0,                
SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_HRQHV },
+       { "req.hdrs_bin",    smp_fetch_hdrs_bin,       0,                
SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_HRQHV },
 
        /* HTTP version on the response path */
-       { "res.ver",         smp_fetch_stver,          0,                NULL,  
  SMP_T_STR,  SMP_USE_HRSHV },
-       { "resp_ver",        smp_fetch_stver,          0,                NULL,  
  SMP_T_STR,  SMP_USE_HRSHV },
+       { "res.ver",         smp_fetch_stver,          0,                
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRSHV },
+       { "resp_ver",        smp_fetch_stver,          0,                
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRSHV },
 
        /* explicit req.{cook,hdr} are used to force the fetch direction to be 
request-only */
-       { "req.cook",        smp_fetch_cookie,         ARG1(0,STR),      NULL,  
  SMP_T_STR,  SMP_USE_HRQHV },
-       { "req.cook_cnt",    smp_fetch_cookie_cnt,     ARG1(0,STR),      NULL,  
  SMP_T_SINT, SMP_USE_HRQHV },
-       { "req.cook_val",    smp_fetch_cookie_val,     ARG1(0,STR),      NULL,  
  SMP_T_SINT, SMP_USE_HRQHV },
-
-       { "req.fhdr",        smp_fetch_fhdr,           ARG2(0,STR,SINT), 
val_hdr, SMP_T_STR,  SMP_USE_HRQHV },
-       { "req.fhdr_cnt",    smp_fetch_fhdr_cnt,       ARG1(0,STR),      NULL,  
  SMP_T_SINT, SMP_USE_HRQHV },
-       { "req.hdr",         smp_fetch_hdr,            ARG2(0,STR,SINT), 
val_hdr, SMP_T_STR,  SMP_USE_HRQHV },
-       { "req.hdr_cnt",     smp_fetch_hdr_cnt,        ARG1(0,STR),      NULL,  
  SMP_T_SINT, SMP_USE_HRQHV },
-       { "req.hdr_ip",      smp_fetch_hdr_ip,         ARG2(0,STR,SINT), 
val_hdr, SMP_T_IPV4, SMP_USE_HRQHV },
-       { "req.hdr_names",   smp_fetch_hdr_names,      ARG1(0,STR),      NULL,  
  SMP_T_STR,  SMP_USE_HRQHV },
-       { "req.hdr_val",     smp_fetch_hdr_val,        ARG2(0,STR,SINT), 
val_hdr, SMP_T_SINT, SMP_USE_HRQHV },
+       { "req.cook",        smp_fetch_cookie,         ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHV },
+       { "req.cook_cnt",    smp_fetch_cookie_cnt,     ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRQHV },
+       { "req.cook_val",    smp_fetch_cookie_val,     ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRQHV },
+
+       { "req.fhdr",        smp_fetch_fhdr,           ARG2(0,STR,SINT), 
SMP_VAL_ARGS(val_hdr),  SMP_T_STR,  SMP_USE_HRQHV },
+       { "req.fhdr_cnt",    smp_fetch_fhdr_cnt,       ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRQHV },
+       { "req.hdr",         smp_fetch_hdr,            ARG2(0,STR,SINT), 
SMP_VAL_ARGS(val_hdr),  SMP_T_STR,  SMP_USE_HRQHV },
+       { "req.hdr_cnt",     smp_fetch_hdr_cnt,        ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRQHV },
+       { "req.hdr_ip",      smp_fetch_hdr_ip,         ARG2(0,STR,SINT), 
SMP_VAL_ARGS(val_hdr),  SMP_T_IPV4, SMP_USE_HRQHV },
+       { "req.hdr_names",   smp_fetch_hdr_names,      ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHV },
+       { "req.hdr_val",     smp_fetch_hdr_val,        ARG2(0,STR,SINT), 
SMP_VAL_ARGS(val_hdr),  SMP_T_SINT, SMP_USE_HRQHV },
 
        /* explicit req.{cook,hdr} are used to force the fetch direction to be 
response-only */
-       { "res.cook",        smp_fetch_cookie,         ARG1(0,STR),      NULL,  
  SMP_T_STR,  SMP_USE_HRSHV },
-       { "res.cook_cnt",    smp_fetch_cookie_cnt,     ARG1(0,STR),      NULL,  
  SMP_T_SINT, SMP_USE_HRSHV },
-       { "res.cook_val",    smp_fetch_cookie_val,     ARG1(0,STR),      NULL,  
  SMP_T_SINT, SMP_USE_HRSHV },
-
-       { "res.fhdr",        smp_fetch_fhdr,           ARG2(0,STR,SINT), 
val_hdr, SMP_T_STR,  SMP_USE_HRSHV },
-       { "res.fhdr_cnt",    smp_fetch_fhdr_cnt,       ARG1(0,STR),      NULL,  
  SMP_T_SINT, SMP_USE_HRSHV },
-       { "res.hdr",         smp_fetch_hdr,            ARG2(0,STR,SINT), 
val_hdr, SMP_T_STR,  SMP_USE_HRSHV },
-       { "res.hdr_cnt",     smp_fetch_hdr_cnt,        ARG1(0,STR),      NULL,  
  SMP_T_SINT, SMP_USE_HRSHV },
-       { "res.hdr_ip",      smp_fetch_hdr_ip,         ARG2(0,STR,SINT), 
val_hdr, SMP_T_IPV4, SMP_USE_HRSHV },
-       { "res.hdr_names",   smp_fetch_hdr_names,      ARG1(0,STR),      NULL,  
  SMP_T_STR,  SMP_USE_HRSHV },
-       { "res.hdr_val",     smp_fetch_hdr_val,        ARG2(0,STR,SINT), 
val_hdr, SMP_T_SINT, SMP_USE_HRSHV },
+       { "res.cook",        smp_fetch_cookie,         ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRSHV },
+       { "res.cook_cnt",    smp_fetch_cookie_cnt,     ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRSHV },
+       { "res.cook_val",    smp_fetch_cookie_val,     ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRSHV },
+
+       { "res.fhdr",        smp_fetch_fhdr,           ARG2(0,STR,SINT), 
SMP_VAL_ARGS(val_hdr),  SMP_T_STR,  SMP_USE_HRSHV },
+       { "res.fhdr_cnt",    smp_fetch_fhdr_cnt,       ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRSHV },
+       { "res.hdr",         smp_fetch_hdr,            ARG2(0,STR,SINT), 
SMP_VAL_ARGS(val_hdr),  SMP_T_STR,  SMP_USE_HRSHV },
+       { "res.hdr_cnt",     smp_fetch_hdr_cnt,        ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRSHV },
+       { "res.hdr_ip",      smp_fetch_hdr_ip,         ARG2(0,STR,SINT), 
SMP_VAL_ARGS(val_hdr),  SMP_T_IPV4, SMP_USE_HRSHV },
+       { "res.hdr_names",   smp_fetch_hdr_names,      ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRSHV },
+       { "res.hdr_val",     smp_fetch_hdr_val,        ARG2(0,STR,SINT), 
SMP_VAL_ARGS(val_hdr),  SMP_T_SINT, SMP_USE_HRSHV },
 
        /* scook is valid only on the response and is used for ACL 
compatibility */
-       { "scook",           smp_fetch_cookie,         ARG1(0,STR),      NULL,  
  SMP_T_STR,  SMP_USE_HRSHV },
-       { "scook_cnt",       smp_fetch_cookie_cnt,     ARG1(0,STR),      NULL,  
  SMP_T_SINT, SMP_USE_HRSHV },
-       { "scook_val",       smp_fetch_cookie_val,     ARG1(0,STR),      NULL,  
  SMP_T_SINT, SMP_USE_HRSHV },
-       { "set-cookie",      smp_fetch_cookie,         ARG1(0,STR),      NULL,  
  SMP_T_STR,  SMP_USE_HRSHV }, /* deprecated */
+       { "scook",           smp_fetch_cookie,         ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRSHV },
+       { "scook_cnt",       smp_fetch_cookie_cnt,     ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRSHV },
+       { "scook_val",       smp_fetch_cookie_val,     ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRSHV },
+       { "set-cookie",      smp_fetch_cookie,         ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRSHV }, /* deprecated */
 
        /* shdr is valid only on the response and is used for ACL compatibility 
*/
-       { "shdr",            smp_fetch_hdr,            ARG2(0,STR,SINT), 
val_hdr, SMP_T_STR,  SMP_USE_HRSHV },
-       { "shdr_cnt",        smp_fetch_hdr_cnt,        ARG1(0,STR),      NULL,  
  SMP_T_SINT, SMP_USE_HRSHV },
-       { "shdr_ip",         smp_fetch_hdr_ip,         ARG2(0,STR,SINT), 
val_hdr, SMP_T_IPV4, SMP_USE_HRSHV },
-       { "shdr_val",        smp_fetch_hdr_val,        ARG2(0,STR,SINT), 
val_hdr, SMP_T_SINT, SMP_USE_HRSHV },
-
-       { "status",          smp_fetch_stcode,         0,                NULL,  
  SMP_T_SINT, SMP_USE_HRSHP },
-       { "unique-id",       smp_fetch_uniqueid,       0,                NULL,  
  SMP_T_STR,  SMP_SRC_L4SRV },
-       { "url",             smp_fetch_url,            0,                NULL,  
  SMP_T_STR,  SMP_USE_HRQHV },
-       { "url32",           smp_fetch_url32,          0,                NULL,  
  SMP_T_SINT, SMP_USE_HRQHV },
-       { "url32+src",       smp_fetch_url32_src,      0,                NULL,  
  SMP_T_BIN,  SMP_USE_HRQHV },
-       { "url_ip",          smp_fetch_url_ip,         0,                NULL,  
  SMP_T_IPV4, SMP_USE_HRQHV },
-       { "url_port",        smp_fetch_url_port,       0,                NULL,  
  SMP_T_SINT, SMP_USE_HRQHV },
-       { "url_param",       smp_fetch_url_param,      ARG2(0,STR,STR),  NULL,  
  SMP_T_STR,  SMP_USE_HRQHV },
-       { "urlp"     ,       smp_fetch_url_param,      ARG2(0,STR,STR),  NULL,  
  SMP_T_STR,  SMP_USE_HRQHV },
-       { "urlp_val",        smp_fetch_url_param_val,  ARG2(0,STR,STR),  NULL,  
  SMP_T_SINT, SMP_USE_HRQHV },
+       { "shdr",            smp_fetch_hdr,            ARG2(0,STR,SINT), 
SMP_VAL_ARGS(val_hdr),  SMP_T_STR,  SMP_USE_HRSHV },
+       { "shdr_cnt",        smp_fetch_hdr_cnt,        ARG1(0,STR),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRSHV },
+       { "shdr_ip",         smp_fetch_hdr_ip,         ARG2(0,STR,SINT), 
SMP_VAL_ARGS(val_hdr),  SMP_T_IPV4, SMP_USE_HRSHV },
+       { "shdr_val",        smp_fetch_hdr_val,        ARG2(0,STR,SINT), 
SMP_VAL_ARGS(val_hdr),  SMP_T_SINT, SMP_USE_HRSHV },
+
+       { "status",          smp_fetch_stcode,         0,                
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRSHP },
+       { "unique-id",       smp_fetch_uniqueid,       0,                
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_SRC_L4SRV },
+       { "url",             smp_fetch_url,            0,                
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHV },
+       { "url32",           smp_fetch_url32,          0,                
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRQHV },
+       { "url32+src",       smp_fetch_url32_src,      0,                
SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_HRQHV },
+       { "url_ip",          smp_fetch_url_ip,         0,                
SMP_VAL_ARGS(NULL), SMP_T_IPV4, SMP_USE_HRQHV },
+       { "url_port",        smp_fetch_url_port,       0,                
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRQHV },
+       { "url_param",       smp_fetch_url_param,      ARG2(0,STR,STR),  
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHV },
+       { "urlp"     ,       smp_fetch_url_param,      ARG2(0,STR,STR),  
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_HRQHV },
+       { "urlp_val",        smp_fetch_url_param_val,  ARG2(0,STR,STR),  
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_HRQHV },
        { /* END */ },
 }};
 
@@ -12938,11 +12938,11 @@ static struct sample_fetch_kw_list 
sample_fetch_keywords = {ILH, {
 /************************************************************************/
 /* Note: must not be declared <const> as its list will be overwritten */
 static struct sample_conv_kw_list sample_conv_kws = {ILH, {
-       { "http_date", sample_conv_http_date,  ARG1(0,SINT),     NULL, 
SMP_T_SINT, SMP_T_STR},
-       { "language",  sample_conv_q_prefered, ARG2(1,STR,STR),  NULL, 
SMP_T_STR,  SMP_T_STR},
-       { "capture-req", smp_conv_req_capture, ARG1(1,SINT),     NULL, 
SMP_T_STR,  SMP_T_STR},
-       { "capture-res", smp_conv_res_capture, ARG1(1,SINT),     NULL, 
SMP_T_STR,  SMP_T_STR},
-       { "url_dec",   sample_conv_url_dec,    0,                NULL, 
SMP_T_STR,  SMP_T_STR},
+       { "http_date", sample_conv_http_date,  ARG1(0,SINT),     
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_T_STR},
+       { "language",  sample_conv_q_prefered, ARG2(1,STR,STR),  
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_T_STR},
+       { "capture-req", smp_conv_req_capture, ARG1(1,SINT),     
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_T_STR},
+       { "capture-res", smp_conv_res_capture, ARG1(1,SINT),     
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_T_STR},
+       { "url_dec",   sample_conv_url_dec,    0,                
SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_T_STR},
        { NULL, NULL, 0, 0, 0 },
 }};
 
diff --git a/src/proto_tcp.c b/src/proto_tcp.c
index 857ebe133..ab5abe8fb 100644
--- a/src/proto_tcp.c
+++ b/src/proto_tcp.c
@@ -1938,22 +1938,22 @@ static int srv_parse_tcp_ut(char **args, int *cur_arg, 
struct proxy *px, struct
  * instance v4/v6 must be declared v4.
  */
 static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, {
-       { "dst",      smp_fetch_dst,   0, NULL, SMP_T_IPV4, SMP_USE_L4CLI },
-       { "dst_is_local", smp_fetch_dst_is_local, 0, NULL, SMP_T_BOOL, 
SMP_USE_L4CLI },
-       { "dst_port", smp_fetch_dport, 0, NULL, SMP_T_SINT, SMP_USE_L4CLI },
-       { "src",      smp_fetch_src,   0, NULL, SMP_T_IPV4, SMP_USE_L4CLI },
-       { "src_is_local", smp_fetch_src_is_local, 0, NULL, SMP_T_BOOL, 
SMP_USE_L4CLI },
-       { "src_port", smp_fetch_sport, 0, NULL, SMP_T_SINT, SMP_USE_L4CLI },
+       { "dst",      smp_fetch_dst,   0, SMP_VAL_ARGS(NULL), SMP_T_IPV4, 
SMP_USE_L4CLI },
+       { "dst_is_local", smp_fetch_dst_is_local, 0, SMP_VAL_ARGS(NULL), 
SMP_T_BOOL, SMP_USE_L4CLI },
+       { "dst_port", smp_fetch_dport, 0, SMP_VAL_ARGS(NULL), SMP_T_SINT, 
SMP_USE_L4CLI },
+       { "src",      smp_fetch_src,   0, SMP_VAL_ARGS(NULL), SMP_T_IPV4, 
SMP_USE_L4CLI },
+       { "src_is_local", smp_fetch_src_is_local, 0, SMP_VAL_ARGS(NULL), 
SMP_T_BOOL, SMP_USE_L4CLI },
+       { "src_port", smp_fetch_sport, 0, SMP_VAL_ARGS(NULL), SMP_T_SINT, 
SMP_USE_L4CLI },
 #ifdef TCP_INFO
-       { "fc_rtt",           smp_fetch_fc_rtt,           ARG1(0,STR), NULL, 
SMP_T_SINT, SMP_USE_L4CLI },
-       { "fc_rttvar",        smp_fetch_fc_rttvar,        ARG1(0,STR), NULL, 
SMP_T_SINT, SMP_USE_L4CLI },
+       { "fc_rtt",           smp_fetch_fc_rtt,           ARG1(0,STR), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI },
+       { "fc_rttvar",        smp_fetch_fc_rttvar,        ARG1(0,STR), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI },
 #if defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__)
-       { "fc_unacked",       smp_fetch_fc_unacked,       ARG1(0,STR), NULL, 
SMP_T_SINT, SMP_USE_L4CLI },
-       { "fc_sacked",        smp_fetch_fc_sacked,        ARG1(0,STR), NULL, 
SMP_T_SINT, SMP_USE_L4CLI },
-       { "fc_retrans",       smp_fetch_fc_retrans,       ARG1(0,STR), NULL, 
SMP_T_SINT, SMP_USE_L4CLI },
-       { "fc_fackets",       smp_fetch_fc_fackets,       ARG1(0,STR), NULL, 
SMP_T_SINT, SMP_USE_L4CLI },
-       { "fc_lost",          smp_fetch_fc_lost,          ARG1(0,STR), NULL, 
SMP_T_SINT, SMP_USE_L4CLI },
-       { "fc_reordering",    smp_fetch_fc_reordering,    ARG1(0,STR), NULL, 
SMP_T_SINT, SMP_USE_L4CLI },
+       { "fc_unacked",       smp_fetch_fc_unacked,       ARG1(0,STR), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI },
+       { "fc_sacked",        smp_fetch_fc_sacked,        ARG1(0,STR), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI },
+       { "fc_retrans",       smp_fetch_fc_retrans,       ARG1(0,STR), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI },
+       { "fc_fackets",       smp_fetch_fc_fackets,       ARG1(0,STR), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI },
+       { "fc_lost",          smp_fetch_fc_lost,          ARG1(0,STR), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI },
+       { "fc_reordering",    smp_fetch_fc_reordering,    ARG1(0,STR), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI },
 #endif // linux || freebsd || netbsd
 #endif // TCP_INFO
        { /* END */ },
diff --git a/src/sample.c b/src/sample.c
index 139d97662..b4ed77d48 100644
--- a/src/sample.c
+++ b/src/sample.c
@@ -2755,24 +2755,24 @@ static int smp_fetch_const_meth(const struct arg *args, 
struct sample *smp, cons
  * instance IPv4/IPv6 must be declared IPv4.
  */
 static struct sample_fetch_kw_list smp_kws = {ILH, {
-       { "always_false", smp_fetch_false, 0,            NULL, SMP_T_BOOL, 
SMP_USE_INTRN },
-       { "always_true",  smp_fetch_true,  0,            NULL, SMP_T_BOOL, 
SMP_USE_INTRN },
-       { "env",          smp_fetch_env,   ARG1(1,STR),  NULL, SMP_T_STR,  
SMP_USE_INTRN },
-       { "date",         smp_fetch_date,  ARG1(0,SINT), NULL, SMP_T_SINT, 
SMP_USE_INTRN },
-       { "hostname",     smp_fetch_hostname, 0,         NULL, SMP_T_STR,  
SMP_USE_INTRN },
-       { "nbproc",       smp_fetch_nbproc,0,            NULL, SMP_T_SINT, 
SMP_USE_INTRN },
-       { "proc",         smp_fetch_proc,  0,            NULL, SMP_T_SINT, 
SMP_USE_INTRN },
-       { "thread",       smp_fetch_thread,  0,          NULL, SMP_T_SINT, 
SMP_USE_INTRN },
-       { "rand",         smp_fetch_rand,  ARG1(0,SINT), NULL, SMP_T_SINT, 
SMP_USE_INTRN },
-       { "stopping",     smp_fetch_stopping, 0,         NULL, SMP_T_BOOL, 
SMP_USE_INTRN },
-
-       { "str",  smp_fetch_const_str,  ARG1(1,STR),  NULL                , 
SMP_T_STR,  SMP_USE_INTRN },
-       { "bool", smp_fetch_const_bool, ARG1(1,STR),  smp_check_const_bool, 
SMP_T_BOOL, SMP_USE_INTRN },
-       { "int",  smp_fetch_const_int,  ARG1(1,SINT), NULL                , 
SMP_T_SINT, SMP_USE_INTRN },
-       { "ipv4", smp_fetch_const_ipv4, ARG1(1,IPV4), NULL                , 
SMP_T_IPV4, SMP_USE_INTRN },
-       { "ipv6", smp_fetch_const_ipv6, ARG1(1,IPV6), NULL                , 
SMP_T_IPV6, SMP_USE_INTRN },
-       { "bin",  smp_fetch_const_bin,  ARG1(1,STR),  smp_check_const_bin , 
SMP_T_BIN,  SMP_USE_INTRN },
-       { "meth", smp_fetch_const_meth, ARG1(1,STR),  smp_check_const_meth, 
SMP_T_METH, SMP_USE_INTRN },
+       { "always_false", smp_fetch_false, 0,            SMP_VAL_ARGS(NULL), 
SMP_T_BOOL, SMP_USE_INTRN },
+       { "always_true",  smp_fetch_true,  0,            SMP_VAL_ARGS(NULL), 
SMP_T_BOOL, SMP_USE_INTRN },
+       { "env",          smp_fetch_env,   ARG1(1,STR),  SMP_VAL_ARGS(NULL), 
SMP_T_STR,  SMP_USE_INTRN },
+       { "date",         smp_fetch_date,  ARG1(0,SINT), SMP_VAL_ARGS(NULL), 
SMP_T_SINT, SMP_USE_INTRN },
+       { "hostname",     smp_fetch_hostname, 0,         SMP_VAL_ARGS(NULL), 
SMP_T_STR,  SMP_USE_INTRN },
+       { "nbproc",       smp_fetch_nbproc,0,            SMP_VAL_ARGS(NULL), 
SMP_T_SINT, SMP_USE_INTRN },
+       { "proc",         smp_fetch_proc,  0,            SMP_VAL_ARGS(NULL), 
SMP_T_SINT, SMP_USE_INTRN },
+       { "thread",       smp_fetch_thread,  0,          SMP_VAL_ARGS(NULL), 
SMP_T_SINT, SMP_USE_INTRN },
+       { "rand",         smp_fetch_rand,  ARG1(0,SINT), SMP_VAL_ARGS(NULL), 
SMP_T_SINT, SMP_USE_INTRN },
+       { "stopping",     smp_fetch_stopping, 0,         SMP_VAL_ARGS(NULL), 
SMP_T_BOOL, SMP_USE_INTRN },
+
+       { "str",  smp_fetch_const_str,  ARG1(1,STR),  SMP_VAL_ARGS(NULL)        
        , SMP_T_STR,  SMP_USE_INTRN },
+       { "bool", smp_fetch_const_bool, ARG1(1,STR),  
SMP_VAL_ARGS(smp_check_const_bool), SMP_T_BOOL, SMP_USE_INTRN },
+       { "int",  smp_fetch_const_int,  ARG1(1,SINT), SMP_VAL_ARGS(NULL)        
        , SMP_T_SINT, SMP_USE_INTRN },
+       { "ipv4", smp_fetch_const_ipv4, ARG1(1,IPV4), SMP_VAL_ARGS(NULL)        
        , SMP_T_IPV4, SMP_USE_INTRN },
+       { "ipv6", smp_fetch_const_ipv6, ARG1(1,IPV6), SMP_VAL_ARGS(NULL)        
        , SMP_T_IPV6, SMP_USE_INTRN },
+       { "bin",  smp_fetch_const_bin,  ARG1(1,STR),  
SMP_VAL_ARGS(smp_check_const_bin) , SMP_T_BIN,  SMP_USE_INTRN },
+       { "meth", smp_fetch_const_meth, ARG1(1,STR),  
SMP_VAL_ARGS(smp_check_const_meth), SMP_T_METH, SMP_USE_INTRN },
 
        { /* END */ },
 }};
@@ -2780,45 +2780,45 @@ static struct sample_fetch_kw_list smp_kws = {ILH, {
 /* Note: must not be declared <const> as its list will be overwritten */
 static struct sample_conv_kw_list sample_conv_kws = {ILH, {
 #ifdef DEBUG_EXPR
-       { "debug",  sample_conv_debug,     0,            NULL, SMP_T_ANY,  
SMP_T_ANY  },
+       { "debug",  sample_conv_debug,     0,            SMP_VAL_ARGS(NULL), 
SMP_T_ANY,  SMP_T_ANY  },
 #endif
 
-       { "b64dec", sample_conv_base642bin,0,            NULL, SMP_T_STR,  
SMP_T_BIN  },
-       { "base64", sample_conv_bin2base64,0,            NULL, SMP_T_BIN,  
SMP_T_STR  },
-       { "upper",  sample_conv_str2upper, 0,            NULL, SMP_T_STR,  
SMP_T_STR  },
-       { "lower",  sample_conv_str2lower, 0,            NULL, SMP_T_STR,  
SMP_T_STR  },
-       { "hex",    sample_conv_bin2hex,   0,            NULL, SMP_T_BIN,  
SMP_T_STR  },
-       { "hex2i",  sample_conv_hex2int,   0,            NULL, SMP_T_STR,  
SMP_T_SINT },
-       { "ipmask", sample_conv_ipmask,    ARG1(1,MSK4), NULL, SMP_T_IPV4, 
SMP_T_IPV4 },
-       { "ltime",  sample_conv_ltime,     ARG2(1,STR,SINT), NULL, SMP_T_SINT, 
SMP_T_STR },
-       { "utime",  sample_conv_utime,     ARG2(1,STR,SINT), NULL, SMP_T_SINT, 
SMP_T_STR },
-       { "crc32",  sample_conv_crc32,     ARG1(0,SINT), NULL, SMP_T_BIN,  
SMP_T_SINT  },
-       { "djb2",   sample_conv_djb2,      ARG1(0,SINT), NULL, SMP_T_BIN,  
SMP_T_SINT  },
-       { "sdbm",   sample_conv_sdbm,      ARG1(0,SINT), NULL, SMP_T_BIN,  
SMP_T_SINT  },
-       { "wt6",    sample_conv_wt6,       ARG1(0,SINT), NULL, SMP_T_BIN,  
SMP_T_SINT  },
-       { "xxh32",  sample_conv_xxh32,     ARG1(0,SINT), NULL, SMP_T_BIN,  
SMP_T_SINT  },
-       { "xxh64",  sample_conv_xxh64,     ARG1(0,SINT), NULL, SMP_T_BIN,  
SMP_T_SINT  },
-       { "json",   sample_conv_json,      ARG1(1,STR),  
sample_conv_json_check, SMP_T_STR,  SMP_T_STR },
-       { "bytes",  sample_conv_bytes,     ARG2(1,SINT,SINT), NULL, SMP_T_BIN,  
SMP_T_BIN },
-       { "field",  sample_conv_field,     ARG2(2,SINT,STR), 
sample_conv_field_check, SMP_T_STR,  SMP_T_STR },
-       { "word",   sample_conv_word,      ARG2(2,SINT,STR), 
sample_conv_field_check, SMP_T_STR,  SMP_T_STR },
-       { "regsub", sample_conv_regsub,    ARG3(2,REG,STR,STR), 
sample_conv_regsub_check, SMP_T_STR, SMP_T_STR },
-       { "sha1",   sample_conv_sha1,      0,            NULL, SMP_T_BIN,  
SMP_T_BIN  },
-
-       { "and",    sample_conv_binary_and, ARG1(1,STR), check_operator, 
SMP_T_SINT, SMP_T_SINT  },
-       { "or",     sample_conv_binary_or,  ARG1(1,STR), check_operator, 
SMP_T_SINT, SMP_T_SINT  },
-       { "xor",    sample_conv_binary_xor, ARG1(1,STR), check_operator, 
SMP_T_SINT, SMP_T_SINT  },
-       { "cpl",    sample_conv_binary_cpl,           0, NULL, SMP_T_SINT, 
SMP_T_SINT  },
-       { "bool",   sample_conv_arith_bool,           0, NULL, SMP_T_SINT, 
SMP_T_BOOL },
-       { "not",    sample_conv_arith_not,            0, NULL, SMP_T_SINT, 
SMP_T_BOOL },
-       { "odd",    sample_conv_arith_odd,            0, NULL, SMP_T_SINT, 
SMP_T_BOOL },
-       { "even",   sample_conv_arith_even,           0, NULL, SMP_T_SINT, 
SMP_T_BOOL },
-       { "add",    sample_conv_arith_add,  ARG1(1,STR), check_operator, 
SMP_T_SINT, SMP_T_SINT  },
-       { "sub",    sample_conv_arith_sub,  ARG1(1,STR), check_operator, 
SMP_T_SINT, SMP_T_SINT  },
-       { "mul",    sample_conv_arith_mul,  ARG1(1,STR), check_operator, 
SMP_T_SINT, SMP_T_SINT  },
-       { "div",    sample_conv_arith_div,  ARG1(1,STR), check_operator, 
SMP_T_SINT, SMP_T_SINT  },
-       { "mod",    sample_conv_arith_mod,  ARG1(1,STR), check_operator, 
SMP_T_SINT, SMP_T_SINT  },
-       { "neg",    sample_conv_arith_neg,            0, NULL, SMP_T_SINT, 
SMP_T_SINT  },
+       { "b64dec", sample_conv_base642bin,0,            SMP_VAL_ARGS(NULL), 
SMP_T_STR,  SMP_T_BIN  },
+       { "base64", sample_conv_bin2base64,0,            SMP_VAL_ARGS(NULL), 
SMP_T_BIN,  SMP_T_STR  },
+       { "upper",  sample_conv_str2upper, 0,            SMP_VAL_ARGS(NULL), 
SMP_T_STR,  SMP_T_STR  },
+       { "lower",  sample_conv_str2lower, 0,            SMP_VAL_ARGS(NULL), 
SMP_T_STR,  SMP_T_STR  },
+       { "hex",    sample_conv_bin2hex,   0,            SMP_VAL_ARGS(NULL), 
SMP_T_BIN,  SMP_T_STR  },
+       { "hex2i",  sample_conv_hex2int,   0,            SMP_VAL_ARGS(NULL), 
SMP_T_STR,  SMP_T_SINT },
+       { "ipmask", sample_conv_ipmask,    ARG1(1,MSK4), SMP_VAL_ARGS(NULL), 
SMP_T_IPV4, SMP_T_IPV4 },
+       { "ltime",  sample_conv_ltime,     ARG2(1,STR,SINT), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_T_STR },
+       { "utime",  sample_conv_utime,     ARG2(1,STR,SINT), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_T_STR },
+       { "crc32",  sample_conv_crc32,     ARG1(0,SINT), SMP_VAL_ARGS(NULL), 
SMP_T_BIN,  SMP_T_SINT  },
+       { "djb2",   sample_conv_djb2,      ARG1(0,SINT), SMP_VAL_ARGS(NULL), 
SMP_T_BIN,  SMP_T_SINT  },
+       { "sdbm",   sample_conv_sdbm,      ARG1(0,SINT), SMP_VAL_ARGS(NULL), 
SMP_T_BIN,  SMP_T_SINT  },
+       { "wt6",    sample_conv_wt6,       ARG1(0,SINT), SMP_VAL_ARGS(NULL), 
SMP_T_BIN,  SMP_T_SINT  },
+       { "xxh32",  sample_conv_xxh32,     ARG1(0,SINT), SMP_VAL_ARGS(NULL), 
SMP_T_BIN,  SMP_T_SINT  },
+       { "xxh64",  sample_conv_xxh64,     ARG1(0,SINT), SMP_VAL_ARGS(NULL), 
SMP_T_BIN,  SMP_T_SINT  },
+       { "json",   sample_conv_json,      ARG1(1,STR),  
SMP_VAL_ARGS(sample_conv_json_check), SMP_T_STR,  SMP_T_STR },
+       { "bytes",  sample_conv_bytes,     ARG2(1,SINT,SINT), 
SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_T_BIN },
+       { "field",  sample_conv_field,     ARG2(2,SINT,STR), 
SMP_VAL_ARGS(sample_conv_field_check), SMP_T_STR,  SMP_T_STR },
+       { "word",   sample_conv_word,      ARG2(2,SINT,STR), 
SMP_VAL_ARGS(sample_conv_field_check), SMP_T_STR,  SMP_T_STR },
+       { "regsub", sample_conv_regsub,    ARG3(2,REG,STR,STR), 
SMP_VAL_ARGS(sample_conv_regsub_check), SMP_T_STR, SMP_T_STR },
+       { "sha1",   sample_conv_sha1,      0,            SMP_VAL_ARGS(NULL), 
SMP_T_BIN,  SMP_T_BIN  },
+
+       { "and",    sample_conv_binary_and, ARG1(1,STR), 
SMP_VAL_ARGS(check_operator), SMP_T_SINT, SMP_T_SINT  },
+       { "or",     sample_conv_binary_or,  ARG1(1,STR), 
SMP_VAL_ARGS(check_operator), SMP_T_SINT, SMP_T_SINT  },
+       { "xor",    sample_conv_binary_xor, ARG1(1,STR), 
SMP_VAL_ARGS(check_operator), SMP_T_SINT, SMP_T_SINT  },
+       { "cpl",    sample_conv_binary_cpl,           0, SMP_VAL_ARGS(NULL), 
SMP_T_SINT, SMP_T_SINT  },
+       { "bool",   sample_conv_arith_bool,           0, SMP_VAL_ARGS(NULL), 
SMP_T_SINT, SMP_T_BOOL },
+       { "not",    sample_conv_arith_not,            0, SMP_VAL_ARGS(NULL), 
SMP_T_SINT, SMP_T_BOOL },
+       { "odd",    sample_conv_arith_odd,            0, SMP_VAL_ARGS(NULL), 
SMP_T_SINT, SMP_T_BOOL },
+       { "even",   sample_conv_arith_even,           0, SMP_VAL_ARGS(NULL), 
SMP_T_SINT, SMP_T_BOOL },
+       { "add",    sample_conv_arith_add,  ARG1(1,STR), 
SMP_VAL_ARGS(check_operator), SMP_T_SINT, SMP_T_SINT  },
+       { "sub",    sample_conv_arith_sub,  ARG1(1,STR), 
SMP_VAL_ARGS(check_operator), SMP_T_SINT, SMP_T_SINT  },
+       { "mul",    sample_conv_arith_mul,  ARG1(1,STR), 
SMP_VAL_ARGS(check_operator), SMP_T_SINT, SMP_T_SINT  },
+       { "div",    sample_conv_arith_div,  ARG1(1,STR), 
SMP_VAL_ARGS(check_operator), SMP_T_SINT, SMP_T_SINT  },
+       { "mod",    sample_conv_arith_mod,  ARG1(1,STR), 
SMP_VAL_ARGS(check_operator), SMP_T_SINT, SMP_T_SINT  },
+       { "neg",    sample_conv_arith_neg,            0, SMP_VAL_ARGS(NULL), 
SMP_T_SINT, SMP_T_SINT  },
 
        { NULL, NULL, 0, 0, 0 },
 }};
diff --git a/src/ssl_sock.c b/src/ssl_sock.c
index 24ccc4b12..400e876b8 100644
--- a/src/ssl_sock.c
+++ b/src/ssl_sock.c
@@ -8642,60 +8642,60 @@ static struct cli_kw_list cli_kws = {{ },{
  * Please take care of keeping this list alphabetically sorted.
  */
 static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, {
-       { "ssl_bc",                 smp_fetch_ssl_fc,             0,            
       NULL,    SMP_T_BOOL, SMP_USE_L5SRV },
-       { "ssl_bc_alg_keysize",     smp_fetch_ssl_fc_alg_keysize, 0,            
       NULL,    SMP_T_SINT, SMP_USE_L5SRV },
-       { "ssl_bc_cipher",          smp_fetch_ssl_fc_cipher,      0,            
       NULL,    SMP_T_STR,  SMP_USE_L5SRV },
-       { "ssl_bc_protocol",        smp_fetch_ssl_fc_protocol,    0,            
       NULL,    SMP_T_STR,  SMP_USE_L5SRV },
-       { "ssl_bc_unique_id",       smp_fetch_ssl_fc_unique_id,   0,            
       NULL,    SMP_T_BIN,  SMP_USE_L5SRV },
-       { "ssl_bc_use_keysize",     smp_fetch_ssl_fc_use_keysize, 0,            
       NULL,    SMP_T_SINT, SMP_USE_L5SRV },
-       { "ssl_bc_session_id",      smp_fetch_ssl_fc_session_id,  0,            
       NULL,    SMP_T_BIN,  SMP_USE_L5SRV },
-       { "ssl_c_ca_err",           smp_fetch_ssl_c_ca_err,       0,            
       NULL,    SMP_T_SINT, SMP_USE_L5CLI },
-       { "ssl_c_ca_err_depth",     smp_fetch_ssl_c_ca_err_depth, 0,            
       NULL,    SMP_T_SINT, SMP_USE_L5CLI },
-       { "ssl_c_der",              smp_fetch_ssl_x_der,          0,            
       NULL,    SMP_T_BIN,  SMP_USE_L5CLI },
-       { "ssl_c_err",              smp_fetch_ssl_c_err,          0,            
       NULL,    SMP_T_SINT, SMP_USE_L5CLI },
-       { "ssl_c_i_dn",             smp_fetch_ssl_x_i_dn,         
ARG2(0,STR,SINT),    NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_c_key_alg",          smp_fetch_ssl_x_key_alg,      0,            
       NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_c_notafter",         smp_fetch_ssl_x_notafter,     0,            
       NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_c_notbefore",        smp_fetch_ssl_x_notbefore,    0,            
       NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_c_sig_alg",          smp_fetch_ssl_x_sig_alg,      0,            
       NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_c_s_dn",             smp_fetch_ssl_x_s_dn,         
ARG2(0,STR,SINT),    NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_c_serial",           smp_fetch_ssl_x_serial,       0,            
       NULL,    SMP_T_BIN,  SMP_USE_L5CLI },
-       { "ssl_c_sha1",             smp_fetch_ssl_x_sha1,         0,            
       NULL,    SMP_T_BIN,  SMP_USE_L5CLI },
-       { "ssl_c_used",             smp_fetch_ssl_c_used,         0,            
       NULL,    SMP_T_BOOL, SMP_USE_L5CLI },
-       { "ssl_c_verify",           smp_fetch_ssl_c_verify,       0,            
       NULL,    SMP_T_SINT, SMP_USE_L5CLI },
-       { "ssl_c_version",          smp_fetch_ssl_x_version,      0,            
       NULL,    SMP_T_SINT, SMP_USE_L5CLI },
-       { "ssl_f_der",              smp_fetch_ssl_x_der,          0,            
       NULL,    SMP_T_BIN,  SMP_USE_L5CLI },
-       { "ssl_f_i_dn",             smp_fetch_ssl_x_i_dn,         
ARG2(0,STR,SINT),    NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_f_key_alg",          smp_fetch_ssl_x_key_alg,      0,            
       NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_f_notafter",         smp_fetch_ssl_x_notafter,     0,            
       NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_f_notbefore",        smp_fetch_ssl_x_notbefore,    0,            
       NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_f_sig_alg",          smp_fetch_ssl_x_sig_alg,      0,            
       NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_f_s_dn",             smp_fetch_ssl_x_s_dn,         
ARG2(0,STR,SINT),    NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_f_serial",           smp_fetch_ssl_x_serial,       0,            
       NULL,    SMP_T_BIN,  SMP_USE_L5CLI },
-       { "ssl_f_sha1",             smp_fetch_ssl_x_sha1,         0,            
       NULL,    SMP_T_BIN,  SMP_USE_L5CLI },
-       { "ssl_f_version",          smp_fetch_ssl_x_version,      0,            
       NULL,    SMP_T_SINT, SMP_USE_L5CLI },
-       { "ssl_fc",                 smp_fetch_ssl_fc,             0,            
       NULL,    SMP_T_BOOL, SMP_USE_L5CLI },
-       { "ssl_fc_alg_keysize",     smp_fetch_ssl_fc_alg_keysize, 0,            
       NULL,    SMP_T_SINT, SMP_USE_L5CLI },
-       { "ssl_fc_cipher",          smp_fetch_ssl_fc_cipher,      0,            
       NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_fc_has_crt",         smp_fetch_ssl_fc_has_crt,     0,            
       NULL,    SMP_T_BOOL, SMP_USE_L5CLI },
-       { "ssl_fc_has_early",       smp_fetch_ssl_fc_has_early,   0,            
       NULL,    SMP_T_BOOL, SMP_USE_L5CLI },
-       { "ssl_fc_has_sni",         smp_fetch_ssl_fc_has_sni,     0,            
       NULL,    SMP_T_BOOL, SMP_USE_L5CLI },
-       { "ssl_fc_is_resumed",      smp_fetch_ssl_fc_is_resumed,  0,            
       NULL,    SMP_T_BOOL, SMP_USE_L5CLI },
+       { "ssl_bc",                 smp_fetch_ssl_fc,             0,            
       SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_L5SRV },
+       { "ssl_bc_alg_keysize",     smp_fetch_ssl_fc_alg_keysize, 0,            
       SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L5SRV },
+       { "ssl_bc_cipher",          smp_fetch_ssl_fc_cipher,      0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5SRV },
+       { "ssl_bc_protocol",        smp_fetch_ssl_fc_protocol,    0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5SRV },
+       { "ssl_bc_unique_id",       smp_fetch_ssl_fc_unique_id,   0,            
       SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_L5SRV },
+       { "ssl_bc_use_keysize",     smp_fetch_ssl_fc_use_keysize, 0,            
       SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L5SRV },
+       { "ssl_bc_session_id",      smp_fetch_ssl_fc_session_id,  0,            
       SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_L5SRV },
+       { "ssl_c_ca_err",           smp_fetch_ssl_c_ca_err,       0,            
       SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L5CLI },
+       { "ssl_c_ca_err_depth",     smp_fetch_ssl_c_ca_err_depth, 0,            
       SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L5CLI },
+       { "ssl_c_der",              smp_fetch_ssl_x_der,          0,            
       SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_L5CLI },
+       { "ssl_c_err",              smp_fetch_ssl_c_err,          0,            
       SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L5CLI },
+       { "ssl_c_i_dn",             smp_fetch_ssl_x_i_dn,         
ARG2(0,STR,SINT),    SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_c_key_alg",          smp_fetch_ssl_x_key_alg,      0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_c_notafter",         smp_fetch_ssl_x_notafter,     0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_c_notbefore",        smp_fetch_ssl_x_notbefore,    0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_c_sig_alg",          smp_fetch_ssl_x_sig_alg,      0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_c_s_dn",             smp_fetch_ssl_x_s_dn,         
ARG2(0,STR,SINT),    SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_c_serial",           smp_fetch_ssl_x_serial,       0,            
       SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_L5CLI },
+       { "ssl_c_sha1",             smp_fetch_ssl_x_sha1,         0,            
       SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_L5CLI },
+       { "ssl_c_used",             smp_fetch_ssl_c_used,         0,            
       SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_L5CLI },
+       { "ssl_c_verify",           smp_fetch_ssl_c_verify,       0,            
       SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L5CLI },
+       { "ssl_c_version",          smp_fetch_ssl_x_version,      0,            
       SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L5CLI },
+       { "ssl_f_der",              smp_fetch_ssl_x_der,          0,            
       SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_L5CLI },
+       { "ssl_f_i_dn",             smp_fetch_ssl_x_i_dn,         
ARG2(0,STR,SINT),    SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_f_key_alg",          smp_fetch_ssl_x_key_alg,      0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_f_notafter",         smp_fetch_ssl_x_notafter,     0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_f_notbefore",        smp_fetch_ssl_x_notbefore,    0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_f_sig_alg",          smp_fetch_ssl_x_sig_alg,      0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_f_s_dn",             smp_fetch_ssl_x_s_dn,         
ARG2(0,STR,SINT),    SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_f_serial",           smp_fetch_ssl_x_serial,       0,            
       SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_L5CLI },
+       { "ssl_f_sha1",             smp_fetch_ssl_x_sha1,         0,            
       SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_L5CLI },
+       { "ssl_f_version",          smp_fetch_ssl_x_version,      0,            
       SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L5CLI },
+       { "ssl_fc",                 smp_fetch_ssl_fc,             0,            
       SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_L5CLI },
+       { "ssl_fc_alg_keysize",     smp_fetch_ssl_fc_alg_keysize, 0,            
       SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L5CLI },
+       { "ssl_fc_cipher",          smp_fetch_ssl_fc_cipher,      0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_fc_has_crt",         smp_fetch_ssl_fc_has_crt,     0,            
       SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_L5CLI },
+       { "ssl_fc_has_early",       smp_fetch_ssl_fc_has_early,   0,            
       SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_L5CLI },
+       { "ssl_fc_has_sni",         smp_fetch_ssl_fc_has_sni,     0,            
       SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_L5CLI },
+       { "ssl_fc_is_resumed",      smp_fetch_ssl_fc_is_resumed,  0,            
       SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_L5CLI },
 #if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
-       { "ssl_fc_npn",             smp_fetch_ssl_fc_npn,         0,            
       NULL,    SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_fc_npn",             smp_fetch_ssl_fc_npn,         0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
 #endif
 #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
-       { "ssl_fc_alpn",            smp_fetch_ssl_fc_alpn,        0,            
       NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-#endif
-       { "ssl_fc_protocol",        smp_fetch_ssl_fc_protocol,    0,            
       NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_fc_unique_id",       smp_fetch_ssl_fc_unique_id,   0,            
       NULL,    SMP_T_BIN,  SMP_USE_L5CLI },
-       { "ssl_fc_use_keysize",     smp_fetch_ssl_fc_use_keysize, 0,            
       NULL,    SMP_T_SINT, SMP_USE_L5CLI },
-       { "ssl_fc_session_id",      smp_fetch_ssl_fc_session_id,  0,            
       NULL,    SMP_T_BIN,  SMP_USE_L5CLI },
-       { "ssl_fc_sni",             smp_fetch_ssl_fc_sni,         0,            
       NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_fc_cipherlist_bin",  smp_fetch_ssl_fc_cl_bin,      0,            
       NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_fc_cipherlist_hex",  smp_fetch_ssl_fc_cl_hex,      0,            
       NULL,    SMP_T_BIN,  SMP_USE_L5CLI },
-       { "ssl_fc_cipherlist_str",  smp_fetch_ssl_fc_cl_str,      0,            
       NULL,    SMP_T_STR,  SMP_USE_L5CLI },
-       { "ssl_fc_cipherlist_xxh",  smp_fetch_ssl_fc_cl_xxh64,    0,            
       NULL,    SMP_T_SINT, SMP_USE_L5CLI },
+       { "ssl_fc_alpn",            smp_fetch_ssl_fc_alpn,        0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+#endif
+       { "ssl_fc_protocol",        smp_fetch_ssl_fc_protocol,    0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_fc_unique_id",       smp_fetch_ssl_fc_unique_id,   0,            
       SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_L5CLI },
+       { "ssl_fc_use_keysize",     smp_fetch_ssl_fc_use_keysize, 0,            
       SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L5CLI },
+       { "ssl_fc_session_id",      smp_fetch_ssl_fc_session_id,  0,            
       SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_L5CLI },
+       { "ssl_fc_sni",             smp_fetch_ssl_fc_sni,         0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_fc_cipherlist_bin",  smp_fetch_ssl_fc_cl_bin,      0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_fc_cipherlist_hex",  smp_fetch_ssl_fc_cl_hex,      0,            
       SMP_VAL_ARGS(NULL), SMP_T_BIN,  SMP_USE_L5CLI },
+       { "ssl_fc_cipherlist_str",  smp_fetch_ssl_fc_cl_str,      0,            
       SMP_VAL_ARGS(NULL), SMP_T_STR,  SMP_USE_L5CLI },
+       { "ssl_fc_cipherlist_xxh",  smp_fetch_ssl_fc_cl_xxh64,    0,            
       SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L5CLI },
        { NULL, NULL, 0, 0, 0 },
 }};
 
diff --git a/src/stick_table.c b/src/stick_table.c
index 0a2383786..930858273 100644
--- a/src/stick_table.c
+++ b/src/stick_table.c
@@ -3328,140 +3328,140 @@ static struct action_kw_list http_res_kws = { { }, {
 // * Please take care of keeping this list alphabetically sorted.
 // */
 //static struct sample_fetch_kw_list smp_fetch_keywords = {ILH, {
-//     { "table_avl",          smp_fetch_table_avl,         ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-//     { "table_cnt",          smp_fetch_table_cnt,         ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
+//     { "table_avl",          smp_fetch_table_avl,         ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+//     { "table_cnt",          smp_fetch_table_cnt,         ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
 //     { /* END */ },
 //}};
 /* Note: must not be declared <const> as its list will be overwritten.
  * Please take care of keeping this list alphabetically sorted.
  */
 static struct sample_fetch_kw_list smp_fetch_keywords = {ILH, {
-       { "sc_bytes_in_rate",   smp_fetch_sc_bytes_in_rate,  ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc_bytes_out_rate",  smp_fetch_sc_bytes_out_rate, ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc_clr_gpc0",        smp_fetch_sc_clr_gpc0,       ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc_conn_cnt",        smp_fetch_sc_conn_cnt,       ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc_conn_cur",        smp_fetch_sc_conn_cur,       ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc_conn_rate",       smp_fetch_sc_conn_rate,      ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc_get_gpt0",        smp_fetch_sc_get_gpt0,       ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc_get_gpc0",        smp_fetch_sc_get_gpc0,       ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc_gpc0_rate",       smp_fetch_sc_gpc0_rate,      ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc_http_err_cnt",    smp_fetch_sc_http_err_cnt,   ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc_http_err_rate",   smp_fetch_sc_http_err_rate,  ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc_http_req_cnt",    smp_fetch_sc_http_req_cnt,   ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc_http_req_rate",   smp_fetch_sc_http_req_rate,  ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc_inc_gpc0",        smp_fetch_sc_inc_gpc0,       ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc_kbytes_in",       smp_fetch_sc_kbytes_in,      ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "sc_kbytes_out",      smp_fetch_sc_kbytes_out,     ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "sc_sess_cnt",        smp_fetch_sc_sess_cnt,       ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc_sess_rate",       smp_fetch_sc_sess_rate,      ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc_tracked",         smp_fetch_sc_tracked,        ARG2(1,SINT,TAB), 
NULL, SMP_T_BOOL, SMP_USE_INTRN, },
-       { "sc_trackers",        smp_fetch_sc_trackers,       ARG2(1,SINT,TAB), 
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_bytes_in_rate",  smp_fetch_sc_bytes_in_rate,  ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_bytes_out_rate", smp_fetch_sc_bytes_out_rate, ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_clr_gpc0",       smp_fetch_sc_clr_gpc0,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_conn_cnt",       smp_fetch_sc_conn_cnt,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_conn_cur",       smp_fetch_sc_conn_cur,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_conn_rate",      smp_fetch_sc_conn_rate,      ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_get_gpt0",       smp_fetch_sc_get_gpt0,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_get_gpc0",       smp_fetch_sc_get_gpc0,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_gpc0_rate",      smp_fetch_sc_gpc0_rate,      ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_http_err_cnt",   smp_fetch_sc_http_err_cnt,   ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_http_err_rate",  smp_fetch_sc_http_err_rate,  ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_http_req_cnt",   smp_fetch_sc_http_req_cnt,   ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_http_req_rate",  smp_fetch_sc_http_req_rate,  ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_inc_gpc0",       smp_fetch_sc_inc_gpc0,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_kbytes_in",      smp_fetch_sc_kbytes_in,      ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "sc0_kbytes_out",     smp_fetch_sc_kbytes_out,     ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "sc0_sess_cnt",       smp_fetch_sc_sess_cnt,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_sess_rate",      smp_fetch_sc_sess_rate,      ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc0_tracked",        smp_fetch_sc_tracked,        ARG1(0,TAB),      
NULL, SMP_T_BOOL, SMP_USE_INTRN, },
-       { "sc0_trackers",       smp_fetch_sc_trackers,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_bytes_in_rate",  smp_fetch_sc_bytes_in_rate,  ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_bytes_out_rate", smp_fetch_sc_bytes_out_rate, ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_clr_gpc0",       smp_fetch_sc_clr_gpc0,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_conn_cnt",       smp_fetch_sc_conn_cnt,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_conn_cur",       smp_fetch_sc_conn_cur,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_conn_rate",      smp_fetch_sc_conn_rate,      ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_get_gpt0",       smp_fetch_sc_get_gpt0,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_get_gpc0",       smp_fetch_sc_get_gpc0,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_gpc0_rate",      smp_fetch_sc_gpc0_rate,      ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_http_err_cnt",   smp_fetch_sc_http_err_cnt,   ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_http_err_rate",  smp_fetch_sc_http_err_rate,  ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_http_req_cnt",   smp_fetch_sc_http_req_cnt,   ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_http_req_rate",  smp_fetch_sc_http_req_rate,  ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_inc_gpc0",       smp_fetch_sc_inc_gpc0,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_kbytes_in",      smp_fetch_sc_kbytes_in,      ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "sc1_kbytes_out",     smp_fetch_sc_kbytes_out,     ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "sc1_sess_cnt",       smp_fetch_sc_sess_cnt,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_sess_rate",      smp_fetch_sc_sess_rate,      ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc1_tracked",        smp_fetch_sc_tracked,        ARG1(0,TAB),      
NULL, SMP_T_BOOL, SMP_USE_INTRN, },
-       { "sc1_trackers",       smp_fetch_sc_trackers,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_bytes_in_rate",  smp_fetch_sc_bytes_in_rate,  ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_bytes_out_rate", smp_fetch_sc_bytes_out_rate, ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_clr_gpc0",       smp_fetch_sc_clr_gpc0,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_conn_cnt",       smp_fetch_sc_conn_cnt,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_conn_cur",       smp_fetch_sc_conn_cur,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_conn_rate",      smp_fetch_sc_conn_rate,      ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_get_gpt0",       smp_fetch_sc_get_gpt0,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_get_gpc0",       smp_fetch_sc_get_gpc0,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_gpc0_rate",      smp_fetch_sc_gpc0_rate,      ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_http_err_cnt",   smp_fetch_sc_http_err_cnt,   ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_http_err_rate",  smp_fetch_sc_http_err_rate,  ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_http_req_cnt",   smp_fetch_sc_http_req_cnt,   ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_http_req_rate",  smp_fetch_sc_http_req_rate,  ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_inc_gpc0",       smp_fetch_sc_inc_gpc0,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_kbytes_in",      smp_fetch_sc_kbytes_in,      ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "sc2_kbytes_out",     smp_fetch_sc_kbytes_out,     ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "sc2_sess_cnt",       smp_fetch_sc_sess_cnt,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_sess_rate",      smp_fetch_sc_sess_rate,      ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "sc2_tracked",        smp_fetch_sc_tracked,        ARG1(0,TAB),      
NULL, SMP_T_BOOL, SMP_USE_INTRN, },
-       { "sc2_trackers",       smp_fetch_sc_trackers,       ARG1(0,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "src_bytes_in_rate",  smp_fetch_sc_bytes_in_rate,  ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_bytes_out_rate", smp_fetch_sc_bytes_out_rate, ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_clr_gpc0",       smp_fetch_sc_clr_gpc0,       ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_conn_cnt",       smp_fetch_sc_conn_cnt,       ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_conn_cur",       smp_fetch_sc_conn_cur,       ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_conn_rate",      smp_fetch_sc_conn_rate,      ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_get_gpt0",       smp_fetch_sc_get_gpt0,       ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_get_gpc0",       smp_fetch_sc_get_gpc0,       ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_gpc0_rate",      smp_fetch_sc_gpc0_rate,      ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_http_err_cnt",   smp_fetch_sc_http_err_cnt,   ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_http_err_rate",  smp_fetch_sc_http_err_rate,  ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_http_req_cnt",   smp_fetch_sc_http_req_cnt,   ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_http_req_rate",  smp_fetch_sc_http_req_rate,  ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_inc_gpc0",       smp_fetch_sc_inc_gpc0,       ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_kbytes_in",      smp_fetch_sc_kbytes_in,      ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_kbytes_out",     smp_fetch_sc_kbytes_out,     ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_sess_cnt",       smp_fetch_sc_sess_cnt,       ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_sess_rate",      smp_fetch_sc_sess_rate,      ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "src_updt_conn_cnt",  smp_fetch_src_updt_conn_cnt, ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_L4CLI, },
-       { "table_avl",          smp_fetch_table_avl,         ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
-       { "table_cnt",          smp_fetch_table_cnt,         ARG1(1,TAB),      
NULL, SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_bytes_in_rate",   smp_fetch_sc_bytes_in_rate,  ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_bytes_out_rate",  smp_fetch_sc_bytes_out_rate, ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_clr_gpc0",        smp_fetch_sc_clr_gpc0,       ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_conn_cnt",        smp_fetch_sc_conn_cnt,       ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_conn_cur",        smp_fetch_sc_conn_cur,       ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_conn_rate",       smp_fetch_sc_conn_rate,      ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_get_gpt0",        smp_fetch_sc_get_gpt0,       ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_get_gpc0",        smp_fetch_sc_get_gpc0,       ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_gpc0_rate",       smp_fetch_sc_gpc0_rate,      ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_http_err_cnt",    smp_fetch_sc_http_err_cnt,   ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_http_err_rate",   smp_fetch_sc_http_err_rate,  ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_http_req_cnt",    smp_fetch_sc_http_req_cnt,   ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_http_req_rate",   smp_fetch_sc_http_req_rate,  ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_inc_gpc0",        smp_fetch_sc_inc_gpc0,       ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_kbytes_in",       smp_fetch_sc_kbytes_in,      ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "sc_kbytes_out",      smp_fetch_sc_kbytes_out,     ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "sc_sess_cnt",        smp_fetch_sc_sess_cnt,       ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_sess_rate",       smp_fetch_sc_sess_rate,      ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc_tracked",         smp_fetch_sc_tracked,        ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_INTRN, },
+       { "sc_trackers",        smp_fetch_sc_trackers,       ARG2(1,SINT,TAB), 
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_bytes_in_rate",  smp_fetch_sc_bytes_in_rate,  ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_bytes_out_rate", smp_fetch_sc_bytes_out_rate, ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_clr_gpc0",       smp_fetch_sc_clr_gpc0,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_conn_cnt",       smp_fetch_sc_conn_cnt,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_conn_cur",       smp_fetch_sc_conn_cur,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_conn_rate",      smp_fetch_sc_conn_rate,      ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_get_gpt0",       smp_fetch_sc_get_gpt0,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_get_gpc0",       smp_fetch_sc_get_gpc0,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_gpc0_rate",      smp_fetch_sc_gpc0_rate,      ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_http_err_cnt",   smp_fetch_sc_http_err_cnt,   ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_http_err_rate",  smp_fetch_sc_http_err_rate,  ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_http_req_cnt",   smp_fetch_sc_http_req_cnt,   ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_http_req_rate",  smp_fetch_sc_http_req_rate,  ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_inc_gpc0",       smp_fetch_sc_inc_gpc0,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_kbytes_in",      smp_fetch_sc_kbytes_in,      ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "sc0_kbytes_out",     smp_fetch_sc_kbytes_out,     ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "sc0_sess_cnt",       smp_fetch_sc_sess_cnt,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_sess_rate",      smp_fetch_sc_sess_rate,      ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc0_tracked",        smp_fetch_sc_tracked,        ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_INTRN, },
+       { "sc0_trackers",       smp_fetch_sc_trackers,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_bytes_in_rate",  smp_fetch_sc_bytes_in_rate,  ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_bytes_out_rate", smp_fetch_sc_bytes_out_rate, ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_clr_gpc0",       smp_fetch_sc_clr_gpc0,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_conn_cnt",       smp_fetch_sc_conn_cnt,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_conn_cur",       smp_fetch_sc_conn_cur,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_conn_rate",      smp_fetch_sc_conn_rate,      ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_get_gpt0",       smp_fetch_sc_get_gpt0,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_get_gpc0",       smp_fetch_sc_get_gpc0,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_gpc0_rate",      smp_fetch_sc_gpc0_rate,      ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_http_err_cnt",   smp_fetch_sc_http_err_cnt,   ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_http_err_rate",  smp_fetch_sc_http_err_rate,  ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_http_req_cnt",   smp_fetch_sc_http_req_cnt,   ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_http_req_rate",  smp_fetch_sc_http_req_rate,  ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_inc_gpc0",       smp_fetch_sc_inc_gpc0,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_kbytes_in",      smp_fetch_sc_kbytes_in,      ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "sc1_kbytes_out",     smp_fetch_sc_kbytes_out,     ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "sc1_sess_cnt",       smp_fetch_sc_sess_cnt,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_sess_rate",      smp_fetch_sc_sess_rate,      ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc1_tracked",        smp_fetch_sc_tracked,        ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_INTRN, },
+       { "sc1_trackers",       smp_fetch_sc_trackers,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_bytes_in_rate",  smp_fetch_sc_bytes_in_rate,  ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_bytes_out_rate", smp_fetch_sc_bytes_out_rate, ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_clr_gpc0",       smp_fetch_sc_clr_gpc0,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_conn_cnt",       smp_fetch_sc_conn_cnt,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_conn_cur",       smp_fetch_sc_conn_cur,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_conn_rate",      smp_fetch_sc_conn_rate,      ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_get_gpt0",       smp_fetch_sc_get_gpt0,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_get_gpc0",       smp_fetch_sc_get_gpc0,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_gpc0_rate",      smp_fetch_sc_gpc0_rate,      ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_http_err_cnt",   smp_fetch_sc_http_err_cnt,   ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_http_err_rate",  smp_fetch_sc_http_err_rate,  ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_http_req_cnt",   smp_fetch_sc_http_req_cnt,   ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_http_req_rate",  smp_fetch_sc_http_req_rate,  ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_inc_gpc0",       smp_fetch_sc_inc_gpc0,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_kbytes_in",      smp_fetch_sc_kbytes_in,      ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "sc2_kbytes_out",     smp_fetch_sc_kbytes_out,     ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "sc2_sess_cnt",       smp_fetch_sc_sess_cnt,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_sess_rate",      smp_fetch_sc_sess_rate,      ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "sc2_tracked",        smp_fetch_sc_tracked,        ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_BOOL, SMP_USE_INTRN, },
+       { "sc2_trackers",       smp_fetch_sc_trackers,       ARG1(0,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "src_bytes_in_rate",  smp_fetch_sc_bytes_in_rate,  ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_bytes_out_rate", smp_fetch_sc_bytes_out_rate, ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_clr_gpc0",       smp_fetch_sc_clr_gpc0,       ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_conn_cnt",       smp_fetch_sc_conn_cnt,       ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_conn_cur",       smp_fetch_sc_conn_cur,       ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_conn_rate",      smp_fetch_sc_conn_rate,      ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_get_gpt0",       smp_fetch_sc_get_gpt0,       ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_get_gpc0",       smp_fetch_sc_get_gpc0,       ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_gpc0_rate",      smp_fetch_sc_gpc0_rate,      ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_http_err_cnt",   smp_fetch_sc_http_err_cnt,   ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_http_err_rate",  smp_fetch_sc_http_err_rate,  ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_http_req_cnt",   smp_fetch_sc_http_req_cnt,   ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_http_req_rate",  smp_fetch_sc_http_req_rate,  ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_inc_gpc0",       smp_fetch_sc_inc_gpc0,       ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_kbytes_in",      smp_fetch_sc_kbytes_in,      ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_kbytes_out",     smp_fetch_sc_kbytes_out,     ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_sess_cnt",       smp_fetch_sc_sess_cnt,       ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_sess_rate",      smp_fetch_sc_sess_rate,      ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "src_updt_conn_cnt",  smp_fetch_src_updt_conn_cnt, ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_L4CLI, },
+       { "table_avl",          smp_fetch_table_avl,         ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
+       { "table_cnt",          smp_fetch_table_cnt,         ARG1(1,TAB),      
SMP_VAL_ARGS(NULL), SMP_T_SINT, SMP_USE_INTRN, },
        { /* END */ },
 }};
 
 
 /* Note: must not be declared <const> as its list will be overwritten */
 static struct sample_conv_kw_list sample_conv_kws = {ILH, {
-       { "in_table",             sample_conv_in_table,             
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_BOOL  },
-       { "table_bytes_in_rate",  sample_conv_table_bytes_in_rate,  
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_bytes_out_rate", sample_conv_table_bytes_out_rate, 
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_conn_cnt",       sample_conv_table_conn_cnt,       
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_conn_cur",       sample_conv_table_conn_cur,       
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_conn_rate",      sample_conv_table_conn_rate,      
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_gpt0",           sample_conv_table_gpt0,           
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_gpc0",           sample_conv_table_gpc0,           
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_gpc0_rate",      sample_conv_table_gpc0_rate,      
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_http_err_cnt",   sample_conv_table_http_err_cnt,   
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_http_err_rate",  sample_conv_table_http_err_rate,  
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_http_req_cnt",   sample_conv_table_http_req_cnt,   
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_http_req_rate",  sample_conv_table_http_req_rate,  
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_kbytes_in",      sample_conv_table_kbytes_in,      
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_kbytes_out",     sample_conv_table_kbytes_out,     
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_server_id",      sample_conv_table_server_id,      
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_sess_cnt",       sample_conv_table_sess_cnt,       
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_sess_rate",      sample_conv_table_sess_rate,      
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
-       { "table_trackers",       sample_conv_table_trackers,       
ARG1(1,TAB),  NULL, SMP_T_ANY,  SMP_T_SINT  },
+       { "in_table",             sample_conv_in_table,             
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_BOOL  },
+       { "table_bytes_in_rate",  sample_conv_table_bytes_in_rate,  
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_bytes_out_rate", sample_conv_table_bytes_out_rate, 
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_conn_cnt",       sample_conv_table_conn_cnt,       
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_conn_cur",       sample_conv_table_conn_cur,       
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_conn_rate",      sample_conv_table_conn_rate,      
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_gpt0",           sample_conv_table_gpt0,           
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_gpc0",           sample_conv_table_gpc0,           
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_gpc0_rate",      sample_conv_table_gpc0_rate,      
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_http_err_cnt",   sample_conv_table_http_err_cnt,   
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_http_err_rate",  sample_conv_table_http_err_rate,  
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_http_req_cnt",   sample_conv_table_http_req_cnt,   
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_http_req_rate",  sample_conv_table_http_req_rate,  
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_kbytes_in",      sample_conv_table_kbytes_in,      
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_kbytes_out",     sample_conv_table_kbytes_out,     
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_server_id",      sample_conv_table_server_id,      
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_sess_cnt",       sample_conv_table_sess_cnt,       
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_sess_rate",      sample_conv_table_sess_rate,      
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
+       { "table_trackers",       sample_conv_table_trackers,       
ARG1(1,TAB),  SMP_VAL_ARGS(NULL), SMP_T_ANY,  SMP_T_SINT  },
        { /* END */ },
 }};
 
diff --git a/src/vars.c b/src/vars.c
index 566ead6ec..fab83c5d2 100644
--- a/src/vars.c
+++ b/src/vars.c
@@ -846,14 +846,13 @@ static int vars_max_size_reqres(char **args, int 
section_type, struct proxy *cur
 }
 
 static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, {
-
-       { "var", smp_fetch_var, ARG1(1,STR), smp_check_var, SMP_T_STR, 
SMP_USE_L4CLI },
+       { "var", smp_fetch_var, ARG1(1,STR), SMP_VAL_ARGS(smp_check_var), 
SMP_T_STR, SMP_USE_L4CLI },
        { /* END */ },
 }};
 
 static struct sample_conv_kw_list sample_conv_kws = {ILH, {
-       { "set-var",   smp_conv_store, ARG1(1,STR), conv_check_var, SMP_T_ANY, 
SMP_T_ANY },
-       { "unset-var", smp_conv_clear, ARG1(1,STR), conv_check_var, SMP_T_ANY, 
SMP_T_ANY },
+       { "set-var",   smp_conv_store, ARG1(1,STR), 
SMP_VAL_ARGS(conv_check_var),  SMP_T_ANY, SMP_T_ANY },
+       { "unset-var", smp_conv_clear, ARG1(1,STR), 
SMP_VAL_ARGS(conv_check_var),  SMP_T_ANY, SMP_T_ANY },
        { /* END */ },
 }};
 
diff --git a/src/wurfl.c b/src/wurfl.c
index 591fbdba3..d11365802 100644
--- a/src/wurfl.c
+++ b/src/wurfl.c
@@ -670,8 +670,8 @@ static struct cfg_kw_list wurflcfg_kws = {{ }, {
 
 /* Note: must not be declared <const> as its list will be overwritten */
 static struct sample_fetch_kw_list fetch_kws = {ILH, {
-               { "wurfl-get-all", ha_wurfl_get_all, 0, NULL, SMP_T_STR, 
SMP_USE_HRQHV },
-               { "wurfl-get", ha_wurfl_get, 
ARG12(1,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR), NULL, SMP_T_STR, 
SMP_USE_HRQHV },
+               { "wurfl-get-all", ha_wurfl_get_all, 0, SMP_VAL_ARGS(NULL),  
SMP_T_STR, SMP_USE_HRQHV },
+               { "wurfl-get", ha_wurfl_get, 
ARG12(1,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR,STR), SMP_VAL_ARGS(NULL),  
SMP_T_STR, SMP_USE_HRQHV },
                { NULL, NULL, 0, 0, 0 },
        }
 };
-- 
2.18.0


Reply via email to