static void testUriHeadersInInvite(void) {
belle_sip_request_t* request;
belle_sip_stack_t *stack=belle_sip_stack_new(NULL);
belle_sip_provider_t *prov=belle_sip_provider_new(stack,NULL);
const char* raw_uri="sip:[email protected]"
"?header1=blabla"
"&header2=blue%3Bweftutu%3Dbla"
"&From=toto"
"&To=sip%3Atoto%40titi.com"
"&Call-ID=asdads"
"&CSeq=asdasd"
"&Via=asdasd"
"&Accept=adsad"
"&Accept-Encoding=adsad"
"&Accept-Language=adsad"
"&Allow=adsad"
"&Record-Route=adsad"
"&Contact=adsad"
"&Organization=adsad"
"&Supported=adsad"
"&User-Agent=adsad";
belle_sip_header_t* raw_header;
request=belle_sip_request_create( belle_sip_uri_parse(raw_uri)
,"INVITE"
,belle_sip_provider_create_call_id(prov)
,belle_sip_header_cseq_create(20,"INVITE")
,belle_sip_header_from_create2("sip:[email protected]","4654")
,NULL
,belle_sip_header_via_new()
,70);
CU_ASSERT_PTR_NOT_NULL(request);
CU_ASSERT_PTR_NOT_NULL(raw_header=belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"header1"));
if (raw_header) {
CU_ASSERT_STRING_EQUAL(belle_sip_header_extension_get_value(BELLE_SIP_HEADER_EXTENSION(raw_header)),"blabla");
}
CU_ASSERT_PTR_NOT_NULL(raw_header=belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"header2"));
if (raw_header) {
CU_ASSERT_STRING_EQUAL(belle_sip_header_extension_get_value(BELLE_SIP_HEADER_EXTENSION(raw_header)),"blue;weftutu=bla");
}
CU_ASSERT_PTR_NOT_NULL(raw_header=belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"To"));
if (raw_header) {
CU_ASSERT_STRING_EQUAL(belle_sip_header_extension_get_value(BELLE_SIP_HEADER_EXTENSION(raw_header)),"sip:[email protected]");
}
CU_ASSERT_STRING_NOT_EQUAL(belle_sip_header_get_unparsed_value(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"From")),"toto");
CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"Record-Route"));
CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"Accept"));
CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"Accept-Encoding"));
CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"Accept-Language"));
CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"Allow"));
CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"Contact"));
CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"Organization"));
CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"Supported"));
CU_ASSERT_PTR_NULL(belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),"User-Agent"));
belle_sip_object_unref(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){
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 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);
}
}
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);
}
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_extension_get_value(BELLE_SIP_HEADER_EXTENSION(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==100){
status=SalReferTrying;
}else if (code==200){
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 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 server_process_request_event(void *obj, const belle_sip_request_event_t *event){
endpoint_t* endpoint = (endpoint_t*)obj;
belle_sip_server_transaction_t* server_transaction =belle_sip_provider_create_server_transaction(endpoint->provider,belle_sip_request_event_get_request(event));
belle_sip_request_t* req = belle_sip_transaction_get_request(BELLE_SIP_TRANSACTION(server_transaction));
belle_sip_response_t* resp;
belle_sip_header_contact_t* contact;
belle_sip_header_expires_t* expires;
belle_sip_header_authorization_t* authorization;
belle_sip_header_via_t* via;
const char* raw_authenticate_digest = "WWW-Authenticate: Digest "
"algorithm=MD5, realm=\"" SIPDOMAIN "\", opaque=\"1bc7f9097684320\"";
belle_sip_header_www_authenticate_t* www_authenticate=NULL;
const char* auth_uri;
const char* qop;
unsigned char auth_ok=0;
char local_resp[33];
belle_sip_message("caller_process_request_event received [%s] message",belle_sip_request_get_method(belle_sip_request_event_get_request(event)));
switch (endpoint->auth) {
case none: {
auth_ok=1;
break;
}
case digest_auth:
case digest: {
if ((authorization=belle_sip_message_get_header_by_type(req,belle_sip_header_authorization_t)) != NULL){
qop=belle_sip_header_authorization_get_qop(authorization);
if (qop && strcmp(qop,"auth")==0) {
compute_response_auth_qop( belle_sip_header_authorization_get_username(authorization)
,belle_sip_header_authorization_get_realm(authorization)
,PASSWD
,endpoint->nonce
,endpoint->nonce_count
,belle_sip_header_authorization_get_cnonce(authorization)
,belle_sip_header_authorization_get_qop(authorization)
,belle_sip_request_get_method(req)
,auth_uri=belle_sip_uri_to_string(belle_sip_header_authorization_get_uri(authorization))
,local_resp);
} else {
/*digest*/
compute_response(belle_sip_header_authorization_get_username(authorization)
,belle_sip_header_authorization_get_realm(authorization)
,PASSWD
,endpoint->nonce
,belle_sip_request_get_method(req)
,auth_uri=belle_sip_uri_to_string(belle_sip_header_authorization_get_uri(authorization))
,local_resp);
}
belle_sip_free((void*)auth_uri);
auth_ok=strcmp(belle_sip_header_authorization_get_response(authorization),local_resp)==0;
}
if (auth_ok && endpoint->nonce_count<MAX_NC_COUNT ) {/*revoke nonce after MAX_NC_COUNT uses*/
if (endpoint->auth == digest ) {
sprintf(endpoint->nonce,"%p",authorization); //*change the nonce for next auth*/
} else {
endpoint->nonce_count++;
}
} else {
auth_ok=0;
www_authenticate=belle_sip_header_www_authenticate_parse(raw_authenticate_digest);
sprintf(endpoint->nonce,"%p",authorization); //*change the nonce for next auth*/
belle_sip_header_www_authenticate_set_nonce(www_authenticate,endpoint->nonce);
if (endpoint->auth == digest_auth) {
belle_sip_header_www_authenticate_add_qop(www_authenticate,"auth");
if (endpoint->nonce_count>=MAX_NC_COUNT) {
belle_sip_header_www_authenticate_set_stale(www_authenticate,1);
endpoint->nonce_count=1;
}
}
}
}
break;
default:
break;
}
if (auth_ok) {
resp=belle_sip_response_create_from_request(belle_sip_request_event_get_request(event),200);
if (!endpoint->expire_in_contact) {
belle_sip_message_add_header(BELLE_SIP_MESSAGE(resp),BELLE_SIP_HEADER(expires=belle_sip_message_get_header_by_type(req,belle_sip_header_expires_t)));
}
if (strcmp(belle_sip_request_get_method(req),"REGISTER")==0) {
contact=belle_sip_message_get_header_by_type(req,belle_sip_header_contact_t);
} else {
contact=belle_sip_header_contact_new();
}
if(endpoint->unreconizable_contact) {
/*put an unexpected address*/
belle_sip_uri_set_host(belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(contact)),"nimportequoi.com");
}
belle_sip_message_add_header(BELLE_SIP_MESSAGE(resp),BELLE_SIP_HEADER(contact));
if (strcmp(belle_sip_request_get_method(req),"PUBLISH")==0) {
belle_sip_header_t* sip_if_match=belle_sip_message_get_header(BELLE_SIP_MESSAGE(resp),"SIP-If-Match");
if (sip_if_match) {
CU_ASSERT_STRING_EQUAL(belle_sip_header_extension_get_value(BELLE_SIP_HEADER_EXTENSION(sip_if_match)),"blablietag");
}
/*check for body*/
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_body(BELLE_SIP_MESSAGE(req)));
if (belle_sip_message_get_body(BELLE_SIP_MESSAGE(req))) {
CU_ASSERT_STRING_EQUAL(belle_sip_message_get_body(BELLE_SIP_MESSAGE(req)),publish_body);
}
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header_by_type(req,belle_sip_header_content_type_t));
CU_ASSERT_PTR_NOT_NULL(belle_sip_message_get_header_by_type(req,belle_sip_header_content_length_t));
belle_sip_message_add_header(BELLE_SIP_MESSAGE(resp),belle_sip_header_create("SIP-ETag","blablietag"));
}
} else {
resp=belle_sip_response_create_from_request(belle_sip_request_event_get_request(event),401);
if (www_authenticate)
belle_sip_message_add_header(BELLE_SIP_MESSAGE(resp),BELLE_SIP_HEADER(www_authenticate));
}
if (endpoint->received) {
via=belle_sip_message_get_header_by_type(req,belle_sip_header_via_t);
belle_sip_header_via_set_received(via,endpoint->received);
}
belle_sip_server_transaction_send_response(server_transaction,resp);
}
static void process_response_event(belle_sip_listener_t *user_ctx, const belle_sip_response_event_t *event){
belle_sip_client_transaction_t* client_transaction = belle_sip_response_event_get_client_transaction(event);
belle_sip_response_t* response = belle_sip_response_event_get_response(event);
belle_sip_request_t* request=belle_sip_transaction_get_request(BELLE_SIP_TRANSACTION(client_transaction));
int response_code = belle_sip_response_get_status_code(response);
belle_sip_refresher_t* refresher=(belle_sip_refresher_t*)user_ctx;
belle_sip_header_contact_t *contact;
if (refresher && (client_transaction !=refresher->transaction))
return; /*not for me*/
set_or_update_dialog(refresher,belle_sip_response_event_get_dialog(event));
/*success case:*/
if (response_code>=200 && response_code<300){
refresher->auth_failures=0;
refresher->number_of_retry=0;
/*great, success*/
if (strcmp(belle_sip_request_get_method(request),"PUBLISH")==0) {
/*search for etag*/
belle_sip_header_t* etag=belle_sip_message_get_header(BELLE_SIP_MESSAGE(response),"SIP-ETag");
if (etag) {
belle_sip_header_t* sip_if_match = belle_sip_header_create("SIP-If-Match",belle_sip_header_extension_get_value(BELLE_SIP_HEADER_EXTENSION(etag)));
/*update request for next refresh*/
belle_sip_message_remove_header(BELLE_SIP_MESSAGE(request),"SIP-If-Match");
belle_sip_message_add_header(BELLE_SIP_MESSAGE(request),sip_if_match);
} else if (refresher->target_expires > 0){
belle_sip_warning("Refresher [%p] received 200ok to a publish without etag",refresher);
}
}
/*update expire if needed*/
set_expires_from_trans(refresher);
if (refresher->target_expires<=0) {
belle_sip_refresher_stop(refresher); /*doesn't not make sense to refresh if expire =0;*/
} else {
/*remove all contact with expire = 0 from request if any, because no need to refresh them*/
const belle_sip_list_t * contact_list= belle_sip_message_get_headers(BELLE_SIP_MESSAGE(request),BELLE_SIP_CONTACT);
belle_sip_list_t *iterator, *head;
if (contact_list) {
for (iterator=head=belle_sip_list_copy(contact_list);iterator!=NULL;iterator=iterator->next) {
belle_sip_header_contact_t *contact_for_expire = (belle_sip_header_contact_t *)(iterator->data);
if (belle_sip_header_contact_get_expires(contact_for_expire) == 0) {
belle_sip_message_remove_header_from_ptr(BELLE_SIP_MESSAGE(request),BELLE_SIP_HEADER(contact_for_expire));
}
}
belle_sip_list_free(head);
}
}
if (refresher->state==started) {
if (!refresher->first_acknoleged_request)
belle_sip_object_ref(refresher->first_acknoleged_request = request);
if (is_contact_address_acurate(refresher,request)) {
schedule_timer(refresher); /*re-arm timer*/
} else {
belle_sip_message("belle_sip_refresher_start(): refresher [%p] is resubmitting request because contact sent was not correct in original request.",refresher);
belle_sip_refresher_refresh(refresher,refresher->target_expires);
return;
}
}
else belle_sip_message("Refresher [%p] not scheduling next refresh, because it was stopped",refresher);
}else{/*special error cases*/
switch (response_code) {
case 301:
case 302:
contact=belle_sip_message_get_header_by_type(response,belle_sip_header_contact_t);
if (contact){
belle_sip_uri_t *uri=belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(contact));
if (uri && belle_sip_refresher_refresh_internal(refresher,refresher->target_expires,TRUE,&refresher->auth_events,uri)==0)
return;
}
break;
case 401:
case 407:
refresher->auth_failures++;
if (refresher->auth_failures>1){
/*avoid looping with 407 or 401 */
belle_sip_warning("Authentication is failing constantly, %s",(refresher->target_expires>0)? "will retry later":"giving up.");
if (refresher->target_expires>0) retry_later(refresher);
refresher->auth_failures=0; /*reset auth failure*/
break;
}
if (refresher->auth_events) {
refresher->auth_events=belle_sip_list_free_with_data(refresher->auth_events,(void (*)(void*))belle_sip_auth_event_destroy);
}
if (belle_sip_refresher_refresh_internal(refresher,refresher->target_expires,TRUE,&refresher->auth_events,NULL)==0)
return; /*ok, keep 401 internal*/
break; /*Else notify user of registration failure*/
case 403:
/*In case of 403, we will retry later, just in case*/
if (refresher->target_expires>0) retry_later(refresher);
break;
case 412:
if (strcmp(belle_sip_request_get_method(request),"PUBLISH")==0) {
belle_sip_message_remove_header(BELLE_SIP_MESSAGE(request),"SIP-If-Match");
if (refresher->target_expires>0) {
retry_later_on_io_error(refresher);
return; /*do not notify this kind of error*/
}
} else {
if (refresher->target_expires>0) retry_later(refresher);
}
break;
case 423:{
belle_sip_header_extension_t *min_expires=BELLE_SIP_HEADER_EXTENSION(belle_sip_message_get_header((belle_sip_message_t*)response,"Min-Expires"));
if (min_expires){
const char *value=belle_sip_header_extension_get_value(min_expires);
if (value){
int new_expires=atoi(value);
if (new_expires>0 && refresher->state==started){
refresher->target_expires=new_expires;
belle_sip_refresher_refresh(refresher,refresher->target_expires);
return;
}
}
}else belle_sip_warning("Receiving 423 but no min-expires header.");
break;
}
case 491: {
if (refresher->target_expires>0) {
retry_later_on_io_error(refresher);
return; /*do not notify this kind of error*/
}
}
case 505:
case 501:
/*irrecoverable errors, probably no need to retry later*/
break;
default:
/*for all other errors, retry later*/
if (refresher->target_expires>0) retry_later(refresher);
break;
}
}
if (refresher->listener) refresher->listener(refresher,refresher->user_data,response_code, belle_sip_response_get_reason_phrase(response));
}
static void process_request_event(void *op_base, const belle_sip_request_event_t *event) {
SalOp* op = (SalOp*)op_base;
belle_sip_server_transaction_t* server_transaction=NULL;
belle_sdp_session_description_t* sdp;
belle_sip_request_t* req = belle_sip_request_event_get_request(event);
belle_sip_dialog_state_t dialog_state;
belle_sip_response_t* resp;
belle_sip_header_t* call_info;
if (strcmp("ACK",belle_sip_request_get_method(req))!=0){ /*ACK does'nt create srv transaction*/
server_transaction = belle_sip_provider_create_server_transaction(op->base.root->prov,belle_sip_request_event_get_request(event));
belle_sip_object_ref(server_transaction);
belle_sip_transaction_set_application_data(BELLE_SIP_TRANSACTION(server_transaction),op);
sal_op_ref(op);
}
if (strcmp("INVITE",belle_sip_request_get_method(req))==0) {
if (op->pending_server_trans) belle_sip_object_unref(op->pending_server_trans);
/*updating pending invite transaction*/
op->pending_server_trans=server_transaction;
belle_sip_object_ref(op->pending_server_trans);
}
if (!op->dialog) {
set_or_update_dialog(op,belle_sip_provider_create_dialog(op->base.root->prov,BELLE_SIP_TRANSACTION(op->pending_server_trans)));
ms_message("new incoming call from [%s] to [%s]",sal_op_get_from(op),sal_op_get_to(op));
}
dialog_state=belle_sip_dialog_get_state(op->dialog);
switch(dialog_state) {
case BELLE_SIP_DIALOG_NULL: {
if (strcmp("INVITE",belle_sip_request_get_method(req))==0) {
if (!op->replaces && (op->replaces=belle_sip_message_get_header_by_type(BELLE_SIP_MESSAGE(req),belle_sip_header_replaces_t))) {
belle_sip_object_ref(op->replaces);
} else if(op->replaces) {
ms_warning("replace header already set");
}
process_sdp_for_invite(op,req);
if ((call_info=belle_sip_message_get_header(BELLE_SIP_MESSAGE(req),"Call-Info"))) {
if( strstr(belle_sip_header_extension_get_value(BELLE_SIP_HEADER_EXTENSION(call_info)),"answer-after=") != NULL) {
op->auto_answer_asked=TRUE;
ms_message("The caller asked to automatically answer the call(Emergency?)\n");
}
}
op->base.root->callbacks.call_received(op);
break;
} /* else same behavior as for EARLY state*/
}
case BELLE_SIP_DIALOG_EARLY: {
//hmm probably a cancel
if (strcmp("CANCEL",belle_sip_request_get_method(req))==0) {
if(belle_sip_request_event_get_server_transaction(event)) {
/*first answer 200 ok to cancel*/
belle_sip_server_transaction_send_response(server_transaction
,sal_op_create_response_from_request(op,req,200));
/*terminate invite transaction*/
call_terminated(op
,op->pending_server_trans
,belle_sip_transaction_get_request(BELLE_SIP_TRANSACTION(op->pending_server_trans)),487);
} else {
/*call leg does not exist*/
belle_sip_server_transaction_send_response(server_transaction
,sal_op_create_response_from_request(op,req,481));
}
} else if (strcmp("PRACK",belle_sip_request_get_method(req))==0) {
resp=sal_op_create_response_from_request(op,req,200);
belle_sip_server_transaction_send_response(server_transaction,resp);
} else {
belle_sip_error("Unexpected method [%s] for dialog state BELLE_SIP_DIALOG_EARLY",belle_sip_request_get_method(req));
unsupported_method(server_transaction,req);
}
break;
}
case BELLE_SIP_DIALOG_CONFIRMED:
/*great ACK received*/
if (strcmp("ACK",belle_sip_request_get_method(req))==0) {
if (op->sdp_offering){
if ((sdp=belle_sdp_session_description_create(BELLE_SIP_MESSAGE(req)))){
if (op->base.remote_media)
sal_media_description_unref(op->base.remote_media);
op->base.remote_media=sal_media_description_new();
sdp_to_media_description(sdp,op->base.remote_media);
sdp_process(op);
belle_sip_object_unref(sdp);
}
}
/*FIXME
if (op->reinvite){
op->reinvite=FALSE;
}*/
op->base.root->callbacks.call_ack(op);
} else if(strcmp("BYE",belle_sip_request_get_method(req))==0) {
resp=sal_op_create_response_from_request(op,req,200);
belle_sip_server_transaction_send_response(server_transaction,resp);
op->base.root->callbacks.call_terminated(op,op->dir==SalOpDirIncoming?sal_op_get_from(op):sal_op_get_to(op));
op->state=SalOpStateTerminating;
/*call end not notified by dialog deletion because transaction can end before dialog*/
} else if(strcmp("INVITE",belle_sip_request_get_method(req))==0) {
/*re-invite*/
if (op->base.remote_media){
sal_media_description_unref(op->base.remote_media);
op->base.remote_media=NULL;
}
if (op->result){
sal_media_description_unref(op->result);
op->result=NULL;
}
process_sdp_for_invite(op,req);
op->base.root->callbacks.call_updating(op);
} else if (strcmp("INFO",belle_sip_request_get_method(req))==0){
if (belle_sip_message_get_body(BELLE_SIP_MESSAGE(req))
&& strstr(belle_sip_message_get_body(BELLE_SIP_MESSAGE(req)),"picture_fast_update")) {
/*vfu request*/
ms_message("Receiving VFU request on op [%p]",op);
if (op->base.root->callbacks.vfu_request){
op->base.root->callbacks.vfu_request(op);
}
}else{
SalBody salbody;
if (sal_op_get_body(op,(belle_sip_message_t*)req,&salbody)) {
op->base.root->callbacks.info_received(op,&salbody);
} else {
op->base.root->callbacks.info_received(op,NULL);
}
}
resp=sal_op_create_response_from_request(op,req,200);
belle_sip_server_transaction_send_response(server_transaction,resp);
}else if (strcmp("REFER",belle_sip_request_get_method(req))==0) {
sal_op_process_refer(op,event,server_transaction);
} else if (strcmp("NOTIFY",belle_sip_request_get_method(req))==0) {
sal_op_call_process_notify(op,event,server_transaction);
} else if (strcmp("OPTIONS",belle_sip_request_get_method(req))==0) {
resp=sal_op_create_response_from_request(op,req,200);
belle_sip_server_transaction_send_response(server_transaction,resp);
} else if (strcmp("CANCEL",belle_sip_request_get_method(req))==0) {
/*call leg does not exist because 200ok already sent*/
belle_sip_server_transaction_send_response( server_transaction
,sal_op_create_response_from_request(op,req,481));
} else{
ms_error("unexpected method [%s] for dialog [%p]",belle_sip_request_get_method(req),op->dialog);
unsupported_method(server_transaction,req);
}
break;
default: {
ms_error("unexpected dialog state [%s]",belle_sip_dialog_state_to_string(dialog_state));
}
/* no break */
}
if (server_transaction) belle_sip_object_unref(server_transaction);
}
