ShellPkg/Application/Shell/Shell.c

   1 /** @file
   2   This is THE shell (application)
   3
   4   Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "Shell.h"
  16
  17 //
  18 // Initialize the global structure
  19 //
  20 SHELL_INFO ShellInfoObject = {
  21   NULL,
  22   NULL,
  23   FALSE,
  24   FALSE,
  25   {
  26     0,
  27     0,
  28     0,
  29     0,
  30     0,
  31     0,
  32     0,
  33     0,
  34     0,
  35     0,
  36     NULL,
  37     NULL
  38   },
  39   {0,0},
  40   {
  41     {0,0},
  42     0,
  43     0,
  44     TRUE
  45   },
  46   NULL,
  47   0,
  48   NULL,
  49   NULL,
  50   NULL,
  51   NULL,
  52   NULL,
  53   {0,0,NULL,NULL},
  54   {0,0},
  55   NULL,
  56   NULL,
  57   NULL,
  58   NULL,
  59   FALSE
  60 };
  61
  62 STATIC CONST CHAR16 mScriptExtension[]      = L".NSH";
  63 STATIC CONST CHAR16 mExecutableExtensions[] = L".NSH;.EFI";
  64 STATIC CONST CHAR16 mStartupScript[]        = L"startup.nsh";
  65
  66 /**
  67   Function to start monitoring for CTRL-S using SimpleTextInputEx.  This
  68   feature's enabled state was not known when the shell initially launched.
  69
  70   @retval EFI_SUCCESS           The feature is enabled.
  71   @retval EFI_OUT_OF_RESOURCES  There is not enough mnemory available.
  72 **/
  73 EFI_STATUS
  74 EFIAPI
  75 InternalEfiShellStartCtrlSMonitor(
  76   VOID
  77   )
  78 {
  79   EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *SimpleEx;
  80   EFI_KEY_DATA                      KeyData;
  81   EFI_STATUS                        Status;
  82
  83   Status = gBS->OpenProtocol(
  84     gST->ConsoleInHandle,
  85     &gEfiSimpleTextInputExProtocolGuid,
  86     (VOID**)&SimpleEx,
  87     gImageHandle,
  88     NULL,
  89     EFI_OPEN_PROTOCOL_GET_PROTOCOL);
  90   if (EFI_ERROR(Status)) {
  91     ShellPrintHiiEx(
  92       -1,
  93       -1,
  94       NULL,
  95       STRING_TOKEN (STR_SHELL_NO_IN_EX),
  96       ShellInfoObject.HiiHandle);
  97     return (EFI_SUCCESS);
  98   }
  99
 100   KeyData.KeyState.KeyToggleState = 0;
 101   KeyData.Key.ScanCode            = 0;
 102   KeyData.KeyState.KeyShiftState  = EFI_SHIFT_STATE_VALID|EFI_LEFT_CONTROL_PRESSED;
 103   KeyData.Key.UnicodeChar         = L's';
 104
 105   Status = SimpleEx->RegisterKeyNotify(
 106     SimpleEx,
 107     &KeyData,
 108     NotificationFunction,
 109     &ShellInfoObject.CtrlSNotifyHandle1);
 110
 111   KeyData.KeyState.KeyShiftState  = EFI_SHIFT_STATE_VALID|EFI_RIGHT_CONTROL_PRESSED;
 112   if (!EFI_ERROR(Status)) {
 113     Status = SimpleEx->RegisterKeyNotify(
 114       SimpleEx,
 115       &KeyData,
 116       NotificationFunction,
 117       &ShellInfoObject.CtrlSNotifyHandle2);
 118   }
 119   KeyData.KeyState.KeyShiftState  = EFI_SHIFT_STATE_VALID|EFI_LEFT_CONTROL_PRESSED;
 120   KeyData.Key.UnicodeChar         = 19;
 121
 122   if (!EFI_ERROR(Status)) {
 123     Status = SimpleEx->RegisterKeyNotify(
 124       SimpleEx,
 125       &KeyData,
 126       NotificationFunction,
 127       &ShellInfoObject.CtrlSNotifyHandle2);
 128   }
 129   KeyData.KeyState.KeyShiftState  = EFI_SHIFT_STATE_VALID|EFI_RIGHT_CONTROL_PRESSED;
 130   if (!EFI_ERROR(Status)) {
 131     Status = SimpleEx->RegisterKeyNotify(
 132       SimpleEx,
 133       &KeyData,
 134       NotificationFunction,
 135       &ShellInfoObject.CtrlSNotifyHandle2);
 136   }
 137   return (Status);
 138 }
 139
 140
 141
 142 /**
 143   The entry point for the application.
 144
 145   @param[in] ImageHandle    The firmware allocated handle for the EFI image.
 146   @param[in] SystemTable    A pointer to the EFI System Table.
 147
 148   @retval EFI_SUCCESS       The entry point is executed successfully.
 149   @retval other             Some error occurs when executing this entry point.
 150
 151 **/
 152 EFI_STATUS
 153 EFIAPI
 154 UefiMain (
 155   IN EFI_HANDLE        ImageHandle,
 156   IN EFI_SYSTEM_TABLE  *SystemTable
 157   )
 158 {
 159   EFI_STATUS                      Status;
 160   CHAR16                          *TempString;
 161   UINTN                           Size;
 162   EFI_HANDLE                      ConInHandle;
 163   EFI_SIMPLE_TEXT_INPUT_PROTOCOL  *OldConIn;
 164
 165   if (PcdGet8(PcdShellSupportLevel) > 3) {
 166     return (EFI_UNSUPPORTED);
 167   }
 168
 169   //
 170   // Clear the screen
 171   //
 172   Status = gST->ConOut->ClearScreen(gST->ConOut);
 173   if (EFI_ERROR(Status)) {
 174     return (Status);
 175   }
 176
 177   //
 178   // Populate the global structure from PCDs
 179   //
 180   ShellInfoObject.ImageDevPath                = NULL;
 181   ShellInfoObject.FileDevPath                 = NULL;
 182   ShellInfoObject.PageBreakEnabled            = PcdGetBool(PcdShellPageBreakDefault);
 183   ShellInfoObject.ViewingSettings.InsertMode  = PcdGetBool(PcdShellInsertModeDefault);
 184   ShellInfoObject.LogScreenCount              = PcdGet8   (PcdShellScreenLogCount  );
 185
 186   //
 187   // verify we dont allow for spec violation
 188   //
 189   ASSERT(ShellInfoObject.LogScreenCount >= 3);
 190
 191   //
 192   // Initialize the LIST ENTRY objects...
 193   //
 194   InitializeListHead(&ShellInfoObject.BufferToFreeList.Link);
 195   InitializeListHead(&ShellInfoObject.ViewingSettings.CommandHistory.Link);
 196   InitializeListHead(&ShellInfoObject.SplitList.Link);
 197
 198   //
 199   // Check PCDs for optional features that are not implemented yet.
 200   //
 201   if (   PcdGetBool(PcdShellSupportOldProtocols)
 202       || !FeaturePcdGet(PcdShellRequireHiiPlatform)
 203       || FeaturePcdGet(PcdShellSupportFrameworkHii)
 204    ) {
 205     return (EFI_UNSUPPORTED);
 206   }
 207
 208   //
 209   // turn off the watchdog timer
 210   //
 211   gBS->SetWatchdogTimer (0, 0, 0, NULL);
 212
 213   //
 214   // install our console logger.  This will keep a log of the output for back-browsing
 215   //
 216   Status = ConsoleLoggerInstall(ShellInfoObject.LogScreenCount, &ShellInfoObject.ConsoleInfo);
 217   if (!EFI_ERROR(Status)) {
 218     //
 219     // Enable the cursor to be visible
 220     //
 221     gST->ConOut->EnableCursor (gST->ConOut, TRUE);
 222
 223     //
 224     // If supporting EFI 1.1 we need to install HII protocol
 225     // only do this if PcdShellRequireHiiPlatform == FALSE
 226     //
 227     // remove EFI_UNSUPPORTED check above when complete.
 228     ///@todo add support for Framework HII
 229
 230     //
 231     // install our (solitary) HII package
 232     //
 233     ShellInfoObject.HiiHandle = HiiAddPackages (&gEfiCallerIdGuid, gImageHandle, ShellStrings, NULL);
 234     if (ShellInfoObject.HiiHandle == NULL) {
 235       if (PcdGetBool(PcdShellSupportFrameworkHii)) {
 236         ///@todo Add our package into Framework HII
 237       }
 238       if (ShellInfoObject.HiiHandle == NULL) {
 239         return (EFI_NOT_STARTED);
 240       }
 241     }
 242
 243     //
 244     // create and install the EfiShellParametersProtocol
 245     //
 246     Status = CreatePopulateInstallShellParametersProtocol(&ShellInfoObject.NewShellParametersProtocol, &ShellInfoObject.RootShellInstance);
 247     ASSERT_EFI_ERROR(Status);
 248     ASSERT(ShellInfoObject.NewShellParametersProtocol != NULL);
 249
 250     //
 251     // create and install the EfiShellProtocol
 252     //
 253     Status = CreatePopulateInstallShellProtocol(&ShellInfoObject.NewEfiShellProtocol);
 254     ASSERT_EFI_ERROR(Status);
 255     ASSERT(ShellInfoObject.NewEfiShellProtocol != NULL);
 256
 257     //
 258     // Now initialize the shell library (it requires Shell Parameters protocol)
 259     //
 260     Status = ShellInitialize();
 261     ASSERT_EFI_ERROR(Status);
 262
 263     Status = CommandInit();
 264     ASSERT_EFI_ERROR(Status);
 265
 266     //
 267     // Check the command line
 268     //
 269     Status = ProcessCommandLine();
 270
 271     //
 272     // If shell support level is >= 1 create the mappings and paths
 273     //
 274     if (PcdGet8(PcdShellSupportLevel) >= 1) {
 275       Status = ShellCommandCreateInitialMappingsAndPaths();
 276     }
 277
 278     //
 279     // save the device path for the loaded image and the device path for the filepath (under loaded image)
 280     // These are where to look for the startup.nsh file
 281     //
 282     Status = GetDevicePathsForImageAndFile(&ShellInfoObject.ImageDevPath, &ShellInfoObject.FileDevPath);
 283     ASSERT_EFI_ERROR(Status);
 284
 285     //
 286     // Display the version
 287     //
 288     if (!ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoVersion) {
 289       ShellPrintHiiEx (
 290         0,
 291         gST->ConOut->Mode->CursorRow,
 292         NULL,
 293         STRING_TOKEN (STR_VER_OUTPUT_MAIN),
 294         ShellInfoObject.HiiHandle,
 295         SupportLevel[PcdGet8(PcdShellSupportLevel)],
 296         gEfiShellProtocol->MajorVersion,
 297         gEfiShellProtocol->MinorVersion,
 298         (gST->Hdr.Revision&0xffff0000)>>16,
 299         (gST->Hdr.Revision&0x0000ffff),
 300         gST->FirmwareVendor,
 301         gST->FirmwareRevision
 302        );
 303     }
 304
 305     //
 306     // Display the mapping
 307     //
 308     if (PcdGet8(PcdShellSupportLevel) >= 2 && !ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoMap) {
 309       Status = RunCommand(L"map");
 310       ASSERT_EFI_ERROR(Status);
 311     }
 312
 313     //
 314     // init all the built in alias'
 315     //
 316     Status = SetBuiltInAlias();
 317     ASSERT_EFI_ERROR(Status);
 318
 319     //
 320     // Initialize environment variables
 321     //
 322     if (ShellCommandGetProfileList() != NULL) {
 323       Status = InternalEfiShellSetEnv(L"profiles", ShellCommandGetProfileList(), TRUE);
 324       ASSERT_EFI_ERROR(Status);
 325     }
 326
 327     Size        = 100;
 328     TempString  = AllocateZeroPool(Size);
 329
 330     UnicodeSPrint(TempString, Size, L"%d", PcdGet8(PcdShellSupportLevel));
 331     Status = InternalEfiShellSetEnv(L"uefishellsupport", TempString, TRUE);
 332     ASSERT_EFI_ERROR(Status);
 333
 334     UnicodeSPrint(TempString, Size, L"%d.%d", ShellInfoObject.NewEfiShellProtocol->MajorVersion, ShellInfoObject.NewEfiShellProtocol->MinorVersion);
 335     Status = InternalEfiShellSetEnv(L"uefishellversion", TempString, TRUE);
 336     ASSERT_EFI_ERROR(Status);
 337
 338     UnicodeSPrint(TempString, Size, L"%d.%d", (gST->Hdr.Revision & 0xFFFF0000) >> 16, gST->Hdr.Revision & 0x0000FFFF);
 339     Status = InternalEfiShellSetEnv(L"uefiversion", TempString, TRUE);
 340     ASSERT_EFI_ERROR(Status);
 341
 342     FreePool(TempString);
 343
 344     if (!EFI_ERROR(Status)) {
 345       if (!ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoInterrupt) {
 346         //
 347         // Set up the event for CTRL-C monitoring...
 348         //
 349         Status = InernalEfiShellStartMonitor();
 350       }
 351
 352       if (!EFI_ERROR(Status) && !ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn) {
 353         //
 354         // Set up the event for CTRL-S monitoring...
 355         //
 356         Status = InternalEfiShellStartCtrlSMonitor();
 357       }
 358
 359       if (!EFI_ERROR(Status) && ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn) {
 360         //
 361         // close off the gST->ConIn
 362         //
 363         OldConIn      = gST->ConIn;
 364         ConInHandle   = gST->ConsoleInHandle;
 365         gST->ConIn = CreateSimpleTextInOnFile((SHELL_FILE_HANDLE)&FileInterfaceNulFile, &gST->ConsoleInHandle);
 366       } else {
 367         OldConIn      = NULL;
 368         ConInHandle   = NULL;
 369       }
 370
 371       if (!EFI_ERROR(Status) && PcdGet8(PcdShellSupportLevel) >= 1) {
 372         //
 373         // process the startup script or launch the called app.
 374         //
 375         Status = DoStartupScript(ShellInfoObject.ImageDevPath, ShellInfoObject.FileDevPath);
 376       }
 377
 378       if (!ShellCommandGetExit() && (PcdGet8(PcdShellSupportLevel) >= 3 || PcdGetBool(PcdShellForceConsole)) && !EFI_ERROR(Status) && !ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn) {
 379         //
 380         // begin the UI waiting loop
 381         //
 382         do {
 383           //
 384           // clean out all the memory allocated for CONST <something> * return values
 385           // between each shell prompt presentation
 386           //
 387           if (!IsListEmpty(&ShellInfoObject.BufferToFreeList.Link)){
 388             FreeBufferList(&ShellInfoObject.BufferToFreeList);
 389           }
 390
 391           //
 392           // Reset page break back to default.
 393           //
 394           ShellInfoObject.PageBreakEnabled        = PcdGetBool(PcdShellPageBreakDefault);
 395           ShellInfoObject.ConsoleInfo->Enabled    = TRUE;
 396           ShellInfoObject.ConsoleInfo->RowCounter = 0;
 397
 398           //
 399           // Reset the CTRL-C event (yes we ignore the return values)
 400           //
 401           Status = gBS->CheckEvent (ShellInfoObject.NewEfiShellProtocol->ExecutionBreak);
 402
 403           //
 404           // Display Prompt
 405           //
 406           Status = DoShellPrompt();
 407         } while (!ShellCommandGetExit());
 408       }
 409       if (OldConIn != NULL && ConInHandle != NULL) {
 410         CloseSimpleTextInOnFile (gST->ConIn);
 411         gST->ConIn            = OldConIn;
 412         gST->ConsoleInHandle  = ConInHandle;
 413       }
 414     }
 415   }
 416
 417   //
 418   // uninstall protocols / free memory / etc...
 419   //
 420   if (ShellInfoObject.UserBreakTimer != NULL) {
 421     gBS->CloseEvent(ShellInfoObject.UserBreakTimer);
 422     DEBUG_CODE(ShellInfoObject.UserBreakTimer = NULL;);
 423   }
 424   if (ShellInfoObject.ImageDevPath != NULL) {
 425     FreePool(ShellInfoObject.ImageDevPath);
 426     DEBUG_CODE(ShellInfoObject.ImageDevPath = NULL;);
 427   }
 428   if (ShellInfoObject.FileDevPath != NULL) {
 429     FreePool(ShellInfoObject.FileDevPath);
 430     DEBUG_CODE(ShellInfoObject.FileDevPath = NULL;);
 431   }
 432   if (ShellInfoObject.NewShellParametersProtocol != NULL) {
 433     CleanUpShellParametersProtocol(ShellInfoObject.NewShellParametersProtocol);
 434     DEBUG_CODE(ShellInfoObject.NewShellParametersProtocol = NULL;);
 435   }
 436   if (ShellInfoObject.NewEfiShellProtocol != NULL){
 437     if (ShellInfoObject.NewEfiShellProtocol->IsRootShell()){
 438       ShellInfoObject.NewEfiShellProtocol->SetEnv(L"cwd", L"", TRUE);
 439     }
 440     CleanUpShellProtocol(ShellInfoObject.NewEfiShellProtocol);
 441     DEBUG_CODE(ShellInfoObject.NewEfiShellProtocol = NULL;);
 442   }
 443
 444   if (!IsListEmpty(&ShellInfoObject.BufferToFreeList.Link)){
 445     FreeBufferList(&ShellInfoObject.BufferToFreeList);
 446   }
 447
 448   if (!IsListEmpty(&ShellInfoObject.SplitList.Link)){
 449     ASSERT(FALSE); ///@todo finish this de-allocation.
 450   }
 451
 452   if (ShellInfoObject.ShellInitSettings.FileName != NULL) {
 453     FreePool(ShellInfoObject.ShellInitSettings.FileName);
 454     DEBUG_CODE(ShellInfoObject.ShellInitSettings.FileName = NULL;);
 455   }
 456
 457   if (ShellInfoObject.ShellInitSettings.FileOptions != NULL) {
 458     FreePool(ShellInfoObject.ShellInitSettings.FileOptions);
 459     DEBUG_CODE(ShellInfoObject.ShellInitSettings.FileOptions = NULL;);
 460   }
 461
 462   if (ShellInfoObject.HiiHandle != NULL) {
 463     HiiRemovePackages(ShellInfoObject.HiiHandle);
 464     DEBUG_CODE(ShellInfoObject.HiiHandle = NULL;);
 465   }
 466
 467   if (!IsListEmpty(&ShellInfoObject.ViewingSettings.CommandHistory.Link)){
 468     FreeBufferList(&ShellInfoObject.ViewingSettings.CommandHistory);
 469   }
 470
 471   ASSERT(ShellInfoObject.ConsoleInfo != NULL);
 472   if (ShellInfoObject.ConsoleInfo != NULL) {
 473     ConsoleLoggerUninstall(ShellInfoObject.ConsoleInfo);
 474     FreePool(ShellInfoObject.ConsoleInfo);
 475     DEBUG_CODE(ShellInfoObject.ConsoleInfo = NULL;);
 476   }
 477
 478   if (ShellCommandGetExit()) {
 479     return ((EFI_STATUS)ShellCommandGetExitCode());
 480   }
 481   return (Status);
 482 }
 483
 484 /**
 485   Sets all the alias' that were registered with the ShellCommandLib library.
 486
 487   @retval EFI_SUCCESS           all init commands were run sucessfully.
 488 **/
 489 EFI_STATUS
 490 EFIAPI
 491 SetBuiltInAlias(
 492   )
 493 {
 494   EFI_STATUS          Status;
 495   CONST ALIAS_LIST    *List;
 496   ALIAS_LIST          *Node;
 497
 498   //
 499   // Get all the commands we want to run
 500   //
 501   List = ShellCommandGetInitAliasList();
 502
 503   //
 504   // for each command in the List
 505   //
 506   for ( Node = (ALIAS_LIST*)GetFirstNode(&List->Link)
 507       ; !IsNull (&List->Link, &Node->Link)
 508       ; Node = (ALIAS_LIST *)GetNextNode(&List->Link, &Node->Link)
 509    ){
 510     //
 511     // install the alias'
 512     //
 513     Status = InternalSetAlias(Node->CommandString, Node->Alias, TRUE);
 514     ASSERT_EFI_ERROR(Status);
 515   }
 516   return (EFI_SUCCESS);
 517 }
 518
 519 /**
 520   Internal function to determine if 2 command names are really the same.
 521
 522   @param[in] Command1       The pointer to the first command name.
 523   @param[in] Command2       The pointer to the second command name.
 524
 525   @retval TRUE              The 2 command names are the same.
 526   @retval FALSE             The 2 command names are not the same.
 527 **/
 528 BOOLEAN
 529 EFIAPI
 530 IsCommand(
 531   IN CONST CHAR16 *Command1,
 532   IN CONST CHAR16 *Command2
 533   )
 534 {
 535   if (StringNoCaseCompare(&Command1, &Command2) == 0) {
 536     return (TRUE);
 537   }
 538   return (FALSE);
 539 }
 540
 541 /**
 542   Internal function to determine if a command is a script only command.
 543
 544   @param[in] CommandName    The pointer to the command name.
 545
 546   @retval TRUE              The command is a script only command.
 547   @retval FALSE             The command is not a script only command.
 548 **/
 549 BOOLEAN
 550 EFIAPI
 551 IsScriptOnlyCommand(
 552   IN CONST CHAR16 *CommandName
 553   )
 554 {
 555   if (IsCommand(CommandName, L"for")
 556     ||IsCommand(CommandName, L"endfor")
 557     ||IsCommand(CommandName, L"if")
 558     ||IsCommand(CommandName, L"else")
 559     ||IsCommand(CommandName, L"endif")
 560     ||IsCommand(CommandName, L"goto")) {
 561     return (TRUE);
 562   }
 563   return (FALSE);
 564 }
 565
 566 /**
 567   This function will populate the 2 device path protocol parameters based on the
 568   global gImageHandle.  The DevPath will point to the device path for the handle that has
 569   loaded image protocol installed on it.  The FilePath will point to the device path
 570   for the file that was loaded.
 571
 572   @param[in, out] DevPath       On a sucessful return the device path to the loaded image.
 573   @param[in, out] FilePath      On a sucessful return the device path to the file.
 574
 575   @retval EFI_SUCCESS           The 2 device paths were sucessfully returned.
 576   @retval other                 A error from gBS->HandleProtocol.
 577
 578   @sa HandleProtocol
 579 **/
 580 EFI_STATUS
 581 EFIAPI
 582 GetDevicePathsForImageAndFile (
 583   IN OUT EFI_DEVICE_PATH_PROTOCOL **DevPath,
 584   IN OUT EFI_DEVICE_PATH_PROTOCOL **FilePath
 585   )
 586 {
 587   EFI_STATUS                Status;
 588   EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
 589   EFI_DEVICE_PATH_PROTOCOL  *ImageDevicePath;
 590
 591   ASSERT(DevPath  != NULL);
 592   ASSERT(FilePath != NULL);
 593
 594   Status = gBS->OpenProtocol (
 595                 gImageHandle,
 596                 &gEfiLoadedImageProtocolGuid,
 597                 (VOID**)&LoadedImage,
 598                 gImageHandle,
 599                 NULL,
 600                 EFI_OPEN_PROTOCOL_GET_PROTOCOL
 601                );
 602   if (!EFI_ERROR (Status)) {
 603     Status = gBS->OpenProtocol (
 604                   LoadedImage->DeviceHandle,
 605                   &gEfiDevicePathProtocolGuid,
 606                   (VOID**)&ImageDevicePath,
 607                   gImageHandle,
 608                   NULL,
 609                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 610                  );
 611     if (!EFI_ERROR (Status)) {
 612       *DevPath  = DuplicateDevicePath (ImageDevicePath);
 613       *FilePath = DuplicateDevicePath (LoadedImage->FilePath);
 614       gBS->CloseProtocol(
 615                   LoadedImage->DeviceHandle,
 616                   &gEfiDevicePathProtocolGuid,
 617                   gImageHandle,
 618                   NULL);
 619     }
 620     gBS->CloseProtocol(
 621                 gImageHandle,
 622                 &gEfiLoadedImageProtocolGuid,
 623                 gImageHandle,
 624                 NULL);
 625   }
 626   return (Status);
 627 }
 628
 629 STATIC CONST SHELL_PARAM_ITEM mShellParamList[] = {
 630   {L"-nostartup",     TypeFlag},
 631   {L"-startup",       TypeFlag},
 632   {L"-noconsoleout",  TypeFlag},
 633   {L"-noconsolein",   TypeFlag},
 634   {L"-nointerrupt",   TypeFlag},
 635   {L"-nomap",         TypeFlag},
 636   {L"-noversion",     TypeFlag},
 637   {L"-startup",       TypeFlag},
 638   {L"-delay",         TypeValue},
 639   {NULL, TypeMax}
 640   };
 641
 642 /**
 643   Process all Uefi Shell 2.0 command line options.
 644
 645   see Uefi Shell 2.0 section 3.2 for full details.
 646
 647   the command line must resemble the following:
 648
 649   shell.efi [ShellOpt-options] [options] [file-name [file-name-options]]
 650
 651   ShellOpt-options  Options which control the initialization behavior of the shell.
 652                     These options are read from the EFI global variable "ShellOpt"
 653                     and are processed before options or file-name.
 654
 655   options           Options which control the initialization behavior of the shell.
 656
 657   file-name         The name of a UEFI shell application or script to be executed
 658                     after initialization is complete. By default, if file-name is
 659                     specified, then -nostartup is implied. Scripts are not supported
 660                     by level 0.
 661
 662   file-name-options The command-line options that are passed to file-name when it
 663                     is invoked.
 664
 665   This will initialize the ShellInfoObject.ShellInitSettings global variable.
 666
 667   @retval EFI_SUCCESS           The variable is initialized.
 668 **/
 669 EFI_STATUS
 670 EFIAPI
 671 ProcessCommandLine(
 672   VOID
 673   )
 674 {
 675   EFI_STATUS    Status;
 676   LIST_ENTRY    *Package;
 677   UINTN         Size;
 678   CONST CHAR16  *TempConst;
 679   UINTN         Count;
 680   UINTN         LoopVar;
 681   CHAR16        *ProblemParam;
 682   UINT64        Intermediate;
 683
 684   Package       = NULL;
 685   ProblemParam  = NULL;
 686
 687   Status = ShellCommandLineParse (mShellParamList, &Package, NULL, FALSE);
 688
 689   Count = 1;
 690   Size = 0;
 691   TempConst = ShellCommandLineGetRawValue(Package, Count++);
 692   if (TempConst != NULL && StrLen(TempConst)) {
 693     ShellInfoObject.ShellInitSettings.FileName = AllocateZeroPool(StrSize(TempConst));
 694     if (ShellInfoObject.ShellInitSettings.FileName == NULL) {
 695       return (EFI_OUT_OF_RESOURCES);
 696     }
 697     StrCpy(ShellInfoObject.ShellInitSettings.FileName, TempConst);
 698     ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoStartup = 1;
 699     for (LoopVar = 0 ; LoopVar < gEfiShellParametersProtocol->Argc ; LoopVar++) {
 700       if (StrCmp(gEfiShellParametersProtocol->Argv[LoopVar], ShellInfoObject.ShellInitSettings.FileName)==0) {
 701         LoopVar++;
 702         //
 703         // We found the file... add the rest of the params...
 704         //
 705         for ( ; LoopVar < gEfiShellParametersProtocol->Argc ; LoopVar++) {
 706           ASSERT((ShellInfoObject.ShellInitSettings.FileOptions == NULL && Size == 0) || (ShellInfoObject.ShellInitSettings.FileOptions != NULL));
 707           StrnCatGrow(&ShellInfoObject.ShellInitSettings.FileOptions,
 708                       &Size,
 709                       L" ",
 710                       0);
 711           if (ShellInfoObject.ShellInitSettings.FileOptions == NULL) {
 712             SHELL_FREE_NON_NULL(ShellInfoObject.ShellInitSettings.FileName);
 713             return (EFI_OUT_OF_RESOURCES);
 714           }
 715           StrnCatGrow(&ShellInfoObject.ShellInitSettings.FileOptions,
 716                       &Size,
 717                       gEfiShellParametersProtocol->Argv[LoopVar],
 718                       0);
 719           if (ShellInfoObject.ShellInitSettings.FileOptions == NULL) {
 720             SHELL_FREE_NON_NULL(ShellInfoObject.ShellInitSettings.FileName);
 721             return (EFI_OUT_OF_RESOURCES);
 722           }
 723         }
 724       }
 725     }
 726   } else {
 727     ShellCommandLineFreeVarList(Package);
 728     Package = NULL;
 729     Status = ShellCommandLineParse (mShellParamList, &Package, &ProblemParam, FALSE);
 730     if (EFI_ERROR(Status)) {
 731       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), ShellInfoObject.HiiHandle, ProblemParam);
 732       FreePool(ProblemParam);
 733       ShellCommandLineFreeVarList(Package);
 734       return (EFI_INVALID_PARAMETER);
 735     }
 736   }
 737
 738   ShellInfoObject.ShellInitSettings.BitUnion.Bits.Startup      = ShellCommandLineGetFlag(Package, L"-startup");
 739   ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoStartup    = ShellCommandLineGetFlag(Package, L"-nostartup");
 740   ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleOut = ShellCommandLineGetFlag(Package, L"-noconsoleout");
 741   ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn  = ShellCommandLineGetFlag(Package, L"-noconsolein");
 742   ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoInterrupt  = ShellCommandLineGetFlag(Package, L"-nointerrupt");
 743   ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoMap        = ShellCommandLineGetFlag(Package, L"-nomap");
 744   ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoVersion    = ShellCommandLineGetFlag(Package, L"-noversion");
 745   ShellInfoObject.ShellInitSettings.BitUnion.Bits.Delay        = ShellCommandLineGetFlag(Package, L"-delay");
 746
 747   ShellInfoObject.ShellInitSettings.Delay = 5;
 748
 749   if (ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoInterrupt) {
 750     ShellInfoObject.ShellInitSettings.Delay = 0;
 751   } else if (ShellInfoObject.ShellInitSettings.BitUnion.Bits.Delay) {
 752     TempConst = ShellCommandLineGetValue(Package, L"-delay");
 753     if (TempConst != NULL && *TempConst == L':') {
 754       TempConst++;
 755     }
 756     if (TempConst != NULL && !EFI_ERROR(ShellConvertStringToUint64(TempConst, &Intermediate, FALSE, FALSE))) {
 757       ShellInfoObject.ShellInitSettings.Delay = (UINTN)Intermediate;
 758     }
 759   }
 760   ShellCommandLineFreeVarList(Package);
 761
 762   return (Status);
 763 }
 764
 765 /**
 766   Handles all interaction with the default startup script.
 767
 768   this will check that the correct command line parameters were passed, handle the delay, and then start running the script.
 769
 770   @param ImagePath              the path to the image for shell.  first place to look for the startup script
 771   @param FilePath               the path to the file for shell.  second place to look for the startup script.
 772
 773   @retval EFI_SUCCESS           the variable is initialized.
 774 **/
 775 EFI_STATUS
 776 EFIAPI
 777 DoStartupScript(
 778   EFI_DEVICE_PATH_PROTOCOL *ImagePath,
 779   EFI_DEVICE_PATH_PROTOCOL *FilePath
 780   )
 781 {
 782   EFI_STATUS                    Status;
 783   UINTN                         Delay;
 784   EFI_INPUT_KEY                 Key;
 785   SHELL_FILE_HANDLE             FileHandle;
 786   EFI_DEVICE_PATH_PROTOCOL      *NewPath;
 787   EFI_DEVICE_PATH_PROTOCOL      *NamePath;
 788   CHAR16                        *FileStringPath;
 789   CHAR16                        *TempSpot;
 790   UINTN                         NewSize;
 791   CONST CHAR16                  *MapName;
 792
 793   Key.UnicodeChar = CHAR_NULL;
 794   Key.ScanCode    = 0;
 795   FileHandle      = NULL;
 796
 797   if (!ShellInfoObject.ShellInitSettings.BitUnion.Bits.Startup && ShellInfoObject.ShellInitSettings.FileName != NULL) {
 798     //
 799     // launch something else instead
 800     //
 801     NewSize = StrSize(ShellInfoObject.ShellInitSettings.FileName);
 802     if (ShellInfoObject.ShellInitSettings.FileOptions != NULL) {
 803       NewSize += StrSize(ShellInfoObject.ShellInitSettings.FileOptions) + sizeof(CHAR16);
 804     }
 805     FileStringPath = AllocateZeroPool(NewSize);
 806     if (FileStringPath == NULL) {
 807       return (EFI_OUT_OF_RESOURCES);
 808     }
 809     StrCpy(FileStringPath, ShellInfoObject.ShellInitSettings.FileName);
 810     if (ShellInfoObject.ShellInitSettings.FileOptions != NULL) {
 811       StrCat(FileStringPath, L" ");
 812       StrCat(FileStringPath, ShellInfoObject.ShellInitSettings.FileOptions);
 813     }
 814     Status = RunCommand(FileStringPath);
 815     FreePool(FileStringPath);
 816     return (Status);
 817
 818   }
 819
 820   //
 821   // for shell level 0 we do no scripts
 822   // Without the Startup bit overriding we allow for nostartup to prevent scripts
 823   //
 824   if ( (PcdGet8(PcdShellSupportLevel) < 1)
 825     || (ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoStartup && !ShellInfoObject.ShellInitSettings.BitUnion.Bits.Startup)
 826    ){
 827     return (EFI_SUCCESS);
 828   }
 829
 830   gST->ConOut->EnableCursor(gST->ConOut, FALSE);
 831   //
 832   // print out our warning and see if they press a key
 833   //
 834   for ( Status = EFI_UNSUPPORTED, Delay = ShellInfoObject.ShellInitSettings.Delay * 10
 835       ; Delay != 0 && EFI_ERROR(Status)
 836       ; Delay--
 837      ){
 838     ShellPrintHiiEx(0, gST->ConOut->Mode->CursorRow, NULL, STRING_TOKEN (STR_SHELL_STARTUP_QUESTION), ShellInfoObject.HiiHandle, Delay/10);
 839     gBS->Stall (100000);
 840     if (!ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn) {
 841       Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
 842     }
 843   }
 844   ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_CRLF), ShellInfoObject.HiiHandle);
 845   gST->ConOut->EnableCursor(gST->ConOut, TRUE);
 846
 847   //
 848   // ESC was pressed
 849   //
 850   if (Status == EFI_SUCCESS && Key.UnicodeChar == 0 && Key.ScanCode == SCAN_ESC) {
 851     return (EFI_SUCCESS);
 852   }
 853
 854   //
 855   // Try the first location (must be file system)
 856   //
 857   MapName = ShellInfoObject.NewEfiShellProtocol->GetMapFromDevicePath(&ImagePath);
 858   if (MapName != NULL) {
 859     FileStringPath = NULL;
 860     NewSize = 0;
 861     FileStringPath = StrnCatGrow(&FileStringPath, &NewSize, MapName, 0);
 862     if (FileStringPath == NULL) {
 863       Status = EFI_OUT_OF_RESOURCES;
 864     } else {
 865       TempSpot = StrStr(FileStringPath, L";");
 866       if (TempSpot != NULL) {
 867         *TempSpot = CHAR_NULL;
 868       }
 869       FileStringPath = StrnCatGrow(&FileStringPath, &NewSize, ((FILEPATH_DEVICE_PATH*)FilePath)->PathName, 0);
 870       PathRemoveLastItem(FileStringPath);
 871       FileStringPath = StrnCatGrow(&FileStringPath, &NewSize, mStartupScript, 0);
 872       Status = ShellInfoObject.NewEfiShellProtocol->OpenFileByName(FileStringPath, &FileHandle, EFI_FILE_MODE_READ);
 873       FreePool(FileStringPath);
 874     }
 875   }
 876   if (EFI_ERROR(Status)) {
 877     NamePath = FileDevicePath (NULL, mStartupScript);
 878     NewPath = AppendDevicePathNode (ImagePath, NamePath);
 879     FreePool(NamePath);
 880
 881     //
 882     // Try the location
 883     //
 884     Status = InternalOpenFileDevicePath(NewPath, &FileHandle, EFI_FILE_MODE_READ, 0);
 885     FreePool(NewPath);
 886   }
 887   //
 888   // If we got a file, run it
 889   //
 890   if (!EFI_ERROR(Status) && FileHandle != NULL) {
 891     Status = RunScriptFileHandle (FileHandle, mStartupScript);
 892     ShellInfoObject.NewEfiShellProtocol->CloseFile(FileHandle);
 893   } else {
 894     FileStringPath = ShellFindFilePath(mStartupScript);
 895     if (FileStringPath == NULL) {
 896       //
 897       // we return success since we dont need to have a startup script
 898       //
 899       Status = EFI_SUCCESS;
 900       ASSERT(FileHandle == NULL);
 901     } else {
 902       Status = RunScriptFile(FileStringPath);
 903       FreePool(FileStringPath);
 904     }
 905   }
 906
 907
 908   return (Status);
 909 }
 910
 911 /**
 912   Function to perform the shell prompt looping.  It will do a single prompt,
 913   dispatch the result, and then return.  It is expected that the caller will
 914   call this function in a loop many times.
 915
 916   @retval EFI_SUCCESS
 917   @retval RETURN_ABORTED
 918 **/
 919 EFI_STATUS
 920 EFIAPI
 921 DoShellPrompt (
 922   VOID
 923   )
 924 {
 925   UINTN         Column;
 926   UINTN         Row;
 927   CHAR16        *CmdLine;
 928   CONST CHAR16  *CurDir;
 929   UINTN         BufferSize;
 930   EFI_STATUS    Status;
 931
 932   CurDir  = NULL;
 933
 934   //
 935   // Get screen setting to decide size of the command line buffer
 936   //
 937   gST->ConOut->QueryMode (gST->ConOut, gST->ConOut->Mode->Mode, &Column, &Row);
 938   BufferSize  = Column * Row * sizeof (CHAR16);
 939   CmdLine     = AllocateZeroPool (BufferSize);
 940   if (CmdLine == NULL) {
 941     return EFI_OUT_OF_RESOURCES;
 942   }
 943
 944   CurDir = ShellInfoObject.NewEfiShellProtocol->GetEnv(L"cwd");
 945
 946   //
 947   // Prompt for input
 948   //
 949   gST->ConOut->SetCursorPosition (gST->ConOut, 0, gST->ConOut->Mode->CursorRow);
 950
 951   if (CurDir != NULL && StrLen(CurDir) > 1) {
 952     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_CURDIR), ShellInfoObject.HiiHandle, CurDir);
 953   } else {
 954     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_SHELL), ShellInfoObject.HiiHandle);
 955   }
 956
 957   //
 958   // Read a line from the console
 959   //
 960   Status = ShellInfoObject.NewEfiShellProtocol->ReadFile(ShellInfoObject.NewShellParametersProtocol->StdIn, &BufferSize, CmdLine);
 961
 962   //
 963   // Null terminate the string and parse it
 964   //
 965   if (!EFI_ERROR (Status)) {
 966     CmdLine[BufferSize / sizeof (CHAR16)] = CHAR_NULL;
 967     Status = RunCommand(CmdLine);
 968   }
 969
 970   //
 971   // Done with this command
 972   //
 973   FreePool (CmdLine);
 974   return Status;
 975 }
 976
 977 /**
 978   Add a buffer to the Buffer To Free List for safely returning buffers to other
 979   places without risking letting them modify internal shell information.
 980
 981   @param Buffer   Something to pass to FreePool when the shell is exiting.
 982 **/
 983 VOID*
 984 EFIAPI
 985 AddBufferToFreeList(
 986   VOID *Buffer
 987   )
 988 {
 989   BUFFER_LIST   *BufferListEntry;
 990
 991   if (Buffer == NULL) {
 992     return (NULL);
 993   }
 994
 995   BufferListEntry = AllocateZeroPool(sizeof(BUFFER_LIST));
 996   ASSERT(BufferListEntry != NULL);
 997   BufferListEntry->Buffer = Buffer;
 998   InsertTailList(&ShellInfoObject.BufferToFreeList.Link, &BufferListEntry->Link);
 999   return (Buffer);
1000 }
1001
1002 /**
1003   Add a buffer to the Line History List
1004
1005   @param Buffer     The line buffer to add.
1006 **/
1007 VOID
1008 EFIAPI
1009 AddLineToCommandHistory(
1010   IN CONST CHAR16 *Buffer
1011   )
1012 {
1013   BUFFER_LIST *Node;
1014
1015   Node = AllocateZeroPool(sizeof(BUFFER_LIST));
1016   ASSERT(Node != NULL);
1017   Node->Buffer = AllocateZeroPool(StrSize(Buffer));
1018   ASSERT(Node->Buffer != NULL);
1019   StrCpy(Node->Buffer, Buffer);
1020
1021   InsertTailList(&ShellInfoObject.ViewingSettings.CommandHistory.Link, &Node->Link);
1022 }
1023
1024 /**
1025   Checks if a string is an alias for another command.  If yes, then it replaces the alias name
1026   with the correct command name.
1027
1028   @param[in, out] CommandString    Upon entry the potential alias.  Upon return the
1029                                    command name if it was an alias.  If it was not
1030                                    an alias it will be unchanged.  This function may
1031                                    change the buffer to fit the command name.
1032
1033   @retval EFI_SUCCESS             The name was changed.
1034   @retval EFI_SUCCESS             The name was not an alias.
1035   @retval EFI_OUT_OF_RESOURCES    A memory allocation failed.
1036 **/
1037 EFI_STATUS
1038 EFIAPI
1039 ShellConvertAlias(
1040   IN OUT CHAR16 **CommandString
1041   )
1042 {
1043   CONST CHAR16  *NewString;
1044
1045   NewString = ShellInfoObject.NewEfiShellProtocol->GetAlias(*CommandString, NULL);
1046   if (NewString == NULL) {
1047     return (EFI_SUCCESS);
1048   }
1049   FreePool(*CommandString);
1050   *CommandString = AllocateZeroPool(StrSize(NewString));
1051   if (*CommandString == NULL) {
1052     return (EFI_OUT_OF_RESOURCES);
1053   }
1054   StrCpy(*CommandString, NewString);
1055   return (EFI_SUCCESS);
1056 }
1057
1058 /**
1059   Function allocates a new command line and replaces all instances of environment
1060   variable names that are correctly preset to their values.
1061
1062   If the return value is not NULL the memory must be caller freed.
1063
1064   @param[in] OriginalCommandLine    The original command line
1065
1066   @retval NULL                      An error ocurred.
1067   @return                           The new command line with no environment variables present.
1068 **/
1069 CHAR16*
1070 EFIAPI
1071 ShellConvertVariables (
1072   IN CONST CHAR16 *OriginalCommandLine
1073   )
1074 {
1075   CONST CHAR16        *MasterEnvList;
1076   UINTN               NewSize;
1077   CHAR16              *NewCommandLine1;
1078   CHAR16              *NewCommandLine2;
1079   CHAR16              *Temp;
1080   UINTN               ItemSize;
1081   CHAR16              *ItemTemp;
1082   SCRIPT_FILE         *CurrentScriptFile;
1083   ALIAS_LIST          *AliasListNode;
1084
1085   ASSERT(OriginalCommandLine != NULL);
1086
1087   ItemSize          = 0;
1088   NewSize           = StrSize(OriginalCommandLine);
1089   CurrentScriptFile = ShellCommandGetCurrentScriptFile();
1090   Temp              = NULL;
1091
1092   ///@todo update this to handle the %0 - %9 for scripting only (borrow from line 1256 area) ? ? ?
1093
1094   //
1095   // calculate the size required for the post-conversion string...
1096   //
1097   if (CurrentScriptFile != NULL) {
1098     for (AliasListNode = (ALIAS_LIST*)GetFirstNode(&CurrentScriptFile->SubstList)
1099       ;  !IsNull(&CurrentScriptFile->SubstList, &AliasListNode->Link)
1100       ;  AliasListNode = (ALIAS_LIST*)GetNextNode(&CurrentScriptFile->SubstList, &AliasListNode->Link)
1101    ){
1102       for (Temp = StrStr(OriginalCommandLine, AliasListNode->Alias)
1103         ;  Temp != NULL
1104         ;  Temp = StrStr(Temp+1, AliasListNode->Alias)
1105        ){
1106         //
1107         // we need a preceeding and if there is space no ^ preceeding (if no space ignore)
1108         //
1109         if ((((Temp-OriginalCommandLine)>2) && *(Temp-2) != L'^') || ((Temp-OriginalCommandLine)<=2)) {
1110           NewSize += StrSize(AliasListNode->CommandString);
1111         }
1112       }
1113     }
1114   }
1115
1116   for (MasterEnvList = EfiShellGetEnv(NULL)
1117     ;  MasterEnvList != NULL && *MasterEnvList != CHAR_NULL //&& *(MasterEnvList+1) != CHAR_NULL
1118     ;  MasterEnvList += StrLen(MasterEnvList) + 1
1119    ){
1120     if (StrSize(MasterEnvList) > ItemSize) {
1121       ItemSize = StrSize(MasterEnvList);
1122     }
1123     for (Temp = StrStr(OriginalCommandLine, MasterEnvList)
1124       ;  Temp != NULL
1125       ;  Temp = StrStr(Temp+1, MasterEnvList)
1126      ){
1127       //
1128       // we need a preceeding and following % and if there is space no ^ preceeding (if no space ignore)
1129       //
1130       if (*(Temp-1) == L'%' && *(Temp+StrLen(MasterEnvList)) == L'%' &&
1131         ((((Temp-OriginalCommandLine)>2) && *(Temp-2) != L'^') || ((Temp-OriginalCommandLine)<=2))) {
1132         NewSize+=StrSize(EfiShellGetEnv(MasterEnvList));
1133       }
1134     }
1135   }
1136
1137   //
1138   // Quick out if none were found...
1139   //
1140   if (NewSize == StrSize(OriginalCommandLine)) {
1141     ASSERT(Temp == NULL);
1142     Temp = StrnCatGrow(&Temp, NULL, OriginalCommandLine, 0);
1143     return (Temp);
1144   }
1145
1146   //
1147   // now do the replacements...
1148   //
1149   NewCommandLine1 = AllocateZeroPool(NewSize);
1150   NewCommandLine2 = AllocateZeroPool(NewSize);
1151   ItemTemp        = AllocateZeroPool(ItemSize+(2*sizeof(CHAR16)));
1152   if (NewCommandLine1 == NULL || NewCommandLine2 == NULL || ItemTemp == NULL) {
1153     SHELL_FREE_NON_NULL(NewCommandLine1);
1154     SHELL_FREE_NON_NULL(NewCommandLine2);
1155     SHELL_FREE_NON_NULL(ItemTemp);
1156     return (NULL);
1157   }
1158   StrCpy(NewCommandLine1, OriginalCommandLine);
1159   for (MasterEnvList = EfiShellGetEnv(NULL)
1160     ;  MasterEnvList != NULL && *MasterEnvList != CHAR_NULL //&& *(MasterEnvList+1) != CHAR_NULL
1161     ;  MasterEnvList += StrLen(MasterEnvList) + 1
1162    ){
1163     StrCpy(ItemTemp, L"%");
1164     StrCat(ItemTemp, MasterEnvList);
1165     StrCat(ItemTemp, L"%");
1166     ShellCopySearchAndReplace(NewCommandLine1, NewCommandLine2, NewSize, ItemTemp, EfiShellGetEnv(MasterEnvList), TRUE, FALSE);
1167     StrCpy(NewCommandLine1, NewCommandLine2);
1168   }
1169   if (CurrentScriptFile != NULL) {
1170     for (AliasListNode = (ALIAS_LIST*)GetFirstNode(&CurrentScriptFile->SubstList)
1171       ;  !IsNull(&CurrentScriptFile->SubstList, &AliasListNode->Link)
1172       ;  AliasListNode = (ALIAS_LIST*)GetNextNode(&CurrentScriptFile->SubstList, &AliasListNode->Link)
1173    ){
1174     ShellCopySearchAndReplace(NewCommandLine1, NewCommandLine2, NewSize, AliasListNode->Alias, AliasListNode->CommandString, TRUE, FALSE);
1175     StrCpy(NewCommandLine1, NewCommandLine2);
1176     }
1177   }
1178
1179   FreePool(NewCommandLine2);
1180   FreePool(ItemTemp);
1181
1182   return (NewCommandLine1);
1183 }
1184
1185 /**
1186   Internal function to run a command line with pipe usage.
1187
1188   @param[in] CmdLine        The pointer to the command line.
1189   @param[in] StdIn          The pointer to the Standard input.
1190   @param[in] StdOut         The pointer to the Standard output.
1191
1192   @retval EFI_SUCCESS       The split command is executed successfully.
1193   @retval other             Some error occurs when executing the split command.
1194 **/
1195 EFI_STATUS
1196 EFIAPI
1197 RunSplitCommand(
1198   IN CONST CHAR16             *CmdLine,
1199   IN       SHELL_FILE_HANDLE  *StdIn,
1200   IN       SHELL_FILE_HANDLE  *StdOut
1201   )
1202 {
1203   EFI_STATUS        Status;
1204   CHAR16            *NextCommandLine;
1205   CHAR16            *OurCommandLine;
1206   UINTN             Size1;
1207   UINTN             Size2;
1208   SPLIT_LIST        *Split;
1209   SHELL_FILE_HANDLE *TempFileHandle;
1210   BOOLEAN           Unicode;
1211
1212   ASSERT(StdOut == NULL);
1213
1214   ASSERT(StrStr(CmdLine, L"|") != NULL);
1215
1216   Status          = EFI_SUCCESS;
1217   NextCommandLine = NULL;
1218   OurCommandLine  = NULL;
1219   Size1           = 0;
1220   Size2           = 0;
1221
1222   NextCommandLine = StrnCatGrow(&NextCommandLine, &Size1, StrStr(CmdLine, L"|")+1, 0);
1223   OurCommandLine  = StrnCatGrow(&OurCommandLine , &Size2, CmdLine                , StrStr(CmdLine, L"|") - CmdLine);
1224
1225   if (NextCommandLine == NULL || OurCommandLine == NULL) {
1226     SHELL_FREE_NON_NULL(OurCommandLine);
1227     SHELL_FREE_NON_NULL(NextCommandLine);
1228     return (EFI_OUT_OF_RESOURCES);
1229   } else if (StrStr(OurCommandLine, L"|") != NULL || Size1 == 0 || Size2 == 0) {
1230     SHELL_FREE_NON_NULL(OurCommandLine);
1231     SHELL_FREE_NON_NULL(NextCommandLine);
1232     return (EFI_INVALID_PARAMETER);
1233   } else if (NextCommandLine[0] != CHAR_NULL &&
1234       NextCommandLine[0] == L'a' &&
1235       NextCommandLine[1] == L' '
1236      ){
1237     CopyMem(NextCommandLine, NextCommandLine+1, StrSize(NextCommandLine) - sizeof(NextCommandLine[0]));
1238     Unicode = FALSE;
1239   } else {
1240     Unicode = TRUE;
1241   }
1242
1243
1244   //
1245   // make a SPLIT_LIST item and add to list
1246   //
1247   Split = AllocateZeroPool(sizeof(SPLIT_LIST));
1248   ASSERT(Split != NULL);
1249   Split->SplitStdIn   = StdIn;
1250   Split->SplitStdOut  = ConvertEfiFileProtocolToShellHandle(CreateFileInterfaceMem(Unicode), NULL);
1251   ASSERT(Split->SplitStdOut != NULL);
1252   InsertHeadList(&ShellInfoObject.SplitList.Link, &Split->Link);
1253
1254   Status = RunCommand(OurCommandLine);
1255
1256   //
1257   // move the output from the first to the in to the second.
1258   //
1259   TempFileHandle      = Split->SplitStdOut;
1260   if (Split->SplitStdIn == StdIn) {
1261     Split->SplitStdOut = NULL;
1262   } else {
1263     Split->SplitStdOut  = Split->SplitStdIn;
1264   }
1265   Split->SplitStdIn   = TempFileHandle;
1266   ShellInfoObject.NewEfiShellProtocol->SetFilePosition(ConvertShellHandleToEfiFileProtocol(Split->SplitStdIn), 0);
1267
1268   if (!EFI_ERROR(Status)) {
1269     Status = RunCommand(NextCommandLine);
1270   }
1271
1272   //
1273   // remove the top level from the ScriptList
1274   //
1275   ASSERT((SPLIT_LIST*)GetFirstNode(&ShellInfoObject.SplitList.Link) == Split);
1276   RemoveEntryList(&Split->Link);
1277
1278   //
1279   // Note that the original StdIn is now the StdOut...
1280   //
1281   if (Split->SplitStdOut != NULL && Split->SplitStdOut != StdIn) {
1282     ShellInfoObject.NewEfiShellProtocol->CloseFile(ConvertShellHandleToEfiFileProtocol(Split->SplitStdOut));
1283   }
1284   if (Split->SplitStdIn != NULL) {
1285     ShellInfoObject.NewEfiShellProtocol->CloseFile(ConvertShellHandleToEfiFileProtocol(Split->SplitStdIn));
1286   }
1287
1288   FreePool(Split);
1289   FreePool(NextCommandLine);
1290   FreePool(OurCommandLine);
1291
1292   return (Status);
1293 }
1294
1295 /**
1296   Function will process and run a command line.
1297
1298   This will determine if the command line represents an internal shell
1299   command or dispatch an external application.
1300
1301   @param[in] CmdLine      The command line to parse.
1302
1303   @retval EFI_SUCCESS     The command was completed.
1304   @retval EFI_ABORTED     The command's operation was aborted.
1305 **/
1306 EFI_STATUS
1307 EFIAPI
1308 RunCommand(
1309   IN CONST CHAR16   *CmdLine
1310   )
1311 {
1312   EFI_STATUS                Status;
1313   CHAR16                    *CommandName;
1314   SHELL_STATUS              ShellStatus;
1315   UINTN                     Argc;
1316   CHAR16                    **Argv;
1317   BOOLEAN                   LastError;
1318   CHAR16                    LeString[11];
1319   CHAR16                    *PostAliasCmdLine;
1320   UINTN                     PostAliasSize;
1321   CHAR16                    *PostVariableCmdLine;
1322   CHAR16                    *CommandWithPath;
1323   CONST EFI_DEVICE_PATH_PROTOCOL  *DevPath;
1324   CONST CHAR16              *TempLocation;
1325   CONST CHAR16              *TempLocation2;
1326   SHELL_FILE_HANDLE         OriginalStdIn;
1327   SHELL_FILE_HANDLE         OriginalStdOut;
1328   SHELL_FILE_HANDLE         OriginalStdErr;
1329   SYSTEM_TABLE_INFO         OriginalSystemTableInfo;
1330   CHAR16                    *TempLocation3;
1331   UINTN                     Count;
1332   UINTN                     Count2;
1333   CHAR16                    *CleanOriginal;
1334   SPLIT_LIST                *Split;
1335
1336   ASSERT(CmdLine != NULL);
1337   if (StrLen(CmdLine) == 0) {
1338     return (EFI_SUCCESS);
1339   }
1340
1341   CommandName         = NULL;
1342   PostVariableCmdLine = NULL;
1343   PostAliasCmdLine    = NULL;
1344   CommandWithPath     = NULL;
1345   DevPath             = NULL;
1346   Status              = EFI_SUCCESS;
1347   CleanOriginal       = NULL;
1348   Split               = NULL;
1349
1350   CleanOriginal = StrnCatGrow(&CleanOriginal, NULL, CmdLine, 0);
1351   if (CleanOriginal == NULL) {
1352     return (EFI_OUT_OF_RESOURCES);
1353   }
1354   while (CleanOriginal[StrLen(CleanOriginal)-1] == L' ') {
1355     CleanOriginal[StrLen(CleanOriginal)-1] = CHAR_NULL;
1356   }
1357   while (CleanOriginal[0] == L' ') {
1358     CopyMem(CleanOriginal, CleanOriginal+1, StrSize(CleanOriginal) - sizeof(CleanOriginal[0]));
1359   }
1360
1361   CommandName = NULL;
1362   if (StrStr(CleanOriginal, L" ") == NULL){
1363     StrnCatGrow(&CommandName, NULL, CleanOriginal, 0);
1364   } else {
1365     StrnCatGrow(&CommandName, NULL, CleanOriginal, StrStr(CleanOriginal, L" ") - CleanOriginal);
1366   }
1367
1368   ASSERT(PostAliasCmdLine == NULL);
1369   if (!ShellCommandIsCommandOnList(CommandName)) {
1370     //
1371     // Convert via alias
1372     //
1373     Status = ShellConvertAlias(&CommandName);
1374     PostAliasSize = 0;
1375     PostAliasCmdLine = StrnCatGrow(&PostAliasCmdLine, &PostAliasSize, CommandName, 0);
1376     PostAliasCmdLine = StrnCatGrow(&PostAliasCmdLine, &PostAliasSize, StrStr(CleanOriginal, L" "), 0);
1377     ASSERT_EFI_ERROR(Status);
1378   } else {
1379     PostAliasCmdLine = StrnCatGrow(&PostAliasCmdLine, NULL, CleanOriginal, 0);
1380   }
1381
1382   if (CleanOriginal != NULL) {
1383     FreePool(CleanOriginal);
1384     CleanOriginal = NULL;
1385   }
1386
1387   if (CommandName != NULL) {
1388     FreePool(CommandName);
1389     CommandName = NULL;
1390   }
1391
1392   PostVariableCmdLine = ShellConvertVariables(PostAliasCmdLine);
1393
1394   //
1395   // we can now free the modified by alias command line
1396   //
1397   if (PostAliasCmdLine != NULL) {
1398     FreePool(PostAliasCmdLine);
1399     PostAliasCmdLine = NULL;
1400   }
1401
1402   if (PostVariableCmdLine == NULL) {
1403     return (EFI_OUT_OF_RESOURCES);
1404   }
1405
1406   while (PostVariableCmdLine[StrLen(PostVariableCmdLine)-1] == L' ') {
1407     PostVariableCmdLine[StrLen(PostVariableCmdLine)-1] = CHAR_NULL;
1408   }
1409   while (PostVariableCmdLine[0] == L' ') {
1410     CopyMem(PostVariableCmdLine, PostVariableCmdLine+1, StrSize(PostVariableCmdLine) - sizeof(PostVariableCmdLine[0]));
1411   }
1412
1413   //
1414   // We dont do normal processing with a split command line (output from one command input to another)
1415   //
1416   TempLocation3 = NULL;
1417   if (StrStr(PostVariableCmdLine, L"|") != NULL) {
1418     for (TempLocation3 = PostVariableCmdLine ; TempLocation3 != NULL && *TempLocation3 != CHAR_NULL ; TempLocation3++) {
1419       if (*TempLocation3 == L'^' && *(TempLocation3+1) == L'|') {
1420         TempLocation3++;
1421       } else if (*TempLocation3 == L'|') {
1422         break;
1423       }
1424     }
1425   }
1426   if (TempLocation3 != NULL && *TempLocation3 != CHAR_NULL) {
1427     //
1428     // are we in an existing split???
1429     //
1430     if (!IsListEmpty(&ShellInfoObject.SplitList.Link)) {
1431       Split = (SPLIT_LIST*)GetFirstNode(&ShellInfoObject.SplitList.Link);
1432     }
1433
1434     if (Split == NULL) {
1435       Status = RunSplitCommand(PostVariableCmdLine, NULL, NULL);
1436     } else {
1437       Status = RunSplitCommand(PostVariableCmdLine, Split->SplitStdIn, Split->SplitStdOut);
1438     }
1439     if (EFI_ERROR(Status)) {
1440       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_INVALID_SPLIT), ShellInfoObject.HiiHandle, PostVariableCmdLine);
1441     }
1442   } else {
1443
1444     //
1445     // If this is a mapped drive change handle that...
1446     //
1447     if (PostVariableCmdLine[(StrLen(PostVariableCmdLine)-1)] == L':' && StrStr(PostVariableCmdLine, L" ") == NULL) {
1448       Status = ShellInfoObject.NewEfiShellProtocol->SetCurDir(NULL, PostVariableCmdLine);
1449       if (EFI_ERROR(Status)) {
1450         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_INVALID_MAPPING), ShellInfoObject.HiiHandle, PostVariableCmdLine);
1451       }
1452       FreePool(PostVariableCmdLine);
1453       return (Status);
1454     }
1455
1456     ///@todo update this section to divide into 3 ways - run internal command, run split (above), and run an external file...
1457     ///      We waste a lot of time doing processing like StdIn,StdOut,Argv,Argc for things that are external files...
1458
1459
1460
1461     Status = UpdateStdInStdOutStdErr(ShellInfoObject.NewShellParametersProtocol, PostVariableCmdLine, &OriginalStdIn, &OriginalStdOut, &OriginalStdErr, &OriginalSystemTableInfo);
1462     if (EFI_ERROR(Status)) {
1463       if (Status == EFI_NOT_FOUND) {
1464         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_REDUNDA_REDIR), ShellInfoObject.HiiHandle);
1465       } else {
1466         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_INVALID_REDIR), ShellInfoObject.HiiHandle);
1467       }
1468     } else {
1469       while (PostVariableCmdLine[StrLen(PostVariableCmdLine)-1] == L' ') {
1470         PostVariableCmdLine[StrLen(PostVariableCmdLine)-1] = CHAR_NULL;
1471       }
1472       while (PostVariableCmdLine[0] == L' ') {
1473         CopyMem(PostVariableCmdLine, PostVariableCmdLine+1, StrSize(PostVariableCmdLine) - sizeof(PostVariableCmdLine[0]));
1474       }
1475
1476       //
1477       // get the argc and argv updated for internal commands
1478       //
1479       Status = UpdateArgcArgv(ShellInfoObject.NewShellParametersProtocol, PostVariableCmdLine, &Argv, &Argc);
1480       ASSERT_EFI_ERROR(Status);
1481
1482       for (Count = 0 ; Count < ShellInfoObject.NewShellParametersProtocol->Argc ; Count++) {
1483         if (StrStr(ShellInfoObject.NewShellParametersProtocol->Argv[Count], L"-?") == ShellInfoObject.NewShellParametersProtocol->Argv[Count]
1484         ||  (ShellInfoObject.NewShellParametersProtocol->Argv[0][0] == L'?' && ShellInfoObject.NewShellParametersProtocol->Argv[0][1] == CHAR_NULL)
1485           ) {
1486           //
1487           // We need to redo the arguments since a parameter was -?
1488           // move them all down 1 to the end, then up one then replace the first with help
1489           //
1490           FreePool(ShellInfoObject.NewShellParametersProtocol->Argv[Count]);
1491           ShellInfoObject.NewShellParametersProtocol->Argv[Count] = NULL;
1492           for (Count2 = Count ; (Count2 + 1) < ShellInfoObject.NewShellParametersProtocol->Argc ; Count2++) {
1493             ShellInfoObject.NewShellParametersProtocol->Argv[Count2] = ShellInfoObject.NewShellParametersProtocol->Argv[Count2+1];
1494           }
1495           ShellInfoObject.NewShellParametersProtocol->Argv[Count2] = NULL;
1496           for (Count2 = ShellInfoObject.NewShellParametersProtocol->Argc -1 ; Count2 > 0 ; Count2--) {
1497             ShellInfoObject.NewShellParametersProtocol->Argv[Count2] = ShellInfoObject.NewShellParametersProtocol->Argv[Count2-1];
1498           }
1499           ShellInfoObject.NewShellParametersProtocol->Argv[0] = NULL;
1500           ShellInfoObject.NewShellParametersProtocol->Argv[0] = StrnCatGrow(&ShellInfoObject.NewShellParametersProtocol->Argv[0], NULL, L"help", 0);
1501           break;
1502         }
1503       }
1504
1505       //
1506       // command or file?
1507       //
1508       if (ShellCommandIsCommandOnList(ShellInfoObject.NewShellParametersProtocol->Argv[0])) {
1509         //
1510         // Run the command (which was converted if it was an alias)
1511         //
1512         if (!EFI_ERROR(Status))  {
1513           Status = ShellCommandRunCommandHandler(ShellInfoObject.NewShellParametersProtocol->Argv[0], &ShellStatus, &LastError);
1514           ASSERT_EFI_ERROR(Status);
1515           UnicodeSPrint(LeString, sizeof(LeString)*sizeof(LeString[0]), L"0x%08x", ShellStatus);
1516           DEBUG_CODE(InternalEfiShellSetEnv(L"DebugLasterror", LeString, TRUE););
1517           if (LastError) {
1518             InternalEfiShellSetEnv(L"Lasterror", LeString, TRUE);
1519           }
1520           //
1521           // Pass thru the exitcode from the app.
1522           //
1523           if (ShellCommandGetExit()) {
1524             Status = ShellStatus;
1525           } else if (ShellStatus != 0 && IsScriptOnlyCommand(ShellInfoObject.NewShellParametersProtocol->Argv[0])) {
1526             Status = EFI_ABORTED;
1527           }
1528         }
1529       } else {
1530         //
1531         // run an external file (or script)
1532         //
1533         if (StrStr(ShellInfoObject.NewShellParametersProtocol->Argv[0], L":") != NULL) {
1534           ASSERT (CommandWithPath == NULL);
1535           if (ShellIsFile(ShellInfoObject.NewShellParametersProtocol->Argv[0]) == EFI_SUCCESS) {
1536             CommandWithPath = StrnCatGrow(&CommandWithPath, NULL, ShellInfoObject.NewShellParametersProtocol->Argv[0], 0);
1537           }
1538         }
1539         if (CommandWithPath == NULL) {
1540           CommandWithPath = ShellFindFilePathEx(ShellInfoObject.NewShellParametersProtocol->Argv[0], mExecutableExtensions);
1541         }
1542         if (CommandWithPath == NULL || ShellIsDirectory(CommandWithPath) == EFI_SUCCESS) {
1543           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_NOT_FOUND), ShellInfoObject.HiiHandle, ShellInfoObject.NewShellParametersProtocol->Argv[0]);
1544         } else {
1545           //
1546           // Check if it's a NSH (script) file.
1547           //
1548           TempLocation = CommandWithPath+StrLen(CommandWithPath)-4;
1549           TempLocation2 = mScriptExtension;
1550           if ((StrLen(CommandWithPath) > 4) && (StringNoCaseCompare((VOID*)(&TempLocation), (VOID*)(&TempLocation2)) == 0)) {
1551             Status = RunScriptFile (CommandWithPath);
1552           } else {
1553             DevPath = ShellInfoObject.NewEfiShellProtocol->GetDevicePathFromFilePath(CommandWithPath);
1554             ASSERT(DevPath != NULL);
1555             Status = InternalShellExecuteDevicePath(
1556               &gImageHandle,
1557               DevPath,
1558               PostVariableCmdLine,
1559               NULL,
1560               NULL
1561              );
1562           }
1563         }
1564       }
1565       CommandName = StrnCatGrow(&CommandName, NULL, ShellInfoObject.NewShellParametersProtocol->Argv[0], 0);
1566
1567       RestoreArgcArgv(ShellInfoObject.NewShellParametersProtocol, &Argv, &Argc);
1568
1569       RestoreStdInStdOutStdErr(ShellInfoObject.NewShellParametersProtocol, &OriginalStdIn, &OriginalStdOut, &OriginalStdErr, &OriginalSystemTableInfo);
1570     }
1571     if (CommandName != NULL) {
1572       if (ShellCommandGetCurrentScriptFile() != NULL &&  !IsScriptOnlyCommand(CommandName)) {
1573         //
1574         // if this is NOT a scipt only command return success so the script won't quit.
1575         // prevent killing the script - this is the only place where we know the actual command name (after alias and variable replacement...)
1576         //
1577         Status = EFI_SUCCESS;
1578       }
1579     }
1580   }
1581
1582   SHELL_FREE_NON_NULL(CommandName);
1583   SHELL_FREE_NON_NULL(CommandWithPath);
1584   SHELL_FREE_NON_NULL(PostVariableCmdLine);
1585
1586   return (Status);
1587 }
1588
1589 STATIC CONST UINT16 InvalidChars[] = {L'*', L'?', L'<', L'>', L'\\', L'/', L'\"', 0x0001, 0x0002};
1590 /**
1591   Function determins if the CommandName COULD be a valid command.  It does not determine whether
1592   this is a valid command.  It only checks for invalid characters.
1593
1594   @param[in] CommandName    The name to check
1595
1596   @retval TRUE              CommandName could be a command name
1597   @retval FALSE             CommandName could not be a valid command name
1598 **/
1599 BOOLEAN
1600 EFIAPI
1601 IsValidCommandName(
1602   IN CONST CHAR16     *CommandName
1603   )
1604 {
1605   UINTN Count;
1606   if (CommandName == NULL) {
1607     ASSERT(FALSE);
1608     return (FALSE);
1609   }
1610   for ( Count = 0
1611       ; Count < sizeof(InvalidChars) / sizeof(InvalidChars[0])
1612       ; Count++
1613      ){
1614     if (ScanMem16(CommandName, StrSize(CommandName), InvalidChars[Count]) != NULL) {
1615       return (FALSE);
1616     }
1617   }
1618   return (TRUE);
1619 }
1620
1621 /**
1622   Function to process a NSH script file via SHELL_FILE_HANDLE.
1623
1624   @param[in] Handle             The handle to the already opened file.
1625   @param[in] Name               The name of the script file.
1626
1627   @retval EFI_SUCCESS           the script completed sucessfully
1628 **/
1629 EFI_STATUS
1630 EFIAPI
1631 RunScriptFileHandle (
1632   IN SHELL_FILE_HANDLE  Handle,
1633   IN CONST CHAR16       *Name
1634   )
1635 {
1636   EFI_STATUS          Status;
1637   SCRIPT_FILE         *NewScriptFile;
1638   UINTN               LoopVar;
1639   CHAR16              *CommandLine;
1640   CHAR16              *CommandLine2;
1641   CHAR16              *CommandLine3;
1642   SCRIPT_COMMAND_LIST *LastCommand;
1643   BOOLEAN             Ascii;
1644   BOOLEAN             PreScriptEchoState;
1645   BOOLEAN             PreCommandEchoState;
1646   CONST CHAR16        *CurDir;
1647   UINTN               LineCount;
1648   CHAR16              LeString[50];
1649
1650   ASSERT(!ShellCommandGetScriptExit());
1651
1652   PreScriptEchoState = ShellCommandGetEchoState();
1653
1654   NewScriptFile = (SCRIPT_FILE*)AllocateZeroPool(sizeof(SCRIPT_FILE));
1655   if (NewScriptFile == NULL) {
1656     return (EFI_OUT_OF_RESOURCES);
1657   }
1658
1659   //
1660   // Set up the name
1661   //
1662   ASSERT(NewScriptFile->ScriptName == NULL);
1663   NewScriptFile->ScriptName = StrnCatGrow(&NewScriptFile->ScriptName, NULL, Name, 0);
1664   if (NewScriptFile->ScriptName == NULL) {
1665     DeleteScriptFileStruct(NewScriptFile);
1666     return (EFI_OUT_OF_RESOURCES);
1667   }
1668
1669   //
1670   // Save the parameters (used to replace %0 to %9 later on)
1671   //
1672   NewScriptFile->Argc = ShellInfoObject.NewShellParametersProtocol->Argc;
1673   if (NewScriptFile->Argc != 0) {
1674     NewScriptFile->Argv = (CHAR16**)AllocateZeroPool(NewScriptFile->Argc * sizeof(CHAR16*));
1675     if (NewScriptFile->Argv == NULL) {
1676       DeleteScriptFileStruct(NewScriptFile);
1677       return (EFI_OUT_OF_RESOURCES);
1678     }
1679     for (LoopVar = 0 ; LoopVar < 10 && LoopVar < NewScriptFile->Argc; LoopVar++) {
1680       ASSERT(NewScriptFile->Argv[LoopVar] == NULL);
1681       NewScriptFile->Argv[LoopVar] = StrnCatGrow(&NewScriptFile->Argv[LoopVar], NULL, ShellInfoObject.NewShellParametersProtocol->Argv[LoopVar], 0);
1682       if (NewScriptFile->Argv[LoopVar] == NULL) {
1683         DeleteScriptFileStruct(NewScriptFile);
1684         return (EFI_OUT_OF_RESOURCES);
1685       }
1686     }
1687   } else {
1688     NewScriptFile->Argv = NULL;
1689   }
1690
1691   InitializeListHead(&NewScriptFile->CommandList);
1692   InitializeListHead(&NewScriptFile->SubstList);
1693
1694   //
1695   // Now build the list of all script commands.
1696   //
1697   LineCount = 0;
1698   while(!ShellFileHandleEof(Handle)) {
1699     CommandLine = ShellFileHandleReturnLine(Handle, &Ascii);
1700     LineCount++;
1701     if (CommandLine == NULL || StrLen(CommandLine) == 0) {
1702       continue;
1703     }
1704     NewScriptFile->CurrentCommand = AllocateZeroPool(sizeof(SCRIPT_COMMAND_LIST));
1705     if (NewScriptFile->CurrentCommand == NULL) {
1706       DeleteScriptFileStruct(NewScriptFile);
1707       return (EFI_OUT_OF_RESOURCES);
1708     }
1709
1710     NewScriptFile->CurrentCommand->Cl   = CommandLine;
1711     NewScriptFile->CurrentCommand->Data = NULL;
1712     NewScriptFile->CurrentCommand->Line = LineCount;
1713
1714     InsertTailList(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link);
1715   }
1716
1717   //
1718   // Add this as the topmost script file
1719   //
1720   ShellCommandSetNewScript (NewScriptFile);
1721
1722   //
1723   // Now enumerate through the commands and run each one.
1724   //
1725   CommandLine = AllocateZeroPool(PcdGet16(PcdShellPrintBufferSize));
1726   if (CommandLine == NULL) {
1727     DeleteScriptFileStruct(NewScriptFile);
1728     return (EFI_OUT_OF_RESOURCES);
1729   }
1730   CommandLine2 = AllocateZeroPool(PcdGet16(PcdShellPrintBufferSize));
1731   if (CommandLine2 == NULL) {
1732     FreePool(CommandLine);
1733     DeleteScriptFileStruct(NewScriptFile);
1734     return (EFI_OUT_OF_RESOURCES);
1735   }
1736
1737   for ( NewScriptFile->CurrentCommand = (SCRIPT_COMMAND_LIST *)GetFirstNode(&NewScriptFile->CommandList)
1738       ; !IsNull(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link)
1739       ; // conditional increment in the body of the loop
1740   ){
1741     ASSERT(CommandLine2 != NULL);
1742     StrCpy(CommandLine2, NewScriptFile->CurrentCommand->Cl);
1743
1744     //
1745     // NULL out comments
1746     //
1747     for (CommandLine3 = CommandLine2 ; CommandLine3 != NULL && *CommandLine3 != CHAR_NULL ; CommandLine3++) {
1748       if (*CommandLine3 == L'^') {
1749         if (*(CommandLine3+1) == L'#' || *(CommandLine3+1) == L':') {
1750           CopyMem(CommandLine3, CommandLine3+1, StrSize(CommandLine3) - sizeof(CommandLine3[0]));
1751         }
1752       } else if (*CommandLine3 == L'#') {
1753         *CommandLine3 = CHAR_NULL;
1754       }
1755     }
1756
1757     if (CommandLine2 != NULL && StrLen(CommandLine2) >= 1) {
1758       //
1759       // Due to variability in starting the find and replace action we need to have both buffers the same.
1760       //
1761       StrCpy(CommandLine, CommandLine2);
1762
1763       //
1764       // Remove the %0 to %9 from the command line (if we have some arguments)
1765       //
1766       if (NewScriptFile->Argv != NULL) {
1767         switch (NewScriptFile->Argc) {
1768           default:
1769             Status = ShellCopySearchAndReplace(CommandLine2,  CommandLine, PcdGet16 (PcdShellPrintBufferSize), L"%9", NewScriptFile->Argv[9], FALSE, TRUE);
1770             ASSERT_EFI_ERROR(Status);
1771           case 9:
1772             Status = ShellCopySearchAndReplace(CommandLine,  CommandLine2, PcdGet16 (PcdShellPrintBufferSize), L"%8", NewScriptFile->Argv[8], FALSE, TRUE);
1773             ASSERT_EFI_ERROR(Status);
1774           case 8:
1775             Status = ShellCopySearchAndReplace(CommandLine2,  CommandLine, PcdGet16 (PcdShellPrintBufferSize), L"%7", NewScriptFile->Argv[7], FALSE, TRUE);
1776             ASSERT_EFI_ERROR(Status);
1777           case 7:
1778             Status = ShellCopySearchAndReplace(CommandLine,  CommandLine2, PcdGet16 (PcdShellPrintBufferSize), L"%6", NewScriptFile->Argv[6], FALSE, TRUE);
1779             ASSERT_EFI_ERROR(Status);
1780           case 6:
1781             Status = ShellCopySearchAndReplace(CommandLine2,  CommandLine, PcdGet16 (PcdShellPrintBufferSize), L"%5", NewScriptFile->Argv[5], FALSE, TRUE);
1782             ASSERT_EFI_ERROR(Status);
1783           case 5:
1784             Status = ShellCopySearchAndReplace(CommandLine,  CommandLine2, PcdGet16 (PcdShellPrintBufferSize), L"%4", NewScriptFile->Argv[4], FALSE, TRUE);
1785             ASSERT_EFI_ERROR(Status);
1786           case 4:
1787             Status = ShellCopySearchAndReplace(CommandLine2,  CommandLine, PcdGet16 (PcdShellPrintBufferSize), L"%3", NewScriptFile->Argv[3], FALSE, TRUE);
1788             ASSERT_EFI_ERROR(Status);
1789           case 3:
1790             Status = ShellCopySearchAndReplace(CommandLine,  CommandLine2, PcdGet16 (PcdShellPrintBufferSize), L"%2", NewScriptFile->Argv[2], FALSE, TRUE);
1791             ASSERT_EFI_ERROR(Status);
1792           case 2:
1793             Status = ShellCopySearchAndReplace(CommandLine2,  CommandLine, PcdGet16 (PcdShellPrintBufferSize), L"%1", NewScriptFile->Argv[1], FALSE, TRUE);
1794             ASSERT_EFI_ERROR(Status);
1795           case 1:
1796             Status = ShellCopySearchAndReplace(CommandLine,  CommandLine2, PcdGet16 (PcdShellPrintBufferSize), L"%0", NewScriptFile->Argv[0], FALSE, TRUE);
1797             ASSERT_EFI_ERROR(Status);
1798             break;
1799           case 0:
1800             break;
1801         }
1802       }
1803       Status = ShellCopySearchAndReplace(CommandLine2,  CommandLine, PcdGet16 (PcdShellPrintBufferSize), L"%1", L"\"\"", FALSE, FALSE);
1804       Status = ShellCopySearchAndReplace(CommandLine,  CommandLine2, PcdGet16 (PcdShellPrintBufferSize), L"%2", L"\"\"", FALSE, FALSE);
1805       Status = ShellCopySearchAndReplace(CommandLine2,  CommandLine, PcdGet16 (PcdShellPrintBufferSize), L"%3", L"\"\"", FALSE, FALSE);
1806       Status = ShellCopySearchAndReplace(CommandLine,  CommandLine2, PcdGet16 (PcdShellPrintBufferSize), L"%4", L"\"\"", FALSE, FALSE);
1807       Status = ShellCopySearchAndReplace(CommandLine2,  CommandLine, PcdGet16 (PcdShellPrintBufferSize), L"%5", L"\"\"", FALSE, FALSE);
1808       Status = ShellCopySearchAndReplace(CommandLine,  CommandLine2, PcdGet16 (PcdShellPrintBufferSize), L"%6", L"\"\"", FALSE, FALSE);
1809       Status = ShellCopySearchAndReplace(CommandLine2,  CommandLine, PcdGet16 (PcdShellPrintBufferSize), L"%7", L"\"\"", FALSE, FALSE);
1810       Status = ShellCopySearchAndReplace(CommandLine,  CommandLine2, PcdGet16 (PcdShellPrintBufferSize), L"%8", L"\"\"", FALSE, FALSE);
1811       Status = ShellCopySearchAndReplace(CommandLine2,  CommandLine, PcdGet16 (PcdShellPrintBufferSize), L"%9", L"\"\"", FALSE, FALSE);
1812
1813       StrCpy(CommandLine2, CommandLine);
1814
1815       LastCommand = NewScriptFile->CurrentCommand;
1816
1817       for (CommandLine3 = CommandLine2 ; CommandLine3[0] == L' ' ; CommandLine3++);
1818
1819       if (CommandLine3 != NULL && CommandLine3[0] == L':' ) {
1820         //
1821         // This line is a goto target / label
1822         //
1823       } else {
1824         if (CommandLine3 != NULL && StrLen(CommandLine3) > 0) {
1825           if (CommandLine3[0] == L'@') {
1826             //
1827             // We need to save the current echo state
1828             // and disable echo for just this command.
1829             //
1830             PreCommandEchoState = ShellCommandGetEchoState();
1831             ShellCommandSetEchoState(FALSE);
1832             Status = RunCommand(CommandLine3+1);
1833
1834             //
1835             // Now restore the pre-'@' echo state.
1836             //
1837             ShellCommandSetEchoState(PreCommandEchoState);
1838           } else {
1839             if (ShellCommandGetEchoState()) {
1840               CurDir = ShellInfoObject.NewEfiShellProtocol->GetEnv(L"cwd");
1841               if (CurDir != NULL && StrLen(CurDir) > 1) {
1842                 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_CURDIR), ShellInfoObject.HiiHandle, CurDir);
1843               } else {
1844                 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_SHELL), ShellInfoObject.HiiHandle);
1845               }
1846               ShellPrintEx(-1, -1, L"%s\r\n", CommandLine2);
1847             }
1848             Status = RunCommand(CommandLine3);
1849           }
1850         }
1851
1852         if (ShellCommandGetScriptExit()) {
1853           UnicodeSPrint(LeString, sizeof(LeString)*sizeof(LeString[0]), L"0x%Lx", ShellCommandGetExitCode());
1854           DEBUG_CODE(InternalEfiShellSetEnv(L"DebugLasterror", LeString, TRUE););
1855           InternalEfiShellSetEnv(L"Lasterror", LeString, TRUE);
1856
1857           ShellCommandRegisterExit(FALSE, 0);
1858           Status = EFI_SUCCESS;
1859           break;
1860         }
1861         if (EFI_ERROR(Status)) {
1862           break;
1863         }
1864         if (ShellCommandGetExit()) {
1865           break;
1866         }
1867       }
1868       //
1869       // If that commend did not update the CurrentCommand then we need to advance it...
1870       //
1871       if (LastCommand == NewScriptFile->CurrentCommand) {
1872         NewScriptFile->CurrentCommand = (SCRIPT_COMMAND_LIST *)GetNextNode(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link);
1873         if (!IsNull(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link)) {
1874           NewScriptFile->CurrentCommand->Reset = TRUE;
1875         }
1876       }
1877     } else {
1878       NewScriptFile->CurrentCommand = (SCRIPT_COMMAND_LIST *)GetNextNode(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link);
1879       if (!IsNull(&NewScriptFile->CommandList, &NewScriptFile->CurrentCommand->Link)) {
1880         NewScriptFile->CurrentCommand->Reset = TRUE;
1881       }
1882     }
1883   }
1884
1885
1886   FreePool(CommandLine);
1887   FreePool(CommandLine2);
1888   ShellCommandSetNewScript (NULL);
1889
1890   //
1891   // Only if this was the last script reset the state.
1892   //
1893   if (ShellCommandGetCurrentScriptFile()==NULL) {
1894     ShellCommandSetEchoState(PreScriptEchoState);
1895   }
1896   return (EFI_SUCCESS);
1897 }
1898
1899 /**
1900   Function to process a NSH script file.
1901
1902   @param[in] ScriptPath         Pointer to the script file name (including file system path).
1903
1904   @retval EFI_SUCCESS           the script completed sucessfully
1905 **/
1906 EFI_STATUS
1907 EFIAPI
1908 RunScriptFile (
1909   IN CONST CHAR16 *ScriptPath
1910   )
1911 {
1912   EFI_STATUS          Status;
1913   SHELL_FILE_HANDLE   FileHandle;
1914
1915   if (ShellIsFile(ScriptPath) != EFI_SUCCESS) {
1916     return (EFI_INVALID_PARAMETER);
1917   }
1918
1919   Status = ShellOpenFileByName(ScriptPath, &FileHandle, EFI_FILE_MODE_READ, 0);
1920   if (EFI_ERROR(Status)) {
1921     return (Status);
1922   }
1923
1924   Status = RunScriptFileHandle(FileHandle, ScriptPath);
1925
1926   ShellCloseFile(&FileHandle);
1927
1928   return (Status);
1929 }