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: 24177 $
 * $Author: rjongbloed $
 * $Date: 2010-04-05 06:52:04 -0500 (Mon, 05 Apr 2010) $
 */

#include <ptlib/sockets.h>

#ifndef PTLIB_PNAT_H
#define PTLIB_PNAT_H

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

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

  public:
    PNatMethod();

    ~PNatMethod();


    virtual void PrintOn(
      ostream & strm
    ) const;


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

    virtual PString GetName() const = 0;

    virtual PString GetServer() const;

    virtual bool GetServerAddress(
      PIPSocket::Address & address,   
      WORD & port                     
    ) const = 0;

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

    virtual bool GetInterfaceAddress(
      PIPSocket::Address & internalAddress  
    ) const = 0;

    virtual PBoolean CreateSocket(
      PUDPSocket * & socket,
      const PIPSocket::Address & binding = PIPSocket::GetDefaultIpAny(),
      WORD localPort = 0
    ) = 0;

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

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

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

    virtual void Activate(bool active);

    virtual void SetAlternateAddresses(
      const PStringArray & addresses,   
      void * userData = NULL            
    );

    enum RTPSupportTypes {
      RTPSupported,
      RTPIfSendMedia,
      RTPUnsupported,
      RTPUnknown,
      NumRTPSupportTypes
    };

    virtual RTPSupportTypes GetRTPSupport(
      PBoolean force = false    
    ) = 0;

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

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

      PMutex mutex;
      WORD   basePort;
      WORD   maxPort;
      WORD   currentPort;
    } singlePortInfo, pairedPortInfo;

        WORD RandomPortPair(unsigned int start, unsigned int end);
};


PLIST(PNatList, PNatMethod);


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

  PBoolean 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 className> class PNatMethodServiceDescriptor : public PDevicePluginServiceDescriptor
{
  public:
    virtual PObject *    CreateInstance(int /*userData*/) const { return (PNatMethod *)new className; }
    virtual PStringArray GetDeviceNames(int /*userData*/) const { return className::GetNatMethodName(); }
    virtual bool  ValidateDeviceName(const PString & deviceName, int /*userData*/) const { 
              return (deviceName == GetDeviceNames(0)[0]); 
        } 
};

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

#endif // PTLIB_PNAT_H


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

---