1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Copied from Linux Monitor (LiMon) - Networking. 4 * 5 * Copyright 1994 - 2000 Neil Russell. 6 * (See License) 7 * Copyright 2000 Roland Borde 8 * Copyright 2000 Paolo Scaffardi 9 * Copyright 2000-2002 Wolfgang Denk, wd@denx.de 10 */ 11 12/* 13 * General Desription: 14 * 15 * The user interface supports commands for BOOTP, RARP, and TFTP. 16 * Also, we support ARP internally. Depending on available data, 17 * these interact as follows: 18 * 19 * BOOTP: 20 * 21 * Prerequisites: - own ethernet address 22 * We want: - own IP address 23 * - TFTP server IP address 24 * - name of bootfile 25 * Next step: ARP 26 * 27 * LINKLOCAL: 28 * 29 * Prerequisites: - own ethernet address 30 * We want: - own IP address 31 * Next step: ARP 32 * 33 * RARP: 34 * 35 * Prerequisites: - own ethernet address 36 * We want: - own IP address 37 * - TFTP server IP address 38 * Next step: ARP 39 * 40 * ARP: 41 * 42 * Prerequisites: - own ethernet address 43 * - own IP address 44 * - TFTP server IP address 45 * We want: - TFTP server ethernet address 46 * Next step: TFTP 47 * 48 * DHCP: 49 * 50 * Prerequisites: - own ethernet address 51 * We want: - IP, Netmask, ServerIP, Gateway IP 52 * - bootfilename, lease time 53 * Next step: - TFTP 54 * 55 * TFTP: 56 * 57 * Prerequisites: - own ethernet address 58 * - own IP address 59 * - TFTP server IP address 60 * - TFTP server ethernet address 61 * - name of bootfile (if unknown, we use a default name 62 * derived from our own IP address) 63 * We want: - load the boot file 64 * Next step: none 65 * 66 * NFS: 67 * 68 * Prerequisites: - own ethernet address 69 * - own IP address 70 * - name of bootfile (if unknown, we use a default name 71 * derived from our own IP address) 72 * We want: - load the boot file 73 * Next step: none 74 * 75 * 76 * WOL: 77 * 78 * Prerequisites: - own ethernet address 79 * We want: - magic packet or timeout 80 * Next step: none 81 */ 82 83 84#include <common.h> 85#include <bootstage.h> 86#include <command.h> 87#include <console.h> 88#include <env.h> 89#include <env_internal.h> 90#include <errno.h> 91#include <image.h> 92#include <log.h> 93#include <net.h> 94#include <net6.h> 95#include <ndisc.h> 96#include <net/fastboot_udp.h> 97#include <net/fastboot_tcp.h> 98#include <net/tftp.h> 99#include <net/ncsi.h> 100#if defined(CONFIG_CMD_PCAP) 101#include <net/pcap.h> 102#endif 103#include <net/udp.h> 104#if defined(CONFIG_LED_STATUS) 105#include <miiphy.h> 106#include <status_led.h> 107#endif 108#include <watchdog.h> 109#include <linux/compiler.h> 110#include <test/test.h> 111#include <net/tcp.h> 112#include <net/wget.h> 113#include "arp.h" 114#include "bootp.h" 115#include "cdp.h" 116#if defined(CONFIG_CMD_DNS) 117#include "dns.h" 118#endif 119#include "link_local.h" 120#include "nfs.h" 121#include "ping.h" 122#include "rarp.h" 123#if defined(CONFIG_CMD_WOL) 124#include "wol.h" 125#endif 126#include "dhcpv6.h" 127#include "net_rand.h" 128 129/** BOOTP EXTENTIONS **/ 130 131/* Our subnet mask (0=unknown) */ 132struct in_addr net_netmask; 133/* Our gateways IP address */ 134struct in_addr net_gateway; 135/* Our DNS IP address */ 136struct in_addr net_dns_server; 137#if defined(CONFIG_BOOTP_DNS2) 138/* Our 2nd DNS IP address */ 139struct in_addr net_dns_server2; 140#endif 141/* Indicates whether the pxe path prefix / config file was specified in dhcp option */ 142char *pxelinux_configfile; 143 144/** END OF BOOTP EXTENTIONS **/ 145 146/* Our ethernet address */ 147u8 net_ethaddr[6]; 148/* Boot server enet address */ 149u8 net_server_ethaddr[6]; 150/* Our IP addr (0 = unknown) */ 151struct in_addr net_ip; 152/* Server IP addr (0 = unknown) */ 153struct in_addr net_server_ip; 154/* Current receive packet */ 155uchar *net_rx_packet; 156/* Current rx packet length */ 157int net_rx_packet_len; 158/* IP packet ID */ 159static unsigned net_ip_id; 160/* Ethernet bcast address */ 161const u8 net_bcast_ethaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 162const u8 net_null_ethaddr[6]; 163#if defined(CONFIG_API) || defined(CONFIG_EFI_LOADER) 164void (*push_packet)(void *, int len) = 0; 165#endif 166/* Network loop state */ 167enum net_loop_state net_state; 168/* Tried all network devices */ 169int net_restart_wrap; 170/* Network loop restarted */ 171static int net_restarted; 172/* At least one device configured */ 173static int net_dev_exists; 174 175/* XXX in both little & big endian machines 0xFFFF == ntohs(-1) */ 176/* default is without VLAN */ 177ushort net_our_vlan = 0xFFFF; 178/* ditto */ 179ushort net_native_vlan = 0xFFFF; 180 181/* Boot File name */ 182char net_boot_file_name[1024]; 183/* Indicates whether the file name was specified on the command line */ 184bool net_boot_file_name_explicit; 185/* The actual transferred size of the bootfile (in bytes) */ 186u32 net_boot_file_size; 187/* Boot file size in blocks as reported by the DHCP server */ 188u32 net_boot_file_expected_size_in_blocks; 189 190static uchar net_pkt_buf[(PKTBUFSRX+1) * PKTSIZE_ALIGN + PKTALIGN]; 191/* Receive packets */ 192uchar *net_rx_packets[PKTBUFSRX]; 193/* Current UDP RX packet handler */ 194static rxhand_f *udp_packet_handler; 195/* Current ARP RX packet handler */ 196static rxhand_f *arp_packet_handler; 197#ifdef CONFIG_CMD_TFTPPUT 198/* Current ICMP rx handler */ 199static rxhand_icmp_f *packet_icmp_handler; 200#endif 201/* Current timeout handler */ 202static thand_f *time_handler; 203/* Time base value */ 204static ulong time_start; 205/* Current timeout value */ 206static ulong time_delta; 207/* THE transmit packet */ 208uchar *net_tx_packet; 209 210static int net_check_prereq(enum proto_t protocol); 211 212static int net_try_count; 213 214int __maybe_unused net_busy_flag; 215 216/**********************************************************************/ 217 218static int on_ipaddr(const char *name, const char *value, enum env_op op, 219 int flags) 220{ 221 if (flags & H_PROGRAMMATIC) 222 return 0; 223 224 net_ip = string_to_ip(value); 225 226 return 0; 227} 228U_BOOT_ENV_CALLBACK(ipaddr, on_ipaddr); 229 230static int on_gatewayip(const char *name, const char *value, enum env_op op, 231 int flags) 232{ 233 if (flags & H_PROGRAMMATIC) 234 return 0; 235 236 net_gateway = string_to_ip(value); 237 238 return 0; 239} 240U_BOOT_ENV_CALLBACK(gatewayip, on_gatewayip); 241 242static int on_netmask(const char *name, const char *value, enum env_op op, 243 int flags) 244{ 245 if (flags & H_PROGRAMMATIC) 246 return 0; 247 248 net_netmask = string_to_ip(value); 249 250 return 0; 251} 252U_BOOT_ENV_CALLBACK(netmask, on_netmask); 253 254static int on_serverip(const char *name, const char *value, enum env_op op, 255 int flags) 256{ 257 if (flags & H_PROGRAMMATIC) 258 return 0; 259 260 net_server_ip = string_to_ip(value); 261 262 return 0; 263} 264U_BOOT_ENV_CALLBACK(serverip, on_serverip); 265 266static int on_nvlan(const char *name, const char *value, enum env_op op, 267 int flags) 268{ 269 if (flags & H_PROGRAMMATIC) 270 return 0; 271 272 net_native_vlan = string_to_vlan(value); 273 274 return 0; 275} 276U_BOOT_ENV_CALLBACK(nvlan, on_nvlan); 277 278static int on_vlan(const char *name, const char *value, enum env_op op, 279 int flags) 280{ 281 if (flags & H_PROGRAMMATIC) 282 return 0; 283 284 net_our_vlan = string_to_vlan(value); 285 286 return 0; 287} 288U_BOOT_ENV_CALLBACK(vlan, on_vlan); 289 290#if defined(CONFIG_CMD_DNS) 291static int on_dnsip(const char *name, const char *value, enum env_op op, 292 int flags) 293{ 294 if (flags & H_PROGRAMMATIC) 295 return 0; 296 297 net_dns_server = string_to_ip(value); 298 299 return 0; 300} 301U_BOOT_ENV_CALLBACK(dnsip, on_dnsip); 302#endif 303 304/* 305 * Check if autoload is enabled. If so, use either NFS or TFTP to download 306 * the boot file. 307 */ 308void net_auto_load(void) 309{ 310#if defined(CONFIG_CMD_NFS) && !defined(CONFIG_SPL_BUILD) 311 const char *s = env_get("autoload"); 312 313 if (s != NULL && strcmp(s, "NFS") == 0) { 314 if (net_check_prereq(NFS)) { 315/* We aren't expecting to get a serverip, so just accept the assigned IP */ 316 if (IS_ENABLED(CONFIG_BOOTP_SERVERIP)) { 317 net_set_state(NETLOOP_SUCCESS); 318 } else { 319 printf("Cannot autoload with NFS\n"); 320 net_set_state(NETLOOP_FAIL); 321 } 322 return; 323 } 324 /* 325 * Use NFS to load the bootfile. 326 */ 327 nfs_start(); 328 return; 329 } 330#endif 331 if (env_get_yesno("autoload") == 0) { 332 /* 333 * Just use BOOTP/RARP to configure system; 334 * Do not use TFTP to load the bootfile. 335 */ 336 net_set_state(NETLOOP_SUCCESS); 337 return; 338 } 339 if (net_check_prereq(TFTPGET)) { 340/* We aren't expecting to get a serverip, so just accept the assigned IP */ 341 if (IS_ENABLED(CONFIG_BOOTP_SERVERIP)) { 342 net_set_state(NETLOOP_SUCCESS); 343 } else { 344 printf("Cannot autoload with TFTPGET\n"); 345 net_set_state(NETLOOP_FAIL); 346 } 347 return; 348 } 349 tftp_start(TFTPGET); 350} 351 352static int net_init_loop(void) 353{ 354 static bool first_call = true; 355 356 if (eth_get_dev()) { 357 memcpy(net_ethaddr, eth_get_ethaddr(), 6); 358 359 if (IS_ENABLED(CONFIG_IPV6)) { 360 ip6_make_lladdr(&net_link_local_ip6, net_ethaddr); 361 if (!memcmp(&net_ip6, &net_null_addr_ip6, 362 sizeof(struct in6_addr))) 363 memcpy(&net_ip6, &net_link_local_ip6, 364 sizeof(struct in6_addr)); 365 } 366 } 367 else 368 /* 369 * Not ideal, but there's no way to get the actual error, and I 370 * don't feel like fixing all the users of eth_get_dev to deal 371 * with errors. 372 */ 373 return -ENONET; 374 375 if (IS_ENABLED(CONFIG_IPV6_ROUTER_DISCOVERY)) 376 if (first_call && use_ip6) { 377 first_call = false; 378 srand_mac(); /* This is for rand used in ip6_send_rs. */ 379 net_loop(RS); 380 } 381 return 0; 382} 383 384static void net_clear_handlers(void) 385{ 386 net_set_udp_handler(NULL); 387 net_set_arp_handler(NULL); 388 net_set_timeout_handler(0, NULL); 389} 390 391static void net_cleanup_loop(void) 392{ 393 net_clear_handlers(); 394} 395 396int net_init(void) 397{ 398 static int first_call = 1; 399 400 if (first_call) { 401 /* 402 * Setup packet buffers, aligned correctly. 403 */ 404 int i; 405 406 net_tx_packet = &net_pkt_buf[0] + (PKTALIGN - 1); 407 net_tx_packet -= (ulong)net_tx_packet % PKTALIGN; 408 for (i = 0; i < PKTBUFSRX; i++) { 409 net_rx_packets[i] = net_tx_packet + 410 (i + 1) * PKTSIZE_ALIGN; 411 } 412 arp_init(); 413 ndisc_init(); 414 net_clear_handlers(); 415 416 /* Only need to setup buffer pointers once. */ 417 first_call = 0; 418 if (IS_ENABLED(CONFIG_PROT_TCP)) 419 tcp_set_tcp_state(TCP_CLOSED); 420 } 421 422 return net_init_loop(); 423} 424 425/**********************************************************************/ 426/* 427 * Main network processing loop. 428 */ 429 430int net_loop(enum proto_t protocol) 431{ 432 int ret = -EINVAL; 433 enum net_loop_state prev_net_state = net_state; 434 435#if defined(CONFIG_CMD_PING) 436 if (protocol != PING) 437 net_ping_ip.s_addr = 0; 438#endif 439 net_restarted = 0; 440 net_dev_exists = 0; 441 net_try_count = 1; 442 debug_cond(DEBUG_INT_STATE, "--- net_loop Entry\n"); 443 444#ifdef CONFIG_PHY_NCSI 445 if (phy_interface_is_ncsi() && protocol != NCSI && !ncsi_active()) { 446 printf("%s: configuring NCSI first\n", __func__); 447 if (net_loop(NCSI) < 0) 448 return ret; 449 eth_init_state_only(); 450 goto restart; 451 } 452#endif 453 454 bootstage_mark_name(BOOTSTAGE_ID_ETH_START, "eth_start"); 455 net_init(); 456 if (eth_is_on_demand_init()) { 457 eth_halt(); 458 eth_set_current(); 459 ret = eth_init(); 460 if (ret < 0) { 461 eth_halt(); 462 return ret; 463 } 464 } else { 465 eth_init_state_only(); 466 } 467 468restart: 469#ifdef CONFIG_USB_KEYBOARD 470 net_busy_flag = 0; 471#endif 472 net_set_state(NETLOOP_CONTINUE); 473 474 /* 475 * Start the ball rolling with the given start function. From 476 * here on, this code is a state machine driven by received 477 * packets and timer events. 478 */ 479 debug_cond(DEBUG_INT_STATE, "--- net_loop Init\n"); 480 net_init_loop(); 481 482 if (!test_eth_enabled()) 483 return 0; 484 485 switch (net_check_prereq(protocol)) { 486 case 1: 487 /* network not configured */ 488 eth_halt(); 489 net_set_state(prev_net_state); 490 return -ENODEV; 491 492 case 2: 493 /* network device not configured */ 494 break; 495 496 case 0: 497 net_dev_exists = 1; 498 net_boot_file_size = 0; 499 switch (protocol) { 500#ifdef CONFIG_CMD_TFTPBOOT 501 case TFTPGET: 502#ifdef CONFIG_CMD_TFTPPUT 503 case TFTPPUT: 504#endif 505 /* always use ARP to get server ethernet address */ 506 tftp_start(protocol); 507 break; 508#endif 509#ifdef CONFIG_CMD_TFTPSRV 510 case TFTPSRV: 511 tftp_start_server(); 512 break; 513#endif 514#if CONFIG_IS_ENABLED(UDP_FUNCTION_FASTBOOT) 515 case FASTBOOT_UDP: 516 fastboot_udp_start_server(); 517 break; 518#endif 519#if CONFIG_IS_ENABLED(TCP_FUNCTION_FASTBOOT) 520 case FASTBOOT_TCP: 521 fastboot_tcp_start_server(); 522 break; 523#endif 524#if defined(CONFIG_CMD_DHCP) 525 case DHCP: 526 bootp_reset(); 527 net_ip.s_addr = 0; 528 dhcp_request(); /* Basically same as BOOTP */ 529 break; 530#endif 531 case DHCP6: 532 if (IS_ENABLED(CONFIG_CMD_DHCP6)) 533 dhcp6_start(); 534 break; 535#if defined(CONFIG_CMD_BOOTP) 536 case BOOTP: 537 bootp_reset(); 538 net_ip.s_addr = 0; 539 bootp_request(); 540 break; 541#endif 542#if defined(CONFIG_CMD_RARP) 543 case RARP: 544 rarp_try = 0; 545 net_ip.s_addr = 0; 546 rarp_request(); 547 break; 548#endif 549#if defined(CONFIG_CMD_PING) 550 case PING: 551 ping_start(); 552 break; 553#endif 554#if defined(CONFIG_CMD_PING6) 555 case PING6: 556 ping6_start(); 557 break; 558#endif 559#if defined(CONFIG_CMD_NFS) && !defined(CONFIG_SPL_BUILD) 560 case NFS: 561 nfs_start(); 562 break; 563#endif 564#if defined(CONFIG_CMD_WGET) 565 case WGET: 566 wget_start(); 567 break; 568#endif 569#if defined(CONFIG_CMD_CDP) 570 case CDP: 571 cdp_start(); 572 break; 573#endif 574#if defined(CONFIG_NETCONSOLE) && !defined(CONFIG_SPL_BUILD) 575 case NETCONS: 576 nc_start(); 577 break; 578#endif 579#if defined(CONFIG_CMD_DNS) 580 case DNS: 581 dns_start(); 582 break; 583#endif 584#if defined(CONFIG_CMD_LINK_LOCAL) 585 case LINKLOCAL: 586 link_local_start(); 587 break; 588#endif 589#if defined(CONFIG_CMD_WOL) 590 case WOL: 591 wol_start(); 592 break; 593#endif 594#if defined(CONFIG_PHY_NCSI) 595 case NCSI: 596 ncsi_probe_packages(); 597 break; 598#endif 599 case RS: 600 if (IS_ENABLED(CONFIG_IPV6_ROUTER_DISCOVERY)) 601 ip6_send_rs(); 602 break; 603 default: 604 break; 605 } 606 607 if (IS_ENABLED(CONFIG_PROT_UDP) && protocol == UDP) 608 udp_start(); 609 610 break; 611 } 612 613#if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) 614#if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \ 615 defined(CONFIG_LED_STATUS) && \ 616 defined(CONFIG_LED_STATUS_RED) 617 /* 618 * Echo the inverted link state to the fault LED. 619 */ 620 if (miiphy_link(eth_get_dev()->name, CONFIG_SYS_FAULT_MII_ADDR)) 621 status_led_set(CONFIG_LED_STATUS_RED, CONFIG_LED_STATUS_OFF); 622 else 623 status_led_set(CONFIG_LED_STATUS_RED, CONFIG_LED_STATUS_ON); 624#endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */ 625#endif /* CONFIG_MII, ... */ 626#ifdef CONFIG_USB_KEYBOARD 627 net_busy_flag = 1; 628#endif 629 630 /* 631 * Main packet reception loop. Loop receiving packets until 632 * someone sets `net_state' to a state that terminates. 633 */ 634 for (;;) { 635 schedule(); 636 if (arp_timeout_check() > 0) 637 time_start = get_timer(0); 638 639 if (IS_ENABLED(CONFIG_IPV6)) { 640 if (use_ip6 && (ndisc_timeout_check() > 0)) 641 time_start = get_timer(0); 642 } 643 644 /* 645 * Check the ethernet for a new packet. The ethernet 646 * receive routine will process it. 647 * Most drivers return the most recent packet size, but not 648 * errors that may have happened. 649 */ 650 eth_rx(); 651 652 /* 653 * Abort if ctrl-c was pressed. 654 */ 655 if (ctrlc()) { 656 /* cancel any ARP that may not have completed */ 657 net_arp_wait_packet_ip.s_addr = 0; 658 659 net_cleanup_loop(); 660 eth_halt(); 661 /* Invalidate the last protocol */ 662 eth_set_last_protocol(BOOTP); 663 664 puts("\nAbort\n"); 665 /* include a debug print as well incase the debug 666 messages are directed to stderr */ 667 debug_cond(DEBUG_INT_STATE, "--- net_loop Abort!\n"); 668 ret = -EINTR; 669 goto done; 670 } 671 672 /* 673 * Check for a timeout, and run the timeout handler 674 * if we have one. 675 */ 676 if (time_handler && 677 ((get_timer(0) - time_start) > time_delta)) { 678 thand_f *x; 679 680#if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) 681#if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \ 682 defined(CONFIG_LED_STATUS) && \ 683 defined(CONFIG_LED_STATUS_RED) 684 /* 685 * Echo the inverted link state to the fault LED. 686 */ 687 if (miiphy_link(eth_get_dev()->name, 688 CONFIG_SYS_FAULT_MII_ADDR)) 689 status_led_set(CONFIG_LED_STATUS_RED, 690 CONFIG_LED_STATUS_OFF); 691 else 692 status_led_set(CONFIG_LED_STATUS_RED, 693 CONFIG_LED_STATUS_ON); 694#endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */ 695#endif /* CONFIG_MII, ... */ 696 debug_cond(DEBUG_INT_STATE, "--- net_loop timeout\n"); 697 x = time_handler; 698 time_handler = (thand_f *)0; 699 (*x)(); 700 } else if (IS_ENABLED(CONFIG_IPV6_ROUTER_DISCOVERY)) 701 if (time_handler && protocol == RS) 702 if (!ip6_is_unspecified_addr(&net_gateway6) && 703 net_prefix_length != 0) { 704 net_set_state(NETLOOP_SUCCESS); 705 net_set_timeout_handler(0, NULL); 706 } 707 708 if (net_state == NETLOOP_FAIL) 709 ret = net_start_again(); 710 711 switch (net_state) { 712 case NETLOOP_RESTART: 713 net_restarted = 1; 714 goto restart; 715 716 case NETLOOP_SUCCESS: 717 net_cleanup_loop(); 718 if (net_boot_file_size > 0) { 719 printf("Bytes transferred = %u (%x hex)\n", 720 net_boot_file_size, net_boot_file_size); 721 env_set_hex("filesize", net_boot_file_size); 722 env_set_hex("fileaddr", image_load_addr); 723 } 724 if (protocol != NETCONS && protocol != NCSI) 725 eth_halt(); 726 else 727 eth_halt_state_only(); 728 729 eth_set_last_protocol(protocol); 730 731 ret = net_boot_file_size; 732 debug_cond(DEBUG_INT_STATE, "--- net_loop Success!\n"); 733 goto done; 734 735 case NETLOOP_FAIL: 736 net_cleanup_loop(); 737 /* Invalidate the last protocol */ 738 eth_set_last_protocol(BOOTP); 739 debug_cond(DEBUG_INT_STATE, "--- net_loop Fail!\n"); 740 ret = -ENONET; 741 goto done; 742 743 case NETLOOP_CONTINUE: 744 continue; 745 } 746 } 747 748done: 749#ifdef CONFIG_USB_KEYBOARD 750 net_busy_flag = 0; 751#endif 752#ifdef CONFIG_CMD_TFTPPUT 753 /* Clear out the handlers */ 754 net_set_udp_handler(NULL); 755 net_set_icmp_handler(NULL); 756#endif 757 net_set_state(prev_net_state); 758 759#if defined(CONFIG_CMD_PCAP) 760 if (pcap_active()) 761 pcap_print_status(); 762#endif 763 return ret; 764} 765 766/**********************************************************************/ 767 768static void start_again_timeout_handler(void) 769{ 770 net_set_state(NETLOOP_RESTART); 771} 772 773int net_start_again(void) 774{ 775 char *nretry; 776 int retry_forever = 0; 777 unsigned long retrycnt = 0; 778 int ret; 779 780 nretry = env_get("netretry"); 781 if (nretry) { 782 if (!strcmp(nretry, "yes")) 783 retry_forever = 1; 784 else if (!strcmp(nretry, "no")) 785 retrycnt = 0; 786 else if (!strcmp(nretry, "once")) 787 retrycnt = 1; 788 else 789 retrycnt = simple_strtoul(nretry, NULL, 0); 790 } else { 791 retrycnt = 0; 792 retry_forever = 0; 793 } 794 795 if ((!retry_forever) && (net_try_count > retrycnt)) { 796 eth_halt(); 797 net_set_state(NETLOOP_FAIL); 798 /* 799 * We don't provide a way for the protocol to return an error, 800 * but this is almost always the reason. 801 */ 802 return -ETIMEDOUT; 803 } 804 805 net_try_count++; 806 807 eth_halt(); 808#if !defined(CONFIG_NET_DO_NOT_TRY_ANOTHER) 809 eth_try_another(!net_restarted); 810#endif 811 ret = eth_init(); 812 if (net_restart_wrap) { 813 net_restart_wrap = 0; 814 if (net_dev_exists) { 815 net_set_timeout_handler(10000UL, 816 start_again_timeout_handler); 817 net_set_udp_handler(NULL); 818 } else { 819 net_set_state(NETLOOP_FAIL); 820 } 821 } else { 822 net_set_state(NETLOOP_RESTART); 823 } 824 return ret; 825} 826 827/**********************************************************************/ 828/* 829 * Miscelaneous bits. 830 */ 831 832static void dummy_handler(uchar *pkt, unsigned dport, 833 struct in_addr sip, unsigned sport, 834 unsigned len) 835{ 836} 837 838rxhand_f *net_get_udp_handler(void) 839{ 840 return udp_packet_handler; 841} 842 843void net_set_udp_handler(rxhand_f *f) 844{ 845 debug_cond(DEBUG_INT_STATE, "--- net_loop UDP handler set (%p)\n", f); 846 if (f == NULL) 847 udp_packet_handler = dummy_handler; 848 else 849 udp_packet_handler = f; 850} 851 852rxhand_f *net_get_arp_handler(void) 853{ 854 return arp_packet_handler; 855} 856 857void net_set_arp_handler(rxhand_f *f) 858{ 859 debug_cond(DEBUG_INT_STATE, "--- net_loop ARP handler set (%p)\n", f); 860 if (f == NULL) 861 arp_packet_handler = dummy_handler; 862 else 863 arp_packet_handler = f; 864} 865 866#ifdef CONFIG_CMD_TFTPPUT 867void net_set_icmp_handler(rxhand_icmp_f *f) 868{ 869 packet_icmp_handler = f; 870} 871#endif 872 873void net_set_timeout_handler(ulong iv, thand_f *f) 874{ 875 if (iv == 0) { 876 debug_cond(DEBUG_INT_STATE, 877 "--- net_loop timeout handler cancelled\n"); 878 time_handler = (thand_f *)0; 879 } else { 880 debug_cond(DEBUG_INT_STATE, 881 "--- net_loop timeout handler set (%p)\n", f); 882 time_handler = f; 883 time_start = get_timer(0); 884 time_delta = iv * CONFIG_SYS_HZ / 1000; 885 } 886} 887 888uchar *net_get_async_tx_pkt_buf(void) 889{ 890 if (arp_is_waiting()) 891 return arp_tx_packet; /* If we are waiting, we already sent */ 892 else 893 return net_tx_packet; 894} 895 896int net_send_udp_packet(uchar *ether, struct in_addr dest, int dport, int sport, 897 int payload_len) 898{ 899 return net_send_ip_packet(ether, dest, dport, sport, payload_len, 900 IPPROTO_UDP, 0, 0, 0); 901} 902 903#if defined(CONFIG_PROT_TCP) 904int net_send_tcp_packet(int payload_len, int dport, int sport, u8 action, 905 u32 tcp_seq_num, u32 tcp_ack_num) 906{ 907 return net_send_ip_packet(net_server_ethaddr, net_server_ip, dport, 908 sport, payload_len, IPPROTO_TCP, action, 909 tcp_seq_num, tcp_ack_num); 910} 911#endif 912 913int net_send_ip_packet(uchar *ether, struct in_addr dest, int dport, int sport, 914 int payload_len, int proto, u8 action, u32 tcp_seq_num, 915 u32 tcp_ack_num) 916{ 917 uchar *pkt; 918 int eth_hdr_size; 919 int pkt_hdr_size; 920 921 /* make sure the net_tx_packet is initialized (net_init() was called) */ 922 assert(net_tx_packet != NULL); 923 if (net_tx_packet == NULL) 924 return -1; 925 926 /* convert to new style broadcast */ 927 if (dest.s_addr == 0) 928 dest.s_addr = 0xFFFFFFFF; 929 930 /* if broadcast, make the ether address a broadcast and don't do ARP */ 931 if (dest.s_addr == 0xFFFFFFFF) 932 ether = (uchar *)net_bcast_ethaddr; 933 934 pkt = (uchar *)net_tx_packet; 935 936 eth_hdr_size = net_set_ether(pkt, ether, PROT_IP); 937 938 switch (proto) { 939 case IPPROTO_UDP: 940 net_set_udp_header(pkt + eth_hdr_size, dest, dport, sport, 941 payload_len); 942 pkt_hdr_size = eth_hdr_size + IP_UDP_HDR_SIZE; 943 break; 944#if defined(CONFIG_PROT_TCP) 945 case IPPROTO_TCP: 946 pkt_hdr_size = eth_hdr_size 947 + tcp_set_tcp_header(pkt + eth_hdr_size, dport, sport, 948 payload_len, action, tcp_seq_num, 949 tcp_ack_num); 950 break; 951#endif 952 default: 953 return -EINVAL; 954 } 955 956 /* if MAC address was not discovered yet, do an ARP request */ 957 if (memcmp(ether, net_null_ethaddr, 6) == 0) { 958 debug_cond(DEBUG_DEV_PKT, "sending ARP for %pI4\n", &dest); 959 960 /* save the ip and eth addr for the packet to send after arp */ 961 net_arp_wait_packet_ip = dest; 962 arp_wait_packet_ethaddr = ether; 963 964 /* size of the waiting packet */ 965 arp_wait_tx_packet_size = pkt_hdr_size + payload_len; 966 967 /* and do the ARP request */ 968 arp_wait_try = 1; 969 arp_wait_timer_start = get_timer(0); 970 arp_request(); 971 return 1; /* waiting */ 972 } else { 973 debug_cond(DEBUG_DEV_PKT, "sending UDP to %pI4/%pM\n", 974 &dest, ether); 975 net_send_packet(net_tx_packet, pkt_hdr_size + payload_len); 976 return 0; /* transmitted */ 977 } 978} 979 980#ifdef CONFIG_IP_DEFRAG 981/* 982 * This function collects fragments in a single packet, according 983 * to the algorithm in RFC815. It returns NULL or the pointer to 984 * a complete packet, in static storage 985 */ 986#define IP_PKTSIZE (CONFIG_NET_MAXDEFRAG) 987 988#define IP_MAXUDP (IP_PKTSIZE - IP_HDR_SIZE) 989 990/* 991 * this is the packet being assembled, either data or frag control. 992 * Fragments go by 8 bytes, so this union must be 8 bytes long 993 */ 994struct hole { 995 /* first_byte is address of this structure */ 996 u16 last_byte; /* last byte in this hole + 1 (begin of next hole) */ 997 u16 next_hole; /* index of next (in 8-b blocks), 0 == none */ 998 u16 prev_hole; /* index of prev, 0 == none */ 999 u16 unused; 1000}; 1001 1002static struct ip_udp_hdr *__net_defragment(struct ip_udp_hdr *ip, int *lenp) 1003{ 1004 static uchar pkt_buff[IP_PKTSIZE] __aligned(PKTALIGN); 1005 static u16 first_hole, total_len; 1006 struct hole *payload, *thisfrag, *h, *newh; 1007 struct ip_udp_hdr *localip = (struct ip_udp_hdr *)pkt_buff; 1008 uchar *indata = (uchar *)ip; 1009 int offset8, start, len, done = 0; 1010 u16 ip_off = ntohs(ip->ip_off); 1011 1012 /* 1013 * Calling code already rejected <, but we don't have to deal 1014 * with an IP fragment with no payload. 1015 */ 1016 if (ntohs(ip->ip_len) <= IP_HDR_SIZE) 1017 return NULL; 1018 1019 /* payload starts after IP header, this fragment is in there */ 1020 payload = (struct hole *)(pkt_buff + IP_HDR_SIZE); 1021 offset8 = (ip_off & IP_OFFS); 1022 thisfrag = payload + offset8; 1023 start = offset8 * 8; 1024 len = ntohs(ip->ip_len) - IP_HDR_SIZE; 1025 1026 /* All but last fragment must have a multiple-of-8 payload. */ 1027 if ((len & 7) && (ip_off & IP_FLAGS_MFRAG)) 1028 return NULL; 1029 1030 if (start + len > IP_MAXUDP) /* fragment extends too far */ 1031 return NULL; 1032 1033 if (!total_len || localip->ip_id != ip->ip_id) { 1034 /* new (or different) packet, reset structs */ 1035 total_len = 0xffff; 1036 payload[0].last_byte = ~0; 1037 payload[0].next_hole = 0; 1038 payload[0].prev_hole = 0; 1039 first_hole = 0; 1040 /* any IP header will work, copy the first we received */ 1041 memcpy(localip, ip, IP_HDR_SIZE); 1042 } 1043 1044 /* 1045 * What follows is the reassembly algorithm. We use the payload 1046 * array as a linked list of hole descriptors, as each hole starts 1047 * at a multiple of 8 bytes. However, last byte can be whatever value, 1048 * so it is represented as byte count, not as 8-byte blocks. 1049 */ 1050 1051 h = payload + first_hole; 1052 while (h->last_byte < start) { 1053 if (!h->next_hole) { 1054 /* no hole that far away */ 1055 return NULL; 1056 } 1057 h = payload + h->next_hole; 1058 } 1059 1060 /* last fragment may be 1..7 bytes, the "+7" forces acceptance */ 1061 if (offset8 + ((len + 7) / 8) <= h - payload) { 1062 /* no overlap with holes (dup fragment?) */ 1063 return NULL; 1064 } 1065 1066 if (!(ip_off & IP_FLAGS_MFRAG)) { 1067 /* no more fragmentss: truncate this (last) hole */ 1068 total_len = start + len; 1069 h->last_byte = start + len; 1070 } 1071 1072 /* 1073 * There is some overlap: fix the hole list. This code deals 1074 * with a fragment that overlaps with two different holes 1075 * (thus being a superset of a previously-received fragment) 1076 * by only using the part of the fragment that fits in the 1077 * first hole. 1078 */ 1079 if (h->last_byte < start + len) 1080 len = h->last_byte - start; 1081 1082 if ((h >= thisfrag) && (h->last_byte <= start + len)) { 1083 /* complete overlap with hole: remove hole */ 1084 if (!h->prev_hole && !h->next_hole) { 1085 /* last remaining hole */ 1086 done = 1; 1087 } else if (!h->prev_hole) { 1088 /* first hole */ 1089 first_hole = h->next_hole; 1090 payload[h->next_hole].prev_hole = 0; 1091 } else if (!h->next_hole) { 1092 /* last hole */ 1093 payload[h->prev_hole].next_hole = 0; 1094 } else { 1095 /* in the middle of the list */ 1096 payload[h->next_hole].prev_hole = h->prev_hole; 1097 payload[h->prev_hole].next_hole = h->next_hole; 1098 } 1099 1100 } else if (h->last_byte <= start + len) { 1101 /* overlaps with final part of the hole: shorten this hole */ 1102 h->last_byte = start; 1103 1104 } else if (h >= thisfrag) { 1105 /* overlaps with initial part of the hole: move this hole */ 1106 newh = thisfrag + (len / 8); 1107 *newh = *h; 1108 h = newh; 1109 if (h->next_hole) 1110 payload[h->next_hole].prev_hole = (h - payload); 1111 if (h->prev_hole) 1112 payload[h->prev_hole].next_hole = (h - payload); 1113 else 1114 first_hole = (h - payload); 1115 1116 } else { 1117 /* fragment sits in the middle: split the hole */ 1118 newh = thisfrag + (len / 8); 1119 *newh = *h; 1120 h->last_byte = start; 1121 h->next_hole = (newh - payload); 1122 newh->prev_hole = (h - payload); 1123 if (newh->next_hole) 1124 payload[newh->next_hole].prev_hole = (newh - payload); 1125 } 1126 1127 /* finally copy this fragment and possibly return whole packet */ 1128 memcpy((uchar *)thisfrag, indata + IP_HDR_SIZE, len); 1129 if (!done) 1130 return NULL; 1131 1132 *lenp = total_len + IP_HDR_SIZE; 1133 localip->ip_len = htons(*lenp); 1134 return localip; 1135} 1136 1137static inline struct ip_udp_hdr *net_defragment(struct ip_udp_hdr *ip, 1138 int *lenp) 1139{ 1140 u16 ip_off = ntohs(ip->ip_off); 1141 if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG))) 1142 return ip; /* not a fragment */ 1143 return __net_defragment(ip, lenp); 1144} 1145 1146#else /* !CONFIG_IP_DEFRAG */ 1147 1148static inline struct ip_udp_hdr *net_defragment(struct ip_udp_hdr *ip, 1149 int *lenp) 1150{ 1151 u16 ip_off = ntohs(ip->ip_off); 1152 if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG))) 1153 return ip; /* not a fragment */ 1154 return NULL; 1155} 1156#endif 1157 1158/** 1159 * Receive an ICMP packet. We deal with REDIRECT and PING here, and silently 1160 * drop others. 1161 * 1162 * @parma ip IP packet containing the ICMP 1163 */ 1164static void receive_icmp(struct ip_udp_hdr *ip, int len, 1165 struct in_addr src_ip, struct ethernet_hdr *et) 1166{ 1167 struct icmp_hdr *icmph = (struct icmp_hdr *)&ip->udp_src; 1168 1169 switch (icmph->type) { 1170 case ICMP_REDIRECT: 1171 if (icmph->code != ICMP_REDIR_HOST) 1172 return; 1173 printf(" ICMP Host Redirect to %pI4 ", 1174 &icmph->un.gateway); 1175 break; 1176 default: 1177#if defined(CONFIG_CMD_PING) 1178 ping_receive(et, ip, len); 1179#endif 1180#ifdef CONFIG_CMD_TFTPPUT 1181 if (packet_icmp_handler) 1182 packet_icmp_handler(icmph->type, icmph->code, 1183 ntohs(ip->udp_dst), src_ip, 1184 ntohs(ip->udp_src), icmph->un.data, 1185 ntohs(ip->udp_len)); 1186#endif 1187 break; 1188 } 1189} 1190 1191void net_process_received_packet(uchar *in_packet, int len) 1192{ 1193 struct ethernet_hdr *et; 1194 struct ip_udp_hdr *ip; 1195 struct in_addr dst_ip; 1196 struct in_addr src_ip; 1197 int eth_proto; 1198#if defined(CONFIG_CMD_CDP) 1199 int iscdp; 1200#endif 1201 ushort cti = 0, vlanid = VLAN_NONE, myvlanid, mynvlanid; 1202 1203 debug_cond(DEBUG_NET_PKT, "packet received\n"); 1204 if (DEBUG_NET_PKT_TRACE) 1205 print_hex_dump_bytes("rx: ", DUMP_PREFIX_OFFSET, in_packet, 1206 len); 1207 1208#if defined(CONFIG_CMD_PCAP) 1209 pcap_post(in_packet, len, false); 1210#endif 1211 net_rx_packet = in_packet; 1212 net_rx_packet_len = len; 1213 et = (struct ethernet_hdr *)in_packet; 1214 1215 /* too small packet? */ 1216 if (len < ETHER_HDR_SIZE) 1217 return; 1218 1219#if defined(CONFIG_API) || defined(CONFIG_EFI_LOADER) 1220 if (push_packet) { 1221 (*push_packet)(in_packet, len); 1222 return; 1223 } 1224#endif 1225 1226#if defined(CONFIG_CMD_CDP) 1227 /* keep track if packet is CDP */ 1228 iscdp = is_cdp_packet(et->et_dest); 1229#endif 1230 1231 myvlanid = ntohs(net_our_vlan); 1232 if (myvlanid == (ushort)-1) 1233 myvlanid = VLAN_NONE; 1234 mynvlanid = ntohs(net_native_vlan); 1235 if (mynvlanid == (ushort)-1) 1236 mynvlanid = VLAN_NONE; 1237 1238 eth_proto = ntohs(et->et_protlen); 1239 1240 if (eth_proto < 1514) { 1241 struct e802_hdr *et802 = (struct e802_hdr *)et; 1242 /* 1243 * Got a 802.2 packet. Check the other protocol field. 1244 * XXX VLAN over 802.2+SNAP not implemented! 1245 */ 1246 eth_proto = ntohs(et802->et_prot); 1247 1248 ip = (struct ip_udp_hdr *)(in_packet + E802_HDR_SIZE); 1249 len -= E802_HDR_SIZE; 1250 1251 } else if (eth_proto != PROT_VLAN) { /* normal packet */ 1252 ip = (struct ip_udp_hdr *)(in_packet + ETHER_HDR_SIZE); 1253 len -= ETHER_HDR_SIZE; 1254 1255 } else { /* VLAN packet */ 1256 struct vlan_ethernet_hdr *vet = 1257 (struct vlan_ethernet_hdr *)et; 1258 1259 debug_cond(DEBUG_NET_PKT, "VLAN packet received\n"); 1260 1261 /* too small packet? */ 1262 if (len < VLAN_ETHER_HDR_SIZE) 1263 return; 1264 1265 /* if no VLAN active */ 1266 if ((ntohs(net_our_vlan) & VLAN_IDMASK) == VLAN_NONE 1267#if defined(CONFIG_CMD_CDP) 1268 && iscdp == 0 1269#endif 1270 ) 1271 return; 1272 1273 cti = ntohs(vet->vet_tag); 1274 vlanid = cti & VLAN_IDMASK; 1275 eth_proto = ntohs(vet->vet_type); 1276 1277 ip = (struct ip_udp_hdr *)(in_packet + VLAN_ETHER_HDR_SIZE); 1278 len -= VLAN_ETHER_HDR_SIZE; 1279 } 1280 1281 debug_cond(DEBUG_NET_PKT, "Receive from protocol 0x%x\n", eth_proto); 1282 1283#if defined(CONFIG_CMD_CDP) 1284 if (iscdp) { 1285 cdp_receive((uchar *)ip, len); 1286 return; 1287 } 1288#endif 1289 1290 if ((myvlanid & VLAN_IDMASK) != VLAN_NONE) { 1291 if (vlanid == VLAN_NONE) 1292 vlanid = (mynvlanid & VLAN_IDMASK); 1293 /* not matched? */ 1294 if (vlanid != (myvlanid & VLAN_IDMASK)) 1295 return; 1296 } 1297 1298 switch (eth_proto) { 1299 case PROT_ARP: 1300 arp_receive(et, ip, len); 1301 break; 1302 1303#ifdef CONFIG_CMD_RARP 1304 case PROT_RARP: 1305 rarp_receive(ip, len); 1306 break; 1307#endif 1308#if IS_ENABLED(CONFIG_IPV6) 1309 case PROT_IP6: 1310 net_ip6_handler(et, (struct ip6_hdr *)ip, len); 1311 break; 1312#endif 1313 case PROT_IP: 1314 debug_cond(DEBUG_NET_PKT, "Got IP\n"); 1315 /* Before we start poking the header, make sure it is there */ 1316 if (len < IP_HDR_SIZE) { 1317 debug("len bad %d < %lu\n", len, 1318 (ulong)IP_HDR_SIZE); 1319 return; 1320 } 1321 /* Check the packet length */ 1322 if (len < ntohs(ip->ip_len)) { 1323 debug("len bad %d < %d\n", len, ntohs(ip->ip_len)); 1324 return; 1325 } 1326 len = ntohs(ip->ip_len); 1327 if (len < IP_HDR_SIZE) { 1328 debug("bad ip->ip_len %d < %d\n", len, (int)IP_HDR_SIZE); 1329 return; 1330 } 1331 debug_cond(DEBUG_NET_PKT, "len=%d, v=%02x\n", 1332 len, ip->ip_hl_v & 0xff); 1333 1334 /* Can't deal with anything except IPv4 */ 1335 if ((ip->ip_hl_v & 0xf0) != 0x40) 1336 return; 1337 /* Can't deal with IP options (headers != 20 bytes) */ 1338 if ((ip->ip_hl_v & 0x0f) != 0x05) 1339 return; 1340 /* Check the Checksum of the header */ 1341 if (!ip_checksum_ok((uchar *)ip, IP_HDR_SIZE)) { 1342 debug("checksum bad\n"); 1343 return; 1344 } 1345 /* If it is not for us, ignore it */ 1346 dst_ip = net_read_ip(&ip->ip_dst); 1347 if (net_ip.s_addr && dst_ip.s_addr != net_ip.s_addr && 1348 dst_ip.s_addr != 0xFFFFFFFF) { 1349 return; 1350 } 1351 /* Read source IP address for later use */ 1352 src_ip = net_read_ip(&ip->ip_src); 1353 /* 1354 * The function returns the unchanged packet if it's not 1355 * a fragment, and either the complete packet or NULL if 1356 * it is a fragment (if !CONFIG_IP_DEFRAG, it returns NULL) 1357 */ 1358 ip = net_defragment(ip, &len); 1359 if (!ip) 1360 return; 1361 /* 1362 * watch for ICMP host redirects 1363 * 1364 * There is no real handler code (yet). We just watch 1365 * for ICMP host redirect messages. In case anybody 1366 * sees these messages: please contact me 1367 * (wd@denx.de), or - even better - send me the 1368 * necessary fixes :-) 1369 * 1370 * Note: in all cases where I have seen this so far 1371 * it was a problem with the router configuration, 1372 * for instance when a router was configured in the 1373 * BOOTP reply, but the TFTP server was on the same 1374 * subnet. So this is probably a warning that your 1375 * configuration might be wrong. But I'm not really 1376 * sure if there aren't any other situations. 1377 * 1378 * Simon Glass <sjg@chromium.org>: We get an ICMP when 1379 * we send a tftp packet to a dead connection, or when 1380 * there is no server at the other end. 1381 */ 1382 if (ip->ip_p == IPPROTO_ICMP) { 1383 receive_icmp(ip, len, src_ip, et); 1384 return; 1385#if defined(CONFIG_PROT_TCP) 1386 } else if (ip->ip_p == IPPROTO_TCP) { 1387 debug_cond(DEBUG_DEV_PKT, 1388 "TCP PH (to=%pI4, from=%pI4, len=%d)\n", 1389 &dst_ip, &src_ip, len); 1390 1391 rxhand_tcp_f((union tcp_build_pkt *)ip, len); 1392 return; 1393#endif 1394 } else if (ip->ip_p != IPPROTO_UDP) { /* Only UDP packets */ 1395 return; 1396 } 1397 1398 if (ntohs(ip->udp_len) < UDP_HDR_SIZE || ntohs(ip->udp_len) > len - IP_HDR_SIZE) 1399 return; 1400 1401 debug_cond(DEBUG_DEV_PKT, 1402 "received UDP (to=%pI4, from=%pI4, len=%d)\n", 1403 &dst_ip, &src_ip, len); 1404 1405 if (IS_ENABLED(CONFIG_UDP_CHECKSUM) && ip->udp_xsum != 0) { 1406 ulong xsum; 1407 u8 *sumptr; 1408 ushort sumlen; 1409 1410 xsum = ip->ip_p; 1411 xsum += (ntohs(ip->udp_len)); 1412 xsum += (ntohl(ip->ip_src.s_addr) >> 16) & 0x0000ffff; 1413 xsum += (ntohl(ip->ip_src.s_addr) >> 0) & 0x0000ffff; 1414 xsum += (ntohl(ip->ip_dst.s_addr) >> 16) & 0x0000ffff; 1415 xsum += (ntohl(ip->ip_dst.s_addr) >> 0) & 0x0000ffff; 1416 1417 sumlen = ntohs(ip->udp_len); 1418 sumptr = (u8 *)&ip->udp_src; 1419 1420 while (sumlen > 1) { 1421 /* inlined ntohs() to avoid alignment errors */ 1422 xsum += (sumptr[0] << 8) + sumptr[1]; 1423 sumptr += 2; 1424 sumlen -= 2; 1425 } 1426 if (sumlen > 0) 1427 xsum += (sumptr[0] << 8) + sumptr[0]; 1428 while ((xsum >> 16) != 0) { 1429 xsum = (xsum & 0x0000ffff) + 1430 ((xsum >> 16) & 0x0000ffff); 1431 } 1432 if ((xsum != 0x00000000) && (xsum != 0x0000ffff)) { 1433 printf(" UDP wrong checksum %08lx %08x\n", 1434 xsum, ntohs(ip->udp_xsum)); 1435 return; 1436 } 1437 } 1438 1439#if defined(CONFIG_NETCONSOLE) && !defined(CONFIG_SPL_BUILD) 1440 nc_input_packet((uchar *)ip + IP_UDP_HDR_SIZE, 1441 src_ip, 1442 ntohs(ip->udp_dst), 1443 ntohs(ip->udp_src), 1444 ntohs(ip->udp_len) - UDP_HDR_SIZE); 1445#endif 1446 /* 1447 * IP header OK. Pass the packet to the current handler. 1448 */ 1449 (*udp_packet_handler)((uchar *)ip + IP_UDP_HDR_SIZE, 1450 ntohs(ip->udp_dst), 1451 src_ip, 1452 ntohs(ip->udp_src), 1453 ntohs(ip->udp_len) - UDP_HDR_SIZE); 1454 break; 1455#ifdef CONFIG_CMD_WOL 1456 case PROT_WOL: 1457 wol_receive(ip, len); 1458 break; 1459#endif 1460#ifdef CONFIG_PHY_NCSI 1461 case PROT_NCSI: 1462 ncsi_receive(et, ip, len); 1463 break; 1464#endif 1465 } 1466} 1467 1468/**********************************************************************/ 1469 1470static int net_check_prereq(enum proto_t protocol) 1471{ 1472 switch (protocol) { 1473 /* Fall through */ 1474#if defined(CONFIG_CMD_PING) 1475 case PING: 1476 if (net_ping_ip.s_addr == 0) { 1477 puts("*** ERROR: ping address not given\n"); 1478 return 1; 1479 } 1480 goto common; 1481#endif 1482#if defined(CONFIG_CMD_PING6) 1483 case PING6: 1484 if (ip6_is_unspecified_addr(&net_ping_ip6)) { 1485 puts("*** ERROR: ping address not given\n"); 1486 return 1; 1487 } 1488 goto common; 1489#endif 1490#if defined(CONFIG_CMD_DNS) 1491 case DNS: 1492 if (net_dns_server.s_addr == 0) { 1493 puts("*** ERROR: DNS server address not given\n"); 1494 return 1; 1495 } 1496 goto common; 1497#endif 1498#if defined(CONFIG_PROT_UDP) 1499 case UDP: 1500 if (udp_prereq()) 1501 return 1; 1502 goto common; 1503#endif 1504 1505#if defined(CONFIG_CMD_NFS) 1506 case NFS: 1507#endif 1508 /* Fall through */ 1509 case TFTPGET: 1510 case TFTPPUT: 1511 if (IS_ENABLED(CONFIG_IPV6) && use_ip6) { 1512 if (!memcmp(&net_server_ip6, &net_null_addr_ip6, 1513 sizeof(struct in6_addr)) && 1514 !strchr(net_boot_file_name, '[')) { 1515 puts("*** ERROR: `serverip6' not set\n"); 1516 return 1; 1517 } 1518 } else if (net_server_ip.s_addr == 0 && !is_serverip_in_cmd()) { 1519 puts("*** ERROR: `serverip' not set\n"); 1520 return 1; 1521 } 1522#if defined(CONFIG_CMD_PING) || \ 1523 defined(CONFIG_CMD_DNS) || defined(CONFIG_PROT_UDP) 1524common: 1525#endif 1526 /* Fall through */ 1527 1528 case NETCONS: 1529 case FASTBOOT_UDP: 1530 case FASTBOOT_TCP: 1531 case TFTPSRV: 1532 if (IS_ENABLED(CONFIG_IPV6) && use_ip6) { 1533 if (!memcmp(&net_link_local_ip6, &net_null_addr_ip6, 1534 sizeof(struct in6_addr))) { 1535 puts("*** ERROR: `ip6addr` not set\n"); 1536 return 1; 1537 } 1538 } else if (net_ip.s_addr == 0) { 1539 puts("*** ERROR: `ipaddr' not set\n"); 1540 return 1; 1541 } 1542 /* Fall through */ 1543 1544#ifdef CONFIG_CMD_RARP 1545 case RARP: 1546#endif 1547#ifdef CONFIG_PHY_NCSI 1548 case NCSI: 1549#endif 1550 case BOOTP: 1551 case CDP: 1552 case DHCP: 1553 case LINKLOCAL: 1554 if (memcmp(net_ethaddr, "\0\0\0\0\0\0", 6) == 0) { 1555 int num = eth_get_dev_index(); 1556 1557 switch (num) { 1558 case -1: 1559 puts("*** ERROR: No ethernet found.\n"); 1560 return 1; 1561 case 0: 1562 puts("*** ERROR: `ethaddr' not set\n"); 1563 break; 1564 default: 1565 printf("*** ERROR: `eth%daddr' not set\n", 1566 num); 1567 break; 1568 } 1569 1570 net_start_again(); 1571 return 2; 1572 } 1573 /* Fall through */ 1574 default: 1575 return 0; 1576 } 1577 return 0; /* OK */ 1578} 1579/**********************************************************************/ 1580 1581int 1582net_eth_hdr_size(void) 1583{ 1584 ushort myvlanid; 1585 1586 myvlanid = ntohs(net_our_vlan); 1587 if (myvlanid == (ushort)-1) 1588 myvlanid = VLAN_NONE; 1589 1590 return ((myvlanid & VLAN_IDMASK) == VLAN_NONE) ? ETHER_HDR_SIZE : 1591 VLAN_ETHER_HDR_SIZE; 1592} 1593 1594int net_set_ether(uchar *xet, const uchar *dest_ethaddr, uint prot) 1595{ 1596 struct ethernet_hdr *et = (struct ethernet_hdr *)xet; 1597 ushort myvlanid; 1598 1599 myvlanid = ntohs(net_our_vlan); 1600 if (myvlanid == (ushort)-1) 1601 myvlanid = VLAN_NONE; 1602 1603 memcpy(et->et_dest, dest_ethaddr, 6); 1604 memcpy(et->et_src, net_ethaddr, 6); 1605 if ((myvlanid & VLAN_IDMASK) == VLAN_NONE) { 1606 et->et_protlen = htons(prot); 1607 return ETHER_HDR_SIZE; 1608 } else { 1609 struct vlan_ethernet_hdr *vet = 1610 (struct vlan_ethernet_hdr *)xet; 1611 1612 vet->vet_vlan_type = htons(PROT_VLAN); 1613 vet->vet_tag = htons((0 << 5) | (myvlanid & VLAN_IDMASK)); 1614 vet->vet_type = htons(prot); 1615 return VLAN_ETHER_HDR_SIZE; 1616 } 1617} 1618 1619int net_update_ether(struct ethernet_hdr *et, uchar *addr, uint prot) 1620{ 1621 ushort protlen; 1622 1623 memcpy(et->et_dest, addr, 6); 1624 memcpy(et->et_src, net_ethaddr, 6); 1625 protlen = ntohs(et->et_protlen); 1626 if (protlen == PROT_VLAN) { 1627 struct vlan_ethernet_hdr *vet = 1628 (struct vlan_ethernet_hdr *)et; 1629 vet->vet_type = htons(prot); 1630 return VLAN_ETHER_HDR_SIZE; 1631 } else if (protlen > 1514) { 1632 et->et_protlen = htons(prot); 1633 return ETHER_HDR_SIZE; 1634 } else { 1635 /* 802.2 + SNAP */ 1636 struct e802_hdr *et802 = (struct e802_hdr *)et; 1637 et802->et_prot = htons(prot); 1638 return E802_HDR_SIZE; 1639 } 1640} 1641 1642void net_set_ip_header(uchar *pkt, struct in_addr dest, struct in_addr source, 1643 u16 pkt_len, u8 proto) 1644{ 1645 struct ip_udp_hdr *ip = (struct ip_udp_hdr *)pkt; 1646 1647 /* 1648 * Construct an IP header. 1649 */ 1650 /* IP_HDR_SIZE / 4 (not including UDP) */ 1651 ip->ip_hl_v = 0x45; 1652 ip->ip_tos = 0; 1653 ip->ip_len = htons(pkt_len); 1654 ip->ip_p = proto; 1655 ip->ip_id = htons(net_ip_id++); 1656 ip->ip_off = htons(IP_FLAGS_DFRAG); /* Don't fragment */ 1657 ip->ip_ttl = 255; 1658 ip->ip_sum = 0; 1659 /* already in network byte order */ 1660 net_copy_ip((void *)&ip->ip_src, &source); 1661 /* already in network byte order */ 1662 net_copy_ip((void *)&ip->ip_dst, &dest); 1663 1664 ip->ip_sum = compute_ip_checksum(ip, IP_HDR_SIZE); 1665} 1666 1667void net_set_udp_header(uchar *pkt, struct in_addr dest, int dport, int sport, 1668 int len) 1669{ 1670 struct ip_udp_hdr *ip = (struct ip_udp_hdr *)pkt; 1671 1672 /* 1673 * If the data is an odd number of bytes, zero the 1674 * byte after the last byte so that the checksum 1675 * will work. 1676 */ 1677 if (len & 1) 1678 pkt[IP_UDP_HDR_SIZE + len] = 0; 1679 1680 net_set_ip_header(pkt, dest, net_ip, IP_UDP_HDR_SIZE + len, 1681 IPPROTO_UDP); 1682 1683 ip->udp_src = htons(sport); 1684 ip->udp_dst = htons(dport); 1685 ip->udp_len = htons(UDP_HDR_SIZE + len); 1686 ip->udp_xsum = 0; 1687} 1688 1689void copy_filename(char *dst, const char *src, int size) 1690{ 1691 if (src && *src && (*src == '"')) { 1692 ++src; 1693 --size; 1694 } 1695 1696 while ((--size > 0) && src && *src && (*src != '"')) 1697 *dst++ = *src++; 1698 *dst = '\0'; 1699} 1700 1701int is_serverip_in_cmd(void) 1702{ 1703 return !!strchr(net_boot_file_name, ':'); 1704} 1705 1706int net_parse_bootfile(struct in_addr *ipaddr, char *filename, int max_len) 1707{ 1708 char *colon; 1709 struct in_addr ip; 1710 ip.s_addr = 0; 1711 1712 if (net_boot_file_name[0] == '\0') 1713 return 0; 1714 1715 colon = strchr(net_boot_file_name, ':'); 1716 if (colon) { 1717 ip = string_to_ip(net_boot_file_name); 1718 if (ipaddr && ip.s_addr) 1719 *ipaddr = ip; 1720 } 1721 if (ip.s_addr) { 1722 strncpy(filename, colon + 1, max_len); 1723 } else { 1724 strncpy(filename, net_boot_file_name, max_len); 1725 } 1726 filename[max_len - 1] = '\0'; 1727 1728 return 1; 1729} 1730 1731void ip_to_string(struct in_addr x, char *s) 1732{ 1733 x.s_addr = ntohl(x.s_addr); 1734 sprintf(s, "%d.%d.%d.%d", 1735 (int) ((x.s_addr >> 24) & 0xff), 1736 (int) ((x.s_addr >> 16) & 0xff), 1737 (int) ((x.s_addr >> 8) & 0xff), 1738 (int) ((x.s_addr >> 0) & 0xff) 1739 ); 1740} 1741 1742void vlan_to_string(ushort x, char *s) 1743{ 1744 x = ntohs(x); 1745 1746 if (x == (ushort)-1) 1747 x = VLAN_NONE; 1748 1749 if (x == VLAN_NONE) 1750 strcpy(s, "none"); 1751 else 1752 sprintf(s, "%d", x & VLAN_IDMASK); 1753} 1754 1755ushort string_to_vlan(const char *s) 1756{ 1757 ushort id; 1758 1759 if (s == NULL) 1760 return htons(VLAN_NONE); 1761 1762 if (*s < '0' || *s > '9') 1763 id = VLAN_NONE; 1764 else 1765 id = (ushort)dectoul(s, NULL); 1766 1767 return htons(id); 1768} 1769 1770ushort env_get_vlan(char *var) 1771{ 1772 return string_to_vlan(env_get(var)); 1773} 1774