xref: /openbmc/u-boot/net/tftp.c (revision cdb74977)
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