deleted file mode 100644

@@ -1,2148 +0,0 @@

-/*

- * SIP routing engine

- *

- * Copyright (C) 2001-2003 FhG Fokus

- *

- * This file is part of Kamailio, a free SIP server.

- *

- * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

- *

- */

-

-

-/** Kamailio core :: expression evaluation, route fixups and routing lists.

- * @file route.c

- * @ingroup core

- * Module: @ref core

- */

-

-#include <stdlib.h>

-#include <sys/types.h>

-#include <regex.h>

-#include <netdb.h>

-#include <string.h>

-#include <sys/socket.h>

-#include <netinet/in.h>

-#include <arpa/inet.h>

-#include <netdb.h>

-

-#include "route.h"

-#include "forward.h"

-#include "dprint.h"

-#include "proxy.h"

-#include "action.h"

-#include "lvalue.h"

-#include "rvalue.h"

-#include "sr_module.h"

-#include "ip_addr.h"

-#include "resolve.h"

-#include "socket_info.h"

-#include "parser/parse_uri.h"

-#include "parser/parse_from.h"

-#include "parser/parse_to.h"

-#include "mem/mem.h"

-#include "select.h"

-#include "onsend.h"

-#include "str_hash.h"

-#include "ut.h"

-#include "rvalue.h"

-#include "switch.h"

-#include "cfg/cfg_struct.h"

-

-#define RT_HASH_SIZE	8 /* route names hash */

-

-/* main routing script table  */

-struct route_list main_rt;

-struct route_list onreply_rt;

-struct route_list failure_rt;

-struct route_list branch_rt;

-struct route_list onsend_rt;

-struct route_list event_rt;

-

-int route_type = REQUEST_ROUTE;

-

-/** script optimization level, useful for debugging.

- *  0 - no optimization

- *  1 - optimize rval expressions

- *  2 - optimize expr elems

- */

-int scr_opt_lev=9;

-

-inline static void destroy_rlist(struct route_list* rt)

-{

-	struct str_hash_entry* e;

-	struct str_hash_entry* tmp;

-

-	if (rt->rlist){

-		pkg_free(rt->rlist);

-		rt->rlist=0;

-		rt->entries=0;

-	}

-	if (rt->names.table){

-		clist_foreach_safe(rt->names.table, e, tmp, next){

-			pkg_free(e);

-		}

-		pkg_free(rt->names.table);

-		rt->names.table=0;

-		rt->names.size=0;

-	}

-}

-

-

-

-void destroy_routes()

-{

-	destroy_rlist(&main_rt);

-	destroy_rlist(&onreply_rt);

-	destroy_rlist(&failure_rt);

-	destroy_rlist(&branch_rt);

-	destroy_rlist(&event_rt);

-}

-

-

-

-/* adds route name -> i mapping

- * WARNING: it doesn't check for pre-existing routes 

- * return -1 on error, route index on success

- */

-static int route_add(struct route_list* rt, char* name, int i)

-{

-	struct str_hash_entry* e;

-	

-	e=pkg_malloc(sizeof(struct str_hash_entry));

-	if (e==0){

-		LM_CRIT("out of memory\n");

-		goto error;

-	}

-	LM_DBG("mapping routing block (%p)[%s] to %d\n", rt, name, i);

-	e->key.s=name;

-	e->key.len=strlen(name);

-	e->flags=0;

-	e->u.n=i;

-	str_hash_add(&rt->names, e);

-	return 0;

-error:

-	return -1;

-}

-

-

-

-/* returns -1 on error, 0 on success */

-inline  static int init_rlist(char* r_name, struct route_list* rt,

-								int n_entries, int hash_size)

-{

-		rt->rlist=pkg_malloc(sizeof(struct action*)*n_entries);

-		if (rt->rlist==0){ 

-			LM_CRIT("failed to allocate \"%s\" route tables: " 

-					"out of memory\n", r_name); 

-			goto error; 

-		}

-		memset(rt->rlist, 0 , sizeof(struct action*)*n_entries);

-		rt->idx=1; /* idx=0 == default == reserved */

-		rt->entries=n_entries;

-		if (str_hash_alloc(&rt->names, hash_size)<0){

-			LM_CRIT("\"%s\" route table: failed to alloc hash\n",

-					r_name);

-			goto error;

-		}

-		str_hash_init(&rt->names);

-		route_add(rt, "0", 0);  /* default route */

-		

-		return 0;

-error:

-		return -1;

-}

-

-

-

-/* init route tables */

-int init_routes()

-{

-	if (init_rlist("main", &main_rt, RT_NO, RT_HASH_SIZE)<0)

-		goto error;

-	if (init_rlist("on_reply", &onreply_rt, ONREPLY_RT_NO, RT_HASH_SIZE)<0)

-		goto error;

-	if (init_rlist("failure", &failure_rt, FAILURE_RT_NO, RT_HASH_SIZE)<0)

-		goto error;

-	if (init_rlist("branch", &branch_rt, BRANCH_RT_NO, RT_HASH_SIZE)<0)

-		goto error;

-	if (init_rlist("on_send", &onsend_rt, ONSEND_RT_NO, RT_HASH_SIZE)<0)

-		goto error;

-	if (init_rlist("event", &event_rt, EVENT_RT_NO, RT_HASH_SIZE)<0)

-		goto error;

-	return 0;

-error:

-	destroy_routes();

-	return -1;

-}

-

-

-

-static inline int route_new_list(struct route_list* rt)

-{

-	int ret;

-	struct action** tmp;

-	

-	ret=-1;

-	if (rt->idx >= rt->entries){

-		tmp=pkg_realloc(rt->rlist, 2*rt->entries*sizeof(struct action*));

-		if (tmp==0){

-			LM_CRIT("out of memory\n");

-			goto end;

-		}

-		/* init the newly allocated memory chunk */

-		memset(&tmp[rt->entries], 0, rt->entries*sizeof(struct action*));

-		rt->rlist=tmp;

-		rt->entries*=2;

-	}

-	if (rt->idx<rt->entries){

-		ret=rt->idx;

-		rt->idx++;

-	}

-end:

-	return ret;

-}

-

-

-

-

-/* 

- * if the "name" route already exists, return its index, else

- * create a new empty route

- * return route index in rt->rlist or -1 on error

- */

-int route_get(struct route_list* rt, char* name)

-{

-	int len;

-	struct str_hash_entry* e;

-	int i;

-	

-	len=strlen(name);

-	/* check if exists an non empty*/

-	e=str_hash_get(&rt->names, name, len);

-	if (e){

-		i=e->u.n;

-	}else{

-		i=route_new_list(rt);

-		if (i==-1) goto error;

-		if (route_add(rt, name, i)<0){

-			goto error;

-		}

-	}

-	return i;

-error:

-	return -1;

-}

-

-

-

-/* 

- * if the "name" route already exists, return its index, else

- * return error

- * return route index in rt->rlist or -1 on error

- */

-int route_lookup(struct route_list* rt, char* name)

-{

-	int len;

-	struct str_hash_entry* e;

-	

-	len=strlen(name);

-	/* check if exists an non empty*/

-	e=str_hash_get(&rt->names, name, len);

-	if (e){

-		return e->u.n;

-	}else{

-		return -1;

-	}

-}

-

-

-

-int fix_actions(struct action* a); /*fwd declaration*/

-

-

-/** optimize the left side of a struct expr.

- *  @return 1 if optimized, 0 if not and -1 on error

- */

-static int exp_optimize_left(struct expr* exp)

-{

-	struct rval_expr* rve;

-	struct rvalue* rval;

-	int old_ltype, old_rtype, old_op;

-	int ret;

-	

-	ret=0;

-	if (exp->type!=ELEM_T)

-		return 0;

-	old_ltype=exp->l_type;

-	old_rtype=exp->r_type;

-	old_op=exp->op;

-	if (exp->l_type==RVEXP_O){

-		rve=exp->l.param;

-		/* rve should be previously fixed/optimized */

-		/* optimize exp (rval(val)) -> exp(val) */

-		if (rve->op==RVE_RVAL_OP){

-			rval=&rve->left.rval;

-			switch(rval->type){

-				case RV_INT:

-					if (exp->op==NO_OP){

-						exp->l_type=NUMBER_O;

-						exp->l.param=0;

-						exp->r_type=NUMBER_ST;

-						exp->r.numval=rval->v.l;

-						rval_destroy(rval);

-						pkg_free(rve);

-						ret=1;

-					}

-					break;

-				case RV_STR:

-					/* string evaluated in expression context - not

-					   supported */

-					break;

-				case RV_BEXPR:

-					if (exp->op==NO_OP){

-						/* replace the current expr. */

-						*exp=*(rval->v.bexpr);

-						rval_destroy(rval);

-						pkg_free(rve);

-						ret=1;

-					};

-					break;

-				case RV_ACTION_ST:

-					if (exp->op==NO_OP){

-						exp->l_type=ACTION_O;

-						exp->l.param=0;

-						exp->r_type=ACTION_ST;

-						exp->r.param=rval->v.action;

-						rval_destroy(rval);

-						pkg_free(rve);

-						ret=1;

-					}

-					break;

-				case RV_SEL:

-					exp->l.select=pkg_malloc(sizeof(*exp->l.select));

-					if (exp->l.select){

-						exp->l_type=SELECT_O;

-						*exp->l.select=rval->v.sel;

-						rval_destroy(rval);

-						pkg_free(rve);

-						ret=1;

-					}else

-						ret=-1;

-					break;

-				case RV_AVP:

-					exp->l.attr=pkg_malloc(sizeof(*exp->l.attr));

-					if (exp->l.attr){

-						exp->l_type=AVP_O;

-						*exp->l.attr=rval->v.avps;

-						rval_destroy(rval);

-						pkg_free(rve);

-						ret=1;

-					}else

-						ret=-1;

-					break;

-				case RV_PVAR:

-					exp->l.param=pkg_malloc(sizeof(pv_spec_t));

-					if (exp->l.param){

-						exp->l_type=PVAR_O;

-						*((pv_spec_t*)exp->l.param)=rval->v.pvs;

-						rval_destroy(rval);

-						pkg_free(rve);

-						ret=1;

-					}else

-						ret=-1;

-					break;

-				case RV_NONE:

-					break;

-			}

-		}

-	}

-	if (ret>0)

-		LM_DBG("op%d(_O%d_, ST%d) => op%d(_O%d_, ST%d)\n",

-			old_op, old_ltype, old_rtype, exp->op, exp->l_type, exp->r_type);

-	return ret;

-}

-

-

-

-/** optimize the left side of a struct expr.

- *  @return 1 if optimized, 0 if not and -1 on error

- */

-static int exp_optimize_right(struct expr* exp)

-{

-	struct rval_expr* rve;

-	struct rvalue* rval;

-	int old_ltype, old_rtype, old_op;

-	int ret;

-	

-	ret=0;

-	if ((exp->type!=ELEM_T) ||(exp->op==NO_OP))

-		return 0;

-	old_ltype=exp->l_type;

-	old_rtype=exp->r_type;

-	old_op=exp->op;

-	if (exp->r_type==RVE_ST){

-		rve=exp->r.param;

-		/* rve should be previously fixed/optimized */

-		/* optimize exp (rval(val)) -> exp(val) */

-		if (rve->op==RVE_RVAL_OP){

-			rval=&rve->left.rval;

-			switch(rval->type){

-				case RV_INT:

-					exp->r_type=NUMBER_ST;

-					exp->r.numval=rval->v.l;

-					rval_destroy(rval);

-					pkg_free(rve);

-					ret=1;

-					break;

-				case RV_STR:

-					exp->r.str.s=pkg_malloc(rval->v.s.len+1);

-					if (exp->r.str.s){

-						exp->r.str.len=rval->v.s.len;

-						memcpy(exp->r.str.s, rval->v.s.s, rval->v.s.len);

-						exp->r.str.s[exp->r.str.len]=0;

-						exp->r_type=STRING_ST;

-						rval_destroy(rval);

-						pkg_free(rve);

-						ret=1;

-					}else

-						ret=-1;

-					break;

-				case RV_BEXPR:

-					/* cannot be optimized further, is an exp_elem

-					   which is not constant */

-					break;

-				case RV_ACTION_ST:

-					/* cannot be optimized further, is not constant and

-					  eval_elem() does not support ACTION_ST for op!=NO_OP*/

-					break;

-				case RV_SEL:

-					exp->r.select=pkg_malloc(sizeof(*exp->l.select));

-					if (exp->r.select){

-						exp->r_type=SELECT_ST;

-						*exp->r.select=rval->v.sel;

-						rval_destroy(rval);

-						pkg_free(rve);

-						ret=1;

-					}else

-						ret=-1;

-					break;

-				case RV_AVP:

-					exp->r.attr=pkg_malloc(sizeof(*exp->l.attr));

-					if (exp->r.attr){

-						exp->r_type=AVP_ST;

-						*exp->r.attr=rval->v.avps;

-						rval_destroy(rval);

-						pkg_free(rve);

-						ret=1;

-					}else

-						ret=-1;

-					break;

-				case RV_PVAR:

-					exp->r.param=pkg_malloc(sizeof(pv_spec_t));

-					if (exp->r.param){

-						exp->r_type=PVAR_ST;

-						*((pv_spec_t*)exp->r.param)=rval->v.pvs;

-						rval_destroy(rval);

-						pkg_free(rve);

-						ret=1;

-					}else

-						ret=-1;

-					break;

-				case RV_NONE:

-					ret=-1;

-					break;

-			}

-		}

-	}

-	if (ret>0)

-		LM_DBG("op%d(O%d, _ST%d_) => op%d(O%d, _ST%d_)\n",

-			old_op, old_ltype, old_rtype, exp->op, exp->l_type, exp->r_type);

-	return ret;

-}

-

-

-

-/* traverses an expr tree and compiles the REs where necessary)

- * returns: 0 for ok, <0 if errors */

-int fix_expr(struct expr* exp)

-{

-	regex_t* re;

-	int ret;

-	int len;

-

-	ret=E_BUG;

-	if (exp==0){

-		LM_CRIT("null pointer\n");

-		return E_BUG;

-	}

-	if (exp->type==EXP_T){

-		switch(exp->op){

-			case LOGAND_OP:

-			case LOGOR_OP:

-						if ((ret=fix_expr(exp->l.expr))!=0)

-							return ret;

-						ret=fix_expr(exp->r.expr);

-						break;

-			case NOT_OP:

-						ret=fix_expr(exp->l.expr);

-						break;

-			default:

-						LM_CRIT("unknown op %d\n", exp->op);

-		}

-	}else if (exp->type==ELEM_T){

-			/* first calculate lengths of strings  (only right side, since 

-			  left side can never be a string) */

-			if (exp->r_type==STRING_ST) {

-				if (exp->r.string) len = strlen(exp->r.string);

-				else len = 0;

-				exp->r.str.s = exp->r.string;

-				exp->r.str.len = len;

-			}

-			/* then fix & optimize rve/rvals (they might be optimized

-			   to non-rvals, e.g. string, avp a.s.o and needs to be done

-			   before MATCH_OP and other fixups) */

-			if (exp->l_type==RVEXP_O){

-				if ((ret=fix_rval_expr(exp->l.param))<0){

-					LM_ERR("Unable to fix left rval expression\n");

-					return ret;

-				}

-				if (scr_opt_lev>=2)

-					exp_optimize_left(exp);

-			}

-			if (exp->r_type==RVE_ST){

-				if ((ret=fix_rval_expr(exp->r.param))<0){

-					LM_ERR("Unable to fix right rval expression\n");

-					return ret;

-				}

-				if (scr_opt_lev>=2)

-					exp_optimize_right(exp);

-			}

-			

-			

-			if (exp->op==MATCH_OP){

-				     /* right side either has to be string, in which case

-				      * we turn it into regular expression, or it is regular

-				      * expression already. In that case we do nothing

-				      */

-				if (exp->r_type==STRING_ST){

-					re=(regex_t*)pkg_malloc(sizeof(regex_t));

-					if (re==0){

-						LM_CRIT("memory allocation failure\n");

-						return E_OUT_OF_MEM;

-					}

-					if (regcomp(re, (char*) exp->r.param,

-								REG_EXTENDED|REG_NOSUB|REG_ICASE) ){

-						LM_CRIT("bad re \"%s\"\n", (char*) exp->r.param);

-						pkg_free(re);

-						return E_BAD_RE;

-					}

-					/* replace the string with the re */

-					pkg_free(exp->r.param);

-					exp->r.re=re;

-					exp->r_type=RE_ST;

-				}else if (exp->r_type!=RE_ST && exp->r_type != AVP_ST

-						&& exp->r_type != SELECT_ST &&

-						exp->r_type != SELECT_UNFIXED_ST &&

-						exp->r_type!= RVE_ST

-						&& exp->r_type != PVAR_ST){

-					LM_CRIT("invalid type for match\n");

-					return E_BUG;

-				}

-			}

-			if (exp->l_type==ACTION_O){

-				ret=fix_actions((struct action*)exp->r.param);

-				if (ret!=0){

-					LM_CRIT("fix_actions error\n");

-					return ret;

-				}

-			}

-			if (exp->l_type==SELECT_UNFIXED_O) {

-				if ((ret=resolve_select(exp->l.select)) < 0) {

-					LM_ERR("Unable to resolve select\n");

-					print_select(exp->l.select);

-					return ret;

-				}

-				exp->l_type=SELECT_O;

-			}

-			if (exp->r_type==SELECT_UNFIXED_ST) {

-				if ((ret=resolve_select(exp->r.select)) < 0) {

-					LM_ERR("Unable to resolve select\n");

-					print_select(exp->r.select);

-					return ret;

-				}

-				exp->r_type=SELECT_ST;

-			}

-			/* PVAR don't need fixing */

-			ret=0;

-	}

-	return ret;

-}

-

-

-

-/* adds the proxies in the proxy list & resolves the hostnames */

-/* returns 0 if ok, <0 on error */

-int fix_actions(struct action* a)

-{

-	struct action *t;

-	struct proxy_l* p;

-	char *tmp;

-	void *tmp_p;

-	int ret;

-	int i;

-	sr31_cmd_export_t* cmd;

-	str s;

-	struct hostent* he;

-	struct ip_addr ip;

-	struct socket_info* si;

-	struct lvalue* lval;

-	struct rval_expr* rve;

-	struct rval_expr* err_rve;

-	enum rval_type rve_type, err_type, expected_type;

-	struct rvalue* rv;

-	int rve_param_no;

-

-	if (a==0){

-		LM_CRIT("null pointer\n");

-		return E_BUG;

-	}

-	for(t=a; t!=0; t=t->next){

-		switch(t->type){

-			case FORWARD_T:

-			case FORWARD_TLS_T:

-			case FORWARD_TCP_T:

-			case FORWARD_SCTP_T:

-			case FORWARD_UDP_T:

-					switch(t->val[0].type){

-						case IP_ST:

-							tmp=strdup(ip_addr2a(

-										(struct ip_addr*)t->val[0].u.data));

-							if (tmp==0){

-								LM_CRIT("memory allocation failure\n");

-								ret = E_OUT_OF_MEM;

-								goto error;

-							}

-							t->val[0].type=STRING_ST;

-							t->val[0].u.string=tmp;

-							/* no break */

-						case STRING_ST:

-							s.s = t->val[0].u.string;

-							s.len = strlen(s.s);

-							p=add_proxy(&s, t->val[1].u.number, 0); /* FIXME proto*/

-							if (p==0) { ret =E_BAD_ADDRESS; goto error; }

-							t->val[0].u.data=p;

-							t->val[0].type=PROXY_ST;

-							break;

-						case URIHOST_ST:

-							break;

-						default:

-							LM_CRIT("invalid type %d (should be string or number)\n",

-										t->type);

-							ret = E_BUG;

-							goto error;

-					}

-					break;

-			case IF_T:

-				if (t->val[0].type!=RVE_ST){

-					LM_CRIT("invalid subtype %d for if (should be rval expr)\n",

-								t->val[0].type);

-					ret = E_BUG;

-					goto error;

-				}else if( (t->val[1].type!=ACTIONS_ST) &&

-							(t->val[1].type!=NOSUBTYPE) ){

-					LM_CRIT("invalid subtype %d for if() {...} (should be action)\n",

-								t->val[1].type);

-					ret = E_BUG;

-					goto error;

-				}else if( (t->val[2].type!=ACTIONS_ST) &&

-							(t->val[2].type!=NOSUBTYPE) ){

-					LM_CRIT("invalid subtype %d for if() {} else{...}(should be action)\n",

-								t->val[2].type);

-					ret = E_BUG;

-					goto error;

-				}

-				rve=(struct rval_expr*)t->val[0].u.data;

-				if (rve){

-					err_rve=0;

-					if (!rve_check_type(&rve_type, rve, &err_rve,

-											&err_type, &expected_type)){

-						if (err_rve)

-							LM_ERR("invalid expression "

-									"(%d,%d): subexpression (%d,%d) has type"

-									" %s,  but %s is expected\n",

-									rve->fpos.s_line, rve->fpos.s_col,

-									err_rve->fpos.s_line, err_rve->fpos.s_col,

-									rval_type_name(err_type),

-									rval_type_name(expected_type) );

-						else

-							LM_ERR("invalid expression  (%d,%d): type mismatch?",

-									rve->fpos.s_line, rve->fpos.s_col);

-						ret = E_SCRIPT;

-						goto error;

-					}

-					/* it's not an error anymore to have non-int in an if,

-					   only a script warning (to allow backward compat. stuff

-					   like if (@ruri) 

-					if (rve_type!=RV_INT && rve_type!=RV_NONE){

-						LM_ERR("fix_actions: invalid expression (%d,%d):"

-								" bad type, integer expected\n",

-								rve->fpos.s_line, rve->fpos.s_col);

-						return E_UNSPEC;

-					}

-					*/

-					if ((ret=fix_rval_expr(t->val[0].u.data))<0)

-						goto error;

-				}

-				if ( (t->val[1].type==ACTIONS_ST)&&(t->val[1].u.data) ){

-					if ((ret=fix_actions((struct action*)t->val[1].u.data))<0)

-						goto error;

-				}

-				if ( (t->val[2].type==ACTIONS_ST)&&(t->val[2].u.data) ){

-						if ((ret=fix_actions((struct action*)t->val[2].u.data))

-								<0)

-						goto error;

-				}

-				break;

-			case SWITCH_T:

-				if (t->val[0].type!=RVE_ST){

-					LM_CRIT("invalid subtype %d for switch() (should be expr)\n",

-								t->val[0].type);

-					ret = E_BUG;

-					goto error;

-				}else if (t->val[1].type!=CASE_ST){

-					LM_CRIT("invalid subtype %d for switch(...){...}(should be case)\n",

-								t->val[1].type);

-					ret = E_BUG;

-					goto error;

-				}

-				if (t->val[0].u.data){

-					if ((ret=fix_rval_expr(t->val[0].u.data))<0)

-						goto error;

-				}else{

-					LM_CRIT("null switch() expression\n");

-					ret = E_BUG;

-					goto error;

-				}

-				if ((ret=fix_switch(t))<0)

-					goto error;

-				break;

-			case WHILE_T:

-				if (t->val[0].type!=RVE_ST){

-					LM_CRIT("invalid subtype %d for while() (should be expr)\n",

-								t->val[0].type);

-					ret = E_BUG;

-					goto error;

-				}else if (t->val[1].type!=ACTIONS_ST){

-					LM_CRIT("invalid subtype %d for while(...){...}(should be action)\n",

-								t->val[1].type);

-					ret = E_BUG;

-					goto error;

-				}

-				rve=(struct rval_expr*)t->val[0].u.data;

-				if (rve){

-					err_rve=0;

-					if (!rve_check_type(&rve_type, rve, &err_rve,

-											&err_type, &expected_type)){

-						if (err_rve)

-							LM_ERR("invalid expression "

-									"(%d,%d): subexpression (%d,%d) has type"

-									" %s,  but %s is expected\n",

-									rve->fpos.s_line, rve->fpos.s_col,

-									err_rve->fpos.s_line, err_rve->fpos.s_col,

-									rval_type_name(err_type),

-									rval_type_name(expected_type) );

-						else

-							LM_ERR("invalid expression (%d,%d): type mismatch?",

-									rve->fpos.s_line, rve->fpos.s_col);

-						ret = E_SCRIPT;

-						goto error;

-					}

-					if (rve_type!=RV_INT && rve_type!=RV_NONE){

-						LM_ERR("invalid expression (%d,%d): bad type, integer expected\n",

-								rve->fpos.s_line, rve->fpos.s_col);

-						ret = E_SCRIPT;

-						goto error;

-					}

-					if ((ret=fix_rval_expr(t->val[0].u.data))<0)

-						goto error;

-				}else{

-					LM_CRIT("null while() expression\n");

-					ret = E_BUG;

-					goto error;

-				}

-				if ( t->val[1].u.data && 

-					((ret= fix_actions((struct action*)t->val[1].u.data))<0)){

-					goto error;

-				}

-				break;

-			case DROP_T:

-				/* only RVEs need fixing for drop/return/break */

-				if (t->val[0].type!=RVE_ST)

-					break;

-				rve=(struct rval_expr*)t->val[0].u.data;

-				if (rve){

-					err_rve=0;

-					if (!rve_check_type(&rve_type, rve, &err_rve,

-											&err_type, &expected_type)){

-						if (err_rve)

-							LM_ERR("invalid expression "

-									"(%d,%d): subexpression (%d,%d) has type"

-									" %s,  but %s is expected\n",

-									rve->fpos.s_line, rve->fpos.s_col,

-									err_rve->fpos.s_line, err_rve->fpos.s_col,

-									rval_type_name(err_type),

-									rval_type_name(expected_type) );

-						else

-							LM_ERR("invalid expression (%d,%d): type mismatch?",

-									rve->fpos.s_line, rve->fpos.s_col);

-						ret = E_SCRIPT;

-						goto error;

-					}

-					if (rve_type!=RV_INT && rve_type!=RV_NONE){

-						LM_ERR("invalid expression (%d,%d): bad type, integer expected\n",

-								rve->fpos.s_line, rve->fpos.s_col);

-						ret = E_SCRIPT;

-						goto error;

-					}

-					if ((ret=fix_rval_expr(t->val[0].u.data))<0)

-						goto error;

-				}else{

-					LM_CRIT("null drop/return expression\n");

-					ret = E_BUG;

-					goto error;

-				}

-				break;

-			case ASSIGN_T:

-			case ADD_T:

-				if (t->val[0].type !=LVAL_ST) {

-					LM_CRIT("Invalid left side of assignment\n");

-					ret = E_BUG;

-					goto error;

-				}

-				if (t->val[1].type !=RVE_ST) {

-					LM_CRIT("Invalid right side of assignment (%d)\n",

-								t->val[1].type);

-					ret = E_BUG;

-					goto error;

-				}

-				lval=t->val[0].u.data;

-				if (lval->type==LV_AVP){

-					if (lval->lv.avps.type & AVP_CLASS_DOMAIN) {

-						LM_ERR("You cannot change domain"

-									" attributes from the script, they are"

-									" read-only\n");

-						ret = E_BUG;

-						goto error;

-					} else if (lval->lv.avps.type & AVP_CLASS_GLOBAL) {

-						LM_ERR("You cannot change global"

-								   " attributes from the script, they are"

-								   "read-only\n");

-						ret = E_BUG;

-						goto error;

-					}

-				}

-				if ((ret=fix_rval_expr(t->val[1].u.data))<0)

-					goto error;

-				break;

-

-			case MODULE0_T:

-			case MODULE1_T:

-			case MODULE2_T:

-			case MODULE3_T:

-			case MODULE4_T:

-			case MODULE5_T:

-			case MODULE6_T:

-			case MODULEX_T:

-				cmd = t->val[0].u.data;

-				rve_param_no = 0;

-				if (cmd) {

-					LM_DBG("fixing %s()\n", cmd->name);

-					if (t->val[1].u.number==0) {

-						ret = call_fixup(cmd->fixup, 0, 0);

-						if (ret < 0)

-							goto error;

-					}

-					for (i=0; i < t->val[1].u.number; i++) {

-						if (t->val[i+2].type == RVE_ST) {