xref: /openbmc/u-boot/net/tftp.c (revision 1f92c074cbb53debc7ad31073dc7895d8a2aa44e)
1  /*
2   * Copyright 1994, 1995, 2000 Neil Russell.
3   * (See License)
4   * Copyright 2000, 2001 DENX Software Engineering, Wolfgang Denk, wd@denx.de
5   * Copyright 2011 Comelit Group SpA,
6   *                Luca Ceresoli <luca.ceresoli@comelit.it>
7   */
8  
9  #include <common.h>
10  #include <command.h>
11  #include <efi_loader.h>
12  #include <mapmem.h>
13  #include <net.h>
14  #include <net/tftp.h>
15  #include "bootp.h"
16  #ifdef CONFIG_SYS_DIRECT_FLASH_TFTP
17  #include <flash.h>
18  #endif
19  
20  DECLARE_GLOBAL_DATA_PTR;
21  
22  /* Well known TFTP port # */
23  #define WELL_KNOWN_PORT	69
24  /* Millisecs to timeout for lost pkt */
25  #define TIMEOUT		5000UL
26  #ifndef	CONFIG_NET_RETRY_COUNT
27  /* # of timeouts before giving up */
28  # define TIMEOUT_COUNT	10
29  #else
30  # define TIMEOUT_COUNT  (CONFIG_NET_RETRY_COUNT * 2)
31  #endif
32  /* Number of "loading" hashes per line (for checking the image size) */
33  #define HASHES_PER_LINE	65
34  
35  /*
36   *	TFTP operations.
37   */
38  #define TFTP_RRQ	1
39  #define TFTP_WRQ	2
40  #define TFTP_DATA	3
41  #define TFTP_ACK	4
42  #define TFTP_ERROR	5
43  #define TFTP_OACK	6
44  
45  static ulong timeout_ms = TIMEOUT;
46  static int timeout_count_max = TIMEOUT_COUNT;
47  static ulong time_start;   /* Record time we started tftp */
48  
49  /*
50   * These globals govern the timeout behavior when attempting a connection to a
51   * TFTP server. tftp_timeout_ms specifies the number of milliseconds to
52   * wait for the server to respond to initial connection. Second global,
53   * tftp_timeout_count_max, gives the number of such connection retries.
54   * tftp_timeout_count_max must be non-negative and tftp_timeout_ms must be
55   * positive. The globals are meant to be set (and restored) by code needing
56   * non-standard timeout behavior when initiating a TFTP transfer.
57   */
58  ulong tftp_timeout_ms = TIMEOUT;
59  int tftp_timeout_count_max = TIMEOUT_COUNT;
60  
61  enum {
62  	TFTP_ERR_UNDEFINED           = 0,
63  	TFTP_ERR_FILE_NOT_FOUND      = 1,
64  	TFTP_ERR_ACCESS_DENIED       = 2,
65  	TFTP_ERR_DISK_FULL           = 3,
66  	TFTP_ERR_UNEXPECTED_OPCODE   = 4,
67  	TFTP_ERR_UNKNOWN_TRANSFER_ID  = 5,
68  	TFTP_ERR_FILE_ALREADY_EXISTS = 6,
69  };
70  
71  static struct in_addr tftp_remote_ip;
72  /* The UDP port at their end */
73  static int	tftp_remote_port;
74  /* The UDP port at our end */
75  static int	tftp_our_port;
76  static int	timeout_count;
77  /* packet sequence number */
78  static ulong	tftp_cur_block;
79  /* last packet sequence number received */
80  static ulong	tftp_prev_block;
81  /* count of sequence number wraparounds */
82  static ulong	tftp_block_wrap;
83  /* memory offset due to wrapping */
84  static ulong	tftp_block_wrap_offset;
85  static int	tftp_state;
86  static ulong	tftp_load_addr;
87  #ifdef CONFIG_LMB
88  static ulong	tftp_load_size;
89  #endif
90  #ifdef CONFIG_TFTP_TSIZE
91  /* The file size reported by the server */
92  static int	tftp_tsize;
93  /* The number of hashes we printed */
94  static short	tftp_tsize_num_hash;
95  #endif
96  #ifdef CONFIG_CMD_TFTPPUT
97  /* 1 if writing, else 0 */
98  static int	tftp_put_active;
99  /* 1 if we have sent the last block */
100  static int	tftp_put_final_block_sent;
101  #else
102  #define tftp_put_active	0
103  #endif
104  
105  #define STATE_SEND_RRQ	1
106  #define STATE_DATA	2
107  #define STATE_TOO_LARGE	3
108  #define STATE_BAD_MAGIC	4
109  #define STATE_OACK	5
110  #define STATE_RECV_WRQ	6
111  #define STATE_SEND_WRQ	7
112  
113  /* default TFTP block size */
114  #define TFTP_BLOCK_SIZE		512
115  /* sequence number is 16 bit */
116  #define TFTP_SEQUENCE_SIZE	((ulong)(1<<16))
117  
118  #define DEFAULT_NAME_LEN	(8 + 4 + 1)
119  static char default_filename[DEFAULT_NAME_LEN];
120  
121  #ifndef CONFIG_TFTP_FILE_NAME_MAX_LEN
122  #define MAX_LEN 128
123  #else
124  #define MAX_LEN CONFIG_TFTP_FILE_NAME_MAX_LEN
125  #endif
126  
127  static char tftp_filename[MAX_LEN];
128  
129  /* 512 is poor choice for ethernet, MTU is typically 1500.
130   * Minus eth.hdrs thats 1468.  Can get 2x better throughput with
131   * almost-MTU block sizes.  At least try... fall back to 512 if need be.
132   * (but those using CONFIG_IP_DEFRAG may want to set a larger block in cfg file)
133   */
134  #ifdef CONFIG_TFTP_BLOCKSIZE
135  #define TFTP_MTU_BLOCKSIZE CONFIG_TFTP_BLOCKSIZE
136  #else
137  #define TFTP_MTU_BLOCKSIZE 1468
138  #endif
139  
140  static unsigned short tftp_block_size = TFTP_BLOCK_SIZE;
141  static unsigned short tftp_block_size_option = TFTP_MTU_BLOCKSIZE;
142  
143  static inline int store_block(int block, uchar *src, unsigned int len)
144  {
145  	ulong offset = block * tftp_block_size + tftp_block_wrap_offset;
146  	ulong newsize = offset + len;
147  	ulong store_addr = tftp_load_addr + offset;
148  #ifdef CONFIG_SYS_DIRECT_FLASH_TFTP
149  	int i, rc = 0;
150  
151  	for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {
152  		/* start address in flash? */
153  		if (flash_info[i].flash_id == FLASH_UNKNOWN)
154  			continue;
155  		if (store_addr >= flash_info[i].start[0]) {
156  			rc = 1;
157  			break;
158  		}
159  	}
160  
161  	if (rc) { /* Flash is destination for this packet */
162  		rc = flash_write((char *)src, store_addr, len);
163  		if (rc) {
164  			flash_perror(rc);
165  			return rc;
166  		}
167  	} else
168  #endif /* CONFIG_SYS_DIRECT_FLASH_TFTP */
169  	{
170  		void *ptr;
171  
172  #ifdef CONFIG_LMB
173  		if (store_addr < tftp_load_addr ||
174  		    store_addr + len > tftp_load_addr + tftp_load_size) {
175  			puts("\nTFTP error: ");
176  			puts("trying to overwrite reserved memory...\n");
177  			return -1;
178  		}
179  #endif
180  		ptr = map_sysmem(store_addr, len);
181  		memcpy(ptr, src, len);
182  		unmap_sysmem(ptr);
183  	}
184  
185  	if (net_boot_file_size < newsize)
186  		net_boot_file_size = newsize;
187  
188  	return 0;
189  }
190  
191  /* Clear our state ready for a new transfer */
192  static void new_transfer(void)
193  {
194  	tftp_prev_block = 0;
195  	tftp_block_wrap = 0;
196  	tftp_block_wrap_offset = 0;
197  #ifdef CONFIG_CMD_TFTPPUT
198  	tftp_put_final_block_sent = 0;
199  #endif
200  }
201  
202  #ifdef CONFIG_CMD_TFTPPUT
203  /**
204   * Load the next block from memory to be sent over tftp.
205   *
206   * @param block	Block number to send
207   * @param dst	Destination buffer for data
208   * @param len	Number of bytes in block (this one and every other)
209   * @return number of bytes loaded
210   */
211  static int load_block(unsigned block, uchar *dst, unsigned len)
212  {
213  	/* We may want to get the final block from the previous set */
214  	ulong offset = ((int)block - 1) * len + tftp_block_wrap_offset;
215  	ulong tosend = len;
216  
217  	tosend = min(net_boot_file_size - offset, tosend);
218  	(void)memcpy(dst, (void *)(save_addr + offset), tosend);
219  	debug("%s: block=%d, offset=%ld, len=%d, tosend=%ld\n", __func__,
220  	      block, offset, len, tosend);
221  	return tosend;
222  }
223  #endif
224  
225  static void tftp_send(void);
226  static void tftp_timeout_handler(void);
227  
228  /**********************************************************************/
229  
230  static void show_block_marker(void)
231  {
232  #ifdef CONFIG_TFTP_TSIZE
233  	if (tftp_tsize) {
234  		ulong pos = tftp_cur_block * tftp_block_size +
235  			tftp_block_wrap_offset;
236  		if (pos > tftp_tsize)
237  			pos = tftp_tsize;
238  
239  		while (tftp_tsize_num_hash < pos * 50 / tftp_tsize) {
240  			putc('#');
241  			tftp_tsize_num_hash++;
242  		}
243  	} else
244  #endif
245  	{
246  		if (((tftp_cur_block - 1) % 10) == 0)
247  			putc('#');
248  		else if ((tftp_cur_block % (10 * HASHES_PER_LINE)) == 0)
249  			puts("\n\t ");
250  	}
251  }
252  
253  /**
254   * restart the current transfer due to an error
255   *
256   * @param msg	Message to print for user
257   */
258  static void restart(const char *msg)
259  {
260  	printf("\n%s; starting again\n", msg);
261  	net_start_again();
262  }
263  
264  /*
265   * Check if the block number has wrapped, and update progress
266   *
267   * TODO: The egregious use of global variables in this file should be tidied.
268   */
269  static void update_block_number(void)
270  {
271  	/*
272  	 * RFC1350 specifies that the first data packet will
273  	 * have sequence number 1. If we receive a sequence
274  	 * number of 0 this means that there was a wrap
275  	 * around of the (16 bit) counter.
276  	 */
277  	if (tftp_cur_block == 0 && tftp_prev_block != 0) {
278  		tftp_block_wrap++;
279  		tftp_block_wrap_offset += tftp_block_size * TFTP_SEQUENCE_SIZE;
280  		timeout_count = 0; /* we've done well, reset the timeout */
281  	} else {
282  		show_block_marker();
283  	}
284  }
285  
286  /* The TFTP get or put is complete */
287  static void tftp_complete(void)
288  {
289  #ifdef CONFIG_TFTP_TSIZE
290  	/* Print hash marks for the last packet received */
291  	while (tftp_tsize && tftp_tsize_num_hash < 49) {
292  		putc('#');
293  		tftp_tsize_num_hash++;
294  	}
295  	puts("  ");
296  	print_size(tftp_tsize, "");
297  #endif
298  	time_start = get_timer(time_start);
299  	if (time_start > 0) {
300  		puts("\n\t ");	/* Line up with "Loading: " */
301  		print_size(net_boot_file_size /
302  			time_start * 1000, "/s");
303  	}
304  	puts("\ndone\n");
305  	net_set_state(NETLOOP_SUCCESS);
306  }
307  
308  static void tftp_send(void)
309  {
310  	uchar *pkt;
311  	uchar *xp;
312  	int len = 0;
313  	ushort *s;
314  
315  	/*
316  	 *	We will always be sending some sort of packet, so
317  	 *	cobble together the packet headers now.
318  	 */
319  	pkt = net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE;
320  
321  	switch (tftp_state) {
322  	case STATE_SEND_RRQ:
323  	case STATE_SEND_WRQ:
324  		xp = pkt;
325  		s = (ushort *)pkt;
326  #ifdef CONFIG_CMD_TFTPPUT
327  		*s++ = htons(tftp_state == STATE_SEND_RRQ ? TFTP_RRQ :
328  			TFTP_WRQ);
329  #else
330  		*s++ = htons(TFTP_RRQ);
331  #endif
332  		pkt = (uchar *)s;
333  		strcpy((char *)pkt, tftp_filename);
334  		pkt += strlen(tftp_filename) + 1;
335  		strcpy((char *)pkt, "octet");
336  		pkt += 5 /*strlen("octet")*/ + 1;
337  		strcpy((char *)pkt, "timeout");
338  		pkt += 7 /*strlen("timeout")*/ + 1;
339  		sprintf((char *)pkt, "%lu", timeout_ms / 1000);
340  		debug("send option \"timeout %s\"\n", (char *)pkt);
341  		pkt += strlen((char *)pkt) + 1;
342  #ifdef CONFIG_TFTP_TSIZE
343  		pkt += sprintf((char *)pkt, "tsize%c%u%c",
344  				0, net_boot_file_size, 0);
345  #endif
346  		/* try for more effic. blk size */
347  		pkt += sprintf((char *)pkt, "blksize%c%d%c",
348  				0, tftp_block_size_option, 0);
349  		len = pkt - xp;
350  		break;
351  
352  	case STATE_OACK:
353  
354  	case STATE_RECV_WRQ:
355  	case STATE_DATA:
356  		xp = pkt;
357  		s = (ushort *)pkt;
358  		s[0] = htons(TFTP_ACK);
359  		s[1] = htons(tftp_cur_block);
360  		pkt = (uchar *)(s + 2);
361  #ifdef CONFIG_CMD_TFTPPUT
362  		if (tftp_put_active) {
363  			int toload = tftp_block_size;
364  			int loaded = load_block(tftp_cur_block, pkt, toload);
365  
366  			s[0] = htons(TFTP_DATA);
367  			pkt += loaded;
368  			tftp_put_final_block_sent = (loaded < toload);
369  		}
370  #endif
371  		len = pkt - xp;
372  		break;
373  
374  	case STATE_TOO_LARGE:
375  		xp = pkt;
376  		s = (ushort *)pkt;
377  		*s++ = htons(TFTP_ERROR);
378  			*s++ = htons(3);
379  
380  		pkt = (uchar *)s;
381  		strcpy((char *)pkt, "File too large");
382  		pkt += 14 /*strlen("File too large")*/ + 1;
383  		len = pkt - xp;
384  		break;
385  
386  	case STATE_BAD_MAGIC:
387  		xp = pkt;
388  		s = (ushort *)pkt;
389  		*s++ = htons(TFTP_ERROR);
390  		*s++ = htons(2);
391  		pkt = (uchar *)s;
392  		strcpy((char *)pkt, "File has bad magic");
393  		pkt += 18 /*strlen("File has bad magic")*/ + 1;
394  		len = pkt - xp;
395  		break;
396  	}
397  
398  	net_send_udp_packet(net_server_ethaddr, tftp_remote_ip,
399  			    tftp_remote_port, tftp_our_port, len);
400  }
401  
402  #ifdef CONFIG_CMD_TFTPPUT
403  static void icmp_handler(unsigned type, unsigned code, unsigned dest,
404  			 struct in_addr sip, unsigned src, uchar *pkt,
405  			 unsigned len)
406  {
407  	if (type == ICMP_NOT_REACH && code == ICMP_NOT_REACH_PORT) {
408  		/* Oh dear the other end has gone away */
409  		restart("TFTP server died");
410  	}
411  }
412  #endif
413  
414  static void tftp_handler(uchar *pkt, unsigned dest, struct in_addr sip,
415  			 unsigned src, unsigned len)
416  {
417  	__be16 proto;
418  	__be16 *s;
419  	int i;
420  
421  	if (dest != tftp_our_port) {
422  			return;
423  	}
424  	if (tftp_state != STATE_SEND_RRQ && src != tftp_remote_port &&
425  	    tftp_state != STATE_RECV_WRQ && tftp_state != STATE_SEND_WRQ)
426  		return;
427  
428  	if (len < 2)
429  		return;
430  	len -= 2;
431  	/* warning: don't use increment (++) in ntohs() macros!! */
432  	s = (__be16 *)pkt;
433  	proto = *s++;
434  	pkt = (uchar *)s;
435  	switch (ntohs(proto)) {
436  	case TFTP_RRQ:
437  		break;
438  
439  	case TFTP_ACK:
440  #ifdef CONFIG_CMD_TFTPPUT
441  		if (tftp_put_active) {
442  			if (tftp_put_final_block_sent) {
443  				tftp_complete();
444  			} else {
445  				/*
446  				 * Move to the next block. We want our block
447  				 * count to wrap just like the other end!
448  				 */
449  				int block = ntohs(*s);
450  				int ack_ok = (tftp_cur_block == block);
451  
452  				tftp_cur_block = (unsigned short)(block + 1);
453  				update_block_number();
454  				if (ack_ok)
455  					tftp_send(); /* Send next data block */
456  			}
457  		}
458  #endif
459  		break;
460  
461  	default:
462  		break;
463  
464  #ifdef CONFIG_CMD_TFTPSRV
465  	case TFTP_WRQ:
466  		debug("Got WRQ\n");
467  		tftp_remote_ip = sip;
468  		tftp_remote_port = src;
469  		tftp_our_port = 1024 + (get_timer(0) % 3072);
470  		new_transfer();
471  		tftp_send(); /* Send ACK(0) */
472  		break;
473  #endif
474  
475  	case TFTP_OACK:
476  		debug("Got OACK: %s %s\n",
477  		      pkt, pkt + strlen((char *)pkt) + 1);
478  		tftp_state = STATE_OACK;
479  		tftp_remote_port = src;
480  		/*
481  		 * Check for 'blksize' option.
482  		 * Careful: "i" is signed, "len" is unsigned, thus
483  		 * something like "len-8" may give a *huge* number
484  		 */
485  		for (i = 0; i+8 < len; i++) {
486  			if (strcmp((char *)pkt + i, "blksize") == 0) {
487  				tftp_block_size = (unsigned short)
488  					simple_strtoul((char *)pkt + i + 8,
489  						       NULL, 10);
490  				debug("Blocksize ack: %s, %d\n",
491  				      (char *)pkt + i + 8, tftp_block_size);
492  			}
493  #ifdef CONFIG_TFTP_TSIZE
494  			if (strcmp((char *)pkt+i, "tsize") == 0) {
495  				tftp_tsize = simple_strtoul((char *)pkt + i + 6,
496  							   NULL, 10);
497  				debug("size = %s, %d\n",
498  				      (char *)pkt + i + 6, tftp_tsize);
499  			}
500  #endif
501  		}
502  #ifdef CONFIG_CMD_TFTPPUT
503  		if (tftp_put_active) {
504  			/* Get ready to send the first block */
505  			tftp_state = STATE_DATA;
506  			tftp_cur_block++;
507  		}
508  #endif
509  		tftp_send(); /* Send ACK or first data block */
510  		break;
511  	case TFTP_DATA:
512  		if (len < 2)
513  			return;
514  		len -= 2;
515  		tftp_cur_block = ntohs(*(__be16 *)pkt);
516  
517  		update_block_number();
518  
519  		if (tftp_state == STATE_SEND_RRQ)
520  			debug("Server did not acknowledge timeout option!\n");
521  
522  		if (tftp_state == STATE_SEND_RRQ || tftp_state == STATE_OACK ||
523  		    tftp_state == STATE_RECV_WRQ) {
524  			/* first block received */
525  			tftp_state = STATE_DATA;
526  			tftp_remote_port = src;
527  			new_transfer();
528  
529  			if (tftp_cur_block != 1) {	/* Assertion */
530  				puts("\nTFTP error: ");
531  				printf("First block is not block 1 (%ld)\n",
532  				       tftp_cur_block);
533  				puts("Starting again\n\n");
534  				net_start_again();
535  				break;
536  			}
537  		}
538  
539  		if (tftp_cur_block == tftp_prev_block) {
540  			/* Same block again; ignore it. */
541  			break;
542  		}
543  
544  		tftp_prev_block = tftp_cur_block;
545  		timeout_count_max = tftp_timeout_count_max;
546  		net_set_timeout_handler(timeout_ms, tftp_timeout_handler);
547  
548  		if (store_block(tftp_cur_block - 1, pkt + 2, len)) {
549  			eth_halt();
550  			net_set_state(NETLOOP_FAIL);
551  			break;
552  		}
553  
554  		/*
555  		 *	Acknowledge the block just received, which will prompt
556  		 *	the remote for the next one.
557  		 */
558  		tftp_send();
559  
560  		if (len < tftp_block_size)
561  			tftp_complete();
562  		break;
563  
564  	case TFTP_ERROR:
565  		printf("\nTFTP error: '%s' (%d)\n",
566  		       pkt + 2, ntohs(*(__be16 *)pkt));
567  
568  		switch (ntohs(*(__be16 *)pkt)) {
569  		case TFTP_ERR_FILE_NOT_FOUND:
570  		case TFTP_ERR_ACCESS_DENIED:
571  			puts("Not retrying...\n");
572  			eth_halt();
573  			net_set_state(NETLOOP_FAIL);
574  			break;
575  		case TFTP_ERR_UNDEFINED:
576  		case TFTP_ERR_DISK_FULL:
577  		case TFTP_ERR_UNEXPECTED_OPCODE:
578  		case TFTP_ERR_UNKNOWN_TRANSFER_ID:
579  		case TFTP_ERR_FILE_ALREADY_EXISTS:
580  		default:
581  			puts("Starting again\n\n");
582  			net_start_again();
583  			break;
584  		}
585  		break;
586  	}
587  }
588  
589  
590  static void tftp_timeout_handler(void)
591  {
592  	if (++timeout_count > timeout_count_max) {
593  		restart("Retry count exceeded");
594  	} else {
595  		puts("T ");
596  		net_set_timeout_handler(timeout_ms, tftp_timeout_handler);
597  		if (tftp_state != STATE_RECV_WRQ)
598  			tftp_send();
599  	}
600  }
601  
602  /* Initialize tftp_load_addr and tftp_load_size from load_addr and lmb */
603  static int tftp_init_load_addr(void)
604  {
605  #ifdef CONFIG_LMB
606  	struct lmb lmb;
607  	phys_size_t max_size;
608  
609  	lmb_init_and_reserve(&lmb, gd->bd->bi_dram[0].start,
610  			     gd->bd->bi_dram[0].size, (void *)gd->fdt_blob);
611  
612  	max_size = lmb_get_free_size(&lmb, load_addr);
613  	if (!max_size)
614  		return -1;
615  
616  	tftp_load_size = max_size;
617  #endif
618  	tftp_load_addr = load_addr;
619  	return 0;
620  }
621  
622  void tftp_start(enum proto_t protocol)
623  {
624  #if CONFIG_NET_TFTP_VARS
625  	char *ep;             /* Environment pointer */
626  
627  	/*
628  	 * Allow the user to choose TFTP blocksize and timeout.
629  	 * TFTP protocol has a minimal timeout of 1 second.
630  	 */
631  
632  	ep = env_get("tftpblocksize");
633  	if (ep != NULL)
634  		tftp_block_size_option = simple_strtol(ep, NULL, 10);
635  
636  	ep = env_get("tftptimeout");
637  	if (ep != NULL)
638  		timeout_ms = simple_strtol(ep, NULL, 10);
639  
640  	if (timeout_ms < 1000) {
641  		printf("TFTP timeout (%ld ms) too low, set min = 1000 ms\n",
642  		       timeout_ms);
643  		timeout_ms = 1000;
644  	}
645  
646  	ep = env_get("tftptimeoutcountmax");
647  	if (ep != NULL)
648  		tftp_timeout_count_max = simple_strtol(ep, NULL, 10);
649  
650  	if (tftp_timeout_count_max < 0) {
651  		printf("TFTP timeout count max (%d ms) negative, set to 0\n",
652  		       tftp_timeout_count_max);
653  		tftp_timeout_count_max = 0;
654  	}
655  #endif
656  
657  	debug("TFTP blocksize = %i, timeout = %ld ms\n",
658  	      tftp_block_size_option, timeout_ms);
659  
660  	tftp_remote_ip = net_server_ip;
661  	if (!net_parse_bootfile(&tftp_remote_ip, tftp_filename, MAX_LEN)) {
662  		sprintf(default_filename, "%02X%02X%02X%02X.img",
663  			net_ip.s_addr & 0xFF,
664  			(net_ip.s_addr >>  8) & 0xFF,
665  			(net_ip.s_addr >> 16) & 0xFF,
666  			(net_ip.s_addr >> 24) & 0xFF);
667  
668  		strncpy(tftp_filename, default_filename, DEFAULT_NAME_LEN);
669  		tftp_filename[DEFAULT_NAME_LEN - 1] = 0;
670  
671  		printf("*** Warning: no boot file name; using '%s'\n",
672  		       tftp_filename);
673  	}
674  
675  	printf("Using %s device\n", eth_get_name());
676  	printf("TFTP %s server %pI4; our IP address is %pI4",
677  #ifdef CONFIG_CMD_TFTPPUT
678  	       protocol == TFTPPUT ? "to" : "from",
679  #else
680  	       "from",
681  #endif
682  	       &tftp_remote_ip, &net_ip);
683  
684  	/* Check if we need to send across this subnet */
685  	if (net_gateway.s_addr && net_netmask.s_addr) {
686  		struct in_addr our_net;
687  		struct in_addr remote_net;
688  
689  		our_net.s_addr = net_ip.s_addr & net_netmask.s_addr;
690  		remote_net.s_addr = tftp_remote_ip.s_addr & net_netmask.s_addr;
691  		if (our_net.s_addr != remote_net.s_addr)
692  			printf("; sending through gateway %pI4", &net_gateway);
693  	}
694  	putc('\n');
695  
696  	printf("Filename '%s'.", tftp_filename);
697  
698  	if (net_boot_file_expected_size_in_blocks) {
699  		printf(" Size is 0x%x Bytes = ",
700  		       net_boot_file_expected_size_in_blocks << 9);
701  		print_size(net_boot_file_expected_size_in_blocks << 9, "");
702  	}
703  
704  	putc('\n');
705  #ifdef CONFIG_CMD_TFTPPUT
706  	tftp_put_active = (protocol == TFTPPUT);
707  	if (tftp_put_active) {
708  		printf("Save address: 0x%lx\n", save_addr);
709  		printf("Save size:    0x%lx\n", save_size);
710  		net_boot_file_size = save_size;
711  		puts("Saving: *\b");
712  		tftp_state = STATE_SEND_WRQ;
713  		new_transfer();
714  	} else
715  #endif
716  	{
717  		if (tftp_init_load_addr()) {
718  			eth_halt();
719  			net_set_state(NETLOOP_FAIL);
720  			puts("\nTFTP error: ");
721  			puts("trying to overwrite reserved memory...\n");
722  			return;
723  		}
724  		printf("Load address: 0x%lx\n", tftp_load_addr);
725  		puts("Loading: *\b");
726  		tftp_state = STATE_SEND_RRQ;
727  #ifdef CONFIG_CMD_BOOTEFI
728  		efi_set_bootdev("Net", "", tftp_filename);
729  #endif
730  	}
731  
732  	time_start = get_timer(0);
733  	timeout_count_max = tftp_timeout_count_max;
734  
735  	net_set_timeout_handler(timeout_ms, tftp_timeout_handler);
736  	net_set_udp_handler(tftp_handler);
737  #ifdef CONFIG_CMD_TFTPPUT
738  	net_set_icmp_handler(icmp_handler);
739  #endif
740  	tftp_remote_port = WELL_KNOWN_PORT;
741  	timeout_count = 0;
742  	/* Use a pseudo-random port unless a specific port is set */
743  	tftp_our_port = 1024 + (get_timer(0) % 3072);
744  
745  #ifdef CONFIG_TFTP_PORT
746  	ep = env_get("tftpdstp");
747  	if (ep != NULL)
748  		tftp_remote_port = simple_strtol(ep, NULL, 10);
749  	ep = env_get("tftpsrcp");
750  	if (ep != NULL)
751  		tftp_our_port = simple_strtol(ep, NULL, 10);
752  #endif
753  	tftp_cur_block = 0;
754  
755  	/* zero out server ether in case the server ip has changed */
756  	memset(net_server_ethaddr, 0, 6);
757  	/* Revert tftp_block_size to dflt */
758  	tftp_block_size = TFTP_BLOCK_SIZE;
759  #ifdef CONFIG_TFTP_TSIZE
760  	tftp_tsize = 0;
761  	tftp_tsize_num_hash = 0;
762  #endif
763  
764  	tftp_send();
765  }
766  
767  #ifdef CONFIG_CMD_TFTPSRV
768  void tftp_start_server(void)
769  {
770  	tftp_filename[0] = 0;
771  
772  	if (tftp_init_load_addr()) {
773  		eth_halt();
774  		net_set_state(NETLOOP_FAIL);
775  		puts("\nTFTP error: trying to overwrite reserved memory...\n");
776  		return;
777  	}
778  	printf("Using %s device\n", eth_get_name());
779  	printf("Listening for TFTP transfer on %pI4\n", &net_ip);
780  	printf("Load address: 0x%lx\n", tftp_load_addr);
781  
782  	puts("Loading: *\b");
783  
784  	timeout_count_max = tftp_timeout_count_max;
785  	timeout_count = 0;
786  	timeout_ms = TIMEOUT;
787  	net_set_timeout_handler(timeout_ms, tftp_timeout_handler);
788  
789  	/* Revert tftp_block_size to dflt */
790  	tftp_block_size = TFTP_BLOCK_SIZE;
791  	tftp_cur_block = 0;
792  	tftp_our_port = WELL_KNOWN_PORT;
793  
794  #ifdef CONFIG_TFTP_TSIZE
795  	tftp_tsize = 0;
796  	tftp_tsize_num_hash = 0;
797  #endif
798  
799  	tftp_state = STATE_RECV_WRQ;
800  	net_set_udp_handler(tftp_handler);
801  
802  	/* zero out server ether in case the server ip has changed */
803  	memset(net_server_ethaddr, 0, 6);
804  }
805  #endif /* CONFIG_CMD_TFTPSRV */
806  
807