pnat.h

Go to the documentation of this file.

/*
 * pnat.h
 *
 * NAT Strategy support for Portable Windows Library.
 *
 * Virteos is a Trade Mark of ISVO (Asia) Pte Ltd.
 *
 * Copyright (c) 2004 ISVO (Asia) Pte Ltd. All Rights Reserved.
 *
 * 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 derived from and used in conjunction with the 
 * OpenH323 Project (www.openh323.org/)
 *
 * The Initial Developer of the Original Code is ISVO (Asia) Pte Ltd.
 *
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 31475 $
 * $Author: rjongbloed $
 * $Date: 2014-02-15 14:40:04 +1100 (Sat, 15 Feb 2014) $
 */

#ifndef PTLIB_PNAT_H
#define PTLIB_PNAT_H

#include <ptlib.h>

#if P_NAT

#include <ptlib/sockets.h>

#include <ptlib/plugin.h>
#include <ptlib/pluginmgr.h>

class PNATUDPSocket;


class PNatMethod  : public PObject
{
    PCLASSINFO(PNatMethod,PObject);

  public:
    enum Component {
      eComponent_RTP  = 1,
      eComponent_RTCP = 2,
      eComponent_Unknown = 255,
    };

    P_DECLARE_STREAMABLE_ENUM(NatTypes,
      UnknownNat,         
      OpenNat,            
      ConeNat,            
      RestrictedNat,      
      PortRestrictedNat,  
      SymmetricNat,       
      BlockedNat,         
      PartiallyBlocked    
    );

  protected:
    PNatMethod(unsigned priority);

  public:
    ~PNatMethod();


    virtual void PrintOn(
      ostream & strm
    ) const;
    virtual Comparison Compare(
      const PObject & obj
    ) const;


    static PNatMethod * Create(
      const PString & name,             
      PPluginManager * pluginMgr = NULL 
    );

    static PString GetNatTypeString(
      NatTypes type   
    );

    virtual PCaselessString GetMethodName() const = 0;

    virtual PString GetFriendlyName() const;

    virtual void Activate(bool active);

    virtual bool IsAvailable(
      const PIPSocket::Address & binding = PIPSocket::GetDefaultIpAny(),
      PObject * context = NULL
    );

    virtual PString GetServer() const = 0;

    virtual bool GetServerAddress(
      PIPSocket::Address & address,   
      WORD & port                     
    ) const;
    virtual bool GetServerAddress(
      PIPSocketAddressAndPort & externalAddressAndPort 
    ) const;

    NatTypes GetNatType(
      const PTimeInterval & maxAge
    );

    __inline NatTypes GetNatType(
      bool force = false    
    ) { return GetNatType(force ? PTimeInterval(0) : PMaxTimeInterval); }

    __inline NatTypes GetNatType() const { return m_natType; }

    PString GetNatTypeName(
      bool force = false    
    ) { return GetNatTypeString(GetNatType(force)); }

    PString GetNatTypeName() const { return GetNatTypeString(GetNatType()); }

    virtual bool SetServer(const PString & server);

    virtual void SetCredentials(
      const PString & username, 
      const PString & password, 
      const PString & realm
    );

    static const PTimeInterval & GetDefaultMaxAge();

    bool GetExternalAddress(
      PIPSocket::Address & externalAddress, 
      const PTimeInterval & maxAge = GetDefaultMaxAge() 
    );
    bool GetExternalAddress(
      PIPSocket::Address & externalAddress  
    ) const;

    bool GetInterfaceAddress(
      PIPSocket::Address & internalAddress  
    ) const;

    virtual bool Open(
      const PIPSocket::Address & ifaceAddr
    );

    virtual void Close() { }

    virtual PBoolean CreateSocket(
      PUDPSocket * & socket,
      const PIPSocket::Address & binding = PIPSocket::GetDefaultIpAny(),
      WORD localPort = 0,
      PObject * context = NULL,
      Component component = eComponent_Unknown
    );

    virtual bool CreateSocketPair(
      PUDPSocket * & socket1,
      PUDPSocket * & socket2,
      const PIPSocket::Address & binding = PIPSocket::GetDefaultIpAny(),
      PObject * context = NULL
    );

    P_DECLARE_ENUM(RTPSupportTypes,
      RTPSupported,
      RTPIfSendMedia,
      RTPUnsupported,
      RTPUnknown
    );

    virtual RTPSupportTypes GetRTPSupport(
      bool force = false    
    );

    virtual void SetPortRanges(
      WORD portBase,          
      WORD portMax = 0,       
      WORD portPairBase = 0,  
      WORD portPairMax = 0    
    );

    bool     IsActive()    const { return m_active; }
    unsigned GetPriority() const { return m_priority; }

  protected:
    virtual PNATUDPSocket * InternalCreateSocket(Component component, PObject * context) = 0;
    virtual void InternalUpdate() = 0;

    bool m_active;

    PIPSocket::PortRange m_singlePortRange;
    PIPSocket::PortRange m_pairedPortRange;

    PNatMethod::NatTypes    m_natType;
    PIPSocketAddressAndPort m_externalAddress;
    PTime                   m_updateTime;
    PMutex                  m_mutex;

  private:
    unsigned m_priority;

  P_REMOVE_VIRTUAL(NatTypes,InternalGetNatType(bool,const PTimeInterval &),UnknownNat);

  friend class PNatMethods;
};



class PNatCandidate : public PObject
{
  PCLASSINFO(PNatCandidate, PObject);
  public:
    P_DECLARE_ENUM(Types,
      HostType,
      ServerReflexiveType,
      PeerReflexiveType,
      RelayType
    );

    PNatCandidate(
      Types type = EndTypes,
      PNatMethod::Component component = PNatMethod::eComponent_Unknown,
      const char * foundation = NULL
    );

    virtual void PrintOn(ostream & strm) const;

    void CalculatePriority();

    Types                   m_type;
    PNatMethod::Component   m_component;
    unsigned                m_priority;
    PString                 m_foundation;             // ICE support
    PString                 m_protocol;               // Almost invariably "udp"
    PIPSocketAddressAndPort m_baseTransportAddress;   // Address of physical host
    PIPSocketAddressAndPort m_localTransportAddress;  // Address presented to remote system
};


typedef PList<PNatCandidate> PNatCandidateList;



class PNATUDPSocket : public PUDPSocket
{
  PCLASSINFO(PNATUDPSocket, PUDPSocket);

  public:
    PNATUDPSocket(
      PNatMethod::Component component
    );

    virtual PString GetName() const;
    virtual const char * GetNatName() const { return "NAT"; }

    virtual void GetCandidateInfo(PNatCandidate & candidate);

    // Get phsyical, non-translated, IP/port for socket.
    PString GetBaseAddress() const;
    bool GetBaseAddress(PIPSocketAddressAndPort & addrAndPort) const;

    PNatMethod::Component GetComponent() const
    { return m_component; }

  protected:
    virtual bool InternalGetBaseAddress(PIPSocketAddressAndPort & addrAndPort);

    PNatMethod::Component m_component;
};



class PNatMethod_Fixed  : public PNatMethod
{
  PCLASSINFO(PNatMethod_Fixed, PNatMethod);
  public:
    enum { DefaultPriority = 50 };
    PNatMethod_Fixed(unsigned priority = DefaultPriority);

    static const char * MethodName();
    virtual PCaselessString GetMethodName() const;

    virtual PString GetServer() const;
    virtual bool SetServer(const PString & str);
    virtual bool GetInterfaceAddress(PIPSocket::Address & addr) const;
    virtual bool Open(const PIPSocket::Address & addr);
    virtual bool IsAvailable(const PIPSocket::Address & binding, PObject * context);

  protected:
    virtual PNATUDPSocket * InternalCreateSocket(Component component, PObject * context);
    virtual void InternalUpdate();

    PIPSocket::Address m_interfaceAddress;
};


class PNatMethods : public PSortedList<PNatMethod>
{
    typedef PSortedList<PNatMethod> BaseClass;
    PCLASSINFO(PNatMethods, BaseClass);
  public :
    PNatMethods(
      bool loadFromFactory = false,
      PPluginManager * pluginMgr = NULL
    );

    void LoadAll(PPluginManager * pluginMgr = NULL);

    virtual PNatMethod * GetMethod(
      const PIPSocket::Address & binding = PIPSocket::GetDefaultIpAny(),
      PObject * context = NULL
    );

    virtual PNatMethod * GetMethodByName(
      const PString & name
    );

    virtual bool RemoveMethod(
      const PString & name
    );

    virtual bool SetMethodPriority(
      const PString & name,
      unsigned priority
    );

    virtual bool IsLocalAddress(
      const PIPSocket::Address & ip
    ) const;

    void SetPortRanges(
      WORD portBase,          
      WORD portMax = 0,       
      WORD portPairBase = 0,  
      WORD portPairMax = 0    
    );


    PNatMethods & GetNATList() { return *this; }  // For backward compatibility
};


typedef PNatMethods PNatList;     // For backward compatibility
typedef PNatMethods PNatStrategy; // For backward compatibility



//
// declare macros and structures needed for NAT plugins
//

PCREATE_PLUGIN_SERVICE(PNatMethod);

#define PCREATE_NAT_PLUGIN(name, friendlyName) \
    PCREATE_PLUGIN(name, PNatMethod, PNatMethod_##name, PPlugin_PNatMethod, \
      virtual const char * GetFriendlyName() const { return friendlyName; } \
    )


#define P_NAT_PARAM(...) ,__VA_ARGS__


#if P_STUN
  PPLUGIN_STATIC_LOAD(STUN, PNatMethod);
#endif

#if P_TURN
  PPLUGIN_STATIC_LOAD(TURN, PNatMethod);
#endif

#else  // P_NAT

#define P_NAT_PARAM(...)

#endif // P_NAT

#endif // PTLIB_PNAT_H


// End Of File ///////////////////////////////////////////////////////////////