net/net.c

   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) */
 132 struct in_addr net_netmask;
 133 /* Our gateways IP address */
 134 struct in_addr net_gateway;
 135 /* Our DNS IP address */
 136 struct in_addr net_dns_server;
 137 #if defined(CONFIG_BOOTP_DNS2)
 138 /* Our 2nd DNS IP address */
 139 struct in_addr net_dns_server2;
 140 #endif
 141 /* Indicates whether the pxe path prefix / config file was specified in dhcp option */
 142 char *pxelinux_configfile;
 143
 144 /** END OF BOOTP EXTENTIONS **/
 145
 146 /* Our ethernet address */
 147 u8 net_ethaddr[6];
 148 /* Boot server enet address */
 149 u8 net_server_ethaddr[6];
 150 /* Our IP addr (0 = unknown) */
 151 struct in_addr  net_ip;
 152 /* Server IP addr (0 = unknown) */
 153 struct in_addr  net_server_ip;
 154 /* Current receive packet */
 155 uchar *net_rx_packet;
 156 /* Current rx packet length */
 157 int             net_rx_packet_len;
 158 /* IP packet ID */
 159 static unsigned net_ip_id;
 160 /* Ethernet bcast address */
 161 const u8 net_bcast_ethaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 162 const u8 net_null_ethaddr[6];
 163 #if defined(CONFIG_API) || defined(CONFIG_EFI_LOADER)
 164 void (*push_packet)(void *, int len) = 0;
 165 #endif
 166 /* Network loop state */
 167 enum net_loop_state net_state;
 168 /* Tried all network devices */
 169 int             net_restart_wrap;
 170 /* Network loop restarted */
 171 static int      net_restarted;
 172 /* At least one device configured */
 173 static int      net_dev_exists;
 174
 175 /* XXX in both little & big endian machines 0xFFFF == ntohs(-1) */
 176 /* default is without VLAN */
 177 ushort          net_our_vlan = 0xFFFF;
 178 /* ditto */
 179 ushort          net_native_vlan = 0xFFFF;
 180
 181 /* Boot File name */
 182 char net_boot_file_name[1024];
 183 /* Indicates whether the file name was specified on the command line */
 184 bool net_boot_file_name_explicit;
 185 /* The actual transferred size of the bootfile (in bytes) */
 186 u32 net_boot_file_size;
 187 /* Boot file size in blocks as reported by the DHCP server */
 188 u32 net_boot_file_expected_size_in_blocks;
 189
 190 static uchar net_pkt_buf[(PKTBUFSRX+1) * PKTSIZE_ALIGN + PKTALIGN];
 191 /* Receive packets */
 192 uchar *net_rx_packets[PKTBUFSRX];
 193 /* Current UDP RX packet handler */
 194 static rxhand_f *udp_packet_handler;
 195 /* Current ARP RX packet handler */
 196 static rxhand_f *arp_packet_handler;
 197 #ifdef CONFIG_CMD_TFTPPUT
 198 /* Current ICMP rx handler */
 199 static rxhand_icmp_f *packet_icmp_handler;
 200 #endif
 201 /* Current timeout handler */
 202 static thand_f *time_handler;
 203 /* Time base value */
 204 static ulong    time_start;
 205 /* Current timeout value */
 206 static ulong    time_delta;
 207 /* THE transmit packet */
 208 uchar *net_tx_packet;
 209
 210 static int net_check_prereq(enum proto_t protocol);
 211
 212 static int net_try_count;
 213
 214 int __maybe_unused net_busy_flag;
 215
 216 /**********************************************************************/
 217
 218 static 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 }
 228 U_BOOT_ENV_CALLBACK(ipaddr, on_ipaddr);
 229
 230 static 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 }
 240 U_BOOT_ENV_CALLBACK(gatewayip, on_gatewayip);
 241
 242 static 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 }
 252 U_BOOT_ENV_CALLBACK(netmask, on_netmask);
 253
 254 static 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 }
 264 U_BOOT_ENV_CALLBACK(serverip, on_serverip);
 265
 266 static 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 }
 276 U_BOOT_ENV_CALLBACK(nvlan, on_nvlan);
 277
 278 static 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 }
 288 U_BOOT_ENV_CALLBACK(vlan, on_vlan);
 289
 290 #if defined(CONFIG_CMD_DNS)
 291 static 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 }
 301 U_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  */
 308 void 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
 352 static 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
 384 static 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
 391 static void net_cleanup_loop(void)
 392 {
 393         net_clear_handlers();
 394 }
 395
 396 int 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
 430 int 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
 468 restart:
 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 defined(CONFIG_UDP_FUNCTION_FASTBOOT)
 515                 case FASTBOOT_UDP:
 516                         fastboot_udp_start_server();
 517                         break;
 518 #endif
 519 #if defined(CONFIG_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 = %d (%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
 748 done:
 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
 768 static void start_again_timeout_handler(void)
 769 {
 770         net_set_state(NETLOOP_RESTART);
 771 }
 772
 773 int 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
 832 static void dummy_handler(uchar *pkt, unsigned dport,
 833                         struct in_addr sip, unsigned sport,
 834                         unsigned len)
 835 {
 836 }
 837
 838 rxhand_f *net_get_udp_handler(void)
 839 {
 840         return udp_packet_handler;
 841 }
 842
 843 void 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
 852 rxhand_f *net_get_arp_handler(void)
 853 {
 854         return arp_packet_handler;
 855 }
 856
 857 void 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
 867 void net_set_icmp_handler(rxhand_icmp_f *f)
 868 {
 869         packet_icmp_handler = f;
 870 }
 871 #endif
 872
 873 void 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
 888 uchar *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
 896 int 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)
 904 int 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
 913 int 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  */
 994 struct 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
1002 static 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
1137 static 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
1148 static 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  */
1164 static 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
1191 void 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
1205 #if defined(CONFIG_CMD_PCAP)
1206         pcap_post(in_packet, len, false);
1207 #endif
1208         net_rx_packet = in_packet;
1209         net_rx_packet_len = len;
1210         et = (struct ethernet_hdr *)in_packet;
1211
1212         /* too small packet? */
1213         if (len < ETHER_HDR_SIZE)
1214                 return;
1215
1216 #if defined(CONFIG_API) || defined(CONFIG_EFI_LOADER)
1217         if (push_packet) {
1218                 (*push_packet)(in_packet, len);
1219                 return;
1220         }
1221 #endif
1222
1223 #if defined(CONFIG_CMD_CDP)
1224         /* keep track if packet is CDP */
1225         iscdp = is_cdp_packet(et->et_dest);
1226 #endif
1227
1228         myvlanid = ntohs(net_our_vlan);
1229         if (myvlanid == (ushort)-1)
1230                 myvlanid = VLAN_NONE;
1231         mynvlanid = ntohs(net_native_vlan);
1232         if (mynvlanid == (ushort)-1)
1233                 mynvlanid = VLAN_NONE;
1234
1235         eth_proto = ntohs(et->et_protlen);
1236
1237         if (eth_proto < 1514) {
1238                 struct e802_hdr *et802 = (struct e802_hdr *)et;
1239                 /*
1240                  *      Got a 802.2 packet.  Check the other protocol field.
1241                  *      XXX VLAN over 802.2+SNAP not implemented!
1242                  */
1243                 eth_proto = ntohs(et802->et_prot);
1244
1245                 ip = (struct ip_udp_hdr *)(in_packet + E802_HDR_SIZE);
1246                 len -= E802_HDR_SIZE;
1247
1248         } else if (eth_proto != PROT_VLAN) {    /* normal packet */
1249                 ip = (struct ip_udp_hdr *)(in_packet + ETHER_HDR_SIZE);
1250                 len -= ETHER_HDR_SIZE;
1251
1252         } else {                        /* VLAN packet */
1253                 struct vlan_ethernet_hdr *vet =
1254                         (struct vlan_ethernet_hdr *)et;
1255
1256                 debug_cond(DEBUG_NET_PKT, "VLAN packet received\n");
1257
1258                 /* too small packet? */
1259                 if (len < VLAN_ETHER_HDR_SIZE)
1260                         return;
1261
1262                 /* if no VLAN active */
1263                 if ((ntohs(net_our_vlan) & VLAN_IDMASK) == VLAN_NONE
1264 #if defined(CONFIG_CMD_CDP)
1265                                 && iscdp == 0
1266 #endif
1267                                 )
1268                         return;
1269
1270                 cti = ntohs(vet->vet_tag);
1271                 vlanid = cti & VLAN_IDMASK;
1272                 eth_proto = ntohs(vet->vet_type);
1273
1274                 ip = (struct ip_udp_hdr *)(in_packet + VLAN_ETHER_HDR_SIZE);
1275                 len -= VLAN_ETHER_HDR_SIZE;
1276         }
1277
1278         debug_cond(DEBUG_NET_PKT, "Receive from protocol 0x%x\n", eth_proto);
1279
1280 #if defined(CONFIG_CMD_CDP)
1281         if (iscdp) {
1282                 cdp_receive((uchar *)ip, len);
1283                 return;
1284         }
1285 #endif
1286
1287         if ((myvlanid & VLAN_IDMASK) != VLAN_NONE) {
1288                 if (vlanid == VLAN_NONE)
1289                         vlanid = (mynvlanid & VLAN_IDMASK);
1290                 /* not matched? */
1291                 if (vlanid != (myvlanid & VLAN_IDMASK))
1292                         return;
1293         }
1294
1295         switch (eth_proto) {
1296         case PROT_ARP:
1297                 arp_receive(et, ip, len);
1298                 break;
1299
1300 #ifdef CONFIG_CMD_RARP
1301         case PROT_RARP:
1302                 rarp_receive(ip, len);
1303                 break;
1304 #endif
1305 #if IS_ENABLED(CONFIG_IPV6)
1306         case PROT_IP6:
1307                 net_ip6_handler(et, (struct ip6_hdr *)ip, len);
1308                 break;
1309 #endif
1310         case PROT_IP:
1311                 debug_cond(DEBUG_NET_PKT, "Got IP\n");
1312                 /* Before we start poking the header, make sure it is there */
1313                 if (len < IP_HDR_SIZE) {
1314                         debug("len bad %d < %lu\n", len,
1315                               (ulong)IP_HDR_SIZE);
1316                         return;
1317                 }
1318                 /* Check the packet length */
1319                 if (len < ntohs(ip->ip_len)) {
1320                         debug("len bad %d < %d\n", len, ntohs(ip->ip_len));
1321                         return;
1322                 }
1323                 len = ntohs(ip->ip_len);
1324                 if (len < IP_HDR_SIZE) {
1325                         debug("bad ip->ip_len %d < %d\n", len, (int)IP_HDR_SIZE);
1326                         return;
1327                 }
1328                 debug_cond(DEBUG_NET_PKT, "len=%d, v=%02x\n",
1329                            len, ip->ip_hl_v & 0xff);
1330
1331                 /* Can't deal with anything except IPv4 */
1332                 if ((ip->ip_hl_v & 0xf0) != 0x40)
1333                         return;
1334                 /* Can't deal with IP options (headers != 20 bytes) */
1335                 if ((ip->ip_hl_v & 0x0f) != 0x05)
1336                         return;
1337                 /* Check the Checksum of the header */
1338                 if (!ip_checksum_ok((uchar *)ip, IP_HDR_SIZE)) {
1339                         debug("checksum bad\n");
1340                         return;
1341                 }
1342                 /* If it is not for us, ignore it */
1343                 dst_ip = net_read_ip(&ip->ip_dst);
1344                 if (net_ip.s_addr && dst_ip.s_addr != net_ip.s_addr &&
1345                     dst_ip.s_addr != 0xFFFFFFFF) {
1346                                 return;
1347                 }
1348                 /* Read source IP address for later use */
1349                 src_ip = net_read_ip(&ip->ip_src);
1350                 /*
1351                  * The function returns the unchanged packet if it's not
1352                  * a fragment, and either the complete packet or NULL if
1353                  * it is a fragment (if !CONFIG_IP_DEFRAG, it returns NULL)
1354                  */
1355                 ip = net_defragment(ip, &len);
1356                 if (!ip)
1357                         return;
1358                 /*
1359                  * watch for ICMP host redirects
1360                  *
1361                  * There is no real handler code (yet). We just watch
1362                  * for ICMP host redirect messages. In case anybody
1363                  * sees these messages: please contact me
1364                  * (wd@denx.de), or - even better - send me the
1365                  * necessary fixes :-)
1366                  *
1367                  * Note: in all cases where I have seen this so far
1368                  * it was a problem with the router configuration,
1369                  * for instance when a router was configured in the
1370                  * BOOTP reply, but the TFTP server was on the same
1371                  * subnet. So this is probably a warning that your
1372                  * configuration might be wrong. But I'm not really
1373                  * sure if there aren't any other situations.
1374                  *
1375                  * Simon Glass <sjg@chromium.org>: We get an ICMP when
1376                  * we send a tftp packet to a dead connection, or when
1377                  * there is no server at the other end.
1378                  */
1379                 if (ip->ip_p == IPPROTO_ICMP) {
1380                         receive_icmp(ip, len, src_ip, et);
1381                         return;
1382 #if defined(CONFIG_PROT_TCP)
1383                 } else if (ip->ip_p == IPPROTO_TCP) {
1384                         debug_cond(DEBUG_DEV_PKT,
1385                                    "TCP PH (to=%pI4, from=%pI4, len=%d)\n",
1386                                    &dst_ip, &src_ip, len);
1387
1388                         rxhand_tcp_f((union tcp_build_pkt *)ip, len);
1389                         return;
1390 #endif
1391                 } else if (ip->ip_p != IPPROTO_UDP) {   /* Only UDP packets */
1392                         return;
1393                 }
1394
1395                 if (ntohs(ip->udp_len) < UDP_HDR_SIZE || ntohs(ip->udp_len) > len - IP_HDR_SIZE)
1396                         return;
1397
1398                 debug_cond(DEBUG_DEV_PKT,
1399                            "received UDP (to=%pI4, from=%pI4, len=%d)\n",
1400                            &dst_ip, &src_ip, len);
1401
1402                 if (IS_ENABLED(CONFIG_UDP_CHECKSUM) && ip->udp_xsum != 0) {
1403                         ulong   xsum;
1404                         u8 *sumptr;
1405                         ushort  sumlen;
1406
1407                         xsum  = ip->ip_p;
1408                         xsum += (ntohs(ip->udp_len));
1409                         xsum += (ntohl(ip->ip_src.s_addr) >> 16) & 0x0000ffff;
1410                         xsum += (ntohl(ip->ip_src.s_addr) >>  0) & 0x0000ffff;
1411                         xsum += (ntohl(ip->ip_dst.s_addr) >> 16) & 0x0000ffff;
1412                         xsum += (ntohl(ip->ip_dst.s_addr) >>  0) & 0x0000ffff;
1413
1414                         sumlen = ntohs(ip->udp_len);
1415                         sumptr = (u8 *)&ip->udp_src;
1416
1417                         while (sumlen > 1) {
1418                                 /* inlined ntohs() to avoid alignment errors */
1419                                 xsum += (sumptr[0] << 8) + sumptr[1];
1420                                 sumptr += 2;
1421                                 sumlen -= 2;
1422                         }
1423                         if (sumlen > 0)
1424                                 xsum += (sumptr[0] << 8) + sumptr[0];
1425                         while ((xsum >> 16) != 0) {
1426                                 xsum = (xsum & 0x0000ffff) +
1427                                        ((xsum >> 16) & 0x0000ffff);
1428                         }
1429                         if ((xsum != 0x00000000) && (xsum != 0x0000ffff)) {
1430                                 printf(" UDP wrong checksum %08lx %08x\n",
1431                                        xsum, ntohs(ip->udp_xsum));
1432                                 return;
1433                         }
1434                 }
1435
1436 #if defined(CONFIG_NETCONSOLE) && !defined(CONFIG_SPL_BUILD)
1437                 nc_input_packet((uchar *)ip + IP_UDP_HDR_SIZE,
1438                                 src_ip,
1439                                 ntohs(ip->udp_dst),
1440                                 ntohs(ip->udp_src),
1441                                 ntohs(ip->udp_len) - UDP_HDR_SIZE);
1442 #endif
1443                 /*
1444                  * IP header OK.  Pass the packet to the current handler.
1445                  */
1446                 (*udp_packet_handler)((uchar *)ip + IP_UDP_HDR_SIZE,
1447                                       ntohs(ip->udp_dst),
1448                                       src_ip,
1449                                       ntohs(ip->udp_src),
1450                                       ntohs(ip->udp_len) - UDP_HDR_SIZE);
1451                 break;
1452 #ifdef CONFIG_CMD_WOL
1453         case PROT_WOL:
1454                 wol_receive(ip, len);
1455                 break;
1456 #endif
1457 #ifdef CONFIG_PHY_NCSI
1458         case PROT_NCSI:
1459                 ncsi_receive(et, ip, len);
1460                 break;
1461 #endif
1462         }
1463 }
1464
1465 /**********************************************************************/
1466
1467 static int net_check_prereq(enum proto_t protocol)
1468 {
1469         switch (protocol) {
1470                 /* Fall through */
1471 #if defined(CONFIG_CMD_PING)
1472         case PING:
1473                 if (net_ping_ip.s_addr == 0) {
1474                         puts("*** ERROR: ping address not given\n");
1475                         return 1;
1476                 }
1477                 goto common;
1478 #endif
1479 #if defined(CONFIG_CMD_PING6)
1480         case PING6:
1481                 if (ip6_is_unspecified_addr(&net_ping_ip6)) {
1482                         puts("*** ERROR: ping address not given\n");
1483                         return 1;
1484                 }
1485                 goto common;
1486 #endif
1487 #if defined(CONFIG_CMD_DNS)
1488         case DNS:
1489                 if (net_dns_server.s_addr == 0) {
1490                         puts("*** ERROR: DNS server address not given\n");
1491                         return 1;
1492                 }
1493                 goto common;
1494 #endif
1495 #if defined(CONFIG_PROT_UDP)
1496         case UDP:
1497                 if (udp_prereq())
1498                         return 1;
1499                 goto common;
1500 #endif
1501
1502 #if defined(CONFIG_CMD_NFS)
1503         case NFS:
1504 #endif
1505                 /* Fall through */
1506         case TFTPGET:
1507         case TFTPPUT:
1508                 if (IS_ENABLED(CONFIG_IPV6) && use_ip6) {
1509                         if (!memcmp(&net_server_ip6, &net_null_addr_ip6,
1510                                     sizeof(struct in6_addr)) &&
1511                                     !strchr(net_boot_file_name, '[')) {
1512                                 puts("*** ERROR: `serverip6' not set\n");
1513                                 return 1;
1514                         }
1515                 } else if (net_server_ip.s_addr == 0 && !is_serverip_in_cmd()) {
1516                         puts("*** ERROR: `serverip' not set\n");
1517                         return 1;
1518                 }
1519 #if     defined(CONFIG_CMD_PING) || \
1520         defined(CONFIG_CMD_DNS) || defined(CONFIG_PROT_UDP)
1521 common:
1522 #endif
1523                 /* Fall through */
1524
1525         case NETCONS:
1526         case FASTBOOT_UDP:
1527         case FASTBOOT_TCP:
1528         case TFTPSRV:
1529                 if (IS_ENABLED(CONFIG_IPV6) && use_ip6) {
1530                         if (!memcmp(&net_link_local_ip6, &net_null_addr_ip6,
1531                                     sizeof(struct in6_addr))) {
1532                                 puts("*** ERROR: `ip6addr` not set\n");
1533                                 return 1;
1534                         }
1535                 } else if (net_ip.s_addr == 0) {
1536                         puts("*** ERROR: `ipaddr' not set\n");
1537                         return 1;
1538                 }
1539                 /* Fall through */
1540
1541 #ifdef CONFIG_CMD_RARP
1542         case RARP:
1543 #endif
1544 #ifdef CONFIG_PHY_NCSI
1545         case NCSI:
1546 #endif
1547         case BOOTP:
1548         case CDP:
1549         case DHCP:
1550         case LINKLOCAL:
1551                 if (memcmp(net_ethaddr, "\0\0\0\0\0\0", 6) == 0) {
1552                         int num = eth_get_dev_index();
1553
1554                         switch (num) {
1555                         case -1:
1556                                 puts("*** ERROR: No ethernet found.\n");
1557                                 return 1;
1558                         case 0:
1559                                 puts("*** ERROR: `ethaddr' not set\n");
1560                                 break;
1561                         default:
1562                                 printf("*** ERROR: `eth%daddr' not set\n",
1563                                        num);
1564                                 break;
1565                         }
1566
1567                         net_start_again();
1568                         return 2;
1569                 }
1570                 /* Fall through */
1571         default:
1572                 return 0;
1573         }
1574         return 0;               /* OK */
1575 }
1576 /**********************************************************************/
1577
1578 int
1579 net_eth_hdr_size(void)
1580 {
1581         ushort myvlanid;
1582
1583         myvlanid = ntohs(net_our_vlan);
1584         if (myvlanid == (ushort)-1)
1585                 myvlanid = VLAN_NONE;
1586
1587         return ((myvlanid & VLAN_IDMASK) == VLAN_NONE) ? ETHER_HDR_SIZE :
1588                 VLAN_ETHER_HDR_SIZE;
1589 }
1590
1591 int net_set_ether(uchar *xet, const uchar *dest_ethaddr, uint prot)
1592 {
1593         struct ethernet_hdr *et = (struct ethernet_hdr *)xet;
1594         ushort myvlanid;
1595
1596         myvlanid = ntohs(net_our_vlan);
1597         if (myvlanid == (ushort)-1)
1598                 myvlanid = VLAN_NONE;
1599
1600         memcpy(et->et_dest, dest_ethaddr, 6);
1601         memcpy(et->et_src, net_ethaddr, 6);
1602         if ((myvlanid & VLAN_IDMASK) == VLAN_NONE) {
1603                 et->et_protlen = htons(prot);
1604                 return ETHER_HDR_SIZE;
1605         } else {
1606                 struct vlan_ethernet_hdr *vet =
1607                         (struct vlan_ethernet_hdr *)xet;
1608
1609                 vet->vet_vlan_type = htons(PROT_VLAN);
1610                 vet->vet_tag = htons((0 << 5) | (myvlanid & VLAN_IDMASK));
1611                 vet->vet_type = htons(prot);
1612                 return VLAN_ETHER_HDR_SIZE;
1613         }
1614 }
1615
1616 int net_update_ether(struct ethernet_hdr *et, uchar *addr, uint prot)
1617 {
1618         ushort protlen;
1619
1620         memcpy(et->et_dest, addr, 6);
1621         memcpy(et->et_src, net_ethaddr, 6);
1622         protlen = ntohs(et->et_protlen);
1623         if (protlen == PROT_VLAN) {
1624                 struct vlan_ethernet_hdr *vet =
1625                         (struct vlan_ethernet_hdr *)et;
1626                 vet->vet_type = htons(prot);
1627                 return VLAN_ETHER_HDR_SIZE;
1628         } else if (protlen > 1514) {
1629                 et->et_protlen = htons(prot);
1630                 return ETHER_HDR_SIZE;
1631         } else {
1632                 /* 802.2 + SNAP */
1633                 struct e802_hdr *et802 = (struct e802_hdr *)et;
1634                 et802->et_prot = htons(prot);
1635                 return E802_HDR_SIZE;
1636         }
1637 }
1638
1639 void net_set_ip_header(uchar *pkt, struct in_addr dest, struct in_addr source,
1640                        u16 pkt_len, u8 proto)
1641 {
1642         struct ip_udp_hdr *ip = (struct ip_udp_hdr *)pkt;
1643
1644         /*
1645          *      Construct an IP header.
1646          */
1647         /* IP_HDR_SIZE / 4 (not including UDP) */
1648         ip->ip_hl_v  = 0x45;
1649         ip->ip_tos   = 0;
1650         ip->ip_len   = htons(pkt_len);
1651         ip->ip_p     = proto;
1652         ip->ip_id    = htons(net_ip_id++);
1653         ip->ip_off   = htons(IP_FLAGS_DFRAG);   /* Don't fragment */
1654         ip->ip_ttl   = 255;
1655         ip->ip_sum   = 0;
1656         /* already in network byte order */
1657         net_copy_ip((void *)&ip->ip_src, &source);
1658         /* already in network byte order */
1659         net_copy_ip((void *)&ip->ip_dst, &dest);
1660
1661         ip->ip_sum   = compute_ip_checksum(ip, IP_HDR_SIZE);
1662 }
1663
1664 void net_set_udp_header(uchar *pkt, struct in_addr dest, int dport, int sport,
1665                         int len)
1666 {
1667         struct ip_udp_hdr *ip = (struct ip_udp_hdr *)pkt;
1668
1669         /*
1670          *      If the data is an odd number of bytes, zero the
1671          *      byte after the last byte so that the checksum
1672          *      will work.
1673          */
1674         if (len & 1)
1675                 pkt[IP_UDP_HDR_SIZE + len] = 0;
1676
1677         net_set_ip_header(pkt, dest, net_ip, IP_UDP_HDR_SIZE + len,
1678                           IPPROTO_UDP);
1679
1680         ip->udp_src  = htons(sport);
1681         ip->udp_dst  = htons(dport);
1682         ip->udp_len  = htons(UDP_HDR_SIZE + len);
1683         ip->udp_xsum = 0;
1684 }
1685
1686 void copy_filename(char *dst, const char *src, int size)
1687 {
1688         if (src && *src && (*src == '"')) {
1689                 ++src;
1690                 --size;
1691         }
1692
1693         while ((--size > 0) && src && *src && (*src != '"'))
1694                 *dst++ = *src++;
1695         *dst = '\0';
1696 }
1697
1698 int is_serverip_in_cmd(void)
1699 {
1700         return !!strchr(net_boot_file_name, ':');
1701 }
1702
1703 int net_parse_bootfile(struct in_addr *ipaddr, char *filename, int max_len)
1704 {
1705         char *colon;
1706         struct in_addr ip;
1707         ip.s_addr = 0;
1708
1709         if (net_boot_file_name[0] == '\0')
1710                 return 0;
1711
1712         colon = strchr(net_boot_file_name, ':');
1713         if (colon) {
1714                 ip = string_to_ip(net_boot_file_name);
1715                 if (ipaddr && ip.s_addr)
1716                         *ipaddr = ip;
1717         }
1718         if (ip.s_addr) {
1719                 strncpy(filename, colon + 1, max_len);
1720         } else {
1721                 strncpy(filename, net_boot_file_name, max_len);
1722         }
1723         filename[max_len - 1] = '\0';
1724
1725         return 1;
1726 }
1727
1728 void ip_to_string(struct in_addr x, char *s)
1729 {
1730         x.s_addr = ntohl(x.s_addr);
1731         sprintf(s, "%d.%d.%d.%d",
1732                 (int) ((x.s_addr >> 24) & 0xff),
1733                 (int) ((x.s_addr >> 16) & 0xff),
1734                 (int) ((x.s_addr >> 8) & 0xff),
1735                 (int) ((x.s_addr >> 0) & 0xff)
1736         );
1737 }
1738
1739 void vlan_to_string(ushort x, char *s)
1740 {
1741         x = ntohs(x);
1742
1743         if (x == (ushort)-1)
1744                 x = VLAN_NONE;
1745
1746         if (x == VLAN_NONE)
1747                 strcpy(s, "none");
1748         else
1749                 sprintf(s, "%d", x & VLAN_IDMASK);
1750 }
1751
1752 ushort string_to_vlan(const char *s)
1753 {
1754         ushort id;
1755
1756         if (s == NULL)
1757                 return htons(VLAN_NONE);
1758
1759         if (*s < '0' || *s > '9')
1760                 id = VLAN_NONE;
1761         else
1762                 id = (ushort)dectoul(s, NULL);
1763
1764         return htons(id);
1765 }
1766
1767 ushort env_get_vlan(char *var)
1768 {
1769         return string_to_vlan(env_get(var));
1770 }