static unsigned int wait_for(belle_sip_stack_t*s1, belle_sip_stack_t*s2,int* counter,int value,int timeout) { int retry=0; #define ITER 100 while (*counter<value && retry++ <(timeout/ITER)) { if (s1) belle_sip_stack_sleep(s1,ITER/2); if (s2) belle_sip_stack_sleep(s2,ITER/2); } if(*counter<value) return FALSE; else return TRUE; }
static belle_sip_request_t* send_message(belle_sip_request_t *initial_request, const char* realm){ int i; int io_error_count=0; belle_sip_request_t *message_request=NULL; belle_sip_request_t *clone_request=NULL; // belle_sip_header_authorization_t * h=NULL; is_register_ok = 0; message_request=belle_sip_request_create( belle_sip_uri_parse("sip:sip.linphone.org;transport=tcp") ,"MESSAGE" ,belle_sip_provider_create_call_id(prov) ,belle_sip_header_cseq_create(22,"MESSAGE") ,belle_sip_message_get_header_by_type(BELLE_SIP_MESSAGE(initial_request), belle_sip_header_from_t) ,belle_sip_header_to_parse("To: sip:[email protected]") ,belle_sip_header_via_new() ,70); belle_sip_message_add_header(BELLE_SIP_MESSAGE(message_request),BELLE_SIP_HEADER(belle_sip_header_expires_create(600))); belle_sip_message_add_header(BELLE_SIP_MESSAGE(message_request),BELLE_SIP_HEADER(belle_sip_header_contact_new())); belle_sip_provider_add_authorization(prov,message_request,NULL,NULL,NULL,realm); // h = belle_sip_message_get_header_by_type(BELLE_SIP_MESSAGE(message_request), belle_sip_header_authorization_t); /*if a matching authorization was found, use it as a proxy authorization*/ // if (h != NULL){ // belle_sip_header_set_name(BELLE_SIP_HEADER(h), BELLE_SIP_PROXY_AUTHORIZATION); // } clone_request = (belle_sip_request_t*)belle_sip_object_ref(belle_sip_object_clone((belle_sip_object_t*)message_request)); belle_sip_client_transaction_send_request_to(belle_sip_provider_create_client_transaction(prov,message_request),NULL); for(i=0; i<2 && io_error_count==0 &&is_register_ok==0;i++) belle_sip_stack_sleep(stack,5000); return clone_request; }
belle_sip_request_t* try_register_user_at_domain(belle_sip_stack_t * stack ,belle_sip_provider_t *prov ,const char *transport ,int use_transaction ,const char* username ,const char* domain ,const char* outbound_proxy ,int success_expected) { belle_sip_request_t *req,*copy; char identity[256]; char uri[256]; int i; char *outbound=NULL; number_of_challenge=0; if (transport) snprintf(uri,sizeof(uri),"sip:%s;transport=%s",domain,transport); else snprintf(uri,sizeof(uri),"sip:%s",domain); if (transport && strcasecmp("tls",transport)==0 && belle_sip_provider_get_listening_point(prov,"tls")==NULL){ belle_sip_error("No TLS support, test skipped."); return NULL; } if (outbound_proxy){ if (strstr(outbound_proxy,"sip:")==NULL && strstr(outbound_proxy,"sips:")==NULL){ outbound=belle_sip_strdup_printf("sip:%s",outbound_proxy); }else outbound=belle_sip_strdup(outbound_proxy); } snprintf(identity,sizeof(identity),"Tester <sip:%s@%s>",username,domain); req=belle_sip_request_create( belle_sip_uri_parse(uri), "REGISTER", belle_sip_provider_create_call_id(prov), belle_sip_header_cseq_create(20,"REGISTER"), belle_sip_header_from_create2(identity,BELLE_SIP_RANDOM_TAG), belle_sip_header_to_create2(identity,NULL), belle_sip_header_via_new(), 70); is_register_ok=0; io_error_count=0; using_transaction=0; belle_sip_message_add_header(BELLE_SIP_MESSAGE(req),BELLE_SIP_HEADER(belle_sip_header_expires_create(600))); belle_sip_message_add_header(BELLE_SIP_MESSAGE(req),BELLE_SIP_HEADER(belle_sip_header_contact_new())); copy=(belle_sip_request_t*)belle_sip_object_ref(belle_sip_object_clone((belle_sip_object_t*)req)); belle_sip_provider_add_sip_listener(prov,l=BELLE_SIP_LISTENER(listener)); if (use_transaction){ belle_sip_client_transaction_t *t=belle_sip_provider_create_client_transaction(prov,req); belle_sip_client_transaction_send_request_to(t,outbound?belle_sip_uri_parse(outbound):NULL); }else belle_sip_provider_send_request(prov,req); for(i=0;!is_register_ok && i<2 && io_error_count==0;i++) belle_sip_stack_sleep(stack,5000); CU_ASSERT_EQUAL(is_register_ok,success_expected); if (success_expected) CU_ASSERT_EQUAL(using_transaction,use_transaction); belle_sip_provider_remove_sip_listener(prov,l); if (outbound) belle_sip_free(outbound); return copy; }
void unregister_user(belle_sip_stack_t * stack ,belle_sip_provider_t *prov ,belle_sip_request_t* initial_request ,int use_transaction) { belle_sip_request_t *req; belle_sip_header_cseq_t* cseq; belle_sip_header_expires_t* expires_header; int i; belle_sip_provider_add_sip_listener(prov,l); is_register_ok=0; using_transaction=0; req=(belle_sip_request_t*)belle_sip_object_clone((belle_sip_object_t*)initial_request); cseq=(belle_sip_header_cseq_t*)belle_sip_message_get_header((belle_sip_message_t*)req,BELLE_SIP_CSEQ); belle_sip_header_cseq_set_seq_number(cseq,belle_sip_header_cseq_get_seq_number(cseq)+2); /*+2 if initial reg was challenged*/ expires_header=(belle_sip_header_expires_t*)belle_sip_message_get_header(BELLE_SIP_MESSAGE(req),BELLE_SIP_EXPIRES); belle_sip_header_expires_set_expires(expires_header,0); if (use_transaction){ belle_sip_client_transaction_t *t; belle_sip_provider_add_authorization(prov,req,NULL,NULL,NULL,NULL); /*just in case*/ t=belle_sip_provider_create_client_transaction(prov,req); belle_sip_client_transaction_send_request(t); }else belle_sip_provider_send_request(prov,req); for(i=0;!is_register_ok && i<2 ;i++) belle_sip_stack_sleep(stack,5000); CU_ASSERT_EQUAL(is_register_ok,1); CU_ASSERT_EQUAL(using_transaction,use_transaction); belle_sip_provider_remove_sip_listener(prov,l); }
static int wait_for(belle_sip_stack_t*s1,int* counter,int value,int timeout) { int retry=0; #define SLEEP_TIME 100 while (*counter!=value && retry++ <(timeout/SLEEP_TIME)) { if (s1) belle_sip_stack_sleep(s1,SLEEP_TIME); } if (*counter!=value) return FALSE; else return TRUE; }
static void testMalformedMandatoryField(void){ belle_sip_stack_t* stack = belle_sip_stack_new(NULL); belle_sip_listening_point_t* lp = belle_sip_stack_create_listening_point(stack, "127.0.0.1", LISTENING_POINT_PORT, "tcp"); belle_sip_provider_t* provider = belle_sip_provider_new(stack,lp); belle_sip_listener_callbacks_t listener_cbs = {0}; /* the MESSAGE message has no definition on which fields are required, which means we'll go into * * * */ const char* raw_message = "MESSAGE sip:[email protected]:5861;transport=tcp SIP/2.0\r\n" "Via: SIP/2.0/TCP " LISTENING_POINT_HOSTPORT ";branch=z9hG4bK5eca096a;rport\r\n" "Max-Forwards: 70\r\n" "From: \"MS TFT\" <sip:[email protected]>;tag=as2413a381\r\n" "To: <sip:[email protected]:5861;app-id=fr.lollol.phone.prod;pn-type=apple;pn-tok=azertyuiopqsdfghhjjkmlqoijfubieuzhqiluehcpoqidufqsdkjlcnuoishcvs;pn-msg-str=IM_MSG;pn-call-str=IC_MSG;pn-call-snd=ring.caf;pn-msg-snd=msg.caf;transport=tcp>;tag=\r\n" "Call-ID: [email protected]:5060\r\n" "CSeq: 103 MESSAGE\r\n" "User-Agent: Sip Server On Host (20130523_12h10)\r\n" "Content-Type: text/plain;charset=UTF-8\r\n" "Content-Length: 276\r\n" "\r\n" "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n" "<VDUCMediaConfig GId=\"1234567\" IdPosteType=\"123\"><Label>Salut Bilout TFT MS2</Label><MediaConfig GId=\"456\"><CommandCode Code=\"MediaCommand*\"><Label>Porte ouverte</Label></CommandCode><withVideo FPS=\"0.0\"/></MediaConfig></VDUCMediaConfig>\r\n" "\r\n"; belle_sip_message_t* message = belle_sip_message_parse(raw_message); belle_sip_listener_t* listener = NULL; int called_times = 0; listener_cbs.process_response_event = testMalformedFrom_process_response_cb; listener = belle_sip_listener_create_from_callbacks(&listener_cbs, &called_times); belle_sip_provider_add_sip_listener(provider, listener); belle_sip_object_ref(message); belle_sip_object_ref(message); /* double ref: originally the message is created with 0 refcount, and dispatch_message will unref() it.*/ belle_sip_provider_dispatch_message(provider, message); // we expect the stack to send a 400 error belle_sip_stack_sleep(stack,1000); CU_ASSERT_EQUAL(called_times,1); belle_sip_provider_remove_sip_listener(provider,listener); belle_sip_object_unref(listener); belle_sip_object_unref(provider); belle_sip_object_unref(stack); belle_sip_object_unref(message); }
static unsigned int wait_for(belle_sip_stack_t *stack, int *current_value, int expected_value, int timeout) { #define ITER 100 uint64_t begin, end; begin = belle_sip_time_ms(); end = begin + timeout; while ((*current_value != expected_value) && (belle_sip_time_ms() < end)) { if (stack) belle_sip_stack_sleep(stack, ITER); } if (*current_value != expected_value) return FALSE; else return TRUE; }
static void test_register_channel_inactive(void){ belle_sip_listening_point_t *lp=belle_sip_provider_get_listening_point(prov,"TCP"); CU_ASSERT_PTR_NOT_NULL_FATAL(lp); belle_sip_stack_set_inactive_transport_timeout(stack,5); belle_sip_listening_point_clean_channels(lp); CU_ASSERT_EQUAL(belle_sip_listening_point_get_channel_count(lp),0); register_test("tcp",1); CU_ASSERT_EQUAL(belle_sip_listening_point_get_channel_count(lp),1); belle_sip_stack_sleep(stack,5000); CU_ASSERT_EQUAL(belle_sip_listening_point_get_channel_count(lp),0); belle_sip_stack_set_inactive_transport_timeout(stack,3600); }
static void test_bad_request(void) { belle_sip_request_t *req; belle_sip_listener_t *bad_req_listener; belle_sip_client_transaction_t *t; belle_sip_header_address_t* route_address=belle_sip_header_address_create(NULL,belle_sip_uri_create(NULL,test_domain)); belle_sip_header_route_t* route; belle_sip_header_to_t* to = belle_sip_header_to_create2("sip:[email protected]",NULL); belle_sip_listener_callbacks_t cbs; belle_sip_listening_point_t *lp=belle_sip_provider_get_listening_point(prov,"TCP"); int bad_request_response_received=0; memset(&cbs,0,sizeof(cbs)); cbs.process_io_error=bad_req_process_io_error; cbs.process_response_event=bad_req_process_response_event; bad_req_listener = belle_sip_listener_create_from_callbacks(&cbs,&bad_request_response_received); req=belle_sip_request_create( BELLE_SIP_URI(belle_sip_object_clone(BELLE_SIP_OBJECT(belle_sip_header_address_get_uri(route_address)))), "REGISTER", belle_sip_provider_create_call_id(prov), belle_sip_header_cseq_create(20,"REGISTER"), belle_sip_header_from_create2("sip:[email protected]",BELLE_SIP_RANDOM_TAG), to, belle_sip_header_via_new(), 70); belle_sip_uri_set_transport_param(belle_sip_header_address_get_uri(route_address),"tcp"); route = belle_sip_header_route_create(route_address); belle_sip_header_set_name(BELLE_SIP_HEADER(to),"BrokenHeader"); belle_sip_message_add_header(BELLE_SIP_MESSAGE(req),BELLE_SIP_HEADER(belle_sip_header_expires_create(600))); belle_sip_message_add_header(BELLE_SIP_MESSAGE(req),BELLE_SIP_HEADER(route)); belle_sip_message_add_header(BELLE_SIP_MESSAGE(req),BELLE_SIP_HEADER(belle_sip_header_contact_new())); belle_sip_provider_add_sip_listener(prov,bad_req_listener); t=belle_sip_provider_create_client_transaction(prov,req); belle_sip_client_transaction_send_request(t); belle_sip_stack_sleep(stack,3000); CU_ASSERT_TRUE(bad_request_response_received==1); belle_sip_provider_remove_sip_listener(prov,bad_req_listener); belle_sip_object_unref(bad_req_listener); belle_sip_listening_point_clean_channels(lp); }
static void prepare_query(CardDavRequest *request) { belle_http_request_listener_callbacks_t cbs = { 0 }; belle_http_request_listener_t *l = NULL; belle_generic_uri_t *uri = NULL; belle_http_request_t *req = NULL; belle_sip_memory_body_handler_t *bh = NULL; belle_sip_stack_t *stack = NULL; belle_http_provider_t *http_provider = NULL; belle_sip_set_log_level(BELLE_SIP_LOG_MESSAGE); uri = belle_generic_uri_parse(request->url); if (!uri) { belle_sip_error("Could not send request, URL %s is invalid", request->url); return; } req = belle_http_request_create(request->method, uri, belle_sip_header_content_type_create("application", "xml; charset=utf-8"), belle_sip_header_create("Depth", request->depth), NULL); if (!req) { belle_sip_object_unref(uri); belle_sip_error("Could not create request"); return; } bh = belle_sip_memory_body_handler_new_copy_from_buffer(request->body, strlen(request->body), NULL, NULL); belle_sip_message_set_body_handler(BELLE_SIP_MESSAGE(req), BELLE_SIP_BODY_HANDLER(bh)); cbs.process_response = process_response_from_post_xml_rpc_request; cbs.process_io_error = process_io_error_from_post_xml_rpc_request; cbs.process_auth_requested = process_auth_requested_from_post_xml_rpc_request; l = belle_http_request_listener_create_from_callbacks(&cbs, request); stack = belle_sip_stack_new(NULL); http_provider = belle_sip_stack_create_http_provider(stack, "0.0.0.0"); request->request_in_progress = 1; belle_http_provider_send_request(http_provider, req, l); while (request->request_in_progress) { belle_sip_stack_sleep(stack, 0); } }
static void testMalformedFrom(void){ belle_sip_stack_t* stack = belle_sip_stack_new(NULL); belle_sip_listening_point_t* lp = belle_sip_stack_create_listening_point(stack, "127.0.0.1", LISTENING_POINT_PORT, "tcp"); belle_sip_provider_t* provider = belle_sip_provider_new(stack,lp); belle_sip_listener_callbacks_t listener_cbs = {0}; const char* raw_message = "INVITE sip:[email protected] SIP/2.0\r\n" "Via: SIP/2.0/TCP " LISTENING_POINT_HOSTPORT ";branch=z9hG4bK-edx-U_1zoIkaq72GJPqpSmDpJQ-ouBelFuLODzf9oS5J9MeFUA;rport\r\n" "From: c\x8e test <sip:00_12_34_56_78_90@us2>;tag=klsk+kwDc\r\n" /** 'cŽ test' should be enclosed in double quotes */ "To: <sip:[email protected];transport=tcp>\r\n" "Contact: <sip:[email protected]>\r\n" "Call-ID: [email protected]\r\n" "Content-Type: application/sdp\r\n" "Content-Length: 389\r\n" "CSeq: 1 INVITE\r\n" "Allow: INVITE, ACK, BYE, CANCEL, OPTIONS, INFO, UPDATE, REGISTER, MESSAGE, REFER, SUBSCRIBE, PRACK\r\n" "Accept: application/sdp, application/dtmf-relay\r\n" "Max-Forwards: 69\r\n" "\r\n" "v=0\r\n" "o=- 1826 1826 IN IP4 172.16.42.1\r\n" "s=VeriCall Edge\r\n" "c=IN IP4 172.16.42.1\r\n" "t=0 0\r\n" "m=audio 20506 RTP/AVP 0 8 13 101\r\n" "a=rtpmap:0 PCMU/8000\r\n" "a=rtpmap:8 PCMA/8000\r\n" "a=rtpmap:13 CN/8000\r\n" "a=rtpmap:101 telephone-event/8000\r\n" "a=fmtp:101 0-15\r\n" "m=video 24194 RTP/AVP 105 104\r\n" "a=sendonly\r\n" "a=rtpmap:105 H264/90000\r\n" "a=fmtp:105 packetization-mode=0\r\n" "a=rtpmap:104 H263-1998/90000\r\n" "a=fmtp:104 CIF=1;J=1\r\n"; belle_sip_message_t* message = belle_sip_message_parse(raw_message); belle_sip_listener_t* listener = NULL; int called_times = 0; listener_cbs.process_response_event = testMalformedFrom_process_response_cb; listener = belle_sip_listener_create_from_callbacks(&listener_cbs, &called_times); belle_sip_provider_add_sip_listener(provider, listener); belle_sip_object_ref(message); belle_sip_object_ref(message); /* double ref: originally the message is created with 0 refcount, and dispatch_message will unref() it.*/ belle_sip_provider_dispatch_message(provider, message); // we expect the stack to send a 400 error belle_sip_stack_sleep(stack,1000); CU_ASSERT_EQUAL(called_times,1); belle_sip_provider_remove_sip_listener(provider,listener); belle_sip_object_unref(listener); belle_sip_object_unref(provider); belle_sip_object_unref(stack); belle_sip_object_unref(message); }
int sal_iterate(Sal *sal){ belle_sip_stack_sleep(sal->stack,0); return 0; }