blob: 43abbac7c32e184a9c420019fbe1df8b5393e5e1 [file] [log] [blame]
Tom Rinif739fcd2018-05-07 17:02:21 -04001// SPDX-License-Identifier: GPL-2.0
wdenk2d966952002-10-31 22:12:35 +00002/*
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 *
Ehsan Mohandesi6de98b62023-04-21 17:08:21 -070027 * LINKLOCAL:
Joe Hershbergerd22c3382012-05-23 08:00:12 +000028 *
29 * Prerequisites: - own ethernet address
30 * We want: - own IP address
31 * Next step: ARP
32 *
wdenk2d966952002-10-31 22:12:35 +000033 * 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 *
Wolfgang Denkb2f50802005-08-12 23:43:12 +020050 * Prerequisites: - own ethernet address
51 * We want: - IP, Netmask, ServerIP, Gateway IP
52 * - bootfilename, lease time
53 * Next step: - TFTP
wdenk2d966952002-10-31 22:12:35 +000054 *
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
wdenkcbd8a352004-02-24 02:00:03 +000065 *
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
wdenkea287de2005-04-01 00:25:43 +000074 *
Lothar Feltend8970da2018-06-22 22:29:54 +020075 *
76 * WOL:
77 *
78 * Prerequisites: - own ethernet address
79 * We want: - magic packet or timeout
80 * Next step: none
wdenk2d966952002-10-31 22:12:35 +000081 */
82
83
84#include <common.h>
Simon Glass52f24232020-05-10 11:40:00 -060085#include <bootstage.h>
wdenk2d966952002-10-31 22:12:35 +000086#include <command.h>
Simon Glass24b852a2015-11-08 23:47:45 -070087#include <console.h>
Simon Glassc7694dd2019-08-01 09:46:46 -060088#include <env.h>
Simon Glassf3998fd2019-08-02 09:44:25 -060089#include <env_internal.h>
Joe Hershberger60304592015-03-22 17:09:24 -050090#include <errno.h>
Simon Glass8e8ccfe2019-12-28 10:45:03 -070091#include <image.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060092#include <log.h>
wdenk2d966952002-10-31 22:12:35 +000093#include <net.h>
Viacheslav Mitrofanovffdbf3b2022-12-02 12:18:06 +030094#include <net6.h>
95#include <ndisc.h>
Dmitrii Merkurev443d3192023-04-12 19:49:30 +010096#include <net/fastboot_udp.h>
97#include <net/fastboot_tcp.h>
Lukasz Majewski34696952015-08-24 00:21:43 +020098#include <net/tftp.h>
Samuel Mendoza-Jonas09bd3d02022-08-08 21:46:03 +093099#include <net/ncsi.h>
Ramon Fried3eaac632019-07-18 21:43:30 +0300100#if defined(CONFIG_CMD_PCAP)
101#include <net/pcap.h>
102#endif
Philippe Reynesb43ea1b2020-09-18 14:13:00 +0200103#include <net/udp.h>
Uri Mashiach2d8d1902017-01-19 10:51:45 +0200104#if defined(CONFIG_LED_STATUS)
Joe Hershberger4545f4e2012-05-23 07:58:15 +0000105#include <miiphy.h>
106#include <status_led.h>
107#endif
108#include <watchdog.h>
109#include <linux/compiler.h>
Simon Glassf43b2df2023-01-17 10:47:27 -0700110#include <test/test.h>
Sean Edmonda0245812023-04-11 10:48:46 -0700111#include <net/tcp.h>
112#include <net/wget.h>
Joe Hershbergerd280d3f2012-05-23 07:58:01 +0000113#include "arp.h"
wdenk2d966952002-10-31 22:12:35 +0000114#include "bootp.h"
Joe Hershbergerf575ae12012-05-23 07:57:59 +0000115#include "cdp.h"
Robin Getz1a32bf42009-07-20 14:53:54 -0400116#if defined(CONFIG_CMD_DNS)
117#include "dns.h"
118#endif
Joe Hershbergerd22c3382012-05-23 08:00:12 +0000119#include "link_local.h"
Joe Hershberger4545f4e2012-05-23 07:58:15 +0000120#include "nfs.h"
Joe Hershbergera36b12f2012-05-23 07:58:02 +0000121#include "ping.h"
Joe Hershberger4545f4e2012-05-23 07:58:15 +0000122#include "rarp.h"
Lothar Feltend8970da2018-06-22 22:29:54 +0200123#if defined(CONFIG_CMD_WOL)
124#include "wol.h"
125#endif
Sean Edmonda0245812023-04-11 10:48:46 -0700126#include "dhcpv6.h"
Ehsan Mohandesi6de98b62023-04-21 17:08:21 -0700127#include "net_rand.h"
wdenk2d966952002-10-31 22:12:35 +0000128
wdenk2d966952002-10-31 22:12:35 +0000129/** BOOTP EXTENTIONS **/
130
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000131/* Our subnet mask (0=unknown) */
Joe Hershberger049a95a2015-04-08 01:41:01 -0500132struct in_addr net_netmask;
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000133/* Our gateways IP address */
Joe Hershberger049a95a2015-04-08 01:41:01 -0500134struct in_addr net_gateway;
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000135/* Our DNS IP address */
Joe Hershberger049a95a2015-04-08 01:41:01 -0500136struct in_addr net_dns_server;
Jon Loeliger1fe80d72007-07-09 22:08:34 -0500137#if defined(CONFIG_BOOTP_DNS2)
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000138/* Our 2nd DNS IP address */
Joe Hershberger049a95a2015-04-08 01:41:01 -0500139struct in_addr net_dns_server2;
stroesefe389a82003-08-28 14:17:32 +0000140#endif
Sean Edmonda0245812023-04-11 10:48:46 -0700141/* Indicates whether the pxe path prefix / config file was specified in dhcp option */
142char *pxelinux_configfile;
wdenk2d966952002-10-31 22:12:35 +0000143
144/** END OF BOOTP EXTENTIONS **/
145
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000146/* Our ethernet address */
Joe Hershberger0adb5b72015-04-08 01:41:04 -0500147u8 net_ethaddr[6];
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000148/* Boot server enet address */
Joe Hershberger0adb5b72015-04-08 01:41:04 -0500149u8 net_server_ethaddr[6];
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000150/* Our IP addr (0 = unknown) */
Joe Hershberger049a95a2015-04-08 01:41:01 -0500151struct in_addr net_ip;
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000152/* Server IP addr (0 = unknown) */
Joe Hershberger049a95a2015-04-08 01:41:01 -0500153struct in_addr net_server_ip;
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000154/* Current receive packet */
Joe Hershberger1203fcc2015-04-08 01:41:05 -0500155uchar *net_rx_packet;
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000156/* Current rx packet length */
Joe Hershberger1203fcc2015-04-08 01:41:05 -0500157int net_rx_packet_len;
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000158/* IP packet ID */
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500159static unsigned net_ip_id;
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000160/* Ethernet bcast address */
Joe Hershberger0adb5b72015-04-08 01:41:04 -0500161const u8 net_bcast_ethaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
162const u8 net_null_ethaddr[6];
Alexander Graf0efe1bc2016-05-06 21:01:01 +0200163#if defined(CONFIG_API) || defined(CONFIG_EFI_LOADER)
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500164void (*push_packet)(void *, int len) = 0;
Rafal Jaworowskif85b6072007-12-27 18:19:02 +0100165#endif
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000166/* Network loop state */
Joe Hershberger22f6e992012-05-23 07:59:14 +0000167enum net_loop_state net_state;
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000168/* Tried all network devices */
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500169int net_restart_wrap;
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000170/* Network loop restarted */
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500171static int net_restarted;
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000172/* At least one device configured */
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500173static int net_dev_exists;
wdenk2d966952002-10-31 22:12:35 +0000174
wdenk6e592382004-04-18 17:39:38 +0000175/* XXX in both little & big endian machines 0xFFFF == ntohs(-1) */
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000176/* default is without VLAN */
Joe Hershberger4fd50552015-04-08 01:41:17 -0500177ushort net_our_vlan = 0xFFFF;
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000178/* ditto */
Joe Hershberger4fd50552015-04-08 01:41:17 -0500179ushort net_native_vlan = 0xFFFF;
wdenka3d991b2004-04-15 21:48:45 +0000180
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000181/* Boot File name */
Jacob Stiffler11a69ff2015-09-30 10:12:05 -0400182char net_boot_file_name[1024];
Alexander Graf449312c2018-06-15 10:29:27 +0200183/* Indicates whether the file name was specified on the command line */
184bool net_boot_file_name_explicit;
Joe Hershberger14111572015-04-08 01:41:02 -0500185/* 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;
wdenk2d966952002-10-31 22:12:35 +0000189
Joe Hershberger1203fcc2015-04-08 01:41:05 -0500190static uchar net_pkt_buf[(PKTBUFSRX+1) * PKTSIZE_ALIGN + PKTALIGN];
Joe Hershberger2a504df2015-03-22 17:09:11 -0500191/* Receive packets */
192uchar *net_rx_packets[PKTBUFSRX];
Joe Hershbergerece223b2012-05-23 07:59:15 +0000193/* Current UDP RX packet handler */
194static rxhand_f *udp_packet_handler;
195/* Current ARP RX packet handler */
196static rxhand_f *arp_packet_handler;
Simon Glass39bccd22011-10-26 14:18:38 +0000197#ifdef CONFIG_CMD_TFTPPUT
Joe Hershbergerece223b2012-05-23 07:59:15 +0000198/* Current ICMP rx handler */
199static rxhand_icmp_f *packet_icmp_handler;
Simon Glass39bccd22011-10-26 14:18:38 +0000200#endif
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000201/* Current timeout handler */
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500202static thand_f *time_handler;
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000203/* Time base value */
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500204static ulong time_start;
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000205/* Current timeout value */
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500206static ulong time_delta;
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000207/* THE transmit packet */
Joe Hershberger1203fcc2015-04-08 01:41:05 -0500208uchar *net_tx_packet;
wdenk2d966952002-10-31 22:12:35 +0000209
Simon Glasse4bf0c52011-10-24 18:00:02 +0000210static int net_check_prereq(enum proto_t protocol);
wdenk2d966952002-10-31 22:12:35 +0000211
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500212static int net_try_count;
Remy Bohmer67b96e82009-10-28 22:13:39 +0100213
Jim Linb63056d2013-08-13 19:03:05 +0800214int __maybe_unused net_busy_flag;
215
wdenk2d966952002-10-31 22:12:35 +0000216/**********************************************************************/
wdenk73a8b272003-06-05 19:27:42 +0000217
Joe Hershbergerfd305632015-05-20 14:27:23 -0500218static 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
Simon Glasse4a3d572011-10-27 06:24:32 +0000304/*
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{
Tom Rinia6ab4b52019-12-05 19:35:07 -0500310#if defined(CONFIG_CMD_NFS) && !defined(CONFIG_SPL_BUILD)
Simon Glass00caae62017-08-03 12:22:12 -0600311 const char *s = env_get("autoload");
Simon Glasse4a3d572011-10-27 06:24:32 +0000312
Joe Hershbergerec8a2522012-12-11 22:16:22 -0600313 if (s != NULL && strcmp(s, "NFS") == 0) {
Joe Hershberger3855cad2018-07-03 19:36:40 -0500314 if (net_check_prereq(NFS)) {
315/* We aren't expecting to get a serverip, so just accept the assigned IP */
Simon Glass43407532021-12-18 11:27:52 -0700316 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 }
Joe Hershberger3855cad2018-07-03 19:36:40 -0500322 return;
323 }
Joe Hershbergerec8a2522012-12-11 22:16:22 -0600324 /*
325 * Use NFS to load the bootfile.
326 */
Joe Hershberger68c76a32015-04-08 01:41:10 -0500327 nfs_start();
Joe Hershbergerec8a2522012-12-11 22:16:22 -0600328 return;
329 }
Simon Glasse4a3d572011-10-27 06:24:32 +0000330#endif
Simon Glassbfebc8c2017-08-03 12:22:13 -0600331 if (env_get_yesno("autoload") == 0) {
Joe Hershbergerec8a2522012-12-11 22:16:22 -0600332 /*
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;
Simon Glasse4a3d572011-10-27 06:24:32 +0000338 }
Joe Hershberger3855cad2018-07-03 19:36:40 -0500339 if (net_check_prereq(TFTPGET)) {
340/* We aren't expecting to get a serverip, so just accept the assigned IP */
Simon Glass43407532021-12-18 11:27:52 -0700341 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 }
Joe Hershberger3855cad2018-07-03 19:36:40 -0500347 return;
348 }
Joe Hershberger8885c5f2015-04-08 01:41:07 -0500349 tftp_start(TFTPGET);
Simon Glasse4a3d572011-10-27 06:24:32 +0000350}
351
Sean Andersonc3f02782020-09-12 17:45:43 -0400352static int net_init_loop(void)
Heiko Schocher2f70c492009-02-10 09:38:52 +0100353{
Ehsan Mohandesi6de98b62023-04-21 17:08:21 -0700354 static bool first_call = true;
355
Viacheslav Mitrofanovffdbf3b2022-12-02 12:18:06 +0300356 if (eth_get_dev()) {
Joe Hershberger0adb5b72015-04-08 01:41:04 -0500357 memcpy(net_ethaddr, eth_get_ethaddr(), 6);
Viacheslav Mitrofanovffdbf3b2022-12-02 12:18:06 +0300358
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 }
Sean Andersonc3f02782020-09-12 17:45:43 -0400367 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;
Michael Zaidman3c172c42009-04-04 01:43:00 +0300374
Ehsan Mohandesi6de98b62023-04-21 17:08:21 -0700375 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 }
Sean Andersonc3f02782020-09-12 17:45:43 -0400381 return 0;
Heiko Schocher2f70c492009-02-10 09:38:52 +0100382}
383
Joe Hershbergerece223b2012-05-23 07:59:15 +0000384static void net_clear_handlers(void)
385{
386 net_set_udp_handler(NULL);
387 net_set_arp_handler(NULL);
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500388 net_set_timeout_handler(0, NULL);
Joe Hershbergerece223b2012-05-23 07:59:15 +0000389}
390
391static void net_cleanup_loop(void)
392{
393 net_clear_handlers();
394}
395
Sean Andersonc3f02782020-09-12 17:45:43 -0400396int net_init(void)
Joe Hershberger46c495d2012-05-23 07:59:22 +0000397{
398 static int first_call = 1;
399
400 if (first_call) {
401 /*
402 * Setup packet buffers, aligned correctly.
403 */
404 int i;
405
Joe Hershberger1203fcc2015-04-08 01:41:05 -0500406 net_tx_packet = &net_pkt_buf[0] + (PKTALIGN - 1);
407 net_tx_packet -= (ulong)net_tx_packet % PKTALIGN;
Joe Hershberger2a504df2015-03-22 17:09:11 -0500408 for (i = 0; i < PKTBUFSRX; i++) {
Joe Hershberger1203fcc2015-04-08 01:41:05 -0500409 net_rx_packets[i] = net_tx_packet +
410 (i + 1) * PKTSIZE_ALIGN;
Joe Hershberger2a504df2015-03-22 17:09:11 -0500411 }
Joe Hershberger85d25e02015-04-08 01:41:08 -0500412 arp_init();
Viacheslav Mitrofanovffdbf3b2022-12-02 12:18:06 +0300413 ndisc_init();
Joe Hershberger46c495d2012-05-23 07:59:22 +0000414 net_clear_handlers();
415
416 /* Only need to setup buffer pointers once. */
417 first_call = 0;
Ying-Chun Liu (PaulLiu)a3bf1932022-11-08 14:17:28 +0800418 if (IS_ENABLED(CONFIG_PROT_TCP))
419 tcp_set_tcp_state(TCP_CLOSED);
Joe Hershberger46c495d2012-05-23 07:59:22 +0000420 }
421
Sean Andersonc3f02782020-09-12 17:45:43 -0400422 return net_init_loop();
Joe Hershberger46c495d2012-05-23 07:59:22 +0000423}
424
wdenk73a8b272003-06-05 19:27:42 +0000425/**********************************************************************/
wdenk2d966952002-10-31 22:12:35 +0000426/*
427 * Main network processing loop.
428 */
429
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500430int net_loop(enum proto_t protocol)
wdenk2d966952002-10-31 22:12:35 +0000431{
Joe Hershberger60304592015-03-22 17:09:24 -0500432 int ret = -EINVAL;
Leonid Iziumtsev60177b22018-05-08 15:55:50 +0200433 enum net_loop_state prev_net_state = net_state;
wdenk2d966952002-10-31 22:12:35 +0000434
Marek Szyprowskidef7a5c2020-06-15 11:15:57 +0200435#if defined(CONFIG_CMD_PING)
436 if (protocol != PING)
437 net_ping_ip.s_addr = 0;
438#endif
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500439 net_restarted = 0;
440 net_dev_exists = 0;
441 net_try_count = 1;
442 debug_cond(DEBUG_INT_STATE, "--- net_loop Entry\n");
wdenk73a8b272003-06-05 19:27:42 +0000443
Samuel Mendoza-Jonas09bd3d02022-08-08 21:46:03 +0930444#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
Simon Glass573f14f2011-12-10 11:08:06 +0000454 bootstage_mark_name(BOOTSTAGE_ID_ETH_START, "eth_start");
Joe Hershberger46c495d2012-05-23 07:59:22 +0000455 net_init();
Yang Liud9506cd2020-12-21 14:44:39 +1100456 if (eth_is_on_demand_init()) {
wdenkb1bf6f22005-04-03 14:52:59 +0000457 eth_halt();
Joe Hershbergerf8be7d62012-08-03 10:59:08 +0000458 eth_set_current();
Joe Hershberger60304592015-03-22 17:09:24 -0500459 ret = eth_init();
460 if (ret < 0) {
Joe Hershbergerf8be7d62012-08-03 10:59:08 +0000461 eth_halt();
Joe Hershberger60304592015-03-22 17:09:24 -0500462 return ret;
Joe Hershbergerf8be7d62012-08-03 10:59:08 +0000463 }
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500464 } else {
Joe Hershbergerd2eaec62015-03-22 17:09:06 -0500465 eth_init_state_only();
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500466 }
Samuel Mendoza-Jonas4b290d42022-08-08 21:46:04 +0930467
wdenk2d966952002-10-31 22:12:35 +0000468restart:
Jim Linb63056d2013-08-13 19:03:05 +0800469#ifdef CONFIG_USB_KEYBOARD
470 net_busy_flag = 0;
471#endif
Joe Hershberger22f6e992012-05-23 07:59:14 +0000472 net_set_state(NETLOOP_CONTINUE);
wdenk2d966952002-10-31 22:12:35 +0000473
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 */
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500479 debug_cond(DEBUG_INT_STATE, "--- net_loop Init\n");
480 net_init_loop();
wdenk2d966952002-10-31 22:12:35 +0000481
Simon Glassf43b2df2023-01-17 10:47:27 -0700482 if (!test_eth_enabled())
483 return 0;
484
Luca Ceresoli4f63acd2011-05-11 03:59:56 +0000485 switch (net_check_prereq(protocol)) {
wdenk2d966952002-10-31 22:12:35 +0000486 case 1:
487 /* network not configured */
wdenkb1bf6f22005-04-03 14:52:59 +0000488 eth_halt();
Leonid Iziumtsev60177b22018-05-08 15:55:50 +0200489 net_set_state(prev_net_state);
Joe Hershberger60304592015-03-22 17:09:24 -0500490 return -ENODEV;
wdenk2d966952002-10-31 22:12:35 +0000491
wdenk2d966952002-10-31 22:12:35 +0000492 case 2:
493 /* network device not configured */
494 break;
wdenk2d966952002-10-31 22:12:35 +0000495
496 case 0:
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500497 net_dev_exists = 1;
Joe Hershberger14111572015-04-08 01:41:02 -0500498 net_boot_file_size = 0;
wdenk2d966952002-10-31 22:12:35 +0000499 switch (protocol) {
Krebs, Olaf808f13d2020-03-09 14:27:55 +0000500#ifdef CONFIG_CMD_TFTPBOOT
Simon Glasse4bf0c52011-10-24 18:00:02 +0000501 case TFTPGET:
Simon Glass1fb7cd42011-10-24 18:00:07 +0000502#ifdef CONFIG_CMD_TFTPPUT
503 case TFTPPUT:
504#endif
wdenk2d966952002-10-31 22:12:35 +0000505 /* always use ARP to get server ethernet address */
Joe Hershberger8885c5f2015-04-08 01:41:07 -0500506 tftp_start(protocol);
wdenk2d966952002-10-31 22:12:35 +0000507 break;
Krebs, Olaf808f13d2020-03-09 14:27:55 +0000508#endif
Luca Ceresoli7a83af02011-05-17 00:03:40 +0000509#ifdef CONFIG_CMD_TFTPSRV
510 case TFTPSRV:
Joe Hershberger8885c5f2015-04-08 01:41:07 -0500511 tftp_start_server();
Luca Ceresoli7a83af02011-05-17 00:03:40 +0000512 break;
513#endif
Dmitrii Merkurev443d3192023-04-12 19:49:30 +0100514#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();
Alex Kiernanf73a7df2018-05-29 15:30:53 +0000522 break;
523#endif
Jon Loeliger643d1ab2007-07-09 17:45:14 -0500524#if defined(CONFIG_CMD_DHCP)
wdenk2d966952002-10-31 22:12:35 +0000525 case DHCP:
Joe Hershberger7044c6b2015-04-08 01:41:09 -0500526 bootp_reset();
Joe Hershberger049a95a2015-04-08 01:41:01 -0500527 net_ip.s_addr = 0;
Joe Hershberger7044c6b2015-04-08 01:41:09 -0500528 dhcp_request(); /* Basically same as BOOTP */
wdenk2d966952002-10-31 22:12:35 +0000529 break;
Jon Loeliger610f2e92007-07-10 11:05:02 -0500530#endif
Sean Edmonda0245812023-04-11 10:48:46 -0700531 case DHCP6:
532 if (IS_ENABLED(CONFIG_CMD_DHCP6))
533 dhcp6_start();
534 break;
Krebs, Olaf808f13d2020-03-09 14:27:55 +0000535#if defined(CONFIG_CMD_BOOTP)
wdenk2d966952002-10-31 22:12:35 +0000536 case BOOTP:
Joe Hershberger7044c6b2015-04-08 01:41:09 -0500537 bootp_reset();
Joe Hershberger049a95a2015-04-08 01:41:01 -0500538 net_ip.s_addr = 0;
Joe Hershberger7044c6b2015-04-08 01:41:09 -0500539 bootp_request();
wdenk2d966952002-10-31 22:12:35 +0000540 break;
Krebs, Olaf808f13d2020-03-09 14:27:55 +0000541#endif
Peter Tyserbf6cb242010-09-30 11:25:48 -0500542#if defined(CONFIG_CMD_RARP)
wdenk2d966952002-10-31 22:12:35 +0000543 case RARP:
Joe Hershberger698d78e2015-04-08 01:41:11 -0500544 rarp_try = 0;
Joe Hershberger049a95a2015-04-08 01:41:01 -0500545 net_ip.s_addr = 0;
Joe Hershberger698d78e2015-04-08 01:41:11 -0500546 rarp_request();
wdenk2d966952002-10-31 22:12:35 +0000547 break;
Peter Tyserbf6cb242010-09-30 11:25:48 -0500548#endif
Jon Loeliger643d1ab2007-07-09 17:45:14 -0500549#if defined(CONFIG_CMD_PING)
wdenk73a8b272003-06-05 19:27:42 +0000550 case PING:
Joe Hershbergera36b12f2012-05-23 07:58:02 +0000551 ping_start();
wdenk73a8b272003-06-05 19:27:42 +0000552 break;
553#endif
Viacheslav Mitrofanoveeb0a2c2022-12-02 12:18:08 +0300554#if defined(CONFIG_CMD_PING6)
555 case PING6:
556 ping6_start();
557 break;
558#endif
Tom Rinia6ab4b52019-12-05 19:35:07 -0500559#if defined(CONFIG_CMD_NFS) && !defined(CONFIG_SPL_BUILD)
wdenkcbd8a352004-02-24 02:00:03 +0000560 case NFS:
Joe Hershberger68c76a32015-04-08 01:41:10 -0500561 nfs_start();
wdenkcbd8a352004-02-24 02:00:03 +0000562 break;
563#endif
Ying-Chun Liu (PaulLiu)cfbae482022-11-08 14:17:29 +0800564#if defined(CONFIG_CMD_WGET)
565 case WGET:
566 wget_start();
567 break;
568#endif
Jon Loeliger643d1ab2007-07-09 17:45:14 -0500569#if defined(CONFIG_CMD_CDP)
wdenka3d991b2004-04-15 21:48:45 +0000570 case CDP:
Joe Hershberger6aede5b2015-04-08 01:41:14 -0500571 cdp_start();
wdenka3d991b2004-04-15 21:48:45 +0000572 break;
573#endif
Holger Dengler66c89ee2017-07-20 10:10:55 +0200574#if defined(CONFIG_NETCONSOLE) && !defined(CONFIG_SPL_BUILD)
wdenk68ceb292004-08-02 21:11:11 +0000575 case NETCONS:
Joe Hershberger6a38a5f2015-04-08 01:41:16 -0500576 nc_start();
wdenk68ceb292004-08-02 21:11:11 +0000577 break;
578#endif
Robin Getz1a32bf42009-07-20 14:53:54 -0400579#if defined(CONFIG_CMD_DNS)
580 case DNS:
Joe Hershberger786eac52015-04-08 01:41:15 -0500581 dns_start();
Robin Getz1a32bf42009-07-20 14:53:54 -0400582 break;
583#endif
Joe Hershbergerd22c3382012-05-23 08:00:12 +0000584#if defined(CONFIG_CMD_LINK_LOCAL)
585 case LINKLOCAL:
586 link_local_start();
587 break;
588#endif
Lothar Feltend8970da2018-06-22 22:29:54 +0200589#if defined(CONFIG_CMD_WOL)
590 case WOL:
591 wol_start();
592 break;
593#endif
Samuel Mendoza-Jonas09bd3d02022-08-08 21:46:03 +0930594#if defined(CONFIG_PHY_NCSI)
595 case NCSI:
596 ncsi_probe_packages();
597 break;
598#endif
Ehsan Mohandesi6de98b62023-04-21 17:08:21 -0700599 case RS:
600 if (IS_ENABLED(CONFIG_IPV6_ROUTER_DISCOVERY))
601 ip6_send_rs();
602 break;
wdenk2d966952002-10-31 22:12:35 +0000603 default:
604 break;
605 }
606
Philippe Reynesb43ea1b2020-09-18 14:13:00 +0200607 if (IS_ENABLED(CONFIG_PROT_UDP) && protocol == UDP)
608 udp_start();
609
wdenk2d966952002-10-31 22:12:35 +0000610 break;
611 }
612
Jon Loeliger643d1ab2007-07-09 17:45:14 -0500613#if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
Luca Ceresoli3e38e422011-05-11 03:59:54 +0000614#if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \
Uri Mashiach2d8d1902017-01-19 10:51:45 +0200615 defined(CONFIG_LED_STATUS) && \
616 defined(CONFIG_LED_STATUS_RED)
wdenkfc3e2162003-10-08 22:33:00 +0000617 /*
wdenk42d1f032003-10-15 23:53:47 +0000618 * Echo the inverted link state to the fault LED.
wdenkfc3e2162003-10-08 22:33:00 +0000619 */
Luca Ceresolid3c65b02011-05-04 02:40:43 +0000620 if (miiphy_link(eth_get_dev()->name, CONFIG_SYS_FAULT_MII_ADDR))
Uri Mashiach2d8d1902017-01-19 10:51:45 +0200621 status_led_set(CONFIG_LED_STATUS_RED, CONFIG_LED_STATUS_OFF);
Luca Ceresolid3c65b02011-05-04 02:40:43 +0000622 else
Uri Mashiach2d8d1902017-01-19 10:51:45 +0200623 status_led_set(CONFIG_LED_STATUS_RED, CONFIG_LED_STATUS_ON);
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200624#endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */
wdenkfc3e2162003-10-08 22:33:00 +0000625#endif /* CONFIG_MII, ... */
Jim Linb63056d2013-08-13 19:03:05 +0800626#ifdef CONFIG_USB_KEYBOARD
627 net_busy_flag = 1;
628#endif
wdenk2d966952002-10-31 22:12:35 +0000629
630 /*
631 * Main packet reception loop. Loop receiving packets until
Joe Hershberger22f6e992012-05-23 07:59:14 +0000632 * someone sets `net_state' to a state that terminates.
wdenk2d966952002-10-31 22:12:35 +0000633 */
634 for (;;) {
Stefan Roese29caf932022-09-02 14:10:46 +0200635 schedule();
Joe Hershbergerc5a75332015-12-21 16:31:35 -0600636 if (arp_timeout_check() > 0)
637 time_start = get_timer(0);
638
Viacheslav Mitrofanovffdbf3b2022-12-02 12:18:06 +0300639 if (IS_ENABLED(CONFIG_IPV6)) {
640 if (use_ip6 && (ndisc_timeout_check() > 0))
641 time_start = get_timer(0);
642 }
643
wdenk2d966952002-10-31 22:12:35 +0000644 /*
645 * Check the ethernet for a new packet. The ethernet
646 * receive routine will process it.
Joe Hershberger60304592015-03-22 17:09:24 -0500647 * Most drivers return the most recent packet size, but not
648 * errors that may have happened.
wdenk2d966952002-10-31 22:12:35 +0000649 */
Guennadi Liakhovetski40cb90e2008-04-03 17:04:19 +0200650 eth_rx();
wdenk2d966952002-10-31 22:12:35 +0000651
652 /*
653 * Abort if ctrl-c was pressed.
654 */
655 if (ctrlc()) {
Joe Hershbergere94070c2012-05-23 07:59:24 +0000656 /* cancel any ARP that may not have completed */
Joe Hershberger049a95a2015-04-08 01:41:01 -0500657 net_arp_wait_packet_ip.s_addr = 0;
Joe Hershbergere94070c2012-05-23 07:59:24 +0000658
Joe Hershbergerece223b2012-05-23 07:59:15 +0000659 net_cleanup_loop();
wdenk8bde7f72003-06-27 21:31:46 +0000660 eth_halt();
Joe Hershbergerf8be7d62012-08-03 10:59:08 +0000661 /* Invalidate the last protocol */
662 eth_set_last_protocol(BOOTP);
663
Luca Ceresoli4f63acd2011-05-11 03:59:56 +0000664 puts("\nAbort\n");
Joe Hershberger4ef8d532012-05-23 08:01:04 +0000665 /* include a debug print as well incase the debug
666 messages are directed to stderr */
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500667 debug_cond(DEBUG_INT_STATE, "--- net_loop Abort!\n");
Michal Simek19a4fba2015-08-21 08:49:48 +0200668 ret = -EINTR;
Simon Glass4793ee62011-10-24 18:00:01 +0000669 goto done;
wdenk2d966952002-10-31 22:12:35 +0000670 }
671
wdenk2d966952002-10-31 22:12:35 +0000672 /*
673 * Check for a timeout, and run the timeout handler
674 * if we have one.
675 */
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500676 if (time_handler &&
677 ((get_timer(0) - time_start) > time_delta)) {
wdenk2d966952002-10-31 22:12:35 +0000678 thand_f *x;
679
Jon Loeliger643d1ab2007-07-09 17:45:14 -0500680#if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
Luca Ceresoli4f63acd2011-05-11 03:59:56 +0000681#if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \
Uri Mashiach2d8d1902017-01-19 10:51:45 +0200682 defined(CONFIG_LED_STATUS) && \
683 defined(CONFIG_LED_STATUS_RED)
wdenkfc3e2162003-10-08 22:33:00 +0000684 /*
wdenk42d1f032003-10-15 23:53:47 +0000685 * Echo the inverted link state to the fault LED.
wdenkfc3e2162003-10-08 22:33:00 +0000686 */
Luca Ceresoli4f63acd2011-05-11 03:59:56 +0000687 if (miiphy_link(eth_get_dev()->name,
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500688 CONFIG_SYS_FAULT_MII_ADDR))
Uri Mashiach2d8d1902017-01-19 10:51:45 +0200689 status_led_set(CONFIG_LED_STATUS_RED,
690 CONFIG_LED_STATUS_OFF);
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500691 else
Uri Mashiach2d8d1902017-01-19 10:51:45 +0200692 status_led_set(CONFIG_LED_STATUS_RED,
693 CONFIG_LED_STATUS_ON);
Luca Ceresoli4f63acd2011-05-11 03:59:56 +0000694#endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */
wdenkfc3e2162003-10-08 22:33:00 +0000695#endif /* CONFIG_MII, ... */
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500696 debug_cond(DEBUG_INT_STATE, "--- net_loop timeout\n");
697 x = time_handler;
698 time_handler = (thand_f *)0;
wdenk2d966952002-10-31 22:12:35 +0000699 (*x)();
Ehsan Mohandesi6de98b62023-04-21 17:08:21 -0700700 } 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 }
wdenk2d966952002-10-31 22:12:35 +0000707
Joe Hershberger5c421332015-03-22 17:09:07 -0500708 if (net_state == NETLOOP_FAIL)
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500709 ret = net_start_again();
wdenk2d966952002-10-31 22:12:35 +0000710
Joe Hershberger22f6e992012-05-23 07:59:14 +0000711 switch (net_state) {
wdenk2d966952002-10-31 22:12:35 +0000712 case NETLOOP_RESTART:
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500713 net_restarted = 1;
wdenk2d966952002-10-31 22:12:35 +0000714 goto restart;
715
716 case NETLOOP_SUCCESS:
Joe Hershbergerece223b2012-05-23 07:59:15 +0000717 net_cleanup_loop();
Joe Hershberger14111572015-04-08 01:41:02 -0500718 if (net_boot_file_size > 0) {
719 printf("Bytes transferred = %d (%x hex)\n",
720 net_boot_file_size, net_boot_file_size);
Simon Glass018f5302017-08-03 12:22:10 -0600721 env_set_hex("filesize", net_boot_file_size);
Simon Glassbb872dd2019-12-28 10:45:02 -0700722 env_set_hex("fileaddr", image_load_addr);
wdenk2d966952002-10-31 22:12:35 +0000723 }
Samuel Mendoza-Jonas09bd3d02022-08-08 21:46:03 +0930724 if (protocol != NETCONS && protocol != NCSI)
Joe Hershbergerf8be7d62012-08-03 10:59:08 +0000725 eth_halt();
726 else
727 eth_halt_state_only();
728
729 eth_set_last_protocol(protocol);
730
Joe Hershberger14111572015-04-08 01:41:02 -0500731 ret = net_boot_file_size;
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500732 debug_cond(DEBUG_INT_STATE, "--- net_loop Success!\n");
Simon Glass4793ee62011-10-24 18:00:01 +0000733 goto done;
wdenk2d966952002-10-31 22:12:35 +0000734
735 case NETLOOP_FAIL:
Joe Hershbergerece223b2012-05-23 07:59:15 +0000736 net_cleanup_loop();
Joe Hershbergerf8be7d62012-08-03 10:59:08 +0000737 /* Invalidate the last protocol */
738 eth_set_last_protocol(BOOTP);
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500739 debug_cond(DEBUG_INT_STATE, "--- net_loop Fail!\n");
Thomas RIENOESSLa735e6e2018-11-21 15:56:07 +0100740 ret = -ENONET;
Simon Glass4793ee62011-10-24 18:00:01 +0000741 goto done;
Joe Hershberger22f6e992012-05-23 07:59:14 +0000742
743 case NETLOOP_CONTINUE:
744 continue;
wdenk2d966952002-10-31 22:12:35 +0000745 }
746 }
Simon Glass4793ee62011-10-24 18:00:01 +0000747
748done:
Jim Linb63056d2013-08-13 19:03:05 +0800749#ifdef CONFIG_USB_KEYBOARD
750 net_busy_flag = 0;
751#endif
Simon Glass39bccd22011-10-26 14:18:38 +0000752#ifdef CONFIG_CMD_TFTPPUT
Simon Glass4793ee62011-10-24 18:00:01 +0000753 /* Clear out the handlers */
Joe Hershbergerece223b2012-05-23 07:59:15 +0000754 net_set_udp_handler(NULL);
Simon Glass4793ee62011-10-24 18:00:01 +0000755 net_set_icmp_handler(NULL);
Simon Glass39bccd22011-10-26 14:18:38 +0000756#endif
Leonid Iziumtsev60177b22018-05-08 15:55:50 +0200757 net_set_state(prev_net_state);
Ramon Fried3eaac632019-07-18 21:43:30 +0300758
759#if defined(CONFIG_CMD_PCAP)
760 if (pcap_active())
761 pcap_print_status();
762#endif
Simon Glass4793ee62011-10-24 18:00:01 +0000763 return ret;
wdenk2d966952002-10-31 22:12:35 +0000764}
765
766/**********************************************************************/
767
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500768static void start_again_timeout_handler(void)
wdenk2d966952002-10-31 22:12:35 +0000769{
Joe Hershberger22f6e992012-05-23 07:59:14 +0000770 net_set_state(NETLOOP_RESTART);
wdenk2d966952002-10-31 22:12:35 +0000771}
772
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500773int net_start_again(void)
wdenk2d966952002-10-31 22:12:35 +0000774{
wdenk6e592382004-04-18 17:39:38 +0000775 char *nretry;
Remy Bohmer67b96e82009-10-28 22:13:39 +0100776 int retry_forever = 0;
777 unsigned long retrycnt = 0;
Joe Hershberger60304592015-03-22 17:09:24 -0500778 int ret;
wdenka3d991b2004-04-15 21:48:45 +0000779
Simon Glass00caae62017-08-03 12:22:12 -0600780 nretry = env_get("netretry");
Remy Bohmer67b96e82009-10-28 22:13:39 +0100781 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);
Joe Hershberger5c421332015-03-22 17:09:07 -0500790 } else {
791 retrycnt = 0;
792 retry_forever = 0;
793 }
Remy Bohmer67b96e82009-10-28 22:13:39 +0100794
Leonid Iziumtsev17d413b2018-03-09 15:29:06 +0100795 if ((!retry_forever) && (net_try_count > retrycnt)) {
Remy Bohmer67b96e82009-10-28 22:13:39 +0100796 eth_halt();
Joe Hershberger22f6e992012-05-23 07:59:14 +0000797 net_set_state(NETLOOP_FAIL);
Joe Hershberger60304592015-03-22 17:09:24 -0500798 /*
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;
wdenka3d991b2004-04-15 21:48:45 +0000803 }
Remy Bohmer67b96e82009-10-28 22:13:39 +0100804
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500805 net_try_count++;
Remy Bohmer67b96e82009-10-28 22:13:39 +0100806
Luca Ceresoli4f63acd2011-05-11 03:59:56 +0000807 eth_halt();
Matthias Fuchs8b0c5c12007-12-27 16:58:41 +0100808#if !defined(CONFIG_NET_DO_NOT_TRY_ANOTHER)
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500809 eth_try_another(!net_restarted);
Matthias Fuchs8b0c5c12007-12-27 16:58:41 +0100810#endif
Joe Hershberger60304592015-03-22 17:09:24 -0500811 ret = eth_init();
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500812 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);
Joe Hershbergerece223b2012-05-23 07:59:15 +0000817 net_set_udp_handler(NULL);
wdenk6e592382004-04-18 17:39:38 +0000818 } else {
Joe Hershberger22f6e992012-05-23 07:59:14 +0000819 net_set_state(NETLOOP_FAIL);
wdenk2d966952002-10-31 22:12:35 +0000820 }
wdenk6e592382004-04-18 17:39:38 +0000821 } else {
Joe Hershberger22f6e992012-05-23 07:59:14 +0000822 net_set_state(NETLOOP_RESTART);
wdenk2d966952002-10-31 22:12:35 +0000823 }
Joe Hershberger60304592015-03-22 17:09:24 -0500824 return ret;
wdenk2d966952002-10-31 22:12:35 +0000825}
826
827/**********************************************************************/
828/*
829 * Miscelaneous bits.
830 */
831
Joe Hershbergerece223b2012-05-23 07:59:15 +0000832static void dummy_handler(uchar *pkt, unsigned dport,
Joe Hershberger049a95a2015-04-08 01:41:01 -0500833 struct in_addr sip, unsigned sport,
Joe Hershbergerece223b2012-05-23 07:59:15 +0000834 unsigned len)
Joe Hershbergerd280d3f2012-05-23 07:58:01 +0000835{
Joe Hershbergerd280d3f2012-05-23 07:58:01 +0000836}
837
Joe Hershbergerece223b2012-05-23 07:59:15 +0000838rxhand_f *net_get_udp_handler(void)
wdenk2d966952002-10-31 22:12:35 +0000839{
Joe Hershbergerece223b2012-05-23 07:59:15 +0000840 return udp_packet_handler;
841}
842
843void net_set_udp_handler(rxhand_f *f)
844{
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500845 debug_cond(DEBUG_INT_STATE, "--- net_loop UDP handler set (%p)\n", f);
Joe Hershbergerece223b2012-05-23 07:59:15 +0000846 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{
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500859 debug_cond(DEBUG_INT_STATE, "--- net_loop ARP handler set (%p)\n", f);
Joe Hershbergerece223b2012-05-23 07:59:15 +0000860 if (f == NULL)
861 arp_packet_handler = dummy_handler;
862 else
863 arp_packet_handler = f;
wdenk2d966952002-10-31 22:12:35 +0000864}
865
Simon Glass39bccd22011-10-26 14:18:38 +0000866#ifdef CONFIG_CMD_TFTPPUT
Simon Glass4793ee62011-10-24 18:00:01 +0000867void net_set_icmp_handler(rxhand_icmp_f *f)
868{
869 packet_icmp_handler = f;
870}
Simon Glass39bccd22011-10-26 14:18:38 +0000871#endif
wdenk2d966952002-10-31 22:12:35 +0000872
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500873void net_set_timeout_handler(ulong iv, thand_f *f)
wdenk2d966952002-10-31 22:12:35 +0000874{
875 if (iv == 0) {
Joe Hershberger4ef8d532012-05-23 08:01:04 +0000876 debug_cond(DEBUG_INT_STATE,
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500877 "--- net_loop timeout handler cancelled\n");
878 time_handler = (thand_f *)0;
wdenk2d966952002-10-31 22:12:35 +0000879 } else {
Joe Hershberger4ef8d532012-05-23 08:01:04 +0000880 debug_cond(DEBUG_INT_STATE,
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500881 "--- 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;
wdenk2d966952002-10-31 22:12:35 +0000885 }
886}
887
Joe Hershbergerac3f26c2018-09-26 16:49:02 -0500888uchar *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
Joe Hershberger1203fcc2015-04-08 01:41:05 -0500896int net_send_udp_packet(uchar *ether, struct in_addr dest, int dport, int sport,
Joe Hershberger206d07f2012-05-23 07:58:10 +0000897 int payload_len)
wdenk73a8b272003-06-05 19:27:42 +0000898{
Duncan Hare5d457ec2018-06-24 15:40:41 -0700899 return net_send_ip_packet(ether, dest, dport, sport, payload_len,
900 IPPROTO_UDP, 0, 0, 0);
901}
902
Ying-Chun Liu (PaulLiu)a3bf1932022-11-08 14:17:28 +0800903#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
Duncan Hare5d457ec2018-06-24 15:40:41 -0700913int 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{
wdenka3d991b2004-04-15 21:48:45 +0000917 uchar *pkt;
Joe Hershberger92146372012-05-23 07:59:08 +0000918 int eth_hdr_size;
919 int pkt_hdr_size;
wdenka3d991b2004-04-15 21:48:45 +0000920
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500921 /* make sure the net_tx_packet is initialized (net_init() was called) */
Joe Hershberger1203fcc2015-04-08 01:41:05 -0500922 assert(net_tx_packet != NULL);
923 if (net_tx_packet == NULL)
Joe Hershberger46c495d2012-05-23 07:59:22 +0000924 return -1;
925
wdenk73a8b272003-06-05 19:27:42 +0000926 /* convert to new style broadcast */
Joe Hershberger049a95a2015-04-08 01:41:01 -0500927 if (dest.s_addr == 0)
928 dest.s_addr = 0xFFFFFFFF;
wdenk2d966952002-10-31 22:12:35 +0000929
wdenk73a8b272003-06-05 19:27:42 +0000930 /* if broadcast, make the ether address a broadcast and don't do ARP */
Joe Hershberger049a95a2015-04-08 01:41:01 -0500931 if (dest.s_addr == 0xFFFFFFFF)
Joe Hershberger0adb5b72015-04-08 01:41:04 -0500932 ether = (uchar *)net_bcast_ethaddr;
wdenk73a8b272003-06-05 19:27:42 +0000933
Joe Hershberger1203fcc2015-04-08 01:41:05 -0500934 pkt = (uchar *)net_tx_packet;
wdenk73a8b272003-06-05 19:27:42 +0000935
Joe Hershberger1203fcc2015-04-08 01:41:05 -0500936 eth_hdr_size = net_set_ether(pkt, ether, PROT_IP);
Duncan Hare5d457ec2018-06-24 15:40:41 -0700937
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;
Ying-Chun Liu (PaulLiu)a3bf1932022-11-08 14:17:28 +0800944#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
Duncan Hare5d457ec2018-06-24 15:40:41 -0700952 default:
953 return -EINVAL;
954 }
Robin Getz0ebf04c2009-07-23 03:01:03 -0400955
Joe Hershbergere94070c2012-05-23 07:59:24 +0000956 /* if MAC address was not discovered yet, do an ARP request */
Joe Hershberger0adb5b72015-04-08 01:41:04 -0500957 if (memcmp(ether, net_null_ethaddr, 6) == 0) {
Joe Hershberger4ef8d532012-05-23 08:01:04 +0000958 debug_cond(DEBUG_DEV_PKT, "sending ARP for %pI4\n", &dest);
Joe Hershberger92146372012-05-23 07:59:08 +0000959
960 /* save the ip and eth addr for the packet to send after arp */
Joe Hershberger049a95a2015-04-08 01:41:01 -0500961 net_arp_wait_packet_ip = dest;
Joe Hershberger85d25e02015-04-08 01:41:08 -0500962 arp_wait_packet_ethaddr = ether;
wdenka3d991b2004-04-15 21:48:45 +0000963
wdenk73a8b272003-06-05 19:27:42 +0000964 /* size of the waiting packet */
Joe Hershberger85d25e02015-04-08 01:41:08 -0500965 arp_wait_tx_packet_size = pkt_hdr_size + payload_len;
wdenk73a8b272003-06-05 19:27:42 +0000966
967 /* and do the ARP request */
Joe Hershberger85d25e02015-04-08 01:41:08 -0500968 arp_wait_try = 1;
969 arp_wait_timer_start = get_timer(0);
970 arp_request();
wdenk73a8b272003-06-05 19:27:42 +0000971 return 1; /* waiting */
Joe Hershberger92146372012-05-23 07:59:08 +0000972 } else {
Joe Hershberger4ef8d532012-05-23 08:01:04 +0000973 debug_cond(DEBUG_DEV_PKT, "sending UDP to %pI4/%pM\n",
Joe Hershbergerbc0571f2015-04-08 01:41:21 -0500974 &dest, ether);
Joe Hershberger1203fcc2015-04-08 01:41:05 -0500975 net_send_packet(net_tx_packet, pkt_hdr_size + payload_len);
Joe Hershberger92146372012-05-23 07:59:08 +0000976 return 0; /* transmitted */
wdenk73a8b272003-06-05 19:27:42 +0000977 }
wdenk73a8b272003-06-05 19:27:42 +0000978}
979
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +0200980#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 */
Joe Hershbergeraa7a6482016-08-15 14:42:15 -0500986#define IP_PKTSIZE (CONFIG_NET_MAXDEFRAG)
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +0200987
Joe Hershbergerc5c59df2012-05-23 07:58:05 +0000988#define IP_MAXUDP (IP_PKTSIZE - IP_HDR_SIZE)
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +0200989
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
Joe Hershbergerbc0571f2015-04-08 01:41:21 -05001002static struct ip_udp_hdr *__net_defragment(struct ip_udp_hdr *ip, int *lenp)
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001003{
Joe Hershberger48522bb2012-05-15 08:59:08 +00001004 static uchar pkt_buff[IP_PKTSIZE] __aligned(PKTALIGN);
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001005 static u16 first_hole, total_len;
1006 struct hole *payload, *thisfrag, *h, *newh;
Joe Hershberger594c26f2012-05-23 07:58:04 +00001007 struct ip_udp_hdr *localip = (struct ip_udp_hdr *)pkt_buff;
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001008 uchar *indata = (uchar *)ip;
1009 int offset8, start, len, done = 0;
1010 u16 ip_off = ntohs(ip->ip_off);
1011
Rasmus Villemoes1817c382022-10-14 19:43:39 +02001012 /*
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)
Fabio Estevamb85d1302022-05-26 11:14:37 -03001017 return NULL;
1018
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001019 /* payload starts after IP header, this fragment is in there */
Joe Hershbergerc5c59df2012-05-23 07:58:05 +00001020 payload = (struct hole *)(pkt_buff + IP_HDR_SIZE);
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001021 offset8 = (ip_off & IP_OFFS);
1022 thisfrag = payload + offset8;
1023 start = offset8 * 8;
Joe Hershbergerc5c59df2012-05-23 07:58:05 +00001024 len = ntohs(ip->ip_len) - IP_HDR_SIZE;
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001025
Rasmus Villemoes1817c382022-10-14 19:43:39 +02001026 /* All but last fragment must have a multiple-of-8 payload. */
1027 if ((len & 7) && (ip_off & IP_FLAGS_MFRAG))
1028 return NULL;
1029
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001030 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 */
Joe Hershbergerc5c59df2012-05-23 07:58:05 +00001041 memcpy(localip, ip, IP_HDR_SIZE);
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001042 }
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
Fillod Stephanee397e592010-06-11 19:26:43 +02001060 /* last fragment may be 1..7 bytes, the "+7" forces acceptance */
1061 if (offset8 + ((len + 7) / 8) <= h - payload) {
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001062 /* 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 /*
Rasmus Villemoes06869682022-10-17 09:52:51 +02001073 * 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.
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001078 */
Rasmus Villemoes06869682022-10-17 09:52:51 +02001079 if (h->last_byte < start + len)
1080 len = h->last_byte - start;
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001081
Luca Ceresoli4f63acd2011-05-11 03:59:56 +00001082 if ((h >= thisfrag) && (h->last_byte <= start + len)) {
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001083 /* 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 */
Joe Hershbergerc5c59df2012-05-23 07:58:05 +00001128 memcpy((uchar *)thisfrag, indata + IP_HDR_SIZE, len);
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001129 if (!done)
1130 return NULL;
1131
Joe Hershbergerc5c59df2012-05-23 07:58:05 +00001132 *lenp = total_len + IP_HDR_SIZE;
Rasmus Villemoes06653c72022-10-14 19:43:40 +02001133 localip->ip_len = htons(*lenp);
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001134 return localip;
1135}
1136
Joe Hershbergerbc0571f2015-04-08 01:41:21 -05001137static inline struct ip_udp_hdr *net_defragment(struct ip_udp_hdr *ip,
1138 int *lenp)
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001139{
1140 u16 ip_off = ntohs(ip->ip_off);
1141 if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG)))
1142 return ip; /* not a fragment */
Joe Hershbergerbc0571f2015-04-08 01:41:21 -05001143 return __net_defragment(ip, lenp);
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001144}
1145
1146#else /* !CONFIG_IP_DEFRAG */
1147
Joe Hershbergerbc0571f2015-04-08 01:41:21 -05001148static inline struct ip_udp_hdr *net_defragment(struct ip_udp_hdr *ip,
1149 int *lenp)
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001150{
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
wdenka3d991b2004-04-15 21:48:45 +00001157
Simon Glass8f79bb12011-10-24 18:00:00 +00001158/**
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 */
Joe Hershberger594c26f2012-05-23 07:58:04 +00001164static void receive_icmp(struct ip_udp_hdr *ip, int len,
Joe Hershberger049a95a2015-04-08 01:41:01 -05001165 struct in_addr src_ip, struct ethernet_hdr *et)
Simon Glass8f79bb12011-10-24 18:00:00 +00001166{
Joe Hershbergere0a63072012-05-23 07:58:09 +00001167 struct icmp_hdr *icmph = (struct icmp_hdr *)&ip->udp_src;
Simon Glass8f79bb12011-10-24 18:00:00 +00001168
1169 switch (icmph->type) {
1170 case ICMP_REDIRECT:
1171 if (icmph->code != ICMP_REDIR_HOST)
1172 return;
1173 printf(" ICMP Host Redirect to %pI4 ",
Joe Hershbergerbc0571f2015-04-08 01:41:21 -05001174 &icmph->un.gateway);
Simon Glass8f79bb12011-10-24 18:00:00 +00001175 break;
Simon Glass8f79bb12011-10-24 18:00:00 +00001176 default:
Joe Hershbergera36b12f2012-05-23 07:58:02 +00001177#if defined(CONFIG_CMD_PING)
1178 ping_receive(et, ip, len);
1179#endif
Simon Glass39bccd22011-10-26 14:18:38 +00001180#ifdef CONFIG_CMD_TFTPPUT
Simon Glass4793ee62011-10-24 18:00:01 +00001181 if (packet_icmp_handler)
1182 packet_icmp_handler(icmph->type, icmph->code,
Joe Hershbergerbc0571f2015-04-08 01:41:21 -05001183 ntohs(ip->udp_dst), src_ip,
1184 ntohs(ip->udp_src), icmph->un.data,
1185 ntohs(ip->udp_len));
Simon Glass39bccd22011-10-26 14:18:38 +00001186#endif
Simon Glass8f79bb12011-10-24 18:00:00 +00001187 break;
1188 }
1189}
1190
Joe Hershberger2a504df2015-03-22 17:09:11 -05001191void net_process_received_packet(uchar *in_packet, int len)
wdenk2d966952002-10-31 22:12:35 +00001192{
Joe Hershbergercb487f52012-05-23 07:58:06 +00001193 struct ethernet_hdr *et;
Joe Hershberger594c26f2012-05-23 07:58:04 +00001194 struct ip_udp_hdr *ip;
Joe Hershberger049a95a2015-04-08 01:41:01 -05001195 struct in_addr dst_ip;
1196 struct in_addr src_ip;
Joe Hershberger8d353eb2012-05-23 07:58:12 +00001197 int eth_proto;
Jon Loeliger643d1ab2007-07-09 17:45:14 -05001198#if defined(CONFIG_CMD_CDP)
wdenka3d991b2004-04-15 21:48:45 +00001199 int iscdp;
1200#endif
1201 ushort cti = 0, vlanid = VLAN_NONE, myvlanid, mynvlanid;
wdenk2d966952002-10-31 22:12:35 +00001202
Joe Hershberger4ef8d532012-05-23 08:01:04 +00001203 debug_cond(DEBUG_NET_PKT, "packet received\n");
wdenka3d991b2004-04-15 21:48:45 +00001204
Ramon Fried3eaac632019-07-18 21:43:30 +03001205#if defined(CONFIG_CMD_PCAP)
1206 pcap_post(in_packet, len, false);
1207#endif
Joe Hershberger1203fcc2015-04-08 01:41:05 -05001208 net_rx_packet = in_packet;
1209 net_rx_packet_len = len;
Joe Hershberger2a504df2015-03-22 17:09:11 -05001210 et = (struct ethernet_hdr *)in_packet;
wdenka3d991b2004-04-15 21:48:45 +00001211
1212 /* too small packet? */
1213 if (len < ETHER_HDR_SIZE)
1214 return;
1215
Alexander Graf0efe1bc2016-05-06 21:01:01 +02001216#if defined(CONFIG_API) || defined(CONFIG_EFI_LOADER)
Rafal Jaworowskif85b6072007-12-27 18:19:02 +01001217 if (push_packet) {
Joe Hershberger2a504df2015-03-22 17:09:11 -05001218 (*push_packet)(in_packet, len);
Rafal Jaworowskif85b6072007-12-27 18:19:02 +01001219 return;
1220 }
1221#endif
1222
Jon Loeliger643d1ab2007-07-09 17:45:14 -05001223#if defined(CONFIG_CMD_CDP)
wdenka3d991b2004-04-15 21:48:45 +00001224 /* keep track if packet is CDP */
Joe Hershberger17351882012-05-23 07:58:00 +00001225 iscdp = is_cdp_packet(et->et_dest);
wdenka3d991b2004-04-15 21:48:45 +00001226#endif
1227
Joe Hershberger4fd50552015-04-08 01:41:17 -05001228 myvlanid = ntohs(net_our_vlan);
wdenka3d991b2004-04-15 21:48:45 +00001229 if (myvlanid == (ushort)-1)
1230 myvlanid = VLAN_NONE;
Joe Hershberger4fd50552015-04-08 01:41:17 -05001231 mynvlanid = ntohs(net_native_vlan);
wdenka3d991b2004-04-15 21:48:45 +00001232 if (mynvlanid == (ushort)-1)
1233 mynvlanid = VLAN_NONE;
wdenk2d966952002-10-31 22:12:35 +00001234
Joe Hershberger8d353eb2012-05-23 07:58:12 +00001235 eth_proto = ntohs(et->et_protlen);
wdenk2d966952002-10-31 22:12:35 +00001236
Joe Hershberger8d353eb2012-05-23 07:58:12 +00001237 if (eth_proto < 1514) {
Joe Hershbergercb487f52012-05-23 07:58:06 +00001238 struct e802_hdr *et802 = (struct e802_hdr *)et;
wdenk2d966952002-10-31 22:12:35 +00001239 /*
Joe Hershbergerda5ebe22012-05-23 07:58:11 +00001240 * Got a 802.2 packet. Check the other protocol field.
1241 * XXX VLAN over 802.2+SNAP not implemented!
wdenk2d966952002-10-31 22:12:35 +00001242 */
Joe Hershberger8d353eb2012-05-23 07:58:12 +00001243 eth_proto = ntohs(et802->et_prot);
wdenka3d991b2004-04-15 21:48:45 +00001244
Joe Hershberger2a504df2015-03-22 17:09:11 -05001245 ip = (struct ip_udp_hdr *)(in_packet + E802_HDR_SIZE);
wdenk2d966952002-10-31 22:12:35 +00001246 len -= E802_HDR_SIZE;
wdenka3d991b2004-04-15 21:48:45 +00001247
Joe Hershberger8d353eb2012-05-23 07:58:12 +00001248 } else if (eth_proto != PROT_VLAN) { /* normal packet */
Joe Hershberger2a504df2015-03-22 17:09:11 -05001249 ip = (struct ip_udp_hdr *)(in_packet + ETHER_HDR_SIZE);
wdenk2d966952002-10-31 22:12:35 +00001250 len -= ETHER_HDR_SIZE;
wdenka3d991b2004-04-15 21:48:45 +00001251
1252 } else { /* VLAN packet */
Joe Hershbergerc68cca32012-05-23 07:58:07 +00001253 struct vlan_ethernet_hdr *vet =
1254 (struct vlan_ethernet_hdr *)et;
wdenka3d991b2004-04-15 21:48:45 +00001255
Joe Hershberger4ef8d532012-05-23 08:01:04 +00001256 debug_cond(DEBUG_NET_PKT, "VLAN packet received\n");
Robin Getz0ebf04c2009-07-23 03:01:03 -04001257
wdenka3d991b2004-04-15 21:48:45 +00001258 /* too small packet? */
1259 if (len < VLAN_ETHER_HDR_SIZE)
1260 return;
1261
1262 /* if no VLAN active */
Joe Hershberger4fd50552015-04-08 01:41:17 -05001263 if ((ntohs(net_our_vlan) & VLAN_IDMASK) == VLAN_NONE
Jon Loeliger643d1ab2007-07-09 17:45:14 -05001264#if defined(CONFIG_CMD_CDP)
wdenka3d991b2004-04-15 21:48:45 +00001265 && iscdp == 0
1266#endif
1267 )
1268 return;
1269
1270 cti = ntohs(vet->vet_tag);
1271 vlanid = cti & VLAN_IDMASK;
Joe Hershberger8d353eb2012-05-23 07:58:12 +00001272 eth_proto = ntohs(vet->vet_type);
wdenka3d991b2004-04-15 21:48:45 +00001273
Joe Hershberger2a504df2015-03-22 17:09:11 -05001274 ip = (struct ip_udp_hdr *)(in_packet + VLAN_ETHER_HDR_SIZE);
wdenka3d991b2004-04-15 21:48:45 +00001275 len -= VLAN_ETHER_HDR_SIZE;
wdenk2d966952002-10-31 22:12:35 +00001276 }
1277
Joe Hershberger4ef8d532012-05-23 08:01:04 +00001278 debug_cond(DEBUG_NET_PKT, "Receive from protocol 0x%x\n", eth_proto);
wdenk2d966952002-10-31 22:12:35 +00001279
Jon Loeliger643d1ab2007-07-09 17:45:14 -05001280#if defined(CONFIG_CMD_CDP)
wdenka3d991b2004-04-15 21:48:45 +00001281 if (iscdp) {
Joe Hershberger0b4c5ff2012-05-23 07:58:13 +00001282 cdp_receive((uchar *)ip, len);
wdenka3d991b2004-04-15 21:48:45 +00001283 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
Joe Hershberger8d353eb2012-05-23 07:58:12 +00001295 switch (eth_proto) {
wdenk2d966952002-10-31 22:12:35 +00001296 case PROT_ARP:
Joe Hershberger85d25e02015-04-08 01:41:08 -05001297 arp_receive(et, ip, len);
wdenk289f9322005-01-12 00:15:14 +00001298 break;
wdenk2d966952002-10-31 22:12:35 +00001299
Peter Tyserbf6cb242010-09-30 11:25:48 -05001300#ifdef CONFIG_CMD_RARP
wdenk2d966952002-10-31 22:12:35 +00001301 case PROT_RARP:
Joe Hershberger8b9c5322012-05-23 07:58:03 +00001302 rarp_receive(ip, len);
wdenk2d966952002-10-31 22:12:35 +00001303 break;
Peter Tyserbf6cb242010-09-30 11:25:48 -05001304#endif
Viacheslav Mitrofanovffdbf3b2022-12-02 12:18:06 +03001305#if IS_ENABLED(CONFIG_IPV6)
1306 case PROT_IP6:
1307 net_ip6_handler(et, (struct ip6_hdr *)ip, len);
Viacheslav Mitrofanov0d6d5a42022-12-06 10:08:16 +03001308 break;
Viacheslav Mitrofanovffdbf3b2022-12-02 12:18:06 +03001309#endif
wdenk2d966952002-10-31 22:12:35 +00001310 case PROT_IP:
Joe Hershberger4ef8d532012-05-23 08:01:04 +00001311 debug_cond(DEBUG_NET_PKT, "Got IP\n");
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001312 /* Before we start poking the header, make sure it is there */
Rasmus Villemoesad359d82022-10-14 19:43:38 +02001313 if (len < IP_HDR_SIZE) {
Joe Hershberger594c26f2012-05-23 07:58:04 +00001314 debug("len bad %d < %lu\n", len,
Rasmus Villemoesad359d82022-10-14 19:43:38 +02001315 (ulong)IP_HDR_SIZE);
wdenk2d966952002-10-31 22:12:35 +00001316 return;
1317 }
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001318 /* Check the packet length */
wdenk2d966952002-10-31 22:12:35 +00001319 if (len < ntohs(ip->ip_len)) {
Joe Hershberger4ef8d532012-05-23 08:01:04 +00001320 debug("len bad %d < %d\n", len, ntohs(ip->ip_len));
wdenk2d966952002-10-31 22:12:35 +00001321 return;
1322 }
1323 len = ntohs(ip->ip_len);
Rasmus Villemoesad359d82022-10-14 19:43:38 +02001324 if (len < IP_HDR_SIZE) {
1325 debug("bad ip->ip_len %d < %d\n", len, (int)IP_HDR_SIZE);
1326 return;
1327 }
Joe Hershberger4ef8d532012-05-23 08:01:04 +00001328 debug_cond(DEBUG_NET_PKT, "len=%d, v=%02x\n",
Joe Hershbergerbc0571f2015-04-08 01:41:21 -05001329 len, ip->ip_hl_v & 0xff);
Robin Getz0ebf04c2009-07-23 03:01:03 -04001330
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001331 /* Can't deal with anything except IPv4 */
Luca Ceresolid3c65b02011-05-04 02:40:43 +00001332 if ((ip->ip_hl_v & 0xf0) != 0x40)
wdenk2d966952002-10-31 22:12:35 +00001333 return;
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001334 /* Can't deal with IP options (headers != 20 bytes) */
Rasmus Villemoesb0fcc482022-10-14 19:43:37 +02001335 if ((ip->ip_hl_v & 0x0f) != 0x05)
Remy Bohmer6b52cfe2008-06-03 15:48:17 +02001336 return;
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001337 /* Check the Checksum of the header */
Simon Glass0da0fcd2015-01-19 22:16:08 -07001338 if (!ip_checksum_ok((uchar *)ip, IP_HDR_SIZE)) {
Joe Hershberger4ef8d532012-05-23 08:01:04 +00001339 debug("checksum bad\n");
wdenk2d966952002-10-31 22:12:35 +00001340 return;
1341 }
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001342 /* If it is not for us, ignore it */
Joe Hershberger049a95a2015-04-08 01:41:01 -05001343 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) {
Luca Ceresolic819abe2011-05-04 02:40:46 +00001346 return;
wdenk2d966952002-10-31 22:12:35 +00001347 }
Luca Ceresoli03eb1292011-04-18 06:19:50 +00001348 /* Read source IP address for later use */
Joe Hershberger049a95a2015-04-08 01:41:01 -05001349 src_ip = net_read_ip(&ip->ip_src);
wdenk2d966952002-10-31 22:12:35 +00001350 /*
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001351 * 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 */
Joe Hershbergerbc0571f2015-04-08 01:41:21 -05001355 ip = net_defragment(ip, &len);
Luca Ceresoliccb9ebe2011-05-04 02:40:47 +00001356 if (!ip)
Alessandro Rubini5cfaa4e2009-08-07 13:58:56 +02001357 return;
1358 /*
wdenk2d966952002-10-31 22:12:35 +00001359 * watch for ICMP host redirects
1360 *
wdenk8bde7f72003-06-27 21:31:46 +00001361 * 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 :-)
wdenk2d966952002-10-31 22:12:35 +00001366 *
wdenk8bde7f72003-06-27 21:31:46 +00001367 * 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.
Simon Glass4793ee62011-10-24 18:00:01 +00001374 *
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.
wdenk2d966952002-10-31 22:12:35 +00001378 */
1379 if (ip->ip_p == IPPROTO_ICMP) {
Simon Glass8f79bb12011-10-24 18:00:00 +00001380 receive_icmp(ip, len, src_ip, et);
1381 return;
Ying-Chun Liu (PaulLiu)a3bf1932022-11-08 14:17:28 +08001382#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
wdenk2d966952002-10-31 22:12:35 +00001391 } else if (ip->ip_p != IPPROTO_UDP) { /* Only UDP packets */
1392 return;
1393 }
1394
Rasmus Villemoes06653c72022-10-14 19:43:40 +02001395 if (ntohs(ip->udp_len) < UDP_HDR_SIZE || ntohs(ip->udp_len) > len - IP_HDR_SIZE)
liucheng (G)fe728802019-08-29 13:47:33 +00001396 return;
1397
Joe Hershberger4ef8d532012-05-23 08:01:04 +00001398 debug_cond(DEBUG_DEV_PKT,
Joe Hershbergerbc0571f2015-04-08 01:41:21 -05001399 "received UDP (to=%pI4, from=%pI4, len=%d)\n",
1400 &dst_ip, &src_ip, len);
Joe Hershberger4ef8d532012-05-23 08:01:04 +00001401
Simon Glass4b37fd12021-12-18 11:27:49 -07001402 if (IS_ENABLED(CONFIG_UDP_CHECKSUM) && ip->udp_xsum != 0) {
Wolfgang Denkb2f50802005-08-12 23:43:12 +02001403 ulong xsum;
Heinrich Schuchardt85244232019-11-05 12:48:19 +01001404 u8 *sumptr;
Stefan Roese8534bf92005-08-12 20:06:52 +02001405 ushort sumlen;
1406
1407 xsum = ip->ip_p;
1408 xsum += (ntohs(ip->udp_len));
Joe Hershberger049a95a2015-04-08 01:41:01 -05001409 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;
Stefan Roese8534bf92005-08-12 20:06:52 +02001413
1414 sumlen = ntohs(ip->udp_len);
Heinrich Schuchardt85244232019-11-05 12:48:19 +01001415 sumptr = (u8 *)&ip->udp_src;
Stefan Roese8534bf92005-08-12 20:06:52 +02001416
1417 while (sumlen > 1) {
Heinrich Schuchardt85244232019-11-05 12:48:19 +01001418 /* inlined ntohs() to avoid alignment errors */
1419 xsum += (sumptr[0] << 8) + sumptr[1];
1420 sumptr += 2;
Stefan Roese8534bf92005-08-12 20:06:52 +02001421 sumlen -= 2;
1422 }
Heinrich Schuchardt85244232019-11-05 12:48:19 +01001423 if (sumlen > 0)
1424 xsum += (sumptr[0] << 8) + sumptr[0];
Stefan Roese8534bf92005-08-12 20:06:52 +02001425 while ((xsum >> 16) != 0) {
Luca Ceresoli3e38e422011-05-11 03:59:54 +00001426 xsum = (xsum & 0x0000ffff) +
1427 ((xsum >> 16) & 0x0000ffff);
Stefan Roese8534bf92005-08-12 20:06:52 +02001428 }
1429 if ((xsum != 0x00000000) && (xsum != 0x0000ffff)) {
Wolfgang Denk9b55a252008-07-11 01:16:00 +02001430 printf(" UDP wrong checksum %08lx %08x\n",
Joe Hershbergerbc0571f2015-04-08 01:41:21 -05001431 xsum, ntohs(ip->udp_xsum));
Stefan Roese8534bf92005-08-12 20:06:52 +02001432 return;
1433 }
1434 }
Stefan Roese8534bf92005-08-12 20:06:52 +02001435
Holger Dengler66c89ee2017-07-20 10:10:55 +02001436#if defined(CONFIG_NETCONSOLE) && !defined(CONFIG_SPL_BUILD)
Joe Hershberger594c26f2012-05-23 07:58:04 +00001437 nc_input_packet((uchar *)ip + IP_UDP_HDR_SIZE,
Joe Hershbergerece223b2012-05-23 07:59:15 +00001438 src_ip,
Joe Hershbergerbc0571f2015-04-08 01:41:21 -05001439 ntohs(ip->udp_dst),
Joe Hershbergerece223b2012-05-23 07:59:15 +00001440 ntohs(ip->udp_src),
1441 ntohs(ip->udp_len) - UDP_HDR_SIZE);
Joe Hershbergerbc0571f2015-04-08 01:41:21 -05001442#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);
wdenk2d966952002-10-31 22:12:35 +00001451 break;
Lothar Feltend8970da2018-06-22 22:29:54 +02001452#ifdef CONFIG_CMD_WOL
1453 case PROT_WOL:
1454 wol_receive(ip, len);
1455 break;
1456#endif
Samuel Mendoza-Jonas09bd3d02022-08-08 21:46:03 +09301457#ifdef CONFIG_PHY_NCSI
1458 case PROT_NCSI:
1459 ncsi_receive(et, ip, len);
1460 break;
1461#endif
wdenk2d966952002-10-31 22:12:35 +00001462 }
1463}
1464
wdenk2d966952002-10-31 22:12:35 +00001465/**********************************************************************/
1466
Simon Glasse4bf0c52011-10-24 18:00:02 +00001467static int net_check_prereq(enum proto_t protocol)
wdenk2d966952002-10-31 22:12:35 +00001468{
1469 switch (protocol) {
wdenk6e592382004-04-18 17:39:38 +00001470 /* Fall through */
Jon Loeliger643d1ab2007-07-09 17:45:14 -05001471#if defined(CONFIG_CMD_PING)
wdenk73a8b272003-06-05 19:27:42 +00001472 case PING:
Joe Hershberger049a95a2015-04-08 01:41:01 -05001473 if (net_ping_ip.s_addr == 0) {
Luca Ceresoli4f63acd2011-05-11 03:59:56 +00001474 puts("*** ERROR: ping address not given\n");
Luca Ceresoli92895de2011-05-04 02:40:45 +00001475 return 1;
wdenk6e592382004-04-18 17:39:38 +00001476 }
1477 goto common;
wdenk73a8b272003-06-05 19:27:42 +00001478#endif
Viacheslav Mitrofanoveeb0a2c2022-12-02 12:18:08 +03001479#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
Robin Getz1a32bf42009-07-20 14:53:54 -04001487#if defined(CONFIG_CMD_DNS)
1488 case DNS:
Joe Hershberger049a95a2015-04-08 01:41:01 -05001489 if (net_dns_server.s_addr == 0) {
Robin Getz1a32bf42009-07-20 14:53:54 -04001490 puts("*** ERROR: DNS server address not given\n");
1491 return 1;
1492 }
1493 goto common;
1494#endif
Philippe Reynesb43ea1b2020-09-18 14:13:00 +02001495#if defined(CONFIG_PROT_UDP)
1496 case UDP:
1497 if (udp_prereq())
1498 return 1;
1499 goto common;
1500#endif
1501
Jon Loeliger643d1ab2007-07-09 17:45:14 -05001502#if defined(CONFIG_CMD_NFS)
wdenkcbd8a352004-02-24 02:00:03 +00001503 case NFS:
1504#endif
Joe Hershbergerbc0571f2015-04-08 01:41:21 -05001505 /* Fall through */
Simon Glasse4bf0c52011-10-24 18:00:02 +00001506 case TFTPGET:
Simon Glass1fb7cd42011-10-24 18:00:07 +00001507 case TFTPPUT:
Viacheslav Mitrofanov7fbf2302022-12-02 12:18:07 +03001508 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()) {
Luca Ceresoli4f63acd2011-05-11 03:59:56 +00001516 puts("*** ERROR: `serverip' not set\n");
Luca Ceresoli92895de2011-05-04 02:40:45 +00001517 return 1;
wdenk6e592382004-04-18 17:39:38 +00001518 }
Philippe Reynes912ece42020-09-18 14:13:02 +02001519#if defined(CONFIG_CMD_PING) || \
Philippe Reynesb43ea1b2020-09-18 14:13:00 +02001520 defined(CONFIG_CMD_DNS) || defined(CONFIG_PROT_UDP)
Luca Ceresoli4f63acd2011-05-11 03:59:56 +00001521common:
wdenk73a8b272003-06-05 19:27:42 +00001522#endif
Simon Guinot8b6bbe12011-05-01 23:38:40 +00001523 /* Fall through */
wdenk73a8b272003-06-05 19:27:42 +00001524
Simon Guinot8b6bbe12011-05-01 23:38:40 +00001525 case NETCONS:
Dmitrii Merkurev443d3192023-04-12 19:49:30 +01001526 case FASTBOOT_UDP:
1527 case FASTBOOT_TCP:
Luca Ceresoli7a83af02011-05-17 00:03:40 +00001528 case TFTPSRV:
Viacheslav Mitrofanov7fbf2302022-12-02 12:18:07 +03001529 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) {
Luca Ceresoli4f63acd2011-05-11 03:59:56 +00001536 puts("*** ERROR: `ipaddr' not set\n");
Luca Ceresoli92895de2011-05-04 02:40:45 +00001537 return 1;
wdenk6e592382004-04-18 17:39:38 +00001538 }
1539 /* Fall through */
wdenk2d966952002-10-31 22:12:35 +00001540
Peter Tyserbf6cb242010-09-30 11:25:48 -05001541#ifdef CONFIG_CMD_RARP
wdenk2d966952002-10-31 22:12:35 +00001542 case RARP:
Peter Tyserbf6cb242010-09-30 11:25:48 -05001543#endif
Samuel Mendoza-Jonas09bd3d02022-08-08 21:46:03 +09301544#ifdef CONFIG_PHY_NCSI
1545 case NCSI:
1546#endif
wdenk2d966952002-10-31 22:12:35 +00001547 case BOOTP:
wdenka3d991b2004-04-15 21:48:45 +00001548 case CDP:
Peter Tyserbf6cb242010-09-30 11:25:48 -05001549 case DHCP:
Joe Hershbergerd22c3382012-05-23 08:00:12 +00001550 case LINKLOCAL:
Joe Hershberger0adb5b72015-04-08 01:41:04 -05001551 if (memcmp(net_ethaddr, "\0\0\0\0\0\0", 6) == 0) {
Luca Ceresoli4f63acd2011-05-11 03:59:56 +00001552 int num = eth_get_dev_index();
wdenk2d966952002-10-31 22:12:35 +00001553
wdenk6e592382004-04-18 17:39:38 +00001554 switch (num) {
1555 case -1:
Luca Ceresoli4f63acd2011-05-11 03:59:56 +00001556 puts("*** ERROR: No ethernet found.\n");
Luca Ceresoli92895de2011-05-04 02:40:45 +00001557 return 1;
wdenk6e592382004-04-18 17:39:38 +00001558 case 0:
Luca Ceresoli4f63acd2011-05-11 03:59:56 +00001559 puts("*** ERROR: `ethaddr' not set\n");
wdenk2d966952002-10-31 22:12:35 +00001560 break;
wdenk6e592382004-04-18 17:39:38 +00001561 default:
Luca Ceresoli4f63acd2011-05-11 03:59:56 +00001562 printf("*** ERROR: `eth%daddr' not set\n",
Joe Hershbergerbc0571f2015-04-08 01:41:21 -05001563 num);
wdenk2d966952002-10-31 22:12:35 +00001564 break;
wdenk2d966952002-10-31 22:12:35 +00001565 }
wdenk6e592382004-04-18 17:39:38 +00001566
Joe Hershbergerbc0571f2015-04-08 01:41:21 -05001567 net_start_again();
Luca Ceresoli92895de2011-05-04 02:40:45 +00001568 return 2;
wdenk6e592382004-04-18 17:39:38 +00001569 }
1570 /* Fall through */
1571 default:
Luca Ceresoli92895de2011-05-04 02:40:45 +00001572 return 0;
wdenk2d966952002-10-31 22:12:35 +00001573 }
Luca Ceresoli92895de2011-05-04 02:40:45 +00001574 return 0; /* OK */
wdenk2d966952002-10-31 22:12:35 +00001575}
1576/**********************************************************************/
1577
1578int
Joe Hershberger1203fcc2015-04-08 01:41:05 -05001579net_eth_hdr_size(void)
wdenka3d991b2004-04-15 21:48:45 +00001580{
1581 ushort myvlanid;
wdenk2d966952002-10-31 22:12:35 +00001582
Joe Hershberger4fd50552015-04-08 01:41:17 -05001583 myvlanid = ntohs(net_our_vlan);
wdenka3d991b2004-04-15 21:48:45 +00001584 if (myvlanid == (ushort)-1)
1585 myvlanid = VLAN_NONE;
1586
Luca Ceresoli3e38e422011-05-11 03:59:54 +00001587 return ((myvlanid & VLAN_IDMASK) == VLAN_NONE) ? ETHER_HDR_SIZE :
1588 VLAN_ETHER_HDR_SIZE;
wdenka3d991b2004-04-15 21:48:45 +00001589}
1590
Joe Hershberger1203fcc2015-04-08 01:41:05 -05001591int net_set_ether(uchar *xet, const uchar *dest_ethaddr, uint prot)
wdenk2d966952002-10-31 22:12:35 +00001592{
Joe Hershbergercb487f52012-05-23 07:58:06 +00001593 struct ethernet_hdr *et = (struct ethernet_hdr *)xet;
wdenka3d991b2004-04-15 21:48:45 +00001594 ushort myvlanid;
1595
Joe Hershberger4fd50552015-04-08 01:41:17 -05001596 myvlanid = ntohs(net_our_vlan);
wdenka3d991b2004-04-15 21:48:45 +00001597 if (myvlanid == (ushort)-1)
1598 myvlanid = VLAN_NONE;
wdenk2d966952002-10-31 22:12:35 +00001599
Joe Hershberger0adb5b72015-04-08 01:41:04 -05001600 memcpy(et->et_dest, dest_ethaddr, 6);
1601 memcpy(et->et_src, net_ethaddr, 6);
wdenka3d991b2004-04-15 21:48:45 +00001602 if ((myvlanid & VLAN_IDMASK) == VLAN_NONE) {
Luca Ceresolic819abe2011-05-04 02:40:46 +00001603 et->et_protlen = htons(prot);
wdenka3d991b2004-04-15 21:48:45 +00001604 return ETHER_HDR_SIZE;
1605 } else {
Joe Hershbergerc68cca32012-05-23 07:58:07 +00001606 struct vlan_ethernet_hdr *vet =
1607 (struct vlan_ethernet_hdr *)xet;
wdenk2d966952002-10-31 22:12:35 +00001608
wdenka3d991b2004-04-15 21:48:45 +00001609 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}
wdenk2d966952002-10-31 22:12:35 +00001615
Joe Hershbergere7111012012-05-23 07:59:16 +00001616int net_update_ether(struct ethernet_hdr *et, uchar *addr, uint prot)
1617{
1618 ushort protlen;
1619
1620 memcpy(et->et_dest, addr, 6);
Joe Hershberger0adb5b72015-04-08 01:41:04 -05001621 memcpy(et->et_src, net_ethaddr, 6);
Joe Hershbergere7111012012-05-23 07:59:16 +00001622 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
Duncan Hare5d457ec2018-06-24 15:40:41 -07001639void net_set_ip_header(uchar *pkt, struct in_addr dest, struct in_addr source,
1640 u16 pkt_len, u8 proto)
wdenk2d966952002-10-31 22:12:35 +00001641{
Joe Hershberger4b11c912012-05-23 07:59:07 +00001642 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;
Duncan Hare5d457ec2018-06-24 15:40:41 -07001650 ip->ip_len = htons(pkt_len);
1651 ip->ip_p = proto;
Joe Hershbergerbc0571f2015-04-08 01:41:21 -05001652 ip->ip_id = htons(net_ip_id++);
Joe Hershberger4b11c912012-05-23 07:59:07 +00001653 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 */
Joe Hershberger049a95a2015-04-08 01:41:01 -05001657 net_copy_ip((void *)&ip->ip_src, &source);
Joe Hershberger4b11c912012-05-23 07:59:07 +00001658 /* already in network byte order */
Joe Hershberger049a95a2015-04-08 01:41:01 -05001659 net_copy_ip((void *)&ip->ip_dst, &dest);
Duncan Hare5d457ec2018-06-24 15:40:41 -07001660
1661 ip->ip_sum = compute_ip_checksum(ip, IP_HDR_SIZE);
Joe Hershberger4b11c912012-05-23 07:59:07 +00001662}
1663
Joe Hershberger049a95a2015-04-08 01:41:01 -05001664void net_set_udp_header(uchar *pkt, struct in_addr dest, int dport, int sport,
Joe Hershberger4b11c912012-05-23 07:59:07 +00001665 int len)
1666{
1667 struct ip_udp_hdr *ip = (struct ip_udp_hdr *)pkt;
wdenk2d966952002-10-31 22:12:35 +00001668
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)
Joe Hershberger4b11c912012-05-23 07:59:07 +00001675 pkt[IP_UDP_HDR_SIZE + len] = 0;
wdenk2d966952002-10-31 22:12:35 +00001676
Duncan Hare5d457ec2018-06-24 15:40:41 -07001677 net_set_ip_header(pkt, dest, net_ip, IP_UDP_HDR_SIZE + len,
1678 IPPROTO_UDP);
Joe Hershberger4b11c912012-05-23 07:59:07 +00001679
wdenk2d966952002-10-31 22:12:35 +00001680 ip->udp_src = htons(sport);
1681 ip->udp_dst = htons(dport);
Joe Hershberger594c26f2012-05-23 07:58:04 +00001682 ip->udp_len = htons(UDP_HDR_SIZE + len);
wdenk2d966952002-10-31 22:12:35 +00001683 ip->udp_xsum = 0;
wdenk2d966952002-10-31 22:12:35 +00001684}
1685
Luca Ceresoli4f63acd2011-05-11 03:59:56 +00001686void copy_filename(char *dst, const char *src, int size)
wdenk2d966952002-10-31 22:12:35 +00001687{
Joe Hershberger16cf1452018-07-03 19:36:41 -05001688 if (src && *src && (*src == '"')) {
wdenk2d966952002-10-31 22:12:35 +00001689 ++src;
1690 --size;
1691 }
1692
Joe Hershberger16cf1452018-07-03 19:36:41 -05001693 while ((--size > 0) && src && *src && (*src != '"'))
wdenk2d966952002-10-31 22:12:35 +00001694 *dst++ = *src++;
wdenk2d966952002-10-31 22:12:35 +00001695 *dst = '\0';
1696}
1697
Joe Hershberger3a66fcb2018-07-03 19:36:39 -05001698int is_serverip_in_cmd(void)
1699{
1700 return !!strchr(net_boot_file_name, ':');
1701}
1702
Joe Hershberger6ab12832018-07-03 19:36:43 -05001703int net_parse_bootfile(struct in_addr *ipaddr, char *filename, int max_len)
1704{
1705 char *colon;
Lyle Franklin85f8e032022-04-16 11:36:43 -04001706 struct in_addr ip;
1707 ip.s_addr = 0;
Joe Hershberger6ab12832018-07-03 19:36:43 -05001708
1709 if (net_boot_file_name[0] == '\0')
1710 return 0;
1711
1712 colon = strchr(net_boot_file_name, ':');
1713 if (colon) {
Lyle Franklin85f8e032022-04-16 11:36:43 -04001714 ip = string_to_ip(net_boot_file_name);
1715 if (ipaddr && ip.s_addr)
1716 *ipaddr = ip;
1717 }
1718 if (ip.s_addr) {
Joe Hershberger6ab12832018-07-03 19:36:43 -05001719 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
Joe Hershberger049a95a2015-04-08 01:41:01 -05001728void ip_to_string(struct in_addr x, char *s)
wdenk2d966952002-10-31 22:12:35 +00001729{
Joe Hershberger049a95a2015-04-08 01:41:01 -05001730 x.s_addr = ntohl(x.s_addr);
Luca Ceresoli4f63acd2011-05-11 03:59:56 +00001731 sprintf(s, "%d.%d.%d.%d",
Joe Hershberger049a95a2015-04-08 01:41:01 -05001732 (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)
wdenk6e592382004-04-18 17:39:38 +00001736 );
wdenk2d966952002-10-31 22:12:35 +00001737}
1738
Joe Hershberger4fd50552015-04-08 01:41:17 -05001739void vlan_to_string(ushort x, char *s)
wdenka3d991b2004-04-15 21:48:45 +00001740{
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
Joe Hershberger4fd50552015-04-08 01:41:17 -05001752ushort string_to_vlan(const char *s)
wdenka3d991b2004-04-15 21:48:45 +00001753{
1754 ushort id;
1755
1756 if (s == NULL)
wdenkb9711de2004-04-25 13:18:40 +00001757 return htons(VLAN_NONE);
wdenka3d991b2004-04-15 21:48:45 +00001758
1759 if (*s < '0' || *s > '9')
1760 id = VLAN_NONE;
1761 else
Simon Glass0b1284e2021-07-24 09:03:30 -06001762 id = (ushort)dectoul(s, NULL);
wdenka3d991b2004-04-15 21:48:45 +00001763
wdenkb9711de2004-04-25 13:18:40 +00001764 return htons(id);
wdenka3d991b2004-04-15 21:48:45 +00001765}
1766
Simon Glass723806c2017-08-03 12:22:15 -06001767ushort env_get_vlan(char *var)
wdenka3d991b2004-04-15 21:48:45 +00001768{
Simon Glass00caae62017-08-03 12:22:12 -06001769 return string_to_vlan(env_get(var));
wdenka3d991b2004-04-15 21:48:45 +00001770}