Eric Lee / smarc-uboot

Download as
Browse Code ยป

Commit 16cf145fd659a01c5db7f286e8c9a4700f736920

Authored by Joe Hershberger
1 parent 3855cad623
Exists in smarc_8mq_lf_v2020.04 and in 11 other branches 8qm-imx_v2020.04_5.4.70_2.3.0, emb_lf_v2022.04, pitx_8mp_lf_v2020.04, smarc-8m-android-10.0.0_2.6.0, smarc-8m-android-11.0.0_2.0.0, smarc-8mp-android-11.0.0_2.0.0, smarc_8m-imx_v2019.04_4.19.35_1.1.0, smarc_8mm-imx_v2019.04_4.19.35_1.1.0, smarc_8mm-imx_v2020.04_5.4.24_2.1.0, smarc_8mp_lf_v2020.04, smarc_8mq-imx_v2020.04_5.4.24_2.1.0

net: Make copy_filename() accept NULL src 

Rather than crashing, check the src ptr and set dst to empty string.

Signed-off-by: Joe Hershberger <joe.hershberger@ni.com>

Showing 1 changed file with 2 additions and 2 deletions Inline Diff

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