[mirror_edk2.git] / ShellPkg / Library / UefiShellCommandLib / UefiShellCommandLib.c

/** @file\r
  Provides interface to shell internal functions for shell commands.\r
\r
  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>\r
  This program and the accompanying materials\r
  are licensed and made available under the terms and conditions of the BSD License\r
  which accompanies this distribution.  The full text of the license may be found at\r
  http://opensource.org/licenses/bsd-license.php\r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include "UefiShellCommandLib.h"\r
\r
/// The tag for use in identifying UNICODE files.\r
/// If the file is UNICODE, the first 16 bits of the file will equal this value.\r
enum {\r
  gUnicodeFileTag = 0xFEFF\r
};\r
\r
// STATIC local variables\r
STATIC SHELL_COMMAND_INTERNAL_LIST_ENTRY  mCommandList;\r
STATIC SCRIPT_FILE_LIST                   mScriptList;\r
STATIC ALIAS_LIST                         mAliasList;\r
STATIC BOOLEAN                            mEchoState;\r
STATIC BOOLEAN                            mExitRequested;\r
STATIC BOOLEAN                            mExitScript;\r
STATIC CHAR16                             *mProfileList;\r
STATIC UINTN                              mProfileListSize;\r
STATIC UINTN                              mFsMaxCount = 0;\r
STATIC UINTN                              mBlkMaxCount = 0;\r
STATIC BUFFER_LIST                        mFileHandleList;\r
\r
// global variables required by library class.\r
EFI_UNICODE_COLLATION_PROTOCOL    *gUnicodeCollation            = NULL;\r
EFI_DEVICE_PATH_TO_TEXT_PROTOCOL  *gDevPathToText               = NULL;\r
SHELL_MAP_LIST                    gShellMapList;\r
SHELL_MAP_LIST                    *gShellCurDir                 = NULL;\r
\r
CONST CHAR16* SupportLevel[] = {\r
  L"Minimal",\r
  L"Scripting",\r
  L"Basic",\r
  L"Interactive"\r
};\r
\r
/**\r
  Function to make sure that the global protocol pointers are valid.\r
  must be called after constructor before accessing the pointers.\r
**/\r
EFI_STATUS\r
EFIAPI\r
CommandInit(\r
  VOID\r
  )\r
{\r
  EFI_STATUS Status;\r
  if (gUnicodeCollation == NULL) {\r
    Status = gBS->LocateProtocol(&gEfiUnicodeCollation2ProtocolGuid, NULL, (VOID**)&gUnicodeCollation);\r
    if (EFI_ERROR(Status)) {\r
      return (EFI_DEVICE_ERROR);\r
    }\r
  }\r
  if (gDevPathToText == NULL) {\r
    Status = gBS->LocateProtocol(&gEfiDevicePathToTextProtocolGuid, NULL, (VOID**)&gDevPathToText);\r
    if (EFI_ERROR(Status)) {\r
      return (EFI_DEVICE_ERROR);\r
    }\r
  }\r
  return (EFI_SUCCESS);\r
}\r
\r
/**\r
  Constructor for the Shell Command library.\r
\r
  Initialize the library and determine if the underlying is a UEFI Shell 2.0 or an EFI shell.\r
\r
  @param ImageHandle    the image handle of the process\r
  @param SystemTable    the EFI System Table pointer\r
\r
  @retval EFI_SUCCESS   the initialization was complete sucessfully\r
**/\r
RETURN_STATUS\r
EFIAPI\r
ShellCommandLibConstructor (\r
  IN EFI_HANDLE        ImageHandle,\r
  IN EFI_SYSTEM_TABLE  *SystemTable\r
  )\r
{\r
  EFI_STATUS        Status;\r
  InitializeListHead(&gShellMapList.Link);\r
  InitializeListHead(&mCommandList.Link);\r
  InitializeListHead(&mAliasList.Link);\r
  InitializeListHead(&mScriptList.Link);\r
  InitializeListHead(&mFileHandleList.Link);\r
  mEchoState = TRUE;\r
\r
  mExitRequested    = FALSE;\r
  mExitScript       = FALSE;\r
  mProfileListSize  = 0;\r
  mProfileList      = NULL;\r
\r
  if (gUnicodeCollation == NULL) {\r
    Status = gBS->LocateProtocol(&gEfiUnicodeCollation2ProtocolGuid, NULL, (VOID**)&gUnicodeCollation);\r
    if (EFI_ERROR(Status)) {\r
      return (EFI_DEVICE_ERROR);\r
    }\r
  }\r
\r
  return (RETURN_SUCCESS);\r
}\r
\r
/**\r
  Destructor for the library.  free any resources.\r
\r
  @param ImageHandle    the image handle of the process\r
  @param SystemTable    the EFI System Table pointer\r
\r
  @retval RETURN_SUCCESS this function always returns success\r
**/\r
RETURN_STATUS\r
EFIAPI\r
ShellCommandLibDestructor (\r
  IN EFI_HANDLE        ImageHandle,\r
  IN EFI_SYSTEM_TABLE  *SystemTable\r
  )\r
{\r
  SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;\r
  COMMAND_LIST                      *Node2;\r
  SCRIPT_FILE_LIST                  *Node3;\r
  SHELL_MAP_LIST                    *MapNode;\r
  //\r
  // enumerate throught the list and free all the memory\r
  //\r
  while (!IsListEmpty (&mCommandList.Link)) {\r
    Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode(&mCommandList.Link);\r
    RemoveEntryList(&Node->Link);\r
    SHELL_FREE_NON_NULL(Node->CommandString);\r
    FreePool(Node);\r
    DEBUG_CODE(Node = NULL;);\r
  }\r
\r
  //\r
  // enumerate through the init command list and free all memory\r
  //\r
  while (!IsListEmpty (&mAliasList.Link)) {\r
    Node2 = (COMMAND_LIST *)GetFirstNode(&mAliasList.Link);\r
    RemoveEntryList(&Node2->Link);\r
    SHELL_FREE_NON_NULL(Node2->CommandString);\r
    FreePool(Node2);\r
    DEBUG_CODE(Node2 = NULL;);\r
  }\r
\r
  //\r
  // enumerate throught the list and free all the memory\r
  //\r
  while (!IsListEmpty (&mScriptList.Link)) {\r
    Node3 = (SCRIPT_FILE_LIST *)GetFirstNode(&mScriptList.Link);\r
    RemoveEntryList(&Node3->Link);\r
    DeleteScriptFileStruct(Node3->Data);\r
    FreePool(Node3);\r
  }\r
\r
  //\r
  // enumerate throught the mappings list and free all the memory\r
  //\r
  if (!IsListEmpty(&gShellMapList.Link)) {\r
    for (MapNode = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)\r
         ; !IsListEmpty (&gShellMapList.Link)\r
         ; MapNode = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)\r
        ){\r
      ASSERT(MapNode != NULL);\r
      RemoveEntryList(&MapNode->Link);\r
      SHELL_FREE_NON_NULL(MapNode->DevicePath);\r
      SHELL_FREE_NON_NULL(MapNode->MapName);\r
      SHELL_FREE_NON_NULL(MapNode->CurrentDirectoryPath);\r
      FreePool(MapNode);\r
    }\r
  }\r
  if (!IsListEmpty(&mFileHandleList.Link)){\r
    FreeBufferList(&mFileHandleList);\r
  }\r
\r
  if (mProfileList != NULL) {\r
    FreePool(mProfileList);\r
  }\r
\r
  gUnicodeCollation            = NULL;\r
  gDevPathToText               = NULL;\r
  gShellCurDir                 = NULL;\r
\r
  return (RETURN_SUCCESS);\r
}\r
\r
/**\r
  Checks if a command is already on the list.\r
\r
  @param[in] CommandString        The command string to check for on the list.\r
**/\r
BOOLEAN\r
EFIAPI\r
ShellCommandIsCommandOnList (\r
  IN CONST  CHAR16                      *CommandString\r
  )\r
{\r
  SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;\r
\r
  //\r
  // assert for NULL parameter\r
  //\r
  ASSERT(CommandString != NULL);\r
\r
  //\r
  // check for the command\r
  //\r
  for ( Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode(&mCommandList.Link)\r
      ; !IsNull(&mCommandList.Link, &Node->Link)\r
      ; Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetNextNode(&mCommandList.Link, &Node->Link)\r
     ){\r
    ASSERT(Node->CommandString != NULL);\r
    if (gUnicodeCollation->StriColl(\r
          gUnicodeCollation,\r
          (CHAR16*)CommandString,\r
          Node->CommandString) == 0\r
       ){\r
      return (TRUE);\r
    }\r
  }\r
  return (FALSE);\r
}\r
\r
/**\r
  Get the help text for a command.\r
\r
  @param[in] CommandString        The command name.\r
\r
  @retval NULL  No help text was found.\r
  @return       String of help text. Caller reuiqred to free.\r
**/\r
CHAR16*\r
EFIAPI\r
ShellCommandGetCommandHelp (\r
  IN CONST  CHAR16                      *CommandString\r
  )\r
{\r
  SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;\r
\r
  //\r
  // assert for NULL parameter\r
  //\r
  ASSERT(CommandString != NULL);\r
\r
  //\r
  // check for the command\r
  //\r
  for ( Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode(&mCommandList.Link)\r
      ; !IsNull(&mCommandList.Link, &Node->Link)\r
      ; Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetNextNode(&mCommandList.Link, &Node->Link)\r
     ){\r
    ASSERT(Node->CommandString != NULL);\r
    if (gUnicodeCollation->StriColl(\r
          gUnicodeCollation,\r
          (CHAR16*)CommandString,\r
          Node->CommandString) == 0\r
       ){\r
      return (HiiGetString(Node->HiiHandle, Node->ManFormatHelp, NULL));\r
    }\r
  }\r
  return (NULL);\r
}\r
\r
/**\r
  Registers handlers of type SHELL_RUN_COMMAND and\r
  SHELL_GET_MAN_FILENAME for each shell command.\r
\r
  If the ShellSupportLevel is greater than the value of the\r
  PcdShellSupportLevel then return RETURN_UNSUPPORTED.\r
\r
  Registers the handlers specified by GetHelpInfoHandler and CommandHandler\r
  with the command specified by CommandString. If the command named by\r
  CommandString has already been registered, then return\r
  RETURN_ALREADY_STARTED.\r
\r
  If there are not enough resources available to register the handlers then\r
  RETURN_OUT_OF_RESOURCES is returned.\r
\r
  If CommandString is NULL, then ASSERT().\r
  If GetHelpInfoHandler is NULL, then ASSERT().\r
  If CommandHandler is NULL, then ASSERT().\r
  If ProfileName is NULL, then ASSERT().\r
\r
  @param[in]  CommandString         Pointer to the command name.  This is the\r
                                    name to look for on the command line in\r
                                    the shell.\r
  @param[in]  CommandHandler        Pointer to a function that runs the\r
                                    specified command.\r
  @param[in]  GetManFileName        Pointer to a function that provides man\r
                                    filename.\r
  @param[in]  ShellMinSupportLevel  minimum Shell Support Level which has this\r
                                    function.\r
  @param[in]  ProfileName           profile name to require for support of this\r
                                    function.\r
  @param[in]  CanAffectLE           indicates whether this command's return value\r
                                    can change the LASTERROR environment variable.\r
  @param[in]  HiiHandle             Handle of this command's HII entry.\r
  @param[in]  ManFormatHelp         HII locator for the help text.\r
\r
  @retval  RETURN_SUCCESS           The handlers were registered.\r
  @retval  RETURN_OUT_OF_RESOURCES  There are not enough resources available to\r
                                    register the shell command.\r
  @retval RETURN_UNSUPPORTED        the ShellMinSupportLevel was higher than the\r
                                    currently allowed support level.\r
  @retval RETURN_ALREADY_STARTED    The CommandString represents a command that\r
                                    is already registered.  Only 1 handler set for\r
                                    a given command is allowed.\r
  @sa SHELL_GET_MAN_FILENAME\r
  @sa SHELL_RUN_COMMAND\r
**/\r
RETURN_STATUS\r
EFIAPI\r
ShellCommandRegisterCommandName (\r
  IN CONST  CHAR16                      *CommandString,\r
  IN        SHELL_RUN_COMMAND           CommandHandler,\r
  IN        SHELL_GET_MAN_FILENAME      GetManFileName,\r
  IN        UINT32                      ShellMinSupportLevel,\r
  IN CONST  CHAR16                      *ProfileName,\r
  IN CONST  BOOLEAN                     CanAffectLE,\r
  IN CONST  EFI_HANDLE                  HiiHandle,\r
  IN CONST  EFI_STRING_ID               ManFormatHelp\r
  )\r
{\r
  SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;\r
\r
  //\r
  // ASSERTs for NULL parameters\r
  //\r
  ASSERT(CommandString  != NULL);\r
  ASSERT(GetManFileName != NULL);\r
  ASSERT(CommandHandler != NULL);\r
  ASSERT(ProfileName    != NULL);\r
\r
  //\r
  // check for shell support level\r
  //\r
  if (PcdGet8(PcdShellSupportLevel) < ShellMinSupportLevel) {\r
    return (RETURN_UNSUPPORTED);\r
  }\r
\r
  //\r
  // check for already on the list\r
  //\r
  if (ShellCommandIsCommandOnList(CommandString)) {\r
    return (RETURN_ALREADY_STARTED);\r
  }\r
\r
  //\r
  // allocate memory for new struct\r
  //\r
  Node = AllocateZeroPool(sizeof(SHELL_COMMAND_INTERNAL_LIST_ENTRY));\r
  ASSERT(Node != NULL);\r
  Node->CommandString = AllocateZeroPool(StrSize(CommandString));\r
  ASSERT(Node->CommandString != NULL);\r
\r
  //\r
  // populate the new struct\r
  //\r
  StrCpy(Node->CommandString, CommandString);\r
\r
  Node->GetManFileName  = GetManFileName;\r
  Node->CommandHandler  = CommandHandler;\r
  Node->LastError       = CanAffectLE;\r
  Node->HiiHandle       = HiiHandle;\r
  Node->ManFormatHelp   = ManFormatHelp;\r
\r
  if ( StrLen(ProfileName)>0\r
    && ((mProfileList != NULL\r
    && StrStr(mProfileList, ProfileName) == NULL) || mProfileList == NULL)\r
   ){\r
    ASSERT((mProfileList == NULL && mProfileListSize == 0) || (mProfileList != NULL));\r
    if (mProfileList == NULL) {\r
      //\r
      // If this is the first make a leading ';'\r
      //\r
      StrnCatGrow(&mProfileList, &mProfileListSize, L";", 0);\r
    }\r
    StrnCatGrow(&mProfileList, &mProfileListSize, ProfileName, 0);\r
    StrnCatGrow(&mProfileList, &mProfileListSize, L";", 0);\r
  }\r
\r
  //\r
  // add the new struct to the list\r
  //\r
  InsertTailList (&mCommandList.Link, &Node->Link);\r
\r
  return (RETURN_SUCCESS);\r
}\r
\r
/**\r
  Function to get the current Profile string.\r
\r
  @retval NULL  There are no installed profiles.\r
  @return       A semi-colon delimited list of profiles.\r
**/\r
CONST CHAR16 *\r
EFIAPI\r
ShellCommandGetProfileList (\r
  VOID\r
  )\r
{\r
  return (mProfileList);\r
}\r
\r
/**\r
  Checks if a command string has been registered for CommandString and if so it runs\r
  the previously registered handler for that command with the command line.\r
\r
  If CommandString is NULL, then ASSERT().\r
\r
  If Sections is specified, then each section name listed will be compared in a casesensitive\r
  manner, to the section names described in Appendix B UEFI Shell 2.0 spec. If the section exists,\r
  it will be appended to the returned help text. If the section does not exist, no\r
  information will be returned. If Sections is NULL, then all help text information\r
  available will be returned.\r
\r
  @param[in]  CommandString         Pointer to the command name.  This is the name\r
                                    found on the command line in the shell.\r
  @param[in,out] RetVal             Pointer to the return vaule from the command handler.\r
\r
  @param[in,out]  CanAffectLE       indicates whether this command's return value\r
                                    needs to be placed into LASTERROR environment variable.\r
\r
  @retval RETURN_SUCCESS            The handler was run.\r
  @retval RETURN_NOT_FOUND          The CommandString did not match a registered\r
                                    command name.\r
  @sa SHELL_RUN_COMMAND\r
**/\r
RETURN_STATUS\r
EFIAPI\r
ShellCommandRunCommandHandler (\r
  IN CONST CHAR16               *CommandString,\r
  IN OUT SHELL_STATUS           *RetVal,\r
  IN OUT BOOLEAN                *CanAffectLE OPTIONAL\r
  )\r
{\r
  SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;\r
\r
  //\r
  // assert for NULL parameters\r
  //\r
  ASSERT(CommandString != NULL);\r
\r
  //\r
  // check for the command\r
  //\r
  for ( Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode(&mCommandList.Link)\r
      ; !IsNull(&mCommandList.Link, &Node->Link)\r
      ; Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetNextNode(&mCommandList.Link, &Node->Link)\r
     ){\r
    ASSERT(Node->CommandString != NULL);\r
    if (gUnicodeCollation->StriColl(\r
          gUnicodeCollation,\r
          (CHAR16*)CommandString,\r
          Node->CommandString) == 0\r
       ){\r
      if (CanAffectLE != NULL) {\r
        *CanAffectLE = Node->LastError;\r
      }\r
      if (RetVal != NULL) {\r
        *RetVal = Node->CommandHandler(NULL, gST);\r
      } else {\r
        Node->CommandHandler(NULL, gST);\r
      }\r
      return (RETURN_SUCCESS);\r
    }\r
  }\r
  return (RETURN_NOT_FOUND);\r
}\r
\r
/**\r
  Checks if a command string has been registered for CommandString and if so it\r
  returns the MAN filename specified for that command.\r
\r
  If CommandString is NULL, then ASSERT().\r
\r
  @param[in]  CommandString         Pointer to the command name.  This is the name\r
                                    found on the command line in the shell.\\r
\r
  @retval NULL                      the commandString was not a registered command.\r
  @return other                     the name of the MAN file.\r
  @sa SHELL_GET_MAN_FILENAME\r
**/\r
CONST CHAR16*\r
EFIAPI\r
ShellCommandGetManFileNameHandler (\r
  IN CONST CHAR16               *CommandString\r
  )\r
{\r
  SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;\r
\r
  //\r
  // assert for NULL parameters\r
  //\r
  ASSERT(CommandString != NULL);\r
\r
  //\r
  // check for the command\r
  //\r
  for ( Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode(&mCommandList.Link)\r
      ; !IsNull(&mCommandList.Link, &Node->Link)\r
      ; Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetNextNode(&mCommandList.Link, &Node->Link)\r
     ){\r
    ASSERT(Node->CommandString != NULL);\r
    if (gUnicodeCollation->StriColl(\r
          gUnicodeCollation,\r
          (CHAR16*)CommandString,\r
          Node->CommandString) == 0\r
       ){\r
      return (Node->GetManFileName());\r
    }\r
  }\r
  return (NULL);\r
}\r
\r
/**\r
  Get the list of all available shell internal commands.  This is a linked list\r
  (via LIST_ENTRY structure).  enumerate through it using the BaseLib linked\r
  list functions.  do not modify the values.\r
\r
  @param[in] Sort       TRUE to alphabetically sort the values first.  FALSE otherwise.\r
\r
  @return a Linked list of all available shell commands.\r
**/\r
CONST COMMAND_LIST*\r
EFIAPI\r
ShellCommandGetCommandList (\r
  IN CONST BOOLEAN Sort\r
  )\r
{\r
//  if (!Sort) {\r
//    return ((COMMAND_LIST*)(&mCommandList));\r
//  }\r
  return ((COMMAND_LIST*)(&mCommandList));\r
}\r
\r
/**\r
  Registers aliases to be set as part of the initialization of the shell application.\r
\r
  If Command is NULL, then ASSERT().\r
  If Alias is NULL, then ASSERT().\r
\r
  @param[in]  Command               Pointer to the Command\r
  @param[in]  Alias                 Pointer to Alias\r
\r
  @retval  RETURN_SUCCESS           The handlers were registered.\r
  @retval  RETURN_OUT_OF_RESOURCES  There are not enough resources available to\r
                                    register the shell command.\r
**/\r
RETURN_STATUS\r
EFIAPI\r
ShellCommandRegisterAlias (\r
  IN CONST CHAR16                       *Command,\r
  IN CONST CHAR16                       *Alias\r
  )\r
{\r
  ALIAS_LIST *Node;\r
\r
  //\r
  // Asserts for NULL\r
  //\r
  ASSERT(Command != NULL);\r
  ASSERT(Alias   != NULL);\r
\r
  //\r
  // allocate memory for new struct\r
  //\r
  Node = AllocateZeroPool(sizeof(ALIAS_LIST));\r
  ASSERT(Node != NULL);\r
  Node->CommandString = AllocateZeroPool(StrSize(Command));\r
  Node->Alias = AllocateZeroPool(StrSize(Alias));\r
  ASSERT(Node->CommandString != NULL);\r
  ASSERT(Node->Alias != NULL);\r
\r
  //\r
  // populate the new struct\r
  //\r
  StrCpy(Node->CommandString, Command);\r
  StrCpy(Node->Alias        , Alias );\r
\r
  //\r
  // add the new struct to the list\r
  //\r
  InsertTailList (&mAliasList.Link, &Node->Link);\r
\r
  return (RETURN_SUCCESS);\r
}\r
\r
/**\r
  Get the list of all shell alias commands.  This is a linked list\r
  (via LIST_ENTRY structure).  enumerate through it using the BaseLib linked\r
  list functions.  do not modify the values.\r
\r
  @return a Linked list of all requested shell alias'.\r
**/\r
CONST ALIAS_LIST*\r
EFIAPI\r
ShellCommandGetInitAliasList (\r
  VOID\r
  )\r
{\r
    return (&mAliasList);\r
}\r
\r
/**\r
  Determine if a given alias is on the list of built in alias'.\r
\r
  @param[in] Alias              The alias to test for\r
\r
  @retval TRUE                  The alias is a built in alias\r
  @retval FALSE                 The alias is not a built in alias\r
**/\r
BOOLEAN\r
EFIAPI\r
ShellCommandIsOnAliasList(\r
  IN CONST CHAR16 *Alias\r
  )\r
{\r
  ALIAS_LIST *Node;\r
\r
  //\r
  // assert for NULL parameter\r
  //\r
  ASSERT(Alias != NULL);\r
\r
  //\r
  // check for the Alias\r
  //\r
  for ( Node = (ALIAS_LIST *)GetFirstNode(&mAliasList.Link)\r
      ; !IsNull(&mAliasList.Link, &Node->Link)\r
      ; Node = (ALIAS_LIST *)GetNextNode(&mAliasList.Link, &Node->Link)\r
     ){\r
    ASSERT(Node->CommandString != NULL);\r
    ASSERT(Node->Alias != NULL);\r
    if (gUnicodeCollation->StriColl(\r
          gUnicodeCollation,\r
          (CHAR16*)Alias,\r
          Node->CommandString) == 0\r
       ){\r
      return (TRUE);\r
    }\r
    if (gUnicodeCollation->StriColl(\r
          gUnicodeCollation,\r
          (CHAR16*)Alias,\r
          Node->Alias) == 0\r
       ){\r
      return (TRUE);\r
    }\r
  }\r
  return (FALSE);\r
}\r
\r
/**\r
  Function to determine current state of ECHO.  Echo determins if lines from scripts\r
  and ECHO commands are enabled.\r
\r
  @retval TRUE    Echo is currently enabled\r
  @retval FALSE   Echo is currently disabled\r
**/\r
BOOLEAN\r
EFIAPI\r
ShellCommandGetEchoState(\r
  VOID\r
  )\r
{\r
  return (mEchoState);\r
}\r
\r
/**\r
  Function to set current state of ECHO.  Echo determins if lines from scripts\r
  and ECHO commands are enabled.\r
\r
  If State is TRUE, Echo will be enabled.\r
  If State is FALSE, Echo will be disabled.\r
\r
  @param[in] State      How to set echo.\r
**/\r
VOID\r
EFIAPI\r
ShellCommandSetEchoState(\r
  IN BOOLEAN State\r
  )\r
{\r
  mEchoState = State;\r
}\r
\r
/**\r
  Indicate that the current shell or script should exit.\r
\r
  @param[in] ScriptOnly   TRUE if only exiting a script, FALSE othrwise.\r
**/\r
VOID\r
EFIAPI\r
ShellCommandRegisterExit (\r
  IN BOOLEAN ScriptOnly\r
  )\r
{\r
  mExitRequested = (BOOLEAN)(!mExitRequested);\r
  if (mExitRequested) {\r
    mExitScript    = ScriptOnly;\r
  } else {\r
    mExitScript    = FALSE;\r
  }\r
}\r
\r
/**\r
  Retrieve the Exit indicator.\r
\r
  @retval TRUE      Exit was indicated.\r
  @retval FALSE     Exis was not indicated.\r
**/\r
BOOLEAN\r
EFIAPI\r
ShellCommandGetExit (\r
  VOID\r
  )\r
{\r
  return (mExitRequested);\r
}\r
\r
/**\r
  Retrieve the Exit script indicator.\r
\r
  If ShellCommandGetExit returns FALSE than the return from this is undefined.\r
\r
  @retval TRUE      ScriptOnly was indicated.\r
  @retval FALSE     ScriptOnly was not indicated.\r
**/\r
BOOLEAN\r
EFIAPI\r
ShellCommandGetScriptExit (\r
  VOID\r
  )\r
{\r
  return (mExitScript);\r
}\r
\r
/**\r
  Function to cleanup all memory from a SCRIPT_FILE structure.\r
\r
  @param[in] Script     The pointer to the structure to cleanup.\r
**/\r
VOID\r
EFIAPI\r
DeleteScriptFileStruct (\r
  IN SCRIPT_FILE *Script\r
  )\r
{\r
  UINT8       LoopVar;\r
\r
  if (Script == NULL) {\r
    return;\r
  }\r
\r
  for (LoopVar = 0 ; LoopVar < Script->Argc ; LoopVar++) {\r
    SHELL_FREE_NON_NULL(Script->Argv[LoopVar]);\r
  }\r
  if (Script->Argv != NULL) {\r
    SHELL_FREE_NON_NULL(Script->Argv);\r
  }\r
  Script->CurrentCommand = NULL;\r
  while (!IsListEmpty (&Script->CommandList)) {\r
    Script->CurrentCommand = (SCRIPT_COMMAND_LIST *)GetFirstNode(&Script->CommandList);\r
    if (Script->CurrentCommand != NULL) {\r
      RemoveEntryList(&Script->CurrentCommand->Link);\r
      if (Script->CurrentCommand->Cl != NULL) {\r
        SHELL_FREE_NON_NULL(Script->CurrentCommand->Cl);\r
      }\r
      if (Script->CurrentCommand->Data != NULL) {\r
        SHELL_FREE_NON_NULL(Script->CurrentCommand->Data);\r
      }\r
      SHELL_FREE_NON_NULL(Script->CurrentCommand);\r
    }\r
  }\r
  SHELL_FREE_NON_NULL(Script->ScriptName);\r
  SHELL_FREE_NON_NULL(Script);\r
}\r
\r
/**\r
  Function to return a pointer to the currently running script file object.\r
\r
  @retval NULL        A script file is not currently running.\r
  @return             A pointer to the current script file object.\r
**/\r
SCRIPT_FILE*\r
EFIAPI\r
ShellCommandGetCurrentScriptFile (\r
  VOID\r
  )\r
{\r
  SCRIPT_FILE_LIST *List;\r
  if (IsListEmpty (&mScriptList.Link)) {\r
    return (NULL);\r
  }\r
  List = ((SCRIPT_FILE_LIST*)GetFirstNode(&mScriptList.Link));\r
  return (List->Data);\r
}\r
\r
/**\r
  Function to set a new script as the currently running one.\r
\r
  This function will correctly stack and unstack nested scripts.\r
\r
  @param[in] Script   Pointer to new script information structure.  if NULL\r
                      will remove and de-allocate the top-most Script structure.\r
\r
  @return             A pointer to the current running script file after this\r
                      change.  NULL if removing the final script.\r
**/\r
SCRIPT_FILE*\r
EFIAPI\r
ShellCommandSetNewScript (\r
  IN SCRIPT_FILE *Script OPTIONAL\r
  )\r
{\r
  SCRIPT_FILE_LIST *Node;\r
  if (Script == NULL) {\r
    if (IsListEmpty (&mScriptList.Link)) {\r
      return (NULL);\r
    }\r
    Node = (SCRIPT_FILE_LIST *)GetFirstNode(&mScriptList.Link);\r
    RemoveEntryList(&Node->Link);\r
    DeleteScriptFileStruct(Node->Data);\r
    FreePool(Node);\r
  } else {\r
    Node = AllocateZeroPool(sizeof(SCRIPT_FILE_LIST));\r
    if (Node == NULL) {\r
      return (NULL);\r
    }\r
    Node->Data = Script;\r
    InsertHeadList(&mScriptList.Link, &Node->Link);\r
  }\r
  return (ShellCommandGetCurrentScriptFile());\r
}\r
\r
/**\r
  Function to generate the next default mapping name.\r
\r
  If the return value is not NULL then it must be callee freed.\r
\r
  @param Type                   What kind of mapping name to make.\r
\r
  @retval NULL                  a memory allocation failed.\r
  @return a new map name string\r
**/\r
CHAR16*\r
EFIAPI\r
ShellCommandCreateNewMappingName(\r
  IN CONST SHELL_MAPPING_TYPE Type\r
  )\r
{\r
  CHAR16  *String;\r
  ASSERT(Type < MappingTypeMax);\r
\r
  String = NULL;\r
\r
  String = AllocateZeroPool(PcdGet8(PcdShellMapNameLength) * sizeof(String[0]));\r
  UnicodeSPrint(\r
    String,\r
    PcdGet8(PcdShellMapNameLength) * sizeof(String[0]),\r
    Type == MappingTypeFileSystem?L"FS%d:":L"BLK%d:",\r
    Type == MappingTypeFileSystem?mFsMaxCount++:mBlkMaxCount++);\r
\r
  return (String);\r
}\r
\r
/**\r
  Function to add a map node to the list of map items and update the "path" environment variable (optionally).\r
\r
  If Path is TRUE (during initialization only), the path environment variable will also be updated to include\r
  default paths on the new map name...\r
\r
  Path should be FALSE when this function is called from the protocol SetMap function.\r
\r
  @param[in] Name               The human readable mapped name.\r
  @param[in] DevicePath         The Device Path for this map.\r
  @param[in] Flags              The Flags attribute for this map item.\r
  @param[in] Path               TRUE to update path, FALSE to skip this step (should only be TRUE during initialization).\r
\r
  @retval EFI_SUCCESS           The addition was sucessful.\r
  @retval EFI_OUT_OF_RESOURCES  A memory allocation failed.\r
  @retval EFI_INVALID_PARAMETER A parameter was invalid.\r
**/\r
EFI_STATUS\r
EFIAPI\r
ShellCommandAddMapItemAndUpdatePath(\r
  IN CONST CHAR16                   *Name,\r
  IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,\r
  IN CONST UINT64                   Flags,\r
  IN CONST BOOLEAN                  Path\r
  )\r
{\r
  EFI_STATUS      Status;\r
  SHELL_MAP_LIST  *MapListNode;\r
  CONST CHAR16    *OriginalPath;\r
  CHAR16          *NewPath;\r
  UINTN           NewPathSize;\r
\r
  NewPathSize = 0;\r
  NewPath = NULL;\r
  OriginalPath = NULL;\r
  Status = EFI_SUCCESS;\r
\r
  MapListNode = AllocateZeroPool(sizeof(SHELL_MAP_LIST));\r
  if (MapListNode == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
  } else {\r
    MapListNode->Flags = Flags;\r
    MapListNode->MapName = AllocateZeroPool(StrSize(Name));\r
    MapListNode->DevicePath = DuplicateDevicePath(DevicePath);\r
    if ((MapListNode->MapName == NULL) || (MapListNode->DevicePath == NULL)){\r
      Status = EFI_OUT_OF_RESOURCES;\r
    } else {\r
      StrCpy(MapListNode->MapName, Name);\r
      InsertTailList(&gShellMapList.Link, &MapListNode->Link);\r
    }\r
  }\r
  if (EFI_ERROR(Status)) {\r
    if (MapListNode != NULL) {\r
      if (MapListNode->DevicePath != NULL) {\r
        FreePool(MapListNode->DevicePath);\r
      }\r
      if (MapListNode->MapName != NULL) {\r
        FreePool(MapListNode->MapName);\r
      }\r
      FreePool(MapListNode);\r
    }\r
  } else if (Path) {\r
    //\r
    // Since there was no error and Path was TRUE\r
    // Now add the correct path for that mapping\r
    //\r
    OriginalPath = gEfiShellProtocol->GetEnv(L"path");\r
    ASSERT((NewPath == NULL && NewPathSize == 0) || (NewPath != NULL));\r
    if (OriginalPath != NULL) {\r
      StrnCatGrow(&NewPath, &NewPathSize, OriginalPath, 0);\r
    } else {\r
      StrnCatGrow(&NewPath, &NewPathSize, L".\\", 0);\r
    }\r
    StrnCatGrow(&NewPath, &NewPathSize, L";", 0);\r
    StrnCatGrow(&NewPath, &NewPathSize, Name, 0);\r
    StrnCatGrow(&NewPath, &NewPathSize, L"\\efi\\tools\\;", 0);\r
    StrnCatGrow(&NewPath, &NewPathSize, Name, 0);\r
    StrnCatGrow(&NewPath, &NewPathSize, L"\\efi\\boot\\;", 0);\r
    StrnCatGrow(&NewPath, &NewPathSize, Name, 0);\r
    StrnCatGrow(&NewPath, &NewPathSize, L"\\", 0);\r
\r
    Status = gEfiShellProtocol->SetEnv(L"path", NewPath, TRUE);\r
    ASSERT_EFI_ERROR(Status);\r
    FreePool(NewPath);\r
  }\r
  return (Status);\r
}\r
\r
/**\r
  Creates the default map names for each device path in the system with\r
  a protocol depending on the Type.\r
\r
  Creates the consistent map names for each device path in the system with\r
  a protocol depending on the Type.\r
\r
  Note: This will reset all mappings in the system("map -r").\r
\r
  Also sets up the default path environment variable if Type is FileSystem.\r
\r
  @retval EFI_SUCCESS           All map names were created sucessfully.\r
  @retval EFI_NOT_FOUND         No protocols were found in the system.\r
  @return                       Error returned from gBS->LocateHandle().\r
\r
  @sa LocateHandle\r
**/\r
EFI_STATUS\r
EFIAPI\r
ShellCommandCreateInitialMappingsAndPaths(\r
  VOID\r
  )\r
{\r
  EFI_STATUS                Status;\r
  EFI_HANDLE                *HandleList;\r
  UINTN                     Count;\r
  EFI_DEVICE_PATH_PROTOCOL  **DevicePathList;\r
  CHAR16                    *NewDefaultName;\r
  CHAR16                    *NewConsistName;\r
  EFI_DEVICE_PATH_PROTOCOL  **ConsistMappingTable;\r
  SHELL_MAP_LIST            *MapListNode;\r
\r
  HandleList  = NULL;\r
\r
  //\r
  // Reset the static members back to zero\r
  //\r
  mFsMaxCount = 0;\r
  mBlkMaxCount = 0;\r
\r
  gEfiShellProtocol->SetEnv(L"path", L"", TRUE);\r
\r
  //\r
  // First empty out the existing list.\r
  //\r
  if (!IsListEmpty(&gShellMapList.Link)) {\r
    for ( MapListNode = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)\r
        ; !IsListEmpty(&gShellMapList.Link)\r
        ; MapListNode = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)\r
       ){\r
          RemoveEntryList(&MapListNode->Link);\r
          FreePool(MapListNode);\r
    } // for loop\r
  }\r
\r
  //\r
  // Find each handle with Simple File System\r
  //\r
  HandleList = GetHandleListByProtocol(&gEfiSimpleFileSystemProtocolGuid);\r
  if (HandleList != NULL) {\r
    //\r
    // Do a count of the handles\r
    //\r
    for (Count = 0 ; HandleList[Count] != NULL ; Count++);\r
\r
    //\r
    // Get all Device Paths\r
    //\r
    DevicePathList = AllocateZeroPool(sizeof(EFI_DEVICE_PATH_PROTOCOL*) * Count);\r
    ASSERT(DevicePathList != NULL);\r
\r
    for (Count = 0 ; HandleList[Count] != NULL ; Count++) {\r
      DevicePathList[Count] = DevicePathFromHandle(HandleList[Count]);\r
    }\r
\r
    //\r
    // Sort all DevicePaths\r
    //\r
    PerformQuickSort(DevicePathList, Count, sizeof(EFI_DEVICE_PATH_PROTOCOL*), DevicePathCompare);\r
\r
    ShellCommandConsistMappingInitialize(&ConsistMappingTable);\r
    //\r
    // Assign new Mappings to all...\r
    //\r
    for (Count = 0 ; HandleList[Count] != NULL ; Count++) {\r
      //\r
      // Get default name first\r
      //\r
      NewDefaultName = ShellCommandCreateNewMappingName(MappingTypeFileSystem);\r
      ASSERT(NewDefaultName != NULL);\r
      Status = ShellCommandAddMapItemAndUpdatePath(NewDefaultName, DevicePathList[Count], 0, TRUE);\r
      ASSERT_EFI_ERROR(Status);\r
      FreePool(NewDefaultName);\r
\r
      //\r
      // Now do consistent name\r
      //\r
      NewConsistName = ShellCommandConsistMappingGenMappingName(DevicePathList[Count], ConsistMappingTable);\r
      if (NewConsistName != NULL) {\r
        Status = ShellCommandAddMapItemAndUpdatePath(NewConsistName, DevicePathList[Count], 0, FALSE);\r
        ASSERT_EFI_ERROR(Status);\r
        FreePool(NewConsistName);\r
      }\r
    }\r
\r
    ShellCommandConsistMappingUnInitialize(ConsistMappingTable);\r
\r
    SHELL_FREE_NON_NULL(HandleList);\r
    SHELL_FREE_NON_NULL(DevicePathList);\r
\r
    HandleList = NULL;\r
  } else {\r
    Count = (UINTN)-1;\r
  }\r
\r
  //\r
  // Find each handle with Block Io\r
  //\r
  HandleList = GetHandleListByProtocol(&gEfiBlockIoProtocolGuid);\r
  if (HandleList != NULL) {\r
    for (Count = 0 ; HandleList[Count] != NULL ; Count++);\r
\r
    //\r
    // Get all Device Paths\r
    //\r
    DevicePathList = AllocateZeroPool(sizeof(EFI_DEVICE_PATH_PROTOCOL*) * Count);\r
    ASSERT(DevicePathList != NULL);\r
\r
    for (Count = 0 ; HandleList[Count] != NULL ; Count++) {\r
      DevicePathList[Count] = DevicePathFromHandle(HandleList[Count]);\r
    }\r
\r
    //\r
    // Sort all DevicePaths\r
    //\r
    PerformQuickSort(DevicePathList, Count, sizeof(EFI_DEVICE_PATH_PROTOCOL*), DevicePathCompare);\r
\r
    //\r
    // Assign new Mappings to all...\r
    //\r
    for (Count = 0 ; HandleList[Count] != NULL ; Count++) {\r
      //\r
      // Get default name first\r
      //\r
      NewDefaultName = ShellCommandCreateNewMappingName(MappingTypeBlockIo);\r
      ASSERT(NewDefaultName != NULL);\r
      Status = ShellCommandAddMapItemAndUpdatePath(NewDefaultName, DevicePathList[Count], 0, FALSE);\r
      ASSERT_EFI_ERROR(Status);\r
      FreePool(NewDefaultName);\r
    }\r
\r
    SHELL_FREE_NON_NULL(HandleList);\r
    SHELL_FREE_NON_NULL(DevicePathList);\r
  } else if (Count == (UINTN)-1) {\r
    return (EFI_NOT_FOUND);\r
  }\r
\r
  return (EFI_SUCCESS);\r
}\r
\r
/**\r
  Converts a SHELL_FILE_HANDLE to an EFI_FILE_PROTOCOL*.\r
\r
  @param[in] Handle     The SHELL_FILE_HANDLE to convert.\r
\r
  @return a EFI_FILE_PROTOCOL* representing the same file.\r
**/\r
EFI_FILE_PROTOCOL*\r
EFIAPI\r
ConvertShellHandleToEfiFileProtocol(\r
  IN CONST SHELL_FILE_HANDLE Handle\r
  )\r
{\r
  return ((EFI_FILE_PROTOCOL*)(Handle));\r
}\r
\r
/**\r
  Converts a EFI_FILE_PROTOCOL* to an SHELL_FILE_HANDLE.\r
\r
  @param[in] Handle     The pointer to EFI_FILE_PROTOCOL to convert.\r
  @param[in] Path       The path to the file for verification.\r
\r
  @return               A SHELL_FILE_HANDLE representing the same file.\r
  @retval NULL          There was not enough memory.\r
**/\r
SHELL_FILE_HANDLE\r
EFIAPI\r
ConvertEfiFileProtocolToShellHandle(\r
  IN CONST EFI_FILE_PROTOCOL *Handle,\r
  IN CONST CHAR16            *Path\r
  )\r
{\r
  SHELL_COMMAND_FILE_HANDLE *Buffer;\r
  BUFFER_LIST               *NewNode;\r
\r
  if (Path != NULL) {\r
    Buffer              = AllocateZeroPool(sizeof(SHELL_COMMAND_FILE_HANDLE));\r
    if (Buffer == NULL) {\r
      return (NULL);\r
    }\r
    NewNode             = AllocateZeroPool(sizeof(BUFFER_LIST));\r
    if (NewNode == NULL) {\r
      return (NULL);\r
    }\r
    Buffer->FileHandle  = (EFI_FILE_PROTOCOL*)Handle;\r
    Buffer->Path        = StrnCatGrow(&Buffer->Path, NULL, Path, 0);\r
    if (Buffer->Path == NULL) {\r
      return (NULL);\r
    }\r
    NewNode->Buffer     = Buffer;\r
\r
    InsertHeadList(&mFileHandleList.Link, &NewNode->Link);\r
  }\r
  return ((SHELL_FILE_HANDLE)(Handle));\r
}\r
\r
/**\r
  Find the path that was logged with the specified SHELL_FILE_HANDLE.\r
\r
  @param[in] Handle     The SHELL_FILE_HANDLE to query on.\r
\r
  @return A pointer to the path for the file.\r
**/\r
CONST CHAR16*\r
EFIAPI\r
ShellFileHandleGetPath(\r
  IN CONST SHELL_FILE_HANDLE Handle\r
  )\r
{\r
  BUFFER_LIST               *Node;\r
\r
  for (Node = (BUFFER_LIST*)GetFirstNode(&mFileHandleList.Link)\r
    ;  !IsNull(&mFileHandleList.Link, &Node->Link)\r
    ;  Node = (BUFFER_LIST*)GetNextNode(&mFileHandleList.Link, &Node->Link)\r
   ){\r
    if ((Node->Buffer) && (((SHELL_COMMAND_FILE_HANDLE *)Node->Buffer)->FileHandle == Handle)){\r
      return (((SHELL_COMMAND_FILE_HANDLE *)Node->Buffer)->Path);\r
    }\r
  }\r
  return (NULL);\r
}\r
\r
/**\r
  Remove a SHELL_FILE_HANDLE from the list of SHELL_FILE_HANDLES.\r
\r
  @param[in] Handle     The SHELL_FILE_HANDLE to remove.\r
\r
  @retval TRUE          The item was removed.\r
  @retval FALSE         The item was not found.\r
**/\r
BOOLEAN\r
EFIAPI\r
ShellFileHandleRemove(\r
  IN CONST SHELL_FILE_HANDLE Handle\r
  )\r
{\r
  BUFFER_LIST               *Node;\r
\r
  for (Node = (BUFFER_LIST*)GetFirstNode(&mFileHandleList.Link)\r
    ;  !IsNull(&mFileHandleList.Link, &Node->Link)\r
    ;  Node = (BUFFER_LIST*)GetNextNode(&mFileHandleList.Link, &Node->Link)\r
   ){\r
    if ((Node->Buffer) && (((SHELL_COMMAND_FILE_HANDLE *)Node->Buffer)->FileHandle == Handle)){\r
      RemoveEntryList(&Node->Link);\r
      SHELL_FREE_NON_NULL(((SHELL_COMMAND_FILE_HANDLE *)Node->Buffer)->Path);\r
      SHELL_FREE_NON_NULL(Node->Buffer);\r
      SHELL_FREE_NON_NULL(Node);\r
      return (TRUE);\r
    }\r
  }\r
  return (FALSE);\r
}\r
\r
/**\r
  Function to determine if a SHELL_FILE_HANDLE is at the end of the file.\r
\r
  This will NOT work on directories.\r
\r
  If Handle is NULL, then ASSERT.\r
\r
  @param[in] Handle     the file handle\r
\r
  @retval TRUE          the position is at the end of the file\r
  @retval FALSE         the position is not at the end of the file\r
**/\r
BOOLEAN\r
EFIAPI\r
ShellFileHandleEof(\r
  IN SHELL_FILE_HANDLE Handle\r
  )\r
{\r
  EFI_FILE_INFO *Info;\r
  UINT64        Pos;\r
  BOOLEAN       RetVal;\r
\r
  //\r
  // ASSERT if Handle is NULL\r
  //\r
  ASSERT(Handle != NULL);\r
\r
  gEfiShellProtocol->GetFilePosition(Handle, &Pos);\r
  Info = gEfiShellProtocol->GetFileInfo (Handle);\r
  ASSERT(Info != NULL);\r
  gEfiShellProtocol->SetFilePosition(Handle, Pos);\r
\r
  if (Info == NULL) {\r
    return (FALSE);\r
  }\r
\r
  if (Pos == Info->FileSize) {\r
    RetVal = TRUE;\r
  } else {\r
    RetVal = FALSE;\r
  }\r
\r
  FreePool (Info);\r
\r
  return (RetVal);\r
}\r
\r
/**\r
  Function to read a single line from a SHELL_FILE_HANDLE. The \n is not included in the returned\r
  buffer.  The returned buffer must be callee freed.\r
\r
  If the position upon start is 0, then the Ascii Boolean will be set.  This should be\r
  maintained and not changed for all operations with the same file.\r
\r
  @param[in]      Handle        SHELL_FILE_HANDLE to read from.\r
  @param[in,out]  Ascii         Boolean value for indicating whether the file is\r
                                Ascii (TRUE) or UCS2 (FALSE).\r
\r
  @return                       The line of text from the file.\r
\r
  @sa ShellFileHandleReadLine\r
**/\r
CHAR16*\r
EFIAPI\r
ShellFileHandleReturnLine(\r
  IN SHELL_FILE_HANDLE            Handle,\r
  IN OUT BOOLEAN                *Ascii\r
  )\r
{\r
  CHAR16          *RetVal;\r
  UINTN           Size;\r
  EFI_STATUS      Status;\r
\r
  Size = 0;\r
  RetVal = NULL;\r
\r
  Status = ShellFileHandleReadLine(Handle, RetVal, &Size, FALSE, Ascii);\r
  if (Status == EFI_BUFFER_TOO_SMALL) {\r
    RetVal = AllocateZeroPool(Size);\r
    Status = ShellFileHandleReadLine(Handle, RetVal, &Size, FALSE, Ascii);\r
  }\r
  ASSERT_EFI_ERROR(Status);\r
  if (EFI_ERROR(Status) && (RetVal != NULL)) {\r
    FreePool(RetVal);\r
    RetVal = NULL;\r
  }\r
  return (RetVal);\r
}\r
\r
/**\r
  Function to read a single line (up to but not including the \n) from a SHELL_FILE_HANDLE.\r
\r
  If the position upon start is 0, then the Ascii Boolean will be set.  This should be\r
  maintained and not changed for all operations with the same file.\r
\r
  @param[in]      Handle        SHELL_FILE_HANDLE to read from.\r
  @param[in,out]  Buffer        The pointer to buffer to read into.\r
  @param[in,out]  Size          The pointer to number of bytes in Buffer.\r
  @param[in]      Truncate      If the buffer is large enough, this has no effect.\r
                                If the buffer is is too small and Truncate is TRUE,\r
                                the line will be truncated.\r
                                If the buffer is is too small and Truncate is FALSE,\r
                                then no read will occur.\r
\r
  @param[in,out]  Ascii         Boolean value for indicating whether the file is\r
                                Ascii (TRUE) or UCS2 (FALSE).\r
\r
  @retval EFI_SUCCESS           The operation was successful.  The line is stored in\r
                                Buffer.\r
  @retval EFI_INVALID_PARAMETER Handle was NULL.\r
  @retval EFI_INVALID_PARAMETER Size was NULL.\r
  @retval EFI_BUFFER_TOO_SMALL  Size was not large enough to store the line.\r
                                Size was updated to the minimum space required.\r
  @sa ShellFileHandleRead\r
**/\r
EFI_STATUS\r
EFIAPI\r
ShellFileHandleReadLine(\r
  IN SHELL_FILE_HANDLE          Handle,\r
  IN OUT CHAR16                 *Buffer,\r
  IN OUT UINTN                  *Size,\r
  IN BOOLEAN                    Truncate,\r
  IN OUT BOOLEAN                *Ascii\r
  )\r
{\r
  EFI_STATUS  Status;\r
  CHAR16      CharBuffer;\r
  UINTN       CharSize;\r
  UINTN       CountSoFar;\r
  UINT64      OriginalFilePosition;\r
\r
\r
  if (Handle == NULL\r
    ||Size   == NULL\r
   ){\r
    return (EFI_INVALID_PARAMETER);\r
  }\r
  if (Buffer == NULL) {\r
    ASSERT(*Size == 0);\r
  } else {\r
    *Buffer = CHAR_NULL;\r
  }\r
  gEfiShellProtocol->GetFilePosition(Handle, &OriginalFilePosition);\r
  if (OriginalFilePosition == 0) {\r
    CharSize = sizeof(CHAR16);\r
    Status = gEfiShellProtocol->ReadFile(Handle, &CharSize, &CharBuffer);\r
    ASSERT_EFI_ERROR(Status);\r
    if (CharBuffer == gUnicodeFileTag) {\r
      *Ascii = FALSE;\r
    } else {\r
      *Ascii = TRUE;\r
      gEfiShellProtocol->SetFilePosition(Handle, OriginalFilePosition);\r
    }\r
  }\r
\r
  for (CountSoFar = 0;;CountSoFar++){\r
    CharBuffer = 0;\r
    if (*Ascii) {\r
      CharSize = sizeof(CHAR8);\r
    } else {\r
      CharSize = sizeof(CHAR16);\r
    }\r
    Status = gEfiShellProtocol->ReadFile(Handle, &CharSize, &CharBuffer);\r
    if (  EFI_ERROR(Status)\r
       || CharSize == 0\r
       || (CharBuffer == L'\n' && !(*Ascii))\r
       || (CharBuffer ==  '\n' && *Ascii)\r
     ){\r
      break;\r
    }\r
    //\r
    // if we have space save it...\r
    //\r
    if ((CountSoFar+1)*sizeof(CHAR16) < *Size){\r
      ASSERT(Buffer != NULL);\r
      ((CHAR16*)Buffer)[CountSoFar] = CharBuffer;\r
      ((CHAR16*)Buffer)[CountSoFar+1] = CHAR_NULL;\r
    }\r
  }\r
\r
  //\r
  // if we ran out of space tell when...\r
  //\r
  if ((CountSoFar+1)*sizeof(CHAR16) > *Size){\r
    *Size = (CountSoFar+1)*sizeof(CHAR16);\r
    if (!Truncate) {\r
      gEfiShellProtocol->SetFilePosition(Handle, OriginalFilePosition);\r
    } else {\r
      DEBUG((DEBUG_WARN, "The line was truncated in ShellFileHandleReadLine"));\r
    }\r
    return (EFI_BUFFER_TOO_SMALL);\r
  }\r
  while(Buffer[StrLen(Buffer)-1] == L'\r') {\r
    Buffer[StrLen(Buffer)-1] = CHAR_NULL;\r
  }\r
\r
  return (Status);\r
}\r
/**\r
  Frees any BUFFER_LIST defined type.\r
\r
  @param[in] List     The BUFFER_LIST object to free.\r
**/\r
VOID\r
EFIAPI\r
FreeBufferList (\r
  IN BUFFER_LIST *List\r
  )\r
{\r
  BUFFER_LIST               *BufferListEntry;\r
\r
  if (List == NULL){\r
    return;\r
  }\r
  //\r
  // enumerate through the buffer list and free all memory\r
  //\r
  for ( BufferListEntry = ( BUFFER_LIST *)GetFirstNode(&List->Link)\r
      ; !IsListEmpty (&List->Link)\r
      ; BufferListEntry = (BUFFER_LIST *)GetFirstNode(&List->Link)\r
     ){\r
    RemoveEntryList(&BufferListEntry->Link);\r
    ASSERT(BufferListEntry->Buffer != NULL);\r
    if (BufferListEntry->Buffer != NULL) {\r
      FreePool(BufferListEntry->Buffer);\r
    }\r
    FreePool(BufferListEntry);\r
  }\r
}\r
\r