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: 24764 $
 * $Author: rjongbloed $
 * $Date: 2010-09-30 01:52:18 -0500 (Thu, 30 Sep 2010) $
 */

#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/buildopts.h>

#if OPAL_SIP

#include <ptclib/threadpool.h>
#include <opal/rtpep.h>
#include <sip/sipcon.h>
#include <sip/sippdu.h>
#include <sip/handlers.h> 

#if OPAL_HAS_SIPIM
#include <im/sipim.h>
#endif

class SIPRegisterHandler;


//
//  provide flag so applications know if presence is available
//
#define OPAL_HAS_SIP_PRESENCE   1


class SIPAuthInfo : public PObject
{
  public:
    SIPAuthInfo()
    { }

    SIPAuthInfo(const PString & u, const PString & p)
    { username = u; password = p; }
    PString username;
    PString password;
};


class SIPEndPoint : public OpalRTPEndPoint
{
  PCLASSINFO(SIPEndPoint, OpalRTPEndPoint);

  public:
    SIPEndPoint(
      OpalManager & manager
    );

    ~SIPEndPoint();

    virtual void ShutDown();

    virtual PString GetDefaultTransport() const;

    virtual PBoolean NewIncomingConnection(
      OpalTransport * transport  
    );

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

    virtual void OnReleased(
      OpalConnection & connection   
    );

    virtual PBoolean GarbageCollection();

    virtual SIPConnection * CreateConnection(
      OpalCall & call,                         
      const PString & token,                   
      void * userData,                         
      const SIPURL & destination,              
      OpalTransport * transport,               
      SIP_PDU * invite,                        
      unsigned int options = 0,                
      OpalConnection::StringOptions * stringOptions = NULL 

    );
    
    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  
    );
  

    OpalTransport * CreateTransport(
      const SIPURL & remoteURL,
      const PString & localInterface = PString::Empty()
    );

    virtual void HandlePDU(
      OpalTransport & transport
    );

    virtual PBoolean OnReceivedPDU(
      OpalTransport & transport,
      SIP_PDU * pdu
    );

    virtual bool OnReceivedConnectionlessPDU(
      OpalTransport & transport, 
      SIP_PDU * pdu
    );

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

    virtual PBoolean OnReceivedINVITE(
      OpalTransport & transport,
      SIP_PDU * pdu
    );

    virtual PBoolean OnReceivedNOTIFY(
      OpalTransport & transport,
      SIP_PDU & response
    );

    virtual PBoolean OnReceivedREGISTER(
      OpalTransport & transport, 
      SIP_PDU & pdu
    );

    virtual PBoolean OnReceivedSUBSCRIBE(
      OpalTransport & transport, 
      SIP_PDU & pdu
    );

    virtual bool OnReceivedMESSAGE(
      OpalTransport & transport,
      SIP_PDU & response
    );

    virtual bool OnReceivedOPTIONS(
      OpalTransport & transport,
      SIP_PDU & response
    );
    
    virtual void OnTransactionFailed(
      SIPTransaction & transaction
    );
    
    virtual void OnRTPStatistics(
      const SIPConnection & connection,  
      const RTP_Session & session         
    ) const;
 

    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,                      
      bool asynchronous = true            
    );

    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;          
    };

    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 Unsubscribe(
      SIPSubscribe::PredefinedPackages eventPackage,  
      const PString & aor                             
    );
    bool Unsubscribe(
      const PString & eventPackage,  
      const PString & aor            
    );

    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;

    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    
    );

    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 PBoolean Message(
      const PURL & to, 
      const PString & type,
      const PString & body,
      PURL & from, 
      PString & conversationId
    );
    virtual PBoolean Message(
      OpalIM & message
    );

    virtual void OnMessageFailed(
      const SIPURL & messageUrl,
      SIP_PDU::StatusCodes reason
    );


    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); }


    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
    );


    PBoolean Ping(
      const PURL & to
    );

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

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

    void SetMIMEForm(PBoolean v) { mimeForm = v; }
    PBoolean GetMIMEForm() const { return mimeForm; }

    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; }
    
    void SetNATBindingTimeout(
      const PTimeInterval & t
    ) { natBindingTimeout = t; natBindingTimer.RunContinuous (natBindingTimeout); }
    const PTimeInterval & GetNATBindingTimeout() const { return natBindingTimeout; }

    void AddTransaction(
      SIPTransaction * transaction
    ) { transactions.SetAt(transaction->GetTransactionID(), transaction); }

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

    bool GetAuthentication(const PString & authRealm, PString & user, PString & password); 
    
    virtual SIPURL GetRegisteredProxy(const SIPURL & remoteURL);

    virtual SIPURL GetRegisteredPartyName(const SIPURL & remoteURL, const OpalTransport & transport);


    virtual SIPURL GetDefaultRegisteredPartyName(const OpalTransport & transport);
    

    SIPURL GetContactURL(const OpalTransport &transport, const SIPURL & localURI);


    virtual SIPURL GetLocalURL(
       const OpalTransport & transport,             
       const PString & userName = PString::Empty()  
    );
    
    
    const SIPURL & GetProxy() const { return 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) { userAgentString = str; }


    virtual unsigned GetAllowedMethods() const;


    enum NATBindingRefreshMethod{
      None,
      Options,
      EmptyRequest,
      NumMethods
    };


    void SetNATBindingRefreshMethod(const NATBindingRefreshMethod m) { natMethod = m; }

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

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

#if OPAL_HAS_SIPIM
    virtual OpalSIPIMManager & GetSIPIMManager() { return m_sipIMManager; }
#endif

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

  protected:
    PDECLARE_NOTIFIER(PThread, SIPEndPoint, TransportThreadMain);
    PDECLARE_NOTIFIER(PTimer, SIPEndPoint, NATBindingRefresh);

    SIPURL        proxy;
    PString       userAgentString;

    SIPConnection::PRACKMode m_defaultPrackMode;

    bool          mimeForm;
    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 natBindingTimeout;

    bool              m_shuttingDown;
    SIPHandlersList   activeSIPHandlers;
    PStringToString   m_receivedConnectionTokens;

    PSafeDictionary<PString, SIPTransaction> transactions;

    PTimer                  natBindingTimer;
    NATBindingRefreshMethod natMethod;
    PAtomicInteger          lastSentCSeq;
    int                     m_defaultAppearanceCode;

    std::map<PString, PSyncPoint> m_registrationComplete;

  public:
    class WorkThreadPool;
    class SIP_Work
    {
      public:
        SIP_Work(SIPEndPoint & ep, SIP_PDU * pdu, const PString & token);
        virtual ~SIP_Work();

        virtual void Process();

        SIPEndPoint & m_endpoint;
        SIP_PDU     * m_pdu;
        PString       m_token;
    };

    class WorkThreadPool : public PThreadPool<SIP_Work>
    {
      public:
        virtual WorkerThreadBase * CreateWorkerThread();
    } m_connectionThreadPool, m_handlerThreadPool;

  protected:
    typedef std::queue<SIP_Work *> SIP_WorkQueue;

    class SIP_Work_Thread : public WorkThreadPool::WorkerThread
    {
      public:
        SIP_Work_Thread(WorkThreadPool & pool_);

        void AddWork(SIP_Work * work);
        void RemoveWork(SIP_Work * work);
        unsigned GetWorkSize() const;

        void Main();
        void Shutdown();

      protected:
        PSyncPoint m_sync;
        SIP_WorkQueue m_pduQueue;
    };

    enum {
      HighPriority = 80,
      LowPriority  = 30,
    };
    class InterfaceMonitor : public PInterfaceMonitorClient
    {
        PCLASSINFO(InterfaceMonitor, PInterfaceMonitorClient);
      public:
        InterfaceMonitor(SIPEndPoint & manager, PINDEX priority);
        
        virtual void OnAddInterface(const PIPSocket::InterfaceEntry & entry);
        virtual void OnRemoveInterface(const PIPSocket::InterfaceEntry & entry);

      protected:
        SIPEndPoint & m_endpoint;
    };
    InterfaceMonitor m_highPriorityMonitor;
    InterfaceMonitor m_lowPriorityMonitor;

    friend void InterfaceMonitor::OnAddInterface(const PIPSocket::InterfaceEntry & entry);
    friend void InterfaceMonitor::OnRemoveInterface(const PIPSocket::InterfaceEntry & entry);

#if OPAL_HAS_SIPIM
    OpalSIPIMManager m_sipIMManager;
#endif

    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 &));

  public:
    struct ConnectionlessMessageInfo {
      ConnectionlessMessageInfo(OpalTransport & transport, SIP_PDU & pdu)
        : m_pdu(pdu), m_transport(transport), m_status(true)
      { }

      SIP_PDU & m_pdu;
      OpalTransport & m_transport;
      bool 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; }

  protected:
    ConnectionlessMessageNotifier m_onConnectionlessMessage;
};


#endif // OPAL_SIP

#endif // OPAL_SIP_SIPEP_H


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

---