sr-dev December 2008

sr-dev@lists.kamailio.org

11 participants
70 discussions

by Daniel-Constantin Mierla

Hello, I have uploaded xlog and (stripped) pv Kamailio/Openser modules to sip-router.org site at: http://sip-router.org/pub/tmp/miconda/ If you are willing to test them, then just get the branch "master" from git and merge with "daniel/pv". Details about GIT repository: http://sip-router.org/2008/11/18/git-repository-online/ The pv module does not include yet the pseudo-variables and transformations dependent of K/O extensions (e.g., branch, script flags, ...). Probably one important to decide upon is the AVP (to start a new discussion about it separately). The ones missing now will be gradually activated as dependent code is sorted out. Testing and feedback is welcome. Andrei is doing heavy work to improve the config script interpreter for string and arithmetic operations, you can track the commits at: http://lists.sip-router.org/pipermail/sr-dev/ Once work is finished and the developers' branches are merged, we can mark an important milestone - K/O pseudo-variables working in sip-router config file, opening full functionality for large set of K/O modules and clean compatibility of config files for many typical deployments. SIP-Router is able to load now both types of modules: ser and k/o. DB APIs from both projects were tested as library, from K/O point of view mi and statistics API are the extensions yet to be made libraries for sip-router. Cheers, Daniel -- Daniel-Constantin Mierla http://www.asipto.com

15 years, 11 months

git:daniel/pv: fix add/lookup pv name

by Daniel-Constantin Mierla

Module: sip-router Branch: daniel/pv Commit: 41c098d017d823bcff70872b7f185faee893b745 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=41c098d… Author: Daniel-Constantin Mierla <miconda(a)gmail.com> Committer: Daniel-Constantin Mierla <miconda(a)gmail.com> Date: Tue Dec 16 13:11:47 2008 +0200 fix add/lookup pv name --- pvapi.c | 7 +------ 1 files changed, 1 insertions(+), 6 deletions(-) diff --git a/pvapi.c b/pvapi.c index 9bb1de4..e93b459 100644 --- a/pvapi.c +++ b/pvapi.c @@ -120,13 +120,10 @@ int pv_table_add(pv_export_t *e) { if(pvi->pvid > pvid) break; - if(pvi->pve.name.len > in->len) - break; if(pvi->pve.name.len==in->len) { found = strncmp(pvi->pve.name.s, in->s, in->len); - if(found>0) - break; + if(found==0) { LM_ERR("pvar [%.*s] already exists\n", in->len, in->s); @@ -334,8 +331,6 @@ pv_export_t* pv_lookup_spec_name(str *pvname, pv_spec_p e) { if(pvi->pvid > pvid) break; - if(pvi->pve.name.len > pvname->len) - break; if(pvi->pvid==pvid && pvi->pve.name.len==pvname->len && memcmp(pvi->pve.name.s, pvname->s, pvname->len)==0)

15 years, 11 months

git:andrei/script_vars: script engine: pvar & avp fixes

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/script_vars Commit: a4ade2b9635011c0b66e1c2e96f77271b59551d8 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=a4ade2b… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Tue Dec 16 12:06:23 2008 +0100 script engine: pvar & avp fixes - fix avp type flags in assignments (not always set/reset) - always look first for the integer value of a pvar (since and int pvar can also have a str value) - don't destroy the pvar values before using them (typo) --- lvalue.c | 44 +++++++++++++++++++++++++------------------- route.c | 2 +- rvalue.c | 2 +- 3 files changed, 27 insertions(+), 21 deletions(-) diff --git a/lvalue.c b/lvalue.c index e5f1afd..77a9a86 100644 --- a/lvalue.c +++ b/lvalue.c @@ -69,7 +69,7 @@ inline static int lval_avp_assign(struct run_act_ctx* h, struct sip_msg* msg, goto error; case RV_INT: value.n=rv->v.l; - flags=avp->type; + flags=avp->type & ~AVP_VAL_STR; ret=!(!value.n); break; case RV_STR: @@ -78,7 +78,7 @@ inline static int lval_avp_assign(struct run_act_ctx* h, struct sip_msg* msg, ret=(value.s.len>0); break; case RV_ACTION_ST: - flags=avp->type; + flags=avp->type & ~AVP_VAL_STR; if (rv->v.action) value.n=run_actions(h, rv->v.action, msg); else @@ -93,7 +93,7 @@ inline static int lval_avp_assign(struct run_act_ctx* h, struct sip_msg* msg, WARN("error in expression\n"); value.n=0; /* expr. is treated as false */ } - flags=avp->type; + flags=avp->type & ~AVP_VAL_STR; ret=value.n; break; case RV_SEL: @@ -107,7 +107,7 @@ inline static int lval_avp_assign(struct run_act_ctx* h, struct sip_msg* msg, value.s.len=0; } } - flags=avp->type; + flags=avp->type|AVP_VAL_STR; ret=(value.s.len>0); break; case RV_AVP: @@ -116,10 +116,11 @@ inline static int lval_avp_assign(struct run_act_ctx* h, struct sip_msg* msg, r_avp = search_first_avp(rv->v.avps.type, rv->v.avps.name, &value, &st); while(r_avp){ - /* We take only the type and name from the source avp - * and reset the class and track flags */ - flags=(avp->type & ~AVP_INDEX_ALL) | - (r_avp->flags & ~(AVP_CLASS_ALL|AVP_TRACK_ALL)); + /* We take only the val type from the source avp + * and reset the class, track flags and name type */ + flags=(avp->type & ~(AVP_INDEX_ALL|AVP_VAL_STR)) | + (r_avp->flags & ~(AVP_CLASS_ALL|AVP_TRACK_ALL| + AVP_NAME_STR|AVP_NAME_RE)); if (add_avp_before(avp_mark, flags, avp->name, value)<0){ ERR("failed to assign avp\n"); ret=-1; @@ -139,8 +140,11 @@ inline static int lval_avp_assign(struct run_act_ctx* h, struct sip_msg* msg, r_avp = search_avp_by_index(rv->v.avps.type, rv->v.avps.name, &value, rv->v.avps.index); if (likely(r_avp)){ - flags=avp->type | (r_avp->flags & - ~(AVP_CLASS_ALL|AVP_TRACK_ALL)); + /* take only the val type from the source avp + * and reset the class, track flags and name type */ + flags=(avp->type & ~AVP_VAL_STR) | (r_avp->flags & + ~(AVP_CLASS_ALL|AVP_TRACK_ALL|AVP_NAME_STR| + AVP_NAME_RE)); ret=1; }else{ ret=-1; @@ -149,27 +153,30 @@ inline static int lval_avp_assign(struct run_act_ctx* h, struct sip_msg* msg, } break; case RV_PVAR: - flags=avp->type; memset(&pval, 0, sizeof(pval)); if (likely(pv_get_spec_value(msg, &rv->v.pvs, &pval)==0)){ destroy_pval=1; - if (pval.flags & PV_VAL_STR){ - value.s=pval.rs; - ret=(value.s.len>0); - }else if (pval.flags & PV_TYPE_INT){ + if (pval.flags & PV_TYPE_INT){ value.n=pval.ri; ret=value.n; + flags=avp->type & ~AVP_VAL_STR; + }else if (pval.flags & PV_VAL_STR){ + value.s=pval.rs; + ret=(value.s.len>0); + flags=avp->type | AVP_VAL_STR; }else if (pval.flags==PV_VAL_NONE || (pval.flags & (PV_VAL_NULL|PV_VAL_EMPTY))){ value.s.s=""; value.s.len=0; ret=0; + flags=avp->type | AVP_VAL_STR; } }else{ /* non existing pvar */ value.s.s=""; value.s.len=0; ret=0; + flags=avp->type | AVP_VAL_STR; } break; } @@ -286,13 +293,12 @@ inline static int lval_pvar_assign(struct run_act_ctx* h, struct sip_msg* msg, } break; case RV_PVAR: - memset(&pval, 0, sizeof(pval)); if (likely(pv_get_spec_value(msg, &rv->v.pvs, &pval)==0)){ destroy_pval=1; - if (pval.flags & PV_VAL_STR){ - ret=(pval.rs.len>0); - }else if (pval.flags & PV_TYPE_INT){ + if (pval.flags & PV_TYPE_INT){ ret=!(!pval.ri); + }else if (pval.flags & PV_VAL_STR){ + ret=(pval.rs.len>0); }else{ ERR("no value in pvar assignment rval\n"); ret=-1; diff --git a/route.c b/route.c index 4164284..ad85c00 100644 --- a/route.c +++ b/route.c @@ -841,8 +841,8 @@ inline static int comp_num(int op, long left, int rtype, union exp_op* r, return (op == DIFF_OP); /* error, not found => false */ } if (likely(pval.flags & (PV_TYPE_INT|PV_VAL_INT))){ - pv_value_destroy(&pval); right=pval.ri; + pv_value_destroy(&pval); }else{ pv_value_destroy(&pval); return (op == DIFF_OP); /* not found or invalid type */ diff --git a/rvalue.c b/rvalue.c index 6f9b118..063be00 100644 --- a/rvalue.c +++ b/rvalue.c @@ -661,8 +661,8 @@ int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, memset(&pval, 0, sizeof(pval)); if (likely(pv_get_spec_value(msg, &rv->v.pvs, &pval)==0)){ if (likely(pval.flags & PV_VAL_INT)){ - pv_value_destroy(&pval); *i=pval.ri; + pv_value_destroy(&pval); }else if (likely(pval.flags & PV_VAL_STR)){ pv_value_destroy(&pval); goto rv_str;

15 years, 11 months

git:andrei/script_vars: script: fix pvar parsing

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/script_vars Commit: 1c67272d35800a32ef3877ce87799c318dca8d52 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=1c67272… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Tue Dec 16 12:03:44 2008 +0100 script: fix pvar parsing - fix parsing for pvars with multiple '(' --- cfg.lex | 1 + 1 files changed, 1 insertions(+), 0 deletions(-) diff --git a/cfg.lex b/cfg.lex index 6e9d991..fc9eecb 100644 --- a/cfg.lex +++ b/cfg.lex @@ -806,6 +806,7 @@ EAT_ABLE [\ \t\b\r] } yymore(); } +<PVAR_P>{LPAREN} { p_nest++; yymore(); } <PVAR_P>. { yymore(); } <PVARID>{ID}|'.' {yymore(); }

15 years, 11 months

avp script flags

by Daniel-Constantin Mierla

Hello, while adapting the PV API, I got into the AVP script flags? Is anyone still using them? If yes, for what purpose, maybe we can figure out a nicer way and drop these flags. We have to find the solution to make AVPs from kamailio/openser and ser compatible in the new sip-router.org project. Just for those not being sure what I am talking about, avp names can have flags after the name type specifier, like: $avp(i3:23) - meaning that flags 1 and 2 (bitmask ...0011) are set for that avp. As I haven't seen any related discussions for quite some time, the functionality might not be updated all over the code. Cheers, Daniel -- Daniel-Constantin Mierla http://www.asipto.com

15 years, 11 months

operators and variables

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

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

sr-dev December 2008