sr-dev

sr-dev@lists.kamailio.org

13 participants
43416 discussions

by Andrei Pelinescu-Onciul

It would be better to have different operators for strings and for integers. Right now we have '+', '==' and '!=' that can be used both for strings and integers. The problem with this approach is that it makes some optimizations impossible, especially when combined with dynamic typed variables (avps or pvars). '+' is especially bad because one can tell what type ($v + x) has only at runtime. I think having perl like operators would help a lot: - '.' for string concatenation (instead of reusing '+'), e.g.: $v= "foo" . "bar" - 'eq' instead of == for strings, e.g.: $v eq "bar" - 'ne' instead of != for strings, e.g.: $v ne "bar" We could support them right now in parallel with the old ones and obsolete +, == and != for strings in the future (but that means we still cannot optimize '+' in all the cases) or switch right now (maybe with some old compat switch which will support old scripts style). The question is how much are they used right now. While I think '==' and '!=' are used quite often, I'm not sure about '+' for strings (and '+' is the most important anyway). Note: we can still support '==' and '!=' for condition tests not involving variables (e.g. method=="INVITE", uri=="sip:foo" a.s.o.). Another advantage that this change would bring is better type checking at startup (more errors flagged without having to run the script) and possible implicit conversions (e.g. int to string or string to int) if we decide to support them. Any comments? In the future it would also be much better to have typed script vars (e.g. int $var1). This would help a lot in checking the script for correctness. With the dynamic typed vars, one has to run the script to find errors. It would also help in optimizing, but not so much if we separate the operators, like above. Andrei

15 years, 9 months

git:andrei/script_vars: script parsing: expression type checking on startup

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/script_vars Commit: 8a0c71c947d6662e034567c49a71fb5fabefbfa1 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=8a0c71c… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Mon Dec 15 21:24:47 2008 +0100 script parsing: expression type checking on startup - check expressions type and report errors at script parsing time - yyerror() uses now a printf style format --- cfg.y | 150 ++++++++++++++++++++++++++++++++++++++++++++++++---------------- 1 files changed, 112 insertions(+), 38 deletions(-) diff --git a/cfg.y b/cfg.y index ce6e130..d6422f6 100644 --- a/cfg.y +++ b/cfg.y @@ -99,6 +99,7 @@ #include <stdlib.h> #include <stdio.h> +#include <stdarg.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> @@ -180,7 +181,7 @@ extern int yylex(); -static void yyerror(char* s); +static void yyerror(char* s, ...); static char* tmp; static int i_tmp; static unsigned u_tmp; @@ -199,6 +200,10 @@ static struct lvalue* lval_tmp; static struct rvalue* rval_tmp; static void warn(char* s); +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, + struct rval_expr* rve2); static struct socket_id* mk_listen_id(char*, int, int); static struct name_lst* mk_name_lst(char* name, int flags); static struct socket_id* mk_listen_id2(struct name_lst*, int, int); @@ -1489,7 +1494,7 @@ send_route_stm: ROUTE_SEND LBRACE actions RBRACE { exp: rval_expr { - if (!rve_check_type((enum rval_type*)&i_tmp, $1)){ + if (!rve_check_type((enum rval_type*)&i_tmp, $1, 0, 0 ,0)){ yyerror("invalid expression"); $$=0; }else if (i_tmp!=RV_INT && i_tmp!=RV_NONE){ @@ -1992,18 +1997,18 @@ lval: attr_id_ass { } ; -rval: intno {$$=mk_rval_expr_v(RV_INT, (void*)$1); } +rval: intno {$$=mk_rve_rval(RV_INT, (void*)$1); } | STRING { s_tmp.s=$1; s_tmp.len=strlen($1); - $$=mk_rval_expr_v(RV_STR, &s_tmp); } - | attr_id_any {$$=mk_rval_expr_v(RV_AVP, $1); pkg_free($1); } - | pvar {$$=mk_rval_expr_v(RV_PVAR, $1); pkg_free($1); } + $$=mk_rve_rval(RV_STR, &s_tmp); } + | attr_id_any {$$=mk_rve_rval(RV_AVP, $1); pkg_free($1); } + | pvar {$$=mk_rve_rval(RV_PVAR, $1); pkg_free($1); } | avp_pvar { switch($1->type){ case LV_AVP: - $$=mk_rval_expr_v(RV_AVP, &$1->lv.avps); + $$=mk_rve_rval(RV_AVP, &$1->lv.avps); break; case LV_PVAR: - $$=mk_rval_expr_v(RV_PVAR, &$1->lv.pvs); + $$=mk_rve_rval(RV_PVAR, &$1->lv.pvs); break; default: yyerror("BUG: invalid lvalue type "); @@ -2011,11 +2016,12 @@ rval: intno {$$=mk_rval_expr_v(RV_INT, (void*)$1); } } pkg_free($1); /* not needed anymore */ } - | select_id {$$=mk_rval_expr_v(RV_SEL, $1); pkg_free($1); } - | fcmd {$$=mk_rval_expr_v(RV_ACTION_ST, $1); } - | LBRACE actions RBRACE {$$=mk_rval_expr_v(RV_ACTION_ST, $2); } + | select_id {$$=mk_rve_rval(RV_SEL, $1); pkg_free($1); } + | fcmd {$$=mk_rve_rval(RV_ACTION_ST, $1); } + | exp_elem { $$=mk_rve_rval(RV_BEXPR, $1); } + | LBRACE actions RBRACE {$$=mk_rve_rval(RV_ACTION_ST, $2); } | LBRACE error RBRACE { yyerror("bad command block"); } - | LPAREN assign_action RPAREN {$$=mk_rval_expr_v(RV_ACTION_ST, $2); } + | LPAREN assign_action RPAREN {$$=mk_rve_rval(RV_ACTION_ST, $2); } | LPAREN error RPAREN { yyerror("bad expression"); } ; @@ -2039,36 +2045,32 @@ rval_expr: rval { $$=$1; YYABORT; } } - | rve_un_op %prec NOT rval_expr {$$=mk_rval_expr1($1, $2); } - | rval_expr PLUS rval_expr {$$=mk_rval_expr2(RVE_PLUS_OP, $1, $3); } - | rval_expr MINUS rval_expr {$$=mk_rval_expr2(RVE_MINUS_OP, $1, $3); } - | rval_expr STAR rval_expr {$$=mk_rval_expr2(RVE_MUL_OP, $1, $3); } - | rval_expr SLASH rval_expr {$$=mk_rval_expr2(RVE_DIV_OP, $1, $3); } - | rval_expr BIN_OR rval_expr {$$=mk_rval_expr2(RVE_BOR_OP, $1, $3); } - | rval_expr BIN_AND rval_expr {$$=mk_rval_expr2(RVE_BAND_OP, $1, $3);} - | rval_expr rve_cmpop %prec GT rval_expr - { $$=mk_rval_expr2( $2, $1, $3);} + | rve_un_op %prec NOT rval_expr {$$=mk_rve1($1, $2); } + | rval_expr PLUS rval_expr {$$=mk_rve2(RVE_PLUS_OP, $1, $3); } + | rval_expr MINUS rval_expr {$$=mk_rve2(RVE_MINUS_OP, $1, $3); } + | rval_expr STAR rval_expr {$$=mk_rve2(RVE_MUL_OP, $1, $3); } + | rval_expr SLASH rval_expr {$$=mk_rve2(RVE_DIV_OP, $1, $3); } + | rval_expr BIN_OR rval_expr {$$=mk_rve2(RVE_BOR_OP, $1, $3); } + | rval_expr BIN_AND rval_expr {$$=mk_rve2(RVE_BAND_OP, $1, $3);} + | rval_expr rve_cmpop %prec GT rval_expr { $$=mk_rve2( $2, $1, $3);} | rval_expr rve_equalop %prec EQUAL_T rval_expr - { $$=mk_rval_expr2( $2, $1, $3);} - | rval_expr LOG_AND rval_expr - { $$=mk_rval_expr2(RVE_LAND_OP, $1, $3);} - | rval_expr LOG_OR rval_expr - { $$=mk_rval_expr2(RVE_LOR_OP, $1, $3);} - | LPAREN rval_expr RPAREN { $$=$2; } - | exp_elem { $$=mk_rval_expr_v(RV_BEXPR, $1); } - | rve_un_op %prec NOT error { yyerror("bad expression"); } - | rval_expr PLUS error { yyerror("bad expression"); } - | rval_expr MINUS error { yyerror("bad expression"); } - | rval_expr STAR error { yyerror("bad expression"); } - | rval_expr SLASH error { yyerror("bad expression"); } - | rval_expr BIN_OR error { yyerror("bad expression"); } - | rval_expr BIN_AND error { yyerror("bad expression"); } + { $$=mk_rve2( $2, $1, $3);} + | rval_expr LOG_AND rval_expr { $$=mk_rve2(RVE_LAND_OP, $1, $3);} + | rval_expr LOG_OR rval_expr { $$=mk_rve2(RVE_LOR_OP, $1, $3);} + | LPAREN rval_expr RPAREN { $$=$2; } + | rve_un_op %prec NOT error { yyerror("bad expression"); } + | rval_expr PLUS error { yyerror("bad expression"); } + | rval_expr MINUS error { yyerror("bad expression"); } + | rval_expr STAR error { yyerror("bad expression"); } + | rval_expr SLASH error { yyerror("bad expression"); } + | rval_expr BIN_OR error { yyerror("bad expression"); } + | rval_expr BIN_AND error { yyerror("bad expression"); } | rval_expr rve_cmpop %prec GT error { yyerror("bad expression"); } | rval_expr rve_equalop %prec EQUAL_T error { yyerror("bad expression"); } - | rval_expr LOG_AND error { yyerror("bad expression"); } - | rval_expr LOG_OR error { yyerror("bad expression"); } + | rval_expr LOG_AND error { yyerror("bad expression"); } + | rval_expr LOG_OR error { yyerror("bad expression"); } ; assign_action: lval assign_op rval_expr { $$=mk_action($2, 2, LVAL_ST, $1, @@ -2562,8 +2564,14 @@ static void warn(char* s) cfg_warnings++; } -static void yyerror(char* s) +static void yyerror(char* format, ...) { + va_list ap; + char s[256]; + + va_start(ap, format); + vsnprintf(s, sizeof(s), format, ap); + va_end(ap); if (line!=startline) LOG(L_CRIT, "*** PARSE ERROR *** (%d,%d-%d,%d): %s\n", startline, startcolumn, line, column-1, s); @@ -2577,6 +2585,72 @@ static void yyerror(char* s) } +/** mk_rval_expr_v wrapper. + * checks mk_rval_expr_v return value and sets the cfg. pos + * (line and column numbers) + * @return rval_expr* on success, 0 on error (@see mk_rval_expr_v) + */ +static struct rval_expr* mk_rve_rval(enum rval_type type, void* v) +{ + struct rval_expr* ret; + + ret=mk_rval_expr_v(type, v); + if (ret==0){ + yyerror("internal error: failed to create rval expr"); + /* YYABORT; */ + } + return ret; +} + + +/** mk_rval_expr1 wrapper. + * checks mk_rval_expr1 return value (!=0 and type checking) + * @return rval_expr* on success, 0 on error (@see mk_rval_expr1) + */ +static struct rval_expr* mk_rve1(enum rval_expr_op op, struct rval_expr* rve1) +{ + struct rval_expr* ret; + struct rval_expr* bad_rve; + enum rval_type type, bad_t, exp_t; + + ret=mk_rval_expr1(op, rve1); + if (ret && (rve_check_type(&type, ret, &bad_rve, &bad_t, &exp_t)!=1)){ + yyerror("bad expression: type mismatch (%s instead of %s)", + rval_type_name(bad_t), rval_type_name(exp_t)); + } + return ret; +} + + +/** mk_rval_expr2 wrapper. + * checks mk_rval_expr2 return value (!=0 and type checking) + * @return rval_expr* on success, 0 on error (@see mk_rval_expr2) + */ +static struct rval_expr* mk_rve2(enum rval_expr_op op, struct rval_expr* rve1, + struct rval_expr* rve2) +{ + struct rval_expr* ret; + struct rval_expr* bad_rve; + enum rval_type type, type1, type2, bad_t, exp_t; + + ret=mk_rval_expr2(op, rve1, rve2); + if (ret && (rve_check_type(&type, ret, &bad_rve, &bad_t, &exp_t)!=1)){ + if (rve_check_type(&type1, rve1, &bad_rve, &bad_t, &exp_t)!=1) + yyerror("bad expression: left side type mismatch" + " (%s instead of %s)", + rval_type_name(bad_t), rval_type_name(exp_t)); + else if (rve_check_type(&type2, rve2, &bad_rve, &bad_t, &exp_t)!=1) + yyerror("bad expression: right side type mismatch" + " (%s instead of %s)", + rval_type_name(bad_t), rval_type_name(exp_t)); + else + yyerror("bad expression: type mismatch (%s instead of %s)", + rval_type_name(bad_t), rval_type_name(exp_t)); + } + return ret; +} + + static struct name_lst* mk_name_lst(char* host, int flags) { struct name_lst* l;

15 years, 9 months

git:andrei/script_vars: script engine: rve_check_type() extended

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/script_vars Commit: 70341d3b4f46c8a6bdbbdfcb314f01cee08a226d URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=70341d3… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Mon Dec 15 21:22:09 2008 +0100 script engine: rve_check_type() extended - extended rve_check_type() to return also the subexpression for which the check failed, its type and the expected type. --- rvalue.c | 101 ++++++++++++++++++++++++++++++++++++++++++++++++++++---------- rvalue.h | 6 +++- 2 files changed, 90 insertions(+), 17 deletions(-) diff --git a/rvalue.c b/rvalue.c index ed73baf..c637dec 100644 --- a/rvalue.c +++ b/rvalue.c @@ -191,6 +191,36 @@ struct rvalue* rval_new_str(str* s, int extra_size) +/** get string name for a type. + * + * @return - null terminated name of the type + */ +char* rval_type_name(enum rval_type type) +{ + switch(type){ + case RV_NONE: + return "none"; + case RV_INT: + return "int"; + case RV_STR: + return "str"; + case RV_BEXPR: + return "bexpr_t"; + case RV_ACTION_ST: + return "action_t"; + case RV_PVAR: + return "pvar"; + case RV_AVP: + return "avp"; + break; + case RV_SEL: + return "select"; + } + return "error_unkown_type"; +} + + + /** create a new pk_malloc'ed rvalue from a rval_val union. * * @param s - pointer to str, must be non-null @@ -242,7 +272,7 @@ inline static enum rval_type rval_get_btype(struct run_act_ctx* h, pv_value_t* pv; enum rval_type tmp; enum rval_type* ptype; - + switch(rv->type){ case RV_INT: case RV_STR: @@ -454,10 +484,21 @@ static int rve_op_unary(enum rval_expr_op op) /** returns 1 if expression is valid (type-wise). + * @param type - filled with the type of the expression (RV_INT, RV_STR or + * RV_NONE if it's dynamic) + * @param rve - checked expression + * @param bad_rve - set on failure to the subexpression for which the + * type check failed + * @param bad_type - set on failure to the type of the bad subexpression + * @param exp_type - set on failure to the expected type for the bad + * subexpression * @return 0 or 1 and sets *type to the resulting type * (RV_INT, RV_STR or RV_NONE if it can be found only at runtime) */ -int rve_check_type(enum rval_type* type, struct rval_expr* rve) +int rve_check_type(enum rval_type* type, struct rval_expr* rve, + struct rval_expr** bad_rve, + enum rval_type* bad_t, + enum rval_type* exp_t) { enum rval_type type1, type2; @@ -469,9 +510,13 @@ int rve_check_type(enum rval_type* type, struct rval_expr* rve) case RVE_BOOL_OP: case RVE_LNOT_OP: *type=RV_INT; - if (rve_check_type(&type1, rve->left.rve)){ - if (type1==RV_STR) + if (rve_check_type(&type1, rve->left.rve, bad_rve, bad_t, exp_t)){ + if (type1==RV_STR){ + if (bad_rve) *bad_rve=rve->left.rve; + if (bad_t) *bad_t=type1; + if (exp_t) *exp_t=RV_INT; return 0; + } return 1; } return 0; @@ -488,12 +533,21 @@ int rve_check_type(enum rval_type* type, struct rval_expr* rve) case RVE_LT_OP: case RVE_LTE_OP: *type=RV_INT; - if (rve_check_type(&type1, rve->left.rve)){ - if (type1==RV_STR) + if (rve_check_type(&type1, rve->left.rve, bad_rve, bad_t, exp_t)){ + if (type1==RV_STR){ + if (bad_rve) *bad_rve=rve->left.rve; + if (bad_t) *bad_t=type1; + if (exp_t) *exp_t=RV_INT; return 0; - if (rve_check_type(&type2, rve->right.rve)){ - if (type2==RV_STR) + } + if (rve_check_type(&type2, rve->right.rve, bad_rve, + bad_t, exp_t)){ + if (type2==RV_STR){ + if (bad_rve) *bad_rve=rve->left.rve; + if (bad_t) *bad_t=type2; + if (exp_t) *exp_t=RV_INT; return 0; + } return 1; } } @@ -501,23 +555,34 @@ int rve_check_type(enum rval_type* type, struct rval_expr* rve) case RVE_EQ_OP: case RVE_DIFF_OP: *type=RV_INT; - if (rve_check_type(&type1, rve->left.rve)){ - if (rve_check_type(&type2, rve->right.rve)){ + 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)) + !(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; + } return 1; } } return 0; case RVE_PLUS_OP: - if (rve_check_type(&type1, rve->left.rve)){ - if (rve_check_type(&type2, rve->right.rve)){ + *type=RV_NONE; + 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)) + !(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; + } *type=type1; return 1; } @@ -1879,6 +1944,8 @@ static int rve_optimize(struct rval_expr* rve) int flags; struct rval_expr tmp_rve; enum rval_type type; + struct rval_expr* bad_rve; + enum rval_type bad_type, exp_type; ret=0; flags=0; @@ -1912,8 +1979,10 @@ static int rve_optimize(struct rval_expr* rve) return rve_optimize(rve->left.rve); rve_optimize(rve->left.rve); rve_optimize(rve->right.rve); - if (!rve_check_type(&type, rve)){ - ERR("optimization failure, type mismatch in expression\n"); + if (!rve_check_type(&type, rve, &bad_rve, &bad_type, &exp_type)){ + ERR("optimization failure, type mismatch in expression, " + "type %s, but expected %s\n", + rval_type_name(bad_type), rval_type_name(exp_type)); return 0; } /* TODO: $v - a => $v + (-a) */ diff --git a/rvalue.h b/rvalue.h index faa6143..5a1c10b 100644 --- a/rvalue.h +++ b/rvalue.h @@ -185,7 +185,11 @@ enum rval_type rve_guess_type(struct rval_expr* rve); /** returns true if expression is constant. */ int rve_is_constant(struct rval_expr* rve); /** returns 1 if expression is valid (type-wise).*/ -int rve_check_type(enum rval_type* type, struct rval_expr* rve); +int rve_check_type(enum rval_type* type, struct rval_expr* rve, + struct rval_expr** bad_rve, enum rval_type* bad_type, + enum rval_type* exp_type); +/** returns a string name for type (debugging).*/ +char* rval_type_name(enum rval_type type); /** create a RVE_RVAL_OP rval_expr, containing a single rval of the given type */

15 years, 9 months

git:andrei/script_vars: script parsing: better expression error reporting

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/script_vars Commit: 9a31872ccbd89266c5300a0f443f96b6a4934e6f URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=9a31872… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Mon Dec 15 23:13:20 2008 +0100 script parsing: better expression error reporting - report bad expression position on type mismatch e.g.: *** PARSE ERROR *** (42,8-18): bad expression: type mismatch: str instead of int at (42,16) --- cfg.y | 97 ++++++++++++++++++++++++++++++++++++++++++-------------- route_struct.h | 9 +++++ rvalue.c | 15 ++++++-- rvalue.h | 11 +++++-- 4 files changed, 101 insertions(+), 31 deletions(-) diff --git a/cfg.y b/cfg.y index d6422f6..7ced7c1 100644 --- a/cfg.y +++ b/cfg.y @@ -200,6 +200,9 @@ static struct lvalue* lval_tmp; 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, @@ -2057,7 +2060,7 @@ rval_expr: rval { $$=$1; { $$=mk_rve2( $2, $1, $3);} | rval_expr LOG_AND rval_expr { $$=mk_rve2(RVE_LAND_OP, $1, $3);} | rval_expr LOG_OR rval_expr { $$=mk_rve2(RVE_LOR_OP, $1, $3);} - | LPAREN rval_expr RPAREN { $$=$2; } + | LPAREN rval_expr RPAREN { $$=$2;} | rve_un_op %prec NOT error { yyerror("bad expression"); } | rval_expr PLUS error { yyerror("bad expression"); } | rval_expr MINUS error { yyerror("bad expression"); } @@ -2551,6 +2554,16 @@ extern int column; extern int startcolumn; extern int startline; + +static void get_cpos(struct cfg_pos* pos) +{ + pos->s_line=startline; + pos->e_line=line; + pos->s_col=startcolumn; + pos->e_col=column-1; +} + + static void warn(char* s) { if (line!=startline) @@ -2564,7 +2577,7 @@ static void warn(char* s) cfg_warnings++; } -static void yyerror(char* format, ...) +static void yyerror_at(struct cfg_pos* p, char* format, ...) { va_list ap; char s[256]; @@ -2572,19 +2585,53 @@ static void yyerror(char* format, ...) va_start(ap, format); vsnprintf(s, sizeof(s), format, ap); va_end(ap); - if (line!=startline) + if (p->e_line!=p->s_line) LOG(L_CRIT, "*** PARSE ERROR *** (%d,%d-%d,%d): %s\n", - startline, startcolumn, line, column-1, s); - else if (startcolumn!=(column-1)) + p->s_line, p->s_col, p->e_line, p->e_col, s); + else if (p->s_col!=p->e_col) LOG(L_CRIT, "*** PARSE ERROR *** (%d,%d-%d): %s\n", - startline, startcolumn, column-1, s); + p->s_line, p->s_col, p->e_col, s); else LOG(L_CRIT, "*** PARSE ERROR *** (%d,%d): %s\n", - startline, startcolumn, s); + p->s_line, p->s_col, s); cfg_errors++; } +static void yyerror(char* format, ...) +{ + va_list ap; + char s[256]; + struct cfg_pos pos; + + get_cpos(&pos); + va_start(ap, format); + vsnprintf(s, sizeof(s), format, ap); + va_end(ap); + yyerror_at(&pos, s); +} + + + +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) @@ -2593,8 +2640,10 @@ static void yyerror(char* format, ...) static struct rval_expr* mk_rve_rval(enum rval_type type, void* v) { struct rval_expr* ret; + struct cfg_pos pos; - ret=mk_rval_expr_v(type, v); + get_cpos(&pos); + ret=mk_rval_expr_v(type, v, &pos); if (ret==0){ yyerror("internal error: failed to create rval expr"); /* YYABORT; */ @@ -2613,10 +2662,13 @@ static struct rval_expr* mk_rve1(enum rval_expr_op op, struct rval_expr* rve1) struct rval_expr* bad_rve; enum rval_type type, bad_t, exp_t; - ret=mk_rval_expr1(op, rve1); + if (rve1==0) + return 0; + ret=mk_rval_expr1(op, rve1, &rve1->fpos); if (ret && (rve_check_type(&type, ret, &bad_rve, &bad_t, &exp_t)!=1)){ - yyerror("bad expression: type mismatch (%s instead of %s)", - rval_type_name(bad_t), rval_type_name(exp_t)); + yyerror_at(&rve1->fpos, "bad expression: type mismatch" + " (%s instead of %s)", rval_type_name(bad_t), + rval_type_name(exp_t)); } return ret; } @@ -2631,21 +2683,18 @@ static struct rval_expr* mk_rve2(enum rval_expr_op op, struct rval_expr* rve1, { struct rval_expr* ret; struct rval_expr* bad_rve; - enum rval_type type, type1, type2, bad_t, exp_t; + enum rval_type type, bad_t, exp_t; + struct cfg_pos pos; - ret=mk_rval_expr2(op, rve1, rve2); + if ((rve1==0) || (rve2==0)) + return 0; + get_rve2_pos(&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)){ - if (rve_check_type(&type1, rve1, &bad_rve, &bad_t, &exp_t)!=1) - yyerror("bad expression: left side type mismatch" - " (%s instead of %s)", - rval_type_name(bad_t), rval_type_name(exp_t)); - else if (rve_check_type(&type2, rve2, &bad_rve, &bad_t, &exp_t)!=1) - yyerror("bad expression: right side type mismatch" - " (%s instead of %s)", - rval_type_name(bad_t), rval_type_name(exp_t)); - else - yyerror("bad expression: type mismatch (%s instead of %s)", - rval_type_name(bad_t), rval_type_name(exp_t)); + yyerror_at(&pos, "bad expression: type mismatch:" + " %s instead of %s at (%d,%d)", + rval_type_name(bad_t), rval_type_name(exp_t), + bad_rve->fpos.s_line, bad_rve->fpos.s_col); } return ret; } diff --git a/route_struct.h b/route_struct.h index c27fef2..ba5046e 100644 --- a/route_struct.h +++ b/route_struct.h @@ -102,6 +102,15 @@ enum { NOSUBTYPE=0, STRING_ST, NET_ST, NUMBER_ST, IP_ST, RE_ST, PROXY_ST, #define EXIT_R_F 1 #define RETURN_R_F 2 + +struct cfg_pos{ + int s_line; + int e_line; + unsigned short s_col; + unsigned short e_col; +}; + + /* Expression operand */ union exp_op { void* param; diff --git a/rvalue.c b/rvalue.c index c637dec..6f9b118 100644 --- a/rvalue.c +++ b/rvalue.c @@ -543,7 +543,7 @@ int rve_check_type(enum rval_type* type, struct rval_expr* rve, if (rve_check_type(&type2, rve->right.rve, bad_rve, bad_t, exp_t)){ if (type2==RV_STR){ - if (bad_rve) *bad_rve=rve->left.rve; + if (bad_rve) *bad_rve=rve->right.rve; if (bad_t) *bad_t=type2; if (exp_t) *exp_t=RV_INT; return 0; @@ -1597,9 +1597,11 @@ error: * * @param rv_type - rval type * @param val - rval value + * @param pos - config position * @return new pkg_malloc'ed rval_expr or 0 on error. */ -struct rval_expr* mk_rval_expr_v(enum rval_type rv_type, void* val) +struct rval_expr* mk_rval_expr_v(enum rval_type rv_type, void* val, + struct cfg_pos* pos) { struct rval_expr* rve; union rval_val v; @@ -1649,6 +1651,7 @@ struct rval_expr* mk_rval_expr_v(enum rval_type rv_type, void* val) } rval_init(&rve->left.rval, rv_type, &v, flags); rve->op=RVE_RVAL_OP; + if (pos) rve->fpos=*pos; return rve; } @@ -1660,7 +1663,8 @@ struct rval_expr* mk_rval_expr_v(enum rval_type rv_type, void* val) * @param rve1 - rval expr. on which the operator will act. * @return new pkg_malloc'ed rval_expr or 0 on error. */ -struct rval_expr* mk_rval_expr1(enum rval_expr_op op, struct rval_expr* rve1) +struct rval_expr* mk_rval_expr1(enum rval_expr_op op, struct rval_expr* rve1, + struct cfg_pos* pos) { struct rval_expr* ret; @@ -1679,6 +1683,7 @@ struct rval_expr* mk_rval_expr1(enum rval_expr_op op, struct rval_expr* rve1) memset(ret, sizeof(*ret), 0); ret->op=op; ret->left.rve=rve1; + if (pos) ret->fpos=*pos; return ret; } @@ -1692,7 +1697,8 @@ struct rval_expr* mk_rval_expr1(enum rval_expr_op op, struct rval_expr* rve1) * @return new pkg_malloc'ed rval_expr or 0 on error. */ struct rval_expr* mk_rval_expr2(enum rval_expr_op op, struct rval_expr* rve1, - struct rval_expr* rve2) + struct rval_expr* rve2, + struct cfg_pos* pos) { struct rval_expr* ret; @@ -1723,6 +1729,7 @@ struct rval_expr* mk_rval_expr2(enum rval_expr_op op, struct rval_expr* rve1, ret->op=op; ret->left.rve=rve1; ret->right.rve=rve2; + if (pos) ret->fpos=*pos; return ret; } diff --git a/rvalue.h b/rvalue.h index 5a1c10b..f36f189 100644 --- a/rvalue.h +++ b/rvalue.h @@ -94,6 +94,7 @@ struct rvalue{ #define RV_RV_ALLOCED_F 2 /* free rv itself (pkg_free(rv)) */ #define RV_ALL_ALLOCED_F (RV_CNT_ALLOCED|RV_RV_ALLOCED) + struct rval_expr{ enum rval_expr_op op; union{ @@ -104,6 +105,7 @@ struct rval_expr{ struct rval_expr* rve; struct rvalue rval; }right; + struct cfg_pos fpos; }; @@ -193,12 +195,15 @@ char* rval_type_name(enum rval_type type); /** create a RVE_RVAL_OP rval_expr, containing a single rval of the given type */ -struct rval_expr* mk_rval_expr_v(enum rval_type rv_type, void* val); +struct rval_expr* mk_rval_expr_v(enum rval_type rv_type, void* val, + struct cfg_pos* pos); /** create a unary op. rval_expr.. */ -struct rval_expr* mk_rval_expr1(enum rval_expr_op op, struct rval_expr* rve1); +struct rval_expr* mk_rval_expr1(enum rval_expr_op op, struct rval_expr* rve1, + struct cfg_pos* pos); /** create a rval_expr. from 2 other rval exprs, using op. */ struct rval_expr* mk_rval_expr2(enum rval_expr_op op, struct rval_expr* rve1, - struct rval_expr* rve2); + struct rval_expr* rve2, + struct cfg_pos* pos); /** fix a rval_expr. */ int fix_rval_expr(void** p);

15 years, 9 months

git repository online

by Andrei Pelinescu-Onciul

As you probably have noticed the git repository for sip-router is now online. It was started from ser core and tm. git urls: git://git.sip-router.org/sip-router (read only) http://git.sip-router.org/sip-router (read only, slower, git://... recomended) ssh://git.sip-router.org/sip-router (read write but account on git.sip-router.org needed) Web interface: http://git.sip-router.org/cgi-bin/gitweb.cgi Branches acl: the repository is setup so that you can write/commit only to the following branches: <your_username>/.* tmp/.* master We'll add access to more branches as needed (I've added this rules to avoid creating lots of "root" branches by mistake, e.g. git pull from a local branch without a refspec). Please create the commit messages following the git convention (start with one short line, preferably less then 50 chars summarizing the changes, then one empty line and then a more detailed description). See: http://www.kernel.org/pub/software/scm/git/docs/user-manual.html#creating-g… http://www.tpope.net/node/106 Quick git introduction: # clone the repo into the sip-router directory git clone git://git.sip-router.org/sip-router cd sip-router git branch -a # show all branches # create a local branch based on origin/andrei/mod_f_params git checkout --track -b my_branch origin/andrei/mod_f_params git log # see commit log git log --pretty=oneline # only the first line from each commit vim Makefile.defs git add Makefile.defs git commit # or git commmit -a to skip the add step and commit all # changed files # push changes back (note you need ssh access for this) # note: the next command will fail, unless your username is andrei :-) # publish changes on the local "my_branc" to the remote # andrei/mod_f_params git push origin my_branch:andrei/mod_f_params # or push them into the master branch if you are sure about them git push origin my_branch:master For more info about git try: http://git.or.cz/gitwiki/GitDocumentation and if you want to know how it works: http://eagain.net/articles/git-for-computer-scientists/ (highly recommended) CVS access: CVS_SERVER="git cvsserver" cvs \ -d :ext:andrei@git.sip-router.org/sip-router co master (instead of master you can use any other branch name that doesn't include a '/') The initial checkout takes a while, but after that cvs update seems fast enough. SVN access: unfortunately we do not have it. It looks like the git svnserver is in the project stage (there is some python code but not runnable yet). There is a way around it, but it would be quite complex to setup: a git to svn gateway and then svn to git imports. Other repositories on git.sip-router.org: ser - entire ser updated from cvs ser_core - only ser_core, automatically updated from cvs, read-only test - test repository, contains an early sip-router version, it has the same access rules as sip-router (if you have something you want to test, please use it rather then trying directly on sip-router). Special thanks go to Jan, who not only did setup git.sip-router.org (including automatic cvs sync for some of the repos), but he's also hosting it on one of his private machines. Andrei

15 years, 9 months

Usrloc, Databases, and Caching

by Martin Hoffmann

Heisann, I know everyone is busy getting this project off the ground, but I think it might be worthwhile discussing the future on the side and anyway, this regards the database API which sort of is currently being nailed down. Since we were talking about it internally, I was thinking a bit about the future of usrloc. It has this thing where it caches entries in memory. Now, technically usrloc is just a database (or maybe a database on top of a database). Wouldn't it make sense to get rid of it and instead implement a database module that caches and then simplify the registrar module to use database queries directly? This has the benefit that other modules can suddenly use caching, too, if they want. In SER, the domain module for instance already does some caching, so there is some code replication. I believe the database API to be simple enough to provide caching especially since the new model with pre-registered queries allows the cache to be set up with those queries in mind. Regards, Martin

15 years, 9 months

git:andrei/script_vars: pvars: silent version for pv_parse_spec

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/script_vars Commit: 15ec6f3c26b83d6123e228d93181e92d1ba1bbc4 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=15ec6f3… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Fri Dec 12 14:20:55 2008 +0100 pvars: silent version for pv_parse_spec - added a silent version for pv_parse_spec (pv_parse_spec2()), so that the script parsing fallback from pvars to avps for ambiguous identifiers can happen without a ton of error messages --- cfg.y | 3 +- pvapi.c | 87 ++++++++++++++++++++++++++++++++++++++------------------------ pvar.h | 3 +- 3 files changed, 57 insertions(+), 36 deletions(-) diff --git a/cfg.y b/cfg.y index 6bd5b43..ce6e130 100644 --- a/cfg.y +++ b/cfg.y @@ -1913,6 +1913,7 @@ pvar: PVAR { if (pv_parse_spec(&s_tmp, pv_spec)==0){ yyerror("unknown script pseudo variable"); pkg_free(pv_spec); + pv_spec=0; YYABORT; } $$=pv_spec; @@ -1927,7 +1928,7 @@ avp_pvar: AVP_OR_PVAR { } memset(lval_tmp, 0, sizeof(*lval_tmp)); s_tmp.s=$1; s_tmp.len=strlen(s_tmp.s); - if (pv_parse_spec(&s_tmp, &lval_tmp->lv.pvs)==0){ + if (pv_parse_spec2(&s_tmp, &lval_tmp->lv.pvs, 1)==0){ /* not a pvar, try avps */ lval_tmp->lv.avps.type|= AVP_NAME_STR; lval_tmp->lv.avps.name.s.s = s_tmp.s+1; diff --git a/pvapi.c b/pvapi.c index f3d7b58..77c2de2 100644 --- a/pvapi.c +++ b/pvapi.c @@ -352,7 +352,7 @@ pv_export_t* pv_lookup_spec_name(str *pvname, pv_spec_p e) return NULL; } -char* pv_parse_spec(str *in, pv_spec_p e) +char* pv_parse_spec2(str *in, pv_spec_p e, int silent) { char *p; str s; @@ -364,7 +364,7 @@ char* pv_parse_spec(str *in, pv_spec_p e) if(in==NULL || in->s==NULL || e==NULL || *in->s!=PV_MARKER) { - LM_ERR("bad parameters\n"); + if (!silent) LM_ERR("bad parameters\n"); return NULL; } @@ -411,8 +411,9 @@ char* pv_parse_spec(str *in, pv_spec_p e) p++; pvstate = 4; } else { - LM_ERR("invalid char '%c' in [%.*s] (%d)\n", *p, in->len, in->s, - pvstate); + if (!silent) + LM_ERR("invalid char '%c' in [%.*s] (%d)\n", + *p, in->len, in->s, pvstate); goto error; } } else { @@ -433,21 +434,24 @@ char* pv_parse_spec(str *in, pv_spec_p e) done_inm: if((pte = pv_lookup_spec_name(&pvname, e))==NULL) { - LM_ERR("error searching pvar \"%.*s\"\n", pvname.len, pvname.s); + if (!silent) + LM_ERR("error searching pvar \"%.*s\"\n", pvname.len, pvname.s); goto error; } if(pte->parse_name!=NULL && pvstate!=2 && pvstate!=5) { - LM_ERR("pvar \"%.*s\" expects an inner name\n", - pvname.len, pvname.s); + if (!silent) + LM_ERR("pvar \"%.*s\" expects an inner name\n", + pvname.len, pvname.s); goto error; } if(pvstate==2 || pvstate==5) { if(pte->parse_name==NULL) { - LM_ERR("pvar \"%.*s\" does not get name param\n", - pvname.len, pvname.s); + if (!silent) + LM_ERR("pvar \"%.*s\" does not get name param\n", + pvname.len, pvname.s); goto error; } s.s = p; @@ -470,15 +474,17 @@ done_inm: if(p==s.s) { - LM_ERR("pvar \"%.*s\" does not get empty name param\n", - pvname.len, pvname.s); + if (!silent) + LM_ERR("pvar \"%.*s\" does not get empty name param\n", + pvname.len, pvname.s); goto error; } s.len = p - s.s; if(pte->parse_name(e, &s)!=0) { - LM_ERR("pvar \"%.*s\" has an invalid name param [%.*s]\n", - pvname.len, pvname.s, s.len, s.s); + if (!silent) + LM_ERR("pvar \"%.*s\" has an invalid name param [%.*s]\n", + pvname.len, pvname.s, s.len, s.s); goto error; } if(pvstate==2) @@ -494,8 +500,9 @@ done_inm: p++; pvstate = 4; } else { - LM_ERR("invalid char '%c' in [%.*s] (%d)\n", *p, in->len, in->s, - pvstate); + if (!silent) + LM_ERR("invalid char '%c' in [%.*s] (%d)\n", + *p, in->len, in->s, pvstate); goto error; } } else { @@ -504,8 +511,9 @@ done_inm: p++; goto done_all; } else { - LM_ERR("invalid char '%c' in [%.*s] (%d)\n", *p, in->len, in->s, - pvstate); + if (!silent) + LM_ERR("invalid char '%c' in [%.*s] (%d)\n", + *p, in->len, in->s, pvstate); goto error; } } @@ -515,8 +523,9 @@ done_vnm: { if(pte->parse_index==NULL) { - LM_ERR("pvar \"%.*s\" does not get index param\n", - pvname.len, pvname.s); + if (!silent) + LM_ERR("pvar \"%.*s\" does not get index param\n", + pvname.len, pvname.s); goto error; } s.s = p; @@ -538,15 +547,17 @@ done_vnm: if(p==s.s) { - LM_ERR("pvar \"%.*s\" does not get empty index param\n", - pvname.len, pvname.s); + if (!silent) + LM_ERR("pvar \"%.*s\" does not get empty index param\n", + pvname.len, pvname.s); goto error; } s.len = p - s.s; if(pte->parse_index(e, &s)!=0) { - LM_ERR("pvar \"%.*s\" has an invalid index param [%.*s]\n", - pvname.len, pvname.s, s.len, s.s); + if (!silent) + LM_ERR("pvar \"%.*s\" has an invalid index param [%.*s]\n", + pvname.len, pvname.s, s.len, s.s); goto error; } p++; @@ -557,8 +568,9 @@ done_vnm: p++; pvstate = 4; } else { - LM_ERR("invalid char '%c' in [%.*s] (%d)\n", *p, in->len, in->s, - pvstate); + if (!silent) + LM_ERR("invalid char '%c' in [%.*s] (%d)\n", + *p, in->len, in->s, pvstate); goto error; } } @@ -594,8 +606,9 @@ done_idx: if(p==s.s) { - LM_ERR("pvar \"%.*s\" does not get empty index param\n", - pvname.len, pvname.s); + if (!silent) + LM_ERR("pvar \"%.*s\" does not get empty index param\n", + pvname.len, pvname.s); goto error; } s.len = p - s.s + 1; @@ -603,12 +616,14 @@ done_idx: p = tr_lookup(&s, &tr); if(p==NULL) { - LM_ERR("bad tr in pvar name \"%.*s\"\n", pvname.len, pvname.s); + if (!silent) + LM_ERR("bad tr in pvar name \"%.*s\"\n", pvname.len, pvname.s); goto error; } if(*p!=PV_RNBRACKET) { - LM_ERR("bad pvar name \"%.*s\" (%c)!\n", in->len, in->s, *p); + if (!silent) + LM_ERR("bad pvar name \"%.*s\" (%c)!\n", in->len, in->s, *p); goto error; } e->trans = (void*)tr; @@ -621,11 +636,15 @@ done_all: return p; error: - if(p!=NULL) - LM_ERR("wrong char [%c/%d] in [%.*s] at [%d (%d)]\n", *p, (int)*p, - in->len, in->s, (int)(p-in->s), pvstate); - else - LM_ERR("invalid parsing in [%.*s] at (%d)\n", in->len, in->s, pvstate); + if(p!=NULL){ + if (!silent) + LM_ERR("wrong char [%c/%d] in [%.*s] at [%d (%d)]\n", *p, (int)*p, + in->len, in->s, (int)(p-in->s), pvstate); + }else{ + if (!silent) + LM_ERR("invalid parsing in [%.*s] at (%d)\n", + in->len, in->s, pvstate); + } return NULL; } /* end: pv_parse_spec */ diff --git a/pvar.h b/pvar.h index 811ea34..5eeac62 100644 --- a/pvar.h +++ b/pvar.h @@ -158,7 +158,8 @@ typedef struct _pv_elem struct _pv_elem *next; } pv_elem_t, *pv_elem_p; -char* pv_parse_spec(str *in, pv_spec_p sp); +char* pv_parse_spec2(str *in, pv_spec_p sp, int silent); +#define pv_parse_spec(in, sp) pv_parse_spec2((in), (sp), 0) int pv_get_spec_value(struct sip_msg* msg, pv_spec_p sp, pv_value_t *value); int pv_print_spec(struct sip_msg* msg, pv_spec_p sp, char *buf, int *len); int pv_printf(struct sip_msg* msg, pv_elem_p list, char *buf, int *len);

15 years, 9 months

git:andrei/script_vars: script parsing: better error reporting

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/script_vars Commit: f65e66ce24a7e4a9a0ff81ee5f5866ef12ed7f9f URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=f65e66c… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Fri Dec 12 13:58:37 2008 +0100 script parsing: better error reporting - more informative parse error messages for expression/rvalues - account for the possibility of having a multi line token when reporting an error message - fixed ending column number in error messages --- cfg.y | 43 ++++++++++++++++++++++++++++++++++++------- 1 files changed, 36 insertions(+), 7 deletions(-) diff --git a/cfg.y b/cfg.y index a17ad4b..6bd5b43 100644 --- a/cfg.y +++ b/cfg.y @@ -2013,9 +2013,9 @@ rval: intno {$$=mk_rval_expr_v(RV_INT, (void*)$1); } | select_id {$$=mk_rval_expr_v(RV_SEL, $1); pkg_free($1); } | fcmd {$$=mk_rval_expr_v(RV_ACTION_ST, $1); } | LBRACE actions RBRACE {$$=mk_rval_expr_v(RV_ACTION_ST, $2); } + | LBRACE error RBRACE { yyerror("bad command block"); } | LPAREN assign_action RPAREN {$$=mk_rval_expr_v(RV_ACTION_ST, $2); } - //| exp {$$=mk_rval_expr_v(RV_BEXPR, $1);} - /* missing/TODO: RV_ACTION_ST */ + | LPAREN error RPAREN { yyerror("bad expression"); } ; @@ -2055,6 +2055,19 @@ rval_expr: rval { $$=$1; { $$=mk_rval_expr2(RVE_LOR_OP, $1, $3);} | LPAREN rval_expr RPAREN { $$=$2; } | exp_elem { $$=mk_rval_expr_v(RV_BEXPR, $1); } + | rve_un_op %prec NOT error { yyerror("bad expression"); } + | rval_expr PLUS error { yyerror("bad expression"); } + | rval_expr MINUS error { yyerror("bad expression"); } + | rval_expr STAR error { yyerror("bad expression"); } + | rval_expr SLASH error { yyerror("bad expression"); } + | rval_expr BIN_OR error { yyerror("bad expression"); } + | rval_expr BIN_AND error { yyerror("bad expression"); } + | rval_expr rve_cmpop %prec GT error + { yyerror("bad expression"); } + | rval_expr rve_equalop %prec EQUAL_T error + { yyerror("bad expression"); } + | rval_expr LOG_AND error { yyerror("bad expression"); } + | rval_expr LOG_OR error { yyerror("bad expression"); } ; assign_action: lval assign_op rval_expr { $$=mk_action($2, 2, LVAL_ST, $1, @@ -2498,12 +2511,13 @@ cmd: } $$ = mod_func_action; } + | ID error { yyerror("'('')' expected (function call)");} ; func_params: /* empty */ | func_params COMMA func_param { } | func_param {} - | func_params error { yyerror("call params error\n"); YYABORT; } + | func_params error { yyerror("call params error\n"); } ; func_param: NUMBER { @@ -2532,17 +2546,32 @@ func_param: extern int line; extern int column; extern int startcolumn; +extern int startline; + static void warn(char* s) { - LOG(L_WARN, "cfg. warning: (%d,%d-%d): %s\n", line, startcolumn, - column, s); + if (line!=startline) + LOG(L_WARN, "cfg. warning: (%d,%d-%d,%d): %s\n", + startline, startcolumn, line, column-1, s); + else if (startcolumn!=(column-1)) + LOG(L_WARN, "cfg. warning: (%d,%d-%d): %s\n", startline, startcolumn, + column-1, s); + else + LOG(L_WARN, "cfg. warning: (%d,%d): %s\n", startline, startcolumn, s); cfg_warnings++; } static void yyerror(char* s) { - LOG(L_CRIT, "*** PARSE ERROR *** (%d,%d-%d): %s\n", line, startcolumn, - column, s); + if (line!=startline) + LOG(L_CRIT, "*** PARSE ERROR *** (%d,%d-%d,%d): %s\n", + startline, startcolumn, line, column-1, s); + else if (startcolumn!=(column-1)) + LOG(L_CRIT, "*** PARSE ERROR *** (%d,%d-%d): %s\n", + startline, startcolumn, column-1, s); + else + LOG(L_CRIT, "*** PARSE ERROR *** (%d,%d): %s\n", + startline, startcolumn, s); cfg_errors++; }

15 years, 9 months

git:andrei/script_vars: script parsing: fix line/column counting in strings

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/script_vars Commit: 9c674bfa6e1b60082beb57bd571995ff1cd8208b URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=9c674bf… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Fri Dec 12 12:55:02 2008 +0100 script parsing: fix line/column counting in strings - added startline which contains the starting line for a token (some tokens can span multiple lines). - string tokens are now correctly reported (startline and startcolumn always point at the beginning) --- cfg.lex | 108 ++++++++++++++++++++++++++++++++++++++++++++++---------------- 1 files changed, 80 insertions(+), 28 deletions(-) diff --git a/cfg.lex b/cfg.lex index 7578837..6e9d991 100644 --- a/cfg.lex +++ b/cfg.lex @@ -119,10 +119,15 @@ int line=1; int column=1; int startcolumn=1; + int startline=1; + static int ign_lines=0; + static int ign_columns=0; static char* addchar(struct str_buf *, char); static char* addstr(struct str_buf *, char*, int); static void count(); + static void count_more(); + static void count_ignore(); %} @@ -806,7 +811,7 @@ EAT_ABLE [\ \t\b\r] <PVARID>{ID}|'.' {yymore(); } <PVARID>{LPAREN} { state = PVAR_P_S; BEGIN(PVAR_P); p_nest=1; yymore(); } -<PVARID>. { count(); state=INITIAL_S; BEGIN(INITIAL); +<PVARID>. { yyless(0); state=INITIAL_S; BEGIN(INITIAL); return PVAR; } @@ -872,7 +877,7 @@ EAT_ABLE [\ \t\b\r] <INITIAL>{COMMA} { count(); return COMMA; } <INITIAL>{SEMICOLON} { count(); return SEMICOLON; } <INITIAL>{COLON} { count(); return COLON; } -<INITIAL>{STAR} { count(); return STAR; } +<INITIAL>{STAR} { count(); return STAR; } <INITIAL>{RPAREN} { count(); return RPAREN; } <INITIAL>{LPAREN} { count(); return LPAREN; } <INITIAL>{LBRACE} { count(); return LBRACE; } @@ -885,16 +890,19 @@ EAT_ABLE [\ \t\b\r] <INITIAL>{CR} { count();/* return CR;*/ } -<INITIAL,SELECT>{QUOTES} { count(); old_initial = YY_START; old_state = state; state=STRING_S; BEGIN(STRING1); } -<INITIAL>{TICK} { count(); old_initial = YY_START; old_state = state; state=STRING_S; BEGIN(STRING2); } +<INITIAL,SELECT>{QUOTES} { count(); old_initial = YY_START; + old_state = state; state=STRING_S; + BEGIN(STRING1); } +<INITIAL>{TICK} { count(); old_initial = YY_START; old_state = state; + state=STRING_S; BEGIN(STRING2); } -<STRING1>{QUOTES} { count(); +<STRING1>{QUOTES} { count_more(); yytext[yyleng-1]=0; yyleng--; addstr(&s_buf, yytext, yyleng); BEGIN(STR_BETWEEN); } -<STRING2>{TICK} { count(); state=old_state; BEGIN(old_initial); +<STRING2>{TICK} { count_more(); state=old_state; BEGIN(old_initial); yytext[yyleng-1]=0; yyleng--; addstr(&s_buf, yytext, yyleng); yylval.strval=s_buf.s; @@ -903,24 +911,28 @@ EAT_ABLE [\ \t\b\r] } <STRING2>.|{EAT_ABLE}|{CR} { yymore(); } -<STRING1>\\n { count(); addchar(&s_buf, '\n'); } -<STRING1>\\r { count(); addchar(&s_buf, '\r'); } -<STRING1>\\a { count(); addchar(&s_buf, '\a'); } -<STRING1>\\t { count(); addchar(&s_buf, '\t'); } -<STRING1>\\{QUOTES} { count(); addchar(&s_buf, '"'); } -<STRING1>\\\\ { count(); addchar(&s_buf, '\\'); } -<STRING1>\\x{HEX}{1,2} { count(); addchar(&s_buf, +<STRING1>\\n { count_more(); addchar(&s_buf, '\n'); } +<STRING1>\\r { count_more(); addchar(&s_buf, '\r'); } +<STRING1>\\a { count_more(); addchar(&s_buf, '\a'); } +<STRING1>\\t { count_more(); addchar(&s_buf, '\t'); } +<STRING1>\\{QUOTES} { count_more(); addchar(&s_buf, '"'); } +<STRING1>\\\\ { count_more(); addchar(&s_buf, '\\'); } +<STRING1>\\x{HEX}{1,2} { count_more(); addchar(&s_buf, (char)strtol(yytext+2, 0, 16)); } /* don't allow \[0-7]{1}, it will eat the backreferences from subst_uri if allowed (although everybody should use '' in subt_uri) */ -<STRING1>\\[0-7]{2,3} { count(); addchar(&s_buf, +<STRING1>\\[0-7]{2,3} { count_more(); addchar(&s_buf, (char)strtol(yytext+1, 0, 8)); } -<STRING1>\\{CR} { count(); } /* eat escaped CRs */ -<STRING1>.|{EAT_ABLE}|{CR} { addchar(&s_buf, *yytext); } - -<STR_BETWEEN>{EAT_ABLE}|{CR} { count(); /* eat whitespace */ } -<STR_BETWEEN>{QUOTES} { count(); state=STRING_S; BEGIN(STRING1);} -<STR_BETWEEN>. { yyless(0); +<STRING1>\\{CR} { count_more(); } /* eat escaped CRs */ +<STRING1>.|{EAT_ABLE}|{CR} { count_more(); addchar(&s_buf, *yytext); } + +<STR_BETWEEN>{EAT_ABLE}|{CR} { count_ignore(); } +<STR_BETWEEN>{QUOTES} { count_more(); state=STRING_S; + BEGIN(STRING1);} +<STR_BETWEEN>. { + yyless(0); /* reparse it */ + /* ignore the whitespace now that is + counted, return saved string value */ state=old_state; BEGIN(old_initial); yylval.strval=s_buf.s; memset(&s_buf, 0, sizeof(s_buf)); @@ -1043,26 +1055,66 @@ error: -static void count() +/** helper function for count_*(). */ +static void count_lc(int* l, int* c) { int i; - - startcolumn=column; for (i=0; i<yyleng;i++){ if (yytext[i]=='\n'){ - line++; - column=startcolumn=1; + (*l)++; + (*c)=1; }else if (yytext[i]=='\t'){ - column++; - /*column+=8 -(column%8);*/ + (*c)++; + /*(*c)+=8 -((*c)%8);*/ }else{ - column++; + (*c)++; } } } +/* helper function */ +static void count_restore_ignored() +{ + if (ign_lines) /* ignored line(s) => column has changed */ + column=ign_columns; + else + column+=ign_columns; + line+=ign_lines; + ign_lines=ign_columns=0; +} + + + +/** count/record position for stuff added to the current token. */ +static void count_more() +{ + count_restore_ignored(); + count_lc(&line, &column); +} + + + +/** count/record position for a new token. */ +static void count() +{ + count_restore_ignored(); + startline=line; + startcolumn=column; + count_more(); +} + + + +/** record discarded stuff (not contained in the token) so that + the next token position can be adjusted properly*/ +static void count_ignore() +{ + count_lc(&ign_lines, &ign_columns); +} + + /* replacement yywrap, removes libfl dependency */ int yywrap() {

15 years, 9 months

Re: [SR-Dev] [Serdev] CVS:commitlog: sip_router/modules/tm t_cancel.c t_fwd.c t_reply.c t_reply.h t_suspend.c t_suspend.h tm.c tm_load.c tm_load.h

by Andrei Pelinescu-Onciul

[crossposting since this is of general interest] On Nov 12, 2008 at 00:30, Klaus Darilion <klaus.mailinglists(a)pernau.at> wrote: > Hi Miklos! > > This sounds great. Can you make a sample function which uses the new > feature? We are thinking of doing a dns_prefetch module using this. The sip-router.cfg will look like: route{ ... dns_prefetch("uri", ROUTE_DNS_OK); # end of script } route[ROUTE_DNS_OK]{ if (dns_error){ ... } # continue normal processing # the uri was resolved and is in the dns cache ... t_relay() ... } However don't expect something quickly as everybody is quite busy and we would still need to write a dns resolver process pool (time consuming). Note that this is not the "final" async. solution since it's not transparent for the script writer (scripts would have to be written in a special way), works only with tm and it's also a little inefficient for dns usage. In the long term we will have completely transparent async. support for dns and maybe db lookups (though it's controversial if we really need it for normal db lookups). This will take much longer and will require among other things reviewing all the global variable use (most of the global variables will either need to be registered or allocated in some known special place). If Miklos doesn't beat me to it, I'll probably start working on it only after the core merging is complete. > > Can this also be used for DNS lookups and TCP/TLS connection setup? Yes for DNS (see above) and in general for any route-level async processing involving tm (e.g. lookup some part of the message in a slow DB and execute automatically another route when the DB responds). It cannot be used for TCP/TLS, but it's not needed anyway. In ser TCP connection setup and TCP send is already asynchronous, at least if you have tcp_buf_write=yes in ser.cfg (I agree it's not a very well chosen name :-)). TLS does not support it yet, so if you use TLS you should not set this option (that's why it's not yet the default). TLS support for it requires non-trivial changes in the tcp core and it will probably come after the merge (it's started already but far from finished). (BTW: most of the core new options documentation in ser can be found in NEWS) Andrei > > Further, also for Kamailio cooperation better documentation would be > needed. Thus, instead of writing long CVS commit messages I think it > would be better to write the text into the module documentation, and > then copy/paste it into the CVS commit. > > regards > Klaus > > Miklos Tirpak wrote: > > tirpi 2008/11/10 13:47:03 CET > > > > SER CVS Repository > > > > Modified files: > > modules/tm t_cancel.c t_fwd.c t_reply.c t_reply.h > > tm.c tm_load.c tm_load.h > > Added files: > > modules/tm t_suspend.c t_suspend.h > > Log: > > t_suspend() and t_continue() functions are introduced. > > > > These fuctions can be used by other modules to implement > > asynchronous actions: t_suspend() saves the transaction, returns its > > identifiers, and t_continue() continues the SIP request processing. > > (The transaction processing does not continue from the same point > > in the script, a separate route block defined by the parameter of > > t_continue() is executed instead. The reply lock is held during the > > route block execution.) FR timer is ticking while the > > transaction is suspended, and the transaction's failure route is > > executed if t_continue() is not called in time. > > > > Missing: msg lumps are saved by t_suspend() and are not updated by > > the subsequent t_relay(). This means that the modifications made > > between them are lost. > > > > Revision Changes Path > > 1.32 +7 -2 sip_router/modules/tm/t_cancel.c > > http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/modules/tm/t_cance… > > 1.107 +8 -2 sip_router/modules/tm/t_fwd.c > > http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/modules/tm/t_fwd.c… > > 1.162 +4 -4 sip_router/modules/tm/t_reply.c > > http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/modules/tm/t_reply… > > 1.31 +7 -1 sip_router/modules/tm/t_reply.h > > http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/modules/tm/t_reply… > > 1.1 +154 -0 sip_router/modules/tm/t_suspend.c (new) > > http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/modules/tm/t_suspe… > > 1.1 +42 -0 sip_router/modules/tm/t_suspend.h (new) > > http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/modules/tm/t_suspe… > > 1.177 +3 -1 sip_router/modules/tm/tm.c > > http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/modules/tm/tm.c.di… > > 1.31 +11 -1 sip_router/modules/tm/tm_load.c > > http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/modules/tm/tm_load… > > 1.31 +4 -1 sip_router/modules/tm/tm_load.h > > http://cvs.berlios.de/cgi-bin/viewcvs.cgi/ser/sip_router/modules/tm/tm_load… > > _______________________________________________ > > Serdev mailing list > > Serdev(a)lists.iptel.org > > http://lists.iptel.org/mailman/listinfo/serdev > > _______________________________________________ > Serdev mailing list > Serdev(a)lists.iptel.org > http://lists.iptel.org/mailman/listinfo/serdev

15 years, 9 months

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

sr-dev