1. We have moved from vBulletin to XenForo and you are viewing the site in the middle of the move. Though the functional aspect of everything is working fine, we are still working on other changes including the new design on Xenforo.
    Dismiss Notice

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,276
    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