vlDisSocket.h

Go to the documentation of this file.

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

#include <vlutil/vlInetUdpSocket.h>
#include <vlutil/vlInetSocketUtils.h>
#include <vlutil/vlNetTimeStamp.h>
#include <vlutil/vlList.h>
#include <set>

enum DtPduTestOperator {  DtPduTest_EQ, DtPduTest_NEQ } ;
enum DtPduFilterType { DtPduFtInetAddr, DtPduFtNetU8 };

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

#define DtDEFAULT_DIS_PORT 3000

class DT_DLL_VLUTIL DtPduFilterTest
{
  public:
    DtPduFilterTest() { disableTest();}
    virtual ~DtPduFilterTest() {}

    void disableTest()                              { setTest(DtPduTest_NEQ, 0, 0); }
    void setTest(DtPduTestOperator op, DtU32 value) { setTest(op, 1, &value);    }
    void extendTest(DtU32 value)                    { extendTest (1, &value);    }
    void reduceTest(DtU32 value)                    { reduceTest (1, &value);    }
    virtual void setOperator(DtPduTestOperator op);
    virtual void setTest(DtPduTestOperator op, int n, DtU32 *values);
    virtual void extendTest(int n, DtU32 *values);
    virtual void reduceTest(int n, DtU32 *values);
    
    virtual bool evalTest(void* buf, int offset, DtPduFilterType type);

  protected:

    virtual void clearList();
    DtPduTestOperator testOp;
    DtList values;
};

class DtDisSockPimpl;

class DT_DLL_VLUTIL DtDisSocket : public DtInetUdpSocket
{
public:
   DtDisSocket( const DtInetEndpoint& dest, DtU16 localPort = 0, 
                DtInetDevice* hostIf = NULL, DtU32 flags = DtDefaultSockOpts,
                bool immediateOpen = true, 
                bool suppressSelfReflectEnabled = false );

   virtual ~DtDisSocket();

   virtual bool openSocket();

   virtual bool closeSocket();

   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 recvFrom( caddr_t buff, size_t buffSize,
                                         DtInetEndpoint& src,
                                         DtU32 flags = 0 );

   virtual bool addDestination(const DtInetEndpoint& destination);

   virtual void removeDestination(const DtInetEndpoint& destination);


   virtual bool setSendSockNonBlockingOption( bool onOrOff );
   virtual bool setSendSockSendBuffSize( DtU32 size );
   virtual bool setSendSockRcvBuffSize( DtU32 size );
   virtual bool setSendSockBroadcastOption( bool onOrOff );
   virtual bool setSendSockReuseAddrOption( bool onOrOff );
   virtual bool setSendSockDoNotRouteOption( bool onOrOff );
   virtual bool setSendSockSendLowWatermark( DtU32 size );
   virtual bool setSendSockRcvLowWatermark( DtU32 size );
   virtual bool setSendSockMcastDevice( DtInetAddr devAddr );
   virtual bool setSendSockMcastDevice( DtInetDevice* hostIf );

   virtual DtU32 getSendSockSendBuffSize();
   virtual DtU32 getSendSockRcvBuffSize();
   virtual DtU32 getSendSockBytesAvailable();
   virtual bool  getSendSockBroadcastOption();
   virtual bool  getSendSockReuseAddrOption();
   virtual bool  getSendSockDoNotRouteOption();
   virtual DtU32 getSendSockSendLowWatermark();
   virtual DtU32 getSendSockRcvLowWatermark();

    virtual bool sendSockJoinMulticastGroup( DtInetAddr grpAddr, 
                                             DtInetDevice* device = NULL );
    virtual bool sendSockJoinMulticastGroup( DtInetEndpoint grpEndpoint, 
                                             DtInetDevice* device = NULL );
    virtual bool sendSockDropMulticastGroup( DtInetAddr grpAddr, 
                                             DtInetDevice* device = NULL );
    virtual bool sendSockDropMulticastGroup( DtInetEndpoint grpEndpoint, 
                                             DtInetDevice* device = NULL );
   virtual bool setSendSockMcastTtlOption( DtU32 ttl );



   virtual void setBundling( int maxBundleSize, bool enableUnbundling, 
      int minPacketSize, int sizeOffset, int sizeLength, bool testDisHeader );
   
   virtual bool setMaxBundleSize( int size );
   virtual int  getMaxBundleSize();
   virtual bool isBundling();

   virtual void setUnbundling( int onOrOff );
   virtual int  isUnbundling();

   virtual void setMinPacketSize( int size );   
   virtual int  minPacketSize();
   
   virtual DtPduFilterTest *exerciseId();
   virtual DtPduFilterTest *protocolVersion();
   virtual DtPduFilterTest *pduKind();
   virtual DtPduFilterTest *ipAddr();

   virtual DtInetEndpoint& localSenderEndpoint() const;

   virtual DtInetSockFlushStatus flush();

   virtual int addToBundle( int size, DtInetBufferChain& buffChain, 
                            DtInetEndpoint& ep );
   virtual int unbundle( int size, DtInetBufferChain& buffChain, 
                         DtInetEndpoint& ep, int* status );
   virtual int getNextBundle( int size, DtInetBufferChain& buffChain, 
                              DtInetEndpoint& ep, int* status );
   virtual DtInetSockFlushStatus flushBundle( DtInetEndpoint& ep );

   virtual int suppressSelfReflect( int size, DtInetBufferChain& buffChain, 
                                    DtInetEndpoint& ep, int* status );

   virtual int filterExercisePdus( int size, DtInetBufferChain& buffChain, 
                                   DtInetEndpoint& ep, int* status );

protected:
   virtual void* disSendSocket();

   static int addToBundle( DtInetSocket* sock, int size,
                           DtInetBufferChain& buffChain, DtInetEndpoint& ep, 
                           void* usr );
   static int flushBundle( DtInetSocket* sock, int size,
                           DtInetBufferChain& buffChain, DtInetEndpoint& ep, 
                           void* usr );
   static int unbundle( DtInetSocket* sock, int size,
                        DtInetBufferChain& buffChain, DtInetEndpoint& ep, 
                        void* usr );
   static int getNextBundle( DtInetSocket* sock, int size,
                             DtInetBufferChain& buffChain, DtInetEndpoint& ep,
                             void* usr );

   static int suppressSelfReflect( DtInetSocket* sock, int size,
                                   DtInetBufferChain& buffChain, 
                                   DtInetEndpoint& ep, void* usr );

   static int filterExercisePdus( DtInetSocket* sock, int size,
                                  DtInetBufferChain& buffChain, 
                                  DtInetEndpoint& ep, void* usr );

   virtual DtInetDevice* findInterface( const DtInetAddr& dest );

   // Determine size of PDU during unbundling
   struct DtDisSocketPduHeader; // forward declaration. 
   virtual DtU16 getPduSize( DtDisSocketPduHeader* hdr, 
                     int hdrOffset, DtInetBufferChain::iterator current,
                     DtInetBufferChain::iterator end, int* status );


private:
   DtDisSocket( const DtDisSocket& orig );

   DtDisSocket& operator=(const DtDisSocket& orig);

   friend class DtDisSockPimpl;
   DtDisSockPimpl* myAsyncSendSockPimpl;

protected:
   // The send socket is only used when self-reflect filtering is enabled
   
   void*          mySendSocketIoService;

   void*          mySendSocket; 

   DtInetEndpoint mySendEndpoint;
   std::set<DtInetEndpoint> myAdditionalDestinations;

   bool mySuppressSelfReflect;

   // Bundle buffers and control members
   DtInetUtils::DtInetSockOutboundBundleMap   myOutboundBundles;
   DtInetUtils::DtInetSockInboundBundleQueue  myInboundBundles;

   int                               myMaxBundleSize; // outbound only
   int                               myMinBundleSize; // outbound only
   bool                              myUnbundlingEnabled;

   /* per Document IST-CR-93-15 Section 5.3.15 */
   struct DtDisSocketPduHeader
   {
      DtNetU8           version;
      DtNetU8           DtExercise;
      DtNetU8           DtKind;
      DtNetU8           family;
      DtNetTimeStamp    DtTime;
      DtNetU16          DtLength;
      DtNetU16          unused_16;
   };

    DtPduFilterTest myVersionFilter;
    DtPduFilterTest myExerciseFilter;
    DtPduFilterTest myKindFilter;
    DtPduFilterTest myAddrFilter;

}; 
// end of class DtDisSocket

inline DtPduFilterTest *DtDisSocket::exerciseId()      
{ 
   return &myExerciseFilter; 
}

inline DtPduFilterTest *DtDisSocket::protocolVersion()
{ 
   return &myVersionFilter;  
}

inline DtPduFilterTest *DtDisSocket::pduKind()         
{ 
   return &myKindFilter;     
}

inline DtPduFilterTest *DtDisSocket::ipAddr()          
{ 
   return &myAddrFilter;     
}


#ifdef DtUSE_UTILITIES_NAMESPACE
} 
#endif