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