net/tftp.c

   1 /*
   2  *      Copyright 1994, 1995, 2000 Neil Russell.
   3  *      (See License)
   4  *      Copyright 2000, 2001 DENX Software Engineering, Wolfgang Denk, wd@denx.de
   5  */
   6
   7 #include <common.h>
   8 #include <command.h>
   9 #include <net.h>
  10 #include "tftp.h"
  11 #include "bootp.h"
  12
  13 #define WELL_KNOWN_PORT 69              /* Well known TFTP port #               */
  14 #define TIMEOUT         5000UL          /* Millisecs to timeout for lost pkt */
  15 #ifndef CONFIG_NET_RETRY_COUNT
  16 # define TIMEOUT_COUNT  10              /* # of timeouts before giving up  */
  17 #else
  18 # define TIMEOUT_COUNT  (CONFIG_NET_RETRY_COUNT * 2)
  19 #endif
  20                                         /* (for checking the image size)        */
  21 #define HASHES_PER_LINE 65              /* Number of "loading" hashes per line  */
  22
  23 /*
  24  *      TFTP operations.
  25  */
  26 #define TFTP_RRQ        1
  27 #define TFTP_WRQ        2
  28 #define TFTP_DATA       3
  29 #define TFTP_ACK        4
  30 #define TFTP_ERROR      5
  31 #define TFTP_OACK       6
  32
  33 static ulong TftpTimeoutMSecs = TIMEOUT;
  34 static int TftpTimeoutCountMax = TIMEOUT_COUNT;
  35
  36 /*
  37  * These globals govern the timeout behavior when attempting a connection to a
  38  * TFTP server. TftpRRQTimeoutMSecs specifies the number of milliseconds to
  39  * wait for the server to respond to initial connection. Second global,
  40  * TftpRRQTimeoutCountMax, gives the number of such connection retries.
  41  * TftpRRQTimeoutCountMax must be non-negative and TftpRRQTimeoutMSecs must be
  42  * positive. The globals are meant to be set (and restored) by code needing
  43  * non-standard timeout behavior when initiating a TFTP transfer.
  44  */
  45 ulong TftpRRQTimeoutMSecs = TIMEOUT;
  46 int TftpRRQTimeoutCountMax = TIMEOUT_COUNT;
  47
  48 enum {
  49         TFTP_ERR_UNDEFINED           = 0,
  50         TFTP_ERR_FILE_NOT_FOUND      = 1,
  51         TFTP_ERR_ACCESS_DENIED       = 2,
  52         TFTP_ERR_DISK_FULL           = 3,
  53         TFTP_ERR_UNEXPECTED_OPCODE   = 4,
  54         TFTP_ERR_UNKNOWN_TRANSFER_ID  = 5,
  55         TFTP_ERR_FILE_ALREADY_EXISTS = 6,
  56 };
  57
  58 static IPaddr_t TftpServerIP;
  59 static int      TftpServerPort;         /* The UDP port at their end            */
  60 static int      TftpOurPort;            /* The UDP port at our end              */
  61 static int      TftpTimeoutCount;
  62 static ulong    TftpBlock;              /* packet sequence number               */
  63 static ulong    TftpLastBlock;          /* last packet sequence number received */
  64 static ulong    TftpBlockWrap;          /* count of sequence number wraparounds */
  65 static ulong    TftpBlockWrapOffset;    /* memory offset due to wrapping        */
  66 static int      TftpState;
  67 #ifdef CONFIG_TFTP_TSIZE
  68 static int      TftpTsize;              /* The file size reported by the server */
  69 static short    TftpNumchars;           /* The number of hashes we printed      */
  70 #endif
  71
  72 #define STATE_RRQ       1
  73 #define STATE_DATA      2
  74 #define STATE_TOO_LARGE 3
  75 #define STATE_BAD_MAGIC 4
  76 #define STATE_OACK      5
  77
  78 #define TFTP_BLOCK_SIZE         512                 /* default TFTP block size  */
  79 #define TFTP_SEQUENCE_SIZE      ((ulong)(1<<16))    /* sequence number is 16 bit */
  80
  81 #define DEFAULT_NAME_LEN        (8 + 4 + 1)
  82 static char default_filename[DEFAULT_NAME_LEN];
  83
  84 #ifndef CONFIG_TFTP_FILE_NAME_MAX_LEN
  85 #define MAX_LEN 128
  86 #else
  87 #define MAX_LEN CONFIG_TFTP_FILE_NAME_MAX_LEN
  88 #endif
  89
  90 static char tftp_filename[MAX_LEN];
  91
  92 #ifdef CONFIG_SYS_DIRECT_FLASH_TFTP
  93 extern flash_info_t flash_info[];
  94 #endif
  95
  96 /* 512 is poor choice for ethernet, MTU is typically 1500.
  97  * Minus eth.hdrs thats 1468.  Can get 2x better throughput with
  98  * almost-MTU block sizes.  At least try... fall back to 512 if need be.
  99  * (but those using CONFIG_IP_DEFRAG may want to set a larger block in cfg file)
 100  */
 101 #ifdef CONFIG_TFTP_BLOCKSIZE
 102 #define TFTP_MTU_BLOCKSIZE CONFIG_TFTP_BLOCKSIZE
 103 #else
 104 #define TFTP_MTU_BLOCKSIZE 1468
 105 #endif
 106
 107 static unsigned short TftpBlkSize=TFTP_BLOCK_SIZE;
 108 static unsigned short TftpBlkSizeOption=TFTP_MTU_BLOCKSIZE;
 109
 110 #ifdef CONFIG_MCAST_TFTP
 111 #include <malloc.h>
 112 #define MTFTP_BITMAPSIZE        0x1000
 113 static unsigned *Bitmap;
 114 static int PrevBitmapHole,Mapsize=MTFTP_BITMAPSIZE;
 115 static uchar ProhibitMcast=0, MasterClient=0;
 116 static uchar Multicast=0;
 117 extern IPaddr_t Mcast_addr;
 118 static int Mcast_port;
 119 static ulong TftpEndingBlock; /* can get 'last' block before done..*/
 120
 121 static void parse_multicast_oack(char *pkt,int len);
 122
 123 static void
 124 mcast_cleanup(void)
 125 {
 126         if (Mcast_addr) eth_mcast_join(Mcast_addr, 0);
 127         if (Bitmap) free(Bitmap);
 128         Bitmap=NULL;
 129         Mcast_addr = Multicast = Mcast_port = 0;
 130         TftpEndingBlock = -1;
 131 }
 132
 133 #endif  /* CONFIG_MCAST_TFTP */
 134
 135 static __inline__ void
 136 store_block (unsigned block, uchar * src, unsigned len)
 137 {
 138         ulong offset = block * TftpBlkSize + TftpBlockWrapOffset;
 139         ulong newsize = offset + len;
 140 #ifdef CONFIG_SYS_DIRECT_FLASH_TFTP
 141         int i, rc = 0;
 142
 143         for (i=0; i<CONFIG_SYS_MAX_FLASH_BANKS; i++) {
 144                 /* start address in flash? */
 145                 if (flash_info[i].flash_id == FLASH_UNKNOWN)
 146                         continue;
 147                 if (load_addr + offset >= flash_info[i].start[0]) {
 148                         rc = 1;
 149                         break;
 150                 }
 151         }
 152
 153         if (rc) { /* Flash is destination for this packet */
 154                 rc = flash_write ((char *)src, (ulong)(load_addr+offset), len);
 155                 if (rc) {
 156                         flash_perror (rc);
 157                         NetState = NETLOOP_FAIL;
 158                         return;
 159                 }
 160         }
 161         else
 162 #endif /* CONFIG_SYS_DIRECT_FLASH_TFTP */
 163         {
 164                 (void)memcpy((void *)(load_addr + offset), src, len);
 165         }
 166 #ifdef CONFIG_MCAST_TFTP
 167         if (Multicast)
 168                 ext2_set_bit(block, Bitmap);
 169 #endif
 170
 171         if (NetBootFileXferSize < newsize)
 172                 NetBootFileXferSize = newsize;
 173 }
 174
 175 static void TftpSend (void);
 176 static void TftpTimeout (void);
 177
 178 /**********************************************************************/
 179
 180 static void
 181 TftpSend (void)
 182 {
 183         volatile uchar *        pkt;
 184         volatile uchar *        xp;
 185         int                     len = 0;
 186         volatile ushort *s;
 187
 188 #ifdef CONFIG_MCAST_TFTP
 189         /* Multicast TFTP.. non-MasterClients do not ACK data. */
 190         if (Multicast
 191          && (TftpState == STATE_DATA)
 192          && (MasterClient == 0))
 193                 return;
 194 #endif
 195         /*
 196          *      We will always be sending some sort of packet, so
 197          *      cobble together the packet headers now.
 198          */
 199         pkt = NetTxPacket + NetEthHdrSize() + IP_HDR_SIZE;
 200
 201         switch (TftpState) {
 202
 203         case STATE_RRQ:
 204                 xp = pkt;
 205                 s = (ushort *)pkt;
 206                 *s++ = htons(TFTP_RRQ);
 207                 pkt = (uchar *)s;
 208                 strcpy ((char *)pkt, tftp_filename);
 209                 pkt += strlen(tftp_filename) + 1;
 210                 strcpy ((char *)pkt, "octet");
 211                 pkt += 5 /*strlen("octet")*/ + 1;
 212                 strcpy ((char *)pkt, "timeout");
 213                 pkt += 7 /*strlen("timeout")*/ + 1;
 214                 sprintf((char *)pkt, "%lu", TftpTimeoutMSecs / 1000);
 215                 debug("send option \"timeout %s\"\n", (char *)pkt);
 216                 pkt += strlen((char *)pkt) + 1;
 217 #ifdef CONFIG_TFTP_TSIZE
 218                 memcpy((char *)pkt, "tsize\0000\0", 8);
 219                 pkt += 8;
 220 #endif
 221                 /* try for more effic. blk size */
 222                 pkt += sprintf((char *)pkt,"blksize%c%d%c",
 223                                 0,TftpBlkSizeOption,0);
 224 #ifdef CONFIG_MCAST_TFTP
 225                 /* Check all preconditions before even trying the option */
 226                 if (!ProhibitMcast
 227                  && (Bitmap=malloc(Mapsize))
 228                  && eth_get_dev()->mcast) {
 229                         free(Bitmap);
 230                         Bitmap=NULL;
 231                         pkt += sprintf((char *)pkt,"multicast%c%c",0,0);
 232                 }
 233 #endif /* CONFIG_MCAST_TFTP */
 234                 len = pkt - xp;
 235                 break;
 236
 237         case STATE_OACK:
 238 #ifdef CONFIG_MCAST_TFTP
 239                 /* My turn!  Start at where I need blocks I missed.*/
 240                 if (Multicast)
 241                         TftpBlock=ext2_find_next_zero_bit(Bitmap,(Mapsize*8),0);
 242                 /*..falling..*/
 243 #endif
 244         case STATE_DATA:
 245                 xp = pkt;
 246                 s = (ushort *)pkt;
 247                 *s++ = htons(TFTP_ACK);
 248                 *s++ = htons(TftpBlock);
 249                 pkt = (uchar *)s;
 250                 len = pkt - xp;
 251                 break;
 252
 253         case STATE_TOO_LARGE:
 254                 xp = pkt;
 255                 s = (ushort *)pkt;
 256                 *s++ = htons(TFTP_ERROR);
 257                 *s++ = htons(3);
 258                 pkt = (uchar *)s;
 259                 strcpy ((char *)pkt, "File too large");
 260                 pkt += 14 /*strlen("File too large")*/ + 1;
 261                 len = pkt - xp;
 262                 break;
 263
 264         case STATE_BAD_MAGIC:
 265                 xp = pkt;
 266                 s = (ushort *)pkt;
 267                 *s++ = htons(TFTP_ERROR);
 268                 *s++ = htons(2);
 269                 pkt = (uchar *)s;
 270                 strcpy ((char *)pkt, "File has bad magic");
 271                 pkt += 18 /*strlen("File has bad magic")*/ + 1;
 272                 len = pkt - xp;
 273                 break;
 274         }
 275
 276         NetSendUDPPacket(NetServerEther, TftpServerIP, TftpServerPort, TftpOurPort, len);
 277 }
 278
 279
 280 static void
 281 TftpHandler(uchar *pkt, unsigned dest, IPaddr_t sip, unsigned src,
 282             unsigned len)
 283 {
 284         ushort proto;
 285         ushort *s;
 286         int i;
 287
 288         if (dest != TftpOurPort) {
 289 #ifdef CONFIG_MCAST_TFTP
 290                 if (Multicast
 291                  && (!Mcast_port || (dest != Mcast_port)))
 292 #endif
 293                 return;
 294         }
 295         if (TftpState != STATE_RRQ && src != TftpServerPort) {
 296                 return;
 297         }
 298
 299         if (len < 2) {
 300                 return;
 301         }
 302         len -= 2;
 303         /* warning: don't use increment (++) in ntohs() macros!! */
 304         s = (ushort *)pkt;
 305         proto = *s++;
 306         pkt = (uchar *)s;
 307         switch (ntohs(proto)) {
 308
 309         case TFTP_RRQ:
 310         case TFTP_WRQ:
 311         case TFTP_ACK:
 312                 break;
 313         default:
 314                 break;
 315
 316         case TFTP_OACK:
 317                 debug("Got OACK: %s %s\n",
 318                         pkt,
 319                         pkt + strlen((char *)pkt) + 1);
 320                 TftpState = STATE_OACK;
 321                 TftpServerPort = src;
 322                 /*
 323                  * Check for 'blksize' option.
 324                  * Careful: "i" is signed, "len" is unsigned, thus
 325                  * something like "len-8" may give a *huge* number
 326                  */
 327                 for (i=0; i+8<len; i++) {
 328                         if (strcmp ((char*)pkt+i,"blksize") == 0) {
 329                                 TftpBlkSize = (unsigned short)
 330                                         simple_strtoul((char*)pkt+i+8,NULL,10);
 331                                 debug("Blocksize ack: %s, %d\n",
 332                                         (char*)pkt+i+8,TftpBlkSize);
 333                         }
 334 #ifdef CONFIG_TFTP_TSIZE
 335                         if (strcmp ((char*)pkt+i,"tsize") == 0) {
 336                                 TftpTsize = simple_strtoul((char*)pkt+i+6,NULL,10);
 337                                 debug("size = %s, %d\n",
 338                                          (char*)pkt+i+6, TftpTsize);
 339                         }
 340 #endif
 341                 }
 342 #ifdef CONFIG_MCAST_TFTP
 343                 parse_multicast_oack((char *)pkt,len-1);
 344                 if ((Multicast) && (!MasterClient))
 345                         TftpState = STATE_DATA; /* passive.. */
 346                 else
 347 #endif
 348                 TftpSend (); /* Send ACK */
 349                 break;
 350         case TFTP_DATA:
 351                 if (len < 2)
 352                         return;
 353                 len -= 2;
 354                 TftpBlock = ntohs(*(ushort *)pkt);
 355
 356                 /*
 357                  * RFC1350 specifies that the first data packet will
 358                  * have sequence number 1. If we receive a sequence
 359                  * number of 0 this means that there was a wrap
 360                  * around of the (16 bit) counter.
 361                  */
 362                 if (TftpBlock == 0) {
 363                         TftpBlockWrap++;
 364                         TftpBlockWrapOffset += TftpBlkSize * TFTP_SEQUENCE_SIZE;
 365                         printf ("\n\t %lu MB received\n\t ", TftpBlockWrapOffset>>20);
 366                 }
 367 #ifdef CONFIG_TFTP_TSIZE
 368                 else if (TftpTsize) {
 369                         while (TftpNumchars < NetBootFileXferSize * 50 / TftpTsize) {
 370                                 putc('#');
 371                                 TftpNumchars++;
 372                         }
 373                 }
 374 #endif
 375                 else {
 376                         if (((TftpBlock - 1) % 10) == 0) {
 377                                 putc ('#');
 378                         } else if ((TftpBlock % (10 * HASHES_PER_LINE)) == 0) {
 379                                 puts ("\n\t ");
 380                         }
 381                 }
 382
 383                 if (TftpState == STATE_RRQ)
 384                         debug("Server did not acknowledge timeout option!\n");
 385
 386                 if (TftpState == STATE_RRQ || TftpState == STATE_OACK) {
 387                         /* first block received */
 388                         TftpState = STATE_DATA;
 389                         TftpServerPort = src;
 390                         TftpLastBlock = 0;
 391                         TftpBlockWrap = 0;
 392                         TftpBlockWrapOffset = 0;
 393
 394 #ifdef CONFIG_MCAST_TFTP
 395                         if (Multicast) { /* start!=1 common if mcast */
 396                                 TftpLastBlock = TftpBlock - 1;
 397                         } else
 398 #endif
 399                         if (TftpBlock != 1) {   /* Assertion */
 400                                 printf ("\nTFTP error: "
 401                                         "First block is not block 1 (%ld)\n"
 402                                         "Starting again\n\n",
 403                                         TftpBlock);
 404                                 NetStartAgain ();
 405                                 break;
 406                         }
 407                 }
 408
 409                 if (TftpBlock == TftpLastBlock) {
 410                         /*
 411                          *      Same block again; ignore it.
 412                          */
 413                         break;
 414                 }
 415
 416                 TftpLastBlock = TftpBlock;
 417                 TftpTimeoutCountMax = TIMEOUT_COUNT;
 418                 NetSetTimeout (TftpTimeoutMSecs, TftpTimeout);
 419
 420                 store_block (TftpBlock - 1, pkt + 2, len);
 421
 422                 /*
 423                  *      Acknoledge the block just received, which will prompt
 424                  *      the server for the next one.
 425                  */
 426 #ifdef CONFIG_MCAST_TFTP
 427                 /* if I am the MasterClient, actively calculate what my next
 428                  * needed block is; else I'm passive; not ACKING
 429                  */
 430                 if (Multicast) {
 431                         if (len < TftpBlkSize)  {
 432                                 TftpEndingBlock = TftpBlock;
 433                         } else if (MasterClient) {
 434                                 TftpBlock = PrevBitmapHole =
 435                                         ext2_find_next_zero_bit(
 436                                                 Bitmap,
 437                                                 (Mapsize*8),
 438                                                 PrevBitmapHole);
 439                                 if (TftpBlock > ((Mapsize*8) - 1)) {
 440                                         printf ("tftpfile too big\n");
 441                                         /* try to double it and retry */
 442                                         Mapsize<<=1;
 443                                         mcast_cleanup();
 444                                         NetStartAgain ();
 445                                         return;
 446                                 }
 447                                 TftpLastBlock = TftpBlock;
 448                         }
 449                 }
 450 #endif
 451                 TftpSend ();
 452
 453 #ifdef CONFIG_MCAST_TFTP
 454                 if (Multicast) {
 455                         if (MasterClient && (TftpBlock >= TftpEndingBlock)) {
 456                                 puts ("\nMulticast tftp done\n");
 457                                 mcast_cleanup();
 458                                 NetState = NETLOOP_SUCCESS;
 459                         }
 460                 }
 461                 else
 462 #endif
 463                 if (len < TftpBlkSize) {
 464                         /*
 465                          *      We received the whole thing.  Try to
 466                          *      run it.
 467                          */
 468 #ifdef CONFIG_TFTP_TSIZE
 469                         /* Print out the hash marks for the last packet received */
 470                         while (TftpTsize && TftpNumchars < 49) {
 471                                 putc('#');
 472                                 TftpNumchars++;
 473                         }
 474 #endif
 475                         puts ("\ndone\n");
 476                         NetState = NETLOOP_SUCCESS;
 477                 }
 478                 break;
 479
 480         case TFTP_ERROR:
 481                 printf ("\nTFTP error: '%s' (%d)\n",
 482                                         pkt + 2, ntohs(*(ushort *)pkt));
 483
 484                 switch (ntohs(*(ushort *)pkt)) {
 485                 case TFTP_ERR_FILE_NOT_FOUND:
 486                 case TFTP_ERR_ACCESS_DENIED:
 487                         puts("Not retrying...\n");
 488                         eth_halt();
 489                         NetState = NETLOOP_FAIL;
 490                         break;
 491                 case TFTP_ERR_UNDEFINED:
 492                 case TFTP_ERR_DISK_FULL:
 493                 case TFTP_ERR_UNEXPECTED_OPCODE:
 494                 case TFTP_ERR_UNKNOWN_TRANSFER_ID:
 495                 case TFTP_ERR_FILE_ALREADY_EXISTS:
 496                 default:
 497                         puts("Starting again\n\n");
 498 #ifdef CONFIG_MCAST_TFTP
 499                         mcast_cleanup();
 500 #endif
 501                         NetStartAgain();
 502                         break;
 503                 }
 504                 break;
 505         }
 506 }
 507
 508
 509 static void
 510 TftpTimeout (void)
 511 {
 512         if (++TftpTimeoutCount > TftpTimeoutCountMax) {
 513                 puts ("\nRetry count exceeded; starting again\n");
 514 #ifdef CONFIG_MCAST_TFTP
 515                 mcast_cleanup();
 516 #endif
 517                 NetStartAgain ();
 518         } else {
 519                 puts ("T ");
 520                 NetSetTimeout (TftpTimeoutMSecs, TftpTimeout);
 521                 TftpSend ();
 522         }
 523 }
 524
 525
 526 void
 527 TftpStart (void)
 528 {
 529         char *ep;             /* Environment pointer */
 530
 531         /*
 532          * Allow the user to choose TFTP blocksize and timeout.
 533          * TFTP protocol has a minimal timeout of 1 second.
 534          */
 535         if ((ep = getenv("tftpblocksize")) != NULL)
 536                 TftpBlkSizeOption = simple_strtol(ep, NULL, 10);
 537
 538         if ((ep = getenv("tftptimeout")) != NULL)
 539                 TftpTimeoutMSecs = simple_strtol(ep, NULL, 10);
 540
 541         if (TftpTimeoutMSecs < 1000) {
 542                 printf("TFTP timeout (%ld ms) too low, "
 543                         "set minimum = 1000 ms\n",
 544                         TftpTimeoutMSecs);
 545                 TftpTimeoutMSecs = 1000;
 546         }
 547
 548         debug("TFTP blocksize = %i, timeout = %ld ms\n",
 549                 TftpBlkSizeOption, TftpTimeoutMSecs);
 550
 551         TftpServerIP = NetServerIP;
 552         if (BootFile[0] == '\0') {
 553                 sprintf(default_filename, "%02lX%02lX%02lX%02lX.img",
 554                         NetOurIP & 0xFF,
 555                         (NetOurIP >>  8) & 0xFF,
 556                         (NetOurIP >> 16) & 0xFF,
 557                         (NetOurIP >> 24) & 0xFF );
 558
 559                 strncpy(tftp_filename, default_filename, MAX_LEN);
 560                 tftp_filename[MAX_LEN-1] = 0;
 561
 562                 printf ("*** Warning: no boot file name; using '%s'\n",
 563                         tftp_filename);
 564         } else {
 565                 char *p = strchr (BootFile, ':');
 566
 567                 if (p == NULL) {
 568                         strncpy(tftp_filename, BootFile, MAX_LEN);
 569                         tftp_filename[MAX_LEN-1] = 0;
 570                 } else {
 571                         TftpServerIP = string_to_ip (BootFile);
 572                         strncpy(tftp_filename, p + 1, MAX_LEN);
 573                         tftp_filename[MAX_LEN-1] = 0;
 574                 }
 575         }
 576
 577 #if defined(CONFIG_NET_MULTI)
 578         printf ("Using %s device\n", eth_get_name());
 579 #endif
 580         printf("TFTP from server %pI4"
 581                 "; our IP address is %pI4", &TftpServerIP, &NetOurIP);
 582
 583         /* Check if we need to send across this subnet */
 584         if (NetOurGatewayIP && NetOurSubnetMask) {
 585             IPaddr_t OurNet     = NetOurIP    & NetOurSubnetMask;
 586             IPaddr_t ServerNet  = TftpServerIP & NetOurSubnetMask;
 587
 588             if (OurNet != ServerNet)
 589                 printf("; sending through gateway %pI4", &NetOurGatewayIP);
 590         }
 591         putc ('\n');
 592
 593         printf ("Filename '%s'.", tftp_filename);
 594
 595         if (NetBootFileSize) {
 596                 printf (" Size is 0x%x Bytes = ", NetBootFileSize<<9);
 597                 print_size (NetBootFileSize<<9, "");
 598         }
 599
 600         putc ('\n');
 601
 602         printf ("Load address: 0x%lx\n", load_addr);
 603
 604         puts ("Loading: *\b");
 605
 606         TftpTimeoutCountMax = TftpRRQTimeoutCountMax;
 607
 608         NetSetTimeout (TftpTimeoutMSecs, TftpTimeout);
 609         NetSetHandler (TftpHandler);
 610
 611         TftpServerPort = WELL_KNOWN_PORT;
 612         TftpTimeoutCount = 0;
 613         TftpState = STATE_RRQ;
 614         /* Use a pseudo-random port unless a specific port is set */
 615         TftpOurPort = 1024 + (get_timer(0) % 3072);
 616
 617 #ifdef CONFIG_TFTP_PORT
 618         if ((ep = getenv("tftpdstp")) != NULL) {
 619                 TftpServerPort = simple_strtol(ep, NULL, 10);
 620         }
 621         if ((ep = getenv("tftpsrcp")) != NULL) {
 622                 TftpOurPort= simple_strtol(ep, NULL, 10);
 623         }
 624 #endif
 625         TftpBlock = 0;
 626
 627         /* zero out server ether in case the server ip has changed */
 628         memset(NetServerEther, 0, 6);
 629         /* Revert TftpBlkSize to dflt */
 630         TftpBlkSize = TFTP_BLOCK_SIZE;
 631 #ifdef CONFIG_MCAST_TFTP
 632         mcast_cleanup();
 633 #endif
 634 #ifdef CONFIG_TFTP_TSIZE
 635         TftpTsize = 0;
 636         TftpNumchars = 0;
 637 #endif
 638
 639         TftpSend ();
 640 }
 641
 642 #ifdef CONFIG_MCAST_TFTP
 643 /* Credits: atftp project.
 644  */
 645
 646 /* pick up BcastAddr, Port, and whether I am [now] the master-client. *
 647  * Frame:
 648  *    +-------+-----------+---+-------~~-------+---+
 649  *    |  opc  | multicast | 0 | addr, port, mc | 0 |
 650  *    +-------+-----------+---+-------~~-------+---+
 651  * The multicast addr/port becomes what I listen to, and if 'mc' is '1' then
 652  * I am the new master-client so must send ACKs to DataBlocks.  If I am not
 653  * master-client, I'm a passive client, gathering what DataBlocks I may and
 654  * making note of which ones I got in my bitmask.
 655  * In theory, I never go from master->passive..
 656  * .. this comes in with pkt already pointing just past opc
 657  */
 658 static void parse_multicast_oack(char *pkt, int len)
 659 {
 660  int i;
 661  IPaddr_t addr;
 662  char *mc_adr, *port,  *mc;
 663
 664         mc_adr=port=mc=NULL;
 665         /* march along looking for 'multicast\0', which has to start at least
 666          * 14 bytes back from the end.
 667          */
 668         for (i=0;i<len-14;i++)
 669                 if (strcmp (pkt+i,"multicast") == 0)
 670                         break;
 671         if (i >= (len-14)) /* non-Multicast OACK, ign. */
 672                 return;
 673
 674         i+=10; /* strlen multicast */
 675         mc_adr = pkt+i;
 676         for (;i<len;i++) {
 677                 if (*(pkt+i) == ',') {
 678                         *(pkt+i) = '\0';
 679                         if (port) {
 680                                 mc = pkt+i+1;
 681                                 break;
 682                         } else {
 683                                 port = pkt+i+1;
 684                         }
 685                 }
 686         }
 687         if (!port || !mc_adr || !mc ) return;
 688         if (Multicast && MasterClient) {
 689                 printf ("I got a OACK as master Client, WRONG!\n");
 690                 return;
 691         }
 692         /* ..I now accept packets destined for this MCAST addr, port */
 693         if (!Multicast) {
 694                 if (Bitmap) {
 695                         printf ("Internal failure! no mcast.\n");
 696                         free(Bitmap);
 697                         Bitmap=NULL;
 698                         ProhibitMcast=1;
 699                         return ;
 700                 }
 701                 /* I malloc instead of pre-declare; so that if the file ends
 702                  * up being too big for this bitmap I can retry
 703                  */
 704                 if (!(Bitmap = malloc (Mapsize))) {
 705                         printf ("No Bitmap, no multicast. Sorry.\n");
 706                         ProhibitMcast=1;
 707                         return;
 708                 }
 709                 memset (Bitmap,0,Mapsize);
 710                 PrevBitmapHole = 0;
 711                 Multicast = 1;
 712         }
 713         addr = string_to_ip(mc_adr);
 714         if (Mcast_addr != addr) {
 715                 if (Mcast_addr)
 716                         eth_mcast_join(Mcast_addr, 0);
 717                 if (eth_mcast_join(Mcast_addr=addr, 1)) {
 718                         printf ("Fail to set mcast, revert to TFTP\n");
 719                         ProhibitMcast=1;
 720                         mcast_cleanup();
 721                         NetStartAgain();
 722                 }
 723         }
 724         MasterClient = (unsigned char)simple_strtoul((char *)mc,NULL,10);
 725         Mcast_port = (unsigned short)simple_strtoul(port,NULL,10);
 726         printf ("Multicast: %s:%d [%d]\n", mc_adr, Mcast_port, MasterClient);
 727         return;
 728 }
 729
 730 #endif /* Multicast TFTP */