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, unsigned src, unsigned len) 282 { 283 ushort proto; 284 ushort *s; 285 int i; 286 287 if (dest != TftpOurPort) { 288 #ifdef CONFIG_MCAST_TFTP 289 if (Multicast 290 && (!Mcast_port || (dest != Mcast_port))) 291 #endif 292 return; 293 } 294 if (TftpState != STATE_RRQ && src != TftpServerPort) { 295 return; 296 } 297 298 if (len < 2) { 299 return; 300 } 301 len -= 2; 302 /* warning: don't use increment (++) in ntohs() macros!! */ 303 s = (ushort *)pkt; 304 proto = *s++; 305 pkt = (uchar *)s; 306 switch (ntohs(proto)) { 307 308 case TFTP_RRQ: 309 case TFTP_WRQ: 310 case TFTP_ACK: 311 break; 312 default: 313 break; 314 315 case TFTP_OACK: 316 debug("Got OACK: %s %s\n", 317 pkt, 318 pkt + strlen((char *)pkt) + 1); 319 TftpState = STATE_OACK; 320 TftpServerPort = src; 321 /* 322 * Check for 'blksize' option. 323 * Careful: "i" is signed, "len" is unsigned, thus 324 * something like "len-8" may give a *huge* number 325 */ 326 for (i=0; i+8<len; i++) { 327 if (strcmp ((char*)pkt+i,"blksize") == 0) { 328 TftpBlkSize = (unsigned short) 329 simple_strtoul((char*)pkt+i+8,NULL,10); 330 debug("Blocksize ack: %s, %d\n", 331 (char*)pkt+i+8,TftpBlkSize); 332 } 333 #ifdef CONFIG_TFTP_TSIZE 334 if (strcmp ((char*)pkt+i,"tsize") == 0) { 335 TftpTsize = simple_strtoul((char*)pkt+i+6,NULL,10); 336 debug("size = %s, %d\n", 337 (char*)pkt+i+6, TftpTsize); 338 } 339 #endif 340 } 341 #ifdef CONFIG_MCAST_TFTP 342 parse_multicast_oack((char *)pkt,len-1); 343 if ((Multicast) && (!MasterClient)) 344 TftpState = STATE_DATA; /* passive.. */ 345 else 346 #endif 347 TftpSend (); /* Send ACK */ 348 break; 349 case TFTP_DATA: 350 if (len < 2) 351 return; 352 len -= 2; 353 TftpBlock = ntohs(*(ushort *)pkt); 354 355 /* 356 * RFC1350 specifies that the first data packet will 357 * have sequence number 1. If we receive a sequence 358 * number of 0 this means that there was a wrap 359 * around of the (16 bit) counter. 360 */ 361 if (TftpBlock == 0) { 362 TftpBlockWrap++; 363 TftpBlockWrapOffset += TftpBlkSize * TFTP_SEQUENCE_SIZE; 364 printf ("\n\t %lu MB received\n\t ", TftpBlockWrapOffset>>20); 365 } 366 #ifdef CONFIG_TFTP_TSIZE 367 else if (TftpTsize) { 368 while (TftpNumchars < NetBootFileXferSize * 50 / TftpTsize) { 369 putc('#'); 370 TftpNumchars++; 371 } 372 } 373 #endif 374 else { 375 if (((TftpBlock - 1) % 10) == 0) { 376 putc ('#'); 377 } else if ((TftpBlock % (10 * HASHES_PER_LINE)) == 0) { 378 puts ("\n\t "); 379 } 380 } 381 382 if (TftpState == STATE_RRQ) 383 debug("Server did not acknowledge timeout option!\n"); 384 385 if (TftpState == STATE_RRQ || TftpState == STATE_OACK) { 386 /* first block received */ 387 TftpState = STATE_DATA; 388 TftpServerPort = src; 389 TftpLastBlock = 0; 390 TftpBlockWrap = 0; 391 TftpBlockWrapOffset = 0; 392 393 #ifdef CONFIG_MCAST_TFTP 394 if (Multicast) { /* start!=1 common if mcast */ 395 TftpLastBlock = TftpBlock - 1; 396 } else 397 #endif 398 if (TftpBlock != 1) { /* Assertion */ 399 printf ("\nTFTP error: " 400 "First block is not block 1 (%ld)\n" 401 "Starting again\n\n", 402 TftpBlock); 403 NetStartAgain (); 404 break; 405 } 406 } 407 408 if (TftpBlock == TftpLastBlock) { 409 /* 410 * Same block again; ignore it. 411 */ 412 break; 413 } 414 415 TftpLastBlock = TftpBlock; 416 TftpTimeoutCountMax = TIMEOUT_COUNT; 417 NetSetTimeout (TftpTimeoutMSecs, TftpTimeout); 418 419 store_block (TftpBlock - 1, pkt + 2, len); 420 421 /* 422 * Acknoledge the block just received, which will prompt 423 * the server for the next one. 424 */ 425 #ifdef CONFIG_MCAST_TFTP 426 /* if I am the MasterClient, actively calculate what my next 427 * needed block is; else I'm passive; not ACKING 428 */ 429 if (Multicast) { 430 if (len < TftpBlkSize) { 431 TftpEndingBlock = TftpBlock; 432 } else if (MasterClient) { 433 TftpBlock = PrevBitmapHole = 434 ext2_find_next_zero_bit( 435 Bitmap, 436 (Mapsize*8), 437 PrevBitmapHole); 438 if (TftpBlock > ((Mapsize*8) - 1)) { 439 printf ("tftpfile too big\n"); 440 /* try to double it and retry */ 441 Mapsize<<=1; 442 mcast_cleanup(); 443 NetStartAgain (); 444 return; 445 } 446 TftpLastBlock = TftpBlock; 447 } 448 } 449 #endif 450 TftpSend (); 451 452 #ifdef CONFIG_MCAST_TFTP 453 if (Multicast) { 454 if (MasterClient && (TftpBlock >= TftpEndingBlock)) { 455 puts ("\nMulticast tftp done\n"); 456 mcast_cleanup(); 457 NetState = NETLOOP_SUCCESS; 458 } 459 } 460 else 461 #endif 462 if (len < TftpBlkSize) { 463 /* 464 * We received the whole thing. Try to 465 * run it. 466 */ 467 #ifdef CONFIG_TFTP_TSIZE 468 /* Print out the hash marks for the last packet received */ 469 while (TftpTsize && TftpNumchars < 49) { 470 putc('#'); 471 TftpNumchars++; 472 } 473 #endif 474 puts ("\ndone\n"); 475 NetState = NETLOOP_SUCCESS; 476 } 477 break; 478 479 case TFTP_ERROR: 480 printf ("\nTFTP error: '%s' (%d)\n", 481 pkt + 2, ntohs(*(ushort *)pkt)); 482 483 switch (ntohs(*(ushort *)pkt)) { 484 case TFTP_ERR_FILE_NOT_FOUND: 485 case TFTP_ERR_ACCESS_DENIED: 486 puts("Not retrying...\n"); 487 eth_halt(); 488 NetState = NETLOOP_FAIL; 489 break; 490 case TFTP_ERR_UNDEFINED: 491 case TFTP_ERR_DISK_FULL: 492 case TFTP_ERR_UNEXPECTED_OPCODE: 493 case TFTP_ERR_UNKNOWN_TRANSFER_ID: 494 case TFTP_ERR_FILE_ALREADY_EXISTS: 495 default: 496 puts("Starting again\n\n"); 497 #ifdef CONFIG_MCAST_TFTP 498 mcast_cleanup(); 499 #endif 500 NetStartAgain(); 501 break; 502 } 503 break; 504 } 505 } 506 507 508 static void 509 TftpTimeout (void) 510 { 511 if (++TftpTimeoutCount > TftpTimeoutCountMax) { 512 puts ("\nRetry count exceeded; starting again\n"); 513 #ifdef CONFIG_MCAST_TFTP 514 mcast_cleanup(); 515 #endif 516 NetStartAgain (); 517 } else { 518 puts ("T "); 519 NetSetTimeout (TftpTimeoutMSecs, TftpTimeout); 520 TftpSend (); 521 } 522 } 523 524 525 void 526 TftpStart (void) 527 { 528 char *ep; /* Environment pointer */ 529 530 /* 531 * Allow the user to choose TFTP blocksize and timeout. 532 * TFTP protocol has a minimal timeout of 1 second. 533 */ 534 if ((ep = getenv("tftpblocksize")) != NULL) 535 TftpBlkSizeOption = simple_strtol(ep, NULL, 10); 536 537 if ((ep = getenv("tftptimeout")) != NULL) 538 TftpTimeoutMSecs = simple_strtol(ep, NULL, 10); 539 540 if (TftpTimeoutMSecs < 1000) { 541 printf("TFTP timeout (%ld ms) too low, " 542 "set minimum = 1000 ms\n", 543 TftpTimeoutMSecs); 544 TftpTimeoutMSecs = 1000; 545 } 546 547 debug("TFTP blocksize = %i, timeout = %ld ms\n", 548 TftpBlkSizeOption, TftpTimeoutMSecs); 549 550 TftpServerIP = NetServerIP; 551 if (BootFile[0] == '\0') { 552 sprintf(default_filename, "%02lX%02lX%02lX%02lX.img", 553 NetOurIP & 0xFF, 554 (NetOurIP >> 8) & 0xFF, 555 (NetOurIP >> 16) & 0xFF, 556 (NetOurIP >> 24) & 0xFF ); 557 558 strncpy(tftp_filename, default_filename, MAX_LEN); 559 tftp_filename[MAX_LEN-1] = 0; 560 561 printf ("*** Warning: no boot file name; using '%s'\n", 562 tftp_filename); 563 } else { 564 char *p = strchr (BootFile, ':'); 565 566 if (p == NULL) { 567 strncpy(tftp_filename, BootFile, MAX_LEN); 568 tftp_filename[MAX_LEN-1] = 0; 569 } else { 570 TftpServerIP = string_to_ip (BootFile); 571 strncpy(tftp_filename, p + 1, MAX_LEN); 572 tftp_filename[MAX_LEN-1] = 0; 573 } 574 } 575 576 #if defined(CONFIG_NET_MULTI) 577 printf ("Using %s device\n", eth_get_name()); 578 #endif 579 printf("TFTP from server %pI4" 580 "; our IP address is %pI4", &TftpServerIP, &NetOurIP); 581 582 /* Check if we need to send across this subnet */ 583 if (NetOurGatewayIP && NetOurSubnetMask) { 584 IPaddr_t OurNet = NetOurIP & NetOurSubnetMask; 585 IPaddr_t ServerNet = TftpServerIP & NetOurSubnetMask; 586 587 if (OurNet != ServerNet) 588 printf("; sending through gateway %pI4", &NetOurGatewayIP); 589 } 590 putc ('\n'); 591 592 printf ("Filename '%s'.", tftp_filename); 593 594 if (NetBootFileSize) { 595 printf (" Size is 0x%x Bytes = ", NetBootFileSize<<9); 596 print_size (NetBootFileSize<<9, ""); 597 } 598 599 putc ('\n'); 600 601 printf ("Load address: 0x%lx\n", load_addr); 602 603 puts ("Loading: *\b"); 604 605 TftpTimeoutCountMax = TftpRRQTimeoutCountMax; 606 607 NetSetTimeout (TftpTimeoutMSecs, TftpTimeout); 608 NetSetHandler (TftpHandler); 609 610 TftpServerPort = WELL_KNOWN_PORT; 611 TftpTimeoutCount = 0; 612 TftpState = STATE_RRQ; 613 /* Use a pseudo-random port unless a specific port is set */ 614 TftpOurPort = 1024 + (get_timer(0) % 3072); 615 616 #ifdef CONFIG_TFTP_PORT 617 if ((ep = getenv("tftpdstp")) != NULL) { 618 TftpServerPort = simple_strtol(ep, NULL, 10); 619 } 620 if ((ep = getenv("tftpsrcp")) != NULL) { 621 TftpOurPort= simple_strtol(ep, NULL, 10); 622 } 623 #endif 624 TftpBlock = 0; 625 626 /* zero out server ether in case the server ip has changed */ 627 memset(NetServerEther, 0, 6); 628 /* Revert TftpBlkSize to dflt */ 629 TftpBlkSize = TFTP_BLOCK_SIZE; 630 #ifdef CONFIG_MCAST_TFTP 631 mcast_cleanup(); 632 #endif 633 #ifdef CONFIG_TFTP_TSIZE 634 TftpTsize = 0; 635 TftpNumchars = 0; 636 #endif 637 638 TftpSend (); 639 } 640 641 #ifdef CONFIG_MCAST_TFTP 642 /* Credits: atftp project. 643 */ 644 645 /* pick up BcastAddr, Port, and whether I am [now] the master-client. * 646 * Frame: 647 * +-------+-----------+---+-------~~-------+---+ 648 * | opc | multicast | 0 | addr, port, mc | 0 | 649 * +-------+-----------+---+-------~~-------+---+ 650 * The multicast addr/port becomes what I listen to, and if 'mc' is '1' then 651 * I am the new master-client so must send ACKs to DataBlocks. If I am not 652 * master-client, I'm a passive client, gathering what DataBlocks I may and 653 * making note of which ones I got in my bitmask. 654 * In theory, I never go from master->passive.. 655 * .. this comes in with pkt already pointing just past opc 656 */ 657 static void parse_multicast_oack(char *pkt, int len) 658 { 659 int i; 660 IPaddr_t addr; 661 char *mc_adr, *port, *mc; 662 663 mc_adr=port=mc=NULL; 664 /* march along looking for 'multicast\0', which has to start at least 665 * 14 bytes back from the end. 666 */ 667 for (i=0;i<len-14;i++) 668 if (strcmp (pkt+i,"multicast") == 0) 669 break; 670 if (i >= (len-14)) /* non-Multicast OACK, ign. */ 671 return; 672 673 i+=10; /* strlen multicast */ 674 mc_adr = pkt+i; 675 for (;i<len;i++) { 676 if (*(pkt+i) == ',') { 677 *(pkt+i) = '\0'; 678 if (port) { 679 mc = pkt+i+1; 680 break; 681 } else { 682 port = pkt+i+1; 683 } 684 } 685 } 686 if (!port || !mc_adr || !mc ) return; 687 if (Multicast && MasterClient) { 688 printf ("I got a OACK as master Client, WRONG!\n"); 689 return; 690 } 691 /* ..I now accept packets destined for this MCAST addr, port */ 692 if (!Multicast) { 693 if (Bitmap) { 694 printf ("Internal failure! no mcast.\n"); 695 free(Bitmap); 696 Bitmap=NULL; 697 ProhibitMcast=1; 698 return ; 699 } 700 /* I malloc instead of pre-declare; so that if the file ends 701 * up being too big for this bitmap I can retry 702 */ 703 if (!(Bitmap = malloc (Mapsize))) { 704 printf ("No Bitmap, no multicast. Sorry.\n"); 705 ProhibitMcast=1; 706 return; 707 } 708 memset (Bitmap,0,Mapsize); 709 PrevBitmapHole = 0; 710 Multicast = 1; 711 } 712 addr = string_to_ip(mc_adr); 713 if (Mcast_addr != addr) { 714 if (Mcast_addr) 715 eth_mcast_join(Mcast_addr, 0); 716 if (eth_mcast_join(Mcast_addr=addr, 1)) { 717 printf ("Fail to set mcast, revert to TFTP\n"); 718 ProhibitMcast=1; 719 mcast_cleanup(); 720 NetStartAgain(); 721 } 722 } 723 MasterClient = (unsigned char)simple_strtoul((char *)mc,NULL,10); 724 Mcast_port = (unsigned short)simple_strtoul(port,NULL,10); 725 printf ("Multicast: %s:%d [%d]\n", mc_adr, Mcast_port, MasterClient); 726 return; 727 } 728 729 #endif /* Multicast TFTP */ 730