Subversion Repositories HomeAutomation

/*********************************************************************

 *

 *                  TFTP Client module for Microchip TCP/IP Stack

 *

 *********************************************************************

 * FileName:        TFTPc.c

 * Dependencies:    TFTPc.h

 *                  UDP.h

 * Processor:       PIC18

 * Complier:        MCC18 v1.00.50 or higher

 *                  HITECH PICC-18 V8.10PL1 or higher

 * Company:         Microchip Technology, Inc.

 *

 * Software License Agreement

 *

 * The software supplied herewith by Microchip Technology Incorporated

 * (the “Company”) for its PICmicro® Microcontroller is intended and

 * supplied to you, the Company’s customer, for use solely and

 * exclusively on Microchip PICmicro Microcontroller products. The

 * software is owned by the Company and/or its supplier, and is

 * protected under applicable copyright laws. All rights are reserved.

 * Any use in violation of the foregoing restrictions may subject the

 * user to criminal sanctions under applicable laws, as well as to

 * civil liability for the breach of the terms and conditions of this

 * license.

 *

 * THIS SOFTWARE IS PROVIDED IN AN “AS IS” CONDITION. NO WARRANTIES,

 * WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED

 * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A

 * PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT,

 * IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR

 * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.

 *

 * Author               Date    Comment

 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 * Nilesh Rajbharti     8/5/03  Original        (Rev 1.0)

 ********************************************************************/

#if defined(WIN32)

    #include <stdio.h>

    #define TFTP_DEBUG

#endif

#include "..\Include\tftpc.h"

#include "..\Include\arptsk.h"

#include "..\Include\tick.h"

#if !defined(STACK_USE_TFTP_CLIENT)

    #error TFTP Client module is not enabled.

    #error If you do not want TFTP Client module, remove this file from your

    #error project to reduce your code size.

    #error If you do want TFTP Client module, make sure that STACK_USE_TFTP_CLIENT

    #error is defined in StackTsk.h file.

#endif

#define TFTP_CLIENT_PORT        65352L       // Some unique port on this

                                            // device.

#define TFTP_SERVER_PORT        (69L)

#define TFTP_BLOCK_SIZE         (0x200L)     // 512 bytes

#define TFTP_BLOCK_SIZE_MSB     (0x02)

typedef enum _TFTP_STATE

{

    SM_TFTP_WAIT = 0,

    SM_TFTP_READY,

    SM_TFTP_WAIT_FOR_DATA,

    SM_TFTP_WAIT_FOR_ACK,

    SM_TFTP_DUPLICATE_ACK,

    SM_TFTP_SEND_ACK,

    SM_TFTP_SEND_LAST_ACK

} TFTP_STATE;

typedef enum _TFTP_OPCODE

{

    TFTP_OPCODE_RRQ = 1,         // Get

    TFTP_OPCODE_WRQ,            // Put

    TFTP_OPCODE_DATA,           // Actual data

    TFTP_OPCODE_ACK,            // Ack for Get/Put

    TFTP_OPCODE_ERROR           // Error

} TFTP_OPCODE;

UDP_SOCKET _tftpSocket;         // TFTP Socket for TFTP server link

WORD _tftpError;

static union _MutExVar

{

    struct

    {

        NODE_INFO _hostInfo;

    } group1;

    struct

    {

        WORD_VAL _tftpBlockNumber;

        WORD_VAL _tftpDuplicateBlock;

        WORD_VAL _tftpBlockLength;

    } group2;

} MutExVar;     // Mutually Exclusive variable groups to conserve RAM.

static TFTP_STATE _tftpState;

static BYTE _tftpRetries;

static TICK _tftpStartTick;

static union

{

    struct

    {

        unsigned int bIsFlushed : 1;

        unsigned int bIsAcked : 1;

        unsigned int bIsClosed : 1;

        unsigned int bIsClosing : 1;

        unsigned int bIsReading : 1;

    } bits;

    BYTE Val;

} _tftpFlags;

// Private helper functions

static void _TFTPSendFileName(TFTP_OPCODE command, char *fileName);

static void _TFTPSendAck(WORD_VAL blockNumber);

// Blank out DEBUG statements if not enabled.

#if defined(TFTP_DEBUG)

    #define DEBUG(a)        a

#else

    #define DEBUG(a)

#endif

/*********************************************************************

 * Function:        void TFTPOpen(IP_ADDR *host)

 *

 * PreCondition:    UDP module is already initialized

 *                  and at least one UDP socket is available.

 *

 * Input:           host        - IP address of remote TFTP server

 *

 * Output:          None

 *

 * Side Effects:    None

 *

 * Overview:        Initiates ARP for given host and prepares

 *                  TFTP module for next sequence of function calls.

 *

 * Note:            Use TFTPIsOpened() to check if a connection was

 *                  successfully opened or not.

 *

 ********************************************************************/

void TFTPOpen(IP_ADDR *host)

{

    DEBUG(printf("Opening a connection..."));

    // Remember this address locally.

    MutExVar.group1._hostInfo.IPAddr.Val = host->Val;

    // Initiate ARP resolution.

    ARPResolve(&MutExVar.group1._hostInfo.IPAddr);

    // Wait for ARP to get resolved.

    _tftpState = SM_TFTP_WAIT;

    // Mark this as start tick to detect timeout condition.

    _tftpStartTick = TickGet();

    // Forget about all previous attempts.

    _tftpRetries = 1;

}

/*********************************************************************

 * Function:        TFTP_RESULT TFTPIsOpened(void)

 *

 * PreCondition:    TFTPOpen() is already called.

 *

 * Input:           None

 *

 * Output:          TFTP_OK if previous call to TFTPOpen is complete

 *

 *                  TFTP_TIMEOUT if remote host did not respond to

 *                          previous ARP request.

 *

 *                  TFTP_NOT_READY if remote has still not responded

 *                          and timeout has not expired.

 *

 * Side Effects:    None

 *

 * Overview:        Waits for ARP reply and opens a UDP socket

 *                  to perform further TFTP operations.

 *

 * Note:            Once opened, application may keep TFTP socket

 *                  open and future TFTP operations.

 *                  If TFTPClose() is called to close the connection

 *                  TFTPOpen() must be called again before performing

 *                  any other TFTP operations.

 ********************************************************************/

TFTP_RESULT TFTPIsOpened(void)

{

    switch(_tftpState)

    {

    default:

        DEBUG(printf("Resolving remote IP...\n"));

        // Check to see if adddress is resolved.

        if ( ARPIsResolved(&MutExVar.group1._hostInfo.IPAddr,

                           &MutExVar.group1._hostInfo.MACAddr) )

        {

            _tftpSocket = UDPOpen(TFTP_CLIENT_PORT,

                                  &MutExVar.group1._hostInfo,

                                  TFTP_SERVER_PORT);

            _tftpState = SM_TFTP_READY;

        }

        else

            break;

    case SM_TFTP_READY:

        // Wait for UDP to be ready.  Immediately after this user will

        // may TFTPGetFile or TFTPPutFile and we have to make sure that

        // UDP is read to transmit.  These functions do not check for

        // UDP to get ready.

        if ( UDPIsPutReady(_tftpSocket) )

            return TFTP_OK;

    }

    // Make sure that we do not do this forever.

    if ( TickGetDiff(TickGet(), _tftpStartTick) >= TFTP_ARP_TIMEOUT_VAL )

    {

        _tftpStartTick = TickGet();

        // Forget about all previous attempts.

        _tftpRetries = 1;

        return TFTP_TIMEOUT;

    }

    return TFTP_NOT_READY;

}

/*********************************************************************

 * Function:        void TFTPOpenFile(char *fileName,

 *                                    TFTP_FILE_MODE mode)

 *

 * PreCondition:    TFPTIsFileOpenReady() = TRUE

 *

 * Input:           fileName        - File name that is to be opened.

 *                  mode            - Mode of file access

 *                                    Must be

 *                                      TFTP_FILE_MODE_READ for read

 *                                      TFTP_FILE_MODE_WRITE for write

 *

 * Output:          None

 *

 * Side Effects:    None

 *

 * Overview:        Prepares and sends TFTP file name and mode packet.

 *

 * Note:            By default, this funciton uses "octet" or binary

 *                  mode of file transfer.

 *                  Use TFTPIsFileOpened() to check if file is

 *                  ready to be read or written.

 ********************************************************************/

void TFTPOpenFile(char *fileName, TFTP_FILE_MODE mode)

{

    DEBUG(printf("Opening file...\n"));

    // Set TFTP Server port.  If this is the first call, remotePort

    // must have been set by TFTPOpen().  But if caller does not do

    // TFTPOpen for every transfer, we must reset remote port.

    // Most TFTP servers accept connection TFTP port. but once

    // connection is established, they use other temp. port,

    UDPSocketInfo[_tftpSocket].remotePort = TFTP_SERVER_PORT;

    // Tell remote server about our intention.

    _TFTPSendFileName(mode, fileName);

    // Clear all flags.

    _tftpFlags.Val = 0;

    // Remember start tick for this operation.

    _tftpStartTick = TickGet();

    // Depending on mode of operation, remote server will respond with

    // specific block number.

    if ( mode == TFTP_FILE_MODE_READ )

    {

        // Remember that we are reading a file.

        _tftpFlags.bits.bIsReading = TRUE;

        // For read operation, server would respond with data block of 1.

        MutExVar.group2._tftpBlockNumber.Val = 1;

        // Next packet would be the data packet.

        _tftpState = SM_TFTP_WAIT_FOR_DATA;

    }

    else

    {

        // Remember that we are writing a file.

        _tftpFlags.bits.bIsReading = FALSE;

        // For write operation, server would respond with data block of 0.

        MutExVar.group2._tftpBlockNumber.Val = 0;

        // Next packet would be the ACK packet.

        _tftpState = SM_TFTP_WAIT_FOR_ACK;

    }

}

/*********************************************************************

 * Function:        TFTP_RESULT TFTPIsFileOpened(void)

 *

 * PreCondition:    TFTPOpenFile() is called.

 *

 * Input:           None

 *

 * Output:          TFTP_OK if file is ready to be read or written

 *

 *                  TFTP_RETRY if previous attempt was timed out

 *                  needs to be retried.

 *

 *                  TFTP_TIMEOUT if all attempts were exhausted.

 *

 *                  TFTP_NOT_ERROR if remote server responded with

 *                  error

 *

 *                  TFTP_NOT_READY if file is not yet opened.

 *

 * Side Effects:    None

 *

 * Overview:        Waits for remote server response regarding

 *                  previous attempt to open file.

 *                  If no response is received within specified

 *                  timeout, fnction returns with TFTP_RETRY

 *                  and application logic must issue another

 *                  TFTPFileOpen().

 *

 * Note:            None

 ********************************************************************/

TFTP_RESULT TFTPIsFileOpened(void)

{

    if ( _tftpFlags.bits.bIsReading )

        return TFTPIsGetReady();

    else

        return TFTPIsPutReady();

}

/*********************************************************************

 * Function:        TFTP_RESULT TFTPIsGetReady(void)

 *

 * PreCondition:    TFTPOpenFile() is called with TFTP_FILE_MODE_READ

 *                  and TFTPIsFileOpened() returned with TRUE.

 *

 * Input:           None

 *

 * Output:          TFTP_OK if it there is more data byte available

 *                  to read

 *

 *                  TFTP_TIMEOUT if timeout occurred waiting for

 *                  new data.

 *

 *                  TFTP_END_OF_FILE if end of file has reached.

 *

 *                  TFTP_ERROR if remote server returned ERROR.

 *                      Actual error code may be read by calling

 *                      TFTPGetError()

 *

 *                  TFTP_NOT_READY if still waiting for new data.

 *

 * Side Effects:    None

 *

 * Overview:        Waits for data block.  If data block does not

 *                  arrive within specified timeout, it automatically

 *                  sends out ack for previous block to remind

 *                  server to send next data block.

 *                  If all attempts are exhausted, it returns with

 *                  TFTP_TIMEOUT.

 *

 * Note:            By default, this funciton uses "octet" or binary

 *                  mode of file transfer.

 ********************************************************************/

TFTP_RESULT TFTPIsGetReady(void)

{

    WORD_VAL opCode;

    WORD_VAL blockNumber;

    BOOL bTimeOut;

    // Check to see if timeout has occurred.

    bTimeOut = FALSE;

    if ( TickGetDiff(TickGet(), _tftpStartTick) >= TFTP_GET_TIMEOUT_VAL )

    {

        bTimeOut = TRUE;

        _tftpStartTick = TickGet();

    }

    switch(_tftpState)

    {

    case SM_TFTP_WAIT_FOR_DATA:

        // If timeout occurs in this state, it may be because, we have not

        // even received very first data block or some in between block.

        if ( bTimeOut == TRUE )

        {

            bTimeOut = FALSE;

            if ( _tftpRetries++ > (TFTP_MAX_RETRIES-1) )

            {

                DEBUG(printf("TFTPIsGetReady(): Timeout.\n"));

                // Forget about all previous attempts.

                _tftpRetries = 1;

                return TFTP_TIMEOUT;

            }

            // If we have not even received first block, ask application

            // retry.

            if ( MutExVar.group2._tftpBlockNumber.Val == 1 )

            {

                DEBUG(printf("TFTPIsGetReady(): TFTPOpen Retry.\n"));

                return TFTP_RETRY;

            }

            else

            {

                DEBUG(printf("TFTPIsGetReady(): ACK Retry #%d...,\n", _tftpRetries));

                // Block number was already incremented in last ACK attempt,

                // so decrement it.

                MutExVar.group2._tftpBlockNumber.Val--;

                // Do it.

                _tftpState = SM_TFTP_SEND_ACK;

                break;

            }

        }

        // For Read operation, server will respond with data block.

        if ( !UDPIsGetReady(_tftpSocket) )

            break;

        // Get opCode

        UDPGet(&opCode.byte.MSB);

        UDPGet(&opCode.byte.LSB);

        // Get block number.

        UDPGet(&blockNumber.byte.MSB);

        UDPGet(&blockNumber.byte.LSB);

        // In order to read file, this must be data with block number of 0.

        if ( opCode.Val == TFTP_OPCODE_DATA )

        {

            // Make sure that this is not a duplicate block.

            if ( MutExVar.group2._tftpBlockNumber.Val == blockNumber.Val )

            {

                // Mark that we have not acked this block.

                _tftpFlags.bits.bIsAcked = FALSE;

                // Since we have a packet, forget about previous retry count.

                _tftpRetries = 1;

                _tftpState = SM_TFTP_READY;

                return TFTP_OK;

            }

            // If received block has already been received, simply ack it

            // so that Server can "get over" it and send next block.

            else if ( MutExVar.group2._tftpBlockNumber.Val > blockNumber.Val )

            {

                DEBUG(printf("TFTPIsGetReady(): "\

                            "Duplicate block %d received - droping it...\n", \

                            blockNumber.Val));

                MutExVar.group2._tftpDuplicateBlock.Val = blockNumber.Val;

                _tftpState = SM_TFTP_DUPLICATE_ACK;

            }

#if defined(TFTP_DEBUG)

            else

            {

                DEBUG(printf("TFTPIsGetReady(): "\

                             "Unexpected block %d received - droping it...\n", \

                             blockNumber.Val));

            }

#endif

        }

        // Discard all unexpected and error blocks.

        UDPDiscard();

        // If this was an error, remember error code for later delivery.

        if ( opCode.Val == TFTP_OPCODE_ERROR )

        {

            _tftpError = blockNumber.Val;

            return TFTP_ERROR;

        }

        break;

    case SM_TFTP_DUPLICATE_ACK:

        if ( UDPIsPutReady(_tftpSocket) )

        {

            _TFTPSendAck(MutExVar.group2._tftpDuplicateBlock);

            _tftpState = SM_TFTP_WAIT_FOR_DATA;

        }

        break;

    case SM_TFTP_READY:

        if ( UDPIsGetReady(_tftpSocket) )

        {

            _tftpStartTick = TickGet();

            return TFTP_OK;

        }

        // End of file is reached when data block is less than 512 bytes long.

        // To reduce code, only MSB compared against 0x02 (of 0x200 = 512) to

        // determine if block is less than 512 bytes long or not.

        else if ( MutExVar.group2._tftpBlockLength.Val == 0 ||

                  MutExVar.group2._tftpBlockLength.byte.MSB < TFTP_BLOCK_SIZE_MSB )

            _tftpState = SM_TFTP_SEND_LAST_ACK;

        else

            break;

    case SM_TFTP_SEND_LAST_ACK:

    case SM_TFTP_SEND_ACK:

        if ( UDPIsPutReady(_tftpSocket) )

        {

            _TFTPSendAck(MutExVar.group2._tftpBlockNumber);

            // This is the next block we are expecting.

            MutExVar.group2._tftpBlockNumber.Val++;

            // Remember that we have already acked current block.

            _tftpFlags.bits.bIsAcked = TRUE;

            if ( _tftpState == SM_TFTP_SEND_LAST_ACK )

                return TFTP_END_OF_FILE;

            _tftpState = SM_TFTP_WAIT_FOR_DATA;

        }

        break;

    }

    return TFTP_NOT_READY;

}

/*********************************************************************

 * Function:        BYTE TFTPGet(void)

 *

 * PreCondition:    TFTPOpenFile() is called with TFTP_FILE_MODE_READ

 *                  and TFTPIsGetReady() = TRUE

 *

 * Input:           None

 *

 * Output:          data byte as received from remote server.

 *

 * Side Effects:    None

 *

 * Overview:        Fetches next data byte from TFTP socket.

 *                  If end of data block is reached, it issues

 *                  ack to server so that next data block can be

 *                  received.

 *

 * Note:            Use this function to read file from server.

 ********************************************************************/

BYTE TFTPGet(void)

{

    BYTE v;

    // Read byte from UDP

    UDPGet(&v);

    // Update block length

    MutExVar.group2._tftpBlockLength.Val++;

    // Check to see if entire data block is fetched.

    // To reduce code, MSB is compared for 0x02 (of 0x200 = 512).

    if ( MutExVar.group2._tftpBlockLength.byte.MSB == TFTP_BLOCK_SIZE_MSB )

    {

        // Entire block was fetched.  Discard everything else.

        UDPDiscard();

        // Remember that we have flushed this block.

        _tftpFlags.bits.bIsFlushed = TRUE;

        // Reset block length.

        MutExVar.group2._tftpBlockLength.Val = 0;

        // Must send ACK to receive next block.

        _tftpState = SM_TFTP_SEND_ACK;

    }

    return v;

}

/*********************************************************************

 * Function:        void TFTPCloseFile(void)

 *

 * PreCondition:    TFTPOpenFile() was called and TFTPIsFileOpened()

 *                  had returned with TFTP_OK.

 *

 * Input:           None

 *

 * Output:          None

 *

 * Side Effects:    None

 *

 * Overview:        If file is opened in read mode, it makes sure

 *                  that last ACK is sent to server

 *                  If file is opened in write mode, it makes sure

 *                  that last block is sent out to server and

 *                  waits for server to respond with ACK.

 *

 * Note:            TFTPIsFileClosed() must be called to confirm

 *                  if file was really closed.

 ********************************************************************/

void TFTPCloseFile(void)

{

    // If a file was opened for read, we can close it immediately.

    if ( _tftpFlags.bits.bIsReading )

    {

        // If this was premature close, make sure that we discard

        // current block.

        if ( !_tftpFlags.bits.bIsFlushed )

        {

            _tftpFlags.bits.bIsFlushed = TRUE;

            UDPDiscard();

        }

        if ( _tftpFlags.bits.bIsAcked )

        {

            _tftpFlags.bits.bIsClosed = TRUE;

            _tftpFlags.bits.bIsClosing = FALSE;

            return;

        }

        else

        {

            _tftpState = SM_TFTP_SEND_LAST_ACK;

            _tftpFlags.bits.bIsClosing = TRUE;

        }

        return;

    }

    // For write mode, if we have not flushed last block, do it now.

    if ( !_tftpFlags.bits.bIsFlushed )

    {

        _tftpFlags.bits.bIsFlushed = TRUE;

        UDPFlush();

    }

    // For write mode, if our last block was ack'ed by remote server,

    // file is said to be closed.

    if ( _tftpFlags.bits.bIsAcked )

    {

        _tftpFlags.bits.bIsClosed = TRUE;

        _tftpFlags.bits.bIsClosing = FALSE;

        return;

    }

    _tftpState = SM_TFTP_WAIT_FOR_ACK;

    _tftpFlags.bits.bIsClosing =  TRUE;

}

/*********************************************************************

 * Function:        TFTP_RESULT TFPTIsFileClosed(void)

 *

 * PreCondition:    TFTPCloseFile() is already called.

 *

 * Input:           None

 *

 * Output:          TFTP_OK if file was successfully closdd

 *

 *                  TFTP_RETRY if file mode was Write and remote

 *                  server did not receive last packet.

 *                  Application must retry with last block.

 *

 *                  TFTP_TIMEOUT if all attempts were exhausted

 *                  in closing file.

 *

 *                  TFTP_ERROR if remote server sent an error

 *                  in response to last block.

 *                  Actual error code may be read by calling

 *                  TFTPGetError()

 *

 *                  TFTP_NOT_READY if file is not closed yet.

 *

 * Side Effects:    None

 *

 * Overview:        If file mode is Read, it simply makes that

 *                  last block is acknowledged.

 *                  If file mode is Write, it waits for server ack.

 *                  If no ack was received within specified timeout

 *                  instructs appliaction to resend last block.

 *                  It keeps track of retries and declares timeout

 *                  all attempts were exhausted.

 *

 * Note:            None

 ********************************************************************/

TFTP_RESULT TFTPIsFileClosed(void)

{

    if ( _tftpFlags.bits.bIsReading )

        return TFTPIsGetReady();

    else

        return TFTPIsPutReady();

}

/*********************************************************************

 * Function:        TFTP_RESULT TFTPIsPutReady(void)

 *

 * PreCondition:    TFTPOpenFile() is called with TFTP_FILE_MODE_WRITE

 *                  and TFTPIsFileOpened() returned with TRUE.

 *

 * Input:           None

 *

 * Output:          TFTP_OK if it is okay to write more data byte.

 *

 *                  TFTP_TIMEOUT if timeout occurred waiting for

 *                  ack from server

 *

 *                  TFTP_RETRY if all server did not send ack

 *                  on time and application needs to resend

 *                  last block.

 *

 *                  TFTP_ERROR if remote server returned ERROR.

 *                  Actual error code may be read by calling

 *                  TFTPGetError()

 *

 *                  TFTP_NOT_READY if still waiting...

 *

 * Side Effects:    None

 *

 * Overview:        Waits for ack from server.  If ack does not

 *                  arrive within specified timeout, it it instructs

 *                  application to retry last block by returning

 *                  TFTP_RETRY.

 *

 *                  If all attempts are exhausted, it returns with

 *                  TFTP_TIMEOUT.

 *

 * Note:            None

 ********************************************************************/

TFTP_RESULT TFTPIsPutReady(void)

{

    WORD_VAL opCode;

    WORD_VAL blockNumber;

    BOOL bTimeOut;

    // Check to see if timeout has occurred.

    bTimeOut = FALSE;

    if ( TickGetDiff(TickGet(), _tftpStartTick) >= TFTP_GET_TIMEOUT_VAL )

    {

        bTimeOut = TRUE;

        _tftpStartTick = TickGet();

    }

    switch(_tftpState)

    {

    case SM_TFTP_WAIT_FOR_ACK:

        // When timeout occurs in this state, application must retry.

        if ( bTimeOut )

        {

            if ( _tftpRetries++ > (TFTP_MAX_RETRIES-1) )

            {

                DEBUG(printf("TFTPIsPutReady(): Timeout.\n"));

                // Forget about all previous attempts.

                _tftpRetries = 1;

                return TFTP_TIMEOUT;

            }

            else

            {

                DEBUG(printf("TFTPIsPutReady(): Retry.\n"));

                return TFTP_RETRY;

            }

        }

        // Must wait for ACK from server before we transmit next block.

        if ( !UDPIsGetReady(_tftpSocket) )

            break;

        // Get opCode.

        UDPGet(&opCode.byte.MSB);

        UDPGet(&opCode.byte.LSB);

        // Get block number.

        UDPGet(&blockNumber.byte.MSB);

        UDPGet(&blockNumber.byte.LSB);

        // Discard everything else.

        UDPDiscard();

        // This must be ACK or else there is a problem.

        if ( opCode.Val == TFTP_OPCODE_ACK )

        {

            // Also the block number must match with what we are expecting.

            if ( MutExVar.group2._tftpBlockNumber.Val == blockNumber.Val )

            {

                // Mark that block we sent previously has been ack'ed.

                _tftpFlags.bits.bIsAcked = TRUE;

                // Since we have ack, forget about previous retry count.

                _tftpRetries = 1;

                // If this file is being closed, this must be last ack.

                // Declare it as closed.

                if ( _tftpFlags.bits.bIsClosing )

                {

                    _tftpFlags.bits.bIsClosed = TRUE;

                    return TFTP_OK;

                }

                // Or else, wait for put to become ready so that caller

                // can transfer more data blocks.

                _tftpState = SM_TFTP_WAIT;

            }

            else

            {

                DEBUG(printf("TFTPIsPutReady(): "\

                    "Unexpected block %d received - droping it...\n", \

                    blockNumber.Val));

                return TFTP_NOT_READY;

            }

        }

        else if ( opCode.Val == TFTP_OPCODE_ERROR )

        {

            // For error opCode, remember error code so that application

            // can read it later.

            _tftpError = blockNumber.Val;

            // Declare error.

            return TFTP_ERROR;

        }

        else

            break;

    case SM_TFTP_WAIT:

        // Wait for UDP is to be ready to transmit.

        if ( UDPIsPutReady(_tftpSocket) )

        {

            // Put next block of data.

            MutExVar.group2._tftpBlockNumber.Val++;

            UDPPut(0);

            UDPPut(TFTP_OPCODE_DATA);

            UDPPut(MutExVar.group2._tftpBlockNumber.byte.MSB);

            UDPPut(MutExVar.group2._tftpBlockNumber.byte.LSB);

            // Remember that this block is not yet flushed.

            _tftpFlags.bits.bIsFlushed = FALSE;

            // Remember that this block is not acknowledged.

            _tftpFlags.bits.bIsAcked = FALSE;

            // Now, TFTP module is ready to put more data.

            _tftpState = SM_TFTP_READY;

            return TFTP_OK;

        }

        break;

    case SM_TFTP_READY:

        // TFTP module is said to be ready only when underlying UDP

        // is ready to transmit.

        if ( UDPIsPutReady(_tftpSocket) )

            return TFTP_OK;

    }

    return TFTP_NOT_READY;

}

/*********************************************************************

 * Function:        void TFTPPut(BYTE c)

 *

 * PreCondition:    TFTPOpenFile() is called with TFTP_FILE_MODE_WRITE

 *                  and TFTPIsPutReady() = TRUE

 *

 * Input:           c       - Data byte that is to be written

 *

 * Output:          None

 *

 * Side Effects:    None

 *

 * Overview:        Puts given data byte into TFTP socket.

 *                  If end of data block is reached, it

 *                  transmits entire block.

 *

 * Note:            Use this function to write file to server.

 ********************************************************************/

void TFTPPut(BYTE c)

{

    // Put given byte directly to UDP

    UDPPut(c);