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