vlSocket.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992, 1997 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: vlSocket.h,v $ $Revision: 1.2.6.2 $ $State: Exp $
*********************************************************************/
#ifndef vlSocket_H_
#define vlSocket_H_

#include <vlutil/vlConfig.h>
#include <vlutil/vlUtil.h>
#include <vlutil/vlList.h>
#include <vlutil/vlMutex.h>

#if DT_HAVE_STD_H
#include <std.h>
#endif

#include <stdio.h>
#include <sys/types.h>
#include <map>
#include <vector>

struct ifconf;

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif



#define DtDEFAULT_MAX_PACKET_SIZE  15000 //! Multiple of 8 bytes.
#define DtDEFAULT_PORT 3000

#ifdef DtUSE_UTILITIES_NAMESPACE
const DtIpv4Addr DtUSE_DEFAULT_IP_ADDR = DtUSE_UTILITIES_NAMESPACE::DtIpv4Addr(0);
#else
const DtIpv4Addr DtUSE_DEFAULT_IP_ADDR = DtIpv4Addr(0);
#endif

#define DtSOCKET_PACKET      1
#define DtSOCKET_NO_PACKET        0
#define DtSOCKET_SERVER_MSG      -1
#define DtSOCKET_FILTERED_PACKET -2
#define DtSOCKET_FILTERED_BY_PORT -3


enum DtTestOperator {  Dto_EQ, Dto_NEQ } ;

enum DtFilterType { DtFtInetAddr, DtFtNetU8 };

enum DtFlushStatus
{
   DtFlushError = -1, 
   DtFlushIncomplete, 
   DtFlushComplete   
};

class DT_DLL_NETCOMPAT DtFilterTest
{
  public:
    DtFilterTest() { disableTest();}
    virtual ~DtFilterTest() {}

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

  protected:

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

class DT_DLL_NETCOMPAT DtSocket
{
  public:
    
    DtSocket();

    virtual ~DtSocket();

    virtual int DtSend(caddr_t packet, size_t size, 
             DtIpv4Addr addr = DtUSE_DEFAULT_IP_ADDR);

    virtual int sendTo(caddr_t packet, size_t size, 
             DtIpv4Addr addr = DtUSE_DEFAULT_IP_ADDR) = 0;

    virtual int DtRecv(caddr_t *buffptr, int *status=0) = 0;

    virtual int DtRecv(caddr_t buff, size_t) = 0;
    caddr_t DtRecv();

    virtual DtFlushStatus flush();

    virtual DtFlushStatus flush(long& byteCount);

    virtual void setReceiveBufferSize(int newsize);

    virtual void setSendBufferSize(int newsize);
   
    virtual void setBundling(int maxSize);
    virtual int isBundling();
    virtual void setUnbundling(int);

    virtual DtIpv4Addr lastSourceInetAddr();
    virtual int DtReportPktsRcvd(void);
    virtual void DtBecomeNonBlocking(void);
    virtual void notifyMe();

    virtual int listenToMulticastGroup(DtIpv4Addr addr, DtIpv4Addr netInterface = DtUSE_DEFAULT_IP_ADDR);
    virtual int dropMulticastGroup(DtIpv4Addr addr, DtIpv4Addr netInterface = DtUSE_DEFAULT_IP_ADDR);
    virtual int setMcastTtl(int);
    virtual void setMcastDevice(DtIpv4Addr);

    virtual DtFilterTest *exerciseId();
    virtual DtFilterTest *protocolVersion();
    virtual DtFilterTest *pduKind();
    virtual DtFilterTest *ipAddr();
    
    
    int myBlockingFlag;
    int pkts_rcvd;
    
    virtual int readFd();
    virtual int writeFd();
    virtual bool isOk() const;

    static void initializeNetwork();
    

    static void setQuietSockets(bool quietVal);
    static bool areQuietSockets();

  protected:
    
#ifdef _WIN32
    static void winInit();
    static void winClose();
    static int theWindowsInitializedCount;
    static DtMutex theWindowsInitMutex;
#endif

    static bool theAreQuietSockets;

   static int getConfig(const char* device, int sock, ifconf* ifc);

  protected:

    virtual bool accept(char *buf, DtIpv4Addr iaddr);

    typedef std::vector<char> Buffer;
    typedef std::map<DtIpv4Addr, Buffer> BufferMap; 

    BufferMap myBufferMap;

    int myBundlingFlag;
    int myMaxBundleSize;
    int mySockFd;


  private:
    DtSocket(const DtSocket &);

    DtSocket &operator=(const DtSocket &);

  private:

    DtFilterTest myVersionFilter;
    DtFilterTest myExerciseFilter;
    DtFilterTest myKindFilter;
    DtFilterTest myAddrFilter;
};

DT_DLL_NETCOMPAT DtSocket *DtNewDfltSocket(int port, DtIpv4Addr destAddr = 0,
                                        bool use_async = false);
DT_DLL_NETCOMPAT int DtMaxPacketSize();

DT_DLL_NETCOMPAT void DtSetMaxPacketSize(int size);

#ifdef DtUSE_UTILITIES_NAMESPACE
}
#endif

#define vlSocket_inl_
#include "vlSocket.inl"
#undef vlSocket_inl_

#endif