ftp_client.pc

无线网络仿真工具Glomosim2.03

    if (nodePtr->appData.appStats == TRUE)
    {
        AppFtpClientPrintStats(nodePtr, clientPtr);
    }
}


/*
 * NAME:        AppFtpClientGetFtpClient.
 * PURPOSE:     search for a ftp client data structure. 
 * PARAMETERS:  nodePtr - pointer to the node. 
 *              connId - connection ID of the ftp client. 
 * RETURN:      the pointer to the ftp client data structure,
 *              NULL if nothing found.
 */
static GlomoAppFtpClient *
AppFtpClientGetFtpClient(GlomoNode *nodePtr, int connId)
{
    AppInfo *appList = nodePtr->appData.appPtr;
    GlomoAppFtpClient *ftpClient;
    
    for (; appList != NULL; appList = appList->appNext) 
    {
        if (appList->appType == APP_FTP_CLIENT)
        {
            ftpClient = (GlomoAppFtpClient *) appList->appDetail;

            if (ftpClient->connectionId == connId)
            {
                return ftpClient;
            }
        }
    }

    return NULL;
}


/*
 * NAME:        AppFtpClientUpdateFtpClient.
 * PURPOSE:     update existing ftp client data structure by including 
 *              connection id.
 * PARAMETERS:  nodePtr - pointer to the node.
 *              openResult - result of the open request.
 * RETRUN:      the pointer to the created ftp client data structure,
 *              NULL if no data structure allocated.
 */
static GlomoAppFtpClient *
AppFtpClientUpdateFtpClient(GlomoNode *nodePtr,
                            TransportToAppOpenResult *openResult)
{
    char clockStr[GLOMO_MAX_STRING_LENGTH];

    AppInfo *appList = nodePtr->appData.appPtr;
    GlomoAppFtpClient *tmpFtpClient = NULL;
    GlomoAppFtpClient *ftpClient = NULL;

    for (; appList != NULL; appList = appList->appNext)
    {
        if (appList->appType == APP_FTP_CLIENT)
        {
            tmpFtpClient = (GlomoAppFtpClient *) appList->appDetail;

            #ifdef DEBUG
                printf("FTP Client: Node %d comparing uniqueId "
                       "%d with %d\n", nodePtr->nodeAddr,
                       tmpFtpClient->uniqueId, openResult->uniqueId);
            #endif

            if (tmpFtpClient->uniqueId == openResult->uniqueId)
            {
                ftpClient = tmpFtpClient;
                break;
            }
        }
    }

    if (ftpClient == NULL)
    {
        assert(FALSE);
    }

    /*
     * fill in connection id, etc.
     */
    ftpClient->connectionId = openResult->connectionId;
    ftpClient->localAddr = openResult->localAddr;
    ftpClient->remoteAddr = openResult->remoteAddr;
    ftpClient->sessionStart = simclock();
    ftpClient->sessionFinish = simclock();
    ftpClient->sessionIsClosed = FALSE;

    #ifdef DEBUG
        printf("FTP Client: Node %d updating ftp "
               "client struture\n", nodePtr->nodeAddr);

        printf("    connectionId = %d\n", ftpClient->connectionId);
        printf("    localAddr = %d\n", ftpClient->localAddr);
        printf("    remoteAddr = %d\n", ftpClient->remoteAddr);
        printf("    itemsToSend = %d\n", ftpClient->itemsToSend);
    #endif

    return ftpClient;
}


/*
 * NAME:        AppFtpClientNewFtpClient.
 * PURPOSE:     create a new ftp client data structure, place it
 *              at the beginning of the application list. 
 * PARAMETERS:  nodePtr - pointer to the node.
 *              serverAddr - ftp server to this client.
 *              itemsToSend - number of ftp items to send in simulation.
 * RETRUN:      the pointer to the created ftp client data structure,
 *              NULL if no data structure allocated. 
 */
static GlomoAppFtpClient *
AppFtpClientNewFtpClient(GlomoNode *nodePtr, 
                         NODE_ADDR serverAddr,
                         int itemsToSend)
{
    AppInfo *newApp;
    GlomoAppFtpClient *ftpClient;

    newApp = (AppInfo *) pc_malloc(sizeof(AppInfo));

    if (newApp == NULL) 
    {
        assert(FALSE);
    }

    ftpClient = (GlomoAppFtpClient *) pc_malloc(sizeof(GlomoAppFtpClient));

    if (ftpClient == NULL) 
    {
        assert(FALSE);
    }

    /*
     * fill in connection id, etc.
     */
    newApp->appType = APP_FTP_CLIENT;  
    ftpClient->connectionId = -1;
    ftpClient->uniqueId = nodePtr->appData.uniqueId++;

    ftpClient->localAddr = nodePtr->nodeAddr;
    ftpClient->remoteAddr = serverAddr;

    // Make unique seed from node's initial seed value.                                                     
                                                    
    ftpClient->seed[0] = nodePtr->initialSeedValue[0] + serverAddr;
    ftpClient->seed[1] = nodePtr->initialSeedValue[1] + itemsToSend;
    ftpClient->seed[2] = nodePtr->initialSeedValue[2] + ftpClient->uniqueId;
    
    
    if (itemsToSend > 0) 
    {
        ftpClient->itemsToSend = itemsToSend;
    } 
    else 
    {
        ftpClient->itemsToSend = AppFtpClientItemsToSend(ftpClient);
    }

    ftpClient->itemSizeLeft = 0;
    ftpClient->numBytesSent = 0;
    ftpClient->numBytesRecvd = 0;

    #ifdef DEBUG
        printf("FTP Client: Node %d creating new ftp "
               "client struture\n", nodePtr->nodeAddr);

        printf("    connectionId = %d\n", ftpClient->connectionId);
        printf("    localAddr = %d\n", ftpClient->localAddr);
        printf("    remoteAddr = %d\n", ftpClient->remoteAddr);
        printf("    itemsToSend = %d\n", ftpClient->itemsToSend);
    #endif

    newApp->appDetail = ftpClient;
    newApp->appNext = nodePtr->appData.appPtr; 
    nodePtr->appData.appPtr = newApp;

    return ftpClient;
}

/*
 * NAME:        AppFtpClientSendNextItem.
 * PURPOSE:     Send the next item.
 * PARAMETERS:  nodePtr - pointer to the node, 
 *              clientPtr - pointer to the ftp client data structure. 
 * RETRUN:      none. 
 */
static void
AppFtpClientSendNextItem(GlomoNode *nodePtr, GlomoAppFtpClient *clientPtr)
{
    assert(clientPtr->itemSizeLeft == 0);

    if (clientPtr->itemsToSend > 0)
    {
        clientPtr->itemSizeLeft = AppFtpClientItemSize(clientPtr);
        clientPtr->itemSizeLeft += AppFtpClientCtrlPktSize(clientPtr);

        AppFtpClientSendNextPacket(nodePtr, clientPtr);
        clientPtr->itemsToSend --;
    } 
    else
    {
        AppTcpSendData(nodePtr, TRANSPORT_PROTOCOL_TCP, 
                    clientPtr->connectionId, "c", 1);

        clientPtr->sessionIsClosed = TRUE;
        clientPtr->sessionFinish = simclock();

    }
}

/*
 * NAME:        AppFtpClientSendNextPacket.
 * PURPOSE:     Send the remaining data.
 * PARAMETERS:  nodePtr - pointer to the node, 
 *              clientPtr - pointer to the ftp client data structure. 
 * RETRUN:      none. 
 */
static void
AppFtpClientSendNextPacket(GlomoNode *nodePtr, GlomoAppFtpClient *clientPtr)
{
    int itemSize;
    char payload[MAX_APP_DATA_UNIT];

    memset(payload, 'd', MAX_APP_DATA_UNIT);

    /* Break packet down of larger than MAX_APP_DATA_UNIT. */
    if (clientPtr->itemSizeLeft > MAX_APP_DATA_UNIT)
    {
        itemSize = MAX_APP_DATA_UNIT;
        clientPtr->itemSizeLeft -= MAX_APP_DATA_UNIT;
    }
    else
    {
        itemSize = clientPtr->itemSizeLeft;

        /* Mark the end of the packet. */
        payload[itemSize-1] = 'e';
        clientPtr->itemSizeLeft = 0;
    }

    AppTcpSendData(nodePtr, TRANSPORT_PROTOCOL_TCP,
                clientPtr->connectionId, payload, itemSize);
}

/*
 * NAME:        AppFtpClientItemsToSend.
 * PURPOSE:     call tcplib function ftp_nitems() to get the 
 *              number of items to send in an ftp session.
 * PARAMETERS:  nodePtr - pointer to the node.
 * RETRUN:      amount of items to send.
 */
static int 
AppFtpClientItemsToSend(GlomoAppFtpClient *clientPtr)
{
    int items;

    items = ftp_nitems(clientPtr->seed);

    #ifdef DEBUG
        printf("FTP nitems = %d\n", items);
    #endif

    return items;
}



/*
 * NAME:        AppFtpClientItemSize.
 * PURPOSE:     call tcplib function ftp_itemsize() to get the size
 *              of each item.
 * PARAMETERS:  nodePtr - pointer to the node.
 * RETRUN:      size of an item.
 */
static int
AppFtpClientItemSize(GlomoAppFtpClient *clientPtr)
{
    int size;

    size = ftp_itemsize(clientPtr->seed);

    #ifdef DEBUG
        printf("FTP item size = %d\n", size);
    #endif

    return size;
}

/*
 * NAME:        AppFtpClientCtrlPktSize.
 * PURPOSE:     call tcplib function ftp_ctlsize().
 * PARAMETERS:  nodePtr - pointer to the node.
 * RETRUN:      ftp control packet size.
 */
int 
AppFtpClientCtrlPktSize(GlomoAppFtpClient *clientPtr)
{
    int ctrlPktSize;
    ctrlPktSize = ftp_ctlsize(clientPtr->seed);
  
    #ifdef DEBUG
        printf("FTP: Node %d ftp control pktsize = %d\n", 
                ctrlPktSize);
    #endif

    return (ctrlPktSize);
}