sr-dev

sr-dev@lists.kamailio.org

12 participants
44183 discussions

git:andrei/type_conversion: news: update (new operators, expr. eval behaviour a.s.o.)

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/type_conversion Commit: bb4d414574c35b1ba2c0497e19313b4cd000f775 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=bb4d414… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Tue Apr 28 19:54:03 2009 +0200 news: update (new operators, expr. eval behaviour a.s.o.) --- NEWS | 27 +++++++++++++++++++++++++++ 1 files changed, 27 insertions(+), 0 deletions(-) diff --git a/NEWS b/NEWS index fade123..ed1ab96 100644 --- a/NEWS +++ b/NEWS @@ -6,6 +6,33 @@ $Id$ sip-router changes core: + - new operators eq, ne for string compares and ieq, ine for interger + compares. The names are not yet final (use them at your own risk). + Future version might use ==/!= only for ints (ieq/ine) and eq/ne for + strings (under debate). + They are almost equivalent to == or !=, but they force the conversion + of their operands (eq to string and ieq to int), allowing among other + things better type checking on startup and more optimizations. + Non equiv. examples: 0 == "" (true) is not equivalent to 0 eq "" + (false: it evaluates to "0" eq ""). "a" ieq "b" (true: (int)"a" is 0 + and (int)"b" is 0) is not equivalent to "a" == "b" (false). + Note: internally == and != are converted on startup to eq/ne/ieq/ine + whenever possible (both operand types can be safely determined at + start time and they are the same). + - try to guess what the user wanted when operators that support multiple + types are used on different typed operands. In general convert the + the right operand to the type of the left operand and then perform the + operation. Exception: the left operand is undef. + This applies to the following operators: +, == and !=. + Special case: undef as left operand: + For +: undef + expr -> undef is converted to string => "" + expr. + For == and !=: undef == expr -> undef is converted to type_of expr. + If expr is undef, then undef == undef is true (internally is converted + to string). + - expression evaluation changes: auto-convert to interger or string + in function of the operators: + int(undef)==0, int("")==0, int("123")==123, int("abc")==0 + str(undef)=="", str(123)=="123". - new script operators: defined, strlen, strempty defined expr - returns true if expr is defined, and false if not. Note: only a standalone avp or pvar can be

15 years, 8 months

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, 8 months

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, 8 months

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, 8 months

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, 8 months

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, 8 months

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, 8 months

git:andrei/type_conversion: core expr eval: defined @select

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/type_conversion Commit: 970e1f64e93410101a3dcf8914151388991ba800 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=970e1f6… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Tue Apr 28 09:50:07 2009 +0200 core expr eval: defined @select - a select can now be undefined (defined @select when run_select returns >0 or error => true) - RV_CACHE_SELECT introduced --- rvalue.c | 21 +++++++++++++++------ rvalue.h | 3 ++- 2 files changed, 17 insertions(+), 7 deletions(-) diff --git a/rvalue.c b/rvalue.c index 897fb4d..aa99131 100644 --- a/rvalue.c +++ b/rvalue.c @@ -1386,9 +1386,11 @@ error: /** checks if rv is defined. * @param res - set to the result 1 - defined, 0 not defined * @return 0 on success, -1 on error - * Can use cached rvalues (c1). - * Note: a rv can be undefined if it's an undefined avp or pvar or + * Can use cached rvalues (cache). + * Note: a rv can be undefined if it's an undefined avp or pvar or select or * if it's NONE + * Note2: an error in the avp, pvar or select search is equivalent to + * undefined (and it's not reported) */ inline static int rv_defined(struct run_act_ctx* h, struct sip_msg* msg, int* res, @@ -1397,13 +1399,21 @@ inline static int rv_defined(struct run_act_ctx* h, avp_t* r_avp; int_str avp_val; pv_value_t pval; + str tmp; *res=1; switch(rv->type){ + case RV_SEL: + if (unlikely(cache && cache->cache_type==RV_CACHE_SELECT)){ + *res=(cache->val_type!=RV_NONE); + }else + /* run select returns 0 on success, -1 on error and >0 on + undefined. error is considered undefined */ + *res=(run_select(&tmp, &rv->v.sel, msg)==0); + break; case RV_AVP: if (unlikely(cache && cache->cache_type==RV_CACHE_AVP)){ - if (cache->val_type==RV_NONE) - *res=0; + *res=(cache->val_type!=RV_NONE); }else{ r_avp = search_avp_by_index(rv->v.avps.type, rv->v.avps.name, &avp_val, rv->v.avps.index); @@ -1415,8 +1425,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)){ - if (cache->val_type==RV_NONE) - *res=0; + *res=(cache->val_type==RV_NONE); }else{ memset(&pval, 0, sizeof(pval)); if (likely(pv_get_spec_value(msg, &rv->v.pvs, &pval)==0)){ diff --git a/rvalue.h b/rvalue.h index a9dbe0d..e99d1f8 100644 --- a/rvalue.h +++ b/rvalue.h @@ -118,7 +118,8 @@ struct rval_expr{ enum rval_cache_type{ RV_CACHE_EMPTY, RV_CACHE_PVAR, - RV_CACHE_AVP + RV_CACHE_AVP, + RV_CACHE_SELECT }; /** value cache for a rvalue struct.

15 years, 8 months

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, 8 months

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, 8 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

sr-dev