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