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 - 2016, 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
1044   //
1045   // Most if not all UEFI commands will have an '\r\n' at the end of any output.
1046   // Since the output was redirected to a variable, it does not make sense to
1047   // keep this.  So, before closing, strip the trailing '\r\n' from the variable
1048   // if it exists.
1049   //
1050   NewBuffer   = NULL;
1051   NewSize     = 0;
1052
1053   Status = IsVolatileEnv (((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, &Volatile);
1054   if (EFI_ERROR (Status)) {
1055     return Status;
1056   }
1057
1058   Status = SHELL_GET_ENVIRONMENT_VARIABLE(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, &NewSize, NewBuffer);
1059   if (Status == EFI_BUFFER_TOO_SMALL) {
1060     NewBuffer = AllocateZeroPool(NewSize + sizeof(CHAR16));
1061     if (NewBuffer == NULL) {
1062       return EFI_OUT_OF_RESOURCES;
1063     }
1064     Status = SHELL_GET_ENVIRONMENT_VARIABLE(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, &NewSize, NewBuffer);
1065   }
1066
1067   if (!EFI_ERROR(Status) && NewBuffer != NULL) {
1068
1069     if (StrSize(NewBuffer) > 6)
1070     {
1071       if ((((CHAR16*)NewBuffer)[(StrSize(NewBuffer)/2) - 2] == CHAR_LINEFEED)
1072            && (((CHAR16*)NewBuffer)[(StrSize(NewBuffer)/2) - 3] == CHAR_CARRIAGE_RETURN)) {
1073         ((CHAR16*)NewBuffer)[(StrSize(NewBuffer)/2) - 3] = CHAR_NULL;
1074       }
1075
1076       if (Volatile) {
1077         Status = SHELL_SET_ENVIRONMENT_VARIABLE_V(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, StrSize(NewBuffer), NewBuffer);
1078       } else {
1079         Status = SHELL_SET_ENVIRONMENT_VARIABLE_NV(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, StrSize(NewBuffer), NewBuffer);
1080       }
1081     }
1082   }
1083
1084   SHELL_FREE_NON_NULL(NewBuffer);
1085   FreePool((EFI_FILE_PROTOCOL_ENVIRONMENT*)This);
1086   return (Status);
1087 }
1088
1089 /**
1090   File style interface for Environment Variable (Delete).
1091
1092   @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.
1093
1094   @retval The return value from FileInterfaceEnvClose().
1095 **/
1096 EFI_STATUS
1097 EFIAPI
1098 FileInterfaceEnvDelete(
1099   IN EFI_FILE_PROTOCOL *This
1100   )
1101 {
1102   SHELL_DELETE_ENVIRONMENT_VARIABLE(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name);
1103   return (FileInterfaceEnvClose(This));
1104 }
1105
1106 /**
1107   File style interface for Environment Variable (Read).
1108
1109   @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.
1110   @param[in, out] BufferSize   Size in bytes of Buffer.
1111   @param[out] Buffer           The pointer to the buffer to fill.
1112
1113   @retval EFI_SUCCESS   The data was read.
1114 **/
1115 EFI_STATUS
1116 EFIAPI
1117 FileInterfaceEnvRead(
1118   IN EFI_FILE_PROTOCOL *This,
1119   IN OUT UINTN *BufferSize,
1120   OUT VOID *Buffer
1121   )
1122 {
1123   return (SHELL_GET_ENVIRONMENT_VARIABLE(
1124     ((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name,
1125     BufferSize,
1126     Buffer));
1127 }
1128
1129 /**
1130   File style interface for Volatile Environment Variable (Write).
1131
1132   @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.
1133   @param[in, out] BufferSize   Size in bytes of Buffer.
1134   @param[in] Buffer            The pointer to the buffer to write.
1135
1136   @retval EFI_SUCCESS   The data was read.
1137 **/
1138 EFI_STATUS
1139 EFIAPI
1140 FileInterfaceEnvVolWrite(
1141   IN EFI_FILE_PROTOCOL *This,
1142   IN OUT UINTN *BufferSize,
1143   IN VOID *Buffer
1144   )
1145 {
1146   VOID*       NewBuffer;
1147   UINTN       NewSize;
1148   EFI_STATUS  Status;
1149
1150   NewBuffer   = NULL;
1151   NewSize     = 0;
1152
1153   Status = SHELL_GET_ENVIRONMENT_VARIABLE(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, &NewSize, NewBuffer);
1154   if (Status == EFI_BUFFER_TOO_SMALL){
1155     NewBuffer = AllocateZeroPool(NewSize + *BufferSize + sizeof(CHAR16));
1156     Status = SHELL_GET_ENVIRONMENT_VARIABLE(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, &NewSize, NewBuffer);
1157   }
1158   if (!EFI_ERROR(Status) && NewBuffer != NULL) {
1159     while (((CHAR16*)NewBuffer)[NewSize/2] == CHAR_NULL) {
1160       //
1161       // We want to overwrite the CHAR_NULL
1162       //
1163       NewSize -= 2;
1164     }
1165     CopyMem((UINT8*)NewBuffer + NewSize + 2, Buffer, *BufferSize);
1166     Status = SHELL_SET_ENVIRONMENT_VARIABLE_V(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, StrSize(NewBuffer), NewBuffer);
1167     FreePool(NewBuffer);
1168     return (Status);
1169   } else {
1170     SHELL_FREE_NON_NULL(NewBuffer);
1171     return (SHELL_SET_ENVIRONMENT_VARIABLE_V(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, *BufferSize, Buffer));
1172   }
1173 }
1174
1175
1176 /**
1177   File style interface for Non Volatile Environment Variable (Write).
1178
1179   @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.
1180   @param[in, out] BufferSize   Size in bytes of Buffer.
1181   @param[in] Buffer            The pointer to the buffer to write.
1182
1183   @retval EFI_SUCCESS   The data was read.
1184 **/
1185 EFI_STATUS
1186 EFIAPI
1187 FileInterfaceEnvNonVolWrite(
1188   IN EFI_FILE_PROTOCOL *This,
1189   IN OUT UINTN *BufferSize,
1190   IN VOID *Buffer
1191   )
1192 {
1193   VOID*       NewBuffer;
1194   UINTN       NewSize;
1195   EFI_STATUS  Status;
1196
1197   NewBuffer   = NULL;
1198   NewSize     = 0;
1199
1200   Status = SHELL_GET_ENVIRONMENT_VARIABLE(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, &NewSize, NewBuffer);
1201   if (Status == EFI_BUFFER_TOO_SMALL){
1202     NewBuffer = AllocateZeroPool(NewSize + *BufferSize);
1203     Status = SHELL_GET_ENVIRONMENT_VARIABLE(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, &NewSize, NewBuffer);
1204   }
1205   if (!EFI_ERROR(Status)) {
1206     CopyMem((UINT8*)NewBuffer + NewSize, Buffer, *BufferSize);
1207     return (SHELL_SET_ENVIRONMENT_VARIABLE_NV(
1208     ((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name,
1209     NewSize + *BufferSize,
1210     NewBuffer));
1211   } else {
1212     return (SHELL_SET_ENVIRONMENT_VARIABLE_NV(
1213     ((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name,
1214     *BufferSize,
1215     Buffer));
1216   }
1217 }
1218
1219 /**
1220   Creates a EFI_FILE_PROTOCOL (almost) object for using to access
1221   environment variables through file operations.
1222
1223   @param EnvName    The name of the Environment Variable to be operated on.
1224
1225   @retval NULL      Memory could not be allocated.
1226   @return other     a pointer to an EFI_FILE_PROTOCOL structure
1227 **/
1228 EFI_FILE_PROTOCOL*
1229 CreateFileInterfaceEnv(
1230   IN CONST CHAR16 *EnvName
1231   )
1232 {
1233   EFI_STATUS                     Status;
1234   EFI_FILE_PROTOCOL_ENVIRONMENT  *EnvFileInterface;
1235   UINTN                          EnvNameSize;
1236   BOOLEAN                        Volatile;
1237
1238   if (EnvName == NULL) {
1239     return (NULL);
1240   }
1241
1242   Status = IsVolatileEnv (EnvName, &Volatile);
1243   if (EFI_ERROR (Status)) {
1244     return NULL;
1245   }
1246
1247   //
1248   // Get some memory
1249   //
1250   EnvNameSize = StrSize(EnvName);
1251   EnvFileInterface = AllocateZeroPool(sizeof(EFI_FILE_PROTOCOL_ENVIRONMENT)+EnvNameSize);
1252   if (EnvFileInterface == NULL){
1253     return (NULL);
1254   }
1255
1256   //
1257   // Assign the generic members
1258   //
1259   EnvFileInterface->Revision    = EFI_FILE_REVISION;
1260   EnvFileInterface->Open        = FileInterfaceOpenNotFound;
1261   EnvFileInterface->Close       = FileInterfaceEnvClose;
1262   EnvFileInterface->GetPosition = FileInterfaceNopGetPosition;
1263   EnvFileInterface->SetPosition = FileInterfaceNopSetPosition;
1264   EnvFileInterface->GetInfo     = FileInterfaceNopGetInfo;
1265   EnvFileInterface->SetInfo     = FileInterfaceNopSetInfo;
1266   EnvFileInterface->Flush       = FileInterfaceNopGeneric;
1267   EnvFileInterface->Delete      = FileInterfaceEnvDelete;
1268   EnvFileInterface->Read        = FileInterfaceEnvRead;
1269
1270   CopyMem(EnvFileInterface->Name, EnvName, EnvNameSize);
1271
1272   //
1273   // Assign the different members for Volatile and Non-Volatile variables
1274   //
1275   if (Volatile) {
1276     EnvFileInterface->Write       = FileInterfaceEnvVolWrite;
1277   } else {
1278     EnvFileInterface->Write       = FileInterfaceEnvNonVolWrite;
1279   }
1280   return ((EFI_FILE_PROTOCOL *)EnvFileInterface);
1281 }
1282
1283 /**
1284   Move the cursor position one character backward.
1285
1286   @param[in] LineLength       Length of a line. Get it by calling QueryMode
1287   @param[in, out] Column      Current column of the cursor position
1288   @param[in, out] Row         Current row of the cursor position
1289 **/
1290 VOID
1291 MoveCursorBackward (
1292   IN     UINTN                   LineLength,
1293   IN OUT UINTN                   *Column,
1294   IN OUT UINTN                   *Row
1295   )
1296 {
1297   //
1298   // If current column is 0, move to the last column of the previous line,
1299   // otherwise, just decrement column.
1300   //
1301   if (*Column == 0) {
1302     *Column = LineLength - 1;
1303     if (*Row > 0) {
1304       (*Row)--;
1305     }
1306     return;
1307   }
1308   (*Column)--;
1309 }
1310
1311 /**
1312   Move the cursor position one character forward.
1313
1314   @param[in] LineLength       Length of a line.
1315   @param[in] TotalRow         Total row of a screen
1316   @param[in, out] Column      Current column of the cursor position
1317   @param[in, out] Row         Current row of the cursor position
1318 **/
1319 VOID
1320 MoveCursorForward (
1321   IN     UINTN                   LineLength,
1322   IN     UINTN                   TotalRow,
1323   IN OUT UINTN                   *Column,
1324   IN OUT UINTN                   *Row
1325   )
1326 {
1327   //
1328   // Increment Column.
1329   // If this puts column past the end of the line, move to first column
1330   // of the next row.
1331   //
1332   (*Column)++;
1333   if (*Column >= LineLength) {
1334     (*Column) = 0;
1335     if ((*Row) < TotalRow - 1) {
1336       (*Row)++;
1337     }
1338   }
1339 }
1340
1341 /**
1342   Prints out each previously typed command in the command list history log.
1343
1344   When each screen is full it will pause for a key before continuing.
1345
1346   @param[in] TotalCols    How many columns are on the screen
1347   @param[in] TotalRows    How many rows are on the screen
1348   @param[in] StartColumn  which column to start at
1349 **/
1350 VOID
1351 PrintCommandHistory (
1352   IN CONST UINTN TotalCols,
1353   IN CONST UINTN TotalRows,
1354   IN CONST UINTN StartColumn
1355   )
1356 {
1357   BUFFER_LIST     *Node;
1358   UINTN           Index;
1359   UINTN           LineNumber;
1360   UINTN           LineCount;
1361
1362   ShellPrintEx (-1, -1, L"\n");
1363   Index       = 0;
1364   LineNumber  = 0;
1365   //
1366   // go through history list...
1367   //
1368   for ( Node = (BUFFER_LIST*)GetFirstNode(&ShellInfoObject.ViewingSettings.CommandHistory.Link)
1369       ; !IsNull(&ShellInfoObject.ViewingSettings.CommandHistory.Link, &Node->Link)
1370       ; Node = (BUFFER_LIST*)GetNextNode(&ShellInfoObject.ViewingSettings.CommandHistory.Link, &Node->Link)
1371    ){
1372     Index++;
1373     LineCount = ((StrLen (Node->Buffer) + StartColumn + 1) / TotalCols) + 1;
1374
1375     if (LineNumber + LineCount >= TotalRows) {
1376       ShellPromptForResponseHii(
1377         ShellPromptResponseTypeEnterContinue,
1378         STRING_TOKEN (STR_SHELL_ENTER_TO_CONT),
1379         ShellInfoObject.HiiHandle,
1380         NULL
1381        );
1382       LineNumber = 0;
1383     }
1384     ShellPrintEx (-1, -1, L"%2d. %s\n", Index, Node->Buffer);
1385     LineNumber += LineCount;
1386   }
1387 }
1388
1389
1390
1391
1392
1393
1394 //
1395 // This is identical to EFI_FILE_PROTOCOL except for the additional members
1396 // for the buffer, size, and position.
1397 //
1398
1399 typedef struct {
1400   UINT64                Revision;
1401   EFI_FILE_OPEN         Open;
1402   EFI_FILE_CLOSE        Close;
1403   EFI_FILE_DELETE       Delete;
1404   EFI_FILE_READ         Read;
1405   EFI_FILE_WRITE        Write;
1406   EFI_FILE_GET_POSITION GetPosition;
1407   EFI_FILE_SET_POSITION SetPosition;
1408   EFI_FILE_GET_INFO     GetInfo;
1409   EFI_FILE_SET_INFO     SetInfo;
1410   EFI_FILE_FLUSH        Flush;
1411   VOID                  *Buffer;
1412   UINT64                Position;
1413   UINT64                BufferSize;
1414   BOOLEAN               Unicode;
1415   UINT64                FileSize;
1416 } EFI_FILE_PROTOCOL_MEM;
1417
1418 /**
1419   File style interface for Mem (SetPosition).
1420
1421   @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.
1422   @param[out] Position  The position to set.
1423
1424   @retval EFI_SUCCESS             The position was successfully changed.
1425   @retval EFI_INVALID_PARAMETER   The Position was invalid.
1426 **/
1427 EFI_STATUS
1428 EFIAPI
1429 FileInterfaceMemSetPosition(
1430   IN EFI_FILE_PROTOCOL *This,
1431   OUT UINT64 Position
1432   )
1433 {
1434   if (Position <= ((EFI_FILE_PROTOCOL_MEM*)This)->FileSize) {
1435     ((EFI_FILE_PROTOCOL_MEM*)This)->Position = Position;
1436     return (EFI_SUCCESS);
1437   } else {
1438     return (EFI_INVALID_PARAMETER);
1439   }
1440 }
1441
1442 /**
1443   File style interface for Mem (GetPosition).
1444
1445   @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.
1446   @param[out] Position  The pointer to the position.
1447
1448   @retval EFI_SUCCESS   The position was retrieved.
1449 **/
1450 EFI_STATUS
1451 EFIAPI
1452 FileInterfaceMemGetPosition(
1453   IN EFI_FILE_PROTOCOL *This,
1454   OUT UINT64 *Position
1455   )
1456 {
1457   *Position = ((EFI_FILE_PROTOCOL_MEM*)This)->Position;
1458   return (EFI_SUCCESS);
1459 }
1460
1461 /**
1462   File style interface for Mem (Write).
1463
1464   @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.
1465   @param[in, out] BufferSize   Size in bytes of Buffer.
1466   @param[in] Buffer            The pointer to the buffer to write.
1467
1468   @retval EFI_OUT_OF_RESOURCES The operation failed due to lack of resources.
1469   @retval EFI_SUCCESS          The data was written.
1470 **/
1471 EFI_STATUS
1472 EFIAPI
1473 FileInterfaceMemWrite(
1474   IN EFI_FILE_PROTOCOL *This,
1475   IN OUT UINTN *BufferSize,
1476   IN VOID *Buffer
1477   )
1478 {
1479   CHAR8                  *AsciiBuffer;
1480   EFI_FILE_PROTOCOL_MEM  *MemFile;
1481
1482   MemFile = (EFI_FILE_PROTOCOL_MEM *) This;
1483   if (MemFile->Unicode) {
1484     //
1485     // Unicode
1486     //
1487     if ((UINTN)(MemFile->Position + (*BufferSize)) > (UINTN)(MemFile->BufferSize)) {
1488       MemFile->Buffer = ReallocatePool((UINTN)(MemFile->BufferSize), (UINTN)(MemFile->BufferSize) + (*BufferSize) + MEM_WRITE_REALLOC_OVERHEAD, MemFile->Buffer);
1489       MemFile->BufferSize += (*BufferSize) + MEM_WRITE_REALLOC_OVERHEAD;
1490     }
1491     CopyMem(((UINT8*)MemFile->Buffer) + MemFile->Position, Buffer, *BufferSize);
1492     MemFile->Position += (*BufferSize);
1493     MemFile->FileSize = MemFile->Position;
1494     return (EFI_SUCCESS);
1495   } else {
1496     //
1497     // Ascii
1498     //
1499     AsciiBuffer = AllocateZeroPool(*BufferSize);
1500     if (AsciiBuffer == NULL) {
1501       return (EFI_OUT_OF_RESOURCES);
1502     }
1503     AsciiSPrint(AsciiBuffer, *BufferSize, "%S", Buffer);
1504     if ((UINTN)(MemFile->Position + AsciiStrSize(AsciiBuffer)) > (UINTN)(MemFile->BufferSize)) {
1505       MemFile->Buffer = ReallocatePool((UINTN)(MemFile->BufferSize), (UINTN)(MemFile->BufferSize) + AsciiStrSize(AsciiBuffer) + MEM_WRITE_REALLOC_OVERHEAD, MemFile->Buffer);
1506       MemFile->BufferSize += AsciiStrSize(AsciiBuffer) + MEM_WRITE_REALLOC_OVERHEAD;
1507     }
1508     CopyMem(((UINT8*)MemFile->Buffer) + MemFile->Position, AsciiBuffer, AsciiStrSize(AsciiBuffer));
1509     MemFile->Position += (*BufferSize / sizeof(CHAR16));
1510     MemFile->FileSize = MemFile->Position;
1511     FreePool(AsciiBuffer);
1512     return (EFI_SUCCESS);
1513   }
1514 }
1515
1516 /**
1517   File style interface for Mem (Read).
1518
1519   @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.
1520   @param[in, out] BufferSize   Size in bytes of Buffer.
1521   @param[in] Buffer            The pointer to the buffer to fill.
1522
1523   @retval EFI_SUCCESS   The data was read.
1524 **/
1525 EFI_STATUS
1526 EFIAPI
1527 FileInterfaceMemRead(
1528   IN EFI_FILE_PROTOCOL *This,
1529   IN OUT UINTN *BufferSize,
1530   IN VOID *Buffer
1531   )
1532 {
1533   EFI_FILE_PROTOCOL_MEM  *MemFile;
1534
1535   MemFile = (EFI_FILE_PROTOCOL_MEM *) This;
1536   if (*BufferSize > (UINTN)((MemFile->FileSize) - (UINTN)(MemFile->Position))) {
1537     (*BufferSize) = (UINTN)((MemFile->FileSize) - (UINTN)(MemFile->Position));
1538   }
1539   CopyMem(Buffer, ((UINT8*)MemFile->Buffer) + MemFile->Position, (*BufferSize));
1540   MemFile->Position = MemFile->Position + (*BufferSize);
1541   return (EFI_SUCCESS);
1542 }
1543
1544 /**
1545   File style interface for Mem (Close).
1546
1547   Frees all memory associated with this object.
1548
1549   @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.
1550
1551   @retval EFI_SUCCESS   The 'file' was closed.
1552 **/
1553 EFI_STATUS
1554 EFIAPI
1555 FileInterfaceMemClose(
1556   IN EFI_FILE_PROTOCOL *This
1557   )
1558 {
1559   SHELL_FREE_NON_NULL(((EFI_FILE_PROTOCOL_MEM*)This)->Buffer);
1560   SHELL_FREE_NON_NULL(This);
1561   return (EFI_SUCCESS);
1562 }
1563
1564 /**
1565   Creates a EFI_FILE_PROTOCOL (almost) object for using to access
1566   a file entirely in memory through file operations.
1567
1568   @param[in] Unicode Boolean value with TRUE for Unicode and FALSE for Ascii.
1569
1570   @retval NULL      Memory could not be allocated.
1571   @return other     A pointer to an EFI_FILE_PROTOCOL structure.
1572 **/
1573 EFI_FILE_PROTOCOL*
1574 CreateFileInterfaceMem(
1575   IN CONST BOOLEAN Unicode
1576   )
1577 {
1578   EFI_FILE_PROTOCOL_MEM  *FileInterface;
1579
1580   //
1581   // Get some memory
1582   //
1583   FileInterface = AllocateZeroPool(sizeof(EFI_FILE_PROTOCOL_MEM));
1584   if (FileInterface == NULL){
1585     return (NULL);
1586   }
1587
1588   //
1589   // Assign the generic members
1590   //
1591   FileInterface->Revision    = EFI_FILE_REVISION;
1592   FileInterface->Open        = FileInterfaceOpenNotFound;
1593   FileInterface->Close       = FileInterfaceMemClose;
1594   FileInterface->GetPosition = FileInterfaceMemGetPosition;
1595   FileInterface->SetPosition = FileInterfaceMemSetPosition;
1596   FileInterface->GetInfo     = FileInterfaceNopGetInfo;
1597   FileInterface->SetInfo     = FileInterfaceNopSetInfo;
1598   FileInterface->Flush       = FileInterfaceNopGeneric;
1599   FileInterface->Delete      = FileInterfaceNopGeneric;
1600   FileInterface->Read        = FileInterfaceMemRead;
1601   FileInterface->Write       = FileInterfaceMemWrite;
1602   FileInterface->Unicode     = Unicode;
1603
1604   ASSERT(FileInterface->Buffer      == NULL);
1605   ASSERT(FileInterface->BufferSize  == 0);
1606   ASSERT(FileInterface->Position    == 0);
1607
1608   if (Unicode) {
1609     FileInterface->Buffer = AllocateZeroPool(sizeof(gUnicodeFileTag));
1610     if (FileInterface->Buffer == NULL) {
1611       FreePool (FileInterface);
1612       return NULL;
1613     }
1614     *((CHAR16 *) (FileInterface->Buffer)) = EFI_UNICODE_BYTE_ORDER_MARK;
1615     FileInterface->BufferSize = 2;
1616     FileInterface->Position = 2;
1617   }
1618
1619   return ((EFI_FILE_PROTOCOL *)FileInterface);
1620 }
1621
1622 typedef struct {
1623   UINT64                Revision;
1624   EFI_FILE_OPEN         Open;
1625   EFI_FILE_CLOSE        Close;
1626   EFI_FILE_DELETE       Delete;
1627   EFI_FILE_READ         Read;
1628   EFI_FILE_WRITE        Write;
1629   EFI_FILE_GET_POSITION GetPosition;
1630   EFI_FILE_SET_POSITION SetPosition;
1631   EFI_FILE_GET_INFO     GetInfo;
1632   EFI_FILE_SET_INFO     SetInfo;
1633   EFI_FILE_FLUSH        Flush;
1634   BOOLEAN               Unicode;
1635   EFI_FILE_PROTOCOL     *Orig;
1636 } EFI_FILE_PROTOCOL_FILE;
1637
1638 /**
1639   Set a files current position
1640
1641   @param  This            Protocol instance pointer.
1642   @param  Position        Byte position from the start of the file.
1643
1644   @retval EFI_SUCCESS     Data was written.
1645   @retval EFI_UNSUPPORTED Seek request for non-zero is not valid on open.
1646
1647 **/
1648 EFI_STATUS
1649 EFIAPI
1650 FileInterfaceFileSetPosition(
1651   IN EFI_FILE_PROTOCOL        *This,
1652   IN UINT64                   Position
1653   )
1654 {
1655   return ((EFI_FILE_PROTOCOL_FILE*)This)->Orig->SetPosition(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, Position);
1656 }
1657
1658 /**
1659   Get a file's current position
1660
1661   @param  This            Protocol instance pointer.
1662   @param  Position        Byte position from the start of the file.
1663
1664   @retval EFI_SUCCESS     Data was written.
1665   @retval EFI_UNSUPPORTED Seek request for non-zero is not valid on open..
1666
1667 **/
1668 EFI_STATUS
1669 EFIAPI
1670 FileInterfaceFileGetPosition(
1671   IN EFI_FILE_PROTOCOL        *This,
1672   OUT UINT64                  *Position
1673   )
1674 {
1675   return ((EFI_FILE_PROTOCOL_FILE*)This)->Orig->GetPosition(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, Position);
1676 }
1677
1678 /**
1679   Get information about a file.
1680
1681   @param  This            Protocol instance pointer.
1682   @param  InformationType Type of information to return in Buffer.
1683   @param  BufferSize      On input size of buffer, on output amount of data in buffer.
1684   @param  Buffer          The buffer to return data.
1685
1686   @retval EFI_SUCCESS          Data was returned.
1687   @retval EFI_UNSUPPORT        InformationType is not supported.
1688   @retval EFI_NO_MEDIA         The device has no media.
1689   @retval EFI_DEVICE_ERROR     The device reported an error.
1690   @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1691   @retval EFI_WRITE_PROTECTED  The device is write protected.
1692   @retval EFI_ACCESS_DENIED    The file was open for read only.
1693   @retval EFI_BUFFER_TOO_SMALL Buffer was too small; required size returned in BufferSize.
1694
1695 **/
1696 EFI_STATUS
1697 EFIAPI
1698 FileInterfaceFileGetInfo(
1699   IN EFI_FILE_PROTOCOL        *This,
1700   IN EFI_GUID                 *InformationType,
1701   IN OUT UINTN                *BufferSize,
1702   OUT VOID                    *Buffer
1703   )
1704 {
1705   return ((EFI_FILE_PROTOCOL_FILE*)This)->Orig->GetInfo(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, InformationType, BufferSize, Buffer);
1706 }
1707
1708 /**
1709   Set information about a file
1710
1711   @param  This            Protocol instance pointer.
1712   @param  InformationType Type of information in Buffer.
1713   @param  BufferSize      Size of buffer.
1714   @param  Buffer          The data to write.
1715
1716   @retval EFI_SUCCESS          Data was returned.
1717   @retval EFI_UNSUPPORT        InformationType is not supported.
1718   @retval EFI_NO_MEDIA         The device has no media.
1719   @retval EFI_DEVICE_ERROR     The device reported an error.
1720   @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1721   @retval EFI_WRITE_PROTECTED  The device is write protected.
1722   @retval EFI_ACCESS_DENIED    The file was open for read only.
1723
1724 **/
1725 EFI_STATUS
1726 EFIAPI
1727 FileInterfaceFileSetInfo(
1728   IN EFI_FILE_PROTOCOL        *This,
1729   IN EFI_GUID                 *InformationType,
1730   IN UINTN                    BufferSize,
1731   IN VOID                     *Buffer
1732   )
1733 {
1734   return ((EFI_FILE_PROTOCOL_FILE*)This)->Orig->SetInfo(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, InformationType, BufferSize, Buffer);
1735 }
1736
1737 /**
1738   Flush data back for the file handle.
1739
1740   @param  This Protocol instance pointer.
1741
1742   @retval EFI_SUCCESS          Data was written.
1743   @retval EFI_UNSUPPORT        Writes to Open directory are not supported.
1744   @retval EFI_NO_MEDIA         The device has no media.
1745   @retval EFI_DEVICE_ERROR     The device reported an error.
1746   @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1747   @retval EFI_WRITE_PROTECTED  The device is write protected.
1748   @retval EFI_ACCESS_DENIED    The file was open for read only.
1749   @retval EFI_VOLUME_FULL      The volume is full.
1750
1751 **/
1752 EFI_STATUS
1753 EFIAPI
1754 FileInterfaceFileFlush(
1755   IN EFI_FILE_PROTOCOL  *This
1756   )
1757 {
1758   return ((EFI_FILE_PROTOCOL_FILE*)This)->Orig->Flush(((EFI_FILE_PROTOCOL_FILE*)This)->Orig);
1759 }
1760
1761 /**
1762   Read data from the file.
1763
1764   @param  This       Protocol instance pointer.
1765   @param  BufferSize On input size of buffer, on output amount of data in buffer.
1766   @param  Buffer     The buffer in which data is read.
1767
1768   @retval EFI_SUCCESS          Data was read.
1769   @retval EFI_NO_MEDIA         The device has no media.
1770   @retval EFI_DEVICE_ERROR     The device reported an error.
1771   @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1772   @retval EFI_BUFFER_TO_SMALL  BufferSize is too small. BufferSize contains required size.
1773
1774 **/
1775 EFI_STATUS
1776 EFIAPI
1777 FileInterfaceFileRead(
1778   IN EFI_FILE_PROTOCOL        *This,
1779   IN OUT UINTN                *BufferSize,
1780   OUT VOID                    *Buffer
1781   )
1782 {
1783   CHAR8       *AsciiStrBuffer;
1784   CHAR16      *UscStrBuffer;
1785   UINTN       Size;
1786   UINTN       CharNum;
1787   EFI_STATUS  Status;
1788   if (((EFI_FILE_PROTOCOL_FILE*)This)->Unicode) {
1789     //
1790     // Unicode
1791     //
1792     return (((EFI_FILE_PROTOCOL_FILE*)This)->Orig->Read(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, BufferSize, Buffer));
1793   } else {
1794     //
1795     // Ascii
1796     //
1797     Size  = (*BufferSize) / sizeof(CHAR16);
1798     AsciiStrBuffer = AllocateZeroPool(Size + sizeof(CHAR8));
1799     if (AsciiStrBuffer == NULL) {
1800       return EFI_OUT_OF_RESOURCES;
1801     }
1802     UscStrBuffer = AllocateZeroPool(*BufferSize + sizeof(CHAR16));
1803     if (UscStrBuffer== NULL) {
1804       SHELL_FREE_NON_NULL(AsciiStrBuffer);
1805       return EFI_OUT_OF_RESOURCES;
1806     }
1807     Status = (((EFI_FILE_PROTOCOL_FILE*)This)->Orig->Read(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, &Size, AsciiStrBuffer));
1808     if (!EFI_ERROR(Status)) {
1809       CharNum = UnicodeSPrint(UscStrBuffer, *BufferSize + sizeof(CHAR16), L"%a", AsciiStrBuffer);
1810       if (CharNum == Size) {
1811         CopyMem (Buffer, UscStrBuffer, *BufferSize);
1812       } else {
1813         Status = EFI_UNSUPPORTED;
1814       }
1815     }
1816     SHELL_FREE_NON_NULL(AsciiStrBuffer);
1817     SHELL_FREE_NON_NULL(UscStrBuffer);
1818     return (Status);
1819   }
1820 }
1821
1822 /**
1823   Opens a new file relative to the source file's location.
1824
1825   @param[in]  This       The protocol instance pointer.
1826   @param[out]  NewHandle Returns File Handle for FileName.
1827   @param[in]  FileName   Null terminated string. "\", ".", and ".." are supported.
1828   @param[in]  OpenMode   Open mode for file.
1829   @param[in]  Attributes Only used for EFI_FILE_MODE_CREATE.
1830
1831   @retval EFI_SUCCESS          The device was opened.
1832   @retval EFI_NOT_FOUND        The specified file could not be found on the device.
1833   @retval EFI_NO_MEDIA         The device has no media.
1834   @retval EFI_MEDIA_CHANGED    The media has changed.
1835   @retval EFI_DEVICE_ERROR     The device reported an error.
1836   @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1837   @retval EFI_ACCESS_DENIED    The service denied access to the file.
1838   @retval EFI_OUT_OF_RESOURCES The volume was not opened due to lack of resources.
1839   @retval EFI_VOLUME_FULL      The volume is full.
1840 **/
1841 EFI_STATUS
1842 EFIAPI
1843 FileInterfaceFileOpen (
1844   IN EFI_FILE_PROTOCOL        *This,
1845   OUT EFI_FILE_PROTOCOL       **NewHandle,
1846   IN CHAR16                   *FileName,
1847   IN UINT64                   OpenMode,
1848   IN UINT64                   Attributes
1849   )
1850 {
1851   return ((EFI_FILE_PROTOCOL_FILE*)This)->Orig->Open(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, NewHandle, FileName, OpenMode, Attributes);
1852 }
1853
1854 /**
1855   Close and delete the file handle.
1856
1857   @param  This                     Protocol instance pointer.
1858
1859   @retval EFI_SUCCESS              The device was opened.
1860   @retval EFI_WARN_DELETE_FAILURE  The handle was closed but the file was not deleted.
1861
1862 **/
1863 EFI_STATUS
1864 EFIAPI
1865 FileInterfaceFileDelete(
1866   IN EFI_FILE_PROTOCOL  *This
1867   )
1868 {
1869   EFI_STATUS Status;
1870   Status = ((EFI_FILE_PROTOCOL_FILE*)This)->Orig->Delete(((EFI_FILE_PROTOCOL_FILE*)This)->Orig);
1871   FreePool(This);
1872   return (Status);
1873 }
1874
1875 /**
1876   File style interface for File (Close).
1877
1878   @param[in] This       The pointer to the EFI_FILE_PROTOCOL object.
1879
1880   @retval EFI_SUCCESS   The file was closed.
1881 **/
1882 EFI_STATUS
1883 EFIAPI
1884 FileInterfaceFileClose(
1885   IN EFI_FILE_PROTOCOL *This
1886   )
1887 {
1888   EFI_STATUS Status;
1889   Status = ((EFI_FILE_PROTOCOL_FILE*)This)->Orig->Close(((EFI_FILE_PROTOCOL_FILE*)This)->Orig);
1890   FreePool(This);
1891   return (Status);
1892 }
1893
1894 /**
1895   File style interface for File (Write).
1896
1897   If the file was opened with ASCII mode the data will be processed through
1898   AsciiSPrint before writing.
1899
1900   @param[in] This              The pointer to the EFI_FILE_PROTOCOL object.
1901   @param[in, out] BufferSize   Size in bytes of Buffer.
1902   @param[in] Buffer            The pointer to the buffer to write.
1903
1904   @retval EFI_SUCCESS   The data was written.
1905 **/
1906 EFI_STATUS
1907 EFIAPI
1908 FileInterfaceFileWrite(
1909   IN     EFI_FILE_PROTOCOL  *This,
1910   IN OUT UINTN              *BufferSize,
1911   IN     VOID               *Buffer
1912   )
1913 {
1914   CHAR8       *AsciiBuffer;
1915   UINTN       Size;
1916   EFI_STATUS  Status;
1917   if (((EFI_FILE_PROTOCOL_FILE*)This)->Unicode) {
1918     //
1919     // Unicode
1920     //
1921     return (((EFI_FILE_PROTOCOL_FILE*)This)->Orig->Write(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, BufferSize, Buffer));
1922   } else {
1923     //
1924     // Ascii
1925     //
1926     AsciiBuffer = AllocateZeroPool(*BufferSize);
1927     AsciiSPrint(AsciiBuffer, *BufferSize, "%S", Buffer);
1928     Size = AsciiStrSize(AsciiBuffer) - 1; // (we dont need the null terminator)
1929     Status = (((EFI_FILE_PROTOCOL_FILE*)This)->Orig->Write(((EFI_FILE_PROTOCOL_FILE*)This)->Orig, &Size, AsciiBuffer));
1930     FreePool(AsciiBuffer);
1931     return (Status);
1932   }
1933 }
1934
1935 /**
1936   Create a file interface with unicode information.
1937
1938   This will create a new EFI_FILE_PROTOCOL identical to the Templace
1939   except that the new one has Unicode and Ascii knowledge.
1940
1941   @param[in] Template   A pointer to the EFI_FILE_PROTOCOL object.
1942   @param[in] Unicode    TRUE for UCS-2, FALSE for ASCII.
1943
1944   @return a new EFI_FILE_PROTOCOL object to be used instead of the template.
1945 **/
1946 EFI_FILE_PROTOCOL*
1947 CreateFileInterfaceFile(
1948   IN CONST EFI_FILE_PROTOCOL  *Template,
1949   IN CONST BOOLEAN            Unicode
1950   )
1951 {
1952   EFI_FILE_PROTOCOL_FILE *NewOne;
1953
1954   NewOne = AllocateZeroPool(sizeof(EFI_FILE_PROTOCOL_FILE));
1955   if (NewOne == NULL) {
1956     return (NULL);
1957   }
1958   CopyMem(NewOne, Template, sizeof(EFI_FILE_PROTOCOL_FILE));
1959   NewOne->Orig        = (EFI_FILE_PROTOCOL *)Template;
1960   NewOne->Unicode     = Unicode;
1961   NewOne->Open        = FileInterfaceFileOpen;
1962   NewOne->Close       = FileInterfaceFileClose;
1963   NewOne->Delete      = FileInterfaceFileDelete;
1964   NewOne->Read        = FileInterfaceFileRead;
1965   NewOne->Write       = FileInterfaceFileWrite;
1966   NewOne->GetPosition = FileInterfaceFileGetPosition;
1967   NewOne->SetPosition = FileInterfaceFileSetPosition;
1968   NewOne->GetInfo     = FileInterfaceFileGetInfo;
1969   NewOne->SetInfo     = FileInterfaceFileSetInfo;
1970   NewOne->Flush       = FileInterfaceFileFlush;
1971
1972   return ((EFI_FILE_PROTOCOL *)NewOne);
1973 }