[mirror_edk2.git] / ShellPkg / Application / Shell / FileHandleWrappers.c

/** @file\r
  EFI_FILE_PROTOCOL wrappers for other items (Like Environment Variables,\r
  StdIn, StdOut, StdErr, etc...).\r
\r
  Copyright 2016 Dell Inc.\r
  Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>\r
  (C) Copyright 2013 Hewlett-Packard Development Company, L.P.<BR>\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "Shell.h"\r
#include "FileHandleInternal.h"\r
\r
#define MEM_WRITE_REALLOC_OVERHEAD  1024\r
\r
/**\r
  File style interface for console (Open).\r
\r
  @param[in] This       Ignored.\r
  @param[out] NewHandle Ignored.\r
  @param[in] FileName   Ignored.\r
  @param[in] OpenMode   Ignored.\r
  @param[in] Attributes Ignored.\r
\r
  @retval EFI_NOT_FOUND\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceOpenNotFound (\r
  IN EFI_FILE_PROTOCOL   *This,\r
  OUT EFI_FILE_PROTOCOL  **NewHandle,\r
  IN CHAR16              *FileName,\r
  IN UINT64              OpenMode,\r
  IN UINT64              Attributes\r
  )\r
{\r
  return (EFI_NOT_FOUND);\r
}\r
\r
/**\r
  File style interface for console (Close, Delete, & Flush)\r
\r
  @param[in] This       Ignored.\r
\r
  @retval EFI_SUCCESS\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceNopGeneric (\r
  IN EFI_FILE_PROTOCOL  *This\r
  )\r
{\r
  return (EFI_SUCCESS);\r
}\r
\r
/**\r
  File style interface for console (GetPosition).\r
\r
  @param[in] This       Ignored.\r
  @param[out] Position  Ignored.\r
\r
  @retval EFI_UNSUPPORTED\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceNopGetPosition (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  OUT UINT64            *Position\r
  )\r
{\r
  return (EFI_UNSUPPORTED);\r
}\r
\r
/**\r
  File style interface for console (SetPosition).\r
\r
  @param[in] This       Ignored.\r
  @param[in] Position   Ignored.\r
\r
  @retval EFI_UNSUPPORTED\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceNopSetPosition (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN UINT64             Position\r
  )\r
{\r
  return (EFI_UNSUPPORTED);\r
}\r
\r
/**\r
  File style interface for console (GetInfo).\r
\r
  @param[in] This              Ignored.\r
  @param[in] InformationType   Ignored.\r
  @param[in, out] BufferSize   Ignored.\r
  @param[out] Buffer           Ignored.\r
\r
  @retval EFI_UNSUPPORTED\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceNopGetInfo (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN EFI_GUID           *InformationType,\r
  IN OUT UINTN          *BufferSize,\r
  OUT VOID              *Buffer\r
  )\r
{\r
  return (EFI_UNSUPPORTED);\r
}\r
\r
/**\r
  File style interface for console (SetInfo).\r
\r
  @param[in] This       Ignored.\r
  @param[in] InformationType   Ignored.\r
  @param[in] BufferSize Ignored.\r
  @param[in] Buffer     Ignored.\r
\r
  @retval EFI_UNSUPPORTED\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceNopSetInfo (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN EFI_GUID           *InformationType,\r
  IN UINTN              BufferSize,\r
  IN VOID               *Buffer\r
  )\r
{\r
  return (EFI_UNSUPPORTED);\r
}\r
\r
/**\r
  File style interface for StdOut (Write).\r
\r
  Writes data to the screen.\r
\r
  @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.\r
  @param[in, out] BufferSize   Size in bytes of Buffer.\r
  @param[in] Buffer            The pointer to the buffer to write.\r
\r
  @retval EFI_UNSUPPORTED No output console is supported.\r
  @return A return value from gST->ConOut->OutputString.\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceStdOutWrite (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN OUT UINTN          *BufferSize,\r
  IN VOID               *Buffer\r
  )\r
{\r
  if (ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleOut) {\r
    return (EFI_UNSUPPORTED);\r
  }\r
\r
  if (*((CHAR16 *)Buffer) == gUnicodeFileTag) {\r
    return (gST->ConOut->OutputString (gST->ConOut, (CHAR16 *)Buffer + 1));\r
  }\r
\r
  return (gST->ConOut->OutputString (gST->ConOut, Buffer));\r
}\r
\r
/**\r
  File style interface for StdIn (Write).\r
\r
  @param[in] This            Ignored.\r
  @param[in, out] BufferSize Ignored.\r
  @param[in] Buffer          Ignored.\r
\r
  @retval EFI_UNSUPPORTED\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceStdInWrite (\r
  IN      EFI_FILE_PROTOCOL  *This,\r
  IN OUT  UINTN              *BufferSize,\r
  IN      VOID               *Buffer\r
  )\r
{\r
  return (EFI_UNSUPPORTED);\r
}\r
\r
/**\r
  File style interface for console StdErr (Write).\r
\r
  Writes error to the error output.\r
\r
  @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.\r
  @param[in, out] BufferSize   Size in bytes of Buffer.\r
  @param[in] Buffer            The pointer to the buffer to write.\r
\r
  @return A return value from gST->StdErr->OutputString.\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceStdErrWrite (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN OUT UINTN          *BufferSize,\r
  IN VOID               *Buffer\r
  )\r
{\r
  return (gST->StdErr->OutputString (gST->StdErr, Buffer));\r
}\r
\r
/**\r
  File style interface for console StdOut (Read).\r
\r
  @param[in] This              Ignored.\r
  @param[in, out] BufferSize   Ignored.\r
  @param[out] Buffer           Ignored.\r
\r
  @retval EFI_UNSUPPORTED\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceStdOutRead (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN OUT UINTN          *BufferSize,\r
  OUT VOID              *Buffer\r
  )\r
{\r
  return (EFI_UNSUPPORTED);\r
}\r
\r
/**\r
  File style interface for console StdErr (Read).\r
\r
  @param[in] This              Ignored.\r
  @param[in, out] BufferSize   Ignored.\r
  @param[out] Buffer           Ignored.\r
\r
  @retval EFI_UNSUPPORTED Always.\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceStdErrRead (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN OUT UINTN          *BufferSize,\r
  OUT VOID              *Buffer\r
  )\r
{\r
  return (EFI_UNSUPPORTED);\r
}\r
\r
/**\r
  File style interface for NUL file (Read).\r
\r
  @param[in] This              Ignored.\r
  @param[in, out] BufferSize   Poiner to 0 upon return.\r
  @param[out] Buffer           Ignored.\r
\r
  @retval EFI_SUCCESS Always.\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceNulRead (\r
  IN      EFI_FILE_PROTOCOL  *This,\r
  IN OUT  UINTN              *BufferSize,\r
  OUT     VOID               *Buffer\r
  )\r
{\r
  *BufferSize = 0;\r
  return (EFI_SUCCESS);\r
}\r
\r
/**\r
  File style interface for NUL file (Write).\r
\r
  @param[in] This              Ignored.\r
  @param[in, out] BufferSize   Ignored.\r
  @param[in] Buffer            Ignored.\r
\r
  @retval EFI_SUCCESS\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceNulWrite (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN OUT UINTN          *BufferSize,\r
  IN VOID               *Buffer\r
  )\r
{\r
  return (EFI_SUCCESS);\r
}\r
\r
/**\r
  Create the TAB completion list.\r
\r
  @param[in]  InputString       The command line to expand.\r
  @param[in]  StringLen         Length of the command line.\r
  @param[in]  BufferSize        Buffer size.\r
  @param[in, out] TabCompletionList Return the TAB completion list.\r
  @param[in, out] TabUpdatePos      Return the TAB update position.\r
**/\r
EFI_STATUS\r
CreateTabCompletionList (\r
  IN CONST CHAR16             *InputString,\r
  IN CONST UINTN              StringLen,\r
  IN CONST UINTN              BufferSize,\r
  IN OUT EFI_SHELL_FILE_INFO  **TabCompletionList,\r
  IN OUT   UINTN              *TabUpdatePos\r
  )\r
{\r
  BOOLEAN              InQuotation;\r
  UINTN                TabPos;\r
  UINTN                Index;\r
  CONST CHAR16         *Cwd;\r
  EFI_STATUS           Status;\r
  CHAR16               *TabStr;\r
  EFI_SHELL_FILE_INFO  *FileList;\r
  EFI_SHELL_FILE_INFO  *FileInfo;\r
  EFI_SHELL_FILE_INFO  *TempFileInfo;\r
\r
  //\r
  // Allocate buffers\r
  //\r
  TabStr = AllocateZeroPool (BufferSize);\r
  if (TabStr == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // handle auto complete of file and directory names...\r
  // E.g.: cd fs0:\EFI\Bo<TAB>\r
  //          ^        ^\r
  //          TabPos   TabUpdatePos\r
  //\r
  TabPos        = 0;\r
  *TabUpdatePos = 0;\r
  FileList      = NULL;\r
  InQuotation   = FALSE;\r
  for (Index = 0; Index < StringLen; Index++) {\r
    switch (InputString[Index]) {\r
      case L'\"':\r
        InQuotation = (BOOLEAN)(!InQuotation);\r
        break;\r
\r
      case L' ':\r
        if (!InQuotation) {\r
          TabPos        = Index + 1;\r
          *TabUpdatePos = TabPos;\r
        }\r
\r
        break;\r
\r
      case L':':\r
      //\r
      // handle the case "fs0:<TAB>"\r
      // Update the TabUpdatePos as well.\r
      //\r
      case L'\\':\r
        *TabUpdatePos = Index + 1;\r
        break;\r
\r
      default:\r
        break;\r
    }\r
  }\r
\r
  if (StrStr (InputString + TabPos, L":") == NULL) {\r
    //\r
    // If file path doesn't contain ":", ...\r
    //\r
    Cwd = ShellInfoObject.NewEfiShellProtocol->GetCurDir (NULL);\r
    if (Cwd != NULL) {\r
      if (InputString[TabPos] != L'\\') {\r
        //\r
        // and it doesn't begin with "\\", it's a path relative to current directory.\r
        // TabStr = "<cwd>\\"\r
        //\r
        StrnCpyS (TabStr, BufferSize / sizeof (CHAR16), Cwd, (BufferSize) / sizeof (CHAR16) - 1);\r
        StrCatS (TabStr, (BufferSize) / sizeof (CHAR16), L"\\");\r
      } else {\r
        //\r
        // and it begins with "\\", it's a path pointing to root directory of current map.\r
        // TabStr = "fsx:"\r
        //\r
        Index = StrStr (Cwd, L":") - Cwd + 1;\r
        StrnCpyS (TabStr, BufferSize / sizeof (CHAR16), Cwd, Index);\r
      }\r
    }\r
  }\r
\r
  StrnCatS (TabStr, (BufferSize) / sizeof (CHAR16), InputString + TabPos, StringLen - TabPos);\r
  StrnCatS (TabStr, (BufferSize) / sizeof (CHAR16), L"*", (BufferSize) / sizeof (CHAR16) - 1 - StrLen (TabStr));\r
  Status = ShellInfoObject.NewEfiShellProtocol->FindFiles (TabStr, &FileList);\r
\r
  //\r
  // Filter out the non-directory for "CD" command\r
  // Filter "." and ".." for all\r
  //\r
  if (!EFI_ERROR (Status) && (FileList != NULL)) {\r
    //\r
    // Skip the spaces in the beginning\r
    //\r
    while (*InputString == L' ') {\r
      InputString++;\r
    }\r
\r
    for (FileInfo = (EFI_SHELL_FILE_INFO *)GetFirstNode (&FileList->Link); !IsNull (&FileList->Link, &FileInfo->Link); ) {\r
      if (((StrCmp (FileInfo->FileName, L".") == 0) || (StrCmp (FileInfo->FileName, L"..") == 0)) ||\r
          ((((InputString[0] == L'c') || (InputString[0] == L'C')) && ((InputString[1] == L'd') || (InputString[1] == L'D'))) &&\r
           (ShellIsDirectory (FileInfo->FullName) != EFI_SUCCESS)))\r
      {\r
        TempFileInfo = FileInfo;\r
        FileInfo     = (EFI_SHELL_FILE_INFO *)RemoveEntryList (&FileInfo->Link);\r
        InternalFreeShellFileInfoNode (TempFileInfo);\r
      } else {\r
        FileInfo = (EFI_SHELL_FILE_INFO *)GetNextNode (&FileList->Link, &FileInfo->Link);\r
      }\r
    }\r
  }\r
\r
  if ((FileList != NULL) && !IsListEmpty (&FileList->Link)) {\r
    Status = EFI_SUCCESS;\r
  } else {\r
    ShellInfoObject.NewEfiShellProtocol->FreeFileList (&FileList);\r
    Status = EFI_NOT_FOUND;\r
  }\r
\r
  FreePool (TabStr);\r
\r
  *TabCompletionList = FileList;\r
  return Status;\r
}\r
\r
/**\r
  File style interface for console (Read).\r
\r
  This will return a single line of input from the console.\r
\r
  @param This           A pointer to the EFI_FILE_PROTOCOL instance that is the\r
                        file handle to read data from. Not used.\r
  @param BufferSize     On input, the size of the Buffer. On output, the amount\r
                        of data returned in Buffer. In both cases, the size is\r
                        measured in bytes.\r
  @param Buffer         The buffer into which the data is read.\r
\r
\r
  @retval EFI_SUCCESS           The data was read.\r
  @retval EFI_NO_MEDIA          The device has no medium.\r
  @retval EFI_DEVICE_ERROR      The device reported an error.\r
  @retval EFI_DEVICE_ERROR      An attempt was made to read from a deleted file.\r
  @retval EFI_DEVICE_ERROR      On entry, the current file position is beyond the end of the file.\r
  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.\r
  @retval EFI_BUFFER_TOO_SMALL  The BufferSize is too small to read the current directory\r
                                entry. BufferSize has been updated with the size\r
                                needed to complete the request.\r
  @retval EFI_OUT_OF_RESOURCES  A memory allocation failed.\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceStdInRead (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN OUT UINTN          *BufferSize,\r
  OUT VOID              *Buffer\r
  )\r
{\r
  CHAR16         *CurrentString;\r
  BOOLEAN        Done;\r
  UINTN          TabUpdatePos;        // Start index of the string updated by TAB stroke\r
  UINTN          Column;              // Column of current cursor\r
  UINTN          Row;                 // Row of current cursor\r
  UINTN          StartColumn;         // Column at the beginning of the line\r
  UINTN          Update;              // Line index for update\r
  UINTN          Delete;              // Num of chars to delete from console after update\r
  UINTN          StringLen;           // Total length of the line\r
  UINTN          StringCurPos;        // Line index corresponding to the cursor\r
  UINTN          MaxStr;              // Maximum possible line length\r
  UINTN          TotalColumn;         // Num of columns in the console\r
  UINTN          TotalRow;            // Num of rows in the console\r
  UINTN          SkipLength;\r
  UINTN          OutputLength;        // Length of the update string\r
  UINTN          TailRow;             // Row of end of line\r
  UINTN          TailColumn;          // Column of end of line\r
  EFI_INPUT_KEY  Key;\r
\r
  BUFFER_LIST          *LinePos;\r
  BUFFER_LIST          *NewPos;\r
  BOOLEAN              InScrolling;\r
  EFI_STATUS           Status;\r
  BOOLEAN              InTabScrolling; // Whether in TAB-completion state\r
  EFI_SHELL_FILE_INFO  *TabCompleteList;\r
  EFI_SHELL_FILE_INFO  *TabCurrent;\r
  UINTN                EventIndex;\r
  CHAR16               *TabOutputStr;\r
\r
  //\r
  // If buffer is not large enough to hold a CHAR16, return minimum buffer size\r
  //\r
  if (*BufferSize < sizeof (CHAR16) * 2) {\r
    *BufferSize = sizeof (CHAR16) * 2;\r
    return (EFI_BUFFER_TOO_SMALL);\r
  }\r
\r
  Done            = FALSE;\r
  CurrentString   = Buffer;\r
  StringLen       = 0;\r
  StringCurPos    = 0;\r
  OutputLength    = 0;\r
  Update          = 0;\r
  Delete          = 0;\r
  LinePos         = NewPos = (BUFFER_LIST *)(&ShellInfoObject.ViewingSettings.CommandHistory);\r
  InScrolling     = FALSE;\r
  InTabScrolling  = FALSE;\r
  Status          = EFI_SUCCESS;\r
  TabOutputStr    = NULL;\r
  TabUpdatePos    = 0;\r
  TabCompleteList = NULL;\r
  TabCurrent      = NULL;\r
\r
  //\r
  // Get the screen setting and the current cursor location\r
  //\r
  Column = StartColumn = gST->ConOut->Mode->CursorColumn;\r
  Row    = gST->ConOut->Mode->CursorRow;\r
  gST->ConOut->QueryMode (gST->ConOut, gST->ConOut->Mode->Mode, &TotalColumn, &TotalRow);\r
\r
  //\r
  // Limit the line length to the buffer size or the minimum size of the\r
  // screen. (The smaller takes effect)\r
  //\r
  MaxStr = TotalColumn * (TotalRow - 1) - StartColumn;\r
  if (MaxStr > *BufferSize / sizeof (CHAR16)) {\r
    MaxStr = *BufferSize / sizeof (CHAR16);\r
  }\r
\r
  ZeroMem (CurrentString, MaxStr * sizeof (CHAR16));\r
  do {\r
    //\r
    // Read a key\r
    //\r
    gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &EventIndex);\r
    Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);\r
    if (EFI_ERROR (Status)) {\r
      if (Status == EFI_NOT_READY) {\r
        continue;\r
      }\r
\r
      ZeroMem (CurrentString, MaxStr * sizeof (CHAR16));\r
      StringLen = 0;\r
      break;\r
    }\r
\r
    //\r
    // Press PageUp or PageDown to scroll the history screen up or down.\r
    // Press any other key to quit scrolling.\r
    //\r
    if ((Key.UnicodeChar == 0) && ((Key.ScanCode == SCAN_PAGE_UP) || (Key.ScanCode == SCAN_PAGE_DOWN))) {\r
      if (Key.ScanCode == SCAN_PAGE_UP) {\r
        ConsoleLoggerDisplayHistory (FALSE, 0, ShellInfoObject.ConsoleInfo);\r
      } else if (Key.ScanCode == SCAN_PAGE_DOWN) {\r
        ConsoleLoggerDisplayHistory (TRUE, 0, ShellInfoObject.ConsoleInfo);\r
      }\r
\r
      InScrolling = TRUE;\r
    } else {\r
      if (InScrolling) {\r
        ConsoleLoggerStopHistory (ShellInfoObject.ConsoleInfo);\r
        InScrolling = FALSE;\r
      }\r
    }\r
\r
    //\r
    // If we are quitting TAB scrolling...\r
    //\r
    if (InTabScrolling && (Key.UnicodeChar != CHAR_TAB)) {\r
      if (TabCompleteList != NULL) {\r
        ShellInfoObject.NewEfiShellProtocol->FreeFileList (&TabCompleteList);\r
        DEBUG_CODE (\r
          TabCompleteList = NULL;\r
          );\r
      }\r
\r
      InTabScrolling = FALSE;\r
    }\r
\r
    switch (Key.UnicodeChar) {\r
      case CHAR_CARRIAGE_RETURN:\r
        //\r
        // All done, print a newline at the end of the string\r
        //\r
        TailRow    = Row + (StringLen - StringCurPos + Column) / TotalColumn;\r
        TailColumn = (StringLen - StringCurPos + Column) % TotalColumn;\r
        ShellPrintEx ((INT32)TailColumn, (INT32)TailRow, L"%N\n");\r
        Done = TRUE;\r
        break;\r
\r
      case CHAR_BACKSPACE:\r
        if (StringCurPos != 0) {\r
          //\r
          // If not move back beyond string beginning, move all characters behind\r
          // the current position one character forward\r
          //\r
          StringCurPos--;\r
          Update = StringCurPos;\r
          Delete = 1;\r
          CopyMem (CurrentString + StringCurPos, CurrentString + StringCurPos + 1, sizeof (CHAR16) * (StringLen - StringCurPos));\r
\r
          //\r
          // Adjust the current column and row\r
          //\r
          MoveCursorBackward (TotalColumn, &Column, &Row);\r
        }\r
\r
        break;\r
\r
      case CHAR_TAB:\r
        if (!InTabScrolling) {\r
          TabCurrent = NULL;\r
          //\r
          // Initialize a tab complete operation.\r
          //\r
          Status = CreateTabCompletionList (CurrentString, StringLen, *BufferSize, &TabCompleteList, &TabUpdatePos);\r
          if (!EFI_ERROR (Status)) {\r
            InTabScrolling = TRUE;\r
          }\r
\r
          //\r
          // We do not set up the replacement.\r
          // The next section will do that.\r
          //\r
        }\r
\r
        if (InTabScrolling) {\r
          //\r
          // We are in a tab complete operation.\r
          // set up the next replacement.\r
          //\r
          ASSERT (TabCompleteList != NULL);\r
          if (TabCurrent == NULL) {\r
            TabCurrent = (EFI_SHELL_FILE_INFO *)GetFirstNode (&TabCompleteList->Link);\r
          } else {\r
            TabCurrent = (EFI_SHELL_FILE_INFO *)GetNextNode (&TabCompleteList->Link, &TabCurrent->Link);\r
          }\r
\r
          //\r
          // Skip over the empty list beginning node\r
          //\r
          if (IsNull (&TabCompleteList->Link, &TabCurrent->Link)) {\r
            TabCurrent = (EFI_SHELL_FILE_INFO *)GetNextNode (&TabCompleteList->Link, &TabCurrent->Link);\r
          }\r
        }\r
\r
        break;\r
\r
      default:\r
        if (Key.UnicodeChar >= ' ') {\r
          //\r
          // If we are at the buffer's end, drop the key\r
          //\r
          if ((StringLen == MaxStr - 1) && (ShellInfoObject.ViewingSettings.InsertMode || (StringCurPos == StringLen))) {\r
            break;\r
          }\r
\r
          //\r
          // If in insert mode, make space by moving each other character 1\r
          // space higher in the array\r
          //\r
          if (ShellInfoObject.ViewingSettings.InsertMode) {\r
            CopyMem (CurrentString + StringCurPos + 1, CurrentString + StringCurPos, (StringLen - StringCurPos)*sizeof (CurrentString[0]));\r
          }\r
\r
          CurrentString[StringCurPos] = Key.UnicodeChar;\r
          Update                      = StringCurPos;\r
\r
          StringCurPos += 1;\r
          OutputLength  = 1;\r
        }\r
\r
        break;\r
\r
      case 0:\r
        switch (Key.ScanCode) {\r
          case SCAN_DELETE:\r
            //\r
            // Move characters behind current position one character forward\r
            //\r
            if (StringLen != 0) {\r
              Update = StringCurPos;\r
              Delete = 1;\r
              CopyMem (CurrentString + StringCurPos, CurrentString + StringCurPos + 1, sizeof (CHAR16) * (StringLen - StringCurPos));\r
            }\r
\r
            break;\r
\r
          case SCAN_UP:\r
            //\r
            // Prepare to print the previous command\r
            //\r
            NewPos = (BUFFER_LIST *)GetPreviousNode (&ShellInfoObject.ViewingSettings.CommandHistory.Link, &LinePos->Link);\r
            if (IsNull (&ShellInfoObject.ViewingSettings.CommandHistory.Link, &LinePos->Link)) {\r
              NewPos = (BUFFER_LIST *)GetPreviousNode (&ShellInfoObject.ViewingSettings.CommandHistory.Link, &LinePos->Link);\r
            }\r
\r
            break;\r
\r
          case SCAN_DOWN:\r
            //\r
            // Prepare to print the next command\r
            //\r
            NewPos = (BUFFER_LIST *)GetNextNode (&ShellInfoObject.ViewingSettings.CommandHistory.Link, &LinePos->Link);\r
            if (NewPos == (BUFFER_LIST *)(&ShellInfoObject.ViewingSettings.CommandHistory)) {\r
              NewPos = (BUFFER_LIST *)GetNextNode (&ShellInfoObject.ViewingSettings.CommandHistory.Link, &LinePos->Link);\r
            }\r
\r
            break;\r
\r
          case SCAN_LEFT:\r
            //\r
            // Adjust current cursor position\r
            //\r
            if (StringCurPos != 0) {\r
              --StringCurPos;\r
              MoveCursorBackward (TotalColumn, &Column, &Row);\r
            }\r
\r
            break;\r
\r
          case SCAN_RIGHT:\r
            //\r
            // Adjust current cursor position\r
            //\r
            if (StringCurPos < StringLen) {\r
              ++StringCurPos;\r
              MoveCursorForward (TotalColumn, TotalRow, &Column, &Row);\r
            }\r
\r
            break;\r
\r
          case SCAN_HOME:\r
            //\r
            // Move current cursor position to the beginning of the command line\r
            //\r
            Row         -= (StringCurPos + StartColumn) / TotalColumn;\r
            Column       = StartColumn;\r
            StringCurPos = 0;\r
            break;\r
\r
          case SCAN_END:\r
            //\r
            // Move current cursor position to the end of the command line\r
            //\r
            TailRow      = Row + (StringLen - StringCurPos + Column) / TotalColumn;\r
            TailColumn   = (StringLen - StringCurPos + Column) % TotalColumn;\r
            Row          = TailRow;\r
            Column       = TailColumn;\r
            StringCurPos = StringLen;\r
            break;\r
\r
          case SCAN_ESC:\r
            //\r
            // Prepare to clear the current command line\r
            //\r
            CurrentString[0] = 0;\r
            Update           = 0;\r
            Delete           = StringLen;\r
            Row             -= (StringCurPos + StartColumn) / TotalColumn;\r
            Column           = StartColumn;\r
            OutputLength     = 0;\r
            break;\r
\r
          case SCAN_INSERT:\r
            //\r
            // Toggle the SEnvInsertMode flag\r
            //\r
            ShellInfoObject.ViewingSettings.InsertMode = (BOOLEAN) !ShellInfoObject.ViewingSettings.InsertMode;\r
            break;\r
\r
          case SCAN_F7:\r
            //\r
            // Print command history\r
            //\r
            PrintCommandHistory (TotalColumn, TotalRow, 4);\r
            *CurrentString = CHAR_NULL;\r
            Done           = TRUE;\r
            break;\r
        }\r
    }\r
\r
    if (Done) {\r
      break;\r
    }\r
\r
    //\r
    // If we are in auto-complete mode, we are preparing to print\r
    // the next file or directory name\r
    //\r
    if (InTabScrolling) {\r
      TabOutputStr = AllocateZeroPool (*BufferSize);\r
      if (TabOutputStr == NULL) {\r
        Status = EFI_OUT_OF_RESOURCES;\r
      }\r
    }\r
\r
    if (InTabScrolling && (TabOutputStr != NULL)) {\r
      //\r
      // Adjust the column and row to the start of TAB-completion string.\r
      //\r
      Column       = (StartColumn + TabUpdatePos) % TotalColumn;\r
      Row         -= (StartColumn + StringCurPos) / TotalColumn - (StartColumn + TabUpdatePos) / TotalColumn;\r
      OutputLength = StrLen (TabCurrent->FileName);\r
      //\r
      // if the output string contains  blank space, quotation marks L'\"'\r
      // should be added to the output.\r
      //\r
      if (StrStr (TabCurrent->FileName, L" ") != NULL) {\r
        TabOutputStr[0] = L'\"';\r
        CopyMem (TabOutputStr + 1, TabCurrent->FileName, OutputLength * sizeof (CHAR16));\r
        TabOutputStr[OutputLength + 1] = L'\"';\r
        TabOutputStr[OutputLength + 2] = CHAR_NULL;\r
      } else {\r
        CopyMem (TabOutputStr, TabCurrent->FileName, OutputLength * sizeof (CHAR16));\r
        TabOutputStr[OutputLength] = CHAR_NULL;\r
      }\r
\r
      OutputLength = StrLen (TabOutputStr) < MaxStr - 1 ? StrLen (TabOutputStr) : MaxStr - 1;\r
      CopyMem (CurrentString + TabUpdatePos, TabOutputStr, OutputLength * sizeof (CHAR16));\r
      CurrentString[TabUpdatePos + OutputLength] = CHAR_NULL;\r
      StringCurPos                               = TabUpdatePos + OutputLength;\r
      Update                                     = TabUpdatePos;\r
      if (StringLen > TabUpdatePos + OutputLength) {\r
        Delete = StringLen - TabUpdatePos - OutputLength;\r
      }\r
\r
      FreePool (TabOutputStr);\r
    }\r
\r
    //\r
    // If we have a new position, we are preparing to print a previous or\r
    // next command.\r
    //\r
    if (NewPos != (BUFFER_LIST *)(&ShellInfoObject.ViewingSettings.CommandHistory)) {\r
      Column = StartColumn;\r
      Row   -= (StringCurPos + StartColumn) / TotalColumn;\r
\r
      LinePos = NewPos;\r
      NewPos  = (BUFFER_LIST *)(&ShellInfoObject.ViewingSettings.CommandHistory);\r
\r
      OutputLength = StrLen (LinePos->Buffer) < MaxStr - 1 ? StrLen (LinePos->Buffer) : MaxStr - 1;\r
      CopyMem (CurrentString, LinePos->Buffer, OutputLength * sizeof (CHAR16));\r
      CurrentString[OutputLength] = CHAR_NULL;\r
\r
      StringCurPos = OutputLength;\r
\r
      //\r
      // Draw new input string\r
      //\r
      Update = 0;\r
      if (StringLen > OutputLength) {\r
        //\r
        // If old string was longer, blank its tail\r
        //\r
        Delete = StringLen - OutputLength;\r
      }\r
    }\r
\r
    //\r
    // If we need to update the output do so now\r
    //\r
    if (Update != (UINTN)-1) {\r
      ShellPrintEx ((INT32)Column, (INT32)Row, L"%s%.*s", CurrentString + Update, Delete, L"");\r
      StringLen = StrLen (CurrentString);\r
\r
      if (Delete != 0) {\r
        SetMem (CurrentString + StringLen, Delete * sizeof (CHAR16), CHAR_NULL);\r
      }\r
\r
      if (StringCurPos > StringLen) {\r
        StringCurPos = StringLen;\r
      }\r
\r
      Update = (UINTN)-1;\r
\r
      //\r
      // After using print to reflect newly updates, if we're not using\r
      // BACKSPACE and DELETE, we need to move the cursor position forward,\r
      // so adjust row and column here.\r
      //\r
      if ((Key.UnicodeChar != CHAR_BACKSPACE) && !((Key.UnicodeChar == 0) && (Key.ScanCode == SCAN_DELETE))) {\r
        //\r
        // Calculate row and column of the tail of current string\r
        //\r
        TailRow    = Row + (StringLen - StringCurPos + Column + OutputLength) / TotalColumn;\r
        TailColumn = (StringLen - StringCurPos + Column + OutputLength) % TotalColumn;\r
\r
        //\r
        // If the tail of string reaches screen end, screen rolls up, so if\r
        // Row does not equal TailRow, Row should be decremented\r
        //\r
        // (if we are recalling commands using UPPER and DOWN key, and if the\r
        // old command is too long to fit the screen, TailColumn must be 79.\r
        //\r
        if ((TailColumn == 0) && (TailRow >= TotalRow) && (Row != TailRow)) {\r
          Row--;\r
        }\r
\r
        //\r
        // Calculate the cursor position after current operation. If cursor\r
        // reaches line end, update both row and column, otherwise, only\r
        // column will be changed.\r
        //\r
        if (Column + OutputLength >= TotalColumn) {\r
          SkipLength = OutputLength - (TotalColumn - Column);\r
\r
          Row += SkipLength / TotalColumn + 1;\r
          if (Row > TotalRow - 1) {\r
            Row = TotalRow - 1;\r
          }\r
\r
          Column = SkipLength % TotalColumn;\r
        } else {\r
          Column += OutputLength;\r
        }\r
      }\r
\r
      Delete = 0;\r
    }\r
\r
    //\r
    // Set the cursor position for this key\r
    //\r
    gST->ConOut->SetCursorPosition (gST->ConOut, Column, Row);\r
  } while (!Done);\r
\r
  if ((CurrentString != NULL) && (StrLen (CurrentString) > 0)) {\r
    //\r
    // add the line to the history buffer\r
    //\r
    AddLineToCommandHistory (CurrentString);\r
  }\r
\r
  //\r
  // Return the data to the caller\r
  //\r
  *BufferSize = StringLen * sizeof (CHAR16);\r
\r
  //\r
  // if this was used it should be deallocated by now...\r
  // prevent memory leaks...\r
  //\r
  if (TabCompleteList != NULL) {\r
    ShellInfoObject.NewEfiShellProtocol->FreeFileList (&TabCompleteList);\r
  }\r
\r
  ASSERT (TabCompleteList == NULL);\r
\r
  return Status;\r
}\r
\r
//\r
// FILE style interfaces for StdIn/StdOut/StdErr\r
//\r
EFI_FILE_PROTOCOL  FileInterfaceStdIn = {\r
  EFI_FILE_REVISION,\r
  FileInterfaceOpenNotFound,\r
  FileInterfaceNopGeneric,\r
  FileInterfaceNopGeneric,\r
  FileInterfaceStdInRead,\r
  FileInterfaceStdInWrite,\r
  FileInterfaceNopGetPosition,\r
  FileInterfaceNopSetPosition,\r
  FileInterfaceNopGetInfo,\r
  FileInterfaceNopSetInfo,\r
  FileInterfaceNopGeneric\r
};\r
\r
EFI_FILE_PROTOCOL  FileInterfaceStdOut = {\r
  EFI_FILE_REVISION,\r
  FileInterfaceOpenNotFound,\r
  FileInterfaceNopGeneric,\r
  FileInterfaceNopGeneric,\r
  FileInterfaceStdOutRead,\r
  FileInterfaceStdOutWrite,\r
  FileInterfaceNopGetPosition,\r
  FileInterfaceNopSetPosition,\r
  FileInterfaceNopGetInfo,\r
  FileInterfaceNopSetInfo,\r
  FileInterfaceNopGeneric\r
};\r
\r
EFI_FILE_PROTOCOL  FileInterfaceStdErr = {\r
  EFI_FILE_REVISION,\r
  FileInterfaceOpenNotFound,\r
  FileInterfaceNopGeneric,\r
  FileInterfaceNopGeneric,\r
  FileInterfaceStdErrRead,\r
  FileInterfaceStdErrWrite,\r
  FileInterfaceNopGetPosition,\r
  FileInterfaceNopSetPosition,\r
  FileInterfaceNopGetInfo,\r
  FileInterfaceNopSetInfo,\r
  FileInterfaceNopGeneric\r
};\r
\r
EFI_FILE_PROTOCOL  FileInterfaceNulFile = {\r
  EFI_FILE_REVISION,\r
  FileInterfaceOpenNotFound,\r
  FileInterfaceNopGeneric,\r
  FileInterfaceNopGeneric,\r
  FileInterfaceNulRead,\r
  FileInterfaceNulWrite,\r
  FileInterfaceNopGetPosition,\r
  FileInterfaceNopSetPosition,\r
  FileInterfaceNopGetInfo,\r
  FileInterfaceNopSetInfo,\r
  FileInterfaceNopGeneric\r
};\r
\r
//\r
// This is identical to EFI_FILE_PROTOCOL except for the additional member\r
// for the name.\r
//\r
\r
typedef struct {\r
  UINT64                   Revision;\r
  EFI_FILE_OPEN            Open;\r
  EFI_FILE_CLOSE           Close;\r
  EFI_FILE_DELETE          Delete;\r
  EFI_FILE_READ            Read;\r
  EFI_FILE_WRITE           Write;\r
  EFI_FILE_GET_POSITION    GetPosition;\r
  EFI_FILE_SET_POSITION    SetPosition;\r
  EFI_FILE_GET_INFO        GetInfo;\r
  EFI_FILE_SET_INFO        SetInfo;\r
  EFI_FILE_FLUSH           Flush;\r
  CHAR16                   Name[1];\r
} EFI_FILE_PROTOCOL_ENVIRONMENT;\r
// ANSI compliance helper to get size of the struct.\r
#define SIZE_OF_EFI_FILE_PROTOCOL_ENVIRONMENT  EFI_FIELD_OFFSET (EFI_FILE_PROTOCOL_ENVIRONMENT, Name)\r
\r
/**\r
  File style interface for Environment Variable (Close).\r
\r
  Frees the memory for this object.\r
\r
  @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.\r
\r
  @retval EFI_SUCCESS\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceEnvClose (\r
  IN EFI_FILE_PROTOCOL  *This\r
  )\r
{\r
  VOID        *NewBuffer;\r
  UINTN       NewSize;\r
  EFI_STATUS  Status;\r
  BOOLEAN     Volatile;\r
  UINTN       TotalSize;\r
\r
  //\r
  // Most if not all UEFI commands will have an '\r\n' at the end of any output.\r
  // Since the output was redirected to a variable, it does not make sense to\r
  // keep this.  So, before closing, strip the trailing '\r\n' from the variable\r
  // if it exists.\r
  //\r
  NewBuffer = NULL;\r
  NewSize   = 0;\r
  TotalSize = 0;\r
\r
  Status = IsVolatileEnv (((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name, &Volatile);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = SHELL_GET_ENVIRONMENT_VARIABLE (((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name, &NewSize, NewBuffer);\r
  if (Status == EFI_BUFFER_TOO_SMALL) {\r
    TotalSize = NewSize + sizeof (CHAR16);\r
    NewBuffer = AllocateZeroPool (TotalSize);\r
    if (NewBuffer == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    Status = SHELL_GET_ENVIRONMENT_VARIABLE (((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name, &NewSize, NewBuffer);\r
  }\r
\r
  if (!EFI_ERROR (Status) && (NewBuffer != NULL)) {\r
    if (TotalSize / sizeof (CHAR16) >= 3) {\r
      if ((((CHAR16 *)NewBuffer)[TotalSize / sizeof (CHAR16) - 2] == CHAR_LINEFEED) &&\r
          (((CHAR16 *)NewBuffer)[TotalSize / sizeof (CHAR16) - 3] == CHAR_CARRIAGE_RETURN)\r
          )\r
      {\r
        ((CHAR16 *)NewBuffer)[TotalSize / sizeof (CHAR16) - 3] = CHAR_NULL;\r
        //\r
        // If the NewBuffer end with \r\n\0, We will replace '\r' by '\0' and then update TotalSize.\r
        //\r
        TotalSize -= sizeof (CHAR16) * 2;\r
      }\r
\r
      if (Volatile) {\r
        Status = SHELL_SET_ENVIRONMENT_VARIABLE_V (\r
                   ((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name,\r
                   TotalSize - sizeof (CHAR16),\r
                   NewBuffer\r
                   );\r
\r
        if (!EFI_ERROR (Status)) {\r
          Status = ShellAddEnvVarToList (\r
                     ((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name,\r
                     NewBuffer,\r
                     TotalSize,\r
                     EFI_VARIABLE_BOOTSERVICE_ACCESS\r
                     );\r
        }\r
      } else {\r
        Status = SHELL_SET_ENVIRONMENT_VARIABLE_NV (\r
                   ((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name,\r
                   TotalSize - sizeof (CHAR16),\r
                   NewBuffer\r
                   );\r
\r
        if (!EFI_ERROR (Status)) {\r
          Status = ShellAddEnvVarToList (\r
                     ((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name,\r
                     NewBuffer,\r
                     TotalSize,\r
                     EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS\r
                     );\r
        }\r
      }\r
    }\r
  }\r
\r
  SHELL_FREE_NON_NULL (NewBuffer);\r
  FreePool ((EFI_FILE_PROTOCOL_ENVIRONMENT *)This);\r
  return (Status);\r
}\r
\r
/**\r
  File style interface for Environment Variable (Delete).\r
\r
  @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.\r
\r
  @retval The return value from FileInterfaceEnvClose().\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceEnvDelete (\r
  IN EFI_FILE_PROTOCOL  *This\r
  )\r
{\r
  SHELL_DELETE_ENVIRONMENT_VARIABLE (((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name);\r
  return (FileInterfaceEnvClose (This));\r
}\r
\r
/**\r
  File style interface for Environment Variable (Read).\r
\r
  @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.\r
  @param[in, out] BufferSize   Size in bytes of Buffer.\r
  @param[out] Buffer           The pointer to the buffer to fill.\r
\r
  @retval EFI_SUCCESS   The data was read.\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceEnvRead (\r
  IN     EFI_FILE_PROTOCOL  *This,\r
  IN OUT UINTN              *BufferSize,\r
  OUT    VOID               *Buffer\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  *BufferSize = *BufferSize / sizeof (CHAR16) * sizeof (CHAR16);\r
  if (*BufferSize != 0) {\r
    //\r
    // Make sure the first unicode character is \xFEFF\r
    //\r
    *(CHAR16 *)Buffer = gUnicodeFileTag;\r
    Buffer            = (CHAR16 *)Buffer + 1;\r
    *BufferSize      -= sizeof (gUnicodeFileTag);\r
  }\r
\r
  Status = SHELL_GET_ENVIRONMENT_VARIABLE (\r
             ((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name,\r
             BufferSize,\r
             Buffer\r
             );\r
  if (!EFI_ERROR (Status) || (Status == EFI_BUFFER_TOO_SMALL)) {\r
    //\r
    // BufferSize is valid and needs update when Status is Success or BufferTooSmall.\r
    //\r
    *BufferSize += sizeof (gUnicodeFileTag);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  File style interface for Volatile Environment Variable (Write).\r
  This function also caches the environment variable into gShellEnvVarList.\r
\r
  @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.\r
  @param[in, out] BufferSize   Size in bytes of Buffer.\r
  @param[in] Buffer            The pointer to the buffer to write.\r
\r
  @retval EFI_SUCCESS             The data was successfully write to variable.\r
  @retval SHELL_OUT_OF_RESOURCES  A memory allocation failed.\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceEnvVolWrite (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN OUT UINTN          *BufferSize,\r
  IN VOID               *Buffer\r
  )\r
{\r
  VOID        *NewBuffer;\r
  UINTN       NewSize;\r
  EFI_STATUS  Status;\r
  UINTN       TotalSize;\r
\r
  NewBuffer = NULL;\r
  NewSize   = 0;\r
  TotalSize = 0;\r
\r
  Status = SHELL_GET_ENVIRONMENT_VARIABLE (((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name, &NewSize, NewBuffer);\r
  if (Status == EFI_BUFFER_TOO_SMALL) {\r
    TotalSize = NewSize + *BufferSize + sizeof (CHAR16);\r
  } else if (Status == EFI_NOT_FOUND) {\r
    TotalSize = *BufferSize + sizeof (CHAR16);\r
  } else {\r
    return Status;\r
  }\r
\r
  NewBuffer = AllocateZeroPool (TotalSize);\r
  if (NewBuffer == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  if (Status == EFI_BUFFER_TOO_SMALL) {\r
    Status = SHELL_GET_ENVIRONMENT_VARIABLE (((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name, &NewSize, NewBuffer);\r
  }\r
\r
  if (EFI_ERROR (Status) && (Status != EFI_NOT_FOUND)) {\r
    FreePool (NewBuffer);\r
    return Status;\r
  }\r
\r
  CopyMem ((UINT8 *)NewBuffer + NewSize, Buffer, *BufferSize);\r
  Status = ShellAddEnvVarToList (\r
             ((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name,\r
             NewBuffer,\r
             TotalSize,\r
             EFI_VARIABLE_BOOTSERVICE_ACCESS\r
             );\r
  if (EFI_ERROR (Status)) {\r
    FreePool (NewBuffer);\r
    return Status;\r
  }\r
\r
  Status = SHELL_SET_ENVIRONMENT_VARIABLE_V (\r
             ((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name,\r
             TotalSize - sizeof (CHAR16),\r
             NewBuffer\r
             );\r
  if (EFI_ERROR (Status)) {\r
    ShellRemvoeEnvVarFromList (((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name);\r
  }\r
\r
  FreePool (NewBuffer);\r
  return Status;\r
}\r
\r
/**\r
  File style interface for Non Volatile Environment Variable (Write).\r
  This function also caches the environment variable into gShellEnvVarList.\r
\r
  @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.\r
  @param[in, out] BufferSize   Size in bytes of Buffer.\r
  @param[in] Buffer            The pointer to the buffer to write.\r
\r
  @retval EFI_SUCCESS             The data was successfully write to variable.\r
  @retval SHELL_OUT_OF_RESOURCES  A memory allocation failed.\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceEnvNonVolWrite (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN OUT UINTN          *BufferSize,\r
  IN VOID               *Buffer\r
  )\r
{\r
  VOID        *NewBuffer;\r
  UINTN       NewSize;\r
  EFI_STATUS  Status;\r
  UINTN       TotalSize;\r
\r
  NewBuffer = NULL;\r
  NewSize   = 0;\r
  TotalSize = 0;\r
\r
  Status = SHELL_GET_ENVIRONMENT_VARIABLE (((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name, &NewSize, NewBuffer);\r
  if (Status == EFI_BUFFER_TOO_SMALL) {\r
    TotalSize = NewSize + *BufferSize + sizeof (CHAR16);\r
  } else if (Status == EFI_NOT_FOUND) {\r
    TotalSize = *BufferSize + sizeof (CHAR16);\r
  } else {\r
    return Status;\r
  }\r
\r
  NewBuffer = AllocateZeroPool (TotalSize);\r
  if (NewBuffer == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  if (Status == EFI_BUFFER_TOO_SMALL) {\r
    Status = SHELL_GET_ENVIRONMENT_VARIABLE (((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name, &NewSize, NewBuffer);\r
  }\r
\r
  if (EFI_ERROR (Status) && (Status != EFI_NOT_FOUND)) {\r
    FreePool (NewBuffer);\r
    return Status;\r
  }\r
\r
  CopyMem ((UINT8 *)NewBuffer + NewSize, Buffer, *BufferSize);\r
  Status = ShellAddEnvVarToList (\r
             ((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name,\r
             NewBuffer,\r
             TotalSize,\r
             EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS\r
             );\r
  if (EFI_ERROR (Status)) {\r
    FreePool (NewBuffer);\r
    return Status;\r
  }\r
\r
  Status = SHELL_SET_ENVIRONMENT_VARIABLE_NV (\r
             ((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name,\r
             TotalSize - sizeof (CHAR16),\r
             NewBuffer\r
             );\r
  if (EFI_ERROR (Status)) {\r
    ShellRemvoeEnvVarFromList (((EFI_FILE_PROTOCOL_ENVIRONMENT *)This)->Name);\r
  }\r
\r
  FreePool (NewBuffer);\r
  return Status;\r
}\r
\r
/**\r
  Creates a EFI_FILE_PROTOCOL (almost) object for using to access\r
  environment variables through file operations.\r
\r
  @param EnvName    The name of the Environment Variable to be operated on.\r
\r
  @retval NULL      Memory could not be allocated.\r
  @return other     a pointer to an EFI_FILE_PROTOCOL structure\r
**/\r
EFI_FILE_PROTOCOL *\r
CreateFileInterfaceEnv (\r
  IN CONST CHAR16  *EnvName\r
  )\r
{\r
  EFI_STATUS                     Status;\r
  EFI_FILE_PROTOCOL_ENVIRONMENT  *EnvFileInterface;\r
  UINTN                          EnvNameSize;\r
  BOOLEAN                        Volatile;\r
\r
  if (EnvName == NULL) {\r
    return (NULL);\r
  }\r
\r
  Status = IsVolatileEnv (EnvName, &Volatile);\r
  if (EFI_ERROR (Status)) {\r
    return NULL;\r
  }\r
\r
  //\r
  // Get some memory\r
  //\r
  EnvNameSize      = StrSize (EnvName);\r
  EnvFileInterface = AllocateZeroPool (sizeof (EFI_FILE_PROTOCOL_ENVIRONMENT)+EnvNameSize);\r
  if (EnvFileInterface == NULL) {\r
    return (NULL);\r
  }\r
\r
  //\r
  // Assign the generic members\r
  //\r
  EnvFileInterface->Revision    = EFI_FILE_REVISION;\r
  EnvFileInterface->Open        = FileInterfaceOpenNotFound;\r
  EnvFileInterface->Close       = FileInterfaceEnvClose;\r
  EnvFileInterface->GetPosition = FileInterfaceNopGetPosition;\r
  EnvFileInterface->SetPosition = FileInterfaceNopSetPosition;\r
  EnvFileInterface->GetInfo     = FileInterfaceNopGetInfo;\r
  EnvFileInterface->SetInfo     = FileInterfaceNopSetInfo;\r
  EnvFileInterface->Flush       = FileInterfaceNopGeneric;\r
  EnvFileInterface->Delete      = FileInterfaceEnvDelete;\r
  EnvFileInterface->Read        = FileInterfaceEnvRead;\r
\r
  CopyMem (EnvFileInterface->Name, EnvName, EnvNameSize);\r
\r
  //\r
  // Assign the different members for Volatile and Non-Volatile variables\r
  //\r
  if (Volatile) {\r
    EnvFileInterface->Write = FileInterfaceEnvVolWrite;\r
  } else {\r
    EnvFileInterface->Write = FileInterfaceEnvNonVolWrite;\r
  }\r
\r
  return ((EFI_FILE_PROTOCOL *)EnvFileInterface);\r
}\r
\r
/**\r
  Move the cursor position one character backward.\r
\r
  @param[in] LineLength       Length of a line. Get it by calling QueryMode\r
  @param[in, out] Column      Current column of the cursor position\r
  @param[in, out] Row         Current row of the cursor position\r
**/\r
VOID\r
MoveCursorBackward (\r
  IN     UINTN  LineLength,\r
  IN OUT UINTN  *Column,\r
  IN OUT UINTN  *Row\r
  )\r
{\r
  //\r
  // If current column is 0, move to the last column of the previous line,\r
  // otherwise, just decrement column.\r
  //\r
  if (*Column == 0) {\r
    *Column = LineLength - 1;\r
    if (*Row > 0) {\r
      (*Row)--;\r
    }\r
\r
    return;\r
  }\r
\r
  (*Column)--;\r
}\r
\r
/**\r
  Move the cursor position one character forward.\r
\r
  @param[in] LineLength       Length of a line.\r
  @param[in] TotalRow         Total row of a screen\r
  @param[in, out] Column      Current column of the cursor position\r
  @param[in, out] Row         Current row of the cursor position\r
**/\r
VOID\r
MoveCursorForward (\r
  IN     UINTN  LineLength,\r
  IN     UINTN  TotalRow,\r
  IN OUT UINTN  *Column,\r
  IN OUT UINTN  *Row\r
  )\r
{\r
  //\r
  // Increment Column.\r
  // If this puts column past the end of the line, move to first column\r
  // of the next row.\r
  //\r
  (*Column)++;\r
  if (*Column >= LineLength) {\r
    (*Column) = 0;\r
    if ((*Row) < TotalRow - 1) {\r
      (*Row)++;\r
    }\r
  }\r
}\r
\r
/**\r
  Prints out each previously typed command in the command list history log.\r
\r
  When each screen is full it will pause for a key before continuing.\r
\r
  @param[in] TotalCols    How many columns are on the screen\r
  @param[in] TotalRows    How many rows are on the screen\r
  @param[in] StartColumn  which column to start at\r
**/\r
VOID\r
PrintCommandHistory (\r
  IN CONST UINTN  TotalCols,\r
  IN CONST UINTN  TotalRows,\r
  IN CONST UINTN  StartColumn\r
  )\r
{\r
  BUFFER_LIST  *Node;\r
  UINTN        Index;\r
  UINTN        LineNumber;\r
  UINTN        LineCount;\r
\r
  ShellPrintEx (-1, -1, L"\n");\r
  Index      = 0;\r
  LineNumber = 0;\r
  //\r
  // go through history list...\r
  //\r
  for ( Node = (BUFFER_LIST *)GetFirstNode (&ShellInfoObject.ViewingSettings.CommandHistory.Link)\r
        ; !IsNull (&ShellInfoObject.ViewingSettings.CommandHistory.Link, &Node->Link)\r
        ; Node = (BUFFER_LIST *)GetNextNode (&ShellInfoObject.ViewingSettings.CommandHistory.Link, &Node->Link)\r
        )\r
  {\r
    Index++;\r
    LineCount = ((StrLen (Node->Buffer) + StartColumn + 1) / TotalCols) + 1;\r
\r
    if (LineNumber + LineCount >= TotalRows) {\r
      ShellPromptForResponseHii (\r
        ShellPromptResponseTypeEnterContinue,\r
        STRING_TOKEN (STR_SHELL_ENTER_TO_CONT),\r
        ShellInfoObject.HiiHandle,\r
        NULL\r
        );\r
      LineNumber = 0;\r
    }\r
\r
    ShellPrintEx (-1, -1, L"%2d. %s\n", Index, Node->Buffer);\r
    LineNumber += LineCount;\r
  }\r
}\r
\r
//\r
// This is identical to EFI_FILE_PROTOCOL except for the additional members\r
// for the buffer, size, and position.\r
//\r
\r
typedef struct {\r
  UINT64                   Revision;\r
  EFI_FILE_OPEN            Open;\r
  EFI_FILE_CLOSE           Close;\r
  EFI_FILE_DELETE          Delete;\r
  EFI_FILE_READ            Read;\r
  EFI_FILE_WRITE           Write;\r
  EFI_FILE_GET_POSITION    GetPosition;\r
  EFI_FILE_SET_POSITION    SetPosition;\r
  EFI_FILE_GET_INFO        GetInfo;\r
  EFI_FILE_SET_INFO        SetInfo;\r
  EFI_FILE_FLUSH           Flush;\r
  VOID                     *Buffer;\r
  UINT64                   Position;\r
  UINT64                   BufferSize;\r
  BOOLEAN                  Unicode;\r
  UINT64                   FileSize;\r
} EFI_FILE_PROTOCOL_MEM;\r
\r
/**\r
  File style interface for Mem (SetPosition).\r
\r
  @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.\r
  @param[out] Position  The position to set.\r
\r
  @retval EFI_SUCCESS             The position was successfully changed.\r
  @retval EFI_INVALID_PARAMETER   The Position was invalid.\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceMemSetPosition (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  OUT UINT64            Position\r
  )\r
{\r
  if (Position <= ((EFI_FILE_PROTOCOL_MEM *)This)->FileSize) {\r
    ((EFI_FILE_PROTOCOL_MEM *)This)->Position = Position;\r
    return (EFI_SUCCESS);\r
  } else {\r
    return (EFI_INVALID_PARAMETER);\r
  }\r
}\r
\r
/**\r
  File style interface for Mem (GetPosition).\r
\r
  @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.\r
  @param[out] Position  The pointer to the position.\r
\r
  @retval EFI_SUCCESS   The position was retrieved.\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceMemGetPosition (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  OUT UINT64            *Position\r
  )\r
{\r
  *Position = ((EFI_FILE_PROTOCOL_MEM *)This)->Position;\r
  return (EFI_SUCCESS);\r
}\r
\r
/**\r
  File style interface for Mem (GetInfo).\r
\r
  @param  This            Protocol instance pointer.\r
  @param  InformationType Type of information to return in Buffer.\r
  @param  BufferSize      On input size of buffer, on output amount of data in buffer.\r
  @param  Buffer          The buffer to return data.\r
\r
  @retval EFI_SUCCESS          Data was returned.\r
  @retval EFI_UNSUPPORT        InformationType is not supported.\r
  @retval EFI_NO_MEDIA         The device has no media.\r
  @retval EFI_DEVICE_ERROR     The device reported an error.\r
  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.\r
  @retval EFI_WRITE_PROTECTED  The device is write protected.\r
  @retval EFI_ACCESS_DENIED    The file was open for read only.\r
  @retval EFI_BUFFER_TOO_SMALL Buffer was too small; required size returned in BufferSize.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceMemGetInfo (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN EFI_GUID           *InformationType,\r
  IN OUT UINTN          *BufferSize,\r
  OUT VOID              *Buffer\r
  )\r
{\r
  EFI_FILE_INFO  *FileInfo;\r
\r
  if (CompareGuid (InformationType, &gEfiFileInfoGuid)) {\r
    if (*BufferSize < sizeof (EFI_FILE_INFO)) {\r
      *BufferSize = sizeof (EFI_FILE_INFO);\r
      return EFI_BUFFER_TOO_SMALL;\r
    }\r
\r
    if (Buffer == NULL) {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    FileInfo       = (EFI_FILE_INFO *)Buffer;\r
    FileInfo->Size = sizeof (*FileInfo);\r
    ZeroMem (FileInfo, sizeof (*FileInfo));\r
    FileInfo->FileSize     = ((EFI_FILE_PROTOCOL_MEM *)This)->FileSize;\r
    FileInfo->PhysicalSize = FileInfo->FileSize;\r
    return EFI_SUCCESS;\r
  }\r
\r
  return EFI_UNSUPPORTED;\r
}\r
\r
/**\r
  File style interface for Mem (Write).\r
\r
  @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.\r
  @param[in, out] BufferSize   Size in bytes of Buffer.\r
  @param[in] Buffer            The pointer to the buffer to write.\r
\r
  @retval EFI_OUT_OF_RESOURCES The operation failed due to lack of resources.\r
  @retval EFI_SUCCESS          The data was written.\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceMemWrite (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN OUT UINTN          *BufferSize,\r
  IN VOID               *Buffer\r
  )\r
{\r
  CHAR8                  *AsciiBuffer;\r
  EFI_FILE_PROTOCOL_MEM  *MemFile;\r
\r
  MemFile = (EFI_FILE_PROTOCOL_MEM *)This;\r
  if (MemFile->Unicode) {\r
    //\r
    // Unicode\r
    //\r
    if ((UINTN)(MemFile->Position + (*BufferSize)) > (UINTN)(MemFile->BufferSize)) {\r
      MemFile->Buffer = ReallocatePool ((UINTN)(MemFile->BufferSize), (UINTN)(MemFile->BufferSize) + (*BufferSize) + MEM_WRITE_REALLOC_OVERHEAD, MemFile->Buffer);\r
      if (MemFile->Buffer == NULL) {\r
        return EFI_OUT_OF_RESOURCES;\r
      }\r
\r
      MemFile->BufferSize += (*BufferSize) + MEM_WRITE_REALLOC_OVERHEAD;\r
    }\r
\r
    CopyMem (((UINT8 *)MemFile->Buffer) + MemFile->Position, Buffer, *BufferSize);\r
    MemFile->Position += (*BufferSize);\r
    MemFile->FileSize  = MemFile->Position;\r
    return (EFI_SUCCESS);\r
  } else {\r
    //\r
    // Ascii\r
    //\r
    AsciiBuffer = AllocateZeroPool (*BufferSize);\r
    if (AsciiBuffer == NULL) {\r
      return (EFI_OUT_OF_RESOURCES);\r
    }\r
\r
    AsciiSPrint (AsciiBuffer, *BufferSize, "%S", Buffer);\r
    if ((UINTN)(MemFile->Position + AsciiStrSize (AsciiBuffer)) > (UINTN)(MemFile->BufferSize)) {\r
      MemFile->Buffer = ReallocatePool ((UINTN)(MemFile->BufferSize), (UINTN)(MemFile->BufferSize) + AsciiStrSize (AsciiBuffer) + MEM_WRITE_REALLOC_OVERHEAD, MemFile->Buffer);\r
      if (MemFile->Buffer == NULL) {\r
        FreePool (AsciiBuffer);\r
        return EFI_OUT_OF_RESOURCES;\r
      }\r
\r
      MemFile->BufferSize += AsciiStrSize (AsciiBuffer) + MEM_WRITE_REALLOC_OVERHEAD;\r
    }\r
\r
    CopyMem (((UINT8 *)MemFile->Buffer) + MemFile->Position, AsciiBuffer, AsciiStrSize (AsciiBuffer));\r
    MemFile->Position += (*BufferSize / sizeof (CHAR16));\r
    MemFile->FileSize  = MemFile->Position;\r
    FreePool (AsciiBuffer);\r
    return (EFI_SUCCESS);\r
  }\r
}\r
\r
/**\r
  File style interface for Mem (Read).\r
\r
  @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.\r
  @param[in, out] BufferSize   Size in bytes of Buffer.\r
  @param[in] Buffer            The pointer to the buffer to fill.\r
\r
  @retval EFI_SUCCESS   The data was read.\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceMemRead (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN OUT UINTN          *BufferSize,\r
  IN VOID               *Buffer\r
  )\r
{\r
  EFI_FILE_PROTOCOL_MEM  *MemFile;\r
\r
  MemFile = (EFI_FILE_PROTOCOL_MEM *)This;\r
  if (*BufferSize > (UINTN)((MemFile->FileSize) - (UINTN)(MemFile->Position))) {\r
    (*BufferSize) = (UINTN)((MemFile->FileSize) - (UINTN)(MemFile->Position));\r
  }\r
\r
  CopyMem (Buffer, ((UINT8 *)MemFile->Buffer) + MemFile->Position, (*BufferSize));\r
  MemFile->Position = MemFile->Position + (*BufferSize);\r
  return (EFI_SUCCESS);\r
}\r
\r
/**\r
  File style interface for Mem (Close).\r
\r
  Frees all memory associated with this object.\r
\r
  @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.\r
\r
  @retval EFI_SUCCESS   The 'file' was closed.\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceMemClose (\r
  IN EFI_FILE_PROTOCOL  *This\r
  )\r
{\r
  SHELL_FREE_NON_NULL (((EFI_FILE_PROTOCOL_MEM *)This)->Buffer);\r
  SHELL_FREE_NON_NULL (This);\r
  return (EFI_SUCCESS);\r
}\r
\r
/**\r
  Creates a EFI_FILE_PROTOCOL (almost) object for using to access\r
  a file entirely in memory through file operations.\r
\r
  @param[in] Unicode Boolean value with TRUE for Unicode and FALSE for Ascii.\r
\r
  @retval NULL      Memory could not be allocated.\r
  @return other     A pointer to an EFI_FILE_PROTOCOL structure.\r
**/\r
EFI_FILE_PROTOCOL *\r
CreateFileInterfaceMem (\r
  IN CONST BOOLEAN  Unicode\r
  )\r
{\r
  EFI_FILE_PROTOCOL_MEM  *FileInterface;\r
\r
  //\r
  // Get some memory\r
  //\r
  FileInterface = AllocateZeroPool (sizeof (EFI_FILE_PROTOCOL_MEM));\r
  if (FileInterface == NULL) {\r
    return (NULL);\r
  }\r
\r
  //\r
  // Assign the generic members\r
  //\r
  FileInterface->Revision    = EFI_FILE_REVISION;\r
  FileInterface->Open        = FileInterfaceOpenNotFound;\r
  FileInterface->Close       = FileInterfaceMemClose;\r
  FileInterface->GetPosition = FileInterfaceMemGetPosition;\r
  FileInterface->SetPosition = FileInterfaceMemSetPosition;\r
  FileInterface->GetInfo     = FileInterfaceMemGetInfo;\r
  FileInterface->SetInfo     = FileInterfaceNopSetInfo;\r
  FileInterface->Flush       = FileInterfaceNopGeneric;\r
  FileInterface->Delete      = FileInterfaceNopGeneric;\r
  FileInterface->Read        = FileInterfaceMemRead;\r
  FileInterface->Write       = FileInterfaceMemWrite;\r
  FileInterface->Unicode     = Unicode;\r
\r
  ASSERT (FileInterface->Buffer      == NULL);\r
  ASSERT (FileInterface->BufferSize  == 0);\r
  ASSERT (FileInterface->Position    == 0);\r
\r
  if (Unicode) {\r
    FileInterface->Buffer = AllocateZeroPool (sizeof (gUnicodeFileTag));\r
    if (FileInterface->Buffer == NULL) {\r
      FreePool (FileInterface);\r
      return NULL;\r
    }\r
\r
    *((CHAR16 *)(FileInterface->Buffer)) = EFI_UNICODE_BYTE_ORDER_MARK;\r
    FileInterface->BufferSize            = 2;\r
    FileInterface->Position              = 2;\r
  }\r
\r
  return ((EFI_FILE_PROTOCOL *)FileInterface);\r
}\r
\r
typedef struct {\r
  UINT64                   Revision;\r
  EFI_FILE_OPEN            Open;\r
  EFI_FILE_CLOSE           Close;\r
  EFI_FILE_DELETE          Delete;\r
  EFI_FILE_READ            Read;\r
  EFI_FILE_WRITE           Write;\r
  EFI_FILE_GET_POSITION    GetPosition;\r
  EFI_FILE_SET_POSITION    SetPosition;\r
  EFI_FILE_GET_INFO        GetInfo;\r
  EFI_FILE_SET_INFO        SetInfo;\r
  EFI_FILE_FLUSH           Flush;\r
  BOOLEAN                  Unicode;\r
  EFI_FILE_PROTOCOL        *Orig;\r
} EFI_FILE_PROTOCOL_FILE;\r
\r
/**\r
  Set a files current position\r
\r
  @param  This            Protocol instance pointer.\r
  @param  Position        Byte position from the start of the file.\r
\r
  @retval EFI_SUCCESS     Data was written.\r
  @retval EFI_UNSUPPORTED Seek request for non-zero is not valid on open.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceFileSetPosition (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN UINT64             Position\r
  )\r
{\r
  return ((EFI_FILE_PROTOCOL_FILE *)This)->Orig->SetPosition (((EFI_FILE_PROTOCOL_FILE *)This)->Orig, Position);\r
}\r
\r
/**\r
  Get a file's current position\r
\r
  @param  This            Protocol instance pointer.\r
  @param  Position        Byte position from the start of the file.\r
\r
  @retval EFI_SUCCESS     Data was written.\r
  @retval EFI_UNSUPPORTED Seek request for non-zero is not valid on open..\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceFileGetPosition (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  OUT UINT64            *Position\r
  )\r
{\r
  return ((EFI_FILE_PROTOCOL_FILE *)This)->Orig->GetPosition (((EFI_FILE_PROTOCOL_FILE *)This)->Orig, Position);\r
}\r
\r
/**\r
  Get information about a file.\r
\r
  @param  This            Protocol instance pointer.\r
  @param  InformationType Type of information to return in Buffer.\r
  @param  BufferSize      On input size of buffer, on output amount of data in buffer.\r
  @param  Buffer          The buffer to return data.\r
\r
  @retval EFI_SUCCESS          Data was returned.\r
  @retval EFI_UNSUPPORT        InformationType is not supported.\r
  @retval EFI_NO_MEDIA         The device has no media.\r
  @retval EFI_DEVICE_ERROR     The device reported an error.\r
  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.\r
  @retval EFI_WRITE_PROTECTED  The device is write protected.\r
  @retval EFI_ACCESS_DENIED    The file was open for read only.\r
  @retval EFI_BUFFER_TOO_SMALL Buffer was too small; required size returned in BufferSize.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceFileGetInfo (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN EFI_GUID           *InformationType,\r
  IN OUT UINTN          *BufferSize,\r
  OUT VOID              *Buffer\r
  )\r
{\r
  return ((EFI_FILE_PROTOCOL_FILE *)This)->Orig->GetInfo (((EFI_FILE_PROTOCOL_FILE *)This)->Orig, InformationType, BufferSize, Buffer);\r
}\r
\r
/**\r
  Set information about a file\r
\r
  @param  This            Protocol instance pointer.\r
  @param  InformationType Type of information in Buffer.\r
  @param  BufferSize      Size of buffer.\r
  @param  Buffer          The data to write.\r
\r
  @retval EFI_SUCCESS          Data was returned.\r
  @retval EFI_UNSUPPORT        InformationType is not supported.\r
  @retval EFI_NO_MEDIA         The device has no media.\r
  @retval EFI_DEVICE_ERROR     The device reported an error.\r
  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.\r
  @retval EFI_WRITE_PROTECTED  The device is write protected.\r
  @retval EFI_ACCESS_DENIED    The file was open for read only.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceFileSetInfo (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN EFI_GUID           *InformationType,\r
  IN UINTN              BufferSize,\r
  IN VOID               *Buffer\r
  )\r
{\r
  return ((EFI_FILE_PROTOCOL_FILE *)This)->Orig->SetInfo (((EFI_FILE_PROTOCOL_FILE *)This)->Orig, InformationType, BufferSize, Buffer);\r
}\r
\r
/**\r
  Flush data back for the file handle.\r
\r
  @param  This Protocol instance pointer.\r
\r
  @retval EFI_SUCCESS          Data was written.\r
  @retval EFI_UNSUPPORT        Writes to Open directory are not supported.\r
  @retval EFI_NO_MEDIA         The device has no media.\r
  @retval EFI_DEVICE_ERROR     The device reported an error.\r
  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.\r
  @retval EFI_WRITE_PROTECTED  The device is write protected.\r
  @retval EFI_ACCESS_DENIED    The file was open for read only.\r
  @retval EFI_VOLUME_FULL      The volume is full.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceFileFlush (\r
  IN EFI_FILE_PROTOCOL  *This\r
  )\r
{\r
  return ((EFI_FILE_PROTOCOL_FILE *)This)->Orig->Flush (((EFI_FILE_PROTOCOL_FILE *)This)->Orig);\r
}\r
\r
/**\r
  Read data from the file.\r
\r
  @param  This       Protocol instance pointer.\r
  @param  BufferSize On input size of buffer, on output amount of data in buffer.\r
  @param  Buffer     The buffer in which data is read.\r
\r
  @retval EFI_SUCCESS          Data was read.\r
  @retval EFI_NO_MEDIA         The device has no media.\r
  @retval EFI_DEVICE_ERROR     The device reported an error.\r
  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.\r
  @retval EFI_BUFFER_TO_SMALL  BufferSize is too small. BufferSize contains required size.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceFileRead (\r
  IN EFI_FILE_PROTOCOL  *This,\r
  IN OUT UINTN          *BufferSize,\r
  OUT VOID              *Buffer\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINT64      Position;\r
  CHAR8       *AsciiStrBuffer;\r
  CHAR16      *UscStrBuffer;\r
  UINTN       Size;\r
\r
  if (((EFI_FILE_PROTOCOL_FILE *)This)->Unicode) {\r
    //\r
    // Unicode\r
    // There might be different file tag for the Unicode file. We cannot unconditionally insert the \xFEFF.\r
    // So we choose to leave the file content as is.\r
    //\r
    return (((EFI_FILE_PROTOCOL_FILE *)This)->Orig->Read (((EFI_FILE_PROTOCOL_FILE *)This)->Orig, BufferSize, Buffer));\r
  } else {\r
    //\r
    // Ascii\r
    //\r
    *BufferSize = *BufferSize / sizeof (CHAR16) * sizeof (CHAR16);\r
    if (*BufferSize == 0) {\r
      return EFI_SUCCESS;\r
    }\r
\r
    Status = ((EFI_FILE_PROTOCOL_FILE *)This)->Orig->GetPosition (((EFI_FILE_PROTOCOL_FILE *)This)->Orig, &Position);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    if (Position == 0) {\r
      //\r
      // First two bytes in Buffer is for the Unicode file tag.\r
      //\r
      *(CHAR16 *)Buffer = gUnicodeFileTag;\r
      Buffer            = (CHAR16 *)Buffer + 1;\r
      Size              = *BufferSize / sizeof (CHAR16) - 1;\r
    } else {\r
      Size = *BufferSize / sizeof (CHAR16);\r
    }\r
\r
    AsciiStrBuffer = AllocateZeroPool (Size + 1);\r
    if (AsciiStrBuffer == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    UscStrBuffer = AllocateZeroPool ((Size + 1) * sizeof (CHAR16));\r
    if (UscStrBuffer == NULL) {\r
      SHELL_FREE_NON_NULL (AsciiStrBuffer);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    Status = ((EFI_FILE_PROTOCOL_FILE *)This)->Orig->Read (((EFI_FILE_PROTOCOL_FILE *)This)->Orig, &Size, AsciiStrBuffer);\r
    if (!EFI_ERROR (Status)) {\r
      AsciiStrToUnicodeStrS (AsciiStrBuffer, UscStrBuffer, Size + 1);\r
      *BufferSize = Size * sizeof (CHAR16);\r
      CopyMem (Buffer, UscStrBuffer, *BufferSize);\r
    }\r
\r
    SHELL_FREE_NON_NULL (AsciiStrBuffer);\r
    SHELL_FREE_NON_NULL (UscStrBuffer);\r
    return Status;\r
  }\r
}\r
\r
/**\r
  Opens a new file relative to the source file's location.\r
\r
  @param[in]  This       The protocol instance pointer.\r
  @param[out]  NewHandle Returns File Handle for FileName.\r
  @param[in]  FileName   Null terminated string. "\", ".", and ".." are supported.\r
  @param[in]  OpenMode   Open mode for file.\r
  @param[in]  Attributes Only used for EFI_FILE_MODE_CREATE.\r
\r
  @retval EFI_SUCCESS          The device was opened.\r
  @retval EFI_NOT_FOUND        The specified file could not be found on the device.\r
  @retval EFI_NO_MEDIA         The device has no media.\r
  @retval EFI_MEDIA_CHANGED    The media has changed.\r
  @retval EFI_DEVICE_ERROR     The device reported an error.\r
  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.\r
  @retval EFI_ACCESS_DENIED    The service denied access to the file.\r
  @retval EFI_OUT_OF_RESOURCES The volume was not opened due to lack of resources.\r
  @retval EFI_VOLUME_FULL      The volume is full.\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceFileOpen (\r
  IN EFI_FILE_PROTOCOL   *This,\r
  OUT EFI_FILE_PROTOCOL  **NewHandle,\r
  IN CHAR16              *FileName,\r
  IN UINT64              OpenMode,\r
  IN UINT64              Attributes\r
  )\r
{\r
  return ((EFI_FILE_PROTOCOL_FILE *)This)->Orig->Open (((EFI_FILE_PROTOCOL_FILE *)This)->Orig, NewHandle, FileName, OpenMode, Attributes);\r
}\r
\r
/**\r
  Close and delete the file handle.\r
\r
  @param  This                     Protocol instance pointer.\r
\r
  @retval EFI_SUCCESS              The device was opened.\r
  @retval EFI_WARN_DELETE_FAILURE  The handle was closed but the file was not deleted.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceFileDelete (\r
  IN EFI_FILE_PROTOCOL  *This\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  Status = ((EFI_FILE_PROTOCOL_FILE *)This)->Orig->Delete (((EFI_FILE_PROTOCOL_FILE *)This)->Orig);\r
  FreePool (This);\r
  return (Status);\r
}\r
\r
/**\r
  File style interface for File (Close).\r
\r
  @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.\r
\r
  @retval EFI_SUCCESS   The file was closed.\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceFileClose (\r
  IN EFI_FILE_PROTOCOL  *This\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  Status = ((EFI_FILE_PROTOCOL_FILE *)This)->Orig->Close (((EFI_FILE_PROTOCOL_FILE *)This)->Orig);\r
  FreePool (This);\r
  return (Status);\r
}\r
\r
/**\r
  File style interface for File (Write).\r
\r
  If the file was opened with ASCII mode the data will be processed through\r
  AsciiSPrint before writing.\r
\r
  @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.\r
  @param[in, out] BufferSize   Size in bytes of Buffer.\r
  @param[in] Buffer            The pointer to the buffer to write.\r
\r
  @retval EFI_SUCCESS   The data was written.\r
**/\r
EFI_STATUS\r
EFIAPI\r
FileInterfaceFileWrite (\r
  IN     EFI_FILE_PROTOCOL  *This,\r
  IN OUT UINTN              *BufferSize,\r
  IN     VOID               *Buffer\r
  )\r
{\r
  CHAR8       *AsciiBuffer;\r
  UINTN       Size;\r
  EFI_STATUS  Status;\r
\r
  if (((EFI_FILE_PROTOCOL_FILE *)This)->Unicode) {\r
    //\r
    // Unicode\r
    //\r
    return (((EFI_FILE_PROTOCOL_FILE *)This)->Orig->Write (((EFI_FILE_PROTOCOL_FILE *)This)->Orig, BufferSize, Buffer));\r
  } else {\r
    //\r
    // Ascii\r
    //\r
    AsciiBuffer = AllocateZeroPool (*BufferSize);\r
    AsciiSPrint (AsciiBuffer, *BufferSize, "%S", Buffer);\r
    Size   = AsciiStrSize (AsciiBuffer) - 1; // (we dont need the null terminator)\r
    Status = (((EFI_FILE_PROTOCOL_FILE *)This)->Orig->Write (((EFI_FILE_PROTOCOL_FILE *)This)->Orig, &Size, AsciiBuffer));\r
    FreePool (AsciiBuffer);\r
    return (Status);\r
  }\r
}\r
\r
/**\r
  Create a file interface with unicode information.\r
\r
  This will create a new EFI_FILE_PROTOCOL identical to the Templace\r
  except that the new one has Unicode and Ascii knowledge.\r
\r
  @param[in] Template   A pointer to the EFI_FILE_PROTOCOL object.\r
  @param[in] Unicode    TRUE for UCS-2, FALSE for ASCII.\r
\r
  @return a new EFI_FILE_PROTOCOL object to be used instead of the template.\r
**/\r
EFI_FILE_PROTOCOL *\r
CreateFileInterfaceFile (\r
  IN CONST EFI_FILE_PROTOCOL  *Template,\r
  IN CONST BOOLEAN            Unicode\r
  )\r
{\r
  EFI_FILE_PROTOCOL_FILE  *NewOne;\r
\r
  NewOne = AllocateZeroPool (sizeof (EFI_FILE_PROTOCOL_FILE));\r
  if (NewOne == NULL) {\r
    return (NULL);\r
  }\r
\r
  CopyMem (NewOne, Template, sizeof (EFI_FILE_PROTOCOL_FILE));\r
  NewOne->Orig        = (EFI_FILE_PROTOCOL *)Template;\r
  NewOne->Unicode     = Unicode;\r
  NewOne->Open        = FileInterfaceFileOpen;\r
  NewOne->Close       = FileInterfaceFileClose;\r
  NewOne->Delete      = FileInterfaceFileDelete;\r
  NewOne->Read        = FileInterfaceFileRead;\r
  NewOne->Write       = FileInterfaceFileWrite;\r
  NewOne->GetPosition = FileInterfaceFileGetPosition;\r
  NewOne->SetPosition = FileInterfaceFileSetPosition;\r
  NewOne->GetInfo     = FileInterfaceFileGetInfo;\r
  NewOne->SetInfo     = FileInterfaceFileSetInfo;\r
  NewOne->Flush       = FileInterfaceFileFlush;\r
\r
  return ((EFI_FILE_PROTOCOL *)NewOne);\r
}\r