[MEDIUM] Add stick table (persistence) management functions and types
diff --git a/src/stick_table.c b/src/stick_table.c
new file mode 100644
index 0000000..0d70e32
--- /dev/null
+++ b/src/stick_table.c
@@ -0,0 +1,334 @@
+/*
+ * Stick tables management functions.
+ *
+ * Copyright 2009-2010 EXCELIANCE, Emeric Brun <ebrun@exceliance.fr>
+ *
+ * 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 <string.h>
+
+#include <common/config.h>
+#include <common/memory.h>
+#include <common/mini-clist.h>
+#include <common/standard.h>
+#include <common/time.h>
+
+#include <ebmbtree.h>
+#include <ebsttree.h>
+
+#include <types/stick_table.h>
+
+#include <proto/proxy.h>
+#include <proto/session.h>
+#include <proto/task.h>
+
+
+/*
+ * Free an allocate sticked session <ts>.
+ * Decrease table <t> sticked session counter .
+ */
+void stksess_free(struct stktable *t, struct stksess *ts)
+{
+ t->current--;
+ pool_free2(t->pool,ts);
+}
+
+/*
+ * Init or modify <key> of th sticked session <ts> present in table <t>.
+ */
+void stksess_key(struct stktable *t, struct stksess *ts, struct stktable_key *key)
+{
+ if (t->type != STKTABLE_TYPE_STRING)
+ memcpy(ts->keys.key, key->key , t->key_size);
+ else {
+ memcpy(ts->keys.key, key->key, MIN(t->key_size - 1, key->key_len));
+ ts->keys.key[MIN(t->key_size - 1, key->key_len)] = 0;
+ }
+}
+
+
+/*
+ * Init sticked session <ts> using <key>.
+ */
+struct stksess *stksess_init(struct stktable *t, struct stksess * ts, struct stktable_key *key)
+{
+ ts->keys.node.leaf_p = NULL;
+ ts->exps.node.leaf_p = NULL;
+ ts->sid = 0;
+ stksess_key(t, ts, key);
+
+ return ts;
+}
+
+/*
+ * Trash oldest <to_batch> sticked sessions from table <t>
+ * Returns number of trashed sticked session.
+ */
+static int stktable_trash_oldest(struct stktable *t, int to_batch)
+{
+ struct stksess *ts;
+ struct eb32_node *eb;
+ int batched = 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
+ * <now_ms> is in the first half and we're first scanning the last
+ * half. Let's loop back to the beginning of the tree now.
+ */
+ eb = eb32_first(&t->exps);
+ if (likely(!eb))
+ break;
+ }
+
+ /* timer looks expired, detach it from the queue */
+ ts = eb32_entry(eb, struct stksess, exps);
+ eb = eb32_next(eb);
+
+ eb32_delete(&ts->exps);
+
+ if (ts->expire != ts->exps.key) {
+
+ if (!tick_isset(ts->expire))
+ continue;
+
+ ts->exps.key = ts->expire;
+
+ eb32_insert(&t->exps, &ts->exps);
+
+ if (!eb || eb->key > ts->exps.key)
+ eb = &ts->exps;
+
+ continue;
+ }
+ /* session expired, trash it */
+
+ ebmb_delete(&ts->keys);
+ stksess_free(t, ts);
+ batched++;
+ }
+
+ return batched;
+}
+
+/*
+ * Allocate and initialise a new sticked session.
+ * The new sticked session is returned or NULL in case of lack of memory.
+ * Sticked sessions should only be allocated this way, and must be
+ * freed using stksess_free().
+ * Increase table <t> sticked session counter.
+ */
+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))
+ return NULL;
+ }
+
+ ts = pool_alloc2(t->pool);
+ if (ts) {
+ t->current++;
+ stksess_init(t, ts, key);
+ }
+
+ return ts;
+}
+
+/*
+ * Lookup in table <t> for a sticked session identified by <key>.
+ * Returns pointer on requested sticked session or NULL if no one found.
+ */
+struct stksess *stktable_lookup(struct stktable *t, struct stktable_key *key)
+{
+ struct ebmb_node *eb;
+
+ /* lookup on track session */
+ if (t->type == STKTABLE_TYPE_STRING)
+ eb = ebst_lookup_len(&t->keys, key->key, key->key_len);
+ else
+ eb = ebmb_lookup(&t->keys, key->key, t->key_size);
+
+ if (unlikely(!eb)) {
+ /* no session found */
+ return NULL;
+ }
+
+ /* Existing session, returns server id */
+ return ebmb_entry(eb, struct stksess, keys);
+}
+
+/*
+ * Store sticked session if not present in table.
+ * Il already present, update the existing session.
+ */
+int stktable_store(struct stktable *t, struct stksess *tsess, int sid)
+{
+ struct stksess *ts;
+ struct ebmb_node *eb;
+
+ if (t->type == STKTABLE_TYPE_STRING)
+ eb = ebst_lookup(&(t->keys), (char *)tsess->keys.key);
+ else
+ eb = ebmb_lookup(&(t->keys), tsess->keys.key, t->key_size);
+
+ if (unlikely(!eb)) {
+ tsess->sid = sid;
+ ebmb_insert(&t->keys, &tsess->keys, t->key_size);
+
+ tsess->exps.key = tsess->expire = tick_add(now_ms, MS_TO_TICKS(t->expire));
+ eb32_insert(&t->exps, &tsess->exps);
+
+ if (t->expire) {
+ t->exp_task->expire = t->exp_next = tick_first(tsess->expire, t->exp_next);
+ task_queue(t->exp_task);
+ }
+ return 0;
+ }
+
+ /* Existing track session */
+ ts = ebmb_entry(eb, struct stksess, keys);
+
+ if ( ts->sid != sid )
+ ts->sid = sid;
+ return 1;
+}
+
+/*
+ * Trash expired sticked sessions from table <t>.
+ */
+static int stktable_trash_expired(struct stktable *t)
+{
+ struct stksess *ts;
+ struct eb32_node *eb;
+
+ 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
+ * <now_ms> is in the first half and we're first scanning the last
+ * half. Let's loop back to the beginning of the tree now.
+ */
+ 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;
+ return t->exp_next;
+ }
+
+ /* timer looks expired, detach it from the queue */
+ ts = eb32_entry(eb, struct stksess, exps);
+ eb = eb32_next(eb);
+
+ eb32_delete(&ts->exps);
+
+ if (!tick_is_expired(ts->expire, now_ms)) {
+ if (!tick_isset(ts->expire))
+ continue;
+
+ ts->exps.key = ts->expire;
+ eb32_insert(&t->exps, &ts->exps);
+
+ if (!eb || eb->key > ts->exps.key)
+ eb = &ts->exps;
+ continue;
+ }
+
+ /* session expired, trash it */
+ ebmb_delete(&ts->keys);
+ stksess_free(t, ts);
+ }
+
+ /* We have found no task to expire in any tree */
+ t->exp_next = TICK_ETERNITY;
+ return t->exp_next;
+}
+
+/*
+ * Task processing function to trash expired sticked sessions.
+ */
+static struct task *process_table_expire(struct task * task)
+{
+ struct stktable *t = (struct stktable *)task->context;
+
+ task->expire = stktable_trash_expired(t);
+ return task;
+}
+
+/* Perform minimal intializations, report 0 in case of error, 1 if OK. */
+int stktable_init(struct stktable *t)
+{
+ if (t->size) {
+ memset(&t->keys, 0, sizeof(t->keys));
+ memset(&t->exps, 0, sizeof(t->exps));
+
+ t->pool = create_pool("sticktables", sizeof(struct stksess) + t->key_size, MEM_F_SHARED);
+
+ t->exp_next = TICK_ETERNITY;
+ if ( t->expire ) {
+ t->exp_task = task_new();
+ t->exp_task->process = process_table_expire;
+ t->exp_task->expire = TICK_ETERNITY;
+ t->exp_task->context = (void *)t;
+ }
+ return t->pool != NULL;
+ }
+ return 1;
+}
+
+/*
+ * Configuration keywords of known table types
+ */
+struct stktable_type stktable_types[STKTABLE_TYPES] = { { "ip", 0, 4 } ,
+ { "integer", 0, 4 },
+ { "string", STKTABLE_TYPEFLAG_CUSTOMKEYSIZE, 32 } };
+
+
+/*
+ * Parse table type configuration.
+ * Returns 0 on successful parsing, else 1.
+ * <myidx> is set at next configuration <args> index.
+ */
+int stktable_parse_type(char **args, int *myidx, unsigned long *type, size_t *key_size)
+{
+ for (*type = 0; *type < STKTABLE_TYPES; (*type)++) {
+ if (strcmp(args[*myidx], stktable_types[*type].kw) != 0)
+ continue;
+
+ *key_size = stktable_types[*type].default_size;
+ (*myidx)++;
+
+ if (stktable_types[*type].flags & STKTABLE_TYPEFLAG_CUSTOMKEYSIZE) {
+ if (strcmp("len", args[*myidx]) == 0) {
+ (*myidx)++;
+ *key_size = atol(args[*myidx]);
+ if ( !*key_size )
+ break;
+ /* null terminated string needs +1 for '\0'. */
+ (*key_size)++;
+ (*myidx)++;
+ }
+ }
+ return 0;
+ }
+ return 1;
+}
+
+