MINOR: session: rename sample fetch functions and declare the sample keywords

The following sample fetch functions were only usable by ACLs but are now
usable by sample fetches too :

  sc1_bytes_in_rate, sc1_bytes_out_rate, sc1_clr_gpc0, sc1_conn_cnt,
  sc1_conn_cur, sc1_conn_rate, sc1_get_gpc0, sc1_http_err_cnt,
  sc1_http_err_rate, sc1_http_req_cnt, sc1_http_req_rate, sc1_inc_gpc0,
  sc1_kbytes_in, sc1_kbytes_out, sc1_sess_cnt, sc1_sess_rate, sc1_trackers,
  sc2_bytes_in_rate, sc2_bytes_out_rate, sc2_clr_gpc0, sc2_conn_cnt,
  sc2_conn_cur, sc2_conn_rate, sc2_get_gpc0, sc2_http_err_cnt,
  sc2_http_err_rate, sc2_http_req_cnt, sc2_http_req_rate, sc2_inc_gpc0,
  sc2_kbytes_in, sc2_kbytes_out, sc2_sess_cnt, sc2_sess_rate, sc2_trackers,
  src_bytes_in_rate, src_bytes_out_rate, src_clr_gpc0, src_conn_cnt,
  src_conn_cur, src_conn_rate, src_get_gpc0, src_http_err_cnt,
  src_http_err_rate, src_http_req_cnt, src_http_req_rate, src_inc_gpc0,
  src_kbytes_in, src_kbytes_out, src_sess_cnt, src_sess_rate,
  src_updt_conn_cnt, table_avl, table_cnt,

The fetch functions have been renamed "smp_fetch_*".

diff --git a/doc/configuration.txt b/doc/configuration.txt
index 8183daad6037984fa7772208e35954bbcc5544d5..d15df49071e2d643da620439f2c364ef3a82f011 100644 (file)
--- a/doc/configuration.txt
+++ b/doc/configuration.txt
@@ -9855,6 +9855,127 @@ The list of currently supported pattern fetch functions is the following :
   resp_ver     Returns the version string from the HTTP response, for example
                "1.1". This can be useful for logs, but is mostly there for ACL.
 
+  sc1_bytes_in_rate
+  sc2_bytes_in_rate
+               Returns the average client-to-server bytes rate from the
+               currently tracked counters, measured in amount of bytes over the
+               period configured in the table. See also src_bytes_in_rate.
+
+  sc1_bytes_out_rate
+  sc2_bytes_out_rate
+               Returns the average server-to-client bytes rate from the
+               currently tracked counters, measured in amount of bytes over the
+               period configured in the table. See also src_bytes_out_rate.
+
+  sc1_clr_gpc0
+  sc2_clr_gpc0
+               Clears the first General Purpose Counter associated to the
+               currently tracked counters, and returns its previous value.
+               This is only useful when used by ACLs.
+
+  sc1_conn_cnt
+  sc2_conn_cnt
+               Returns the cumulated number of incoming connections from
+               currently tracked counters. See also src_conn_cnt.
+
+  sc1_conn_cur
+  sc2_conn_cur
+               Returns the current amount of concurrent connections tracking
+               the same tracked counters. This number is automatically
+               incremented when tracking begins and decremented when tracking
+               stops. See also src_conn_cur.
+
+  sc1_conn_rate
+  sc2_conn_rate
+               Returns the average connection rate from the currently tracked
+               counters, measured in amount of connections over the period
+               configured in the table. See also src_conn_rate.
+
+  sc1_get_gpc0
+  sc2_get_gpc0
+               Returns the value of the first General Purpose Counter
+               associated to the currently tracked counters. See also
+               src_get_gpc0 and sc1/sc2_inc_gpc0.
+
+  sc1_http_err_cnt
+  sc2_http_err_cnt
+               Returns the cumulated number of HTTP errors from the currently
+               tracked counters. This includes the both request errors and 4xx
+               error responses. See also src_http_err_cnt.
+
+  sc1_http_err_rate
+  sc2_http_err_rate
+               Returns the average rate of HTTP errors from the currently
+               tracked counters, measured in amount of errors over the period
+               configured in the table. This includes the both request errors
+               and 4xx error responses. See also src_http_err_rate.
+
+  sc1_http_req_cnt
+  sc2_http_req_cnt
+               Returns the cumulated number of HTTP requests from the currently
+               tracked counters. This includes every started request, valid or
+               not. See also src_http_req_cnt.
+
+  sc1_http_req_rate
+  sc2_http_req_rate
+               Returns the average rate of HTTP requests from the currently
+               tracked counters, measured in amount of requests over the period
+               configured in the table. This includes every started request,
+               valid or not. See also src_http_req_rate.
+
+  sc1_inc_gpc0
+  sc2_inc_gpc0
+               Increments the first General Purpose Counter associated to the
+               currently tracked counters, and returns its new value. This is
+               only useful when used by ACLs.
+
+  sc1_kbytes_in
+  sc2_kbytes_in
+               Returns the amount of client-to-server data from the currently
+               tracked counters, measured in kilobytes over the period
+               configured in the table. The value being stored as a 32-bit
+               integer, it wraps at 4 terabytes. See also src_kbytes_in.
+
+  sc1_kbytes_out
+  sc2_kbytes_out
+               Returns the amount of server-to-client data from the currently
+               tracked counters, measured in kilobytes over the period
+               configured in the table. The value being stored as a 32-bit
+               integer, it wraps at 4 terabytes. See also src_kbytes_out.
+
+  sc1_sess_cnt
+  sc2_sess_cnt
+               Returns the cumulated number of incoming connections that were
+               transformed into sessions, which means that they were accepted
+               by a "tcp-request connection" rule, from the currently tracked
+               counters. A backend may count more sessions than connections
+               because each connection could result in many backend sessions if
+               some HTTP keep-alive is performed over the connection with the
+               client. See also src_sess_cnt.
+
+  sc1_sess_rate
+  sc2_sess_rate
+               Returns the average session rate from the currently tracked
+               counters, measured in amount of sessions over the period
+               configured in the table. A session is a connection that got past
+               the early "tcp-request connection" rules. A backend may count
+               more sessions than connections because each connection could
+               result in many backend sessions if some HTTP keep-alive is
+               performed over the connection with the client. See also
+               src_sess_rate.
+
+  sc1_trackers
+  sc2_trackers
+               Returns the current amount of concurrent connections tracking
+               the same tracked counters. This number is automatically
+               incremented when tracking begins and decremented when tracking
+               stops. It differs from sc1_conn_cur in that it does not rely on
+               any stored information but on the table's reference count (the
+               "use" value which is returned by "show table" on the CLI). This
+               may sometimes be more suited for layer7 tracking. It can be used
+               to tell a server how many concurrent connections there are from
+               a given address for example.
+
   scook([<name>])
                This extracts the last occurrence of the cookie name <name> on a
                "Set-Cookie" header line from the response, and returns its
@@ -9925,11 +10046,132 @@ The list of currently supported pattern fetch functions is the following :
                On IPv6 tables, IPv4 address is mapped to its IPv6 equivalent,
                according to RFC 4291.
 
+  src_bytes_in_rate([<table>])
+               Returns the average bytes rate from the connection's source IPv4
+               address in the current proxy's stick-table or in the designated
+               stick-table, measured in amount of bytes over the period
+               configured in the table. If the address is not found, zero is
+               returned. See also sc1/sc2_bytes_in_rate.
+
+  src_bytes_out_rate([<table>])
+               Returns the average bytes rate to the connection's source IPv4
+               address in the current proxy's stick-table or in the designated
+               stick-table, measured in amount of bytes over the period
+               configured in the table. If the address is not found, zero is
+               returned. See also sc1/sc2_bytes_out_rate.
+
+  src_clr_gpc0([<table>])
+               Clears the first General Purpose Counter associated to the
+               connection's source IPv4 address in the current proxy's
+               stick-table or in the designated stick-table, and returns its
+               previous value. This is only useful when used by ACLs.
+
+  src_conn_cnt([<table>])
+               Returns the cumulated number of connections initiated from the
+               current connection's source IPv4 address in the current proxy's
+               stick-table or in the designated stick-table. If the address is
+               not found, zero is returned. See also sc1/sc2_conn_cnt.
+
+  src_conn_cur([<table>])
+               Returns the current amount of concurrent connections initiated
+               from the current connection's source IPv4 address in the current
+               proxy's stick-table or in the designated stick-table. If the
+               address is not found, zero is returned. See also
+               sc1/sc2_conn_cur.
+
+  src_conn_rate([<table>])
+               Returns the average connection rate from the connection's source
+               IPv4 address in the current proxy's stick-table or in the
+               designated stick-table, measured in amount of connections over
+               the period configured in the table. If the address is not found,
+               zero is returned. See also sc1/sc2_conn_rate.
+
+  src_get_gpc0([<table>])
+               Returns the value of the first General Purpose Counter
+               associated to the connection's source IPv4 address in the
+               current proxy's stick-table or in the designated stick-table. If
+               the address is not found, zero is returned.  See also
+               sc1/sc2_get_gpc0 and src_inc_gpc0.
+
+  src_http_err_cnt([<table>])
+               Returns the cumulated number of HTTP errors from the current
+               connection's source IPv4 address in the current proxy's
+               stick-table or in the designated stick-table. This includes the
+               both request errors and 4xx error responses. If the address is
+               not found, zero is returned. See also sc1/sc2_http_err_cnt.
+
+  src_http_err_rate([<table>])
+               Returns the average rate of HTTP errors from the current
+               connection's source IPv4 address in the current proxy's
+               stick-table or in the designated stick- table, measured in
+               amount of errors over the period configured in the table.  This
+               includes the both request errors and 4xx error responses. If the
+               address is not found, zero is returned. See also
+               sc1/sc2_http_err_rate.
+
+  src_http_req_cnt([<table>])
+               Returns the cumulated number of HTTP requests from the current
+               connection's source IPv4 address in the current proxy's
+               stick-table or in the designated stick-table. This includes
+               every started request, valid or not. If the address is not
+               found, zero is returned. See also sc1/sc2_http_req_cnt.
+
+  src_http_req_rate([<table>])
+               Returns the average rate of HTTP requests from the current
+               connection's source IPv4 address in the current proxy's
+               stick-table or in the designated stick-table, measured in amount
+               of requests over the period configured in the table. This
+               includes every started request, valid or not. If the address is
+               not found, zero is returned. See also sc1/sc2_http_req_rate.
+
+  src_inc_gpc0([<table>])
+               Increments the first General Purpose Counter associated to the
+               connection's source IPv4 address in the current proxy's
+               stick-table or in the designated stick-table, and returns its
+               new value. This is only useful when used by ACLs.
+
+  src_kbytes_in([<table>])
+               Returns the amount of data received from the connection's source
+               IPv4 address in the current proxy's stick-table or in the
+               designated stick-table, measured in kilobytes over the period
+               configured in the table. If the address is not found, zero is
+               returned. The value being stored as a 32-bit integer, it wraps
+               at 4 terabytes. See also sc1/sc2_kbytes_in.
+
+  src_kbytes_out([<table>])
+               Returns the amount of data sent to the connection's source IPv4
+               address in the current proxy's stick-table or in the designated
+               stick-table, measured in kilobytes over the period configured in
+               the table. If the address is not found, zero is returned. The
+               value being stored as a 32-bit integer, it wraps at 4 terabytes.
+               See also sc1/sc2_kbytes_out.
+
   src_port     This is the source TCP port of the session on the client side,
                which is the port the client connected from. It is very unlikely
                that this function will be useful but it's available at no cost.
                It is of type integer and only works with such tables.
 
+  src_sess_cnt([<table>])
+               Returns the cumulated number of connections initiated from the
+               current connection's source IPv4 address in the current proxy's
+               stick-table or in the designated stick-table, that were
+               transformed into sessions, which means that they were accepted
+               by "tcp-request" rules. If the address is not found, zero is
+               returned. See also sc1/sc2_sess_cnt.
+
+  src_sess_rate([<table>])
+               Returns the average session rate from the connection's source
+               IPv4 address in the current proxy's stick-table or in the
+               designated stick-table, measured in amount of sessions over the
+               period configured in the table. A session is a connection that
+               got past the early "tcp-request" rules. If the address is not
+               found, zero is returned. See also sc1/sc2_sess_rate.
+
+  src_updt_conn_cnt([<table>])
+               Creates or updates the entry associated to the source IPv4
+               address in the current proxy's stick-table or in the designated
+               stick-table. This is only useful when used by ACLs.
+
   srv_conn(<backend>/<server>)
                Returns an integer value corresponding to the number of
                currently established connections on this server, possibly
@@ -10133,6 +10375,17 @@ The list of currently supported pattern fetch functions is the following :
   status       Returns an integer containing the HTTP status code in the HTTP
                response, for example, 302. It is mostly used within ACLs.
 
+  table_avl([<table>])
+               Returns the total number of available entries in the current
+               proxy's stick-table or in the designated stick-table. See also
+               table_cnt.
+
+  table_cnt([<table>])
+               Returns the total number of entries currently in use in the
+               current proxy's stick-table or in the designated stick-table.
+               See also src_conn_cnt and table_avl for other entry counting
+               methods.
+
   url          This extracts the request's URL as presented in the request. A
                typical use is with prefetch-capable caches, and with portals
                which need to aggregate multiple information from databases and

diff --git a/src/session.c b/src/session.c
index fbb130bad10bd6ef0983e708c318e199c8454e7b..4b8a116d3898299eb117c5c53fefcef63bf147d6 100644 (file)
--- a/src/session.c
+++ b/src/session.c
@@ -2578,7 +2578,7 @@ void session_shutdown(struct session *session, int why)
 
 /* set temp integer to the General Purpose Counter 0 value in the stksess entry <ts> */
 static int
-acl_fetch_get_gpc0(struct stktable *table, struct sample *smp, struct stksess *ts)
+smp_fetch_get_gpc0(struct stktable *table, struct sample *smp, struct stksess *ts)
 {
        smp->flags = SMP_F_VOL_TEST;
        smp->type = SMP_T_UINT;
@@ -2596,24 +2596,24 @@ acl_fetch_get_gpc0(struct stktable *table, struct sample *smp, struct stksess *t
  * frontend counters.
  */
 static int
-acl_fetch_sc1_get_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_get_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
                return 0;
-       return acl_fetch_get_gpc0(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
+       return smp_fetch_get_gpc0(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
 }
 
 /* set temp integer to the General Purpose Counter 0 value from the session's tracked
  * backend counters.
  */
 static int
-acl_fetch_sc2_get_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_get_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
                return 0;
-       return acl_fetch_get_gpc0(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
+       return smp_fetch_get_gpc0(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
 }
 
 /* set temp integer to the General Purpose Counter 0 value from the session's source
@@ -2621,7 +2621,7 @@ acl_fetch_sc2_get_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_get_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_get_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        struct stktable_key *key;
@@ -2631,14 +2631,14 @@ acl_fetch_src_get_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned
                return 0;
 
        px = args->data.prx;
-       return acl_fetch_get_gpc0(&px->table, smp, stktable_lookup_key(&px->table, key));
+       return smp_fetch_get_gpc0(&px->table, smp, stktable_lookup_key(&px->table, key));
 }
 
 /* Increment the General Purpose Counter 0 value in the stksess entry <ts> and
  * return it into temp integer.
  */
 static int
-acl_fetch_inc_gpc0(struct stktable *table, struct sample *smp, struct stksess *ts)
+smp_fetch_inc_gpc0(struct stktable *table, struct sample *smp, struct stksess *ts)
 {
        smp->flags = SMP_F_VOL_TEST;
        smp->type = SMP_T_UINT;
@@ -2656,24 +2656,24 @@ acl_fetch_inc_gpc0(struct stktable *table, struct sample *smp, struct stksess *t
  * frontend counters and return it into temp integer.
  */
 static int
-acl_fetch_sc1_inc_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_inc_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
                return 0;
-       return acl_fetch_inc_gpc0(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
+       return smp_fetch_inc_gpc0(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
 }
 
 /* Increment the General Purpose Counter 0 value from the session's tracked
  * backend counters and return it into temp integer.
  */
 static int
-acl_fetch_sc2_inc_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_inc_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
                return 0;
-       return acl_fetch_inc_gpc0(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
+       return smp_fetch_inc_gpc0(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
 }
 
 /* Increment the General Purpose Counter 0 value from the session's source
@@ -2681,7 +2681,7 @@ acl_fetch_sc2_inc_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_inc_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_inc_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        struct stktable_key *key;
@@ -2691,14 +2691,14 @@ acl_fetch_src_inc_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned
                return 0;
 
        px = args->data.prx;
-       return acl_fetch_inc_gpc0(&px->table, smp, stktable_update_key(&px->table, key));
+       return smp_fetch_inc_gpc0(&px->table, smp, stktable_update_key(&px->table, key));
 }
 
 /* Clear the General Purpose Counter 0 value in the stksess entry <ts> and
  * return its previous value into temp integer.
  */
 static int
-acl_fetch_clr_gpc0(struct stktable *table, struct sample *smp, struct stksess *ts)
+smp_fetch_clr_gpc0(struct stktable *table, struct sample *smp, struct stksess *ts)
 {
        smp->flags = SMP_F_VOL_TEST;
        smp->type = SMP_T_UINT;
@@ -2717,24 +2717,24 @@ acl_fetch_clr_gpc0(struct stktable *table, struct sample *smp, struct stksess *t
  * frontend counters and return its previous value into temp integer.
  */
 static int
-acl_fetch_sc1_clr_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_clr_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
                return 0;
-       return acl_fetch_clr_gpc0(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
+       return smp_fetch_clr_gpc0(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
 }
 
 /* Clear the General Purpose Counter 0 value from the session's tracked
  * backend counters and return its previous value into temp integer.
  */
 static int
-acl_fetch_sc2_clr_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_clr_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
                return 0;
-       return acl_fetch_clr_gpc0(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
+       return smp_fetch_clr_gpc0(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
 }
 
 /* Clear the General Purpose Counter 0 value from the session's source address
@@ -2742,7 +2742,7 @@ acl_fetch_sc2_clr_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_clr_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_clr_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        struct stktable_key *key;
@@ -2752,12 +2752,12 @@ acl_fetch_src_clr_gpc0(struct proxy *px, struct session *l4, void *l7, unsigned
                return 0;
 
        px = args->data.prx;
-       return acl_fetch_clr_gpc0(&px->table, smp, stktable_update_key(&px->table, key));
+       return smp_fetch_clr_gpc0(&px->table, smp, stktable_update_key(&px->table, key));
 }
 
 /* set temp integer to the cumulated number of connections in the stksess entry <ts> */
 static int
-acl_fetch_conn_cnt(struct stktable *table, struct sample *smp, struct stksess *ts)
+smp_fetch_conn_cnt(struct stktable *table, struct sample *smp, struct stksess *ts)
 {
        smp->flags = SMP_F_VOL_TEST;
        smp->type = SMP_T_UINT;
@@ -2773,24 +2773,24 @@ acl_fetch_conn_cnt(struct stktable *table, struct sample *smp, struct stksess *t
 
 /* set temp integer to the cumulated number of connections from the session's tracked FE counters */
 static int
-acl_fetch_sc1_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
                return 0;
 
-       return acl_fetch_conn_cnt(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
+       return smp_fetch_conn_cnt(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
 }
 
 /* set temp integer to the cumulated number of connections from the session's tracked BE counters */
 static int
-acl_fetch_sc2_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
                return 0;
 
-       return acl_fetch_conn_cnt(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
+       return smp_fetch_conn_cnt(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
 }
 
 /* set temp integer to the cumulated number of connections from the session's source
@@ -2798,7 +2798,7 @@ acl_fetch_sc2_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        struct stktable_key *key;
@@ -2808,12 +2808,12 @@ acl_fetch_src_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned
                return 0;
 
        px = args->data.prx;
-       return acl_fetch_conn_cnt(&px->table, smp, stktable_lookup_key(&px->table, key));
+       return smp_fetch_conn_cnt(&px->table, smp, stktable_lookup_key(&px->table, key));
 }
 
 /* set temp integer to the connection rate in the stksess entry <ts> over the configured period */
 static int
-acl_fetch_conn_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
+smp_fetch_conn_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
 {
        smp->flags = SMP_F_VOL_TEST;
        smp->type = SMP_T_UINT;
@@ -2832,26 +2832,26 @@ acl_fetch_conn_rate(struct stktable *table, struct sample *smp, struct stksess *
  * the configured period.
  */
 static int
-acl_fetch_sc1_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                         const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
                return 0;
 
-       return acl_fetch_conn_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
+       return smp_fetch_conn_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
 }
 
 /* set temp integer to the connection rate from the session's tracked BE counters over
  * the configured period.
  */
 static int
-acl_fetch_sc2_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                         const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
                return 0;
 
-       return acl_fetch_conn_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
+       return smp_fetch_conn_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
 }
 
 /* set temp integer to the connection rate from the session's source address in the
@@ -2859,7 +2859,7 @@ acl_fetch_sc2_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                         const struct arg *args, struct sample *smp)
 {
        struct stktable_key *key;
@@ -2869,7 +2869,7 @@ acl_fetch_src_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned
                return 0;
 
        px = args->data.prx;
-       return acl_fetch_conn_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
+       return smp_fetch_conn_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
 }
 
 /* set temp integer to the number of connections from the session's source address
@@ -2877,7 +2877,7 @@ acl_fetch_src_conn_rate(struct proxy *px, struct session *l4, void *l7, unsigned
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_updt_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_updt_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                             const struct arg *args, struct sample *smp)
 {
        struct stksess *ts;
@@ -2906,7 +2906,7 @@ acl_fetch_src_updt_conn_cnt(struct proxy *px, struct session *l4, void *l7, unsi
 
 /* set temp integer to the number of concurrent connections in the stksess entry <ts> */
 static int
-acl_fetch_conn_cur(struct stktable *table, struct sample *smp, struct stksess *ts)
+smp_fetch_conn_cur(struct stktable *table, struct sample *smp, struct stksess *ts)
 {
        smp->flags = SMP_F_VOL_TEST;
        smp->type = SMP_T_UINT;
@@ -2923,24 +2923,24 @@ acl_fetch_conn_cur(struct stktable *table, struct sample *smp, struct stksess *t
 
 /* set temp integer to the number of concurrent connections from the session's tracked FE counters */
 static int
-acl_fetch_sc1_conn_cur(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_conn_cur(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
                return 0;
 
-       return acl_fetch_conn_cur(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
+       return smp_fetch_conn_cur(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
 }
 
 /* set temp integer to the number of concurrent connections from the session's tracked BE counters */
 static int
-acl_fetch_sc2_conn_cur(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_conn_cur(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
                return 0;
 
-       return acl_fetch_conn_cur(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
+       return smp_fetch_conn_cur(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
 }
 
 /* set temp integer to the number of concurrent connections from the session's source
@@ -2948,7 +2948,7 @@ acl_fetch_sc2_conn_cur(struct proxy *px, struct session *l4, void *l7, unsigned
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_conn_cur(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_conn_cur(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        struct stktable_key *key;
@@ -2958,12 +2958,12 @@ acl_fetch_src_conn_cur(struct proxy *px, struct session *l4, void *l7, unsigned
                return 0;
 
        px = args->data.prx;
-       return acl_fetch_conn_cur(&px->table, smp, stktable_lookup_key(&px->table, key));
+       return smp_fetch_conn_cur(&px->table, smp, stktable_lookup_key(&px->table, key));
 }
 
 /* set temp integer to the cumulated number of sessions in the stksess entry <ts> */
 static int
-acl_fetch_sess_cnt(struct stktable *table, struct sample *smp, struct stksess *ts)
+smp_fetch_sess_cnt(struct stktable *table, struct sample *smp, struct stksess *ts)
 {
        smp->flags = SMP_F_VOL_TEST;
        smp->type = SMP_T_UINT;
@@ -2979,24 +2979,24 @@ acl_fetch_sess_cnt(struct stktable *table, struct sample *smp, struct stksess *t
 
 /* set temp integer to the cumulated number of sessions from the session's tracked FE counters */
 static int
-acl_fetch_sc1_sess_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_sess_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
                return 0;
 
-       return acl_fetch_sess_cnt(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
+       return smp_fetch_sess_cnt(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
 }
 
 /* set temp integer to the cumulated number of sessions from the session's tracked BE counters */
 static int
-acl_fetch_sc2_sess_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_sess_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
                return 0;
 
-       return acl_fetch_sess_cnt(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
+       return smp_fetch_sess_cnt(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
 }
 
 /* set temp integer to the cumulated number of session from the session's source
@@ -3004,7 +3004,7 @@ acl_fetch_sc2_sess_cnt(struct proxy *px, struct session *l4, void *l7, unsigned
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_sess_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_sess_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        struct stktable_key *key;
@@ -3014,12 +3014,12 @@ acl_fetch_src_sess_cnt(struct proxy *px, struct session *l4, void *l7, unsigned
                return 0;
 
        px = args->data.prx;
-       return acl_fetch_sess_cnt(&px->table, smp, stktable_lookup_key(&px->table, key));
+       return smp_fetch_sess_cnt(&px->table, smp, stktable_lookup_key(&px->table, key));
 }
 
 /* set temp integer to the session rate in the stksess entry <ts> over the configured period */
 static int
-acl_fetch_sess_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
+smp_fetch_sess_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
 {
        smp->flags = SMP_F_VOL_TEST;
        smp->type = SMP_T_UINT;
@@ -3038,26 +3038,26 @@ acl_fetch_sess_rate(struct stktable *table, struct sample *smp, struct stksess *
  * the configured period.
  */
 static int
-acl_fetch_sc1_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                         const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
                return 0;
 
-       return acl_fetch_sess_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
+       return smp_fetch_sess_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
 }
 
 /* set temp integer to the session rate from the session's tracked BE counters over
  * the configured period.
  */
 static int
-acl_fetch_sc2_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                         const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
                return 0;
 
-       return acl_fetch_sess_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
+       return smp_fetch_sess_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
 }
 
 /* set temp integer to the session rate from the session's source address in the
@@ -3065,7 +3065,7 @@ acl_fetch_sc2_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                         const struct arg *args, struct sample *smp)
 {
        struct stktable_key *key;
@@ -3075,12 +3075,12 @@ acl_fetch_src_sess_rate(struct proxy *px, struct session *l4, void *l7, unsigned
                return 0;
 
        px = args->data.prx;
-       return acl_fetch_sess_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
+       return smp_fetch_sess_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
 }
 
 /* set temp integer to the cumulated number of sessions in the stksess entry <ts> */
 static int
-acl_fetch_http_req_cnt(struct stktable *table, struct sample *smp, struct stksess *ts)
+smp_fetch_http_req_cnt(struct stktable *table, struct sample *smp, struct stksess *ts)
 {
        smp->flags = SMP_F_VOL_TEST;
        smp->type = SMP_T_UINT;
@@ -3096,24 +3096,24 @@ acl_fetch_http_req_cnt(struct stktable *table, struct sample *smp, struct stkses
 
 /* set temp integer to the cumulated number of sessions from the session's tracked FE counters */
 static int
-acl_fetch_sc1_http_req_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_http_req_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                            const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
                return 0;
 
-       return acl_fetch_http_req_cnt(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
+       return smp_fetch_http_req_cnt(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
 }
 
 /* set temp integer to the cumulated number of sessions from the session's tracked BE counters */
 static int
-acl_fetch_sc2_http_req_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_http_req_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                            const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
                return 0;
 
-       return acl_fetch_http_req_cnt(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
+       return smp_fetch_http_req_cnt(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
 }
 
 /* set temp integer to the cumulated number of session from the session's source
@@ -3121,7 +3121,7 @@ acl_fetch_sc2_http_req_cnt(struct proxy *px, struct session *l4, void *l7, unsig
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_http_req_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_http_req_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                            const struct arg *args, struct sample *smp)
 {
        struct stktable_key *key;
@@ -3131,12 +3131,12 @@ acl_fetch_src_http_req_cnt(struct proxy *px, struct session *l4, void *l7, unsig
                return 0;
 
        px = args->data.prx;
-       return acl_fetch_http_req_cnt(&px->table, smp, stktable_lookup_key(&px->table, key));
+       return smp_fetch_http_req_cnt(&px->table, smp, stktable_lookup_key(&px->table, key));
 }
 
 /* set temp integer to the session rate in the stksess entry <ts> over the configured period */
 static int
-acl_fetch_http_req_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
+smp_fetch_http_req_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
 {
        smp->flags = SMP_F_VOL_TEST;
        smp->type = SMP_T_UINT;
@@ -3155,26 +3155,26 @@ acl_fetch_http_req_rate(struct stktable *table, struct sample *smp, struct stkse
  * the configured period.
  */
 static int
-acl_fetch_sc1_http_req_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_http_req_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                             const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
                return 0;
 
-       return acl_fetch_http_req_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
+       return smp_fetch_http_req_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
 }
 
 /* set temp integer to the session rate from the session's tracked BE counters over
  * the configured period.
  */
 static int
-acl_fetch_sc2_http_req_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_http_req_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                             const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
                return 0;
 
-       return acl_fetch_http_req_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
+       return smp_fetch_http_req_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
 }
 
 /* set temp integer to the session rate from the session's source address in the
@@ -3182,7 +3182,7 @@ acl_fetch_sc2_http_req_rate(struct proxy *px, struct session *l4, void *l7, unsi
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_http_req_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_http_req_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                             const struct arg *args, struct sample *smp)
 {
        struct stktable_key *key;
@@ -3192,12 +3192,12 @@ acl_fetch_src_http_req_rate(struct proxy *px, struct session *l4, void *l7, unsi
                return 0;
 
        px = args->data.prx;
-       return acl_fetch_http_req_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
+       return smp_fetch_http_req_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
 }
 
 /* set temp integer to the cumulated number of sessions in the stksess entry <ts> */
 static int
-acl_fetch_http_err_cnt(struct stktable *table, struct sample *smp, struct stksess *ts)
+smp_fetch_http_err_cnt(struct stktable *table, struct sample *smp, struct stksess *ts)
 {
        smp->flags = SMP_F_VOL_TEST;
        smp->type = SMP_T_UINT;
@@ -3213,24 +3213,24 @@ acl_fetch_http_err_cnt(struct stktable *table, struct sample *smp, struct stkses
 
 /* set temp integer to the cumulated number of sessions from the session's tracked FE counters */
 static int
-acl_fetch_sc1_http_err_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_http_err_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                            const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
                return 0;
 
-       return acl_fetch_http_err_cnt(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
+       return smp_fetch_http_err_cnt(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
 }
 
 /* set temp integer to the cumulated number of sessions from the session's tracked BE counters */
 static int
-acl_fetch_sc2_http_err_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_http_err_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                            const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
                return 0;
 
-       return acl_fetch_http_err_cnt(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
+       return smp_fetch_http_err_cnt(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
 }
 
 /* set temp integer to the cumulated number of session from the session's source
@@ -3238,7 +3238,7 @@ acl_fetch_sc2_http_err_cnt(struct proxy *px, struct session *l4, void *l7, unsig
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_http_err_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_http_err_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                            const struct arg *args, struct sample *smp)
 {
        struct stktable_key *key;
@@ -3248,12 +3248,12 @@ acl_fetch_src_http_err_cnt(struct proxy *px, struct session *l4, void *l7, unsig
                return 0;
 
        px = args->data.prx;
-       return acl_fetch_http_err_cnt(&px->table, smp, stktable_lookup_key(&px->table, key));
+       return smp_fetch_http_err_cnt(&px->table, smp, stktable_lookup_key(&px->table, key));
 }
 
 /* set temp integer to the session rate in the stksess entry <ts> over the configured period */
 static int
-acl_fetch_http_err_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
+smp_fetch_http_err_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
 {
        smp->flags = SMP_F_VOL_TEST;
        smp->type = SMP_T_UINT;
@@ -3272,26 +3272,26 @@ acl_fetch_http_err_rate(struct stktable *table, struct sample *smp, struct stkse
  * the configured period.
  */
 static int
-acl_fetch_sc1_http_err_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_http_err_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                             const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
                return 0;
 
-       return acl_fetch_http_err_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
+       return smp_fetch_http_err_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
 }
 
 /* set temp integer to the session rate from the session's tracked BE counters over
  * the configured period.
  */
 static int
-acl_fetch_sc2_http_err_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_http_err_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                             const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
                return 0;
 
-       return acl_fetch_http_err_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
+       return smp_fetch_http_err_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
 }
 
 /* set temp integer to the session rate from the session's source address in the
@@ -3299,7 +3299,7 @@ acl_fetch_sc2_http_err_rate(struct proxy *px, struct session *l4, void *l7, unsi
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_http_err_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_http_err_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                             const struct arg *args, struct sample *smp)
 {
        struct stktable_key *key;
@@ -3309,12 +3309,12 @@ acl_fetch_src_http_err_rate(struct proxy *px, struct session *l4, void *l7, unsi
                return 0;
 
        px = args->data.prx;
-       return acl_fetch_http_err_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
+       return smp_fetch_http_err_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
 }
 
 /* set temp integer to the number of kbytes received from clients matching the stksess entry <ts> */
 static int
-acl_fetch_kbytes_in(struct stktable *table, struct sample *smp, struct stksess *ts)
+smp_fetch_kbytes_in(struct stktable *table, struct sample *smp, struct stksess *ts)
 {
        smp->flags = SMP_F_VOL_TEST;
        smp->type = SMP_T_UINT;
@@ -3333,26 +3333,26 @@ acl_fetch_kbytes_in(struct stktable *table, struct sample *smp, struct stksess *
  * session's tracked FE counters.
  */
 static int
-acl_fetch_sc1_kbytes_in(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_kbytes_in(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                         const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
                return 0;
 
-       return acl_fetch_kbytes_in(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
+       return smp_fetch_kbytes_in(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
 }
 
 /* set temp integer to the number of kbytes received from clients according to the
  * session's tracked BE counters.
  */
 static int
-acl_fetch_sc2_kbytes_in(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_kbytes_in(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                         const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
                return 0;
 
-       return acl_fetch_kbytes_in(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
+       return smp_fetch_kbytes_in(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
 }
 
 /* set temp integer to the number of kbytes received from the session's source
@@ -3360,7 +3360,7 @@ acl_fetch_sc2_kbytes_in(struct proxy *px, struct session *l4, void *l7, unsigned
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_kbytes_in(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_kbytes_in(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        struct stktable_key *key;
@@ -3370,14 +3370,14 @@ acl_fetch_src_kbytes_in(struct proxy *px, struct session *l4, void *l7, unsigned
                return 0;
 
        px = args->data.prx;
-       return acl_fetch_kbytes_in(&px->table, smp, stktable_lookup_key(&px->table, key));
+       return smp_fetch_kbytes_in(&px->table, smp, stktable_lookup_key(&px->table, key));
 }
 
 /* set temp integer to the bytes rate from clients in the stksess entry <ts> over the
  * configured period.
  */
 static int
-acl_fetch_bytes_in_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
+smp_fetch_bytes_in_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
 {
        smp->flags = SMP_F_VOL_TEST;
        smp->type = SMP_T_UINT;
@@ -3396,26 +3396,26 @@ acl_fetch_bytes_in_rate(struct stktable *table, struct sample *smp, struct stkse
  * counters over the configured period.
  */
 static int
-acl_fetch_sc1_bytes_in_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_bytes_in_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                             const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
                return 0;
 
-       return acl_fetch_bytes_in_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
+       return smp_fetch_bytes_in_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
 }
 
 /* set temp integer to the bytes rate from clients from the session's tracked BE
  * counters over the configured period.
  */
 static int
-acl_fetch_sc2_bytes_in_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_bytes_in_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                             const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
                return 0;
 
-       return acl_fetch_bytes_in_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
+       return smp_fetch_bytes_in_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
 }
 
 /* set temp integer to the bytes rate from clients from the session's source address
@@ -3423,7 +3423,7 @@ acl_fetch_sc2_bytes_in_rate(struct proxy *px, struct session *l4, void *l7, unsi
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_bytes_in_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_bytes_in_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                             const struct arg *args, struct sample *smp)
 {
        struct stktable_key *key;
@@ -3433,12 +3433,12 @@ acl_fetch_src_bytes_in_rate(struct proxy *px, struct session *l4, void *l7, unsi
                return 0;
 
        px = args->data.prx;
-       return acl_fetch_bytes_in_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
+       return smp_fetch_bytes_in_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
 }
 
 /* set temp integer to the number of kbytes sent to clients matching the stksess entry <ts> */
 static int
-acl_fetch_kbytes_out(struct stktable *table, struct sample *smp, struct stksess *ts)
+smp_fetch_kbytes_out(struct stktable *table, struct sample *smp, struct stksess *ts)
 {
        smp->flags = SMP_F_VOL_TEST;
        smp->type = SMP_T_UINT;
@@ -3457,26 +3457,26 @@ acl_fetch_kbytes_out(struct stktable *table, struct sample *smp, struct stksess
  * tracked FE counters.
  */
 static int
-acl_fetch_sc1_kbytes_out(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_kbytes_out(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                          const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
                return 0;
 
-       return acl_fetch_kbytes_out(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
+       return smp_fetch_kbytes_out(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
 }
 
 /* set temp integer to the number of kbytes sent to clients according to the session's
  * tracked BE counters.
  */
 static int
-acl_fetch_sc2_kbytes_out(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_kbytes_out(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                          const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
                return 0;
 
-       return acl_fetch_kbytes_out(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
+       return smp_fetch_kbytes_out(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
 }
 
 /* set temp integer to the number of kbytes sent to the session's source address in
@@ -3484,7 +3484,7 @@ acl_fetch_sc2_kbytes_out(struct proxy *px, struct session *l4, void *l7, unsigne
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_kbytes_out(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_kbytes_out(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                          const struct arg *args, struct sample *smp)
 {
        struct stktable_key *key;
@@ -3494,14 +3494,14 @@ acl_fetch_src_kbytes_out(struct proxy *px, struct session *l4, void *l7, unsigne
                return 0;
 
        px = args->data.prx;
-       return acl_fetch_kbytes_out(&px->table, smp, stktable_lookup_key(&px->table, key));
+       return smp_fetch_kbytes_out(&px->table, smp, stktable_lookup_key(&px->table, key));
 }
 
 /* set temp integer to the bytes rate to clients in the stksess entry <ts> over the
  * configured period.
  */
 static int
-acl_fetch_bytes_out_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
+smp_fetch_bytes_out_rate(struct stktable *table, struct sample *smp, struct stksess *ts)
 {
        smp->flags = SMP_F_VOL_TEST;
        smp->type = SMP_T_UINT;
@@ -3520,26 +3520,26 @@ acl_fetch_bytes_out_rate(struct stktable *table, struct sample *smp, struct stks
  * over the configured period.
  */
 static int
-acl_fetch_sc1_bytes_out_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_bytes_out_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                              const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
                return 0;
 
-       return acl_fetch_bytes_out_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
+       return smp_fetch_bytes_out_rate(l4->stkctr[0].table, smp, l4->stkctr[0].entry);
 }
 
 /* set temp integer to the bytes rate to clients from the session's tracked BE counters
  * over the configured period.
  */
 static int
-acl_fetch_sc2_bytes_out_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_bytes_out_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                              const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
                return 0;
 
-       return acl_fetch_bytes_out_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
+       return smp_fetch_bytes_out_rate(l4->stkctr[1].table, smp, l4->stkctr[1].entry);
 }
 
 /* set temp integer to the bytes rate to client from the session's source address in
@@ -3547,7 +3547,7 @@ acl_fetch_sc2_bytes_out_rate(struct proxy *px, struct session *l4, void *l7, uns
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_src_bytes_out_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_src_bytes_out_rate(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                              const struct arg *args, struct sample *smp)
 {
        struct stktable_key *key;
@@ -3557,12 +3557,12 @@ acl_fetch_src_bytes_out_rate(struct proxy *px, struct session *l4, void *l7, uns
                return 0;
 
        px = args->data.prx;
-       return acl_fetch_bytes_out_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
+       return smp_fetch_bytes_out_rate(&px->table, smp, stktable_lookup_key(&px->table, key));
 }
 
 /* set temp integer to the number of active trackers on the SC1 entry */
 static int
-acl_fetch_sc1_trackers(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc1_trackers(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[0].entry)
@@ -3573,7 +3573,7 @@ acl_fetch_sc1_trackers(struct proxy *px, struct session *l4, void *l7, unsigned
 
 /* set temp integer to the number of active trackers on the SC1 entry */
 static int
-acl_fetch_sc2_trackers(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_sc2_trackers(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                        const struct arg *args, struct sample *smp)
 {
        if (!l4->stkctr[1].entry)
@@ -3586,7 +3586,7 @@ acl_fetch_sc2_trackers(struct proxy *px, struct session *l4, void *l7, unsigned
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_table_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_table_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                     const struct arg *args, struct sample *smp)
 {
        smp->flags = SMP_F_VOL_TEST;
@@ -3599,7 +3599,7 @@ acl_fetch_table_cnt(struct proxy *px, struct session *l4, void *l7, unsigned int
  * Accepts exactly 1 argument of type table.
  */
 static int
-acl_fetch_table_avl(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
+smp_fetch_table_avl(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                     const struct arg *args, struct sample *smp)
 {
        px = args->data.prx;
@@ -3613,65 +3613,126 @@ acl_fetch_table_avl(struct proxy *px, struct session *l4, void *l7, unsigned int
  * Please take care of keeping this list alphabetically sorted.
  */
 static struct acl_kw_list acl_kws = {{ },{
-       { "sc1_bytes_in_rate",  acl_parse_int,   acl_fetch_sc1_bytes_in_rate,  acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc1_bytes_out_rate", acl_parse_int,   acl_fetch_sc1_bytes_out_rate, acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc1_clr_gpc0",       acl_parse_int,   acl_fetch_sc1_clr_gpc0,       acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc1_conn_cnt",       acl_parse_int,   acl_fetch_sc1_conn_cnt,       acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc1_conn_cur",       acl_parse_int,   acl_fetch_sc1_conn_cur,       acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc1_conn_rate",      acl_parse_int,   acl_fetch_sc1_conn_rate,      acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc1_get_gpc0",       acl_parse_int,   acl_fetch_sc1_get_gpc0,       acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc1_http_err_cnt",   acl_parse_int,   acl_fetch_sc1_http_err_cnt,   acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc1_http_err_rate",  acl_parse_int,   acl_fetch_sc1_http_err_rate,  acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc1_http_req_cnt",   acl_parse_int,   acl_fetch_sc1_http_req_cnt,   acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc1_http_req_rate",  acl_parse_int,   acl_fetch_sc1_http_req_rate,  acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc1_inc_gpc0",       acl_parse_int,   acl_fetch_sc1_inc_gpc0,       acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc1_kbytes_in",      acl_parse_int,   acl_fetch_sc1_kbytes_in,      acl_match_int, ACL_USE_TCP4_VOLATILE, 0 },
-       { "sc1_kbytes_out",     acl_parse_int,   acl_fetch_sc1_kbytes_out,     acl_match_int, ACL_USE_TCP4_VOLATILE, 0 },
-       { "sc1_sess_cnt",       acl_parse_int,   acl_fetch_sc1_sess_cnt,       acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc1_sess_rate",      acl_parse_int,   acl_fetch_sc1_sess_rate,      acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc1_trackers",       acl_parse_int,   acl_fetch_sc1_trackers,       acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc2_bytes_in_rate",  acl_parse_int,   acl_fetch_sc2_bytes_in_rate,  acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc2_bytes_out_rate", acl_parse_int,   acl_fetch_sc2_bytes_out_rate, acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc2_clr_gpc0",       acl_parse_int,   acl_fetch_sc2_clr_gpc0,       acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc2_conn_cnt",       acl_parse_int,   acl_fetch_sc2_conn_cnt,       acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc2_conn_cur",       acl_parse_int,   acl_fetch_sc2_conn_cur,       acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc2_conn_rate",      acl_parse_int,   acl_fetch_sc2_conn_rate,      acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc2_get_gpc0",       acl_parse_int,   acl_fetch_sc2_get_gpc0,       acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc2_http_err_cnt",   acl_parse_int,   acl_fetch_sc2_http_err_cnt,   acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc2_http_err_rate",  acl_parse_int,   acl_fetch_sc2_http_err_rate,  acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc2_http_req_cnt",   acl_parse_int,   acl_fetch_sc2_http_req_cnt,   acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc2_http_req_rate",  acl_parse_int,   acl_fetch_sc2_http_req_rate,  acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc2_inc_gpc0",       acl_parse_int,   acl_fetch_sc2_inc_gpc0,       acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc2_kbytes_in",      acl_parse_int,   acl_fetch_sc2_kbytes_in,      acl_match_int, ACL_USE_TCP4_VOLATILE, 0 },
-       { "sc2_kbytes_out",     acl_parse_int,   acl_fetch_sc2_kbytes_out,     acl_match_int, ACL_USE_TCP4_VOLATILE, 0 },
-       { "sc2_sess_cnt",       acl_parse_int,   acl_fetch_sc2_sess_cnt,       acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc2_sess_rate",      acl_parse_int,   acl_fetch_sc2_sess_rate,      acl_match_int, ACL_USE_NOTHING,       0 },
-       { "sc2_trackers",       acl_parse_int,   acl_fetch_sc2_trackers,       acl_match_int, ACL_USE_NOTHING,       0 },
-       { "src_bytes_in_rate",  acl_parse_int,   acl_fetch_src_bytes_in_rate,  acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "src_bytes_out_rate", acl_parse_int,   acl_fetch_src_bytes_out_rate, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "src_clr_gpc0",       acl_parse_int,   acl_fetch_src_clr_gpc0,       acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "src_conn_cnt",       acl_parse_int,   acl_fetch_src_conn_cnt,       acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "src_conn_cur",       acl_parse_int,   acl_fetch_src_conn_cur,       acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "src_conn_rate",      acl_parse_int,   acl_fetch_src_conn_rate,      acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "src_get_gpc0",       acl_parse_int,   acl_fetch_src_get_gpc0,       acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "src_http_err_cnt",   acl_parse_int,   acl_fetch_src_http_err_cnt,   acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "src_http_err_rate",  acl_parse_int,   acl_fetch_src_http_err_rate,  acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "src_http_req_cnt",   acl_parse_int,   acl_fetch_src_http_req_cnt,   acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "src_http_req_rate",  acl_parse_int,   acl_fetch_src_http_req_rate,  acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "src_inc_gpc0",       acl_parse_int,   acl_fetch_src_inc_gpc0,       acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "src_kbytes_in",      acl_parse_int,   acl_fetch_src_kbytes_in,      acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "src_kbytes_out",     acl_parse_int,   acl_fetch_src_kbytes_out,     acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "src_sess_cnt",       acl_parse_int,   acl_fetch_src_sess_cnt,       acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "src_sess_rate",      acl_parse_int,   acl_fetch_src_sess_rate,      acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "src_updt_conn_cnt",  acl_parse_int,   acl_fetch_src_updt_conn_cnt,  acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
-       { "table_avl",          acl_parse_int,   acl_fetch_table_avl,          acl_match_int, ACL_USE_NOTHING,       ARG1(1,TAB) },
-       { "table_cnt",          acl_parse_int,   acl_fetch_table_cnt,          acl_match_int, ACL_USE_NOTHING,       ARG1(1,TAB) },
-       { NULL, NULL, NULL, NULL },
+       { "sc1_bytes_in_rate",  acl_parse_int,   smp_fetch_sc1_bytes_in_rate,  acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc1_bytes_out_rate", acl_parse_int,   smp_fetch_sc1_bytes_out_rate, acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc1_clr_gpc0",       acl_parse_int,   smp_fetch_sc1_clr_gpc0,       acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc1_conn_cnt",       acl_parse_int,   smp_fetch_sc1_conn_cnt,       acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc1_conn_cur",       acl_parse_int,   smp_fetch_sc1_conn_cur,       acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc1_conn_rate",      acl_parse_int,   smp_fetch_sc1_conn_rate,      acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc1_get_gpc0",       acl_parse_int,   smp_fetch_sc1_get_gpc0,       acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc1_http_err_cnt",   acl_parse_int,   smp_fetch_sc1_http_err_cnt,   acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc1_http_err_rate",  acl_parse_int,   smp_fetch_sc1_http_err_rate,  acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc1_http_req_cnt",   acl_parse_int,   smp_fetch_sc1_http_req_cnt,   acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc1_http_req_rate",  acl_parse_int,   smp_fetch_sc1_http_req_rate,  acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc1_inc_gpc0",       acl_parse_int,   smp_fetch_sc1_inc_gpc0,       acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc1_kbytes_in",      acl_parse_int,   smp_fetch_sc1_kbytes_in,      acl_match_int, ACL_USE_TCP4_VOLATILE, 0 },
+       { "sc1_kbytes_out",     acl_parse_int,   smp_fetch_sc1_kbytes_out,     acl_match_int, ACL_USE_TCP4_VOLATILE, 0 },
+       { "sc1_sess_cnt",       acl_parse_int,   smp_fetch_sc1_sess_cnt,       acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc1_sess_rate",      acl_parse_int,   smp_fetch_sc1_sess_rate,      acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc1_trackers",       acl_parse_int,   smp_fetch_sc1_trackers,       acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc2_bytes_in_rate",  acl_parse_int,   smp_fetch_sc2_bytes_in_rate,  acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc2_bytes_out_rate", acl_parse_int,   smp_fetch_sc2_bytes_out_rate, acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc2_clr_gpc0",       acl_parse_int,   smp_fetch_sc2_clr_gpc0,       acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc2_conn_cnt",       acl_parse_int,   smp_fetch_sc2_conn_cnt,       acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc2_conn_cur",       acl_parse_int,   smp_fetch_sc2_conn_cur,       acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc2_conn_rate",      acl_parse_int,   smp_fetch_sc2_conn_rate,      acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc2_get_gpc0",       acl_parse_int,   smp_fetch_sc2_get_gpc0,       acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc2_http_err_cnt",   acl_parse_int,   smp_fetch_sc2_http_err_cnt,   acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc2_http_err_rate",  acl_parse_int,   smp_fetch_sc2_http_err_rate,  acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc2_http_req_cnt",   acl_parse_int,   smp_fetch_sc2_http_req_cnt,   acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc2_http_req_rate",  acl_parse_int,   smp_fetch_sc2_http_req_rate,  acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc2_inc_gpc0",       acl_parse_int,   smp_fetch_sc2_inc_gpc0,       acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc2_kbytes_in",      acl_parse_int,   smp_fetch_sc2_kbytes_in,      acl_match_int, ACL_USE_TCP4_VOLATILE, 0 },
+       { "sc2_kbytes_out",     acl_parse_int,   smp_fetch_sc2_kbytes_out,     acl_match_int, ACL_USE_TCP4_VOLATILE, 0 },
+       { "sc2_sess_cnt",       acl_parse_int,   smp_fetch_sc2_sess_cnt,       acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc2_sess_rate",      acl_parse_int,   smp_fetch_sc2_sess_rate,      acl_match_int, ACL_USE_NOTHING,       0 },
+       { "sc2_trackers",       acl_parse_int,   smp_fetch_sc2_trackers,       acl_match_int, ACL_USE_NOTHING,       0 },
+       { "src_bytes_in_rate",  acl_parse_int,   smp_fetch_src_bytes_in_rate,  acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "src_bytes_out_rate", acl_parse_int,   smp_fetch_src_bytes_out_rate, acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "src_clr_gpc0",       acl_parse_int,   smp_fetch_src_clr_gpc0,       acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "src_conn_cnt",       acl_parse_int,   smp_fetch_src_conn_cnt,       acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "src_conn_cur",       acl_parse_int,   smp_fetch_src_conn_cur,       acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "src_conn_rate",      acl_parse_int,   smp_fetch_src_conn_rate,      acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "src_get_gpc0",       acl_parse_int,   smp_fetch_src_get_gpc0,       acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "src_http_err_cnt",   acl_parse_int,   smp_fetch_src_http_err_cnt,   acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "src_http_err_rate",  acl_parse_int,   smp_fetch_src_http_err_rate,  acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "src_http_req_cnt",   acl_parse_int,   smp_fetch_src_http_req_cnt,   acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "src_http_req_rate",  acl_parse_int,   smp_fetch_src_http_req_rate,  acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "src_inc_gpc0",       acl_parse_int,   smp_fetch_src_inc_gpc0,       acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "src_kbytes_in",      acl_parse_int,   smp_fetch_src_kbytes_in,      acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "src_kbytes_out",     acl_parse_int,   smp_fetch_src_kbytes_out,     acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "src_sess_cnt",       acl_parse_int,   smp_fetch_src_sess_cnt,       acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "src_sess_rate",      acl_parse_int,   smp_fetch_src_sess_rate,      acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "src_updt_conn_cnt",  acl_parse_int,   smp_fetch_src_updt_conn_cnt,  acl_match_int, ACL_USE_TCP4_VOLATILE, ARG1(1,TAB) },
+       { "table_avl",          acl_parse_int,   smp_fetch_table_avl,          acl_match_int, ACL_USE_NOTHING,       ARG1(1,TAB) },
+       { "table_cnt",          acl_parse_int,   smp_fetch_table_cnt,          acl_match_int, ACL_USE_NOTHING,       ARG1(1,TAB) },
+       { /* 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 = {{ },{
+       { "sc1_bytes_in_rate",  smp_fetch_sc1_bytes_in_rate,  0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc1_bytes_out_rate", smp_fetch_sc1_bytes_out_rate, 0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc1_clr_gpc0",       smp_fetch_sc1_clr_gpc0,       0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc1_conn_cnt",       smp_fetch_sc1_conn_cnt,       0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc1_conn_cur",       smp_fetch_sc1_conn_cur,       0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc1_conn_rate",      smp_fetch_sc1_conn_rate,      0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc1_get_gpc0",       smp_fetch_sc1_get_gpc0,       0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc1_http_err_cnt",   smp_fetch_sc1_http_err_cnt,   0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc1_http_err_rate",  smp_fetch_sc1_http_err_rate,  0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc1_http_req_cnt",   smp_fetch_sc1_http_req_cnt,   0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc1_http_req_rate",  smp_fetch_sc1_http_req_rate,  0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc1_inc_gpc0",       smp_fetch_sc1_inc_gpc0,       0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc1_kbytes_in",      smp_fetch_sc1_kbytes_in,      0,           NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "sc1_kbytes_out",     smp_fetch_sc1_kbytes_out,     0,           NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "sc1_sess_cnt",       smp_fetch_sc1_sess_cnt,       0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc1_sess_rate",      smp_fetch_sc1_sess_rate,      0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc1_trackers",       smp_fetch_sc1_trackers,       0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc2_bytes_in_rate",  smp_fetch_sc2_bytes_in_rate,  0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc2_bytes_out_rate", smp_fetch_sc2_bytes_out_rate, 0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc2_clr_gpc0",       smp_fetch_sc2_clr_gpc0,       0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc2_conn_cnt",       smp_fetch_sc2_conn_cnt,       0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc2_conn_cur",       smp_fetch_sc2_conn_cur,       0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc2_conn_rate",      smp_fetch_sc2_conn_rate,      0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc2_get_gpc0",       smp_fetch_sc2_get_gpc0,       0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc2_http_err_cnt",   smp_fetch_sc2_http_err_cnt,   0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc2_http_err_rate",  smp_fetch_sc2_http_err_rate,  0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc2_http_req_cnt",   smp_fetch_sc2_http_req_cnt,   0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc2_http_req_rate",  smp_fetch_sc2_http_req_rate,  0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc2_inc_gpc0",       smp_fetch_sc2_inc_gpc0,       0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc2_kbytes_in",      smp_fetch_sc2_kbytes_in,      0,           NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "sc2_kbytes_out",     smp_fetch_sc2_kbytes_out,     0,           NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "sc2_sess_cnt",       smp_fetch_sc2_sess_cnt,       0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc2_sess_rate",      smp_fetch_sc2_sess_rate,      0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "sc2_trackers",       smp_fetch_sc2_trackers,       0,           NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "src_bytes_in_rate",  smp_fetch_src_bytes_in_rate,  ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "src_bytes_out_rate", smp_fetch_src_bytes_out_rate, ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "src_clr_gpc0",       smp_fetch_src_clr_gpc0,       ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "src_conn_cnt",       smp_fetch_src_conn_cnt,       ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "src_conn_cur",       smp_fetch_src_conn_cur,       ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "src_conn_rate",      smp_fetch_src_conn_rate,      ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "src_get_gpc0",       smp_fetch_src_get_gpc0,       ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "src_http_err_cnt",   smp_fetch_src_http_err_cnt,   ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "src_http_err_rate",  smp_fetch_src_http_err_rate,  ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "src_http_req_cnt",   smp_fetch_src_http_req_cnt,   ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "src_http_req_rate",  smp_fetch_src_http_req_rate,  ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "src_inc_gpc0",       smp_fetch_src_inc_gpc0,       ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "src_kbytes_in",      smp_fetch_src_kbytes_in,      ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "src_kbytes_out",     smp_fetch_src_kbytes_out,     ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "src_sess_cnt",       smp_fetch_src_sess_cnt,       ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "src_sess_rate",      smp_fetch_src_sess_rate,      ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "src_updt_conn_cnt",  smp_fetch_src_updt_conn_cnt,  ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_L4CLI, },
+       { "table_avl",          smp_fetch_table_avl,          ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { "table_cnt",          smp_fetch_table_cnt,          ARG1(1,TAB), NULL, SMP_T_UINT, SMP_USE_INTRN, },
+       { /* END */ },
 }};
 
 __attribute__((constructor))
 static void __session_init(void)
 {
+       sample_register_fetches(&smp_fetch_keywords);
        acl_register_keywords(&acl_kws);
 }