sr-dev August 2010

sr-dev@lists.kamailio.org

26 participants
346 discussions

Re: [sr-dev] pua_dialoginfo deletes AVPs?

by Jasmin Schnatterbeck

Hi Henning, because of the fact, that the problem only appears, if the pua_dialoginfo module is enabled, I think the problem is located somewhere in the code tm hooks, dialog hooks or pua/pua_dialoginfo itself... I have attached the debug output of pua_dialoginfo which shows only, if the module is enabled... may it is useful in any way... Regards Jasmin > On Friday 04 June 2010, Jasmin Schnatterbeck wrote: > > onreply_avp_mode does not seem to be available in kamailio 3.0.2 (at > > least not in the module doc) > > I think this parameter is for avps in reply_route? or does it work for > > branch_route also? > > Hi Jasmin, > > ah, sorry. Its not available or necessary anymore in 3.0. In 1.5 it also > affected the branch_route, i think, but for the newer version this behaviour > is now the default. Then in your case its probably another problem.. > > Cheers, > > Henning

14 years, 4 months

duplicate db_res_t

by Chandrakant Solanki

Hello I am using kamailio 1.5.0.2. I have developed one custom function in module, and also create one custom structure to store database recordset. What I would like to do is... 1] I have structure say struct record and it has variable struct record { int id; char name; db_res_t *res; }; 2] Execute one query and store result into "db_res" variable of db_res_t datatype; 3] Now I would like to preserve 'n in future i will use this recordset.. so how can i store this "db_res" variable into structure variable. I have tried using below syntax... struct record rec[2]; db_res = get_record( "pass_any_query" ); rec[0].res = db_res; But when I used this rec[0].res in future it gives garbage value. Any Idea...??? -- Regards, Chandrakant Solanki

14 years, 4 months

[tracker] Comment added: SDP parsing when dealing with multi-part bodies

by sip-router

THIS IS AN AUTOMATED MESSAGE, DO NOT REPLY. The following task has a new comment added: FS#73 - SDP parsing when dealing with multi-part bodies User who did this - Ovidiu Sas (osas) ---------- The nathelper module is using now the core SDP parser. Please test this on the trunk and report any issues. Regards, Ovidiu Sas ---------- More information can be found at the following URL: http://sip-router.org/tracker/index.php?do=details&task_id=73#comment106 You are receiving this message because you have requested it from the Flyspray bugtracking system. If you did not expect this message or don't want to receive mails in future, you can change your notification settings at the URL shown above.

14 years, 4 months

git:master: nathelper(k): Core SDP parser integrated into nathelper

by Ovidiu Sas

Module: sip-router Branch: master Commit: 377e5afba8907b0ea84147459c881f6e5af11b0c URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=377e5af… Author: Ovidiu Sas <osas(a)voipembedded.com> Committer: Ovidiu Sas <osas(a)voipembedded.com> Date: Thu Aug 5 18:40:53 2010 -0400 nathelper(k): Core SDP parser integrated into nathelper The nathelper (k version) is using the core SDP parser to extract the IP and port from the received message. --- modules_k/nathelper/nathelper.c | 372 ++++++++++----------------------------- 1 files changed, 96 insertions(+), 276 deletions(-) Diff: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commitdiff;h=377…

14 years, 4 months

git:andrei/rve_f_params: core: enable RVE fixup support when fixup_free is present

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/rve_f_params Commit: d002aae942d64ebff7621140f2b148401595978b URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=d002aae… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Fri Aug 6 00:22:05 2010 +0200 core: enable RVE fixup support when fixup_free is present RVEs can now be used transparently in all module functions that have registered free_fixup function or that have standard fixup functions with known corresponding free_fixups. This means all the module functions that use ser-like fparam style fixups (sr_module.h) or kamailio style fixups (mod_fix.h). E.g.: texops(k): $del="From"; remove_hf_re("^"+$del); set_body($body, $content_type); --- action.c | 56 +++++++++++++++++++++++++++++++++++++++++++------------- cfg.y | 7 ++++--- route.c | 3 ++- route_struct.h | 1 + 4 files changed, 50 insertions(+), 17 deletions(-) diff --git a/action.c b/action.c index 9c643fb..08bc712 100644 --- a/action.c +++ b/action.c @@ -133,14 +133,18 @@ struct onsend_info* p_onsend=0; /* onsend route send info */ * Assumes src is unchanged. * Side-effects: clobbers i (int). */ -#define MODF_RVE_PARAM_FREE(src, dst) \ +#define MODF_RVE_PARAM_FREE(cmd, src, dst) \ for (i=0; i < (dst)[1].u.number; i++) { \ if ((src)[i+2].type == RVE_ST && (dst)[i+2].u.data) { \ - if ((dst)[i+2].type == FPARAM_DYN_ST) {\ - /* frees also orig. dst.u.data */ \ - fparam_free_contents((dst)[i+2].u.data); \ - /* the fparam struct. (dst.u.data) is freed below */ \ + if ((dst)[i+2].type == RVE_FREE_FIXUP_ST) {\ + /* call free_fixup (which should restore the original + string) */ \ + call_fixup((cmd)->free_fixup, &(dst)[i+2].u.data, i+1); \ + } else if ((dst)[i+2].type == FPARAM_DYN_ST) {\ + /* completely frees fparam and restore original string */\ + fparam_free_restore(&(dst)[i+2].u.data); \ } \ + /* free allocated string */ \ pkg_free((dst)[i+2].u.data); \ (dst)[i+2].u.data = 0; \ } \ @@ -165,18 +169,44 @@ struct onsend_info* p_onsend=0; /* onsend route send info */ rval_destroy(rv); \ ERR("failed to convert RVE to string\n"); \ (dst)[1].u.number = i; \ - MODF_RVE_PARAM_FREE(src, dst); \ + MODF_RVE_PARAM_FREE(cmd, src, dst); \ goto error; \ } \ (dst)[i+2].type = STRING_RVE_ST; \ (dst)[i+2].u.string = s.s; \ (dst)[i+2].u.str.len = s.len; \ rval_destroy(rv); \ - if ((cmd)->fixup && \ - (cmd)->fixup_flags & FIXUP_F_FPARAM_RVE) { \ - call_fixup((cmd)->fixup, &(dst)[i+2].u.data, i+1); \ - if ((dst)[i+2].u.data != s.s) \ - (dst)[i+2].type = FPARAM_DYN_ST; \ + if ((cmd)->fixup) {\ + if ((cmd)->free_fixup) {\ + if (likely( call_fixup((cmd)->fixup, \ + &(dst)[i+2].u.data, i+1) >= 0) ) { \ + /* success => mark it for calling free fixup */ \ + if (likely((dst)[i+2].u.data != s.s)) \ + (dst)[i+2].type = RVE_FREE_FIXUP_ST; \ + } else { \ + /* error calling fixup => mark conv. parameter \ + and return error */ \ + (dst)[1].u.number = i; \ + ERR("runtime fixup failed for %s param %d\n", \ + (cmd)->name, i+1); \ + MODF_RVE_PARAM_FREE(cmd, src, dst); \ + goto error; \ + } \ + } else if ((cmd)->fixup_flags & FIXUP_F_FPARAM_RVE) { \ + if (likely( call_fixup((cmd)->fixup, \ + &(dst)[i+2].u.data, i+1) >= 0)) { \ + if ((dst)[i+2].u.data != s.s) \ + (dst)[i+2].type = FPARAM_DYN_ST; \ + } else { \ + /* error calling fixup => mark conv. parameter \ + and return error */ \ + (dst)[1].u.number = i; \ + ERR("runtime fixup failed for %s param %d\n", \ + (cmd)->name, i+1); \ + MODF_RVE_PARAM_FREE(cmd, src, dst); \ + goto error; \ + }\ + } \ } \ } else \ (dst)[i+2]=(src)[i+2]; \ @@ -238,7 +268,7 @@ struct onsend_info* p_onsend=0; /* onsend route send info */ ret=((f_type)cmd->function)((msg), __VAR_ARGS__); \ MODF_HANDLE_RETCODE(h, ret); \ /* free strings allocated by us or fixups */ \ - MODF_RVE_PARAM_FREE(src, dst); \ + MODF_RVE_PARAM_FREE(cmd, src, dst); \ } while (0) #else /* ! __SUNPRO_C (gcc, icc a.s.o) */ #define MODF_RVE_CALL(f_type, h, msg, src, dst, params...) \ @@ -248,7 +278,7 @@ struct onsend_info* p_onsend=0; /* onsend route send info */ ret=((f_type)cmd->function)((msg), ## params ); \ MODF_HANDLE_RETCODE(h, ret); \ /* free strings allocated by us or fixups */ \ - MODF_RVE_PARAM_FREE(src, dst); \ + MODF_RVE_PARAM_FREE(cmd, src, dst); \ } while (0) #endif /* __SUNPRO_C */ diff --git a/cfg.y b/cfg.y index f97c408..7627619 100644 --- a/cfg.y +++ b/cfg.y @@ -3751,9 +3751,10 @@ static int mod_f_params_pre_fixup(struct action* a) if (is_fparam_rve_fixup(cmd_exp->fixup)) /* mark known fparam rve safe fixups */ cmd_exp->fixup_flags |= FIXUP_F_FPARAM_RVE; - else if (!(cmd_exp->fixup_flags & FIXUP_F_FPARAM_RVE)) { - /* v0 or v1 functions that have fixups need constant, - string params.*/ + else if (!(cmd_exp->fixup_flags & FIXUP_F_FPARAM_RVE) && + cmd_exp->free_fixup == 0) { + /* v0 or v1 functions that have fixups and no coresp. fixup_free + functions, need constant, string params.*/ for (r=0; r < param_no; r++) { rve=params[r].u.data; if (!rve_is_constant(rve)) { diff --git a/route.c b/route.c index e603030..c05a781 100644 --- a/route.c +++ b/route.c @@ -985,7 +985,8 @@ int fix_actions(struct action* a) or RVE_ST (non-ct RVEs) */ if (rve_param_no) { /* we have to fix the type */ if (cmd->fixup && - !(cmd->fixup_flags & FIXUP_F_FPARAM_RVE)) { + !(cmd->fixup_flags & FIXUP_F_FPARAM_RVE) && + cmd->free_fixup == 0) { BUG("non-ct RVEs (%d) in module function call" "that does not support them (%s)\n", rve_param_no, cmd->name); diff --git a/route_struct.h b/route_struct.h index 178ac77..5c1d37f 100644 --- a/route_struct.h +++ b/route_struct.h @@ -128,6 +128,7 @@ enum _operand_subtype{ RETCODE_ST, CASE_ST, BLOCK_ST, JUMPTABLE_ST, CONDTABLE_ST, MATCH_CONDTABLE_ST, STRING_RVE_ST /* RVE converted to a string (fparam hack) */, + RVE_FREE_FIXUP_ST /* (str)RVE fixed up by a reversable fixup */, FPARAM_DYN_ST /* temporary only (fparam hack) */ };

14 years, 4 months

git:andrei/rve_f_params: core: functions to get a fixup corresp. fixup_free function

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/rve_f_params Commit: 0b52bcff633ea5482d6812d9f5a84faa7bbc2738 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=0b52bcf… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Aug 5 23:09:26 2010 +0200 core: functions to get a fixup corresp. fixup_free function Added functions that given a known fixup, returns its corresponding fixup_free function. The known fixups are the fparam style fixups and the kamailio style fixups (from mod_fix.h). --- mod_fix.c | 30 ++++++++++++++++++++++++++++++ mod_fix.h | 4 ++++ sr_module.c | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++-- sr_module.h | 3 +++ 4 files changed, 87 insertions(+), 2 deletions(-) diff --git a/mod_fix.c b/mod_fix.c index 0f4db9c..0182e6f 100644 --- a/mod_fix.c +++ b/mod_fix.c @@ -497,3 +497,33 @@ FIXUP_F_SPVE_T(spve_spve, 1, 2, 2, 0) FIXUP_F_SPVE_T(spve_uint, 1, 2, 1, FPARAM_INT) FIXUP_F_SPVE_T(spve_str, 1, 2, 1, FPARAM_STR) FIXUP_F_SPVE_T(spve_null, 1, 1, 1, 0) + +/** get the corresp. fixup_free* function. + * @param f -fixup function pointer. + * @return - pointer to free_fixup function if known, 0 otherwise. + */ +free_fixup_function mod_fix_get_fixup_free(fixup_function f) +{ + if (f == fixup_str_null) return fixup_free_str_null; + if (f == fixup_str_str) return fixup_free_str_str; + /* no free fixup for fixup_uint_* (they overwrite the pointer + value with a number and the original value cannot be recovered) */ + if (f == fixup_uint_null) return 0; + if (f == fixup_uint_uint) return 0; + if (f == fixup_regexp_null) return fixup_free_regexp_null; + if (f == fixup_pvar_null) return fixup_free_pvar_null; + if (f == fixup_pvar_pvar) return fixup_free_pvar_pvar; + if (f == fixup_pvar_str) return fixup_free_pvar_str; + if (f == fixup_pvar_str_str) return fixup_free_pvar_str_str; + if (f == fixup_igp_igp) return fixup_free_igp_igp; + if (f == fixup_igp_null) return fixup_free_igp_null; + if (f == fixup_igp_pvar) return fixup_free_igp_pvar; + if (f == fixup_igp_pvar_pvar) return fixup_free_igp_pvar_pvar; + if (f == fixup_spve_spve) return fixup_free_spve_spve; + if (f == fixup_spve_null) return fixup_free_spve_null; + /* no free fixup, because of the uint part (the uint cannot be freed, + see above fixup_uint_null) */ + if (f == fixup_spve_uint) return 0; + if (f == fixup_spve_str) return fixup_free_spve_str; + return 0; +} diff --git a/mod_fix.h b/mod_fix.h index bd5d8a9..ec395b4 100644 --- a/mod_fix.h +++ b/mod_fix.h @@ -125,4 +125,8 @@ int fixup_spve_uint(void** param, int param_no); int fixup_spve_str(void** param, int param_no); int fixup_free_spve_str(void** param, int param_no); + +/** get the corresp. free fixup function.*/ +free_fixup_function mod_fix_get_fixup_free(fixup_function f); + #endif diff --git a/sr_module.c b/sr_module.c index d552318..2628226 100644 --- a/sr_module.c +++ b/sr_module.c @@ -49,6 +49,7 @@ */ #include "sr_module.h" +#include "mod_fix.h" #include "dprint.h" #include "error.h" #include "mem/mem.h" @@ -1634,7 +1635,7 @@ int fixup_free_fparam_2(void** param, int param_no) /** returns true if a fixup is a fparam_t* one. - * Used to automatically detect fparam fixups that can be used with non + * Used to automatically detect "pure" fparam fixups that can be used with non * contant RVEs. * @param f - function pointer * @return 1 for fparam fixups, 0 for others. @@ -1652,7 +1653,54 @@ int is_fparam_rve_fixup(fixup_function f) f == fixup_int_2 || f == fixup_str_12 || f == fixup_str_1 || - f == fixup_str_2) + f == fixup_str_2 || + f == fixup_regex_12 || + f == fixup_regex_1 || + f == fixup_regex_2 + ) return 1; return 0; } + + + +/** returns the corresponding fixup_free* for various known fixup types. + * Used to automatically fill in free_fixup* functions. + * @param f - fixup function pointer + * @return - free fixup function pointer on success, 0 on failure (unknown + * fixup or no free fixup function). + */ +free_fixup_function get_fixup_free(fixup_function f) +{ + free_fixup_function ret; + /* "pure" fparam, all parameters */ + if (f == fixup_var_str_12 || + f == fixup_var_int_12 || + f == fixup_int_12 || + f == fixup_str_12 || + f == fixup_regex_12) + return fixup_free_fparam_all; + + /* "pure" fparam, 1st parameter */ + if (f == fixup_var_str_1 || + f == fixup_var_int_1 || + f == fixup_int_1 || + f == fixup_str_1 || + f == fixup_regex_1) + return fixup_free_fparam_1; + + /* "pure" fparam, 2nd parameters */ + if (f == fixup_var_str_2 || + f == fixup_var_int_2 || + f == fixup_int_2 || + f == fixup_str_2 || + f == fixup_regex_2) + return fixup_free_fparam_2; + + /* mod_fix.h kamailio style fixups */ + if ((ret = mod_fix_get_fixup_free(f)) != 0) + return ret; + + /* unknown */ + return 0; +} diff --git a/sr_module.h b/sr_module.h index 17606ab..7bbc19d 100644 --- a/sr_module.h +++ b/sr_module.h @@ -600,4 +600,7 @@ void fparam_free_restore(void** param); int fixup_free_fparam_all(void** param, int param_no); int fixup_free_fparam_1(void** param, int param_no); int fixup_free_fparam_2(void** param, int param_no); + +free_fixup_function get_fixup_free(fixup_function f); + #endif /* sr_module_h */

14 years, 4 months

git:andrei/rve_f_params: core: automatically fill known fixup_free functions

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/rve_f_params Commit: d709a720cdbc578eb27184061708f730d2552b6f URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=d709a72… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Aug 5 23:13:12 2010 +0200 core: automatically fill known fixup_free functions When a module is loaded, for each fixup with a missing fixup_free function fill the fixup_free function if known. This way if a module uses one of the known standard fixups, the core will fill the corresponding free fixup function even if it's missing in the original module or the module uses a ser style interface (that does not have a way to define free fixups). --- sr_module.c | 3 +++ 1 files changed, 3 insertions(+), 0 deletions(-) diff --git a/sr_module.c b/sr_module.c index 2628226..04fb080 100644 --- a/sr_module.c +++ b/sr_module.c @@ -203,6 +203,9 @@ static sr31_cmd_export_t* sr_cmd_exports_convert(unsigned ver, /* 3.1+ specific stuff */ ret[i].fixup_flags = 0; ret[i].module_exports = mod; + /* fill known free fixups */ + if (ret[i].fixup && ret[i].free_fixup == 0) + ret[i].free_fixup = get_fixup_free(ret[i].fixup); } return ret; error:

14 years, 4 months

git:andrei/rve_f_params: core: added generic fparam fixup_free functions

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/rve_f_params Commit: 6a40b4bdc0c9a481276cfdbfde3a70f833b85836 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=6a40b4b… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Aug 5 22:47:29 2010 +0200 core: added generic fparam fixup_free functions Added generic fparam fixup_free functions that can be used to clean up after a fparam fixup: void fparam_free_restore(void** param); int fixup_free_fparam_all(void** param, int param_no); int fixup_free_fparam_1(void** param, int param_no); int fixup_free_fparam_2(void** param, int param_no); They will free anything that was allocated by the fixup and restore the parameter pointer to the saved original value. --- mod_fix.c | 1 + sr_module.c | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++++--- sr_module.h | 9 ++++++++ 3 files changed, 73 insertions(+), 4 deletions(-) diff --git a/mod_fix.c b/mod_fix.c index 2e5f076..69974b0 100644 --- a/mod_fix.c +++ b/mod_fix.c @@ -34,6 +34,7 @@ #include "mod_fix.h" #include "mem/mem.h" +#include "trim.h" diff --git a/sr_module.c b/sr_module.c index b729102..d552318 100644 --- a/sr_module.c +++ b/sr_module.c @@ -1169,6 +1169,7 @@ error: /** fparam_t free function. * Frees the "content" of a fparam, but not the fparam itself. + * Note: it doesn't free fp->orig! * Assumes pkg_malloc'ed content. * @param fp - fparam to be freed * @@ -1220,10 +1221,25 @@ void fparam_free_contents(fparam_t* fp) } break; } - if (fp->orig){ - pkg_free(fp->orig); - fp->orig=0; - } +} + + + +/** generic free fixup type function for a fixed fparam. + * It will free whatever was allocated during the initial fparam fixup + * and restore the original param value. + */ +void fparam_free_restore(void** param) +{ + fparam_t *fp; + void *orig; + + fp = *param; + orig = fp->orig; + fp->orig = 0; + fparam_free_contents(fp); + pkg_free(fp); + *param = orig; } @@ -1574,6 +1590,49 @@ int get_regex_fparam(regex_t *dst, struct sip_msg* msg, fparam_t* param) +/** generic free fixup function for "pure" fparam type fixups. + * @param param - double pointer to param, as for normal fixup functions. + * @param param_no - parameter number, ignored. + * @return 0 on success (always). + */ +int fixup_free_fparam_all(void** param, int param_no) +{ + fparam_free_restore(param); + return 0; +} + + + +/** generic free fixup function for "pure" first parameter fparam type fixups. + * @param param - double pointer to param, as for normal fixup functions. + * @param param_no - parameter number: the function will work only for + * param_no == 1 (first parameter). + * @return 0 on success (always). + */ +int fixup_free_fparam_1(void** param, int param_no) +{ + if (param_no == 1) + fparam_free_restore(param); + return 0; +} + + + +/** generic free fixup function for "pure" 2nd parameter fparam type fixups. + * @param param - double pointer to param, as for normal fixup functions. + * @param param_no - parameter number: the function will work only for + * param_no == 2 (2nd parameter). + * @return 0 on success (always). + */ +int fixup_free_fparam_2(void** param, int param_no) +{ + if (param_no == 2) + fparam_free_restore(param); + return 0; +} + + + /** returns true if a fixup is a fparam_t* one. * Used to automatically detect fparam fixups that can be used with non * contant RVEs. diff --git a/sr_module.h b/sr_module.h index 8048b6c..17606ab 100644 --- a/sr_module.h +++ b/sr_module.h @@ -591,4 +591,13 @@ int get_regex_fparam(regex_t *dst, struct sip_msg* msg, fparam_t* param); int is_fparam_rve_fixup(fixup_function f); + +/** generic free fixup type function for a fixed fparam. + * It will free whatever was allocated during the initial fparam fixup + * and restore the original param value. + */ +void fparam_free_restore(void** param); +int fixup_free_fparam_all(void** param, int param_no); +int fixup_free_fparam_1(void** param, int param_no); +int fixup_free_fparam_2(void** param, int param_no); #endif /* sr_module_h */

14 years, 4 months

git:andrei/rve_f_params: core: k style fixup_free fixes

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/rve_f_params Commit: d756b6bfbaceddb6f05d038e93f49c062e1baa90 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=d756b6b… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Aug 5 22:55:18 2010 +0200 core: k style fixup_free fixes - always restore the original parameter pointer value in fixup_free function. - fixup_uint_*() re-written (don't use fparam and hence avoid a pkg_malloc()). - remove fixup_free_uint_*(): since the fixup_uint_*() functions replace the original string pointer directly with an integer, it's never possible to restore the original value => it's not possible to have a proper fixup_free_uint_*(). - fixup_regexp_null() and fixup_free_regexp_null() fixed & re-written. fixup_regexp_null() now uses a hack to save the original pointer so that fixup_free_regexp_null() can restore it (now fixup_free_regexp_null() works). - fixup_pvar_*() and fixup_free_pvar_*() fixed & re-written (similar with fixup_regexp_null()). - fixup_igp_pvar(), fixup_igp_pvar_pvar(), fixup_free_igp_pvar() and fixup_free_igp_pvar_pvar() fixed & re-written (similar with fixup_regexp_null()). - added missing fixup_free_* declarations. --- mod_fix.c | 292 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++---- mod_fix.h | 5 + 2 files changed, 277 insertions(+), 20 deletions(-) diff --git a/mod_fix.c b/mod_fix.c index 69974b0..0f4db9c 100644 --- a/mod_fix.c +++ b/mod_fix.c @@ -51,11 +51,8 @@ int fixup_regexpNL_none(void** param, int param_no); /* textops */ { \ if ((param_no > (maxp)) || (param_no < (minp))) \ return E_UNSPEC; \ - if (*param){ \ - fparam_free_contents((fparam_t*)*param); \ - pkg_free(*param); \ - *param=0; \ - } \ + if (*param) \ + fparam_free_restore(param); \ return 0; \ } @@ -150,7 +147,7 @@ int fixup_regexpNL_none(void** param, int param_no); /* textops */ int ret; \ if (param && *param){ \ p=(param_no>(no1))? *param - (long)&((fparam_t*)0)->v : *param;\ - if ((ret=fixup_free_fpt_##suffix(&p, param_no))==0) *param=0; \ + if ((ret=fixup_free_fpt_##suffix(&p, param_no))==0) *param=p; \ return ret; \ } \ return 0; \ @@ -169,24 +166,286 @@ int fixup_regexpNL_none(void** param, int param_no); /* textops */ FIXUP_F1T(str_null, 1, 1, FPARAM_STR) FIXUP_F1T(str_str, 1, 2, FPARAM_STR) +FIXUP_F1T(str_all, 1, 100, FPARAM_STR) -/* TODO: int can be converted in place, no need for pkg_malloc'ed fparam_t*/ +/* + no free fixups possible for unit_* + (they overwrite the pointer with the converted number => the original + value cannot be recovered) FIXUP_F1T(uint_null, 1, 1, FPARAM_INT) FIXUP_F1T(uint_uint, 1, 2, FPARAM_INT) +*/ + + + +int fixup_uint_uint(void** param, int param_no) +{ + str s; + unsigned int num; + + s.s = *param; + s.len = strlen(s.s); + if (likely(str2int(&s, &num) == 0)) { + *param = (void*)(long)num; + } else + /* not a number */ + return E_UNSPEC; + return 0; +} + + + +int fixup_uint_null(void** param, int param_no) +{ + if (param_no == 1) + return fixup_uint_uint(param, param_no); + return E_UNSPEC; +} + +/* fixup_regexp_null() has to be written "by hand", since + it needs to save the original pointer (the fixup users expects + a pointer to the regex in *param and hence the original value + needed on free cannot be recovered directly). FIXUP_F1T(regexp_null, 1, 1, FPARAM_REGEX) +*/ +struct regex_fixup { + regex_t regex; /* compiled regex */ + void* orig; /* original pointer */ +}; + +int fixup_regexp_null(void** param, int param_no) +{ + struct regex_fixup* re; + + if (param_no != 1) + return E_UNSPEC; + if ((re=pkg_malloc(sizeof(*re))) ==0) { + ERR("No memory left\n"); + goto error; + } + if (regcomp(&re->regex, *param, + REG_EXTENDED|REG_ICASE|REG_NEWLINE)) + goto error; + re->orig = *param; + *param = re; + return 0; +error: + if (re) + pkg_free(re); + return E_UNSPEC; +} + + +int fixup_free_regexp_null(void** param, int param_no) +{ + struct regex_fixup* re; + + if (param_no != 1) + return E_UNSPEC; + if (*param) { + re = *param; + *param = re->orig; + regfree(&re->regex); + pkg_free(re); + } + return 0; +} + +/* fixup_pvar_*() has to be written "by hand", since + it needs to save the original pointer (the fixup users expects + a pointer to the pv_spec_t in *param and hence the original value + needed on free cannot be recovered directly). FIXUP_F1T(pvar_null, 1, 1, FPARAM_PVS) FIXUP_F1T(pvar_pvar, 1, 2, FPARAM_PVS) +*/ + +struct pvs_fixup { + pv_spec_t pvs; /* parsed pv spec */ + void* orig; /* original pointer */ +}; + +int fixup_pvar_all(void** param, int param_no) +{ + struct pvs_fixup* pvs_f; + str name; + + pvs_f = 0; + name.s = *param; + name.len = strlen(name.s); + trim(&name); + if (name.len == 0 || name.s[0] != '$') + /* not a pvs id */ + goto error; + if ((pvs_f=pkg_malloc(sizeof(*pvs_f))) == 0) { + ERR("No memory left\n"); + goto error; + } + if (pv_parse_spec2(&name, &pvs_f->pvs, 1) == 0) + /* not a valid pvs identifier */ + goto error; + pvs_f->orig = *param; + *param = pvs_f; + return 0; +error: + if (pvs_f) + pkg_free(pvs_f); + return E_UNSPEC; +} + + + +int fixup_free_pvar_all(void** param, int param_no) +{ + struct pvs_fixup* pvs_f; + + if (*param) { + pvs_f = *param; + *param = pvs_f->orig; + pv_spec_free_contents(&pvs_f->pvs); + pkg_free(pvs_f); + } + return 0; +} + + + +int fixup_pvar_pvar(void** param, int param_no) +{ + if (param_no > 2) + return E_UNSPEC; + return fixup_free_pvar_all(param, param_no); +} + + + +int fixup_free_pvar_pvar(void** param, int param_no) +{ + if (param_no > 2) + return E_UNSPEC; + return fixup_free_pvar_all(param, param_no); +} + + + +int fixup_pvar_null(void** param, int param_no) +{ + if (param_no != 1) + return E_UNSPEC; + return fixup_pvar_all(param, param_no); +} + + +int fixup_free_pvar_null(void** param, int param_no) +{ + if (param_no != 1) + return E_UNSPEC; + return fixup_free_pvar_all(param, param_no); +} + +/* must be written "by hand", see above (fixup_pvar_pvar). FIXUP_F2T(pvar_str, 1, 2, 1, FPARAM_PVS, FPARAM_STR) FIXUP_F2T(pvar_str_str, 1, 3, 1, FPARAM_PVS, FPARAM_STR) +*/ + +int fixup_pvar_str(void** param, int param_no) +{ + if (param_no == 1) + return fixup_pvar_all(param, param_no); + else if (param_no == 2) + return fixup_str_str(param, param_no); + return E_UNSPEC; +} + + + +int fixup_free_pvar_str(void** param, int param_no) +{ + if (param_no == 1) + return fixup_free_pvar_all(param, param_no); + else if (param_no == 2) + return fixup_free_str_str(param, param_no); + return E_UNSPEC; +} + + + +int fixup_pvar_str_str(void** param, int param_no) +{ + if (param_no == 1) + return fixup_pvar_all(param, param_no); + else if (param_no == 2 || param_no == 3) + return fixup_str_all(param, param_no); + return E_UNSPEC; +} + + + +int fixup_free_pvar_str_str(void** param, int param_no) +{ + if (param_no == 1) + return fixup_free_pvar_all(param, param_no); + else if (param_no == 2 || param_no == 3) + return fixup_free_str_all(param, param_no); + return E_UNSPEC; +} + + FIXUP_F2FP(igp_null, 1, 1, 1, FPARAM_INT|FPARAM_PVS, 0) FIXUP_F2FP(igp_igp, 1, 2, 2, FPARAM_INT|FPARAM_PVS, 0) -FIXUP_F2FP(igp_pvar, 1, 2, 1, FPARAM_INT|FPARAM_PVS, FPARAM_PVS) +/* must be declared by hand, because of the pvar special handling + (see above) +FIXUP_F2FP(igp_pvar, 1, 2, 1, FPARAM_INT|FPARAM_PVS, FPARAM_PVS) FIXUP_F2FP_T(igp_pvar_pvar, 1, 3, 1, FPARAM_INT|FPARAM_PVS, FPARAM_PVS) +*/ + +int fixup_igp_pvar(void** param, int param_no) +{ + if (param_no == 1) + return fixup_igp_null(param, param_no); + else if (param_no == 2) + return fixup_pvar_all(param, param_no); + return E_UNSPEC; +} + + + +int fixup_free_igp_pvar(void** param, int param_no) +{ + if (param_no == 1) + return fixup_free_igp_null(param, param_no); + else if (param_no == 2) + return fixup_free_pvar_all(param, param_no); + return E_UNSPEC; +} + + + +int fixup_igp_pvar_pvar(void** param, int param_no) +{ + if (param_no == 1) + return fixup_igp_null(param, param_no); + else if (param_no == 2 || param_no == 3) + return fixup_pvar_all(param, param_no); + return E_UNSPEC; +} + + + +int fixup_free_igp_pvar_pvar(void** param, int param_no) +{ + if (param_no == 1) + return fixup_free_igp_null(param, param_no); + else if (param_no == 2 || param_no == 3) + return fixup_free_pvar_all(param, param_no); + return E_UNSPEC; +} + + /** macro for declaring a spve fixup and the corresponding free_fixup * for a function expecting first no1 params as fparam converted spve @@ -203,21 +462,16 @@ FIXUP_F2FP_T(igp_pvar_pvar, 1, 3, 1, FPARAM_INT|FPARAM_PVS, FPARAM_PVS) int fixup_##suffix (void** param, int param_no) \ { \ int ret; \ - char * bkp; \ fparam_t* fp; \ if (param_no<=(no1)){ \ if ((ret=fix_param_types(FPARAM_PVE, param))<0){ \ - ERR("Cannot convert function parameter %d to" #type2 "\n", \ + ERR("Cannot convert function parameter %d to spve \n", \ param_no);\ return E_UNSPEC; \ } else{ \ fp=(fparam_t*)*param; \ if ((ret==0) && (fp->v.pve->spec.getf==0)){ \ - bkp=fp->orig; \ - fp->orig=0; /* make sure orig string is not freed */ \ - fparam_free_contents(fp); \ - pkg_free(fp); \ - *param=bkp; \ + fparam_free_restore(param); \ return fix_param_types(FPARAM_STR, param); \ } else if (ret==1) \ return fix_param_types(FPARAM_STR, param); \ @@ -229,11 +483,9 @@ FIXUP_F2FP_T(igp_pvar_pvar, 1, 3, 1, FPARAM_INT|FPARAM_PVS, FPARAM_PVS) int fixup_free_##suffix (void** param, int param_no) \ { \ if (param && *param){ \ - if (param_no<=(no1)){ \ - fparam_free_contents((fparam_t*)*param); \ - pkg_free(*param); \ - *param=0; \ - } else \ + if (param_no<=(no1)) \ + fparam_free_restore(param); \ + else \ return fixup_free_spvet_##suffix(param, param_no); \ } \ return 0; \ diff --git a/mod_fix.h b/mod_fix.h index 37bccb6..bd5d8a9 100644 --- a/mod_fix.h +++ b/mod_fix.h @@ -106,7 +106,9 @@ int fixup_pvar_str_str(void** param, int param_no); int fixup_free_pvar_str_str(void** param, int param_no); int fixup_igp_igp(void** param, int param_no); +int fixup_free_igp_igp(void** param, int param_no); int fixup_igp_null(void** param, int param_no); +int fixup_free_igp_null(void** param, int param_no); int fixup_get_ivalue(struct sip_msg* msg, gparam_p gp, int *val); int fixup_igp_pvar(void** param, int param_no); @@ -116,8 +118,11 @@ int fixup_igp_pvar_pvar(void** param, int param_no); int fixup_free_igp_pvar_pvar(void** param, int param_no); int fixup_spve_spve(void** param, int param_no); +int fixup_free_spve_spve(void** param, int param_no); int fixup_spve_null(void** param, int param_no); +int fixup_free_spve_null(void** param, int param_no); int fixup_spve_uint(void** param, int param_no); int fixup_spve_str(void** param, int param_no); +int fixup_free_spve_str(void** param, int param_no); #endif

14 years, 4 months

git:andrei/rve_f_params: core: pvapi: added pv_spec_free_contents()

by Andrei Pelinescu-Onciul

Module: sip-router Branch: andrei/rve_f_params Commit: b4f455f834e621c58c0750660b9e63ccbb01f695 URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=b4f455f… Author: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Committer: Andrei Pelinescu-Onciul <andrei(a)iptel.org> Date: Thu Aug 5 22:38:24 2010 +0200 core: pvapi: added pv_spec_free_contents() Added pv_spec_free_contents() that behaves like pv_spec_free(), but frees only the contents of the pv_spec and not the pv_spec itself (good for cleaning up pv_specs that are part of other structures). --- pvapi.c | 16 +++++++++++++--- pvar.h | 1 + 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/pvapi.c b/pvapi.c index 72024cd..7610534 100644 --- a/pvapi.c +++ b/pvapi.c @@ -1075,15 +1075,25 @@ error: return NULL; } + + +/** frees only the contests of a pv_spec_t. */ +void pv_spec_free_contents(pv_spec_t *spec) +{ + /* TODO: free name if it is PV */ + if(spec->trans) + tr_free((trans_t*)spec->trans); +} + + + /** * */ void pv_spec_free(pv_spec_t *spec) { if(spec==0) return; - /* TODO: free name if it is PV */ - if(spec->trans) - tr_free((trans_t*)spec->trans); + pv_spec_free_contents(spec); pkg_free(spec); } diff --git a/pvar.h b/pvar.h index 19b9310..b1a5cfa 100644 --- a/pvar.h +++ b/pvar.h @@ -175,6 +175,7 @@ int pv_printf(struct sip_msg* msg, pv_elem_p list, char *buf, int *len); int pv_elem_free_all(pv_elem_p log); void pv_value_destroy(pv_value_t *val); void pv_spec_free(pv_spec_t *spec); +void pv_spec_free_contents(pv_spec_t* spec); int pv_spec_dbg(pv_spec_p sp); int pv_get_spec_index(struct sip_msg* msg, pv_param_p ip, int *idx, int *flags); int pv_get_avp_name(struct sip_msg* msg, pv_param_p ip, int_str *avp_name,

14 years, 4 months

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

sr-dev August 2010