transports.h

Go to the documentation of this file.

/*
 * transport.h
 *
 * Transport declarations
 *
 * Open Phone Abstraction Library (OPAL)
 * Formally known as the Open H323 project.
 *
 * Copyright (c) 2001 Equivalence Pty. Ltd.
 * Portions Copyright (C) 2006 by Post Increment
 *
 * 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): Post Increment
 *     Portions of this code were written with the assistance of funding from
 *     US Joint Forces Command Joint Concept Development & Experimentation (J9)
 *     http://www.jfcom.mil/about/abt_j9.htm
 *
 * $Log: transports.h,v $
 * Revision 2.30  2007/10/12 04:00:44  rjongbloed
 * Fixed being able to SIP call to localhost.
 *
 * Revision 2.29  2007/09/07 05:44:14  rjongbloed
 * Fixed initialisation of SSL context in both OpalListenerTCPS contructors.
 *
 * Revision 2.28  2007/07/24 13:46:45  rjongbloed
 * Fixed correct selection of interface after forked INVITE reply arrives on bundled socket.
 *
 * Revision 2.27  2007/07/22 04:03:46  rjongbloed
 * Fixed issues with STUN usage in socket bundling, now OpalTransport indicates
 *   if it wants local or NAT address/port for inclusion to outgoing PDUs.
 *
 * Revision 2.26  2007/06/25 05:44:45  rjongbloed
 * Fixed numerous issues with "bound" managed socket, ie associating
 *   listeners to a specific named interface.
 *
 * Revision 2.25  2007/06/10 08:55:11  rjongbloed
 * Major rework of how SIP utilises sockets, using new "socket bundling" subsystem.
 *
 * Revision 2.24  2006/10/21 11:48:48  hfriederich
 * Allow to find out how many interfaces are used before calling WriteConnect()
 *
 * Revision 2.23  2006/08/29 01:37:11  csoutheren
 * Change secure URLs to use h323s and tcps to be inline with sips
 *
 * Revision 2.22  2006/08/29 00:55:04  csoutheren
 * Fix problem with creating TCP transports associated with UDP tranports
 *
 * Revision 2.21  2006/08/28 00:51:12  csoutheren
 * Applied 1545808 - OpalTransportUDP connectSockets protection
 * Thanks to Drazen Dimoti
 *
 * Revision 2.20  2006/08/21 05:29:25  csoutheren
 * Messy but relatively simple change to add support for secure (SSL/TLS) TCP transport
 * and secure H.323 signalling via the sh323 URL scheme
 *
 * Revision 2.19  2005/11/30 13:35:26  csoutheren
 * Changed tags for Doxygen
 *
 * Revision 2.18  2005/09/19 20:48:23  dsandras
 * Added the "can reuse address" flag to the OpalTransportUDP class.
 *
 * Revision 2.17  2005/01/16 23:07:33  csoutheren
 * Fixed problem with IPv6 INADDR_ANY
 *
 * Revision 2.16  2004/03/22 11:39:44  rjongbloed
 * Fixed problems with correctly terminating the OpalTransportUDP that is generated from
 *   an OpalListenerUDP, this should not close the socket or stop the thread.
 *
 * Revision 2.15  2004/03/13 06:25:52  rjongbloed
 * Slight rearrangement of local party name and alias list to beter match common
 *   behaviour in ancestor.
 * Abstracted local party name for endpoint into ancestor from H.,323.
 *
 * Revision 2.14  2004/03/11 06:54:27  csoutheren
 * Added ability to disable SIP or H.323 stacks
 *
 * Revision 2.13  2004/02/19 10:47:01  rjongbloed
 * Merged OpenH323 version 1.13.1 changes.
 *
 * Revision 2.12  2003/01/07 04:39:53  robertj
 * Updated to OpenH323 v1.11.2
 *
 * Revision 2.11  2002/11/10 11:33:17  robertj
 * Updated to OpenH323 v1.10.3
 *
 * Revision 1.43  2003/12/29 13:28:45  dominance
 * fixed docbook syntax trying to generate LaTeX formula with ip$10.x.x.x.
 *
 * Revision 1.42  2003/04/10 09:44:55  robertj
 * Added associated transport to new GetInterfaceAddresses() function so
 *   interfaces can be ordered according to active transport links. Improves
 *   interoperability.
 * Replaced old listener GetTransportPDU() with GetInterfaceAddresses()
 *   and H323SetTransportAddresses() functions.
 *
 * Revision 1.41  2003/04/10 01:03:25  craigs
 * Added functions to access to lists of interfaces
 *
 * Revision 1.40  2003/03/21 05:24:02  robertj
 * Added setting of remote port in UDP transport constructor.
 *
 * Revision 1.39  2003/02/06 04:29:23  robertj
 * Added more support for adding things to H323TransportAddressArrays
 *
 * Revision 1.38  2002/11/21 06:39:56  robertj
 * Changed promiscuous mode to be three way. Fixes race condition in gkserver
 *   which can cause crashes or more PDUs to be sent to the wrong place.
 *
 * Revision 1.37  2002/11/10 08:10:43  robertj
 * Moved constants for "well known" ports to better place (OPAL change).
 *
 * Revision 2.10  2002/09/16 02:52:35  robertj
 * Added #define so can select if #pragma interface/implementation is used on
 *   platform basis (eg MacOS) rather than compiler, thanks Robert Monaghan.
 *
 * Revision 2.9  2002/09/12 06:58:17  robertj
 * Removed protocol prefix strings as static members as has problems with
 *   use in DLL environment.
 *
 * Revision 2.8  2002/09/06 02:41:00  robertj
 * Added ability to specify stream or datagram (TCP or UDP) transport is to
 * be created from a transport address regardless of the addresses mode.
 *
 * Revision 2.7  2002/07/01 04:56:31  robertj
 * Updated to OpenH323 v1.9.1
 *
 * Revision 2.6  2002/06/16 23:07:47  robertj
 * Fixed several memory leaks, thanks Ted Szoczei
 *
 * Revision 2.5  2002/04/09 00:12:10  robertj
 * Added ability to set the local address on a transport, under some circumstances.
 *
 * Revision 2.4  2001/11/13 04:29:47  robertj
 * Changed OpalTransportAddress CreateTransport and CreateListsner functions
 *   to have extra parameter to control local binding of sockets.
 *
 * Revision 2.3  2001/11/12 05:32:12  robertj
 * Added OpalTransportAddress::GetIpAddress when don't need port number.
 *
 * Revision 2.2  2001/11/09 05:49:47  robertj
 * Abstracted UDP connection algorithm
 *
 * Revision 2.1  2001/11/06 05:40:13  robertj
 * Added OpalListenerUDP class to do listener semantics on a UDP socket.
 *
 * Revision 2.0  2001/07/27 15:48:24  robertj
 * Conversion of OpenH323 to Open Phone Abstraction Library (OPAL)
 *
 */

#ifndef __OPAL_TRANSPORT_H
#define __OPAL_TRANSPORT_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal/buildopts.h>

#include <ptlib/sockets.h>
#include <ptclib/psockbun.h>


class OpalManager;
class OpalEndPoint;
class OpalListener;
class OpalTransport;
class OpalInternalTransport;



class OpalTransportAddress : public PString
{
  PCLASSINFO(OpalTransportAddress, PString);
  public:
    OpalTransportAddress();
    OpalTransportAddress(
      const char * address,      
      WORD port = 0,             
      const char * proto = NULL  
    );
    OpalTransportAddress(
      const PString & address,   
      WORD port = 0,             
      const char * proto = NULL  
    );
    OpalTransportAddress(
      const PIPSocket::Address & ip,
      WORD port,
      const char * proto = NULL 
    );

    BOOL IsEquivalent(
      const OpalTransportAddress & address
    ) const;

    BOOL IsCompatible(
      const OpalTransportAddress & address
    ) const;

    BOOL GetIpAddress(PIPSocket::Address & ip) const;

    BOOL GetIpAndPort(PIPSocket::Address & ip, WORD & port) const;

    virtual PString GetHostName() const;

    enum BindOptions {
      NoBinding,
      HostOnly,
      FullTSAP,
      Streamed,
      Datagram,
      NumBindOptions
    };

    OpalListener * CreateListener(
      OpalEndPoint & endpoint,   
      BindOptions option         
    ) const;

    virtual OpalTransport * CreateTransport(
      OpalEndPoint & endpoint,   
      BindOptions option = HostOnly 
    ) const;


  protected:
    void SetInternalTransport(
      WORD port,             
      const char * proto     
    );

    OpalInternalTransport * transport;
};


PDECLARE_ARRAY(OpalTransportAddressArray, OpalTransportAddress)
  public:
    OpalTransportAddressArray(
      const OpalTransportAddress & address
    ) { AppendAddress(address); }
    OpalTransportAddressArray(
      const PStringArray & array
    ) { AppendStringCollection(array); }
    OpalTransportAddressArray(
      const PStringList & list
    ) { AppendStringCollection(list); }
    OpalTransportAddressArray(
      const PSortedStringList & list
    ) { AppendStringCollection(list); }

    void AppendString(
      const char * address
    );
    void AppendString(
      const PString & address
    );
    void AppendAddress(
      const OpalTransportAddress & address
    );

  protected:
    void AppendStringCollection(
      const PCollection & coll
    );
};





class OpalListener : public PObject
{
    PCLASSINFO(OpalListener, PObject);
  public:
    OpalListener(
      OpalEndPoint & endpoint   
    );

    void PrintOn(
      ostream & strm
    ) const;

    enum ThreadMode {
      SpawnNewThreadMode,
      HandOffThreadMode,
      SingleThreadMode
    };

    virtual BOOL Open(
      const PNotifier & acceptHandler,  
      ThreadMode mode = SpawnNewThreadMode 
    ) = 0;

    virtual BOOL IsOpen() = 0;

    virtual void Close() = 0;

    virtual OpalTransport * Accept(
      const PTimeInterval & timeout  
    ) = 0;

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

    virtual OpalTransportAddress GetLocalAddress(
      const OpalTransportAddress & preferredAddress = OpalTransportAddress()
    ) const = 0;

    OpalTransportAddress GetTransportAddress() const { return GetLocalAddress(); }

    void CloseWait();

    void CleanUpOnTermination() { CloseWait(); }


  protected:
    PDECLARE_NOTIFIER(PThread, OpalListener, ListenForConnections);
    BOOL StartThread(
      const PNotifier & acceptHandler,  
      ThreadMode mode                   
    );

    OpalEndPoint & endpoint;
    PThread      * thread;
    PNotifier      acceptHandler;
    ThreadMode     threadMode;
};


PLIST(OpalListenerList, OpalListener);


OpalTransportAddressArray OpalGetInterfaceAddresses(
  const OpalListenerList & listeners, 
  BOOL excludeLocalHost = TRUE,       
  OpalTransport * associatedTransport = NULL
);

OpalTransportAddressArray OpalGetInterfaceAddresses(
  const OpalTransportAddress & addr,  
  BOOL excludeLocalHost = TRUE,       
  OpalTransport * associatedTransport = NULL
);


class OpalListenerIP : public OpalListener
{
  PCLASSINFO(OpalListenerIP, OpalListener);
  public:
    OpalListenerIP(
      OpalEndPoint & endpoint,                 
      PIPSocket::Address binding = PIPSocket::GetDefaultIpAny(), 
      WORD port = 0,                           
      BOOL exclusive = TRUE
    );
    OpalListenerIP(
      OpalEndPoint & endpoint,                  
      const OpalTransportAddress & binding,     
      OpalTransportAddress::BindOptions option  
    );

    virtual OpalTransportAddress GetLocalAddress(
      const OpalTransportAddress & preferredAddress = OpalTransportAddress()
    ) const;

    WORD GetListenerPort() const { return listenerPort; }

    virtual const char * GetProtoPrefix() const = 0;


  protected:
    PIPSocket::Address localAddress;
    WORD               listenerPort;
    BOOL               exclusiveListener;
};


class OpalListenerTCP : public OpalListenerIP
{
  PCLASSINFO(OpalListenerTCP, OpalListenerIP);
  public:
    OpalListenerTCP(
      OpalEndPoint & endpoint,                 
      PIPSocket::Address binding = PIPSocket::GetDefaultIpAny(), 
      WORD port = 0,                           
      BOOL exclusive = TRUE
    );
    OpalListenerTCP(
      OpalEndPoint & endpoint,                  
      const OpalTransportAddress & binding,     
      OpalTransportAddress::BindOptions option  
    );

    ~OpalListenerTCP();

    virtual BOOL Open(
      const PNotifier & acceptHandler,  
      ThreadMode mode = SpawnNewThreadMode 
    );

    virtual BOOL IsOpen();

    virtual void Close();

    virtual OpalTransport * Accept(
      const PTimeInterval & timeout  
    );

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


  protected:
    virtual const char * GetProtoPrefix() const;

    PTCPSocket listener;
};


class OpalListenerUDP : public OpalListenerIP
{
  PCLASSINFO(OpalListenerUDP, OpalListenerIP);
  public:
    OpalListenerUDP(
      OpalEndPoint & endpoint,  
      PIPSocket::Address binding = PIPSocket::GetDefaultIpAny(), 
      WORD port = 0,            
      BOOL exclusive = TRUE
    );
    OpalListenerUDP(
      OpalEndPoint & endpoint,                  
      const OpalTransportAddress & binding,     
      OpalTransportAddress::BindOptions option  
    );

    ~OpalListenerUDP();

    virtual BOOL Open(
      const PNotifier & acceptHandler,  
      ThreadMode mode = SpawnNewThreadMode 
    );

    virtual BOOL IsOpen();

    virtual void Close();

    virtual OpalTransport * Accept(
      const PTimeInterval & timeout  
    );

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


  protected:
    virtual const char * GetProtoPrefix() const;

    PMonitoredSocketsPtr listenerBundle;
};



class OpalTransport : public PIndirectChannel
{
    PCLASSINFO(OpalTransport, PIndirectChannel);
  public:
    OpalTransport(OpalEndPoint & endpoint);

    ~OpalTransport();

    void PrintOn(
      ostream & strm
    ) const;

    virtual BOOL IsReliable() const = 0;

    virtual PString GetInterface() const;

    virtual OpalTransportAddress GetLocalAddress() const = 0;

    virtual BOOL SetLocalAddress(
      const OpalTransportAddress & address
    ) = 0;

    virtual OpalTransportAddress GetRemoteAddress() const = 0;

    virtual BOOL SetRemoteAddress(
      const OpalTransportAddress & address
    ) = 0;

    virtual BOOL Connect() = 0;

    BOOL ConnectTo(
      const OpalTransportAddress & address
    ) { return SetRemoteAddress(address) && Connect(); }

    virtual void EndConnect(
      const PString & iface  
    );

    virtual BOOL Close();

    void CloseWait();

    void CleanUpOnTermination() { CloseWait(); }

    virtual BOOL IsCompatibleTransport(
      const OpalTransportAddress & address
    ) const = 0;

    enum PromisciousModes {
      AcceptFromRemoteOnly,
      AcceptFromAnyAutoSet,
      AcceptFromAny,
      NumPromisciousModes
    };

    virtual void SetPromiscuous(
      PromisciousModes promiscuous
    );

    virtual OpalTransportAddress GetLastReceivedAddress() const;

    virtual BOOL ReadPDU(
      PBYTEArray & packet   
    ) = 0;

    virtual BOOL WritePDU(
      const PBYTEArray & pdu     
    ) = 0;

    typedef BOOL (*WriteConnectCallback)(OpalTransport & transport, void * userData);

    virtual BOOL WriteConnect(
      WriteConnectCallback function,  
      void * userData                 
    );

    virtual void AttachThread(
      PThread * thread
    );

    virtual BOOL IsRunning() const;

    OpalEndPoint & GetEndPoint() const { return endpoint; }

    virtual void SetReadsPerPDU(int) {}

  protected:
    OpalEndPoint & endpoint;
    PThread      * thread;      
};


class OpalTransportIP : public OpalTransport
{
  PCLASSINFO(OpalTransportIP, OpalTransport);
  public:
    OpalTransportIP(
      OpalEndPoint & endpoint,    
      PIPSocket::Address binding, 
      WORD port                   
    );

    virtual OpalTransportAddress GetLocalAddress() const;

    virtual BOOL SetLocalAddress(
      const OpalTransportAddress & address
    );

    virtual OpalTransportAddress GetRemoteAddress() const;

    virtual BOOL SetRemoteAddress(
      const OpalTransportAddress & address
    );


  protected:
    virtual const char * GetProtoPrefix() const = 0;

    PIPSocket::Address localAddress;  // Address of the local interface
    WORD               localPort;
    PIPSocket::Address remoteAddress; // Address of the remote host
    WORD               remotePort;
};


class OpalTransportTCP : public OpalTransportIP
{
    PCLASSINFO(OpalTransportTCP, OpalTransportIP);
  public:
    OpalTransportTCP(
      OpalEndPoint & endpoint,    
      PIPSocket::Address binding = PIPSocket::GetDefaultIpAny(), 
      WORD port = 0,              
      BOOL reuseAddr = FALSE      
    );
    OpalTransportTCP(
      OpalEndPoint & endpoint,    
      PTCPSocket * socket         
    );

    ~OpalTransportTCP();

    virtual BOOL IsReliable() const;

    virtual BOOL IsCompatibleTransport(
      const OpalTransportAddress & address
    ) const;

    virtual BOOL Connect();

    virtual BOOL ReadPDU(
      PBYTEArray & pdu  
    );

    virtual BOOL WritePDU(
      const PBYTEArray & pdu     
    );


  protected:
    virtual const char * GetProtoPrefix() const;

    virtual BOOL OnOpen();


    BOOL reuseAddressFlag;
};


class OpalTransportUDP : public OpalTransportIP
{
  PCLASSINFO(OpalTransportUDP, OpalTransportIP);
  public:
    OpalTransportUDP(
      OpalEndPoint & endpoint,    
      PIPSocket::Address binding = PIPSocket::GetDefaultIpAny(), 
      WORD port = 0,              
      BOOL reuseAddr = FALSE      
    );

    OpalTransportUDP(
      OpalEndPoint & endpoint,              
      const PBYTEArray & preReadPacket,     
      const PMonitoredSocketsPtr & sockets, 
      const PString & iface,                
      PIPSocket::Address remoteAddress,     
      WORD remotePort                       
    );

    ~OpalTransportUDP();

    virtual BOOL Read(
      void * buffer,
      PINDEX length
    );

    virtual BOOL IsReliable() const;

    virtual BOOL IsCompatibleTransport(
      const OpalTransportAddress & address
    ) const;

    virtual BOOL Connect();

    virtual void EndConnect(
      const PString & iface  
    );

    virtual PString GetInterface() const;

    virtual OpalTransportAddress GetLocalAddress() const;

    virtual BOOL SetLocalAddress(
      const OpalTransportAddress & address
    );

    virtual BOOL SetRemoteAddress(
      const OpalTransportAddress & address
    );

    virtual void SetPromiscuous(
      PromisciousModes promiscuous
    );

    virtual OpalTransportAddress GetLastReceivedAddress() const;

    virtual BOOL ReadPDU(
      PBYTEArray & packet   
    );

    virtual BOOL WritePDU(
      const PBYTEArray & pdu     
    );

    virtual BOOL WriteConnect(
      WriteConnectCallback function,  
      void * userData                 
    );

    virtual void SetReadsPerPDU(int v) { readsPerPdu = v; }

  protected:
    virtual const char * GetProtoPrefix() const;

    OpalManager & manager;
    PBYTEArray    preReadPacket;
    int readsPerPdu;
};



class OpalInternalTransport : public PObject
{
    PCLASSINFO(OpalInternalTransport, PObject);
  public:
    virtual PString GetHostName(
      const OpalTransportAddress & address
    ) const;

    virtual BOOL GetIpAndPort(
      const OpalTransportAddress & address,
      PIPSocket::Address & ip,
      WORD & port
    ) const;

    virtual OpalListener * CreateListener(
      const OpalTransportAddress & address,
      OpalEndPoint & endpoint,
      OpalTransportAddress::BindOptions options
    ) const  = 0;

    virtual OpalTransport * CreateTransport(
      const OpalTransportAddress & address,
      OpalEndPoint & endpoint,
      OpalTransportAddress::BindOptions options
    ) const = 0;
};



class OpalInternalIPTransport : public OpalInternalTransport
{
    PCLASSINFO(OpalInternalIPTransport, OpalInternalTransport);
  public:
    virtual PString GetHostName(
      const OpalTransportAddress & address
    ) const;
    virtual BOOL GetIpAndPort(
      const OpalTransportAddress & address,
      PIPSocket::Address & ip,
      WORD & port
    ) const;

    static BOOL GetAdjustedIpAndPort(const OpalTransportAddress & address,
                                     OpalEndPoint & endpoint,
                                     OpalTransportAddress::BindOptions option,
                                     PIPSocket::Address & ip,
                                     WORD & port,
                                     BOOL & reuseAddr);
};

template <class ListenerType, class TransportType, unsigned AltTypeOption, class AltTypeClass>
class OpalInternalIPTransportTemplate : public OpalInternalIPTransport
{
  public:
    OpalListener * CreateListener(
      const OpalTransportAddress & address,
      OpalEndPoint & endpoint,
      OpalTransportAddress::BindOptions options
    ) const
    {
      return new ListenerType(endpoint, address, options);
    }

    OpalTransport * CreateTransport(
      const OpalTransportAddress & address,
      OpalEndPoint & endpoint,
      OpalTransportAddress::BindOptions options
    ) const
    {
      PIPSocket::Address ip;
      WORD port;
      BOOL reuseAddr;
      if (GetAdjustedIpAndPort(address, endpoint, options, ip, port, reuseAddr)) {
        if (options == AltTypeOption)
          return new AltTypeClass(endpoint, ip, 0, reuseAddr);
        else
          return new TransportType(endpoint, ip, 0, reuseAddr);
      }
      return NULL;
    }
};

typedef OpalInternalIPTransportTemplate<OpalListenerTCP, OpalTransportTCP, OpalTransportAddress::Datagram, OpalTransportUDP> OpalInternalTCPTransport;
typedef OpalInternalIPTransportTemplate<OpalListenerUDP, OpalTransportUDP, OpalTransportAddress::Streamed, OpalTransportTCP> OpalInternalUDPTransport;

#if P_SSL

class PSSLContext;

class OpalListenerTCPS : public OpalListenerTCP
{
  PCLASSINFO(OpalListenerTCPS, OpalListenerTCP);
  public:
    OpalListenerTCPS(
      OpalEndPoint & endpoint,                 
      PIPSocket::Address binding = PIPSocket::GetDefaultIpAny(), 
      WORD port = 0,                           
      BOOL exclusive = TRUE
    );
    OpalListenerTCPS(
      OpalEndPoint & endpoint,                  
      const OpalTransportAddress & binding,     
      OpalTransportAddress::BindOptions option  
    );

    ~OpalListenerTCPS();

    OpalTransport * Accept(const PTimeInterval & timeout);
    const char * GetProtoPrefix() const;

  protected:
    void Construct();

    PSSLContext * sslContext;
};

class OpalTransportTCPS : public OpalTransportTCP
{
  PCLASSINFO(OpalTransportTCPS, OpalTransportTCP);
    public:
      OpalTransportTCPS(
        OpalEndPoint & endpoint,    
        PIPSocket::Address binding = PIPSocket::GetDefaultIpAny(), 
        WORD port = 0,              
        BOOL reuseAddr = FALSE      
      );
      OpalTransportTCPS(
        OpalEndPoint & endpoint,    
        PTCPSocket * socket         
      );

      ~OpalTransportTCPS();

      BOOL IsCompatibleTransport(const OpalTransportAddress & address) const;
      BOOL Connect();
      BOOL OnOpen();
      const char * GetProtoPrefix() const;

    protected:
      PSSLContext * sslContext;
};

typedef OpalInternalIPTransportTemplate<OpalListenerTCPS, OpalTransportTCPS, OpalTransportAddress::Datagram, OpalTransportUDP> OpalInternalTCPSTransport;


#endif // P_SSL


#endif  // __OPAL_TRANSPORT_H


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

---