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 }