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 #if defined(CONFIG_STATUS_LED)
82 #include <status_led.h>
85 #include <linux/compiler.h>
89 #if defined(CONFIG_CMD_DNS)
95 #if defined(CONFIG_CMD_SNTP)
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 */
152 enum net_loop_state net_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 net_set_state(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 net_set_state(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 `net_state' 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;
479 case NETLOOP_CONTINUE:
485 #ifdef CONFIG_CMD_TFTPPUT
486 /* Clear out the handlers */
488 net_set_icmp_handler(NULL);
493 /**********************************************************************/
496 startAgainTimeout(void)
498 net_set_state(NETLOOP_RESTART);
502 startAgainHandler(uchar *pkt, unsigned dest, IPaddr_t sip,
503 unsigned src, unsigned len)
505 /* Totally ignore the packet */
508 void NetStartAgain(void)
511 int retry_forever = 0;
512 unsigned long retrycnt = 0;
514 nretry = getenv("netretry");
516 if (!strcmp(nretry, "yes"))
518 else if (!strcmp(nretry, "no"))
520 else if (!strcmp(nretry, "once"))
523 retrycnt = simple_strtoul(nretry, NULL, 0);
527 if ((!retry_forever) && (NetTryCount >= retrycnt)) {
529 net_set_state(NETLOOP_FAIL);
536 #if !defined(CONFIG_NET_DO_NOT_TRY_ANOTHER)
537 eth_try_another(!NetRestarted);
540 if (NetRestartWrap) {
543 NetSetTimeout(10000UL, startAgainTimeout);
544 NetSetHandler(startAgainHandler);
546 net_set_state(NETLOOP_FAIL);
549 net_set_state(NETLOOP_RESTART);
553 /**********************************************************************/
561 return packetHandler;
566 NetSetHandler(rxhand_f *f)
571 #ifdef CONFIG_CMD_TFTPPUT
572 void net_set_icmp_handler(rxhand_icmp_f *f)
574 packet_icmp_handler = f;
579 NetSetTimeout(ulong iv, thand_f *f)
582 timeHandler = (thand_f *)0;
585 timeStart = get_timer(0);
590 int NetSendUDPPacket(uchar *ether, IPaddr_t dest, int dport, int sport,
598 /* convert to new style broadcast */
602 /* if broadcast, make the ether address a broadcast and don't do ARP */
603 if (dest == 0xFFFFFFFF)
604 ether = NetBcastAddr;
607 * if MAC address was not discovered yet, save the packet and do
610 if (memcmp(ether, NetEtherNullAddr, 6) == 0) {
612 pkt = NetArpWaitTxPacket;
614 pkt = (uchar *)NetTxPacket;
616 eth_hdr_size = NetSetEther(pkt, ether, PROT_IP);
618 net_set_udp_header(pkt, dest, dport, sport, payload_len);
619 pkt_hdr_size = eth_hdr_size + IP_UDP_HDR_SIZE;
622 debug("sending ARP for %pI4\n", &dest);
624 /* save the ip and eth addr for the packet to send after arp */
625 NetArpWaitPacketIP = dest;
626 NetArpWaitPacketMAC = ether;
629 * Copy the packet data from the NetTxPacket into the
630 * NetArpWaitTxPacket to send after arp
632 memcpy(pkt + IP_UDP_HDR_SIZE, (uchar *)NetTxPacket +
633 pkt_hdr_size, payload_len);
635 /* size of the waiting packet */
636 NetArpWaitTxPacketSize = pkt_hdr_size + payload_len;
638 /* and do the ARP request */
640 NetArpWaitTimerStart = get_timer(0);
642 return 1; /* waiting */
644 debug("sending UDP to %pI4/%pM\n", &dest, ether);
645 NetSendPacket(NetTxPacket, pkt_hdr_size + payload_len);
646 return 0; /* transmitted */
650 #ifdef CONFIG_IP_DEFRAG
652 * This function collects fragments in a single packet, according
653 * to the algorithm in RFC815. It returns NULL or the pointer to
654 * a complete packet, in static storage
656 #ifndef CONFIG_NET_MAXDEFRAG
657 #define CONFIG_NET_MAXDEFRAG 16384
660 * MAXDEFRAG, above, is chosen in the config file and is real data
661 * so we need to add the NFS overhead, which is more than TFTP.
662 * To use sizeof in the internal unnamed structures, we need a real
663 * instance (can't do "sizeof(struct rpc_t.u.reply))", unfortunately).
664 * The compiler doesn't complain nor allocates the actual structure
666 static struct rpc_t rpc_specimen;
667 #define IP_PKTSIZE (CONFIG_NET_MAXDEFRAG + sizeof(rpc_specimen.u.reply))
669 #define IP_MAXUDP (IP_PKTSIZE - IP_HDR_SIZE)
672 * this is the packet being assembled, either data or frag control.
673 * Fragments go by 8 bytes, so this union must be 8 bytes long
676 /* first_byte is address of this structure */
677 u16 last_byte; /* last byte in this hole + 1 (begin of next hole) */
678 u16 next_hole; /* index of next (in 8-b blocks), 0 == none */
679 u16 prev_hole; /* index of prev, 0 == none */
683 static struct ip_udp_hdr *__NetDefragment(struct ip_udp_hdr *ip, int *lenp)
685 static uchar pkt_buff[IP_PKTSIZE] __aligned(PKTALIGN);
686 static u16 first_hole, total_len;
687 struct hole *payload, *thisfrag, *h, *newh;
688 struct ip_udp_hdr *localip = (struct ip_udp_hdr *)pkt_buff;
689 uchar *indata = (uchar *)ip;
690 int offset8, start, len, done = 0;
691 u16 ip_off = ntohs(ip->ip_off);
693 /* payload starts after IP header, this fragment is in there */
694 payload = (struct hole *)(pkt_buff + IP_HDR_SIZE);
695 offset8 = (ip_off & IP_OFFS);
696 thisfrag = payload + offset8;
698 len = ntohs(ip->ip_len) - IP_HDR_SIZE;
700 if (start + len > IP_MAXUDP) /* fragment extends too far */
703 if (!total_len || localip->ip_id != ip->ip_id) {
704 /* new (or different) packet, reset structs */
706 payload[0].last_byte = ~0;
707 payload[0].next_hole = 0;
708 payload[0].prev_hole = 0;
710 /* any IP header will work, copy the first we received */
711 memcpy(localip, ip, IP_HDR_SIZE);
715 * What follows is the reassembly algorithm. We use the payload
716 * array as a linked list of hole descriptors, as each hole starts
717 * at a multiple of 8 bytes. However, last byte can be whatever value,
718 * so it is represented as byte count, not as 8-byte blocks.
721 h = payload + first_hole;
722 while (h->last_byte < start) {
724 /* no hole that far away */
727 h = payload + h->next_hole;
730 /* last fragment may be 1..7 bytes, the "+7" forces acceptance */
731 if (offset8 + ((len + 7) / 8) <= h - payload) {
732 /* no overlap with holes (dup fragment?) */
736 if (!(ip_off & IP_FLAGS_MFRAG)) {
737 /* no more fragmentss: truncate this (last) hole */
738 total_len = start + len;
739 h->last_byte = start + len;
743 * There is some overlap: fix the hole list. This code doesn't
744 * deal with a fragment that overlaps with two different holes
745 * (thus being a superset of a previously-received fragment).
748 if ((h >= thisfrag) && (h->last_byte <= start + len)) {
749 /* complete overlap with hole: remove hole */
750 if (!h->prev_hole && !h->next_hole) {
751 /* last remaining hole */
753 } else if (!h->prev_hole) {
755 first_hole = h->next_hole;
756 payload[h->next_hole].prev_hole = 0;
757 } else if (!h->next_hole) {
759 payload[h->prev_hole].next_hole = 0;
761 /* in the middle of the list */
762 payload[h->next_hole].prev_hole = h->prev_hole;
763 payload[h->prev_hole].next_hole = h->next_hole;
766 } else if (h->last_byte <= start + len) {
767 /* overlaps with final part of the hole: shorten this hole */
768 h->last_byte = start;
770 } else if (h >= thisfrag) {
771 /* overlaps with initial part of the hole: move this hole */
772 newh = thisfrag + (len / 8);
776 payload[h->next_hole].prev_hole = (h - payload);
778 payload[h->prev_hole].next_hole = (h - payload);
780 first_hole = (h - payload);
783 /* fragment sits in the middle: split the hole */
784 newh = thisfrag + (len / 8);
786 h->last_byte = start;
787 h->next_hole = (newh - payload);
788 newh->prev_hole = (h - payload);
790 payload[newh->next_hole].prev_hole = (newh - payload);
793 /* finally copy this fragment and possibly return whole packet */
794 memcpy((uchar *)thisfrag, indata + IP_HDR_SIZE, len);
798 localip->ip_len = htons(total_len);
799 *lenp = total_len + IP_HDR_SIZE;
803 static inline struct ip_udp_hdr *NetDefragment(struct ip_udp_hdr *ip, int *lenp)
805 u16 ip_off = ntohs(ip->ip_off);
806 if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG)))
807 return ip; /* not a fragment */
808 return __NetDefragment(ip, lenp);
811 #else /* !CONFIG_IP_DEFRAG */
813 static inline struct ip_udp_hdr *NetDefragment(struct ip_udp_hdr *ip, int *lenp)
815 u16 ip_off = ntohs(ip->ip_off);
816 if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG)))
817 return ip; /* not a fragment */
823 * Receive an ICMP packet. We deal with REDIRECT and PING here, and silently
826 * @parma ip IP packet containing the ICMP
828 static void receive_icmp(struct ip_udp_hdr *ip, int len,
829 IPaddr_t src_ip, struct ethernet_hdr *et)
831 struct icmp_hdr *icmph = (struct icmp_hdr *)&ip->udp_src;
833 switch (icmph->type) {
835 if (icmph->code != ICMP_REDIR_HOST)
837 printf(" ICMP Host Redirect to %pI4 ",
841 #if defined(CONFIG_CMD_PING)
842 ping_receive(et, ip, len);
844 #ifdef CONFIG_CMD_TFTPPUT
845 if (packet_icmp_handler)
846 packet_icmp_handler(icmph->type, icmph->code,
847 ntohs(ip->udp_dst), src_ip, ntohs(ip->udp_src),
848 icmph->un.data, ntohs(ip->udp_len));
855 NetReceive(uchar *inpkt, int len)
857 struct ethernet_hdr *et;
858 struct ip_udp_hdr *ip;
862 #if defined(CONFIG_CMD_CDP)
865 ushort cti = 0, vlanid = VLAN_NONE, myvlanid, mynvlanid;
867 debug("packet received\n");
870 NetRxPacketLen = len;
871 et = (struct ethernet_hdr *)inpkt;
873 /* too small packet? */
874 if (len < ETHER_HDR_SIZE)
879 (*push_packet)(inpkt, len);
884 #if defined(CONFIG_CMD_CDP)
885 /* keep track if packet is CDP */
886 iscdp = is_cdp_packet(et->et_dest);
889 myvlanid = ntohs(NetOurVLAN);
890 if (myvlanid == (ushort)-1)
891 myvlanid = VLAN_NONE;
892 mynvlanid = ntohs(NetOurNativeVLAN);
893 if (mynvlanid == (ushort)-1)
894 mynvlanid = VLAN_NONE;
896 eth_proto = ntohs(et->et_protlen);
898 debug("packet received\n");
900 if (eth_proto < 1514) {
901 struct e802_hdr *et802 = (struct e802_hdr *)et;
903 * Got a 802.2 packet. Check the other protocol field.
904 * XXX VLAN over 802.2+SNAP not implemented!
906 eth_proto = ntohs(et802->et_prot);
908 ip = (struct ip_udp_hdr *)(inpkt + E802_HDR_SIZE);
909 len -= E802_HDR_SIZE;
911 } else if (eth_proto != PROT_VLAN) { /* normal packet */
912 ip = (struct ip_udp_hdr *)(inpkt + ETHER_HDR_SIZE);
913 len -= ETHER_HDR_SIZE;
915 } else { /* VLAN packet */
916 struct vlan_ethernet_hdr *vet =
917 (struct vlan_ethernet_hdr *)et;
919 debug("VLAN packet received\n");
921 /* too small packet? */
922 if (len < VLAN_ETHER_HDR_SIZE)
925 /* if no VLAN active */
926 if ((ntohs(NetOurVLAN) & VLAN_IDMASK) == VLAN_NONE
927 #if defined(CONFIG_CMD_CDP)
933 cti = ntohs(vet->vet_tag);
934 vlanid = cti & VLAN_IDMASK;
935 eth_proto = ntohs(vet->vet_type);
937 ip = (struct ip_udp_hdr *)(inpkt + VLAN_ETHER_HDR_SIZE);
938 len -= VLAN_ETHER_HDR_SIZE;
941 debug("Receive from protocol 0x%x\n", eth_proto);
943 #if defined(CONFIG_CMD_CDP)
945 cdp_receive((uchar *)ip, len);
950 if ((myvlanid & VLAN_IDMASK) != VLAN_NONE) {
951 if (vlanid == VLAN_NONE)
952 vlanid = (mynvlanid & VLAN_IDMASK);
954 if (vlanid != (myvlanid & VLAN_IDMASK))
961 ArpReceive(et, ip, len);
964 #ifdef CONFIG_CMD_RARP
966 rarp_receive(ip, len);
971 /* Before we start poking the header, make sure it is there */
972 if (len < IP_UDP_HDR_SIZE) {
973 debug("len bad %d < %lu\n", len,
974 (ulong)IP_UDP_HDR_SIZE);
977 /* Check the packet length */
978 if (len < ntohs(ip->ip_len)) {
979 printf("len bad %d < %d\n", len, ntohs(ip->ip_len));
982 len = ntohs(ip->ip_len);
983 debug("len=%d, v=%02x\n", len, ip->ip_hl_v & 0xff);
985 /* Can't deal with anything except IPv4 */
986 if ((ip->ip_hl_v & 0xf0) != 0x40)
988 /* Can't deal with IP options (headers != 20 bytes) */
989 if ((ip->ip_hl_v & 0x0f) > 0x05)
991 /* Check the Checksum of the header */
992 if (!NetCksumOk((uchar *)ip, IP_HDR_SIZE / 2)) {
993 puts("checksum bad\n");
996 /* If it is not for us, ignore it */
997 dst_ip = NetReadIP(&ip->ip_dst);
998 if (NetOurIP && dst_ip != NetOurIP && dst_ip != 0xFFFFFFFF) {
999 #ifdef CONFIG_MCAST_TFTP
1000 if (Mcast_addr != dst_ip)
1004 /* Read source IP address for later use */
1005 src_ip = NetReadIP(&ip->ip_src);
1007 * The function returns the unchanged packet if it's not
1008 * a fragment, and either the complete packet or NULL if
1009 * it is a fragment (if !CONFIG_IP_DEFRAG, it returns NULL)
1011 ip = NetDefragment(ip, &len);
1015 * watch for ICMP host redirects
1017 * There is no real handler code (yet). We just watch
1018 * for ICMP host redirect messages. In case anybody
1019 * sees these messages: please contact me
1020 * (wd@denx.de), or - even better - send me the
1021 * necessary fixes :-)
1023 * Note: in all cases where I have seen this so far
1024 * it was a problem with the router configuration,
1025 * for instance when a router was configured in the
1026 * BOOTP reply, but the TFTP server was on the same
1027 * subnet. So this is probably a warning that your
1028 * configuration might be wrong. But I'm not really
1029 * sure if there aren't any other situations.
1031 * Simon Glass <sjg@chromium.org>: We get an ICMP when
1032 * we send a tftp packet to a dead connection, or when
1033 * there is no server at the other end.
1035 if (ip->ip_p == IPPROTO_ICMP) {
1036 receive_icmp(ip, len, src_ip, et);
1038 } else if (ip->ip_p != IPPROTO_UDP) { /* Only UDP packets */
1042 #ifdef CONFIG_UDP_CHECKSUM
1043 if (ip->udp_xsum != 0) {
1049 xsum += (ntohs(ip->udp_len));
1050 xsum += (ntohl(ip->ip_src) >> 16) & 0x0000ffff;
1051 xsum += (ntohl(ip->ip_src) >> 0) & 0x0000ffff;
1052 xsum += (ntohl(ip->ip_dst) >> 16) & 0x0000ffff;
1053 xsum += (ntohl(ip->ip_dst) >> 0) & 0x0000ffff;
1055 sumlen = ntohs(ip->udp_len);
1056 sumptr = (ushort *) &(ip->udp_src);
1058 while (sumlen > 1) {
1061 sumdata = *sumptr++;
1062 xsum += ntohs(sumdata);
1068 sumdata = *(unsigned char *) sumptr;
1069 sumdata = (sumdata << 8) & 0xff00;
1072 while ((xsum >> 16) != 0) {
1073 xsum = (xsum & 0x0000ffff) +
1074 ((xsum >> 16) & 0x0000ffff);
1076 if ((xsum != 0x00000000) && (xsum != 0x0000ffff)) {
1077 printf(" UDP wrong checksum %08lx %08x\n",
1078 xsum, ntohs(ip->udp_xsum));
1085 #ifdef CONFIG_NETCONSOLE
1086 nc_input_packet((uchar *)ip + IP_UDP_HDR_SIZE,
1089 ntohs(ip->udp_len) - UDP_HDR_SIZE);
1092 * IP header OK. Pass the packet to the current handler.
1094 (*packetHandler)((uchar *)ip + IP_UDP_HDR_SIZE,
1098 ntohs(ip->udp_len) - UDP_HDR_SIZE);
1104 /**********************************************************************/
1106 static int net_check_prereq(enum proto_t protocol)
1110 #if defined(CONFIG_CMD_PING)
1112 if (NetPingIP == 0) {
1113 puts("*** ERROR: ping address not given\n");
1118 #if defined(CONFIG_CMD_SNTP)
1120 if (NetNtpServerIP == 0) {
1121 puts("*** ERROR: NTP server address not given\n");
1126 #if defined(CONFIG_CMD_DNS)
1128 if (NetOurDNSIP == 0) {
1129 puts("*** ERROR: DNS server address not given\n");
1134 #if defined(CONFIG_CMD_NFS)
1139 if (NetServerIP == 0) {
1140 puts("*** ERROR: `serverip' not set\n");
1143 #if defined(CONFIG_CMD_PING) || defined(CONFIG_CMD_SNTP) || \
1144 defined(CONFIG_CMD_DNS)
1151 if (NetOurIP == 0) {
1152 puts("*** ERROR: `ipaddr' not set\n");
1157 #ifdef CONFIG_CMD_RARP
1163 if (memcmp(NetOurEther, "\0\0\0\0\0\0", 6) == 0) {
1164 int num = eth_get_dev_index();
1168 puts("*** ERROR: No ethernet found.\n");
1171 puts("*** ERROR: `ethaddr' not set\n");
1174 printf("*** ERROR: `eth%daddr' not set\n",
1188 /**********************************************************************/
1191 NetCksumOk(uchar *ptr, int len)
1193 return !((NetCksum(ptr, len) + 1) & 0xfffe);
1198 NetCksum(uchar *ptr, int len)
1201 ushort *p = (ushort *)ptr;
1206 xsum = (xsum & 0xffff) + (xsum >> 16);
1207 xsum = (xsum & 0xffff) + (xsum >> 16);
1208 return xsum & 0xffff;
1216 myvlanid = ntohs(NetOurVLAN);
1217 if (myvlanid == (ushort)-1)
1218 myvlanid = VLAN_NONE;
1220 return ((myvlanid & VLAN_IDMASK) == VLAN_NONE) ? ETHER_HDR_SIZE :
1221 VLAN_ETHER_HDR_SIZE;
1225 NetSetEther(uchar *xet, uchar * addr, uint prot)
1227 struct ethernet_hdr *et = (struct ethernet_hdr *)xet;
1230 myvlanid = ntohs(NetOurVLAN);
1231 if (myvlanid == (ushort)-1)
1232 myvlanid = VLAN_NONE;
1234 memcpy(et->et_dest, addr, 6);
1235 memcpy(et->et_src, NetOurEther, 6);
1236 if ((myvlanid & VLAN_IDMASK) == VLAN_NONE) {
1237 et->et_protlen = htons(prot);
1238 return ETHER_HDR_SIZE;
1240 struct vlan_ethernet_hdr *vet =
1241 (struct vlan_ethernet_hdr *)xet;
1243 vet->vet_vlan_type = htons(PROT_VLAN);
1244 vet->vet_tag = htons((0 << 5) | (myvlanid & VLAN_IDMASK));
1245 vet->vet_type = htons(prot);
1246 return VLAN_ETHER_HDR_SIZE;
1250 void net_set_ip_header(uchar *pkt, IPaddr_t dest, IPaddr_t source)
1252 struct ip_udp_hdr *ip = (struct ip_udp_hdr *)pkt;
1255 * Construct an IP header.
1257 /* IP_HDR_SIZE / 4 (not including UDP) */
1260 ip->ip_len = htons(IP_HDR_SIZE);
1261 ip->ip_id = htons(NetIPID++);
1262 ip->ip_off = htons(IP_FLAGS_DFRAG); /* Don't fragment */
1265 /* already in network byte order */
1266 NetCopyIP((void *)&ip->ip_src, &source);
1267 /* already in network byte order */
1268 NetCopyIP((void *)&ip->ip_dst, &dest);
1271 void net_set_udp_header(uchar *pkt, IPaddr_t dest, int dport, int sport,
1274 struct ip_udp_hdr *ip = (struct ip_udp_hdr *)pkt;
1277 * If the data is an odd number of bytes, zero the
1278 * byte after the last byte so that the checksum
1282 pkt[IP_UDP_HDR_SIZE + len] = 0;
1284 net_set_ip_header(pkt, dest, NetOurIP);
1285 ip->ip_len = htons(IP_UDP_HDR_SIZE + len);
1286 ip->ip_p = IPPROTO_UDP;
1287 ip->ip_sum = ~NetCksum((uchar *)ip, IP_HDR_SIZE >> 1);
1289 ip->udp_src = htons(sport);
1290 ip->udp_dst = htons(dport);
1291 ip->udp_len = htons(UDP_HDR_SIZE + len);
1295 void copy_filename(char *dst, const char *src, int size)
1297 if (*src && (*src == '"')) {
1302 while ((--size > 0) && *src && (*src != '"'))
1307 #if defined(CONFIG_CMD_NFS) || \
1308 defined(CONFIG_CMD_SNTP) || \
1309 defined(CONFIG_CMD_DNS)
1311 * make port a little random (1024-17407)
1312 * This keeps the math somewhat trivial to compute, and seems to work with
1313 * all supported protocols/clients/servers
1315 unsigned int random_port(void)
1317 return 1024 + (get_timer(0) % 0x4000);
1321 void ip_to_string(IPaddr_t x, char *s)
1324 sprintf(s, "%d.%d.%d.%d",
1325 (int) ((x >> 24) & 0xff),
1326 (int) ((x >> 16) & 0xff),
1327 (int) ((x >> 8) & 0xff), (int) ((x >> 0) & 0xff)
1331 void VLAN_to_string(ushort x, char *s)
1335 if (x == (ushort)-1)
1341 sprintf(s, "%d", x & VLAN_IDMASK);
1344 ushort string_to_VLAN(const char *s)
1349 return htons(VLAN_NONE);
1351 if (*s < '0' || *s > '9')
1354 id = (ushort)simple_strtoul(s, NULL, 10);
1359 ushort getenv_VLAN(char *var)
1361 return string_to_VLAN(getenv(var));