sipvoiplink.cpp

/*
 *  Copyright (C) 2004-2006 Savoir-Faire Linux inc.
 *  Author: Yan Morin <yan.morin@savoirfairelinux.com>
 *  Author : Laurielle Lea <laurielle.lea@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.
 */
/*
 * YM: 2006-11-15: changes unsigned int to std::string::size_type, thanks to Pierre Pomes (AMD64 compilation)
 */
#include "sipvoiplink.h"
#include "eventthread.h"
#include "sipcall.h"
#include <sstream> // for ostringstream
#include "sipaccount.h"

#include "manager.h"
#include "user_cfg.h" // SIGNALISATION / PULSE #define

// for listener
#define DEFAULT_SIP_PORT  5060
#define RANDOM_SIP_PORT   rand() % 64000 + 1024
#define RANDOM_LOCAL_PORT ((rand() % 27250) + 5250)*2

#define EXOSIP_ERROR_NO   0
#define EXOSIP_ERROR_STD -1
#define EXOSIP_ERROR_BUILDING -2

// for registration
#define EXPIRES_VALUE 180

// 1XX responses
#define DIALOG_ESTABLISHED 101
// see: osip_const.h

// FOR VOICE Message handling
#define VOICE_MSG     "Voice-Message"
#define LENGTH_VOICE_MSG  15

// need for hold/unhold
#define INVITE_METHOD "INVITE"


SIPVoIPLink::SIPVoIPLink(const AccountID& accountID)
 : VoIPLink(accountID), _localExternAddress("")
{
  _evThread = new EventThread(this);
  _initDone = false;

  _nMsgVoicemail = 0;
  _eXosipRegID = EXOSIP_ERROR_STD;

  _nbTryListenAddr = 2; // number of times to try to start SIP listener
  _localExternPort = 0;

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

SIPVoIPLink::~SIPVoIPLink()
{
  terminate();
  delete _evThread; _evThread = 0;
}

bool 
SIPVoIPLink::init()
{
  _debug("INIT DONE : %d\n" , _initDone);
  if (!_initDone) {
    if (0 != eXosip_init()) {
      _debug("! SIP Failure: Could not initialize eXosip\n");
      return false;
    }

    // Pour éviter qu'on refasse l'init sans avoir considéré l'erreur,
    // s'il y en a une ?
    _initDone = true;
  
    // check networking capabilities
    if ( !checkNetwork() ) {
      _debug("! SIP FAILURE: Unable to determine network capabilities\n");
      return false;
    }
  
    // if we useStun and we failed to receive something on port 5060, we try a random port
    // If use STUN server, firewall address setup
    int errExosip = 0;
    int port = DEFAULT_SIP_PORT;
  
    int iTry = 1;  // try number..
  
    do {
      if (_useStun && !Manager::instance().behindNat(_stunServer, port)) { 
        port = RANDOM_SIP_PORT; 
        if (!Manager::instance().behindNat(_stunServer, port)) {
         _debug("! SIP Failure: Unable to check NAT setting\n");
          return false; // hoho we can't use the random sip port too...
        }
      }
  
      // second parameter, NULL is "::" for ipv6 and "0.0.0.0" for ipv4, we can put INADDR_ANY
      errExosip = eXosip_listen_addr(IPPROTO_UDP, INADDR_ANY, port, AF_INET, 0);
      if (errExosip != 0) {
        _debug("* SIP Info: [%d/%d] could not initialize SIP listener on port %d\n", iTry, _nbTryListenAddr, port);
        port = RANDOM_SIP_PORT;
      }
    } while ( errExosip != 0 && iTry < _nbTryListenAddr );
  
    if ( errExosip != 0 ) { // we didn't succeeded
      _debug("! SIP Failure: SIP failed to listen on port %d\n", port);
      return false;
    }
    _localPort = port;
    _debug("  SIP Init: listening on port %d\n", port);
    
    if (_useStun) {
      // This method is used to replace contact address with the public address of your NAT
      // it should be call after eXosip_listen_addr
      // set by last behindNat() call (ish)...
      _localExternAddress  = Manager::instance().getFirewallAddress();
      _localExternPort     = Manager::instance().getFirewallPort();
      eXosip_masquerade_contact(_localExternAddress.data(), _localExternPort);
    } else {
      _localExternAddress = _localIPAddress;
      _localExternPort    = _localPort;
    }
    
    // Set user agent
    std::string tmp = std::string(PROGNAME_GLOBAL) + "/" + std::string(SFLPHONED_VERSION);
    eXosip_set_user_agent(tmp.data());
  
    _debug("  SIP Init: starting loop thread (SIP events)\n");
    _evThread->start();
  }

  _initDone = true;

  // Useless
  return true;
}

void 
SIPVoIPLink::terminate()
{
  _debug("Terminate before\n");
  terminateSIPCall(); 
  _debug("Terminate after\n");
  if (_initDone) {
    // TODO The next line makes the daemon crash on 
    // account delete if at least one account is registered.
    // It should called only when the last account 
    // is deleted/unregistered.
    // eXosip_quit();
    _initDone = false;
  }
}

void
SIPVoIPLink::terminateSIPCall()
{
  
  ost::MutexLock m(_callMapMutex);
  CallMap::iterator iter = _callMap.begin();
  SIPCall *call;
  while( iter != _callMap.end() ) {
    call = dynamic_cast<SIPCall*>(iter->second);
    if (call) {
      // Release SIP stack.
      eXosip_lock();
      eXosip_call_terminate(call->getCid(), call->getDid() );
      eXosip_unlock();
      delete call; call = 0;
    }
    iter++;
  }
  _callMap.clear();
}

bool
SIPVoIPLink::checkNetwork()
{
  // Set IP address
  return loadSIPLocalIP();
}

bool
SIPVoIPLink::loadSIPLocalIP() 
{
  bool returnValue = true;
  if (_localIPAddress == "127.0.0.1") {
    char* myIPAddress = new char[65];
    if (eXosip_guess_localip(AF_INET, myIPAddress, 64) == EXOSIP_ERROR_STD) {
      returnValue = false;
    } else {
      _localIPAddress = std::string(myIPAddress);
      _debug("  SIP Info: Checking network, setting local IP address to: %s\n", myIPAddress);
    }
    delete [] myIPAddress; myIPAddress = NULL;
  }
  return returnValue;
}

void
SIPVoIPLink::getEvent()
{
	char* tmp2;
	const char* localport = ""+_localPort;
	eXosip_event_t* event = eXosip_event_wait(0, 50);
	eXosip_lock();
	eXosip_automatic_action();
	eXosip_unlock();

	if ( event == NULL ) {
		return;
	}
      
	switch (event->type) {
	/* REGISTER related events */
	case EXOSIP_REGISTRATION_NEW:         /** 00 < announce new registration.       */
		_debugMid(" !EXOSIP_REGISTRATION_NEW event is not implemented\n");
		break;
	case EXOSIP_REGISTRATION_SUCCESS:     /** 01 < user is successfully registred.  */
		_debugMid(" !EXOSIP_REGISTRATION_SUCCESS \n");
		if(_eXosipRegID == EXOSIP_ERROR_STD){
		  _debug("Successfully Unregister account ID = %s\n" , getAccountID().c_str());
		  setRegistrationState(Unregistered);
		  if( _evThread ) _evThread->stop();
		}
		else{
		  _debug("Successfully Register account ID = %s\n" , getAccountID().c_str());
		  setRegistrationState(Registered);
		}
		break;
	case EXOSIP_REGISTRATION_FAILURE:     /** 02 < user is not registred.           */
		setRegistrationState(Error, "SIP registration failure.");
		_debugMid(" !EXOSIP_REGISTRATION_FAILURE\n");
		break;
	case EXOSIP_REGISTRATION_REFRESHED:   /** 03 < registration has been refreshed. */
		_debugMid(" !EXOSIP_REGISTRATION_REFRESHED event is not implemented\n");
		break;
	case EXOSIP_REGISTRATION_TERMINATED:  /** 04 < UA is not registred any more.    */
		setRegistrationState(Unregistered, "Registration terminated by remote host");
		_debugMid(" !EXOSIP_REGISTRATION_TERMINATED event is not implemented\n");
		break;

	/* INVITE related events within calls */
	case EXOSIP_CALL_INVITE:          /** 05 < announce a new call                   */
		_debugMid(" !EXOSIP_CALL_INVITE\n");
		SIPCallInvite(event);
		break;
	case EXOSIP_CALL_REINVITE:        /** 06 < announce a new INVITE within call     */
		SIPCallReinvite(event);
		_debugMid(" !EXOSIP_REGISTRATION_TERMINATED event is not implemented\n");
		break;

	/* CALL related events */
	case EXOSIP_CALL_NOANSWER:        /** 07 < announce no answer within the timeout */
		_debugMid(" !EXOSIP_CALL_NOANSWER event is not implemented\n");
		break;
	case EXOSIP_CALL_PROCEEDING:      /** 08 < announce processing by a remote app   */
		_debugMid(" !EXOSIP_CALL_PROCEEDING event is not implemented\n");
		break;
	case EXOSIP_CALL_RINGING:         /** 09 < announce ringback                     */
		_debugMid(" !EXOSIP_CALL_RINGING\n");
		SIPCallRinging(event);
		break;
	case EXOSIP_CALL_ANSWERED:        /** 10 < announce start of call                */
		_debugMid(" !EXOSIP_CALL_ANSWERED\n");
		SIPCallAnswered(event);
		break;
	case EXOSIP_CALL_REDIRECTED:      /** 11 < announce a redirection                */
		_debugMid(" !EXOSIP_CALL_REDIRECTED event is not implemented\n");
		break;
	case EXOSIP_CALL_REQUESTFAILURE:  /** 12 < announce a request failure            */
		_debugMid(" !EXOSIP_CALL_REQUESTFAILURE");
		SIPCallRequestFailure(event);
		break;
	case EXOSIP_CALL_SERVERFAILURE:   /** 13 < announce a server failure             */
		_debugMid(" !EXOSIP_CALL_SERVERFAILURE");
		SIPCallServerFailure(event);
		break;
	case EXOSIP_CALL_GLOBALFAILURE:   /** 14 < announce a global failure             */
		_debugMid(" !EXOSIP_CALL_GLOBALFAILURE\n");
		SIPCallServerFailure(event);
		break;
	case EXOSIP_CALL_ACK:             /** 15 < ACK received for 200ok to INVITE      */
		_debugMid(" !EXOSIP_CALL_ACK\n");
		SIPCallAck(event);
		break;
	case EXOSIP_CALL_CANCELLED:       /** 16 < announce that call has been cancelled */
		_debugMid(" !EXOSIP_CALL_CANCELLED\n");
		break;
	case EXOSIP_CALL_TIMEOUT:         /** 17 < announce that call has failed         */
		_debugMid(" !EXOSIP_CALL_TIMEOUT\n");
		Manager::instance().displayError(" !EXOSIP Call Error not implemented yet");
		break;

	/* Request related events within calls (except INVITE) */
	case EXOSIP_CALL_MESSAGE_NEW:            /** 18 < announce new incoming MESSAGE. */
		_debugMid(" !EXOSIP_CALL_MESSAGE_NEW\n");
		SIPCallMessageNew(event);
		break;
	case EXOSIP_CALL_MESSAGE_PROCEEDING:     /** 19 < announce a 1xx for MESSAGE. */
		_debugMid(" !EXOSIP_CALL_MESSAGE_PROCEEDING\n");
		break;
	case EXOSIP_CALL_MESSAGE_ANSWERED:       /** 20 < announce a 200ok  */
		// 200 OK
		_debugMid(" !EXOSIP_CALL_MESSAGE_ANSWERED\n");
		break;
	case EXOSIP_CALL_MESSAGE_REDIRECTED:     /** 21 < announce a failure. */
		_debugMid(" !EXOSIP_CALL_MESSAGE_REDIRECTED\n");
		break;
	case EXOSIP_CALL_MESSAGE_REQUESTFAILURE: /** 22 < announce a failure. */
		_debugMid(" !EXOSIP_CALL_MESSAGE_REQUESTFAILURE\n");
		break;
	case EXOSIP_CALL_MESSAGE_SERVERFAILURE:  /** 23 < announce a failure. */
		_debugMid(" !EXOSIP_CALL_MESSAGE_SERVERFAILURE\n");
		break;
	case EXOSIP_CALL_MESSAGE_GLOBALFAILURE:  /** 24 < announce a failure. */
		_debugMid(" !EXOSIP_CALL_MESSAGE_GLOBALFAILURE\n");
		Manager::instance().displayError(" !EXOSIP Call Message not implemented yet");
		break;

	case EXOSIP_CALL_CLOSED:          /** 25 < a BYE was received for this call */
		_debugMid(" !EXOSIP_CALL_CLOSED\n");
		SIPCallClosed(event);
		break;

	/* For both UAS & UAC events */
	case EXOSIP_CALL_RELEASED:           /** 26 < call context is cleared. */
		_debugMid(" !EXOSIP_CALL_RELEASED\n");
		SIPCallReleased(event);
		break;

	/* Response received for request outside calls */
	case EXOSIP_MESSAGE_NEW:            /** 27 < announce new incoming MESSAGE. */
		_debugMid(" !EXOSIP_MESSAGE_NEW\n");
		if (event->request == NULL) { break; }
		SIPMessageNew(event);
		break;
	case EXOSIP_MESSAGE_PROCEEDING:     /** 28 < announce a 1xx for MESSAGE. */
		_debugMid(" !EXOSIP_MESSAGE_PROCEEDING\n");
		break;
	case EXOSIP_MESSAGE_ANSWERED:       /** 29 < announce a 200ok  */
		_debugMid(" !EXOSIP_MESSAGE_ANSWERED\n");
		break;
	case EXOSIP_MESSAGE_REDIRECTED:     /** 30 < announce a failure. */
		_debugMid(" !EXOSIP_MESSAGE_REDIRECTED\n");
		Manager::instance().displayError(" !EXOSIP Message not implemented yet");
		break;

	case EXOSIP_MESSAGE_REQUESTFAILURE: /** 31 < announce a failure. */
		_debugMid(" !EXOSIP_MESSAGE_REQUESTFAILURE\n");
		if (event->response !=0 && event->response->status_code == SIP_METHOD_NOT_ALLOWED) {
			Manager::instance().incomingMessage(getAccountID(), "Message are not allowed");
		} else {
			Manager::instance().displayError(" !EXOSIP_MESSAGE_REQUESTFAILURE not implemented yet");
		}
		break;
	case EXOSIP_MESSAGE_SERVERFAILURE:  /** 32 < announce a failure. */
		_debugMid(" !EXOSIP_MESSAGE_SERVERFAILURE\n");
		break;
	case EXOSIP_MESSAGE_GLOBALFAILURE:  /** 33 < announce a failure. */
		_debugMid(" !EXOSIP_MESSAGE_GLOBALFAILURE\n");
		Manager::instance().displayError(" !EXOSIP Message not implemented yet");
		break;

	/* Presence and Instant Messaging */
	case EXOSIP_SUBSCRIPTION_UPDATE:       /** 34 < announce incoming SUBSCRIBE.      */
		_debugMid(" !EXOSIP_SUBSCRIPTION_UPDATE\n");
		break;
	case EXOSIP_SUBSCRIPTION_CLOSED:       /** 35 < announce end of subscription.     */
		_debugMid(" !EXOSIP_SUBSCRIPTION_CLOSED\n");
		Manager::instance().displayError(" !EXOSIP Subscription not implemented yet");
		break;

	case EXOSIP_SUBSCRIPTION_NOANSWER:        /** 37 < announce no answer              */
		_debugMid(" !EXOSIP_SUBSCRIPTION_NOANSWER\n");
		break;
	case EXOSIP_SUBSCRIPTION_PROCEEDING:      /** 38 < announce a 1xx                  */
		_debugMid(" !EXOSIP_SUBSCRIPTION_PROCEEDING\n");
		Manager::instance().displayError(" !EXOSIP Subscription response not implemented yet");
		break;
	case EXOSIP_SUBSCRIPTION_ANSWERED:        /** 39 < announce a 200ok                */
		_debugMid(" !EXOSIP_SUBSCRIPTION_ANSWERED\n");
		eXosip_lock();
		eXosip_automatic_action();
		eXosip_unlock();
		break;

	case EXOSIP_SUBSCRIPTION_REDIRECTED:      /** 40 < announce a redirection          */
		_debugMid(" !EXOSIP_SUBSCRIPTION_REDIRECTED\n");
		break;
	case EXOSIP_SUBSCRIPTION_REQUESTFAILURE:  /** 41 < announce a request failure      */
		_debugMid(" !EXOSIP_SUBSCRIPTION_REQUESTFAILURE\n");
		break;
	case EXOSIP_SUBSCRIPTION_SERVERFAILURE:   /** 42 < announce a server failure       */
		_debugMid(" !EXOSIP_SUBSCRIPTION_REQUESTFAILURE\n");
		break;
	case EXOSIP_SUBSCRIPTION_GLOBALFAILURE:   /** 43 < announce a global failure       */
		_debugMid(" !EXOSIP_SUBSCRIPTION_GLOBALFAILURE\n");
		break;
	case EXOSIP_SUBSCRIPTION_NOTIFY:          /** 44 < announce new NOTIFY request     */
		_debugMid(" !EXOSIP_SUBSCRIPTION_NOTIFY\n");
		osip_body_t* body;
		osip_from_to_str(event->request->from, &tmp2);
		osip_message_get_body(event->request, 0, &body);
		if (body != NULL && body->body != NULL) {
//			printf("\n---------------------------------\n");
//			printf ("(%i) from: %s\n  %s\n", event->tid, tmp2, body->body);
//			printf("---------------------------------\n");
		}
		osip_free(tmp2);
		break;
	case EXOSIP_SUBSCRIPTION_RELEASED:        /** 45 < call context is cleared.        */
		_debugMid(" !EXOSIP_SUBSCRIPTION_RELEASED\n");
		Manager::instance().displayError(" !EXOSIP Subscription response not implemented yet.");
		break;

	case EXOSIP_IN_SUBSCRIPTION_NEW:          /** 46 < announce new incoming SUBSCRIBE.*/
		_debugMid(" !EXOSIP_IN_SUBSCRIPTION_NEW\n");
		break;
	case EXOSIP_IN_SUBSCRIPTION_RELEASED:     /** 47 < announce end of subscription.   */
		_debugMid(" !EXOSIP_IN_SUBSCRIPTION_RELEASED\n");
		Manager::instance().displayError(" !EXOSIP Subscription not implemented yet");
		break;

	case EXOSIP_EVENT_COUNT:               /** 48 < MAX number of events  */
		_debugMid(" !EXOSIP_EVENT_COUNT : SHOULD NEVER HAPPEN!!!!!\n");
		break;
	default:
		printf("received eXosip event (type, did, cid) = (%d, %d, %d)", event->type, event->did, event->cid);
		break;
	}
	eXosip_event_free(event);
}

bool
SIPVoIPLink::sendRegister()
{

  if (_eXosipRegID != EXOSIP_ERROR_STD) {
    Manager::instance().displayError("! SIP Error: Registration already sent. Try to unregister");
    return false;
  }

  std::string hostname = getHostName();
  if (hostname.empty()) {
    Manager::instance().displayConfigError("Fill host part field");
    return false;
  }

  if (_userpart.empty()) {
    Manager::instance().displayConfigError("Fill user part field");
    return false;
  }


  std::string proxy = "sip:" + _proxy;
  hostname = "sip:" + hostname;
  std::string from = SIPFromHeader(_userpart, getHostName());
  
  osip_message_t *reg = NULL;
  eXosip_lock();
  if (!_proxy.empty()) {
    _debug("* SIP Info: Register from: %s to %s\n", from.data(), proxy.data());
    _eXosipRegID = eXosip_register_build_initial_register(from.data(), 
                  proxy.data(), NULL, EXPIRES_VALUE, &reg);
  } else {
    _debug("* SIP Info: Register from: %s to %s\n", from.data(), hostname.data());
    _eXosipRegID = eXosip_register_build_initial_register(from.data(), 
                  hostname.data(), NULL, EXPIRES_VALUE, &reg);
  }
  eXosip_unlock();
  if (_eXosipRegID < EXOSIP_ERROR_NO ) {
    return false;
  }

  if (!sendSIPAuthentification()) {
    _debug("* SIP Info: register without authentication\n");
    return false;
  }

  osip_message_set_header (reg, "Event", "Registration");
  osip_message_set_header (reg, "Allow-Events", "presence");

  eXosip_lock();
  int eXosipErr = eXosip_register_send_register(_eXosipRegID, reg);
  if (eXosipErr == EXOSIP_ERROR_BUILDING) {
    _debug("! SIP Failure: Cannot build registration, check the setup\n"); 
    eXosip_unlock();
    return false;
  }
  if (eXosipErr == EXOSIP_ERROR_STD) {
    _debug("! SIP Failure: Registration sending failed\n");
    eXosip_unlock();
    return false;
  }

  setRegistrationState(Trying);
  eXosip_unlock();

  return true;
}

std::string
SIPVoIPLink::SIPFromHeader(const std::string& userpart, const std::string& hostpart) 
{
  return ("\"" + getFullName() + "\"" + " <sip:" + userpart + "@" + hostpart + ">");
}

std::string
SIPVoIPLink::SIPFromHeaderAlternate(const std::string& userpart, const std::string& hostpart) 
{
  return ("<sip:" + userpart + "@" + hostpart + ">");
}

bool
SIPVoIPLink::sendSIPAuthentification() 
{
  std::string login = _authname;
  if (login.empty()) {
    login = _userpart;
  }
  if (login.empty()) {
    /** @todo Ajouter ici un call à setRegistrationState(Error, "Fill balh") ? */
    Manager::instance().displayConfigError("Fill authentification name");
    return false;
  }
  if (_password.empty()) {
    /** @todo Même chose ici  ? */
    Manager::instance().displayConfigError("Fill password field");
    return false;
  }
  eXosip_lock();
  int returnValue = eXosip_add_authentication_info(login.data(), login.data(), _password.data(), NULL, NULL);
  eXosip_unlock();

  return (returnValue != EXOSIP_ERROR_STD ? true : false);
}

bool
SIPVoIPLink::sendUnregister()
{
  _debug("SEND UNREGISTER for account %s\n" , getAccountID().c_str());
  if ( _eXosipRegID == EXOSIP_ERROR_STD) return false;
  int eXosipErr = EXOSIP_ERROR_NO;
  osip_message_t *reg = NULL;

  eXosip_lock();
  eXosipErr = eXosip_register_build_register (_eXosipRegID, 0, &reg);
  eXosip_unlock();

  if (eXosipErr != EXOSIP_ERROR_NO) {
    _debug("! SIP Failure: Unable to build registration for sendUnregister");
    return false;
  }

  eXosip_lock();
  _debug("< Sending REGISTER (expire=0)\n");
  eXosipErr = eXosip_register_send_register (_eXosipRegID, reg);
  if (eXosipErr == EXOSIP_ERROR_BUILDING) {
    _debug("! SIP Failure: Cannot build registration (unregister), check the setup\n"); 
    eXosip_unlock();
    return false;
  }
  if (eXosipErr == EXOSIP_ERROR_STD) {
    _debug("! SIP Failure: Unable to send registration (unregister)\n");
  }
  _eXosipRegID = EXOSIP_ERROR_STD;
  eXosip_unlock();

  return true;
}

Call* 
SIPVoIPLink::newOutgoingCall(const CallID& id, const std::string& toUrl)
{
  SIPCall* call = new SIPCall(id, Call::Outgoing);
  if (call) {
    call->setPeerNumber(toUrl);
    // 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)
{
  _debug("- SIP Action: start answering\n");

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

  // Send 200 OK
  osip_message_t *answerMessage = NULL;
  eXosip_lock();
  int i = eXosip_call_build_answer(call->getTid(), SIP_OK, &answerMessage);
  if (i != 0) {
    _debug("< SIP Building Error: send 400 Bad Request\n");
    eXosip_call_send_answer (call->getTid(), SIP_BAD_REQUEST, NULL);
  } else {
    // use exosip, bug locked
    i = 0;
    sdp_message_t *remote_sdp = eXosip_get_remote_sdp(call->getDid());
    if (remote_sdp!=NULL) {
      i = call->sdp_complete_message(remote_sdp, answerMessage);
      if (i!=0) {
        osip_message_free(answerMessage);
      }
      sdp_message_free(remote_sdp);
    }
    if (i != 0) {
      _debug("< SIP Error: send 415 Unsupported Media Type\n");
      eXosip_call_send_answer (call->getTid(), SIP_UNSUPPORTED_MEDIA_TYPE, NULL);
    } else {
      _debug("< SIP send 200 OK\n");
      eXosip_call_send_answer (call->getTid(), SIP_OK, answerMessage);
    }
  }
  eXosip_unlock();

  if(i==0) {
    // Incoming call is answered, start the sound thread.
    _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__);
    }
  }
  removeCall(call->getCallId());
  return false;
}

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

  _debug("- SIP Action: Hang up call %s [cd: %3d %3d]\n", id.data(), call->getCid(), call->getDid()); 
  // Release SIP stack.
  eXosip_lock();
  eXosip_call_terminate(call->getCid(), call->getDid());
  eXosip_unlock();

  // Release RTP thread
  if (Manager::instance().isCurrentCall(id)) {
    _debug("* SIP Info: Stopping AudioRTP for hangup\n");
    _audiortp.closeRtpSession();
  }
  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()); 
  // Release SIP stack.
  eXosip_lock();
  eXosip_call_terminate(call->getCid(), -1);
  eXosip_unlock();

  removeCall(id);
  return true;
}

bool
SIPVoIPLink::onhold(const CallID& id)
{
  SIPCall* 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");
  _audiortp.closeRtpSession();


  int did = call->getDid();

  eXosip_lock ();
  sdp_message_t *local_sdp = eXosip_get_local_sdp(did);
  eXosip_unlock ();

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

  // Build INVITE_METHOD for put call on-hold
  osip_message_t *invite = NULL;
  eXosip_lock ();
  int exosipErr = eXosip_call_build_request (did, INVITE_METHOD, &invite);
  eXosip_unlock ();

  if (exosipErr != 0) {
    sdp_message_free(local_sdp);
    _debug("! SIP Failure: unable to build invite method to hold call\n");
    return false;
  }

  /* add sdp body */
  {
    char *tmp = NULL;

    int i = sdp_hold_call(local_sdp);
    if (i != 0) {
      sdp_message_free (local_sdp);
      osip_message_free (invite);
      _debug("! SIP Failure: Unable to hold call in SDP\n");
      return false;
    }
    
    i = sdp_message_to_str(local_sdp, &tmp);
    sdp_message_free(local_sdp);
    if (i != 0) {
      osip_message_free (invite);
      osip_free (tmp);
      _debug("! SIP Failure: Unable to translate sdp message to string\n");
      return false;
    }
    osip_message_set_body (invite, tmp, strlen (tmp));
    osip_free (tmp);
    osip_message_set_content_type (invite, "application/sdp");
  }
  
  // send request
  _debug("< SIP: Send on hold request\n");
  eXosip_lock ();
  exosipErr = eXosip_call_send_request (did, invite);
  eXosip_unlock ();
  
  return true;
}

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

  int did = call->getDid();

  eXosip_lock ();
  sdp_message_t *local_sdp = eXosip_get_local_sdp(did);
  eXosip_unlock ();

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

  // Build INVITE_METHOD for put call off-hold
  osip_message_t *invite;
  eXosip_lock ();
  int exosipErr = eXosip_call_build_request (did, INVITE_METHOD, &invite);
  eXosip_unlock ();

  if (exosipErr != 0) {
    sdp_message_free(local_sdp);
    return EXOSIP_ERROR_STD;
  }

  /* add sdp body */
  {
    char *tmp = NULL;
    
    int i = sdp_off_hold_call (local_sdp);
    if (i != 0) {
      sdp_message_free (local_sdp);
      osip_message_free (invite);
      return false;
    }
    
    i = sdp_message_to_str (local_sdp, &tmp);
    sdp_message_free (local_sdp);
    if (i != 0) {
      osip_message_free (invite);
      osip_free (tmp);
      return false;
    }
    osip_message_set_body (invite, tmp, strlen (tmp));
    osip_free (tmp);
    osip_message_set_content_type (invite, "application/sdp");
  }

  // Send request
  _debug("< Send off hold request\n");
  eXosip_lock ();
  exosipErr = eXosip_call_send_request (did, invite);
  eXosip_unlock ();

  // 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 = getSIPCall(id);
  if (call==0) { _debug("! SIP Failure: Call doesn't exist\n"); return false; }  

  std::string tmp_to = SIPToHeader(to);
  if (tmp_to.find("@") == std::string::npos) {
    tmp_to = tmp_to + "@" + getHostName();
  }

  osip_message_t *refer;
  eXosip_lock();
  // Build transfer request
  int exosipErr = eXosip_call_build_refer(call->getDid(), (char*)tmp_to.data(), &refer);
  if (exosipErr == 0) {
    // Send transfer request
    _debug("< SIP send transfer request to %s\n", tmp_to.data());
    exosipErr = eXosip_call_send_request(call->getDid(), refer);
  }
  eXosip_unlock();

  _audiortp.closeRtpSession();
  // shall we delete the call?
  //removeCall(id);
  return true;
}

bool
SIPVoIPLink::refuse (const CallID& id)
{
  SIPCall* 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; 
  }


  osip_message_t *answerMessage = NULL;
  eXosip_lock();
  // not BUSY.. where decline the invitation!
  int exosipErr = eXosip_call_build_answer(call->getTid(), SIP_DECLINE, &answerMessage);
  if (exosipErr == 0) {
    exosipErr = eXosip_call_send_answer(call->getTid(), SIP_DECLINE, answerMessage);
  }
  eXosip_unlock();
  return true;
}

bool 
SIPVoIPLink::carryingDTMFdigits(const CallID& id, char code)
{
  SIPCall* call = getSIPCall(id);
  if (call==0) { _debug("Call doesn't exist\n"); return false; }  

  int duration = Manager::instance().getConfigInt(SIGNALISATION, PULSE_LENGTH);
  osip_message_t *info;
  const int body_len = 1000;
  int i;

  char *dtmf_body = new char[body_len];

  eXosip_lock();
  // Build info request
  i = eXosip_call_build_info(call->getDid(), &info);
  if (i == 0) {
    snprintf(dtmf_body, body_len - 1, "Signal=%c\r\nDuration=%d\r\n", code, duration);
    osip_message_set_content_type (info, "application/dtmf-relay");
    osip_message_set_body (info, dtmf_body, strlen (dtmf_body));
    // Send info request
    i = eXosip_call_send_request(call->getDid(), info);
  }
  eXosip_unlock();
  
  delete[] dtmf_body; dtmf_body = NULL;
  return true;
}

bool
SIPVoIPLink::sendMessage(const std::string& to, const std::string& body)
{
  bool returnValue = false;

  // fast return
  if (body.empty()) {return returnValue; }

  osip_message_t* message = 0;
  const char* method = "MESSAGE";

  std::string sipFrom = getSipFrom();
  std::string sipTo   = getSipTo(to);
  std::string sipRoute = getSipRoute();

  if (!SIPCheckUrl(sipFrom)) {
    Manager::instance().displayConfigError("Error in source address");
    return returnValue;
  }
  if (!SIPCheckUrl(sipTo)) {
    Manager::instance().displayError("Error in destination address");
    return returnValue;
  }

  int eXosipError = EXOSIP_ERROR_STD;
  eXosip_lock();
  if ( sipRoute.empty() ) {
    eXosipError = eXosip_message_build_request(&message, method, sipTo.c_str(), sipFrom.c_str(), NULL);
  } else {
    eXosipError = eXosip_message_build_request(&message, method, sipTo.c_str(), sipFrom.c_str(), sipRoute.c_str());
  }