/* * Stick tables management functions. * * Copyright 2009-2010 EXCELIANCE, Emeric Brun * Copyright (C) 2010 Willy Tarreau * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* structure used to return a table key built from a sample */ static THREAD_LOCAL struct stktable_key static_table_key; static int (*smp_fetch_src)(const struct arg *, struct sample *, const char *, void *); struct stktable *stktables_list; struct eb_root stktable_by_name = EB_ROOT; #define round_ptr_size(i) (((i) + (sizeof(void *) - 1)) &~ (sizeof(void *) - 1)) /* This function inserts stktable into the tree of known stick-table. * The stick-table ID is used as the storing key so it must already have * been initialized. */ void stktable_store_name(struct stktable *t) { t->name.key = t->id; ebis_insert(&stktable_by_name, &t->name); } struct stktable *stktable_find_by_name(const char *name) { struct ebpt_node *node; struct stktable *t; node = ebis_lookup(&stktable_by_name, name); if (node) { t = container_of(node, struct stktable, name); if (strcmp(t->id, name) == 0) return t; } return NULL; } /* * Free an allocated sticky session , and decrease sticky sessions counter * in table . */ void __stksess_free(struct stktable *t, struct stksess *ts) { t->current--; pool_free(t->pool, (void *)ts - round_ptr_size(t->data_size)); } /* * Free an allocated sticky session , and decrease sticky sessions counter * in table . * This function locks the table */ void stksess_free(struct stktable *t, struct stksess *ts) { void *data; data = stktable_data_ptr(t, ts, STKTABLE_DT_SERVER_KEY); if (data) { dict_entry_unref(&server_key_dict, stktable_data_cast(data, std_t_dict)); stktable_data_cast(data, std_t_dict) = NULL; } HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock); __stksess_free(t, ts); HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock); } /* * Kill an stksess (only if its ref_cnt is zero). */ int __stksess_kill(struct stktable *t, struct stksess *ts) { if (ts->ref_cnt) return 0; eb32_delete(&ts->exp); eb32_delete(&ts->upd); ebmb_delete(&ts->key); __stksess_free(t, ts); return 1; } /* * Decrease the refcount if decrefcnt is not 0. * and try to kill the stksess * This function locks the table */ int stksess_kill(struct stktable *t, struct stksess *ts, int decrefcnt) { int ret; HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock); if (decrefcnt) ts->ref_cnt--; ret = __stksess_kill(t, ts); HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock); return ret; } /* * Initialize or update the key in the sticky session present in table * from the value present in . */ void stksess_setkey(struct stktable *t, struct stksess *ts, struct stktable_key *key) { if (t->type != SMP_T_STR) memcpy(ts->key.key, key->key, t->key_size); else { memcpy(ts->key.key, key->key, MIN(t->key_size - 1, key->key_len)); ts->key.key[MIN(t->key_size - 1, key->key_len)] = 0; } } /* * Init sticky session of table . The data parts are cleared and * is returned. */ static struct stksess *__stksess_init(struct stktable *t, struct stksess * ts) { memset((void *)ts - t->data_size, 0, t->data_size); ts->ref_cnt = 0; ts->key.node.leaf_p = NULL; ts->exp.node.leaf_p = NULL; ts->upd.node.leaf_p = NULL; ts->expire = tick_add(now_ms, MS_TO_TICKS(t->expire)); HA_RWLOCK_INIT(&ts->lock); return ts; } /* * Trash oldest sticky sessions from table * Returns number of trashed sticky sessions. It may actually trash less * than expected if finding these requires too long a search time (e.g. * most of them have ts->ref_cnt>0). */ int __stktable_trash_oldest(struct stktable *t, int to_batch) { struct stksess *ts; struct eb32_node *eb; int max_search = to_batch * 2; // no more than 50% misses int batched = 0; int looped = 0; eb = eb32_lookup_ge(&t->exps, now_ms - TIMER_LOOK_BACK); while (batched < to_batch) { if (unlikely(!eb)) { /* we might have reached the end of the tree, typically because * is in the first half and we're first scanning the last * half. Let's loop back to the beginning of the tree now if we * have not yet visited it. */ if (looped) break; looped = 1; eb = eb32_first(&t->exps); if (likely(!eb)) break; } if (--max_search < 0) break; /* timer looks expired, detach it from the queue */ ts = eb32_entry(eb, struct stksess, exp); eb = eb32_next(eb); /* don't delete an entry which is currently referenced */ if (ts->ref_cnt) continue; eb32_delete(&ts->exp); if (ts->expire != ts->exp.key) { if (!tick_isset(ts->expire)) continue; ts->exp.key = ts->expire; eb32_insert(&t->exps, &ts->exp); /* the update might have jumped beyond the next element, * possibly causing a wrapping. We need to check whether * the next element should be used instead. If the next * element doesn't exist it means we're on the right * side and have to check the first one then. If it * exists and is closer, we must use it, otherwise we * use the current one. */ if (!eb) eb = eb32_first(&t->exps); if (!eb || tick_is_lt(ts->exp.key, eb->key)) eb = &ts->exp; continue; } /* session expired, trash it */ ebmb_delete(&ts->key); eb32_delete(&ts->upd); __stksess_free(t, ts); batched++; } return batched; } /* * Trash oldest sticky sessions from table * Returns number of trashed sticky sessions. * This function locks the table */ int stktable_trash_oldest(struct stktable *t, int to_batch) { int ret; HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock); ret = __stktable_trash_oldest(t, to_batch); HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock); return ret; } /* * Allocate and initialise a new sticky session. * The new sticky session is returned or NULL in case of lack of memory. * Sticky sessions should only be allocated this way, and must be freed using * stksess_free(). Table 's sticky session counter is increased. If * is not NULL, it is assigned to the new session. */ struct stksess *__stksess_new(struct stktable *t, struct stktable_key *key) { struct stksess *ts; if (unlikely(t->current == t->size)) { if ( t->nopurge ) return NULL; if (!__stktable_trash_oldest(t, (t->size >> 8) + 1)) return NULL; } ts = pool_alloc(t->pool); if (ts) { t->current++; ts = (void *)ts + round_ptr_size(t->data_size); __stksess_init(t, ts); if (key) stksess_setkey(t, ts, key); } return ts; } /* * Allocate and initialise a new sticky session. * The new sticky session is returned or NULL in case of lack of memory. * Sticky sessions should only be allocated this way, and must be freed using * stksess_free(). Table 's sticky session counter is increased. If * is not NULL, it is assigned to the new session. * This function locks the table */ struct stksess *stksess_new(struct stktable *t, struct stktable_key *key) { struct stksess *ts; HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock); ts = __stksess_new(t, key); HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock); return ts; } /* * Looks in table for a sticky session matching key . * Returns pointer on requested sticky session or NULL if none was found. */ struct stksess *__stktable_lookup_key(struct stktable *t, struct stktable_key *key) { struct ebmb_node *eb; if (t->type == SMP_T_STR) eb = ebst_lookup_len(&t->keys, key->key, key->key_len+1 < t->key_size ? key->key_len : t->key_size-1); else eb = ebmb_lookup(&t->keys, key->key, t->key_size); if (unlikely(!eb)) { /* no session found */ return NULL; } return ebmb_entry(eb, struct stksess, key); } /* * Looks in table for a sticky session matching key . * Returns pointer on requested sticky session or NULL if none was found. * The refcount of the found entry is increased and this function * is protected using the table lock */ struct stksess *stktable_lookup_key(struct stktable *t, struct stktable_key *key) { struct stksess *ts; HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock); ts = __stktable_lookup_key(t, key); if (ts) ts->ref_cnt++; HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock); return ts; } /* * Looks in table for a sticky session with same key as . * Returns pointer on requested sticky session or NULL if none was found. */ struct stksess *__stktable_lookup(struct stktable *t, struct stksess *ts) { struct ebmb_node *eb; if (t->type == SMP_T_STR) eb = ebst_lookup(&(t->keys), (char *)ts->key.key); else eb = ebmb_lookup(&(t->keys), ts->key.key, t->key_size); if (unlikely(!eb)) return NULL; return ebmb_entry(eb, struct stksess, key); } /* * Looks in table for a sticky session with same key as . * Returns pointer on requested sticky session or NULL if none was found. * The refcount of the found entry is increased and this function * is protected using the table lock */ struct stksess *stktable_lookup(struct stktable *t, struct stksess *ts) { struct stksess *lts; HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock); lts = __stktable_lookup(t, ts); if (lts) lts->ref_cnt++; HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock); return lts; } /* Update the expiration timer for but do not touch its expiration node. * The table's expiration timer is updated if set. * The node will be also inserted into the update tree if needed, at a position * depending if the update is a local or coming from a remote node */ void __stktable_touch_with_exp(struct stktable *t, struct stksess *ts, int local, int expire) { struct eb32_node * eb; ts->expire = expire; if (t->expire) { t->exp_task->expire = t->exp_next = tick_first(ts->expire, t->exp_next); task_queue(t->exp_task); } /* If sync is enabled */ if (t->sync_task) { if (local) { /* If this entry is not in the tree or not scheduled for at least one peer */ if (!ts->upd.node.leaf_p || (int)(t->commitupdate - ts->upd.key) >= 0 || (int)(ts->upd.key - t->localupdate) >= 0) { ts->upd.key = ++t->update; t->localupdate = t->update; eb32_delete(&ts->upd); eb = eb32_insert(&t->updates, &ts->upd); if (eb != &ts->upd) { eb32_delete(eb); eb32_insert(&t->updates, &ts->upd); } } task_wakeup(t->sync_task, TASK_WOKEN_MSG); } else { /* If this entry is not in the tree */ if (!ts->upd.node.leaf_p) { ts->upd.key= (++t->update)+(2147483648U); eb = eb32_insert(&t->updates, &ts->upd); if (eb != &ts->upd) { eb32_delete(eb); eb32_insert(&t->updates, &ts->upd); } } } } } /* Update the expiration timer for but do not touch its expiration node. * The table's expiration timer is updated using the date of expiration coming from * stick-table configuration. * The node will be also inserted into the update tree if needed, at a position * considering the update is coming from a remote node */ void stktable_touch_remote(struct stktable *t, struct stksess *ts, int decrefcnt) { HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock); __stktable_touch_with_exp(t, ts, 0, ts->expire); if (decrefcnt) ts->ref_cnt--; HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock); } /* Update the expiration timer for but do not touch its expiration node. * The table's expiration timer is updated using the date of expiration coming from * stick-table configuration. * The node will be also inserted into the update tree if needed, at a position * considering the update was made locally */ void stktable_touch_local(struct stktable *t, struct stksess *ts, int decrefcnt) { int expire = tick_add(now_ms, MS_TO_TICKS(t->expire)); HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock); __stktable_touch_with_exp(t, ts, 1, expire); if (decrefcnt) ts->ref_cnt--; HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock); } /* Just decrease the ref_cnt of the current session. Does nothing if is NULL */ static void stktable_release(struct stktable *t, struct stksess *ts) { if (!ts) return; HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock); ts->ref_cnt--; HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock); } /* Insert new sticky session in the table. It is assumed that it does not * yet exist (the caller must check this). The table's timeout is updated if it * is set. is returned. */ void __stktable_store(struct stktable *t, struct stksess *ts) { ebmb_insert(&t->keys, &ts->key, t->key_size); ts->exp.key = ts->expire; eb32_insert(&t->exps, &ts->exp); if (t->expire) { t->exp_task->expire = t->exp_next = tick_first(ts->expire, t->exp_next); task_queue(t->exp_task); } } /* Returns a valid or initialized stksess for the specified stktable_key in the * specified table, or NULL if the key was NULL, or if no entry was found nor * could be created. The entry's expiration is updated. */ struct stksess *__stktable_get_entry(struct stktable *table, struct stktable_key *key) { struct stksess *ts; if (!key) return NULL; ts = __stktable_lookup_key(table, key); if (ts == NULL) { /* entry does not exist, initialize a new one */ ts = __stksess_new(table, key); if (!ts) return NULL; __stktable_store(table, ts); } return ts; } /* Returns a valid or initialized stksess for the specified stktable_key in the * specified table, or NULL if the key was NULL, or if no entry was found nor * could be created. The entry's expiration is updated. * This function locks the table, and the refcount of the entry is increased. */ struct stksess *stktable_get_entry(struct stktable *table, struct stktable_key *key) { struct stksess *ts; HA_SPIN_LOCK(STK_TABLE_LOCK, &table->lock); ts = __stktable_get_entry(table, key); if (ts) ts->ref_cnt++; HA_SPIN_UNLOCK(STK_TABLE_LOCK, &table->lock); return ts; } /* Lookup for an entry with the same key and store the submitted * stksess if not found. */ struct stksess *__stktable_set_entry(struct stktable *table, struct stksess *nts) { struct stksess *ts; ts = __stktable_lookup(table, nts); if (ts == NULL) { ts = nts; __stktable_store(table, ts); } return ts; } /* Lookup for an entry with the same key and store the submitted * stksess if not found. * This function locks the table, and the refcount of the entry is increased. */ struct stksess *stktable_set_entry(struct stktable *table, struct stksess *nts) { struct stksess *ts; HA_SPIN_LOCK(STK_TABLE_LOCK, &table->lock); ts = __stktable_set_entry(table, nts); ts->ref_cnt++; HA_SPIN_UNLOCK(STK_TABLE_LOCK, &table->lock); return ts; } /* * Task processing function to trash expired sticky sessions. A pointer to the * task itself is returned since it never dies. */ struct task *process_table_expire(struct task *task, void *context, unsigned int state) { struct stktable *t = context; struct stksess *ts; struct eb32_node *eb; int looped = 0; HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock); eb = eb32_lookup_ge(&t->exps, now_ms - TIMER_LOOK_BACK); while (1) { if (unlikely(!eb)) { /* we might have reached the end of the tree, typically because * is in the first half and we're first scanning the last * half. Let's loop back to the beginning of the tree now if we * have not yet visited it. */ if (looped) break; looped = 1; eb = eb32_first(&t->exps); if (likely(!eb)) break; } if (likely(tick_is_lt(now_ms, eb->key))) { /* timer not expired yet, revisit it later */ t->exp_next = eb->key; goto out_unlock; } /* timer looks expired, detach it from the queue */ ts = eb32_entry(eb, struct stksess, exp); eb = eb32_next(eb); /* don't delete an entry which is currently referenced */ if (ts->ref_cnt) continue; eb32_delete(&ts->exp); if (!tick_is_expired(ts->expire, now_ms)) { if (!tick_isset(ts->expire)) continue; ts->exp.key = ts->expire; eb32_insert(&t->exps, &ts->exp); /* the update might have jumped beyond the next element, * possibly causing a wrapping. We need to check whether * the next element should be used instead. If the next * element doesn't exist it means we're on the right * side and have to check the first one then. If it * exists and is closer, we must use it, otherwise we * use the current one. */ if (!eb) eb = eb32_first(&t->exps); if (!eb || tick_is_lt(ts->exp.key, eb->key)) eb = &ts->exp; continue; } /* session expired, trash it */ ebmb_delete(&ts->key); eb32_delete(&ts->upd); __stksess_free(t, ts); } /* We have found no task to expire in any tree */ t->exp_next = TICK_ETERNITY; out_unlock: task->expire = t->exp_next; HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock); return task; } /* Perform minimal stick table intializations, report 0 in case of error, 1 if OK. */ int stktable_init(struct stktable *t) { int peers_retval = 0; if (t->size) { t->keys = EB_ROOT_UNIQUE; memset(&t->exps, 0, sizeof(t->exps)); t->updates = EB_ROOT_UNIQUE; HA_SPIN_INIT(&t->lock); t->pool = create_pool("sticktables", sizeof(struct stksess) + round_ptr_size(t->data_size) + t->key_size, MEM_F_SHARED); t->exp_next = TICK_ETERNITY; if ( t->expire ) { t->exp_task = task_new_anywhere(); if (!t->exp_task) return 0; t->exp_task->process = process_table_expire; t->exp_task->context = (void *)t; } if (t->peers.p && t->peers.p->peers_fe && !(t->peers.p->peers_fe->flags & (PR_FL_DISABLED|PR_FL_STOPPED))) { peers_retval = peers_register_table(t->peers.p, t); } return (t->pool != NULL) && !peers_retval; } return 1; } /* * Configuration keywords of known table types */ struct stktable_type stktable_types[SMP_TYPES] = { [SMP_T_SINT] = { "integer", 0, 4 }, [SMP_T_IPV4] = { "ip", 0, 4 }, [SMP_T_IPV6] = { "ipv6", 0, 16 }, [SMP_T_STR] = { "string", STK_F_CUSTOM_KEYSIZE, 32 }, [SMP_T_BIN] = { "binary", STK_F_CUSTOM_KEYSIZE, 32 } }; /* * Parse table type configuration. * Returns 0 on successful parsing, else 1. * is set at next configuration index. */ int stktable_parse_type(char **args, int *myidx, unsigned long *type, size_t *key_size) { for (*type = 0; *type < SMP_TYPES; (*type)++) { if (!stktable_types[*type].kw) continue; if (strcmp(args[*myidx], stktable_types[*type].kw) != 0) continue; *key_size = stktable_types[*type].default_size; (*myidx)++; if (stktable_types[*type].flags & STK_F_CUSTOM_KEYSIZE) { if (strcmp("len", args[*myidx]) == 0) { (*myidx)++; *key_size = atol(args[*myidx]); if (!*key_size) break; if (*type == SMP_T_STR) { /* null terminated string needs +1 for '\0'. */ (*key_size)++; } (*myidx)++; } } return 0; } return 1; } /* reserve some space for data type , there is 2 optionnals * argument at and to configure this data type and * they can be NULL if unused for a given type. * Returns PE_NONE (0) if OK or an error code among : * - PE_ENUM_OOR if does not exist * - PE_EXIST if is already registered * - PE_ARG_NOT_USE if / was provided but not expected * - PE_ARG_MISSING if / was expected but not provided * - PE_ARG_VALUE_OOR if type is an array and it out of array size range. */ int stktable_alloc_data_type(struct stktable *t, int type, const char *sa, const char *sa2) { if (type >= STKTABLE_DATA_TYPES) return PE_ENUM_OOR; if (t->data_ofs[type]) /* already allocated */ return PE_EXIST; t->data_nbelem[type] = 1; if (stktable_data_types[type].is_array) { /* arrays take their element count on first argument */ if (!sa) return PE_ARG_MISSING; t->data_nbelem[type] = atoi(sa); if (!t->data_nbelem[type] || (t->data_nbelem[type] > STKTABLE_MAX_DT_ARRAY_SIZE)) return PE_ARG_VALUE_OOR; sa = sa2; } switch (stktable_data_types[type].arg_type) { case ARG_T_NONE: if (sa) return PE_ARG_NOT_USED; break; case ARG_T_INT: if (!sa) return PE_ARG_MISSING; t->data_arg[type].i = atoi(sa); break; case ARG_T_DELAY: if (!sa) return PE_ARG_MISSING; sa = parse_time_err(sa, &t->data_arg[type].u, TIME_UNIT_MS); if (sa) return PE_ARG_INVC; /* invalid char */ break; } t->data_size += t->data_nbelem[type] * stktable_type_size(stktable_data_types[type].std_type); t->data_ofs[type] = -t->data_size; return PE_NONE; } /* * Parse a line with as number in configuration file to configure * the stick-table with as address and as ID. * provides the "peers" section pointer only if this function is called * from a "peers" section. * is the stick-table name which is sent over the network. It must be equal * to if this stick-table is parsed from a proxy section, and prefixed by * "peers" section name followed by a '/' character if parsed from a "peers" section. * This is the responsibility of the caller to check this. * Return an error status with ERR_* flags set if required, 0 if no error was encountered. */ int parse_stick_table(const char *file, int linenum, char **args, struct stktable *t, char *id, char *nid, struct peers *peers) { int err_code = 0; int idx = 1; unsigned int val; if (!id || !*id) { ha_alert("parsing [%s:%d] : %s: ID not provided.\n", file, linenum, args[0]); err_code |= ERR_ALERT | ERR_ABORT; goto out; } /* Store the "peers" section if this function is called from a "peers" section. */ if (peers) { t->peers.p = peers; idx++; } t->id = id; t->nid = nid; t->type = (unsigned int)-1; t->conf.file = file; t->conf.line = linenum; while (*args[idx]) { const char *err; if (strcmp(args[idx], "size") == 0) { idx++; if (!*(args[idx])) { ha_alert("parsing [%s:%d] : %s: missing argument after '%s'.\n", file, linenum, args[0], args[idx-1]); err_code |= ERR_ALERT | ERR_FATAL; goto out; } if ((err = parse_size_err(args[idx], &t->size))) { ha_alert("parsing [%s:%d] : %s: unexpected character '%c' in argument of '%s'.\n", file, linenum, args[0], *err, args[idx-1]); err_code |= ERR_ALERT | ERR_FATAL; goto out; } idx++; } /* This argument does not exit in "peers" section. */ else if (!peers && strcmp(args[idx], "peers") == 0) { idx++; if (!*(args[idx])) { ha_alert("parsing [%s:%d] : %s: missing argument after '%s'.\n", file, linenum, args[0], args[idx-1]); err_code |= ERR_ALERT | ERR_FATAL; goto out; } t->peers.name = strdup(args[idx++]); } else if (strcmp(args[idx], "expire") == 0) { idx++; if (!*(args[idx])) { ha_alert("parsing [%s:%d] : %s: missing argument after '%s'.\n", file, linenum, args[0], args[idx-1]); err_code |= ERR_ALERT | ERR_FATAL; goto out; } err = parse_time_err(args[idx], &val, TIME_UNIT_MS); if (err == PARSE_TIME_OVER) { ha_alert("parsing [%s:%d]: %s: timer overflow in argument <%s> to <%s>, maximum value is 2147483647 ms (~24.8 days).\n", file, linenum, args[0], args[idx], args[idx-1]); err_code |= ERR_ALERT | ERR_FATAL; goto out; } else if (err == PARSE_TIME_UNDER) { ha_alert("parsing [%s:%d]: %s: timer underflow in argument <%s> to <%s>, minimum non-null value is 1 ms.\n", file, linenum, args[0], args[idx], args[idx-1]); err_code |= ERR_ALERT | ERR_FATAL; goto out; } else if (err) { ha_alert("parsing [%s:%d] : %s: unexpected character '%c' in argument of '%s'.\n", file, linenum, args[0], *err, args[idx-1]); err_code |= ERR_ALERT | ERR_FATAL; goto out; } t->expire = val; idx++; } else if (strcmp(args[idx], "nopurge") == 0) { t->nopurge = 1; idx++; } else if (strcmp(args[idx], "type") == 0) { idx++; if (stktable_parse_type(args, &idx, &t->type, &t->key_size) != 0) { ha_alert("parsing [%s:%d] : %s: unknown type '%s'.\n", file, linenum, args[0], args[idx]); err_code |= ERR_ALERT | ERR_FATAL; goto out; } /* idx already points to next arg */ } else if (strcmp(args[idx], "store") == 0) { int type, err; char *cw, *nw, *sa, *sa2; idx++; nw = args[idx]; while (*nw) { /* the "store" keyword supports a comma-separated list */ cw = nw; sa = NULL; /* store arg */ sa2 = NULL; while (*nw && *nw != ',') { if (*nw == '(') { *nw = 0; sa = ++nw; while (*nw != ')') { if (!*nw) { ha_alert("parsing [%s:%d] : %s: missing closing parenthesis after store option '%s'.\n", file, linenum, args[0], cw); err_code |= ERR_ALERT | ERR_FATAL; goto out; } if (*nw == ',') { *nw = '\0'; sa2 = nw + 1; } nw++; } *nw = '\0'; } nw++; } if (*nw) *nw++ = '\0'; type = stktable_get_data_type(cw); if (type < 0) { ha_alert("parsing [%s:%d] : %s: unknown store option '%s'.\n", file, linenum, args[0], cw); err_code |= ERR_ALERT | ERR_FATAL; goto out; } err = stktable_alloc_data_type(t, type, sa, sa2); switch (err) { case PE_NONE: break; case PE_EXIST: ha_warning("parsing [%s:%d]: %s: store option '%s' already enabled, ignored.\n", file, linenum, args[0], cw); err_code |= ERR_WARN; break; case PE_ARG_MISSING: ha_alert("parsing [%s:%d] : %s: missing argument to store option '%s'.\n", file, linenum, args[0], cw); err_code |= ERR_ALERT | ERR_FATAL; goto out; case PE_ARG_NOT_USED: ha_alert("parsing [%s:%d] : %s: unexpected argument to store option '%s'.\n", file, linenum, args[0], cw); err_code |= ERR_ALERT | ERR_FATAL; goto out; case PE_ARG_VALUE_OOR: ha_alert("parsing [%s:%d] : %s: array size is out of allowed range (1-%d) for store option '%s'.\n", file, linenum, args[0], STKTABLE_MAX_DT_ARRAY_SIZE, cw); err_code |= ERR_ALERT | ERR_FATAL; goto out; default: ha_alert("parsing [%s:%d] : %s: error when processing store option '%s'.\n", file, linenum, args[0], cw); err_code |= ERR_ALERT | ERR_FATAL; goto out; } } idx++; if (t->data_ofs[STKTABLE_DT_GPT] && t->data_ofs[STKTABLE_DT_GPT0]) { ha_alert("parsing [%s:%d] : %s: simultaneous usage of 'gpt' and 'gpt0' in a same table is not permitted as 'gpt' overrides 'gpt0'.\n", file, linenum, args[0]); err_code |= ERR_ALERT | ERR_FATAL; goto out; } else if (t->data_ofs[STKTABLE_DT_GPC] && (t->data_ofs[STKTABLE_DT_GPC0] || t->data_ofs[STKTABLE_DT_GPC1])) { ha_alert("parsing [%s:%d] : %s: simultaneous usage of 'gpc' and 'gpc[0/1]' in a same table is not permitted as 'gpc' overrides 'gpc[0/1]'.\n", file, linenum, args[0]); err_code |= ERR_ALERT | ERR_FATAL; goto out; } else if (t->data_ofs[STKTABLE_DT_GPC_RATE] && (t->data_ofs[STKTABLE_DT_GPC0_RATE] || t->data_ofs[STKTABLE_DT_GPC1_RATE])) { ha_alert("parsing [%s:%d] : %s: simultaneous usage of 'gpc_rate' and 'gpc[0/1]_rate' in a same table is not permitted as 'gpc_rate' overrides 'gpc[0/1]_rate'.\n", file, linenum, args[0]); err_code |= ERR_ALERT | ERR_FATAL; goto out; } } else if (strcmp(args[idx], "srvkey") == 0) { char *keytype; idx++; keytype = args[idx]; if (strcmp(keytype, "name") == 0) { t->server_key_type = STKTABLE_SRV_NAME; } else if (strcmp(keytype, "addr") == 0) { t->server_key_type = STKTABLE_SRV_ADDR; } else { ha_alert("parsing [%s:%d] : %s : unknown server key type '%s'.\n", file, linenum, args[0], keytype); err_code |= ERR_ALERT | ERR_FATAL; goto out; } idx++; } else { ha_alert("parsing [%s:%d] : %s: unknown argument '%s'.\n", file, linenum, args[0], args[idx]); err_code |= ERR_ALERT | ERR_FATAL; goto out; } } if (!t->size) { ha_alert("parsing [%s:%d] : %s: missing size.\n", file, linenum, args[0]); err_code |= ERR_ALERT | ERR_FATAL; goto out; } if (t->type == (unsigned int)-1) { ha_alert("parsing [%s:%d] : %s: missing type.\n", file, linenum, args[0]); err_code |= ERR_ALERT | ERR_FATAL; goto out; } out: return err_code; } /* Prepares a stktable_key from a sample to search into table . * Note that the sample *is* modified and that the returned key may point * to it, so the sample must not be modified afterwards before the lookup. * Returns NULL if the sample could not be converted (eg: no matching type), * otherwise a pointer to the static stktable_key filled with what is needed * for the lookup. */ struct stktable_key *smp_to_stkey(struct sample *smp, struct stktable *t) { /* Convert sample. */ if (!sample_convert(smp, t->type)) return NULL; /* Fill static_table_key. */ switch (t->type) { case SMP_T_IPV4: static_table_key.key = &smp->data.u.ipv4; static_table_key.key_len = 4; break; case SMP_T_IPV6: static_table_key.key = &smp->data.u.ipv6; static_table_key.key_len = 16; break; case SMP_T_SINT: /* The stick table require a 32bit unsigned int, "sint" is a * signed 64 it, so we can convert it inplace. */ smp->data.u.sint = (unsigned int)smp->data.u.sint; static_table_key.key = &smp->data.u.sint; static_table_key.key_len = 4; break; case SMP_T_STR: if (!smp_make_safe(smp)) return NULL; static_table_key.key = smp->data.u.str.area; static_table_key.key_len = smp->data.u.str.data; break; case SMP_T_BIN: if (smp->data.u.str.data < t->key_size) { /* This type needs padding with 0. */ if (!smp_make_rw(smp)) return NULL; if (smp->data.u.str.size < t->key_size) if (!smp_dup(smp)) return NULL; if (smp->data.u.str.size < t->key_size) return NULL; memset(smp->data.u.str.area + smp->data.u.str.data, 0, t->key_size - smp->data.u.str.data); smp->data.u.str.data = t->key_size; } static_table_key.key = smp->data.u.str.area; static_table_key.key_len = smp->data.u.str.data; break; default: /* impossible case. */ return NULL; } return &static_table_key; } /* * Process a fetch + format conversion as defined by the sample expression * on request or response considering the parameter. Returns either NULL if * no key could be extracted, or a pointer to the converted result stored in * static_table_key in format . If is not NULL, it will be reset * and its flags will be initialized so that the caller gets a copy of the input * sample, and knows why it was not accepted (eg: SMP_F_MAY_CHANGE is present * without SMP_OPT_FINAL). The output will be usable like this : * * return MAY_CHANGE FINAL Meaning for the sample * NULL 0 * Not present and will never be (eg: header) * NULL 1 0 Not present or unstable, could change (eg: req_len) * NULL 1 1 Not present, will not change anymore * smp 0 * Present and will not change (eg: header) * smp 1 0 not possible * smp 1 1 Present, last known value (eg: request length) */ struct stktable_key *stktable_fetch_key(struct stktable *t, struct proxy *px, struct session *sess, struct stream *strm, unsigned int opt, struct sample_expr *expr, struct sample *smp) { if (smp) memset(smp, 0, sizeof(*smp)); smp = sample_process(px, sess, strm, opt, expr, smp); if (!smp) return NULL; if ((smp->flags & SMP_F_MAY_CHANGE) && !(opt & SMP_OPT_FINAL)) return NULL; /* we can only use stable samples */ return smp_to_stkey(smp, t); } /* * Returns 1 if sample expression result can be converted to table key of * type , otherwise zero. Used in configuration check. */ int stktable_compatible_sample(struct sample_expr *expr, unsigned long table_type) { int out_type; if (table_type >= SMP_TYPES || !stktable_types[table_type].kw) return 0; out_type = smp_expr_output_type(expr); /* Convert sample. */ if (!sample_casts[out_type][table_type]) return 0; return 1; } /* Extra data types processing : after the last one, some room may remain * before STKTABLE_DATA_TYPES that may be used to register extra data types * at run time. */ struct stktable_data_type stktable_data_types[STKTABLE_DATA_TYPES] = { [STKTABLE_DT_SERVER_ID] = { .name = "server_id", .std_type = STD_T_SINT }, [STKTABLE_DT_GPT0] = { .name = "gpt0", .std_type = STD_T_UINT }, [STKTABLE_DT_GPC0] = { .name = "gpc0", .std_type = STD_T_UINT }, [STKTABLE_DT_GPC0_RATE] = { .name = "gpc0_rate", .std_type = STD_T_FRQP, .arg_type = ARG_T_DELAY }, [STKTABLE_DT_CONN_CNT] = { .name = "conn_cnt", .std_type = STD_T_UINT }, [STKTABLE_DT_CONN_RATE] = { .name = "conn_rate", .std_type = STD_T_FRQP, .arg_type = ARG_T_DELAY }, [STKTABLE_DT_CONN_CUR] = { .name = "conn_cur", .std_type = STD_T_UINT, .is_local = 1 }, [STKTABLE_DT_SESS_CNT] = { .name = "sess_cnt", .std_type = STD_T_UINT }, [STKTABLE_DT_SESS_RATE] = { .name = "sess_rate", .std_type = STD_T_FRQP, .arg_type = ARG_T_DELAY }, [STKTABLE_DT_HTTP_REQ_CNT] = { .name = "http_req_cnt", .std_type = STD_T_UINT }, [STKTABLE_DT_HTTP_REQ_RATE] = { .name = "http_req_rate", .std_type = STD_T_FRQP, .arg_type = ARG_T_DELAY }, [STKTABLE_DT_HTTP_ERR_CNT] = { .name = "http_err_cnt", .std_type = STD_T_UINT }, [STKTABLE_DT_HTTP_ERR_RATE] = { .name = "http_err_rate", .std_type = STD_T_FRQP, .arg_type = ARG_T_DELAY }, [STKTABLE_DT_BYTES_IN_CNT] = { .name = "bytes_in_cnt", .std_type = STD_T_ULL }, [STKTABLE_DT_BYTES_IN_RATE] = { .name = "bytes_in_rate", .std_type = STD_T_FRQP, .arg_type = ARG_T_DELAY }, [STKTABLE_DT_BYTES_OUT_CNT] = { .name = "bytes_out_cnt", .std_type = STD_T_ULL }, [STKTABLE_DT_BYTES_OUT_RATE]= { .name = "bytes_out_rate", .std_type = STD_T_FRQP, .arg_type = ARG_T_DELAY }, [STKTABLE_DT_GPC1] = { .name = "gpc1", .std_type = STD_T_UINT }, [STKTABLE_DT_GPC1_RATE] = { .name = "gpc1_rate", .std_type = STD_T_FRQP, .arg_type = ARG_T_DELAY }, [STKTABLE_DT_SERVER_KEY] = { .name = "server_key", .std_type = STD_T_DICT }, [STKTABLE_DT_HTTP_FAIL_CNT] = { .name = "http_fail_cnt", .std_type = STD_T_UINT }, [STKTABLE_DT_HTTP_FAIL_RATE]= { .name = "http_fail_rate", .std_type = STD_T_FRQP, .arg_type = ARG_T_DELAY }, [STKTABLE_DT_GPT] = { .name = "gpt", .std_type = STD_T_UINT, .is_array = 1 }, [STKTABLE_DT_GPC] = { .name = "gpc", .std_type = STD_T_UINT, .is_array = 1 }, [STKTABLE_DT_GPC_RATE] = { .name = "gpc_rate", .std_type = STD_T_FRQP, .is_array = 1, .arg_type = ARG_T_DELAY }, }; /* Registers stick-table extra data type with index , name , type * and arg type . If the index is negative, the next free * index is automatically allocated. The allocated index is returned, or -1 if * no free index was found or was already registered. The is used * directly as a pointer, so if it's not stable, the caller must allocate it. */ int stktable_register_data_store(int idx, const char *name, int std_type, int arg_type) { if (idx < 0) { for (idx = 0; idx < STKTABLE_DATA_TYPES; idx++) { if (!stktable_data_types[idx].name) break; if (strcmp(stktable_data_types[idx].name, name) == 0) return -1; } } if (idx >= STKTABLE_DATA_TYPES) return -1; if (stktable_data_types[idx].name != NULL) return -1; stktable_data_types[idx].name = name; stktable_data_types[idx].std_type = std_type; stktable_data_types[idx].arg_type = arg_type; return idx; } /* * Returns the data type number for the stktable_data_type whose name is , * or <0 if not found. */ int stktable_get_data_type(char *name) { int type; for (type = 0; type < STKTABLE_DATA_TYPES; type++) { if (!stktable_data_types[type].name) continue; if (strcmp(name, stktable_data_types[type].name) == 0) return type; } /* For backwards compatibility */ if (strcmp(name, "server_name") == 0) return STKTABLE_DT_SERVER_KEY; return -1; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns true if found, false otherwise. The input * type is STR so that input samples are converted to string (since all types * can be converted to strings), then the function casts the string again into * the table's type. This is a double conversion, but in the future we might * support automatic input types to perform the cast on the fly. */ static int sample_conv_in_table(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->data.type = SMP_T_BOOL; smp->data.u.sint = !!ts; smp->flags = SMP_F_VOL_TEST; stktable_release(t, ts); return 1; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the data rate received from clients in bytes/s * if the key is present in the table, otherwise zero, so that comparisons can * be easily performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_bytes_in_rate(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_BYTES_IN_RATE); if (ptr) smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), t->data_arg[STKTABLE_DT_BYTES_IN_RATE].u); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the cumulated number of connections for the key * if the key is present in the table, otherwise zero, so that comparisons can * be easily performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_conn_cnt(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_CNT); if (ptr) smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the number of concurrent connections for the * key if the key is present in the table, otherwise zero, so that comparisons * can be easily performed. If the inspected parameter is not stored in the * table, is returned. */ static int sample_conv_table_conn_cur(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_CUR); if (ptr) smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the rate of incoming connections from the key * if the key is present in the table, otherwise zero, so that comparisons can * be easily performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_conn_rate(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_RATE); if (ptr) smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), t->data_arg[STKTABLE_DT_CONN_RATE].u); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the expiration delay for the key if the key is * present in the table, otherwise the default value provided as second argument * if any, if not (no default value), is returned. */ static int sample_conv_table_expire(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) { /* key not present */ if (arg_p[1].type == ARGT_STOP) return 0; /* default value */ smp->data.u.sint = arg_p[1].data.sint; return 1; } smp->data.u.sint = tick_remain(now_ms, ts->expire); stktable_release(t, ts); return 1; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the time the key remains unused if the key is * present in the table, otherwise the default value provided as second argument * if any, if not (no default value), is returned. */ static int sample_conv_table_idle(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) { /* key not present */ if (arg_p[1].type == ARGT_STOP) return 0; /* default value */ smp->data.u.sint = arg_p[1].data.sint; return 1; } smp->data.u.sint = tick_remain(tick_remain(now_ms, ts->expire), t->expire); stktable_release(t, ts); return 1; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the data rate sent to clients in bytes/s * if the key is present in the table, otherwise zero, so that comparisons can * be easily performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_bytes_out_rate(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_BYTES_OUT_RATE); if (ptr) smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), t->data_arg[STKTABLE_DT_BYTES_OUT_RATE].u); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg_p(1), and looks * it up into this table. Returns the value of the GPT[arg_p(0)] tag for the key * if the key is present in the table, otherwise false, so that comparisons can * be easily performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_gpt(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; unsigned int idx; idx = arg_p[0].data.sint; t = arg_p[1].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr_idx(t, ts, STKTABLE_DT_GPT, idx); if (ptr) smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the value of the GPT0 tag for the key * if the key is present in the table, otherwise false, so that comparisons can * be easily performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_gpt0(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_GPT0); if (!ptr) ptr = stktable_data_ptr_idx(t, ts, STKTABLE_DT_GPT, 0); if (ptr) smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg_p(1), and looks * it up into this table. Returns the value of the GPC[arg_p(0)] counter for the key * if the key is present in the table, otherwise zero, so that comparisons can * be easily performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_gpc(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; unsigned int idx; idx = arg_p[0].data.sint; t = arg_p[1].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr_idx(t, ts, STKTABLE_DT_GPC, idx); if (ptr) smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg_p(1), and looks * it up into this table. Returns the event rate of the GPC[arg_p(0)] counter * for the key if the key is present in the table, otherwise zero, so that * comparisons can be easily performed. If the inspected parameter is not * stored in the table, is returned. */ static int sample_conv_table_gpc_rate(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; unsigned int idx; idx = arg_p[0].data.sint; t = arg_p[1].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr_idx(t, ts, STKTABLE_DT_GPC_RATE, idx); if (ptr) smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), t->data_arg[STKTABLE_DT_GPC_RATE].u); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the value of the GPC0 counter for the key * if the key is present in the table, otherwise zero, so that comparisons can * be easily performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_gpc0(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_GPC0); if (!ptr) { /* fallback on the gpc array */ ptr = stktable_data_ptr_idx(t, ts, STKTABLE_DT_GPC, 0); } if (ptr) smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the event rate of the GPC0 counter for the key * if the key is present in the table, otherwise zero, so that comparisons can * be easily performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_gpc0_rate(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_GPC0_RATE); if (ptr) smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), t->data_arg[STKTABLE_DT_GPC0_RATE].u); else { /* fallback on the gpc array */ ptr = stktable_data_ptr_idx(t, ts, STKTABLE_DT_GPC_RATE, 0); if (ptr) smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), t->data_arg[STKTABLE_DT_GPC_RATE].u); } stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the value of the GPC1 counter for the key * if the key is present in the table, otherwise zero, so that comparisons can * be easily performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_gpc1(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_GPC1); if (!ptr) { /* fallback on the gpc array */ ptr = stktable_data_ptr_idx(t, ts, STKTABLE_DT_GPC, 1); } if (ptr) smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the event rate of the GPC1 counter for the key * if the key is present in the table, otherwise zero, so that comparisons can * be easily performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_gpc1_rate(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_GPC1_RATE); if (ptr) smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), t->data_arg[STKTABLE_DT_GPC1_RATE].u); else { /* fallback on the gpc array */ ptr = stktable_data_ptr_idx(t, ts, STKTABLE_DT_GPC_RATE, 1); if (ptr) smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), t->data_arg[STKTABLE_DT_GPC_RATE].u); } stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the cumulated number of HTTP request errors * for the key if the key is present in the table, otherwise zero, so that * comparisons can be easily performed. If the inspected parameter is not stored * in the table, is returned. */ static int sample_conv_table_http_err_cnt(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_HTTP_ERR_CNT); if (ptr) smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the HTTP request error rate the key * if the key is present in the table, otherwise zero, so that comparisons can * be easily performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_http_err_rate(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_HTTP_ERR_RATE); if (ptr) smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), t->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the cumulated number of HTTP response failures * for the key if the key is present in the table, otherwise zero, so that * comparisons can be easily performed. If the inspected parameter is not stored * in the table, is returned. */ static int sample_conv_table_http_fail_cnt(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_HTTP_FAIL_CNT); if (ptr) smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the HTTP response failure rate for the key * if the key is present in the table, otherwise zero, so that comparisons can * be easily performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_http_fail_rate(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_HTTP_FAIL_RATE); if (ptr) smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), t->data_arg[STKTABLE_DT_HTTP_FAIL_RATE].u); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the cumulated number of HTTP request for the * key if the key is present in the table, otherwise zero, so that comparisons * can be easily performed. If the inspected parameter is not stored in the * table, is returned. */ static int sample_conv_table_http_req_cnt(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_HTTP_REQ_CNT); if (ptr) smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the HTTP request rate the key if the key is * present in the table, otherwise zero, so that comparisons can be easily * performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_http_req_rate(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_HTTP_REQ_RATE); if (ptr) smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), t->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the volume of datareceived from clients in kbytes * if the key is present in the table, otherwise zero, so that comparisons can * be easily performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_kbytes_in(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_BYTES_IN_CNT); if (ptr) smp->data.u.sint = stktable_data_cast(ptr, std_t_ull) >> 10; stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the volume of data sent to clients in kbytes * if the key is present in the table, otherwise zero, so that comparisons can * be easily performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_kbytes_out(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_BYTES_OUT_CNT); if (ptr) smp->data.u.sint = stktable_data_cast(ptr, std_t_ull) >> 10; stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the server ID associated with the key if the * key is present in the table, otherwise zero, so that comparisons can be * easily performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_server_id(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_SERVER_ID); if (ptr) smp->data.u.sint = stktable_data_cast(ptr, std_t_sint); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the cumulated number of sessions for the * key if the key is present in the table, otherwise zero, so that comparisons * can be easily performed. If the inspected parameter is not stored in the * table, is returned. */ static int sample_conv_table_sess_cnt(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_SESS_CNT); if (ptr) smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the session rate the key if the key is * present in the table, otherwise zero, so that comparisons can be easily * performed. If the inspected parameter is not stored in the table, * is returned. */ static int sample_conv_table_sess_rate(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; void *ptr; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) /* key not present */ return 1; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_SESS_RATE); if (ptr) smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), t->data_arg[STKTABLE_DT_SESS_RATE].u); stktable_release(t, ts); return !!ptr; } /* Casts sample to the type of the table specified in arg(0), and looks * it up into this table. Returns the amount of concurrent connections tracking * the same key if the key is present in the table, otherwise zero, so that * comparisons can be easily performed. If the inspected parameter is not * stored in the table, is returned. */ static int sample_conv_table_trackers(const struct arg *arg_p, struct sample *smp, void *private) { struct stktable *t; struct stktable_key *key; struct stksess *ts; t = arg_p[0].data.t; key = smp_to_stkey(smp, t); if (!key) return 0; ts = stktable_lookup_key(t, key); smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!ts) return 1; smp->data.u.sint = ts->ref_cnt; stktable_release(t, ts); return 1; } /* This function increments the gpc counter at index 'rule->arg.gpc.idx' of the * array on the tracksc counter of index 'rule->arg.gpc.sc' stored into the * or directly in the session if is set to NULL * * This function always returns ACT_RET_CONT and parameter flags is unused. */ static enum act_return action_inc_gpc(struct act_rule *rule, struct proxy *px, struct session *sess, struct stream *s, int flags) { struct stksess *ts; struct stkctr *stkctr; /* Extract the stksess, return OK if no stksess available. */ if (s) stkctr = &s->stkctr[rule->arg.gpc.sc]; else stkctr = &sess->stkctr[rule->arg.gpc.sc]; ts = stkctr_entry(stkctr); if (ts) { void *ptr1, *ptr2; /* First, update gpc_rate if it's tracked. Second, update its gpc if tracked. */ ptr1 = stktable_data_ptr_idx(stkctr->table, ts, STKTABLE_DT_GPC_RATE, rule->arg.gpc.idx); ptr2 = stktable_data_ptr_idx(stkctr->table, ts, STKTABLE_DT_GPC, rule->arg.gpc.idx); if (ptr1 || ptr2) { HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock); if (ptr1) update_freq_ctr_period(&stktable_data_cast(ptr1, std_t_frqp), stkctr->table->data_arg[STKTABLE_DT_GPC_RATE].u, 1); if (ptr2) stktable_data_cast(ptr2, std_t_uint)++; HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); /* If data was modified, we need to touch to re-schedule sync */ stktable_touch_local(stkctr->table, ts, 0); } } return ACT_RET_CONT; } /* Same as action_inc_gpc() but for gpc0 only */ static enum act_return action_inc_gpc0(struct act_rule *rule, struct proxy *px, struct session *sess, struct stream *s, int flags) { struct stksess *ts; struct stkctr *stkctr; unsigned int period = 0; /* Extract the stksess, return OK if no stksess available. */ if (s) stkctr = &s->stkctr[rule->arg.gpc.sc]; else stkctr = &sess->stkctr[rule->arg.gpc.sc]; ts = stkctr_entry(stkctr); if (ts) { void *ptr1, *ptr2; /* First, update gpc0_rate if it's tracked. Second, update its gpc0 if tracked. */ ptr1 = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_GPC0_RATE); if (ptr1) { period = stkctr->table->data_arg[STKTABLE_DT_GPC0_RATE].u; } else { /* fallback on the gpc array */ ptr1 = stktable_data_ptr_idx(stkctr->table, ts, STKTABLE_DT_GPC_RATE, 0); if (ptr1) period = stkctr->table->data_arg[STKTABLE_DT_GPC_RATE].u; } ptr2 = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_GPC0); if (!ptr2) { /* fallback on the gpc array */ ptr2 = stktable_data_ptr_idx(stkctr->table, ts, STKTABLE_DT_GPC, 0); } if (ptr1 || ptr2) { HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock); if (ptr1) update_freq_ctr_period(&stktable_data_cast(ptr1, std_t_frqp), period, 1); if (ptr2) stktable_data_cast(ptr2, std_t_uint)++; HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); /* If data was modified, we need to touch to re-schedule sync */ stktable_touch_local(stkctr->table, ts, 0); } } return ACT_RET_CONT; } /* Same as action_inc_gpc() but for gpc1 only */ static enum act_return action_inc_gpc1(struct act_rule *rule, struct proxy *px, struct session *sess, struct stream *s, int flags) { struct stksess *ts; struct stkctr *stkctr; unsigned int period = 0; /* Extract the stksess, return OK if no stksess available. */ if (s) stkctr = &s->stkctr[rule->arg.gpc.sc]; else stkctr = &sess->stkctr[rule->arg.gpc.sc]; ts = stkctr_entry(stkctr); if (ts) { void *ptr1, *ptr2; /* First, update gpc1_rate if it's tracked. Second, update its gpc1 if tracked. */ ptr1 = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_GPC1_RATE); if (ptr1) { period = stkctr->table->data_arg[STKTABLE_DT_GPC1_RATE].u; } else { /* fallback on the gpc array */ ptr1 = stktable_data_ptr_idx(stkctr->table, ts, STKTABLE_DT_GPC_RATE, 1); if (ptr1) period = stkctr->table->data_arg[STKTABLE_DT_GPC_RATE].u; } ptr2 = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_GPC1); if (!ptr2) { /* fallback on the gpc array */ ptr2 = stktable_data_ptr_idx(stkctr->table, ts, STKTABLE_DT_GPC, 1); } if (ptr1 || ptr2) { HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock); if (ptr1) update_freq_ctr_period(&stktable_data_cast(ptr1, std_t_frqp), period, 1); if (ptr2) stktable_data_cast(ptr2, std_t_uint)++; HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); /* If data was modified, we need to touch to re-schedule sync */ stktable_touch_local(stkctr->table, ts, 0); } } return ACT_RET_CONT; } /* This function is a common parser for actions incrementing the GPC * (General Purpose Counters). It understands the formats: * * sc-inc-gpc(,) * sc-inc-gpc0([]) * sc-inc-gpc1([]) * * It returns ACT_RET_PRS_ERR if fails and is filled with an error * message. Otherwise it returns ACT_RET_PRS_OK. */ static enum act_parse_ret parse_inc_gpc(const char **args, int *arg, struct proxy *px, struct act_rule *rule, char **err) { const char *cmd_name = args[*arg-1]; char *error; cmd_name += strlen("sc-inc-gpc"); if (*cmd_name == '(') { cmd_name++; /* skip the '(' */ rule->arg.gpc.idx = strtoul(cmd_name, &error, 10); /* Convert stick table id. */ if (*error != ',') { memprintf(err, "Missing gpc ID '%s'. Expects sc-inc-gpc(,)", args[*arg-1]); return ACT_RET_PRS_ERR; } else { cmd_name = error + 1; /* skip the ',' */ rule->arg.gpc.sc = strtol(cmd_name, &error, 10); /* Convert stick table id. */ if (*error != ')') { memprintf(err, "invalid stick table track ID '%s'. Expects sc-inc-gpc(,)", args[*arg-1]); return ACT_RET_PRS_ERR; } if (rule->arg.gpc.sc >= MAX_SESS_STKCTR) { memprintf(err, "invalid stick table track ID '%s'. The max allowed ID is %d", args[*arg-1], MAX_SESS_STKCTR-1); return ACT_RET_PRS_ERR; } } rule->action_ptr = action_inc_gpc; } else if (*cmd_name == '0' ||*cmd_name == '1') { char c = *cmd_name; cmd_name++; if (*cmd_name == '\0') { /* default stick table id. */ rule->arg.gpc.sc = 0; } else { /* parse the stick table id. */ if (*cmd_name != '(') { memprintf(err, "invalid stick table track ID. Expects %s()", args[*arg-1]); return ACT_RET_PRS_ERR; } cmd_name++; /* jump the '(' */ rule->arg.gpc.sc = strtol(cmd_name, &error, 10); /* Convert stick table id. */ if (*error != ')') { memprintf(err, "invalid stick table track ID. Expects %s()", args[*arg-1]); return ACT_RET_PRS_ERR; } if (rule->arg.gpc.sc >= MAX_SESS_STKCTR) { memprintf(err, "invalid stick table track ID. The max allowed ID is %d", MAX_SESS_STKCTR-1); return ACT_RET_PRS_ERR; } } if (c == '1') rule->action_ptr = action_inc_gpc1; else rule->action_ptr = action_inc_gpc0; } else { /* default stick table id. */ memprintf(err, "invalid gpc ID '%s'. Expects sc-inc-gpc(,)", args[*arg-1]); return ACT_RET_PRS_ERR; } rule->action = ACT_CUSTOM; return ACT_RET_PRS_OK; } /* This function sets the gpt at index 'rule->arg.gpt.idx' of the array on the * tracksc counter of index 'rule->arg.gpt.sc' stored into the or * directly in the session if is set to NULL. This gpt is * set to the value computed by the expression 'rule->arg.gpt.expr' or if * 'rule->arg.gpt.expr' is null directly to the value of 'rule->arg.gpt.value'. * * This function always returns ACT_RET_CONT and parameter flags is unused. */ static enum act_return action_set_gpt(struct act_rule *rule, struct proxy *px, struct session *sess, struct stream *s, int flags) { void *ptr; struct stksess *ts; struct stkctr *stkctr; unsigned int value = 0; struct sample *smp; int smp_opt_dir; /* Extract the stksess, return OK if no stksess available. */ if (s) stkctr = &s->stkctr[rule->arg.gpt.sc]; else stkctr = &sess->stkctr[rule->arg.gpt.sc]; ts = stkctr_entry(stkctr); if (!ts) return ACT_RET_CONT; /* Store the sample in the required sc, and ignore errors. */ ptr = stktable_data_ptr_idx(stkctr->table, ts, STKTABLE_DT_GPT, rule->arg.gpt.idx); if (ptr) { if (!rule->arg.gpt.expr) value = (unsigned int)(rule->arg.gpt.value); else { switch (rule->from) { case ACT_F_TCP_REQ_SES: smp_opt_dir = SMP_OPT_DIR_REQ; break; case ACT_F_TCP_REQ_CNT: smp_opt_dir = SMP_OPT_DIR_REQ; break; case ACT_F_TCP_RES_CNT: smp_opt_dir = SMP_OPT_DIR_RES; break; case ACT_F_HTTP_REQ: smp_opt_dir = SMP_OPT_DIR_REQ; break; case ACT_F_HTTP_RES: smp_opt_dir = SMP_OPT_DIR_RES; break; default: send_log(px, LOG_ERR, "stick table: internal error while setting gpt%u.", rule->arg.gpt.idx); if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) ha_alert("stick table: internal error while executing setting gpt%u.\n", rule->arg.gpt.idx); return ACT_RET_CONT; } /* Fetch and cast the expression. */ smp = sample_fetch_as_type(px, sess, s, smp_opt_dir|SMP_OPT_FINAL, rule->arg.gpt.expr, SMP_T_SINT); if (!smp) { send_log(px, LOG_WARNING, "stick table: invalid expression or data type while setting gpt%u.", rule->arg.gpt.idx); if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) ha_alert("stick table: invalid expression or data type while setting gpt%u.\n", rule->arg.gpt.idx); return ACT_RET_CONT; } value = (unsigned int)(smp->data.u.sint); } HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock); stktable_data_cast(ptr, std_t_uint) = value; HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); stktable_touch_local(stkctr->table, ts, 0); } return ACT_RET_CONT; } /* Always returns 1. */ static enum act_return action_set_gpt0(struct act_rule *rule, struct proxy *px, struct session *sess, struct stream *s, int flags) { void *ptr; struct stksess *ts; struct stkctr *stkctr; unsigned int value = 0; struct sample *smp; int smp_opt_dir; /* Extract the stksess, return OK if no stksess available. */ if (s) stkctr = &s->stkctr[rule->arg.gpt.sc]; else stkctr = &sess->stkctr[rule->arg.gpt.sc]; ts = stkctr_entry(stkctr); if (!ts) return ACT_RET_CONT; /* Store the sample in the required sc, and ignore errors. */ ptr = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_GPT0); if (!ptr) ptr = stktable_data_ptr_idx(stkctr->table, ts, STKTABLE_DT_GPT, 0); if (ptr) { if (!rule->arg.gpt.expr) value = (unsigned int)(rule->arg.gpt.value); else { switch (rule->from) { case ACT_F_TCP_REQ_SES: smp_opt_dir = SMP_OPT_DIR_REQ; break; case ACT_F_TCP_REQ_CNT: smp_opt_dir = SMP_OPT_DIR_REQ; break; case ACT_F_TCP_RES_CNT: smp_opt_dir = SMP_OPT_DIR_RES; break; case ACT_F_HTTP_REQ: smp_opt_dir = SMP_OPT_DIR_REQ; break; case ACT_F_HTTP_RES: smp_opt_dir = SMP_OPT_DIR_RES; break; default: send_log(px, LOG_ERR, "stick table: internal error while setting gpt0."); if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) ha_alert("stick table: internal error while executing setting gpt0.\n"); return ACT_RET_CONT; } /* Fetch and cast the expression. */ smp = sample_fetch_as_type(px, sess, s, smp_opt_dir|SMP_OPT_FINAL, rule->arg.gpt.expr, SMP_T_SINT); if (!smp) { send_log(px, LOG_WARNING, "stick table: invalid expression or data type while setting gpt0."); if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) ha_alert("stick table: invalid expression or data type while setting gpt0.\n"); return ACT_RET_CONT; } value = (unsigned int)(smp->data.u.sint); } HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock); stktable_data_cast(ptr, std_t_uint) = value; HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); stktable_touch_local(stkctr->table, ts, 0); } return ACT_RET_CONT; } /* This function is a parser for the "sc-set-gpt" and "sc-set-gpt0" actions. * It understands the formats: * * sc-set-gpt(,) * sc-set-gpt0() * * It returns ACT_RET_PRS_ERR if fails and is filled with an error message. * Otherwise, it returns ACT_RET_PRS_OK and the variable 'rule->arg.gpt.expr' * is filled with the pointer to the expression to execute or NULL if the arg * is directly an integer stored into 'rule->arg.gpt.value'. */ static enum act_parse_ret parse_set_gpt(const char **args, int *arg, struct proxy *px, struct act_rule *rule, char **err) { const char *cmd_name = args[*arg-1]; char *error; int smp_val; cmd_name += strlen("sc-set-gpt"); if (*cmd_name == '(') { cmd_name++; /* skip the '(' */ rule->arg.gpt.idx = strtoul(cmd_name, &error, 10); /* Convert stick table id. */ if (*error != ',') { memprintf(err, "Missing gpt ID '%s'. Expects sc-set-gpt(,)", args[*arg-1]); return ACT_RET_PRS_ERR; } else { cmd_name = error + 1; /* skip the ',' */ rule->arg.gpt.sc = strtol(cmd_name, &error, 10); /* Convert stick table id. */ if (*error != ')') { memprintf(err, "invalid stick table track ID '%s'. Expects sc-set-gpt(,)", args[*arg-1]); return ACT_RET_PRS_ERR; } if (rule->arg.gpt.sc >= MAX_SESS_STKCTR) { memprintf(err, "invalid stick table track ID '%s'. The max allowed ID is %d", args[*arg-1], MAX_SESS_STKCTR-1); return ACT_RET_PRS_ERR; } } rule->action_ptr = action_set_gpt; } else if (*cmd_name == '0') { cmd_name++; if (*cmd_name == '\0') { /* default stick table id. */ rule->arg.gpt.sc = 0; } else { /* parse the stick table id. */ if (*cmd_name != '(') { memprintf(err, "invalid stick table track ID '%s'. Expects sc-set-gpt0()", args[*arg-1]); return ACT_RET_PRS_ERR; } cmd_name++; /* jump the '(' */ rule->arg.gpt.sc = strtol(cmd_name, &error, 10); /* Convert stick table id. */ if (*error != ')') { memprintf(err, "invalid stick table track ID '%s'. Expects sc-set-gpt0()", args[*arg-1]); return ACT_RET_PRS_ERR; } if (rule->arg.gpt.sc >= MAX_SESS_STKCTR) { memprintf(err, "invalid stick table track ID '%s'. The max allowed ID is %d", args[*arg-1], MAX_SESS_STKCTR-1); return ACT_RET_PRS_ERR; } } rule->action_ptr = action_set_gpt0; } else { /* default stick table id. */ memprintf(err, "invalid gpt ID '%s'. Expects sc-set-gpt(,)", args[*arg-1]); return ACT_RET_PRS_ERR; } /* value may be either an integer or an expression */ rule->arg.gpt.expr = NULL; rule->arg.gpt.value = strtol(args[*arg], &error, 10); if (*error == '\0') { /* valid integer, skip it */ (*arg)++; } else { rule->arg.gpt.expr = sample_parse_expr((char **)args, arg, px->conf.args.file, px->conf.args.line, err, &px->conf.args, NULL); if (!rule->arg.gpt.expr) return ACT_RET_PRS_ERR; switch (rule->from) { case ACT_F_TCP_REQ_SES: smp_val = SMP_VAL_FE_SES_ACC; break; case ACT_F_TCP_REQ_CNT: smp_val = SMP_VAL_FE_REQ_CNT; break; case ACT_F_TCP_RES_CNT: smp_val = SMP_VAL_BE_RES_CNT; break; case ACT_F_HTTP_REQ: smp_val = SMP_VAL_FE_HRQ_HDR; break; case ACT_F_HTTP_RES: smp_val = SMP_VAL_BE_HRS_HDR; break; default: memprintf(err, "internal error, unexpected rule->from=%d, please report this bug!", rule->from); return ACT_RET_PRS_ERR; } if (!(rule->arg.gpt.expr->fetch->val & smp_val)) { memprintf(err, "fetch method '%s' extracts information from '%s', none of which is available here", args[*arg-1], sample_src_names(rule->arg.gpt.expr->fetch->use)); free(rule->arg.gpt.expr); return ACT_RET_PRS_ERR; } } rule->action = ACT_CUSTOM; return ACT_RET_PRS_OK; } /* set temp integer to the number of used entries in the table pointed to by expr. * Accepts exactly 1 argument of type table. */ static int smp_fetch_table_cnt(const struct arg *args, struct sample *smp, const char *kw, void *private) { smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = args->data.t->current; return 1; } /* set temp integer to the number of free entries in the table pointed to by expr. * Accepts exactly 1 argument of type table. */ static int smp_fetch_table_avl(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stktable *t; t = args->data.t; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = t->size - t->current; return 1; } /* Returns a pointer to a stkctr depending on the fetch keyword name. * It is designed to be called as sc[0-9]_* sc_* or src_* exclusively. * sc[0-9]_* will return a pointer to the respective field in the * stream . sc_* requires an UINT argument specifying the stick * counter number. src_* will fill a locally allocated structure with * the table and entry corresponding to what is specified with src_*. * NULL may be returned if the designated stkctr is not tracked. For * the sc_* and sc[0-9]_* forms, an optional table argument may be * passed. When present, the currently tracked key is then looked up * in the specified table instead of the current table. The purpose is * to be able to convert multiple values per key (eg: have gpc0 from * multiple tables). is allowed to be NULL, in which case only * the session will be consulted. */ struct stkctr * smp_fetch_sc_stkctr(struct session *sess, struct stream *strm, const struct arg *args, const char *kw, struct stkctr *stkctr) { struct stkctr *stkptr; struct stksess *stksess; unsigned int num = kw[2] - '0'; int arg = 0; if (num == '_' - '0') { /* sc_* variant, args[0] = ctr# (mandatory) */ num = args[arg++].data.sint; } else if (num > 9) { /* src_* variant, args[0] = table */ struct stktable_key *key; struct connection *conn = objt_conn(sess->origin); struct sample smp; if (!conn) return NULL; /* Fetch source address in a sample. */ smp.px = NULL; smp.sess = sess; smp.strm = strm; if (!smp_fetch_src || !smp_fetch_src(empty_arg_list, &smp, "src", NULL)) return NULL; /* Converts into key. */ key = smp_to_stkey(&smp, args->data.t); if (!key) return NULL; stkctr->table = args->data.t; stkctr_set_entry(stkctr, stktable_lookup_key(stkctr->table, key)); return stkctr; } /* Here, contains the counter number from 0 to 9 for * the sc[0-9]_ form, or even higher using sc_(num) if needed. * args[arg] is the first optional argument. We first lookup the * ctr form the stream, then from the session if it was not there. * But we must be sure the counter does not exceed MAX_SESS_STKCTR. */ if (num >= MAX_SESS_STKCTR) return NULL; if (strm) stkptr = &strm->stkctr[num]; if (!strm || !stkctr_entry(stkptr)) { stkptr = &sess->stkctr[num]; if (!stkctr_entry(stkptr)) return NULL; } stksess = stkctr_entry(stkptr); if (!stksess) return NULL; if (unlikely(args[arg].type == ARGT_TAB)) { /* an alternate table was specified, let's look up the same key there */ stkctr->table = args[arg].data.t; stkctr_set_entry(stkctr, stktable_lookup(stkctr->table, stksess)); return stkctr; } return stkptr; } /* same as smp_fetch_sc_stkctr() but dedicated to src_* and can create * the entry if it doesn't exist yet. This is needed for a few fetch * functions which need to create an entry, such as src_inc_gpc* and * src_clr_gpc*. */ struct stkctr * smp_create_src_stkctr(struct session *sess, struct stream *strm, const struct arg *args, const char *kw, struct stkctr *stkctr) { struct stktable_key *key; struct connection *conn = objt_conn(sess->origin); struct sample smp; if (strncmp(kw, "src_", 4) != 0) return NULL; if (!conn) return NULL; /* Fetch source address in a sample. */ smp.px = NULL; smp.sess = sess; smp.strm = strm; if (!smp_fetch_src || !smp_fetch_src(empty_arg_list, &smp, "src", NULL)) return NULL; /* Converts into key. */ key = smp_to_stkey(&smp, args->data.t); if (!key) return NULL; stkctr->table = args->data.t; stkctr_set_entry(stkctr, stktable_get_entry(stkctr->table, key)); return stkctr; } /* set return a boolean indicating if the requested stream counter is * currently being tracked or not. * Supports being called as "sc[0-9]_tracked" only. */ static int smp_fetch_sc_tracked(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_BOOL; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); smp->data.u.sint = !!stkctr; /* release the ref count */ if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 1; } /* set to the General Purpose Tag of index set as first arg * to value from the stream's tracked frontend counters or from the src. * Supports being called as "sc_get_gpt(,[,])" or * "src_get_gpt([,
])" only. Value zero is returned if * the key is new or gpt is not stored. */ static int smp_fetch_sc_get_gpt(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; unsigned int idx; idx = args[0].data.sint; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args + 1, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr)) { void *ptr; ptr = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPT, idx); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the General Purpose Flag 0 value from the stream's tracked * frontend counters or from the src. * Supports being called as "sc[0-9]_get_gpc0" or "src_get_gpt0" only. Value * zero is returned if the key is new. */ static int smp_fetch_sc_get_gpt0(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr)) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPT0); if (!ptr) ptr = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPT, 0); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the GPC[args(0)]'s value from the stream's tracked * frontend counters or from the src. * Supports being called as "sc_get_gpc(,[,
])" or * "src_get_gpc([,
])" only. Value * Value zero is returned if the key is new or gpc is not stored. */ static int smp_fetch_sc_get_gpc(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; unsigned int idx; idx = args[0].data.sint; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args + 1, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC, idx); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the General Purpose Counter 0 value from the stream's tracked * frontend counters or from the src. * Supports being called as "sc[0-9]_get_gpc0" or "src_get_gpc0" only. Value * zero is returned if the key is new. */ static int smp_fetch_sc_get_gpc0(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC0); if (!ptr) { /* fallback on the gpc array */ ptr = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC, 0); } if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the General Purpose Counter 1 value from the stream's tracked * frontend counters or from the src. * Supports being called as "sc[0-9]_get_gpc1" or "src_get_gpc1" only. Value * zero is returned if the key is new. */ static int smp_fetch_sc_get_gpc1(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC1); if (!ptr) { /* fallback on the gpc array */ ptr = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC, 1); } if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the GPC[args(0)]'s event rate from the stream's * tracked frontend counters or from the src. * Supports being called as "sc_gpc_rate(,[,[,
])" only. * Value zero is returned if the key is new or gpc_rate is not stored. */ static int smp_fetch_sc_gpc_rate(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; unsigned int idx; idx = args[0].data.sint; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args + 1, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC_RATE, idx); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), stkctr->table->data_arg[STKTABLE_DT_GPC_RATE].u); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the General Purpose Counter 0's event rate from the stream's * tracked frontend counters or from the src. * Supports being called as "sc[0-9]_gpc0_rate" or "src_gpc0_rate" only. * Value zero is returned if the key is new. */ static int smp_fetch_sc_gpc0_rate(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; unsigned int period; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC0_RATE); if (ptr) { period = stkctr->table->data_arg[STKTABLE_DT_GPC0_RATE].u; } else { /* fallback on the gpc array */ ptr = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC_RATE, 0); if (ptr) period = stkctr->table->data_arg[STKTABLE_DT_GPC_RATE].u; } if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), period); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the General Purpose Counter 1's event rate from the stream's * tracked frontend counters or from the src. * Supports being called as "sc[0-9]_gpc1_rate" or "src_gpc1_rate" only. * Value zero is returned if the key is new. */ static int smp_fetch_sc_gpc1_rate(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; unsigned int period; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC1_RATE); if (ptr) { period = stkctr->table->data_arg[STKTABLE_DT_GPC1_RATE].u; } else { /* fallback on the gpc array */ ptr = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC_RATE, 1); if (ptr) period = stkctr->table->data_arg[STKTABLE_DT_GPC_RATE].u; } if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), period); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* Increment the GPC[args(0)] value from the stream's tracked * frontend counters and return it into temp integer. * Supports being called as "sc_inc_gpc(,[,
])" * or "src_inc_gpc([,
])" only. */ static int smp_fetch_sc_inc_gpc(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; unsigned int idx; idx = args[0].data.sint; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args + 1, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!stkctr_entry(stkctr)) stkctr = smp_create_src_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (stkctr && stkctr_entry(stkctr)) { void *ptr1,*ptr2; /* First, update gpc0_rate if it's tracked. Second, update its * gpc0 if tracked. Returns gpc0's value otherwise the curr_ctr. */ ptr1 = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC_RATE, idx); ptr2 = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC, idx); if (ptr1 || ptr2) { HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (ptr1) { update_freq_ctr_period(&stktable_data_cast(ptr1, std_t_frqp), stkctr->table->data_arg[STKTABLE_DT_GPC_RATE].u, 1); smp->data.u.sint = (&stktable_data_cast(ptr1, std_t_frqp))->curr_ctr; } if (ptr2) smp->data.u.sint = ++stktable_data_cast(ptr2, std_t_uint); HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); /* If data was modified, we need to touch to re-schedule sync */ stktable_touch_local(stkctr->table, stkctr_entry(stkctr), (stkctr == &tmpstkctr) ? 1 : 0); } else if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* Increment the General Purpose Counter 0 value from the stream's tracked * frontend counters and return it into temp integer. * Supports being called as "sc[0-9]_inc_gpc0" or "src_inc_gpc0" only. */ static int smp_fetch_sc_inc_gpc0(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; unsigned int period = 0; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!stkctr_entry(stkctr)) stkctr = smp_create_src_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (stkctr && stkctr_entry(stkctr)) { void *ptr1,*ptr2; /* First, update gpc0_rate if it's tracked. Second, update its * gpc0 if tracked. Returns gpc0's value otherwise the curr_ctr. */ ptr1 = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC0_RATE); if (ptr1) { period = stkctr->table->data_arg[STKTABLE_DT_GPC0_RATE].u; } else { /* fallback on the gpc array */ ptr1 = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC_RATE, 0); if (ptr1) period = stkctr->table->data_arg[STKTABLE_DT_GPC_RATE].u; } ptr2 = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC0); if (!ptr2) { /* fallback on the gpc array */ ptr2 = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC, 0); } if (ptr1 || ptr2) { HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (ptr1) { update_freq_ctr_period(&stktable_data_cast(ptr1, std_t_frqp), period, 1); smp->data.u.sint = (&stktable_data_cast(ptr1, std_t_frqp))->curr_ctr; } if (ptr2) smp->data.u.sint = ++stktable_data_cast(ptr2, std_t_uint); HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); /* If data was modified, we need to touch to re-schedule sync */ stktable_touch_local(stkctr->table, stkctr_entry(stkctr), (stkctr == &tmpstkctr) ? 1 : 0); } else if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* Increment the General Purpose Counter 1 value from the stream's tracked * frontend counters and return it into temp integer. * Supports being called as "sc[0-9]_inc_gpc1" or "src_inc_gpc1" only. */ static int smp_fetch_sc_inc_gpc1(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; unsigned int period = 0; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!stkctr_entry(stkctr)) stkctr = smp_create_src_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (stkctr && stkctr_entry(stkctr)) { void *ptr1,*ptr2; /* First, update gpc1_rate if it's tracked. Second, update its * gpc1 if tracked. Returns gpc1's value otherwise the curr_ctr. */ ptr1 = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC1_RATE); if (ptr1) { period = stkctr->table->data_arg[STKTABLE_DT_GPC1_RATE].u; } else { /* fallback on the gpc array */ ptr1 = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC_RATE, 1); if (ptr1) period = stkctr->table->data_arg[STKTABLE_DT_GPC_RATE].u; } ptr2 = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC1); if (!ptr2) { /* fallback on the gpc array */ ptr2 = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC, 1); } if (ptr1 || ptr2) { HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (ptr1) { update_freq_ctr_period(&stktable_data_cast(ptr1, std_t_frqp), period, 1); smp->data.u.sint = (&stktable_data_cast(ptr1, std_t_frqp))->curr_ctr; } if (ptr2) smp->data.u.sint = ++stktable_data_cast(ptr2, std_t_uint); HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); /* If data was modified, we need to touch to re-schedule sync */ stktable_touch_local(stkctr->table, stkctr_entry(stkctr), (stkctr == &tmpstkctr) ? 1 : 0); } else if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* Clear the GPC[args(0)] value from the stream's tracked * frontend counters and return its previous value into temp integer. * Supports being called as "sc_clr_gpc(,[,
])" * or "src_clr_gpc([,
])" only. */ static int smp_fetch_sc_clr_gpc(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; unsigned int idx; idx = args[0].data.sint; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args + 1, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!stkctr_entry(stkctr)) stkctr = smp_create_src_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (stkctr && stkctr_entry(stkctr)) { void *ptr; ptr = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC, idx); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); stktable_data_cast(ptr, std_t_uint) = 0; HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); /* If data was modified, we need to touch to re-schedule sync */ stktable_touch_local(stkctr->table, stkctr_entry(stkctr), (stkctr == &tmpstkctr) ? 1 : 0); } return 1; } /* Clear the General Purpose Counter 0 value from the stream's tracked * frontend counters and return its previous value into temp integer. * Supports being called as "sc[0-9]_clr_gpc0" or "src_clr_gpc0" only. */ static int smp_fetch_sc_clr_gpc0(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!stkctr_entry(stkctr)) stkctr = smp_create_src_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (stkctr && stkctr_entry(stkctr)) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC0); if (!ptr) { /* fallback on the gpc array */ ptr = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC, 0); } if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); stktable_data_cast(ptr, std_t_uint) = 0; HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); /* If data was modified, we need to touch to re-schedule sync */ stktable_touch_local(stkctr->table, stkctr_entry(stkctr), (stkctr == &tmpstkctr) ? 1 : 0); } return 1; } /* Clear the General Purpose Counter 1 value from the stream's tracked * frontend counters and return its previous value into temp integer. * Supports being called as "sc[0-9]_clr_gpc1" or "src_clr_gpc1" only. */ static int smp_fetch_sc_clr_gpc1(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (!stkctr_entry(stkctr)) stkctr = smp_create_src_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (stkctr && stkctr_entry(stkctr)) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC1); if (!ptr) { /* fallback on the gpc array */ ptr = stktable_data_ptr_idx(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC, 1); } if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); stktable_data_cast(ptr, std_t_uint) = 0; HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); /* If data was modified, we need to touch to re-schedule sync */ stktable_touch_local(stkctr->table, stkctr_entry(stkctr), (stkctr == &tmpstkctr) ? 1 : 0); } return 1; } /* set to the cumulated number of connections from the stream's tracked * frontend counters. Supports being called as "sc[0-9]_conn_cnt" or * "src_conn_cnt" only. */ static int smp_fetch_sc_conn_cnt(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_CONN_CNT); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the connection rate from the stream's tracked frontend * counters. Supports being called as "sc[0-9]_conn_rate" or "src_conn_rate" * only. */ static int smp_fetch_sc_conn_rate(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_CONN_RATE); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), stkctr->table->data_arg[STKTABLE_DT_CONN_RATE].u); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set temp integer to the number of connections from the stream's source address * in the table pointed to by expr, after updating it. * Accepts exactly 1 argument of type table. */ static int smp_fetch_src_updt_conn_cnt(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct connection *conn = objt_conn(smp->sess->origin); struct stksess *ts; struct stktable_key *key; void *ptr; struct stktable *t; if (!conn) return 0; /* Fetch source address in a sample. */ if (!smp_fetch_src || !smp_fetch_src(empty_arg_list, smp, "src", NULL)) return 0; /* Converts into key. */ key = smp_to_stkey(smp, args->data.t); if (!key) return 0; t = args->data.t; if ((ts = stktable_get_entry(t, key)) == NULL) /* entry does not exist and could not be created */ return 0; ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_CNT); if (!ptr) { return 0; /* parameter not stored in this table */ } smp->data.type = SMP_T_SINT; HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock); smp->data.u.sint = ++stktable_data_cast(ptr, std_t_uint); HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); smp->flags = SMP_F_VOL_TEST; stktable_touch_local(t, ts, 1); /* Touch was previously performed by stktable_update_key */ return 1; } /* set to the number of concurrent connections from the stream's tracked * frontend counters. Supports being called as "sc[0-9]_conn_cur" or * "src_conn_cur" only. */ static int smp_fetch_sc_conn_cur(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_CONN_CUR); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the cumulated number of streams from the stream's tracked * frontend counters. Supports being called as "sc[0-9]_sess_cnt" or * "src_sess_cnt" only. */ static int smp_fetch_sc_sess_cnt(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_CNT); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the stream rate from the stream's tracked frontend counters. * Supports being called as "sc[0-9]_sess_rate" or "src_sess_rate" only. */ static int smp_fetch_sc_sess_rate(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_RATE); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), stkctr->table->data_arg[STKTABLE_DT_SESS_RATE].u); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the cumulated number of HTTP requests from the stream's tracked * frontend counters. Supports being called as "sc[0-9]_http_req_cnt" or * "src_http_req_cnt" only. */ static int smp_fetch_sc_http_req_cnt(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_CNT); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the HTTP request rate from the stream's tracked frontend * counters. Supports being called as "sc[0-9]_http_req_rate" or * "src_http_req_rate" only. */ static int smp_fetch_sc_http_req_rate(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_RATE); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), stkctr->table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the cumulated number of HTTP requests errors from the stream's * tracked frontend counters. Supports being called as "sc[0-9]_http_err_cnt" or * "src_http_err_cnt" only. */ static int smp_fetch_sc_http_err_cnt(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_ERR_CNT); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the HTTP request error rate from the stream's tracked frontend * counters. Supports being called as "sc[0-9]_http_err_rate" or * "src_http_err_rate" only. */ static int smp_fetch_sc_http_err_rate(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_ERR_RATE); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), stkctr->table->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the cumulated number of HTTP response failures from the stream's * tracked frontend counters. Supports being called as "sc[0-9]_http_fail_cnt" or * "src_http_fail_cnt" only. */ static int smp_fetch_sc_http_fail_cnt(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_FAIL_CNT); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = stktable_data_cast(ptr, std_t_uint); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the HTTP response failure rate from the stream's tracked frontend * counters. Supports being called as "sc[0-9]_http_fail_rate" or * "src_http_fail_rate" only. */ static int smp_fetch_sc_http_fail_rate(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_FAIL_RATE); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), stkctr->table->data_arg[STKTABLE_DT_HTTP_FAIL_RATE].u); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the number of kbytes received from clients, as found in the * stream's tracked frontend counters. Supports being called as * "sc[0-9]_kbytes_in" or "src_kbytes_in" only. */ static int smp_fetch_sc_kbytes_in(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_BYTES_IN_CNT); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = stktable_data_cast(ptr, std_t_ull) >> 10; HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the data rate received from clients in bytes/s, as found * in the stream's tracked frontend counters. Supports being called as * "sc[0-9]_bytes_in_rate" or "src_bytes_in_rate" only. */ static int smp_fetch_sc_bytes_in_rate(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_BYTES_IN_RATE); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), stkctr->table->data_arg[STKTABLE_DT_BYTES_IN_RATE].u); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the number of kbytes sent to clients, as found in the * stream's tracked frontend counters. Supports being called as * "sc[0-9]_kbytes_out" or "src_kbytes_out" only. */ static int smp_fetch_sc_kbytes_out(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_BYTES_OUT_CNT); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = stktable_data_cast(ptr, std_t_ull) >> 10; HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the data rate sent to clients in bytes/s, as found in the * stream's tracked frontend counters. Supports being called as * "sc[0-9]_bytes_out_rate" or "src_bytes_out_rate" only. */ static int smp_fetch_sc_bytes_out_rate(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; smp->data.u.sint = 0; if (stkctr_entry(stkctr) != NULL) { void *ptr; ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_BYTES_OUT_RATE); if (!ptr) { if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); return 0; /* parameter not stored */ } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), stkctr->table->data_arg[STKTABLE_DT_BYTES_OUT_RATE].u); HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock); if (stkctr == &tmpstkctr) stktable_release(stkctr->table, stkctr_entry(stkctr)); } return 1; } /* set to the number of active trackers on the SC entry in the stream's * tracked frontend counters. Supports being called as "sc[0-9]_trackers" only. */ static int smp_fetch_sc_trackers(const struct arg *args, struct sample *smp, const char *kw, void *private) { struct stkctr tmpstkctr; struct stkctr *stkctr; stkctr = smp_fetch_sc_stkctr(smp->sess, smp->strm, args, kw, &tmpstkctr); if (!stkctr) return 0; smp->flags = SMP_F_VOL_TEST; smp->data.type = SMP_T_SINT; if (stkctr == &tmpstkctr) { smp->data.u.sint = stkctr_entry(stkctr) ? (stkctr_entry(stkctr)->ref_cnt-1) : 0; stktable_release(stkctr->table, stkctr_entry(stkctr)); } else { smp->data.u.sint = stkctr_entry(stkctr) ? stkctr_entry(stkctr)->ref_cnt : 0; } return 1; } /* The functions below are used to manipulate table contents from the CLI. * There are 3 main actions, "clear", "set" and "show". The code is shared * between all actions, and the action is encoded in the void *private in * the appctx as well as in the keyword registration, among one of the * following values. */ enum { STK_CLI_ACT_CLR, STK_CLI_ACT_SET, STK_CLI_ACT_SHOW, }; /* Dump the status of a table to a stream connector's * read buffer. It returns 0 if the output buffer is full * and needs to be called again, otherwise non-zero. */ static int table_dump_head_to_buffer(struct buffer *msg, struct appctx *appctx, struct stktable *t, struct stktable *target) { struct stream *s = __sc_strm(appctx_sc(appctx)); chunk_appendf(msg, "# table: %s, type: %s, size:%d, used:%d\n", t->id, stktable_types[t->type].kw, t->size, t->current); /* any other information should be dumped here */ if (target && (strm_li(s)->bind_conf->level & ACCESS_LVL_MASK) < ACCESS_LVL_OPER) chunk_appendf(msg, "# contents not dumped due to insufficient privileges\n"); if (applet_putchk(appctx, msg) == -1) return 0; return 1; } /* Dump a table entry to a stream connector's * read buffer. It returns 0 if the output buffer is full * and needs to be called again, otherwise non-zero. */ static int table_dump_entry_to_buffer(struct buffer *msg, struct appctx *appctx, struct stktable *t, struct stksess *entry) { int dt; chunk_appendf(msg, "%p:", entry); if (t->type == SMP_T_IPV4) { char addr[INET_ADDRSTRLEN]; inet_ntop(AF_INET, (const void *)&entry->key.key, addr, sizeof(addr)); chunk_appendf(msg, " key=%s", addr); } else if (t->type == SMP_T_IPV6) { char addr[INET6_ADDRSTRLEN]; inet_ntop(AF_INET6, (const void *)&entry->key.key, addr, sizeof(addr)); chunk_appendf(msg, " key=%s", addr); } else if (t->type == SMP_T_SINT) { chunk_appendf(msg, " key=%u", read_u32(entry->key.key)); } else if (t->type == SMP_T_STR) { chunk_appendf(msg, " key="); dump_text(msg, (const char *)entry->key.key, t->key_size); } else { chunk_appendf(msg, " key="); dump_binary(msg, (const char *)entry->key.key, t->key_size); } chunk_appendf(msg, " use=%d exp=%d", entry->ref_cnt - 1, tick_remain(now_ms, entry->expire)); for (dt = 0; dt < STKTABLE_DATA_TYPES; dt++) { void *ptr; if (t->data_ofs[dt] == 0) continue; if (stktable_data_types[dt].is_array) { char tmp[16] = {}; const char *name_pfx = stktable_data_types[dt].name; const char *name_sfx = NULL; unsigned int idx = 0; int i = 0; /* split name to show index before first _ of the name * for example: 'gpc3_rate' if array name is 'gpc_rate'. */ for (i = 0 ; i < (sizeof(tmp) - 1); i++) { if (!name_pfx[i]) break; if (name_pfx[i] == '_') { name_pfx = &tmp[0]; name_sfx = &stktable_data_types[dt].name[i]; break; } tmp[i] = name_pfx[i]; } ptr = stktable_data_ptr_idx(t, entry, dt, idx); while (ptr) { if (stktable_data_types[dt].arg_type == ARG_T_DELAY) chunk_appendf(msg, " %s%u%s(%u)=", name_pfx, idx, name_sfx ? name_sfx : "", t->data_arg[dt].u); else chunk_appendf(msg, " %s%u%s=", name_pfx, idx, name_sfx ? name_sfx : ""); switch (stktable_data_types[dt].std_type) { case STD_T_SINT: chunk_appendf(msg, "%d", stktable_data_cast(ptr, std_t_sint)); break; case STD_T_UINT: chunk_appendf(msg, "%u", stktable_data_cast(ptr, std_t_uint)); break; case STD_T_ULL: chunk_appendf(msg, "%llu", stktable_data_cast(ptr, std_t_ull)); break; case STD_T_FRQP: chunk_appendf(msg, "%u", read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), t->data_arg[dt].u)); break; } ptr = stktable_data_ptr_idx(t, entry, dt, ++idx); } continue; } if (stktable_data_types[dt].arg_type == ARG_T_DELAY) chunk_appendf(msg, " %s(%u)=", stktable_data_types[dt].name, t->data_arg[dt].u); else chunk_appendf(msg, " %s=", stktable_data_types[dt].name); ptr = stktable_data_ptr(t, entry, dt); switch (stktable_data_types[dt].std_type) { case STD_T_SINT: chunk_appendf(msg, "%d", stktable_data_cast(ptr, std_t_sint)); break; case STD_T_UINT: chunk_appendf(msg, "%u", stktable_data_cast(ptr, std_t_uint)); break; case STD_T_ULL: chunk_appendf(msg, "%llu", stktable_data_cast(ptr, std_t_ull)); break; case STD_T_FRQP: chunk_appendf(msg, "%u", read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), t->data_arg[dt].u)); break; case STD_T_DICT: { struct dict_entry *de; de = stktable_data_cast(ptr, std_t_dict); chunk_appendf(msg, "%s", de ? (char *)de->value.key : "-"); break; } } } chunk_appendf(msg, "\n"); if (applet_putchk(appctx, msg) == -1) return 0; return 1; } /* appctx context used by the "show table" command */ struct show_table_ctx { void *target; /* table we want to dump, or NULL for all */ struct stktable *t; /* table being currently dumped (first if NULL) */ struct stksess *entry; /* last entry we were trying to dump (or first if NULL) */ long long value[STKTABLE_FILTER_LEN]; /* value to compare against */ signed char data_type[STKTABLE_FILTER_LEN]; /* type of data to compare, or -1 if none */ signed char data_op[STKTABLE_FILTER_LEN]; /* operator (STD_OP_*) when data_type set */ enum { STATE_NEXT = 0, /* px points to next table, entry=NULL */ STATE_DUMP, /* px points to curr table, entry is valid, refcount held */ STATE_DONE, /* done dumping */ } state; char action; /* action on the table : one of STK_CLI_ACT_* */ }; /* Processes a single table entry matching a specific key passed in argument. * returns 0 if wants to be called again, 1 if has ended processing. */ static int table_process_entry_per_key(struct appctx *appctx, char **args) { struct show_table_ctx *ctx = appctx->svcctx; struct stktable *t = ctx->target; struct stksess *ts; uint32_t uint32_key; unsigned char ip6_key[sizeof(struct in6_addr)]; long long value; int data_type; int cur_arg; void *ptr; struct freq_ctr *frqp; if (!*args[4]) return cli_err(appctx, "Key value expected\n"); switch (t->type) { case SMP_T_IPV4: uint32_key = htonl(inetaddr_host(args[4])); static_table_key.key = &uint32_key; break; case SMP_T_IPV6: if (inet_pton(AF_INET6, args[4], ip6_key) <= 0) return cli_err(appctx, "Invalid key\n"); static_table_key.key = &ip6_key; break; case SMP_T_SINT: { char *endptr; unsigned long val; errno = 0; val = strtoul(args[4], &endptr, 10); if ((errno == ERANGE && val == ULONG_MAX) || (errno != 0 && val == 0) || endptr == args[4] || val > 0xffffffff) return cli_err(appctx, "Invalid key\n"); uint32_key = (uint32_t) val; static_table_key.key = &uint32_key; break; } break; case SMP_T_STR: static_table_key.key = args[4]; static_table_key.key_len = strlen(args[4]); break; default: switch (ctx->action) { case STK_CLI_ACT_SHOW: return cli_err(appctx, "Showing keys from tables of type other than ip, ipv6, string and integer is not supported\n"); case STK_CLI_ACT_CLR: return cli_err(appctx, "Removing keys from tables of type other than ip, ipv6, string and integer is not supported\n"); case STK_CLI_ACT_SET: return cli_err(appctx, "Inserting keys into tables of type other than ip, ipv6, string and integer is not supported\n"); default: return cli_err(appctx, "Unknown action\n"); } } /* check permissions */ if (!cli_has_level(appctx, ACCESS_LVL_OPER)) return 1; switch (ctx->action) { case STK_CLI_ACT_SHOW: ts = stktable_lookup_key(t, &static_table_key); if (!ts) return 1; chunk_reset(&trash); if (!table_dump_head_to_buffer(&trash, appctx, t, t)) { stktable_release(t, ts); return 0; } HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &ts->lock); if (!table_dump_entry_to_buffer(&trash, appctx, t, ts)) { HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock); stktable_release(t, ts); return 0; } HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock); stktable_release(t, ts); break; case STK_CLI_ACT_CLR: ts = stktable_lookup_key(t, &static_table_key); if (!ts) return 1; if (!stksess_kill(t, ts, 1)) { /* don't delete an entry which is currently referenced */ return cli_err(appctx, "Entry currently in use, cannot remove\n"); } break; case STK_CLI_ACT_SET: ts = stktable_get_entry(t, &static_table_key); if (!ts) { /* don't delete an entry which is currently referenced */ return cli_err(appctx, "Unable to allocate a new entry\n"); } HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock); for (cur_arg = 5; *args[cur_arg]; cur_arg += 2) { if (strncmp(args[cur_arg], "data.", 5) != 0) { cli_err(appctx, "\"data.\" followed by a value expected\n"); HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); stktable_touch_local(t, ts, 1); return 1; } data_type = stktable_get_data_type(args[cur_arg] + 5); if (data_type < 0) { cli_err(appctx, "Unknown data type\n"); HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); stktable_touch_local(t, ts, 1); return 1; } if (!t->data_ofs[data_type]) { cli_err(appctx, "Data type not stored in this table\n"); HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); stktable_touch_local(t, ts, 1); return 1; } if (!*args[cur_arg+1] || strl2llrc(args[cur_arg+1], strlen(args[cur_arg+1]), &value) != 0) { cli_err(appctx, "Require a valid integer value to store\n"); HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); stktable_touch_local(t, ts, 1); return 1; } ptr = stktable_data_ptr(t, ts, data_type); switch (stktable_data_types[data_type].std_type) { case STD_T_SINT: stktable_data_cast(ptr, std_t_sint) = value; break; case STD_T_UINT: stktable_data_cast(ptr, std_t_uint) = value; break; case STD_T_ULL: stktable_data_cast(ptr, std_t_ull) = value; break; case STD_T_FRQP: /* We set both the current and previous values. That way * the reported frequency is stable during all the period * then slowly fades out. This allows external tools to * push measures without having to update them too often. */ frqp = &stktable_data_cast(ptr, std_t_frqp); /* First bit is reserved for the freq_ctr lock Note: here we're still protected by the stksess lock so we don't need to update the update the freq_ctr using its internal lock */ frqp->curr_tick = now_ms & ~0x1; frqp->prev_ctr = 0; frqp->curr_ctr = value; break; } } HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); stktable_touch_local(t, ts, 1); break; default: return cli_err(appctx, "Unknown action\n"); } return 1; } /* Prepares the appctx fields with the data-based filters from the command line. * Returns 0 if the dump can proceed, 1 if has ended processing. */ static int table_prepare_data_request(struct appctx *appctx, char **args) { struct show_table_ctx *ctx = appctx->svcctx; int i; char *err = NULL; if (ctx->action != STK_CLI_ACT_SHOW && ctx->action != STK_CLI_ACT_CLR) return cli_err(appctx, "content-based lookup is only supported with the \"show\" and \"clear\" actions\n"); for (i = 0; i < STKTABLE_FILTER_LEN; i++) { if (i > 0 && !*args[3+3*i]) // number of filter entries can be less than STKTABLE_FILTER_LEN break; /* condition on stored data value */ ctx->data_type[i] = stktable_get_data_type(args[3+3*i] + 5); if (ctx->data_type[i] < 0) return cli_dynerr(appctx, memprintf(&err, "Filter entry #%i: Unknown data type\n", i + 1)); if (!((struct stktable *)ctx->target)->data_ofs[ctx->data_type[i]]) return cli_dynerr(appctx, memprintf(&err, "Filter entry #%i: Data type not stored in this table\n", i + 1)); ctx->data_op[i] = get_std_op(args[4+3*i]); if (ctx->data_op[i] < 0) return cli_dynerr(appctx, memprintf(&err, "Filter entry #%i: Require and operator among \"eq\", \"ne\", \"le\", \"ge\", \"lt\", \"gt\"\n", i + 1)); if (!*args[5+3*i] || strl2llrc(args[5+3*i], strlen(args[5+3*i]), &ctx->value[i]) != 0) return cli_dynerr(appctx, memprintf(&err, "Filter entry #%i: Require a valid integer value to compare against\n", i + 1)); } if (*args[3+3*i]) { return cli_dynerr(appctx, memprintf(&err, "Detected extra data in filter, %ith word of input, after '%s'\n", 3+3*i + 1, args[2+3*i])); } /* OK we're done, all the fields are set */ return 0; } /* returns 0 if wants to be called, 1 if has ended processing */ static int cli_parse_table_req(char **args, char *payload, struct appctx *appctx, void *private) { struct show_table_ctx *ctx = applet_reserve_svcctx(appctx, sizeof(*ctx)); int i; for (i = 0; i < STKTABLE_FILTER_LEN; i++) ctx->data_type[i] = -1; ctx->target = NULL; ctx->entry = NULL; ctx->action = (long)private; // keyword argument, one of STK_CLI_ACT_* if (*args[2]) { ctx->t = ctx->target = stktable_find_by_name(args[2]); if (!ctx->target) return cli_err(appctx, "No such table\n"); } else { ctx->t = stktables_list; if (ctx->action != STK_CLI_ACT_SHOW) goto err_args; return 0; } if (strcmp(args[3], "key") == 0) return table_process_entry_per_key(appctx, args); else if (strncmp(args[3], "data.", 5) == 0) return table_prepare_data_request(appctx, args); else if (*args[3]) goto err_args; return 0; err_args: switch (ctx->action) { case STK_CLI_ACT_SHOW: return cli_err(appctx, "Optional argument only supports \"data.\" and key \n"); case STK_CLI_ACT_CLR: return cli_err(appctx, "Required arguments:
\"data.\" or
key \n"); case STK_CLI_ACT_SET: return cli_err(appctx, "Required arguments:
key [data. ]*\n"); default: return cli_err(appctx, "Unknown action\n"); } } /* This function is used to deal with table operations (dump or clear depending * on the action stored in appctx->private). It returns 0 if the output buffer is * full and it needs to be called again, otherwise non-zero. */ static int cli_io_handler_table(struct appctx *appctx) { struct show_table_ctx *ctx = appctx->svcctx; struct stconn *sc = appctx_sc(appctx); struct stream *s = __sc_strm(sc); struct ebmb_node *eb; int skip_entry; int show = ctx->action == STK_CLI_ACT_SHOW; /* * We have 3 possible states in ctx->state : * - STATE_NEXT : the proxy pointer points to the next table to * dump, the entry pointer is NULL ; * - STATE_DUMP : the proxy pointer points to the current table * and the entry pointer points to the next entry to be dumped, * and the refcount on the next entry is held ; * - STATE_DONE : nothing left to dump, the buffer may contain some * data though. */ if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW))) { /* in case of abort, remove any refcount we might have set on an entry */ if (ctx->state == STATE_DUMP) { stksess_kill_if_expired(ctx->t, ctx->entry, 1); } return 1; } chunk_reset(&trash); while (ctx->state != STATE_DONE) { switch (ctx->state) { case STATE_NEXT: if (!ctx->t || (ctx->target && ctx->t != ctx->target)) { ctx->state = STATE_DONE; break; } if (ctx->t->size) { if (show && !table_dump_head_to_buffer(&trash, appctx, ctx->t, ctx->target)) return 0; if (ctx->target && (strm_li(s)->bind_conf->level & ACCESS_LVL_MASK) >= ACCESS_LVL_OPER) { /* dump entries only if table explicitly requested */ HA_SPIN_LOCK(STK_TABLE_LOCK, &ctx->t->lock); eb = ebmb_first(&ctx->t->keys); if (eb) { ctx->entry = ebmb_entry(eb, struct stksess, key); ctx->entry->ref_cnt++; ctx->state = STATE_DUMP; HA_SPIN_UNLOCK(STK_TABLE_LOCK, &ctx->t->lock); break; } HA_SPIN_UNLOCK(STK_TABLE_LOCK, &ctx->t->lock); } } ctx->t = ctx->t->next; break; case STATE_DUMP: skip_entry = 0; HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &ctx->entry->lock); if (ctx->data_type[0] >= 0) { /* we're filtering on some data contents */ void *ptr; int dt, i; signed char op; long long data, value; for (i = 0; i < STKTABLE_FILTER_LEN; i++) { if (ctx->data_type[i] == -1) break; dt = ctx->data_type[i]; ptr = stktable_data_ptr(ctx->t, ctx->entry, dt); data = 0; switch (stktable_data_types[dt].std_type) { case STD_T_SINT: data = stktable_data_cast(ptr, std_t_sint); break; case STD_T_UINT: data = stktable_data_cast(ptr, std_t_uint); break; case STD_T_ULL: data = stktable_data_cast(ptr, std_t_ull); break; case STD_T_FRQP: data = read_freq_ctr_period(&stktable_data_cast(ptr, std_t_frqp), ctx->t->data_arg[dt].u); break; } op = ctx->data_op[i]; value = ctx->value[i]; /* skip the entry if the data does not match the test and the value */ if ((data < value && (op == STD_OP_EQ || op == STD_OP_GT || op == STD_OP_GE)) || (data == value && (op == STD_OP_NE || op == STD_OP_GT || op == STD_OP_LT)) || (data > value && (op == STD_OP_EQ || op == STD_OP_LT || op == STD_OP_LE))) { skip_entry = 1; break; } } } if (show && !skip_entry && !table_dump_entry_to_buffer(&trash, appctx, ctx->t, ctx->entry)) { HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ctx->entry->lock); return 0; } HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ctx->entry->lock); HA_SPIN_LOCK(STK_TABLE_LOCK, &ctx->t->lock); ctx->entry->ref_cnt--; eb = ebmb_next(&ctx->entry->key); if (eb) { struct stksess *old = ctx->entry; ctx->entry = ebmb_entry(eb, struct stksess, key); if (show) __stksess_kill_if_expired(ctx->t, old); else if (!skip_entry && !ctx->entry->ref_cnt) __stksess_kill(ctx->t, old); ctx->entry->ref_cnt++; HA_SPIN_UNLOCK(STK_TABLE_LOCK, &ctx->t->lock); break; } if (show) __stksess_kill_if_expired(ctx->t, ctx->entry); else if (!skip_entry && !ctx->entry->ref_cnt) __stksess_kill(ctx->t, ctx->entry); HA_SPIN_UNLOCK(STK_TABLE_LOCK, &ctx->t->lock); ctx->t = ctx->t->next; ctx->state = STATE_NEXT; break; default: break; } } return 1; } static void cli_release_show_table(struct appctx *appctx) { struct show_table_ctx *ctx = appctx->svcctx; if (ctx->state == STATE_DUMP) { stksess_kill_if_expired(ctx->t, ctx->entry, 1); } } static void stkt_late_init(void) { struct sample_fetch *f; f = find_sample_fetch("src", strlen("src")); if (f) smp_fetch_src = f->process; } INITCALL0(STG_INIT, stkt_late_init); /* register cli keywords */ static struct cli_kw_list cli_kws = {{ },{ { { "clear", "table", NULL }, "clear table
[]* : remove an entry from a table (filter: data/key)", cli_parse_table_req, cli_io_handler_table, cli_release_show_table, (void *)STK_CLI_ACT_CLR }, { { "set", "table", NULL }, "set table
key [data.* ]* : update or create a table entry's data", cli_parse_table_req, cli_io_handler_table, NULL, (void *)STK_CLI_ACT_SET }, { { "show", "table", NULL }, "show table
[]* : report table usage stats or dump this table's contents (filter: data/key)", cli_parse_table_req, cli_io_handler_table, cli_release_show_table, (void *)STK_CLI_ACT_SHOW }, {{},} }}; INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws); static struct action_kw_list tcp_conn_kws = { { }, { { "sc-inc-gpc", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-inc-gpc0", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-inc-gpc1", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-set-gpt", parse_set_gpt, KWF_MATCH_PREFIX }, { "sc-set-gpt0", parse_set_gpt, KWF_MATCH_PREFIX }, { /* END */ } }}; INITCALL1(STG_REGISTER, tcp_req_conn_keywords_register, &tcp_conn_kws); static struct action_kw_list tcp_sess_kws = { { }, { { "sc-inc-gpc", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-inc-gpc0", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-inc-gpc1", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-set-gpt", parse_set_gpt, KWF_MATCH_PREFIX }, { "sc-set-gpt0", parse_set_gpt, KWF_MATCH_PREFIX }, { /* END */ } }}; INITCALL1(STG_REGISTER, tcp_req_sess_keywords_register, &tcp_sess_kws); static struct action_kw_list tcp_req_kws = { { }, { { "sc-inc-gpc", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-inc-gpc0", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-inc-gpc1", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-set-gpt", parse_set_gpt, KWF_MATCH_PREFIX }, { "sc-set-gpt0", parse_set_gpt, KWF_MATCH_PREFIX }, { /* END */ } }}; INITCALL1(STG_REGISTER, tcp_req_cont_keywords_register, &tcp_req_kws); static struct action_kw_list tcp_res_kws = { { }, { { "sc-inc-gpc", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-inc-gpc0", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-inc-gpc1", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-set-gpt", parse_set_gpt, KWF_MATCH_PREFIX }, { "sc-set-gpt0", parse_set_gpt, KWF_MATCH_PREFIX }, { /* END */ } }}; INITCALL1(STG_REGISTER, tcp_res_cont_keywords_register, &tcp_res_kws); static struct action_kw_list http_req_kws = { { }, { { "sc-inc-gpc", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-inc-gpc0", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-inc-gpc1", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-set-gpt", parse_set_gpt, KWF_MATCH_PREFIX }, { "sc-set-gpt0", parse_set_gpt, KWF_MATCH_PREFIX }, { /* END */ } }}; INITCALL1(STG_REGISTER, http_req_keywords_register, &http_req_kws); static struct action_kw_list http_res_kws = { { }, { { "sc-inc-gpc", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-inc-gpc0", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-inc-gpc1", parse_inc_gpc, KWF_MATCH_PREFIX }, { "sc-set-gpt", parse_set_gpt, KWF_MATCH_PREFIX }, { "sc-set-gpt0", parse_set_gpt, KWF_MATCH_PREFIX }, { /* END */ } }}; INITCALL1(STG_REGISTER, http_res_keywords_register, &http_res_kws); /* Note: must not be declared 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_gpc", smp_fetch_sc_clr_gpc, ARG3(2,SINT,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_clr_gpc1", smp_fetch_sc_clr_gpc1, 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_gpt", smp_fetch_sc_get_gpt, ARG3(2,SINT,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_gpc", smp_fetch_sc_get_gpc, ARG3(2,SINT,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_get_gpc1", smp_fetch_sc_get_gpc1, ARG2(1,SINT,TAB), NULL, SMP_T_SINT, SMP_USE_INTRN }, { "sc_gpc_rate", smp_fetch_sc_gpc_rate, ARG3(2,SINT,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_gpc1_rate", smp_fetch_sc_gpc1_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_fail_cnt", smp_fetch_sc_http_fail_cnt, ARG2(1,SINT,TAB), NULL, SMP_T_SINT, SMP_USE_INTRN, }, { "sc_http_fail_rate", smp_fetch_sc_http_fail_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_gpc", smp_fetch_sc_inc_gpc, ARG3(2,SINT,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_inc_gpc1", smp_fetch_sc_inc_gpc1, 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_clr_gpc1", smp_fetch_sc_clr_gpc1, 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_get_gpc1", smp_fetch_sc_get_gpc1, 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_gpc1_rate", smp_fetch_sc_gpc1_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_fail_cnt", smp_fetch_sc_http_fail_cnt, ARG1(0,TAB), NULL, SMP_T_SINT, SMP_USE_INTRN, }, { "sc0_http_fail_rate", smp_fetch_sc_http_fail_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_inc_gpc1", smp_fetch_sc_inc_gpc1, 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_gpc", smp_fetch_sc_clr_gpc, ARG2(1,SINT,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_clr_gpc1", smp_fetch_sc_clr_gpc1, 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_get_gpc1", smp_fetch_sc_get_gpc1, 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_gpc1_rate", smp_fetch_sc_gpc1_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_fail_cnt", smp_fetch_sc_http_fail_cnt, ARG1(0,TAB), NULL, SMP_T_SINT, SMP_USE_INTRN, }, { "sc1_http_fail_rate", smp_fetch_sc_http_fail_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_inc_gpc1", smp_fetch_sc_inc_gpc1, 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_clr_gpc1", smp_fetch_sc_clr_gpc1, 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_get_gpc1", smp_fetch_sc_get_gpc1, 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_gpc1_rate", smp_fetch_sc_gpc1_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_fail_cnt", smp_fetch_sc_http_fail_cnt, ARG1(0,TAB), NULL, SMP_T_SINT, SMP_USE_INTRN, }, { "sc2_http_fail_rate", smp_fetch_sc_http_fail_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_inc_gpc1", smp_fetch_sc_inc_gpc1, 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_gpc", smp_fetch_sc_clr_gpc, ARG2(2,SINT,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_clr_gpc1", smp_fetch_sc_clr_gpc1, 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_gpt" , smp_fetch_sc_get_gpt, ARG2(2,SINT,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_gpc", smp_fetch_sc_get_gpc, ARG2(2,SINT,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_get_gpc1", smp_fetch_sc_get_gpc1, ARG1(1,TAB), NULL, SMP_T_SINT, SMP_USE_L4CLI, }, { "src_gpc_rate", smp_fetch_sc_gpc_rate, ARG2(2,SINT,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_gpc1_rate", smp_fetch_sc_gpc1_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_fail_cnt", smp_fetch_sc_http_fail_cnt, ARG1(1,TAB), NULL, SMP_T_SINT, SMP_USE_L4CLI, }, { "src_http_fail_rate", smp_fetch_sc_http_fail_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_gpc", smp_fetch_sc_inc_gpc, ARG2(2,SINT,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_inc_gpc1", smp_fetch_sc_inc_gpc1, 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, }, { /* END */ }, }}; INITCALL1(STG_REGISTER, sample_register_fetches, &smp_fetch_keywords); /* Note: must not be declared 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_expire", sample_conv_table_expire, ARG2(1,TAB,SINT), NULL, SMP_T_ANY, SMP_T_SINT }, { "table_gpt", sample_conv_table_gpt, ARG2(2,SINT,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_gpc", sample_conv_table_gpc, ARG2(2,SINT,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_gpc1", sample_conv_table_gpc1, ARG1(1,TAB), NULL, SMP_T_ANY, SMP_T_SINT }, { "table_gpc_rate", sample_conv_table_gpc_rate, ARG2(2,SINT,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_gpc1_rate", sample_conv_table_gpc1_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_fail_cnt", sample_conv_table_http_fail_cnt, ARG1(1,TAB), NULL, SMP_T_ANY, SMP_T_SINT }, { "table_http_fail_rate", sample_conv_table_http_fail_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_idle", sample_conv_table_idle, ARG2(1,TAB,SINT), 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 }, { /* END */ }, }}; INITCALL1(STG_REGISTER, sample_register_convs, &sample_conv_kws);