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 short TFTP_quit_on_error = 0;
36
37 /*
38 * These globals govern the timeout behavior when attempting a connection to a
39 * TFTP server. TftpRRQTimeoutMSecs specifies the number of milliseconds to
40 * wait for the server to respond to initial connection. Second global,
41 * TftpRRQTimeoutCountMax, gives the number of such connection retries.
42 * TftpRRQTimeoutCountMax must be non-negative and TftpRRQTimeoutMSecs must be
43 * positive. The globals are meant to be set (and restored) by code needing
44 * non-standard timeout behavior when initiating a TFTP transfer.
45 */
46 ulong TftpRRQTimeoutMSecs = TIMEOUT;
47 int TftpRRQTimeoutCountMax = TIMEOUT_COUNT;
48
49 enum {
50 TFTP_ERR_UNDEFINED = 0,
51 TFTP_ERR_FILE_NOT_FOUND = 1,
52 TFTP_ERR_ACCESS_DENIED = 2,
53 TFTP_ERR_DISK_FULL = 3,
54 TFTP_ERR_UNEXPECTED_OPCODE = 4,
55 TFTP_ERR_UNKNOWN_TRANSFER_ID = 5,
56 TFTP_ERR_FILE_ALREADY_EXISTS = 6,
57 };
58
59 static IPaddr_t TftpServerIP;
60 static int TftpServerPort; /* The UDP port at their end */
61 static int TftpOurPort; /* The UDP port at our end */
62 static int TftpTimeoutCount;
63 static ulong TftpBlock; /* packet sequence number */
64 static ulong TftpLastBlock; /* last packet sequence number received */
65 static ulong TftpBlockWrap; /* count of sequence number wraparounds */
66 static ulong TftpBlockWrapOffset; /* memory offset due to wrapping */
67 static int TftpState;
68 #ifdef CONFIG_TFTP_TSIZE
69 static int TftpTsize; /* The file size reported by the server */
70 static short TftpNumchars; /* The number of hashes we printed */
71 #endif
72
73 #define STATE_RRQ 1
74 #define STATE_DATA 2
75 #define STATE_TOO_LARGE 3
76 #define STATE_BAD_MAGIC 4
77 #define STATE_OACK 5
78
79 #define TFTP_BLOCK_SIZE 512 /* default TFTP block size */
80 #define TFTP_SEQUENCE_SIZE ((ulong)(1<<16)) /* sequence number is 16 bit */
81
82 #define DEFAULT_NAME_LEN (8 + 4 + 1)
83 static char default_filename[DEFAULT_NAME_LEN];
84
85 #ifndef CONFIG_TFTP_FILE_NAME_MAX_LEN
86 #define MAX_LEN 128
87 #else
88 #define MAX_LEN CONFIG_TFTP_FILE_NAME_MAX_LEN
89 #endif
90
91 static char tftp_filename[MAX_LEN];
92
93 #ifdef CONFIG_SYS_DIRECT_FLASH_TFTP
94 extern flash_info_t flash_info[];
95 #endif
96
97 /* 512 is poor choice for ethernet, MTU is typically 1500.
98 * Minus eth.hdrs thats 1468. Can get 2x better throughput with
99 * almost-MTU block sizes. At least try... fall back to 512 if need be.
100 * (but those using CONFIG_IP_DEFRAG may want to set a larger block in cfg file)
101 */
102 #ifdef CONFIG_TFTP_BLOCKSIZE
103 #define TFTP_MTU_BLOCKSIZE CONFIG_TFTP_BLOCKSIZE
104 #else
105 #define TFTP_MTU_BLOCKSIZE 1468
106 #endif
107
108 static unsigned short TftpBlkSize=TFTP_BLOCK_SIZE;
109 static unsigned short TftpBlkSizeOption=TFTP_MTU_BLOCKSIZE;
110
111 #ifdef CONFIG_MCAST_TFTP
112 #include <malloc.h>
113 #define MTFTP_BITMAPSIZE 0x1000
114 static unsigned *Bitmap;
115 static int PrevBitmapHole,Mapsize=MTFTP_BITMAPSIZE;
116 static uchar ProhibitMcast=0, MasterClient=0;
117 static uchar Multicast=0;
118 extern IPaddr_t Mcast_addr;
119 static int Mcast_port;
120 static ulong TftpEndingBlock; /* can get 'last' block before done..*/
121
122 static void parse_multicast_oack(char *pkt,int len);
123
124 static void
mcast_cleanup(void)125 mcast_cleanup(void)
126 {
127 if (Mcast_addr) eth_mcast_join(Mcast_addr, 0);
128 if (Bitmap) free(Bitmap);
129 Bitmap=NULL;
130 Mcast_addr = Multicast = Mcast_port = 0;
131 TftpEndingBlock = -1;
132 }
133
134 #endif /* CONFIG_MCAST_TFTP */
135
136 static __inline__ void
store_block(unsigned block,uchar * src,unsigned len)137 store_block (unsigned block, uchar * src, unsigned len)
138 {
139 ulong offset = block * TftpBlkSize + TftpBlockWrapOffset;
140 ulong newsize = offset + len;
141 #ifdef CONFIG_SYS_DIRECT_FLASH_TFTP
142 int i, rc = 0;
143
144 for (i=0; i<CONFIG_SYS_MAX_FLASH_BANKS; i++) {
145 /* start address in flash? */
146 if (flash_info[i].flash_id == FLASH_UNKNOWN)
147 continue;
148 if (load_addr + offset >= flash_info[i].start[0]) {
149 rc = 1;
150 break;
151 }
152 }
153
154 if (rc) { /* Flash is destination for this packet */
155 rc = flash_write ((char *)src, (ulong)(load_addr+offset), len);
156 if (rc) {
157 flash_perror (rc);
158 NetState = NETLOOP_FAIL;
159 return;
160 }
161 }
162 else
163 #endif /* CONFIG_SYS_DIRECT_FLASH_TFTP */
164 {
165 (void)memcpy((void *)(load_addr + offset), src, len);
166 }
167 #ifdef CONFIG_MCAST_TFTP
168 if (Multicast)
169 ext2_set_bit(block, Bitmap);
170 #endif
171
172 if (NetBootFileXferSize < newsize)
173 NetBootFileXferSize = newsize;
174 }
175
176 static void TftpSend (void);
177 static void TftpTimeout (void);
178
179 /**********************************************************************/
180
181 static void
TftpSend(void)182 TftpSend (void)
183 {
184 volatile uchar * pkt;
185 volatile uchar * xp;
186 int len = 0;
187 volatile ushort *s;
188
189 #ifdef CONFIG_MCAST_TFTP
190 /* Multicast TFTP.. non-MasterClients do not ACK data. */
191 if (Multicast
192 && (TftpState == STATE_DATA)
193 && (MasterClient == 0))
194 return;
195 #endif
196 /*
197 * We will always be sending some sort of packet, so
198 * cobble together the packet headers now.
199 */
200 pkt = NetTxPacket + NetEthHdrSize() + IP_HDR_SIZE;
201
202 switch (TftpState) {
203
204 case STATE_RRQ:
205 xp = pkt;
206 s = (ushort *)pkt;
207 *s++ = htons(TFTP_RRQ);
208 pkt = (uchar *)s;
209 strcpy ((char *)pkt, tftp_filename);
210 pkt += strlen(tftp_filename) + 1;
211 strcpy ((char *)pkt, "octet");
212 pkt += 5 /*strlen("octet")*/ + 1;
213 strcpy ((char *)pkt, "timeout");
214 pkt += 7 /*strlen("timeout")*/ + 1;
215 sprintf((char *)pkt, "%lu", TftpTimeoutMSecs / 1000);
216 debug("send option \"timeout %s\"\n", (char *)pkt);
217 pkt += strlen((char *)pkt) + 1;
218 #ifdef CONFIG_TFTP_TSIZE
219 memcpy((char *)pkt, "tsize\0000\0", 8);
220 pkt += 8;
221 #endif
222 /* try for more effic. blk size */
223 pkt += sprintf((char *)pkt,"blksize%c%d%c",
224 0,TftpBlkSizeOption,0);
225 #ifdef CONFIG_MCAST_TFTP
226 /* Check all preconditions before even trying the option */
227 if (!ProhibitMcast
228 && (Bitmap=malloc(Mapsize))
229 && eth_get_dev()->mcast) {
230 free(Bitmap);
231 Bitmap=NULL;
232 pkt += sprintf((char *)pkt,"multicast%c%c",0,0);
233 }
234 #endif /* CONFIG_MCAST_TFTP */
235 len = pkt - xp;
236 break;
237
238 case STATE_OACK:
239 #ifdef CONFIG_MCAST_TFTP
240 /* My turn! Start at where I need blocks I missed.*/
241 if (Multicast)
242 TftpBlock=ext2_find_next_zero_bit(Bitmap,(Mapsize*8),0);
243 /*..falling..*/
244 #endif
245 case STATE_DATA:
246 xp = pkt;
247 s = (ushort *)pkt;
248 *s++ = htons(TFTP_ACK);
249 *s++ = htons(TftpBlock);
250 pkt = (uchar *)s;
251 len = pkt - xp;
252 break;
253
254 case STATE_TOO_LARGE:
255 xp = pkt;
256 s = (ushort *)pkt;
257 *s++ = htons(TFTP_ERROR);
258 *s++ = htons(3);
259 pkt = (uchar *)s;
260 strcpy ((char *)pkt, "File too large");
261 pkt += 14 /*strlen("File too large")*/ + 1;
262 len = pkt - xp;
263 break;
264
265 case STATE_BAD_MAGIC:
266 xp = pkt;
267 s = (ushort *)pkt;
268 *s++ = htons(TFTP_ERROR);
269 *s++ = htons(2);
270 pkt = (uchar *)s;
271 strcpy ((char *)pkt, "File has bad magic");
272 pkt += 18 /*strlen("File has bad magic")*/ + 1;
273 len = pkt - xp;
274 break;
275 }
276
277 NetSendUDPPacket(NetServerEther, TftpServerIP, TftpServerPort, TftpOurPort, len);
278 }
279
280
281 static void
TftpHandler(uchar * pkt,unsigned dest,unsigned src,unsigned len)282 TftpHandler (uchar * pkt, unsigned dest, unsigned src, 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
TftpTimeout(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
TftpStart(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 */
parse_multicast_oack(char * pkt,int len)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