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: 29076 $
 * $Author: rjongbloed $
 * $Date: 2013-02-12 19:30:20 +1100 (Tue, 12 Feb 2013) $
 */

#ifndef PTLIB_PNAT_H
#define PTLIB_PNAT_H

#include <ptbuildopts.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 {
      NatPortStart = 49152,
      NatPortEnd   = 65535
    };

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

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

    PNatMethod();

    ~PNatMethod();


    virtual void PrintOn(
      ostream & strm
    ) const;


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

    static PString GetNatTypeString(
      NatTypes type   
    );

    virtual PString GetName() const = 0;

    virtual PString GetServer() const = 0;

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

    __inline NatTypes GetNatType(
      const PTimeInterval & maxAge
    ) { return InternalGetNatType(false, maxAge); }

    __inline NatTypes GetNatType(
      bool force = false    
    ) { return InternalGetNatType(force, PMaxTimeInterval); }

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

    virtual bool SetServer(const PString & server);

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

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

    virtual 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
    ) { return CreateSocket(eComponent_Unknown, socket, binding, localPort); }
    virtual bool CreateSocket(
      Component component,
      PUDPSocket * & socket,
      const PIPSocket::Address & binding = PIPSocket::GetDefaultIpAny(),
      WORD localPort = 0
    );

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

    virtual bool CreateSocketPair(
      PUDPSocket * & socket1,
      PUDPSocket * & socket2,
      const PIPSocket::Address & binding,
      void * userData
    );

    virtual bool CreateSocketPairAsync(
      const PString & token
    );

    virtual bool GetSocketPairAsync(
      const PString & token,
      PUDPSocket * & socket1,
      PUDPSocket * & socket2,
      const PIPSocket::Address & binding = PIPSocket::GetDefaultIpAny(),
      void * userData = NULL
    );

    virtual bool IsAvailable(
      const PIPSocket::Address & binding
    );

    virtual void Activate(bool active);

    virtual void SetAlternateAddresses(
      const PStringArray & addresses,   
      void * userData = 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    
    );

    struct PortInfo {
      PortInfo(WORD port = 0)
        : basePort(port)
        , maxPort(port)
        , currentPort(port)
      {
      }

      void SetPorts(
        WORD start,
        WORD end
      );

      WORD GetNext(
        unsigned increment
      );

      WORD GetRandomPair();

      PMutex mutex;
      WORD   basePort;
      WORD   maxPort;
      WORD   currentPort;
    } ;

  protected:
    virtual NatTypes InternalGetNatType(bool forced, const PTimeInterval & maxAge) = 0;

    PortInfo singlePortInfo, pairedPortInfo;
};


PLIST(PNatList, PNatMethod);


class PNatCandidate : public PObject
{
  PCLASSINFO(PNatCandidate, PObject);
  public:
    enum {
      eType_Unknown,
      eType_Host,
      eType_ServerReflexive,
      eType_PeerReflexive,
      eType_Relay
    };

    PNatCandidate();
    PNatCandidate(int type, PNatMethod::Component component);

    virtual PString AsString() const;

    PIPSocketAddressAndPort m_baseAddress;
    PIPSocketAddressAndPort m_transport;
    int                     m_type;
    PNatMethod::Component   m_component;
};


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

  public:
    PNATUDPSocket(
      PNatMethod::Component component = PNatMethod::eComponent_Unknown
    );

    virtual PNatCandidate GetCandidateInfo();

    virtual PString GetBaseAddress();
    virtual bool GetBaseAddress(PIPSocketAddressAndPort & addrAndPort);

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

    void SetComponent(PNatMethod::Component component)
    { m_component = component; }

  protected:
    virtual bool InternalGetBaseAddress(PIPSocketAddressAndPort & addrAndPort);

    PNatMethod::Component m_component;
};



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

    static PString GetNatMethodName();
    virtual PString GetName() const;

    virtual PString GetServer() const;
    virtual bool SetServer(const PString & str);
    virtual bool GetExternalAddress(PIPSocket::Address & addr ,const PTimeInterval &);
    virtual bool GetInterfaceAddress(PIPSocket::Address & addr) const;
    virtual bool Open(const PIPSocket::Address & addr);
    virtual bool IsAvailable(const PIPSocket::Address &);

  protected:
    virtual NatTypes InternalGetNatType(bool forced, const PTimeInterval & maxAge);

    NatTypes           m_type;
    PIPSocket::Address m_interfaceAddress;
    PIPSocket::Address m_externalAddress;
};


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

public :

  PNatStrategy();

  ~PNatStrategy();

  void AddMethod(PNatMethod * method);

  PNatMethod * GetMethod(const PIPSocket::Address & address = PIPSocket::GetDefaultIpAny());

  PNatMethod * GetMethodByName(const PString & name);

  bool RemoveMethod(const PString & meth);

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

    PNatList & GetNATList() {  return natlist; };

        PNatMethod * LoadNatMethod(const PString & name);

    static PStringArray GetRegisteredList();


private:
  PNatList natlist;
  PPluginManager * pluginMgr;
};

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

template <class SVC> class PNatMethodServiceDescriptor : public PDevicePluginServiceDescriptor
{
  public:
    virtual PObject *    CreateInstance(int /*userData*/) const { return new SVC; }
    virtual PStringArray GetDeviceNames(int /*userData*/) const { return SVC::GetNatMethodName(); }
    virtual bool  ValidateDeviceName(const PString & deviceName, int /*userData*/) const { return SVC::GetNatMethodName() *= deviceName; }
};

#define PCREATE_NAT_PLUGIN(name) \
  static PNatMethodServiceDescriptor<PNatMethod_##name> PNatMethod_##name##_descriptor; \
  PCREATE_PLUGIN(name, PNatMethod, &PNatMethod_##name##_descriptor) \


#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 ///////////////////////////////////////////////////////////////