vlDisSocket.h

Go to the documentation of this file.

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


#pragma once

#include <vlutil/vlAttributePduStrategy.h>
#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

#define DtDIS_HEADER_PROTOCOL_VERSION_BYTE_OFFSET 0
#define DtDIS_HEADER_EXERCISE_IDENTIFIER_BYTE_OFFSET 1
#define DtDIS_HEADER_PDU_TYPE_BYTE_OFFSET 2
#define DtDIS_HEADER_PROTOCOL_FAMILY_BYTE_OFFSET 3
#define DtDIS_HEADER_TIMESTAMP_BYTE_OFFSET 4
#define DtDIS_HEADER_LENGTH_BYTE_OFFSET 8
#define DtDIS_HEADER_PDU_STATUS_BYTE_OFFSET 10

// Mask to extract the Coupled Extension Indicator from bit 3 (00001000)
#define DtDIS_HEADER_CEI_QUERY_MASK 0x8

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 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 setSendMcastDevice( const DtInetAddr& devAddr );
   virtual bool setMcastTtlOption( DtU32 ttl );



   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 void setBundling( int maxBundleSize, int sizeOffset, int sizeLength,
      bool testDisHeader );

   virtual bool setMaxBundleSize( int size );
   virtual int  getMaxBundleSize();
   virtual bool isBundling();

   virtual void setMinPacketSize( int size );
   virtual int  minPacketSize();

   virtual void setBundleByteAlignment( DtU32 size );
   virtual DtU32 sendBundleByteAlignment();
   // Return the bundle by alignment for the given protocol version
   virtual DtU32 receiveBundleByteAlignment(int protocolVersion);

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

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

   virtual void setAttributePduStrategy(DtAttributePduStrategy strat);
   virtual DtAttributePduStrategy attributePduStrategy() const;

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

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

   // 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, bool& isCoupling, bool expectAttributePdu = false);

   // Determine size of a Coupled PDU during unbundling
   virtual DtU16 getCoupledAttributePduSize( DtDisSocketPduHeader* hdr,
      int hdrOffset, DtInetBufferChain::iterator current,
      DtInetBufferChain::iterator end, int* status, int pduLengthAndPadding, unsigned int size);

   // From the given iterator walk through chain for the given offset number of bytes.
   // Return an iterator to the buffer containing the offset or end if offset past end of chain.
   virtual DtInetBufferChain::iterator advanceToOffset(DtU16& offset,
      DtInetBufferChain::iterator chainIter, DtInetBufferChain::iterator chainEnd);

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
   DtU32 myBundleByteAlignment;
   int myMinPacketSize; // inbound only

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

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

    DtMutex myMonitor;
    bool &myUseMonitor;

    DtAttributePduStrategy myAttributePduStrategy;
};
// 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