ShellPkg/Application/Shell/FileHandleWrappers.c

   1 /** @file
   2   EFI_FILE_PROTOCOL wrappers for other items (Like Environment Variables,
   3   StdIn, StdOut, StdErr, etc...).
   4
   5   Copyright 2016 Dell Inc.
   6   Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
   7   (C) Copyright 2013 Hewlett-Packard Development Company, L.P.<BR>
   8   This program and the accompanying materials
   9   are licensed and made available under the terms and conditions of the BSD License
  10   which accompanies this distribution.  The full text of the license may be found at
  11   http://opensource.org/licenses/bsd-license.php
  12
  13   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  14   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  15
  16 **/
  17
  18 #include "Shell.h"
  19 #include "FileHandleInternal.h"
  20
  21 #define MEM_WRITE_REALLOC_OVERHEAD 1024
  22
  23 /**
  24   File style interface for console (Open).
  25
  26   @param[in] This       Ignored.
  27   @param[out] NewHandle Ignored.
  28   @param[in] FileName   Ignored.
  29   @param[in] OpenMode   Ignored.
  30   @param[in] Attributes Ignored.
  31
  32   @retval EFI_NOT_FOUND
  33 **/
  34 EFI_STATUS
  35 EFIAPI
  36 FileInterfaceOpenNotFound(
  37   IN EFI_FILE_PROTOCOL *This,
  38   OUT EFI_FILE_PROTOCOL **NewHandle,
  39   IN CHAR16 *FileName,
  40   IN UINT64 OpenMode,
  41   IN UINT64 Attributes
  42   )
  43 {
  44   return (EFI_NOT_FOUND);
  45 }
  46
  47 /**
  48   File style interface for console (Close, Delete, & Flush)
  49
  50   @param[in] This       Ignored.
  51
  52   @retval EFI_SUCCESS
  53 **/
  54 EFI_STATUS
  55 EFIAPI
  56 FileInterfaceNopGeneric(
  57   IN EFI_FILE_PROTOCOL *This
  58   )
  59 {
  60   return (EFI_SUCCESS);
  61 }
  62
  63 /**
  64   File style interface for console (GetPosition).
  65
  66   @param[in] This       Ignored.
  67   @param[out] Position  Ignored.
  68
  69   @retval EFI_UNSUPPORTED
  70 **/
  71 EFI_STATUS
  72 EFIAPI
  73 FileInterfaceNopGetPosition(
  74   IN EFI_FILE_PROTOCOL *This,
  75   OUT UINT64 *Position
  76   )
  77 {
  78   return (EFI_UNSUPPORTED);
  79 }
  80
  81 /**
  82   File style interface for console (SetPosition).
  83
  84   @param[in] This       Ignored.
  85   @param[in] Position   Ignored.
  86
  87   @retval EFI_UNSUPPORTED
  88 **/
  89 EFI_STATUS
  90 EFIAPI
  91 FileInterfaceNopSetPosition(
  92   IN EFI_FILE_PROTOCOL *This,
  93   IN UINT64 Position
  94   )
  95 {
  96   return (EFI_UNSUPPORTED);
  97 }
  98
  99 /**
 100   File style interface for console (GetInfo).
 101
 102   @param[in] This              Ignored.
 103   @param[in] InformationType   Ignored.
 104   @param[in, out] BufferSize   Ignored.
 105   @param[out] Buffer           Ignored.
 106
 107   @retval EFI_UNSUPPORTED
 108 **/
 109 EFI_STATUS
 110 EFIAPI
 111 FileInterfaceNopGetInfo(
 112   IN EFI_FILE_PROTOCOL *This,
 113   IN EFI_GUID *InformationType,
 114   IN OUT UINTN *BufferSize,
 115   OUT VOID *Buffer
 116   )
 117 {
 118   return (EFI_UNSUPPORTED);
 119 }
 120
 121 /**
 122   File style interface for console (SetInfo).
 123
 124   @param[in] This       Ignored.
 125   @param[in] InformationType   Ignored.
 126   @param[in] BufferSize Ignored.
 127   @param[in] Buffer     Ignored.
 128
 129   @retval EFI_UNSUPPORTED
 130 **/
 131 EFI_STATUS
 132 EFIAPI
 133 FileInterfaceNopSetInfo(
 134   IN EFI_FILE_PROTOCOL *This,
 135   IN EFI_GUID *InformationType,
 136   IN UINTN BufferSize,
 137   IN VOID *Buffer
 138   )
 139 {
 140   return (EFI_UNSUPPORTED);
 141 }
 142
 143 /**
 144   File style interface for StdOut (Write).
 145
 146   Writes data to the screen.
 147
 148   @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.
 149   @param[in, out] BufferSize   Size in bytes of Buffer.
 150   @param[in] Buffer            The pointer to the buffer to write.
 151
 152   @retval EFI_UNSUPPORTED No output console is supported.
 153   @return A return value from gST->ConOut->OutputString.
 154 **/
 155 EFI_STATUS
 156 EFIAPI
 157 FileInterfaceStdOutWrite(
 158   IN EFI_FILE_PROTOCOL *This,
 159   IN OUT UINTN *BufferSize,
 160   IN VOID *Buffer
 161   )
 162 {
 163   if (ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleOut) {
 164     return (EFI_UNSUPPORTED);
 165   }
 166   if (*((CHAR16 *)Buffer) == gUnicodeFileTag) {
 167     return (gST->ConOut->OutputString(gST->ConOut, (CHAR16 *)Buffer + 1));
 168   }
 169   return (gST->ConOut->OutputString(gST->ConOut, Buffer));
 170 }
 171
 172 /**
 173   File style interface for StdIn (Write).
 174
 175   @param[in] This            Ignored.
 176   @param[in, out] BufferSize Ignored.
 177   @param[in] Buffer          Ignored.
 178
 179   @retval EFI_UNSUPPORTED
 180 **/
 181 EFI_STATUS
 182 EFIAPI
 183 FileInterfaceStdInWrite(
 184   IN      EFI_FILE_PROTOCOL *This,
 185   IN OUT  UINTN             *BufferSize,
 186   IN      VOID              *Buffer
 187   )
 188 {
 189   return (EFI_UNSUPPORTED);
 190 }
 191
 192 /**
 193   File style interface for console StdErr (Write).
 194
 195   Writes error to the error output.
 196
 197   @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.
 198   @param[in, out] BufferSize   Size in bytes of Buffer.
 199   @param[in] Buffer            The pointer to the buffer to write.
 200
 201   @return A return value from gST->StdErr->OutputString.
 202 **/
 203 EFI_STATUS
 204 EFIAPI
 205 FileInterfaceStdErrWrite(
 206   IN EFI_FILE_PROTOCOL *This,
 207   IN OUT UINTN *BufferSize,
 208   IN VOID *Buffer
 209   )
 210 {
 211   return (gST->StdErr->OutputString(gST->StdErr, Buffer));
 212 }
 213
 214 /**
 215   File style interface for console StdOut (Read).
 216
 217   @param[in] This              Ignored.
 218   @param[in, out] BufferSize   Ignored.
 219   @param[out] Buffer           Ignored.
 220
 221   @retval EFI_UNSUPPORTED
 222 **/
 223 EFI_STATUS
 224 EFIAPI
 225 FileInterfaceStdOutRead(
 226   IN EFI_FILE_PROTOCOL *This,
 227   IN OUT UINTN *BufferSize,
 228   OUT VOID *Buffer
 229   )
 230 {
 231   return (EFI_UNSUPPORTED);
 232 }
 233
 234 /**
 235   File style interface for console StdErr (Read).
 236
 237   @param[in] This              Ignored.
 238   @param[in, out] BufferSize   Ignored.
 239   @param[out] Buffer           Ignored.
 240
 241   @retval EFI_UNSUPPORTED Always.
 242 **/
 243 EFI_STATUS
 244 EFIAPI
 245 FileInterfaceStdErrRead(
 246   IN EFI_FILE_PROTOCOL *This,
 247   IN OUT UINTN *BufferSize,
 248   OUT VOID *Buffer
 249   )
 250 {
 251   return (EFI_UNSUPPORTED);
 252 }
 253
 254 /**
 255   File style interface for NUL file (Read).
 256
 257   @param[in] This              Ignored.
 258   @param[in, out] BufferSize   Poiner to 0 upon return.
 259   @param[out] Buffer           Ignored.
 260
 261   @retval EFI_SUCCESS Always.
 262 **/
 263 EFI_STATUS
 264 EFIAPI
 265 FileInterfaceNulRead(
 266   IN      EFI_FILE_PROTOCOL *This,
 267   IN OUT  UINTN             *BufferSize,
 268   OUT     VOID              *Buffer
 269   )
 270 {
 271   *BufferSize = 0;
 272   return (EFI_SUCCESS);
 273 }
 274
 275 /**
 276   File style interface for NUL file (Write).
 277
 278   @param[in] This              Ignored.
 279   @param[in, out] BufferSize   Ignored.
 280   @param[in] Buffer            Ignored.
 281
 282   @retval EFI_SUCCESS
 283 **/
 284 EFI_STATUS
 285 EFIAPI
 286 FileInterfaceNulWrite(
 287   IN EFI_FILE_PROTOCOL *This,
 288   IN OUT UINTN *BufferSize,
 289   IN VOID *Buffer
 290   )
 291 {
 292   return (EFI_SUCCESS);
 293 }
 294
 295 /**
 296   Create the TAB completion list.
 297
 298   @param[in]  InputString       The command line to expand.
 299   @param[in]  StringLen         Length of the command line.
 300   @param[in]  BufferSize        Buffer size.
 301   @param[in, out] TabCompletionList Return the TAB completion list.
 302   @param[in, out] TabUpdatePos      Return the TAB update position.
 303 **/
 304 EFI_STATUS
 305 CreateTabCompletionList (
 306   IN CONST CHAR16             *InputString,
 307   IN CONST UINTN              StringLen,
 308   IN CONST UINTN              BufferSize,
 309   IN OUT EFI_SHELL_FILE_INFO  **TabCompletionList,
 310   IN OUT   UINTN              *TabUpdatePos
 311 )
 312 {
 313   BOOLEAN             InQuotation;
 314   UINTN               TabPos;
 315   UINTN               Index;
 316   CONST CHAR16        *Cwd;
 317   EFI_STATUS          Status;
 318   CHAR16              *TabStr;
 319   EFI_SHELL_FILE_INFO *FileList;
 320   EFI_SHELL_FILE_INFO *FileInfo;
 321   EFI_SHELL_FILE_INFO *TempFileInfo;
 322
 323   //
 324   // Allocate buffers
 325   //
 326   TabStr = AllocateZeroPool (BufferSize);
 327   if (TabStr == NULL) {
 328     return EFI_OUT_OF_RESOURCES;
 329   }
 330
 331   //
 332   // handle auto complete of file and directory names...
 333   // E.g.: cd fs0:\EFI\Bo<TAB>
 334   //          ^        ^
 335   //          TabPos   TabUpdatePos
 336   //
 337   TabPos        = 0;
 338   *TabUpdatePos = 0;
 339   FileList      = NULL;
 340   InQuotation   = FALSE;
 341   for (Index = 0; Index < StringLen; Index++) {
 342     switch (InputString[Index]) {
 343     case L'\"':
 344       InQuotation = (BOOLEAN) (!InQuotation);
 345       break;
 346
 347     case L' ':
 348       if (!InQuotation) {
 349         TabPos = Index + 1;
 350         *TabUpdatePos = TabPos;
 351       }
 352       break;
 353
 354     case L':':
 355       //
 356       // handle the case "fs0:<TAB>"
 357       // Update the TabUpdatePos as well.
 358       //
 359     case L'\\':
 360       *TabUpdatePos = Index + 1;
 361       break;
 362
 363     default:
 364       break;
 365     }
 366   }
 367
 368   if (StrStr (InputString + TabPos, L":") == NULL) {
 369     //
 370     // If file path doesn't contain ":", ...
 371     //
 372     Cwd = ShellInfoObject.NewEfiShellProtocol->GetCurDir (NULL);
 373     if (Cwd != NULL) {
 374       if (InputString[TabPos] != L'\\') {
 375         //
 376         // and it doesn't begin with "\\", it's a path relative to current directory.
 377         // TabStr = "<cwd>\\"
 378         //
 379         StrnCpyS (TabStr, BufferSize / sizeof (CHAR16), Cwd, (BufferSize) / sizeof (CHAR16) - 1);
 380         StrCatS (TabStr, (BufferSize) / sizeof (CHAR16), L"\\");
 381       } else {
 382         //
 383         // and it begins with "\\", it's a path pointing to root directory of current map.
 384         // TabStr = "fsx:"
 385         //
 386         Index = StrStr (Cwd, L":") - Cwd + 1;
 387         StrnCpyS (TabStr, BufferSize / sizeof (CHAR16), Cwd, Index);
 388       }
 389     }
 390   }
 391   StrnCatS (TabStr, (BufferSize) / sizeof (CHAR16), InputString + TabPos, StringLen - TabPos);
 392   StrnCatS (TabStr, (BufferSize) / sizeof (CHAR16), L"*", (BufferSize) / sizeof (CHAR16) - 1 - StrLen (TabStr));
 393   Status  = ShellInfoObject.NewEfiShellProtocol->FindFiles(TabStr, &FileList);
 394
 395   //
 396   // Filter out the non-directory for "CD" command
 397   // Filter "." and ".." for all
 398   //
 399   if (!EFI_ERROR (Status) && FileList != NULL) {
 400     //
 401     // Skip the spaces in the beginning
 402     //
 403     while (*InputString == L' ') {
 404       InputString++;
 405     }
 406
 407     for (FileInfo = (EFI_SHELL_FILE_INFO *) GetFirstNode (&FileList->Link); !IsNull (&FileList->Link, &FileInfo->Link); ) {
 408       if (((StrCmp (FileInfo->FileName, L".") == 0) || (StrCmp (FileInfo->FileName, L"..") == 0)) ||
 409           (((InputString[0] == L'c' || InputString[0] == L'C') && (InputString[1] == L'd' || InputString[1] == L'D')) &&
 410            (ShellIsDirectory (FileInfo->FullName) != EFI_SUCCESS))) {
 411         TempFileInfo = FileInfo;
 412         FileInfo = (EFI_SHELL_FILE_INFO *) RemoveEntryList (&FileInfo->Link);
 413         InternalFreeShellFileInfoNode (TempFileInfo);
 414       } else {
 415         FileInfo = (EFI_SHELL_FILE_INFO *) GetNextNode (&FileList->Link, &FileInfo->Link);
 416       }
 417     }
 418   }
 419
 420   if (FileList != NULL && !IsListEmpty (&FileList->Link)) {
 421     Status = EFI_SUCCESS;
 422   } else {
 423     ShellInfoObject.NewEfiShellProtocol->FreeFileList (&FileList);
 424     Status = EFI_NOT_FOUND;
 425   }
 426
 427   FreePool (TabStr);
 428
 429   *TabCompletionList = FileList;
 430   return Status;
 431 }
 432
 433 /**
 434   File style interface for console (Read).
 435
 436   This will return a single line of input from the console.
 437
 438   @param This           A pointer to the EFI_FILE_PROTOCOL instance that is the
 439                         file handle to read data from. Not used.
 440   @param BufferSize     On input, the size of the Buffer. On output, the amount
 441                         of data returned in Buffer. In both cases, the size is
 442                         measured in bytes.
 443   @param Buffer         The buffer into which the data is read.
 444
 445
 446   @retval EFI_SUCCESS           The data was read.
 447   @retval EFI_NO_MEDIA          The device has no medium.
 448   @retval EFI_DEVICE_ERROR      The device reported an error.
 449   @retval EFI_DEVICE_ERROR      An attempt was made to read from a deleted file.
 450   @retval EFI_DEVICE_ERROR      On entry, the current file position is beyond the end of the file.
 451   @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
 452   @retval EFI_BUFFER_TOO_SMALL  The BufferSize is too small to read the current directory
 453                                 entry. BufferSize has been updated with the size
 454                                 needed to complete the request.
 455   @retval EFI_OUT_OF_RESOURCES  A memory allocation failed.
 456 **/
 457 EFI_STATUS
 458 EFIAPI
 459 FileInterfaceStdInRead(
 460   IN EFI_FILE_PROTOCOL *This,
 461   IN OUT UINTN *BufferSize,
 462   OUT VOID *Buffer
 463   )
 464 {
 465   CHAR16              *CurrentString;
 466   BOOLEAN             Done;
 467   UINTN               TabUpdatePos;   // Start index of the string updated by TAB stroke
 468   UINTN               Column;         // Column of current cursor
 469   UINTN               Row;            // Row of current cursor
 470   UINTN               StartColumn;    // Column at the beginning of the line
 471   UINTN               Update;         // Line index for update
 472   UINTN               Delete;         // Num of chars to delete from console after update
 473   UINTN               StringLen;      // Total length of the line
 474   UINTN               StringCurPos;   // Line index corresponding to the cursor
 475   UINTN               MaxStr;         // Maximum possible line length
 476   UINTN               TotalColumn;     // Num of columns in the console
 477   UINTN               TotalRow;       // Num of rows in the console
 478   UINTN               SkipLength;
 479   UINTN               OutputLength;   // Length of the update string
 480   UINTN               TailRow;        // Row of end of line
 481   UINTN               TailColumn;     // Column of end of line
 482   EFI_INPUT_KEY       Key;
 483
 484   BUFFER_LIST         *LinePos;
 485   BUFFER_LIST         *NewPos;
 486   BOOLEAN             InScrolling;
 487   EFI_STATUS          Status;
 488   BOOLEAN             InTabScrolling; // Whether in TAB-completion state
 489   EFI_SHELL_FILE_INFO *TabCompleteList;
 490   EFI_SHELL_FILE_INFO *TabCurrent;
 491   UINTN               EventIndex;
 492   CHAR16              *TabOutputStr;
 493
 494   //
 495   // If buffer is not large enough to hold a CHAR16, return minimum buffer size
 496   //
 497   if (*BufferSize < sizeof (CHAR16) * 2) {
 498     *BufferSize = sizeof (CHAR16) * 2;
 499     return (EFI_BUFFER_TOO_SMALL);
 500   }
 501
 502   Done              = FALSE;
 503   CurrentString     = Buffer;
 504   StringLen         = 0;
 505   StringCurPos      = 0;
 506   OutputLength      = 0;
 507   Update            = 0;
 508   Delete            = 0;
 509   LinePos           = NewPos = (BUFFER_LIST*)(&ShellInfoObject.ViewingSettings.CommandHistory);
 510   InScrolling       = FALSE;
 511   InTabScrolling    = FALSE;
 512   Status            = EFI_SUCCESS;
 513   TabOutputStr      = NULL;
 514   TabUpdatePos      = 0;
 515   TabCompleteList   = NULL;
 516   TabCurrent        = NULL;
 517
 518   //
 519   // Get the screen setting and the current cursor location
 520   //
 521   Column      = StartColumn = gST->ConOut->Mode->CursorColumn;
 522   Row         = gST->ConOut->Mode->CursorRow;
 523   gST->ConOut->QueryMode (gST->ConOut, gST->ConOut->Mode->Mode, &TotalColumn, &TotalRow);
 524
 525   //
 526   // Limit the line length to the buffer size or the minimun size of the
 527   // screen. (The smaller takes effect)
 528   //
 529   MaxStr = TotalColumn * (TotalRow - 1) - StartColumn;
 530   if (MaxStr > *BufferSize / sizeof (CHAR16)) {
 531     MaxStr = *BufferSize / sizeof (CHAR16);
 532   }
 533   ZeroMem (CurrentString, MaxStr * sizeof (CHAR16));
 534   do {
 535     //
 536     // Read a key
 537     //
 538     gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &EventIndex);
 539     Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
 540     if (EFI_ERROR (Status)) {
 541
 542       if (Status == EFI_NOT_READY)
 543         continue;
 544
 545       ZeroMem (CurrentString, MaxStr * sizeof(CHAR16));
 546       StringLen = 0;
 547       break;
 548     }
 549
 550     //
 551     // Press PageUp or PageDown to scroll the history screen up or down.
 552     // Press any other key to quit scrolling.
 553     //
 554     if (Key.UnicodeChar == 0 && (Key.ScanCode == SCAN_PAGE_UP || Key.ScanCode == SCAN_PAGE_DOWN)) {
 555       if (Key.ScanCode == SCAN_PAGE_UP) {
 556         ConsoleLoggerDisplayHistory(FALSE, 0, ShellInfoObject.ConsoleInfo);
 557       } else if (Key.ScanCode == SCAN_PAGE_DOWN) {
 558         ConsoleLoggerDisplayHistory(TRUE, 0, ShellInfoObject.ConsoleInfo);
 559       }
 560
 561       InScrolling = TRUE;
 562     } else {
 563       if (InScrolling) {
 564         ConsoleLoggerStopHistory(ShellInfoObject.ConsoleInfo);
 565         InScrolling = FALSE;
 566       }
 567     }
 568
 569     //
 570     // If we are quitting TAB scrolling...
 571     //
 572     if (InTabScrolling && Key.UnicodeChar != CHAR_TAB) {
 573       if (TabCompleteList != NULL) {
 574         ShellInfoObject.NewEfiShellProtocol->FreeFileList (&TabCompleteList);
 575         DEBUG_CODE(TabCompleteList = NULL;);
 576       }
 577       InTabScrolling = FALSE;
 578     }
 579
 580     switch (Key.UnicodeChar) {
 581     case CHAR_CARRIAGE_RETURN:
 582       //
 583       // All done, print a newline at the end of the string
 584       //
 585       TailRow     = Row + (StringLen - StringCurPos + Column) / TotalColumn;
 586       TailColumn  = (StringLen - StringCurPos + Column) % TotalColumn;
 587       ShellPrintEx ((INT32)TailColumn, (INT32)TailRow, L"%N\n");
 588       Done = TRUE;
 589       break;
 590
 591     case CHAR_BACKSPACE:
 592       if (StringCurPos != 0) {
 593         //
 594         // If not move back beyond string beginning, move all characters behind
 595         // the current position one character forward
 596         //
 597         StringCurPos--;
 598         Update  = StringCurPos;
 599         Delete  = 1;
 600         CopyMem (CurrentString + StringCurPos, CurrentString + StringCurPos + 1, sizeof (CHAR16) * (StringLen - StringCurPos));
 601
 602         //
 603         // Adjust the current column and row
 604         //
 605         MoveCursorBackward (TotalColumn, &Column, &Row);
 606       }
 607       break;
 608
 609     case CHAR_TAB:
 610       if (!InTabScrolling) {
 611         TabCurrent = NULL;
 612         //
 613         // Initialize a tab complete operation.
 614         //
 615         Status = CreateTabCompletionList (CurrentString, StringLen, *BufferSize, &TabCompleteList, &TabUpdatePos);
 616         if (!EFI_ERROR(Status)) {
 617           InTabScrolling = TRUE;
 618         }
 619
 620         //
 621         // We do not set up the replacement.
 622         // The next section will do that.
 623         //
 624       }
 625
 626       if (InTabScrolling) {
 627         //
 628         // We are in a tab complete operation.
 629         // set up the next replacement.
 630         //
 631         ASSERT(TabCompleteList != NULL);
 632         if (TabCurrent == NULL) {
 633           TabCurrent = (EFI_SHELL_FILE_INFO*) GetFirstNode (&TabCompleteList->Link);
 634         } else {
 635           TabCurrent = (EFI_SHELL_FILE_INFO*) GetNextNode (&TabCompleteList->Link, &TabCurrent->Link);
 636         }
 637
 638         //
 639         // Skip over the empty list beginning node
 640         //
 641         if (IsNull(&TabCompleteList->Link, &TabCurrent->Link)) {
 642           TabCurrent = (EFI_SHELL_FILE_INFO*) GetNextNode (&TabCompleteList->Link, &TabCurrent->Link);
 643         }
 644       }
 645       break;
 646
 647     default:
 648       if (Key.UnicodeChar >= ' ') {
 649         //
 650         // If we are at the buffer's end, drop the key
 651         //
 652         if (StringLen == MaxStr - 1 && (ShellInfoObject.ViewingSettings.InsertMode || StringCurPos == StringLen)) {
 653           break;
 654         }
 655         //
 656         // If in insert mode, make space by moving each other character 1
 657         // space higher in the array
 658         //
 659         if (ShellInfoObject.ViewingSettings.InsertMode) {
 660           CopyMem(CurrentString + StringCurPos + 1, CurrentString + StringCurPos, (StringLen - StringCurPos)*sizeof(CurrentString[0]));
 661         }
 662
 663         CurrentString[StringCurPos] = Key.UnicodeChar;
 664         Update      = StringCurPos;
 665
 666         StringCurPos += 1;
 667         OutputLength = 1;
 668       }
 669       break;
 670
 671     case 0:
 672       switch (Key.ScanCode) {
 673       case SCAN_DELETE:
 674         //
 675         // Move characters behind current position one character forward
 676         //
 677         if (StringLen != 0) {
 678           Update  = StringCurPos;
 679           Delete  = 1;
 680           CopyMem (CurrentString + StringCurPos, CurrentString + StringCurPos + 1, sizeof (CHAR16) * (StringLen - StringCurPos));
 681         }
 682         break;
 683
 684       case SCAN_UP:
 685         //
 686         // Prepare to print the previous command
 687         //
 688         NewPos = (BUFFER_LIST*)GetPreviousNode(&ShellInfoObject.ViewingSettings.CommandHistory.Link, &LinePos->Link);
 689         if (IsNull(&ShellInfoObject.ViewingSettings.CommandHistory.Link, &LinePos->Link)) {
 690           NewPos = (BUFFER_LIST*)GetPreviousNode(&ShellInfoObject.ViewingSettings.CommandHistory.Link, &LinePos->Link);
 691         }
 692         break;
 693
 694       case SCAN_DOWN:
 695         //
 696         // Prepare to print the next command
 697         //
 698         NewPos = (BUFFER_LIST*)GetNextNode(&ShellInfoObject.ViewingSettings.CommandHistory.Link, &LinePos->Link);
 699         if (NewPos == (BUFFER_LIST*)(&ShellInfoObject.ViewingSettings.CommandHistory)) {
 700           NewPos = (BUFFER_LIST*)GetNextNode(&ShellInfoObject.ViewingSettings.CommandHistory.Link, &LinePos->Link);
 701         }
 702         break;
 703
 704       case SCAN_LEFT:
 705         //
 706         // Adjust current cursor position
 707         //
 708         if (StringCurPos != 0) {
 709           --StringCurPos;
 710           MoveCursorBackward (TotalColumn, &Column, &Row);
 711         }
 712         break;
 713
 714       case SCAN_RIGHT:
 715         //
 716         // Adjust current cursor position
 717         //
 718         if (StringCurPos < StringLen) {
 719           ++StringCurPos;
 720           MoveCursorForward (TotalColumn, TotalRow, &Column, &Row);
 721         }
 722         break;
 723
 724       case SCAN_HOME:
 725         //
 726         // Move current cursor position to the beginning of the command line
 727         //
 728         Row -= (StringCurPos + StartColumn) / TotalColumn;
 729         Column  = StartColumn;
 730         StringCurPos  = 0;
 731         break;
 732
 733       case SCAN_END:
 734         //
 735         // Move current cursor position to the end of the command line
 736         //
 737         TailRow       = Row + (StringLen - StringCurPos + Column) / TotalColumn;
 738         TailColumn    = (StringLen - StringCurPos + Column) % TotalColumn;
 739         Row           = TailRow;
 740         Column        = TailColumn;
 741         StringCurPos  = StringLen;
 742         break;
 743
 744       case SCAN_ESC:
 745         //
 746         // Prepare to clear the current command line
 747         //
 748         CurrentString[0]  = 0;
 749         Update  = 0;
 750         Delete  = StringLen;
 751         Row -= (StringCurPos + StartColumn) / TotalColumn;
 752         Column        = StartColumn;
 753         OutputLength  = 0;
 754         break;
 755
 756       case SCAN_INSERT:
 757         //
 758         // Toggle the SEnvInsertMode flag
 759         //
 760         ShellInfoObject.ViewingSettings.InsertMode = (BOOLEAN)!ShellInfoObject.ViewingSettings.InsertMode;
 761         break;
 762
 763       case SCAN_F7:
 764         //
 765         // Print command history
 766         //
 767         PrintCommandHistory (TotalColumn, TotalRow, 4);
 768         *CurrentString  = CHAR_NULL;
 769         Done  = TRUE;
 770         break;
 771       }
 772     }
 773
 774     if (Done) {
 775       break;
 776     }
 777
 778     //
 779     // If we are in auto-complete mode, we are preparing to print
 780     // the next file or directory name
 781     //
 782     if (InTabScrolling) {
 783       TabOutputStr = AllocateZeroPool (*BufferSize);
 784       if (TabOutputStr == NULL) {
 785         Status = EFI_OUT_OF_RESOURCES;
 786       }
 787     }
 788
 789     if (InTabScrolling && TabOutputStr != NULL) {
 790
 791       //
 792       // Adjust the column and row to the start of TAB-completion string.
 793       //
 794       Column = (StartColumn + TabUpdatePos) % TotalColumn;
 795       Row -= (StartColumn + StringCurPos) / TotalColumn - (StartColumn + TabUpdatePos) / TotalColumn;
 796       OutputLength = StrLen (TabCurrent->FileName);
 797       //
 798       // if the output string contains  blank space, quotation marks L'\"'
 799       // should be added to the output.
 800       //
 801       if (StrStr(TabCurrent->FileName, L" ") != NULL){
 802         TabOutputStr[0] = L'\"';
 803         CopyMem (TabOutputStr + 1, TabCurrent->FileName, OutputLength * sizeof (CHAR16));
 804         TabOutputStr[OutputLength + 1] = L'\"';
 805         TabOutputStr[OutputLength + 2] = CHAR_NULL;
 806       } else {
 807         CopyMem (TabOutputStr, TabCurrent->FileName, OutputLength * sizeof (CHAR16));
 808         TabOutputStr[OutputLength] = CHAR_NULL;
 809       }
 810       OutputLength = StrLen (TabOutputStr) < MaxStr - 1 ? StrLen (TabOutputStr) : MaxStr - 1;
 811       CopyMem (CurrentString + TabUpdatePos, TabOutputStr, OutputLength * sizeof (CHAR16));
 812       CurrentString[TabUpdatePos + OutputLength] = CHAR_NULL;
 813       StringCurPos = TabUpdatePos + OutputLength;
 814       Update = TabUpdatePos;
 815       if (StringLen > TabUpdatePos + OutputLength) {
 816         Delete = StringLen - TabUpdatePos - OutputLength;
 817       }
 818
 819       FreePool(TabOutputStr);
 820     }
 821
 822     //
 823     // If we have a new position, we are preparing to print a previous or
 824     // next command.
 825     //
 826     if (NewPos != (BUFFER_LIST*)(&ShellInfoObject.ViewingSettings.CommandHistory)) {
 827       Column = StartColumn;
 828       Row -= (StringCurPos + StartColumn) / TotalColumn;
 829
 830       LinePos       = NewPos;
 831       NewPos        = (BUFFER_LIST*)(&ShellInfoObject.ViewingSettings.CommandHistory);
 832
 833       OutputLength  = StrLen (LinePos->Buffer) < MaxStr - 1 ? StrLen (LinePos->Buffer) : MaxStr - 1;
 834       CopyMem (CurrentString, LinePos->Buffer, OutputLength * sizeof (CHAR16));
 835       CurrentString[OutputLength] = CHAR_NULL;
 836
 837       StringCurPos            = OutputLength;
 838
 839       //
 840       // Draw new input string
 841       //
 842       Update = 0;
 843       if (StringLen > OutputLength) {
 844         //
 845         // If old string was longer, blank its tail
 846         //
 847         Delete = StringLen - OutputLength;
 848       }
 849     }
 850     //
 851     // If we need to update the output do so now
 852     //
 853     if (Update != (UINTN) -1) {
 854       ShellPrintEx ((INT32)Column, (INT32)Row, L"%s%.*s", CurrentString + Update, Delete, L"");
 855       StringLen = StrLen (CurrentString);
 856
 857       if (Delete != 0) {
 858         SetMem (CurrentString + StringLen, Delete * sizeof (CHAR16), CHAR_NULL);
 859       }
 860
 861       if (StringCurPos > StringLen) {
 862         StringCurPos = StringLen;
 863       }
 864
 865       Update = (UINTN) -1;
 866
 867       //
 868       // After using print to reflect newly updates, if we're not using
 869       // BACKSPACE and DELETE, we need to move the cursor position forward,
 870       // so adjust row and column here.
 871       //
 872       if (Key.UnicodeChar != CHAR_BACKSPACE && !(Key.UnicodeChar == 0 && Key.ScanCode == SCAN_DELETE)) {
 873         //
 874         // Calulate row and column of the tail of current string
 875         //
 876         TailRow     = Row + (StringLen - StringCurPos + Column + OutputLength) / TotalColumn;
 877         TailColumn  = (StringLen - StringCurPos + Column + OutputLength) % TotalColumn;
 878
 879         //
 880         // If the tail of string reaches screen end, screen rolls up, so if
 881         // Row does not equal TailRow, Row should be decremented
 882         //
 883         // (if we are recalling commands using UPPER and DOWN key, and if the
 884         // old command is too long to fit the screen, TailColumn must be 79.
 885         //
 886         if (TailColumn == 0 && TailRow >= TotalRow && Row != TailRow) {
 887           Row--;
 888         }
 889         //
 890         // Calculate the cursor position after current operation. If cursor
 891         // reaches line end, update both row and column, otherwise, only
 892         // column will be changed.
 893         //
 894         if (Column + OutputLength >= TotalColumn) {
 895           SkipLength = OutputLength - (TotalColumn - Column);
 896
 897           Row += SkipLength / TotalColumn + 1;
 898           if (Row > TotalRow - 1) {
 899             Row = TotalRow - 1;
 900           }
 901
 902           Column = SkipLength % TotalColumn;
 903         } else {
 904           Column += OutputLength;
 905         }
 906       }
 907
 908       Delete = 0;
 909     }
 910     //
 911     // Set the cursor position for this key
 912     //
 913     gST->ConOut->SetCursorPosition (gST->ConOut, Column, Row);
 914   } while (!Done);
 915
 916   if (CurrentString != NULL && StrLen(CurrentString) > 0) {
 917     //
 918     // add the line to the history buffer
 919     //
 920     AddLineToCommandHistory(CurrentString);
 921   }
 922
 923   //
 924   // Return the data to the caller
 925   //
 926   *BufferSize = StringLen * sizeof (CHAR16);
 927
 928   //
 929   // if this was used it should be deallocated by now...
 930   // prevent memory leaks...
 931   //
 932   if (TabCompleteList != NULL) {
 933     ShellInfoObject.NewEfiShellProtocol->FreeFileList (&TabCompleteList);
 934   }
 935   ASSERT(TabCompleteList == NULL);
 936
 937   return Status;
 938 }
 939
 940 //
 941 // FILE sytle interfaces for StdIn/StdOut/StdErr
 942 //
 943 EFI_FILE_PROTOCOL FileInterfaceStdIn = {
 944   EFI_FILE_REVISION,
 945   FileInterfaceOpenNotFound,
 946   FileInterfaceNopGeneric,
 947   FileInterfaceNopGeneric,
 948   FileInterfaceStdInRead,
 949   FileInterfaceStdInWrite,
 950   FileInterfaceNopGetPosition,
 951   FileInterfaceNopSetPosition,
 952   FileInterfaceNopGetInfo,
 953   FileInterfaceNopSetInfo,
 954   FileInterfaceNopGeneric
 955 };
 956
 957 EFI_FILE_PROTOCOL FileInterfaceStdOut = {
 958   EFI_FILE_REVISION,
 959   FileInterfaceOpenNotFound,
 960   FileInterfaceNopGeneric,
 961   FileInterfaceNopGeneric,
 962   FileInterfaceStdOutRead,
 963   FileInterfaceStdOutWrite,
 964   FileInterfaceNopGetPosition,
 965   FileInterfaceNopSetPosition,
 966   FileInterfaceNopGetInfo,
 967   FileInterfaceNopSetInfo,
 968   FileInterfaceNopGeneric
 969 };
 970
 971 EFI_FILE_PROTOCOL FileInterfaceStdErr = {
 972   EFI_FILE_REVISION,
 973   FileInterfaceOpenNotFound,
 974   FileInterfaceNopGeneric,
 975   FileInterfaceNopGeneric,
 976   FileInterfaceStdErrRead,
 977   FileInterfaceStdErrWrite,
 978   FileInterfaceNopGetPosition,
 979   FileInterfaceNopSetPosition,
 980   FileInterfaceNopGetInfo,
 981   FileInterfaceNopSetInfo,
 982   FileInterfaceNopGeneric
 983 };
 984
 985 EFI_FILE_PROTOCOL FileInterfaceNulFile = {
 986   EFI_FILE_REVISION,
 987   FileInterfaceOpenNotFound,
 988   FileInterfaceNopGeneric,
 989   FileInterfaceNopGeneric,
 990   FileInterfaceNulRead,
 991   FileInterfaceNulWrite,
 992   FileInterfaceNopGetPosition,
 993   FileInterfaceNopSetPosition,
 994   FileInterfaceNopGetInfo,
 995   FileInterfaceNopSetInfo,
 996   FileInterfaceNopGeneric
 997 };
 998
 999
1000
1001
1002 //
1003 // This is identical to EFI_FILE_PROTOCOL except for the additional member
1004 // for the name.
1005 //
1006
1007 typedef struct {
1008   UINT64                Revision;
1009   EFI_FILE_OPEN         Open;
1010   EFI_FILE_CLOSE        Close;
1011   EFI_FILE_DELETE       Delete;
1012   EFI_FILE_READ         Read;
1013   EFI_FILE_WRITE        Write;
1014   EFI_FILE_GET_POSITION GetPosition;
1015   EFI_FILE_SET_POSITION SetPosition;
1016   EFI_FILE_GET_INFO     GetInfo;
1017   EFI_FILE_SET_INFO     SetInfo;
1018   EFI_FILE_FLUSH        Flush;
1019   CHAR16                Name[1];
1020 } EFI_FILE_PROTOCOL_ENVIRONMENT;
1021 //ANSI compliance helper to get size of the struct.
1022 #define SIZE_OF_EFI_FILE_PROTOCOL_ENVIRONMENT EFI_FIELD_OFFSET (EFI_FILE_PROTOCOL_ENVIRONMENT, Name)
1023
1024 /**
1025   File style interface for Environment Variable (Close).
1026
1027   Frees the memory for this object.
1028
1029   @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.
1030
1031   @retval EFI_SUCCESS
1032 **/
1033 EFI_STATUS
1034 EFIAPI
1035 FileInterfaceEnvClose(
1036   IN EFI_FILE_PROTOCOL *This
1037   )
1038 {
1039   VOID*       NewBuffer;
1040   UINTN       NewSize;
1041   EFI_STATUS  Status;
1042   BOOLEAN     Volatile;
1043   UINTN       TotalSize;
1044
1045   //
1046   // Most if not all UEFI commands will have an '\r\n' at the end of any output.
1047   // Since the output was redirected to a variable, it does not make sense to
1048   // keep this.  So, before closing, strip the trailing '\r\n' from the variable
1049   // if it exists.
1050   //
1051   NewBuffer   = NULL;
1052   NewSize     = 0;
1053   TotalSize   = 0;
1054
1055   Status = IsVolatileEnv (((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, &Volatile);
1056   if (EFI_ERROR (Status)) {
1057     return Status;
1058   }
1059
1060   Status = SHELL_GET_ENVIRONMENT_VARIABLE(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, &NewSize, NewBuffer);
1061   if (Status == EFI_BUFFER_TOO_SMALL) {
1062     TotalSize = NewSize + sizeof (CHAR16);
1063     NewBuffer = AllocateZeroPool (TotalSize);
1064     if (NewBuffer == NULL) {
1065       return EFI_OUT_OF_RESOURCES;
1066     }
1067     Status = SHELL_GET_ENVIRONMENT_VARIABLE(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, &NewSize, NewBuffer);
1068   }
1069
1070   if (!EFI_ERROR(Status) && NewBuffer != NULL) {
1071
1072     if (TotalSize / sizeof (CHAR16) >= 3) {
1073       if ( (((CHAR16*)NewBuffer)[TotalSize / sizeof (CHAR16) - 2] == CHAR_LINEFEED) &&
1074            (((CHAR16*)NewBuffer)[TotalSize / sizeof (CHAR16) - 3] == CHAR_CARRIAGE_RETURN)
1075          ) {
1076         ((CHAR16*)NewBuffer)[TotalSize / sizeof (CHAR16) - 3] = CHAR_NULL;
1077         //
1078         // If the NewBuffer end with \r\n\0, We will repace '\r' by '\0' and then update TotalSize.
1079         //
1080         TotalSize -= sizeof(CHAR16) * 2;
1081       }
1082
1083       if (Volatile) {
1084         Status = SHELL_SET_ENVIRONMENT_VARIABLE_V (
1085                    ((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name,
1086                    TotalSize - sizeof (CHAR16),
1087                    NewBuffer
1088                    );
1089
1090         if (!EFI_ERROR(Status)) {
1091           Status = ShellAddEnvVarToList (
1092                      ((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name,
1093                      NewBuffer,
1094                      TotalSize,
1095                      EFI_VARIABLE_BOOTSERVICE_ACCESS
1096                      );
1097         }
1098       } else {
1099         Status = SHELL_SET_ENVIRONMENT_VARIABLE_NV (
1100                    ((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name,
1101                    TotalSize - sizeof (CHAR16),
1102                    NewBuffer
1103                    );
1104
1105         if (!EFI_ERROR(Status)) {
1106           Status = ShellAddEnvVarToList (
1107                      ((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name,
1108                      NewBuffer,
1109                      TotalSize,
1110                      EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS
1111                      );
1112         }
1113       }
1114     }
1115   }
1116
1117   SHELL_FREE_NON_NULL(NewBuffer);
1118   FreePool((EFI_FILE_PROTOCOL_ENVIRONMENT*)This);
1119   return (Status);
1120 }
1121
1122 /**
1123   File style interface for Environment Variable (Delete).
1124
1125   @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.
1126
1127   @retval The return value from FileInterfaceEnvClose().
1128 **/
1129 EFI_STATUS
1130 EFIAPI
1131 FileInterfaceEnvDelete(
1132   IN EFI_FILE_PROTOCOL *This
1133   )
1134 {
1135   SHELL_DELETE_ENVIRONMENT_VARIABLE(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name);
1136   return (FileInterfaceEnvClose(This));
1137 }
1138
1139 /**
1140   File style interface for Environment Variable (Read).
1141
1142   @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.
1143   @param[in, out] BufferSize   Size in bytes of Buffer.
1144   @param[out] Buffer           The pointer to the buffer to fill.
1145
1146   @retval EFI_SUCCESS   The data was read.
1147 **/
1148 EFI_STATUS
1149 EFIAPI
1150 FileInterfaceEnvRead(
1151   IN EFI_FILE_PROTOCOL *This,
1152   IN OUT UINTN *BufferSize,
1153   OUT VOID *Buffer
1154   )
1155 {
1156   return (SHELL_GET_ENVIRONMENT_VARIABLE(
1157     ((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name,
1158     BufferSize,
1159     Buffer));
1160 }
1161
1162 /**
1163   File style interface for Volatile Environment Variable (Write).
1164   This function also caches the environment variable into gShellEnvVarList.
1165
1166   @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.
1167   @param[in, out] BufferSize   Size in bytes of Buffer.
1168   @param[in] Buffer            The pointer to the buffer to write.
1169
1170   @retval EFI_SUCCESS             The data was successfully write to variable.
1171   @retval SHELL_OUT_OF_RESOURCES  A memory allocation failed.
1172 **/
1173 EFI_STATUS
1174 EFIAPI
1175 FileInterfaceEnvVolWrite(
1176   IN EFI_FILE_PROTOCOL *This,
1177   IN OUT UINTN *BufferSize,
1178   IN VOID *Buffer
1179   )
1180 {
1181   VOID*       NewBuffer;
1182   UINTN       NewSize;
1183   EFI_STATUS  Status;
1184   UINTN       TotalSize;
1185
1186   NewBuffer   = NULL;
1187   NewSize     = 0;
1188   TotalSize   = 0;
1189
1190   Status = SHELL_GET_ENVIRONMENT_VARIABLE(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, &NewSize, NewBuffer);
1191   if (Status == EFI_BUFFER_TOO_SMALL) {
1192     TotalSize = NewSize + *BufferSize + sizeof (CHAR16);
1193   } else if (Status == EFI_NOT_FOUND) {
1194     TotalSize = *BufferSize + sizeof(CHAR16);
1195   } else {
1196     return Status;
1197   }
1198
1199   NewBuffer = AllocateZeroPool (TotalSize);
1200   if (NewBuffer == NULL) {
1201     return EFI_OUT_OF_RESOURCES;
1202   }
1203
1204   if (Status == EFI_BUFFER_TOO_SMALL) {
1205     Status = SHELL_GET_ENVIRONMENT_VARIABLE(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, &NewSize, NewBuffer);
1206   }
1207
1208   if (EFI_ERROR (Status) && Status != EFI_NOT_FOUND) {
1209     FreePool (NewBuffer);
1210     return Status;
1211   }
1212
1213   CopyMem ((UINT8*)NewBuffer + NewSize, Buffer, *BufferSize);
1214   Status = ShellAddEnvVarToList (
1215              ((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name,
1216              NewBuffer,
1217              TotalSize,
1218              EFI_VARIABLE_BOOTSERVICE_ACCESS
1219              );
1220   if (EFI_ERROR(Status)) {
1221     FreePool (NewBuffer);
1222     return Status;
1223   }
1224
1225   Status = SHELL_SET_ENVIRONMENT_VARIABLE_V (
1226              ((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name,
1227              TotalSize - sizeof (CHAR16),
1228              NewBuffer
1229              );
1230   if (EFI_ERROR(Status)) {
1231     ShellRemvoeEnvVarFromList (((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name);
1232   }
1233
1234   FreePool (NewBuffer);
1235   return Status;
1236 }
1237
1238
1239 /**
1240   File style interface for Non Volatile Environment Variable (Write).
1241   This function also caches the environment variable into gShellEnvVarList.
1242
1243   @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.
1244   @param[in, out] BufferSize   Size in bytes of Buffer.
1245   @param[in] Buffer            The pointer to the buffer to write.
1246
1247   @retval EFI_SUCCESS             The data was successfully write to variable.
1248   @retval SHELL_OUT_OF_RESOURCES  A memory allocation failed.
1249 **/
1250 EFI_STATUS
1251 EFIAPI
1252 FileInterfaceEnvNonVolWrite(
1253   IN EFI_FILE_PROTOCOL *This,
1254   IN OUT UINTN *BufferSize,
1255   IN VOID *Buffer
1256   )
1257 {
1258   VOID*       NewBuffer;
1259   UINTN       NewSize;
1260   EFI_STATUS  Status;
1261   UINTN       TotalSize;
1262
1263   NewBuffer   = NULL;
1264   NewSize     = 0;
1265   TotalSize   = 0;
1266
1267   Status = SHELL_GET_ENVIRONMENT_VARIABLE(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, &NewSize, NewBuffer);
1268   if (Status == EFI_BUFFER_TOO_SMALL) {
1269     TotalSize = NewSize + *BufferSize + sizeof (CHAR16);
1270   } else if (Status == EFI_NOT_FOUND) {
1271     TotalSize = *BufferSize + sizeof (CHAR16);
1272   } else {
1273     return Status;
1274   }
1275
1276   NewBuffer = AllocateZeroPool (TotalSize);
1277   if (NewBuffer == NULL) {
1278     return EFI_OUT_OF_RESOURCES;
1279   }
1280
1281   if (Status == EFI_BUFFER_TOO_SMALL) {
1282     Status = SHELL_GET_ENVIRONMENT_VARIABLE(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, &NewSize, NewBuffer);
1283   }
1284
1285   if (EFI_ERROR(Status) && Status != EFI_NOT_FOUND) {
1286     FreePool (NewBuffer);
1287     return Status;
1288   }
1289
1290   CopyMem ((UINT8*) NewBuffer + NewSize, Buffer, *BufferSize);
1291   Status = ShellAddEnvVarToList (
1292              ((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name,
1293              NewBuffer,
1294              TotalSize,
1295              EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS
1296              );
1297   if (EFI_ERROR (Status)) {
1298     FreePool (NewBuffer);
1299     return Status;
1300   }
1301
1302   Status = SHELL_SET_ENVIRONMENT_VARIABLE_NV (
1303              ((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name,
1304              TotalSize - sizeof (CHAR16),
1305              NewBuffer
1306              );
1307   if (EFI_ERROR (Status)) {
1308     ShellRemvoeEnvVarFromList (((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name);
1309   }
1310
1311   FreePool (NewBuffer);
1312   return Status;
1313 }
1314
1315 /**
1316   Creates a EFI_FILE_PROTOCOL (almost) object for using to access
1317   environment variables through file operations.
1318
1319   @param EnvName    The name of the Environment Variable to be operated on.
1320
1321   @retval NULL      Memory could not be allocated.
1322   @return other     a pointer to an EFI_FILE_PROTOCOL structure
1323 **/
1324 EFI_FILE_PROTOCOL*
1325 CreateFileInterfaceEnv(
1326   IN CONST CHAR16 *EnvName
1327   )
1328 {
1329   EFI_STATUS                     Status;
1330   EFI_FILE_PROTOCOL_ENVIRONMENT  *EnvFileInterface;
1331   UINTN                          EnvNameSize;
1332   BOOLEAN                        Volatile;
1333
1334   if (EnvName == NULL) {
1335     return (NULL);
1336   }
1337
1338   Status = IsVolatileEnv (EnvName, &Volatile);
1339   if (EFI_ERROR (Status)) {
1340     return NULL;
1341   }
1342
1343   //
1344   // Get some memory
1345   //
1346   EnvNameSize = StrSize(EnvName);
1347   EnvFileInterface = AllocateZeroPool(sizeof(EFI_FILE_PROTOCOL_ENVIRONMENT)+EnvNameSize);
1348   if (EnvFileInterface == NULL){
1349     return (NULL);
1350   }
1351
1352   //
1353   // Assign the generic members
1354   //
1355   EnvFileInterface->Revision    = EFI_FILE_REVISION;
1356   EnvFileInterface->Open        = FileInterfaceOpenNotFound;
1357   EnvFileInterface->Close       = FileInterfaceEnvClose;
1358   EnvFileInterface->GetPosition = FileInterfaceNopGetPosition;
1359   EnvFileInterface->SetPosition = FileInterfaceNopSetPosition;
1360   EnvFileInterface->GetInfo     = FileInterfaceNopGetInfo;
1361   EnvFileInterface->SetInfo     = FileInterfaceNopSetInfo;
1362   EnvFileInterface->Flush       = FileInterfaceNopGeneric;
1363   EnvFileInterface->Delete      = FileInterfaceEnvDelete;
1364   EnvFileInterface->Read        = FileInterfaceEnvRead;
1365
1366   CopyMem(EnvFileInterface->Name, EnvName, EnvNameSize);
1367
1368   //
1369   // Assign the different members for Volatile and Non-Volatile variables
1370   //
1371   if (Volatile) {
1372     EnvFileInterface->Write       = FileInterfaceEnvVolWrite;
1373   } else {
1374     EnvFileInterface->Write       = FileInterfaceEnvNonVolWrite;
1375   }
1376   return ((EFI_FILE_PROTOCOL *)EnvFileInterface);
1377 }
1378
1379 /**
1380   Move the cursor position one character backward.
1381
1382   @param[in] LineLength       Length of a line. Get it by calling QueryMode
1383   @param[in, out] Column      Current column of the cursor position
1384   @param[in, out] Row         Current row of the cursor position
1385 **/
1386 VOID
1387 MoveCursorBackward (
1388   IN     UINTN                   LineLength,
1389   IN OUT UINTN                   *Column,
1390   IN OUT UINTN                   *Row
1391   )
1392 {
1393   //
1394   // If current column is 0, move to the last column of the previous line,
1395   // otherwise, just decrement column.
1396   //
1397   if (*Column == 0) {
1398     *Column = LineLength - 1;
1399     if (*Row > 0) {
1400       (*Row)--;
1401     }
1402     return;
1403   }
1404   (*Column)--;
1405 }
1406
1407 /**
1408   Move the cursor position one character forward.
1409
1410   @param[in] LineLength       Length of a line.
1411   @param[in] TotalRow         Total row of a screen
1412   @param[in, out] Column      Current column of the cursor position
1413   @param[in, out] Row         Current row of the cursor position
1414 **/
1415 VOID
1416 MoveCursorForward (
1417   IN     UINTN                   LineLength,
1418   IN     UINTN                   TotalRow,
1419   IN OUT UINTN                   *Column,
1420   IN OUT UINTN                   *Row
1421   )
1422 {
1423   //
1424   // Increment Column.
1425   // If this puts column past the end of the line, move to first column
1426   // of the next row.
1427   //
1428   (*Column)++;
1429   if (*Column >= LineLength) {
1430     (*Column) = 0;
1431     if ((*Row) < TotalRow - 1) {
1432       (*Row)++;
1433     }
1434   }
1435 }
1436
1437 /**
1438   Prints out each previously typed command in the command list history log.
1439
1440   When each screen is full it will pause for a key before continuing.
1441
1442   @param[in] TotalCols    How many columns are on the screen
1443   @param[in] TotalRows    How many rows are on the screen
1444   @param[in] StartColumn  which column to start at
1445 **/
1446 VOID
1447 PrintCommandHistory (
1448   IN CONST UINTN TotalCols,
1449   IN CONST UINTN TotalRows,
1450   IN CONST UINTN StartColumn
1451   )
1452 {
1453   BUFFER_LIST     *Node;
1454   UINTN           Index;
1455   UINTN           LineNumber;
1456   UINTN           LineCount;
1457
1458   ShellPrintEx (-1, -1, L"\n");
1459   Index       = 0;
1460   LineNumber  = 0;
1461   //
1462   // go through history list...
1463   //
1464   for ( Node = (BUFFER_LIST*)GetFirstNode(&ShellInfoObject.ViewingSettings.CommandHistory.Link)
1465       ; !IsNull(&ShellInfoObject.ViewingSettings.CommandHistory.Link, &Node->Link)
1466       ; Node = (BUFFER_LIST*)GetNextNode(&ShellInfoObject.ViewingSettings.CommandHistory.Link, &Node->Link)
1467    ){
1468     Index++;
1469     LineCount = ((StrLen (Node->Buffer) + StartColumn + 1) / TotalCols) + 1;
1470
1471     if (LineNumber + LineCount >= TotalRows) {
1472       ShellPromptForResponseHii(
1473         ShellPromptResponseTypeEnterContinue,
1474         STRING_TOKEN (STR_SHELL_ENTER_TO_CONT),
1475         ShellInfoObject.HiiHandle,
1476         NULL
1477        );
1478       LineNumber = 0;
1479     }
1480     ShellPrintEx (-1, -1, L"%2d. %s\n", Index, Node->Buffer);
1481     LineNumber += LineCount;
1482   }
1483 }
1484
1485
1486
1487
1488
1489
1490 //
1491 // This is identical to EFI_FILE_PROTOCOL except for the additional members
1492 // for the buffer, size, and position.
1493 //
1494
1495 typedef struct {
1496   UINT64                Revision;
1497   EFI_FILE_OPEN         Open;
1498   EFI_FILE_CLOSE        Close;
1499   EFI_FILE_DELETE       Delete;
1500   EFI_FILE_READ         Read;
1501   EFI_FILE_WRITE        Write;
1502   EFI_FILE_GET_POSITION GetPosition;
1503   EFI_FILE_SET_POSITION SetPosition;
1504   EFI_FILE_GET_INFO     GetInfo;
1505   EFI_FILE_SET_INFO     SetInfo;
1506   EFI_FILE_FLUSH        Flush;
1507   VOID                  *Buffer;
1508   UINT64                Position;
1509   UINT64                BufferSize;
1510   BOOLEAN               Unicode;
1511   UINT64                FileSize;
1512 } EFI_FILE_PROTOCOL_MEM;
1513
1514 /**
1515   File style interface for Mem (SetPosition).
1516
1517   @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.
1518   @param[out] Position  The position to set.
1519
1520   @retval EFI_SUCCESS             The position was successfully changed.
1521   @retval EFI_INVALID_PARAMETER   The Position was invalid.
1522 **/
1523 EFI_STATUS
1524 EFIAPI
1525 FileInterfaceMemSetPosition(
1526   IN EFI_FILE_PROTOCOL *This,
1527   OUT UINT64 Position
1528   )
1529 {
1530   if (Position <= ((EFI_FILE_PROTOCOL_MEM*)This)->FileSize) {
1531     ((EFI_FILE_PROTOCOL_MEM*)This)->Position = Position;
1532     return (EFI_SUCCESS);
1533   } else {
1534     return (EFI_INVALID_PARAMETER);
1535   }
1536 }
1537
1538 /**
1539   File style interface for Mem (GetPosition).
1540
1541   @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.
1542   @param[out] Position  The pointer to the position.
1543
1544   @retval EFI_SUCCESS   The position was retrieved.
1545 **/
1546 EFI_STATUS
1547 EFIAPI
1548 FileInterfaceMemGetPosition(
1549   IN EFI_FILE_PROTOCOL *This,
1550   OUT UINT64 *Position
1551   )
1552 {
1553   *Position = ((EFI_FILE_PROTOCOL_MEM*)This)->Position;
1554   return (EFI_SUCCESS);
1555 }
1556
1557 /**
1558   File style interface for Mem (Write).
1559
1560   @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.
1561   @param[in, out] BufferSize   Size in bytes of Buffer.
1562   @param[in] Buffer            The pointer to the buffer to write.
1563
1564   @retval EFI_OUT_OF_RESOURCES The operation failed due to lack of resources.
1565   @retval EFI_SUCCESS          The data was written.
1566 **/
1567 EFI_STATUS
1568 EFIAPI
1569 FileInterfaceMemWrite(
1570   IN EFI_FILE_PROTOCOL *This,
1571   IN OUT UINTN *BufferSize,
1572   IN VOID *Buffer
1573   )
1574 {
1575   CHAR8                  *AsciiBuffer;
1576   EFI_FILE_PROTOCOL_MEM  *MemFile;
1577
1578   MemFile = (EFI_FILE_PROTOCOL_MEM *) This;
1579   if (MemFile->Unicode) {
1580     //
1581     // Unicode
1582     //
1583     if ((UINTN)(MemFile->Position + (*BufferSize)) > (UINTN)(MemFile->BufferSize)) {
1584       MemFile->Buffer = ReallocatePool((UINTN)(MemFile->BufferSize), (UINTN)(MemFile->BufferSize) + (*BufferSize) + MEM_WRITE_REALLOC_OVERHEAD, MemFile->Buffer);
1585       MemFile->BufferSize += (*BufferSize) + MEM_WRITE_REALLOC_OVERHEAD;
1586     }
1587     CopyMem(((UINT8*)MemFile->Buffer) + MemFile->Position, Buffer, *BufferSize);
1588     MemFile->Position += (*BufferSize);
1589     MemFile->FileSize = MemFile->Position;
1590     return (EFI_SUCCESS);
1591   } else {
1592     //
1593     // Ascii
1594     //
1595     AsciiBuffer = AllocateZeroPool(*BufferSize);
1596     if (AsciiBuffer == NULL) {
1597       return (EFI_OUT_OF_RESOURCES);
1598     }
1599     AsciiSPrint(AsciiBuffer, *BufferSize, "%S", Buffer);
1600     if ((UINTN)(MemFile->Position + AsciiStrSize(AsciiBuffer)) > (UINTN)(MemFile->BufferSize)) {
1601       MemFile->Buffer = ReallocatePool((UINTN)(MemFile->BufferSize), (UINTN)(MemFile->BufferSize) + AsciiStrSize(AsciiBuffer) + MEM_WRITE_REALLOC_OVERHEAD, MemFile->Buffer);
1602       MemFile->BufferSize += AsciiStrSize(AsciiBuffer) + MEM_WRITE_REALLOC_OVERHEAD;
1603     }
1604     CopyMem(((UINT8*)MemFile->Buffer) + MemFile->Position, AsciiBuffer, AsciiStrSize(AsciiBuffer));
1605     MemFile->Position += (*BufferSize / sizeof(CHAR16));
1606     MemFile->FileSize = MemFile->Position;
1607     FreePool(AsciiBuffer);
1608     return (EFI_SUCCESS);
1609   }
1610 }
1611
1612 /**
1613   File style interface for Mem (Read).
1614
1615   @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.
1616   @param[in, out] BufferSize   Size in bytes of Buffer.
1617   @param[in] Buffer            The pointer to the buffer to fill.
1618
1619   @retval EFI_SUCCESS   The data was read.
1620 **/
1621 EFI_STATUS
1622 EFIAPI
1623 FileInterfaceMemRead(
1624   IN EFI_FILE_PROTOCOL *This,
1625   IN OUT UINTN *BufferSize,
1626   IN VOID *Buffer
1627   )
1628 {
1629   EFI_FILE_PROTOCOL_MEM  *MemFile;
1630
1631   MemFile = (EFI_FILE_PROTOCOL_MEM *) This;
1632   if (*BufferSize > (UINTN)((MemFile->FileSize) - (UINTN)(MemFile->Position))) {
1633     (*BufferSize) = (UINTN)((MemFile->FileSize) - (UINTN)(MemFile->Position));
1634   }
1635   CopyMem(Buffer, ((UINT8*)MemFile->Buffer) + MemFile->Position, (*BufferSize));
1636   MemFile->Position = MemFile->Position + (*BufferSize);
1637   return (EFI_SUCCESS);
1638 }
1639
1640 /**
1641   File style interface for Mem (Close).
1642
1643   Frees all memory associated with this object.
1644
1645   @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.
1646
1647   @retval EFI_SUCCESS   The 'file' was closed.
1648 **/
1649 EFI_STATUS
1650 EFIAPI
1651 FileInterfaceMemClose(
1652   IN EFI_FILE_PROTOCOL *This
1653   )
1654 {
1655   SHELL_FREE_NON_NULL(((EFI_FILE_PROTOCOL_MEM*)This)->Buffer);
1656   SHELL_FREE_NON_NULL(This);
1657   return (EFI_SUCCESS);
1658 }
1659
1660 /**
1661   Creates a EFI_FILE_PROTOCOL (almost) object for using to access
1662   a file entirely in memory through file operations.
1663
1664   @param[in] Unicode Boolean value with TRUE for Unicode and FALSE for Ascii.
1665
1666   @retval NULL      Memory could not be allocated.
1667   @return other     A pointer to an EFI_FILE_PROTOCOL structure.
1668 **/
1669 EFI_FILE_PROTOCOL*
1670 CreateFileInterfaceMem(
1671   IN CONST BOOLEAN Unicode
1672   )
1673 {
1674   EFI_FILE_PROTOCOL_MEM  *FileInterface;
1675
1676   //
1677   // Get some memory
1678   //
1679   FileInterface = AllocateZeroPool(sizeof(EFI_FILE_PROTOCOL_MEM));
1680   if (FileInterface == NULL){
1681     return (NULL);
1682   }
1683
1684   //
1685   // Assign the generic members
1686   //
1687   FileInterface->Revision    = EFI_FILE_REVISION;
1688   FileInterface->Open        = FileInterfaceOpenNotFound;
1689   FileInterface->Close       = FileInterfaceMemClose;
1690   FileInterface->GetPosition = FileInterfaceMemGetPosition;
1691   FileInterface->SetPosition = FileInterfaceMemSetPosition;
1692   FileInterface->GetInfo     = FileInterfaceNopGetInfo;
1693   FileInterface->SetInfo     = FileInterfaceNopSetInfo;
1694   FileInterface->Flush       = FileInterfaceNopGeneric;
1695   FileInterface->Delete      = FileInterfaceNopGeneric;
1696   FileInterface->Read        = FileInterfaceMemRead;
1697   FileInterface->Write       = FileInterfaceMemWrite;
1698   FileInterface->Unicode     = Unicode;
1699
1700   ASSERT(FileInterface->Buffer      == NULL);
1701   ASSERT(FileInterface->BufferSize  == 0);
1702   ASSERT(FileInterface->Position    == 0);
1703
1704   if (Unicode) {
1705     FileInterface->Buffer = AllocateZeroPool(sizeof(gUnicodeFileTag));
1706     if (FileInterface->Buffer == NULL) {
1707       FreePool (FileInterface);
1708       return NULL;
1709     }
1710     *((CHAR16 *) (FileInterface->Buffer)) = EFI_UNICODE_BYTE_ORDER_MARK;
1711     FileInterface->BufferSize = 2;
1712     FileInterface->Position = 2;
1713   }
1714
1715   return ((EFI_FILE_PROTOCOL *)FileInterface);
1716 }
1717
1718 typedef struct {
1719   UINT64                Revision;
1720   EFI_FILE_OPEN         Open;
1721   EFI_FILE_CLOSE        Close;
1722   EFI_FILE_DELETE       Delete;
1723   EFI_FILE_READ         Read;
1724   EFI_FILE_WRITE        Write;
1725   EFI_FILE_GET_POSITION GetPosition;
1726   EFI_FILE_SET_POSITION SetPosition;
1727   EFI_FILE_GET_INFO     GetInfo;
1728   EFI_FILE_SET_INFO     SetInfo;
1729   EFI_FILE_FLUSH        Flush;
1730   BOOLEAN               Unicode;
1731   EFI_FILE_PROTOCOL     *Orig;
1732 } EFI_FILE_PROTOCOL_FILE;
1733
1734 /**
1735   Set a files current position
1736
1737   @param  This            Protocol instance pointer.
1738   @param  Position        Byte position from the start of the file.
1739
1740   @retval EFI_SUCCESS     Data was written.
1741   @retval EFI_UNSUPPORTED Seek request for non-zero is not valid on open.
1742
1743 **/
1744 EFI_STATUS
1745 EFIAPI
1746 FileInterfaceFileSetPosition(
1747   IN EFI_FILE_PROTOCOL        *This,
1748   IN UINT64                   Position
1749   )
1750 {
1751   return ((EFI_FILE_PROTOCOL_FILE*)This)->Orig->SetPosition(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, Position);
1752 }
1753
1754 /**
1755   Get a file's current position
1756
1757   @param  This            Protocol instance pointer.
1758   @param  Position        Byte position from the start of the file.
1759
1760   @retval EFI_SUCCESS     Data was written.
1761   @retval EFI_UNSUPPORTED Seek request for non-zero is not valid on open..
1762
1763 **/
1764 EFI_STATUS
1765 EFIAPI
1766 FileInterfaceFileGetPosition(
1767   IN EFI_FILE_PROTOCOL        *This,
1768   OUT UINT64                  *Position
1769   )
1770 {
1771   return ((EFI_FILE_PROTOCOL_FILE*)This)->Orig->GetPosition(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, Position);
1772 }
1773
1774 /**
1775   Get information about a file.
1776
1777   @param  This            Protocol instance pointer.
1778   @param  InformationType Type of information to return in Buffer.
1779   @param  BufferSize      On input size of buffer, on output amount of data in buffer.
1780   @param  Buffer          The buffer to return data.
1781
1782   @retval EFI_SUCCESS          Data was returned.
1783   @retval EFI_UNSUPPORT        InformationType is not supported.
1784   @retval EFI_NO_MEDIA         The device has no media.
1785   @retval EFI_DEVICE_ERROR     The device reported an error.
1786   @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1787   @retval EFI_WRITE_PROTECTED  The device is write protected.
1788   @retval EFI_ACCESS_DENIED    The file was open for read only.
1789   @retval EFI_BUFFER_TOO_SMALL Buffer was too small; required size returned in BufferSize.
1790
1791 **/
1792 EFI_STATUS
1793 EFIAPI
1794 FileInterfaceFileGetInfo(
1795   IN EFI_FILE_PROTOCOL        *This,
1796   IN EFI_GUID                 *InformationType,
1797   IN OUT UINTN                *BufferSize,
1798   OUT VOID                    *Buffer
1799   )
1800 {
1801   return ((EFI_FILE_PROTOCOL_FILE*)This)->Orig->GetInfo(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, InformationType, BufferSize, Buffer);
1802 }
1803
1804 /**
1805   Set information about a file
1806
1807   @param  This            Protocol instance pointer.
1808   @param  InformationType Type of information in Buffer.
1809   @param  BufferSize      Size of buffer.
1810   @param  Buffer          The data to write.
1811
1812   @retval EFI_SUCCESS          Data was returned.
1813   @retval EFI_UNSUPPORT        InformationType is not supported.
1814   @retval EFI_NO_MEDIA         The device has no media.
1815   @retval EFI_DEVICE_ERROR     The device reported an error.
1816   @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1817   @retval EFI_WRITE_PROTECTED  The device is write protected.
1818   @retval EFI_ACCESS_DENIED    The file was open for read only.
1819
1820 **/
1821 EFI_STATUS
1822 EFIAPI
1823 FileInterfaceFileSetInfo(
1824   IN EFI_FILE_PROTOCOL        *This,
1825   IN EFI_GUID                 *InformationType,
1826   IN UINTN                    BufferSize,
1827   IN VOID                     *Buffer
1828   )
1829 {
1830   return ((EFI_FILE_PROTOCOL_FILE*)This)->Orig->SetInfo(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, InformationType, BufferSize, Buffer);
1831 }
1832
1833 /**
1834   Flush data back for the file handle.
1835
1836   @param  This Protocol instance pointer.
1837
1838   @retval EFI_SUCCESS          Data was written.
1839   @retval EFI_UNSUPPORT        Writes to Open directory are not supported.
1840   @retval EFI_NO_MEDIA         The device has no media.
1841   @retval EFI_DEVICE_ERROR     The device reported an error.
1842   @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1843   @retval EFI_WRITE_PROTECTED  The device is write protected.
1844   @retval EFI_ACCESS_DENIED    The file was open for read only.
1845   @retval EFI_VOLUME_FULL      The volume is full.
1846
1847 **/
1848 EFI_STATUS
1849 EFIAPI
1850 FileInterfaceFileFlush(
1851   IN EFI_FILE_PROTOCOL  *This
1852   )
1853 {
1854   return ((EFI_FILE_PROTOCOL_FILE*)This)->Orig->Flush(((EFI_FILE_PROTOCOL_FILE*)This)->Orig);
1855 }
1856
1857 /**
1858   Read data from the file.
1859
1860   @param  This       Protocol instance pointer.
1861   @param  BufferSize On input size of buffer, on output amount of data in buffer.
1862   @param  Buffer     The buffer in which data is read.
1863
1864   @retval EFI_SUCCESS          Data was read.
1865   @retval EFI_NO_MEDIA         The device has no media.
1866   @retval EFI_DEVICE_ERROR     The device reported an error.
1867   @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1868   @retval EFI_BUFFER_TO_SMALL  BufferSize is too small. BufferSize contains required size.
1869
1870 **/
1871 EFI_STATUS
1872 EFIAPI
1873 FileInterfaceFileRead(
1874   IN EFI_FILE_PROTOCOL        *This,
1875   IN OUT UINTN                *BufferSize,
1876   OUT VOID                    *Buffer
1877   )
1878 {
1879   CHAR8       *AsciiStrBuffer;
1880   CHAR16      *UscStrBuffer;
1881   UINTN       Size;
1882   UINTN       CharNum;
1883   EFI_STATUS  Status;
1884   if (((EFI_FILE_PROTOCOL_FILE*)This)->Unicode) {
1885     //
1886     // Unicode
1887     //
1888     return (((EFI_FILE_PROTOCOL_FILE*)This)->Orig->Read(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, BufferSize, Buffer));
1889   } else {
1890     //
1891     // Ascii
1892     //
1893     Size  = (*BufferSize) / sizeof(CHAR16);
1894     AsciiStrBuffer = AllocateZeroPool(Size + sizeof(CHAR8));
1895     if (AsciiStrBuffer == NULL) {
1896       return EFI_OUT_OF_RESOURCES;
1897     }
1898     UscStrBuffer = AllocateZeroPool(*BufferSize + sizeof(CHAR16));
1899     if (UscStrBuffer== NULL) {
1900       SHELL_FREE_NON_NULL(AsciiStrBuffer);
1901       return EFI_OUT_OF_RESOURCES;
1902     }
1903     Status = (((EFI_FILE_PROTOCOL_FILE*)This)->Orig->Read(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, &Size, AsciiStrBuffer));
1904     if (!EFI_ERROR(Status)) {
1905       CharNum = UnicodeSPrint(UscStrBuffer, *BufferSize + sizeof(CHAR16), L"%a", AsciiStrBuffer);
1906       if (CharNum == Size) {
1907         CopyMem (Buffer, UscStrBuffer, *BufferSize);
1908       } else {
1909         Status = EFI_UNSUPPORTED;
1910       }
1911     }
1912     SHELL_FREE_NON_NULL(AsciiStrBuffer);
1913     SHELL_FREE_NON_NULL(UscStrBuffer);
1914     return (Status);
1915   }
1916 }
1917
1918 /**
1919   Opens a new file relative to the source file's location.
1920
1921   @param[in]  This       The protocol instance pointer.
1922   @param[out]  NewHandle Returns File Handle for FileName.
1923   @param[in]  FileName   Null terminated string. "\", ".", and ".." are supported.
1924   @param[in]  OpenMode   Open mode for file.
1925   @param[in]  Attributes Only used for EFI_FILE_MODE_CREATE.
1926
1927   @retval EFI_SUCCESS          The device was opened.
1928   @retval EFI_NOT_FOUND        The specified file could not be found on the device.
1929   @retval EFI_NO_MEDIA         The device has no media.
1930   @retval EFI_MEDIA_CHANGED    The media has changed.
1931   @retval EFI_DEVICE_ERROR     The device reported an error.
1932   @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1933   @retval EFI_ACCESS_DENIED    The service denied access to the file.
1934   @retval EFI_OUT_OF_RESOURCES The volume was not opened due to lack of resources.
1935   @retval EFI_VOLUME_FULL      The volume is full.
1936 **/
1937 EFI_STATUS
1938 EFIAPI
1939 FileInterfaceFileOpen (
1940   IN EFI_FILE_PROTOCOL        *This,
1941   OUT EFI_FILE_PROTOCOL       **NewHandle,
1942   IN CHAR16                   *FileName,
1943   IN UINT64                   OpenMode,
1944   IN UINT64                   Attributes
1945   )
1946 {
1947   return ((EFI_FILE_PROTOCOL_FILE*)This)->Orig->Open(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, NewHandle, FileName, OpenMode, Attributes);
1948 }
1949
1950 /**
1951   Close and delete the file handle.
1952
1953   @param  This                     Protocol instance pointer.
1954
1955   @retval EFI_SUCCESS              The device was opened.
1956   @retval EFI_WARN_DELETE_FAILURE  The handle was closed but the file was not deleted.
1957
1958 **/
1959 EFI_STATUS
1960 EFIAPI
1961 FileInterfaceFileDelete(
1962   IN EFI_FILE_PROTOCOL  *This
1963   )
1964 {
1965   EFI_STATUS Status;
1966   Status = ((EFI_FILE_PROTOCOL_FILE*)This)->Orig->Delete(((EFI_FILE_PROTOCOL_FILE*)This)->Orig);
1967   FreePool(This);
1968   return (Status);
1969 }
1970
1971 /**
1972   File style interface for File (Close).
1973
1974   @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.
1975
1976   @retval EFI_SUCCESS   The file was closed.
1977 **/
1978 EFI_STATUS
1979 EFIAPI
1980 FileInterfaceFileClose(
1981   IN EFI_FILE_PROTOCOL *This
1982   )
1983 {
1984   EFI_STATUS Status;
1985   Status = ((EFI_FILE_PROTOCOL_FILE*)This)->Orig->Close(((EFI_FILE_PROTOCOL_FILE*)This)->Orig);
1986   FreePool(This);
1987   return (Status);
1988 }
1989
1990 /**
1991   File style interface for File (Write).
1992
1993   If the file was opened with ASCII mode the data will be processed through
1994   AsciiSPrint before writing.
1995
1996   @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.
1997   @param[in, out] BufferSize   Size in bytes of Buffer.
1998   @param[in] Buffer            The pointer to the buffer to write.
1999
2000   @retval EFI_SUCCESS   The data was written.
2001 **/
2002 EFI_STATUS
2003 EFIAPI
2004 FileInterfaceFileWrite(
2005   IN     EFI_FILE_PROTOCOL  *This,
2006   IN OUT UINTN              *BufferSize,
2007   IN     VOID               *Buffer
2008   )
2009 {
2010   CHAR8       *AsciiBuffer;
2011   UINTN       Size;
2012   EFI_STATUS  Status;
2013   if (((EFI_FILE_PROTOCOL_FILE*)This)->Unicode) {
2014     //
2015     // Unicode
2016     //
2017     return (((EFI_FILE_PROTOCOL_FILE*)This)->Orig->Write(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, BufferSize, Buffer));
2018   } else {
2019     //
2020     // Ascii
2021     //
2022     AsciiBuffer = AllocateZeroPool(*BufferSize);
2023     AsciiSPrint(AsciiBuffer, *BufferSize, "%S", Buffer);
2024     Size = AsciiStrSize(AsciiBuffer) - 1; // (we dont need the null terminator)
2025     Status = (((EFI_FILE_PROTOCOL_FILE*)This)->Orig->Write(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, &Size, AsciiBuffer));
2026     FreePool(AsciiBuffer);
2027     return (Status);
2028   }
2029 }
2030
2031 /**
2032   Create a file interface with unicode information.
2033
2034   This will create a new EFI_FILE_PROTOCOL identical to the Templace
2035   except that the new one has Unicode and Ascii knowledge.
2036
2037   @param[in] Template   A pointer to the EFI_FILE_PROTOCOL object.
2038   @param[in] Unicode    TRUE for UCS-2, FALSE for ASCII.
2039
2040   @return a new EFI_FILE_PROTOCOL object to be used instead of the template.
2041 **/
2042 EFI_FILE_PROTOCOL*
2043 CreateFileInterfaceFile(
2044   IN CONST EFI_FILE_PROTOCOL  *Template,
2045   IN CONST BOOLEAN            Unicode
2046   )
2047 {
2048   EFI_FILE_PROTOCOL_FILE *NewOne;
2049
2050   NewOne = AllocateZeroPool(sizeof(EFI_FILE_PROTOCOL_FILE));
2051   if (NewOne == NULL) {
2052     return (NULL);
2053   }
2054   CopyMem(NewOne, Template, sizeof(EFI_FILE_PROTOCOL_FILE));
2055   NewOne->Orig        = (EFI_FILE_PROTOCOL *)Template;
2056   NewOne->Unicode     = Unicode;
2057   NewOne->Open        = FileInterfaceFileOpen;
2058   NewOne->Close       = FileInterfaceFileClose;
2059   NewOne->Delete      = FileInterfaceFileDelete;
2060   NewOne->Read        = FileInterfaceFileRead;
2061   NewOne->Write       = FileInterfaceFileWrite;
2062   NewOne->GetPosition = FileInterfaceFileGetPosition;
2063   NewOne->SetPosition = FileInterfaceFileSetPosition;
2064   NewOne->GetInfo     = FileInterfaceFileGetInfo;
2065   NewOne->SetInfo     = FileInterfaceFileSetInfo;
2066   NewOne->Flush       = FileInterfaceFileFlush;
2067
2068   return ((EFI_FILE_PROTOCOL *)NewOne);
2069 }