---

CAVERNnet_tcp_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
 ******************************************************************/
/*
This is a C++ class to support TCP/IP sockets.
The 2 main classes are CAVERNnet_tcpClient_c and CAVERNnet_tcpServer_c.

If you are writing a server you need to instantiate a tcpServer object.
Likewise if you are writing a client you need to instantiate a tcpClient
object.

*/

#ifndef _CAVERNPLUS_TCP_C
#define _CAVERNPLUS_TCP_C

#ifdef WIN32
#include <errno.h>
#elif defined(__sgi)
extern int errno;
#endif

#include "CAVERNnet_socketbase_c.hxx"
#include "CAVERNnet_perfMonitor_c.hxx"
//#include "CAVERNnet_perfDaemon_c.hxx"

class CAVERNnet_perfMonitor_c;
class CAVERNnet_tcpServer_c;
//class CAVERNnet_perfDaemon_c;

class CAVERNnet_tcpClient_c : public CAVERNnet_socketbase_c {

        // Allow CAVERNnet_tcpServer_c objects to call MakeNonBlocking.
        friend class CAVERNnet_tcpServer_c;

protected:
        /* Not to be called by user */
        void makeNonBlocking();

        struct sockaddr_in clientInfo;
        int clientSockFd;
        int clientStatus;
        int timeOutStatus;
        int timeOutPeriod;
    CAVERNnet_perfMonitor_c pmonitor;
public:



        static const int BLOCKING/* = 1*/;

        static const int NON_BLOCKING/* = 2*/;

        // Make the conncection blocking and never time out.
        //static const int NEVER_TIME_OUT_BLOCKING/* = 3*/;




        static const int NO_TIME_OUT/* = -1*/;

        static const int DEFAULT_TIME_OUT/* = NO_TIME_OUT*/; 



        static const int SOCKET_NOT_OPEN/* = -1*/;

        static const int CONNECTION_TERMINATED/* = -2*/;

        static const int NON_BLOCKING_HAS_NO_DATA/* = -3*/;

        static const int TIMED_OUT/* = -4*/;

        static const int OK/* = 1*/;

        static const int NON_BLOCKING_NOT_READY_TO_WRITE/* = -6*/;

        static const int NOT_READY/* = -7*/;

        static const int READY_TO_READ/* = -8*/;

        static const int READY_TO_WRITE/* = -9*/;

        static const int READY_TO_READ_AND_WRITE/* = -10*/;

    static const int READ_BUFFER_SIZE/* = -11*/;

    static const int WRITE_BUFFER_SIZE/* = -12*/;

        
        void setTimeOut(int t) {timeOutPeriod = t;}

        int getTimeOut() {return timeOutPeriod;}

        void setClientInfo(struct sockaddr_in* info) { clientInfo = *info; }

        void setClientSockFd(int sockfd) { clientSockFd = sockfd; }

        CAVERNnet_tcpClient_c();
        ~CAVERNnet_tcpClient_c() { if (clientSockFd) close(); }



        unsigned int getRemoteIP();

        void getRemoteIP(char* name);

        unsigned int getSelfIP();

        void getSelfIP(char *name);

        int  getSelfPort();

        int  getRemotePort();

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

        void setSockOptions(int option, int buffersize);        


        int isReadyToRead();

        int isReadyToWrite();

        int isReady();

        int write(char *ptr, int  *nbytes, int blockingType);


        void showStatus(int status, int nbytes);

        void close();

        int connectToServer(char *ip, int port);


    //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();

    //Set the instantaneous latency 
    void setInstantaneousLatency(double latency);


};

class CAVERNnet_tcpServer_c : public CAVERNnet_socketbase_c {


protected:
        int serverPort;

        int timeOutPeriod;
        int sockfd;
        struct sockaddr_in  serverInfo;

public:


        static const int OK/* = 1*/;

        static const int FAILED/* = 0*/;

        //      static int CAVERNnet_tcpServer_c::NO_TIME_OUT;

        void setTimeOut(int t) {timeOutPeriod = t;}

        int getTimeOut() {return timeOutPeriod;}

        CAVERNnet_tcpServer_c();
        ~CAVERNnet_tcpServer_c() { if (sockfd) close(); }

        unsigned int getSelfIP();

        void getSelfIP(char* name);

        int getSelfPort() {
                return ntohs(serverInfo.sin_port);
        }

        int init(int port);

        void close();

        CAVERNnet_tcpClient_c *checkForNewConnections();
};

#endif

---