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