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
1058 SHELL_FILE_HANDLE FileHandle
;
1059 EFI_DEVICE_PATH_PROTOCOL
*NewPath
;
1060 EFI_DEVICE_PATH_PROTOCOL
*NamePath
;
1061 CHAR16
*FileStringPath
;
1064 CONST CHAR16
*MapName
;
1066 Key
.UnicodeChar
= CHAR_NULL
;
1070 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
&& ShellInfoObject
.ShellInitSettings
.FileName
!= NULL
) {
1072 // launch something else instead
1074 NewSize
= StrSize(ShellInfoObject
.ShellInitSettings
.FileName
);
1075 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
1076 NewSize
+= StrSize(ShellInfoObject
.ShellInitSettings
.FileOptions
) + sizeof(CHAR16
);
1078 FileStringPath
= AllocateZeroPool(NewSize
);
1079 if (FileStringPath
== NULL
) {
1080 return (EFI_OUT_OF_RESOURCES
);
1082 StrCpyS(FileStringPath
, NewSize
/sizeof(CHAR16
), ShellInfoObject
.ShellInitSettings
.FileName
);
1083 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
1084 StrnCatS(FileStringPath
, NewSize
/sizeof(CHAR16
), L
" ", NewSize
/sizeof(CHAR16
) - StrLen(FileStringPath
) -1);
1085 StrnCatS(FileStringPath
, NewSize
/sizeof(CHAR16
), ShellInfoObject
.ShellInitSettings
.FileOptions
, NewSize
/sizeof(CHAR16
) - StrLen(FileStringPath
) -1);
1087 Status
= RunCommand(FileStringPath
);
1088 FreePool(FileStringPath
);
1094 // for shell level 0 we do no scripts
1095 // Without the Startup bit overriding we allow for nostartup to prevent scripts
1097 if ( (PcdGet8(PcdShellSupportLevel
) < 1)
1098 || (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
&& !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
)
1100 return (EFI_SUCCESS
);
1103 gST
->ConOut
->EnableCursor(gST
->ConOut
, FALSE
);
1105 // print out our warning and see if they press a key
1107 for ( Status
= EFI_UNSUPPORTED
, Delay
= ShellInfoObject
.ShellInitSettings
.Delay
1108 ; Delay
!= 0 && EFI_ERROR(Status
)
1111 ShellPrintHiiEx(0, gST
->ConOut
->Mode
->CursorRow
, NULL
, STRING_TOKEN (STR_SHELL_STARTUP_QUESTION
), ShellInfoObject
.HiiHandle
, Delay
);
1112 gBS
->Stall (1000000);
1113 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
1114 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
1117 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CRLF
), ShellInfoObject
.HiiHandle
);
1118 gST
->ConOut
->EnableCursor(gST
->ConOut
, TRUE
);
1123 if (Status
== EFI_SUCCESS
&& Key
.UnicodeChar
== 0 && Key
.ScanCode
== SCAN_ESC
) {
1124 return (EFI_SUCCESS
);
1128 // Try the first location (must be file system)
1130 MapName
= ShellInfoObject
.NewEfiShellProtocol
->GetMapFromDevicePath(&ImagePath
);
1131 if (MapName
!= NULL
) {
1132 FileStringPath
= NULL
;
1134 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, MapName
, 0);
1135 if (FileStringPath
== NULL
) {
1136 Status
= EFI_OUT_OF_RESOURCES
;
1138 TempSpot
= StrStr(FileStringPath
, L
";");
1139 if (TempSpot
!= NULL
) {
1140 *TempSpot
= CHAR_NULL
;
1142 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, ((FILEPATH_DEVICE_PATH
*)FilePath
)->PathName
, 0);
1143 PathRemoveLastItem(FileStringPath
);
1144 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, mStartupScript
, 0);
1145 Status
= ShellInfoObject
.NewEfiShellProtocol
->OpenFileByName(FileStringPath
, &FileHandle
, EFI_FILE_MODE_READ
);
1146 FreePool(FileStringPath
);
1149 if (EFI_ERROR(Status
)) {
1150 NamePath
= FileDevicePath (NULL
, mStartupScript
);
1151 NewPath
= AppendDevicePathNode (ImagePath
, NamePath
);
1157 Status
= InternalOpenFileDevicePath(NewPath
, &FileHandle
, EFI_FILE_MODE_READ
, 0);
1161 // If we got a file, run it
1163 if (!EFI_ERROR(Status
) && FileHandle
!= NULL
) {
1164 Status
= RunScriptFile (mStartupScript
, FileHandle
, L
"", ShellInfoObject
.NewShellParametersProtocol
);
1165 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(FileHandle
);
1167 FileStringPath
= ShellFindFilePath(mStartupScript
);
1168 if (FileStringPath
== NULL
) {
1170 // we return success since we don't need to have a startup script
1172 Status
= EFI_SUCCESS
;
1173 ASSERT(FileHandle
== NULL
);
1175 Status
= RunScriptFile(FileStringPath
, NULL
, L
"", ShellInfoObject
.NewShellParametersProtocol
);
1176 FreePool(FileStringPath
);
1185 Function to perform the shell prompt looping. It will do a single prompt,
1186 dispatch the result, and then return. It is expected that the caller will
1187 call this function in a loop many times.
1190 @retval RETURN_ABORTED
1201 CONST CHAR16
*CurDir
;
1208 // Get screen setting to decide size of the command line buffer
1210 gST
->ConOut
->QueryMode (gST
->ConOut
, gST
->ConOut
->Mode
->Mode
, &Column
, &Row
);
1211 BufferSize
= Column
* Row
* sizeof (CHAR16
);
1212 CmdLine
= AllocateZeroPool (BufferSize
);
1213 if (CmdLine
== NULL
) {
1214 return EFI_OUT_OF_RESOURCES
;
1217 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
1222 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, gST
->ConOut
->Mode
->CursorRow
);
1224 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
1225 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
1227 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
1231 // Read a line from the console
1233 Status
= ShellInfoObject
.NewEfiShellProtocol
->ReadFile(ShellInfoObject
.NewShellParametersProtocol
->StdIn
, &BufferSize
, CmdLine
);
1236 // Null terminate the string and parse it
1238 if (!EFI_ERROR (Status
)) {
1239 CmdLine
[BufferSize
/ sizeof (CHAR16
)] = CHAR_NULL
;
1240 Status
= RunCommand(CmdLine
);
1244 // Done with this command
1251 Add a buffer to the Buffer To Free List for safely returning buffers to other
1252 places without risking letting them modify internal shell information.
1254 @param Buffer Something to pass to FreePool when the shell is exiting.
1258 AddBufferToFreeList(
1262 BUFFER_LIST
*BufferListEntry
;
1264 if (Buffer
== NULL
) {
1268 BufferListEntry
= AllocateZeroPool(sizeof(BUFFER_LIST
));
1269 ASSERT(BufferListEntry
!= NULL
);
1270 BufferListEntry
->Buffer
= Buffer
;
1271 InsertTailList(&ShellInfoObject
.BufferToFreeList
.Link
, &BufferListEntry
->Link
);
1276 Add a buffer to the Line History List
1278 @param Buffer The line buffer to add.
1282 AddLineToCommandHistory(
1283 IN CONST CHAR16
*Buffer
1288 Node
= AllocateZeroPool(sizeof(BUFFER_LIST
));
1289 ASSERT(Node
!= NULL
);
1290 Node
->Buffer
= AllocateCopyPool(StrSize(Buffer
), Buffer
);
1291 ASSERT(Node
->Buffer
!= NULL
);
1293 InsertTailList(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
, &Node
->Link
);
1297 Checks if a string is an alias for another command. If yes, then it replaces the alias name
1298 with the correct command name.
1300 @param[in, out] CommandString Upon entry the potential alias. Upon return the
1301 command name if it was an alias. If it was not
1302 an alias it will be unchanged. This function may
1303 change the buffer to fit the command name.
1305 @retval EFI_SUCCESS The name was changed.
1306 @retval EFI_SUCCESS The name was not an alias.
1307 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
1312 IN OUT CHAR16
**CommandString
1315 CONST CHAR16
*NewString
;
1317 NewString
= ShellInfoObject
.NewEfiShellProtocol
->GetAlias(*CommandString
, NULL
);
1318 if (NewString
== NULL
) {
1319 return (EFI_SUCCESS
);
1321 FreePool(*CommandString
);
1322 *CommandString
= AllocateCopyPool(StrSize(NewString
), NewString
);
1323 if (*CommandString
== NULL
) {
1324 return (EFI_OUT_OF_RESOURCES
);
1326 return (EFI_SUCCESS
);
1330 This function will eliminate unreplaced (and therefore non-found) environment variables.
1332 @param[in,out] CmdLine The command line to update.
1336 StripUnreplacedEnvironmentVariables(
1337 IN OUT CHAR16
*CmdLine
1340 CHAR16
*FirstPercent
;
1342 CHAR16
*SecondPercent
;
1343 CHAR16
*SecondQuote
;
1344 CHAR16
*CurrentLocator
;
1346 for (CurrentLocator
= CmdLine
; CurrentLocator
!= NULL
; ) {
1347 FirstQuote
= FindNextInstance(CurrentLocator
, L
"\"", TRUE
);
1348 FirstPercent
= FindNextInstance(CurrentLocator
, L
"%", TRUE
);
1349 SecondPercent
= FirstPercent
!=NULL
?FindNextInstance(FirstPercent
+1, L
"%", TRUE
):NULL
;
1350 if (FirstPercent
== NULL
|| SecondPercent
== NULL
) {
1352 // If we ever don't have 2 % we are done.
1357 if (FirstQuote
!= NULL
&& FirstQuote
< FirstPercent
) {
1358 SecondQuote
= FindNextInstance(FirstQuote
+1, L
"\"", TRUE
);
1360 // Quote is first found
1363 if (SecondQuote
< FirstPercent
) {
1365 // restart after the pair of "
1367 CurrentLocator
= SecondQuote
+ 1;
1368 } else /* FirstPercent < SecondQuote */{
1370 // Restart on the first percent
1372 CurrentLocator
= FirstPercent
;
1377 if (FirstQuote
== NULL
|| SecondPercent
< FirstQuote
) {
1378 if (IsValidEnvironmentVariableName(FirstPercent
, SecondPercent
)) {
1380 // We need to remove from FirstPercent to SecondPercent
1382 CopyMem(FirstPercent
, SecondPercent
+ 1, StrSize(SecondPercent
+ 1));
1384 // don't need to update the locator. both % characters are gone.
1387 CurrentLocator
= SecondPercent
+ 1;
1391 CurrentLocator
= FirstQuote
;
1393 return (EFI_SUCCESS
);
1397 Function allocates a new command line and replaces all instances of environment
1398 variable names that are correctly preset to their values.
1400 If the return value is not NULL the memory must be caller freed.
1402 @param[in] OriginalCommandLine The original command line
1404 @retval NULL An error occurred.
1405 @return The new command line with no environment variables present.
1409 ShellConvertVariables (
1410 IN CONST CHAR16
*OriginalCommandLine
1413 CONST CHAR16
*MasterEnvList
;
1415 CHAR16
*NewCommandLine1
;
1416 CHAR16
*NewCommandLine2
;
1420 SCRIPT_FILE
*CurrentScriptFile
;
1421 ALIAS_LIST
*AliasListNode
;
1423 ASSERT(OriginalCommandLine
!= NULL
);
1426 NewSize
= StrSize(OriginalCommandLine
);
1427 CurrentScriptFile
= ShellCommandGetCurrentScriptFile();
1430 ///@todo update this to handle the %0 - %9 for scripting only (borrow from line 1256 area) ? ? ?
1433 // calculate the size required for the post-conversion string...
1435 if (CurrentScriptFile
!= NULL
) {
1436 for (AliasListNode
= (ALIAS_LIST
*)GetFirstNode(&CurrentScriptFile
->SubstList
)
1437 ; !IsNull(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1438 ; AliasListNode
= (ALIAS_LIST
*)GetNextNode(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1440 for (Temp
= StrStr(OriginalCommandLine
, AliasListNode
->Alias
)
1442 ; Temp
= StrStr(Temp
+1, AliasListNode
->Alias
)
1445 // we need a preceding and if there is space no ^ preceding (if no space ignore)
1447 if ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2)) {
1448 NewSize
+= StrSize(AliasListNode
->CommandString
);
1454 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1455 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
//&& *(MasterEnvList+1) != CHAR_NULL
1456 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1458 if (StrSize(MasterEnvList
) > ItemSize
) {
1459 ItemSize
= StrSize(MasterEnvList
);
1461 for (Temp
= StrStr(OriginalCommandLine
, MasterEnvList
)
1463 ; Temp
= StrStr(Temp
+1, MasterEnvList
)
1466 // we need a preceding and following % and if there is space no ^ preceding (if no space ignore)
1468 if (*(Temp
-1) == L
'%' && *(Temp
+StrLen(MasterEnvList
)) == L
'%' &&
1469 ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2))) {
1470 NewSize
+=StrSize(EfiShellGetEnv(MasterEnvList
));
1476 // now do the replacements...
1478 NewCommandLine1
= AllocateCopyPool(NewSize
, OriginalCommandLine
);
1479 NewCommandLine2
= AllocateZeroPool(NewSize
);
1480 ItemTemp
= AllocateZeroPool(ItemSize
+(2*sizeof(CHAR16
)));
1481 if (NewCommandLine1
== NULL
|| NewCommandLine2
== NULL
|| ItemTemp
== NULL
) {
1482 SHELL_FREE_NON_NULL(NewCommandLine1
);
1483 SHELL_FREE_NON_NULL(NewCommandLine2
);
1484 SHELL_FREE_NON_NULL(ItemTemp
);
1487 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1488 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
1489 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1492 ((ItemSize
+(2*sizeof(CHAR16
)))/sizeof(CHAR16
)),
1496 ((ItemSize
+(2*sizeof(CHAR16
)))/sizeof(CHAR16
)),
1500 ((ItemSize
+(2*sizeof(CHAR16
)))/sizeof(CHAR16
)),
1503 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, ItemTemp
, EfiShellGetEnv(MasterEnvList
), TRUE
, FALSE
);
1504 StrCpyS(NewCommandLine1
, NewSize
/sizeof(CHAR16
), NewCommandLine2
);
1506 if (CurrentScriptFile
!= NULL
) {
1507 for (AliasListNode
= (ALIAS_LIST
*)GetFirstNode(&CurrentScriptFile
->SubstList
)
1508 ; !IsNull(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1509 ; AliasListNode
= (ALIAS_LIST
*)GetNextNode(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1511 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, AliasListNode
->Alias
, AliasListNode
->CommandString
, TRUE
, FALSE
);
1512 StrCpyS(NewCommandLine1
, NewSize
/sizeof(CHAR16
), NewCommandLine2
);
1517 // Remove non-existent environment variables
1519 StripUnreplacedEnvironmentVariables(NewCommandLine1
);
1522 // Now cleanup any straggler intentionally ignored "%" characters
1524 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, L
"^%", L
"%", TRUE
, FALSE
);
1525 StrCpyS(NewCommandLine1
, NewSize
/sizeof(CHAR16
), NewCommandLine2
);
1527 FreePool(NewCommandLine2
);
1530 return (NewCommandLine1
);
1534 Internal function to run a command line with pipe usage.
1536 @param[in] CmdLine The pointer to the command line.
1537 @param[in] StdIn The pointer to the Standard input.
1538 @param[in] StdOut The pointer to the Standard output.
1540 @retval EFI_SUCCESS The split command is executed successfully.
1541 @retval other Some error occurs when executing the split command.
1546 IN CONST CHAR16
*CmdLine
,
1547 IN SHELL_FILE_HANDLE
*StdIn
,
1548 IN SHELL_FILE_HANDLE
*StdOut
1552 CHAR16
*NextCommandLine
;
1553 CHAR16
*OurCommandLine
;
1557 SHELL_FILE_HANDLE
*TempFileHandle
;
1560 ASSERT(StdOut
== NULL
);
1562 ASSERT(StrStr(CmdLine
, L
"|") != NULL
);
1564 Status
= EFI_SUCCESS
;
1565 NextCommandLine
= NULL
;
1566 OurCommandLine
= NULL
;
1570 NextCommandLine
= StrnCatGrow(&NextCommandLine
, &Size1
, StrStr(CmdLine
, L
"|")+1, 0);
1571 OurCommandLine
= StrnCatGrow(&OurCommandLine
, &Size2
, CmdLine
, StrStr(CmdLine
, L
"|") - CmdLine
);
1573 if (NextCommandLine
== NULL
|| OurCommandLine
== NULL
) {
1574 SHELL_FREE_NON_NULL(OurCommandLine
);
1575 SHELL_FREE_NON_NULL(NextCommandLine
);
1576 return (EFI_OUT_OF_RESOURCES
);
1577 } else if (StrStr(OurCommandLine
, L
"|") != NULL
|| Size1
== 0 || Size2
== 0) {
1578 SHELL_FREE_NON_NULL(OurCommandLine
);
1579 SHELL_FREE_NON_NULL(NextCommandLine
);
1580 return (EFI_INVALID_PARAMETER
);
1581 } else if (NextCommandLine
[0] == L
'a' &&
1582 (NextCommandLine
[1] == L
' ' || NextCommandLine
[1] == CHAR_NULL
)
1584 CopyMem(NextCommandLine
, NextCommandLine
+1, StrSize(NextCommandLine
) - sizeof(NextCommandLine
[0]));
1585 while (NextCommandLine
[0] == L
' ') {
1586 CopyMem(NextCommandLine
, NextCommandLine
+1, StrSize(NextCommandLine
) - sizeof(NextCommandLine
[0]));
1588 if (NextCommandLine
[0] == CHAR_NULL
) {
1589 SHELL_FREE_NON_NULL(OurCommandLine
);
1590 SHELL_FREE_NON_NULL(NextCommandLine
);
1591 return (EFI_INVALID_PARAMETER
);
1600 // make a SPLIT_LIST item and add to list
1602 Split
= AllocateZeroPool(sizeof(SPLIT_LIST
));
1603 ASSERT(Split
!= NULL
);
1604 Split
->SplitStdIn
= StdIn
;
1605 Split
->SplitStdOut
= ConvertEfiFileProtocolToShellHandle(CreateFileInterfaceMem(Unicode
), NULL
);
1606 ASSERT(Split
->SplitStdOut
!= NULL
);
1607 InsertHeadList(&ShellInfoObject
.SplitList
.Link
, &Split
->Link
);
1609 Status
= RunCommand(OurCommandLine
);
1612 // move the output from the first to the in to the second.
1614 TempFileHandle
= Split
->SplitStdOut
;
1615 if (Split
->SplitStdIn
== StdIn
) {
1616 Split
->SplitStdOut
= NULL
;
1618 Split
->SplitStdOut
= Split
->SplitStdIn
;
1620 Split
->SplitStdIn
= TempFileHandle
;
1621 ShellInfoObject
.NewEfiShellProtocol
->SetFilePosition(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdIn
), 0);
1623 if (!EFI_ERROR(Status
)) {
1624 Status
= RunCommand(NextCommandLine
);
1628 // remove the top level from the ScriptList
1630 ASSERT((SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
) == Split
);
1631 RemoveEntryList(&Split
->Link
);
1634 // Note that the original StdIn is now the StdOut...
1636 if (Split
->SplitStdOut
!= NULL
&& Split
->SplitStdOut
!= StdIn
) {
1637 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdOut
));
1639 if (Split
->SplitStdIn
!= NULL
) {
1640 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdIn
));
1644 FreePool(NextCommandLine
);
1645 FreePool(OurCommandLine
);
1651 Take the original command line, substitute any variables, free
1652 the original string, return the modified copy.
1654 @param[in] CmdLine pointer to the command line to update.
1656 @retval EFI_SUCCESS the function was successful.
1657 @retval EFI_OUT_OF_RESOURCES a memory allocation failed.
1661 ShellSubstituteVariables(
1666 NewCmdLine
= ShellConvertVariables(*CmdLine
);
1667 SHELL_FREE_NON_NULL(*CmdLine
);
1668 if (NewCmdLine
== NULL
) {
1669 return (EFI_OUT_OF_RESOURCES
);
1671 *CmdLine
= NewCmdLine
;
1672 return (EFI_SUCCESS
);
1676 Take the original command line, substitute any alias in the first group of space delimited characters, free
1677 the original string, return the modified copy.
1679 @param[in] CmdLine pointer to the command line to update.
1681 @retval EFI_SUCCESS the function was successful.
1682 @retval EFI_OUT_OF_RESOURCES a memory allocation failed.
1686 ShellSubstituteAliases(
1691 CHAR16
*CommandName
;
1693 UINTN PostAliasSize
;
1694 ASSERT(CmdLine
!= NULL
);
1695 ASSERT(*CmdLine
!= NULL
);
1699 if (StrStr((*CmdLine
), L
" ") == NULL
){
1700 StrnCatGrow(&CommandName
, NULL
, (*CmdLine
), 0);
1702 StrnCatGrow(&CommandName
, NULL
, (*CmdLine
), StrStr((*CmdLine
), L
" ") - (*CmdLine
));
1706 // This cannot happen 'inline' since the CmdLine can need extra space.
1709 if (!ShellCommandIsCommandOnList(CommandName
)) {
1711 // Convert via alias
1713 Status
= ShellConvertAlias(&CommandName
);
1714 if (EFI_ERROR(Status
)){
1718 NewCmdLine
= StrnCatGrow(&NewCmdLine
, &PostAliasSize
, CommandName
, 0);
1719 if (NewCmdLine
== NULL
) {
1720 SHELL_FREE_NON_NULL(CommandName
);
1721 SHELL_FREE_NON_NULL(*CmdLine
);
1722 return (EFI_OUT_OF_RESOURCES
);
1724 NewCmdLine
= StrnCatGrow(&NewCmdLine
, &PostAliasSize
, StrStr((*CmdLine
), L
" "), 0);
1725 if (NewCmdLine
== NULL
) {
1726 SHELL_FREE_NON_NULL(CommandName
);
1727 SHELL_FREE_NON_NULL(*CmdLine
);
1728 return (EFI_OUT_OF_RESOURCES
);
1731 NewCmdLine
= StrnCatGrow(&NewCmdLine
, NULL
, (*CmdLine
), 0);
1734 SHELL_FREE_NON_NULL(*CmdLine
);
1735 SHELL_FREE_NON_NULL(CommandName
);
1738 // re-assign the passed in double pointer to point to our newly allocated buffer
1740 *CmdLine
= NewCmdLine
;
1742 return (EFI_SUCCESS
);
1746 Takes the Argv[0] part of the command line and determine the meaning of it.
1748 @param[in] CmdName pointer to the command line to update.
1750 @retval Internal_Command The name is an internal command.
1751 @retval File_Sys_Change the name is a file system change.
1752 @retval Script_File_Name the name is a NSH script file.
1753 @retval Unknown_Invalid the name is unknown.
1754 @retval Efi_Application the name is an application (.EFI).
1756 SHELL_OPERATION_TYPES
1759 IN CONST CHAR16
*CmdName
1762 CHAR16
* FileWithPath
;
1763 CONST CHAR16
* TempLocation
;
1764 CONST CHAR16
* TempLocation2
;
1766 FileWithPath
= NULL
;
1768 // test for an internal command.
1770 if (ShellCommandIsCommandOnList(CmdName
)) {
1771 return (Internal_Command
);
1775 // Test for file system change request. anything ending with first : and cant have spaces.
1777 if (CmdName
[(StrLen(CmdName
)-1)] == L
':') {
1778 if ( StrStr(CmdName
, L
" ") != NULL
1779 || StrLen(StrStr(CmdName
, L
":")) > 1
1781 return (Unknown_Invalid
);
1783 return (File_Sys_Change
);
1789 if ((FileWithPath
= ShellFindFilePathEx(CmdName
, mExecutableExtensions
)) != NULL
) {
1791 // See if that file has a script file extension
1793 if (StrLen(FileWithPath
) > 4) {
1794 TempLocation
= FileWithPath
+StrLen(FileWithPath
)-4;
1795 TempLocation2
= mScriptExtension
;
1796 if (StringNoCaseCompare((VOID
*)(&TempLocation
), (VOID
*)(&TempLocation2
)) == 0) {
1797 SHELL_FREE_NON_NULL(FileWithPath
);
1798 return (Script_File_Name
);
1803 // Was a file, but not a script. we treat this as an application.
1805 SHELL_FREE_NON_NULL(FileWithPath
);
1806 return (Efi_Application
);
1809 SHELL_FREE_NON_NULL(FileWithPath
);
1811 // No clue what this is... return invalid flag...
1813 return (Unknown_Invalid
);
1817 Determine if the first item in a command line is valid.
1819 @param[in] CmdLine The command line to parse.
1821 @retval EFI_SUCCESS The item is valid.
1822 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
1823 @retval EFI_NOT_FOUND The operation type is unknown or invalid.
1828 IN CONST CHAR16
*CmdLine
1832 CHAR16
*FirstParameter
;
1838 Temp
= StrnCatGrow(&Temp
, NULL
, CmdLine
, 0);
1840 return (EFI_OUT_OF_RESOURCES
);
1843 FirstParameter
= StrStr(Temp
, L
"|");
1844 if (FirstParameter
!= NULL
) {
1845 *FirstParameter
= CHAR_NULL
;
1848 FirstParameter
= NULL
;
1851 // Process the command line
1853 Status
= ProcessCommandLineToFinal(&Temp
);
1855 if (!EFI_ERROR(Status
)) {
1856 FirstParameter
= AllocateZeroPool(StrSize(CmdLine
));
1857 if (FirstParameter
== NULL
) {
1858 SHELL_FREE_NON_NULL(Temp
);
1859 return (EFI_OUT_OF_RESOURCES
);
1861 TempWalker
= (CHAR16
*)Temp
;
1862 if (!EFI_ERROR(GetNextParameter(&TempWalker
, &FirstParameter
, StrSize(CmdLine
)))) {
1863 if (GetOperationType(FirstParameter
) == Unknown_Invalid
) {
1864 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
1865 SetLastError(SHELL_NOT_FOUND
);
1866 Status
= EFI_NOT_FOUND
;
1871 SHELL_FREE_NON_NULL(Temp
);
1872 SHELL_FREE_NON_NULL(FirstParameter
);
1877 Determine if a command line contains with a split contains only valid commands.
1879 @param[in] CmdLine The command line to parse.
1881 @retval EFI_SUCCESS CmdLine has only valid commands, application, or has no split.
1882 @retval EFI_ABORTED CmdLine has at least one invalid command or application.
1887 IN CONST CHAR16
*CmdLine
1890 CONST CHAR16
*TempSpot
;
1894 // If this was the only item, then get out
1896 if (!ContainsSplit(CmdLine
)) {
1897 return (EFI_SUCCESS
);
1901 // Verify up to the pipe or end character
1903 Status
= IsValidSplit(CmdLine
);
1904 if (EFI_ERROR(Status
)) {
1909 // recurse to verify the next item
1911 TempSpot
= FindFirstCharacter(CmdLine
, L
"|", L
'^') + 1;
1912 if (*TempSpot
== L
'a' &&
1913 (*(TempSpot
+ 1) == L
' ' || *(TempSpot
+ 1) == CHAR_NULL
)
1915 // If it's an ASCII pipe '|a'
1919 return (VerifySplit(TempSpot
));
1923 Process a split based operation.
1925 @param[in] CmdLine pointer to the command line to process
1927 @retval EFI_SUCCESS The operation was successful
1928 @return an error occurred.
1932 ProcessNewSplitCommandLine(
1933 IN CONST CHAR16
*CmdLine
1939 Status
= VerifySplit(CmdLine
);
1940 if (EFI_ERROR(Status
)) {
1947 // are we in an existing split???
1949 if (!IsListEmpty(&ShellInfoObject
.SplitList
.Link
)) {
1950 Split
= (SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
);
1953 if (Split
== NULL
) {
1954 Status
= RunSplitCommand(CmdLine
, NULL
, NULL
);
1956 Status
= RunSplitCommand(CmdLine
, Split
->SplitStdIn
, Split
->SplitStdOut
);
1958 if (EFI_ERROR(Status
)) {
1959 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_SPLIT
), ShellInfoObject
.HiiHandle
, CmdLine
);
1965 Handle a request to change the current file system.
1967 @param[in] CmdLine The passed in command line.
1969 @retval EFI_SUCCESS The operation was successful.
1974 IN CONST CHAR16
*CmdLine
1978 Status
= EFI_SUCCESS
;
1981 // make sure we are the right operation
1983 ASSERT(CmdLine
[(StrLen(CmdLine
)-1)] == L
':' && StrStr(CmdLine
, L
" ") == NULL
);
1986 // Call the protocol API to do the work
1988 Status
= ShellInfoObject
.NewEfiShellProtocol
->SetCurDir(NULL
, CmdLine
);
1991 // Report any errors
1993 if (EFI_ERROR(Status
)) {
1994 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_MAPPING
), ShellInfoObject
.HiiHandle
, CmdLine
);
2001 Reprocess the command line to direct all -? to the help command.
2003 if found, will add "help" as argv[0], and move the rest later.
2005 @param[in,out] CmdLine pointer to the command line to update
2010 IN OUT CHAR16
**CmdLine
2013 CHAR16
*CurrentParameter
;
2015 CHAR16
*NewCommandLine
;
2017 UINTN NewCmdLineSize
;
2019 Status
= EFI_SUCCESS
;
2021 CurrentParameter
= AllocateZeroPool(StrSize(*CmdLine
));
2022 if (CurrentParameter
== NULL
) {
2023 return (EFI_OUT_OF_RESOURCES
);
2027 while(Walker
!= NULL
&& *Walker
!= CHAR_NULL
) {
2028 if (!EFI_ERROR(GetNextParameter(&Walker
, &CurrentParameter
, StrSize(*CmdLine
)))) {
2029 if (StrStr(CurrentParameter
, L
"-?") == CurrentParameter
) {
2030 CurrentParameter
[0] = L
' ';
2031 CurrentParameter
[1] = L
' ';
2032 NewCmdLineSize
= StrSize(L
"help ") + StrSize(*CmdLine
);
2033 NewCommandLine
= AllocateZeroPool(NewCmdLineSize
);
2034 if (NewCommandLine
== NULL
) {
2035 Status
= EFI_OUT_OF_RESOURCES
;
2040 // We know the space is sufficient since we just calculated it.
2042 StrnCpyS(NewCommandLine
, NewCmdLineSize
/sizeof(CHAR16
), L
"help ", 5);
2043 StrnCatS(NewCommandLine
, NewCmdLineSize
/sizeof(CHAR16
), *CmdLine
, StrLen(*CmdLine
));
2044 SHELL_FREE_NON_NULL(*CmdLine
);
2045 *CmdLine
= NewCommandLine
;
2051 SHELL_FREE_NON_NULL(CurrentParameter
);
2057 Function to update the shell variable "lasterror".
2059 @param[in] ErrorCode the error code to put into lasterror.
2064 IN CONST SHELL_STATUS ErrorCode
2067 CHAR16 LeString
[19];
2068 if (sizeof(EFI_STATUS
) == sizeof(UINT64
)) {
2069 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%Lx", ErrorCode
);
2071 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%x", ErrorCode
);
2073 DEBUG_CODE(InternalEfiShellSetEnv(L
"debuglasterror", LeString
, TRUE
););
2074 InternalEfiShellSetEnv(L
"lasterror", LeString
, TRUE
);
2076 return (EFI_SUCCESS
);
2080 Converts the command line to it's post-processed form. this replaces variables and alias' per UEFI Shell spec.
2082 @param[in,out] CmdLine pointer to the command line to update
2084 @retval EFI_SUCCESS The operation was successful
2085 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
2086 @return some other error occurred
2090 ProcessCommandLineToFinal(
2091 IN OUT CHAR16
**CmdLine
2095 TrimSpaces(CmdLine
);
2097 Status
= ShellSubstituteAliases(CmdLine
);
2098 if (EFI_ERROR(Status
)) {
2102 TrimSpaces(CmdLine
);
2104 Status
= ShellSubstituteVariables(CmdLine
);
2105 if (EFI_ERROR(Status
)) {
2108 ASSERT (*CmdLine
!= NULL
);
2110 TrimSpaces(CmdLine
);
2113 // update for help parsing
2115 if (StrStr(*CmdLine
, L
"?") != NULL
) {
2117 // This may do nothing if the ? does not indicate help.
2118 // Save all the details for in the API below.
2120 Status
= DoHelpUpdate(CmdLine
);
2123 TrimSpaces(CmdLine
);
2125 return (EFI_SUCCESS
);
2129 Run an internal shell command.
2131 This API will update the shell's environment since these commands are libraries.
2133 @param[in] CmdLine the command line to run.
2134 @param[in] FirstParameter the first parameter on the command line
2135 @param[in] ParamProtocol the shell parameters protocol pointer
2137 @retval EFI_SUCCESS The command was completed.
2138 @retval EFI_ABORTED The command's operation was aborted.
2143 IN CONST CHAR16
*CmdLine
,
2144 IN CHAR16
*FirstParameter
,
2145 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
2151 SHELL_STATUS CommandReturnedStatus
;
2156 NewCmdLine
= AllocateCopyPool (StrSize (CmdLine
), CmdLine
);
2157 if (NewCmdLine
== NULL
) {
2158 return EFI_OUT_OF_RESOURCES
;
2161 for (Walker
= NewCmdLine
; Walker
!= NULL
&& *Walker
!= CHAR_NULL
; Walker
++) {
2162 if (*Walker
== L
'^' && *(Walker
+1) == L
'#') {
2163 CopyMem(Walker
, Walker
+1, StrSize(Walker
) - sizeof(Walker
[0]));
2168 // get the argc and argv updated for internal commands
2170 Status
= UpdateArgcArgv(ParamProtocol
, NewCmdLine
, &Argv
, &Argc
);
2171 if (!EFI_ERROR(Status
)) {
2173 // Run the internal command.
2175 Status
= ShellCommandRunCommandHandler(FirstParameter
, &CommandReturnedStatus
, &LastError
);
2177 if (!EFI_ERROR(Status
)) {
2179 // Update last error status.
2180 // some commands do not update last error.
2183 SetLastError(CommandReturnedStatus
);
2187 // Pass thru the exitcode from the app.
2189 if (ShellCommandGetExit()) {
2191 // An Exit was requested ("exit" command), pass its value up.
2193 Status
= CommandReturnedStatus
;
2194 } else if (CommandReturnedStatus
!= SHELL_SUCCESS
&& IsScriptOnlyCommand(FirstParameter
)) {
2196 // Always abort when a script only command fails for any reason
2198 Status
= EFI_ABORTED
;
2199 } else if (ShellCommandGetCurrentScriptFile() != NULL
&& CommandReturnedStatus
== SHELL_ABORTED
) {
2201 // Abort when in a script and a command aborted
2203 Status
= EFI_ABORTED
;
2209 // This is guaranteed to be called after UpdateArgcArgv no matter what else happened.
2210 // This is safe even if the update API failed. In this case, it may be a no-op.
2212 RestoreArgcArgv(ParamProtocol
, &Argv
, &Argc
);
2215 // If a script is running and the command is not a script only command, then
2216 // change return value to success so the script won't halt (unless aborted).
2218 // Script only commands have to be able halt the script since the script will
2219 // not operate if they are failing.
2221 if ( ShellCommandGetCurrentScriptFile() != NULL
2222 && !IsScriptOnlyCommand(FirstParameter
)
2223 && Status
!= EFI_ABORTED
2225 Status
= EFI_SUCCESS
;
2228 FreePool (NewCmdLine
);
2233 Function to run the command or file.
2235 @param[in] Type the type of operation being run.
2236 @param[in] CmdLine the command line to run.
2237 @param[in] FirstParameter the first parameter on the command line
2238 @param[in] ParamProtocol the shell parameters protocol pointer
2240 @retval EFI_SUCCESS The command was completed.
2241 @retval EFI_ABORTED The command's operation was aborted.
2246 IN SHELL_OPERATION_TYPES Type
,
2247 IN CONST CHAR16
*CmdLine
,
2248 IN CHAR16
*FirstParameter
,
2249 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
2253 EFI_STATUS StartStatus
;
2254 CHAR16
*CommandWithPath
;
2255 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
2256 SHELL_STATUS CalleeExitStatus
;
2258 Status
= EFI_SUCCESS
;
2259 CommandWithPath
= NULL
;
2261 CalleeExitStatus
= SHELL_INVALID_PARAMETER
;
2264 case Internal_Command
:
2265 Status
= RunInternalCommand(CmdLine
, FirstParameter
, ParamProtocol
);
2267 case Script_File_Name
:
2268 case Efi_Application
:
2270 // Process a fully qualified path
2272 if (StrStr(FirstParameter
, L
":") != NULL
) {
2273 ASSERT (CommandWithPath
== NULL
);
2274 if (ShellIsFile(FirstParameter
) == EFI_SUCCESS
) {
2275 CommandWithPath
= StrnCatGrow(&CommandWithPath
, NULL
, FirstParameter
, 0);
2280 // Process a relative path and also check in the path environment variable
2282 if (CommandWithPath
== NULL
) {
2283 CommandWithPath
= ShellFindFilePathEx(FirstParameter
, mExecutableExtensions
);
2287 // This should be impossible now.
2289 ASSERT(CommandWithPath
!= NULL
);
2292 // Make sure that path is not just a directory (or not found)
2294 if (!EFI_ERROR(ShellIsDirectory(CommandWithPath
))) {
2295 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2296 SetLastError(SHELL_NOT_FOUND
);
2299 case Script_File_Name
:
2300 Status
= RunScriptFile (CommandWithPath
, NULL
, CmdLine
, ParamProtocol
);
2302 case Efi_Application
:
2304 // Get the device path of the application image
2306 DevPath
= ShellInfoObject
.NewEfiShellProtocol
->GetDevicePathFromFilePath(CommandWithPath
);
2307 if (DevPath
== NULL
){
2308 Status
= EFI_OUT_OF_RESOURCES
;
2313 // Execute the device path
2315 Status
= InternalShellExecuteDevicePath(
2323 SHELL_FREE_NON_NULL(DevPath
);
2325 if(EFI_ERROR (Status
)) {
2326 CalleeExitStatus
= (SHELL_STATUS
) (Status
& (~MAX_BIT
));
2328 CalleeExitStatus
= (SHELL_STATUS
) StartStatus
;
2332 // Update last error status.
2334 // Status is an EFI_STATUS. Clear top bit to convert to SHELL_STATUS
2335 SetLastError(CalleeExitStatus
);
2351 SHELL_FREE_NON_NULL(CommandWithPath
);
2357 Function to setup StdIn, StdErr, StdOut, and then run the command or file.
2359 @param[in] Type the type of operation being run.
2360 @param[in] CmdLine the command line to run.
2361 @param[in] FirstParameter the first parameter on the command line.
2362 @param[in] ParamProtocol the shell parameters protocol pointer
2364 @retval EFI_SUCCESS The command was completed.
2365 @retval EFI_ABORTED The command's operation was aborted.
2369 SetupAndRunCommandOrFile(
2370 IN SHELL_OPERATION_TYPES Type
,
2372 IN CHAR16
*FirstParameter
,
2373 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
2377 SHELL_FILE_HANDLE OriginalStdIn
;
2378 SHELL_FILE_HANDLE OriginalStdOut
;
2379 SHELL_FILE_HANDLE OriginalStdErr
;
2380 SYSTEM_TABLE_INFO OriginalSystemTableInfo
;
2383 // Update the StdIn, StdOut, and StdErr for redirection to environment variables, files, etc... unicode and ASCII
2385 Status
= UpdateStdInStdOutStdErr(ParamProtocol
, CmdLine
, &OriginalStdIn
, &OriginalStdOut
, &OriginalStdErr
, &OriginalSystemTableInfo
);
2388 // The StdIn, StdOut, and StdErr are set up.
2389 // Now run the command, script, or application
2391 if (!EFI_ERROR(Status
)) {
2392 TrimSpaces(&CmdLine
);
2393 Status
= RunCommandOrFile(Type
, CmdLine
, FirstParameter
, ParamProtocol
);
2399 if (EFI_ERROR(Status
)) {
2400 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_ERROR
), ShellInfoObject
.HiiHandle
, (VOID
*)(Status
));
2404 // put back the original StdIn, StdOut, and StdErr
2406 RestoreStdInStdOutStdErr(ParamProtocol
, &OriginalStdIn
, &OriginalStdOut
, &OriginalStdErr
, &OriginalSystemTableInfo
);
2412 Function will process and run a command line.
2414 This will determine if the command line represents an internal shell
2415 command or dispatch an external application.
2417 @param[in] CmdLine The command line to parse.
2419 @retval EFI_SUCCESS The command was completed.
2420 @retval EFI_ABORTED The command's operation was aborted.
2425 IN CONST CHAR16
*CmdLine
2429 CHAR16
*CleanOriginal
;
2430 CHAR16
*FirstParameter
;
2432 SHELL_OPERATION_TYPES Type
;
2434 ASSERT(CmdLine
!= NULL
);
2435 if (StrLen(CmdLine
) == 0) {
2436 return (EFI_SUCCESS
);
2439 Status
= EFI_SUCCESS
;
2440 CleanOriginal
= NULL
;
2442 CleanOriginal
= StrnCatGrow(&CleanOriginal
, NULL
, CmdLine
, 0);
2443 if (CleanOriginal
== NULL
) {
2444 return (EFI_OUT_OF_RESOURCES
);
2447 TrimSpaces(&CleanOriginal
);
2450 // NULL out comments (leveraged from RunScriptFileHandle() ).
2451 // The # character on a line is used to denote that all characters on the same line
2452 // and to the right of the # are to be ignored by the shell.
2453 // Afterwards, again remove spaces, in case any were between the last command-parameter and '#'.
2455 for (TempWalker
= CleanOriginal
; TempWalker
!= NULL
&& *TempWalker
!= CHAR_NULL
; TempWalker
++) {
2456 if (*TempWalker
== L
'^') {
2457 if (*(TempWalker
+ 1) == L
'#') {
2460 } else if (*TempWalker
== L
'#') {
2461 *TempWalker
= CHAR_NULL
;
2465 TrimSpaces(&CleanOriginal
);
2468 // Handle case that passed in command line is just 1 or more " " characters.
2470 if (StrLen (CleanOriginal
) == 0) {
2471 SHELL_FREE_NON_NULL(CleanOriginal
);
2472 return (EFI_SUCCESS
);
2475 Status
= ProcessCommandLineToFinal(&CleanOriginal
);
2476 if (EFI_ERROR(Status
)) {
2477 SHELL_FREE_NON_NULL(CleanOriginal
);
2482 // We don't do normal processing with a split command line (output from one command input to another)
2484 if (ContainsSplit(CleanOriginal
)) {
2485 Status
= ProcessNewSplitCommandLine(CleanOriginal
);
2486 SHELL_FREE_NON_NULL(CleanOriginal
);
2491 // We need the first parameter information so we can determine the operation type
2493 FirstParameter
= AllocateZeroPool(StrSize(CleanOriginal
));
2494 if (FirstParameter
== NULL
) {
2495 SHELL_FREE_NON_NULL(CleanOriginal
);
2496 return (EFI_OUT_OF_RESOURCES
);
2498 TempWalker
= CleanOriginal
;
2499 if (!EFI_ERROR(GetNextParameter(&TempWalker
, &FirstParameter
, StrSize(CleanOriginal
)))) {
2501 // Depending on the first parameter we change the behavior
2503 switch (Type
= GetOperationType(FirstParameter
)) {
2504 case File_Sys_Change
:
2505 Status
= ChangeMappedDrive (FirstParameter
);
2507 case Internal_Command
:
2508 case Script_File_Name
:
2509 case Efi_Application
:
2510 Status
= SetupAndRunCommandOrFile(Type
, CleanOriginal
, FirstParameter
, ShellInfoObject
.NewShellParametersProtocol
);
2514 // Whatever was typed, it was invalid.
2516 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2517 SetLastError(SHELL_NOT_FOUND
);
2521 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2522 SetLastError(SHELL_NOT_FOUND
);
2525 SHELL_FREE_NON_NULL(CleanOriginal
);
2526 SHELL_FREE_NON_NULL(FirstParameter
);
2531 STATIC CONST UINT16 InvalidChars
[] = {L
'*', L
'?', L
'<', L
'>', L
'\\', L
'/', L
'\"', 0x0001, 0x0002};
2533 Function determines if the CommandName COULD be a valid command. It does not determine whether
2534 this is a valid command. It only checks for invalid characters.
2536 @param[in] CommandName The name to check
2538 @retval TRUE CommandName could be a command name
2539 @retval FALSE CommandName could not be a valid command name
2544 IN CONST CHAR16
*CommandName
2548 if (CommandName
== NULL
) {
2553 ; Count
< sizeof(InvalidChars
) / sizeof(InvalidChars
[0])
2556 if (ScanMem16(CommandName
, StrSize(CommandName
), InvalidChars
[Count
]) != NULL
) {
2564 Function to process a NSH script file via SHELL_FILE_HANDLE.
2566 @param[in] Handle The handle to the already opened file.
2567 @param[in] Name The name of the script file.
2569 @retval EFI_SUCCESS the script completed successfully
2573 RunScriptFileHandle (
2574 IN SHELL_FILE_HANDLE Handle
,
2575 IN CONST CHAR16
*Name
2579 SCRIPT_FILE
*NewScriptFile
;
2581 UINTN PrintBuffSize
;
2582 CHAR16
*CommandLine
;
2583 CHAR16
*CommandLine2
;
2584 CHAR16
*CommandLine3
;
2585 SCRIPT_COMMAND_LIST
*LastCommand
;
2587 BOOLEAN PreScriptEchoState
;
2588 BOOLEAN PreCommandEchoState
;
2589 CONST CHAR16
*CurDir
;
2591 CHAR16 LeString
[50];
2593 ASSERT(!ShellCommandGetScriptExit());
2595 PreScriptEchoState
= ShellCommandGetEchoState();
2596 PrintBuffSize
= PcdGet16(PcdShellPrintBufferSize
);
2598 NewScriptFile
= (SCRIPT_FILE
*)AllocateZeroPool(sizeof(SCRIPT_FILE
));
2599 if (NewScriptFile
== NULL
) {
2600 return (EFI_OUT_OF_RESOURCES
);
2606 ASSERT(NewScriptFile
->ScriptName
== NULL
);
2607 NewScriptFile
->ScriptName
= StrnCatGrow(&NewScriptFile
->ScriptName
, NULL
, Name
, 0);
2608 if (NewScriptFile
->ScriptName
== NULL
) {
2609 DeleteScriptFileStruct(NewScriptFile
);
2610 return (EFI_OUT_OF_RESOURCES
);
2614 // Save the parameters (used to replace %0 to %9 later on)
2616 NewScriptFile
->Argc
= ShellInfoObject
.NewShellParametersProtocol
->Argc
;
2617 if (NewScriptFile
->Argc
!= 0) {
2618 NewScriptFile
->Argv
= (CHAR16
**)AllocateZeroPool(NewScriptFile
->Argc
* sizeof(CHAR16
*));
2619 if (NewScriptFile
->Argv
== NULL
) {
2620 DeleteScriptFileStruct(NewScriptFile
);
2621 return (EFI_OUT_OF_RESOURCES
);
2623 for (LoopVar
= 0 ; LoopVar
< 10 && LoopVar
< NewScriptFile
->Argc
; LoopVar
++) {
2624 ASSERT(NewScriptFile
->Argv
[LoopVar
] == NULL
);
2625 NewScriptFile
->Argv
[LoopVar
] = StrnCatGrow(&NewScriptFile
->Argv
[LoopVar
], NULL
, ShellInfoObject
.NewShellParametersProtocol
->Argv
[LoopVar
], 0);
2626 if (NewScriptFile
->Argv
[LoopVar
] == NULL
) {
2627 DeleteScriptFileStruct(NewScriptFile
);
2628 return (EFI_OUT_OF_RESOURCES
);
2632 NewScriptFile
->Argv
= NULL
;
2635 InitializeListHead(&NewScriptFile
->CommandList
);
2636 InitializeListHead(&NewScriptFile
->SubstList
);
2639 // Now build the list of all script commands.
2642 while(!ShellFileHandleEof(Handle
)) {
2643 CommandLine
= ShellFileHandleReturnLine(Handle
, &Ascii
);
2645 if (CommandLine
== NULL
|| StrLen(CommandLine
) == 0 || CommandLine
[0] == '#') {
2646 SHELL_FREE_NON_NULL(CommandLine
);
2649 NewScriptFile
->CurrentCommand
= AllocateZeroPool(sizeof(SCRIPT_COMMAND_LIST
));
2650 if (NewScriptFile
->CurrentCommand
== NULL
) {
2651 SHELL_FREE_NON_NULL(CommandLine
);
2652 DeleteScriptFileStruct(NewScriptFile
);
2653 return (EFI_OUT_OF_RESOURCES
);
2656 NewScriptFile
->CurrentCommand
->Cl
= CommandLine
;
2657 NewScriptFile
->CurrentCommand
->Data
= NULL
;
2658 NewScriptFile
->CurrentCommand
->Line
= LineCount
;
2660 InsertTailList(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
2664 // Add this as the topmost script file
2666 ShellCommandSetNewScript (NewScriptFile
);
2669 // Now enumerate through the commands and run each one.
2671 CommandLine
= AllocateZeroPool(PrintBuffSize
);
2672 if (CommandLine
== NULL
) {
2673 DeleteScriptFileStruct(NewScriptFile
);
2674 return (EFI_OUT_OF_RESOURCES
);
2676 CommandLine2
= AllocateZeroPool(PrintBuffSize
);
2677 if (CommandLine2
== NULL
) {
2678 FreePool(CommandLine
);
2679 DeleteScriptFileStruct(NewScriptFile
);
2680 return (EFI_OUT_OF_RESOURCES
);
2683 for ( NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetFirstNode(&NewScriptFile
->CommandList
)
2684 ; !IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)
2685 ; // conditional increment in the body of the loop
2687 ASSERT(CommandLine2
!= NULL
);
2688 StrnCpyS( CommandLine2
,
2689 PrintBuffSize
/sizeof(CHAR16
),
2690 NewScriptFile
->CurrentCommand
->Cl
,
2691 PrintBuffSize
/sizeof(CHAR16
) - 1
2695 // NULL out comments
2697 for (CommandLine3
= CommandLine2
; CommandLine3
!= NULL
&& *CommandLine3
!= CHAR_NULL
; CommandLine3
++) {
2698 if (*CommandLine3
== L
'^') {
2699 if ( *(CommandLine3
+1) == L
':') {
2700 CopyMem(CommandLine3
, CommandLine3
+1, StrSize(CommandLine3
) - sizeof(CommandLine3
[0]));
2701 } else if (*(CommandLine3
+1) == L
'#') {
2704 } else if (*CommandLine3
== L
'#') {
2705 *CommandLine3
= CHAR_NULL
;
2709 if (CommandLine2
!= NULL
&& StrLen(CommandLine2
) >= 1) {
2711 // Due to variability in starting the find and replace action we need to have both buffers the same.
2713 StrnCpyS( CommandLine
,
2714 PrintBuffSize
/sizeof(CHAR16
),
2716 PrintBuffSize
/sizeof(CHAR16
) - 1
2720 // Remove the %0 to %9 from the command line (if we have some arguments)
2722 if (NewScriptFile
->Argv
!= NULL
) {
2723 switch (NewScriptFile
->Argc
) {
2725 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%9", NewScriptFile
->Argv
[9], FALSE
, TRUE
);
2726 ASSERT_EFI_ERROR(Status
);
2728 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%8", NewScriptFile
->Argv
[8], FALSE
, TRUE
);
2729 ASSERT_EFI_ERROR(Status
);
2731 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%7", NewScriptFile
->Argv
[7], FALSE
, TRUE
);
2732 ASSERT_EFI_ERROR(Status
);
2734 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%6", NewScriptFile
->Argv
[6], FALSE
, TRUE
);
2735 ASSERT_EFI_ERROR(Status
);
2737 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%5", NewScriptFile
->Argv
[5], FALSE
, TRUE
);
2738 ASSERT_EFI_ERROR(Status
);
2740 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%4", NewScriptFile
->Argv
[4], FALSE
, TRUE
);
2741 ASSERT_EFI_ERROR(Status
);
2743 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%3", NewScriptFile
->Argv
[3], FALSE
, TRUE
);
2744 ASSERT_EFI_ERROR(Status
);
2746 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%2", NewScriptFile
->Argv
[2], FALSE
, TRUE
);
2747 ASSERT_EFI_ERROR(Status
);
2749 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%1", NewScriptFile
->Argv
[1], FALSE
, TRUE
);
2750 ASSERT_EFI_ERROR(Status
);
2752 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%0", NewScriptFile
->Argv
[0], FALSE
, TRUE
);
2753 ASSERT_EFI_ERROR(Status
);
2759 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%1", L
"\"\"", FALSE
, FALSE
);
2760 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%2", L
"\"\"", FALSE
, FALSE
);
2761 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%3", L
"\"\"", FALSE
, FALSE
);
2762 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%4", L
"\"\"", FALSE
, FALSE
);
2763 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%5", L
"\"\"", FALSE
, FALSE
);
2764 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%6", L
"\"\"", FALSE
, FALSE
);
2765 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%7", L
"\"\"", FALSE
, FALSE
);
2766 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%8", L
"\"\"", FALSE
, FALSE
);
2767 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%9", L
"\"\"", FALSE
, FALSE
);
2769 StrnCpyS( CommandLine2
,
2770 PrintBuffSize
/sizeof(CHAR16
),
2772 PrintBuffSize
/sizeof(CHAR16
) - 1
2775 LastCommand
= NewScriptFile
->CurrentCommand
;
2777 for (CommandLine3
= CommandLine2
; CommandLine3
[0] == L
' ' ; CommandLine3
++);
2779 if (CommandLine3
!= NULL
&& CommandLine3
[0] == L
':' ) {
2781 // This line is a goto target / label
2784 if (CommandLine3
!= NULL
&& StrLen(CommandLine3
) > 0) {
2785 if (CommandLine3
[0] == L
'@') {
2787 // We need to save the current echo state
2788 // and disable echo for just this command.
2790 PreCommandEchoState
= ShellCommandGetEchoState();
2791 ShellCommandSetEchoState(FALSE
);
2792 Status
= RunCommand(CommandLine3
+1);
2795 // If command was "@echo -off" or "@echo -on" then don't restore echo state
2797 if (StrCmp (L
"@echo -off", CommandLine3
) != 0 &&
2798 StrCmp (L
"@echo -on", CommandLine3
) != 0) {
2800 // Now restore the pre-'@' echo state.
2802 ShellCommandSetEchoState(PreCommandEchoState
);
2805 if (ShellCommandGetEchoState()) {
2806 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
2807 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
2808 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
2810 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
2812 ShellPrintEx(-1, -1, L
"%s\r\n", CommandLine2
);
2814 Status
= RunCommand(CommandLine3
);
2818 if (ShellCommandGetScriptExit()) {
2820 // ShellCommandGetExitCode() always returns a UINT64
2822 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%Lx", ShellCommandGetExitCode());
2823 DEBUG_CODE(InternalEfiShellSetEnv(L
"debuglasterror", LeString
, TRUE
););
2824 InternalEfiShellSetEnv(L
"lasterror", LeString
, TRUE
);
2826 ShellCommandRegisterExit(FALSE
, 0);
2827 Status
= EFI_SUCCESS
;
2830 if (ShellGetExecutionBreakFlag()) {
2833 if (EFI_ERROR(Status
)) {
2836 if (ShellCommandGetExit()) {
2841 // If that commend did not update the CurrentCommand then we need to advance it...
2843 if (LastCommand
== NewScriptFile
->CurrentCommand
) {
2844 NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetNextNode(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
2845 if (!IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)) {
2846 NewScriptFile
->CurrentCommand
->Reset
= TRUE
;
2850 NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetNextNode(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
2851 if (!IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)) {
2852 NewScriptFile
->CurrentCommand
->Reset
= TRUE
;
2858 FreePool(CommandLine
);
2859 FreePool(CommandLine2
);
2860 ShellCommandSetNewScript (NULL
);
2863 // Only if this was the last script reset the state.
2865 if (ShellCommandGetCurrentScriptFile()==NULL
) {
2866 ShellCommandSetEchoState(PreScriptEchoState
);
2868 return (EFI_SUCCESS
);
2872 Function to process a NSH script file.
2874 @param[in] ScriptPath Pointer to the script file name (including file system path).
2875 @param[in] Handle the handle of the script file already opened.
2876 @param[in] CmdLine the command line to run.
2877 @param[in] ParamProtocol the shell parameters protocol pointer
2879 @retval EFI_SUCCESS the script completed successfully
2884 IN CONST CHAR16
*ScriptPath
,
2885 IN SHELL_FILE_HANDLE Handle OPTIONAL
,
2886 IN CONST CHAR16
*CmdLine
,
2887 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
2891 SHELL_FILE_HANDLE FileHandle
;
2895 if (ShellIsFile(ScriptPath
) != EFI_SUCCESS
) {
2896 return (EFI_INVALID_PARAMETER
);
2900 // get the argc and argv updated for scripts
2902 Status
= UpdateArgcArgv(ParamProtocol
, CmdLine
, &Argv
, &Argc
);
2903 if (!EFI_ERROR(Status
)) {
2905 if (Handle
== NULL
) {
2909 Status
= ShellOpenFileByName(ScriptPath
, &FileHandle
, EFI_FILE_MODE_READ
, 0);
2910 if (!EFI_ERROR(Status
)) {
2914 Status
= RunScriptFileHandle(FileHandle
, ScriptPath
);
2917 // now close the file
2919 ShellCloseFile(&FileHandle
);
2922 Status
= RunScriptFileHandle(Handle
, ScriptPath
);
2927 // This is guaranteed to be called after UpdateArgcArgv no matter what else happened.
2928 // This is safe even if the update API failed. In this case, it may be a no-op.
2930 RestoreArgcArgv(ParamProtocol
, &Argv
, &Argc
);
2936 Return the pointer to the first occurrence of any character from a list of characters.
2938 @param[in] String the string to parse
2939 @param[in] CharacterList the list of character to look for
2940 @param[in] EscapeCharacter An escape character to skip
2942 @return the location of the first character in the string
2943 @retval CHAR_NULL no instance of any character in CharacterList was found in String
2948 IN CONST CHAR16
*String
,
2949 IN CONST CHAR16
*CharacterList
,
2950 IN CONST CHAR16 EscapeCharacter
2956 for (WalkStr
= 0; WalkStr
< StrLen(String
); WalkStr
++) {
2957 if (String
[WalkStr
] == EscapeCharacter
) {
2961 for (WalkChar
= 0; WalkChar
< StrLen(CharacterList
); WalkChar
++) {
2962 if (String
[WalkStr
] == CharacterList
[WalkChar
]) {
2963 return (&String
[WalkStr
]);
2967 return (String
+ StrLen(String
));