/*

    int do_tftpb (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])

    {

        return netboot_common (TFTP, cmdtp, argc, argv);

    }

    U_BOOT_CMD(

        tftpboot,    3,    1,    do_tftpb,

        "tftpboot- boot image via network using TFTP protocol\n",

        "[loadAddress] [[hostIPaddr:]bootfilename]\n"

    );

    */

    int do_tftp (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])

    {

        return netboot_common (TFTP, cmdtp, argc, argv);

    }

    U_BOOT_CMD(

        tftp,    ,    ,    do_tftp,

        "tftp\t- download or upload image via network using TFTP protocol\n",

        "[loadAddress] [bootfilename] <upload_size>\n"

    );

    static int

    netboot_common (proto_t proto, cmd_tbl_t *cmdtp, int argc, char *argv[])

    {

        extern ulong upload_addr;

        extern ulong upload_size;

        char *s;

        int rcode = ;

        int size;

        /* pre-set load_addr */

        if ((s = getenv("loadaddr")) != NULL) {

            load_addr = simple_strtoul(s, NULL, );

        }

        switch (argc) {

        case :

            break;

        case :    /* only one arg - accept two forms:

             * just load address, or just boot file name.

             * The latter form must be written "filename" here.

             */

            if (argv[][] == '"') {    /* just boot filename */

                copy_filename (BootFile, argv[], sizeof(BootFile));

            } else {            /* load address    */

                load_addr = simple_strtoul(argv[], NULL, );

            }

            break;

        case :    load_addr = simple_strtoul(argv[], NULL, );

            copy_filename (BootFile, argv[], sizeof(BootFile));

            upload_size = ;

            break;

        case :

            upload_addr = simple_strtoul(argv[], NULL, );

            upload_size = simple_strtoul(argv[], NULL, );

            copy_filename (BootFile, argv[], sizeof(BootFile));

            break;

        default: printf ("Usage:\n%s\n", cmdtp->usage);

            show_boot_progress (-);

            return ;

        }

        show_boot_progress ();

        if ((size = NetLoop(proto)) < ) {

            show_boot_progress (-);

            return ;

        }

        show_boot_progress ();

        /* NetLoop ok, update environment */

        netboot_update_env();

        /* done if no file was loaded (no errors though) */

        if (size == ) {

            show_boot_progress (-);

            return ;

        }

        /* flush cache */

        flush_cache(load_addr, size);

        /* Loading ok, check if we should attempt an auto-start */

        if (((s = getenv("autostart")) != NULL) && (strcmp(s,"yes") == )) {

            char *local_args[];

            local_args[] = argv[];

            local_args[] = NULL;

            printf ("Automatic boot of image at addr 0x%08lX ...\n",

                load_addr);

            show_boot_progress ();

            rcode = do_bootm (cmdtp, , , local_args);

        }

    #ifdef CONFIG_AUTOSCRIPT

        if (((s = getenv("autoscript")) != NULL) && (strcmp(s,"yes") == )) {

            printf ("Running autoscript at addr 0x%08lX", load_addr);

            s = getenv ("autoscript_uname");

            if (s)

                printf (":%s ...\n", s);

            else

                puts (" ...\n");

            show_boot_progress ();

            rcode = autoscript (load_addr, s);

        }

    #endif

        if (rcode < )

            show_boot_progress (-);

        else

            show_boot_progress ();

        return rcode;

    }

    /*

    * Copyright 1994, 1995, 2000 Neil Russell.

    * (See License)

    * Copyright 2000, 2001 DENX Software Engineering, Wolfgang Denk, wd@denx.de

    */

    #include <common.h>

    #include <command.h>

    #include <net.h>

    #include "tftp.h"

    #include "bootp.h"

    #undef ET_DEBUG

    #if defined(CONFIG_CMD_NET)

    #define WELL_KNOWN_PORT 69 /* Well known TFTP port # */

    #define TIMEOUT 1 /* Seconds to timeout for a lost pkt */

    #ifndef CONFIG_NET_RETRY_COUNT

    # define TIMEOUT_COUNT  /* # of timeouts before giving up */

    #else

    # define TIMEOUT_COUNT (CONFIG_NET_RETRY_COUNT * )

    #endif

    /* (for checking the image size) */

    #define TBLKS_PER_HASHES 64

    #define HASHES_PER_LINE 32 /* Number of "loading" hashes per line */

    /*

    * TFTP operations.

    */

    #define TFTP_RRQ 1

    #define TFTP_WRQ 2

    #define TFTP_DATA 3

    #define TFTP_ACK 4

    #define TFTP_ERROR 5

    #define TFTP_OACK 6

    #define STATE_OK 0

    #define STATE_ERROR 3

    #define STATE_WRQ 6

    #define STATE_ACK 7

    static IPaddr_t TftpServerIP;

    static int TftpServerPort; /* The UDP port at their end */

    static int TftpOurPort; /* The UDP port at our end */

    static int TftpTimeoutCount;

    static ulong TftpBlock; /* packet sequence number */

    static ulong TftpLastBlock; /* last packet sequence number received */

    static ulong TftpBlockWrap; /* count of sequence number wraparounds */

    static ulong TftpBlockWrapOffset; /* memory offset due to wrapping */

    static int TftpState;

    #define STATE_RRQ 1

    #define STATE_DATA 2

    #define STATE_TOO_LARGE 3

    #define STATE_BAD_MAGIC 4

    #define STATE_OACK 5

    #define TFTP_BLOCK_SIZE 512 /* default TFTP block size */

    #define TFTP_SEQUENCE_SIZE ((ulong)(1<<16)) /* sequence number is 16 bit */

    #define DEFAULT_NAME_LEN (8 + 4 + 1)

    static char default_filename[DEFAULT_NAME_LEN];

    #ifndef CONFIG_TFTP_FILE_NAME_MAX_LEN

    #define MAX_LEN 128

    #else

    #define MAX_LEN CONFIG_TFTP_FILE_NAME_MAX_LEN

    #endif

    static char tftp_filename[MAX_LEN];

    #ifdef CFG_DIRECT_FLASH_TFTP

    extern flash_info_t flash_info[];

    #endif

    ulong upload_addr = CFG_LOAD_ADDR; /* Default upLoad Address */

    ulong upload_size = ;

    /* 512 is poor choice for ethernet, MTU is typically 1500.

    * Minus eth.hdrs thats 1468. Can get 2x better throughput with

    * almost-MTU block sizes. At least try... fall back to 512 if need be.

    */

    #define TFTP_MTU_BLOCKSIZE 1468

    static unsigned short TftpBlkSize=TFTP_BLOCK_SIZE;

    static unsigned short TftpBlkSizeOption=TFTP_MTU_BLOCKSIZE;

    #ifdef CONFIG_MCAST_TFTP

    #include <malloc.h>

    #define MTFTP_BITMAPSIZE 0x1000

    static unsigned *Bitmap;

    static int PrevBitmapHole,Mapsize=MTFTP_BITMAPSIZE;

    static uchar ProhibitMcast=, MasterClient=;

    static uchar Multicast=;

    extern IPaddr_t Mcast_addr;

    static int Mcast_port;

    static ulong TftpEndingBlock; /* can get 'last' block before done..*/

    static void parse_multicast_oack(char *pkt,int len);

    static void

    mcast_cleanup(void)

    {

    if (Mcast_addr) eth_mcast_join(Mcast_addr, );

    if (Bitmap) free(Bitmap);

    Bitmap=NULL;

    Mcast_addr = Multicast = Mcast_port = ;

    TftpEndingBlock = -;

    }

    #endif /* CONFIG_MCAST_TFTP */

    static __inline__ void

    store_block (unsigned block, uchar * src, unsigned len)

    {

    ulong offset = block * TftpBlkSize + TftpBlockWrapOffset;

    ulong newsize = offset + len;

    #ifdef CFG_DIRECT_FLASH_TFTP

    int i, rc = ;

    for (i=; i<CFG_MAX_FLASH_BANKS; i++) {

    /* start address in flash? */

    if (flash_info[i].flash_id == FLASH_UNKNOWN)

    continue;

    if ((load_addr + offset >= flash_info[i].start[]) && (load_addr + offset < flash_info[i].start[] + flash_info[i].size)) {

    rc = ;

    break;

    }

    }

    if (rc) { /* Flash is destination for this packet */

    rc = flash_write ((char *)src, (ulong)(load_addr+offset), len);

    if (rc) {

    flash_perror (rc);

    NetState = NETLOOP_FAIL;

    return;

    }

    }

    else

    #endif /* CFG_DIRECT_FLASH_TFTP */

    {

    (void)memcpy((void *)(load_addr + offset), src, len);

    }

    #ifdef CONFIG_MCAST_TFTP

    if (Multicast)

    ext2_set_bit(block, Bitmap);

    #endif

    if (NetBootFileXferSize < newsize)

    NetBootFileXferSize = newsize;

    }

    static void TftpSend (void);

    static void TftpTimeout (void);

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

    static void

    TftpSend (void)

    {

    volatile uchar * pkt;

    volatile uchar * xp;

    int len = ;

    int uplen=;

    volatile ushort *s;

    #ifdef CONFIG_MCAST_TFTP

    /* Multicast TFTP.. non-MasterClients do not ACK data. */

    if (Multicast

    && (TftpState == STATE_DATA)

    && (MasterClient == ))

    return;

    #endif

    /*

    * We will always be sending some sort of packet, so

    * cobble together the packet headers now.

    */

    pkt = NetTxPacket + NetEthHdrSize() + IP_HDR_SIZE;

    switch (TftpState) {

    case STATE_RRQ:

    case STATE_WRQ:

    xp = pkt;

    s = (ushort *)pkt;

    if(TftpState == STATE_WRQ)

    *s++ = htons(TFTP_WRQ);

    else *s++ = htons(TFTP_RRQ);

    pkt = (uchar *)s;

    strcpy ((char *)pkt, tftp_filename);

    pkt += strlen(tftp_filename) + ;

    strcpy ((char *)pkt, "octet");

    pkt +=  /*strlen("octet")*/ + ;

    strcpy ((char *)pkt, "timeout");

    pkt +=  /*strlen("timeout")*/ + ;

    sprintf((char *)pkt, "%d", TIMEOUT);

    #ifdef ET_DEBUG

    printf("send option \"timeout %s\"\n", (char *)pkt);

    #endif

    pkt += strlen((char *)pkt) + ;

    /* try for more effic. blk size */

    if(TftpState == STATE_WRQ)

    pkt += sprintf((char *)pkt,"blksize%c%d%c",

    ,TftpBlkSizeOption,);

    else

    pkt += sprintf((char *)pkt,"blksize%c%d%c",

    ,TftpBlkSizeOption,);

    #ifdef CONFIG_MCAST_TFTP

    /* Check all preconditions before even trying the option */

    if (!ProhibitMcast

    && (Bitmap=malloc(Mapsize))

    && eth_get_dev()->mcast) {

    free(Bitmap);

    Bitmap=NULL;

    pkt += sprintf((char *)pkt,"multicast%c%c",,);

    }

    #endif /* CONFIG_MCAST_TFTP */

    len = pkt - xp;

    printf("%%");

    break;

    case STATE_OACK:

    #ifdef CONFIG_MCAST_TFTP

    /* My turn! Start at where I need blocks I missed.*/

    if (Multicast)

    TftpBlock=ext2_find_next_zero_bit(Bitmap,(Mapsize*),);

    /*..falling..*/

    #endif

    case STATE_DATA:

    xp = pkt;

    s = (ushort *)pkt;

    *s++ = htons(TFTP_ACK);

    *s++ = htons(TftpBlock);

    pkt = (uchar *)s;

    len = pkt - xp;

    break;

    case STATE_TOO_LARGE:

    xp = pkt;

    s = (ushort *)pkt;

    *s++ = htons(TFTP_ERROR);

    *s++ = htons();

    pkt = (uchar *)s;

    strcpy ((char *)pkt, "File too large");

    pkt +=  /*strlen("File too large")*/ + ;

    len = pkt - xp;

    break;

    case STATE_BAD_MAGIC:

    xp = pkt;

    s = (ushort *)pkt;

    *s++ = htons(TFTP_ERROR);

    *s++ = htons();

    pkt = (uchar *)s;

    strcpy ((char *)pkt, "File has bad magic");

    pkt +=  /*strlen("File has bad magic")*/ + ;

    len = pkt - xp;

    break;

    case STATE_ACK:

    xp = pkt;

    s = (ushort *)pkt;

    *s++ = htons(TFTP_DATA);

    *s++ = htons(TftpBlock+);

    pkt = (uchar *)s;

    uplen = (upload_size-TftpBlock*TftpBlkSize);

    uplen = uplen > TftpBlkSize ? TftpBlkSize : uplen;

    memcpy((void*)pkt, (const char*)upload_addr + TftpBlock*TftpBlkSize , uplen);

    pkt += uplen;

    len = pkt - xp;

    break;

    default:

    return;

    }

    NetSendUDPPacket(NetServerEther, TftpServerIP, TftpServerPort, TftpOurPort, len);

    }

    static void tftp_show_transferd(int block, unsigned long wrap)

    {

    #define SHOW_TRANSFERD(tail) printf ("\t[%2lu.%03lu MB]%s", ((block-1)* TftpBlkSize + wrap)>>20, \

    (((block-) * TftpBlkSize + wrap)&0x0FFFFF)>>, tail)

    if( ((block-) & (TBLKS_PER_HASHES-)) == )

    putc('#');

    if( ((block-) & (TBLKS_PER_HASHES*HASHES_PER_LINE-)) == ) {

    if((block-) ==) {

    if(wrap==) {

    puts("\t[ Connected ]\n");

    } else {

    SHOW_TRANSFERD(" [BlockCounter Reset]\n");

    }

    } else {

    SHOW_TRANSFERD("\n");

    }

    }

    #undef SHOW_TRANSFERD

    }

    static void

    TftpHandler (uchar * pkt, unsigned dest, unsigned src, unsigned len)

    {

    ushort proto;

    ushort *s;

    int i;

    if (dest != TftpOurPort) {

    #ifdef CONFIG_MCAST_TFTP

    if (Multicast

    && (!Mcast_port || (dest != Mcast_port)))

    #endif

    return;

    }

    if ( !(TftpState==STATE_RRQ || TftpState==STATE_WRQ) && src != TftpServerPort) {

    return;

    }

    if (len < ) {

    return;

    }

    len -= ;

    /* warning: don't use increment (++) in ntohs() macros!! */

    s = (ushort *)pkt;

    proto = *s++;

    pkt = (uchar *)s;

    switch (ntohs(proto)) {

    case TFTP_RRQ:

    case TFTP_WRQ:

    break;

    case TFTP_ACK:

    TftpServerPort = src;

    TftpState=STATE_ACK;

    TftpBlock = ntohs(*(ushort *)pkt);

    if(TftpLastBlock == TftpBlock) {

    putc('%');

    } else {

    tftp_show_transferd(TftpBlock, TftpBlockWrapOffset);

    }

    TftpLastBlock = TftpBlock;

    NetSetTimeout (TIMEOUT * CFG_HZ, TftpTimeout);

    if(TftpBlkSize*TftpBlock> upload_size )

    {

    NetState = NETLOOP_SUCCESS;

    TftpState = STATE_OK;

    printf ("\n\t %lu.%03lu MB upload ok.\n", (TftpBlockWrapOffset+upload_size)>>,

    ((TftpBlockWrapOffset+upload_size)&0x0FFFFF)>>);

    break;

    }

    TftpSend (); /* Send ACK */

    break;

    default:

    break;

    case TFTP_OACK:

    #ifdef ET_DEBUG

    printf("Got OACK: %s %s\n", pkt, pkt+strlen(pkt)+);

    #endif

    if(TftpState == STATE_WRQ)

    {

    TftpState = STATE_ACK;

    TftpBlock = ;

    }

    else

    {

    TftpState = STATE_OACK;

    }

    TftpServerPort = src;

    /*

    * Check for 'blksize' option.

    * Careful: "i" is signed, "len" is unsigned, thus

    * something like "len-8" may give a *huge* number

    */

    for (i=; i+<len; i++) {

    if (strcmp ((char*)pkt+i,"blksize") == ) {

    TftpBlkSize = (unsigned short)

    simple_strtoul((char*)pkt+i+,NULL,);

    #ifdef ET_DEBUG

    printf ("Blocksize ack: %s, %d\n",

    (char*)pkt+i+,TftpBlkSize);

    #endif

    break;

    }

    }

    #ifdef CONFIG_MCAST_TFTP

    parse_multicast_oack((char *)pkt,len-);

    if ((Multicast) && (!MasterClient))

    TftpState = STATE_DATA; /* passive.. */

    else

    #endif

    TftpSend (); /* Send ACK */

    break;

    case TFTP_DATA:

    if (len < )

    return;

    len -= ;

    TftpBlock = ntohs(*(ushort *)pkt);

    /*

    * RFC1350 specifies that the first data packet will

    * have sequence number 1. If we receive a sequence

    * number of 0 this means that there was a wrap

    * around of the (16 bit) counter.

    */

    if (TftpBlock == ) {

    TftpBlockWrap++;

    TftpBlockWrapOffset += TftpBlkSize * TFTP_SEQUENCE_SIZE;

    printf ("\n\t %lu MB received\n\t ", TftpBlockWrapOffset>>);

    } else {

    #if 0

    if (((TftpBlock - ) % ) == ) {

    putc ('#');

    } else if ((TftpBlock % ( * HASHES_PER_LINE)) == ) {

    puts ("\n\t ");

    }

    #endif

    tftp_show_transferd(TftpBlock, TftpBlockWrapOffset);

    }

    #ifdef ET_DEBUG

    if (TftpState == STATE_RRQ) {

    puts ("Server did not acknowledge timeout option!\n");

    }

    #endif

    if (TftpState == STATE_RRQ || TftpState == STATE_OACK) {

    /* first block received */

    TftpState = STATE_DATA;

    TftpServerPort = src;

    TftpLastBlock = ;

    TftpBlockWrap = ;

    TftpBlockWrapOffset = ;

    #ifdef CONFIG_MCAST_TFTP

    if (Multicast) { /* start!=1 common if mcast */

    TftpLastBlock = TftpBlock - ;

    } else

    #endif

    if (TftpBlock != ) { /* Assertion */

    printf ("\nTFTP error: "

    "First block is not block 1 (%ld)\n"

    "Starting again\n\n",

    TftpBlock);

    NetStartAgain ();

    break;

    }

    }

    if (TftpBlock == TftpLastBlock) {

    /*

    * Same block again; ignore it.

    */

    putc ('%');

    break;

    }

    TftpLastBlock = TftpBlock;

    NetSetTimeout (TIMEOUT * CFG_HZ, TftpTimeout);

    store_block (TftpBlock - , pkt + , len);

    /*

    * Acknoledge the block just received, which will prompt

    * the server for the next one.

    */

    #ifdef CONFIG_MCAST_TFTP

    /* if I am the MasterClient, actively calculate what my next

    * needed block is; else I'm passive; not ACKING

    */

    if (Multicast) {

    if (len < TftpBlkSize) {

    TftpEndingBlock = TftpBlock;

    } else if (MasterClient) {

    TftpBlock = PrevBitmapHole =

    ext2_find_next_zero_bit(

    Bitmap,

    (Mapsize*),

    PrevBitmapHole);

    if (TftpBlock > ((Mapsize*) - )) {

    printf ("tftpfile too big\n");

    /* try to double it and retry */

    Mapsize<<=;

    mcast_cleanup();

    NetStartAgain ();

    return;

    }

    TftpLastBlock = TftpBlock;

    }

    }

    #endif

    TftpSend ();

    #ifdef CONFIG_MCAST_TFTP

    if (Multicast) {

    if (MasterClient && (TftpBlock >= TftpEndingBlock)) {

    puts ("\nMulticast tftp done\n");

    mcast_cleanup();

    NetState = NETLOOP_SUCCESS;

    }

    }

    else

    #endif

    if (len < TftpBlkSize) {

    /*

    * We received the whole thing. Try to

    * run it.

    */

    printf ("\n\t %lu.%03lu MB download ok.\n", ((TftpBlock-)* TftpBlkSize + TftpBlockWrapOffset)>>,

    (((TftpBlock-) * TftpBlkSize + TftpBlockWrapOffset)&0x0FFFFF)>>);

    puts ("\ndone\n");

    NetState = NETLOOP_SUCCESS;

    }

    break;

    case TFTP_ERROR:

    printf ("\nTFTP error: '%s' (%d)\n",

    pkt + , ntohs(*(ushort *)pkt));

    puts ("Starting again\n\n");

    #ifdef CONFIG_MCAST_TFTP

    mcast_cleanup();

    #endif

    NetStartAgain ();

    break;

    }

    }

    static void

    TftpTimeout (void)

    {

    if (++TftpTimeoutCount > TIMEOUT_COUNT) {

    puts ("\nRetry count exceeded; starting again\n");

    #ifdef CONFIG_MCAST_TFTP

    mcast_cleanup();

    #endif

    NetStartAgain ();

    } else {

    puts ("T ");

    NetSetTimeout (TIMEOUT * CFG_HZ, TftpTimeout);

    TftpSend ();

    }

    }

    void

    TftpStart (void)

    {

    #ifdef CONFIG_TFTP_PORT

    char *ep; /* Environment pointer */

    #endif

    if(upload_size)

    TftpState = STATE_WRQ;

    else TftpState = STATE_RRQ;

    TftpServerIP = NetServerIP;

    if (BootFile[] == '\0') {

    sprintf(default_filename, "%02lX%02lX%02lX%02lX.img",

    NetOurIP & 0xFF,

    (NetOurIP >> ) & 0xFF,

    (NetOurIP >> ) & 0xFF,

    (NetOurIP >> ) & 0xFF );

    strncpy(tftp_filename, default_filename, MAX_LEN);

    tftp_filename[MAX_LEN-] = ;

    printf ("*** Warning: no boot file name; using '%s'\n",

    tftp_filename);

    } else {

    char *p = strchr (BootFile, ':');

    if (p == NULL) {

    strncpy(tftp_filename, BootFile, MAX_LEN);

    tftp_filename[MAX_LEN-] = ;

    } else {

    *p++ = '\0';

    TftpServerIP = string_to_ip (BootFile);

    strncpy(tftp_filename, p, MAX_LEN);

    tftp_filename[MAX_LEN-] = ;

    }

    }

    #if defined(CONFIG_NET_MULTI)

    printf ("Using %s device\n", eth_get_name());

    #endif

    if( TftpState == STATE_WRQ)

    {

    puts ("TFTP to server "); print_IPaddr (NetServerIP);

    }

    else

    {

    puts ("TFTP from server "); print_IPaddr (TftpServerIP);

    }

    puts ("; our IP address is "); print_IPaddr (NetOurIP);

    /* Check if we need to send across this subnet */

    if (NetOurGatewayIP && NetOurSubnetMask) {

    IPaddr_t OurNet = NetOurIP & NetOurSubnetMask;

    IPaddr_t ServerNet = TftpServerIP & NetOurSubnetMask;

    if (OurNet != ServerNet) {

    puts ("; sending through gateway ");

    print_IPaddr (NetOurGatewayIP) ;

    }

    }

    putc ('\n');

    if( TftpState == STATE_WRQ)

    printf ("Upload Filename '%s'.", tftp_filename);

    else printf ("Download Filename '%s'.", tftp_filename);

    if (NetBootFileSize) {

    printf (" Size is 0x%x Bytes = ", NetBootFileSize<<);

    print_size (NetBootFileSize<<, "");

    }

    putc ('\n');

    if( TftpState == STATE_WRQ)

    {

    printf ("Upload from address: 0x%lx, ", upload_addr);

    printf ("%lu.%03lu MB to be send ...\n", upload_size>>, (upload_size&0x0FFFFF)>>);

    printf ("Uploading: *\b");

    }

    else

    {

    printf ("Download to address: 0x%lx\n", load_addr);

    printf ("Downloading: *\b");

    }

    NetSetTimeout (TIMEOUT * CFG_HZ, TftpTimeout);

    NetSetHandler (TftpHandler);

    TftpServerPort = WELL_KNOWN_PORT;

    TftpTimeoutCount = ;

    /* Use a pseudo-random port unless a specific port is set */

    TftpOurPort =  + (get_timer() % );

    #ifdef CONFIG_TFTP_PORT

    if ((ep = getenv("tftpdstp")) != NULL) {

    TftpServerPort = simple_strtol(ep, NULL, );

    }

    if ((ep = getenv("tftpsrcp")) != NULL) {

    TftpOurPort= simple_strtol(ep, NULL, );

    }

    #endif

    TftpBlock = ;

    TftpLastBlock = ;

    TftpBlockWrap = ;

    TftpBlockWrapOffset = ;

    /* zero out server ether in case the server ip has changed */

    memset(NetServerEther, , );

    /* Revert TftpBlkSize to dflt */

    TftpBlkSize = TFTP_BLOCK_SIZE;

    #ifdef CONFIG_MCAST_TFTP

    mcast_cleanup();

    #endif

    TftpSend ();

    }

    #ifdef CONFIG_MCAST_TFTP

    /* Credits: atftp project.

    */

    /* pick up BcastAddr, Port, and whether I am [now] the master-client. *

    * Frame:

    * +-------+-----------+---+-------~~-------+---+

    * | opc | multicast | 0 | addr, port, mc | 0 |

    * +-------+-----------+---+-------~~-------+---+

    * The multicast addr/port becomes what I listen to, and if 'mc' is '1' then

    * I am the new master-client so must send ACKs to DataBlocks. If I am not

    * master-client, I'm a passive client, gathering what DataBlocks I may and

    * making note of which ones I got in my bitmask.

    * In theory, I never go from master->passive..

    * .. this comes in with pkt already pointing just past opc

    */

    static void parse_multicast_oack(char *pkt, int len)

    {

    int i;

    IPaddr_t addr;

    char *mc_adr, *port, *mc;

    mc_adr=port=mc=NULL;

    /* march along looking for 'multicast\0', which has to start at least

    * 14 bytes back from the end.

    */

    for (i=;i<len-;i++)

    if (strcmp (pkt+i,"multicast") == )

    break;

    if (i >= (len-)) /* non-Multicast OACK, ign. */

    return;

    i+=; /* strlen multicast */

    mc_adr = pkt+i;

    for (;i<len;i++) {

    if (*(pkt+i) == ',') {

    *(pkt+i) = '\0';

    if (port) {

    mc = pkt+i+;

    break;

    } else {

    port = pkt+i+;

    }

    }

    }

    if (!port || !mc_adr || !mc ) return;

    if (Multicast && MasterClient) {

    printf ("I got a OACK as master Client, WRONG!\n");

    return;

    }

    /* ..I now accept packets destined for this MCAST addr, port */

    if (!Multicast) {

    if (Bitmap) {

    printf ("Internal failure! no mcast.\n");

    free(Bitmap);

    Bitmap=NULL;

    ProhibitMcast=;

    return ;

    }

    /* I malloc instead of pre-declare; so that if the file ends

    * up being too big for this bitmap I can retry

    */

    if (!(Bitmap = malloc (Mapsize))) {

    printf ("No Bitmap, no multicast. Sorry.\n");

    ProhibitMcast=;

    return;

    }

    memset (Bitmap,,Mapsize);

    PrevBitmapHole = ;

    Multicast = ;

    }

    addr = string_to_ip(mc_adr);

    if (Mcast_addr != addr) {

    if (Mcast_addr)

    eth_mcast_join(Mcast_addr, );

    if (eth_mcast_join(Mcast_addr=addr, )) {

    printf ("Fail to set mcast, revert to TFTP\n");

    ProhibitMcast=;

    mcast_cleanup();

    NetStartAgain();

    }

    }

    MasterClient = (unsigned char)simple_strtoul((char *)mc,NULL,);

    Mcast_port = (unsigned short)simple_strtoul(port,NULL,);

    printf ("Multicast: %s:%d [%d]\n", mc_adr, Mcast_port, MasterClient);

    return;

    }

    #endif /* Multicast TFTP */

    #endif