5ca013c92df21f91a0e635a1549349c632c5a766
[mirror_edk2.git] / SecurityPkg / VariableAuthenticated / SecureBootConfigDxe / SecureBootConfigFileExplorer.c
1 /** @file
2 Internal file explorer functions for SecureBoot configuration module.
3
4 Copyright (c) 2012 - 2014, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include "SecureBootConfigImpl.h"
16
17 ///
18 /// File system selection menu
19 ///
20 SECUREBOOT_MENU_OPTION FsOptionMenu = {
21 SECUREBOOT_MENU_OPTION_SIGNATURE,
22 {NULL},
23 0
24 };
25
26 ///
27 /// Files and sub-directories in current directory menu
28 ///
29 SECUREBOOT_MENU_OPTION DirectoryMenu = {
30 SECUREBOOT_MENU_OPTION_SIGNATURE,
31 {NULL},
32 0
33 };
34
35 VOID *mStartOpCodeHandle = NULL;
36 VOID *mEndOpCodeHandle = NULL;
37 EFI_IFR_GUID_LABEL *mStartLabel = NULL;
38 EFI_IFR_GUID_LABEL *mEndLabel = NULL;
39
40 /**
41 Duplicate a string.
42
43 @param[in] Src The source string.
44
45 @return A new string which is duplicated copy of the source,
46 or NULL if there is not enough memory.
47
48 **/
49 CHAR16 *
50 StrDuplicate (
51 IN CHAR16 *Src
52 )
53 {
54 CHAR16 *Dest;
55 UINTN Size;
56
57 Size = StrSize (Src);
58 Dest = AllocateZeroPool (Size);
59 ASSERT (Dest != NULL);
60 if (Dest != NULL) {
61 CopyMem (Dest, Src, Size);
62 }
63
64 return Dest;
65 }
66
67 /**
68 Helper function called as part of the code needed to allocate
69 the proper sized buffer for various EFI interfaces.
70
71 @param[in, out] Status Current status
72 @param[in, out] Buffer Current allocated buffer, or NULL
73 @param[in] BufferSize Current buffer size needed
74
75 @retval TRUE If the buffer was reallocated and the caller
76 should try the API again.
77 @retval FALSE The caller should not call this function again.
78
79 **/
80 BOOLEAN
81 GrowBuffer (
82 IN OUT EFI_STATUS *Status,
83 IN OUT VOID **Buffer,
84 IN UINTN BufferSize
85 )
86 {
87 BOOLEAN TryAgain;
88
89 //
90 // If this is an initial request, buffer will be null with a new buffer size
91 //
92 if ((*Buffer == NULL) && (BufferSize != 0)) {
93 *Status = EFI_BUFFER_TOO_SMALL;
94 }
95 //
96 // If the status code is "buffer too small", resize the buffer
97 //
98 TryAgain = FALSE;
99 if (*Status == EFI_BUFFER_TOO_SMALL) {
100
101 if (*Buffer != NULL) {
102 FreePool (*Buffer);
103 }
104
105 *Buffer = AllocateZeroPool (BufferSize);
106
107 if (*Buffer != NULL) {
108 TryAgain = TRUE;
109 } else {
110 *Status = EFI_OUT_OF_RESOURCES;
111 }
112 }
113 //
114 // If there's an error, free the buffer
115 //
116 if (!TryAgain && EFI_ERROR (*Status) && (*Buffer != NULL)) {
117 FreePool (*Buffer);
118 *Buffer = NULL;
119 }
120
121 return TryAgain;
122 }
123
124 /**
125 Append file name to existing file name, and allocate a new buffer
126 to hold the appended result.
127
128 @param[in] Str1 The existing file name
129 @param[in] Str2 The file name to be appended
130
131 @return A new string with appended result.
132
133 **/
134 CHAR16 *
135 AppendFileName (
136 IN CHAR16 *Str1,
137 IN CHAR16 *Str2
138 )
139 {
140 UINTN Size1;
141 UINTN Size2;
142 CHAR16 *Str;
143 CHAR16 *TmpStr;
144 CHAR16 *Ptr;
145 CHAR16 *LastSlash;
146
147 Size1 = StrSize (Str1);
148 Size2 = StrSize (Str2);
149 Str = AllocateZeroPool (Size1 + Size2 + sizeof (CHAR16));
150 ASSERT (Str != NULL);
151
152 TmpStr = AllocateZeroPool (Size1 + Size2 + sizeof (CHAR16));
153 ASSERT (TmpStr != NULL);
154
155 StrCat (Str, Str1);
156 if (!((*Str == '\\') && (*(Str + 1) == 0))) {
157 StrCat (Str, L"\\");
158 }
159
160 StrCat (Str, Str2);
161
162 Ptr = Str;
163 LastSlash = Str;
164 while (*Ptr != 0) {
165 if (*Ptr == '\\' && *(Ptr + 1) == '.' && *(Ptr + 2) == '.' && *(Ptr + 3) == L'\\') {
166 //
167 // Convert "\Name\..\" to "\"
168 // DO NOT convert the .. if it is at the end of the string. This will
169 // break the .. behavior in changing directories.
170 //
171
172 //
173 // Use TmpStr as a backup, as StrCpy in BaseLib does not handle copy of two strings
174 // that overlap.
175 //
176 StrCpy (TmpStr, Ptr + 3);
177 StrCpy (LastSlash, TmpStr);
178 Ptr = LastSlash;
179 } else if (*Ptr == '\\' && *(Ptr + 1) == '.' && *(Ptr + 2) == '\\') {
180 //
181 // Convert a "\.\" to a "\"
182 //
183
184 //
185 // Use TmpStr as a backup, as StrCpy in BaseLib does not handle copy of two strings
186 // that overlap.
187 //
188 StrCpy (TmpStr, Ptr + 2);
189 StrCpy (Ptr, TmpStr);
190 Ptr = LastSlash;
191 } else if (*Ptr == '\\') {
192 LastSlash = Ptr;
193 }
194
195 Ptr++;
196 }
197
198 FreePool (TmpStr);
199
200 return Str;
201 }
202
203 /**
204 Create a SECUREBOOT_MENU_ENTRY, and stores it in a buffer allocated from the pool.
205
206 @return The new menu entry or NULL of error happens.
207
208 **/
209 SECUREBOOT_MENU_ENTRY *
210 CreateMenuEntry (
211 VOID
212 )
213 {
214 SECUREBOOT_MENU_ENTRY *MenuEntry;
215 UINTN ContextSize;
216
217 //
218 // Create new menu entry
219 //
220 MenuEntry = AllocateZeroPool (sizeof (SECUREBOOT_MENU_ENTRY));
221 if (MenuEntry == NULL) {
222 return NULL;
223 }
224
225 ContextSize = sizeof (SECUREBOOT_FILE_CONTEXT);
226 MenuEntry->FileContext = AllocateZeroPool (ContextSize);
227 if (MenuEntry->FileContext == NULL) {
228 FreePool (MenuEntry);
229 return NULL;
230 }
231
232 MenuEntry->Signature = SECUREBOOT_MENU_ENTRY_SIGNATURE;
233
234 return MenuEntry;
235 }
236
237 /**
238 Get Menu Entry from the Menu Entry List by MenuNumber.
239
240 If MenuNumber is great or equal to the number of Menu
241 Entry in the list, then ASSERT.
242
243 @param[in] MenuOption The Menu Entry List to read the menu entry.
244 @param[in] MenuNumber The index of Menu Entry.
245
246 @return The Menu Entry.
247
248 **/
249 SECUREBOOT_MENU_ENTRY *
250 GetMenuEntry (
251 IN SECUREBOOT_MENU_OPTION *MenuOption,
252 IN UINTN MenuNumber
253 )
254 {
255 SECUREBOOT_MENU_ENTRY *NewMenuEntry;
256 UINTN Index;
257 LIST_ENTRY *List;
258
259 ASSERT (MenuNumber < MenuOption->MenuNumber);
260
261 List = MenuOption->Head.ForwardLink;
262 for (Index = 0; Index < MenuNumber; Index++) {
263 List = List->ForwardLink;
264 }
265
266 NewMenuEntry = CR (List, SECUREBOOT_MENU_ENTRY, Link, SECUREBOOT_MENU_ENTRY_SIGNATURE);
267
268 return NewMenuEntry;
269 }
270
271 /**
272 Create string tokens for a menu from its help strings and display strings.
273
274 @param[in] HiiHandle Hii Handle of the package to be updated.
275 @param[in] MenuOption The Menu whose string tokens need to be created.
276
277 **/
278 VOID
279 CreateMenuStringToken (
280 IN EFI_HII_HANDLE HiiHandle,
281 IN SECUREBOOT_MENU_OPTION *MenuOption
282 )
283 {
284 SECUREBOOT_MENU_ENTRY *NewMenuEntry;
285 UINTN Index;
286
287 for (Index = 0; Index < MenuOption->MenuNumber; Index++) {
288 NewMenuEntry = GetMenuEntry (MenuOption, Index);
289
290 NewMenuEntry->DisplayStringToken = HiiSetString (
291 HiiHandle,
292 0,
293 NewMenuEntry->DisplayString,
294 NULL
295 );
296
297 if (NewMenuEntry->HelpString == NULL) {
298 NewMenuEntry->HelpStringToken = NewMenuEntry->DisplayStringToken;
299 } else {
300 NewMenuEntry->HelpStringToken = HiiSetString (
301 HiiHandle,
302 0,
303 NewMenuEntry->HelpString,
304 NULL
305 );
306 }
307 }
308 }
309
310 /**
311 Free up all resources allocated for a SECUREBOOT_MENU_ENTRY.
312
313 @param[in, out] MenuEntry A pointer to SECUREBOOT_MENU_ENTRY.
314
315 **/
316 VOID
317 DestroyMenuEntry (
318 IN OUT SECUREBOOT_MENU_ENTRY *MenuEntry
319 )
320 {
321 SECUREBOOT_FILE_CONTEXT *FileContext;
322
323
324 FileContext = (SECUREBOOT_FILE_CONTEXT *) MenuEntry->FileContext;
325
326 if (!FileContext->IsRoot && FileContext->DevicePath != NULL) {
327 FreePool (FileContext->DevicePath);
328 } else {
329 if (FileContext->FHandle != NULL) {
330 FileContext->FHandle->Close (FileContext->FHandle);
331 }
332 }
333
334 if (FileContext->FileName != NULL) {
335 FreePool (FileContext->FileName);
336 }
337 if (FileContext->Info != NULL) {
338 FreePool (FileContext->Info);
339 }
340
341 FreePool (FileContext);
342
343 if (MenuEntry->DisplayString != NULL) {
344 FreePool (MenuEntry->DisplayString);
345 }
346 if (MenuEntry->HelpString != NULL) {
347 FreePool (MenuEntry->HelpString);
348 }
349
350 FreePool (MenuEntry);
351 }
352
353 /**
354 Free resources allocated in Allocate Rountine.
355
356 @param[in, out] MenuOption Menu to be freed
357
358 **/
359 VOID
360 FreeMenu (
361 IN OUT SECUREBOOT_MENU_OPTION *MenuOption
362 )
363 {
364 SECUREBOOT_MENU_ENTRY *MenuEntry;
365 while (!IsListEmpty (&MenuOption->Head)) {
366 MenuEntry = CR (
367 MenuOption->Head.ForwardLink,
368 SECUREBOOT_MENU_ENTRY,
369 Link,
370 SECUREBOOT_MENU_ENTRY_SIGNATURE
371 );
372 RemoveEntryList (&MenuEntry->Link);
373 DestroyMenuEntry (MenuEntry);
374 }
375 MenuOption->MenuNumber = 0;
376 }
377
378 /**
379 This function gets the file information from an open file descriptor, and stores it
380 in a buffer allocated from pool.
381
382 @param[in] FHand File Handle.
383
384 @return A pointer to a buffer with file information or NULL is returned
385
386 **/
387 EFI_FILE_INFO *
388 FileInfo (
389 IN EFI_FILE_HANDLE FHand
390 )
391 {
392 EFI_STATUS Status;
393 EFI_FILE_INFO *Buffer;
394 UINTN BufferSize;
395
396 //
397 // Initialize for GrowBuffer loop
398 //
399 Buffer = NULL;
400 BufferSize = SIZE_OF_EFI_FILE_INFO + 200;
401
402 //
403 // Call the real function
404 //
405 while (GrowBuffer (&Status, (VOID **) &Buffer, BufferSize)) {
406 Status = FHand->GetInfo (
407 FHand,
408 &gEfiFileInfoGuid,
409 &BufferSize,
410 Buffer
411 );
412 }
413
414 return Buffer;
415 }
416
417 /**
418 This function gets the file system information from an open file descriptor,
419 and stores it in a buffer allocated from pool.
420
421 @param[in] FHand The file handle.
422
423 @return A pointer to a buffer with file information.
424 @retval NULL is returned if failed to get Vaolume Label Info.
425
426 **/
427 EFI_FILE_SYSTEM_VOLUME_LABEL *
428 FileSystemVolumeLabelInfo (
429 IN EFI_FILE_HANDLE FHand
430 )
431 {
432 EFI_STATUS Status;
433 EFI_FILE_SYSTEM_VOLUME_LABEL *Buffer;
434 UINTN BufferSize;
435 //
436 // Initialize for GrowBuffer loop
437 //
438 Buffer = NULL;
439 BufferSize = SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL + 200;
440
441 //
442 // Call the real function
443 //
444 while (GrowBuffer (&Status, (VOID **) &Buffer, BufferSize)) {
445 Status = FHand->GetInfo (
446 FHand,
447 &gEfiFileSystemVolumeLabelInfoIdGuid,
448 &BufferSize,
449 Buffer
450 );
451 }
452
453 return Buffer;
454 }
455
456 /**
457 This function will open a file or directory referenced by DevicePath.
458
459 This function opens a file with the open mode according to the file path. The
460 Attributes is valid only for EFI_FILE_MODE_CREATE.
461
462 @param[in, out] FilePath On input, the device path to the file.
463 On output, the remaining device path.
464 @param[out] FileHandle Pointer to the file handle.
465 @param[in] OpenMode The mode to open the file with.
466 @param[in] Attributes The file's file attributes.
467
468 @retval EFI_SUCCESS The information was set.
469 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
470 @retval EFI_UNSUPPORTED Could not open the file path.
471 @retval EFI_NOT_FOUND The specified file could not be found on the
472 device or the file system could not be found on
473 the device.
474 @retval EFI_NO_MEDIA The device has no medium.
475 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the
476 medium is no longer supported.
477 @retval EFI_DEVICE_ERROR The device reported an error.
478 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
479 @retval EFI_WRITE_PROTECTED The file or medium is write protected.
480 @retval EFI_ACCESS_DENIED The file was opened read only.
481 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the
482 file.
483 @retval EFI_VOLUME_FULL The volume is full.
484 **/
485 EFI_STATUS
486 EFIAPI
487 OpenFileByDevicePath(
488 IN OUT EFI_DEVICE_PATH_PROTOCOL **FilePath,
489 OUT EFI_FILE_HANDLE *FileHandle,
490 IN UINT64 OpenMode,
491 IN UINT64 Attributes
492 )
493 {
494 EFI_STATUS Status;
495 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *EfiSimpleFileSystemProtocol;
496 EFI_FILE_PROTOCOL *Handle1;
497 EFI_FILE_PROTOCOL *Handle2;
498 EFI_HANDLE DeviceHandle;
499
500 if ((FilePath == NULL || FileHandle == NULL)) {
501 return EFI_INVALID_PARAMETER;
502 }
503
504 Status = gBS->LocateDevicePath (
505 &gEfiSimpleFileSystemProtocolGuid,
506 FilePath,
507 &DeviceHandle
508 );
509 if (EFI_ERROR (Status)) {
510 return Status;
511 }
512
513 Status = gBS->OpenProtocol(
514 DeviceHandle,
515 &gEfiSimpleFileSystemProtocolGuid,
516 (VOID**)&EfiSimpleFileSystemProtocol,
517 gImageHandle,
518 NULL,
519 EFI_OPEN_PROTOCOL_GET_PROTOCOL
520 );
521 if (EFI_ERROR (Status)) {
522 return Status;
523 }
524
525 Status = EfiSimpleFileSystemProtocol->OpenVolume(EfiSimpleFileSystemProtocol, &Handle1);
526 if (EFI_ERROR (Status)) {
527 FileHandle = NULL;
528 return Status;
529 }
530
531 //
532 // go down directories one node at a time.
533 //
534 while (!IsDevicePathEnd (*FilePath)) {
535 //
536 // For file system access each node should be a file path component
537 //
538 if (DevicePathType (*FilePath) != MEDIA_DEVICE_PATH ||
539 DevicePathSubType (*FilePath) != MEDIA_FILEPATH_DP
540 ) {
541 FileHandle = NULL;
542 return (EFI_INVALID_PARAMETER);
543 }
544 //
545 // Open this file path node
546 //
547 Handle2 = Handle1;
548 Handle1 = NULL;
549
550 //
551 // Try to test opening an existing file
552 //
553 Status = Handle2->Open (
554 Handle2,
555 &Handle1,
556 ((FILEPATH_DEVICE_PATH*)*FilePath)->PathName,
557 OpenMode &~EFI_FILE_MODE_CREATE,
558 0
559 );
560
561 //
562 // see if the error was that it needs to be created
563 //
564 if ((EFI_ERROR (Status)) && (OpenMode != (OpenMode &~EFI_FILE_MODE_CREATE))) {
565 Status = Handle2->Open (
566 Handle2,
567 &Handle1,
568 ((FILEPATH_DEVICE_PATH*)*FilePath)->PathName,
569 OpenMode,
570 Attributes
571 );
572 }
573 //
574 // Close the last node
575 //
576 Handle2->Close (Handle2);
577
578 if (EFI_ERROR(Status)) {
579 return (Status);
580 }
581
582 //
583 // Get the next node
584 //
585 *FilePath = NextDevicePathNode (*FilePath);
586 }
587
588 //
589 // This is a weak spot since if the undefined SHELL_FILE_HANDLE format changes this must change also!
590 //
591 *FileHandle = (VOID*)Handle1;
592 return EFI_SUCCESS;
593 }
594
595 /**
596 Function opens and returns a file handle to the root directory of a volume.
597
598 @param[in] DeviceHandle A handle for a device
599
600 @return A valid file handle or NULL if error happens.
601
602 **/
603 EFI_FILE_HANDLE
604 OpenRoot (
605 IN EFI_HANDLE DeviceHandle
606 )
607 {
608 EFI_STATUS Status;
609 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Volume;
610 EFI_FILE_HANDLE File;
611
612 File = NULL;
613
614 //
615 // File the file system interface to the device
616 //
617 Status = gBS->HandleProtocol (
618 DeviceHandle,
619 &gEfiSimpleFileSystemProtocolGuid,
620 (VOID *) &Volume
621 );
622
623 //
624 // Open the root directory of the volume
625 //
626 if (!EFI_ERROR (Status)) {
627 Status = Volume->OpenVolume (
628 Volume,
629 &File
630 );
631 }
632 //
633 // Done
634 //
635 return EFI_ERROR (Status) ? NULL : File;
636 }
637
638 /**
639 This function builds the FsOptionMenu list which records all
640 available file system in the system. They include all instances
641 of EFI_SIMPLE_FILE_SYSTEM_PROTOCOL, all instances of EFI_LOAD_FILE_SYSTEM
642 and all type of legacy boot device.
643
644 @retval EFI_SUCCESS Success find the file system
645 @retval EFI_OUT_OF_RESOURCES Can not create menu entry
646
647 **/
648 EFI_STATUS
649 FindFileSystem (
650 VOID
651 )
652 {
653 UINTN NoBlkIoHandles;
654 UINTN NoSimpleFsHandles;
655 EFI_HANDLE *BlkIoHandle;
656 EFI_HANDLE *SimpleFsHandle;
657 UINT16 *VolumeLabel;
658 EFI_BLOCK_IO_PROTOCOL *BlkIo;
659 UINTN Index;
660 EFI_STATUS Status;
661 SECUREBOOT_MENU_ENTRY *MenuEntry;
662 SECUREBOOT_FILE_CONTEXT *FileContext;
663 UINT16 *TempStr;
664 UINTN OptionNumber;
665 VOID *Buffer;
666
667 BOOLEAN RemovableMedia;
668
669
670 NoSimpleFsHandles = 0;
671 OptionNumber = 0;
672 InitializeListHead (&FsOptionMenu.Head);
673
674 //
675 // Locate Handles that support BlockIo protocol
676 //
677 Status = gBS->LocateHandleBuffer (
678 ByProtocol,
679 &gEfiBlockIoProtocolGuid,
680 NULL,
681 &NoBlkIoHandles,
682 &BlkIoHandle
683 );
684 if (!EFI_ERROR (Status)) {
685
686 for (Index = 0; Index < NoBlkIoHandles; Index++) {
687 Status = gBS->HandleProtocol (
688 BlkIoHandle[Index],
689 &gEfiBlockIoProtocolGuid,
690 (VOID **) &BlkIo
691 );
692
693 if (EFI_ERROR (Status)) {
694 continue;
695 }
696
697 //
698 // Issue a dummy read to trigger reinstall of BlockIo protocol for removable media
699 //
700 if (BlkIo->Media->RemovableMedia) {
701 Buffer = AllocateZeroPool (BlkIo->Media->BlockSize);
702 if (NULL == Buffer) {
703 FreePool (BlkIoHandle);
704 return EFI_OUT_OF_RESOURCES;
705 }
706
707 BlkIo->ReadBlocks (
708 BlkIo,
709 BlkIo->Media->MediaId,
710 0,
711 BlkIo->Media->BlockSize,
712 Buffer
713 );
714 FreePool (Buffer);
715 }
716 }
717 FreePool (BlkIoHandle);
718 }
719
720 //
721 // Locate Handles that support Simple File System protocol
722 //
723 Status = gBS->LocateHandleBuffer (
724 ByProtocol,
725 &gEfiSimpleFileSystemProtocolGuid,
726 NULL,
727 &NoSimpleFsHandles,
728 &SimpleFsHandle
729 );
730 if (!EFI_ERROR (Status)) {
731 //
732 // Find all the instances of the File System prototocol
733 //
734 for (Index = 0; Index < NoSimpleFsHandles; Index++) {
735 Status = gBS->HandleProtocol (
736 SimpleFsHandle[Index],
737 &gEfiBlockIoProtocolGuid,
738 (VOID **) &BlkIo
739 );
740 if (EFI_ERROR (Status)) {
741 //
742 // If no block IO exists assume it's NOT a removable media
743 //
744 RemovableMedia = FALSE;
745 } else {
746 //
747 // If block IO exists check to see if it's remobable media
748 //
749 RemovableMedia = BlkIo->Media->RemovableMedia;
750 }
751
752 //
753 // Allocate pool for this instance.
754 //
755 MenuEntry = CreateMenuEntry ();
756 if (NULL == MenuEntry) {
757 FreePool (SimpleFsHandle);
758 return EFI_OUT_OF_RESOURCES;
759 }
760
761 FileContext = (SECUREBOOT_FILE_CONTEXT *) MenuEntry->FileContext;
762
763 FileContext->Handle = SimpleFsHandle[Index];
764 MenuEntry->OptionNumber = Index;
765 FileContext->FHandle = OpenRoot (FileContext->Handle);
766 if (FileContext->FHandle == NULL) {
767 DestroyMenuEntry (MenuEntry);
768 continue;
769 }
770
771 MenuEntry->HelpString = DevicePathToStr (DevicePathFromHandle (FileContext->Handle));
772 FileContext->Info = FileSystemVolumeLabelInfo (FileContext->FHandle);
773 FileContext->FileName = StrDuplicate (L"\\");
774 FileContext->DevicePath = FileDevicePath (
775 FileContext->Handle,
776 FileContext->FileName
777 );
778 FileContext->IsDir = TRUE;
779 FileContext->IsRoot = TRUE;
780 FileContext->IsRemovableMedia = RemovableMedia;
781 FileContext->IsLoadFile = FALSE;
782
783 //
784 // Get current file system's Volume Label
785 //
786 if (FileContext->Info == NULL) {
787 VolumeLabel = L"NO FILE SYSTEM INFO";
788 } else {
789 if (FileContext->Info->VolumeLabel == NULL) {
790 VolumeLabel = L"NULL VOLUME LABEL";
791 } else {
792 VolumeLabel = FileContext->Info->VolumeLabel;
793 if (*VolumeLabel == 0x0000) {
794 VolumeLabel = L"NO VOLUME LABEL";
795 }
796 }
797 }
798
799 TempStr = MenuEntry->HelpString;
800 MenuEntry->DisplayString = AllocateZeroPool (MAX_CHAR);
801 ASSERT (MenuEntry->DisplayString != NULL);
802 UnicodeSPrint (
803 MenuEntry->DisplayString,
804 MAX_CHAR,
805 L"%s, [%s]",
806 VolumeLabel,
807 TempStr
808 );
809 OptionNumber++;
810 InsertTailList (&FsOptionMenu.Head, &MenuEntry->Link);
811 }
812 }
813
814 if (NoSimpleFsHandles != 0) {
815 FreePool (SimpleFsHandle);
816 }
817
818 //
819 // Remember how many file system options are here
820 //
821 FsOptionMenu.MenuNumber = OptionNumber;
822 return EFI_SUCCESS;
823 }
824
825
826 /**
827 Find files under the current directory. All files and sub-directories
828 in current directory will be stored in DirectoryMenu for future use.
829
830 @param[in] MenuEntry The Menu Entry.
831
832 @retval EFI_SUCCESS Get files from current dir successfully.
833 @return Other Can't get files from current dir.
834
835 **/
836 EFI_STATUS
837 FindFiles (
838 IN SECUREBOOT_MENU_ENTRY *MenuEntry
839 )
840 {
841 EFI_FILE_HANDLE NewDir;
842 EFI_FILE_HANDLE Dir;
843 EFI_FILE_INFO *DirInfo;
844 UINTN BufferSize;
845 UINTN DirBufferSize;
846 SECUREBOOT_MENU_ENTRY *NewMenuEntry;
847 SECUREBOOT_FILE_CONTEXT *FileContext;
848 SECUREBOOT_FILE_CONTEXT *NewFileContext;
849 UINTN Pass;
850 EFI_STATUS Status;
851 UINTN OptionNumber;
852
853 FileContext = (SECUREBOOT_FILE_CONTEXT *) MenuEntry->FileContext;
854 Dir = FileContext->FHandle;
855 OptionNumber = 0;
856 //
857 // Open current directory to get files from it
858 //
859 Status = Dir->Open (
860 Dir,
861 &NewDir,
862 FileContext->FileName,
863 EFI_FILE_READ_ONLY,
864 0
865 );
866 if (!FileContext->IsRoot) {
867 Dir->Close (Dir);
868 }
869
870 if (EFI_ERROR (Status)) {
871 return Status;
872 }
873
874 DirInfo = FileInfo (NewDir);
875 if (DirInfo == NULL) {
876 return EFI_NOT_FOUND;
877 }
878
879 if ((DirInfo->Attribute & EFI_FILE_DIRECTORY) == 0) {
880 return EFI_INVALID_PARAMETER;
881 }
882
883 FileContext->DevicePath = FileDevicePath (
884 FileContext->Handle,
885 FileContext->FileName
886 );
887
888 DirBufferSize = sizeof (EFI_FILE_INFO) + 1024;
889 DirInfo = AllocateZeroPool (DirBufferSize);
890 if (DirInfo == NULL) {
891 return EFI_OUT_OF_RESOURCES;
892 }
893
894 //
895 // Get all files in current directory
896 // Pass 1 to get Directories
897 // Pass 2 to get files that are EFI images
898 //
899 for (Pass = 1; Pass <= 2; Pass++) {
900 NewDir->SetPosition (NewDir, 0);
901 for (;;) {
902 BufferSize = DirBufferSize;
903 Status = NewDir->Read (NewDir, &BufferSize, DirInfo);
904 if (EFI_ERROR (Status) || BufferSize == 0) {
905 break;
906 }
907
908 if (((DirInfo->Attribute & EFI_FILE_DIRECTORY) != 0 && Pass == 2) ||
909 ((DirInfo->Attribute & EFI_FILE_DIRECTORY) == 0 && Pass == 1)
910 ) {
911 //
912 // Pass 1 is for Directories
913 // Pass 2 is for file names
914 //
915 continue;
916 }
917
918 NewMenuEntry = CreateMenuEntry ();
919 if (NULL == NewMenuEntry) {
920 return EFI_OUT_OF_RESOURCES;
921 }
922
923 NewFileContext = (SECUREBOOT_FILE_CONTEXT *) NewMenuEntry->FileContext;
924 NewFileContext->Handle = FileContext->Handle;
925 NewFileContext->FileName = AppendFileName (
926 FileContext->FileName,
927 DirInfo->FileName
928 );
929 NewFileContext->FHandle = NewDir;
930 NewFileContext->DevicePath = FileDevicePath (
931 NewFileContext->Handle,
932 NewFileContext->FileName
933 );
934 NewMenuEntry->HelpString = NULL;
935
936 NewFileContext->IsDir = (BOOLEAN) ((DirInfo->Attribute & EFI_FILE_DIRECTORY) == EFI_FILE_DIRECTORY);
937 if (NewFileContext->IsDir) {
938 BufferSize = StrLen (DirInfo->FileName) * 2 + 6;
939 NewMenuEntry->DisplayString = AllocateZeroPool (BufferSize);
940
941 UnicodeSPrint (
942 NewMenuEntry->DisplayString,
943 BufferSize,
944 L"<%s>",
945 DirInfo->FileName
946 );
947
948 } else {
949 NewMenuEntry->DisplayString = StrDuplicate (DirInfo->FileName);
950 }
951
952 NewFileContext->IsRoot = FALSE;
953 NewFileContext->IsLoadFile = FALSE;
954 NewFileContext->IsRemovableMedia = FALSE;
955
956 NewMenuEntry->OptionNumber = OptionNumber;
957 OptionNumber++;
958 InsertTailList (&DirectoryMenu.Head, &NewMenuEntry->Link);
959 }
960 }
961
962 DirectoryMenu.MenuNumber = OptionNumber;
963 FreePool (DirInfo);
964 return EFI_SUCCESS;
965 }
966
967 /**
968 Refresh the global UpdateData structure.
969
970 **/
971 VOID
972 RefreshUpdateData (
973 VOID
974 )
975 {
976 //
977 // Free current updated date
978 //
979 if (mStartOpCodeHandle != NULL) {
980 HiiFreeOpCodeHandle (mStartOpCodeHandle);
981 }
982
983 //
984 // Create new OpCode Handle
985 //
986 mStartOpCodeHandle = HiiAllocateOpCodeHandle ();
987
988 //
989 // Create Hii Extend Label OpCode as the start opcode
990 //
991 mStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
992 mStartOpCodeHandle,
993 &gEfiIfrTianoGuid,
994 NULL,
995 sizeof (EFI_IFR_GUID_LABEL)
996 );
997 mStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
998 }
999
1000 /**
1001 Update the File Explore page.
1002
1003 @param[in] HiiHandle Hii Handle of the package to be updated.
1004 @param[in] MenuOption The Menu whose string tokens need to be updated.
1005 @param[in] FeCurrentState Current file explorer state.
1006
1007 **/
1008 VOID
1009 UpdateFileExplorePage (
1010 IN EFI_HII_HANDLE HiiHandle,
1011 IN SECUREBOOT_MENU_OPTION *MenuOption,
1012 IN FILE_EXPLORER_STATE FeCurrentState
1013 )
1014 {
1015 UINTN Index;
1016 SECUREBOOT_MENU_ENTRY *NewMenuEntry;
1017 SECUREBOOT_FILE_CONTEXT *NewFileContext;
1018 EFI_FORM_ID FormId;
1019 EFI_FORM_ID FileFormId;
1020
1021 if (FeCurrentState == FileExplorerStateEnrollPkFile) {
1022 FormId = SECUREBOOT_ADD_PK_FILE_FORM_ID;
1023 FileFormId = FORM_FILE_EXPLORER_ID_PK;
1024 } else if (FeCurrentState == FileExplorerStateEnrollKekFile) {
1025 FormId = FORMID_ENROLL_KEK_FORM;
1026 FileFormId = FORM_FILE_EXPLORER_ID_KEK;
1027 } else if (FeCurrentState == FileExplorerStateEnrollSignatureFileToDb) {
1028 FormId = SECUREBOOT_ENROLL_SIGNATURE_TO_DB;
1029 FileFormId = FORM_FILE_EXPLORER_ID_DB;
1030 } else if (FeCurrentState == FileExplorerStateEnrollSignatureFileToDbx) {
1031 FormId = SECUREBOOT_ENROLL_SIGNATURE_TO_DBX;
1032 FileFormId = FORM_FILE_EXPLORER_ID_DBX;
1033 } else if (FeCurrentState == FileExplorerStateEnrollSignatureFileToDbt) {
1034 FormId = SECUREBOOT_ENROLL_SIGNATURE_TO_DBT;
1035 FileFormId = FORM_FILE_EXPLORER_ID_DBT;
1036 } else {
1037 return;
1038 }
1039
1040 NewMenuEntry = NULL;
1041 NewFileContext = NULL;
1042
1043 RefreshUpdateData ();
1044 mStartLabel->Number = FORM_FILE_EXPLORER_ID;
1045
1046 for (Index = 0; Index < MenuOption->MenuNumber; Index++) {
1047 NewMenuEntry = GetMenuEntry (MenuOption, Index);
1048 NewFileContext = (SECUREBOOT_FILE_CONTEXT *) NewMenuEntry->FileContext;
1049
1050 if (NewFileContext->IsDir) {
1051 //
1052 // Create Text opcode for directory.
1053 //
1054 HiiCreateActionOpCode (
1055 mStartOpCodeHandle,
1056 (UINT16) (FILE_OPTION_OFFSET + Index),
1057 NewMenuEntry->DisplayStringToken,
1058 STRING_TOKEN (STR_NULL),
1059 EFI_IFR_FLAG_CALLBACK,
1060 0
1061 );
1062 } else {
1063
1064 //
1065 // Create Goto opcode for file.
1066 //
1067 HiiCreateGotoOpCode (
1068 mStartOpCodeHandle,
1069 FormId,
1070 NewMenuEntry->DisplayStringToken,
1071 STRING_TOKEN (STR_NULL),
1072 EFI_IFR_FLAG_CALLBACK,
1073 (UINT16) (FILE_OPTION_GOTO_OFFSET + Index)
1074 );
1075 }
1076 }
1077
1078 HiiUpdateForm (
1079 HiiHandle,
1080 &gSecureBootConfigFormSetGuid,
1081 FileFormId,
1082 mStartOpCodeHandle, // Label FORM_FILE_EXPLORER_ID
1083 mEndOpCodeHandle // LABEL_END
1084 );
1085 }
1086
1087 /**
1088 Update the file explorer page with the refreshed file system.
1089
1090 @param[in] PrivateData Module private data.
1091 @param[in] KeyValue Key value to identify the type of data to expect.
1092
1093 @retval TRUE Inform the caller to create a callback packet to exit file explorer.
1094 @retval FALSE Indicate that there is no need to exit file explorer.
1095
1096 **/
1097 BOOLEAN
1098 UpdateFileExplorer (
1099 IN SECUREBOOT_CONFIG_PRIVATE_DATA *PrivateData,
1100 IN UINT16 KeyValue
1101 )
1102 {
1103 UINT16 FileOptionMask;
1104 SECUREBOOT_MENU_ENTRY *NewMenuEntry;
1105 SECUREBOOT_FILE_CONTEXT *NewFileContext;
1106 EFI_FORM_ID FormId;
1107 BOOLEAN ExitFileExplorer;
1108 EFI_STATUS Status;
1109 EFI_DEVICE_PATH_PROTOCOL *TmpDevicePath;
1110
1111 NewMenuEntry = NULL;
1112 NewFileContext = NULL;
1113 ExitFileExplorer = FALSE;
1114 FileOptionMask = (UINT16) (FILE_OPTION_MASK & KeyValue);
1115
1116 if (PrivateData->FeDisplayContext == FileExplorerDisplayUnknown) {
1117 //
1118 // First in, display file system.
1119 //
1120 FreeMenu (&FsOptionMenu);
1121 FindFileSystem ();
1122
1123 CreateMenuStringToken (PrivateData->HiiHandle, &FsOptionMenu);
1124 UpdateFileExplorePage (PrivateData->HiiHandle, &FsOptionMenu, PrivateData->FeCurrentState);
1125
1126 PrivateData->FeDisplayContext = FileExplorerDisplayFileSystem;
1127 } else {
1128 if (PrivateData->FeDisplayContext == FileExplorerDisplayFileSystem) {
1129 NewMenuEntry = GetMenuEntry (&FsOptionMenu, FileOptionMask);
1130 } else if (PrivateData->FeDisplayContext == FileExplorerDisplayDirectory) {
1131 NewMenuEntry = GetMenuEntry (&DirectoryMenu, FileOptionMask);
1132 }
1133
1134 NewFileContext = (SECUREBOOT_FILE_CONTEXT *) NewMenuEntry->FileContext;
1135
1136 if (NewFileContext->IsDir ) {
1137 PrivateData->FeDisplayContext = FileExplorerDisplayDirectory;
1138
1139 RemoveEntryList (&NewMenuEntry->Link);
1140 FreeMenu (&DirectoryMenu);
1141 Status = FindFiles (NewMenuEntry);
1142 if (EFI_ERROR (Status)) {
1143 ExitFileExplorer = TRUE;
1144 goto OnExit;
1145 }
1146 CreateMenuStringToken (PrivateData->HiiHandle, &DirectoryMenu);
1147 DestroyMenuEntry (NewMenuEntry);
1148
1149 UpdateFileExplorePage (PrivateData->HiiHandle, &DirectoryMenu, PrivateData->FeCurrentState);
1150
1151 } else {
1152 if (PrivateData->FeCurrentState == FileExplorerStateEnrollPkFile) {
1153 FormId = SECUREBOOT_ADD_PK_FILE_FORM_ID;
1154 } else if (PrivateData->FeCurrentState == FileExplorerStateEnrollKekFile) {
1155 FormId = FORMID_ENROLL_KEK_FORM;
1156 } else if (PrivateData->FeCurrentState == FileExplorerStateEnrollSignatureFileToDb) {
1157 FormId = SECUREBOOT_ENROLL_SIGNATURE_TO_DB;
1158 } else if (PrivateData->FeCurrentState == FileExplorerStateEnrollSignatureFileToDbx) {
1159 FormId = SECUREBOOT_ENROLL_SIGNATURE_TO_DBX;
1160 } else if (PrivateData->FeCurrentState == FileExplorerStateEnrollSignatureFileToDbt) {
1161 FormId = SECUREBOOT_ENROLL_SIGNATURE_TO_DBT;
1162 } else {
1163 return FALSE;
1164 }
1165
1166 PrivateData->MenuEntry = NewMenuEntry;
1167 PrivateData->FileContext->FileName = NewFileContext->FileName;
1168
1169 TmpDevicePath = NewFileContext->DevicePath;
1170 OpenFileByDevicePath (
1171 &TmpDevicePath,
1172 &PrivateData->FileContext->FHandle,
1173 EFI_FILE_MODE_READ,
1174 0
1175 );
1176
1177 //
1178 // Create Subtitle op-code for the display string of the option.
1179 //
1180 RefreshUpdateData ();
1181 mStartLabel->Number = FormId;
1182
1183 HiiCreateSubTitleOpCode (
1184 mStartOpCodeHandle,
1185 NewMenuEntry->DisplayStringToken,
1186 0,
1187 0,
1188 0
1189 );
1190
1191 HiiUpdateForm (
1192 PrivateData->HiiHandle,
1193 &gSecureBootConfigFormSetGuid,
1194 FormId,
1195 mStartOpCodeHandle, // Label FormId
1196 mEndOpCodeHandle // LABEL_END
1197 );
1198 }
1199 }
1200
1201 OnExit:
1202 return ExitFileExplorer;
1203 }
1204
1205 /**
1206 Clean up the dynamic opcode at label and form specified by both LabelId.
1207
1208 @param[in] LabelId It is both the Form ID and Label ID for opcode deletion.
1209 @param[in] PrivateData Module private data.
1210
1211 **/
1212 VOID
1213 CleanUpPage (
1214 IN UINT16 LabelId,
1215 IN SECUREBOOT_CONFIG_PRIVATE_DATA *PrivateData
1216 )
1217 {
1218 RefreshUpdateData ();
1219
1220 //
1221 // Remove all op-codes from dynamic page
1222 //
1223 mStartLabel->Number = LabelId;
1224 HiiUpdateForm (
1225 PrivateData->HiiHandle,
1226 &gSecureBootConfigFormSetGuid,
1227 LabelId,
1228 mStartOpCodeHandle, // Label LabelId
1229 mEndOpCodeHandle // LABEL_END
1230 );
1231 }