/*
* Convert the char* parameters
*/
static int challenge_fixup_async(void** param, int param_no) {
if (strlen((char*) *param) <= 0) {
LM_ERR("empty parameter %d not allowed\n", param_no);
return -1;
}
if (param_no == 1) { //route name - static or dynamic string (config vars)
if (fixup_spve_null(param, param_no) < 0)
return -1;
return 0;
} else if (param_no == 2) {
if (fixup_var_str_12(param, 1) == -1) {
LM_ERR("Error doing fixup on challenge");
return -1;
}
} else if (param_no == 3) /* algorithm */ {
if (fixup_var_str_12(param, 1) == -1) {
LM_ERR("Error doing fixup on challenge");
return -1;
}
}
return 0;
}
/*
* Convert the char* parameters
*/
static int auth_fixup(void** param, int param_no)
{
db1_con_t* dbh = NULL;
str name;
if(strlen((char*)*param)<=0) {
LM_ERR("empty parameter %d not allowed\n", param_no);
return -1;
}
if (param_no == 1 || param_no == 3) {
return fixup_var_str_12(param, 1);
} else if (param_no == 2) {
name.s = (char*)*param;
name.len = strlen(name.s);
dbh = auth_dbf.init(&db_url);
if (!dbh) {
LM_ERR("unable to open database connection\n");
return -1;
}
if(version_table_check!=0
&& db_check_table_version(&auth_dbf, dbh, &name,
TABLE_VERSION) < 0) {
LM_ERR("error during table version check.\n");
auth_dbf.close(dbh);
return -1;
}
auth_dbf.close(dbh);
}
return 0;
}
/*
* Fix tel2sip function params: uri and hostpart pvars and
* result writable pvar.
*/
static int fixup_tel2sip(void** param, int param_no)
{
if ((param_no == 1) || (param_no == 2)) {
if (fixup_var_str_12(param, 1) < 0) {
LM_ERR("failed to fixup uri or hostpart pvar\n");
return -1;
}
return 0;
}
if (param_no == 3) {
if (fixup_pvar_null(param, 1) != 0) {
LM_ERR("failed to fixup result pvar\n");
return -1;
}
if (((pv_spec_t *)(*param))->setf == NULL) {
LM_ERR("result pvar is not writeble\n");
return -1;
}
return 0;
}
LM_ERR("invalid parameter number <%d>\n", param_no);
return -1;
}
static int fixup_auth_get_www_authenticate(void **param, int param_no)
{
if(strlen((char*)*param)<=0) {
LM_ERR("empty parameter %d not allowed\n", param_no);
return -1;
}
switch(param_no) {
case 1:
return fixup_var_str_12(param, 1);
case 2:
return fixup_var_int_12(param, 1);
case 3:
if (fixup_pvar_null(param, 1) != 0) {
LM_ERR("failed to fixup result pvar\n");
return -1;
}
if (((pv_spec_t *)(*param))->setf == NULL) {
LM_ERR("result pvar is not writeble\n");
return -1;
}
return 0;
}
return 0;
}
/*
* Convert cfg parameters to run-time structures
*/
static int auth_check_fixup(void** param, int param_no)
{
if(strlen((char*)*param)<=0) {
LM_ERR("empty parameter %d not allowed\n", param_no);
return -1;
}
if (param_no == 1) {
return fixup_var_str_12(param, 1);
}
if (param_no == 2) {
return fixup_var_str_12(param, 2);
}
if (param_no == 3) {
return fixup_igp_null(param, 1);
}
return 0;
}
static int set_iattr_fixup(void** param, int param_no)
{
if (param_no == 1) {
return fixup_var_str_12(param, param_no);
} else {
return fixup_var_int_12(param, param_no);
}
}
static int fixup_str_1_attr_2(void** param, int param_no)
{
if (param_no == 1) {
return fixup_var_str_12(param, 1);
} else if (param_no == 2) {
return avpid_fixup(param, 1);
}
return 0;
}
/*
* Convert char* parameter to udomain_t* pointer
*/
static int domain2_fixup(void** param, int param_no)
{
if (param_no == 1) {
return domain_fixup(param, param_no);
} else {
return fixup_var_str_12(param, 2);
}
return 0;
}
static int fixup_http_async_post(void** param, int param_no)
{
if (param_no == 1 || param_no == 2) {
return fixup_spve_null(param, 1);
}
if (param_no == 3) {
return fixup_var_str_12(param, param_no);
}
LM_ERR("invalid parameter number <%d>\n", param_no);
return -1;
}
int get_credentials(struct sip_msg* msg, select_t* s, struct hdr_field** hdr)
{
int ret;
str realm;
hdr_types_t hdr_type;
*hdr = NULL;
if (!msg) {
/* fix-up call check domain for fparam conversion */
void * ptr;
char chr;
ptr=(void *)(s->params[1].v.s.s);
chr=s->params[1].v.s.s[s->params[1].v.s.len];
s->params[1].v.s.s[s->params[1].v.s.len]=0;
ret=fixup_var_str_12(&ptr,0);
if (ret>=0) {
s->params[1].v.s.s[s->params[1].v.s.len]=chr;
s->params[1].v.p=ptr;
s->params[1].type=SEL_PARAM_PTR;
}
return ret;
}
/* Try to find credentials with corresponding realm
* in the message, parse them and return pointer to
* parsed structure
*/
if (s->params[1].type==SEL_PARAM_PTR) {
if (get_str_fparam(&realm, msg, s->params[1].v.p)<0)
return -1;
} else {
realm = s->params[1].v.s;
}
switch (s->params[0].v.i) {
case SEL_AUTH_WWW:
hdr_type = HDR_AUTHORIZATION_T;
break;
case SEL_AUTH_PROXY:
hdr_type = HDR_PROXYAUTH_T;
break;
default:
BUG("Unexpected parameter value \"%d\"\n", s->params[0].v.i);
return -1;
}
ret = find_credentials(msg, &realm, hdr_type, hdr);
return ret;
}
static int fixup_t_reply(void** param, int param_no)
{
int ret;
if (param_no == 1) {
ret = fix_param(FPARAM_AVP, param);
if (ret <= 0) return ret;
return fix_param(FPARAM_INT, param);
} else if (param_no == 2) {
return fixup_var_str_12(param, 2);
}
return 0;
}
static int fixup_ip_is_trusted(void** param, int param_no) {
int ret = E_CFG;
struct ip_set_param *p;
str s;
if (param_no == 1) {
p = pkg_malloc(sizeof(*p));
if (!p) return E_OUT_OF_MEM;
memset(p, 0, sizeof(*p));
s.s = *param;
s.len = strlen(s.s);
if (is_ip_set_name(&s)) {
p->u.global.ip_set = ip_set_list_find_by_name(s);
if (!p->u.global.ip_set) {
ERR(MODULE_NAME": fixup_ip_is_trusted: ip set '%.*s' is not declared\n", s.len, s.s);
goto err;
}
p->kind = IP_SET_PARAM_KIND_GLOBAL;
} else {
ret = fixup_var_str_12(param, param_no);
if (ret < 0) goto err;
ip_set_init(&p->u.local.ip_set, 0);
p->u.local.fparam = *param;
*param = p;
p->kind = IP_SET_PARAM_KIND_LOCAL;
}
}
else {
return fixup_var_str_12(param, param_no);
}
return E_OK;
err:
pkg_free(p);
return ret;
}
/**
* @brief fixup function for {www,proxy}_challenge
*/
static int fixup_auth_challenge(void **param, int param_no)
{
if(strlen((char*)*param)<=0) {
LM_ERR("empty parameter %d not allowed\n", param_no);
return -1;
}
switch(param_no) {
case 1:
return fixup_var_str_12(param, 1);
case 2:
return fixup_var_int_12(param, 1);
}
return 0;
}
/*
* Convert the char* parameters
*/
static int auth_fixup(void** param, int param_no) {
if (strlen((char*) *param) <= 0) {
LM_ERR("empty parameter %d not allowed\n", param_no);
return -1;
}
if (param_no == 1) {
if (fixup_var_str_12(param, 1) == -1) {
LM_ERR("Erroring doing fixup on auth");
return -1;
}
}
return 0;
}
static int lookup_domain_fixup(void** param, int param_no)
{
unsigned long flags;
char* s;
if (param_no == 1) {
/* Determine the track and class of attributes to be loaded */
s = (char*)*param;
flags = 0;
if (*s != '$' || (strlen(s) != 3)) {
ERR("Invalid parameter value, $xy expected\n");
return -1;
}
switch((s[1] << 8) + s[2]) {
case 0x4644: /* $fd */
case 0x6664:
case 0x4664:
case 0x6644:
flags = AVP_TRACK_FROM | AVP_CLASS_DOMAIN;
break;
case 0x5444: /* $td */
case 0x7464:
case 0x5464:
case 0x7444:
flags = AVP_TRACK_TO | AVP_CLASS_DOMAIN;
break;
default:
ERR("Invalid parameter value: '%s'\n", s);
return -1;
}
pkg_free(*param);
*param = (void*)flags;
} else if (param_no == 2) {
return fixup_var_str_12(param, 2);
}
return 0;
}
static int ro_fixup(void **param, int param_no) {
str s;
unsigned int num;
if ( (param_no > 0 && param_no <= 4) || (param_no == 6) ) {
return fixup_var_str_12(param, param_no);
} else if (param_no == 5) {
/*convert to int */
s.s = (char*)*param;
s.len = strlen(s.s);
if (str2int(&s, &num)==0) {
pkg_free(*param);
*param = (void*)(unsigned long)num;
return 0;
}
LM_ERR("Bad reservation units: <%s>n", (char*)(*param));
return E_CFG;
}
return 0;
}
/* Same as fixup_var_str_12 but applies to the 2nd parameter only */
int fixup_var_str_2(void** param, int param_no)
{
if (param_no == 2) return fixup_var_str_12(param, param_no);
else return 0;
}
static int attrs_fixup(void** param, int param_no)
{
unsigned long flags;
char* s;
if (param_no == 1) {
/* Determine the track and class of attributes to be loaded */
s = (char*)*param;
flags = 0;
if (*s != '$' || (strlen(s) != 3)) {
ERR("Invalid parameter value, $xy expected\n");
return -1;
}
switch((s[1] << 8) + s[2]) {
case 0x4655: /* $fu */
case 0x6675:
case 0x4675:
case 0x6655:
flags = AVP_TRACK_FROM | AVP_CLASS_USER;
break;
case 0x4652: /* $fr */
case 0x6672:
case 0x4672:
case 0x6652:
flags = AVP_TRACK_FROM | AVP_CLASS_URI;
break;
case 0x5455: /* $tu */
case 0x7475:
case 0x5475:
case 0x7455:
flags = AVP_TRACK_TO | AVP_CLASS_USER;
break;
case 0x5452: /* $tr */
case 0x7472:
case 0x5472:
case 0x7452:
flags = AVP_TRACK_TO | AVP_CLASS_URI;
break;
default:
ERR("Invalid parameter value: '%s'\n", s);
return -1;
}
if ((flags & AVP_CLASS_URI) && !dm_get_did) {
dm_get_did = (domain_get_did_t)find_export("get_did", 0, 0);
if (!dm_get_did) {
ERR("Domain module required but not found\n");
return -1;
}
}
pkg_free(*param);
*param = (void*)flags;
} else if (param_no == 2) {
return fixup_var_str_12(param, 2);
}
return 0;
}
