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
30 * - TFTP server IP address
35 * Prerequisites: - own ethernet address
37 * - TFTP server IP address
38 * We want: - TFTP server ethernet address
43 * Prerequisites: - own ethernet address
44 * We want: - IP, Netmask, ServerIP, Gateway IP
45 * - bootfilename, lease time
50 * Prerequisites: - own ethernet address
52 * - TFTP server IP address
53 * - TFTP server ethernet address
54 * - name of bootfile (if unknown, we use a default name
55 * derived from our own IP address)
56 * We want: - load the boot file
61 * Prerequisites: - own ethernet address
63 * - name of bootfile (if unknown, we use a default name
64 * derived from our own IP address)
65 * We want: - load the boot file
70 * Prerequisites: - own ethernet address
72 * We want: - network time
80 #include <linux/compiler.h>
87 #ifdef CONFIG_STATUS_LED
88 #include <status_led.h>
91 #if defined(CONFIG_CMD_SNTP)
95 #if defined(CONFIG_CMD_DNS)
100 DECLARE_GLOBAL_DATA_PTR
;
102 /** BOOTP EXTENTIONS **/
104 /* Our subnet mask (0=unknown) */
105 IPaddr_t NetOurSubnetMask
;
106 /* Our gateways IP address */
107 IPaddr_t NetOurGatewayIP
;
108 /* Our DNS IP address */
109 IPaddr_t NetOurDNSIP
;
110 #if defined(CONFIG_BOOTP_DNS2)
111 /* Our 2nd DNS IP address */
112 IPaddr_t NetOurDNS2IP
;
115 char NetOurNISDomain
[32] = {0,};
117 char NetOurHostName
[32] = {0,};
119 char NetOurRootPath
[64] = {0,};
120 /* Our bootfile size in blocks */
121 ushort NetBootFileSize
;
123 #ifdef CONFIG_MCAST_TFTP /* Multicast TFTP */
127 /** END OF BOOTP EXTENTIONS **/
129 /* The actual transferred size of the bootfile (in bytes) */
130 ulong NetBootFileXferSize
;
131 /* Our ethernet address */
132 uchar NetOurEther
[6];
133 /* Boot server enet address */
134 uchar NetServerEther
[6];
135 /* Our IP addr (0 = unknown) */
137 /* Server IP addr (0 = unknown) */
138 IPaddr_t NetServerIP
;
139 /* Current receive packet */
141 /* Current rx packet length */
145 /* Ethernet bcast address */
146 uchar NetBcastAddr
[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
147 uchar NetEtherNullAddr
[6];
149 void (*push_packet
)(void *, int len
) = 0;
151 /* Network loop state */
153 /* Tried all network devices */
155 /* Network loop restarted */
156 static int NetRestarted
;
157 /* At least one device configured */
158 static int NetDevExists
;
160 /* XXX in both little & big endian machines 0xFFFF == ntohs(-1) */
161 /* default is without VLAN */
162 ushort NetOurVLAN
= 0xFFFF;
164 ushort NetOurNativeVLAN
= 0xFFFF;
169 #if defined(CONFIG_CMD_SNTP)
170 /* NTP server IP address */
171 IPaddr_t NetNtpServerIP
;
172 /* offset time from UTC */
176 uchar PktBuf
[(PKTBUFSRX
+1) * PKTSIZE_ALIGN
+ PKTALIGN
];
179 uchar
*NetRxPackets
[PKTBUFSRX
];
181 /* Current RX packet handler */
182 static rxhand_f
*packetHandler
;
183 #ifdef CONFIG_CMD_TFTPPUT
184 static rxhand_icmp_f
*packet_icmp_handler
; /* Current ICMP rx handler */
186 /* Current timeout handler */
187 static thand_f
*timeHandler
;
188 /* Time base value */
189 static ulong timeStart
;
190 /* Current timeout value */
191 static ulong timeDelta
;
192 /* THE transmit packet */
195 static int net_check_prereq(enum proto_t protocol
);
197 static int NetTryCount
;
199 /**********************************************************************/
202 * Check if autoload is enabled. If so, use either NFS or TFTP to download
205 void net_auto_load(void)
207 const char *s
= getenv("autoload");
212 * Just use BOOTP/RARP to configure system;
213 * Do not use TFTP to load the bootfile.
215 NetState
= NETLOOP_SUCCESS
;
218 #if defined(CONFIG_CMD_NFS)
219 if (strcmp(s
, "NFS") == 0) {
221 * Use NFS to load the bootfile.
231 static void NetInitLoop(enum proto_t protocol
)
233 static int env_changed_id
;
234 int env_id
= get_env_id();
236 /* update only when the environment has changed */
237 if (env_changed_id
!= env_id
) {
238 NetOurIP
= getenv_IPaddr("ipaddr");
239 NetOurGatewayIP
= getenv_IPaddr("gatewayip");
240 NetOurSubnetMask
= getenv_IPaddr("netmask");
241 NetServerIP
= getenv_IPaddr("serverip");
242 NetOurNativeVLAN
= getenv_VLAN("nvlan");
243 NetOurVLAN
= getenv_VLAN("vlan");
244 #if defined(CONFIG_CMD_DNS)
245 NetOurDNSIP
= getenv_IPaddr("dnsip");
247 env_changed_id
= env_id
;
253 /**********************************************************************/
255 * Main network processing loop.
258 int NetLoop(enum proto_t protocol
)
274 * Setup packet buffers, aligned correctly.
276 NetTxPacket
= &PktBuf
[0] + (PKTALIGN
- 1);
277 NetTxPacket
-= (ulong
)NetTxPacket
% PKTALIGN
;
278 for (i
= 0; i
< PKTBUFSRX
; i
++)
279 NetRxPackets
[i
] = NetTxPacket
+ (i
+1)*PKTSIZE_ALIGN
;
282 bootstage_mark_name(BOOTSTAGE_ID_ETH_START
, "eth_start");
285 if (eth_init(bd
) < 0) {
291 memcpy(NetOurEther
, eth_get_dev()->enetaddr
, 6);
293 NetState
= NETLOOP_CONTINUE
;
296 * Start the ball rolling with the given start function. From
297 * here on, this code is a state machine driven by received
298 * packets and timer events.
300 NetInitLoop(protocol
);
302 switch (net_check_prereq(protocol
)) {
304 /* network not configured */
309 /* network device not configured */
314 NetBootFileXferSize
= 0;
317 #ifdef CONFIG_CMD_TFTPPUT
320 /* always use ARP to get server ethernet address */
323 #ifdef CONFIG_CMD_TFTPSRV
328 #if defined(CONFIG_CMD_DHCP)
332 DhcpRequest(); /* Basically same as BOOTP */
342 #if defined(CONFIG_CMD_RARP)
349 #if defined(CONFIG_CMD_PING)
354 #if defined(CONFIG_CMD_NFS)
359 #if defined(CONFIG_CMD_CDP)
364 #ifdef CONFIG_NETCONSOLE
369 #if defined(CONFIG_CMD_SNTP)
374 #if defined(CONFIG_CMD_DNS)
386 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
387 #if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \
388 defined(CONFIG_STATUS_LED) && \
389 defined(STATUS_LED_RED)
391 * Echo the inverted link state to the fault LED.
393 if (miiphy_link(eth_get_dev()->name
, CONFIG_SYS_FAULT_MII_ADDR
))
394 status_led_set(STATUS_LED_RED
, STATUS_LED_OFF
);
396 status_led_set(STATUS_LED_RED
, STATUS_LED_ON
);
397 #endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */
398 #endif /* CONFIG_MII, ... */
401 * Main packet reception loop. Loop receiving packets until
402 * someone sets `NetState' to a state that terminates.
406 #ifdef CONFIG_SHOW_ACTIVITY
410 * Check the ethernet for a new packet. The ethernet
411 * receive routine will process it.
416 * Abort if ctrl-c was pressed.
427 * Check for a timeout, and run the timeout handler
430 if (timeHandler
&& ((get_timer(0) - timeStart
) > timeDelta
)) {
433 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
434 #if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \
435 defined(CONFIG_STATUS_LED) && \
436 defined(STATUS_LED_RED)
438 * Echo the inverted link state to the fault LED.
440 if (miiphy_link(eth_get_dev()->name
,
441 CONFIG_SYS_FAULT_MII_ADDR
)) {
442 status_led_set(STATUS_LED_RED
, STATUS_LED_OFF
);
444 status_led_set(STATUS_LED_RED
, STATUS_LED_ON
);
446 #endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */
447 #endif /* CONFIG_MII, ... */
449 timeHandler
= (thand_f
*)0;
456 case NETLOOP_RESTART
:
460 case NETLOOP_SUCCESS
:
461 if (NetBootFileXferSize
> 0) {
463 printf("Bytes transferred = %ld (%lx hex)\n",
465 NetBootFileXferSize
);
466 sprintf(buf
, "%lX", NetBootFileXferSize
);
467 setenv("filesize", buf
);
469 sprintf(buf
, "%lX", (unsigned long)load_addr
);
470 setenv("fileaddr", buf
);
473 ret
= NetBootFileXferSize
;
482 #ifdef CONFIG_CMD_TFTPPUT
483 /* Clear out the handlers */
485 net_set_icmp_handler(NULL
);
490 /**********************************************************************/
493 startAgainTimeout(void)
495 NetState
= NETLOOP_RESTART
;
499 startAgainHandler(uchar
*pkt
, unsigned dest
, IPaddr_t sip
,
500 unsigned src
, unsigned len
)
502 /* Totally ignore the packet */
505 void NetStartAgain(void)
508 int retry_forever
= 0;
509 unsigned long retrycnt
= 0;
511 nretry
= getenv("netretry");
513 if (!strcmp(nretry
, "yes"))
515 else if (!strcmp(nretry
, "no"))
517 else if (!strcmp(nretry
, "once"))
520 retrycnt
= simple_strtoul(nretry
, NULL
, 0);
524 if ((!retry_forever
) && (NetTryCount
>= retrycnt
)) {
526 NetState
= NETLOOP_FAIL
;
533 #if !defined(CONFIG_NET_DO_NOT_TRY_ANOTHER)
534 eth_try_another(!NetRestarted
);
537 if (NetRestartWrap
) {
540 NetSetTimeout(10000UL, startAgainTimeout
);
541 NetSetHandler(startAgainHandler
);
543 NetState
= NETLOOP_FAIL
;
546 NetState
= NETLOOP_RESTART
;
550 /**********************************************************************/
558 return packetHandler
;
563 NetSetHandler(rxhand_f
*f
)
568 #ifdef CONFIG_CMD_TFTPPUT
569 void net_set_icmp_handler(rxhand_icmp_f
*f
)
571 packet_icmp_handler
= f
;
576 NetSetTimeout(ulong iv
, thand_f
*f
)
579 timeHandler
= (thand_f
*)0;
582 timeStart
= get_timer(0);
589 NetSendPacket(uchar
*pkt
, int len
)
591 (void) eth_send(pkt
, len
);
595 NetSendUDPPacket(uchar
*ether
, IPaddr_t dest
, int dport
, int sport
, int len
)
599 /* convert to new style broadcast */
603 /* if broadcast, make the ether address a broadcast and don't do ARP */
604 if (dest
== 0xFFFFFFFF)
605 ether
= NetBcastAddr
;
608 * if MAC address was not discovered yet, save the packet and do
611 if (memcmp(ether
, NetEtherNullAddr
, 6) == 0) {
613 debug("sending ARP for %08x\n", dest
);
615 NetArpWaitPacketIP
= dest
;
616 NetArpWaitPacketMAC
= ether
;
618 pkt
= NetArpWaitTxPacket
;
619 pkt
+= NetSetEther(pkt
, NetArpWaitPacketMAC
, PROT_IP
);
621 NetSetIP(pkt
, dest
, dport
, sport
, len
);
622 memcpy(pkt
+ IP_UDP_HDR_SIZE
, (uchar
*)NetTxPacket
+
623 (pkt
- (uchar
*)NetArpWaitTxPacket
) +
624 IP_UDP_HDR_SIZE
, len
);
626 /* size of the waiting packet */
627 NetArpWaitTxPacketSize
= (pkt
- NetArpWaitTxPacket
) +
628 IP_UDP_HDR_SIZE
+ len
;
630 /* and do the ARP request */
632 NetArpWaitTimerStart
= get_timer(0);
634 return 1; /* waiting */
637 debug("sending UDP to %08x/%pM\n", dest
, ether
);
639 pkt
= (uchar
*)NetTxPacket
;
640 pkt
+= NetSetEther(pkt
, ether
, PROT_IP
);
641 NetSetIP(pkt
, dest
, dport
, sport
, len
);
642 eth_send(NetTxPacket
, (pkt
- NetTxPacket
) + IP_UDP_HDR_SIZE
+ len
);
644 return 0; /* transmitted */
647 #ifdef CONFIG_IP_DEFRAG
649 * This function collects fragments in a single packet, according
650 * to the algorithm in RFC815. It returns NULL or the pointer to
651 * a complete packet, in static storage
653 #ifndef CONFIG_NET_MAXDEFRAG
654 #define CONFIG_NET_MAXDEFRAG 16384
657 * MAXDEFRAG, above, is chosen in the config file and is real data
658 * so we need to add the NFS overhead, which is more than TFTP.
659 * To use sizeof in the internal unnamed structures, we need a real
660 * instance (can't do "sizeof(struct rpc_t.u.reply))", unfortunately).
661 * The compiler doesn't complain nor allocates the actual structure
663 static struct rpc_t rpc_specimen
;
664 #define IP_PKTSIZE (CONFIG_NET_MAXDEFRAG + sizeof(rpc_specimen.u.reply))
666 #define IP_MAXUDP (IP_PKTSIZE - IP_HDR_SIZE_NO_UDP)
669 * this is the packet being assembled, either data or frag control.
670 * Fragments go by 8 bytes, so this union must be 8 bytes long
673 /* first_byte is address of this structure */
674 u16 last_byte
; /* last byte in this hole + 1 (begin of next hole) */
675 u16 next_hole
; /* index of next (in 8-b blocks), 0 == none */
676 u16 prev_hole
; /* index of prev, 0 == none */
680 static struct ip_udp_hdr
*__NetDefragment(struct ip_udp_hdr
*ip
, int *lenp
)
682 static uchar pkt_buff
[IP_PKTSIZE
] __aligned(PKTALIGN
);
683 static u16 first_hole
, total_len
;
684 struct hole
*payload
, *thisfrag
, *h
, *newh
;
685 struct ip_udp_hdr
*localip
= (struct ip_udp_hdr
*)pkt_buff
;
686 uchar
*indata
= (uchar
*)ip
;
687 int offset8
, start
, len
, done
= 0;
688 u16 ip_off
= ntohs(ip
->ip_off
);
690 /* payload starts after IP header, this fragment is in there */
691 payload
= (struct hole
*)(pkt_buff
+ IP_HDR_SIZE_NO_UDP
);
692 offset8
= (ip_off
& IP_OFFS
);
693 thisfrag
= payload
+ offset8
;
695 len
= ntohs(ip
->ip_len
) - IP_HDR_SIZE_NO_UDP
;
697 if (start
+ len
> IP_MAXUDP
) /* fragment extends too far */
700 if (!total_len
|| localip
->ip_id
!= ip
->ip_id
) {
701 /* new (or different) packet, reset structs */
703 payload
[0].last_byte
= ~0;
704 payload
[0].next_hole
= 0;
705 payload
[0].prev_hole
= 0;
707 /* any IP header will work, copy the first we received */
708 memcpy(localip
, ip
, IP_HDR_SIZE_NO_UDP
);
712 * What follows is the reassembly algorithm. We use the payload
713 * array as a linked list of hole descriptors, as each hole starts
714 * at a multiple of 8 bytes. However, last byte can be whatever value,
715 * so it is represented as byte count, not as 8-byte blocks.
718 h
= payload
+ first_hole
;
719 while (h
->last_byte
< start
) {
721 /* no hole that far away */
724 h
= payload
+ h
->next_hole
;
727 /* last fragment may be 1..7 bytes, the "+7" forces acceptance */
728 if (offset8
+ ((len
+ 7) / 8) <= h
- payload
) {
729 /* no overlap with holes (dup fragment?) */
733 if (!(ip_off
& IP_FLAGS_MFRAG
)) {
734 /* no more fragmentss: truncate this (last) hole */
735 total_len
= start
+ len
;
736 h
->last_byte
= start
+ len
;
740 * There is some overlap: fix the hole list. This code doesn't
741 * deal with a fragment that overlaps with two different holes
742 * (thus being a superset of a previously-received fragment).
745 if ((h
>= thisfrag
) && (h
->last_byte
<= start
+ len
)) {
746 /* complete overlap with hole: remove hole */
747 if (!h
->prev_hole
&& !h
->next_hole
) {
748 /* last remaining hole */
750 } else if (!h
->prev_hole
) {
752 first_hole
= h
->next_hole
;
753 payload
[h
->next_hole
].prev_hole
= 0;
754 } else if (!h
->next_hole
) {
756 payload
[h
->prev_hole
].next_hole
= 0;
758 /* in the middle of the list */
759 payload
[h
->next_hole
].prev_hole
= h
->prev_hole
;
760 payload
[h
->prev_hole
].next_hole
= h
->next_hole
;
763 } else if (h
->last_byte
<= start
+ len
) {
764 /* overlaps with final part of the hole: shorten this hole */
765 h
->last_byte
= start
;
767 } else if (h
>= thisfrag
) {
768 /* overlaps with initial part of the hole: move this hole */
769 newh
= thisfrag
+ (len
/ 8);
773 payload
[h
->next_hole
].prev_hole
= (h
- payload
);
775 payload
[h
->prev_hole
].next_hole
= (h
- payload
);
777 first_hole
= (h
- payload
);
780 /* fragment sits in the middle: split the hole */
781 newh
= thisfrag
+ (len
/ 8);
783 h
->last_byte
= start
;
784 h
->next_hole
= (newh
- payload
);
785 newh
->prev_hole
= (h
- payload
);
787 payload
[newh
->next_hole
].prev_hole
= (newh
- payload
);
790 /* finally copy this fragment and possibly return whole packet */
791 memcpy((uchar
*)thisfrag
, indata
+ IP_HDR_SIZE_NO_UDP
, len
);
795 localip
->ip_len
= htons(total_len
);
796 *lenp
= total_len
+ IP_HDR_SIZE_NO_UDP
;
800 static inline struct ip_udp_hdr
*NetDefragment(struct ip_udp_hdr
*ip
, int *lenp
)
802 u16 ip_off
= ntohs(ip
->ip_off
);
803 if (!(ip_off
& (IP_OFFS
| IP_FLAGS_MFRAG
)))
804 return ip
; /* not a fragment */
805 return __NetDefragment(ip
, lenp
);
808 #else /* !CONFIG_IP_DEFRAG */
810 static inline struct ip_udp_hdr
*NetDefragment(struct ip_udp_hdr
*ip
, int *lenp
)
812 u16 ip_off
= ntohs(ip
->ip_off
);
813 if (!(ip_off
& (IP_OFFS
| IP_FLAGS_MFRAG
)))
814 return ip
; /* not a fragment */
820 * Receive an ICMP packet. We deal with REDIRECT and PING here, and silently
823 * @parma ip IP packet containing the ICMP
825 static void receive_icmp(struct ip_udp_hdr
*ip
, int len
,
826 IPaddr_t src_ip
, Ethernet_t
*et
)
828 ICMP_t
*icmph
= (ICMP_t
*)&ip
->udp_src
;
830 switch (icmph
->type
) {
832 if (icmph
->code
!= ICMP_REDIR_HOST
)
834 printf(" ICMP Host Redirect to %pI4 ",
838 #if defined(CONFIG_CMD_PING)
839 ping_receive(et
, ip
, len
);
841 #ifdef CONFIG_CMD_TFTPPUT
842 if (packet_icmp_handler
)
843 packet_icmp_handler(icmph
->type
, icmph
->code
,
844 ntohs(ip
->udp_dst
), src_ip
, ntohs(ip
->udp_src
),
845 icmph
->un
.data
, ntohs(ip
->udp_len
));
852 NetReceive(uchar
*inpkt
, int len
)
855 struct ip_udp_hdr
*ip
;
859 #if defined(CONFIG_CMD_CDP)
862 ushort cti
= 0, vlanid
= VLAN_NONE
, myvlanid
, mynvlanid
;
864 debug("packet received\n");
867 NetRxPacketLen
= len
;
868 et
= (Ethernet_t
*)inpkt
;
870 /* too small packet? */
871 if (len
< ETHER_HDR_SIZE
)
876 (*push_packet
)(inpkt
, len
);
881 #if defined(CONFIG_CMD_CDP)
882 /* keep track if packet is CDP */
883 iscdp
= is_cdp_packet(et
->et_dest
);
886 myvlanid
= ntohs(NetOurVLAN
);
887 if (myvlanid
== (ushort
)-1)
888 myvlanid
= VLAN_NONE
;
889 mynvlanid
= ntohs(NetOurNativeVLAN
);
890 if (mynvlanid
== (ushort
)-1)
891 mynvlanid
= VLAN_NONE
;
893 x
= ntohs(et
->et_protlen
);
895 debug("packet received\n");
899 * Got a 802 packet. Check the other protocol field.
901 x
= ntohs(et
->et_prot
);
903 ip
= (struct ip_udp_hdr
*)(inpkt
+ E802_HDR_SIZE
);
904 len
-= E802_HDR_SIZE
;
906 } else if (x
!= PROT_VLAN
) { /* normal packet */
907 ip
= (struct ip_udp_hdr
*)(inpkt
+ ETHER_HDR_SIZE
);
908 len
-= ETHER_HDR_SIZE
;
910 } else { /* VLAN packet */
911 VLAN_Ethernet_t
*vet
= (VLAN_Ethernet_t
*)et
;
913 debug("VLAN packet received\n");
915 /* too small packet? */
916 if (len
< VLAN_ETHER_HDR_SIZE
)
919 /* if no VLAN active */
920 if ((ntohs(NetOurVLAN
) & VLAN_IDMASK
) == VLAN_NONE
921 #if defined(CONFIG_CMD_CDP)
927 cti
= ntohs(vet
->vet_tag
);
928 vlanid
= cti
& VLAN_IDMASK
;
929 x
= ntohs(vet
->vet_type
);
931 ip
= (struct ip_udp_hdr
*)(inpkt
+ VLAN_ETHER_HDR_SIZE
);
932 len
-= VLAN_ETHER_HDR_SIZE
;
935 debug("Receive from protocol 0x%x\n", x
);
937 #if defined(CONFIG_CMD_CDP)
939 CDPHandler((uchar
*)ip
, len
);
944 if ((myvlanid
& VLAN_IDMASK
) != VLAN_NONE
) {
945 if (vlanid
== VLAN_NONE
)
946 vlanid
= (mynvlanid
& VLAN_IDMASK
);
948 if (vlanid
!= (myvlanid
& VLAN_IDMASK
))
955 ArpReceive(et
, ip
, len
);
958 #ifdef CONFIG_CMD_RARP
960 rarp_receive(ip
, len
);
965 /* Before we start poking the header, make sure it is there */
966 if (len
< IP_UDP_HDR_SIZE
) {
967 debug("len bad %d < %lu\n", len
,
968 (ulong
)IP_UDP_HDR_SIZE
);
971 /* Check the packet length */
972 if (len
< ntohs(ip
->ip_len
)) {
973 printf("len bad %d < %d\n", len
, ntohs(ip
->ip_len
));
976 len
= ntohs(ip
->ip_len
);
977 debug("len=%d, v=%02x\n", len
, ip
->ip_hl_v
& 0xff);
979 /* Can't deal with anything except IPv4 */
980 if ((ip
->ip_hl_v
& 0xf0) != 0x40)
982 /* Can't deal with IP options (headers != 20 bytes) */
983 if ((ip
->ip_hl_v
& 0x0f) > 0x05)
985 /* Check the Checksum of the header */
986 if (!NetCksumOk((uchar
*)ip
, IP_HDR_SIZE_NO_UDP
/ 2)) {
987 puts("checksum bad\n");
990 /* If it is not for us, ignore it */
991 tmp
= NetReadIP(&ip
->ip_dst
);
992 if (NetOurIP
&& tmp
!= NetOurIP
&& tmp
!= 0xFFFFFFFF) {
993 #ifdef CONFIG_MCAST_TFTP
994 if (Mcast_addr
!= tmp
)
998 /* Read source IP address for later use */
999 src_ip
= NetReadIP(&ip
->ip_src
);
1001 * The function returns the unchanged packet if it's not
1002 * a fragment, and either the complete packet or NULL if
1003 * it is a fragment (if !CONFIG_IP_DEFRAG, it returns NULL)
1005 ip
= NetDefragment(ip
, &len
);
1009 * watch for ICMP host redirects
1011 * There is no real handler code (yet). We just watch
1012 * for ICMP host redirect messages. In case anybody
1013 * sees these messages: please contact me
1014 * (wd@denx.de), or - even better - send me the
1015 * necessary fixes :-)
1017 * Note: in all cases where I have seen this so far
1018 * it was a problem with the router configuration,
1019 * for instance when a router was configured in the
1020 * BOOTP reply, but the TFTP server was on the same
1021 * subnet. So this is probably a warning that your
1022 * configuration might be wrong. But I'm not really
1023 * sure if there aren't any other situations.
1025 * Simon Glass <sjg@chromium.org>: We get an ICMP when
1026 * we send a tftp packet to a dead connection, or when
1027 * there is no server at the other end.
1029 if (ip
->ip_p
== IPPROTO_ICMP
) {
1030 receive_icmp(ip
, len
, src_ip
, et
);
1032 } else if (ip
->ip_p
!= IPPROTO_UDP
) { /* Only UDP packets */
1036 #ifdef CONFIG_UDP_CHECKSUM
1037 if (ip
->udp_xsum
!= 0) {
1043 xsum
+= (ntohs(ip
->udp_len
));
1044 xsum
+= (ntohl(ip
->ip_src
) >> 16) & 0x0000ffff;
1045 xsum
+= (ntohl(ip
->ip_src
) >> 0) & 0x0000ffff;
1046 xsum
+= (ntohl(ip
->ip_dst
) >> 16) & 0x0000ffff;
1047 xsum
+= (ntohl(ip
->ip_dst
) >> 0) & 0x0000ffff;
1049 sumlen
= ntohs(ip
->udp_len
);
1050 sumptr
= (ushort
*) &(ip
->udp_src
);
1052 while (sumlen
> 1) {
1055 sumdata
= *sumptr
++;
1056 xsum
+= ntohs(sumdata
);
1062 sumdata
= *(unsigned char *) sumptr
;
1063 sumdata
= (sumdata
<< 8) & 0xff00;
1066 while ((xsum
>> 16) != 0) {
1067 xsum
= (xsum
& 0x0000ffff) +
1068 ((xsum
>> 16) & 0x0000ffff);
1070 if ((xsum
!= 0x00000000) && (xsum
!= 0x0000ffff)) {
1071 printf(" UDP wrong checksum %08lx %08x\n",
1072 xsum
, ntohs(ip
->udp_xsum
));
1079 #ifdef CONFIG_NETCONSOLE
1080 nc_input_packet((uchar
*)ip
+ IP_UDP_HDR_SIZE
,
1083 ntohs(ip
->udp_len
) - UDP_HDR_SIZE
);
1086 * IP header OK. Pass the packet to the current handler.
1088 (*packetHandler
)((uchar
*)ip
+ IP_UDP_HDR_SIZE
,
1092 ntohs(ip
->udp_len
) - UDP_HDR_SIZE
);
1098 /**********************************************************************/
1100 static int net_check_prereq(enum proto_t protocol
)
1104 #if defined(CONFIG_CMD_PING)
1106 if (NetPingIP
== 0) {
1107 puts("*** ERROR: ping address not given\n");
1112 #if defined(CONFIG_CMD_SNTP)
1114 if (NetNtpServerIP
== 0) {
1115 puts("*** ERROR: NTP server address not given\n");
1120 #if defined(CONFIG_CMD_DNS)
1122 if (NetOurDNSIP
== 0) {
1123 puts("*** ERROR: DNS server address not given\n");
1128 #if defined(CONFIG_CMD_NFS)
1133 if (NetServerIP
== 0) {
1134 puts("*** ERROR: `serverip' not set\n");
1137 #if defined(CONFIG_CMD_PING) || defined(CONFIG_CMD_SNTP) || \
1138 defined(CONFIG_CMD_DNS)
1145 if (NetOurIP
== 0) {
1146 puts("*** ERROR: `ipaddr' not set\n");
1151 #ifdef CONFIG_CMD_RARP
1157 if (memcmp(NetOurEther
, "\0\0\0\0\0\0", 6) == 0) {
1158 int num
= eth_get_dev_index();
1162 puts("*** ERROR: No ethernet found.\n");
1165 puts("*** ERROR: `ethaddr' not set\n");
1168 printf("*** ERROR: `eth%daddr' not set\n",
1182 /**********************************************************************/
1185 NetCksumOk(uchar
*ptr
, int len
)
1187 return !((NetCksum(ptr
, len
) + 1) & 0xfffe);
1192 NetCksum(uchar
*ptr
, int len
)
1195 ushort
*p
= (ushort
*)ptr
;
1200 xsum
= (xsum
& 0xffff) + (xsum
>> 16);
1201 xsum
= (xsum
& 0xffff) + (xsum
>> 16);
1202 return xsum
& 0xffff;
1210 myvlanid
= ntohs(NetOurVLAN
);
1211 if (myvlanid
== (ushort
)-1)
1212 myvlanid
= VLAN_NONE
;
1214 return ((myvlanid
& VLAN_IDMASK
) == VLAN_NONE
) ? ETHER_HDR_SIZE
:
1215 VLAN_ETHER_HDR_SIZE
;
1219 NetSetEther(uchar
*xet
, uchar
* addr
, uint prot
)
1221 Ethernet_t
*et
= (Ethernet_t
*)xet
;
1224 myvlanid
= ntohs(NetOurVLAN
);
1225 if (myvlanid
== (ushort
)-1)
1226 myvlanid
= VLAN_NONE
;
1228 memcpy(et
->et_dest
, addr
, 6);
1229 memcpy(et
->et_src
, NetOurEther
, 6);
1230 if ((myvlanid
& VLAN_IDMASK
) == VLAN_NONE
) {
1231 et
->et_protlen
= htons(prot
);
1232 return ETHER_HDR_SIZE
;
1234 VLAN_Ethernet_t
*vet
= (VLAN_Ethernet_t
*)xet
;
1236 vet
->vet_vlan_type
= htons(PROT_VLAN
);
1237 vet
->vet_tag
= htons((0 << 5) | (myvlanid
& VLAN_IDMASK
));
1238 vet
->vet_type
= htons(prot
);
1239 return VLAN_ETHER_HDR_SIZE
;
1243 void NetSetIP(uchar
*xip
, IPaddr_t dest
, int dport
, int sport
, int len
)
1245 struct ip_udp_hdr
*ip
= (struct ip_udp_hdr
*)xip
;
1248 * If the data is an odd number of bytes, zero the
1249 * byte after the last byte so that the checksum
1253 xip
[IP_UDP_HDR_SIZE
+ len
] = 0;
1256 * Construct an IP and UDP header.
1257 * (need to set no fragment bit - XXX)
1259 /* IP_HDR_SIZE / 4 (not including UDP) */
1262 ip
->ip_len
= htons(IP_UDP_HDR_SIZE
+ len
);
1263 ip
->ip_id
= htons(NetIPID
++);
1264 ip
->ip_off
= htons(IP_FLAGS_DFRAG
); /* Don't fragment */
1266 ip
->ip_p
= 17; /* UDP */
1268 /* already in network byte order */
1269 NetCopyIP((void *)&ip
->ip_src
, &NetOurIP
);
1271 NetCopyIP((void *)&ip
->ip_dst
, &dest
);
1272 ip
->udp_src
= htons(sport
);
1273 ip
->udp_dst
= htons(dport
);
1274 ip
->udp_len
= htons(UDP_HDR_SIZE
+ len
);
1276 ip
->ip_sum
= ~NetCksum((uchar
*)ip
, IP_HDR_SIZE_NO_UDP
/ 2);
1279 void copy_filename(char *dst
, const char *src
, int size
)
1281 if (*src
&& (*src
== '"')) {
1286 while ((--size
> 0) && *src
&& (*src
!= '"'))
1291 #if defined(CONFIG_CMD_NFS) || \
1292 defined(CONFIG_CMD_SNTP) || \
1293 defined(CONFIG_CMD_DNS)
1295 * make port a little random (1024-17407)
1296 * This keeps the math somewhat trivial to compute, and seems to work with
1297 * all supported protocols/clients/servers
1299 unsigned int random_port(void)
1301 return 1024 + (get_timer(0) % 0x4000);
1305 void ip_to_string(IPaddr_t x
, char *s
)
1308 sprintf(s
, "%d.%d.%d.%d",
1309 (int) ((x
>> 24) & 0xff),
1310 (int) ((x
>> 16) & 0xff),
1311 (int) ((x
>> 8) & 0xff), (int) ((x
>> 0) & 0xff)
1315 void VLAN_to_string(ushort x
, char *s
)
1319 if (x
== (ushort
)-1)
1325 sprintf(s
, "%d", x
& VLAN_IDMASK
);
1328 ushort
string_to_VLAN(const char *s
)
1333 return htons(VLAN_NONE
);
1335 if (*s
< '0' || *s
> '9')
1338 id
= (ushort
)simple_strtoul(s
, NULL
, 10);
1343 ushort
getenv_VLAN(char *var
)
1345 return string_to_VLAN(getenv(var
));