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