avpops.c

/*
 * $Id$
 *
 * Copyright (C) 2004-2006 Voice Sistem SRL
 *
 * This file is part of Kamailio.
 *
 * Kamailio 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.
 *
 * Kamailio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * History:
 * ---------
 *  2004-10-04  first version (ramona)
 *  2004-11-15  added support for db schemes for avp_db_load (ramona)
 *  2004-11-17  aligned to new AVP core global aliases (ramona)
 *  2005-01-30  "fm" (fast match) operator added (ramona)
 *  2005-01-30  avp_copy (copy/move operation) added (ramona)
 */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h> /* for regex */
#include <regex.h>

#include "../../mem/shm_mem.h"
#include "../../mem/mem.h"
#include "../../parser/parse_hname2.h"
#include "../../sr_module.h"
#include "../../str.h"
#include "../../dprint.h"
#include "../../error.h"
#include "../../ut.h"
#include "avpops_parse.h"
#include "avpops_impl.h"
#include "avpops_db.h"


MODULE_VERSION

/* modules param variables */
static str db_url          = {NULL, 0};  /* database url */
static str db_table        = {NULL, 0};  /* table */
static int use_domain      = 0;  /* if domain should be use for avp matching */
static str uuid_col        = str_init("uuid");
static str attribute_col   = str_init("attribute");
static str value_col       = str_init("value");
static str type_col        = str_init("type");
static str username_col    = str_init("username");
static str domain_col      = str_init("domain");
static str* db_columns[6] = {&uuid_col, &attribute_col, &value_col, &type_col, &username_col, &domain_col};


static int avpops_init(void);
static int avpops_child_init(int rank);

static int fixup_db_load_avp(void** param, int param_no);
static int fixup_db_delete_avp(void** param, int param_no);
static int fixup_db_store_avp(void** param, int param_no);
static int fixup_db_query_avp(void** param, int param_no);
static int fixup_delete_avp(void** param, int param_no);
static int fixup_copy_avp(void** param, int param_no);
static int fixup_pushto_avp(void** param, int param_no);
static int fixup_check_avp(void** param, int param_no);
static int fixup_op_avp(void** param, int param_no);
static int fixup_subst(void** param, int param_no);
static int fixup_is_avp_set(void** param, int param_no);

static int w_print_avps(struct sip_msg* msg, char* foo, char *bar);
static int w_dbload_avps(struct sip_msg* msg, char* source, char* param);
static int w_dbdelete_avps(struct sip_msg* msg, char* source, char* param);
static int w_dbstore_avps(struct sip_msg* msg, char* source, char* param);
static int w_dbquery1_avps(struct sip_msg* msg, char* query, char* param);
static int w_dbquery2_avps(struct sip_msg* msg, char* query, char* dest);
static int w_delete_avps(struct sip_msg* msg, char* param, char *foo);
static int w_copy_avps(struct sip_msg* msg, char* param, char *check);
static int w_pushto_avps(struct sip_msg* msg, char* destination, char *param);
static int w_check_avps(struct sip_msg* msg, char* param, char *check);
static int w_op_avps(struct sip_msg* msg, char* param, char *op);
static int w_subst(struct sip_msg* msg, char* src, char *subst);
static int w_is_avp_set(struct sip_msg* msg, char* param, char *foo);

static cmd_export_t cmds[] = {
        {"avp_print", (cmd_function)w_print_avps, 0, 0, 0,
                REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
        {"avp_db_load", (cmd_function)w_dbload_avps,  2, fixup_db_load_avp, 0,
                REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
        {"avp_db_delete", (cmd_function)w_dbdelete_avps, 2, fixup_db_delete_avp, 0,
                REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
        {"avp_db_store", (cmd_function)w_dbstore_avps,  2, fixup_db_store_avp, 0,
                REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
        {"avp_db_query", (cmd_function)w_dbquery1_avps, 1, fixup_db_query_avp, 0,
                REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
        {"avp_db_query", (cmd_function)w_dbquery2_avps, 2, fixup_db_query_avp, 0,
                REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
        {"avp_delete", (cmd_function)w_delete_avps, 1, fixup_delete_avp, 0,
                REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
        {"avp_copy",   (cmd_function)w_copy_avps,  2,  fixup_copy_avp, 0,
                REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
        {"avp_pushto", (cmd_function)w_pushto_avps, 2, fixup_pushto_avp, 0,
                REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
        {"avp_check",  (cmd_function)w_check_avps, 2, fixup_check_avp, 0,
                REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
        {"avp_op",     (cmd_function)w_op_avps, 2, fixup_op_avp, 0,
                REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
        {"avp_subst",  (cmd_function)w_subst,   2, fixup_subst, 0,
                REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
        {"is_avp_set", (cmd_function)w_is_avp_set, 1, fixup_is_avp_set, 0,
                REQUEST_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE|ONREPLY_ROUTE|LOCAL_ROUTE},
        {0, 0, 0, 0, 0, 0}
};


static param_export_t params[] = {
        {"db_url",            STR_PARAM, &db_url.s        },
        {"avp_table",         STR_PARAM, &db_table.s      },
        {"use_domain",        INT_PARAM, &use_domain      },
        {"uuid_column",       STR_PARAM, &uuid_col.s      },
        {"attribute_column",  STR_PARAM, &attribute_col.s },
        {"value_column",      STR_PARAM, &value_col.s     },
        {"type_column",       STR_PARAM, &type_col.s      },
        {"username_column",   STR_PARAM, &username_col.s  },
        {"domain_column",     STR_PARAM, &domain_col.s    },
        {"db_scheme",         STR_PARAM|USE_FUNC_PARAM, (void*)avp_add_db_scheme },
        {0, 0, 0}
};


struct module_exports exports = {
        "avpops",
        DEFAULT_DLFLAGS, /* dlopen flags */
        cmds,       /* Exported functions */
        params,     /* Exported parameters */
        0,          /* exported statistics */
        0,          /* exported MI functions */
        0,          /* exported pseudo-variables */
        0,          /* extra processes */
        avpops_init,/* Module initialization function */
        0,
        0,
        (child_init_function) avpops_child_init /* per-child init function */
};


static int avpops_init(void)
{
        if (db_url.s)
                db_url.len = strlen(db_url.s);
        if (db_table.s)
                db_table.len = strlen(db_table.s);
        uuid_col.len = strlen(uuid_col.s);
        attribute_col.len = strlen(attribute_col.s);
        value_col.len = strlen(value_col.s);
        type_col.len = strlen(type_col.s);
        username_col.len = strlen(username_col.s);
        domain_col.len = strlen(domain_col.s);

        /* if DB_URL defined -> bind to a DB module */
        if (db_url.s!=0)
        {
                /* check AVP_TABLE param */
                if (db_table.s==0)
                {
                        LM_CRIT("\"AVP_DB\" present but \"AVP_TABLE\" found empty\n");
                        goto error;
                }
                /* bind to the DB module */
                if (avpops_db_bind(&db_url)<0)
                        goto error;
        }

        init_store_avps(db_columns);

        return 0;
error:
        return -1;
}


static int avpops_child_init(int rank)
{
        /* init DB only if enabled */
        if (db_url.s==0)
                return 0;
        /* skip main process and TCP manager process */
        if (rank==PROC_INIT || rank==PROC_MAIN || rank==PROC_TCP_MAIN)
                return 0;
        /* init DB connection */
        return avpops_db_init(&db_url, &db_table, db_columns);
}


static int fixup_db_avp(void** param, int param_no, int allow_scheme)
{
        struct fis_param *sp;
        struct db_param  *dbp;
        int flags;
        str s;
        char *p;

        flags=0;
        if (db_url.s==0)
        {
                LM_ERR("you have to configure a db_url for using avp_db_xxx functions\n");
                return E_UNSPEC;
        }

        s.s = (char*)*param;
        if (param_no==1)
        {
                /* prepare the fis_param structure */
                sp = (struct fis_param*)pkg_malloc(sizeof(struct fis_param));
                if (sp==0) {
                        LM_ERR("no more pkg mem!\n");
                        return E_OUT_OF_MEM;
                }
                memset( sp, 0, sizeof(struct fis_param));

                if ( (p=strchr(s.s,'/'))!=0)
                {
                        *(p++) = 0;
                        /* check for extra flags/params */
                        if (!strcasecmp("domain",p)) {
                                flags|=AVPOPS_FLAG_DOMAIN0;
                        } else if (!strcasecmp("username",p)) {
                                flags|=AVPOPS_FLAG_USER0;
                        } else if (!strcasecmp("uri",p)) {
                                flags|=AVPOPS_FLAG_URI0;
                        } else if (!strcasecmp("uuid",p)) {
                                flags|=AVPOPS_FLAG_UUID0;
                        } else {
                                LM_ERR("unknow flag "
                                        "<%s>\n",p);
                                return E_UNSPEC;
                        }
                }
                if (*s.s!='$')
                {
                        /* is a constant string -> use it as uuid*/
                        sp->opd = ((flags==0)?AVPOPS_FLAG_UUID0:flags)|AVPOPS_VAL_STR;
                        sp->u.s.s = (char*)pkg_malloc(strlen(s.s)+1);
                        if (sp->u.s.s==0) {
                                LM_ERR("no more pkg mem!!\n");
                                return E_OUT_OF_MEM;
                        }
                        sp->u.s.len = strlen(s.s);
                        strcpy(sp->u.s.s, s.s);
                } else {
                        /* is a variable $xxxxx */
                        s.len = strlen(s.s);
                        p = pv_parse_spec(&s, &sp->u.sval);
                        if (p==0 || sp->u.sval.type==PVT_NULL || sp->u.sval.type==PVT_EMPTY)
                        {
                                LM_ERR("bad param 1; "
                                        "expected : $pseudo-variable or int/str value\n");
                                return E_UNSPEC;
                        }
                        
                        if(sp->u.sval.type==PVT_RURI || sp->u.sval.type==PVT_FROM
                                        || sp->u.sval.type==PVT_TO || sp->u.sval.type==PVT_OURI)
                        {
                                sp->opd = ((flags==0)?AVPOPS_FLAG_URI0:flags)|AVPOPS_VAL_PVAR;
                        } else {
                                sp->opd = ((flags==0)?AVPOPS_FLAG_UUID0:flags)|AVPOPS_VAL_PVAR;
                        }
                }
                *param=(void*)sp;
        } else if (param_no==2) {
                /* compose the db_param structure */
                dbp = (struct db_param*)pkg_malloc(sizeof(struct db_param));
                if (dbp==0)
                {
                        LM_ERR("no more pkg mem!!!\n");
                        return E_OUT_OF_MEM;
                }
                memset( dbp, 0, sizeof(struct db_param));
                if ( parse_avp_db( s.s, dbp, allow_scheme)!=0 )
                {
                        LM_ERR("parse failed\n");
                        return E_UNSPEC;
                }
                *param=(void*)dbp;
        }

        return 0;
}


static int fixup_db_load_avp(void** param, int param_no)
{
        return fixup_db_avp( param, param_no, 1/*allow scheme*/);
}

static int fixup_db_delete_avp(void** param, int param_no)
{
        return fixup_db_avp( param, param_no, 0/*no scheme*/);
}


static int fixup_db_store_avp(void** param, int param_no)
{
        return fixup_db_avp( param, param_no, 0/*no scheme*/);
}

static int fixup_db_query_avp(void** param, int param_no)
{
        pv_elem_t *model = NULL;
        pvname_list_t *anlist = NULL;
        str s;

        if (db_url.s==0)
        {
                LM_ERR("you have to configure db_url for using avp_db_query function\n");
                return E_UNSPEC;
        }

        s.s = (char*)(*param);
        if (param_no==1)
        {
                if(s.s==NULL)
                {
                        LM_ERR("null format in P%d\n",
                                        param_no);
                        return E_UNSPEC;
                }
                s.len = strlen(s.s);
                if(pv_parse_format(&s, &model)<0)
                {
                        LM_ERR("wrong format[%s]\n", s.s);
                        return E_UNSPEC;
                }
                        
                *param = (void*)model;
                return 0;
        } else if(param_no==2) {
                if(s.s==NULL)
                {
                        LM_ERR("null format in P%d\n", param_no);
                        return E_UNSPEC;
                }
                                s.len = strlen(s.s);

                anlist = parse_pvname_list(&s, PVT_AVP);
                if(anlist==NULL)
                {
                        LM_ERR("bad format in P%d [%s]\n", param_no, s.s);
                        return E_UNSPEC;
                }
                *param = (void*)anlist;
                return 0;
        }

        return 0;
}


static int fixup_delete_avp(void** param, int param_no)
{
        struct fis_param *ap=NULL;
        char *p;
        char *s;
        unsigned int flags;
        str s0;

        s = (char*)(*param);
        if (param_no==1) {
                /* attribute name / alias */
                if ( (p=strchr(s,'/'))!=0 )
                        *(p++)=0;
                
                if(*s=='$')
                {
                        /* is variable */
                        ap = avpops_parse_pvar(s);
                        if (ap==0)
                        {
                                LM_ERR("unable to get"
                                        " pseudo-variable in param \n");
                                return E_UNSPEC;
                        }
                        if (ap->u.sval.type!=PVT_AVP)
                        {
                                LM_ERR("bad param; expected : $avp(name)\n");
                                return E_UNSPEC;
                        }
                        ap->opd|=AVPOPS_VAL_PVAR;
                        ap->type = AVPOPS_VAL_PVAR;
                } else {
                        if(strlen(s)<1)
                        {
                                LM_ERR("bad param - expected : $avp(name), *, s or i value\n");
                                return E_UNSPEC;
                        }
                        ap = (struct fis_param*)pkg_malloc(sizeof(struct fis_param));
                        if (ap==0)
                        {
                                LM_ERR(" no more pkg mem\n");
                                return E_OUT_OF_MEM;
                        }
                        memset(ap, 0, sizeof(struct fis_param));
                        ap->opd|=AVPOPS_VAL_NONE;
                        switch(*s) {
                                case 's': case 'S':
                                        ap->opd = AVPOPS_VAL_NONE|AVPOPS_VAL_STR;
                                break;
                                case 'i': case 'I':
                                        ap->opd = AVPOPS_VAL_NONE|AVPOPS_VAL_INT;
                                break;
                                case '*': case 'a': case 'A':
                                        ap->opd = AVPOPS_VAL_NONE;
                                break;
                                default:
                                        LM_ERR(" bad param - expected : *, s or i AVP flag\n");
                                        pkg_free(ap);
                                        return E_UNSPEC;
                        }
                        /* flags */
                        flags = 0;
                        if(*(s+1)!='\0')
                        {
                                s0.s = s+1;
                                s0.len = strlen(s0.s);
                                if(str2int(&s0, &flags)!=0)
                                {
                                        LM_ERR("bad avp flags\n");
                                        pkg_free(ap);
                                        return E_UNSPEC;
                                }
                        }
                        ap->type = AVPOPS_VAL_INT;
                        ap->u.n = flags<<8;
                }

                /* flags */
                for( ; p&&*p ; p++ )
                {
                        switch (*p)
                        {
                                case 'g':
                                case 'G':
                                        ap->ops|=AVPOPS_FLAG_ALL;
                                        break;
                                default:
                                        LM_ERR(" bad flag <%c>\n",*p);
                                        if(ap!=NULL)
                                                pkg_free(ap);
                                        return E_UNSPEC;
                        }
                }
                /* force some flags: if no avp name is given, force "all" flag */
                if (ap->opd&AVPOPS_VAL_NONE)
                        ap->ops |= AVPOPS_FLAG_ALL;

                *param=(void*)ap;
        }

        return 0;
}

static int fixup_copy_avp(void** param, int param_no)
{
        struct fis_param *ap;
        char *s;
        char *p;

        s = (char*)*param;
        ap = 0;
        p = 0;

        if (param_no==2)
        {
                /* avp / flags */
                if ( (p=strchr(s,'/'))!=0 )
                        *(p++)=0;
        }

        ap = avpops_parse_pvar(s);
        if (ap==0)
        {
                LM_ERR("unable to get pseudo-variable in P%d\n", param_no);
                return E_OUT_OF_MEM;
        }

        /* attr name is mandatory */
        if (ap->u.sval.type!=PVT_AVP)
        {
                LM_ERR("you must specify only AVP as parameter\n");
                return E_UNSPEC;
        }

        if (param_no==2)
        {
                /* flags */
                for( ; p&&*p ; p++ )
                {
                        switch (*p) {
                                case 'g':
                                case 'G':
                                        ap->ops|=AVPOPS_FLAG_ALL;
                                        break;
                                case 'd':
                                case 'D':
                                        ap->ops|=AVPOPS_FLAG_DELETE;
                                        break;
                                case 'n':
                                case 'N':
                                        ap->ops|=AVPOPS_FLAG_CASTN;
                                        break;
                                case 's':
                                case 'S':
                                        ap->ops|=AVPOPS_FLAG_CASTS;
                                        break;
                                default:
                                        LM_ERR("bad flag <%c>\n",*p);
                                        return E_UNSPEC;
                        }
                }
        }

        *param=(void*)ap;
        return 0;
}

static int fixup_pushto_avp(void** param, int param_no)
{
        struct fis_param *ap;
        char *s;
        char *p;

        s = (char*)*param;
        ap = 0;

        if (param_no==1)
        {
                if ( *s!='$')
                {
                        LM_ERR("bad param 1; expected : $ru $du ...\n");
                        return E_UNSPEC;
                }
                /* compose the param structure */

                if ( (p=strchr(s,'/'))!=0 )
                        *(p++)=0;
                ap = avpops_parse_pvar(s);
                if (ap==0)
                {
                        LM_ERR("unable to get pseudo-variable in param 1\n");
                        return E_OUT_OF_MEM;
                }

                switch(ap->u.sval.type) {
                        case PVT_RURI:
                                ap->opd = AVPOPS_VAL_NONE|AVPOPS_USE_RURI;
                                if ( p && !(
                                        (!strcasecmp("username",p)
                                                        && (ap->opd|=AVPOPS_FLAG_USER0)) ||
                                        (!strcasecmp("domain",p)
                                                        && (ap->opd|=AVPOPS_FLAG_DOMAIN0)) ))
                                {
                                        LM_ERR("unknown ruri flag \"%s\"!\n",p);
                                        return E_UNSPEC;
                                }
                        break;
                        case PVT_DSTURI:
                                if ( p!=0 )
                                {
                                        LM_ERR("unknown duri flag \"%s\"!\n",p);
                                        return E_UNSPEC;
                                }
                                ap->opd = AVPOPS_VAL_NONE|AVPOPS_USE_DURI;
                        break;
                        case PVT_HDR:
                                /* what's the hdr destination ? request or reply? */
                                LM_ERR("push to header  is obsoleted - use append_hf() "
                                                "or append_to_reply() from textops module!\n");
                                return E_UNSPEC;
                        break;
                        case PVT_BRANCH:
                                if ( p!=0 )
                                {
                                        LM_ERR("unknown branch flag \"%s\"!\n",p);
                                        return E_UNSPEC;
                                }
                                ap->opd = AVPOPS_VAL_NONE|AVPOPS_USE_BRANCH;
                        break;
                        default:
                                LM_ERR("unsupported destination \"%s\"; "
                                                "expected $ru,$du,$br\n",s);
                                return E_UNSPEC;
                }
        } else if (param_no==2) {
                /* attribute name*/
                if ( *s!='$')
                {
                        LM_ERR("bad param 2; expected: $pseudo-variable ...\n");
                        return E_UNSPEC;
                }
                /* compose the param structure */

                if ( (p=strchr(s,'/'))!=0 )
                        *(p++)=0;
                ap = avpops_parse_pvar(s);
                if (ap==0)
                {
                        LM_ERR("unable to get pseudo-variable in param 2\n");
                        return E_OUT_OF_MEM;
                }
                if (ap->u.sval.type==PVT_NULL)
                {
                        LM_ERR("bad param 2; expected : $pseudo-variable ...\n");
                        pkg_free(ap);
                        return E_UNSPEC;
                }
                ap->opd |= AVPOPS_VAL_PVAR;

                /* flags */
                for( ; p&&*p ; p++ )
                {
                        switch (*p) {
                                case 'g':
                                case 'G':
                                        ap->ops|=AVPOPS_FLAG_ALL;
                                        break;
                                default:
                                        LM_ERR("bad flag <%c>\n",*p);
                                        pkg_free(ap);
                                        return E_UNSPEC;
                        }
                }
        }

        *param=(void*)ap;
        return 0;
}

static int fixup_check_avp(void** param, int param_no)
{
        struct fis_param *ap;
        regex_t* re;
        char *s;

        s = (char*)*param;
        ap = 0;

        if (param_no==1)
        {
                ap = avpops_parse_pvar(s);
                if (ap==0)
                {
                        LM_ERR("unable to get pseudo-variable in param 1\n");
                        return E_OUT_OF_MEM;
                }
                /* attr name is mandatory */
                if (ap->u.sval.type==PVT_NULL)
                {
                        LM_ERR("null pseudo-variable in param 1\n");
                        return E_UNSPEC;
                }
        } else if (param_no==2) {
                if ( (ap=parse_check_value(s))==0 )
                {
                        LM_ERR("failed to parse checked value \n");
                        return E_UNSPEC;
                }
                /* if REGEXP op -> compile the expresion */
                if (ap->ops&AVPOPS_OP_RE)
                {
                        if ( (ap->opd&AVPOPS_VAL_STR)==0 )
                        {
                                LM_ERR("regexp operation requires string value\n");
                                return E_UNSPEC;
                        }
                        re = pkg_malloc(sizeof(regex_t));
                        if (re==0)
                        {
                                LM_ERR("no more pkg mem\n");
                                return E_OUT_OF_MEM;
                        }
                        LM_DBG("compiling regexp <%.*s>\n", ap->u.s.len, ap->u.s.s);
                        if (regcomp(re, ap->u.s.s,
                                                REG_EXTENDED|REG_ICASE|REG_NEWLINE))
                        {
                                pkg_free(re);
                                LM_ERR("bad re <%.*s>\n", ap->u.s.len, ap->u.s.s);
                                return E_BAD_RE;
                        }
                        /* free the string and link the regexp */
                        // pkg_free(ap->sval.p.s);
                        ap->u.s.s = (char*)re;
                } else if (ap->ops&AVPOPS_OP_FM) {
                        if ( !( ap->opd&AVPOPS_VAL_PVAR ||
                        (!(ap->opd&AVPOPS_VAL_PVAR) && ap->opd&AVPOPS_VAL_STR) ) )
                        {
                                LM_ERR("fast_match operation requires string value or "
                                                "avp name/alias (%d/%d)\n",     ap->opd, ap->ops);
                                return E_UNSPEC;
                        }
                }
        }

        *param=(void*)ap;
        return 0;
}

static int fixup_subst(void** param, int param_no)
{
        struct subst_expr* se;
        str subst;
        struct fis_param *ap;
        struct fis_param **av;
        char *s;
        char *p;
        
        if (param_no==1) {
                s = (char*)*param;
                ap = 0;
                p = 0;
                av = (struct fis_param**)pkg_malloc(2*sizeof(struct fis_param*));
                if(av==NULL)
                {
                        LM_ERR("no more pkg memory\n");
                        return E_UNSPEC;                        
                }
                memset(av, 0, 2*sizeof(struct fis_param*));

                /* avp src / avp dst /flags */
                if ( (p=strchr(s,'/'))!=0 )
                        *(p++)=0;
                ap = avpops_parse_pvar(s);
                if (ap==0)
                {
                        LM_ERR("unable to get pseudo-variable in param 2 [%s]\n", s);
                        return E_OUT_OF_MEM;
                }
                if (ap->u.sval.type!=PVT_AVP)
                {
                        LM_ERR("bad attribute name <%s>\n", (char*)*param);
                        pkg_free(av);
                        return E_UNSPEC;
                }
                /* attr name is mandatory */
                if (ap->opd&AVPOPS_VAL_NONE)
                {
                        LM_ERR("you must specify a name for the AVP\n");
                        return E_UNSPEC;
                }
                av[0] = ap;
                if(p==0 || *p=='\0')
                {
                        *param=(void*)av;
                        return 0;
                }
                
                /* dst || flags */
                s = p;
                if(*s==PV_MARKER)
                {
                        if ( (p=strchr(s,'/'))!=0 )
                                *(p++)=0;
                        if(p==0 || (p!=0 && p-s>1))
                        {
                                ap = avpops_parse_pvar(s);
                                if (ap==0)
                                {
                                        LM_ERR("unable to get pseudo-variable in param 2 [%s]\n",s);
                                        return E_OUT_OF_MEM;
                                }
                        
                                if (ap->u.sval.type!=PVT_AVP)
                                {
                                        LM_ERR("bad attribute name <%s>!\n", s);
                                        pkg_free(av);
                                        return E_UNSPEC;
                                }
                                /* attr name is mandatory */
                                if (ap->opd&AVPOPS_VAL_NONE)
                                {
                                        LM_ERR("you must specify a name for the AVP!\n");
                                        return E_UNSPEC;
                                }
                                av[1] = ap;
                        }
                        if(p==0 || *p=='\0')
                        {
                                *param=(void*)av;
                                return 0;
                        }
                }
                
                /* flags */
                for( ; p&&*p ; p++ )
                {
                        switch (*p) {
                                case 'g':
                                case 'G':
                                        av[0]->ops|=AVPOPS_FLAG_ALL;
                                        break;
                                case 'd':
                                case 'D':
                                        av[0]->ops|=AVPOPS_FLAG_DELETE;
                                        break;
                                default:
                                        LM_ERR("bad flag <%c>\n",*p);
                                        return E_UNSPEC;
                        }
                }
                *param=(void*)av;
        } else if (param_no==2) {
                LM_DBG("%s fixing %s\n", exports.name, (char*)(*param));
                subst.s=*param;
                subst.len=strlen(*param);
                se=subst_parser(&subst);
                if (se==0){
                        LM_ERR("%s: bad subst re %s\n",exports.name, (char*)*param);
                        return E_BAD_RE;
                }
                /* don't free string -- needed for specifiers */
                /* pkg_free(*param); */
                /* replace it with the compiled subst. re */
                *param=se;
        }

        return 0;
}

static int fixup_op_avp(void** param, int param_no)
{
        struct fis_param *ap;
        struct fis_param **av;
        char *s;
        char *p;

        s = (char*)*param;
        ap = 0;

        if (param_no==1)
        {
                av = (struct fis_param**)pkg_malloc(2*sizeof(struct fis_param*));
                if(av==NULL)
                {
                        LM_ERR("no more pkg memory\n");
                        return E_UNSPEC;                        
                }
                memset(av, 0, 2*sizeof(struct fis_param*));
                /* avp src / avp dst */
                if ( (p=strchr(s,'/'))!=0 )
                        *(p++)=0;

                av[0] = avpops_parse_pvar(s);
                if (av[0]==0)
                {
                        LM_ERR("unable to get pseudo-variable in param 1\n");
                        return E_OUT_OF_MEM;
                }
                if (av[0]->u.sval.type!=PVT_AVP)
                {
                        LM_ERR("bad attribute name <%s>\n", (char*)*param);
                        pkg_free(av);
                        return E_UNSPEC;
                }
                if(p==0 || *p=='\0')
                {
                        *param=(void*)av;
                        return 0;
                }
                
                s = p;
                ap = avpops_parse_pvar(s);
                if (ap==0)
                {
                        LM_ERR("unable to get pseudo-variable in param 1 (2)\n");
                        return E_OUT_OF_MEM;
                }
                if (ap->u.sval.type!=PVT_AVP)
                {
                        LM_ERR("bad attribute name/alias <%s>!\n", s);
                        pkg_free(av);
                        return E_UNSPEC;
                }
                av[1] = ap;
                *param=(void*)av;
                return 0;
        } else if (param_no==2) {
                if ( (ap=parse_op_value(s))==0 )
                {
                        LM_ERR("failed to parse the value \n");
                        return E_UNSPEC;
                }
                /* only integer values or avps */
                if ( (ap->opd&AVPOPS_VAL_STR)!=0 && (ap->opd&AVPOPS_VAL_PVAR)==0)
                {
                        LM_ERR("operations requires integer values\n");
                        return E_UNSPEC;
                }
                *param=(void*)ap;
                return 0;
        }
        return -1;
}

static int fixup_is_avp_set(void** param, int param_no)
{
        struct fis_param *ap;
        char *p;
        char *s;
        
        s = (char*)(*param);
        if (param_no==1) {
                /* attribute name | alias / flags */
                if ( (p=strchr(s,'/'))!=0 )
                        *(p++)=0;
                
                ap = avpops_parse_pvar(s);
                if (ap==0)
                {
                        LM_ERR("unable to get pseudo-variable in param\n");
                        return E_OUT_OF_MEM;
                }
                
                if (ap->u.sval.type!=PVT_AVP)
                {
                        LM_ERR("bad attribute name <%s>\n", (char*)*param);
                        return E_UNSPEC;
                }
                if(p==0 || *p=='\0')
                        ap->ops|=AVPOPS_FLAG_ALL;

                /* flags */
                for( ; p&&*p ; p++ )
                {
                        switch (*p) {
                                case 'e':
                                case 'E':
                                        ap->ops|=AVPOPS_FLAG_EMPTY;
                                        break;
                                case 'n':
                                case 'N':
                                        if(ap->ops&AVPOPS_FLAG_CASTS)
                                        {
                                                LM_ERR("invalid flag combination <%c> and 's|S'\n",*p);
                                                return E_UNSPEC;
                                        }
                                        ap->ops|=AVPOPS_FLAG_CASTN;
                                        break;
                                case 's':
                                case 'S':
                                        if(ap->ops&AVPOPS_FLAG_CASTN)
                                        {
                                                LM_ERR("invalid flag combination <%c> and 'n|N'\n",*p);
                                                return E_UNSPEC;
                                        }
                                        ap->ops|=AVPOPS_FLAG_CASTS;
                                        break;
                                default:
                                        LM_ERR("bad flag <%c>\n",*p);
                                        return E_UNSPEC;
                        }
                }
                
                *param=(void*)ap;
        }

        return 0;
}

static int w_dbload_avps(struct sip_msg* msg, char* source, char* param)
{
        return ops_dbload_avps ( msg, (struct fis_param*)source,
                                                                (struct db_param*)param, use_domain);
}

static int w_dbdelete_avps(struct sip_msg* msg, char* source, char* param)
{
        return ops_dbdelete_avps ( msg, (struct fis_param*)source,
                                                                (struct db_param*)param, use_domain);
}

static int w_dbstore_avps(struct sip_msg* msg, char* source, char* param)
{
        return ops_dbstore_avps ( msg, (struct fis_param*)source,
                                                                (struct db_param*)param, use_domain);
}

static int w_dbquery1_avps(struct sip_msg* msg, char* query, char* param)
{
        return ops_dbquery_avps ( msg, (pv_elem_t*)query, 0);
}

static int w_dbquery2_avps(struct sip_msg* msg, char* query, char* dest)
{
        return ops_dbquery_avps ( msg, (pv_elem_t*)query, (pvname_list_t*)dest);
}

static int w_delete_avps(struct sip_msg* msg, char* param, char* foo)
{
        return ops_delete_avp ( msg, (struct fis_param*)param);
}

static int w_copy_avps(struct sip_msg* msg, char* name1, char *name2)
{
        return ops_copy_avp ( msg, (struct fis_param*)name1,
                                                                (struct fis_param*)name2);
}

static int w_pushto_avps(struct sip_msg* msg, char* destination, char *param)
{
        return ops_pushto_avp ( msg, (struct fis_param*)destination,
                                                                (struct fis_param*)param);
}

static int w_check_avps(struct sip_msg* msg, char* param, char *check)
{
        return ops_check_avp ( msg, (struct fis_param*)param,
                                                                (struct fis_param*)check);
}

static int w_op_avps(struct sip_msg* msg, char* param, char *op)
{
        return ops_op_avp ( msg, (struct fis_param**)param,
                                                                (struct fis_param*)op);
}

static int w_subst(struct sip_msg* msg, char* src, char *subst)
{
        return ops_subst(msg, (struct fis_param**)src, (struct subst_expr*)subst);
}

static int w_is_avp_set(struct sip_msg* msg, char* param, char *op)
{
        return ops_is_avp_set(msg, (struct fis_param*)param);
}

static int w_print_avps(struct sip_msg* msg, char* foo, char *bar)
{
        return ops_print_avp();
}