vars.c

/*
 * Copyright (c) 2005-2012 by KoanLogic s.r.l. <http://www.koanlogic.com>
 * All rights reserved.
 *
 * This file is part of KLone, and as such it is subject to the license stated
 * in the LICENSE file which you have received as part of this distribution.
 *
 * $Id: vars.c,v 1.32 2008/05/16 15:04:47 tat Exp $
 */

#include "klone_conf.h"
#include <sys/types.h>
#include <stdlib.h>
#include <u/libu.h>
#include <klone/vars.h>
#include <klone/varprv.h>
#include <klone/utils.h>

TAILQ_HEAD(var_list_s, var_s);

struct vars_s
{
    u_list_t *list;              /* list of variables (var_t) */
    int flags;
};

u_string_t *vars_get_value_s(vars_t *vs, const char *name)
{
    var_t *v = NULL;

    dbg_err_if (vs == NULL);
    dbg_err_if (name == NULL);

    dbg_err_if((v = vars_get(vs, name)) == NULL);

    return var_get_value_s(v);
err:
    return NULL;
}

int vars_create(vars_t **pvs)
{
    vars_t *vs = NULL;

    dbg_err_if (pvs == NULL);

    vs = u_zalloc(sizeof(vars_t));
    dbg_err_if(vs == NULL);

    dbg_err_if(u_list_create(&vs->list));

    *pvs = vs;

    return 0;
err:
    if(vs)
        vars_free(vs);
    return ~0;
}

int vars_set_flags(vars_t *vs, int flags)
{
    dbg_err_if (vs == NULL);

    vs->flags = flags;

    return 0;
err:
    return ~0;
}

int vars_free(vars_t *vs)
{
    var_t *v;
    int t;

    if(vs)
    {
        /* if the var_t objects are owned by this vars_t then free them all */
        if((vs->flags & VARS_FLAG_FOREIGN) == 0)
        {
            /* free all variables */
            for(t = 0; (v = u_list_get_n(vs->list, t)) != NULL; ++t)
                var_free(v);
        }

        if(vs->list)
            u_list_free(vs->list);

        U_FREE(vs);
    }

    return 0;
}

int vars_add(vars_t *vs, var_t *v)
{
    dbg_err_if(vs == NULL);
    dbg_err_if(v == NULL);

    dbg_err_if(u_list_add(vs->list, v));

    return 0;
err:
    return ~0;
}

int vars_del(vars_t *vs, var_t *v)
{
    dbg_err_if(vs == NULL);
    dbg_err_if(v == NULL);
   
    dbg_err_if(u_list_del(vs->list, v));

    return 0;
err:
    return ~0;
}

var_t *vars_getn(vars_t *vs, size_t i)
{
    dbg_return_if (vs == NULL, NULL);
    nop_return_if (i >= u_list_count(vs->list), NULL);

    return u_list_get_n(vs->list, i);
}

size_t vars_count(vars_t *vs)
{
    dbg_return_if (vs == NULL, 0);

    return u_list_count(vs->list);
}

size_t vars_countn(vars_t *vs, const char *name)
{
    var_t *v;
    size_t c = 0;
    int t;

    dbg_return_if (vs == NULL || name == NULL, 0);

    for(t = 0; (v = u_list_get_n(vs->list, t)) != NULL; ++t)
    {
        if(strcasecmp(u_string_c(v->sname), name) == 0)
            c++;
    }

    return c;
}

int vars_add_urlvar(vars_t *vs, const char *cstr, var_t **pv)
{
    enum { NAMESZ = 256, VALSZ = 4096 };
    char sname[NAMESZ], svalue[VALSZ];
    char *val, *str = NULL, *name = sname, *value = svalue;
    var_t *var = NULL;
    ssize_t vsz;
    size_t val_len, nam_len;

    dbg_return_if (vs == NULL, ~0);
    dbg_return_if (cstr == NULL, ~0);
    /* pv may be NULL */
        
    /* dup the string so we can modify it */
    dbg_err_sif ((str = u_strdup(cstr)) == NULL);

    /* zero-term the name part and set the value pointer */
    dbg_err_if ((val = strchr(str, '=')) == NULL);
    *val++ = '\0'; 

    val_len = strlen(val);
    nam_len = strlen(str);

    /* if the buffer on the stack is too small alloc a bigger one */
    if (nam_len >= NAMESZ)
        dbg_err_if ((name = u_zalloc(1 + nam_len)) == NULL);

    /* if the buffer on the stack is too small alloc a bigger one */
    if (val_len >= VALSZ)
        dbg_err_if ((value = u_zalloc(1 + val_len)) == NULL);

    /* url-decode var name */
    dbg_err_if (u_urlncpy(name, str, nam_len, URLCPY_DECODE) <= 0);

    /* url-decode var value */
    if (val_len)
        dbg_err_if ((vsz = u_urlncpy(value, val, val_len, URLCPY_DECODE)) <= 0);
    else 
    {
        /* an empty value */
        value[0] = '\0';
        vsz = 1;
    }

    /* u_dbg("name: [%s]  value: [%s]", name, value); */

    dbg_err_if (var_bin_create(name, (unsigned char *) value, vsz, &var));

    /* push into the var list */
    dbg_err_if (vars_add(vs, var));

    if (pv)
        *pv = var;

    /* if the buffer has been alloc'd on the heap then free it */
    if (value && value != svalue)
        u_free(value);

    if (name && name != sname)
        u_free(name);

    u_free(str);

    return 0;
err:
    if (value && value != svalue)
        u_free(value);
    if (name && name != sname)
        u_free(name);
    u_free(str);
    if (var)
        var_free(var);
    return ~0;
}

int vars_add_strvar(vars_t *vs, const char *str)
{
    char *eq, *dups = NULL;
    var_t *var = NULL;

    dbg_err_if (vs == NULL);
    dbg_err_if (str == NULL);

    /* dup the string (str is const) */
    dups = u_strdup(str);
    dbg_err_if(dups == NULL);

    /* search the '=' and replace it with a '\0' */
    eq = strchr(dups, '=');
    dbg_err_if(eq == NULL);
    *eq = 0;

    /* create a new var obj */
    dbg_err_if(var_create(dups, eq+1, &var));

    U_FREE(dups);

    /* push into the cookie list */
    dbg_err_if(vars_add(vs, var));

    return 0;
err:
    U_FREE(dups);
    if(var)
        var_free(var);
    return ~0;
}

var_t *vars_geti(vars_t *vs, const char *var_name, size_t i)
{
    var_t *v;
    int t;

    dbg_goto_if (vs == NULL, notfound);
    dbg_goto_if (var_name == NULL, notfound);

    for(t = 0; (v = u_list_get_n(vs->list, t)) != NULL; ++t)
    {
        if(strcasecmp(u_string_c(v->sname), var_name) == 0)
        {
            if(i-- == 0)
                return v;
        }
    }

notfound:
    return NULL;
}

var_t *vars_get(vars_t *vs, const char *var_name)
{
    dbg_return_if (vs == NULL, NULL);
    dbg_return_if (var_name == NULL, NULL);

    return vars_geti(vs, var_name, 0);
}

int vars_geti_value_i(vars_t *vs, const char *name, size_t ith)
{
    const char *v;

    dbg_return_if (vs == NULL, 0);
    dbg_return_if (name == NULL, 0);

    v = vars_geti_value(vs, name, ith);
    if(v == NULL)
        return 0;
    else
        return atoi(v);
}

u_string_t *vars_geti_value_s(vars_t *vs, const char *name, size_t ith)
{
    var_t *v = NULL;

    dbg_err_if (vs == NULL);
    dbg_err_if (name == NULL);

    dbg_err_if((v = vars_geti(vs, name, ith)) == NULL);

    return var_get_value_s(v);
err:
    return NULL;
}

int vars_get_value_i(vars_t *vs, const char *name)
{
    dbg_return_if (vs == NULL, 0);
    dbg_return_if (name == NULL, 0);

    return vars_geti_value_i(vs, name, 0);
}

const char *vars_geti_value(vars_t *vs, const char *name, size_t ith)
{
    var_t *v;

    dbg_return_if (vs == NULL, NULL);
    dbg_return_if (name == NULL, NULL);
    
    v = vars_geti(vs, name, ith);

    return  v ? var_get_value(v) : NULL;
}

const char *vars_get_value(vars_t *vs, const char *name)
{
    dbg_return_if (vs == NULL, NULL);
    dbg_return_if (name == NULL, NULL);

    return vars_geti_value(vs, name, 0);
}

void vars_foreach(vars_t *vs, int (*cb)(var_t *, void *), void *arg)
{
    var_t *v;
    int t;

    dbg_ifb (vs == NULL) return;
    dbg_ifb (cb == NULL) return;

    for(t = 0; (v = u_list_get_n(vs->list, t)) != NULL; ++t)
    {
        if(cb(v, arg))
            break;
    }

    return;
}