sipvoiplink.cpp

/*
 *  Copyright (C) 2004-2009 Savoir-Faire Linux inc.
 *
 *  Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>
 *  Author: Yun Liu <yun.liu@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.
 */

#include "sipvoiplink.h"
#include "eventthread.h"
#include "sipcall.h"
#include "sipaccount.h"
#include "audio/audiortp.h"

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

/*
 *  The global pool factory
 */
pj_caching_pool _cp;

/*
 * The pool to allocate memory
 */
pj_pool_t *_pool;    

/*
 *	The SIP endpoint
 */
pjsip_endpoint *_endpt;

/*
 *	The SIP module
 */
pjsip_module _mod_ua;  

/*
 * Thread related
 */
pj_thread_t *thread;
pj_thread_desc desc;


/**
 * Get the number of voicemail waiting in a SIP message
 */
void set_voicemail_info( AccountID account, pjsip_msg_body *body );

/**
 * Set audio (SDP) configuration for a call
 * localport, localip, localexternalport
 * @param call a SIPCall valid pointer
 * @return bool True
 */
bool setCallAudioLocal(SIPCall* call, std::string localIP, bool stun, std::string server);

// Documentated from the PJSIP Developer's Guide, available on the pjsip website/

/*
 * Session callback
 * Called when the invite session state has changed.
 *
 * @param	inv	A pointer on a pjsip_inv_session structure
 * @param	e	A pointer on a pjsip_event structure
 */
void call_on_state_changed( pjsip_inv_session *inv, pjsip_event *e);

/*
 * Session callback
 * Called after SDP offer/answer session has completed.
 *
 * @param	inv	A pointer on a pjsip_inv_session structure
 * @param	status	A pj_status_t structure
 */
void call_on_media_update( pjsip_inv_session *inv UNUSED, pj_status_t status UNUSED);

/*
 * Called when the invote usage module has created a new dialog and invite
 * because of forked outgoing request.
 *
 * @param	inv	A pointer on a pjsip_inv_session structure
 * @param	e	A pointer on a pjsip_event structure
 */
void call_on_forked(pjsip_inv_session *inv, pjsip_event *e);

/*
 * Session callback
 * Called whenever any transactions within the session has changed their state.
 * Useful to monitor the progress of an outgoing request.
 *
 * @param	inv	A pointer on a pjsip_inv_session structure
 * @param	tsx	A pointer on a pjsip_transaction structure
 * @param	e	A pointer on a pjsip_event structure
 */
void call_on_tsx_changed(pjsip_inv_session *inv, pjsip_transaction *tsx, pjsip_event *e);

/*
 * Registration callback
 */
void regc_cb(struct pjsip_regc_cbparam *param);

/*
 * Called to handle incoming requests outside dialogs
 * @param   rdata
 * @return  pj_bool_t
 */
pj_bool_t mod_on_rx_request(pjsip_rx_data *rdata);

/*
 * Called to handle incoming response
 * @param	rdata
 * @return	pj_bool_t
 */
pj_bool_t mod_on_rx_response(pjsip_rx_data *rdata UNUSED) ;

/*
 * Transfer callbacks
 */
void xfer_func_cb( pjsip_evsub *sub, pjsip_event *event);
void xfer_svr_cb(pjsip_evsub *sub, pjsip_event *event);
void onCallTransfered(pjsip_inv_session *inv, pjsip_rx_data *rdata);

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

SIPVoIPLink* SIPVoIPLink::_instance = NULL;


    SIPVoIPLink::SIPVoIPLink(const AccountID& accountID)
    : VoIPLink(accountID)
      , _nbTryListenAddr(2) // number of times to try to start SIP listener
      , _stunServer("")
    , _localExternAddress("") 
    , _localExternPort(0)
    , _audiortp(new AudioRtp())
    ,_regPort(DEFAULT_SIP_PORT)
    , _useStun(false)
    , _clients(0)
{
    _debug("SIPVoIPLink::~SIPVoIPLink(): sipvoiplink constructor called \n");    

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

    /* Instanciate the C++ thread */
    _evThread = new EventThread(this);

    /* Start pjsip initialization step */
    init();
}

SIPVoIPLink::~SIPVoIPLink()
{
    _debug("SIPVoIPLink::~SIPVoIPLink(): sipvoiplink destructor called \n");
    terminate();
}

SIPVoIPLink* SIPVoIPLink::instance( const AccountID& id)
{

    if(!_instance ){
        _instance = new SIPVoIPLink( id );
    }

    return _instance;
}

void SIPVoIPLink::decrementClients (void)
{
    _clients--;
    if(_clients == 0){
        terminate();
        SIPVoIPLink::_instance=NULL;
    }
}

bool SIPVoIPLink::init()
{
    if(initDone())
        return false;
    /* Initialize the pjsip library */
    pjsip_init();
    initDone(true);

    return true;
}

    void 
SIPVoIPLink::terminate()
{
    delete _evThread; _evThread = NULL;

    /* Clean shutdown of pjsip library */
    if( initDone() )
    {
        pjsip_shutdown();
    }
    initDone(false);
}

    void
SIPVoIPLink::terminateSIPCall()
{
    _debug("SIPVoIPLink::terminateSIPCall(): function called \n");
    ost::MutexLock m(_callMapMutex);
    CallMap::iterator iter = _callMap.begin();
    SIPCall *call;
    while( iter != _callMap.end() ) {
        call = dynamic_cast<SIPCall*>(iter->second);
        if (call) {
            // terminate the sip call
      	    _debug("SIPVoIPLink::terminateSIPCall()::the call is deleted, should close recording file \n");
            delete call; call = 0;
        }
        iter++;
    }
    _callMap.clear();
}

    void
SIPVoIPLink::terminateOneCall(const CallID& id)
{
    _debug("SIPVoIPLink::terminateOneCall(): function called \n");
  
    SIPCall *call;
    
    call = getSIPCall(id);
    if (call) {
    // terminate the sip call
        _debug("SIPVoIPLink::terminateOneCall()::the call is deleted, should close recording file \n");
        delete call; call = 0;
    }
}



    void
SIPVoIPLink::getEvent()
{
    // We have to register the external thread so it could access the pjsip framework
    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);
}

int SIPVoIPLink::sendRegister( AccountID id )
{
    pj_status_t status;
    int expire_value;
    char contactTmp[256];
    pj_str_t svr, aor, contact;
    pjsip_tx_data *tdata;
    std::string tmp, hostname, username, password;
    SIPAccount *account;
    pjsip_regc *regc;

    account = dynamic_cast<SIPAccount *> (Manager::instance().getAccount(id));
    hostname = account->getHostname();
    username = account->getUsername();
    password = account->getPassword();

    _mutexSIP.enterMutex(); 

    /* Get the client registration information for this particular account */
    regc = account->getRegistrationInfo();
    /* If the registration already exists, delete it */
    if(regc) {
        status = pjsip_regc_destroy(regc);
        regc = NULL;
        PJ_ASSERT_RETURN( status == PJ_SUCCESS, 1 );
    }

    account->setRegister(true);

    /* Set the expire value of the message from the config file */
    expire_value = Manager::instance().getRegistrationExpireValue();

    /* Update the state of the voip link */
    account->setRegistrationState(Trying);

    if (!validStunServer) {
        account->setRegistrationState(ErrorExistStun);
        account->setRegister(false);
        _mutexSIP.leaveMutex(); 
        return false;
    }

    /* Create the registration according to the account ID */
    status = pjsip_regc_create(_endpt, (void*)account, &regc_cb, &regc);
    if (status != PJ_SUCCESS) {
        _debug("UserAgent: Unable to create regc.\n");
        _mutexSIP.leaveMutex(); 
        return false;
    }

    tmp = "sip:" + hostname;
    pj_strdup2(_pool, &svr, tmp.data());

    tmp = "<sip:" + username + "@" + hostname + ">";
    pj_strdup2(_pool, &aor, tmp.data());

    sprintf(contactTmp, "<sip:%s@%s:%d>", username.data(), _localExternAddress.data(), _localExternPort);
    pj_strdup2(_pool, &contact, contactTmp);
    account->setContact(contactTmp);

    status = pjsip_regc_init(regc, &svr, &aor, &aor, 1, &contact, 600); //timeout);
    if (status != PJ_SUCCESS) {
        _debug("UserAgent: Unable to initialize regc. %d\n", status); //, regc->str_srv_url.ptr);
        _mutexSIP.leaveMutex(); 
        return false;
    }

    pjsip_cred_info *cred = account->getCredInfo();

    if(!cred)
        cred = new pjsip_cred_info();

    pj_bzero(cred, sizeof (pjsip_cred_info));
    pj_strdup2(_pool, &cred->username, username.data());
    cred->data_type = PJSIP_CRED_DATA_PLAIN_PASSWD;
    pj_strdup2(_pool, &cred->data, password.data());
    pj_strdup2(_pool, &cred->realm, "*");
    pj_strdup2(_pool, &cred->scheme, "digest");
    pjsip_regc_set_credentials(regc, 1, cred);

    account->setCredInfo(cred);

    status = pjsip_regc_register(regc, PJ_TRUE, &tdata);
    if (status != PJ_SUCCESS) {
        _debug("UserAgent: Unable to register regc.\n");
        _mutexSIP.leaveMutex(); 
        return false;
    }

    status = pjsip_regc_send(regc, tdata);
    if (status != PJ_SUCCESS) {
        _debug("UserAgent: Unable to send regc request.\n");
        _mutexSIP.leaveMutex(); 
        return false;
    }

    _mutexSIP.leaveMutex(); 

    account->setRegistrationInfo(regc);

    return true;
}

    int 
SIPVoIPLink::sendUnregister( AccountID id )
{
    pj_status_t status = 0;
    pjsip_tx_data *tdata = NULL;
    SIPAccount *account;
    pjsip_regc *regc;

    account = dynamic_cast<SIPAccount *> (Manager::instance().getAccount(id));
    regc = account->getRegistrationInfo();

    if(!account->isRegister()){
        account->setRegistrationState(Unregistered); 
        return true;
    }

    if(regc) {
        status = pjsip_regc_unregister(regc, &tdata);
        if(status != PJ_SUCCESS) {
            _debug("UserAgent: Unable to unregister regc.\n");
            return false;
        }

        status = pjsip_regc_send( regc, tdata );
        if(status != PJ_SUCCESS) {
            _debug("UserAgent: Unable to send regc request.\n");
            return false;
        }
    } else {
        _debug("UserAgent: regc is null!\n");
        return false;
    }

    account->setRegistrationInfo(regc);
    account->setRegister(false);

    return true;
}

Call* 
SIPVoIPLink::newOutgoingCall(const CallID& id, const std::string& toUrl)
{
    Account* account;

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

    if (call) {
        account = dynamic_cast<SIPAccount *>(Manager::instance().getAccount(Manager::instance().getAccountFromCall(id)));
        if(!account)
        {
            _debug("Error retrieving the account to the make the call with\n");
            call->setConnectionState(Call::Disconnected);
            call->setState(Call::Error);
            delete call; call=0;
            return call;
        }
        //call->setPeerNumber(toUrl);
        call->setPeerNumber(getSipTo(toUrl, account->getHostname()));
        _debug("Try to make a call to: %s with call ID: %s\n", toUrl.data(), id.data());
        // we have to add the codec before using it in SIPOutgoingInvite...
        call->setCodecMap(Manager::instance().getCodecDescriptorMap());
        if ( SIPOutgoingInvite(call) ) {
            call->setConnectionState(Call::Progressing);
            call->setState(Call::Active);
            addCall(call);
        } else {
            delete call; call = 0;
        }
    }
    return call;
}

    bool
SIPVoIPLink::answer(const CallID& id)
{

    int i;
    SIPCall *call;
    pj_status_t status;
    pjsip_tx_data *tdata;

    _debug("- SIP Action: start answering\n");

    call = getSIPCall(id);

    if (call==0) {
        _debug("! SIP Failure: SIPCall doesn't exists\n");
        return false;
    }

    // User answered the incoming call, tell peer this news
    if (call->startNegociation(_pool)) {
        // Create and send a 200(OK) response
        _debug("UserAgent: Negociation success!\n");
        status = pjsip_inv_answer(call->getInvSession(), PJSIP_SC_OK, NULL, NULL, &tdata);
        PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);
        status = pjsip_inv_send_msg(call->getInvSession(), tdata);
        PJ_ASSERT_RETURN(status == PJ_SUCCESS, 1);

        _debug("* SIP Info: Starting AudioRTP when answering\n");
        if (_audiortp->createNewSession(call) >= 0) {
            call->setAudioStart(true);
            call->setConnectionState(Call::Connected);
            call->setState(Call::Active);
            return true;
        } else {
            _debug("! SIP Failure: Unable to start sound when answering %s/%d\n", __FILE__, __LINE__);
        }
    }
    terminateOneCall(call->getCallId());
    removeCall(call->getCallId());
    return false;
}

    bool
SIPVoIPLink::hangup(const CallID& id)
{
    pj_status_t status;
    pjsip_tx_data *tdata = NULL;
    SIPCall* call;

    call = getSIPCall(id);

    if (call==0) { _debug("! SIP Error: Call doesn't exist\n"); return false; }  

    // User hangup current call. Notify peer
    status = pjsip_inv_end_session(call->getInvSession(), 404, NULL, &tdata);
    if(status != PJ_SUCCESS)
        return false;

    if(tdata == NULL)
        return true;

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

    call->getInvSession()->mod_data[getModId()] = NULL;
    

    // Release RTP thread
    if (Manager::instance().isCurrentCall(id)) {
        _debug("* SIP Info: Stopping AudioRTP for hangup\n");
        _audiortp->closeRtpSession();
    }
 
    terminateOneCall(id);
    removeCall(id);

    return true;
}

    bool
SIPVoIPLink::cancel(const CallID& id)
{
    SIPCall* call = getSIPCall(id);
    if (call==0) { _debug("! SIP Error: Call doesn't exist\n"); return false; }  

    _debug("- SIP Action: Cancel call %s [cid: %3d]\n", id.data(), call->getCid()); 

    terminateOneCall(id);
    removeCall(id);

    return true;
}

    bool
SIPVoIPLink::onhold(const CallID& id)
{

    pj_status_t status;
    pjsip_tx_data *tdata;
    pjmedia_sdp_attr *attr;
    pjmedia_sdp_session* local_sdp;
    SIPCall* call;

    call = getSIPCall(id);

    if (call==0) { _debug("! SIP Error: call doesn't exist\n"); return false; }  


    // Stop sound
    call->setAudioStart(false);
    call->setState(Call::Hold);
    _debug("* SIP Info: Stopping AudioRTP for onhold action\n");
    //_mutexSIP.enterMutex();
        _audiortp->closeRtpSession();
    //_mutexSIP.leaveMutex();
    
    local_sdp = call->getLocalSDPSession();

    if( local_sdp == NULL ){
        _debug("! SIP Failure: unable to find local_sdp\n");
        return false;
    }

    /* Create re-INVITE with new offer */
    // Remove all the attributes with the specified name
    pjmedia_sdp_media_remove_all_attr(local_sdp->media[0], "sendrecv");
    attr = pjmedia_sdp_attr_create(_pool, "sendonly", NULL);
    pjmedia_sdp_media_add_attr(local_sdp->media[0], attr);

    status = pjsip_inv_reinvite( call->getInvSession(), NULL, local_sdp, &tdata);
    if( status != PJ_SUCCESS )
    {
        _debug("On hold: creation of the Re-invite request failed\n");
        return false;
    }
    /* Send the request */
    status = pjsip_inv_send_msg( call->getInvSession(), tdata);

    return (status == PJ_SUCCESS);
}

    bool 
SIPVoIPLink::offhold(const CallID& id)
{
    SIPCall *call;
    pj_status_t status;
    pjsip_tx_data *tdata;
    pjmedia_sdp_attr *attr;
    pjmedia_sdp_session* local_sdp;

    call = getSIPCall(id);

    if (call==0) { 
        _debug("! SIP Error: Call doesn't exist\n"); 
        return false; 
    }

    local_sdp = call->getLocalSDPSession();
    if( local_sdp == NULL ){
        _debug("! SIP Failure: unable to find local_sdp\n");
        return false;
    }

    /* Create re-INVITE with new offer */
    // Remove all the attributes with the specified name
    pjmedia_sdp_media_remove_all_attr(local_sdp->media[0], "sendonly");
    attr = pjmedia_sdp_attr_create(_pool, "sendrecv", NULL);
    pjmedia_sdp_media_add_attr(local_sdp->media[0], attr);

    status = pjsip_inv_reinvite( call->getInvSession(), NULL, local_sdp , &tdata);
    if( status != PJ_SUCCESS )
    {
        _debug("Off hold: creation of the Re-invite request failed\n");
        return false;
    }

    /* Send the request */
    status = pjsip_inv_send_msg( call->getInvSession(), tdata);
    if( status != PJ_SUCCESS )
        return false;

    // Enable audio
    _debug("* SIP Info: Starting AudioRTP when offhold\n");
    call->setState(Call::Active);
    // it's sure that this is the current call id...
    if (_audiortp->createNewSession(call) < 0) {
        _debug("! SIP Failure: Unable to start sound (%s:%d)\n", __FILE__, __LINE__);
        return false;
    }

    return true;
}

    bool 
SIPVoIPLink::transfer(const CallID& id, const std::string& to)
{
    SIPCall *call;
    std::string tmp_to;
    pjsip_evsub *sub;
    pjsip_tx_data *tdata;
    struct pjsip_evsub_user xfer_cb;
    pj_status_t status;
    pj_str_t dest;
    AccountID account_id;
    Account* account;


    call = getSIPCall(id);
    call->stopRecording();
    account_id = Manager::instance().getAccountFromCall(id);
    account = dynamic_cast<SIPAccount *>(Manager::instance().getAccount(account_id));

    if (call==0) { 
        _debug("! SIP Failure: Call doesn't exist\n"); 
        return false; 
    }  

    tmp_to = SIPToHeader(to);
    if (tmp_to.find("@") == std::string::npos) {
        tmp_to = tmp_to + "@" + account->getHostname();
    }

    _debug("In transfer, tmp_to is %s\n", tmp_to.data());

    pj_strdup2(_pool, &dest, to.data());

    /* Create xfer client subscription. */
    pj_bzero(&xfer_cb, sizeof(xfer_cb));
    xfer_cb.on_evsub_state = &xfer_func_cb;

    status = pjsip_xfer_create_uac(call->getInvSession()->dlg, &xfer_cb, &sub);
    if (status != PJ_SUCCESS) {
        _debug("UserAgent: Unable to create xfer -- %d\n", status);
        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 not find the cooresponding
     * voiplink from the call any more. But the voiplink is useful!
     */
    AccountID accId = Manager::instance().getAccountFromCall(call->getCallId());
    pjsip_evsub_set_mod_data(sub, getModId(), this);

    /*
     * Create REFER request.
     */
    status = pjsip_xfer_initiate(sub, &dest, &tdata);
    if (status != PJ_SUCCESS) {
        _debug("UserAgent: Unable to create REFER request -- %d\n", status);
        return false;
    }

    /* Send. */
    status = pjsip_xfer_send_request(sub, tdata);
    if (status != PJ_SUCCESS) {
        _debug("UserAgent: Unable to send REFER request -- %d\n", status);
        return false;
    }

    return true;
}

bool SIPVoIPLink::transferStep2()
{
    _audiortp->closeRtpSession();
    return true;
}

    bool
SIPVoIPLink::refuse (const CallID& id)
{
    SIPCall *call;
    pj_status_t status;
    pjsip_tx_data *tdata;

    _debug("SIPVoIPLink::refuse() : teh call is refused \n");
    call = getSIPCall(id);

    if (call==0) { 
        _debug("Call doesn't exist\n"); 
        return false; 
    }  

    // can't refuse outgoing call or connected
    if (!call->isIncoming() || call->getConnectionState() == Call::Connected) { 
        _debug("It's not an incoming call, or it's already answered\n");
        return false; 
    }

    // User refuse current call. Notify peer
    status = pjsip_inv_end_session(call->getInvSession(), PJSIP_SC_DECLINE, NULL, &tdata); //603
    if(status != PJ_SUCCESS)
        return false;

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

    call->getInvSession()->mod_data[getModId()] = NULL;

    terminateOneCall(id);
    return true;
}

void 
SIPVoIPLink::setRecording(const CallID& id)
{
  //SIPCall *call;
  //call = getSIPCall(id);
  
  //call->setRecording();

  _audiortp->setRecording();
}

bool
SIPVoIPLink::isRecording(const CallID& id)
{
  SIPCall *call;
  call = getSIPCall(id);
  
  return call->isRecording();
}

    bool 
SIPVoIPLink::carryingDTMFdigits(const CallID& id, char code)
{

    SIPCall *call;
    int duration;
    const int body_len = 1000;
    char *dtmf_body;
    pj_status_t status;
    pjsip_tx_data *tdata;
    pj_str_t methodName, content;
    pjsip_method method;
    pjsip_media_type ctype;

    call = getSIPCall(id);

    if (call==0) { 
        _debug("Call doesn't exist\n"); 
        return false; 
    }

    duration = Manager::instance().getConfigInt(SIGNALISATION, PULSE_LENGTH);
    dtmf_body = new char[body_len];

    snprintf(dtmf_body, body_len - 1, "Signal=%c\r\nDuration=%d\r\n", code, duration);

    pj_strdup2(_pool, &methodName, "INFO");
    pjsip_method_init_np(&method, &methodName);

    /* Create request message. */
    status = pjsip_dlg_create_request( call->getInvSession()->dlg, &method, -1, &tdata);
    if (status != PJ_SUCCESS) {
        _debug("UserAgent: Unable to create INFO request -- %d\n", status);
        return false;
    }

    /* Get MIME type */
    pj_strdup2(_pool, &ctype.type, "application");
    pj_strdup2(_pool, &ctype.subtype, "dtmf-relay");

    /* Create "application/dtmf-relay" message body. */
    pj_strdup2(_pool, &content, dtmf_body);
    tdata->msg->body = pjsip_msg_body_create( tdata->pool, &ctype.type, &ctype.subtype, &content);
    if (tdata->msg->body == NULL) {
        _debug("UserAgent: Unable to create msg body!\n");
        pjsip_tx_data_dec_ref(tdata);
        return false;
    }

    /* Send the request. */
    status = pjsip_dlg_send_request( call->getInvSession()->dlg, tdata, getModId(), NULL);
    if (status != PJ_SUCCESS) {
        _debug("UserAgent: Unable to send MESSAGE request -- %d\n", status);
        return false;
    }

    return true;
}

    bool
SIPVoIPLink::SIPOutgoingInvite(SIPCall* call) 
{
    // If no SIP proxy setting for direct call with only IP address
    if (!SIPStartCall(call, "")) {
        _debug("! SIP Failure: call not started\n");
        return false;
    }
    return true;
}

    bool
SIPVoIPLink::SIPStartCall(SIPCall* call, const std::string& subject UNUSED) 
{
    std::string strTo, strFrom;
    pj_status_t status;
    pjsip_dialog *dialog;
    pjsip_tx_data *tdata;
    pj_str_t from, to, contact;
    AccountID id;
    SIPAccount *account;

    if (!call) 
        return false;

    id = Manager::instance().getAccountFromCall(call->getCallId());
    // Get the basic information about the callee account
    account = dynamic_cast<SIPAccount *>(Manager::instance().getAccount(id));

    strTo = getSipTo(call->getPeerNumber(), account->getHostname());
    _debug("            To: %s\n", strTo.data());

    // Generate the from URI
    strFrom = "sip:" + account->getUsername() + "@" + account->getHostname();

    // pjsip need the from and to information in pj_str_t format
    pj_strdup2(_pool, &from, strFrom.data());
    pj_strdup2(_pool, &to, strTo.data());
    pj_strdup2(_pool, &contact, account->getContact().data());

    // create the dialog (UAC)
    status = pjsip_dlg_create_uac(pjsip_ua_instance(), &from,
            &contact,
            &to,
            NULL,
            &dialog);
    PJ_ASSERT_RETURN(status == PJ_SUCCESS, false);

    setCallAudioLocal(call, getLocalIPAddress(), useStun(), getStunServer());
    call->setIp(getLocalIP());

    // Building the local SDP offer
    call->createInitialOffer(_pool);

    // Create the invite session for this call
    pjsip_inv_session *inv;
    status = pjsip_inv_create_uac(dialog, call->getLocalSDPSession(), 0, &inv);
    PJ_ASSERT_RETURN(status == PJ_SUCCESS, false);

    // Set auth information
    pjsip_auth_clt_set_credentials(&dialog->auth_sess, 1, account->getCredInfo());

    // Associate current call in the invite session
    inv->mod_data[getModId()] = call;

    status = pjsip_inv_invite(inv, &tdata);
    PJ_ASSERT_RETURN(status == PJ_SUCCESS, false);

    // Associate current invite session in the call
    call->setInvSession(inv);

    status = pjsip_inv_send_msg(inv, tdata);
    if(status != PJ_SUCCESS) {
        return false;
    }

    return true;
}

std::string SIPVoIPLink::getSipTo(const std::string& to_url, std::string hostname) {
    // Form the From header field basis on configuration panel
    //bool isRegistered = (_eXosipRegID == EXOSIP_ERROR_STD) ? false : true;

    // add a @host if we are registered and there is no one inside the url
    if (to_url.find("@") == std::string::npos) {// && isRegistered) {
        if(!hostname.empty()) {
            return SIPToHeader(to_url + "@" + hostname);
        }
    }
    return SIPToHeader(to_url);
    }

    std::string SIPVoIPLink::SIPToHeader(const std::string& to) 
    {
        if (to.find("sip:") == std::string::npos) {
            return ("sip:" + to );
        } else {
            return to;
        }
    }

    bool
        SIPVoIPLink::SIPCheckUrl(const std::string& url UNUSED)
        {
            return true;
        }

    bool setCallAudioLocal(SIPCall* call, std::string localIP, bool stun, std::string server) 
    {
        // Setting Audio
        unsigned int callLocalAudioPort = RANDOM_LOCAL_PORT;
        unsigned int callLocalExternAudioPort = callLocalAudioPort;
        if (stun) {
            // If use Stun server
            if (Manager::instance().behindNat(server, callLocalAudioPort)) {
                callLocalExternAudioPort = Manager::instance().getFirewallPort();
            }
        }
        _debug("            Setting local audio port to: %d\n", callLocalAudioPort);
        _debug("            Setting local audio port (external) to: %d\n", callLocalExternAudioPort);

        // Set local audio port for SIPCall(id)
        call->setLocalIp(localIP);
        call->setLocalAudioPort(callLocalAudioPort);
        call->setLocalExternAudioPort(callLocalExternAudioPort);

        return true;
    }

void
SIPVoIPLink::SIPCallServerFailure(SIPCall *call) 
{
    //if (!event->response) { return; }
    //switch(event->response->status_code) {
    //case SIP_SERVICE_UNAVAILABLE: // 500
    //case SIP_BUSY_EVRYWHERE:     // 600
    //case SIP_DECLINE:             // 603
    //SIPCall* call = findSIPCallWithCid(event->cid);
    if (call != 0) {
        _debug("Server error!\n");
        CallID id = call->getCallId();
        Manager::instance().callFailure(id);
        terminateOneCall(id);
        removeCall(id);
    }
    //break;
    //}
}

void
SIPVoIPLink::SIPCallClosed(SIPCall *call) 
{

    _debug("SIPVoIPLink::SIPCallClosed():: function called when peer hangup");
    // it was without did before
    //SIPCall* call = findSIPCallWithCid(event->cid);
    if (!call) { return; }

    CallID id = call->getCallId();
    //call->setDid(event->did);
    if (Manager::instance().isCurrentCall(id)) {
        call->setAudioStart(false);
        _debug("* SIP Info: Stopping AudioRTP when closing\n");
        _audiortp->closeRtpSession();
    }
    _debug("After close RTP\n");
    Manager::instance().peerHungupCall(id);
    terminateOneCall(id);
    removeCall(id);
    _debug("After remove call ID\n");
}

void
SIPVoIPLink::SIPCallReleased(SIPCall *call)
{
    // do cleanup if exists
    // only cid because did is always 0 in these case..
    //SIPCall* call = findSIPCallWithCid(event->cid);
    if (!call) { return; }