int lookup_path_to_contact(struct sip_msg* _m, char* contact_uri) {
ucontact_t* contact;
str s_contact_uri;
str path_dst;
get_act_time();
if (get_str_fparam(&s_contact_uri, _m, (fparam_t*) contact_uri) < 0) {
LM_ERR("failed to get RURI\n");
return -1;
}
LM_DBG("Looking up contact [%.*s]\n", s_contact_uri.len, s_contact_uri.s);
if (ul.get_ucontact(NULL, &s_contact_uri, 0, 0, 0, &contact) == 0) { //get_contact returns with lock
if (!VALID_CONTACT(contact, act_time)) {
LM_DBG("Contact is not valid...ignoring\n");
ul.release_ucontact(contact);
} else {
LM_DBG("CONTACT FOUND and path is [%.*s]\n", contact->path.len, contact->path.s);
if (get_path_dst_uri(&contact->path, &path_dst) < 0) {
LM_ERR("failed to get dst_uri for Path\n");
ul.release_ucontact(contact);
return -1;
}
if (set_path_vector(_m, &contact->path) < 0) {
LM_ERR("failed to set path vector\n");
ul.release_ucontact(contact);
return -1;
}
if (set_dst_uri(_m, &path_dst) < 0) {
LM_ERR("failed to set dst_uri of Path\n");
ul.release_ucontact(contact);
return -1;
}
ul.release_ucontact(contact);
return 1;
}
}
LM_DBG("no contact found for [%.*s]\n", s_contact_uri.len, s_contact_uri.s);
return -1;
}
/*! \brief
* Lookup contact in the database and rewrite Request-URI
* \return: -1 : not found
* -2 : found but method not allowed
* -3 : error
*/
int lookup(struct sip_msg* _m, char* _t, char* _f, char* _s)
{
unsigned int flags;
urecord_t* r;
str aor, uri;
ucontact_t* ptr,*it;
int res;
int ret;
str path_dst;
str flags_s;
char* ua = NULL;
char* re_end = NULL;
int re_len = 0;
char tmp;
regex_t ua_re;
int regexp_flags = 0;
regmatch_t ua_match;
pv_value_t val;
int_str istr;
str sip_instance = {0,0},call_id = {0,0};
/* branch index */
int idx;
/* temporary branch values*/
int tlen;
char *turi;
qvalue_t tq;
flags = 0;
if (_f && _f[0]!=0) {
if (fixup_get_svalue( _m, (gparam_p)_f, &flags_s)!=0) {
LM_ERR("invalid owner uri parameter");
return -1;
}
for( res=0 ; res< flags_s.len ; res++ ) {
switch (flags_s.s[res]) {
case 'm': flags |= REG_LOOKUP_METHODFILTER_FLAG; break;
case 'b': flags |= REG_LOOKUP_NOBRANCH_FLAG; break;
case 'r': flags |= REG_BRANCH_AOR_LOOKUP_FLAG; break;
case 'u':
if (flags_s.s[res+1] != '/') {
LM_ERR("no regexp after 'u' flag");
break;
}
res++;
if ((re_end = strrchr(flags_s.s+res+1, '/')) == NULL) {
LM_ERR("no regexp after 'u' flag");
break;
}
res++;
re_len = re_end-flags_s.s-res;
if (re_len == 0) {
LM_ERR("empty regexp");
break;
}
ua = flags_s.s+res;
flags |= REG_LOOKUP_UAFILTER_FLAG;
LM_DBG("found regexp /%.*s/", re_len, ua);
res += re_len;
break;
case 'i': regexp_flags |= REG_ICASE; break;
case 'e': regexp_flags |= REG_EXTENDED; break;
default: LM_WARN("unsuported flag %c \n",flags_s.s[res]);
}
}
}
if (flags®_BRANCH_AOR_LOOKUP_FLAG) {
/* extract all the branches for further usage */
nbranches = 0;
while (
(turi=get_branch(nbranches, &tlen, &tq, NULL, NULL, NULL, NULL))
) {
/* copy uri */
branch_uris[nbranches].s = urimem[nbranches];
if (tlen) {
memcpy(branch_uris[nbranches].s, turi, tlen);
branch_uris[nbranches].len = tlen;
} else {
*branch_uris[nbranches].s = '\0';
branch_uris[nbranches].len = 0;
}
nbranches++;
}
clear_branches();
idx=0;
}
if (_s) {
if (pv_get_spec_value( _m, (pv_spec_p)_s, &val)!=0) {
LM_ERR("failed to get PV value\n");
return -1;
}
if ( (val.flags&PV_VAL_STR)==0 ) {
LM_ERR("PV vals is not string\n");
return -1;
}
uri = val.rs;
} else {
if (_m->new_uri.s) uri = _m->new_uri;
else uri = _m->first_line.u.request.uri;
}
if (extract_aor(&uri, &aor,&sip_instance,&call_id) < 0) {
LM_ERR("failed to extract address of record\n");
return -3;
}
get_act_time();
ul.lock_udomain((udomain_t*)_t, &aor);
res = ul.get_urecord((udomain_t*)_t, &aor, &r);
if (res > 0) {
LM_DBG("'%.*s' Not found in usrloc\n", aor.len, ZSW(aor.s));
ul.unlock_udomain((udomain_t*)_t, &aor);
return -1;
}
if (flags & REG_LOOKUP_UAFILTER_FLAG) {
tmp = *(ua+re_len);
*(ua+re_len) = '\0';
if (regcomp(&ua_re, ua, regexp_flags) != 0) {
LM_ERR("bad regexp '%s'\n", ua);
*(ua+re_len) = tmp;
return -1;
}
*(ua+re_len) = tmp;
}
ptr = r->contacts;
ret = -1;
/* look first for an un-expired and suported contact */
search_valid_contact:
while ( (ptr) &&
!(VALID_CONTACT(ptr,act_time) && (ret=-2) && allowed_method(_m,ptr,flags)))
ptr = ptr->next;
if (ptr==0) {
/* nothing found */
LM_DBG("nothing found !\n");
goto done;
}
ua_re_check(
ret = -1;
ptr = ptr->next;
goto search_valid_contact
);
if (sip_instance.len && sip_instance.s) {
LM_DBG("ruri has gruu in lookup\n");
/* uri has GRUU */
if (ptr->instance.len-2 != sip_instance.len ||
memcmp(ptr->instance.s+1,sip_instance.s,sip_instance.len)) {
LM_DBG("no match to sip instace - [%.*s] - [%.*s]\n",ptr->instance.len-2,ptr->instance.s+1,
sip_instance.len,sip_instance.s);
/* not the targeted instance, search some more */
ptr = ptr->next;
goto search_valid_contact;
}
LM_DBG("matched sip instace\n");
}
if (call_id.len && call_id.s) {
/* decide whether GRUU is expired or not
*
* first - match call-id */
if (ptr->callid.len != call_id.len ||
memcmp(ptr->callid.s,call_id.s,call_id.len)) {
LM_DBG("no match to call id - [%.*s] - [%.*s]\n",ptr->callid.len,ptr->callid.s,
call_id.len,call_id.s);
ptr = ptr->next;
goto search_valid_contact;
}
/* matched call-id, check if there are newer contacts with
* same sip instace bup newer last_modified */
it = ptr->next;
while ( it ) {
if (VALID_CONTACT(it,act_time)) {
if (it->instance.len-2 == sip_instance.len && sip_instance.s &&
memcmp(it->instance.s+1,sip_instance.s,sip_instance.len) == 0)
if (it->last_modified > ptr->last_modified) {
/* same instance id, but newer modified -> expired GRUU, no match at all */
break;
}
}
it=it->next;
}
if (it != NULL) {
ret = -1;
goto done;
}
}
LM_DBG("found a complete match\n");
ret = 1;
if (ptr) {
LM_DBG("setting as ruri <%.*s>\n",ptr->c.len,ptr->c.s);
if (set_ruri(_m, &ptr->c) < 0) {
LM_ERR("unable to rewrite Request-URI\n");
ret = -3;
goto done;
}
/* If a Path is present, use first path-uri in favour of
* received-uri because in that case the last hop towards the uac
* has to handle NAT. - agranig */
if (ptr->path.s && ptr->path.len) {
if (get_path_dst_uri(&ptr->path, &path_dst) < 0) {
LM_ERR("failed to get dst_uri for Path\n");
ret = -3;
goto done;
}
if (set_path_vector(_m, &ptr->path) < 0) {
LM_ERR("failed to set path vector\n");
ret = -3;
goto done;
}
if (set_dst_uri(_m, &path_dst) < 0) {
LM_ERR("failed to set dst_uri of Path\n");
ret = -3;
goto done;
}
} else if (ptr->received.s && ptr->received.len) {
if (set_dst_uri(_m, &ptr->received) < 0) {
ret = -3;
goto done;
}
}
set_ruri_q( _m, ptr->q);
setbflag( _m, 0, ptr->cflags);
if (ptr->sock)
_m->force_send_socket = ptr->sock;
/* populate the 'attributes' avp */
if (attr_avp_name != -1) {
istr.s = ptr->attr;
if (add_avp_last(AVP_VAL_STR, attr_avp_name, istr) != 0) {
LM_ERR("Failed to populate attr avp!\n");
}
}
ptr = ptr->next;
}
/* Append branches if enabled */
/* If we got to this point and the URI had a ;gr parameter and it was matched
* to a contact. No point in branching */
if ( flags®_LOOKUP_NOBRANCH_FLAG || (sip_instance.len && sip_instance.s) ) goto done;
LM_DBG("looking for branches\n");
do {
for( ; ptr ; ptr = ptr->next ) {
if (VALID_CONTACT(ptr, act_time) && allowed_method(_m,ptr,flags)) {
path_dst.len = 0;
if(ptr->path.s && ptr->path.len
&& get_path_dst_uri(&ptr->path, &path_dst) < 0) {
LM_ERR("failed to get dst_uri for Path\n");
continue;
}
ua_re_check(continue);
/* The same as for the first contact applies for branches
* regarding path vs. received. */
LM_DBG("setting branch <%.*s>\n",ptr->c.len,ptr->c.s);
if (append_branch(_m,&ptr->c,path_dst.len?&path_dst:&ptr->received,
&ptr->path, ptr->q, ptr->cflags, ptr->sock) == -1) {
LM_ERR("failed to append a branch\n");
/* Also give a chance to the next branches*/
continue;
}
/* populate the 'attributes' avp */
if (attr_avp_name != -1) {
istr.s = ptr->attr;
if (add_avp_last(AVP_VAL_STR, attr_avp_name, istr) != 0) {
LM_ERR("Failed to populate attr avp!\n");
}
}
}
}
/* 0 branches condition also filled; idx initially -1*/
if (!(flags®_BRANCH_AOR_LOOKUP_FLAG) || idx == nbranches)
goto done;
/* relsease old aor lock */
ul.unlock_udomain((udomain_t*)_t, &aor);
ul.release_urecord(r, 0);
/* idx starts from -1 */
uri = branch_uris[idx];
if (extract_aor(&uri, &aor, NULL, &call_id) < 0) {
LM_ERR("failed to extract address of record for branch uri\n");
return -3;
}
/* release old urecord */
/* get lock on new aor */
LM_DBG("getting contacts from aor [%.*s]"
"in branch %d\n", aor.len, aor.s, idx);
ul.lock_udomain((udomain_t*)_t, &aor);
res = ul.get_urecord((udomain_t*)_t, &aor, &r);
if (res > 0) {
LM_DBG("'%.*s' Not found in usrloc\n", aor.len, ZSW(aor.s));
goto done;
}
idx++;
ptr = r->contacts;
} while (1);
static int ul_contact_event_to_msg(struct sip_msg *req)
{
static enum ul_attrs { UL_URI, UL_RECEIVED, UL_PATH, UL_QVAL,
UL_SOCKET, UL_BFLAGS, UL_ATTR, UL_MAX } ul_attr;
/* keep the names of the AVPs aligned with the contact-related events
* from USRLOC module !!!! */
static str ul_names[UL_MAX]= {str_init("uri"),str_init("received"),
str_init("path"),str_init("qval"),
str_init("socket"),str_init("bflags"),
str_init("attr") };
static int avp_ids[UL_MAX] = { -1, -1, -1, -1, -1, -1, -1};
int_str vals[UL_MAX];
int proto, port;
str host;
str path_dst;
if (avp_ids[0]==-1) {
/* init the avp IDs mapping us on the UL event */
for( ul_attr=0 ; ul_attr<UL_MAX ; ul_attr++ ){
if (parse_avp_spec( &ul_names[ul_attr], &avp_ids[ul_attr])<0) {
LM_ERR("failed to init UL AVP %d/%s\n",
ul_attr,ul_names[ul_attr].s);
avp_ids[0] = -1;
return -1;
}
}
}
/* fetch the AVP values one by one */
for( ul_attr=0 ; ul_attr<UL_MAX ; ul_attr++ ) {
if (search_first_avp(0, avp_ids[ul_attr], &vals[ul_attr], NULL)==NULL){
LM_ERR("cannot find AVP(%d) for event attr %d/%s\n",
avp_ids[ul_attr], ul_attr, ul_names[ul_attr].s);
return -1;
}
}
/* OK, we have the values, lets inject them into the SIP msg */
LM_DBG("injecting new branch: uri=<%.*s>, received=<%.*s>,"
"path=<%.*s>, qval=%d, socket=<%.*s>, bflags=%X, attr=<%.*s>\n",
vals[UL_URI].s.len, vals[UL_URI].s.s,
vals[UL_RECEIVED].s.len, vals[UL_RECEIVED].s.s,
vals[UL_PATH].s.len, vals[UL_PATH].s.s,
vals[UL_QVAL].n,
vals[UL_SOCKET].s.len, vals[UL_SOCKET].s.s,
vals[UL_BFLAGS].n,
vals[UL_ATTR].s.len, vals[UL_ATTR].s.s);
/* contact URI goes as RURI */
if (set_ruri( req, &vals[UL_URI].s)<0) {
LM_ERR("failed to set new RURI\n");
return -1;
}
/* contact PATH goes as path */
if (vals[UL_PATH].s.len) {
if (get_path_dst_uri(&vals[UL_PATH].s, &path_dst) < 0) {
LM_ERR("failed to get dst_uri for Path\n");
return -1;
}
if (set_dst_uri( req, &path_dst) < 0) {
LM_ERR("failed to set dst_uri of Path\n");
return -1;
}
if (set_path_vector( req, &vals[UL_PATH].s)<0) {
LM_ERR("failed to set PATH\n");
return -1;
}
} else
/* contact RECEIVED goes as DURI */
if (vals[UL_RECEIVED].s.len) {
if (set_dst_uri( req, &vals[UL_RECEIVED].s)<0) {
LM_ERR("failed to set DST URI\n");
return -1;
}
}
/* contact Qval goes as RURI Qval */
set_ruri_q( req, vals[UL_QVAL].n);
/* contact BFLAGS goes as RURI bflags */
setb0flags( req, vals[UL_BFLAGS].n);
/* socket info */
if (vals[UL_SOCKET].s.len) {
if ( parse_phostport( vals[UL_SOCKET].s.s, vals[UL_SOCKET].s.len,
&host.s, &host.len, &port, &proto) < 0) {
LM_ERR("failed to parse socket from Event attr <%.*s>\n",
vals[UL_SOCKET].s.len, vals[UL_SOCKET].s.s);
} else {
req->force_send_socket = grep_sock_info( &host,
(unsigned short)port, (unsigned short)proto);
}
}
return 0;
}
/*! \brief
* Lookup contact in the database and rewrite Request-URI
* \return: -1 : not found
* -2 : found but method not allowed
* -3 : error
*/
int lookup(struct sip_msg* _m, udomain_t* _d) {
impurecord_t* r;
str aor, uri;
ucontact_t* ptr;
int res;
int ret;
str path_dst;
flag_t old_bflags;
int i = 0;
if (_m->new_uri.s) uri = _m->new_uri;
else uri = _m->first_line.u.request.uri;
if (extract_aor(&uri, &aor) < 0) {
LM_ERR("failed to extract address of record\n");
return -3;
}
get_act_time();
ul.lock_udomain(_d, &aor);
res = ul.get_impurecord(_d, &aor, &r);
if (res > 0) {
LM_DBG("'%.*s' Not found in usrloc\n", aor.len, ZSW(aor.s));
ul.unlock_udomain(_d, &aor);
return -1;
}
ret = -1;
while (i < MAX_CONTACTS_PER_IMPU && (ptr = r->newcontacts[i])) {
if (VALID_CONTACT(ptr, act_time) && allowed_method(_m, ptr)) {
LM_DBG("Found a valid contact [%.*s]\n", ptr->c.len, ptr->c.s);
i++;
break;
}
i++;
}
/* look first for an un-expired and suported contact */
if (ptr == 0) {
/* nothing found */
goto done;
}
ret = 1;
if (ptr) {
if (rewrite_uri(_m, &ptr->c) < 0) {
LM_ERR("unable to rewrite Request-URI\n");
ret = -3;
goto done;
}
/* reset next hop address */
reset_dst_uri(_m);
/* If a Path is present, use first path-uri in favour of
* received-uri because in that case the last hop towards the uac
* has to handle NAT. - agranig */
if (ptr->path.s && ptr->path.len) {
if (get_path_dst_uri(&ptr->path, &path_dst) < 0) {
LM_ERR("failed to get dst_uri for Path\n");
ret = -3;
goto done;
}
if (set_path_vector(_m, &ptr->path) < 0) {
LM_ERR("failed to set path vector\n");
ret = -3;
goto done;
}
if (set_dst_uri(_m, &path_dst) < 0) {
LM_ERR("failed to set dst_uri of Path\n");
ret = -3;
goto done;
}
} else if (ptr->received.s && ptr->received.len) {
if (set_dst_uri(_m, &ptr->received) < 0) {
ret = -3;
goto done;
}
}
set_ruri_q(ptr->q);
old_bflags = 0;
getbflagsval(0, &old_bflags);
setbflagsval(0, old_bflags | ptr->cflags);
if (ptr->sock)
set_force_socket(_m, ptr->sock);
ptr = ptr->next;
}
/* Append branches if enabled */
if (!cfg_get(registrar, registrar_cfg, append_branches)) goto done;
//the last i was the first valid contact we found - let's go through the rest of valid contacts and append the branches.
while (i < MAX_CONTACTS_PER_IMPU && (ptr = r->newcontacts[i])) {
if (VALID_CONTACT(ptr, act_time) && allowed_method(_m, ptr)) {
path_dst.len = 0;
if (ptr->path.s && ptr->path.len
&& get_path_dst_uri(&ptr->path, &path_dst) < 0) {
LM_ERR("failed to get dst_uri for Path\n");
continue;
}
/* The same as for the first contact applies for branches
* regarding path vs. received. */
if (km_append_branch(_m, &ptr->c, path_dst.len ? &path_dst : &ptr->received,
&ptr->path, ptr->q, ptr->cflags, ptr->sock) == -1) {
LM_ERR("failed to append a branch\n");
/* Also give a chance to the next branches*/
continue;
}
}
i++;
}
done:
ul.unlock_udomain(_d, &aor);
return ret;
}
/*! \brief
* Lookup contact in the database and rewrite Request-URI
* \return: -1 : not found
* -2 : found but method not allowed
* -3 : error
*/
int lookup(struct sip_msg* _m, udomain_t* _d, str* _uri)
{
urecord_t* r;
str aor, uri;
sip_uri_t puri;
ucontact_t* ptr = 0;
int res;
int ret;
str path_dst;
flag_t old_bflags;
int i;
str inst = {0};
unsigned int ahash = 0;
sr_xavp_t *xavp=NULL;
sr_xavp_t *list=NULL;
str xname = {"ruid", 4};
sr_xval_t xval;
ret = -1;
if (_m->new_uri.s) uri = _m->new_uri;
else uri = _m->first_line.u.request.uri;
if (extract_aor((_uri)?_uri:&uri, &aor, &puri) < 0) {
LM_ERR("failed to extract address of record\n");
return -3;
}
/* check if gruu */
if(puri.gr.s!=NULL)
{
if(puri.gr_val.len>0) {
/* pub-gruu */
inst = puri.gr_val;
LM_DBG("looking up pub gruu [%.*s]\n", inst.len, inst.s);
} else {
/* temp-gruu */
ahash = 0;
inst = puri.user;
for(i=inst.len-1; i>=0; i--)
{
if(inst.s[i]==REG_GRUU_SEP)
break;
ahash <<= 4;
if(inst.s[i] >='0' && inst.s[i] <='9') ahash+=inst.s[i] -'0';
else if (inst.s[i] >='a' && inst.s[i] <='f') ahash+=inst.s[i] -'a'+10;
else if (inst.s[i] >='A' && inst.s[i] <='F') ahash+=inst.s[i] -'A'+10;
else {
LM_ERR("failed to extract temp gruu - invalid hash\n");
return -3;
}
}
if(i<0) {
LM_ERR("failed to extract temp gruu - invalid format\n");
return -3;
}
inst.len = i;
LM_DBG("looking up temp gruu [%u / %.*s]\n", ahash, inst.len, inst.s);
}
}
get_act_time();
if(puri.gr.s==NULL || puri.gr_val.len>0)
{
/* aor or pub-gruu lookup */
ul.lock_udomain(_d, &aor);
res = ul.get_urecord(_d, &aor, &r);
if (res > 0) {
LM_DBG("'%.*s' Not found in usrloc\n", aor.len, ZSW(aor.s));
ul.unlock_udomain(_d, &aor);
return -1;
}
ptr = r->contacts;
ret = -1;
/* look first for an un-expired and suported contact */
while (ptr) {
if(VALID_CONTACT(ptr,act_time)) {
if(allowed_method(_m,ptr)) {
/* match on instance, if pub-gruu */
if(inst.len>0) {
if(reg_cmp_instances(&inst, &ptr->instance)==0)
{
/* pub-gruu - found by instance */
LM_DBG("contact for [%.*s] found by pub gruu [%.*s]\n",
aor.len, ZSW(aor.s), inst.len, inst.s);
break;
}
} else {
/* no-gruu - found by address */
LM_DBG("contact for [%.*s] found by address\n",
aor.len, ZSW(aor.s));
break;
}
} else {
LM_DBG("contact for [%.*s] cannot handle the SIP method\n",
aor.len, ZSW(aor.s));
ret = -2;
}
}
ptr = ptr->next;
}
if (ptr==0) {
/* nothing found */
LM_DBG("'%.*s' has no valid contact in usrloc\n", aor.len, ZSW(aor.s));
goto done;
}
} else {
/* temp-gruu lookup */
res = ul.get_urecord_by_ruid(_d, ahash, &inst, &r, &ptr);
if(res<0) {
LM_DBG("temp gruu '%.*s' not found in usrloc\n", aor.len, ZSW(aor.s));
return -1;
}
aor = *ptr->aor;
/* test if un-expired and suported contact */
if( (ptr) && !(VALID_CONTACT(ptr,act_time)
&& (ret=-2) && allowed_method(_m,ptr)))
goto done;
LM_DBG("contact for [%.*s] found by temp gruu [%.*s / %u]\n",
aor.len, ZSW(aor.s), inst.len, inst.s, ahash);
}
ret = 1;
if (ptr) {
if (rewrite_uri(_m, &ptr->c) < 0) {
LM_ERR("unable to rewrite Request-URI\n");
ret = -3;
goto done;
}
/* reset next hop address */
reset_dst_uri(_m);
/* add xavp with details of the record (ruid, ...) */
if(reg_xavp_rcd.s!=NULL)
{
list = xavp_get(®_xavp_rcd, NULL);
xavp = list;
memset(&xval, 0, sizeof(sr_xval_t));
xval.type = SR_XTYPE_STR;
xval.v.s = ptr->ruid;
xavp_add_value(&xname, &xval, &xavp);
if(list==NULL)
{
/* no reg_xavp_rcd xavp in root list - add it */
xval.type = SR_XTYPE_XAVP;
xval.v.xavp = xavp;
xavp_add_value(®_xavp_rcd, &xval, NULL);
}
}
/* If a Path is present, use first path-uri in favour of
* received-uri because in that case the last hop towards the uac
* has to handle NAT. - agranig */
if (ptr->path.s && ptr->path.len) {
if (get_path_dst_uri(&ptr->path, &path_dst) < 0) {
LM_ERR("failed to get dst_uri for Path\n");
ret = -3;
goto done;
}
if (set_path_vector(_m, &ptr->path) < 0) {
LM_ERR("failed to set path vector\n");
ret = -3;
goto done;
}
if (set_dst_uri(_m, &path_dst) < 0) {
LM_ERR("failed to set dst_uri of Path\n");
ret = -3;
goto done;
}
} else if (ptr->received.s && ptr->received.len) {
if (set_dst_uri(_m, &ptr->received) < 0) {
ret = -3;
goto done;
}
}
if (ptr->instance.len) {
if (set_instance(_m, &(ptr->instance)) < 0) {
ret = -3;
goto done;
}
}
_m->reg_id = ptr->reg_id;
if (ptr->ruid.len) {
if (set_ruid(_m, &(ptr->ruid)) < 0) {
ret = -3;
goto done;
}
}
if (ptr->user_agent.len) {
if (set_ua(_m, &(ptr->user_agent)) < 0) {
ret = -3;
goto done;
}
}
set_ruri_q(ptr->q);
old_bflags = 0;
getbflagsval(0, &old_bflags);
setbflagsval(0, old_bflags|ptr->cflags);
if (ptr->sock)
set_force_socket(_m, ptr->sock);
if(ptr->xavp!=NULL) {
xavp = xavp_clone_level_nodata(ptr->xavp);
if(xavp_add(xavp, NULL)<0) {
ret = -3;
goto done;
}
}
ptr = ptr->next;
}
/* if was gruu, no more branches */
if(inst.len>0) goto done;
/* Append branches if enabled */
if (!cfg_get(registrar, registrar_cfg, append_branches)) goto done;
for( ; ptr ; ptr = ptr->next ) {
if (VALID_CONTACT(ptr, act_time) && allowed_method(_m, ptr)) {
path_dst.len = 0;
if(ptr->path.s && ptr->path.len
&& get_path_dst_uri(&ptr->path, &path_dst) < 0) {
LM_ERR("failed to get dst_uri for Path\n");
continue;
}
/* The same as for the first contact applies for branches
* regarding path vs. received. */
LM_DBG("instance is %.*s\n",
ptr->instance.len, ptr->instance.s);
if (append_branch(_m, &ptr->c,
path_dst.len?&path_dst:&ptr->received,
&ptr->path, ptr->q, ptr->cflags,
ptr->sock,
ptr->instance.len?&(ptr->instance):0,
ptr->instance.len?ptr->reg_id:0,
&ptr->ruid, &ptr->user_agent)
== -1) {
LM_ERR("failed to append a branch\n");
/* Also give a chance to the next branches*/
continue;
}
if(ptr->xavp!=NULL) {
xavp = xavp_clone_level_nodata(ptr->xavp);
if(xavp_insert(xavp, nr_branches, NULL)<0) {
ret = -3;
goto done;
}
}
}
}
done:
ul.release_urecord(r);
ul.unlock_udomain(_d, &aor);
return ret;
}
/*! \brief
* Lookup contact in the database and rewrite Request-URI
* \return: -1 : not found
* -2 : found but method not allowed
* -3 : error
*/
int lookup(struct sip_msg* _m, char* _t, char* _f, char* _s)
{
unsigned int flags;
urecord_t* r;
str aor, uri;
ucontact_t* ptr,*it;
int res;
int ret;
str path_dst;
str flags_s;
pv_value_t val;
int_str istr;
str sip_instance = {0,0},call_id = {0,0};
flags = 0;
if (_f && _f[0]!=0) {
if (fixup_get_svalue( _m, (gparam_p)_f, &flags_s)!=0) {
LM_ERR("invalid owner uri parameter");
return -1;
}
for( res=0 ; res< flags_s.len ; res++ ) {
switch (flags_s.s[res]) {
case 'm': flags |= REG_LOOKUP_METHODFILTER_FLAG; break;
case 'b': flags |= REG_LOOKUP_NOBRANCH_FLAG; break;
default: LM_WARN("unsuported flag %c \n",flags_s.s[res]);
}
}
}
if (_s) {
if (pv_get_spec_value( _m, (pv_spec_p)_s, &val)!=0) {
LM_ERR("failed to get PV value\n");
return -1;
}
if ( (val.flags&PV_VAL_STR)==0 ) {
LM_ERR("PV vals is not string\n");
return -1;
}
uri = val.rs;
} else {
if (_m->new_uri.s) uri = _m->new_uri;
else uri = _m->first_line.u.request.uri;
}
if (extract_aor(&uri, &aor,&sip_instance,&call_id) < 0) {
LM_ERR("failed to extract address of record\n");
return -3;
}
get_act_time();
ul.lock_udomain((udomain_t*)_t, &aor);
res = ul.get_urecord((udomain_t*)_t, &aor, &r);
if (res > 0) {
LM_DBG("'%.*s' Not found in usrloc\n", aor.len, ZSW(aor.s));
ul.unlock_udomain((udomain_t*)_t, &aor);
return -1;
}
ptr = r->contacts;
ret = -1;
/* look first for an un-expired and suported contact */
search_valid_contact:
while ( (ptr) &&
!(VALID_CONTACT(ptr,act_time) && (ret=-2) && allowed_method(_m,ptr,flags)))
ptr = ptr->next;
if (ptr==0) {
/* nothing found */
LM_DBG("nothing found !\n");
goto done;
}
if (sip_instance.len && sip_instance.s) {
LM_DBG("ruri has gruu in lookup\n");
/* uri has GRUU */
if (ptr->instance.len-2 != sip_instance.len ||
memcmp(ptr->instance.s+1,sip_instance.s,sip_instance.len)) {
LM_DBG("no match to sip instace - [%.*s] - [%.*s]\n",ptr->instance.len-2,ptr->instance.s+1,
sip_instance.len,sip_instance.s);
/* not the targeted instance, search some more */
ptr = ptr->next;
goto search_valid_contact;
}
LM_DBG("matched sip instace\n");
}
if (call_id.len && call_id.s) {
/* decide whether GRUU is expired or not
*
* first - match call-id */
if (ptr->callid.len != call_id.len ||
memcmp(ptr->callid.s,call_id.s,call_id.len)) {
LM_DBG("no match to call id - [%.*s] - [%.*s]\n",ptr->callid.len,ptr->callid.s,
call_id.len,call_id.s);
ptr = ptr->next;
goto search_valid_contact;
}
/* matched call-id, check if there are newer contacts with
* same sip instace bup newer last_modified */
it = ptr->next;
while ( it ) {
if (VALID_CONTACT(it,act_time)) {
if (it->instance.len-2 == sip_instance.len &&
memcmp(it->instance.s+1,sip_instance.s,sip_instance.len) == 0)
if (it->last_modified > ptr->last_modified) {
/* same instance id, but newer modified -> expired GRUU, no match at all */
break;
}
}
it=it->next;
}
if (it != NULL) {
ret = -1;
goto done;
}
}
LM_DBG("found a complete match\n");
ret = 1;
if (ptr) {
LM_DBG("setting as ruri <%.*s>\n",ptr->c.len,ptr->c.s);
if (set_ruri(_m, &ptr->c) < 0) {
LM_ERR("unable to rewrite Request-URI\n");
ret = -3;
goto done;
}
/* If a Path is present, use first path-uri in favour of
* received-uri because in that case the last hop towards the uac
* has to handle NAT. - agranig */
if (ptr->path.s && ptr->path.len) {
if (get_path_dst_uri(&ptr->path, &path_dst) < 0) {
LM_ERR("failed to get dst_uri for Path\n");
ret = -3;
goto done;
}
if (set_path_vector(_m, &ptr->path) < 0) {
LM_ERR("failed to set path vector\n");
ret = -3;
goto done;
}
if (set_dst_uri(_m, &path_dst) < 0) {
LM_ERR("failed to set dst_uri of Path\n");
ret = -3;
goto done;
}
} else if (ptr->received.s && ptr->received.len) {
if (set_dst_uri(_m, &ptr->received) < 0) {
ret = -3;
goto done;
}
}
set_ruri_q(ptr->q);
setbflag( 0, ptr->cflags);
if (ptr->sock)
_m->force_send_socket = ptr->sock;
/* populate the 'attributes' avp */
if (attr_avp_name != -1) {
istr.s = ptr->attr;
if (add_avp_last(AVP_VAL_STR, attr_avp_name, istr) != 0) {
LM_ERR("Failed to populate attr avp!\n");
}
}
ptr = ptr->next;
}
/* Append branches if enabled */
/* If we got to this point and the URI had a ;gr parameter and it was matched
* to a contact. No point in branching */
if ( flags®_LOOKUP_NOBRANCH_FLAG || (sip_instance.len && sip_instance.s) ) goto done;
LM_DBG("looking for branches\n");
for( ; ptr ; ptr = ptr->next ) {
if (VALID_CONTACT(ptr, act_time) && allowed_method(_m,ptr,flags)) {
path_dst.len = 0;
if(ptr->path.s && ptr->path.len
&& get_path_dst_uri(&ptr->path, &path_dst) < 0) {
LM_ERR("failed to get dst_uri for Path\n");
continue;
}
/* The same as for the first contact applies for branches
* regarding path vs. received. */
LM_DBG("setting branch <%.*s>\n",ptr->c.len,ptr->c.s);
if (append_branch(_m,&ptr->c,path_dst.len?&path_dst:&ptr->received,
&ptr->path, ptr->q, ptr->cflags, ptr->sock) == -1) {
LM_ERR("failed to append a branch\n");
/* Also give a chance to the next branches*/
continue;
}
/* populate the 'attributes' avp */
if (attr_avp_name != -1) {
istr.s = ptr->attr;
if (add_avp_last(AVP_VAL_STR, attr_avp_name, istr) != 0) {
LM_ERR("Failed to populate attr avp!\n");
}
}
}
}
done:
ul.release_urecord(r);
ul.unlock_udomain((udomain_t*)_t, &aor);
return ret;
}
static int get_all_db_ucontacts(void *buf, int len, unsigned int flags,
unsigned int part_idx, unsigned int part_max)
{
static char query_buf[512];
static str query_str;
static struct sip_uri puri;
struct socket_info *sock;
struct proxy_l next_hop;
db_res_t *res = NULL;
db_row_t *row;
db_val_t *val;
dlist_t *dom;
str uri, host, flag_list;
int i, no_rows = 10;
int now_len;
char now_s[25];
char *p, *p1;
int port, proto, p_len, p1_len;
unsigned int dbflags;
int needed;
int shortage = 0;
shortage = 0;
/* Reserve space for terminating 0000 */
len -= sizeof p_len;
/* get the current time in DB format */
now_len = 25;
if (db_time2str(time(NULL), now_s, &now_len) != 0) {
LM_ERR("failed to print now time\n");
return -1;
}
LM_DBG("buf: %p. flags: %d\n", buf, flags);
/* for each table */
for (dom = root; dom; dom = dom->next) {
if (db_check_table_version(&ul_dbf, ul_dbh, dom->d->name, UL_TABLE_VERSION))
goto error;
/* read the destinations */
if (ul_dbf.use_table(ul_dbh, dom->d->name) < 0) {
LM_ERR("cannot select table \"%.*s\"\n", dom->d->name->len,
dom->d->name->s);
goto error;
}
i = snprintf(query_buf, sizeof query_buf, "select %.*s, %.*s, %.*s,"
#ifdef ORACLE_USRLOC
" %.*s, %.*s from %s where %.*s > %.*s and mod(id, %u) = %u",
#else
" %.*s, %.*s from %s where %.*s > %.*s and id %% %u = %u",
#endif
received_col.len, received_col.s,
contact_col.len, contact_col.s,
sock_col.len, sock_col.s,
cflags_col.len, cflags_col.s,
path_col.len, path_col.s,
dom->d->name->s,
expires_col.len, expires_col.s,
now_len, now_s,
part_max, part_idx);
LM_DBG("query: %.*s\n", (int)(sizeof query_buf), query_buf);
if (i >= sizeof query_buf) {
LM_ERR("DB query too long\n");
goto error;
}
query_str.s = query_buf;
query_str.len = i;
if (DB_CAPABILITY(ul_dbf, DB_CAP_FETCH)) {
if (ul_dbf.raw_query(ul_dbh, &query_str, 0) < 0) {
LM_ERR("raw_query failed\n");
goto error;
}
no_rows = estimate_available_rows(20+128+20+128+64, 5);
if (no_rows == 0)
no_rows = 10;
LM_DBG("fetching %d rows\n", no_rows);
if (ul_dbf.fetch_result(ul_dbh, &res, no_rows) < 0) {
LM_ERR("Error fetching rows\n");
goto error;
}
} else if (ul_dbf.raw_query(ul_dbh, &query_str, &res) < 0) {
LM_ERR("raw_query failed\n");
goto error;
}
do {
for (i = 0; i < RES_ROW_N(res); i++) {
row = RES_ROWS(res) + i;
val = ROW_VALUES(row) + 3; /* cflags */
flag_list.s = (char *)VAL_STRING(val);
flag_list.len = strlen(flag_list.s);
LM_DBG("contact cflags: '%.*s'\n", flag_list.len, flag_list.s);
/* contact is not flagged at all */
if (flags && (val->nul || !flag_list.s))
continue;
dbflags = flag_list_to_bitmask(&flag_list,
FLAG_TYPE_BRANCH, FLAG_DELIM);
LM_DBG("masks: param: %d --- %d :db\n", flags, dbflags);
/* check if contact flags match the given bitmask */
if ((dbflags & flags) != flags)
continue;
/* received */
p = (char*)VAL_STRING(ROW_VALUES(row));
if (VAL_NULL(ROW_VALUES(row)) || !p || !p[0]) {
/* contact */
p = (char*)VAL_STRING(ROW_VALUES(row) + 1);
if (VAL_NULL(ROW_VALUES(row) + 1) || !p || *p == '\0') {
LM_ERR("empty contact -> skipping\n");
continue;
}
}
p_len = strlen(p);
/* path */
p1 = (char*)VAL_STRING(ROW_VALUES(row) + 4);
if (VAL_NULL(ROW_VALUES(row) + 4) || !p1 || *p1 == '\0') {
p1 = NULL;
p1_len = 0;
} else
p1_len = strlen(p1);
needed = (int)(p_len + sizeof p_len + p1_len + sizeof p1_len +
sizeof sock + sizeof dbflags + sizeof next_hop);
LM_DBG("len: %d, needed: %d\n", len, needed);
if (len < needed) {
shortage += needed;
continue;
}
/* determine and parse the URI of this contact's next hop */
if (p1_len > 0) {
/* send to first URI in path */
host.s = p1;
host.len = p1_len;
if (get_path_dst_uri(&host, &uri) < 0) {
LM_ERR("failed to get dst_uri for Path\n");
continue;
}
if (parse_uri(uri.s, uri.len, &puri) < 0) {
LM_ERR("failed to parse path URI of next hop: '%*.s'\n",
p1_len, p1);
return -1;
}
} else {
if (parse_uri(p, p_len, &puri) < 0) {
LM_ERR("failed to parse contact of next hop: '%*.s'\n",
p_len, p);
return -1;
}
}
/* write received/contact */
memcpy(buf, &p_len, sizeof p_len);
buf += sizeof p_len;
memcpy(buf, p, p_len);
buf += p_len;
/* write path */
memcpy(buf, &p1_len, sizeof p1_len);
buf += sizeof p1_len;
memcpy(buf, p1, p1_len);
buf += p1_len;
/* sock */
p = (char*)VAL_STRING(ROW_VALUES(row) + 2);
if (VAL_NULL(ROW_VALUES(row)+2) || !p || *p == '\0') {
sock = NULL;
} else {
if (parse_phostport(p, strlen(p), &host.s, &host.len,
&port, &proto) != 0) {
LM_ERR("bad socket <%s>...ignoring\n", p);
sock = NULL;
} else {
sock = grep_sock_info(&host, (unsigned short)port, proto);
if (!sock)
LM_DBG("non-local socket <%s>...ignoring\n", p);
}
}
/* write sock and flags */
memcpy(buf, &sock, sizeof sock);
buf += sizeof sock;
memcpy(buf, &dbflags, sizeof dbflags);
buf += sizeof dbflags;
memset(&next_hop, 0, sizeof next_hop);
next_hop.port = puri.port_no;
next_hop.proto = puri.proto;
next_hop.name = puri.host;
/* write the next hop */
memcpy(buf, &next_hop, sizeof next_hop);
buf += sizeof next_hop;
len -= needed;
}
if (DB_CAPABILITY(ul_dbf, DB_CAP_FETCH)) {
if (ul_dbf.fetch_result(ul_dbh, &res, no_rows) < 0) {
LM_ERR("fetching rows (1)\n");
goto error;
}
} else
break;
} while (RES_ROW_N(res) > 0);
ul_dbf.free_result(ul_dbh, res);
}
/* len < 0 is possible, if size of the buffer < sizeof c->c.len */
if (len >= 0)
memset(buf, 0, sizeof p_len);
/* Shouldn't happen */
if (shortage > 0 && len > shortage)
abort();
shortage -= len;
return shortage > 0 ? shortage : 0;
error:
if (res)
ul_dbf.free_result(ul_dbh, res);
return -1;
}
