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(), (CONST 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
;
1212 // Get screen setting to decide size of the command line buffer
1214 gST
->ConOut
->QueryMode (gST
->ConOut
, gST
->ConOut
->Mode
->Mode
, &Column
, &Row
);
1215 BufferSize
= Column
* Row
* sizeof (CHAR16
);
1216 CmdLine
= AllocateZeroPool (BufferSize
);
1217 if (CmdLine
== NULL
) {
1218 return EFI_OUT_OF_RESOURCES
;
1221 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
1226 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, gST
->ConOut
->Mode
->CursorRow
);
1228 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
1229 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
1231 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
1235 // Read a line from the console
1237 Status
= ShellInfoObject
.NewEfiShellProtocol
->ReadFile(ShellInfoObject
.NewShellParametersProtocol
->StdIn
, &BufferSize
, CmdLine
);
1240 // Null terminate the string and parse it
1242 if (!EFI_ERROR (Status
)) {
1243 CmdLine
[BufferSize
/ sizeof (CHAR16
)] = CHAR_NULL
;
1244 Status
= RunCommand(CmdLine
);
1248 // Done with this command
1255 Add a buffer to the Buffer To Free List for safely returning buffers to other
1256 places without risking letting them modify internal shell information.
1258 @param Buffer Something to pass to FreePool when the shell is exiting.
1262 AddBufferToFreeList(
1266 BUFFER_LIST
*BufferListEntry
;
1268 if (Buffer
== NULL
) {
1272 BufferListEntry
= AllocateZeroPool(sizeof(BUFFER_LIST
));
1273 ASSERT(BufferListEntry
!= NULL
);
1274 BufferListEntry
->Buffer
= Buffer
;
1275 InsertTailList(&ShellInfoObject
.BufferToFreeList
.Link
, &BufferListEntry
->Link
);
1280 Add a buffer to the Line History List
1282 @param Buffer The line buffer to add.
1286 AddLineToCommandHistory(
1287 IN CONST CHAR16
*Buffer
1292 Node
= AllocateZeroPool(sizeof(BUFFER_LIST
));
1293 ASSERT(Node
!= NULL
);
1294 Node
->Buffer
= AllocateCopyPool(StrSize(Buffer
), Buffer
);
1295 ASSERT(Node
->Buffer
!= NULL
);
1297 InsertTailList(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
, &Node
->Link
);
1301 Checks if a string is an alias for another command. If yes, then it replaces the alias name
1302 with the correct command name.
1304 @param[in, out] CommandString Upon entry the potential alias. Upon return the
1305 command name if it was an alias. If it was not
1306 an alias it will be unchanged. This function may
1307 change the buffer to fit the command name.
1309 @retval EFI_SUCCESS The name was changed.
1310 @retval EFI_SUCCESS The name was not an alias.
1311 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
1316 IN OUT CHAR16
**CommandString
1319 CONST CHAR16
*NewString
;
1321 NewString
= ShellInfoObject
.NewEfiShellProtocol
->GetAlias(*CommandString
, NULL
);
1322 if (NewString
== NULL
) {
1323 return (EFI_SUCCESS
);
1325 FreePool(*CommandString
);
1326 *CommandString
= AllocateCopyPool(StrSize(NewString
), NewString
);
1327 if (*CommandString
== NULL
) {
1328 return (EFI_OUT_OF_RESOURCES
);
1330 return (EFI_SUCCESS
);
1334 This function will eliminate unreplaced (and therefore non-found) environment variables.
1336 @param[in,out] CmdLine The command line to update.
1340 StripUnreplacedEnvironmentVariables(
1341 IN OUT CHAR16
*CmdLine
1344 CHAR16
*FirstPercent
;
1346 CHAR16
*SecondPercent
;
1347 CHAR16
*SecondQuote
;
1348 CHAR16
*CurrentLocator
;
1350 for (CurrentLocator
= CmdLine
; CurrentLocator
!= NULL
; ) {
1351 FirstQuote
= FindNextInstance(CurrentLocator
, L
"\"", TRUE
);
1352 FirstPercent
= FindNextInstance(CurrentLocator
, L
"%", TRUE
);
1353 SecondPercent
= FirstPercent
!=NULL
?FindNextInstance(FirstPercent
+1, L
"%", TRUE
):NULL
;
1354 if (FirstPercent
== NULL
|| SecondPercent
== NULL
) {
1356 // If we ever don't have 2 % we are done.
1361 if (FirstQuote
!= NULL
&& FirstQuote
< FirstPercent
) {
1362 SecondQuote
= FindNextInstance(FirstQuote
+1, L
"\"", TRUE
);
1364 // Quote is first found
1367 if (SecondQuote
< FirstPercent
) {
1369 // restart after the pair of "
1371 CurrentLocator
= SecondQuote
+ 1;
1372 } else /* FirstPercent < SecondQuote */{
1374 // Restart on the first percent
1376 CurrentLocator
= FirstPercent
;
1381 if (FirstQuote
== NULL
|| SecondPercent
< FirstQuote
) {
1382 if (IsValidEnvironmentVariableName(FirstPercent
, SecondPercent
)) {
1384 // We need to remove from FirstPercent to SecondPercent
1386 CopyMem(FirstPercent
, SecondPercent
+ 1, StrSize(SecondPercent
+ 1));
1388 // don't need to update the locator. both % characters are gone.
1391 CurrentLocator
= SecondPercent
+ 1;
1395 CurrentLocator
= FirstQuote
;
1397 return (EFI_SUCCESS
);
1401 Function allocates a new command line and replaces all instances of environment
1402 variable names that are correctly preset to their values.
1404 If the return value is not NULL the memory must be caller freed.
1406 @param[in] OriginalCommandLine The original command line
1408 @retval NULL An error occurred.
1409 @return The new command line with no environment variables present.
1413 ShellConvertVariables (
1414 IN CONST CHAR16
*OriginalCommandLine
1417 CONST CHAR16
*MasterEnvList
;
1419 CHAR16
*NewCommandLine1
;
1420 CHAR16
*NewCommandLine2
;
1424 SCRIPT_FILE
*CurrentScriptFile
;
1425 ALIAS_LIST
*AliasListNode
;
1427 ASSERT(OriginalCommandLine
!= NULL
);
1430 NewSize
= StrSize(OriginalCommandLine
);
1431 CurrentScriptFile
= ShellCommandGetCurrentScriptFile();
1434 ///@todo update this to handle the %0 - %9 for scripting only (borrow from line 1256 area) ? ? ?
1437 // calculate the size required for the post-conversion string...
1439 if (CurrentScriptFile
!= NULL
) {
1440 for (AliasListNode
= (ALIAS_LIST
*)GetFirstNode(&CurrentScriptFile
->SubstList
)
1441 ; !IsNull(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1442 ; AliasListNode
= (ALIAS_LIST
*)GetNextNode(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1444 for (Temp
= StrStr(OriginalCommandLine
, AliasListNode
->Alias
)
1446 ; Temp
= StrStr(Temp
+1, AliasListNode
->Alias
)
1449 // we need a preceding and if there is space no ^ preceding (if no space ignore)
1451 if ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2)) {
1452 NewSize
+= StrSize(AliasListNode
->CommandString
);
1458 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1459 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
//&& *(MasterEnvList+1) != CHAR_NULL
1460 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1462 if (StrSize(MasterEnvList
) > ItemSize
) {
1463 ItemSize
= StrSize(MasterEnvList
);
1465 for (Temp
= StrStr(OriginalCommandLine
, MasterEnvList
)
1467 ; Temp
= StrStr(Temp
+1, MasterEnvList
)
1470 // we need a preceding and following % and if there is space no ^ preceding (if no space ignore)
1472 if (*(Temp
-1) == L
'%' && *(Temp
+StrLen(MasterEnvList
)) == L
'%' &&
1473 ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2))) {
1474 NewSize
+=StrSize(EfiShellGetEnv(MasterEnvList
));
1480 // now do the replacements...
1482 NewCommandLine1
= AllocateCopyPool(NewSize
, OriginalCommandLine
);
1483 NewCommandLine2
= AllocateZeroPool(NewSize
);
1484 ItemTemp
= AllocateZeroPool(ItemSize
+(2*sizeof(CHAR16
)));
1485 if (NewCommandLine1
== NULL
|| NewCommandLine2
== NULL
|| ItemTemp
== NULL
) {
1486 SHELL_FREE_NON_NULL(NewCommandLine1
);
1487 SHELL_FREE_NON_NULL(NewCommandLine2
);
1488 SHELL_FREE_NON_NULL(ItemTemp
);
1491 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1492 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
1493 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1496 ((ItemSize
+(2*sizeof(CHAR16
)))/sizeof(CHAR16
)),
1500 ((ItemSize
+(2*sizeof(CHAR16
)))/sizeof(CHAR16
)),
1504 ((ItemSize
+(2*sizeof(CHAR16
)))/sizeof(CHAR16
)),
1507 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, ItemTemp
, EfiShellGetEnv(MasterEnvList
), TRUE
, FALSE
);
1508 StrCpyS(NewCommandLine1
, NewSize
/sizeof(CHAR16
), NewCommandLine2
);
1510 if (CurrentScriptFile
!= NULL
) {
1511 for (AliasListNode
= (ALIAS_LIST
*)GetFirstNode(&CurrentScriptFile
->SubstList
)
1512 ; !IsNull(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1513 ; AliasListNode
= (ALIAS_LIST
*)GetNextNode(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1515 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, AliasListNode
->Alias
, AliasListNode
->CommandString
, TRUE
, FALSE
);
1516 StrCpyS(NewCommandLine1
, NewSize
/sizeof(CHAR16
), NewCommandLine2
);
1521 // Remove non-existent environment variables
1523 StripUnreplacedEnvironmentVariables(NewCommandLine1
);
1526 // Now cleanup any straggler intentionally ignored "%" characters
1528 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, L
"^%", L
"%", TRUE
, FALSE
);
1529 StrCpyS(NewCommandLine1
, NewSize
/sizeof(CHAR16
), NewCommandLine2
);
1531 FreePool(NewCommandLine2
);
1534 return (NewCommandLine1
);
1538 Internal function to run a command line with pipe usage.
1540 @param[in] CmdLine The pointer to the command line.
1541 @param[in] StdIn The pointer to the Standard input.
1542 @param[in] StdOut The pointer to the Standard output.
1544 @retval EFI_SUCCESS The split command is executed successfully.
1545 @retval other Some error occurs when executing the split command.
1550 IN CONST CHAR16
*CmdLine
,
1551 IN SHELL_FILE_HANDLE
*StdIn
,
1552 IN SHELL_FILE_HANDLE
*StdOut
1556 CHAR16
*NextCommandLine
;
1557 CHAR16
*OurCommandLine
;
1561 SHELL_FILE_HANDLE
*TempFileHandle
;
1564 ASSERT(StdOut
== NULL
);
1566 ASSERT(StrStr(CmdLine
, L
"|") != NULL
);
1568 Status
= EFI_SUCCESS
;
1569 NextCommandLine
= NULL
;
1570 OurCommandLine
= NULL
;
1574 NextCommandLine
= StrnCatGrow(&NextCommandLine
, &Size1
, StrStr(CmdLine
, L
"|")+1, 0);
1575 OurCommandLine
= StrnCatGrow(&OurCommandLine
, &Size2
, CmdLine
, StrStr(CmdLine
, L
"|") - CmdLine
);
1577 if (NextCommandLine
== NULL
|| OurCommandLine
== NULL
) {
1578 SHELL_FREE_NON_NULL(OurCommandLine
);
1579 SHELL_FREE_NON_NULL(NextCommandLine
);
1580 return (EFI_OUT_OF_RESOURCES
);
1581 } else if (StrStr(OurCommandLine
, L
"|") != NULL
|| Size1
== 0 || Size2
== 0) {
1582 SHELL_FREE_NON_NULL(OurCommandLine
);
1583 SHELL_FREE_NON_NULL(NextCommandLine
);
1584 return (EFI_INVALID_PARAMETER
);
1585 } else if (NextCommandLine
[0] == L
'a' &&
1586 (NextCommandLine
[1] == L
' ' || NextCommandLine
[1] == CHAR_NULL
)
1588 CopyMem(NextCommandLine
, NextCommandLine
+1, StrSize(NextCommandLine
) - sizeof(NextCommandLine
[0]));
1589 while (NextCommandLine
[0] == L
' ') {
1590 CopyMem(NextCommandLine
, NextCommandLine
+1, StrSize(NextCommandLine
) - sizeof(NextCommandLine
[0]));
1592 if (NextCommandLine
[0] == CHAR_NULL
) {
1593 SHELL_FREE_NON_NULL(OurCommandLine
);
1594 SHELL_FREE_NON_NULL(NextCommandLine
);
1595 return (EFI_INVALID_PARAMETER
);
1604 // make a SPLIT_LIST item and add to list
1606 Split
= AllocateZeroPool(sizeof(SPLIT_LIST
));
1607 ASSERT(Split
!= NULL
);
1608 Split
->SplitStdIn
= StdIn
;
1609 Split
->SplitStdOut
= ConvertEfiFileProtocolToShellHandle(CreateFileInterfaceMem(Unicode
), NULL
);
1610 ASSERT(Split
->SplitStdOut
!= NULL
);
1611 InsertHeadList(&ShellInfoObject
.SplitList
.Link
, &Split
->Link
);
1613 Status
= RunCommand(OurCommandLine
);
1616 // move the output from the first to the in to the second.
1618 TempFileHandle
= Split
->SplitStdOut
;
1619 if (Split
->SplitStdIn
== StdIn
) {
1620 Split
->SplitStdOut
= NULL
;
1622 Split
->SplitStdOut
= Split
->SplitStdIn
;
1624 Split
->SplitStdIn
= TempFileHandle
;
1625 ShellInfoObject
.NewEfiShellProtocol
->SetFilePosition(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdIn
), 0);
1627 if (!EFI_ERROR(Status
)) {
1628 Status
= RunCommand(NextCommandLine
);
1632 // remove the top level from the ScriptList
1634 ASSERT((SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
) == Split
);
1635 RemoveEntryList(&Split
->Link
);
1638 // Note that the original StdIn is now the StdOut...
1640 if (Split
->SplitStdOut
!= NULL
&& Split
->SplitStdOut
!= StdIn
) {
1641 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdOut
));
1643 if (Split
->SplitStdIn
!= NULL
) {
1644 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdIn
));
1648 FreePool(NextCommandLine
);
1649 FreePool(OurCommandLine
);
1655 Take the original command line, substitute any variables, free
1656 the original string, return the modified copy.
1658 @param[in] CmdLine pointer to the command line to update.
1660 @retval EFI_SUCCESS the function was successful.
1661 @retval EFI_OUT_OF_RESOURCES a memory allocation failed.
1665 ShellSubstituteVariables(
1670 NewCmdLine
= ShellConvertVariables(*CmdLine
);
1671 SHELL_FREE_NON_NULL(*CmdLine
);
1672 if (NewCmdLine
== NULL
) {
1673 return (EFI_OUT_OF_RESOURCES
);
1675 *CmdLine
= NewCmdLine
;
1676 return (EFI_SUCCESS
);
1680 Take the original command line, substitute any alias in the first group of space delimited characters, free
1681 the original string, return the modified copy.
1683 @param[in] CmdLine pointer to the command line to update.
1685 @retval EFI_SUCCESS the function was successful.
1686 @retval EFI_OUT_OF_RESOURCES a memory allocation failed.
1690 ShellSubstituteAliases(
1695 CHAR16
*CommandName
;
1697 UINTN PostAliasSize
;
1698 ASSERT(CmdLine
!= NULL
);
1699 ASSERT(*CmdLine
!= NULL
);
1703 if (StrStr((*CmdLine
), L
" ") == NULL
){
1704 StrnCatGrow(&CommandName
, NULL
, (*CmdLine
), 0);
1706 StrnCatGrow(&CommandName
, NULL
, (*CmdLine
), StrStr((*CmdLine
), L
" ") - (*CmdLine
));
1710 // This cannot happen 'inline' since the CmdLine can need extra space.
1713 if (!ShellCommandIsCommandOnList(CommandName
)) {
1715 // Convert via alias
1717 Status
= ShellConvertAlias(&CommandName
);
1718 if (EFI_ERROR(Status
)){
1722 NewCmdLine
= StrnCatGrow(&NewCmdLine
, &PostAliasSize
, CommandName
, 0);
1723 if (NewCmdLine
== NULL
) {
1724 SHELL_FREE_NON_NULL(CommandName
);
1725 SHELL_FREE_NON_NULL(*CmdLine
);
1726 return (EFI_OUT_OF_RESOURCES
);
1728 NewCmdLine
= StrnCatGrow(&NewCmdLine
, &PostAliasSize
, StrStr((*CmdLine
), L
" "), 0);
1729 if (NewCmdLine
== NULL
) {
1730 SHELL_FREE_NON_NULL(CommandName
);
1731 SHELL_FREE_NON_NULL(*CmdLine
);
1732 return (EFI_OUT_OF_RESOURCES
);
1735 NewCmdLine
= StrnCatGrow(&NewCmdLine
, NULL
, (*CmdLine
), 0);
1738 SHELL_FREE_NON_NULL(*CmdLine
);
1739 SHELL_FREE_NON_NULL(CommandName
);
1742 // re-assign the passed in double pointer to point to our newly allocated buffer
1744 *CmdLine
= NewCmdLine
;
1746 return (EFI_SUCCESS
);
1750 Takes the Argv[0] part of the command line and determine the meaning of it.
1752 @param[in] CmdName pointer to the command line to update.
1754 @retval Internal_Command The name is an internal command.
1755 @retval File_Sys_Change the name is a file system change.
1756 @retval Script_File_Name the name is a NSH script file.
1757 @retval Unknown_Invalid the name is unknown.
1758 @retval Efi_Application the name is an application (.EFI).
1760 SHELL_OPERATION_TYPES
1763 IN CONST CHAR16
*CmdName
1766 CHAR16
* FileWithPath
;
1767 CONST CHAR16
* TempLocation
;
1768 CONST CHAR16
* TempLocation2
;
1770 FileWithPath
= NULL
;
1772 // test for an internal command.
1774 if (ShellCommandIsCommandOnList(CmdName
)) {
1775 return (Internal_Command
);
1779 // Test for file system change request. anything ending with first : and cant have spaces.
1781 if (CmdName
[(StrLen(CmdName
)-1)] == L
':') {
1782 if ( StrStr(CmdName
, L
" ") != NULL
1783 || StrLen(StrStr(CmdName
, L
":")) > 1
1785 return (Unknown_Invalid
);
1787 return (File_Sys_Change
);
1793 if ((FileWithPath
= ShellFindFilePathEx(CmdName
, mExecutableExtensions
)) != NULL
) {
1795 // See if that file has a script file extension
1797 if (StrLen(FileWithPath
) > 4) {
1798 TempLocation
= FileWithPath
+StrLen(FileWithPath
)-4;
1799 TempLocation2
= mScriptExtension
;
1800 if (StringNoCaseCompare((VOID
*)(&TempLocation
), (VOID
*)(&TempLocation2
)) == 0) {
1801 SHELL_FREE_NON_NULL(FileWithPath
);
1802 return (Script_File_Name
);
1807 // Was a file, but not a script. we treat this as an application.
1809 SHELL_FREE_NON_NULL(FileWithPath
);
1810 return (Efi_Application
);
1813 SHELL_FREE_NON_NULL(FileWithPath
);
1815 // No clue what this is... return invalid flag...
1817 return (Unknown_Invalid
);
1821 Determine if the first item in a command line is valid.
1823 @param[in] CmdLine The command line to parse.
1825 @retval EFI_SUCCESS The item is valid.
1826 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
1827 @retval EFI_NOT_FOUND The operation type is unknown or invalid.
1832 IN CONST CHAR16
*CmdLine
1836 CHAR16
*FirstParameter
;
1842 Temp
= StrnCatGrow(&Temp
, NULL
, CmdLine
, 0);
1844 return (EFI_OUT_OF_RESOURCES
);
1847 FirstParameter
= StrStr(Temp
, L
"|");
1848 if (FirstParameter
!= NULL
) {
1849 *FirstParameter
= CHAR_NULL
;
1852 FirstParameter
= NULL
;
1855 // Process the command line
1857 Status
= ProcessCommandLineToFinal(&Temp
);
1859 if (!EFI_ERROR(Status
)) {
1860 FirstParameter
= AllocateZeroPool(StrSize(CmdLine
));
1861 if (FirstParameter
== NULL
) {
1862 SHELL_FREE_NON_NULL(Temp
);
1863 return (EFI_OUT_OF_RESOURCES
);
1865 TempWalker
= (CHAR16
*)Temp
;
1866 if (!EFI_ERROR(GetNextParameter(&TempWalker
, &FirstParameter
, StrSize(CmdLine
)))) {
1867 if (GetOperationType(FirstParameter
) == Unknown_Invalid
) {
1868 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
1869 SetLastError(SHELL_NOT_FOUND
);
1870 Status
= EFI_NOT_FOUND
;
1875 SHELL_FREE_NON_NULL(Temp
);
1876 SHELL_FREE_NON_NULL(FirstParameter
);
1881 Determine if a command line contains with a split contains only valid commands.
1883 @param[in] CmdLine The command line to parse.
1885 @retval EFI_SUCCESS CmdLine has only valid commands, application, or has no split.
1886 @retval EFI_ABORTED CmdLine has at least one invalid command or application.
1891 IN CONST CHAR16
*CmdLine
1894 CONST CHAR16
*TempSpot
;
1898 // If this was the only item, then get out
1900 if (!ContainsSplit(CmdLine
)) {
1901 return (EFI_SUCCESS
);
1905 // Verify up to the pipe or end character
1907 Status
= IsValidSplit(CmdLine
);
1908 if (EFI_ERROR(Status
)) {
1913 // recurse to verify the next item
1915 TempSpot
= FindFirstCharacter(CmdLine
, L
"|", L
'^') + 1;
1916 if (*TempSpot
== L
'a' &&
1917 (*(TempSpot
+ 1) == L
' ' || *(TempSpot
+ 1) == CHAR_NULL
)
1919 // If it's an ASCII pipe '|a'
1923 return (VerifySplit(TempSpot
));
1927 Process a split based operation.
1929 @param[in] CmdLine pointer to the command line to process
1931 @retval EFI_SUCCESS The operation was successful
1932 @return an error occurred.
1936 ProcessNewSplitCommandLine(
1937 IN CONST CHAR16
*CmdLine
1943 Status
= VerifySplit(CmdLine
);
1944 if (EFI_ERROR(Status
)) {
1951 // are we in an existing split???
1953 if (!IsListEmpty(&ShellInfoObject
.SplitList
.Link
)) {
1954 Split
= (SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
);
1957 if (Split
== NULL
) {
1958 Status
= RunSplitCommand(CmdLine
, NULL
, NULL
);
1960 Status
= RunSplitCommand(CmdLine
, Split
->SplitStdIn
, Split
->SplitStdOut
);
1962 if (EFI_ERROR(Status
)) {
1963 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_SPLIT
), ShellInfoObject
.HiiHandle
, CmdLine
);
1969 Handle a request to change the current file system.
1971 @param[in] CmdLine The passed in command line.
1973 @retval EFI_SUCCESS The operation was successful.
1978 IN CONST CHAR16
*CmdLine
1982 Status
= EFI_SUCCESS
;
1985 // make sure we are the right operation
1987 ASSERT(CmdLine
[(StrLen(CmdLine
)-1)] == L
':' && StrStr(CmdLine
, L
" ") == NULL
);
1990 // Call the protocol API to do the work
1992 Status
= ShellInfoObject
.NewEfiShellProtocol
->SetCurDir(NULL
, CmdLine
);
1995 // Report any errors
1997 if (EFI_ERROR(Status
)) {
1998 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_MAPPING
), ShellInfoObject
.HiiHandle
, CmdLine
);
2005 Reprocess the command line to direct all -? to the help command.
2007 if found, will add "help" as argv[0], and move the rest later.
2009 @param[in,out] CmdLine pointer to the command line to update
2014 IN OUT CHAR16
**CmdLine
2017 CHAR16
*CurrentParameter
;
2019 CHAR16
*NewCommandLine
;
2021 UINTN NewCmdLineSize
;
2023 Status
= EFI_SUCCESS
;
2025 CurrentParameter
= AllocateZeroPool(StrSize(*CmdLine
));
2026 if (CurrentParameter
== NULL
) {
2027 return (EFI_OUT_OF_RESOURCES
);
2031 while(Walker
!= NULL
&& *Walker
!= CHAR_NULL
) {
2032 if (!EFI_ERROR(GetNextParameter(&Walker
, &CurrentParameter
, StrSize(*CmdLine
)))) {
2033 if (StrStr(CurrentParameter
, L
"-?") == CurrentParameter
) {
2034 CurrentParameter
[0] = L
' ';
2035 CurrentParameter
[1] = L
' ';
2036 NewCmdLineSize
= StrSize(L
"help ") + StrSize(*CmdLine
);
2037 NewCommandLine
= AllocateZeroPool(NewCmdLineSize
);
2038 if (NewCommandLine
== NULL
) {
2039 Status
= EFI_OUT_OF_RESOURCES
;
2044 // We know the space is sufficient since we just calculated it.
2046 StrnCpyS(NewCommandLine
, NewCmdLineSize
/sizeof(CHAR16
), L
"help ", 5);
2047 StrnCatS(NewCommandLine
, NewCmdLineSize
/sizeof(CHAR16
), *CmdLine
, StrLen(*CmdLine
));
2048 SHELL_FREE_NON_NULL(*CmdLine
);
2049 *CmdLine
= NewCommandLine
;
2055 SHELL_FREE_NON_NULL(CurrentParameter
);
2061 Function to update the shell variable "lasterror".
2063 @param[in] ErrorCode the error code to put into lasterror.
2068 IN CONST SHELL_STATUS ErrorCode
2071 CHAR16 LeString
[19];
2072 if (sizeof(EFI_STATUS
) == sizeof(UINT64
)) {
2073 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%Lx", ErrorCode
);
2075 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%x", ErrorCode
);
2077 DEBUG_CODE(InternalEfiShellSetEnv(L
"debuglasterror", LeString
, TRUE
););
2078 InternalEfiShellSetEnv(L
"lasterror", LeString
, TRUE
);
2080 return (EFI_SUCCESS
);
2084 Converts the command line to it's post-processed form. this replaces variables and alias' per UEFI Shell spec.
2086 @param[in,out] CmdLine pointer to the command line to update
2088 @retval EFI_SUCCESS The operation was successful
2089 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
2090 @return some other error occurred
2094 ProcessCommandLineToFinal(
2095 IN OUT CHAR16
**CmdLine
2099 TrimSpaces(CmdLine
);
2101 Status
= ShellSubstituteAliases(CmdLine
);
2102 if (EFI_ERROR(Status
)) {
2106 TrimSpaces(CmdLine
);
2108 Status
= ShellSubstituteVariables(CmdLine
);
2109 if (EFI_ERROR(Status
)) {
2112 ASSERT (*CmdLine
!= NULL
);
2114 TrimSpaces(CmdLine
);
2117 // update for help parsing
2119 if (StrStr(*CmdLine
, L
"?") != NULL
) {
2121 // This may do nothing if the ? does not indicate help.
2122 // Save all the details for in the API below.
2124 Status
= DoHelpUpdate(CmdLine
);
2127 TrimSpaces(CmdLine
);
2129 return (EFI_SUCCESS
);
2133 Run an internal shell command.
2135 This API will update the shell's environment since these commands are libraries.
2137 @param[in] CmdLine the command line to run.
2138 @param[in] FirstParameter the first parameter on the command line
2139 @param[in] ParamProtocol the shell parameters protocol pointer
2140 @param[out] CommandStatus the status from the command line.
2142 @retval EFI_SUCCESS The command was completed.
2143 @retval EFI_ABORTED The command's operation was aborted.
2148 IN CONST CHAR16
*CmdLine
,
2149 IN CHAR16
*FirstParameter
,
2150 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2151 OUT EFI_STATUS
*CommandStatus
2157 SHELL_STATUS CommandReturnedStatus
;
2162 NewCmdLine
= AllocateCopyPool (StrSize (CmdLine
), CmdLine
);
2163 if (NewCmdLine
== NULL
) {
2164 return EFI_OUT_OF_RESOURCES
;
2167 for (Walker
= NewCmdLine
; Walker
!= NULL
&& *Walker
!= CHAR_NULL
; Walker
++) {
2168 if (*Walker
== L
'^' && *(Walker
+1) == L
'#') {
2169 CopyMem(Walker
, Walker
+1, StrSize(Walker
) - sizeof(Walker
[0]));
2174 // get the argc and argv updated for internal commands
2176 Status
= UpdateArgcArgv(ParamProtocol
, NewCmdLine
, &Argv
, &Argc
);
2177 if (!EFI_ERROR(Status
)) {
2179 // Run the internal command.
2181 Status
= ShellCommandRunCommandHandler(FirstParameter
, &CommandReturnedStatus
, &LastError
);
2183 if (!EFI_ERROR(Status
)) {
2184 if (CommandStatus
!= NULL
) {
2185 if (CommandReturnedStatus
!= SHELL_SUCCESS
) {
2186 *CommandStatus
= (EFI_STATUS
)(CommandReturnedStatus
| MAX_BIT
);
2188 *CommandStatus
= EFI_SUCCESS
;
2193 // Update last error status.
2194 // some commands do not update last error.
2197 SetLastError(CommandReturnedStatus
);
2201 // Pass thru the exitcode from the app.
2203 if (ShellCommandGetExit()) {
2205 // An Exit was requested ("exit" command), pass its value up.
2207 Status
= CommandReturnedStatus
;
2208 } else if (CommandReturnedStatus
!= SHELL_SUCCESS
&& IsScriptOnlyCommand(FirstParameter
)) {
2210 // Always abort when a script only command fails for any reason
2212 Status
= EFI_ABORTED
;
2213 } else if (ShellCommandGetCurrentScriptFile() != NULL
&& CommandReturnedStatus
== SHELL_ABORTED
) {
2215 // Abort when in a script and a command aborted
2217 Status
= EFI_ABORTED
;
2223 // This is guaranteed to be called after UpdateArgcArgv no matter what else happened.
2224 // This is safe even if the update API failed. In this case, it may be a no-op.
2226 RestoreArgcArgv(ParamProtocol
, &Argv
, &Argc
);
2229 // If a script is running and the command is not a script only command, then
2230 // change return value to success so the script won't halt (unless aborted).
2232 // Script only commands have to be able halt the script since the script will
2233 // not operate if they are failing.
2235 if ( ShellCommandGetCurrentScriptFile() != NULL
2236 && !IsScriptOnlyCommand(FirstParameter
)
2237 && Status
!= EFI_ABORTED
2239 Status
= EFI_SUCCESS
;
2242 FreePool (NewCmdLine
);
2247 Function to run the command or file.
2249 @param[in] Type the type of operation being run.
2250 @param[in] CmdLine the command line to run.
2251 @param[in] FirstParameter the first parameter on the command line
2252 @param[in] ParamProtocol the shell parameters protocol pointer
2253 @param[out] CommandStatus the status from the command line.
2255 @retval EFI_SUCCESS The command was completed.
2256 @retval EFI_ABORTED The command's operation was aborted.
2261 IN SHELL_OPERATION_TYPES Type
,
2262 IN CONST CHAR16
*CmdLine
,
2263 IN CHAR16
*FirstParameter
,
2264 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2265 OUT EFI_STATUS
*CommandStatus
2269 EFI_STATUS StartStatus
;
2270 CHAR16
*CommandWithPath
;
2271 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
2272 SHELL_STATUS CalleeExitStatus
;
2274 Status
= EFI_SUCCESS
;
2275 CommandWithPath
= NULL
;
2277 CalleeExitStatus
= SHELL_INVALID_PARAMETER
;
2280 case Internal_Command
:
2281 Status
= RunInternalCommand(CmdLine
, FirstParameter
, ParamProtocol
, CommandStatus
);
2283 case Script_File_Name
:
2284 case Efi_Application
:
2286 // Process a fully qualified path
2288 if (StrStr(FirstParameter
, L
":") != NULL
) {
2289 ASSERT (CommandWithPath
== NULL
);
2290 if (ShellIsFile(FirstParameter
) == EFI_SUCCESS
) {
2291 CommandWithPath
= StrnCatGrow(&CommandWithPath
, NULL
, FirstParameter
, 0);
2296 // Process a relative path and also check in the path environment variable
2298 if (CommandWithPath
== NULL
) {
2299 CommandWithPath
= ShellFindFilePathEx(FirstParameter
, mExecutableExtensions
);
2303 // This should be impossible now.
2305 ASSERT(CommandWithPath
!= NULL
);
2308 // Make sure that path is not just a directory (or not found)
2310 if (!EFI_ERROR(ShellIsDirectory(CommandWithPath
))) {
2311 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2312 SetLastError(SHELL_NOT_FOUND
);
2315 case Script_File_Name
:
2316 Status
= RunScriptFile (CommandWithPath
, NULL
, CmdLine
, ParamProtocol
);
2318 case Efi_Application
:
2320 // Get the device path of the application image
2322 DevPath
= ShellInfoObject
.NewEfiShellProtocol
->GetDevicePathFromFilePath(CommandWithPath
);
2323 if (DevPath
== NULL
){
2324 Status
= EFI_OUT_OF_RESOURCES
;
2329 // Execute the device path
2331 Status
= InternalShellExecuteDevicePath(
2339 SHELL_FREE_NON_NULL(DevPath
);
2341 if(EFI_ERROR (Status
)) {
2342 CalleeExitStatus
= (SHELL_STATUS
) (Status
& (~MAX_BIT
));
2344 CalleeExitStatus
= (SHELL_STATUS
) StartStatus
;
2347 if (CommandStatus
!= NULL
) {
2348 *CommandStatus
= CalleeExitStatus
;
2352 // Update last error status.
2354 // Status is an EFI_STATUS. Clear top bit to convert to SHELL_STATUS
2355 SetLastError(CalleeExitStatus
);
2371 SHELL_FREE_NON_NULL(CommandWithPath
);
2377 Function to setup StdIn, StdErr, StdOut, and then run the command or file.
2379 @param[in] Type the type of operation being run.
2380 @param[in] CmdLine the command line to run.
2381 @param[in] FirstParameter the first parameter on the command line.
2382 @param[in] ParamProtocol the shell parameters protocol pointer
2383 @param[out] CommandStatus the status from the command line.
2385 @retval EFI_SUCCESS The command was completed.
2386 @retval EFI_ABORTED The command's operation was aborted.
2390 SetupAndRunCommandOrFile(
2391 IN SHELL_OPERATION_TYPES Type
,
2393 IN CHAR16
*FirstParameter
,
2394 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2395 OUT EFI_STATUS
*CommandStatus
2399 SHELL_FILE_HANDLE OriginalStdIn
;
2400 SHELL_FILE_HANDLE OriginalStdOut
;
2401 SHELL_FILE_HANDLE OriginalStdErr
;
2402 SYSTEM_TABLE_INFO OriginalSystemTableInfo
;
2405 // Update the StdIn, StdOut, and StdErr for redirection to environment variables, files, etc... unicode and ASCII
2407 Status
= UpdateStdInStdOutStdErr(ParamProtocol
, CmdLine
, &OriginalStdIn
, &OriginalStdOut
, &OriginalStdErr
, &OriginalSystemTableInfo
);
2410 // The StdIn, StdOut, and StdErr are set up.
2411 // Now run the command, script, or application
2413 if (!EFI_ERROR(Status
)) {
2414 TrimSpaces(&CmdLine
);
2415 Status
= RunCommandOrFile(Type
, CmdLine
, FirstParameter
, ParamProtocol
, CommandStatus
);
2421 if (EFI_ERROR(Status
)) {
2422 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_ERROR
), ShellInfoObject
.HiiHandle
, (VOID
*)(Status
));
2426 // put back the original StdIn, StdOut, and StdErr
2428 RestoreStdInStdOutStdErr(ParamProtocol
, &OriginalStdIn
, &OriginalStdOut
, &OriginalStdErr
, &OriginalSystemTableInfo
);
2434 Function will process and run a command line.
2436 This will determine if the command line represents an internal shell
2437 command or dispatch an external application.
2439 @param[in] CmdLine The command line to parse.
2440 @param[out] CommandStatus The status from the command line.
2442 @retval EFI_SUCCESS The command was completed.
2443 @retval EFI_ABORTED The command's operation was aborted.
2448 IN CONST CHAR16
*CmdLine
,
2449 OUT EFI_STATUS
*CommandStatus
2453 CHAR16
*CleanOriginal
;
2454 CHAR16
*FirstParameter
;
2456 SHELL_OPERATION_TYPES Type
;
2458 ASSERT(CmdLine
!= NULL
);
2459 if (StrLen(CmdLine
) == 0) {
2460 return (EFI_SUCCESS
);
2463 Status
= EFI_SUCCESS
;
2464 CleanOriginal
= NULL
;
2466 CleanOriginal
= StrnCatGrow(&CleanOriginal
, NULL
, CmdLine
, 0);
2467 if (CleanOriginal
== NULL
) {
2468 return (EFI_OUT_OF_RESOURCES
);
2471 TrimSpaces(&CleanOriginal
);
2474 // NULL out comments (leveraged from RunScriptFileHandle() ).
2475 // The # character on a line is used to denote that all characters on the same line
2476 // and to the right of the # are to be ignored by the shell.
2477 // Afterwards, again remove spaces, in case any were between the last command-parameter and '#'.
2479 for (TempWalker
= CleanOriginal
; TempWalker
!= NULL
&& *TempWalker
!= CHAR_NULL
; TempWalker
++) {
2480 if (*TempWalker
== L
'^') {
2481 if (*(TempWalker
+ 1) == L
'#') {
2484 } else if (*TempWalker
== L
'#') {
2485 *TempWalker
= CHAR_NULL
;
2489 TrimSpaces(&CleanOriginal
);
2492 // Handle case that passed in command line is just 1 or more " " characters.
2494 if (StrLen (CleanOriginal
) == 0) {
2495 SHELL_FREE_NON_NULL(CleanOriginal
);
2496 return (EFI_SUCCESS
);
2499 Status
= ProcessCommandLineToFinal(&CleanOriginal
);
2500 if (EFI_ERROR(Status
)) {
2501 SHELL_FREE_NON_NULL(CleanOriginal
);
2506 // We don't do normal processing with a split command line (output from one command input to another)
2508 if (ContainsSplit(CleanOriginal
)) {
2509 Status
= ProcessNewSplitCommandLine(CleanOriginal
);
2510 SHELL_FREE_NON_NULL(CleanOriginal
);
2515 // We need the first parameter information so we can determine the operation type
2517 FirstParameter
= AllocateZeroPool(StrSize(CleanOriginal
));
2518 if (FirstParameter
== NULL
) {
2519 SHELL_FREE_NON_NULL(CleanOriginal
);
2520 return (EFI_OUT_OF_RESOURCES
);
2522 TempWalker
= CleanOriginal
;
2523 if (!EFI_ERROR(GetNextParameter(&TempWalker
, &FirstParameter
, StrSize(CleanOriginal
)))) {
2525 // Depending on the first parameter we change the behavior
2527 switch (Type
= GetOperationType(FirstParameter
)) {
2528 case File_Sys_Change
:
2529 Status
= ChangeMappedDrive (FirstParameter
);
2531 case Internal_Command
:
2532 case Script_File_Name
:
2533 case Efi_Application
:
2534 Status
= SetupAndRunCommandOrFile(Type
, CleanOriginal
, FirstParameter
, ShellInfoObject
.NewShellParametersProtocol
, CommandStatus
);
2538 // Whatever was typed, it was invalid.
2540 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2541 SetLastError(SHELL_NOT_FOUND
);
2545 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2546 SetLastError(SHELL_NOT_FOUND
);
2549 SHELL_FREE_NON_NULL(CleanOriginal
);
2550 SHELL_FREE_NON_NULL(FirstParameter
);
2556 Function will process and run a command line.
2558 This will determine if the command line represents an internal shell
2559 command or dispatch an external application.
2561 @param[in] CmdLine The command line to parse.
2563 @retval EFI_SUCCESS The command was completed.
2564 @retval EFI_ABORTED The command's operation was aborted.
2569 IN CONST CHAR16
*CmdLine
2572 return (RunShellCommand(CmdLine
, NULL
));
2576 STATIC CONST UINT16 InvalidChars
[] = {L
'*', L
'?', L
'<', L
'>', L
'\\', L
'/', L
'\"', 0x0001, 0x0002};
2578 Function determines if the CommandName COULD be a valid command. It does not determine whether
2579 this is a valid command. It only checks for invalid characters.
2581 @param[in] CommandName The name to check
2583 @retval TRUE CommandName could be a command name
2584 @retval FALSE CommandName could not be a valid command name
2589 IN CONST CHAR16
*CommandName
2593 if (CommandName
== NULL
) {
2598 ; Count
< sizeof(InvalidChars
) / sizeof(InvalidChars
[0])
2601 if (ScanMem16(CommandName
, StrSize(CommandName
), InvalidChars
[Count
]) != NULL
) {
2609 Function to process a NSH script file via SHELL_FILE_HANDLE.
2611 @param[in] Handle The handle to the already opened file.
2612 @param[in] Name The name of the script file.
2614 @retval EFI_SUCCESS the script completed successfully
2618 RunScriptFileHandle (
2619 IN SHELL_FILE_HANDLE Handle
,
2620 IN CONST CHAR16
*Name
2624 SCRIPT_FILE
*NewScriptFile
;
2626 UINTN PrintBuffSize
;
2627 CHAR16
*CommandLine
;
2628 CHAR16
*CommandLine2
;
2629 CHAR16
*CommandLine3
;
2630 SCRIPT_COMMAND_LIST
*LastCommand
;
2632 BOOLEAN PreScriptEchoState
;
2633 BOOLEAN PreCommandEchoState
;
2634 CONST CHAR16
*CurDir
;
2636 CHAR16 LeString
[50];
2638 ASSERT(!ShellCommandGetScriptExit());
2640 PreScriptEchoState
= ShellCommandGetEchoState();
2641 PrintBuffSize
= PcdGet16(PcdShellPrintBufferSize
);
2643 NewScriptFile
= (SCRIPT_FILE
*)AllocateZeroPool(sizeof(SCRIPT_FILE
));
2644 if (NewScriptFile
== NULL
) {
2645 return (EFI_OUT_OF_RESOURCES
);
2651 ASSERT(NewScriptFile
->ScriptName
== NULL
);
2652 NewScriptFile
->ScriptName
= StrnCatGrow(&NewScriptFile
->ScriptName
, NULL
, Name
, 0);
2653 if (NewScriptFile
->ScriptName
== NULL
) {
2654 DeleteScriptFileStruct(NewScriptFile
);
2655 return (EFI_OUT_OF_RESOURCES
);
2659 // Save the parameters (used to replace %0 to %9 later on)
2661 NewScriptFile
->Argc
= ShellInfoObject
.NewShellParametersProtocol
->Argc
;
2662 if (NewScriptFile
->Argc
!= 0) {
2663 NewScriptFile
->Argv
= (CHAR16
**)AllocateZeroPool(NewScriptFile
->Argc
* sizeof(CHAR16
*));
2664 if (NewScriptFile
->Argv
== NULL
) {
2665 DeleteScriptFileStruct(NewScriptFile
);
2666 return (EFI_OUT_OF_RESOURCES
);
2668 for (LoopVar
= 0 ; LoopVar
< 10 && LoopVar
< NewScriptFile
->Argc
; LoopVar
++) {
2669 ASSERT(NewScriptFile
->Argv
[LoopVar
] == NULL
);
2670 NewScriptFile
->Argv
[LoopVar
] = StrnCatGrow(&NewScriptFile
->Argv
[LoopVar
], NULL
, ShellInfoObject
.NewShellParametersProtocol
->Argv
[LoopVar
], 0);
2671 if (NewScriptFile
->Argv
[LoopVar
] == NULL
) {
2672 DeleteScriptFileStruct(NewScriptFile
);
2673 return (EFI_OUT_OF_RESOURCES
);
2677 NewScriptFile
->Argv
= NULL
;
2680 InitializeListHead(&NewScriptFile
->CommandList
);
2681 InitializeListHead(&NewScriptFile
->SubstList
);
2684 // Now build the list of all script commands.
2687 while(!ShellFileHandleEof(Handle
)) {
2688 CommandLine
= ShellFileHandleReturnLine(Handle
, &Ascii
);
2690 if (CommandLine
== NULL
|| StrLen(CommandLine
) == 0 || CommandLine
[0] == '#') {
2691 SHELL_FREE_NON_NULL(CommandLine
);
2694 NewScriptFile
->CurrentCommand
= AllocateZeroPool(sizeof(SCRIPT_COMMAND_LIST
));
2695 if (NewScriptFile
->CurrentCommand
== NULL
) {
2696 SHELL_FREE_NON_NULL(CommandLine
);
2697 DeleteScriptFileStruct(NewScriptFile
);
2698 return (EFI_OUT_OF_RESOURCES
);
2701 NewScriptFile
->CurrentCommand
->Cl
= CommandLine
;
2702 NewScriptFile
->CurrentCommand
->Data
= NULL
;
2703 NewScriptFile
->CurrentCommand
->Line
= LineCount
;
2705 InsertTailList(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
2709 // Add this as the topmost script file
2711 ShellCommandSetNewScript (NewScriptFile
);
2714 // Now enumerate through the commands and run each one.
2716 CommandLine
= AllocateZeroPool(PrintBuffSize
);
2717 if (CommandLine
== NULL
) {
2718 DeleteScriptFileStruct(NewScriptFile
);
2719 return (EFI_OUT_OF_RESOURCES
);
2721 CommandLine2
= AllocateZeroPool(PrintBuffSize
);
2722 if (CommandLine2
== NULL
) {
2723 FreePool(CommandLine
);
2724 DeleteScriptFileStruct(NewScriptFile
);
2725 return (EFI_OUT_OF_RESOURCES
);
2728 for ( NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetFirstNode(&NewScriptFile
->CommandList
)
2729 ; !IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)
2730 ; // conditional increment in the body of the loop
2732 ASSERT(CommandLine2
!= NULL
);
2733 StrnCpyS( CommandLine2
,
2734 PrintBuffSize
/sizeof(CHAR16
),
2735 NewScriptFile
->CurrentCommand
->Cl
,
2736 PrintBuffSize
/sizeof(CHAR16
) - 1
2740 // NULL out comments
2742 for (CommandLine3
= CommandLine2
; CommandLine3
!= NULL
&& *CommandLine3
!= CHAR_NULL
; CommandLine3
++) {
2743 if (*CommandLine3
== L
'^') {
2744 if ( *(CommandLine3
+1) == L
':') {
2745 CopyMem(CommandLine3
, CommandLine3
+1, StrSize(CommandLine3
) - sizeof(CommandLine3
[0]));
2746 } else if (*(CommandLine3
+1) == L
'#') {
2749 } else if (*CommandLine3
== L
'#') {
2750 *CommandLine3
= CHAR_NULL
;
2754 if (CommandLine2
!= NULL
&& StrLen(CommandLine2
) >= 1) {
2756 // Due to variability in starting the find and replace action we need to have both buffers the same.
2758 StrnCpyS( CommandLine
,
2759 PrintBuffSize
/sizeof(CHAR16
),
2761 PrintBuffSize
/sizeof(CHAR16
) - 1
2765 // Remove the %0 to %9 from the command line (if we have some arguments)
2767 if (NewScriptFile
->Argv
!= NULL
) {
2768 switch (NewScriptFile
->Argc
) {
2770 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%9", NewScriptFile
->Argv
[9], FALSE
, TRUE
);
2771 ASSERT_EFI_ERROR(Status
);
2773 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%8", NewScriptFile
->Argv
[8], FALSE
, TRUE
);
2774 ASSERT_EFI_ERROR(Status
);
2776 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%7", NewScriptFile
->Argv
[7], FALSE
, TRUE
);
2777 ASSERT_EFI_ERROR(Status
);
2779 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%6", NewScriptFile
->Argv
[6], FALSE
, TRUE
);
2780 ASSERT_EFI_ERROR(Status
);
2782 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%5", NewScriptFile
->Argv
[5], FALSE
, TRUE
);
2783 ASSERT_EFI_ERROR(Status
);
2785 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%4", NewScriptFile
->Argv
[4], FALSE
, TRUE
);
2786 ASSERT_EFI_ERROR(Status
);
2788 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%3", NewScriptFile
->Argv
[3], FALSE
, TRUE
);
2789 ASSERT_EFI_ERROR(Status
);
2791 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%2", NewScriptFile
->Argv
[2], FALSE
, TRUE
);
2792 ASSERT_EFI_ERROR(Status
);
2794 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%1", NewScriptFile
->Argv
[1], FALSE
, TRUE
);
2795 ASSERT_EFI_ERROR(Status
);
2797 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%0", NewScriptFile
->Argv
[0], FALSE
, TRUE
);
2798 ASSERT_EFI_ERROR(Status
);
2804 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%1", L
"\"\"", FALSE
, FALSE
);
2805 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%2", L
"\"\"", FALSE
, FALSE
);
2806 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%3", L
"\"\"", FALSE
, FALSE
);
2807 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%4", L
"\"\"", FALSE
, FALSE
);
2808 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%5", L
"\"\"", FALSE
, FALSE
);
2809 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%6", L
"\"\"", FALSE
, FALSE
);
2810 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%7", L
"\"\"", FALSE
, FALSE
);
2811 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%8", L
"\"\"", FALSE
, FALSE
);
2812 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%9", L
"\"\"", FALSE
, FALSE
);
2814 StrnCpyS( CommandLine2
,
2815 PrintBuffSize
/sizeof(CHAR16
),
2817 PrintBuffSize
/sizeof(CHAR16
) - 1
2820 LastCommand
= NewScriptFile
->CurrentCommand
;
2822 for (CommandLine3
= CommandLine2
; CommandLine3
[0] == L
' ' ; CommandLine3
++);
2824 if (CommandLine3
!= NULL
&& CommandLine3
[0] == L
':' ) {
2826 // This line is a goto target / label
2829 if (CommandLine3
!= NULL
&& StrLen(CommandLine3
) > 0) {
2830 if (CommandLine3
[0] == L
'@') {
2832 // We need to save the current echo state
2833 // and disable echo for just this command.
2835 PreCommandEchoState
= ShellCommandGetEchoState();
2836 ShellCommandSetEchoState(FALSE
);
2837 Status
= RunCommand(CommandLine3
+1);
2840 // If command was "@echo -off" or "@echo -on" then don't restore echo state
2842 if (StrCmp (L
"@echo -off", CommandLine3
) != 0 &&
2843 StrCmp (L
"@echo -on", CommandLine3
) != 0) {
2845 // Now restore the pre-'@' echo state.
2847 ShellCommandSetEchoState(PreCommandEchoState
);
2850 if (ShellCommandGetEchoState()) {
2851 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
2852 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
2853 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
2855 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
2857 ShellPrintEx(-1, -1, L
"%s\r\n", CommandLine2
);
2859 Status
= RunCommand(CommandLine3
);
2863 if (ShellCommandGetScriptExit()) {
2865 // ShellCommandGetExitCode() always returns a UINT64
2867 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%Lx", ShellCommandGetExitCode());
2868 DEBUG_CODE(InternalEfiShellSetEnv(L
"debuglasterror", LeString
, TRUE
););
2869 InternalEfiShellSetEnv(L
"lasterror", LeString
, TRUE
);
2871 ShellCommandRegisterExit(FALSE
, 0);
2872 Status
= EFI_SUCCESS
;
2875 if (ShellGetExecutionBreakFlag()) {
2878 if (EFI_ERROR(Status
)) {
2881 if (ShellCommandGetExit()) {
2886 // If that commend did not update the CurrentCommand then we need to advance it...
2888 if (LastCommand
== NewScriptFile
->CurrentCommand
) {
2889 NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetNextNode(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
2890 if (!IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)) {
2891 NewScriptFile
->CurrentCommand
->Reset
= TRUE
;
2895 NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetNextNode(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
2896 if (!IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)) {
2897 NewScriptFile
->CurrentCommand
->Reset
= TRUE
;
2903 FreePool(CommandLine
);
2904 FreePool(CommandLine2
);
2905 ShellCommandSetNewScript (NULL
);
2908 // Only if this was the last script reset the state.
2910 if (ShellCommandGetCurrentScriptFile()==NULL
) {
2911 ShellCommandSetEchoState(PreScriptEchoState
);
2913 return (EFI_SUCCESS
);
2917 Function to process a NSH script file.
2919 @param[in] ScriptPath Pointer to the script file name (including file system path).
2920 @param[in] Handle the handle of the script file already opened.
2921 @param[in] CmdLine the command line to run.
2922 @param[in] ParamProtocol the shell parameters protocol pointer
2924 @retval EFI_SUCCESS the script completed successfully
2929 IN CONST CHAR16
*ScriptPath
,
2930 IN SHELL_FILE_HANDLE Handle OPTIONAL
,
2931 IN CONST CHAR16
*CmdLine
,
2932 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
2936 SHELL_FILE_HANDLE FileHandle
;
2940 if (ShellIsFile(ScriptPath
) != EFI_SUCCESS
) {
2941 return (EFI_INVALID_PARAMETER
);
2945 // get the argc and argv updated for scripts
2947 Status
= UpdateArgcArgv(ParamProtocol
, CmdLine
, &Argv
, &Argc
);
2948 if (!EFI_ERROR(Status
)) {
2950 if (Handle
== NULL
) {
2954 Status
= ShellOpenFileByName(ScriptPath
, &FileHandle
, EFI_FILE_MODE_READ
, 0);
2955 if (!EFI_ERROR(Status
)) {
2959 Status
= RunScriptFileHandle(FileHandle
, ScriptPath
);
2962 // now close the file
2964 ShellCloseFile(&FileHandle
);
2967 Status
= RunScriptFileHandle(Handle
, ScriptPath
);
2972 // This is guaranteed to be called after UpdateArgcArgv no matter what else happened.
2973 // This is safe even if the update API failed. In this case, it may be a no-op.
2975 RestoreArgcArgv(ParamProtocol
, &Argv
, &Argc
);
2981 Return the pointer to the first occurrence of any character from a list of characters.
2983 @param[in] String the string to parse
2984 @param[in] CharacterList the list of character to look for
2985 @param[in] EscapeCharacter An escape character to skip
2987 @return the location of the first character in the string
2988 @retval CHAR_NULL no instance of any character in CharacterList was found in String
2993 IN CONST CHAR16
*String
,
2994 IN CONST CHAR16
*CharacterList
,
2995 IN CONST CHAR16 EscapeCharacter
3001 for (WalkStr
= 0; WalkStr
< StrLen(String
); WalkStr
++) {
3002 if (String
[WalkStr
] == EscapeCharacter
) {
3006 for (WalkChar
= 0; WalkChar
< StrLen(CharacterList
); WalkChar
++) {
3007 if (String
[WalkStr
] == CharacterList
[WalkChar
]) {
3008 return (&String
[WalkStr
]);
3012 return (String
+ StrLen(String
));