2 This is THE shell (application)
4 Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
5 (C) Copyright 2013-2014 Hewlett-Packard Development Company, L.P.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
19 // Initialize the global structure
21 SHELL_INFO ShellInfoObject
= {
56 {{NULL
, NULL
}, NULL
, NULL
},
57 {{NULL
, NULL
}, NULL
, NULL
},
69 STATIC CONST CHAR16 mScriptExtension
[] = L
".NSH";
70 STATIC CONST CHAR16 mExecutableExtensions
[] = L
".NSH;.EFI";
71 STATIC CONST CHAR16 mStartupScript
[] = L
"startup.nsh";
74 Cleans off leading and trailing spaces and tabs.
76 @param[in] String pointer to the string to trim them off.
84 ASSERT(String
!= NULL
);
85 ASSERT(*String
!= NULL
);
87 // Remove any spaces and tabs at the beginning of the (*String).
89 while (((*String
)[0] == L
' ') || ((*String
)[0] == L
'\t')) {
90 CopyMem((*String
), (*String
)+1, StrSize((*String
)) - sizeof((*String
)[0]));
94 // Remove any spaces and tabs at the end of the (*String).
96 while ((StrLen (*String
) > 0) && (((*String
)[StrLen((*String
))-1] == L
' ') || ((*String
)[StrLen((*String
))-1] == L
'\t'))) {
97 (*String
)[StrLen((*String
))-1] = CHAR_NULL
;
100 return (EFI_SUCCESS
);
104 Parse for the next instance of one string within another string. Can optionally make sure that
105 the string was not escaped (^ character) per the shell specification.
107 @param[in] SourceString The string to search within
108 @param[in] FindString The string to look for
109 @param[in] CheckForEscapeCharacter TRUE to skip escaped instances of FinfString, otherwise will return even escaped instances
114 IN CONST CHAR16
*SourceString
,
115 IN CONST CHAR16
*FindString
,
116 IN CONST BOOLEAN CheckForEscapeCharacter
120 if (SourceString
== NULL
) {
123 Temp
= StrStr(SourceString
, FindString
);
126 // If nothing found, or we don't care about escape characters
128 if (Temp
== NULL
|| !CheckForEscapeCharacter
) {
133 // If we found an escaped character, try again on the remainder of the string
135 if ((Temp
> (SourceString
)) && *(Temp
-1) == L
'^') {
136 return FindNextInstance(Temp
+1, FindString
, CheckForEscapeCharacter
);
140 // we found the right character
146 Check whether the string between a pair of % is a valid environment variable name.
148 @param[in] BeginPercent pointer to the first percent.
149 @param[in] EndPercent pointer to the last percent.
151 @retval TRUE is a valid environment variable name.
152 @retval FALSE is NOT a valid environment variable name.
155 IsValidEnvironmentVariableName(
156 IN CONST CHAR16
*BeginPercent
,
157 IN CONST CHAR16
*EndPercent
160 CONST CHAR16
*Walker
;
164 ASSERT (BeginPercent
!= NULL
);
165 ASSERT (EndPercent
!= NULL
);
166 ASSERT (BeginPercent
< EndPercent
);
168 if ((BeginPercent
+ 1) == EndPercent
) {
172 for (Walker
= BeginPercent
+ 1; Walker
< EndPercent
; Walker
++) {
174 (*Walker
>= L
'0' && *Walker
<= L
'9') ||
175 (*Walker
>= L
'A' && *Walker
<= L
'Z') ||
176 (*Walker
>= L
'a' && *Walker
<= L
'z') ||
179 if (Walker
== BeginPercent
+ 1 && (*Walker
>= L
'0' && *Walker
<= L
'9')) {
193 Determine if a command line contains a split operation
195 @param[in] CmdLine The command line to parse.
197 @retval TRUE CmdLine has a valid split.
198 @retval FALSE CmdLine does not have a valid split.
203 IN CONST CHAR16
*CmdLine
206 CONST CHAR16
*TempSpot
;
207 CONST CHAR16
*FirstQuote
;
208 CONST CHAR16
*SecondQuote
;
210 FirstQuote
= FindNextInstance (CmdLine
, L
"\"", TRUE
);
212 TempSpot
= FindFirstCharacter(CmdLine
, L
"|", L
'^');
214 if (FirstQuote
== NULL
||
216 TempSpot
== CHAR_NULL
||
217 FirstQuote
> TempSpot
219 return (BOOLEAN
) ((TempSpot
!= NULL
) && (*TempSpot
!= CHAR_NULL
));
222 while ((TempSpot
!= NULL
) && (*TempSpot
!= CHAR_NULL
)) {
223 if (FirstQuote
== NULL
|| FirstQuote
> TempSpot
) {
226 SecondQuote
= FindNextInstance (FirstQuote
+ 1, L
"\"", TRUE
);
227 if (SecondQuote
== NULL
) {
230 if (SecondQuote
< TempSpot
) {
231 FirstQuote
= FindNextInstance (SecondQuote
+ 1, L
"\"", TRUE
);
234 FirstQuote
= FindNextInstance (SecondQuote
+ 1, L
"\"", TRUE
);
235 TempSpot
= FindFirstCharacter(TempSpot
+ 1, L
"|", L
'^');
240 return (BOOLEAN
) ((TempSpot
!= NULL
) && (*TempSpot
!= CHAR_NULL
));
244 Function to start monitoring for CTRL-S using SimpleTextInputEx. This
245 feature's enabled state was not known when the shell initially launched.
247 @retval EFI_SUCCESS The feature is enabled.
248 @retval EFI_OUT_OF_RESOURCES There is not enough memory available.
252 InternalEfiShellStartCtrlSMonitor(
256 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
257 EFI_KEY_DATA KeyData
;
260 Status
= gBS
->OpenProtocol(
261 gST
->ConsoleInHandle
,
262 &gEfiSimpleTextInputExProtocolGuid
,
266 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
267 if (EFI_ERROR(Status
)) {
272 STRING_TOKEN (STR_SHELL_NO_IN_EX
),
273 ShellInfoObject
.HiiHandle
);
274 return (EFI_SUCCESS
);
277 KeyData
.KeyState
.KeyToggleState
= 0;
278 KeyData
.Key
.ScanCode
= 0;
279 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
280 KeyData
.Key
.UnicodeChar
= L
's';
282 Status
= SimpleEx
->RegisterKeyNotify(
285 NotificationFunction
,
286 &ShellInfoObject
.CtrlSNotifyHandle1
);
288 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
289 if (!EFI_ERROR(Status
)) {
290 Status
= SimpleEx
->RegisterKeyNotify(
293 NotificationFunction
,
294 &ShellInfoObject
.CtrlSNotifyHandle2
);
296 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
297 KeyData
.Key
.UnicodeChar
= 19;
299 if (!EFI_ERROR(Status
)) {
300 Status
= SimpleEx
->RegisterKeyNotify(
303 NotificationFunction
,
304 &ShellInfoObject
.CtrlSNotifyHandle3
);
306 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
307 if (!EFI_ERROR(Status
)) {
308 Status
= SimpleEx
->RegisterKeyNotify(
311 NotificationFunction
,
312 &ShellInfoObject
.CtrlSNotifyHandle4
);
320 The entry point for the application.
322 @param[in] ImageHandle The firmware allocated handle for the EFI image.
323 @param[in] SystemTable A pointer to the EFI System Table.
325 @retval EFI_SUCCESS The entry point is executed successfully.
326 @retval other Some error occurs when executing this entry point.
332 IN EFI_HANDLE ImageHandle
,
333 IN EFI_SYSTEM_TABLE
*SystemTable
339 EFI_HANDLE ConInHandle
;
340 EFI_SIMPLE_TEXT_INPUT_PROTOCOL
*OldConIn
;
342 if (PcdGet8(PcdShellSupportLevel
) > 3) {
343 return (EFI_UNSUPPORTED
);
349 Status
= gST
->ConOut
->ClearScreen(gST
->ConOut
);
350 if (EFI_ERROR(Status
)) {
355 // Populate the global structure from PCDs
357 ShellInfoObject
.ImageDevPath
= NULL
;
358 ShellInfoObject
.FileDevPath
= NULL
;
359 ShellInfoObject
.PageBreakEnabled
= PcdGetBool(PcdShellPageBreakDefault
);
360 ShellInfoObject
.ViewingSettings
.InsertMode
= PcdGetBool(PcdShellInsertModeDefault
);
361 ShellInfoObject
.LogScreenCount
= PcdGet8 (PcdShellScreenLogCount
);
364 // verify we dont allow for spec violation
366 ASSERT(ShellInfoObject
.LogScreenCount
>= 3);
369 // Initialize the LIST ENTRY objects...
371 InitializeListHead(&ShellInfoObject
.BufferToFreeList
.Link
);
372 InitializeListHead(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
);
373 InitializeListHead(&ShellInfoObject
.SplitList
.Link
);
376 // Check PCDs for optional features that are not implemented yet.
378 if ( PcdGetBool(PcdShellSupportOldProtocols
)
379 || !FeaturePcdGet(PcdShellRequireHiiPlatform
)
380 || FeaturePcdGet(PcdShellSupportFrameworkHii
)
382 return (EFI_UNSUPPORTED
);
386 // turn off the watchdog timer
388 gBS
->SetWatchdogTimer (0, 0, 0, NULL
);
391 // install our console logger. This will keep a log of the output for back-browsing
393 Status
= ConsoleLoggerInstall(ShellInfoObject
.LogScreenCount
, &ShellInfoObject
.ConsoleInfo
);
394 if (!EFI_ERROR(Status
)) {
396 // Enable the cursor to be visible
398 gST
->ConOut
->EnableCursor (gST
->ConOut
, TRUE
);
401 // If supporting EFI 1.1 we need to install HII protocol
402 // only do this if PcdShellRequireHiiPlatform == FALSE
404 // remove EFI_UNSUPPORTED check above when complete.
405 ///@todo add support for Framework HII
408 // install our (solitary) HII package
410 ShellInfoObject
.HiiHandle
= HiiAddPackages (&gEfiCallerIdGuid
, gImageHandle
, ShellStrings
, NULL
);
411 if (ShellInfoObject
.HiiHandle
== NULL
) {
412 if (PcdGetBool(PcdShellSupportFrameworkHii
)) {
413 ///@todo Add our package into Framework HII
415 if (ShellInfoObject
.HiiHandle
== NULL
) {
416 Status
= EFI_NOT_STARTED
;
422 // create and install the EfiShellParametersProtocol
424 Status
= CreatePopulateInstallShellParametersProtocol(&ShellInfoObject
.NewShellParametersProtocol
, &ShellInfoObject
.RootShellInstance
);
425 ASSERT_EFI_ERROR(Status
);
426 ASSERT(ShellInfoObject
.NewShellParametersProtocol
!= NULL
);
429 // create and install the EfiShellProtocol
431 Status
= CreatePopulateInstallShellProtocol(&ShellInfoObject
.NewEfiShellProtocol
);
432 ASSERT_EFI_ERROR(Status
);
433 ASSERT(ShellInfoObject
.NewEfiShellProtocol
!= NULL
);
436 // Now initialize the shell library (it requires Shell Parameters protocol)
438 Status
= ShellInitialize();
439 ASSERT_EFI_ERROR(Status
);
441 Status
= CommandInit();
442 ASSERT_EFI_ERROR(Status
);
445 // Check the command line
447 Status
= ProcessCommandLine ();
448 if (EFI_ERROR (Status
)) {
453 // If shell support level is >= 1 create the mappings and paths
455 if (PcdGet8(PcdShellSupportLevel
) >= 1) {
456 Status
= ShellCommandCreateInitialMappingsAndPaths();
460 // save the device path for the loaded image and the device path for the filepath (under loaded image)
461 // These are where to look for the startup.nsh file
463 Status
= GetDevicePathsForImageAndFile(&ShellInfoObject
.ImageDevPath
, &ShellInfoObject
.FileDevPath
);
464 ASSERT_EFI_ERROR(Status
);
467 // Display the version
469 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoVersion
) {
472 gST
->ConOut
->Mode
->CursorRow
,
474 STRING_TOKEN (STR_VER_OUTPUT_MAIN_SHELL
),
475 ShellInfoObject
.HiiHandle
,
476 SupportLevel
[PcdGet8(PcdShellSupportLevel
)],
477 gEfiShellProtocol
->MajorVersion
,
478 gEfiShellProtocol
->MinorVersion
485 STRING_TOKEN (STR_VER_OUTPUT_MAIN_SUPPLIER
),
486 ShellInfoObject
.HiiHandle
,
487 (CHAR16
*) PcdGetPtr (PcdShellSupplier
)
494 STRING_TOKEN (STR_VER_OUTPUT_MAIN_UEFI
),
495 ShellInfoObject
.HiiHandle
,
496 (gST
->Hdr
.Revision
&0xffff0000)>>16,
497 (gST
->Hdr
.Revision
&0x0000ffff),
499 gST
->FirmwareRevision
504 // Display the mapping
506 if (PcdGet8(PcdShellSupportLevel
) >= 2 && !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoMap
) {
507 Status
= RunCommand(L
"map");
508 ASSERT_EFI_ERROR(Status
);
512 // init all the built in alias'
514 Status
= SetBuiltInAlias();
515 ASSERT_EFI_ERROR(Status
);
518 // Initialize environment variables
520 if (ShellCommandGetProfileList() != NULL
) {
521 Status
= InternalEfiShellSetEnv(L
"profiles", ShellCommandGetProfileList(), TRUE
);
522 ASSERT_EFI_ERROR(Status
);
526 TempString
= AllocateZeroPool(Size
);
528 UnicodeSPrint(TempString
, Size
, L
"%d", PcdGet8(PcdShellSupportLevel
));
529 Status
= InternalEfiShellSetEnv(L
"uefishellsupport", TempString
, TRUE
);
530 ASSERT_EFI_ERROR(Status
);
532 UnicodeSPrint(TempString
, Size
, L
"%d.%d", ShellInfoObject
.NewEfiShellProtocol
->MajorVersion
, ShellInfoObject
.NewEfiShellProtocol
->MinorVersion
);
533 Status
= InternalEfiShellSetEnv(L
"uefishellversion", TempString
, TRUE
);
534 ASSERT_EFI_ERROR(Status
);
536 UnicodeSPrint(TempString
, Size
, L
"%d.%d", (gST
->Hdr
.Revision
& 0xFFFF0000) >> 16, gST
->Hdr
.Revision
& 0x0000FFFF);
537 Status
= InternalEfiShellSetEnv(L
"uefiversion", TempString
, TRUE
);
538 ASSERT_EFI_ERROR(Status
);
540 FreePool(TempString
);
542 if (!EFI_ERROR(Status
)) {
543 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
) {
545 // Set up the event for CTRL-C monitoring...
547 Status
= InernalEfiShellStartMonitor();
550 if (!EFI_ERROR(Status
) && !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
552 // Set up the event for CTRL-S monitoring...
554 Status
= InternalEfiShellStartCtrlSMonitor();
557 if (!EFI_ERROR(Status
) && ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
559 // close off the gST->ConIn
561 OldConIn
= gST
->ConIn
;
562 ConInHandle
= gST
->ConsoleInHandle
;
563 gST
->ConIn
= CreateSimpleTextInOnFile((SHELL_FILE_HANDLE
)&FileInterfaceNulFile
, &gST
->ConsoleInHandle
);
569 if (!EFI_ERROR(Status
) && PcdGet8(PcdShellSupportLevel
) >= 1) {
571 // process the startup script or launch the called app.
573 Status
= DoStartupScript(ShellInfoObject
.ImageDevPath
, ShellInfoObject
.FileDevPath
);
576 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Exit
&& !ShellCommandGetExit() && (PcdGet8(PcdShellSupportLevel
) >= 3 || PcdGetBool(PcdShellForceConsole
)) && !EFI_ERROR(Status
) && !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
578 // begin the UI waiting loop
582 // clean out all the memory allocated for CONST <something> * return values
583 // between each shell prompt presentation
585 if (!IsListEmpty(&ShellInfoObject
.BufferToFreeList
.Link
)){
586 FreeBufferList(&ShellInfoObject
.BufferToFreeList
);
590 // Reset page break back to default.
592 ShellInfoObject
.PageBreakEnabled
= PcdGetBool(PcdShellPageBreakDefault
);
593 ASSERT (ShellInfoObject
.ConsoleInfo
!= NULL
);
594 ShellInfoObject
.ConsoleInfo
->Enabled
= TRUE
;
595 ShellInfoObject
.ConsoleInfo
->RowCounter
= 0;
598 // Reset the CTRL-C event (yes we ignore the return values)
600 Status
= gBS
->CheckEvent (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
);
605 Status
= DoShellPrompt();
606 } while (!ShellCommandGetExit());
608 if (OldConIn
!= NULL
&& ConInHandle
!= NULL
) {
609 CloseSimpleTextInOnFile (gST
->ConIn
);
610 gST
->ConIn
= OldConIn
;
611 gST
->ConsoleInHandle
= ConInHandle
;
618 // uninstall protocols / free memory / etc...
620 if (ShellInfoObject
.UserBreakTimer
!= NULL
) {
621 gBS
->CloseEvent(ShellInfoObject
.UserBreakTimer
);
622 DEBUG_CODE(ShellInfoObject
.UserBreakTimer
= NULL
;);
624 if (ShellInfoObject
.ImageDevPath
!= NULL
) {
625 FreePool(ShellInfoObject
.ImageDevPath
);
626 DEBUG_CODE(ShellInfoObject
.ImageDevPath
= NULL
;);
628 if (ShellInfoObject
.FileDevPath
!= NULL
) {
629 FreePool(ShellInfoObject
.FileDevPath
);
630 DEBUG_CODE(ShellInfoObject
.FileDevPath
= NULL
;);
632 if (ShellInfoObject
.NewShellParametersProtocol
!= NULL
) {
633 CleanUpShellParametersProtocol(ShellInfoObject
.NewShellParametersProtocol
);
634 DEBUG_CODE(ShellInfoObject
.NewShellParametersProtocol
= NULL
;);
636 if (ShellInfoObject
.NewEfiShellProtocol
!= NULL
){
637 if (ShellInfoObject
.NewEfiShellProtocol
->IsRootShell()){
638 InternalEfiShellSetEnv(L
"cwd", NULL
, TRUE
);
640 CleanUpShellProtocol(ShellInfoObject
.NewEfiShellProtocol
);
641 DEBUG_CODE(ShellInfoObject
.NewEfiShellProtocol
= NULL
;);
644 if (!IsListEmpty(&ShellInfoObject
.BufferToFreeList
.Link
)){
645 FreeBufferList(&ShellInfoObject
.BufferToFreeList
);
648 if (!IsListEmpty(&ShellInfoObject
.SplitList
.Link
)){
649 ASSERT(FALSE
); ///@todo finish this de-allocation.
652 if (ShellInfoObject
.ShellInitSettings
.FileName
!= NULL
) {
653 FreePool(ShellInfoObject
.ShellInitSettings
.FileName
);
654 DEBUG_CODE(ShellInfoObject
.ShellInitSettings
.FileName
= NULL
;);
657 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
658 FreePool(ShellInfoObject
.ShellInitSettings
.FileOptions
);
659 DEBUG_CODE(ShellInfoObject
.ShellInitSettings
.FileOptions
= NULL
;);
662 if (ShellInfoObject
.HiiHandle
!= NULL
) {
663 HiiRemovePackages(ShellInfoObject
.HiiHandle
);
664 DEBUG_CODE(ShellInfoObject
.HiiHandle
= NULL
;);
667 if (!IsListEmpty(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
)){
668 FreeBufferList(&ShellInfoObject
.ViewingSettings
.CommandHistory
);
671 ASSERT(ShellInfoObject
.ConsoleInfo
!= NULL
);
672 if (ShellInfoObject
.ConsoleInfo
!= NULL
) {
673 ConsoleLoggerUninstall(ShellInfoObject
.ConsoleInfo
);
674 FreePool(ShellInfoObject
.ConsoleInfo
);
675 DEBUG_CODE(ShellInfoObject
.ConsoleInfo
= NULL
;);
678 if (ShellCommandGetExit()) {
679 return ((EFI_STATUS
)ShellCommandGetExitCode());
685 Sets all the alias' that were registered with the ShellCommandLib library.
687 @retval EFI_SUCCESS all init commands were run successfully.
695 CONST ALIAS_LIST
*List
;
699 // Get all the commands we want to run
701 List
= ShellCommandGetInitAliasList();
704 // for each command in the List
706 for ( Node
= (ALIAS_LIST
*)GetFirstNode(&List
->Link
)
707 ; !IsNull (&List
->Link
, &Node
->Link
)
708 ; Node
= (ALIAS_LIST
*)GetNextNode(&List
->Link
, &Node
->Link
)
711 // install the alias'
713 Status
= InternalSetAlias(Node
->CommandString
, Node
->Alias
, TRUE
);
714 ASSERT_EFI_ERROR(Status
);
716 return (EFI_SUCCESS
);
720 Internal function to determine if 2 command names are really the same.
722 @param[in] Command1 The pointer to the first command name.
723 @param[in] Command2 The pointer to the second command name.
725 @retval TRUE The 2 command names are the same.
726 @retval FALSE The 2 command names are not the same.
731 IN CONST CHAR16
*Command1
,
732 IN CONST CHAR16
*Command2
735 if (StringNoCaseCompare(&Command1
, &Command2
) == 0) {
742 Internal function to determine if a command is a script only command.
744 @param[in] CommandName The pointer to the command name.
746 @retval TRUE The command is a script only command.
747 @retval FALSE The command is not a script only command.
752 IN CONST CHAR16
*CommandName
755 if (IsCommand(CommandName
, L
"for")
756 ||IsCommand(CommandName
, L
"endfor")
757 ||IsCommand(CommandName
, L
"if")
758 ||IsCommand(CommandName
, L
"else")
759 ||IsCommand(CommandName
, L
"endif")
760 ||IsCommand(CommandName
, L
"goto")) {
767 This function will populate the 2 device path protocol parameters based on the
768 global gImageHandle. The DevPath will point to the device path for the handle that has
769 loaded image protocol installed on it. The FilePath will point to the device path
770 for the file that was loaded.
772 @param[in, out] DevPath On a successful return the device path to the loaded image.
773 @param[in, out] FilePath On a successful return the device path to the file.
775 @retval EFI_SUCCESS The 2 device paths were successfully returned.
776 @retval other A error from gBS->HandleProtocol.
782 GetDevicePathsForImageAndFile (
783 IN OUT EFI_DEVICE_PATH_PROTOCOL
**DevPath
,
784 IN OUT EFI_DEVICE_PATH_PROTOCOL
**FilePath
788 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
789 EFI_DEVICE_PATH_PROTOCOL
*ImageDevicePath
;
791 ASSERT(DevPath
!= NULL
);
792 ASSERT(FilePath
!= NULL
);
794 Status
= gBS
->OpenProtocol (
796 &gEfiLoadedImageProtocolGuid
,
797 (VOID
**)&LoadedImage
,
800 EFI_OPEN_PROTOCOL_GET_PROTOCOL
802 if (!EFI_ERROR (Status
)) {
803 Status
= gBS
->OpenProtocol (
804 LoadedImage
->DeviceHandle
,
805 &gEfiDevicePathProtocolGuid
,
806 (VOID
**)&ImageDevicePath
,
809 EFI_OPEN_PROTOCOL_GET_PROTOCOL
811 if (!EFI_ERROR (Status
)) {
812 *DevPath
= DuplicateDevicePath (ImageDevicePath
);
813 *FilePath
= DuplicateDevicePath (LoadedImage
->FilePath
);
815 LoadedImage
->DeviceHandle
,
816 &gEfiDevicePathProtocolGuid
,
822 &gEfiLoadedImageProtocolGuid
,
830 Process all Uefi Shell 2.0 command line options.
832 see Uefi Shell 2.0 section 3.2 for full details.
834 the command line must resemble the following:
836 shell.efi [ShellOpt-options] [options] [file-name [file-name-options]]
838 ShellOpt-options Options which control the initialization behavior of the shell.
839 These options are read from the EFI global variable "ShellOpt"
840 and are processed before options or file-name.
842 options Options which control the initialization behavior of the shell.
844 file-name The name of a UEFI shell application or script to be executed
845 after initialization is complete. By default, if file-name is
846 specified, then -nostartup is implied. Scripts are not supported
849 file-name-options The command-line options that are passed to file-name when it
852 This will initialize the ShellInfoObject.ShellInitSettings global variable.
854 @retval EFI_SUCCESS The variable is initialized.
865 CHAR16
*DelayValueStr
;
868 EFI_UNICODE_COLLATION_PROTOCOL
*UnicodeCollation
;
870 // `file-name-options` will contain arguments to `file-name` that we don't
871 // know about. This would cause ShellCommandLineParse to error, so we parse
872 // arguments manually, ignoring those after the first thing that doesn't look
873 // like a shell option (which is assumed to be `file-name`).
875 Status
= gBS
->LocateProtocol (
876 &gEfiUnicodeCollationProtocolGuid
,
878 (VOID
**) &UnicodeCollation
880 if (EFI_ERROR (Status
)) {
884 // Set default options
885 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
= FALSE
;
886 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
= FALSE
;
887 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleOut
= FALSE
;
888 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
= FALSE
;
889 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
= FALSE
;
890 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoMap
= FALSE
;
891 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoVersion
= FALSE
;
892 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Delay
= FALSE
;
893 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Exit
= FALSE
;
894 ShellInfoObject
.ShellInitSettings
.Delay
= 5;
897 // Start LoopVar at 0 to parse only optional arguments at Argv[0]
898 // and parse other parameters from Argv[1]. This is for use case that
899 // UEFI Shell boot option is created, and OptionalData is provided
900 // that starts with shell command-line options.
902 for (LoopVar
= 0 ; LoopVar
< gEfiShellParametersProtocol
->Argc
; LoopVar
++) {
903 CurrentArg
= gEfiShellParametersProtocol
->Argv
[LoopVar
];
904 if (UnicodeCollation
->StriColl (
909 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
= TRUE
;
911 else if (UnicodeCollation
->StriColl (
916 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
= TRUE
;
918 else if (UnicodeCollation
->StriColl (
923 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleOut
= TRUE
;
925 else if (UnicodeCollation
->StriColl (
930 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
= TRUE
;
932 else if (UnicodeCollation
->StriColl (
937 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
= TRUE
;
939 else if (UnicodeCollation
->StriColl (
944 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoMap
= TRUE
;
946 else if (UnicodeCollation
->StriColl (
951 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoVersion
= TRUE
;
953 else if (UnicodeCollation
->StriColl (
958 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Delay
= TRUE
;
959 // Check for optional delay value following "-delay"
960 DelayValueStr
= gEfiShellParametersProtocol
->Argv
[LoopVar
+ 1];
961 if (DelayValueStr
!= NULL
){
962 if (*DelayValueStr
== L
':') {
965 if (!EFI_ERROR(ShellConvertStringToUint64 (
971 ShellInfoObject
.ShellInitSettings
.Delay
= (UINTN
)DelayValue
;
975 } else if (UnicodeCollation
->StriColl (
980 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Exit
= TRUE
;
981 } else if (StrnCmp (L
"-", CurrentArg
, 1) == 0) {
982 // Unrecognized option
983 ShellPrintHiiEx(-1, -1, NULL
,
984 STRING_TOKEN (STR_GEN_PROBLEM
),
985 ShellInfoObject
.HiiHandle
,
988 return EFI_INVALID_PARAMETER
;
991 // First argument should be Shell.efi image name
997 ShellInfoObject
.ShellInitSettings
.FileName
= AllocateCopyPool(StrSize(CurrentArg
), CurrentArg
);
998 if (ShellInfoObject
.ShellInitSettings
.FileName
== NULL
) {
999 return (EFI_OUT_OF_RESOURCES
);
1002 // We found `file-name`.
1004 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
= 1;
1007 // Add `file-name-options`
1008 for (Size
= 0 ; LoopVar
< gEfiShellParametersProtocol
->Argc
; LoopVar
++) {
1009 ASSERT((ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
&& Size
== 0) || (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
));
1010 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileOptions
,
1014 if (ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
) {
1015 SHELL_FREE_NON_NULL(ShellInfoObject
.ShellInitSettings
.FileName
);
1016 return (EFI_OUT_OF_RESOURCES
);
1018 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileOptions
,
1020 gEfiShellParametersProtocol
->Argv
[LoopVar
],
1022 if (ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
) {
1023 SHELL_FREE_NON_NULL(ShellInfoObject
.ShellInitSettings
.FileName
);
1024 return (EFI_OUT_OF_RESOURCES
);
1030 // "-nointerrupt" overrides "-delay"
1031 if (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
) {
1032 ShellInfoObject
.ShellInitSettings
.Delay
= 0;
1039 Handles all interaction with the default startup script.
1041 this will check that the correct command line parameters were passed, handle the delay, and then start running the script.
1043 @param ImagePath the path to the image for shell. first place to look for the startup script
1044 @param FilePath the path to the file for shell. second place to look for the startup script.
1046 @retval EFI_SUCCESS the variable is initialized.
1051 IN EFI_DEVICE_PATH_PROTOCOL
*ImagePath
,
1052 IN EFI_DEVICE_PATH_PROTOCOL
*FilePath
1056 EFI_STATUS CalleeStatus
;
1059 SHELL_FILE_HANDLE FileHandle
;
1060 EFI_DEVICE_PATH_PROTOCOL
*NewPath
;
1061 EFI_DEVICE_PATH_PROTOCOL
*NamePath
;
1062 CHAR16
*FileStringPath
;
1065 CONST CHAR16
*MapName
;
1067 Key
.UnicodeChar
= CHAR_NULL
;
1071 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
&& ShellInfoObject
.ShellInitSettings
.FileName
!= NULL
) {
1073 // launch something else instead
1075 NewSize
= StrSize(ShellInfoObject
.ShellInitSettings
.FileName
);
1076 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
1077 NewSize
+= StrSize(ShellInfoObject
.ShellInitSettings
.FileOptions
) + sizeof(CHAR16
);
1079 FileStringPath
= AllocateZeroPool(NewSize
);
1080 if (FileStringPath
== NULL
) {
1081 return (EFI_OUT_OF_RESOURCES
);
1083 StrCpyS(FileStringPath
, NewSize
/sizeof(CHAR16
), ShellInfoObject
.ShellInitSettings
.FileName
);
1084 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
1085 StrnCatS(FileStringPath
, NewSize
/sizeof(CHAR16
), L
" ", NewSize
/sizeof(CHAR16
) - StrLen(FileStringPath
) -1);
1086 StrnCatS(FileStringPath
, NewSize
/sizeof(CHAR16
), ShellInfoObject
.ShellInitSettings
.FileOptions
, NewSize
/sizeof(CHAR16
) - StrLen(FileStringPath
) -1);
1088 Status
= RunShellCommand(FileStringPath
, &CalleeStatus
);
1089 if (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Exit
== TRUE
) {
1090 ShellCommandRegisterExit(gEfiShellProtocol
->BatchIsActive(), (UINT64
)CalleeStatus
);
1092 FreePool(FileStringPath
);
1098 // for shell level 0 we do no scripts
1099 // Without the Startup bit overriding we allow for nostartup to prevent scripts
1101 if ( (PcdGet8(PcdShellSupportLevel
) < 1)
1102 || (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
&& !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
)
1104 return (EFI_SUCCESS
);
1107 gST
->ConOut
->EnableCursor(gST
->ConOut
, FALSE
);
1109 // print out our warning and see if they press a key
1111 for ( Status
= EFI_UNSUPPORTED
, Delay
= ShellInfoObject
.ShellInitSettings
.Delay
1112 ; Delay
!= 0 && EFI_ERROR(Status
)
1115 ShellPrintHiiEx(0, gST
->ConOut
->Mode
->CursorRow
, NULL
, STRING_TOKEN (STR_SHELL_STARTUP_QUESTION
), ShellInfoObject
.HiiHandle
, Delay
);
1116 gBS
->Stall (1000000);
1117 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
1118 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
1121 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CRLF
), ShellInfoObject
.HiiHandle
);
1122 gST
->ConOut
->EnableCursor(gST
->ConOut
, TRUE
);
1127 if (Status
== EFI_SUCCESS
&& Key
.UnicodeChar
== 0 && Key
.ScanCode
== SCAN_ESC
) {
1128 return (EFI_SUCCESS
);
1132 // Try the first location (must be file system)
1134 MapName
= ShellInfoObject
.NewEfiShellProtocol
->GetMapFromDevicePath(&ImagePath
);
1135 if (MapName
!= NULL
) {
1136 FileStringPath
= NULL
;
1138 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, MapName
, 0);
1139 if (FileStringPath
== NULL
) {
1140 Status
= EFI_OUT_OF_RESOURCES
;
1142 TempSpot
= StrStr(FileStringPath
, L
";");
1143 if (TempSpot
!= NULL
) {
1144 *TempSpot
= CHAR_NULL
;
1146 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, ((FILEPATH_DEVICE_PATH
*)FilePath
)->PathName
, 0);
1147 PathRemoveLastItem(FileStringPath
);
1148 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, mStartupScript
, 0);
1149 Status
= ShellInfoObject
.NewEfiShellProtocol
->OpenFileByName(FileStringPath
, &FileHandle
, EFI_FILE_MODE_READ
);
1150 FreePool(FileStringPath
);
1153 if (EFI_ERROR(Status
)) {
1154 NamePath
= FileDevicePath (NULL
, mStartupScript
);
1155 NewPath
= AppendDevicePathNode (ImagePath
, NamePath
);
1161 Status
= InternalOpenFileDevicePath(NewPath
, &FileHandle
, EFI_FILE_MODE_READ
, 0);
1165 // If we got a file, run it
1167 if (!EFI_ERROR(Status
) && FileHandle
!= NULL
) {
1168 Status
= RunScriptFile (mStartupScript
, FileHandle
, L
"", ShellInfoObject
.NewShellParametersProtocol
);
1169 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(FileHandle
);
1171 FileStringPath
= ShellFindFilePath(mStartupScript
);
1172 if (FileStringPath
== NULL
) {
1174 // we return success since we don't need to have a startup script
1176 Status
= EFI_SUCCESS
;
1177 ASSERT(FileHandle
== NULL
);
1179 Status
= RunScriptFile(FileStringPath
, NULL
, L
"", ShellInfoObject
.NewShellParametersProtocol
);
1180 FreePool(FileStringPath
);
1189 Function to perform the shell prompt looping. It will do a single prompt,
1190 dispatch the result, and then return. It is expected that the caller will
1191 call this function in a loop many times.
1194 @retval RETURN_ABORTED
1205 CONST CHAR16
*CurDir
;
1208 LIST_ENTRY OldBufferList
;
1213 // Get screen setting to decide size of the command line buffer
1215 gST
->ConOut
->QueryMode (gST
->ConOut
, gST
->ConOut
->Mode
->Mode
, &Column
, &Row
);
1216 BufferSize
= Column
* Row
* sizeof (CHAR16
);
1217 CmdLine
= AllocateZeroPool (BufferSize
);
1218 if (CmdLine
== NULL
) {
1219 return EFI_OUT_OF_RESOURCES
;
1222 SaveBufferList(&OldBufferList
);
1223 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
1228 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, gST
->ConOut
->Mode
->CursorRow
);
1230 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
1231 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
1233 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
1237 // Read a line from the console
1239 Status
= ShellInfoObject
.NewEfiShellProtocol
->ReadFile(ShellInfoObject
.NewShellParametersProtocol
->StdIn
, &BufferSize
, CmdLine
);
1242 // Null terminate the string and parse it
1244 if (!EFI_ERROR (Status
)) {
1245 CmdLine
[BufferSize
/ sizeof (CHAR16
)] = CHAR_NULL
;
1246 Status
= RunCommand(CmdLine
);
1250 // Done with this command
1252 RestoreBufferList(&OldBufferList
);
1258 Add a buffer to the Buffer To Free List for safely returning buffers to other
1259 places without risking letting them modify internal shell information.
1261 @param Buffer Something to pass to FreePool when the shell is exiting.
1265 AddBufferToFreeList(
1269 BUFFER_LIST
*BufferListEntry
;
1271 if (Buffer
== NULL
) {
1275 BufferListEntry
= AllocateZeroPool(sizeof(BUFFER_LIST
));
1276 ASSERT(BufferListEntry
!= NULL
);
1277 BufferListEntry
->Buffer
= Buffer
;
1278 InsertTailList(&ShellInfoObject
.BufferToFreeList
.Link
, &BufferListEntry
->Link
);
1284 Create a new buffer list and stores the old one to OldBufferList
1286 @param OldBufferList The temporary list head used to store the nodes in BufferToFreeList.
1290 OUT LIST_ENTRY
*OldBufferList
1293 CopyMem (OldBufferList
, &ShellInfoObject
.BufferToFreeList
.Link
, sizeof (LIST_ENTRY
));
1294 InitializeListHead (&ShellInfoObject
.BufferToFreeList
.Link
);
1298 Restore previous nodes into BufferToFreeList .
1300 @param OldBufferList The temporary list head used to store the nodes in BufferToFreeList.
1304 IN OUT LIST_ENTRY
*OldBufferList
1307 FreeBufferList (&ShellInfoObject
.BufferToFreeList
);
1308 CopyMem (&ShellInfoObject
.BufferToFreeList
.Link
, OldBufferList
, sizeof (LIST_ENTRY
));
1313 Add a buffer to the Line History List
1315 @param Buffer The line buffer to add.
1319 AddLineToCommandHistory(
1320 IN CONST CHAR16
*Buffer
1324 BUFFER_LIST
*Walker
;
1325 UINT16 MaxHistoryCmdCount
;
1329 MaxHistoryCmdCount
= PcdGet16(PcdShellMaxHistoryCommandCount
);
1331 if (MaxHistoryCmdCount
== 0) {
1336 Node
= AllocateZeroPool(sizeof(BUFFER_LIST
));
1337 ASSERT(Node
!= NULL
);
1338 Node
->Buffer
= AllocateCopyPool(StrSize(Buffer
), Buffer
);
1339 ASSERT(Node
->Buffer
!= NULL
);
1341 for ( Walker
= (BUFFER_LIST
*)GetFirstNode(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
)
1342 ; !IsNull(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
, &Walker
->Link
)
1343 ; Walker
= (BUFFER_LIST
*)GetNextNode(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
, &Walker
->Link
)
1347 if (Count
< MaxHistoryCmdCount
){
1348 InsertTailList(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
, &Node
->Link
);
1350 Walker
= (BUFFER_LIST
*)GetFirstNode(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
);
1351 RemoveEntryList(&Walker
->Link
);
1352 if (Walker
->Buffer
!= NULL
) {
1353 FreePool(Walker
->Buffer
);
1356 InsertTailList(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
, &Node
->Link
);
1361 Checks if a string is an alias for another command. If yes, then it replaces the alias name
1362 with the correct command name.
1364 @param[in, out] CommandString Upon entry the potential alias. Upon return the
1365 command name if it was an alias. If it was not
1366 an alias it will be unchanged. This function may
1367 change the buffer to fit the command name.
1369 @retval EFI_SUCCESS The name was changed.
1370 @retval EFI_SUCCESS The name was not an alias.
1371 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
1376 IN OUT CHAR16
**CommandString
1379 CONST CHAR16
*NewString
;
1381 NewString
= ShellInfoObject
.NewEfiShellProtocol
->GetAlias(*CommandString
, NULL
);
1382 if (NewString
== NULL
) {
1383 return (EFI_SUCCESS
);
1385 FreePool(*CommandString
);
1386 *CommandString
= AllocateCopyPool(StrSize(NewString
), NewString
);
1387 if (*CommandString
== NULL
) {
1388 return (EFI_OUT_OF_RESOURCES
);
1390 return (EFI_SUCCESS
);
1394 This function will eliminate unreplaced (and therefore non-found) environment variables.
1396 @param[in,out] CmdLine The command line to update.
1400 StripUnreplacedEnvironmentVariables(
1401 IN OUT CHAR16
*CmdLine
1404 CHAR16
*FirstPercent
;
1406 CHAR16
*SecondPercent
;
1407 CHAR16
*SecondQuote
;
1408 CHAR16
*CurrentLocator
;
1410 for (CurrentLocator
= CmdLine
; CurrentLocator
!= NULL
; ) {
1411 FirstQuote
= FindNextInstance(CurrentLocator
, L
"\"", TRUE
);
1412 FirstPercent
= FindNextInstance(CurrentLocator
, L
"%", TRUE
);
1413 SecondPercent
= FirstPercent
!=NULL
?FindNextInstance(FirstPercent
+1, L
"%", TRUE
):NULL
;
1414 if (FirstPercent
== NULL
|| SecondPercent
== NULL
) {
1416 // If we ever don't have 2 % we are done.
1421 if (FirstQuote
!= NULL
&& FirstQuote
< FirstPercent
) {
1422 SecondQuote
= FindNextInstance(FirstQuote
+1, L
"\"", TRUE
);
1424 // Quote is first found
1427 if (SecondQuote
< FirstPercent
) {
1429 // restart after the pair of "
1431 CurrentLocator
= SecondQuote
+ 1;
1432 } else /* FirstPercent < SecondQuote */{
1434 // Restart on the first percent
1436 CurrentLocator
= FirstPercent
;
1441 if (FirstQuote
== NULL
|| SecondPercent
< FirstQuote
) {
1442 if (IsValidEnvironmentVariableName(FirstPercent
, SecondPercent
)) {
1444 // We need to remove from FirstPercent to SecondPercent
1446 CopyMem(FirstPercent
, SecondPercent
+ 1, StrSize(SecondPercent
+ 1));
1448 // don't need to update the locator. both % characters are gone.
1451 CurrentLocator
= SecondPercent
+ 1;
1455 CurrentLocator
= FirstQuote
;
1457 return (EFI_SUCCESS
);
1461 Function allocates a new command line and replaces all instances of environment
1462 variable names that are correctly preset to their values.
1464 If the return value is not NULL the memory must be caller freed.
1466 @param[in] OriginalCommandLine The original command line
1468 @retval NULL An error occurred.
1469 @return The new command line with no environment variables present.
1473 ShellConvertVariables (
1474 IN CONST CHAR16
*OriginalCommandLine
1477 CONST CHAR16
*MasterEnvList
;
1479 CHAR16
*NewCommandLine1
;
1480 CHAR16
*NewCommandLine2
;
1484 SCRIPT_FILE
*CurrentScriptFile
;
1485 ALIAS_LIST
*AliasListNode
;
1487 ASSERT(OriginalCommandLine
!= NULL
);
1490 NewSize
= StrSize(OriginalCommandLine
);
1491 CurrentScriptFile
= ShellCommandGetCurrentScriptFile();
1494 ///@todo update this to handle the %0 - %9 for scripting only (borrow from line 1256 area) ? ? ?
1497 // calculate the size required for the post-conversion string...
1499 if (CurrentScriptFile
!= NULL
) {
1500 for (AliasListNode
= (ALIAS_LIST
*)GetFirstNode(&CurrentScriptFile
->SubstList
)
1501 ; !IsNull(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1502 ; AliasListNode
= (ALIAS_LIST
*)GetNextNode(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1504 for (Temp
= StrStr(OriginalCommandLine
, AliasListNode
->Alias
)
1506 ; Temp
= StrStr(Temp
+1, AliasListNode
->Alias
)
1509 // we need a preceding and if there is space no ^ preceding (if no space ignore)
1511 if ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2)) {
1512 NewSize
+= StrSize(AliasListNode
->CommandString
);
1518 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1519 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
//&& *(MasterEnvList+1) != CHAR_NULL
1520 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1522 if (StrSize(MasterEnvList
) > ItemSize
) {
1523 ItemSize
= StrSize(MasterEnvList
);
1525 for (Temp
= StrStr(OriginalCommandLine
, MasterEnvList
)
1527 ; Temp
= StrStr(Temp
+1, MasterEnvList
)
1530 // we need a preceding and following % and if there is space no ^ preceding (if no space ignore)
1532 if (*(Temp
-1) == L
'%' && *(Temp
+StrLen(MasterEnvList
)) == L
'%' &&
1533 ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2))) {
1534 NewSize
+=StrSize(EfiShellGetEnv(MasterEnvList
));
1540 // now do the replacements...
1542 NewCommandLine1
= AllocateCopyPool(NewSize
, OriginalCommandLine
);
1543 NewCommandLine2
= AllocateZeroPool(NewSize
);
1544 ItemTemp
= AllocateZeroPool(ItemSize
+(2*sizeof(CHAR16
)));
1545 if (NewCommandLine1
== NULL
|| NewCommandLine2
== NULL
|| ItemTemp
== NULL
) {
1546 SHELL_FREE_NON_NULL(NewCommandLine1
);
1547 SHELL_FREE_NON_NULL(NewCommandLine2
);
1548 SHELL_FREE_NON_NULL(ItemTemp
);
1551 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1552 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
1553 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1556 ((ItemSize
+(2*sizeof(CHAR16
)))/sizeof(CHAR16
)),
1560 ((ItemSize
+(2*sizeof(CHAR16
)))/sizeof(CHAR16
)),
1564 ((ItemSize
+(2*sizeof(CHAR16
)))/sizeof(CHAR16
)),
1567 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, ItemTemp
, EfiShellGetEnv(MasterEnvList
), TRUE
, FALSE
);
1568 StrCpyS(NewCommandLine1
, NewSize
/sizeof(CHAR16
), NewCommandLine2
);
1570 if (CurrentScriptFile
!= NULL
) {
1571 for (AliasListNode
= (ALIAS_LIST
*)GetFirstNode(&CurrentScriptFile
->SubstList
)
1572 ; !IsNull(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1573 ; AliasListNode
= (ALIAS_LIST
*)GetNextNode(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1575 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, AliasListNode
->Alias
, AliasListNode
->CommandString
, TRUE
, FALSE
);
1576 StrCpyS(NewCommandLine1
, NewSize
/sizeof(CHAR16
), NewCommandLine2
);
1581 // Remove non-existent environment variables
1583 StripUnreplacedEnvironmentVariables(NewCommandLine1
);
1586 // Now cleanup any straggler intentionally ignored "%" characters
1588 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, L
"^%", L
"%", TRUE
, FALSE
);
1589 StrCpyS(NewCommandLine1
, NewSize
/sizeof(CHAR16
), NewCommandLine2
);
1591 FreePool(NewCommandLine2
);
1594 return (NewCommandLine1
);
1598 Internal function to run a command line with pipe usage.
1600 @param[in] CmdLine The pointer to the command line.
1601 @param[in] StdIn The pointer to the Standard input.
1602 @param[in] StdOut The pointer to the Standard output.
1604 @retval EFI_SUCCESS The split command is executed successfully.
1605 @retval other Some error occurs when executing the split command.
1610 IN CONST CHAR16
*CmdLine
,
1611 IN SHELL_FILE_HANDLE
*StdIn
,
1612 IN SHELL_FILE_HANDLE
*StdOut
1616 CHAR16
*NextCommandLine
;
1617 CHAR16
*OurCommandLine
;
1621 SHELL_FILE_HANDLE
*TempFileHandle
;
1624 ASSERT(StdOut
== NULL
);
1626 ASSERT(StrStr(CmdLine
, L
"|") != NULL
);
1628 Status
= EFI_SUCCESS
;
1629 NextCommandLine
= NULL
;
1630 OurCommandLine
= NULL
;
1634 NextCommandLine
= StrnCatGrow(&NextCommandLine
, &Size1
, StrStr(CmdLine
, L
"|")+1, 0);
1635 OurCommandLine
= StrnCatGrow(&OurCommandLine
, &Size2
, CmdLine
, StrStr(CmdLine
, L
"|") - CmdLine
);
1637 if (NextCommandLine
== NULL
|| OurCommandLine
== NULL
) {
1638 SHELL_FREE_NON_NULL(OurCommandLine
);
1639 SHELL_FREE_NON_NULL(NextCommandLine
);
1640 return (EFI_OUT_OF_RESOURCES
);
1641 } else if (StrStr(OurCommandLine
, L
"|") != NULL
|| Size1
== 0 || Size2
== 0) {
1642 SHELL_FREE_NON_NULL(OurCommandLine
);
1643 SHELL_FREE_NON_NULL(NextCommandLine
);
1644 return (EFI_INVALID_PARAMETER
);
1645 } else if (NextCommandLine
[0] == L
'a' &&
1646 (NextCommandLine
[1] == L
' ' || NextCommandLine
[1] == CHAR_NULL
)
1648 CopyMem(NextCommandLine
, NextCommandLine
+1, StrSize(NextCommandLine
) - sizeof(NextCommandLine
[0]));
1649 while (NextCommandLine
[0] == L
' ') {
1650 CopyMem(NextCommandLine
, NextCommandLine
+1, StrSize(NextCommandLine
) - sizeof(NextCommandLine
[0]));
1652 if (NextCommandLine
[0] == CHAR_NULL
) {
1653 SHELL_FREE_NON_NULL(OurCommandLine
);
1654 SHELL_FREE_NON_NULL(NextCommandLine
);
1655 return (EFI_INVALID_PARAMETER
);
1664 // make a SPLIT_LIST item and add to list
1666 Split
= AllocateZeroPool(sizeof(SPLIT_LIST
));
1667 ASSERT(Split
!= NULL
);
1668 Split
->SplitStdIn
= StdIn
;
1669 Split
->SplitStdOut
= ConvertEfiFileProtocolToShellHandle(CreateFileInterfaceMem(Unicode
), NULL
);
1670 ASSERT(Split
->SplitStdOut
!= NULL
);
1671 InsertHeadList(&ShellInfoObject
.SplitList
.Link
, &Split
->Link
);
1673 Status
= RunCommand(OurCommandLine
);
1676 // move the output from the first to the in to the second.
1678 TempFileHandle
= Split
->SplitStdOut
;
1679 if (Split
->SplitStdIn
== StdIn
) {
1680 Split
->SplitStdOut
= NULL
;
1682 Split
->SplitStdOut
= Split
->SplitStdIn
;
1684 Split
->SplitStdIn
= TempFileHandle
;
1685 ShellInfoObject
.NewEfiShellProtocol
->SetFilePosition(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdIn
), 0);
1687 if (!EFI_ERROR(Status
)) {
1688 Status
= RunCommand(NextCommandLine
);
1692 // remove the top level from the ScriptList
1694 ASSERT((SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
) == Split
);
1695 RemoveEntryList(&Split
->Link
);
1698 // Note that the original StdIn is now the StdOut...
1700 if (Split
->SplitStdOut
!= NULL
&& Split
->SplitStdOut
!= StdIn
) {
1701 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdOut
));
1703 if (Split
->SplitStdIn
!= NULL
) {
1704 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdIn
));
1708 FreePool(NextCommandLine
);
1709 FreePool(OurCommandLine
);
1715 Take the original command line, substitute any variables, free
1716 the original string, return the modified copy.
1718 @param[in] CmdLine pointer to the command line to update.
1720 @retval EFI_SUCCESS the function was successful.
1721 @retval EFI_OUT_OF_RESOURCES a memory allocation failed.
1725 ShellSubstituteVariables(
1730 NewCmdLine
= ShellConvertVariables(*CmdLine
);
1731 SHELL_FREE_NON_NULL(*CmdLine
);
1732 if (NewCmdLine
== NULL
) {
1733 return (EFI_OUT_OF_RESOURCES
);
1735 *CmdLine
= NewCmdLine
;
1736 return (EFI_SUCCESS
);
1740 Take the original command line, substitute any alias in the first group of space delimited characters, free
1741 the original string, return the modified copy.
1743 @param[in] CmdLine pointer to the command line to update.
1745 @retval EFI_SUCCESS the function was successful.
1746 @retval EFI_OUT_OF_RESOURCES a memory allocation failed.
1750 ShellSubstituteAliases(
1755 CHAR16
*CommandName
;
1757 UINTN PostAliasSize
;
1758 ASSERT(CmdLine
!= NULL
);
1759 ASSERT(*CmdLine
!= NULL
);
1763 if (StrStr((*CmdLine
), L
" ") == NULL
){
1764 StrnCatGrow(&CommandName
, NULL
, (*CmdLine
), 0);
1766 StrnCatGrow(&CommandName
, NULL
, (*CmdLine
), StrStr((*CmdLine
), L
" ") - (*CmdLine
));
1770 // This cannot happen 'inline' since the CmdLine can need extra space.
1773 if (!ShellCommandIsCommandOnList(CommandName
)) {
1775 // Convert via alias
1777 Status
= ShellConvertAlias(&CommandName
);
1778 if (EFI_ERROR(Status
)){
1782 NewCmdLine
= StrnCatGrow(&NewCmdLine
, &PostAliasSize
, CommandName
, 0);
1783 if (NewCmdLine
== NULL
) {
1784 SHELL_FREE_NON_NULL(CommandName
);
1785 SHELL_FREE_NON_NULL(*CmdLine
);
1786 return (EFI_OUT_OF_RESOURCES
);
1788 NewCmdLine
= StrnCatGrow(&NewCmdLine
, &PostAliasSize
, StrStr((*CmdLine
), L
" "), 0);
1789 if (NewCmdLine
== NULL
) {
1790 SHELL_FREE_NON_NULL(CommandName
);
1791 SHELL_FREE_NON_NULL(*CmdLine
);
1792 return (EFI_OUT_OF_RESOURCES
);
1795 NewCmdLine
= StrnCatGrow(&NewCmdLine
, NULL
, (*CmdLine
), 0);
1798 SHELL_FREE_NON_NULL(*CmdLine
);
1799 SHELL_FREE_NON_NULL(CommandName
);
1802 // re-assign the passed in double pointer to point to our newly allocated buffer
1804 *CmdLine
= NewCmdLine
;
1806 return (EFI_SUCCESS
);
1810 Takes the Argv[0] part of the command line and determine the meaning of it.
1812 @param[in] CmdName pointer to the command line to update.
1814 @retval Internal_Command The name is an internal command.
1815 @retval File_Sys_Change the name is a file system change.
1816 @retval Script_File_Name the name is a NSH script file.
1817 @retval Unknown_Invalid the name is unknown.
1818 @retval Efi_Application the name is an application (.EFI).
1820 SHELL_OPERATION_TYPES
1823 IN CONST CHAR16
*CmdName
1826 CHAR16
* FileWithPath
;
1827 CONST CHAR16
* TempLocation
;
1828 CONST CHAR16
* TempLocation2
;
1830 FileWithPath
= NULL
;
1832 // test for an internal command.
1834 if (ShellCommandIsCommandOnList(CmdName
)) {
1835 return (Internal_Command
);
1839 // Test for file system change request. anything ending with first : and cant have spaces.
1841 if (CmdName
[(StrLen(CmdName
)-1)] == L
':') {
1842 if ( StrStr(CmdName
, L
" ") != NULL
1843 || StrLen(StrStr(CmdName
, L
":")) > 1
1845 return (Unknown_Invalid
);
1847 return (File_Sys_Change
);
1853 if ((FileWithPath
= ShellFindFilePathEx(CmdName
, mExecutableExtensions
)) != NULL
) {
1855 // See if that file has a script file extension
1857 if (StrLen(FileWithPath
) > 4) {
1858 TempLocation
= FileWithPath
+StrLen(FileWithPath
)-4;
1859 TempLocation2
= mScriptExtension
;
1860 if (StringNoCaseCompare((VOID
*)(&TempLocation
), (VOID
*)(&TempLocation2
)) == 0) {
1861 SHELL_FREE_NON_NULL(FileWithPath
);
1862 return (Script_File_Name
);
1867 // Was a file, but not a script. we treat this as an application.
1869 SHELL_FREE_NON_NULL(FileWithPath
);
1870 return (Efi_Application
);
1873 SHELL_FREE_NON_NULL(FileWithPath
);
1875 // No clue what this is... return invalid flag...
1877 return (Unknown_Invalid
);
1881 Determine if the first item in a command line is valid.
1883 @param[in] CmdLine The command line to parse.
1885 @retval EFI_SUCCESS The item is valid.
1886 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
1887 @retval EFI_NOT_FOUND The operation type is unknown or invalid.
1892 IN CONST CHAR16
*CmdLine
1896 CHAR16
*FirstParameter
;
1902 Temp
= StrnCatGrow(&Temp
, NULL
, CmdLine
, 0);
1904 return (EFI_OUT_OF_RESOURCES
);
1907 FirstParameter
= StrStr(Temp
, L
"|");
1908 if (FirstParameter
!= NULL
) {
1909 *FirstParameter
= CHAR_NULL
;
1912 FirstParameter
= NULL
;
1915 // Process the command line
1917 Status
= ProcessCommandLineToFinal(&Temp
);
1919 if (!EFI_ERROR(Status
)) {
1920 FirstParameter
= AllocateZeroPool(StrSize(CmdLine
));
1921 if (FirstParameter
== NULL
) {
1922 SHELL_FREE_NON_NULL(Temp
);
1923 return (EFI_OUT_OF_RESOURCES
);
1925 TempWalker
= (CHAR16
*)Temp
;
1926 if (!EFI_ERROR(GetNextParameter(&TempWalker
, &FirstParameter
, StrSize(CmdLine
), TRUE
))) {
1927 if (GetOperationType(FirstParameter
) == Unknown_Invalid
) {
1928 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
1929 SetLastError(SHELL_NOT_FOUND
);
1930 Status
= EFI_NOT_FOUND
;
1935 SHELL_FREE_NON_NULL(Temp
);
1936 SHELL_FREE_NON_NULL(FirstParameter
);
1941 Determine if a command line contains with a split contains only valid commands.
1943 @param[in] CmdLine The command line to parse.
1945 @retval EFI_SUCCESS CmdLine has only valid commands, application, or has no split.
1946 @retval EFI_ABORTED CmdLine has at least one invalid command or application.
1951 IN CONST CHAR16
*CmdLine
1954 CONST CHAR16
*TempSpot
;
1958 // If this was the only item, then get out
1960 if (!ContainsSplit(CmdLine
)) {
1961 return (EFI_SUCCESS
);
1965 // Verify up to the pipe or end character
1967 Status
= IsValidSplit(CmdLine
);
1968 if (EFI_ERROR(Status
)) {
1973 // recurse to verify the next item
1975 TempSpot
= FindFirstCharacter(CmdLine
, L
"|", L
'^') + 1;
1976 if (*TempSpot
== L
'a' &&
1977 (*(TempSpot
+ 1) == L
' ' || *(TempSpot
+ 1) == CHAR_NULL
)
1979 // If it's an ASCII pipe '|a'
1983 return (VerifySplit(TempSpot
));
1987 Process a split based operation.
1989 @param[in] CmdLine pointer to the command line to process
1991 @retval EFI_SUCCESS The operation was successful
1992 @return an error occurred.
1996 ProcessNewSplitCommandLine(
1997 IN CONST CHAR16
*CmdLine
2003 Status
= VerifySplit(CmdLine
);
2004 if (EFI_ERROR(Status
)) {
2011 // are we in an existing split???
2013 if (!IsListEmpty(&ShellInfoObject
.SplitList
.Link
)) {
2014 Split
= (SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
);
2017 if (Split
== NULL
) {
2018 Status
= RunSplitCommand(CmdLine
, NULL
, NULL
);
2020 Status
= RunSplitCommand(CmdLine
, Split
->SplitStdIn
, Split
->SplitStdOut
);
2022 if (EFI_ERROR(Status
)) {
2023 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_SPLIT
), ShellInfoObject
.HiiHandle
, CmdLine
);
2029 Handle a request to change the current file system.
2031 @param[in] CmdLine The passed in command line.
2033 @retval EFI_SUCCESS The operation was successful.
2038 IN CONST CHAR16
*CmdLine
2042 Status
= EFI_SUCCESS
;
2045 // make sure we are the right operation
2047 ASSERT(CmdLine
[(StrLen(CmdLine
)-1)] == L
':' && StrStr(CmdLine
, L
" ") == NULL
);
2050 // Call the protocol API to do the work
2052 Status
= ShellInfoObject
.NewEfiShellProtocol
->SetCurDir(NULL
, CmdLine
);
2055 // Report any errors
2057 if (EFI_ERROR(Status
)) {
2058 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_MAPPING
), ShellInfoObject
.HiiHandle
, CmdLine
);
2065 Reprocess the command line to direct all -? to the help command.
2067 if found, will add "help" as argv[0], and move the rest later.
2069 @param[in,out] CmdLine pointer to the command line to update
2074 IN OUT CHAR16
**CmdLine
2077 CHAR16
*CurrentParameter
;
2079 CHAR16
*NewCommandLine
;
2081 UINTN NewCmdLineSize
;
2083 Status
= EFI_SUCCESS
;
2085 CurrentParameter
= AllocateZeroPool(StrSize(*CmdLine
));
2086 if (CurrentParameter
== NULL
) {
2087 return (EFI_OUT_OF_RESOURCES
);
2091 while(Walker
!= NULL
&& *Walker
!= CHAR_NULL
) {
2092 if (!EFI_ERROR(GetNextParameter(&Walker
, &CurrentParameter
, StrSize(*CmdLine
), TRUE
))) {
2093 if (StrStr(CurrentParameter
, L
"-?") == CurrentParameter
) {
2094 CurrentParameter
[0] = L
' ';
2095 CurrentParameter
[1] = L
' ';
2096 NewCmdLineSize
= StrSize(L
"help ") + StrSize(*CmdLine
);
2097 NewCommandLine
= AllocateZeroPool(NewCmdLineSize
);
2098 if (NewCommandLine
== NULL
) {
2099 Status
= EFI_OUT_OF_RESOURCES
;
2104 // We know the space is sufficient since we just calculated it.
2106 StrnCpyS(NewCommandLine
, NewCmdLineSize
/sizeof(CHAR16
), L
"help ", 5);
2107 StrnCatS(NewCommandLine
, NewCmdLineSize
/sizeof(CHAR16
), *CmdLine
, StrLen(*CmdLine
));
2108 SHELL_FREE_NON_NULL(*CmdLine
);
2109 *CmdLine
= NewCommandLine
;
2115 SHELL_FREE_NON_NULL(CurrentParameter
);
2121 Function to update the shell variable "lasterror".
2123 @param[in] ErrorCode the error code to put into lasterror.
2128 IN CONST SHELL_STATUS ErrorCode
2131 CHAR16 LeString
[19];
2132 if (sizeof(EFI_STATUS
) == sizeof(UINT64
)) {
2133 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%Lx", ErrorCode
);
2135 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%x", ErrorCode
);
2137 DEBUG_CODE(InternalEfiShellSetEnv(L
"debuglasterror", LeString
, TRUE
););
2138 InternalEfiShellSetEnv(L
"lasterror", LeString
, TRUE
);
2140 return (EFI_SUCCESS
);
2144 Converts the command line to it's post-processed form. this replaces variables and alias' per UEFI Shell spec.
2146 @param[in,out] CmdLine pointer to the command line to update
2148 @retval EFI_SUCCESS The operation was successful
2149 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
2150 @return some other error occurred
2154 ProcessCommandLineToFinal(
2155 IN OUT CHAR16
**CmdLine
2159 TrimSpaces(CmdLine
);
2161 Status
= ShellSubstituteAliases(CmdLine
);
2162 if (EFI_ERROR(Status
)) {
2166 TrimSpaces(CmdLine
);
2168 Status
= ShellSubstituteVariables(CmdLine
);
2169 if (EFI_ERROR(Status
)) {
2172 ASSERT (*CmdLine
!= NULL
);
2174 TrimSpaces(CmdLine
);
2177 // update for help parsing
2179 if (StrStr(*CmdLine
, L
"?") != NULL
) {
2181 // This may do nothing if the ? does not indicate help.
2182 // Save all the details for in the API below.
2184 Status
= DoHelpUpdate(CmdLine
);
2187 TrimSpaces(CmdLine
);
2189 return (EFI_SUCCESS
);
2193 Run an internal shell command.
2195 This API will update the shell's environment since these commands are libraries.
2197 @param[in] CmdLine the command line to run.
2198 @param[in] FirstParameter the first parameter on the command line
2199 @param[in] ParamProtocol the shell parameters protocol pointer
2200 @param[out] CommandStatus the status from the command line.
2202 @retval EFI_SUCCESS The command was completed.
2203 @retval EFI_ABORTED The command's operation was aborted.
2208 IN CONST CHAR16
*CmdLine
,
2209 IN CHAR16
*FirstParameter
,
2210 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2211 OUT EFI_STATUS
*CommandStatus
2217 SHELL_STATUS CommandReturnedStatus
;
2222 NewCmdLine
= AllocateCopyPool (StrSize (CmdLine
), CmdLine
);
2223 if (NewCmdLine
== NULL
) {
2224 return EFI_OUT_OF_RESOURCES
;
2227 for (Walker
= NewCmdLine
; Walker
!= NULL
&& *Walker
!= CHAR_NULL
; Walker
++) {
2228 if (*Walker
== L
'^' && *(Walker
+1) == L
'#') {
2229 CopyMem(Walker
, Walker
+1, StrSize(Walker
) - sizeof(Walker
[0]));
2234 // get the argc and argv updated for internal commands
2236 Status
= UpdateArgcArgv(ParamProtocol
, NewCmdLine
, Internal_Command
, &Argv
, &Argc
);
2237 if (!EFI_ERROR(Status
)) {
2239 // Run the internal command.
2241 Status
= ShellCommandRunCommandHandler(FirstParameter
, &CommandReturnedStatus
, &LastError
);
2243 if (!EFI_ERROR(Status
)) {
2244 if (CommandStatus
!= NULL
) {
2245 if (CommandReturnedStatus
!= SHELL_SUCCESS
) {
2246 *CommandStatus
= (EFI_STATUS
)(CommandReturnedStatus
| MAX_BIT
);
2248 *CommandStatus
= EFI_SUCCESS
;
2253 // Update last error status.
2254 // some commands do not update last error.
2257 SetLastError(CommandReturnedStatus
);
2261 // Pass thru the exitcode from the app.
2263 if (ShellCommandGetExit()) {
2265 // An Exit was requested ("exit" command), pass its value up.
2267 Status
= CommandReturnedStatus
;
2268 } else if (CommandReturnedStatus
!= SHELL_SUCCESS
&& IsScriptOnlyCommand(FirstParameter
)) {
2270 // Always abort when a script only command fails for any reason
2272 Status
= EFI_ABORTED
;
2273 } else if (ShellCommandGetCurrentScriptFile() != NULL
&& CommandReturnedStatus
== SHELL_ABORTED
) {
2275 // Abort when in a script and a command aborted
2277 Status
= EFI_ABORTED
;
2283 // This is guaranteed to be called after UpdateArgcArgv no matter what else happened.
2284 // This is safe even if the update API failed. In this case, it may be a no-op.
2286 RestoreArgcArgv(ParamProtocol
, &Argv
, &Argc
);
2289 // If a script is running and the command is not a script only command, then
2290 // change return value to success so the script won't halt (unless aborted).
2292 // Script only commands have to be able halt the script since the script will
2293 // not operate if they are failing.
2295 if ( ShellCommandGetCurrentScriptFile() != NULL
2296 && !IsScriptOnlyCommand(FirstParameter
)
2297 && Status
!= EFI_ABORTED
2299 Status
= EFI_SUCCESS
;
2302 FreePool (NewCmdLine
);
2307 Function to run the command or file.
2309 @param[in] Type the type of operation being run.
2310 @param[in] CmdLine the command line to run.
2311 @param[in] FirstParameter the first parameter on the command line
2312 @param[in] ParamProtocol the shell parameters protocol pointer
2313 @param[out] CommandStatus the status from the command line.
2315 @retval EFI_SUCCESS The command was completed.
2316 @retval EFI_ABORTED The command's operation was aborted.
2321 IN SHELL_OPERATION_TYPES Type
,
2322 IN CONST CHAR16
*CmdLine
,
2323 IN CHAR16
*FirstParameter
,
2324 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2325 OUT EFI_STATUS
*CommandStatus
2329 EFI_STATUS StartStatus
;
2330 CHAR16
*CommandWithPath
;
2331 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
2332 SHELL_STATUS CalleeExitStatus
;
2334 Status
= EFI_SUCCESS
;
2335 CommandWithPath
= NULL
;
2337 CalleeExitStatus
= SHELL_INVALID_PARAMETER
;
2340 case Internal_Command
:
2341 Status
= RunInternalCommand(CmdLine
, FirstParameter
, ParamProtocol
, CommandStatus
);
2343 case Script_File_Name
:
2344 case Efi_Application
:
2346 // Process a fully qualified path
2348 if (StrStr(FirstParameter
, L
":") != NULL
) {
2349 ASSERT (CommandWithPath
== NULL
);
2350 if (ShellIsFile(FirstParameter
) == EFI_SUCCESS
) {
2351 CommandWithPath
= StrnCatGrow(&CommandWithPath
, NULL
, FirstParameter
, 0);
2356 // Process a relative path and also check in the path environment variable
2358 if (CommandWithPath
== NULL
) {
2359 CommandWithPath
= ShellFindFilePathEx(FirstParameter
, mExecutableExtensions
);
2363 // This should be impossible now.
2365 ASSERT(CommandWithPath
!= NULL
);
2368 // Make sure that path is not just a directory (or not found)
2370 if (!EFI_ERROR(ShellIsDirectory(CommandWithPath
))) {
2371 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2372 SetLastError(SHELL_NOT_FOUND
);
2375 case Script_File_Name
:
2376 Status
= RunScriptFile (CommandWithPath
, NULL
, CmdLine
, ParamProtocol
);
2378 case Efi_Application
:
2380 // Get the device path of the application image
2382 DevPath
= ShellInfoObject
.NewEfiShellProtocol
->GetDevicePathFromFilePath(CommandWithPath
);
2383 if (DevPath
== NULL
){
2384 Status
= EFI_OUT_OF_RESOURCES
;
2389 // Execute the device path
2391 Status
= InternalShellExecuteDevicePath(
2399 SHELL_FREE_NON_NULL(DevPath
);
2401 if(EFI_ERROR (Status
)) {
2402 CalleeExitStatus
= (SHELL_STATUS
) (Status
& (~MAX_BIT
));
2404 CalleeExitStatus
= (SHELL_STATUS
) StartStatus
;
2407 if (CommandStatus
!= NULL
) {
2408 *CommandStatus
= CalleeExitStatus
;
2412 // Update last error status.
2414 // Status is an EFI_STATUS. Clear top bit to convert to SHELL_STATUS
2415 SetLastError(CalleeExitStatus
);
2431 SHELL_FREE_NON_NULL(CommandWithPath
);
2437 Function to setup StdIn, StdErr, StdOut, and then run the command or file.
2439 @param[in] Type the type of operation being run.
2440 @param[in] CmdLine the command line to run.
2441 @param[in] FirstParameter the first parameter on the command line.
2442 @param[in] ParamProtocol the shell parameters protocol pointer
2443 @param[out] CommandStatus the status from the command line.
2445 @retval EFI_SUCCESS The command was completed.
2446 @retval EFI_ABORTED The command's operation was aborted.
2450 SetupAndRunCommandOrFile(
2451 IN SHELL_OPERATION_TYPES Type
,
2453 IN CHAR16
*FirstParameter
,
2454 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2455 OUT EFI_STATUS
*CommandStatus
2459 SHELL_FILE_HANDLE OriginalStdIn
;
2460 SHELL_FILE_HANDLE OriginalStdOut
;
2461 SHELL_FILE_HANDLE OriginalStdErr
;
2462 SYSTEM_TABLE_INFO OriginalSystemTableInfo
;
2465 // Update the StdIn, StdOut, and StdErr for redirection to environment variables, files, etc... unicode and ASCII
2467 Status
= UpdateStdInStdOutStdErr(ParamProtocol
, CmdLine
, &OriginalStdIn
, &OriginalStdOut
, &OriginalStdErr
, &OriginalSystemTableInfo
);
2470 // The StdIn, StdOut, and StdErr are set up.
2471 // Now run the command, script, or application
2473 if (!EFI_ERROR(Status
)) {
2474 TrimSpaces(&CmdLine
);
2475 Status
= RunCommandOrFile(Type
, CmdLine
, FirstParameter
, ParamProtocol
, CommandStatus
);
2481 if (EFI_ERROR(Status
)) {
2482 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_ERROR
), ShellInfoObject
.HiiHandle
, (VOID
*)(Status
));
2486 // put back the original StdIn, StdOut, and StdErr
2488 RestoreStdInStdOutStdErr(ParamProtocol
, &OriginalStdIn
, &OriginalStdOut
, &OriginalStdErr
, &OriginalSystemTableInfo
);
2494 Function will process and run a command line.
2496 This will determine if the command line represents an internal shell
2497 command or dispatch an external application.
2499 @param[in] CmdLine The command line to parse.
2500 @param[out] CommandStatus The status from the command line.
2502 @retval EFI_SUCCESS The command was completed.
2503 @retval EFI_ABORTED The command's operation was aborted.
2508 IN CONST CHAR16
*CmdLine
,
2509 OUT EFI_STATUS
*CommandStatus
2513 CHAR16
*CleanOriginal
;
2514 CHAR16
*FirstParameter
;
2516 SHELL_OPERATION_TYPES Type
;
2518 ASSERT(CmdLine
!= NULL
);
2519 if (StrLen(CmdLine
) == 0) {
2520 return (EFI_SUCCESS
);
2523 Status
= EFI_SUCCESS
;
2524 CleanOriginal
= NULL
;
2526 CleanOriginal
= StrnCatGrow(&CleanOriginal
, NULL
, CmdLine
, 0);
2527 if (CleanOriginal
== NULL
) {
2528 return (EFI_OUT_OF_RESOURCES
);
2531 TrimSpaces(&CleanOriginal
);
2534 // NULL out comments (leveraged from RunScriptFileHandle() ).
2535 // The # character on a line is used to denote that all characters on the same line
2536 // and to the right of the # are to be ignored by the shell.
2537 // Afterwards, again remove spaces, in case any were between the last command-parameter and '#'.
2539 for (TempWalker
= CleanOriginal
; TempWalker
!= NULL
&& *TempWalker
!= CHAR_NULL
; TempWalker
++) {
2540 if (*TempWalker
== L
'^') {
2541 if (*(TempWalker
+ 1) == L
'#') {
2544 } else if (*TempWalker
== L
'#') {
2545 *TempWalker
= CHAR_NULL
;
2549 TrimSpaces(&CleanOriginal
);
2552 // Handle case that passed in command line is just 1 or more " " characters.
2554 if (StrLen (CleanOriginal
) == 0) {
2555 SHELL_FREE_NON_NULL(CleanOriginal
);
2556 return (EFI_SUCCESS
);
2559 Status
= ProcessCommandLineToFinal(&CleanOriginal
);
2560 if (EFI_ERROR(Status
)) {
2561 SHELL_FREE_NON_NULL(CleanOriginal
);
2566 // We don't do normal processing with a split command line (output from one command input to another)
2568 if (ContainsSplit(CleanOriginal
)) {
2569 Status
= ProcessNewSplitCommandLine(CleanOriginal
);
2570 SHELL_FREE_NON_NULL(CleanOriginal
);
2575 // We need the first parameter information so we can determine the operation type
2577 FirstParameter
= AllocateZeroPool(StrSize(CleanOriginal
));
2578 if (FirstParameter
== NULL
) {
2579 SHELL_FREE_NON_NULL(CleanOriginal
);
2580 return (EFI_OUT_OF_RESOURCES
);
2582 TempWalker
= CleanOriginal
;
2583 if (!EFI_ERROR(GetNextParameter(&TempWalker
, &FirstParameter
, StrSize(CleanOriginal
), TRUE
))) {
2585 // Depending on the first parameter we change the behavior
2587 switch (Type
= GetOperationType(FirstParameter
)) {
2588 case File_Sys_Change
:
2589 Status
= ChangeMappedDrive (FirstParameter
);
2591 case Internal_Command
:
2592 case Script_File_Name
:
2593 case Efi_Application
:
2594 Status
= SetupAndRunCommandOrFile(Type
, CleanOriginal
, FirstParameter
, ShellInfoObject
.NewShellParametersProtocol
, CommandStatus
);
2598 // Whatever was typed, it was invalid.
2600 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2601 SetLastError(SHELL_NOT_FOUND
);
2605 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2606 SetLastError(SHELL_NOT_FOUND
);
2609 SHELL_FREE_NON_NULL(CleanOriginal
);
2610 SHELL_FREE_NON_NULL(FirstParameter
);
2616 Function will process and run a command line.
2618 This will determine if the command line represents an internal shell
2619 command or dispatch an external application.
2621 @param[in] CmdLine The command line to parse.
2623 @retval EFI_SUCCESS The command was completed.
2624 @retval EFI_ABORTED The command's operation was aborted.
2629 IN CONST CHAR16
*CmdLine
2632 return (RunShellCommand(CmdLine
, NULL
));
2636 STATIC CONST UINT16 InvalidChars
[] = {L
'*', L
'?', L
'<', L
'>', L
'\\', L
'/', L
'\"', 0x0001, 0x0002};
2638 Function determines if the CommandName COULD be a valid command. It does not determine whether
2639 this is a valid command. It only checks for invalid characters.
2641 @param[in] CommandName The name to check
2643 @retval TRUE CommandName could be a command name
2644 @retval FALSE CommandName could not be a valid command name
2649 IN CONST CHAR16
*CommandName
2653 if (CommandName
== NULL
) {
2658 ; Count
< sizeof(InvalidChars
) / sizeof(InvalidChars
[0])
2661 if (ScanMem16(CommandName
, StrSize(CommandName
), InvalidChars
[Count
]) != NULL
) {
2669 Function to process a NSH script file via SHELL_FILE_HANDLE.
2671 @param[in] Handle The handle to the already opened file.
2672 @param[in] Name The name of the script file.
2674 @retval EFI_SUCCESS the script completed successfully
2678 RunScriptFileHandle (
2679 IN SHELL_FILE_HANDLE Handle
,
2680 IN CONST CHAR16
*Name
2684 SCRIPT_FILE
*NewScriptFile
;
2686 UINTN PrintBuffSize
;
2687 CHAR16
*CommandLine
;
2688 CHAR16
*CommandLine2
;
2689 CHAR16
*CommandLine3
;
2690 SCRIPT_COMMAND_LIST
*LastCommand
;
2692 BOOLEAN PreScriptEchoState
;
2693 BOOLEAN PreCommandEchoState
;
2694 CONST CHAR16
*CurDir
;
2696 CHAR16 LeString
[50];
2697 LIST_ENTRY OldBufferList
;
2699 ASSERT(!ShellCommandGetScriptExit());
2701 PreScriptEchoState
= ShellCommandGetEchoState();
2702 PrintBuffSize
= PcdGet16(PcdShellPrintBufferSize
);
2704 NewScriptFile
= (SCRIPT_FILE
*)AllocateZeroPool(sizeof(SCRIPT_FILE
));
2705 if (NewScriptFile
== NULL
) {
2706 return (EFI_OUT_OF_RESOURCES
);
2712 ASSERT(NewScriptFile
->ScriptName
== NULL
);
2713 NewScriptFile
->ScriptName
= StrnCatGrow(&NewScriptFile
->ScriptName
, NULL
, Name
, 0);
2714 if (NewScriptFile
->ScriptName
== NULL
) {
2715 DeleteScriptFileStruct(NewScriptFile
);
2716 return (EFI_OUT_OF_RESOURCES
);
2720 // Save the parameters (used to replace %0 to %9 later on)
2722 NewScriptFile
->Argc
= ShellInfoObject
.NewShellParametersProtocol
->Argc
;
2723 if (NewScriptFile
->Argc
!= 0) {
2724 NewScriptFile
->Argv
= (CHAR16
**)AllocateZeroPool(NewScriptFile
->Argc
* sizeof(CHAR16
*));
2725 if (NewScriptFile
->Argv
== NULL
) {
2726 DeleteScriptFileStruct(NewScriptFile
);
2727 return (EFI_OUT_OF_RESOURCES
);
2729 for (LoopVar
= 0 ; LoopVar
< 10 && LoopVar
< NewScriptFile
->Argc
; LoopVar
++) {
2730 ASSERT(NewScriptFile
->Argv
[LoopVar
] == NULL
);
2731 NewScriptFile
->Argv
[LoopVar
] = StrnCatGrow(&NewScriptFile
->Argv
[LoopVar
], NULL
, ShellInfoObject
.NewShellParametersProtocol
->Argv
[LoopVar
], 0);
2732 if (NewScriptFile
->Argv
[LoopVar
] == NULL
) {
2733 DeleteScriptFileStruct(NewScriptFile
);
2734 return (EFI_OUT_OF_RESOURCES
);
2738 NewScriptFile
->Argv
= NULL
;
2741 InitializeListHead(&NewScriptFile
->CommandList
);
2742 InitializeListHead(&NewScriptFile
->SubstList
);
2745 // Now build the list of all script commands.
2748 while(!ShellFileHandleEof(Handle
)) {
2749 CommandLine
= ShellFileHandleReturnLine(Handle
, &Ascii
);
2751 if (CommandLine
== NULL
|| StrLen(CommandLine
) == 0 || CommandLine
[0] == '#') {
2752 SHELL_FREE_NON_NULL(CommandLine
);
2755 NewScriptFile
->CurrentCommand
= AllocateZeroPool(sizeof(SCRIPT_COMMAND_LIST
));
2756 if (NewScriptFile
->CurrentCommand
== NULL
) {
2757 SHELL_FREE_NON_NULL(CommandLine
);
2758 DeleteScriptFileStruct(NewScriptFile
);
2759 return (EFI_OUT_OF_RESOURCES
);
2762 NewScriptFile
->CurrentCommand
->Cl
= CommandLine
;
2763 NewScriptFile
->CurrentCommand
->Data
= NULL
;
2764 NewScriptFile
->CurrentCommand
->Line
= LineCount
;
2766 InsertTailList(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
2770 // Add this as the topmost script file
2772 ShellCommandSetNewScript (NewScriptFile
);
2775 // Now enumerate through the commands and run each one.
2777 CommandLine
= AllocateZeroPool(PrintBuffSize
);
2778 if (CommandLine
== NULL
) {
2779 DeleteScriptFileStruct(NewScriptFile
);
2780 return (EFI_OUT_OF_RESOURCES
);
2782 CommandLine2
= AllocateZeroPool(PrintBuffSize
);
2783 if (CommandLine2
== NULL
) {
2784 FreePool(CommandLine
);
2785 DeleteScriptFileStruct(NewScriptFile
);
2786 return (EFI_OUT_OF_RESOURCES
);
2789 for ( NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetFirstNode(&NewScriptFile
->CommandList
)
2790 ; !IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)
2791 ; // conditional increment in the body of the loop
2793 ASSERT(CommandLine2
!= NULL
);
2794 StrnCpyS( CommandLine2
,
2795 PrintBuffSize
/sizeof(CHAR16
),
2796 NewScriptFile
->CurrentCommand
->Cl
,
2797 PrintBuffSize
/sizeof(CHAR16
) - 1
2800 SaveBufferList(&OldBufferList
);
2803 // NULL out comments
2805 for (CommandLine3
= CommandLine2
; CommandLine3
!= NULL
&& *CommandLine3
!= CHAR_NULL
; CommandLine3
++) {
2806 if (*CommandLine3
== L
'^') {
2807 if ( *(CommandLine3
+1) == L
':') {
2808 CopyMem(CommandLine3
, CommandLine3
+1, StrSize(CommandLine3
) - sizeof(CommandLine3
[0]));
2809 } else if (*(CommandLine3
+1) == L
'#') {
2812 } else if (*CommandLine3
== L
'#') {
2813 *CommandLine3
= CHAR_NULL
;
2817 if (CommandLine2
!= NULL
&& StrLen(CommandLine2
) >= 1) {
2819 // Due to variability in starting the find and replace action we need to have both buffers the same.
2821 StrnCpyS( CommandLine
,
2822 PrintBuffSize
/sizeof(CHAR16
),
2824 PrintBuffSize
/sizeof(CHAR16
) - 1
2828 // Remove the %0 to %9 from the command line (if we have some arguments)
2830 if (NewScriptFile
->Argv
!= NULL
) {
2831 switch (NewScriptFile
->Argc
) {
2833 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%9", NewScriptFile
->Argv
[9], FALSE
, FALSE
);
2834 ASSERT_EFI_ERROR(Status
);
2836 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%8", NewScriptFile
->Argv
[8], FALSE
, FALSE
);
2837 ASSERT_EFI_ERROR(Status
);
2839 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%7", NewScriptFile
->Argv
[7], FALSE
, FALSE
);
2840 ASSERT_EFI_ERROR(Status
);
2842 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%6", NewScriptFile
->Argv
[6], FALSE
, FALSE
);
2843 ASSERT_EFI_ERROR(Status
);
2845 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%5", NewScriptFile
->Argv
[5], FALSE
, FALSE
);
2846 ASSERT_EFI_ERROR(Status
);
2848 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%4", NewScriptFile
->Argv
[4], FALSE
, FALSE
);
2849 ASSERT_EFI_ERROR(Status
);
2851 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%3", NewScriptFile
->Argv
[3], FALSE
, FALSE
);
2852 ASSERT_EFI_ERROR(Status
);
2854 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%2", NewScriptFile
->Argv
[2], FALSE
, FALSE
);
2855 ASSERT_EFI_ERROR(Status
);
2857 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%1", NewScriptFile
->Argv
[1], FALSE
, FALSE
);
2858 ASSERT_EFI_ERROR(Status
);
2860 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%0", NewScriptFile
->Argv
[0], FALSE
, FALSE
);
2861 ASSERT_EFI_ERROR(Status
);
2867 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%1", L
"\"\"", FALSE
, FALSE
);
2868 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%2", L
"\"\"", FALSE
, FALSE
);
2869 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%3", L
"\"\"", FALSE
, FALSE
);
2870 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%4", L
"\"\"", FALSE
, FALSE
);
2871 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%5", L
"\"\"", FALSE
, FALSE
);
2872 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%6", L
"\"\"", FALSE
, FALSE
);
2873 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%7", L
"\"\"", FALSE
, FALSE
);
2874 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%8", L
"\"\"", FALSE
, FALSE
);
2875 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%9", L
"\"\"", FALSE
, FALSE
);
2877 StrnCpyS( CommandLine2
,
2878 PrintBuffSize
/sizeof(CHAR16
),
2880 PrintBuffSize
/sizeof(CHAR16
) - 1
2883 LastCommand
= NewScriptFile
->CurrentCommand
;
2885 for (CommandLine3
= CommandLine2
; CommandLine3
[0] == L
' ' ; CommandLine3
++);
2887 if (CommandLine3
!= NULL
&& CommandLine3
[0] == L
':' ) {
2889 // This line is a goto target / label
2892 if (CommandLine3
!= NULL
&& StrLen(CommandLine3
) > 0) {
2893 if (CommandLine3
[0] == L
'@') {
2895 // We need to save the current echo state
2896 // and disable echo for just this command.
2898 PreCommandEchoState
= ShellCommandGetEchoState();
2899 ShellCommandSetEchoState(FALSE
);
2900 Status
= RunCommand(CommandLine3
+1);
2903 // If command was "@echo -off" or "@echo -on" then don't restore echo state
2905 if (StrCmp (L
"@echo -off", CommandLine3
) != 0 &&
2906 StrCmp (L
"@echo -on", CommandLine3
) != 0) {
2908 // Now restore the pre-'@' echo state.
2910 ShellCommandSetEchoState(PreCommandEchoState
);
2913 if (ShellCommandGetEchoState()) {
2914 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
2915 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
2916 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
2918 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
2920 ShellPrintEx(-1, -1, L
"%s\r\n", CommandLine2
);
2922 Status
= RunCommand(CommandLine3
);
2926 if (ShellCommandGetScriptExit()) {
2928 // ShellCommandGetExitCode() always returns a UINT64
2930 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%Lx", ShellCommandGetExitCode());
2931 DEBUG_CODE(InternalEfiShellSetEnv(L
"debuglasterror", LeString
, TRUE
););
2932 InternalEfiShellSetEnv(L
"lasterror", LeString
, TRUE
);
2934 ShellCommandRegisterExit(FALSE
, 0);
2935 Status
= EFI_SUCCESS
;
2936 RestoreBufferList(&OldBufferList
);
2939 if (ShellGetExecutionBreakFlag()) {
2940 RestoreBufferList(&OldBufferList
);
2943 if (EFI_ERROR(Status
)) {
2944 RestoreBufferList(&OldBufferList
);
2947 if (ShellCommandGetExit()) {
2948 RestoreBufferList(&OldBufferList
);
2953 // If that commend did not update the CurrentCommand then we need to advance it...
2955 if (LastCommand
== NewScriptFile
->CurrentCommand
) {
2956 NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetNextNode(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
2957 if (!IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)) {
2958 NewScriptFile
->CurrentCommand
->Reset
= TRUE
;
2962 NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetNextNode(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
2963 if (!IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)) {
2964 NewScriptFile
->CurrentCommand
->Reset
= TRUE
;
2967 RestoreBufferList(&OldBufferList
);
2971 FreePool(CommandLine
);
2972 FreePool(CommandLine2
);
2973 ShellCommandSetNewScript (NULL
);
2976 // Only if this was the last script reset the state.
2978 if (ShellCommandGetCurrentScriptFile()==NULL
) {
2979 ShellCommandSetEchoState(PreScriptEchoState
);
2981 return (EFI_SUCCESS
);
2985 Function to process a NSH script file.
2987 @param[in] ScriptPath Pointer to the script file name (including file system path).
2988 @param[in] Handle the handle of the script file already opened.
2989 @param[in] CmdLine the command line to run.
2990 @param[in] ParamProtocol the shell parameters protocol pointer
2992 @retval EFI_SUCCESS the script completed successfully
2997 IN CONST CHAR16
*ScriptPath
,
2998 IN SHELL_FILE_HANDLE Handle OPTIONAL
,
2999 IN CONST CHAR16
*CmdLine
,
3000 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
3004 SHELL_FILE_HANDLE FileHandle
;
3008 if (ShellIsFile(ScriptPath
) != EFI_SUCCESS
) {
3009 return (EFI_INVALID_PARAMETER
);
3013 // get the argc and argv updated for scripts
3015 Status
= UpdateArgcArgv(ParamProtocol
, CmdLine
, Script_File_Name
, &Argv
, &Argc
);
3016 if (!EFI_ERROR(Status
)) {
3018 if (Handle
== NULL
) {
3022 Status
= ShellOpenFileByName(ScriptPath
, &FileHandle
, EFI_FILE_MODE_READ
, 0);
3023 if (!EFI_ERROR(Status
)) {
3027 Status
= RunScriptFileHandle(FileHandle
, ScriptPath
);
3030 // now close the file
3032 ShellCloseFile(&FileHandle
);
3035 Status
= RunScriptFileHandle(Handle
, ScriptPath
);
3040 // This is guaranteed to be called after UpdateArgcArgv no matter what else happened.
3041 // This is safe even if the update API failed. In this case, it may be a no-op.
3043 RestoreArgcArgv(ParamProtocol
, &Argv
, &Argc
);
3049 Return the pointer to the first occurrence of any character from a list of characters.
3051 @param[in] String the string to parse
3052 @param[in] CharacterList the list of character to look for
3053 @param[in] EscapeCharacter An escape character to skip
3055 @return the location of the first character in the string
3056 @retval CHAR_NULL no instance of any character in CharacterList was found in String
3061 IN CONST CHAR16
*String
,
3062 IN CONST CHAR16
*CharacterList
,
3063 IN CONST CHAR16 EscapeCharacter
3069 for (WalkStr
= 0; WalkStr
< StrLen(String
); WalkStr
++) {
3070 if (String
[WalkStr
] == EscapeCharacter
) {
3074 for (WalkChar
= 0; WalkChar
< StrLen(CharacterList
); WalkChar
++) {
3075 if (String
[WalkStr
] == CharacterList
[WalkChar
]) {
3076 return (&String
[WalkStr
]);
3080 return (String
+ StrLen(String
));