vlInetSocket.h

Go to the documentation of this file.

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

#include <vlutil/vlInet.h>
#include <vlutil/vlInetAddr.h>
#include <vlutil/vlInetAddrUtils.h>
#include <vlutil/vlInetDevice.h>
#include <vlutil/vlInetEndpoint.h>
#include <vlutil/vlThreadSafe.h>
#include <vlutil/vlString.h>
#include <vlutil/vlTime.h>
#include <deque>
#include <map>

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

#define DtRead           ((DtU32) 0x01)
#define DtWrite          ((DtU32)  0x02)
#define DtReadWrite      (DtRead | DtWrite)
#define DtBindToDestAddr ((DtU32) 0x08)
#define DtQuiet          ((DtU32) 0x10)

#define DtSockOptStrictMulticastBinding ((DtU32) 0x20)
#ifdef _WIN32
#define DtSockOptNonBlocking ((DtU32) 0x40) // MSG_DONTWAIT not supported
#else // !_WIN32
// Not sure if MSG_DONTWAIT is supported on Solaris, Irix, etc...
#define DtSockOptNonBlocking ((DtU32) MSG_DONTWAIT)
#endif
#define DtSockOptNoDelay     ((DtU32) 0x80)
#define DtSockAsyncRead      ((DtU32) 0x100)
#define DtSockAsyncWrite     ((DtU32) 0x200)
#define DtAsyncReadWrite     (DtSockAsyncRead | DtSockAsyncWrite)
#define DtSockWriteable      ((DtU32)DtWrite | DtSockAsyncWrite)
#define DtSockReadable       ((DtU32)DtRead | DtSockAsyncRead)
#define DtSockOptAddrReuse   ((DtU32) 0x400)
#define DtSockOptPortReuse   ((DtU32) 0x800)
#define DtSockOptAllReuse    (DtSockOptAddrReuse | DtSockOptPortReuse)
#define DtSockDisablePreProcCallbacks ((DtU32) 0x1000)
#define DtSockDisablePostProcCallbacks ((DtU32) 0x2000)
#define DtSockDisableCallbacks (DtSockDisablePreProcCallbacks || DtSockDisablePostProcCallbacks)
// By default client sockets will be configured for blocking mode, read-write
// operation, address and port reuse enabled (UDP), NODELAY (TCP) operation.
#define DtDefaultSockOpts (DtU32)(DtReadWrite | DtSockOptAllReuse | DtSockOptNoDelay)

class DtInetSocket;

// STOPPED HERE -- use shared_ptr for buffers see Boost documentation on reference-counted buffers
typedef std::vector<char> DtInetBuffer;
typedef std::vector<DtInetBuffer*> DtInetBufferChain;
typedef std::pair<void*, DtInetBuffer*> DtInetBuffQueueEntry;
typedef DtThreadSafe<std::deque<DtInetBuffQueueEntry> > DtInetThreadSafeQueue;
typedef DtThreadSafe<std::deque<DtTime> > DtInetThreadSafeTSQueue;

enum DtInetSockState
{
   DtInetSockState_ERROR           = -1,
   DtInetSockState_NOT_INITIALIZED =  0,
   DtInetSockState_INITIALIZED,
   DtInetSockState_OPEN,
   DtInetSockState_LISTENING,
   DtInetSockState_INPROGRESS,
   DtInetSockState_CONN_REFUSED,
   DtInetSockState_CONNECTED,
   DtInetSockState_TIMEDOUT,
   DtInetSockState_DISCONNECTED,
   DtInetSockState_CLOSED

};

enum DtInetSockRcvStatus
{
   DtInetSockRcv_UNBUNDLED_PACKET        = -5,
   DtInetSockRcv_BUFFER_TOO_SMALL = -4,
   DtInetSockRcv_FILTERED_BY_PORT = -3,
   DtInetSockRcv_FILTERED_PACKET  = -2,
   DtInetSockRcv_ERROR            = -1,
   DtInetSockRcv_NO_PACKET        = 0,
   // Any value greater than NO_PACKET represents
   // the number of bytes received
   DtInetSockRcv_MAX_RETVAL       = INT_MAX

};

enum DtInetSockFlushStatus
{
   DtInetSockFlush_ERROR            = -1,
   DtInetSockFlush_MORE_TO_FLUSH    =  0,
   DtInetSockFlush_FLUSH_COMPLETE   =  1

};

enum DtInetSockProcessingType
{
   DtInetSockProcess_PRE_RECV,
   DtInetSockProcess_POST_RECV,
   DtInetSockProcess_PRE_SEND,
   DtInetSockProcess_POST_SEND
};

typedef int (*DtInetSocketProcessingCallback)( DtInetSocket* sock, int size,
                                               DtInetBufferChain& buffChain,
                                               DtInetEndpoint& ep, void* usr);
class DtInetSocketProcessingCbInfo
{
public:

   DtInetSocketProcessingCbInfo( DtInetSocketProcessingCallback cb, void* usr, 
      int order )
   {
      myCb = cb;
      myUsr = usr;
      myCallOrder = order;
   }

   DtInetSocketProcessingCallback myCb;
   void* myUsr;
   int   myCallOrder;
};
typedef std::multimap<int, DtInetSocketProcessingCbInfo*> DtInetSockCallbackList;


class DT_DLL_VLUTIL DtInetSocket
{
public:
    
   DtInetSocket();

   virtual ~DtInetSocket();

   virtual bool setDestination( const DtInetEndpoint& dest ) = 0;
   virtual const DtInetEndpoint& destination() const;

   virtual const DtInetEndpoint& localEndpoint() const;

   virtual bool setLocalPort( DtU16 port );
   virtual DtU16 localPort() const;

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

   virtual const DtInetDevice* hostIf() const;

   virtual bool openSocket() = 0;

   virtual bool closeSocket() = 0;

   virtual bool connectToDestination() = 0;


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

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

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


   virtual DtInetSockRcvStatus recv( caddr_t buff, size_t buffSize,
      DtU32 flags = 0 ) = 0;

   virtual DtInetSockRcvStatus recvToChain( DtInetBufferChain& packets,
      DtU32 flags = 0 ) = 0;

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

   virtual DtInetSockState state();

   virtual bool isOk();

   virtual DtU32 protocol() const;

   virtual DtInetUtils::DtInetAddrFamily family() const;

   virtual unsigned descriptor() const = 0;

   virtual DtU32 flags() { return myFlags; }

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

   virtual bool setNonBlockingOption( bool onOrOff ) = 0;
   virtual bool setReuseAddressOption( bool onOrOff ) = 0;
   virtual bool setSendBufferSize( DtU32 size ) = 0;
   virtual bool setReceiveBufferSize( DtU32 size ) = 0;
   virtual bool setDoNotRouteOption( bool onOrOff ) = 0;
   virtual bool setSendLowWatermark( DtU32 size ) = 0;
   virtual bool setReceiveLowWatermark( DtU32 size ) = 0;

   virtual bool  isNonBlocking() const;
   virtual bool  isNoDelay() const;
   virtual bool  getReuseAddressOption() = 0;
   virtual bool  getDoNotRouteOption() = 0;
   virtual DtU32 getSendBufferSize() = 0;
   virtual DtU32 getReceiveBufferSize() = 0;
   virtual DtU32 getBytesAvailable() = 0;
   virtual DtU32 getSendLowWatermark() = 0;
   virtual DtU32 getReceiveLowWatermark() = 0;

   virtual bool isIPv4() const;
   virtual bool isIPv6() const;
   virtual bool isTcp() const;
   virtual bool isUdp() const;

   virtual int      getLastError();
   virtual DtString getLastErrorString();
   virtual bool     isErrorWouldBlockOrTryAgain();
   virtual void     clearError();

   virtual int      getTerminationCode();
   virtual DtString getTerminationString();

   virtual DtU64 totalBytesSent() const;
   virtual DtU64 totalPacketsSent() const;
   virtual DtU64 totalBytesReceived() const;
   virtual DtU64 totalPacketsReceived() const;

   virtual void clearStats();

   virtual bool addProcessingCallback( DtInetSockProcessingType kind, 
      DtInetSocketProcessingCallback cb, void* usr, int callSequence = -1 );
   
   virtual bool removeProcessingCallback( DtInetSockProcessingType kind, 
      DtInetSocketProcessingCallback cb );

   // Absolute time of arrival of the datagram just read
   virtual DtTime receiveTime() { return myReceiveTime; }

#ifdef _WIN32

   inline HANDLE getReadHandle() const { return myInetReadHandle; }
#endif

protected:
   virtual bool findAndRemoveCallback( DtInetSockCallbackList& cbList,
      DtInetSocketProcessingCallback cb );

private:
   DtInetSocket( const DtInetSocket& orig );

   DtInetSocket& operator=(const DtInetSocket& orig);

protected:
#ifdef _WIN32
   HANDLE myInetReadHandle;
#endif

   DtInetEndpoint myLocalEndpoint;
   DtInetEndpoint myRemoteEndpoint;

   DtInetDevice* myHostIf;

   DtInetSockState myState;

   DtU32 myFlags;
   bool  myAsync;
   bool  myNonBlockingEnabled;
   bool  myNoDelayEnabled;
   bool  myStartImmediately;

   int      myErrorCode;
   DtString myErrorString;

   int      myTerminationCode;
   DtString myTerminationString;

   DtInetSockCallbackList myPreRecvCallbacks;
   DtInetSockCallbackList myPostRecvCallbacks;
   DtInetSockCallbackList myPreSendCallbacks;
   DtInetSockCallbackList myPostSendCallbacks;

   // For internal statistics only
   DtU64 mySentByteCount;
   DtU64 mySentPacketCount;
   DtU64 myReceivedByteCount;
   DtU64 myReceivedPacketCount;

   // Absolute time of arrival of the datagram just read
   DtTime myReceiveTime;
};
// end of class DtInetSocket

inline DtU64 DtInetSocket::totalBytesSent() const
{
   return mySentByteCount;
}

inline DtU64 DtInetSocket::totalPacketsSent() const
{
   return mySentPacketCount;
}

inline DtU64 DtInetSocket::totalBytesReceived() const
{
   return myReceivedByteCount;
}

inline DtU64 DtInetSocket::totalPacketsReceived() const
{
   return myReceivedPacketCount;
}

inline void DtInetSocket::clearStats()
{
   mySentByteCount = 0;
   mySentPacketCount = 0;
   myReceivedByteCount = 0;
   myReceivedPacketCount = 0;
}

inline bool DtInetSocket::findAndRemoveCallback( DtInetSockCallbackList& cbList,
                                                 DtInetSocketProcessingCallback cb )
{
   bool found = false;
   DtInetSockCallbackList::iterator iter = cbList.begin();
   while ( !found && iter != cbList.end() )
   {
      if ( cb == iter->second->myCb )
      {
         DtDELETE(iter->second);
         cbList.erase( iter );
         found = true;
      }
      else
      {
         ++iter;
      }
   }

   return found;
}

#ifdef DtUSE_UTILITIES_NAMESPACE
} 
#endif