sr-dev

sr-dev@lists.kamailio.org

44307 discussions

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

SF.net SVN: openser:[6040] branches/1.5/modules/dialog

by Timo Reimann

Revision: 6040 http://openser.svn.sourceforge.net/openser/?rev=6040&view=rev Author: timoreimann Date: 2010-08-05 16:39:48 +0000 (Thu, 05 Aug 2010) Log Message: ----------- modules/dialog: Provide new fix to prevent "unable to find dialog" WARN messages caused by accessing a dialog in the "deleted" state (often happens with simultaneous BYE requests when both UAs hang up at the same time). This commit uses a different approach where a "deleted" flag is set in get_dlg() and lookup_dlg() which callers may evaluate. Callers who only care about existing dialogs can ignore the flag by passing a NULL argument. This revision "replaces" 6027. Modified Paths: -------------- branches/1.5/modules/dialog/dialog.c branches/1.5/modules/dialog/dlg_handlers.c branches/1.5/modules/dialog/dlg_hash.c branches/1.5/modules/dialog/dlg_hash.h branches/1.5/modules/dialog/dlg_req_within.c This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

14 years, 6 months

SF.net SVN: openser:[6039] branches/1.5/modules/dialog

by Timo Reimann

Revision: 6039 http://openser.svn.sourceforge.net/openser/?rev=6039&view=rev Author: timoreimann Date: 2010-08-05 16:26:56 +0000 (Thu, 05 Aug 2010) Log Message: ----------- modules/dialog: Revert "Prevent 'unable to find dialog' WARN messages caused by accessing a dialog in the "deleted" state". The approach chosen was incomplete as it requires extending checks of return values for all calls to get_dlg() and lookup_dlg() against POINTER_CLOSED_MARKER. Otherwise, it may lead to server crashes when code mistakes POINTER_CLOSED_MARKER for an existing dialog. However, having to check against two return values requires a lot of logic changes. Therefore, a better approach will be taken in a follow-up commit. This reverts release 6027. Modified Paths: -------------- branches/1.5/modules/dialog/dlg_cb.c branches/1.5/modules/dialog/dlg_handlers.c branches/1.5/modules/dialog/dlg_hash.c branches/1.5/modules/dialog/dlg_hash.h This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

14 years, 6 months

missing callback in struct publ_info (module pua)

by nikita

Hello, I was trying to write a small module using the pua api, unfortunatly I have found that there is no callback on publish reply (struct publ_info : publrpl_cb_t* cbrpl;) unlike what is described in the doc. (http://kamailio.org/docs/modules/devel/modules_k/pua.html#id2556188). Maybe I have missed an old thread ex plaining that issue ? I have found that I can do something similar with register_puacb (modules_k/pua/send_publish.c:341) but in the doc it's said that the functio||n is for subscribe reply (it's why I was trying to add the callback in struct publ_info). If it's a bug, I have already a patch to add the publrpl_cb_t in publ_info and I guess it's working but I have tested it only with my module. Please, tell me if you want that I open a new ticket in the bug tracker about it. Thanks, -- nikita

14 years, 6 months

git:kamailio_3.0: modules_k/dialog: Remove trailing whitespace.

by Timo Reimann

Module: sip-router Branch: kamailio_3.0 Commit: fa28c630360669af64bffb4ef3a8bcc12b050bbc URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=fa28c63… Author: Timo Reimann <timo.reimann(a)1und1.de> Committer: Timo Reimann <timo.reimann(a)1und1.de> Date: Thu Aug 5 18:17:01 2010 +0200 modules_k/dialog: Remove trailing whitespace. (cherry picked from commit 3ed75d129730ffe30fb3c1d5f8fa7870c9b5516a) --- modules_k/dialog/dlg_hash.c | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) diff --git a/modules_k/dialog/dlg_hash.c b/modules_k/dialog/dlg_hash.c index 58332a6..b004cef 100644 --- a/modules_k/dialog/dlg_hash.c +++ b/modules_k/dialog/dlg_hash.c @@ -369,7 +369,7 @@ struct dlg_cell* lookup_dlg( unsigned int h_entry, unsigned int h_id, unsigned i if (del != NULL) *del = 0; - + if (h_entry>=d_table->size) goto not_found;

14 years, 6 months

git:master: modules_k/dialog: Remove trailing whitespace.

by Timo Reimann

Module: sip-router Branch: master Commit: 3ed75d129730ffe30fb3c1d5f8fa7870c9b5516a URL: http://git.sip-router.org/cgi-bin/gitweb.cgi/sip-router/?a=commit;h=3ed75d1… Author: Timo Reimann <timo.reimann(a)1und1.de> Committer: Timo Reimann <timo.reimann(a)1und1.de> Date: Thu Aug 5 18:17:01 2010 +0200 modules_k/dialog: Remove trailing whitespace. --- modules_k/dialog/dlg_hash.c | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) diff --git a/modules_k/dialog/dlg_hash.c b/modules_k/dialog/dlg_hash.c index 58332a6..b004cef 100644 --- a/modules_k/dialog/dlg_hash.c +++ b/modules_k/dialog/dlg_hash.c @@ -369,7 +369,7 @@ struct dlg_cell* lookup_dlg( unsigned int h_entry, unsigned int h_id, unsigned i if (del != NULL) *del = 0; - + if (h_entry>=d_table->size) goto not_found;

14 years, 6 months

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

sr-dev