ShellPkg/Library/UefiShellCommandLib/UefiShellCommandLib.c

   1 /** @file
   2   Provides interface to shell internal functions for shell commands.
   3
   4   Copyright (c) 2009 - 2016, Intel Corporation. All rights reserved.<BR>
   5   (C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR>
   6   (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
   7
   8   This program and the accompanying materials
   9   are licensed and made available under the terms and conditions of the BSD License
  10   which accompanies this distribution.  The full text of the license may be found at
  11   http://opensource.org/licenses/bsd-license.php
  12
  13   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  14   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  15
  16 **/
  17
  18 #include "UefiShellCommandLib.h"
  19
  20 // STATIC local variables
  21 STATIC SHELL_COMMAND_INTERNAL_LIST_ENTRY  mCommandList;
  22 STATIC SCRIPT_FILE_LIST                   mScriptList;
  23 STATIC ALIAS_LIST                         mAliasList;
  24 STATIC BOOLEAN                            mEchoState;
  25 STATIC BOOLEAN                            mExitRequested;
  26 STATIC UINT64                             mExitCode;
  27 STATIC BOOLEAN                            mExitScript;
  28 STATIC CHAR16                             *mProfileList;
  29 STATIC UINTN                              mProfileListSize;
  30 STATIC UINTN                              mFsMaxCount = 0;
  31 STATIC UINTN                              mBlkMaxCount = 0;
  32 STATIC BUFFER_LIST                        mFileHandleList;
  33
  34 STATIC CONST CHAR8 Hex[] = {
  35   '0',
  36   '1',
  37   '2',
  38   '3',
  39   '4',
  40   '5',
  41   '6',
  42   '7',
  43   '8',
  44   '9',
  45   'A',
  46   'B',
  47   'C',
  48   'D',
  49   'E',
  50   'F'
  51 };
  52
  53 // global variables required by library class.
  54 EFI_UNICODE_COLLATION_PROTOCOL    *gUnicodeCollation            = NULL;
  55 SHELL_MAP_LIST                    gShellMapList;
  56 SHELL_MAP_LIST                    *gShellCurDir                 = NULL;
  57
  58 CONST CHAR16* SupportLevel[] = {
  59   L"Minimal",
  60   L"Scripting",
  61   L"Basic",
  62   L"Interactive"
  63 };
  64
  65 /**
  66   Function to make sure that the global protocol pointers are valid.
  67   must be called after constructor before accessing the pointers.
  68 **/
  69 EFI_STATUS
  70 EFIAPI
  71 CommandInit(
  72   VOID
  73   )
  74 {
  75   EFI_STATUS Status;
  76   if (gUnicodeCollation == NULL) {
  77     Status = gBS->LocateProtocol(&gEfiUnicodeCollation2ProtocolGuid, NULL, (VOID**)&gUnicodeCollation);
  78     if (EFI_ERROR(Status)) {
  79       return (EFI_DEVICE_ERROR);
  80     }
  81   }
  82   return (EFI_SUCCESS);
  83 }
  84
  85 /**
  86   Constructor for the Shell Command library.
  87
  88   Initialize the library and determine if the underlying is a UEFI Shell 2.0 or an EFI shell.
  89
  90   @param ImageHandle    the image handle of the process
  91   @param SystemTable    the EFI System Table pointer
  92
  93   @retval EFI_SUCCESS   the initialization was complete sucessfully
  94 **/
  95 RETURN_STATUS
  96 EFIAPI
  97 ShellCommandLibConstructor (
  98   IN EFI_HANDLE        ImageHandle,
  99   IN EFI_SYSTEM_TABLE  *SystemTable
 100   )
 101 {
 102   EFI_STATUS        Status;
 103   InitializeListHead(&gShellMapList.Link);
 104   InitializeListHead(&mCommandList.Link);
 105   InitializeListHead(&mAliasList.Link);
 106   InitializeListHead(&mScriptList.Link);
 107   InitializeListHead(&mFileHandleList.Link);
 108   mEchoState = TRUE;
 109
 110   mExitRequested    = FALSE;
 111   mExitScript       = FALSE;
 112   mProfileListSize  = 0;
 113   mProfileList      = NULL;
 114
 115   if (gUnicodeCollation == NULL) {
 116     Status = gBS->LocateProtocol(&gEfiUnicodeCollation2ProtocolGuid, NULL, (VOID**)&gUnicodeCollation);
 117     if (EFI_ERROR(Status)) {
 118       return (EFI_DEVICE_ERROR);
 119     }
 120   }
 121
 122   return (RETURN_SUCCESS);
 123 }
 124
 125 /**
 126   Frees list of file handles.
 127
 128   @param[in] List     The list to free.
 129 **/
 130 VOID
 131 FreeFileHandleList (
 132   IN BUFFER_LIST *List
 133   )
 134 {
 135   BUFFER_LIST               *BufferListEntry;
 136
 137   if (List == NULL){
 138     return;
 139   }
 140   //
 141   // enumerate through the buffer list and free all memory
 142   //
 143   for ( BufferListEntry = ( BUFFER_LIST *)GetFirstNode(&List->Link)
 144       ; !IsListEmpty (&List->Link)
 145       ; BufferListEntry = (BUFFER_LIST *)GetFirstNode(&List->Link)
 146      ){
 147     RemoveEntryList(&BufferListEntry->Link);
 148     ASSERT(BufferListEntry->Buffer != NULL);
 149     SHELL_FREE_NON_NULL(((SHELL_COMMAND_FILE_HANDLE*)(BufferListEntry->Buffer))->Path);
 150     SHELL_FREE_NON_NULL(BufferListEntry->Buffer);
 151     SHELL_FREE_NON_NULL(BufferListEntry);
 152   }
 153 }
 154
 155 /**
 156   Destructor for the library.  free any resources.
 157
 158   @param ImageHandle    the image handle of the process
 159   @param SystemTable    the EFI System Table pointer
 160
 161   @retval RETURN_SUCCESS this function always returns success
 162 **/
 163 RETURN_STATUS
 164 EFIAPI
 165 ShellCommandLibDestructor (
 166   IN EFI_HANDLE        ImageHandle,
 167   IN EFI_SYSTEM_TABLE  *SystemTable
 168   )
 169 {
 170   SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;
 171   ALIAS_LIST                        *Node2;
 172   SCRIPT_FILE_LIST                  *Node3;
 173   SHELL_MAP_LIST                    *MapNode;
 174   //
 175   // enumerate throught the list and free all the memory
 176   //
 177   while (!IsListEmpty (&mCommandList.Link)) {
 178     Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode(&mCommandList.Link);
 179     RemoveEntryList(&Node->Link);
 180     SHELL_FREE_NON_NULL(Node->CommandString);
 181     FreePool(Node);
 182     DEBUG_CODE(Node = NULL;);
 183   }
 184
 185   //
 186   // enumerate through the alias list and free all memory
 187   //
 188   while (!IsListEmpty (&mAliasList.Link)) {
 189     Node2 = (ALIAS_LIST *)GetFirstNode(&mAliasList.Link);
 190     RemoveEntryList(&Node2->Link);
 191     SHELL_FREE_NON_NULL(Node2->CommandString);
 192     SHELL_FREE_NON_NULL(Node2->Alias);
 193     SHELL_FREE_NON_NULL(Node2);
 194     DEBUG_CODE(Node2 = NULL;);
 195   }
 196
 197   //
 198   // enumerate throught the list and free all the memory
 199   //
 200   while (!IsListEmpty (&mScriptList.Link)) {
 201     Node3 = (SCRIPT_FILE_LIST *)GetFirstNode(&mScriptList.Link);
 202     RemoveEntryList(&Node3->Link);
 203     DeleteScriptFileStruct(Node3->Data);
 204     FreePool(Node3);
 205   }
 206
 207   //
 208   // enumerate throught the mappings list and free all the memory
 209   //
 210   if (!IsListEmpty(&gShellMapList.Link)) {
 211     for (MapNode = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
 212          ; !IsListEmpty (&gShellMapList.Link)
 213          ; MapNode = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
 214         ){
 215       ASSERT(MapNode != NULL);
 216       RemoveEntryList(&MapNode->Link);
 217       SHELL_FREE_NON_NULL(MapNode->DevicePath);
 218       SHELL_FREE_NON_NULL(MapNode->MapName);
 219       SHELL_FREE_NON_NULL(MapNode->CurrentDirectoryPath);
 220       FreePool(MapNode);
 221     }
 222   }
 223   if (!IsListEmpty(&mFileHandleList.Link)){
 224     FreeFileHandleList(&mFileHandleList);
 225   }
 226
 227   if (mProfileList != NULL) {
 228     FreePool(mProfileList);
 229   }
 230
 231   gUnicodeCollation            = NULL;
 232   gShellCurDir                 = NULL;
 233
 234   return (RETURN_SUCCESS);
 235 }
 236
 237 /**
 238   Find a dynamic command protocol instance given a command name string.
 239
 240   @param CommandString  the command name string
 241
 242   @return instance      the command protocol instance, if dynamic command instance found
 243   @retval NULL          no dynamic command protocol instance found for name
 244 **/
 245 CONST EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL *
 246 ShellCommandFindDynamicCommand (
 247   IN CONST CHAR16 *CommandString
 248   )
 249 {
 250   EFI_STATUS                          Status;
 251   EFI_HANDLE                          *CommandHandleList;
 252   EFI_HANDLE                          *NextCommand;
 253   EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL  *DynamicCommand;
 254
 255   CommandHandleList = GetHandleListByProtocol(&gEfiShellDynamicCommandProtocolGuid);
 256   if (CommandHandleList == NULL) {
 257     //
 258     // not found or out of resources
 259     //
 260     return NULL;
 261   }
 262
 263   for (NextCommand = CommandHandleList; *NextCommand != NULL; NextCommand++) {
 264     Status = gBS->HandleProtocol(
 265       *NextCommand,
 266       &gEfiShellDynamicCommandProtocolGuid,
 267       (VOID **)&DynamicCommand
 268       );
 269
 270     if (EFI_ERROR(Status)) {
 271       continue;
 272     }
 273
 274     if (gUnicodeCollation->StriColl(
 275           gUnicodeCollation,
 276           (CHAR16*)CommandString,
 277           (CHAR16*)DynamicCommand->CommandName) == 0
 278           ){
 279         FreePool(CommandHandleList);
 280         return (DynamicCommand);
 281     }
 282   }
 283
 284   FreePool(CommandHandleList);
 285   return (NULL);
 286 }
 287
 288 /**
 289   Checks if a command exists as a dynamic command protocol instance
 290
 291   @param[in] CommandString        The command string to check for on the list.
 292 **/
 293 BOOLEAN
 294 ShellCommandDynamicCommandExists (
 295   IN CONST CHAR16 *CommandString
 296   )
 297 {
 298   return (BOOLEAN) ((ShellCommandFindDynamicCommand(CommandString) != NULL));
 299 }
 300
 301 /**
 302   Checks if a command is already on the internal command list.
 303
 304   @param[in] CommandString        The command string to check for on the list.
 305 **/
 306 BOOLEAN
 307 ShellCommandIsCommandOnInternalList(
 308   IN CONST  CHAR16 *CommandString
 309   )
 310 {
 311   SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;
 312
 313   //
 314   // assert for NULL parameter
 315   //
 316   ASSERT(CommandString != NULL);
 317
 318   //
 319   // check for the command
 320   //
 321   for ( Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode(&mCommandList.Link)
 322       ; !IsNull(&mCommandList.Link, &Node->Link)
 323       ; Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetNextNode(&mCommandList.Link, &Node->Link)
 324      ){
 325     ASSERT(Node->CommandString != NULL);
 326     if (gUnicodeCollation->StriColl(
 327           gUnicodeCollation,
 328           (CHAR16*)CommandString,
 329           Node->CommandString) == 0
 330        ){
 331       return (TRUE);
 332     }
 333   }
 334   return (FALSE);
 335 }
 336
 337 /**
 338   Checks if a command exists, either internally or through the dynamic command protocol.
 339
 340   @param[in] CommandString        The command string to check for on the list.
 341 **/
 342 BOOLEAN
 343 EFIAPI
 344 ShellCommandIsCommandOnList(
 345   IN CONST  CHAR16                      *CommandString
 346   )
 347 {
 348   if (ShellCommandIsCommandOnInternalList(CommandString)) {
 349     return TRUE;
 350   }
 351
 352   return ShellCommandDynamicCommandExists(CommandString);
 353 }
 354
 355 /**
 356  Get the help text for a dynamic command.
 357
 358   @param[in] CommandString        The command name.
 359
 360   @retval NULL  No help text was found.
 361   @return       String of help text. Caller required to free.
 362 **/
 363 CHAR16*
 364 ShellCommandGetDynamicCommandHelp(
 365   IN CONST  CHAR16                      *CommandString
 366   )
 367 {
 368   EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL  *DynamicCommand;
 369
 370   DynamicCommand = (EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL  *)ShellCommandFindDynamicCommand(CommandString);
 371   if (DynamicCommand == NULL) {
 372     return (NULL);
 373   }
 374
 375   //
 376   // TODO: how to get proper language?
 377   //
 378   return DynamicCommand->GetHelp(DynamicCommand, "en");
 379 }
 380
 381 /**
 382   Get the help text for an internal command.
 383
 384   @param[in] CommandString        The command name.
 385
 386   @retval NULL  No help text was found.
 387   @return       String of help text. Caller reuiqred to free.
 388 **/
 389 CHAR16*
 390 ShellCommandGetInternalCommandHelp(
 391   IN CONST  CHAR16                      *CommandString
 392   )
 393 {
 394   SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;
 395
 396   //
 397   // assert for NULL parameter
 398   //
 399   ASSERT(CommandString != NULL);
 400
 401   //
 402   // check for the command
 403   //
 404   for ( Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode(&mCommandList.Link)
 405       ; !IsNull(&mCommandList.Link, &Node->Link)
 406       ; Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetNextNode(&mCommandList.Link, &Node->Link)
 407      ){
 408     ASSERT(Node->CommandString != NULL);
 409     if (gUnicodeCollation->StriColl(
 410           gUnicodeCollation,
 411           (CHAR16*)CommandString,
 412           Node->CommandString) == 0
 413        ){
 414       return (HiiGetString(Node->HiiHandle, Node->ManFormatHelp, NULL));
 415     }
 416   }
 417   return (NULL);
 418 }
 419
 420 /**
 421   Get the help text for a command.
 422
 423   @param[in] CommandString        The command name.
 424
 425   @retval NULL  No help text was found.
 426   @return       String of help text.Caller reuiqred to free.
 427 **/
 428 CHAR16*
 429 EFIAPI
 430 ShellCommandGetCommandHelp (
 431   IN CONST  CHAR16                      *CommandString
 432   )
 433 {
 434   CHAR16      *HelpStr;
 435   HelpStr = ShellCommandGetInternalCommandHelp(CommandString);
 436
 437   if (HelpStr == NULL) {
 438     HelpStr = ShellCommandGetDynamicCommandHelp(CommandString);
 439   }
 440
 441   return HelpStr;
 442 }
 443
 444
 445 /**
 446   Registers handlers of type SHELL_RUN_COMMAND and
 447   SHELL_GET_MAN_FILENAME for each shell command.
 448
 449   If the ShellSupportLevel is greater than the value of the
 450   PcdShellSupportLevel then return RETURN_UNSUPPORTED.
 451
 452   Registers the handlers specified by GetHelpInfoHandler and CommandHandler
 453   with the command specified by CommandString. If the command named by
 454   CommandString has already been registered, then return
 455   RETURN_ALREADY_STARTED.
 456
 457   If there are not enough resources available to register the handlers then
 458   RETURN_OUT_OF_RESOURCES is returned.
 459
 460   If CommandString is NULL, then ASSERT().
 461   If GetHelpInfoHandler is NULL, then ASSERT().
 462   If CommandHandler is NULL, then ASSERT().
 463   If ProfileName is NULL, then ASSERT().
 464
 465   @param[in]  CommandString         Pointer to the command name.  This is the
 466                                     name to look for on the command line in
 467                                     the shell.
 468   @param[in]  CommandHandler        Pointer to a function that runs the
 469                                     specified command.
 470   @param[in]  GetManFileName        Pointer to a function that provides man
 471                                     filename.
 472   @param[in]  ShellMinSupportLevel  minimum Shell Support Level which has this
 473                                     function.
 474   @param[in]  ProfileName           profile name to require for support of this
 475                                     function.
 476   @param[in]  CanAffectLE           indicates whether this command's return value
 477                                     can change the LASTERROR environment variable.
 478   @param[in]  HiiHandle             Handle of this command's HII entry.
 479   @param[in]  ManFormatHelp         HII locator for the help text.
 480
 481   @retval  RETURN_SUCCESS           The handlers were registered.
 482   @retval  RETURN_OUT_OF_RESOURCES  There are not enough resources available to
 483                                     register the shell command.
 484   @retval RETURN_UNSUPPORTED        the ShellMinSupportLevel was higher than the
 485                                     currently allowed support level.
 486   @retval RETURN_ALREADY_STARTED    The CommandString represents a command that
 487                                     is already registered.  Only 1 handler set for
 488                                     a given command is allowed.
 489   @sa SHELL_GET_MAN_FILENAME
 490   @sa SHELL_RUN_COMMAND
 491 **/
 492 RETURN_STATUS
 493 EFIAPI
 494 ShellCommandRegisterCommandName (
 495   IN CONST  CHAR16                      *CommandString,
 496   IN        SHELL_RUN_COMMAND           CommandHandler,
 497   IN        SHELL_GET_MAN_FILENAME      GetManFileName,
 498   IN        UINT32                      ShellMinSupportLevel,
 499   IN CONST  CHAR16                      *ProfileName,
 500   IN CONST  BOOLEAN                     CanAffectLE,
 501   IN CONST  EFI_HANDLE                  HiiHandle,
 502   IN CONST  EFI_STRING_ID               ManFormatHelp
 503   )
 504 {
 505   SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;
 506   SHELL_COMMAND_INTERNAL_LIST_ENTRY *Command;
 507   SHELL_COMMAND_INTERNAL_LIST_ENTRY *PrevCommand;
 508   INTN LexicalMatchValue;
 509
 510   //
 511   // Initialize local variables.
 512   //
 513   Command = NULL;
 514   PrevCommand = NULL;
 515   LexicalMatchValue = 0;
 516
 517   //
 518   // ASSERTs for NULL parameters
 519   //
 520   ASSERT(CommandString  != NULL);
 521   ASSERT(GetManFileName != NULL);
 522   ASSERT(CommandHandler != NULL);
 523   ASSERT(ProfileName    != NULL);
 524
 525   //
 526   // check for shell support level
 527   //
 528   if (PcdGet8(PcdShellSupportLevel) < ShellMinSupportLevel) {
 529     return (RETURN_UNSUPPORTED);
 530   }
 531
 532   //
 533   // check for already on the list
 534   //
 535   if (ShellCommandIsCommandOnList(CommandString)) {
 536     return (RETURN_ALREADY_STARTED);
 537   }
 538
 539   //
 540   // allocate memory for new struct
 541   //
 542   Node = AllocateZeroPool(sizeof(SHELL_COMMAND_INTERNAL_LIST_ENTRY));
 543   if (Node == NULL) {
 544     return RETURN_OUT_OF_RESOURCES;
 545   }
 546   Node->CommandString = AllocateCopyPool(StrSize(CommandString), CommandString);
 547   if (Node->CommandString == NULL) {
 548     FreePool (Node);
 549     return RETURN_OUT_OF_RESOURCES;
 550   }
 551
 552   Node->GetManFileName  = GetManFileName;
 553   Node->CommandHandler  = CommandHandler;
 554   Node->LastError       = CanAffectLE;
 555   Node->HiiHandle       = HiiHandle;
 556   Node->ManFormatHelp   = ManFormatHelp;
 557
 558   if ( StrLen(ProfileName)>0
 559     && ((mProfileList != NULL
 560     && StrStr(mProfileList, ProfileName) == NULL) || mProfileList == NULL)
 561    ){
 562     ASSERT((mProfileList == NULL && mProfileListSize == 0) || (mProfileList != NULL));
 563     if (mProfileList == NULL) {
 564       //
 565       // If this is the first make a leading ';'
 566       //
 567       StrnCatGrow(&mProfileList, &mProfileListSize, L";", 0);
 568     }
 569     StrnCatGrow(&mProfileList, &mProfileListSize, ProfileName, 0);
 570     StrnCatGrow(&mProfileList, &mProfileListSize, L";", 0);
 571   }
 572
 573   //
 574   // Insert a new entry on top of the list
 575   //
 576   InsertHeadList (&mCommandList.Link, &Node->Link);
 577
 578   //
 579   // Move a new registered command to its sorted ordered location in the list
 580   //
 581   for (Command = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode (&mCommandList.Link),
 582         PrevCommand = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode (&mCommandList.Link)
 583         ; !IsNull (&mCommandList.Link, &Command->Link)
 584         ; Command = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetNextNode (&mCommandList.Link, &Command->Link)) {
 585
 586     //
 587     // Get Lexical Comparison Value between PrevCommand and Command list entry
 588     //
 589     LexicalMatchValue = gUnicodeCollation->StriColl (
 590                                              gUnicodeCollation,
 591                                              PrevCommand->CommandString,
 592                                              Command->CommandString
 593                                              );
 594
 595     //
 596     // Swap PrevCommand and Command list entry if PrevCommand list entry
 597     // is alphabetically greater than Command list entry
 598     //
 599     if (LexicalMatchValue > 0){
 600       Command = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *) SwapListEntries (&PrevCommand->Link, &Command->Link);
 601     } else if (LexicalMatchValue < 0) {
 602       //
 603       // PrevCommand entry is lexically lower than Command entry
 604       //
 605       break;
 606     }
 607   }
 608
 609   return (RETURN_SUCCESS);
 610 }
 611
 612 /**
 613   Function to get the current Profile string.
 614
 615   @retval NULL  There are no installed profiles.
 616   @return       A semi-colon delimited list of profiles.
 617 **/
 618 CONST CHAR16 *
 619 EFIAPI
 620 ShellCommandGetProfileList (
 621   VOID
 622   )
 623 {
 624   return (mProfileList);
 625 }
 626
 627 /**
 628   Checks if a command string has been registered for CommandString and if so it runs
 629   the previously registered handler for that command with the command line.
 630
 631   If CommandString is NULL, then ASSERT().
 632
 633   If Sections is specified, then each section name listed will be compared in a casesensitive
 634   manner, to the section names described in Appendix B UEFI Shell 2.0 spec. If the section exists,
 635   it will be appended to the returned help text. If the section does not exist, no
 636   information will be returned. If Sections is NULL, then all help text information
 637   available will be returned.
 638
 639   @param[in]  CommandString          Pointer to the command name.  This is the name
 640                                      found on the command line in the shell.
 641   @param[in, out] RetVal             Pointer to the return vaule from the command handler.
 642
 643   @param[in, out]  CanAffectLE       indicates whether this command's return value
 644                                      needs to be placed into LASTERROR environment variable.
 645
 646   @retval RETURN_SUCCESS            The handler was run.
 647   @retval RETURN_NOT_FOUND          The CommandString did not match a registered
 648                                     command name.
 649   @sa SHELL_RUN_COMMAND
 650 **/
 651 RETURN_STATUS
 652 EFIAPI
 653 ShellCommandRunCommandHandler (
 654   IN CONST CHAR16               *CommandString,
 655   IN OUT SHELL_STATUS           *RetVal,
 656   IN OUT BOOLEAN                *CanAffectLE OPTIONAL
 657   )
 658 {
 659   SHELL_COMMAND_INTERNAL_LIST_ENTRY   *Node;
 660   EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL  *DynamicCommand;
 661
 662   //
 663   // assert for NULL parameters
 664   //
 665   ASSERT(CommandString != NULL);
 666
 667   //
 668   // check for the command
 669   //
 670   for ( Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode(&mCommandList.Link)
 671       ; !IsNull(&mCommandList.Link, &Node->Link)
 672       ; Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetNextNode(&mCommandList.Link, &Node->Link)
 673      ){
 674     ASSERT(Node->CommandString != NULL);
 675     if (gUnicodeCollation->StriColl(
 676           gUnicodeCollation,
 677           (CHAR16*)CommandString,
 678           Node->CommandString) == 0
 679       ){
 680       if (CanAffectLE != NULL) {
 681         *CanAffectLE = Node->LastError;
 682       }
 683       if (RetVal != NULL) {
 684         *RetVal = Node->CommandHandler(NULL, gST);
 685       } else {
 686         Node->CommandHandler(NULL, gST);
 687       }
 688       return (RETURN_SUCCESS);
 689     }
 690   }
 691
 692   //
 693   // An internal command was not found, try to find a dynamic command
 694   //
 695   DynamicCommand = (EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL  *)ShellCommandFindDynamicCommand(CommandString);
 696   if (DynamicCommand != NULL) {
 697     if (RetVal != NULL) {
 698       *RetVal = DynamicCommand->Handler(DynamicCommand, gST, gEfiShellParametersProtocol, gEfiShellProtocol);
 699     } else {
 700       DynamicCommand->Handler(DynamicCommand, gST, gEfiShellParametersProtocol, gEfiShellProtocol);
 701     }
 702     return (RETURN_SUCCESS);
 703   }
 704
 705   return (RETURN_NOT_FOUND);
 706 }
 707
 708 /**
 709   Checks if a command string has been registered for CommandString and if so it
 710   returns the MAN filename specified for that command.
 711
 712   If CommandString is NULL, then ASSERT().
 713
 714   @param[in]  CommandString         Pointer to the command name.  This is the name
 715                                     found on the command line in the shell.\
 716
 717   @retval NULL                      the commandString was not a registered command.
 718   @return other                     the name of the MAN file.
 719   @sa SHELL_GET_MAN_FILENAME
 720 **/
 721 CONST CHAR16*
 722 EFIAPI
 723 ShellCommandGetManFileNameHandler (
 724   IN CONST CHAR16               *CommandString
 725   )
 726 {
 727   SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;
 728
 729   //
 730   // assert for NULL parameters
 731   //
 732   ASSERT(CommandString != NULL);
 733
 734   //
 735   // check for the command
 736   //
 737   for ( Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode(&mCommandList.Link)
 738       ; !IsNull(&mCommandList.Link, &Node->Link)
 739       ; Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetNextNode(&mCommandList.Link, &Node->Link)
 740      ){
 741     ASSERT(Node->CommandString != NULL);
 742     if (gUnicodeCollation->StriColl(
 743           gUnicodeCollation,
 744           (CHAR16*)CommandString,
 745           Node->CommandString) == 0
 746        ){
 747       return (Node->GetManFileName());
 748     }
 749   }
 750   return (NULL);
 751 }
 752
 753 /**
 754   Get the list of all available shell internal commands.  This is a linked list
 755   (via LIST_ENTRY structure).  enumerate through it using the BaseLib linked
 756   list functions.  do not modify the values.
 757
 758   @param[in] Sort       TRUE to alphabetically sort the values first.  FALSE otherwise.
 759
 760   @return a Linked list of all available shell commands.
 761 **/
 762 CONST COMMAND_LIST*
 763 EFIAPI
 764 ShellCommandGetCommandList (
 765   IN CONST BOOLEAN Sort
 766   )
 767 {
 768 //  if (!Sort) {
 769 //    return ((COMMAND_LIST*)(&mCommandList));
 770 //  }
 771   return ((COMMAND_LIST*)(&mCommandList));
 772 }
 773
 774 /**
 775   Registers aliases to be set as part of the initialization of the shell application.
 776
 777   If Command is NULL, then ASSERT().
 778   If Alias is NULL, then ASSERT().
 779
 780   @param[in]  Command               Pointer to the Command
 781   @param[in]  Alias                 Pointer to Alias
 782
 783   @retval  RETURN_SUCCESS           The handlers were registered.
 784   @retval  RETURN_OUT_OF_RESOURCES  There are not enough resources available to
 785                                     register the shell command.
 786 **/
 787 RETURN_STATUS
 788 EFIAPI
 789 ShellCommandRegisterAlias (
 790   IN CONST CHAR16                       *Command,
 791   IN CONST CHAR16                       *Alias
 792   )
 793 {
 794   ALIAS_LIST *Node;
 795   ALIAS_LIST *CommandAlias;
 796   ALIAS_LIST *PrevCommandAlias;
 797   INTN       LexicalMatchValue;
 798
 799   //
 800   // Asserts for NULL
 801   //
 802   ASSERT(Command != NULL);
 803   ASSERT(Alias   != NULL);
 804
 805   //
 806   // allocate memory for new struct
 807   //
 808   Node = AllocateZeroPool(sizeof(ALIAS_LIST));
 809   if (Node == NULL) {
 810     return RETURN_OUT_OF_RESOURCES;
 811   }
 812   Node->CommandString = AllocateCopyPool(StrSize(Command), Command);
 813   if (Node->CommandString == NULL) {
 814     FreePool (Node);
 815     return RETURN_OUT_OF_RESOURCES;
 816   }
 817   Node->Alias = AllocateCopyPool(StrSize(Alias), Alias);
 818   if (Node->Alias == NULL) {
 819     FreePool (Node->CommandString);
 820     FreePool (Node);
 821     return RETURN_OUT_OF_RESOURCES;
 822   }
 823
 824   InsertHeadList (&mAliasList.Link, &Node->Link);
 825
 826   //
 827   // Move a new pre-defined registered alias to its sorted ordered location in the list
 828   //
 829   for ( CommandAlias = (ALIAS_LIST *)GetFirstNode (&mAliasList.Link),
 830          PrevCommandAlias = (ALIAS_LIST *)GetFirstNode (&mAliasList.Link)
 831        ; !IsNull (&mAliasList.Link, &CommandAlias->Link)
 832        ; CommandAlias = (ALIAS_LIST *) GetNextNode (&mAliasList.Link, &CommandAlias->Link) ) {
 833     //
 834     // Get Lexical comparison value between PrevCommandAlias and CommandAlias List Entry
 835     //
 836     LexicalMatchValue = gUnicodeCollation->StriColl (
 837                                              gUnicodeCollation,
 838                                              PrevCommandAlias->Alias,
 839                                              CommandAlias->Alias
 840                                              );
 841
 842     //
 843     // Swap PrevCommandAlias and CommandAlias list entry if PrevCommandAlias list entry
 844     // is alphabetically greater than CommandAlias list entry
 845     //
 846     if (LexicalMatchValue > 0) {
 847       CommandAlias = (ALIAS_LIST *) SwapListEntries (&PrevCommandAlias->Link, &CommandAlias->Link);
 848     } else if (LexicalMatchValue < 0) {
 849       //
 850       // PrevCommandAlias entry is lexically lower than CommandAlias entry
 851       //
 852       break;
 853     }
 854   }
 855
 856   return (RETURN_SUCCESS);
 857 }
 858
 859 /**
 860   Get the list of all shell alias commands.  This is a linked list
 861   (via LIST_ENTRY structure).  enumerate through it using the BaseLib linked
 862   list functions.  do not modify the values.
 863
 864   @return a Linked list of all requested shell alias'.
 865 **/
 866 CONST ALIAS_LIST*
 867 EFIAPI
 868 ShellCommandGetInitAliasList (
 869   VOID
 870   )
 871 {
 872     return (&mAliasList);
 873 }
 874
 875 /**
 876   Determine if a given alias is on the list of built in alias'.
 877
 878   @param[in] Alias              The alias to test for
 879
 880   @retval TRUE                  The alias is a built in alias
 881   @retval FALSE                 The alias is not a built in alias
 882 **/
 883 BOOLEAN
 884 EFIAPI
 885 ShellCommandIsOnAliasList(
 886   IN CONST CHAR16 *Alias
 887   )
 888 {
 889   ALIAS_LIST *Node;
 890
 891   //
 892   // assert for NULL parameter
 893   //
 894   ASSERT(Alias != NULL);
 895
 896   //
 897   // check for the Alias
 898   //
 899   for ( Node = (ALIAS_LIST *)GetFirstNode(&mAliasList.Link)
 900       ; !IsNull(&mAliasList.Link, &Node->Link)
 901       ; Node = (ALIAS_LIST *)GetNextNode(&mAliasList.Link, &Node->Link)
 902      ){
 903     ASSERT(Node->CommandString != NULL);
 904     ASSERT(Node->Alias != NULL);
 905     if (gUnicodeCollation->StriColl(
 906           gUnicodeCollation,
 907           (CHAR16*)Alias,
 908           Node->CommandString) == 0
 909        ){
 910       return (TRUE);
 911     }
 912     if (gUnicodeCollation->StriColl(
 913           gUnicodeCollation,
 914           (CHAR16*)Alias,
 915           Node->Alias) == 0
 916        ){
 917       return (TRUE);
 918     }
 919   }
 920   return (FALSE);
 921 }
 922
 923 /**
 924   Function to determine current state of ECHO.  Echo determines if lines from scripts
 925   and ECHO commands are enabled.
 926
 927   @retval TRUE    Echo is currently enabled
 928   @retval FALSE   Echo is currently disabled
 929 **/
 930 BOOLEAN
 931 EFIAPI
 932 ShellCommandGetEchoState(
 933   VOID
 934   )
 935 {
 936   return (mEchoState);
 937 }
 938
 939 /**
 940   Function to set current state of ECHO.  Echo determines if lines from scripts
 941   and ECHO commands are enabled.
 942
 943   If State is TRUE, Echo will be enabled.
 944   If State is FALSE, Echo will be disabled.
 945
 946   @param[in] State      How to set echo.
 947 **/
 948 VOID
 949 EFIAPI
 950 ShellCommandSetEchoState(
 951   IN BOOLEAN State
 952   )
 953 {
 954   mEchoState = State;
 955 }
 956
 957 /**
 958   Indicate that the current shell or script should exit.
 959
 960   @param[in] ScriptOnly   TRUE if exiting a script; FALSE otherwise.
 961   @param[in] ErrorCode    The 64 bit error code to return.
 962 **/
 963 VOID
 964 EFIAPI
 965 ShellCommandRegisterExit (
 966   IN BOOLEAN      ScriptOnly,
 967   IN CONST UINT64 ErrorCode
 968   )
 969 {
 970   mExitRequested = (BOOLEAN)(!mExitRequested);
 971   if (mExitRequested) {
 972     mExitScript    = ScriptOnly;
 973   } else {
 974     mExitScript    = FALSE;
 975   }
 976   mExitCode = ErrorCode;
 977 }
 978
 979 /**
 980   Retrieve the Exit indicator.
 981
 982   @retval TRUE      Exit was indicated.
 983   @retval FALSE     Exis was not indicated.
 984 **/
 985 BOOLEAN
 986 EFIAPI
 987 ShellCommandGetExit (
 988   VOID
 989   )
 990 {
 991   return (mExitRequested);
 992 }
 993
 994 /**
 995   Retrieve the Exit code.
 996
 997   If ShellCommandGetExit returns FALSE than the return from this is undefined.
 998
 999   @return the value passed into RegisterExit.
1000 **/
1001 UINT64
1002 EFIAPI
1003 ShellCommandGetExitCode (
1004   VOID
1005   )
1006 {
1007   return (mExitCode);
1008 }
1009 /**
1010   Retrieve the Exit script indicator.
1011
1012   If ShellCommandGetExit returns FALSE than the return from this is undefined.
1013
1014   @retval TRUE      ScriptOnly was indicated.
1015   @retval FALSE     ScriptOnly was not indicated.
1016 **/
1017 BOOLEAN
1018 EFIAPI
1019 ShellCommandGetScriptExit (
1020   VOID
1021   )
1022 {
1023   return (mExitScript);
1024 }
1025
1026 /**
1027   Function to cleanup all memory from a SCRIPT_FILE structure.
1028
1029   @param[in] Script     The pointer to the structure to cleanup.
1030 **/
1031 VOID
1032 EFIAPI
1033 DeleteScriptFileStruct (
1034   IN SCRIPT_FILE *Script
1035   )
1036 {
1037   UINT8       LoopVar;
1038
1039   if (Script == NULL) {
1040     return;
1041   }
1042
1043   for (LoopVar = 0 ; LoopVar < Script->Argc ; LoopVar++) {
1044     SHELL_FREE_NON_NULL(Script->Argv[LoopVar]);
1045   }
1046   if (Script->Argv != NULL) {
1047     SHELL_FREE_NON_NULL(Script->Argv);
1048   }
1049   Script->CurrentCommand = NULL;
1050   while (!IsListEmpty (&Script->CommandList)) {
1051     Script->CurrentCommand = (SCRIPT_COMMAND_LIST *)GetFirstNode(&Script->CommandList);
1052     if (Script->CurrentCommand != NULL) {
1053       RemoveEntryList(&Script->CurrentCommand->Link);
1054       if (Script->CurrentCommand->Cl != NULL) {
1055         SHELL_FREE_NON_NULL(Script->CurrentCommand->Cl);
1056       }
1057       if (Script->CurrentCommand->Data != NULL) {
1058         SHELL_FREE_NON_NULL(Script->CurrentCommand->Data);
1059       }
1060       SHELL_FREE_NON_NULL(Script->CurrentCommand);
1061     }
1062   }
1063   SHELL_FREE_NON_NULL(Script->ScriptName);
1064   SHELL_FREE_NON_NULL(Script);
1065 }
1066
1067 /**
1068   Function to return a pointer to the currently running script file object.
1069
1070   @retval NULL        A script file is not currently running.
1071   @return             A pointer to the current script file object.
1072 **/
1073 SCRIPT_FILE*
1074 EFIAPI
1075 ShellCommandGetCurrentScriptFile (
1076   VOID
1077   )
1078 {
1079   SCRIPT_FILE_LIST *List;
1080   if (IsListEmpty (&mScriptList.Link)) {
1081     return (NULL);
1082   }
1083   List = ((SCRIPT_FILE_LIST*)GetFirstNode(&mScriptList.Link));
1084   return (List->Data);
1085 }
1086
1087 /**
1088   Function to set a new script as the currently running one.
1089
1090   This function will correctly stack and unstack nested scripts.
1091
1092   @param[in] Script   Pointer to new script information structure.  if NULL
1093                       will remove and de-allocate the top-most Script structure.
1094
1095   @return             A pointer to the current running script file after this
1096                       change.  NULL if removing the final script.
1097 **/
1098 SCRIPT_FILE*
1099 EFIAPI
1100 ShellCommandSetNewScript (
1101   IN SCRIPT_FILE *Script OPTIONAL
1102   )
1103 {
1104   SCRIPT_FILE_LIST *Node;
1105   if (Script == NULL) {
1106     if (IsListEmpty (&mScriptList.Link)) {
1107       return (NULL);
1108     }
1109     Node = (SCRIPT_FILE_LIST *)GetFirstNode(&mScriptList.Link);
1110     RemoveEntryList(&Node->Link);
1111     DeleteScriptFileStruct(Node->Data);
1112     FreePool(Node);
1113   } else {
1114     Node = AllocateZeroPool(sizeof(SCRIPT_FILE_LIST));
1115     if (Node == NULL) {
1116       return (NULL);
1117     }
1118     Node->Data = Script;
1119     InsertHeadList(&mScriptList.Link, &Node->Link);
1120   }
1121   return (ShellCommandGetCurrentScriptFile());
1122 }
1123
1124 /**
1125   Function to generate the next default mapping name.
1126
1127   If the return value is not NULL then it must be callee freed.
1128
1129   @param Type                   What kind of mapping name to make.
1130
1131   @retval NULL                  a memory allocation failed.
1132   @return a new map name string
1133 **/
1134 CHAR16*
1135 EFIAPI
1136 ShellCommandCreateNewMappingName(
1137   IN CONST SHELL_MAPPING_TYPE Type
1138   )
1139 {
1140   CHAR16  *String;
1141   ASSERT(Type < MappingTypeMax);
1142
1143   String = NULL;
1144
1145   String = AllocateZeroPool(PcdGet8(PcdShellMapNameLength) * sizeof(String[0]));
1146   UnicodeSPrint(
1147     String,
1148     PcdGet8(PcdShellMapNameLength) * sizeof(String[0]),
1149     Type == MappingTypeFileSystem?L"FS%d:":L"BLK%d:",
1150     Type == MappingTypeFileSystem?mFsMaxCount++:mBlkMaxCount++);
1151
1152   return (String);
1153 }
1154
1155 /**
1156   Function to add a map node to the list of map items and update the "path" environment variable (optionally).
1157
1158   If Path is TRUE (during initialization only), the path environment variable will also be updated to include
1159   default paths on the new map name...
1160
1161   Path should be FALSE when this function is called from the protocol SetMap function.
1162
1163   @param[in] Name               The human readable mapped name.
1164   @param[in] DevicePath         The Device Path for this map.
1165   @param[in] Flags              The Flags attribute for this map item.
1166   @param[in] Path               TRUE to update path, FALSE to skip this step (should only be TRUE during initialization).
1167
1168   @retval EFI_SUCCESS           The addition was sucessful.
1169   @retval EFI_OUT_OF_RESOURCES  A memory allocation failed.
1170   @retval EFI_INVALID_PARAMETER A parameter was invalid.
1171 **/
1172 EFI_STATUS
1173 EFIAPI
1174 ShellCommandAddMapItemAndUpdatePath(
1175   IN CONST CHAR16                   *Name,
1176   IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
1177   IN CONST UINT64                   Flags,
1178   IN CONST BOOLEAN                  Path
1179   )
1180 {
1181   EFI_STATUS      Status;
1182   SHELL_MAP_LIST  *MapListNode;
1183   CONST CHAR16    *OriginalPath;
1184   CHAR16          *NewPath;
1185   UINTN           NewPathSize;
1186
1187   NewPathSize = 0;
1188   NewPath = NULL;
1189   OriginalPath = NULL;
1190   Status = EFI_SUCCESS;
1191
1192   MapListNode = AllocateZeroPool(sizeof(SHELL_MAP_LIST));
1193   if (MapListNode == NULL) {
1194     Status = EFI_OUT_OF_RESOURCES;
1195   } else {
1196     MapListNode->Flags = Flags;
1197     MapListNode->MapName = AllocateCopyPool(StrSize(Name), Name);
1198     MapListNode->DevicePath = DuplicateDevicePath(DevicePath);
1199     if ((MapListNode->MapName == NULL) || (MapListNode->DevicePath == NULL)){
1200       Status = EFI_OUT_OF_RESOURCES;
1201     } else {
1202       InsertTailList(&gShellMapList.Link, &MapListNode->Link);
1203     }
1204   }
1205   if (EFI_ERROR(Status)) {
1206     if (MapListNode != NULL) {
1207       if (MapListNode->DevicePath != NULL) {
1208         FreePool(MapListNode->DevicePath);
1209       }
1210       if (MapListNode->MapName != NULL) {
1211         FreePool(MapListNode->MapName);
1212       }
1213       FreePool(MapListNode);
1214     }
1215   } else if (Path) {
1216     //
1217     // Since there was no error and Path was TRUE
1218     // Now add the correct path for that mapping
1219     //
1220     OriginalPath = gEfiShellProtocol->GetEnv(L"path");
1221     ASSERT((NewPath == NULL && NewPathSize == 0) || (NewPath != NULL));
1222     if (OriginalPath != NULL) {
1223       StrnCatGrow(&NewPath, &NewPathSize, OriginalPath, 0);
1224       StrnCatGrow(&NewPath, &NewPathSize, L";", 0);
1225     }
1226     StrnCatGrow(&NewPath, &NewPathSize, Name, 0);
1227     StrnCatGrow(&NewPath, &NewPathSize, L"\\efi\\tools\\;", 0);
1228     StrnCatGrow(&NewPath, &NewPathSize, Name, 0);
1229     StrnCatGrow(&NewPath, &NewPathSize, L"\\efi\\boot\\;", 0);
1230     StrnCatGrow(&NewPath, &NewPathSize, Name, 0);
1231     StrnCatGrow(&NewPath, &NewPathSize, L"\\", 0);
1232
1233     Status = gEfiShellProtocol->SetEnv(L"path", NewPath, TRUE);
1234     ASSERT_EFI_ERROR(Status);
1235     FreePool(NewPath);
1236   }
1237   return (Status);
1238 }
1239
1240 /**
1241   Creates the default map names for each device path in the system with
1242   a protocol depending on the Type.
1243
1244   Creates the consistent map names for each device path in the system with
1245   a protocol depending on the Type.
1246
1247   Note: This will reset all mappings in the system("map -r").
1248
1249   Also sets up the default path environment variable if Type is FileSystem.
1250
1251   @retval EFI_SUCCESS           All map names were created sucessfully.
1252   @retval EFI_NOT_FOUND         No protocols were found in the system.
1253   @return                       Error returned from gBS->LocateHandle().
1254
1255   @sa LocateHandle
1256 **/
1257 EFI_STATUS
1258 EFIAPI
1259 ShellCommandCreateInitialMappingsAndPaths(
1260   VOID
1261   )
1262 {
1263   EFI_STATUS                Status;
1264   EFI_HANDLE                *HandleList;
1265   UINTN                     Count;
1266   EFI_DEVICE_PATH_PROTOCOL  **DevicePathList;
1267   CHAR16                    *NewDefaultName;
1268   CHAR16                    *NewConsistName;
1269   EFI_DEVICE_PATH_PROTOCOL  **ConsistMappingTable;
1270   SHELL_MAP_LIST            *MapListNode;
1271
1272   HandleList  = NULL;
1273
1274   //
1275   // Reset the static members back to zero
1276   //
1277   mFsMaxCount = 0;
1278   mBlkMaxCount = 0;
1279
1280   gEfiShellProtocol->SetEnv(L"path", L"", TRUE);
1281
1282   //
1283   // First empty out the existing list.
1284   //
1285   if (!IsListEmpty(&gShellMapList.Link)) {
1286     for ( MapListNode = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
1287         ; !IsListEmpty(&gShellMapList.Link)
1288         ; MapListNode = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
1289        ){
1290           RemoveEntryList(&MapListNode->Link);
1291           SHELL_FREE_NON_NULL(MapListNode->DevicePath);
1292           SHELL_FREE_NON_NULL(MapListNode->MapName);
1293           SHELL_FREE_NON_NULL(MapListNode->CurrentDirectoryPath);
1294           FreePool(MapListNode);
1295     } // for loop
1296   }
1297
1298   //
1299   // Find each handle with Simple File System
1300   //
1301   HandleList = GetHandleListByProtocol(&gEfiSimpleFileSystemProtocolGuid);
1302   if (HandleList != NULL) {
1303     //
1304     // Do a count of the handles
1305     //
1306     for (Count = 0 ; HandleList[Count] != NULL ; Count++);
1307
1308     //
1309     // Get all Device Paths
1310     //
1311     DevicePathList = AllocateZeroPool(sizeof(EFI_DEVICE_PATH_PROTOCOL*) * Count);
1312     if (DevicePathList == NULL) {
1313       SHELL_FREE_NON_NULL (HandleList);
1314       return EFI_OUT_OF_RESOURCES;
1315     }
1316
1317     for (Count = 0 ; HandleList[Count] != NULL ; Count++) {
1318       DevicePathList[Count] = DevicePathFromHandle(HandleList[Count]);
1319     }
1320
1321     //
1322     // Sort all DevicePaths
1323     //
1324     PerformQuickSort(DevicePathList, Count, sizeof(EFI_DEVICE_PATH_PROTOCOL*), DevicePathCompare);
1325
1326     ShellCommandConsistMappingInitialize(&ConsistMappingTable);
1327     //
1328     // Assign new Mappings to all...
1329     //
1330     for (Count = 0 ; HandleList[Count] != NULL ; Count++) {
1331       //
1332       // Get default name first
1333       //
1334       NewDefaultName = ShellCommandCreateNewMappingName(MappingTypeFileSystem);
1335       ASSERT(NewDefaultName != NULL);
1336       Status = ShellCommandAddMapItemAndUpdatePath(NewDefaultName, DevicePathList[Count], 0, TRUE);
1337       ASSERT_EFI_ERROR(Status);
1338       FreePool(NewDefaultName);
1339
1340       //
1341       // Now do consistent name
1342       //
1343       NewConsistName = ShellCommandConsistMappingGenMappingName(DevicePathList[Count], ConsistMappingTable);
1344       if (NewConsistName != NULL) {
1345         Status = ShellCommandAddMapItemAndUpdatePath(NewConsistName, DevicePathList[Count], 0, FALSE);
1346         ASSERT_EFI_ERROR(Status);
1347         FreePool(NewConsistName);
1348       }
1349     }
1350
1351     ShellCommandConsistMappingUnInitialize(ConsistMappingTable);
1352
1353     SHELL_FREE_NON_NULL(HandleList);
1354     SHELL_FREE_NON_NULL(DevicePathList);
1355
1356     HandleList = NULL;
1357   } else {
1358     Count = (UINTN)-1;
1359   }
1360
1361   //
1362   // Find each handle with Block Io
1363   //
1364   HandleList = GetHandleListByProtocol(&gEfiBlockIoProtocolGuid);
1365   if (HandleList != NULL) {
1366     for (Count = 0 ; HandleList[Count] != NULL ; Count++);
1367
1368     //
1369     // Get all Device Paths
1370     //
1371     DevicePathList = AllocateZeroPool(sizeof(EFI_DEVICE_PATH_PROTOCOL*) * Count);
1372     if (DevicePathList == NULL) {
1373       SHELL_FREE_NON_NULL (HandleList);
1374       return EFI_OUT_OF_RESOURCES;
1375     }
1376
1377     for (Count = 0 ; HandleList[Count] != NULL ; Count++) {
1378       DevicePathList[Count] = DevicePathFromHandle(HandleList[Count]);
1379     }
1380
1381     //
1382     // Sort all DevicePaths
1383     //
1384     PerformQuickSort(DevicePathList, Count, sizeof(EFI_DEVICE_PATH_PROTOCOL*), DevicePathCompare);
1385
1386     //
1387     // Assign new Mappings to all...
1388     //
1389     for (Count = 0 ; HandleList[Count] != NULL ; Count++) {
1390       //
1391       // Get default name first
1392       //
1393       NewDefaultName = ShellCommandCreateNewMappingName(MappingTypeBlockIo);
1394       ASSERT(NewDefaultName != NULL);
1395       Status = ShellCommandAddMapItemAndUpdatePath(NewDefaultName, DevicePathList[Count], 0, FALSE);
1396       ASSERT_EFI_ERROR(Status);
1397       FreePool(NewDefaultName);
1398     }
1399
1400     SHELL_FREE_NON_NULL(HandleList);
1401     SHELL_FREE_NON_NULL(DevicePathList);
1402   } else if (Count == (UINTN)-1) {
1403     return (EFI_NOT_FOUND);
1404   }
1405
1406   return (EFI_SUCCESS);
1407 }
1408
1409 /**
1410   Add mappings for any devices without one.  Do not change any existing maps.
1411
1412   @retval EFI_SUCCESS   The operation was successful.
1413 **/
1414 EFI_STATUS
1415 EFIAPI
1416 ShellCommandUpdateMapping (
1417   VOID
1418   )
1419 {
1420   EFI_STATUS                Status;
1421   EFI_HANDLE                *HandleList;
1422   UINTN                     Count;
1423   EFI_DEVICE_PATH_PROTOCOL  **DevicePathList;
1424   CHAR16                    *NewDefaultName;
1425   CHAR16                    *NewConsistName;
1426   EFI_DEVICE_PATH_PROTOCOL  **ConsistMappingTable;
1427
1428   HandleList  = NULL;
1429   Status      = EFI_SUCCESS;
1430
1431   //
1432   // remove mappings that represent removed devices.
1433   //
1434
1435   //
1436   // Find each handle with Simple File System
1437   //
1438   HandleList = GetHandleListByProtocol(&gEfiSimpleFileSystemProtocolGuid);
1439   if (HandleList != NULL) {
1440     //
1441     // Do a count of the handles
1442     //
1443     for (Count = 0 ; HandleList[Count] != NULL ; Count++);
1444
1445     //
1446     // Get all Device Paths
1447     //
1448     DevicePathList = AllocateZeroPool(sizeof(EFI_DEVICE_PATH_PROTOCOL*) * Count);
1449     if (DevicePathList == NULL) {
1450       return (EFI_OUT_OF_RESOURCES);
1451     }
1452
1453     for (Count = 0 ; HandleList[Count] != NULL ; Count++) {
1454       DevicePathList[Count] = DevicePathFromHandle(HandleList[Count]);
1455     }
1456
1457     //
1458     // Sort all DevicePaths
1459     //
1460     PerformQuickSort(DevicePathList, Count, sizeof(EFI_DEVICE_PATH_PROTOCOL*), DevicePathCompare);
1461
1462     ShellCommandConsistMappingInitialize(&ConsistMappingTable);
1463
1464     //
1465     // Assign new Mappings to remainders
1466     //
1467     for (Count = 0 ; !EFI_ERROR(Status) && HandleList[Count] != NULL && !EFI_ERROR(Status); Count++) {
1468       //
1469       // Skip ones that already have
1470       //
1471       if (gEfiShellProtocol->GetMapFromDevicePath(&DevicePathList[Count]) != NULL) {
1472         continue;
1473       }
1474       //
1475       // Get default name
1476       //
1477       NewDefaultName = ShellCommandCreateNewMappingName(MappingTypeFileSystem);
1478       if (NewDefaultName == NULL) {
1479         Status = EFI_OUT_OF_RESOURCES;
1480         break;
1481       }
1482
1483       //
1484       // Call shell protocol SetMap function now...
1485       //
1486       Status = gEfiShellProtocol->SetMap(DevicePathList[Count], NewDefaultName);
1487
1488       if (!EFI_ERROR(Status)) {
1489         //
1490         // Now do consistent name
1491         //
1492         NewConsistName = ShellCommandConsistMappingGenMappingName(DevicePathList[Count], ConsistMappingTable);
1493         if (NewConsistName != NULL) {
1494           Status = gEfiShellProtocol->SetMap(DevicePathList[Count], NewConsistName);
1495           FreePool(NewConsistName);
1496         }
1497       }
1498
1499       FreePool(NewDefaultName);
1500     }
1501     ShellCommandConsistMappingUnInitialize(ConsistMappingTable);
1502     SHELL_FREE_NON_NULL(HandleList);
1503     SHELL_FREE_NON_NULL(DevicePathList);
1504
1505     HandleList = NULL;
1506   } else {
1507     Count = (UINTN)-1;
1508   }
1509   //
1510   // Do it all over again for gEfiBlockIoProtocolGuid
1511   //
1512
1513   return (Status);
1514 }
1515
1516 /**
1517   Converts a SHELL_FILE_HANDLE to an EFI_FILE_PROTOCOL*.
1518
1519   @param[in] Handle     The SHELL_FILE_HANDLE to convert.
1520
1521   @return a EFI_FILE_PROTOCOL* representing the same file.
1522 **/
1523 EFI_FILE_PROTOCOL*
1524 EFIAPI
1525 ConvertShellHandleToEfiFileProtocol(
1526   IN CONST SHELL_FILE_HANDLE Handle
1527   )
1528 {
1529   return ((EFI_FILE_PROTOCOL*)(Handle));
1530 }
1531
1532 /**
1533   Converts a EFI_FILE_PROTOCOL* to an SHELL_FILE_HANDLE.
1534
1535   @param[in] Handle     The pointer to EFI_FILE_PROTOCOL to convert.
1536   @param[in] Path       The path to the file for verification.
1537
1538   @return               A SHELL_FILE_HANDLE representing the same file.
1539   @retval NULL          There was not enough memory.
1540 **/
1541 SHELL_FILE_HANDLE
1542 EFIAPI
1543 ConvertEfiFileProtocolToShellHandle(
1544   IN CONST EFI_FILE_PROTOCOL *Handle,
1545   IN CONST CHAR16            *Path
1546   )
1547 {
1548   SHELL_COMMAND_FILE_HANDLE *Buffer;
1549   BUFFER_LIST               *NewNode;
1550
1551   if (Path != NULL) {
1552     Buffer              = AllocateZeroPool(sizeof(SHELL_COMMAND_FILE_HANDLE));
1553     if (Buffer == NULL) {
1554       return (NULL);
1555     }
1556     NewNode             = AllocateZeroPool(sizeof(BUFFER_LIST));
1557     if (NewNode == NULL) {
1558       SHELL_FREE_NON_NULL(Buffer);
1559       return (NULL);
1560     }
1561     Buffer->FileHandle  = (EFI_FILE_PROTOCOL*)Handle;
1562     Buffer->Path        = StrnCatGrow(&Buffer->Path, NULL, Path, 0);
1563     if (Buffer->Path == NULL) {
1564       SHELL_FREE_NON_NULL(NewNode);
1565       SHELL_FREE_NON_NULL(Buffer);
1566       return (NULL);
1567     }
1568     NewNode->Buffer     = Buffer;
1569
1570     InsertHeadList(&mFileHandleList.Link, &NewNode->Link);
1571   }
1572   return ((SHELL_FILE_HANDLE)(Handle));
1573 }
1574
1575 /**
1576   Find the path that was logged with the specified SHELL_FILE_HANDLE.
1577
1578   @param[in] Handle     The SHELL_FILE_HANDLE to query on.
1579
1580   @return A pointer to the path for the file.
1581 **/
1582 CONST CHAR16*
1583 EFIAPI
1584 ShellFileHandleGetPath(
1585   IN CONST SHELL_FILE_HANDLE Handle
1586   )
1587 {
1588   BUFFER_LIST               *Node;
1589
1590   for (Node = (BUFFER_LIST*)GetFirstNode(&mFileHandleList.Link)
1591     ;  !IsNull(&mFileHandleList.Link, &Node->Link)
1592     ;  Node = (BUFFER_LIST*)GetNextNode(&mFileHandleList.Link, &Node->Link)
1593    ){
1594     if ((Node->Buffer) && (((SHELL_COMMAND_FILE_HANDLE *)Node->Buffer)->FileHandle == Handle)){
1595       return (((SHELL_COMMAND_FILE_HANDLE *)Node->Buffer)->Path);
1596     }
1597   }
1598   return (NULL);
1599 }
1600
1601 /**
1602   Remove a SHELL_FILE_HANDLE from the list of SHELL_FILE_HANDLES.
1603
1604   @param[in] Handle     The SHELL_FILE_HANDLE to remove.
1605
1606   @retval TRUE          The item was removed.
1607   @retval FALSE         The item was not found.
1608 **/
1609 BOOLEAN
1610 EFIAPI
1611 ShellFileHandleRemove(
1612   IN CONST SHELL_FILE_HANDLE Handle
1613   )
1614 {
1615   BUFFER_LIST               *Node;
1616
1617   for (Node = (BUFFER_LIST*)GetFirstNode(&mFileHandleList.Link)
1618     ;  !IsNull(&mFileHandleList.Link, &Node->Link)
1619     ;  Node = (BUFFER_LIST*)GetNextNode(&mFileHandleList.Link, &Node->Link)
1620    ){
1621     if ((Node->Buffer) && (((SHELL_COMMAND_FILE_HANDLE *)Node->Buffer)->FileHandle == Handle)){
1622       RemoveEntryList(&Node->Link);
1623       SHELL_FREE_NON_NULL(((SHELL_COMMAND_FILE_HANDLE *)Node->Buffer)->Path);
1624       SHELL_FREE_NON_NULL(Node->Buffer);
1625       SHELL_FREE_NON_NULL(Node);
1626       return (TRUE);
1627     }
1628   }
1629   return (FALSE);
1630 }
1631
1632 /**
1633   Function to determine if a SHELL_FILE_HANDLE is at the end of the file.
1634
1635   This will NOT work on directories.
1636
1637   If Handle is NULL, then ASSERT.
1638
1639   @param[in] Handle     the file handle
1640
1641   @retval TRUE          the position is at the end of the file
1642   @retval FALSE         the position is not at the end of the file
1643 **/
1644 BOOLEAN
1645 EFIAPI
1646 ShellFileHandleEof(
1647   IN SHELL_FILE_HANDLE Handle
1648   )
1649 {
1650   EFI_FILE_INFO *Info;
1651   UINT64        Pos;
1652   BOOLEAN       RetVal;
1653
1654   //
1655   // ASSERT if Handle is NULL
1656   //
1657   ASSERT(Handle != NULL);
1658
1659   gEfiShellProtocol->GetFilePosition(Handle, &Pos);
1660   Info = gEfiShellProtocol->GetFileInfo (Handle);
1661   gEfiShellProtocol->SetFilePosition(Handle, Pos);
1662
1663   if (Info == NULL) {
1664     return (FALSE);
1665   }
1666
1667   if (Pos == Info->FileSize) {
1668     RetVal = TRUE;
1669   } else {
1670     RetVal = FALSE;
1671   }
1672
1673   FreePool (Info);
1674
1675   return (RetVal);
1676 }
1677
1678 /**
1679   Frees any BUFFER_LIST defined type.
1680
1681   @param[in] List     The BUFFER_LIST object to free.
1682 **/
1683 VOID
1684 EFIAPI
1685 FreeBufferList (
1686   IN BUFFER_LIST *List
1687   )
1688 {
1689   BUFFER_LIST               *BufferListEntry;
1690
1691   if (List == NULL){
1692     return;
1693   }
1694   //
1695   // enumerate through the buffer list and free all memory
1696   //
1697   for ( BufferListEntry = ( BUFFER_LIST *)GetFirstNode(&List->Link)
1698       ; !IsListEmpty (&List->Link)
1699       ; BufferListEntry = (BUFFER_LIST *)GetFirstNode(&List->Link)
1700      ){
1701     RemoveEntryList(&BufferListEntry->Link);
1702     if (BufferListEntry->Buffer != NULL) {
1703       FreePool(BufferListEntry->Buffer);
1704     }
1705     FreePool(BufferListEntry);
1706   }
1707 }
1708
1709 /**
1710   Dump some hexadecimal data to the screen.
1711
1712   @param[in] Indent     How many spaces to indent the output.
1713   @param[in] Offset     The offset of the printing.
1714   @param[in] DataSize   The size in bytes of UserData.
1715   @param[in] UserData   The data to print out.
1716 **/
1717 VOID
1718 EFIAPI
1719 DumpHex (
1720   IN UINTN        Indent,
1721   IN UINTN        Offset,
1722   IN UINTN        DataSize,
1723   IN VOID         *UserData
1724   )
1725 {
1726   UINT8 *Data;
1727
1728   CHAR8 Val[50];
1729
1730   CHAR8 Str[20];
1731
1732   UINT8 TempByte;
1733   UINTN Size;
1734   UINTN Index;
1735
1736   Data = UserData;
1737   while (DataSize != 0) {
1738     Size = 16;
1739     if (Size > DataSize) {
1740       Size = DataSize;
1741     }
1742
1743     for (Index = 0; Index < Size; Index += 1) {
1744       TempByte            = Data[Index];
1745       Val[Index * 3 + 0]  = Hex[TempByte >> 4];
1746       Val[Index * 3 + 1]  = Hex[TempByte & 0xF];
1747       Val[Index * 3 + 2]  = (CHAR8) ((Index == 7) ? '-' : ' ');
1748       Str[Index]          = (CHAR8) ((TempByte < ' ' || TempByte > 'z') ? '.' : TempByte);
1749     }
1750
1751     Val[Index * 3]  = 0;
1752     Str[Index]      = 0;
1753     ShellPrintEx(-1, -1, L"%*a%08X: %-48a *%a*\r\n", Indent, "", Offset, Val, Str);
1754
1755     Data += Size;
1756     Offset += Size;
1757     DataSize -= Size;
1758   }
1759 }
1760
1761 /**
1762   Dump HEX data into buffer.
1763
1764   @param[in] Buffer     HEX data to be dumped in Buffer.
1765   @param[in] Indent     How many spaces to indent the output.
1766   @param[in] Offset     The offset of the printing.
1767   @param[in] DataSize   The size in bytes of UserData.
1768   @param[in] UserData   The data to print out.
1769 **/
1770 CHAR16*
1771 EFIAPI
1772 CatSDumpHex (
1773   IN CHAR16  *Buffer,
1774   IN UINTN   Indent,
1775   IN UINTN   Offset,
1776   IN UINTN   DataSize,
1777   IN VOID    *UserData
1778   )
1779 {
1780   UINT8   *Data;
1781   UINT8   TempByte;
1782   UINTN   Size;
1783   UINTN   Index;
1784   CHAR8   Val[50];
1785   CHAR8   Str[20];
1786   CHAR16  *RetVal;
1787   CHAR16  *TempRetVal;
1788
1789   Data = UserData;
1790   RetVal = Buffer;
1791   while (DataSize != 0) {
1792     Size = 16;
1793     if (Size > DataSize) {
1794       Size = DataSize;
1795     }
1796
1797     for (Index = 0; Index < Size; Index += 1) {
1798       TempByte            = Data[Index];
1799       Val[Index * 3 + 0]  = Hex[TempByte >> 4];
1800       Val[Index * 3 + 1]  = Hex[TempByte & 0xF];
1801       Val[Index * 3 + 2]  = (CHAR8) ((Index == 7) ? '-' : ' ');
1802       Str[Index]          = (CHAR8) ((TempByte < ' ' || TempByte > 'z') ? '.' : TempByte);
1803     }
1804
1805     Val[Index * 3]  = 0;
1806     Str[Index]      = 0;
1807     TempRetVal = CatSPrint (RetVal, L"%*a%08X: %-48a *%a*\r\n", Indent, "", Offset, Val, Str);
1808     SHELL_FREE_NON_NULL (RetVal);
1809     RetVal = TempRetVal;
1810
1811     Data += Size;
1812     Offset += Size;
1813     DataSize -= Size;
1814   }
1815
1816   return RetVal;
1817 }