Fix warning differ in signedness in net/net.c and net/nfs.c
[platform/kernel/u-boot.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  */
6
7 #include <common.h>
8 #include <command.h>
9 #include <net.h>
10 #include "tftp.h"
11 #include "bootp.h"
12
13 #undef  ET_DEBUG
14
15 #if defined(CONFIG_CMD_NET)
16
17 #define WELL_KNOWN_PORT 69              /* Well known TFTP port #               */
18 #define TIMEOUT         5UL             /* Seconds to timeout for a lost pkt    */
19 #ifndef CONFIG_NET_RETRY_COUNT
20 # define TIMEOUT_COUNT  10              /* # of timeouts before giving up  */
21 #else
22 # define TIMEOUT_COUNT  (CONFIG_NET_RETRY_COUNT * 2)
23 #endif
24                                         /* (for checking the image size)        */
25 #define HASHES_PER_LINE 65              /* Number of "loading" hashes per line  */
26
27 /*
28  *      TFTP operations.
29  */
30 #define TFTP_RRQ        1
31 #define TFTP_WRQ        2
32 #define TFTP_DATA       3
33 #define TFTP_ACK        4
34 #define TFTP_ERROR      5
35 #define TFTP_OACK       6
36
37
38 static int      TftpServerPort;         /* The UDP port at their end            */
39 static int      TftpOurPort;            /* The UDP port at our end              */
40 static int      TftpTimeoutCount;
41 static ulong    TftpBlock;              /* packet sequence number               */
42 static ulong    TftpLastBlock;          /* last packet sequence number received */
43 static ulong    TftpBlockWrap;          /* count of sequence number wraparounds */
44 static ulong    TftpBlockWrapOffset;    /* memory offset due to wrapping        */
45 static int      TftpState;
46
47 #define STATE_RRQ       1
48 #define STATE_DATA      2
49 #define STATE_TOO_LARGE 3
50 #define STATE_BAD_MAGIC 4
51 #define STATE_OACK      5
52
53 #define TFTP_BLOCK_SIZE         512                 /* default TFTP block size  */
54 #define TFTP_SEQUENCE_SIZE      ((ulong)(1<<16))    /* sequence number is 16 bit */
55
56 #define DEFAULT_NAME_LEN        (8 + 4 + 1)
57 static char default_filename[DEFAULT_NAME_LEN];
58 static char *tftp_filename;
59
60 #ifdef CFG_DIRECT_FLASH_TFTP
61 extern flash_info_t flash_info[];
62 #endif
63
64 /* 512 is poor choice for ethernet, MTU is typically 1500.
65  * Minus eth.hdrs thats 1468.  Can get 2x better throughput with
66  * almost-MTU block sizes.  At least try... fall back to 512 if need be.
67  */
68 #define TFTP_MTU_BLOCKSIZE 1468
69 static unsigned short TftpBlkSize=TFTP_BLOCK_SIZE;
70 static unsigned short TftpBlkSizeOption=TFTP_MTU_BLOCKSIZE;
71
72 #ifdef CONFIG_MCAST_TFTP
73 #include <malloc.h>
74 #define MTFTP_BITMAPSIZE        0x1000
75 static unsigned *Bitmap;
76 static int PrevBitmapHole,Mapsize=MTFTP_BITMAPSIZE;
77 static uchar ProhibitMcast=0, MasterClient=0;
78 static uchar Multicast=0;
79 extern IPaddr_t Mcast_addr;
80 static int Mcast_port;
81 static ulong TftpEndingBlock; /* can get 'last' block before done..*/
82
83 static void parse_multicast_oack(char *pkt,int len);
84
85 static void
86 mcast_cleanup(void)
87 {
88         if (Mcast_addr) eth_mcast_join(Mcast_addr, 0);
89         if (Bitmap) free(Bitmap);
90         Bitmap=NULL;
91         Mcast_addr = Multicast = Mcast_port = 0;
92         TftpEndingBlock = -1;
93 }
94
95 #endif  /* CONFIG_MCAST_TFTP */
96
97 static __inline__ void
98 store_block (unsigned block, uchar * src, unsigned len)
99 {
100         ulong offset = block * TftpBlkSize + TftpBlockWrapOffset;
101         ulong newsize = offset + len;
102 #ifdef CFG_DIRECT_FLASH_TFTP
103         int i, rc = 0;
104
105         for (i=0; i<CFG_MAX_FLASH_BANKS; i++) {
106                 /* start address in flash? */
107                 if (load_addr + offset >= flash_info[i].start[0]) {
108                         rc = 1;
109                         break;
110                 }
111         }
112
113         if (rc) { /* Flash is destination for this packet */
114                 rc = flash_write ((char *)src, (ulong)(load_addr+offset), len);
115                 if (rc) {
116                         flash_perror (rc);
117                         NetState = NETLOOP_FAIL;
118                         return;
119                 }
120         }
121         else
122 #endif /* CFG_DIRECT_FLASH_TFTP */
123         {
124                 (void)memcpy((void *)(load_addr + offset), src, len);
125         }
126 #ifdef CONFIG_MCAST_TFTP
127         if (Multicast)
128                 ext2_set_bit(block, Bitmap);
129 #endif
130
131         if (NetBootFileXferSize < newsize)
132                 NetBootFileXferSize = newsize;
133 }
134
135 static void TftpSend (void);
136 static void TftpTimeout (void);
137
138 /**********************************************************************/
139
140 static void
141 TftpSend (void)
142 {
143         volatile uchar *        pkt;
144         volatile uchar *        xp;
145         int                     len = 0;
146         volatile ushort *s;
147
148 #ifdef CONFIG_MCAST_TFTP
149         /* Multicast TFTP.. non-MasterClients do not ACK data. */
150         if (Multicast
151          && (TftpState == STATE_DATA)
152          && (MasterClient == 0))
153                 return;
154 #endif
155         /*
156          *      We will always be sending some sort of packet, so
157          *      cobble together the packet headers now.
158          */
159         pkt = NetTxPacket + NetEthHdrSize() + IP_HDR_SIZE;
160
161         switch (TftpState) {
162
163         case STATE_RRQ:
164                 xp = pkt;
165                 s = (ushort *)pkt;
166                 *s++ = htons(TFTP_RRQ);
167                 pkt = (uchar *)s;
168                 strcpy ((char *)pkt, tftp_filename);
169                 pkt += strlen(tftp_filename) + 1;
170                 strcpy ((char *)pkt, "octet");
171                 pkt += 5 /*strlen("octet")*/ + 1;
172                 strcpy ((char *)pkt, "timeout");
173                 pkt += 7 /*strlen("timeout")*/ + 1;
174                 sprintf((char *)pkt, "%d", TIMEOUT);
175 #ifdef ET_DEBUG
176                 printf("send option \"timeout %s\"\n", (char *)pkt);
177 #endif
178                 pkt += strlen((char *)pkt) + 1;
179                 /* try for more effic. blk size */
180                 pkt += sprintf((char *)pkt,"blksize%c%d%c",
181                                 0,TftpBlkSizeOption,0);
182 #ifdef CONFIG_MCAST_TFTP
183                 /* Check all preconditions before even trying the option */
184                 if (!ProhibitMcast
185                  && (Bitmap=malloc(Mapsize))
186                  && eth_get_dev()->mcast) {
187                         free(Bitmap);
188                         Bitmap=NULL;
189                         pkt += sprintf((char *)pkt,"multicast%c%c",0,0);
190                 }
191 #endif /* CONFIG_MCAST_TFTP */
192                 len = pkt - xp;
193                 break;
194
195         case STATE_OACK:
196 #ifdef CONFIG_MCAST_TFTP
197                 /* My turn!  Start at where I need blocks I missed.*/
198                 if (Multicast)
199                         TftpBlock=ext2_find_next_zero_bit(Bitmap,(Mapsize*8),0);
200                 /*..falling..*/
201 #endif
202         case STATE_DATA:
203                 xp = pkt;
204                 s = (ushort *)pkt;
205                 *s++ = htons(TFTP_ACK);
206                 *s++ = htons(TftpBlock);
207                 pkt = (uchar *)s;
208                 len = pkt - xp;
209                 break;
210
211         case STATE_TOO_LARGE:
212                 xp = pkt;
213                 s = (ushort *)pkt;
214                 *s++ = htons(TFTP_ERROR);
215                 *s++ = htons(3);
216                 pkt = (uchar *)s;
217                 strcpy ((char *)pkt, "File too large");
218                 pkt += 14 /*strlen("File too large")*/ + 1;
219                 len = pkt - xp;
220                 break;
221
222         case STATE_BAD_MAGIC:
223                 xp = pkt;
224                 s = (ushort *)pkt;
225                 *s++ = htons(TFTP_ERROR);
226                 *s++ = htons(2);
227                 pkt = (uchar *)s;
228                 strcpy ((char *)pkt, "File has bad magic");
229                 pkt += 18 /*strlen("File has bad magic")*/ + 1;
230                 len = pkt - xp;
231                 break;
232         }
233
234         NetSendUDPPacket(NetServerEther, NetServerIP, TftpServerPort, TftpOurPort, len);
235 }
236
237
238 static void
239 TftpHandler (uchar * pkt, unsigned dest, unsigned src, unsigned len)
240 {
241         ushort proto;
242         ushort *s;
243         int i;
244
245         if (dest != TftpOurPort) {
246 #ifdef CONFIG_MCAST_TFTP
247                 if (Multicast
248                  && (!Mcast_port || (dest != Mcast_port)))
249 #endif
250                 return;
251         }
252         if (TftpState != STATE_RRQ && src != TftpServerPort) {
253                 return;
254         }
255
256         if (len < 2) {
257                 return;
258         }
259         len -= 2;
260         /* warning: don't use increment (++) in ntohs() macros!! */
261         s = (ushort *)pkt;
262         proto = *s++;
263         pkt = (uchar *)s;
264         switch (ntohs(proto)) {
265
266         case TFTP_RRQ:
267         case TFTP_WRQ:
268         case TFTP_ACK:
269                 break;
270         default:
271                 break;
272
273         case TFTP_OACK:
274 #ifdef ET_DEBUG
275                 printf("Got OACK: %s %s\n", pkt, pkt+strlen(pkt)+1);
276 #endif
277                 TftpState = STATE_OACK;
278                 TftpServerPort = src;
279                 /*
280                  * Check for 'blksize' option.
281                  * Careful: "i" is signed, "len" is unsigned, thus
282                  * something like "len-8" may give a *huge* number
283                  */
284                 for (i=0; i+8<len; i++) {
285                         if (strcmp ((char*)pkt+i,"blksize") == 0) {
286                                 TftpBlkSize = (unsigned short)
287                                         simple_strtoul((char*)pkt+i+8,NULL,10);
288 #ifdef ET_DEBUG
289                                 printf ("Blocksize ack: %s, %d\n",
290                                         (char*)pkt+i+8,TftpBlkSize);
291 #endif
292                                 break;
293                         }
294                 }
295 #ifdef CONFIG_MCAST_TFTP
296                 parse_multicast_oack((char *)pkt,len-1);
297                 if ((Multicast) && (!MasterClient))
298                         TftpState = STATE_DATA; /* passive.. */
299                 else
300 #endif
301                 TftpSend (); /* Send ACK */
302                 break;
303         case TFTP_DATA:
304                 if (len < 2)
305                         return;
306                 len -= 2;
307                 TftpBlock = ntohs(*(ushort *)pkt);
308
309                 /*
310                  * RFC1350 specifies that the first data packet will
311                  * have sequence number 1. If we receive a sequence
312                  * number of 0 this means that there was a wrap
313                  * around of the (16 bit) counter.
314                  */
315                 if (TftpBlock == 0) {
316                         TftpBlockWrap++;
317                         TftpBlockWrapOffset += TftpBlkSize * TFTP_SEQUENCE_SIZE;
318                         printf ("\n\t %lu MB received\n\t ", TftpBlockWrapOffset>>20);
319                 } else {
320                         if (((TftpBlock - 1) % 10) == 0) {
321                                 putc ('#');
322                         } else if ((TftpBlock % (10 * HASHES_PER_LINE)) == 0) {
323                                 puts ("\n\t ");
324                         }
325                 }
326
327 #ifdef ET_DEBUG
328                 if (TftpState == STATE_RRQ) {
329                         puts ("Server did not acknowledge timeout option!\n");
330                 }
331 #endif
332
333                 if (TftpState == STATE_RRQ || TftpState == STATE_OACK) {
334                         /* first block received */
335                         TftpState = STATE_DATA;
336                         TftpServerPort = src;
337                         TftpLastBlock = 0;
338                         TftpBlockWrap = 0;
339                         TftpBlockWrapOffset = 0;
340
341 #ifdef CONFIG_MCAST_TFTP
342                         if (Multicast) { /* start!=1 common if mcast */
343                                 TftpLastBlock = TftpBlock - 1;
344                         } else
345 #endif
346                         if (TftpBlock != 1) {   /* Assertion */
347                                 printf ("\nTFTP error: "
348                                         "First block is not block 1 (%ld)\n"
349                                         "Starting again\n\n",
350                                         TftpBlock);
351                                 NetStartAgain ();
352                                 break;
353                         }
354                 }
355
356                 if (TftpBlock == TftpLastBlock) {
357                         /*
358                          *      Same block again; ignore it.
359                          */
360                         break;
361                 }
362
363                 TftpLastBlock = TftpBlock;
364                 NetSetTimeout (TIMEOUT * CFG_HZ, TftpTimeout);
365
366                 store_block (TftpBlock - 1, pkt + 2, len);
367
368                 /*
369                  *      Acknoledge the block just received, which will prompt
370                  *      the server for the next one.
371                  */
372 #ifdef CONFIG_MCAST_TFTP
373                 /* if I am the MasterClient, actively calculate what my next
374                  * needed block is; else I'm passive; not ACKING
375                  */
376                 if (Multicast) {
377                         if (len < TftpBlkSize)  {
378                                 TftpEndingBlock = TftpBlock;
379                         } else if (MasterClient) {
380                                 TftpBlock = PrevBitmapHole =
381                                         ext2_find_next_zero_bit(
382                                                 Bitmap,
383                                                 (Mapsize*8),
384                                                 PrevBitmapHole);
385                                 if (TftpBlock > ((Mapsize*8) - 1)) {
386                                         printf ("tftpfile too big\n");
387                                         /* try to double it and retry */
388                                         Mapsize<<=1;
389                                         mcast_cleanup();
390                                         NetStartAgain ();
391                                         return;
392                                 }
393                                 TftpLastBlock = TftpBlock;
394                         }
395                 }
396 #endif
397                 TftpSend ();
398
399 #ifdef CONFIG_MCAST_TFTP
400                 if (Multicast) {
401                         if (MasterClient && (TftpBlock >= TftpEndingBlock)) {
402                                 puts ("\nMulticast tftp done\n");
403                                 mcast_cleanup();
404                                 NetState = NETLOOP_SUCCESS;
405                         }
406                 }
407                 else
408 #endif
409                 if (len < TftpBlkSize) {
410                         /*
411                          *      We received the whole thing.  Try to
412                          *      run it.
413                          */
414                         puts ("\ndone\n");
415                         NetState = NETLOOP_SUCCESS;
416                 }
417                 break;
418
419         case TFTP_ERROR:
420                 printf ("\nTFTP error: '%s' (%d)\n",
421                                         pkt + 2, ntohs(*(ushort *)pkt));
422                 puts ("Starting again\n\n");
423 #ifdef CONFIG_MCAST_TFTP
424                 mcast_cleanup();
425 #endif
426                 NetStartAgain ();
427                 break;
428         }
429 }
430
431
432 static void
433 TftpTimeout (void)
434 {
435         if (++TftpTimeoutCount > TIMEOUT_COUNT) {
436                 puts ("\nRetry count exceeded; starting again\n");
437 #ifdef CONFIG_MCAST_TFTP
438                 mcast_cleanup();
439 #endif
440                 NetStartAgain ();
441         } else {
442                 puts ("T ");
443                 NetSetTimeout (TIMEOUT * CFG_HZ, TftpTimeout);
444                 TftpSend ();
445         }
446 }
447
448
449 void
450 TftpStart (void)
451 {
452 #ifdef CONFIG_TFTP_PORT
453         char *ep;             /* Environment pointer */
454 #endif
455
456         if (BootFile[0] == '\0') {
457                 sprintf(default_filename, "%02lX%02lX%02lX%02lX.img",
458                         NetOurIP & 0xFF,
459                         (NetOurIP >>  8) & 0xFF,
460                         (NetOurIP >> 16) & 0xFF,
461                         (NetOurIP >> 24) & 0xFF );
462                 tftp_filename = default_filename;
463
464                 printf ("*** Warning: no boot file name; using '%s'\n",
465                         tftp_filename);
466         } else {
467                 tftp_filename = BootFile;
468         }
469
470 #if defined(CONFIG_NET_MULTI)
471         printf ("Using %s device\n", eth_get_name());
472 #endif
473         puts ("TFTP from server ");     print_IPaddr (NetServerIP);
474         puts ("; our IP address is ");  print_IPaddr (NetOurIP);
475
476         /* Check if we need to send across this subnet */
477         if (NetOurGatewayIP && NetOurSubnetMask) {
478             IPaddr_t OurNet     = NetOurIP    & NetOurSubnetMask;
479             IPaddr_t ServerNet  = NetServerIP & NetOurSubnetMask;
480
481             if (OurNet != ServerNet) {
482                 puts ("; sending through gateway ");
483                 print_IPaddr (NetOurGatewayIP) ;
484             }
485         }
486         putc ('\n');
487
488         printf ("Filename '%s'.", tftp_filename);
489
490         if (NetBootFileSize) {
491                 printf (" Size is 0x%x Bytes = ", NetBootFileSize<<9);
492                 print_size (NetBootFileSize<<9, "");
493         }
494
495         putc ('\n');
496
497         printf ("Load address: 0x%lx\n", load_addr);
498
499         puts ("Loading: *\b");
500
501         NetSetTimeout (TIMEOUT * CFG_HZ, TftpTimeout);
502         NetSetHandler (TftpHandler);
503
504         TftpServerPort = WELL_KNOWN_PORT;
505         TftpTimeoutCount = 0;
506         TftpState = STATE_RRQ;
507         /* Use a pseudo-random port unless a specific port is set */
508         TftpOurPort = 1024 + (get_timer(0) % 3072);
509
510 #ifdef CONFIG_TFTP_PORT
511         if ((ep = getenv("tftpdstp")) != NULL) {
512                 TftpServerPort = simple_strtol(ep, NULL, 10);
513         }
514         if ((ep = getenv("tftpsrcp")) != NULL) {
515                 TftpOurPort= simple_strtol(ep, NULL, 10);
516         }
517 #endif
518         TftpBlock = 0;
519
520         /* zero out server ether in case the server ip has changed */
521         memset(NetServerEther, 0, 6);
522         /* Revert TftpBlkSize to dflt */
523         TftpBlkSize = TFTP_BLOCK_SIZE;
524 #ifdef CONFIG_MCAST_TFTP
525         mcast_cleanup();
526 #endif
527
528         TftpSend ();
529 }
530
531 #ifdef CONFIG_MCAST_TFTP
532 /* Credits: atftp project.
533  */
534
535 /* pick up BcastAddr, Port, and whether I am [now] the master-client. *
536  * Frame:
537  *    +-------+-----------+---+-------~~-------+---+
538  *    |  opc  | multicast | 0 | addr, port, mc | 0 |
539  *    +-------+-----------+---+-------~~-------+---+
540  * The multicast addr/port becomes what I listen to, and if 'mc' is '1' then
541  * I am the new master-client so must send ACKs to DataBlocks.  If I am not
542  * master-client, I'm a passive client, gathering what DataBlocks I may and
543  * making note of which ones I got in my bitmask.
544  * In theory, I never go from master->passive..
545  * .. this comes in with pkt already pointing just past opc
546  */
547 static void parse_multicast_oack(char *pkt, int len)
548 {
549  int i;
550  IPaddr_t addr;
551  char *mc_adr, *port,  *mc;
552
553         mc_adr=port=mc=NULL;
554         /* march along looking for 'multicast\0', which has to start at least
555          * 14 bytes back from the end.
556          */
557         for (i=0;i<len-14;i++)
558                 if (strcmp (pkt+i,"multicast") == 0)
559                         break;
560         if (i >= (len-14)) /* non-Multicast OACK, ign. */
561                 return;
562
563         i+=10; /* strlen multicast */
564         mc_adr = pkt+i;
565         for (;i<len;i++) {
566                 if (*(pkt+i) == ',') {
567                         *(pkt+i) = '\0';
568                         if (port) {
569                                 mc = pkt+i+1;
570                                 break;
571                         } else {
572                                 port = pkt+i+1;
573                         }
574                 }
575         }
576         if (!port || !mc_adr || !mc ) return;
577         if (Multicast && MasterClient) {
578                 printf ("I got a OACK as master Client, WRONG!\n");
579                 return;
580         }
581         /* ..I now accept packets destined for this MCAST addr, port */
582         if (!Multicast) {
583                 if (Bitmap) {
584                         printf ("Internal failure! no mcast.\n");
585                         free(Bitmap);
586                         Bitmap=NULL;
587                         ProhibitMcast=1;
588                         return ;
589                 }
590                 /* I malloc instead of pre-declare; so that if the file ends
591                  * up being too big for this bitmap I can retry
592                  */
593                 if (!(Bitmap = malloc (Mapsize))) {
594                         printf ("No Bitmap, no multicast. Sorry.\n");
595                         ProhibitMcast=1;
596                         return;
597                 }
598                 memset (Bitmap,0,Mapsize);
599                 PrevBitmapHole = 0;
600                 Multicast = 1;
601         }
602         addr = string_to_ip(mc_adr);
603         if (Mcast_addr != addr) {
604                 if (Mcast_addr)
605                         eth_mcast_join(Mcast_addr, 0);
606                 if (eth_mcast_join(Mcast_addr=addr, 1)) {
607                         printf ("Fail to set mcast, revert to TFTP\n");
608                         ProhibitMcast=1;
609                         mcast_cleanup();
610                         NetStartAgain();
611                 }
612         }
613         MasterClient = (unsigned char)simple_strtoul((char *)mc,NULL,10);
614         Mcast_port = (unsigned short)simple_strtoul(port,NULL,10);
615         printf ("Multicast: %s:%d [%d]\n", mc_adr, Mcast_port, MasterClient);
616         return;
617 }
618
619 #endif /* Multicast TFTP */
620
621 #endif