vlCliServer.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2025 MAK Technologies, Inc
** All rights reserved.
*********************************************************************/
#pragma once

#include <stdio.h>
#include <string.h>
#include "vlUtil.h"

#if DT_HAVE_DAEMON
#include "vlShmQueue.h"

#include "vlShmReader.h"
#include "vlShmWriter.h"
#endif

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

/*****************************************
 * Constants used by Clients and Servers *
 *****************************************/

#define DtCsClientPathSize 160
#define DtCsMaxWarningSize 160

#define DtCsVersionApril95  2
#define DtCsVersionSeptember95  3
#define DtCsVersionCurrent DtCsVersionSeptember95
#define DtMinimumSendQSizeSupportedByVers2Server 32

#define DtCsClientTypePacket   0
#define DtCsClientTypeControl  1

#define DtCsUseDefaultSize    -1

#define DtCsFlagsRead                 0x0001
#define DtCsFlagsWrite                0x0002
#define DtCsFlagsReadWrite            (DtCsFlagsRead | DtCsFlagsWrite)

#define DtCsFlagsServerChooseDropMode 0x0004
#define DtCsFlagsServerDropOldest     0x0008
#define DtCsFlagsClientDropOldest     0x0010
#define DtCsFlagsDropOldest           (DtCsFlagsClientDropOldest | \
                                       DtCsFlagsServerDropOldest)

#define DtCsFlagsReadResourceWait     0x0020
#define DtCsFlagsWriteResourceWait    0x0040
#define DtCsFlagsResourceWait         (DtCsFlagsReadResourceWait | \
                                       DtCsFlagsWriteResourceWait)

#define DtCsFlagsDontNotify           0x0080
#define DtCsFlagsControlOnly          0x0100


/**********************************  
 * Messages from Client to Server *
 **********************************/



#define DtCsMsgWaitingKind       0


#define DtCsAddClientKind        1
#define DtCsClientPacketKind     2
#define DtCsControlReqKind       4
#define DtCsFilterKind           5
#define DtCsMulticastReqKind  13

    /**********************************  
     * Types of Control Req Messages  *
     **********************************/

#define     DtCsCrExternal           0
#define     DtCsCrInternal           1
#define     DtCsCrTestClients        2
#define     DtCsCrPing               3
#define     DtCsCrState              4
#define     DtCsCrCState             5
#define     DtCsCrQuit               6
#define     DtCsCrDisconnect         7
#define     DtCsCrUnbundle           8
#define     DtCsCrNoUnbundle         9

    /**********************************  
     *    Multicast Request Types     *
     **********************************/

#define  DtCsMSubscribe    0
#define  DtCsMUnsubscribe  1

/**********************************  
 * Messages from Server to Client *
 **********************************/




#define DtCsAckKind              6
#define DtCsCliQuotaKind         7


#define DtCsServerPacketKind     8
#define DtCsStateReturnKind      9
#define DtCsCStateReturnKind    10
#define DtCsWarningKind         11
#define DtCsNoticeKind          12

    /*****************************  
     * Types of Notice Messages  *
     *****************************/

#define     DtCsNExternal           0
#define     DtCsNInternal           1
#define     DtCsNExtCliQuota        2
#define     DtCsNPing               3
#define     DtCsNClosing            4


struct DtCsMsgHdr
{
    DtU8 kind;
    DtU8 version;
};

/**************************************
 * Messages sent to Client and Server *
 **************************************/

struct DtCsMsgWaiting
{
    DtCsMsgHdr hdr;
};

/*******************************
 * Messages sent to the Server *
 *******************************/


struct DtCsAddClient
{
    DtCsMsgHdr hdr;
    DtU16      flags;
    DtInt32    server2ClientSize;
    DtInt32    client2ServerSize;
    DtInt32    clientProcessId;
    char       clientPath[DtCsClientPathSize];
};


struct DtCsClientPacket
{
    DtCsMsgHdr hdr;
    DtU16      padding;
    DtU32      length;
};

struct DtCsControlReq
{
    DtCsMsgHdr hdr;
    DtU16      request;
    DtU32 clientId;
};

struct DtCsMulticastReq
{
    DtCsMsgHdr    hdr;
    DtU16         request;
    DtU32   addr;
    DtU32   clientId;
};

#define DtCsFilterTypeExercise  0
#define DtCsFilterTypeVersion   1
#define DtCsFilterTypePduKind   2
#define DtCsFilterTypeIpAddr    3

#define DtCsFilterOpSetOperator 0
#define DtCsFilterOpAddValue    1

#define DtCsOperatorEQ          0
#define DtCsOperatorNEQ         1

struct DtCsFilter
{
    DtCsMsgHdr hdr;
    DtU8       filterType;
    DtU8       filterOp;
    DtU32      value;
    DtU32      clientId;
};


/*******************************
 * Messages sent to the Server *
 *******************************/

struct DtCsAck
{
    DtCsMsgHdr hdr;
    DtU8       internal;
    DtU8       padding;      
    DtU32      clientId;
    DtU32      shmKey;
    DtU32      semKey;
    DtInt32    server2ClientSize;
    DtInt32    client2ServerSize;
};

struct DtCsCliQuota
{
    DtCsMsgHdr hdr;
};

struct DT_DLL_VLUTIL DtCsServerMsgWaiting
{
    DtCsMsgHdr hdr;
};


struct DtCsServerPacket
{
        DtCsMsgHdr hdr;
   DtU16      padding1;
   DtU32      sourceAddr;
   DtU32      arrivalTime;
   DtU32      length;
};

struct DtCsStateReturn
{
    DtCsMsgHdr hdr;
    DtU8       internal;
    DtU8       unbundling;
    DtU16      numPacketClients;
    DtU16      numControlClients;
    DtInt32    clientQuota;  
    DtU32      port;
};


#define DtCsCStateServerBlockRead  0x01
#define DtCsCStateServerBlockWrite 0x02
#define DtCsCStateClientBlockRead  0x04
#define DtCsCStateClientBlockWrite 0x08

struct DtCsCStateReturn
{
    DtCsMsgHdr hdr;
    DtU16      flags;
    DtU8       serverDropOldest;
    DtU8       serverResourceWait;
    DtU8       blockFlags;
    DtU8       padding;

    DtInt32    processId;
    DtU32      clientId;
    
    DtInt32    client2ServerSize;
    DtInt32    server2ClientSize;

    DtInt32    packetsRcvdFromClient;
    DtInt32    packetsSentToClient;

    DtInt32    newPacketsDropped;
    DtInt32    oldPacketsDropped;
};

struct DtCsWarning
{
    DtCsMsgHdr hdr;
    DtU16      reason;  
    char       warningMsg[DtCsMaxWarningSize];
};

struct DtCsNotice
{
    DtCsMsgHdr hdr;
    DtU16      notice;
};


union DtCsMsg
{
    DtCsMsgHdr              hdr;

    DtCsMsgWaiting          msgWaiting;

    DtCsAddClient           addClient;
    DtCsClientPacket        clientPacket;
    DtCsControlReq          controlReq;
    DtCsMulticastReq     multicastReq;
    DtCsFilter              filter;

    DtCsAck                 ack;
    DtCsCliQuota            cliQuota;
    DtCsServerPacket        serverPacket;
    DtCsStateReturn         stateReturn;
    DtCsCStateReturn        cStateReturn;
    DtCsWarning             warning;
    DtCsNotice              notice;
};


/*
 *
 */

class DT_DLL_VLUTIL DtClientServerMsg
{
  public:
    DtClientServerMsg() {}
    DtClientServerMsg(DtCsMsg *msg);

    virtual ~DtClientServerMsg() {}

    virtual int send() = 0;
    virtual void print();

    DtU8 kind()      { return msg.hdr.kind; }
    DtU8 version()   { return msg.hdr.version; }
    size_t msgSize() { return size; }

  protected:
    DtCsMsg msg;
    size_t size;

};

class DT_DLL_VLUTIL DtSocketMsg : public DtClientServerMsg
{
  public:
    DtSocketMsg(int sockId) { sendFd = sockId; }

    DtSocketMsg(int sockId, DtCsMsg *m) : DtClientServerMsg(m) 
   { sendFd = sockId; }

    virtual ~DtSocketMsg() {}

    virtual int send();

  private:
    int sendFd;
};

#if DT_HAVE_DAEMON
class DT_DLL_VLUTIL DtShmMsg : public DtClientServerMsg
{
  public:
    DtShmMsg(DtShmMsgQueueWriter *w) { writer = w; }
    DtShmMsg(DtShmMsgQueueWriter *w, DtCsMsg *m) : DtClientServerMsg(m) 
   { writer = w; }

    virtual ~DtShmMsg() {}

    virtual int send();

  protected:
    DtShmMsgQueueWriter *writer;
};
#endif

class DT_DLL_VLUTIL DtCsMsgWaitingMsg : public DtSocketMsg
{
  public:

    DtCsMsgWaitingMsg(int fd, DtCsMsg *m) : DtSocketMsg(fd, m) {}

    DtCsMsgWaitingMsg(int fd);

    virtual ~DtCsMsgWaitingMsg() {}
};


class DT_DLL_VLUTIL DtCsAddClientMsg : public DtSocketMsg
{
  public:

    DtCsAddClientMsg(int fd, DtCsMsg *m) : DtSocketMsg(fd, m) {}

    DtCsAddClientMsg(int fd, DtU16 flgs, DtInt32 s2cSize, DtInt32 c2sSize, 
   DtInt32 pid, char *path);

    virtual ~DtCsAddClientMsg() {}
    
    DtU16 flags()               { return msg.addClient.flags; }

    void setServer2ClientSize(DtU32 s){ msg.addClient.server2ClientSize = s; }
    DtInt32 server2ClientSize() { return msg.addClient.server2ClientSize; }

    void setClient2ServerSize(DtU32 s){ msg.addClient.client2ServerSize = s; }
    DtInt32 client2ServerSize() { return msg.addClient.client2ServerSize; }

    DtInt32 clientProcessId()   { return msg.addClient.clientProcessId; }
    char *clientPath()          { return msg.addClient.clientPath; }
};

#if DT_HAVE_DAEMON
class DT_DLL_VLUTIL DtCsClientPacketMsg : public DtShmMsg
{
  public:

    DtCsClientPacketMsg(DtShmMsgQueueWriter * w, DtCsMsg *m, char *d)
        : DtShmMsg(w, m) { theBytes = d; }

    DtCsClientPacketMsg(DtShmMsgQueueWriter * w, DtU32 length, char *d);

    virtual ~DtCsClientPacketMsg() {}

    int send();

    void setData(char *d) { theBytes = d; };
    char *data() { return theBytes; }

    DtU32 length() { return msg.clientPacket.length; }
    void setLength(DtU32 s) { msg.clientPacket.length = s; };

  private:
    char *theBytes;
};

class DT_DLL_VLUTIL DtCsControlReqMsg : public DtSocketMsg
{
  public:

    DtCsControlReqMsg(int fd, DtCsMsg *m) : DtSocketMsg(fd, m) {}
    DtCsControlReqMsg(int fd, DtU16 request, DtU32 clientId);

    virtual ~DtCsControlReqMsg() {}

    void setRequest(DtU16 r) {  msg.controlReq.request = r; }
    DtU16 request()    { return msg.controlReq.request; }
    DtU32 clientId()   { return msg.controlReq.clientId; }
    void setClientId(DtU32 id) {msg.controlReq.clientId = id; }
};

class DT_DLL_VLUTIL DtCsMulticastReqMsg : public DtSocketMsg
{
  public:

    DtCsMulticastReqMsg(int fd, DtCsMsg *m) : DtSocketMsg(fd, m) {}
    DtCsMulticastReqMsg(int fd, DtU16 request, DtIpv4Addr addr, 
         DtU32 clientId);

    virtual ~DtCsMulticastReqMsg() {}

    void setRequest(DtU16 r) {  msg.multicastReq.request = r; }
    DtU16 request()    { return msg.multicastReq.request; }
    DtU32 clientId()   { return msg.multicastReq.clientId; }
    void setClientId(DtU32 id) {msg.multicastReq.clientId = id; }
    void setAddr(DtIpv4Addr addr) {msg.multicastReq.addr = (DtU32) addr; }
    DtIpv4Addr addr() { return (DtIpv4Addr) msg.multicastReq.addr; }
};

class DT_DLL_VLUTIL DtCsFilterMsg : public DtSocketMsg
{
  public:
    
    DtCsFilterMsg(int fd, DtCsMsg *m) : DtSocketMsg(fd, m) {}
    DtCsFilterMsg(int fd, DtU8 type, DtU8 op, DtU32 val, DtU32 clientId);

    virtual ~DtCsFilterMsg() {}

    DtU8 filterType()          { return msg.filter.filterType; }

    DtU8 filterOp()            { return msg.filter.filterOp; }
    void setFilterOp (DtU8 op) { msg.filter.filterOp = op; }

    DtU32 value()              { return msg.filter.value; }
    void setValue (DtU32 val)  { msg.filter.value = val; }
    DtU32 clientId() {return msg.filter.clientId; }
    void setClientId(DtU32 id) {msg.filter.clientId = id; }
};


class DT_DLL_VLUTIL DtCsAckMsg : public DtSocketMsg
{
  public:

    DtCsAckMsg(int fd, DtCsMsg *m) : DtSocketMsg(fd, m) {}

    DtCsAckMsg(int fd, DtU8 internal, DtU32 clientId, DtU32 shmKey,
      DtU32 semKey, DtInt32 server2ClientSize, DtInt32 client2ServerSize);

    virtual ~DtCsAckMsg() {}

    DtU8 internal()             { return msg.ack.internal; }
    DtU32 clientId()            { return msg.ack.clientId; }
    DtU32 shmKey()              { return msg.ack.shmKey; }
    DtU32 semKey()              { return msg.ack.semKey; }
    DtInt32 server2ClientSize() { return msg.ack.server2ClientSize; }
    DtInt32 client2ServerSize() { return msg.ack.client2ServerSize; }

};

class DT_DLL_VLUTIL DtCsCliQuotaMsg : public DtSocketMsg
{
  public:

    DtCsCliQuotaMsg(int fd, DtCsMsg *m) : DtSocketMsg(fd, m) {}

    DtCsCliQuotaMsg(int fd);

    virtual ~DtCsCliQuotaMsg() {}
};

class DT_DLL_VLUTIL DtCsServerPacketMsg : public DtShmMsg
{
  public:

    DtCsServerPacketMsg(DtShmMsgQueueWriter * w, DtCsMsg *m, char *d) 
   : DtShmMsg(w, m) { theBytes = d; }

    DtCsServerPacketMsg(DtShmMsgQueueWriter * w, DtU32 sourceAddr, DtU32 
   arrivalTime, DtU32 length, char *d);

    virtual ~DtCsServerPacketMsg() {}

    int send();

    void setData(char *d)        { theBytes = d; };
    char *data()                 { return theBytes; }

    void setLength(DtU32 s)      { msg.serverPacket.length = s; };
    DtU32 length()               { return msg.serverPacket.length; }

    void setSourceAddr(DtU32 s)  { msg.serverPacket.sourceAddr = s; }
    DtU32 sourceAddr()           { return msg.serverPacket.sourceAddr; }

    void setArrivalTime(DtU32 a) { msg.serverPacket.arrivalTime = a; }
    DtU32 arrivalTime()          { return msg.serverPacket.arrivalTime; }

  private:

    char *theBytes;
};

class DT_DLL_VLUTIL DtCsStateReturnMsg : public DtShmMsg
{
  public:

    DtCsStateReturnMsg(DtShmMsgQueueWriter * w, DtCsMsg *m) : DtShmMsg(w, m) {}

    DtCsStateReturnMsg(DtShmMsgQueueWriter * w, DtU8 internal, DtU16 
   numPacketClients, DtU16 numControlClients, DtInt32 clientQuota,
   DtU32 prt, DtU8 ub);

    virtual ~DtCsStateReturnMsg() {}
    
    void print();

    DtU8 internal()           { return msg.stateReturn.internal; }
    DtU8 unbundling()         { return msg.stateReturn.unbundling; }
    DtU16 numPacketClients()  { return msg.stateReturn.numPacketClients; }
    DtU16 numControlClients() { return msg.stateReturn.numControlClients; }
    DtInt32 clientQuota()     { return msg.stateReturn.clientQuota; }
    DtU32  port()             { return msg.stateReturn.port; }
};

class DT_DLL_VLUTIL DtCsCStateReturnMsg : public DtShmMsg
{
  public:

    DtCsCStateReturnMsg(DtShmMsgQueueWriter * w, DtCsMsg *m) : DtShmMsg(w, m) {}

    DtCsCStateReturnMsg(DtShmMsgQueueWriter * w, DtU16 flags, 
   DtU8 serverDropOldest, DtU8 serverResourceWait, DtU8 blockFlags,
   DtInt32 processId, DtU32 clientId, DtInt32 client2ServerSize, 
   DtInt32 server2ClientSize, DtInt32 packetsRcvdFromClient, 
   DtInt32 packetsSendToClient, DtInt32 newPacketsDropped, 
   DtInt32 oldPacketsDropped);
    
    virtual ~DtCsCStateReturnMsg() {}

    void print();

    DtU16 flags()                   {return msg.cStateReturn.flags; }
    DtU8 serverDropOldest()         {return msg.cStateReturn.serverDropOldest; }
    DtU8 serverResourceWait()       {return 
                   msg.cStateReturn.serverResourceWait; }
    DtU8 blockFlags()               {return msg.cStateReturn.blockFlags; }

    DtInt32 processId()             {return msg.cStateReturn.processId; }
    DtU32 clientId()                {return msg.cStateReturn.clientId; }
    DtInt32 client2ServerSize()     {return msg.cStateReturn.client2ServerSize;}
    DtInt32 server2ClientSize()     {return msg.cStateReturn.server2ClientSize;}
    DtInt32 packetsRcvdFromClient() {return 
                   msg.cStateReturn.packetsRcvdFromClient; }
    DtInt32 packetsSendToClient()   {return 
                   msg.cStateReturn.packetsSentToClient; }
    DtInt32 newPacketsDropped()     {return 
                   msg.cStateReturn.newPacketsDropped; }
    DtInt32 oldPacketsDropped()     {return 
                   msg.cStateReturn.oldPacketsDropped; }
};

class DT_DLL_VLUTIL DtCsWarningMsg : public DtShmMsg
{
  public:

    DtCsWarningMsg(DtShmMsgQueueWriter * w, DtCsMsg *m) : DtShmMsg(w, m) {}

    DtCsWarningMsg(DtShmMsgQueueWriter * w, DtU16 reason, char *warningMsg);

    virtual ~DtCsWarningMsg() {}

    void print();

    DtU16 reason()      { return msg.warning.reason; }
    void setReason (DtU16 r) { msg.warning.reason = r; }
    char *warningMsg()  { return msg.warning.warningMsg; };
    void setWarningMsg (char *m) 
   { strncpy(msg.warning.warningMsg, m, sizeof(msg.warning.warningMsg)); }
};

class DT_DLL_VLUTIL DtCsNoticeMsg : public DtShmMsg
{
  public:

    DtCsNoticeMsg(DtShmMsgQueueWriter * w, DtCsMsg *m) : DtShmMsg(w, m) {}

    DtCsNoticeMsg(DtShmMsgQueueWriter * w, DtU16 notice);

    void print();

    virtual ~DtCsNoticeMsg() {}

    int notice()                { return msg.notice.notice; }
    void setNotice(DtU16 n) { msg.notice.notice = n; }
};
#endif

/* ---------------------- SUPPORT UTILS ---------------------- */

#if DT_HAVE_DAEMON
DT_DLL_VLUTIL void DtPacketServerRequestPath(unsigned n, char* requestPath, int vers=DtCsVersionCurrent);

#endif 

/* if who is NULL, warning msgs will not be printed */
DT_DLL_VLUTIL enum DtOpenUnixDgramAction { DtBIND, DtCONNECT };
DT_DLL_VLUTIL int DtOpenUnixDgram(char *path, DtOpenUnixDgramAction action, char *who);
DT_DLL_VLUTIL int DtPacketServerIsAlive(int port);

#ifdef DtUSE_UTILITIES_NAMESPACE
} 
#endif