/*
 * $Id$
 *
 */


#include "hash_func.h"
#include "t_funcs.h"
#include "../../dprint.h"
#include "../../config.h"
#include "../../parser_f.h"
#include "../../ut.h"
#include "../../timer.h"




inline int check_for_no_response( struct cell *Trans ,int code, int relay)
{
	if ( code/100>3 && Trans->uac[Trans->nr_of_outgoings].uri.s )
	{
		forward_serial_branch( Trans , Trans->nr_of_outgoings );
		return -1;
	}
	return relay;
}



/* Retransmits the last sent inbound reply.
 * input: p_msg==request for which I want to retransmit an associated reply
 * Returns  -1 - error
 *           1 - OK
 */
int t_retransmit_reply( /* struct sip_msg* p_msg    */ )
{
	static char b[BUF_SIZE];
	int len;

	if (!T->uas.response.buffer)
		return 0;

	if ( (len=T->uas.response.buffer_len)==0 || len>BUF_SIZE ) {
		UNLOCK_REPLIES( T );
		return -1;
	}
	memcpy( b, T->uas.response.buffer, len );
	UNLOCK_REPLIES( T );
	SEND_PR_BUFFER( & T->uas.response, b, len );
	return 1;
}





/* Force a new response into inbound response buffer.
  * returns 1 if everything was OK or -1 for error
  */
int t_send_reply( struct sip_msg* p_msg, unsigned int code, char * text,
														unsigned int branch)
{
	unsigned int len, buf_len=0;
	char * buf;
	struct retr_buf *rb;
	int relay, save_clone;

	buf = build_res_buf_from_sip_req(code,text,T->uas.tag->s,T->uas.tag->len,
		T->uas.request,&len);
	DBG("DEBUG: t_send_reply: buffer computed\n");
	if (!buf)
	{
		DBG("DEBUG: t_send_reply: response building failed\n");
		goto error;
	}

	LOCK_REPLIES( T );
	relay = t_should_relay_response(T, code, branch, &save_clone);

	if (save_clone)
	{
		T->uac[branch].status = code;
	}

	rb = & T->uas.response;
	if (relay >=0 && (relay=check_for_no_response(T,code,relay))>=0 )
	{
		if (!rb->buffer) {
			/* initialize retransmission structure */
			if (update_sock_struct_from_via(  &(rb->to),  p_msg->via1 )==-1)
			{
				UNLOCK_REPLIES( T );
				LOG(L_ERR,"ERROR: t_send_reply: cannot lookup reply dst: %s\n",
					p_msg->via1->host.s );
				goto error2;
			}
			rb->to.sin_family = AF_INET;
			rb->activ_type = code;
			buf_len = len + REPLY_OVERBUFFER_LEN;
		}else{
			buf_len = len;
		}
		/* puts the reply's buffer to uas.response */
		if (! (rb->buffer = (char*)shm_resize( rb->buffer, buf_len )))
		{
			UNLOCK_REPLIES( T );
			LOG(L_ERR, "ERROR: t_send_reply: cannot allocate shmem buffer\n");
			goto error2;
		}
		rb->buffer_len = len ;
		memcpy( rb->buffer , buf , len );
		T->uas.status = code;
		/* needs to be protected too because what timers are set depends
		   on current transactions status */
		t_update_timers_after_sending_reply( rb );
	} /* if realy */

	UNLOCK_REPLIES( T );

	if (relay>=0) SEND_PR_BUFFER( rb, buf, len );
	pkg_free( buf ) ;
	DBG("DEBUG: t_send_reply: finished\n");
	return 1;

error2:
	pkg_free ( buf );
error:
	return -1;
}



#if 0
/* Push a previously stored reply from UA Client to UA Server
 * and send it out */
static int push_reply( struct cell* trans , unsigned int branch ,
												char *buf, unsigned int len)
{
	unsigned int buf_len;
	struct retrans_buff *rb;

	DBG("DEBUG: push_reply_from_uac_to_uas: start\n");
	rb= & trans->outbound_response;
	/* if there is a reply, release the buffer (everything else stays same) */
	if ( ! rb->retr_buffer ) {
		/*init retrans buffer*/
		memset( rb , 0 , sizeof (struct retrans_buff) );
		if (update_sock_struct_from_via(  &(rb->to),
			trans->inbound_response[branch]->via2 )==-1) {
				LOG(L_ERR, "ERROR: push_reply_from_uac_to_uas: "
					"cannot lookup reply dst: %s\n",
				trans->inbound_response[branch]->via2->host.s );
				goto error;
		}
		rb->retr_timer.tg=TG_RT;
		rb->fr_timer.tg=TG_FR;
		rb->retr_timer.payload = rb;
		rb->fr_timer.payload =  rb;
		rb->to.sin_family = AF_INET;
		rb->my_T = trans;
		rb->status = trans->inbound_response[branch]->REPLY_STATUS;
	};

	/* if this is a first reply (?100), longer replies will probably follow;
	try avoiding shm_resize by higher buffer size */
	buf_len = rb->retr_buffer ? len : len + REPLY_OVERBUFFER_LEN;
	if (! (rb->retr_buffer = (char*)shm_resize( rb->retr_buffer, buf_len )))
	{
		LOG(L_ERR, "ERROR: t_push: cannot allocate shmem buffer\n");
		goto error1;
	}
	rb->bufflen = len ;
	memcpy( rb->retr_buffer , buf , len );

	/* update the status*/
	trans->status = trans->inbound_response[branch]->REPLY_STATUS;
	if ( trans->inbound_response[branch]->REPLY_STATUS>=200 &&
		trans->relaied_reply_branch==-1 ) {

		memcpy( & trans->ack_to, & trans->outbound_request[ branch ]->to,
			sizeof( struct sockaddr_in ) );
		trans->relaied_reply_branch = branch;
	}

	/*send the reply*/
	SEND_BUFFER( rb );
	return 1;

error1:
error:
	return -1;
}
#endif



/*  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 t_on_reply( struct sip_msg  *p_msg )
{
	int branch, msg_status, msg_class, save_clone;
	int local_cancel;
	int relay;
	int start_fr = 0;
	int is_invite;
	/* retransmission structure of outbound reply and request */
	struct retr_buf *rb=0;
	char *buf=0, *ack=0;
	/* length of outbound reply */
	unsigned int res_len, ack_len;
	/* buffer length (might be somewhat larger than message size */
	unsigned int alloc_len;
	str *str_foo;


	/* make sure we know the assosociated tranaction ... */
	if (t_check( p_msg  , &branch , &local_cancel)==-1)
		return 1;
	/* ... if there is no such, tell the core router to forward statelessly */
	if ( T<=0 ) return 1;

	DBG("DEBUG: t_on_reply: org. status uas=%d, uac[%d]=%d loca_cancel=%d)\n",
		T->uas.status, branch, T->uac[branch].status, local_cancel);

	/* special cases (local cancel reply) -bogdan */
	if (local_cancel==1)
	{
		reset_timer( hash_table, &(T->uac[branch].request.retr_timer));
		if ( p_msg->REPLY_STATUS>=200 )
			reset_timer(hash_table,&(T->uac[branch].request.fr_timer));
		goto error;
	}

	/* do we have via2 ? - maybe we'll need it for forwarding -bogdan*/
	if ((p_msg->via2==0) || (p_msg->via2->error!=VIA_PARSE_OK)){
		/* no second via => error */
		LOG(L_ERR, "ERROR: t_on_reply: no 2nd via found in reply\n");
		goto error;
	}

	msg_status=p_msg->REPLY_STATUS;
	msg_class=REPLY_CLASS(p_msg);
	is_invite= T->uas.request->REQ_METHOD==METHOD_INVITE;

	/*  generate the retrans buffer, make a simplified
	assumption everything but 100 will be fwd-ed;
	sometimes it will result in useless CPU cycles
	but mostly the assumption holds and allows the
	work to be done out of criticial lock region */
	if (msg_status==100 && T->uac[branch].status)
		buf=0;
	else {
		/* buf maybe allo'ed*/
		buf = build_res_buf_from_sip_res ( p_msg, &res_len);
		if (!buf) {
			LOG(L_ERR, "ERROR: t_on_reply_received: "
			"no mem for outbound reply buffer\n");
			goto error;
		}
	}

	/* *** stop timers *** */
	/* stop retransmission */
	reset_timer( hash_table, &(T->uac[branch].request.retr_timer));
	/* stop final response timer only if I got a final response */
	if ( msg_class>1 )
		reset_timer( hash_table, &(T->uac[branch].request.fr_timer));

	LOCK_REPLIES( T );
	/* if a got the first prov. response for an INVITE ->
	   change FR_TIME_OUT to INV_FR_TIME_UT */
	start_fr = !T->uac[branch].rpl_received && msg_class==1 && is_invite;

	/* *** store and relay message as needed *** */
	relay = t_should_relay_response( T , msg_status, branch, &save_clone );
	DBG("DEBUG: t_on_reply: branch=%d, save=%d, relay=%d\n",
		branch, save_clone, relay );

	if (save_clone)
	{
		str_foo = &(T->uac[branch].tag);
		str_foo->s = shm_resize(str_foo->s, (str_foo?0:TAG_OVERBUFFER_LEN) +
			get_to(p_msg)->tag_value.len);
		if (!str_foo->s)
		{
			LOG( L_ERR , "ERROR: t_on_reply: connot alocate memory!\n");
			goto error1;
		}
		/* when forking, replies greater then 300 are saved */
		if ((T->nr_of_outgoings>1 || T->uac[T->nr_of_outgoings].uri.s)
			&& msg_status>=300 )
		{
			DBG("DEBUG: t_on_reply: saving reply! \n");
			str_foo = &(T->uac[branch].rpl_buffer);
			str_foo->s = shm_resize(str_foo->s, res_len+
				(str_foo->s?0:REPLY_OVERBUFFER_LEN) );
			if (!str_foo->s)
			{
				LOG( L_ERR , "ERROR: t_on_reply: connot alocate memory!\n");
				goto error1;
			}
			memcpy(str_foo->s,buf,res_len);
			str_foo->len = res_len;
		}
		/*copy the TO tag from reply*/
		T->uac[branch].tag.len = get_to(p_msg)->tag_value.len;
		memcpy( T->uac[branch].tag.s, get_to(p_msg)->tag_value.s,
			T->uac[branch].tag.len );
		T->uac[branch].rpl_received = 1;
		T->uac[branch].status = msg_status;
	}

	rb = & T->uas.response;
	if (relay >= 0  && (relay=check_for_no_response(T,msg_status,relay))>=0 ) {
		if (relay!=branch)
		{
			str_foo = &(T->uac[relay].rpl_buffer);
			if (buf) pkg_free(buf);
			buf = (char*)pkg_malloc(str_foo->len);
			if (!buf)
			{
				UNLOCK_REPLIES( T );
				start_fr = 1;
				LOG(L_ERR, "ERROR: t_on_reply: cannot alloc pkg mem\n");
				goto error1;
			}
			memcpy( buf , str_foo->s , str_foo->len );
			res_len = str_foo->len;
		}
		/* if there is no reply yet, initialize the structure */
		if ( ! rb->buffer ) {
			/*init retrans buffer*/
			if (update_sock_struct_from_via( &(rb->to),p_msg->via2 )==-1) {
				UNLOCK_REPLIES( T );
				start_fr = 1;
				LOG(L_ERR, "ERROR: t_on_reply: cannot lookup reply dst: %s\n",
					p_msg->via2->host.s );
				goto error1;
			}
			rb->to.sin_family = AF_INET;
			rb->activ_type = p_msg->REPLY_STATUS;
			/* allocate something more for the first message;
			   subsequent messages will be longer and buffer
			   reusing will save us a malloc lock */
			alloc_len = res_len + REPLY_OVERBUFFER_LEN ;
		}else{
			alloc_len = res_len;
		}
		/* puts the reply's buffer to uas.response */
		if (! (rb->buffer = (char*)shm_resize( rb->buffer, alloc_len ))) {
			UNLOCK_REPLIES( T );
			start_fr = 1;
			LOG(L_ERR, "ERROR: t_on_reply: cannot alloc shmem\n");
			goto error1;
		}
		rb->buffer_len = res_len;
		memcpy( rb->buffer, buf, res_len );
		/* update the status ... */
		T->uas.status = p_msg->REPLY_STATUS;
		T->uas.tag=&(T->uac[relay].tag);
		if (T->uas.status >=200 && T->relaied_reply_branch==-1 )
				T->relaied_reply_branch = relay;
	}; /* if relay ... */

	UNLOCK_REPLIES( T );

	if (relay >= 0) {
		SEND_PR_BUFFER( rb, buf, res_len );
		t_update_timers_after_sending_reply( rb );
	}

	/* *** ACK handling *** */
	if ( is_invite ) {
		if ( T->uac[branch].request.ack_len )
		{   /*retransmit*/
			/* I don't need any additional syncing here -- after ack
			   is introduced it's never changed */
			SEND_ACK_BUFFER( &(T->uac[branch].request) );
		} else if (msg_class>2 ) {
			/*on a non-200 reply to INVITE*/
			DBG("DEBUG: t_on_reply_received: >=3xx reply to INVITE:"
				"send ACK\n");
			ack = build_ack( p_msg, T, branch , &ack_len);
			if (ack) {
				SEND_PR_BUFFER( &(T->uac[branch].request), ack, ack_len );
				/* append to transaction structure */
				attach_ack( T, branch, ack , ack_len );
			} else {
				/* restart FR */
				start_fr=1;
				DBG("ERROR: t_on_reply: build_ack failed\n");
			}
		}
	} /* is_invite */

	/* restart retransmission if a provisional response came for
	   a non_INVITE -> retrasmit at RT_T2*/
	if ( msg_class==1 && !is_invite )
	{
		rb->retr_list = RT_T2;
		set_timer( hash_table, &(rb->retr_timer), RT_T2 );
	}
error1:
	if (start_fr)
		set_timer( hash_table, &(rb->fr_timer), FR_INV_TIMER_LIST );
	if (buf) pkg_free( buf );
error:
	T_UNREF( T );
	/* don't try to relay statelessly on error; on troubles, simply do nothing;
	   that will make the other party to retransmit; hopefuly, we'll then 
	   be better off */
	return 0;
}