static int nict_on_timer_E(belle_sip_nict_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
const belle_sip_timer_config_t *cfg=belle_sip_transaction_get_timer_config(base);
switch(base->state){
case BELLE_SIP_TRANSACTION_TRYING:
{
/*reset the timer */
unsigned int prev_timeout=belle_sip_source_get_timeout(obj->timer_E);
belle_sip_source_set_timeout(obj->timer_E,MIN(2*prev_timeout,(unsigned int)cfg->T2));
belle_sip_message("nict_on_timer_E: sending retransmission");
belle_sip_channel_queue_message(base->channel,(belle_sip_message_t*)base->request);
}
break;
case BELLE_SIP_TRANSACTION_PROCEEDING:
belle_sip_source_set_timeout(obj->timer_E,cfg->T2);
belle_sip_message("nict_on_timer_E: sending retransmission");
belle_sip_channel_queue_message(base->channel,(belle_sip_message_t*)base->request);
break;
default:
/*if we are not in these cases, timer_E does nothing, so remove it*/
return BELLE_SIP_STOP;
break;
}
return BELLE_SIP_CONTINUE;
}
static int dialog_on_200Ok_timer(belle_sip_dialog_t *dialog){
/*reset the timer */
const belle_sip_timer_config_t *cfg=belle_sip_stack_get_timer_config(dialog->provider->stack);
unsigned int prev_timeout=belle_sip_source_get_timeout(dialog->timer_200Ok);
belle_sip_source_set_timeout(dialog->timer_200Ok,MIN(2*prev_timeout,(unsigned int)cfg->T2));
belle_sip_message("Dialog sending retransmission of 200Ok");
belle_sip_provider_send_response(dialog->provider,dialog->last_200Ok);
return BELLE_SIP_CONTINUE;
}
static int ict_on_timer_A(belle_sip_ict_t *obj){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
switch(base->state){
case BELLE_SIP_TRANSACTION_CALLING:
{
/*reset the timer to twice the previous value, and retransmit */
unsigned int prev_timeout=belle_sip_source_get_timeout(obj->timer_A);
belle_sip_source_set_timeout(obj->timer_A,2*prev_timeout);
belle_sip_channel_queue_message(base->channel,(belle_sip_message_t*)base->request);
}
break;
default:
break;
}
return BELLE_SIP_CONTINUE;
}
static int tls_process_handshake(belle_sip_channel_t *obj){
belle_sip_tls_channel_t* channel=(belle_sip_tls_channel_t*)obj;
int err=tls_channel_handshake(channel);
if (err==0){
belle_sip_message("Channel [%p]: SSL handshake finished.",obj);
belle_sip_source_set_timeout((belle_sip_source_t*)obj,-1);
belle_sip_message("Calling channel ready from the ssll ");
belle_sip_channel_set_ready(obj,(struct sockaddr*)&channel->ss,channel->socklen);
}else if (err==POLARSSL_ERR_NET_WANT_READ || err==POLARSSL_ERR_NET_WANT_WRITE){
belle_sip_message("Channel [%p]: SSL handshake in progress...",obj);
}else{
char tmp[128];
error_strerror(err,tmp,sizeof(tmp));
belle_sip_error("Channel [%p]: SSL handshake failed : %s",obj,tmp);
return -1;
}
return 0;
}
static void update_inactivity_timer(belle_sip_channel_t *obj, int from_recv){
int inactive_timeout=belle_sip_stack_get_inactive_transport_timeout(obj->stack)*1000;
if (inactive_timeout>0){
if (!obj->inactivity_timer ){
obj->inactivity_timer=belle_sip_main_loop_create_timeout(obj->stack->ml,channel_inactive_timeout,obj,inactive_timeout,"Channel inactivity timer");
}else{
/*restart the timer for new period*/
belle_sip_source_set_timeout(obj->inactivity_timer,inactive_timeout);
}
}else{
if (obj->inactivity_timer){
belle_sip_main_loop_remove_source(obj->stack->ml,obj->inactivity_timer);
belle_sip_object_unref(obj->inactivity_timer);
obj->inactivity_timer=NULL;
}
}
if (from_recv)
obj->last_recv_time=belle_sip_time_ms();
}
void belle_sip_listening_point_set_keep_alive(belle_sip_listening_point_t *lp,int ms) {
if (ms <=0) {
if (lp->keep_alive_timer) {
belle_sip_main_loop_remove_source(lp->stack->ml,lp->keep_alive_timer);
belle_sip_object_unref(lp->keep_alive_timer);
lp->keep_alive_timer=NULL;
}
return;
}
if (!lp->keep_alive_timer) {
lp->keep_alive_timer = belle_sip_main_loop_create_timeout(lp->stack->ml
, keep_alive_timer_func
, lp
, ms
,"keep alive") ;
} else {
belle_sip_source_set_timeout(lp->keep_alive_timer,ms);
}
return;
}
static int tls_process_data(belle_sip_channel_t *obj,unsigned int revents){
belle_sip_tls_channel_t* channel=(belle_sip_tls_channel_t*)obj;
if (obj->state == BELLE_SIP_CHANNEL_CONNECTING ) {
if (!channel->socket_connected) {
channel->socklen=sizeof(channel->ss);
if (finalize_stream_connection((belle_sip_stream_channel_t*)obj,revents,(struct sockaddr*)&channel->ss,&channel->socklen)) {
goto process_error;
}
belle_sip_message("Channel [%p]: Connected at TCP level, now doing TLS handshake",obj);
channel->socket_connected=1;
belle_sip_source_set_events((belle_sip_source_t*)channel,BELLE_SIP_EVENT_READ|BELLE_SIP_EVENT_ERROR);
belle_sip_source_set_timeout((belle_sip_source_t*)obj,belle_sip_stack_get_transport_timeout(obj->stack));
if (tls_process_handshake(obj)==-1) goto process_error;
}else{
if (revents & BELLE_SIP_EVENT_READ){
if (tls_process_handshake(obj)==-1) goto process_error;
}else if (revents==BELLE_SIP_EVENT_TIMEOUT){
belle_sip_error("channel [%p]: SSL handshake took too much time.",obj);
goto process_error;
}else{
belle_sip_warning("channeEHHCXCCCl [%p]: unexpected event [%i] during TLS handshake.",obj,revents);
}
}
} else if ( obj->state == BELLE_SIP_CHANNEL_READY) {
return belle_sip_channel_process_data(obj,revents);
} else {
belle_sip_warning("Unexpected event [%i], for channel [%p]",revents,channel);
return BELLE_SIP_STOP;
}
return BELLE_SIP_CONTINUE;
process_error:
belle_sip_error("Cannot connect to [%s://%s:%i]",belle_sip_channel_get_transport_name(obj),obj->peer_name,obj->peer_port);
channel_set_state(obj,BELLE_SIP_CHANNEL_ERROR);
return BELLE_SIP_STOP;
}
