wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copied from Linux Monitor (LiMon) - Networking. |
| 3 | * |
| 4 | * Copyright 1994 - 2000 Neil Russell. |
| 5 | * (See License) |
| 6 | * Copyright 2000 Roland Borde |
| 7 | * Copyright 2000 Paolo Scaffardi |
| 8 | * Copyright 2000-2002 Wolfgang Denk, wd@denx.de |
| 9 | */ |
| 10 | |
| 11 | /* |
| 12 | * General Desription: |
| 13 | * |
| 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: |
| 17 | * |
| 18 | * BOOTP: |
| 19 | * |
| 20 | * Prerequisites: - own ethernet address |
| 21 | * We want: - own IP address |
| 22 | * - TFTP server IP address |
| 23 | * - name of bootfile |
| 24 | * Next step: ARP |
| 25 | * |
| 26 | * RARP: |
| 27 | * |
| 28 | * Prerequisites: - own ethernet address |
| 29 | * We want: - own IP address |
| 30 | * - TFTP server IP address |
| 31 | * Next step: ARP |
| 32 | * |
| 33 | * ARP: |
| 34 | * |
| 35 | * Prerequisites: - own ethernet address |
| 36 | * - own IP address |
| 37 | * - TFTP server IP address |
| 38 | * We want: - TFTP server ethernet address |
| 39 | * Next step: TFTP |
| 40 | * |
| 41 | * DHCP: |
| 42 | * |
Wolfgang Denk | b2f5080 | 2005-08-12 23:43:12 +0200 | [diff] [blame] | 43 | * Prerequisites: - own ethernet address |
| 44 | * We want: - IP, Netmask, ServerIP, Gateway IP |
| 45 | * - bootfilename, lease time |
| 46 | * Next step: - TFTP |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 47 | * |
| 48 | * TFTP: |
| 49 | * |
| 50 | * Prerequisites: - own ethernet address |
| 51 | * - own IP 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 |
| 57 | * Next step: none |
wdenk | cbd8a35 | 2004-02-24 02:00:03 +0000 | [diff] [blame] | 58 | * |
| 59 | * NFS: |
| 60 | * |
| 61 | * Prerequisites: - own ethernet address |
| 62 | * - own IP 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 |
| 66 | * Next step: none |
wdenk | ea287de | 2005-04-01 00:25:43 +0000 | [diff] [blame] | 67 | * |
| 68 | * SNTP: |
| 69 | * |
Wolfgang Denk | b2f5080 | 2005-08-12 23:43:12 +0200 | [diff] [blame] | 70 | * Prerequisites: - own ethernet address |
wdenk | ea287de | 2005-04-01 00:25:43 +0000 | [diff] [blame] | 71 | * - own IP address |
| 72 | * We want: - network time |
| 73 | * Next step: none |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 74 | */ |
| 75 | |
| 76 | |
| 77 | #include <common.h> |
| 78 | #include <watchdog.h> |
| 79 | #include <command.h> |
| 80 | #include <net.h> |
| 81 | #include "bootp.h" |
| 82 | #include "tftp.h" |
Peter Tyser | bf6cb24 | 2010-09-30 11:25:48 -0500 | [diff] [blame] | 83 | #ifdef CONFIG_CMD_RARP |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 84 | #include "rarp.h" |
Peter Tyser | bf6cb24 | 2010-09-30 11:25:48 -0500 | [diff] [blame] | 85 | #endif |
wdenk | cbd8a35 | 2004-02-24 02:00:03 +0000 | [diff] [blame] | 86 | #include "nfs.h" |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 87 | #ifdef CONFIG_STATUS_LED |
| 88 | #include <status_led.h> |
| 89 | #include <miiphy.h> |
| 90 | #endif |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 91 | #if defined(CONFIG_CMD_SNTP) |
wdenk | ea287de | 2005-04-01 00:25:43 +0000 | [diff] [blame] | 92 | #include "sntp.h" |
| 93 | #endif |
Peter Tyser | 561858e | 2008-11-03 09:30:59 -0600 | [diff] [blame] | 94 | #if defined(CONFIG_CDP_VERSION) |
| 95 | #include <timestamp.h> |
| 96 | #endif |
Robin Getz | 1a32bf4 | 2009-07-20 14:53:54 -0400 | [diff] [blame] | 97 | #if defined(CONFIG_CMD_DNS) |
| 98 | #include "dns.h" |
| 99 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 100 | |
Wolfgang Denk | d87080b | 2006-03-31 18:32:53 +0200 | [diff] [blame] | 101 | DECLARE_GLOBAL_DATA_PTR; |
| 102 | |
Guennadi Liakhovetski | 40cb90e | 2008-04-03 17:04:19 +0200 | [diff] [blame] | 103 | #ifndef CONFIG_ARP_TIMEOUT |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 104 | /* Milliseconds before trying ARP again */ |
| 105 | # define ARP_TIMEOUT 5000UL |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 106 | #else |
Bartlomiej Sieka | 49f3bdb | 2008-10-01 15:26:28 +0200 | [diff] [blame] | 107 | # define ARP_TIMEOUT CONFIG_ARP_TIMEOUT |
Guennadi Liakhovetski | 40cb90e | 2008-04-03 17:04:19 +0200 | [diff] [blame] | 108 | #endif |
| 109 | |
| 110 | |
| 111 | #ifndef CONFIG_NET_RETRY_COUNT |
| 112 | # define ARP_TIMEOUT_COUNT 5 /* # of timeouts before giving up */ |
| 113 | #else |
| 114 | # define ARP_TIMEOUT_COUNT CONFIG_NET_RETRY_COUNT |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 115 | #endif |
| 116 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 117 | /** BOOTP EXTENTIONS **/ |
| 118 | |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 119 | /* Our subnet mask (0=unknown) */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 120 | IPaddr_t NetOurSubnetMask; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 121 | /* Our gateways IP address */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 122 | IPaddr_t NetOurGatewayIP; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 123 | /* Our DNS IP address */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 124 | IPaddr_t NetOurDNSIP; |
Jon Loeliger | 1fe80d7 | 2007-07-09 22:08:34 -0500 | [diff] [blame] | 125 | #if defined(CONFIG_BOOTP_DNS2) |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 126 | /* Our 2nd DNS IP address */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 127 | IPaddr_t NetOurDNS2IP; |
stroese | fe389a8 | 2003-08-28 14:17:32 +0000 | [diff] [blame] | 128 | #endif |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 129 | /* Our NIS domain */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 130 | char NetOurNISDomain[32] = {0,}; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 131 | /* Our hostname */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 132 | char NetOurHostName[32] = {0,}; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 133 | /* Our bootpath */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 134 | char NetOurRootPath[64] = {0,}; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 135 | /* Our bootfile size in blocks */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 136 | ushort NetBootFileSize; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 137 | |
David Updegraff | 53a5c42 | 2007-06-11 10:41:07 -0500 | [diff] [blame] | 138 | #ifdef CONFIG_MCAST_TFTP /* Multicast TFTP */ |
| 139 | IPaddr_t Mcast_addr; |
| 140 | #endif |
| 141 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 142 | /** END OF BOOTP EXTENTIONS **/ |
| 143 | |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 144 | /* The actual transferred size of the bootfile (in bytes) */ |
| 145 | ulong NetBootFileXferSize; |
| 146 | /* Our ethernet address */ |
| 147 | uchar NetOurEther[6]; |
| 148 | /* Boot server enet address */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 149 | uchar NetServerEther[6]; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 150 | /* Our IP addr (0 = unknown) */ |
| 151 | IPaddr_t NetOurIP; |
| 152 | /* Server IP addr (0 = unknown) */ |
| 153 | IPaddr_t NetServerIP; |
| 154 | /* Current receive packet */ |
| 155 | volatile uchar *NetRxPacket; |
| 156 | /* Current rx packet length */ |
| 157 | int NetRxPacketLen; |
| 158 | /* IP packet ID */ |
| 159 | unsigned NetIPID; |
| 160 | /* Ethernet bcast address */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 161 | uchar NetBcastAddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; |
| 162 | uchar NetEtherNullAddr[6]; |
Rafal Jaworowski | f85b607 | 2007-12-27 18:19:02 +0100 | [diff] [blame] | 163 | #ifdef CONFIG_API |
| 164 | void (*push_packet)(volatile void *, int len) = 0; |
| 165 | #endif |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 166 | #if defined(CONFIG_CMD_CDP) |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 167 | /* Ethernet bcast address */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 168 | uchar NetCDPAddr[6] = { 0x01, 0x00, 0x0c, 0xcc, 0xcc, 0xcc }; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 169 | #endif |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 170 | /* Network loop state */ |
| 171 | int NetState; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 172 | #ifdef CONFIG_NET_MULTI |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 173 | /* Tried all network devices */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 174 | int NetRestartWrap; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 175 | /* Network loop restarted */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 176 | static int NetRestarted; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 177 | /* At least one device configured */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 178 | static int NetDevExists; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 179 | #endif |
| 180 | |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 181 | /* XXX in both little & big endian machines 0xFFFF == ntohs(-1) */ |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 182 | /* default is without VLAN */ |
| 183 | ushort NetOurVLAN = 0xFFFF; |
| 184 | /* ditto */ |
| 185 | ushort NetOurNativeVLAN = 0xFFFF; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 186 | |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 187 | /* Boot File name */ |
| 188 | char BootFile[128]; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 189 | |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 190 | #if defined(CONFIG_CMD_PING) |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 191 | /* the ip address to ping */ |
| 192 | IPaddr_t NetPingIP; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 193 | |
| 194 | static void PingStart(void); |
| 195 | #endif |
| 196 | |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 197 | #if defined(CONFIG_CMD_CDP) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 198 | static void CDPStart(void); |
| 199 | #endif |
| 200 | |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 201 | #if defined(CONFIG_CMD_SNTP) |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 202 | /* NTP server IP address */ |
| 203 | IPaddr_t NetNtpServerIP; |
| 204 | /* offset time from UTC */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 205 | int NetTimeOffset; |
wdenk | ea287de | 2005-04-01 00:25:43 +0000 | [diff] [blame] | 206 | #endif |
| 207 | |
wdenk | 68ceb29 | 2004-08-02 21:11:11 +0000 | [diff] [blame] | 208 | #ifdef CONFIG_NETCONSOLE |
| 209 | void NcStart(void); |
| 210 | int nc_input_packet(uchar *pkt, unsigned dest, unsigned src, unsigned len); |
| 211 | #endif |
| 212 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 213 | volatile uchar PktBuf[(PKTBUFSRX+1) * PKTSIZE_ALIGN + PKTALIGN]; |
| 214 | |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 215 | /* Receive packet */ |
| 216 | volatile uchar *NetRxPackets[PKTBUFSRX]; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 217 | |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 218 | /* Current RX packet handler */ |
| 219 | static rxhand_f *packetHandler; |
| 220 | /* Current timeout handler */ |
| 221 | static thand_f *timeHandler; |
| 222 | /* Time base value */ |
| 223 | static ulong timeStart; |
| 224 | /* Current timeout value */ |
| 225 | static ulong timeDelta; |
| 226 | /* THE transmit packet */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 227 | volatile uchar *NetTxPacket; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 228 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 229 | static int net_check_prereq(proto_t protocol); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 230 | |
Remy Bohmer | 67b96e8 | 2009-10-28 22:13:39 +0100 | [diff] [blame] | 231 | static int NetTryCount; |
| 232 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 233 | /**********************************************************************/ |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 234 | |
| 235 | IPaddr_t NetArpWaitPacketIP; |
| 236 | IPaddr_t NetArpWaitReplyIP; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 237 | /* MAC address of waiting packet's destination */ |
| 238 | uchar *NetArpWaitPacketMAC; |
| 239 | /* THE transmit packet */ |
| 240 | uchar *NetArpWaitTxPacket; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 241 | int NetArpWaitTxPacketSize; |
Wolfgang Denk | 53677ef | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 242 | uchar NetArpWaitPacketBuf[PKTSIZE_ALIGN + PKTALIGN]; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 243 | ulong NetArpWaitTimerStart; |
| 244 | int NetArpWaitTry; |
| 245 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 246 | void ArpRequest(void) |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 247 | { |
| 248 | int i; |
| 249 | volatile uchar *pkt; |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 250 | ARP_t *arp; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 251 | |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 252 | debug("ARP broadcast %d\n", NetArpWaitTry); |
| 253 | |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 254 | pkt = NetTxPacket; |
| 255 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 256 | pkt += NetSetEther(pkt, NetBcastAddr, PROT_ARP); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 257 | |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 258 | arp = (ARP_t *) pkt; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 259 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 260 | arp->ar_hrd = htons(ARP_ETHER); |
| 261 | arp->ar_pro = htons(PROT_IP); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 262 | arp->ar_hln = 6; |
| 263 | arp->ar_pln = 4; |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 264 | arp->ar_op = htons(ARPOP_REQUEST); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 265 | |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 266 | /* source ET addr */ |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 267 | memcpy(&arp->ar_data[0], NetOurEther, 6); |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 268 | /* source IP addr */ |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 269 | NetWriteIP((uchar *) &arp->ar_data[6], NetOurIP); |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 270 | for (i = 10; i < 16; ++i) { |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 271 | /* dest ET addr = 0 */ |
| 272 | arp->ar_data[i] = 0; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 273 | } |
| 274 | |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 275 | if ((NetArpWaitPacketIP & NetOurSubnetMask) != |
| 276 | (NetOurIP & NetOurSubnetMask)) { |
| 277 | if (NetOurGatewayIP == 0) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 278 | puts("## Warning: gatewayip needed but not set\n"); |
Wolfgang Denk | d509b81 | 2006-03-12 01:13:30 +0100 | [diff] [blame] | 279 | NetArpWaitReplyIP = NetArpWaitPacketIP; |
| 280 | } else { |
| 281 | NetArpWaitReplyIP = NetOurGatewayIP; |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 282 | } |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 283 | } else { |
| 284 | NetArpWaitReplyIP = NetArpWaitPacketIP; |
| 285 | } |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 286 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 287 | NetWriteIP((uchar *) &arp->ar_data[16], NetArpWaitReplyIP); |
| 288 | (void) eth_send(NetTxPacket, (pkt - NetTxPacket) + ARP_HDR_SIZE); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 289 | } |
| 290 | |
| 291 | void ArpTimeoutCheck(void) |
| 292 | { |
| 293 | ulong t; |
| 294 | |
| 295 | if (!NetArpWaitPacketIP) |
| 296 | return; |
| 297 | |
| 298 | t = get_timer(0); |
| 299 | |
| 300 | /* check for arp timeout */ |
Bartlomiej Sieka | 49f3bdb | 2008-10-01 15:26:28 +0200 | [diff] [blame] | 301 | if ((t - NetArpWaitTimerStart) > ARP_TIMEOUT) { |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 302 | NetArpWaitTry++; |
| 303 | |
| 304 | if (NetArpWaitTry >= ARP_TIMEOUT_COUNT) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 305 | puts("\nARP Retry count exceeded; starting again\n"); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 306 | NetArpWaitTry = 0; |
| 307 | NetStartAgain(); |
| 308 | } else { |
| 309 | NetArpWaitTimerStart = t; |
| 310 | ArpRequest(); |
| 311 | } |
| 312 | } |
| 313 | } |
| 314 | |
Heiko Schocher | da95427 | 2009-04-28 08:36:11 +0200 | [diff] [blame] | 315 | static void |
Heiko Schocher | 2f70c49 | 2009-02-10 09:38:52 +0100 | [diff] [blame] | 316 | NetInitLoop(proto_t protocol) |
| 317 | { |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 318 | static int env_changed_id; |
Heiko Schocher | 2f70c49 | 2009-02-10 09:38:52 +0100 | [diff] [blame] | 319 | bd_t *bd = gd->bd; |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 320 | int env_id = get_env_id(); |
Heiko Schocher | 2f70c49 | 2009-02-10 09:38:52 +0100 | [diff] [blame] | 321 | |
| 322 | /* update only when the environment has changed */ |
Michael Zaidman | 3c172c4 | 2009-04-04 01:43:00 +0300 | [diff] [blame] | 323 | if (env_changed_id != env_id) { |
Heiko Schocher | 2f70c49 | 2009-02-10 09:38:52 +0100 | [diff] [blame] | 324 | NetCopyIP(&NetOurIP, &bd->bi_ip_addr); |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 325 | NetOurGatewayIP = getenv_IPaddr("gatewayip"); |
| 326 | NetOurSubnetMask = getenv_IPaddr("netmask"); |
| 327 | NetServerIP = getenv_IPaddr("serverip"); |
Heiko Schocher | 2f70c49 | 2009-02-10 09:38:52 +0100 | [diff] [blame] | 328 | NetOurNativeVLAN = getenv_VLAN("nvlan"); |
Michael Zaidman | 3c172c4 | 2009-04-04 01:43:00 +0300 | [diff] [blame] | 329 | NetOurVLAN = getenv_VLAN("vlan"); |
Robin Getz | 1a32bf4 | 2009-07-20 14:53:54 -0400 | [diff] [blame] | 330 | #if defined(CONFIG_CMD_DNS) |
| 331 | NetOurDNSIP = getenv_IPaddr("dnsip"); |
| 332 | #endif |
Michael Zaidman | 3c172c4 | 2009-04-04 01:43:00 +0300 | [diff] [blame] | 333 | env_changed_id = env_id; |
Heiko Schocher | 2f70c49 | 2009-02-10 09:38:52 +0100 | [diff] [blame] | 334 | } |
Michael Zaidman | 3c172c4 | 2009-04-04 01:43:00 +0300 | [diff] [blame] | 335 | |
Heiko Schocher | da95427 | 2009-04-28 08:36:11 +0200 | [diff] [blame] | 336 | return; |
Heiko Schocher | 2f70c49 | 2009-02-10 09:38:52 +0100 | [diff] [blame] | 337 | } |
| 338 | |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 339 | /**********************************************************************/ |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 340 | /* |
| 341 | * Main network processing loop. |
| 342 | */ |
| 343 | |
| 344 | int |
| 345 | NetLoop(proto_t protocol) |
| 346 | { |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 347 | bd_t *bd = gd->bd; |
| 348 | |
| 349 | #ifdef CONFIG_NET_MULTI |
| 350 | NetRestarted = 0; |
| 351 | NetDevExists = 0; |
| 352 | #endif |
| 353 | |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 354 | /* XXX problem with bss workaround */ |
| 355 | NetArpWaitPacketMAC = NULL; |
| 356 | NetArpWaitTxPacket = NULL; |
| 357 | NetArpWaitPacketIP = 0; |
| 358 | NetArpWaitReplyIP = 0; |
| 359 | NetArpWaitTxPacket = NULL; |
| 360 | NetTxPacket = NULL; |
Remy Bohmer | 67b96e8 | 2009-10-28 22:13:39 +0100 | [diff] [blame] | 361 | NetTryCount = 1; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 362 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 363 | if (!NetTxPacket) { |
| 364 | int i; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 365 | /* |
| 366 | * Setup packet buffers, aligned correctly. |
| 367 | */ |
| 368 | NetTxPacket = &PktBuf[0] + (PKTALIGN - 1); |
| 369 | NetTxPacket -= (ulong)NetTxPacket % PKTALIGN; |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame^] | 370 | for (i = 0; i < PKTBUFSRX; i++) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 371 | NetRxPackets[i] = NetTxPacket + (i+1)*PKTSIZE_ALIGN; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 372 | } |
| 373 | |
| 374 | if (!NetArpWaitTxPacket) { |
| 375 | NetArpWaitTxPacket = &NetArpWaitPacketBuf[0] + (PKTALIGN - 1); |
| 376 | NetArpWaitTxPacket -= (ulong)NetArpWaitTxPacket % PKTALIGN; |
| 377 | NetArpWaitTxPacketSize = 0; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 378 | } |
| 379 | |
| 380 | eth_halt(); |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 381 | #ifdef CONFIG_NET_MULTI |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 382 | eth_set_current(); |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 383 | #endif |
wdenk | b1bf6f2 | 2005-04-03 14:52:59 +0000 | [diff] [blame] | 384 | if (eth_init(bd) < 0) { |
| 385 | eth_halt(); |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 386 | return(-1); |
wdenk | b1bf6f2 | 2005-04-03 14:52:59 +0000 | [diff] [blame] | 387 | } |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 388 | |
| 389 | restart: |
| 390 | #ifdef CONFIG_NET_MULTI |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 391 | memcpy(NetOurEther, eth_get_dev()->enetaddr, 6); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 392 | #else |
Mike Frysinger | 95823ca | 2009-02-11 18:23:48 -0500 | [diff] [blame] | 393 | eth_getenv_enetaddr("ethaddr", NetOurEther); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 394 | #endif |
| 395 | |
| 396 | NetState = NETLOOP_CONTINUE; |
| 397 | |
| 398 | /* |
| 399 | * Start the ball rolling with the given start function. From |
| 400 | * here on, this code is a state machine driven by received |
| 401 | * packets and timer events. |
| 402 | */ |
Heiko Schocher | 2f70c49 | 2009-02-10 09:38:52 +0100 | [diff] [blame] | 403 | NetInitLoop(protocol); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 404 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 405 | switch (net_check_prereq(protocol)) { |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 406 | case 1: |
| 407 | /* network not configured */ |
wdenk | b1bf6f2 | 2005-04-03 14:52:59 +0000 | [diff] [blame] | 408 | eth_halt(); |
wdenk | 1d0350e | 2002-11-11 21:14:20 +0000 | [diff] [blame] | 409 | return (-1); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 410 | |
| 411 | #ifdef CONFIG_NET_MULTI |
| 412 | case 2: |
| 413 | /* network device not configured */ |
| 414 | break; |
| 415 | #endif /* CONFIG_NET_MULTI */ |
| 416 | |
| 417 | case 0: |
| 418 | #ifdef CONFIG_NET_MULTI |
| 419 | NetDevExists = 1; |
| 420 | #endif |
| 421 | switch (protocol) { |
| 422 | case TFTP: |
| 423 | /* always use ARP to get server ethernet address */ |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 424 | TftpStart(); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 425 | break; |
| 426 | |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 427 | #if defined(CONFIG_CMD_DHCP) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 428 | case DHCP: |
wdenk | d407bf5 | 2004-10-11 22:51:13 +0000 | [diff] [blame] | 429 | BootpTry = 0; |
Michael Zaidman | 09133f8 | 2009-07-14 23:37:12 +0300 | [diff] [blame] | 430 | NetOurIP = 0; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 431 | DhcpRequest(); /* Basically same as BOOTP */ |
| 432 | break; |
Jon Loeliger | 610f2e9 | 2007-07-10 11:05:02 -0500 | [diff] [blame] | 433 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 434 | |
| 435 | case BOOTP: |
| 436 | BootpTry = 0; |
Michael Zaidman | 09133f8 | 2009-07-14 23:37:12 +0300 | [diff] [blame] | 437 | NetOurIP = 0; |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 438 | BootpRequest(); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 439 | break; |
| 440 | |
Peter Tyser | bf6cb24 | 2010-09-30 11:25:48 -0500 | [diff] [blame] | 441 | #if defined(CONFIG_CMD_RARP) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 442 | case RARP: |
| 443 | RarpTry = 0; |
Michael Zaidman | 09133f8 | 2009-07-14 23:37:12 +0300 | [diff] [blame] | 444 | NetOurIP = 0; |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 445 | RarpRequest(); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 446 | break; |
Peter Tyser | bf6cb24 | 2010-09-30 11:25:48 -0500 | [diff] [blame] | 447 | #endif |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 448 | #if defined(CONFIG_CMD_PING) |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 449 | case PING: |
| 450 | PingStart(); |
| 451 | break; |
| 452 | #endif |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 453 | #if defined(CONFIG_CMD_NFS) |
wdenk | cbd8a35 | 2004-02-24 02:00:03 +0000 | [diff] [blame] | 454 | case NFS: |
| 455 | NfsStart(); |
| 456 | break; |
| 457 | #endif |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 458 | #if defined(CONFIG_CMD_CDP) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 459 | case CDP: |
| 460 | CDPStart(); |
| 461 | break; |
| 462 | #endif |
wdenk | 68ceb29 | 2004-08-02 21:11:11 +0000 | [diff] [blame] | 463 | #ifdef CONFIG_NETCONSOLE |
| 464 | case NETCONS: |
| 465 | NcStart(); |
| 466 | break; |
| 467 | #endif |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 468 | #if defined(CONFIG_CMD_SNTP) |
wdenk | ea287de | 2005-04-01 00:25:43 +0000 | [diff] [blame] | 469 | case SNTP: |
| 470 | SntpStart(); |
| 471 | break; |
| 472 | #endif |
Robin Getz | 1a32bf4 | 2009-07-20 14:53:54 -0400 | [diff] [blame] | 473 | #if defined(CONFIG_CMD_DNS) |
| 474 | case DNS: |
| 475 | DnsStart(); |
| 476 | break; |
| 477 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 478 | default: |
| 479 | break; |
| 480 | } |
| 481 | |
| 482 | NetBootFileXferSize = 0; |
| 483 | break; |
| 484 | } |
| 485 | |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 486 | #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 487 | #if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \ |
| 488 | defined(CONFIG_STATUS_LED) && \ |
| 489 | defined(STATUS_LED_RED) |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 490 | /* |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 491 | * Echo the inverted link state to the fault LED. |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 492 | */ |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame^] | 493 | if (miiphy_link(eth_get_dev()->name, CONFIG_SYS_FAULT_MII_ADDR)) |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 494 | status_led_set(STATUS_LED_RED, STATUS_LED_OFF); |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame^] | 495 | else |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 496 | status_led_set(STATUS_LED_RED, STATUS_LED_ON); |
Jean-Christophe PLAGNIOL-VILLARD | 6d0f6bc | 2008-10-16 15:01:15 +0200 | [diff] [blame] | 497 | #endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */ |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 498 | #endif /* CONFIG_MII, ... */ |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 499 | |
| 500 | /* |
| 501 | * Main packet reception loop. Loop receiving packets until |
wdenk | 59acc29 | 2005-04-03 14:18:51 +0000 | [diff] [blame] | 502 | * someone sets `NetState' to a state that terminates. |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 503 | */ |
| 504 | for (;;) { |
| 505 | WATCHDOG_RESET(); |
| 506 | #ifdef CONFIG_SHOW_ACTIVITY |
| 507 | { |
| 508 | extern void show_activity(int arg); |
| 509 | show_activity(1); |
| 510 | } |
| 511 | #endif |
| 512 | /* |
| 513 | * Check the ethernet for a new packet. The ethernet |
| 514 | * receive routine will process it. |
| 515 | */ |
Guennadi Liakhovetski | 40cb90e | 2008-04-03 17:04:19 +0200 | [diff] [blame] | 516 | eth_rx(); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 517 | |
| 518 | /* |
| 519 | * Abort if ctrl-c was pressed. |
| 520 | */ |
| 521 | if (ctrlc()) { |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 522 | eth_halt(); |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 523 | puts("\nAbort\n"); |
wdenk | 1d0350e | 2002-11-11 21:14:20 +0000 | [diff] [blame] | 524 | return (-1); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 525 | } |
| 526 | |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 527 | ArpTimeoutCheck(); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 528 | |
| 529 | /* |
| 530 | * Check for a timeout, and run the timeout handler |
| 531 | * if we have one. |
| 532 | */ |
wdenk | e0ac62d | 2003-08-17 18:55:18 +0000 | [diff] [blame] | 533 | if (timeHandler && ((get_timer(0) - timeStart) > timeDelta)) { |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 534 | thand_f *x; |
| 535 | |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 536 | #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 537 | #if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \ |
| 538 | defined(CONFIG_STATUS_LED) && \ |
| 539 | defined(STATUS_LED_RED) |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 540 | /* |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 541 | * Echo the inverted link state to the fault LED. |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 542 | */ |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 543 | if (miiphy_link(eth_get_dev()->name, |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 544 | CONFIG_SYS_FAULT_MII_ADDR)) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 545 | status_led_set(STATUS_LED_RED, STATUS_LED_OFF); |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 546 | } else { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 547 | status_led_set(STATUS_LED_RED, STATUS_LED_ON); |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 548 | } |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 549 | #endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */ |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 550 | #endif /* CONFIG_MII, ... */ |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 551 | x = timeHandler; |
| 552 | timeHandler = (thand_f *)0; |
| 553 | (*x)(); |
| 554 | } |
| 555 | |
| 556 | |
| 557 | switch (NetState) { |
| 558 | |
| 559 | case NETLOOP_RESTART: |
| 560 | #ifdef CONFIG_NET_MULTI |
| 561 | NetRestarted = 1; |
| 562 | #endif |
| 563 | goto restart; |
| 564 | |
| 565 | case NETLOOP_SUCCESS: |
| 566 | if (NetBootFileXferSize > 0) { |
Wolfgang Denk | f34024d | 2007-09-12 00:48:57 +0200 | [diff] [blame] | 567 | char buf[20]; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 568 | printf("Bytes transferred = %ld (%lx hex)\n", |
| 569 | NetBootFileXferSize, |
| 570 | NetBootFileXferSize); |
Wolfgang Denk | f34024d | 2007-09-12 00:48:57 +0200 | [diff] [blame] | 571 | sprintf(buf, "%lX", NetBootFileXferSize); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 572 | setenv("filesize", buf); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 573 | |
| 574 | sprintf(buf, "%lX", (unsigned long)load_addr); |
| 575 | setenv("fileaddr", buf); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 576 | } |
| 577 | eth_halt(); |
| 578 | return NetBootFileXferSize; |
| 579 | |
| 580 | case NETLOOP_FAIL: |
wdenk | 1d0350e | 2002-11-11 21:14:20 +0000 | [diff] [blame] | 581 | return (-1); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 582 | } |
| 583 | } |
| 584 | } |
| 585 | |
| 586 | /**********************************************************************/ |
| 587 | |
| 588 | static void |
| 589 | startAgainTimeout(void) |
| 590 | { |
| 591 | NetState = NETLOOP_RESTART; |
| 592 | } |
| 593 | |
| 594 | static void |
Luca Ceresoli | 03eb129 | 2011-04-18 06:19:50 +0000 | [diff] [blame] | 595 | startAgainHandler(uchar *pkt, unsigned dest, IPaddr_t sip, |
| 596 | unsigned src, unsigned len) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 597 | { |
| 598 | /* Totally ignore the packet */ |
| 599 | } |
| 600 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 601 | void NetStartAgain(void) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 602 | { |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 603 | char *nretry; |
Remy Bohmer | 67b96e8 | 2009-10-28 22:13:39 +0100 | [diff] [blame] | 604 | int retry_forever = 0; |
| 605 | unsigned long retrycnt = 0; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 606 | |
Remy Bohmer | 67b96e8 | 2009-10-28 22:13:39 +0100 | [diff] [blame] | 607 | nretry = getenv("netretry"); |
| 608 | if (nretry) { |
| 609 | if (!strcmp(nretry, "yes")) |
| 610 | retry_forever = 1; |
| 611 | else if (!strcmp(nretry, "no")) |
| 612 | retrycnt = 0; |
| 613 | else if (!strcmp(nretry, "once")) |
| 614 | retrycnt = 1; |
| 615 | else |
| 616 | retrycnt = simple_strtoul(nretry, NULL, 0); |
| 617 | } else |
| 618 | retry_forever = 1; |
| 619 | |
| 620 | if ((!retry_forever) && (NetTryCount >= retrycnt)) { |
| 621 | eth_halt(); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 622 | NetState = NETLOOP_FAIL; |
| 623 | return; |
| 624 | } |
Remy Bohmer | 67b96e8 | 2009-10-28 22:13:39 +0100 | [diff] [blame] | 625 | |
| 626 | NetTryCount++; |
| 627 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 628 | #ifndef CONFIG_NET_MULTI |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 629 | NetSetTimeout(10000UL, startAgainTimeout); |
| 630 | NetSetHandler(startAgainHandler); |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 631 | #else /* !CONFIG_NET_MULTI*/ |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 632 | eth_halt(); |
Matthias Fuchs | 8b0c5c1 | 2007-12-27 16:58:41 +0100 | [diff] [blame] | 633 | #if !defined(CONFIG_NET_DO_NOT_TRY_ANOTHER) |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 634 | eth_try_another(!NetRestarted); |
Matthias Fuchs | 8b0c5c1 | 2007-12-27 16:58:41 +0100 | [diff] [blame] | 635 | #endif |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 636 | eth_init(gd->bd); |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 637 | if (NetRestartWrap) { |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 638 | NetRestartWrap = 0; |
Remy Bohmer | 67b96e8 | 2009-10-28 22:13:39 +0100 | [diff] [blame] | 639 | if (NetDevExists) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 640 | NetSetTimeout(10000UL, startAgainTimeout); |
| 641 | NetSetHandler(startAgainHandler); |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 642 | } else { |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 643 | NetState = NETLOOP_FAIL; |
| 644 | } |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 645 | } else { |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 646 | NetState = NETLOOP_RESTART; |
| 647 | } |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 648 | #endif /* CONFIG_NET_MULTI */ |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 649 | } |
| 650 | |
| 651 | /**********************************************************************/ |
| 652 | /* |
| 653 | * Miscelaneous bits. |
| 654 | */ |
| 655 | |
| 656 | void |
| 657 | NetSetHandler(rxhand_f * f) |
| 658 | { |
| 659 | packetHandler = f; |
| 660 | } |
| 661 | |
| 662 | |
| 663 | void |
wdenk | 3e01d75 | 2004-10-09 21:56:21 +0000 | [diff] [blame] | 664 | NetSetTimeout(ulong iv, thand_f * f) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 665 | { |
| 666 | if (iv == 0) { |
| 667 | timeHandler = (thand_f *)0; |
| 668 | } else { |
| 669 | timeHandler = f; |
wdenk | e0ac62d | 2003-08-17 18:55:18 +0000 | [diff] [blame] | 670 | timeStart = get_timer(0); |
| 671 | timeDelta = iv; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 672 | } |
| 673 | } |
| 674 | |
| 675 | |
| 676 | void |
| 677 | NetSendPacket(volatile uchar * pkt, int len) |
| 678 | { |
| 679 | (void) eth_send(pkt, len); |
| 680 | } |
| 681 | |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 682 | int |
| 683 | NetSendUDPPacket(uchar *ether, IPaddr_t dest, int dport, int sport, int len) |
| 684 | { |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 685 | uchar *pkt; |
| 686 | |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 687 | /* convert to new style broadcast */ |
| 688 | if (dest == 0) |
| 689 | dest = 0xFFFFFFFF; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 690 | |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 691 | /* if broadcast, make the ether address a broadcast and don't do ARP */ |
| 692 | if (dest == 0xFFFFFFFF) |
| 693 | ether = NetBcastAddr; |
| 694 | |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 695 | /* |
| 696 | * if MAC address was not discovered yet, save the packet and do |
| 697 | * an ARP request |
| 698 | */ |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 699 | if (memcmp(ether, NetEtherNullAddr, 6) == 0) { |
| 700 | |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 701 | debug("sending ARP for %08lx\n", dest); |
| 702 | |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 703 | NetArpWaitPacketIP = dest; |
| 704 | NetArpWaitPacketMAC = ether; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 705 | |
| 706 | pkt = NetArpWaitTxPacket; |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 707 | pkt += NetSetEther(pkt, NetArpWaitPacketMAC, PROT_IP); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 708 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 709 | NetSetIP(pkt, dest, dport, sport, len); |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 710 | memcpy(pkt + IP_HDR_SIZE, (uchar *)NetTxPacket + |
| 711 | (pkt - (uchar *)NetArpWaitTxPacket) + IP_HDR_SIZE, len); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 712 | |
| 713 | /* size of the waiting packet */ |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 714 | NetArpWaitTxPacketSize = (pkt - NetArpWaitTxPacket) + |
| 715 | IP_HDR_SIZE + len; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 716 | |
| 717 | /* and do the ARP request */ |
| 718 | NetArpWaitTry = 1; |
| 719 | NetArpWaitTimerStart = get_timer(0); |
| 720 | ArpRequest(); |
| 721 | return 1; /* waiting */ |
| 722 | } |
| 723 | |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 724 | debug("sending UDP to %08lx/%pM\n", dest, ether); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 725 | |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 726 | pkt = (uchar *)NetTxPacket; |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 727 | pkt += NetSetEther(pkt, ether, PROT_IP); |
| 728 | NetSetIP(pkt, dest, dport, sport, len); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 729 | (void) eth_send(NetTxPacket, (pkt - NetTxPacket) + IP_HDR_SIZE + len); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 730 | |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 731 | return 0; /* transmitted */ |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 732 | } |
| 733 | |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 734 | #if defined(CONFIG_CMD_PING) |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 735 | static ushort PingSeqNo; |
| 736 | |
| 737 | int PingSend(void) |
| 738 | { |
| 739 | static uchar mac[6]; |
| 740 | volatile IP_t *ip; |
| 741 | volatile ushort *s; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 742 | uchar *pkt; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 743 | |
| 744 | /* XXX always send arp request */ |
| 745 | |
| 746 | memcpy(mac, NetEtherNullAddr, 6); |
| 747 | |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 748 | debug("sending ARP for %08lx\n", NetPingIP); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 749 | |
| 750 | NetArpWaitPacketIP = NetPingIP; |
| 751 | NetArpWaitPacketMAC = mac; |
| 752 | |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 753 | pkt = NetArpWaitTxPacket; |
| 754 | pkt += NetSetEther(pkt, mac, PROT_IP); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 755 | |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 756 | ip = (volatile IP_t *)pkt; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 757 | |
| 758 | /* |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 759 | * Construct an IP and ICMP header. |
| 760 | * (need to set no fragment bit - XXX) |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 761 | */ |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 762 | /* IP_HDR_SIZE / 4 (not including UDP) */ |
| 763 | ip->ip_hl_v = 0x45; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 764 | ip->ip_tos = 0; |
| 765 | ip->ip_len = htons(IP_HDR_SIZE_NO_UDP + 8); |
| 766 | ip->ip_id = htons(NetIPID++); |
Peter Tyser | e0c07b8 | 2008-12-01 16:26:20 -0600 | [diff] [blame] | 767 | ip->ip_off = htons(IP_FLAGS_DFRAG); /* Don't fragment */ |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 768 | ip->ip_ttl = 255; |
| 769 | ip->ip_p = 0x01; /* ICMP */ |
| 770 | ip->ip_sum = 0; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 771 | /* already in network byte order */ |
| 772 | NetCopyIP((void*)&ip->ip_src, &NetOurIP); |
| 773 | /* - "" - */ |
| 774 | NetCopyIP((void*)&ip->ip_dst, &NetPingIP); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 775 | ip->ip_sum = ~NetCksum((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2); |
| 776 | |
| 777 | s = &ip->udp_src; /* XXX ICMP starts here */ |
| 778 | s[0] = htons(0x0800); /* echo-request, code */ |
| 779 | s[1] = 0; /* checksum */ |
Wolfgang Denk | 53677ef | 2008-05-20 16:00:29 +0200 | [diff] [blame] | 780 | s[2] = 0; /* identifier */ |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 781 | s[3] = htons(PingSeqNo++); /* sequence number */ |
| 782 | s[1] = ~NetCksum((uchar *)s, 8/2); |
| 783 | |
| 784 | /* size of the waiting packet */ |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 785 | NetArpWaitTxPacketSize = |
| 786 | (pkt - NetArpWaitTxPacket) + IP_HDR_SIZE_NO_UDP + 8; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 787 | |
| 788 | /* and do the ARP request */ |
| 789 | NetArpWaitTry = 1; |
| 790 | NetArpWaitTimerStart = get_timer(0); |
| 791 | ArpRequest(); |
| 792 | return 1; /* waiting */ |
| 793 | } |
| 794 | |
| 795 | static void |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 796 | PingTimeout(void) |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 797 | { |
| 798 | eth_halt(); |
| 799 | NetState = NETLOOP_FAIL; /* we did not get the reply */ |
| 800 | } |
| 801 | |
| 802 | static void |
Luca Ceresoli | 03eb129 | 2011-04-18 06:19:50 +0000 | [diff] [blame] | 803 | PingHandler(uchar *pkt, unsigned dest, IPaddr_t sip, unsigned src, |
| 804 | unsigned len) |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 805 | { |
Luca Ceresoli | 03eb129 | 2011-04-18 06:19:50 +0000 | [diff] [blame] | 806 | if (sip != NetPingIP) |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 807 | return; |
| 808 | |
| 809 | NetState = NETLOOP_SUCCESS; |
| 810 | } |
| 811 | |
| 812 | static void PingStart(void) |
| 813 | { |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 814 | #if defined(CONFIG_NET_MULTI) |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 815 | printf("Using %s device\n", eth_get_name()); |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 816 | #endif /* CONFIG_NET_MULTI */ |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 817 | NetSetTimeout(10000UL, PingTimeout); |
| 818 | NetSetHandler(PingHandler); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 819 | |
| 820 | PingSend(); |
| 821 | } |
Jon Loeliger | 610f2e9 | 2007-07-10 11:05:02 -0500 | [diff] [blame] | 822 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 823 | |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 824 | #if defined(CONFIG_CMD_CDP) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 825 | |
| 826 | #define CDP_DEVICE_ID_TLV 0x0001 |
| 827 | #define CDP_ADDRESS_TLV 0x0002 |
| 828 | #define CDP_PORT_ID_TLV 0x0003 |
| 829 | #define CDP_CAPABILITIES_TLV 0x0004 |
| 830 | #define CDP_VERSION_TLV 0x0005 |
| 831 | #define CDP_PLATFORM_TLV 0x0006 |
| 832 | #define CDP_NATIVE_VLAN_TLV 0x000a |
| 833 | #define CDP_APPLIANCE_VLAN_TLV 0x000e |
| 834 | #define CDP_TRIGGER_TLV 0x000f |
| 835 | #define CDP_POWER_CONSUMPTION_TLV 0x0010 |
| 836 | #define CDP_SYSNAME_TLV 0x0014 |
| 837 | #define CDP_SYSOBJECT_TLV 0x0015 |
| 838 | #define CDP_MANAGEMENT_ADDRESS_TLV 0x0016 |
| 839 | |
Bartlomiej Sieka | 49f3bdb | 2008-10-01 15:26:28 +0200 | [diff] [blame] | 840 | #define CDP_TIMEOUT 250UL /* one packet every 250ms */ |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 841 | |
| 842 | static int CDPSeq; |
| 843 | static int CDPOK; |
| 844 | |
| 845 | ushort CDPNativeVLAN; |
| 846 | ushort CDPApplianceVLAN; |
| 847 | |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 848 | static const uchar CDP_SNAP_hdr[8] = { 0xAA, 0xAA, 0x03, 0x00, 0x00, 0x0C, 0x20, |
| 849 | 0x00 }; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 850 | |
| 851 | static ushort CDP_compute_csum(const uchar *buff, ushort len) |
| 852 | { |
| 853 | ushort csum; |
| 854 | int odd; |
| 855 | ulong result = 0; |
| 856 | ushort leftover; |
Wolfgang Denk | 77ddac9 | 2005-10-13 16:45:02 +0200 | [diff] [blame] | 857 | ushort *p; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 858 | |
| 859 | if (len > 0) { |
| 860 | odd = 1 & (ulong)buff; |
| 861 | if (odd) { |
| 862 | result = *buff << 8; |
| 863 | len--; |
| 864 | buff++; |
| 865 | } |
| 866 | while (len > 1) { |
Wolfgang Denk | 77ddac9 | 2005-10-13 16:45:02 +0200 | [diff] [blame] | 867 | p = (ushort *)buff; |
| 868 | result += *p++; |
| 869 | buff = (uchar *)p; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 870 | if (result & 0x80000000) |
| 871 | result = (result & 0xFFFF) + (result >> 16); |
| 872 | len -= 2; |
| 873 | } |
| 874 | if (len) { |
| 875 | leftover = (signed short)(*(const signed char *)buff); |
Wolfgang Denk | 3ada834 | 2005-11-10 20:59:46 +0100 | [diff] [blame] | 876 | /* CISCO SUCKS big time! (and blows too): |
| 877 | * CDP uses the IP checksum algorithm with a twist; |
| 878 | * for the last byte it *sign* extends and sums. |
| 879 | */ |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 880 | result = (result & 0xffff0000) | |
| 881 | ((result + leftover) & 0x0000ffff); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 882 | } |
| 883 | while (result >> 16) |
| 884 | result = (result & 0xFFFF) + (result >> 16); |
| 885 | |
| 886 | if (odd) |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 887 | result = ((result >> 8) & 0xff) | |
| 888 | ((result & 0xff) << 8); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 889 | } |
| 890 | |
| 891 | /* add up 16-bit and 17-bit words for 17+c bits */ |
| 892 | result = (result & 0xffff) + (result >> 16); |
| 893 | /* add up 16-bit and 2-bit for 16+c bit */ |
| 894 | result = (result & 0xffff) + (result >> 16); |
| 895 | /* add up carry.. */ |
| 896 | result = (result & 0xffff) + (result >> 16); |
| 897 | |
| 898 | /* negate */ |
| 899 | csum = ~(ushort)result; |
| 900 | |
| 901 | /* run time endian detection */ |
| 902 | if (csum != htons(csum)) /* little endian */ |
| 903 | csum = htons(csum); |
| 904 | |
| 905 | return csum; |
| 906 | } |
| 907 | |
| 908 | int CDPSendTrigger(void) |
| 909 | { |
| 910 | volatile uchar *pkt; |
| 911 | volatile ushort *s; |
| 912 | volatile ushort *cp; |
| 913 | Ethernet_t *et; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 914 | int len; |
| 915 | ushort chksum; |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 916 | #if defined(CONFIG_CDP_DEVICE_ID) || defined(CONFIG_CDP_PORT_ID) || \ |
| 917 | defined(CONFIG_CDP_VERSION) || defined(CONFIG_CDP_PLATFORM) |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 918 | char buf[32]; |
| 919 | #endif |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 920 | |
| 921 | pkt = NetTxPacket; |
| 922 | et = (Ethernet_t *)pkt; |
| 923 | |
| 924 | /* NOTE: trigger sent not on any VLAN */ |
| 925 | |
| 926 | /* form ethernet header */ |
| 927 | memcpy(et->et_dest, NetCDPAddr, 6); |
| 928 | memcpy(et->et_src, NetOurEther, 6); |
| 929 | |
| 930 | pkt += ETHER_HDR_SIZE; |
| 931 | |
| 932 | /* SNAP header */ |
| 933 | memcpy((uchar *)pkt, CDP_SNAP_hdr, sizeof(CDP_SNAP_hdr)); |
| 934 | pkt += sizeof(CDP_SNAP_hdr); |
| 935 | |
| 936 | /* CDP header */ |
| 937 | *pkt++ = 0x02; /* CDP version 2 */ |
| 938 | *pkt++ = 180; /* TTL */ |
| 939 | s = (volatile ushort *)pkt; |
| 940 | cp = s; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 941 | /* checksum (0 for later calculation) */ |
| 942 | *s++ = htons(0); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 943 | |
| 944 | /* CDP fields */ |
| 945 | #ifdef CONFIG_CDP_DEVICE_ID |
| 946 | *s++ = htons(CDP_DEVICE_ID_TLV); |
| 947 | *s++ = htons(CONFIG_CDP_DEVICE_ID); |
Mike Frysinger | 95823ca | 2009-02-11 18:23:48 -0500 | [diff] [blame] | 948 | sprintf(buf, CONFIG_CDP_DEVICE_ID_PREFIX "%pm", NetOurEther); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 949 | memcpy((uchar *)s, buf, 16); |
| 950 | s += 16 / 2; |
| 951 | #endif |
| 952 | |
| 953 | #ifdef CONFIG_CDP_PORT_ID |
| 954 | *s++ = htons(CDP_PORT_ID_TLV); |
| 955 | memset(buf, 0, sizeof(buf)); |
| 956 | sprintf(buf, CONFIG_CDP_PORT_ID, eth_get_dev_index()); |
| 957 | len = strlen(buf); |
| 958 | if (len & 1) /* make it even */ |
| 959 | len++; |
| 960 | *s++ = htons(len + 4); |
| 961 | memcpy((uchar *)s, buf, len); |
| 962 | s += len / 2; |
| 963 | #endif |
| 964 | |
| 965 | #ifdef CONFIG_CDP_CAPABILITIES |
| 966 | *s++ = htons(CDP_CAPABILITIES_TLV); |
| 967 | *s++ = htons(8); |
| 968 | *(ulong *)s = htonl(CONFIG_CDP_CAPABILITIES); |
| 969 | s += 2; |
| 970 | #endif |
| 971 | |
| 972 | #ifdef CONFIG_CDP_VERSION |
| 973 | *s++ = htons(CDP_VERSION_TLV); |
| 974 | memset(buf, 0, sizeof(buf)); |
| 975 | strcpy(buf, CONFIG_CDP_VERSION); |
| 976 | len = strlen(buf); |
| 977 | if (len & 1) /* make it even */ |
| 978 | len++; |
| 979 | *s++ = htons(len + 4); |
| 980 | memcpy((uchar *)s, buf, len); |
| 981 | s += len / 2; |
| 982 | #endif |
| 983 | |
| 984 | #ifdef CONFIG_CDP_PLATFORM |
| 985 | *s++ = htons(CDP_PLATFORM_TLV); |
| 986 | memset(buf, 0, sizeof(buf)); |
| 987 | strcpy(buf, CONFIG_CDP_PLATFORM); |
| 988 | len = strlen(buf); |
| 989 | if (len & 1) /* make it even */ |
| 990 | len++; |
| 991 | *s++ = htons(len + 4); |
| 992 | memcpy((uchar *)s, buf, len); |
| 993 | s += len / 2; |
| 994 | #endif |
| 995 | |
| 996 | #ifdef CONFIG_CDP_TRIGGER |
| 997 | *s++ = htons(CDP_TRIGGER_TLV); |
| 998 | *s++ = htons(8); |
| 999 | *(ulong *)s = htonl(CONFIG_CDP_TRIGGER); |
| 1000 | s += 2; |
| 1001 | #endif |
| 1002 | |
| 1003 | #ifdef CONFIG_CDP_POWER_CONSUMPTION |
| 1004 | *s++ = htons(CDP_POWER_CONSUMPTION_TLV); |
| 1005 | *s++ = htons(6); |
| 1006 | *s++ = htons(CONFIG_CDP_POWER_CONSUMPTION); |
| 1007 | #endif |
| 1008 | |
| 1009 | /* length of ethernet packet */ |
| 1010 | len = (uchar *)s - ((uchar *)NetTxPacket + ETHER_HDR_SIZE); |
| 1011 | et->et_protlen = htons(len); |
| 1012 | |
| 1013 | len = ETHER_HDR_SIZE + sizeof(CDP_SNAP_hdr); |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1014 | chksum = CDP_compute_csum((uchar *)NetTxPacket + len, |
| 1015 | (uchar *)s - (NetTxPacket + len)); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1016 | if (chksum == 0) |
| 1017 | chksum = 0xFFFF; |
| 1018 | *cp = htons(chksum); |
| 1019 | |
| 1020 | (void) eth_send(NetTxPacket, (uchar *)s - NetTxPacket); |
| 1021 | return 0; |
| 1022 | } |
| 1023 | |
| 1024 | static void |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1025 | CDPTimeout(void) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1026 | { |
| 1027 | CDPSeq++; |
| 1028 | |
| 1029 | if (CDPSeq < 3) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1030 | NetSetTimeout(CDP_TIMEOUT, CDPTimeout); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1031 | CDPSendTrigger(); |
| 1032 | return; |
| 1033 | } |
| 1034 | |
| 1035 | /* if not OK try again */ |
| 1036 | if (!CDPOK) |
| 1037 | NetStartAgain(); |
| 1038 | else |
| 1039 | NetState = NETLOOP_SUCCESS; |
| 1040 | } |
| 1041 | |
| 1042 | static void |
Luca Ceresoli | 03eb129 | 2011-04-18 06:19:50 +0000 | [diff] [blame] | 1043 | CDPDummyHandler(uchar *pkt, unsigned dest, IPaddr_t sip, unsigned src, |
| 1044 | unsigned len) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1045 | { |
| 1046 | /* nothing */ |
| 1047 | } |
| 1048 | |
| 1049 | static void |
| 1050 | CDPHandler(const uchar * pkt, unsigned len) |
| 1051 | { |
| 1052 | const uchar *t; |
| 1053 | const ushort *ss; |
| 1054 | ushort type, tlen; |
| 1055 | uchar applid; |
| 1056 | ushort vlan, nvlan; |
| 1057 | |
| 1058 | /* minimum size? */ |
| 1059 | if (len < sizeof(CDP_SNAP_hdr) + 4) |
| 1060 | goto pkt_short; |
| 1061 | |
| 1062 | /* check for valid CDP SNAP header */ |
| 1063 | if (memcmp(pkt, CDP_SNAP_hdr, sizeof(CDP_SNAP_hdr)) != 0) |
| 1064 | return; |
| 1065 | |
| 1066 | pkt += sizeof(CDP_SNAP_hdr); |
| 1067 | len -= sizeof(CDP_SNAP_hdr); |
| 1068 | |
| 1069 | /* Version of CDP protocol must be >= 2 and TTL != 0 */ |
| 1070 | if (pkt[0] < 0x02 || pkt[1] == 0) |
| 1071 | return; |
| 1072 | |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1073 | /* |
| 1074 | * if version is greater than 0x02 maybe we'll have a problem; |
| 1075 | * output a warning |
| 1076 | */ |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1077 | if (pkt[0] != 0x02) |
| 1078 | printf("** WARNING: CDP packet received with a protocol version %d > 2\n", |
| 1079 | pkt[0] & 0xff); |
| 1080 | |
| 1081 | if (CDP_compute_csum(pkt, len) != 0) |
| 1082 | return; |
| 1083 | |
| 1084 | pkt += 4; |
| 1085 | len -= 4; |
| 1086 | |
| 1087 | vlan = htons(-1); |
| 1088 | nvlan = htons(-1); |
| 1089 | while (len > 0) { |
| 1090 | if (len < 4) |
| 1091 | goto pkt_short; |
| 1092 | |
| 1093 | ss = (const ushort *)pkt; |
| 1094 | type = ntohs(ss[0]); |
| 1095 | tlen = ntohs(ss[1]); |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame^] | 1096 | if (tlen > len) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1097 | goto pkt_short; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1098 | |
| 1099 | pkt += tlen; |
| 1100 | len -= tlen; |
| 1101 | |
| 1102 | ss += 2; /* point ss to the data of the TLV */ |
| 1103 | tlen -= 4; |
| 1104 | |
| 1105 | switch (type) { |
| 1106 | case CDP_DEVICE_ID_TLV: |
| 1107 | break; |
| 1108 | case CDP_ADDRESS_TLV: |
| 1109 | break; |
| 1110 | case CDP_PORT_ID_TLV: |
| 1111 | break; |
| 1112 | case CDP_CAPABILITIES_TLV: |
| 1113 | break; |
| 1114 | case CDP_VERSION_TLV: |
| 1115 | break; |
| 1116 | case CDP_PLATFORM_TLV: |
| 1117 | break; |
| 1118 | case CDP_NATIVE_VLAN_TLV: |
| 1119 | nvlan = *ss; |
| 1120 | break; |
| 1121 | case CDP_APPLIANCE_VLAN_TLV: |
| 1122 | t = (const uchar *)ss; |
| 1123 | while (tlen > 0) { |
| 1124 | if (tlen < 3) |
| 1125 | goto pkt_short; |
| 1126 | |
| 1127 | applid = t[0]; |
| 1128 | ss = (const ushort *)(t + 1); |
| 1129 | |
| 1130 | #ifdef CONFIG_CDP_APPLIANCE_VLAN_TYPE |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1131 | if (applid == |
| 1132 | CONFIG_CDP_APPLIANCE_VLAN_TYPE) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1133 | vlan = *ss; |
| 1134 | #else |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1135 | /* XXX will this work; dunno */ |
| 1136 | vlan = ntohs(*ss); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1137 | #endif |
| 1138 | t += 3; tlen -= 3; |
| 1139 | } |
| 1140 | break; |
| 1141 | case CDP_TRIGGER_TLV: |
| 1142 | break; |
| 1143 | case CDP_POWER_CONSUMPTION_TLV: |
| 1144 | break; |
| 1145 | case CDP_SYSNAME_TLV: |
| 1146 | break; |
| 1147 | case CDP_SYSOBJECT_TLV: |
| 1148 | break; |
| 1149 | case CDP_MANAGEMENT_ADDRESS_TLV: |
| 1150 | break; |
| 1151 | } |
| 1152 | } |
| 1153 | |
| 1154 | CDPApplianceVLAN = vlan; |
| 1155 | CDPNativeVLAN = nvlan; |
| 1156 | |
| 1157 | CDPOK = 1; |
| 1158 | return; |
| 1159 | |
| 1160 | pkt_short: |
| 1161 | printf("** CDP packet is too short\n"); |
| 1162 | return; |
| 1163 | } |
| 1164 | |
| 1165 | static void CDPStart(void) |
| 1166 | { |
| 1167 | #if defined(CONFIG_NET_MULTI) |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1168 | printf("Using %s device\n", eth_get_name()); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1169 | #endif |
| 1170 | CDPSeq = 0; |
| 1171 | CDPOK = 0; |
| 1172 | |
| 1173 | CDPNativeVLAN = htons(-1); |
| 1174 | CDPApplianceVLAN = htons(-1); |
| 1175 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1176 | NetSetTimeout(CDP_TIMEOUT, CDPTimeout); |
| 1177 | NetSetHandler(CDPDummyHandler); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1178 | |
| 1179 | CDPSendTrigger(); |
| 1180 | } |
Jon Loeliger | 610f2e9 | 2007-07-10 11:05:02 -0500 | [diff] [blame] | 1181 | #endif |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1182 | |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1183 | #ifdef CONFIG_IP_DEFRAG |
| 1184 | /* |
| 1185 | * This function collects fragments in a single packet, according |
| 1186 | * to the algorithm in RFC815. It returns NULL or the pointer to |
| 1187 | * a complete packet, in static storage |
| 1188 | */ |
| 1189 | #ifndef CONFIG_NET_MAXDEFRAG |
| 1190 | #define CONFIG_NET_MAXDEFRAG 16384 |
| 1191 | #endif |
| 1192 | /* |
| 1193 | * MAXDEFRAG, above, is chosen in the config file and is real data |
| 1194 | * so we need to add the NFS overhead, which is more than TFTP. |
| 1195 | * To use sizeof in the internal unnamed structures, we need a real |
| 1196 | * instance (can't do "sizeof(struct rpc_t.u.reply))", unfortunately). |
| 1197 | * The compiler doesn't complain nor allocates the actual structure |
| 1198 | */ |
| 1199 | static struct rpc_t rpc_specimen; |
| 1200 | #define IP_PKTSIZE (CONFIG_NET_MAXDEFRAG + sizeof(rpc_specimen.u.reply)) |
| 1201 | |
| 1202 | #define IP_MAXUDP (IP_PKTSIZE - IP_HDR_SIZE_NO_UDP) |
| 1203 | |
| 1204 | /* |
| 1205 | * this is the packet being assembled, either data or frag control. |
| 1206 | * Fragments go by 8 bytes, so this union must be 8 bytes long |
| 1207 | */ |
| 1208 | struct hole { |
| 1209 | /* first_byte is address of this structure */ |
| 1210 | u16 last_byte; /* last byte in this hole + 1 (begin of next hole) */ |
| 1211 | u16 next_hole; /* index of next (in 8-b blocks), 0 == none */ |
| 1212 | u16 prev_hole; /* index of prev, 0 == none */ |
| 1213 | u16 unused; |
| 1214 | }; |
| 1215 | |
| 1216 | static IP_t *__NetDefragment(IP_t *ip, int *lenp) |
| 1217 | { |
| 1218 | static uchar pkt_buff[IP_PKTSIZE] __attribute__((aligned(PKTALIGN))); |
| 1219 | static u16 first_hole, total_len; |
| 1220 | struct hole *payload, *thisfrag, *h, *newh; |
| 1221 | IP_t *localip = (IP_t *)pkt_buff; |
| 1222 | uchar *indata = (uchar *)ip; |
| 1223 | int offset8, start, len, done = 0; |
| 1224 | u16 ip_off = ntohs(ip->ip_off); |
| 1225 | |
| 1226 | /* payload starts after IP header, this fragment is in there */ |
| 1227 | payload = (struct hole *)(pkt_buff + IP_HDR_SIZE_NO_UDP); |
| 1228 | offset8 = (ip_off & IP_OFFS); |
| 1229 | thisfrag = payload + offset8; |
| 1230 | start = offset8 * 8; |
| 1231 | len = ntohs(ip->ip_len) - IP_HDR_SIZE_NO_UDP; |
| 1232 | |
| 1233 | if (start + len > IP_MAXUDP) /* fragment extends too far */ |
| 1234 | return NULL; |
| 1235 | |
| 1236 | if (!total_len || localip->ip_id != ip->ip_id) { |
| 1237 | /* new (or different) packet, reset structs */ |
| 1238 | total_len = 0xffff; |
| 1239 | payload[0].last_byte = ~0; |
| 1240 | payload[0].next_hole = 0; |
| 1241 | payload[0].prev_hole = 0; |
| 1242 | first_hole = 0; |
| 1243 | /* any IP header will work, copy the first we received */ |
| 1244 | memcpy(localip, ip, IP_HDR_SIZE_NO_UDP); |
| 1245 | } |
| 1246 | |
| 1247 | /* |
| 1248 | * What follows is the reassembly algorithm. We use the payload |
| 1249 | * array as a linked list of hole descriptors, as each hole starts |
| 1250 | * at a multiple of 8 bytes. However, last byte can be whatever value, |
| 1251 | * so it is represented as byte count, not as 8-byte blocks. |
| 1252 | */ |
| 1253 | |
| 1254 | h = payload + first_hole; |
| 1255 | while (h->last_byte < start) { |
| 1256 | if (!h->next_hole) { |
| 1257 | /* no hole that far away */ |
| 1258 | return NULL; |
| 1259 | } |
| 1260 | h = payload + h->next_hole; |
| 1261 | } |
| 1262 | |
Fillod Stephane | e397e59 | 2010-06-11 19:26:43 +0200 | [diff] [blame] | 1263 | /* last fragment may be 1..7 bytes, the "+7" forces acceptance */ |
| 1264 | if (offset8 + ((len + 7) / 8) <= h - payload) { |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1265 | /* no overlap with holes (dup fragment?) */ |
| 1266 | return NULL; |
| 1267 | } |
| 1268 | |
| 1269 | if (!(ip_off & IP_FLAGS_MFRAG)) { |
| 1270 | /* no more fragmentss: truncate this (last) hole */ |
| 1271 | total_len = start + len; |
| 1272 | h->last_byte = start + len; |
| 1273 | } |
| 1274 | |
| 1275 | /* |
| 1276 | * There is some overlap: fix the hole list. This code doesn't |
| 1277 | * deal with a fragment that overlaps with two different holes |
| 1278 | * (thus being a superset of a previously-received fragment). |
| 1279 | */ |
| 1280 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1281 | if ((h >= thisfrag) && (h->last_byte <= start + len)) { |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1282 | /* complete overlap with hole: remove hole */ |
| 1283 | if (!h->prev_hole && !h->next_hole) { |
| 1284 | /* last remaining hole */ |
| 1285 | done = 1; |
| 1286 | } else if (!h->prev_hole) { |
| 1287 | /* first hole */ |
| 1288 | first_hole = h->next_hole; |
| 1289 | payload[h->next_hole].prev_hole = 0; |
| 1290 | } else if (!h->next_hole) { |
| 1291 | /* last hole */ |
| 1292 | payload[h->prev_hole].next_hole = 0; |
| 1293 | } else { |
| 1294 | /* in the middle of the list */ |
| 1295 | payload[h->next_hole].prev_hole = h->prev_hole; |
| 1296 | payload[h->prev_hole].next_hole = h->next_hole; |
| 1297 | } |
| 1298 | |
| 1299 | } else if (h->last_byte <= start + len) { |
| 1300 | /* overlaps with final part of the hole: shorten this hole */ |
| 1301 | h->last_byte = start; |
| 1302 | |
| 1303 | } else if (h >= thisfrag) { |
| 1304 | /* overlaps with initial part of the hole: move this hole */ |
| 1305 | newh = thisfrag + (len / 8); |
| 1306 | *newh = *h; |
| 1307 | h = newh; |
| 1308 | if (h->next_hole) |
| 1309 | payload[h->next_hole].prev_hole = (h - payload); |
| 1310 | if (h->prev_hole) |
| 1311 | payload[h->prev_hole].next_hole = (h - payload); |
| 1312 | else |
| 1313 | first_hole = (h - payload); |
| 1314 | |
| 1315 | } else { |
| 1316 | /* fragment sits in the middle: split the hole */ |
| 1317 | newh = thisfrag + (len / 8); |
| 1318 | *newh = *h; |
| 1319 | h->last_byte = start; |
| 1320 | h->next_hole = (newh - payload); |
| 1321 | newh->prev_hole = (h - payload); |
| 1322 | if (newh->next_hole) |
| 1323 | payload[newh->next_hole].prev_hole = (newh - payload); |
| 1324 | } |
| 1325 | |
| 1326 | /* finally copy this fragment and possibly return whole packet */ |
| 1327 | memcpy((uchar *)thisfrag, indata + IP_HDR_SIZE_NO_UDP, len); |
| 1328 | if (!done) |
| 1329 | return NULL; |
| 1330 | |
| 1331 | localip->ip_len = htons(total_len); |
| 1332 | *lenp = total_len + IP_HDR_SIZE_NO_UDP; |
| 1333 | return localip; |
| 1334 | } |
| 1335 | |
| 1336 | static inline IP_t *NetDefragment(IP_t *ip, int *lenp) |
| 1337 | { |
| 1338 | u16 ip_off = ntohs(ip->ip_off); |
| 1339 | if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG))) |
| 1340 | return ip; /* not a fragment */ |
| 1341 | return __NetDefragment(ip, lenp); |
| 1342 | } |
| 1343 | |
| 1344 | #else /* !CONFIG_IP_DEFRAG */ |
| 1345 | |
| 1346 | static inline IP_t *NetDefragment(IP_t *ip, int *lenp) |
| 1347 | { |
| 1348 | u16 ip_off = ntohs(ip->ip_off); |
| 1349 | if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG))) |
| 1350 | return ip; /* not a fragment */ |
| 1351 | return NULL; |
| 1352 | } |
| 1353 | #endif |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1354 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1355 | void |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1356 | NetReceive(volatile uchar * inpkt, int len) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1357 | { |
| 1358 | Ethernet_t *et; |
| 1359 | IP_t *ip; |
| 1360 | ARP_t *arp; |
| 1361 | IPaddr_t tmp; |
Luca Ceresoli | 03eb129 | 2011-04-18 06:19:50 +0000 | [diff] [blame] | 1362 | IPaddr_t src_ip; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1363 | int x; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1364 | uchar *pkt; |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 1365 | #if defined(CONFIG_CMD_CDP) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1366 | int iscdp; |
| 1367 | #endif |
| 1368 | ushort cti = 0, vlanid = VLAN_NONE, myvlanid, mynvlanid; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1369 | |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 1370 | debug("packet received\n"); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1371 | |
Mike Frysinger | d9bec9f | 2009-07-18 21:04:08 -0400 | [diff] [blame] | 1372 | NetRxPacket = inpkt; |
| 1373 | NetRxPacketLen = len; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1374 | et = (Ethernet_t *)inpkt; |
| 1375 | |
| 1376 | /* too small packet? */ |
| 1377 | if (len < ETHER_HDR_SIZE) |
| 1378 | return; |
| 1379 | |
Rafal Jaworowski | f85b607 | 2007-12-27 18:19:02 +0100 | [diff] [blame] | 1380 | #ifdef CONFIG_API |
| 1381 | if (push_packet) { |
| 1382 | (*push_packet)(inpkt, len); |
| 1383 | return; |
| 1384 | } |
| 1385 | #endif |
| 1386 | |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 1387 | #if defined(CONFIG_CMD_CDP) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1388 | /* keep track if packet is CDP */ |
| 1389 | iscdp = memcmp(et->et_dest, NetCDPAddr, 6) == 0; |
| 1390 | #endif |
| 1391 | |
| 1392 | myvlanid = ntohs(NetOurVLAN); |
| 1393 | if (myvlanid == (ushort)-1) |
| 1394 | myvlanid = VLAN_NONE; |
| 1395 | mynvlanid = ntohs(NetOurNativeVLAN); |
| 1396 | if (mynvlanid == (ushort)-1) |
| 1397 | mynvlanid = VLAN_NONE; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1398 | |
| 1399 | x = ntohs(et->et_protlen); |
| 1400 | |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 1401 | debug("packet received\n"); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1402 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1403 | if (x < 1514) { |
| 1404 | /* |
| 1405 | * Got a 802 packet. Check the other protocol field. |
| 1406 | */ |
| 1407 | x = ntohs(et->et_prot); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1408 | |
| 1409 | ip = (IP_t *)(inpkt + E802_HDR_SIZE); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1410 | len -= E802_HDR_SIZE; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1411 | |
| 1412 | } else if (x != PROT_VLAN) { /* normal packet */ |
| 1413 | ip = (IP_t *)(inpkt + ETHER_HDR_SIZE); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1414 | len -= ETHER_HDR_SIZE; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1415 | |
| 1416 | } else { /* VLAN packet */ |
| 1417 | VLAN_Ethernet_t *vet = (VLAN_Ethernet_t *)et; |
| 1418 | |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 1419 | debug("VLAN packet received\n"); |
| 1420 | |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1421 | /* too small packet? */ |
| 1422 | if (len < VLAN_ETHER_HDR_SIZE) |
| 1423 | return; |
| 1424 | |
| 1425 | /* if no VLAN active */ |
| 1426 | if ((ntohs(NetOurVLAN) & VLAN_IDMASK) == VLAN_NONE |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 1427 | #if defined(CONFIG_CMD_CDP) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1428 | && iscdp == 0 |
| 1429 | #endif |
| 1430 | ) |
| 1431 | return; |
| 1432 | |
| 1433 | cti = ntohs(vet->vet_tag); |
| 1434 | vlanid = cti & VLAN_IDMASK; |
| 1435 | x = ntohs(vet->vet_type); |
| 1436 | |
| 1437 | ip = (IP_t *)(inpkt + VLAN_ETHER_HDR_SIZE); |
| 1438 | len -= VLAN_ETHER_HDR_SIZE; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1439 | } |
| 1440 | |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 1441 | debug("Receive from protocol 0x%x\n", x); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1442 | |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 1443 | #if defined(CONFIG_CMD_CDP) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1444 | if (iscdp) { |
| 1445 | CDPHandler((uchar *)ip, len); |
| 1446 | return; |
| 1447 | } |
| 1448 | #endif |
| 1449 | |
| 1450 | if ((myvlanid & VLAN_IDMASK) != VLAN_NONE) { |
| 1451 | if (vlanid == VLAN_NONE) |
| 1452 | vlanid = (mynvlanid & VLAN_IDMASK); |
| 1453 | /* not matched? */ |
| 1454 | if (vlanid != (myvlanid & VLAN_IDMASK)) |
| 1455 | return; |
| 1456 | } |
| 1457 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1458 | switch (x) { |
| 1459 | |
| 1460 | case PROT_ARP: |
| 1461 | /* |
| 1462 | * We have to deal with two types of ARP packets: |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1463 | * - REQUEST packets will be answered by sending our |
| 1464 | * IP address - if we know it. |
| 1465 | * - REPLY packates are expected only after we asked |
| 1466 | * for the TFTP server's or the gateway's ethernet |
| 1467 | * address; so if we receive such a packet, we set |
| 1468 | * the server ethernet address |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1469 | */ |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 1470 | debug("Got ARP\n"); |
| 1471 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1472 | arp = (ARP_t *)ip; |
| 1473 | if (len < ARP_HDR_SIZE) { |
| 1474 | printf("bad length %d < %d\n", len, ARP_HDR_SIZE); |
| 1475 | return; |
| 1476 | } |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame^] | 1477 | if (ntohs(arp->ar_hrd) != ARP_ETHER) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1478 | return; |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame^] | 1479 | if (ntohs(arp->ar_pro) != PROT_IP) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1480 | return; |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame^] | 1481 | if (arp->ar_hln != 6) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1482 | return; |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame^] | 1483 | if (arp->ar_pln != 4) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1484 | return; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1485 | |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame^] | 1486 | if (NetOurIP == 0) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1487 | return; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1488 | |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame^] | 1489 | if (NetReadIP(&arp->ar_data[16]) != NetOurIP) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1490 | return; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1491 | |
| 1492 | switch (ntohs(arp->ar_op)) { |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1493 | case ARPOP_REQUEST: |
| 1494 | /* reply with our IP address */ |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 1495 | debug("Got ARP REQUEST, return our IP\n"); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1496 | pkt = (uchar *)et; |
| 1497 | pkt += NetSetEther(pkt, et->et_src, PROT_ARP); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1498 | arp->ar_op = htons(ARPOP_REPLY); |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1499 | memcpy(&arp->ar_data[10], &arp->ar_data[0], 6); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1500 | NetCopyIP(&arp->ar_data[16], &arp->ar_data[6]); |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1501 | memcpy(&arp->ar_data[0], NetOurEther, 6); |
| 1502 | NetCopyIP(&arp->ar_data[6], &NetOurIP); |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1503 | (void) eth_send((uchar *)et, |
| 1504 | (pkt - (uchar *)et) + ARP_HDR_SIZE); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1505 | return; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1506 | |
| 1507 | case ARPOP_REPLY: /* arp reply */ |
| 1508 | /* are we waiting for a reply */ |
| 1509 | if (!NetArpWaitPacketIP || !NetArpWaitPacketMAC) |
| 1510 | break; |
Robin Getz | 97cfe86 | 2009-07-21 12:15:28 -0400 | [diff] [blame] | 1511 | |
| 1512 | #ifdef CONFIG_KEEP_SERVERADDR |
| 1513 | if (NetServerIP == NetArpWaitPacketIP) { |
| 1514 | char buf[20]; |
| 1515 | sprintf(buf, "%pM", arp->ar_data); |
| 1516 | setenv("serveraddr", buf); |
| 1517 | } |
| 1518 | #endif |
| 1519 | |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 1520 | debug("Got ARP REPLY, set server/gtwy eth addr (%pM)\n", |
Mike Frysinger | 95823ca | 2009-02-11 18:23:48 -0500 | [diff] [blame] | 1521 | arp->ar_data); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1522 | |
| 1523 | tmp = NetReadIP(&arp->ar_data[6]); |
| 1524 | |
| 1525 | /* matched waiting packet's address */ |
| 1526 | if (tmp == NetArpWaitReplyIP) { |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 1527 | debug("Got it\n"); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1528 | /* save address for later use */ |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1529 | memcpy(NetArpWaitPacketMAC, |
| 1530 | &arp->ar_data[0], 6); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1531 | |
wdenk | 68ceb29 | 2004-08-02 21:11:11 +0000 | [diff] [blame] | 1532 | #ifdef CONFIG_NETCONSOLE |
Luca Ceresoli | 03eb129 | 2011-04-18 06:19:50 +0000 | [diff] [blame] | 1533 | (*packetHandler)(0, 0, 0, 0, 0); |
wdenk | 68ceb29 | 2004-08-02 21:11:11 +0000 | [diff] [blame] | 1534 | #endif |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1535 | /* modify header, and transmit it */ |
| 1536 | memcpy(((Ethernet_t *)NetArpWaitTxPacket)->et_dest, NetArpWaitPacketMAC, 6); |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1537 | (void) eth_send(NetArpWaitTxPacket, |
| 1538 | NetArpWaitTxPacketSize); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1539 | |
| 1540 | /* no arp request pending now */ |
| 1541 | NetArpWaitPacketIP = 0; |
| 1542 | NetArpWaitTxPacketSize = 0; |
| 1543 | NetArpWaitPacketMAC = NULL; |
| 1544 | |
| 1545 | } |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1546 | return; |
| 1547 | default: |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1548 | debug("Unexpected ARP opcode 0x%x\n", |
| 1549 | ntohs(arp->ar_op)); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1550 | return; |
| 1551 | } |
wdenk | 289f932 | 2005-01-12 00:15:14 +0000 | [diff] [blame] | 1552 | break; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1553 | |
Peter Tyser | bf6cb24 | 2010-09-30 11:25:48 -0500 | [diff] [blame] | 1554 | #ifdef CONFIG_CMD_RARP |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1555 | case PROT_RARP: |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 1556 | debug("Got RARP\n"); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1557 | arp = (ARP_t *)ip; |
| 1558 | if (len < ARP_HDR_SIZE) { |
| 1559 | printf("bad length %d < %d\n", len, ARP_HDR_SIZE); |
| 1560 | return; |
| 1561 | } |
| 1562 | |
| 1563 | if ((ntohs(arp->ar_op) != RARPOP_REPLY) || |
| 1564 | (ntohs(arp->ar_hrd) != ARP_ETHER) || |
| 1565 | (ntohs(arp->ar_pro) != PROT_IP) || |
| 1566 | (arp->ar_hln != 6) || (arp->ar_pln != 4)) { |
| 1567 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1568 | puts("invalid RARP header\n"); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1569 | } else { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1570 | NetCopyIP(&NetOurIP, &arp->ar_data[16]); |
wdenk | 3d3befa | 2004-03-14 15:06:13 +0000 | [diff] [blame] | 1571 | if (NetServerIP == 0) |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1572 | NetCopyIP(&NetServerIP, &arp->ar_data[6]); |
| 1573 | memcpy(NetServerEther, &arp->ar_data[0], 6); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1574 | |
Luca Ceresoli | 03eb129 | 2011-04-18 06:19:50 +0000 | [diff] [blame] | 1575 | (*packetHandler)(0, 0, 0, 0, 0); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1576 | } |
| 1577 | break; |
Peter Tyser | bf6cb24 | 2010-09-30 11:25:48 -0500 | [diff] [blame] | 1578 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1579 | case PROT_IP: |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 1580 | debug("Got IP\n"); |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1581 | /* Before we start poking the header, make sure it is there */ |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1582 | if (len < IP_HDR_SIZE) { |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 1583 | debug("len bad %d < %lu\n", len, (ulong)IP_HDR_SIZE); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1584 | return; |
| 1585 | } |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1586 | /* Check the packet length */ |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1587 | if (len < ntohs(ip->ip_len)) { |
| 1588 | printf("len bad %d < %d\n", len, ntohs(ip->ip_len)); |
| 1589 | return; |
| 1590 | } |
| 1591 | len = ntohs(ip->ip_len); |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 1592 | debug("len=%d, v=%02x\n", len, ip->ip_hl_v & 0xff); |
| 1593 | |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1594 | /* Can't deal with anything except IPv4 */ |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame^] | 1595 | if ((ip->ip_hl_v & 0xf0) != 0x40) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1596 | return; |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1597 | /* Can't deal with IP options (headers != 20 bytes) */ |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame^] | 1598 | if ((ip->ip_hl_v & 0x0f) > 0x05) |
Remy Bohmer | 6b52cfe | 2008-06-03 15:48:17 +0200 | [diff] [blame] | 1599 | return; |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1600 | /* Check the Checksum of the header */ |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1601 | if (!NetCksumOk((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2)) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1602 | puts("checksum bad\n"); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1603 | return; |
| 1604 | } |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1605 | /* If it is not for us, ignore it */ |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1606 | tmp = NetReadIP(&ip->ip_dst); |
| 1607 | if (NetOurIP && tmp != NetOurIP && tmp != 0xFFFFFFFF) { |
David Updegraff | 53a5c42 | 2007-06-11 10:41:07 -0500 | [diff] [blame] | 1608 | #ifdef CONFIG_MCAST_TFTP |
Wolfgang Denk | 85eb5ca | 2007-08-14 09:47:27 +0200 | [diff] [blame] | 1609 | if (Mcast_addr != tmp) |
David Updegraff | 53a5c42 | 2007-06-11 10:41:07 -0500 | [diff] [blame] | 1610 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1611 | return; |
| 1612 | } |
Luca Ceresoli | 03eb129 | 2011-04-18 06:19:50 +0000 | [diff] [blame] | 1613 | /* Read source IP address for later use */ |
| 1614 | src_ip = NetReadIP(&ip->ip_src); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1615 | /* |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1616 | * The function returns the unchanged packet if it's not |
| 1617 | * a fragment, and either the complete packet or NULL if |
| 1618 | * it is a fragment (if !CONFIG_IP_DEFRAG, it returns NULL) |
| 1619 | */ |
| 1620 | if (!(ip = NetDefragment(ip, &len))) |
| 1621 | return; |
| 1622 | /* |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1623 | * watch for ICMP host redirects |
| 1624 | * |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1625 | * There is no real handler code (yet). We just watch |
| 1626 | * for ICMP host redirect messages. In case anybody |
| 1627 | * sees these messages: please contact me |
| 1628 | * (wd@denx.de), or - even better - send me the |
| 1629 | * necessary fixes :-) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1630 | * |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1631 | * Note: in all cases where I have seen this so far |
| 1632 | * it was a problem with the router configuration, |
| 1633 | * for instance when a router was configured in the |
| 1634 | * BOOTP reply, but the TFTP server was on the same |
| 1635 | * subnet. So this is probably a warning that your |
| 1636 | * configuration might be wrong. But I'm not really |
| 1637 | * sure if there aren't any other situations. |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1638 | */ |
| 1639 | if (ip->ip_p == IPPROTO_ICMP) { |
| 1640 | ICMP_t *icmph = (ICMP_t *)&(ip->udp_src); |
| 1641 | |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1642 | switch (icmph->type) { |
| 1643 | case ICMP_REDIRECT: |
wdenk | 90dc670 | 2005-05-03 14:12:25 +0000 | [diff] [blame] | 1644 | if (icmph->code != ICMP_REDIR_HOST) |
| 1645 | return; |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1646 | printf(" ICMP Host Redirect to %pI4 ", |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1647 | &icmph->un.gateway); |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1648 | return; |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 1649 | #if defined(CONFIG_CMD_PING) |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1650 | case ICMP_ECHO_REPLY: |
| 1651 | /* |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1652 | * IP header OK. Pass the packet to the |
| 1653 | * current handler. |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1654 | */ |
| 1655 | /* XXX point to ip packet */ |
Luca Ceresoli | 03eb129 | 2011-04-18 06:19:50 +0000 | [diff] [blame] | 1656 | (*packetHandler)((uchar *)ip, 0, src_ip, 0, 0); |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1657 | return; |
Ed Swarthout | 8385317 | 2007-03-07 12:14:50 -0600 | [diff] [blame] | 1658 | case ICMP_ECHO_REQUEST: |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1659 | debug("Got ICMP ECHO REQUEST, return %d bytes\n", |
Luca Ceresoli | 03eb129 | 2011-04-18 06:19:50 +0000 | [diff] [blame] | 1660 | ETHER_HDR_SIZE + len); |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 1661 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1662 | memcpy(&et->et_dest[0], &et->et_src[0], 6); |
| 1663 | memcpy(&et->et_src[0], NetOurEther, 6); |
Ed Swarthout | 8385317 | 2007-03-07 12:14:50 -0600 | [diff] [blame] | 1664 | |
| 1665 | ip->ip_sum = 0; |
| 1666 | ip->ip_off = 0; |
| 1667 | NetCopyIP((void*)&ip->ip_dst, &ip->ip_src); |
| 1668 | NetCopyIP((void*)&ip->ip_src, &NetOurIP); |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1669 | ip->ip_sum = ~NetCksum((uchar *)ip, |
| 1670 | IP_HDR_SIZE_NO_UDP >> 1); |
Ed Swarthout | 8385317 | 2007-03-07 12:14:50 -0600 | [diff] [blame] | 1671 | |
| 1672 | icmph->type = ICMP_ECHO_REPLY; |
| 1673 | icmph->checksum = 0; |
| 1674 | icmph->checksum = ~NetCksum((uchar *)icmph, |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1675 | (len - IP_HDR_SIZE_NO_UDP) >> 1); |
| 1676 | (void) eth_send((uchar *)et, |
| 1677 | ETHER_HDR_SIZE + len); |
Ed Swarthout | 8385317 | 2007-03-07 12:14:50 -0600 | [diff] [blame] | 1678 | return; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1679 | #endif |
| 1680 | default: |
| 1681 | return; |
| 1682 | } |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1683 | } else if (ip->ip_p != IPPROTO_UDP) { /* Only UDP packets */ |
| 1684 | return; |
| 1685 | } |
| 1686 | |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1687 | #ifdef CONFIG_UDP_CHECKSUM |
| 1688 | if (ip->udp_xsum != 0) { |
Wolfgang Denk | b2f5080 | 2005-08-12 23:43:12 +0200 | [diff] [blame] | 1689 | ulong xsum; |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1690 | ushort *sumptr; |
| 1691 | ushort sumlen; |
| 1692 | |
| 1693 | xsum = ip->ip_p; |
| 1694 | xsum += (ntohs(ip->udp_len)); |
| 1695 | xsum += (ntohl(ip->ip_src) >> 16) & 0x0000ffff; |
| 1696 | xsum += (ntohl(ip->ip_src) >> 0) & 0x0000ffff; |
| 1697 | xsum += (ntohl(ip->ip_dst) >> 16) & 0x0000ffff; |
| 1698 | xsum += (ntohl(ip->ip_dst) >> 0) & 0x0000ffff; |
| 1699 | |
| 1700 | sumlen = ntohs(ip->udp_len); |
| 1701 | sumptr = (ushort *) &(ip->udp_src); |
| 1702 | |
| 1703 | while (sumlen > 1) { |
Wolfgang Denk | b2f5080 | 2005-08-12 23:43:12 +0200 | [diff] [blame] | 1704 | ushort sumdata; |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1705 | |
| 1706 | sumdata = *sumptr++; |
| 1707 | xsum += ntohs(sumdata); |
| 1708 | sumlen -= 2; |
| 1709 | } |
| 1710 | if (sumlen > 0) { |
Wolfgang Denk | b2f5080 | 2005-08-12 23:43:12 +0200 | [diff] [blame] | 1711 | ushort sumdata; |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1712 | |
| 1713 | sumdata = *(unsigned char *) sumptr; |
Wolfgang Denk | b2f5080 | 2005-08-12 23:43:12 +0200 | [diff] [blame] | 1714 | sumdata = (sumdata << 8) & 0xff00; |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1715 | xsum += sumdata; |
| 1716 | } |
| 1717 | while ((xsum >> 16) != 0) { |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1718 | xsum = (xsum & 0x0000ffff) + |
| 1719 | ((xsum >> 16) & 0x0000ffff); |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1720 | } |
| 1721 | if ((xsum != 0x00000000) && (xsum != 0x0000ffff)) { |
Wolfgang Denk | 9b55a25 | 2008-07-11 01:16:00 +0200 | [diff] [blame] | 1722 | printf(" UDP wrong checksum %08lx %08x\n", |
| 1723 | xsum, ntohs(ip->udp_xsum)); |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1724 | return; |
| 1725 | } |
| 1726 | } |
| 1727 | #endif |
| 1728 | |
David Updegraff | 53a5c42 | 2007-06-11 10:41:07 -0500 | [diff] [blame] | 1729 | |
wdenk | 68ceb29 | 2004-08-02 21:11:11 +0000 | [diff] [blame] | 1730 | #ifdef CONFIG_NETCONSOLE |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1731 | nc_input_packet((uchar *)ip + IP_HDR_SIZE, |
wdenk | 68ceb29 | 2004-08-02 21:11:11 +0000 | [diff] [blame] | 1732 | ntohs(ip->udp_dst), |
| 1733 | ntohs(ip->udp_src), |
| 1734 | ntohs(ip->udp_len) - 8); |
| 1735 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1736 | /* |
| 1737 | * IP header OK. Pass the packet to the current handler. |
| 1738 | */ |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1739 | (*packetHandler)((uchar *)ip + IP_HDR_SIZE, |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1740 | ntohs(ip->udp_dst), |
Luca Ceresoli | 03eb129 | 2011-04-18 06:19:50 +0000 | [diff] [blame] | 1741 | src_ip, |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1742 | ntohs(ip->udp_src), |
| 1743 | ntohs(ip->udp_len) - 8); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1744 | break; |
| 1745 | } |
| 1746 | } |
| 1747 | |
| 1748 | |
| 1749 | /**********************************************************************/ |
| 1750 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1751 | static int net_check_prereq(proto_t protocol) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1752 | { |
| 1753 | switch (protocol) { |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1754 | /* Fall through */ |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 1755 | #if defined(CONFIG_CMD_PING) |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1756 | case PING: |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1757 | if (NetPingIP == 0) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1758 | puts("*** ERROR: ping address not given\n"); |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1759 | return (1); |
| 1760 | } |
| 1761 | goto common; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1762 | #endif |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 1763 | #if defined(CONFIG_CMD_SNTP) |
wdenk | ea287de | 2005-04-01 00:25:43 +0000 | [diff] [blame] | 1764 | case SNTP: |
| 1765 | if (NetNtpServerIP == 0) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1766 | puts("*** ERROR: NTP server address not given\n"); |
wdenk | ea287de | 2005-04-01 00:25:43 +0000 | [diff] [blame] | 1767 | return (1); |
| 1768 | } |
| 1769 | goto common; |
| 1770 | #endif |
Robin Getz | 1a32bf4 | 2009-07-20 14:53:54 -0400 | [diff] [blame] | 1771 | #if defined(CONFIG_CMD_DNS) |
| 1772 | case DNS: |
| 1773 | if (NetOurDNSIP == 0) { |
| 1774 | puts("*** ERROR: DNS server address not given\n"); |
| 1775 | return 1; |
| 1776 | } |
| 1777 | goto common; |
| 1778 | #endif |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 1779 | #if defined(CONFIG_CMD_NFS) |
wdenk | cbd8a35 | 2004-02-24 02:00:03 +0000 | [diff] [blame] | 1780 | case NFS: |
| 1781 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1782 | case TFTP: |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1783 | if (NetServerIP == 0) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1784 | puts("*** ERROR: `serverip' not set\n"); |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1785 | return (1); |
| 1786 | } |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1787 | #if defined(CONFIG_CMD_PING) || defined(CONFIG_CMD_SNTP) || \ |
| 1788 | defined(CONFIG_CMD_DNS) |
| 1789 | common: |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1790 | #endif |
Simon Guinot | 8b6bbe1 | 2011-05-01 23:38:40 +0000 | [diff] [blame] | 1791 | /* Fall through */ |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1792 | |
Simon Guinot | 8b6bbe1 | 2011-05-01 23:38:40 +0000 | [diff] [blame] | 1793 | case NETCONS: |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1794 | if (NetOurIP == 0) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1795 | puts("*** ERROR: `ipaddr' not set\n"); |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1796 | return (1); |
| 1797 | } |
| 1798 | /* Fall through */ |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1799 | |
Peter Tyser | bf6cb24 | 2010-09-30 11:25:48 -0500 | [diff] [blame] | 1800 | #ifdef CONFIG_CMD_RARP |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1801 | case RARP: |
Peter Tyser | bf6cb24 | 2010-09-30 11:25:48 -0500 | [diff] [blame] | 1802 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1803 | case BOOTP: |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1804 | case CDP: |
Peter Tyser | bf6cb24 | 2010-09-30 11:25:48 -0500 | [diff] [blame] | 1805 | case DHCP: |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1806 | if (memcmp(NetOurEther, "\0\0\0\0\0\0", 6) == 0) { |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1807 | #ifdef CONFIG_NET_MULTI |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1808 | extern int eth_get_dev_index(void); |
| 1809 | int num = eth_get_dev_index(); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1810 | |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1811 | switch (num) { |
| 1812 | case -1: |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1813 | puts("*** ERROR: No ethernet found.\n"); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1814 | return (1); |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1815 | case 0: |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1816 | puts("*** ERROR: `ethaddr' not set\n"); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1817 | break; |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1818 | default: |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1819 | printf("*** ERROR: `eth%daddr' not set\n", |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1820 | num); |
| 1821 | break; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1822 | } |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1823 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1824 | NetStartAgain(); |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1825 | return (2); |
| 1826 | #else |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1827 | puts("*** ERROR: `ethaddr' not set\n"); |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1828 | return (1); |
| 1829 | #endif |
| 1830 | } |
| 1831 | /* Fall through */ |
| 1832 | default: |
| 1833 | return (0); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1834 | } |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1835 | return (0); /* OK */ |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1836 | } |
| 1837 | /**********************************************************************/ |
| 1838 | |
| 1839 | int |
| 1840 | NetCksumOk(uchar * ptr, int len) |
| 1841 | { |
| 1842 | return !((NetCksum(ptr, len) + 1) & 0xfffe); |
| 1843 | } |
| 1844 | |
| 1845 | |
| 1846 | unsigned |
| 1847 | NetCksum(uchar * ptr, int len) |
| 1848 | { |
| 1849 | ulong xsum; |
Stefan Roese | 9d2a873 | 2005-08-31 12:55:50 +0200 | [diff] [blame] | 1850 | ushort *p = (ushort *)ptr; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1851 | |
| 1852 | xsum = 0; |
| 1853 | while (len-- > 0) |
Wolfgang Denk | 7bc5ee0 | 2005-08-26 01:36:03 +0200 | [diff] [blame] | 1854 | xsum += *p++; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1855 | xsum = (xsum & 0xffff) + (xsum >> 16); |
| 1856 | xsum = (xsum & 0xffff) + (xsum >> 16); |
| 1857 | return (xsum & 0xffff); |
| 1858 | } |
| 1859 | |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1860 | int |
| 1861 | NetEthHdrSize(void) |
| 1862 | { |
| 1863 | ushort myvlanid; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1864 | |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1865 | myvlanid = ntohs(NetOurVLAN); |
| 1866 | if (myvlanid == (ushort)-1) |
| 1867 | myvlanid = VLAN_NONE; |
| 1868 | |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1869 | return ((myvlanid & VLAN_IDMASK) == VLAN_NONE) ? ETHER_HDR_SIZE : |
| 1870 | VLAN_ETHER_HDR_SIZE; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1871 | } |
| 1872 | |
| 1873 | int |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1874 | NetSetEther(volatile uchar * xet, uchar * addr, uint prot) |
| 1875 | { |
| 1876 | Ethernet_t *et = (Ethernet_t *)xet; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1877 | ushort myvlanid; |
| 1878 | |
| 1879 | myvlanid = ntohs(NetOurVLAN); |
| 1880 | if (myvlanid == (ushort)-1) |
| 1881 | myvlanid = VLAN_NONE; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1882 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1883 | memcpy(et->et_dest, addr, 6); |
| 1884 | memcpy(et->et_src, NetOurEther, 6); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1885 | if ((myvlanid & VLAN_IDMASK) == VLAN_NONE) { |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1886 | et->et_protlen = htons(prot); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1887 | return ETHER_HDR_SIZE; |
| 1888 | } else { |
| 1889 | VLAN_Ethernet_t *vet = (VLAN_Ethernet_t *)xet; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1890 | |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1891 | vet->vet_vlan_type = htons(PROT_VLAN); |
| 1892 | vet->vet_tag = htons((0 << 5) | (myvlanid & VLAN_IDMASK)); |
| 1893 | vet->vet_type = htons(prot); |
| 1894 | return VLAN_ETHER_HDR_SIZE; |
| 1895 | } |
| 1896 | } |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1897 | |
| 1898 | void |
| 1899 | NetSetIP(volatile uchar * xip, IPaddr_t dest, int dport, int sport, int len) |
| 1900 | { |
Olav Morken | af8626e | 2009-01-23 12:56:26 +0100 | [diff] [blame] | 1901 | IP_t *ip = (IP_t *)xip; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1902 | |
| 1903 | /* |
| 1904 | * If the data is an odd number of bytes, zero the |
| 1905 | * byte after the last byte so that the checksum |
| 1906 | * will work. |
| 1907 | */ |
| 1908 | if (len & 1) |
| 1909 | xip[IP_HDR_SIZE + len] = 0; |
| 1910 | |
| 1911 | /* |
| 1912 | * Construct an IP and UDP header. |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1913 | * (need to set no fragment bit - XXX) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1914 | */ |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1915 | /* IP_HDR_SIZE / 4 (not including UDP) */ |
| 1916 | ip->ip_hl_v = 0x45; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1917 | ip->ip_tos = 0; |
| 1918 | ip->ip_len = htons(IP_HDR_SIZE + len); |
| 1919 | ip->ip_id = htons(NetIPID++); |
Peter Tyser | e0c07b8 | 2008-12-01 16:26:20 -0600 | [diff] [blame] | 1920 | ip->ip_off = htons(IP_FLAGS_DFRAG); /* Don't fragment */ |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1921 | ip->ip_ttl = 255; |
| 1922 | ip->ip_p = 17; /* UDP */ |
| 1923 | ip->ip_sum = 0; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1924 | /* already in network byte order */ |
| 1925 | NetCopyIP((void*)&ip->ip_src, &NetOurIP); |
| 1926 | /* - "" - */ |
| 1927 | NetCopyIP((void*)&ip->ip_dst, &dest); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1928 | ip->udp_src = htons(sport); |
| 1929 | ip->udp_dst = htons(dport); |
| 1930 | ip->udp_len = htons(8 + len); |
| 1931 | ip->udp_xsum = 0; |
| 1932 | ip->ip_sum = ~NetCksum((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2); |
| 1933 | } |
| 1934 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1935 | void copy_filename(char *dst, const char *src, int size) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1936 | { |
| 1937 | if (*src && (*src == '"')) { |
| 1938 | ++src; |
| 1939 | --size; |
| 1940 | } |
| 1941 | |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame^] | 1942 | while ((--size > 0) && *src && (*src != '"')) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1943 | *dst++ = *src++; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1944 | *dst = '\0'; |
| 1945 | } |
| 1946 | |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1947 | #if defined(CONFIG_CMD_NFS) || \ |
| 1948 | defined(CONFIG_CMD_SNTP) || \ |
| 1949 | defined(CONFIG_CMD_DNS) |
Robin Getz | 1a32bf4 | 2009-07-20 14:53:54 -0400 | [diff] [blame] | 1950 | /* |
Robin Getz | 9739946 | 2010-03-08 14:07:00 -0500 | [diff] [blame] | 1951 | * make port a little random (1024-17407) |
| 1952 | * This keeps the math somewhat trivial to compute, and seems to work with |
| 1953 | * all supported protocols/clients/servers |
Robin Getz | 1a32bf4 | 2009-07-20 14:53:54 -0400 | [diff] [blame] | 1954 | */ |
| 1955 | unsigned int random_port(void) |
| 1956 | { |
Robin Getz | 9739946 | 2010-03-08 14:07:00 -0500 | [diff] [blame] | 1957 | return 1024 + (get_timer(0) % 0x4000); |
Robin Getz | 1a32bf4 | 2009-07-20 14:53:54 -0400 | [diff] [blame] | 1958 | } |
| 1959 | #endif |
| 1960 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1961 | void ip_to_string(IPaddr_t x, char *s) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1962 | { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1963 | x = ntohl(x); |
| 1964 | sprintf(s, "%d.%d.%d.%d", |
| 1965 | (int) ((x >> 24) & 0xff), |
| 1966 | (int) ((x >> 16) & 0xff), |
| 1967 | (int) ((x >> 8) & 0xff), (int) ((x >> 0) & 0xff) |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1968 | ); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1969 | } |
| 1970 | |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1971 | void VLAN_to_string(ushort x, char *s) |
| 1972 | { |
| 1973 | x = ntohs(x); |
| 1974 | |
| 1975 | if (x == (ushort)-1) |
| 1976 | x = VLAN_NONE; |
| 1977 | |
| 1978 | if (x == VLAN_NONE) |
| 1979 | strcpy(s, "none"); |
| 1980 | else |
| 1981 | sprintf(s, "%d", x & VLAN_IDMASK); |
| 1982 | } |
| 1983 | |
Mike Frysinger | 2e3ef6e | 2010-10-20 07:16:48 -0400 | [diff] [blame] | 1984 | ushort string_to_VLAN(const char *s) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1985 | { |
| 1986 | ushort id; |
| 1987 | |
| 1988 | if (s == NULL) |
wdenk | b9711de | 2004-04-25 13:18:40 +0000 | [diff] [blame] | 1989 | return htons(VLAN_NONE); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1990 | |
| 1991 | if (*s < '0' || *s > '9') |
| 1992 | id = VLAN_NONE; |
| 1993 | else |
| 1994 | id = (ushort)simple_strtoul(s, NULL, 10); |
| 1995 | |
wdenk | b9711de | 2004-04-25 13:18:40 +0000 | [diff] [blame] | 1996 | return htons(id); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1997 | } |
| 1998 | |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1999 | ushort getenv_VLAN(char *var) |
| 2000 | { |
| 2001 | return (string_to_VLAN(getenv(var))); |
| 2002 | } |