Help with IP Sockets project/Dissertation

Hi There all

My name is Shahid Qureshi and I am studying my Bsc(Hons) Computing & Networks at the University of Plymouth in the UK.

I am developing an IP sockets program for my final year Bsc (Hons) in Computing & Networks which is going to be used for the university robot project. I have the IP sockets program working and now I am trying to add some additions functions to the program which allows me to measure network performance related tests over a (LAN).

The tests will include sending/echoing bytes a number of bytes to the server and back. The tests will also need to show the time of how long it took to send & receive the message from the client & server respectively, the timing has to be measure milliseconds and to be able to calculate the the elasped time. The project needs to be in for the 28th August and I am not having much luck with it.

I have enclosed some coding below to show what the program currently looks like at the moment, This also includes my attempts of measuring the time when a message is received by the server, and my attempts to show the number of bytes sent. I desperately need help, any small piece of info you may have just might mke the difference. The coding is shown below for the client & server, this might take a little while to read.

Client Coding:

Code:

#include "mySocket.h" 
#include "myLog.h" 
#include "myException.h" 
#include "myHostInfo.h" 
#include <string.h> 
//#include "PerfTimer.h" 
#include <Windows.h> 
#include <Time.h> 
//#include <afxwin.h> 


myLog winLog; 
void readServerConfig(string&); 
void checkFileExistence(const string&); 

int main() 
{ 
// Initialize the winsock library 
myTcpSocket::initialize(); 
// LARGE_INTEGER *lpPerformanceCount = (LARGE_INTEGER) new (sizeof 
(LARGE_INTEGER)); 
LARGE_INTEGER lpPerformanceCount ; 
// u_char cTTL 
// CString str; 




// get client's information (assume neither the name nor the address is given) 
winLog << endl; 
winLog << "Retrieve the localHost [CLIENT] name and address:" << endl; 
myHostInfo clientInfo; 
string clientName = clientInfo.getHostName(); 
string clientIPAddress = clientInfo.getHostIPAddress(); 
std::cout << "Name: " << clientName << endl; 
std::cout << "Address: " << clientIPAddress << endl; 
winLog << " ==> Name: " << clientName << endl; 
winLog << " ==> Address: " << clientIPAddress << endl; 

// get server's IP address and name 
string serverIPAddress = ""; 
readServerConfig(serverIPAddress); 
winLog << endl; 
winLog << "Retrieve the remoteHost [SERVER] name and address:" << endl; 
winLog << " ==> the given address is " << serverIPAddress << endl; 

myHostInfo serverInfo(serverIPAddress,ADDRESS); 
string serverName = serverInfo.getHostName(); 
std::cout << "Name: " << serverName << endl; 
std::cout << "Address: " << serverIPAddress << endl; 
winLog << " ==> Name: " << serverName << endl; 
winLog << " ==> Address: " << serverIPAddress << endl; 

// create the socket for client 
myTcpSocket myClient(PORTNUM); 
std::cout << myClient; 
winLog << "client configuation: " << endl; 
winLog << myClient; 

// connect to the server. 
std::cout << "connecting to the server [" << serverName << "] ... " << endl; 
winLog << "connecting to the server [" << serverName << "] ... " << endl; 
myClient.connectToServer(serverIPAddress,ADDRESS); 

int recvBytes = 0; 

while (1) 
{ 
// send message to server 
char messageToServer[MAX_MSG_LEN+1]= "hello world2"; 
//char senddata(socketId,buf,MAX_MSG_LENGTH,0); 
//memset(messageToServer,0,sizeof(messageToServer)); 
std::cout << "[SEND] "; 
std::cin.getline(messageToServer,MAX_MSG_LEN); 
//memset(messageToServer,0,sizeof(senddata)); 
std::cout << " %s [%s]with %d bytes of data:"; 
std::cout << strlen(messageToServer); 


//########################################### 

char tmpbuf[128], timebuf[26]; 
time_t ltime; 
string mystr; 
mystr="ABC"; 
// time( &ltime ); 
QueryPerformanceCounter( &lpPerformanceCount); 
std::cout<<( "Time in something:=%ldms,TTL=%d", &lpPerformanceCount); 
//Removing getline so we that we don't need to wait for input //std::cin.getline 
// (messageToServer,MAX_MSG_LEN); 




//########################################### 


winLog << "[SEND] " << mystr << endl; 
myClient.sendMessage(mystr); 
if ( !string(messageToServer).compare("Quit") || !string 
(messageToServer).compare("quit") ) 
break; 

// receive message from server 
string messageFromServer = ""; 
recvBytes = myClient.recieveMessage(messageFromServer); 
if ( recvBytes == -99 ) 
break; 

std::cout << "[RECV:" << serverName << "]: " << messageFromServer << endl; 
winLog << "[RECV:" << serverName << "]: " << messageFromServer << endl; 

} 

return 1; 
} 

void readServerConfig(string& serverIPAddr) 
{ 
serverIPAddr = "127.0.0.1"; //DEBUG 15.02.08 
string serverConfigFile = ".\\serverConfig.txt"; 
//checkFileExistence(serverConfigFile); 
//ifstream serverConfig(serverConfigFile.c_str()); 

// read server's IP address 
//getline(serverConfig,serverIPAddr); 

//serverConfig.close(); 
} 

void checkFileExistence(const string& fileName) 
{ 
ifstream file(fileName.c_str()); 
if (!file) 
{ 
std::cout << "Cannot continue:" << fileName << " does NOT exist!" << endl; 
exit(1); 
} 
file.close(); 
} 



Server coding: 

#include "myEvent.h" 
#include "mySocket.h" 
#include "myLog.h" 
#include "myException.h" 
#include "myHostInfo.h" 
#include "mySemaphore.h" 
#include "myThread.h" 
#include "myThreadArgument.h" 
#include <iostream> 
#include <stdio.h> 
#include <sys/types.h> 
#include <sys/timeb.h> 
#include <time.h> 



myLog winLog; 



DWORD WINAPI clientHandleThread(LPVOID threadInfo) 
{ 
// this structure will contain all the data this callback will work on 
myThreadArgument* clientArgument = (myThreadArgument*)threadInfo; 

// the semamphore to protect the access to the std output 
mySemaphore* coutSemaphore = clientArgument->getCoutSemaphore(); 

// get the client connection: receiving messages from client and 
// sending messages to the client will all be done by using 
// this client connection 
myTcpSocket* clientConnection = clientArgument->getClientConnect(); 
string clientName = clientArgument->getHostName(); 

// the server is communicating with this client here 
while(1) 
{ 
string messageFromClient = ""; 

// receive from the client 

int numBytes = clientConnection->recieveMessage(messageFromClient); 
if ( numBytes == -99 ) 
break; 

// write to the console and the log file, so lock the semaphore 
coutSemaphore->lock(); 

cout << "[RECV fr " << clientName << "]: " << messageFromClient << endl; 
winLog << "[RECV fr " << clientName << "]: " << messageFromClient << endl; 

// if the client wants to discount 
if ( messageFromClient.compare("quit") == 0 || messageFromClient.compare("Quit") == 0 ) 
{ 
coutSemaphore->unlock(); 
break; 
} 
else // send to the client 
{ 
char messageToClient[MAX_MSG_LEN+1]; 
memset(messageToClient,0,sizeof(messageToClient)); 
cout << "[SEND to " << clientName << "]: "; 
//PC cin.getline(messageToClient,MAX_MSG_LEN); 
winLog << "[SEND to " << clientName << "]: " << messageToClient << endl; 
clientConnection->sendMessage(string(messageToClient)); 
coutSemaphore->unlock(); 
} 
} 

// if we reach here, this session with the client is done, 
// so we set the event on this thread to inform the main 
// control that this session is finished 
clientArgument->getExitEvent()->setEvent(); 
return 1; 
} 

DWORD WINAPI serverHandleThread(LPVOID threadInfo) 
{ 
// this structure will contain all the data this callback will work on 
myThreadArgument* serverArgument = (myThreadArgument*)threadInfo; 

// the semamphore to protect the access to the std output 
mySemaphore* coutSemaphore = serverArgument->getCoutSemaphore(); 

// get the server 
myTcpSocket* myServer = serverArgument->getClientConnect(); 
string serverName = serverArgument->getHostName(); 

// bind the server to the socket 
myServer->bindSocket(); 
cout << endl << "server finishes binding process... " << endl; 
winLog << endl << "server finishes binding process... " << endl; 

// server starts to wait for client calls 
myServer->listenToClient(); 
cout << "server is waiting for client calls ... " << endl; 
winLog << "server is waiting for client calls ... " << endl; 

// server starts to listen, and generates a thread to 
// handle each client 

myThreadArgument* clientArgument[MAX_NUM_CLIENTS]; 
myThread* clientHandle[MAX_NUM_CLIENTS]; 
for ( int i = 0; i < MAX_NUM_CLIENTS; i++ ) 
{ 
clientArgument[i] = NULL; 
clientHandle[i] = NULL; 
} 
int currNumOfClients = 0; 

while ( 1 ) 
{ 
// wait to accept a client connection. 
// processing is suspended until the client connects 
myTcpSocket* client; // connection dedicated for client communication 
string clientName; // client name 
client = myServer->acceptClient(clientName); 
clientName = clientName + "-" + char(65+currNumOfClients); 

// lock the std out so we can write to the console 
coutSemaphore->lock(); 
cout << endl << "==> A client from [" << clientName << "] is connected!" << endl << endl; 
winLog << endl << "==> A client from [" << clientName << "] is connected!" << endl << endl; 
coutSemaphore->unlock(); 

// for this client, generate a thread to handle it 
if ( currNumOfClients < MAX_NUM_CLIENTS-1 ) 
{ 
clientArgument[currNumOfClients] = new myThreadArgument 
(client,coutSemaphore,clientName); 
clientHandle[currNumOfClients] = new myThread(clientHandleThread, 
(void*)clientArgument[currNumOfClients]); 
serverArgument->addClientArgument(clientArgument[currNumOfClients]); 
clientHandle[currNumOfClients]->execute(); 
currNumOfClients++; 
} 
} 

return 1; 
} 

int main(void) 

{ 

// build a semaphore so we can synchronize the access to std cout 
// also includes the log file 
mySemaphore coutSemaphore(string(""),1); 

// Initialize the winsock library 
myTcpSocket::initialize(); 

// create the server: local host will be used as the server, let us 
// first use myHostInfo class to show the name and IP address 
// of the local host 
winLog << endl; 
winLog << "Retrieve the local host name and address:" << endl; 

myHostInfo serverInfo; 
string serverName = serverInfo.getHostName(); 
string serverIPAddress = serverInfo.getHostIPAddress(); 
std::cout << "my localhost (server) information:" << endl; 
std::cout << " Name: " << serverName << endl; 
std::cout << " Address: " << serverIPAddress << endl; 
winLog << " ==> Name: " << serverName << endl; 
winLog << " ==> Address: " << serverIPAddress << endl; 

// open socket on the local host(server) and show its configuration 
myTcpSocket myServer(PORTNUM); 
std::cout << myServer; 
winLog << myServer; 

// create a thread to implement server process: listening to the socket, 
// accepting client calls and communicating with clients. This will free the 
// main control (see below) to do other process. 
myThreadArgument* serverArgument = new myThreadArgument 
(&myServer,&coutSemaphore,serverName); 
myThread* serverThread = new myThread(serverHandleThread,(void*) 
serverArgument); 
serverThread->execute(); 

// main control: since the serverThread is handling the server functions, 
// this main control is free to do other things. 
while ( 1 ) //MAIN CONTROL LOOP 
{ 
// do whatever you need to do here, I am using Sleep(x) 
// to make a little delay, pretending to be the other 
// possible processings. 
Sleep(1000); 

} 
return 1; 
} 

Thank you

Shahid