NetworkPkg/HttpBootDxe: Add HTTP Boot Callback protocol support.
[mirror_edk2.git] / NetworkPkg / HttpBootDxe / HttpBootImpl.c
1 /** @file
2 The implementation of EFI_LOAD_FILE_PROTOCOL for UEFI HTTP boot.
3
4 Copyright (c) 2015 - 2016, 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 goto ON_EXIT;
331 }
332 }
333
334 if (!Private->HttpCreated) {
335 //
336 // Create HTTP child.
337 //
338 Status = HttpBootCreateHttpIo (Private);
339 if (EFI_ERROR (Status)) {
340 goto ON_EXIT;
341 }
342 }
343
344 if (Private->BootFileSize == 0) {
345 //
346 // Discover the information about the bootfile if we haven't.
347 //
348
349 //
350 // Try to use HTTP HEAD method.
351 //
352 Status = HttpBootGetBootFile (
353 Private,
354 TRUE,
355 &Private->BootFileSize,
356 NULL,
357 &Private->ImageType
358 );
359 if (EFI_ERROR (Status) && Status != EFI_BUFFER_TOO_SMALL) {
360 //
361 // Failed to get file size by HEAD method, may be trunked encoding, try HTTP GET method.
362 //
363 ASSERT (Private->BootFileSize == 0);
364 Status = HttpBootGetBootFile (
365 Private,
366 FALSE,
367 &Private->BootFileSize,
368 NULL,
369 &Private->ImageType
370 );
371 if (EFI_ERROR (Status) && Status != EFI_BUFFER_TOO_SMALL) {
372 goto ON_EXIT;
373 }
374 }
375 }
376
377 if (*BufferSize < Private->BootFileSize) {
378 *BufferSize = Private->BootFileSize;
379 *ImageType = Private->ImageType;
380 Status = EFI_BUFFER_TOO_SMALL;
381 goto ON_EXIT;
382 }
383
384 //
385 // Load the boot file into Buffer
386 //
387 Status = HttpBootGetBootFile (
388 Private,
389 FALSE,
390 BufferSize,
391 Buffer,
392 ImageType
393 );
394
395 ON_EXIT:
396 HttpBootUninstallCallback (Private);
397 return Status;
398 }
399
400 /**
401 Disable the use of UEFI HTTP boot function.
402
403 @param[in] Private The pointer to the driver's private data.
404
405 @retval EFI_SUCCESS HTTP boot was successfully disabled.
406 @retval EFI_NOT_STARTED The driver is already in stopped state.
407 @retval EFI_INVALID_PARAMETER Private is NULL.
408 @retval Others Unexpected error when stop the function.
409
410 **/
411 EFI_STATUS
412 HttpBootStop (
413 IN HTTP_BOOT_PRIVATE_DATA *Private
414 )
415 {
416 UINTN Index;
417
418 if (Private == NULL) {
419 return EFI_INVALID_PARAMETER;
420 }
421
422 if (!Private->Started) {
423 return EFI_NOT_STARTED;
424 }
425
426 if (Private->HttpCreated) {
427 HttpIoDestroyIo (&Private->HttpIo);
428 Private->HttpCreated = FALSE;
429 }
430
431 Private->Started = FALSE;
432 ZeroMem (&Private->StationIp, sizeof (EFI_IP_ADDRESS));
433 ZeroMem (&Private->SubnetMask, sizeof (EFI_IP_ADDRESS));
434 ZeroMem (&Private->GatewayIp, sizeof (EFI_IP_ADDRESS));
435 Private->Port = 0;
436 Private->BootFileUri = NULL;
437 Private->BootFileUriParser = NULL;
438 Private->BootFileSize = 0;
439 Private->SelectIndex = 0;
440 Private->SelectProxyType = HttpOfferTypeMax;
441
442 if (!Private->UsingIpv6) {
443 //
444 // Stop and release the DHCP4 child.
445 //
446 Private->Dhcp4->Stop (Private->Dhcp4);
447 Private->Dhcp4->Configure (Private->Dhcp4, NULL);
448
449 for (Index = 0; Index < HTTP_BOOT_OFFER_MAX_NUM; Index++) {
450 if (Private->OfferBuffer[Index].Dhcp4.UriParser) {
451 HttpUrlFreeParser (Private->OfferBuffer[Index].Dhcp4.UriParser);
452 }
453 }
454 } else {
455 //
456 // Stop and release the DHCP6 child.
457 //
458 Private->Dhcp6->Stop (Private->Dhcp6);
459 Private->Dhcp6->Configure (Private->Dhcp6, NULL);
460
461 for (Index = 0; Index < HTTP_BOOT_OFFER_MAX_NUM; Index++) {
462 if (Private->OfferBuffer[Index].Dhcp6.UriParser) {
463 HttpUrlFreeParser (Private->OfferBuffer[Index].Dhcp6.UriParser);
464 }
465 }
466 }
467
468 if (Private->FilePathUri!= NULL) {
469 FreePool (Private->FilePathUri);
470 HttpUrlFreeParser (Private->FilePathUriParser);
471 Private->FilePathUri = NULL;
472 Private->FilePathUriParser = NULL;
473 }
474
475 ZeroMem (Private->OfferBuffer, sizeof (Private->OfferBuffer));
476 Private->OfferNum = 0;
477 ZeroMem (Private->OfferCount, sizeof (Private->OfferCount));
478 ZeroMem (Private->OfferIndex, sizeof (Private->OfferIndex));
479
480 HttpBootFreeCacheList (Private);
481
482 return EFI_SUCCESS;
483 }
484
485 /**
486 Causes the driver to load a specified file.
487
488 @param This Protocol instance pointer.
489 @param FilePath The device specific path of the file to load.
490 @param BootPolicy If TRUE, indicates that the request originates from the
491 boot manager is attempting to load FilePath as a boot
492 selection. If FALSE, then FilePath must match as exact file
493 to be loaded.
494 @param BufferSize On input the size of Buffer in bytes. On output with a return
495 code of EFI_SUCCESS, the amount of data transferred to
496 Buffer. On output with a return code of EFI_BUFFER_TOO_SMALL,
497 the size of Buffer required to retrieve the requested file.
498 @param Buffer The memory buffer to transfer the file to. IF Buffer is NULL,
499 then the size of the requested file is returned in
500 BufferSize.
501
502 @retval EFI_SUCCESS The file was loaded.
503 @retval EFI_UNSUPPORTED The device does not support the provided BootPolicy
504 @retval EFI_INVALID_PARAMETER FilePath is not a valid device path, or
505 BufferSize is NULL.
506 @retval EFI_NO_MEDIA No medium was present to load the file.
507 @retval EFI_DEVICE_ERROR The file was not loaded due to a device error.
508 @retval EFI_NO_RESPONSE The remote system did not respond.
509 @retval EFI_NOT_FOUND The file was not found.
510 @retval EFI_ABORTED The file load process was manually cancelled.
511 @retval EFI_BUFFER_TOO_SMALL The BufferSize is too small to read the current directory entry.
512 BufferSize has been updated with the size needed to complete
513 the request.
514
515 **/
516 EFI_STATUS
517 EFIAPI
518 HttpBootDxeLoadFile (
519 IN EFI_LOAD_FILE_PROTOCOL *This,
520 IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
521 IN BOOLEAN BootPolicy,
522 IN OUT UINTN *BufferSize,
523 IN VOID *Buffer OPTIONAL
524 )
525 {
526 HTTP_BOOT_PRIVATE_DATA *Private;
527 HTTP_BOOT_VIRTUAL_NIC *VirtualNic;
528 BOOLEAN MediaPresent;
529 BOOLEAN UsingIpv6;
530 EFI_STATUS Status;
531 HTTP_BOOT_IMAGE_TYPE ImageType;
532
533 if (This == NULL || BufferSize == NULL || FilePath == NULL) {
534 return EFI_INVALID_PARAMETER;
535 }
536
537 //
538 // Only support BootPolicy
539 //
540 if (!BootPolicy) {
541 return EFI_UNSUPPORTED;
542 }
543
544 VirtualNic = HTTP_BOOT_VIRTUAL_NIC_FROM_LOADFILE (This);
545 Private = VirtualNic->Private;
546
547 //
548 // Check media status before HTTP boot start
549 //
550 MediaPresent = TRUE;
551 NetLibDetectMedia (Private->Controller, &MediaPresent);
552 if (!MediaPresent) {
553 return EFI_NO_MEDIA;
554 }
555
556 //
557 // Check whether the virtual nic is using IPv6 or not.
558 //
559 UsingIpv6 = FALSE;
560 if (VirtualNic == Private->Ip6Nic) {
561 UsingIpv6 = TRUE;
562 }
563
564 //
565 // Initialize HTTP boot.
566 //
567 Status = HttpBootStart (Private, UsingIpv6, FilePath);
568 if (Status != EFI_SUCCESS && Status != EFI_ALREADY_STARTED) {
569 return Status;
570 }
571
572 //
573 // Load the boot file.
574 //
575 ImageType = ImageTypeMax;
576 Status = HttpBootLoadFile (Private, BufferSize, Buffer, &ImageType);
577 if (EFI_ERROR (Status)) {
578 if (Status == EFI_BUFFER_TOO_SMALL && (ImageType == ImageTypeVirtualCd || ImageType == ImageTypeVirtualDisk)) {
579 Status = EFI_WARN_FILE_SYSTEM;
580 } else if (Status != EFI_BUFFER_TOO_SMALL) {
581 HttpBootStop (Private);
582 }
583 return Status;
584 }
585
586 //
587 // Register the RAM Disk to the system if needed.
588 //
589 if (ImageType == ImageTypeVirtualCd || ImageType == ImageTypeVirtualDisk) {
590 Status = HttpBootRegisterRamDisk (Private, *BufferSize, Buffer, ImageType);
591 if (!EFI_ERROR (Status)) {
592 Status = EFI_WARN_FILE_SYSTEM;
593 }
594 }
595
596 //
597 // Stop the HTTP Boot service after the boot image is downloaded.
598 //
599 HttpBootStop (Private);
600 return Status;
601 }
602
603 ///
604 /// Load File Protocol instance
605 ///
606 GLOBAL_REMOVE_IF_UNREFERENCED
607 EFI_LOAD_FILE_PROTOCOL gHttpBootDxeLoadFile = {
608 HttpBootDxeLoadFile
609 };
610
611 /**
612 Callback function that is invoked when the HTTP Boot driver is about to transmit or has received a
613 packet.
614
615 This function is invoked when the HTTP Boot driver is about to transmit or has received packet.
616 Parameters DataType and Received specify the type of event and the format of the buffer pointed
617 to by Data. Due to the polling nature of UEFI device drivers, this callback function should not
618 execute for more than 5 ms.
619 The returned status code determines the behavior of the HTTP Boot driver.
620
621 @param[in] This Pointer to the EFI_HTTP_BOOT_CALLBACK_PROTOCOL instance.
622 @param[in] DataType The event that occurs in the current state.
623 @param[in] Received TRUE if the callback is being invoked due to a receive event.
624 FALSE if the callback is being invoked due to a transmit event.
625 @param[in] DataLength The length in bytes of the buffer pointed to by Data.
626 @param[in] Data A pointer to the buffer of data, the data type is specified by
627 DataType.
628
629 @retval EFI_SUCCESS Tells the HTTP Boot driver to continue the HTTP Boot process.
630 @retval EFI_ABORTED Tells the HTTP Boot driver to abort the current HTTP Boot process.
631 **/
632 EFI_STATUS
633 HttpBootCallback (
634 IN EFI_HTTP_BOOT_CALLBACK_PROTOCOL *This,
635 IN EFI_HTTP_BOOT_CALLBACK_DATA_TYPE DataType,
636 IN BOOLEAN Received,
637 IN UINT32 DataLength,
638 IN VOID *Data OPTIONAL
639 )
640 {
641 EFI_HTTP_MESSAGE *HttpMessage;
642 EFI_HTTP_HEADER *HttpHeader;
643 HTTP_BOOT_PRIVATE_DATA *Private;
644 UINT32 Percentage;
645
646 Private = HTTP_BOOT_PRIVATE_DATA_FROM_CALLBACK_PROTOCOL(This);
647
648 switch (DataType) {
649 case HttpBootDhcp4:
650 case HttpBootDhcp6:
651 Print (L".");
652 break;
653
654 case HttpBootHttpRequest:
655 if (Data != NULL) {
656 HttpMessage = (EFI_HTTP_MESSAGE *) Data;
657 if (HttpMessage->Data.Request->Method == HttpMethodGet &&
658 HttpMessage->Data.Request->Url != NULL) {
659 Print (L"\n URI: %s\n", HttpMessage->Data.Request->Url);
660 }
661 }
662 break;
663
664 case HttpBootHttpResponse:
665 if (Data != NULL) {
666 HttpMessage = (EFI_HTTP_MESSAGE *) Data;
667 HttpHeader = HttpFindHeader (
668 HttpMessage->HeaderCount,
669 HttpMessage->Headers,
670 HTTP_HEADER_CONTENT_LENGTH
671 );
672 if (HttpHeader != NULL) {
673 Private->FileSize = AsciiStrDecimalToUintn (HttpHeader->FieldValue);
674 Private->ReceivedSize = 0;
675 Private->Percentage = 0;
676 }
677 }
678 break;
679
680 case HttpBootHttpEntityBody:
681 if (DataLength != 0) {
682 if (Private->FileSize != 0) {
683 //
684 // We already know the file size, print in percentage format.
685 //
686 if (Private->ReceivedSize == 0) {
687 Print (L" File Size: %lu\n", Private->FileSize);
688 }
689 Private->ReceivedSize += DataLength;
690 Percentage = (UINT32) DivU64x64Remainder (MultU64x32 (Private->ReceivedSize, 100), Private->FileSize, NULL);
691 if (Private->Percentage != Percentage) {
692 Private->Percentage = Percentage;
693 Print (L"\r Downloading...%d%%", Percentage);
694 }
695 } else {
696 //
697 // In some case we couldn't get the file size from the HTTP header, so we
698 // just print the downloaded file size.
699 //
700 Private->ReceivedSize += DataLength;
701 Print (L"\r Downloading...%lu Bytes", Private->ReceivedSize);
702 }
703 }
704 break;
705
706 default:
707 break;
708 };
709
710 return EFI_SUCCESS;
711 }
712
713 ///
714 /// HTTP Boot Callback Protocol instance
715 ///
716 GLOBAL_REMOVE_IF_UNREFERENCED
717 EFI_HTTP_BOOT_CALLBACK_PROTOCOL gHttpBootDxeHttpBootCallback = {
718 HttpBootCallback
719 };