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