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
 *
 * $Revision: 21283 $
 * $Author: rjongbloed $
 * $Date: 2008-10-11 07:10:58 +0000 (Sat, 11 Oct 2008) $
 */

#ifndef OPAL_OPAL_TRANSPORT_H
#define OPAL_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 
    );

    PBoolean IsEquivalent(
      const OpalTransportAddress & address
    ) const;

    PBoolean IsCompatible(
      const OpalTransportAddress & address
    ) const;

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

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

    virtual PString GetHostName() const;

    enum BindOptions {
      NoBinding,
      HostOnly,
      FullTSAP,
      Streamed,
      Datagram,
      RouteInterface,
      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 PBoolean Open(
      const PNotifier & acceptHandler,  
      ThreadMode mode = SpawnNewThreadMode 
    ) = 0;

    virtual PBoolean 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);
    PBoolean StartThread(
      const PNotifier & acceptHandler,  
      ThreadMode mode                   
    );

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


PLIST(OpalListenerList, OpalListener);


class OpalListenerIP : public OpalListener
{
  PCLASSINFO(OpalListenerIP, OpalListener);
  public:
    OpalListenerIP(
      OpalEndPoint & endpoint,                 
      PIPSocket::Address binding = PIPSocket::GetDefaultIpAny(), 
      WORD port = 0,                           
      PBoolean exclusive = PTrue
    );
    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;
    PBoolean               exclusiveListener;
};


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

    ~OpalListenerTCP();

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

    virtual PBoolean 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,            
      PBoolean exclusive = PTrue
    );
    OpalListenerUDP(
      OpalEndPoint & endpoint,                  
      const OpalTransportAddress & binding,     
      OpalTransportAddress::BindOptions option  
    );

    ~OpalListenerUDP();

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

    virtual PBoolean 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 PBoolean IsReliable() const = 0;

    virtual PString GetInterface() const;

    virtual bool SetInterface(
      const PString & iface  
    );

    virtual OpalTransportAddress GetLocalAddress() const = 0;

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

    virtual OpalTransportAddress GetRemoteAddress() const = 0;

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

    virtual PBoolean Connect() = 0;

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

    virtual PBoolean Close();

    void CloseWait();

    void CleanUpOnTermination() { CloseWait(); }

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

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

    virtual void SetPromiscuous(
      PromisciousModes promiscuous
    );

    virtual OpalTransportAddress GetLastReceivedAddress() const;

    virtual PString GetLastReceivedInterface() const;

    virtual PBoolean ReadPDU(
      PBYTEArray & packet   
    ) = 0;

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

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

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

    virtual void AttachThread(
      PThread * thread
    );

    virtual PBoolean IsRunning() const;

    OpalEndPoint & GetEndPoint() const { return endpoint; }

    virtual const char * GetProtoPrefix() const = 0;

    PMutex & GetWriteMutex() { return m_writeMutex; }

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


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

    virtual OpalTransportAddress GetLocalAddress() const;

    virtual PBoolean SetLocalAddress(
      const OpalTransportAddress & address
    );

    virtual OpalTransportAddress GetRemoteAddress() const;

    virtual PBoolean 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,              
      PBoolean reuseAddr = PFalse      
    );
    OpalTransportTCP(
      OpalEndPoint & endpoint,    
      PTCPSocket * socket         
    );

    ~OpalTransportTCP();

    virtual PBoolean IsReliable() const;

    virtual PBoolean IsCompatibleTransport(
      const OpalTransportAddress & address
    ) const;

    virtual PBoolean Connect();

    virtual PBoolean ReadPDU(
      PBYTEArray & pdu  
    );

    virtual PBoolean WritePDU(
      const PBYTEArray & pdu     
    );


  protected:
    virtual const char * GetProtoPrefix() const;

    virtual PBoolean OnOpen();


    PBoolean reuseAddressFlag;
};


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

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

    ~OpalTransportUDP();

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

    virtual PBoolean IsReliable() const;

    virtual PBoolean IsCompatibleTransport(
      const OpalTransportAddress & address
    ) const;

    virtual PBoolean Connect();

    virtual PString GetInterface() const;

    virtual bool SetInterface(
      const PString & iface  
    );

    virtual OpalTransportAddress GetLocalAddress() const;

    virtual PBoolean SetLocalAddress(
      const OpalTransportAddress & address
    );

    virtual PBoolean SetRemoteAddress(
      const OpalTransportAddress & address
    );

    virtual void SetPromiscuous(
      PromisciousModes promiscuous
    );

    virtual OpalTransportAddress GetLastReceivedAddress() const;

    virtual PString GetLastReceivedInterface() const;

    virtual PBoolean ReadPDU(
      PBYTEArray & packet   
    );

    virtual PBoolean WritePDU(
      const PBYTEArray & pdu     
    );

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

  protected:
    virtual const char * GetProtoPrefix() const;

    OpalManager & manager;
    PBYTEArray    preReadPacket;
};



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

    virtual PBoolean 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 PBoolean GetIpAndPort(
      const OpalTransportAddress & address,
      PIPSocket::Address & ip,
      WORD & port
    ) const;

    static PBoolean GetAdjustedIpAndPort(const OpalTransportAddress & address,
                                     OpalEndPoint & endpoint,
                                     OpalTransportAddress::BindOptions option,
                                     PIPSocket::Address & ip,
                                     WORD & port,
                                     PBoolean & 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;
      PBoolean 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 OPAL_PTLIB_SSL

class PSSLContext;

class OpalListenerTCPS : public OpalListenerTCP
{
  PCLASSINFO(OpalListenerTCPS, OpalListenerTCP);
  public:
    OpalListenerTCPS(
      OpalEndPoint & endpoint,                 
      PIPSocket::Address binding = PIPSocket::GetDefaultIpAny(), 
      WORD port = 0,                           
      PBoolean exclusive = PTrue
    );
    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,              
        PBoolean reuseAddr = PFalse      
      );
      OpalTransportTCPS(
        OpalEndPoint & endpoint,    
        PTCPSocket * socket         
      );

      ~OpalTransportTCPS();

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

    protected:
      PSSLContext * sslContext;
};

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


#endif // OPAL_PTLIB_SSL


#endif  // OPAL_OPAL_TRANSPORT_H


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

---