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