2 This is THE shell (application)
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
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.
18 // Initialize the global structure
20 SHELL_INFO ShellInfoObject
= {
62 STATIC CONST CHAR16 mScriptExtension
[] = L
".NSH";
63 STATIC CONST CHAR16 mExecutableExtensions
[] = L
".NSH;.EFI";
64 STATIC CONST CHAR16 mStartupScript
[] = L
"startup.nsh";
67 Function to start monitoring for CTRL-S using SimpleTextInputEx. This
68 feature's enabled state was not known when the shell initially launched.
70 @retval EFI_SUCCESS The feature is enabled.
71 @retval EFI_OUT_OF_RESOURCES There is not enough mnemory available.
75 InternalEfiShellStartCtrlSMonitor(
79 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
83 Status
= gBS
->OpenProtocol(
85 &gEfiSimpleTextInputExProtocolGuid
,
89 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
90 if (EFI_ERROR(Status
)) {
95 STRING_TOKEN (STR_SHELL_NO_IN_EX
),
96 ShellInfoObject
.HiiHandle
);
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';
105 Status
= SimpleEx
->RegisterKeyNotify(
108 NotificationFunction
,
109 &ShellInfoObject
.CtrlSNotifyHandle1
);
111 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
112 if (!EFI_ERROR(Status
)) {
113 Status
= SimpleEx
->RegisterKeyNotify(
116 NotificationFunction
,
117 &ShellInfoObject
.CtrlSNotifyHandle2
);
119 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
120 KeyData
.Key
.UnicodeChar
= 19;
122 if (!EFI_ERROR(Status
)) {
123 Status
= SimpleEx
->RegisterKeyNotify(
126 NotificationFunction
,
127 &ShellInfoObject
.CtrlSNotifyHandle2
);
129 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
130 if (!EFI_ERROR(Status
)) {
131 Status
= SimpleEx
->RegisterKeyNotify(
134 NotificationFunction
,
135 &ShellInfoObject
.CtrlSNotifyHandle2
);
143 The entry point for the application.
145 @param[in] ImageHandle The firmware allocated handle for the EFI image.
146 @param[in] SystemTable A pointer to the EFI System Table.
148 @retval EFI_SUCCESS The entry point is executed successfully.
149 @retval other Some error occurs when executing this entry point.
155 IN EFI_HANDLE ImageHandle
,
156 IN EFI_SYSTEM_TABLE
*SystemTable
162 EFI_HANDLE ConInHandle
;
163 EFI_SIMPLE_TEXT_INPUT_PROTOCOL
*OldConIn
;
165 if (PcdGet8(PcdShellSupportLevel
) > 3) {
166 return (EFI_UNSUPPORTED
);
172 Status
= gST
->ConOut
->ClearScreen(gST
->ConOut
);
173 if (EFI_ERROR(Status
)) {
178 // Populate the global structure from PCDs
180 ShellInfoObject
.ImageDevPath
= NULL
;
181 ShellInfoObject
.FileDevPath
= NULL
;
182 ShellInfoObject
.PageBreakEnabled
= PcdGetBool(PcdShellPageBreakDefault
);
183 ShellInfoObject
.ViewingSettings
.InsertMode
= PcdGetBool(PcdShellInsertModeDefault
);
184 ShellInfoObject
.LogScreenCount
= PcdGet8 (PcdShellScreenLogCount
);
187 // verify we dont allow for spec violation
189 ASSERT(ShellInfoObject
.LogScreenCount
>= 3);
192 // Initialize the LIST ENTRY objects...
194 InitializeListHead(&ShellInfoObject
.BufferToFreeList
.Link
);
195 InitializeListHead(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
);
196 InitializeListHead(&ShellInfoObject
.SplitList
.Link
);
199 // Check PCDs for optional features that are not implemented yet.
201 if ( PcdGetBool(PcdShellSupportOldProtocols
)
202 || !FeaturePcdGet(PcdShellRequireHiiPlatform
)
203 || FeaturePcdGet(PcdShellSupportFrameworkHii
)
205 return (EFI_UNSUPPORTED
);
209 // turn off the watchdog timer
211 gBS
->SetWatchdogTimer (0, 0, 0, NULL
);
214 // install our console logger. This will keep a log of the output for back-browsing
216 Status
= ConsoleLoggerInstall(ShellInfoObject
.LogScreenCount
, &ShellInfoObject
.ConsoleInfo
);
217 if (!EFI_ERROR(Status
)) {
219 // Enable the cursor to be visible
221 gST
->ConOut
->EnableCursor (gST
->ConOut
, TRUE
);
224 // If supporting EFI 1.1 we need to install HII protocol
225 // only do this if PcdShellRequireHiiPlatform == FALSE
227 // remove EFI_UNSUPPORTED check above when complete.
228 ///@todo add support for Framework HII
231 // install our (solitary) HII package
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
238 if (ShellInfoObject
.HiiHandle
== NULL
) {
239 return (EFI_NOT_STARTED
);
244 // create and install the EfiShellParametersProtocol
246 Status
= CreatePopulateInstallShellParametersProtocol(&ShellInfoObject
.NewShellParametersProtocol
, &ShellInfoObject
.RootShellInstance
);
247 ASSERT_EFI_ERROR(Status
);
248 ASSERT(ShellInfoObject
.NewShellParametersProtocol
!= NULL
);
251 // create and install the EfiShellProtocol
253 Status
= CreatePopulateInstallShellProtocol(&ShellInfoObject
.NewEfiShellProtocol
);
254 ASSERT_EFI_ERROR(Status
);
255 ASSERT(ShellInfoObject
.NewEfiShellProtocol
!= NULL
);
258 // Now initialize the shell library (it requires Shell Parameters protocol)
260 Status
= ShellInitialize();
261 ASSERT_EFI_ERROR(Status
);
263 Status
= CommandInit();
264 ASSERT_EFI_ERROR(Status
);
267 // Check the command line
269 Status
= ProcessCommandLine();
272 // If shell support level is >= 1 create the mappings and paths
274 if (PcdGet8(PcdShellSupportLevel
) >= 1) {
275 Status
= ShellCommandCreateInitialMappingsAndPaths();
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
282 Status
= GetDevicePathsForImageAndFile(&ShellInfoObject
.ImageDevPath
, &ShellInfoObject
.FileDevPath
);
283 ASSERT_EFI_ERROR(Status
);
286 // Display the version
288 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoVersion
) {
291 gST
->ConOut
->Mode
->CursorRow
,
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),
301 gST
->FirmwareRevision
306 // Display the mapping
308 if (PcdGet8(PcdShellSupportLevel
) >= 2 && !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoMap
) {
309 Status
= RunCommand(L
"map");
310 ASSERT_EFI_ERROR(Status
);
314 // init all the built in alias'
316 Status
= SetBuiltInAlias();
317 ASSERT_EFI_ERROR(Status
);
320 // Initialize environment variables
322 if (ShellCommandGetProfileList() != NULL
) {
323 Status
= InternalEfiShellSetEnv(L
"profiles", ShellCommandGetProfileList(), TRUE
);
324 ASSERT_EFI_ERROR(Status
);
328 TempString
= AllocateZeroPool(Size
);
330 UnicodeSPrint(TempString
, Size
, L
"%d", PcdGet8(PcdShellSupportLevel
));
331 Status
= InternalEfiShellSetEnv(L
"uefishellsupport", TempString
, TRUE
);
332 ASSERT_EFI_ERROR(Status
);
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
);
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
);
342 FreePool(TempString
);
344 if (!EFI_ERROR(Status
)) {
345 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
) {
347 // Set up the event for CTRL-C monitoring...
349 Status
= InernalEfiShellStartMonitor();
352 if (!EFI_ERROR(Status
) && !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
354 // Set up the event for CTRL-S monitoring...
356 Status
= InternalEfiShellStartCtrlSMonitor();
359 if (!EFI_ERROR(Status
) && ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
361 // close off the gST->ConIn
363 OldConIn
= gST
->ConIn
;
364 ConInHandle
= gST
->ConsoleInHandle
;
365 gST
->ConIn
= CreateSimpleTextInOnFile((SHELL_FILE_HANDLE
)&FileInterfaceNulFile
, &gST
->ConsoleInHandle
);
371 if (!EFI_ERROR(Status
) && PcdGet8(PcdShellSupportLevel
) >= 1) {
373 // process the startup script or launch the called app.
375 Status
= DoStartupScript(ShellInfoObject
.ImageDevPath
, ShellInfoObject
.FileDevPath
);
378 if (!ShellCommandGetExit() && (PcdGet8(PcdShellSupportLevel
) >= 3 || PcdGetBool(PcdShellForceConsole
)) && !EFI_ERROR(Status
) && !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
380 // begin the UI waiting loop
384 // clean out all the memory allocated for CONST <something> * return values
385 // between each shell prompt presentation
387 if (!IsListEmpty(&ShellInfoObject
.BufferToFreeList
.Link
)){
388 FreeBufferList(&ShellInfoObject
.BufferToFreeList
);
392 // Reset page break back to default.
394 ShellInfoObject
.PageBreakEnabled
= PcdGetBool(PcdShellPageBreakDefault
);
395 ShellInfoObject
.ConsoleInfo
->Enabled
= TRUE
;
396 ShellInfoObject
.ConsoleInfo
->RowCounter
= 0;
399 // Reset the CTRL-C event (yes we ignore the return values)
401 Status
= gBS
->CheckEvent (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
);
406 Status
= DoShellPrompt();
407 } while (!ShellCommandGetExit());
409 if (OldConIn
!= NULL
&& ConInHandle
!= NULL
) {
410 CloseSimpleTextInOnFile (gST
->ConIn
);
411 gST
->ConIn
= OldConIn
;
412 gST
->ConsoleInHandle
= ConInHandle
;
418 // uninstall protocols / free memory / etc...
420 if (ShellInfoObject
.UserBreakTimer
!= NULL
) {
421 gBS
->CloseEvent(ShellInfoObject
.UserBreakTimer
);
422 DEBUG_CODE(ShellInfoObject
.UserBreakTimer
= NULL
;);
424 if (ShellInfoObject
.ImageDevPath
!= NULL
) {
425 FreePool(ShellInfoObject
.ImageDevPath
);
426 DEBUG_CODE(ShellInfoObject
.ImageDevPath
= NULL
;);
428 if (ShellInfoObject
.FileDevPath
!= NULL
) {
429 FreePool(ShellInfoObject
.FileDevPath
);
430 DEBUG_CODE(ShellInfoObject
.FileDevPath
= NULL
;);
432 if (ShellInfoObject
.NewShellParametersProtocol
!= NULL
) {
433 CleanUpShellParametersProtocol(ShellInfoObject
.NewShellParametersProtocol
);
434 DEBUG_CODE(ShellInfoObject
.NewShellParametersProtocol
= NULL
;);
436 if (ShellInfoObject
.NewEfiShellProtocol
!= NULL
){
437 if (ShellInfoObject
.NewEfiShellProtocol
->IsRootShell()){
438 ShellInfoObject
.NewEfiShellProtocol
->SetEnv(L
"cwd", L
"", TRUE
);
440 CleanUpShellProtocol(ShellInfoObject
.NewEfiShellProtocol
);
441 DEBUG_CODE(ShellInfoObject
.NewEfiShellProtocol
= NULL
;);
444 if (!IsListEmpty(&ShellInfoObject
.BufferToFreeList
.Link
)){
445 FreeBufferList(&ShellInfoObject
.BufferToFreeList
);
448 if (!IsListEmpty(&ShellInfoObject
.SplitList
.Link
)){
449 ASSERT(FALSE
); ///@todo finish this de-allocation.
452 if (ShellInfoObject
.ShellInitSettings
.FileName
!= NULL
) {
453 FreePool(ShellInfoObject
.ShellInitSettings
.FileName
);
454 DEBUG_CODE(ShellInfoObject
.ShellInitSettings
.FileName
= NULL
;);
457 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
458 FreePool(ShellInfoObject
.ShellInitSettings
.FileOptions
);
459 DEBUG_CODE(ShellInfoObject
.ShellInitSettings
.FileOptions
= NULL
;);
462 if (ShellInfoObject
.HiiHandle
!= NULL
) {
463 HiiRemovePackages(ShellInfoObject
.HiiHandle
);
464 DEBUG_CODE(ShellInfoObject
.HiiHandle
= NULL
;);
467 if (!IsListEmpty(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
)){
468 FreeBufferList(&ShellInfoObject
.ViewingSettings
.CommandHistory
);
471 ASSERT(ShellInfoObject
.ConsoleInfo
!= NULL
);
472 if (ShellInfoObject
.ConsoleInfo
!= NULL
) {
473 ConsoleLoggerUninstall(ShellInfoObject
.ConsoleInfo
);
474 FreePool(ShellInfoObject
.ConsoleInfo
);
475 DEBUG_CODE(ShellInfoObject
.ConsoleInfo
= NULL
;);
478 if (ShellCommandGetExit()) {
479 return ((EFI_STATUS
)ShellCommandGetExitCode());
485 Sets all the alias' that were registered with the ShellCommandLib library.
487 @retval EFI_SUCCESS all init commands were run sucessfully.
495 CONST ALIAS_LIST
*List
;
499 // Get all the commands we want to run
501 List
= ShellCommandGetInitAliasList();
504 // for each command in the List
506 for ( Node
= (ALIAS_LIST
*)GetFirstNode(&List
->Link
)
507 ; !IsNull (&List
->Link
, &Node
->Link
)
508 ; Node
= (ALIAS_LIST
*)GetNextNode(&List
->Link
, &Node
->Link
)
511 // install the alias'
513 Status
= InternalSetAlias(Node
->CommandString
, Node
->Alias
, TRUE
);
514 ASSERT_EFI_ERROR(Status
);
516 return (EFI_SUCCESS
);
520 Internal function to determine if 2 command names are really the same.
522 @param[in] Command1 The pointer to the first command name.
523 @param[in] Command2 The pointer to the second command name.
525 @retval TRUE The 2 command names are the same.
526 @retval FALSE The 2 command names are not the same.
531 IN CONST CHAR16
*Command1
,
532 IN CONST CHAR16
*Command2
535 if (StringNoCaseCompare(&Command1
, &Command2
) == 0) {
542 Internal function to determine if a command is a script only command.
544 @param[in] CommandName The pointer to the command name.
546 @retval TRUE The command is a script only command.
547 @retval FALSE The command is not a script only command.
552 IN CONST CHAR16
*CommandName
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")) {
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.
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.
575 @retval EFI_SUCCESS The 2 device paths were sucessfully returned.
576 @retval other A error from gBS->HandleProtocol.
582 GetDevicePathsForImageAndFile (
583 IN OUT EFI_DEVICE_PATH_PROTOCOL
**DevPath
,
584 IN OUT EFI_DEVICE_PATH_PROTOCOL
**FilePath
588 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
589 EFI_DEVICE_PATH_PROTOCOL
*ImageDevicePath
;
591 ASSERT(DevPath
!= NULL
);
592 ASSERT(FilePath
!= NULL
);
594 Status
= gBS
->OpenProtocol (
596 &gEfiLoadedImageProtocolGuid
,
597 (VOID
**)&LoadedImage
,
600 EFI_OPEN_PROTOCOL_GET_PROTOCOL
602 if (!EFI_ERROR (Status
)) {
603 Status
= gBS
->OpenProtocol (
604 LoadedImage
->DeviceHandle
,
605 &gEfiDevicePathProtocolGuid
,
606 (VOID
**)&ImageDevicePath
,
609 EFI_OPEN_PROTOCOL_GET_PROTOCOL
611 if (!EFI_ERROR (Status
)) {
612 *DevPath
= DuplicateDevicePath (ImageDevicePath
);
613 *FilePath
= DuplicateDevicePath (LoadedImage
->FilePath
);
615 LoadedImage
->DeviceHandle
,
616 &gEfiDevicePathProtocolGuid
,
622 &gEfiLoadedImageProtocolGuid
,
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
},
643 Process all Uefi Shell 2.0 command line options.
645 see Uefi Shell 2.0 section 3.2 for full details.
647 the command line must resemble the following:
649 shell.efi [ShellOpt-options] [options] [file-name [file-name-options]]
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.
655 options Options which control the initialization behavior of the shell.
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
662 file-name-options The command-line options that are passed to file-name when it
665 This will initialize the ShellInfoObject.ShellInitSettings global variable.
667 @retval EFI_SUCCESS The variable is initialized.
678 CONST CHAR16
*TempConst
;
681 CHAR16
*ProblemParam
;
687 Status
= ShellCommandLineParse (mShellParamList
, &Package
, NULL
, FALSE
);
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
);
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) {
703 // We found the file... add the rest of the params...
705 for ( ; LoopVar
< gEfiShellParametersProtocol
->Argc
; LoopVar
++) {
706 ASSERT((ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
&& Size
== 0) || (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
));
707 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileOptions
,
711 if (ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
) {
712 SHELL_FREE_NON_NULL(ShellInfoObject
.ShellInitSettings
.FileName
);
713 return (EFI_OUT_OF_RESOURCES
);
715 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileOptions
,
717 gEfiShellParametersProtocol
->Argv
[LoopVar
],
719 if (ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
) {
720 SHELL_FREE_NON_NULL(ShellInfoObject
.ShellInitSettings
.FileName
);
721 return (EFI_OUT_OF_RESOURCES
);
727 ShellCommandLineFreeVarList(Package
);
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
);
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");
747 ShellInfoObject
.ShellInitSettings
.Delay
= 5;
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
':') {
756 if (TempConst
!= NULL
&& !EFI_ERROR(ShellConvertStringToUint64(TempConst
, &Intermediate
, FALSE
, FALSE
))) {
757 ShellInfoObject
.ShellInitSettings
.Delay
= (UINTN
)Intermediate
;
760 ShellCommandLineFreeVarList(Package
);
766 Handles all interaction with the default startup script.
768 this will check that the correct command line parameters were passed, handle the delay, and then start running the script.
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.
773 @retval EFI_SUCCESS the variable is initialized.
778 EFI_DEVICE_PATH_PROTOCOL
*ImagePath
,
779 EFI_DEVICE_PATH_PROTOCOL
*FilePath
785 SHELL_FILE_HANDLE FileHandle
;
786 EFI_DEVICE_PATH_PROTOCOL
*NewPath
;
787 EFI_DEVICE_PATH_PROTOCOL
*NamePath
;
788 CHAR16
*FileStringPath
;
791 CONST CHAR16
*MapName
;
793 Key
.UnicodeChar
= CHAR_NULL
;
797 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
&& ShellInfoObject
.ShellInitSettings
.FileName
!= NULL
) {
799 // launch something else instead
801 NewSize
= StrSize(ShellInfoObject
.ShellInitSettings
.FileName
);
802 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
803 NewSize
+= StrSize(ShellInfoObject
.ShellInitSettings
.FileOptions
) + sizeof(CHAR16
);
805 FileStringPath
= AllocateZeroPool(NewSize
);
806 if (FileStringPath
== NULL
) {
807 return (EFI_OUT_OF_RESOURCES
);
809 StrCpy(FileStringPath
, ShellInfoObject
.ShellInitSettings
.FileName
);
810 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
811 StrCat(FileStringPath
, L
" ");
812 StrCat(FileStringPath
, ShellInfoObject
.ShellInitSettings
.FileOptions
);
814 Status
= RunCommand(FileStringPath
);
815 FreePool(FileStringPath
);
821 // for shell level 0 we do no scripts
822 // Without the Startup bit overriding we allow for nostartup to prevent scripts
824 if ( (PcdGet8(PcdShellSupportLevel
) < 1)
825 || (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
&& !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
)
827 return (EFI_SUCCESS
);
830 gST
->ConOut
->EnableCursor(gST
->ConOut
, FALSE
);
832 // print out our warning and see if they press a key
834 for ( Status
= EFI_UNSUPPORTED
, Delay
= ShellInfoObject
.ShellInitSettings
.Delay
* 10
835 ; Delay
!= 0 && EFI_ERROR(Status
)
838 ShellPrintHiiEx(0, gST
->ConOut
->Mode
->CursorRow
, NULL
, STRING_TOKEN (STR_SHELL_STARTUP_QUESTION
), ShellInfoObject
.HiiHandle
, Delay
/10);
840 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
841 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
844 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CRLF
), ShellInfoObject
.HiiHandle
);
845 gST
->ConOut
->EnableCursor(gST
->ConOut
, TRUE
);
850 if (Status
== EFI_SUCCESS
&& Key
.UnicodeChar
== 0 && Key
.ScanCode
== SCAN_ESC
) {
851 return (EFI_SUCCESS
);
855 // Try the first location (must be file system)
857 MapName
= ShellInfoObject
.NewEfiShellProtocol
->GetMapFromDevicePath(&ImagePath
);
858 if (MapName
!= NULL
) {
859 FileStringPath
= NULL
;
861 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, MapName
, 0);
862 if (FileStringPath
== NULL
) {
863 Status
= EFI_OUT_OF_RESOURCES
;
865 TempSpot
= StrStr(FileStringPath
, L
";");
866 if (TempSpot
!= NULL
) {
867 *TempSpot
= CHAR_NULL
;
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
);
876 if (EFI_ERROR(Status
)) {
877 NamePath
= FileDevicePath (NULL
, mStartupScript
);
878 NewPath
= AppendDevicePathNode (ImagePath
, NamePath
);
884 Status
= InternalOpenFileDevicePath(NewPath
, &FileHandle
, EFI_FILE_MODE_READ
, 0);
888 // If we got a file, run it
890 if (!EFI_ERROR(Status
) && FileHandle
!= NULL
) {
891 Status
= RunScriptFileHandle (FileHandle
, mStartupScript
);
892 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(FileHandle
);
894 FileStringPath
= ShellFindFilePath(mStartupScript
);
895 if (FileStringPath
== NULL
) {
897 // we return success since we dont need to have a startup script
899 Status
= EFI_SUCCESS
;
900 ASSERT(FileHandle
== NULL
);
902 Status
= RunScriptFile(FileStringPath
);
903 FreePool(FileStringPath
);
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.
917 @retval RETURN_ABORTED
928 CONST CHAR16
*CurDir
;
935 // Get screen setting to decide size of the command line buffer
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
;
944 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
949 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, gST
->ConOut
->Mode
->CursorRow
);
951 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
952 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
954 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
958 // Read a line from the console
960 Status
= ShellInfoObject
.NewEfiShellProtocol
->ReadFile(ShellInfoObject
.NewShellParametersProtocol
->StdIn
, &BufferSize
, CmdLine
);
963 // Null terminate the string and parse it
965 if (!EFI_ERROR (Status
)) {
966 CmdLine
[BufferSize
/ sizeof (CHAR16
)] = CHAR_NULL
;
967 Status
= RunCommand(CmdLine
);
971 // Done with this command
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.
981 @param Buffer Something to pass to FreePool when the shell is exiting.
989 BUFFER_LIST
*BufferListEntry
;
991 if (Buffer
== NULL
) {
995 BufferListEntry
= AllocateZeroPool(sizeof(BUFFER_LIST
));
996 ASSERT(BufferListEntry
!= NULL
);
997 BufferListEntry
->Buffer
= Buffer
;
998 InsertTailList(&ShellInfoObject
.BufferToFreeList
.Link
, &BufferListEntry
->Link
);
1003 Add a buffer to the Line History List
1005 @param Buffer The line buffer to add.
1009 AddLineToCommandHistory(
1010 IN CONST CHAR16
*Buffer
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
);
1021 InsertTailList(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
, &Node
->Link
);
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.
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.
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.
1040 IN OUT CHAR16
**CommandString
1043 CONST CHAR16
*NewString
;
1045 NewString
= ShellInfoObject
.NewEfiShellProtocol
->GetAlias(*CommandString
, NULL
);
1046 if (NewString
== NULL
) {
1047 return (EFI_SUCCESS
);
1049 FreePool(*CommandString
);
1050 *CommandString
= AllocateZeroPool(StrSize(NewString
));
1051 if (*CommandString
== NULL
) {
1052 return (EFI_OUT_OF_RESOURCES
);
1054 StrCpy(*CommandString
, NewString
);
1055 return (EFI_SUCCESS
);
1059 Function allocates a new command line and replaces all instances of environment
1060 variable names that are correctly preset to their values.
1062 If the return value is not NULL the memory must be caller freed.
1064 @param[in] OriginalCommandLine The original command line
1066 @retval NULL An error ocurred.
1067 @return The new command line with no environment variables present.
1071 ShellConvertVariables (
1072 IN CONST CHAR16
*OriginalCommandLine
1075 CONST CHAR16
*MasterEnvList
;
1077 CHAR16
*NewCommandLine1
;
1078 CHAR16
*NewCommandLine2
;
1082 SCRIPT_FILE
*CurrentScriptFile
;
1083 ALIAS_LIST
*AliasListNode
;
1085 ASSERT(OriginalCommandLine
!= NULL
);
1088 NewSize
= StrSize(OriginalCommandLine
);
1089 CurrentScriptFile
= ShellCommandGetCurrentScriptFile();
1092 ///@todo update this to handle the %0 - %9 for scripting only (borrow from line 1256 area) ? ? ?
1095 // calculate the size required for the post-conversion string...
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
)
1102 for (Temp
= StrStr(OriginalCommandLine
, AliasListNode
->Alias
)
1104 ; Temp
= StrStr(Temp
+1, AliasListNode
->Alias
)
1107 // we need a preceeding and if there is space no ^ preceeding (if no space ignore)
1109 if ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2)) {
1110 NewSize
+= StrSize(AliasListNode
->CommandString
);
1116 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1117 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
//&& *(MasterEnvList+1) != CHAR_NULL
1118 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1120 if (StrSize(MasterEnvList
) > ItemSize
) {
1121 ItemSize
= StrSize(MasterEnvList
);
1123 for (Temp
= StrStr(OriginalCommandLine
, MasterEnvList
)
1125 ; Temp
= StrStr(Temp
+1, MasterEnvList
)
1128 // we need a preceeding and following % and if there is space no ^ preceeding (if no space ignore)
1130 if (*(Temp
-1) == L
'%' && *(Temp
+StrLen(MasterEnvList
)) == L
'%' &&
1131 ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2))) {
1132 NewSize
+=StrSize(EfiShellGetEnv(MasterEnvList
));
1138 // Quick out if none were found...
1140 if (NewSize
== StrSize(OriginalCommandLine
)) {
1141 ASSERT(Temp
== NULL
);
1142 Temp
= StrnCatGrow(&Temp
, NULL
, OriginalCommandLine
, 0);
1147 // now do the replacements...
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
);
1158 StrCpy(NewCommandLine1
, OriginalCommandLine
);
1159 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1160 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
//&& *(MasterEnvList+1) != CHAR_NULL
1161 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
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
);
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
)
1174 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, AliasListNode
->Alias
, AliasListNode
->CommandString
, TRUE
, FALSE
);
1175 StrCpy(NewCommandLine1
, NewCommandLine2
);
1179 FreePool(NewCommandLine2
);
1182 return (NewCommandLine1
);
1186 Internal function to run a command line with pipe usage.
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.
1192 @retval EFI_SUCCESS The split command is executed successfully.
1193 @retval other Some error occurs when executing the split command.
1198 IN CONST CHAR16
*CmdLine
,
1199 IN SHELL_FILE_HANDLE
*StdIn
,
1200 IN SHELL_FILE_HANDLE
*StdOut
1204 CHAR16
*NextCommandLine
;
1205 CHAR16
*OurCommandLine
;
1209 SHELL_FILE_HANDLE
*TempFileHandle
;
1212 ASSERT(StdOut
== NULL
);
1214 ASSERT(StrStr(CmdLine
, L
"|") != NULL
);
1216 Status
= EFI_SUCCESS
;
1217 NextCommandLine
= NULL
;
1218 OurCommandLine
= NULL
;
1222 NextCommandLine
= StrnCatGrow(&NextCommandLine
, &Size1
, StrStr(CmdLine
, L
"|")+1, 0);
1223 OurCommandLine
= StrnCatGrow(&OurCommandLine
, &Size2
, CmdLine
, StrStr(CmdLine
, L
"|") - CmdLine
);
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
' '
1237 CopyMem(NextCommandLine
, NextCommandLine
+1, StrSize(NextCommandLine
) - sizeof(NextCommandLine
[0]));
1245 // make a SPLIT_LIST item and add to list
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
);
1254 Status
= RunCommand(OurCommandLine
);
1257 // move the output from the first to the in to the second.
1259 TempFileHandle
= Split
->SplitStdOut
;
1260 if (Split
->SplitStdIn
== StdIn
) {
1261 Split
->SplitStdOut
= NULL
;
1263 Split
->SplitStdOut
= Split
->SplitStdIn
;
1265 Split
->SplitStdIn
= TempFileHandle
;
1266 ShellInfoObject
.NewEfiShellProtocol
->SetFilePosition(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdIn
), 0);
1268 if (!EFI_ERROR(Status
)) {
1269 Status
= RunCommand(NextCommandLine
);
1273 // remove the top level from the ScriptList
1275 ASSERT((SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
) == Split
);
1276 RemoveEntryList(&Split
->Link
);
1279 // Note that the original StdIn is now the StdOut...
1281 if (Split
->SplitStdOut
!= NULL
&& Split
->SplitStdOut
!= StdIn
) {
1282 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdOut
));
1284 if (Split
->SplitStdIn
!= NULL
) {
1285 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdIn
));
1289 FreePool(NextCommandLine
);
1290 FreePool(OurCommandLine
);
1296 Function will process and run a command line.
1298 This will determine if the command line represents an internal shell
1299 command or dispatch an external application.
1301 @param[in] CmdLine The command line to parse.
1303 @retval EFI_SUCCESS The command was completed.
1304 @retval EFI_ABORTED The command's operation was aborted.
1309 IN CONST CHAR16
*CmdLine
1313 CHAR16
*CommandName
;
1314 SHELL_STATUS ShellStatus
;
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
;
1333 CHAR16
*CleanOriginal
;
1336 ASSERT(CmdLine
!= NULL
);
1337 if (StrLen(CmdLine
) == 0) {
1338 return (EFI_SUCCESS
);
1342 PostVariableCmdLine
= NULL
;
1343 PostAliasCmdLine
= NULL
;
1344 CommandWithPath
= NULL
;
1346 Status
= EFI_SUCCESS
;
1347 CleanOriginal
= NULL
;
1350 CleanOriginal
= StrnCatGrow(&CleanOriginal
, NULL
, CmdLine
, 0);
1351 if (CleanOriginal
== NULL
) {
1352 return (EFI_OUT_OF_RESOURCES
);
1354 while (CleanOriginal
[StrLen(CleanOriginal
)-1] == L
' ') {
1355 CleanOriginal
[StrLen(CleanOriginal
)-1] = CHAR_NULL
;
1357 while (CleanOriginal
[0] == L
' ') {
1358 CopyMem(CleanOriginal
, CleanOriginal
+1, StrSize(CleanOriginal
) - sizeof(CleanOriginal
[0]));
1362 if (StrStr(CleanOriginal
, L
" ") == NULL
){
1363 StrnCatGrow(&CommandName
, NULL
, CleanOriginal
, 0);
1365 StrnCatGrow(&CommandName
, NULL
, CleanOriginal
, StrStr(CleanOriginal
, L
" ") - CleanOriginal
);
1368 ASSERT(PostAliasCmdLine
== NULL
);
1369 if (!ShellCommandIsCommandOnList(CommandName
)) {
1371 // Convert via alias
1373 Status
= ShellConvertAlias(&CommandName
);
1375 PostAliasCmdLine
= StrnCatGrow(&PostAliasCmdLine
, &PostAliasSize
, CommandName
, 0);
1376 PostAliasCmdLine
= StrnCatGrow(&PostAliasCmdLine
, &PostAliasSize
, StrStr(CleanOriginal
, L
" "), 0);
1377 ASSERT_EFI_ERROR(Status
);
1379 PostAliasCmdLine
= StrnCatGrow(&PostAliasCmdLine
, NULL
, CleanOriginal
, 0);
1382 if (CleanOriginal
!= NULL
) {
1383 FreePool(CleanOriginal
);
1384 CleanOriginal
= NULL
;
1387 if (CommandName
!= NULL
) {
1388 FreePool(CommandName
);
1392 PostVariableCmdLine
= ShellConvertVariables(PostAliasCmdLine
);
1395 // we can now free the modified by alias command line
1397 if (PostAliasCmdLine
!= NULL
) {
1398 FreePool(PostAliasCmdLine
);
1399 PostAliasCmdLine
= NULL
;
1402 if (PostVariableCmdLine
== NULL
) {
1403 return (EFI_OUT_OF_RESOURCES
);
1406 while (PostVariableCmdLine
[StrLen(PostVariableCmdLine
)-1] == L
' ') {
1407 PostVariableCmdLine
[StrLen(PostVariableCmdLine
)-1] = CHAR_NULL
;
1409 while (PostVariableCmdLine
[0] == L
' ') {
1410 CopyMem(PostVariableCmdLine
, PostVariableCmdLine
+1, StrSize(PostVariableCmdLine
) - sizeof(PostVariableCmdLine
[0]));
1414 // We dont do normal processing with a split command line (output from one command input to another)
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
'|') {
1421 } else if (*TempLocation3
== L
'|') {
1426 if (TempLocation3
!= NULL
&& *TempLocation3
!= CHAR_NULL
) {
1428 // are we in an existing split???
1430 if (!IsListEmpty(&ShellInfoObject
.SplitList
.Link
)) {
1431 Split
= (SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
);
1434 if (Split
== NULL
) {
1435 Status
= RunSplitCommand(PostVariableCmdLine
, NULL
, NULL
);
1437 Status
= RunSplitCommand(PostVariableCmdLine
, Split
->SplitStdIn
, Split
->SplitStdOut
);
1439 if (EFI_ERROR(Status
)) {
1440 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_SPLIT
), ShellInfoObject
.HiiHandle
, PostVariableCmdLine
);
1445 // If this is a mapped drive change handle that...
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
);
1452 FreePool(PostVariableCmdLine
);
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...
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
);
1466 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_REDIR
), ShellInfoObject
.HiiHandle
);
1469 while (PostVariableCmdLine
[StrLen(PostVariableCmdLine
)-1] == L
' ') {
1470 PostVariableCmdLine
[StrLen(PostVariableCmdLine
)-1] = CHAR_NULL
;
1472 while (PostVariableCmdLine
[0] == L
' ') {
1473 CopyMem(PostVariableCmdLine
, PostVariableCmdLine
+1, StrSize(PostVariableCmdLine
) - sizeof(PostVariableCmdLine
[0]));
1477 // get the argc and argv updated for internal commands
1479 Status
= UpdateArgcArgv(ShellInfoObject
.NewShellParametersProtocol
, PostVariableCmdLine
, &Argv
, &Argc
);
1480 ASSERT_EFI_ERROR(Status
);
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
)
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
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];
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];
1499 ShellInfoObject
.NewShellParametersProtocol
->Argv
[0] = NULL
;
1500 ShellInfoObject
.NewShellParametersProtocol
->Argv
[0] = StrnCatGrow(&ShellInfoObject
.NewShellParametersProtocol
->Argv
[0], NULL
, L
"help", 0);
1508 if (ShellCommandIsCommandOnList(ShellInfoObject
.NewShellParametersProtocol
->Argv
[0])) {
1510 // Run the command (which was converted if it was an alias)
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
););
1518 InternalEfiShellSetEnv(L
"Lasterror", LeString
, TRUE
);
1521 // Pass thru the exitcode from the app.
1523 if (ShellCommandGetExit()) {
1524 Status
= ShellStatus
;
1525 } else if (ShellStatus
!= 0 && IsScriptOnlyCommand(ShellInfoObject
.NewShellParametersProtocol
->Argv
[0])) {
1526 Status
= EFI_ABORTED
;
1531 // run an external file (or script)
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);
1539 if (CommandWithPath
== NULL
) {
1540 CommandWithPath
= ShellFindFilePathEx(ShellInfoObject
.NewShellParametersProtocol
->Argv
[0], mExecutableExtensions
);
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]);
1546 // Check if it's a NSH (script) file.
1548 TempLocation
= CommandWithPath
+StrLen(CommandWithPath
)-4;
1549 TempLocation2
= mScriptExtension
;
1550 if ((StrLen(CommandWithPath
) > 4) && (StringNoCaseCompare((VOID
*)(&TempLocation
), (VOID
*)(&TempLocation2
)) == 0)) {
1551 Status
= RunScriptFile (CommandWithPath
);
1553 DevPath
= ShellInfoObject
.NewEfiShellProtocol
->GetDevicePathFromFilePath(CommandWithPath
);
1554 ASSERT(DevPath
!= NULL
);
1555 Status
= InternalShellExecuteDevicePath(
1558 PostVariableCmdLine
,
1565 CommandName
= StrnCatGrow(&CommandName
, NULL
, ShellInfoObject
.NewShellParametersProtocol
->Argv
[0], 0);
1567 RestoreArgcArgv(ShellInfoObject
.NewShellParametersProtocol
, &Argv
, &Argc
);
1569 RestoreStdInStdOutStdErr(ShellInfoObject
.NewShellParametersProtocol
, &OriginalStdIn
, &OriginalStdOut
, &OriginalStdErr
, &OriginalSystemTableInfo
);
1571 if (CommandName
!= NULL
) {
1572 if (ShellCommandGetCurrentScriptFile() != NULL
&& !IsScriptOnlyCommand(CommandName
)) {
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...)
1577 Status
= EFI_SUCCESS
;
1582 SHELL_FREE_NON_NULL(CommandName
);
1583 SHELL_FREE_NON_NULL(CommandWithPath
);
1584 SHELL_FREE_NON_NULL(PostVariableCmdLine
);
1589 STATIC CONST UINT16 InvalidChars
[] = {L
'*', L
'?', L
'<', L
'>', L
'\\', L
'/', L
'\"', 0x0001, 0x0002};
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.
1594 @param[in] CommandName The name to check
1596 @retval TRUE CommandName could be a command name
1597 @retval FALSE CommandName could not be a valid command name
1602 IN CONST CHAR16
*CommandName
1606 if (CommandName
== NULL
) {
1611 ; Count
< sizeof(InvalidChars
) / sizeof(InvalidChars
[0])
1614 if (ScanMem16(CommandName
, StrSize(CommandName
), InvalidChars
[Count
]) != NULL
) {
1622 Function to process a NSH script file via SHELL_FILE_HANDLE.
1624 @param[in] Handle The handle to the already opened file.
1625 @param[in] Name The name of the script file.
1627 @retval EFI_SUCCESS the script completed sucessfully
1631 RunScriptFileHandle (
1632 IN SHELL_FILE_HANDLE Handle
,
1633 IN CONST CHAR16
*Name
1637 SCRIPT_FILE
*NewScriptFile
;
1639 CHAR16
*CommandLine
;
1640 CHAR16
*CommandLine2
;
1641 CHAR16
*CommandLine3
;
1642 SCRIPT_COMMAND_LIST
*LastCommand
;
1644 BOOLEAN PreScriptEchoState
;
1645 BOOLEAN PreCommandEchoState
;
1646 CONST CHAR16
*CurDir
;
1648 CHAR16 LeString
[50];
1650 ASSERT(!ShellCommandGetScriptExit());
1652 PreScriptEchoState
= ShellCommandGetEchoState();
1654 NewScriptFile
= (SCRIPT_FILE
*)AllocateZeroPool(sizeof(SCRIPT_FILE
));
1655 if (NewScriptFile
== NULL
) {
1656 return (EFI_OUT_OF_RESOURCES
);
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
);
1670 // Save the parameters (used to replace %0 to %9 later on)
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
);
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
);
1688 NewScriptFile
->Argv
= NULL
;
1691 InitializeListHead(&NewScriptFile
->CommandList
);
1692 InitializeListHead(&NewScriptFile
->SubstList
);
1695 // Now build the list of all script commands.
1698 while(!ShellFileHandleEof(Handle
)) {
1699 CommandLine
= ShellFileHandleReturnLine(Handle
, &Ascii
);
1701 if (CommandLine
== NULL
|| StrLen(CommandLine
) == 0) {
1704 NewScriptFile
->CurrentCommand
= AllocateZeroPool(sizeof(SCRIPT_COMMAND_LIST
));
1705 if (NewScriptFile
->CurrentCommand
== NULL
) {
1706 DeleteScriptFileStruct(NewScriptFile
);
1707 return (EFI_OUT_OF_RESOURCES
);
1710 NewScriptFile
->CurrentCommand
->Cl
= CommandLine
;
1711 NewScriptFile
->CurrentCommand
->Data
= NULL
;
1712 NewScriptFile
->CurrentCommand
->Line
= LineCount
;
1714 InsertTailList(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
1718 // Add this as the topmost script file
1720 ShellCommandSetNewScript (NewScriptFile
);
1723 // Now enumerate through the commands and run each one.
1725 CommandLine
= AllocateZeroPool(PcdGet16(PcdShellPrintBufferSize
));
1726 if (CommandLine
== NULL
) {
1727 DeleteScriptFileStruct(NewScriptFile
);
1728 return (EFI_OUT_OF_RESOURCES
);
1730 CommandLine2
= AllocateZeroPool(PcdGet16(PcdShellPrintBufferSize
));
1731 if (CommandLine2
== NULL
) {
1732 FreePool(CommandLine
);
1733 DeleteScriptFileStruct(NewScriptFile
);
1734 return (EFI_OUT_OF_RESOURCES
);
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
1741 ASSERT(CommandLine2
!= NULL
);
1742 StrCpy(CommandLine2
, NewScriptFile
->CurrentCommand
->Cl
);
1745 // NULL out comments
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]));
1752 } else if (*CommandLine3
== L
'#') {
1753 *CommandLine3
= CHAR_NULL
;
1757 if (CommandLine2
!= NULL
&& StrLen(CommandLine2
) >= 1) {
1759 // Due to variability in starting the find and replace action we need to have both buffers the same.
1761 StrCpy(CommandLine
, CommandLine2
);
1764 // Remove the %0 to %9 from the command line (if we have some arguments)
1766 if (NewScriptFile
->Argv
!= NULL
) {
1767 switch (NewScriptFile
->Argc
) {
1769 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%9", NewScriptFile
->Argv
[9], FALSE
, TRUE
);
1770 ASSERT_EFI_ERROR(Status
);
1772 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%8", NewScriptFile
->Argv
[8], FALSE
, TRUE
);
1773 ASSERT_EFI_ERROR(Status
);
1775 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%7", NewScriptFile
->Argv
[7], FALSE
, TRUE
);
1776 ASSERT_EFI_ERROR(Status
);
1778 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%6", NewScriptFile
->Argv
[6], FALSE
, TRUE
);
1779 ASSERT_EFI_ERROR(Status
);
1781 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%5", NewScriptFile
->Argv
[5], FALSE
, TRUE
);
1782 ASSERT_EFI_ERROR(Status
);
1784 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%4", NewScriptFile
->Argv
[4], FALSE
, TRUE
);
1785 ASSERT_EFI_ERROR(Status
);
1787 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%3", NewScriptFile
->Argv
[3], FALSE
, TRUE
);
1788 ASSERT_EFI_ERROR(Status
);
1790 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%2", NewScriptFile
->Argv
[2], FALSE
, TRUE
);
1791 ASSERT_EFI_ERROR(Status
);
1793 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%1", NewScriptFile
->Argv
[1], FALSE
, TRUE
);
1794 ASSERT_EFI_ERROR(Status
);
1796 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%0", NewScriptFile
->Argv
[0], FALSE
, TRUE
);
1797 ASSERT_EFI_ERROR(Status
);
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
);
1813 StrCpy(CommandLine2
, CommandLine
);
1815 LastCommand
= NewScriptFile
->CurrentCommand
;
1817 for (CommandLine3
= CommandLine2
; CommandLine3
[0] == L
' ' ; CommandLine3
++);
1819 if (CommandLine3
!= NULL
&& CommandLine3
[0] == L
':' ) {
1821 // This line is a goto target / label
1824 if (CommandLine3
!= NULL
&& StrLen(CommandLine3
) > 0) {
1825 if (CommandLine3
[0] == L
'@') {
1827 // We need to save the current echo state
1828 // and disable echo for just this command.
1830 PreCommandEchoState
= ShellCommandGetEchoState();
1831 ShellCommandSetEchoState(FALSE
);
1832 Status
= RunCommand(CommandLine3
+1);
1835 // Now restore the pre-'@' echo state.
1837 ShellCommandSetEchoState(PreCommandEchoState
);
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
);
1844 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
1846 ShellPrintEx(-1, -1, L
"%s\r\n", CommandLine2
);
1848 Status
= RunCommand(CommandLine3
);
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
);
1857 ShellCommandRegisterExit(FALSE
, 0);
1858 Status
= EFI_SUCCESS
;
1861 if (EFI_ERROR(Status
)) {
1864 if (ShellCommandGetExit()) {
1869 // If that commend did not update the CurrentCommand then we need to advance it...
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
;
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
;
1886 FreePool(CommandLine
);
1887 FreePool(CommandLine2
);
1888 ShellCommandSetNewScript (NULL
);
1891 // Only if this was the last script reset the state.
1893 if (ShellCommandGetCurrentScriptFile()==NULL
) {
1894 ShellCommandSetEchoState(PreScriptEchoState
);
1896 return (EFI_SUCCESS
);
1900 Function to process a NSH script file.
1902 @param[in] ScriptPath Pointer to the script file name (including file system path).
1904 @retval EFI_SUCCESS the script completed sucessfully
1909 IN CONST CHAR16
*ScriptPath
1913 SHELL_FILE_HANDLE FileHandle
;
1915 if (ShellIsFile(ScriptPath
) != EFI_SUCCESS
) {
1916 return (EFI_INVALID_PARAMETER
);
1919 Status
= ShellOpenFileByName(ScriptPath
, &FileHandle
, EFI_FILE_MODE_READ
, 0);
1920 if (EFI_ERROR(Status
)) {
1924 Status
= RunScriptFileHandle(FileHandle
, ScriptPath
);
1926 ShellCloseFile(&FileHandle
);