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 |
Wolfgang Denk | 2ea9103 | 2014-09-30 10:44:01 +0200 | [diff] [blame] | 9 | * SPDX-License-Identifier: GPL-2.0 |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 10 | */ |
| 11 | |
| 12 | /* |
| 13 | * General Desription: |
| 14 | * |
| 15 | * The user interface supports commands for BOOTP, RARP, and TFTP. |
| 16 | * Also, we support ARP internally. Depending on available data, |
| 17 | * these interact as follows: |
| 18 | * |
| 19 | * BOOTP: |
| 20 | * |
| 21 | * Prerequisites: - own ethernet address |
| 22 | * We want: - own IP address |
| 23 | * - TFTP server IP address |
| 24 | * - name of bootfile |
| 25 | * Next step: ARP |
| 26 | * |
Joe Hershberger | d22c338 | 2012-05-23 08:00:12 +0000 | [diff] [blame] | 27 | * LINK_LOCAL: |
| 28 | * |
| 29 | * Prerequisites: - own ethernet address |
| 30 | * We want: - own IP address |
| 31 | * Next step: ARP |
| 32 | * |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 33 | * RARP: |
| 34 | * |
| 35 | * Prerequisites: - own ethernet address |
| 36 | * We want: - own IP address |
| 37 | * - TFTP server IP address |
| 38 | * Next step: ARP |
| 39 | * |
| 40 | * ARP: |
| 41 | * |
| 42 | * Prerequisites: - own ethernet address |
| 43 | * - own IP address |
| 44 | * - TFTP server IP address |
| 45 | * We want: - TFTP server ethernet address |
| 46 | * Next step: TFTP |
| 47 | * |
| 48 | * DHCP: |
| 49 | * |
Wolfgang Denk | b2f5080 | 2005-08-12 23:43:12 +0200 | [diff] [blame] | 50 | * Prerequisites: - own ethernet address |
| 51 | * We want: - IP, Netmask, ServerIP, Gateway IP |
| 52 | * - bootfilename, lease time |
| 53 | * Next step: - TFTP |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 54 | * |
| 55 | * TFTP: |
| 56 | * |
| 57 | * Prerequisites: - own ethernet address |
| 58 | * - own IP address |
| 59 | * - TFTP server IP address |
| 60 | * - TFTP server ethernet address |
| 61 | * - name of bootfile (if unknown, we use a default name |
| 62 | * derived from our own IP address) |
| 63 | * We want: - load the boot file |
| 64 | * Next step: none |
wdenk | cbd8a35 | 2004-02-24 02:00:03 +0000 | [diff] [blame] | 65 | * |
| 66 | * NFS: |
| 67 | * |
| 68 | * Prerequisites: - own ethernet address |
| 69 | * - own IP address |
| 70 | * - name of bootfile (if unknown, we use a default name |
| 71 | * derived from our own IP address) |
| 72 | * We want: - load the boot file |
| 73 | * Next step: none |
wdenk | ea287de | 2005-04-01 00:25:43 +0000 | [diff] [blame] | 74 | * |
| 75 | * SNTP: |
| 76 | * |
Wolfgang Denk | b2f5080 | 2005-08-12 23:43:12 +0200 | [diff] [blame] | 77 | * Prerequisites: - own ethernet address |
wdenk | ea287de | 2005-04-01 00:25:43 +0000 | [diff] [blame] | 78 | * - own IP address |
| 79 | * We want: - network time |
| 80 | * Next step: none |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 81 | */ |
| 82 | |
| 83 | |
| 84 | #include <common.h> |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 85 | #include <command.h> |
Joe Hershberger | a9f51c9 | 2012-12-11 22:16:26 -0600 | [diff] [blame] | 86 | #include <environment.h> |
Joe Hershberger | 6030459 | 2015-03-22 17:09:24 -0500 | [diff] [blame] | 87 | #include <errno.h> |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 88 | #include <net.h> |
Joe Hershberger | 4545f4e | 2012-05-23 07:58:15 +0000 | [diff] [blame] | 89 | #if defined(CONFIG_STATUS_LED) |
| 90 | #include <miiphy.h> |
| 91 | #include <status_led.h> |
| 92 | #endif |
| 93 | #include <watchdog.h> |
| 94 | #include <linux/compiler.h> |
Joe Hershberger | d280d3f | 2012-05-23 07:58:01 +0000 | [diff] [blame] | 95 | #include "arp.h" |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 96 | #include "bootp.h" |
Joe Hershberger | f575ae1 | 2012-05-23 07:57:59 +0000 | [diff] [blame] | 97 | #include "cdp.h" |
Robin Getz | 1a32bf4 | 2009-07-20 14:53:54 -0400 | [diff] [blame] | 98 | #if defined(CONFIG_CMD_DNS) |
| 99 | #include "dns.h" |
| 100 | #endif |
Joe Hershberger | d22c338 | 2012-05-23 08:00:12 +0000 | [diff] [blame] | 101 | #include "link_local.h" |
Joe Hershberger | 4545f4e | 2012-05-23 07:58:15 +0000 | [diff] [blame] | 102 | #include "nfs.h" |
Joe Hershberger | a36b12f | 2012-05-23 07:58:02 +0000 | [diff] [blame] | 103 | #include "ping.h" |
Joe Hershberger | 4545f4e | 2012-05-23 07:58:15 +0000 | [diff] [blame] | 104 | #include "rarp.h" |
| 105 | #if defined(CONFIG_CMD_SNTP) |
| 106 | #include "sntp.h" |
| 107 | #endif |
| 108 | #include "tftp.h" |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 109 | |
Wolfgang Denk | d87080b | 2006-03-31 18:32:53 +0200 | [diff] [blame] | 110 | DECLARE_GLOBAL_DATA_PTR; |
| 111 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 112 | /** BOOTP EXTENTIONS **/ |
| 113 | |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 114 | /* Our subnet mask (0=unknown) */ |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 115 | struct in_addr net_netmask; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 116 | /* Our gateways IP address */ |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 117 | struct in_addr net_gateway; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 118 | /* Our DNS IP address */ |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 119 | struct in_addr net_dns_server; |
Jon Loeliger | 1fe80d7 | 2007-07-09 22:08:34 -0500 | [diff] [blame] | 120 | #if defined(CONFIG_BOOTP_DNS2) |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 121 | /* Our 2nd DNS IP address */ |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 122 | struct in_addr net_dns_server2; |
stroese | fe389a8 | 2003-08-28 14:17:32 +0000 | [diff] [blame] | 123 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 124 | |
David Updegraff | 53a5c42 | 2007-06-11 10:41:07 -0500 | [diff] [blame] | 125 | #ifdef CONFIG_MCAST_TFTP /* Multicast TFTP */ |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 126 | struct in_addr net_mcast_addr; |
David Updegraff | 53a5c42 | 2007-06-11 10:41:07 -0500 | [diff] [blame] | 127 | #endif |
| 128 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 129 | /** END OF BOOTP EXTENTIONS **/ |
| 130 | |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 131 | /* Our ethernet address */ |
Joe Hershberger | 0adb5b7 | 2015-04-08 01:41:04 -0500 | [diff] [blame] | 132 | u8 net_ethaddr[6]; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 133 | /* Boot server enet address */ |
Joe Hershberger | 0adb5b7 | 2015-04-08 01:41:04 -0500 | [diff] [blame] | 134 | u8 net_server_ethaddr[6]; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 135 | /* Our IP addr (0 = unknown) */ |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 136 | struct in_addr net_ip; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 137 | /* Server IP addr (0 = unknown) */ |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 138 | struct in_addr net_server_ip; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 139 | /* Current receive packet */ |
Joe Hershberger | 1203fcc | 2015-04-08 01:41:05 -0500 | [diff] [blame] | 140 | uchar *net_rx_packet; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 141 | /* Current rx packet length */ |
Joe Hershberger | 1203fcc | 2015-04-08 01:41:05 -0500 | [diff] [blame] | 142 | int net_rx_packet_len; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 143 | /* IP packet ID */ |
| 144 | unsigned NetIPID; |
| 145 | /* Ethernet bcast address */ |
Joe Hershberger | 0adb5b7 | 2015-04-08 01:41:04 -0500 | [diff] [blame] | 146 | const u8 net_bcast_ethaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; |
| 147 | const u8 net_null_ethaddr[6]; |
Rafal Jaworowski | f85b607 | 2007-12-27 18:19:02 +0100 | [diff] [blame] | 148 | #ifdef CONFIG_API |
Joe Hershberger | db288a9 | 2012-05-15 08:59:04 +0000 | [diff] [blame] | 149 | void (*push_packet)(void *, int len) = 0; |
Rafal Jaworowski | f85b607 | 2007-12-27 18:19:02 +0100 | [diff] [blame] | 150 | #endif |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 151 | /* Network loop state */ |
Joe Hershberger | 22f6e99 | 2012-05-23 07:59:14 +0000 | [diff] [blame] | 152 | enum net_loop_state net_state; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 153 | /* Tried all network devices */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 154 | int NetRestartWrap; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 155 | /* Network loop restarted */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 156 | static int NetRestarted; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 157 | /* At least one device configured */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 158 | static int NetDevExists; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 159 | |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 160 | /* XXX in both little & big endian machines 0xFFFF == ntohs(-1) */ |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 161 | /* default is without VLAN */ |
| 162 | ushort NetOurVLAN = 0xFFFF; |
| 163 | /* ditto */ |
| 164 | ushort NetOurNativeVLAN = 0xFFFF; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 165 | |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 166 | /* Boot File name */ |
Joe Hershberger | 1411157 | 2015-04-08 01:41:02 -0500 | [diff] [blame] | 167 | char net_boot_file_name[128]; |
| 168 | /* The actual transferred size of the bootfile (in bytes) */ |
| 169 | u32 net_boot_file_size; |
| 170 | /* Boot file size in blocks as reported by the DHCP server */ |
| 171 | u32 net_boot_file_expected_size_in_blocks; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 172 | |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 173 | #if defined(CONFIG_CMD_SNTP) |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 174 | /* NTP server IP address */ |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 175 | struct in_addr net_ntp_server; |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 176 | /* offset time from UTC */ |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 177 | int NetTimeOffset; |
wdenk | ea287de | 2005-04-01 00:25:43 +0000 | [diff] [blame] | 178 | #endif |
| 179 | |
Joe Hershberger | 1203fcc | 2015-04-08 01:41:05 -0500 | [diff] [blame] | 180 | static uchar net_pkt_buf[(PKTBUFSRX+1) * PKTSIZE_ALIGN + PKTALIGN]; |
Joe Hershberger | 2a504df | 2015-03-22 17:09:11 -0500 | [diff] [blame] | 181 | /* Receive packets */ |
| 182 | uchar *net_rx_packets[PKTBUFSRX]; |
Joe Hershberger | ece223b | 2012-05-23 07:59:15 +0000 | [diff] [blame] | 183 | /* Current UDP RX packet handler */ |
| 184 | static rxhand_f *udp_packet_handler; |
| 185 | /* Current ARP RX packet handler */ |
| 186 | static rxhand_f *arp_packet_handler; |
Simon Glass | 39bccd2 | 2011-10-26 14:18:38 +0000 | [diff] [blame] | 187 | #ifdef CONFIG_CMD_TFTPPUT |
Joe Hershberger | ece223b | 2012-05-23 07:59:15 +0000 | [diff] [blame] | 188 | /* Current ICMP rx handler */ |
| 189 | static rxhand_icmp_f *packet_icmp_handler; |
Simon Glass | 39bccd2 | 2011-10-26 14:18:38 +0000 | [diff] [blame] | 190 | #endif |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 191 | /* Current timeout handler */ |
| 192 | static thand_f *timeHandler; |
| 193 | /* Time base value */ |
| 194 | static ulong timeStart; |
| 195 | /* Current timeout value */ |
| 196 | static ulong timeDelta; |
| 197 | /* THE transmit packet */ |
Joe Hershberger | 1203fcc | 2015-04-08 01:41:05 -0500 | [diff] [blame] | 198 | uchar *net_tx_packet; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 199 | |
Simon Glass | e4bf0c5 | 2011-10-24 18:00:02 +0000 | [diff] [blame] | 200 | static int net_check_prereq(enum proto_t protocol); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 201 | |
Remy Bohmer | 67b96e8 | 2009-10-28 22:13:39 +0100 | [diff] [blame] | 202 | static int NetTryCount; |
| 203 | |
Jim Lin | b63056d | 2013-08-13 19:03:05 +0800 | [diff] [blame] | 204 | int __maybe_unused net_busy_flag; |
| 205 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 206 | /**********************************************************************/ |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 207 | |
Joe Hershberger | a9f51c9 | 2012-12-11 22:16:26 -0600 | [diff] [blame] | 208 | static int on_bootfile(const char *name, const char *value, enum env_op op, |
| 209 | int flags) |
| 210 | { |
| 211 | switch (op) { |
| 212 | case env_op_create: |
| 213 | case env_op_overwrite: |
Joe Hershberger | 1411157 | 2015-04-08 01:41:02 -0500 | [diff] [blame] | 214 | copy_filename(net_boot_file_name, value, |
| 215 | sizeof(net_boot_file_name)); |
Joe Hershberger | a9f51c9 | 2012-12-11 22:16:26 -0600 | [diff] [blame] | 216 | break; |
| 217 | default: |
| 218 | break; |
| 219 | } |
| 220 | |
| 221 | return 0; |
| 222 | } |
| 223 | U_BOOT_ENV_CALLBACK(bootfile, on_bootfile); |
| 224 | |
Simon Glass | e4a3d57 | 2011-10-27 06:24:32 +0000 | [diff] [blame] | 225 | /* |
| 226 | * Check if autoload is enabled. If so, use either NFS or TFTP to download |
| 227 | * the boot file. |
| 228 | */ |
| 229 | void net_auto_load(void) |
| 230 | { |
Joe Hershberger | ec8a252 | 2012-12-11 22:16:22 -0600 | [diff] [blame] | 231 | #if defined(CONFIG_CMD_NFS) |
Simon Glass | e4a3d57 | 2011-10-27 06:24:32 +0000 | [diff] [blame] | 232 | const char *s = getenv("autoload"); |
| 233 | |
Joe Hershberger | ec8a252 | 2012-12-11 22:16:22 -0600 | [diff] [blame] | 234 | if (s != NULL && strcmp(s, "NFS") == 0) { |
| 235 | /* |
| 236 | * Use NFS to load the bootfile. |
| 237 | */ |
| 238 | NfsStart(); |
| 239 | return; |
| 240 | } |
Simon Glass | e4a3d57 | 2011-10-27 06:24:32 +0000 | [diff] [blame] | 241 | #endif |
Joe Hershberger | ec8a252 | 2012-12-11 22:16:22 -0600 | [diff] [blame] | 242 | if (getenv_yesno("autoload") == 0) { |
| 243 | /* |
| 244 | * Just use BOOTP/RARP to configure system; |
| 245 | * Do not use TFTP to load the bootfile. |
| 246 | */ |
| 247 | net_set_state(NETLOOP_SUCCESS); |
| 248 | return; |
Simon Glass | e4a3d57 | 2011-10-27 06:24:32 +0000 | [diff] [blame] | 249 | } |
| 250 | TftpStart(TFTPGET); |
| 251 | } |
| 252 | |
Joe Hershberger | cb1c991 | 2012-05-23 07:59:21 +0000 | [diff] [blame] | 253 | static void NetInitLoop(void) |
Heiko Schocher | 2f70c49 | 2009-02-10 09:38:52 +0100 | [diff] [blame] | 254 | { |
Luca Ceresoli | c586ce6 | 2011-05-11 03:59:55 +0000 | [diff] [blame] | 255 | static int env_changed_id; |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 256 | int env_id = get_env_id(); |
Heiko Schocher | 2f70c49 | 2009-02-10 09:38:52 +0100 | [diff] [blame] | 257 | |
| 258 | /* update only when the environment has changed */ |
Michael Zaidman | 3c172c4 | 2009-04-04 01:43:00 +0300 | [diff] [blame] | 259 | if (env_changed_id != env_id) { |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 260 | net_ip = getenv_ip("ipaddr"); |
| 261 | net_gateway = getenv_ip("gatewayip"); |
| 262 | net_netmask = getenv_ip("netmask"); |
| 263 | net_server_ip = getenv_ip("serverip"); |
Heiko Schocher | 2f70c49 | 2009-02-10 09:38:52 +0100 | [diff] [blame] | 264 | NetOurNativeVLAN = getenv_VLAN("nvlan"); |
Michael Zaidman | 3c172c4 | 2009-04-04 01:43:00 +0300 | [diff] [blame] | 265 | NetOurVLAN = getenv_VLAN("vlan"); |
Robin Getz | 1a32bf4 | 2009-07-20 14:53:54 -0400 | [diff] [blame] | 266 | #if defined(CONFIG_CMD_DNS) |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 267 | net_dns_server = getenv_ip("dnsip"); |
Robin Getz | 1a32bf4 | 2009-07-20 14:53:54 -0400 | [diff] [blame] | 268 | #endif |
Michael Zaidman | 3c172c4 | 2009-04-04 01:43:00 +0300 | [diff] [blame] | 269 | env_changed_id = env_id; |
Heiko Schocher | 2f70c49 | 2009-02-10 09:38:52 +0100 | [diff] [blame] | 270 | } |
Jim Lin | 7315cfd | 2013-05-17 17:41:03 +0800 | [diff] [blame] | 271 | if (eth_get_dev()) |
Joe Hershberger | 0adb5b7 | 2015-04-08 01:41:04 -0500 | [diff] [blame] | 272 | memcpy(net_ethaddr, eth_get_ethaddr(), 6); |
Michael Zaidman | 3c172c4 | 2009-04-04 01:43:00 +0300 | [diff] [blame] | 273 | |
Heiko Schocher | da95427 | 2009-04-28 08:36:11 +0200 | [diff] [blame] | 274 | return; |
Heiko Schocher | 2f70c49 | 2009-02-10 09:38:52 +0100 | [diff] [blame] | 275 | } |
| 276 | |
Joe Hershberger | ece223b | 2012-05-23 07:59:15 +0000 | [diff] [blame] | 277 | static void net_clear_handlers(void) |
| 278 | { |
| 279 | net_set_udp_handler(NULL); |
| 280 | net_set_arp_handler(NULL); |
| 281 | NetSetTimeout(0, NULL); |
| 282 | } |
| 283 | |
| 284 | static void net_cleanup_loop(void) |
| 285 | { |
| 286 | net_clear_handlers(); |
| 287 | } |
| 288 | |
Joe Hershberger | 46c495d | 2012-05-23 07:59:22 +0000 | [diff] [blame] | 289 | void net_init(void) |
| 290 | { |
| 291 | static int first_call = 1; |
| 292 | |
| 293 | if (first_call) { |
| 294 | /* |
| 295 | * Setup packet buffers, aligned correctly. |
| 296 | */ |
| 297 | int i; |
| 298 | |
Joe Hershberger | 1203fcc | 2015-04-08 01:41:05 -0500 | [diff] [blame] | 299 | net_tx_packet = &net_pkt_buf[0] + (PKTALIGN - 1); |
| 300 | net_tx_packet -= (ulong)net_tx_packet % PKTALIGN; |
Joe Hershberger | 2a504df | 2015-03-22 17:09:11 -0500 | [diff] [blame] | 301 | for (i = 0; i < PKTBUFSRX; i++) { |
Joe Hershberger | 1203fcc | 2015-04-08 01:41:05 -0500 | [diff] [blame] | 302 | net_rx_packets[i] = net_tx_packet + |
| 303 | (i + 1) * PKTSIZE_ALIGN; |
Joe Hershberger | 2a504df | 2015-03-22 17:09:11 -0500 | [diff] [blame] | 304 | } |
Joe Hershberger | 46c495d | 2012-05-23 07:59:22 +0000 | [diff] [blame] | 305 | ArpInit(); |
| 306 | net_clear_handlers(); |
| 307 | |
| 308 | /* Only need to setup buffer pointers once. */ |
| 309 | first_call = 0; |
| 310 | } |
| 311 | |
| 312 | NetInitLoop(); |
| 313 | } |
| 314 | |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 315 | /**********************************************************************/ |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 316 | /* |
| 317 | * Main network processing loop. |
| 318 | */ |
| 319 | |
Simon Glass | e4bf0c5 | 2011-10-24 18:00:02 +0000 | [diff] [blame] | 320 | int NetLoop(enum proto_t protocol) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 321 | { |
Joe Hershberger | 6030459 | 2015-03-22 17:09:24 -0500 | [diff] [blame] | 322 | int ret = -EINVAL; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 323 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 324 | NetRestarted = 0; |
| 325 | NetDevExists = 0; |
Remy Bohmer | 67b96e8 | 2009-10-28 22:13:39 +0100 | [diff] [blame] | 326 | NetTryCount = 1; |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 327 | debug_cond(DEBUG_INT_STATE, "--- NetLoop Entry\n"); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 328 | |
Simon Glass | 573f14f | 2011-12-10 11:08:06 +0000 | [diff] [blame] | 329 | bootstage_mark_name(BOOTSTAGE_ID_ETH_START, "eth_start"); |
Joe Hershberger | 46c495d | 2012-05-23 07:59:22 +0000 | [diff] [blame] | 330 | net_init(); |
Joe Hershberger | f8be7d6 | 2012-08-03 10:59:08 +0000 | [diff] [blame] | 331 | if (eth_is_on_demand_init() || protocol != NETCONS) { |
wdenk | b1bf6f2 | 2005-04-03 14:52:59 +0000 | [diff] [blame] | 332 | eth_halt(); |
Joe Hershberger | f8be7d6 | 2012-08-03 10:59:08 +0000 | [diff] [blame] | 333 | eth_set_current(); |
Joe Hershberger | 6030459 | 2015-03-22 17:09:24 -0500 | [diff] [blame] | 334 | ret = eth_init(); |
| 335 | if (ret < 0) { |
Joe Hershberger | f8be7d6 | 2012-08-03 10:59:08 +0000 | [diff] [blame] | 336 | eth_halt(); |
Joe Hershberger | 6030459 | 2015-03-22 17:09:24 -0500 | [diff] [blame] | 337 | return ret; |
Joe Hershberger | f8be7d6 | 2012-08-03 10:59:08 +0000 | [diff] [blame] | 338 | } |
| 339 | } else |
Joe Hershberger | d2eaec6 | 2015-03-22 17:09:06 -0500 | [diff] [blame] | 340 | eth_init_state_only(); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 341 | |
| 342 | restart: |
Jim Lin | b63056d | 2013-08-13 19:03:05 +0800 | [diff] [blame] | 343 | #ifdef CONFIG_USB_KEYBOARD |
| 344 | net_busy_flag = 0; |
| 345 | #endif |
Joe Hershberger | 22f6e99 | 2012-05-23 07:59:14 +0000 | [diff] [blame] | 346 | net_set_state(NETLOOP_CONTINUE); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 347 | |
| 348 | /* |
| 349 | * Start the ball rolling with the given start function. From |
| 350 | * here on, this code is a state machine driven by received |
| 351 | * packets and timer events. |
| 352 | */ |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 353 | debug_cond(DEBUG_INT_STATE, "--- NetLoop Init\n"); |
Joe Hershberger | cb1c991 | 2012-05-23 07:59:21 +0000 | [diff] [blame] | 354 | NetInitLoop(); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 355 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 356 | switch (net_check_prereq(protocol)) { |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 357 | case 1: |
| 358 | /* network not configured */ |
wdenk | b1bf6f2 | 2005-04-03 14:52:59 +0000 | [diff] [blame] | 359 | eth_halt(); |
Joe Hershberger | 6030459 | 2015-03-22 17:09:24 -0500 | [diff] [blame] | 360 | return -ENODEV; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 361 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 362 | case 2: |
| 363 | /* network device not configured */ |
| 364 | break; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 365 | |
| 366 | case 0: |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 367 | NetDevExists = 1; |
Joe Hershberger | 1411157 | 2015-04-08 01:41:02 -0500 | [diff] [blame] | 368 | net_boot_file_size = 0; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 369 | switch (protocol) { |
Simon Glass | e4bf0c5 | 2011-10-24 18:00:02 +0000 | [diff] [blame] | 370 | case TFTPGET: |
Simon Glass | 1fb7cd4 | 2011-10-24 18:00:07 +0000 | [diff] [blame] | 371 | #ifdef CONFIG_CMD_TFTPPUT |
| 372 | case TFTPPUT: |
| 373 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 374 | /* always use ARP to get server ethernet address */ |
Simon Glass | e4bf0c5 | 2011-10-24 18:00:02 +0000 | [diff] [blame] | 375 | TftpStart(protocol); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 376 | break; |
Luca Ceresoli | 7a83af0 | 2011-05-17 00:03:40 +0000 | [diff] [blame] | 377 | #ifdef CONFIG_CMD_TFTPSRV |
| 378 | case TFTPSRV: |
| 379 | TftpStartServer(); |
| 380 | break; |
| 381 | #endif |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 382 | #if defined(CONFIG_CMD_DHCP) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 383 | case DHCP: |
Stephen Warren | f59be6e | 2014-07-25 17:30:48 -0600 | [diff] [blame] | 384 | BootpReset(); |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 385 | net_ip.s_addr = 0; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 386 | DhcpRequest(); /* Basically same as BOOTP */ |
| 387 | break; |
Jon Loeliger | 610f2e9 | 2007-07-10 11:05:02 -0500 | [diff] [blame] | 388 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 389 | |
| 390 | case BOOTP: |
Stephen Warren | f59be6e | 2014-07-25 17:30:48 -0600 | [diff] [blame] | 391 | BootpReset(); |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 392 | net_ip.s_addr = 0; |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 393 | BootpRequest(); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 394 | break; |
| 395 | |
Peter Tyser | bf6cb24 | 2010-09-30 11:25:48 -0500 | [diff] [blame] | 396 | #if defined(CONFIG_CMD_RARP) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 397 | case RARP: |
| 398 | RarpTry = 0; |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 399 | net_ip.s_addr = 0; |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 400 | RarpRequest(); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 401 | break; |
Peter Tyser | bf6cb24 | 2010-09-30 11:25:48 -0500 | [diff] [blame] | 402 | #endif |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 403 | #if defined(CONFIG_CMD_PING) |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 404 | case PING: |
Joe Hershberger | a36b12f | 2012-05-23 07:58:02 +0000 | [diff] [blame] | 405 | ping_start(); |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 406 | break; |
| 407 | #endif |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 408 | #if defined(CONFIG_CMD_NFS) |
wdenk | cbd8a35 | 2004-02-24 02:00:03 +0000 | [diff] [blame] | 409 | case NFS: |
| 410 | NfsStart(); |
| 411 | break; |
| 412 | #endif |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 413 | #if defined(CONFIG_CMD_CDP) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 414 | case CDP: |
| 415 | CDPStart(); |
| 416 | break; |
| 417 | #endif |
Hannes Petermaier | 1f9ce30 | 2014-06-13 06:25:29 +0200 | [diff] [blame] | 418 | #if defined (CONFIG_NETCONSOLE) && !(CONFIG_SPL_BUILD) |
wdenk | 68ceb29 | 2004-08-02 21:11:11 +0000 | [diff] [blame] | 419 | case NETCONS: |
| 420 | NcStart(); |
| 421 | break; |
| 422 | #endif |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 423 | #if defined(CONFIG_CMD_SNTP) |
wdenk | ea287de | 2005-04-01 00:25:43 +0000 | [diff] [blame] | 424 | case SNTP: |
| 425 | SntpStart(); |
| 426 | break; |
| 427 | #endif |
Robin Getz | 1a32bf4 | 2009-07-20 14:53:54 -0400 | [diff] [blame] | 428 | #if defined(CONFIG_CMD_DNS) |
| 429 | case DNS: |
| 430 | DnsStart(); |
| 431 | break; |
| 432 | #endif |
Joe Hershberger | d22c338 | 2012-05-23 08:00:12 +0000 | [diff] [blame] | 433 | #if defined(CONFIG_CMD_LINK_LOCAL) |
| 434 | case LINKLOCAL: |
| 435 | link_local_start(); |
| 436 | break; |
| 437 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 438 | default: |
| 439 | break; |
| 440 | } |
| 441 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 442 | break; |
| 443 | } |
| 444 | |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 445 | #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 446 | #if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \ |
| 447 | defined(CONFIG_STATUS_LED) && \ |
| 448 | defined(STATUS_LED_RED) |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 449 | /* |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 450 | * Echo the inverted link state to the fault LED. |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 451 | */ |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame] | 452 | if (miiphy_link(eth_get_dev()->name, CONFIG_SYS_FAULT_MII_ADDR)) |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 453 | status_led_set(STATUS_LED_RED, STATUS_LED_OFF); |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame] | 454 | else |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 455 | status_led_set(STATUS_LED_RED, STATUS_LED_ON); |
Jean-Christophe PLAGNIOL-VILLARD | 6d0f6bc | 2008-10-16 15:01:15 +0200 | [diff] [blame] | 456 | #endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */ |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 457 | #endif /* CONFIG_MII, ... */ |
Jim Lin | b63056d | 2013-08-13 19:03:05 +0800 | [diff] [blame] | 458 | #ifdef CONFIG_USB_KEYBOARD |
| 459 | net_busy_flag = 1; |
| 460 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 461 | |
| 462 | /* |
| 463 | * Main packet reception loop. Loop receiving packets until |
Joe Hershberger | 22f6e99 | 2012-05-23 07:59:14 +0000 | [diff] [blame] | 464 | * someone sets `net_state' to a state that terminates. |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 465 | */ |
| 466 | for (;;) { |
| 467 | WATCHDOG_RESET(); |
| 468 | #ifdef CONFIG_SHOW_ACTIVITY |
Joe Hershberger | 48522bb | 2012-05-15 08:59:08 +0000 | [diff] [blame] | 469 | show_activity(1); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 470 | #endif |
| 471 | /* |
| 472 | * Check the ethernet for a new packet. The ethernet |
| 473 | * receive routine will process it. |
Joe Hershberger | 6030459 | 2015-03-22 17:09:24 -0500 | [diff] [blame] | 474 | * Most drivers return the most recent packet size, but not |
| 475 | * errors that may have happened. |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 476 | */ |
Guennadi Liakhovetski | 40cb90e | 2008-04-03 17:04:19 +0200 | [diff] [blame] | 477 | eth_rx(); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 478 | |
| 479 | /* |
| 480 | * Abort if ctrl-c was pressed. |
| 481 | */ |
| 482 | if (ctrlc()) { |
Joe Hershberger | e94070c | 2012-05-23 07:59:24 +0000 | [diff] [blame] | 483 | /* cancel any ARP that may not have completed */ |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 484 | net_arp_wait_packet_ip.s_addr = 0; |
Joe Hershberger | e94070c | 2012-05-23 07:59:24 +0000 | [diff] [blame] | 485 | |
Joe Hershberger | ece223b | 2012-05-23 07:59:15 +0000 | [diff] [blame] | 486 | net_cleanup_loop(); |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 487 | eth_halt(); |
Joe Hershberger | f8be7d6 | 2012-08-03 10:59:08 +0000 | [diff] [blame] | 488 | /* Invalidate the last protocol */ |
| 489 | eth_set_last_protocol(BOOTP); |
| 490 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 491 | puts("\nAbort\n"); |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 492 | /* include a debug print as well incase the debug |
| 493 | messages are directed to stderr */ |
| 494 | debug_cond(DEBUG_INT_STATE, "--- NetLoop Abort!\n"); |
Simon Glass | 4793ee6 | 2011-10-24 18:00:01 +0000 | [diff] [blame] | 495 | goto done; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 496 | } |
| 497 | |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 498 | ArpTimeoutCheck(); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 499 | |
| 500 | /* |
| 501 | * Check for a timeout, and run the timeout handler |
| 502 | * if we have one. |
| 503 | */ |
wdenk | e0ac62d | 2003-08-17 18:55:18 +0000 | [diff] [blame] | 504 | if (timeHandler && ((get_timer(0) - timeStart) > timeDelta)) { |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 505 | thand_f *x; |
| 506 | |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 507 | #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 508 | #if defined(CONFIG_SYS_FAULT_ECHO_LINK_DOWN) && \ |
| 509 | defined(CONFIG_STATUS_LED) && \ |
| 510 | defined(STATUS_LED_RED) |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 511 | /* |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 512 | * Echo the inverted link state to the fault LED. |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 513 | */ |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 514 | if (miiphy_link(eth_get_dev()->name, |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 515 | CONFIG_SYS_FAULT_MII_ADDR)) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 516 | status_led_set(STATUS_LED_RED, STATUS_LED_OFF); |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 517 | } else { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 518 | status_led_set(STATUS_LED_RED, STATUS_LED_ON); |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 519 | } |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 520 | #endif /* CONFIG_SYS_FAULT_ECHO_LINK_DOWN, ... */ |
wdenk | fc3e216 | 2003-10-08 22:33:00 +0000 | [diff] [blame] | 521 | #endif /* CONFIG_MII, ... */ |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 522 | debug_cond(DEBUG_INT_STATE, "--- NetLoop timeout\n"); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 523 | x = timeHandler; |
| 524 | timeHandler = (thand_f *)0; |
| 525 | (*x)(); |
| 526 | } |
| 527 | |
Joe Hershberger | 5c42133 | 2015-03-22 17:09:07 -0500 | [diff] [blame] | 528 | if (net_state == NETLOOP_FAIL) |
Joe Hershberger | 6030459 | 2015-03-22 17:09:24 -0500 | [diff] [blame] | 529 | ret = NetStartAgain(); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 530 | |
Joe Hershberger | 22f6e99 | 2012-05-23 07:59:14 +0000 | [diff] [blame] | 531 | switch (net_state) { |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 532 | |
| 533 | case NETLOOP_RESTART: |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 534 | NetRestarted = 1; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 535 | goto restart; |
| 536 | |
| 537 | case NETLOOP_SUCCESS: |
Joe Hershberger | ece223b | 2012-05-23 07:59:15 +0000 | [diff] [blame] | 538 | net_cleanup_loop(); |
Joe Hershberger | 1411157 | 2015-04-08 01:41:02 -0500 | [diff] [blame] | 539 | if (net_boot_file_size > 0) { |
| 540 | printf("Bytes transferred = %d (%x hex)\n", |
| 541 | net_boot_file_size, net_boot_file_size); |
| 542 | setenv_hex("filesize", net_boot_file_size); |
Simon Glass | 978226d | 2013-02-24 17:33:24 +0000 | [diff] [blame] | 543 | setenv_hex("fileaddr", load_addr); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 544 | } |
Joe Hershberger | f8be7d6 | 2012-08-03 10:59:08 +0000 | [diff] [blame] | 545 | if (protocol != NETCONS) |
| 546 | eth_halt(); |
| 547 | else |
| 548 | eth_halt_state_only(); |
| 549 | |
| 550 | eth_set_last_protocol(protocol); |
| 551 | |
Joe Hershberger | 1411157 | 2015-04-08 01:41:02 -0500 | [diff] [blame] | 552 | ret = net_boot_file_size; |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 553 | debug_cond(DEBUG_INT_STATE, "--- NetLoop Success!\n"); |
Simon Glass | 4793ee6 | 2011-10-24 18:00:01 +0000 | [diff] [blame] | 554 | goto done; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 555 | |
| 556 | case NETLOOP_FAIL: |
Joe Hershberger | ece223b | 2012-05-23 07:59:15 +0000 | [diff] [blame] | 557 | net_cleanup_loop(); |
Joe Hershberger | f8be7d6 | 2012-08-03 10:59:08 +0000 | [diff] [blame] | 558 | /* Invalidate the last protocol */ |
| 559 | eth_set_last_protocol(BOOTP); |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 560 | debug_cond(DEBUG_INT_STATE, "--- NetLoop Fail!\n"); |
Simon Glass | 4793ee6 | 2011-10-24 18:00:01 +0000 | [diff] [blame] | 561 | goto done; |
Joe Hershberger | 22f6e99 | 2012-05-23 07:59:14 +0000 | [diff] [blame] | 562 | |
| 563 | case NETLOOP_CONTINUE: |
| 564 | continue; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 565 | } |
| 566 | } |
Simon Glass | 4793ee6 | 2011-10-24 18:00:01 +0000 | [diff] [blame] | 567 | |
| 568 | done: |
Jim Lin | b63056d | 2013-08-13 19:03:05 +0800 | [diff] [blame] | 569 | #ifdef CONFIG_USB_KEYBOARD |
| 570 | net_busy_flag = 0; |
| 571 | #endif |
Simon Glass | 39bccd2 | 2011-10-26 14:18:38 +0000 | [diff] [blame] | 572 | #ifdef CONFIG_CMD_TFTPPUT |
Simon Glass | 4793ee6 | 2011-10-24 18:00:01 +0000 | [diff] [blame] | 573 | /* Clear out the handlers */ |
Joe Hershberger | ece223b | 2012-05-23 07:59:15 +0000 | [diff] [blame] | 574 | net_set_udp_handler(NULL); |
Simon Glass | 4793ee6 | 2011-10-24 18:00:01 +0000 | [diff] [blame] | 575 | net_set_icmp_handler(NULL); |
Simon Glass | 39bccd2 | 2011-10-26 14:18:38 +0000 | [diff] [blame] | 576 | #endif |
Simon Glass | 4793ee6 | 2011-10-24 18:00:01 +0000 | [diff] [blame] | 577 | return ret; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 578 | } |
| 579 | |
| 580 | /**********************************************************************/ |
| 581 | |
| 582 | static void |
| 583 | startAgainTimeout(void) |
| 584 | { |
Joe Hershberger | 22f6e99 | 2012-05-23 07:59:14 +0000 | [diff] [blame] | 585 | net_set_state(NETLOOP_RESTART); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 586 | } |
| 587 | |
Joe Hershberger | 6030459 | 2015-03-22 17:09:24 -0500 | [diff] [blame] | 588 | int NetStartAgain(void) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 589 | { |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 590 | char *nretry; |
Remy Bohmer | 67b96e8 | 2009-10-28 22:13:39 +0100 | [diff] [blame] | 591 | int retry_forever = 0; |
| 592 | unsigned long retrycnt = 0; |
Joe Hershberger | 6030459 | 2015-03-22 17:09:24 -0500 | [diff] [blame] | 593 | int ret; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 594 | |
Remy Bohmer | 67b96e8 | 2009-10-28 22:13:39 +0100 | [diff] [blame] | 595 | nretry = getenv("netretry"); |
| 596 | if (nretry) { |
| 597 | if (!strcmp(nretry, "yes")) |
| 598 | retry_forever = 1; |
| 599 | else if (!strcmp(nretry, "no")) |
| 600 | retrycnt = 0; |
| 601 | else if (!strcmp(nretry, "once")) |
| 602 | retrycnt = 1; |
| 603 | else |
| 604 | retrycnt = simple_strtoul(nretry, NULL, 0); |
Joe Hershberger | 5c42133 | 2015-03-22 17:09:07 -0500 | [diff] [blame] | 605 | } else { |
| 606 | retrycnt = 0; |
| 607 | retry_forever = 0; |
| 608 | } |
Remy Bohmer | 67b96e8 | 2009-10-28 22:13:39 +0100 | [diff] [blame] | 609 | |
| 610 | if ((!retry_forever) && (NetTryCount >= retrycnt)) { |
| 611 | eth_halt(); |
Joe Hershberger | 22f6e99 | 2012-05-23 07:59:14 +0000 | [diff] [blame] | 612 | net_set_state(NETLOOP_FAIL); |
Joe Hershberger | 6030459 | 2015-03-22 17:09:24 -0500 | [diff] [blame] | 613 | /* |
| 614 | * We don't provide a way for the protocol to return an error, |
| 615 | * but this is almost always the reason. |
| 616 | */ |
| 617 | return -ETIMEDOUT; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 618 | } |
Remy Bohmer | 67b96e8 | 2009-10-28 22:13:39 +0100 | [diff] [blame] | 619 | |
| 620 | NetTryCount++; |
| 621 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 622 | eth_halt(); |
Matthias Fuchs | 8b0c5c1 | 2007-12-27 16:58:41 +0100 | [diff] [blame] | 623 | #if !defined(CONFIG_NET_DO_NOT_TRY_ANOTHER) |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 624 | eth_try_another(!NetRestarted); |
Matthias Fuchs | 8b0c5c1 | 2007-12-27 16:58:41 +0100 | [diff] [blame] | 625 | #endif |
Joe Hershberger | 6030459 | 2015-03-22 17:09:24 -0500 | [diff] [blame] | 626 | ret = eth_init(); |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 627 | if (NetRestartWrap) { |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 628 | NetRestartWrap = 0; |
Remy Bohmer | 67b96e8 | 2009-10-28 22:13:39 +0100 | [diff] [blame] | 629 | if (NetDevExists) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 630 | NetSetTimeout(10000UL, startAgainTimeout); |
Joe Hershberger | ece223b | 2012-05-23 07:59:15 +0000 | [diff] [blame] | 631 | net_set_udp_handler(NULL); |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 632 | } else { |
Joe Hershberger | 22f6e99 | 2012-05-23 07:59:14 +0000 | [diff] [blame] | 633 | net_set_state(NETLOOP_FAIL); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 634 | } |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 635 | } else { |
Joe Hershberger | 22f6e99 | 2012-05-23 07:59:14 +0000 | [diff] [blame] | 636 | net_set_state(NETLOOP_RESTART); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 637 | } |
Joe Hershberger | 6030459 | 2015-03-22 17:09:24 -0500 | [diff] [blame] | 638 | return ret; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 639 | } |
| 640 | |
| 641 | /**********************************************************************/ |
| 642 | /* |
| 643 | * Miscelaneous bits. |
| 644 | */ |
| 645 | |
Joe Hershberger | ece223b | 2012-05-23 07:59:15 +0000 | [diff] [blame] | 646 | static void dummy_handler(uchar *pkt, unsigned dport, |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 647 | struct in_addr sip, unsigned sport, |
Joe Hershberger | ece223b | 2012-05-23 07:59:15 +0000 | [diff] [blame] | 648 | unsigned len) |
Joe Hershberger | d280d3f | 2012-05-23 07:58:01 +0000 | [diff] [blame] | 649 | { |
Joe Hershberger | d280d3f | 2012-05-23 07:58:01 +0000 | [diff] [blame] | 650 | } |
| 651 | |
Joe Hershberger | ece223b | 2012-05-23 07:59:15 +0000 | [diff] [blame] | 652 | rxhand_f *net_get_udp_handler(void) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 653 | { |
Joe Hershberger | ece223b | 2012-05-23 07:59:15 +0000 | [diff] [blame] | 654 | return udp_packet_handler; |
| 655 | } |
| 656 | |
| 657 | void net_set_udp_handler(rxhand_f *f) |
| 658 | { |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 659 | debug_cond(DEBUG_INT_STATE, "--- NetLoop UDP handler set (%p)\n", f); |
Joe Hershberger | ece223b | 2012-05-23 07:59:15 +0000 | [diff] [blame] | 660 | if (f == NULL) |
| 661 | udp_packet_handler = dummy_handler; |
| 662 | else |
| 663 | udp_packet_handler = f; |
| 664 | } |
| 665 | |
| 666 | rxhand_f *net_get_arp_handler(void) |
| 667 | { |
| 668 | return arp_packet_handler; |
| 669 | } |
| 670 | |
| 671 | void net_set_arp_handler(rxhand_f *f) |
| 672 | { |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 673 | debug_cond(DEBUG_INT_STATE, "--- NetLoop ARP handler set (%p)\n", f); |
Joe Hershberger | ece223b | 2012-05-23 07:59:15 +0000 | [diff] [blame] | 674 | if (f == NULL) |
| 675 | arp_packet_handler = dummy_handler; |
| 676 | else |
| 677 | arp_packet_handler = f; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 678 | } |
| 679 | |
Simon Glass | 39bccd2 | 2011-10-26 14:18:38 +0000 | [diff] [blame] | 680 | #ifdef CONFIG_CMD_TFTPPUT |
Simon Glass | 4793ee6 | 2011-10-24 18:00:01 +0000 | [diff] [blame] | 681 | void net_set_icmp_handler(rxhand_icmp_f *f) |
| 682 | { |
| 683 | packet_icmp_handler = f; |
| 684 | } |
Simon Glass | 39bccd2 | 2011-10-26 14:18:38 +0000 | [diff] [blame] | 685 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 686 | |
| 687 | void |
Luca Ceresoli | 6b147d1 | 2011-05-04 02:40:44 +0000 | [diff] [blame] | 688 | NetSetTimeout(ulong iv, thand_f *f) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 689 | { |
| 690 | if (iv == 0) { |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 691 | debug_cond(DEBUG_INT_STATE, |
| 692 | "--- NetLoop timeout handler cancelled\n"); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 693 | timeHandler = (thand_f *)0; |
| 694 | } else { |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 695 | debug_cond(DEBUG_INT_STATE, |
| 696 | "--- NetLoop timeout handler set (%p)\n", f); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 697 | timeHandler = f; |
wdenk | e0ac62d | 2003-08-17 18:55:18 +0000 | [diff] [blame] | 698 | timeStart = get_timer(0); |
Tetsuyuki Kobayashi | 1389f98 | 2012-06-25 02:37:27 +0000 | [diff] [blame] | 699 | timeDelta = iv * CONFIG_SYS_HZ / 1000; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 700 | } |
| 701 | } |
| 702 | |
Joe Hershberger | 1203fcc | 2015-04-08 01:41:05 -0500 | [diff] [blame] | 703 | int net_send_udp_packet(uchar *ether, struct in_addr dest, int dport, int sport, |
Joe Hershberger | 206d07f | 2012-05-23 07:58:10 +0000 | [diff] [blame] | 704 | int payload_len) |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 705 | { |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 706 | uchar *pkt; |
Joe Hershberger | 9214637 | 2012-05-23 07:59:08 +0000 | [diff] [blame] | 707 | int eth_hdr_size; |
| 708 | int pkt_hdr_size; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 709 | |
Joe Hershberger | 1203fcc | 2015-04-08 01:41:05 -0500 | [diff] [blame] | 710 | /* make sure the net_tx_packet is initialized (NetInit() was called) */ |
| 711 | assert(net_tx_packet != NULL); |
| 712 | if (net_tx_packet == NULL) |
Joe Hershberger | 46c495d | 2012-05-23 07:59:22 +0000 | [diff] [blame] | 713 | return -1; |
| 714 | |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 715 | /* convert to new style broadcast */ |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 716 | if (dest.s_addr == 0) |
| 717 | dest.s_addr = 0xFFFFFFFF; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 718 | |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 719 | /* if broadcast, make the ether address a broadcast and don't do ARP */ |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 720 | if (dest.s_addr == 0xFFFFFFFF) |
Joe Hershberger | 0adb5b7 | 2015-04-08 01:41:04 -0500 | [diff] [blame] | 721 | ether = (uchar *)net_bcast_ethaddr; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 722 | |
Joe Hershberger | 1203fcc | 2015-04-08 01:41:05 -0500 | [diff] [blame] | 723 | pkt = (uchar *)net_tx_packet; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 724 | |
Joe Hershberger | 1203fcc | 2015-04-08 01:41:05 -0500 | [diff] [blame] | 725 | eth_hdr_size = net_set_ether(pkt, ether, PROT_IP); |
Joe Hershberger | 9214637 | 2012-05-23 07:59:08 +0000 | [diff] [blame] | 726 | pkt += eth_hdr_size; |
| 727 | net_set_udp_header(pkt, dest, dport, sport, payload_len); |
| 728 | pkt_hdr_size = eth_hdr_size + IP_UDP_HDR_SIZE; |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 729 | |
Joe Hershberger | e94070c | 2012-05-23 07:59:24 +0000 | [diff] [blame] | 730 | /* if MAC address was not discovered yet, do an ARP request */ |
Joe Hershberger | 0adb5b7 | 2015-04-08 01:41:04 -0500 | [diff] [blame] | 731 | if (memcmp(ether, net_null_ethaddr, 6) == 0) { |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 732 | debug_cond(DEBUG_DEV_PKT, "sending ARP for %pI4\n", &dest); |
Joe Hershberger | 9214637 | 2012-05-23 07:59:08 +0000 | [diff] [blame] | 733 | |
| 734 | /* save the ip and eth addr for the packet to send after arp */ |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 735 | net_arp_wait_packet_ip = dest; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 736 | NetArpWaitPacketMAC = ether; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 737 | |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 738 | /* size of the waiting packet */ |
Joe Hershberger | 9214637 | 2012-05-23 07:59:08 +0000 | [diff] [blame] | 739 | NetArpWaitTxPacketSize = pkt_hdr_size + payload_len; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 740 | |
| 741 | /* and do the ARP request */ |
| 742 | NetArpWaitTry = 1; |
| 743 | NetArpWaitTimerStart = get_timer(0); |
| 744 | ArpRequest(); |
| 745 | return 1; /* waiting */ |
Joe Hershberger | 9214637 | 2012-05-23 07:59:08 +0000 | [diff] [blame] | 746 | } else { |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 747 | debug_cond(DEBUG_DEV_PKT, "sending UDP to %pI4/%pM\n", |
| 748 | &dest, ether); |
Joe Hershberger | 1203fcc | 2015-04-08 01:41:05 -0500 | [diff] [blame] | 749 | net_send_packet(net_tx_packet, pkt_hdr_size + payload_len); |
Joe Hershberger | 9214637 | 2012-05-23 07:59:08 +0000 | [diff] [blame] | 750 | return 0; /* transmitted */ |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 751 | } |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 752 | } |
| 753 | |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 754 | #ifdef CONFIG_IP_DEFRAG |
| 755 | /* |
| 756 | * This function collects fragments in a single packet, according |
| 757 | * to the algorithm in RFC815. It returns NULL or the pointer to |
| 758 | * a complete packet, in static storage |
| 759 | */ |
| 760 | #ifndef CONFIG_NET_MAXDEFRAG |
| 761 | #define CONFIG_NET_MAXDEFRAG 16384 |
| 762 | #endif |
| 763 | /* |
| 764 | * MAXDEFRAG, above, is chosen in the config file and is real data |
| 765 | * so we need to add the NFS overhead, which is more than TFTP. |
| 766 | * To use sizeof in the internal unnamed structures, we need a real |
| 767 | * instance (can't do "sizeof(struct rpc_t.u.reply))", unfortunately). |
| 768 | * The compiler doesn't complain nor allocates the actual structure |
| 769 | */ |
| 770 | static struct rpc_t rpc_specimen; |
| 771 | #define IP_PKTSIZE (CONFIG_NET_MAXDEFRAG + sizeof(rpc_specimen.u.reply)) |
| 772 | |
Joe Hershberger | c5c59df | 2012-05-23 07:58:05 +0000 | [diff] [blame] | 773 | #define IP_MAXUDP (IP_PKTSIZE - IP_HDR_SIZE) |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 774 | |
| 775 | /* |
| 776 | * this is the packet being assembled, either data or frag control. |
| 777 | * Fragments go by 8 bytes, so this union must be 8 bytes long |
| 778 | */ |
| 779 | struct hole { |
| 780 | /* first_byte is address of this structure */ |
| 781 | u16 last_byte; /* last byte in this hole + 1 (begin of next hole) */ |
| 782 | u16 next_hole; /* index of next (in 8-b blocks), 0 == none */ |
| 783 | u16 prev_hole; /* index of prev, 0 == none */ |
| 784 | u16 unused; |
| 785 | }; |
| 786 | |
Joe Hershberger | 594c26f | 2012-05-23 07:58:04 +0000 | [diff] [blame] | 787 | static struct ip_udp_hdr *__NetDefragment(struct ip_udp_hdr *ip, int *lenp) |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 788 | { |
Joe Hershberger | 48522bb | 2012-05-15 08:59:08 +0000 | [diff] [blame] | 789 | static uchar pkt_buff[IP_PKTSIZE] __aligned(PKTALIGN); |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 790 | static u16 first_hole, total_len; |
| 791 | struct hole *payload, *thisfrag, *h, *newh; |
Joe Hershberger | 594c26f | 2012-05-23 07:58:04 +0000 | [diff] [blame] | 792 | struct ip_udp_hdr *localip = (struct ip_udp_hdr *)pkt_buff; |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 793 | uchar *indata = (uchar *)ip; |
| 794 | int offset8, start, len, done = 0; |
| 795 | u16 ip_off = ntohs(ip->ip_off); |
| 796 | |
| 797 | /* payload starts after IP header, this fragment is in there */ |
Joe Hershberger | c5c59df | 2012-05-23 07:58:05 +0000 | [diff] [blame] | 798 | payload = (struct hole *)(pkt_buff + IP_HDR_SIZE); |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 799 | offset8 = (ip_off & IP_OFFS); |
| 800 | thisfrag = payload + offset8; |
| 801 | start = offset8 * 8; |
Joe Hershberger | c5c59df | 2012-05-23 07:58:05 +0000 | [diff] [blame] | 802 | len = ntohs(ip->ip_len) - IP_HDR_SIZE; |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 803 | |
| 804 | if (start + len > IP_MAXUDP) /* fragment extends too far */ |
| 805 | return NULL; |
| 806 | |
| 807 | if (!total_len || localip->ip_id != ip->ip_id) { |
| 808 | /* new (or different) packet, reset structs */ |
| 809 | total_len = 0xffff; |
| 810 | payload[0].last_byte = ~0; |
| 811 | payload[0].next_hole = 0; |
| 812 | payload[0].prev_hole = 0; |
| 813 | first_hole = 0; |
| 814 | /* any IP header will work, copy the first we received */ |
Joe Hershberger | c5c59df | 2012-05-23 07:58:05 +0000 | [diff] [blame] | 815 | memcpy(localip, ip, IP_HDR_SIZE); |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 816 | } |
| 817 | |
| 818 | /* |
| 819 | * What follows is the reassembly algorithm. We use the payload |
| 820 | * array as a linked list of hole descriptors, as each hole starts |
| 821 | * at a multiple of 8 bytes. However, last byte can be whatever value, |
| 822 | * so it is represented as byte count, not as 8-byte blocks. |
| 823 | */ |
| 824 | |
| 825 | h = payload + first_hole; |
| 826 | while (h->last_byte < start) { |
| 827 | if (!h->next_hole) { |
| 828 | /* no hole that far away */ |
| 829 | return NULL; |
| 830 | } |
| 831 | h = payload + h->next_hole; |
| 832 | } |
| 833 | |
Fillod Stephane | e397e59 | 2010-06-11 19:26:43 +0200 | [diff] [blame] | 834 | /* last fragment may be 1..7 bytes, the "+7" forces acceptance */ |
| 835 | if (offset8 + ((len + 7) / 8) <= h - payload) { |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 836 | /* no overlap with holes (dup fragment?) */ |
| 837 | return NULL; |
| 838 | } |
| 839 | |
| 840 | if (!(ip_off & IP_FLAGS_MFRAG)) { |
| 841 | /* no more fragmentss: truncate this (last) hole */ |
| 842 | total_len = start + len; |
| 843 | h->last_byte = start + len; |
| 844 | } |
| 845 | |
| 846 | /* |
| 847 | * There is some overlap: fix the hole list. This code doesn't |
| 848 | * deal with a fragment that overlaps with two different holes |
| 849 | * (thus being a superset of a previously-received fragment). |
| 850 | */ |
| 851 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 852 | if ((h >= thisfrag) && (h->last_byte <= start + len)) { |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 853 | /* complete overlap with hole: remove hole */ |
| 854 | if (!h->prev_hole && !h->next_hole) { |
| 855 | /* last remaining hole */ |
| 856 | done = 1; |
| 857 | } else if (!h->prev_hole) { |
| 858 | /* first hole */ |
| 859 | first_hole = h->next_hole; |
| 860 | payload[h->next_hole].prev_hole = 0; |
| 861 | } else if (!h->next_hole) { |
| 862 | /* last hole */ |
| 863 | payload[h->prev_hole].next_hole = 0; |
| 864 | } else { |
| 865 | /* in the middle of the list */ |
| 866 | payload[h->next_hole].prev_hole = h->prev_hole; |
| 867 | payload[h->prev_hole].next_hole = h->next_hole; |
| 868 | } |
| 869 | |
| 870 | } else if (h->last_byte <= start + len) { |
| 871 | /* overlaps with final part of the hole: shorten this hole */ |
| 872 | h->last_byte = start; |
| 873 | |
| 874 | } else if (h >= thisfrag) { |
| 875 | /* overlaps with initial part of the hole: move this hole */ |
| 876 | newh = thisfrag + (len / 8); |
| 877 | *newh = *h; |
| 878 | h = newh; |
| 879 | if (h->next_hole) |
| 880 | payload[h->next_hole].prev_hole = (h - payload); |
| 881 | if (h->prev_hole) |
| 882 | payload[h->prev_hole].next_hole = (h - payload); |
| 883 | else |
| 884 | first_hole = (h - payload); |
| 885 | |
| 886 | } else { |
| 887 | /* fragment sits in the middle: split the hole */ |
| 888 | newh = thisfrag + (len / 8); |
| 889 | *newh = *h; |
| 890 | h->last_byte = start; |
| 891 | h->next_hole = (newh - payload); |
| 892 | newh->prev_hole = (h - payload); |
| 893 | if (newh->next_hole) |
| 894 | payload[newh->next_hole].prev_hole = (newh - payload); |
| 895 | } |
| 896 | |
| 897 | /* finally copy this fragment and possibly return whole packet */ |
Joe Hershberger | c5c59df | 2012-05-23 07:58:05 +0000 | [diff] [blame] | 898 | memcpy((uchar *)thisfrag, indata + IP_HDR_SIZE, len); |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 899 | if (!done) |
| 900 | return NULL; |
| 901 | |
| 902 | localip->ip_len = htons(total_len); |
Joe Hershberger | c5c59df | 2012-05-23 07:58:05 +0000 | [diff] [blame] | 903 | *lenp = total_len + IP_HDR_SIZE; |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 904 | return localip; |
| 905 | } |
| 906 | |
Joe Hershberger | 594c26f | 2012-05-23 07:58:04 +0000 | [diff] [blame] | 907 | static inline struct ip_udp_hdr *NetDefragment(struct ip_udp_hdr *ip, int *lenp) |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 908 | { |
| 909 | u16 ip_off = ntohs(ip->ip_off); |
| 910 | if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG))) |
| 911 | return ip; /* not a fragment */ |
| 912 | return __NetDefragment(ip, lenp); |
| 913 | } |
| 914 | |
| 915 | #else /* !CONFIG_IP_DEFRAG */ |
| 916 | |
Joe Hershberger | 594c26f | 2012-05-23 07:58:04 +0000 | [diff] [blame] | 917 | static inline struct ip_udp_hdr *NetDefragment(struct ip_udp_hdr *ip, int *lenp) |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 918 | { |
| 919 | u16 ip_off = ntohs(ip->ip_off); |
| 920 | if (!(ip_off & (IP_OFFS | IP_FLAGS_MFRAG))) |
| 921 | return ip; /* not a fragment */ |
| 922 | return NULL; |
| 923 | } |
| 924 | #endif |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 925 | |
Simon Glass | 8f79bb1 | 2011-10-24 18:00:00 +0000 | [diff] [blame] | 926 | /** |
| 927 | * Receive an ICMP packet. We deal with REDIRECT and PING here, and silently |
| 928 | * drop others. |
| 929 | * |
| 930 | * @parma ip IP packet containing the ICMP |
| 931 | */ |
Joe Hershberger | 594c26f | 2012-05-23 07:58:04 +0000 | [diff] [blame] | 932 | static void receive_icmp(struct ip_udp_hdr *ip, int len, |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 933 | struct in_addr src_ip, struct ethernet_hdr *et) |
Simon Glass | 8f79bb1 | 2011-10-24 18:00:00 +0000 | [diff] [blame] | 934 | { |
Joe Hershberger | e0a6307 | 2012-05-23 07:58:09 +0000 | [diff] [blame] | 935 | struct icmp_hdr *icmph = (struct icmp_hdr *)&ip->udp_src; |
Simon Glass | 8f79bb1 | 2011-10-24 18:00:00 +0000 | [diff] [blame] | 936 | |
| 937 | switch (icmph->type) { |
| 938 | case ICMP_REDIRECT: |
| 939 | if (icmph->code != ICMP_REDIR_HOST) |
| 940 | return; |
| 941 | printf(" ICMP Host Redirect to %pI4 ", |
| 942 | &icmph->un.gateway); |
| 943 | break; |
Simon Glass | 8f79bb1 | 2011-10-24 18:00:00 +0000 | [diff] [blame] | 944 | default: |
Joe Hershberger | a36b12f | 2012-05-23 07:58:02 +0000 | [diff] [blame] | 945 | #if defined(CONFIG_CMD_PING) |
| 946 | ping_receive(et, ip, len); |
| 947 | #endif |
Simon Glass | 39bccd2 | 2011-10-26 14:18:38 +0000 | [diff] [blame] | 948 | #ifdef CONFIG_CMD_TFTPPUT |
Simon Glass | 4793ee6 | 2011-10-24 18:00:01 +0000 | [diff] [blame] | 949 | if (packet_icmp_handler) |
| 950 | packet_icmp_handler(icmph->type, icmph->code, |
| 951 | ntohs(ip->udp_dst), src_ip, ntohs(ip->udp_src), |
| 952 | icmph->un.data, ntohs(ip->udp_len)); |
Simon Glass | 39bccd2 | 2011-10-26 14:18:38 +0000 | [diff] [blame] | 953 | #endif |
Simon Glass | 8f79bb1 | 2011-10-24 18:00:00 +0000 | [diff] [blame] | 954 | break; |
| 955 | } |
| 956 | } |
| 957 | |
Joe Hershberger | 2a504df | 2015-03-22 17:09:11 -0500 | [diff] [blame] | 958 | void net_process_received_packet(uchar *in_packet, int len) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 959 | { |
Joe Hershberger | cb487f5 | 2012-05-23 07:58:06 +0000 | [diff] [blame] | 960 | struct ethernet_hdr *et; |
Joe Hershberger | 594c26f | 2012-05-23 07:58:04 +0000 | [diff] [blame] | 961 | struct ip_udp_hdr *ip; |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 962 | struct in_addr dst_ip; |
| 963 | struct in_addr src_ip; |
Joe Hershberger | 8d353eb | 2012-05-23 07:58:12 +0000 | [diff] [blame] | 964 | int eth_proto; |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 965 | #if defined(CONFIG_CMD_CDP) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 966 | int iscdp; |
| 967 | #endif |
| 968 | ushort cti = 0, vlanid = VLAN_NONE, myvlanid, mynvlanid; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 969 | |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 970 | debug_cond(DEBUG_NET_PKT, "packet received\n"); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 971 | |
Joe Hershberger | 1203fcc | 2015-04-08 01:41:05 -0500 | [diff] [blame] | 972 | net_rx_packet = in_packet; |
| 973 | net_rx_packet_len = len; |
Joe Hershberger | 2a504df | 2015-03-22 17:09:11 -0500 | [diff] [blame] | 974 | et = (struct ethernet_hdr *)in_packet; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 975 | |
| 976 | /* too small packet? */ |
| 977 | if (len < ETHER_HDR_SIZE) |
| 978 | return; |
| 979 | |
Rafal Jaworowski | f85b607 | 2007-12-27 18:19:02 +0100 | [diff] [blame] | 980 | #ifdef CONFIG_API |
| 981 | if (push_packet) { |
Joe Hershberger | 2a504df | 2015-03-22 17:09:11 -0500 | [diff] [blame] | 982 | (*push_packet)(in_packet, len); |
Rafal Jaworowski | f85b607 | 2007-12-27 18:19:02 +0100 | [diff] [blame] | 983 | return; |
| 984 | } |
| 985 | #endif |
| 986 | |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 987 | #if defined(CONFIG_CMD_CDP) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 988 | /* keep track if packet is CDP */ |
Joe Hershberger | 1735188 | 2012-05-23 07:58:00 +0000 | [diff] [blame] | 989 | iscdp = is_cdp_packet(et->et_dest); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 990 | #endif |
| 991 | |
| 992 | myvlanid = ntohs(NetOurVLAN); |
| 993 | if (myvlanid == (ushort)-1) |
| 994 | myvlanid = VLAN_NONE; |
| 995 | mynvlanid = ntohs(NetOurNativeVLAN); |
| 996 | if (mynvlanid == (ushort)-1) |
| 997 | mynvlanid = VLAN_NONE; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 998 | |
Joe Hershberger | 8d353eb | 2012-05-23 07:58:12 +0000 | [diff] [blame] | 999 | eth_proto = ntohs(et->et_protlen); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1000 | |
Joe Hershberger | 8d353eb | 2012-05-23 07:58:12 +0000 | [diff] [blame] | 1001 | if (eth_proto < 1514) { |
Joe Hershberger | cb487f5 | 2012-05-23 07:58:06 +0000 | [diff] [blame] | 1002 | struct e802_hdr *et802 = (struct e802_hdr *)et; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1003 | /* |
Joe Hershberger | da5ebe2 | 2012-05-23 07:58:11 +0000 | [diff] [blame] | 1004 | * Got a 802.2 packet. Check the other protocol field. |
| 1005 | * XXX VLAN over 802.2+SNAP not implemented! |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1006 | */ |
Joe Hershberger | 8d353eb | 2012-05-23 07:58:12 +0000 | [diff] [blame] | 1007 | eth_proto = ntohs(et802->et_prot); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1008 | |
Joe Hershberger | 2a504df | 2015-03-22 17:09:11 -0500 | [diff] [blame] | 1009 | ip = (struct ip_udp_hdr *)(in_packet + E802_HDR_SIZE); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1010 | len -= E802_HDR_SIZE; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1011 | |
Joe Hershberger | 8d353eb | 2012-05-23 07:58:12 +0000 | [diff] [blame] | 1012 | } else if (eth_proto != PROT_VLAN) { /* normal packet */ |
Joe Hershberger | 2a504df | 2015-03-22 17:09:11 -0500 | [diff] [blame] | 1013 | ip = (struct ip_udp_hdr *)(in_packet + ETHER_HDR_SIZE); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1014 | len -= ETHER_HDR_SIZE; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1015 | |
| 1016 | } else { /* VLAN packet */ |
Joe Hershberger | c68cca3 | 2012-05-23 07:58:07 +0000 | [diff] [blame] | 1017 | struct vlan_ethernet_hdr *vet = |
| 1018 | (struct vlan_ethernet_hdr *)et; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1019 | |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 1020 | debug_cond(DEBUG_NET_PKT, "VLAN packet received\n"); |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 1021 | |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1022 | /* too small packet? */ |
| 1023 | if (len < VLAN_ETHER_HDR_SIZE) |
| 1024 | return; |
| 1025 | |
| 1026 | /* if no VLAN active */ |
| 1027 | if ((ntohs(NetOurVLAN) & VLAN_IDMASK) == VLAN_NONE |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 1028 | #if defined(CONFIG_CMD_CDP) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1029 | && iscdp == 0 |
| 1030 | #endif |
| 1031 | ) |
| 1032 | return; |
| 1033 | |
| 1034 | cti = ntohs(vet->vet_tag); |
| 1035 | vlanid = cti & VLAN_IDMASK; |
Joe Hershberger | 8d353eb | 2012-05-23 07:58:12 +0000 | [diff] [blame] | 1036 | eth_proto = ntohs(vet->vet_type); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1037 | |
Joe Hershberger | 2a504df | 2015-03-22 17:09:11 -0500 | [diff] [blame] | 1038 | ip = (struct ip_udp_hdr *)(in_packet + VLAN_ETHER_HDR_SIZE); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1039 | len -= VLAN_ETHER_HDR_SIZE; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1040 | } |
| 1041 | |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 1042 | debug_cond(DEBUG_NET_PKT, "Receive from protocol 0x%x\n", eth_proto); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1043 | |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 1044 | #if defined(CONFIG_CMD_CDP) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1045 | if (iscdp) { |
Joe Hershberger | 0b4c5ff | 2012-05-23 07:58:13 +0000 | [diff] [blame] | 1046 | cdp_receive((uchar *)ip, len); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1047 | return; |
| 1048 | } |
| 1049 | #endif |
| 1050 | |
| 1051 | if ((myvlanid & VLAN_IDMASK) != VLAN_NONE) { |
| 1052 | if (vlanid == VLAN_NONE) |
| 1053 | vlanid = (mynvlanid & VLAN_IDMASK); |
| 1054 | /* not matched? */ |
| 1055 | if (vlanid != (myvlanid & VLAN_IDMASK)) |
| 1056 | return; |
| 1057 | } |
| 1058 | |
Joe Hershberger | 8d353eb | 2012-05-23 07:58:12 +0000 | [diff] [blame] | 1059 | switch (eth_proto) { |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1060 | |
| 1061 | case PROT_ARP: |
Joe Hershberger | d280d3f | 2012-05-23 07:58:01 +0000 | [diff] [blame] | 1062 | ArpReceive(et, ip, len); |
wdenk | 289f932 | 2005-01-12 00:15:14 +0000 | [diff] [blame] | 1063 | break; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1064 | |
Peter Tyser | bf6cb24 | 2010-09-30 11:25:48 -0500 | [diff] [blame] | 1065 | #ifdef CONFIG_CMD_RARP |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1066 | case PROT_RARP: |
Joe Hershberger | 8b9c532 | 2012-05-23 07:58:03 +0000 | [diff] [blame] | 1067 | rarp_receive(ip, len); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1068 | break; |
Peter Tyser | bf6cb24 | 2010-09-30 11:25:48 -0500 | [diff] [blame] | 1069 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1070 | case PROT_IP: |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 1071 | debug_cond(DEBUG_NET_PKT, "Got IP\n"); |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1072 | /* Before we start poking the header, make sure it is there */ |
Joe Hershberger | 594c26f | 2012-05-23 07:58:04 +0000 | [diff] [blame] | 1073 | if (len < IP_UDP_HDR_SIZE) { |
| 1074 | debug("len bad %d < %lu\n", len, |
| 1075 | (ulong)IP_UDP_HDR_SIZE); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1076 | return; |
| 1077 | } |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1078 | /* Check the packet length */ |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1079 | if (len < ntohs(ip->ip_len)) { |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 1080 | debug("len bad %d < %d\n", len, ntohs(ip->ip_len)); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1081 | return; |
| 1082 | } |
| 1083 | len = ntohs(ip->ip_len); |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 1084 | debug_cond(DEBUG_NET_PKT, "len=%d, v=%02x\n", |
| 1085 | len, ip->ip_hl_v & 0xff); |
Robin Getz | 0ebf04c | 2009-07-23 03:01:03 -0400 | [diff] [blame] | 1086 | |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1087 | /* Can't deal with anything except IPv4 */ |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame] | 1088 | if ((ip->ip_hl_v & 0xf0) != 0x40) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1089 | return; |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1090 | /* Can't deal with IP options (headers != 20 bytes) */ |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame] | 1091 | if ((ip->ip_hl_v & 0x0f) > 0x05) |
Remy Bohmer | 6b52cfe | 2008-06-03 15:48:17 +0200 | [diff] [blame] | 1092 | return; |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1093 | /* Check the Checksum of the header */ |
Simon Glass | 0da0fcd | 2015-01-19 22:16:08 -0700 | [diff] [blame] | 1094 | if (!ip_checksum_ok((uchar *)ip, IP_HDR_SIZE)) { |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 1095 | debug("checksum bad\n"); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1096 | return; |
| 1097 | } |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1098 | /* If it is not for us, ignore it */ |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1099 | dst_ip = net_read_ip(&ip->ip_dst); |
| 1100 | if (net_ip.s_addr && dst_ip.s_addr != net_ip.s_addr && |
| 1101 | dst_ip.s_addr != 0xFFFFFFFF) { |
David Updegraff | 53a5c42 | 2007-06-11 10:41:07 -0500 | [diff] [blame] | 1102 | #ifdef CONFIG_MCAST_TFTP |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1103 | if (net_mcast_addr != dst_ip) |
David Updegraff | 53a5c42 | 2007-06-11 10:41:07 -0500 | [diff] [blame] | 1104 | #endif |
Luca Ceresoli | c819abe | 2011-05-04 02:40:46 +0000 | [diff] [blame] | 1105 | return; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1106 | } |
Luca Ceresoli | 03eb129 | 2011-04-18 06:19:50 +0000 | [diff] [blame] | 1107 | /* Read source IP address for later use */ |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1108 | src_ip = net_read_ip(&ip->ip_src); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1109 | /* |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1110 | * The function returns the unchanged packet if it's not |
| 1111 | * a fragment, and either the complete packet or NULL if |
| 1112 | * it is a fragment (if !CONFIG_IP_DEFRAG, it returns NULL) |
| 1113 | */ |
Luca Ceresoli | ccb9ebe | 2011-05-04 02:40:47 +0000 | [diff] [blame] | 1114 | ip = NetDefragment(ip, &len); |
| 1115 | if (!ip) |
Alessandro Rubini | 5cfaa4e | 2009-08-07 13:58:56 +0200 | [diff] [blame] | 1116 | return; |
| 1117 | /* |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1118 | * watch for ICMP host redirects |
| 1119 | * |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1120 | * There is no real handler code (yet). We just watch |
| 1121 | * for ICMP host redirect messages. In case anybody |
| 1122 | * sees these messages: please contact me |
| 1123 | * (wd@denx.de), or - even better - send me the |
| 1124 | * necessary fixes :-) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1125 | * |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 1126 | * Note: in all cases where I have seen this so far |
| 1127 | * it was a problem with the router configuration, |
| 1128 | * for instance when a router was configured in the |
| 1129 | * BOOTP reply, but the TFTP server was on the same |
| 1130 | * subnet. So this is probably a warning that your |
| 1131 | * configuration might be wrong. But I'm not really |
| 1132 | * sure if there aren't any other situations. |
Simon Glass | 4793ee6 | 2011-10-24 18:00:01 +0000 | [diff] [blame] | 1133 | * |
| 1134 | * Simon Glass <sjg@chromium.org>: We get an ICMP when |
| 1135 | * we send a tftp packet to a dead connection, or when |
| 1136 | * there is no server at the other end. |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1137 | */ |
| 1138 | if (ip->ip_p == IPPROTO_ICMP) { |
Simon Glass | 8f79bb1 | 2011-10-24 18:00:00 +0000 | [diff] [blame] | 1139 | receive_icmp(ip, len, src_ip, et); |
| 1140 | return; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1141 | } else if (ip->ip_p != IPPROTO_UDP) { /* Only UDP packets */ |
| 1142 | return; |
| 1143 | } |
| 1144 | |
Joe Hershberger | 4ef8d53 | 2012-05-23 08:01:04 +0000 | [diff] [blame] | 1145 | debug_cond(DEBUG_DEV_PKT, |
| 1146 | "received UDP (to=%pI4, from=%pI4, len=%d)\n", |
| 1147 | &dst_ip, &src_ip, len); |
| 1148 | |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1149 | #ifdef CONFIG_UDP_CHECKSUM |
| 1150 | if (ip->udp_xsum != 0) { |
Wolfgang Denk | b2f5080 | 2005-08-12 23:43:12 +0200 | [diff] [blame] | 1151 | ulong xsum; |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1152 | ushort *sumptr; |
| 1153 | ushort sumlen; |
| 1154 | |
| 1155 | xsum = ip->ip_p; |
| 1156 | xsum += (ntohs(ip->udp_len)); |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1157 | xsum += (ntohl(ip->ip_src.s_addr) >> 16) & 0x0000ffff; |
| 1158 | xsum += (ntohl(ip->ip_src.s_addr) >> 0) & 0x0000ffff; |
| 1159 | xsum += (ntohl(ip->ip_dst.s_addr) >> 16) & 0x0000ffff; |
| 1160 | xsum += (ntohl(ip->ip_dst.s_addr) >> 0) & 0x0000ffff; |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1161 | |
| 1162 | sumlen = ntohs(ip->udp_len); |
| 1163 | sumptr = (ushort *) &(ip->udp_src); |
| 1164 | |
| 1165 | while (sumlen > 1) { |
Wolfgang Denk | b2f5080 | 2005-08-12 23:43:12 +0200 | [diff] [blame] | 1166 | ushort sumdata; |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1167 | |
| 1168 | sumdata = *sumptr++; |
| 1169 | xsum += ntohs(sumdata); |
| 1170 | sumlen -= 2; |
| 1171 | } |
| 1172 | if (sumlen > 0) { |
Wolfgang Denk | b2f5080 | 2005-08-12 23:43:12 +0200 | [diff] [blame] | 1173 | ushort sumdata; |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1174 | |
| 1175 | sumdata = *(unsigned char *) sumptr; |
Wolfgang Denk | b2f5080 | 2005-08-12 23:43:12 +0200 | [diff] [blame] | 1176 | sumdata = (sumdata << 8) & 0xff00; |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1177 | xsum += sumdata; |
| 1178 | } |
| 1179 | while ((xsum >> 16) != 0) { |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1180 | xsum = (xsum & 0x0000ffff) + |
| 1181 | ((xsum >> 16) & 0x0000ffff); |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1182 | } |
| 1183 | if ((xsum != 0x00000000) && (xsum != 0x0000ffff)) { |
Wolfgang Denk | 9b55a25 | 2008-07-11 01:16:00 +0200 | [diff] [blame] | 1184 | printf(" UDP wrong checksum %08lx %08x\n", |
| 1185 | xsum, ntohs(ip->udp_xsum)); |
Stefan Roese | 8534bf9 | 2005-08-12 20:06:52 +0200 | [diff] [blame] | 1186 | return; |
| 1187 | } |
| 1188 | } |
| 1189 | #endif |
| 1190 | |
David Updegraff | 53a5c42 | 2007-06-11 10:41:07 -0500 | [diff] [blame] | 1191 | |
Hannes Petermaier | 1f9ce30 | 2014-06-13 06:25:29 +0200 | [diff] [blame] | 1192 | #if defined (CONFIG_NETCONSOLE) && !(CONFIG_SPL_BUILD) |
Joe Hershberger | 594c26f | 2012-05-23 07:58:04 +0000 | [diff] [blame] | 1193 | nc_input_packet((uchar *)ip + IP_UDP_HDR_SIZE, |
Joe Hershberger | 8cab08e | 2012-10-03 09:14:03 +0000 | [diff] [blame] | 1194 | src_ip, |
Joe Hershberger | 594c26f | 2012-05-23 07:58:04 +0000 | [diff] [blame] | 1195 | ntohs(ip->udp_dst), |
| 1196 | ntohs(ip->udp_src), |
| 1197 | ntohs(ip->udp_len) - UDP_HDR_SIZE); |
wdenk | 68ceb29 | 2004-08-02 21:11:11 +0000 | [diff] [blame] | 1198 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1199 | /* |
| 1200 | * IP header OK. Pass the packet to the current handler. |
| 1201 | */ |
Joe Hershberger | ece223b | 2012-05-23 07:59:15 +0000 | [diff] [blame] | 1202 | (*udp_packet_handler)((uchar *)ip + IP_UDP_HDR_SIZE, |
| 1203 | ntohs(ip->udp_dst), |
| 1204 | src_ip, |
| 1205 | ntohs(ip->udp_src), |
| 1206 | ntohs(ip->udp_len) - UDP_HDR_SIZE); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1207 | break; |
| 1208 | } |
| 1209 | } |
| 1210 | |
| 1211 | |
| 1212 | /**********************************************************************/ |
| 1213 | |
Simon Glass | e4bf0c5 | 2011-10-24 18:00:02 +0000 | [diff] [blame] | 1214 | static int net_check_prereq(enum proto_t protocol) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1215 | { |
| 1216 | switch (protocol) { |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1217 | /* Fall through */ |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 1218 | #if defined(CONFIG_CMD_PING) |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1219 | case PING: |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1220 | if (net_ping_ip.s_addr == 0) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1221 | puts("*** ERROR: ping address not given\n"); |
Luca Ceresoli | 92895de | 2011-05-04 02:40:45 +0000 | [diff] [blame] | 1222 | return 1; |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1223 | } |
| 1224 | goto common; |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1225 | #endif |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 1226 | #if defined(CONFIG_CMD_SNTP) |
wdenk | ea287de | 2005-04-01 00:25:43 +0000 | [diff] [blame] | 1227 | case SNTP: |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1228 | if (net_ntp_server.s_addr == 0) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1229 | puts("*** ERROR: NTP server address not given\n"); |
Luca Ceresoli | 92895de | 2011-05-04 02:40:45 +0000 | [diff] [blame] | 1230 | return 1; |
wdenk | ea287de | 2005-04-01 00:25:43 +0000 | [diff] [blame] | 1231 | } |
| 1232 | goto common; |
| 1233 | #endif |
Robin Getz | 1a32bf4 | 2009-07-20 14:53:54 -0400 | [diff] [blame] | 1234 | #if defined(CONFIG_CMD_DNS) |
| 1235 | case DNS: |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1236 | if (net_dns_server.s_addr == 0) { |
Robin Getz | 1a32bf4 | 2009-07-20 14:53:54 -0400 | [diff] [blame] | 1237 | puts("*** ERROR: DNS server address not given\n"); |
| 1238 | return 1; |
| 1239 | } |
| 1240 | goto common; |
| 1241 | #endif |
Jon Loeliger | 643d1ab | 2007-07-09 17:45:14 -0500 | [diff] [blame] | 1242 | #if defined(CONFIG_CMD_NFS) |
wdenk | cbd8a35 | 2004-02-24 02:00:03 +0000 | [diff] [blame] | 1243 | case NFS: |
| 1244 | #endif |
Simon Glass | e4bf0c5 | 2011-10-24 18:00:02 +0000 | [diff] [blame] | 1245 | case TFTPGET: |
Simon Glass | 1fb7cd4 | 2011-10-24 18:00:07 +0000 | [diff] [blame] | 1246 | case TFTPPUT: |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1247 | if (net_server_ip.s_addr == 0) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1248 | puts("*** ERROR: `serverip' not set\n"); |
Luca Ceresoli | 92895de | 2011-05-04 02:40:45 +0000 | [diff] [blame] | 1249 | return 1; |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1250 | } |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1251 | #if defined(CONFIG_CMD_PING) || defined(CONFIG_CMD_SNTP) || \ |
| 1252 | defined(CONFIG_CMD_DNS) |
| 1253 | common: |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1254 | #endif |
Simon Guinot | 8b6bbe1 | 2011-05-01 23:38:40 +0000 | [diff] [blame] | 1255 | /* Fall through */ |
wdenk | 73a8b27 | 2003-06-05 19:27:42 +0000 | [diff] [blame] | 1256 | |
Simon Guinot | 8b6bbe1 | 2011-05-01 23:38:40 +0000 | [diff] [blame] | 1257 | case NETCONS: |
Luca Ceresoli | 7a83af0 | 2011-05-17 00:03:40 +0000 | [diff] [blame] | 1258 | case TFTPSRV: |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1259 | if (net_ip.s_addr == 0) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1260 | puts("*** ERROR: `ipaddr' not set\n"); |
Luca Ceresoli | 92895de | 2011-05-04 02:40:45 +0000 | [diff] [blame] | 1261 | return 1; |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1262 | } |
| 1263 | /* Fall through */ |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1264 | |
Peter Tyser | bf6cb24 | 2010-09-30 11:25:48 -0500 | [diff] [blame] | 1265 | #ifdef CONFIG_CMD_RARP |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1266 | case RARP: |
Peter Tyser | bf6cb24 | 2010-09-30 11:25:48 -0500 | [diff] [blame] | 1267 | #endif |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1268 | case BOOTP: |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1269 | case CDP: |
Peter Tyser | bf6cb24 | 2010-09-30 11:25:48 -0500 | [diff] [blame] | 1270 | case DHCP: |
Joe Hershberger | d22c338 | 2012-05-23 08:00:12 +0000 | [diff] [blame] | 1271 | case LINKLOCAL: |
Joe Hershberger | 0adb5b7 | 2015-04-08 01:41:04 -0500 | [diff] [blame] | 1272 | if (memcmp(net_ethaddr, "\0\0\0\0\0\0", 6) == 0) { |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1273 | int num = eth_get_dev_index(); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1274 | |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1275 | switch (num) { |
| 1276 | case -1: |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1277 | puts("*** ERROR: No ethernet found.\n"); |
Luca Ceresoli | 92895de | 2011-05-04 02:40:45 +0000 | [diff] [blame] | 1278 | return 1; |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1279 | case 0: |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1280 | puts("*** ERROR: `ethaddr' not set\n"); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1281 | break; |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1282 | default: |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1283 | printf("*** ERROR: `eth%daddr' not set\n", |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1284 | num); |
| 1285 | break; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1286 | } |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1287 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1288 | NetStartAgain(); |
Luca Ceresoli | 92895de | 2011-05-04 02:40:45 +0000 | [diff] [blame] | 1289 | return 2; |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1290 | } |
| 1291 | /* Fall through */ |
| 1292 | default: |
Luca Ceresoli | 92895de | 2011-05-04 02:40:45 +0000 | [diff] [blame] | 1293 | return 0; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1294 | } |
Luca Ceresoli | 92895de | 2011-05-04 02:40:45 +0000 | [diff] [blame] | 1295 | return 0; /* OK */ |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1296 | } |
| 1297 | /**********************************************************************/ |
| 1298 | |
| 1299 | int |
Joe Hershberger | 1203fcc | 2015-04-08 01:41:05 -0500 | [diff] [blame] | 1300 | net_eth_hdr_size(void) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1301 | { |
| 1302 | ushort myvlanid; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1303 | |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1304 | myvlanid = ntohs(NetOurVLAN); |
| 1305 | if (myvlanid == (ushort)-1) |
| 1306 | myvlanid = VLAN_NONE; |
| 1307 | |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1308 | return ((myvlanid & VLAN_IDMASK) == VLAN_NONE) ? ETHER_HDR_SIZE : |
| 1309 | VLAN_ETHER_HDR_SIZE; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1310 | } |
| 1311 | |
Joe Hershberger | 1203fcc | 2015-04-08 01:41:05 -0500 | [diff] [blame] | 1312 | int net_set_ether(uchar *xet, const uchar *dest_ethaddr, uint prot) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1313 | { |
Joe Hershberger | cb487f5 | 2012-05-23 07:58:06 +0000 | [diff] [blame] | 1314 | struct ethernet_hdr *et = (struct ethernet_hdr *)xet; |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1315 | ushort myvlanid; |
| 1316 | |
| 1317 | myvlanid = ntohs(NetOurVLAN); |
| 1318 | if (myvlanid == (ushort)-1) |
| 1319 | myvlanid = VLAN_NONE; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1320 | |
Joe Hershberger | 0adb5b7 | 2015-04-08 01:41:04 -0500 | [diff] [blame] | 1321 | memcpy(et->et_dest, dest_ethaddr, 6); |
| 1322 | memcpy(et->et_src, net_ethaddr, 6); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1323 | if ((myvlanid & VLAN_IDMASK) == VLAN_NONE) { |
Luca Ceresoli | c819abe | 2011-05-04 02:40:46 +0000 | [diff] [blame] | 1324 | et->et_protlen = htons(prot); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1325 | return ETHER_HDR_SIZE; |
| 1326 | } else { |
Joe Hershberger | c68cca3 | 2012-05-23 07:58:07 +0000 | [diff] [blame] | 1327 | struct vlan_ethernet_hdr *vet = |
| 1328 | (struct vlan_ethernet_hdr *)xet; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1329 | |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1330 | vet->vet_vlan_type = htons(PROT_VLAN); |
| 1331 | vet->vet_tag = htons((0 << 5) | (myvlanid & VLAN_IDMASK)); |
| 1332 | vet->vet_type = htons(prot); |
| 1333 | return VLAN_ETHER_HDR_SIZE; |
| 1334 | } |
| 1335 | } |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1336 | |
Joe Hershberger | e711101 | 2012-05-23 07:59:16 +0000 | [diff] [blame] | 1337 | int net_update_ether(struct ethernet_hdr *et, uchar *addr, uint prot) |
| 1338 | { |
| 1339 | ushort protlen; |
| 1340 | |
| 1341 | memcpy(et->et_dest, addr, 6); |
Joe Hershberger | 0adb5b7 | 2015-04-08 01:41:04 -0500 | [diff] [blame] | 1342 | memcpy(et->et_src, net_ethaddr, 6); |
Joe Hershberger | e711101 | 2012-05-23 07:59:16 +0000 | [diff] [blame] | 1343 | protlen = ntohs(et->et_protlen); |
| 1344 | if (protlen == PROT_VLAN) { |
| 1345 | struct vlan_ethernet_hdr *vet = |
| 1346 | (struct vlan_ethernet_hdr *)et; |
| 1347 | vet->vet_type = htons(prot); |
| 1348 | return VLAN_ETHER_HDR_SIZE; |
| 1349 | } else if (protlen > 1514) { |
| 1350 | et->et_protlen = htons(prot); |
| 1351 | return ETHER_HDR_SIZE; |
| 1352 | } else { |
| 1353 | /* 802.2 + SNAP */ |
| 1354 | struct e802_hdr *et802 = (struct e802_hdr *)et; |
| 1355 | et802->et_prot = htons(prot); |
| 1356 | return E802_HDR_SIZE; |
| 1357 | } |
| 1358 | } |
| 1359 | |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1360 | void net_set_ip_header(uchar *pkt, struct in_addr dest, struct in_addr source) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1361 | { |
Joe Hershberger | 4b11c91 | 2012-05-23 07:59:07 +0000 | [diff] [blame] | 1362 | struct ip_udp_hdr *ip = (struct ip_udp_hdr *)pkt; |
| 1363 | |
| 1364 | /* |
| 1365 | * Construct an IP header. |
| 1366 | */ |
| 1367 | /* IP_HDR_SIZE / 4 (not including UDP) */ |
| 1368 | ip->ip_hl_v = 0x45; |
| 1369 | ip->ip_tos = 0; |
| 1370 | ip->ip_len = htons(IP_HDR_SIZE); |
| 1371 | ip->ip_id = htons(NetIPID++); |
| 1372 | ip->ip_off = htons(IP_FLAGS_DFRAG); /* Don't fragment */ |
| 1373 | ip->ip_ttl = 255; |
| 1374 | ip->ip_sum = 0; |
| 1375 | /* already in network byte order */ |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1376 | net_copy_ip((void *)&ip->ip_src, &source); |
Joe Hershberger | 4b11c91 | 2012-05-23 07:59:07 +0000 | [diff] [blame] | 1377 | /* already in network byte order */ |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1378 | net_copy_ip((void *)&ip->ip_dst, &dest); |
Joe Hershberger | 4b11c91 | 2012-05-23 07:59:07 +0000 | [diff] [blame] | 1379 | } |
| 1380 | |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1381 | void net_set_udp_header(uchar *pkt, struct in_addr dest, int dport, int sport, |
Joe Hershberger | 4b11c91 | 2012-05-23 07:59:07 +0000 | [diff] [blame] | 1382 | int len) |
| 1383 | { |
| 1384 | struct ip_udp_hdr *ip = (struct ip_udp_hdr *)pkt; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1385 | |
| 1386 | /* |
| 1387 | * If the data is an odd number of bytes, zero the |
| 1388 | * byte after the last byte so that the checksum |
| 1389 | * will work. |
| 1390 | */ |
| 1391 | if (len & 1) |
Joe Hershberger | 4b11c91 | 2012-05-23 07:59:07 +0000 | [diff] [blame] | 1392 | pkt[IP_UDP_HDR_SIZE + len] = 0; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1393 | |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1394 | net_set_ip_header(pkt, dest, net_ip); |
Joe Hershberger | 594c26f | 2012-05-23 07:58:04 +0000 | [diff] [blame] | 1395 | ip->ip_len = htons(IP_UDP_HDR_SIZE + len); |
Joe Hershberger | 4b11c91 | 2012-05-23 07:59:07 +0000 | [diff] [blame] | 1396 | ip->ip_p = IPPROTO_UDP; |
Simon Glass | 0da0fcd | 2015-01-19 22:16:08 -0700 | [diff] [blame] | 1397 | ip->ip_sum = compute_ip_checksum(ip, IP_HDR_SIZE); |
Joe Hershberger | 4b11c91 | 2012-05-23 07:59:07 +0000 | [diff] [blame] | 1398 | |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1399 | ip->udp_src = htons(sport); |
| 1400 | ip->udp_dst = htons(dport); |
Joe Hershberger | 594c26f | 2012-05-23 07:58:04 +0000 | [diff] [blame] | 1401 | ip->udp_len = htons(UDP_HDR_SIZE + len); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1402 | ip->udp_xsum = 0; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1403 | } |
| 1404 | |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1405 | void copy_filename(char *dst, const char *src, int size) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1406 | { |
| 1407 | if (*src && (*src == '"')) { |
| 1408 | ++src; |
| 1409 | --size; |
| 1410 | } |
| 1411 | |
Luca Ceresoli | d3c65b0 | 2011-05-04 02:40:43 +0000 | [diff] [blame] | 1412 | while ((--size > 0) && *src && (*src != '"')) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1413 | *dst++ = *src++; |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1414 | *dst = '\0'; |
| 1415 | } |
| 1416 | |
Luca Ceresoli | 3e38e42 | 2011-05-11 03:59:54 +0000 | [diff] [blame] | 1417 | #if defined(CONFIG_CMD_NFS) || \ |
| 1418 | defined(CONFIG_CMD_SNTP) || \ |
| 1419 | defined(CONFIG_CMD_DNS) |
Robin Getz | 1a32bf4 | 2009-07-20 14:53:54 -0400 | [diff] [blame] | 1420 | /* |
Robin Getz | 9739946 | 2010-03-08 14:07:00 -0500 | [diff] [blame] | 1421 | * make port a little random (1024-17407) |
| 1422 | * This keeps the math somewhat trivial to compute, and seems to work with |
| 1423 | * all supported protocols/clients/servers |
Robin Getz | 1a32bf4 | 2009-07-20 14:53:54 -0400 | [diff] [blame] | 1424 | */ |
| 1425 | unsigned int random_port(void) |
| 1426 | { |
Robin Getz | 9739946 | 2010-03-08 14:07:00 -0500 | [diff] [blame] | 1427 | return 1024 + (get_timer(0) % 0x4000); |
Robin Getz | 1a32bf4 | 2009-07-20 14:53:54 -0400 | [diff] [blame] | 1428 | } |
| 1429 | #endif |
| 1430 | |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1431 | void ip_to_string(struct in_addr x, char *s) |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1432 | { |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1433 | x.s_addr = ntohl(x.s_addr); |
Luca Ceresoli | 4f63acd | 2011-05-11 03:59:56 +0000 | [diff] [blame] | 1434 | sprintf(s, "%d.%d.%d.%d", |
Joe Hershberger | 049a95a | 2015-04-08 01:41:01 -0500 | [diff] [blame] | 1435 | (int) ((x.s_addr >> 24) & 0xff), |
| 1436 | (int) ((x.s_addr >> 16) & 0xff), |
| 1437 | (int) ((x.s_addr >> 8) & 0xff), |
| 1438 | (int) ((x.s_addr >> 0) & 0xff) |
wdenk | 6e59238 | 2004-04-18 17:39:38 +0000 | [diff] [blame] | 1439 | ); |
wdenk | 2d96695 | 2002-10-31 22:12:35 +0000 | [diff] [blame] | 1440 | } |
| 1441 | |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1442 | void VLAN_to_string(ushort x, char *s) |
| 1443 | { |
| 1444 | x = ntohs(x); |
| 1445 | |
| 1446 | if (x == (ushort)-1) |
| 1447 | x = VLAN_NONE; |
| 1448 | |
| 1449 | if (x == VLAN_NONE) |
| 1450 | strcpy(s, "none"); |
| 1451 | else |
| 1452 | sprintf(s, "%d", x & VLAN_IDMASK); |
| 1453 | } |
| 1454 | |
Mike Frysinger | 2e3ef6e | 2010-10-20 07:16:48 -0400 | [diff] [blame] | 1455 | ushort string_to_VLAN(const char *s) |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1456 | { |
| 1457 | ushort id; |
| 1458 | |
| 1459 | if (s == NULL) |
wdenk | b9711de | 2004-04-25 13:18:40 +0000 | [diff] [blame] | 1460 | return htons(VLAN_NONE); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1461 | |
| 1462 | if (*s < '0' || *s > '9') |
| 1463 | id = VLAN_NONE; |
| 1464 | else |
| 1465 | id = (ushort)simple_strtoul(s, NULL, 10); |
| 1466 | |
wdenk | b9711de | 2004-04-25 13:18:40 +0000 | [diff] [blame] | 1467 | return htons(id); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1468 | } |
| 1469 | |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1470 | ushort getenv_VLAN(char *var) |
| 1471 | { |
Luca Ceresoli | 92895de | 2011-05-04 02:40:45 +0000 | [diff] [blame] | 1472 | return string_to_VLAN(getenv(var)); |
wdenk | a3d991b | 2004-04-15 21:48:45 +0000 | [diff] [blame] | 1473 | } |