vlNetSocket.h

Go to the documentation of this file.

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


#include <vlutil/vlMachineTypes.h>
#include <vlutil/vlNetTypes.h>
#include "vlSocket.h"
#include <vlutil/vlUtil.h>

struct sockaddr_in;
struct ifreq;

#if defined(__solaris__) || defined(__sgi__)
#define DtRead                 ((DtU8) 0x01)
#define DtWrite                   ((DtU8)  0x02)
#define DtReadWrite             (DtRead | DtWrite)
#define DtBindToDestAddr        ((DtU8) 0x08)
#define DtQuiet                 ((DtU8) 0x10)
#else
#include <vlutil/vlInetSocket.h>
#endif

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

DT_DLL_NETCOMPAT DtIpv4Addr DtInetBroadcastOfDevice( const char* device );

DT_DLL_NETCOMPAT DtIpv4Addr DtInetAddrOfDevice( const char* device );

DT_DLL_NETCOMPAT DtIpv4Addr DtNetMaskOfDevice( const char* device );

DT_DLL_NETCOMPAT DtIpv4Addr DtFirstHostInetAddr();

DT_DLL_NETCOMPAT int DtIsMulticastAddr( DtIpv4Addr addr );

enum DtInitErrorAction 
{ 
   DtInitErrorFatal, 
   DtInitErrorWarn, 
   DtInitErrorIgnore
};

class DT_DLL_NETCOMPAT DtNetSocket : public DtSocket
{
public:
   
   DtNetSocket(int port = DtDEFAULT_PORT, DtU8 flags = DtReadWrite, DtIpv4Addr devAddr = 0);

   DtNetSocket(int port, DtIpv4Addr destAddr, DtU8 flags, DtIpv4Addr devAddr = 0);

   DtNetSocket(char* dummy, int sockfd, DtU8 flags = DtReadWrite);

   virtual ~DtNetSocket();
   
   virtual int sendTo(caddr_t packet, size_t size, DtIpv4Addr addr);
   
   virtual int DtRecv(caddr_t* buffptr, int* status = NULL);

   virtual int DtRecv(caddr_t buff, size_t);

   virtual DtIpv4Addr lastSourceInetAddr();
   
   virtual void DtBecomeNonBlocking(void);


   

   virtual void setBundling( int maxBundleSize, bool enableUnbundling, 
      int minPacketSize, int sizeOffset, int sizeLength, bool testDisHeader );

   virtual void setBundling( int maxBundleSize);
   
   virtual void setUnbundling(int onOff);
   virtual int isUnbundling();
   
   virtual int minPacketSize();
   virtual void setMinPacketSize( int size );   
   
   virtual int sizeOffset();
   virtual void setSizeOffset( int offset );

   virtual int sizeLength();
   virtual void setSizeLength( int length );

   virtual bool testDisHeader();
   virtual void enableDisHeaderTest( bool shouldTest );

   virtual int readFd();
   virtual int writeFd();
   
   virtual bool isOk() const;
   
   virtual int listenToMulticastGroup(
      DtIpv4Addr multicastAddr, DtIpv4Addr netInterface = DtUSE_DEFAULT_IP_ADDR );
   virtual int dropMulticastGroup(
      DtIpv4Addr multicastAddr, DtIpv4Addr netInterface = DtUSE_DEFAULT_IP_ADDR );
   
   virtual int setMcastTtl(int ttl);

   virtual void setMcastDevice(DtIpv4Addr devAddr);
   virtual DtIpv4Addr mcastDevice() const;
   
   virtual void setFilterPort(const int& port);

   virtual void setSendPort(const int& port);

public:
   
   static int isMulticastAddr(DtIpv4Addr addr);

   static int enableBroadcast(int sockfd);

   static void makeNonBlocking(int sockfd);

   static int makeReusable(int sockfd);

   static void setRetryOnSend(unsigned int numRetries, double waitPeriod);

   static DtIpv4Addr inetBroadcastOfDevice(const char *device = NULL);
   static DtIpv4Addr inetAddrOfDevice(const char *device = NULL);
   static DtIpv4Addr netMaskOfDevice(const char *device = NULL);
   static DtIpv4Addr firstHostInetAddr();

   static void setInetAddr(sockaddr_in &s, u_long addr, int port);

#ifdef _WIN32
   static DtIpv4Addr envNetMask();

   static void netMaskFromReg(char* tszNetMask);

   static DtIpv4Addr systemNetMask();
#endif

public:
   
   static DtInitErrorAction initErrorAction;

protected:

   void init(int port, DtIpv4Addr dest_addr, DtU8 flags, DtIpv4Addr devAddr = 0);

   virtual int dataLeftInCurrentBundle();

   virtual int retrySendTo( caddr_t packet, size_t size, sockaddr_in& dest );

   virtual int recvWithStatus(caddr_t* buffptr, int* status);

   virtual int recvFromNet(caddr_t* buffptr);

   virtual int recvWithUnbundling(caddr_t* buffptr);

   int initSocket();

   int initWrite(DtIpv4Addr dest);

   int initRead(DtIpv4Addr dest);

   virtual int privateListenToMulticastGroup(DtIpv4Addr multicastAddr,
      int on_init = 0, DtIpv4Addr netInterface = DtUSE_DEFAULT_IP_ADDR );

   virtual void findNextPacket();

   virtual unsigned int getNextPacketSize();
   
   virtual unsigned int currentHeaderMatchesFirstInBundle();
   
protected:
   
   static ifreq* findIfr(
      const char* device, int sock, ifconf* ifc);

   static DtIpv4Addr netMaskOfIfr(ifreq *ifr, int sock);
   static DtIpv4Addr inetAddrOfIfr(ifreq *ifr, int sock);
   static DtIpv4Addr inetBroadcastOfIfr(ifreq *ifr, int sock);
   static bool capableOfIpBroadcast(ifreq* ifr, int sock);

      
protected:
   
   int myUdpPort;
   int myFilterPort;
   int mySendPort;
   unsigned int mySourcePort;
   char* myPktBuff;
   char* myUnbundleBuff;
   void* myNextPacket;
   int myUsingExternalSocket;
   DtIpv4Addr myExtSockAddr;
   DtIpv4Addr myDestInetAddr;
   DtIpv4Addr myDevAddr;
   int myUnbundling;

   int sizeLeft;


   int myPktMinSize;
   int myPktSizeOffset;
   int myPktSizeLength;
   int myMaxPacketSize;
   bool myTestingDisHeader;

   int boundToDestAddr;
   int firstInBundle;
   int firstExId;
   int firstProtocol;

   bool myOkFlag;
   sockaddr_in* destSockAddr;
   sockaddr_in* sourceSockAddr;
   DtU8 myFlags;

protected:

   static unsigned int theMaxSendRetries;
   static double theSendRetryPeriod;

protected:

   DtNetSocket(const DtNetSocket &);

   DtNetSocket &operator=(const DtNetSocket &);
   
};

inline void DtNetSocket::setBundling( int maxBundleSize)
{
   DtSocket::setBundling(maxBundleSize);
}


#ifdef DtUSE_UTILITIES_NAMESPACE
} 
#endif

#endif