让uboot的tftp支持上传功能

转载：http://blog.chinaunix.net/uid-20737871-id-2124122.html

uboot下的tftp下载功能是非常重要和常见的功能。但是偶尔有些特殊需求的人需要使用uboot的tftp具有上传功能。
默认的uboot没有tftp上传功能，如果需要修改uboot代码。
使用时键入第4个参数，则不同于3个参数的tftp下载功能。
#tftp 50400000 xx.bin 10000
TFTP to server 192.168.0.30; our IP address is 192.168.0.152
Upload Filename 'xx.bin'.
Upload from address: 0x50400000, 0.064 MB to be send ...
Uploading: %#   [ Connected ]

0.064 MB upload ok.
这条命令将板子上0x50400000 开始，长度0x10000的数据上传到远程tftp服务器，命名为xx.bin

这个修改在uboot1.3.4和2008.10版本上测试通过。
1、修改common/cmd_net.c
注释掉

    /*
    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"
    );
    */

可以看出默认uboot执行tftp命令其实调用的是tftpboot，uboot果然是看命名的前面几个字母而不是全名。例如print命令只需要键入pri。
接着添加

    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"
    );

然后修改netboot_common成如下代码

    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;
    }

2、修改net/tftp.c 为

    /*
    * 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