---

CAVERNnet_tcpReflector_c.hxx

/******************************************************************
 * CAVERNsoft
 * Copyright (C) 1994-2000 Electronic Visualization Laboratory,
 * all rights reserved
 * By Jason Leigh, Yong-joo Cho, Naveen Krishnaprasad, Chris Scharver,
 * Stuart Bailey, Atul Nayak, Shalini Venkataraman
 * University of Illinois at Chicago
 * 
 * This publication and its text and code may not be copied for commercial 
 * use without the express written permission of the University of Illinois
 * at Chicago.
 * The contributors disclaim any representation of warranty: use this
 * code at your own risk.
 * Direct questions, comments etc to cavern@evl.uic.edu
 ******************************************************************/

#include "CAVERNnet_tcp_c.hxx"

#ifndef _CAVERNPLUS_TCP_REFLECTOR
#define _CAVERNPLUS_TCP_REFLECTOR

#define TCP_REFLECTOR_DEFAULT_PORT      7000
#define PERFDAEMON_ALIVE 1
#define PERFDAEMON_NOT_ALIVE 0

class CAVERNnet_tcpReflectorClient_c;

class CAVERNnet_tcpReflector_c
{
public:
        CAVERNnet_tcpReflector_c();
        ~CAVERNnet_tcpReflector_c();


        static const int OK/* = 0*/;

        static const int FAILED/* = 1*/;

        static const int MEM_ALLOC_ERR/* = 2*/;

        static const int NEW_CONNECTION_ESTABLISHED/* = 4*/;

        static const int TOO_MANY_CLIENTS/* = 5*/;

        static const int NO_NEW_CONNECTION/* = 6*/;

        static const int NON_BLOCKING_HAS_NO_DATA/* = 7*/;

        static const int SKIP_DISTRIBUTION/* = 8*/;

        static const int DEFAULT_PORT/* = 7000*/;

        int init(int incomingPort=TCP_REFLECTOR_DEFAULT_PORT, int maxClients = 64, 
                     char* forwardAddr = NULL, unsigned short forwardPort = 0);

        int process();

        int checkForNewClients();

        int setForcedDestination(char *ipAddr, unsigned short port);

        void sendToAll(char* buffer, int dataSize);

        void intercept(int (*callback) (CAVERNnet_tcpReflectorClient_c *client, char** buffer, int *bufferSize,  void *userData), void* userData);

        void interceptNewConnection(void (*callback) (CAVERNnet_tcpReflectorClient_c *newClient, void* userData), void *userData);

    //Functions added for performance monitoring interface    

    void showStats(char* streamInfo, char* comment);
    
    int logStats(char* streamInfo, char* comment, FILE* filePtr);

    int sendStats(char* streamInfo, char* comment);

    int initSendStats(char* monitorClientIP, int port = PERF_DAEMON_DEFAULT_PORT);
    
    void exitSendStats();

private:
        CAVERNnet_tcpReflectorClient_c **clients;
        CAVERNnet_tcpServer_c *server;
        unsigned short incomingPort;
    char* perfDaemonIP;   //IP of the perfDaemon - used for initsendstats
    int perfDaemonPort;   //PerfDaemon Port
    int perfDaemonStatus; //Status that indicates if the perfDaemon is running
        int (*interceptCallback) (CAVERNnet_tcpReflectorClient_c *newClient, char** buffer, int* bufsize, void *userData);
        void *interceptUserData;

        void (*interceptNewConnectionCallback) (CAVERNnet_tcpReflectorClient_c *newClient, void *userData);
        void *interceptNewConnectionUserData;


        // Distribute the data to all connected clients except the one indicated in
        // clientToIgnore. Specify -1 if want to send to all.
        int distributeDataExceptTo(int clientToIgnore, char* buf, int incomingSize);

        // Remove a client from the client array.
        void removeClient(int clientNum);

        // Close all client sockets and remove them. Used by destructor.
        // Also closes down and deallocates the server.
        void closeDownSockets();

        // Add a client to the client pool
        int addNewClient(CAVERNnet_tcpReflectorClient_c* newClient);

        int maxNumClients;
};

class CAVERNnet_tcpReflectorClient_c 
{
private:
        CAVERNnet_tcpClient_c *client;
        int timeOut;
        int connectionAlive;

public:


        static const int OK/* = 1*/;

        static const int FAILED/* = 2*/;

        static const int MEM_ALLOC_ERR/* = 3*/;

        static const int NON_BLOCKING_HAS_NO_DATA/* = 7*/;

        static const int CONNECTION_TERMINATED/* = 8*/;

        static const int NOT_READY/* = 9*/;

        static const int READY_TO_READ/* = 10*/;

        static const int READY_TO_WRITE/* = 11*/;

        static const int READY_TO_READ_AND_WRITE/* = 12*/;

        static const int BLOCKING/* = CAVERNnet_tcpClient_c::BLOCKING*/;
        static const int NON_BLOCKING/* = CAVERNnet_tcpClient_c::NON_BLOCKING*/;

        static const int NO_TIME_OUT/* = CAVERNnet_tcpClient_c::NO_TIME_OUT*/;


        CAVERNnet_tcpReflectorClient_c();

        CAVERNnet_tcpReflectorClient_c(CAVERNnet_tcpClient_c *);

        ~CAVERNnet_tcpReflectorClient_c();

        int read(char** ret, int* nbytes, int blockingType);

        int write(char *outgoingData, int* nbytes);

        int isReadyToRead();

        int isReadyToWrite();

        int isReady();



        unsigned int getRemoteIP();

        void getRemoteIP(char* name);

        unsigned int getSelfIP();

        void getSelfIP(char *name);

        int  getSelfPort();

        int  getRemotePort();

        void showStatus(int status, int nbytes);

        void close();

        int connectToServer(char *ip, int port=CAVERNnet_tcpReflector_c::DEFAULT_PORT);

        void setTimeOut(int timeout=CAVERNnet_tcpReflectorClient_c::NO_TIME_OUT);

    //Functions added for performance monitoring interface
  
    void showStats(char* streamInfo, char* comment);
    
    int logStats(char* streamInfo, char* comment, FILE* filePtr);

    int sendStats(char* streamInfo, char* comment);

    int initSendStats(char* monitorClientIP, int port = PERF_DAEMON_DEFAULT_PORT);
    
    void exitSendStats();
};

#endif

---