forked from mirrors/linphone-iphone
976 lines
34 KiB
C++
976 lines
34 KiB
C++
#include "sal.hpp"
|
|
#include "call_op.h"
|
|
#include "presence_op.h"
|
|
#include "event_op.h"
|
|
#include "message_op.h"
|
|
#include "bellesip_sal/sal_impl.h"
|
|
#include "tester_utils.h"
|
|
#include "private.h"
|
|
|
|
using namespace std;
|
|
|
|
LINPHONE_BEGIN_NAMESPACE
|
|
|
|
void Sal::process_dialog_terminated_cb(void *sal, const belle_sip_dialog_terminated_event_t *event) {
|
|
belle_sip_dialog_t* dialog = belle_sip_dialog_terminated_event_get_dialog(event);
|
|
SalOp* op = reinterpret_cast<SalOp *>(belle_sip_dialog_get_application_data(dialog));
|
|
if (op && op->callbacks && op->callbacks->process_dialog_terminated) {
|
|
op->callbacks->process_dialog_terminated(op,event);
|
|
} else {
|
|
ms_error("sal process_dialog_terminated no op found for this dialog [%p], ignoring",dialog);
|
|
}
|
|
}
|
|
|
|
void Sal::process_io_error_cb(void *user_ctx, const belle_sip_io_error_event_t *event){
|
|
belle_sip_client_transaction_t*client_transaction;
|
|
SalOp* op;
|
|
if (BELLE_SIP_OBJECT_IS_INSTANCE_OF(belle_sip_io_error_event_get_source(event),belle_sip_client_transaction_t)) {
|
|
client_transaction=BELLE_SIP_CLIENT_TRANSACTION(belle_sip_io_error_event_get_source(event));
|
|
op = (SalOp*)belle_sip_transaction_get_application_data(BELLE_SIP_TRANSACTION(client_transaction));
|
|
/*also reset auth count on IO error*/
|
|
op->auth_requests=0;
|
|
if (op->callbacks && op->callbacks->process_io_error) {
|
|
op->callbacks->process_io_error(op,event);
|
|
}
|
|
} else {
|
|
/*ms_error("sal process_io_error not implemented yet for non transaction");*/
|
|
/*nop, because already handle at transaction layer*/
|
|
}
|
|
}
|
|
|
|
void Sal::process_request_event_cb(void *ud, const belle_sip_request_event_t *event) {
|
|
Sal *sal=(Sal*)ud;
|
|
SalOp* op=NULL;
|
|
belle_sip_request_t* req = belle_sip_request_event_get_request(event);
|
|
belle_sip_dialog_t* dialog=belle_sip_request_event_get_dialog(event);
|
|
belle_sip_header_address_t* origin_address;
|
|
belle_sip_header_address_t* address=NULL;
|
|
belle_sip_header_from_t* from_header;
|
|
belle_sip_header_to_t* to;
|
|
belle_sip_header_diversion_t* diversion;
|
|
belle_sip_response_t* resp;
|
|
belle_sip_header_t *evh;
|
|
const char *method=belle_sip_request_get_method(req);
|
|
belle_sip_header_contact_t* remote_contact = belle_sip_message_get_header_by_type(req, belle_sip_header_contact_t);
|
|
|
|
from_header=belle_sip_message_get_header_by_type(BELLE_SIP_MESSAGE(req),belle_sip_header_from_t);
|
|
|
|
if (dialog) {
|
|
op=(SalOp*)belle_sip_dialog_get_application_data(dialog);
|
|
|
|
if (op == NULL && strcmp("NOTIFY",method) == 0) {
|
|
/*special case for Dialog created by notify mathing subscribe*/
|
|
belle_sip_transaction_t * sub_trans = belle_sip_dialog_get_last_transaction(dialog);
|
|
op = (SalOp*)belle_sip_transaction_get_application_data(sub_trans);
|
|
}
|
|
if (op==NULL || op->state==SalOp::State::Terminated){
|
|
ms_warning("Receiving request for null or terminated op [%p], ignored",op);
|
|
return;
|
|
}
|
|
}else{
|
|
/*handle the case where we are receiving a request with to tag but it is not belonging to any dialog*/
|
|
belle_sip_header_to_t *to = belle_sip_message_get_header_by_type(req, belle_sip_header_to_t);
|
|
if ((strcmp("INVITE",method)==0 || strcmp("NOTIFY",method)==0) && (belle_sip_header_to_get_tag(to) != NULL)) {
|
|
ms_warning("Receiving %s with to-tag but no know dialog here. Rejecting.", method);
|
|
resp=belle_sip_response_create_from_request(req,481);
|
|
belle_sip_provider_send_response(sal->prov,resp);
|
|
return;
|
|
/* by default (eg. when a to-tag is present), out of dialog ACK are automatically
|
|
handled in lower layers (belle-sip) but in case it misses, it will be forwarded to us */
|
|
} else if (strcmp("ACK",method)==0 && (belle_sip_header_to_get_tag(to) == NULL)) {
|
|
ms_warning("Receiving ACK without to-tag but no know dialog here. Ignoring");
|
|
return;
|
|
}
|
|
|
|
if (strcmp("INVITE",method)==0) {
|
|
op=new SalCallOp(sal);
|
|
op->dir=SalOp::Dir::Incoming;
|
|
op->fill_cbs();
|
|
}else if ((strcmp("SUBSCRIBE",method)==0 || strcmp("NOTIFY",method)==0) && (evh=belle_sip_message_get_header(BELLE_SIP_MESSAGE(req),"Event"))!=NULL) {
|
|
if (strncmp(belle_sip_header_get_unparsed_value(evh),"presence",strlen("presence"))==0){
|
|
op=new SalPresenceOp(sal);
|
|
} else {
|
|
op=new SalSubscribeOp(sal);
|
|
}
|
|
op->dir=SalOp::Dir::Incoming;
|
|
op->fill_cbs();
|
|
}else if (strcmp("MESSAGE",method)==0) {
|
|
op=new SalMessageOp(sal);
|
|
op->dir=SalOp::Dir::Incoming;
|
|
op->fill_cbs();
|
|
}else if (strcmp("OPTIONS",method)==0) {
|
|
resp=belle_sip_response_create_from_request(req,200);
|
|
belle_sip_provider_send_response(sal->prov,resp);
|
|
return;
|
|
}else if (strcmp("INFO",method)==0) {
|
|
resp=belle_sip_response_create_from_request(req,481);/*INFO out of call dialogs are not allowed*/
|
|
belle_sip_provider_send_response(sal->prov,resp);
|
|
return;
|
|
}else if (strcmp("BYE",method)==0) {
|
|
resp=belle_sip_response_create_from_request(req,481);/*out of dialog BYE */
|
|
belle_sip_provider_send_response(sal->prov,resp);
|
|
return;
|
|
}else if (strcmp("CANCEL",method)==0) {
|
|
resp=belle_sip_response_create_from_request(req,481);/*out of dialog CANCEL */
|
|
belle_sip_provider_send_response(sal->prov,resp);
|
|
return;
|
|
}else if (sal->_enable_test_features && strcmp("PUBLISH",method)==0) {
|
|
resp=belle_sip_response_create_from_request(req,200);/*out of dialog PUBLISH */
|
|
belle_sip_message_add_header((belle_sip_message_t*)resp,belle_sip_header_create("SIP-Etag","4441929FFFZQOA"));
|
|
belle_sip_provider_send_response(sal->prov,resp);
|
|
return;
|
|
}else {
|
|
ms_error("sal process_request_event not implemented yet for method [%s]",belle_sip_request_get_method(req));
|
|
resp=belle_sip_response_create_from_request(req,405);
|
|
belle_sip_message_add_header(BELLE_SIP_MESSAGE(resp)
|
|
,BELLE_SIP_HEADER(belle_sip_header_allow_create("INVITE, CANCEL, ACK, BYE, SUBSCRIBE, NOTIFY, MESSAGE, OPTIONS, INFO")));
|
|
belle_sip_provider_send_response(sal->prov,resp);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!op->from_address) {
|
|
if (belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(from_header)))
|
|
address=belle_sip_header_address_create(belle_sip_header_address_get_displayname(BELLE_SIP_HEADER_ADDRESS(from_header))
|
|
,belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(from_header)));
|
|
else if ((belle_sip_header_address_get_absolute_uri(BELLE_SIP_HEADER_ADDRESS(from_header))))
|
|
address=belle_sip_header_address_create2(belle_sip_header_address_get_displayname(BELLE_SIP_HEADER_ADDRESS(from_header))
|
|
,belle_sip_header_address_get_absolute_uri(BELLE_SIP_HEADER_ADDRESS(from_header)));
|
|
else
|
|
ms_error("Cannot not find from uri from request [%p]",req);
|
|
op->set_from_address((SalAddress*)address);
|
|
belle_sip_object_unref(address);
|
|
}
|
|
|
|
if( remote_contact ){
|
|
op->set_remote_contact(belle_sip_header_get_unparsed_value(BELLE_SIP_HEADER(remote_contact)));
|
|
}
|
|
|
|
if (!op->to_address) {
|
|
to=belle_sip_message_get_header_by_type(BELLE_SIP_MESSAGE(req),belle_sip_header_to_t);
|
|
if (belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(to)))
|
|
address=belle_sip_header_address_create(belle_sip_header_address_get_displayname(BELLE_SIP_HEADER_ADDRESS(to))
|
|
,belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(to)));
|
|
else if ((belle_sip_header_address_get_absolute_uri(BELLE_SIP_HEADER_ADDRESS(to))))
|
|
address=belle_sip_header_address_create2(belle_sip_header_address_get_displayname(BELLE_SIP_HEADER_ADDRESS(to))
|
|
,belle_sip_header_address_get_absolute_uri(BELLE_SIP_HEADER_ADDRESS(to)));
|
|
else
|
|
ms_error("Cannot not find to uri from request [%p]",req);
|
|
|
|
op->set_to_address((SalAddress*)address);
|
|
belle_sip_object_unref(address);
|
|
}
|
|
|
|
if(!op->diversion_address){
|
|
diversion=belle_sip_message_get_header_by_type(BELLE_SIP_MESSAGE(req),belle_sip_header_diversion_t);
|
|
if (diversion) {
|
|
if (belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(diversion)))
|
|
address=belle_sip_header_address_create(belle_sip_header_address_get_displayname(BELLE_SIP_HEADER_ADDRESS(diversion))
|
|
,belle_sip_header_address_get_uri(BELLE_SIP_HEADER_ADDRESS(diversion)));
|
|
else if ((belle_sip_header_address_get_absolute_uri(BELLE_SIP_HEADER_ADDRESS(diversion))))
|
|
address=belle_sip_header_address_create2(belle_sip_header_address_get_displayname(BELLE_SIP_HEADER_ADDRESS(diversion))
|
|
,belle_sip_header_address_get_absolute_uri(BELLE_SIP_HEADER_ADDRESS(diversion)));
|
|
else
|
|
ms_warning("Cannot not find diversion header from request [%p]",req);
|
|
if (address) {
|
|
op->set_diversion_address((SalAddress*)address);
|
|
belle_sip_object_unref(address);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!op->origin) {
|
|
/*set origin uri*/
|
|
origin_address=belle_sip_header_address_create(NULL,belle_sip_request_extract_origin(req));
|
|
op->set_network_origin_address((SalAddress*)origin_address);
|
|
belle_sip_object_unref(origin_address);
|
|
}
|
|
if (!op->remote_ua) {
|
|
op->set_remote_ua(BELLE_SIP_MESSAGE(req));
|
|
}
|
|
|
|
if (!op->call_id) {
|
|
op->call_id=ms_strdup(belle_sip_header_call_id_get_call_id(BELLE_SIP_HEADER_CALL_ID(belle_sip_message_get_header_by_type(BELLE_SIP_MESSAGE(req), belle_sip_header_call_id_t))));
|
|
}
|
|
/*It is worth noting that proxies can (and
|
|
will) remove this header field*/
|
|
op->set_privacy_from_message((belle_sip_message_t*)req);
|
|
|
|
op->assign_recv_headers((belle_sip_message_t*)req);
|
|
if (op->callbacks && op->callbacks->process_request_event) {
|
|
op->callbacks->process_request_event(op,event);
|
|
} else {
|
|
ms_error("sal process_request_event not implemented yet");
|
|
}
|
|
|
|
}
|
|
|
|
void Sal::process_response_event_cb(void *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);
|
|
int response_code = belle_sip_response_get_status_code(response);
|
|
|
|
if (!client_transaction) {
|
|
ms_warning("Discarding stateless response [%i]",response_code);
|
|
return;
|
|
} else {
|
|
SalOp* op = (SalOp*)belle_sip_transaction_get_application_data(BELLE_SIP_TRANSACTION(client_transaction));
|
|
belle_sip_request_t* request=belle_sip_transaction_get_request(BELLE_SIP_TRANSACTION(client_transaction));
|
|
belle_sip_header_contact_t* remote_contact = belle_sip_message_get_header_by_type(response, belle_sip_header_contact_t);
|
|
|
|
if (op->state == SalOp::State::Terminated) {
|
|
belle_sip_message("Op [%p] is terminated, nothing to do with this [%i]", op, response_code);
|
|
return;
|
|
}
|
|
/*do it all the time, since we can receive provisional responses from a different instance than the final one*/
|
|
op->set_remote_ua(BELLE_SIP_MESSAGE(response));
|
|
|
|
if(remote_contact) {
|
|
op->set_remote_contact(belle_sip_header_get_unparsed_value(BELLE_SIP_HEADER(remote_contact)));
|
|
}
|
|
|
|
if (!op->call_id) {
|
|
op->call_id=ms_strdup(belle_sip_header_call_id_get_call_id(BELLE_SIP_HEADER_CALL_ID(belle_sip_message_get_header_by_type(BELLE_SIP_MESSAGE(response), belle_sip_header_call_id_t))));
|
|
}
|
|
|
|
op->assign_recv_headers((belle_sip_message_t*)response);
|
|
|
|
if (op->callbacks && op->callbacks->process_response_event) {
|
|
/*handle authorization*/
|
|
switch (response_code) {
|
|
case 200:
|
|
break;
|
|
case 401:
|
|
case 407:
|
|
if (op->state == SalOp::State::Terminating && strcmp("BYE",belle_sip_request_get_method(request))!=0) {
|
|
/*only bye are completed*/
|
|
belle_sip_message("Op is in state terminating, nothing else to do ");
|
|
} else {
|
|
if (op->pending_auth_transaction){
|
|
belle_sip_object_unref(op->pending_auth_transaction);
|
|
op->pending_auth_transaction=NULL;
|
|
}
|
|
if (++op->auth_requests > 2) {
|
|
ms_warning("Auth info cannot be found for op [%s/%s] after 2 attempts, giving up",op->get_from()
|
|
,op->get_to());
|
|
op->root->callbacks.auth_failure(op,op->auth_info);
|
|
op->root->remove_pending_auth(op);
|
|
} else {
|
|
op->pending_auth_transaction=(belle_sip_client_transaction_t*)belle_sip_object_ref(client_transaction);
|
|
op->process_authentication();
|
|
return;
|
|
}
|
|
}
|
|
break;
|
|
case 403:
|
|
if (op->auth_info) op->root->callbacks.auth_failure(op,op->auth_info);
|
|
break;
|
|
}
|
|
if (response_code >= 180 && response_code !=401 && response_code !=407 && response_code !=403) {
|
|
/*not an auth request*/
|
|
op->auth_requests=0;
|
|
}
|
|
op->callbacks->process_response_event(op,event);
|
|
} else {
|
|
ms_error("Unhandled event response [%p]",event);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Sal::process_timeout_cb(void *user_ctx, const belle_sip_timeout_event_t *event) {
|
|
belle_sip_client_transaction_t* client_transaction = belle_sip_timeout_event_get_client_transaction(event);
|
|
SalOp* op = (SalOp*)belle_sip_transaction_get_application_data(BELLE_SIP_TRANSACTION(client_transaction));
|
|
if (op && op->callbacks && op->callbacks->process_timeout) {
|
|
op->callbacks->process_timeout(op,event);
|
|
} else {
|
|
ms_error("Unhandled event timeout [%p]",event);
|
|
}
|
|
}
|
|
|
|
void Sal::process_transaction_terminated_cb(void *user_ctx, const belle_sip_transaction_terminated_event_t *event) {
|
|
belle_sip_client_transaction_t* client_transaction = belle_sip_transaction_terminated_event_get_client_transaction(event);
|
|
belle_sip_server_transaction_t* server_transaction = belle_sip_transaction_terminated_event_get_server_transaction(event);
|
|
belle_sip_transaction_t* trans;
|
|
SalOp* op;
|
|
|
|
if(client_transaction)
|
|
trans=BELLE_SIP_TRANSACTION(client_transaction);
|
|
else
|
|
trans=BELLE_SIP_TRANSACTION(server_transaction);
|
|
|
|
op = (SalOp*)belle_sip_transaction_get_application_data(trans);
|
|
if (op && op->callbacks && op->callbacks->process_transaction_terminated) {
|
|
op->callbacks->process_transaction_terminated(op,event);
|
|
} else {
|
|
ms_message("Unhandled transaction terminated [%p]",trans);
|
|
}
|
|
if (op) {
|
|
op->unref(); /*because every transaction ref op*/
|
|
belle_sip_transaction_set_application_data(trans,NULL); /*no longuer reference something we do not ref to avoid futur access of a released op*/
|
|
}
|
|
}
|
|
|
|
void Sal::process_auth_requested_cb(void *sal, belle_sip_auth_event_t *event) {
|
|
SalAuthInfo* auth_info = sal_auth_info_create(event);
|
|
((Sal*)sal)->callbacks.auth_requested(reinterpret_cast<Sal *>(sal),auth_info);
|
|
belle_sip_auth_event_set_passwd(event,(const char*)auth_info->password);
|
|
belle_sip_auth_event_set_ha1(event,(const char*)auth_info->ha1);
|
|
belle_sip_auth_event_set_userid(event,(const char*)auth_info->userid);
|
|
belle_sip_auth_event_set_signing_key(event,(belle_sip_signing_key_t *)auth_info->key);
|
|
belle_sip_auth_event_set_client_certificates_chain(event,(belle_sip_certificates_chain_t* )auth_info->certificates);
|
|
sal_auth_info_delete(auth_info);
|
|
}
|
|
|
|
Sal::Sal(MSFactory *factory){
|
|
belle_sip_listener_callbacks_t listener_callbacks = {0};
|
|
|
|
/*belle_sip_object_enable_marshal_check(TRUE);*/
|
|
this->factory = factory;
|
|
/*first create the stack, which initializes the belle-sip object's pool for this thread*/
|
|
this->stack = belle_sip_stack_new(NULL);
|
|
|
|
this->user_agent=belle_sip_header_user_agent_new();
|
|
#if defined(PACKAGE_NAME) && defined(LIBLINPHONE_VERSION)
|
|
belle_sip_header_user_agent_add_product(this->user_agent, PACKAGE_NAME "/" LIBLINPHONE_VERSION);
|
|
#else
|
|
belle_sip_header_user_agent_add_product(this->user_agent, "Unknown");
|
|
#endif
|
|
append_stack_string_to_user_agent();
|
|
belle_sip_object_ref(this->user_agent);
|
|
|
|
this->prov = belle_sip_stack_create_provider(this->stack,NULL);
|
|
enable_nat_helper(TRUE);
|
|
|
|
listener_callbacks.process_dialog_terminated=process_dialog_terminated_cb;
|
|
listener_callbacks.process_io_error=process_io_error_cb;
|
|
listener_callbacks.process_request_event=process_request_event_cb;
|
|
listener_callbacks.process_response_event=process_response_event_cb;
|
|
listener_callbacks.process_timeout=process_timeout_cb;
|
|
listener_callbacks.process_transaction_terminated=process_transaction_terminated_cb;
|
|
listener_callbacks.process_auth_requested=process_auth_requested_cb;
|
|
this->listener=belle_sip_listener_create_from_callbacks(&listener_callbacks, this);
|
|
belle_sip_provider_add_sip_listener(this->prov, this->listener);
|
|
}
|
|
|
|
Sal::~Sal() {
|
|
belle_sip_object_unref(this->user_agent);
|
|
belle_sip_object_unref(this->prov);
|
|
belle_sip_object_unref(this->stack);
|
|
belle_sip_object_unref(this->listener);
|
|
if (this->supported) belle_sip_object_unref(this->supported);
|
|
bctbx_list_free_with_data(this->supported_tags,ms_free);
|
|
bctbx_list_free_with_data(this->supported_content_types, ms_free);
|
|
if (this->uuid) ms_free(this->uuid);
|
|
if (this->root_ca) ms_free(this->root_ca);
|
|
if (this->root_ca_data) ms_free(this->root_ca_data);
|
|
}
|
|
|
|
void Sal::set_callbacks(const Callbacks *cbs) {
|
|
memcpy(&this->callbacks,cbs,sizeof(*cbs));
|
|
if (this->callbacks.call_received==NULL)
|
|
this->callbacks.call_received=(OnCallReceivedCb)unimplemented_stub;
|
|
if (this->callbacks.call_ringing==NULL)
|
|
this->callbacks.call_ringing=(OnCallRingingCb)unimplemented_stub;
|
|
if (this->callbacks.call_accepted==NULL)
|
|
this->callbacks.call_accepted=(OnCallAcceptedCb)unimplemented_stub;
|
|
if (this->callbacks.call_failure==NULL)
|
|
this->callbacks.call_failure=(OnCallFailureCb)unimplemented_stub;
|
|
if (this->callbacks.call_terminated==NULL)
|
|
this->callbacks.call_terminated=(OnCallTerminatedCb)unimplemented_stub;
|
|
if (this->callbacks.call_released==NULL)
|
|
this->callbacks.call_released=(OnCallReleasedCb)unimplemented_stub;
|
|
if (this->callbacks.call_updating==NULL)
|
|
this->callbacks.call_updating=(OnCallUpdatingCb)unimplemented_stub;
|
|
if (this->callbacks.auth_failure==NULL)
|
|
this->callbacks.auth_failure=(OnAuthFailureCb)unimplemented_stub;
|
|
if (this->callbacks.register_success==NULL)
|
|
this->callbacks.register_success=(OnRegisterSuccessCb)unimplemented_stub;
|
|
if (this->callbacks.register_failure==NULL)
|
|
this->callbacks.register_failure=(OnRegisterFailureCb)unimplemented_stub;
|
|
if (this->callbacks.dtmf_received==NULL)
|
|
this->callbacks.dtmf_received=(OnDtmfReceivedCb)unimplemented_stub;
|
|
if (this->callbacks.notify==NULL)
|
|
this->callbacks.notify=(OnNotifyCb)unimplemented_stub;
|
|
if (this->callbacks.subscribe_received==NULL)
|
|
this->callbacks.subscribe_received=(OnSubscribeReceivedCb)unimplemented_stub;
|
|
if (this->callbacks.incoming_subscribe_closed==NULL)
|
|
this->callbacks.incoming_subscribe_closed=(OnIncomingSubscribeClosedCb)unimplemented_stub;
|
|
if (this->callbacks.parse_presence_requested==NULL)
|
|
this->callbacks.parse_presence_requested=(OnParsePresenceRequestedCb)unimplemented_stub;
|
|
if (this->callbacks.convert_presence_to_xml_requested==NULL)
|
|
this->callbacks.convert_presence_to_xml_requested=(OnConvertPresenceToXMLRequestedCb)unimplemented_stub;
|
|
if (this->callbacks.notify_presence==NULL)
|
|
this->callbacks.notify_presence=(OnNotifyPresenceCb)unimplemented_stub;
|
|
if (this->callbacks.subscribe_presence_received==NULL)
|
|
this->callbacks.subscribe_presence_received=(OnSubscribePresenceReceivedCb)unimplemented_stub;
|
|
if (this->callbacks.message_received==NULL)
|
|
this->callbacks.message_received=(OnMessageReceivedCb)unimplemented_stub;
|
|
if (this->callbacks.ping_reply==NULL)
|
|
this->callbacks.ping_reply=(OnPingReplyCb)unimplemented_stub;
|
|
if (this->callbacks.auth_requested==NULL)
|
|
this->callbacks.auth_requested=(OnAuthRequestedCb)unimplemented_stub;
|
|
if (this->callbacks.info_received==NULL)
|
|
this->callbacks.info_received=(OnInfoReceivedCb)unimplemented_stub;
|
|
if (this->callbacks.on_publish_response==NULL)
|
|
this->callbacks.on_publish_response=(OnPublishResponseCb)unimplemented_stub;
|
|
if (this->callbacks.on_expire==NULL)
|
|
this->callbacks.on_expire=(OnExpireCb)unimplemented_stub;
|
|
}
|
|
|
|
void Sal::set_tls_properties(){
|
|
belle_sip_listening_point_t *lp=belle_sip_provider_get_listening_point(this->prov,"TLS");
|
|
if (lp){
|
|
belle_sip_tls_listening_point_t *tlp=BELLE_SIP_TLS_LISTENING_POINT(lp);
|
|
belle_tls_crypto_config_t *crypto_config = belle_tls_crypto_config_new();
|
|
int verify_exceptions = BELLE_TLS_VERIFY_NONE;
|
|
if (!this->tls_verify) verify_exceptions = BELLE_TLS_VERIFY_ANY_REASON;
|
|
else if (!this->tls_verify_cn) verify_exceptions = BELLE_TLS_VERIFY_CN_MISMATCH;
|
|
belle_tls_crypto_config_set_verify_exceptions(crypto_config, verify_exceptions);
|
|
if (this->root_ca != NULL) belle_tls_crypto_config_set_root_ca(crypto_config, this->root_ca);
|
|
if (this->root_ca_data != NULL) belle_tls_crypto_config_set_root_ca_data(crypto_config, this->root_ca_data);
|
|
if (this->ssl_config != NULL) belle_tls_crypto_config_set_ssl_config(crypto_config, this->ssl_config);
|
|
belle_sip_tls_listening_point_set_crypto_config(tlp, crypto_config);
|
|
belle_sip_object_unref(crypto_config);
|
|
}
|
|
}
|
|
|
|
int Sal::add_listen_port(SalAddress* addr, bool_t is_tunneled) {
|
|
int result;
|
|
belle_sip_listening_point_t* lp;
|
|
if (is_tunneled){
|
|
#ifdef TUNNEL_ENABLED
|
|
if (sal_address_get_transport(addr)!=SalTransportUDP){
|
|
ms_error("Tunneled mode is only available for UDP kind of transports.");
|
|
return -1;
|
|
}
|
|
lp = belle_sip_tunnel_listening_point_new(this->stack, this->tunnel_client);
|
|
if (!lp){
|
|
ms_error("Could not create tunnel listening point.");
|
|
return -1;
|
|
}
|
|
#else
|
|
ms_error("No tunnel support in library.");
|
|
return -1;
|
|
#endif
|
|
}else{
|
|
lp = belle_sip_stack_create_listening_point(this->stack,
|
|
sal_address_get_domain(addr),
|
|
sal_address_get_port(addr),
|
|
sal_transport_to_string(sal_address_get_transport(addr)));
|
|
}
|
|
if (lp) {
|
|
belle_sip_listening_point_set_keep_alive(lp,this->keep_alive);
|
|
result = belle_sip_provider_add_listening_point(this->prov,lp);
|
|
if (sal_address_get_transport(addr)==SalTransportTLS) {
|
|
set_tls_properties();
|
|
}
|
|
} else {
|
|
return -1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
int Sal::set_listen_port(const char *addr, int port, SalTransport tr, bool_t is_tunneled) {
|
|
SalAddress* sal_addr = sal_address_new(NULL);
|
|
int result;
|
|
sal_address_set_domain(sal_addr,addr);
|
|
sal_address_set_port(sal_addr,port);
|
|
sal_address_set_transport(sal_addr,tr);
|
|
result = add_listen_port(sal_addr, is_tunneled);
|
|
sal_address_destroy(sal_addr);
|
|
return result;
|
|
}
|
|
|
|
int Sal::get_listening_port(SalTransport tr){
|
|
const char *tpn=sal_transport_to_string(tr);
|
|
belle_sip_listening_point_t *lp=belle_sip_provider_get_listening_point(this->prov, tpn);
|
|
if (lp){
|
|
return belle_sip_listening_point_get_port(lp);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int Sal::unlisten_ports(){
|
|
const belle_sip_list_t * lps = belle_sip_provider_get_listening_points(this->prov);
|
|
belle_sip_list_t * tmp_list = belle_sip_list_copy(lps);
|
|
belle_sip_list_for_each2 (tmp_list,(void (*)(void*,void*))remove_listening_point,this->prov);
|
|
belle_sip_list_free(tmp_list);
|
|
ms_message("sal_unlisten_ports done");
|
|
return 0;
|
|
}
|
|
|
|
int Sal::transport_available(SalTransport t) {
|
|
switch(t){
|
|
case SalTransportUDP:
|
|
case SalTransportTCP:
|
|
return TRUE;
|
|
case SalTransportTLS:
|
|
return belle_sip_stack_tls_available(this->stack);
|
|
case SalTransportDTLS:
|
|
return FALSE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void Sal::make_supported_header(){
|
|
bctbx_list_t *it;
|
|
char *alltags=NULL;
|
|
size_t buflen=64;
|
|
size_t written=0;
|
|
|
|
if (this->supported){
|
|
belle_sip_object_unref(this->supported);
|
|
this->supported=NULL;
|
|
}
|
|
for(it=this->supported_tags;it!=NULL;it=it->next){
|
|
const char *tag=(const char*)it->data;
|
|
size_t taglen=strlen(tag);
|
|
if (alltags==NULL || (written+taglen+1>=buflen)) alltags=reinterpret_cast<char *>(ms_realloc(alltags,(buflen=buflen*2)));
|
|
written+=snprintf(alltags+written,buflen-written,it->next ? "%s, " : "%s",tag);
|
|
}
|
|
if (alltags){
|
|
this->supported=belle_sip_header_create("Supported",alltags);
|
|
if (this->supported){
|
|
belle_sip_object_ref(this->supported);
|
|
}
|
|
ms_free(alltags);
|
|
}
|
|
}
|
|
|
|
void Sal::set_supported_tags(const char* tags){
|
|
this->supported_tags=bctbx_list_free_with_data(this->supported_tags,ms_free);
|
|
if (tags){
|
|
char *iter;
|
|
char *buffer=ms_strdup(tags);
|
|
char *tag;
|
|
char *context=NULL;
|
|
iter=buffer;
|
|
while((tag=strtok_r(iter,", ",&context))!=NULL){
|
|
iter=NULL;
|
|
this->supported_tags=bctbx_list_append(this->supported_tags,ms_strdup(tag));
|
|
}
|
|
ms_free(buffer);
|
|
}
|
|
make_supported_header();
|
|
}
|
|
|
|
void Sal::add_supported_tag(const char* tag){
|
|
bctbx_list_t *elem=bctbx_list_find_custom(this->supported_tags,(bctbx_compare_func)strcasecmp,tag);
|
|
if (!elem){
|
|
this->supported_tags=bctbx_list_append(this->supported_tags,ms_strdup(tag));
|
|
make_supported_header();
|
|
}
|
|
}
|
|
|
|
void Sal::remove_supported_tag(const char* tag){
|
|
bctbx_list_t *elem=bctbx_list_find_custom(this->supported_tags,(bctbx_compare_func)strcasecmp,tag);
|
|
if (elem){
|
|
ms_free(elem->data);
|
|
this->supported_tags=bctbx_list_erase_link(this->supported_tags,elem);
|
|
make_supported_header();
|
|
}
|
|
}
|
|
|
|
int Sal::reset_transports() {
|
|
ms_message("Reseting transports");
|
|
belle_sip_provider_clean_channels(this->prov);
|
|
return 0;
|
|
}
|
|
|
|
ortp_socket_t Sal::get_socket() const {
|
|
ms_warning("sal_get_socket is deprecated");
|
|
return -1;
|
|
}
|
|
|
|
void Sal::set_user_agent(const char *user_agent) {
|
|
belle_sip_header_user_agent_set_products(this->user_agent,NULL);
|
|
belle_sip_header_user_agent_add_product(this->user_agent,user_agent);
|
|
}
|
|
|
|
const char* Sal::get_user_agent() const {
|
|
static char user_agent[255];
|
|
belle_sip_header_user_agent_get_products_as_string(this->user_agent, user_agent, 254);
|
|
return user_agent;
|
|
}
|
|
|
|
void Sal::append_stack_string_to_user_agent() {
|
|
char stack_string[64];
|
|
snprintf(stack_string, sizeof(stack_string) - 1, "(belle-sip/%s)", belle_sip_version_to_string());
|
|
belle_sip_header_user_agent_add_product(this->user_agent, stack_string);
|
|
}
|
|
|
|
void Sal::set_keepalive_period(unsigned int value) {
|
|
const belle_sip_list_t* iterator;
|
|
belle_sip_listening_point_t* lp;
|
|
this->keep_alive=value;
|
|
for (iterator=belle_sip_provider_get_listening_points(this->prov);iterator!=NULL;iterator=iterator->next) {
|
|
lp=(belle_sip_listening_point_t*)iterator->data;
|
|
if (this->use_tcp_tls_keep_alive || strcasecmp(belle_sip_listening_point_get_transport(lp),"udp")==0) {
|
|
belle_sip_listening_point_set_keep_alive(lp,this->keep_alive);
|
|
}
|
|
}
|
|
}
|
|
|
|
int Sal::set_tunnel(void *tunnelclient) {
|
|
#ifdef TUNNEL_ENABLED
|
|
this->tunnel_client=tunnelclient;
|
|
return 0;
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
bool_t Sal::is_content_type_supported(const char *content_type) const {
|
|
bctbx_list_t *item;
|
|
for (item = this->supported_content_types; item != NULL; item = bctbx_list_next(item)) {
|
|
const char *item_content_type = (const char *)bctbx_list_get_data(item);
|
|
if (strcmp(item_content_type, content_type) == 0) return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void Sal::add_content_type_support(const char *content_type) {
|
|
if ((content_type != NULL) && (is_content_type_supported(content_type) == FALSE)) {
|
|
this->supported_content_types = bctbx_list_append(this->supported_content_types, ms_strdup(content_type));
|
|
}
|
|
}
|
|
|
|
void Sal::use_rport(bool_t use_rports) {
|
|
belle_sip_provider_enable_rport(this->prov,use_rports);
|
|
ms_message("Sal use rport [%s]", use_rports ? "enabled" : "disabled");
|
|
}
|
|
|
|
void Sal::set_root_ca(const char* rootCa) {
|
|
if (this->root_ca) {
|
|
ms_free(this->root_ca);
|
|
this->root_ca = NULL;
|
|
}
|
|
if (rootCa)
|
|
this->root_ca = ms_strdup(rootCa);
|
|
set_tls_properties();
|
|
}
|
|
|
|
void Sal::set_root_ca_data(const char* data) {
|
|
if (this->root_ca_data) {
|
|
ms_free(this->root_ca_data);
|
|
this->root_ca_data = NULL;
|
|
}
|
|
if (data)
|
|
this->root_ca_data = ms_strdup(data);
|
|
set_tls_properties();
|
|
}
|
|
|
|
void Sal::verify_server_certificates(bool_t verify) {
|
|
this->tls_verify=verify;
|
|
set_tls_properties();
|
|
}
|
|
|
|
void Sal::verify_server_cn(bool_t verify) {
|
|
this->tls_verify_cn = verify;
|
|
set_tls_properties();
|
|
}
|
|
|
|
void Sal::set_ssl_config(void *ssl_config) {
|
|
this->ssl_config = ssl_config;
|
|
set_tls_properties();
|
|
}
|
|
|
|
void Sal::set_uuid(const char *uuid){
|
|
if (this->uuid){
|
|
ms_free(this->uuid);
|
|
this->uuid=NULL;
|
|
}
|
|
if (uuid)
|
|
this->uuid=ms_strdup(uuid);
|
|
}
|
|
|
|
int Sal::create_uuid(char *uuid, size_t len) {
|
|
if (generate_uuid(uuid, len) == 0) {
|
|
set_uuid(uuid);
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int Sal::generate_uuid(char *uuid, size_t len) {
|
|
sal_uuid_t uuid_struct;
|
|
int i;
|
|
int written;
|
|
|
|
if (len==0) return -1;
|
|
/*create an UUID as described in RFC4122, 4.4 */
|
|
belle_sip_random_bytes((unsigned char*)&uuid_struct, sizeof(sal_uuid_t));
|
|
uuid_struct.clock_seq_hi_and_reserved&=(unsigned char)~(1<<6);
|
|
uuid_struct.clock_seq_hi_and_reserved|=(unsigned char)1<<7;
|
|
uuid_struct.time_hi_and_version&=(unsigned char)~(0xf<<12);
|
|
uuid_struct.time_hi_and_version|=(unsigned char)4<<12;
|
|
|
|
written=snprintf(uuid,len,"%8.8x-%4.4x-%4.4x-%2.2x%2.2x-", uuid_struct.time_low, uuid_struct.time_mid,
|
|
uuid_struct.time_hi_and_version, uuid_struct.clock_seq_hi_and_reserved,
|
|
uuid_struct.clock_seq_low);
|
|
if ((written < 0) || ((size_t)written > (len +13))) {
|
|
ms_error("sal_create_uuid(): buffer is too short !");
|
|
return -1;
|
|
}
|
|
for (i = 0; i < 6; i++)
|
|
written+=snprintf(uuid+written,len-written,"%2.2x", uuid_struct.node[i]);
|
|
uuid[len-1]='\0';
|
|
return 0;
|
|
}
|
|
|
|
void Sal::add_pending_auth(SalOp *op){
|
|
if (bctbx_list_find(this->pending_auths,op)==NULL){
|
|
this->pending_auths=bctbx_list_append(this->pending_auths,op);
|
|
op->has_auth_pending=TRUE;
|
|
}
|
|
}
|
|
|
|
void Sal::remove_pending_auth(SalOp *op){
|
|
if (op->has_auth_pending){
|
|
op->has_auth_pending=FALSE;
|
|
if (bctbx_list_find(this->pending_auths,op)){
|
|
this->pending_auths=bctbx_list_remove(this->pending_auths,op);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Sal::set_default_sdp_handling(SalOpSDPHandling sdp_handling_method) {
|
|
if (sdp_handling_method != SalOpSDPNormal ) ms_message("Enabling special SDP handling for all new SalOp in Sal[%p]!", this);
|
|
this->default_sdp_handling = sdp_handling_method;
|
|
}
|
|
|
|
void Sal::enable_nat_helper(bool_t enable) {
|
|
this->_nat_helper_enabled=enable;
|
|
belle_sip_provider_enable_nat_helper(this->prov,enable);
|
|
ms_message("Sal nat helper [%s]",enable?"enabled":"disabled");
|
|
}
|
|
|
|
void Sal::get_default_local_ip(int address_family, char *ip, size_t iplen) {
|
|
strncpy(ip,address_family==AF_INET6 ? "::1" : "127.0.0.1",iplen);
|
|
ms_error("sal_get_default_local_ip() is deprecated.");
|
|
}
|
|
|
|
void Sal::set_dns_servers(const bctbx_list_t *servers){
|
|
belle_sip_list_t *l = NULL;
|
|
|
|
/*we have to convert the bctbx_list_t into a belle_sip_list_t first*/
|
|
for (; servers != NULL; servers = servers->next){
|
|
l = belle_sip_list_append(l, servers->data);
|
|
}
|
|
belle_sip_stack_set_dns_servers(this->stack, l);
|
|
belle_sip_list_free(l);
|
|
}
|
|
|
|
belle_sip_source_t *Sal::create_timer(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(this->stack);
|
|
return belle_sip_main_loop_create_timeout(ml, func, data, timeout_value_ms, timer_name);
|
|
}
|
|
|
|
void Sal::cancel_timer(belle_sip_source_t *timer) {
|
|
belle_sip_main_loop_t *ml = belle_sip_stack_get_main_loop(this->stack);
|
|
belle_sip_main_loop_remove_source(ml, timer);
|
|
}
|
|
|
|
belle_sip_response_t* Sal::create_response_from_request (belle_sip_request_t* req, int code ) {
|
|
belle_sip_response_t *resp=belle_sip_response_create_from_request(req,code);
|
|
belle_sip_message_add_header(BELLE_SIP_MESSAGE(resp),BELLE_SIP_HEADER(this->user_agent));
|
|
belle_sip_message_add_header(BELLE_SIP_MESSAGE(resp), this->supported);
|
|
return resp;
|
|
}
|
|
|
|
|
|
|
|
|
|
/***********************************/
|
|
/* Global functions implementation */
|
|
/***********************************/
|
|
|
|
int to_sip_code(SalReason r) {
|
|
int ret=500;
|
|
switch(r){
|
|
case SalReasonNone:
|
|
ret=200;
|
|
break;
|
|
case SalReasonIOError:
|
|
ret=503;
|
|
break;
|
|
case SalReasonUnknown:
|
|
ret=400;
|
|
break;
|
|
case SalReasonBusy:
|
|
ret=486;
|
|
break;
|
|
case SalReasonDeclined:
|
|
ret=603;
|
|
break;
|
|
case SalReasonDoNotDisturb:
|
|
ret=600;
|
|
break;
|
|
case SalReasonForbidden:
|
|
ret=403;
|
|
break;
|
|
case SalReasonUnsupportedContent:
|
|
ret=415;
|
|
break;
|
|
case SalReasonNotFound:
|
|
ret=404;
|
|
break;
|
|
case SalReasonRedirect:
|
|
ret=302;
|
|
break;
|
|
case SalReasonTemporarilyUnavailable:
|
|
ret=480;
|
|
break;
|
|
case SalReasonServiceUnavailable:
|
|
ret=503;
|
|
break;
|
|
case SalReasonRequestPending:
|
|
ret=491;
|
|
break;
|
|
case SalReasonUnauthorized:
|
|
ret=401;
|
|
break;
|
|
case SalReasonNotAcceptable:
|
|
ret=488; /*or maybe 606 Not Acceptable ?*/
|
|
break;
|
|
case SalReasonNoMatch:
|
|
ret=481;
|
|
break;
|
|
case SalReasonRequestTimeout:
|
|
ret=408;
|
|
break;
|
|
case SalReasonMovedPermanently:
|
|
ret=301;
|
|
break;
|
|
case SalReasonGone:
|
|
ret=410;
|
|
break;
|
|
case SalReasonAddressIncomplete:
|
|
ret=484;
|
|
break;
|
|
case SalReasonNotImplemented:
|
|
ret=501;
|
|
break;
|
|
case SalReasonServerTimeout:
|
|
ret=504;
|
|
break;
|
|
case SalReasonBadGateway:
|
|
ret=502;
|
|
break;
|
|
case SalReasonInternalError:
|
|
ret=500;
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
LINPHONE_END_NAMESPACE
|
|
|
|
/*******************************/
|
|
/* C++ to C wrapping functions */
|
|
/*******************************/
|
|
|
|
using namespace LINPHONE_NAMESPACE;
|
|
|
|
extern "C" {
|
|
|
|
Sal *linphone_core_get_sal(const LinphoneCore *lc) {
|
|
return lc->sal;
|
|
}
|
|
|
|
SalOp *linphone_proxy_config_get_sal_op(const LinphoneProxyConfig *cfg) {
|
|
return cfg->op;
|
|
}
|
|
|
|
SalOp *linphone_call_get_op_as_sal_op(const LinphoneCall *call) {
|
|
return linphone_call_get_op(call);
|
|
}
|
|
|
|
Sal *sal_init(MSFactory *factory) {
|
|
return new Sal(factory);
|
|
}
|
|
|
|
void sal_uninit(Sal* sal) {
|
|
delete sal;
|
|
}
|
|
|
|
int sal_create_uuid(Sal *ctx, char *uuid, size_t len) {
|
|
return ctx->create_uuid(uuid, len);
|
|
}
|
|
|
|
void sal_set_uuid(Sal *ctx, const char *uuid) {
|
|
ctx->set_uuid(uuid);
|
|
}
|
|
|
|
void sal_default_set_sdp_handling(Sal* h, SalOpSDPHandling handling_method) {
|
|
h->set_default_sdp_handling(handling_method);
|
|
}
|
|
|
|
void sal_set_send_error(Sal *sal,int value) {
|
|
sal->set_send_error(value);
|
|
}
|
|
|
|
void sal_set_recv_error(Sal *sal,int value) {
|
|
sal->set_recv_error(value);
|
|
}
|
|
|
|
int sal_enable_pending_trans_checking(Sal *sal, bool_t value) {
|
|
return sal->enable_pending_trans_checking(value);
|
|
}
|
|
|
|
void sal_enable_unconditional_answer(Sal *sal,int value) {
|
|
sal->enable_unconditional_answer(value);
|
|
}
|
|
|
|
void sal_set_dns_timeout(Sal* sal,int timeout) {
|
|
sal->set_dns_timeout(timeout);
|
|
}
|
|
|
|
void sal_set_dns_user_hosts_file(Sal *sal, const char *hosts_file) {
|
|
sal->set_dns_user_hosts_file(hosts_file);
|
|
}
|
|
|
|
void *sal_get_stack_impl(Sal *sal) {
|
|
return sal->get_stack_impl();
|
|
}
|
|
|
|
void sal_set_refresher_retry_after(Sal *sal,int value) {
|
|
sal->set_refresher_retry_after(value);
|
|
}
|
|
|
|
int sal_get_refresher_retry_after(const Sal *sal) {
|
|
return sal->get_refresher_retry_after();
|
|
}
|
|
|
|
void sal_set_transport_timeout(Sal* sal,int timeout) {
|
|
sal->set_transport_timeout(timeout);
|
|
}
|
|
|
|
void sal_enable_test_features(Sal*ctx, bool_t enabled) {
|
|
ctx->enable_test_features(enabled);
|
|
}
|
|
|
|
int sal_transport_available(Sal *ctx, SalTransport t) {
|
|
return ctx->transport_available(t);
|
|
}
|
|
|
|
const SalErrorInfo *sal_op_get_error_info(const SalOp *op) {
|
|
return op->get_error_info();
|
|
}
|
|
|
|
bool_t sal_call_dialog_request_pending(const SalOp *op) {
|
|
auto callOp = dynamic_cast<const SalCallOp *>(op);
|
|
return callOp->dialog_request_pending();
|
|
}
|
|
|
|
void sal_call_set_sdp_handling(SalOp *h, SalOpSDPHandling handling) {
|
|
auto callOp = dynamic_cast<SalCallOp *>(h);
|
|
callOp->set_sdp_handling(handling);
|
|
}
|
|
|
|
SalMediaDescription * sal_call_get_final_media_description(SalOp *h) {
|
|
auto callOp = dynamic_cast<SalCallOp *>(h);
|
|
return callOp->get_final_media_description();
|
|
}
|
|
|
|
}
|