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