vlClientSocket.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1993, 1994, 1995, 1997 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: vlClientSocket.h,v $ $Revision: 1.2.6.1 $ $State: Exp $
*********************************************************************/
#ifndef vlClientSocket_H_
#define vlClientSocket_H_
 

#include <vlutil/vlNetTypes.h>
#include "vlSocket.h"
#include "vlNetSocket.h"
#include <vlutil/vlCliServer.h>

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

#if DT_HAVE_DAEMON
class DT_DLL_NETCOMPAT DtCsFilterTest : public DtFilterTest
{
  public:
    DtCsFilterTest(int fd,  DtU8 filterType, DtU32 clientId);
    virtual ~DtCsFilterTest();

    void setOperator(DtTestOperator op);
    void extendTest(int n, DtU32 *values);
    void reduceTest(int n, DtU32 *vals);
    bool evalTest(char *, int , DtFilterType){return true;}

  private:
    DtCsFilterMsg     filterMsg;
};
#endif

#define DtCsFlagsDefault (DtCsFlagsReadWrite | DtCsFlagsServerChooseDropMode )
#define DtCsQDefaultSize DtCsUseDefaultSize

class DT_DLL_NETCOMPAT DtClientSocket : public DtSocket
{
  public:

    DtClientSocket(int port, int recvQSize =
   DtCsQDefaultSize, unsigned short csFlags = DtCsFlagsDefault);

    DtClientSocket(int port, DtIpv4Addr destAddr, int recvQSize =
   DtCsQDefaultSize, unsigned short csFlags = DtCsFlagsDefault);

    ~DtClientSocket();
    
    int sendTo(caddr_t packet, size_t size, DtIpv4Addr addr);

    int DtRecv(caddr_t, size_t);  
    int DtRecv(caddr_t *buffptr, int *status=NULL);

    int listenToMulticastGroup(DtIpv4Addr multicastAddr);
    int dropMulticastGroup(DtIpv4Addr multicastAddr);
    int setMcastTtl(int ttl) { return netSock->setMcastTtl(ttl); }

    void setUnbundling(int onOff);
 
    DtIpv4Addr lastSourceInetAddr() { return sourceAddr; }
    void DtBecomeNonBlocking(void);
    
    int readFd()           { return recvFd;   }
    int writeFd()          { return sendFd;  }
    virtual bool isOk() const;
    bool isInternal();

    void setPsMsgTimeout(int seconds);

    void notifyMe();
    void disconnectFromServer();
    void setPacketServerInternal();
    void setPacketServerExternal();
    void pingClients();
    void testClients();
    void terminatePacketServer();
    void requestServerState();
    void requestServerCStates();
    void setPacketServerUnbundling(int onOff);

#if DT_HAVE_DAEMON
    DtFilterTest *exerciseId()      { return exercise; }
    DtFilterTest *protocolVersion() { return version; }
    DtFilterTest *pduKind()         { return kind; } 
    DtFilterTest *ipAddr()          { return addr; }   
#endif

    DtTime psMsgTimeout;

  protected:

    void init(int port, DtIpv4Addr destAddr, int recvQSize, 
         unsigned short csFlags);

    int timedRecv(caddr_t buf, size_t size, char *psKind);
    void drainNotifySocket();
    void checkGoAway();

#if DT_HAVE_DAEMON
    DtShmMsgQueueReader *reader;
#endif

    DtNetSocket *netSock;
    bool notifyPending;

    bool myOkFlag;
    int recvFd;
    int sendFd;
    long clientId;

  private:

    void processControlMsg(DtCsMsg *msg);
    DtCsMsg *getPsMsg (DtCsMsg *buf, char desiredKind);
    void cleanup(void);

#if DT_HAVE_DAEMON
    DtCsFilterTest *exercise;
    DtCsFilterTest *version;
    DtCsFilterTest *kind;
    DtCsFilterTest *addr;
#endif

    DtIpv4Addr destAddr;
    char clientSocketPath[DtCsClientPathSize];
    int serverPort;
    bool internal;
    DtIpv4Addr sourceAddr;
    DtNetFloat64* pktBuff8;

    char *shmAddr;
#if DT_HAVE_DAEMON
    DtCsControlReqMsg *controlMsg;
#endif
};

inline bool DtClientSocket::isOk() const       
{ 
   return myOkFlag;       
}

#ifdef DtUSE_UTILITIES_NAMESPACE
} 
#endif

#endif /* _CLIENTSOCKET_H_ */