/* * GloMoSim is COPYRIGHTED software.  Release 2.02 of GloMoSim is available  * at no cost to educational users only. * * Commercial use of this software requires a separate license.  No cost, * evaluation licenses are available for such purposes; please contact * info@scalable-networks.com * * By obtaining copies of this and any other files that comprise GloMoSim2.02, * you, the Licensee, agree to abide by the following conditions and * understandings with respect to the copyrighted software: * * 1.Permission to use, copy, and modify this software and its documentation *   for education and non-commercial research purposes only is hereby granted *   to Licensee, provided that the copyright notice, the original author's *   names and unit identification, and this permission notice appear on all *   such copies, and that no charge be made for such copies. Any entity *   desiring permission to use this software for any commercial or *   non-educational research purposes should contact:  * *   Professor Rajive Bagrodia  *   University of California, Los Angeles  *   Department of Computer Science  *   Box 951596  *   3532 Boelter Hall  *   Los Angeles, CA 90095-1596  *   rajive@cs.ucla.edu * * 2.NO REPRESENTATIONS ARE MADE ABOUT THE SUITABILITY OF THE SOFTWARE FOR ANY *   PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. * * 3.Neither the software developers, the Parallel Computing Lab, UCLA, or any *   affiliate of the UC system shall be liable for any damages suffered by *   Licensee from the use of this software. */// Use the latest version of Parsec if this line causes a compiler error./* * $Id: telnet_server.pc,v 1.15 2001/02/15 03:17:26 mineo Exp $ * * This file contains initialization function, message processing * function, and finalize function used by telnet server.  */#include <stdlib.h>#include <stdio.h>#include <string.h>#include <assert.h> #include "api.h"#include "structmsg.h"#include "fileio.h"#include "message.h"#include "application.h"#include "app_util.h"#include "telnet_server.h"#include "tcpapps.h"#include "tcp.h"/* * NAME:        AppLayerTelnetServer. * PURPOSE:     Models the behaviour of Telnet server on receiving the *              message encapsulated in msg. * PARAMETERS:  nodePtr - pointer to the node which received the message. *              msg - message received by the layer * RETURN:      none. */void AppLayerTelnetServer(GlomoNode *nodePtr, Message *msg){    char buf[GLOMO_MAX_STRING_LENGTH];    GlomoAppTelnetServer *serverPtr;    ctoa(simclock(), buf);    switch(msg->eventType)     {        case MSG_APP_FromTransListenResult:         {            TransportToAppListenResult *listenResult;            listenResult = (TransportToAppListenResult *) msg->info;             #ifdef DEBUG                printf("%s: node %u got listenResult\n",                        buf, nodePtr->nodeAddr);            #endif            if (listenResult->connectionId == -1)            {                nodePtr->appData.numAppTcpFailure ++;            }            break;        }        case MSG_APP_FromTransOpenResult:         {            TransportToAppOpenResult *openResult;            openResult = (TransportToAppOpenResult *) msg->info;             #ifdef DEBUG                printf("%s: node %u got OpenResult\n", buf, nodePtr->nodeAddr);            #endif            assert(openResult->type == TCP_CONN_PASSIVE_OPEN);            if (openResult->connectionId < 0)             {                nodePtr->appData.numAppTcpFailure ++;            }             else             {                GlomoAppTelnetServer *serverPtr;                 serverPtr = AppTelnetServerNewTelnetServer(nodePtr, openResult);                assert(serverPtr != NULL);            }            break;        }        case MSG_APP_FromTransDataSent:        {            TransportToAppDataSent *dataSent;            dataSent = (TransportToAppDataSent *) msg->info;                    #ifdef DEBUG                printf("%s: node %u sent data %ld\n", buf, nodePtr->nodeAddr,                       dataSent->length);             #endif            serverPtr = AppTelnetServerGetTelnetServer(nodePtr,                                         dataSent->connectionId);            assert(serverPtr != NULL);            serverPtr->numBytesSent += dataSent->length;            break;        }          case MSG_APP_FromTransDataReceived:         {            TransportToAppDataReceived *dataRecvd;            dataRecvd = (TransportToAppDataReceived *) msg->info;            #ifdef DEBUG                printf("%s: node %u received data %ld\n",                        buf, nodePtr->nodeAddr, msg->packetSize);            #endif            serverPtr = AppTelnetServerGetTelnetServer(nodePtr,                                                        dataRecvd->connectionId);            assert(serverPtr != NULL);            serverPtr->numBytesRecvd += msg->packetSize;            if (msg->packet[msg->packetSize - 1] == 'c')             {                /*                  * Client wants to close the session, so server also                 * initiates a close.                 */                AppTcpCloseConnection(nodePtr, TRANSPORT_PROTOCOL_TCP,                                    serverPtr->connectionId);                serverPtr->sessionFinish = simclock();                serverPtr->sessionIsClosed = TRUE;            }             else if (msg->packet[msg->packetSize - 1] == 'd')             {                /* Send a response packet back. */                if (serverPtr->sessionIsClosed == FALSE)                {                    AppTelnetServerSendResponse(nodePtr, serverPtr);                 }            }            else            {                assert(0);            }            break;        }        case MSG_APP_FromTransCloseResult:        {            TransportToAppCloseResult *closeResult;            closeResult = (TransportToAppCloseResult *) msg->info;            #ifdef DEBUG                printf("%s: node %u got close result\n",                        buf, nodePtr->nodeAddr);            #endif            serverPtr = AppTelnetServerGetTelnetServer(nodePtr,                                                  closeResult->connectionId);            assert(serverPtr != NULL);            if (serverPtr->sessionIsClosed == FALSE)             {                serverPtr->sessionIsClosed = TRUE;                serverPtr->sessionFinish = simclock();            }            break;        }        default:            ctoa(simclock(), buf);            printf("Time %s: Node %u received message of unknown type"                   " %ld.\n", buf, nodePtr->nodeAddr, msg->eventType);            assert(FALSE);    }    GLOMO_MsgFree(nodePtr, msg);}/* * NAME:        AppTelnetServerInit.  * PURPOSE:     listen on Telnet server port.  * PARAMETERS:  nodePtr - pointer to the node. * RETURN:      none.  */voidAppTelnetServerInit(GlomoNode *nodePtr){    AppTcpServerListen(nodePtr,                        TRANSPORT_PROTOCOL_TCP,                        APP_TELNET_SERVER,                       nodePtr->nodeAddr,                        (short)APP_TELNET_SERVER);}/* * NAME:        AppTelnetServerFinalize.  * PURPOSE:     Collect statistics of a Telnet session.  * PARAMETERS:  nodePtr - pointer to the node. *              serverPtr - pointer to the telnet server data structure.  * RETURN:      none.  */voidAppTelnetServerFinalize(GlomoNode *nodePtr, GlomoAppTelnetServer *serverPtr){    clocktype throughput;    char clockStr[GLOMO_MAX_STRING_LENGTH];    char startStr[GLOMO_MAX_STRING_LENGTH];    char closeStr[GLOMO_MAX_STRING_LENGTH];    char buf[GLOMO_MAX_STRING_LENGTH];    char throughputStr[GLOMO_MAX_STRING_LENGTH];    ctoa(serverPtr->sessionStart, startStr);    if (serverPtr->sessionIsClosed == FALSE)     {        serverPtr->sessionFinish = simclock();        ctoa(simclock(), clockStr);        sprintf(closeStr, "%s ns (not closed)", clockStr);    }     else     {        ctoa(serverPtr->sessionFinish, clockStr);        sprintf(closeStr, "%s ns (closed)", clockStr);    }    if (serverPtr->sessionFinish <= serverPtr->sessionStart)     {        throughput = 0;     }     else     {        throughput = (serverPtr->numBytesRecvd * 8.0 * SECOND) /                     (serverPtr->sessionFinish - serverPtr->sessionStart);    }    ctoa(throughput, throughputStr);    sprintf(buf, "from %ld to %ld (cid = %d), start = %s, end = %s, "            "bytes sent = %ld B, bytes recv =  %ld B, throughput = %s bps",            serverPtr->remoteAddr, serverPtr->localAddr,             serverPtr->connectionId, startStr, closeStr,            serverPtr->numBytesSent, serverPtr->numBytesRecvd,            throughputStr);    GLOMO_PrintStat(nodePtr, "AppTelnetServer", buf);}/* * NAME:        AppTelnetServerGetTelnetServer. * PURPOSE:     search for a telnet server data structure.  * PARAMETERS:  nodePtr - pointer to the node,  *              connId - connection ID of the telnet server.  * RETURN:      the pointer to the telnet server data structure, *              NULL if nothing found. */static GlomoAppTelnetServer *AppTelnetServerGetTelnetServer(GlomoNode *nodePtr, int connId){    AppInfo *appList = nodePtr->appData.appPtr;    GlomoAppTelnetServer *telnetServer;        for (; appList != NULL; appList = appList->appNext)     {        if (appList->appType == APP_TELNET_SERVER)         {            telnetServer = (GlomoAppTelnetServer *) appList->appDetail;            if (telnetServer->connectionId == connId)             {                return telnetServer;            }        }    }    return NULL;}/* * NAME:        AppTelnetServerNewTelnetServer. * PURPOSE:     create a new telnet server data structure, place it                at the beginning of the application list.  * PARAMETERS:  nodePtr - pointer to the node,  *              openResult - result of the open request.  * RETRUN:      the pointer to the created telnet server data structure, *              NULL if no data structure allocated.  */static GlomoAppTelnetServer *AppTelnetServerNewTelnetServer(GlomoNode *nodePtr,                                TransportToAppOpenResult *openResult){    AppInfo *newApp;    GlomoAppTelnetServer *telnetServer;    newApp = (AppInfo *) pc_malloc(sizeof(AppInfo));    if (newApp == NULL)     {        assert(FALSE);    }    telnetServer = (GlomoAppTelnetServer *)                     pc_malloc(sizeof(GlomoAppTelnetServer));    /*     * fill in connection id, etc.     */    newApp->appType = APP_TELNET_SERVER;    telnetServer->connectionId = openResult->connectionId;    telnetServer->localAddr = openResult->localAddr;    telnetServer->remoteAddr = openResult->remoteAddr;    telnetServer->sessionStart = simclock();    telnetServer->sessionFinish = 0;     telnetServer->sessionIsClosed = FALSE;     telnetServer->numBytesSent = 0;    telnetServer->numBytesRecvd = 0;    newApp->appDetail = telnetServer;    newApp->appNext = nodePtr->appData.appPtr;     nodePtr->appData.appPtr = newApp;    return telnetServer;}/* * NAME:        AppTelnetServerSendResponse. * PURPOSE:     call AppTelnetServerRespPktSize() to get the  *              response packet size,                 and send the packet.  * PARAMETERS:  nodePtr - pointer to the node,  *              serverPtr - pointer to the server data structure.  * RETRUN:      none.  */static voidAppTelnetServerSendResponse(GlomoNode *nodePtr, GlomoAppTelnetServer *serverPtr){    int pktSize;    char payload[MAX_APP_DATA_UNIT];    pktSize = AppTelnetServerRespPktSize(nodePtr);    AppTcpSendData(nodePtr, TRANSPORT_PROTOCOL_TCP, serverPtr->connectionId,                    payload, pktSize);}/* * NAME:        AppTelnetServerRespPktSize. * PURPOSE:     call tcplib function telnet_pktsize(). * PARAMETERS:  nodePtr - pointer to the node. * RETRUN:      telnet control packet size. */static int AppTelnetServerRespPktSize(GlomoNode *nodePtr){    int ctrlPktSize;    ctrlPktSize = telnet_pktsize(nodePtr->seed);    #ifdef DEBUG        printf("TELNET control pktsize = %d\n", ctrlPktSize);    #endif    return (ctrlPktSize);}