MdeModulePkg/Library/FileExplorerLib/FileExplorer.c

   1 /** @file
   2 File explorer related functions.
   3
   4 Copyright (c) 2004 - 2016, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials are licensed and made available under
   6 the terms and conditions of the BSD License that accompanies this distribution.
   7 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
  16 #include "FileExplorer.h"
  17
  18 EFI_GUID FileExplorerGuid       = EFI_FILE_EXPLORE_FORMSET_GUID;
  19
  20 ///
  21 /// File system selection menu
  22 ///
  23 MENU_OPTION      mFsOptionMenu = {
  24   MENU_OPTION_SIGNATURE,
  25   {NULL},
  26   0,
  27   FALSE
  28 };
  29
  30 FILE_EXPLORER_CALLBACK_DATA  gFileExplorerPrivate = {
  31   FILE_EXPLORER_CALLBACK_DATA_SIGNATURE,
  32   NULL,
  33   NULL,
  34   {
  35     LibExtractConfig,
  36     LibRouteConfig,
  37     LibCallback
  38   },
  39   NULL,
  40   &mFsOptionMenu,
  41   0
  42 };
  43
  44 HII_VENDOR_DEVICE_PATH  *gHiiVendorDevicePath;
  45
  46 HII_VENDOR_DEVICE_PATH  FeHiiVendorDevicePath = {
  47   {
  48     {
  49       HARDWARE_DEVICE_PATH,
  50       HW_VENDOR_DP,
  51       {
  52         (UINT8) (sizeof (VENDOR_DEVICE_PATH)),
  53         (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8)
  54       }
  55     },
  56     //
  57     // Will be replace with gEfiCallerIdGuid in code.
  58     //
  59     { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } }
  60   },
  61   {
  62     END_DEVICE_PATH_TYPE,
  63     END_ENTIRE_DEVICE_PATH_SUBTYPE,
  64     {
  65       (UINT8) (END_DEVICE_PATH_LENGTH),
  66       (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8)
  67     }
  68   }
  69 };
  70
  71 VOID                *mLibStartOpCodeHandle = NULL;
  72 VOID                *mLibEndOpCodeHandle = NULL;
  73 EFI_IFR_GUID_LABEL  *mLibStartLabel = NULL;
  74 EFI_IFR_GUID_LABEL  *mLibEndLabel = NULL;
  75
  76 /**
  77   This function allows a caller to extract the current configuration for one
  78   or more named elements from the target driver.
  79
  80
  81   @param This            Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
  82   @param Request         A null-terminated Unicode string in <ConfigRequest> format.
  83   @param Progress        On return, points to a character in the Request string.
  84                          Points to the string's null terminator if request was successful.
  85                          Points to the most recent '&' before the first failing name/value
  86                          pair (or the beginning of the string if the failure is in the
  87                          first name/value pair) if the request was not successful.
  88   @param Results         A null-terminated Unicode string in <ConfigAltResp> format which
  89                          has all values filled in for the names in the Request string.
  90                          String to be allocated by the called function.
  91
  92   @retval  EFI_INVALID_PARAMETER  Request is illegal syntax, or unknown name.
  93   @retval  EFI_NOT_FOUND          Routing data doesn't match any storage in this driver.
  94
  95 **/
  96 EFI_STATUS
  97 EFIAPI
  98 LibExtractConfig (
  99   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
 100   IN  CONST EFI_STRING                       Request,
 101   OUT EFI_STRING                             *Progress,
 102   OUT EFI_STRING                             *Results
 103   )
 104 {
 105   if (Progress == NULL || Results == NULL) {
 106     return EFI_INVALID_PARAMETER;
 107   }
 108
 109   *Progress = Request;
 110   return EFI_NOT_FOUND;
 111 }
 112
 113 /**
 114   This function processes the results of changes in configuration.
 115
 116
 117   @param This            Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
 118   @param Configuration   A null-terminated Unicode string in <ConfigResp> format.
 119   @param Progress        A pointer to a string filled in with the offset of the most
 120                          recent '&' before the first failing name/value pair (or the
 121                          beginning of the string if the failure is in the first
 122                          name/value pair) or the terminating NULL if all was successful.
 123
 124   @retval  EFI_INVALID_PARAMETER  Configuration is NULL.
 125   @retval  EFI_NOT_FOUND          Routing data doesn't match any storage in this driver.
 126
 127 **/
 128 EFI_STATUS
 129 EFIAPI
 130 LibRouteConfig (
 131   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
 132   IN  CONST EFI_STRING                       Configuration,
 133   OUT EFI_STRING                             *Progress
 134   )
 135 {
 136   if (Configuration == NULL || Progress == NULL) {
 137     return EFI_INVALID_PARAMETER;
 138   }
 139
 140   *Progress = Configuration;
 141   return EFI_NOT_FOUND;
 142 }
 143
 144 /**
 145   This function processes the results of changes in configuration.
 146   When user select a interactive opcode, this callback will be triggered.
 147   Based on the Question(QuestionId) that triggers the callback, the corresponding
 148   actions is performed. It handles:
 149
 150   1) Process the axtra action or exit file explorer when user select one file .
 151   2) update of file content if a dir is selected.
 152
 153   @param This            Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL.
 154   @param Action          Specifies the type of action taken by the browser.
 155   @param QuestionId      A unique value which is sent to the original exporting driver
 156                          so that it can identify the type of data to expect.
 157   @param Type            The type of value for the question.
 158   @param Value           A pointer to the data being sent to the original exporting driver.
 159   @param ActionRequest   On return, points to the action requested by the callback function.
 160
 161   @retval  EFI_SUCCESS           The callback successfully handled the action.
 162   @retval  other error           Error occur when parse one directory.
 163 **/
 164 EFI_STATUS
 165 EFIAPI
 166 LibCallback (
 167   IN  CONST EFI_HII_CONFIG_ACCESS_PROTOCOL   *This,
 168   IN  EFI_BROWSER_ACTION                     Action,
 169   IN  EFI_QUESTION_ID                        QuestionId,
 170   IN  UINT8                                  Type,
 171   IN  EFI_IFR_TYPE_VALUE                     *Value,
 172   OUT EFI_BROWSER_ACTION_REQUEST             *ActionRequest
 173   )
 174 {
 175   EFI_STATUS    Status;
 176   BOOLEAN       NeedExit;
 177
 178   NeedExit = TRUE;
 179
 180   if (Action != EFI_BROWSER_ACTION_CHANGING && Action != EFI_BROWSER_ACTION_CHANGED) {
 181     //
 182     // Do nothing for other UEFI Action. Only do call back when data is changed.
 183     //
 184     return EFI_UNSUPPORTED;
 185   }
 186
 187   if (Action == EFI_BROWSER_ACTION_CHANGED) {
 188     if ((Value == NULL) || (ActionRequest == NULL)) {
 189       return EFI_INVALID_PARAMETER;
 190     }
 191
 192     if (QuestionId >= FILE_OPTION_OFFSET) {
 193       LibGetDevicePath(QuestionId);
 194
 195       //
 196       // Process the extra action.
 197       //
 198       if (gFileExplorerPrivate.ChooseHandler != NULL) {
 199         NeedExit = gFileExplorerPrivate.ChooseHandler (gFileExplorerPrivate.RetDevicePath);
 200       }
 201
 202       if (NeedExit) {
 203         *ActionRequest = EFI_BROWSER_ACTION_REQUEST_EXIT;
 204       }
 205     }
 206   } else if (Action == EFI_BROWSER_ACTION_CHANGING) {
 207     if (Value == NULL) {
 208       return EFI_INVALID_PARAMETER;
 209     }
 210
 211     if (QuestionId >= FILE_OPTION_OFFSET) {
 212       Status = LibUpdateFileExplorer (QuestionId);
 213       if (EFI_ERROR (Status)) {
 214         return Status;
 215       }
 216     }
 217   }
 218
 219   return EFI_SUCCESS;
 220 }
 221
 222 /**
 223   Create a menu entry by given menu type.
 224
 225   @retval NULL           If failed to create the menu.
 226   @return the new menu entry.
 227
 228 **/
 229 MENU_ENTRY *
 230 LibCreateMenuEntry (
 231   VOID
 232   )
 233 {
 234   MENU_ENTRY *MenuEntry;
 235
 236   //
 237   // Create new menu entry
 238   //
 239   MenuEntry = AllocateZeroPool (sizeof (MENU_ENTRY));
 240   if (MenuEntry == NULL) {
 241     return NULL;
 242   }
 243
 244   MenuEntry->VariableContext = AllocateZeroPool (sizeof (FILE_CONTEXT));
 245   if (MenuEntry->VariableContext == NULL) {
 246     FreePool (MenuEntry);
 247     return NULL;
 248   }
 249
 250   MenuEntry->Signature        = MENU_ENTRY_SIGNATURE;
 251   return MenuEntry;
 252 }
 253
 254
 255 /**
 256   Get the Menu Entry from the list in Menu Entry List.
 257
 258   If MenuNumber is great or equal to the number of Menu
 259   Entry in the list, then ASSERT.
 260
 261   @param MenuOption      The Menu Entry List to read the menu entry.
 262   @param MenuNumber      The index of Menu Entry.
 263
 264   @return The Menu Entry.
 265
 266 **/
 267 MENU_ENTRY *
 268 LibGetMenuEntry (
 269   MENU_OPTION         *MenuOption,
 270   UINTN               MenuNumber
 271   )
 272 {
 273   MENU_ENTRY      *NewMenuEntry;
 274   UINTN           Index;
 275   LIST_ENTRY      *List;
 276
 277   ASSERT (MenuNumber < MenuOption->MenuNumber);
 278
 279   List = MenuOption->Head.ForwardLink;
 280   for (Index = 0; Index < MenuNumber; Index++) {
 281     List = List->ForwardLink;
 282   }
 283
 284   NewMenuEntry = CR (List, MENU_ENTRY, Link, MENU_ENTRY_SIGNATURE);
 285
 286   return NewMenuEntry;
 287 }
 288
 289 /**
 290   Free up all resource allocated for a BM_MENU_ENTRY.
 291
 292   @param MenuEntry   A pointer to BM_MENU_ENTRY.
 293
 294 **/
 295 VOID
 296 LibDestroyMenuEntry (
 297   MENU_ENTRY         *MenuEntry
 298   )
 299 {
 300   FILE_CONTEXT           *FileContext;
 301
 302   FileContext = (FILE_CONTEXT *) MenuEntry->VariableContext;
 303
 304   if (!FileContext->IsRoot) {
 305     if (FileContext->DevicePath != NULL) {
 306       FreePool (FileContext->DevicePath);
 307     }
 308   } else {
 309     if (FileContext->FileHandle != NULL) {
 310       FileContext->FileHandle->Close (FileContext->FileHandle);
 311     }
 312   }
 313
 314   if (FileContext->FileName != NULL) {
 315     FreePool (FileContext->FileName);
 316   }
 317
 318   FreePool (FileContext);
 319
 320   if (MenuEntry->DisplayString != NULL) {
 321     FreePool (MenuEntry->DisplayString);
 322   }
 323   if (MenuEntry->HelpString != NULL) {
 324     FreePool (MenuEntry->HelpString);
 325   }
 326
 327   FreePool (MenuEntry);
 328 }
 329
 330
 331 /**
 332   Free resources allocated in Allocate Rountine.
 333
 334   @param FreeMenu        Menu to be freed
 335 **/
 336 VOID
 337 LibFreeMenu (
 338   MENU_OPTION        *FreeMenu
 339   )
 340 {
 341   MENU_ENTRY *MenuEntry;
 342   while (!IsListEmpty (&FreeMenu->Head)) {
 343     MenuEntry = CR (
 344                   FreeMenu->Head.ForwardLink,
 345                   MENU_ENTRY,
 346                   Link,
 347                   MENU_ENTRY_SIGNATURE
 348                   );
 349     RemoveEntryList (&MenuEntry->Link);
 350     LibDestroyMenuEntry (MenuEntry);
 351   }
 352   FreeMenu->MenuNumber = 0;
 353 }
 354
 355 /**
 356
 357   Function opens and returns a file handle to the root directory of a volume.
 358
 359   @param DeviceHandle    A handle for a device
 360
 361   @return A valid file handle or NULL is returned
 362
 363 **/
 364 EFI_FILE_HANDLE
 365 LibOpenRoot (
 366   IN EFI_HANDLE                   DeviceHandle
 367   )
 368 {
 369   EFI_STATUS                      Status;
 370   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Volume;
 371   EFI_FILE_HANDLE                 File;
 372
 373   File = NULL;
 374
 375   //
 376   // File the file system interface to the device
 377   //
 378   Status = gBS->HandleProtocol (
 379                   DeviceHandle,
 380                   &gEfiSimpleFileSystemProtocolGuid,
 381                   (VOID *) &Volume
 382                   );
 383
 384   //
 385   // Open the root directory of the volume
 386   //
 387   if (!EFI_ERROR (Status)) {
 388     Status = Volume->OpenVolume (
 389                       Volume,
 390                       &File
 391                       );
 392   }
 393   //
 394   // Done
 395   //
 396   return EFI_ERROR (Status) ? NULL : File;
 397 }
 398
 399 /**
 400   This function converts an input device structure to a Unicode string.
 401
 402   @param DevPath                  A pointer to the device path structure.
 403
 404   @return A new allocated Unicode string that represents the device path.
 405
 406 **/
 407 CHAR16 *
 408 LibDevicePathToStr (
 409   IN EFI_DEVICE_PATH_PROTOCOL     *DevPath
 410   )
 411 {
 412   EFI_STATUS                       Status;
 413   CHAR16                           *ToText;
 414   EFI_DEVICE_PATH_TO_TEXT_PROTOCOL *DevPathToText;
 415
 416   if (DevPath == NULL) {
 417     return NULL;
 418   }
 419
 420   Status = gBS->LocateProtocol (
 421                   &gEfiDevicePathToTextProtocolGuid,
 422                   NULL,
 423                   (VOID **) &DevPathToText
 424                   );
 425   ASSERT_EFI_ERROR (Status);
 426   ToText = DevPathToText->ConvertDevicePathToText (
 427                             DevPath,
 428                             FALSE,
 429                             TRUE
 430                             );
 431   ASSERT (ToText != NULL);
 432
 433   return ToText;
 434 }
 435
 436 /**
 437   Duplicate a string.
 438
 439   @param Src             The source.
 440
 441   @return A new string which is duplicated copy of the source.
 442   @retval NULL If there is not enough memory.
 443
 444 **/
 445 CHAR16 *
 446 LibStrDuplicate (
 447   IN CHAR16   *Src
 448   )
 449 {
 450   CHAR16  *Dest;
 451   UINTN   Size;
 452
 453   Size  = StrSize (Src);
 454   Dest  = AllocateZeroPool (Size);
 455   ASSERT (Dest != NULL);
 456   if (Dest != NULL) {
 457     CopyMem (Dest, Src, Size);
 458   }
 459
 460   return Dest;
 461 }
 462
 463 /**
 464
 465   Function gets the file information from an open file descriptor, and stores it
 466   in a buffer allocated from pool.
 467
 468   @param FHand           File Handle.
 469   @param InfoType        Info type need to get.
 470
 471   @retval                A pointer to a buffer with file information or NULL is returned
 472
 473 **/
 474 VOID *
 475 LibFileInfo (
 476   IN EFI_FILE_HANDLE      FHand,
 477   IN EFI_GUID             *InfoType
 478   )
 479 {
 480   EFI_STATUS    Status;
 481   EFI_FILE_INFO *Buffer;
 482   UINTN         BufferSize;
 483
 484   Buffer      = NULL;
 485   BufferSize  = 0;
 486
 487   Status = FHand->GetInfo (
 488                     FHand,
 489                     InfoType,
 490                     &BufferSize,
 491                     Buffer
 492                     );
 493   if (Status == EFI_BUFFER_TOO_SMALL) {
 494     Buffer = AllocatePool (BufferSize);
 495     ASSERT (Buffer != NULL);
 496   }
 497
 498   Status = FHand->GetInfo (
 499                     FHand,
 500                     InfoType,
 501                     &BufferSize,
 502                     Buffer
 503                     );
 504
 505   return Buffer;
 506 }
 507
 508 /**
 509
 510   Get file type base on the file name.
 511   Just cut the file name, from the ".". eg ".efi"
 512
 513   @param FileName  File need to be checked.
 514
 515   @retval the file type string.
 516
 517 **/
 518 CHAR16*
 519 LibGetTypeFromName (
 520   IN CHAR16   *FileName
 521   )
 522 {
 523   UINTN    Index;
 524
 525   Index = StrLen (FileName) - 1;
 526   while ((FileName[Index] != L'.') && (Index != 0)) {
 527     Index--;
 528   }
 529
 530   return Index == 0 ? NULL : &FileName[Index];
 531 }
 532
 533 /**
 534   Converts the unicode character of the string from uppercase to lowercase.
 535   This is a internal function.
 536
 537   @param ConfigString  String to be converted
 538
 539 **/
 540 VOID
 541 LibToLowerString (
 542   IN CHAR16  *String
 543   )
 544 {
 545   CHAR16      *TmpStr;
 546
 547   for (TmpStr = String; *TmpStr != L'\0'; TmpStr++) {
 548     if (*TmpStr >= L'A' && *TmpStr <= L'Z') {
 549       *TmpStr = (CHAR16) (*TmpStr - L'A' + L'a');
 550     }
 551   }
 552 }
 553
 554 /**
 555
 556   Check whether current FileName point to a valid
 557   Efi Image File.
 558
 559   @param FileName  File need to be checked.
 560
 561   @retval TRUE  Is Efi Image
 562   @retval FALSE Not a valid Efi Image
 563
 564 **/
 565 BOOLEAN
 566 LibIsSupportedFileType (
 567   IN UINT16  *FileName
 568   )
 569 {
 570   CHAR16     *InputFileType;
 571   CHAR16     *TmpStr;
 572   BOOLEAN    IsSupported;
 573
 574   if (gFileExplorerPrivate.FileType == NULL) {
 575     return TRUE;
 576   }
 577
 578   InputFileType = LibGetTypeFromName (FileName);
 579   //
 580   // If the file not has *.* style, always return TRUE.
 581   //
 582   if (InputFileType == NULL) {
 583     return TRUE;
 584   }
 585
 586   TmpStr = AllocateCopyPool (StrSize (InputFileType), InputFileType);
 587   ASSERT(TmpStr != NULL);
 588   LibToLowerString(TmpStr);
 589
 590   IsSupported = (StrStr (gFileExplorerPrivate.FileType, TmpStr) == NULL ? FALSE : TRUE);
 591
 592   FreePool (TmpStr);
 593   return IsSupported;
 594 }
 595
 596 /**
 597
 598   Append file name to existing file name.
 599
 600   @param Str1  The existing file name
 601   @param Str2  The file name to be appended
 602
 603   @return Allocate a new string to hold the appended result.
 604           Caller is responsible to free the returned string.
 605
 606 **/
 607 CHAR16 *
 608 LibAppendFileName (
 609   IN  CHAR16  *Str1,
 610   IN  CHAR16  *Str2
 611   )
 612 {
 613   UINTN   Size1;
 614   UINTN   Size2;
 615   UINTN   MaxLen;
 616   CHAR16  *Str;
 617   CHAR16  *TmpStr;
 618   CHAR16  *Ptr;
 619   CHAR16  *LastSlash;
 620
 621   Size1 = StrSize (Str1);
 622   Size2 = StrSize (Str2);
 623   MaxLen = (Size1 + Size2 + sizeof (CHAR16))/ sizeof (CHAR16);
 624   Str   = AllocateZeroPool (Size1 + Size2 + sizeof (CHAR16));
 625   ASSERT (Str != NULL);
 626
 627   TmpStr = AllocateZeroPool (Size1 + Size2 + sizeof (CHAR16));
 628   ASSERT (TmpStr != NULL);
 629
 630   StrCpyS (Str, MaxLen, Str1);
 631   if (!((*Str == '\\') && (*(Str + 1) == 0))) {
 632     StrCatS (Str, MaxLen, L"\\");
 633   }
 634
 635   StrCatS (Str, MaxLen, Str2);
 636
 637   Ptr       = Str;
 638   LastSlash = Str;
 639   while (*Ptr != 0) {
 640     if (*Ptr == '\\' && *(Ptr + 1) == '.' && *(Ptr + 2) == '.' && *(Ptr + 3) == L'\\') {
 641       //
 642       // Convert "\Name\..\" to "\"
 643       // DO NOT convert the .. if it is at the end of the string. This will
 644       // break the .. behavior in changing directories.
 645       //
 646
 647       //
 648       // Use TmpStr as a backup, as StrCpyS in BaseLib does not handle copy of two strings
 649       // that overlap.
 650       //
 651       StrCpyS (TmpStr, MaxLen, Ptr + 3);
 652       StrCpyS (LastSlash, MaxLen - (UINTN) (LastSlash - Str), TmpStr);
 653       Ptr = LastSlash;
 654     } else if (*Ptr == '\\' && *(Ptr + 1) == '.' && *(Ptr + 2) == '\\') {
 655       //
 656       // Convert a "\.\" to a "\"
 657       //
 658
 659       //
 660       // Use TmpStr as a backup, as StrCpyS in BaseLib does not handle copy of two strings
 661       // that overlap.
 662       //
 663       StrCpyS (TmpStr, MaxLen, Ptr + 2);
 664       StrCpyS (Ptr, MaxLen - (UINTN) (Ptr - Str), TmpStr);
 665       Ptr = LastSlash;
 666     } else if (*Ptr == '\\') {
 667       LastSlash = Ptr;
 668     }
 669
 670     Ptr++;
 671   }
 672
 673   FreePool (TmpStr);
 674
 675   return Str;
 676 }
 677
 678 /**
 679   This function build the FsOptionMenu list which records all
 680   available file system in the system. They includes all instances
 681   of EFI_SIMPLE_FILE_SYSTEM_PROTOCOL, all instances of EFI_LOAD_FILE_SYSTEM.
 682
 683
 684   @retval  EFI_SUCCESS             Success find the file system
 685   @retval  EFI_OUT_OF_RESOURCES    Can not create menu entry
 686
 687 **/
 688 EFI_STATUS
 689 LibFindFileSystem (
 690   VOID
 691   )
 692 {
 693   UINTN                        NoSimpleFsHandles;
 694   UINTN                        NoLoadFileHandles;
 695   EFI_HANDLE                   *SimpleFsHandle;
 696   EFI_HANDLE                   *LoadFileHandle;
 697   UINT16                       *VolumeLabel;
 698   UINTN                        Index;
 699   EFI_STATUS                   Status;
 700   MENU_ENTRY                   *MenuEntry;
 701   FILE_CONTEXT                 *FileContext;
 702   UINTN                        OptionNumber;
 703   EFI_FILE_SYSTEM_VOLUME_LABEL *Info;
 704
 705   NoSimpleFsHandles = 0;
 706   NoLoadFileHandles = 0;
 707   OptionNumber      = 0;
 708
 709   //
 710   // Locate Handles that support Simple File System protocol
 711   //
 712   Status = gBS->LocateHandleBuffer (
 713                   ByProtocol,
 714                   &gEfiSimpleFileSystemProtocolGuid,
 715                   NULL,
 716                   &NoSimpleFsHandles,
 717                   &SimpleFsHandle
 718                   );
 719   if (!EFI_ERROR (Status)) {
 720     //
 721     // Find all the instances of the File System prototocol
 722     //
 723     for (Index = 0; Index < NoSimpleFsHandles; Index++) {
 724       //
 725       // Allocate pool for this load option
 726       //
 727       MenuEntry = LibCreateMenuEntry ();
 728       if (NULL == MenuEntry) {
 729         FreePool (SimpleFsHandle);
 730         return EFI_OUT_OF_RESOURCES;
 731       }
 732
 733       FileContext = (FILE_CONTEXT *) MenuEntry->VariableContext;
 734       FileContext->DeviceHandle = SimpleFsHandle[Index];
 735       FileContext->FileHandle = LibOpenRoot (FileContext->DeviceHandle);
 736       if (FileContext->FileHandle == NULL) {
 737         LibDestroyMenuEntry (MenuEntry);
 738         continue;
 739       }
 740
 741       MenuEntry->HelpString = LibDevicePathToStr (DevicePathFromHandle (FileContext->DeviceHandle));
 742       FileContext->FileName = LibStrDuplicate (L"\\");
 743       FileContext->DevicePath = FileDevicePath (FileContext->DeviceHandle, FileContext->FileName);
 744       FileContext->IsDir = TRUE;
 745       FileContext->IsRoot = TRUE;
 746
 747       //
 748       // Get current file system's Volume Label
 749       //
 750       Info = (EFI_FILE_SYSTEM_VOLUME_LABEL *) LibFileInfo (FileContext->FileHandle, &gEfiFileSystemVolumeLabelInfoIdGuid);
 751       if (Info == NULL) {
 752         VolumeLabel = L"NO FILE SYSTEM INFO";
 753       } else {
 754         if (Info->VolumeLabel == NULL) {
 755           VolumeLabel = L"NULL VOLUME LABEL";
 756         } else {
 757           VolumeLabel = Info->VolumeLabel;
 758           if (*VolumeLabel == 0x0000) {
 759             VolumeLabel = L"NO VOLUME LABEL";
 760           }
 761         }
 762       }
 763       MenuEntry->DisplayString  = AllocateZeroPool (MAX_CHAR);
 764       ASSERT (MenuEntry->DisplayString != NULL);
 765       UnicodeSPrint (
 766         MenuEntry->DisplayString,
 767         MAX_CHAR,
 768         L"%s, [%s]",
 769         VolumeLabel,
 770         MenuEntry->HelpString
 771         );
 772           MenuEntry->DisplayStringToken = HiiSetString (
 773                                              gFileExplorerPrivate.FeHiiHandle,
 774                                              0,
 775                                              MenuEntry->DisplayString,
 776                                              NULL
 777                                              );
 778       FreePool (Info);
 779
 780       OptionNumber++;
 781       InsertTailList (&gFileExplorerPrivate.FsOptionMenu->Head, &MenuEntry->Link);
 782     }
 783   }
 784
 785   if (NoSimpleFsHandles != 0) {
 786     FreePool (SimpleFsHandle);
 787   }
 788
 789   //
 790   // Searching for handles that support Load File protocol
 791   //
 792   Status = gBS->LocateHandleBuffer (
 793                   ByProtocol,
 794                   &gEfiLoadFileProtocolGuid,
 795                   NULL,
 796                   &NoLoadFileHandles,
 797                   &LoadFileHandle
 798                   );
 799
 800   if (!EFI_ERROR (Status)) {
 801     for (Index = 0; Index < NoLoadFileHandles; Index++) {
 802       MenuEntry = LibCreateMenuEntry ();
 803       if (NULL == MenuEntry) {
 804         FreePool (LoadFileHandle);
 805         return EFI_OUT_OF_RESOURCES;
 806       }
 807
 808       FileContext = (FILE_CONTEXT *) MenuEntry->VariableContext;
 809       FileContext->DeviceHandle = LoadFileHandle[Index];
 810       FileContext->IsRoot = TRUE;
 811
 812       FileContext->DevicePath = DevicePathFromHandle (FileContext->DeviceHandle);
 813       FileContext->FileName = LibDevicePathToStr (FileContext->DevicePath);
 814
 815       MenuEntry->HelpString = LibDevicePathToStr (FileContext->DevicePath);
 816       MenuEntry->DisplayString = AllocateZeroPool (MAX_CHAR);
 817       ASSERT (MenuEntry->DisplayString != NULL);
 818       UnicodeSPrint (
 819         MenuEntry->DisplayString,
 820         MAX_CHAR,
 821         L"Load File [%s]",
 822         MenuEntry->HelpString
 823         );
 824       MenuEntry->DisplayStringToken = HiiSetString (
 825                                            gFileExplorerPrivate.FeHiiHandle,
 826                                            0,
 827                                            MenuEntry->DisplayString,
 828                                            NULL
 829                                            );
 830
 831       OptionNumber++;
 832       InsertTailList (&gFileExplorerPrivate.FsOptionMenu->Head, &MenuEntry->Link);
 833     }
 834   }
 835
 836   if (NoLoadFileHandles != 0) {
 837     FreePool (LoadFileHandle);
 838   }
 839
 840   gFileExplorerPrivate.FsOptionMenu->MenuNumber = OptionNumber;
 841
 842   return EFI_SUCCESS;
 843 }
 844
 845 /**
 846   Find the file handle from the input menu info.
 847
 848   @param  MenuEntry        Input Menu info.
 849   @param  RetFileHandle    Return the file handle for the input device path.
 850
 851   @retval EFI_SUCESS       Find the file handle success.
 852   @retval Other            Find the file handle failure.
 853 **/
 854 EFI_STATUS
 855 LibGetFileHandleFromMenu (
 856   IN  MENU_ENTRY                *MenuEntry,
 857   OUT EFI_FILE_HANDLE           *RetFileHandle
 858   )
 859 {
 860   EFI_FILE_HANDLE Dir;
 861   EFI_FILE_HANDLE NewDir;
 862   FILE_CONTEXT    *FileContext;
 863   EFI_STATUS      Status;
 864
 865   FileContext   = (FILE_CONTEXT *) MenuEntry->VariableContext;
 866   Dir           = FileContext->FileHandle;
 867
 868   //
 869   // Open current directory to get files from it
 870   //
 871   Status = Dir->Open (
 872                   Dir,
 873                   &NewDir,
 874                   FileContext->FileName,
 875                   EFI_FILE_READ_ONLY,
 876                   0
 877                   );
 878   if (EFI_ERROR (Status)) {
 879     return Status;
 880   }
 881
 882   if (!FileContext->IsRoot) {
 883     Dir->Close (Dir);
 884   }
 885
 886   *RetFileHandle = NewDir;
 887
 888   return EFI_SUCCESS;
 889 }
 890
 891 /**
 892   Find the file handle from the input device path info.
 893
 894   @param  RootDirectory    Device path info.
 895   @param  RetFileHandle    Return the file handle for the input device path.
 896   @param  ParentFileName   Parent file name.
 897   @param  DeviceHandle     Driver handle for this partition.
 898
 899   @retval EFI_SUCESS       Find the file handle success.
 900   @retval Other            Find the file handle failure.
 901 **/
 902 EFI_STATUS
 903 LibGetFileHandleFromDevicePath (
 904   IN  EFI_DEVICE_PATH_PROTOCOL  *RootDirectory,
 905   OUT EFI_FILE_HANDLE           *RetFileHandle,
 906   OUT UINT16                    **ParentFileName,
 907   OUT EFI_HANDLE                *DeviceHandle
 908   )
 909 {
 910   EFI_DEVICE_PATH_PROTOCOL          *DevicePathNode;
 911   EFI_DEVICE_PATH_PROTOCOL          *TempDevicePathNode;
 912   EFI_STATUS                        Status;
 913   EFI_HANDLE                        Handle;
 914   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL   *Volume;
 915   EFI_FILE_HANDLE                   FileHandle;
 916   EFI_FILE_HANDLE                   LastHandle;
 917   CHAR16                            *TempPath;
 918
 919   *ParentFileName = NULL;
 920
 921   //
 922   // Attempt to access the file via a file system interface
 923   //
 924   DevicePathNode = RootDirectory;
 925   Status = gBS->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid, &DevicePathNode, &Handle);
 926   if (EFI_ERROR (Status)) {
 927     return Status;
 928   }
 929
 930   Status = gBS->HandleProtocol (Handle, &gEfiSimpleFileSystemProtocolGuid, (VOID**)&Volume);
 931   if (EFI_ERROR (Status)) {
 932     return Status;
 933   }
 934
 935   //
 936   // Open the Volume to get the File System handle
 937   //
 938   Status = Volume->OpenVolume (Volume, &FileHandle);
 939   if (EFI_ERROR (Status)) {
 940     return Status;
 941   }
 942
 943   *DeviceHandle = Handle;
 944
 945   if (IsDevicePathEnd(DevicePathNode)) {
 946     *ParentFileName = AllocateCopyPool (StrSize (L"\\"), L"\\");
 947     *RetFileHandle = FileHandle;
 948     return EFI_SUCCESS;
 949   }
 950
 951   //
 952   // Duplicate the device path to avoid the access to unaligned device path node.
 953   // Because the device path consists of one or more FILE PATH MEDIA DEVICE PATH
 954   // nodes, It assures the fields in device path nodes are 2 byte aligned.
 955   //
 956   TempDevicePathNode = DuplicateDevicePath (DevicePathNode);
 957   if (TempDevicePathNode == NULL) {
 958
 959     //
 960     // Setting Status to an EFI_ERROR value will cause the rest of
 961     // the file system support below to be skipped.
 962     //
 963     Status = EFI_OUT_OF_RESOURCES;
 964   }
 965
 966   //
 967   // Parse each MEDIA_FILEPATH_DP node. There may be more than one, since the
 968   // directory information and filename can be seperate. The goal is to inch
 969   // our way down each device path node and close the previous node
 970   //
 971   DevicePathNode = TempDevicePathNode;
 972   while (!EFI_ERROR (Status) && !IsDevicePathEnd (DevicePathNode)) {
 973     if (DevicePathType (DevicePathNode) != MEDIA_DEVICE_PATH ||
 974         DevicePathSubType (DevicePathNode) != MEDIA_FILEPATH_DP) {
 975       Status = EFI_UNSUPPORTED;
 976       goto Done;
 977     }
 978
 979     LastHandle = FileHandle;
 980     FileHandle = NULL;
 981
 982     Status = LastHandle->Open (
 983                           LastHandle,
 984                           &FileHandle,
 985                           ((FILEPATH_DEVICE_PATH *) DevicePathNode)->PathName,
 986                           EFI_FILE_MODE_READ,
 987                           0
 988                           );
 989     if (*ParentFileName == NULL) {
 990       *ParentFileName = AllocateCopyPool (StrSize (((FILEPATH_DEVICE_PATH *) DevicePathNode)->PathName), ((FILEPATH_DEVICE_PATH *) DevicePathNode)->PathName);
 991     } else {
 992       TempPath = LibAppendFileName (*ParentFileName, ((FILEPATH_DEVICE_PATH *) DevicePathNode)->PathName);
 993       FreePool (*ParentFileName);
 994       *ParentFileName = TempPath;
 995     }
 996
 997     //
 998     // Close the previous node
 999     //
1000     LastHandle->Close (LastHandle);
1001
1002     DevicePathNode = NextDevicePathNode (DevicePathNode);
1003   }
1004
1005   if (EFI_ERROR (Status)) {
1006     goto Done;
1007   }
1008
1009   *RetFileHandle = FileHandle;
1010
1011   Status = EFI_SUCCESS;
1012
1013 Done:
1014   if (TempDevicePathNode != NULL) {
1015     FreePool (TempDevicePathNode);
1016   }
1017
1018   if ((FileHandle != NULL) && (EFI_ERROR (Status))) {
1019     FileHandle->Close (FileHandle);
1020   }
1021
1022   return Status;
1023 }
1024
1025 /**
1026   Find files under current directory.
1027
1028   All files and sub-directories in current directory
1029   will be stored in DirectoryMenu for future use.
1030
1031   @param FileHandle    Parent file handle.
1032   @param FileName      Parent file name.
1033   @param DeviceHandle  Driver handle for this partition.
1034
1035   @retval EFI_SUCCESS         Get files from current dir successfully.
1036   @return Other value if can't get files from current dir.
1037
1038 **/
1039 EFI_STATUS
1040 LibFindFiles (
1041   IN EFI_FILE_HANDLE           FileHandle,
1042   IN UINT16                    *FileName,
1043   IN EFI_HANDLE                DeviceHandle
1044   )
1045 {
1046   EFI_FILE_INFO   *DirInfo;
1047   UINTN           BufferSize;
1048   UINTN           DirBufferSize;
1049   MENU_ENTRY      *NewMenuEntry;
1050   FILE_CONTEXT    *NewFileContext;
1051   UINTN           Pass;
1052   EFI_STATUS      Status;
1053   UINTN           OptionNumber;
1054
1055   OptionNumber = 0;
1056
1057   DirBufferSize = sizeof (EFI_FILE_INFO) + 1024;
1058   DirInfo       = AllocateZeroPool (DirBufferSize);
1059   if (DirInfo == NULL) {
1060     return EFI_OUT_OF_RESOURCES;
1061   }
1062
1063   //
1064   // Get all files in current directory
1065   // Pass 1 to get Directories
1066   // Pass 2 to get files that are EFI images
1067   //
1068   for (Pass = 1; Pass <= 2; Pass++) {
1069     FileHandle->SetPosition (FileHandle, 0);
1070     for (;;) {
1071       BufferSize  = DirBufferSize;
1072       Status      = FileHandle->Read (FileHandle, &BufferSize, DirInfo);
1073       if (EFI_ERROR (Status) || BufferSize == 0) {
1074         break;
1075       }
1076
1077       if (((DirInfo->Attribute & EFI_FILE_DIRECTORY) != 0 && Pass == 2) ||
1078           ((DirInfo->Attribute & EFI_FILE_DIRECTORY) == 0 && Pass == 1)
1079           ) {
1080         //
1081         // Pass 1 is for Directories
1082         // Pass 2 is for file names
1083         //
1084         continue;
1085       }
1086
1087       if (!((DirInfo->Attribute & EFI_FILE_DIRECTORY) != 0 || LibIsSupportedFileType (DirInfo->FileName))) {
1088         //
1089         // Slip file unless it is a directory entry or a .EFI file
1090         //
1091         continue;
1092       }
1093
1094       NewMenuEntry = LibCreateMenuEntry ();
1095       if (NULL == NewMenuEntry) {
1096         return EFI_OUT_OF_RESOURCES;
1097       }
1098
1099       NewFileContext = (FILE_CONTEXT *) NewMenuEntry->VariableContext;
1100       NewFileContext->DeviceHandle = DeviceHandle;
1101       NewFileContext->FileName = LibAppendFileName (FileName, DirInfo->FileName);
1102       NewFileContext->FileHandle = FileHandle;
1103       NewFileContext->DevicePath = FileDevicePath (NewFileContext->DeviceHandle, NewFileContext->FileName);
1104       NewMenuEntry->HelpString = NULL;
1105       NewFileContext->IsDir = (BOOLEAN) ((DirInfo->Attribute & EFI_FILE_DIRECTORY) == EFI_FILE_DIRECTORY);
1106
1107       if (NewFileContext->IsDir) {
1108         BufferSize = StrLen (DirInfo->FileName) * 2 + 6;
1109         NewMenuEntry->DisplayString = AllocateZeroPool (BufferSize);
1110         UnicodeSPrint (
1111           NewMenuEntry->DisplayString,
1112           BufferSize,
1113           L"<%s>",
1114           DirInfo->FileName
1115           );
1116       } else {
1117         NewMenuEntry->DisplayString = LibStrDuplicate (DirInfo->FileName);
1118       }
1119
1120       NewMenuEntry->DisplayStringToken = HiiSetString (
1121                                            gFileExplorerPrivate.FeHiiHandle,
1122                                            0,
1123                                            NewMenuEntry->DisplayString,
1124                                            NULL
1125                                            );
1126
1127       NewFileContext->IsRoot            = FALSE;
1128
1129       OptionNumber++;
1130       InsertTailList (&gFileExplorerPrivate.FsOptionMenu->Head, &NewMenuEntry->Link);
1131     }
1132   }
1133
1134   gFileExplorerPrivate.FsOptionMenu->MenuNumber = OptionNumber;
1135
1136   FreePool (DirInfo);
1137
1138   return EFI_SUCCESS;
1139 }
1140
1141 /**
1142   Refresh the global UpdateData structure.
1143
1144 **/
1145 VOID
1146 LibRefreshUpdateData (
1147   VOID
1148   )
1149 {
1150   //
1151   // Free current updated date
1152   //
1153   if (mLibStartOpCodeHandle != NULL) {
1154     HiiFreeOpCodeHandle (mLibStartOpCodeHandle);
1155   }
1156   if (mLibEndOpCodeHandle != NULL) {
1157     HiiFreeOpCodeHandle (mLibEndOpCodeHandle);
1158   }
1159
1160   //
1161   // Create new OpCode Handle
1162   //
1163   mLibStartOpCodeHandle = HiiAllocateOpCodeHandle ();
1164   mLibEndOpCodeHandle = HiiAllocateOpCodeHandle ();
1165
1166   //
1167   // Create Hii Extend Label OpCode as the start opcode
1168   //
1169   mLibStartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
1170                                          mLibStartOpCodeHandle,
1171                                          &gEfiIfrTianoGuid,
1172                                          NULL,
1173                                          sizeof (EFI_IFR_GUID_LABEL)
1174                                          );
1175   mLibStartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1176
1177   mLibStartLabel->Number = FORM_FILE_EXPLORER_ID;
1178
1179   //
1180   // Create Hii Extend Label OpCode as the start opcode
1181   //
1182   mLibEndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (
1183                                          mLibEndOpCodeHandle,
1184                                          &gEfiIfrTianoGuid,
1185                                          NULL,
1186                                          sizeof (EFI_IFR_GUID_LABEL)
1187                                          );
1188   mLibEndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1189
1190   mLibEndLabel->Number = LABEL_END;
1191 }
1192
1193 /**
1194
1195   Update the File Explore page.
1196
1197 **/
1198 VOID
1199 LibUpdateFileExplorePage (
1200   VOID
1201   )
1202 {
1203   UINTN           Index;
1204   MENU_ENTRY      *NewMenuEntry;
1205   FILE_CONTEXT    *NewFileContext;
1206   MENU_OPTION     *MenuOption;
1207
1208   NewMenuEntry    = NULL;
1209   NewFileContext  = NULL;
1210
1211   LibRefreshUpdateData ();
1212   MenuOption = gFileExplorerPrivate.FsOptionMenu;
1213
1214   for (Index = 0; Index < MenuOption->MenuNumber; Index++) {
1215     NewMenuEntry    = LibGetMenuEntry (MenuOption, Index);
1216     NewFileContext  = (FILE_CONTEXT *) NewMenuEntry->VariableContext;
1217
1218     if (!NewFileContext->IsDir) {
1219       //
1220       // Create Text opcode for directory, also create Text opcode for file in FileExplorerStateBootFromFile.
1221       //
1222       HiiCreateActionOpCode (
1223         mLibStartOpCodeHandle,
1224         (UINT16) (FILE_OPTION_OFFSET + Index),
1225         NewMenuEntry->DisplayStringToken,
1226         STRING_TOKEN (STR_NULL_STRING),
1227         EFI_IFR_FLAG_CALLBACK,
1228         0
1229         );
1230     } else {
1231       //
1232       // Create Goto opcode for file in FileExplorerStateAddBootOption or FileExplorerStateAddDriverOptionState.
1233       //
1234       HiiCreateGotoOpCode (
1235         mLibStartOpCodeHandle,
1236         FORM_FILE_EXPLORER_ID,
1237         NewMenuEntry->DisplayStringToken,
1238         STRING_TOKEN (STR_NULL_STRING),
1239         EFI_IFR_FLAG_CALLBACK,
1240         (UINT16) (FILE_OPTION_OFFSET + Index)
1241         );
1242     }
1243   }
1244
1245   HiiUpdateForm (
1246     gFileExplorerPrivate.FeHiiHandle,
1247     &FileExplorerGuid,
1248     FORM_FILE_EXPLORER_ID,
1249     mLibStartOpCodeHandle, // Label FORM_FILE_EXPLORER_ID
1250     mLibEndOpCodeHandle    // LABEL_END
1251     );
1252 }
1253
1254 /**
1255   Update the file explower page with the refershed file system.
1256
1257   @param KeyValue        Key value to identify the type of data to expect.
1258
1259   @retval  EFI_SUCCESS   Update the file explorer form success.
1260   @retval  other errors  Error occur when parse one directory.
1261
1262 **/
1263 EFI_STATUS
1264 LibUpdateFileExplorer (
1265   IN UINT16                       KeyValue
1266   )
1267 {
1268   UINT16          FileOptionMask;
1269   MENU_ENTRY      *NewMenuEntry;
1270   FILE_CONTEXT    *NewFileContext;
1271   EFI_STATUS      Status;
1272   EFI_FILE_HANDLE FileHandle;
1273
1274   Status = EFI_SUCCESS;
1275   FileOptionMask = (UINT16) (FILE_OPTION_MASK & KeyValue);
1276   NewMenuEntry   = LibGetMenuEntry (gFileExplorerPrivate.FsOptionMenu, FileOptionMask);
1277   NewFileContext = (FILE_CONTEXT *) NewMenuEntry->VariableContext;
1278
1279   if (NewFileContext->IsDir) {
1280     RemoveEntryList (&NewMenuEntry->Link);
1281     LibFreeMenu (gFileExplorerPrivate.FsOptionMenu);
1282     LibGetFileHandleFromMenu (NewMenuEntry, &FileHandle);
1283     Status = LibFindFiles (FileHandle, NewFileContext->FileName, NewFileContext->DeviceHandle);
1284     if (!EFI_ERROR (Status)) {
1285       LibUpdateFileExplorePage ();
1286     } else {
1287       LibFreeMenu (gFileExplorerPrivate.FsOptionMenu);
1288     }
1289     LibDestroyMenuEntry (NewMenuEntry);
1290   }
1291
1292   return Status;
1293 }
1294
1295 /**
1296   Get the device path info saved in the menu structure.
1297
1298   @param KeyValue        Key value to identify the type of data to expect.
1299
1300 **/
1301 VOID
1302 LibGetDevicePath (
1303   IN UINT16                       KeyValue
1304   )
1305 {
1306   UINT16          FileOptionMask;
1307   MENU_ENTRY      *NewMenuEntry;
1308   FILE_CONTEXT    *NewFileContext;
1309
1310   FileOptionMask    = (UINT16) (FILE_OPTION_MASK & KeyValue);
1311
1312   NewMenuEntry = LibGetMenuEntry (gFileExplorerPrivate.FsOptionMenu, FileOptionMask);
1313
1314   NewFileContext = (FILE_CONTEXT *) NewMenuEntry->VariableContext;
1315
1316   if (gFileExplorerPrivate.RetDevicePath != NULL) {
1317     FreePool (gFileExplorerPrivate.RetDevicePath);
1318   }
1319   gFileExplorerPrivate.RetDevicePath = DuplicateDevicePath (NewFileContext->DevicePath);
1320 }
1321
1322 /**
1323   Choose a file in the specified directory.
1324
1325   If user input NULL for the RootDirectory, will choose file in the system.
1326
1327   If user input *File != NULL, function will return the allocate device path
1328   info for the choosed file, caller has to free the memory after use it.
1329
1330   @param  RootDirectory    Pointer to the root directory.
1331   @param  FileType         The file type need to choose.
1332   @param  ChooseHandler    Function pointer to the extra task need to do
1333                            after choose one file.
1334   @param  File             Return the device path for the last time chosed file.
1335
1336   @retval EFI_SUCESS             Choose file success.
1337   @retval EFI_INVALID_PARAMETER  Both ChooseHandler and return device path are NULL
1338                                  One of them must not NULL.
1339   @retval Other errors           Choose file failed.
1340 **/
1341 EFI_STATUS
1342 EFIAPI
1343 ChooseFile (
1344   IN  EFI_DEVICE_PATH_PROTOCOL  *RootDirectory,
1345   IN  CHAR16                    *FileType,  OPTIONAL
1346   IN  CHOOSE_HANDLER            ChooseHandler,  OPTIONAL
1347   OUT EFI_DEVICE_PATH_PROTOCOL  **File  OPTIONAL
1348   )
1349 {
1350   EFI_FILE_HANDLE                   FileHandle;
1351   EFI_STATUS                        Status;
1352   UINT16                            *FileName;
1353   EFI_HANDLE                        DeviceHandle;
1354
1355   if ((ChooseHandler == NULL) && (File == NULL)) {
1356     return EFI_INVALID_PARAMETER;
1357   }
1358
1359   FileName = NULL;
1360
1361   gFileExplorerPrivate.RetDevicePath = NULL;
1362   gFileExplorerPrivate.ChooseHandler = ChooseHandler;
1363   if (FileType != NULL) {
1364     gFileExplorerPrivate.FileType = AllocateCopyPool (StrSize (FileType), FileType);
1365     ASSERT(gFileExplorerPrivate.FileType != NULL);
1366     LibToLowerString(gFileExplorerPrivate.FileType);
1367   } else {
1368     gFileExplorerPrivate.FileType = NULL;
1369   }
1370
1371   if (RootDirectory == NULL) {
1372     Status = LibFindFileSystem();
1373   } else {
1374     Status = LibGetFileHandleFromDevicePath(RootDirectory, &FileHandle, &FileName, &DeviceHandle);
1375     if (EFI_ERROR (Status)) {
1376       goto Done;
1377     }
1378
1379     Status = LibFindFiles (FileHandle, FileName, DeviceHandle);
1380   }
1381   if (EFI_ERROR (Status)) {
1382     goto Done;
1383   }
1384
1385   LibUpdateFileExplorePage();
1386
1387   gFileExplorerPrivate.FormBrowser2->SendForm (
1388                          gFileExplorerPrivate.FormBrowser2,
1389                          &gFileExplorerPrivate.FeHiiHandle,
1390                          1,
1391                          &FileExplorerGuid,
1392                          0,
1393                          NULL,
1394                          NULL
1395                          );
1396
1397 Done:
1398   if ((Status == EFI_SUCCESS) && (File != NULL)) {
1399     *File  = gFileExplorerPrivate.RetDevicePath;
1400   } else if (gFileExplorerPrivate.RetDevicePath != NULL) {
1401     FreePool (gFileExplorerPrivate.RetDevicePath);
1402   }
1403
1404   if (gFileExplorerPrivate.FileType != NULL) {
1405     FreePool (gFileExplorerPrivate.FileType);
1406   }
1407
1408   LibFreeMenu (gFileExplorerPrivate.FsOptionMenu);
1409
1410   if (FileName != NULL) {
1411     FreePool (FileName);
1412   }
1413
1414   return Status;
1415 }
1416
1417 /**
1418
1419   Install Boot Manager Menu driver.
1420
1421   @param ImageHandle     The image handle.
1422   @param SystemTable     The system table.
1423
1424   @retval  EFI_SUCEESS  Install File explorer library success.
1425
1426 **/
1427 EFI_STATUS
1428 EFIAPI
1429 FileExplorerLibConstructor (
1430   IN EFI_HANDLE                            ImageHandle,
1431   IN EFI_SYSTEM_TABLE                      *SystemTable
1432   )
1433 {
1434   EFI_STATUS                     Status;
1435
1436   gHiiVendorDevicePath = (HII_VENDOR_DEVICE_PATH*) DuplicateDevicePath ((EFI_DEVICE_PATH_PROTOCOL*)&FeHiiVendorDevicePath);
1437   ASSERT (gHiiVendorDevicePath != NULL);
1438   CopyGuid (&gHiiVendorDevicePath->VendorDevicePath.Guid, &gEfiCallerIdGuid);
1439
1440   //
1441   // Install Device Path Protocol and Config Access protocol to driver handle
1442   //
1443   Status = gBS->InstallMultipleProtocolInterfaces (
1444                   &gFileExplorerPrivate.FeDriverHandle,
1445                   &gEfiDevicePathProtocolGuid,
1446                   gHiiVendorDevicePath,
1447                   &gEfiHiiConfigAccessProtocolGuid,
1448                   &gFileExplorerPrivate.FeConfigAccess,
1449                   NULL
1450                   );
1451   if (Status == EFI_ALREADY_STARTED) {
1452     return EFI_SUCCESS;
1453   }
1454   if (EFI_ERROR (Status)) {
1455     return Status;
1456   }
1457
1458   //
1459   // Post our File Explorer VFR binary to the HII database.
1460   //
1461   gFileExplorerPrivate.FeHiiHandle = HiiAddPackages (
1462                                    &FileExplorerGuid,
1463                                    gFileExplorerPrivate.FeDriverHandle,
1464                                    FileExplorerVfrBin,
1465                                    FileExplorerLibStrings,
1466                                    NULL
1467                                    );
1468   ASSERT (gFileExplorerPrivate.FeHiiHandle != NULL);
1469
1470   //
1471   // Locate Formbrowser2 protocol
1472   //
1473   Status = gBS->LocateProtocol (&gEfiFormBrowser2ProtocolGuid, NULL, (VOID **) &gFileExplorerPrivate.FormBrowser2);
1474   ASSERT_EFI_ERROR (Status);
1475
1476   InitializeListHead (&gFileExplorerPrivate.FsOptionMenu->Head);
1477
1478   return EFI_SUCCESS;
1479 }
1480
1481 /**
1482   Unloads the application and its installed protocol.
1483
1484   @param[in]  ImageHandle       Handle that identifies the image to be unloaded.
1485   @param[in]  SystemTable       The system table.
1486
1487   @retval EFI_SUCCESS           The image has been unloaded.
1488 **/
1489 EFI_STATUS
1490 EFIAPI
1491 FileExplorerLibDestructor (
1492   IN EFI_HANDLE                            ImageHandle,
1493   IN EFI_SYSTEM_TABLE                      *SystemTable
1494   )
1495 {
1496   EFI_STATUS    Status;
1497
1498   ASSERT (gHiiVendorDevicePath != NULL);
1499
1500   if (gFileExplorerPrivate.FeDriverHandle != NULL) {
1501     Status = gBS->UninstallMultipleProtocolInterfaces (
1502                     gFileExplorerPrivate.FeDriverHandle,
1503                     &gEfiDevicePathProtocolGuid,
1504                     gHiiVendorDevicePath,
1505                     &gEfiHiiConfigAccessProtocolGuid,
1506                     &gFileExplorerPrivate.FeConfigAccess,
1507                     NULL
1508                     );
1509     ASSERT_EFI_ERROR (Status);
1510
1511     HiiRemovePackages (gFileExplorerPrivate.FeHiiHandle);
1512   }
1513
1514   FreePool (gHiiVendorDevicePath);
1515
1516   return EFI_SUCCESS;
1517 }
1518