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 BdsStrCpy (
1060   OUT     CHAR16                    *Destination,
1061   IN      CONST CHAR16              *Source
1062   )
1063 {
1064   CHAR16                            *ReturnValue;
1065
1066   //
1067   // Destination cannot be NULL
1068   //
1069   ASSERT (Destination != NULL);
1070
1071   ReturnValue = Destination;
1072   while (*Source) {
1073     *(Destination++) = *(Source++);
1074   }
1075   *Destination = 0;
1076   return ReturnValue;
1077 }
1078
1079 CHAR16 *
1080 BOpt_AppendFileName (
1081   IN  CHAR16  *Str1,
1082   IN  CHAR16  *Str2
1083   )
1084 /*++
1085
1086 Routine Description
1087   Append file name to existing file name.
1088
1089 Arguments:
1090   Str1  -   existing file name
1091   Str2  -   file name to be appended
1092
1093 Returns:
1094   Allocate a new string to hold the appended result.
1095   Caller is responsible to free the returned string.
1096
1097 --*/
1098 {
1099   UINTN   Size1;
1100   UINTN   Size2;
1101   CHAR16  *Str;
1102   CHAR16  *Ptr;
1103   CHAR16  *LastSlash;
1104
1105   Size1 = StrSize (Str1);
1106   Size2 = StrSize (Str2);
1107   Str   = AllocateZeroPool (Size1 + Size2 + sizeof (CHAR16));
1108   ASSERT (Str != NULL);
1109
1110   StrCat (Str, Str1);
1111   if (!((*Str == '\\') && (*(Str + 1) == 0))) {
1112     StrCat (Str, L"\\");
1113   }
1114
1115   StrCat (Str, Str2);
1116
1117   Ptr       = Str;
1118   LastSlash = Str;
1119   while (*Ptr != 0) {
1120     if (*Ptr == '\\' && *(Ptr + 1) == '.' && *(Ptr + 2) == '.' && *(Ptr + 3) != 0) {
1121       //
1122       // Convert \Name\..\ to \
1123       // DO NOT convert the .. if it is at the end of the string. This will
1124       // break the .. behavior in changing directories.
1125       //
1126       BdsStrCpy (LastSlash, Ptr + 3);
1127       Ptr = LastSlash;
1128     } else if (*Ptr == '\\' && *(Ptr + 1) == '.' && *(Ptr + 2) == '\\') {
1129       //
1130       // Convert a \.\ to a \
1131       //
1132       BdsStrCpy (Ptr, Ptr + 2);
1133       Ptr = LastSlash;
1134     } else if (*Ptr == '\\') {
1135       LastSlash = Ptr;
1136     }
1137
1138     Ptr++;
1139   }
1140
1141   return Str;
1142 }
1143
1144 BOOLEAN
1145 BOpt_IsEfiImageName (
1146   IN UINT16  *FileName
1147   )
1148 /*++
1149
1150 Routine Description
1151   Check whether current FileName point to a valid
1152   Efi Image File.
1153
1154 Arguments:
1155   FileName  -   File need to be checked.
1156
1157 Returns:
1158   TRUE  -   Is Efi Image
1159   FALSE -   Not a valid Efi Image
1160
1161 --*/
1162 {
1163   //
1164   // Search for ".efi" extension
1165   //
1166   while (*FileName) {
1167     if (FileName[0] == '.') {
1168       if (FileName[1] == 'e' || FileName[1] == 'E') {
1169         if (FileName[2] == 'f' || FileName[2] == 'F') {
1170           if (FileName[3] == 'i' || FileName[3] == 'I') {
1171             return TRUE;
1172           } else if (FileName[3] == 0x0000) {
1173             return FALSE;
1174           }
1175         } else if (FileName[2] == 0x0000) {
1176           return FALSE;
1177         }
1178       } else if (FileName[1] == 0x0000) {
1179         return FALSE;
1180       }
1181     }
1182
1183     FileName += 1;
1184   }
1185
1186   return FALSE;
1187 }
1188
1189
1190 RETURN_STATUS
1191 EFIAPI
1192 IsEfiAppReadFromFile (
1193   IN     VOID    *FileHandle,
1194   IN     UINTN   FileOffset,
1195   IN OUT UINTN   *ReadSize,
1196   OUT    VOID    *Buffer
1197   )
1198 {
1199   EFI_STATUS        Status;
1200   EFI_FILE_HANDLE   File;
1201
1202   File = (EFI_FILE_HANDLE)FileHandle;
1203   Status = File->SetPosition (File, FileOffset);
1204   if (EFI_ERROR (Status)) {
1205     return Status;
1206   }
1207
1208   return File->Read (File, ReadSize, Buffer);
1209 }
1210
1211
1212
1213 BOOLEAN
1214 BOpt_IsEfiApp (
1215   IN EFI_FILE_HANDLE Dir,
1216   IN UINT16          *FileName
1217   )
1218 /*++
1219
1220 Routine Description:
1221   Check whether current FileName point to a valid Efi Application
1222
1223 Arguments:
1224   Dir       -   Pointer to current Directory
1225   FileName  -   Pointer to current File name.
1226
1227 Returns:
1228   TRUE      -   Is a valid Efi Application
1229   FALSE     -   not a valid Efi Application
1230
1231 --*/
1232 {
1233   EFI_STATUS                            Status;
1234   PE_COFF_LOADER_IMAGE_CONTEXT          ImageContext;
1235   EFI_FILE_HANDLE                       File;
1236
1237   Status = Dir->Open (Dir, &File, FileName, EFI_FILE_MODE_READ, 0);
1238   if (EFI_ERROR (Status)) {
1239     return FALSE;
1240   }
1241
1242   ZeroMem (&ImageContext, sizeof (ImageContext));
1243   ImageContext.Handle    = (VOID *)File;
1244   ImageContext.ImageRead = IsEfiAppReadFromFile;
1245
1246   Status = PeCoffLoaderGetImageInfo (&ImageContext);
1247   File->Close (File);
1248   if (EFI_ERROR (Status)) {
1249     return FALSE;
1250   }
1251
1252   if (ImageContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) {
1253     return TRUE;
1254   } else {
1255     return FALSE;
1256   }
1257  }
1258
1259
1260 EFI_STATUS
1261 BOpt_FindDrivers (
1262   VOID
1263   )
1264 /*++
1265
1266 Routine Description
1267   Find drivers that will be added as Driver#### variables from handles
1268   in current system environment
1269   All valid handles in the system except those consume SimpleFs, LoadFile
1270   are stored in DriverMenu for future use.
1271
1272 Arguments:
1273   None
1274
1275 Returns:
1276   EFI_SUCCESS
1277   Others
1278
1279 --*/
1280 {
1281   UINTN                           NoDevicePathHandles;
1282   EFI_HANDLE                      *DevicePathHandle;
1283   UINTN                           Index;
1284   EFI_STATUS                      Status;
1285   BM_MENU_ENTRY                   *NewMenuEntry;
1286   BM_HANDLE_CONTEXT               *NewHandleContext;
1287   EFI_HANDLE                      CurHandle;
1288   UINTN                           OptionNumber;
1289   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SimpleFs;
1290   EFI_LOAD_FILE_PROTOCOL          *LoadFile;
1291
1292   SimpleFs  = NULL;
1293   LoadFile  = NULL;
1294
1295   InitializeListHead (&DriverMenu.Head);
1296
1297   //
1298   // At first, get all handles that support Device Path
1299   // protocol which is the basic requirement for
1300   // Driver####
1301   //
1302   Status = gBS->LocateHandleBuffer (
1303                   ByProtocol,
1304                   &gEfiDevicePathProtocolGuid,
1305                   NULL,
1306                   &NoDevicePathHandles,
1307                   &DevicePathHandle
1308                   );
1309   if (EFI_ERROR (Status)) {
1310     return Status;
1311   }
1312
1313   OptionNumber = 0;
1314   for (Index = 0; Index < NoDevicePathHandles; Index++) {
1315     CurHandle = DevicePathHandle[Index];
1316
1317     //
1318     //  Check whether this handle support
1319     //  driver binding
1320     //
1321     Status = gBS->HandleProtocol (
1322                     CurHandle,
1323                     &gEfiSimpleFileSystemProtocolGuid,
1324                     &SimpleFs
1325                     );
1326     if (Status == EFI_SUCCESS) {
1327       continue;
1328     }
1329
1330     Status = gBS->HandleProtocol (
1331                     CurHandle,
1332                     &gEfiLoadFileProtocolGuid,
1333                     &LoadFile
1334                     );
1335     if (Status == EFI_SUCCESS) {
1336       continue;
1337     }
1338
1339     NewMenuEntry = BOpt_CreateMenuEntry (BM_HANDLE_CONTEXT_SELECT);
1340     if (NULL == NewMenuEntry) {
1341       return EFI_OUT_OF_RESOURCES;
1342     }
1343
1344     NewHandleContext              = (BM_HANDLE_CONTEXT *) NewMenuEntry->VariableContext;
1345     NewHandleContext->Handle      = CurHandle;
1346     NewHandleContext->DevicePath  = DevicePathFromHandle (CurHandle);
1347     NewMenuEntry->DisplayString = DevicePathToStr (NewHandleContext->DevicePath);
1348     NewMenuEntry->HelpString    = NULL;
1349     NewMenuEntry->OptionNumber  = OptionNumber;
1350     OptionNumber++;
1351     InsertTailList (&DriverMenu.Head, &NewMenuEntry->Link);
1352
1353   }
1354
1355   DriverMenu.MenuNumber = OptionNumber;
1356   return EFI_SUCCESS;
1357 }
1358
1359 UINT16
1360 BOpt_GetBootOptionNumber (
1361   VOID
1362   )
1363 /*++
1364
1365 Routine Description:
1366   Get the Option Number that does not used
1367
1368 Arguments:
1369
1370 Returns:
1371   The Option Number
1372
1373 --*/
1374 {
1375   BM_MENU_ENTRY *NewMenuEntry;
1376   UINT16        *BootOrderList;
1377   UINTN         BootOrderListSize;
1378   UINT16        Number;
1379   UINTN         Index;
1380   UINTN         Index2;
1381   BOOLEAN       Found;
1382   CHAR16        StrTemp[100];
1383   UINT16        *OptionBuffer;
1384   UINTN         OptionSize;
1385
1386   BootOrderListSize = 0;
1387   BootOrderList     = NULL;
1388
1389   BootOrderList = BdsLibGetVariableAndSize (
1390                     L"BootOrder",
1391                     &gEfiGlobalVariableGuid,
1392                     &BootOrderListSize
1393                     );
1394   if (BootOrderList) {
1395     //
1396     // already have Boot####
1397     //
1398     // AlreadyBootNumbers = BootOrderListSize / sizeof(UINT16);
1399     //
1400     for (Index = 0; Index < BootOrderListSize / sizeof (UINT16); Index++) {
1401       Found = TRUE;
1402       for (Index2 = 0; Index2 < BootOptionMenu.MenuNumber; Index2++) {
1403         NewMenuEntry = BOpt_GetMenuEntry (&BootOptionMenu, Index2);
1404         if (Index == NewMenuEntry->OptionNumber) {
1405           Found = FALSE;
1406           break;
1407         }
1408       }
1409
1410       if (Found) {
1411            UnicodeSPrint (StrTemp, 100, L"Boot%04x", Index);
1412            DEBUG((EFI_D_ERROR,"INdex= %s\n", StrTemp));
1413        OptionBuffer = BdsLibGetVariableAndSize (
1414                 StrTemp,
1415                 &gEfiGlobalVariableGuid,
1416                 &OptionSize
1417                 );
1418       if (NULL == OptionBuffer)
1419         break;
1420       }
1421     }
1422     //
1423     // end for Index
1424     //
1425     Number = (UINT16) Index;
1426   } else {
1427     //
1428     // No Boot####
1429     //
1430     Number = 0;
1431   }
1432
1433   return Number;
1434 }
1435
1436 UINT16
1437 BOpt_GetDriverOptionNumber (
1438   VOID
1439   )
1440 /*++
1441
1442 Routine Description:
1443   Get the Option Number that does not used
1444
1445 Arguments:
1446
1447 Returns:
1448   The Option Number
1449
1450 --*/
1451 {
1452   BM_MENU_ENTRY *NewMenuEntry;
1453   UINT16        *DriverOrderList;
1454   UINTN         DriverOrderListSize;
1455   UINT16        Number;
1456   UINTN         Index;
1457   UINTN         Index2;
1458   BOOLEAN       Found;
1459
1460   DriverOrderListSize = 0;
1461   DriverOrderList     = NULL;
1462
1463   DriverOrderList = BdsLibGetVariableAndSize (
1464                       L"DriverOrder",
1465                       &gEfiGlobalVariableGuid,
1466                       &DriverOrderListSize
1467                       );
1468   if (DriverOrderList) {
1469     //
1470     // already have Driver####
1471     //
1472     // AlreadyDriverNumbers = DriverOrderListSize / sizeof(UINT16);
1473     //
1474     for (Index = 0; Index < DriverOrderListSize / sizeof (UINT16); Index++) {
1475       Found = TRUE;
1476       for (Index2 = 0; Index2 < DriverOptionMenu.MenuNumber; Index2++) {
1477         NewMenuEntry = BOpt_GetMenuEntry (&DriverOptionMenu, Index2);
1478         if (Index == NewMenuEntry->OptionNumber) {
1479           Found = FALSE;
1480           break;
1481         }
1482       }
1483
1484       if (Found) {
1485         break;
1486       }
1487     }
1488     //
1489     // end for Index
1490     //
1491     Number = (UINT16) Index;
1492   } else {
1493     //
1494     // No Driver####
1495     //
1496     Number = 0;
1497   }
1498
1499   return Number;
1500 }
1501
1502 EFI_STATUS
1503 BOpt_GetDriverOptions (
1504   IN  BMM_CALLBACK_DATA         *CallbackData
1505   )
1506 /*++
1507
1508 Routine Description:
1509   Build up all DriverOptionMenu
1510
1511 Arguments:
1512
1513 Returns:
1514   The Option Number
1515
1516 --*/
1517 {
1518   UINTN           Index;
1519   UINT16          DriverString[12];
1520   UINT8           *LoadOptionFromVar;
1521   UINT8           *LoadOption;
1522   UINTN           DriverOptionSize;
1523
1524   UINT16          *DriverOrderList;
1525   UINTN           DriverOrderListSize;
1526   BM_MENU_ENTRY   *NewMenuEntry;
1527   BM_LOAD_CONTEXT *NewLoadContext;
1528   UINT8           *LoadOptionPtr;
1529   UINTN           StringSize;
1530   UINTN           OptionalDataSize;
1531   UINT8           *LoadOptionEnd;
1532
1533   DriverOrderListSize = 0;
1534   DriverOrderList     = NULL;
1535   DriverOptionSize    = 0;
1536   LoadOptionFromVar   = NULL;
1537   BOpt_FreeMenu (&DriverOptionMenu);
1538   InitializeListHead (&DriverOptionMenu.Head);
1539   //
1540   // Get the DriverOrder from the Var
1541   //
1542   DriverOrderList = BdsLibGetVariableAndSize (
1543                       L"DriverOrder",
1544                       &gEfiGlobalVariableGuid,
1545                       &DriverOrderListSize
1546                       );
1547
1548   for (Index = 0; Index < DriverOrderListSize / sizeof (UINT16); Index++) {
1549     UnicodeSPrint (
1550       DriverString,
1551       sizeof (DriverString),
1552       L"Driver%04x",
1553       DriverOrderList[Index]
1554       );
1555     //
1556     //  Get all loadoptions from the VAR
1557     //
1558     LoadOptionFromVar = BdsLibGetVariableAndSize (
1559                           DriverString,
1560                           &gEfiGlobalVariableGuid,
1561                           &DriverOptionSize
1562                           );
1563     if (!LoadOptionFromVar) {
1564       continue;
1565     }
1566
1567     LoadOption = AllocateZeroPool (DriverOptionSize);
1568     if (!LoadOption) {
1569       continue;
1570     }
1571
1572     CopyMem (LoadOption, LoadOptionFromVar, DriverOptionSize);
1573     SafeFreePool (LoadOptionFromVar);
1574
1575     NewMenuEntry = BOpt_CreateMenuEntry (BM_LOAD_CONTEXT_SELECT);
1576     if (NULL == NewMenuEntry) {
1577       return EFI_OUT_OF_RESOURCES;
1578     }
1579
1580     NewLoadContext                      = (BM_LOAD_CONTEXT *) NewMenuEntry->VariableContext;
1581     LoadOptionPtr                       = LoadOption;
1582     LoadOptionEnd                       = LoadOption + DriverOptionSize;
1583     NewMenuEntry->OptionNumber          = DriverOrderList[Index];
1584     NewLoadContext->LoadOptionModified  = FALSE;
1585     NewLoadContext->Deleted             = FALSE;
1586     NewLoadContext->IsLegacy            = FALSE;
1587
1588     //
1589     // LoadOption is a pointer type of UINT8
1590     // for easy use with following LOAD_OPTION
1591     // embedded in this struct
1592     //
1593     NewLoadContext->LoadOption      = LoadOption;
1594     NewLoadContext->LoadOptionSize  = DriverOptionSize;
1595
1596     NewLoadContext->Attributes      = *(UINT32 *) LoadOptionPtr;
1597     NewLoadContext->IsActive        = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_ACTIVE);
1598
1599     NewLoadContext->ForceReconnect  = (BOOLEAN) (NewLoadContext->Attributes & LOAD_OPTION_FORCE_RECONNECT);
1600
1601     LoadOptionPtr += sizeof (UINT32);
1602
1603     NewLoadContext->FilePathListLength = *(UINT16 *) LoadOptionPtr;
1604     LoadOptionPtr += sizeof (UINT16);
1605
1606     StringSize                  = StrSize ((UINT16 *) LoadOptionPtr);
1607     NewLoadContext->Description = AllocateZeroPool (StringSize);
1608     ASSERT (NewLoadContext->Description != NULL);
1609     CopyMem (
1610       NewLoadContext->Description,
1611       (UINT16 *) LoadOptionPtr,
1612       StringSize
1613       );
1614     NewMenuEntry->DisplayString = NewLoadContext->Description;
1615
1616     LoadOptionPtr += StringSize;
1617
1618     NewLoadContext->FilePathList = AllocateZeroPool (NewLoadContext->FilePathListLength);
1619     ASSERT (NewLoadContext->FilePathList != NULL);
1620     CopyMem (
1621       NewLoadContext->FilePathList,
1622       (EFI_DEVICE_PATH_PROTOCOL *) LoadOptionPtr,
1623       NewLoadContext->FilePathListLength
1624       );
1625
1626     NewMenuEntry->HelpString = DevicePathToStr (NewLoadContext->FilePathList);
1627     NewMenuEntry->DisplayStringToken = GetStringTokenFromDepository (
1628                                         CallbackData,
1629                                         DriverOptionStrDepository
1630                                         );
1631     NewMenuEntry->HelpStringToken = GetStringTokenFromDepository (
1632                                       CallbackData,
1633                                       DriverOptionHelpStrDepository
1634                                       );
1635     LoadOptionPtr += NewLoadContext->FilePathListLength;
1636
1637     if (LoadOptionPtr < LoadOptionEnd) {
1638       OptionalDataSize = DriverOptionSize -
1639         sizeof (UINT32) -
1640         sizeof (UINT16) -
1641         StringSize -
1642         NewLoadContext->FilePathListLength;
1643
1644       NewLoadContext->OptionalData = AllocateZeroPool (OptionalDataSize);
1645       ASSERT (NewLoadContext->OptionalData != NULL);
1646       CopyMem (
1647         NewLoadContext->OptionalData,
1648         LoadOptionPtr,
1649         OptionalDataSize
1650         );
1651
1652       NewLoadContext->OptionalDataSize = OptionalDataSize;
1653     }
1654
1655     InsertTailList (&DriverOptionMenu.Head, &NewMenuEntry->Link);
1656
1657   }
1658
1659   SafeFreePool (DriverOrderList);
1660   DriverOptionMenu.MenuNumber = Index;
1661   return EFI_SUCCESS;
1662
1663 }
1664
1665 VOID
1666 SafeFreePool (
1667   IN VOID    *Buffer
1668   )
1669 /*++
1670
1671 Routine Description:
1672   Wrap original FreePool gBS call
1673   in order to decrease code length
1674
1675 Arguments:
1676
1677 Returns:
1678
1679 --*/
1680 {
1681   if (Buffer != NULL) {
1682     gBS->FreePool (Buffer);
1683     Buffer = NULL;
1684   }
1685 }