]> git.ipfire.org Git - people/ms/u-boot.git/blame - net/net.c
net: Move common init into a new eth_common.c file
[people/ms/u-boot.git] / net / net.c
CommitLineData
2d966958
WD
1/*
2 * Copied from Linux Monitor (LiMon) - Networking.
3 *
4 * Copyright 1994 - 2000 Neil Russell.
5 * (See License)
6 * Copyright 2000 Roland Borde
7 * Copyright 2000 Paolo Scaffardi
8 * Copyright 2000-2002 Wolfgang Denk, wd@denx.de
2ea91039 9 * SPDX-License-Identifier: GPL-2.0
2d966958
WD
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 *
d22c338e
JH
27 * LINK_LOCAL:
28 *
29 * Prerequisites: - own ethernet address
30 * We want: - own IP address
31 * Next step: ARP
32 *
2d966958
WD
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 *
b2f50807
WD
50 * Prerequisites: - own ethernet address
51 * We want: - IP, Netmask, ServerIP, Gateway IP
52 * - bootfilename, lease time
53 * Next step: - TFTP
2d966958
WD
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
cbd8a35c
WD
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
ea287deb
WD
74 *
75 * SNTP:
76 *
b2f50807 77 * Prerequisites: - own ethernet address
ea287deb
WD
78 * - own IP address
79 * We want: - network time
80 * Next step: none
2d966958
WD
81 */
82
83
84#include <common.h>
2d966958 85#include <command.h>
24b852a7 86#include <console.h>
a9f51c9b 87#include <environment.h>
60304592 88#include <errno.h>
2d966958 89#include <net.h>
34696958 90#include <net/tftp.h>
4545f4e6 91#if defined(CONFIG_STATUS_LED)
fc3e2165 92#include <miiphy.h>
4545f4e6 93#include <status_led.h>
fc3e2165 94#endif
4545f4e6
JH
95#include <watchdog.h>
96#include <linux/compiler.h>
97#include "arp.h"
98#include "bootp.h"
f575ae1f 99#include "cdp.h"
1a32bf41
RG
100#if defined(CONFIG_CMD_DNS)
101#include "dns.h"
102#endif
d22c338e 103#include "link_local.h"
4545f4e6 104#include "nfs.h"
a36b12f9 105#include "ping.h"
4545f4e6
JH
106#include "rarp.h"
107#if defined(CONFIG_CMD_SNTP)
108#include "sntp.h"
109#endif
2d966958 110
d87080b7
WD
111DECLARE_GLOBAL_DATA_PTR;
112
2d966958
WD
113/** BOOTP EXTENTIONS **/
114
3e38e429 115/* Our subnet mask (0=unknown) */
049a95a7 116struct in_addr net_netmask;
3e38e429 117/* Our gateways IP address */
049a95a7 118struct in_addr net_gateway;
3e38e429 119/* Our DNS IP address */
049a95a7 120struct in_addr net_dns_server;
1fe80d79 121#if defined(CONFIG_BOOTP_DNS2)
3e38e429 122/* Our 2nd DNS IP address */
049a95a7 123struct in_addr net_dns_server2;
3e38e429 124#endif
2d966958 125
53a5c424 126#ifdef CONFIG_MCAST_TFTP /* Multicast TFTP */
049a95a7 127struct in_addr net_mcast_addr;
53a5c424
DU
128#endif
129
2d966958
WD
130/** END OF BOOTP EXTENTIONS **/
131
3e38e429 132/* Our ethernet address */
0adb5b76 133u8 net_ethaddr[6];
3e38e429 134/* Boot server enet address */
0adb5b76 135u8 net_server_ethaddr[6];
3e38e429 136/* Our IP addr (0 = unknown) */
049a95a7 137struct in_addr net_ip;
3e38e429 138/* Server IP addr (0 = unknown) */
049a95a7 139struct in_addr net_server_ip;
3e38e429 140/* Current receive packet */
1203fcce 141uchar *net_rx_packet;
3e38e429 142/* Current rx packet length */
1203fcce 143int net_rx_packet_len;
3e38e429 144/* IP packet ID */
bc0571fc 145static unsigned net_ip_id;
3e38e429 146/* Ethernet bcast address */
0adb5b76
JH
147const u8 net_bcast_ethaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
148const u8 net_null_ethaddr[6];
f85b6071 149#ifdef CONFIG_API
bc0571fc 150void (*push_packet)(void *, int len) = 0;
f85b6071 151#endif
3e38e429 152/* Network loop state */
22f6e99d 153enum net_loop_state net_state;
3e38e429 154/* Tried all network devices */
bc0571fc 155int net_restart_wrap;
3e38e429 156/* Network loop restarted */
bc0571fc 157static int net_restarted;
3e38e429 158/* At least one device configured */
bc0571fc 159static int net_dev_exists;
2d966958 160
6e592385 161/* XXX in both little & big endian machines 0xFFFF == ntohs(-1) */
3e38e429 162/* default is without VLAN */
4fd5055f 163ushort net_our_vlan = 0xFFFF;
3e38e429 164/* ditto */
4fd5055f 165ushort net_native_vlan = 0xFFFF;
a3d991bd 166
3e38e429 167/* Boot File name */
11a69ff8 168char net_boot_file_name[1024];
1411157d
JH
169/* The actual transferred size of the bootfile (in bytes) */
170u32 net_boot_file_size;
171/* Boot file size in blocks as reported by the DHCP server */
172u32 net_boot_file_expected_size_in_blocks;
2d966958 173
643d1ab2 174#if defined(CONFIG_CMD_SNTP)
3e38e429 175/* NTP server IP address */
049a95a7 176struct in_addr net_ntp_server;
3e38e429 177/* offset time from UTC */
bc0571fc 178int net_ntp_time_offset;
ea287deb
WD
179#endif
180
1203fcce 181static uchar net_pkt_buf[(PKTBUFSRX+1) * PKTSIZE_ALIGN + PKTALIGN];
2a504df0
JH
182/* Receive packets */
183uchar *net_rx_packets[PKTBUFSRX];
ece223b5
JH
184/* Current UDP RX packet handler */
185static rxhand_f *udp_packet_handler;
186/* Current ARP RX packet handler */
187static rxhand_f *arp_packet_handler;
39bccd21 188#ifdef CONFIG_CMD_TFTPPUT
ece223b5
JH
189/* Current ICMP rx handler */
190static rxhand_icmp_f *packet_icmp_handler;
39bccd21 191#endif
3e38e429 192/* Current timeout handler */
bc0571fc 193static thand_f *time_handler;
3e38e429 194/* Time base value */
bc0571fc 195static ulong time_start;
3e38e429 196/* Current timeout value */
bc0571fc 197static ulong time_delta;
3e38e429 198/* THE transmit packet */
1203fcce 199uchar *net_tx_packet;
2d966958 200
e4bf0c5c 201static int net_check_prereq(enum proto_t protocol);
2d966958 202
bc0571fc 203static int net_try_count;
67b96e87 204
b63056d6
JL
205int __maybe_unused net_busy_flag;
206
73a8b27c
WD
207/**********************************************************************/
208
a9f51c9b
JH
209static int on_bootfile(const char *name, const char *value, enum env_op op,
210 int flags)
211{
fd305633
JH
212 if (flags & H_PROGRAMMATIC)
213 return 0;
214
a9f51c9b
JH
215 switch (op) {
216 case env_op_create:
217 case env_op_overwrite:
1411157d
JH
218 copy_filename(net_boot_file_name, value,
219 sizeof(net_boot_file_name));
a9f51c9b
JH
220 break;
221 default:
222 break;
223 }
224
225 return 0;
226}
227U_BOOT_ENV_CALLBACK(bootfile, on_bootfile);
228
fd305633
JH
229static int on_ipaddr(const char *name, const char *value, enum env_op op,
230 int flags)
231{
232 if (flags & H_PROGRAMMATIC)
233 return 0;
234
235 net_ip = string_to_ip(value);
236
237 return 0;
238}
239U_BOOT_ENV_CALLBACK(ipaddr, on_ipaddr);
240
241static int on_gatewayip(const char *name, const char *value, enum env_op op,
242 int flags)
243{
244 if (flags & H_PROGRAMMATIC)
245 return 0;
246
247 net_gateway = string_to_ip(value);
248
249 return 0;
250}
251U_BOOT_ENV_CALLBACK(gatewayip, on_gatewayip);
252
253static int on_netmask(const char *name, const char *value, enum env_op op,
254 int flags)
255{
256 if (flags & H_PROGRAMMATIC)
257 return 0;
258
259 net_netmask = string_to_ip(value);
260
261 return 0;
262}
263U_BOOT_ENV_CALLBACK(netmask, on_netmask);
264
265static int on_serverip(const char *name, const char *value, enum env_op op,
266 int flags)
267{
268 if (flags & H_PROGRAMMATIC)
269 return 0;
270
271 net_server_ip = string_to_ip(value);
272
273 return 0;
274}
275U_BOOT_ENV_CALLBACK(serverip, on_serverip);
276
277static int on_nvlan(const char *name, const char *value, enum env_op op,
278 int flags)
279{
280 if (flags & H_PROGRAMMATIC)
281 return 0;
282
283 net_native_vlan = string_to_vlan(value);
284
285 return 0;
286}
287U_BOOT_ENV_CALLBACK(nvlan, on_nvlan);
288
289static int on_vlan(const char *name, const char *value, enum env_op op,
290 int flags)
291{
292 if (flags & H_PROGRAMMATIC)
293 return 0;
294
295 net_our_vlan = string_to_vlan(value);
296
297 return 0;
298}
299U_BOOT_ENV_CALLBACK(vlan, on_vlan);
300
301#if defined(CONFIG_CMD_DNS)
302static int on_dnsip(const char *name, const char *value, enum env_op op,
303 int flags)
304{
305 if (flags & H_PROGRAMMATIC)
306 return 0;
307
308 net_dns_server = string_to_ip(value);
309
310 return 0;
311}
312U_BOOT_ENV_CALLBACK(dnsip, on_dnsip);
313#endif
314
e4a3d57d
SG
315/*
316 * Check if autoload is enabled. If so, use either NFS or TFTP to download
317 * the boot file.
318 */
319void net_auto_load(void)
320{
ec8a252c 321#if defined(CONFIG_CMD_NFS)
e4a3d57d
SG
322 const char *s = getenv("autoload");
323
ec8a252c
JH
324 if (s != NULL && strcmp(s, "NFS") == 0) {
325 /*
326 * Use NFS to load the bootfile.
327 */
68c76a3a 328 nfs_start();
ec8a252c
JH
329 return;
330 }
e4a3d57d 331#endif
ec8a252c
JH
332 if (getenv_yesno("autoload") == 0) {
333 /*
334 * Just use BOOTP/RARP to configure system;
335 * Do not use TFTP to load the bootfile.
336 */
337 net_set_state(NETLOOP_SUCCESS);
338 return;
e4a3d57d 339 }
8885c5fe 340 tftp_start(TFTPGET);
e4a3d57d
SG
341}
342
bc0571fc 343static void net_init_loop(void)
2f70c49e 344{
7315cfd9 345 if (eth_get_dev())
0adb5b76 346 memcpy(net_ethaddr, eth_get_ethaddr(), 6);
3c172c4f 347
da95427c 348 return;
2f70c49e
HS
349}
350
ece223b5
JH
351static void net_clear_handlers(void)
352{
353 net_set_udp_handler(NULL);
354 net_set_arp_handler(NULL);
bc0571fc 355 net_set_timeout_handler(0, NULL);
ece223b5
JH
356}
357
358static void net_cleanup_loop(void)
359{
360 net_clear_handlers();
361}
362
46c495d5
JH
363void net_init(void)
364{
365 static int first_call = 1;
366
367 if (first_call) {
368 /*
369 * Setup packet buffers, aligned correctly.
370 */
371 int i;
372
1203fcce
JH
373 net_tx_packet = &net_pkt_buf[0] + (PKTALIGN - 1);
374 net_tx_packet -= (ulong)net_tx_packet % PKTALIGN;
2a504df0 375 for (i = 0; i < PKTBUFSRX; i++) {
1203fcce
JH
376 net_rx_packets[i] = net_tx_packet +
377 (i + 1) * PKTSIZE_ALIGN;
2a504df0 378 }
85d25e0e 379 arp_init();
46c495d5
JH
380 net_clear_handlers();
381
382 /* Only need to setup buffer pointers once. */
383 first_call = 0;
384 }
385
bc0571fc 386 net_init_loop();
46c495d5
JH
387}
388
2d966958
WD
389/**********************************************************************/
390/*
391 * Main network processing loop.
392 */
393
bc0571fc 394int net_loop(enum proto_t protocol)
2d966958 395{
60304592 396 int ret = -EINVAL;
2d966958 397
bc0571fc
JH
398 net_restarted = 0;
399 net_dev_exists = 0;
400 net_try_count = 1;
401 debug_cond(DEBUG_INT_STATE, "--- net_loop Entry\n");
73a8b27c 402
573f14fe 403 bootstage_mark_name(BOOTSTAGE_ID_ETH_START, "eth_start");
46c495d5 404 net_init();
f8be7d65 405 if (eth_is_on_demand_init() || protocol != NETCONS) {
b1bf6f2c 406 eth_halt();
f8be7d65 407 eth_set_current();
60304592
JH
408 ret = eth_init();
409 if (ret < 0) {
f8be7d65 410 eth_halt();
60304592 411 return ret;
f8be7d65 412 }
bc0571fc 413 } else {
d2eaec60 414 eth_init_state_only();
bc0571fc 415 }
2d966958 416restart:
b63056d6
JL
417#ifdef CONFIG_USB_KEYBOARD
418 net_busy_flag = 0;
419#endif
22f6e99d 420 net_set_state(NETLOOP_CONTINUE);
2d966958
WD
421
422 /*
423 * Start the ball rolling with the given start function. From
424 * here on, this code is a state machine driven by received
425 * packets and timer events.
426 */
bc0571fc
JH
427 debug_cond(DEBUG_INT_STATE, "--- net_loop Init\n");
428 net_init_loop();
2d966958 429
4f63acd0 430 switch (net_check_prereq(protocol)) {
2d966958
WD
431 case 1:
432 /* network not configured */
b1bf6f2c 433 eth_halt();
60304592 434 return -ENODEV;
2d966958 435
2d966958
WD
436 case 2:
437 /* network device not configured */
438 break;
2d966958
WD
439
440 case 0:
bc0571fc 441 net_dev_exists = 1;
1411157d 442 net_boot_file_size = 0;
2d966958 443 switch (protocol) {
e4bf0c5c 444 case TFTPGET:
1fb7cd49
SG
445#ifdef CONFIG_CMD_TFTPPUT
446 case TFTPPUT:
447#endif
2d966958 448 /* always use ARP to get server ethernet address */
8885c5fe 449 tftp_start(protocol);
2d966958 450 break;
7a83af07
LC
451#ifdef CONFIG_CMD_TFTPSRV
452 case TFTPSRV:
8885c5fe 453 tftp_start_server();
7a83af07
LC
454 break;
455#endif
643d1ab2 456#if defined(CONFIG_CMD_DHCP)
2d966958 457 case DHCP:
7044c6bb 458 bootp_reset();
049a95a7 459 net_ip.s_addr = 0;
7044c6bb 460 dhcp_request(); /* Basically same as BOOTP */
2d966958 461 break;
610f2e9c 462#endif
2d966958
WD
463
464 case BOOTP:
7044c6bb 465 bootp_reset();
049a95a7 466 net_ip.s_addr = 0;
7044c6bb 467 bootp_request();
2d966958
WD
468 break;
469
bf6cb247 470#if defined(CONFIG_CMD_RARP)
2d966958 471 case RARP:
698d78e5 472 rarp_try = 0;
049a95a7 473 net_ip.s_addr = 0;
698d78e5 474 rarp_request();
2d966958 475 break;
bf6cb247 476#endif
643d1ab2 477#if defined(CONFIG_CMD_PING)
73a8b27c 478 case PING:
a36b12f9 479 ping_start();
73a8b27c 480 break;
cbd8a35c 481#endif
643d1ab2 482#if defined(CONFIG_CMD_NFS)
cbd8a35c 483 case NFS:
68c76a3a 484 nfs_start();
cbd8a35c 485 break;
a3d991bd 486#endif
643d1ab2 487#if defined(CONFIG_CMD_CDP)
a3d991bd 488 case CDP:
6aede5b7 489 cdp_start();
a3d991bd 490 break;
68ceb29e 491#endif
bc0571fc 492#if defined(CONFIG_NETCONSOLE) && !(CONFIG_SPL_BUILD)
68ceb29e 493 case NETCONS:
6a38a5f3 494 nc_start();
68ceb29e 495 break;
ea287deb 496#endif
643d1ab2 497#if defined(CONFIG_CMD_SNTP)
ea287deb 498 case SNTP:
38ba2558 499 sntp_start();
ea287deb 500 break;
1a32bf41
RG
501#endif
502#if defined(CONFIG_CMD_DNS)
503 case DNS:
786eac5f 504 dns_start();
1a32bf41 505 break;
d22c338e
JH
506#endif
507#if defined(CONFIG_CMD_LINK_LOCAL)
508 case LINKLOCAL:
509 link_local_start();
510 break;
73a8b27c 511#endif
2d966958
WD
512 default:
513 break;
514 }
515
2d966958
WD
516 break;
517 }
518
643d1ab2 519#if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
3e38e429
LC
520#if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \
521 defined(CONFIG_STATUS_LED) && \
522 defined(STATUS_LED_RED)
fc3e2165 523 /*
42d1f039 524 * Echo the inverted link state to the fault LED.
fc3e2165 525 */
d3c65b01 526 if (miiphy_link(eth_get_dev()->name, CONFIG_SYS_FAULT_MII_ADDR))
4f63acd0 527 status_led_set(STATUS_LED_RED, STATUS_LED_OFF);
d3c65b01 528 else
4f63acd0 529 status_led_set(STATUS_LED_RED, STATUS_LED_ON);
6d0f6bcf 530#endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */
fc3e2165 531#endif /* CONFIG_MII, ... */
b63056d6
JL
532#ifdef CONFIG_USB_KEYBOARD
533 net_busy_flag = 1;
534#endif
2d966958
WD
535
536 /*
537 * Main packet reception loop. Loop receiving packets until
22f6e99d 538 * someone sets `net_state' to a state that terminates.
2d966958
WD
539 */
540 for (;;) {
541 WATCHDOG_RESET();
542#ifdef CONFIG_SHOW_ACTIVITY
48522bb5 543 show_activity(1);
2d966958 544#endif
c5a75339
JH
545 if (arp_timeout_check() > 0)
546 time_start = get_timer(0);
547
2d966958
WD
548 /*
549 * Check the ethernet for a new packet. The ethernet
550 * receive routine will process it.
60304592
JH
551 * Most drivers return the most recent packet size, but not
552 * errors that may have happened.
2d966958 553 */
40cb90ee 554 eth_rx();
2d966958
WD
555
556 /*
557 * Abort if ctrl-c was pressed.
558 */
559 if (ctrlc()) {
e94070c4 560 /* cancel any ARP that may not have completed */
049a95a7 561 net_arp_wait_packet_ip.s_addr = 0;
e94070c4 562
ece223b5 563 net_cleanup_loop();
8bde7f77 564 eth_halt();
f8be7d65
JH
565 /* Invalidate the last protocol */
566 eth_set_last_protocol(BOOTP);
567
4f63acd0 568 puts("\nAbort\n");
4ef8d53c
JH
569 /* include a debug print as well incase the debug
570 messages are directed to stderr */
bc0571fc 571 debug_cond(DEBUG_INT_STATE, "--- net_loop Abort!\n");
19a4fbaa 572 ret = -EINTR;
4793ee65 573 goto done;
2d966958
WD
574 }
575
2d966958
WD
576 /*
577 * Check for a timeout, and run the timeout handler
578 * if we have one.
579 */
bc0571fc
JH
580 if (time_handler &&
581 ((get_timer(0) - time_start) > time_delta)) {
2d966958
WD
582 thand_f *x;
583
643d1ab2 584#if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
4f63acd0
LC
585#if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \
586 defined(CONFIG_STATUS_LED) && \
587 defined(STATUS_LED_RED)
fc3e2165 588 /*
42d1f039 589 * Echo the inverted link state to the fault LED.
fc3e2165 590 */
4f63acd0 591 if (miiphy_link(eth_get_dev()->name,
bc0571fc 592 CONFIG_SYS_FAULT_MII_ADDR))
4f63acd0 593 status_led_set(STATUS_LED_RED, STATUS_LED_OFF);
bc0571fc 594 else
4f63acd0 595 status_led_set(STATUS_LED_RED, STATUS_LED_ON);
4f63acd0 596#endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */
fc3e2165 597#endif /* CONFIG_MII, ... */
bc0571fc
JH
598 debug_cond(DEBUG_INT_STATE, "--- net_loop timeout\n");
599 x = time_handler;
600 time_handler = (thand_f *)0;
2d966958
WD
601 (*x)();
602 }
603
5c421331 604 if (net_state == NETLOOP_FAIL)
bc0571fc 605 ret = net_start_again();
2d966958 606
22f6e99d 607 switch (net_state) {
2d966958 608 case NETLOOP_RESTART:
bc0571fc 609 net_restarted = 1;
2d966958
WD
610 goto restart;
611
612 case NETLOOP_SUCCESS:
ece223b5 613 net_cleanup_loop();
1411157d
JH
614 if (net_boot_file_size > 0) {
615 printf("Bytes transferred = %d (%x hex)\n",
616 net_boot_file_size, net_boot_file_size);
617 setenv_hex("filesize", net_boot_file_size);
978226da 618 setenv_hex("fileaddr", load_addr);
2d966958 619 }
f8be7d65
JH
620 if (protocol != NETCONS)
621 eth_halt();
622 else
623 eth_halt_state_only();
624
625 eth_set_last_protocol(protocol);
626
1411157d 627 ret = net_boot_file_size;
bc0571fc 628 debug_cond(DEBUG_INT_STATE, "--- net_loop Success!\n");
4793ee65 629 goto done;
2d966958
WD
630
631 case NETLOOP_FAIL:
ece223b5 632 net_cleanup_loop();
f8be7d65
JH
633 /* Invalidate the last protocol */
634 eth_set_last_protocol(BOOTP);
bc0571fc 635 debug_cond(DEBUG_INT_STATE, "--- net_loop Fail!\n");
4793ee65 636 goto done;
22f6e99d
JH
637
638 case NETLOOP_CONTINUE:
639 continue;
2d966958
WD
640 }
641 }
4793ee65
SG
642
643done:
b63056d6
JL
644#ifdef CONFIG_USB_KEYBOARD
645 net_busy_flag = 0;
646#endif
39bccd21 647#ifdef CONFIG_CMD_TFTPPUT
4793ee65 648 /* Clear out the handlers */
ece223b5 649 net_set_udp_handler(NULL);
4793ee65 650 net_set_icmp_handler(NULL);
39bccd21 651#endif
4793ee65 652 return ret;
2d966958
WD
653}
654
655/**********************************************************************/
656
bc0571fc 657static void start_again_timeout_handler(void)
2d966958 658{
22f6e99d 659 net_set_state(NETLOOP_RESTART);
2d966958
WD
660}
661
bc0571fc 662int net_start_again(void)
2d966958 663{
6e592385 664 char *nretry;
67b96e87
RB
665 int retry_forever = 0;
666 unsigned long retrycnt = 0;
60304592 667 int ret;
67b96e87
RB
668
669 nretry = getenv("netretry");
670 if (nretry) {
671 if (!strcmp(nretry, "yes"))
672 retry_forever = 1;
673 else if (!strcmp(nretry, "no"))
674 retrycnt = 0;
675 else if (!strcmp(nretry, "once"))
676 retrycnt = 1;
677 else
678 retrycnt = simple_strtoul(nretry, NULL, 0);
5c421331
JH
679 } else {
680 retrycnt = 0;
681 retry_forever = 0;
682 }
67b96e87 683
bc0571fc 684 if ((!retry_forever) && (net_try_count >= retrycnt)) {
67b96e87 685 eth_halt();
22f6e99d 686 net_set_state(NETLOOP_FAIL);
60304592
JH
687 /*
688 * We don't provide a way for the protocol to return an error,
689 * but this is almost always the reason.
690 */
691 return -ETIMEDOUT;
a3d991bd 692 }
67b96e87 693
bc0571fc 694 net_try_count++;
67b96e87 695
4f63acd0 696 eth_halt();
8b0c5c12 697#if !defined(CONFIG_NET_DO_NOT_TRY_ANOTHER)
bc0571fc 698 eth_try_another(!net_restarted);
8b0c5c12 699#endif
60304592 700 ret = eth_init();
bc0571fc
JH
701 if (net_restart_wrap) {
702 net_restart_wrap = 0;
703 if (net_dev_exists) {
704 net_set_timeout_handler(10000UL,
705 start_again_timeout_handler);
ece223b5 706 net_set_udp_handler(NULL);
6e592385 707 } else {
22f6e99d 708 net_set_state(NETLOOP_FAIL);
2d966958 709 }
6e592385 710 } else {
22f6e99d 711 net_set_state(NETLOOP_RESTART);
2d966958 712 }
60304592 713 return ret;
2d966958
WD
714}
715
716/**********************************************************************/
717/*
718 * Miscelaneous bits.
719 */
720
ece223b5 721static void dummy_handler(uchar *pkt, unsigned dport,
049a95a7 722 struct in_addr sip, unsigned sport,
ece223b5 723 unsigned len)
d280d3f4 724{
d280d3f4
JH
725}
726
ece223b5
JH
727rxhand_f *net_get_udp_handler(void)
728{
729 return udp_packet_handler;
730}
d280d3f4 731
ece223b5
JH
732void net_set_udp_handler(rxhand_f *f)
733{
bc0571fc 734 debug_cond(DEBUG_INT_STATE, "--- net_loop UDP handler set (%p)\n", f);
ece223b5
JH
735 if (f == NULL)
736 udp_packet_handler = dummy_handler;
737 else
738 udp_packet_handler = f;
739}
740
741rxhand_f *net_get_arp_handler(void)
2d966958 742{
ece223b5
JH
743 return arp_packet_handler;
744}
745
746void net_set_arp_handler(rxhand_f *f)
747{
bc0571fc 748 debug_cond(DEBUG_INT_STATE, "--- net_loop ARP handler set (%p)\n", f);
ece223b5
JH
749 if (f == NULL)
750 arp_packet_handler = dummy_handler;
751 else
752 arp_packet_handler = f;
2d966958
WD
753}
754
39bccd21 755#ifdef CONFIG_CMD_TFTPPUT
4793ee65
SG
756void net_set_icmp_handler(rxhand_icmp_f *f)
757{
758 packet_icmp_handler = f;
759}
39bccd21 760#endif
2d966958 761
bc0571fc 762void net_set_timeout_handler(ulong iv, thand_f *f)
2d966958
WD
763{
764 if (iv == 0) {
4ef8d53c 765 debug_cond(DEBUG_INT_STATE,
bc0571fc
JH
766 "--- net_loop timeout handler cancelled\n");
767 time_handler = (thand_f *)0;
2d966958 768 } else {
4ef8d53c 769 debug_cond(DEBUG_INT_STATE,
bc0571fc
JH
770 "--- net_loop timeout handler set (%p)\n", f);
771 time_handler = f;
772 time_start = get_timer(0);
773 time_delta = iv * CONFIG_SYS_HZ / 1000;
2d966958
WD
774 }
775}
776
1203fcce 777int net_send_udp_packet(uchar *ether, struct in_addr dest, int dport, int sport,
206d07fd 778 int payload_len)
73a8b27c 779{
a3d991bd 780 uchar *pkt;
9214637a
JH
781 int eth_hdr_size;
782 int pkt_hdr_size;
a3d991bd 783
bc0571fc 784 /* make sure the net_tx_packet is initialized (net_init() was called) */
1203fcce
JH
785 assert(net_tx_packet != NULL);
786 if (net_tx_packet == NULL)
46c495d5
JH
787 return -1;
788
73a8b27c 789 /* convert to new style broadcast */
049a95a7
JH
790 if (dest.s_addr == 0)
791 dest.s_addr = 0xFFFFFFFF;
73a8b27c
WD
792
793 /* if broadcast, make the ether address a broadcast and don't do ARP */
049a95a7 794 if (dest.s_addr == 0xFFFFFFFF)
0adb5b76 795 ether = (uchar *)net_bcast_ethaddr;
73a8b27c 796
1203fcce 797 pkt = (uchar *)net_tx_packet;
9214637a 798
1203fcce 799 eth_hdr_size = net_set_ether(pkt, ether, PROT_IP);
9214637a
JH
800 pkt += eth_hdr_size;
801 net_set_udp_header(pkt, dest, dport, sport, payload_len);
802 pkt_hdr_size = eth_hdr_size + IP_UDP_HDR_SIZE;
73a8b27c 803
e94070c4 804 /* if MAC address was not discovered yet, do an ARP request */
0adb5b76 805 if (memcmp(ether, net_null_ethaddr, 6) == 0) {
4ef8d53c 806 debug_cond(DEBUG_DEV_PKT, "sending ARP for %pI4\n", &dest);
0ebf04c6 807
9214637a 808 /* save the ip and eth addr for the packet to send after arp */
049a95a7 809 net_arp_wait_packet_ip = dest;
85d25e0e 810 arp_wait_packet_ethaddr = ether;
a3d991bd 811
73a8b27c 812 /* size of the waiting packet */
85d25e0e 813 arp_wait_tx_packet_size = pkt_hdr_size + payload_len;
73a8b27c
WD
814
815 /* and do the ARP request */
85d25e0e
JH
816 arp_wait_try = 1;
817 arp_wait_timer_start = get_timer(0);
818 arp_request();
73a8b27c 819 return 1; /* waiting */
9214637a 820 } else {
4ef8d53c 821 debug_cond(DEBUG_DEV_PKT, "sending UDP to %pI4/%pM\n",
bc0571fc 822 &dest, ether);
1203fcce 823 net_send_packet(net_tx_packet, pkt_hdr_size + payload_len);
9214637a 824 return 0; /* transmitted */
73a8b27c 825 }
73a8b27c
WD
826}
827
5cfaa4e5
AR
828#ifdef CONFIG_IP_DEFRAG
829/*
830 * This function collects fragments in a single packet, according
831 * to the algorithm in RFC815. It returns NULL or the pointer to
832 * a complete packet, in static storage
833 */
834#ifndef CONFIG_NET_MAXDEFRAG
835#define CONFIG_NET_MAXDEFRAG 16384
836#endif
837/*
838 * MAXDEFRAG, above, is chosen in the config file and is real data
839 * so we need to add the NFS overhead, which is more than TFTP.
840 * To use sizeof in the internal unnamed structures, we need a real
841 * instance (can't do "sizeof(struct rpc_t.u.reply))", unfortunately).
842 * The compiler doesn't complain nor allocates the actual structure
843 */
844static struct rpc_t rpc_specimen;
845#define IP_PKTSIZE (CONFIG_NET_MAXDEFRAG + sizeof(rpc_specimen.u.reply))
846
c5c59df0 847#define IP_MAXUDP (IP_PKTSIZE - IP_HDR_SIZE)
5cfaa4e5
AR
848
849/*
850 * this is the packet being assembled, either data or frag control.
851 * Fragments go by 8 bytes, so this union must be 8 bytes long
852 */
853struct hole {
854 /* first_byte is address of this structure */
855 u16 last_byte; /* last byte in this hole + 1 (begin of next hole) */
856 u16 next_hole; /* index of next (in 8-b blocks), 0 == none */
857 u16 prev_hole; /* index of prev, 0 == none */
858 u16 unused;
859};
860
bc0571fc 861static struct ip_udp_hdr *__net_defragment(struct ip_udp_hdr *ip, int *lenp)
5cfaa4e5 862{
48522bb5 863 static uchar pkt_buff[IP_PKTSIZE] __aligned(PKTALIGN);
5cfaa4e5
AR
864 static u16 first_hole, total_len;
865 struct hole *payload, *thisfrag, *h, *newh;
594c26f8 866 struct ip_udp_hdr *localip = (struct ip_udp_hdr *)pkt_buff;
5cfaa4e5
AR
867 uchar *indata = (uchar *)ip;
868 int offset8, start, len, done = 0;
869 u16 ip_off = ntohs(ip->ip_off);
870
871 /* payload starts after IP header, this fragment is in there */
c5c59df0 872 payload = (struct hole *)(pkt_buff + IP_HDR_SIZE);
5cfaa4e5
AR
873 offset8 = (ip_off & IP_OFFS);
874 thisfrag = payload + offset8;
875 start = offset8 * 8;
c5c59df0 876 len = ntohs(ip->ip_len) - IP_HDR_SIZE;
5cfaa4e5
AR
877
878 if (start + len > IP_MAXUDP) /* fragment extends too far */
879 return NULL;
880
881 if (!total_len || localip->ip_id != ip->ip_id) {
882 /* new (or different) packet, reset structs */
883 total_len = 0xffff;
884 payload[0].last_byte = ~0;
885 payload[0].next_hole = 0;
886 payload[0].prev_hole = 0;
887 first_hole = 0;
888 /* any IP header will work, copy the first we received */
c5c59df0 889 memcpy(localip, ip, IP_HDR_SIZE);
5cfaa4e5
AR
890 }
891
892 /*
893 * What follows is the reassembly algorithm. We use the payload
894 * array as a linked list of hole descriptors, as each hole starts
895 * at a multiple of 8 bytes. However, last byte can be whatever value,
896 * so it is represented as byte count, not as 8-byte blocks.
897 */
898
899 h = payload + first_hole;
900 while (h->last_byte < start) {
901 if (!h->next_hole) {
902 /* no hole that far away */
903 return NULL;
904 }
905 h = payload + h->next_hole;
906 }
907
e397e59e
FS
908 /* last fragment may be 1..7 bytes, the "+7" forces acceptance */
909 if (offset8 + ((len + 7) / 8) <= h - payload) {
5cfaa4e5
AR
910 /* no overlap with holes (dup fragment?) */
911 return NULL;
912 }
913
914 if (!(ip_off & IP_FLAGS_MFRAG)) {
915 /* no more fragmentss: truncate this (last) hole */
916 total_len = start + len;
917 h->last_byte = start + len;
918 }
919
920 /*
921 * There is some overlap: fix the hole list. This code doesn't
922 * deal with a fragment that overlaps with two different holes
923 * (thus being a superset of a previously-received fragment).
924 */
925
4f63acd0 926 if ((h >= thisfrag) && (h->last_byte <= start + len)) {
5cfaa4e5
AR
927 /* complete overlap with hole: remove hole */
928 if (!h->prev_hole && !h->next_hole) {
929 /* last remaining hole */
930 done = 1;
931 } else if (!h->prev_hole) {
932 /* first hole */
933 first_hole = h->next_hole;
934 payload[h->next_hole].prev_hole = 0;
935 } else if (!h->next_hole) {
936 /* last hole */
937 payload[h->prev_hole].next_hole = 0;
938 } else {
939 /* in the middle of the list */
940 payload[h->next_hole].prev_hole = h->prev_hole;
941 payload[h->prev_hole].next_hole = h->next_hole;
942 }
943
944 } else if (h->last_byte <= start + len) {
945 /* overlaps with final part of the hole: shorten this hole */
946 h->last_byte = start;
947
948 } else if (h >= thisfrag) {
949 /* overlaps with initial part of the hole: move this hole */
950 newh = thisfrag + (len / 8);
951 *newh = *h;
952 h = newh;
953 if (h->next_hole)
954 payload[h->next_hole].prev_hole = (h - payload);
955 if (h->prev_hole)
956 payload[h->prev_hole].next_hole = (h - payload);
957 else
958 first_hole = (h - payload);
959
960 } else {
961 /* fragment sits in the middle: split the hole */
962 newh = thisfrag + (len / 8);
963 *newh = *h;
964 h->last_byte = start;
965 h->next_hole = (newh - payload);
966 newh->prev_hole = (h - payload);
967 if (newh->next_hole)
968 payload[newh->next_hole].prev_hole = (newh - payload);
969 }
970
971 /* finally copy this fragment and possibly return whole packet */
c5c59df0 972 memcpy((uchar *)thisfrag, indata + IP_HDR_SIZE, len);
5cfaa4e5
AR
973 if (!done)
974 return NULL;
975
976 localip->ip_len = htons(total_len);
c5c59df0 977 *lenp = total_len + IP_HDR_SIZE;
5cfaa4e5
AR
978 return localip;
979}
980
bc0571fc
JH
981static inline struct ip_udp_hdr *net_defragment(struct ip_udp_hdr *ip,
982 int *lenp)
5cfaa4e5
AR
983{
984 u16 ip_off = ntohs(ip->ip_off);
985 if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG)))
986 return ip; /* not a fragment */
bc0571fc 987 return __net_defragment(ip, lenp);
5cfaa4e5
AR
988}
989
990#else /* !CONFIG_IP_DEFRAG */
991
bc0571fc
JH
992static inline struct ip_udp_hdr *net_defragment(struct ip_udp_hdr *ip,
993 int *lenp)
5cfaa4e5
AR
994{
995 u16 ip_off = ntohs(ip->ip_off);
996 if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG)))
997 return ip; /* not a fragment */
998 return NULL;
999}
1000#endif
a3d991bd 1001
8f79bb17
SG
1002/**
1003 * Receive an ICMP packet. We deal with REDIRECT and PING here, and silently
1004 * drop others.
1005 *
1006 * @parma ip IP packet containing the ICMP
1007 */
594c26f8 1008static void receive_icmp(struct ip_udp_hdr *ip, int len,
049a95a7 1009 struct in_addr src_ip, struct ethernet_hdr *et)
8f79bb17 1010{
e0a63079 1011 struct icmp_hdr *icmph = (struct icmp_hdr *)&ip->udp_src;
8f79bb17
SG
1012
1013 switch (icmph->type) {
1014 case ICMP_REDIRECT:
1015 if (icmph->code != ICMP_REDIR_HOST)
1016 return;
1017 printf(" ICMP Host Redirect to %pI4 ",
bc0571fc 1018 &icmph->un.gateway);
8f79bb17 1019 break;
a36b12f9 1020 default:
8f79bb17 1021#if defined(CONFIG_CMD_PING)
a36b12f9 1022 ping_receive(et, ip, len);
8f79bb17 1023#endif
39bccd21 1024#ifdef CONFIG_CMD_TFTPPUT
4793ee65
SG
1025 if (packet_icmp_handler)
1026 packet_icmp_handler(icmph->type, icmph->code,
bc0571fc
JH
1027 ntohs(ip->udp_dst), src_ip,
1028 ntohs(ip->udp_src), icmph->un.data,
1029 ntohs(ip->udp_len));
39bccd21 1030#endif
8f79bb17
SG
1031 break;
1032 }
1033}
1034
2a504df0 1035void net_process_received_packet(uchar *in_packet, int len)
2d966958 1036{
cb487f56 1037 struct ethernet_hdr *et;
594c26f8 1038 struct ip_udp_hdr *ip;
049a95a7
JH
1039 struct in_addr dst_ip;
1040 struct in_addr src_ip;
8d353eb8 1041 int eth_proto;
643d1ab2 1042#if defined(CONFIG_CMD_CDP)
a3d991bd
WD
1043 int iscdp;
1044#endif
1045 ushort cti = 0, vlanid = VLAN_NONE, myvlanid, mynvlanid;
1046
4ef8d53c 1047 debug_cond(DEBUG_NET_PKT, "packet received\n");
2d966958 1048
1203fcce
JH
1049 net_rx_packet = in_packet;
1050 net_rx_packet_len = len;
2a504df0 1051 et = (struct ethernet_hdr *)in_packet;
a3d991bd
WD
1052
1053 /* too small packet? */
1054 if (len < ETHER_HDR_SIZE)
1055 return;
1056
f85b6071
RJ
1057#ifdef CONFIG_API
1058 if (push_packet) {
2a504df0 1059 (*push_packet)(in_packet, len);
f85b6071
RJ
1060 return;
1061 }
1062#endif
1063
643d1ab2 1064#if defined(CONFIG_CMD_CDP)
a3d991bd 1065 /* keep track if packet is CDP */
17351883 1066 iscdp = is_cdp_packet(et->et_dest);
a3d991bd
WD
1067#endif
1068
4fd5055f 1069 myvlanid = ntohs(net_our_vlan);
a3d991bd
WD
1070 if (myvlanid == (ushort)-1)
1071 myvlanid = VLAN_NONE;
4fd5055f 1072 mynvlanid = ntohs(net_native_vlan);
a3d991bd
WD
1073 if (mynvlanid == (ushort)-1)
1074 mynvlanid = VLAN_NONE;
2d966958 1075
8d353eb8 1076 eth_proto = ntohs(et->et_protlen);
2d966958 1077
8d353eb8 1078 if (eth_proto < 1514) {
cb487f56 1079 struct e802_hdr *et802 = (struct e802_hdr *)et;
2d966958 1080 /*
da5ebe2c
JH
1081 * Got a 802.2 packet. Check the other protocol field.
1082 * XXX VLAN over 802.2+SNAP not implemented!
2d966958 1083 */
8d353eb8 1084 eth_proto = ntohs(et802->et_prot);
a3d991bd 1085
2a504df0 1086 ip = (struct ip_udp_hdr *)(in_packet + E802_HDR_SIZE);
2d966958 1087 len -= E802_HDR_SIZE;
a3d991bd 1088
8d353eb8 1089 } else if (eth_proto != PROT_VLAN) { /* normal packet */
2a504df0 1090 ip = (struct ip_udp_hdr *)(in_packet + ETHER_HDR_SIZE);
2d966958 1091 len -= ETHER_HDR_SIZE;
a3d991bd
WD
1092
1093 } else { /* VLAN packet */
c68cca35
JH
1094 struct vlan_ethernet_hdr *vet =
1095 (struct vlan_ethernet_hdr *)et;
a3d991bd 1096
4ef8d53c 1097 debug_cond(DEBUG_NET_PKT, "VLAN packet received\n");
0ebf04c6 1098
a3d991bd
WD
1099 /* too small packet? */
1100 if (len < VLAN_ETHER_HDR_SIZE)
1101 return;
1102
1103 /* if no VLAN active */
4fd5055f 1104 if ((ntohs(net_our_vlan) & VLAN_IDMASK) == VLAN_NONE
643d1ab2 1105#if defined(CONFIG_CMD_CDP)
a3d991bd
WD
1106 && iscdp == 0
1107#endif
1108 )
1109 return;
1110
1111 cti = ntohs(vet->vet_tag);
1112 vlanid = cti & VLAN_IDMASK;
8d353eb8 1113 eth_proto = ntohs(vet->vet_type);
a3d991bd 1114
2a504df0 1115 ip = (struct ip_udp_hdr *)(in_packet + VLAN_ETHER_HDR_SIZE);
a3d991bd 1116 len -= VLAN_ETHER_HDR_SIZE;
2d966958
WD
1117 }
1118
4ef8d53c 1119 debug_cond(DEBUG_NET_PKT, "Receive from protocol 0x%x\n", eth_proto);
2d966958 1120
643d1ab2 1121#if defined(CONFIG_CMD_CDP)
a3d991bd 1122 if (iscdp) {
0b4c5ff4 1123 cdp_receive((uchar *)ip, len);
a3d991bd
WD
1124 return;
1125 }
1126#endif
1127
1128 if ((myvlanid & VLAN_IDMASK) != VLAN_NONE) {
1129 if (vlanid == VLAN_NONE)
1130 vlanid = (mynvlanid & VLAN_IDMASK);
1131 /* not matched? */
1132 if (vlanid != (myvlanid & VLAN_IDMASK))
1133 return;
1134 }
1135
8d353eb8 1136 switch (eth_proto) {
2d966958 1137 case PROT_ARP:
85d25e0e 1138 arp_receive(et, ip, len);
289f932c 1139 break;
2d966958 1140
bf6cb247 1141#ifdef CONFIG_CMD_RARP
2d966958 1142 case PROT_RARP:
8b9c5322 1143 rarp_receive(ip, len);
2d966958 1144 break;
bf6cb247 1145#endif
2d966958 1146 case PROT_IP:
4ef8d53c 1147 debug_cond(DEBUG_NET_PKT, "Got IP\n");
5cfaa4e5 1148 /* Before we start poking the header, make sure it is there */
594c26f8
JH
1149 if (len < IP_UDP_HDR_SIZE) {
1150 debug("len bad %d < %lu\n", len,
bc0571fc 1151 (ulong)IP_UDP_HDR_SIZE);
2d966958
WD
1152 return;
1153 }
5cfaa4e5 1154 /* Check the packet length */
2d966958 1155 if (len < ntohs(ip->ip_len)) {
4ef8d53c 1156 debug("len bad %d < %d\n", len, ntohs(ip->ip_len));
2d966958
WD
1157 return;
1158 }
1159 len = ntohs(ip->ip_len);
4ef8d53c 1160 debug_cond(DEBUG_NET_PKT, "len=%d, v=%02x\n",
bc0571fc 1161 len, ip->ip_hl_v & 0xff);
0ebf04c6 1162
5cfaa4e5 1163 /* Can't deal with anything except IPv4 */
d3c65b01 1164 if ((ip->ip_hl_v & 0xf0) != 0x40)
2d966958 1165 return;
5cfaa4e5 1166 /* Can't deal with IP options (headers != 20 bytes) */
d3c65b01 1167 if ((ip->ip_hl_v & 0x0f) > 0x05)
6b52cfe1 1168 return;
5cfaa4e5 1169 /* Check the Checksum of the header */
0da0fcd5 1170 if (!ip_checksum_ok((uchar *)ip, IP_HDR_SIZE)) {
4ef8d53c 1171 debug("checksum bad\n");
2d966958
WD
1172 return;
1173 }
5cfaa4e5 1174 /* If it is not for us, ignore it */
049a95a7
JH
1175 dst_ip = net_read_ip(&ip->ip_dst);
1176 if (net_ip.s_addr && dst_ip.s_addr != net_ip.s_addr &&
1177 dst_ip.s_addr != 0xFFFFFFFF) {
53a5c424 1178#ifdef CONFIG_MCAST_TFTP
049a95a7 1179 if (net_mcast_addr != dst_ip)
53a5c424 1180#endif
c819abee 1181 return;
2d966958 1182 }
03eb129f 1183 /* Read source IP address for later use */
049a95a7 1184 src_ip = net_read_ip(&ip->ip_src);
5cfaa4e5
AR
1185 /*
1186 * The function returns the unchanged packet if it's not
1187 * a fragment, and either the complete packet or NULL if
1188 * it is a fragment (if !CONFIG_IP_DEFRAG, it returns NULL)
1189 */
bc0571fc 1190 ip = net_defragment(ip, &len);
ccb9ebef 1191 if (!ip)
5cfaa4e5 1192 return;
2d966958
WD
1193 /*
1194 * watch for ICMP host redirects
1195 *
8bde7f77
WD
1196 * There is no real handler code (yet). We just watch
1197 * for ICMP host redirect messages. In case anybody
1198 * sees these messages: please contact me
1199 * (wd@denx.de), or - even better - send me the
1200 * necessary fixes :-)
2d966958 1201 *
8bde7f77
WD
1202 * Note: in all cases where I have seen this so far
1203 * it was a problem with the router configuration,
1204 * for instance when a router was configured in the
1205 * BOOTP reply, but the TFTP server was on the same
1206 * subnet. So this is probably a warning that your
1207 * configuration might be wrong. But I'm not really
1208 * sure if there aren't any other situations.
4793ee65
SG
1209 *
1210 * Simon Glass <sjg@chromium.org>: We get an ICMP when
1211 * we send a tftp packet to a dead connection, or when
1212 * there is no server at the other end.
2d966958
WD
1213 */
1214 if (ip->ip_p == IPPROTO_ICMP) {
8f79bb17
SG
1215 receive_icmp(ip, len, src_ip, et);
1216 return;
2d966958
WD
1217 } else if (ip->ip_p != IPPROTO_UDP) { /* Only UDP packets */
1218 return;
1219 }
1220
4ef8d53c 1221 debug_cond(DEBUG_DEV_PKT,
bc0571fc
JH
1222 "received UDP (to=%pI4, from=%pI4, len=%d)\n",
1223 &dst_ip, &src_ip, len);
4ef8d53c 1224
8534bf9a
SR
1225#ifdef CONFIG_UDP_CHECKSUM
1226 if (ip->udp_xsum != 0) {
b2f50807 1227 ulong xsum;
8534bf9a
SR
1228 ushort *sumptr;
1229 ushort sumlen;
1230
1231 xsum = ip->ip_p;
1232 xsum += (ntohs(ip->udp_len));
049a95a7
JH
1233 xsum += (ntohl(ip->ip_src.s_addr) >> 16) & 0x0000ffff;
1234 xsum += (ntohl(ip->ip_src.s_addr) >> 0) & 0x0000ffff;
1235 xsum += (ntohl(ip->ip_dst.s_addr) >> 16) & 0x0000ffff;
1236 xsum += (ntohl(ip->ip_dst.s_addr) >> 0) & 0x0000ffff;
8534bf9a
SR
1237
1238 sumlen = ntohs(ip->udp_len);
bc0571fc 1239 sumptr = (ushort *)&(ip->udp_src);
8534bf9a
SR
1240
1241 while (sumlen > 1) {
b2f50807 1242 ushort sumdata;
8534bf9a
SR
1243
1244 sumdata = *sumptr++;
1245 xsum += ntohs(sumdata);
1246 sumlen -= 2;
1247 }
1248 if (sumlen > 0) {
b2f50807 1249 ushort sumdata;
8534bf9a 1250
bc0571fc 1251 sumdata = *(unsigned char *)sumptr;
b2f50807 1252 sumdata = (sumdata << 8) & 0xff00;
8534bf9a
SR
1253 xsum += sumdata;
1254 }
1255 while ((xsum >> 16) != 0) {
3e38e429
LC
1256 xsum = (xsum & 0x0000ffff) +
1257 ((xsum >> 16) & 0x0000ffff);
8534bf9a
SR
1258 }
1259 if ((xsum != 0x00000000) && (xsum != 0x0000ffff)) {
9b55a253 1260 printf(" UDP wrong checksum %08lx %08x\n",
bc0571fc 1261 xsum, ntohs(ip->udp_xsum));
8534bf9a
SR
1262 return;
1263 }
1264 }
1265#endif
1266
bc0571fc 1267#if defined(CONFIG_NETCONSOLE) && !(CONFIG_SPL_BUILD)
594c26f8 1268 nc_input_packet((uchar *)ip + IP_UDP_HDR_SIZE,
bc0571fc
JH
1269 src_ip,
1270 ntohs(ip->udp_dst),
1271 ntohs(ip->udp_src),
1272 ntohs(ip->udp_len) - UDP_HDR_SIZE);
68ceb29e 1273#endif
2d966958 1274 /*
bc0571fc 1275 * IP header OK. Pass the packet to the current handler.
2d966958 1276 */
ece223b5 1277 (*udp_packet_handler)((uchar *)ip + IP_UDP_HDR_SIZE,
bc0571fc
JH
1278 ntohs(ip->udp_dst),
1279 src_ip,
1280 ntohs(ip->udp_src),
1281 ntohs(ip->udp_len) - UDP_HDR_SIZE);
2d966958
WD
1282 break;
1283 }
1284}
1285
2d966958
WD
1286/**********************************************************************/
1287
e4bf0c5c 1288static int net_check_prereq(enum proto_t protocol)
2d966958
WD
1289{
1290 switch (protocol) {
6e592385 1291 /* Fall through */
643d1ab2 1292#if defined(CONFIG_CMD_PING)
73a8b27c 1293 case PING:
049a95a7 1294 if (net_ping_ip.s_addr == 0) {
4f63acd0 1295 puts("*** ERROR: ping address not given\n");
92895de9 1296 return 1;
6e592385
WD
1297 }
1298 goto common;
cbd8a35c 1299#endif
643d1ab2 1300#if defined(CONFIG_CMD_SNTP)
ea287deb 1301 case SNTP:
049a95a7 1302 if (net_ntp_server.s_addr == 0) {
4f63acd0 1303 puts("*** ERROR: NTP server address not given\n");
92895de9 1304 return 1;
ea287deb
WD
1305 }
1306 goto common;
1307#endif
1a32bf41
RG
1308#if defined(CONFIG_CMD_DNS)
1309 case DNS:
049a95a7 1310 if (net_dns_server.s_addr == 0) {
1a32bf41
RG
1311 puts("*** ERROR: DNS server address not given\n");
1312 return 1;
1313 }
1314 goto common;
1315#endif
643d1ab2 1316#if defined(CONFIG_CMD_NFS)
cbd8a35c 1317 case NFS:
73a8b27c 1318#endif
bc0571fc 1319 /* Fall through */
e4bf0c5c 1320 case TFTPGET:
1fb7cd49 1321 case TFTPPUT:
049a95a7 1322 if (net_server_ip.s_addr == 0) {
4f63acd0 1323 puts("*** ERROR: `serverip' not set\n");
92895de9 1324 return 1;
6e592385 1325 }
4f63acd0
LC
1326#if defined(CONFIG_CMD_PING) || defined(CONFIG_CMD_SNTP) || \
1327 defined(CONFIG_CMD_DNS)
1328common:
73a8b27c 1329#endif
8b6bbe10 1330 /* Fall through */
73a8b27c 1331
8b6bbe10 1332 case NETCONS:
7a83af07 1333 case TFTPSRV:
049a95a7 1334 if (net_ip.s_addr == 0) {
4f63acd0 1335 puts("*** ERROR: `ipaddr' not set\n");
92895de9 1336 return 1;
6e592385
WD
1337 }
1338 /* Fall through */
2d966958 1339
bf6cb247 1340#ifdef CONFIG_CMD_RARP
2d966958 1341 case RARP:
bf6cb247 1342#endif
2d966958 1343 case BOOTP:
a3d991bd 1344 case CDP:
bf6cb247 1345 case DHCP:
d22c338e 1346 case LINKLOCAL:
0adb5b76 1347 if (memcmp(net_ethaddr, "\0\0\0\0\0\0", 6) == 0) {
4f63acd0 1348 int num = eth_get_dev_index();
2d966958 1349
6e592385
WD
1350 switch (num) {
1351 case -1:
4f63acd0 1352 puts("*** ERROR: No ethernet found.\n");
92895de9 1353 return 1;
6e592385 1354 case 0:
4f63acd0 1355 puts("*** ERROR: `ethaddr' not set\n");
2d966958 1356 break;
6e592385 1357 default:
4f63acd0 1358 printf("*** ERROR: `eth%daddr' not set\n",
bc0571fc 1359 num);
2d966958 1360 break;
6e592385 1361 }
2d966958 1362
bc0571fc 1363 net_start_again();
92895de9 1364 return 2;
6e592385
WD
1365 }
1366 /* Fall through */
1367 default:
92895de9 1368 return 0;
2d966958 1369 }
92895de9 1370 return 0; /* OK */
2d966958
WD
1371}
1372/**********************************************************************/
1373
a3d991bd 1374int
1203fcce 1375net_eth_hdr_size(void)
a3d991bd
WD
1376{
1377 ushort myvlanid;
2d966958 1378
4fd5055f 1379 myvlanid = ntohs(net_our_vlan);
a3d991bd
WD
1380 if (myvlanid == (ushort)-1)
1381 myvlanid = VLAN_NONE;
1382
3e38e429
LC
1383 return ((myvlanid & VLAN_IDMASK) == VLAN_NONE) ? ETHER_HDR_SIZE :
1384 VLAN_ETHER_HDR_SIZE;
a3d991bd
WD
1385}
1386
1203fcce 1387int net_set_ether(uchar *xet, const uchar *dest_ethaddr, uint prot)
2d966958 1388{
cb487f56 1389 struct ethernet_hdr *et = (struct ethernet_hdr *)xet;
a3d991bd
WD
1390 ushort myvlanid;
1391
4fd5055f 1392 myvlanid = ntohs(net_our_vlan);
a3d991bd
WD
1393 if (myvlanid == (ushort)-1)
1394 myvlanid = VLAN_NONE;
2d966958 1395
0adb5b76
JH
1396 memcpy(et->et_dest, dest_ethaddr, 6);
1397 memcpy(et->et_src, net_ethaddr, 6);
a3d991bd 1398 if ((myvlanid & VLAN_IDMASK) == VLAN_NONE) {
c819abee 1399 et->et_protlen = htons(prot);
a3d991bd
WD
1400 return ETHER_HDR_SIZE;
1401 } else {
c68cca35
JH
1402 struct vlan_ethernet_hdr *vet =
1403 (struct vlan_ethernet_hdr *)xet;
2d966958 1404
a3d991bd
WD
1405 vet->vet_vlan_type = htons(PROT_VLAN);
1406 vet->vet_tag = htons((0 << 5) | (myvlanid & VLAN_IDMASK));
1407 vet->vet_type = htons(prot);
1408 return VLAN_ETHER_HDR_SIZE;
1409 }
1410}
2d966958 1411
e7111015
JH
1412int net_update_ether(struct ethernet_hdr *et, uchar *addr, uint prot)
1413{
1414 ushort protlen;
1415
1416 memcpy(et->et_dest, addr, 6);
0adb5b76 1417 memcpy(et->et_src, net_ethaddr, 6);
e7111015
JH
1418 protlen = ntohs(et->et_protlen);
1419 if (protlen == PROT_VLAN) {
1420 struct vlan_ethernet_hdr *vet =
1421 (struct vlan_ethernet_hdr *)et;
1422 vet->vet_type = htons(prot);
1423 return VLAN_ETHER_HDR_SIZE;
1424 } else if (protlen > 1514) {
1425 et->et_protlen = htons(prot);
1426 return ETHER_HDR_SIZE;
1427 } else {
1428 /* 802.2 + SNAP */
1429 struct e802_hdr *et802 = (struct e802_hdr *)et;
1430 et802->et_prot = htons(prot);
1431 return E802_HDR_SIZE;
1432 }
1433}
1434
049a95a7 1435void net_set_ip_header(uchar *pkt, struct in_addr dest, struct in_addr source)
2d966958 1436{
4b11c916 1437 struct ip_udp_hdr *ip = (struct ip_udp_hdr *)pkt;
2d966958
WD
1438
1439 /*
4b11c916 1440 * Construct an IP header.
2d966958 1441 */
3e38e429
LC
1442 /* IP_HDR_SIZE / 4 (not including UDP) */
1443 ip->ip_hl_v = 0x45;
2d966958 1444 ip->ip_tos = 0;
4b11c916 1445 ip->ip_len = htons(IP_HDR_SIZE);
bc0571fc 1446 ip->ip_id = htons(net_ip_id++);
e0c07b86 1447 ip->ip_off = htons(IP_FLAGS_DFRAG); /* Don't fragment */
2d966958 1448 ip->ip_ttl = 255;
2d966958 1449 ip->ip_sum = 0;
3e38e429 1450 /* already in network byte order */
049a95a7 1451 net_copy_ip((void *)&ip->ip_src, &source);
4b11c916 1452 /* already in network byte order */
049a95a7 1453 net_copy_ip((void *)&ip->ip_dst, &dest);
4b11c916
JH
1454}
1455
049a95a7 1456void net_set_udp_header(uchar *pkt, struct in_addr dest, int dport, int sport,
4b11c916
JH
1457 int len)
1458{
1459 struct ip_udp_hdr *ip = (struct ip_udp_hdr *)pkt;
1460
1461 /*
1462 * If the data is an odd number of bytes, zero the
1463 * byte after the last byte so that the checksum
1464 * will work.
1465 */
1466 if (len & 1)
1467 pkt[IP_UDP_HDR_SIZE + len] = 0;
1468
049a95a7 1469 net_set_ip_header(pkt, dest, net_ip);
4b11c916
JH
1470 ip->ip_len = htons(IP_UDP_HDR_SIZE + len);
1471 ip->ip_p = IPPROTO_UDP;
0da0fcd5 1472 ip->ip_sum = compute_ip_checksum(ip, IP_HDR_SIZE);
4b11c916 1473
2d966958
WD
1474 ip->udp_src = htons(sport);
1475 ip->udp_dst = htons(dport);
594c26f8 1476 ip->udp_len = htons(UDP_HDR_SIZE + len);
2d966958 1477 ip->udp_xsum = 0;
2d966958
WD
1478}
1479
4f63acd0 1480void copy_filename(char *dst, const char *src, int size)
2d966958
WD
1481{
1482 if (*src && (*src == '"')) {
1483 ++src;
1484 --size;
1485 }
1486
d3c65b01 1487 while ((--size > 0) && *src && (*src != '"'))
2d966958 1488 *dst++ = *src++;
2d966958
WD
1489 *dst = '\0';
1490}
1491
3e38e429
LC
1492#if defined(CONFIG_CMD_NFS) || \
1493 defined(CONFIG_CMD_SNTP) || \
1494 defined(CONFIG_CMD_DNS)
1a32bf41 1495/*
9739946c
RG
1496 * make port a little random (1024-17407)
1497 * This keeps the math somewhat trivial to compute, and seems to work with
1498 * all supported protocols/clients/servers
1a32bf41
RG
1499 */
1500unsigned int random_port(void)
1501{
9739946c 1502 return 1024 + (get_timer(0) % 0x4000);
1a32bf41
RG
1503}
1504#endif
1505
049a95a7 1506void ip_to_string(struct in_addr x, char *s)
2d966958 1507{
049a95a7 1508 x.s_addr = ntohl(x.s_addr);
4f63acd0 1509 sprintf(s, "%d.%d.%d.%d",
049a95a7
JH
1510 (int) ((x.s_addr >> 24) & 0xff),
1511 (int) ((x.s_addr >> 16) & 0xff),
1512 (int) ((x.s_addr >> 8) & 0xff),
1513 (int) ((x.s_addr >> 0) & 0xff)
6e592385 1514 );
2d966958
WD
1515}
1516
4fd5055f 1517void vlan_to_string(ushort x, char *s)
a3d991bd
WD
1518{
1519 x = ntohs(x);
1520
1521 if (x == (ushort)-1)
1522 x = VLAN_NONE;
1523
1524 if (x == VLAN_NONE)
1525 strcpy(s, "none");
1526 else
1527 sprintf(s, "%d", x & VLAN_IDMASK);
1528}
1529
4fd5055f 1530ushort string_to_vlan(const char *s)
a3d991bd
WD
1531{
1532 ushort id;
1533
1534 if (s == NULL)
b9711de1 1535 return htons(VLAN_NONE);
a3d991bd
WD
1536
1537 if (*s < '0' || *s > '9')
1538 id = VLAN_NONE;
1539 else
1540 id = (ushort)simple_strtoul(s, NULL, 10);
1541
b9711de1 1542 return htons(id);
a3d991bd
WD
1543}
1544
4fd5055f 1545ushort getenv_vlan(char *var)
a3d991bd 1546{
4fd5055f 1547 return string_to_vlan(getenv(var));
a3d991bd 1548}