NetworkPkg/HttpBootDxe/HttpBootImpl.c

   1 /** @file
   2   The implementation of EFI_LOAD_FILE_PROTOCOL for UEFI HTTP boot.
   3
   4 Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved.<BR>
   5 (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
   6 This program and the accompanying materials are licensed and made available under
   7 the terms and conditions of the BSD License that accompanies this distribution.
   8 The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php.
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "HttpBootDxe.h"
  17
  18 /**
  19   Install HTTP Boot Callback Protocol if not installed before.
  20
  21   @param[in] Private           Pointer to HTTP Boot private data.
  22
  23   @retval EFI_SUCCESS          HTTP Boot Callback Protocol installed succesfully.
  24   @retval Others               Failed to install HTTP Boot Callback Protocol.
  25
  26 **/
  27 EFI_STATUS
  28 HttpBootInstallCallback (
  29   IN HTTP_BOOT_PRIVATE_DATA           *Private
  30   )
  31 {
  32   EFI_STATUS                  Status;
  33   EFI_HANDLE                  ControllerHandle;
  34
  35   if (!Private->UsingIpv6) {
  36     ControllerHandle = Private->Ip4Nic->Controller;
  37   } else {
  38     ControllerHandle = Private->Ip6Nic->Controller;
  39   }
  40
  41   //
  42   // Check whether gEfiHttpBootCallbackProtocolGuid already installed.
  43   //
  44   Status = gBS->HandleProtocol (
  45                   ControllerHandle,
  46                   &gEfiHttpBootCallbackProtocolGuid,
  47                   (VOID **) &Private->HttpBootCallback
  48                   );
  49   if (Status == EFI_UNSUPPORTED) {
  50
  51     CopyMem (
  52       &Private->LoadFileCallback,
  53       &gHttpBootDxeHttpBootCallback,
  54       sizeof (EFI_HTTP_BOOT_CALLBACK_PROTOCOL)
  55       );
  56
  57     //
  58     // Install a default callback if user didn't offer one.
  59     //
  60     Status = gBS->InstallProtocolInterface (
  61                     &ControllerHandle,
  62                     &gEfiHttpBootCallbackProtocolGuid,
  63                     EFI_NATIVE_INTERFACE,
  64                     &Private->LoadFileCallback
  65                     );
  66     if (EFI_ERROR (Status)) {
  67       return Status;
  68     }
  69     Private->HttpBootCallback = &Private->LoadFileCallback;
  70   }
  71
  72   return EFI_SUCCESS;
  73 }
  74
  75 /**
  76   Uninstall HTTP Boot Callback Protocol if it's installed by this driver.
  77
  78   @param[in] Private           Pointer to HTTP Boot private data.
  79
  80 **/
  81 VOID
  82 HttpBootUninstallCallback (
  83   IN HTTP_BOOT_PRIVATE_DATA           *Private
  84   )
  85 {
  86   if (Private->HttpBootCallback == &Private->LoadFileCallback) {
  87     gBS->UninstallProtocolInterface (
  88           Private->Controller,
  89           &gEfiHttpBootCallbackProtocolGuid,
  90           &Private->HttpBootCallback
  91           );
  92     Private->HttpBootCallback = NULL;
  93   }
  94 }
  95
  96 /**
  97   Enable the use of UEFI HTTP boot function.
  98
  99   If the driver has already been started but not satisfy the requirement (IP stack and
 100   specified boot file path), this function will stop the driver and start it again.
 101
 102   @param[in]    Private            The pointer to the driver's private data.
 103   @param[in]    UsingIpv6          Specifies the type of IP addresses that are to be
 104                                    used during the session that is being started.
 105                                    Set to TRUE for IPv6, and FALSE for IPv4.
 106   @param[in]    FilePath           The device specific path of the file to load.
 107
 108   @retval EFI_SUCCESS              HTTP boot was successfully enabled.
 109   @retval EFI_INVALID_PARAMETER    Private is NULL or FilePath is NULL.
 110   @retval EFI_INVALID_PARAMETER    The FilePath doesn't contain a valid URI device path node.
 111   @retval EFI_ALREADY_STARTED      The driver is already in started state.
 112   @retval EFI_OUT_OF_RESOURCES     There are not enough resources.
 113
 114 **/
 115 EFI_STATUS
 116 HttpBootStart (
 117   IN HTTP_BOOT_PRIVATE_DATA           *Private,
 118   IN BOOLEAN                          UsingIpv6,
 119   IN EFI_DEVICE_PATH_PROTOCOL         *FilePath
 120   )
 121 {
 122   UINTN                Index;
 123   EFI_STATUS           Status;
 124   CHAR8                *Uri;
 125
 126   Uri = NULL;
 127
 128   if (Private == NULL || FilePath == NULL) {
 129     return EFI_INVALID_PARAMETER;
 130   }
 131
 132   //
 133   // Check the URI in the input FilePath, in order to see whether it is
 134   // required to boot from a new specified boot file.
 135   //
 136   Status = HttpBootParseFilePath (FilePath, &Uri);
 137   if (EFI_ERROR (Status)) {
 138     return EFI_INVALID_PARAMETER;
 139   }
 140
 141   //
 142   // Check whether we need to stop and restart the HTTP boot driver.
 143   //
 144   if (Private->Started) {
 145     //
 146     // Restart is needed in 2 cases:
 147     // 1. Http boot driver has already been started but not on the required IP stack.
 148     // 2. The specified boot file URI in FilePath is different with the one we have
 149     // recorded before.
 150     //
 151     if ((UsingIpv6 != Private->UsingIpv6) ||
 152         ((Uri != NULL) && (AsciiStrCmp (Private->BootFileUri, Uri) != 0))) {
 153       //
 154       // Restart is required, first stop then continue this start function.
 155       //
 156       Status = HttpBootStop (Private);
 157       if (EFI_ERROR (Status)) {
 158         if (Uri != NULL) {
 159           FreePool (Uri);
 160         }
 161         return Status;
 162       }
 163     } else {
 164       //
 165       // Restart is not required.
 166       //
 167       if (Uri != NULL) {
 168         FreePool (Uri);
 169       }
 170       return EFI_ALREADY_STARTED;
 171     }
 172   }
 173
 174   //
 175   // Detect whether using ipv6 or not, and set it to the private data.
 176   //
 177   if (UsingIpv6 && Private->Ip6Nic != NULL) {
 178     Private->UsingIpv6 = TRUE;
 179   } else if (!UsingIpv6 && Private->Ip4Nic != NULL) {
 180     Private->UsingIpv6 = FALSE;
 181   } else {
 182     if (Uri != NULL) {
 183       FreePool (Uri);
 184     }
 185     return EFI_UNSUPPORTED;
 186   }
 187
 188   //
 189   // Record the specified URI and prepare the URI parser if needed.
 190   //
 191   Private->FilePathUri = Uri;
 192   if (Private->FilePathUri != NULL) {
 193     Status = HttpParseUrl (
 194                Private->FilePathUri,
 195                (UINT32) AsciiStrLen (Private->FilePathUri),
 196                FALSE,
 197                &Private->FilePathUriParser
 198                );
 199     if (EFI_ERROR (Status)) {
 200       FreePool (Private->FilePathUri);
 201       return Status;
 202     }
 203   }
 204
 205   //
 206   // Init the content of cached DHCP offer list.
 207   //
 208   ZeroMem (Private->OfferBuffer, sizeof (Private->OfferBuffer));
 209   if (!Private->UsingIpv6) {
 210     for (Index = 0; Index < HTTP_BOOT_OFFER_MAX_NUM; Index++) {
 211       Private->OfferBuffer[Index].Dhcp4.Packet.Offer.Size = HTTP_CACHED_DHCP4_PACKET_MAX_SIZE;
 212     }
 213   } else {
 214     for (Index = 0; Index < HTTP_BOOT_OFFER_MAX_NUM; Index++) {
 215       Private->OfferBuffer[Index].Dhcp6.Packet.Offer.Size = HTTP_CACHED_DHCP6_PACKET_MAX_SIZE;
 216     }
 217   }
 218
 219   if (Private->UsingIpv6) {
 220     //
 221     // Set Ip6 policy to Automatic to start the Ip6 router discovery.
 222     //
 223     Status = HttpBootSetIp6Policy (Private);
 224     if (EFI_ERROR (Status)) {
 225       return Status;
 226     }
 227   }
 228   Private->Started   = TRUE;
 229   Print (L"\n>>Start HTTP Boot over IPv%d", Private->UsingIpv6 ? 6 : 4);
 230
 231   return EFI_SUCCESS;
 232 }
 233
 234 /**
 235   Attempt to complete a DHCPv4 D.O.R.A or DHCPv6 S.R.A.A sequence to retrieve the boot resource information.
 236
 237   @param[in]    Private            The pointer to the driver's private data.
 238
 239   @retval EFI_SUCCESS              Boot info was successfully retrieved.
 240   @retval EFI_INVALID_PARAMETER    Private is NULL.
 241   @retval EFI_NOT_STARTED          The driver is in stopped state.
 242   @retval EFI_DEVICE_ERROR         An unexpected network error occurred.
 243   @retval Others                   Other errors as indicated.
 244
 245 **/
 246 EFI_STATUS
 247 HttpBootDhcp (
 248   IN HTTP_BOOT_PRIVATE_DATA           *Private
 249   )
 250 {
 251   EFI_STATUS                Status;
 252
 253   if (Private == NULL) {
 254     return EFI_INVALID_PARAMETER;
 255   }
 256
 257   if (!Private->Started) {
 258     return EFI_NOT_STARTED;
 259   }
 260
 261   Status = EFI_DEVICE_ERROR;
 262
 263   if (!Private->UsingIpv6) {
 264     //
 265     // Start D.O.R.A process to get a IPv4 address and other boot information.
 266     //
 267     Status = HttpBootDhcp4Dora (Private);
 268   } else {
 269      //
 270     // Start S.A.R.R process to get a IPv6 address and other boot information.
 271     //
 272     Status = HttpBootDhcp6Sarr (Private);
 273   }
 274
 275   return Status;
 276 }
 277
 278 /**
 279   Attempt to download the boot file through HTTP message exchange.
 280
 281   @param[in]          Private         The pointer to the driver's private data.
 282   @param[in, out]     BufferSize      On input the size of Buffer in bytes. On output with a return
 283                                       code of EFI_SUCCESS, the amount of data transferred to
 284                                       Buffer. On output with a return code of EFI_BUFFER_TOO_SMALL,
 285                                       the size of Buffer required to retrieve the requested file.
 286   @param[in]          Buffer          The memory buffer to transfer the file to. If Buffer is NULL,
 287                                       then the size of the requested file is returned in
 288                                       BufferSize.
 289   @param[out]         ImageType       The image type of the downloaded file.
 290
 291   @retval EFI_SUCCESS                 Boot file was loaded successfully.
 292   @retval EFI_INVALID_PARAMETER       Private is NULL, or ImageType is NULL, or BufferSize is NULL.
 293   @retval EFI_INVALID_PARAMETER       *BufferSize is not zero, and Buffer is NULL.
 294   @retval EFI_NOT_STARTED             The driver is in stopped state.
 295   @retval EFI_BUFFER_TOO_SMALL        The BufferSize is too small to read the boot file. BufferSize has
 296                                       been updated with the size needed to complete the request.
 297   @retval EFI_DEVICE_ERROR            An unexpected network error occurred.
 298   @retval Others                      Other errors as indicated.
 299
 300 **/
 301 EFI_STATUS
 302 HttpBootLoadFile (
 303   IN     HTTP_BOOT_PRIVATE_DATA       *Private,
 304   IN OUT UINTN                        *BufferSize,
 305   IN     VOID                         *Buffer,       OPTIONAL
 306      OUT HTTP_BOOT_IMAGE_TYPE         *ImageType
 307   )
 308 {
 309   EFI_STATUS             Status;
 310
 311   if (Private == NULL || ImageType == NULL || BufferSize == NULL ) {
 312     return EFI_INVALID_PARAMETER;
 313   }
 314
 315   if (*BufferSize != 0 && Buffer == NULL) {
 316     return EFI_INVALID_PARAMETER;
 317   }
 318
 319   if (!Private->Started) {
 320     return EFI_NOT_STARTED;
 321   }
 322
 323   Status = HttpBootInstallCallback (Private);
 324   if (EFI_ERROR(Status)) {
 325     goto ON_EXIT;
 326   }
 327
 328   if (Private->BootFileUri == NULL) {
 329     //
 330     // Parse the cached offer to get the boot file URL first.
 331     //
 332     Status = HttpBootDiscoverBootInfo (Private);
 333     if (EFI_ERROR (Status)) {
 334       AsciiPrint ("\n  Error: Could not discover the boot information for DHCP server.\n");
 335       goto ON_EXIT;
 336     }
 337   }
 338
 339   if (!Private->HttpCreated) {
 340     //
 341     // Create HTTP child.
 342     //
 343     Status = HttpBootCreateHttpIo (Private);
 344     if (EFI_ERROR (Status)) {
 345       goto ON_EXIT;
 346     }
 347   }
 348
 349   if (Private->BootFileSize == 0) {
 350     //
 351     // Discover the information about the bootfile if we haven't.
 352     //
 353
 354     //
 355     // Try to use HTTP HEAD method.
 356     //
 357     Status = HttpBootGetBootFile (
 358                Private,
 359                TRUE,
 360                &Private->BootFileSize,
 361                NULL,
 362                &Private->ImageType
 363                );
 364     if (EFI_ERROR (Status) && Status != EFI_BUFFER_TOO_SMALL) {
 365       //
 366       // Failed to get file size by HEAD method, may be trunked encoding, try HTTP GET method.
 367       //
 368       ASSERT (Private->BootFileSize == 0);
 369       Status = HttpBootGetBootFile (
 370                  Private,
 371                  FALSE,
 372                  &Private->BootFileSize,
 373                  NULL,
 374                  &Private->ImageType
 375                  );
 376       if (EFI_ERROR (Status) && Status != EFI_BUFFER_TOO_SMALL) {
 377         AsciiPrint ("\n  Error: Could not retrieve NBP file size from HTTP server.\n");
 378         goto ON_EXIT;
 379       }
 380     }
 381   }
 382
 383   if (*BufferSize < Private->BootFileSize) {
 384     *BufferSize = Private->BootFileSize;
 385     *ImageType = Private->ImageType;
 386     Status = EFI_BUFFER_TOO_SMALL;
 387     goto ON_EXIT;
 388   }
 389
 390   //
 391   // Load the boot file into Buffer
 392   //
 393   Status = HttpBootGetBootFile (
 394              Private,
 395              FALSE,
 396              BufferSize,
 397              Buffer,
 398              ImageType
 399              );
 400
 401 ON_EXIT:
 402   HttpBootUninstallCallback (Private);
 403
 404   if (Status == EFI_ACCESS_DENIED) {
 405     AsciiPrint ("\n  Error: Could not establish connection with HTTP server.\n");
 406   } else if (Status == EFI_BUFFER_TOO_SMALL && Buffer != NULL) {
 407     AsciiPrint ("\n  Error: Buffer size is smaller than the requested file.\n");
 408   } else if (Status == EFI_OUT_OF_RESOURCES) {
 409     AsciiPrint ("\n  Error: Could not allocate I/O buffers.\n");
 410   } else if (Status == EFI_DEVICE_ERROR) {
 411     AsciiPrint ("\n  Error: Network device error.\n");
 412   } else if (Status == EFI_TIMEOUT) {
 413     AsciiPrint ("\n  Error: Server response timeout.\n");
 414   } else if (Status == EFI_ABORTED) {
 415     AsciiPrint ("\n  Error: Remote boot cancelled.\n");
 416   } else if (Status != EFI_BUFFER_TOO_SMALL) {
 417     AsciiPrint ("\n  Error: Unexpected network error.\n");
 418   }
 419   return Status;
 420 }
 421
 422 /**
 423   Disable the use of UEFI HTTP boot function.
 424
 425   @param[in]    Private            The pointer to the driver's private data.
 426
 427   @retval EFI_SUCCESS              HTTP boot was successfully disabled.
 428   @retval EFI_NOT_STARTED          The driver is already in stopped state.
 429   @retval EFI_INVALID_PARAMETER    Private is NULL.
 430   @retval Others                   Unexpected error when stop the function.
 431
 432 **/
 433 EFI_STATUS
 434 HttpBootStop (
 435   IN HTTP_BOOT_PRIVATE_DATA           *Private
 436   )
 437 {
 438   UINTN            Index;
 439
 440   if (Private == NULL) {
 441     return EFI_INVALID_PARAMETER;
 442   }
 443
 444   if (!Private->Started) {
 445     return EFI_NOT_STARTED;
 446   }
 447
 448   if (Private->HttpCreated) {
 449     HttpIoDestroyIo (&Private->HttpIo);
 450     Private->HttpCreated = FALSE;
 451   }
 452
 453   Private->Started = FALSE;
 454   ZeroMem (&Private->StationIp, sizeof (EFI_IP_ADDRESS));
 455   ZeroMem (&Private->SubnetMask, sizeof (EFI_IP_ADDRESS));
 456   ZeroMem (&Private->GatewayIp, sizeof (EFI_IP_ADDRESS));
 457   Private->Port = 0;
 458   Private->BootFileUri = NULL;
 459   Private->BootFileUriParser = NULL;
 460   Private->BootFileSize = 0;
 461   Private->SelectIndex = 0;
 462   Private->SelectProxyType = HttpOfferTypeMax;
 463
 464   if (!Private->UsingIpv6) {
 465     //
 466     // Stop and release the DHCP4 child.
 467     //
 468     Private->Dhcp4->Stop (Private->Dhcp4);
 469     Private->Dhcp4->Configure (Private->Dhcp4, NULL);
 470
 471     for (Index = 0; Index < HTTP_BOOT_OFFER_MAX_NUM; Index++) {
 472       if (Private->OfferBuffer[Index].Dhcp4.UriParser) {
 473         HttpUrlFreeParser (Private->OfferBuffer[Index].Dhcp4.UriParser);
 474       }
 475     }
 476   } else {
 477     //
 478     // Stop and release the DHCP6 child.
 479     //
 480     Private->Dhcp6->Stop (Private->Dhcp6);
 481     Private->Dhcp6->Configure (Private->Dhcp6, NULL);
 482
 483     for (Index = 0; Index < HTTP_BOOT_OFFER_MAX_NUM; Index++) {
 484       if (Private->OfferBuffer[Index].Dhcp6.UriParser) {
 485         HttpUrlFreeParser (Private->OfferBuffer[Index].Dhcp6.UriParser);
 486       }
 487     }
 488   }
 489
 490   if (Private->DnsServerIp != NULL) {
 491     FreePool (Private->DnsServerIp);
 492     Private->DnsServerIp = NULL;
 493   }
 494
 495   if (Private->FilePathUri!= NULL) {
 496     FreePool (Private->FilePathUri);
 497     HttpUrlFreeParser (Private->FilePathUriParser);
 498     Private->FilePathUri = NULL;
 499     Private->FilePathUriParser = NULL;
 500   }
 501
 502   ZeroMem (Private->OfferBuffer, sizeof (Private->OfferBuffer));
 503   Private->OfferNum = 0;
 504   ZeroMem (Private->OfferCount, sizeof (Private->OfferCount));
 505   ZeroMem (Private->OfferIndex, sizeof (Private->OfferIndex));
 506
 507   HttpBootFreeCacheList (Private);
 508
 509   return EFI_SUCCESS;
 510 }
 511
 512 /**
 513   Causes the driver to load a specified file.
 514
 515   @param  This       Protocol instance pointer.
 516   @param  FilePath   The device specific path of the file to load.
 517   @param  BootPolicy If TRUE, indicates that the request originates from the
 518                      boot manager is attempting to load FilePath as a boot
 519                      selection. If FALSE, then FilePath must match as exact file
 520                      to be loaded.
 521   @param  BufferSize On input the size of Buffer in bytes. On output with a return
 522                      code of EFI_SUCCESS, the amount of data transferred to
 523                      Buffer. On output with a return code of EFI_BUFFER_TOO_SMALL,
 524                      the size of Buffer required to retrieve the requested file.
 525   @param  Buffer     The memory buffer to transfer the file to. IF Buffer is NULL,
 526                      then the size of the requested file is returned in
 527                      BufferSize.
 528
 529   @retval EFI_SUCCESS           The file was loaded.
 530   @retval EFI_UNSUPPORTED       The device does not support the provided BootPolicy
 531   @retval EFI_INVALID_PARAMETER FilePath is not a valid device path, or
 532                                 BufferSize is NULL.
 533   @retval EFI_NO_MEDIA          No medium was present to load the file.
 534   @retval EFI_DEVICE_ERROR      The file was not loaded due to a device error.
 535   @retval EFI_NO_RESPONSE       The remote system did not respond.
 536   @retval EFI_NOT_FOUND         The file was not found.
 537   @retval EFI_ABORTED           The file load process was manually cancelled.
 538   @retval EFI_BUFFER_TOO_SMALL  The BufferSize is too small to read the current directory entry.
 539                                 BufferSize has been updated with the size needed to complete
 540                                 the request.
 541
 542 **/
 543 EFI_STATUS
 544 EFIAPI
 545 HttpBootDxeLoadFile (
 546   IN EFI_LOAD_FILE_PROTOCOL           *This,
 547   IN EFI_DEVICE_PATH_PROTOCOL         *FilePath,
 548   IN BOOLEAN                          BootPolicy,
 549   IN OUT UINTN                        *BufferSize,
 550   IN VOID                             *Buffer OPTIONAL
 551   )
 552 {
 553   HTTP_BOOT_PRIVATE_DATA        *Private;
 554   HTTP_BOOT_VIRTUAL_NIC         *VirtualNic;
 555   EFI_STATUS                    MediaStatus;
 556   BOOLEAN                       UsingIpv6;
 557   EFI_STATUS                    Status;
 558   HTTP_BOOT_IMAGE_TYPE          ImageType;
 559
 560   if (This == NULL || BufferSize == NULL || FilePath == NULL) {
 561     return EFI_INVALID_PARAMETER;
 562   }
 563
 564   //
 565   // Only support BootPolicy
 566   //
 567   if (!BootPolicy) {
 568     return EFI_UNSUPPORTED;
 569   }
 570
 571   VirtualNic = HTTP_BOOT_VIRTUAL_NIC_FROM_LOADFILE (This);
 572   Private = VirtualNic->Private;
 573
 574   //
 575   // Check media status before HTTP boot start
 576   //
 577   MediaStatus = EFI_SUCCESS;
 578   NetLibDetectMediaWaitTimeout (Private->Controller, HTTP_BOOT_CHECK_MEDIA_WAITING_TIME, &MediaStatus);
 579   if (MediaStatus != EFI_SUCCESS) {
 580     AsciiPrint ("\n  Error: Could not detect network connection.\n");
 581     return EFI_NO_MEDIA;
 582   }
 583
 584   //
 585   // Check whether the virtual nic is using IPv6 or not.
 586   //
 587   UsingIpv6 = FALSE;
 588   if (VirtualNic == Private->Ip6Nic) {
 589     UsingIpv6 = TRUE;
 590   }
 591
 592   //
 593   // Initialize HTTP boot.
 594   //
 595   Status = HttpBootStart (Private, UsingIpv6, FilePath);
 596   if (Status != EFI_SUCCESS && Status != EFI_ALREADY_STARTED) {
 597     return Status;
 598   }
 599
 600   //
 601   // Load the boot file.
 602   //
 603   ImageType = ImageTypeMax;
 604   Status = HttpBootLoadFile (Private, BufferSize, Buffer, &ImageType);
 605   if (EFI_ERROR (Status)) {
 606     if (Status == EFI_BUFFER_TOO_SMALL && (ImageType == ImageTypeVirtualCd || ImageType == ImageTypeVirtualDisk)) {
 607       Status = EFI_WARN_FILE_SYSTEM;
 608     } else if (Status != EFI_BUFFER_TOO_SMALL) {
 609       HttpBootStop (Private);
 610     }
 611     return Status;
 612   }
 613
 614   //
 615   // Register the RAM Disk to the system if needed.
 616   //
 617   if (ImageType == ImageTypeVirtualCd || ImageType == ImageTypeVirtualDisk) {
 618     Status = HttpBootRegisterRamDisk (Private, *BufferSize, Buffer, ImageType);
 619     if (!EFI_ERROR (Status)) {
 620       Status = EFI_WARN_FILE_SYSTEM;
 621     } else {
 622       AsciiPrint ("\n  Error: Could not register RAM disk to the system.\n");
 623     }
 624   }
 625
 626   //
 627   // Stop the HTTP Boot service after the boot image is downloaded.
 628   //
 629   HttpBootStop (Private);
 630   return Status;
 631 }
 632
 633 ///
 634 /// Load File Protocol instance
 635 ///
 636 GLOBAL_REMOVE_IF_UNREFERENCED
 637 EFI_LOAD_FILE_PROTOCOL  gHttpBootDxeLoadFile = {
 638   HttpBootDxeLoadFile
 639 };
 640
 641 /**
 642   Callback function that is invoked when the HTTP Boot driver is about to transmit or has received a
 643   packet.
 644
 645   This function is invoked when the HTTP Boot driver is about to transmit or has received packet.
 646   Parameters DataType and Received specify the type of event and the format of the buffer pointed
 647   to by Data. Due to the polling nature of UEFI device drivers, this callback function should not
 648   execute for more than 5 ms.
 649   The returned status code determines the behavior of the HTTP Boot driver.
 650
 651   @param[in]  This                Pointer to the EFI_HTTP_BOOT_CALLBACK_PROTOCOL instance.
 652   @param[in]  DataType            The event that occurs in the current state.
 653   @param[in]  Received            TRUE if the callback is being invoked due to a receive event.
 654                                   FALSE if the callback is being invoked due to a transmit event.
 655   @param[in]  DataLength          The length in bytes of the buffer pointed to by Data.
 656   @param[in]  Data                A pointer to the buffer of data, the data type is specified by
 657                                   DataType.
 658
 659   @retval EFI_SUCCESS             Tells the HTTP Boot driver to continue the HTTP Boot process.
 660   @retval EFI_ABORTED             Tells the HTTP Boot driver to abort the current HTTP Boot process.
 661 **/
 662 EFI_STATUS
 663 EFIAPI
 664 HttpBootCallback (
 665   IN EFI_HTTP_BOOT_CALLBACK_PROTOCOL     *This,
 666   IN EFI_HTTP_BOOT_CALLBACK_DATA_TYPE    DataType,
 667   IN BOOLEAN                             Received,
 668   IN UINT32                              DataLength,
 669   IN VOID                                *Data     OPTIONAL
 670   )
 671 {
 672   EFI_HTTP_MESSAGE        *HttpMessage;
 673   EFI_HTTP_HEADER         *HttpHeader;
 674   HTTP_BOOT_PRIVATE_DATA  *Private;
 675   UINT32                  Percentage;
 676
 677   Private = HTTP_BOOT_PRIVATE_DATA_FROM_CALLBACK_PROTOCOL(This);
 678
 679   switch (DataType) {
 680   case HttpBootDhcp4:
 681   case HttpBootDhcp6:
 682     Print (L".");
 683     break;
 684
 685   case HttpBootHttpRequest:
 686     if (Data != NULL) {
 687       HttpMessage = (EFI_HTTP_MESSAGE *) Data;
 688       if (HttpMessage->Data.Request->Method == HttpMethodGet &&
 689           HttpMessage->Data.Request->Url != NULL) {
 690         Print (L"\n  URI: %s\n", HttpMessage->Data.Request->Url);
 691       }
 692     }
 693     break;
 694
 695   case HttpBootHttpResponse:
 696     if (Data != NULL) {
 697       HttpMessage = (EFI_HTTP_MESSAGE *) Data;
 698
 699       if (HttpMessage->Data.Response != NULL) {
 700         if (HttpBootIsHttpRedirectStatusCode (HttpMessage->Data.Response->StatusCode)) {
 701           //
 702           // Server indicates the resource has been redirected to a different URL
 703           // according to the section 6.4 of RFC7231 and the RFC 7538.
 704           // Display the redirect information on the screen.
 705           //
 706           HttpHeader = HttpFindHeader (
 707                  HttpMessage->HeaderCount,
 708                  HttpMessage->Headers,
 709                  HTTP_HEADER_LOCATION
 710                  );
 711           if (HttpHeader != NULL) {
 712             Print (L"\n  HTTP ERROR: Resource Redirected.\n  New Location: %a\n", HttpHeader->FieldValue);
 713           }
 714           break;
 715         }
 716       }
 717
 718       HttpHeader = HttpFindHeader (
 719                      HttpMessage->HeaderCount,
 720                      HttpMessage->Headers,
 721                      HTTP_HEADER_CONTENT_LENGTH
 722                      );
 723       if (HttpHeader != NULL) {
 724         Private->FileSize = AsciiStrDecimalToUintn (HttpHeader->FieldValue);
 725         Private->ReceivedSize = 0;
 726         Private->Percentage   = 0;
 727       }
 728     }
 729     break;
 730
 731   case HttpBootHttpEntityBody:
 732     if (DataLength != 0) {
 733       if (Private->FileSize != 0) {
 734         //
 735         // We already know the file size, print in percentage format.
 736         //
 737         if (Private->ReceivedSize == 0) {
 738           Print (L"  File Size: %lu Bytes\n", Private->FileSize);
 739         }
 740         Private->ReceivedSize += DataLength;
 741         Percentage = (UINT32) DivU64x64Remainder (MultU64x32 (Private->ReceivedSize, 100), Private->FileSize, NULL);
 742         if (Private->Percentage != Percentage) {
 743           Private->Percentage = Percentage;
 744           Print (L"\r  Downloading...%d%%", Percentage);
 745         }
 746       } else {
 747         //
 748         // In some case we couldn't get the file size from the HTTP header, so we
 749         // just print the downloaded file size.
 750         //
 751         Private->ReceivedSize += DataLength;
 752         Print (L"\r  Downloading...%lu Bytes", Private->ReceivedSize);
 753       }
 754     }
 755     break;
 756
 757   default:
 758     break;
 759   };
 760
 761   return EFI_SUCCESS;
 762 }
 763
 764 ///
 765 /// HTTP Boot Callback Protocol instance
 766 ///
 767 GLOBAL_REMOVE_IF_UNREFERENCED
 768 EFI_HTTP_BOOT_CALLBACK_PROTOCOL  gHttpBootDxeHttpBootCallback = {
 769   HttpBootCallback
 770 };