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: 21288 $
 * $Author: dsandras $
 * $Date: 2008-10-12 14:50:25 +0000 (Sun, 12 Oct 2008) $
 */

#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/sockagg.h>
#include <opal/rtpep.h>
#include <sip/sipcon.h>
#include <sip/sippdu.h>
#include <sip/handlers.h> 


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 PBoolean MakeConnection(
      OpalCall & call,                         
      const PString & party,                   
      void * userData,                         
      unsigned int options,                    
      OpalConnection::StringOptions * stringOptions  
    );

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

  

    OpalTransport * CreateTransport(
      const OpalTransportAddress & remoteAddress,
      const OpalTransportAddress & localAddress = OpalTransportAddress()
    );

    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 void OnReceivedIntervalTooBrief(
      SIPTransaction & transaction, 
      SIP_PDU & response)
    ;
  
    virtual void OnReceivedAuthenticationRequired(
      SIPTransaction & transaction,
      SIP_PDU & response
    );

    virtual void OnReceivedOK(
      SIPTransaction & transaction,
      SIP_PDU & response
    );
    
    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
    ) { return PSafePtrCast<OpalConnection, SIPConnection>(GetConnectionWithLock(token, mode)); }

    virtual PBoolean IsAcceptedAddress(const SIPURL & toAddr);


    virtual void OnMessageReceived (const SIPURL & from,
                    const PString & body);


    bool Register(
      const SIPRegister::Params & params 
    );

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

    bool Unregister(const PString & aor);

    bool UnregisterAll();

    PBoolean IsRegistered(const PString & aor);

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

    struct RegistrationStatus {
      PString              m_addressofRecord;   
      bool                 m_wasRegistering;    
      bool                 m_reRegistering;     
      SIP_PDU::StatusCodes m_reason;            
      OpalProductInfo      m_productInfo;       
    };

    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(
      SIPSubscribe::PredefinedPackages eventPackage,
      unsigned expire,
      const PString & to
    );
    bool Subscribe(
      const SIPSubscribe::Params & params 
    );


    bool Unsubscribe(
      SIPSubscribe::PredefinedPackages eventPackage,
      const PString & to
    );
    bool Unsubscribe(
      const PString & eventPackage,
      const PString & to
    );

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

    PBoolean IsSubscribed(
      const PString & eventPackage,
      const PString & to
    );

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

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


    PBoolean Message (
      const PString & to, 
      const PString & body
    );
    

    PBoolean Publish(
      const PString & to,
      const PString & body,
      unsigned expire = 0
    );
    

    PBoolean Ping(
      const PString & to
    );

    virtual void OnPresenceInfoReceived (
      const PString & user,
      const PString & basic,
      const PString & note
    );

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

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

    
    PBoolean GetAuthentication(const PString & authRealm, PString & realm, PString & user, PString & password); 
    
    virtual SIPURL GetRegisteredPartyName(const SIPURL &);


    virtual SIPURL GetDefaultRegisteredPartyName();
    

    SIPURL GetContactURL(const OpalTransport &transport, const PString & userName, const PString & host);


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

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


    virtual unsigned GetAllowedMethods() const;

    PBoolean SendResponse(
      SIP_PDU::StatusCodes code, 
      OpalTransport & transport, 
      SIP_PDU & pdu
    );

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


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

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

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

    SIPURL        proxy;
    PString       userAgentString;

    bool          mimeForm;
    unsigned      maxRetries;
    PTimeInterval retryTimeoutMin;   // T1
    PTimeInterval retryTimeoutMax;   // T2
    PTimeInterval nonInviteTimeout;  // T3
    PTimeInterval pduCleanUpTimeout; // T4
    PTimeInterval inviteTimeout;
    PTimeInterval ackTimeout;
    PTimeInterval registrarTimeToLive;
    PTimeInterval notifierTimeToLive;
    PTimeInterval natBindingTimeout;
    
    SIPHandlersList   activeSIPHandlers;

    PSafeDictionary<PString, SIPTransaction> transactions;

    PTimer                  natBindingTimer;
    NATBindingRefreshMethod natMethod;
    
    PAtomicInteger          lastSentCSeq;    

    struct SIP_PDU_Work
    {
      SIP_PDU_Work()
      { ep = NULL; pdu = NULL; }

      SIPEndPoint * ep;
      SIP_PDU * pdu;
      PString callID;
    };

    typedef std::queue<SIP_PDU_Work *> SIP_PDUWorkQueue;

    class SIP_PDU_Thread : public PThreadPoolWorkerBase
    {
      public:
        SIP_PDU_Thread(PThreadPoolBase & _pool);
        unsigned GetWorkSize() const;
        void OnAddWork(SIP_PDU_Work * work);
        void OnRemoveWork(SIP_PDU_Work *);
        void Shutdown();
        void Main();

      protected:
        PMutex mutex;
        PSyncPoint sync;
        SIP_PDUWorkQueue pduQueue;
    };

    typedef PThreadPool<SIP_PDU_Work, SIP_PDU_Thread> SIPMainThreadPool;
    SIPMainThreadPool threadPool;

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


#endif // OPAL_SIP

#endif // OPAL_SIP_SIPEP_H


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

---