New account implementation.
Need to test more and add dynamic handling in Qt Interface.
SipCall, Call, VoIPLink were rewritten completly
Configuration now in [SIP0] section of .sflphonedrc
The debug of sflphoned is very verbose.
sflphone-cli may not work right now (need to send SIP0 as accountId).

src/Makefile.am

@@ -13,10 +13,10 @@ endif
 
 SUBDIRS = audio config gui $(ZEROCONFDIR)
 
-sflphoned_SOURCES = call.cpp 	eventthread.cpp 	main.cpp 	sipvoiplink.cpp 	voIPLink.cpp \
-		sipcall.cpp 	managerimpl.cpp	\
-		observer.cpp \
-		account.cpp sipaccount.cpp aixaccount.cpp accountcreator.cpp aixvoiplink.cpp
+sflphoned_SOURCES = eventthread.cpp 	main.cpp 	voIPLink.cpp \
+		managerimpl.cpp	observer.cpp \
+		account.cpp sipaccount.cpp iaxaccount.cpp accountcreator.cpp iaxvoiplink.cpp \
+                sipvoiplink.cpp call.cpp sipcall.cpp
 
 sflphoned_CXXFLAGS = -DPREFIX=\"$(prefix)\" -DPROGSHAREDIR=\"${datadir}/sflphone\" $(ZEROCONFFLAGS)
 
@@ -38,6 +38,8 @@ libsflphone_la_LIBADD = \
 libsflphone_la_SOURCES =
 
 noinst_LTLIBRARIES = libsflphone.la
-noinst_HEADERS = managerimpl.h manager.h global.h observer.h eventthread.h sipvoiplink.h user_cfg.h \
-                 call.h voIPLink.h sipcall.h \
-		 account.h sipaccount.h aixaccount.h accountcreator.h aixvoiplink.h
+noinst_HEADERS = managerimpl.h manager.h global.h observer.h eventthread.h user_cfg.h \
+                 voIPLink.h \
+		 account.h sipaccount.h iaxaccount.h accountcreator.h iaxvoiplink.h \
+                 sipvoiplink.h  call.h  sipcall.h
+

src/account.cpp

@@ -24,6 +24,7 @@ Account::Account(const AccountID& accountID) : _accountID(accountID)
   _link = 0;
 
   _shouldInitOnStart = false;
+  _shouldRegisterOnStart = false;
   _enabled = false;
   _registered = false;
 }

src/account.h

@@ -28,6 +28,8 @@ typedef std::string AccountID;
 #define AccountNULL ""
 #define CONFIG_ACCOUNT_TYPE   "Account.type"
 #define CONFIG_ACCOUNT_ENABLE "Account.enable"
+#define CONFIG_ACCOUNT_AUTO_REGISTER  "Account.autoregister"
+
 
 /**
 	@author Yan Morin 
@@ -39,13 +41,13 @@ class Account{
 public:
     Account(const AccountID& accountID);
 
-    ~Account();
+    virtual ~Account();
 
   /**
    * Load the default properties for the account
    */
   virtual void initConfig(Conf::ConfigTree& config) = 0;
-
+  virtual void loadConfig() = 0;
 
   /**
    * Get the voiplink pointer
@@ -77,6 +79,18 @@ public:
    */
   virtual bool terminate() = 0;
 
+  /**
+   * Tell if we should init the account on start
+   * @return true if we must init the link
+   */
+  bool shouldInitOnStart() {return _shouldInitOnStart; }
+
+  /**
+   * Tell if we should init the account on start
+   * @return true if we must init the link
+   */
+  bool shouldRegisterOnStart() {return _shouldRegisterOnStart; }
+
 private:
   /**
    * Create a unique voIPLink() depending on the protocol
@@ -102,6 +116,12 @@ protected:
    */
   bool _shouldInitOnStart;
 
+  /**
+   * Tells if we should register automatically on startup
+   * Modified by the configuration
+   */
+  bool _shouldRegisterOnStart;
+
   /**
    * Tells if the link is enabled or not
    * Modified by init/terminate

src/accountcreator.cpp

@@ -18,7 +18,7 @@
  */
 #include "accountcreator.h"
 #include "sipaccount.h"
-#include "aixaccount.h"
+#include "iaxaccount.h"
 
 AccountCreator::AccountCreator()
 {
@@ -37,8 +37,8 @@ AccountCreator::createAccount(AccountType type, AccountID accountID)
       return new SIPAccount(accountID);
     break;
 
-    case AIX_ACCOUNT:
-      return new AIXAccount(accountID);
+    case IAX_ACCOUNT:
+      return new IAXAccount(accountID);
     break;
   }
   return 0;

src/accountcreator.h

@@ -33,7 +33,7 @@ public:
    /**
     * Public account type
     */
-   enum AccountType {SIP_ACCOUNT, AIX_ACCOUNT };
+   enum AccountType {SIP_ACCOUNT, IAX_ACCOUNT };
 
   /**
    * Create a new account or null

src/audio/audiortp.cpp

@@ -49,7 +49,7 @@ AudioRtp::~AudioRtp (void) {
 }
 
 int 
-AudioRtp::createNewSession (SipCall *ca) {
+AudioRtp::createNewSession (SIPCall *ca) {
   ost::MutexLock m(_threadMutex);
 
   // something should stop the thread before...
@@ -90,7 +90,7 @@ AudioRtp::closeRtpSession () {
 ////////////////////////////////////////////////////////////////////////////////
 // AudioRtpRTX Class                                                          //
 ////////////////////////////////////////////////////////////////////////////////
-AudioRtpRTX::AudioRtpRTX (SipCall *sipcall, AudioLayer* driver, bool sym) {
+AudioRtpRTX::AudioRtpRTX (SIPCall *sipcall, AudioLayer* driver, bool sym) {
   setCancel(cancelDeferred);
   time = new ost::Time();
   _ca = sipcall;
@@ -108,7 +108,7 @@ AudioRtpRTX::AudioRtpRTX (SipCall *sipcall, AudioLayer* driver, bool sym) {
 
   // TODO: Change bind address according to user settings.
   // TODO: this should be the local ip not the external (router) IP
-  std::string localipConfig = "0.0.0.0"; // _ca->getLocalIp();
+  std::string localipConfig = _ca->getLocalIp(); // _ca->getLocalIp();
   ost::InetHostAddress local_ip(localipConfig.c_str());
 
   //_debug("AudioRtpRTX ctor : Local IP:port %s:%d\tsymmetric:%d\n", local_ip.getHostname(), _ca->getLocalAudioPort(), _sym);
@@ -159,9 +159,9 @@ AudioRtpRTX::initAudioRtpSession (void)
     if (_ca == 0) { return; }
 
     //_debug("Init audio RTP session\n");
-    ost::InetHostAddress remote_ip(_ca->getRemoteSdpAudioIp());
+    ost::InetHostAddress remote_ip(_ca->getRemoteIp().c_str());
     if (!remote_ip) {
-      _debug("AudioRTP Thread Error: Target IP address [%s] is not correct!\n", _ca->getRemoteSdpAudioIp());
+      _debug("AudioRTP Thread Error: Target IP address [%s] is not correct!\n", _ca->getRemoteIp().data());
       return;
     }
 
@@ -178,12 +178,12 @@ AudioRtpRTX::initAudioRtpSession (void)
     }
 
     if (!_sym) {
-      if ( !_sessionRecv->addDestination(remote_ip, (unsigned short) _ca->getRemoteSdpAudioPort()) ) {
-        _debug("AudioRTP Thread Error: could not connect to port %d\n",  _ca->getLocalAudioPort());
+      if ( !_sessionRecv->addDestination(remote_ip, (unsigned short) _ca->getRemoteAudioPort()) ) {
+        _debug("AudioRTP Thread Error: could not connect to port %d\n",  _ca->getRemoteAudioPort());
         return;
       }
-      if (!_sessionSend->addDestination (remote_ip, (unsigned short) _ca->getRemoteSdpAudioPort())) {
-        _debug("AudioRTP Thread Error: could not connect to port %d\n",  _ca->getRemoteSdpAudioPort());
+      if (!_sessionSend->addDestination (remote_ip, (unsigned short) _ca->getRemoteAudioPort())) {
+        _debug("AudioRTP Thread Error: could not connect to port %d\n",  _ca->getRemoteAudioPort());
         return;
       }
 
@@ -202,7 +202,7 @@ AudioRtpRTX::initAudioRtpSession (void)
 
       //_debug("AudioRTP Thread: Added session destination %s:%d\n", remote_ip.getHostname(), (unsigned short) _ca->getRemoteSdpAudioPort());
 
-      if (!_session->addDestination (remote_ip, (unsigned short) _ca->getRemoteSdpAudioPort())) {
+      if (!_session->addDestination (remote_ip, (unsigned short) _ca->getRemoteAudioPort())) {
         return;
       }
 
@@ -451,6 +451,7 @@ AudioRtpRTX::run () {
     audiolayer->flushMic();
     audiolayer->startStream();
     _start.post();
+    _debug("AudioRTP Start\n");
     while (!testCancel()) {
       ////////////////////////////
       // Send session
@@ -471,11 +472,11 @@ AudioRtpRTX::run () {
     audiolayer->stopStream();
   } catch(std::exception &e) {
     _start.post();
-    _debug("AudioRTP Thread, run: %s\n", e.what());
+    _debug("AudioRTP Stop: %s\n", e.what());
     throw;
   } catch(...) {
     _start.post();
-    _debugException("AudioRTP Thread, run()");
+    _debugException("AudioRTP Stop");
     throw;
   }
   delete [] data_for_speakers_stereo; data_for_speakers_stereo = 0;

src/audio/audiortp.h

@@ -29,21 +29,21 @@
 #define RTP_FRAMES2SEND 160
 
 class AudioLayer;
-class SipCall;
+class SIPCall;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Two pair of sockets
 ///////////////////////////////////////////////////////////////////////////////
 class AudioRtpRTX : public ost::Thread, public ost::TimerPort {
 public:
-	AudioRtpRTX (SipCall *, AudioLayer*, bool);
+	AudioRtpRTX (SIPCall *, AudioLayer*, bool);
 	~AudioRtpRTX();
 
 	ost::Time *time; 	// For incoming call notification 
 	virtual void run ();
 
 private:
-	SipCall* _ca;
+	SIPCall* _ca;
 	AudioLayer* _audioDevice;
 	ost::RTPSession *_sessionSend;
 	ost::RTPSession *_sessionRecv;
@@ -72,7 +72,7 @@ public:
   AudioRtp();
   ~AudioRtp();
 
-  int 			createNewSession (SipCall *);
+  int 			createNewSession (SIPCall *);
   void			closeRtpSession	 ();
 
 private:

src/call.cpp

-/**
- *  Copyright (C) 2004-2005 Savoir-Faire Linux inc.
+/*
+ *  Copyright (C) 2004-2006 Savoir-Faire Linux inc.
  *  Author: Yan Morin <yan.morin@savoirfairelinux.com>
- *  Author: Laurielle Lea <laurielle.lea@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 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 <iostream>
-
 #include "call.h"
-#include "voIPLink.h"
-
-Call::Call (CALLID id, Call::CallType type, VoIPLink* voiplink)
-{
-	_state = NotExist;
-	_type = Null;
-	_id = id; 
-	_type = type;
-	_voIPLink = voiplink;
-  _flagNotAnswered = true;
-	
-	switch (_type) {
-	case Outgoing:
-		_voIPLink->newOutgoingCall(_id);
-		break;
-	case Incoming:
-		_voIPLink->newIncomingCall(_id);
-		break;
-	default:
-		break;
-	}
-}
 
-Call::~Call (void)
+Call::Call(const CallID& id, Call::CallType type) : _id(id), _type(type)
 {
+  _connectionState = Call::Disconnected;
+  _callState = Call::Inactive;
 }
 
-CALLID
-Call::getId (void)
-{
-	return _id;
-}
 
-void 
-Call::setId (CALLID id)
+Call::~Call()
 {
-	_id = id;
 }
 
 void 
-Call::setVoIPLink (VoIPLink* voIPLink)
-{
-	_voIPLink = voIPLink;
-}
-
-VoIPLink*
-Call::getVoIPLink (void)
-{
-	return _voIPLink;
-}
-
-std::string 
-Call::getCallerIdName (void)
+Call::setConnectionState(ConnectionState state) 
 {
-	return _callerIdName;
+  ost::MutexLock m(_callMutex);
+  _connectionState = state;
 }
 
-void 
-Call::setCallerIdName (const std::string& callerId_name)
+Call::ConnectionState
+Call::getConnectionState() 
 {
-	_callerIdName = callerId_name;
+  ost::MutexLock m(_callMutex);
+  return _connectionState;
 }
 
-std::string 
-Call::getCallerIdNumber (void)
-{
-	return _callerIdNumber;
-}
 
 void 
-Call::setCallerIdNumber (const std::string& callerId_number)
+Call::setState(CallState state) 
 {
-	_callerIdNumber = callerId_number;
+  ost::MutexLock m(_callMutex);
+  _callState = state;
 }
 
 Call::CallState
-Call::getState (void)
-{
-	return _state;  
-}
-
-void 
-Call::setState (Call::CallState state) 
-{
-	_state = state;
-}
-
-Call::CallType 
-Call::getType (void)
+Call::getState() 
 {
-	return _type;
+  ost::MutexLock m(_callMutex);
+  return _callState;
 }
 
-void 
-Call::setType (Call::CallType type)
-{
-	_type = type;
-}
-
-bool
-Call::isBusy (void)
-{
-	if (isAnswered() or isOffHold() or isOnMute() or isOffMute()) {
-		return true;
-	} else {
-		return false;
-	}
-}
-bool 
-Call::isOnHold (void)
-{
-	return (_state == OnHold) ? true : false;
-}
-
-bool 
-Call::isOffHold (void)
-{
-	return (_state == OffHold) ? true : false;
-}
-
-bool 
-Call::isOnMute (void)
-{
-	return (_state == MuteOn) ? true : false;
-}
-
-bool 
-Call::isOffMute (void)
-{
-	return (_state == MuteOff) ? true : false;
-}
-
-bool 
-Call::isTransfered (void)
-{
-	return (_state == Transfered) ? true : false;
-}
-
-bool 
-Call::isHungup (void)
-{
-	return (_state == Hungup) ? true : false;
-}
-
-bool 
-Call::isRinging (void)
-{
-	return (_state == Ringing) ? true : false;
-}
-
-bool 
-Call::isRefused (void)
-{
-	return (_state == Refused) ? true : false;
-}
-
-
-bool 
-Call::isAnswered (void)
-{
-	return (_state == Answered) ? true : false;
-}
-
-bool 
-Call::isNotAnswered (void)
-{
-	return (_state == Error || _state == NotExist || _state == Busy) ? true : false;
-}
-
-bool 
-Call::isProgressing (void)
-{
-	return (_state == Progressing) ? true : false;
-}
-
-bool
-Call::isOutgoingType (void)
-{
-	return (_type == Outgoing) ? true : false;
-}
-
-bool
-Call::isIncomingType (void)
-{
-	return (_type == Incoming) ? true : false;
-}
-
-int 
-Call::outgoingCall(const std::string& to)
-{
-	return _voIPLink->outgoingInvite(_id, to);
-}
-
-int 
-Call::hangup  (void)
-{
-	int i = _voIPLink->hangup(_id);
-  setState(Hungup);
-	return i;
-}
-
-int 
-Call::cancel  (void)
-{
-	int i = _voIPLink->cancel(_id);
-  setState(Hungup);
-	return i;
-}
-
-int 
-Call::answer  (void)
-{
-  _flagNotAnswered = false;
-	int i = _voIPLink->answer(_id);
-  setState(Answered);
-	return i;
-}
-
-int 
-Call::onHold  (void)
-{
-	int i = _voIPLink->onhold(_id);
-  setState(OnHold);
-	return i;
-}
-
-int 
-Call::offHold  (void)
-{
-	int i = _voIPLink->offhold(_id);
-  setState(OffHold);
-	return i;
-}
-
-int 
-Call::transfer  (const std::string& to)
-{
-	int i = _voIPLink->transfer(_id, to);
-  setState(Transfered);
-	return i;
-}
-
-int 
-Call::refuse  (void)
-{
-	int i = _voIPLink->refuse(_id);
-	return i;
-}

src/call.h

-/**
- *  Copyright (C) 2004-2005 Savoir-Faire Linux inc.
+/*
+ *  Copyright (C) 2004-2006 Savoir-Faire Linux inc.
  *  Author: Yan Morin <yan.morin@savoirfairelinux.com>
- *  Author: Laurielle Lea <laurielle.lea@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 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.
  */
-
-#ifndef __CALL_H__
-#define __CALL_H__
+#ifndef CALL_H
+#define CALL_H
 
 #include <string>
+#include <cc++/thread.h> // for mutex
+
+//TODO: remove this, it's only for call ID
+typedef std::string CallID;
+
+/**
+	@author Yan Morin <yan.morin@gmail.com>
+  A call is the base classes for protocol-based calls
+*/
+class Call{
+public:
+    enum CallType {Incoming, Outgoing};
+    enum ConnectionState {Disconnected, Trying, Progressing, Ringing, Connected };
+    enum CallState {Inactive, Active, Hold, Busy, Refused, Error};
 
-typedef unsigned int CALLID;
+    /**
+     * Constructor of a call
+     * @param id Unique identifier of the call
+     * @param type set definitely this call as incoming/outgoing
+     */
+    Call(const CallID& id, Call::CallType type);
+    virtual ~Call();
 
+    /** 
+     * Return a reference on the call id
+     * @return call id
+     */
+    CallID& getCallId() {return _id; }
 
-class VoIPLink;
+    /** 
+     * Set the peer number (destination on outgoing)
+     * not protected by mutex (when created)
+     * @param number peer number
+     */
+    void setPeerNumber(const std::string& number) {  _peerNumber = number; }
+    const std::string& getPeerNumber() {  return _peerNumber; }
 
-class Call {
-public:
-  enum CallType {
-  	Null = 0,
-  	Incoming,
-	Outgoing
-  };
+    /** 
+     * Set the peer name (caller in ingoing)
+     * not protected by mutex (when created)
+     * @param number peer number
+     */
+    void setPeerName(const std::string& name) {  _peerName = name; }
+    const std::string& getPeerName() {  return _peerName; }
+
+    /** 
+     * Set the connection state of the call (protected by mutex)
+     */
+    void setConnectionState(ConnectionState state);
+    /** 
+     * get the connection state of the call (protected by mutex)
+     */
+    ConnectionState getConnectionState();
 
-  enum CallState {
-    NotExist = 0,
-    Busy,
-    OnHold,
-    OffHold,
-    MuteOn,
-    MuteOff,
-    Transfered,
-    Hungup,
-    Answered,
-    Ringing,
-    Progressing,
-    Refused,	// for refuse incoming ringing call	
-    Error     // when a error occur
-  };
+    /**
+     * Set the state of the call (protected by mutex)
+     */
+    void setState(CallState state);
+    /** 
+     * get the call state of the call (protected by mutex)
+     */
+    CallState getState();
 
-	// Constructor
-	Call(CALLID id, CallType type, VoIPLink* voiplink);
-	// Destructor
-	~Call(void);
-	
+protected:
+    /** Protect every attribute that can be changed by two threads */
+    ost::Mutex _callMutex;
 
-	// Handle call-id
-	CALLID getId (void);
-	void setId (CALLID id);
-	
-	// Accessor and modifior of VoIPLink
-	VoIPLink* getVoIPLink(void);
-	void setVoIPLink (VoIPLink* voIPLink);
-		
-	// Handle id name and id number
-	std::string getCallerIdName (void);
-	void setCallerIdName (const std::string& callerId_name);
-	std::string getCallerIdNumber (void);
-	void setCallerIdNumber (const std::string& callerId_number);
- 	
-	// Handle state
-	CallState getState (void);
-	void setState (CallState state);
-	
-	// Handle type of call (incoming or outoing)
-	enum CallType getType (void);
-	void setType (enum CallType type);
+private:  
+    /** Unique ID of the call */
+    CallID _id;
 
-  bool isNotAnswered(void);
-	bool isBusy			  (void);
-	bool isOnHold 		(void);
-	bool isOffHold 		(void);
-	bool isOnMute 		(void);
-	bool isOffMute 		(void);
-	bool isTransfered 	(void);
-	bool isHungup 		(void);
-	bool isRinging 		(void);
-	bool isRefused 		(void);
-	bool isAnswered 	(void);
-	bool isProgressing 	(void);
-	bool isOutgoingType (void);
-	bool isIncomingType (void);
-	
-	int outgoingCall  	(const std::string& to);
-	int hangup  		(void);
-	int cancel  		(void);
-	int answer  		(void);
-	int onHold  		(void);
-	int offHold  		(void);
-	int transfer  		(const std::string& to);
-	int refuse  		(void);
-  void setFlagNotAnswered(bool value) { _flagNotAnswered = value; }
-  bool getFlagNotAnswered() const { return _flagNotAnswered; }
+    /** Type of the call */
+    CallType _type;
+    /** Disconnected/Progressing/Trying/Ringing/Connected */
+    ConnectionState _connectionState;
+    /** Inactive/Active/Hold/Busy/Refused/Error */
+    CallState _callState;
 
-private:
-	VoIPLink		*_voIPLink;	
-	CALLID 		  	 _id;
-	enum CallState 	 _state;
-	enum CallType 	 _type;
-	std::string 			 _callerIdName;
-	std::string 			 _callerIdNumber;
+    /** Name of the peer */
+    std::string _peerName;
 
-  bool _flagNotAnswered;
+    /** Number of the peer */
+    std::string _peerNumber;
 };
 
-#endif // __CALL_H__
+#endif

src/eventthread.cpp

@@ -19,11 +19,11 @@
  */
 
 #include "eventthread.h"
-#include "sipvoiplink.h"
+#include "voIPLink.h"
 
-EventThread::EventThread (SipVoIPLink* sip) : Thread () 
+EventThread::EventThread (VoIPLink* link) : Thread () 
 {
-	_sipthread = sip;
+	_linkthread = link;
 	setCancel(cancelDeferred);
 }
 
@@ -39,7 +39,7 @@ void