inline static int w_t_relay( struct sip_msg *p_msg , char *proxy, char *flags)
{
struct proxy_l *p = NULL;
struct cell *t;
int ret;
t=get_t();
if (proxy && (p=clone_proxy((struct proxy_l*)proxy))==0) {
LM_ERR("failed to clone proxy, dropping packet\n");
return -1;
}
if (!t || t==T_UNDEFINED) {
/* no transaction yet */
if (route_type==FAILURE_ROUTE) {
LM_CRIT("BUG - undefined transaction in failure route\n");
return -1;
}
ret = t_relay_to( p_msg, p, (int)(long)flags );
if (ret<0) {
ret = t_relay_inerr2scripterr();
}
} else {
/* transaction already created */
if ( route_type!=REQUEST_ROUTE && route_type!=FAILURE_ROUTE )
goto route_err;
if (p_msg->REQ_METHOD==METHOD_ACK) {
/* local ACK*/
t_release_transaction(t);
return 1;
}
if (((int)(long)flags)&TM_T_REPLY_nodnsfo_FLAG)
t->flags|=T_NO_DNS_FAILOVER_FLAG;
if (((int)(long)flags)&TM_T_REPLY_reason_FLAG)
t->flags|=T_CANCEL_REASON_FLAG;
update_cloned_msg_from_msg( t->uas.request, p_msg);
ret = t_forward_nonack( t, p_msg, p);
if (ret<=0 ) {
LM_ERR("t_forward_nonack failed\n");
ret = t_relay_inerr2scripterr();
}
}
if (p) {
free_proxy(p);
pkg_free(p);
}
return ret?ret:1;
route_err:
LM_CRIT("unsupported route type: %d\n", route_type);
return 0;
}
inline static int w_t_release(struct sip_msg* msg, char* str, char* str2)
{
struct cell *t;
if (t_check( msg , 0 )==-1) return -1;
t=get_t();
if ( t && t!=T_UNDEFINED )
return t_release_transaction( t );
return 1;
}
int t_unref( struct sip_msg* p_msg )
{
enum kill_reason kr;
if (T==T_UNDEFINED)
return -1;
if (T!=T_NULL_CELL) {
if (p_msg->first_line.type==SIP_REQUEST){
kr=get_kr();
if (kr==0 ||(p_msg->REQ_METHOD==METHOD_ACK && !(kr & REQ_RLSD)))
t_release_transaction(T);
}
UNREF( T );
}
set_t(T_UNDEFINED);
return 1;
}
int t_unref( struct sip_msg* p_msg )
{
enum kill_reason kr;
if (T==T_UNDEFINED || T==T_NULL_CELL)
return -1;
if (p_msg->first_line.type==SIP_REQUEST){
kr=get_kr();
if (kr==0
||(p_msg->REQ_METHOD==METHOD_ACK && !(kr & REQ_RLSD))) {
LOG(L_WARN, "WARNING: script writer didn't release transaction\n");
t_release_transaction(T);
}
}
UNREF( T );
set_t(T_UNDEFINED);
return 1;
}
/*
* Send a request using data from the dialog structure
*/
int t_uac(str* method, str* headers, str* body, dlg_t* dialog,
transaction_cb cb, void* cbp,release_tmcb_param release_func)
{
union sockaddr_union to_su, new_to_su;
struct cell *new_cell;
struct cell *backup_cell;
struct retr_buf *request;
static struct sip_msg *req;
struct usr_avp **backup;
char *buf, *buf1;
int buf_len, buf_len1;
int ret, flags, sflag_bk;
int backup_route_type;
int sip_msg_len;
unsigned int hi;
struct socket_info *new_send_sock;
str h_to, h_from, h_cseq, h_callid;
struct proxy_l *proxy, *new_proxy;
unsigned short dst_changed;
ret=-1;
/*** added by dcm
* - needed by external ua to send a request within a dlg
*/
if(!dialog->hooks.next_hop && w_calculate_hooks(dialog)<0)
goto error3;
if(dialog->obp.s)
dialog->hooks.next_hop = &dialog->obp;
LM_DBG("next_hop=<%.*s>\n",dialog->hooks.next_hop->len,
dialog->hooks.next_hop->s);
/* calculate the socket corresponding to next hop */
proxy = uri2proxy( dialog->hooks.next_hop,
dialog->send_sock ? dialog->send_sock->proto : PROTO_NONE );
if (proxy==0) {
ret=E_BAD_ADDRESS;
goto error3;
}
/* use the first address */
hostent2su( &to_su,
&proxy->host, proxy->addr_idx, proxy->port ? proxy->port:SIP_PORT);
/* check/discover the send socket */
if (dialog->send_sock) {
/* if already set, the protocol of send sock must have the
the same type as the proto required by destination URI */
if (proxy->proto != dialog->send_sock->proto)
dialog->send_sock = NULL;
}
if (dialog->send_sock==NULL) {
/* get the send socket */
dialog->send_sock = get_send_socket( NULL/*msg*/, &to_su, proxy->proto);
if (!dialog->send_sock) {
LM_ERR("no corresponding socket for af %d\n", to_su.s.sa_family);
ser_error = E_NO_SOCKET;
goto error2;
}
}
LM_DBG("sending socket is %.*s \n",
dialog->send_sock->name.len,dialog->send_sock->name.s);
/* ***** Create TRANSACTION and all related ***** */
new_cell = build_cell( NULL/*msg*/, 1/*full UAS clone*/);
if (!new_cell) {
ret=E_OUT_OF_MEM;
LM_ERR("short of cell shmem\n");
goto error2;
}
/* pass the transaction flags from dialog to transaction */
new_cell->flags |= dialog->T_flags;
/* add the callback the transaction for LOCAL_COMPLETED event */
flags = TMCB_LOCAL_COMPLETED;
/* Add also TMCB_LOCAL_RESPONSE_OUT if provisional replies are desired */
if (pass_provisional_replies || pass_provisional(new_cell))
flags |= TMCB_LOCAL_RESPONSE_OUT;
if(cb && insert_tmcb(&(new_cell->tmcb_hl),flags,cb,cbp,release_func)!=1){
ret=E_OUT_OF_MEM;
LM_ERR("short of tmcb shmem\n");
goto error2;
}
if (method->len==INVITE_LEN && memcmp(method->s, INVITE, INVITE_LEN)==0)
new_cell->flags |= T_IS_INVITE_FLAG;
new_cell->flags |= T_IS_LOCAL_FLAG;
request = &new_cell->uac[0].request;
if (dialog->forced_to_su.s.sa_family == AF_UNSPEC)
request->dst.to = to_su;
else
request->dst.to = dialog->forced_to_su;
request->dst.send_sock = dialog->send_sock;
request->dst.proto = dialog->send_sock->proto;
request->dst.proto_reserved1 = 0;
hi=dlg2hash(dialog);
LOCK_HASH(hi);
insert_into_hash_table_unsafe(new_cell, hi);
UNLOCK_HASH(hi);
/* copy AVPs into transaction */
new_cell->user_avps = dialog->avps;
dialog->avps = NULL;
/* ***** Create the message buffer ***** */
buf = build_uac_req(method, headers, body, dialog, 0, new_cell, &buf_len);
if (!buf) {
LM_ERR("failed to build message\n");
ret=E_OUT_OF_MEM;
goto error1;
}
if (local_rlist.a) {
LM_DBG("building sip_msg from buffer\n");
req = buf_to_sip_msg(buf, buf_len, dialog);
if (req==NULL) {
LM_ERR("failed to build sip_msg from buffer\n");
} else {
/* set this transaction as active one */
backup_cell = get_t();
set_t( new_cell );
/* set transaction AVP list */
backup = set_avp_list( &new_cell->user_avps );
/* backup script flags */
sflag_bk = getsflags();
/* disable parallel forking */
set_dset_state( 0 /*disable*/);
/* run the route */
swap_route_type( backup_route_type, LOCAL_ROUTE);
run_top_route( local_rlist.a, req);
set_route_type( backup_route_type );
/* transfer current message context back to t */
new_cell->uac[0].br_flags = getb0flags(req);
/* restore the prevoius active transaction */
set_t( backup_cell );
set_dset_state( 1 /*enable*/);
setsflagsval(sflag_bk);
set_avp_list( backup );
/* check for changes - if none, do not regenerate the buffer */
dst_changed = 1;
if (req->new_uri.s || req->force_send_socket!=dialog->send_sock ||
req->dst_uri.len != dialog->hooks.next_hop->len ||
memcmp(req->dst_uri.s,dialog->hooks.next_hop->s,req->dst_uri.len) ||
(dst_changed=0)==0 || req->add_rm || req->body_lumps){
new_send_sock = NULL;
/* do we also need to change the destination? */
if (dst_changed) {
/* calculate the socket corresponding to next hop */
new_proxy = uri2proxy(
req->dst_uri.s ? &(req->dst_uri) : &req->new_uri,
PROTO_NONE );
if (new_proxy==0)
goto abort_update;
/* use the first address */
hostent2su( &new_to_su,
&new_proxy->host, new_proxy->addr_idx,
new_proxy->port ? new_proxy->port:SIP_PORT);
/* get the send socket */
new_send_sock = get_send_socket( req, &new_to_su,
new_proxy->proto);
if (!new_send_sock) {
free_proxy( new_proxy );
pkg_free( new_proxy );
LM_ERR("no socket found for the new destination\n");
goto abort_update;
}
}
/* if interface change, we need to re-build the via */
if (new_send_sock && new_send_sock != dialog->send_sock) {
LM_DBG("Interface change in local route -> "
"rebuilding via\n");
if (!del_lump(req,req->h_via1->name.s - req->buf,
req->h_via1->len,0)) {
LM_ERR("Failed to remove initial via \n");
goto abort_update;
}
memcpy(req->add_to_branch_s,req->via1->branch->value.s,
req->via1->branch->value.len);
req->add_to_branch_len = req->via1->branch->value.len;
/* update also info about new destination and send sock */
dialog->send_sock = new_send_sock;
free_proxy( proxy );
pkg_free( proxy );
proxy = new_proxy;
request->dst.send_sock = new_send_sock;
request->dst.proto = new_send_sock->proto;
request->dst.proto_reserved1 = 0;
/* build the shm buffer now */
set_init_lump_flags(LUMPFLAG_BRANCH);
buf1 = build_req_buf_from_sip_req(req,
(unsigned int*)&buf_len1,
new_send_sock, new_send_sock->proto,
MSG_TRANS_SHM_FLAG);
reset_init_lump_flags();
del_flaged_lumps( &req->add_rm, LUMPFLAG_BRANCH);
} else {
LM_DBG("Change in local route -> rebuilding buffer\n");
/* build the shm buffer now */
buf1 = build_req_buf_from_sip_req(req,
(unsigned int*)&buf_len1,
dialog->send_sock, dialog->send_sock->proto,
MSG_TRANS_SHM_FLAG|MSG_TRANS_NOVIA_FLAG);
/* now as it used, hide the original VIA header */
del_lump(req,req->h_via1->name.s - req->buf,
req->h_via1->len, 0);
}
if (!buf1) {
LM_ERR("no more shm mem\n");
/* keep original buffer */
goto abort_update;
}
/* update shortcuts */
if(!req->add_rm && !req->new_uri.s) {
/* headers are not affected, simply tranlate */
new_cell->from.s = new_cell->from.s - buf + buf1;
new_cell->to.s = new_cell->to.s - buf + buf1;
new_cell->callid.s = new_cell->callid.s - buf + buf1;
new_cell->cseq_n.s = new_cell->cseq_n.s - buf + buf1;
} else {
/* use heavy artilery :D */
if (extract_ftc_hdrs( buf1, buf_len1, &h_from, &h_to,
&h_cseq, &h_callid)!=0 ) {
LM_ERR("failed to update shortcut pointers\n");
shm_free(buf1);
goto abort_update;
}
new_cell->from = h_from;
new_cell->to = h_to;
new_cell->callid = h_callid;
new_cell->cseq_n = h_cseq;
}
/* here we rely on how build_uac_req()
builds the first line */
new_cell->uac[0].uri.s = buf1 +
req->first_line.u.request.method.len + 1;
new_cell->uac[0].uri.len = GET_RURI(req)->len;
/* update also info about new destination and send sock */
if (new_send_sock)
request->dst.to = new_to_su;
shm_free(buf);
buf = buf1;
buf_len = buf_len1;
/* use new buffer */
} else {
/* no changes over the message, buffer is already generated,
just hide the original VIA for potential further branches */
del_lump(req,req->h_via1->name.s-req->buf,req->h_via1->len,0);
}
abort_update:
/* save the SIP message into transaction */
new_cell->uas.request = sip_msg_cloner( req, &sip_msg_len, 1);
if (new_cell->uas.request==NULL) {
/* reset any T triggering */
new_cell->on_negative = 0;
new_cell->on_reply = 0;
} else {
new_cell->uas.end_request=
((char*)new_cell->uas.request)+sip_msg_len;
}
/* no parallel support in UAC transactions */
new_cell->on_branch = 0;
free_sip_msg(req);
}
}
/* for DNS based failover, copy the DNS proxy into transaction */
if (!disable_dns_failover) {
new_cell->uac[0].proxy = shm_clone_proxy( proxy, 1/*do_free*/);
if (new_cell->uac[0].proxy==NULL)
LM_ERR("failed to store DNS info -> no DNS based failover\n");
}
new_cell->method.s = buf;
new_cell->method.len = method->len;
request->buffer.s = buf;
request->buffer.len = buf_len;
new_cell->nr_of_outgoings++;
if(last_localT) {
*last_localT = new_cell;
REF_UNSAFE(new_cell);
}
if (SEND_BUFFER(request) == -1) {
LM_ERR("attempt to send to '%.*s' failed\n",
dialog->hooks.next_hop->len,
dialog->hooks.next_hop->s);
}
if (method->len==ACK_LEN && memcmp(method->s, ACK, ACK_LEN)==0 ) {
t_release_transaction(new_cell);
} else {
start_retr(request);
}
free_proxy( proxy );
pkg_free( proxy );
return 1;
error1:
LOCK_HASH(hi);
remove_from_hash_table_unsafe(new_cell);
UNLOCK_HASH(hi);
free_cell(new_cell);
error2:
free_proxy( proxy );
pkg_free( proxy );
error3:
return ret;
}
/* WARNING: doesn't work from failure route (deadlock, uses t_reply => tries
* to get the reply lock again */
int t_relay_to( struct sip_msg *p_msg , struct proxy_l *proxy, int proto,
int replicate)
{
int ret;
int new_tran;
/* struct hdr_field *hdr; */
struct cell *t;
struct dest_info dst;
unsigned short port;
str host;
short comp;
#ifndef TM_DELAYED_REPLY
int reply_ret;
#endif
ret=0;
/* special case for CANCEL */
if ( p_msg->REQ_METHOD==METHOD_CANCEL){
ret=t_forward_cancel(p_msg, proxy, proto, &t);
if (t) goto handle_ret;
goto done;
}
new_tran = t_newtran( p_msg );
/* parsing error, memory alloc, whatever ... if via is bad
and we are forced to reply there, return with 0 (->break),
pass error status otherwise
MMA: return value E_SCRIPT means that transaction was already started
from the script so continue with that transaction
*/
if (likely(new_tran!=E_SCRIPT)) {
if (new_tran<0) {
ret = (ser_error==E_BAD_VIA && reply_to_via) ? 0 : new_tran;
goto done;
}
/* if that was a retransmission, return we are happily done */
if (new_tran==0) {
ret = 1;
goto done;
}
}else if (unlikely(p_msg->REQ_METHOD==METHOD_ACK)) {
/* transaction previously found (E_SCRIPT) and msg==ACK
=> ack to neg. reply or ack to local trans.
=> process it and exit */
/* FIXME: there's no way to distinguish here between acks to
local trans. and neg. acks */
/* in normal operation we should never reach this point, if we
do WARN(), it might hide some real bug (apart from possibly
hiding a bug the most harm done is calling the TMCB_ACK_NEG
callbacks twice) */
WARN("negative or local ACK caught, please report\n");
t=get_t();
if (unlikely(has_tran_tmcbs(t, TMCB_ACK_NEG_IN)))
run_trans_callbacks(TMCB_ACK_NEG_IN, t, p_msg, 0,
p_msg->REQ_METHOD);
t_release_transaction(t);
ret=1;
goto done;
}
/* new transaction */
/* at this point if the msg is an ACK it is an e2e ACK and
e2e ACKs do not establish a transaction and are fwd-ed statelessly */
if ( p_msg->REQ_METHOD==METHOD_ACK) {
DBG( "SER: forwarding ACK statelessly \n");
if (proxy==0) {
init_dest_info(&dst);
dst.proto=proto;
if (get_uri_send_info(GET_NEXT_HOP(p_msg), &host, &port,
&dst.proto, &comp)!=0){
ret=E_BAD_ADDRESS;
goto done;
}
#ifdef USE_COMP
dst.comp=comp;
#endif
/* dst->send_sock not set, but forward_request will take care
* of it */
ret=forward_request(p_msg, &host, port, &dst);
} else {
init_dest_info(&dst);
dst.proto=get_proto(proto, proxy->proto);
proxy2su(&dst.to, proxy);
/* dst->send_sock not set, but forward_request will take care
* of it */
ret=forward_request( p_msg , 0, 0, &dst) ;
}
goto done;
}
/* if replication flag is set, mark the transaction as local
so that replies will not be relayed */
t=get_t();
if (replicate) t->flags|=T_IS_LOCAL_FLAG;
/* INVITE processing might take long, particularly because of DNS
look-ups -- let upstream know we're working on it */
if (p_msg->REQ_METHOD==METHOD_INVITE && (t->flags&T_AUTO_INV_100)
&& (t->uas.status < 100)
) {
DBG( "SER: new INVITE\n");
if (!t_reply( t, p_msg , 100 ,
cfg_get(tm, tm_cfg, tm_auto_inv_100_r)))
DBG("SER: ERROR: t_reply (100)\n");
}
/* now go ahead and forward ... */
ret=t_forward_nonack(t, p_msg, proxy, proto);
handle_ret:
if (ret<=0) {
DBG( "t_forward_nonack returned error %d (%d)\n", ret, ser_error);
/* we don't want to pass upstream any reply regarding replicating
* a request; replicated branch must stop at us*/
if (likely(!replicate)) {
if(t->flags&T_DISABLE_INTERNAL_REPLY) {
/* flag set to don't generate the internal negative reply
* - let the transaction live further, processing should
* continue in config */
DBG("not generating immediate reply for error %d\n", ser_error);
tm_error=ser_error;
ret = -4;
goto done;
}
#ifdef TM_DELAYED_REPLY
/* current error in tm_error */
tm_error=ser_error;
set_kr(REQ_ERR_DELAYED);
DBG("%d error reply generation delayed \n", ser_error);
#else
reply_ret=kill_transaction( t, ser_error );
if (reply_ret>0) {
/* we have taken care of all -- do nothing in
script */
DBG("ERROR: generation of a stateful reply "
"on error succeeded\n");
/*ret=0; -- we don't want to stop the script */
} else {
DBG("ERROR: generation of a stateful reply "
"on error failed\n");
t_release_transaction(t);
}
#endif /* TM_DELAYED_REPLY */
}else{
t_release_transaction(t); /* kill it silently */
}
} else {
DBG( "SER: new transaction fwd'ed\n");
}
done:
return ret;
}
/* Continues the SIP request processing previously saved by
* t_suspend(). The script does not continue from the same
* point, but a separate route block is executed instead.
*
* Return value:
* 0 - success
* <0 - failure
*/
int t_continue(unsigned int hash_index, unsigned int label,
struct action *route)
{
struct cell *t;
struct sip_msg faked_req;
struct cancel_info cancel_data;
int branch;
struct ua_client *uac =NULL;
int ret;
int cb_type;
int msg_status;
int last_uac_status;
int reply_status;
int do_put_on_wait;
struct hdr_field *hdr, *prev = 0, *tmp = 0;
if (t_lookup_ident(&t, hash_index, label) < 0) {
LM_ERR("transaction not found\n");
return -1;
}
if (!(t->flags & T_ASYNC_SUSPENDED)) {
LM_WARN("transaction is not suspended [%u:%u]\n", hash_index, label);
return -2;
}
if (t->flags & T_CANCELED) {
t->flags &= ~T_ASYNC_SUSPENDED;
/* The transaction has already been canceled,
* needless to continue */
UNREF(t); /* t_unref would kill the transaction */
/* reset T as we have no working T anymore */
set_t(T_UNDEFINED, T_BR_UNDEFINED);
return 1;
}
/* The transaction has to be locked to protect it
* form calling t_continue() multiple times simultaneously */
LOCK_ASYNC_CONTINUE(t);
t->flags |= T_ASYNC_CONTINUE; /* we can now know anywhere in kamailio
* that we are executing post a suspend */
/* which route block type were we in when we were suspended */
cb_type = FAILURE_CB_TYPE;;
switch (t->async_backup.backup_route) {
case REQUEST_ROUTE:
cb_type = FAILURE_CB_TYPE;
break;
case FAILURE_ROUTE:
cb_type = FAILURE_CB_TYPE;
break;
case TM_ONREPLY_ROUTE:
cb_type = ONREPLY_CB_TYPE;
break;
case BRANCH_ROUTE:
cb_type = FAILURE_CB_TYPE;
break;
}
if(t->async_backup.backup_route != TM_ONREPLY_ROUTE){
branch = t->async_backup.blind_uac; /* get the branch of the blind UAC setup
* during suspend */
if (branch >= 0) {
stop_rb_timers(&t->uac[branch].request);
if (t->uac[branch].last_received != 0) {
/* Either t_continue() has already been
* called or the branch has already timed out.
* Needless to continue. */
t->flags &= ~T_ASYNC_SUSPENDED;
UNLOCK_ASYNC_CONTINUE(t);
UNREF(t); /* t_unref would kill the transaction */
return 1;
}
/* Set last_received to something >= 200,
* the actual value does not matter, the branch
* will never be picked up for response forwarding.
* If last_received is lower than 200,
* then the branch may tried to be cancelled later,
* for example when t_reply() is called from
* a failure route => deadlock, because both
* of them need the reply lock to be held. */
t->uac[branch].last_received=500;
uac = &t->uac[branch];
}
/* else
Not a huge problem, fr timer will fire, but CANCEL
will not be sent. last_received will be set to 408. */
/* We should not reset kr here to 0 as it's quite possible before continuing the dev. has correctly set the
* kr by, for example, sending a transactional reply in code - resetting here will cause a dirty log message
* "WARNING: script writer didn't release transaction" to appear in log files. TODO: maybe we need to add
* a special kr for async?
* reset_kr();
*/
/* fake the request and the environment, like in failure_route */
if (!fake_req(&faked_req, t->uas.request, 0 /* extra flags */, uac)) {
LM_ERR("building fake_req failed\n");
ret = -1;
goto kill_trans;
}
faked_env( t, &faked_req, 1);
/* execute the pre/post -script callbacks based on original route block */
if (exec_pre_script_cb(&faked_req, cb_type)>0) {
if (run_top_route(route, &faked_req, 0)<0)
LM_ERR("failure inside run_top_route\n");
exec_post_script_cb(&faked_req, cb_type);
}
/* TODO: save_msg_lumps should clone the lumps to shm mem */
/* restore original environment and free the fake msg */
faked_env( t, 0, 1);
free_faked_req(&faked_req, t);
/* update the flags */
t->uas.request->flags = faked_req.flags;
if (t->uas.status < 200) {
/* No final reply has been sent yet.
* Check whether or not there is any pending branch.
*/
for ( branch = 0;
branch < t->nr_of_outgoings;
branch++
) {
if (t->uac[branch].last_received < 200)
break;
}
if (branch == t->nr_of_outgoings) {
/* There is not any open branch so there is
* no chance that a final response will be received. */
ret = 0;
goto kill_trans;
}
}
} else {
branch = t->async_backup.backup_branch;
init_cancel_info(&cancel_data);
LM_DBG("continuing from a suspended reply"
" - resetting the suspend branch flag\n");
if (t->uac[branch].reply) {
t->uac[branch].reply->msg_flags &= ~FL_RPL_SUSPENDED;
} else {
LM_WARN("no reply in t_continue for branch. not much we can do\n");
return 0;
}
if (t->uas.request) t->uas.request->msg_flags&= ~FL_RPL_SUSPENDED;
faked_env( t, t->uac[branch].reply, 1);
if (exec_pre_script_cb(t->uac[branch].reply, cb_type)>0) {
if (run_top_route(route, t->uac[branch].reply, 0)<0){
LOG(L_ERR, "ERROR: t_continue_reply: Error in run_top_route\n");
}
exec_post_script_cb(t->uac[branch].reply, cb_type);
}
LM_DBG("restoring previous environment");
faked_env( t, 0, 1);
/*lock transaction replies - will be unlocked when reply is relayed*/
LOCK_REPLIES( t );
if ( is_local(t) ) {
LM_DBG("t is local - sending reply with status code: [%d]\n",
t->uac[branch].reply->first_line.u.reply.statuscode);
reply_status = local_reply( t, t->uac[branch].reply, branch,
t->uac[branch].reply->first_line.u.reply.statuscode,
&cancel_data );
if (reply_status == RPS_COMPLETED) {
/* no more UAC FR/RETR (if I received a 2xx, there may
* be still pending branches ...
*/
cleanup_uac_timers( t );
if (is_invite(t)) cancel_uacs(t, &cancel_data, F_CANCEL_B_KILL);
/* There is no need to call set_final_timer because we know
* that the transaction is local */
put_on_wait(t);
}else if (unlikely(cancel_data.cancel_bitmap)){
/* cancel everything, even non-INVITEs (e.g in case of 6xx), use
* cancel_b_method for canceling unreplied branches */
cancel_uacs(t, &cancel_data, cfg_get(tm,tm_cfg, cancel_b_flags));
}
} else {
LM_DBG("t is not local - relaying reply with status code: [%d]\n",
t->uac[branch].reply->first_line.u.reply.statuscode);
do_put_on_wait = 0;
if(t->uac[branch].reply->first_line.u.reply.statuscode>=200){
do_put_on_wait = 1;
}
reply_status=relay_reply( t, t->uac[branch].reply, branch,
t->uac[branch].reply->first_line.u.reply.statuscode,
&cancel_data, do_put_on_wait );
if (reply_status == RPS_COMPLETED) {
/* no more UAC FR/RETR (if I received a 2xx, there may
be still pending branches ...
*/
cleanup_uac_timers( t );
/* 2xx is a special case: we can have a COMPLETED request
* with branches still open => we have to cancel them */
if (is_invite(t) && cancel_data.cancel_bitmap)
cancel_uacs( t, &cancel_data, F_CANCEL_B_KILL);
/* FR for negative INVITES, WAIT anything else */
/* Call to set_final_timer is embedded in relay_reply to avoid
* race conditions when reply is sent out and an ACK to stop
* retransmissions comes before retransmission timer is set.*/
}else if (unlikely(cancel_data.cancel_bitmap)){
/* cancel everything, even non-INVITEs (e.g in case of 6xx), use
* cancel_b_method for canceling unreplied branches */
cancel_uacs(t, &cancel_data, cfg_get(tm,tm_cfg, cancel_b_flags));
}
}
t->uac[branch].request.flags|=F_RB_REPLIED;
if (reply_status==RPS_ERROR){
goto done;
}
/* update FR/RETR timers on provisional replies */
msg_status=t->uac[branch].reply->REPLY_STATUS;
last_uac_status=t->uac[branch].last_received;
if (is_invite(t) && msg_status<200 &&
( cfg_get(tm, tm_cfg, restart_fr_on_each_reply) ||
( (last_uac_status<msg_status) &&
((msg_status>=180) || (last_uac_status==0)) )
) ) { /* provisional now */
restart_rb_fr(& t->uac[branch].request, t->fr_inv_timeout);
t->uac[branch].request.flags|=F_RB_FR_INV; /* mark fr_inv */
}
}
done:
UNLOCK_ASYNC_CONTINUE(t);
if(t->async_backup.backup_route != TM_ONREPLY_ROUTE){
/* unref the transaction */
t_unref(t->uas.request);
} else {
tm_ctx_set_branch_index(T_BR_UNDEFINED);
/* unref the transaction */
t_unref(t->uac[branch].reply);
LOG(L_DBG,"DEBUG: t_continue_reply: Freeing earlier cloned reply\n");
/* free lumps that were added during reply processing */
del_nonshm_lump( &(t->uac[branch].reply->add_rm) );
del_nonshm_lump( &(t->uac[branch].reply->body_lumps) );
del_nonshm_lump_rpl( &(t->uac[branch].reply->reply_lump) );
/* free header's parsed structures that were added */
for( hdr=t->uac[branch].reply->headers ; hdr ; hdr=hdr->next ) {
if ( hdr->parsed && hdr_allocs_parse(hdr) &&
(hdr->parsed<(void*)t->uac[branch].reply ||
hdr->parsed>=(void*)t->uac[branch].end_reply)) {
clean_hdr_field(hdr);
hdr->parsed = 0;
}
}
/* now go through hdr_fields themselves and remove the pkg allocated space */
hdr = t->uac[branch].reply->headers;
while (hdr) {
if ( hdr && ((void*)hdr<(void*)t->uac[branch].reply ||
(void*)hdr>=(void*)t->uac[branch].end_reply)) {
//this header needs to be freed and removed form the list.
if (!prev) {
t->uac[branch].reply->headers = hdr->next;
} else {
prev->next = hdr->next;
}
tmp = hdr;
hdr = hdr->next;
pkg_free(tmp);
} else {
prev = hdr;
hdr = hdr->next;
}
}
sip_msg_free(t->uac[branch].reply);
t->uac[branch].reply = 0;
}
/*This transaction is no longer suspended so unsetting the SUSPEND flag*/
t->flags &= ~T_ASYNC_SUSPENDED;
return 0;
kill_trans:
t->flags &= ~T_ASYNC_SUSPENDED;
/* The script has hopefully set the error code. If not,
* let us reply with a default error. */
if ((kill_transaction_unsafe(t,
tm_error ? tm_error : E_UNSPEC)) <=0
) {
LOG(L_ERR, "ERROR: t_continue: "
"reply generation failed\n");
/* The transaction must be explicitely released,
* no more timer is running */
UNLOCK_ASYNC_CONTINUE(t);
t_release_transaction(t);
} else {
UNLOCK_ASYNC_CONTINUE(t);
}
if(t->async_backup.backup_route != TM_ONREPLY_ROUTE){
t_unref(t->uas.request);
} else {
/* unref the transaction */
t_unref(t->uac[branch].reply);
}
return ret;
}
/* WARNING: doesn't work from failure route (deadlock, uses t_reply => tries
* to get the reply lock again */
int t_relay_to( struct sip_msg *p_msg , struct proxy_l *proxy, int proto,
int replicate)
{
int ret;
int new_tran;
int reply_ret;
/* struct hdr_field *hdr; */
struct cell *t;
struct dest_info dst;
unsigned short port;
str host;
short comp;
ret=0;
new_tran = t_newtran( p_msg );
/* parsing error, memory alloc, whatever ... if via is bad
and we are forced to reply there, return with 0 (->break),
pass error status otherwise
MMA: return value E_SCRIPT means that transaction was already started from the script
so continue with that transaction
*/
if (new_tran!=E_SCRIPT) {
if (new_tran<0) {
ret = (ser_error==E_BAD_VIA && reply_to_via) ? 0 : new_tran;
goto done;
}
/* if that was a retransmission, return we are happily done */
if (new_tran==0) {
ret = 1;
goto done;
}
}
/* new transaction */
/* ACKs do not establish a transaction and are fwd-ed statelessly */
if ( p_msg->REQ_METHOD==METHOD_ACK) {
DBG( "SER: forwarding ACK statelessly \n");
if (proxy==0) {
init_dest_info(&dst);
dst.proto=proto;
if (get_uri_send_info(GET_NEXT_HOP(p_msg), &host, &port,
&dst.proto, &comp)!=0){
ret=E_BAD_ADDRESS;
goto done;
}
#ifdef USE_COMP
dst.comp=comp;
#endif
/* dst->send_sock not set, but forward_request will take care
* of it */
ret=forward_request(p_msg, &host, port, &dst);
} else {
init_dest_info(&dst);
dst.proto=get_proto(proto, proxy->proto);
proxy2su(&dst.to, proxy);
/* dst->send_sock not set, but forward_request will take care
* of it */
ret=forward_request( p_msg , 0, 0, &dst) ;
}
goto done;
}
/* if replication flag is set, mark the transaction as local
so that replies will not be relayed */
t=get_t();
if (replicate) t->flags|=T_IS_LOCAL_FLAG;
/* INVITE processing might take long, particularly because of DNS
look-ups -- let upstream know we're working on it */
if (p_msg->REQ_METHOD==METHOD_INVITE )
{
DBG( "SER: new INVITE\n");
if (!t_reply( t, p_msg , 100 ,
"trying -- your call is important to us"))
DBG("SER: ERROR: t_reply (100)\n");
}
/* now go ahead and forward ... */
ret=t_forward_nonack(t, p_msg, proxy, proto);
if (ret<=0) {
DBG( "ERROR:tm:t_relay_to: t_forward_nonack returned error \n");
/* we don't want to pass upstream any reply regarding replicating
* a request; replicated branch must stop at us*/
if (!replicate) {
reply_ret=kill_transaction( t );
if (reply_ret>0) {
/* we have taken care of all -- do nothing in
script */
DBG("ERROR: generation of a stateful reply "
"on error succeeded\n");
/*ret=0; -- we don't want to stop the script */
} else {
DBG("ERROR: generation of a stateful reply "
"on error failed\n");
t_release_transaction(t);
}
}else{
t_release_transaction(t); /* kill it silently */
}
} else {
DBG( "SER: new transaction fwd'ed\n");
}
done:
return ret;
}
/* atomic "new_tran" construct; it returns:
<0 on error
+1 if a request did not match a transaction
- it that was an ack, the calling function
shall forward statelessly
- otherwise it means, a new transaction was
introduced and the calling function
shall reply/relay/whatever_appropriate
0 on retransmission
*/
int t_newtran( struct sip_msg* p_msg )
{
int lret, my_err;
int canceled;
/* is T still up-to-date ? */
DBG("DEBUG: t_newtran: msg id=%d , global msg id=%d ,"
" T on entrance=%p\n",p_msg->id,global_msg_id,T);
if ( T && T!=T_UNDEFINED ) {
/* ERROR message moved to w_t_newtran */
DBG("DEBUG: t_newtran: "
"transaction already in process %p\n", T );
return E_SCRIPT;
}
global_msg_id = p_msg->id;
T = T_UNDEFINED;
/* first of all, parse everything -- we will store in shared memory
and need to have all headers ready for generating potential replies
later; parsing later on demand is not an option since the request
will be in shmem and applying parse_headers to it would intermix
shmem with pkg_mem
*/
if (parse_headers(p_msg, HDR_EOH_F, 0 )) {
LOG(L_ERR, "ERROR: t_newtran: parse_headers failed\n");
return E_BAD_REQ;
}
if ((p_msg->parsed_flag & HDR_EOH_F)!=HDR_EOH_F) {
LOG(L_ERR, "ERROR: t_newtran: EoH not parsed\n");
return E_OUT_OF_MEM;
}
/* t_lookup_requests attempts to find the transaction;
it also calls check_transaction_quadruple -> it is
safe to assume we have from/callid/cseq/to
*/
lret = t_lookup_request( p_msg, 1 /* leave locked if not found */,
&canceled );
/* on error, pass the error in the stack ... nothing is locked yet
if 0 is returned */
if (lret==0) return E_BAD_TUPEL;
/* transaction found, it's a retransmission */
if (lret>0) {
if (p_msg->REQ_METHOD==METHOD_ACK) {
t_release_transaction(T);
} else {
t_retransmit_reply(T);
}
/* things are done -- return from script */
return 0;
}
/* from now on, be careful -- hash table is locked */
if (lret==-2) { /* was it an e2e ACK ? if so, trigger a callback */
/* no callbacks? complete quickly */
if ( !has_tran_tmcbs(t_ack,TMCB_E2EACK_IN) ) {
UNLOCK_HASH(p_msg->hash_index);
return 1;
}
REF_UNSAFE(t_ack);
UNLOCK_HASH(p_msg->hash_index);
/* we don't call from within REPLY_LOCK -- that introduces
* a race condition; however, it is so unlikely and the
* impact is so small (callback called multiple times of
* multiple ACK/200s received in parallel), that we do not
* better waste time in locks */
if (unmatched_totag(t_ack, p_msg)) {
run_trans_callbacks( TMCB_E2EACK_IN , t_ack, p_msg, 0,
-p_msg->REQ_METHOD );
}
UNREF(t_ack);
return 1;
}
/* transaction not found, it's a new request (lret<0, lret!=-2);
establish a new transaction ... */
if (p_msg->REQ_METHOD==METHOD_ACK) { /* ... unless it is in ACK */
my_err=1;
goto new_err;
}
my_err=new_t(p_msg);
if (my_err<0) {
LOG(L_ERR, "ERROR: t_newtran: new_t failed\n");
goto new_err;
}
if (canceled) T->flags|=T_CANCELED; /* mark it for future ref. */
UNLOCK_HASH(p_msg->hash_index);
/* now, when the transaction state exists, check if
there is a meaningful Via and calculate it; better
do it now than later: state is established so that
subsequent retransmissions will be absorbed and will
not possibly block during Via DNS resolution; doing
it later would only burn more CPU as if there is an
error, we cannot relay later whatever comes out of the
the transaction
*/
if (!init_rb( &T->uas.response, p_msg)) {
LOG(L_ERR, "ERROR: t_newtran: unresolvable via1\n");
put_on_wait( T );
t_unref(p_msg);
return E_BAD_VIA;
}
return 1;
new_err:
UNLOCK_HASH(p_msg->hash_index);
return my_err;
}
/*
* Send a request using data from the dialog structure
*/
int t_uac(str* method, str* headers, str* body, dlg_t* dialog,
transaction_cb cb, void* cbp,release_tmcb_param release_func)
{
union sockaddr_union to_su;
struct cell *new_cell;
struct retr_buf *request;
static struct sip_msg *req;
struct usr_avp **backup;
char *buf, *buf1;
int buf_len, buf_len1;
int ret, flags, sflag_bk;
int backup_route_type;
unsigned int hi;
struct socket_info* send_sock;
ret=-1;
/*** added by dcm
* - needed by external ua to send a request within a dlg
*/
if(!dialog->hooks.next_hop && w_calculate_hooks(dialog)<0)
goto error2;
if(dialog->obp.s)
dialog->hooks.next_hop = &dialog->obp;
LM_DBG("next_hop=<%.*s>\n",dialog->hooks.next_hop->len,
dialog->hooks.next_hop->s);
/* calculate the socket corresponding to next hop */
send_sock = uri2sock(0, dialog->hooks.next_hop, &to_su,
PROTO_NONE);
if (send_sock==0) {
ret=ser_error;
LM_ERR("no socket found\n");
goto error2;
}
/* if a send socket defined verify if the same protocol */
if(dialog->send_sock) {
if(send_sock->proto != dialog->send_sock->proto)
{
dialog->send_sock = send_sock;
}
}
else
{
dialog->send_sock = send_sock;
}
new_cell = build_cell(0);
if (!new_cell) {
ret=E_OUT_OF_MEM;
LM_ERR("short of cell shmem\n");
goto error2;
}
/* pass the transaction flags from dialog to transaction */
new_cell->flags |= dialog->T_flags;
/* add the callback the transaction for LOCAL_COMPLETED event */
flags = TMCB_LOCAL_COMPLETED;
/* Add also TMCB_LOCAL_RESPONSE_OUT if provisional replies are desired */
if (pass_provisional_replies || pass_provisional(new_cell))
flags |= TMCB_LOCAL_RESPONSE_OUT;
if(cb && insert_tmcb(&(new_cell->tmcb_hl),flags,cb,cbp,release_func)!=1){
ret=E_OUT_OF_MEM;
LM_ERR("short of tmcb shmem\n");
goto error2;
}
if (method->len==INVITE_LEN && memcmp(method->s, INVITE, INVITE_LEN)==0)
new_cell->flags |= T_IS_INVITE_FLAG;
new_cell->flags |= T_IS_LOCAL_FLAG;
request = &new_cell->uac[0].request;
request->dst.to = to_su;
request->dst.send_sock = dialog->send_sock;
request->dst.proto = dialog->send_sock->proto;
request->dst.proto_reserved1 = 0;
hi=dlg2hash(dialog);
LOCK_HASH(hi);
insert_into_hash_table_unsafe(new_cell, hi);
UNLOCK_HASH(hi);
buf = build_uac_req(method, headers, body, dialog, 0, new_cell, &buf_len);
if (!buf) {
LM_ERR("failed to build message\n");
ret=E_OUT_OF_MEM;
goto error1;
}
if (local_rlist.a) {
LM_DBG("building sip_msg from buffer\n");
req = buf_to_sip_msg(buf, buf_len, dialog);
if (req==NULL) {
LM_ERR("failed to build sip_msg from buffer");
} else {
/* set transaction AVP list */
backup = set_avp_list( &new_cell->user_avps );
/* backup script flags */
sflag_bk = getsflags();
/* disable parallel forking */
set_dset_state( 0 /*disable*/);
/* transfer current message context back to t */
new_cell->uac[0].br_flags = req->flags;
/* run the route */
swap_route_type( backup_route_type, LOCAL_ROUTE);
run_top_route( local_rlist.a, req);
set_route_type( backup_route_type );
set_dset_state( 1 /*enable*/);
setsflagsval(sflag_bk);
set_avp_list( backup );
/* check for changes - if none, do not regenerate the buffer
* we ignore any change on RURI and DSTURI and they should not
* be changed -bogdan */
if (req->new_uri.s)
{ pkg_free(req->new_uri.s); req->new_uri.s=0; req->new_uri.len=0; }
if (req->dst_uri.s)
{ pkg_free(req->dst_uri.s); req->dst_uri.s=0; req->dst_uri.len=0; }
if (req->add_rm || req->body_lumps) {
LM_DBG("re-building the buffer (sip_msg changed) - lumps are"
"%p %p\n",req->add_rm, req->body_lumps);
/* build the shm buffer now */
buf1 = build_req_buf_from_sip_req(req,(unsigned int*)&buf_len1,
dialog->send_sock, dialog->send_sock->proto,
MSG_TRANS_SHM_FLAG|MSG_TRANS_NOVIA_FLAG );
if (!buf1) {
LM_ERR("no more shm mem\n");
/* keep original buffer */
} else {
shm_free(buf);
buf = buf1;
buf_len = buf_len1;
/* use new buffer */
}
}
free_sip_msg(req);
}
}
new_cell->method.s = buf;
new_cell->method.len = method->len;
request->buffer.s = buf;
request->buffer.len = buf_len;
new_cell->nr_of_outgoings++;
if(last_localT)
{
*last_localT = new_cell;
REF_UNSAFE(new_cell);
}
if (SEND_BUFFER(request) == -1) {
LM_ERR("attempt to send to '%.*s' failed\n",
dialog->hooks.next_hop->len,
dialog->hooks.next_hop->s);
}
if (method->len==ACK_LEN && memcmp(method->s, ACK, ACK_LEN)==0 ) {
t_release_transaction(new_cell);
} else {
start_retr(request);
}
return 1;
error1:
LOCK_HASH(hi);
remove_from_hash_table_unsafe(new_cell);
UNLOCK_HASH(hi);
free_cell(new_cell);
error2:
return ret;
}
/* atomic "new_tran" construct; it returns:
<0 on error
+1 if a request did not match a transaction
- it that was an ack, the calling function
shall forward statelessly
- otherwise it means, a new transaction was
introduced and the calling function
shall reply/relay/whatever_appropriate
0 on retransmission
*/
int t_newtran( struct sip_msg* p_msg, int full_uas )
{
int lret, my_err;
context_p ctx_backup;
/* is T still up-to-date ? */
LM_DBG("transaction on entrance=%p\n",T);
if ( T && T!=T_UNDEFINED ) {
LM_DBG("transaction already in process %p\n", T );
return E_SCRIPT;
}
T = T_UNDEFINED;
/* first of all, parse everything -- we will store in shared memory
and need to have all headers ready for generating potential replies
later; parsing later on demand is not an option since the request
will be in shmem and applying parse_headers to it would intermix
shmem with pkg_mem
*/
if (parse_headers(p_msg, HDR_EOH_F, 0 )<0) {
LM_ERR("parse_headers failed\n");
return E_BAD_REQ;
}
if ((p_msg->parsed_flag & HDR_EOH_F)!=HDR_EOH_F) {
LM_ERR("EoH not parsed\n");
return E_OUT_OF_MEM;
}
/* t_lookup_requests attempts to find the transaction;
it also calls check_transaction_quadruple -> it is
safe to assume we have from/callid/cseq/to
*/
lret = t_lookup_request( p_msg, 1 /* leave locked if not found */ );
/* on error, pass the error in the stack ... nothing is locked yet
if 0 is returned */
if (lret==0) return E_BAD_TUPEL;
/* transaction found, it's a retransmission */
if (lret>0) {
if (p_msg->REQ_METHOD==METHOD_ACK) {
t_release_transaction(T);
} else {
t_retransmit_reply(T);
}
/* hide the transaction from the upper layer */
t_unref( p_msg );
/* things are done -- return from script */
return 0;
}
/* from now on, be careful -- hash table is locked */
if (lret==-2) { /* was it an e2e ACK ? if so, trigger a callback */
if (e2eack_T->relaied_reply_branch==-2) {
/* if a ACK for a local replied transaction, release the
INVITE transaction and break the script -> simply absorb
the ACK request */
t_release_transaction(e2eack_T);
return 0;
}
LM_DBG("building branch for end2end ACK - flags=%X\n",e2eack_T->flags);
/* to ensure unigueness acros time and space, compute the ACK
* branch in the same maner as for INVITE, but put a t->branch
* value that cannot exist for that INVITE - as it is compute as
* an INVITE, it will not overlapp with other INVITEs or requests.
* But the faked value for t->branch guarantee no overalap with
* corresponding INVITE --bogdan */
if (!t_calc_branch(e2eack_T, e2eack_T->nr_of_outgoings+1,
p_msg->add_to_branch_s, &p_msg->add_to_branch_len )) {
LM_ERR("ACK branch computation failed\n");
}
return 1;
}
/* transaction not found, it's a new request (lret<0, lret!=-2);
establish a new transaction ... */
if (p_msg->REQ_METHOD==METHOD_ACK) /* ... unless it is in ACK */
return 1;
my_err=new_t(p_msg, full_uas);
if (my_err<0) {
LM_ERR("new_t failed\n");
goto new_err;
}
UNLOCK_HASH(p_msg->hash_index);
/* now, when the transaction state exists, check if
there is a meaningful Via and calculate it; better
do it now than later: state is established so that
subsequent retransmissions will be absorbed and will
not possibly block during Via DNS resolution; doing
it later would only burn more CPU as if there is an
error, we cannot relay later whatever comes out of the
the transaction
*/
if (!init_rb( &T->uas.response, p_msg)) {
LM_ERR("unresolvable via1\n");
put_on_wait( T );
t_unref(p_msg);
return E_BAD_VIA;
}
if (auto_100trying && p_msg->REQ_METHOD==METHOD_INVITE) {
ctx_backup = current_processing_ctx;
current_processing_ctx = NULL;
t_reply( T, p_msg , 100 , &relay_reason_100);
current_processing_ctx = ctx_backup;
}
return 1;
new_err:
UNLOCK_HASH(p_msg->hash_index);
return my_err;
}