class CAVERNnet_tcpReflector_c

TCP Reflector class

Public Methods

int init (int incomingPort=TCP_REFLECTOR_DEFAULT_PORT, int maxClients = 64, char* forwardAddr = NULL, unsigned short forwardPort = 0)
Initialize the reflector
int process ()
Call this within a while loop to let the reflector continuously do its processing
int checkForNewClients ()
Call this as often as you wish to check for new clients
int setForcedDestination (char *ipAddr, unsigned short port)
Set a single ip address and port number to which all packets will be sent
void sendToAll (char* buffer, int dataSize)
Send data to all clients connected to the reflector
void intercept (int (*callback) (CAVERNnet_tcpReflectorClient_c *client, char** buffer, int *bufferSize, void *userData), void* userData)
Intercept incoming messages and call a user-defined callback function
void interceptNewConnection (void (*callback) (CAVERNnet_tcpReflectorClient_c *newClient, void* userData), void *userData)
Intercept any new connections that are formed
void showStats (char* streamInfo, char* comment)
Displays the resultant statistics instantaneously in the netlogger format - this should be typically done after a read/write is done a network
int logStats (char* streamInfo, char* comment, FILE* filePtr)
This logs performance statistics in a file
int sendStats (char* streamInfo, char* comment)
Sends the performance statistics to a remote perfdaemon -for further analysis of the monitored data - the initSendStats API should be called first, before calling a sendStats (In order to connect to the perfdaemon initially)

(Note: A typical example of sendStats is given in the (CAVERN_DISTRIB_DIR/demos/tcpreflector/ directory)

int initSendStats (char* monitorClientIP, int port = PERF_DAEMON_DEFAULT_PORT)
Initialize sendStats - provide the IP of the perfDaemon and an optional port number to connect to
void exitSendStats ()
Properly delete the perfDaemonClient after sendStats is done

Public


static const int OK
Status ok.
static const int FAILED
Status failed.
static const int MEM_ALLOC_ERR
Memory allocation error.
static const int NEW_CONNECTION_ESTABLISHED
New client has been connected.
static const int TOO_MANY_CLIENTS
Reflector cannot handle any more connections
static const int NO_NEW_CONNECTION
No new connection.
static const int NON_BLOCKING_HAS_NO_DATA
A non-blocking read had no data available to read.
static const int SKIP_DISTRIBUTION
Skip the data distribution process. Used in user callback. See intercept().

Documentation

TCP Reflector class. This class treats TCP streams as discrete packets/messages that can be reflected to multiple connected clients. Clients must be created using CAVERNnet_tcpReflectorClient_c in order to interpret the TCP stream correctly. Hence do NOT attempt to use CAVERNnet_tcpClient_c to connect to a TCP reflector or it will corrupt the TCP reflector stream. This reflector has 2 main functions: checkForNewClients() and process(). checkForNewClients, as the name suggests, checks to see if any new clients wish to connect to the reflector. Process() does the actual work of data reflection.

checkForNewClients is called everytime process() is called. If you want the check to be done more frequently you need to do it yourself. Similarly if you want the process() call done more frequently it is up to you to do it. I recommend threading those two off and setting up a mutex so that you do not do process() and checkForNewClients() at the same time.

int init(int incomingPort=TCP_REFLECTOR_DEFAULT_PORT, int maxClients = 64, char* forwardAddr = NULL, unsigned short forwardPort = 0)
Initialize the reflector
Returns:
Either CAVERNnet_tcpReflector_c::OK,FAILED,MEM_ALLOC_ERR.
Parameters:
incomingPort - is listening port for incoming connections. Default is 7000.
maxClients - is the max number of clients the reflector will manage.
forwardAddr - is the IP address of a machine running another tcpreflector to whom data must be forwared to.
forwardPort - is the port number of tcpreflector to whom data must be forwared to.

int process()
Call this within a while loop to let the reflector continuously do its processing
Returns:
Either CAVERNnet_tcpReflector_c::OK,MEM_ALLOC_ERR

int checkForNewClients()
Call this as often as you wish to check for new clients. Note. If you do this in a separate thread then you must set up a mutex so that you do not call the proces() call and this call at the same time. The process() call itself has embedded in it 1 check for each time you call it.
Returns:
One of CAVERNnet_tcpReflector_c::NEW_CONNECTION_ESTABLISHED, NO_NEW_CONNECTION, TOO_MANY_CLIENTS.

int setForcedDestination(char *ipAddr, unsigned short port)
Set a single ip address and port number to which all packets will be sent. When you use this method, data is forwarded to the reflector running at the ip address provided. You will also receive data from that reflector. Thus you can create a bidirectional link.

Returns:
One of CAVERNnet_tcpReflector_c::NEW_CONNECTION_ESTABLISHED, NO_NEW_CONNECTION, TOO_MANY_CLIENTS.

void intercept(int (*callback) (CAVERNnet_tcpReflectorClient_c *client, char** buffer, int *bufferSize, void *userData), void* userData)
Intercept incoming messages and call a user-defined callback function. If you want you can also alter the buffer completely so that the reflector will reflect an entirely different message. You can do this by changing the contents of the buffer or by replacing the buffer entirely by allocating memory for a new buffer and stuffing it with your own data. If you choose to allocate a totally new buffer you must remember to deallocate memory for the original buffer before substituting it with yours.

If after your callback function exits you do not wish the reflector to forward the contents of the buffer, return with CAVERN_tcpReflector_c::SKIP_DISTRIBUTION. Otherwise just return CAVERN_tcpReflector_c::OK.

Note also that the callback function will also be given a pointer to a CAVERNnet_tcpReflectorClient_c object that can then be used to send data directly to the client that originally sent the message.

void interceptNewConnection(void (*callback) (CAVERNnet_tcpReflectorClient_c *newClient, void* userData), void *userData)
Intercept any new connections that are formed. This allows you to send private data to the newly formed connection before it assumes its data reflection duties. Callback function will be given a pointer to the CAVERNnet_tcpReflectorClient_c object that can then be used to send data directly to the client.

void showStats(char* streamInfo, char* comment)
Displays the resultant statistics instantaneously in the netlogger format - this should be typically done after a read/write is done a network.

Also, it should be noted that a showStats call should be made at the end of atleast one send and receive for two-way information (the same applies for logStats and sendStats)

Parameters:
streamInfo - A label describing the stream that is being monitored.
comment - A comment on the event that marks the time at which the stream is being monitored

int logStats(char* streamInfo, char* comment, FILE* filePtr)
This logs performance statistics in a file. The user opens a file and passes the file pointer with this function and results of monitoring are written into the logfile.

Returns:
Either CAVERNnet_perfMonitor_c::OK or CAVERNnet_perfMonitor_c::FAILED
Parameters:
streamInfo - A label describing the stream that is being monitored.
comment - A comment on the event that marks the time at which the stream is being monitored
filePtr - File pointer to the file in which the results of monitoring are to be stored

int sendStats(char* streamInfo, char* comment)
Sends the performance statistics to a remote perfdaemon -for further analysis of the monitored data - the initSendStats API should be called first, before calling a sendStats (In order to connect to the perfdaemon initially)

(Note: A typical example of sendStats is given in the (CAVERN_DISTRIB_DIR/demos/tcpreflector/ directory)

Returns:
Either CAVERNnet_perfMonitor_c::OK or CAVERNnet_perfMonitor_c::FAILED
Parameters:
streamInfo - A label describing the stream that is being monitored.
comment - A comment on the event that marks the time at which the stream is being monitored

int initSendStats(char* monitorClientIP, int port = PERF_DAEMON_DEFAULT_PORT)
Initialize sendStats - provide the IP of the perfDaemon and an optional port number to connect to. This should be done initially before using the sendStats API.

Returns:
Either CAVERNnet_perfMonitor_c::OK or CAVERNnet_perfMonitor_c::FAILED
Parameters:
monitorClientIP - IP address of the perfDameon to connect to
port - Port number at which the perfDaemon is running -this is optional. The default port number for perfDaemon is 9500 -so a different port number has to be specified if the perfDaemon is running on a different port.

This class has no child classes.

alphabetic index hierarchy of classes

this page has been generated automatically by doc++

(c)opyright by Malte Zöckler, Roland Wunderling
contact: doc++@zib.de