application.pc

simulator for ad hoc

        }
#ifdef NSTELNET_STUFF
        else if (strcmp(appStr, "NSTELNET") == 0) {
            char sessDurationStr[GLOMO_MAX_STRING_LENGTH];
            char startTimeStr[GLOMO_MAX_STRING_LENGTH];
            NODE_ADDR sourceAddr, destAddr;
            short     sourcePort, destPort;
            clocktype startTime, sessDuration;
            int itemsToSend;
            int connId;
             
            /* For every NSTELNET entry in the app config file, call 
             *  AppNsTelnetClientInit and AppNsTelnetServerInit
             */
            retVal = sscanf(appInput.inputStrings[i],
                            "%s %ld %ld %s %s %u %hu %hu", 
                            appStr, &sourceAddr, &destAddr,
                            sessDurationStr, startTimeStr,
                            &connId, &sourcePort, &destPort);

            if (retVal != 8) {
                fprintf(stderr, "Application: Wrong configuration format!\n"
                assert(0); abort();
            }

            if (node->nodeAddr == sourceAddr || node->nodeAddr == destAddr) {
                startTime = GLOMO_ConvertToClock(startTimeStr);
                sessDuration = GLOMO_ConvertToClock(sessDurationStr);

#ifdef DEBUG
                if (node->nodeAddr == sourceAddr) {
                    printf("Starting NSTELNET client with:\n");
                }
                else {
                    printf("Starting NSTELNET server with:\n");
                }
                printf(" source address: %u\n", node->nodeAddr);
                printf(" source port: %u\n", sourcePort);
                printf(" destination address: %u\n", destAddr);
                printf(" destination port: %u\n", destPort);
                printf(" connection id: %u\n", connId);
                
                ctoa(sessDuration, clockStr);
                printf(" session duration: %s\n", clockStr);
                
                ctoa(startTime, clockStr);
                printf(" start time: %s\n", clockStr);
#endif
                node->appData.telnetSessTime = sessDuration;
                
                if (node->nodeAddr == sourceAddr) {
                    AppNstelnetClientInit(node, sourcePort, destAddr, destPort,
                                          connId, startTime);
                }
                else {
                    AppNstelnetServerInit(node, destPort, sourceAddr, 
                                          sourcePort, connId, startTime);
                }
            }
        }
#endif
        else if (strcmp(appStr, "CBR") == 0) {
            NODE_ADDR sourceAddr, destAddr;
            int itemsToSend, itemSize;
            char intervalStr[GLOMO_MAX_STRING_LENGTH];
            char startTimeStr[GLOMO_MAX_STRING_LENGTH];
            char endTimeStr[GLOMO_MAX_STRING_LENGTH];

            retVal = sscanf(appInput.inputStrings[i],
                            "%s %ld %ld %ld %ld %s %s %s",
                            appStr, &sourceAddr, &destAddr,
                            &itemsToSend, &itemSize,
                            intervalStr, startTimeStr, endTimeStr);

            if (retVal != 8) {
                fprintf(stderr,
                        "Wrong CBR configuration format!\n"
                        "CBR <src> <dest> <items to send> <item size> "
                        "<interval> <start time> <end time>\n");
                assert(0); abort();
            }

            if (sourceAddr == destAddr) {
                fprintf(stderr, "Application: CBR configuration "
                        "has same source/dest (node %ld) pair!\n", sourceAddr);
                assert(0); abort();
            }

            if (node->nodeAddr == sourceAddr) {
                clocktype startTime, endTime, interval;
                startTime = GLOMO_ConvertToClock(startTimeStr);
                endTime = GLOMO_ConvertToClock(endTimeStr);
                interval = GLOMO_ConvertToClock(intervalStr);

                #ifdef DEBUG
                    printf("Starting CBR client with:\n");
                    printf(" source: %u\n", node->nodeAddr);
                    printf(" destination: %u\n", destAddr);

                    printf(" items to send: %ld\n", itemsToSend);
                    printf(" item size: %ld\n", itemSize);

                    ctoa(interval, clockStr);
                    printf(" interval: %s\n", clockStr);

                    ctoa(startTime, clockStr);
                    printf(" start time: %s\n", clockStr);

                    ctoa(endTime, clockStr);
                    printf("  end time: %s\n", clockStr);
                #endif

                AppCbrClientInit(node, destAddr, itemsToSend, itemSize,
                                 interval, startTime, endTime);
            }
            else if (node->nodeAddr == destAddr) {
                AppCbrServerInit(node);
            }
        }
        // else if (strcmp(appStr, "RUMOR") == 0) {
        //    if (node->nodeAddr < NSERVER) {
        //        AppRumorInit(node, nodeInput);
        //    }
        //}
        else if (strcmp(appStr, "HTTP") == 0) {
            NODE_ADDR clientAddr;
            NODE_ADDR *serverAddrs;
            long numServerAddrs;
            long count;
            long itemsToSend, itemSize;
            char threshStr[GLOMO_MAX_STRING_LENGTH];
            char startTimeStr[GLOMO_MAX_STRING_LENGTH];

            tempStr = appInput.inputStrings[i] + 4;
/*
            retVal = sscanf(tempStr, "%ld%ld",
                            &clientAddr, &numServerAddrs);
            assert (retVal == 2);
*/
            retVal = sscanf(tempStr, "%s", clockStr);
            tempStr += strlen(clockStr) + 1;
            clientAddr = atol(clockStr);
            retVal = sscanf(tempStr, "%s", clockStr);
            numServerAddrs = atol(clockStr);
            tempStr += strlen(clockStr) + 1;
            assert (numServerAddrs > 0);
            serverAddrs =
                checked_pc_malloc(sizeof(NODE_ADDR) * numServerAddrs);
            for (count = 0; count < numServerAddrs; count++)
            {
                retVal = sscanf(tempStr, "%s", clockStr);
                assert (retVal == 1);
                serverAddrs[count] = atol(clockStr);
                tempStr += strlen(clockStr) + 1;
            }
            retVal = sscanf(tempStr, "%s%s", startTimeStr, threshStr);
            assert (retVal == 2);
            if (node->nodeAddr == clientAddr)
            {
                clocktype threshTime,
                          startTime;
                threshTime = GLOMO_ConvertToClock(threshStr);
                startTime = GLOMO_ConvertToClock(startTimeStr);

#ifdef DEBUG
                printf("#%ld HTTP %ld servers: ", clientAddr, numServerAddrs);
                for (count = 0; count < numServerAddrs; count++)
                    printf("%ld ", serverAddrs[count]);
                printf("\n");
#endif
                AppHttpClientInit(node, serverAddrs, numServerAddrs,
                                  startTime, threshTime);
            }
        }
        else if (strcmp(appStr, "HTTPD") == 0) {
            NODE_ADDR serverAddr;

            tempStr = appInput.inputStrings[i] + 5;
            retVal = sscanf(tempStr, "%s", clockStr);
            serverAddr = atol(clockStr);

            assert(retVal == 1);

            if (serverAddr == node->nodeAddr)
                AppHttpServerInit(node);
        }
        else {
            printf("Application: Unknown application %s\n", appStr);
            assert(0); abort();
        }
    }
}


/*
 * NAME:        GLOMO_AppLayer.
 * PURPOSE:     call proper protocol to process messages. 
 * PARAMETERS:  node - pointer to the node, 
 *              msg - pointer to the received message.
 * RETURN:      none. 
 */
void GLOMO_AppLayer(GlomoNode *node, Message *msg)
{
    switch(GLOMO_MsgGetProtocol(msg)) {
    case APP_ROUTING_BELLMANFORD:
        RoutingBellmanfordLayer(node, msg);
        break;
    case APP_ROUTING_WRP:
        RoutingWrpLayer(node, msg);
        break;
    case ROUTING_PROTOCOL_FISHEYE:
        RoutingFisheyeLayer(node,msg);
        break;
    case APP_ROUTING_NS_DSDV:            
        RoutingNsDsdvLayer(node, msg);
        break;
    case APP_ROUTING_STATIC:
        RoutingStaticLayer(node, msg);
        break;
#ifdef NSTELNET_STUFF
    case APP_NSTELNET_CLIENT:
        AppLayerNstelnetClient(node, msg);
        break;
#endif
    case APP_TELNET_CLIENT:
        AppLayerTelnetClient(node, msg);
        break;
    case APP_TELNET_SERVER:
        AppLayerTelnetServer(node, msg);
        break;
    case APP_FTP_CLIENT:
        AppLayerFtpClient(node, msg);
        break;
    case APP_FTP_SERVER:
        AppLayerFtpServer(node, msg);
        break;
    case APP_GEN_FTP_CLIENT:
        AppLayerGenFtpClient(node, msg);
        break;
    case APP_GEN_FTP_SERVER:
        AppLayerGenFtpServer(node, msg);
        break;
    case APP_CBR_CLIENT:
        AppLayerCbrClient(node, msg);
        break;
    case APP_CBR_SERVER:
        AppLayerCbrServer(node, msg);
        break;
    case APP_HTTP_CLIENT:
        AppLayerHttpClient(node, msg);
        break;
    case APP_HTTP_SERVER:
        AppLayerHttpServer(node, msg);
        break;
    //case APP_RUMOR:
    //    AppLayerRumor(node, msg);
    //    break;
    default:
        AppLayerHandleUserAppEvent(
            node, node->appData.userApplicationData, msg);
        break;
    }
}


/*
 * NAME:        GLOMO_AppFinalize.
 * PURPOSE:     call protocols to print statistics. 
 * PARAMETERS:  node - pointer to the node, 
 * RETURN:      none. 
 */
void 
GLOMO_AppFinalize(GlomoNode *node)
{
    AppInfo *appList = NULL;
    AppInfo *nextApp = NULL;

    switch(node->appData.routingProtocol)  
    {
        case APP_ROUTING_BELLMANFORD:
            RoutingBellmanfordFinalize(node);
            break;

        case APP_ROUTING_WRP:
            RoutingWrpFinalize(node);
            break;

        case ROUTING_PROTOCOL_FISHEYE:
            RoutingFisheyeFinalize(node);
            break;
            
        case APP_ROUTING_NS_DSDV:
            RoutingNsDsdvFinalize(node);
            break;

        case APP_ROUTING_STATIC:
            RoutingStaticFinalize(node);
            break;

        default: 
            break;
    }

    for (appList = node->appData.appPtr; appList != NULL; appList = nextApp) {
        /*
         * Get application specific data structure and call
         * the corresponding protocol to print the stats.
         */ 
        switch (appList->appType) 
        {
            case APP_TELNET_CLIENT:
                AppTelnetClientFinalize(node, (GlomoAppTelnetClient *) 
                                        appList->appDetail);
                break;

            case APP_TELNET_SERVER:
                AppTelnetServerFinalize(node, (GlomoAppTelnetServer *) 
                                        appList->appDetail);
                break;
        
            case APP_NSTELNET_CLIENT:
                break;
        
            case APP_FTP_CLIENT:
                AppFtpClientFinalize(node, (GlomoAppFtpClient *) 
                                     appList->appDetail);
                break;

            case APP_FTP_SERVER:
                AppFtpServerFinalize(node, (GlomoAppFtpServer *) 
                                     appList->appDetail);
                break;

            case APP_GEN_FTP_CLIENT:
                AppGenFtpClientFinalize(node, (GlomoAppGenFtpClient *)
                                        appList->appDetail);
                break;

            case APP_GEN_FTP_SERVER:
                AppGenFtpServerFinalize(node, (GlomoAppGenFtpServer *)
                                        appList->appDetail);
                break;

            case APP_CBR_CLIENT:
                AppCbrClientFinalize(node, (GlomoAppCbrClient *)
                                     appList->appDetail);
                break;

            case APP_CBR_SERVER:
                AppCbrServerFinalize(node, (GlomoAppCbrServer *)
                                     appList->appDetail);
                break;

            case APP_HTTP_CLIENT:
                AppHttpClientFinalize(node, (GlomoAppHttpClient *)
                                      appList->appDetail);
                break;
            case APP_HTTP_SERVER:
                AppHttpServerFinalize(node, (GlomoAppHttpServer *)
                                      appList->appDetail);
                break;

            //case APP_RUMOR:
            //     break;

        }

        nextApp = appList->appNext;
        free(appList);
    }
    
    AppLayerFinalizeUserApps(node, node->appData.userApplicationData);
}