static void process_dialog_terminated(void *ctx, const belle_sip_dialog_terminated_event_t *event) { SalOp* op=(SalOp*)ctx; if (op->dialog && op->dialog==belle_sip_dialog_terminated_event_get_dialog(event)) { /*belle_sip_transaction_t* trans=belle_sip_dialog_get_last_transaction(op->dialog);*/ ms_message("Dialog [%p] terminated for op [%p]",belle_sip_dialog_terminated_event_get_dialog(event),op); switch(belle_sip_dialog_get_previous_state(op->dialog)) { case BELLE_SIP_DIALOG_CONFIRMED: if (op->state!=SalOpStateTerminated && op->state!=SalOpStateTerminating) { /*this is probably a normal termination from a BYE*/ op->base.root->callbacks.call_terminated(op,op->dir==SalOpDirIncoming?sal_op_get_from(op):sal_op_get_to(op)); op->state=SalOpStateTerminating; } break; default: break; } belle_sip_main_loop_do_later(belle_sip_stack_get_main_loop(op->base.root->stack) ,(belle_sip_callback_t) call_set_released , op); } else { ms_error("dialog unknown for op "); } }
static void bad_req_process_response_event(void *user_ctx, const belle_sip_response_event_t *event){ int *bad_request_response_received=(int*)user_ctx; belle_sip_response_t *resp=belle_sip_response_event_get_response(event); CU_ASSERT_TRUE(resp && belle_sip_response_get_status_code(resp)==400); *bad_request_response_received=1; belle_sip_main_loop_quit(belle_sip_stack_get_main_loop(stack)); }
static void cancel_retry(belle_sip_refresher_t* refresher) { if (refresher->timer){ belle_sip_main_loop_remove_source(belle_sip_stack_get_main_loop(refresher->transaction->base.provider->stack),refresher->timer); belle_sip_object_unref(refresher->timer); refresher->timer=NULL; } }
static void process_response(void *data, const belle_http_response_event_t *event){ belle_http_response_t *resp=event->response; const char *body=belle_sip_message_get_body(BELLE_SIP_MESSAGE(resp)); if (body){ fprintf(stdout,"%s",body); } belle_sip_main_loop_quit(belle_sip_stack_get_main_loop(stack)); }
static void process_io_error(void *user_ctx, const belle_sip_io_error_event_t *event){ BELLESIP_UNUSED(user_ctx); BELLESIP_UNUSED(event); belle_sip_message("process_io_error, exiting main loop"); belle_sip_main_loop_quit(belle_sip_stack_get_main_loop(stack)); io_error_count++; /*CU_ASSERT(CU_FALSE);*/ }
static void schedule_timer_at(belle_sip_refresher_t* refresher,int delay, timer_purpose_t purpose) { belle_sip_message("Refresher: scheduling next timer in %i ms",delay); refresher->timer_purpose=purpose; /*cancel timer if any*/ cancel_retry(refresher); refresher->timer=belle_sip_timeout_source_new(timer_cb,refresher,delay); belle_sip_object_set_name((belle_sip_object_t*)refresher->timer,"Refresher timeout"); belle_sip_main_loop_add_source(belle_sip_stack_get_main_loop(refresher->transaction->base.provider->stack),refresher->timer); }
static void belle_sip_refresher_stop_internal(belle_sip_refresher_t* refresher,int cancel_pending_transaction) { belle_sip_message("Refresher [%p] stopped.",refresher); if (refresher->timer){ belle_sip_main_loop_remove_source(belle_sip_stack_get_main_loop(refresher->transaction->base.provider->stack), refresher->timer); belle_sip_object_unref(refresher->timer); refresher->timer=NULL; } if (cancel_pending_transaction && refresher->transaction && belle_sip_transaction_state_is_transient(belle_sip_transaction_get_state(BELLE_SIP_TRANSACTION(refresher->transaction)))) { belle_sip_transaction_terminate(BELLE_SIP_TRANSACTION(refresher->transaction)); /*refresher cancelled, no need to continue to retransmit*/ } refresher->state=stopped; }
static void process_message_response_event(void *user_ctx, const belle_sip_response_event_t *event){ int status; BELLESIP_UNUSED(user_ctx); CU_ASSERT_PTR_NOT_NULL_FATAL(belle_sip_response_event_get_response(event)); belle_sip_message("process_response_event [%i] [%s]" ,status=belle_sip_response_get_status_code(belle_sip_response_event_get_response(event)) ,belle_sip_response_get_reason_phrase(belle_sip_response_event_get_response(event))); if (status >= 200){ is_register_ok=status; belle_sip_main_loop_quit(belle_sip_stack_get_main_loop(stack)); } }
static void process_response_event(void *user_ctx, const belle_sip_response_event_t *event){ int status; belle_sip_request_t* request; BELLESIP_UNUSED(user_ctx); CU_ASSERT_PTR_NOT_NULL_FATAL(belle_sip_response_event_get_response(event)); belle_sip_message("process_response_event [%i] [%s]" ,status=belle_sip_response_get_status_code(belle_sip_response_event_get_response(event)) ,belle_sip_response_get_reason_phrase(belle_sip_response_event_get_response(event))); if (status==401){ belle_sip_header_cseq_t* cseq; belle_sip_client_transaction_t *t; belle_sip_uri_t *dest; // CU_ASSERT_NOT_EQUAL_FATAL(number_of_challenge,2); CU_ASSERT_PTR_NOT_NULL_FATAL(belle_sip_response_event_get_client_transaction(event)); /*require transaction mode*/ dest=belle_sip_client_transaction_get_route(belle_sip_response_event_get_client_transaction(event)); request=belle_sip_transaction_get_request(BELLE_SIP_TRANSACTION(belle_sip_response_event_get_client_transaction(event))); cseq=(belle_sip_header_cseq_t*)belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),BELLE_SIP_CSEQ); belle_sip_header_cseq_set_seq_number(cseq,belle_sip_header_cseq_get_seq_number(cseq)+1); belle_sip_message_remove_header(BELLE_SIP_MESSAGE(request),BELLE_SIP_AUTHORIZATION); belle_sip_message_remove_header(BELLE_SIP_MESSAGE(request),BELLE_SIP_PROXY_AUTHORIZATION); CU_ASSERT_TRUE_FATAL(belle_sip_provider_add_authorization(prov,request,belle_sip_response_event_get_response(event),NULL,NULL,auth_domain)); t=belle_sip_provider_create_client_transaction(prov,request); belle_sip_client_transaction_send_request_to(t,dest); number_of_challenge++; authorized_request=request; belle_sip_object_ref(authorized_request); } else { CU_ASSERT_EQUAL(status,200); is_register_ok=1; using_transaction=belle_sip_response_event_get_client_transaction(event)!=NULL; belle_sip_main_loop_quit(belle_sip_stack_get_main_loop(stack)); } }
void sal_cancel_timer(Sal *sal, belle_sip_source_t *timer) { belle_sip_main_loop_t *ml = belle_sip_stack_get_main_loop(sal->stack); belle_sip_main_loop_remove_source(ml, timer); }
belle_sip_source_t * sal_create_timer(Sal *sal, belle_sip_source_func_t func, void *data, unsigned int timeout_value_ms, const char* timer_name) { belle_sip_main_loop_t *ml = belle_sip_stack_get_main_loop(sal->stack); return belle_sip_main_loop_create_timeout(ml, func, data, timeout_value_ms, timer_name); }
static void process_timeout(void *data, const belle_sip_timeout_event_t *event){ fprintf(stderr,"Timeout\n"); belle_sip_main_loop_quit(belle_sip_stack_get_main_loop(stack)); }
static void process_io_error(void *data, const belle_sip_io_error_event_t *event){ fprintf(stderr,"IO error\n"); belle_sip_main_loop_quit(belle_sip_stack_get_main_loop(stack)); }
static void stateful_register_udp_with_keep_alive(void) { belle_sip_listening_point_set_keep_alive(belle_sip_provider_get_listening_point(prov,"udp"),200); register_test(NULL,1); belle_sip_main_loop_sleep(belle_sip_stack_get_main_loop(stack),500); belle_sip_listening_point_set_keep_alive(belle_sip_provider_get_listening_point(prov,"udp"),-1); }