EdkNt32Pkg/Dxe/PlatformBds/Generic/BootMaint/BootOption.c

   1 /*++
   2 Copyright (c) 2006, Intel Corporation
   3 All rights reserved. This program and the accompanying materials
   4 are licensed and made available under the terms and conditions of the BSD License
   5 which accompanies this distribution.  The full text of the license may be found at
   6 http://opensource.org/licenses/bsd-license.php
   7
   8 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
   9 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  10
  11 Module Name:
  12
  13   bootoption.c
  14
  15 Abstract:
  16
  17   Provide boot option support for Application "BootMaint"
  18
  19   Include file system navigation, system handle selection
  20
  21   Boot option manipulation
  22
  23 Revision History
  24
  25 --*/
  26
  27 #include "bootmaint.h"
  28 #include "BBSsupport.h"
  29
  30 BM_MENU_ENTRY *
  31 BOpt_CreateMenuEntry (
  32   UINTN           MenuType
  33   )
  34 /*++
  35
  36 Routine Description
  37   Create Menu Entry for future use, make all types together
  38   in order to reduce code size
  39
  40 Arguments:
  41   MenuType            Use this parameter to identify current
  42                       Menu type
  43
  44 Returns:
  45   NULL                Cannot allocate memory for current menu
  46                       entry
  47   Others              A valid pointer pointing to the allocated
  48                       memory pool for current menu entry
  49
  50 --*/
  51 {
  52   BM_MENU_ENTRY *MenuEntry;
  53   UINTN         ContextSize;
  54
  55   switch (MenuType) {
  56   case BM_LOAD_CONTEXT_SELECT:
  57     ContextSize = sizeof (BM_LOAD_CONTEXT);
  58     break;
  59
  60   case BM_FILE_CONTEXT_SELECT:
  61     ContextSize = sizeof (BM_FILE_CONTEXT);
  62     break;
  63
  64   case BM_CONSOLE_CONTEXT_SELECT:
  65     ContextSize = sizeof (BM_CONSOLE_CONTEXT);
  66     break;
  67
  68   case BM_TERMINAL_CONTEXT_SELECT:
  69     ContextSize = sizeof (BM_TERMINAL_CONTEXT);
  70     break;
  71
  72   case BM_HANDLE_CONTEXT_SELECT:
  73     ContextSize = sizeof (BM_HANDLE_CONTEXT);
  74     break;
  75
  76   case BM_LEGACY_DEV_CONTEXT_SELECT:
  77     ContextSize = sizeof (BM_LEGACY_DEVICE_CONTEXT);
  78     break;
  79
  80   default:
  81     ContextSize = 0;
  82     break;
  83
  84   }
  85
  86   if (0 == ContextSize) {
  87     return NULL;
  88   }
  89
  90   MenuEntry = AllocateZeroPool (sizeof (BM_MENU_ENTRY));
  91   if (NULL == MenuEntry) {
  92     return MenuEntry;
  93   }
  94
  95   MenuEntry->VariableContext = AllocateZeroPool (ContextSize);
  96   if (NULL == MenuEntry->VariableContext) {
  97     SafeFreePool (MenuEntry);
  98     MenuEntry = NULL;
  99     return MenuEntry;
 100   }
 101
 102   MenuEntry->Signature        = BM_MENU_ENTRY_SIGNATURE;
 103   MenuEntry->ContextSelection = MenuType;
 104   return MenuEntry;
 105 }
 106
 107 VOID
 108 BOpt_DestroyMenuEntry (
 109   BM_MENU_ENTRY         *MenuEntry
 110   )
 111 /*++
 112   Routine Description :
 113     Destroy the menu entry passed in
 114
 115   Arguments :
 116     The menu entry need to be destroyed
 117
 118   Returns :
 119     None
 120
 121 --*/
 122 {
 123   BM_LOAD_CONTEXT           *LoadContext;
 124   BM_FILE_CONTEXT           *FileContext;
 125   BM_CONSOLE_CONTEXT        *ConsoleContext;
 126   BM_TERMINAL_CONTEXT       *TerminalContext;
 127   BM_HANDLE_CONTEXT         *HandleContext;
 128   BM_LEGACY_DEVICE_CONTEXT  *LegacyDevContext;
 129
 130   //
 131   //  Select by the type in Menu entry for current context type
 132   //
 133   switch (MenuEntry->ContextSelection) {
 134   case BM_LOAD_CONTEXT_SELECT:
 135     LoadContext = (BM_LOAD_CONTEXT *) MenuEntry->VariableContext;
 136     SafeFreePool (LoadContext->FilePathList);
 137     SafeFreePool (LoadContext->LoadOption);
 138     SafeFreePool (LoadContext->OptionalData);
 139     SafeFreePool (LoadContext);
 140     break;
 141
 142   case BM_FILE_CONTEXT_SELECT:
 143     FileContext = (BM_FILE_CONTEXT *) MenuEntry->VariableContext;
 144
 145     if (!FileContext->IsRoot) {
 146       SafeFreePool (FileContext->DevicePath);
 147     } else {
 148       if (FileContext->FHandle != NULL) {
 149         FileContext->FHandle->Close (FileContext->FHandle);
 150       }
 151     }
 152
 153     SafeFreePool (FileContext->FileName);
 154     SafeFreePool (FileContext->Info);
 155     SafeFreePool (FileContext);
 156     break;
 157
 158   case BM_CONSOLE_CONTEXT_SELECT:
 159     ConsoleContext = (BM_CONSOLE_CONTEXT *) MenuEntry->VariableContext;
 160     SafeFreePool (ConsoleContext->DevicePath);
 161     SafeFreePool (ConsoleContext);
 162     break;
 163
 164   case BM_TERMINAL_CONTEXT_SELECT:
 165     TerminalContext = (BM_TERMINAL_CONTEXT *) MenuEntry->VariableContext;
 166     SafeFreePool (TerminalContext->DevicePath);
 167     SafeFreePool (TerminalContext);
 168     break;
 169
 170   case BM_HANDLE_CONTEXT_SELECT:
 171     HandleContext = (BM_HANDLE_CONTEXT *) MenuEntry->VariableContext;
 172     SafeFreePool (HandleContext);
 173     break;
 174
 175   case BM_LEGACY_DEV_CONTEXT_SELECT:
 176     LegacyDevContext = (BM_LEGACY_DEVICE_CONTEXT *) MenuEntry->VariableContext;
 177     SafeFreePool (LegacyDevContext);
 178
 179   default:
 180     break;
 181   }
 182
 183   SafeFreePool (MenuEntry->DisplayString);
 184   if (NULL != MenuEntry->HelpString) {
 185     SafeFreePool (MenuEntry->HelpString);
 186   }
 187
 188   SafeFreePool (MenuEntry);
 189 }
 190
 191 BM_MENU_ENTRY *
 192 BOpt_GetMenuEntry (
 193   BM_MENU_OPTION      *MenuOption,
 194   UINTN               MenuNumber
 195   )
 196 /*++
 197   Rountine Description :
 198     Use this routine to get one particular menu entry in specified
 199     menu
 200
 201   Arguments :
 202     MenuOption        The menu that we will search
 203
 204     MenuNumber        The menunubmer that we want
 205
 206   Returns :
 207     The desired menu entry
 208
 209 --*/
 210 {
 211   BM_MENU_ENTRY   *NewMenuEntry;
 212   UINTN           Index;
 213   LIST_ENTRY      *List;
 214
 215   if (MenuNumber >= MenuOption->MenuNumber) {
 216     return NULL;
 217   }
 218
 219   List = MenuOption->Head.ForwardLink;
 220   for (Index = 0; Index < MenuNumber; Index++) {
 221     List = List->ForwardLink;
 222   }
 223
 224   NewMenuEntry = CR (List, BM_MENU_ENTRY, Link, BM_MENU_ENTRY_SIGNATURE);
 225
 226   return NewMenuEntry;
 227 }
 228
 229 EFI_STATUS
 230 BOpt_FindFileSystem (
 231   IN BMM_CALLBACK_DATA          *CallbackData
 232   )
 233 /*++
 234
 235 Routine Description
 236   Find file systems for current Extensible Firmware
 237   Including Handles that support Simple File System
 238   protocol, Load File protocol.
 239
 240   Building up the FileSystem Menu for user selection
 241   All file system will be stored in FsOptionMenu
 242   for future use.
 243
 244 Arguments:
 245   CallbackData           -   BMM context data
 246
 247 Returns:
 248   EFI_SUCCESS            -   Success find the file system
 249   EFI_OUT_OF_RESOURCES   -   Can not create menu entry
 250
 251 --*/
 252 {
 253   UINTN                     NoSimpleFsHandles;
 254   UINTN                     NoLoadFileHandles;
 255   EFI_HANDLE                *SimpleFsHandle;
 256   EFI_HANDLE                *LoadFileHandle;
 257   UINT16                    *VolumeLabel;
 258   EFI_BLOCK_IO_PROTOCOL     *BlkIo;
 259   UINTN                     Index;
 260   EFI_STATUS                Status;
 261   BM_MENU_ENTRY             *MenuEntry;
 262   BM_FILE_CONTEXT           *FileContext;
 263   UINT16                    *TempStr;
 264   UINTN                     OptionNumber;
 265   EFI_LEGACY_BIOS_PROTOCOL  *LegacyBios;
 266   UINT16                    DeviceType;
 267   BBS_BBS_DEVICE_PATH       BbsDevicePathNode;
 268   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 269   BOOLEAN                   RemovableMedia;
 270
 271
 272   NoSimpleFsHandles = 0;
 273   NoLoadFileHandles = 0;
 274   OptionNumber      = 0;
 275   InitializeListHead (&FsOptionMenu.Head);
 276
 277   //
 278   // Locate Handles that support Simple File System protocol
 279   //
 280   Status = gBS->LocateHandleBuffer (
 281                   ByProtocol,
 282                   &gEfiSimpleFileSystemProtocolGuid,
 283                   NULL,
 284                   &NoSimpleFsHandles,
 285                   &SimpleFsHandle
 286                   );
 287   if (!EFI_ERROR (Status)) {
 288     //
 289     // Find all the instances of the File System prototocol
 290     //
 291     for (Index = 0; Index < NoSimpleFsHandles; Index++) {
 292       Status = gBS->HandleProtocol (
 293                       SimpleFsHandle[Index],
 294                       &gEfiBlockIoProtocolGuid,
 295                       &BlkIo
 296                       );
 297       if (EFI_ERROR (Status)) {
 298         //
 299         // If no block IO exists assume it's NOT a removable media
 300         //
 301         RemovableMedia = FALSE;
 302       } else {
 303         //
 304         // If block IO exists check to see if it's remobable media
 305         //
 306         RemovableMedia = BlkIo->Media->RemovableMedia;
 307       }
 308
 309       //
 310       // Allocate pool for this load option
 311       //
 312       MenuEntry = BOpt_CreateMenuEntry (BM_FILE_CONTEXT_SELECT);
 313       if (NULL == MenuEntry) {
 314         SafeFreePool (SimpleFsHandle);
 315         return EFI_OUT_OF_RESOURCES;
 316       }
 317
 318       FileContext = (BM_FILE_CONTEXT *) MenuEntry->VariableContext;
 319
 320       FileContext->Handle     = SimpleFsHandle[Index];
 321       MenuEntry->OptionNumber = Index;
 322       FileContext->FHandle    = EfiLibOpenRoot (FileContext->Handle);
 323       if (!FileContext->FHandle) {
 324         BOpt_DestroyMenuEntry (MenuEntry);
 325         continue;
 326       }
 327
 328       MenuEntry->HelpString = DevicePathToStr (DevicePathFromHandle (FileContext->Handle));
 329       FileContext->Info = EfiLibFileSystemVolumeLabelInfo (FileContext->FHandle);
 330       FileContext->FileName = EfiStrDuplicate (L"\\");
 331       FileContext->DevicePath = FileDevicePath (
 332                                   FileContext->Handle,
 333                                   FileContext->FileName
 334                                   );
 335       FileContext->IsDir            = TRUE;
 336       FileContext->IsRoot           = TRUE;
 337       FileContext->IsRemovableMedia = FALSE;
 338       FileContext->IsLoadFile       = FALSE;
 339
 340       //
 341       // Get current file system's Volume Label
 342       //
 343       if (FileContext->Info == NULL) {
 344         VolumeLabel = L"NO FILE SYSTEM INFO";
 345       } else {
 346         if (FileContext->Info->VolumeLabel == NULL) {
 347           VolumeLabel = L"NULL VOLUME LABEL";
 348         } else {
 349           VolumeLabel = FileContext->Info->VolumeLabel;
 350           if (*VolumeLabel == 0x0000) {
 351             VolumeLabel = L"NO VOLUME LABEL";
 352           }
 353         }
 354       }
 355
 356       TempStr                   = MenuEntry->HelpString;
 357       MenuEntry->DisplayString  = AllocateZeroPool (MAX_CHAR);
 358       ASSERT (MenuEntry->DisplayString != NULL);
 359       UnicodeSPrint (
 360         MenuEntry->DisplayString,
 361         MAX_CHAR,
 362         L"%s, [%s]",
 363         VolumeLabel,
 364         TempStr
 365         );
 366       OptionNumber++;
 367       InsertTailList (&FsOptionMenu.Head, &MenuEntry->Link);
 368     }
 369   }
 370
 371   if (NoSimpleFsHandles != 0) {
 372     SafeFreePool (SimpleFsHandle);
 373   }
 374   //
 375   // Searching for handles that support Load File protocol
 376   //
 377   Status = gBS->LocateHandleBuffer (
 378                   ByProtocol,
 379                   &gEfiLoadFileProtocolGuid,
 380                   NULL,
 381                   &NoLoadFileHandles,
 382                   &LoadFileHandle
 383                   );
 384
 385   if (!EFI_ERROR (Status)) {
 386     for (Index = 0; Index < NoLoadFileHandles; Index++) {
 387       MenuEntry = BOpt_CreateMenuEntry (BM_FILE_CONTEXT_SELECT);
 388       if (NULL == MenuEntry) {
 389         SafeFreePool (LoadFileHandle);
 390         return EFI_OUT_OF_RESOURCES;
 391       }
 392
 393       FileContext                   = (BM_FILE_CONTEXT *) MenuEntry->VariableContext;
 394       FileContext->IsRemovableMedia = FALSE;
 395       FileContext->IsLoadFile       = TRUE;
 396       FileContext->Handle           = LoadFileHandle[Index];
 397       FileContext->IsRoot           = TRUE;
 398
 399       FileContext->DevicePath = DevicePathFromHandle (FileContext->Handle);
 400
 401       MenuEntry->HelpString     = DevicePathToStr (FileContext->DevicePath);
 402
 403       TempStr                   = MenuEntry->HelpString;
 404       MenuEntry->DisplayString  = AllocateZeroPool (MAX_CHAR);
 405       ASSERT (MenuEntry->DisplayString != NULL);
 406       UnicodeSPrint (
 407         MenuEntry->DisplayString,
 408         MAX_CHAR,
 409         L"Load File [%s]",
 410         TempStr
 411         );
 412
 413       MenuEntry->OptionNumber = OptionNumber;
 414       OptionNumber++;
 415       InsertTailList (&FsOptionMenu.Head, &MenuEntry->Link);
 416     }
 417   }
 418
 419   if (NoLoadFileHandles != 0) {
 420     SafeFreePool (LoadFileHandle);
 421   }
 422
 423   //
 424   // Add Legacy Boot Option Support Here
 425   //
 426   Status = gBS->LocateProtocol (
 427                   &gEfiLegacyBiosProtocolGuid,
 428                   NULL,
 429                   &LegacyBios
 430                   );
 431   if (!EFI_ERROR (Status)) {
 432
 433     for (Index = BBS_TYPE_FLOPPY; Index <= BBS_TYPE_EMBEDDED_NETWORK; Index++) {
 434       MenuEntry = BOpt_CreateMenuEntry (BM_FILE_CONTEXT_SELECT);
 435       if (NULL == MenuEntry) {
 436         return EFI_OUT_OF_RESOURCES;
 437       }
 438
 439       FileContext                       = (BM_FILE_CONTEXT *) MenuEntry->VariableContext;
 440
 441       FileContext->IsRemovableMedia     = FALSE;
 442       FileContext->IsLoadFile           = TRUE;
 443       FileContext->IsBootLegacy         = TRUE;
 444       DeviceType                        = (UINT16) Index;
 445       BbsDevicePathNode.Header.Type     = BBS_DEVICE_PATH;
 446       BbsDevicePathNode.Header.SubType  = BBS_BBS_DP;
 447       SetDevicePathNodeLength (
 448         &BbsDevicePathNode.Header,
 449         sizeof (BBS_BBS_DEVICE_PATH)
 450         );
 451       BbsDevicePathNode.DeviceType  = DeviceType;
 452       BbsDevicePathNode.StatusFlag  = 0;
 453       BbsDevicePathNode.String[0]   = 0;
 454       DevicePath = AppendDevicePathNode (
 455                     EndDevicePath,
 456                     (EFI_DEVICE_PATH_PROTOCOL *) &BbsDevicePathNode
 457                     );
 458
 459       FileContext->DevicePath   = DevicePath;
 460       MenuEntry->HelpString     = DevicePathToStr (FileContext->DevicePath);
 461
 462       TempStr                   = MenuEntry->HelpString;
 463       MenuEntry->DisplayString  = AllocateZeroPool (MAX_CHAR);
 464       ASSERT (MenuEntry->DisplayString != NULL);
 465       UnicodeSPrint (
 466         MenuEntry->DisplayString,
 467         MAX_CHAR,
 468         L"Boot Legacy [%s]",
 469         TempStr
 470         );
 471       MenuEntry->OptionNumber = OptionNumber;
 472       OptionNumber++;
 473       InsertTailList (&FsOptionMenu.Head, &MenuEntry->Link);
 474     }
 475   }
 476   //
 477   // Remember how many file system options are here
 478   //
 479   FsOptionMenu.MenuNumber = OptionNumber;
 480   return EFI_SUCCESS;
 481 }
 482
 483 VOID
 484 BOpt_FreeMenu (
 485   BM_MENU_OPTION        *FreeMenu
 486   )
 487 /*++
 488
 489 Routine Description
 490   Free resources allocated in Allocate Rountine
 491
 492 Arguments:
 493   FreeMenu        Menu to be freed
 494
 495 Returns:
 496   VOID
 497
 498 --*/
 499 {
 500   BM_MENU_ENTRY *MenuEntry;
 501   while (!IsListEmpty (&FreeMenu->Head)) {
 502     MenuEntry = CR (
 503                   FreeMenu->Head.ForwardLink,
 504                   BM_MENU_ENTRY,
 505                   Link,
 506                   BM_MENU_ENTRY_SIGNATURE
 507                   );
 508     RemoveEntryList (&MenuEntry->Link);
 509     BOpt_DestroyMenuEntry (MenuEntry);
 510   }
 511 }
 512
 513 EFI_STATUS
 514 BOpt_FindFiles (
 515   IN BMM_CALLBACK_DATA          *CallbackData,
 516   IN BM_MENU_ENTRY              *MenuEntry
 517   )
 518 /*++
 519
 520 Routine Description
 521   Find files under current directory
 522   All files and sub-directories in current directory
 523   will be stored in DirectoryMenu for future use.
 524
 525 Arguments:
 526   FileOption   -- Pointer for Dir to explore
 527
 528 Returns:
 529   TRUE         -- Get files from current dir successfully
 530   FALSE        -- Can't get files from current dir
 531
 532 --*/
 533 {
 534   EFI_FILE_HANDLE NewDir;
 535   EFI_FILE_HANDLE Dir;
 536   EFI_FILE_INFO   *DirInfo;
 537   UINTN           BufferSize;
 538   UINTN           DirBufferSize;
 539   BM_MENU_ENTRY   *NewMenuEntry;
 540   BM_FILE_CONTEXT *FileContext;
 541   BM_FILE_CONTEXT *NewFileContext;
 542   UINTN           Pass;
 543   EFI_STATUS      Status;
 544   UINTN           OptionNumber;
 545
 546   FileContext   = (BM_FILE_CONTEXT *) MenuEntry->VariableContext;
 547   Dir           = FileContext->FHandle;
 548   OptionNumber  = 0;
 549   //
 550   // Open current directory to get files from it
 551   //
 552   Status = Dir->Open (
 553                   Dir,
 554                   &NewDir,
 555                   FileContext->FileName,
 556                   EFI_FILE_READ_ONLY,
 557                   0
 558                   );
 559   if (!FileContext->IsRoot) {
 560     Dir->Close (Dir);
 561   }
 562
 563   if (EFI_ERROR (Status)) {
 564     return Status;
 565   }
 566
 567   DirInfo = EfiLibFileInfo (NewDir);
 568   if (!DirInfo) {
 569     return EFI_NOT_FOUND;
 570   }
 571
 572   if (!(DirInfo->Attribute & EFI_FILE_DIRECTORY)) {
 573     return EFI_INVALID_PARAMETER;
 574   }
 575
 576   FileContext->DevicePath = FileDevicePath (
 577                               FileContext->Handle,
 578                               FileContext->FileName
 579                               );
 580
 581   DirBufferSize = sizeof (EFI_FILE_INFO) + 1024;
 582   DirInfo       = AllocateZeroPool (DirBufferSize);
 583   if (!DirInfo) {
 584     return EFI_OUT_OF_RESOURCES;
 585   }
 586   //
 587   // Get all files in current directory
 588   // Pass 1 to get Directories
 589   // Pass 2 to get files that are EFI images
 590   //
 591   for (Pass = 1; Pass <= 2; Pass++) {
 592     NewDir->SetPosition (NewDir, 0);
 593     for (;;) {
 594       BufferSize  = DirBufferSize;
 595       Status      = NewDir->Read (NewDir, &BufferSize, DirInfo);
 596       if (EFI_ERROR (Status) || BufferSize == 0) {
 597         break;
 598       }
 599
 600       if ((DirInfo->Attribute & EFI_FILE_DIRECTORY && Pass == 2) ||
 601           (!(DirInfo->Attribute & EFI_FILE_DIRECTORY) && Pass == 1)
 602           ) {
 603         //
 604         // Pass 1 is for Directories
 605         // Pass 2 is for file names
 606         //
 607         continue;
 608       }
 609
 610       if (!(BOpt_IsEfiImageName (DirInfo->FileName) || DirInfo->Attribute & EFI_FILE_DIRECTORY)) {
 611         //
 612         // Slip file unless it is a directory entry or a .EFI file
 613         //
 614         continue;
 615       }
 616
 617       NewMenuEntry = BOpt_CreateMenuEntry (BM_FILE_CONTEXT_SELECT);
 618       if (NULL == NewMenuEntry) {
 619         return EFI_OUT_OF_RESOURCES;
 620       }
 621
 622       NewFileContext          = (BM_FILE_CONTEXT *) NewMenuEntry->VariableContext;
 623       NewFileContext->Handle  = FileContext->Handle;
 624       NewFileContext->FileName = BOpt_AppendFileName (
 625                                   FileContext->FileName,
 626                                   DirInfo->FileName
 627                                   );
 628       NewFileContext->FHandle = NewDir;
 629       NewFileContext->DevicePath = FileDevicePath (
 630                                     NewFileContext->Handle,
 631                                     NewFileContext->FileName
 632                                     );
 633       NewMenuEntry->HelpString = NULL;
 634
 635       MenuEntry->DisplayStringToken = GetStringTokenFromDepository (
 636                                         CallbackData,
 637                                         FileOptionStrDepository
 638                                         );
 639
 640       NewFileContext->IsDir = (BOOLEAN) ((DirInfo->Attribute & EFI_FILE_DIRECTORY) == EFI_FILE_DIRECTORY);
 641
 642       if (NewFileContext->IsDir) {
 643         BufferSize                  = StrLen (DirInfo->FileName) * 2 + 6;
 644         NewMenuEntry->DisplayString = AllocateZeroPool (BufferSize);
 645
 646         UnicodeSPrint (
 647           NewMenuEntry->DisplayString,
 648           BufferSize,
 649           L"<%s>",
 650           DirInfo->FileName
 651           );
 652
 653       } else {
 654         NewMenuEntry->DisplayString = EfiStrDuplicate (DirInfo->FileName);
 655       }
 656
 657       NewFileContext->IsRoot            = FALSE;
 658       NewFileContext->IsLoadFile        = FALSE;
 659       NewFileContext->IsRemovableMedia  = FALSE;
 660
 661       NewMenuEntry->OptionNumber        = OptionNumber;
 662       OptionNumber++;
 663       InsertTailList (&DirectoryMenu.Head, &NewMenuEntry->Link);
 664     }
 665   }
 666
 667   DirectoryMenu.MenuNumber = OptionNumber;
 668   SafeFreePool (DirInfo);
 669   return TRUE;
 670 }
 671
 672 EFI_STATUS
 673 BOpt_GetLegacyOptions (
 674   VOID
 675   )
 676 /*++
 677 Routine Description:
 678
 679   Build the LegacyFDMenu LegacyHDMenu LegacyCDMenu according to LegacyBios.GetBbsInfo().
 680
 681 Arguments:
 682   None
 683
 684 Returns:
 685   The device info of legacy device.
 686
 687 --*/
 688 {
 689   BM_MENU_ENTRY             *NewMenuEntry;
 690   BM_LEGACY_DEVICE_CONTEXT  *NewLegacyDevContext;
 691   EFI_STATUS                Status;
 692   EFI_LEGACY_BIOS_PROTOCOL  *LegacyBios;
 693   UINT16                    HddCount;
 694   HDD_INFO                  *HddInfo;
 695   UINT16                    BbsCount;
 696   BBS_TABLE                 *BbsTable;
 697   UINTN                     Index;
 698   CHAR16                    DescString[100];
 699   UINTN                     FDNum;
 700   UINTN                     HDNum;
 701   UINTN                     CDNum;
 702   UINTN                     NETNum;
 703   UINTN                     BEVNum;
 704
 705   NewMenuEntry  = NULL;
 706   HddInfo       = NULL;
 707   BbsTable      = NULL;
 708   BbsCount      = 0;
 709
 710   //
 711   // Initialize Bbs Table Context from BBS info data
 712   //
 713   InitializeListHead (&LegacyFDMenu.Head);
 714   InitializeListHead (&LegacyHDMenu.Head);
 715   InitializeListHead (&LegacyCDMenu.Head);
 716   InitializeListHead (&LegacyNETMenu.Head);
 717   InitializeListHead (&LegacyBEVMenu.Head);
 718
 719   Status = gBS->LocateProtocol (
 720                   &gEfiLegacyBiosProtocolGuid,
 721                   NULL,
 722                   &LegacyBios
 723                   );
 724   if (!EFI_ERROR (Status)) {
 725     Status = LegacyBios->GetBbsInfo (
 726                           LegacyBios,
 727                           &HddCount,
 728                           &HddInfo,
 729                           &BbsCount,
 730                           &BbsTable
 731                           );
 732     if (EFI_ERROR (Status)) {
 733       return Status;
 734     }
 735   }
 736
 737   FDNum   = 0;
 738   HDNum   = 0;
 739   CDNum   = 0;
 740   NETNum  = 0;
 741   BEVNum  = 0;
 742
 743   for (Index = 0; Index < BbsCount; Index++) {
 744     if ((BBS_IGNORE_ENTRY == BbsTable[Index].BootPriority) ||
 745         (BBS_DO_NOT_BOOT_FROM == BbsTable[Index].BootPriority) ||
 746         (BBS_LOWEST_PRIORITY == BbsTable[Index].BootPriority)
 747         ) {
 748       continue;
 749     }
 750
 751     NewMenuEntry = BOpt_CreateMenuEntry (BM_LEGACY_DEV_CONTEXT_SELECT);
 752     if (NULL == NewMenuEntry) {
 753       break;
 754     }
 755
 756     NewLegacyDevContext           = (BM_LEGACY_DEVICE_CONTEXT *) NewMenuEntry->VariableContext;
 757     NewLegacyDevContext->BbsTable = &BbsTable[Index];
 758     NewLegacyDevContext->Index    = Index;
 759     NewLegacyDevContext->BbsCount = BbsCount;
 760     BdsBuildLegacyDevNameString (
 761       &BbsTable[Index],
 762       Index,
 763       sizeof (DescString),
 764       DescString
 765       );
 766     NewLegacyDevContext->Description = AllocateZeroPool (StrSize (DescString));
 767     if (NULL == NewLegacyDevContext->Description) {
 768       break;
 769     }
 770
 771     CopyMem (NewLegacyDevContext->Description, DescString, StrSize (DescString));
 772     NewMenuEntry->DisplayString = NewLegacyDevContext->Description;
 773     NewMenuEntry->HelpString    = NULL;
 774
 775     switch (BbsTable[Index].DeviceType) {
 776     case BBS_FLOPPY:
 777       InsertTailList (&LegacyFDMenu.Head, &NewMenuEntry->Link);
 778       FDNum++;
 779       break;
 780
 781     case BBS_HARDDISK:
 782       InsertTailList (&LegacyHDMenu.Head, &NewMenuEntry->Link);
 783       HDNum++;
 784       break;
 785
 786     case BBS_CDROM:
 787       InsertTailList (&LegacyCDMenu.Head, &NewMenuEntry->Link);
 788       CDNum++;
 789       break;
 790
 791     case BBS_EMBED_NETWORK:
 792       InsertTailList (&LegacyNETMenu.Head, &NewMenuEntry->Link);
 793       NETNum++;
 794       break;
 795
 796     case BBS_BEV_DEVICE:
 797       InsertTailList (&LegacyBEVMenu.Head, &NewMenuEntry->Link);
 798       BEVNum++;
 799       break;
 800     }
 801   }
 802
 803   if (Index != BbsCount) {
 804     BOpt_FreeLegacyOptions ();
 805     return EFI_OUT_OF_RESOURCES;
 806   }
 807
 808   LegacyFDMenu.MenuNumber   = FDNum;
 809   LegacyHDMenu.MenuNumber   = HDNum;
 810   LegacyCDMenu.MenuNumber   = CDNum;
 811   LegacyNETMenu.MenuNumber  = NETNum;
 812   LegacyBEVMenu.MenuNumber  = BEVNum;
 813   return EFI_SUCCESS;
 814 }
 815
 816 VOID
 817 BOpt_FreeLegacyOptions (
 818   VOID
 819   )
 820 {
 821   BOpt_FreeMenu (&LegacyFDMenu);
 822   BOpt_FreeMenu (&LegacyHDMenu);
 823   BOpt_FreeMenu (&LegacyCDMenu);
 824   BOpt_FreeMenu (&LegacyNETMenu);
 825   BOpt_FreeMenu (&LegacyBEVMenu);
 826 }
 827
 828 EFI_STATUS
 829 BOpt_GetBootOptions (
 830   IN  BMM_CALLBACK_DATA         *CallbackData
 831   )
 832 /*++
 833
 834 Routine Description:
 835
 836   Build the BootOptionMenu according to BootOrder Variable.
 837   This Routine will access the Boot#### to get EFI_LOAD_OPTION
 838
 839 Arguments:
 840   None
 841
 842 Returns:
 843   The number of the Var Boot####
 844
 845 --*/
 846 {
 847   UINTN                     Index;
 848   UINT16                    BootString[10];
 849   UINT8                     *LoadOptionFromVar;
 850   UINT8                     *LoadOption;
 851   UINTN                     BootOptionSize;
 852   BOOLEAN                   BootNextFlag;
 853   UINT16                    *BootOrderList;
 854   UINTN                     BootOrderListSize;
 855   UINT16                    *BootNext;
 856   UINTN                     BootNextSize;
 857   BM_MENU_ENTRY             *NewMenuEntry;
 858   BM_LOAD_CONTEXT           *NewLoadContext;
 859   UINT8                     *LoadOptionPtr;
 860   UINTN                     StringSize;
 861   UINTN                     OptionalDataSize;
 862   UINT8                     *LoadOptionEnd;
 863   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 864   UINTN                     MenuCount;
 865   UINT8                     *Ptr;
 866
 867   MenuCount         = 0;
 868   BootOrderListSize = 0;
 869   BootNextSize      = 0;
 870   BootOrderList     = NULL;
 871   BootNext          = NULL;
 872   LoadOptionFromVar = NULL;
 873   BOpt_FreeMenu (&BootOptionMenu);
 874   InitializeListHead (&BootOptionMenu.Head);
 875
 876   //
 877   // Get the BootOrder from the Var
 878   //
 879   BootOrderList = BdsLibGetVariableAndSize (
 880                     L"BootOrder",
 881                     &gEfiGlobalVariableGuid,
 882                     &BootOrderListSize
 883                     );
 884
 885   //
 886   // Get the BootNext from the Var
 887   //
 888   BootNext = BdsLibGetVariableAndSize (
 889               L"BootNext",
 890               &gEfiGlobalVariableGuid,
 891               &BootNextSize
 892               );
 893
 894   if (BootNext) {
 895     if (BootNextSize != sizeof (UINT16)) {
 896       SafeFreePool (BootNext);
 897       BootNext = NULL;
 898     }
 899   }
 900
 901   for (Index = 0; Index < BootOrderListSize / sizeof (UINT16); Index++) {
 902     UnicodeSPrint (BootString, sizeof (BootString), L"Boot%04x", BootOrderList[Index]);
 903     //
 904     //  Get all loadoptions from the VAR
 905     //
 906     LoadOptionFromVar = BdsLibGetVariableAndSize (
 907                           BootString,
 908                           &gEfiGlobalVariableGuid,
 909                           &BootOptionSize
 910                           );
 911     if (!LoadOptionFromVar) {
 912       continue;
 913     }
 914
 915     LoadOption = AllocateZeroPool (BootOptionSize);
 916     if (!LoadOption) {
 917       continue;
 918     }
 919
 920     CopyMem (LoadOption, LoadOptionFromVar, BootOptionSize);
 921     SafeFreePool (LoadOptionFromVar);
 922
 923     if (BootNext) {
 924       BootNextFlag = (BOOLEAN) (*BootNext == BootOrderList[Index]);
 925     } else {
 926       BootNextFlag = FALSE;
 927     }
 928
 929     if (0 == (*((UINT32 *) LoadOption) & LOAD_OPTION_ACTIVE)) {
 930       SafeFreePool (LoadOption);
 931       continue;
 932     }
 933     //
 934     // BUGBUG: could not return EFI_OUT_OF_RESOURCES here directly.
 935     // the buffer allocated already should be freed before returning.
 936     //
 937     NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
 938     if (NULL == NewMenuEntry) {
 939       return EFI_OUT_OF_RESOURCES;
 940     }
 941
 942     NewLoadContext                      = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
 943
 944     LoadOptionPtr                       = LoadOption;
 945     LoadOptionEnd                       = LoadOption + BootOptionSize;
 946
 947     NewMenuEntry->OptionNumber          = BootOrderList[Index];
 948     NewLoadContext->LoadOptionModified  = FALSE;
 949     NewLoadContext->Deleted             = FALSE;
 950     NewLoadContext->IsBootNext          = BootNextFlag;
 951
 952     //
 953     // Is a Legacy Device?
 954     //
 955     Ptr = (UINT8 *) LoadOption;
 956
 957     //
 958     // Attribute = *(UINT32 *)Ptr;
 959     //
 960     Ptr += sizeof (UINT32);
 961
 962     //
 963     // FilePathSize = *(UINT16 *)Ptr;
 964     //
 965     Ptr += sizeof (UINT16);
 966
 967     //
 968     // Description = (CHAR16 *)Ptr;
 969     //
 970     Ptr += StrSize ((CHAR16 *) Ptr);
 971
 972     //
 973     // Now Ptr point to Device Path
 974     //
 975     DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) Ptr;
 976     if ((BBS_DEVICE_PATH == DevicePath->Type) && (BBS_BBS_DP == DevicePath->SubType)) {
 977       NewLoadContext->IsLegacy = TRUE;
 978     } else {
 979       NewLoadContext->IsLegacy = FALSE;
 980     }
 981     //
 982     // LoadOption is a pointer type of UINT8
 983     // for easy use with following LOAD_OPTION
 984     // embedded in this struct
 985     //
 986     NewLoadContext->LoadOption      = LoadOption;
 987     NewLoadContext->LoadOptionSize  = BootOptionSize;
 988
 989     NewLoadContext->Attributes      = *(UINT32 *) LoadOptionPtr;
 990     NewLoadContext->IsActive        = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_ACTIVE);
 991
 992     NewLoadContext->ForceReconnect  = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_FORCE_RECONNECT);
 993
 994     LoadOptionPtr += sizeof (UINT32);
 995
 996     NewLoadContext->FilePathListLength = *(UINT16 *) LoadOptionPtr;
 997     LoadOptionPtr += sizeof (UINT16);
 998
 999     StringSize                  = StrSize ((UINT16 *) LoadOptionPtr);
1000     NewLoadContext->Description = AllocateZeroPool (StringSize);
1001     ASSERT (NewLoadContext->Description != NULL);
1002     CopyMem (
1003       NewLoadContext->Description,
1004       (UINT16 *) LoadOptionPtr,
1005       StringSize
1006       );
1007     NewMenuEntry->DisplayString = NewLoadContext->Description;
1008
1009     LoadOptionPtr += StringSize;
1010
1011     NewLoadContext->FilePathList = AllocateZeroPool (NewLoadContext->FilePathListLength);
1012     ASSERT (NewLoadContext->FilePathList != NULL);
1013     CopyMem (
1014       NewLoadContext->FilePathList,
1015       (EFI_DEVICE_PATH_PROTOCOL *) LoadOptionPtr,
1016       NewLoadContext->FilePathListLength
1017       );
1018
1019     NewMenuEntry->HelpString = DevicePathToStr (NewLoadContext->FilePathList);
1020     NewMenuEntry->DisplayStringToken = GetStringTokenFromDepository (
1021                                         CallbackData,
1022                                         BootOptionStrDepository
1023                                         );
1024     NewMenuEntry->HelpStringToken = GetStringTokenFromDepository (
1025                                       CallbackData,
1026                                       BootOptionHelpStrDepository
1027                                       );
1028     LoadOptionPtr += NewLoadContext->FilePathListLength;
1029
1030     if (LoadOptionPtr < LoadOptionEnd) {
1031       OptionalDataSize = BootOptionSize -
1032         sizeof (UINT32) -
1033         sizeof (UINT16) -
1034         StringSize -
1035         NewLoadContext->FilePathListLength;
1036
1037       NewLoadContext->OptionalData = AllocateZeroPool (OptionalDataSize);
1038       ASSERT (NewLoadContext->OptionalData != NULL);
1039       CopyMem (
1040         NewLoadContext->OptionalData,
1041         LoadOptionPtr,
1042         OptionalDataSize
1043         );
1044
1045       NewLoadContext->OptionalDataSize = OptionalDataSize;
1046     }
1047
1048     InsertTailList (&BootOptionMenu.Head, &NewMenuEntry->Link);
1049     MenuCount++;
1050   }
1051
1052   SafeFreePool (BootNext);
1053   SafeFreePool (BootOrderList);
1054   BootOptionMenu.MenuNumber = MenuCount;
1055   return MenuCount;
1056 }
1057
1058 CHAR16 *
1059 BOpt_AppendFileName (
1060   IN  CHAR16  *Str1,
1061   IN  CHAR16  *Str2
1062   )
1063 /*++
1064
1065 Routine Description
1066   Append file name to existing file name.
1067
1068 Arguments:
1069   Str1  -   existing file name
1070   Str2  -   file name to be appended
1071
1072 Returns:
1073   Allocate a new string to hold the appended result.
1074   Caller is responsible to free the returned string.
1075
1076 --*/
1077 {
1078   UINTN   Size1;
1079   UINTN   Size2;
1080   CHAR16  *Str;
1081   CHAR16  *Ptr;
1082   CHAR16  *LastSlash;
1083
1084   Size1 = StrSize (Str1);
1085   Size2 = StrSize (Str2);
1086   Str   = AllocateZeroPool (Size1 + Size2 + sizeof (CHAR16));
1087   ASSERT (Str != NULL);
1088
1089   StrCat (Str, Str1);
1090   if (!((*Str == '\\') && (*(Str + 1) == 0))) {
1091     StrCat (Str, L"\\");
1092   }
1093
1094   StrCat (Str, Str2);
1095
1096   Ptr       = Str;
1097   LastSlash = Str;
1098   while (*Ptr != 0) {
1099     if (*Ptr == '\\' && *(Ptr + 1) == '.' && *(Ptr + 2) == '.' && *(Ptr + 3) != 0) {
1100       //
1101       // Convert \Name\..\ to \
1102       // DO NOT convert the .. if it is at the end of the string. This will
1103       // break the .. behavior in changing directories.
1104       //
1105       StrCpy (LastSlash, Ptr + 3);
1106       Ptr = LastSlash;
1107     } else if (*Ptr == '\\' && *(Ptr + 1) == '.' && *(Ptr + 2) == '\\') {
1108       //
1109       // Convert a \.\ to a \
1110       //
1111       StrCpy (Ptr, Ptr + 2);
1112       Ptr = LastSlash;
1113     } else if (*Ptr == '\\') {
1114       LastSlash = Ptr;
1115     }
1116
1117     Ptr++;
1118   }
1119
1120   return Str;
1121 }
1122
1123 BOOLEAN
1124 BOpt_IsEfiImageName (
1125   IN UINT16  *FileName
1126   )
1127 /*++
1128
1129 Routine Description
1130   Check whether current FileName point to a valid
1131   Efi Image File.
1132
1133 Arguments:
1134   FileName  -   File need to be checked.
1135
1136 Returns:
1137   TRUE  -   Is Efi Image
1138   FALSE -   Not a valid Efi Image
1139
1140 --*/
1141 {
1142   //
1143   // Search for ".efi" extension
1144   //
1145   while (*FileName) {
1146     if (FileName[0] == '.') {
1147       if (FileName[1] == 'e' || FileName[1] == 'E') {
1148         if (FileName[2] == 'f' || FileName[2] == 'F') {
1149           if (FileName[3] == 'i' || FileName[3] == 'I') {
1150             return TRUE;
1151           } else if (FileName[3] == 0x0000) {
1152             return FALSE;
1153           }
1154         } else if (FileName[2] == 0x0000) {
1155           return FALSE;
1156         }
1157       } else if (FileName[1] == 0x0000) {
1158         return FALSE;
1159       }
1160     }
1161
1162     FileName += 1;
1163   }
1164
1165   return FALSE;
1166 }
1167
1168
1169 RETURN_STATUS
1170 EFIAPI
1171 IsEfiAppReadFromFile (
1172   IN     VOID    *FileHandle,
1173   IN     UINTN   FileOffset,
1174   IN OUT UINTN   *ReadSize,
1175   OUT    VOID    *Buffer
1176   )
1177 {
1178   EFI_STATUS        Status;
1179   EFI_FILE_HANDLE   File;
1180
1181   File = (EFI_FILE_HANDLE)FileHandle;
1182   Status = File->SetPosition (File, FileOffset);
1183   if (EFI_ERROR (Status)) {
1184     return Status;
1185   }
1186
1187   return File->Read (File, ReadSize, Buffer);
1188 }
1189
1190
1191
1192 BOOLEAN
1193 BOpt_IsEfiApp (
1194   IN EFI_FILE_HANDLE Dir,
1195   IN UINT16          *FileName
1196   )
1197 /*++
1198
1199 Routine Description:
1200   Check whether current FileName point to a valid Efi Application
1201
1202 Arguments:
1203   Dir       -   Pointer to current Directory
1204   FileName  -   Pointer to current File name.
1205
1206 Returns:
1207   TRUE      -   Is a valid Efi Application
1208   FALSE     -   not a valid Efi Application
1209
1210 --*/
1211 {
1212   EFI_STATUS                            Status;
1213   PE_COFF_LOADER_IMAGE_CONTEXT          ImageContext;
1214   EFI_FILE_HANDLE                       File;
1215
1216   Status = Dir->Open (Dir, &File, FileName, EFI_FILE_MODE_READ, 0);
1217   if (EFI_ERROR (Status)) {
1218     return FALSE;
1219   }
1220
1221   ZeroMem (&ImageContext, sizeof (ImageContext));
1222   ImageContext.Handle    = (VOID *)File;
1223   ImageContext.ImageRead = IsEfiAppReadFromFile;
1224
1225   Status = PeCoffLoaderGetImageInfo (&ImageContext);
1226   File->Close (File);
1227   if (EFI_ERROR (Status)) {
1228     return FALSE;
1229   }
1230
1231   if (ImageContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) {
1232     return TRUE;
1233   } else {
1234     return FALSE;
1235   }
1236  }
1237
1238
1239 EFI_STATUS
1240 BOpt_FindDrivers (
1241   VOID
1242   )
1243 /*++
1244
1245 Routine Description
1246   Find drivers that will be added as Driver#### variables from handles
1247   in current system environment
1248   All valid handles in the system except those consume SimpleFs, LoadFile
1249   are stored in DriverMenu for future use.
1250
1251 Arguments:
1252   None
1253
1254 Returns:
1255   EFI_SUCCESS
1256   Others
1257
1258 --*/
1259 {
1260   UINTN                           NoDevicePathHandles;
1261   EFI_HANDLE                      *DevicePathHandle;
1262   UINTN                           Index;
1263   EFI_STATUS                      Status;
1264   BM_MENU_ENTRY                   *NewMenuEntry;
1265   BM_HANDLE_CONTEXT               *NewHandleContext;
1266   EFI_HANDLE                      CurHandle;
1267   UINTN                           OptionNumber;
1268   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SimpleFs;
1269   EFI_LOAD_FILE_PROTOCOL          *LoadFile;
1270
1271   SimpleFs  = NULL;
1272   LoadFile  = NULL;
1273
1274   InitializeListHead (&DriverMenu.Head);
1275
1276   //
1277   // At first, get all handles that support Device Path
1278   // protocol which is the basic requirement for
1279   // Driver####
1280   //
1281   Status = gBS->LocateHandleBuffer (
1282                   ByProtocol,
1283                   &gEfiDevicePathProtocolGuid,
1284                   NULL,
1285                   &NoDevicePathHandles,
1286                   &DevicePathHandle
1287                   );
1288   if (EFI_ERROR (Status)) {
1289     return Status;
1290   }
1291
1292   OptionNumber = 0;
1293   for (Index = 0; Index < NoDevicePathHandles; Index++) {
1294     CurHandle = DevicePathHandle[Index];
1295
1296     //
1297     //  Check whether this handle support
1298     //  driver binding
1299     //
1300     Status = gBS->HandleProtocol (
1301                     CurHandle,
1302                     &gEfiSimpleFileSystemProtocolGuid,
1303                     &SimpleFs
1304                     );
1305     if (Status == EFI_SUCCESS) {
1306       continue;
1307     }
1308
1309     Status = gBS->HandleProtocol (
1310                     CurHandle,
1311                     &gEfiLoadFileProtocolGuid,
1312                     &LoadFile
1313                     );
1314     if (Status == EFI_SUCCESS) {
1315       continue;
1316     }
1317
1318     NewMenuEntry = BOpt_CreateMenuEntry (BM_HANDLE_CONTEXT_SELECT);
1319     if (NULL == NewMenuEntry) {
1320       return EFI_OUT_OF_RESOURCES;
1321     }
1322
1323     NewHandleContext              = (BM_HANDLE_CONTEXT *) NewMenuEntry->VariableContext;
1324     NewHandleContext->Handle      = CurHandle;
1325     NewHandleContext->DevicePath  = DevicePathFromHandle (CurHandle);
1326     NewMenuEntry->DisplayString = DevicePathToStr (NewHandleContext->DevicePath);
1327     NewMenuEntry->HelpString    = NULL;
1328     NewMenuEntry->OptionNumber  = OptionNumber;
1329     OptionNumber++;
1330     InsertTailList (&DriverMenu.Head, &NewMenuEntry->Link);
1331
1332   }
1333
1334   DriverMenu.MenuNumber = OptionNumber;
1335   return EFI_SUCCESS;
1336 }
1337
1338 UINT16
1339 BOpt_GetBootOptionNumber (
1340   VOID
1341   )
1342 /*++
1343
1344 Routine Description:
1345   Get the Option Number that does not used
1346
1347 Arguments:
1348
1349 Returns:
1350   The Option Number
1351
1352 --*/
1353 {
1354   BM_MENU_ENTRY *NewMenuEntry;
1355   UINT16        *BootOrderList;
1356   UINTN         BootOrderListSize;
1357   UINT16        Number;
1358   UINTN         Index;
1359   UINTN         Index2;
1360   BOOLEAN       Found;
1361   CHAR16        StrTemp[100];
1362   UINT16        *OptionBuffer;
1363   UINTN         OptionSize;
1364
1365   BootOrderListSize = 0;
1366   BootOrderList     = NULL;
1367
1368   BootOrderList = BdsLibGetVariableAndSize (
1369                     L"BootOrder",
1370                     &gEfiGlobalVariableGuid,
1371                     &BootOrderListSize
1372                     );
1373   if (BootOrderList) {
1374     //
1375     // already have Boot####
1376     //
1377     // AlreadyBootNumbers = BootOrderListSize / sizeof(UINT16);
1378     //
1379     for (Index = 0; Index < BootOrderListSize / sizeof (UINT16); Index++) {
1380       Found = TRUE;
1381       for (Index2 = 0; Index2 < BootOptionMenu.MenuNumber; Index2++) {
1382         NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index2);
1383         if (Index == NewMenuEntry->OptionNumber) {
1384           Found = FALSE;
1385           break;
1386         }
1387       }
1388
1389       if (Found) {
1390            UnicodeSPrint (StrTemp, 100, L"Boot%04x", Index);
1391            DEBUG((EFI_D_ERROR,"INdex= %s\n", StrTemp));
1392        OptionBuffer = BdsLibGetVariableAndSize (
1393                 StrTemp,
1394                 &gEfiGlobalVariableGuid,
1395                 &OptionSize
1396                 );
1397       if (NULL == OptionBuffer)
1398         break;
1399       }
1400     }
1401     //
1402     // end for Index
1403     //
1404     Number = (UINT16) Index;
1405   } else {
1406     //
1407     // No Boot####
1408     //
1409     Number = 0;
1410   }
1411
1412   return Number;
1413 }
1414
1415 UINT16
1416 BOpt_GetDriverOptionNumber (
1417   VOID
1418   )
1419 /*++
1420
1421 Routine Description:
1422   Get the Option Number that does not used
1423
1424 Arguments:
1425
1426 Returns:
1427   The Option Number
1428
1429 --*/
1430 {
1431   BM_MENU_ENTRY *NewMenuEntry;
1432   UINT16        *DriverOrderList;
1433   UINTN         DriverOrderListSize;
1434   UINT16        Number;
1435   UINTN         Index;
1436   UINTN         Index2;
1437   BOOLEAN       Found;
1438
1439   DriverOrderListSize = 0;
1440   DriverOrderList     = NULL;
1441
1442   DriverOrderList = BdsLibGetVariableAndSize (
1443                       L"DriverOrder",
1444                       &gEfiGlobalVariableGuid,
1445                       &DriverOrderListSize
1446                       );
1447   if (DriverOrderList) {
1448     //
1449     // already have Driver####
1450     //
1451     // AlreadyDriverNumbers = DriverOrderListSize / sizeof(UINT16);
1452     //
1453     for (Index = 0; Index < DriverOrderListSize / sizeof (UINT16); Index++) {
1454       Found = TRUE;
1455       for (Index2 = 0; Index2 < DriverOptionMenu.MenuNumber; Index2++) {
1456         NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, Index2);
1457         if (Index == NewMenuEntry->OptionNumber) {
1458           Found = FALSE;
1459           break;
1460         }
1461       }
1462
1463       if (Found) {
1464         break;
1465       }
1466     }
1467     //
1468     // end for Index
1469     //
1470     Number = (UINT16) Index;
1471   } else {
1472     //
1473     // No Driver####
1474     //
1475     Number = 0;
1476   }
1477
1478   return Number;
1479 }
1480
1481 EFI_STATUS
1482 BOpt_GetDriverOptions (
1483   IN  BMM_CALLBACK_DATA         *CallbackData
1484   )
1485 /*++
1486
1487 Routine Description:
1488   Build up all DriverOptionMenu
1489
1490 Arguments:
1491
1492 Returns:
1493   The Option Number
1494
1495 --*/
1496 {
1497   UINTN           Index;
1498   UINT16          DriverString[12];
1499   UINT8           *LoadOptionFromVar;
1500   UINT8           *LoadOption;
1501   UINTN           DriverOptionSize;
1502
1503   UINT16          *DriverOrderList;
1504   UINTN           DriverOrderListSize;
1505   BM_MENU_ENTRY   *NewMenuEntry;
1506   BM_LOAD_CONTEXT *NewLoadContext;
1507   UINT8           *LoadOptionPtr;
1508   UINTN           StringSize;
1509   UINTN           OptionalDataSize;
1510   UINT8           *LoadOptionEnd;
1511
1512   DriverOrderListSize = 0;
1513   DriverOrderList     = NULL;
1514   DriverOptionSize    = 0;
1515   LoadOptionFromVar   = NULL;
1516   BOpt_FreeMenu (&DriverOptionMenu);
1517   InitializeListHead (&DriverOptionMenu.Head);
1518   //
1519   // Get the DriverOrder from the Var
1520   //
1521   DriverOrderList = BdsLibGetVariableAndSize (
1522                       L"DriverOrder",
1523                       &gEfiGlobalVariableGuid,
1524                       &DriverOrderListSize
1525                       );
1526
1527   for (Index = 0; Index < DriverOrderListSize / sizeof (UINT16); Index++) {
1528     UnicodeSPrint (
1529       DriverString,
1530       sizeof (DriverString),
1531       L"Driver%04x",
1532       DriverOrderList[Index]
1533       );
1534     //
1535     //  Get all loadoptions from the VAR
1536     //
1537     LoadOptionFromVar = BdsLibGetVariableAndSize (
1538                           DriverString,
1539                           &gEfiGlobalVariableGuid,
1540                           &DriverOptionSize
1541                           );
1542     if (!LoadOptionFromVar) {
1543       continue;
1544     }
1545
1546     LoadOption = AllocateZeroPool (DriverOptionSize);
1547     if (!LoadOption) {
1548       continue;
1549     }
1550
1551     CopyMem (LoadOption, LoadOptionFromVar, DriverOptionSize);
1552     SafeFreePool (LoadOptionFromVar);
1553
1554     NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
1555     if (NULL == NewMenuEntry) {
1556       return EFI_OUT_OF_RESOURCES;
1557     }
1558
1559     NewLoadContext                      = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
1560     LoadOptionPtr                       = LoadOption;
1561     LoadOptionEnd                       = LoadOption + DriverOptionSize;
1562     NewMenuEntry->OptionNumber          = DriverOrderList[Index];
1563     NewLoadContext->LoadOptionModified  = FALSE;
1564     NewLoadContext->Deleted             = FALSE;
1565     NewLoadContext->IsLegacy            = FALSE;
1566
1567     //
1568     // LoadOption is a pointer type of UINT8
1569     // for easy use with following LOAD_OPTION
1570     // embedded in this struct
1571     //
1572     NewLoadContext->LoadOption      = LoadOption;
1573     NewLoadContext->LoadOptionSize  = DriverOptionSize;
1574
1575     NewLoadContext->Attributes      = *(UINT32 *) LoadOptionPtr;
1576     NewLoadContext->IsActive        = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_ACTIVE);
1577
1578     NewLoadContext->ForceReconnect  = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_FORCE_RECONNECT);
1579
1580     LoadOptionPtr += sizeof (UINT32);
1581
1582     NewLoadContext->FilePathListLength = *(UINT16 *) LoadOptionPtr;
1583     LoadOptionPtr += sizeof (UINT16);
1584
1585     StringSize                  = StrSize ((UINT16 *) LoadOptionPtr);
1586     NewLoadContext->Description = AllocateZeroPool (StringSize);
1587     ASSERT (NewLoadContext->Description != NULL);
1588     CopyMem (
1589       NewLoadContext->Description,
1590       (UINT16 *) LoadOptionPtr,
1591       StringSize
1592       );
1593     NewMenuEntry->DisplayString = NewLoadContext->Description;
1594
1595     LoadOptionPtr += StringSize;
1596
1597     NewLoadContext->FilePathList = AllocateZeroPool (NewLoadContext->FilePathListLength);
1598     ASSERT (NewLoadContext->FilePathList != NULL);
1599     CopyMem (
1600       NewLoadContext->FilePathList,
1601       (EFI_DEVICE_PATH_PROTOCOL *) LoadOptionPtr,
1602       NewLoadContext->FilePathListLength
1603       );
1604
1605     NewMenuEntry->HelpString = DevicePathToStr (NewLoadContext->FilePathList);
1606     NewMenuEntry->DisplayStringToken = GetStringTokenFromDepository (
1607                                         CallbackData,
1608                                         DriverOptionStrDepository
1609                                         );
1610     NewMenuEntry->HelpStringToken = GetStringTokenFromDepository (
1611                                       CallbackData,
1612                                       DriverOptionHelpStrDepository
1613                                       );
1614     LoadOptionPtr += NewLoadContext->FilePathListLength;
1615
1616     if (LoadOptionPtr < LoadOptionEnd) {
1617       OptionalDataSize = DriverOptionSize -
1618         sizeof (UINT32) -
1619         sizeof (UINT16) -
1620         StringSize -
1621         NewLoadContext->FilePathListLength;
1622
1623       NewLoadContext->OptionalData = AllocateZeroPool (OptionalDataSize);
1624       ASSERT (NewLoadContext->OptionalData != NULL);
1625       CopyMem (
1626         NewLoadContext->OptionalData,
1627         LoadOptionPtr,
1628         OptionalDataSize
1629         );
1630
1631       NewLoadContext->OptionalDataSize = OptionalDataSize;
1632     }
1633
1634     InsertTailList (&DriverOptionMenu.Head, &NewMenuEntry->Link);
1635
1636   }
1637
1638   SafeFreePool (DriverOrderList);
1639   DriverOptionMenu.MenuNumber = Index;
1640   return EFI_SUCCESS;
1641
1642 }
1643
1644 VOID
1645 SafeFreePool (
1646   IN VOID    *Buffer
1647   )
1648 /*++
1649
1650 Routine Description:
1651   Wrap original FreePool gBS call
1652   in order to decrease code length
1653
1654 Arguments:
1655
1656 Returns:
1657
1658 --*/
1659 {
1660   if (Buffer != NULL) {
1661     gBS->FreePool (Buffer);
1662     Buffer = NULL;
1663   }
1664 }