/*
 * sal.cpp
 * Copyright (C) 2010-2018 Belledonne Communications SARL
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include <algorithm>

#include "sal/sal.h"
#include "sal/call-op.h"
#include "sal/presence-op.h"
#include "sal/refer-op.h"
#include "sal/event-op.h"
#include "sal/message-op.h"
#include "bellesip_sal/sal_impl.h"
#include "tester_utils.h"
#include "private.h"

#include "c-wrapper/internal/c-tools.h"

using namespace std;

LINPHONE_BEGIN_NAMESPACE

void Sal::processDialogTerminatedCb(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->mCallbacks && op->mCallbacks->process_dialog_terminated) {
		op->mCallbacks->process_dialog_terminated(op,event);
	} else {
		ms_error("sal process_dialog_terminated no op found for this dialog [%p], ignoring",dialog);
	}
}

void Sal::processIoErrorCb(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->mAuthRequests=0;
		if (op->mCallbacks && op->mCallbacks->process_io_error) {
			op->mCallbacks->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::processRequestEventCb (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);
	belle_sip_header_t *subjectHeader = belle_sip_message_get_header(BELLE_SIP_MESSAGE(req), "Subject");

	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->mState == 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->mProvider,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->fillCallbacks();
		}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->fillCallbacks();
		}else if (strcmp("MESSAGE",method)==0) {
			op=new SalMessageOp(sal);
			op->fillCallbacks();
		}else if (strcmp("REFER",method)==0) {
			op=new SalReferOp(sal);
		}else if (strcmp("OPTIONS",method)==0) {
			resp=belle_sip_response_create_from_request(req,200);
			belle_sip_provider_send_response(sal->mProvider,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->mProvider,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->mProvider,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->mProvider,resp);
			return;
		}else if (sal->mEnableTestFeatures && 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->mProvider,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->mProvider,resp);
			return;
		}
		op->mDir=SalOp::Dir::Incoming;
	}

	if (!op->mFromAddress)  {
		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->setFromAddress((SalAddress*)address);
		belle_sip_object_unref(address);
	}

	if( remote_contact ){
		op->setRemoteContact(belle_sip_header_get_unparsed_value(BELLE_SIP_HEADER(remote_contact)));
	}

	if (!op->mToAddress) {
		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->setToAddress((SalAddress*)address);
		belle_sip_object_unref(address);
	}

	if (subjectHeader) {
		const char *subject = belle_sip_header_get_unparsed_value(subjectHeader);
		op->setSubject(subject);
	}

	if(!op->mDiversionAddress){
		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->setDiversionAddress((SalAddress*)address);
				belle_sip_object_unref(address);
			}
		}
	}

	if (op->mOrigin.empty()) {
		/*set origin uri*/
		origin_address=belle_sip_header_address_create(NULL,belle_sip_request_extract_origin(req));
		op->setNetworkOriginAddress((SalAddress*)origin_address);
		belle_sip_object_unref(origin_address);
	}
	if (op->mRemoteUserAgent.empty())
		op->setRemoteUserAgent(BELLE_SIP_MESSAGE(req));

	if (op->mCallId.empty()) {
		op->mCallId = 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->setPrivacyFromMessage((belle_sip_message_t*)req);

	if (strcmp("ACK",method) != 0){
		/*The ACK custom header is processed specifically later on*/
		op->assignRecvHeaders((belle_sip_message_t*)req);
	}

	if (op->mCallbacks && op->mCallbacks->process_request_event) {
		op->mCallbacks->process_request_event(op,event);
	} else {
		ms_error("sal process_request_event not implemented yet");
	}

}

void Sal::processResponseEventCb(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->mState == 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->setRemoteUserAgent(BELLE_SIP_MESSAGE(response));

		if(remote_contact) {
			op->setRemoteContact(belle_sip_header_get_unparsed_value(BELLE_SIP_HEADER(remote_contact)));
		}

		if (op->mCallId.empty()) {
			op->mCallId = 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->assignRecvHeaders((belle_sip_message_t*)response);

		if (op->mCallbacks && op->mCallbacks->process_response_event) {
			/*handle authorization*/
			switch (response_code) {
				case 200:
					break;
				case 401:
				case 407:
					if (op->mState == 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->mPendingAuthTransaction){
							belle_sip_object_unref(op->mPendingAuthTransaction);
							op->mPendingAuthTransaction=NULL;
						}
						if (++op->mAuthRequests > 2) {
							ms_warning("Auth info cannot be found for op [%s/%s] after 2 attempts, giving up",op->getFrom().c_str()
																												,op->getTo().c_str());
							op->mRoot->mCallbacks.auth_failure(op,op->mAuthInfo);
							op->mRoot->removePendingAuth(op);
						} else {
							op->mPendingAuthTransaction=(belle_sip_client_transaction_t*)belle_sip_object_ref(client_transaction);
							op->processAuthentication();
							return;
						}
					}
					break;
				case 403:
					if (op->mAuthInfo) op->mRoot->mCallbacks.auth_failure(op,op->mAuthInfo);
					break;
				case 302:
				case 301:
					if (op->processRedirect() == 0)
						return;
					break;
			}
			if (response_code >= 180 && response_code !=401 && response_code !=407 && response_code !=403) {
				/*not an auth request*/
				op->mAuthRequests=0;
			}
			op->mCallbacks->process_response_event(op,event);
		} else {
			ms_error("Unhandled event response [%p]",event);
		}
	}
}

void Sal::processTimeoutCb(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->mCallbacks && op->mCallbacks->process_timeout) {
		op->mCallbacks->process_timeout(op,event);
	} else {
		ms_error("Unhandled event timeout [%p]",event);
	}
}

void Sal::processTransactionTerminatedCb(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->mCallbacks && op->mCallbacks->process_transaction_terminated) {
		op->mCallbacks->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::processAuthRequestedCb(void *sal, belle_sip_auth_event_t *event) {
	SalAuthInfo* auth_info = sal_auth_info_create(event);
	((Sal*)sal)->mCallbacks.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);*/
	mFactory = factory;
	/*first create the stack, which initializes the belle-sip object's pool for this thread*/
	mStack = belle_sip_stack_new(NULL);

	mUserAgentHeader=belle_sip_header_user_agent_new();
#if defined(PACKAGE_NAME) && defined(LIBLINPHONE_VERSION)
	belle_sip_header_user_agent_add_product(user_agent, PACKAGE_NAME "/" LIBLINPHONE_VERSION);
#else
	belle_sip_header_user_agent_add_product(mUserAgentHeader, "Unknown");
#endif
	   appendStackStringToUserAgent();
	belle_sip_object_ref(mUserAgentHeader);

	mProvider = belle_sip_stack_create_provider(mStack,NULL);
	enableNatHelper(TRUE);

	listener_callbacks.process_dialog_terminated=processDialogTerminatedCb;
	listener_callbacks.process_io_error=processIoErrorCb;
	listener_callbacks.process_request_event=processRequestEventCb;
	listener_callbacks.process_response_event=processResponseEventCb;
	listener_callbacks.process_timeout=processTimeoutCb;
	listener_callbacks.process_transaction_terminated=processTransactionTerminatedCb;
	listener_callbacks.process_auth_requested=processAuthRequestedCb;
	mListener=belle_sip_listener_create_from_callbacks(&listener_callbacks, this);
	belle_sip_provider_add_sip_listener(mProvider, mListener);
}

Sal::~Sal() {
	belle_sip_object_unref(mUserAgentHeader);
	belle_sip_object_unref(mProvider);
	belle_sip_object_unref(mStack);
	belle_sip_object_unref(mListener);
	if (mSupportedHeader)
		belle_sip_object_unref(mSupportedHeader);
}

void Sal::setCallbacks(const Callbacks *cbs) {
	memcpy(&mCallbacks,cbs,sizeof(*cbs));
	if (mCallbacks.call_received==NULL)
		mCallbacks.call_received=(OnCallReceivedCb)unimplementedStub;
	if (mCallbacks.call_ringing==NULL)
		mCallbacks.call_ringing=(OnCallRingingCb)unimplementedStub;
	if (mCallbacks.call_accepted==NULL)
		mCallbacks.call_accepted=(OnCallAcceptedCb)unimplementedStub;
	if (mCallbacks.call_failure==NULL)
		mCallbacks.call_failure=(OnCallFailureCb)unimplementedStub;
	if (mCallbacks.call_terminated==NULL)
		mCallbacks.call_terminated=(OnCallTerminatedCb)unimplementedStub;
	if (mCallbacks.call_released==NULL)
		mCallbacks.call_released=(OnCallReleasedCb)unimplementedStub;
	if (mCallbacks.call_updating==NULL)
		mCallbacks.call_updating=(OnCallUpdatingCb)unimplementedStub;
	if (mCallbacks.auth_failure==NULL)
		mCallbacks.auth_failure=(OnAuthFailureCb)unimplementedStub;
	if (mCallbacks.register_success==NULL)
		mCallbacks.register_success=(OnRegisterSuccessCb)unimplementedStub;
	if (mCallbacks.register_failure==NULL)
		mCallbacks.register_failure=(OnRegisterFailureCb)unimplementedStub;
	if (mCallbacks.dtmf_received==NULL)
		mCallbacks.dtmf_received=(OnDtmfReceivedCb)unimplementedStub;
	if (mCallbacks.notify==NULL)
		mCallbacks.notify=(OnNotifyCb)unimplementedStub;
	if (mCallbacks.subscribe_received==NULL)
		mCallbacks.subscribe_received=(OnSubscribeReceivedCb)unimplementedStub;
	if (mCallbacks.incoming_subscribe_closed==NULL)
		mCallbacks.incoming_subscribe_closed=(OnIncomingSubscribeClosedCb)unimplementedStub;
	if (mCallbacks.parse_presence_requested==NULL)
		mCallbacks.parse_presence_requested=(OnParsePresenceRequestedCb)unimplementedStub;
	if (mCallbacks.convert_presence_to_xml_requested==NULL)
		mCallbacks.convert_presence_to_xml_requested=(OnConvertPresenceToXMLRequestedCb)unimplementedStub;
	if (mCallbacks.notify_presence==NULL)
		mCallbacks.notify_presence=(OnNotifyPresenceCb)unimplementedStub;
	if (mCallbacks.subscribe_presence_received==NULL)
		mCallbacks.subscribe_presence_received=(OnSubscribePresenceReceivedCb)unimplementedStub;
	if (mCallbacks.message_received==NULL)
		mCallbacks.message_received=(OnMessageReceivedCb)unimplementedStub;
	if (mCallbacks.ping_reply==NULL)
		mCallbacks.ping_reply=(OnPingReplyCb)unimplementedStub;
	if (mCallbacks.auth_requested==NULL)
		mCallbacks.auth_requested=(OnAuthRequestedCb)unimplementedStub;
	if (mCallbacks.info_received==NULL)
		mCallbacks.info_received=(OnInfoReceivedCb)unimplementedStub;
	if (mCallbacks.on_publish_response==NULL)
		mCallbacks.on_publish_response=(OnPublishResponseCb)unimplementedStub;
	if (mCallbacks.on_expire==NULL)
		mCallbacks.on_expire=(OnExpireCb)unimplementedStub;
}

void Sal::setTlsProperties(){
	belle_sip_listening_point_t *lp=belle_sip_provider_get_listening_point(mProvider,"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 (!mTlsVerify) verify_exceptions = BELLE_TLS_VERIFY_ANY_REASON;
		else if (!mTlsVerifyCn) verify_exceptions = BELLE_TLS_VERIFY_CN_MISMATCH;
		belle_tls_crypto_config_set_verify_exceptions(crypto_config, verify_exceptions);
		if (!mRootCa.empty())
			belle_tls_crypto_config_set_root_ca(crypto_config, mRootCa.c_str());
		if (!mRootCaData.empty())
			belle_tls_crypto_config_set_root_ca_data(crypto_config, mRootCaData.c_str());
		if (mSslConfig != NULL) belle_tls_crypto_config_set_ssl_config(crypto_config, mSslConfig);
		if (mTlsPostcheckCb) belle_tls_crypto_config_set_postcheck_callback(crypto_config, mTlsPostcheckCb, mTlsPostcheckCbData);
		belle_sip_tls_listening_point_set_crypto_config(tlp, crypto_config);
		belle_sip_object_unref(crypto_config);
	}
}

int Sal::addListenPort(SalAddress* addr, bool 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(mStack, mTunnelClient);
		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(mStack,
									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,(int)mKeepAlive);
		result = belle_sip_provider_add_listening_point(mProvider,lp);
		if (sal_address_get_transport(addr)==SalTransportTLS) {
			         setTlsProperties();
		}
	} else {
		return -1;
	}
	return result;
}

int Sal::setListenPort (const string &addr, int port, SalTransport tr, bool isTunneled) {
	SalAddress *salAddr = sal_address_new(nullptr);
	sal_address_set_domain(salAddr, L_STRING_TO_C(addr));
	sal_address_set_port(salAddr, port);
	sal_address_set_transport(salAddr, tr);
	int result = addListenPort(salAddr, isTunneled);
	sal_address_destroy(salAddr);
	return result;
}

int Sal::getListeningPort(SalTransport tr){
	const char *tpn=sal_transport_to_string(tr);
	belle_sip_listening_point_t *lp=belle_sip_provider_get_listening_point(mProvider, tpn);
	if (lp){
		return belle_sip_listening_point_get_port(lp);
	}
	return 0;
}

int Sal::unlistenPorts(){
	const belle_sip_list_t * lps = belle_sip_provider_get_listening_points(mProvider);
	belle_sip_list_t * tmp_list = belle_sip_list_copy(lps);
	belle_sip_list_for_each2 (tmp_list,(void (*)(void*,void*))removeListeningPoint,mProvider);
	belle_sip_list_free(tmp_list);
	ms_message("sal_unlisten_ports done");
	return 0;
}

int Sal::isTransportAvailable(SalTransport t) {
	switch(t){
		case SalTransportUDP:
		case SalTransportTCP:
			return TRUE;
		case SalTransportTLS:
			return belle_sip_stack_tls_available(mStack);
		case SalTransportDTLS:
			return FALSE;
	}
	return FALSE;
}

void Sal::makeSupportedHeader () {
	if (mSupportedHeader) {
		belle_sip_object_unref(mSupportedHeader);
		mSupportedHeader = nullptr;
	}
	string tags = Utils::join(mSupportedTags, ", ");
	if (tags.empty())
		return;
	mSupportedHeader = belle_sip_header_create("Supported", tags.c_str());
	if (mSupportedHeader)
		belle_sip_object_ref(mSupportedHeader);
}

void Sal::setSupportedTags (const string &tags) {
	vector<string> splittedTags = Utils::split(tags, ",");
	mSupportedTags.clear();
	for (const auto &tag : splittedTags)
		mSupportedTags.push_back(Utils::trim(tag));
	makeSupportedHeader();
}

const string &Sal::getSupportedTags () const {
	if (mSupportedHeader)
		mSupported = belle_sip_header_get_unparsed_value(mSupportedHeader);
	else
		mSupported.clear();
	return mSupported;
}

void Sal::addSupportedTag (const string &tag) {
	auto it = find(mSupportedTags.cbegin(), mSupportedTags.cend(), tag);
	if (it == mSupportedTags.cend()) {
		mSupportedTags.push_back(tag);
		makeSupportedHeader();
	}
}

void Sal::removeSupportedTag (const string &tag) {
	auto it = find(mSupportedTags.begin(), mSupportedTags.end(), tag);
	if (it != mSupportedTags.end()) {
		mSupportedTags.erase(it);
		makeSupportedHeader();
	}
}

int Sal::resetTransports() {
	ms_message("Reseting transports");
	belle_sip_provider_clean_channels(mProvider);
	return 0;
}

ortp_socket_t Sal::getSocket() const {
	ms_warning("sal_get_socket is deprecated");
	return -1;
}

void Sal::setUserAgent (const string &value) {
	belle_sip_header_user_agent_set_products(mUserAgentHeader, nullptr);
	belle_sip_header_user_agent_add_product(mUserAgentHeader, L_STRING_TO_C(value));
}

const string &Sal::getUserAgent () const {
	char userAgent[256];
	belle_sip_header_user_agent_get_products_as_string(mUserAgentHeader, userAgent, (unsigned int)sizeof(userAgent) - 1);
	mUserAgent = userAgent;
	return mUserAgent;
}

void Sal::appendStackStringToUserAgent () {
	stringstream ss;
	ss << "(belle-sip/" << belle_sip_version_to_string() << ")";
	string stackStr = ss.str();
	belle_sip_header_user_agent_add_product(mUserAgentHeader, stackStr.c_str());
}

void Sal::setKeepAlivePeriod(unsigned int value) {
	const belle_sip_list_t* iterator;
	belle_sip_listening_point_t* lp;
	mKeepAlive=value;
	for (iterator=belle_sip_provider_get_listening_points(mProvider);iterator!=NULL;iterator=iterator->next) {
		lp=(belle_sip_listening_point_t*)iterator->data;
		if (mUseTcpTlsKeepAlive || strcasecmp(belle_sip_listening_point_get_transport(lp),"udp")==0) {
			belle_sip_listening_point_set_keep_alive(lp,(int)mKeepAlive);
		}
	}
}

int Sal::setTunnel(void *tunnelclient) {
#ifdef TUNNEL_ENABLED
	mTunnelClient=tunnelclient;
	return 0;
#else
	return -1;
#endif
}

void Sal::setHttpProxyHost (const string &value) {
	belle_sip_stack_set_http_proxy_host(mStack, L_STRING_TO_C(value));
}

const string &Sal::getHttpProxyHost () const {
	mHttpProxyHost = belle_sip_stack_get_http_proxy_host(mStack);
	return mHttpProxyHost;
}

bool Sal::isContentEncodingAvailable (const string &contentEncoding) const {
	return !!belle_sip_stack_content_encoding_available(mStack, L_STRING_TO_C(contentEncoding));
}

bool Sal::isContentTypeSupported (const string &contentType) const {
	auto it = find_if(mSupportedContentTypes.cbegin(), mSupportedContentTypes.cend(),
		[contentType](string supportedContentType) { return contentType == supportedContentType; });
	return it != mSupportedContentTypes.cend();
}

void Sal::addContentTypeSupport (const string &contentType) {
	if (!contentType.empty() && !isContentTypeSupported(contentType))
		mSupportedContentTypes.push_back(contentType);
}

void Sal::removeContentTypeSupport (const string &contentType) {
	auto it = find(mSupportedContentTypes.begin(), mSupportedContentTypes.end(), contentType);
	if (it != mSupportedContentTypes.end())
		mSupportedContentTypes.erase(it);
}

void Sal::useRport(bool use_rports) {
	belle_sip_provider_enable_rport(mProvider,use_rports);
	ms_message("Sal use rport [%s]", use_rports ? "enabled" : "disabled");
}

void Sal::setRootCa (const string &value) {
	mRootCa = value;
	setTlsProperties();
}

void Sal::setRootCaData (const string &value) {
	mRootCaData = value;
	setTlsProperties();
}

void Sal::verifyServerCertificates(bool verify) {
	mTlsVerify=verify;
	setTlsProperties();
}

void Sal::verifyServerCn(bool verify) {
	mTlsVerifyCn = verify;
	setTlsProperties();
}

void Sal::setSslConfig(void *ssl_config) {
	mSslConfig = ssl_config;
	setTlsProperties();
}

void Sal::setTlsPostcheckCallback(int (*cb)(void *, const bctbx_x509_certificate_t *), void *data){
	mTlsPostcheckCb = cb;
	mTlsPostcheckCbData = data;
}

int Sal::createUuid(char *uuid, size_t len) {
	if (generateUuid(uuid, len) == 0) {
		      setUuid(uuid);
		return 0;
	}
	return -1;
}

int Sal::generateUuid(char *uuid, size_t len) {
	   SalUuid 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(SalUuid));
	uuid_struct.clockSeqHiAndReserved&=(unsigned char)~(1<<6);
	uuid_struct.clockSeqHiAndReserved|=(unsigned char)1<<7;
	uuid_struct.timeHiAndVersion&=(unsigned char)~(0xf<<12);
	uuid_struct.timeHiAndVersion|=(unsigned char)4<<12;

	written=snprintf(uuid,len,"%8.8x-%4.4x-%4.4x-%2.2x%2.2x-", uuid_struct.timeLow, uuid_struct.timeMid,
			uuid_struct.timeHiAndVersion, uuid_struct.clockSeqHiAndReserved,
			uuid_struct.clockSeqLow);
	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-(unsigned long)written,"%2.2x", uuid_struct.node[i]);
	uuid[len-1]='\0';
	return 0;
}

void Sal::addPendingAuth (SalOp *op) {
	auto it = find(mPendingAuths.cbegin(), mPendingAuths.cend(), op);
	if (it == mPendingAuths.cend()) {
		mPendingAuths.push_back(op);
		op->mHasAuthPending = true;
	}
}

void Sal::removePendingAuth (SalOp *op) {
	if (op->mHasAuthPending) {
		op->mHasAuthPending = false;
		mPendingAuths.remove(op);
	}
}

void Sal::setDefaultSdpHandling(SalOpSDPHandling sdp_handling_method)  {
	if (sdp_handling_method != SalOpSDPNormal ) ms_message("Enabling special SDP handling for all new SalOp in Sal[%p]!", this);
	mDefaultSdpHandling = sdp_handling_method;
}

void Sal::enableNatHelper(bool enable) {
	mNatHelperEnabled=enable;
	belle_sip_provider_enable_nat_helper(mProvider,enable);
	ms_message("Sal nat helper [%s]",enable?"enabled":"disabled");
}

void Sal::getDefaultLocalIp(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::setDnsServers(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(mStack, l);
	belle_sip_list_free(l);
}

void Sal::setDnsUserHostsFile (const string &value) {
	belle_sip_stack_set_dns_user_hosts_file(mStack, value.c_str());
}

const string &Sal::getDnsUserHostsFile () const {
	mDnsUserHostsFile = belle_sip_stack_get_dns_user_hosts_file(mStack);
	return mDnsUserHostsFile;
}

belle_sip_resolver_context_t *Sal::resolveA (const string &name, int port, int family, belle_sip_resolver_callback_t cb, void *data) {
	return belle_sip_stack_resolve_a(mStack, L_STRING_TO_C(name), port, family, cb, data);
}

belle_sip_resolver_context_t *Sal::resolve (const string &service, const string &transport, const string &name, int port, int family, belle_sip_resolver_callback_t cb, void *data) {
	return belle_sip_stack_resolve(mStack, L_STRING_TO_C(service), L_STRING_TO_C(transport), L_STRING_TO_C(name), port, family, cb, data);
}

belle_sip_source_t *Sal::createTimer (belle_sip_source_func_t func, void *data, unsigned int timeoutValueMs, const string &timerName) {
	belle_sip_main_loop_t *ml = belle_sip_stack_get_main_loop(mStack);
	return belle_sip_main_loop_create_timeout(ml, func, data, timeoutValueMs, L_STRING_TO_C(timerName));
}

void Sal::cancelTimer(belle_sip_source_t *timer) {
	belle_sip_main_loop_t *ml = belle_sip_stack_get_main_loop(mStack);
	belle_sip_main_loop_remove_source(ml, timer);
}

belle_sip_response_t* Sal::createResponseFromRequest (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(mUserAgentHeader));
	belle_sip_message_add_header(BELLE_SIP_MESSAGE(resp), mSupportedHeader);
	return resp;
}

int Sal::findCryptoIndexFromTag (const SalSrtpCryptoAlgo crypto[], unsigned char tag) {
	for (int i = 0; i < SAL_CRYPTO_ALGO_MAX; i++) {
		if (crypto[i].tag == tag)
			return i;
	}
	return -1;
}



/***********************************/
/* 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 LinphonePrivate;

// NOTE: This is ugly but it's not possible to export simply this set of functions in tester_utils...
// Because tester_utils and private files are ill-thought.
// A workaround is to use LINPHONE_PUBLIC here.

extern "C" {

LINPHONE_PUBLIC Sal *linphone_core_get_sal(const LinphoneCore *lc) {
	return lc->sal;
}

LINPHONE_PUBLIC SalOp *linphone_proxy_config_get_sal_op(const LinphoneProxyConfig *cfg) {
	return cfg->op;
}

LINPHONE_PUBLIC SalOp *linphone_call_get_op_as_sal_op(const LinphoneCall *call) {
	return linphone_call_get_op(call);
}

LINPHONE_PUBLIC Sal *sal_init(MSFactory *factory) {
	return new Sal(factory);
}

LINPHONE_PUBLIC void sal_uninit(Sal* sal) {
	delete sal;
}

LINPHONE_PUBLIC int sal_create_uuid(Sal *ctx, char *uuid, size_t len) {
	return ctx->createUuid(uuid, len);
}

LINPHONE_PUBLIC void sal_set_uuid(Sal *ctx, const char *uuid) {
	ctx->setUuid(L_C_TO_STRING(uuid));
}

LINPHONE_PUBLIC void sal_default_set_sdp_handling(Sal* h, SalOpSDPHandling handling_method) {
	h->setDefaultSdpHandling(handling_method);
}

LINPHONE_PUBLIC void sal_set_send_error(Sal *sal,int value) {
	sal->setSendError(value);
}

LINPHONE_PUBLIC void sal_set_recv_error(Sal *sal,int value) {
	sal->setRecvError(value);
}

LINPHONE_PUBLIC void sal_enable_pending_trans_checking(Sal *sal, bool value) {
	sal->enablePendingTransactionChecking(value);
}

LINPHONE_PUBLIC void sal_enable_unconditional_answer(Sal *sal,int value) {
	sal->enableUnconditionalAnswer(value);
}

LINPHONE_PUBLIC void sal_set_dns_timeout(Sal* sal,int timeout) {
	sal->setDnsTimeout(timeout);
}

LINPHONE_PUBLIC void sal_set_dns_user_hosts_file(Sal *sal, const char *hosts_file) {
	sal->setDnsUserHostsFile(hosts_file);
}

LINPHONE_PUBLIC void *sal_get_stack_impl(Sal *sal) {
	return sal->getStackImpl();
}

LINPHONE_PUBLIC void sal_set_refresher_retry_after(Sal *sal,int value) {
	sal->setRefresherRetryAfter(value);
}

LINPHONE_PUBLIC int sal_get_refresher_retry_after(const Sal *sal) {
	return sal->getRefresherRetryAfter();
}

LINPHONE_PUBLIC void sal_set_transport_timeout(Sal* sal,int timeout) {
	sal->setTransportTimeout(timeout);
}

LINPHONE_PUBLIC void sal_enable_test_features(Sal*ctx, bool enabled) {
	ctx->enableTestFeatures(enabled);
}

LINPHONE_PUBLIC int sal_transport_available(Sal *ctx, SalTransport t) {
	return ctx->isTransportAvailable(t);
}

LINPHONE_PUBLIC const SalErrorInfo *sal_op_get_error_info(const SalOp *op) {
	return op->getErrorInfo();
}

LINPHONE_PUBLIC bool sal_call_dialog_request_pending(const SalOp *op) {
	auto callOp = dynamic_cast<const SalCallOp *>(op);
	return callOp->dialogRequestPending();
}

LINPHONE_PUBLIC void sal_call_set_sdp_handling(SalOp *h, SalOpSDPHandling handling) {
	auto callOp = dynamic_cast<SalCallOp *>(h);
	callOp->setSdpHandling(handling);
}

LINPHONE_PUBLIC SalMediaDescription * sal_call_get_final_media_description(SalOp *h) {
	auto callOp = dynamic_cast<SalCallOp *>(h);
	return callOp->getFinalMediaDescription();
}

LINPHONE_PUBLIC belle_sip_resolver_context_t *sal_resolve_a(Sal *sal, const char *name, int port, int family, belle_sip_resolver_callback_t cb, void *data) {
	return sal->resolveA(name, port, family, cb, data);
}

LINPHONE_PUBLIC Sal *sal_op_get_sal(SalOp *op) {
	return op->getSal();
}

LINPHONE_PUBLIC SalOp *sal_create_refer_op(Sal *sal) {
	return new SalReferOp(sal);
}

LINPHONE_PUBLIC void sal_release_op(SalOp *op) {
	op->release();
}

LINPHONE_PUBLIC void sal_op_set_from(SalOp *sal_refer_op, const char* from) {
	auto referOp = dynamic_cast<SalReferOp *>(sal_refer_op);
	referOp->setFrom(from);
}

LINPHONE_PUBLIC void sal_op_set_to(SalOp *sal_refer_op, const char* to) {
	auto referOp = dynamic_cast<SalReferOp *>(sal_refer_op);
	referOp->setTo(to);
}

LINPHONE_PUBLIC void sal_op_send_refer(SalOp *sal_refer_op, SalAddress* refer_to) {
	auto referOp = dynamic_cast<SalReferOp *>(sal_refer_op);
	referOp->sendRefer(refer_to);
}

LINPHONE_PUBLIC void sal_set_user_pointer(Sal *sal, void *user_pointer) {
	sal->setUserPointer(user_pointer);
}

LINPHONE_PUBLIC void *sal_get_user_pointer(Sal *sal) {
	return sal->getUserPointer();
}

LINPHONE_PUBLIC void sal_set_call_refer_callback(Sal *sal, void (*OnReferCb)(SalOp *op, const SalAddress *referto)) {
	struct Sal::Callbacks cbs = {NULL};
	cbs.refer_received = OnReferCb;
	sal->setCallbacks(&cbs);
}

}