2 This is THE shell (application)
4 Copyright (c) 2009 - 2011, 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
);
831 // print out our warning and see if they press a key
833 for ( Status
= EFI_UNSUPPORTED
, Delay
= ShellInfoObject
.ShellInitSettings
.Delay
* 10
834 ; Delay
!= 0 && EFI_ERROR(Status
)
837 ShellPrintHiiEx(0, gST
->ConOut
->Mode
->CursorRow
, NULL
, STRING_TOKEN (STR_SHELL_STARTUP_QUESTION
), ShellInfoObject
.HiiHandle
, Delay
/10);
839 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
840 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
843 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CRLF
), ShellInfoObject
.HiiHandle
);
848 if (Status
== EFI_SUCCESS
&& Key
.UnicodeChar
== 0 && Key
.ScanCode
== SCAN_ESC
) {
849 return (EFI_SUCCESS
);
853 // Try the first location (must be file system)
855 MapName
= ShellInfoObject
.NewEfiShellProtocol
->GetMapFromDevicePath(&ImagePath
);
856 if (MapName
!= NULL
) {
857 FileStringPath
= NULL
;
859 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, MapName
, 0);
860 TempSpot
= StrStr(FileStringPath
, L
";");
861 if (TempSpot
!= NULL
) {
862 *TempSpot
= CHAR_NULL
;
864 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, ((FILEPATH_DEVICE_PATH
*)FilePath
)->PathName
, 0);
865 PathRemoveLastItem(FileStringPath
);
866 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, mStartupScript
, 0);
867 Status
= ShellInfoObject
.NewEfiShellProtocol
->OpenFileByName(FileStringPath
, &FileHandle
, EFI_FILE_MODE_READ
);
868 FreePool(FileStringPath
);
870 if (EFI_ERROR(Status
)) {
871 NamePath
= FileDevicePath (NULL
, mStartupScript
);
872 NewPath
= AppendDevicePathNode (ImagePath
, NamePath
);
878 Status
= InternalOpenFileDevicePath(NewPath
, &FileHandle
, EFI_FILE_MODE_READ
, 0);
882 // If we got a file, run it
884 if (!EFI_ERROR(Status
) && FileHandle
!= NULL
) {
885 Status
= RunScriptFileHandle (FileHandle
, mStartupScript
);
886 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(FileHandle
);
888 FileStringPath
= ShellFindFilePath(mStartupScript
);
889 if (FileStringPath
== NULL
) {
891 // we return success since we dont need to have a startup script
893 Status
= EFI_SUCCESS
;
894 ASSERT(FileHandle
== NULL
);
896 Status
= RunScriptFile(FileStringPath
);
897 FreePool(FileStringPath
);
906 Function to perform the shell prompt looping. It will do a single prompt,
907 dispatch the result, and then return. It is expected that the caller will
908 call this function in a loop many times.
911 @retval RETURN_ABORTED
922 CONST CHAR16
*CurDir
;
929 // Get screen setting to decide size of the command line buffer
931 gST
->ConOut
->QueryMode (gST
->ConOut
, gST
->ConOut
->Mode
->Mode
, &Column
, &Row
);
932 BufferSize
= Column
* Row
* sizeof (CHAR16
);
933 CmdLine
= AllocateZeroPool (BufferSize
);
934 if (CmdLine
== NULL
) {
935 return EFI_OUT_OF_RESOURCES
;
938 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
943 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, gST
->ConOut
->Mode
->CursorRow
);
945 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
946 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
948 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
952 // Read a line from the console
954 Status
= ShellInfoObject
.NewEfiShellProtocol
->ReadFile(ShellInfoObject
.NewShellParametersProtocol
->StdIn
, &BufferSize
, CmdLine
);
957 // Null terminate the string and parse it
959 if (!EFI_ERROR (Status
)) {
960 CmdLine
[BufferSize
/ sizeof (CHAR16
)] = CHAR_NULL
;
961 Status
= RunCommand(CmdLine
);
965 // Done with this command
972 Add a buffer to the Buffer To Free List for safely returning buffers to other
973 places without risking letting them modify internal shell information.
975 @param Buffer Something to pass to FreePool when the shell is exiting.
983 BUFFER_LIST
*BufferListEntry
;
985 if (Buffer
== NULL
) {
989 BufferListEntry
= AllocateZeroPool(sizeof(BUFFER_LIST
));
990 ASSERT(BufferListEntry
!= NULL
);
991 BufferListEntry
->Buffer
= Buffer
;
992 InsertTailList(&ShellInfoObject
.BufferToFreeList
.Link
, &BufferListEntry
->Link
);
997 Add a buffer to the Line History List
999 @param Buffer The line buffer to add.
1003 AddLineToCommandHistory(
1004 IN CONST CHAR16
*Buffer
1009 Node
= AllocateZeroPool(sizeof(BUFFER_LIST
));
1010 ASSERT(Node
!= NULL
);
1011 Node
->Buffer
= AllocateZeroPool(StrSize(Buffer
));
1012 ASSERT(Node
->Buffer
!= NULL
);
1013 StrCpy(Node
->Buffer
, Buffer
);
1015 InsertTailList(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
, &Node
->Link
);
1019 Checks if a string is an alias for another command. If yes, then it replaces the alias name
1020 with the correct command name.
1022 @param[in, out] CommandString Upon entry the potential alias. Upon return the
1023 command name if it was an alias. If it was not
1024 an alias it will be unchanged. This function may
1025 change the buffer to fit the command name.
1027 @retval EFI_SUCCESS The name was changed.
1028 @retval EFI_SUCCESS The name was not an alias.
1029 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
1034 IN OUT CHAR16
**CommandString
1037 CONST CHAR16
*NewString
;
1039 NewString
= ShellInfoObject
.NewEfiShellProtocol
->GetAlias(*CommandString
, NULL
);
1040 if (NewString
== NULL
) {
1041 return (EFI_SUCCESS
);
1043 FreePool(*CommandString
);
1044 *CommandString
= AllocateZeroPool(StrSize(NewString
));
1045 if (*CommandString
== NULL
) {
1046 return (EFI_OUT_OF_RESOURCES
);
1048 StrCpy(*CommandString
, NewString
);
1049 return (EFI_SUCCESS
);
1053 Function allocates a new command line and replaces all instances of environment
1054 variable names that are correctly preset to their values.
1056 If the return value is not NULL the memory must be caller freed.
1058 @param[in] OriginalCommandLine The original command line
1060 @retval NULL An error ocurred.
1061 @return The new command line with no environment variables present.
1065 ShellConvertVariables (
1066 IN CONST CHAR16
*OriginalCommandLine
1069 CONST CHAR16
*MasterEnvList
;
1071 CHAR16
*NewCommandLine1
;
1072 CHAR16
*NewCommandLine2
;
1076 SCRIPT_FILE
*CurrentScriptFile
;
1077 ALIAS_LIST
*AliasListNode
;
1079 ASSERT(OriginalCommandLine
!= NULL
);
1082 NewSize
= StrSize(OriginalCommandLine
);
1083 CurrentScriptFile
= ShellCommandGetCurrentScriptFile();
1086 ///@todo update this to handle the %0 - %9 for scripting only (borrow from line 1256 area) ? ? ?
1089 // calculate the size required for the post-conversion string...
1091 if (CurrentScriptFile
!= NULL
) {
1092 for (AliasListNode
= (ALIAS_LIST
*)GetFirstNode(&CurrentScriptFile
->SubstList
)
1093 ; !IsNull(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1094 ; AliasListNode
= (ALIAS_LIST
*)GetNextNode(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1096 for (Temp
= StrStr(OriginalCommandLine
, AliasListNode
->Alias
)
1098 ; Temp
= StrStr(Temp
+1, AliasListNode
->Alias
)
1101 // we need a preceeding and if there is space no ^ preceeding (if no space ignore)
1103 if ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2)) {
1104 NewSize
+= StrSize(AliasListNode
->CommandString
);
1110 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1111 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
//&& *(MasterEnvList+1) != CHAR_NULL
1112 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1114 if (StrSize(MasterEnvList
) > ItemSize
) {
1115 ItemSize
= StrSize(MasterEnvList
);
1117 for (Temp
= StrStr(OriginalCommandLine
, MasterEnvList
)
1119 ; Temp
= StrStr(Temp
+1, MasterEnvList
)
1122 // we need a preceeding and following % and if there is space no ^ preceeding (if no space ignore)
1124 if (*(Temp
-1) == L
'%' && *(Temp
+StrLen(MasterEnvList
)) == L
'%' &&
1125 ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2))) {
1126 NewSize
+=StrSize(EfiShellGetEnv(MasterEnvList
));
1132 // Quick out if none were found...
1134 if (NewSize
== StrSize(OriginalCommandLine
)) {
1135 ASSERT(Temp
== NULL
);
1136 Temp
= StrnCatGrow(&Temp
, NULL
, OriginalCommandLine
, 0);
1141 // now do the replacements...
1143 NewCommandLine1
= AllocateZeroPool(NewSize
);
1144 NewCommandLine2
= AllocateZeroPool(NewSize
);
1145 ItemTemp
= AllocateZeroPool(ItemSize
+(2*sizeof(CHAR16
)));
1146 if (NewCommandLine1
== NULL
|| NewCommandLine2
== NULL
|| ItemTemp
== NULL
) {
1147 SHELL_FREE_NON_NULL(NewCommandLine1
);
1148 SHELL_FREE_NON_NULL(NewCommandLine2
);
1149 SHELL_FREE_NON_NULL(ItemTemp
);
1152 StrCpy(NewCommandLine1
, OriginalCommandLine
);
1153 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1154 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
//&& *(MasterEnvList+1) != CHAR_NULL
1155 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1157 StrCpy(ItemTemp
, L
"%");
1158 StrCat(ItemTemp
, MasterEnvList
);
1159 StrCat(ItemTemp
, L
"%");
1160 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, ItemTemp
, EfiShellGetEnv(MasterEnvList
), TRUE
, FALSE
);
1161 StrCpy(NewCommandLine1
, NewCommandLine2
);
1163 if (CurrentScriptFile
!= NULL
) {
1164 for (AliasListNode
= (ALIAS_LIST
*)GetFirstNode(&CurrentScriptFile
->SubstList
)
1165 ; !IsNull(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1166 ; AliasListNode
= (ALIAS_LIST
*)GetNextNode(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1168 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, AliasListNode
->Alias
, AliasListNode
->CommandString
, TRUE
, FALSE
);
1169 StrCpy(NewCommandLine1
, NewCommandLine2
);
1173 FreePool(NewCommandLine2
);
1176 return (NewCommandLine1
);
1180 Internal function to run a command line with pipe usage.
1182 @param[in] CmdLine The pointer to the command line.
1183 @param[in] StdIn The pointer to the Standard input.
1184 @param[in] StdOut The pointer to the Standard output.
1186 @retval EFI_SUCCESS The split command is executed successfully.
1187 @retval other Some error occurs when executing the split command.
1192 IN CONST CHAR16
*CmdLine
,
1193 IN SHELL_FILE_HANDLE
*StdIn
,
1194 IN SHELL_FILE_HANDLE
*StdOut
1198 CHAR16
*NextCommandLine
;
1199 CHAR16
*OurCommandLine
;
1203 SHELL_FILE_HANDLE
*TempFileHandle
;
1206 ASSERT(StdOut
== NULL
);
1208 ASSERT(StrStr(CmdLine
, L
"|") != NULL
);
1210 Status
= EFI_SUCCESS
;
1211 NextCommandLine
= NULL
;
1212 OurCommandLine
= NULL
;
1216 NextCommandLine
= StrnCatGrow(&NextCommandLine
, &Size1
, StrStr(CmdLine
, L
"|")+1, 0);
1217 OurCommandLine
= StrnCatGrow(&OurCommandLine
, &Size2
, CmdLine
, StrStr(CmdLine
, L
"|") - CmdLine
);
1218 if (NextCommandLine
[0] != CHAR_NULL
&&
1219 NextCommandLine
[0] == L
'a' &&
1220 NextCommandLine
[1] == L
' '
1222 CopyMem(NextCommandLine
, NextCommandLine
+1, StrSize(NextCommandLine
) - sizeof(NextCommandLine
[0]));
1230 // make a SPLIT_LIST item and add to list
1232 Split
= AllocateZeroPool(sizeof(SPLIT_LIST
));
1233 ASSERT(Split
!= NULL
);
1234 Split
->SplitStdIn
= StdIn
;
1235 Split
->SplitStdOut
= ConvertEfiFileProtocolToShellHandle(CreateFileInterfaceMem(Unicode
), NULL
);
1236 ASSERT(Split
->SplitStdOut
!= NULL
);
1237 InsertHeadList(&ShellInfoObject
.SplitList
.Link
, &Split
->Link
);
1239 ASSERT(StrStr(OurCommandLine
, L
"|") == NULL
);
1240 Status
= RunCommand(OurCommandLine
);
1243 // move the output from the first to the in to the second.
1245 TempFileHandle
= Split
->SplitStdOut
;
1246 if (Split
->SplitStdIn
== StdIn
) {
1247 Split
->SplitStdOut
= NULL
;
1249 Split
->SplitStdOut
= Split
->SplitStdIn
;
1251 Split
->SplitStdIn
= TempFileHandle
;
1252 ShellInfoObject
.NewEfiShellProtocol
->SetFilePosition(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdIn
), 0);
1254 if (!EFI_ERROR(Status
)) {
1255 Status
= RunCommand(NextCommandLine
);
1259 // remove the top level from the ScriptList
1261 ASSERT((SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
) == Split
);
1262 RemoveEntryList(&Split
->Link
);
1265 // Note that the original StdIn is now the StdOut...
1267 if (Split
->SplitStdOut
!= NULL
&& Split
->SplitStdOut
!= StdIn
) {
1268 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdOut
));
1270 if (Split
->SplitStdIn
!= NULL
) {
1271 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdIn
));
1275 FreePool(NextCommandLine
);
1276 FreePool(OurCommandLine
);
1282 Function will process and run a command line.
1284 This will determine if the command line represents an internal shell
1285 command or dispatch an external application.
1287 @param[in] CmdLine The command line to parse.
1289 @retval EFI_SUCCESS The command was completed.
1290 @retval EFI_ABORTED The command's operation was aborted.
1295 IN CONST CHAR16
*CmdLine
1299 CHAR16
*CommandName
;
1300 SHELL_STATUS ShellStatus
;
1304 CHAR16 LeString
[11];
1305 CHAR16
*PostAliasCmdLine
;
1306 UINTN PostAliasSize
;
1307 CHAR16
*PostVariableCmdLine
;
1308 CHAR16
*CommandWithPath
;
1309 CONST EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
1310 CONST CHAR16
*TempLocation
;
1311 CONST CHAR16
*TempLocation2
;
1312 SHELL_FILE_HANDLE OriginalStdIn
;
1313 SHELL_FILE_HANDLE OriginalStdOut
;
1314 SHELL_FILE_HANDLE OriginalStdErr
;
1315 SYSTEM_TABLE_INFO OriginalSystemTableInfo
;
1316 CHAR16
*TempLocation3
;
1319 CHAR16
*CleanOriginal
;
1322 ASSERT(CmdLine
!= NULL
);
1323 if (StrLen(CmdLine
) == 0) {
1324 return (EFI_SUCCESS
);
1328 PostVariableCmdLine
= NULL
;
1329 PostAliasCmdLine
= NULL
;
1330 CommandWithPath
= NULL
;
1332 Status
= EFI_SUCCESS
;
1333 CleanOriginal
= NULL
;
1336 CleanOriginal
= StrnCatGrow(&CleanOriginal
, NULL
, CmdLine
, 0);
1337 while (CleanOriginal
[StrLen(CleanOriginal
)-1] == L
' ') {
1338 CleanOriginal
[StrLen(CleanOriginal
)-1] = CHAR_NULL
;
1340 while (CleanOriginal
[0] == L
' ') {
1341 CopyMem(CleanOriginal
, CleanOriginal
+1, StrSize(CleanOriginal
) - sizeof(CleanOriginal
[0]));
1345 if (StrStr(CleanOriginal
, L
" ") == NULL
){
1346 StrnCatGrow(&CommandName
, NULL
, CleanOriginal
, 0);
1348 StrnCatGrow(&CommandName
, NULL
, CleanOriginal
, StrStr(CleanOriginal
, L
" ") - CleanOriginal
);
1351 ASSERT(PostAliasCmdLine
== NULL
);
1352 if (!ShellCommandIsCommandOnList(CommandName
)) {
1354 // Convert via alias
1356 Status
= ShellConvertAlias(&CommandName
);
1358 PostAliasCmdLine
= StrnCatGrow(&PostAliasCmdLine
, &PostAliasSize
, CommandName
, 0);
1359 PostAliasCmdLine
= StrnCatGrow(&PostAliasCmdLine
, &PostAliasSize
, StrStr(CleanOriginal
, L
" "), 0);
1360 ASSERT_EFI_ERROR(Status
);
1362 PostAliasCmdLine
= StrnCatGrow(&PostAliasCmdLine
, NULL
, CleanOriginal
, 0);
1365 if (CleanOriginal
!= NULL
) {
1366 FreePool(CleanOriginal
);
1367 CleanOriginal
= NULL
;
1370 if (CommandName
!= NULL
) {
1371 FreePool(CommandName
);
1375 PostVariableCmdLine
= ShellConvertVariables(PostAliasCmdLine
);
1378 // we can now free the modified by alias command line
1380 if (PostAliasCmdLine
!= NULL
) {
1381 FreePool(PostAliasCmdLine
);
1382 PostAliasCmdLine
= NULL
;
1385 if (PostVariableCmdLine
== NULL
) {
1386 return (EFI_OUT_OF_RESOURCES
);
1389 while (PostVariableCmdLine
[StrLen(PostVariableCmdLine
)-1] == L
' ') {
1390 PostVariableCmdLine
[StrLen(PostVariableCmdLine
)-1] = CHAR_NULL
;
1392 while (PostVariableCmdLine
[0] == L
' ') {
1393 CopyMem(PostVariableCmdLine
, PostVariableCmdLine
+1, StrSize(PostVariableCmdLine
) - sizeof(PostVariableCmdLine
[0]));
1397 // We dont do normal processing with a split command line (output from one command input to another)
1399 TempLocation3
= NULL
;
1400 if (StrStr(PostVariableCmdLine
, L
"|") != NULL
) {
1401 for (TempLocation3
= PostVariableCmdLine
; TempLocation3
!= NULL
&& *TempLocation3
!= CHAR_NULL
; TempLocation3
++) {
1402 if (*TempLocation3
== L
'^' && *(TempLocation3
+1) == L
'|') {
1404 } else if (*TempLocation3
== L
'|') {
1409 if (TempLocation3
!= NULL
&& *TempLocation3
!= CHAR_NULL
) {
1411 // are we in an existing split???
1413 if (!IsListEmpty(&ShellInfoObject
.SplitList
.Link
)) {
1414 Split
= (SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
);
1417 if (Split
== NULL
) {
1418 Status
= RunSplitCommand(PostVariableCmdLine
, NULL
, NULL
);
1420 Status
= RunSplitCommand(PostVariableCmdLine
, Split
->SplitStdIn
, Split
->SplitStdOut
);
1425 // If this is a mapped drive change handle that...
1427 if (PostVariableCmdLine
[(StrLen(PostVariableCmdLine
)-1)] == L
':' && StrStr(PostVariableCmdLine
, L
" ") == NULL
) {
1428 Status
= ShellInfoObject
.NewEfiShellProtocol
->SetCurDir(NULL
, PostVariableCmdLine
);
1429 if (EFI_ERROR(Status
)) {
1430 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_MAPPING
), ShellInfoObject
.HiiHandle
, PostVariableCmdLine
);
1432 FreePool(PostVariableCmdLine
);
1436 ///@todo update this section to divide into 3 ways - run internal command, run split (above), and run an external file...
1437 /// We waste a lot of time doing processing like StdIn,StdOut,Argv,Argc for things that are external files...
1441 Status
= UpdateStdInStdOutStdErr(ShellInfoObject
.NewShellParametersProtocol
, PostVariableCmdLine
, &OriginalStdIn
, &OriginalStdOut
, &OriginalStdErr
, &OriginalSystemTableInfo
);
1442 if (EFI_ERROR(Status
)) {
1443 if (Status
== EFI_NOT_FOUND
) {
1444 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_REDUNDA_REDIR
), ShellInfoObject
.HiiHandle
);
1446 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_REDIR
), ShellInfoObject
.HiiHandle
);
1449 while (PostVariableCmdLine
[StrLen(PostVariableCmdLine
)-1] == L
' ') {
1450 PostVariableCmdLine
[StrLen(PostVariableCmdLine
)-1] = CHAR_NULL
;
1452 while (PostVariableCmdLine
[0] == L
' ') {
1453 CopyMem(PostVariableCmdLine
, PostVariableCmdLine
+1, StrSize(PostVariableCmdLine
) - sizeof(PostVariableCmdLine
[0]));
1457 // get the argc and argv updated for internal commands
1459 Status
= UpdateArgcArgv(ShellInfoObject
.NewShellParametersProtocol
, PostVariableCmdLine
, &Argv
, &Argc
);
1460 ASSERT_EFI_ERROR(Status
);
1462 for (Count
= 0 ; Count
< ShellInfoObject
.NewShellParametersProtocol
->Argc
; Count
++) {
1463 if (StrStr(ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count
], L
"-?") == ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count
]
1464 || (ShellInfoObject
.NewShellParametersProtocol
->Argv
[0][0] == L
'?' && ShellInfoObject
.NewShellParametersProtocol
->Argv
[0][1] == CHAR_NULL
)
1467 // We need to redo the arguments since a parameter was -?
1468 // move them all down 1 to the end, then up one then replace the first with help
1470 FreePool(ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count
]);
1471 ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count
] = NULL
;
1472 for (Count2
= Count
; (Count2
+ 1) < ShellInfoObject
.NewShellParametersProtocol
->Argc
; Count2
++) {
1473 ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count2
] = ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count2
+1];
1475 ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count2
] = NULL
;
1476 for (Count2
= ShellInfoObject
.NewShellParametersProtocol
->Argc
-1 ; Count2
> 0 ; Count2
--) {
1477 ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count2
] = ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count2
-1];
1479 ShellInfoObject
.NewShellParametersProtocol
->Argv
[0] = NULL
;
1480 ShellInfoObject
.NewShellParametersProtocol
->Argv
[0] = StrnCatGrow(&ShellInfoObject
.NewShellParametersProtocol
->Argv
[0], NULL
, L
"help", 0);
1488 if (ShellCommandIsCommandOnList(ShellInfoObject
.NewShellParametersProtocol
->Argv
[0])) {
1490 // Run the command (which was converted if it was an alias)
1492 if (!EFI_ERROR(Status
)) {
1493 Status
= ShellCommandRunCommandHandler(ShellInfoObject
.NewShellParametersProtocol
->Argv
[0], &ShellStatus
, &LastError
);
1494 ASSERT_EFI_ERROR(Status
);
1495 UnicodeSPrint(LeString
, sizeof(LeString
)*sizeof(LeString
[0]), L
"0x%08x", ShellStatus
);
1496 DEBUG_CODE(InternalEfiShellSetEnv(L
"DebugLasterror", LeString
, TRUE
););
1498 InternalEfiShellSetEnv(L
"Lasterror", LeString
, TRUE
);
1501 // Pass thru the exitcode from the app.
1503 if (ShellCommandGetExit()) {
1504 Status
= ShellStatus
;
1505 } else if (ShellStatus
!= 0 && IsScriptOnlyCommand(ShellInfoObject
.NewShellParametersProtocol
->Argv
[0])) {
1506 Status
= EFI_ABORTED
;
1511 // run an external file (or script)
1513 if (StrStr(ShellInfoObject
.NewShellParametersProtocol
->Argv
[0], L
":") != NULL
) {
1514 ASSERT (CommandWithPath
== NULL
);
1515 if (ShellIsFile(ShellInfoObject
.NewShellParametersProtocol
->Argv
[0]) == EFI_SUCCESS
) {
1516 CommandWithPath
= StrnCatGrow(&CommandWithPath
, NULL
, ShellInfoObject
.NewShellParametersProtocol
->Argv
[0], 0);
1519 if (CommandWithPath
== NULL
) {
1520 CommandWithPath
= ShellFindFilePathEx(ShellInfoObject
.NewShellParametersProtocol
->Argv
[0], mExecutableExtensions
);
1522 if (CommandWithPath
== NULL
|| ShellIsDirectory(CommandWithPath
) == EFI_SUCCESS
) {
1523 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, ShellInfoObject
.NewShellParametersProtocol
->Argv
[0]);
1526 // Check if it's a NSH (script) file.
1528 TempLocation
= CommandWithPath
+StrLen(CommandWithPath
)-4;
1529 TempLocation2
= mScriptExtension
;
1530 if ((StrLen(CommandWithPath
) > 4) && (StringNoCaseCompare((VOID
*)(&TempLocation
), (VOID
*)(&TempLocation2
)) == 0)) {
1531 Status
= RunScriptFile (CommandWithPath
);
1533 DevPath
= ShellInfoObject
.NewEfiShellProtocol
->GetDevicePathFromFilePath(CommandWithPath
);
1534 ASSERT(DevPath
!= NULL
);
1535 Status
= InternalShellExecuteDevicePath(
1538 PostVariableCmdLine
,
1545 CommandName
= StrnCatGrow(&CommandName
, NULL
, ShellInfoObject
.NewShellParametersProtocol
->Argv
[0], 0);
1547 RestoreArgcArgv(ShellInfoObject
.NewShellParametersProtocol
, &Argv
, &Argc
);
1549 RestoreStdInStdOutStdErr(ShellInfoObject
.NewShellParametersProtocol
, &OriginalStdIn
, &OriginalStdOut
, &OriginalStdErr
, &OriginalSystemTableInfo
);
1551 if (CommandName
!= NULL
) {
1552 if (ShellCommandGetCurrentScriptFile() != NULL
&& !IsScriptOnlyCommand(CommandName
)) {
1554 // if this is NOT a scipt only command return success so the script won't quit.
1555 // prevent killing the script - this is the only place where we know the actual command name (after alias and variable replacement...)
1557 Status
= EFI_SUCCESS
;
1562 SHELL_FREE_NON_NULL(CommandName
);
1563 SHELL_FREE_NON_NULL(CommandWithPath
);
1564 SHELL_FREE_NON_NULL(PostVariableCmdLine
);
1569 STATIC CONST UINT16 InvalidChars
[] = {L
'*', L
'?', L
'<', L
'>', L
'\\', L
'/', L
'\"', 0x0001, 0x0002};
1571 Function determins if the CommandName COULD be a valid command. It does not determine whether
1572 this is a valid command. It only checks for invalid characters.
1574 @param[in] CommandName The name to check
1576 @retval TRUE CommandName could be a command name
1577 @retval FALSE CommandName could not be a valid command name
1582 IN CONST CHAR16
*CommandName
1586 if (CommandName
== NULL
) {
1591 ; Count
< sizeof(InvalidChars
) / sizeof(InvalidChars
[0])
1594 if (ScanMem16(CommandName
, StrSize(CommandName
), InvalidChars
[Count
]) != NULL
) {
1602 Function to process a NSH script file via SHELL_FILE_HANDLE.
1604 @param[in] Handle The handle to the already opened file.
1605 @param[in] Name The name of the script file.
1607 @retval EFI_SUCCESS the script completed sucessfully
1611 RunScriptFileHandle (
1612 IN SHELL_FILE_HANDLE Handle
,
1613 IN CONST CHAR16
*Name
1617 SCRIPT_FILE
*NewScriptFile
;
1619 CHAR16
*CommandLine
;
1620 CHAR16
*CommandLine2
;
1621 CHAR16
*CommandLine3
;
1622 SCRIPT_COMMAND_LIST
*LastCommand
;
1624 BOOLEAN PreScriptEchoState
;
1625 BOOLEAN PreCommandEchoState
;
1626 CONST CHAR16
*CurDir
;
1628 CHAR16 LeString
[50];
1630 ASSERT(!ShellCommandGetScriptExit());
1632 PreScriptEchoState
= ShellCommandGetEchoState();
1634 NewScriptFile
= (SCRIPT_FILE
*)AllocateZeroPool(sizeof(SCRIPT_FILE
));
1635 if (NewScriptFile
== NULL
) {
1636 return (EFI_OUT_OF_RESOURCES
);
1642 ASSERT(NewScriptFile
->ScriptName
== NULL
);
1643 NewScriptFile
->ScriptName
= StrnCatGrow(&NewScriptFile
->ScriptName
, NULL
, Name
, 0);
1644 if (NewScriptFile
->ScriptName
== NULL
) {
1645 DeleteScriptFileStruct(NewScriptFile
);
1646 return (EFI_OUT_OF_RESOURCES
);
1650 // Save the parameters (used to replace %0 to %9 later on)
1652 NewScriptFile
->Argc
= ShellInfoObject
.NewShellParametersProtocol
->Argc
;
1653 if (NewScriptFile
->Argc
!= 0) {
1654 NewScriptFile
->Argv
= (CHAR16
**)AllocateZeroPool(NewScriptFile
->Argc
* sizeof(CHAR16
*));
1655 if (NewScriptFile
->Argv
== NULL
) {
1656 DeleteScriptFileStruct(NewScriptFile
);
1657 return (EFI_OUT_OF_RESOURCES
);
1659 for (LoopVar
= 0 ; LoopVar
< 10 && LoopVar
< NewScriptFile
->Argc
; LoopVar
++) {
1660 ASSERT(NewScriptFile
->Argv
[LoopVar
] == NULL
);
1661 NewScriptFile
->Argv
[LoopVar
] = StrnCatGrow(&NewScriptFile
->Argv
[LoopVar
], NULL
, ShellInfoObject
.NewShellParametersProtocol
->Argv
[LoopVar
], 0);
1662 if (NewScriptFile
->Argv
[LoopVar
] == NULL
) {
1663 DeleteScriptFileStruct(NewScriptFile
);
1664 return (EFI_OUT_OF_RESOURCES
);
1668 NewScriptFile
->Argv
= NULL
;
1671 InitializeListHead(&NewScriptFile
->CommandList
);
1672 InitializeListHead(&NewScriptFile
->SubstList
);
1675 // Now build the list of all script commands.
1678 while(!ShellFileHandleEof(Handle
)) {
1679 CommandLine
= ShellFileHandleReturnLine(Handle
, &Ascii
);
1681 if (CommandLine
== NULL
|| StrLen(CommandLine
) == 0) {
1684 NewScriptFile
->CurrentCommand
= AllocateZeroPool(sizeof(SCRIPT_COMMAND_LIST
));
1685 if (NewScriptFile
->CurrentCommand
== NULL
) {
1686 DeleteScriptFileStruct(NewScriptFile
);
1687 return (EFI_OUT_OF_RESOURCES
);
1690 NewScriptFile
->CurrentCommand
->Cl
= CommandLine
;
1691 NewScriptFile
->CurrentCommand
->Data
= NULL
;
1692 NewScriptFile
->CurrentCommand
->Line
= LineCount
;
1694 InsertTailList(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
1698 // Add this as the topmost script file
1700 ShellCommandSetNewScript (NewScriptFile
);
1703 // Now enumerate through the commands and run each one.
1705 CommandLine
= AllocateZeroPool(PcdGet16(PcdShellPrintBufferSize
));
1706 if (CommandLine
== NULL
) {
1707 DeleteScriptFileStruct(NewScriptFile
);
1708 return (EFI_OUT_OF_RESOURCES
);
1710 CommandLine2
= AllocateZeroPool(PcdGet16(PcdShellPrintBufferSize
));
1711 if (CommandLine2
== NULL
) {
1712 FreePool(CommandLine
);
1713 DeleteScriptFileStruct(NewScriptFile
);
1714 return (EFI_OUT_OF_RESOURCES
);
1717 for ( NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetFirstNode(&NewScriptFile
->CommandList
)
1718 ; !IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)
1719 ; // conditional increment in the body of the loop
1721 ASSERT(CommandLine2
!= NULL
);
1722 StrCpy(CommandLine2
, NewScriptFile
->CurrentCommand
->Cl
);
1725 // NULL out comments
1727 for (CommandLine3
= CommandLine2
; CommandLine3
!= NULL
&& *CommandLine3
!= CHAR_NULL
; CommandLine3
++) {
1728 if (*CommandLine3
== L
'^') {
1729 if (*(CommandLine3
+1) == L
'#' || *(CommandLine3
+1) == L
':') {
1730 CopyMem(CommandLine3
, CommandLine3
+1, StrSize(CommandLine3
) - sizeof(CommandLine3
[0]));
1732 } else if (*CommandLine3
== L
'#') {
1733 *CommandLine3
= CHAR_NULL
;
1737 if (CommandLine2
!= NULL
&& StrLen(CommandLine2
) >= 1) {
1739 // Due to variability in starting the find and replace action we need to have both buffers the same.
1741 StrCpy(CommandLine
, CommandLine2
);
1744 // Remove the %0 to %9 from the command line (if we have some arguments)
1746 if (NewScriptFile
->Argv
!= NULL
) {
1747 switch (NewScriptFile
->Argc
) {
1749 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%9", NewScriptFile
->Argv
[9], FALSE
, TRUE
);
1750 ASSERT_EFI_ERROR(Status
);
1752 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%8", NewScriptFile
->Argv
[8], FALSE
, TRUE
);
1753 ASSERT_EFI_ERROR(Status
);
1755 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%7", NewScriptFile
->Argv
[7], FALSE
, TRUE
);
1756 ASSERT_EFI_ERROR(Status
);
1758 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%6", NewScriptFile
->Argv
[6], FALSE
, TRUE
);
1759 ASSERT_EFI_ERROR(Status
);
1761 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%5", NewScriptFile
->Argv
[5], FALSE
, TRUE
);
1762 ASSERT_EFI_ERROR(Status
);
1764 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%4", NewScriptFile
->Argv
[4], FALSE
, TRUE
);
1765 ASSERT_EFI_ERROR(Status
);
1767 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%3", NewScriptFile
->Argv
[3], FALSE
, TRUE
);
1768 ASSERT_EFI_ERROR(Status
);
1770 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%2", NewScriptFile
->Argv
[2], FALSE
, TRUE
);
1771 ASSERT_EFI_ERROR(Status
);
1773 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%1", NewScriptFile
->Argv
[1], FALSE
, TRUE
);
1774 ASSERT_EFI_ERROR(Status
);
1776 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%0", NewScriptFile
->Argv
[0], FALSE
, TRUE
);
1777 ASSERT_EFI_ERROR(Status
);
1783 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%1", L
"\"\"", FALSE
, FALSE
);
1784 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%2", L
"\"\"", FALSE
, FALSE
);
1785 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%3", L
"\"\"", FALSE
, FALSE
);
1786 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%4", L
"\"\"", FALSE
, FALSE
);
1787 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%5", L
"\"\"", FALSE
, FALSE
);
1788 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%6", L
"\"\"", FALSE
, FALSE
);
1789 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%7", L
"\"\"", FALSE
, FALSE
);
1790 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%8", L
"\"\"", FALSE
, FALSE
);
1791 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%9", L
"\"\"", FALSE
, FALSE
);
1793 StrCpy(CommandLine2
, CommandLine
);
1795 LastCommand
= NewScriptFile
->CurrentCommand
;
1797 for (CommandLine3
= CommandLine2
; CommandLine3
[0] == L
' ' ; CommandLine3
++);
1799 if (CommandLine3
!= NULL
&& CommandLine3
[0] == L
':' ) {
1801 // This line is a goto target / label
1804 if (CommandLine3
!= NULL
&& StrLen(CommandLine3
) > 0) {
1805 if (ShellCommandGetEchoState()) {
1806 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
1807 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
1808 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
1810 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
1812 ShellPrintEx(-1, -1, L
"%s\r\n", CommandLine2
);
1814 if (CommandLine3
[0] == L
'@') {
1816 // We need to save the current echo state
1817 // and disable echo for just this command.
1819 PreCommandEchoState
= ShellCommandGetEchoState();
1820 ShellCommandSetEchoState(FALSE
);
1821 Status
= RunCommand(CommandLine3
+1);
1824 // Now restore the pre-'@' echo state.
1826 ShellCommandSetEchoState(PreCommandEchoState
);
1828 Status
= RunCommand(CommandLine3
);
1832 if (ShellCommandGetScriptExit()) {
1833 UnicodeSPrint(LeString
, sizeof(LeString
)*sizeof(LeString
[0]), L
"0x%Lx", ShellCommandGetExitCode());
1834 DEBUG_CODE(InternalEfiShellSetEnv(L
"DebugLasterror", LeString
, TRUE
););
1835 InternalEfiShellSetEnv(L
"Lasterror", LeString
, TRUE
);
1837 ShellCommandRegisterExit(FALSE
, 0);
1838 Status
= EFI_SUCCESS
;
1841 if (EFI_ERROR(Status
)) {
1844 if (ShellCommandGetExit()) {
1849 // If that commend did not update the CurrentCommand then we need to advance it...
1851 if (LastCommand
== NewScriptFile
->CurrentCommand
) {
1852 NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetNextNode(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
1853 if (!IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)) {
1854 NewScriptFile
->CurrentCommand
->Reset
= TRUE
;
1858 NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetNextNode(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
1859 if (!IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)) {
1860 NewScriptFile
->CurrentCommand
->Reset
= TRUE
;
1866 FreePool(CommandLine
);
1867 FreePool(CommandLine2
);
1868 ShellCommandSetNewScript (NULL
);
1871 // Only if this was the last script reset the state.
1873 if (ShellCommandGetCurrentScriptFile()==NULL
) {
1874 ShellCommandSetEchoState(PreScriptEchoState
);
1876 return (EFI_SUCCESS
);
1880 Function to process a NSH script file.
1882 @param[in] ScriptPath Pointer to the script file name (including file system path).
1884 @retval EFI_SUCCESS the script completed sucessfully
1889 IN CONST CHAR16
*ScriptPath
1893 SHELL_FILE_HANDLE FileHandle
;
1895 if (ShellIsFile(ScriptPath
) != EFI_SUCCESS
) {
1896 return (EFI_INVALID_PARAMETER
);
1899 Status
= ShellOpenFileByName(ScriptPath
, &FileHandle
, EFI_FILE_MODE_READ
, 0);
1900 if (EFI_ERROR(Status
)) {
1904 Status
= RunScriptFileHandle(FileHandle
, ScriptPath
);
1906 ShellCloseFile(&FileHandle
);