sipvoiplink.cpp

/**
 *  Copyright (C) 2004-2005 Savoir-Faire Linux inc.
 *  Author: Yan Morin <yan.morin@savoirfairelinux.com>
 *  Author : Laurielle Lea <laurielle.lea@savoirfairelinux.com>
 *                                                                              
 *  Portions Copyright (C) 2002,2003   Aymeric Moizard <jack@atosc.org>
 *
 *  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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#include <eXosip2/eXosip.h>
#include <osip2/osip.h>

#include "sipvoiplink.h"
#include "global.h"
#include "audio/codecDescriptor.h"
#include "manager.h"
#include "sipcall.h"
#include "user_cfg.h"
#include "eventthread.h"

#define DEFAULT_SIP_PORT	5060
#define RANDOM_SIP_PORT		rand() % 64000 + 1024
#define	DEFAULT_LOCAL_PORT	10500
#define	RANDOM_LOCAL_PORT	((rand() % 27250) + 5250)*2

#define VOICE_MSG			"Voice-Message"
#define LENGTH_VOICE_MSG	15

SipVoIPLink::SipVoIPLink() : VoIPLink()
{
  // default _audioRTP object initialization
  _evThread = new EventThread(this);
  _localPort = 0;
  _nMsgVoicemail = 0;
  _reg_id = -1;
  // defautlt _sipcallVector object initialization

  _registrationSend = false;
  _started = false;
}

SipVoIPLink::~SipVoIPLink(void) {
  endSipCalls();
  delete _evThread; _evThread = NULL;
  if (_started) {
    eXosip_quit();
  }
}

// for voIPLink interface
void
SipVoIPLink::terminate(void) 
{
}

bool
SipVoIPLink::checkNetwork (void)
{
  // Set IP address
  return getSipLocalIp();
}

bool
SipVoIPLink::init(void)
{
  if (0 != eXosip_init()) {
    _debug("Could not initialize eXosip\n");
    return false;
  }
  _started = true;

  srand (time(NULL));
  // second parameter, NULL is "::" for ipv6 and "0.0.0.0" for ipv4, we can put INADDR_ANY
  int i;
  i = eXosip_listen_addr(IPPROTO_UDP, INADDR_ANY, DEFAULT_SIP_PORT, AF_INET, 0);
  if (i != 0) {
    i = eXosip_listen_addr(IPPROTO_UDP, INADDR_ANY, RANDOM_SIP_PORT, AF_INET, 0);
    if (i != 0) {
      _debug("Could not initialize transport layer\n");
      return false;
    } else {
      _debug("VoIP Link listen on random port %d\n", RANDOM_SIP_PORT);
    }
  } else {
   _debug("VoIP Link listen on port %d\n", DEFAULT_SIP_PORT);
  }
  // Set user agent
  std::string tmp = std::string(PROGNAME_GLOBAL) + "/" + std::string(SFLPHONED_VERSION);
  eXosip_set_user_agent(tmp.data());

  // If use STUN server, firewall address setup
  if (Manager::instance().useStun()) {
    if (behindNat() != 1) {
      return false;
    }
    // This method is used to replace contact address with the public address of your NAT
    eXosip_masquerade_contact((Manager::instance().getFirewallAddress()).data(), Manager::instance().getFirewallPort());
  }

  if ( !checkNetwork() ) {
    return false;
  }
  _debug("SIP VoIP Link: listen to SIP Events\n");
  _evThread->start();
  return true;
}

/**
 * Subscibe to message-summary notify
 * It allows eXosip to not send ' 481 Subcription Does Not Exist ' response
 */
void
SipVoIPLink::subscribeMessageSummary()
{
  osip_message_t *subscribe;
  const char *route= NULL;

  // from/to
  ManagerImpl& manager = Manager::instance();
  std::string from = fromHeader(manager.getConfigString(SIGNALISATION, USER_PART), manager.getConfigString(SIGNALISATION, HOST_PART));

  // to
  std::string to;
  to = manager.getConfigString(SIGNALISATION, PROXY);
  if (!to.empty()) {
    to = toHeader(manager.getConfigString(SIGNALISATION, USER_PART)) + "@" + to;
  } else {
    to = from;
  }
  

  // like in http://www.faqs.org/rfcs/rfc3842.html
  const char *event="message-summary";
  int expires = 86400;

  // return 0 if no error
  // the first from is the to... but we send the same
  eXosip_lock();
  int error = eXosip_subscribe_build_initial_request(&subscribe, to.c_str(), from.c_str(), route, event, expires);
  eXosip_unlock();

  if (error == 0) {
    // Accept: application/simple-message-summary
    osip_message_set_header (subscribe, "Accept", "application/simple-message-summary");

    _debug("Sending Message-summary subscription");
    // return 0 if ok
    eXosip_lock();
    error = eXosip_subscribe_send_initial_request (subscribe);
    eXosip_unlock();
    _debug(" and return %d\n", error);
  }
}

bool
SipVoIPLink::isInRtpmap (int index, int payload, CodecDescriptorVector* cdv) {
  for (int i = 0; i < index; i++) {
    if (cdv->at(i)->getPayload() == payload) {
      return true;
    }
  }
  return false;
}

int
SipVoIPLink::setRegister (void) 
{
  ManagerImpl& manager = Manager::instance();

  if (_reg_id != -1) {
    manager.displayError("Registration already sent. Try to unregister");
    return -1;
  }

  // all this will be inside the profil associate with the voip link
  std::string proxy = "sip:" + manager.getConfigString(SIGNALISATION, PROXY);
  std::string hostname = "sip:" + manager.getConfigString(SIGNALISATION, HOST_PART);
  std::string from = fromHeader(manager.getConfigString(SIGNALISATION, USER_PART), manager.getConfigString(SIGNALISATION, HOST_PART));

  if (manager.getConfigString(SIGNALISATION, HOST_PART).empty()) {
    manager.displayConfigError("Fill host part field");
    return -1;
  }
  if (manager.getConfigString(SIGNALISATION, USER_PART).empty()) {
    manager.displayConfigError("Fill user part field");
    return -1;
  }

  _debug("REGISTER From: %s\n", from.data());
  osip_message_t *reg = NULL;
  eXosip_lock();
  if (!manager.getConfigString(SIGNALISATION, PROXY).empty()) {
    _reg_id = eXosip_register_build_initial_register ((char*)from.data(), 
						      (char*)proxy.data(), NULL, EXPIRES_VALUE, &reg);
  } else {
    _reg_id = eXosip_register_build_initial_register ((char*)from.data(), 
						      (char*)hostname.data(), NULL, EXPIRES_VALUE, &reg);
  }
  eXosip_unlock();
  if (_reg_id < 0) {
    return -1;
  }

  if (setAuthentication() == -1) {
    _debug("No authentication\n");
    return -1;
  }

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

  eXosip_lock();
  int i = eXosip_register_send_register (_reg_id, reg);
  if (i == -2) {
    _debug("Cannot build registration, check the setup\n"); 
    eXosip_unlock();
    return -1;
  }
  if (i == -1) {
    _debug("Registration sending failed\n");
    eXosip_unlock();
    return -1;
  }
  eXosip_unlock();

  // subscribe to message one time?
  // subscribeMessageSummary();
  _registrationSend = true;
  return i;
}

/**
 * setUnregister 
 * unregister if we already send the first registration
 * @return -1 if there is an error
 */
int 
SipVoIPLink::setUnregister (void)
{
  if ( _registrationSend ) {
    int i = 0;
    osip_message_t *reg = NULL;

    eXosip_lock();

    if (_reg_id > 0) {
      i = eXosip_register_build_register (_reg_id, 0, &reg);
    }
    eXosip_unlock();
    if (i < 0) {
      return -1;
    }

    eXosip_lock();
    _debug("< Sending REGISTER (expire=0)\n");
    i = eXosip_register_send_register (_reg_id, reg);
    if (i == -2) {
      _debug("  Cannot build registration (unregister), check the setup\n"); 
      eXosip_unlock();
      return -1;
    }
    if (i == -1) {
      _debug("  Registration (unregister) Failed\n");
    }
    eXosip_unlock();
    _reg_id = -1;
    return i;
  } else {
    // no registration send before
    return -1;
  }
}

int
SipVoIPLink::outgoingInvite (CALLID id, const std::string& to_url) 
{
  bool has_ip = checkNetwork();
  std::string from;
  std::string to;

  // TODO: should be inside account settings
  ManagerImpl& manager = Manager::instance();
  // Form the From header field basis on configuration panel
  std::string host = manager.getConfigString(SIGNALISATION, HOST_PART);
  std::string hostFrom = host;
  if ( hostFrom.empty() ) {
    hostFrom = getLocalIpAddress();
  }
  from = fromHeader(manager.getConfigString(SIGNALISATION, USER_PART), hostFrom);
	
  to = toHeader(to_url);

  if (to.find("@") == std::string::npos and 
      manager.getConfigInt(SIGNALISATION, AUTO_REGISTER)) {
    if(!host.empty()) {
      to = to + "@" + manager.getConfigString(SIGNALISATION, HOST_PART);
    }
  }
		
  _debug("            From: %s\n", from.data());
  _debug("            To: %s\n", to.data());

  if (manager.getConfigString(SIGNALISATION, PROXY).empty()) {
    // If no SIP proxy setting for direct call with only IP address
    if (has_ip) {
      if (startCall(id, from, to, "", "") <= 0) {
    	 _debug("Warning SipVoIPLink: call not started\n");
	     return -1;
      }
    } else {
      manager.displayErrorText(id, "No network found\n");
      return -1;
    }
    return 0;
  } else {
    // If SIP proxy setting
    std::string route = "<sip:" + 
      manager.getConfigString(SIGNALISATION, PROXY) + ";lr>";
    if (has_ip) {
      if (startCall(id, from, to, "", route) <= 0) {
	     _debug("Warning SipVoIPLink: call not started\n");
	     return -1;
      }
    } else {
      manager.displayErrorText(id, "No network found\n");
      return -1;
    }
    return 0;
  }
}

/**
 * @return 0 is good, -1 is bad
 */
int
SipVoIPLink::answer (CALLID id) 
{
  int i;
  int port;
  char tmpbuf[64];
  bzero (tmpbuf, 64);
  // Get  port   
  snprintf (tmpbuf, 63, "%d", getSipCall(id)->getLocalAudioPort());

  _debug("%10d: Answer call [cid = %d, did = %d]\n", id, getSipCall(id)->getCid(), getSipCall(id)->getDid());
  port = getSipCall(id)->getLocalAudioPort();
  _debug("            Local audio port: %d\n", port);

  osip_message_t *answerMessage = NULL;
  SipCall* ca = getSipCall(id);

  // Send 180 RINGING
  _debug("< Send 180 Ringing\n");
  eXosip_lock ();
  eXosip_call_send_answer (ca->getTid(), RINGING, NULL);
  eXosip_unlock ();

  // Send 200 OK
  eXosip_lock();
  i = eXosip_call_build_answer (ca->getTid(), OK, &answerMessage);
  if (i != 0) {
   _debug("< Send 400 Bad Request\n");
    eXosip_call_send_answer (ca->getTid(), BAD_REQ, NULL);
  } else {
    // use exosip, bug locked
    i = sdp_complete_200ok (ca->getDid(), answerMessage, port);
    if (i != 0) {
      osip_message_free (answerMessage);
      _debug("< Send 415 Unsupported Media Type\n");
      eXosip_call_send_answer (ca->getTid(), UNSUP_MEDIA_TYPE, NULL);
    } else {
      _debug("< Send 200 OK\n");
      eXosip_call_send_answer (ca->getTid(), OK, answerMessage);
    }
  }
  eXosip_unlock();

  // Incoming call is answered, start the sound channel.
  _debug("          Starting AudioRTP\n");
  if (_audiortp.createNewSession (getSipCall(id)) < 0) {
    _debug("FATAL: Unable to start sound (%s:%d)\n", __FILE__, __LINE__);
    i = -1;
  }
  return i;
}


/**
 * @return > 0 is good, -1 is bad
 */
int
SipVoIPLink::hangup (CALLID id) 
{
  int i = 0;
  SipCall* sipcall = getSipCall(id);
  if (sipcall == NULL) { return -1; }
  _debug("%10d: Hang up call [cid = %d, did = %d]\n", 
    id, sipcall->getCid(), sipcall->getDid());	
  // Release SIP stack.
  eXosip_lock();
  i = eXosip_call_terminate (sipcall->getCid(), sipcall->getDid());
  eXosip_unlock();

  // Release RTP channels
  if (id == Manager::instance().getCurrentCallId()) {
    _audiortp.closeRtpSession();
  }

  deleteSipCall(id);
  return i;
}

int
SipVoIPLink::cancel (CALLID id) 
{
  int i = 0;
  SipCall* sipcall = getSipCall(id);
  _debug("%10d: Cancel call [cid = %d]\n", id, sipcall->getCid());
  // Release SIP stack.
  eXosip_lock();
  i = eXosip_call_terminate (sipcall->getCid(), -1);
  eXosip_unlock();

  deleteSipCall(id);
  return i;
}

/*
 * @return -1 = sipcall not present
 */
int
SipVoIPLink::onhold (CALLID id) 
{
  osip_message_t *invite;
  int i;
  int did;

  sdp_message_t *local_sdp = NULL;

  SipCall *sipcall = getSipCall(id);
  if ( sipcall == NULL ) { return -1; }

  did = sipcall->getDid();

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

  if (local_sdp == NULL) {
    return -1;
  }

  // Build INVITE_METHOD for put call on-hold
  eXosip_lock ();
  i = eXosip_call_build_request (did, INVITE_METHOD, &invite);
  eXosip_unlock ();

  if (i != 0) {
    sdp_message_free(local_sdp);
    return -1;
  }

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

    i = sdp_hold_call (local_sdp);
    if (i != 0) {
      sdp_message_free (local_sdp);
      osip_message_free (invite);
      return -1;
    }
    
    i = sdp_message_to_str (local_sdp, &tmp);
    sdp_message_free (local_sdp);
    if (i != 0) {
      osip_message_free (invite);
      osip_free (tmp);
      return -1;
    }
    osip_message_set_body (invite, tmp, strlen (tmp));
    osip_free (tmp);
    osip_message_set_content_type (invite, "application/sdp");
  }
  
  // Send request
  _audiortp.closeRtpSession();

  eXosip_lock ();
  i = eXosip_call_send_request (did, invite);
  eXosip_unlock ();
  
  // Disable audio
  return i;
}

/**
 * @return 0 is good, -1 is bad
 */
int
SipVoIPLink::offhold (CALLID id) 
{
  osip_message_t *invite;
  int i;
  int did;

  sdp_message_t *local_sdp = NULL;

  did = getSipCall(id)->getDid();
  eXosip_lock ();
  local_sdp = eXosip_get_local_sdp (did);
  eXosip_unlock ();
  if (local_sdp == NULL) {
    return -1;
  }

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

  if (i != 0) {
    sdp_message_free(local_sdp);
    return -1;
  }

  /* add sdp body */
  {
    char *tmp = NULL;
    
    i = sdp_off_hold_call (local_sdp);
    if (i != 0) {
      sdp_message_free (local_sdp);
      osip_message_free (invite);
      return -1;
    }
    
    i = sdp_message_to_str (local_sdp, &tmp);
    sdp_message_free (local_sdp);
    if (i != 0) {
      osip_message_free (invite);
      osip_free (tmp);
      return -1;
    }
    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 ();
  i = eXosip_call_send_request (did, invite);
  eXosip_unlock ();

  // Enable audio
  _debug("          Starting AudioRTP\n");
  if (_audiortp.createNewSession (getSipCall(id)) < 0) {
    _debug("FATAL: Unable to start sound (%s:%d)\n", __FILE__, __LINE__);
    i = -1;
  }
  return i;
}

int
SipVoIPLink::transfer (CALLID id, const std::string& to)
{
  osip_message_t *refer;
  int i;
  std::string tmp_to;
  tmp_to = toHeader(to);
  if (tmp_to.find("@") == std::string::npos) {
    tmp_to = tmp_to + "@" + Manager::instance().getConfigString(SIGNALISATION,
HOST_PART);
  }

  eXosip_lock();
  // Build transfer request
  i = eXosip_call_build_refer (getSipCall(id)->getDid(), (char*)tmp_to.data(),
			       &refer);
  if (i == 0) {
    // Send transfer request
    i = eXosip_call_send_request (getSipCall(id)->getDid(), refer);
  }
  eXosip_unlock();
  return i;
}

int
SipVoIPLink::refuse (CALLID id)
{
  int i;
  char tmpbuf[64];
  bzero (tmpbuf, 64);
  // Get local port   
  snprintf (tmpbuf, 63, "%d", getSipCall(id)->getLocalAudioPort());
	
  osip_message_t *answerMessage = NULL;
  eXosip_lock();
  // not BUSY.. where decline the invitation!
  i = eXosip_call_build_answer (getSipCall(id)->getTid(), SIP_DECLINE, &answerMessage);
  if (i == 0) {
    i = eXosip_call_send_answer (getSipCall(id)->getTid(), SIP_DECLINE, answerMessage);
  }
  eXosip_unlock();
  return i;
}

int
SipVoIPLink::getEvent (void)
{
  // wait for 0 s, 50 ms
  eXosip_event_t* event = eXosip_event_wait (0, 50);
  eXosip_lock();
  eXosip_automatic_action();
  eXosip_unlock();

  if (event == NULL) {
    return -1;
  }

  SipCall* sipcall = NULL;
  CALLID id = 0;
  int returnValue = 0;

  _debug("Receive SipEvent #%d %s\n", event->type, event->textinfo);
  switch (event->type) {
    // IP-Phone user receives a new call
  case EXOSIP_CALL_INVITE: //
    _debug("> INVITE (receive)\n");
    checkNetwork();

    // Set local random port for incoming call
    if (!Manager::instance().useStun()) {
      setLocalPort(RANDOM_LOCAL_PORT);
    } else {
      // If there is a firewall
      if (behindNat() != 0) {
        setLocalPort(Manager::instance().getFirewallPort());
      } else {
        returnValue = -1;
        break;
      }
    }

    // Generate id
    id = Manager::instance().generateNewCallId();
    Manager::instance().pushBackNewCall(id, Incoming);
    _debug("%10d: [cid = %d, did = %d]\n", id, event->cid, event->did);

    // Associate an audio port with a call
    sipcall = getSipCall(id);
    sipcall->setLocalAudioPort(_localPort);
    sipcall->setLocalIp(getLocalIpAddress());
    _debug("            Local listening port: %d\n", _localPort);
    _debug("            Local listening IP: %s\n", getLocalIpAddress().c_str());

    if (sipcall->newIncomingCall(event) == 0 ) {
      if (Manager::instance().incomingCall(id, sipcall->getName(), sipcall->getNumber()) == -1) {
        Manager::instance().displayError("            Incoming Call Failed");
        deleteSipCall(id);
      }
    } else {
      Manager::instance().peerHungupCall(id);
      deleteSipCall(id);
      Manager::instance().displayError("            Incoming Call Failed");
    }
    break;

  case EXOSIP_CALL_REINVITE:
    _debug("> INVITE (reinvite)\n");
    //eXosip_call_send_answer(event->tid, 403, NULL);
    //488 as http://www.atosc.org/pipermail/public/osip/2005-June/005385.html

    id = findCallId(event);
    if (id != 0) {
      sipcall = getSipCall(id);
      if (sipcall != 0) {
        _debug("%10d: Receive Reinvite [cid = %d, did = %d], localport=%d\n", id, event->cid, event->did,sipcall->getLocalAudioPort());

        if ( id == Manager::instance().getCurrentCallId() ) {
          Manager::instance().stopTone();
          _audiortp.closeRtpSession();
        }
        sipcall->newReinviteCall(event);
        // we should receive an ack after that...
      }
    } else {
      _debug("< Send 488 Not Acceptable Here");
      eXosip_lock();
      eXosip_call_send_answer(event->tid, 488, NULL);
      eXosip_unlock();
    }
    break;

  case EXOSIP_CALL_PROCEEDING: // 8
    // proceeding call...
    break;

  case EXOSIP_CALL_RINGING: // 9 peer call is ringing
    id = findCallIdInitial(event);
    _debug("%10d: Receive Call Ringing [cid = %d, did = %d]\n", id, event->cid, event->did);
    if (id != 0) {
      getSipCall(id)->ringingCall(event);
      Manager::instance().peerRingingCall(id);
    } else {
      returnValue = -1;
    }
    break;

  // The peer-user answers
  case EXOSIP_CALL_ANSWERED: // 10
  {
    id = findCallIdInitial(event);
    if ( id != 0) {
      sipcall = getSipCall(id);
      if ( sipcall != 0 ) {
        _debug("%10d: Receive Call Answer [cid = %d, did = %d], localport=%d\n", id, event->cid, event->did, sipcall->getLocalAudioPort());

        // Answer
        if (Manager::instance().callCanBeAnswered(id)) {
          sipcall->setStandBy(false);
          if (sipcall->answeredCall(event) != -1) {
            sipcall->answeredCall_without_hold(event);
            Manager::instance().peerAnsweredCall(id);
  
            if(!Manager::instance().callIsOnHold(id) && Manager::instance().getCurrentCallId()==id) {
              // Outgoing call is answered, start the sound channel.
              _debug("            Starting AudioRTP\n");
              if (_audiortp.createNewSession(sipcall) < 0) {
                _debug("            FATAL: Unable to start sound (%s:%d)\n", 
                __FILE__, __LINE__);
                returnValue = -1;
              }
            }
          }
        } else {
          // Answer to on/off hold to send ACK
          _debug("            Answering call\n");
          sipcall->answeredCall(event);
        }
      }
    } else {
      returnValue = -1;
    }
  }
   break;
  case EXOSIP_CALL_REDIRECTED: // 11
    break;

  case EXOSIP_CALL_ACK: // 15
    id = findCallId(event); 
    _debug("%10d: Receive ACK [cid = %d, did = %d]\n", id, event->cid, event->did);
    if (id != 0 ) {
      sipcall = getSipCall(id);
      if(sipcall != 0 ) { 
        sipcall->receivedAck(event);
        if (sipcall->isReinvite()) {
          sipcall->endReinvite();
          if(!Manager::instance().callIsOnHold(id) && Manager::instance().getCurrentCallId()==id) {
            _debug("            Starting AudioRTP\n");
            _audiortp.createNewSession(sipcall);
          } else {
            _debug("            Didn't start RTP because it's on hold or it's not the current call id\n");
          }
        }
      }
    } else {
      returnValue = -1;
    }
    break;

    // The peer-user closed the phone call(we received BYE).
  case EXOSIP_CALL_CLOSED: // 25
    id = findCallId(event);
    if (id==0) { id = findCallIdInitial(event); }
    _debug("%10d: Receive BYE [cid = %d, did = %d]\n", id, event->cid, event->did);	
    if (id != 0) {
      if (Manager::instance().callCanBeClosed(id)) {
         sipcall = getSipCall(id);
         _audiortp.closeRtpSession();
      }
      Manager::instance().peerHungupCall(id);
      deleteSipCall(id);
    } else {
      returnValue = -1;
    }	
    break;
  case EXOSIP_CALL_RELEASED:
    if (event) {
      _debug("SIP call released: [cid = %d, did = %d]\n", event->cid, event->did);
      id = findCallId(event);
      if (id!=0) {
        // not supposed to be execute on a current call...
        Manager::instance().callFailure(id);
        deleteSipCall(id);
      }

    }
    break;
  case EXOSIP_CALL_REQUESTFAILURE:
    id = findCallId(event);

    // Handle 4XX errors
    switch (event->response->status_code) {
    case AUTH_REQUIRED:
      _debug("SIP Server ask required authentification: logging...\n");
      setAuthentication();
      eXosip_lock();
      eXosip_automatic_action();
      eXosip_unlock();
      break;
    case UNAUTHORIZED:
      _debug("Request is unauthorized. SIP Server ask authentification: logging...\n");
      setAuthentication();
      break;

    case BAD_REQ:
    case FORBIDDEN:
    case NOT_FOUND:
    case NOT_ALLOWED:
    case NOT_ACCEPTABLE:
    case REQ_TIMEOUT:
    case TEMP_UNAVAILABLE:
    case ADDR_INCOMPLETE:
    case NOT_ACCEPTABLE_HERE: // 488
      // Display error on the screen phone
      //Manager::instance().displayError(event->response->reason_phrase);
      Manager::instance().displayErrorText(id, event->response->reason_phrase);
      Manager::instance().callFailure(id);
      deleteSipCall(id);
    break;
    case BUSY_HERE:
      Manager::instance().displayErrorText(id, event->response->reason_phrase);
      Manager::instance().callBusy(id);
      deleteSipCall(id);
      break;
    case REQ_TERMINATED:
      break;
    default:
      break;
    }

    break; 

  case EXOSIP_CALL_SERVERFAILURE:
    // Handle 5XX errors
    switch (event->response->status_code) {
    case SERVICE_UNAVAILABLE:
      id = findCallId(event);
      Manager::instance().callFailure(id);
      break;
    default:
      break;
    }
    break;

  case EXOSIP_CALL_GLOBALFAILURE:
    // Handle 6XX errors
    switch (event->response->status_code) {
    case BUSY_EVERYWHERE:
    case DECLINE:
      id = findCallId(event);
      Manager::instance().callFailure(id);
      break;
    default:
      break;
    }
    break;

  case EXOSIP_CALL_MESSAGE_NEW: // 18
    if (0 == event->request) break;
    if (MSG_IS_INFO(event->request)) {
      _debug("Receive a call message request info\n");
      osip_content_type_t* c_t = event->request->content_type;
      if (c_t != 0 && c_t->type != 0 && c_t->subtype != 0 ) {
        _debug("  Content Type of the message: %s/%s\n", c_t->type, c_t->subtype);
        // application/dtmf-relay
        if (strcmp(c_t->type, "application") == 0 && strcmp(c_t->subtype, "dtmf-relay") == 0) {
          handleDtmfRelay(event);
        }
      }
    }

    osip_message_t *answerOKNewMessage;
    eXosip_lock();
    if ( 0 == eXosip_call_build_answer(event->tid, OK, &answerOKNewMessage)) {
      _debug("< Sending 200 OK\n");
      eXosip_call_send_answer(event->tid, OK, answerOKNewMessage);
    } else {
      _debug("Could not sent an OK message\n");
    }
    eXosip_unlock();
    break;
 
  case EXOSIP_REGISTRATION_SUCCESS: // 1
    // Manager::instance().displayStatus(LOGGED_IN_STATUS);
    Manager::instance().registrationSucceed();
    break;

  case EXOSIP_REGISTRATION_FAILURE: // 2
    //Manager::instance().displayError("getEvent : Registration Failure");
    Manager::instance().registrationFailed();
    break;

  case EXOSIP_MESSAGE_NEW: //27

    if ( event->request == NULL) {
      break; // do nothing
    }
    unsigned int k;
				
    if (MSG_IS_OPTIONS(event->request)) {
      for (k = 0; k < _sipcallVector.size(); k++) {
        if (_sipcallVector.at(k)->getCid() == event->cid) { 
          break;
        }
      }

      // TODO: Que faire si rien trouve??
      eXosip_lock();
      if (k == _sipcallVector.size()) {
        /* answer 200 ok */
        eXosip_options_send_answer (event->tid, OK, NULL);
      } else if (_sipcallVector.at(k)->getCid() == event->cid) {
        /* already answered! */
      } else {
        /* answer 486 ok */
      	eXosip_options_send_answer (event->tid, BUSY_HERE, NULL);
      }
      eXosip_unlock();
    } 

    // Voice message 
    else if (MSG_IS_NOTIFY(event->request)){
      _debug("> NOTIFY Voice message\n");
      int ii;
      unsigned int pos;
      unsigned int pos_slash;

      osip_body_t *body = NULL;
      // Get the message body
      ii = osip_message_get_body(event->request, 0, &body);
      if (ii != 0) {
        _debug("  Cannot get body in a new EXOSIP_MESSAGE_NEW event\n");
        returnValue = -1;
        break;
      }

      // Analyse message body
      if (!body || !body->body) {
        returnValue = -1;
        break;
      }
      std::string str(body->body);
      pos = str.find(VOICE_MSG);

      if (pos == std::string::npos) {
	     // If the string is not found
        returnValue = -1;
        break;
      } 

      pos_slash = str.find ("/");
      std::string nb_msg = str.substr(pos + LENGTH_VOICE_MSG, 
      pos_slash - (pos + LENGTH_VOICE_MSG));

      // Set the number of voice-message
      setMsgVoicemail(atoi(nb_msg.data()));

      if (getMsgVoicemail() != 0) {
        // If there is at least one voice-message, start notification
        Manager::instance().startVoiceMessageNotification(nb_msg);
      } else {
        // Stop notification when there is 0 voice message
        Manager::instance().stopVoiceMessageNotification();
      }
    // http://www.jdrosen.net/papers/draft-ietf-simple-im-session-00.txt
    } else if (MSG_IS_MESSAGE(event->request)) {
      _debug("> MESSAGE received\n");
      // osip_content_type_t* osip_message::content_type
      osip_content_type_t* c_t = event->request->content_type;
      if (c_t != 0 &&  c_t->type != 0 && c_t->subtype != 0 ) {
        _debug("  Content Type of the message: %s/%s\n", c_t->type, c_t->subtype);

        osip_body_t *body = NULL;
        // Get the message body
        if (0 == osip_message_get_body(event->request, 0, &body)) {