/**
* append new branches with generic parameters
*/
int corex_append_branch(sip_msg_t *msg, gparam_t *pu, gparam_t *pq)
{
str uri = {0};
str qv = {0};
int ret = 0;
qvalue_t q = Q_UNSPECIFIED;
flag_t branch_flags = 0;
if (pu!=NULL)
{
if(fixup_get_svalue(msg, pu, &uri)!=0)
{
LM_ERR("cannot get the URI parameter\n");
return -1;
}
}
if (pq!=NULL)
{
if(fixup_get_svalue(msg, pq, &qv)!=0)
{
LM_ERR("cannot get the Q parameter\n");
return -1;
}
if(qv.len>0 && str2q(&q, qv.s, qv.len)<0)
{
LM_ERR("cannot parse the Q parameter\n");
return -1;
}
}
getbflagsval(0, &branch_flags);
ret = append_branch(msg, (uri.len>0)?&uri:0, &msg->dst_uri,
&msg->path_vec, q, branch_flags,
msg->force_send_socket, 0, 0, 0, 0);
if(uri.len<=0)
{
/* reset all branch attributes if r-uri was shifted to branch */
reset_force_socket(msg);
setbflagsval(0, 0);
if(msg->dst_uri.s!=0)
pkg_free(msg->dst_uri.s);
msg->dst_uri.s = 0;
msg->dst_uri.len = 0;
/* if this is a cloned message, don't free the path vector as it was copied into shm memory and will be freed as contiguous block*/
if (!(msg->msg_flags&FL_SHM_CLONE)) {
if(msg->path_vec.s!=0)
pkg_free(msg->path_vec.s);
msg->path_vec.s = 0;
msg->path_vec.len = 0;
}
}
return ret;
}
/**
* append new branches with generic parameters
*/
int corex_append_branch(sip_msg_t *msg, gparam_t *pu, gparam_t *pq)
{
str uri = {0};
str qv = {0};
int ret = 0;
qvalue_t q = Q_UNSPECIFIED;
flag_t branch_flags = 0;
if (pu!=NULL)
{
if(fixup_get_svalue(msg, pu, &uri)!=0)
{
LM_ERR("cannot get the URI parameter\n");
return -1;
}
}
if (pq!=NULL)
{
if(fixup_get_svalue(msg, pq, &qv)!=0)
{
LM_ERR("cannot get the Q parameter\n");
return -1;
}
if(qv.len>0 && str2q(&q, qv.s, qv.len)<0)
{
LM_ERR("cannot parse the Q parameter\n");
return -1;
}
}
getbflagsval(0, &branch_flags);
ret = append_branch(msg, (uri.len>0)?&uri:0, &msg->dst_uri,
&msg->path_vec, q, branch_flags,
msg->force_send_socket, 0, 0);
if(uri.len<=0)
{
/* reset all branch attributes if r-uri was shifted to branch */
reset_force_socket(msg);
setbflagsval(0, 0);
if(msg->dst_uri.s!=0)
pkg_free(msg->dst_uri.s);
msg->dst_uri.s = 0;
msg->dst_uri.len = 0;
if(msg->path_vec.s!=0)
pkg_free(msg->path_vec.s);
msg->path_vec.s = 0;
msg->path_vec.len = 0;
}
return ret;
}
int reset_ruri_branch(sip_msg_t *msg)
{
if(msg==NULL)
return -1;
reset_dst_uri(msg);
reset_path_vector(msg);
set_ruri_q(Q_UNSPECIFIED);
reset_force_socket(msg);
setbflagsval(0, 0);
reset_instance(msg);
msg->reg_id = 0;
return 0;
}
/**
* only reset the pointers after local backup in lookup_branches
*/
int clear_ruri_branch(sip_msg_t *msg)
{
if(msg==NULL)
return -1;
msg->dst_uri.s = 0;
msg->dst_uri.len = 0;
msg->path_vec.s = 0;
msg->path_vec.len = 0;
set_ruri_q(Q_UNSPECIFIED);
reset_force_socket(msg);
setbflagsval(0, 0);
msg->instance.len = 0;
msg->reg_id = 0;
msg->ruid.s = 0;
msg->ruid.len = 0;
msg->location_ua.s = 0;
msg->location_ua.len = 0;
return 0;
}
/**
* Creates new "main" branch by making copy of branch-failure branch.
* Currently the following branch attributes are included:
* request-uri, ruid, path, instance, and branch flags.
*/
static int w_t_reuse_branch(sip_msg_t* msg, char *p1, char *p2)
{
tm_cell_t *t;
int branch;
if (msg == NULL) return -1;
/* first get the transaction */
if (_tmx_tmb.t_check(msg, 0) == -1) return -1;
if ((t = _tmx_tmb.t_gett()) == 0) {
LM_ERR("no transaction\n");
return -1;
}
switch (get_route_type()) {
case BRANCH_FAILURE_ROUTE:
/* use the reason of the winning reply */
if ((branch = _tmx_tmb.t_get_picked_branch()) < 0) {
LM_CRIT("no picked branch (%d) for a final response"
" in MODE_ONFAILURE\n", branch);
return -1;
}
if(rewrite_uri(msg, &(t->uac[branch].uri))<0) {
LM_WARN("failed to rewrite the r-uri\n");
}
set_ruid(msg, &(t->uac[branch].ruid));
if (t->uac[branch].path.len) {
if(set_path_vector(msg, &(t->uac[branch].path))<0) {
LM_WARN("failed to set the path vector\n");
}
} else {
reset_path_vector(msg);
}
setbflagsval(0, t->uac[branch].branch_flags);
set_instance(msg, &(t->uac[branch].instance));
return 1;
default:
LM_ERR("unsupported route_type %d\n", get_route_type());
return -1;
}
}
int t_append_branches(void) {
struct cell *t = NULL;
struct sip_msg *orig_msg = NULL;
short outgoings;
int success_branch;
str current_uri;
str dst_uri, path, instance, ruid, location_ua;
struct socket_info* si;
int q, i, found;
flag_t backup_bflags = 0;
flag_t bflags = 0;
int new_branch, branch_ret, lowest_ret;
branch_bm_t added_branches;
int replies_locked = 0;
t = get_t();
if(t == NULL)
{
LM_ERR("cannot get transaction\n");
return -1;
}
LM_DBG("transaction %u:%u in status %d\n", t->hash_index, t->label, t->uas.status);
/* test if transaction has already been canceled */
if (t->flags & T_CANCELED) {
ser_error=E_CANCELED;
return -1;
}
if ((t->uas.status >= 200 && t->uas.status<=399)
|| ((t->uas.status >= 600 && t->uas.status)
&& !(t->flags & (T_6xx | T_DISABLE_6xx))) ) {
LM_DBG("transaction %u:%u in status %d: cannot append new branch\n",
t->hash_index, t->label, t->uas.status);
return -1;
}
/* set the lock on the transaction here */
LOCK_REPLIES(t);
replies_locked = 1;
outgoings = t->nr_of_outgoings;
orig_msg = t->uas.request;
LM_DBG("Call %.*s: %d (%d) outgoing branches\n",orig_msg->callid->body.len,
orig_msg->callid->body.s,outgoings, nr_branches);
lowest_ret=E_UNSPEC;
added_branches=0;
/* it's a "late" branch so the on_branch variable has already been
reset by previous execution of t_forward_nonack: we use the saved
value */
if (t->on_branch_delayed) {
/* tell add_uac that it should run branch route actions */
set_branch_route(t->on_branch_delayed);
}
outgoings = t->nr_of_outgoings;
/* not really sure that the following is needed */
set_branch_iterator(nr_branches-1);
found = 0;
while((current_uri.s=next_branch( ¤t_uri.len, &q, &dst_uri, &path,
&bflags, &si, &ruid, &instance, &location_ua))) {
LM_DBG("Current uri %.*s\n",current_uri.len, current_uri.s);
for (i=0; i<nr_branches; i++) {
if (t->uac[i].ruid.len == ruid.len
&& !memcmp(t->uac[i].ruid.s, ruid.s, ruid.len)) {
LM_DBG("branch already added [%.*s]\n", ruid.len, ruid.s);
found = 1;
break;
}
}
if (found)
continue;
setbflagsval(0, bflags);
new_branch=add_uac( t, orig_msg, ¤t_uri,
(dst_uri.len) ? (&dst_uri) : ¤t_uri,
&path, 0, si, orig_msg->fwd_send_flags,
orig_msg->rcv.proto, (dst_uri.len)?-1:UAC_SKIP_BR_DST_F, &instance,
&ruid, &location_ua);
/* test if cancel was received meanwhile */
if (t->flags & T_CANCELED) goto canceled;
if (new_branch>=0)
added_branches |= 1<<new_branch;
else
lowest_ret=MIN_int(lowest_ret, new_branch);
}
clear_branches();
LM_DBG("Call %.*s: %d (%d) outgoing branches after clear_branches()\n",
orig_msg->callid->body.len, orig_msg->callid->body.s,outgoings, nr_branches);
setbflagsval(0, backup_bflags);
/* update message flags, if changed in branch route */
t->uas.request->flags = orig_msg->flags;
if (added_branches==0) {
if(lowest_ret!=E_CFG)
LOG(L_ERR, "ERROR: t_append_branch: failure to add branches\n");
ser_error=lowest_ret;
replies_locked = 0;
UNLOCK_REPLIES(t);
return lowest_ret;
}
ser_error=0; /* clear branch adding errors */
/* send them out now */
success_branch=0;
/* since t_append_branch can only be called from REQUEST_ROUTE, always lock replies */
for (i=outgoings; i<t->nr_of_outgoings; i++) {
if (added_branches & (1<<i)) {
branch_ret=t_send_branch(t, i, orig_msg , 0, 0 /* replies are already locked */ );
if (branch_ret>=0){ /* some kind of success */
if (branch_ret==i) { /* success */
success_branch++;
if (unlikely(has_tran_tmcbs(t, TMCB_REQUEST_OUT)))
run_trans_callbacks_with_buf( TMCB_REQUEST_OUT,
&t->uac[nr_branches].request,
orig_msg, 0, -orig_msg->REQ_METHOD);
}
else /* new branch added */
added_branches |= 1<<branch_ret;
}
}
}
if (success_branch<=0) {
/* return always E_SEND for now
* (the real reason could be: denied by onsend routes, blacklisted,
* send failed or any of the errors listed before + dns failed
* when attempting dns failover) */
ser_error=E_SEND;
/* else return the last error (?) */
/* the caller should take care and delete the transaction */
replies_locked = 0;
UNLOCK_REPLIES(t);
return -1;
}
ser_error=0; /* clear branch send errors, we have overall success */
set_kr(REQ_FWDED);
replies_locked = 0;
UNLOCK_REPLIES(t);
return 1;
canceled:
DBG("t_append_branches: cannot append branches to a canceled transaction\n");
/* reset processed branches */
clear_branches();
/* restore backup flags from initial env */
setbflagsval(0, backup_bflags);
/* update message flags, if changed in branch route */
t->uas.request->flags = orig_msg->flags;
/* if needed unlock transaction's replies */
if (likely(replies_locked)) {
/* restore the number of outgoing branches
* since new branches have not been completed */
t->nr_of_outgoings = outgoings;
replies_locked = 0;
UNLOCK_REPLIES(t);
}
ser_error=E_CANCELED;
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, 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;
}
int sbranch_set_ruri(sip_msg_t *msg)
{
str sv;
flag_t old_bflags;
branch_t *br;
int ret;
ret = 0;
br = &_pv_sbranch;
if(br->len==0)
return -1;
sv.s = br->uri;
sv.len = br->len;
if (rewrite_uri(msg, &sv) < 0) {
LM_ERR("unable to rewrite Request-URI\n");
ret = -3;
goto error;
}
/* reset next hop address */
reset_dst_uri(msg);
if(br->dst_uri_len>0) {
sv.s = br->dst_uri;
sv.len = br->dst_uri_len;
if (set_dst_uri(msg, &sv) < 0) {
ret = -3;
goto error;
}
}
reset_path_vector(msg);
if(br->path_len==0) {
sv.s = br->path;
sv.len = br->path_len;
if(set_path_vector(msg, &sv) < 0) {
ret = -4;
goto error;
}
}
reset_instance(msg);
if (br->instance_len) {
sv.s = br->instance;
sv.len = br->instance_len;
if (set_instance(msg, &sv) < 0) {
ret = -5;
goto error;
}
}
reset_ruid(msg);
if (br->ruid_len) {
sv.s = br->ruid;
sv.len = br->ruid_len;
if (set_ruid(msg, &sv) < 0) {
ret = -6;
goto error;
}
}
reset_ua(msg);
if (br->location_ua_len) {
sv.s = br->location_ua;
sv.len = br->location_ua_len;
if (set_ua(msg, &sv) < 0) {
ret = -7;
goto error;
}
}
if (br->force_send_socket)
set_force_socket(msg, br->force_send_socket);
msg->reg_id = br->reg_id;
set_ruri_q(br->q);
old_bflags = 0;
getbflagsval(0, &old_bflags);
setbflagsval(0, old_bflags|br->flags);
return 0;
error:
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 contacts in the database for all branches, including R-URI
* \return: -1 : not found
* -2 : found but method not allowed (for r-uri)
* -3 : error
*/
int lookup_branches(sip_msg_t *msg, udomain_t *d)
{
unsigned int nr_branches_start;
unsigned int i;
int ret;
int found;
str new_uri;
str ruri_b_uri = {0};
str ruri_b_dst_uri = {0};
str ruri_b_path = {0};
int ruri_b_q = Q_UNSPECIFIED;
struct socket_info *ruri_b_socket = 0;
flag_t ruri_b_flags = 0;
str ruri_b_instance = {0};
unsigned int ruri_b_reg_id = 0;
str ruri_b_ruid = {0};
str ruri_b_ua = {0};
branch_t *crt = NULL;
ret = 1;
found = 0;
nr_branches_start = nr_branches;
/* first lookup the r-uri */
ret = lookup(msg, d, NULL);
/* if no other branches -- all done */
if(nr_branches_start==0)
return ret;
if(ret>0)
found = 1;
/* backup r-uri branch */
ruri_b_uri = msg->new_uri;
ruri_b_dst_uri = msg->dst_uri;
ruri_b_path = msg->path_vec;
ruri_b_q = get_ruri_q();
ruri_b_socket = msg->force_send_socket;
getbflagsval(0, &ruri_b_flags);
ruri_b_instance = msg->instance;
ruri_b_reg_id = msg->reg_id;
ruri_b_ruid = msg->ruid;
ruri_b_ua = msg->location_ua;
reset_ruri_branch(msg);
/* set new uri buf to null, otherwise is freed or overwritten by
* rewrite_uri() during branch lookup */
msg->new_uri.len=0;
msg->new_uri.s=0;
msg->parsed_uri_ok=0;
for(i=0; i<nr_branches_start; i++) {
crt = get_sip_branch(i);
/* it has to be a clean branch to do lookup for it */
if(crt->len <= 0 || crt->dst_uri_len > 0
|| crt->path_len > 0 || crt->force_send_socket!=NULL
|| crt->flags !=0)
continue;
/* set the new uri from branch and lookup */
new_uri.s = crt->uri;
new_uri.len = crt->len;
if (rewrite_uri(msg, &new_uri) < 0) {
LM_ERR("unable to rewrite Request-URI for branch %u\n", i);
ret = -3;
goto done;
}
ret = lookup(msg, d, NULL);
if(ret>0) {
/* move r-uri branch attributes to crt branch */
found = 1;
if (unlikely(msg->new_uri.len > MAX_URI_SIZE - 1)) {
LM_ERR("too long uri: %.*s\n", msg->new_uri.len,
msg->new_uri.s);
ret = -3;
goto done;
}
/* copy the dst_uri */
if (msg->dst_uri.len>0 && msg->dst_uri.s!=NULL) {
if (unlikely(msg->dst_uri.len > MAX_URI_SIZE - 1)) {
LM_ERR("too long dst_uri: %.*s\n", msg->dst_uri.len,
msg->dst_uri.s);
ret = -3;
goto done;
}
memcpy(crt->dst_uri, msg->dst_uri.s, msg->dst_uri.len);
crt->dst_uri[msg->dst_uri.len] = 0;
crt->dst_uri_len = msg->dst_uri.len;
}
/* copy the path string */
if (unlikely(msg->path_vec.len>0 && msg->path_vec.s!=NULL)) {
if (unlikely(msg->path_vec.len > MAX_PATH_SIZE - 1)) {
LM_ERR("too long path: %.*s\n", msg->path_vec.len,
msg->path_vec.s);
ret = -3;
goto done;
}
memcpy(crt->path, msg->path_vec.s, msg->path_vec.len);
crt->path[msg->path_vec.len] = 0;
crt->path_len = msg->path_vec.len;
}
/* copy the ruri */
memcpy(crt->uri, msg->new_uri.s, msg->new_uri.len);
crt->uri[msg->new_uri.len] = 0;
crt->len = msg->new_uri.len;
crt->q = get_ruri_q();
crt->force_send_socket = msg->force_send_socket;
getbflagsval(0, &crt->flags);
}
reset_ruri_branch(msg);
}
done:
reset_ruri_branch(msg);
/* new uri could be set to allocated buffer by branch lookup */
if(msg->new_uri.s!=NULL)
pkg_free(msg->new_uri.s);
msg->new_uri = ruri_b_uri;
ruri_mark_new();
msg->parsed_uri_ok = 0;
msg->dst_uri = ruri_b_dst_uri;
msg->path_vec = ruri_b_path;
set_ruri_q(ruri_b_q);
set_force_socket(msg, ruri_b_socket);
setbflagsval(0, ruri_b_flags);
msg->instance = ruri_b_instance;
msg->reg_id = ruri_b_reg_id;
msg->ruid = ruri_b_ruid;
msg->location_ua = ruri_b_ua;
return (found)?1:ret;
}
/*
* Adds to request a new destination set that includes all highest
* priority class contacts in contacts_avp. Request URI is rewritten with
* first contact and the remaining contacts (if any) are added as branches.
* Removes used contacts from contacts_avp. Returns 1, if contacts_avp
* was not empty and a destination set was successfully added. Returns -2,
* if contacts_avp was empty and thus there was nothing to do.
* Returns -1 in case of an error. */
int t_next_contacts(struct sip_msg* msg, char* key, char* value)
{
struct usr_avp *avp, *prev;
int_str val;
str uri, dst, path;
struct socket_info *sock;
unsigned int flags;
struct search_state st;
/* Check if contacts_avp has been defined */
if (contacts_avp.n == 0) {
LM_ERR("feature has been disabled - "
"to enable define contacts_avp module parameter");
return -1;
}
/* Load Request-URI and branches */
/* Find first contacts_avp value */
avp = search_first_avp(contacts_avp_type, contacts_avp, &val, &st);
if (!avp) {
LM_DBG("no AVPs - we are done!\n");
return -2;
}
LM_DBG("next contact is <%.*s>\n", STR_FMT(&val.s));
if (decode_branch_info(val.s.s, &uri, &dst, &path, &sock, &flags)
== 0) {
LM_ERR("decoding of branch info <%.*s> failed\n", STR_FMT(&val.s));
destroy_avp(avp);
return -1;
}
/* Rewrite Request-URI */
rewrite_uri(msg, &uri);
if (dst.s && dst.len) set_dst_uri(msg, &dst);
else reset_dst_uri(msg);
if (path.s && path.len) set_path_vector(msg, &path);
else reset_path_vector(msg);
set_force_socket(msg, sock);
setbflagsval(0, flags);
if (avp->flags & Q_FLAG) {
destroy_avp(avp);
return 1;
}
/* Append branches until out of branches or Q_FLAG is set */
prev = avp;
while ((avp = search_next_avp(&st, &val))) {
destroy_avp(prev);
LM_DBG("next contact is <%.*s>\n", STR_FMT(&val.s));
if (decode_branch_info(val.s.s, &uri, &dst, &path, &sock, &flags)
== 0) {
LM_ERR("decoding of branch info <%.*s> failed\n", STR_FMT(&val.s));
destroy_avp(avp);
return -1;
}
if (append_branch(msg, &uri, &dst, &path, 0, flags, sock) != 1) {
LM_ERR("appending branch failed\n");
destroy_avp(avp);
return -1;
}
if (avp->flags & Q_FLAG) {
destroy_avp(avp);
return 1;
}
prev = avp;
}
destroy_avp(prev);
return 1;
}
int rtjson_init_serial(sip_msg_t *msg, srjson_doc_t *jdoc, sr_xavp_t *iavp)
{
srjson_t *tj = NULL;
srjson_t *nj = NULL;
srjson_t *rj = NULL;
str val;
unsigned int bflags = 0;
unsigned int old_bflags = 0;
struct socket_info* fsocket = NULL;
tj = srjson_GetObjectItem(jdoc, jdoc->root, "routes");
if(tj==NULL || tj->type!=srjson_Array || tj->child==NULL) {
LM_ERR("missing or invalid routes field\n");
goto error;
}
nj = tj->child;
clear_branches();
rj = srjson_GetObjectItem(jdoc, nj, "uri");
if(rj!=NULL && rj->type==srjson_String && rj->valuestring!=NULL) {
val.s = rj->valuestring;
val.len = strlen(val.s);
LM_DBG("rewrite r-uri to: [%.*s]\n", val.len, val.s);
if (rewrite_uri(msg, &val) < 0) {
LM_ERR("unable to rewrite Request-URI\n");
goto error;
}
}
reset_dst_uri(msg);
reset_path_vector(msg);
reset_instance(msg);
reset_ruid(msg);
reset_ua(msg);
reset_force_socket(msg);
msg->reg_id = 0;
set_ruri_q(0);
rj = srjson_GetObjectItem(jdoc, nj, "dst_uri");
if(rj!=NULL && rj->type==srjson_String && rj->valuestring!=NULL) {
val.s = rj->valuestring;
val.len = strlen(val.s);
LM_DBG("rewrite dst-uri to: [%.*s]\n", val.len, val.s);
if (set_dst_uri(msg, &val) < 0) {
LM_ERR("unable to set destination uri\n");
goto error;
}
}
rj = srjson_GetObjectItem(jdoc, nj, "path");
if(rj!=NULL && rj->type==srjson_String && rj->valuestring!=NULL) {
val.s = rj->valuestring;
val.len = strlen(val.s);
LM_DBG("rewrite path to: [%.*s]\n", val.len, val.s);
if (set_path_vector(msg, &val) < 0) {
LM_ERR("unable to set path\n");
goto error;
}
}
rj = srjson_GetObjectItem(jdoc, nj, "socket");
if(rj!=NULL && rj->type==srjson_String && rj->valuestring!=NULL) {
val.s = rj->valuestring;
val.len = strlen(val.s);
LM_DBG("trying to set send socket to: [%.*s]\n", val.len, val.s);
fsocket = lookup_local_socket(&val);
if(fsocket) {
set_force_socket(msg, fsocket);
}
}
rj = srjson_GetObjectItem(jdoc, nj, "branch_flags");
if(rj!=NULL && rj->type==srjson_Number && SRJSON_GET_UINT(rj)!=0) {
bflags = SRJSON_GET_UINT(rj);
old_bflags = 0;
getbflagsval(0, &old_bflags);
setbflagsval(0, old_bflags|bflags);
}
iavp->val.v.i++;
return 0;
error:
return -1;
}
