2 * Copied from Linux Monitor (LiMon) - Networking.
4 * Copyright 1994 - 2000 Neil Russell.
6 * Copyright 2000 Roland Borde
7 * Copyright 2000 Paolo Scaffardi
8 * Copyright 2000-2002 Wolfgang Denk, wd@denx.de
14 * The user interface supports commands for BOOTP, RARP, and TFTP.
15 * Also, we support ARP internally. Depending on available data,
16 * these interact as follows:
20 * Prerequisites: - own ethernet address
21 * We want: - own IP address
22 * - TFTP server IP address
28 * Prerequisites: - own ethernet address
29 * We want: - own IP address
34 * Prerequisites: - own ethernet address
35 * We want: - own IP address
36 * - TFTP server IP address
41 * Prerequisites: - own ethernet address
43 * - TFTP server IP address
44 * We want: - TFTP server ethernet address
49 * Prerequisites: - own ethernet address
50 * We want: - IP, Netmask, ServerIP, Gateway IP
51 * - bootfilename, lease time
56 * Prerequisites: - own ethernet address
58 * - TFTP server IP address
59 * - TFTP server ethernet address
60 * - name of bootfile (if unknown, we use a default name
61 * derived from our own IP address)
62 * We want: - load the boot file
67 * Prerequisites: - own ethernet address
69 * - name of bootfile (if unknown, we use a default name
70 * derived from our own IP address)
71 * We want: - load the boot file
76 * Prerequisites: - own ethernet address
78 * We want: - network time
86 #if defined(CONFIG_STATUS_LED)
88 #include <status_led.h>
91 #include <linux/compiler.h>
95 #if defined(CONFIG_CMD_DNS)
98 #include "link_local.h"
102 #if defined(CONFIG_CMD_SNTP)
107 DECLARE_GLOBAL_DATA_PTR
;
109 /** BOOTP EXTENTIONS **/
111 /* Our subnet mask (0=unknown) */
112 IPaddr_t NetOurSubnetMask
;
113 /* Our gateways IP address */
114 IPaddr_t NetOurGatewayIP
;
115 /* Our DNS IP address */
116 IPaddr_t NetOurDNSIP
;
117 #if defined(CONFIG_BOOTP_DNS2)
118 /* Our 2nd DNS IP address */
119 IPaddr_t NetOurDNS2IP
;
122 char NetOurNISDomain
[32] = {0,};
124 char NetOurHostName
[32] = {0,};
126 char NetOurRootPath
[64] = {0,};
127 /* Our bootfile size in blocks */
128 ushort NetBootFileSize
;
130 #ifdef CONFIG_MCAST_TFTP /* Multicast TFTP */
134 /** END OF BOOTP EXTENTIONS **/
136 /* The actual transferred size of the bootfile (in bytes) */
137 ulong NetBootFileXferSize
;
138 /* Our ethernet address */
139 uchar NetOurEther
[6];
140 /* Boot server enet address */
141 uchar NetServerEther
[6];
142 /* Our IP addr (0 = unknown) */
144 /* Server IP addr (0 = unknown) */
145 IPaddr_t NetServerIP
;
146 /* Current receive packet */
148 /* Current rx packet length */
152 /* Ethernet bcast address */
153 uchar NetBcastAddr
[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
154 uchar NetEtherNullAddr
[6];
156 void (*push_packet
)(void *, int len
) = 0;
158 /* Network loop state */
159 enum net_loop_state net_state
;
160 /* Tried all network devices */
162 /* Network loop restarted */
163 static int NetRestarted
;
164 /* At least one device configured */
165 static int NetDevExists
;
167 /* XXX in both little & big endian machines 0xFFFF == ntohs(-1) */
168 /* default is without VLAN */
169 ushort NetOurVLAN
= 0xFFFF;
171 ushort NetOurNativeVLAN
= 0xFFFF;
176 #if defined(CONFIG_CMD_SNTP)
177 /* NTP server IP address */
178 IPaddr_t NetNtpServerIP
;
179 /* offset time from UTC */
183 uchar PktBuf
[(PKTBUFSRX
+1) * PKTSIZE_ALIGN
+ PKTALIGN
];
186 uchar
*NetRxPackets
[PKTBUFSRX
];
188 /* Current UDP RX packet handler */
189 static rxhand_f
*udp_packet_handler
;
190 /* Current ARP RX packet handler */
191 static rxhand_f
*arp_packet_handler
;
192 #ifdef CONFIG_CMD_TFTPPUT
193 /* Current ICMP rx handler */
194 static rxhand_icmp_f
*packet_icmp_handler
;
196 /* Current timeout handler */
197 static thand_f
*timeHandler
;
198 /* Time base value */
199 static ulong timeStart
;
200 /* Current timeout value */
201 static ulong timeDelta
;
202 /* THE transmit packet */
205 static int net_check_prereq(enum proto_t protocol
);
207 static int NetTryCount
;
209 /**********************************************************************/
212 * Check if autoload is enabled. If so, use either NFS or TFTP to download
215 void net_auto_load(void)
217 const char *s
= getenv("autoload");
222 * Just use BOOTP/RARP to configure system;
223 * Do not use TFTP to load the bootfile.
225 net_set_state(NETLOOP_SUCCESS
);
228 #if defined(CONFIG_CMD_NFS)
229 if (strcmp(s
, "NFS") == 0) {
231 * Use NFS to load the bootfile.
241 static void NetInitLoop(void)
243 static int env_changed_id
;
244 int env_id
= get_env_id();
246 /* update only when the environment has changed */
247 if (env_changed_id
!= env_id
) {
248 NetOurIP
= getenv_IPaddr("ipaddr");
249 NetOurGatewayIP
= getenv_IPaddr("gatewayip");
250 NetOurSubnetMask
= getenv_IPaddr("netmask");
251 NetServerIP
= getenv_IPaddr("serverip");
252 NetOurNativeVLAN
= getenv_VLAN("nvlan");
253 NetOurVLAN
= getenv_VLAN("vlan");
254 #if defined(CONFIG_CMD_DNS)
255 NetOurDNSIP
= getenv_IPaddr("dnsip");
257 env_changed_id
= env_id
;
263 static void net_clear_handlers(void)
265 net_set_udp_handler(NULL
);
266 net_set_arp_handler(NULL
);
267 NetSetTimeout(0, NULL
);
270 static void net_cleanup_loop(void)
272 net_clear_handlers();
277 static int first_call
= 1;
281 * Setup packet buffers, aligned correctly.
285 NetTxPacket
= &PktBuf
[0] + (PKTALIGN
- 1);
286 NetTxPacket
-= (ulong
)NetTxPacket
% PKTALIGN
;
287 for (i
= 0; i
< PKTBUFSRX
; i
++)
288 NetRxPackets
[i
] = NetTxPacket
+ (i
+ 1) * PKTSIZE_ALIGN
;
291 net_clear_handlers();
293 /* Only need to setup buffer pointers once. */
300 /**********************************************************************/
302 * Main network processing loop.
305 int NetLoop(enum proto_t protocol
)
313 debug_cond(DEBUG_INT_STATE
, "--- NetLoop Entry\n");
315 bootstage_mark_name(BOOTSTAGE_ID_ETH_START
, "eth_start");
319 if (eth_init(bd
) < 0) {
325 memcpy(NetOurEther
, eth_get_dev()->enetaddr
, 6);
327 net_set_state(NETLOOP_CONTINUE
);
330 * Start the ball rolling with the given start function. From
331 * here on, this code is a state machine driven by received
332 * packets and timer events.
334 debug_cond(DEBUG_INT_STATE
, "--- NetLoop Init\n");
337 switch (net_check_prereq(protocol
)) {
339 /* network not configured */
344 /* network device not configured */
349 NetBootFileXferSize
= 0;
352 #ifdef CONFIG_CMD_TFTPPUT
355 /* always use ARP to get server ethernet address */
358 #ifdef CONFIG_CMD_TFTPSRV
363 #if defined(CONFIG_CMD_DHCP)
367 DhcpRequest(); /* Basically same as BOOTP */
377 #if defined(CONFIG_CMD_RARP)
384 #if defined(CONFIG_CMD_PING)
389 #if defined(CONFIG_CMD_NFS)
394 #if defined(CONFIG_CMD_CDP)
399 #ifdef CONFIG_NETCONSOLE
404 #if defined(CONFIG_CMD_SNTP)
409 #if defined(CONFIG_CMD_DNS)
414 #if defined(CONFIG_CMD_LINK_LOCAL)
426 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
427 #if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \
428 defined(CONFIG_STATUS_LED) && \
429 defined(STATUS_LED_RED)
431 * Echo the inverted link state to the fault LED.
433 if (miiphy_link(eth_get_dev()->name
, CONFIG_SYS_FAULT_MII_ADDR
))
434 status_led_set(STATUS_LED_RED
, STATUS_LED_OFF
);
436 status_led_set(STATUS_LED_RED
, STATUS_LED_ON
);
437 #endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */
438 #endif /* CONFIG_MII, ... */
441 * Main packet reception loop. Loop receiving packets until
442 * someone sets `net_state' to a state that terminates.
446 #ifdef CONFIG_SHOW_ACTIVITY
450 * Check the ethernet for a new packet. The ethernet
451 * receive routine will process it.
456 * Abort if ctrl-c was pressed.
459 /* cancel any ARP that may not have completed */
460 NetArpWaitPacketIP
= 0;
465 /* include a debug print as well incase the debug
466 messages are directed to stderr */
467 debug_cond(DEBUG_INT_STATE
, "--- NetLoop Abort!\n");
474 * Check for a timeout, and run the timeout handler
477 if (timeHandler
&& ((get_timer(0) - timeStart
) > timeDelta
)) {
480 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
481 #if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \
482 defined(CONFIG_STATUS_LED) && \
483 defined(STATUS_LED_RED)
485 * Echo the inverted link state to the fault LED.
487 if (miiphy_link(eth_get_dev()->name
,
488 CONFIG_SYS_FAULT_MII_ADDR
)) {
489 status_led_set(STATUS_LED_RED
, STATUS_LED_OFF
);
491 status_led_set(STATUS_LED_RED
, STATUS_LED_ON
);
493 #endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */
494 #endif /* CONFIG_MII, ... */
495 debug_cond(DEBUG_INT_STATE
, "--- NetLoop timeout\n");
497 timeHandler
= (thand_f
*)0;
504 case NETLOOP_RESTART
:
508 case NETLOOP_SUCCESS
:
510 if (NetBootFileXferSize
> 0) {
512 printf("Bytes transferred = %ld (%lx hex)\n",
514 NetBootFileXferSize
);
515 sprintf(buf
, "%lX", NetBootFileXferSize
);
516 setenv("filesize", buf
);
518 sprintf(buf
, "%lX", (unsigned long)load_addr
);
519 setenv("fileaddr", buf
);
522 ret
= NetBootFileXferSize
;
523 debug_cond(DEBUG_INT_STATE
, "--- NetLoop Success!\n");
528 debug_cond(DEBUG_INT_STATE
, "--- NetLoop Fail!\n");
531 case NETLOOP_CONTINUE
:
537 #ifdef CONFIG_CMD_TFTPPUT
538 /* Clear out the handlers */
539 net_set_udp_handler(NULL
);
540 net_set_icmp_handler(NULL
);
545 /**********************************************************************/
548 startAgainTimeout(void)
550 net_set_state(NETLOOP_RESTART
);
553 void NetStartAgain(void)
556 int retry_forever
= 0;
557 unsigned long retrycnt
= 0;
559 nretry
= getenv("netretry");
561 if (!strcmp(nretry
, "yes"))
563 else if (!strcmp(nretry
, "no"))
565 else if (!strcmp(nretry
, "once"))
568 retrycnt
= simple_strtoul(nretry
, NULL
, 0);
572 if ((!retry_forever
) && (NetTryCount
>= retrycnt
)) {
574 net_set_state(NETLOOP_FAIL
);
581 #if !defined(CONFIG_NET_DO_NOT_TRY_ANOTHER)
582 eth_try_another(!NetRestarted
);
585 if (NetRestartWrap
) {
588 NetSetTimeout(10000UL, startAgainTimeout
);
589 net_set_udp_handler(NULL
);
591 net_set_state(NETLOOP_FAIL
);
594 net_set_state(NETLOOP_RESTART
);
598 /**********************************************************************/
603 static void dummy_handler(uchar
*pkt
, unsigned dport
,
604 IPaddr_t sip
, unsigned sport
,
609 rxhand_f
*net_get_udp_handler(void)
611 return udp_packet_handler
;
614 void net_set_udp_handler(rxhand_f
*f
)
616 debug_cond(DEBUG_INT_STATE
, "--- NetLoop UDP handler set (%p)\n", f
);
618 udp_packet_handler
= dummy_handler
;
620 udp_packet_handler
= f
;
623 rxhand_f
*net_get_arp_handler(void)
625 return arp_packet_handler
;
628 void net_set_arp_handler(rxhand_f
*f
)
630 debug_cond(DEBUG_INT_STATE
, "--- NetLoop ARP handler set (%p)\n", f
);
632 arp_packet_handler
= dummy_handler
;
634 arp_packet_handler
= f
;
637 #ifdef CONFIG_CMD_TFTPPUT
638 void net_set_icmp_handler(rxhand_icmp_f
*f
)
640 packet_icmp_handler
= f
;
645 NetSetTimeout(ulong iv
, thand_f
*f
)
648 debug_cond(DEBUG_INT_STATE
,
649 "--- NetLoop timeout handler cancelled\n");
650 timeHandler
= (thand_f
*)0;
652 debug_cond(DEBUG_INT_STATE
,
653 "--- NetLoop timeout handler set (%p)\n", f
);
655 timeStart
= get_timer(0);
660 int NetSendUDPPacket(uchar
*ether
, IPaddr_t dest
, int dport
, int sport
,
667 /* make sure the NetTxPacket is initialized (NetInit() was called) */
668 assert(NetTxPacket
!= NULL
);
669 if (NetTxPacket
== NULL
)
672 /* convert to new style broadcast */
676 /* if broadcast, make the ether address a broadcast and don't do ARP */
677 if (dest
== 0xFFFFFFFF)
678 ether
= NetBcastAddr
;
680 pkt
= (uchar
*)NetTxPacket
;
682 eth_hdr_size
= NetSetEther(pkt
, ether
, PROT_IP
);
684 net_set_udp_header(pkt
, dest
, dport
, sport
, payload_len
);
685 pkt_hdr_size
= eth_hdr_size
+ IP_UDP_HDR_SIZE
;
687 /* if MAC address was not discovered yet, do an ARP request */
688 if (memcmp(ether
, NetEtherNullAddr
, 6) == 0) {
689 debug_cond(DEBUG_DEV_PKT
, "sending ARP for %pI4\n", &dest
);
691 /* save the ip and eth addr for the packet to send after arp */
692 NetArpWaitPacketIP
= dest
;
693 NetArpWaitPacketMAC
= ether
;
695 /* size of the waiting packet */
696 NetArpWaitTxPacketSize
= pkt_hdr_size
+ payload_len
;
698 /* and do the ARP request */
700 NetArpWaitTimerStart
= get_timer(0);
702 return 1; /* waiting */
704 debug_cond(DEBUG_DEV_PKT
, "sending UDP to %pI4/%pM\n",
706 NetSendPacket(NetTxPacket
, pkt_hdr_size
+ payload_len
);
707 return 0; /* transmitted */
711 #ifdef CONFIG_IP_DEFRAG
713 * This function collects fragments in a single packet, according
714 * to the algorithm in RFC815. It returns NULL or the pointer to
715 * a complete packet, in static storage
717 #ifndef CONFIG_NET_MAXDEFRAG
718 #define CONFIG_NET_MAXDEFRAG 16384
721 * MAXDEFRAG, above, is chosen in the config file and is real data
722 * so we need to add the NFS overhead, which is more than TFTP.
723 * To use sizeof in the internal unnamed structures, we need a real
724 * instance (can't do "sizeof(struct rpc_t.u.reply))", unfortunately).
725 * The compiler doesn't complain nor allocates the actual structure
727 static struct rpc_t rpc_specimen
;
728 #define IP_PKTSIZE (CONFIG_NET_MAXDEFRAG + sizeof(rpc_specimen.u.reply))
730 #define IP_MAXUDP (IP_PKTSIZE - IP_HDR_SIZE)
733 * this is the packet being assembled, either data or frag control.
734 * Fragments go by 8 bytes, so this union must be 8 bytes long
737 /* first_byte is address of this structure */
738 u16 last_byte
; /* last byte in this hole + 1 (begin of next hole) */
739 u16 next_hole
; /* index of next (in 8-b blocks), 0 == none */
740 u16 prev_hole
; /* index of prev, 0 == none */
744 static struct ip_udp_hdr
*__NetDefragment(struct ip_udp_hdr
*ip
, int *lenp
)
746 static uchar pkt_buff
[IP_PKTSIZE
] __aligned(PKTALIGN
);
747 static u16 first_hole
, total_len
;
748 struct hole
*payload
, *thisfrag
, *h
, *newh
;
749 struct ip_udp_hdr
*localip
= (struct ip_udp_hdr
*)pkt_buff
;
750 uchar
*indata
= (uchar
*)ip
;
751 int offset8
, start
, len
, done
= 0;
752 u16 ip_off
= ntohs(ip
->ip_off
);
754 /* payload starts after IP header, this fragment is in there */
755 payload
= (struct hole
*)(pkt_buff
+ IP_HDR_SIZE
);
756 offset8
= (ip_off
& IP_OFFS
);
757 thisfrag
= payload
+ offset8
;
759 len
= ntohs(ip
->ip_len
) - IP_HDR_SIZE
;
761 if (start
+ len
> IP_MAXUDP
) /* fragment extends too far */
764 if (!total_len
|| localip
->ip_id
!= ip
->ip_id
) {
765 /* new (or different) packet, reset structs */
767 payload
[0].last_byte
= ~0;
768 payload
[0].next_hole
= 0;
769 payload
[0].prev_hole
= 0;
771 /* any IP header will work, copy the first we received */
772 memcpy(localip
, ip
, IP_HDR_SIZE
);
776 * What follows is the reassembly algorithm. We use the payload
777 * array as a linked list of hole descriptors, as each hole starts
778 * at a multiple of 8 bytes. However, last byte can be whatever value,
779 * so it is represented as byte count, not as 8-byte blocks.
782 h
= payload
+ first_hole
;
783 while (h
->last_byte
< start
) {
785 /* no hole that far away */
788 h
= payload
+ h
->next_hole
;
791 /* last fragment may be 1..7 bytes, the "+7" forces acceptance */
792 if (offset8
+ ((len
+ 7) / 8) <= h
- payload
) {
793 /* no overlap with holes (dup fragment?) */
797 if (!(ip_off
& IP_FLAGS_MFRAG
)) {
798 /* no more fragmentss: truncate this (last) hole */
799 total_len
= start
+ len
;
800 h
->last_byte
= start
+ len
;
804 * There is some overlap: fix the hole list. This code doesn't
805 * deal with a fragment that overlaps with two different holes
806 * (thus being a superset of a previously-received fragment).
809 if ((h
>= thisfrag
) && (h
->last_byte
<= start
+ len
)) {
810 /* complete overlap with hole: remove hole */
811 if (!h
->prev_hole
&& !h
->next_hole
) {
812 /* last remaining hole */
814 } else if (!h
->prev_hole
) {
816 first_hole
= h
->next_hole
;
817 payload
[h
->next_hole
].prev_hole
= 0;
818 } else if (!h
->next_hole
) {
820 payload
[h
->prev_hole
].next_hole
= 0;
822 /* in the middle of the list */
823 payload
[h
->next_hole
].prev_hole
= h
->prev_hole
;
824 payload
[h
->prev_hole
].next_hole
= h
->next_hole
;
827 } else if (h
->last_byte
<= start
+ len
) {
828 /* overlaps with final part of the hole: shorten this hole */
829 h
->last_byte
= start
;
831 } else if (h
>= thisfrag
) {
832 /* overlaps with initial part of the hole: move this hole */
833 newh
= thisfrag
+ (len
/ 8);
837 payload
[h
->next_hole
].prev_hole
= (h
- payload
);
839 payload
[h
->prev_hole
].next_hole
= (h
- payload
);
841 first_hole
= (h
- payload
);
844 /* fragment sits in the middle: split the hole */
845 newh
= thisfrag
+ (len
/ 8);
847 h
->last_byte
= start
;
848 h
->next_hole
= (newh
- payload
);
849 newh
->prev_hole
= (h
- payload
);
851 payload
[newh
->next_hole
].prev_hole
= (newh
- payload
);
854 /* finally copy this fragment and possibly return whole packet */
855 memcpy((uchar
*)thisfrag
, indata
+ IP_HDR_SIZE
, len
);
859 localip
->ip_len
= htons(total_len
);
860 *lenp
= total_len
+ IP_HDR_SIZE
;
864 static inline struct ip_udp_hdr
*NetDefragment(struct ip_udp_hdr
*ip
, int *lenp
)
866 u16 ip_off
= ntohs(ip
->ip_off
);
867 if (!(ip_off
& (IP_OFFS
| IP_FLAGS_MFRAG
)))
868 return ip
; /* not a fragment */
869 return __NetDefragment(ip
, lenp
);
872 #else /* !CONFIG_IP_DEFRAG */
874 static inline struct ip_udp_hdr
*NetDefragment(struct ip_udp_hdr
*ip
, int *lenp
)
876 u16 ip_off
= ntohs(ip
->ip_off
);
877 if (!(ip_off
& (IP_OFFS
| IP_FLAGS_MFRAG
)))
878 return ip
; /* not a fragment */
884 * Receive an ICMP packet. We deal with REDIRECT and PING here, and silently
887 * @parma ip IP packet containing the ICMP
889 static void receive_icmp(struct ip_udp_hdr
*ip
, int len
,
890 IPaddr_t src_ip
, struct ethernet_hdr
*et
)
892 struct icmp_hdr
*icmph
= (struct icmp_hdr
*)&ip
->udp_src
;
894 switch (icmph
->type
) {
896 if (icmph
->code
!= ICMP_REDIR_HOST
)
898 printf(" ICMP Host Redirect to %pI4 ",
902 #if defined(CONFIG_CMD_PING)
903 ping_receive(et
, ip
, len
);
905 #ifdef CONFIG_CMD_TFTPPUT
906 if (packet_icmp_handler
)
907 packet_icmp_handler(icmph
->type
, icmph
->code
,
908 ntohs(ip
->udp_dst
), src_ip
, ntohs(ip
->udp_src
),
909 icmph
->un
.data
, ntohs(ip
->udp_len
));
916 NetReceive(uchar
*inpkt
, int len
)
918 struct ethernet_hdr
*et
;
919 struct ip_udp_hdr
*ip
;
923 #if defined(CONFIG_CMD_CDP)
926 ushort cti
= 0, vlanid
= VLAN_NONE
, myvlanid
, mynvlanid
;
928 debug_cond(DEBUG_NET_PKT
, "packet received\n");
931 NetRxPacketLen
= len
;
932 et
= (struct ethernet_hdr
*)inpkt
;
934 /* too small packet? */
935 if (len
< ETHER_HDR_SIZE
)
940 (*push_packet
)(inpkt
, len
);
945 #if defined(CONFIG_CMD_CDP)
946 /* keep track if packet is CDP */
947 iscdp
= is_cdp_packet(et
->et_dest
);
950 myvlanid
= ntohs(NetOurVLAN
);
951 if (myvlanid
== (ushort
)-1)
952 myvlanid
= VLAN_NONE
;
953 mynvlanid
= ntohs(NetOurNativeVLAN
);
954 if (mynvlanid
== (ushort
)-1)
955 mynvlanid
= VLAN_NONE
;
957 eth_proto
= ntohs(et
->et_protlen
);
959 if (eth_proto
< 1514) {
960 struct e802_hdr
*et802
= (struct e802_hdr
*)et
;
962 * Got a 802.2 packet. Check the other protocol field.
963 * XXX VLAN over 802.2+SNAP not implemented!
965 eth_proto
= ntohs(et802
->et_prot
);
967 ip
= (struct ip_udp_hdr
*)(inpkt
+ E802_HDR_SIZE
);
968 len
-= E802_HDR_SIZE
;
970 } else if (eth_proto
!= PROT_VLAN
) { /* normal packet */
971 ip
= (struct ip_udp_hdr
*)(inpkt
+ ETHER_HDR_SIZE
);
972 len
-= ETHER_HDR_SIZE
;
974 } else { /* VLAN packet */
975 struct vlan_ethernet_hdr
*vet
=
976 (struct vlan_ethernet_hdr
*)et
;
978 debug_cond(DEBUG_NET_PKT
, "VLAN packet received\n");
980 /* too small packet? */
981 if (len
< VLAN_ETHER_HDR_SIZE
)
984 /* if no VLAN active */
985 if ((ntohs(NetOurVLAN
) & VLAN_IDMASK
) == VLAN_NONE
986 #if defined(CONFIG_CMD_CDP)
992 cti
= ntohs(vet
->vet_tag
);
993 vlanid
= cti
& VLAN_IDMASK
;
994 eth_proto
= ntohs(vet
->vet_type
);
996 ip
= (struct ip_udp_hdr
*)(inpkt
+ VLAN_ETHER_HDR_SIZE
);
997 len
-= VLAN_ETHER_HDR_SIZE
;
1000 debug_cond(DEBUG_NET_PKT
, "Receive from protocol 0x%x\n", eth_proto
);
1002 #if defined(CONFIG_CMD_CDP)
1004 cdp_receive((uchar
*)ip
, len
);
1009 if ((myvlanid
& VLAN_IDMASK
) != VLAN_NONE
) {
1010 if (vlanid
== VLAN_NONE
)
1011 vlanid
= (mynvlanid
& VLAN_IDMASK
);
1013 if (vlanid
!= (myvlanid
& VLAN_IDMASK
))
1017 switch (eth_proto
) {
1020 ArpReceive(et
, ip
, len
);
1023 #ifdef CONFIG_CMD_RARP
1025 rarp_receive(ip
, len
);
1029 debug_cond(DEBUG_NET_PKT
, "Got IP\n");
1030 /* Before we start poking the header, make sure it is there */
1031 if (len
< IP_UDP_HDR_SIZE
) {
1032 debug("len bad %d < %lu\n", len
,
1033 (ulong
)IP_UDP_HDR_SIZE
);
1036 /* Check the packet length */
1037 if (len
< ntohs(ip
->ip_len
)) {
1038 debug("len bad %d < %d\n", len
, ntohs(ip
->ip_len
));
1041 len
= ntohs(ip
->ip_len
);
1042 debug_cond(DEBUG_NET_PKT
, "len=%d, v=%02x\n",
1043 len
, ip
->ip_hl_v
& 0xff);
1045 /* Can't deal with anything except IPv4 */
1046 if ((ip
->ip_hl_v
& 0xf0) != 0x40)
1048 /* Can't deal with IP options (headers != 20 bytes) */
1049 if ((ip
->ip_hl_v
& 0x0f) > 0x05)
1051 /* Check the Checksum of the header */
1052 if (!NetCksumOk((uchar
*)ip
, IP_HDR_SIZE
/ 2)) {
1053 debug("checksum bad\n");
1056 /* If it is not for us, ignore it */
1057 dst_ip
= NetReadIP(&ip
->ip_dst
);
1058 if (NetOurIP
&& dst_ip
!= NetOurIP
&& dst_ip
!= 0xFFFFFFFF) {
1059 #ifdef CONFIG_MCAST_TFTP
1060 if (Mcast_addr
!= dst_ip
)
1064 /* Read source IP address for later use */
1065 src_ip
= NetReadIP(&ip
->ip_src
);
1067 * The function returns the unchanged packet if it's not
1068 * a fragment, and either the complete packet or NULL if
1069 * it is a fragment (if !CONFIG_IP_DEFRAG, it returns NULL)
1071 ip
= NetDefragment(ip
, &len
);
1075 * watch for ICMP host redirects
1077 * There is no real handler code (yet). We just watch
1078 * for ICMP host redirect messages. In case anybody
1079 * sees these messages: please contact me
1080 * (wd@denx.de), or - even better - send me the
1081 * necessary fixes :-)
1083 * Note: in all cases where I have seen this so far
1084 * it was a problem with the router configuration,
1085 * for instance when a router was configured in the
1086 * BOOTP reply, but the TFTP server was on the same
1087 * subnet. So this is probably a warning that your
1088 * configuration might be wrong. But I'm not really
1089 * sure if there aren't any other situations.
1091 * Simon Glass <sjg@chromium.org>: We get an ICMP when
1092 * we send a tftp packet to a dead connection, or when
1093 * there is no server at the other end.
1095 if (ip
->ip_p
== IPPROTO_ICMP
) {
1096 receive_icmp(ip
, len
, src_ip
, et
);
1098 } else if (ip
->ip_p
!= IPPROTO_UDP
) { /* Only UDP packets */
1102 debug_cond(DEBUG_DEV_PKT
,
1103 "received UDP (to=%pI4, from=%pI4, len=%d)\n",
1104 &dst_ip
, &src_ip
, len
);
1106 #ifdef CONFIG_UDP_CHECKSUM
1107 if (ip
->udp_xsum
!= 0) {
1113 xsum
+= (ntohs(ip
->udp_len
));
1114 xsum
+= (ntohl(ip
->ip_src
) >> 16) & 0x0000ffff;
1115 xsum
+= (ntohl(ip
->ip_src
) >> 0) & 0x0000ffff;
1116 xsum
+= (ntohl(ip
->ip_dst
) >> 16) & 0x0000ffff;
1117 xsum
+= (ntohl(ip
->ip_dst
) >> 0) & 0x0000ffff;
1119 sumlen
= ntohs(ip
->udp_len
);
1120 sumptr
= (ushort
*) &(ip
->udp_src
);
1122 while (sumlen
> 1) {
1125 sumdata
= *sumptr
++;
1126 xsum
+= ntohs(sumdata
);
1132 sumdata
= *(unsigned char *) sumptr
;
1133 sumdata
= (sumdata
<< 8) & 0xff00;
1136 while ((xsum
>> 16) != 0) {
1137 xsum
= (xsum
& 0x0000ffff) +
1138 ((xsum
>> 16) & 0x0000ffff);
1140 if ((xsum
!= 0x00000000) && (xsum
!= 0x0000ffff)) {
1141 printf(" UDP wrong checksum %08lx %08x\n",
1142 xsum
, ntohs(ip
->udp_xsum
));
1149 #ifdef CONFIG_NETCONSOLE
1150 nc_input_packet((uchar
*)ip
+ IP_UDP_HDR_SIZE
,
1153 ntohs(ip
->udp_len
) - UDP_HDR_SIZE
);
1156 * IP header OK. Pass the packet to the current handler.
1158 (*udp_packet_handler
)((uchar
*)ip
+ IP_UDP_HDR_SIZE
,
1162 ntohs(ip
->udp_len
) - UDP_HDR_SIZE
);
1168 /**********************************************************************/
1170 static int net_check_prereq(enum proto_t protocol
)
1174 #if defined(CONFIG_CMD_PING)
1176 if (NetPingIP
== 0) {
1177 puts("*** ERROR: ping address not given\n");
1182 #if defined(CONFIG_CMD_SNTP)
1184 if (NetNtpServerIP
== 0) {
1185 puts("*** ERROR: NTP server address not given\n");
1190 #if defined(CONFIG_CMD_DNS)
1192 if (NetOurDNSIP
== 0) {
1193 puts("*** ERROR: DNS server address not given\n");
1198 #if defined(CONFIG_CMD_NFS)
1203 if (NetServerIP
== 0) {
1204 puts("*** ERROR: `serverip' not set\n");
1207 #if defined(CONFIG_CMD_PING) || defined(CONFIG_CMD_SNTP) || \
1208 defined(CONFIG_CMD_DNS)
1215 if (NetOurIP
== 0) {
1216 puts("*** ERROR: `ipaddr' not set\n");
1221 #ifdef CONFIG_CMD_RARP
1228 if (memcmp(NetOurEther
, "\0\0\0\0\0\0", 6) == 0) {
1229 int num
= eth_get_dev_index();
1233 puts("*** ERROR: No ethernet found.\n");
1236 puts("*** ERROR: `ethaddr' not set\n");
1239 printf("*** ERROR: `eth%daddr' not set\n",
1253 /**********************************************************************/
1256 NetCksumOk(uchar
*ptr
, int len
)
1258 return !((NetCksum(ptr
, len
) + 1) & 0xfffe);
1263 NetCksum(uchar
*ptr
, int len
)
1266 ushort
*p
= (ushort
*)ptr
;
1271 xsum
= (xsum
& 0xffff) + (xsum
>> 16);
1272 xsum
= (xsum
& 0xffff) + (xsum
>> 16);
1273 return xsum
& 0xffff;
1281 myvlanid
= ntohs(NetOurVLAN
);
1282 if (myvlanid
== (ushort
)-1)
1283 myvlanid
= VLAN_NONE
;
1285 return ((myvlanid
& VLAN_IDMASK
) == VLAN_NONE
) ? ETHER_HDR_SIZE
:
1286 VLAN_ETHER_HDR_SIZE
;
1290 NetSetEther(uchar
*xet
, uchar
* addr
, uint prot
)
1292 struct ethernet_hdr
*et
= (struct ethernet_hdr
*)xet
;
1295 myvlanid
= ntohs(NetOurVLAN
);
1296 if (myvlanid
== (ushort
)-1)
1297 myvlanid
= VLAN_NONE
;
1299 memcpy(et
->et_dest
, addr
, 6);
1300 memcpy(et
->et_src
, NetOurEther
, 6);
1301 if ((myvlanid
& VLAN_IDMASK
) == VLAN_NONE
) {
1302 et
->et_protlen
= htons(prot
);
1303 return ETHER_HDR_SIZE
;
1305 struct vlan_ethernet_hdr
*vet
=
1306 (struct vlan_ethernet_hdr
*)xet
;
1308 vet
->vet_vlan_type
= htons(PROT_VLAN
);
1309 vet
->vet_tag
= htons((0 << 5) | (myvlanid
& VLAN_IDMASK
));
1310 vet
->vet_type
= htons(prot
);
1311 return VLAN_ETHER_HDR_SIZE
;
1315 int net_update_ether(struct ethernet_hdr
*et
, uchar
*addr
, uint prot
)
1319 memcpy(et
->et_dest
, addr
, 6);
1320 memcpy(et
->et_src
, NetOurEther
, 6);
1321 protlen
= ntohs(et
->et_protlen
);
1322 if (protlen
== PROT_VLAN
) {
1323 struct vlan_ethernet_hdr
*vet
=
1324 (struct vlan_ethernet_hdr
*)et
;
1325 vet
->vet_type
= htons(prot
);
1326 return VLAN_ETHER_HDR_SIZE
;
1327 } else if (protlen
> 1514) {
1328 et
->et_protlen
= htons(prot
);
1329 return ETHER_HDR_SIZE
;
1332 struct e802_hdr
*et802
= (struct e802_hdr
*)et
;
1333 et802
->et_prot
= htons(prot
);
1334 return E802_HDR_SIZE
;
1338 void net_set_ip_header(uchar
*pkt
, IPaddr_t dest
, IPaddr_t source
)
1340 struct ip_udp_hdr
*ip
= (struct ip_udp_hdr
*)pkt
;
1343 * Construct an IP header.
1345 /* IP_HDR_SIZE / 4 (not including UDP) */
1348 ip
->ip_len
= htons(IP_HDR_SIZE
);
1349 ip
->ip_id
= htons(NetIPID
++);
1350 ip
->ip_off
= htons(IP_FLAGS_DFRAG
); /* Don't fragment */
1353 /* already in network byte order */
1354 NetCopyIP((void *)&ip
->ip_src
, &source
);
1355 /* already in network byte order */
1356 NetCopyIP((void *)&ip
->ip_dst
, &dest
);
1359 void net_set_udp_header(uchar
*pkt
, IPaddr_t dest
, int dport
, int sport
,
1362 struct ip_udp_hdr
*ip
= (struct ip_udp_hdr
*)pkt
;
1365 * If the data is an odd number of bytes, zero the
1366 * byte after the last byte so that the checksum
1370 pkt
[IP_UDP_HDR_SIZE
+ len
] = 0;
1372 net_set_ip_header(pkt
, dest
, NetOurIP
);
1373 ip
->ip_len
= htons(IP_UDP_HDR_SIZE
+ len
);
1374 ip
->ip_p
= IPPROTO_UDP
;
1375 ip
->ip_sum
= ~NetCksum((uchar
*)ip
, IP_HDR_SIZE
>> 1);
1377 ip
->udp_src
= htons(sport
);
1378 ip
->udp_dst
= htons(dport
);
1379 ip
->udp_len
= htons(UDP_HDR_SIZE
+ len
);
1383 void copy_filename(char *dst
, const char *src
, int size
)
1385 if (*src
&& (*src
== '"')) {
1390 while ((--size
> 0) && *src
&& (*src
!= '"'))
1395 #if defined(CONFIG_CMD_NFS) || \
1396 defined(CONFIG_CMD_SNTP) || \
1397 defined(CONFIG_CMD_DNS)
1399 * make port a little random (1024-17407)
1400 * This keeps the math somewhat trivial to compute, and seems to work with
1401 * all supported protocols/clients/servers
1403 unsigned int random_port(void)
1405 return 1024 + (get_timer(0) % 0x4000);
1409 void ip_to_string(IPaddr_t x
, char *s
)
1412 sprintf(s
, "%d.%d.%d.%d",
1413 (int) ((x
>> 24) & 0xff),
1414 (int) ((x
>> 16) & 0xff),
1415 (int) ((x
>> 8) & 0xff), (int) ((x
>> 0) & 0xff)
1419 void VLAN_to_string(ushort x
, char *s
)
1423 if (x
== (ushort
)-1)
1429 sprintf(s
, "%d", x
& VLAN_IDMASK
);
1432 ushort
string_to_VLAN(const char *s
)
1437 return htons(VLAN_NONE
);
1439 if (*s
< '0' || *s
> '9')
1442 id
= (ushort
)simple_strtoul(s
, NULL
, 10);
1447 ushort
getenv_VLAN(char *var
)
1449 return string_to_VLAN(getenv(var
));