ShellPkg/Application/Shell/ShellParametersProtocol.c

   1 /** @file
   2   Member functions of EFI_SHELL_PARAMETERS_PROTOCOL and functions for creation,
   3   manipulation, and initialization of EFI_SHELL_PARAMETERS_PROTOCOL.
   4
   5   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
   6   This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "ShellParametersProtocol.h"
  17 #include "ConsoleWrappers.h"
  18
  19 /**
  20   return the next parameter from a command line string;
  21
  22   This function moves the next parameter from Walker into TempParameter and moves
  23   Walker up past that parameter for recursive calling.  When the final parameter
  24   is moved *Walker will be set to NULL;
  25
  26   Temp Parameter must be large enough to hold the parameter before calling this
  27   function.
  28
  29   @param[in,out] Walker        pointer to string of command line.  Adjusted to
  30                                 reminaing command line on return
  31   @param[in,out] TempParameter pointer to string of command line item extracted.
  32
  33 **/
  34 VOID
  35 EFIAPI
  36 GetNextParameter(
  37   CHAR16 **Walker,
  38   CHAR16 **TempParameter
  39   )
  40 {
  41   CHAR16 *NextDelim;
  42   CHAR16 *TempLoc;
  43
  44   ASSERT(Walker           != NULL);
  45   ASSERT(*Walker          != NULL);
  46   ASSERT(TempParameter    != NULL);
  47   ASSERT(*TempParameter   != NULL);
  48
  49   //
  50   // make sure we dont have any leading spaces
  51   //
  52   while ((*Walker)[0] == L' ') {
  53       (*Walker)++;
  54   }
  55
  56   //
  57   // make sure we still have some params now...
  58   //
  59   if (StrLen(*Walker) == 0) {
  60     ASSERT((*Walker)[0] == CHAR_NULL);
  61     *Walker = NULL;
  62     return;
  63   }
  64
  65   //
  66   // we have a quoted parameter
  67   // could be the last parameter, but SHOULD have a trailing quote
  68   //
  69   if ((*Walker)[0] == L'\"') {
  70     NextDelim = NULL;
  71     for (TempLoc = *Walker + 1 ; TempLoc != NULL && *TempLoc != CHAR_NULL ; TempLoc++) {
  72       if (*TempLoc == L'^' && *(TempLoc+1) == L'^') {
  73         TempLoc++;
  74       } else if (*TempLoc == L'^' && *(TempLoc+1) == L'\"') {
  75         TempLoc++;
  76       } else if (*TempLoc == L'\"') {
  77         NextDelim = TempLoc;
  78         break;
  79       }
  80     }
  81
  82     if (NextDelim - ((*Walker)+1) == 0) {
  83       //
  84       // found ""
  85       //
  86       StrCpy(*TempParameter, L"");
  87       *Walker = NextDelim + 1;
  88     } else if (NextDelim != NULL) {
  89       StrnCpy(*TempParameter, (*Walker)+1, NextDelim - ((*Walker)+1));
  90       *Walker = NextDelim + 1;
  91     } else {
  92       //
  93       // last one... someone forgot the training quote!
  94       //
  95       StrCpy(*TempParameter, *Walker);
  96       *Walker = NULL;
  97     }
  98     for (TempLoc = *TempParameter ; TempLoc != NULL && *TempLoc != CHAR_NULL ; TempLoc++) {
  99       if ((*TempLoc == L'^' && *(TempLoc+1) == L'^')
 100        || (*TempLoc == L'^' && *(TempLoc+1) == L'|')
 101        || (*TempLoc == L'^' && *(TempLoc+1) == L'\"')
 102       ){
 103         CopyMem(TempLoc, TempLoc+1, StrSize(TempLoc) - sizeof(TempLoc[0]));
 104       }
 105     }
 106   } else {
 107     //
 108     // we have a regular parameter (no quote) OR
 109     // we have the final parameter (no trailing space)
 110     //
 111     NextDelim = StrStr((*Walker), L" ");
 112     if (NextDelim != NULL) {
 113       StrnCpy(*TempParameter, *Walker, NextDelim - (*Walker));
 114       (*TempParameter)[NextDelim - (*Walker)] = CHAR_NULL;
 115       *Walker = NextDelim+1;
 116     } else {
 117       //
 118       // last one.
 119       //
 120       StrCpy(*TempParameter, *Walker);
 121       *Walker = NULL;
 122     }
 123     for (NextDelim = *TempParameter ; NextDelim != NULL && *NextDelim != CHAR_NULL ; NextDelim++) {
 124       if (*NextDelim == L'^' && *(NextDelim+1) == L'^') {
 125         CopyMem(NextDelim, NextDelim+1, StrSize(NextDelim) - sizeof(NextDelim[0]));
 126       }/* else if (*NextDelim == L'^') {
 127         *NextDelim = L' ';
 128       }*/
 129     }
 130     while ((*TempParameter)[StrLen(*TempParameter)-1] == L' ') {
 131       (*TempParameter)[StrLen(*TempParameter)-1] = CHAR_NULL;
 132     }
 133     while ((*TempParameter)[0] == L' ') {
 134       CopyMem(*TempParameter, (*TempParameter)+1, StrSize(*TempParameter) - sizeof((*TempParameter)[0]));
 135     }
 136   }
 137   return;
 138 }
 139
 140 /**
 141   Function to populate Argc and Argv.
 142
 143   This function parses the CommandLine and divides it into standard C style Argc/Argv
 144   parameters for inclusion in EFI_SHELL_PARAMETERS_PROTOCOL.  this supports space
 145   delimited and quote surrounded parameter definition.
 146
 147   @param[in] CommandLine        String of command line to parse
 148   @param[in,out] Argv           pointer to array of strings; one for each parameter
 149   @param[in,out] Argc           pointer to number of strings in Argv array
 150
 151   @return EFI_SUCCESS           the operation was sucessful
 152   @return EFI_OUT_OF_RESOURCES  a memory allocation failed.
 153 **/
 154 EFI_STATUS
 155 EFIAPI
 156 ParseCommandLineToArgs(
 157   IN CONST CHAR16 *CommandLine,
 158   IN OUT CHAR16 ***Argv,
 159   IN OUT UINTN *Argc
 160   )
 161 {
 162   UINTN       Count;
 163   CHAR16      *TempParameter;
 164   CHAR16      *Walker;
 165   CHAR16      *NewParam;
 166   UINTN       Size;
 167
 168   ASSERT(Argc != NULL);
 169   ASSERT(Argv != NULL);
 170
 171   if (CommandLine == NULL || StrLen(CommandLine)==0) {
 172     (*Argc) = 0;
 173     (*Argv) = NULL;
 174     return (EFI_SUCCESS);
 175   }
 176
 177   Size = StrSize(CommandLine);
 178   TempParameter = AllocateZeroPool(Size);
 179   if (TempParameter == NULL) {
 180     return (EFI_OUT_OF_RESOURCES);
 181   }
 182
 183   for ( Count = 0
 184       , Walker = (CHAR16*)CommandLine
 185       ; Walker != NULL && *Walker != CHAR_NULL
 186       ; GetNextParameter(&Walker, &TempParameter)
 187       , Count++
 188      );
 189
 190 /*  Count = 0;
 191   Walker = (CHAR16*)CommandLine;
 192   while(Walker != NULL) {
 193     GetNextParameter(&Walker, &TempParameter);
 194     Count++;
 195   }
 196 */
 197   //
 198   // lets allocate the pointer array
 199   //
 200   (*Argv) = AllocateZeroPool((Count)*sizeof(CHAR16*));
 201   if (*Argv == NULL) {
 202     return (EFI_OUT_OF_RESOURCES);
 203   }
 204
 205   *Argc = 0;
 206   Walker = (CHAR16*)CommandLine;
 207   while(Walker != NULL && *Walker != CHAR_NULL) {
 208     SetMem16(TempParameter, Size, CHAR_NULL);
 209     GetNextParameter(&Walker, &TempParameter);
 210     NewParam = AllocateZeroPool(StrSize(TempParameter));
 211     ASSERT(NewParam != NULL);
 212     StrCpy(NewParam, TempParameter);
 213     ((CHAR16**)(*Argv))[(*Argc)] = NewParam;
 214     (*Argc)++;
 215   }
 216   ASSERT(Count >= (*Argc));
 217   return (EFI_SUCCESS);
 218 }
 219
 220 /**
 221   creates a new EFI_SHELL_PARAMETERS_PROTOCOL instance and populates it and then
 222   installs it on our handle and if there is an existing version of the protocol
 223   that one is cached for removal later.
 224
 225   @param[in,out] NewShellParameters on a successful return, a pointer to pointer
 226                                      to the newly installed interface.
 227   @param[in,out] RootShellInstance  on a successful return, pointer to boolean.
 228                                      TRUE if this is the root shell instance.
 229
 230   @retval EFI_SUCCESS               the operation completed successfully.
 231   @return other                     the operation failed.
 232   @sa ReinstallProtocolInterface
 233   @sa InstallProtocolInterface
 234   @sa ParseCommandLineToArgs
 235 **/
 236 EFI_STATUS
 237 EFIAPI
 238 CreatePopulateInstallShellParametersProtocol (
 239   IN OUT EFI_SHELL_PARAMETERS_PROTOCOL  **NewShellParameters,
 240   IN OUT BOOLEAN                        *RootShellInstance
 241   )
 242 {
 243   EFI_STATUS Status;
 244   EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
 245   CHAR16                    *FullCommandLine;
 246   UINTN                     Size;
 247
 248   Size = 0;
 249   FullCommandLine = NULL;
 250   LoadedImage = NULL;
 251
 252   //
 253   // Assert for valid parameters
 254   //
 255   ASSERT(NewShellParameters != NULL);
 256   ASSERT(RootShellInstance  != NULL);
 257
 258   //
 259   // See if we have a shell parameters placed on us
 260   //
 261   Status = gBS->OpenProtocol (
 262                 gImageHandle,
 263                 &gEfiShellParametersProtocolGuid,
 264                 (VOID **) &ShellInfoObject.OldShellParameters,
 265                 gImageHandle,
 266                 NULL,
 267                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
 268                );
 269   //
 270   // if we don't then we must be the root shell (error is expected)
 271   //
 272   if (EFI_ERROR (Status)) {
 273     *RootShellInstance = TRUE;
 274   }
 275
 276   //
 277   // Allocate the new structure
 278   //
 279   *NewShellParameters = AllocateZeroPool(sizeof(EFI_SHELL_PARAMETERS_PROTOCOL));
 280   if ((*NewShellParameters) == NULL) {
 281     return (EFI_OUT_OF_RESOURCES);
 282   }
 283
 284   //
 285   // get loaded image protocol
 286   //
 287   Status = gBS->OpenProtocol (
 288                 gImageHandle,
 289                 &gEfiLoadedImageProtocolGuid,
 290                 (VOID **) &LoadedImage,
 291                 gImageHandle,
 292                 NULL,
 293                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
 294                );
 295   ASSERT_EFI_ERROR(Status);
 296   //
 297   // Build the full command line
 298   //
 299   Status = SHELL_GET_ENVIRONMENT_VARIABLE(L"ShellOpt", &Size, &FullCommandLine);
 300   if (Status == EFI_BUFFER_TOO_SMALL) {
 301     FullCommandLine = AllocateZeroPool(Size + LoadedImage->LoadOptionsSize);
 302     Status = SHELL_GET_ENVIRONMENT_VARIABLE(L"ShellOpt", &Size, &FullCommandLine);
 303   }
 304   if (Status == EFI_NOT_FOUND) {
 305     //
 306     // no parameters via environment... ok
 307     //
 308   } else {
 309     if (EFI_ERROR(Status)) {
 310       return (Status);
 311     }
 312   }
 313   if (Size == 0 && LoadedImage->LoadOptionsSize != 0) {
 314     ASSERT(FullCommandLine == NULL);
 315     //
 316     // Now we need to include a NULL terminator in the size.
 317     //
 318     Size = LoadedImage->LoadOptionsSize + sizeof(FullCommandLine[0]);
 319     FullCommandLine = AllocateZeroPool(Size);
 320   }
 321   if (FullCommandLine != NULL) {
 322     if (LoadedImage->LoadOptionsSize != 0){
 323       StrCpy(FullCommandLine, LoadedImage->LoadOptions);
 324     }
 325     //
 326     // Populate Argc and Argv
 327     //
 328     Status = ParseCommandLineToArgs(FullCommandLine,
 329                                     &(*NewShellParameters)->Argv,
 330                                     &(*NewShellParameters)->Argc);
 331
 332     FreePool(FullCommandLine);
 333
 334     ASSERT_EFI_ERROR(Status);
 335   } else {
 336     (*NewShellParameters)->Argv = NULL;
 337     (*NewShellParameters)->Argc = 0;
 338   }
 339
 340   //
 341   // Populate the 3 faked file systems...
 342   //
 343   if (*RootShellInstance) {
 344     (*NewShellParameters)->StdIn  = &FileInterfaceStdIn;
 345     (*NewShellParameters)->StdOut = &FileInterfaceStdOut;
 346     (*NewShellParameters)->StdErr = &FileInterfaceStdErr;
 347     Status = gBS->InstallProtocolInterface(&gImageHandle,
 348                                            &gEfiShellParametersProtocolGuid,
 349                                            EFI_NATIVE_INTERFACE,
 350                                            (VOID*)(*NewShellParameters));
 351   } else {
 352     //
 353     // copy from the existing ones
 354     //
 355     (*NewShellParameters)->StdIn  = ShellInfoObject.OldShellParameters->StdIn;
 356     (*NewShellParameters)->StdOut = ShellInfoObject.OldShellParameters->StdOut;
 357     (*NewShellParameters)->StdErr = ShellInfoObject.OldShellParameters->StdErr;
 358     Status = gBS->ReinstallProtocolInterface(gImageHandle,
 359                                              &gEfiShellParametersProtocolGuid,
 360                                              (VOID*)ShellInfoObject.OldShellParameters,
 361                                              (VOID*)(*NewShellParameters));
 362   }
 363
 364   return (Status);
 365 }
 366
 367 /**
 368   frees all memory used by createion and installation of shell parameters protocol
 369   and if there was an old version installed it will restore that one.
 370
 371   @param NewShellParameters the interface of EFI_SHELL_PARAMETERS_PROTOCOL that is
 372   being cleaned up.
 373
 374   @retval EFI_SUCCESS     the cleanup was successful
 375   @return other           the cleanup failed
 376   @sa ReinstallProtocolInterface
 377   @sa UninstallProtocolInterface
 378 **/
 379 EFI_STATUS
 380 EFIAPI
 381 CleanUpShellParametersProtocol (
 382   IN OUT EFI_SHELL_PARAMETERS_PROTOCOL  *NewShellParameters
 383   )
 384 {
 385   EFI_STATUS Status;
 386   UINTN LoopCounter;
 387
 388   //
 389   // If the old exists we need to restore it
 390   //
 391   if (ShellInfoObject.OldShellParameters != NULL) {
 392     Status = gBS->ReinstallProtocolInterface(gImageHandle,
 393                                              &gEfiShellParametersProtocolGuid,
 394                                              (VOID*)NewShellParameters,
 395                                              (VOID*)ShellInfoObject.OldShellParameters);
 396     DEBUG_CODE(ShellInfoObject.OldShellParameters = NULL;);
 397   } else {
 398     //
 399     // No old one, just uninstall us...
 400     //
 401     Status = gBS->UninstallProtocolInterface(gImageHandle,
 402                                              &gEfiShellParametersProtocolGuid,
 403                                              (VOID*)NewShellParameters);
 404   }
 405   if (NewShellParameters->Argv != NULL) {
 406     for ( LoopCounter = 0
 407         ; LoopCounter < NewShellParameters->Argc
 408         ; LoopCounter++
 409        ){
 410       FreePool(NewShellParameters->Argv[LoopCounter]);
 411     }
 412     FreePool(NewShellParameters->Argv);
 413   }
 414   FreePool(NewShellParameters);
 415   return (Status);
 416 }
 417
 418 EFI_STATUS
 419 EFIAPI
 420 IsUnicodeFile(
 421   IN CONST CHAR16 *FileName
 422   )
 423 {
 424   SHELL_FILE_HANDLE Handle;
 425   EFI_STATUS        Status;
 426   UINT64            OriginalFilePosition;
 427   UINTN             CharSize;
 428   CHAR16            CharBuffer;
 429
 430   Status = gEfiShellProtocol->OpenFileByName(FileName, &Handle, EFI_FILE_MODE_READ);
 431   if (EFI_ERROR(Status)) {
 432     return (Status);
 433   }
 434   gEfiShellProtocol->GetFilePosition(Handle, &OriginalFilePosition);
 435   gEfiShellProtocol->SetFilePosition(Handle, 0);
 436   CharSize = sizeof(CHAR16);
 437   Status = gEfiShellProtocol->ReadFile(Handle, &CharSize, &CharBuffer);
 438   if (EFI_ERROR(Status) || CharBuffer != gUnicodeFileTag) {
 439     Status = EFI_BUFFER_TOO_SMALL;
 440   }
 441   gEfiShellProtocol->SetFilePosition(Handle, OriginalFilePosition);
 442   gEfiShellProtocol->CloseFile(Handle);
 443   return (Status);
 444 }
 445
 446 /**
 447   Strips out quotes sections of a string.
 448
 449   All of the characters between quotes is replaced with spaces.
 450 **/
 451 VOID
 452 EFIAPI
 453 StripQuotes (
 454   IN OUT CHAR16 *TheString
 455   )
 456 {
 457   BOOLEAN RemoveNow;
 458
 459   for (RemoveNow = FALSE ; TheString != NULL && *TheString != CHAR_NULL ; TheString++) {
 460     if (*TheString == L'^' && *(TheString + 1) == L'\"') {
 461       TheString++;
 462     } else if (*TheString == L'\"') {
 463       RemoveNow = (BOOLEAN)!RemoveNow;
 464     } else if (RemoveNow) {
 465       *TheString = L' ';
 466     }
 467   }
 468 }
 469
 470 /**
 471   Funcion will replace the current StdIn and StdOut in the ShellParameters protocol
 472   structure by parsing NewCommandLine.  The current values are returned to the
 473   user.
 474
 475   This will also update the system table.
 476
 477   @param[in,out] ShellParameters        Pointer to parameter structure to modify.
 478   @param[in] NewCommandLine             The new command line to parse and use.
 479   @param[out] OldStdIn                  Pointer to old StdIn.
 480   @param[out] OldStdOut                 Pointer to old StdOut.
 481   @param[out] OldStdErr                 Pointer to old StdErr.
 482   @param[out] SystemTableInfo           Pointer to old system table information.
 483
 484   @retval   EFI_SUCCESS                 Operation was sucessful, Argv and Argc are valid.
 485   @retval   EFI_OUT_OF_RESOURCES        A memory allocation failed.
 486 **/
 487 EFI_STATUS
 488 EFIAPI
 489 UpdateStdInStdOutStdErr(
 490   IN OUT EFI_SHELL_PARAMETERS_PROTOCOL  *ShellParameters,
 491   IN CHAR16                             *NewCommandLine,
 492   OUT SHELL_FILE_HANDLE                 *OldStdIn,
 493   OUT SHELL_FILE_HANDLE                 *OldStdOut,
 494   OUT SHELL_FILE_HANDLE                 *OldStdErr,
 495   OUT SYSTEM_TABLE_INFO                 *SystemTableInfo
 496   )
 497 {
 498   CHAR16            *CommandLineCopy;
 499   CHAR16            *CommandLineWalker;
 500   CHAR16            *StdErrFileName;
 501   CHAR16            *StdOutFileName;
 502   CHAR16            *StdInFileName;
 503   CHAR16            *StdInVarName;
 504   CHAR16            *StdOutVarName;
 505   CHAR16            *StdErrVarName;
 506   EFI_STATUS        Status;
 507   SHELL_FILE_HANDLE TempHandle;
 508   UINT64            FileSize;
 509   BOOLEAN           OutUnicode;
 510   BOOLEAN           InUnicode;
 511   BOOLEAN           ErrUnicode;
 512   BOOLEAN           OutAppend;
 513   BOOLEAN           ErrAppend;
 514   UINTN             Size;
 515   CHAR16            TagBuffer[2];
 516   SPLIT_LIST        *Split;
 517   CHAR16            *FirstLocation;
 518
 519   OutUnicode      = TRUE;
 520   InUnicode       = TRUE;
 521   ErrUnicode      = TRUE;
 522   StdInVarName    = NULL;
 523   StdOutVarName   = NULL;
 524   StdErrVarName   = NULL;
 525   StdErrFileName  = NULL;
 526   StdInFileName   = NULL;
 527   StdOutFileName  = NULL;
 528   ErrAppend       = FALSE;
 529   OutAppend       = FALSE;
 530   CommandLineCopy = NULL;
 531   FirstLocation   = (CHAR16*)(-1);
 532
 533   if (ShellParameters == NULL || SystemTableInfo == NULL || OldStdIn == NULL || OldStdOut == NULL || OldStdErr == NULL) {
 534     return (EFI_INVALID_PARAMETER);
 535   }
 536
 537   SystemTableInfo->ConIn          = gST->ConIn;
 538   SystemTableInfo->ConInHandle    = gST->ConsoleInHandle;
 539   SystemTableInfo->ConOut         = gST->ConOut;
 540   SystemTableInfo->ConOutHandle   = gST->ConsoleOutHandle;
 541   SystemTableInfo->ConErr         = gST->StdErr;
 542   SystemTableInfo->ConErrHandle   = gST->StandardErrorHandle;
 543   *OldStdIn                       = ShellParameters->StdIn;
 544   *OldStdOut                      = ShellParameters->StdOut;
 545   *OldStdErr                      = ShellParameters->StdErr;
 546
 547   if (NewCommandLine == NULL) {
 548     return (EFI_SUCCESS);
 549   }
 550
 551   CommandLineCopy = StrnCatGrow(&CommandLineCopy, NULL, NewCommandLine, 0);
 552   Status          = EFI_SUCCESS;
 553   Split           = NULL;
 554
 555   StripQuotes(CommandLineCopy);
 556
 557   if (!IsListEmpty(&ShellInfoObject.SplitList.Link)) {
 558     Split = (SPLIT_LIST*)GetFirstNode(&ShellInfoObject.SplitList.Link);
 559     if (Split != NULL && Split->SplitStdIn != NULL) {
 560       ShellParameters->StdIn  = Split->SplitStdIn;
 561     }
 562     if (Split != NULL && Split->SplitStdOut != NULL) {
 563       ShellParameters->StdOut = Split->SplitStdOut;
 564     }
 565   }
 566
 567   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" 2>>v ")) != NULL) {
 568     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 569     SetMem16(CommandLineWalker, 12, L' ');
 570     StdErrVarName   = CommandLineWalker += 6;
 571     ErrAppend       = TRUE;
 572     if (StrStr(CommandLineWalker, L" 2>>v ") != NULL) {
 573       Status = EFI_NOT_FOUND;
 574     }
 575   }
 576   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" 1>>v ")) != NULL) {
 577     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 578     SetMem16(CommandLineWalker, 12, L' ');
 579     StdOutVarName   = CommandLineWalker += 6;
 580     OutAppend       = TRUE;
 581     if (StrStr(CommandLineWalker, L" 1>>v ") != NULL) {
 582       Status = EFI_NOT_FOUND;
 583     }
 584   } else if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" >>v ")) != NULL) {
 585     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 586     SetMem16(CommandLineWalker, 10, L' ');
 587     StdOutVarName   = CommandLineWalker += 5;
 588     OutAppend       = TRUE;
 589     if (StrStr(CommandLineWalker, L" >>v ") != NULL) {
 590       Status = EFI_NOT_FOUND;
 591     }
 592   } else if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" >v ")) != NULL) {
 593     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 594     SetMem16(CommandLineWalker, 8, L' ');
 595     StdOutVarName   = CommandLineWalker += 4;
 596     OutAppend       = FALSE;
 597     if (StrStr(CommandLineWalker, L" >v ") != NULL) {
 598       Status = EFI_NOT_FOUND;
 599     }
 600   }
 601   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" 1>>a ")) != NULL) {
 602     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 603     SetMem16(CommandLineWalker, 12, L' ');
 604     StdOutFileName  = CommandLineWalker += 6;
 605     OutAppend       = TRUE;
 606     OutUnicode      = FALSE;
 607     if (StrStr(CommandLineWalker, L" 1>>a ") != NULL) {
 608       Status = EFI_NOT_FOUND;
 609     }
 610   }
 611   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" 1>> ")) != NULL) {
 612     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 613     SetMem16(CommandLineWalker, 10, L' ');
 614     if (StdOutFileName != NULL) {
 615       Status = EFI_INVALID_PARAMETER;
 616     } else {
 617       StdOutFileName  = CommandLineWalker += 5;
 618       OutAppend       = TRUE;
 619     }
 620     if (StrStr(CommandLineWalker, L" 1>> ") != NULL) {
 621       Status = EFI_NOT_FOUND;
 622     }
 623   }
 624   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" >> ")) != NULL) {
 625     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 626     SetMem16(CommandLineWalker, 8, L' ');
 627     if (StdOutFileName != NULL) {
 628       Status = EFI_INVALID_PARAMETER;
 629     } else {
 630       StdOutFileName  = CommandLineWalker += 4;
 631       OutAppend       = TRUE;
 632     }
 633     if (StrStr(CommandLineWalker, L" >> ") != NULL) {
 634       Status = EFI_NOT_FOUND;
 635     }
 636   }
 637   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" >>a ")) != NULL) {
 638     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 639     SetMem16(CommandLineWalker, 10, L' ');
 640     if (StdOutFileName != NULL) {
 641       Status = EFI_INVALID_PARAMETER;
 642     } else {
 643       StdOutFileName  = CommandLineWalker += 5;
 644       OutAppend       = TRUE;
 645       OutUnicode      = FALSE;
 646     }
 647     if (StrStr(CommandLineWalker, L" >>a ") != NULL) {
 648       Status = EFI_NOT_FOUND;
 649     }
 650   }
 651   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" 1>a ")) != NULL) {
 652     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 653     SetMem16(CommandLineWalker, 10, L' ');
 654     if (StdOutFileName != NULL) {
 655       Status = EFI_INVALID_PARAMETER;
 656     } else {
 657       StdOutFileName  = CommandLineWalker += 5;
 658       OutAppend       = FALSE;
 659       OutUnicode      = FALSE;
 660     }
 661     if (StrStr(CommandLineWalker, L" 1>a ") != NULL) {
 662       Status = EFI_NOT_FOUND;
 663     }
 664   }
 665   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" >a ")) != NULL) {
 666     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 667     SetMem16(CommandLineWalker, 8, L' ');
 668     if (StdOutFileName != NULL) {
 669       Status = EFI_INVALID_PARAMETER;
 670     } else {
 671       StdOutFileName  = CommandLineWalker += 4;
 672       OutAppend       = FALSE;
 673       OutUnicode      = FALSE;
 674     }
 675     if (StrStr(CommandLineWalker, L" >a ") != NULL) {
 676       Status = EFI_NOT_FOUND;
 677     }
 678   }
 679   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" 2>> ")) != NULL) {
 680     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 681     SetMem16(CommandLineWalker, 10, L' ');
 682     if (StdErrFileName != NULL) {
 683       Status = EFI_INVALID_PARAMETER;
 684     } else {
 685       StdErrFileName  = CommandLineWalker += 5;
 686       ErrAppend       = TRUE;
 687     }
 688     if (StrStr(CommandLineWalker, L" 2>> ") != NULL) {
 689       Status = EFI_NOT_FOUND;
 690     }
 691   }
 692
 693   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" 2>v ")) != NULL) {
 694     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 695     SetMem16(CommandLineWalker, 10, L' ');
 696     if (StdErrVarName != NULL) {
 697       Status = EFI_INVALID_PARAMETER;
 698     } else {
 699       StdErrVarName   = CommandLineWalker += 5;
 700       ErrAppend       = FALSE;
 701     }
 702     if (StrStr(CommandLineWalker, L" 2>v ") != NULL) {
 703       Status = EFI_NOT_FOUND;
 704     }
 705   }
 706   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" 1>v ")) != NULL) {
 707     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 708     SetMem16(CommandLineWalker, 10, L' ');
 709     if (StdOutVarName != NULL) {
 710       Status = EFI_INVALID_PARAMETER;
 711     } else {
 712       StdOutVarName   = CommandLineWalker += 5;
 713       OutAppend       = FALSE;
 714     }
 715     if (StrStr(CommandLineWalker, L" 1>v ") != NULL) {
 716       Status = EFI_NOT_FOUND;
 717     }
 718   }
 719   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" 2>a ")) != NULL) {
 720     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 721     SetMem16(CommandLineWalker, 10, L' ');
 722     if (StdErrFileName != NULL) {
 723       Status = EFI_INVALID_PARAMETER;
 724     } else {
 725       StdErrFileName  = CommandLineWalker += 5;
 726       ErrAppend       = FALSE;
 727       ErrUnicode      = FALSE;
 728     }
 729     if (StrStr(CommandLineWalker, L" 2>a ") != NULL) {
 730       Status = EFI_NOT_FOUND;
 731     }
 732   }
 733   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" 2> ")) != NULL) {
 734     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 735     SetMem16(CommandLineWalker, 8, L' ');
 736     if (StdErrFileName != NULL) {
 737       Status = EFI_INVALID_PARAMETER;
 738     } else {
 739       StdErrFileName  = CommandLineWalker += 4;
 740       ErrAppend       = FALSE;
 741     }
 742     if (StrStr(CommandLineWalker, L" 2> ") != NULL) {
 743       Status = EFI_NOT_FOUND;
 744     }
 745   }
 746
 747   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" 1> ")) != NULL) {
 748     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 749     SetMem16(CommandLineWalker, 8, L' ');
 750     if (StdOutFileName != NULL) {
 751       Status = EFI_INVALID_PARAMETER;
 752     } else {
 753       StdOutFileName  = CommandLineWalker += 4;
 754       OutAppend       = FALSE;
 755     }
 756     if (StrStr(CommandLineWalker, L" 1> ") != NULL) {
 757       Status = EFI_NOT_FOUND;
 758     }
 759   }
 760
 761   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" > ")) != NULL) {
 762     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 763     SetMem16(CommandLineWalker, 6, L' ');
 764     if (StdOutFileName != NULL) {
 765       Status = EFI_INVALID_PARAMETER;
 766     } else {
 767       StdOutFileName  = CommandLineWalker += 3;
 768       OutAppend       = FALSE;
 769     }
 770     if (StrStr(CommandLineWalker, L" > ") != NULL) {
 771       Status = EFI_NOT_FOUND;
 772     }
 773   }
 774
 775   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" < ")) != NULL) {
 776     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 777     SetMem16(CommandLineWalker, 6, L' ');
 778     if (StdInFileName != NULL) {
 779       Status = EFI_INVALID_PARAMETER;
 780     } else {
 781       StdInFileName  = CommandLineWalker += 3;
 782     }
 783     if (StrStr(CommandLineWalker, L" < ") != NULL) {
 784       Status = EFI_NOT_FOUND;
 785     }
 786   }
 787   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" <a ")) != NULL) {
 788     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 789     SetMem16(CommandLineWalker, 8, L' ');
 790     if (StdInFileName != NULL) {
 791       Status = EFI_INVALID_PARAMETER;
 792     } else {
 793       StdInFileName   = CommandLineWalker += 4;
 794       InUnicode       = FALSE;
 795     }
 796     if (StrStr(CommandLineWalker, L" <a ") != NULL) {
 797       Status = EFI_NOT_FOUND;
 798     }
 799   }
 800   if (!EFI_ERROR(Status) && (CommandLineWalker = StrStr(CommandLineCopy, L" <v ")) != NULL) {
 801     FirstLocation = MIN(CommandLineWalker, FirstLocation);
 802     SetMem16(CommandLineWalker, 8, L' ');
 803     if (StdInVarName != NULL) {
 804       Status = EFI_INVALID_PARAMETER;
 805     } else {
 806       StdInVarName  = CommandLineWalker += 4;
 807     }
 808     if (StrStr(CommandLineWalker, L" <v ") != NULL) {
 809       Status = EFI_NOT_FOUND;
 810     }
 811   }
 812
 813   if (FirstLocation != (CHAR16*)(-1)
 814     && ((UINTN)(FirstLocation - CommandLineCopy) < StrLen(NewCommandLine))
 815     ){
 816     *(NewCommandLine + (UINTN)(FirstLocation - CommandLineCopy)) = CHAR_NULL;
 817   }
 818
 819   if (!EFI_ERROR(Status)) {
 820     if (StdErrFileName != NULL && (CommandLineWalker = StrStr(StdErrFileName, L" ")) != NULL) {
 821       CommandLineWalker[0] = CHAR_NULL;
 822     }
 823     if (StdOutFileName != NULL && (CommandLineWalker = StrStr(StdOutFileName, L" ")) != NULL) {
 824       CommandLineWalker[0] = CHAR_NULL;
 825     }
 826     if (StdInFileName  != NULL && (CommandLineWalker = StrStr(StdInFileName , L" ")) != NULL) {
 827       CommandLineWalker[0] = CHAR_NULL;
 828     }
 829     if (StdErrVarName  != NULL && (CommandLineWalker = StrStr(StdErrVarName , L" ")) != NULL) {
 830       CommandLineWalker[0] = CHAR_NULL;
 831     }
 832     if (StdOutVarName  != NULL && (CommandLineWalker = StrStr(StdOutVarName , L" ")) != NULL) {
 833       CommandLineWalker[0] = CHAR_NULL;
 834     }
 835     if (StdInVarName   != NULL && (CommandLineWalker = StrStr(StdInVarName  , L" ")) != NULL) {
 836       CommandLineWalker[0] = CHAR_NULL;
 837     }
 838
 839     if (
 840       //
 841       // Check that no 2 filenames are the same
 842       //
 843       (StdErrFileName != NULL && StdOutFileName!= NULL && StringNoCaseCompare(&StdErrFileName, &StdOutFileName) == 0)
 844       ||(StdErrFileName != NULL && StdInFileName != NULL && StringNoCaseCompare(&StdErrFileName, &StdInFileName ) == 0)
 845       ||(StdOutFileName != NULL && StdInFileName != NULL && StringNoCaseCompare(&StdOutFileName, &StdInFileName ) == 0)
 846       //
 847       // Check that no 2 variable names are the same
 848       //
 849       ||(StdErrVarName  != NULL && StdInVarName  != NULL && StringNoCaseCompare(&StdErrVarName , &StdInVarName  ) == 0)
 850       ||(StdOutVarName  != NULL && StdInVarName != NULL && StringNoCaseCompare(&StdOutVarName , &StdInVarName  ) == 0)
 851       ||(StdErrVarName  != NULL && StdOutVarName != NULL && StringNoCaseCompare(&StdErrVarName , &StdOutVarName ) == 0)
 852       //
 853       // When a split (using | operator) is in place some are not allowed
 854       //
 855       ||(Split != NULL && Split->SplitStdIn  != NULL && (StdInVarName  != NULL || StdInFileName  != NULL))
 856       ||(Split != NULL && Split->SplitStdOut != NULL && (StdOutVarName != NULL || StdOutFileName != NULL))
 857       //
 858       // Check that nothing is trying to be output to 2 locations.
 859       //
 860       ||(StdErrFileName != NULL && StdErrVarName != NULL)
 861       ||(StdOutFileName != NULL && StdOutVarName != NULL)
 862       ||(StdInFileName  != NULL && StdInVarName  != NULL)
 863       //
 864       // Check for no volatile environment variables
 865       //
 866       ||(StdErrVarName  != NULL && !IsVolatileEnv(StdErrVarName))
 867       ||(StdOutVarName  != NULL && !IsVolatileEnv(StdOutVarName))
 868       //
 869       // Cant redirect during a reconnect operation.
 870       //
 871       ||(StrStr(NewCommandLine, L"connect -r") != NULL
 872          && (StdOutVarName != NULL || StdOutFileName != NULL || StdErrFileName != NULL || StdErrVarName != NULL))
 873       //
 874       // Check that filetypes (Unicode/Ascii) do not change during an append
 875       //
 876       ||(StdOutFileName != NULL && OutUnicode && OutAppend && (!EFI_ERROR(ShellFileExists(StdOutFileName)) && EFI_ERROR(IsUnicodeFile(StdOutFileName))))
 877       ||(StdErrFileName != NULL && ErrUnicode && ErrAppend && (!EFI_ERROR(ShellFileExists(StdErrFileName)) && EFI_ERROR(IsUnicodeFile(StdErrFileName))))
 878       ||(StdOutFileName != NULL && !OutUnicode && OutAppend && (!EFI_ERROR(ShellFileExists(StdOutFileName)) && !EFI_ERROR(IsUnicodeFile(StdOutFileName))))
 879       ||(StdErrFileName != NULL && !ErrUnicode && ErrAppend && (!EFI_ERROR(ShellFileExists(StdErrFileName)) && !EFI_ERROR(IsUnicodeFile(StdErrFileName))))
 880       ){
 881       Status = EFI_INVALID_PARAMETER;
 882     } else if (!EFI_ERROR(Status)){
 883       //
 884       // Open the Std<Whatever> and we should not have conflicts here...
 885       //
 886
 887       //
 888       // StdErr to a file
 889       //
 890       if (StdErrFileName != NULL) {
 891         if (!ErrAppend) {
 892           //
 893           // delete existing file.
 894           //
 895           ShellInfoObject.NewEfiShellProtocol->DeleteFileByName(StdErrFileName);
 896         }
 897         Status = ShellOpenFileByName(StdErrFileName, &TempHandle, EFI_FILE_MODE_WRITE|EFI_FILE_MODE_READ|EFI_FILE_MODE_CREATE,0);
 898         if (!ErrAppend && ErrUnicode && !EFI_ERROR(Status)) {
 899           //
 900           // Write out the gUnicodeFileTag
 901           //
 902           Size = sizeof(CHAR16);
 903           TagBuffer[0] = gUnicodeFileTag;
 904           TagBuffer[1] = CHAR_NULL;
 905           ShellInfoObject.NewEfiShellProtocol->WriteFile(TempHandle, &Size, TagBuffer);
 906         }
 907         if (!ErrUnicode && !EFI_ERROR(Status)) {
 908           TempHandle = CreateFileInterfaceFile(TempHandle, FALSE);
 909           ASSERT(TempHandle != NULL);
 910         }
 911         if (!EFI_ERROR(Status)) {
 912           ShellParameters->StdErr = TempHandle;
 913           gST->StdErr = CreateSimpleTextOutOnFile(TempHandle, &gST->StandardErrorHandle);
 914         }
 915       }
 916
 917       //
 918       // StdOut to a file
 919       //
 920       if (!EFI_ERROR(Status) && StdOutFileName != NULL) {
 921         if (!OutAppend) {
 922           //
 923           // delete existing file.
 924           //
 925           ShellInfoObject.NewEfiShellProtocol->DeleteFileByName(StdOutFileName);
 926         }
 927         Status = ShellOpenFileByName(StdOutFileName, &TempHandle, EFI_FILE_MODE_WRITE|EFI_FILE_MODE_READ|EFI_FILE_MODE_CREATE,0);
 928         if (TempHandle == NULL) {
 929           Status = EFI_INVALID_PARAMETER;
 930         } else {
 931           if (StrStr(StdOutFileName, L"NUL")==StdOutFileName) {
 932             //no-op
 933           } else if (!OutAppend && OutUnicode && !EFI_ERROR(Status)) {
 934             //
 935             // Write out the gUnicodeFileTag
 936             //
 937             Size = sizeof(CHAR16);
 938             TagBuffer[0] = gUnicodeFileTag;
 939             TagBuffer[1] = CHAR_NULL;
 940             ShellInfoObject.NewEfiShellProtocol->WriteFile(TempHandle, &Size, TagBuffer);
 941           } else if (OutAppend) {
 942             //
 943             // Move to end of file
 944             //
 945             Status = ShellInfoObject.NewEfiShellProtocol->GetFileSize(TempHandle, &FileSize);
 946             if (!EFI_ERROR(Status)) {
 947               Status = ShellInfoObject.NewEfiShellProtocol->SetFilePosition(TempHandle, FileSize);
 948             }
 949           }
 950           if (!OutUnicode && !EFI_ERROR(Status)) {
 951             TempHandle = CreateFileInterfaceFile(TempHandle, FALSE);
 952             ASSERT(TempHandle != NULL);
 953           }
 954           if (!EFI_ERROR(Status)) {
 955             ShellParameters->StdOut = TempHandle;
 956             gST->ConOut = CreateSimpleTextOutOnFile(TempHandle, &gST->ConsoleOutHandle);
 957           }
 958         }
 959       }
 960
 961       //
 962       // StdOut to a var
 963       //
 964       if (!EFI_ERROR(Status) && StdOutVarName != NULL) {
 965         if (!OutAppend) {
 966           //
 967           // delete existing variable.
 968           //
 969           SHELL_SET_ENVIRONMENT_VARIABLE_V(StdOutVarName, 0, L"");
 970         }
 971         TempHandle = CreateFileInterfaceEnv(StdOutVarName);
 972         ASSERT(TempHandle != NULL);
 973         ShellParameters->StdOut = TempHandle;
 974         gST->ConOut = CreateSimpleTextOutOnFile(TempHandle, &gST->ConsoleOutHandle);
 975       }
 976
 977       //
 978       // StdErr to a var
 979       //
 980       if (!EFI_ERROR(Status) && StdErrVarName != NULL) {
 981         if (!ErrAppend) {
 982           //
 983           // delete existing variable.
 984           //
 985           SHELL_SET_ENVIRONMENT_VARIABLE_V(StdErrVarName, 0, L"");
 986         }
 987         TempHandle = CreateFileInterfaceEnv(StdErrVarName);
 988         ASSERT(TempHandle != NULL);
 989         ShellParameters->StdErr = TempHandle;
 990         gST->StdErr = CreateSimpleTextOutOnFile(TempHandle, &gST->StandardErrorHandle);
 991       }
 992
 993       //
 994       // StdIn from a var
 995       //
 996       if (!EFI_ERROR(Status) && StdInVarName != NULL) {
 997         TempHandle = CreateFileInterfaceEnv(StdInVarName);
 998         if (!InUnicode) {
 999           TempHandle = CreateFileInterfaceFile(TempHandle, FALSE);
1000         }
1001         Size = 0;
1002         ASSERT(TempHandle != NULL);
1003         if (((EFI_FILE_PROTOCOL*)TempHandle)->Read(TempHandle, &Size, NULL) != EFI_BUFFER_TOO_SMALL) {
1004           Status = EFI_INVALID_PARAMETER;
1005         } else {
1006           ShellParameters->StdIn = TempHandle;
1007           gST->ConIn = CreateSimpleTextInOnFile(TempHandle, &gST->ConsoleInHandle);
1008         }
1009       }
1010
1011       //
1012       // StdIn from a file
1013       //
1014       if (!EFI_ERROR(Status) && StdInFileName != NULL) {
1015         Status = ShellOpenFileByName(
1016           StdInFileName,
1017           &TempHandle,
1018           EFI_FILE_MODE_READ,
1019           0);
1020         if (!InUnicode && !EFI_ERROR(Status)) {
1021           TempHandle = CreateFileInterfaceFile(TempHandle, FALSE);
1022         }
1023         if (!EFI_ERROR(Status)) {
1024           ShellParameters->StdIn = TempHandle;
1025           gST->ConIn = CreateSimpleTextInOnFile(TempHandle, &gST->ConsoleInHandle);
1026         }
1027       }
1028     }
1029   }
1030   FreePool(CommandLineCopy);
1031
1032   if (gST->ConIn == NULL ||gST->ConOut == NULL) {
1033     return (EFI_OUT_OF_RESOURCES);
1034   }
1035   return (Status);
1036 }
1037
1038 /**
1039   Funcion will replace the current StdIn and StdOut in the ShellParameters protocol
1040   structure with StdIn and StdOut.  The current values are de-allocated.
1041
1042   @param[in,out] ShellParameters      Pointer to parameter structure to modify.
1043   @param[in] OldStdIn                 Pointer to old StdIn.
1044   @param[in] OldStdOut                Pointer to old StdOut.
1045   @param[in] OldStdErr                Pointer to old StdErr.
1046   @param[in] SystemTableInfo          Pointer to old system table information.
1047 **/
1048 EFI_STATUS
1049 EFIAPI
1050 RestoreStdInStdOutStdErr (
1051   IN OUT EFI_SHELL_PARAMETERS_PROTOCOL  *ShellParameters,
1052   IN  SHELL_FILE_HANDLE                 *OldStdIn,
1053   IN  SHELL_FILE_HANDLE                 *OldStdOut,
1054   IN  SHELL_FILE_HANDLE                 *OldStdErr,
1055   IN  SYSTEM_TABLE_INFO                 *SystemTableInfo
1056   )
1057 {
1058   SPLIT_LIST        *Split;
1059
1060   if (ShellParameters == NULL
1061     ||OldStdIn        == NULL
1062     ||OldStdOut       == NULL
1063     ||OldStdErr       == NULL
1064     ||SystemTableInfo == NULL) {
1065     return (EFI_INVALID_PARAMETER);
1066   }
1067   if (!IsListEmpty(&ShellInfoObject.SplitList.Link)) {
1068     Split = (SPLIT_LIST*)GetFirstNode(&ShellInfoObject.SplitList.Link);
1069   } else {
1070     Split = NULL;
1071   }
1072   if (ShellParameters->StdIn  != *OldStdIn) {
1073     if ((Split != NULL && Split->SplitStdIn != ShellParameters->StdIn) || Split == NULL) {
1074       gEfiShellProtocol->CloseFile(ShellParameters->StdIn);
1075     }
1076     ShellParameters->StdIn = *OldStdIn;
1077   }
1078   if (ShellParameters->StdOut != *OldStdOut) {
1079     if ((Split != NULL && Split->SplitStdOut != ShellParameters->StdOut) || Split == NULL) {
1080       gEfiShellProtocol->CloseFile(ShellParameters->StdOut);
1081     }
1082     ShellParameters->StdOut = *OldStdOut;
1083   }
1084   if (ShellParameters->StdErr != *OldStdErr) {
1085     gEfiShellProtocol->CloseFile(ShellParameters->StdErr);
1086     ShellParameters->StdErr = *OldStdErr;
1087   }
1088
1089   if (gST->ConIn != SystemTableInfo->ConIn) {
1090     CloseSimpleTextInOnFile(gST->ConIn);
1091     gST->ConIn                = SystemTableInfo->ConIn;
1092     gST->ConsoleInHandle      = SystemTableInfo->ConInHandle;
1093   }
1094   if (gST->ConOut != SystemTableInfo->ConOut) {
1095     CloseSimpleTextOutOnFile(gST->ConOut);
1096     gST->ConOut               = SystemTableInfo->ConOut;
1097     gST->ConsoleOutHandle     = SystemTableInfo->ConOutHandle;
1098   }
1099   if (gST->StdErr != SystemTableInfo->ConErr) {
1100     CloseSimpleTextOutOnFile(gST->StdErr);
1101     gST->StdErr               = SystemTableInfo->ConErr;
1102     gST->StandardErrorHandle  = SystemTableInfo->ConErrHandle;
1103   }
1104
1105   return (EFI_SUCCESS);
1106 }
1107 /**
1108   Funcion will replace the current Argc and Argv in the ShellParameters protocol
1109   structure by parsing NewCommandLine.  The current values are returned to the
1110   user.
1111
1112   If OldArgv or OldArgc is NULL then that value is not returned.
1113
1114   @param[in,out] ShellParameters        Pointer to parameter structure to modify.
1115   @param[in] NewCommandLine             The new command line to parse and use.
1116   @param[out] OldArgv                   Pointer to old list of parameters.
1117   @param[out] OldArgc                   Pointer to old number of items in Argv list.
1118
1119   @retval   EFI_SUCCESS                 Operation was sucessful, Argv and Argc are valid.
1120   @retval   EFI_OUT_OF_RESOURCES        A memory allocation failed.
1121 **/
1122 EFI_STATUS
1123 EFIAPI
1124 UpdateArgcArgv(
1125   IN OUT EFI_SHELL_PARAMETERS_PROTOCOL  *ShellParameters,
1126   IN CONST CHAR16                       *NewCommandLine,
1127   OUT CHAR16                            ***OldArgv OPTIONAL,
1128   OUT UINTN                             *OldArgc OPTIONAL
1129   )
1130 {
1131   ASSERT(ShellParameters != NULL);
1132
1133   if (OldArgc != NULL) {
1134     *OldArgc = ShellParameters->Argc;
1135   }
1136   if (OldArgc != NULL) {
1137     *OldArgv = ShellParameters->Argv;
1138   }
1139
1140   return (ParseCommandLineToArgs(NewCommandLine, &(ShellParameters->Argv), &(ShellParameters->Argc)));
1141 }
1142
1143 /**
1144   Funcion will replace the current Argc and Argv in the ShellParameters protocol
1145   structure with Argv and Argc.  The current values are de-allocated and the
1146   OldArgv must not be deallocated by the caller.
1147
1148   @param[in,out] ShellParameters       pointer to parameter structure to modify
1149   @param[in] OldArgv                   pointer to old list of parameters
1150   @param[in] OldArgc                   pointer to old number of items in Argv list
1151 **/
1152 VOID
1153 EFIAPI
1154 RestoreArgcArgv(
1155   IN OUT EFI_SHELL_PARAMETERS_PROTOCOL  *ShellParameters,
1156   IN CHAR16                             ***OldArgv,
1157   IN UINTN                              *OldArgc
1158   )
1159 {
1160   UINTN LoopCounter;
1161   ASSERT(ShellParameters != NULL);
1162   ASSERT(OldArgv         != NULL);
1163   ASSERT(OldArgc         != NULL);
1164
1165   if (ShellParameters->Argv != NULL) {
1166     for ( LoopCounter = 0
1167         ; LoopCounter < ShellParameters->Argc
1168         ; LoopCounter++
1169        ){
1170       FreePool(ShellParameters->Argv[LoopCounter]);
1171     }
1172     FreePool(ShellParameters->Argv);
1173   }
1174   ShellParameters->Argv = *OldArgv;
1175   *OldArgv = NULL;
1176   ShellParameters->Argc = *OldArgc;
1177   *OldArgc = 0;
1178 }