xref: /openbmc/u-boot/net/bootp.c (revision 0edd82e2)
1 /*
2  *	Based on LiMon - BOOTP.
3  *
4  *	Copyright 1994, 1995, 2000 Neil Russell.
5  *	(See License)
6  *	Copyright 2000 Roland Borde
7  *	Copyright 2000 Paolo Scaffardi
8  *	Copyright 2000-2004 Wolfgang Denk, wd@denx.de
9  */
10 
11 #include <common.h>
12 #include <command.h>
13 #include <net.h>
14 #include <net/tftp.h>
15 #include "bootp.h"
16 #include "nfs.h"
17 #ifdef CONFIG_STATUS_LED
18 #include <status_led.h>
19 #endif
20 #ifdef CONFIG_BOOTP_RANDOM_DELAY
21 #include "net_rand.h"
22 #endif
23 
24 #define BOOTP_VENDOR_MAGIC	0x63825363	/* RFC1048 Magic Cookie */
25 
26 /*
27  * The timeout for the initial BOOTP/DHCP request used to be described by a
28  * counter of fixed-length timeout periods. TIMEOUT_COUNT represents
29  * that counter
30  *
31  * Now that the timeout periods are variable (exponential backoff and retry)
32  * we convert the timeout count to the absolute time it would have take to
33  * execute that many retries, and keep sending retry packets until that time
34  * is reached.
35  */
36 #ifndef CONFIG_NET_RETRY_COUNT
37 # define TIMEOUT_COUNT	5		/* # of timeouts before giving up */
38 #else
39 # define TIMEOUT_COUNT	(CONFIG_NET_RETRY_COUNT)
40 #endif
41 #define TIMEOUT_MS	((3 + (TIMEOUT_COUNT * 5)) * 1000)
42 
43 #define PORT_BOOTPS	67		/* BOOTP server UDP port */
44 #define PORT_BOOTPC	68		/* BOOTP client UDP port */
45 
46 #ifndef CONFIG_DHCP_MIN_EXT_LEN		/* minimal length of extension list */
47 #define CONFIG_DHCP_MIN_EXT_LEN 64
48 #endif
49 
50 #ifndef CONFIG_BOOTP_ID_CACHE_SIZE
51 #define CONFIG_BOOTP_ID_CACHE_SIZE 4
52 #endif
53 
54 u32		bootp_ids[CONFIG_BOOTP_ID_CACHE_SIZE];
55 unsigned int	bootp_num_ids;
56 int		bootp_try;
57 ulong		bootp_start;
58 ulong		bootp_timeout;
59 char net_nis_domain[32] = {0,}; /* Our NIS domain */
60 char net_hostname[32] = {0,}; /* Our hostname */
61 char net_root_path[64] = {0,}; /* Our bootpath */
62 
63 #if defined(CONFIG_CMD_DHCP)
64 static dhcp_state_t dhcp_state = INIT;
65 static u32 dhcp_leasetime;
66 static struct in_addr dhcp_server_ip;
67 static u8 dhcp_option_overload;
68 #define OVERLOAD_FILE 1
69 #define OVERLOAD_SNAME 2
70 static void dhcp_handler(uchar *pkt, unsigned dest, struct in_addr sip,
71 			unsigned src, unsigned len);
72 
73 /* For Debug */
74 #if 0
75 static char *dhcpmsg2str(int type)
76 {
77 	switch (type) {
78 	case 1:	 return "DHCPDISCOVER"; break;
79 	case 2:	 return "DHCPOFFER";	break;
80 	case 3:	 return "DHCPREQUEST";	break;
81 	case 4:	 return "DHCPDECLINE";	break;
82 	case 5:	 return "DHCPACK";	break;
83 	case 6:	 return "DHCPNACK";	break;
84 	case 7:	 return "DHCPRELEASE";	break;
85 	default: return "UNKNOWN/INVALID MSG TYPE"; break;
86 	}
87 }
88 #endif
89 #endif
90 
91 static void bootp_add_id(ulong id)
92 {
93 	if (bootp_num_ids >= ARRAY_SIZE(bootp_ids)) {
94 		size_t size = sizeof(bootp_ids) - sizeof(id);
95 
96 		memmove(bootp_ids, &bootp_ids[1], size);
97 		bootp_ids[bootp_num_ids - 1] = id;
98 	} else {
99 		bootp_ids[bootp_num_ids] = id;
100 		bootp_num_ids++;
101 	}
102 }
103 
104 static bool bootp_match_id(ulong id)
105 {
106 	unsigned int i;
107 
108 	for (i = 0; i < bootp_num_ids; i++)
109 		if (bootp_ids[i] == id)
110 			return true;
111 
112 	return false;
113 }
114 
115 static int check_reply_packet(uchar *pkt, unsigned dest, unsigned src,
116 			      unsigned len)
117 {
118 	struct bootp_hdr *bp = (struct bootp_hdr *)pkt;
119 	int retval = 0;
120 
121 	if (dest != PORT_BOOTPC || src != PORT_BOOTPS)
122 		retval = -1;
123 	else if (len < sizeof(struct bootp_hdr) - OPT_FIELD_SIZE)
124 		retval = -2;
125 	else if (bp->bp_op != OP_BOOTREPLY)
126 		retval = -3;
127 	else if (bp->bp_htype != HWT_ETHER)
128 		retval = -4;
129 	else if (bp->bp_hlen != HWL_ETHER)
130 		retval = -5;
131 	else if (!bootp_match_id(net_read_u32(&bp->bp_id)))
132 		retval = -6;
133 
134 	debug("Filtering pkt = %d\n", retval);
135 
136 	return retval;
137 }
138 
139 /*
140  * Copy parameters of interest from BOOTP_REPLY/DHCP_OFFER packet
141  */
142 static void store_net_params(struct bootp_hdr *bp)
143 {
144 #if !defined(CONFIG_BOOTP_SERVERIP)
145 	struct in_addr tmp_ip;
146 
147 	net_copy_ip(&tmp_ip, &bp->bp_siaddr);
148 	if (tmp_ip.s_addr != 0)
149 		net_copy_ip(&net_server_ip, &bp->bp_siaddr);
150 	memcpy(net_server_ethaddr,
151 	       ((struct ethernet_hdr *)net_rx_packet)->et_src, 6);
152 	if (
153 #if defined(CONFIG_CMD_DHCP)
154 	    !(dhcp_option_overload & OVERLOAD_FILE) &&
155 #endif
156 	    (strlen(bp->bp_file) > 0)) {
157 		copy_filename(net_boot_file_name, bp->bp_file,
158 			      sizeof(net_boot_file_name));
159 	}
160 
161 	debug("net_boot_file_name: %s\n", net_boot_file_name);
162 
163 	/* Propagate to environment:
164 	 * don't delete exising entry when BOOTP / DHCP reply does
165 	 * not contain a new value
166 	 */
167 	if (*net_boot_file_name)
168 		setenv("bootfile", net_boot_file_name);
169 #endif
170 	net_copy_ip(&net_ip, &bp->bp_yiaddr);
171 }
172 
173 static int truncate_sz(const char *name, int maxlen, int curlen)
174 {
175 	if (curlen >= maxlen) {
176 		printf("*** WARNING: %s is too long (%d - max: %d)"
177 			" - truncated\n", name, curlen, maxlen);
178 		curlen = maxlen - 1;
179 	}
180 	return curlen;
181 }
182 
183 #if !defined(CONFIG_CMD_DHCP)
184 
185 static void bootp_process_vendor_field(u8 *ext)
186 {
187 	int size = *(ext + 1);
188 
189 	debug("[BOOTP] Processing extension %d... (%d bytes)\n", *ext,
190 	      *(ext + 1));
191 
192 	net_boot_file_expected_size_in_blocks = 0;
193 
194 	switch (*ext) {
195 		/* Fixed length fields */
196 	case 1:			/* Subnet mask */
197 		if (net_netmask.s_addr == 0)
198 			net_copy_ip(&net_netmask, (struct in_addr *)(ext + 2));
199 		break;
200 	case 2:			/* Time offset - Not yet supported */
201 		break;
202 		/* Variable length fields */
203 	case 3:			/* Gateways list */
204 		if (net_gateway.s_addr == 0)
205 			net_copy_ip(&net_gateway, (struct in_addr *)(ext + 2));
206 		break;
207 	case 4:			/* Time server - Not yet supported */
208 		break;
209 	case 5:			/* IEN-116 name server - Not yet supported */
210 		break;
211 	case 6:
212 		if (net_dns_server.s_addr == 0)
213 			net_copy_ip(&net_dns_server,
214 				    (struct in_addr *)(ext + 2));
215 #if defined(CONFIG_BOOTP_DNS2)
216 		if ((net_dns_server2.s_addr == 0) && (size > 4))
217 			net_copy_ip(&net_dns_server2,
218 				    (struct in_addr *)(ext + 2 + 4));
219 #endif
220 		break;
221 	case 7:			/* Log server - Not yet supported */
222 		break;
223 	case 8:			/* Cookie/Quote server - Not yet supported */
224 		break;
225 	case 9:			/* LPR server - Not yet supported */
226 		break;
227 	case 10:		/* Impress server - Not yet supported */
228 		break;
229 	case 11:		/* RPL server - Not yet supported */
230 		break;
231 	case 12:		/* Host name */
232 		if (net_hostname[0] == 0) {
233 			size = truncate_sz("Host Name",
234 				sizeof(net_hostname), size);
235 			memcpy(&net_hostname, ext + 2, size);
236 			net_hostname[size] = 0;
237 		}
238 		break;
239 	case 13:		/* Boot file size */
240 		if (size == 2)
241 			net_boot_file_expected_size_in_blocks =
242 				ntohs(*(ushort *)(ext + 2));
243 		else if (size == 4)
244 			net_boot_file_expected_size_in_blocks =
245 				ntohl(*(ulong *)(ext + 2));
246 		break;
247 	case 14:		/* Merit dump file - Not yet supported */
248 		break;
249 	case 15:		/* Domain name - Not yet supported */
250 		break;
251 	case 16:		/* Swap server - Not yet supported */
252 		break;
253 	case 17:		/* Root path */
254 		if (net_root_path[0] == 0) {
255 			size = truncate_sz("Root Path",
256 				sizeof(net_root_path), size);
257 			memcpy(&net_root_path, ext + 2, size);
258 			net_root_path[size] = 0;
259 		}
260 		break;
261 	case 18:		/* Extension path - Not yet supported */
262 		/*
263 		 * This can be used to send the information of the
264 		 * vendor area in another file that the client can
265 		 * access via TFTP.
266 		 */
267 		break;
268 		/* IP host layer fields */
269 	case 40:		/* NIS Domain name */
270 		if (net_nis_domain[0] == 0) {
271 			size = truncate_sz("NIS Domain Name",
272 				sizeof(net_nis_domain), size);
273 			memcpy(&net_nis_domain, ext + 2, size);
274 			net_nis_domain[size] = 0;
275 		}
276 		break;
277 #if defined(CONFIG_CMD_SNTP) && defined(CONFIG_BOOTP_NTPSERVER)
278 	case 42:	/* NTP server IP */
279 		net_copy_ip(&net_ntp_server, (struct in_addr *)(ext + 2));
280 		break;
281 #endif
282 		/* Application layer fields */
283 	case 43:		/* Vendor specific info - Not yet supported */
284 		/*
285 		 * Binary information to exchange specific
286 		 * product information.
287 		 */
288 		break;
289 		/* Reserved (custom) fields (128..254) */
290 	}
291 }
292 
293 static void bootp_process_vendor(u8 *ext, int size)
294 {
295 	u8 *end = ext + size;
296 
297 	debug("[BOOTP] Checking extension (%d bytes)...\n", size);
298 
299 	while ((ext < end) && (*ext != 0xff)) {
300 		if (*ext == 0) {
301 			ext++;
302 		} else {
303 			u8 *opt = ext;
304 
305 			ext += ext[1] + 2;
306 			if (ext <= end)
307 				bootp_process_vendor_field(opt);
308 		}
309 	}
310 
311 	debug("[BOOTP] Received fields:\n");
312 	if (net_netmask.s_addr)
313 		debug("net_netmask : %pI4\n", &net_netmask);
314 
315 	if (net_gateway.s_addr)
316 		debug("net_gateway	: %pI4", &net_gateway);
317 
318 	if (net_boot_file_expected_size_in_blocks)
319 		debug("net_boot_file_expected_size_in_blocks : %d\n",
320 		      net_boot_file_expected_size_in_blocks);
321 
322 	if (net_hostname[0])
323 		debug("net_hostname  : %s\n", net_hostname);
324 
325 	if (net_root_path[0])
326 		debug("net_root_path  : %s\n", net_root_path);
327 
328 	if (net_nis_domain[0])
329 		debug("net_nis_domain : %s\n", net_nis_domain);
330 
331 #if defined(CONFIG_CMD_SNTP) && defined(CONFIG_BOOTP_NTPSERVER)
332 	if (net_ntp_server)
333 		debug("net_ntp_server : %pI4\n", &net_ntp_server);
334 #endif
335 }
336 
337 /*
338  *	Handle a BOOTP received packet.
339  */
340 static void bootp_handler(uchar *pkt, unsigned dest, struct in_addr sip,
341 			  unsigned src, unsigned len)
342 {
343 	struct bootp_hdr *bp;
344 
345 	debug("got BOOTP packet (src=%d, dst=%d, len=%d want_len=%zu)\n",
346 	      src, dest, len, sizeof(struct bootp_hdr));
347 
348 	bp = (struct bootp_hdr *)pkt;
349 
350 	/* Filter out pkts we don't want */
351 	if (check_reply_packet(pkt, dest, src, len))
352 		return;
353 
354 	/*
355 	 *	Got a good BOOTP reply.	 Copy the data into our variables.
356 	 */
357 #if defined(CONFIG_STATUS_LED) && defined(STATUS_LED_BOOT)
358 	status_led_set(STATUS_LED_BOOT, STATUS_LED_OFF);
359 #endif
360 
361 	store_net_params(bp);		/* Store net parameters from reply */
362 
363 	/* Retrieve extended information (we must parse the vendor area) */
364 	if (net_read_u32((u32 *)&bp->bp_vend[0]) == htonl(BOOTP_VENDOR_MAGIC))
365 		bootp_process_vendor((uchar *)&bp->bp_vend[4], len);
366 
367 	net_set_timeout_handler(0, (thand_f *)0);
368 	bootstage_mark_name(BOOTSTAGE_ID_BOOTP_STOP, "bootp_stop");
369 
370 	debug("Got good BOOTP\n");
371 
372 	net_auto_load();
373 }
374 #endif
375 
376 /*
377  *	Timeout on BOOTP/DHCP request.
378  */
379 static void bootp_timeout_handler(void)
380 {
381 	ulong time_taken = get_timer(bootp_start);
382 
383 	if (time_taken >= TIMEOUT_MS) {
384 #ifdef CONFIG_BOOTP_MAY_FAIL
385 		puts("\nRetry time exceeded\n");
386 		net_set_state(NETLOOP_FAIL);
387 #else
388 		puts("\nRetry time exceeded; starting again\n");
389 		net_start_again();
390 #endif
391 	} else {
392 		bootp_timeout *= 2;
393 		if (bootp_timeout > 2000)
394 			bootp_timeout = 2000;
395 		net_set_timeout_handler(bootp_timeout, bootp_timeout_handler);
396 		bootp_request();
397 	}
398 }
399 
400 #define put_vci(e, str)						\
401 	do {							\
402 		size_t vci_strlen = strlen(str);		\
403 		*e++ = 60;	/* Vendor Class Identifier */	\
404 		*e++ = vci_strlen;				\
405 		memcpy(e, str, vci_strlen);			\
406 		e += vci_strlen;				\
407 	} while (0)
408 
409 /*
410  *	Initialize BOOTP extension fields in the request.
411  */
412 #if defined(CONFIG_CMD_DHCP)
413 static int dhcp_extended(u8 *e, int message_type, struct in_addr server_ip,
414 			struct in_addr requested_ip)
415 {
416 	u8 *start = e;
417 	u8 *cnt;
418 #if defined(CONFIG_BOOTP_PXE)
419 	char *uuid;
420 	u16 clientarch;
421 #endif
422 
423 #if defined(CONFIG_BOOTP_VENDOREX)
424 	u8 *x;
425 #endif
426 #if defined(CONFIG_BOOTP_SEND_HOSTNAME)
427 	char *hostname;
428 #endif
429 
430 	*e++ = 99;		/* RFC1048 Magic Cookie */
431 	*e++ = 130;
432 	*e++ = 83;
433 	*e++ = 99;
434 
435 	*e++ = 53;		/* DHCP Message Type */
436 	*e++ = 1;
437 	*e++ = message_type;
438 
439 	*e++ = 57;		/* Maximum DHCP Message Size */
440 	*e++ = 2;
441 	*e++ = (576 - 312 + OPT_FIELD_SIZE) >> 8;
442 	*e++ = (576 - 312 + OPT_FIELD_SIZE) & 0xff;
443 
444 	if (server_ip.s_addr) {
445 		int tmp = ntohl(server_ip.s_addr);
446 
447 		*e++ = 54;	/* ServerID */
448 		*e++ = 4;
449 		*e++ = tmp >> 24;
450 		*e++ = tmp >> 16;
451 		*e++ = tmp >> 8;
452 		*e++ = tmp & 0xff;
453 	}
454 
455 	if (requested_ip.s_addr) {
456 		int tmp = ntohl(requested_ip.s_addr);
457 
458 		*e++ = 50;	/* Requested IP */
459 		*e++ = 4;
460 		*e++ = tmp >> 24;
461 		*e++ = tmp >> 16;
462 		*e++ = tmp >> 8;
463 		*e++ = tmp & 0xff;
464 	}
465 #if defined(CONFIG_BOOTP_SEND_HOSTNAME)
466 	hostname = getenv("hostname");
467 	if (hostname) {
468 		int hostnamelen = strlen(hostname);
469 
470 		*e++ = 12;	/* Hostname */
471 		*e++ = hostnamelen;
472 		memcpy(e, hostname, hostnamelen);
473 		e += hostnamelen;
474 	}
475 #endif
476 
477 #if defined(CONFIG_BOOTP_PXE)
478 	clientarch = CONFIG_BOOTP_PXE_CLIENTARCH;
479 	*e++ = 93;	/* Client System Architecture */
480 	*e++ = 2;
481 	*e++ = (clientarch >> 8) & 0xff;
482 	*e++ = clientarch & 0xff;
483 
484 	*e++ = 94;	/* Client Network Interface Identifier */
485 	*e++ = 3;
486 	*e++ = 1;	/* type field for UNDI */
487 	*e++ = 0;	/* major revision */
488 	*e++ = 0;	/* minor revision */
489 
490 	uuid = getenv("pxeuuid");
491 
492 	if (uuid) {
493 		if (uuid_str_valid(uuid)) {
494 			*e++ = 97;	/* Client Machine Identifier */
495 			*e++ = 17;
496 			*e++ = 0;	/* type 0 - UUID */
497 
498 			uuid_str_to_bin(uuid, e, UUID_STR_FORMAT_STD);
499 			e += 16;
500 		} else {
501 			printf("Invalid pxeuuid: %s\n", uuid);
502 		}
503 	}
504 #endif
505 
506 #if defined(CONFIG_SPL_BUILD) && defined(CONFIG_SPL_NET_VCI_STRING)
507 	put_vci(e, CONFIG_SPL_NET_VCI_STRING);
508 #elif defined(CONFIG_BOOTP_VCI_STRING)
509 	put_vci(e, CONFIG_BOOTP_VCI_STRING);
510 #endif
511 
512 #if defined(CONFIG_BOOTP_VENDOREX)
513 	x = dhcp_vendorex_prep(e);
514 	if (x)
515 		return x - start;
516 #endif
517 
518 	*e++ = 55;		/* Parameter Request List */
519 	 cnt = e++;		/* Pointer to count of requested items */
520 	*cnt = 0;
521 #if defined(CONFIG_BOOTP_SUBNETMASK)
522 	*e++  = 1;		/* Subnet Mask */
523 	*cnt += 1;
524 #endif
525 #if defined(CONFIG_BOOTP_TIMEOFFSET)
526 	*e++  = 2;
527 	*cnt += 1;
528 #endif
529 #if defined(CONFIG_BOOTP_GATEWAY)
530 	*e++  = 3;		/* Router Option */
531 	*cnt += 1;
532 #endif
533 #if defined(CONFIG_BOOTP_DNS)
534 	*e++  = 6;		/* DNS Server(s) */
535 	*cnt += 1;
536 #endif
537 #if defined(CONFIG_BOOTP_HOSTNAME)
538 	*e++  = 12;		/* Hostname */
539 	*cnt += 1;
540 #endif
541 #if defined(CONFIG_BOOTP_BOOTFILESIZE)
542 	*e++  = 13;		/* Boot File Size */
543 	*cnt += 1;
544 #endif
545 #if defined(CONFIG_BOOTP_BOOTPATH)
546 	*e++  = 17;		/* Boot path */
547 	*cnt += 1;
548 #endif
549 #if defined(CONFIG_BOOTP_NISDOMAIN)
550 	*e++  = 40;		/* NIS Domain name request */
551 	*cnt += 1;
552 #endif
553 #if defined(CONFIG_BOOTP_NTPSERVER)
554 	*e++  = 42;
555 	*cnt += 1;
556 #endif
557 	/* no options, so back up to avoid sending an empty request list */
558 	if (*cnt == 0)
559 		e -= 2;
560 
561 	*e++  = 255;		/* End of the list */
562 
563 	/* Pad to minimal length */
564 #ifdef	CONFIG_DHCP_MIN_EXT_LEN
565 	while ((e - start) < CONFIG_DHCP_MIN_EXT_LEN)
566 		*e++ = 0;
567 #endif
568 
569 	return e - start;
570 }
571 
572 #else
573 /*
574  * Warning: no field size check - change CONFIG_BOOTP_* at your own risk!
575  */
576 static int bootp_extended(u8 *e)
577 {
578 	u8 *start = e;
579 
580 	*e++ = 99;		/* RFC1048 Magic Cookie */
581 	*e++ = 130;
582 	*e++ = 83;
583 	*e++ = 99;
584 
585 #if defined(CONFIG_CMD_DHCP)
586 	*e++ = 53;		/* DHCP Message Type */
587 	*e++ = 1;
588 	*e++ = DHCP_DISCOVER;
589 
590 	*e++ = 57;		/* Maximum DHCP Message Size */
591 	*e++ = 2;
592 	*e++ = (576 - 312 + OPT_FIELD_SIZE) >> 16;
593 	*e++ = (576 - 312 + OPT_FIELD_SIZE) & 0xff;
594 #endif
595 
596 #if defined(CONFIG_BOOTP_VCI_STRING) || \
597 	(defined(CONFIG_SPL_BUILD) && defined(CONFIG_SPL_NET_VCI_STRING))
598 #ifdef CONFIG_SPL_BUILD
599 	put_vci(e, CONFIG_SPL_NET_VCI_STRING);
600 #else
601 	put_vci(e, CONFIG_BOOTP_VCI_STRING);
602 #endif
603 #endif
604 
605 #if defined(CONFIG_BOOTP_SUBNETMASK)
606 	*e++ = 1;		/* Subnet mask request */
607 	*e++ = 4;
608 	e   += 4;
609 #endif
610 
611 #if defined(CONFIG_BOOTP_GATEWAY)
612 	*e++ = 3;		/* Default gateway request */
613 	*e++ = 4;
614 	e   += 4;
615 #endif
616 
617 #if defined(CONFIG_BOOTP_DNS)
618 	*e++ = 6;		/* Domain Name Server */
619 	*e++ = 4;
620 	e   += 4;
621 #endif
622 
623 #if defined(CONFIG_BOOTP_HOSTNAME)
624 	*e++ = 12;		/* Host name request */
625 	*e++ = 32;
626 	e   += 32;
627 #endif
628 
629 #if defined(CONFIG_BOOTP_BOOTFILESIZE)
630 	*e++ = 13;		/* Boot file size */
631 	*e++ = 2;
632 	e   += 2;
633 #endif
634 
635 #if defined(CONFIG_BOOTP_BOOTPATH)
636 	*e++ = 17;		/* Boot path */
637 	*e++ = 32;
638 	e   += 32;
639 #endif
640 
641 #if defined(CONFIG_BOOTP_NISDOMAIN)
642 	*e++ = 40;		/* NIS Domain name request */
643 	*e++ = 32;
644 	e   += 32;
645 #endif
646 #if defined(CONFIG_BOOTP_NTPSERVER)
647 	*e++ = 42;
648 	*e++ = 4;
649 	e   += 4;
650 #endif
651 
652 	*e++ = 255;		/* End of the list */
653 
654 	return e - start;
655 }
656 #endif
657 
658 void bootp_reset(void)
659 {
660 	bootp_num_ids = 0;
661 	bootp_try = 0;
662 	bootp_start = get_timer(0);
663 	bootp_timeout = 250;
664 }
665 
666 void bootp_request(void)
667 {
668 	uchar *pkt, *iphdr;
669 	struct bootp_hdr *bp;
670 	int extlen, pktlen, iplen;
671 	int eth_hdr_size;
672 #ifdef CONFIG_BOOTP_RANDOM_DELAY
673 	ulong rand_ms;
674 #endif
675 	u32 bootp_id;
676 	struct in_addr zero_ip;
677 	struct in_addr bcast_ip;
678 
679 	bootstage_mark_name(BOOTSTAGE_ID_BOOTP_START, "bootp_start");
680 #if defined(CONFIG_CMD_DHCP)
681 	dhcp_state = INIT;
682 #endif
683 
684 #ifdef CONFIG_BOOTP_RANDOM_DELAY		/* Random BOOTP delay */
685 	if (bootp_try == 0)
686 		srand_mac();
687 
688 	if (bootp_try <= 2)	/* Start with max 1024 * 1ms */
689 		rand_ms = rand() >> (22 - bootp_try);
690 	else		/* After 3rd BOOTP request max 8192 * 1ms */
691 		rand_ms = rand() >> 19;
692 
693 	printf("Random delay: %ld ms...\n", rand_ms);
694 	mdelay(rand_ms);
695 
696 #endif	/* CONFIG_BOOTP_RANDOM_DELAY */
697 
698 	printf("BOOTP broadcast %d\n", ++bootp_try);
699 	pkt = net_tx_packet;
700 	memset((void *)pkt, 0, PKTSIZE);
701 
702 	eth_hdr_size = net_set_ether(pkt, net_bcast_ethaddr, PROT_IP);
703 	pkt += eth_hdr_size;
704 
705 	/*
706 	 * Next line results in incorrect packet size being transmitted,
707 	 * resulting in errors in some DHCP servers, reporting missing bytes.
708 	 * Size must be set in packet header after extension length has been
709 	 * determined.
710 	 * C. Hallinan, DS4.COM, Inc.
711 	 */
712 	/* net_set_udp_header(pkt, 0xFFFFFFFFL, PORT_BOOTPS, PORT_BOOTPC,
713 		sizeof (struct bootp_hdr)); */
714 	iphdr = pkt;	/* We need this later for net_set_udp_header() */
715 	pkt += IP_UDP_HDR_SIZE;
716 
717 	bp = (struct bootp_hdr *)pkt;
718 	bp->bp_op = OP_BOOTREQUEST;
719 	bp->bp_htype = HWT_ETHER;
720 	bp->bp_hlen = HWL_ETHER;
721 	bp->bp_hops = 0;
722 	/*
723 	 * according to RFC1542, should be 0 on first request, secs since
724 	 * first request otherwise
725 	 */
726 	bp->bp_secs = htons(get_timer(bootp_start) / 1000);
727 	zero_ip.s_addr = 0;
728 	net_write_ip(&bp->bp_ciaddr, zero_ip);
729 	net_write_ip(&bp->bp_yiaddr, zero_ip);
730 	net_write_ip(&bp->bp_siaddr, zero_ip);
731 	net_write_ip(&bp->bp_giaddr, zero_ip);
732 	memcpy(bp->bp_chaddr, net_ethaddr, 6);
733 	copy_filename(bp->bp_file, net_boot_file_name, sizeof(bp->bp_file));
734 
735 	/* Request additional information from the BOOTP/DHCP server */
736 #if defined(CONFIG_CMD_DHCP)
737 	extlen = dhcp_extended((u8 *)bp->bp_vend, DHCP_DISCOVER, zero_ip,
738 			       zero_ip);
739 #else
740 	extlen = bootp_extended((u8 *)bp->bp_vend);
741 #endif
742 
743 	/*
744 	 *	Bootp ID is the lower 4 bytes of our ethernet address
745 	 *	plus the current time in ms.
746 	 */
747 	bootp_id = ((u32)net_ethaddr[2] << 24)
748 		| ((u32)net_ethaddr[3] << 16)
749 		| ((u32)net_ethaddr[4] << 8)
750 		| (u32)net_ethaddr[5];
751 	bootp_id += get_timer(0);
752 	bootp_id = htonl(bootp_id);
753 	bootp_add_id(bootp_id);
754 	net_copy_u32(&bp->bp_id, &bootp_id);
755 
756 	/*
757 	 * Calculate proper packet lengths taking into account the
758 	 * variable size of the options field
759 	 */
760 	iplen = BOOTP_HDR_SIZE - OPT_FIELD_SIZE + extlen;
761 	pktlen = eth_hdr_size + IP_UDP_HDR_SIZE + iplen;
762 	bcast_ip.s_addr = 0xFFFFFFFFL;
763 	net_set_udp_header(iphdr, bcast_ip, PORT_BOOTPS, PORT_BOOTPC, iplen);
764 	net_set_timeout_handler(bootp_timeout, bootp_timeout_handler);
765 
766 #if defined(CONFIG_CMD_DHCP)
767 	dhcp_state = SELECTING;
768 	net_set_udp_handler(dhcp_handler);
769 #else
770 	net_set_udp_handler(bootp_handler);
771 #endif
772 	net_send_packet(net_tx_packet, pktlen);
773 }
774 
775 #if defined(CONFIG_CMD_DHCP)
776 static void dhcp_process_options(uchar *popt, uchar *end)
777 {
778 	int oplen, size;
779 #if defined(CONFIG_CMD_SNTP) && defined(CONFIG_BOOTP_TIMEOFFSET)
780 	int *to_ptr;
781 #endif
782 
783 	while (popt < end && *popt != 0xff) {
784 		oplen = *(popt + 1);
785 		switch (*popt) {
786 		case 0:
787 			oplen = -1; /* Pad omits len byte */
788 			break;
789 		case 1:
790 			net_copy_ip(&net_netmask, (popt + 2));
791 			break;
792 #if defined(CONFIG_CMD_SNTP) && defined(CONFIG_BOOTP_TIMEOFFSET)
793 		case 2:		/* Time offset	*/
794 			to_ptr = &net_ntp_time_offset;
795 			net_copy_u32((u32 *)to_ptr, (u32 *)(popt + 2));
796 			net_ntp_time_offset = ntohl(net_ntp_time_offset);
797 			break;
798 #endif
799 		case 3:
800 			net_copy_ip(&net_gateway, (popt + 2));
801 			break;
802 		case 6:
803 			net_copy_ip(&net_dns_server, (popt + 2));
804 #if defined(CONFIG_BOOTP_DNS2)
805 			if (*(popt + 1) > 4)
806 				net_copy_ip(&net_dns_server2, (popt + 2 + 4));
807 #endif
808 			break;
809 		case 12:
810 			size = truncate_sz("Host Name",
811 				sizeof(net_hostname), oplen);
812 			memcpy(&net_hostname, popt + 2, size);
813 			net_hostname[size] = 0;
814 			break;
815 		case 15:	/* Ignore Domain Name Option */
816 			break;
817 		case 17:
818 			size = truncate_sz("Root Path",
819 				sizeof(net_root_path), oplen);
820 			memcpy(&net_root_path, popt + 2, size);
821 			net_root_path[size] = 0;
822 			break;
823 		case 28:	/* Ignore Broadcast Address Option */
824 			break;
825 #if defined(CONFIG_CMD_SNTP) && defined(CONFIG_BOOTP_NTPSERVER)
826 		case 42:	/* NTP server IP */
827 			net_copy_ip(&net_ntp_server, (popt + 2));
828 			break;
829 #endif
830 		case 51:
831 			net_copy_u32(&dhcp_leasetime, (u32 *)(popt + 2));
832 			break;
833 		case 52:
834 			dhcp_option_overload = popt[2];
835 			break;
836 		case 53:	/* Ignore Message Type Option */
837 			break;
838 		case 54:
839 			net_copy_ip(&dhcp_server_ip, (popt + 2));
840 			break;
841 		case 58:	/* Ignore Renewal Time Option */
842 			break;
843 		case 59:	/* Ignore Rebinding Time Option */
844 			break;
845 		case 66:	/* Ignore TFTP server name */
846 			break;
847 		case 67:	/* Bootfile option */
848 			size = truncate_sz("Bootfile",
849 					   sizeof(net_boot_file_name), oplen);
850 			memcpy(&net_boot_file_name, popt + 2, size);
851 			net_boot_file_name[size] = 0;
852 			break;
853 		default:
854 #if defined(CONFIG_BOOTP_VENDOREX)
855 			if (dhcp_vendorex_proc(popt))
856 				break;
857 #endif
858 			printf("*** Unhandled DHCP Option in OFFER/ACK:"
859 			       " %d\n", *popt);
860 			break;
861 		}
862 		popt += oplen + 2;	/* Process next option */
863 	}
864 }
865 
866 static void dhcp_packet_process_options(struct bootp_hdr *bp)
867 {
868 	uchar *popt = (uchar *)&bp->bp_vend[4];
869 	uchar *end = popt + BOOTP_HDR_SIZE;
870 
871 	if (net_read_u32((u32 *)&bp->bp_vend[0]) != htonl(BOOTP_VENDOR_MAGIC))
872 		return;
873 
874 	dhcp_option_overload = 0;
875 
876 	/*
877 	 * The 'options' field MUST be interpreted first, 'file' next,
878 	 * 'sname' last.
879 	 */
880 	dhcp_process_options(popt, end);
881 
882 	if (dhcp_option_overload & OVERLOAD_FILE) {
883 		popt = (uchar *)bp->bp_file;
884 		end = popt + sizeof(bp->bp_file);
885 		dhcp_process_options(popt, end);
886 	}
887 
888 	if (dhcp_option_overload & OVERLOAD_SNAME) {
889 		popt = (uchar *)bp->bp_sname;
890 		end = popt + sizeof(bp->bp_sname);
891 		dhcp_process_options(popt, end);
892 	}
893 }
894 
895 static int dhcp_message_type(unsigned char *popt)
896 {
897 	if (net_read_u32((u32 *)popt) != htonl(BOOTP_VENDOR_MAGIC))
898 		return -1;
899 
900 	popt += 4;
901 	while (*popt != 0xff) {
902 		if (*popt == 53)	/* DHCP Message Type */
903 			return *(popt + 2);
904 		if (*popt == 0)	{
905 			/* Pad */
906 			popt += 1;
907 		} else {
908 			/* Scan through all options */
909 			popt += *(popt + 1) + 2;
910 		}
911 	}
912 	return -1;
913 }
914 
915 static void dhcp_send_request_packet(struct bootp_hdr *bp_offer)
916 {
917 	uchar *pkt, *iphdr;
918 	struct bootp_hdr *bp;
919 	int pktlen, iplen, extlen;
920 	int eth_hdr_size;
921 	struct in_addr offered_ip;
922 	struct in_addr zero_ip;
923 	struct in_addr bcast_ip;
924 
925 	debug("dhcp_send_request_packet: Sending DHCPREQUEST\n");
926 	pkt = net_tx_packet;
927 	memset((void *)pkt, 0, PKTSIZE);
928 
929 	eth_hdr_size = net_set_ether(pkt, net_bcast_ethaddr, PROT_IP);
930 	pkt += eth_hdr_size;
931 
932 	iphdr = pkt;	/* We'll need this later to set proper pkt size */
933 	pkt += IP_UDP_HDR_SIZE;
934 
935 	bp = (struct bootp_hdr *)pkt;
936 	bp->bp_op = OP_BOOTREQUEST;
937 	bp->bp_htype = HWT_ETHER;
938 	bp->bp_hlen = HWL_ETHER;
939 	bp->bp_hops = 0;
940 	bp->bp_secs = htons(get_timer(bootp_start) / 1000);
941 	/* Do not set the client IP, your IP, or server IP yet, since it
942 	 * hasn't been ACK'ed by the server yet */
943 
944 	/*
945 	 * RFC3046 requires Relay Agents to discard packets with
946 	 * nonzero and offered giaddr
947 	 */
948 	zero_ip.s_addr = 0;
949 	net_write_ip(&bp->bp_giaddr, zero_ip);
950 
951 	memcpy(bp->bp_chaddr, net_ethaddr, 6);
952 	copy_filename(bp->bp_file, net_boot_file_name, sizeof(bp->bp_file));
953 
954 	/*
955 	 * ID is the id of the OFFER packet
956 	 */
957 
958 	net_copy_u32(&bp->bp_id, &bp_offer->bp_id);
959 
960 	/*
961 	 * Copy options from OFFER packet if present
962 	 */
963 
964 	/* Copy offered IP into the parameters request list */
965 	net_copy_ip(&offered_ip, &bp_offer->bp_yiaddr);
966 	extlen = dhcp_extended((u8 *)bp->bp_vend, DHCP_REQUEST,
967 		dhcp_server_ip, offered_ip);
968 
969 	iplen = BOOTP_HDR_SIZE - OPT_FIELD_SIZE + extlen;
970 	pktlen = eth_hdr_size + IP_UDP_HDR_SIZE + iplen;
971 	bcast_ip.s_addr = 0xFFFFFFFFL;
972 	net_set_udp_header(iphdr, bcast_ip, PORT_BOOTPS, PORT_BOOTPC, iplen);
973 
974 #ifdef CONFIG_BOOTP_DHCP_REQUEST_DELAY
975 	udelay(CONFIG_BOOTP_DHCP_REQUEST_DELAY);
976 #endif	/* CONFIG_BOOTP_DHCP_REQUEST_DELAY */
977 	debug("Transmitting DHCPREQUEST packet: len = %d\n", pktlen);
978 	net_send_packet(net_tx_packet, pktlen);
979 }
980 
981 /*
982  *	Handle DHCP received packets.
983  */
984 static void dhcp_handler(uchar *pkt, unsigned dest, struct in_addr sip,
985 			 unsigned src, unsigned len)
986 {
987 	struct bootp_hdr *bp = (struct bootp_hdr *)pkt;
988 
989 	debug("DHCPHandler: got packet: (src=%d, dst=%d, len=%d) state: %d\n",
990 	      src, dest, len, dhcp_state);
991 
992 	/* Filter out pkts we don't want */
993 	if (check_reply_packet(pkt, dest, src, len))
994 		return;
995 
996 	debug("DHCPHandler: got DHCP packet: (src=%d, dst=%d, len=%d) state: "
997 	      "%d\n", src, dest, len, dhcp_state);
998 
999 	if (net_read_ip(&bp->bp_yiaddr).s_addr == 0)
1000 		return;
1001 
1002 	switch (dhcp_state) {
1003 	case SELECTING:
1004 		/*
1005 		 * Wait an appropriate time for any potential DHCPOFFER packets
1006 		 * to arrive.  Then select one, and generate DHCPREQUEST
1007 		 * response.  If filename is in format we recognize, assume it
1008 		 * is a valid OFFER from a server we want.
1009 		 */
1010 		debug("DHCP: state=SELECTING bp_file: \"%s\"\n", bp->bp_file);
1011 #ifdef CONFIG_SYS_BOOTFILE_PREFIX
1012 		if (strncmp(bp->bp_file,
1013 			    CONFIG_SYS_BOOTFILE_PREFIX,
1014 			    strlen(CONFIG_SYS_BOOTFILE_PREFIX)) == 0) {
1015 #endif	/* CONFIG_SYS_BOOTFILE_PREFIX */
1016 			dhcp_packet_process_options(bp);
1017 
1018 			debug("TRANSITIONING TO REQUESTING STATE\n");
1019 			dhcp_state = REQUESTING;
1020 
1021 			net_set_timeout_handler(5000, bootp_timeout_handler);
1022 			dhcp_send_request_packet(bp);
1023 #ifdef CONFIG_SYS_BOOTFILE_PREFIX
1024 		}
1025 #endif	/* CONFIG_SYS_BOOTFILE_PREFIX */
1026 
1027 		return;
1028 		break;
1029 	case REQUESTING:
1030 		debug("DHCP State: REQUESTING\n");
1031 
1032 		if (dhcp_message_type((u8 *)bp->bp_vend) == DHCP_ACK) {
1033 			dhcp_packet_process_options(bp);
1034 			/* Store net params from reply */
1035 			store_net_params(bp);
1036 			dhcp_state = BOUND;
1037 			printf("DHCP client bound to address %pI4 (%lu ms)\n",
1038 			       &net_ip, get_timer(bootp_start));
1039 			net_set_timeout_handler(0, (thand_f *)0);
1040 			bootstage_mark_name(BOOTSTAGE_ID_BOOTP_STOP,
1041 					    "bootp_stop");
1042 
1043 			net_auto_load();
1044 			return;
1045 		}
1046 		break;
1047 	case BOUND:
1048 		/* DHCP client bound to address */
1049 		break;
1050 	default:
1051 		puts("DHCP: INVALID STATE\n");
1052 		break;
1053 	}
1054 }
1055 
1056 void dhcp_request(void)
1057 {
1058 	bootp_request();
1059 }
1060 #endif	/* CONFIG_CMD_DHCP */
1061