vlInetTcpSocket.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
*********************************************************************/
#pragma once

#include <vlutil/vlInetSocket.h>

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

class DtInetTcpSockPimpl;

class DT_DLL_VLUTIL DtInetTcpSocket : public DtInetSocket
{
public:
   DtInetTcpSocket();

   DtInetTcpSocket( DtU16 localPort, DtInetDevice* hostIf = NULL, 
     DtInetUtils::DtInetAddrFamily family = DtInetUtils::DtInetAddrFamily_IPv4,
     DtU32 flags = DtSockOptNoDelay, bool immediateOpen = true );

   DtInetTcpSocket( const DtInetEndpoint& dest, DtU16 localPort = 0, 
                 DtInetDevice* hostIf = NULL, DtU32 flags = DtDefaultSockOpts,
                 bool immediateOpen = true );

   virtual ~DtInetTcpSocket();

   virtual bool setDestination( const DtInetEndpoint& addr );

   virtual bool openSocket();

   virtual bool closeSocket();

   virtual bool bindToDevice( const DtInetDevice* hostIf = NULL );

   virtual bool listenForConnections();

   virtual bool acceptConnection( DtInetTcpSocket* peer, 
                                  DtU32 flags = DtDefaultSockOpts);

   virtual bool connectToDestination();

   virtual int send( caddr_t packet, size_t size, DtU32 flags = 0 );
   virtual int sendTo( caddr_t packet, size_t size,
                       DtInetEndpoint& dest, DtU32 flags = 0 );

   virtual int sendChain( DtInetBufferChain& packets, DtU32 flags = 0 );
   virtual int sendChainTo( DtInetBufferChain& packets,
                            DtInetEndpoint& dest, DtU32 flags = 0 );


   virtual DtInetSockRcvStatus recv( caddr_t buff, size_t buffSize,
                                     DtU32 flags = 0 );
   virtual DtInetSockRcvStatus recvToChain( DtInetBufferChain& packets,
                                            DtU32 flags = 0 );
   virtual DtInetSockRcvStatus recvFrom( caddr_t buff, size_t buffSize,
                                         DtInetEndpoint& src,
                                         DtU32 flags = 0 );
   virtual DtInetSockRcvStatus recvToChainFrom( DtInetBufferChain& packets,
                                                DtInetEndpoint& src,
                                                DtU32 flags = 0 );

   virtual bool setSocket( const DtInetEndpoint& dest, DtU16 localPort = 0, 
      DtInetDevice* hostIf = NULL, DtU32 flags = DtDefaultSockOpts );

   virtual bool isOk();

   virtual int descriptor() const;

   virtual bool setNonBlockingOption( bool onOrOff );
   virtual bool setReuseAddressOption( bool onOrOff );
   virtual bool setSendBufferSize( DtU32 size );
   virtual bool setReceiveBufferSize( DtU32 size );
   virtual bool setDoNotRouteOption( bool onOrOff );
   virtual bool setSendLowWatermark( DtU32 size );
   virtual bool setReceiveLowWatermark( DtU32 size );
   virtual bool setTcpNoDelayOption( bool onOrOff ); 
   virtual bool setTcpLingerOption( DtU16 timeout );
   virtual bool setConnAbortedOption( bool onOrOff );
   virtual bool setTcpKeepAliveOption( bool onOrOff );

   virtual DtU32 getSendBufferSize();
   virtual DtU32 getReceiveBufferSize();
   virtual DtU32 getBytesAvailable();
   virtual bool  getReuseAddressOption();
   virtual bool  getDoNotRouteOption();
   virtual DtU32 getSendLowWatermark();
   virtual DtU32 getReceiveLowWatermark();
   virtual bool  getTcpLingerOption( DtU16& timeout );
   virtual bool  getConnAbortedOption();
   virtual bool  getTcpKeepAliveOption();

protected:
   virtual bool initAcceptedConnection( const DtInetAddr& localAddr, DtU16 localPort,
                                        DtU32 flags = DtDefaultSockOpts );
   virtual bool openAcceptedConnection( DtInetEndpoint peer );

   virtual void* tcpSocket();
   virtual void* tcpServerSocket();

   bool isServerSock() const;

private:
   DtInetTcpSocket( const DtInetTcpSocket& orig );

   DtInetTcpSocket& operator=(const DtInetTcpSocket& orig);

   friend class DtInetTcpSockPimpl;
   DtInetTcpSockPimpl* myAsyncPimpl;

protected:
   void* myIoService;
   void* myTcpSocket;
   void* myTcpAcceptor;  // server sockets only

   // This member should only be used by 'server' sockets. All other sockets
   // should set this to DtInetUtils::DtInetAddrFamily_INVALID to differentiate
   // server and client sockets.
   DtInetUtils::DtInetAddrFamily    myAddrFamily;
}; 
// end of class DtInetTcpSocket

#ifdef DtUSE_UTILITIES_NAMESPACE
} 
#endif