/* generate a fake reply
* it assumes the REPLY_LOCK is already held and returns unlocked */
static void fake_reply(struct cell *t, int branch, int code)
{
struct cancel_info cancel_data;
short do_cancel_branch;
enum rps reply_status;
init_cancel_info(&cancel_data);
do_cancel_branch = is_invite(t) && prepare_cancel_branch(t, branch, 0);
/* mark branch as canceled */
t->uac[branch].request.flags |= F_RB_CANCELED;
t->uac[branch].request.flags |= F_RB_RELAYREPLY;
if(is_local(t)) {
reply_status = local_reply(t, FAKED_REPLY, branch, code, &cancel_data);
} else {
/* rely reply, but don't put on wait, we still need t
* to send the cancels */
reply_status =
relay_reply(t, FAKED_REPLY, branch, code, &cancel_data, 0);
}
/* now when out-of-lock do the cancel I/O */
#ifdef CANCEL_REASON_SUPPORT
if(do_cancel_branch)
cancel_branch(t, branch, &cancel_data.reason, 0);
#else /* CANCEL_REASON_SUPPORT */
if(do_cancel_branch)
cancel_branch(t, branch, 0);
#endif /* CANCEL_REASON_SUPPORT */
/* it's cleaned up on error; if no error occurred and transaction
completed regularly, I have to clean-up myself
*/
if(reply_status == RPS_COMPLETED)
put_on_wait(t);
}
/* cancel branches scheduled for deletion
* params: t - transaction
* cancel_data - structure filled with the cancel bitmap (bitmap with
* the branches that are supposed to be canceled) and
* the cancel reason.
* flags - how_to_cancel flags, see cancel_branch()
* returns: bitmap with the still active branches (on fr timer)
* WARNING: always fill cancel_data->cancel_bitmap using prepare_to_cancel(),
* supplying values in any other way is a bug*/
int cancel_uacs( struct cell *t, struct cancel_info* cancel_data, int flags)
{
int i;
int ret;
int r;
ret=0;
cancel_reason_text(cancel_data);
/* cancel pending client transactions, if any */
for( i=0 ; i<t->nr_of_outgoings ; i++ )
if (cancel_data->cancel_bitmap & (1<<i)){
r=cancel_branch(
t,
i,
#ifdef CANCEL_REASON_SUPPORT
&cancel_data->reason,
#endif /* CANCEL_REASON_SUPPORT */
flags | ((t->uac[i].request.buffer==NULL)?
F_CANCEL_B_FAKE_REPLY:0) /* blind UAC? */
);
ret|=(r!=0)<<i;
}
return ret;
}
/* cancel branches scheduled for deletion */
void cancel_uacs( struct cell *t, branch_bm_t cancel_bm )
{
int i;
/* cancel pending client transactions, if any */
for( i=0 ; i<t->nr_of_outgoings ; i++ )
if (cancel_bm & (1<<i))
cancel_branch(t, i);
}
/* This function is called whenever a reply for our module is received;
* we need to register this function on module initialization;
* Returns : 0 - core router stops
* 1 - core router relay statelessly
*/
int reply_received( struct sip_msg *p_msg )
{
int msg_status;
int last_uac_status;
int branch;
int reply_status;
utime_t timer;
/* has the transaction completed now and we need to clean-up? */
branch_bm_t cancel_bitmap;
struct ua_client *uac;
struct cell *t;
struct usr_avp **backup_list;
unsigned int has_reply_route;
set_t(T_UNDEFINED);
/* make sure we know the associated transaction ... */
if (t_check(p_msg, &branch ) == -1) goto not_found;
/*... if there is none, tell the core router to fwd statelessly */
t = get_t();
if ((t == 0) || (t == T_UNDEFINED)) goto not_found;
cancel_bitmap=0;
msg_status=p_msg->REPLY_STATUS;
uac=&t->uac[branch];
LM_DBG("org. status uas=%d, uac[%d]=%d local=%d is_invite=%d)\n",
t->uas.status, branch, uac->last_received,
is_local(t), is_invite(t));
last_uac_status=uac->last_received;
if_update_stat( tm_enable_stats, tm_rcv_rpls , 1);
/* it's a cancel which is not e2e ? */
if ( get_cseq(p_msg)->method_id==METHOD_CANCEL && is_invite(t) ) {
/* ... then just stop timers */
reset_timer( &uac->local_cancel.retr_timer);
if ( msg_status >= 200 ) {
reset_timer( &uac->local_cancel.fr_timer);
}
LM_DBG("reply to local CANCEL processed\n");
goto done;
}
/* *** stop timers *** */
/* stop retransmission */
reset_timer(&uac->request.retr_timer);
/* stop final response timer only if I got a final response */
if ( msg_status >= 200 ) {
reset_timer( &uac->request.fr_timer);
}
/* acknowledge negative INVITE replies (do it before detailed
* on_reply processing, which may take very long, like if it
* is attempted to establish a TCP connection to a fail-over dst */
if (is_invite(t) && ((msg_status >= 300) ||
(is_local(t) && !no_autoack(t) && msg_status >= 200) )) {
if (send_ack(p_msg, t, branch)!=0)
LM_ERR("failed to send ACK (local=%s)\n", is_local(t)?"yes":"no");
}
_tm_branch_index = branch;
/* processing of on_reply block */
has_reply_route = (t->on_reply) || (t->uac[branch].on_reply);
if (has_reply_route) {
if (onreply_avp_mode) {
/* lock the reply*/
LOCK_REPLIES( t );
/* set the as avp_list the one from transaction */
backup_list = set_avp_list(&t->user_avps);
} else {
backup_list = 0;
}
/* transfer transaction flag to branch context */
p_msg->flags = t->uas.request->flags;
setb0flags(t->uac[branch].br_flags);
/* run block - first per branch and then global one */
if ( t->uac[branch].on_reply &&
(run_top_route(onreply_rlist[t->uac[branch].on_reply].a,p_msg)
&ACT_FL_DROP) && (msg_status<200) ) {
if (onreply_avp_mode) {
UNLOCK_REPLIES( t );
set_avp_list( backup_list );
}
LM_DBG("dropping provisional reply %d\n", msg_status);
goto done;
}
if ( t->on_reply && (run_top_route(onreply_rlist[t->on_reply].a,p_msg)
&ACT_FL_DROP) && (msg_status<200) ) {
if (onreply_avp_mode) {
UNLOCK_REPLIES( t );
set_avp_list( backup_list );
}
LM_DBG("dropping provisional reply %d\n", msg_status);
goto done;
}
/* transfer current message context back to t */
t->uac[branch].br_flags = getb0flags();
t->uas.request->flags = p_msg->flags;
if (onreply_avp_mode)
/* restore original avp list */
set_avp_list( backup_list );
}
if (!onreply_avp_mode || !has_reply_route)
/* lock the reply*/
LOCK_REPLIES( t );
/* mark that the UAC received replies */
uac->flags |= T_UAC_HAS_RECV_REPLY;
/* we fire a cancel on spot if (a) branch is marked "to be canceled" or (b)
* the whole transaction was canceled (received cancel) and no cancel sent
* yet on this branch; and of course, only if a provisional reply :) */
if (t->uac[branch].flags&T_UAC_TO_CANCEL_FLAG ||
((t->flags&T_WAS_CANCELLED_FLAG) && !t->uac[branch].local_cancel.buffer.s)) {
if ( msg_status < 200 )
/* reply for an UAC with a pending cancel -> do cancel now */
cancel_branch(t, branch);
/* reset flag */
t->uac[branch].flags &= ~(T_UAC_TO_CANCEL_FLAG);
}
if (is_local(t)) {
reply_status = local_reply(t,p_msg, branch,msg_status,&cancel_bitmap);
if (reply_status == RPS_COMPLETED) {
cleanup_uac_timers(t);
if (is_invite(t)) cancel_uacs(t, cancel_bitmap);
/* There is no need to call set_final_timer because we know
* that the transaction is local */
put_on_wait(t);
}
} else {
reply_status = relay_reply(t,p_msg,branch,msg_status,&cancel_bitmap);
/* clean-up the transaction when transaction completed */
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_bitmap);
/* FR for negative INVITES, WAIT anything else */
/* set_final_timer(t); */
}
}
if (reply_status!=RPS_PROVISIONAL)
goto done;
/* update FR/RETR timers on provisional replies */
if (msg_status < 200 && (restart_fr_on_each_reply ||
((last_uac_status<msg_status) &&
((msg_status >= 180) || (last_uac_status == 0)))
) ) { /* provisional now */
if (is_invite(t)) {
/* invite: change FR to longer FR_INV, do not
* attempt to restart retransmission any more
*/
backup_list = set_avp_list(&t->user_avps);
if (!fr_inv_avp2timer(&timer)) {
LM_DBG("FR_INV_TIMER = %lld\n", timer);
set_timer(&uac->request.fr_timer,
FR_INV_TIMER_LIST, &timer);
} else {
set_timer(& uac->request.fr_timer, FR_INV_TIMER_LIST, 0);
}
set_avp_list(backup_list);
} else {
/* non-invite: restart retransmissions (slow now) */
uac->request.retr_list = RT_T2;
set_timer(&uac->request.retr_timer, RT_T2, 0);
}
} /* provisional replies */
done:
/* we are done with the transaction, so unref it - the reference
* was incremented by t_check() function -bogdan*/
t_unref(p_msg);
/* don't try to relay statelessly neither on success
* (we forwarded statefully) nor on error; on troubles,
* simply do nothing; that will make the other party to
* retransmit; hopefuly, we'll then be better off
*/
_tm_branch_index = 0;
return 0;
not_found:
set_t(T_UNDEFINED);
return 1;
}
inline static void final_response_handler( struct timer_link *fr_tl )
{
#define CANCEL_REASON_SIP_480 \
"Reason: SIP;cause=480;text=\"NO_ANSWER\"" CRLF
static context_p my_ctx = NULL;
context_p old_ctx;
struct retr_buf* r_buf;
struct cell *t;
if (fr_tl==0){
/* or BUG?, ignoring it for now */
LM_CRIT("final_response_handler(0) called\n");
return;
}
r_buf = get_fr_timer_payload(fr_tl);
t=r_buf->my_T;
# ifdef EXTRA_DEBUG
if (t->damocles)
{
LM_ERR("transaction %p scheduled for deletion and"
" called from FR timer\n",r_buf->my_T);
abort();
}
# endif
reset_timer( &(r_buf->retr_timer) );
/* the transaction is already removed from FR_LIST by the timer */
/* FR for local cancels.... */
if (r_buf->activ_type==TYPE_LOCAL_CANCEL)
{
LM_DBG("stop retr for Local Cancel\n");
return;
}
/* FR for replies (negative INVITE replies) */
if (r_buf->activ_type>0) {
# ifdef EXTRA_DEBUG
if (t->uas.request->REQ_METHOD!=METHOD_INVITE
|| t->uas.status < 200 ) {
LM_ERR("unknown type reply buffer\n");
abort();
}
# endif
put_on_wait( t );
return;
};
/* as this processing is outside the scope of other messages (it is
trigger from timer), a processing context must be attached to it */
old_ctx = current_processing_ctx;
if (my_ctx==NULL) {
my_ctx = context_alloc(CONTEXT_GLOBAL);
if (my_ctx==NULL) {
LM_ERR("failed to alloc new ctx in pkg\n");
}
}
memset( my_ctx, 0, context_size(CONTEXT_GLOBAL) );
current_processing_ctx = my_ctx;
/* set the T context too */
set_t( t );
/* out-of-lock do the cancel I/O */
if (is_invite(t) && should_cancel_branch(t, r_buf->branch) ) {
set_cancel_extra_hdrs( CANCEL_REASON_SIP_480, sizeof(CANCEL_REASON_SIP_480)-1);
cancel_branch(t, r_buf->branch );
set_cancel_extra_hdrs( NULL, 0);
}
/* lock reply processing to determine how to proceed reliably */
LOCK_REPLIES( t );
LM_DBG("Cancel sent out, sending 408 (%p)\n", t);
fake_reply(t, r_buf->branch, 408 );
/* flush the context */
if (current_processing_ctx==NULL)
my_ctx=NULL;
else
context_destroy(CONTEXT_GLOBAL, my_ctx);
/* switch back to the old context */
current_processing_ctx = old_ctx;
/* reset the T context */
init_t();
LM_DBG("done\n");
}
