sipep.h

Go to the documentation of this file.

/*
 * sipep.h
 *
 * Session Initiation Protocol endpoint.
 *
 * Open Phone Abstraction Library (OPAL)
 * Formally known as the Open H323 project.
 *
 * Copyright (c) 2001 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Open Phone Abstraction Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 32514 $
 * $Author: ededu $
 * $Date: 2014-08-13 18:51:27 +1000 (Wed, 13 Aug 2014) $
 */

#ifndef OPAL_SIP_SIPEP_H
#define OPAL_SIP_SIPEP_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#ifndef _PTLIB_H
#include <ptlib.h>
#endif

#include <opal_config.h>

#if OPAL_SIP

#include <rtp/rtpep.h>
#include <sip/sipcon.h>
#include <sip/handlers.h> 



class SIPEndPoint : public OpalRTPEndPoint
{
    PCLASSINFO(SIPEndPoint, OpalRTPEndPoint);
  public:
    SIPEndPoint(
      OpalManager & manager,
      unsigned maxThreads = 15
    );

    ~SIPEndPoint();

    virtual void ShutDown();

    virtual PString GetDefaultTransport() const;

    virtual WORD GetDefaultSignalPort() const;

    virtual PStringList GetNetworkURIs(
      const PString & name
    ) const;

    virtual void NewIncomingConnection(
      OpalListener & listener,            
      const OpalTransportPtr & transport  
    );

    virtual PSafePtr<OpalConnection> MakeConnection(
      OpalCall & call,                         
      const PString & party,                   
      void * userData,                         
      unsigned int options,                    
      OpalConnection::StringOptions * stringOptions  
    );

    virtual void OnReleased(
      OpalConnection & connection   
    );

    virtual void OnConferenceStatusChanged(
      OpalEndPoint & endpoint,  
      const PString & uri,      
      OpalConferenceState::ChangeType change 
    );

    virtual PBoolean GarbageCollection();

    virtual PStringList GetAvailableStringOptions() const;

    virtual SIPConnection * CreateConnection(
      const SIPConnection::Init & init     

    );

    virtual SDPSessionDescription * CreateSDP(
      time_t sessionId,
      unsigned version,
      const OpalTransportAddress & address
    );

    virtual PBoolean SetupTransfer(
      const PString & token,        
      const PString & callIdentity, 
      const PString & remoteParty,  
      void * userData = NULL        
    );
    
    virtual PBoolean ForwardConnection(
      SIPConnection & connection,     
      const PString & forwardParty    
    );

    bool ClearDialogContext(
      const PString & descriptor  
    );
    bool ClearDialogContext(
      SIPDialogContext & context  
    );
  

    OpalTransportPtr GetTransport(
      const SIPTransactionOwner & transactor,
      SIP_PDU::StatusCodes & reason
    );

    virtual void HandlePDU(
      const OpalTransportPtr & transport
    );

    virtual bool OnReceivedPDU(
      SIP_PDU * pdu
    );

    virtual void OnReceivedResponse(
      SIPTransaction & transaction,
      SIP_PDU & response
    );

    virtual bool OnReceivedINVITE(
      SIP_PDU * pdu
    );

    virtual bool OnReceivedNOTIFY(
      SIP_PDU & request
    );

    virtual bool OnReceivedREGISTER(
      SIP_PDU & request
    );

    virtual bool OnReceivedSUBSCRIBE(
      SIP_PDU & request,
      SIPDialogContext * dialog
    );

    virtual bool OnReceivedMESSAGE(
      SIP_PDU & request
    );

    virtual bool OnReceivedOPTIONS(
      SIP_PDU & request
    );
    
    virtual void OnTransactionFailed(
      SIPTransaction & transaction
    );
 

    PSafePtr<SIPConnection> GetSIPConnectionWithLock(
      const PString & token,     
      PSafetyMode mode = PSafeReadWrite,  
      SIP_PDU::StatusCodes * errorCode = NULL 
    );

    virtual PBoolean IsAcceptedAddress(const SIPURL & toAddr);


    bool Register(
      const SIPRegister::Params & params, 
      PString & aor,                      
      SIP_PDU::StatusCodes * reason = NULL 
    );

    // For backward compatibility
    bool Register(
      const SIPRegister::Params & params, 
      PString & aor,                      
      bool asynchronous                   
    );

    bool P_DEPRECATED Register(
      const PString & host,
      const PString & user = PString::Empty(),
      const PString & autName = PString::Empty(),
      const PString & password = PString::Empty(),
      const PString & authRealm = PString::Empty(),
      unsigned expire = 0,
      const PTimeInterval & minRetryTime = PMaxTimeInterval, 
      const PTimeInterval & maxRetryTime = PMaxTimeInterval
    );

    PBoolean IsRegistered(
      const PString & aor,          
      bool includeOffline = false   
    );

    bool Unregister(
      const PString & aor    
    );

    bool UnregisterAll();

    unsigned GetRegistrationsCount() const { return activeSIPHandlers.GetCount(SIP_PDU::Method_REGISTER); }

    PStringList GetRegistrations(
      bool includeOffline = false   
    ) const { return activeSIPHandlers.GetAddresses(includeOffline, SIP_PDU::Method_REGISTER); }

    struct RegistrationStatus {
      SIPRegisterHandler * m_handler;           
      PString              m_addressofRecord;   
      bool                 m_wasRegistering;    
      bool                 m_reRegistering;     
      SIP_PDU::StatusCodes m_reason;            
      OpalProductInfo      m_productInfo;       
      void               * m_userData;          
      friend ostream & operator<<(ostream & strm, const RegistrationStatus & status);
    };

    bool GetRegistrationStatus(
      const PString & token,          
      RegistrationStatus & status     
    );

    virtual void OnRegistrationStatus(
      const RegistrationStatus & status   
    );

    // For backward compatibility
    virtual void OnRegistrationStatus(
      const PString & aor,
      PBoolean wasRegistering,
      PBoolean reRegistering,
      SIP_PDU::StatusCodes reason
    );

    virtual void OnRegistrationFailed(
      const PString & aor,
      SIP_PDU::StatusCodes reason,
      PBoolean wasRegistering
    );

    virtual void OnRegistered(
      const PString & aor,
      PBoolean wasRegistering
    );


    bool Subscribe(
      const SIPSubscribe::Params & params, 
      PString & token,                     
      bool tokenIsAOR = true               
    );

    // For backward compatibility
    bool Subscribe(
      SIPSubscribe::PredefinedPackages eventPackage, 
      unsigned expire,                               
      const PString & aor                            
    );

    bool IsSubscribed(
      const PString & aor,           
      bool includeOffline = false    
    );
    bool IsSubscribed(
      const PString & eventPackage,  
      const PString & aor,           
      bool includeOffline = false    
    );

    bool Unsubscribe(
      const PString & aor,             
      bool invalidateNotifiers = false 
    );
    bool Unsubscribe(
      SIPSubscribe::PredefinedPackages eventPackage,  
      const PString & aor,                            
      bool invalidateNotifiers = false                
    );
    bool Unsubscribe(
      const PString & eventPackage,  
      const PString & aor,             
      bool invalidateNotifiers = false 
    );

    bool UnsubcribeAll(
      SIPSubscribe::PredefinedPackages eventPackage  
    );
    bool UnsubcribeAll(
      const PString & eventPackage  
    );

    unsigned GetSubscriptionCount(
      const SIPSubscribe::EventPackage & eventPackage  
    ) { return activeSIPHandlers.GetCount(SIP_PDU::Method_SUBSCRIBE, eventPackage); }

    PStringList GetSubscriptions(
      const SIPSubscribe::EventPackage & eventPackage, 
      bool includeOffline = false   
    ) const { return activeSIPHandlers.GetAddresses(includeOffline, SIP_PDU::Method_REGISTER, eventPackage); }

    typedef SIPSubscribe::SubscriptionStatus SubscriptionStatus;

    bool GetSubscriptionStatus(
      const PString & token,          
      const PString & eventPackage,   
      SubscriptionStatus & status     
    );

    virtual void OnSubscriptionStatus(
      const SubscriptionStatus & status   
    );

    virtual void OnSubscriptionStatus(
      const PString & eventPackage, 
      const SIPURL & uri,           
      bool wasSubscribing,          
      bool reSubscribing,           
      SIP_PDU::StatusCodes reason   
    );

    virtual void OnSubscriptionStatus(
      SIPSubscribeHandler & handler, 
      const SIPURL & uri,            
      bool wasSubscribing,           
      bool reSubscribing,            
      SIP_PDU::StatusCodes reason    
    );

    enum CanNotifyResult {
      CannotNotify,       
      CanNotifyImmediate, 
      CanNotifyDeferrred  
    };

    virtual CanNotifyResult CanNotify(
      const PString & eventPackage, 
      const SIPURL & aor            
    );

    // For backward compatobility
    virtual bool CanNotify(const PString & eventPackage);

    bool Notify(
      const SIPURL & targetAddress, 
      const PString & eventPackage, 
      const PObject & body          
    );


    virtual void OnDialogInfoReceived(
      const SIPDialogNotification & info  
    );

    void SendNotifyDialogInfo(
      const SIPDialogNotification & info  
    );


    virtual void OnRegInfoReceived(
      const SIPRegNotification & info  
    );


    bool SendMESSAGE(
      SIPMessage::Params & params
    );

    virtual void OnMESSAGECompleted(
      const SIPMessage::Params & params,
      SIP_PDU::StatusCodes reason
    );

    struct ConnectionlessMessageInfo {
      ConnectionlessMessageInfo(SIP_PDU & pdu)
        : m_pdu(pdu)
        , m_transport(*pdu.GetTransport())
        , m_status(ResponseSent)
      { }

      SIP_PDU & m_pdu;
      OpalTransport & m_transport;
      enum {
        NotHandled,
        SendOK,
        MethodNotAllowed,
        ResponseSent
      } m_status;
    };

    typedef PNotifierTemplate<ConnectionlessMessageInfo &> ConnectionlessMessageNotifier;
    #define PDECLARE_ConnectionlessMessageNotifier(cls, fn) PDECLARE_NOTIFIER2(SIPEndPoint, cls, fn, SIPEndPoint::ConnectionlessMessageInfo &)
    #define PCREATE_ConnectionlessMessageNotifier(fn) PCREATE_NOTIFIER2(fn, SIPEndPoint::ConnectionlessMessageInfo &)

    void SetConnectionlessMessageNotifier(
      const ConnectionlessMessageNotifier & notifier
    )
    { m_onConnectionlessMessage = notifier; }


    virtual bool SendOPTIONS(
      const SIPOptions::Params & params
    );

    virtual void OnOptionsCompleted(
      const SIPOptions::Params & params,    
      const SIP_PDU & response              
    );


    bool Publish(
      const SIPSubscribe::Params & params,
      const PString & body,
      PString & aor
    );
    bool Publish(
      const PString & to,   
      const PString & body, 
      unsigned expire = 300 
    );

    PStringList GetPublications(
      const SIPSubscribe::EventPackage & eventPackage, 
      bool includeOffline = false   
    ) const { return activeSIPHandlers.GetAddresses(includeOffline, SIP_PDU::Method_PUBLISH, eventPackage); }


#if OPAL_SIP_PRESENCE

    bool PublishPresence(
      const SIPPresenceInfo & info,  
      unsigned expire = 300          
    );
    
    virtual void OnPresenceInfoReceived (
      const SIPPresenceInfo & info  
    );
    virtual void OnPresenceInfoReceived (
      const PString & identity,
      const PString & basic,
      const PString & note
    );
#endif // OPAL_SIP_PRESENCE


    PBoolean Ping(
      const PURL & to
    );

    const PStringSet & GetAllowedEvents() const { return m_allowedEvents; }

    SIPConnection::PRACKMode GetDefaultPRACKMode() const { return m_defaultPrackMode; }

    void SetDefaultPRACKMode(SIPConnection::PRACKMode mode) { m_defaultPrackMode = mode; }

    void SetMaxPacketSizeUDP(PINDEX sz) { m_maxPacketSizeUDP = sz; }
    PINDEX GetMaxPacketSizeUDP() const { return m_maxPacketSizeUDP; }

    void SetMaxRetries(unsigned r) { maxRetries = r; }
    unsigned GetMaxRetries() const { return maxRetries; }

    void SetRetryTimeouts(
      const PTimeInterval & t1,
      const PTimeInterval & t2
    ) { retryTimeoutMin = t1; retryTimeoutMax = t2; }
    const PTimeInterval & GetRetryTimeoutMin() const { return retryTimeoutMin; }
    const PTimeInterval & GetRetryTimeoutMax() const { return retryTimeoutMax; }

    void SetNonInviteTimeout(
      const PTimeInterval & t
    ) { nonInviteTimeout = t; }
    const PTimeInterval & GetNonInviteTimeout() const { return nonInviteTimeout; }

    void SetPduCleanUpTimeout(
      const PTimeInterval & t
    ) { pduCleanUpTimeout = t; }
    const PTimeInterval & GetPduCleanUpTimeout() const { return pduCleanUpTimeout; }

    void SetInviteTimeout(
      const PTimeInterval & t
    ) { inviteTimeout = t; }
    const PTimeInterval & GetInviteTimeout() const { return inviteTimeout; }

    void SetProgressTimeout(
      const PTimeInterval & t
    ) { m_progressTimeout = t; }
    const PTimeInterval & GetProgressTimeout() const { return m_progressTimeout; }

    void SetAckTimeout(
      const PTimeInterval & t
    ) { ackTimeout = t; }
    const PTimeInterval & GetAckTimeout() const { return ackTimeout; }

    void SetRegistrarTimeToLive(
      const PTimeInterval & t
    ) { registrarTimeToLive = t; }
    const PTimeInterval & GetRegistrarTimeToLive() const { return registrarTimeToLive; }
    
    void SetNotifierTimeToLive(
      const PTimeInterval & t
    ) { notifierTimeToLive = t; }
    const PTimeInterval & GetNotifierTimeToLive() const { return notifierTimeToLive; }
    
    P_DEPRECATED void SetNATBindingTimeout(
      const PTimeInterval & t
    ) { m_keepAliveTimeout = t; }
    P_DEPRECATED const PTimeInterval & GetNATBindingTimeout() const { return m_keepAliveTimeout; }

    enum KeepAliveType {
      NoKeepAlive,
      KeepAliveByCRLF,
      KeepAliveByOPTION,
      NumMethods
    };
    void GetKeepAlive(
      PTimeInterval & timeout,
      KeepAliveType & type
    ) { timeout = m_keepAliveTimeout; type = m_keepAliveType; }
    void SetKeepAlive(
      const PTimeInterval & timeout,
      KeepAliveType type
    ) { m_keepAliveTimeout = timeout; m_keepAliveType = type; }


    void AddTransaction(
      SIPTransaction * transaction
    ) { m_transactions.Append(transaction); }

    PSafePtr<SIPTransaction> GetTransaction(const PString & transactionID, PSafetyMode mode = PSafeReadWrite)
    { return PSafePtrCast<SIPTransactionBase, SIPTransaction>(m_transactions.FindWithLock(transactionID, mode)); }
    
    unsigned GetNextCSeq() { return ++m_lastSentCSeq; }

    void SetRegisteredUserMode(bool v) { m_registeredUserMode = v; }
    bool GetRegisteredUserMode() const { return m_registeredUserMode; }

    bool GetAuthentication(
      const PString & realm,
      PString & authId,
      PString & password
    );
    
    virtual SIPURL GetDefaultLocalURL(const OpalTransport & transport);
    
    void AdjustToRegistration(
      SIP_PDU & pdu,
      SIPConnection * connection = NULL,
      const OpalTransport * transport = NULL
    );


    const SIPURL & GetProxy() const { return m_proxy; }

    void SetProxy(const SIPURL & url);
    
    void SetProxy(
      const PString & hostname,
      const PString & username,
      const PString & password
    );

    
    int GetDefaultAppearanceCode() const { return m_defaultAppearanceCode; }

    void SetDefaultAppearanceCode(int code) { m_defaultAppearanceCode = code; }

    virtual PString GetUserAgent() const;
        
    void SetUserAgent(const PString & str) { m_userAgentString = str; }


    virtual unsigned GetAllowedMethods() const;


    typedef KeepAliveType NATBindingRefreshMethod;
    P_DEPRECATED void SetNATBindingRefreshMethod(const NATBindingRefreshMethod type) { SetKeepAlive(m_keepAliveTimeout, type); }

    virtual SIPRegisterHandler * CreateRegisterHandler(const SIPRegister::Params & params);

    virtual void OnStartTransaction(SIPConnection & conn, SIPTransaction & transaction);


    PSafePtr<SIPHandler> FindSIPHandlerByCallID(const PString & callID, PSafetyMode m)
      { return activeSIPHandlers.FindSIPHandlerByCallID(callID, m); }

    void UpdateHandlerIndexes(SIPHandler * handler)
      { activeSIPHandlers.Update(handler); }


    SIPThreadPool & GetThreadPool() { return m_threadPool; }


  protected:
    void AddTransport(const OpalTransportPtr & transport);
    void TransportThreadMain(OpalTransportPtr transport);

    SIPURL        m_proxy;
    PString       m_userAgentString;
    PStringSet    m_allowedEvents;

    SIPConnection::PRACKMode m_defaultPrackMode;

    PINDEX        m_maxPacketSizeUDP;
    unsigned      maxRetries;
    PTimeInterval retryTimeoutMin;   // T1
    PTimeInterval retryTimeoutMax;   // T2
    PTimeInterval nonInviteTimeout;  // T3
    PTimeInterval pduCleanUpTimeout; // T4
    PTimeInterval inviteTimeout;
    PTimeInterval m_progressTimeout;
    PTimeInterval ackTimeout;
    PTimeInterval registrarTimeToLive;
    PTimeInterval notifierTimeToLive;
    PTimeInterval m_keepAliveTimeout;
    KeepAliveType m_keepAliveType;
    bool          m_registeredUserMode;
    bool          m_shuttingDown;

    // Transport management
    PSafeDictionary<OpalTransportAddress, OpalTransport> m_transportsTable;

    // Sub-protocol handlers
    SIPHandlersList   activeSIPHandlers;
    PSafePtr<SIPHandler> FindHandlerByPDU(const SIP_PDU & pdu, PSafetyMode mode);

    PStringToString   m_receivedConnectionTokens;
    PMutex            m_receivedConnectionMutex;

    PSafeSortedList<SIPTransactionBase> m_transactions;

    PAtomicInteger m_lastSentCSeq;
    int            m_defaultAppearanceCode;

    struct RegistrationCompletion {
      PSyncPoint           m_sync;
      SIP_PDU::StatusCodes m_reason;
      RegistrationCompletion() : m_reason(SIP_PDU::Information_Trying) { }
    };
    std::map<PString, RegistrationCompletion> m_registrationComplete;

    ConnectionlessMessageNotifier m_onConnectionlessMessage;
    typedef std::multimap<PString, SIPURL> ConferenceMap;
    ConferenceMap m_conferenceAOR;

    // Thread pooling
    SIPThreadPool m_threadPool;

    // Network interface checking
    PDECLARE_InterfaceNotifier(SIPEndPoint, OnHighPriorityInterfaceChange);
    PDECLARE_InterfaceNotifier(SIPEndPoint, OnLowPriorityInterfaceChange);
    PInterfaceMonitor::Notifier m_onHighPriorityInterfaceChange;
    PInterfaceMonitor::Notifier m_onLowPriorityInterfaceChange;

    bool m_disableTrying;

    P_REMOVE_VIRTUAL_VOID(OnReceivedIntervalTooBrief(SIPTransaction &, SIP_PDU &));
    P_REMOVE_VIRTUAL_VOID(OnReceivedAuthenticationRequired(SIPTransaction &, SIP_PDU &));
    P_REMOVE_VIRTUAL_VOID(OnReceivedOK(SIPTransaction &, SIP_PDU &));
    P_REMOVE_VIRTUAL_VOID(OnMessageFailed(const SIPURL &, SIP_PDU::StatusCodes));
    P_REMOVE_VIRTUAL(SIPConnection *,CreateConnection(OpalCall &, const PString &, void *, const SIPURL &, OpalTransport *, SIP_PDU *, unsigned, OpalConnection::StringOptions *), NULL);
    P_REMOVE_VIRTUAL(PBoolean, OnReceivedPDU(OpalTransport &, SIP_PDU *), false);
    P_REMOVE_VIRTUAL(bool, OnReceivedConnectionlessPDU(OpalTransport &,  SIP_PDU *), false);
    P_REMOVE_VIRTUAL(bool, OnReceivedConnectionlessPDU(SIP_PDU *), false);
    P_REMOVE_VIRTUAL(PBoolean, OnReceivedINVITE(OpalTransport &, SIP_PDU *), false);
    P_REMOVE_VIRTUAL(PBoolean, OnReceivedNOTIFY(OpalTransport &, SIP_PDU &), false);
    P_REMOVE_VIRTUAL(PBoolean, OnReceivedREGISTER(OpalTransport &, SIP_PDU &), false);
    P_REMOVE_VIRTUAL(PBoolean, OnReceivedSUBSCRIBE(OpalTransport &, SIP_PDU &, SIPDialogContext *), false);
    P_REMOVE_VIRTUAL(bool, OnReceivedMESSAGE(OpalTransport &, SIP_PDU &), false);
    P_REMOVE_VIRTUAL(bool, OnReceivedOPTIONS(OpalTransport &, SIP_PDU &), false);
};


#endif // OPAL_SIP

#endif // OPAL_SIP_SIPEP_H


// End of File ///////////////////////////////////////////////////////////////