| /** @file | |
| The implementation of EFI_LOAD_FILE_PROTOCOL for UEFI HTTP boot. | |
| Copyright (c) 2015 - 2016, Intel Corporation. All rights reserved.<BR> | |
| (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR> | |
| This program and the accompanying materials are licensed and made available under | |
| the terms and conditions of the BSD License that accompanies this distribution. | |
| The full text of the license may be found at | |
| http://opensource.org/licenses/bsd-license.php. | |
| THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, | |
| WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. | |
| **/ | |
| #include "HttpBootDxe.h" | |
| /** | |
| Enable the use of UEFI HTTP boot function. | |
| If the driver has already been started but not satisfy the requirement (IP stack and | |
| specified boot file path), this function will stop the driver and start it again. | |
| @param[in] Private The pointer to the driver's private data. | |
| @param[in] UsingIpv6 Specifies the type of IP addresses that are to be | |
| used during the session that is being started. | |
| Set to TRUE for IPv6, and FALSE for IPv4. | |
| @param[in] FilePath The device specific path of the file to load. | |
| @retval EFI_SUCCESS HTTP boot was successfully enabled. | |
| @retval EFI_INVALID_PARAMETER Private is NULL or FilePath is NULL. | |
| @retval EFI_INVALID_PARAMETER The FilePath doesn't contain a valid URI device path node. | |
| @retval EFI_ALREADY_STARTED The driver is already in started state. | |
| @retval EFI_OUT_OF_RESOURCES There are not enough resources. | |
| **/ | |
| EFI_STATUS | |
| HttpBootStart ( | |
| IN HTTP_BOOT_PRIVATE_DATA *Private, | |
| IN BOOLEAN UsingIpv6, | |
| IN EFI_DEVICE_PATH_PROTOCOL *FilePath | |
| ) | |
| { | |
| UINTN Index; | |
| EFI_STATUS Status; | |
| CHAR8 *Uri; | |
| if (Private == NULL || FilePath == NULL) { | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| // | |
| // Check the URI in the input FilePath, in order to see whether it is | |
| // required to boot from a new specified boot file. | |
| // | |
| Status = HttpBootParseFilePath (FilePath, &Uri); | |
| if (EFI_ERROR (Status)) { | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| // | |
| // Check whether we need to stop and restart the HTTP boot driver. | |
| // | |
| if (Private->Started) { | |
| // | |
| // Restart is needed in 2 cases: | |
| // 1. Http boot driver has already been started but not on the required IP stack. | |
| // 2. The specified boot file URI in FilePath is different with the one we have | |
| // recorded before. | |
| // | |
| if ((UsingIpv6 != Private->UsingIpv6) || | |
| ((Uri != NULL) && (AsciiStrCmp (Private->BootFileUri, Uri) != 0))) { | |
| // | |
| // Restart is required, first stop then continue this start function. | |
| // | |
| Status = HttpBootStop (Private); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| } else { | |
| // | |
| // Restart is not required. | |
| // | |
| if (Uri != NULL) { | |
| FreePool (Uri); | |
| } | |
| return EFI_ALREADY_STARTED; | |
| } | |
| } | |
| // | |
| // Detect whether using ipv6 or not, and set it to the private data. | |
| // | |
| if (UsingIpv6 && Private->Ip6Nic != NULL) { | |
| Private->UsingIpv6 = TRUE; | |
| } else if (!UsingIpv6 && Private->Ip4Nic != NULL) { | |
| Private->UsingIpv6 = FALSE; | |
| } else { | |
| if (Uri != NULL) { | |
| FreePool (Uri); | |
| } | |
| return EFI_UNSUPPORTED; | |
| } | |
| // | |
| // Record the specified URI and prepare the URI parser if needed. | |
| // | |
| Private->FilePathUri = Uri; | |
| if (Private->FilePathUri != NULL) { | |
| Status = HttpParseUrl ( | |
| Private->FilePathUri, | |
| (UINT32) AsciiStrLen (Private->FilePathUri), | |
| FALSE, | |
| &Private->FilePathUriParser | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| FreePool (Private->FilePathUri); | |
| return Status; | |
| } | |
| } | |
| // | |
| // Init the content of cached DHCP offer list. | |
| // | |
| ZeroMem (Private->OfferBuffer, sizeof (Private->OfferBuffer)); | |
| if (!Private->UsingIpv6) { | |
| for (Index = 0; Index < HTTP_BOOT_OFFER_MAX_NUM; Index++) { | |
| Private->OfferBuffer[Index].Dhcp4.Packet.Offer.Size = HTTP_CACHED_DHCP4_PACKET_MAX_SIZE; | |
| } | |
| } else { | |
| for (Index = 0; Index < HTTP_BOOT_OFFER_MAX_NUM; Index++) { | |
| Private->OfferBuffer[Index].Dhcp6.Packet.Offer.Size = HTTP_CACHED_DHCP6_PACKET_MAX_SIZE; | |
| } | |
| } | |
| if (Private->UsingIpv6) { | |
| // | |
| // Set Ip6 policy to Automatic to start the Ip6 router discovery. | |
| // | |
| Status = HttpBootSetIp6Policy (Private); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| } | |
| Private->Started = TRUE; | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Attempt to complete a DHCPv4 D.O.R.A or DHCPv6 S.R.A.A sequence to retrieve the boot resource information. | |
| @param[in] Private The pointer to the driver's private data. | |
| @retval EFI_SUCCESS Boot info was successfully retrieved. | |
| @retval EFI_INVALID_PARAMETER Private is NULL. | |
| @retval EFI_NOT_STARTED The driver is in stopped state. | |
| @retval EFI_DEVICE_ERROR An unexpected network error occurred. | |
| @retval Others Other errors as indicated. | |
| **/ | |
| EFI_STATUS | |
| HttpBootDhcp ( | |
| IN HTTP_BOOT_PRIVATE_DATA *Private | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| if (Private == NULL) { | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| if (!Private->Started) { | |
| return EFI_NOT_STARTED; | |
| } | |
| Status = EFI_DEVICE_ERROR; | |
| if (!Private->UsingIpv6) { | |
| // | |
| // Start D.O.R.A process to get a IPv4 address and other boot information. | |
| // | |
| Status = HttpBootDhcp4Dora (Private); | |
| } else { | |
| // | |
| // Start S.A.R.R process to get a IPv6 address and other boot information. | |
| // | |
| Status = HttpBootDhcp6Sarr (Private); | |
| } | |
| return Status; | |
| } | |
| /** | |
| Attempt to download the boot file through HTTP message exchange. | |
| @param[in] Private The pointer to the driver's private data. | |
| @param[in, out] BufferSize On input the size of Buffer in bytes. On output with a return | |
| code of EFI_SUCCESS, the amount of data transferred to | |
| Buffer. On output with a return code of EFI_BUFFER_TOO_SMALL, | |
| the size of Buffer required to retrieve the requested file. | |
| @param[in] Buffer The memory buffer to transfer the file to. If Buffer is NULL, | |
| then the size of the requested file is returned in | |
| BufferSize. | |
| @param[out] ImageType The image type of the downloaded file. | |
| @retval EFI_SUCCESS Boot file was loaded successfully. | |
| @retval EFI_INVALID_PARAMETER Private is NULL, or ImageType is NULL, or BufferSize is NULL. | |
| @retval EFI_INVALID_PARAMETER *BufferSize is not zero, and Buffer is NULL. | |
| @retval EFI_NOT_STARTED The driver is in stopped state. | |
| @retval EFI_BUFFER_TOO_SMALL The BufferSize is too small to read the boot file. BufferSize has | |
| been updated with the size needed to complete the request. | |
| @retval EFI_DEVICE_ERROR An unexpected network error occurred. | |
| @retval Others Other errors as indicated. | |
| **/ | |
| EFI_STATUS | |
| HttpBootLoadFile ( | |
| IN HTTP_BOOT_PRIVATE_DATA *Private, | |
| IN OUT UINTN *BufferSize, | |
| IN VOID *Buffer, OPTIONAL | |
| OUT HTTP_BOOT_IMAGE_TYPE *ImageType | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| if (Private == NULL || ImageType == NULL || BufferSize == NULL ) { | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| if (*BufferSize != 0 && Buffer == NULL) { | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| if (!Private->Started) { | |
| return EFI_NOT_STARTED; | |
| } | |
| Status = EFI_DEVICE_ERROR; | |
| if (Private->BootFileUri == NULL) { | |
| // | |
| // Parse the cached offer to get the boot file URL first. | |
| // | |
| Status = HttpBootDiscoverBootInfo (Private); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| } | |
| if (!Private->HttpCreated) { | |
| // | |
| // Create HTTP child. | |
| // | |
| Status = HttpBootCreateHttpIo (Private); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| } | |
| if (Private->BootFileSize == 0) { | |
| // | |
| // Discover the information about the bootfile if we haven't. | |
| // | |
| // | |
| // Try to use HTTP HEAD method. | |
| // | |
| Status = HttpBootGetBootFile ( | |
| Private, | |
| TRUE, | |
| &Private->BootFileSize, | |
| NULL, | |
| &Private->ImageType | |
| ); | |
| if (EFI_ERROR (Status) && Status != EFI_BUFFER_TOO_SMALL) { | |
| // | |
| // Failed to get file size by HEAD method, may be trunked encoding, try HTTP GET method. | |
| // | |
| ASSERT (Private->BootFileSize == 0); | |
| Status = HttpBootGetBootFile ( | |
| Private, | |
| FALSE, | |
| &Private->BootFileSize, | |
| NULL, | |
| &Private->ImageType | |
| ); | |
| if (EFI_ERROR (Status) && Status != EFI_BUFFER_TOO_SMALL) { | |
| return Status; | |
| } | |
| } | |
| } | |
| if (*BufferSize < Private->BootFileSize) { | |
| *BufferSize = Private->BootFileSize; | |
| *ImageType = Private->ImageType; | |
| return EFI_BUFFER_TOO_SMALL; | |
| } | |
| // | |
| // Load the boot file into Buffer | |
| // | |
| return HttpBootGetBootFile ( | |
| Private, | |
| FALSE, | |
| BufferSize, | |
| Buffer, | |
| ImageType | |
| ); | |
| } | |
| /** | |
| Disable the use of UEFI HTTP boot function. | |
| @param[in] Private The pointer to the driver's private data. | |
| @retval EFI_SUCCESS HTTP boot was successfully disabled. | |
| @retval EFI_NOT_STARTED The driver is already in stopped state. | |
| @retval EFI_INVALID_PARAMETER Private is NULL. | |
| @retval Others Unexpected error when stop the function. | |
| **/ | |
| EFI_STATUS | |
| HttpBootStop ( | |
| IN HTTP_BOOT_PRIVATE_DATA *Private | |
| ) | |
| { | |
| UINTN Index; | |
| if (Private == NULL) { | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| if (!Private->Started) { | |
| return EFI_NOT_STARTED; | |
| } | |
| if (Private->HttpCreated) { | |
| HttpIoDestroyIo (&Private->HttpIo); | |
| Private->HttpCreated = FALSE; | |
| } | |
| Private->Started = FALSE; | |
| ZeroMem (&Private->StationIp, sizeof (EFI_IP_ADDRESS)); | |
| ZeroMem (&Private->SubnetMask, sizeof (EFI_IP_ADDRESS)); | |
| ZeroMem (&Private->GatewayIp, sizeof (EFI_IP_ADDRESS)); | |
| Private->Port = 0; | |
| Private->BootFileUri = NULL; | |
| Private->BootFileUriParser = NULL; | |
| Private->BootFileSize = 0; | |
| Private->SelectIndex = 0; | |
| Private->SelectProxyType = HttpOfferTypeMax; | |
| if (!Private->UsingIpv6) { | |
| // | |
| // Stop and release the DHCP4 child. | |
| // | |
| Private->Dhcp4->Stop (Private->Dhcp4); | |
| Private->Dhcp4->Configure (Private->Dhcp4, NULL); | |
| for (Index = 0; Index < HTTP_BOOT_OFFER_MAX_NUM; Index++) { | |
| if (Private->OfferBuffer[Index].Dhcp4.UriParser) { | |
| HttpUrlFreeParser (Private->OfferBuffer[Index].Dhcp4.UriParser); | |
| } | |
| } | |
| } else { | |
| // | |
| // Stop and release the DHCP6 child. | |
| // | |
| Private->Dhcp6->Stop (Private->Dhcp6); | |
| Private->Dhcp6->Configure (Private->Dhcp6, NULL); | |
| for (Index = 0; Index < HTTP_BOOT_OFFER_MAX_NUM; Index++) { | |
| if (Private->OfferBuffer[Index].Dhcp6.UriParser) { | |
| HttpUrlFreeParser (Private->OfferBuffer[Index].Dhcp6.UriParser); | |
| } | |
| } | |
| } | |
| if (Private->FilePathUri!= NULL) { | |
| FreePool (Private->FilePathUri); | |
| HttpUrlFreeParser (Private->FilePathUriParser); | |
| Private->FilePathUri = NULL; | |
| Private->FilePathUriParser = NULL; | |
| } | |
| ZeroMem (Private->OfferBuffer, sizeof (Private->OfferBuffer)); | |
| Private->OfferNum = 0; | |
| ZeroMem (Private->OfferCount, sizeof (Private->OfferCount)); | |
| ZeroMem (Private->OfferIndex, sizeof (Private->OfferIndex)); | |
| HttpBootFreeCacheList (Private); | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Causes the driver to load a specified file. | |
| @param This Protocol instance pointer. | |
| @param FilePath The device specific path of the file to load. | |
| @param BootPolicy If TRUE, indicates that the request originates from the | |
| boot manager is attempting to load FilePath as a boot | |
| selection. If FALSE, then FilePath must match as exact file | |
| to be loaded. | |
| @param BufferSize On input the size of Buffer in bytes. On output with a return | |
| code of EFI_SUCCESS, the amount of data transferred to | |
| Buffer. On output with a return code of EFI_BUFFER_TOO_SMALL, | |
| the size of Buffer required to retrieve the requested file. | |
| @param Buffer The memory buffer to transfer the file to. IF Buffer is NULL, | |
| then the size of the requested file is returned in | |
| BufferSize. | |
| @retval EFI_SUCCESS The file was loaded. | |
| @retval EFI_UNSUPPORTED The device does not support the provided BootPolicy | |
| @retval EFI_INVALID_PARAMETER FilePath is not a valid device path, or | |
| BufferSize is NULL. | |
| @retval EFI_NO_MEDIA No medium was present to load the file. | |
| @retval EFI_DEVICE_ERROR The file was not loaded due to a device error. | |
| @retval EFI_NO_RESPONSE The remote system did not respond. | |
| @retval EFI_NOT_FOUND The file was not found. | |
| @retval EFI_ABORTED The file load process was manually cancelled. | |
| @retval EFI_BUFFER_TOO_SMALL The BufferSize is too small to read the current directory entry. | |
| BufferSize has been updated with the size needed to complete | |
| the request. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| HttpBootDxeLoadFile ( | |
| IN EFI_LOAD_FILE_PROTOCOL *This, | |
| IN EFI_DEVICE_PATH_PROTOCOL *FilePath, | |
| IN BOOLEAN BootPolicy, | |
| IN OUT UINTN *BufferSize, | |
| IN VOID *Buffer OPTIONAL | |
| ) | |
| { | |
| HTTP_BOOT_PRIVATE_DATA *Private; | |
| HTTP_BOOT_VIRTUAL_NIC *VirtualNic; | |
| BOOLEAN MediaPresent; | |
| BOOLEAN UsingIpv6; | |
| EFI_STATUS Status; | |
| HTTP_BOOT_IMAGE_TYPE ImageType; | |
| if (This == NULL || BufferSize == NULL || FilePath == NULL) { | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| // | |
| // Only support BootPolicy | |
| // | |
| if (!BootPolicy) { | |
| return EFI_UNSUPPORTED; | |
| } | |
| VirtualNic = HTTP_BOOT_VIRTUAL_NIC_FROM_LOADFILE (This); | |
| Private = VirtualNic->Private; | |
| // | |
| // Check media status before HTTP boot start | |
| // | |
| MediaPresent = TRUE; | |
| NetLibDetectMedia (Private->Controller, &MediaPresent); | |
| if (!MediaPresent) { | |
| return EFI_NO_MEDIA; | |
| } | |
| // | |
| // Check whether the virtual nic is using IPv6 or not. | |
| // | |
| UsingIpv6 = FALSE; | |
| if (VirtualNic == Private->Ip6Nic) { | |
| UsingIpv6 = TRUE; | |
| } | |
| // | |
| // Initialize HTTP boot. | |
| // | |
| Status = HttpBootStart (Private, UsingIpv6, FilePath); | |
| if (Status != EFI_SUCCESS && Status != EFI_ALREADY_STARTED) { | |
| return Status; | |
| } | |
| // | |
| // Load the boot file. | |
| // | |
| ImageType = ImageTypeMax; | |
| Status = HttpBootLoadFile (Private, BufferSize, Buffer, &ImageType); | |
| if (EFI_ERROR (Status)) { | |
| if (Status == EFI_BUFFER_TOO_SMALL && (ImageType == ImageTypeVirtualCd || ImageType == ImageTypeVirtualDisk)) { | |
| Status = EFI_WARN_FILE_SYSTEM; | |
| } else if (Status != EFI_BUFFER_TOO_SMALL) { | |
| HttpBootStop (Private); | |
| } | |
| return Status; | |
| } | |
| // | |
| // Register the RAM Disk to the system if needed. | |
| // | |
| if (ImageType == ImageTypeVirtualCd || ImageType == ImageTypeVirtualDisk) { | |
| Status = HttpBootRegisterRamDisk (Private, *BufferSize, Buffer, ImageType); | |
| if (!EFI_ERROR (Status)) { | |
| Status = EFI_WARN_FILE_SYSTEM; | |
| } | |
| } | |
| // | |
| // Stop the HTTP Boot service after the boot image is downloaded. | |
| // | |
| HttpBootStop (Private); | |
| return Status; | |
| } | |
| /// | |
| /// Load File Protocol instance | |
| /// | |
| GLOBAL_REMOVE_IF_UNREFERENCED | |
| EFI_LOAD_FILE_PROTOCOL gHttpBootDxeLoadFile = { | |
| HttpBootDxeLoadFile | |
| }; |