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