static void testRegisterMessage(void) {
const char* raw_message = "REGISTER sip:192.168.0.20 SIP/2.0\r\n"\
"v: SIP/2.0/UDP 192.168.1.8:5062;rport;branch=z9hG4bK1439638806\r\n"\
"f: <sip:[email protected]>;tag=465687829\r\n"\
"t: <sip:[email protected]>\r\n"\
"i: 1053183492\r\n"\
"CSeq: 1 REGISTER\r\n"\
"m: <sip:[email protected]:5062>\r\n"\
"Max-Forwards: 70\r\n"\
"User-Agent: Linphone/3.3.99.10 (eXosip2/3.3.0)\r\n"\
"Expires: 3600\r\n"\
"Proxy-Authorization: Digest username=\"8117396\", realm=\"Realm\", nonce=\"MTMwNDAwMjIxMjA4NzVkODY4ZmZhODMzMzU4ZDJkOTA1NzM2NTQ2NDZlNmIz"\
", uri=\"sip:linphone.net\", response=\"eed376ff7c963441255ec66594e470e7\", algorithm=MD5, cnonce=\"0a4f113b\", qop=auth, nc=00000001\r\n"\
"l: 0\r\n\r\n";
belle_sip_request_t* request;
belle_sip_message_t* message = belle_sip_message_parse(raw_message);
char* encoded_message = belle_sip_object_to_string(BELLE_SIP_OBJECT(message));
belle_sip_object_unref(BELLE_SIP_OBJECT(message));
message = belle_sip_message_parse(encoded_message);
request = BELLE_SIP_REQUEST(message);
CU_ASSERT_STRING_EQUAL(belle_sip_request_get_method(request),"REGISTER");
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Expires"));
CU_ASSERT_PTR_NOT_NULL(BELLE_SIP_HEADER_EXPIRES(belle_sip_message_get_header(message,"Expires")));
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Proxy-Authorization"));
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Contact"));
check_uri_and_headers(message);
belle_sip_free(encoded_message);
belle_sip_object_unref(message);
}
static void testInviteMessage(void) {
const char* raw_message = "INVITE sip:[email protected] SIP/2.0\r\n"\
"Via: SIP/2.0/UDP 10.23.17.117:22600;branch=z9hG4bK-d8754z-4d7620d2feccbfac-1---d8754z-;rport=4820;received=202.165.193.129\r\n"\
"Max-Forwards: 70\r\n"\
"Contact: <sip:[email protected]:4820>\r\n"\
"To: \"becheong\" <sip:[email protected]>\r\n"\
"From: \"Benjamin Cheong\" <sip:[email protected]>;tag=7326e5f6\r\n"\
"Call-ID: Y2NlNzg0ODc0ZGIxODU1MWI5MzhkNDVkNDZhOTQ4YWU.\r\n"\
"CSeq: 1 INVITE\r\n"\
"Allow: INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO\r\n"\
"c: application/sdp\r\n"\
"Supported: replaces\r\n"\
"Authorization: Digest username=\"003332176\", realm=\"sip.ovh.net\", nonce=\"24212965507cde726e8bc37e04686459\", uri=\"sip:sip.ovh.net\", response=\"896e786e9c0525ca3085322c7f1bce7b\", algorithm=MD5, opaque=\"241b9fb347752f2\"\r\n"\
"User-Agent: X-Lite 4 release 4.0 stamp 58832\r\n"\
"Content-Length: 230\r\n\r\n";
belle_sip_request_t* request;
belle_sip_message_t* message = belle_sip_message_parse(raw_message);
char* encoded_message = belle_sip_object_to_string(BELLE_SIP_OBJECT(message));
belle_sip_object_unref(BELLE_SIP_OBJECT(message));
message = belle_sip_message_parse(encoded_message);
request = BELLE_SIP_REQUEST(message);
CU_ASSERT_STRING_EQUAL(belle_sip_request_get_method(request),"INVITE");
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Contact"));
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Authorization"));
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Content-Type"));
check_uri_and_headers(message);
belle_sip_object_unref(message);
belle_sip_free(encoded_message);
}
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);
}
void sal_op_set_error_info_from_response(SalOp *op, belle_sip_response_t *response){
int code = belle_sip_response_get_status_code(response);
const char *reason_phrase=belle_sip_response_get_reason_phrase(response);
/*Remark: the reason header is to be used mainly in SIP requests, thus the use and prototype of this function should be changed.*/
belle_sip_header_t* reason_header = belle_sip_message_get_header(BELLE_SIP_MESSAGE(response),"Reason");
belle_sip_header_t *warning=belle_sip_message_get_header(BELLE_SIP_MESSAGE(response),"Warning");
SalErrorInfo *ei=&op->error_info;
const char *warnings;
warnings=warning ? belle_sip_header_get_unparsed_value(warning) : NULL;
if (warnings==NULL) warnings=reason_header ? belle_sip_header_get_unparsed_value(reason_header) : NULL;
sal_error_info_set(ei,SalReasonUnknown,code,reason_phrase,warnings);
}
int sal_call_notify_ringing(SalOp *op, bool_t early_media){
int status_code =early_media?183:180;
belle_sip_request_t* req=belle_sip_transaction_get_request(BELLE_SIP_TRANSACTION(op->pending_server_trans));
belle_sip_response_t* ringing_response = sal_op_create_response_from_request(op,req,status_code);
belle_sip_header_t *require;
const char *tags=NULL;
if (early_media){
handle_offer_answer_response(op,ringing_response);
}
require=belle_sip_message_get_header((belle_sip_message_t*)req,"Require");
if (require) tags=belle_sip_header_get_unparsed_value(require);
/* if client requires 100rel, then add necessary stuff*/
if (tags && strstr(tags,"100rel")!=0) {
belle_sip_message_add_header((belle_sip_message_t*)ringing_response,belle_sip_header_create("Require","100rel"));
belle_sip_message_add_header((belle_sip_message_t*)ringing_response,belle_sip_header_create("RSeq","1"));
}
#ifndef SAL_OP_CALL_FORCE_CONTACT_IN_RINGING
if (tags && strstr(tags,"100rel")!=0)
#endif
{
belle_sip_header_address_t* contact= (belle_sip_header_address_t*)sal_op_get_contact_address(op);
belle_sip_header_contact_t* contact_header;
if (contact && (contact_header=belle_sip_header_contact_create(contact))) {
belle_sip_message_add_header(BELLE_SIP_MESSAGE(ringing_response),BELLE_SIP_HEADER(contact_header));
}
}
belle_sip_server_transaction_send_response(op->pending_server_trans,ringing_response);
return 0;
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
static void fix_incoming_via(belle_sip_request_t *msg, const struct addrinfo* origin){
char received[NI_MAXHOST];
char rport[NI_MAXSERV];
belle_sip_header_via_t *via;
int err;
struct sockaddr_storage saddr;
socklen_t slen=sizeof(saddr);
if (!origin) {
belle_sip_warning("cannot fix via for message [%p], probably a test",msg);
return;
}
belle_sip_address_remove_v4_mapping(origin->ai_addr, (struct sockaddr*)&saddr, &slen);
err=getnameinfo((struct sockaddr*)&saddr,slen,received,sizeof(received),
rport,sizeof(rport),NI_NUMERICHOST|NI_NUMERICSERV);
if (err!=0){
belle_sip_error("fix_via: getnameinfo() failed: %s",gai_strerror(errno));
return;
}
via=BELLE_SIP_HEADER_VIA(belle_sip_message_get_header((belle_sip_message_t*)msg,"via"));
if (via){
const char* host = belle_sip_header_via_get_host(via);
if (strcmp(host,received)!=0)
belle_sip_header_via_set_received(via,received);
if (belle_sip_parameters_has_parameter(BELLE_SIP_PARAMETERS(via),"rport")){
int port = belle_sip_header_via_get_listening_port(via);
int rport_int=atoi(rport);
if (rport_int!=port) belle_sip_header_via_set_rport(via,atoi(rport));
}
}
}
bool_t sal_op_get_body(SalOp *op, belle_sip_message_t *msg, SalBody *salbody){
const char *body = NULL;
belle_sip_header_content_type_t *content_type;
belle_sip_header_content_length_t *clen=NULL;
belle_sip_header_t *content_encoding;
content_type=belle_sip_message_get_header_by_type(msg,belle_sip_header_content_type_t);
if (content_type){
body=belle_sip_message_get_body(msg);
clen=belle_sip_message_get_header_by_type(msg,belle_sip_header_content_length_t);
}
content_encoding=belle_sip_message_get_header(msg,"Content-encoding");
memset(salbody,0,sizeof(SalBody));
if (content_type && body && clen) {
salbody->type=belle_sip_header_content_type_get_type(content_type);
salbody->subtype=belle_sip_header_content_type_get_subtype(content_type);
salbody->data=body;
salbody->size=belle_sip_header_content_length_get_content_length(clen);
if (content_encoding)
salbody->encoding=belle_sip_header_get_unparsed_value(content_encoding);
return TRUE;
}
return FALSE;
}
static int set_expires_from_trans(belle_sip_refresher_t* refresher) {
belle_sip_transaction_t* transaction = BELLE_SIP_TRANSACTION(refresher->transaction);
belle_sip_response_t*response=transaction->last_response;
belle_sip_request_t*request=belle_sip_transaction_get_request(transaction);
belle_sip_header_expires_t* expires_header=belle_sip_message_get_header_by_type(request,belle_sip_header_expires_t);
belle_sip_header_contact_t* contact_header;
refresher->obtained_expires=-1;
if (strcmp("REGISTER",belle_sip_request_get_method(request))==0
|| expires_header /*if request has an expire header, refresher can always work*/) {
if (expires_header)
refresher->target_expires = belle_sip_header_expires_get_expires(expires_header);
/*An "expires" parameter on the "Contact" header has no semantics for
* SUBSCRIBE and is explicitly not equivalent to an "Expires" header in
* a SUBSCRIBE request or response.
*/
if (strcmp("REGISTER",belle_sip_request_get_method(request))==0){
if (!expires_header && (contact_header=belle_sip_message_get_header_by_type((belle_sip_message_t*)request,belle_sip_header_contact_t))){
int ct_expires=belle_sip_header_contact_get_expires(BELLE_SIP_HEADER_CONTACT(contact_header));
if (ct_expires!=-1) refresher->target_expires=ct_expires;
}
/*check in response also to get the obtained expires*/
if ((contact_header=belle_sip_refresher_get_contact(refresher))!=NULL){
/*matching contact, check for its possible expires param*/
refresher->obtained_expires=belle_sip_header_contact_get_expires(BELLE_SIP_HEADER_CONTACT(contact_header));
}
}
if (refresher->obtained_expires==-1){
/*no contact with expire or not relevant, looking for Expires header*/
if (response && (expires_header=(belle_sip_header_expires_t*)belle_sip_message_get_header(BELLE_SIP_MESSAGE(response),BELLE_SIP_EXPIRES))) {
refresher->obtained_expires = belle_sip_header_expires_get_expires(expires_header);
}
}
if (refresher->obtained_expires==-1) {
belle_sip_message("Neither Expires header nor corresponding Contact header found, checking from original request");
refresher->obtained_expires=refresher->target_expires;
}else if (refresher->target_expires>0 && refresher->obtained_expires==0){
const char* reason = response ? belle_sip_response_get_reason_phrase(response) : NULL;
/*check this case because otherwise we are going to loop fast in sending refresh requests.*/
/*"Test account created" is a special reason given by testers when we create temporary account.
Since this is a bit of hack, we can ignore logging in that case*/
if (reason && strcmp(reason, "Test account created") != 0) {
belle_sip_warning("Server replied with 0 expires, what does that mean?");
}
/*suppose it's a server bug and assume our target_expires is understood.*/
refresher->obtained_expires=refresher->target_expires;
}
} else if (strcmp("INVITE",belle_sip_request_get_method(request))==0) {
belle_sip_error("Refresher does not support INVITE yet");
return -1;
} else {
belle_sip_error("Refresher does not support [%s] yet",belle_sip_request_get_method(request));
return -1;
}
return 0;
}
static void testHttp200Ok(void) {
const char* raw_message = "HTTP/1.1 200 OK\r\n"
"Date: Tue, 07 Jan 2014 09:28:43 GMT\r\n"
"Server: Apache\r\n"
"Last-Modified: Tue, 18 Aug 1998 20:19:11 GMT\r\n"
"ETag: \"8982a60-14a17-335b3dcdcadc0\"\r\n"
"Accept-Ranges: bytes\r\n"
"Vary: Accept-Encoding\r\n"
"Content-Encoding: gzip\r\n"
"Content-Length: 6\r\n"
"Keep-Alive: timeout=15, max=100\r\n"
"Connection: Keep-Alive\r\n"
"Content-Type: text/plain\r\n"
"\r\n"
"blabla";
char* marshaled_msg;
belle_sip_message_t* msg = belle_sip_message_parse(raw_message);
belle_http_response_t* http_response;
belle_sip_header_extension_t* host_header;
belle_sip_object_t* tmp;
CU_ASSERT_PTR_NOT_NULL_FATAL(msg);
marshaled_msg=belle_sip_object_to_string(BELLE_SIP_OBJECT(msg));
belle_sip_object_unref(msg);
msg = belle_sip_message_parse(marshaled_msg);
belle_sip_free(marshaled_msg);
tmp=belle_sip_object_clone(BELLE_SIP_OBJECT(msg));
belle_sip_object_unref(msg);
msg=BELLE_SIP_MESSAGE(tmp);
CU_ASSERT_TRUE(BELLE_SIP_IS_INSTANCE_OF(msg,belle_http_response_t));
http_response=BELLE_HTTP_RESPONSE(msg);
CU_ASSERT_EQUAL(belle_http_response_get_status_code(http_response),200);
CU_ASSERT_STRING_EQUAL(belle_http_response_get_reason_phrase(http_response),"OK");
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(msg,"Date"));
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(msg,"ETag"));
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(msg,"Connection"));
CU_ASSERT_PTR_NOT_NULL(host_header=BELLE_SIP_HEADER_EXTENSION(belle_sip_message_get_header(msg,"Server")));
CU_ASSERT_STRING_EQUAL(belle_sip_header_extension_get_value(host_header),"Apache");
belle_sip_object_unref(msg);
}
int sal_op_send_request_with_expires(SalOp* op, belle_sip_request_t* request,int expires) {
belle_sip_header_expires_t* expires_header=(belle_sip_header_expires_t*)belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),BELLE_SIP_EXPIRES);
if (!expires_header && expires>=0) {
belle_sip_message_add_header(BELLE_SIP_MESSAGE(request),BELLE_SIP_HEADER(expires_header=belle_sip_header_expires_new()));
}
if (expires_header) belle_sip_header_expires_set_expires(expires_header,expires);
return sal_op_send_request(op,request);
}
const char *sal_custom_header_find(const SalCustomHeader *ch, const char *name){
if (ch){
belle_sip_header_t *h=belle_sip_message_get_header((belle_sip_message_t*)ch,name);
if (h){
return belle_sip_header_get_unparsed_value(h);
}
}
return NULL;
}
belle_sip_hop_t * belle_sip_stack_get_next_hop(belle_sip_stack_t *stack, belle_sip_request_t *req) {
belle_sip_header_route_t *route=BELLE_SIP_HEADER_ROUTE(belle_sip_message_get_header(BELLE_SIP_MESSAGE(req),"route"));
belle_sip_uri_t *uri;
if (route!=NULL){
uri=belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(route));
}else{
uri=belle_sip_request_get_uri(req);
}
return belle_sip_hop_new_from_uri(uri);
}
static void test_extract_source(void) {
const char * invite_1="INVITE sip:[email protected]:50343;transport=tcp;line=f18e0009dd6cc43 SIP/2.0\r\n"
"Via: SIP/2.0/TCP 37.59.129.73;branch=z9hG4bK.SKvK9U327e8mU68XUv5rt144pg\r\n"
"Via: SIP/2.0/UDP 192.168.1.12:15060;rport=15060;branch=z9hG4bK1596944937;received=81.56.113.2\r\n"
"Record-Route: <sip:37.59.129.73;lr;transport=tcp>\r\n"
"Record-Route: <sip:37.59.129.73;lr>\r\n"
"Max-Forwards: 70\r\n"
"From: <sip:[email protected]>;tag=711138653\r\n"
"To: <sip:[email protected]>\r\n"
"Call-ID: 977107319\r\n"
"CSeq: 21 INVITE\r\n"
"Contact: <sip:[email protected]:15060>\r\n"
"Subject: Phone call\r\n"
"User-Agent: Linphone/3.5.2 (eXosip2/3.6.0)\r\n"
"Allow: INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO\r\n"
"Content-Type: application/sdp\r\n"\
"Content-Length: 230\r\n\r\n";
const char * invite_2="INVITE sip:[email protected]:50343;transport=tcp;line=f18e0009dd6cc43 SIP/2.0\r\n"
"Via: SIP/2.0/UDP 192.168.1.12:15060;rport=15060;branch=z9hG4bK1596944937;received=81.56.113.2\r\n"
"Via: SIP/2.0/TCP 37.59.129.73;branch=z9hG4bK.SKvK9U327e8mU68XUv5rt144pg\r\n"
"Record-Route: <sip:37.59.129.73;lr;transport=tcp>\r\n"
"Record-Route: <sip:37.59.129.73;lr>\r\n"
"Max-Forwards: 70\r\n"
"From: <sip:[email protected]>;tag=711138653\r\n"
"To: <sip:[email protected]>\r\n"
"Call-ID: 977107319\r\n"
"CSeq: 21 INVITE\r\n"
"Contact: <sip:[email protected]:15060>\r\n"
"Subject: Phone call\r\n"
"User-Agent: Linphone/3.5.2 (eXosip2/3.6.0)\r\n"
"Allow: INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO\r\n"
"Content-Length: 0\r\n\r\n";
belle_sip_message_t* message = belle_sip_message_parse(invite_1);
belle_sip_request_t* request = BELLE_SIP_REQUEST(message);
belle_sip_uri_t* source =belle_sip_request_extract_origin(request);
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Content-type"));
CU_ASSERT_PTR_NOT_NULL(source);
CU_ASSERT_STRING_EQUAL(belle_sip_uri_get_host(source),"37.59.129.73");
CU_ASSERT_EQUAL(belle_sip_uri_get_port(source),0);
CU_ASSERT_STRING_EQUAL(belle_sip_uri_get_transport_param(source),"tcp");
belle_sip_object_unref(message);
message = belle_sip_message_parse(invite_2);
request = BELLE_SIP_REQUEST(message);
source =belle_sip_request_extract_origin(request);
CU_ASSERT_PTR_NOT_NULL(source);
CU_ASSERT_STRING_EQUAL(belle_sip_uri_get_host(source),"81.56.113.2");
CU_ASSERT_EQUAL(belle_sip_uri_get_port(source),15060);
CU_ASSERT_STRING_EQUAL(belle_sip_uri_get_transport_param(source),"udp");
belle_sip_object_unref(message);
}
void channel_parser_tester_recovery_from_error_base (const char* prelude,const char* raw_message) {
belle_sip_stack_t* stack = belle_sip_stack_new(NULL);
belle_sip_channel_t* channel = belle_sip_stream_channel_new_client(stack
, NULL
, 45421
, NULL
, "127.0.0.1"
, 45421);
belle_sip_request_t* request;
belle_sip_message_t* message;
if (prelude) {
channel->input_stream.write_ptr = strcpy(channel->input_stream.write_ptr,prelude);
channel->input_stream.write_ptr+=strlen(prelude);
belle_sip_channel_parse_stream(channel,FALSE);
}
channel->input_stream.write_ptr = strcpy(channel->input_stream.write_ptr,raw_message);
channel->input_stream.write_ptr+=strlen(raw_message);
belle_sip_channel_parse_stream(channel,FALSE);
CU_ASSERT_PTR_NOT_NULL(channel->incoming_messages);
CU_ASSERT_PTR_NOT_NULL(channel->incoming_messages->data);
message=BELLE_SIP_MESSAGE(channel->incoming_messages->data);
CU_ASSERT_TRUE(BELLE_SIP_OBJECT_IS_INSTANCE_OF(message,belle_sip_request_t));
request = BELLE_SIP_REQUEST(message);
CU_ASSERT_STRING_EQUAL(belle_sip_request_get_method(request),"REGISTER");
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Expires"));
CU_ASSERT_PTR_NOT_NULL(BELLE_SIP_HEADER_EXPIRES(belle_sip_message_get_header(message,"Expires")));
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Proxy-Authorization"));
check_uri_and_headers(message);
belle_sip_object_unref(BELLE_SIP_OBJECT(message));
belle_sip_object_unref(stack);
}
SalBodyHandler * sal_op_get_body_handler(SalOp *op, belle_sip_message_t *msg) {
belle_sip_body_handler_t *body_handler = belle_sip_message_get_body_handler(msg);
if (body_handler != NULL) {
belle_sip_header_content_type_t *content_type = belle_sip_message_get_header_by_type(msg, belle_sip_header_content_type_t);
belle_sip_header_content_length_t *content_length = belle_sip_message_get_header_by_type(msg, belle_sip_header_content_length_t);
belle_sip_header_t *content_encoding = belle_sip_message_get_header(msg, "Content-Encoding");
if (content_type != NULL) belle_sip_body_handler_add_header(body_handler, BELLE_SIP_HEADER(content_type));
if (content_length != NULL) belle_sip_body_handler_add_header(body_handler, BELLE_SIP_HEADER(content_length));
if (content_encoding != NULL) belle_sip_body_handler_add_header(body_handler, content_encoding);
}
return (SalBodyHandler *)body_handler;
}
void channel_parser_http_response () {
belle_sip_stack_t* stack = belle_sip_stack_new(NULL);
belle_sip_channel_t* channel = belle_sip_stream_channel_new_client(stack
, NULL
, 45421
, NULL
, "127.0.0.1"
, 45421);
const char * raw_message= "HTTP/1.1 200 OK\r\n"
"Cache-Control: private\r\n"
"Date: Tue, 07 Jan 2014 13:51:57 GMT\r\n"
"Content-Type: text/html; charset=utf-8\r\n"
"Server: Microsoft-IIS/6.0\r\n"
"X-Powered-By: ASP.NET\r\n"
"Content-Encoding: gzip\r\n"
"Vary: Accept-Encoding\r\n"
"Transfer-Encoding: chunked\r\n"
"\r\n"
"<html></html>\r\n\r\n";
belle_http_response_t* response;
belle_sip_message_t* message;
channel->input_stream.write_ptr = strcpy(channel->input_stream.write_ptr,raw_message);
channel->input_stream.write_ptr+=strlen(raw_message);
belle_sip_channel_parse_stream(channel,TRUE);
CU_ASSERT_PTR_NOT_NULL(channel->incoming_messages);
CU_ASSERT_PTR_NOT_NULL(channel->incoming_messages->data);
message=BELLE_SIP_MESSAGE(channel->incoming_messages->data);
CU_ASSERT_TRUE(BELLE_SIP_OBJECT_IS_INSTANCE_OF(message,belle_http_response_t));
response = BELLE_HTTP_RESPONSE(message);
CU_ASSERT_STRING_EQUAL(belle_http_response_get_reason_phrase(response),"OK");
CU_ASSERT_EQUAL(belle_http_response_get_status_code(response),200);
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Cache-Control"));
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"Vary"));
belle_sip_object_unref(BELLE_SIP_OBJECT(message));
belle_sip_object_unref(stack);
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
void belle_sip_server_transaction_init(belle_sip_server_transaction_t *t, belle_sip_provider_t *prov,belle_sip_request_t *req){
const char *branch;
belle_sip_header_via_t *via=BELLE_SIP_HEADER_VIA(belle_sip_message_get_header((belle_sip_message_t*)req,"via"));
branch=belle_sip_header_via_get_branch(via);
if (branch==NULL || strncmp(branch,BELLE_SIP_BRANCH_MAGIC_COOKIE,strlen(BELLE_SIP_BRANCH_MAGIC_COOKIE))!=0){
branch=req->rfc2543_branch;
if (branch==NULL) belle_sip_fatal("No computed branch for RFC2543 style of message, this should never happen.");
}
t->base.branch_id=belle_sip_strdup(branch);
belle_sip_transaction_init((belle_sip_transaction_t*)t,prov,req);
belle_sip_random_token(t->to_tag,sizeof(t->to_tag));
}
const char *sal_custom_header_find(const SalCustomHeader *ch, const char *name){
if (ch){
belle_sip_header_t *h=belle_sip_message_get_header((belle_sip_message_t*)ch,name);
if (h){
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(h,belle_sip_header_extension_t)){
return belle_sip_header_extension_get_value(BELLE_SIP_HEADER_EXTENSION(h));
}else{
return belle_sip_header_get_unparsed_value(h);
}
}
}
return NULL;
}
static void testHttpGet(void) {
const char* raw_message = "GET /index.php HTTP/1.1\r\n"
"User-Agent: Wget/1.14 (darwin11.4.2)\r\n"
"Accept: */*\r\n"
"Host: www.linphone.org\r\n"
"Connection: Keep-Alive\r\n"
"\r\n";
char* marshaled_msg;
belle_sip_message_t* msg = belle_sip_message_parse(raw_message);
belle_http_request_t* http_request;
belle_generic_uri_t* uri;
belle_sip_header_extension_t* host_header;
belle_sip_object_t* tmp;
CU_ASSERT_PTR_NOT_NULL_FATAL(msg);
marshaled_msg=belle_sip_object_to_string(BELLE_SIP_OBJECT(msg));
belle_sip_object_unref(msg);
msg = belle_sip_message_parse(marshaled_msg);
belle_sip_free(marshaled_msg);
tmp=belle_sip_object_clone(BELLE_SIP_OBJECT(msg));
belle_sip_object_unref(msg);
msg=BELLE_SIP_MESSAGE(tmp);
CU_ASSERT_TRUE(BELLE_SIP_IS_INSTANCE_OF(msg,belle_http_request_t));
http_request=BELLE_HTTP_REQUEST(msg);
CU_ASSERT_PTR_NOT_NULL_FATAL(uri=belle_http_request_get_uri(http_request));
CU_ASSERT_STRING_EQUAL(belle_generic_uri_get_path(uri),"/index.php");
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(msg,"User-Agent"));
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(msg,"Accept"));
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(msg,"Connection"));
CU_ASSERT_PTR_NOT_NULL(host_header=BELLE_SIP_HEADER_EXTENSION(belle_sip_message_get_header(msg,"Host")));
CU_ASSERT_STRING_EQUAL(belle_sip_header_extension_get_value(host_header),"www.linphone.org");
belle_sip_object_unref(msg);
}
static void call_set_error(SalOp* op,belle_sip_response_t* response){
SalError error=SalErrorUnknown;
SalReason sr=SalReasonUnknown;
belle_sip_header_t* reason_header = belle_sip_message_get_header(BELLE_SIP_MESSAGE(response),"Reason");
char* reason=(char*)belle_sip_response_get_reason_phrase(response);
int code = belle_sip_response_get_status_code(response);
if (reason_header){
reason = ms_strdup_printf("%s %s",reason,belle_sip_header_extension_get_value(BELLE_SIP_HEADER_EXTENSION(reason_header)));
}
sal_compute_sal_errors_from_code(code,&error,&sr);
op->base.root->callbacks.call_failure(op,error,sr,reason,code);
if (reason_header != NULL){
ms_free(reason);
}
}
BELLE_SIP_INSTANCIATE_CUSTOM_VPTR_END
void belle_sip_client_transaction_init(belle_sip_client_transaction_t *obj, belle_sip_provider_t *prov, belle_sip_request_t *req){
belle_sip_header_via_t *via=BELLE_SIP_HEADER_VIA(belle_sip_message_get_header((belle_sip_message_t*)req,"via"));
char token[BELLE_SIP_BRANCH_ID_LENGTH];
if (!via){
belle_sip_fatal("belle_sip_client_transaction_init(): No via in request.");
}
if (strcmp(belle_sip_request_get_method(req),"CANCEL")!=0){
obj->base.branch_id=belle_sip_strdup_printf(BELLE_SIP_BRANCH_MAGIC_COOKIE ".%s",belle_sip_random_token(token,sizeof(token)));
belle_sip_header_via_set_branch(via,obj->base.branch_id);
}else{
obj->base.branch_id=belle_sip_strdup(belle_sip_header_via_get_branch(via));
}
belle_sip_transaction_init((belle_sip_transaction_t*)obj, prov,req);
}
void belle_sip_server_transaction_send_response(belle_sip_server_transaction_t *t, belle_sip_response_t *resp){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)t;
belle_sip_header_to_t *to=(belle_sip_header_to_t*)belle_sip_message_get_header((belle_sip_message_t*)resp,"to");
belle_sip_dialog_t *dialog=base->dialog;
int status_code;
belle_sip_object_ref(resp);
if (!base->last_response){
belle_sip_hop_t* hop=belle_sip_response_get_return_hop(resp);
base->channel=belle_sip_provider_get_channel(base->provider,hop);
belle_sip_object_unref(hop);
if (!base->channel){
belle_sip_error("Transaction [%p]: No channel available for sending response.",t);
return;
}
belle_sip_object_ref(base->channel);
belle_sip_channel_add_listener(base->channel, BELLE_SIP_CHANNEL_LISTENER(t));
}
status_code=belle_sip_response_get_status_code(resp);
if (status_code!=100){
if (belle_sip_header_to_get_tag(to)==NULL){
//add a random to tag
belle_sip_header_to_set_tag(to,t->to_tag);
}
/*12.1 Creation of a Dialog
Dialogs are created through the generation of non-failure responses
to requests with specific methods. Within this specification, only
2xx and 101-199 responses with a To tag, where the request was
INVITE, will establish a dialog.*/
if (dialog && status_code>100 && status_code<300){
belle_sip_response_fill_for_dialog(resp,base->request);
}
}
if (BELLE_SIP_OBJECT_VPTR(t,belle_sip_server_transaction_t)->send_new_response(t,resp)==0){
if (base->last_response)
belle_sip_object_unref(base->last_response);
base->last_response=resp;
}
if (dialog)
belle_sip_dialog_update(dialog,BELLE_SIP_TRANSACTION(t),TRUE);
}
static belle_sip_request_t *make_ack(belle_sip_ict_t *obj, belle_sip_response_t *resp){
belle_sip_transaction_t *base=(belle_sip_transaction_t*)obj;
if (obj->ack==NULL){
obj->ack=belle_sip_request_new();
belle_sip_object_ref(obj->ack);
belle_sip_request_set_method(obj->ack,"ACK");
belle_sip_request_set_uri(obj->ack,belle_sip_request_get_uri(base->request));
belle_sip_util_copy_headers((belle_sip_message_t*)base->request,(belle_sip_message_t*)obj->ack,BELLE_SIP_VIA,FALSE);
belle_sip_util_copy_headers((belle_sip_message_t*)base->request,(belle_sip_message_t*)obj->ack,BELLE_SIP_CALL_ID,FALSE);
belle_sip_util_copy_headers((belle_sip_message_t*)base->request,(belle_sip_message_t*)obj->ack,BELLE_SIP_FROM,FALSE);
belle_sip_util_copy_headers((belle_sip_message_t*)resp,(belle_sip_message_t*)obj->ack,BELLE_SIP_TO,FALSE);
belle_sip_util_copy_headers((belle_sip_message_t*)base->request,(belle_sip_message_t*)obj->ack,BELLE_SIP_CONTACT,TRUE);
belle_sip_util_copy_headers((belle_sip_message_t*)base->request,(belle_sip_message_t*)obj->ack,BELLE_SIP_ROUTE,TRUE);
belle_sip_message_add_header((belle_sip_message_t*)obj->ack,
(belle_sip_header_t*)belle_sip_header_cseq_create(
belle_sip_header_cseq_get_seq_number((belle_sip_header_cseq_t*)belle_sip_message_get_header((belle_sip_message_t*)base->request,BELLE_SIP_CSEQ)),
"ACK"));
}
return obj->ack;
}
/*return TRUE if error code*/
bool_t sal_compute_sal_errors(belle_sip_response_t* response,SalError* sal_err,SalReason* sal_reason,char* reason, size_t reason_size) {
int code = belle_sip_response_get_status_code(response);
belle_sip_header_t* reason_header = belle_sip_message_get_header(BELLE_SIP_MESSAGE(response),"Reason");
*sal_err=SalErrorUnknown;
*sal_reason = SalReasonUnknown;
if (reason_header){
snprintf(reason
,reason_size
,"%s %s"
,belle_sip_response_get_reason_phrase(response)
,belle_sip_header_get_unparsed_value(reason_header));
} else {
strncpy(reason,belle_sip_response_get_reason_phrase(response),reason_size);
}
if (code>=400) {
sal_compute_sal_errors_from_code(code,sal_err,sal_reason);
return TRUE;
} else {
return FALSE;
}
}
belle_sip_request_t * belle_sip_client_transaction_create_cancel(belle_sip_client_transaction_t *t){
belle_sip_message_t *orig=(belle_sip_message_t*)t->base.request;
belle_sip_request_t *req;
const char *orig_method=belle_sip_request_get_method((belle_sip_request_t*)orig);
if (strcmp(orig_method,"ACK")==0 || strcmp(orig_method,"INVITE")!=0){
belle_sip_error("belle_sip_client_transaction_create_cancel() cannot be used for ACK or non-INVITE transactions.");
return NULL;
}
if (t->base.state!=BELLE_SIP_TRANSACTION_PROCEEDING){
belle_sip_error("belle_sip_client_transaction_create_cancel() can only be used in state BELLE_SIP_TRANSACTION_PROCEEDING"
" but current transaction state is %s",belle_sip_transaction_state_to_string(t->base.state));
return NULL;
}
req=belle_sip_request_new();
belle_sip_request_set_method(req,"CANCEL");
/* 9.1 Client Behavior
Since requests other than INVITE are responded to immediately,
sending a CANCEL for a non-INVITE request would always create a
race condition.
The following procedures are used to construct a CANCEL request. The
Request-URI, Call-ID, To, the numeric part of CSeq, and From header
fields in the CANCEL request MUST be identical to those in the
request being cancelled, including tags. A CANCEL constructed by a
client MUST have only a single Via header field value matching the
top Via value in the request being cancelled.*/
belle_sip_request_set_uri(req,(belle_sip_uri_t*)belle_sip_object_clone((belle_sip_object_t*)belle_sip_request_get_uri((belle_sip_request_t*)orig)));
belle_sip_util_copy_headers(orig,(belle_sip_message_t*)req,"via",FALSE);
belle_sip_util_copy_headers(orig,(belle_sip_message_t*)req,"call-id",FALSE);
belle_sip_util_copy_headers(orig,(belle_sip_message_t*)req,"from",FALSE);
belle_sip_util_copy_headers(orig,(belle_sip_message_t*)req,"to",FALSE);
belle_sip_util_copy_headers(orig,(belle_sip_message_t*)req,"route",TRUE);
belle_sip_util_copy_headers(orig,(belle_sip_message_t*)req,BELLE_SIP_MAX_FORWARDS,FALSE);
belle_sip_message_add_header((belle_sip_message_t*)req,
(belle_sip_header_t*)belle_sip_header_cseq_create(
belle_sip_header_cseq_get_seq_number((belle_sip_header_cseq_t*)belle_sip_message_get_header(orig,"cseq")),
"CANCEL"));
return req;
}
static void test401ResponseWithoutResponsePhrase(void) {
const char* raw_message = "SIP/2.0 401 \r\n"
"Call-ID: 577586163\r\n"
"CSeq: 21 REGISTER\r\n"
"From: <sip:[email protected]>;tag=1790643209\r\n"
"Server: Cirpack/v4.42x (gw_sip)\r\n"
"To: <sip:[email protected]>;tag=00-08075-24212984-22e348d97\r\n"
"Via: SIP/2.0/UDP 192.168.0.18:5062;received=81.56.113.2;rport=5062;branch=z9hG4bK1939354046\r\n"
"WWW-Authenticate: Digest realm=\"sip.ovh.net\",\r\n nonce=\"24212965507cde726e8bc37e04686459\",opaque=\"241b9fb347752f2\",stale=false,algorithm=MD5\r\n"
"Content-Length: 0\r\n\r\n";
belle_sip_response_t* response;
belle_sip_message_t* message = belle_sip_message_parse(raw_message);
char* encoded_message = belle_sip_object_to_string(BELLE_SIP_OBJECT(message));
belle_sip_object_unref(BELLE_SIP_OBJECT(message));
message = belle_sip_message_parse(encoded_message);
response = BELLE_SIP_RESPONSE(message);
CU_ASSERT_EQUAL(belle_sip_response_get_status_code(response),401);
CU_ASSERT_PTR_NULL(belle_sip_response_get_reason_phrase(response));
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header(message,"WWW-Authenticate"));
check_uri_and_headers(message);
belle_sip_object_unref(message);
belle_sip_free(encoded_message);
}
/*returns TRUE if a body is expected, and initialize a few things in the input stream context*/
static int check_body(belle_sip_channel_t *obj){
belle_sip_message_t *msg=obj->input_stream.msg;
belle_sip_header_content_length_t* content_length_header = belle_sip_message_get_header_by_type(msg,belle_sip_header_content_length_t);
int expect_body=FALSE;
obj->input_stream.content_length= content_length_header ? belle_sip_header_content_length_get_content_length(content_length_header) : 0;
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(msg,belle_sip_response_t) || BELLE_SIP_OBJECT_IS_INSTANCE_OF(msg,belle_sip_request_t)){
expect_body=obj->input_stream.content_length>0;
}else{/*http*/
if (belle_sip_message_get_header_by_type(msg, belle_sip_header_content_type_t)!=NULL){
belle_sip_header_t *transfer_encoding=belle_sip_message_get_header(msg,"Transfer-Encoding");
if (transfer_encoding){
const char *value=belle_sip_header_get_unparsed_value(transfer_encoding);
if (strstr(value,"chunked")!=0){
obj->input_stream.chuncked_mode=1;
obj->input_stream.content_length=0;
obj->input_stream.chunk_size=-1;
obj->input_stream.chunk_read_size=0;
}
}
expect_body=TRUE;
}
}
if (expect_body){
belle_sip_body_handler_t *bh;
/*should notify the listeners*/
BELLE_SIP_INVOKE_LISTENERS_ARG1_ARG2(obj->listeners,belle_sip_channel_listener_t,on_message_headers,obj,msg);
/*check if the listener has setup a body handler, otherwise create a default one*/
if ((bh=belle_sip_message_get_body_handler(msg))==NULL){
belle_sip_message_set_body_handler(msg,(bh=(belle_sip_body_handler_t*)belle_sip_memory_body_handler_new(NULL,NULL)));
}
belle_sip_body_handler_begin_transfer(bh);
}
return expect_body;
}
void sal_op_call_process_notify(SalOp *op, const belle_sip_request_event_t *event, belle_sip_server_transaction_t* server_transaction){
belle_sip_request_t* req = belle_sip_request_event_get_request(event);
const char* body = belle_sip_message_get_body(BELLE_SIP_MESSAGE(req));
belle_sip_header_t* header_event=belle_sip_message_get_header(BELLE_SIP_MESSAGE(req),"Event");
belle_sip_header_content_type_t* content_type = belle_sip_message_get_header_by_type(req,belle_sip_header_content_type_t);
belle_sip_response_t* resp;
ms_message("Receiving NOTIFY request on op [%p]",op);
if (header_event
&& strncasecmp(belle_sip_header_get_unparsed_value(header_event),"refer",strlen("refer"))==0
&& content_type
&& strcmp(belle_sip_header_content_type_get_type(content_type),"message")==0
&& strcmp(belle_sip_header_content_type_get_subtype(content_type),"sipfrag")==0
&& body){
belle_sip_response_t* sipfrag=BELLE_SIP_RESPONSE(belle_sip_message_parse(body));
if (sipfrag){
int code=belle_sip_response_get_status_code(sipfrag);
SalReferStatus status=SalReferFailed;
if (code<200){
status=SalReferTrying;
}else if (code<300){
status=SalReferSuccess;
}else if (code>=400){
status=SalReferFailed;
}
belle_sip_object_unref(sipfrag);
resp = sal_op_create_response_from_request(op,req,200);
belle_sip_server_transaction_send_response(server_transaction,resp);
op->base.root->callbacks.notify_refer(op,status);
}
}else{
ms_error("Notify without sipfrag, trashing");
resp = sal_op_create_response_from_request(op,req,501);
belle_sip_server_transaction_send_response(server_transaction,resp);
}
}
static void http_channel_context_handle_response(belle_http_channel_context_t *ctx , belle_sip_channel_t *chan, belle_http_response_t *response){
belle_http_request_t *req=NULL;
belle_http_response_event_t ev={0};
int code;
belle_sip_header_t *connection;
/*pop the request matching this response*/
ctx->pending_requests=belle_sip_list_pop_front(ctx->pending_requests,(void**)&req);
if (req==NULL){
belle_sip_error("Receiving http response not matching any request.");
return;
}
if (belle_http_request_is_cancelled(req)) {
belle_sip_warning("Receiving http response for a cancelled request.");
return;
}
connection=belle_sip_message_get_header((belle_sip_message_t *)response,"Connection");
if (connection && strstr(belle_sip_header_get_unparsed_value(connection),"close")!=NULL)
chan->about_to_be_closed=TRUE;
belle_http_request_set_response(req,response);
code=belle_http_response_get_status_code(response);
if ((code==401 || code==407) && http_channel_context_handle_authentication(ctx,req)==0 ){
/*nothing to do, the request has been resubmitted with authentication*/
}else{
/*else notify the app about the response received*/
ev.source=(belle_sip_object_t*)ctx->provider;
ev.request=req;
ev.response=response;
BELLE_HTTP_REQUEST_INVOKE_LISTENER(req,process_response,&ev);
if( req->background_task_id ){
belle_sip_warning("HTTP request finished: ending bg task id=[%x]", req->background_task_id);
belle_sip_end_background_task(req->background_task_id);
req->background_task_id = 0;
}
}
belle_sip_object_unref(req);
}
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));
}
}
