1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.

Help with IP Sockets project/Dissertation

Discussion in 'C' started by saqureshi, Aug 5, 2008.

  1. saqureshi

    saqureshi New Member

    Joined:
    Aug 5, 2008
    Messages:
    1
    Likes Received:
    0
    Trophy Points:
    0
    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
     
    Last edited by a moderator: Aug 5, 2008
  2. shabbir

    shabbir Administrator Staff Member

    Joined:
    Jul 12, 2004
    Messages:
    15,285
    Likes Received:
    364
    Trophy Points:
    83
    If you have a C-C++ query try having it in the right forum as well as have it in the right format.
     

Share This Page