2 Implementation of the boot file download function.
4 Copyright (c) 2015 - 2018, 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.
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.
16 #include "HttpBootDxe.h"
19 Update the device path node to include the boot resource information.
21 @param[in] Private The pointer to the driver's private data.
23 @retval EFI_SUCCESS Device patch successfully updated.
24 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.
25 @retval Others Unexpected error happened.
29 HttpBootUpdateDevicePath (
30 IN HTTP_BOOT_PRIVATE_DATA
*Private
34 EFI_DEVICE_PATH_PROTOCOL
*TmpIpDevicePath
;
35 EFI_DEVICE_PATH_PROTOCOL
*TmpDnsDevicePath
;
36 EFI_DEVICE_PATH_PROTOCOL
*NewDevicePath
;
40 TmpIpDevicePath
= NULL
;
41 TmpDnsDevicePath
= NULL
;
44 // Update the IP node with DHCP assigned information.
46 if (!Private
->UsingIpv6
) {
47 Node
= AllocateZeroPool (sizeof (IPv4_DEVICE_PATH
));
49 return EFI_OUT_OF_RESOURCES
;
51 Node
->Ipv4
.Header
.Type
= MESSAGING_DEVICE_PATH
;
52 Node
->Ipv4
.Header
.SubType
= MSG_IPv4_DP
;
53 SetDevicePathNodeLength (Node
, sizeof (IPv4_DEVICE_PATH
));
54 CopyMem (&Node
->Ipv4
.LocalIpAddress
, &Private
->StationIp
, sizeof (EFI_IPv4_ADDRESS
));
55 Node
->Ipv4
.RemotePort
= Private
->Port
;
56 Node
->Ipv4
.Protocol
= EFI_IP_PROTO_TCP
;
57 Node
->Ipv4
.StaticIpAddress
= FALSE
;
58 CopyMem (&Node
->Ipv4
.GatewayIpAddress
, &Private
->GatewayIp
, sizeof (EFI_IPv4_ADDRESS
));
59 CopyMem (&Node
->Ipv4
.SubnetMask
, &Private
->SubnetMask
, sizeof (EFI_IPv4_ADDRESS
));
61 Node
= AllocateZeroPool (sizeof (IPv6_DEVICE_PATH
));
63 return EFI_OUT_OF_RESOURCES
;
65 Node
->Ipv6
.Header
.Type
= MESSAGING_DEVICE_PATH
;
66 Node
->Ipv6
.Header
.SubType
= MSG_IPv6_DP
;
67 SetDevicePathNodeLength (Node
, sizeof (IPv6_DEVICE_PATH
));
68 Node
->Ipv6
.PrefixLength
= IP6_PREFIX_LENGTH
;
69 Node
->Ipv6
.RemotePort
= Private
->Port
;
70 Node
->Ipv6
.Protocol
= EFI_IP_PROTO_TCP
;
71 Node
->Ipv6
.IpAddressOrigin
= 0;
72 CopyMem (&Node
->Ipv6
.LocalIpAddress
, &Private
->StationIp
.v6
, sizeof (EFI_IPv6_ADDRESS
));
73 CopyMem (&Node
->Ipv6
.RemoteIpAddress
, &Private
->ServerIp
.v6
, sizeof (EFI_IPv6_ADDRESS
));
74 CopyMem (&Node
->Ipv6
.GatewayIpAddress
, &Private
->GatewayIp
.v6
, sizeof (EFI_IPv6_ADDRESS
));
77 TmpIpDevicePath
= AppendDevicePathNode (Private
->ParentDevicePath
, (EFI_DEVICE_PATH_PROTOCOL
*) Node
);
79 if (TmpIpDevicePath
== NULL
) {
80 return EFI_OUT_OF_RESOURCES
;
84 // Update the DNS node with DNS server IP list if existed.
86 if (Private
->DnsServerIp
!= NULL
) {
87 Length
= sizeof (EFI_DEVICE_PATH_PROTOCOL
) + sizeof (Node
->Dns
.IsIPv6
) + Private
->DnsServerCount
* sizeof (EFI_IP_ADDRESS
);
88 Node
= AllocatePool (Length
);
90 FreePool (TmpIpDevicePath
);
91 return EFI_OUT_OF_RESOURCES
;
93 Node
->DevPath
.Type
= MESSAGING_DEVICE_PATH
;
94 Node
->DevPath
.SubType
= MSG_DNS_DP
;
95 SetDevicePathNodeLength (Node
, Length
);
96 Node
->Dns
.IsIPv6
= Private
->UsingIpv6
? 0x01 : 0x00;
97 CopyMem ((UINT8
*) Node
+ sizeof (EFI_DEVICE_PATH_PROTOCOL
) + sizeof (Node
->Dns
.IsIPv6
), Private
->DnsServerIp
, Private
->DnsServerCount
* sizeof (EFI_IP_ADDRESS
));
99 TmpDnsDevicePath
= AppendDevicePathNode (TmpIpDevicePath
, (EFI_DEVICE_PATH_PROTOCOL
*) Node
);
101 FreePool (TmpIpDevicePath
);
102 TmpIpDevicePath
= NULL
;
103 if (TmpDnsDevicePath
== NULL
) {
104 return EFI_OUT_OF_RESOURCES
;
109 // Update the URI node with the boot file URI.
111 Length
= sizeof (EFI_DEVICE_PATH_PROTOCOL
) + AsciiStrSize (Private
->BootFileUri
);
112 Node
= AllocatePool (Length
);
114 if (TmpIpDevicePath
!= NULL
) {
115 FreePool (TmpIpDevicePath
);
117 if (TmpDnsDevicePath
!= NULL
) {
118 FreePool (TmpDnsDevicePath
);
120 return EFI_OUT_OF_RESOURCES
;
122 Node
->DevPath
.Type
= MESSAGING_DEVICE_PATH
;
123 Node
->DevPath
.SubType
= MSG_URI_DP
;
124 SetDevicePathNodeLength (Node
, Length
);
125 CopyMem ((UINT8
*) Node
+ sizeof (EFI_DEVICE_PATH_PROTOCOL
), Private
->BootFileUri
, AsciiStrSize (Private
->BootFileUri
));
127 if (TmpDnsDevicePath
!= NULL
) {
128 NewDevicePath
= AppendDevicePathNode (TmpDnsDevicePath
, (EFI_DEVICE_PATH_PROTOCOL
*) Node
);
129 FreePool (TmpDnsDevicePath
);
131 ASSERT (TmpIpDevicePath
!= NULL
);
132 NewDevicePath
= AppendDevicePathNode (TmpIpDevicePath
, (EFI_DEVICE_PATH_PROTOCOL
*) Node
);
133 FreePool (TmpIpDevicePath
);
136 if (NewDevicePath
== NULL
) {
137 return EFI_OUT_OF_RESOURCES
;
140 if (!Private
->UsingIpv6
) {
142 // Reinstall the device path protocol of the child handle.
144 Status
= gBS
->ReinstallProtocolInterface (
145 Private
->Ip4Nic
->Controller
,
146 &gEfiDevicePathProtocolGuid
,
147 Private
->Ip4Nic
->DevicePath
,
150 if (EFI_ERROR (Status
)) {
154 FreePool (Private
->Ip4Nic
->DevicePath
);
155 Private
->Ip4Nic
->DevicePath
= NewDevicePath
;
158 // Reinstall the device path protocol of the child handle.
160 Status
= gBS
->ReinstallProtocolInterface (
161 Private
->Ip6Nic
->Controller
,
162 &gEfiDevicePathProtocolGuid
,
163 Private
->Ip6Nic
->DevicePath
,
166 if (EFI_ERROR (Status
)) {
169 FreePool (Private
->Ip6Nic
->DevicePath
);
170 Private
->Ip6Nic
->DevicePath
= NewDevicePath
;
177 Parse the boot file URI information from the selected Dhcp4 offer packet.
179 @param[in] Private The pointer to the driver's private data.
181 @retval EFI_SUCCESS Successfully parsed out all the boot information.
182 @retval Others Failed to parse out the boot information.
186 HttpBootDhcp4ExtractUriInfo (
187 IN HTTP_BOOT_PRIVATE_DATA
*Private
190 HTTP_BOOT_DHCP4_PACKET_CACHE
*SelectOffer
;
191 HTTP_BOOT_DHCP4_PACKET_CACHE
*HttpOffer
;
194 UINT32 DnsServerIndex
;
195 EFI_DHCP4_PACKET_OPTION
*Option
;
198 ASSERT (Private
!= NULL
);
199 ASSERT (Private
->SelectIndex
!= 0);
200 SelectIndex
= Private
->SelectIndex
- 1;
201 ASSERT (SelectIndex
< HTTP_BOOT_OFFER_MAX_NUM
);
205 Status
= EFI_SUCCESS
;
208 // SelectOffer contains the IP address configuration and name server configuration.
209 // HttpOffer contains the boot file URL.
211 SelectOffer
= &Private
->OfferBuffer
[SelectIndex
].Dhcp4
;
212 if (Private
->FilePathUri
== NULL
) {
214 // In Corporate environment, we need a HttpOffer.
216 if ((SelectOffer
->OfferType
== HttpOfferTypeDhcpIpUri
) ||
217 (SelectOffer
->OfferType
== HttpOfferTypeDhcpIpUriDns
) ||
218 (SelectOffer
->OfferType
== HttpOfferTypeDhcpNameUriDns
)) {
219 HttpOffer
= SelectOffer
;
221 ASSERT (Private
->SelectProxyType
!= HttpOfferTypeMax
);
222 ProxyIndex
= Private
->OfferIndex
[Private
->SelectProxyType
][0];
223 HttpOffer
= &Private
->OfferBuffer
[ProxyIndex
].Dhcp4
;
225 Private
->BootFileUriParser
= HttpOffer
->UriParser
;
226 Private
->BootFileUri
= (CHAR8
*) HttpOffer
->OptList
[HTTP_BOOT_DHCP4_TAG_INDEX_BOOTFILE
]->Data
;
229 // In Home environment the BootFileUri comes from the FilePath.
231 Private
->BootFileUriParser
= Private
->FilePathUriParser
;
232 Private
->BootFileUri
= Private
->FilePathUri
;
236 // Check the URI scheme.
238 Status
= HttpBootCheckUriScheme (Private
->BootFileUri
);
239 if (EFI_ERROR (Status
)) {
240 DEBUG ((EFI_D_ERROR
, "HttpBootDhcp4ExtractUriInfo: %r.\n", Status
));
241 if (Status
== EFI_INVALID_PARAMETER
) {
242 AsciiPrint ("\n Error: Invalid URI address.\n");
243 } else if (Status
== EFI_ACCESS_DENIED
) {
244 AsciiPrint ("\n Error: Access forbidden, only HTTPS connection is allowed.\n");
249 if ((SelectOffer
->OfferType
== HttpOfferTypeDhcpNameUriDns
) ||
250 (SelectOffer
->OfferType
== HttpOfferTypeDhcpDns
) ||
251 (SelectOffer
->OfferType
== HttpOfferTypeDhcpIpUriDns
)) {
252 Option
= SelectOffer
->OptList
[HTTP_BOOT_DHCP4_TAG_INDEX_DNS_SERVER
];
253 ASSERT (Option
!= NULL
);
256 // Record the Dns Server address list.
258 Private
->DnsServerCount
= (Option
->Length
) / sizeof (EFI_IPv4_ADDRESS
);
260 Private
->DnsServerIp
= AllocateZeroPool (Private
->DnsServerCount
* sizeof (EFI_IP_ADDRESS
));
261 if (Private
->DnsServerIp
== NULL
) {
262 return EFI_OUT_OF_RESOURCES
;
265 for (DnsServerIndex
= 0; DnsServerIndex
< Private
->DnsServerCount
; DnsServerIndex
++) {
266 CopyMem (&(Private
->DnsServerIp
[DnsServerIndex
].v4
), &(((EFI_IPv4_ADDRESS
*) Option
->Data
)[DnsServerIndex
]), sizeof (EFI_IPv4_ADDRESS
));
270 // Configure the default DNS server if server assigned.
272 Status
= HttpBootRegisterIp4Dns (
277 if (EFI_ERROR (Status
)) {
278 FreePool (Private
->DnsServerIp
);
279 Private
->DnsServerIp
= NULL
;
285 // Extract the port from URL, and use default HTTP port 80 if not provided.
287 Status
= HttpUrlGetPort (
288 Private
->BootFileUri
,
289 Private
->BootFileUriParser
,
292 if (EFI_ERROR (Status
) || Private
->Port
== 0) {
297 // All boot informations are valid here.
301 // Update the device path to include the boot resource information.
303 Status
= HttpBootUpdateDevicePath (Private
);
304 if (EFI_ERROR (Status
) && Private
->DnsServerIp
!= NULL
) {
305 FreePool (Private
->DnsServerIp
);
306 Private
->DnsServerIp
= NULL
;
313 Parse the boot file URI information from the selected Dhcp6 offer packet.
315 @param[in] Private The pointer to the driver's private data.
317 @retval EFI_SUCCESS Successfully parsed out all the boot information.
318 @retval Others Failed to parse out the boot information.
322 HttpBootDhcp6ExtractUriInfo (
323 IN HTTP_BOOT_PRIVATE_DATA
*Private
326 HTTP_BOOT_DHCP6_PACKET_CACHE
*SelectOffer
;
327 HTTP_BOOT_DHCP6_PACKET_CACHE
*HttpOffer
;
330 UINT32 DnsServerIndex
;
331 EFI_DHCP6_PACKET_OPTION
*Option
;
332 EFI_IPv6_ADDRESS IpAddr
;
338 ASSERT (Private
!= NULL
);
339 ASSERT (Private
->SelectIndex
!= 0);
340 SelectIndex
= Private
->SelectIndex
- 1;
341 ASSERT (SelectIndex
< HTTP_BOOT_OFFER_MAX_NUM
);
345 Status
= EFI_SUCCESS
;
348 // SelectOffer contains the IP address configuration and name server configuration.
349 // HttpOffer contains the boot file URL.
351 SelectOffer
= &Private
->OfferBuffer
[SelectIndex
].Dhcp6
;
352 if (Private
->FilePathUri
== NULL
) {
354 // In Corporate environment, we need a HttpOffer.
356 if ((SelectOffer
->OfferType
== HttpOfferTypeDhcpIpUri
) ||
357 (SelectOffer
->OfferType
== HttpOfferTypeDhcpIpUriDns
) ||
358 (SelectOffer
->OfferType
== HttpOfferTypeDhcpNameUriDns
)) {
359 HttpOffer
= SelectOffer
;
361 ASSERT (Private
->SelectProxyType
!= HttpOfferTypeMax
);
362 ProxyIndex
= Private
->OfferIndex
[Private
->SelectProxyType
][0];
363 HttpOffer
= &Private
->OfferBuffer
[ProxyIndex
].Dhcp6
;
365 Private
->BootFileUriParser
= HttpOffer
->UriParser
;
366 Private
->BootFileUri
= (CHAR8
*) HttpOffer
->OptList
[HTTP_BOOT_DHCP6_IDX_BOOT_FILE_URL
]->Data
;
369 // In Home environment the BootFileUri comes from the FilePath.
371 Private
->BootFileUriParser
= Private
->FilePathUriParser
;
372 Private
->BootFileUri
= Private
->FilePathUri
;
376 // Check the URI scheme.
378 Status
= HttpBootCheckUriScheme (Private
->BootFileUri
);
379 if (EFI_ERROR (Status
)) {
380 DEBUG ((EFI_D_ERROR
, "HttpBootDhcp6ExtractUriInfo: %r.\n", Status
));
381 if (Status
== EFI_INVALID_PARAMETER
) {
382 AsciiPrint ("\n Error: Invalid URI address.\n");
383 } else if (Status
== EFI_ACCESS_DENIED
) {
384 AsciiPrint ("\n Error: Access forbidden, only HTTPS connection is allowed.\n");
390 // Set the Local station address to IP layer.
392 Status
= HttpBootSetIp6Address (Private
);
393 if (EFI_ERROR (Status
)) {
398 // Register the IPv6 gateway address to the network device.
400 Status
= HttpBootSetIp6Gateway (Private
);
401 if (EFI_ERROR (Status
)) {
405 if ((SelectOffer
->OfferType
== HttpOfferTypeDhcpNameUriDns
) ||
406 (SelectOffer
->OfferType
== HttpOfferTypeDhcpDns
) ||
407 (SelectOffer
->OfferType
== HttpOfferTypeDhcpIpUriDns
)) {
408 Option
= SelectOffer
->OptList
[HTTP_BOOT_DHCP6_IDX_DNS_SERVER
];
409 ASSERT (Option
!= NULL
);
412 // Record the Dns Server address list.
414 Private
->DnsServerCount
= HTONS (Option
->OpLen
) / sizeof (EFI_IPv6_ADDRESS
);
416 Private
->DnsServerIp
= AllocateZeroPool (Private
->DnsServerCount
* sizeof (EFI_IP_ADDRESS
));
417 if (Private
->DnsServerIp
== NULL
) {
418 return EFI_OUT_OF_RESOURCES
;
421 for (DnsServerIndex
= 0; DnsServerIndex
< Private
->DnsServerCount
; DnsServerIndex
++) {
422 CopyMem (&(Private
->DnsServerIp
[DnsServerIndex
].v6
), &(((EFI_IPv6_ADDRESS
*) Option
->Data
)[DnsServerIndex
]), sizeof (EFI_IPv6_ADDRESS
));
426 // Configure the default DNS server if server assigned.
428 Status
= HttpBootSetIp6Dns (
430 HTONS (Option
->OpLen
),
433 if (EFI_ERROR (Status
)) {
439 // Extract the HTTP server Ip from URL. This is used to Check route table
440 // whether can send message to HTTP Server Ip through the GateWay.
442 Status
= HttpUrlGetIp6 (
443 Private
->BootFileUri
,
444 Private
->BootFileUriParser
,
448 if (EFI_ERROR (Status
)) {
450 // The Http server address is expressed by Name Ip, so perform DNS resolution
452 Status
= HttpUrlGetHostName (
453 Private
->BootFileUri
,
454 Private
->BootFileUriParser
,
457 if (EFI_ERROR (Status
)) {
461 HostNameSize
= AsciiStrSize (HostName
);
462 HostNameStr
= AllocateZeroPool (HostNameSize
* sizeof (CHAR16
));
463 if (HostNameStr
== NULL
) {
464 Status
= EFI_OUT_OF_RESOURCES
;
468 AsciiStrToUnicodeStrS (HostName
, HostNameStr
, HostNameSize
);
470 if (HostName
!= NULL
) {
474 Status
= HttpBootDns (Private
, HostNameStr
, &IpAddr
);
475 FreePool (HostNameStr
);
476 if (EFI_ERROR (Status
)) {
481 CopyMem (&Private
->ServerIp
.v6
, &IpAddr
, sizeof (EFI_IPv6_ADDRESS
));
484 // Extract the port from URL, and use default HTTP port 80 if not provided.
486 Status
= HttpUrlGetPort (
487 Private
->BootFileUri
,
488 Private
->BootFileUriParser
,
491 if (EFI_ERROR (Status
) || Private
->Port
== 0) {
496 // All boot informations are valid here.
500 // Update the device path to include the boot resource information.
502 Status
= HttpBootUpdateDevicePath (Private
);
503 if (EFI_ERROR (Status
)) {
510 if (Private
->DnsServerIp
!= NULL
) {
511 FreePool (Private
->DnsServerIp
);
512 Private
->DnsServerIp
= NULL
;
520 Discover all the boot information for boot file.
522 @param[in, out] Private The pointer to the driver's private data.
524 @retval EFI_SUCCESS Successfully obtained all the boot information .
525 @retval Others Failed to retrieve the boot information.
529 HttpBootDiscoverBootInfo (
530 IN OUT HTTP_BOOT_PRIVATE_DATA
*Private
536 // Start D.O.R.A/S.A.R.R exchange to acquire station ip address and
537 // other Http boot information.
539 Status
= HttpBootDhcp (Private
);
540 if (EFI_ERROR (Status
)) {
544 if (!Private
->UsingIpv6
) {
545 Status
= HttpBootDhcp4ExtractUriInfo (Private
);
547 Status
= HttpBootDhcp6ExtractUriInfo (Private
);
554 HttpIo Callback function which will be invoked when specified HTTP_IO_CALLBACK_EVENT happened.
556 @param[in] EventType Indicate the Event type that occurs in the current callback.
557 @param[in] Message HTTP message which will be send to, or just received from HTTP server.
558 @param[in] Context The Callback Context pointer.
560 @retval EFI_SUCCESS Tells the HttpIo to continue the HTTP process.
561 @retval Others Tells the HttpIo to abort the current HTTP process.
565 HttpBootHttpIoCallback (
566 IN HTTP_IO_CALLBACK_EVENT EventType
,
567 IN EFI_HTTP_MESSAGE
*Message
,
571 HTTP_BOOT_PRIVATE_DATA
*Private
;
573 Private
= (HTTP_BOOT_PRIVATE_DATA
*) Context
;
574 if (Private
->HttpBootCallback
!= NULL
) {
575 Status
= Private
->HttpBootCallback
->Callback (
576 Private
->HttpBootCallback
,
577 EventType
== HttpIoRequest
? HttpBootHttpRequest
: HttpBootHttpResponse
,
578 EventType
== HttpIoRequest
? FALSE
: TRUE
,
579 sizeof (EFI_HTTP_MESSAGE
),
588 Create a HttpIo instance for the file download.
590 @param[in] Private The pointer to the driver's private data.
592 @retval EFI_SUCCESS Successfully created.
593 @retval Others Failed to create HttpIo.
597 HttpBootCreateHttpIo (
598 IN HTTP_BOOT_PRIVATE_DATA
*Private
601 HTTP_IO_CONFIG_DATA ConfigData
;
603 EFI_HANDLE ImageHandle
;
605 ASSERT (Private
!= NULL
);
607 ZeroMem (&ConfigData
, sizeof (HTTP_IO_CONFIG_DATA
));
608 if (!Private
->UsingIpv6
) {
609 ConfigData
.Config4
.HttpVersion
= HttpVersion11
;
610 ConfigData
.Config4
.RequestTimeOut
= HTTP_BOOT_REQUEST_TIMEOUT
;
611 IP4_COPY_ADDRESS (&ConfigData
.Config4
.LocalIp
, &Private
->StationIp
.v4
);
612 IP4_COPY_ADDRESS (&ConfigData
.Config4
.SubnetMask
, &Private
->SubnetMask
.v4
);
613 ImageHandle
= Private
->Ip4Nic
->ImageHandle
;
615 ConfigData
.Config6
.HttpVersion
= HttpVersion11
;
616 ConfigData
.Config6
.RequestTimeOut
= HTTP_BOOT_REQUEST_TIMEOUT
;
617 IP6_COPY_ADDRESS (&ConfigData
.Config6
.LocalIp
, &Private
->StationIp
.v6
);
618 ImageHandle
= Private
->Ip6Nic
->ImageHandle
;
621 Status
= HttpIoCreateIo (
624 Private
->UsingIpv6
? IP_VERSION_6
: IP_VERSION_4
,
626 HttpBootHttpIoCallback
,
630 if (EFI_ERROR (Status
)) {
634 Private
->HttpCreated
= TRUE
;
639 Release all the resource of a cache item.
641 @param[in] Cache The pointer to the cache item.
646 IN HTTP_BOOT_CACHE_CONTENT
*Cache
651 LIST_ENTRY
*NextEntry
;
652 HTTP_BOOT_ENTITY_DATA
*EntityData
;
656 // Free the request data
658 if (Cache
->RequestData
!= NULL
) {
659 if (Cache
->RequestData
->Url
!= NULL
) {
660 FreePool (Cache
->RequestData
->Url
);
662 FreePool (Cache
->RequestData
);
666 // Free the response header
668 if (Cache
->ResponseData
!= NULL
) {
669 if (Cache
->ResponseData
->Headers
!= NULL
) {
670 for (Index
= 0; Index
< Cache
->ResponseData
->HeaderCount
; Index
++) {
671 FreePool (Cache
->ResponseData
->Headers
[Index
].FieldName
);
672 FreePool (Cache
->ResponseData
->Headers
[Index
].FieldValue
);
674 FreePool (Cache
->ResponseData
->Headers
);
679 // Free the response body
681 NET_LIST_FOR_EACH_SAFE (Entry
, NextEntry
, &Cache
->EntityDataList
) {
682 EntityData
= NET_LIST_USER_STRUCT (Entry
, HTTP_BOOT_ENTITY_DATA
, Link
);
683 if (EntityData
->Block
!= NULL
) {
684 FreePool (EntityData
->Block
);
686 RemoveEntryList (&EntityData
->Link
);
687 FreePool (EntityData
);
695 Clean up all cached data.
697 @param[in] Private The pointer to the driver's private data.
701 HttpBootFreeCacheList (
702 IN HTTP_BOOT_PRIVATE_DATA
*Private
706 LIST_ENTRY
*NextEntry
;
707 HTTP_BOOT_CACHE_CONTENT
*Cache
;
709 NET_LIST_FOR_EACH_SAFE (Entry
, NextEntry
, &Private
->CacheList
) {
710 Cache
= NET_LIST_USER_STRUCT (Entry
, HTTP_BOOT_CACHE_CONTENT
, Link
);
711 RemoveEntryList (&Cache
->Link
);
712 HttpBootFreeCache (Cache
);
717 Get the file content from cached data.
719 @param[in] Private The pointer to the driver's private data.
720 @param[in] Uri Uri of the file to be retrieved from cache.
721 @param[in, out] BufferSize On input the size of Buffer in bytes. On output with a return
722 code of EFI_SUCCESS, the amount of data transferred to
723 Buffer. On output with a return code of EFI_BUFFER_TOO_SMALL,
724 the size of Buffer required to retrieve the requested file.
725 @param[out] Buffer The memory buffer to transfer the file to. IF Buffer is NULL,
726 then the size of the requested file is returned in
728 @param[out] ImageType The image type of the downloaded file.
730 @retval EFI_SUCCESS Successfully created.
731 @retval Others Failed to create HttpIo.
735 HttpBootGetFileFromCache (
736 IN HTTP_BOOT_PRIVATE_DATA
*Private
,
738 IN OUT UINTN
*BufferSize
,
740 OUT HTTP_BOOT_IMAGE_TYPE
*ImageType
745 HTTP_BOOT_CACHE_CONTENT
*Cache
;
746 HTTP_BOOT_ENTITY_DATA
*EntityData
;
749 if (Uri
== NULL
|| BufferSize
== NULL
|| Buffer
== NULL
|| ImageType
== NULL
) {
750 return EFI_INVALID_PARAMETER
;
753 NET_LIST_FOR_EACH (Entry
, &Private
->CacheList
) {
754 Cache
= NET_LIST_USER_STRUCT (Entry
, HTTP_BOOT_CACHE_CONTENT
, Link
);
756 // Compare the URI to see whether we already have a cache for this file.
758 if ((Cache
->RequestData
!= NULL
) &&
759 (Cache
->RequestData
->Url
!= NULL
) &&
760 (StrCmp (Uri
, Cache
->RequestData
->Url
) == 0)) {
762 // Hit in cache, record image type.
764 *ImageType
= Cache
->ImageType
;
767 // Check buffer size.
769 if (*BufferSize
< Cache
->EntityLength
) {
770 *BufferSize
= Cache
->EntityLength
;
771 return EFI_BUFFER_TOO_SMALL
;
775 // Fill data to buffer.
778 NET_LIST_FOR_EACH (Entry2
, &Cache
->EntityDataList
) {
779 EntityData
= NET_LIST_USER_STRUCT (Entry2
, HTTP_BOOT_ENTITY_DATA
, Link
);
780 if (*BufferSize
> CopyedSize
) {
783 EntityData
->DataStart
,
784 MIN (EntityData
->DataLength
, *BufferSize
- CopyedSize
)
786 CopyedSize
+= MIN (EntityData
->DataLength
, *BufferSize
- CopyedSize
);
789 *BufferSize
= CopyedSize
;
794 return EFI_NOT_FOUND
;
798 A callback function to intercept events during message parser.
800 This function will be invoked during HttpParseMessageBody() with various events type. An error
801 return status of the callback function will cause the HttpParseMessageBody() aborted.
803 @param[in] EventType Event type of this callback call.
804 @param[in] Data A pointer to data buffer.
805 @param[in] Length Length in bytes of the Data.
806 @param[in] Context Callback context set by HttpInitMsgParser().
808 @retval EFI_SUCCESS Continue to parser the message body.
809 @retval Others Abort the parse.
814 HttpBootGetBootFileCallback (
815 IN HTTP_BODY_PARSE_EVENT EventType
,
821 HTTP_BOOT_CALLBACK_DATA
*CallbackData
;
822 HTTP_BOOT_ENTITY_DATA
*NewEntityData
;
824 EFI_HTTP_BOOT_CALLBACK_PROTOCOL
*HttpBootCallback
;
827 // We only care about the entity data.
829 if (EventType
!= BodyParseEventOnData
) {
833 CallbackData
= (HTTP_BOOT_CALLBACK_DATA
*) Context
;
834 HttpBootCallback
= CallbackData
->Private
->HttpBootCallback
;
835 if (HttpBootCallback
!= NULL
) {
836 Status
= HttpBootCallback
->Callback (
838 HttpBootHttpEntityBody
,
843 if (EFI_ERROR (Status
)) {
848 // Copy data if caller has provided a buffer.
850 if (CallbackData
->BufferSize
> CallbackData
->CopyedSize
) {
852 CallbackData
->Buffer
+ CallbackData
->CopyedSize
,
854 MIN (Length
, CallbackData
->BufferSize
- CallbackData
->CopyedSize
)
856 CallbackData
->CopyedSize
+= MIN (Length
, CallbackData
->BufferSize
- CallbackData
->CopyedSize
);
860 // The caller doesn't provide a buffer, save the block into cache list.
862 if (CallbackData
->Cache
!= NULL
) {
863 NewEntityData
= AllocatePool (sizeof (HTTP_BOOT_ENTITY_DATA
));
864 if (NewEntityData
== NULL
) {
865 return EFI_OUT_OF_RESOURCES
;
867 if (CallbackData
->NewBlock
) {
868 NewEntityData
->Block
= CallbackData
->Block
;
869 CallbackData
->Block
= NULL
;
871 NewEntityData
->DataLength
= Length
;
872 NewEntityData
->DataStart
= (UINT8
*) Data
;
873 InsertTailList (&CallbackData
->Cache
->EntityDataList
, &NewEntityData
->Link
);
879 This function download the boot file by using UEFI HTTP protocol.
881 @param[in] Private The pointer to the driver's private data.
882 @param[in] HeaderOnly Only request the response header, it could save a lot of time if
883 the caller only want to know the size of the requested file.
884 @param[in, out] BufferSize On input the size of Buffer in bytes. On output with a return
885 code of EFI_SUCCESS, the amount of data transferred to
886 Buffer. On output with a return code of EFI_BUFFER_TOO_SMALL,
887 the size of Buffer required to retrieve the requested file.
888 @param[out] Buffer The memory buffer to transfer the file to. IF Buffer is NULL,
889 then the size of the requested file is returned in
891 @param[out] ImageType The image type of the downloaded file.
893 @retval EFI_SUCCESS The file was loaded.
894 @retval EFI_INVALID_PARAMETER BufferSize is NULL or Buffer Size is not NULL but Buffer is NULL.
895 @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources
896 @retval EFI_BUFFER_TOO_SMALL The BufferSize is too small to read the current directory entry.
897 BufferSize has been updated with the size needed to complete
899 @retval Others Unexpected error happened.
903 HttpBootGetBootFile (
904 IN HTTP_BOOT_PRIVATE_DATA
*Private
,
905 IN BOOLEAN HeaderOnly
,
906 IN OUT UINTN
*BufferSize
,
908 OUT HTTP_BOOT_IMAGE_TYPE
*ImageType
912 EFI_HTTP_STATUS_CODE StatusCode
;
914 EFI_HTTP_REQUEST_DATA
*RequestData
;
915 HTTP_IO_RESPONSE_DATA
*ResponseData
;
916 HTTP_IO_RESPONSE_DATA ResponseBody
;
918 HTTP_IO_HEADER
*HttpIoHeader
;
920 HTTP_BOOT_CALLBACK_DATA Context
;
922 HTTP_BOOT_CACHE_CONTENT
*Cache
;
926 BOOLEAN IdentityMode
;
929 ASSERT (Private
!= NULL
);
930 ASSERT (Private
->HttpCreated
);
932 if (BufferSize
== NULL
|| ImageType
== NULL
) {
933 return EFI_INVALID_PARAMETER
;
936 if (*BufferSize
!= 0 && Buffer
== NULL
) {
937 return EFI_INVALID_PARAMETER
;
941 // First, check whether we already cached the requested Uri.
943 UrlSize
= AsciiStrSize (Private
->BootFileUri
);
944 Url
= AllocatePool (UrlSize
* sizeof (CHAR16
));
946 return EFI_OUT_OF_RESOURCES
;
948 AsciiStrToUnicodeStrS (Private
->BootFileUri
, Url
, UrlSize
);
949 if (!HeaderOnly
&& Buffer
!= NULL
) {
950 Status
= HttpBootGetFileFromCache (Private
, Url
, BufferSize
, Buffer
, ImageType
);
951 if (Status
!= EFI_NOT_FOUND
) {
958 // Not found in cache, try to download it through HTTP.
962 // 1. Create a temp cache item for the requested URI if caller doesn't provide buffer.
965 if ((!HeaderOnly
) && (*BufferSize
== 0)) {
966 Cache
= AllocateZeroPool (sizeof (HTTP_BOOT_CACHE_CONTENT
));
968 Status
= EFI_OUT_OF_RESOURCES
;
971 Cache
->ImageType
= ImageTypeMax
;
972 InitializeListHead (&Cache
->EntityDataList
);
976 // 2. Send HTTP request message.
980 // 2.1 Build HTTP header for the request, 3 header is needed to download a boot file:
985 HttpIoHeader
= HttpBootCreateHeader (3);
986 if (HttpIoHeader
== NULL
) {
987 Status
= EFI_OUT_OF_RESOURCES
;
992 // Add HTTP header field 1: Host
995 Status
= HttpUrlGetHostName (
996 Private
->BootFileUri
,
997 Private
->BootFileUriParser
,
1000 if (EFI_ERROR (Status
)) {
1003 Status
= HttpBootSetHeader (
1008 FreePool (HostName
);
1009 if (EFI_ERROR (Status
)) {
1014 // Add HTTP header field 2: Accept
1016 Status
= HttpBootSetHeader (
1021 if (EFI_ERROR (Status
)) {
1026 // Add HTTP header field 3: User-Agent
1028 Status
= HttpBootSetHeader (
1030 HTTP_HEADER_USER_AGENT
,
1031 HTTP_USER_AGENT_EFI_HTTP_BOOT
1033 if (EFI_ERROR (Status
)) {
1038 // 2.2 Build the rest of HTTP request info.
1040 RequestData
= AllocatePool (sizeof (EFI_HTTP_REQUEST_DATA
));
1041 if (RequestData
== NULL
) {
1042 Status
= EFI_OUT_OF_RESOURCES
;
1045 RequestData
->Method
= HeaderOnly
? HttpMethodHead
: HttpMethodGet
;
1046 RequestData
->Url
= Url
;
1049 // 2.3 Record the request info in a temp cache item.
1051 if (Cache
!= NULL
) {
1052 Cache
->RequestData
= RequestData
;
1056 // 2.4 Send out the request to HTTP server.
1058 HttpIo
= &Private
->HttpIo
;
1059 Status
= HttpIoSendRequest (
1062 HttpIoHeader
->HeaderCount
,
1063 HttpIoHeader
->Headers
,
1067 if (EFI_ERROR (Status
)) {
1072 // 3. Receive HTTP response message.
1076 // 3.1 First step, use zero BodyLength to only receive the response headers.
1078 ResponseData
= AllocateZeroPool (sizeof(HTTP_IO_RESPONSE_DATA
));
1079 if (ResponseData
== NULL
) {
1080 Status
= EFI_OUT_OF_RESOURCES
;
1083 Status
= HttpIoRecvResponse (
1088 if (EFI_ERROR (Status
) || EFI_ERROR (ResponseData
->Status
)) {
1089 if (EFI_ERROR (ResponseData
->Status
)) {
1090 StatusCode
= HttpIo
->RspToken
.Message
->Data
.Response
->StatusCode
;
1091 HttpBootPrintErrorMessage (StatusCode
);
1092 Status
= ResponseData
->Status
;
1098 // Check the image type according to server's response.
1100 Status
= HttpBootCheckImageType (
1101 Private
->BootFileUri
,
1102 Private
->BootFileUriParser
,
1103 ResponseData
->HeaderCount
,
1104 ResponseData
->Headers
,
1107 if (EFI_ERROR (Status
)) {
1112 // 3.2 Cache the response header.
1114 if (Cache
!= NULL
) {
1115 Cache
->ResponseData
= ResponseData
;
1116 Cache
->ImageType
= *ImageType
;
1120 // 3.3 Init a message-body parser from the header information.
1123 Context
.NewBlock
= FALSE
;
1124 Context
.Block
= NULL
;
1125 Context
.CopyedSize
= 0;
1126 Context
.Buffer
= Buffer
;
1127 Context
.BufferSize
= *BufferSize
;
1128 Context
.Cache
= Cache
;
1129 Context
.Private
= Private
;
1130 Status
= HttpInitMsgParser (
1131 HeaderOnly
? HttpMethodHead
: HttpMethodGet
,
1132 ResponseData
->Response
.StatusCode
,
1133 ResponseData
->HeaderCount
,
1134 ResponseData
->Headers
,
1135 HttpBootGetBootFileCallback
,
1139 if (EFI_ERROR (Status
)) {
1144 // 3.4 Continue to receive and parse message-body if needed.
1149 // 3.4.1, check whether we are in identity transfer-coding.
1152 Status
= HttpGetEntityLength (Parser
, &ContentLength
);
1153 if (!EFI_ERROR (Status
)) {
1154 IdentityMode
= TRUE
;
1156 IdentityMode
= FALSE
;
1160 // 3.4.2, start the message-body download, the identity and chunked transfer-coding
1161 // is handled in different path here.
1163 ZeroMem (&ResponseBody
, sizeof (HTTP_IO_RESPONSE_DATA
));
1166 // In identity transfer-coding there is no need to parse the message body,
1167 // just download the message body to the user provided buffer directly.
1170 while (ReceivedSize
< ContentLength
) {
1171 ResponseBody
.Body
= (CHAR8
*) Buffer
+ ReceivedSize
;
1172 ResponseBody
.BodyLength
= *BufferSize
- ReceivedSize
;
1173 Status
= HttpIoRecvResponse (
1178 if (EFI_ERROR (Status
) || EFI_ERROR (ResponseBody
.Status
)) {
1179 if (EFI_ERROR (ResponseBody
.Status
)) {
1180 Status
= ResponseBody
.Status
;
1184 ReceivedSize
+= ResponseBody
.BodyLength
;
1185 if (Private
->HttpBootCallback
!= NULL
) {
1186 Status
= Private
->HttpBootCallback
->Callback (
1187 Private
->HttpBootCallback
,
1188 HttpBootHttpEntityBody
,
1190 (UINT32
)ResponseBody
.BodyLength
,
1193 if (EFI_ERROR (Status
)) {
1200 // In "chunked" transfer-coding mode, so we need to parse the received
1201 // data to get the real entity content.
1204 while (!HttpIsMessageComplete (Parser
)) {
1206 // Allocate a buffer in Block to hold the message-body.
1207 // If caller provides a buffer, this Block will be reused in every HttpIoRecvResponse().
1208 // Otherwise a buffer, the buffer in Block will be cached and we should allocate a new before
1209 // every HttpIoRecvResponse().
1211 if (Block
== NULL
|| Context
.BufferSize
== 0) {
1212 Block
= AllocatePool (HTTP_BOOT_BLOCK_SIZE
);
1213 if (Block
== NULL
) {
1214 Status
= EFI_OUT_OF_RESOURCES
;
1217 Context
.NewBlock
= TRUE
;
1218 Context
.Block
= Block
;
1220 Context
.NewBlock
= FALSE
;
1223 ResponseBody
.Body
= (CHAR8
*) Block
;
1224 ResponseBody
.BodyLength
= HTTP_BOOT_BLOCK_SIZE
;
1225 Status
= HttpIoRecvResponse (
1230 if (EFI_ERROR (Status
) || EFI_ERROR (ResponseBody
.Status
)) {
1231 if (EFI_ERROR (ResponseBody
.Status
)) {
1232 Status
= ResponseBody
.Status
;
1238 // Parse the new received block of the message-body, the block will be saved in cache.
1240 Status
= HttpParseMessageBody (
1242 ResponseBody
.BodyLength
,
1245 if (EFI_ERROR (Status
)) {
1253 // 3.5 Message-body receive & parse is completed, we should be able to get the file size now.
1255 Status
= HttpGetEntityLength (Parser
, &ContentLength
);
1256 if (EFI_ERROR (Status
)) {
1260 if (*BufferSize
< ContentLength
) {
1261 Status
= EFI_BUFFER_TOO_SMALL
;
1263 Status
= EFI_SUCCESS
;
1265 *BufferSize
= ContentLength
;
1268 // 4. Save the cache item to driver's cache list and return.
1270 if (Cache
!= NULL
) {
1271 Cache
->EntityLength
= ContentLength
;
1272 InsertTailList (&Private
->CacheList
, &Cache
->Link
);
1275 if (Parser
!= NULL
) {
1276 HttpFreeMsgParser (Parser
);
1282 if (Parser
!= NULL
) {
1283 HttpFreeMsgParser (Parser
);
1285 if (Context
.Block
!= NULL
) {
1286 FreePool (Context
.Block
);
1288 HttpBootFreeCache (Cache
);
1291 if (ResponseData
!= NULL
) {
1292 FreePool (ResponseData
);
1295 if (RequestData
!= NULL
) {
1296 FreePool (RequestData
);
1299 HttpBootFreeHeader (HttpIoHeader
);
1301 if (Cache
!= NULL
) {