sr-dev April 2009

sr-dev@lists.kamailio.org

13 participants
230 discussions

git:andrei/type_conversion: core expr eval: fix assoc., commut and 0 adding for +, ==

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/type_conversion Commit: 3c8fc182ae386713f15e6a0362924e72b257c31e URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=3c8fc18… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Tue Apr 28 18:34:03 2009 +0200 core expr eval: fix assoc., commut and 0 adding for +, == - fix associativity for the generic plus: because of the non-fixed argument types (can work with strings integers or both in the same type), RVE_PLUS_OP is associative _only_ if the operand types match. Non-assoc. example: "a" + 1 + "2" (can be "a12" or "a3"). Instead of adding extra checks for the same type, rely on the optimizer having already replaced RVE_PLUS_OP with RVE_IPLUS_OP or RVE_CONCAT_OP => RVE_PLUS_OP will be used only when the operands types are mixed or cannot be determined (e.g. AVP), or when script optimizations are turned off (-O0). - fix commutativity for the generic plus. Similar to the above. Non-commut. example: 1 + "2" == 3, but "2" + 1 == "21". - fix commutativity for the generic == and !=. Non. commut. example: 0 == "" , but "" != 0. Similar fix as above, relying on the optimizer and the type specific operators: RVE_IEQ_OP, RVE_IDIFF_OP, RVE_STREQ_OP and RVE_STRDIFF_OP. - fix $v + 0 / 0 + $v -> $v optimizations. Because of the generic plus and recent changes that allow int + str, even if the result is an int (left side operant is integer), 0 + $v can be different from $v. E.g.: 0+"1" == 1, which is different from "1". --- rvalue.c | 37 +++++++++++++++++++++++++++---------- 1 files changed, 27 insertions(+), 10 deletions(-) diff --git a/rvalue.c b/rvalue.c index 7e82503..9a74cda 100644 --- a/rvalue.c +++ b/rvalue.c @@ -2281,6 +2281,9 @@ static int rve_op_is_assoc(enum rval_expr_op op) case RVE_MINUS_OP: return 0; case RVE_PLUS_OP: + /* the generic plus is not assoc, e.g. + "a" + 1 + "2" => "a12" in one case and "a3" in the other */ + return 0; case RVE_IPLUS_OP: case RVE_CONCAT_OP: case RVE_MUL_OP: @@ -2308,7 +2311,7 @@ static int rve_op_is_assoc(enum rval_expr_op op) /** returns true if the operator is commutative. */ -static int rve_op_is_commutative(enum rval_expr_op op, enum rval_type type) +static int rve_op_is_commutative(enum rval_expr_op op) { switch(op){ case RVE_NONE_OP: @@ -2325,7 +2328,10 @@ static int rve_op_is_commutative(enum rval_expr_op op, enum rval_type type) case RVE_MINUS_OP: return 0; case RVE_PLUS_OP: - return type==RV_INT; /* commutative only for INT*/ + /* non commut. when diff. type + (e.g 1 + "2" != "2" + 1 ) => non commut. in general + (specific same type versions are covered by IPLUS & CONCAT) */ + return 0; case RVE_IPLUS_OP: case RVE_MUL_OP: case RVE_BAND_OP: @@ -2345,11 +2351,11 @@ static int rve_op_is_commutative(enum rval_expr_op op, enum rval_type type) return 0; case RVE_DIFF_OP: case RVE_EQ_OP: -#if !defined(UNDEF_EQ_ALWAYS_FALSE) && !defined(UNDEF_EQ_UNDEF_TRUE) - return 1; -#else + /* non. commut. in general, only for same type e.g.: + "" == 0 diff. 0 == "" ( "" == "0" and 0 == 0) + same type versions are covered by IEQ, IDIFF, STREQ, STRDIFF + */ return 0 /* asymmetrical undef handling */; -#endif } return 0; } @@ -2658,8 +2664,19 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) case RVE_PLUS_OP: case RVE_IPLUS_OP: /* we must make sure that this is an int PLUS - (because "foo"+0 is valid => "foo0") */ - if ((i==0) && ((op==RVE_IPLUS_OP)||(rve_type==RV_INT))){ + (because "foo"+0 is valid => "foo0") + Even if overall type is RV_INT, it's still not safe + to optimize a generic PLUS: 0 + $v is not always equivalent + to $v (e.g. 0+"1" ==1 != "1") => optimize only if + IPLUS (always safe since it converts to int first) or + if generic PLUS and result is integer (rve_type) and + expression is of the form $v+ct (and not ct+$v). + TODO: dropping PLUS_OP all together and relying on the + optimizer replacing safe PLUS_OP with IPLUS_OP or CONCAT_OP + will simplify things. + */ + if ((i==0) && ((op==RVE_IPLUS_OP)|| + (rve_type==RV_INT && ct_rve==rve->right.rve))){ /* $v + 0 -> $v * 0 + $v -> $v */ rve_destroy(ct_rve); @@ -2908,7 +2925,7 @@ static int rve_optimize(struct rval_expr* rve) trv->v.s.len, trv->v.s.s, rve->op); ret=1; }else if (rve_is_constant(rve->left.rve->left.rve) && - rve_op_is_commutative(rve->op, type)){ + rve_op_is_commutative(rve->op)){ /* op(op(a, $v), b) => op(op(a, b), $v) */ /* rv= op(a, b) */ tmp_rve.op=rve->op; @@ -2950,7 +2967,7 @@ static int rve_optimize(struct rval_expr* rve) if ((rve->op==rve->right.rve->op) && rve_op_is_assoc(rve->op)){ /* op(a, op(...)) */ if (rve_is_constant(rve->right.rve->right.rve) && - rve_op_is_commutative(rve->op, type)){ + rve_op_is_commutative(rve->op)){ /* op(a, op($v, b)) => op(op(a, b), $v) */ /* rv= op(a, b) */ tmp_rve.op=rve->op;

15 years

git:andrei/type_conversion: core expr eval: minor ==/!= optimization

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/type_conversion Commit: 04ff69818798e2330587c4109a69d8974908b158 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=04ff698… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Tue Apr 28 17:49:54 2009 +0200 core expr eval: minor ==/!= optimization - replace the generic RVE_EQ_OP/RVE_DIFF_OP with the type specific version (RVE_IEQ_OP/RVE_STREQ_OP...), if the type is known. --- rvalue.c | 23 +++++++++++++++++++++-- 1 files changed, 21 insertions(+), 2 deletions(-) diff --git a/rvalue.c b/rvalue.c index 36c6ef4..7e82503 100644 --- a/rvalue.c +++ b/rvalue.c @@ -2341,10 +2341,10 @@ static int rve_op_is_commutative(enum rval_expr_op op, enum rval_type type) case RVE_GTE_OP: case RVE_LT_OP: case RVE_LTE_OP: - case RVE_EQ_OP: + case RVE_CONCAT_OP: return 0; case RVE_DIFF_OP: - case RVE_CONCAT_OP: + case RVE_EQ_OP: #if !defined(UNDEF_EQ_ALWAYS_FALSE) && !defined(UNDEF_EQ_UNDEF_TRUE) return 1; #else @@ -2838,6 +2838,25 @@ static int rve_optimize(struct rval_expr* rve) rve->fpos.e_line, rve->fpos.e_col); } } + /* e1 EQ_OP e2 -> change op if we know e1 basic type + e1 DIFF_OP e2 -> change op if we know e2 basic type */ + if (rve->op==RVE_EQ_OP || rve->op==RVE_DIFF_OP){ + l_type=rve_guess_type(rve->left.rve); + if (l_type==RV_INT){ + rve->op=(rve->op==RVE_EQ_OP)?RVE_IEQ_OP:RVE_IDIFF_OP; + DBG("FIXUP RVE (%d,%d-%d,%d): changed ==/!= into interger" + " ==/!=\n", + rve->fpos.s_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.e_col); + }else if (l_type==RV_STR){ + rve->op=RVE_CONCAT_OP; + rve->op=(rve->op==RVE_EQ_OP)?RVE_STREQ_OP:RVE_STRDIFF_OP; + DBG("FIXUP RVE (%d,%d-%d,%d): changed ==/!= into string" + " ==/!=\n", + rve->fpos.s_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.e_col); + } + } /* $v * 0 => 0; $v * 1 => $v (for *, /, &, |, &&, ||, +, -) */ if (rve_opt_01(rve, type)==1){

15 years

git:andrei/type_conversion: core expr eval: internal == & != int and str only versions

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/type_conversion Commit: 783ad9b3e0ebdee05a8e1f710c0e14da777c9ada URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=783ad9b… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Tue Apr 28 17:39:35 2009 +0200 core expr eval: internal == & != int and str only versions - added RVE_IEQ_OP and RVE_IDIFF_OP - internal integer only (force argument conversion to int) operators - added RVE_STREQ and RVE_STRDIFF_OP - internal string only (force argument conversion to str) operators --- rvalue.c | 111 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++----- rvalue.h | 6 +++ 2 files changed, 108 insertions(+), 9 deletions(-) diff --git a/rvalue.c b/rvalue.c index 2961ee9..36c6ef4 100644 --- a/rvalue.c +++ b/rvalue.c @@ -38,7 +38,7 @@ * UNDEF_EQ_UNDEF_TRUE : undef == something false except for undef==undef * which is true * no UNDEF_EQ* define : undef == expr => convert undef to typeof(expr) - * and perorm normal ==. undef == undef will be + * and perform normal ==. undef == undef will be * converted to string and it will be true * ("" == "") * NOTE: expr == undef, with defined(expr) is always evaluated this way: @@ -411,6 +411,10 @@ enum rval_type rve_guess_type( struct rval_expr* rve) case RVE_LTE_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_IEQ_OP: + case RVE_IDIFF_OP: + case RVE_STREQ_OP: + case RVE_STRDIFF_OP: case RVE_IPLUS_OP: case RVE_STRLEN_OP: case RVE_STREMPTY_OP: @@ -471,6 +475,10 @@ int rve_is_constant(struct rval_expr* rve) case RVE_LTE_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_IEQ_OP: + case RVE_IDIFF_OP: + case RVE_STREQ_OP: + case RVE_STRDIFF_OP: case RVE_PLUS_OP: case RVE_IPLUS_OP: case RVE_CONCAT_OP: @@ -523,6 +531,10 @@ static int rve_op_unary(enum rval_expr_op op) case RVE_LTE_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_IEQ_OP: + case RVE_IDIFF_OP: + case RVE_STREQ_OP: + case RVE_STRDIFF_OP: case RVE_PLUS_OP: case RVE_IPLUS_OP: case RVE_CONCAT_OP: @@ -585,6 +597,8 @@ int rve_check_type(enum rval_type* type, struct rval_expr* rve, case RVE_GTE_OP: case RVE_LT_OP: case RVE_LTE_OP: + case RVE_IEQ_OP: + case RVE_IDIFF_OP: case RVE_IPLUS_OP: *type=RV_INT; if (rve_check_type(&type1, rve->left.rve, bad_rve, bad_t, exp_t)){ @@ -665,6 +679,30 @@ int rve_check_type(enum rval_type* type, struct rval_expr* rve, } } break; + case RVE_STREQ_OP: + case RVE_STRDIFF_OP: + *type=RV_INT; + if (rve_check_type(&type1, rve->left.rve, bad_rve, bad_t, exp_t)){ + if (rve_check_type(&type2, rve->right.rve, bad_rve, bad_t, + exp_t)){ + if ((type2!=type1) && (type1!=RV_NONE) && + (type2!=RV_NONE) && + !(type1==RV_STR && type2==RV_INT)){ + if (bad_rve) *bad_rve=rve->right.rve; + if (bad_t) *bad_t=type2; + if (exp_t) *exp_t=type1; + return 0; + } + if (type1==RV_INT){ + if (bad_rve) *bad_rve=rve->left.rve; + if (bad_t) *bad_t=type1; + if (exp_t) *exp_t=RV_STR; + return 0; + } + return 1; + } + } + break; case RVE_STRLEN_OP: case RVE_STREMPTY_OP: case RVE_DEFINED_OP: @@ -1136,9 +1174,11 @@ inline static int int_intop2(int* res, enum rval_expr_op op, int v1, int v2) *res=v1 <= v2; break; case RVE_EQ_OP: + case RVE_IEQ_OP: *res=v1 == v2; break; case RVE_DIFF_OP: + case RVE_IDIFF_OP: *res=v1 != v2; break; case RVE_CONCAT_OP: @@ -1157,12 +1197,19 @@ inline static int int_intop2(int* res, enum rval_expr_op op, int v1, int v2) inline static int bool_strop2( enum rval_expr_op op, int* res, str* s1, str* s2) { - if (s1->len!=s2->len) - *res= op==RVE_DIFF_OP; - else if (memcmp(s1->s, s2->s, s1->len)==0) - *res= op==RVE_EQ_OP; - else - *res= op==RVE_DIFF_OP; + switch(op){ + case RVE_EQ_OP: + case RVE_STREQ_OP: + *res= (s1->len==s2->len) && (memcmp(s1->s, s2->s, s1->len)==0); + break; + case RVE_DIFF_OP: + case RVE_STRDIFF_OP: + *res= (s1->len!=s2->len) || (memcmp(s1->s, s2->s, s1->len)!=0); + break; + default: + BUG("rv unsupported intop %d\n", op); + return -1; + } return 0; } @@ -1593,6 +1640,8 @@ int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg, case RVE_GTE_OP: case RVE_LT_OP: case RVE_LTE_OP: + case RVE_IEQ_OP: + case RVE_IDIFF_OP: if (unlikely( (ret=rval_expr_eval_int(h, msg, &i1, rve->left.rve)) <0) ) break; @@ -1735,6 +1784,21 @@ int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg, case RVE_DEFINED_OP: ret=int_rve_defined(h, msg, res, rve->left.rve); break; + case RVE_STREQ_OP: + case RVE_STRDIFF_OP: + if (unlikely((rv1=rval_expr_eval(h, msg, rve->left.rve))==0)){ + ret=-1; + break; + } + if (unlikely((rv2=rval_expr_eval(h, msg, rve->right.rve))==0)){ + rval_destroy(rv1); + ret=-1; + break; + } + ret=rval_str_lop2(h, msg, res, rve->op, rv1, 0, rv2, 0); + rval_destroy(rv1); + rval_destroy(rv2); + break; case RVE_STRLEN_OP: case RVE_STREMPTY_OP: if (unlikely((rv1=rval_expr_eval(h, msg, rve->left.rve))==0)){ @@ -1815,7 +1879,11 @@ int rval_expr_eval_rvint( struct run_act_ctx* h, case RVE_LTE_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_IEQ_OP: + case RVE_IDIFF_OP: case RVE_IPLUS_OP: + case RVE_STREQ_OP: + case RVE_STRDIFF_OP: case RVE_STRLEN_OP: case RVE_STREMPTY_OP: case RVE_DEFINED_OP: @@ -1913,7 +1981,11 @@ struct rvalue* rval_expr_eval(struct run_act_ctx* h, struct sip_msg* msg, case RVE_LTE_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_IEQ_OP: + case RVE_IDIFF_OP: case RVE_IPLUS_OP: + case RVE_STREQ_OP: + case RVE_STRDIFF_OP: case RVE_STRLEN_OP: case RVE_STREMPTY_OP: case RVE_DEFINED_OP: @@ -2168,6 +2240,10 @@ struct rval_expr* mk_rval_expr2(enum rval_expr_op op, struct rval_expr* rve1, case RVE_IPLUS_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_IEQ_OP: + case RVE_IDIFF_OP: + case RVE_STREQ_OP: + case RVE_STRDIFF_OP: case RVE_CONCAT_OP: break; default: @@ -2220,6 +2296,10 @@ static int rve_op_is_assoc(enum rval_expr_op op) case RVE_LTE_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_IEQ_OP: + case RVE_IDIFF_OP: + case RVE_STREQ_OP: + case RVE_STRDIFF_OP: return 0; } return 0; @@ -2250,18 +2330,26 @@ static int rve_op_is_commutative(enum rval_expr_op op, enum rval_type type) case RVE_MUL_OP: case RVE_BAND_OP: case RVE_BOR_OP: - return 1; case RVE_LAND_OP: case RVE_LOR_OP: + case RVE_IEQ_OP: + case RVE_IDIFF_OP: + case RVE_STREQ_OP: + case RVE_STRDIFF_OP: return 1; case RVE_GT_OP: case RVE_GTE_OP: case RVE_LT_OP: case RVE_LTE_OP: case RVE_EQ_OP: + return 0; case RVE_DIFF_OP: case RVE_CONCAT_OP: - return 0; +#if !defined(UNDEF_EQ_ALWAYS_FALSE) && !defined(UNDEF_EQ_UNDEF_TRUE) + return 1; +#else + return 0 /* asymmetrical undef handling */; +#endif } return 0; } @@ -2633,6 +2721,7 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) } break; case RVE_EQ_OP: + case RVE_STREQ_OP: if (rv->v.s.len==0){ /* $v == "" -> strempty($v) "" == $v -> strempty ($v) */ @@ -2973,6 +3062,10 @@ int fix_rval_expr(void** p) case RVE_IPLUS_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_IEQ_OP: + case RVE_IDIFF_OP: + case RVE_STREQ_OP: + case RVE_STRDIFF_OP: case RVE_CONCAT_OP: ret=fix_rval_expr((void**)&rve->left.rve); if (ret<0) return ret; diff --git a/rvalue.h b/rvalue.h index e99d1f8..f7fdcc1 100644 --- a/rvalue.h +++ b/rvalue.h @@ -23,6 +23,8 @@ * History: * -------- * 2008-11-30 initial version (andrei) + * 2009-04-28 added string and interger versions for the EQ and DIFF + * operators (andrei) */ #ifndef _rvalue_h_ @@ -59,6 +61,8 @@ enum rval_expr_op{ RVE_GTE_OP, /* 2 members, returns left >= right */ RVE_LT_OP, /* 2 members, returns left < right */ RVE_LTE_OP, /* 2 members, returns left <= right */ + RVE_IEQ_OP, /* 2 members, int == version, returns left == right */ + RVE_IDIFF_OP,/* 2 members, int != version, returns left != right */ RVE_IPLUS_OP, /* 2 members, integer +, returns int(a)+int(b) */ /* common int & str */ RVE_PLUS_OP, /* generic plus (int or str) returns left + right */ @@ -68,6 +72,8 @@ enum rval_expr_op{ RVE_CONCAT_OP,/* 2 members, string concat, returns left . right (str)*/ RVE_STRLEN_OP, /* one member, string length:, returns strlen(val) (int)*/ RVE_STREMPTY_OP, /* one member, returns val=="" (bool) */ + RVE_STREQ_OP, /* 2 members, string == , returns left == right (bool)*/ + RVE_STRDIFF_OP,/* 2 members, string != , returns left != right (bool)*/ /* avp, pvars a.s.o */ RVE_DEFINED_OP, /* one member, returns is_defined(val) (bool) */ };

15 years

git:master: kex: script and branch flags operations

by Daniel-Constantin Mierla

Module: sip-router Branch: master Commit: 313f52655841f1abf4c0db585699cd31e9494a3f URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=313f526… Author: Daniel-Constantin Mierla <miconda(a)gmail.com> Committer: Daniel-Constantin Mierla <miconda(a)gmail.com> Date: Tue Apr 28 16:35:28 2009 +0200 kex: script and branch flags operations - K script and branch flags operations included in kex module - the parameters must be now enclosed in quotes - the parameters can be now integer value or Pseudo-Variable with integer value - the optional 'branch' parameter for branch flags parameters is now the second, for a more logical parameter mapping with the version without this parameter --- modules_k/kex/flags.c | 144 +++++++++++++++++++++++++++++++++++++++++++++++ modules_k/kex/flags.h | 35 +++++++++++ modules_k/kex/kex_mod.c | 29 +++++++++- 3 files changed, 205 insertions(+), 3 deletions(-) diff --git a/modules_k/kex/flags.c b/modules_k/kex/flags.c new file mode 100644 index 0000000..ae539d1 --- /dev/null +++ b/modules_k/kex/flags.c @@ -0,0 +1,144 @@ +/** + * $Id$ + * + * Copyright (C) 2009 + * + * This file is part of SIP-Router.org, a free SIP server. + * + * SIP-Router 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 + */ + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> + +#include "../../dprint.h" +#include "../../flags.h" +#include "../../dset.h" +#include "../../mod_fix.h" +#include "flags.h" + +int w_issflagset(struct sip_msg *msg, char *flag, str *s2) +{ + int fval=0; + if(fixup_get_ivalue(msg, (gparam_p)flag, &fval)!=0) + { + LM_ERR("no flag value\n"); + return -1; + } + if(fval<0 || fval>31) + return -1; + return issflagset((flag_t)fval); +} + +int w_resetsflag(struct sip_msg *msg, char *flag, str *s2) +{ + int fval=0; + if(fixup_get_ivalue(msg, (gparam_p)flag, &fval)!=0) + { + LM_ERR("no flag value\n"); + return -1; + } + if(fval<0 || fval>31) + return -1; + return resetsflag((flag_t)fval); +} + +int w_setsflag(struct sip_msg *msg, char *flag, char *s2) +{ + int fval=0; + if(fixup_get_ivalue(msg, (gparam_p)flag, &fval)!=0) + { + LM_ERR("no flag value\n"); + return -1; + } + if(fval<0 || fval>31) + return -1; + return setsflag((flag_t)fval); +} + +int w_isbflagset(struct sip_msg *msg, char *flag, str *idx) +{ + int fval=0; + int ival=0; + if(fixup_get_ivalue(msg, (gparam_p)flag, &fval)!=0) + { + LM_ERR("no flag value\n"); + return -1; + } + if(fval<0 || fval>31) + return -1; + if(idx!=0) + { + if(fixup_get_ivalue(msg, (gparam_p)idx, &ival)!=0) + { + LM_ERR("no idx value\n"); + return -1; + } + if(ival<0) + return -1; + } + return isbflagset(ival, (flag_t)fval); +} + +int w_resetbflag(struct sip_msg *msg, char *flag, str *idx) +{ + int fval=0; + int ival=0; + if(fixup_get_ivalue(msg, (gparam_p)flag, &fval)!=0) + { + LM_ERR("no flag value\n"); + return -1; + } + if(fval<0 || fval>31) + return -1; + if(idx!=0) + { + if(fixup_get_ivalue(msg, (gparam_p)idx, &ival)!=0) + { + LM_ERR("no idx value\n"); + return -1; + } + if(ival<0) + return -1; + } + return resetbflag(ival, (flag_t)fval); + +} + +int w_setbflag(struct sip_msg *msg, char *flag, char *idx) +{ + int fval=0; + int ival=0; + if(fixup_get_ivalue(msg, (gparam_p)flag, &fval)!=0) + { + LM_ERR("no flag value\n"); + return -1; + } + if(fval<0 || fval>31) + return -1; + if(idx!=0) + { + if(fixup_get_ivalue(msg, (gparam_p)idx, &ival)!=0) + { + LM_ERR("no idx value\n"); + return -1; + } + if(ival<0) + return -1; + } + return setbflag(ival, (flag_t)fval); +} + diff --git a/modules_k/kex/flags.h b/modules_k/kex/flags.h new file mode 100644 index 0000000..d0dbad4 --- /dev/null +++ b/modules_k/kex/flags.h @@ -0,0 +1,35 @@ +/** + * $Id$ + * + * Copyright (C) 2009 + * + * This file is part of SIP-Router.org, a free SIP server. + * + * SIP-Router 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 + */ + +#ifndef _KEX_FLAGS_H_ +#define _KEX_FLAGS_H_ + +#include "../../sr_module.h" + +int w_issflagset(struct sip_msg *msg, char *flag, str *s2); +int w_resetsflag(struct sip_msg *msg, char *flag, str *s2); +int w_setsflag(struct sip_msg *msg, char *flag, char *s2); +int w_isbflagset(struct sip_msg *msg, char *flag, str *idx); +int w_resetbflag(struct sip_msg *msg, char *flag, str *idx); +int w_setbflag(struct sip_msg *msg, char *flag, char *idx); + +#endif diff --git a/modules_k/kex/kex_mod.c b/modules_k/kex/kex_mod.c index c9c3ae3..e4960c0 100644 --- a/modules_k/kex/kex_mod.c +++ b/modules_k/kex/kex_mod.c @@ -3,9 +3,9 @@ * * Copyright (C) 2009 * - * This file is part of Kamailio, a free SIP server. + * This file is part of SIP-Router.org, a free SIP server. * - * Kamailio is free software; you can redistribute it and/or modify + * SIP-Router 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 @@ -26,7 +26,11 @@ #include "../../sr_module.h" #include "../../dprint.h" +#include "../../flags.h" +#include "../../dset.h" +#include "../../mod_fix.h" +#include "flags.h" #include "mi_core.h" #include "core_stats.h" @@ -38,10 +42,28 @@ MODULE_VERSION /** module functions */ static int mod_init(void); - void destroy(void); static cmd_export_t cmds[]={ + {"setsflag", (cmd_function)w_setsflag, 1,fixup_igp_null, + 0, ANY_ROUTE }, + {"resetsflag", (cmd_function)w_resetsflag, 1,fixup_igp_null, + 0, ANY_ROUTE }, + {"issflagset", (cmd_function)w_issflagset, 1,fixup_igp_null, + 0, ANY_ROUTE }, + {"setbflag", (cmd_function)w_setbflag, 1,fixup_igp_null, + 0, ANY_ROUTE }, + {"setbflag", (cmd_function)w_setbflag, 2,fixup_igp_igp, + 0, ANY_ROUTE }, + {"resetbflag", (cmd_function)w_resetbflag, 1,fixup_igp_null, + 0, ANY_ROUTE }, + {"resetbflag", (cmd_function)w_resetbflag, 2,fixup_igp_igp, + 0, ANY_ROUTE }, + {"isbflagset", (cmd_function)w_isbflagset, 1,fixup_igp_null, + 0, ANY_ROUTE }, + {"isbflagset", (cmd_function)w_isbflagset, 2,fixup_igp_igp, + 0, ANY_ROUTE }, + {0,0,0,0,0,0} }; @@ -93,3 +115,4 @@ void destroy(void) return; } +

15 years

git:master: kex: doxumentation for script and branch flags operations

by Daniel-Constantin Mierla

Module: sip-router Branch: master Commit: f9f5c079fb86378d9a665e7bfb7a902ac28fe398 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=f9f5c07… Author: Daniel-Constantin Mierla <miconda(a)gmail.com> Committer: Daniel-Constantin Mierla <miconda(a)gmail.com> Date: Tue Apr 28 16:34:21 2009 +0200 kex: doxumentation for script and branch flags operations --- modules_k/kex/README | 227 ++++++++++++++++++++++++++++++++++----- modules_k/kex/doc/kex_admin.xml | 193 +++++++++++++++++++++++++++++++++ 2 files changed, 393 insertions(+), 27 deletions(-) Diff: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commitdiff;h=f9f…

15 years

git:andrei/type_conversion: core eval expr: cache undefined results too

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/type_conversion Commit: a554337202cd05cd4b2c69177f9c42c9aca7ff9b URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=a554337… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Tue Apr 28 15:08:35 2009 +0200 core eval expr: cache undefined results too - internally cache undefined results of avp and pvar evaluations (using RV_NONE for the val_type), between calls. - fix wrong cache check for defined(pvar) (not used yet) --- rvalue.c | 28 +++++++++++++++------------- 1 files changed, 15 insertions(+), 13 deletions(-) diff --git a/rvalue.c b/rvalue.c index e815c24..14c1f16 100644 --- a/rvalue.c +++ b/rvalue.c @@ -114,7 +114,7 @@ void rve_destroy(struct rval_expr* rve) void rval_cache_clean(struct rval_cache* rvc) { - if (rvc->cache_type==RV_CACHE_PVAR){ + if ((rvc->cache_type==RV_CACHE_PVAR) && (rvc->val_type!=RV_NONE)){ pv_value_destroy(&rvc->c.pval); } rvc->cache_type=RV_CACHE_EMPTY; @@ -264,7 +264,7 @@ struct rvalue* rval_new(enum rval_type t, union rval_val* v, int extra_size) * rval_cache_clean()'en when no longer needed. * * @param rv - target rvalue - * @param val_cache - value cache, might be filled if non-null, + * @param val_cache - write-only: value cache, might be filled if non-null, * it _must_ be rval_cache_clean()'en when done. * @return - basic type or RV_NONE on error */ @@ -291,6 +291,7 @@ inline static enum rval_type rval_get_btype(struct run_act_ctx* h, case RV_PVAR: if (likely(val_cache && val_cache->cache_type==RV_CACHE_EMPTY)){ pv=&val_cache->c.pval; + val_cache->cache_type=RV_CACHE_PVAR; }else{ val_cache=0; pv=&tmp_pval; @@ -298,24 +299,26 @@ inline static enum rval_type rval_get_btype(struct run_act_ctx* h, memset(pv, 0, sizeof(tmp_pval)); if (likely(pv_get_spec_value(msg, &rv->v.pvs, pv)==0)){ if (pv->flags & PV_VAL_STR){ - if (unlikely(val_cache==0)) pv_value_destroy(pv); - else{ - val_cache->cache_type=RV_CACHE_PVAR; + if (likely(val_cache!=0)) val_cache->val_type=RV_STR; - } + else + pv_value_destroy(pv); return RV_STR; }else if (pv->flags & PV_TYPE_INT){ - if (unlikely(val_cache==0)) pv_value_destroy(pv); - else{ - val_cache->cache_type=RV_CACHE_PVAR; + if (likely(val_cache!=0)) val_cache->val_type=RV_INT; - } + else + pv_value_destroy(pv); return RV_INT; }else{ pv_value_destroy(pv); + if (likely(val_cache!=0)) + val_cache->val_type=RV_NONE; /* undefined */ goto error; } }else{ + if (likely(val_cache!=0)) + val_cache->val_type=RV_NONE; /* undefined */ goto error; } break; @@ -340,7 +343,6 @@ inline static enum rval_type rval_get_btype(struct run_act_ctx* h, } }else{ *ptype=RV_NONE; - if (val_cache) val_cache->cache_type=RV_CACHE_EMPTY; goto error; } break; @@ -753,7 +755,7 @@ int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, break; case RV_PVAR: if (unlikely(cache && cache->cache_type==RV_CACHE_PVAR)){ - if (likely((cache->val_type==RV_INT) || + if (likely((cache->val_type==RV_INT) || (cache->c.pval.flags & PV_VAL_INT))){ *i=cache->c.pval.ri; }else if (cache->val_type==RV_STR){ @@ -1496,7 +1498,7 @@ inline static int rv_defined(struct run_act_ctx* h, case RV_PVAR: /* PV_VAL_NULL or pv_get_spec_value error => undef */ if (unlikely(cache && cache->cache_type==RV_CACHE_PVAR)){ - *res=(cache->val_type==RV_NONE); + *res=(cache->val_type!=RV_NONE); }else{ memset(&pval, 0, sizeof(pval)); if (likely(pv_get_spec_value(msg, &rv->v.pvs, &pval)==0)){

15 years

git:andrei/type_conversion: core expr eval: special handling for undef cmp expr

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/type_conversion Commit: ab736da560c93b707653d342f7932f8b677e08fc URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=ab736da… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Tue Apr 28 16:07:23 2009 +0200 core expr eval: special handling for undef cmp expr undef == expression is evaluated in the following way: - default: (type_of(expression))(undef) == expression. If the expression is undef too, the whole comparison it's evaluated to true (internally it's evaluated to (str) undef == (str) undef => "" == "" => true). E.g.: undef == 0 -> (int)undef == 0 -> 0 == 0 -> true undef == "a" -> (str)undef == "a" -> ""=="a" -> false undef == undef -> true - if UNDEF_EQ_UNDEF_TRUE is defined, the == comparison is always false except for undef == undef which is true. E.g.: undef == 0 -> false ; undef == "" false - if UNDEF_EQ_ALWAY_FALSE is defined, the result is always false != is always the reverse of ==. Note: this covers only the case when undef is on the _left_ side (the case in which we do not know what to convert undef to). If the undef is on the right side, it will work like for any other comparison: expr == undef => expr == (type_of(expr)) undef. --- rvalue.c | 91 +++++++++++++++++++++++++++++++++++++++++++++++++++++-------- 1 files changed, 79 insertions(+), 12 deletions(-) diff --git a/rvalue.c b/rvalue.c index 14c1f16..2961ee9 100644 --- a/rvalue.c +++ b/rvalue.c @@ -26,7 +26,23 @@ * 2009-04-24 added support for defined, strempty, strlen (andrei) * 2009-04-28 int and str automatic conversions: (int)undef=0, * (str)undef="", (int)""=0, (int)"123"=123, (int)"abc"=0 - * (andrei) + * handle undef == expr, in function of the UNDEF_EQ_* defines. + * (andrei) + */ + +/* special defines: + * + * UNDEF_EQ_* - how to behave when undef is on the right side of a generic + * compare operator + * UNDEF_EQ_ALWAYS_FALSE: undef == something is always false + * UNDEF_EQ_UNDEF_TRUE : undef == something false except for undef==undef + * which is true + * no UNDEF_EQ* define : undef == expr => convert undef to typeof(expr) + * and perorm normal ==. undef == undef will be + * converted to string and it will be true + * ("" == "") + * NOTE: expr == undef, with defined(expr) is always evaluated this way: + expr == (type_of(expr))undef */ #include "rvalue.h" @@ -1549,7 +1565,7 @@ int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg, int* res, struct rval_expr* rve) { int i1, i2, ret; - struct rval_cache c1; + struct rval_cache c1, c2; struct rvalue* rv1; struct rvalue* rv2; @@ -1616,10 +1632,14 @@ int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg, case RVE_EQ_OP: case RVE_DIFF_OP: /* if left is string, eval left & right as string and - use string diff, else eval as int */ + * use string diff. + * if left is int eval as int using int diff + * if left is undef, look at right and convert to right type + */ rval_cache_init(&c1); if (unlikely( (ret=rval_expr_eval_rvint(h, msg, &rv1, &i1, rve->left.rve, &c1))<0)){ + /* error */ rval_cache_clean(&c1); break; } @@ -1628,20 +1648,67 @@ int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg, rval_cache_clean(&c1); if (unlikely( (ret=rval_expr_eval_int(h, msg, &i2, rve->right.rve)) <0) ) - break; + break; /* error */ ret=int_intop2(res, rve->op, i1, i2); }else{ - if (unlikely((rv2=rval_expr_eval(h, msg, - rve->right.rve))==0)){ + /* not int => str or undef */ + /* check for undefined left operand */ + if (unlikely( c1.cache_type!=RV_CACHE_EMPTY && + c1.val_type==RV_NONE)){ +#ifdef UNDEF_EQ_ALWAYS_FALSE + /* undef == something always false + undef != something always true*/ + ret=(rve->op==RVE_DIFF_OP); +#elif defined UNDEF_EQ_UNDEF_TRUE + /* undef == something defined always false + undef == undef true */ + if (int_rve_defined(h, msg, &i2, rve->right.rve)<0){ + /* error */ + rval_cache_clean(&c1); + rval_destroy(rv1); + break; + } + ret=(!i2) ^ (rve->op==RVE_DIFF_OP); +#else /* ! UNDEF_EQ_* */ + /* undef == val + * => convert to (type_of(val)) (undef) == val */ + rval_cache_init(&c2); + if (unlikely( (ret=rval_expr_eval_rvint(h, msg, &rv2, &i2, + rve->right.rve, &c2))<0)){ + /* error */ + rval_cache_clean(&c1); + rval_cache_clean(&c2); + rval_destroy(rv1); + break; + } + if (rv2==0){ + /* int */ + ret=int_intop2(res, rve->op, 0 /* undef */, i2); + }else{ + /* str or undef */ + ret=rval_str_lop2(h, msg, res, rve->op, rv1, &c1, + rv2, &c2); + rval_cache_clean(&c2); + rval_destroy(rv2); + } +#endif /* UNDEF_EQ_* */ + rval_cache_clean(&c1); rval_destroy(rv1); + }else{ + /* left value == defined and != int => str + * => lval == (str) val */ + if (unlikely((rv2=rval_expr_eval(h, msg, + rve->right.rve))==0)){ + /* error */ + rval_destroy(rv1); + rval_cache_clean(&c1); + break; + } + ret=rval_str_lop2(h, msg, res, rve->op, rv1, &c1, rv2, 0); rval_cache_clean(&c1); - ret=-1; - break; + rval_destroy(rv1); + rval_destroy(rv2); } - ret=rval_str_lop2(h, msg, res, rve->op, rv1, &c1, rv2, 0); - rval_cache_clean(&c1); - rval_destroy(rv1); - rval_destroy(rv2); } break; #if 0

15 years

git:master: pv: fix of tobody.params transformation

by Daniel-Constantin Mierla

Module: sip-router Branch: master Commit: fab99dce51ef9674c1bb4c50c0c1fefd47cc2d7e URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=fab99dc… Author: Daniel-Constantin Mierla <miconda(a)gmail.com> Committer: Daniel-Constantin Mierla <miconda(a)gmail.com> Date: Tue Apr 28 14:54:58 2009 +0200 pv: fix of tobody.params transformation - reported by Alex Hermann --- modules_k/pv/pv_trans.c | 7 ++++++- 1 files changed, 6 insertions(+), 1 deletions(-) diff --git a/modules_k/pv/pv_trans.c b/modules_k/pv/pv_trans.c index 4988687..3401edd 100644 --- a/modules_k/pv/pv_trans.c +++ b/modules_k/pv/pv_trans.c @@ -995,7 +995,12 @@ int tr_eval_tobody(struct sip_msg *msg, tr_param_t *tp, int subtype, if(_tr_tobody.param_lst!=NULL) { val->rs.s = _tr_tobody.param_lst->name.s; - val->rs.len = _tr_tobody.body.s+_tr_tobody.body.len-val->rs.s; + if(_tr_tobody.last_param->value.s!=NULL) + val->rs.len = _tr_tobody.last_param->value.s + +_tr_tobody.last_param->value.len - val->rs.s; + else + val->rs.len = _tr_tobody.last_param->name.s + +_tr_tobody.last_param->name.len - val->rs.s; } else val->rs = _tr_empty; break;

15 years

git:andrei/type_conversion: core expr eval: str automatic conversion to int

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/type_conversion Commit: 54b54c1fcf1f5f6967859890cf345a70cc0aab7f URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=54b54c1… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Tue Apr 28 12:00:04 2009 +0200 core expr eval: str automatic conversion to int (int)"" = 0 (int)"<number>" = <number> (e.g. (int)"123" = 123) (int)"<non-numeric>" = 0 (e.g. (int)"abc" = 0) --- rvalue.c | 44 +++++++++++++++++++++++++++++++++++++------- 1 files changed, 37 insertions(+), 7 deletions(-) diff --git a/rvalue.c b/rvalue.c index 259d921..e815c24 100644 --- a/rvalue.c +++ b/rvalue.c @@ -24,6 +24,9 @@ * -------- * 2008-12-01 initial version (andrei) * 2009-04-24 added support for defined, strempty, strlen (andrei) + * 2009-04-28 int and str automatic conversions: (int)undef=0, + * (str)undef="", (int)""=0, (int)"123"=123, (int)"abc"=0 + * (andrei) */ #include "rvalue.h" @@ -686,12 +689,19 @@ int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, avp_t* r_avp; int_str avp_val; pv_value_t pval; + str tmp; + str* s; + int r; + int destroy_pval; + destroy_pval=0; + s=0; switch(rv->type){ case RV_INT: *i=rv->v.l; break; case RV_STR: + s=&rv->v.s; goto rv_str; case RV_BEXPR: *i=eval_expr(h, rv->v.bexpr, msg); @@ -707,14 +717,23 @@ int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, *i=0; break; case RV_SEL: + r=run_select(&tmp, &rv->v.sel, msg); + if (unlikely(r!=0)){ + if (r<0) + goto eval_error; + else /* i>0 => undefined */ + goto undef; + } + s=&tmp; goto rv_str; case RV_AVP: if (unlikely(cache && cache->cache_type==RV_CACHE_AVP)){ if (likely(cache->val_type==RV_INT)){ *i=cache->c.avp_val.n; - }else if (cache->val_type==RV_STR) + }else if (cache->val_type==RV_STR){ + s=&cache->c.avp_val.s; goto rv_str; - else if (cache->val_type==RV_NONE) + }else if (cache->val_type==RV_NONE) goto undef; else goto error_cache; }else{ @@ -722,6 +741,7 @@ int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, &avp_val, rv->v.avps.index); if (likely(r_avp)){ if (unlikely(r_avp->flags & AVP_VAL_STR)){ + s=&avp_val.s; goto rv_str; }else{ *i=avp_val.n; @@ -736,9 +756,10 @@ int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, if (likely((cache->val_type==RV_INT) || (cache->c.pval.flags & PV_VAL_INT))){ *i=cache->c.pval.ri; - }else if (cache->val_type==RV_STR) + }else if (cache->val_type==RV_STR){ + s=&cache->c.pval.rs; goto rv_str; - else if (cache->val_type==RV_NONE) + }else if (cache->val_type==RV_NONE) goto undef; else goto error_cache; }else{ @@ -748,7 +769,8 @@ int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, *i=pval.ri; pv_value_destroy(&pval); }else if (likely(pval.flags & PV_VAL_STR)){ - pv_value_destroy(&pval); + destroy_pval=1; /* we must pv_value_destroy() later*/ + s=&pval.rs; goto rv_str; }else{ /* no PV_VAL_STR and no PV_VAL_INT => undef @@ -775,8 +797,16 @@ error_cache: BUG("invalid cached value:cache type %d, value type %d\n", cache?cache->cache_type:0, cache?cache->val_type:0); rv_str: - /* rv is of string type => error */ - /* ERR("string in int expression\n"); */ + /* rv is of string type => try to convert it to int */ + /* if "" => 0 (most likely case) */ + if (likely(s->len==0)) *i=0; + else if (unlikely(str2sint(s, i)!=0)){ + /* error converting to int => non numeric => 0 */ + *i=0; + } + if (destroy_pval) + pv_value_destroy(&pval); + return 0; error: *i=0; return -1;

15 years

git:andrei/type_conversion: core expr eval: undef conversion to int and str

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/type_conversion Commit: e9cb7f9402fc044eb877d2fea2dc59bac2c290a2 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=e9cb7f9… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Tue Apr 28 10:50:56 2009 +0200 core expr eval: undef conversion to int and str (int)(undef)=0 (str)(undef)="" --- rvalue.c | 77 +++++++++++++++++++++++++++++++++++++++++++++++-------------- 1 files changed, 59 insertions(+), 18 deletions(-) diff --git a/rvalue.c b/rvalue.c index aa99131..259d921 100644 --- a/rvalue.c +++ b/rvalue.c @@ -668,6 +668,15 @@ int rve_check_type(enum rval_type* type, struct rval_expr* rve, /** get the integer value of an rvalue. * *i=(int)rv + * if rv == undefined select, avp or pvar, return 0. + * if an error occurs while evaluating a select, avp or pvar, behave as + * for the undefined case (and return success). + * @param h - script context handle + * @param msg - sip msg + * @param i - pointer to int, where the conversion result will be stored + * @param rv - rvalue to be converted + * @param cache - cached rv value (read-only), can be 0 + * * @return 0 on success, \<0 on error and EXPR_DROP on drop */ int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, @@ -705,7 +714,9 @@ int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, *i=cache->c.avp_val.n; }else if (cache->val_type==RV_STR) goto rv_str; - else goto error; + else if (cache->val_type==RV_NONE) + goto undef; + else goto error_cache; }else{ r_avp = search_avp_by_index(rv->v.avps.type, rv->v.avps.name, &avp_val, rv->v.avps.index); @@ -716,7 +727,7 @@ int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, *i=avp_val.n; } }else{ - goto error; + goto undef; } } break; @@ -727,7 +738,9 @@ int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, *i=cache->c.pval.ri; }else if (cache->val_type==RV_STR) goto rv_str; - else goto error; + else if (cache->val_type==RV_NONE) + goto undef; + else goto error_cache; }else{ memset(&pval, 0, sizeof(pval)); if (likely(pv_get_spec_value(msg, &rv->v.pvs, &pval)==0)){ @@ -738,11 +751,13 @@ int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, pv_value_destroy(&pval); goto rv_str; }else{ + /* no PV_VAL_STR and no PV_VAL_INT => undef + (PV_VAL_NULL) */ pv_value_destroy(&pval); - goto error; + goto undef; } }else{ - goto error; + goto eval_error; } } break; @@ -751,10 +766,19 @@ int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, goto error; } return 0; +undef: +eval_error: /* same as undefined */ + /* handle undefined => result 0, return success */ + *i=0; + return 0; +error_cache: + BUG("invalid cached value:cache type %d, value type %d\n", + cache?cache->cache_type:0, cache?cache->val_type:0); rv_str: /* rv is of string type => error */ /* ERR("string in int expression\n"); */ error: + *i=0; return -1; } @@ -762,6 +786,9 @@ error: /** get the string value of an rv in a tmp variable * *s=(str)rv + * if rv == undefined select, avp or pvar, return "". + * if an error occurs while evaluating a select, avp or pvar, behave as + * for the undefined case (and return success). * The result points either to a temporary string or inside * new_cache. new_cache must be non zero, initialized previously, * and it _must_ be rval_cache_clean(...)'ed when done. @@ -771,9 +798,9 @@ error: * @param h - script context handle * @param msg - sip msg * @param tmpv - str return value (pointer to a str struct that will be - * be filled. + * be filled with the conversion result) * @param rv - rvalue to be converted - * @param cache - cached rv value (read-only) + * @param cache - cached rv value (read-only), can be 0 * @param tmp_cache - used for temporary storage (so that tmpv will not * point to possible freed data), it must be non-null, * initialized and cleaned afterwards. @@ -814,10 +841,9 @@ int rval_get_tmp_str(struct run_act_ctx* h, struct sip_msg* msg, i=run_select(tmpv, &rv->v.sel, msg); if (unlikely(i!=0)){ if (i<0){ - goto error; - }else { /* i>0 */ - tmpv->s=""; - tmpv->len=0; + goto eval_error; + }else { /* i>0 => undefined */ + goto undef; } } break; @@ -828,7 +854,9 @@ int rval_get_tmp_str(struct run_act_ctx* h, struct sip_msg* msg, }else if (cache->val_type==RV_INT){ i=cache->c.avp_val.n; tmpv->s=int2str(i, &tmpv->len); - }else goto error; + }else if (cache->val_type==RV_NONE){ + goto undef; + }else goto error_cache; }else{ r_avp = search_avp_by_index(rv->v.avps.type, rv->v.avps.name, &tmp_cache->c.avp_val, @@ -842,9 +870,7 @@ int rval_get_tmp_str(struct run_act_ctx* h, struct sip_msg* msg, i=tmp_cache->c.avp_val.n; tmpv->s=int2str(i, &tmpv->len); } - }else{ - goto error; - } + }else goto undef; } break; case RV_PVAR: @@ -854,7 +880,9 @@ int rval_get_tmp_str(struct run_act_ctx* h, struct sip_msg* msg, }else if (cache->val_type==RV_INT){ i=cache->c.pval.ri; tmpv->s=int2str(i, &tmpv->len); - }else goto error; + }else if (cache->val_type==RV_NONE){ + goto undef; + }else goto error_cache; }else{ memset(&tmp_cache->c.pval, 0, sizeof(tmp_cache->c.pval)); if (likely(pv_get_spec_value(msg, &rv->v.pvs, @@ -871,11 +899,13 @@ int rval_get_tmp_str(struct run_act_ctx* h, struct sip_msg* msg, pv_value_destroy(&tmp_cache->c.pval); tmpv->s=int2str(i, &tmpv->len); }else{ + /* no PV_VAL_STR and no PV_VAL_INT => undef + (PV_VAL_NULL) */ pv_value_destroy(&tmp_cache->c.pval); - goto error; + goto undef; } }else{ - goto error; + goto eval_error; } } break; @@ -884,7 +914,18 @@ int rval_get_tmp_str(struct run_act_ctx* h, struct sip_msg* msg, goto error; } return 0; +undef: +eval_error: /* same as undefined */ + /* handle undefined => result "", return success */ + tmpv->s=""; + tmpv->len=0; + return 0; +error_cache: + BUG("invalid cached value:cache type %d, value type %d\n", + cache?cache->cache_type:0, cache?cache->val_type:0); error: + tmpv->s=""; + tmpv->len=0; return -1; }

15 years

← Newer
1
2
3
4
5
6
7
...
23
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

sr-dev April 2009