int fixup_pvar_all(void** param, int param_no)
{
pvs_fixup_t* 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) {
PKG_MEM_ERROR;
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;
}
static int get_mac_avp_value(struct sip_msg *msg, str *value) {
str mac_avp_name_str = str_init(RO_MAC_AVP_NAME);
pv_spec_t avp_spec;
pv_value_t val;
pv_parse_spec2(&mac_avp_name_str, &avp_spec, 1);
if (pv_get_spec_value(msg, &avp_spec, &val) != 0 || val.rs.len == 0) {
value->s = "00:00:00:00:00:00";
value->len = sizeof ("00:00:00:00:00:00") - 1;
return -1;
}
*value = val.rs;
return 0;
}
/** Generic parameter fixup function.
* Creates a fparam_t structure.
* @param type contains allowed parameter types
* @param param is the parameter that will be fixed-up
*
* @return
* 0 on success,
* 1 if the param doesn't match the specified type
* <0 on failure
*/
int fix_param(int type, void** param)
{
fparam_t* p;
str name, s;
int num;
int err;
p = (fparam_t*)pkg_malloc(sizeof(fparam_t));
if (!p) {
LM_ERR("No memory left\n");
return E_OUT_OF_MEM;
}
memset(p, 0, sizeof(fparam_t));
p->orig = *param;
switch(type) {
case FPARAM_UNSPEC:
LM_ERR("Invalid type value\n");
goto error;
case FPARAM_STRING:
p->v.asciiz = *param;
/* no break */
case FPARAM_STR:
p->v.str.s = (char*)*param;
p->v.str.len = strlen(p->v.str.s);
p->fixed = &p->v;
break;
case FPARAM_INT:
s.s = (char*)*param;
s.len = strlen(s.s);
err = str2sint(&s, &num);
if (err == 0) {
p->v.i = (int)num;
} else {
/* Not a number */
pkg_free(p);
return 1;
}
p->fixed = (void*)(long)num;
break;
case FPARAM_REGEX:
if ((p->v.regex = pkg_malloc(sizeof(regex_t))) == 0) {
LM_ERR("No memory left\n");
goto error;
}
if (regcomp(p->v.regex, *param,
REG_EXTENDED|REG_ICASE|REG_NEWLINE)) {
pkg_free(p->v.regex);
p->v.regex=0;
/* not a valid regex */
goto no_match;
}
p->fixed = p->v.regex;
break;
case FPARAM_AVP:
name.s = (char*)*param;
name.len = strlen(name.s);
trim(&name);
if (!name.len || name.s[0] != '$') {
/* Not an AVP identifier */
goto no_match;
}
name.s++;
name.len--;
if (parse_avp_ident(&name, &p->v.avp) < 0) {
/* invalid avp identifier (=> no match) */
goto no_match;
}
p->fixed = &p->v;
break;
case FPARAM_SELECT:
name.s = (char*)*param;
name.len = strlen(name.s);
trim(&name);
if (!name.len || name.s[0] != '@') {
/* Not a select identifier */
goto no_match;
}
if (parse_select(&name.s, &p->v.select) < 0) {
LM_ERR("Error while parsing select identifier\n");
goto error;
}
p->fixed = &p->v;
break;
case FPARAM_SUBST:
s.s = *param;
s.len = strlen(s.s);
p->v.subst = subst_parser(&s);
if (!p->v.subst) {
LM_ERR("Error while parsing regex substitution\n");
goto error;
}
p->fixed = &p->v;
break;
case FPARAM_PVS:
name.s = (char*)*param;
name.len = strlen(name.s);
trim(&name);
if (!name.len || name.s[0] != '$'){
/* not a pvs identifier */
goto no_match;
}
p->v.pvs=pkg_malloc(sizeof(pv_spec_t));
if (p->v.pvs==0){
LM_ERR("out of memory while parsing pv_spec_t\n");
goto error;
}
if (pv_parse_spec2(&name, p->v.pvs, 1)==0){
/* not a valid pvs identifier (but it might be an avp) */
pkg_free(p->v.pvs);
p->v.pvs=0;
goto no_match;
}
p->fixed = p->v.pvs;
break;
case FPARAM_PVE:
name.s = (char*)*param;
name.len = strlen(name.s);
if (pv_parse_format(&name, &p->v.pve)<0){
LM_ERR("bad PVE format: \"%.*s\"\n", name.len, name.s);
goto error;
}
p->fixed = &p->v;
break;
}
p->type = type;
*param = (void*)p;
return 0;
no_match:
pkg_free(p);
return 1;
error:
pkg_free(p);
return E_UNSPEC;
}
