SipUserAgent.h

Go to the documentation of this file.

//
// Copyright (C) 2004-2006 SIPfoundry Inc.
// Licensed by SIPfoundry under the LGPL license.
//
// Copyright (C) 2004-2006 Pingtel Corp.  All rights reserved.
// Licensed to SIPfoundry under a Contributor Agreement.
//
// $$


#ifndef _SipUserAgent_h_
#define _SipUserAgent_h_

// SYSTEM INCLUDES
//#include <...>

// APPLICATION INCLUDES
#include <utl/UtlHashBag.h>
#include <os/OsServerTask.h>
#include <net/SipUserAgentBase.h>
#include <net/SipMessage.h>
#include <net/SipMessageEvent.h>
#include <net/SipTransaction.h>
#include <net/SipTransactionList.h>
#include <net/SipUdpServer.h>
#include <os/OsQueuedEvent.h>
#ifdef SIP_TLS
#include <net/SipTlsServer.h>
#include <os/OsTLS.h>
#endif
#include <os/OsNatKeepaliveListener.h>

// DEFINES
#define SIP_DEFAULT_RTT     500
#define SIP_MINIMUM_RTT     100
#define SIP_MAX_PORT_RANGE  10  // If a port is in use and the sip user agent 
                                // is created with bUseNextAvailablePort set to
                                // true, this is the number of sequential ports
                                // to try.

// proxy, registrar, etc. UDP socket buffer size
#define SIPUA_DEFAULT_SERVER_UDP_BUFFER_SIZE 1000000

// proxy, registrar, etc. OsServerTask OsMsg queue size
#define SIPUA_DEFAULT_SERVER_OSMSG_QUEUE_SIZE 10000

// MACROS
// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// STRUCTS
// TYPEDEFS
// FORWARD DECLARATIONS
class OsConfigDb;
class OsQueuedEvent;
class OsTimer;
class SipSession;
class SipTcpServer;
class SipLineMgr;
class SipUserAgentBase;


class SipUserAgent : public SipUserAgentBase 
#ifdef SIP_TLS
                     , public ITlsSink
#endif 
{
/* //////////////////////////// PUBLIC //////////////////////////////////// */
public:

    friend class SipTransaction;
    friend class SipUdpServer;
    friend int SipUdpServer::run(void* runArg);

    enum EventSubTypes
    {
        UNSPECIFIED = 0,
        SHUTDOWN_MESSAGE = 10,
        KEEPALIVE_MESSAGE
    };

/* ============================ CREATORS ================================== */


    SipUserAgent(int sipTcpPort = SIP_PORT,
                int sipUdpPort = SIP_PORT,
                int sipTlsPort = SIP_PORT+1,
                const char* publicAddress = NULL,
                const char* defaultUser = NULL,
                const char* defaultSipAddress = NULL,
                const char* sipProxyServers = NULL,
                const char* sipDirectoryServers = NULL,
                const char* sipRegistryServers = NULL,
                const char* authenticationScheme = NULL,
                const char* authenicateRealm = NULL,
                OsConfigDb* authenticateDb = NULL,
                OsConfigDb* authorizeUserIds = NULL,
                OsConfigDb* authorizePasswords = NULL,
                SipLineMgr* lineMgr = NULL,
                int sipFirstResendTimeout = SIP_DEFAULT_RTT,
                UtlBoolean defaultToUaTransactions = TRUE,
                int readBufferSize = -1,
                int queueSize = OsServerTask::DEF_MAX_MSGS,
                UtlBoolean bUseNextAvailablePort = FALSE,
                UtlString certNickname = "",
                UtlString certPassword = "",
                UtlString dbLocation = ".",
                UtlBoolean doUaMessageChecks = TRUE);

    virtual
    ~SipUserAgent();

/* ============================ MANIPULATORS ============================== */


    void shutdown(UtlBoolean blockingShutdown = TRUE);

    virtual void enableStun(const char* szStunServer, 
                            int iStunPort,
                            int refreshPeriodInSecs, 
                            OsNotification* pNotification = NULL,
                            const char* szIp = NULL) ;

    virtual UtlBoolean handleMessage(OsMsg& eventMessage);

    virtual void addMessageConsumer(OsServerTask* messageConsumer);


    void addMessageObserver(OsMsgQ& messageQueue,
                              const char* sipMethod = NULL,
                              UtlBoolean wantRequests = TRUE,
                              UtlBoolean wantResponses = TRUE,
                              UtlBoolean wantIncoming = TRUE,
                              UtlBoolean wantOutGoing = FALSE,
                              const char* eventName = NULL,
                              SipSession* pSession = NULL,
                              void* observerData = NULL);



    UtlBoolean removeMessageObserver(OsMsgQ& messageQueue,
                                    void* pObserverData = NULL);


    virtual UtlBoolean send(SipMessage& message,
                            OsMsgQ* responseListener = NULL,
                            void* responseListenerData = NULL,
                            SIPX_TRANSPORT_DATA* pTransport = NULL);


    virtual void dispatch(SipMessage* message,
                          int messageType = SipMessageEvent::APPLICATION,
                          SIPX_TRANSPORT_DATA* pData = NULL);

    void allowMethod(const char* methodName, const bool bAllow = true);

    void allowExtension(const char* extension);

    void getSupportedExtensions(UtlString& extensionsString);


    void setProxyServers(const char* sipProxyServers);


    UtlBoolean addCrLfKeepAlive(const char* szLocalIp,
                                const char* szRemoteIp,
                                const int   remotePort,
                                const int   keepAliveSecs,
                                OsNatKeepaliveListener* pListener) ;

    UtlBoolean removeCrLfKeepAlive(const char* szLocalIp,
                                   const char* szRemoteIp,
                                   const int   remotePort) ;
 
    UtlBoolean addStunKeepAlive(const char* szLocalIp,
                                const char* szRemoteIp,
                                const int   remotePort,
                                const int   keepAliveSecs,
                                OsNatKeepaliveListener* pListener) ;

    UtlBoolean removeStunKeepAlive(const char* szLocalIp,
                                   const char* szRemoteIp,
                                   const int   remotePort) ;

    OsTimer* getTimer() { return mpTimer; }

    UtlBoolean addSipKeepAlive(const char* szLocalIp,
                               const char* szRemoteIp,
                               const int   remotePort,
                               const char* szMethod,
                               const int   keepAliveSecs,
                               OsNatKeepaliveListener* pListener) ;

    UtlBoolean removeSipKeepAlive(const char* szLocalIp,
                                  const char* szRemoteIp,
                                  const int   remotePort,
                                  const char* szMethod) ;

/* ============================ ACCESSORS ================================= */

    UtlBoolean setUseRport(UtlBoolean bEnable) ;

    UtlBoolean getUseRport() const ;

    void setUseRportMapping(UtlBoolean bEnable);

    UtlBoolean getUseRportMapping() const;

    UtlBoolean getConfiguredPublicAddress(UtlString* pIpAddress, int* pPort) ;

    UtlBoolean getLocalAddress(UtlString* pIpAddress,
                               int* pPort,
                               SIPX_TRANSPORT_TYPE protocol = TRANSPORT_UDP) ;

    UtlBoolean getNatMappedAddress(UtlString* pIpAddress, int* pPort) ;

    void setIsUserAgent(UtlBoolean isUserAgent);

    void setUserAgentHeaderProperty( const char* property );
    void setMaxForwards(int maxForwards);

    int getMaxForwards();

    void setForking(UtlBoolean enabled);

    void getFromAddress(UtlString* address, int* port, UtlString* protocol);

    void getViaInfo(int         protocol,
                    UtlString&  address,
                    int&        port,
                    const char* pszTargetAddress,
                    const int*  piTargetPort);

    void getDirectoryServer(int index, UtlString* address,
                            int* port, UtlString* protocol);

    void getProxyServer(int index, UtlString* address,
                        int* port, UtlString* protocol);

    void printStatus();

    void startMessageLog(int newMaximumLogSize = 0);

    void stopMessageLog();

    void clearMessageLog();

    virtual void logMessage(const char* message, int messageLength);

    void getMessageLog(UtlString& logData);

    int getSipStateTransactionTimeout();

    int getDefaultExpiresSeconds() const;
    
    const int getRegisterResponseTimeout() const { return mRegisterTimeoutSeconds; }
    void setRegisterResponseTimeout(const int seconds) { mRegisterTimeoutSeconds = seconds; }

    void setDefaultExpiresSeconds(int expiresSeconds);

    int getDefaultSerialExpiresSeconds() const;

    void setLocationHeader(const char* szHeader);

    void setIncludePlatformInUserAgentName(const bool bInclude);
    
    void setDefaultSerialExpiresSeconds(int expiresSeconds);

    void setMaxTcpSocketIdleTime(int idleTimeSeconds);

    int getMaxSrvRecords() const;

    void setMaxSrvRecords(int numRecords);

    int getDnsSrvTimeout();

    void setDnsSrvTimeout(int timeout);


    void setHostAliases(UtlString& aliases);

    void setRecurseOnlyOne300Contact(UtlBoolean recurseOnlyOne);
    /***< @note this is a 300 not 3xx class response.@endnote */

    void setReturnViasForMaxForwards(UtlBoolean returnVias);


    SipMessage* getRequest(const SipMessage& response);

    int getUdpPort() const ;

    int getTcpPort() const ;

    int getTlsPort() const ;
      
    void setUserAgentName(const UtlString& name);

    const UtlString& getUserAgentName() const;

    
    void setHeaderOptions(const bool bAllowHeader,
                          const bool bDateHeader,
                          const bool bShortNames,
                          const UtlString& acceptLanguage);                                   

    bool getEnabledShortNames()
        {return mbShortNames;}
     // Return enabled state of short names

    void setEnableLocationHeader(const bool bLocationHeader)
        {mbUseLocationHeader=bLocationHeader;}
     // Set if location header is enabled or not


    void stopTransactionTimers() { mSipTransactions.stopTransactionTimers(); }
    void startTransactionTimers() { mSipTransactions.startTransactionTimers(); }                                       

/* ============================ INQUIRY =================================== */

    virtual UtlBoolean isMessageLoggingEnabled();

    virtual UtlBoolean isReady();
    //: Return boolean if the UA is started and initialized

    virtual UtlBoolean waitUntilReady();
    //: Block and wait until the UA is started and initialized

    UtlBoolean isMethodAllowed(const char* method);

    UtlBoolean isExtensionAllowed(const char* extension) const;

    UtlBoolean isForkingEnabled();

    UtlBoolean isMyHostAlias(Url& route) const;

    UtlBoolean recurseOnlyOne300Contact();

    UtlBoolean isOk(OsSocket::IpProtocolSocketType socketType);


    UtlBoolean isShutdownDone();

    void setUserAgentHeader(SipMessage& message);

    void setServerHeader(SipMessage& message);

    void setSelfHeader(SipMessage& message);

    SipContactDb& getContactDb() { return mContactDb; }

    const bool addContactAddress(SIPX_CONTACT_ADDRESS& contactAddress);
    
    void getContactAddresses(SIPX_CONTACT_ADDRESS* pContacts[], int &numContacts);

    void prepareVia(SipMessage&          message,
                    UtlString&           branchId, 
                    OsSocket::IpProtocolSocketType& toProtocol,
                    const char*          szTargetAddress, 
                    const int*           piTargetPort,
                    SIPX_TRANSPORT_DATA* pTransport = NULL) ;

#ifdef SIP_TLS    
    SipTlsServer* getTlsServer() { return mSipTlsServer; }
    // ITlsSink implementation
    bool onServerCertificate(void* pCert, char* serverHostName);
    bool onTlsEvent(int cause);
#endif

    void addExternalTransport(const UtlString tranportName, const SIPX_TRANSPORT_DATA* const pTransport);
    void removeExternalTransport(const UtlString transportName, const SIPX_TRANSPORT_DATA* const pTransport);
    const SIPX_TRANSPORT_DATA* const lookupExternalTransport(const UtlString transportName, const UtlString ipAddress) const;
    
/* //////////////////////////// PROTECTED ///////////////////////////////// */
protected:
    void prepareContact(SipMessage& message, 
                        const char* szTargetAddress, 
                        const int*  piTargetPort) ;

    void selfHeaderValue(UtlString& self);

    void getAllowedMethods(UtlString* allowedMethods);

    void whichExtensionsNotAllowed(const SipMessage* message,
                                   UtlString* disallowedExtensions) const;

    UtlBoolean checkMethods(SipMessage* message);

    UtlBoolean checkExtensions(SipMessage* message);

    UtlBoolean sendStatelessResponse(SipMessage& response);

    UtlBoolean sendStatelessRequest(SipMessage& request,
                                    UtlString& address,
                                    int port,
                                    OsSocket::IpProtocolSocketType protocol,
                                    UtlString& branchId);

    UtlBoolean sendTls(SipMessage* message,
                       const char* serverAddress,
                       int port);

    UtlBoolean sendTcp(SipMessage* message,
                       const char* serverAddress,
                       int port);

    UtlBoolean sendUdp(SipMessage* message,
                       const char* serverAddress,
                       int port);

    UtlBoolean sendCustom(SIPX_TRANSPORT_DATA* pTransport, 
                          SipMessage* message, 
                          const char* sendAddress, 
                          const int sendPort);                       

    UtlBoolean sendSymmetricUdp(SipMessage& message,
                                const char* serverAddress,
                                int         port);

    void lookupSRVSipAddress(UtlString protocol,
                             UtlString& sipAddress,
                             int& port,
                             UtlString& srcIp);

    int getReliableTransportTimeout();

    int getFirstResendTimeout();

    int getLastResendTimeout();

    UtlBoolean shouldAuthenticate(SipMessage* message) const;

    UtlBoolean authorized(SipMessage* request,
                          const char* uri = NULL) const;

    void addAuthentication(SipMessage* message) const;

    UtlBoolean resendWithAuthorization(SipMessage* response,
                                       SipMessage* request,
                                       int* messageType,
                                       int authorizationEntity);
   
/* //////////////////////////// PRIVATE /////////////////////////////////// */
private:

    SipTcpServer* mSipTcpServer;
    SipUdpServer* mSipUdpServer;
#ifdef SIP_TLS
    SipTlsServer* mSipTlsServer;
#endif
    SipTransactionList mSipTransactions;
    UtlString defaultSipUser;
    UtlString defaultSipAddress;
    UtlString proxyServers;
    UtlString directoryServers;
    UtlString registryServers;
    int registryPeriod;
    int lastRegisterSeqNum;
    UtlString registerCallId;
    UtlString sipIpAddress;
    UtlString mConfigPublicAddress ;
    int mSipPort;
    UtlDList allowedSipMethods;
    UtlDList allowedSipExtensions;
    UtlString mUserAgentHeaderProperties;
    UtlHashBag mMyHostAliases;
    UtlHashBag mMessageObservers;
    UtlHashMap mExternalTransports;
    OsRWMutex mMessageLogRMutex;
    OsRWMutex mMessageLogWMutex;
    
    //times
    int mFirstResendTimeoutMs; //intialtimeout
    int mLastResendTimeoutMs; //timeout between last 2 resends
    int mReliableTransportTimeoutMs;//TCP timeout
    int mTransactionStateTimeoutMs;//transaction timeout
    int mDefaultExpiresSeconds; // Seconds
    int mDefaultSerialExpiresSeconds;
    int mMinInviteTransactionTimeout; // INVITE tx must live longer so the phone can ring
    int mMaxTcpSocketIdleTime; // time after which unused TCP sockets are removed
    int mMaxSrvRecords; // Max num of DNS SRV records to use before giving up
    int mDnsSrvTimeout; // second to give up & try the next DNS SRV record

    SipMessage* mpLastSipMessage;
    UtlString defaultUserAgentName;
    long mLastCleanUpTime;
    UtlString mAuthenticationScheme;
    UtlString mAuthenticationRealm;
    OsConfigDb* mpAuthenticationDb;
    OsConfigDb* mpAuthorizationUserIds;
    OsConfigDb* mpAuthorizationPasswords;
    SipLineMgr* mpLineMgr;
    int mMaxMessageLogSize;
    UtlString mMessageLog;
    UtlString mLocationHeader;
    UtlBoolean mIsUaTransactionByDefault;
    UtlBoolean mForkingEnabled;
    int mMaxForwards;
    UtlBoolean mRecurseOnlyOne300Contact;
    UtlBoolean mReturnViasForMaxForwards;
    UtlBoolean mbUseRport;
    UtlBoolean mUseRportMapping; // use Rport IP and port for contact database
    UtlBoolean mbUseLocationHeader;
    bool mbIncludePlatformInUserAgentName;  // whether or not the platform name should
                                            // be appended to the user agent name

    UtlBoolean mDoUaMessageChecks;

    void garbageCollection();

    void queueMessageToInterestedObservers(SipMessageEvent& event,
                                           const UtlString& method);
    void queueMessageToObservers(SipMessage* message,
                                 int messageType);

    OsTimer* mpTimer;

    UtlBoolean mbShuttingDown;
    UtlBoolean mbShutdownDone;
    UtlBoolean mbBlockingShutdown;
    
    bool mbAllowHeader;
    bool mbDateHeader;
    bool mbShortNames;
    UtlString mAcceptLanguage;

    int mRegisterTimeoutSeconds;    

    SipUserAgent(const SipUserAgent& rSipUserAgent);

    SipUserAgent& operator=(const SipUserAgent& rhs);

};

/* ============================ INLINE METHODS ============================ */

#endif  // _SipUserAgent_h_