vlInetUdpSocket.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2015 VT MAK
 * All rights reserved.
 ****************************************************************************/


#pragma once

#include <vlutil/vlInetSocket.h>


#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

class DtInetUdpSockPimpl;

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

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

   virtual ~DtInetUdpSocket();

   virtual bool setDestination( const DtInetEndpoint& dest );

   virtual bool openSocket();

   virtual bool closeSocket();

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

   virtual bool connectToDestination();

   virtual bool disconnect();

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

   virtual unsigned descriptor() const;

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

   virtual bool setNonBlockingOption( bool onOrOff );
   virtual bool setSendBufferSize( DtU32 size );
   virtual bool setReceiveBufferSize( DtU32 size );
   virtual bool setBroadcastOption( bool onOrOff );
   virtual bool setReuseAddressOption( bool onOrOff );
   virtual bool setDoNotRouteOption( bool onOrOff );
   virtual bool setSendLowWatermark( DtU32 size );
   virtual bool setReceiveLowWatermark( DtU32 size );
   virtual bool setMcastDevice( const DtInetAddr& devAddr );
   virtual bool setMcastDevice( DtInetDevice* hostIf );

   virtual DtU32 getSendBufferSize();
   virtual DtU32 getReceiveBufferSize();
   virtual DtU32 getBytesAvailable();
   virtual bool  getBroadcastOption();
   virtual bool  getReuseAddressOption();
   virtual bool  getDoNotRouteOption();
   virtual DtU32 getSendLowWatermark();
   virtual DtU32 getReceiveLowWatermark();

    virtual bool joinMulticastGroup( const DtInetAddr& grpAddr,
                                     DtInetDevice* device = NULL );
    virtual bool joinMulticastGroup( const DtInetEndpoint& grpEndpoint,
                                     DtInetDevice* device = NULL );
    virtual bool dropMulticastGroup( const DtInetAddr& grpAddr,
                                     DtInetDevice* device = NULL );
    virtual bool dropMulticastGroup( const DtInetEndpoint& grpEndpoint,
                                     DtInetDevice* device = NULL );
   virtual bool setMcastTtlOption( DtU32 ttl );

   virtual void* udpSocket();

   virtual void* secondUdpSocket();

protected:

private:
   DtInetUdpSocket( const DtInetUdpSocket& orig );

   DtInetUdpSocket& operator=(const DtInetUdpSocket& orig);

   friend class DtInetUdpSockPimpl;
   DtInetUdpSockPimpl* myAsyncPimpl;

protected:
   void* myIoService;
   void* myUdpSocket;
   //A second socket is only opened in the case that we're running linux AND
   //we want to bind a socket to a specific device address while using broadcast
   //This isn't possible with one boost socket, so we make a second just to listen for broadcast messages.
   void* mySecondUdpSocket;

   // Since DtInetAddr can be either an IPv4 or IPv6 address the use of a
   // std::map would be problematic since there's no easy way to compare
   // addresses without defining a predicate functor.
   typedef std::pair<DtInetAddr, DtInetAddr> DtInetMcastGroupIntfcBinding;
   typedef std::vector<DtInetMcastGroupIntfcBinding> DtInetMcastGroupBindings;
   DtInetMcastGroupBindings myMcastGroups;
   DtClock myReceiveClock;

};
// end of class DtInetUdpSocket

#ifdef DtUSE_UTILITIES_NAMESPACE
} 
#endif