sr-dev

sr-dev@lists.kamailio.org

16 participants
45406 discussions

git:andrei/script_vars: script parsing: helper function updated & moved
by Andrei Pelinescu-Onciul 19 Dec '08

19 Dec '08

Module: sip-router Branch: andrei/script_vars Commit: 33d560253c7fe8dd652251bc057873906edb2682 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=33d5602… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Fri Dec 19 14:20:41 2008 +0100 script parsing: helper function updated & moved - helper function for computing the file position of an expression --- cfg.y | 23 +---------------------- route_struct.c | 24 ++++++++++++++++++++++++ route_struct.h | 3 +++ 3 files changed, 28 insertions(+), 22 deletions(-) diff --git a/cfg.y b/cfg.y index 7ced7c1..63c9eb4 100644 --- a/cfg.y +++ b/cfg.y @@ -201,8 +201,6 @@ static struct rvalue* rval_tmp; static void warn(char* s); static void get_cpos(struct cfg_pos* pos); -static void get_rve2_pos(struct cfg_pos* res, - struct cfg_pos* pos1, struct cfg_pos* pos2); static struct rval_expr* mk_rve_rval(enum rval_type, void* v); static struct rval_expr* mk_rve1(enum rval_expr_op op, struct rval_expr* rve1); static struct rval_expr* mk_rve2(enum rval_expr_op op, struct rval_expr* rve1, @@ -2613,25 +2611,6 @@ static void yyerror(char* format, ...) -static void get_rve2_pos(struct cfg_pos* res, - struct cfg_pos* pos1, struct cfg_pos* pos2) -{ - *res=*pos1; - if ((res->s_line == 0) || (res->s_line > pos2->s_line)){ - res->s_line=pos2->s_line; - res->s_col=pos2->s_col; - }else if ((res->s_line == pos2->s_line) && (res->s_col > pos2->s_col)){ - res->s_col=pos2->s_col; - } - if ((res->e_line == 0) || (res->e_line < pos2->e_line)){ - res->e_line=pos2->e_line; - res->e_col=pos2->e_col; - }else if ((res->e_line == pos2->e_line) && (res->e_col < pos2->e_col)){ - res->e_col=pos2->e_col; - } -} - - /** mk_rval_expr_v wrapper. * checks mk_rval_expr_v return value and sets the cfg. pos * (line and column numbers) @@ -2688,7 +2667,7 @@ static struct rval_expr* mk_rve2(enum rval_expr_op op, struct rval_expr* rve1, if ((rve1==0) || (rve2==0)) return 0; - get_rve2_pos(&pos, &rve1->fpos, &rve2->fpos); + cfg_pos_join(&pos, &rve1->fpos, &rve2->fpos); ret=mk_rval_expr2(op, rve1, rve2, &pos); if (ret && (rve_check_type(&type, ret, &bad_rve, &bad_t, &exp_t)!=1)){ yyerror_at(&pos, "bad expression: type mismatch:" diff --git a/route_struct.c b/route_struct.c index 5cf74ee..7fce4b8 100644 --- a/route_struct.c +++ b/route_struct.c @@ -52,6 +52,30 @@ #include "ut.h" /* ZSW() */ + +/** joins to cfg file positions into a new one. */ +void cfg_pos_join(struct cfg_pos* res, + struct cfg_pos* pos1, struct cfg_pos* pos2) +{ + struct cfg_pos ret; + ret=*pos1; + if ((ret.s_line == 0) || (ret.s_line > pos2->s_line)){ + ret.s_line=pos2->s_line; + ret.s_col=pos2->s_col; + }else if ((ret.s_line == pos2->s_line) && (ret.s_col > pos2->s_col)){ + ret.s_col=pos2->s_col; + } + if ((ret.e_line == 0) || (ret.e_line < pos2->e_line)){ + ret.e_line=pos2->e_line; + ret.e_col=pos2->e_col; + }else if ((ret.e_line == pos2->e_line) && (ret.e_col < pos2->e_col)){ + ret.e_col=pos2->e_col; + } + *res=ret; +} + + + struct expr* mk_exp(int op, struct expr* left, struct expr* right) { struct expr * e; diff --git a/route_struct.h b/route_struct.h index ba5046e..76aac25 100644 --- a/route_struct.h +++ b/route_struct.h @@ -167,5 +167,8 @@ void print_action(struct action* a); void print_actions(struct action* a); void print_expr(struct expr* exp); +/** joins to cfg file positions into a new one. */ +void cfg_pos_join(struct cfg_pos* res, + struct cfg_pos* pos1, struct cfg_pos* pos2); #endif

1 0

git:andrei/script_vars: script engine: optimize $v - ct
by Andrei Pelinescu-Onciul 18 Dec '08

18 Dec '08

Module: sip-router Branch: andrei/script_vars Commit: 73f4a76ec264fdad4921c4ba26ecb1f6dadc81e9 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=73f4a76… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Dec 18 09:45:06 2008 +0100 script engine: optimize $v - ct - $v - ct transformed into $v + (-ct) which is easier to optimize further --- rvalue.c | 19 ++++++++++++++++++- 1 files changed, 18 insertions(+), 1 deletions(-) diff --git a/rvalue.c b/rvalue.c index 063be00..558ab70 100644 --- a/rvalue.c +++ b/rvalue.c @@ -1992,7 +1992,24 @@ static int rve_optimize(struct rval_expr* rve) rval_type_name(bad_type), rval_type_name(exp_type)); return 0; } - /* TODO: $v - a => $v + (-a) */ + /* $v - a => $v + (-a) (easier to optimize)*/ + if ((rve->op==RVE_MINUS_OP) && (rve_is_constant(rve->right.rve))){ + if ((rv=rval_expr_eval(0, 0, rve->right.rve))==0){ + ERR("optimization failure, bad expression\n"); + goto error; + } + if (rv->type==RV_INT){ + rv->v.l=-rv->v.l; + if (rve_replace_with_ct_rv(rve->right.rve, rv)<0) + goto error; + rve->op=RVE_PLUS_OP; + DBG("FIXUP RVE: optimized $v - a into $v + (%d)\n", + (int)rve->right.rve->left.rval.v.l); + } + rval_destroy(rv); + rv=0; + } + /* TODO: $v * 0 => 0; $v * 1 => $v (for *, /, &, |, &&, ||, +, -) */ /* op(op($v, a), b) => op($v, op(a,b)) */

1 0

git:andrei/script_vars: script engine: keep file pos. info when optimizing
by Andrei Pelinescu-Onciul 18 Dec '08

18 Dec '08

Module: sip-router Branch: andrei/script_vars Commit: 991da23d6c14caa4eff82a150bca7fc4c59330b7 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=991da23… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Dec 18 13:33:57 2008 +0100 script engine: keep file pos. info when optimizing - try to keep a reasonable value for an optimized rv. expression script file position - fix file position in debugging messages --- rvalue.c | 23 +++++++++++++++++++---- 1 files changed, 19 insertions(+), 4 deletions(-) diff --git a/rvalue.c b/rvalue.c index ce9e3d3..2a1ea88 100644 --- a/rvalue.c +++ b/rvalue.c @@ -2007,6 +2007,7 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) int i; int ret; enum rval_expr_op op; + struct cfg_pos pos; int right; /* debugging msg */ rv=0; @@ -2046,7 +2047,9 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) /* $v * 1 -> $v * 1 * $v -> $v */ rve_destroy(ct_rve); + pos=rve->fpos; *rve=*v_rve; /* replace current expr. with $v */ + rve->fpos=pos; pkg_free(v_rve);/* rve_destroy(v_rve) would free everything*/ ret=1; @@ -2068,7 +2071,9 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) if (ct_rve==rve->right.rve){ /* $v / 1 -> $v */ rve_destroy(ct_rve); + pos=rve->fpos; *rve=*v_rve; /* replace current expr. with $v */ + rve->fpos=pos; pkg_free(v_rve);/* rve_destroy(v_rve) would free everything*/ ret=1; @@ -2080,7 +2085,9 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) if (ct_rve==rve->right.rve){ /* $v - 0 -> $v */ rve_destroy(ct_rve); + pos=rve->fpos; *rve=*v_rve; /* replace current expr. with $v */ + rve->fpos=pos; pkg_free(v_rve);/* rve_destroy(v_rve) would free everything*/ ret=1; @@ -2104,7 +2111,9 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) /* $v | 0 -> $v * 0 | $v -> $v */ rve_destroy(ct_rve); + pos=rve->fpos; *rve=*v_rve; /* replace current expr. with $v */ + rve->fpos=pos; pkg_free(v_rve);/* rve_destroy(v_rve) would free everything*/ ret=1; @@ -2121,7 +2130,9 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) /* $v && 1 -> $v * 1 && $v -> $v */ rve_destroy(ct_rve); + pos=rve->fpos; *rve=*v_rve; /* replace current expr. with $v */ + rve->fpos=pos; pkg_free(v_rve);/* rve_destroy(v_rve) would free everything*/ ret=1; @@ -2138,7 +2149,9 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) /* $v || 0 -> $v * 0 && $v -> $v */ rve_destroy(ct_rve); + pos=rve->fpos; *rve=*v_rve; /* replace current expr. with $v */ + rve->fpos=pos; pkg_free(v_rve);/* rve_destroy(v_rve) would free everything*/ ret=1; @@ -2151,7 +2164,9 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) /* $v + 0 -> $v * 0 + $v -> $v */ rve_destroy(ct_rve); + pos=rve->fpos; *rve=*v_rve; /* replace current expr. with $v */ + rve->fpos=pos; pkg_free(v_rve);/* rve_destroy(v_rve) would free everything*/ ret=1; @@ -2168,26 +2183,26 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) DBG("FIXUP RVE: (%d,%d-%d,%d) optimized" " op%d($v, %d) -> %d\n", rve->fpos.s_line, rve->fpos.s_col, - rve->fpos.e_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.e_col, op, i, (int)rve->left.rval.v.l); else DBG("FIXUP RVE: (%d,%d-%d,%d) optimized" " op%d($v, %d) -> $v\n", rve->fpos.s_line, rve->fpos.s_col, - rve->fpos.e_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.e_col, op, i); }else{ if ((rve->op==RVE_RVAL_OP) && (rve->left.rval.type==RV_INT)) DBG("FIXUP RVE: (%d,%d-%d,%d) optimized" " op%d(%d, $v) -> %d\n", rve->fpos.s_line, rve->fpos.s_col, - rve->fpos.e_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.e_col, op, i, (int)rve->left.rval.v.l); else DBG("FIXUP RVE: (%d,%d-%d,%d) optimized" " op%d(%d, $v) -> $v\n", rve->fpos.s_line, rve->fpos.s_col, - rve->fpos.e_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.e_col, op, i); } }

1 0

git:andrei/script_vars: script engine: optimize op($v, ct) where ct=0 or 1
by Andrei Pelinescu-Onciul 18 Dec '08

18 Dec '08

Module: sip-router Branch: andrei/script_vars Commit: 5184c21a634b700a3800665269ca659c53e86fe9 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=5184c21… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Dec 18 12:51:50 2008 +0100 script engine: optimize op($v, ct) where ct=0 or 1 - optimize: $v*0->0, 0*$v->0, $v*1->$v 1*$v->$v $v/1->$v, 0/$v->0 $v-0->$v $v&0->0, 0&$v->0 $v|0->$v, 0|$v->$v $v&&0->0, 0&&$v->0, $v&&1->$v, 1&&$v->$v $v||1->1, 1||$v->1, $v||0->$v, 0||$v->$v $v+0->$v, 0+$v->$v if typeof(expression) is int (forced by the context) - fix runtime && and ||: 0 && expr -> don't evaluate expr, return 0 1 || expr -> don't evaluate expr, return 1 --- rvalue.c | 284 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 files changed, 280 insertions(+), 4 deletions(-) diff --git a/rvalue.c b/rvalue.c index 558ab70..ce9e3d3 100644 --- a/rvalue.c +++ b/rvalue.c @@ -1288,8 +1288,6 @@ int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg, case RVE_PLUS_OP: case RVE_BOR_OP: case RVE_BAND_OP: - case RVE_LAND_OP: - case RVE_LOR_OP: case RVE_GT_OP: case RVE_GTE_OP: case RVE_LT_OP: @@ -1302,6 +1300,34 @@ int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg, break; ret=int_intop2(res, rve->op, i1, i2); break; + case RVE_LAND_OP: + if (unlikely( + (ret=rval_expr_eval_int(h, msg, &i1, rve->left.rve)) <0) ) + break; + if (i1==0){ + *res=0; + }else{ + if (unlikely( (ret=rval_expr_eval_int(h, msg, &i2, + rve->right.rve)) <0) ) + break; + *res=i1 && i2; + } + ret=0; + break; + case RVE_LOR_OP: + if (unlikely( + (ret=rval_expr_eval_int(h, msg, &i1, rve->left.rve)) <0) ) + break; + if (i1){ + *res=1; + }else{ + if (unlikely( (ret=rval_expr_eval_int(h, msg, &i2, + rve->right.rve)) <0) ) + break; + *res=i1 || i2; + } + ret=0; + break; case RVE_EQ_OP: case RVE_DIFF_OP: /* if left is string, eval left & right as string and @@ -1593,6 +1619,32 @@ error: +/** evals a rval expr and always returns a new rval. + * like rval_expr_eval, but always returns a new rvalue (never a reference + * to an exisiting one). + * WARNING: result must be rval_destroy()'ed if non-null (it might be + * a reference to another rval). The result can be modified only + * if rv_chg_in_place() returns true. + * @result rvalue on success, 0 on error + */ +struct rvalue* rval_expr_eval_new(struct run_act_ctx* h, struct sip_msg* msg, + struct rval_expr* rve) +{ + struct rvalue* ret; + struct rvalue* rv; + + ret=rval_expr_eval(h, msg, rve); + if (ret && !rv_chg_in_place(ret)){ + rv=ret; + /* create a new rv */ + ret=rval_new(rv->type, &rv->v, 0); + rval_destroy(rv); + } + return ret; +} + + + /** create a RVE_RVAL_OP rval_expr, containing a single rval of the given type. * * @param rv_type - rval type @@ -1941,6 +1993,221 @@ static int rve_replace_with_ct_rv(struct rval_expr* rve, struct rvalue* rv) +/** optimize op($v, 0) or op($v, 1). + * Note: internal use only from rve_optimize + * It should be called after ct optimization, for non-contant + * expressions (the left or right side is not constant). + * @return 1 on success (rve was changed), 0 on failure and -1 on error + */ +static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) +{ + struct rvalue* rv; + struct rval_expr* ct_rve; + struct rval_expr* v_rve; + int i; + int ret; + enum rval_expr_op op; + int right; /* debugging msg */ + + rv=0; + ret=0; + right=0; + + if (rve_is_constant(rve->right.rve)){ + ct_rve=rve->right.rve; + v_rve=rve->left.rve; + right=1; + }else if (rve_is_constant(rve->left.rve)){ + ct_rve=rve->left.rve; + v_rve=rve->right.rve; + right=0; + }else + return 0; /* op($v, $w) */ + + /* rval_expr_eval_new() instead of rval_expr_eval() to avoid + referencing a ct_rve->left.rval if ct_rve is a rval, which + would prevent rve_destroy(ct_rve) from working */ + if ((rv=rval_expr_eval_new(0, 0, ct_rve))==0){ + ERR("optimization failure, bad expression\n"); + goto error; + } + op=rve->op; + if (rv->type==RV_INT){ + i=rv->v.l; + switch(op){ + case RVE_MUL_OP: + if (i==0){ + /* $v * 0 -> 0 + * 0 * $v -> 0 */ + if (rve_replace_with_ct_rv(rve, rv)<0) + goto error; + ret=1; + }else if (i==1){ + /* $v * 1 -> $v + * 1 * $v -> $v */ + rve_destroy(ct_rve); + *rve=*v_rve; /* replace current expr. with $v */ + pkg_free(v_rve);/* rve_destroy(v_rve) would free + everything*/ + ret=1; + } + break; + case RVE_DIV_OP: + if (i==0){ + if (ct_rve==rve->left.rve){ + /* 0 / $v -> 0 */ + if (rve_replace_with_ct_rv(rve, rv)<0) + goto error; + ret=1; + }else{ + /* $v / 0 */ + ERR("RVE divide by 0 at %d,%d\n", + ct_rve->fpos.s_line, ct_rve->fpos.s_col); + } + }else if (i==1){ + if (ct_rve==rve->right.rve){ + /* $v / 1 -> $v */ + rve_destroy(ct_rve); + *rve=*v_rve; /* replace current expr. with $v */ + pkg_free(v_rve);/* rve_destroy(v_rve) would free + everything*/ + ret=1; + } + } + break; + case RVE_MINUS_OP: + if (i==0){ + if (ct_rve==rve->right.rve){ + /* $v - 0 -> $v */ + rve_destroy(ct_rve); + *rve=*v_rve; /* replace current expr. with $v */ + pkg_free(v_rve);/* rve_destroy(v_rve) would free + everything*/ + ret=1; + } + /* ? 0 - $v -> -($v) ? */ + } + break; + case RVE_BAND_OP: + if (i==0){ + /* $v & 0 -> 0 + * 0 & $v -> 0 */ + if (rve_replace_with_ct_rv(rve, rv)<0) + goto error; + ret=1; + } + /* no 0xffffff optimization for now (haven't decide on + the number of bits ) */ + break; + case RVE_BOR_OP: + if (i==0){ + /* $v | 0 -> $v + * 0 | $v -> $v */ + rve_destroy(ct_rve); + *rve=*v_rve; /* replace current expr. with $v */ + pkg_free(v_rve);/* rve_destroy(v_rve) would free + everything*/ + ret=1; + } + break; + case RVE_LAND_OP: + if (i==0){ + /* $v && 0 -> 0 + * 0 && $v -> 0 */ + if (rve_replace_with_ct_rv(rve, rv)<0) + goto error; + ret=1; + }else if (i==1){ + /* $v && 1 -> $v + * 1 && $v -> $v */ + rve_destroy(ct_rve); + *rve=*v_rve; /* replace current expr. with $v */ + pkg_free(v_rve);/* rve_destroy(v_rve) would free + everything*/ + ret=1; + } + break; + case RVE_LOR_OP: + if (i==1){ + /* $v || 1 -> 1 + * 1 || $v -> 1 */ + if (rve_replace_with_ct_rv(rve, rv)<0) + goto error; + ret=1; + }else if (i==0){ + /* $v || 0 -> $v + * 0 && $v -> $v */ + rve_destroy(ct_rve); + *rve=*v_rve; /* replace current expr. with $v */ + pkg_free(v_rve);/* rve_destroy(v_rve) would free + everything*/ + ret=1; + } + break; + case RVE_PLUS_OP: + /* we must make sure that this is an int PLUS + (because "foo"+0 is valid => "foo0") */ + if ((i==0) && (rve_type==RV_INT)){ + /* $v + 0 -> $v + * 0 + $v -> $v */ + rve_destroy(ct_rve); + *rve=*v_rve; /* replace current expr. with $v */ + pkg_free(v_rve);/* rve_destroy(v_rve) would free + everything*/ + ret=1; + } + break; + default: + /* do nothing */ + break; + } + /* debugging messages */ + if (ret==1){ + if (right){ + if ((rve->op==RVE_RVAL_OP) && (rve->left.rval.type==RV_INT)) + DBG("FIXUP RVE: (%d,%d-%d,%d) optimized" + " op%d($v, %d) -> %d\n", + rve->fpos.s_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.s_col, + op, i, (int)rve->left.rval.v.l); + else + DBG("FIXUP RVE: (%d,%d-%d,%d) optimized" + " op%d($v, %d) -> $v\n", + rve->fpos.s_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.s_col, + op, i); + }else{ + if ((rve->op==RVE_RVAL_OP) && (rve->left.rval.type==RV_INT)) + DBG("FIXUP RVE: (%d,%d-%d,%d) optimized" + " op%d(%d, $v) -> %d\n", + rve->fpos.s_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.s_col, + op, i, (int)rve->left.rval.v.l); + else + DBG("FIXUP RVE: (%d,%d-%d,%d) optimized" + " op%d(%d, $v) -> $v\n", + rve->fpos.s_line, rve->fpos.s_col, + rve->fpos.e_line, rve->fpos.s_col, + op, i); + } + } + } + /* no optimization for strings for now + (We could optimize $v + "" or ""+$v, but this ""+$v is a way + to force convert $v to str , it might mess up type checking + (e.g. errors w/o optimization and no errors with) and it brings + a very small benefit anyway (it's unlikely we'll see a lot of + "") + */ + if (rv) rval_destroy(rv); + return ret; +error: + if (rv) rval_destroy(rv); + return -1; +} + + + /** tries to optimize a rval_expr. */ static int rve_optimize(struct rval_expr* rve) { @@ -1987,8 +2254,9 @@ static int rve_optimize(struct rval_expr* rve) rve_optimize(rve->left.rve); rve_optimize(rve->right.rve); if (!rve_check_type(&type, rve, &bad_rve, &bad_type, &exp_type)){ - ERR("optimization failure, type mismatch in expression, " + ERR("optimization failure, type mismatch in expression (%d,%d), " "type %s, but expected %s\n", + bad_rve->fpos.s_line, bad_rve->fpos.s_col, rval_type_name(bad_type), rval_type_name(exp_type)); return 0; } @@ -2010,7 +2278,14 @@ static int rve_optimize(struct rval_expr* rve) rv=0; } - /* TODO: $v * 0 => 0; $v * 1 => $v (for *, /, &, |, &&, ||, +, -) */ + /* $v * 0 => 0; $v * 1 => $v (for *, /, &, |, &&, ||, +, -) */ + if (rve_opt_01(rve, type)==1){ + /* success, rve was changed => return now + (since this is recursively invoked the "new" rve + is already optimized) */ + ret=1; + goto end; + } /* op(op($v, a), b) => op($v, op(a,b)) */ if (rve_is_constant(rve->right.rve)){ @@ -2170,6 +2445,7 @@ static int rve_optimize(struct rval_expr* rve) } /* op(op($v,a), op($w,b)) => no optimizations for now (TODO) */ } +end: return ret; error: if (rv) rval_destroy(rv);

1 0

git:andrei/script_vars: script engine: different operators for int and str +
by Andrei Pelinescu-Onciul 18 Dec '08

18 Dec '08

Module: sip-router Branch: andrei/script_vars Commit: 1b9b3fd68c37ac7e3b4afb753c8424ae3f6c6e0f URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=1b9b3fd… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Dec 18 14:46:05 2008 +0100 script engine: different operators for int and str + - different operators for integer + (RVE_IPLUS_OP) and str plus (RVE_CONCAT_OP). The generic plus (RVE_PLUS_OP) is still present, the new operators are only used in internal optimizations (see below) for now. - if an expression involving the generic '+' is always of type int or str, replace the generic '+' with the interger or string version (makes further optimizations possible). --- rvalue.c | 112 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--- rvalue.h | 4 ++- 2 files changed, 110 insertions(+), 6 deletions(-) diff --git a/rvalue.c b/rvalue.c index 2a1ea88..6471e85 100644 --- a/rvalue.c +++ b/rvalue.c @@ -385,10 +385,13 @@ enum rval_type rve_guess_type( struct rval_expr* rve) case RVE_LTE_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_IPLUS_OP: return RV_INT; case RVE_PLUS_OP: /* '+' evaluates to the type of the left operand */ return rve_guess_type(rve->left.rve); + case RVE_CONCAT_OP: + return RV_STR; case RVE_NONE_OP: break; } @@ -437,6 +440,8 @@ int rve_is_constant(struct rval_expr* rve) case RVE_EQ_OP: case RVE_DIFF_OP: case RVE_PLUS_OP: + case RVE_IPLUS_OP: + case RVE_CONCAT_OP: return rve_is_constant(rve->left.rve) && rve_is_constant(rve->right.rve); case RVE_NONE_OP: @@ -473,6 +478,8 @@ static int rve_op_unary(enum rval_expr_op op) case RVE_EQ_OP: case RVE_DIFF_OP: case RVE_PLUS_OP: + case RVE_IPLUS_OP: + case RVE_CONCAT_OP: return 0; case RVE_NONE_OP: return -1; @@ -532,6 +539,7 @@ 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_IPLUS_OP: *type=RV_INT; if (rve_check_type(&type1, rve->left.rve, bad_rve, bad_t, exp_t)){ if (type1==RV_STR){ @@ -587,6 +595,28 @@ int rve_check_type(enum rval_type* type, struct rval_expr* rve, return 1; } } + case RVE_CONCAT_OP: + *type=RV_STR; + 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; + } + } case RVE_NONE_OP: break; } @@ -936,6 +966,7 @@ inline static int int_intop2(int* res, enum rval_expr_op op, int v1, int v2) { switch(op){ case RVE_PLUS_OP: + case RVE_IPLUS_OP: *res=v1+v2; break; case RVE_MINUS_OP: @@ -981,6 +1012,10 @@ inline static int int_intop2(int* res, enum rval_expr_op op, int v1, int v2) case RVE_DIFF_OP: *res=v1 != v2; break; + case RVE_CONCAT_OP: + *res=0; + /* invalid operand for int */ + return -1; default: BUG("rv unsupported intop %d\n", op); return -1; @@ -1286,6 +1321,7 @@ int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg, case RVE_DIV_OP: case RVE_MINUS_OP: case RVE_PLUS_OP: + case RVE_IPLUS_OP: case RVE_BOR_OP: case RVE_BAND_OP: case RVE_GT_OP: @@ -1376,6 +1412,10 @@ int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg, rval_destroy(rv2); break; #endif + case RVE_CONCAT_OP: + *res=0; + ret=-1; + break; case RVE_NONE_OP: /*default:*/ BUG("invalid rval int expression operation %d\n", rve->op); @@ -1446,6 +1486,7 @@ int rval_expr_eval_rvint( struct run_act_ctx* h, case RVE_LTE_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_IPLUS_OP: /* operator forces integer type */ ret=rval_expr_eval_int(h, msg, res_i, rve); *res_rv=0; @@ -1479,6 +1520,10 @@ int rval_expr_eval_rvint( struct run_act_ctx* h, } rval_cache_clean(&c1); break; + case RVE_CONCAT_OP: + *res_rv=rval_expr_eval(h, msg, rve); + ret=-(*res_rv==0); + break; case RVE_NONE_OP: /*default:*/ BUG("invalid rval expression operation %d\n", rve->op); @@ -1535,6 +1580,7 @@ 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_IPLUS_OP: /* operator forces integer type */ r=rval_expr_eval_int(h, msg, &i, rve); if (likely(r==0)){ @@ -1603,6 +1649,19 @@ struct rvalue* rval_expr_eval(struct run_act_ctx* h, struct sip_msg* msg, } rval_cache_clean(&c1); break; + case RVE_CONCAT_OP: + rv1=rval_expr_eval(h, msg, rve->left.rve); + if (unlikely(rv1==0)){ + ERR("rval expression evaluation failed\n"); + goto error; + } + rv2=rval_expr_eval(h, msg, rve->right.rve); + if (unlikely(rv2==0)){ + ERR("rval expression evaluation failed\n"); + goto error; + } + ret=rval_str_add2(h, msg, rv1, 0, rv2, 0); + break; case RVE_NONE_OP: /*default:*/ BUG("invalid rval expression operation %d\n", rve->op); @@ -1767,8 +1826,10 @@ struct rval_expr* mk_rval_expr2(enum rval_expr_op op, struct rval_expr* rve1, case RVE_LT_OP: case RVE_LTE_OP: case RVE_PLUS_OP: + case RVE_IPLUS_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_CONCAT_OP: break; default: BUG("unsupported operator %d\n", op); @@ -1802,6 +1863,8 @@ static int rve_op_is_assoc(enum rval_expr_op op) case RVE_MINUS_OP: return 0; case RVE_PLUS_OP: + case RVE_IPLUS_OP: + case RVE_CONCAT_OP: case RVE_MUL_OP: case RVE_BAND_OP: case RVE_BOR_OP: @@ -1838,6 +1901,7 @@ static int rve_op_is_commutative(enum rval_expr_op op, enum rval_type type) return 0; case RVE_PLUS_OP: return type==RV_INT; /* commutative only for INT*/ + case RVE_IPLUS_OP: case RVE_MUL_OP: case RVE_BAND_OP: case RVE_BOR_OP: @@ -1851,6 +1915,7 @@ static int rve_op_is_commutative(enum rval_expr_op op, enum rval_type type) case RVE_LTE_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_CONCAT_OP: return 0; } return 0; @@ -2158,9 +2223,10 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) } break; 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) && (rve_type==RV_INT)){ + if ((i==0) && ((op==RVE_IPLUS_OP)||(rve_type==RV_INT))){ /* $v + 0 -> $v * 0 + $v -> $v */ rve_destroy(ct_rve); @@ -2206,14 +2272,32 @@ static int rve_opt_01(struct rval_expr* rve, enum rval_type rve_type) op, i); } } - } - /* no optimization for strings for now + }else if (rv->type==RV_STR){ + switch(op){ + case RVE_CONCAT_OP: + if (rv->v.s.len==0){ + /* $v . "" -> $v + "" . $v -> $v */ + rve_destroy(ct_rve); + pos=rve->fpos; + *rve=*v_rve; /* replace current expr. with $v */ + rve->fpos=pos; + pkg_free(v_rve);/* rve_destroy(v_rve) would free + everything*/ + ret=1; + } + break; + default: + break; + } + /* no optimization for generic RVE_PLUS_OP for now, only for RVE_CONCAT_OP (We could optimize $v + "" or ""+$v, but this ""+$v is a way to force convert $v to str , it might mess up type checking (e.g. errors w/o optimization and no errors with) and it brings a very small benefit anyway (it's unlikely we'll see a lot of "") */ + } if (rv) rval_destroy(rv); return ret; error: @@ -2232,7 +2316,7 @@ static int rve_optimize(struct rval_expr* rve) enum rval_expr_op op; int flags; struct rval_expr tmp_rve; - enum rval_type type; + enum rval_type type, l_type; struct rval_expr* bad_rve; enum rval_type bad_type, exp_type; @@ -2285,7 +2369,7 @@ static int rve_optimize(struct rval_expr* rve) rv->v.l=-rv->v.l; if (rve_replace_with_ct_rv(rve->right.rve, rv)<0) goto error; - rve->op=RVE_PLUS_OP; + rve->op=RVE_IPLUS_OP; DBG("FIXUP RVE: optimized $v - a into $v + (%d)\n", (int)rve->right.rve->left.rval.v.l); } @@ -2293,6 +2377,22 @@ static int rve_optimize(struct rval_expr* rve) rv=0; } + /* e1 PLUS_OP e2 -> change op if we know e1 basic type */ + if (rve->op==RVE_PLUS_OP){ + l_type=rve_guess_type(rve->left.rve); + if (l_type==RV_INT){ + rve->op=RVE_IPLUS_OP; + DBG("FIXUP RVE (%d,%d-%d,%d): changed + into interger plus\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; + DBG("FIXUP RVE (%d,%d-%d,%d): changed + into string concat\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){ /* success, rve was changed => return now @@ -2510,8 +2610,10 @@ int fix_rval_expr(void** p) case RVE_LT_OP: case RVE_LTE_OP: case RVE_PLUS_OP: + case RVE_IPLUS_OP: case RVE_EQ_OP: case RVE_DIFF_OP: + case RVE_CONCAT_OP: ret=fix_rval_expr((void**)&rve->left.rve); if (ret<0) return ret; ret=fix_rval_expr((void**)&rve->right.rve); diff --git a/rvalue.h b/rvalue.h index f36f189..a694c0d 100644 --- a/rvalue.h +++ b/rvalue.h @@ -59,10 +59,12 @@ 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_IPLUS_OP, /* 2 members, integer +, returns int(a)+int(b) */ /* common int & str */ - RVE_PLUS_OP, /* 2 members, returns left + right (int or str)*/ + RVE_PLUS_OP, /* generic plus (int or str) returns left + right */ RVE_EQ_OP, /* 2 members, returns left == right (int)*/ RVE_DIFF_OP, /* 2 members, returns left != right (int)*/ + RVE_CONCAT_OP,/* string concatenation, returns left . right */ /* str only */ };

1 0

library naming
by Daniel-Constantin Mierla 16 Dec '08

16 Dec '08

Hello, I couldn't get the message with a final decision regarding the library naming scheme. Andrei used libsr_xyz at some point, I also like this one. Henning committed directly lib/trie in his branch. I will look soon to make the library out of mi, thinking of: libsr_kmi or libsr_mi, depending or not whether we want to mark the origin. So, two things to decide: - do we stick to libsr_ as prefix to all new libraries included in srouter? - do we want to mark the origin of the library? Short term, might be good as pattern to know what is required for k version of the module. This can be fixed with good documentation. Long term the name might look strange. Cheers, Daniel -- Daniel-Constantin Mierla http://www.asipto.com

2 4

AVPs
by Daniel-Constantin Mierla 16 Dec '08

16 Dec '08

Hello, I think we need to decide about AVPs. Although not deeply investigated, ser seems to have couple of AVPs lists. In kamailio/openser it is one list. Can a ser developer describe a bit the AVP implementation as it is now there? In openser/kamailio we have more or less same architecture as for ser 0.9.6 with couple extensions, but I will detail here so we can have full picture: - avps are kept in shared memory - they are bound to each sip message and moved to transaction if that message create a transaction - avp can have two types of names - integer id, referred as $avp(i:number) - string id, referred as $avp(s:string) - there can be aliases for avp names, defined as "alias=[is]:id", so the script writer can use $avp(alias) - a value of an avp can be either integer or string - not related to avp core part, but important to mention here -- tm, controlled by a parameter, can make the avps from transaction (request) available to onreply_route. Also, just to have in mind, for the future we got into discussion: - moving from linked list to a structure that allows faster search (e.g., hash table) as number of used avps can be big some times - adding support for structure-like values (the value to be another list of (name,value) pairs). A typical use case is serial forking, where one needs to store data in avps. If for one destination an avp is missing, things get screwed. Example: $avp(uri) = {A, B, C} $avp(RPID) = {X, not needed, Y} Internally will look like: $avp(uri) = {A, B, C} $avp(RPID) = {X, Y} So actually, Y will be used for destination B. Workarounds are possible, or course, but maybe we can do it nicer. so it will be like: $avp(dst) = {{u=A,r=Y}, {u=B},{u=C,r=Y}} A possibility to specify the access is $avp(d:dst=>u) Finally, as pointed in another email, it is about making possible to hold "value null" (a mark/flag) and differentiate that from "undefined" (not existing). Cheers, Daniel -- Daniel-Constantin Mierla http://www.asipto.com

4 12

git:ser_core_cvs: dns: fix build warnings when compiling without ipv6
by Andrei Pelinescu-Onciul 16 Dec '08

16 Dec '08

Module: sip-router Branch: ser_core_cvs Commit: 476e1991ab3daaf66d2053cebcb8f00967fe5633 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=476e199… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Tue Dec 16 14:35:55 2008 +0000 dns: fix build warnings when compiling without ipv6 Author: Vance Shipley <vances(a)motivity.ca> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> --- resolve.h | 2 ++ 1 files changed, 2 insertions(+), 0 deletions(-) diff --git a/resolve.h b/resolve.h index 76f3903..4b702ec 100644 --- a/resolve.h +++ b/resolve.h @@ -337,9 +337,11 @@ static inline struct hostent* _resolvehost(char* name) { static struct hostent* he=0; #ifdef HAVE_GETIPNODEBYNAME +#ifdef USE_IPV6 int err; static struct hostent* he2=0; #endif +#endif #ifndef DNS_IP_HACK #ifdef USE_IPV6 int len;

1 0

git:ser_core_cvs: core: fix build on Darwin
by Andrei Pelinescu-Onciul 16 Dec '08

16 Dec '08

Module: sip-router Branch: ser_core_cvs Commit: 8a2ca52622339af82946df172a3300d0b38297d7 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=8a2ca52… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Tue Dec 16 14:34:04 2008 +0000 core: fix build on Darwin Author: Alfred Heggestad <aeh(a)db.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> --- ip_addr.c | 2 +- ip_addr.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ip_addr.c b/ip_addr.c index e17a69d..3efdeb9 100644 --- a/ip_addr.c +++ b/ip_addr.c @@ -190,7 +190,7 @@ int is_mcast(struct ip_addr* ip) return IN_MULTICAST(htonl(ip->u.addr32[0])); #ifdef USE_IPV6 } else if (ip->af==AF_INET6){ - return IN6_IS_ADDR_MULTICAST(&ip->u.addr32[0]); + return IN6_IS_ADDR_MULTICAST((struct in6_addr*)ip->u.addr32); #endif /* USE_IPV6 */ } else { LOG(L_ERR, "ERROR: is_mcast: Unsupported protocol family\n"); diff --git a/ip_addr.h b/ip_addr.h index 6849a87..fdaf6f3 100644 --- a/ip_addr.h +++ b/ip_addr.h @@ -242,7 +242,7 @@ inline static int ip_addr_loopback(struct ip_addr* ip) return ip->u.addr32[0]==htonl(INADDR_LOOPBACK); #ifdef USE_IPV6 else if (ip->af==AF_INET6) - return IN6_IS_ADDR_LOOPBACK(&ip->u.addr32[0]); + return IN6_IS_ADDR_LOOPBACK((struct in6_addr*)ip->u.addr32); #endif /* USE_IPV6 */ return 0; }

1 0

git:ser_core_cvs: doc: tcp tunning update
by Andrei Pelinescu-Onciul 16 Dec '08

16 Dec '08

Module: sip-router Branch: ser_core_cvs Commit: 67e3e42ea4ad48ec225233a32e0c8c36fdba7bc4 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=67e3e42… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Tue Dec 16 14:30:48 2008 +0000 doc: tcp tunning update - update with epoll tunning for kernels >= 2.6.27.8 Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> --- doc/tcp_tunning.txt | 4 ++++ 1 files changed, 4 insertions(+), 0 deletions(-) diff --git a/doc/tcp_tunning.txt b/doc/tcp_tunning.txt index 975e793..b383a42 100644 --- a/doc/tcp_tunning.txt +++ b/doc/tcp_tunning.txt @@ -55,6 +55,10 @@ fs.file-max - maximum number of fds that will be allocated 1.5 other sysctl that might affect tcp connection rate or the maximum number of open connections +fs.epoll.max_user_instances - maximum number of devices - per user (2.6.27.8+) +fs.epoll.max_user_watches - maximum number of "watched" fds - per user + (2.6.27.8+) + iptables - remove the ip_conntrack module (it limits the maximum tcp connections, adds extra overhead (slow)). It's probably better to remove all the iptables modules.

1 0

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

sr-dev