sipvoiplink.cpp

/*
 *  Copyright (C) 2004, 2005, 2006, 2008, 2009, 2010 Savoir-Faire Linux Inc.
 *
 *  Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>
 *  Author: Yun Liu <yun.liu@savoirfairelinux.com>
 *  Author: Pierre-Luc Bacon <pierre-luc.bacon@savoirfairelinux.com>
 *  Author: Alexandre Savard <alexandre.savard@savoirfairelinux.com>
 *
 *  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 3 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  Additional permission under GNU GPL version 3 section 7:
 *
 *  If you modify this program, or any covered work, by linking or
 *  combining it with the OpenSSL project's OpenSSL library (or a
 *  modified version of that library), containing parts covered by the
 *  terms of the OpenSSL or SSLeay licenses, Savoir-Faire Linux Inc.
 *  grants you additional permission to convey the resulting work.
 *  Corresponding Source for a non-source form of such a combination
 *  shall include the source code for the parts of OpenSSL used as well
 *  as that of the covered work.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "sipvoiplink.h"

#include "manager.h"

#include "sip/sdp.h"
#include "sipcall.h"
#include "sipaccount.h"
#include "eventthread.h"
#include "SdesNegotiator.h"

#include "dbus/dbusmanager.h"
#include "dbus/callmanager.h"

#include "hooks/urlhook.h"
#include "im/InstantMessaging.h"

#include "audio/audiolayer.h"
#include "audio/audiortp/AudioRtpFactory.h"

#include "pjsip/sip_endpoint.h"
#include "pjsip/sip_transport_tls.h"
#include "pjsip/sip_uri.h"
#include <pjnath.h>

#include <netinet/in.h>
#include <arpa/nameser.h>
#include <resolv.h>
#include <istream>
#include <utility> // for std::pair

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <linux/if.h>

#include <map>

using namespace sfl;

namespace {
/** The default transport (5060) */
static pjsip_transport *_localUDPTransport = NULL;

/** A map to retreive SFLphone internal call id
 *  Given a SIP call ID (usefull for transaction sucha as transfer)*/
static std::map<std::string, std::string> transferCallID;

/**************** EXTERN VARIABLES AND FUNCTIONS (callbacks) **************************/

/**
 * Set audio (SDP) configuration for a call
 * localport, localip, localexternalport
 * @param call a SIPCall valid pointer
 */
void setCallMediaLocal (SIPCall* call, const std::string &localIP);

/**
 * Helper function to parser header from incoming sip messages
 */
std::string fetchHeaderValue (pjsip_msg *msg, std::string field);

static pj_caching_pool pool_cache, *_cp = &pool_cache;
static pj_pool_t *_pool;
static pjsip_endpoint *_endpt;
static pjsip_module _mod_ua;
static pj_thread_t *thread;

static void sdp_media_update_cb (pjsip_inv_session *inv, pj_status_t status UNUSED);
static void sdp_request_offer_cb (pjsip_inv_session *inv, const pjmedia_sdp_session *offer);
static void sdp_create_offer_cb (pjsip_inv_session *inv, pjmedia_sdp_session **p_offer);
static void invite_session_state_changed_cb (pjsip_inv_session *inv, pjsip_event *e);
static void outgoing_request_forked_cb (pjsip_inv_session *inv, pjsip_event *e);
static void transaction_state_changed_cb (pjsip_inv_session *inv, pjsip_transaction *tsx, pjsip_event *e);
static void registration_cb (struct pjsip_regc_cbparam *param);
static pj_bool_t transaction_request_cb (pjsip_rx_data *rdata);
static pj_bool_t transaction_response_cb (pjsip_rx_data *rdata UNUSED) ;

static void transfer_client_cb (pjsip_evsub *sub, pjsip_event *event);

/**
 * Send a reINVITE inside an active dialog to modify its state
 * Local SDP session should be modified before calling this method
 * @param sip call
 */
int SIPSessionReinvite(SIPCall *);

/**
 * Helper function to process refer function on call transfer
 */
void onCallTransfered (pjsip_inv_session *inv, pjsip_rx_data *rdata);

std::string loadSIPLocalIP()
{
    pj_sockaddr ip_addr;
    if (pj_gethostip (pj_AF_INET(), &ip_addr) == PJ_SUCCESS)
        return pj_inet_ntoa (ip_addr.ipv4.sin_addr);
    return "";
}

pjsip_route_hdr *createRouteSet(const std::string &route, pj_pool_t *hdr_pool)
{
	int port = 0;
	std::string host;

    size_t found = route.find(":");
    if (found != std::string::npos) {
		host = route.substr(0, found);
		port = atoi(route.substr(found + 1, route.length()).c_str());
	}
	else {
		host = route;
	}

	pjsip_route_hdr *route_set = pjsip_route_hdr_create (hdr_pool);
    pjsip_route_hdr *routing = pjsip_route_hdr_create (hdr_pool);
    pjsip_sip_uri *url = pjsip_sip_uri_create (hdr_pool, 0);
    routing->name_addr.uri = (pjsip_uri*) url;
    pj_strdup2(hdr_pool, &url->host, host.c_str());
    url->port = port;

    pj_list_push_back(route_set, pjsip_hdr_clone (hdr_pool, routing));

    return route_set;
}

} // end anonymous namespace

/*************************************************************************************************/

SIPVoIPLink::SIPVoIPLink() : evThread_(new EventThread(this))
{
#define TRY(ret) do { \
		if (ret != PJ_SUCCESS) \
			throw VoipLinkException(#ret " failed"); \
		} while(0)

    srand(time(NULL)); // to get random number for RANDOM_PORT

    TRY(pj_init());
    TRY(pjlib_util_init());
    pj_log_set_level(6);    // From 0 (min) to 6 (max)
    TRY(pjnath_init());

    pj_caching_pool_init (_cp, &pj_pool_factory_default_policy, 0);
    _pool = pj_pool_create (&_cp->factory, "sflphone", 4000, 4000, NULL);
    if (!_pool)
        throw VoipLinkException("UserAgent: Could not initialize memory pool");

    TRY(pjsip_endpt_create (&_cp->factory, pj_gethostname()->ptr, &_endpt));
    if (loadSIPLocalIP().empty())
        throw VoipLinkException("UserAgent: Unable to determine network capabilities");

    TRY(pjsip_tsx_layer_init_module(_endpt));
    TRY(pjsip_ua_init_module(_endpt, NULL));
    TRY(pjsip_replaces_init_module(_endpt)); // See the Replaces specification in RFC 3891
    TRY(pjsip_100rel_init_module(_endpt));

    // Initialize and register sflphone module
    _mod_ua.name = pj_str ( (char*) PACKAGE);
    _mod_ua.id = -1;
    _mod_ua.priority = PJSIP_MOD_PRIORITY_APPLICATION;
    _mod_ua.on_rx_request = &transaction_request_cb;
    _mod_ua.on_rx_response = &transaction_response_cb;
    TRY(pjsip_endpt_register_module(_endpt, &_mod_ua));

    TRY(pjsip_evsub_init_module(_endpt));
    TRY(pjsip_xfer_init_module(_endpt));

    static const pjsip_inv_callback inv_cb = {
    		invite_session_state_changed_cb,
    		outgoing_request_forked_cb,
    		transaction_state_changed_cb,
    		sdp_request_offer_cb,
    		sdp_create_offer_cb,
    		sdp_media_update_cb,
    		NULL,
    		NULL,
    };
    TRY(pjsip_inv_usage_init(_endpt, &inv_cb));

    static const pj_str_t allowed[] = { { (char*) "INFO", 4}, { (char*) "REGISTER", 8}, { (char*) "OPTIONS", 7}, { (char*) "MESSAGE", 7 } };       //  //{"INVITE", 6}, {"ACK",3}, {"BYE",3}, {"CANCEL",6}
    pjsip_endpt_add_capability (_endpt, &_mod_ua, PJSIP_H_ALLOW, NULL, PJ_ARRAY_SIZE (allowed), allowed);

    static const pj_str_t text_plain = { (char*) "text/plain", 10 };
    pjsip_endpt_add_capability (_endpt, &_mod_ua, PJSIP_H_ACCEPT, NULL, 1, &text_plain);

    static const pj_str_t accepted = { (char*) "application/sdp", 15 };
    pjsip_endpt_add_capability (_endpt, &_mod_ua, PJSIP_H_ACCEPT, NULL, 1, &accepted);

    _debug ("UserAgent: pjsip version %s for %s initialized", pj_get_version(), PJ_OS_NAME);

    TRY(pjsip_replaces_init_module(_endpt));

    evThread_->start();
}

SIPVoIPLink::~SIPVoIPLink()
{
	delete evThread_;
    pj_thread_join (thread);
    pj_thread_destroy (thread);

    const pj_time_val tv = {0, 10};
	pjsip_endpt_handle_events(_endpt, &tv);
	pjsip_endpt_destroy (_endpt);

	pj_pool_release (_pool);
	pj_caching_pool_destroy (_cp);

    pj_shutdown();
}

SIPVoIPLink* SIPVoIPLink::instance()
{
	static SIPVoIPLink* instance = NULL;
    if (!instance)
        instance = new SIPVoIPLink;

    return instance;
}

void SIPVoIPLink::init() {}

void SIPVoIPLink::terminate() {}

void
SIPVoIPLink::getEvent()
{
	static pj_thread_desc desc;

    // We have to register the external thread so it could access the pjsip frameworks
    if (!pj_thread_is_registered())
        pj_thread_register(NULL, desc, &thread);

    // PJSIP polling
    pj_time_val timeout = {0, 10};

    pjsip_endpt_handle_events(_endpt, &timeout);
}

void SIPVoIPLink::sendRegister (Account *a)
{
    SIPAccount *account = static_cast<SIPAccount*>(a);

    if (account->transport)
        pjsip_transport_dec_ref(account->transport);

    createSipTransport(account);

	if (!account->transport) {
		// Could not create new transport, this transport may already exists
		account->transport = transportMap_[account->getLocalPort()];
		if (account->transport) {
			pjsip_transport_add_ref(account->transport);
		} else {
			account->transport = _localUDPTransport;
			account->setLocalPort(_localUDPTransport->local_name.port);
		}
	}

	account->setRegister(true);
	account->setRegistrationState (Trying);

    pjsip_regc *regc = account->getRegistrationInfo();
	if (pjsip_regc_create(_endpt, (void *) account, &registration_cb, &regc) != PJ_SUCCESS)
		throw VoipLinkException("UserAgent: Unable to create regc structure.");

	std::string srvUri(account->getServerUri());

	std::string address, port;
	findLocalAddressFromUri(srvUri, account->transport, address, port);

	std::string from(account->getFromUri());
	pj_str_t pjFrom = pj_str((char*)from.c_str());
	std::string contact(account->getContactHeader(address, port));
	pj_str_t pjContact = pj_str((char*)contact.c_str());
	pj_str_t pjSrv = pj_str((char*)srvUri.c_str());

	int expire_value = atoi(account->getRegistrationExpire().c_str());
	if (!expire_value)
		expire_value = PJSIP_REGC_EXPIRATION_NOT_SPECIFIED;


	if (pjsip_regc_init (regc, &pjSrv, &pjFrom, &pjFrom, 1, &pjContact, expire_value) != PJ_SUCCESS)
		throw VoipLinkException("Unable to initialize account registration structure");

	if (!account->getServiceRoute().empty())
		pjsip_regc_set_route_set (regc, createRouteSet(account->getServiceRoute(), _pool));

	pjsip_regc_set_credentials (regc, account->getCredentialCount(), account->getCredInfo());


    pjsip_hdr hdr_list;
	pj_list_init (&hdr_list);
	std::string useragent(account->getUserAgentName());
	pj_str_t pJuseragent = pj_str ((char*)useragent.c_str());
	const pj_str_t STR_USER_AGENT = { (char*) "User-Agent", 10 };

	pjsip_generic_string_hdr *h = pjsip_generic_string_hdr_create(_pool, &STR_USER_AGENT, &pJuseragent);
	pj_list_push_back (&hdr_list, (pjsip_hdr*) h);
	pjsip_regc_add_headers (regc, &hdr_list);


    pjsip_tx_data *tdata;
	if (pjsip_regc_register (regc, PJ_TRUE, &tdata) != PJ_SUCCESS)
		throw VoipLinkException("Unable to initialize transaction data for account registration");

	if (pjsip_regc_set_transport (regc, initTransportSelector (account->transport, _pool)) != PJ_SUCCESS)
		throw VoipLinkException("Unable to set transport");

	// decrease transport's ref count, counter incrementation is managed when acquiring transport
	pjsip_transport_dec_ref(account->transport);

	// pjsip_regc_send increment the transport ref count by one,
	if (pjsip_regc_send(regc, tdata) != PJ_SUCCESS)
		throw VoipLinkException("Unable to send account registration request");

	// Decrease transport's ref count, since coresponding reference counter decrementation
	// is performed in pjsip_regc_destroy. This function is never called in SFLphone as the
	// regc data structure is permanently associated to the account at first registration.
	pjsip_transport_dec_ref (account->transport);

    account->setRegistrationInfo (regc);
}

void SIPVoIPLink::sendUnregister (Account *a)
{
    SIPAccount *account = dynamic_cast<SIPAccount *>(a);

    // This may occurs if account failed to register and is in state INVALID
    if (!account->isRegister()) {
        account->setRegistrationState (Unregistered);
        return;
    }

    pjsip_regc *regc = account->getRegistrationInfo();
    if (!regc)
        throw VoipLinkException("Registration structure is NULL");

    pjsip_tx_data *tdata = NULL;
    if (pjsip_regc_unregister (regc, &tdata) != PJ_SUCCESS)
        throw VoipLinkException("Unable to unregister sip account");

    if (pjsip_regc_send (regc, tdata) != PJ_SUCCESS)
        throw VoipLinkException("Unable to send request to unregister sip account");

    account->setRegister (false);
}

Call *SIPVoIPLink::newOutgoingCall (const std::string& id, const std::string& toUrl)
{
    SIPAccount *account = dynamic_cast<SIPAccount *> (Manager::instance().getAccount (Manager::instance().getAccountFromCall (id)));
    if (account == NULL) // TODO: We should investigate how we could get rid of this error and create a IP2IP call instead
    	throw VoipLinkException("Could not get account for this call");

    SIPCall* call = new SIPCall (id, Call::Outgoing, _cp);

    // If toUri is not a well formated sip URI, use account information to process it
    std::string toUri;
    if((toUrl.find("sip:") != std::string::npos) or
    		toUrl.find("sips:") != std::string::npos)
    	toUri = toUrl;
    else
        toUri = account->getToUri(toUrl);

    call->setPeerNumber (toUri);
    std::string localAddr(getInterfaceAddrFromName (account->getLocalInterface ()));

    if (localAddr == "0.0.0.0")
    	localAddr = loadSIPLocalIP();

    setCallMediaLocal (call, localAddr);

    // May use the published address as well
    std::string addrSdp = account->isStunEnabled() ?
        account->getPublishedAddress() :
        getInterfaceAddrFromName(account->getLocalInterface());

    if (addrSdp == "0.0.0.0")
		addrSdp = loadSIPLocalIP();

    // Initialize the session using ULAW as default codec in case of early media
    // The session should be ready to receive media once the first INVITE is sent, before
    // the session initialization is completed
    sfl::Codec* audiocodec = Manager::instance().audioCodecFactory.instantiateCodec (PAYLOAD_CODEC_ULAW);
    if (audiocodec == NULL) {
    	delete call;
    	throw VoipLinkException ("Could not instantiate codec for early media");
    }

	try {
		call->getAudioRtp()->initAudioRtpConfig ();
		call->getAudioRtp()->initAudioSymmetricRtpSession ();
		call->getAudioRtp()->initLocalCryptoInfo ();
		call->getAudioRtp()->start (static_cast<sfl::AudioCodec *>(audiocodec));
	} catch (...) {
        delete call;
        throw VoipLinkException ("Could not start rtp session for early media");
	}

	call->initRecFileName(toUrl);

	call->getLocalSDP()->setLocalIP (addrSdp);
	call->getLocalSDP()->createOffer(account->getActiveCodecs());

	if (!SIPStartCall(call)) {
		delete call;
		throw VoipLinkException("Could not send outgoing INVITE request for new call");
	}

	return call;
}

void
SIPVoIPLink::answer (Call *c)
{
    SIPCall *call = dynamic_cast<SIPCall*>(c);
    if (!call)
    	return;

    pjsip_tx_data *tdata;
    if (pjsip_inv_answer (call->inv, PJSIP_SC_OK, NULL, NULL, &tdata) != PJ_SUCCESS)
	   throw VoipLinkException("Could not init invite request answer (200 OK)");

    if (pjsip_inv_send_msg (call->inv, tdata) != PJ_SUCCESS)
	   throw VoipLinkException("Could not send invite request answer (200 OK)");

    call->setConnectionState (Call::Connected);
    call->setState (Call::Active);
}

void
SIPVoIPLink::hangup (const std::string& id)
{
    SIPCall* call = getSIPCall(id);

    std::string account_id(Manager::instance().getAccountFromCall(id));
    SIPAccount *account = dynamic_cast<SIPAccount *> (Manager::instance().getAccount (account_id));
    if (account == NULL)
    	throw VoipLinkException("Could not find account for this call");

    pjsip_inv_session *inv = call->inv;
    if (inv == NULL)
        throw VoipLinkException("No invite session for this call");

    // Looks for sip routes
    if (not (account->getServiceRoute().empty())) {
        pjsip_route_hdr *route_set = createRouteSet(account->getServiceRoute(), inv->pool);
        pjsip_dlg_set_route_set (inv->dlg, route_set);
    }

    pjsip_tx_data *tdata = NULL;
    // User hangup current call. Notify peer
    if (pjsip_inv_end_session (inv, 404, NULL, &tdata) != PJ_SUCCESS || !tdata)
        return;

    if (pjsip_inv_send_msg (inv, tdata) != PJ_SUCCESS)
        return;

    // Make sure user data is NULL in callbacks
    inv->mod_data[_mod_ua.id] = NULL;

	if (Manager::instance().isCurrentCall (id))
		call->getAudioRtp()->stop();

    removeCall (id);
}

void
SIPVoIPLink::peerHungup (const std::string& id)
{
    SIPCall* call = getSIPCall(id);

    // User hangup current call. Notify peer
    pjsip_tx_data *tdata = NULL;
    if (pjsip_inv_end_session (call->inv, 404, NULL, &tdata) != PJ_SUCCESS || !tdata)
        return;

    if (pjsip_inv_send_msg (call->inv, tdata) != PJ_SUCCESS)
        return;

    // Make sure user data is NULL in callbacks
    call->inv->mod_data[_mod_ua.id ] = NULL;

	if (Manager::instance().isCurrentCall (id))
		call->getAudioRtp()->stop();

    removeCall (id);
}

void
SIPVoIPLink::onhold (const std::string& id)
{
    SIPCall *call = getSIPCall(id);
    call->setState (Call::Hold);
	call->getAudioRtp()->stop();

	Sdp *sdpSession = call->getLocalSDP();
    if (!sdpSession)
    	throw VoipLinkException("Could not find sdp session");

    sdpSession->removeAttributeFromLocalAudioMedia("sendrecv");
    sdpSession->removeAttributeFromLocalAudioMedia("sendonly");
    sdpSession->addAttributeToLocalAudioMedia("sendonly");

    SIPSessionReinvite (call);
}

void
SIPVoIPLink::offhold (const std::string& id)
{
    SIPCall *call = getSIPCall (id);

	Sdp *sdpSession = call->getLocalSDP();
    if (sdpSession == NULL)
    	throw VoipLinkException("Could not find sdp session");

    try {
        int pl = PAYLOAD_CODEC_ULAW;
        sfl::Codec *sessionMedia = sdpSession->getSessionMedia();
        if (sessionMedia)
    	    pl = sessionMedia->getPayloadType();

        // Create a new instance for this codec
        sfl::Codec* audiocodec = Manager::instance().audioCodecFactory.instantiateCodec (pl);
        if (audiocodec == NULL)
    	    throw VoipLinkException("Could not instantiate codec");

        call->getAudioRtp()->initAudioRtpConfig ();
        call->getAudioRtp()->initAudioSymmetricRtpSession ();
        call->getAudioRtp()->start (static_cast<sfl::AudioCodec *>(audiocodec));

    }
    catch (const SdpException &e) {
    	_error("UserAgent: Exception: %s", e.what());
    } 
    catch (...) {
    	throw VoipLinkException("Could not create audio rtp session");
    }

    sdpSession->removeAttributeFromLocalAudioMedia("sendrecv");
    sdpSession->removeAttributeFromLocalAudioMedia("sendonly");

    sdpSession->addAttributeToLocalAudioMedia("sendrecv");

    /* Create re-INVITE with new offer */
    if (SIPSessionReinvite(call) == PJ_SUCCESS)
    	call->setState (Call::Active);
}

void
SIPVoIPLink::sendTextMessage (sfl::InstantMessaging *module, const std::string& callID, const std::string& message, const std::string& from)
{
    SIPCall *call;
    try {
        call = getSIPCall (callID);
    }
    catch (const VoipLinkException &e) {
        return;
    }

	/* Send IM message */
	sfl::InstantMessaging::UriList list;
	sfl::InstantMessaging::UriEntry entry;
	entry[sfl::IM_XML_URI] = std::string ("\"" + from + "\""); // add double quotes for xml formating

	list.push_front (entry);

	module->send_sip_message (call->inv, callID, module->appendUriList (message, list));
}

void
SIPVoIPLink::transfer (const std::string& id, const std::string& to)
{
    SIPCall *call = getSIPCall(id);

    call->stopRecording();

    std::string account_id(Manager::instance().getAccountFromCall(id));
    SIPAccount *account = dynamic_cast<SIPAccount *>(Manager::instance().getAccount (account_id));
    if (account == NULL)
    	throw VoipLinkException("Could not find account");

    std::string dest;
    pj_str_t pjDest;

    if (to.find ("@") == std::string::npos) {
        dest = account->getToUri(to);
        pj_cstr (&pjDest, dest.c_str());
    }

    pjsip_evsub_user xfer_cb;
    pj_bzero (&xfer_cb, sizeof (xfer_cb));
    xfer_cb.on_evsub_state = &transfer_client_cb;

    pjsip_evsub *sub;
    if (pjsip_xfer_create_uac (call->inv->dlg, &xfer_cb, &sub) != PJ_SUCCESS)
    	throw VoipLinkException("Could not create xfer request");

    /* Associate this voiplink of call with the client subscription
     * We can not just associate call with the client subscription
     * because after this function, we can no find the cooresponding
     * voiplink from the call any more. But the voiplink is useful!
     */
    pjsip_evsub_set_mod_data (sub, _mod_ua.id, this);

    /*
     * Create REFER request.
     */
    pjsip_tx_data *tdata;

    if (pjsip_xfer_initiate (sub, &pjDest, &tdata) != PJ_SUCCESS)
    	throw VoipLinkException("Could not create REFER request");

    // Put SIP call id in map in order to retrieve call during transfer callback
    std::string callidtransfer(call->inv->dlg->call_id->id.ptr, call->inv->dlg->call_id->id.slen);
    transferCallID[callidtransfer] = call->getCallId();

    /* Send. */
    if (pjsip_xfer_send_request (sub, tdata) != PJ_SUCCESS)
    	throw VoipLinkException("Could not send xfer request");
}

bool SIPVoIPLink::attendedTransfer(const std::string& transferId, const std::string& targetId)
{
	char str_dest_buf[PJSIP_MAX_URL_SIZE*2];

	pjsip_dialog *target_dlg = getSIPCall(targetId)->inv->dlg;

    /* Print URI */
	pj_str_t str_dest = { NULL, 0 };
    str_dest_buf[0] = '<';
    str_dest.slen = 1;

	pjsip_uri *uri = (pjsip_uri*) pjsip_uri_get_uri(target_dlg->remote.info->uri);
    int len = pjsip_uri_print(PJSIP_URI_IN_REQ_URI, uri,
                              str_dest_buf+1, sizeof(str_dest_buf)-1);
    str_dest.slen += len;

    len = pj_ansi_snprintf(str_dest_buf + str_dest.slen,
    		               sizeof(str_dest_buf) - str_dest.slen,
    			           "?"
    		               "Replaces=%.*s"
    			           "%%3Bto-tag%%3D%.*s"
    			           "%%3Bfrom-tag%%3D%.*s>",
    			           (int)target_dlg->call_id->id.slen,
                           target_dlg->call_id->id.ptr,
                           (int)target_dlg->remote.info->tag.slen,
                           target_dlg->remote.info->tag.ptr,
                           (int)target_dlg->local.info->tag.slen,
                           target_dlg->local.info->tag.ptr);

    str_dest.ptr = str_dest_buf;
    str_dest.slen += len;

    SIPCall *transferCall = getSIPCall(transferId);

    /* Create xfer client subscription. */
	struct pjsip_evsub_user xfer_cb;
    pj_bzero (&xfer_cb, sizeof (xfer_cb));
    xfer_cb.on_evsub_state = &transfer_client_cb;
	pjsip_evsub *sub;

    if (pjsip_xfer_create_uac (transferCall->inv->dlg, &xfer_cb, &sub) != PJ_SUCCESS)
    	return false;

    /* Associate this voiplink of call with the client subscription
     * We can not just associate call with the client subscription
     * because after this function, we can no find the cooresponding
     * voiplink from the call any more. But the voiplink is useful!
     */
    pjsip_evsub_set_mod_data (sub, _mod_ua.id, this);

	pjsip_tx_data *tdata;
    if (pjsip_xfer_initiate (sub, &str_dest, &tdata) != PJ_SUCCESS)
    	return false;

    // Put SIP call id in map in order to retrieve call during transfer callback
    pj_str_t *callidtr = &transferCall->inv->dlg->call_id->id;
    transferCallID[std::string (callidtr->ptr, callidtr->slen)] = transferCall->getCallId();

    return pjsip_xfer_send_request (sub, tdata) == PJ_SUCCESS;
}

bool
SIPVoIPLink::refuse (const std::string& id)
{
    SIPCall *call = getSIPCall (id);
    if (!call->isIncoming() or call->getConnectionState() == Call::Connected)
        return false;

    call->getAudioRtp()->stop();

    pjsip_tx_data *tdata;
    if (pjsip_inv_end_session (call->inv, PJSIP_SC_DECLINE, NULL, &tdata) != PJ_SUCCESS)
        return false;

    if (pjsip_inv_send_msg (call->inv, tdata) != PJ_SUCCESS)
        return false;

    // Make sure the pointer is NULL in callbacks
    call->inv->mod_data[_mod_ua.id] = NULL;

    removeCall (id);

    return true;
}

std::string
SIPVoIPLink::getCurrentCodecName(Call *call) const
{
    return dynamic_cast<SIPCall*>(call)->getLocalSDP()->getCodecName();
}

void
SIPVoIPLink::carryingDTMFdigits (const std::string& id, char code)
{
    std::string accountID(Manager::instance().getAccountFromCall(id));
    SIPAccount *account = static_cast<SIPAccount*>(Manager::instance().getAccount(accountID));
    if (account) try {
    	dtmfSend(getSIPCall(id), code, account->getDtmfType());
    } catch (VoipLinkException) {
    	// don't do anything if call doesn't exist
    }
}

void
SIPVoIPLink::dtmfSend (SIPCall *call, char code, DtmfType dtmf)
{