1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84#include <common.h>
85#include <bootstage.h>
86#include <command.h>
87#include <console.h>
88#include <env.h>
89#include <env_internal.h>
90#include <errno.h>
91#include <image.h>
92#include <log.h>
93#include <net.h>
94#include <net/fastboot.h>
95#include <net/tftp.h>
96#if defined(CONFIG_CMD_PCAP)
97#include <net/pcap.h>
98#endif
99#include <net/udp.h>
100#if defined(CONFIG_LED_STATUS)
101#include <miiphy.h>
102#include <status_led.h>
103#endif
104#include <watchdog.h>
105#include <linux/compiler.h>
106#include "arp.h"
107#include "bootp.h"
108#include "cdp.h"
109#if defined(CONFIG_CMD_DNS)
110#include "dns.h"
111#endif
112#include "link_local.h"
113#include "nfs.h"
114#include "ping.h"
115#include "rarp.h"
116#if defined(CONFIG_CMD_WOL)
117#include "wol.h"
118#endif
119
120
121
122
123struct in_addr net_netmask;
124
125struct in_addr net_gateway;
126
127struct in_addr net_dns_server;
128#if defined(CONFIG_BOOTP_DNS2)
129
130struct in_addr net_dns_server2;
131#endif
132
133
134
135
136u8 net_ethaddr[6];
137
138u8 net_server_ethaddr[6];
139
140struct in_addr net_ip;
141
142struct in_addr net_server_ip;
143
144uchar *net_rx_packet;
145
146int net_rx_packet_len;
147
148static unsigned net_ip_id;
149
150const u8 net_bcast_ethaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
151const u8 net_null_ethaddr[6];
152#if defined(CONFIG_API) || defined(CONFIG_EFI_LOADER)
153void (*push_packet)(void *, int len) = 0;
154#endif
155
156enum net_loop_state net_state;
157
158int net_restart_wrap;
159
160static int net_restarted;
161
162static int net_dev_exists;
163
164
165
166ushort net_our_vlan = 0xFFFF;
167
168ushort net_native_vlan = 0xFFFF;
169
170
171char net_boot_file_name[1024];
172
173bool net_boot_file_name_explicit;
174
175u32 net_boot_file_size;
176
177u32 net_boot_file_expected_size_in_blocks;
178
179static uchar net_pkt_buf[(PKTBUFSRX+1) * PKTSIZE_ALIGN + PKTALIGN];
180
181uchar *net_rx_packets[PKTBUFSRX];
182
183static rxhand_f *udp_packet_handler;
184
185static rxhand_f *arp_packet_handler;
186#ifdef CONFIG_CMD_TFTPPUT
187
188static rxhand_icmp_f *packet_icmp_handler;
189#endif
190
191static thand_f *time_handler;
192
193static ulong time_start;
194
195static ulong time_delta;
196
197uchar *net_tx_packet;
198
199static int net_check_prereq(enum proto_t protocol);
200
201static int net_try_count;
202
203int __maybe_unused net_busy_flag;
204
205
206
207static int on_ipaddr(const char *name, const char *value, enum env_op op,
208 int flags)
209{
210 if (flags & H_PROGRAMMATIC)
211 return 0;
212
213 net_ip = string_to_ip(value);
214
215 return 0;
216}
217U_BOOT_ENV_CALLBACK(ipaddr, on_ipaddr);
218
219static int on_gatewayip(const char *name, const char *value, enum env_op op,
220 int flags)
221{
222 if (flags & H_PROGRAMMATIC)
223 return 0;
224
225 net_gateway = string_to_ip(value);
226
227 return 0;
228}
229U_BOOT_ENV_CALLBACK(gatewayip, on_gatewayip);
230
231static int on_netmask(const char *name, const char *value, enum env_op op,
232 int flags)
233{
234 if (flags & H_PROGRAMMATIC)
235 return 0;
236
237 net_netmask = string_to_ip(value);
238
239 return 0;
240}
241U_BOOT_ENV_CALLBACK(netmask, on_netmask);
242
243static int on_serverip(const char *name, const char *value, enum env_op op,
244 int flags)
245{
246 if (flags & H_PROGRAMMATIC)
247 return 0;
248
249 net_server_ip = string_to_ip(value);
250
251 return 0;
252}
253U_BOOT_ENV_CALLBACK(serverip, on_serverip);
254
255static int on_nvlan(const char *name, const char *value, enum env_op op,
256 int flags)
257{
258 if (flags & H_PROGRAMMATIC)
259 return 0;
260
261 net_native_vlan = string_to_vlan(value);
262
263 return 0;
264}
265U_BOOT_ENV_CALLBACK(nvlan, on_nvlan);
266
267static int on_vlan(const char *name, const char *value, enum env_op op,
268 int flags)
269{
270 if (flags & H_PROGRAMMATIC)
271 return 0;
272
273 net_our_vlan = string_to_vlan(value);
274
275 return 0;
276}
277U_BOOT_ENV_CALLBACK(vlan, on_vlan);
278
279#if defined(CONFIG_CMD_DNS)
280static int on_dnsip(const char *name, const char *value, enum env_op op,
281 int flags)
282{
283 if (flags & H_PROGRAMMATIC)
284 return 0;
285
286 net_dns_server = string_to_ip(value);
287
288 return 0;
289}
290U_BOOT_ENV_CALLBACK(dnsip, on_dnsip);
291#endif
292
293
294
295
296
297void net_auto_load(void)
298{
299#if defined(CONFIG_CMD_NFS) && !defined(CONFIG_SPL_BUILD)
300 const char *s = env_get("autoload");
301
302 if (s != NULL && strcmp(s, "NFS") == 0) {
303 if (net_check_prereq(NFS)) {
304
305#ifdef CONFIG_BOOTP_SERVERIP
306 net_set_state(NETLOOP_SUCCESS);
307#else
308 printf("Cannot autoload with NFS\n");
309 net_set_state(NETLOOP_FAIL);
310#endif
311 return;
312 }
313
314
315
316 nfs_start();
317 return;
318 }
319#endif
320 if (env_get_yesno("autoload") == 0) {
321
322
323
324
325 net_set_state(NETLOOP_SUCCESS);
326 return;
327 }
328 if (net_check_prereq(TFTPGET)) {
329
330#ifdef CONFIG_BOOTP_SERVERIP
331 net_set_state(NETLOOP_SUCCESS);
332#else
333 printf("Cannot autoload with TFTPGET\n");
334 net_set_state(NETLOOP_FAIL);
335#endif
336 return;
337 }
338 tftp_start(TFTPGET);
339}
340
341static int net_init_loop(void)
342{
343 if (eth_get_dev())
344 memcpy(net_ethaddr, eth_get_ethaddr(), 6);
345 else
346
347
348
349
350
351 return -ENONET;
352
353 return 0;
354}
355
356static void net_clear_handlers(void)
357{
358 net_set_udp_handler(NULL);
359 net_set_arp_handler(NULL);
360 net_set_timeout_handler(0, NULL);
361}
362
363static void net_cleanup_loop(void)
364{
365 net_clear_handlers();
366}
367
368int net_init(void)
369{
370 static int first_call = 1;
371
372 if (first_call) {
373
374
375
376 int i;
377
378 net_tx_packet = &net_pkt_buf[0] + (PKTALIGN - 1);
379 net_tx_packet -= (ulong)net_tx_packet % PKTALIGN;
380 for (i = 0; i < PKTBUFSRX; i++) {
381 net_rx_packets[i] = net_tx_packet +
382 (i + 1) * PKTSIZE_ALIGN;
383 }
384 arp_init();
385 net_clear_handlers();
386
387
388 first_call = 0;
389 }
390
391 return net_init_loop();
392}
393
394
395
396
397
398
399int net_loop(enum proto_t protocol)
400{
401 int ret = -EINVAL;
402 enum net_loop_state prev_net_state = net_state;
403
404#if defined(CONFIG_CMD_PING)
405 if (protocol != PING)
406 net_ping_ip.s_addr = 0;
407#endif
408 net_restarted = 0;
409 net_dev_exists = 0;
410 net_try_count = 1;
411 debug_cond(DEBUG_INT_STATE, "--- net_loop Entry\n");
412
413 bootstage_mark_name(BOOTSTAGE_ID_ETH_START, "eth_start");
414 net_init();
415 if (eth_is_on_demand_init()) {
416 eth_halt();
417 eth_set_current();
418 ret = eth_init();
419 if (ret < 0) {
420 eth_halt();
421 return ret;
422 }
423 } else {
424 eth_init_state_only();
425 }
426restart:
427#ifdef CONFIG_USB_KEYBOARD
428 net_busy_flag = 0;
429#endif
430 net_set_state(NETLOOP_CONTINUE);
431
432
433
434
435
436
437 debug_cond(DEBUG_INT_STATE, "--- net_loop Init\n");
438 net_init_loop();
439
440 switch (net_check_prereq(protocol)) {
441 case 1:
442
443 eth_halt();
444 net_set_state(prev_net_state);
445 return -ENODEV;
446
447 case 2:
448
449 break;
450
451 case 0:
452 net_dev_exists = 1;
453 net_boot_file_size = 0;
454 switch (protocol) {
455#ifdef CONFIG_CMD_TFTPBOOT
456 case TFTPGET:
457#ifdef CONFIG_CMD_TFTPPUT
458 case TFTPPUT:
459#endif
460
461 tftp_start(protocol);
462 break;
463#endif
464#ifdef CONFIG_CMD_TFTPSRV
465 case TFTPSRV:
466 tftp_start_server();
467 break;
468#endif
469#ifdef CONFIG_UDP_FUNCTION_FASTBOOT
470 case FASTBOOT:
471 fastboot_start_server();
472 break;
473#endif
474#if defined(CONFIG_CMD_DHCP)
475 case DHCP:
476 bootp_reset();
477 net_ip.s_addr = 0;
478 dhcp_request();
479 break;
480#endif
481#if defined(CONFIG_CMD_BOOTP)
482 case BOOTP:
483 bootp_reset();
484 net_ip.s_addr = 0;
485 bootp_request();
486 break;
487#endif
488#if defined(CONFIG_CMD_RARP)
489 case RARP:
490 rarp_try = 0;
491 net_ip.s_addr = 0;
492 rarp_request();
493 break;
494#endif
495#if defined(CONFIG_CMD_PING)
496 case PING:
497 ping_start();
498 break;
499#endif
500#if defined(CONFIG_CMD_NFS) && !defined(CONFIG_SPL_BUILD)
501 case NFS:
502 nfs_start();
503 break;
504#endif
505#if defined(CONFIG_CMD_CDP)
506 case CDP:
507 cdp_start();
508 break;
509#endif
510#if defined(CONFIG_NETCONSOLE) && !defined(CONFIG_SPL_BUILD)
511 case NETCONS:
512 nc_start();
513 break;
514#endif
515#if defined(CONFIG_CMD_DNS)
516 case DNS:
517 dns_start();
518 break;
519#endif
520#if defined(CONFIG_CMD_LINK_LOCAL)
521 case LINKLOCAL:
522 link_local_start();
523 break;
524#endif
525#if defined(CONFIG_CMD_WOL)
526 case WOL:
527 wol_start();
528 break;
529#endif
530 default:
531 break;
532 }
533
534 if (IS_ENABLED(CONFIG_PROT_UDP) && protocol == UDP)
535 udp_start();
536
537 break;
538 }
539
540#if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
541#if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \
542 defined(CONFIG_LED_STATUS) && \
543 defined(CONFIG_LED_STATUS_RED)
544
545
546
547 if (miiphy_link(eth_get_dev()->name, CONFIG_SYS_FAULT_MII_ADDR))
548 status_led_set(CONFIG_LED_STATUS_RED, CONFIG_LED_STATUS_OFF);
549 else
550 status_led_set(CONFIG_LED_STATUS_RED, CONFIG_LED_STATUS_ON);
551#endif
552#endif
553#ifdef CONFIG_USB_KEYBOARD
554 net_busy_flag = 1;
555#endif
556
557
558
559
560
561 for (;;) {
562 WATCHDOG_RESET();
563 if (arp_timeout_check() > 0)
564 time_start = get_timer(0);
565
566
567
568
569
570
571
572 eth_rx();
573
574
575
576
577 if (ctrlc()) {
578
579 net_arp_wait_packet_ip.s_addr = 0;
580
581 net_cleanup_loop();
582 eth_halt();
583
584 eth_set_last_protocol(BOOTP);
585
586 puts("\nAbort\n");
587
588
589 debug_cond(DEBUG_INT_STATE, "--- net_loop Abort!\n");
590 ret = -EINTR;
591 goto done;
592 }
593
594
595
596
597
598 if (time_handler &&
599 ((get_timer(0) - time_start) > time_delta)) {
600 thand_f *x;
601
602#if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
603#if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \
604 defined(CONFIG_LED_STATUS) && \
605 defined(CONFIG_LED_STATUS_RED)
606
607
608
609 if (miiphy_link(eth_get_dev()->name,
610 CONFIG_SYS_FAULT_MII_ADDR))
611 status_led_set(CONFIG_LED_STATUS_RED,
612 CONFIG_LED_STATUS_OFF);
613 else
614 status_led_set(CONFIG_LED_STATUS_RED,
615 CONFIG_LED_STATUS_ON);
616#endif
617#endif
618 debug_cond(DEBUG_INT_STATE, "--- net_loop timeout\n");
619 x = time_handler;
620 time_handler = (thand_f *)0;
621 (*x)();
622 }
623
624 if (net_state == NETLOOP_FAIL)
625 ret = net_start_again();
626
627 switch (net_state) {
628 case NETLOOP_RESTART:
629 net_restarted = 1;
630 goto restart;
631
632 case NETLOOP_SUCCESS:
633 net_cleanup_loop();
634 if (net_boot_file_size > 0) {
635 printf("Bytes transferred = %d (%x hex)\n",
636 net_boot_file_size, net_boot_file_size);
637 env_set_hex("filesize", net_boot_file_size);
638 env_set_hex("fileaddr", image_load_addr);
639 }
640 if (protocol != NETCONS)
641 eth_halt();
642 else
643 eth_halt_state_only();
644
645 eth_set_last_protocol(protocol);
646
647 ret = net_boot_file_size;
648 debug_cond(DEBUG_INT_STATE, "--- net_loop Success!\n");
649 goto done;
650
651 case NETLOOP_FAIL:
652 net_cleanup_loop();
653
654 eth_set_last_protocol(BOOTP);
655 debug_cond(DEBUG_INT_STATE, "--- net_loop Fail!\n");
656 ret = -ENONET;
657 goto done;
658
659 case NETLOOP_CONTINUE:
660 continue;
661 }
662 }
663
664done:
665#ifdef CONFIG_USB_KEYBOARD
666 net_busy_flag = 0;
667#endif
668#ifdef CONFIG_CMD_TFTPPUT
669
670 net_set_udp_handler(NULL);
671 net_set_icmp_handler(NULL);
672#endif
673 net_set_state(prev_net_state);
674
675#if defined(CONFIG_CMD_PCAP)
676 if (pcap_active())
677 pcap_print_status();
678#endif
679 return ret;
680}
681
682
683
684static void start_again_timeout_handler(void)
685{
686 net_set_state(NETLOOP_RESTART);
687}
688
689int net_start_again(void)
690{
691 char *nretry;
692 int retry_forever = 0;
693 unsigned long retrycnt = 0;
694 int ret;
695
696 nretry = env_get("netretry");
697 if (nretry) {
698 if (!strcmp(nretry, "yes"))
699 retry_forever = 1;
700 else if (!strcmp(nretry, "no"))
701 retrycnt = 0;
702 else if (!strcmp(nretry, "once"))
703 retrycnt = 1;
704 else
705 retrycnt = simple_strtoul(nretry, NULL, 0);
706 } else {
707 retrycnt = 0;
708 retry_forever = 0;
709 }
710
711 if ((!retry_forever) && (net_try_count > retrycnt)) {
712 eth_halt();
713 net_set_state(NETLOOP_FAIL);
714
715
716
717
718 return -ETIMEDOUT;
719 }
720
721 net_try_count++;
722
723 eth_halt();
724#if !defined(CONFIG_NET_DO_NOT_TRY_ANOTHER)
725 eth_try_another(!net_restarted);
726#endif
727 ret = eth_init();
728 if (net_restart_wrap) {
729 net_restart_wrap = 0;
730 if (net_dev_exists) {
731 net_set_timeout_handler(10000UL,
732 start_again_timeout_handler);
733 net_set_udp_handler(NULL);
734 } else {
735 net_set_state(NETLOOP_FAIL);
736 }
737 } else {
738 net_set_state(NETLOOP_RESTART);
739 }
740 return ret;
741}
742
743
744
745
746
747
748static void dummy_handler(uchar *pkt, unsigned dport,
749 struct in_addr sip, unsigned sport,
750 unsigned len)
751{
752}
753
754rxhand_f *net_get_udp_handler(void)
755{
756 return udp_packet_handler;
757}
758
759void net_set_udp_handler(rxhand_f *f)
760{
761 debug_cond(DEBUG_INT_STATE, "--- net_loop UDP handler set (%p)\n", f);
762 if (f == NULL)
763 udp_packet_handler = dummy_handler;
764 else
765 udp_packet_handler = f;
766}
767
768rxhand_f *net_get_arp_handler(void)
769{
770 return arp_packet_handler;
771}
772
773void net_set_arp_handler(rxhand_f *f)
774{
775 debug_cond(DEBUG_INT_STATE, "--- net_loop ARP handler set (%p)\n", f);
776 if (f == NULL)
777 arp_packet_handler = dummy_handler;
778 else
779 arp_packet_handler = f;
780}
781
782#ifdef CONFIG_CMD_TFTPPUT
783void net_set_icmp_handler(rxhand_icmp_f *f)
784{
785 packet_icmp_handler = f;
786}
787#endif
788
789void net_set_timeout_handler(ulong iv, thand_f *f)
790{
791 if (iv == 0) {
792 debug_cond(DEBUG_INT_STATE,
793 "--- net_loop timeout handler cancelled\n");
794 time_handler = (thand_f *)0;
795 } else {
796 debug_cond(DEBUG_INT_STATE,
797 "--- net_loop timeout handler set (%p)\n", f);
798 time_handler = f;
799 time_start = get_timer(0);
800 time_delta = iv * CONFIG_SYS_HZ / 1000;
801 }
802}
803
804uchar *net_get_async_tx_pkt_buf(void)
805{
806 if (arp_is_waiting())
807 return arp_tx_packet;
808 else
809 return net_tx_packet;
810}
811
812int net_send_udp_packet(uchar *ether, struct in_addr dest, int dport, int sport,
813 int payload_len)
814{
815 return net_send_ip_packet(ether, dest, dport, sport, payload_len,
816 IPPROTO_UDP, 0, 0, 0);
817}
818
819int net_send_ip_packet(uchar *ether, struct in_addr dest, int dport, int sport,
820 int payload_len, int proto, u8 action, u32 tcp_seq_num,
821 u32 tcp_ack_num)
822{
823 uchar *pkt;
824 int eth_hdr_size;
825 int pkt_hdr_size;
826
827
828 assert(net_tx_packet != NULL);
829 if (net_tx_packet == NULL)
830 return -1;
831
832
833 if (dest.s_addr == 0)
834 dest.s_addr = 0xFFFFFFFF;
835
836
837 if (dest.s_addr == 0xFFFFFFFF)
838 ether = (uchar *)net_bcast_ethaddr;
839
840 pkt = (uchar *)net_tx_packet;
841
842 eth_hdr_size = net_set_ether(pkt, ether, PROT_IP);
843
844 switch (proto) {
845 case IPPROTO_UDP:
846 net_set_udp_header(pkt + eth_hdr_size, dest, dport, sport,
847 payload_len);
848 pkt_hdr_size = eth_hdr_size + IP_UDP_HDR_SIZE;
849 break;
850 default:
851 return -EINVAL;
852 }
853
854
855 if (memcmp(ether, net_null_ethaddr, 6) == 0) {
856 debug_cond(DEBUG_DEV_PKT, "sending ARP for %pI4\n", &dest);
857
858
859 net_arp_wait_packet_ip = dest;
860 arp_wait_packet_ethaddr = ether;
861
862
863 arp_wait_tx_packet_size = pkt_hdr_size + payload_len;
864
865
866 arp_wait_try = 1;
867 arp_wait_timer_start = get_timer(0);
868 arp_request();
869 return 1;
870 } else {
871 debug_cond(DEBUG_DEV_PKT, "sending UDP to %pI4/%pM\n",
872 &dest, ether);
873 net_send_packet(net_tx_packet, pkt_hdr_size + payload_len);
874 return 0;
875 }
876}
877
878#ifdef CONFIG_IP_DEFRAG
879
880
881
882
883
884#define IP_PKTSIZE (CONFIG_NET_MAXDEFRAG)
885
886#define IP_MAXUDP (IP_PKTSIZE - IP_HDR_SIZE)
887
888
889
890
891
892struct hole {
893
894 u16 last_byte;
895 u16 next_hole;
896 u16 prev_hole;
897 u16 unused;
898};
899
900static struct ip_udp_hdr *__net_defragment(struct ip_udp_hdr *ip, int *lenp)
901{
902 static uchar pkt_buff[IP_PKTSIZE] __aligned(PKTALIGN);
903 static u16 first_hole, total_len;
904 struct hole *payload, *thisfrag, *h, *newh;
905 struct ip_udp_hdr *localip = (struct ip_udp_hdr *)pkt_buff;
906 uchar *indata = (uchar *)ip;
907 int offset8, start, len, done = 0;
908 u16 ip_off = ntohs(ip->ip_off);
909
910
911 payload = (struct hole *)(pkt_buff + IP_HDR_SIZE);
912 offset8 = (ip_off & IP_OFFS);
913 thisfrag = payload + offset8;
914 start = offset8 * 8;
915 len = ntohs(ip->ip_len) - IP_HDR_SIZE;
916
917 if (start + len > IP_MAXUDP)
918 return NULL;
919
920 if (!total_len || localip->ip_id != ip->ip_id) {
921
922 total_len = 0xffff;
923 payload[0].last_byte = ~0;
924 payload[0].next_hole = 0;
925 payload[0].prev_hole = 0;
926 first_hole = 0;
927
928 memcpy(localip, ip, IP_HDR_SIZE);
929 }
930
931
932
933
934
935
936
937
938 h = payload + first_hole;
939 while (h->last_byte < start) {
940 if (!h->next_hole) {
941
942 return NULL;
943 }
944 h = payload + h->next_hole;
945 }
946
947
948 if (offset8 + ((len + 7) / 8) <= h - payload) {
949
950 return NULL;
951 }
952
953 if (!(ip_off & IP_FLAGS_MFRAG)) {
954
955 total_len = start + len;
956 h->last_byte = start + len;
957 }
958
959
960
961
962
963
964
965 if ((h >= thisfrag) && (h->last_byte <= start + len)) {
966
967 if (!h->prev_hole && !h->next_hole) {
968
969 done = 1;
970 } else if (!h->prev_hole) {
971
972 first_hole = h->next_hole;
973 payload[h->next_hole].prev_hole = 0;
974 } else if (!h->next_hole) {
975
976 payload[h->prev_hole].next_hole = 0;
977 } else {
978
979 payload[h->next_hole].prev_hole = h->prev_hole;
980 payload[h->prev_hole].next_hole = h->next_hole;
981 }
982
983 } else if (h->last_byte <= start + len) {
984
985 h->last_byte = start;
986
987 } else if (h >= thisfrag) {
988
989 newh = thisfrag + (len / 8);
990 *newh = *h;
991 h = newh;
992 if (h->next_hole)
993 payload[h->next_hole].prev_hole = (h - payload);
994 if (h->prev_hole)
995 payload[h->prev_hole].next_hole = (h - payload);
996 else
997 first_hole = (h - payload);
998
999 } else {
1000
1001 newh = thisfrag + (len / 8);
1002 *newh = *h;
1003 h->last_byte = start;
1004 h->next_hole = (newh - payload);
1005 newh->prev_hole = (h - payload);
1006 if (newh->next_hole)
1007 payload[newh->next_hole].prev_hole = (newh - payload);
1008 }
1009
1010
1011 memcpy((uchar *)thisfrag, indata + IP_HDR_SIZE, len);
1012 if (!done)
1013 return NULL;
1014
1015 localip->ip_len = htons(total_len);
1016 *lenp = total_len + IP_HDR_SIZE;
1017 return localip;
1018}
1019
1020static inline struct ip_udp_hdr *net_defragment(struct ip_udp_hdr *ip,
1021 int *lenp)
1022{
1023 u16 ip_off = ntohs(ip->ip_off);
1024 if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG)))
1025 return ip;
1026 return __net_defragment(ip, lenp);
1027}
1028
1029#else
1030
1031static inline struct ip_udp_hdr *net_defragment(struct ip_udp_hdr *ip,
1032 int *lenp)
1033{
1034 u16 ip_off = ntohs(ip->ip_off);
1035 if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG)))
1036 return ip;
1037 return NULL;
1038}
1039#endif
1040
1041
1042
1043
1044
1045
1046
1047static void receive_icmp(struct ip_udp_hdr *ip, int len,
1048 struct in_addr src_ip, struct ethernet_hdr *et)
1049{
1050 struct icmp_hdr *icmph = (struct icmp_hdr *)&ip->udp_src;
1051
1052 switch (icmph->type) {
1053 case ICMP_REDIRECT:
1054 if (icmph->code != ICMP_REDIR_HOST)
1055 return;
1056 printf(" ICMP Host Redirect to %pI4 ",
1057 &icmph->un.gateway);
1058 break;
1059 default:
1060#if defined(CONFIG_CMD_PING)
1061 ping_receive(et, ip, len);
1062#endif
1063#ifdef CONFIG_CMD_TFTPPUT
1064 if (packet_icmp_handler)
1065 packet_icmp_handler(icmph->type, icmph->code,
1066 ntohs(ip->udp_dst), src_ip,
1067 ntohs(ip->udp_src), icmph->un.data,
1068 ntohs(ip->udp_len));
1069#endif
1070 break;
1071 }
1072}
1073
1074void net_process_received_packet(uchar *in_packet, int len)
1075{
1076 struct ethernet_hdr *et;
1077 struct ip_udp_hdr *ip;
1078 struct in_addr dst_ip;
1079 struct in_addr src_ip;
1080 int eth_proto;
1081#if defined(CONFIG_CMD_CDP)
1082 int iscdp;
1083#endif
1084 ushort cti = 0, vlanid = VLAN_NONE, myvlanid, mynvlanid;
1085
1086 debug_cond(DEBUG_NET_PKT, "packet received\n");
1087
1088#if defined(CONFIG_CMD_PCAP)
1089 pcap_post(in_packet, len, false);
1090#endif
1091 net_rx_packet = in_packet;
1092 net_rx_packet_len = len;
1093 et = (struct ethernet_hdr *)in_packet;
1094
1095
1096 if (len < ETHER_HDR_SIZE)
1097 return;
1098
1099#if defined(CONFIG_API) || defined(CONFIG_EFI_LOADER)
1100 if (push_packet) {
1101 (*push_packet)(in_packet, len);
1102 return;
1103 }
1104#endif
1105
1106#if defined(CONFIG_CMD_CDP)
1107
1108 iscdp = is_cdp_packet(et->et_dest);
1109#endif
1110
1111 myvlanid = ntohs(net_our_vlan);
1112 if (myvlanid == (ushort)-1)
1113 myvlanid = VLAN_NONE;
1114 mynvlanid = ntohs(net_native_vlan);
1115 if (mynvlanid == (ushort)-1)
1116 mynvlanid = VLAN_NONE;
1117
1118 eth_proto = ntohs(et->et_protlen);
1119
1120 if (eth_proto < 1514) {
1121 struct e802_hdr *et802 = (struct e802_hdr *)et;
1122
1123
1124
1125
1126 eth_proto = ntohs(et802->et_prot);
1127
1128 ip = (struct ip_udp_hdr *)(in_packet + E802_HDR_SIZE);
1129 len -= E802_HDR_SIZE;
1130
1131 } else if (eth_proto != PROT_VLAN) {
1132 ip = (struct ip_udp_hdr *)(in_packet + ETHER_HDR_SIZE);
1133 len -= ETHER_HDR_SIZE;
1134
1135 } else {
1136 struct vlan_ethernet_hdr *vet =
1137 (struct vlan_ethernet_hdr *)et;
1138
1139 debug_cond(DEBUG_NET_PKT, "VLAN packet received\n");
1140
1141
1142 if (len < VLAN_ETHER_HDR_SIZE)
1143 return;
1144
1145
1146 if ((ntohs(net_our_vlan) & VLAN_IDMASK) == VLAN_NONE
1147#if defined(CONFIG_CMD_CDP)
1148 && iscdp == 0
1149#endif
1150 )
1151 return;
1152
1153 cti = ntohs(vet->vet_tag);
1154 vlanid = cti & VLAN_IDMASK;
1155 eth_proto = ntohs(vet->vet_type);
1156
1157 ip = (struct ip_udp_hdr *)(in_packet + VLAN_ETHER_HDR_SIZE);
1158 len -= VLAN_ETHER_HDR_SIZE;
1159 }
1160
1161 debug_cond(DEBUG_NET_PKT, "Receive from protocol 0x%x\n", eth_proto);
1162
1163#if defined(CONFIG_CMD_CDP)
1164 if (iscdp) {
1165 cdp_receive((uchar *)ip, len);
1166 return;
1167 }
1168#endif
1169
1170 if ((myvlanid & VLAN_IDMASK) != VLAN_NONE) {
1171 if (vlanid == VLAN_NONE)
1172 vlanid = (mynvlanid & VLAN_IDMASK);
1173
1174 if (vlanid != (myvlanid & VLAN_IDMASK))
1175 return;
1176 }
1177
1178 switch (eth_proto) {
1179 case PROT_ARP:
1180 arp_receive(et, ip, len);
1181 break;
1182
1183#ifdef CONFIG_CMD_RARP
1184 case PROT_RARP:
1185 rarp_receive(ip, len);
1186 break;
1187#endif
1188 case PROT_IP:
1189 debug_cond(DEBUG_NET_PKT, "Got IP\n");
1190
1191 if (len < IP_UDP_HDR_SIZE) {
1192 debug("len bad %d < %lu\n", len,
1193 (ulong)IP_UDP_HDR_SIZE);
1194 return;
1195 }
1196
1197 if (len < ntohs(ip->ip_len)) {
1198 debug("len bad %d < %d\n", len, ntohs(ip->ip_len));
1199 return;
1200 }
1201 len = ntohs(ip->ip_len);
1202 debug_cond(DEBUG_NET_PKT, "len=%d, v=%02x\n",
1203 len, ip->ip_hl_v & 0xff);
1204
1205
1206 if ((ip->ip_hl_v & 0xf0) != 0x40)
1207 return;
1208
1209 if ((ip->ip_hl_v & 0x0f) > 0x05)
1210 return;
1211
1212 if (!ip_checksum_ok((uchar *)ip, IP_HDR_SIZE)) {
1213 debug("checksum bad\n");
1214 return;
1215 }
1216
1217 dst_ip = net_read_ip(&ip->ip_dst);
1218 if (net_ip.s_addr && dst_ip.s_addr != net_ip.s_addr &&
1219 dst_ip.s_addr != 0xFFFFFFFF) {
1220 return;
1221 }
1222
1223 src_ip = net_read_ip(&ip->ip_src);
1224
1225
1226
1227
1228
1229 ip = net_defragment(ip, &len);
1230 if (!ip)
1231 return;
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253 if (ip->ip_p == IPPROTO_ICMP) {
1254 receive_icmp(ip, len, src_ip, et);
1255 return;
1256 } else if (ip->ip_p != IPPROTO_UDP) {
1257 return;
1258 }
1259
1260 if (ntohs(ip->udp_len) < UDP_HDR_SIZE || ntohs(ip->udp_len) > ntohs(ip->ip_len))
1261 return;
1262
1263 debug_cond(DEBUG_DEV_PKT,
1264 "received UDP (to=%pI4, from=%pI4, len=%d)\n",
1265 &dst_ip, &src_ip, len);
1266
1267#ifdef CONFIG_UDP_CHECKSUM
1268 if (ip->udp_xsum != 0) {
1269 ulong xsum;
1270 u8 *sumptr;
1271 ushort sumlen;
1272
1273 xsum = ip->ip_p;
1274 xsum += (ntohs(ip->udp_len));
1275 xsum += (ntohl(ip->ip_src.s_addr) >> 16) & 0x0000ffff;
1276 xsum += (ntohl(ip->ip_src.s_addr) >> 0) & 0x0000ffff;
1277 xsum += (ntohl(ip->ip_dst.s_addr) >> 16) & 0x0000ffff;
1278 xsum += (ntohl(ip->ip_dst.s_addr) >> 0) & 0x0000ffff;
1279
1280 sumlen = ntohs(ip->udp_len);
1281 sumptr = (u8 *)&ip->udp_src;
1282
1283 while (sumlen > 1) {
1284
1285 xsum += (sumptr[0] << 8) + sumptr[1];
1286 sumptr += 2;
1287 sumlen -= 2;
1288 }
1289 if (sumlen > 0)
1290 xsum += (sumptr[0] << 8) + sumptr[0];
1291 while ((xsum >> 16) != 0) {
1292 xsum = (xsum & 0x0000ffff) +
1293 ((xsum >> 16) & 0x0000ffff);
1294 }
1295 if ((xsum != 0x00000000) && (xsum != 0x0000ffff)) {
1296 printf(" UDP wrong checksum %08lx %08x\n",
1297 xsum, ntohs(ip->udp_xsum));
1298 return;
1299 }
1300 }
1301#endif
1302
1303#if defined(CONFIG_NETCONSOLE) && !defined(CONFIG_SPL_BUILD)
1304 nc_input_packet((uchar *)ip + IP_UDP_HDR_SIZE,
1305 src_ip,
1306 ntohs(ip->udp_dst),
1307 ntohs(ip->udp_src),
1308 ntohs(ip->udp_len) - UDP_HDR_SIZE);
1309#endif
1310
1311
1312
1313 (*udp_packet_handler)((uchar *)ip + IP_UDP_HDR_SIZE,
1314 ntohs(ip->udp_dst),
1315 src_ip,
1316 ntohs(ip->udp_src),
1317 ntohs(ip->udp_len) - UDP_HDR_SIZE);
1318 break;
1319#ifdef CONFIG_CMD_WOL
1320 case PROT_WOL:
1321 wol_receive(ip, len);
1322 break;
1323#endif
1324 }
1325}
1326
1327
1328
1329static int net_check_prereq(enum proto_t protocol)
1330{
1331 switch (protocol) {
1332
1333#if defined(CONFIG_CMD_PING)
1334 case PING:
1335 if (net_ping_ip.s_addr == 0) {
1336 puts("*** ERROR: ping address not given\n");
1337 return 1;
1338 }
1339 goto common;
1340#endif
1341#if defined(CONFIG_CMD_DNS)
1342 case DNS:
1343 if (net_dns_server.s_addr == 0) {
1344 puts("*** ERROR: DNS server address not given\n");
1345 return 1;
1346 }
1347 goto common;
1348#endif
1349#if defined(CONFIG_PROT_UDP)
1350 case UDP:
1351 if (udp_prereq())
1352 return 1;
1353 goto common;
1354#endif
1355
1356#if defined(CONFIG_CMD_NFS)
1357 case NFS:
1358#endif
1359
1360 case TFTPGET:
1361 case TFTPPUT:
1362 if (net_server_ip.s_addr == 0 && !is_serverip_in_cmd()) {
1363 puts("*** ERROR: `serverip' not set\n");
1364 return 1;
1365 }
1366#if defined(CONFIG_CMD_PING) || \
1367 defined(CONFIG_CMD_DNS) || defined(CONFIG_PROT_UDP)
1368common:
1369#endif
1370
1371
1372 case NETCONS:
1373 case FASTBOOT:
1374 case TFTPSRV:
1375 if (net_ip.s_addr == 0) {
1376 puts("*** ERROR: `ipaddr' not set\n");
1377 return 1;
1378 }
1379
1380
1381#ifdef CONFIG_CMD_RARP
1382 case RARP:
1383#endif
1384 case BOOTP:
1385 case CDP:
1386 case DHCP:
1387 case LINKLOCAL:
1388 if (memcmp(net_ethaddr, "\0\0\0\0\0\0", 6) == 0) {
1389 int num = eth_get_dev_index();
1390
1391 switch (num) {
1392 case -1:
1393 puts("*** ERROR: No ethernet found.\n");
1394 return 1;
1395 case 0:
1396 puts("*** ERROR: `ethaddr' not set\n");
1397 break;
1398 default:
1399 printf("*** ERROR: `eth%daddr' not set\n",
1400 num);
1401 break;
1402 }
1403
1404 net_start_again();
1405 return 2;
1406 }
1407
1408 default:
1409 return 0;
1410 }
1411 return 0;
1412}
1413
1414
1415int
1416net_eth_hdr_size(void)
1417{
1418 ushort myvlanid;
1419
1420 myvlanid = ntohs(net_our_vlan);
1421 if (myvlanid == (ushort)-1)
1422 myvlanid = VLAN_NONE;
1423
1424 return ((myvlanid & VLAN_IDMASK) == VLAN_NONE) ? ETHER_HDR_SIZE :
1425 VLAN_ETHER_HDR_SIZE;
1426}
1427
1428int net_set_ether(uchar *xet, const uchar *dest_ethaddr, uint prot)
1429{
1430 struct ethernet_hdr *et = (struct ethernet_hdr *)xet;
1431 ushort myvlanid;
1432
1433 myvlanid = ntohs(net_our_vlan);
1434 if (myvlanid == (ushort)-1)
1435 myvlanid = VLAN_NONE;
1436
1437 memcpy(et->et_dest, dest_ethaddr, 6);
1438 memcpy(et->et_src, net_ethaddr, 6);
1439 if ((myvlanid & VLAN_IDMASK) == VLAN_NONE) {
1440 et->et_protlen = htons(prot);
1441 return ETHER_HDR_SIZE;
1442 } else {
1443 struct vlan_ethernet_hdr *vet =
1444 (struct vlan_ethernet_hdr *)xet;
1445
1446 vet->vet_vlan_type = htons(PROT_VLAN);
1447 vet->vet_tag = htons((0 << 5) | (myvlanid & VLAN_IDMASK));
1448 vet->vet_type = htons(prot);
1449 return VLAN_ETHER_HDR_SIZE;
1450 }
1451}
1452
1453int net_update_ether(struct ethernet_hdr *et, uchar *addr, uint prot)
1454{
1455 ushort protlen;
1456
1457 memcpy(et->et_dest, addr, 6);
1458 memcpy(et->et_src, net_ethaddr, 6);
1459 protlen = ntohs(et->et_protlen);
1460 if (protlen == PROT_VLAN) {
1461 struct vlan_ethernet_hdr *vet =
1462 (struct vlan_ethernet_hdr *)et;
1463 vet->vet_type = htons(prot);
1464 return VLAN_ETHER_HDR_SIZE;
1465 } else if (protlen > 1514) {
1466 et->et_protlen = htons(prot);
1467 return ETHER_HDR_SIZE;
1468 } else {
1469
1470 struct e802_hdr *et802 = (struct e802_hdr *)et;
1471 et802->et_prot = htons(prot);
1472 return E802_HDR_SIZE;
1473 }
1474}
1475
1476void net_set_ip_header(uchar *pkt, struct in_addr dest, struct in_addr source,
1477 u16 pkt_len, u8 proto)
1478{
1479 struct ip_udp_hdr *ip = (struct ip_udp_hdr *)pkt;
1480
1481
1482
1483
1484
1485 ip->ip_hl_v = 0x45;
1486 ip->ip_tos = 0;
1487 ip->ip_len = htons(pkt_len);
1488 ip->ip_p = proto;
1489 ip->ip_id = htons(net_ip_id++);
1490 ip->ip_off = htons(IP_FLAGS_DFRAG);
1491 ip->ip_ttl = 255;
1492 ip->ip_sum = 0;
1493
1494 net_copy_ip((void *)&ip->ip_src, &source);
1495
1496 net_copy_ip((void *)&ip->ip_dst, &dest);
1497
1498 ip->ip_sum = compute_ip_checksum(ip, IP_HDR_SIZE);
1499}
1500
1501void net_set_udp_header(uchar *pkt, struct in_addr dest, int dport, int sport,
1502 int len)
1503{
1504 struct ip_udp_hdr *ip = (struct ip_udp_hdr *)pkt;
1505
1506
1507
1508
1509
1510
1511 if (len & 1)
1512 pkt[IP_UDP_HDR_SIZE + len] = 0;
1513
1514 net_set_ip_header(pkt, dest, net_ip, IP_UDP_HDR_SIZE + len,
1515 IPPROTO_UDP);
1516
1517 ip->udp_src = htons(sport);
1518 ip->udp_dst = htons(dport);
1519 ip->udp_len = htons(UDP_HDR_SIZE + len);
1520 ip->udp_xsum = 0;
1521}
1522
1523void copy_filename(char *dst, const char *src, int size)
1524{
1525 if (src && *src && (*src == '"')) {
1526 ++src;
1527 --size;
1528 }
1529
1530 while ((--size > 0) && src && *src && (*src != '"'))
1531 *dst++ = *src++;
1532 *dst = '\0';
1533}
1534
1535int is_serverip_in_cmd(void)
1536{
1537 return !!strchr(net_boot_file_name, ':');
1538}
1539
1540int net_parse_bootfile(struct in_addr *ipaddr, char *filename, int max_len)
1541{
1542 char *colon;
1543
1544 if (net_boot_file_name[0] == '\0')
1545 return 0;
1546
1547 colon = strchr(net_boot_file_name, ':');
1548 if (colon) {
1549 if (ipaddr)
1550 *ipaddr = string_to_ip(net_boot_file_name);
1551 strncpy(filename, colon + 1, max_len);
1552 } else {
1553 strncpy(filename, net_boot_file_name, max_len);
1554 }
1555 filename[max_len - 1] = '\0';
1556
1557 return 1;
1558}
1559
1560void ip_to_string(struct in_addr x, char *s)
1561{
1562 x.s_addr = ntohl(x.s_addr);
1563 sprintf(s, "%d.%d.%d.%d",
1564 (int) ((x.s_addr >> 24) & 0xff),
1565 (int) ((x.s_addr >> 16) & 0xff),
1566 (int) ((x.s_addr >> 8) & 0xff),
1567 (int) ((x.s_addr >> 0) & 0xff)
1568 );
1569}
1570
1571void vlan_to_string(ushort x, char *s)
1572{
1573 x = ntohs(x);
1574
1575 if (x == (ushort)-1)
1576 x = VLAN_NONE;
1577
1578 if (x == VLAN_NONE)
1579 strcpy(s, "none");
1580 else
1581 sprintf(s, "%d", x & VLAN_IDMASK);
1582}
1583
1584ushort string_to_vlan(const char *s)
1585{
1586 ushort id;
1587
1588 if (s == NULL)
1589 return htons(VLAN_NONE);
1590
1591 if (*s < '0' || *s > '9')
1592 id = VLAN_NONE;
1593 else
1594 id = (ushort)dectoul(s, NULL);
1595
1596 return htons(id);
1597}
1598
1599ushort env_get_vlan(char *var)
1600{
1601 return string_to_vlan(env_get(var));
1602}
1603