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 (CONFIG_COMMANDS & CFG_CMD_NET)
  16
  17 #define WELL_KNOWN_PORT 69              /* Well known TFTP port #               */
  18 #define TIMEOUT         5               /* 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[CFG_MAX_FLASH_BANKS];
  62 #endif
  63
  64 static __inline__ void
  65 store_block (unsigned block, uchar * src, unsigned len)
  66 {
  67         ulong offset = block * TFTP_BLOCK_SIZE + TftpBlockWrapOffset;
  68         ulong newsize = offset + len;
  69 #ifdef CFG_DIRECT_FLASH_TFTP
  70         int i, rc = 0;
  71
  72         for (i=0; i<CFG_MAX_FLASH_BANKS; i++) {
  73                 /* start address in flash? */
  74                 if (load_addr + offset >= flash_info[i].start[0]) {
  75                         rc = 1;
  76                         break;
  77                 }
  78         }
  79
  80         if (rc) { /* Flash is destination for this packet */
  81                 rc = flash_write ((uchar *)src, (ulong)(load_addr+offset), len);
  82                 if (rc) {
  83                         flash_perror (rc);
  84                         NetState = NETLOOP_FAIL;
  85                         return;
  86                 }
  87         }
  88         else
  89 #endif /* CFG_DIRECT_FLASH_TFTP */
  90         {
  91                 (void)memcpy((void *)(load_addr + offset), src, len);
  92         }
  93
  94         if (NetBootFileXferSize < newsize)
  95                 NetBootFileXferSize = newsize;
  96 }
  97
  98 static void TftpSend (void);
  99 static void TftpTimeout (void);
 100
 101 /**********************************************************************/
 102
 103 static void
 104 TftpSend (void)
 105 {
 106         volatile uchar *        pkt;
 107         volatile uchar *        xp;
 108         int                     len = 0;
 109
 110         /*
 111          *      We will always be sending some sort of packet, so
 112          *      cobble together the packet headers now.
 113          */
 114         pkt = NetTxPacket + NetEthHdrSize() + IP_HDR_SIZE;
 115
 116         switch (TftpState) {
 117
 118         case STATE_RRQ:
 119                 xp = pkt;
 120                 *((ushort *)pkt)++ = htons(TFTP_RRQ);
 121                 strcpy ((char *)pkt, tftp_filename);
 122                 pkt += strlen(tftp_filename) + 1;
 123                 strcpy ((char *)pkt, "octet");
 124                 pkt += 5 /*strlen("octet")*/ + 1;
 125                 strcpy ((char *)pkt, "timeout");
 126                 pkt += 7 /*strlen("timeout")*/ + 1;
 127                 sprintf((char *)pkt, "%d", TIMEOUT);
 128 #ifdef ET_DEBUG
 129                 printf("send option \"timeout %s\"\n", (char *)pkt);
 130 #endif
 131                 pkt += strlen((char *)pkt) + 1;
 132                 len = pkt - xp;
 133                 break;
 134
 135         case STATE_DATA:
 136         case STATE_OACK:
 137                 xp = pkt;
 138                 *((ushort *)pkt)++ = htons(TFTP_ACK);
 139                 *((ushort *)pkt)++ = htons(TftpBlock);
 140                 len = pkt - xp;
 141                 break;
 142
 143         case STATE_TOO_LARGE:
 144                 xp = pkt;
 145                 *((ushort *)pkt)++ = htons(TFTP_ERROR);
 146                 *((ushort *)pkt)++ = htons(3);
 147                 strcpy ((char *)pkt, "File too large");
 148                 pkt += 14 /*strlen("File too large")*/ + 1;
 149                 len = pkt - xp;
 150                 break;
 151
 152         case STATE_BAD_MAGIC:
 153                 xp = pkt;
 154                 *((ushort *)pkt)++ = htons(TFTP_ERROR);
 155                 *((ushort *)pkt)++ = htons(2);
 156                 strcpy ((char *)pkt, "File has bad magic");
 157                 pkt += 18 /*strlen("File has bad magic")*/ + 1;
 158                 len = pkt - xp;
 159                 break;
 160         }
 161
 162         NetSendUDPPacket(NetServerEther, NetServerIP, TftpServerPort, TftpOurPort, len);
 163 }
 164
 165
 166 static void
 167 TftpHandler (uchar * pkt, unsigned dest, unsigned src, unsigned len)
 168 {
 169         ushort proto;
 170
 171         if (dest != TftpOurPort) {
 172                 return;
 173         }
 174         if (TftpState != STATE_RRQ && src != TftpServerPort) {
 175                 return;
 176         }
 177
 178         if (len < 2) {
 179                 return;
 180         }
 181         len -= 2;
 182         /* warning: don't use increment (++) in ntohs() macros!! */
 183         proto = *((ushort *)pkt)++;
 184         switch (ntohs(proto)) {
 185
 186         case TFTP_RRQ:
 187         case TFTP_WRQ:
 188         case TFTP_ACK:
 189                 break;
 190         default:
 191                 break;
 192
 193         case TFTP_OACK:
 194 #ifdef ET_DEBUG
 195                 printf("Got OACK: %s %s\n", pkt, pkt+strlen(pkt)+1);
 196 #endif
 197                 TftpState = STATE_OACK;
 198                 TftpServerPort = src;
 199                 TftpSend (); /* Send ACK */
 200                 break;
 201         case TFTP_DATA:
 202                 if (len < 2)
 203                         return;
 204                 len -= 2;
 205                 TftpBlock = ntohs(*(ushort *)pkt);
 206
 207                 /*
 208                  * RFC1350 specifies that the first data packet will
 209                  * have sequence number 1. If we receive a sequence
 210                  * number of 0 this means that there was a wrap
 211                  * around of the (16 bit) counter.
 212                  */
 213                 if (TftpBlock == 0) {
 214                         TftpBlockWrap++;
 215                         TftpBlockWrapOffset += TFTP_BLOCK_SIZE * TFTP_SEQUENCE_SIZE;
 216                         printf ("\n\t %lu MB reveived\n\t ", TftpBlockWrapOffset>>20);
 217                 } else {
 218                         if (((TftpBlock - 1) % 10) == 0) {
 219                                 putc ('#');
 220                         } else if ((TftpBlock % (10 * HASHES_PER_LINE)) == 0) {
 221                                 puts ("\n\t ");
 222                         }
 223                 }
 224
 225 #ifdef ET_DEBUG
 226                 if (TftpState == STATE_RRQ) {
 227                         puts ("Server did not acknowledge timeout option!\n");
 228                 }
 229 #endif
 230
 231                 if (TftpState == STATE_RRQ || TftpState == STATE_OACK) {
 232                         /* first block received */
 233                         TftpState = STATE_DATA;
 234                         TftpServerPort = src;
 235                         TftpLastBlock = 0;
 236                         TftpBlockWrap = 0;
 237                         TftpBlockWrapOffset = 0;
 238
 239                         if (TftpBlock != 1) {   /* Assertion */
 240                                 printf ("\nTFTP error: "
 241                                         "First block is not block 1 (%ld)\n"
 242                                         "Starting again\n\n",
 243                                         TftpBlock);
 244                                 NetStartAgain ();
 245                                 break;
 246                         }
 247                 }
 248
 249                 if (TftpBlock == TftpLastBlock) {
 250                         /*
 251                          *      Same block again; ignore it.
 252                          */
 253                         break;
 254                 }
 255
 256                 TftpLastBlock = TftpBlock;
 257                 NetSetTimeout (TIMEOUT * CFG_HZ, TftpTimeout);
 258
 259                 store_block (TftpBlock - 1, pkt + 2, len);
 260
 261                 /*
 262                  *      Acknoledge the block just received, which will prompt
 263                  *      the server for the next one.
 264                  */
 265                 TftpSend ();
 266
 267                 if (len < TFTP_BLOCK_SIZE) {
 268                         /*
 269                          *      We received the whole thing.  Try to
 270                          *      run it.
 271                          */
 272                         puts ("\ndone\n");
 273                         NetState = NETLOOP_SUCCESS;
 274                 }
 275                 break;
 276
 277         case TFTP_ERROR:
 278                 printf ("\nTFTP error: '%s' (%d)\n",
 279                                         pkt + 2, ntohs(*(ushort *)pkt));
 280                 puts ("Starting again\n\n");
 281                 NetStartAgain ();
 282                 break;
 283         }
 284 }
 285
 286
 287 static void
 288 TftpTimeout (void)
 289 {
 290         if (++TftpTimeoutCount > TIMEOUT_COUNT) {
 291                 puts ("\nRetry count exceeded; starting again\n");
 292                 NetStartAgain ();
 293         } else {
 294                 puts ("T ");
 295                 NetSetTimeout (TIMEOUT * CFG_HZ, TftpTimeout);
 296                 TftpSend ();
 297         }
 298 }
 299
 300
 301 void
 302 TftpStart (void)
 303 {
 304         if (BootFile[0] == '\0') {
 305                 sprintf(default_filename, "%02lX%02lX%02lX%02lX.img",
 306                         NetOurIP & 0xFF,
 307                         (NetOurIP >>  8) & 0xFF,
 308                         (NetOurIP >> 16) & 0xFF,
 309                         (NetOurIP >> 24) & 0xFF );
 310                 tftp_filename = default_filename;
 311
 312                 printf ("*** Warning: no boot file name; using '%s'\n",
 313                         tftp_filename);
 314         } else {
 315                 tftp_filename = BootFile;
 316         }
 317
 318 #if defined(CONFIG_NET_MULTI)
 319         printf ("Using %s device\n", eth_get_name());
 320 #endif
 321         puts ("TFTP from server ");     print_IPaddr (NetServerIP);
 322         puts ("; our IP address is ");  print_IPaddr (NetOurIP);
 323
 324         /* Check if we need to send across this subnet */
 325         if (NetOurGatewayIP && NetOurSubnetMask) {
 326             IPaddr_t OurNet     = NetOurIP    & NetOurSubnetMask;
 327             IPaddr_t ServerNet  = NetServerIP & NetOurSubnetMask;
 328
 329             if (OurNet != ServerNet) {
 330                 puts ("; sending through gateway ");
 331                 print_IPaddr (NetOurGatewayIP) ;
 332             }
 333         }
 334         putc ('\n');
 335
 336         printf ("Filename '%s'.", tftp_filename);
 337
 338         if (NetBootFileSize) {
 339                 printf (" Size is 0x%x Bytes = ", NetBootFileSize<<9);
 340                 print_size (NetBootFileSize<<9, "");
 341         }
 342
 343         putc ('\n');
 344
 345         printf ("Load address: 0x%lx\n", load_addr);
 346
 347         puts ("Loading: *\b");
 348
 349         NetSetTimeout (TIMEOUT * CFG_HZ, TftpTimeout);
 350         NetSetHandler (TftpHandler);
 351
 352         TftpServerPort = WELL_KNOWN_PORT;
 353         TftpTimeoutCount = 0;
 354         TftpState = STATE_RRQ;
 355         TftpOurPort = 1024 + (get_timer(0) % 3072);
 356         TftpBlock = 0;
 357
 358         /* zero out server ether in case the server ip has changed */
 359         memset(NetServerEther, 0, 6);
 360
 361         TftpSend ();
 362 }
 363
 364 #endif /* CFG_CMD_NET */