2 This is THE shell (application)
4 Copyright (c) 2009 - 2017, 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
= {
57 {{NULL
, NULL
}, NULL
, NULL
},
58 {{NULL
, NULL
}, NULL
, NULL
},
70 STATIC CONST CHAR16 mScriptExtension
[] = L
".NSH";
71 STATIC CONST CHAR16 mExecutableExtensions
[] = L
".NSH;.EFI";
72 STATIC CONST CHAR16 mStartupScript
[] = L
"startup.nsh";
73 CONST CHAR16 mNoNestingEnvVarName
[] = L
"nonesting";
74 CONST CHAR16 mNoNestingTrue
[] = L
"True";
75 CONST CHAR16 mNoNestingFalse
[] = L
"False";
78 Cleans off leading and trailing spaces and tabs.
80 @param[in] String pointer to the string to trim them off.
87 ASSERT(String
!= NULL
);
88 ASSERT(*String
!= NULL
);
90 // Remove any spaces and tabs at the beginning of the (*String).
92 while (((*String
)[0] == L
' ') || ((*String
)[0] == L
'\t')) {
93 CopyMem((*String
), (*String
)+1, StrSize((*String
)) - sizeof((*String
)[0]));
97 // Remove any spaces and tabs at the end of the (*String).
99 while ((StrLen (*String
) > 0) && (((*String
)[StrLen((*String
))-1] == L
' ') || ((*String
)[StrLen((*String
))-1] == L
'\t'))) {
100 (*String
)[StrLen((*String
))-1] = CHAR_NULL
;
103 return (EFI_SUCCESS
);
107 Parse for the next instance of one string within another string. Can optionally make sure that
108 the string was not escaped (^ character) per the shell specification.
110 @param[in] SourceString The string to search within
111 @param[in] FindString The string to look for
112 @param[in] CheckForEscapeCharacter TRUE to skip escaped instances of FinfString, otherwise will return even escaped instances
116 IN CONST CHAR16
*SourceString
,
117 IN CONST CHAR16
*FindString
,
118 IN CONST BOOLEAN CheckForEscapeCharacter
122 if (SourceString
== NULL
) {
125 Temp
= StrStr(SourceString
, FindString
);
128 // If nothing found, or we don't care about escape characters
130 if (Temp
== NULL
|| !CheckForEscapeCharacter
) {
135 // If we found an escaped character, try again on the remainder of the string
137 if ((Temp
> (SourceString
)) && *(Temp
-1) == L
'^') {
138 return FindNextInstance(Temp
+1, FindString
, CheckForEscapeCharacter
);
142 // we found the right character
148 Check whether the string between a pair of % is a valid environment variable name.
150 @param[in] BeginPercent pointer to the first percent.
151 @param[in] EndPercent pointer to the last percent.
153 @retval TRUE is a valid environment variable name.
154 @retval FALSE is NOT a valid environment variable name.
157 IsValidEnvironmentVariableName(
158 IN CONST CHAR16
*BeginPercent
,
159 IN CONST CHAR16
*EndPercent
162 CONST CHAR16
*Walker
;
166 ASSERT (BeginPercent
!= NULL
);
167 ASSERT (EndPercent
!= NULL
);
168 ASSERT (BeginPercent
< EndPercent
);
170 if ((BeginPercent
+ 1) == EndPercent
) {
174 for (Walker
= BeginPercent
+ 1; Walker
< EndPercent
; Walker
++) {
176 (*Walker
>= L
'0' && *Walker
<= L
'9') ||
177 (*Walker
>= L
'A' && *Walker
<= L
'Z') ||
178 (*Walker
>= L
'a' && *Walker
<= L
'z') ||
181 if (Walker
== BeginPercent
+ 1 && (*Walker
>= L
'0' && *Walker
<= L
'9')) {
195 Determine if a command line contains a split operation
197 @param[in] CmdLine The command line to parse.
199 @retval TRUE CmdLine has a valid split.
200 @retval FALSE CmdLine does not have a valid split.
204 IN CONST CHAR16
*CmdLine
207 CONST CHAR16
*TempSpot
;
208 CONST CHAR16
*FirstQuote
;
209 CONST CHAR16
*SecondQuote
;
211 FirstQuote
= FindNextInstance (CmdLine
, L
"\"", TRUE
);
213 TempSpot
= FindFirstCharacter(CmdLine
, L
"|", L
'^');
215 if (FirstQuote
== NULL
||
217 TempSpot
== CHAR_NULL
||
218 FirstQuote
> TempSpot
220 return (BOOLEAN
) ((TempSpot
!= NULL
) && (*TempSpot
!= CHAR_NULL
));
223 while ((TempSpot
!= NULL
) && (*TempSpot
!= CHAR_NULL
)) {
224 if (FirstQuote
== NULL
|| FirstQuote
> TempSpot
) {
227 SecondQuote
= FindNextInstance (FirstQuote
+ 1, L
"\"", TRUE
);
228 if (SecondQuote
== NULL
) {
231 if (SecondQuote
< TempSpot
) {
232 FirstQuote
= FindNextInstance (SecondQuote
+ 1, L
"\"", TRUE
);
235 FirstQuote
= FindNextInstance (SecondQuote
+ 1, L
"\"", TRUE
);
236 TempSpot
= FindFirstCharacter(TempSpot
+ 1, L
"|", L
'^');
241 return (BOOLEAN
) ((TempSpot
!= NULL
) && (*TempSpot
!= CHAR_NULL
));
245 Function to start monitoring for CTRL-S using SimpleTextInputEx. This
246 feature's enabled state was not known when the shell initially launched.
248 @retval EFI_SUCCESS The feature is enabled.
249 @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
;
343 if (PcdGet8(PcdShellSupportLevel
) > 3) {
344 return (EFI_UNSUPPORTED
);
350 Status
= gST
->ConOut
->ClearScreen(gST
->ConOut
);
351 if (EFI_ERROR(Status
)) {
356 // Populate the global structure from PCDs
358 ShellInfoObject
.ImageDevPath
= NULL
;
359 ShellInfoObject
.FileDevPath
= NULL
;
360 ShellInfoObject
.PageBreakEnabled
= PcdGetBool(PcdShellPageBreakDefault
);
361 ShellInfoObject
.ViewingSettings
.InsertMode
= PcdGetBool(PcdShellInsertModeDefault
);
362 ShellInfoObject
.LogScreenCount
= PcdGet8 (PcdShellScreenLogCount
);
365 // verify we dont allow for spec violation
367 ASSERT(ShellInfoObject
.LogScreenCount
>= 3);
370 // Initialize the LIST ENTRY objects...
372 InitializeListHead(&ShellInfoObject
.BufferToFreeList
.Link
);
373 InitializeListHead(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
);
374 InitializeListHead(&ShellInfoObject
.SplitList
.Link
);
377 // Check PCDs for optional features that are not implemented yet.
379 if ( PcdGetBool(PcdShellSupportOldProtocols
)
380 || !FeaturePcdGet(PcdShellRequireHiiPlatform
)
381 || FeaturePcdGet(PcdShellSupportFrameworkHii
)
383 return (EFI_UNSUPPORTED
);
387 // turn off the watchdog timer
389 gBS
->SetWatchdogTimer (0, 0, 0, NULL
);
392 // install our console logger. This will keep a log of the output for back-browsing
394 Status
= ConsoleLoggerInstall(ShellInfoObject
.LogScreenCount
, &ShellInfoObject
.ConsoleInfo
);
395 if (!EFI_ERROR(Status
)) {
397 // Enable the cursor to be visible
399 gST
->ConOut
->EnableCursor (gST
->ConOut
, TRUE
);
402 // If supporting EFI 1.1 we need to install HII protocol
403 // only do this if PcdShellRequireHiiPlatform == FALSE
405 // remove EFI_UNSUPPORTED check above when complete.
406 ///@todo add support for Framework HII
409 // install our (solitary) HII package
411 ShellInfoObject
.HiiHandle
= HiiAddPackages (&gEfiCallerIdGuid
, gImageHandle
, ShellStrings
, NULL
);
412 if (ShellInfoObject
.HiiHandle
== NULL
) {
413 if (PcdGetBool(PcdShellSupportFrameworkHii
)) {
414 ///@todo Add our package into Framework HII
416 if (ShellInfoObject
.HiiHandle
== NULL
) {
417 Status
= EFI_NOT_STARTED
;
423 // create and install the EfiShellParametersProtocol
425 Status
= CreatePopulateInstallShellParametersProtocol(&ShellInfoObject
.NewShellParametersProtocol
, &ShellInfoObject
.RootShellInstance
);
426 ASSERT_EFI_ERROR(Status
);
427 ASSERT(ShellInfoObject
.NewShellParametersProtocol
!= NULL
);
430 // create and install the EfiShellProtocol
432 Status
= CreatePopulateInstallShellProtocol(&ShellInfoObject
.NewEfiShellProtocol
);
433 ASSERT_EFI_ERROR(Status
);
434 ASSERT(ShellInfoObject
.NewEfiShellProtocol
!= NULL
);
437 // Now initialize the shell library (it requires Shell Parameters protocol)
439 Status
= ShellInitialize();
440 ASSERT_EFI_ERROR(Status
);
442 Status
= CommandInit();
443 ASSERT_EFI_ERROR(Status
);
445 Status
= ShellInitEnvVarList ();
448 // Check the command line
450 Status
= ProcessCommandLine ();
451 if (EFI_ERROR (Status
)) {
456 // If shell support level is >= 1 create the mappings and paths
458 if (PcdGet8(PcdShellSupportLevel
) >= 1) {
459 Status
= ShellCommandCreateInitialMappingsAndPaths();
463 // Set the environment variable for nesting support
467 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoNest
) {
469 // No change. require nesting in Shell Protocol Execute()
471 StrnCatGrow(&TempString
,
476 StrnCatGrow(&TempString
,
481 Status
= InternalEfiShellSetEnv(mNoNestingEnvVarName
, TempString
, TRUE
);
482 SHELL_FREE_NON_NULL(TempString
);
486 // save the device path for the loaded image and the device path for the filepath (under loaded image)
487 // These are where to look for the startup.nsh file
489 Status
= GetDevicePathsForImageAndFile(&ShellInfoObject
.ImageDevPath
, &ShellInfoObject
.FileDevPath
);
490 ASSERT_EFI_ERROR(Status
);
493 // Display the version
495 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoVersion
) {
498 gST
->ConOut
->Mode
->CursorRow
,
500 STRING_TOKEN (STR_VER_OUTPUT_MAIN_SHELL
),
501 ShellInfoObject
.HiiHandle
,
502 SupportLevel
[PcdGet8(PcdShellSupportLevel
)],
503 gEfiShellProtocol
->MajorVersion
,
504 gEfiShellProtocol
->MinorVersion
511 STRING_TOKEN (STR_VER_OUTPUT_MAIN_SUPPLIER
),
512 ShellInfoObject
.HiiHandle
,
513 (CHAR16
*) PcdGetPtr (PcdShellSupplier
)
520 STRING_TOKEN (STR_VER_OUTPUT_MAIN_UEFI
),
521 ShellInfoObject
.HiiHandle
,
522 (gST
->Hdr
.Revision
&0xffff0000)>>16,
523 (gST
->Hdr
.Revision
&0x0000ffff),
525 gST
->FirmwareRevision
530 // Display the mapping
532 if (PcdGet8(PcdShellSupportLevel
) >= 2 && !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoMap
) {
533 Status
= RunCommand(L
"map");
534 ASSERT_EFI_ERROR(Status
);
538 // init all the built in alias'
540 Status
= SetBuiltInAlias();
541 ASSERT_EFI_ERROR(Status
);
544 // Initialize environment variables
546 if (ShellCommandGetProfileList() != NULL
) {
547 Status
= InternalEfiShellSetEnv(L
"profiles", ShellCommandGetProfileList(), TRUE
);
548 ASSERT_EFI_ERROR(Status
);
552 TempString
= AllocateZeroPool(Size
);
554 UnicodeSPrint(TempString
, Size
, L
"%d", PcdGet8(PcdShellSupportLevel
));
555 Status
= InternalEfiShellSetEnv(L
"uefishellsupport", TempString
, TRUE
);
556 ASSERT_EFI_ERROR(Status
);
558 UnicodeSPrint(TempString
, Size
, L
"%d.%d", ShellInfoObject
.NewEfiShellProtocol
->MajorVersion
, ShellInfoObject
.NewEfiShellProtocol
->MinorVersion
);
559 Status
= InternalEfiShellSetEnv(L
"uefishellversion", TempString
, TRUE
);
560 ASSERT_EFI_ERROR(Status
);
562 UnicodeSPrint(TempString
, Size
, L
"%d.%d", (gST
->Hdr
.Revision
& 0xFFFF0000) >> 16, gST
->Hdr
.Revision
& 0x0000FFFF);
563 Status
= InternalEfiShellSetEnv(L
"uefiversion", TempString
, TRUE
);
564 ASSERT_EFI_ERROR(Status
);
566 FreePool(TempString
);
568 if (!EFI_ERROR(Status
)) {
569 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
) {
571 // Set up the event for CTRL-C monitoring...
573 Status
= InernalEfiShellStartMonitor();
576 if (!EFI_ERROR(Status
) && !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
578 // Set up the event for CTRL-S monitoring...
580 Status
= InternalEfiShellStartCtrlSMonitor();
583 if (!EFI_ERROR(Status
) && ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
585 // close off the gST->ConIn
587 OldConIn
= gST
->ConIn
;
588 ConInHandle
= gST
->ConsoleInHandle
;
589 gST
->ConIn
= CreateSimpleTextInOnFile((SHELL_FILE_HANDLE
)&FileInterfaceNulFile
, &gST
->ConsoleInHandle
);
595 if (!EFI_ERROR(Status
) && PcdGet8(PcdShellSupportLevel
) >= 1) {
597 // process the startup script or launch the called app.
599 Status
= DoStartupScript(ShellInfoObject
.ImageDevPath
, ShellInfoObject
.FileDevPath
);
602 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Exit
&& !ShellCommandGetExit() && (PcdGet8(PcdShellSupportLevel
) >= 3 || PcdGetBool(PcdShellForceConsole
)) && !EFI_ERROR(Status
) && !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
604 // begin the UI waiting loop
608 // clean out all the memory allocated for CONST <something> * return values
609 // between each shell prompt presentation
611 if (!IsListEmpty(&ShellInfoObject
.BufferToFreeList
.Link
)){
612 FreeBufferList(&ShellInfoObject
.BufferToFreeList
);
616 // Reset page break back to default.
618 ShellInfoObject
.PageBreakEnabled
= PcdGetBool(PcdShellPageBreakDefault
);
619 ASSERT (ShellInfoObject
.ConsoleInfo
!= NULL
);
620 ShellInfoObject
.ConsoleInfo
->Enabled
= TRUE
;
621 ShellInfoObject
.ConsoleInfo
->RowCounter
= 0;
624 // Reset the CTRL-C event (yes we ignore the return values)
626 Status
= gBS
->CheckEvent (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
);
631 Status
= DoShellPrompt();
632 } while (!ShellCommandGetExit());
634 if (OldConIn
!= NULL
&& ConInHandle
!= NULL
) {
635 CloseSimpleTextInOnFile (gST
->ConIn
);
636 gST
->ConIn
= OldConIn
;
637 gST
->ConsoleInHandle
= ConInHandle
;
644 // uninstall protocols / free memory / etc...
646 if (ShellInfoObject
.UserBreakTimer
!= NULL
) {
647 gBS
->CloseEvent(ShellInfoObject
.UserBreakTimer
);
648 DEBUG_CODE(ShellInfoObject
.UserBreakTimer
= NULL
;);
650 if (ShellInfoObject
.ImageDevPath
!= NULL
) {
651 FreePool(ShellInfoObject
.ImageDevPath
);
652 DEBUG_CODE(ShellInfoObject
.ImageDevPath
= NULL
;);
654 if (ShellInfoObject
.FileDevPath
!= NULL
) {
655 FreePool(ShellInfoObject
.FileDevPath
);
656 DEBUG_CODE(ShellInfoObject
.FileDevPath
= NULL
;);
658 if (ShellInfoObject
.NewShellParametersProtocol
!= NULL
) {
659 CleanUpShellParametersProtocol(ShellInfoObject
.NewShellParametersProtocol
);
660 DEBUG_CODE(ShellInfoObject
.NewShellParametersProtocol
= NULL
;);
662 if (ShellInfoObject
.NewEfiShellProtocol
!= NULL
){
663 if (ShellInfoObject
.NewEfiShellProtocol
->IsRootShell()){
664 InternalEfiShellSetEnv(L
"cwd", NULL
, TRUE
);
666 CleanUpShellEnvironment (ShellInfoObject
.NewEfiShellProtocol
);
667 DEBUG_CODE(ShellInfoObject
.NewEfiShellProtocol
= NULL
;);
670 if (!IsListEmpty(&ShellInfoObject
.BufferToFreeList
.Link
)){
671 FreeBufferList(&ShellInfoObject
.BufferToFreeList
);
674 if (!IsListEmpty(&ShellInfoObject
.SplitList
.Link
)){
675 ASSERT(FALSE
); ///@todo finish this de-allocation (free SplitStdIn/Out when needed).
677 for ( Split
= (SPLIT_LIST
*)GetFirstNode (&ShellInfoObject
.SplitList
.Link
)
678 ; !IsNull (&ShellInfoObject
.SplitList
.Link
, &Split
->Link
)
679 ; Split
= (SPLIT_LIST
*)GetNextNode (&ShellInfoObject
.SplitList
.Link
, &Split
->Link
)
681 RemoveEntryList (&Split
->Link
);
685 DEBUG_CODE (InitializeListHead (&ShellInfoObject
.SplitList
.Link
););
688 if (ShellInfoObject
.ShellInitSettings
.FileName
!= NULL
) {
689 FreePool(ShellInfoObject
.ShellInitSettings
.FileName
);
690 DEBUG_CODE(ShellInfoObject
.ShellInitSettings
.FileName
= NULL
;);
693 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
694 FreePool(ShellInfoObject
.ShellInitSettings
.FileOptions
);
695 DEBUG_CODE(ShellInfoObject
.ShellInitSettings
.FileOptions
= NULL
;);
698 if (ShellInfoObject
.HiiHandle
!= NULL
) {
699 HiiRemovePackages(ShellInfoObject
.HiiHandle
);
700 DEBUG_CODE(ShellInfoObject
.HiiHandle
= NULL
;);
703 if (!IsListEmpty(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
)){
704 FreeBufferList(&ShellInfoObject
.ViewingSettings
.CommandHistory
);
707 ASSERT(ShellInfoObject
.ConsoleInfo
!= NULL
);
708 if (ShellInfoObject
.ConsoleInfo
!= NULL
) {
709 ConsoleLoggerUninstall(ShellInfoObject
.ConsoleInfo
);
710 FreePool(ShellInfoObject
.ConsoleInfo
);
711 DEBUG_CODE(ShellInfoObject
.ConsoleInfo
= NULL
;);
714 ShellFreeEnvVarList ();
716 if (ShellCommandGetExit()) {
717 return ((EFI_STATUS
)ShellCommandGetExitCode());
723 Sets all the alias' that were registered with the ShellCommandLib library.
725 @retval EFI_SUCCESS all init commands were run successfully.
732 CONST ALIAS_LIST
*List
;
736 // Get all the commands we want to run
738 List
= ShellCommandGetInitAliasList();
741 // for each command in the List
743 for ( Node
= (ALIAS_LIST
*)GetFirstNode(&List
->Link
)
744 ; !IsNull (&List
->Link
, &Node
->Link
)
745 ; Node
= (ALIAS_LIST
*)GetNextNode(&List
->Link
, &Node
->Link
)
748 // install the alias'
750 Status
= InternalSetAlias(Node
->CommandString
, Node
->Alias
, TRUE
);
751 ASSERT_EFI_ERROR(Status
);
753 return (EFI_SUCCESS
);
757 Internal function to determine if 2 command names are really the same.
759 @param[in] Command1 The pointer to the first command name.
760 @param[in] Command2 The pointer to the second command name.
762 @retval TRUE The 2 command names are the same.
763 @retval FALSE The 2 command names are not the same.
767 IN CONST CHAR16
*Command1
,
768 IN CONST CHAR16
*Command2
771 if (StringNoCaseCompare(&Command1
, &Command2
) == 0) {
778 Internal function to determine if a command is a script only command.
780 @param[in] CommandName The pointer to the command name.
782 @retval TRUE The command is a script only command.
783 @retval FALSE The command is not a script only command.
787 IN CONST CHAR16
*CommandName
790 if (IsCommand(CommandName
, L
"for")
791 ||IsCommand(CommandName
, L
"endfor")
792 ||IsCommand(CommandName
, L
"if")
793 ||IsCommand(CommandName
, L
"else")
794 ||IsCommand(CommandName
, L
"endif")
795 ||IsCommand(CommandName
, L
"goto")) {
802 This function will populate the 2 device path protocol parameters based on the
803 global gImageHandle. The DevPath will point to the device path for the handle that has
804 loaded image protocol installed on it. The FilePath will point to the device path
805 for the file that was loaded.
807 @param[in, out] DevPath On a successful return the device path to the loaded image.
808 @param[in, out] FilePath On a successful return the device path to the file.
810 @retval EFI_SUCCESS The 2 device paths were successfully returned.
811 @retval other A error from gBS->HandleProtocol.
816 GetDevicePathsForImageAndFile (
817 IN OUT EFI_DEVICE_PATH_PROTOCOL
**DevPath
,
818 IN OUT EFI_DEVICE_PATH_PROTOCOL
**FilePath
822 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
823 EFI_DEVICE_PATH_PROTOCOL
*ImageDevicePath
;
825 ASSERT(DevPath
!= NULL
);
826 ASSERT(FilePath
!= NULL
);
828 Status
= gBS
->OpenProtocol (
830 &gEfiLoadedImageProtocolGuid
,
831 (VOID
**)&LoadedImage
,
834 EFI_OPEN_PROTOCOL_GET_PROTOCOL
836 if (!EFI_ERROR (Status
)) {
837 Status
= gBS
->OpenProtocol (
838 LoadedImage
->DeviceHandle
,
839 &gEfiDevicePathProtocolGuid
,
840 (VOID
**)&ImageDevicePath
,
843 EFI_OPEN_PROTOCOL_GET_PROTOCOL
845 if (!EFI_ERROR (Status
)) {
846 *DevPath
= DuplicateDevicePath (ImageDevicePath
);
847 *FilePath
= DuplicateDevicePath (LoadedImage
->FilePath
);
849 LoadedImage
->DeviceHandle
,
850 &gEfiDevicePathProtocolGuid
,
856 &gEfiLoadedImageProtocolGuid
,
864 Process all Uefi Shell 2.0 command line options.
866 see Uefi Shell 2.0 section 3.2 for full details.
868 the command line must resemble the following:
870 shell.efi [ShellOpt-options] [options] [file-name [file-name-options]]
872 ShellOpt-options Options which control the initialization behavior of the shell.
873 These options are read from the EFI global variable "ShellOpt"
874 and are processed before options or file-name.
876 options Options which control the initialization behavior of the shell.
878 file-name The name of a UEFI shell application or script to be executed
879 after initialization is complete. By default, if file-name is
880 specified, then -nostartup is implied. Scripts are not supported
883 file-name-options The command-line options that are passed to file-name when it
886 This will initialize the ShellInfoObject.ShellInitSettings global variable.
888 @retval EFI_SUCCESS The variable is initialized.
898 CHAR16
*DelayValueStr
;
901 EFI_UNICODE_COLLATION_PROTOCOL
*UnicodeCollation
;
903 // `file-name-options` will contain arguments to `file-name` that we don't
904 // know about. This would cause ShellCommandLineParse to error, so we parse
905 // arguments manually, ignoring those after the first thing that doesn't look
906 // like a shell option (which is assumed to be `file-name`).
908 Status
= gBS
->LocateProtocol (
909 &gEfiUnicodeCollation2ProtocolGuid
,
911 (VOID
**) &UnicodeCollation
913 if (EFI_ERROR (Status
)) {
914 Status
= gBS
->LocateProtocol (
915 &gEfiUnicodeCollationProtocolGuid
,
917 (VOID
**) &UnicodeCollation
919 if (EFI_ERROR (Status
)) {
924 // Set default options
925 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
= FALSE
;
926 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
= FALSE
;
927 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleOut
= FALSE
;
928 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
= FALSE
;
929 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
= FALSE
;
930 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoMap
= FALSE
;
931 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoVersion
= FALSE
;
932 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Delay
= FALSE
;
933 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Exit
= FALSE
;
934 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoNest
= FALSE
;
935 ShellInfoObject
.ShellInitSettings
.Delay
= 5;
938 // Start LoopVar at 0 to parse only optional arguments at Argv[0]
939 // and parse other parameters from Argv[1]. This is for use case that
940 // UEFI Shell boot option is created, and OptionalData is provided
941 // that starts with shell command-line options.
943 for (LoopVar
= 0 ; LoopVar
< gEfiShellParametersProtocol
->Argc
; LoopVar
++) {
944 CurrentArg
= gEfiShellParametersProtocol
->Argv
[LoopVar
];
945 if (UnicodeCollation
->StriColl (
950 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
= TRUE
;
952 else if (UnicodeCollation
->StriColl (
957 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
= TRUE
;
959 else if (UnicodeCollation
->StriColl (
964 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleOut
= TRUE
;
966 else if (UnicodeCollation
->StriColl (
971 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
= TRUE
;
973 else if (UnicodeCollation
->StriColl (
978 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
= TRUE
;
980 else if (UnicodeCollation
->StriColl (
985 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoMap
= TRUE
;
987 else if (UnicodeCollation
->StriColl (
992 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoVersion
= TRUE
;
994 else if (UnicodeCollation
->StriColl (
999 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoNest
= TRUE
;
1001 else if (UnicodeCollation
->StriColl (
1006 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Delay
= TRUE
;
1007 // Check for optional delay value following "-delay"
1008 DelayValueStr
= gEfiShellParametersProtocol
->Argv
[LoopVar
+ 1];
1009 if (DelayValueStr
!= NULL
){
1010 if (*DelayValueStr
== L
':') {
1013 if (!EFI_ERROR(ShellConvertStringToUint64 (
1019 ShellInfoObject
.ShellInitSettings
.Delay
= (UINTN
)DelayValue
;
1023 } else if (UnicodeCollation
->StriColl (
1028 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Exit
= TRUE
;
1029 } else if (StrnCmp (L
"-", CurrentArg
, 1) == 0) {
1030 // Unrecognized option
1031 ShellPrintHiiEx(-1, -1, NULL
,
1032 STRING_TOKEN (STR_GEN_PROBLEM
),
1033 ShellInfoObject
.HiiHandle
,
1036 return EFI_INVALID_PARAMETER
;
1039 // First argument should be Shell.efi image name
1045 ShellInfoObject
.ShellInitSettings
.FileName
= NULL
;
1048 // If first argument contains a space, then add double quotes before the argument
1050 if (StrStr (CurrentArg
, L
" ") != NULL
) {
1051 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileName
, &Size
, L
"\"", 0);
1052 if (ShellInfoObject
.ShellInitSettings
.FileName
== NULL
) {
1053 return (EFI_OUT_OF_RESOURCES
);
1056 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileName
, &Size
, CurrentArg
, 0);
1057 if (ShellInfoObject
.ShellInitSettings
.FileName
== NULL
) {
1058 return (EFI_OUT_OF_RESOURCES
);
1061 // If first argument contains a space, then add double quotes after the argument
1063 if (StrStr (CurrentArg
, L
" ") != NULL
) {
1064 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileName
, &Size
, L
"\"", 0);
1065 if (ShellInfoObject
.ShellInitSettings
.FileName
== NULL
) {
1066 return (EFI_OUT_OF_RESOURCES
);
1070 // We found `file-name`.
1072 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
= 1;
1075 // Add `file-name-options`
1076 for (Size
= 0 ; LoopVar
< gEfiShellParametersProtocol
->Argc
; LoopVar
++) {
1077 ASSERT((ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
&& Size
== 0) || (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
));
1079 // Add a space between arguments
1081 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
1082 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileOptions
, &Size
, L
" ", 0);
1083 if (ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
) {
1084 SHELL_FREE_NON_NULL(ShellInfoObject
.ShellInitSettings
.FileName
);
1085 return (EFI_OUT_OF_RESOURCES
);
1089 // If an argumnent contains a space, then add double quotes before the argument
1091 if (StrStr (gEfiShellParametersProtocol
->Argv
[LoopVar
], L
" ") != NULL
) {
1092 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileOptions
,
1096 if (ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
) {
1097 SHELL_FREE_NON_NULL(ShellInfoObject
.ShellInitSettings
.FileName
);
1098 return (EFI_OUT_OF_RESOURCES
);
1101 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileOptions
,
1103 gEfiShellParametersProtocol
->Argv
[LoopVar
],
1105 if (ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
) {
1106 SHELL_FREE_NON_NULL(ShellInfoObject
.ShellInitSettings
.FileName
);
1107 return (EFI_OUT_OF_RESOURCES
);
1110 // If an argumnent contains a space, then add double quotes after the argument
1112 if (StrStr (gEfiShellParametersProtocol
->Argv
[LoopVar
], L
" ") != NULL
) {
1113 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileOptions
,
1117 if (ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
) {
1118 SHELL_FREE_NON_NULL(ShellInfoObject
.ShellInitSettings
.FileName
);
1119 return (EFI_OUT_OF_RESOURCES
);
1126 // "-nointerrupt" overrides "-delay"
1127 if (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
) {
1128 ShellInfoObject
.ShellInitSettings
.Delay
= 0;
1135 Function try to find location of the Startup.nsh file.
1137 The buffer is callee allocated and should be freed by the caller.
1139 @param ImageDevicePath The path to the image for shell. first place to look for the startup script
1140 @param FileDevicePath The path to the file for shell. second place to look for the startup script.
1142 @retval NULL No Startup.nsh file was found.
1143 @return !=NULL Pointer to NULL-terminated path.
1146 LocateStartupScript (
1147 IN EFI_DEVICE_PATH_PROTOCOL
*ImageDevicePath
,
1148 IN EFI_DEVICE_PATH_PROTOCOL
*FileDevicePath
1151 CHAR16
*StartupScriptPath
;
1153 CONST CHAR16
*MapName
;
1156 StartupScriptPath
= NULL
;
1160 // Try to find 'Startup.nsh' in the directory where the shell itself was launched.
1162 MapName
= ShellInfoObject
.NewEfiShellProtocol
->GetMapFromDevicePath (&ImageDevicePath
);
1163 if (MapName
!= NULL
) {
1164 StartupScriptPath
= StrnCatGrow (&StartupScriptPath
, &Size
, MapName
, 0);
1165 if (StartupScriptPath
== NULL
) {
1167 // Do not locate the startup script in sys path when out of resource.
1171 TempSpot
= StrStr (StartupScriptPath
, L
";");
1172 if (TempSpot
!= NULL
) {
1173 *TempSpot
= CHAR_NULL
;
1176 StartupScriptPath
= StrnCatGrow (&StartupScriptPath
, &Size
, ((FILEPATH_DEVICE_PATH
*)FileDevicePath
)->PathName
, 0);
1177 PathRemoveLastItem (StartupScriptPath
);
1178 StartupScriptPath
= StrnCatGrow (&StartupScriptPath
, &Size
, mStartupScript
, 0);
1182 // Try to find 'Startup.nsh' in the execution path defined by the envrionment variable PATH.
1184 if ((StartupScriptPath
== NULL
) || EFI_ERROR (ShellIsFile (StartupScriptPath
))) {
1185 SHELL_FREE_NON_NULL (StartupScriptPath
);
1186 StartupScriptPath
= ShellFindFilePath (mStartupScript
);
1189 return StartupScriptPath
;
1193 Handles all interaction with the default startup script.
1195 this will check that the correct command line parameters were passed, handle the delay, and then start running the script.
1197 @param ImagePath the path to the image for shell. first place to look for the startup script
1198 @param FilePath the path to the file for shell. second place to look for the startup script.
1200 @retval EFI_SUCCESS the variable is initialized.
1204 IN EFI_DEVICE_PATH_PROTOCOL
*ImagePath
,
1205 IN EFI_DEVICE_PATH_PROTOCOL
*FilePath
1209 EFI_STATUS CalleeStatus
;
1212 CHAR16
*FileStringPath
;
1215 Key
.UnicodeChar
= CHAR_NULL
;
1218 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
&& ShellInfoObject
.ShellInitSettings
.FileName
!= NULL
) {
1220 // launch something else instead
1222 NewSize
= StrSize(ShellInfoObject
.ShellInitSettings
.FileName
);
1223 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
1224 NewSize
+= StrSize(ShellInfoObject
.ShellInitSettings
.FileOptions
) + sizeof(CHAR16
);
1226 FileStringPath
= AllocateZeroPool(NewSize
);
1227 if (FileStringPath
== NULL
) {
1228 return (EFI_OUT_OF_RESOURCES
);
1230 StrCpyS(FileStringPath
, NewSize
/sizeof(CHAR16
), ShellInfoObject
.ShellInitSettings
.FileName
);
1231 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
1232 StrnCatS(FileStringPath
, NewSize
/sizeof(CHAR16
), L
" ", NewSize
/sizeof(CHAR16
) - StrLen(FileStringPath
) -1);
1233 StrnCatS(FileStringPath
, NewSize
/sizeof(CHAR16
), ShellInfoObject
.ShellInitSettings
.FileOptions
, NewSize
/sizeof(CHAR16
) - StrLen(FileStringPath
) -1);
1235 Status
= RunShellCommand(FileStringPath
, &CalleeStatus
);
1236 if (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Exit
== TRUE
) {
1237 ShellCommandRegisterExit(gEfiShellProtocol
->BatchIsActive(), (UINT64
)CalleeStatus
);
1239 FreePool(FileStringPath
);
1245 // for shell level 0 we do no scripts
1246 // Without the Startup bit overriding we allow for nostartup to prevent scripts
1248 if ( (PcdGet8(PcdShellSupportLevel
) < 1)
1249 || (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
&& !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
)
1251 return (EFI_SUCCESS
);
1254 gST
->ConOut
->EnableCursor(gST
->ConOut
, FALSE
);
1256 // print out our warning and see if they press a key
1258 for ( Status
= EFI_UNSUPPORTED
, Delay
= ShellInfoObject
.ShellInitSettings
.Delay
1259 ; Delay
!= 0 && EFI_ERROR(Status
)
1262 ShellPrintHiiEx(0, gST
->ConOut
->Mode
->CursorRow
, NULL
, STRING_TOKEN (STR_SHELL_STARTUP_QUESTION
), ShellInfoObject
.HiiHandle
, Delay
);
1263 gBS
->Stall (1000000);
1264 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
1265 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
1268 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CRLF
), ShellInfoObject
.HiiHandle
);
1269 gST
->ConOut
->EnableCursor(gST
->ConOut
, TRUE
);
1274 if (Status
== EFI_SUCCESS
&& Key
.UnicodeChar
== 0 && Key
.ScanCode
== SCAN_ESC
) {
1275 return (EFI_SUCCESS
);
1278 FileStringPath
= LocateStartupScript (ImagePath
, FilePath
);
1279 if (FileStringPath
!= NULL
) {
1280 Status
= RunScriptFile (FileStringPath
, NULL
, L
"", ShellInfoObject
.NewShellParametersProtocol
);
1281 FreePool (FileStringPath
);
1284 // we return success since startup script is not mandatory.
1286 Status
= EFI_SUCCESS
;
1293 Function to perform the shell prompt looping. It will do a single prompt,
1294 dispatch the result, and then return. It is expected that the caller will
1295 call this function in a loop many times.
1298 @retval RETURN_ABORTED
1308 CONST CHAR16
*CurDir
;
1311 LIST_ENTRY OldBufferList
;
1316 // Get screen setting to decide size of the command line buffer
1318 gST
->ConOut
->QueryMode (gST
->ConOut
, gST
->ConOut
->Mode
->Mode
, &Column
, &Row
);
1319 BufferSize
= Column
* Row
* sizeof (CHAR16
);
1320 CmdLine
= AllocateZeroPool (BufferSize
);
1321 if (CmdLine
== NULL
) {
1322 return EFI_OUT_OF_RESOURCES
;
1325 SaveBufferList(&OldBufferList
);
1326 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
1331 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, gST
->ConOut
->Mode
->CursorRow
);
1333 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
1334 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
1336 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
1340 // Read a line from the console
1342 Status
= ShellInfoObject
.NewEfiShellProtocol
->ReadFile(ShellInfoObject
.NewShellParametersProtocol
->StdIn
, &BufferSize
, CmdLine
);
1345 // Null terminate the string and parse it
1347 if (!EFI_ERROR (Status
)) {
1348 CmdLine
[BufferSize
/ sizeof (CHAR16
)] = CHAR_NULL
;
1349 Status
= RunCommand(CmdLine
);
1353 // Done with this command
1355 RestoreBufferList(&OldBufferList
);
1361 Add a buffer to the Buffer To Free List for safely returning buffers to other
1362 places without risking letting them modify internal shell information.
1364 @param Buffer Something to pass to FreePool when the shell is exiting.
1367 AddBufferToFreeList (
1371 BUFFER_LIST
*BufferListEntry
;
1373 if (Buffer
== NULL
) {
1377 BufferListEntry
= AllocateZeroPool (sizeof (BUFFER_LIST
));
1378 if (BufferListEntry
== NULL
) {
1382 BufferListEntry
->Buffer
= Buffer
;
1383 InsertTailList (&ShellInfoObject
.BufferToFreeList
.Link
, &BufferListEntry
->Link
);
1389 Create a new buffer list and stores the old one to OldBufferList
1391 @param OldBufferList The temporary list head used to store the nodes in BufferToFreeList.
1395 OUT LIST_ENTRY
*OldBufferList
1398 CopyMem (OldBufferList
, &ShellInfoObject
.BufferToFreeList
.Link
, sizeof (LIST_ENTRY
));
1399 InitializeListHead (&ShellInfoObject
.BufferToFreeList
.Link
);
1403 Restore previous nodes into BufferToFreeList .
1405 @param OldBufferList The temporary list head used to store the nodes in BufferToFreeList.
1409 IN OUT LIST_ENTRY
*OldBufferList
1412 FreeBufferList (&ShellInfoObject
.BufferToFreeList
);
1413 CopyMem (&ShellInfoObject
.BufferToFreeList
.Link
, OldBufferList
, sizeof (LIST_ENTRY
));
1418 Add a buffer to the Line History List
1420 @param Buffer The line buffer to add.
1423 AddLineToCommandHistory(
1424 IN CONST CHAR16
*Buffer
1428 BUFFER_LIST
*Walker
;
1429 UINT16 MaxHistoryCmdCount
;
1433 MaxHistoryCmdCount
= PcdGet16(PcdShellMaxHistoryCommandCount
);
1435 if (MaxHistoryCmdCount
== 0) {
1440 Node
= AllocateZeroPool(sizeof(BUFFER_LIST
));
1445 Node
->Buffer
= AllocateCopyPool (StrSize (Buffer
), Buffer
);
1446 if (Node
->Buffer
== NULL
) {
1451 for ( Walker
= (BUFFER_LIST
*)GetFirstNode(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
)
1452 ; !IsNull(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
, &Walker
->Link
)
1453 ; Walker
= (BUFFER_LIST
*)GetNextNode(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
, &Walker
->Link
)
1457 if (Count
< MaxHistoryCmdCount
){
1458 InsertTailList(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
, &Node
->Link
);
1460 Walker
= (BUFFER_LIST
*)GetFirstNode(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
);
1461 RemoveEntryList(&Walker
->Link
);
1462 if (Walker
->Buffer
!= NULL
) {
1463 FreePool(Walker
->Buffer
);
1466 InsertTailList(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
, &Node
->Link
);
1471 Checks if a string is an alias for another command. If yes, then it replaces the alias name
1472 with the correct command name.
1474 @param[in, out] CommandString Upon entry the potential alias. Upon return the
1475 command name if it was an alias. If it was not
1476 an alias it will be unchanged. This function may
1477 change the buffer to fit the command name.
1479 @retval EFI_SUCCESS The name was changed.
1480 @retval EFI_SUCCESS The name was not an alias.
1481 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
1485 IN OUT CHAR16
**CommandString
1488 CONST CHAR16
*NewString
;
1490 NewString
= ShellInfoObject
.NewEfiShellProtocol
->GetAlias(*CommandString
, NULL
);
1491 if (NewString
== NULL
) {
1492 return (EFI_SUCCESS
);
1494 FreePool(*CommandString
);
1495 *CommandString
= AllocateCopyPool(StrSize(NewString
), NewString
);
1496 if (*CommandString
== NULL
) {
1497 return (EFI_OUT_OF_RESOURCES
);
1499 return (EFI_SUCCESS
);
1503 This function will eliminate unreplaced (and therefore non-found) environment variables.
1505 @param[in,out] CmdLine The command line to update.
1508 StripUnreplacedEnvironmentVariables(
1509 IN OUT CHAR16
*CmdLine
1512 CHAR16
*FirstPercent
;
1514 CHAR16
*SecondPercent
;
1515 CHAR16
*SecondQuote
;
1516 CHAR16
*CurrentLocator
;
1518 for (CurrentLocator
= CmdLine
; CurrentLocator
!= NULL
; ) {
1519 FirstQuote
= FindNextInstance(CurrentLocator
, L
"\"", TRUE
);
1520 FirstPercent
= FindNextInstance(CurrentLocator
, L
"%", TRUE
);
1521 SecondPercent
= FirstPercent
!=NULL
?FindNextInstance(FirstPercent
+1, L
"%", TRUE
):NULL
;
1522 if (FirstPercent
== NULL
|| SecondPercent
== NULL
) {
1524 // If we ever don't have 2 % we are done.
1529 if (FirstQuote
!= NULL
&& FirstQuote
< FirstPercent
) {
1530 SecondQuote
= FindNextInstance(FirstQuote
+1, L
"\"", TRUE
);
1532 // Quote is first found
1535 if (SecondQuote
< FirstPercent
) {
1537 // restart after the pair of "
1539 CurrentLocator
= SecondQuote
+ 1;
1540 } else /* FirstPercent < SecondQuote */{
1542 // Restart on the first percent
1544 CurrentLocator
= FirstPercent
;
1549 if (FirstQuote
== NULL
|| SecondPercent
< FirstQuote
) {
1550 if (IsValidEnvironmentVariableName(FirstPercent
, SecondPercent
)) {
1552 // We need to remove from FirstPercent to SecondPercent
1554 CopyMem(FirstPercent
, SecondPercent
+ 1, StrSize(SecondPercent
+ 1));
1556 // don't need to update the locator. both % characters are gone.
1559 CurrentLocator
= SecondPercent
+ 1;
1563 CurrentLocator
= FirstQuote
;
1565 return (EFI_SUCCESS
);
1569 Function allocates a new command line and replaces all instances of environment
1570 variable names that are correctly preset to their values.
1572 If the return value is not NULL the memory must be caller freed.
1574 @param[in] OriginalCommandLine The original command line
1576 @retval NULL An error occurred.
1577 @return The new command line with no environment variables present.
1580 ShellConvertVariables (
1581 IN CONST CHAR16
*OriginalCommandLine
1584 CONST CHAR16
*MasterEnvList
;
1586 CHAR16
*NewCommandLine1
;
1587 CHAR16
*NewCommandLine2
;
1591 SCRIPT_FILE
*CurrentScriptFile
;
1592 ALIAS_LIST
*AliasListNode
;
1594 ASSERT(OriginalCommandLine
!= NULL
);
1597 NewSize
= StrSize(OriginalCommandLine
);
1598 CurrentScriptFile
= ShellCommandGetCurrentScriptFile();
1601 ///@todo update this to handle the %0 - %9 for scripting only (borrow from line 1256 area) ? ? ?
1604 // calculate the size required for the post-conversion string...
1606 if (CurrentScriptFile
!= NULL
) {
1607 for (AliasListNode
= (ALIAS_LIST
*)GetFirstNode(&CurrentScriptFile
->SubstList
)
1608 ; !IsNull(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1609 ; AliasListNode
= (ALIAS_LIST
*)GetNextNode(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1611 for (Temp
= StrStr(OriginalCommandLine
, AliasListNode
->Alias
)
1613 ; Temp
= StrStr(Temp
+1, AliasListNode
->Alias
)
1616 // we need a preceding and if there is space no ^ preceding (if no space ignore)
1618 if ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2)) {
1619 NewSize
+= StrSize(AliasListNode
->CommandString
);
1625 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1626 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
//&& *(MasterEnvList+1) != CHAR_NULL
1627 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1629 if (StrSize(MasterEnvList
) > ItemSize
) {
1630 ItemSize
= StrSize(MasterEnvList
);
1632 for (Temp
= StrStr(OriginalCommandLine
, MasterEnvList
)
1634 ; Temp
= StrStr(Temp
+1, MasterEnvList
)
1637 // we need a preceding and following % and if there is space no ^ preceding (if no space ignore)
1639 if (*(Temp
-1) == L
'%' && *(Temp
+StrLen(MasterEnvList
)) == L
'%' &&
1640 ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2))) {
1641 NewSize
+=StrSize(EfiShellGetEnv(MasterEnvList
));
1647 // now do the replacements...
1649 NewCommandLine1
= AllocateCopyPool(NewSize
, OriginalCommandLine
);
1650 NewCommandLine2
= AllocateZeroPool(NewSize
);
1651 ItemTemp
= AllocateZeroPool(ItemSize
+(2*sizeof(CHAR16
)));
1652 if (NewCommandLine1
== NULL
|| NewCommandLine2
== NULL
|| ItemTemp
== NULL
) {
1653 SHELL_FREE_NON_NULL(NewCommandLine1
);
1654 SHELL_FREE_NON_NULL(NewCommandLine2
);
1655 SHELL_FREE_NON_NULL(ItemTemp
);
1658 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1659 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
1660 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1663 ((ItemSize
+(2*sizeof(CHAR16
)))/sizeof(CHAR16
)),
1667 ((ItemSize
+(2*sizeof(CHAR16
)))/sizeof(CHAR16
)),
1671 ((ItemSize
+(2*sizeof(CHAR16
)))/sizeof(CHAR16
)),
1674 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, ItemTemp
, EfiShellGetEnv(MasterEnvList
), TRUE
, FALSE
);
1675 StrCpyS(NewCommandLine1
, NewSize
/sizeof(CHAR16
), NewCommandLine2
);
1677 if (CurrentScriptFile
!= NULL
) {
1678 for (AliasListNode
= (ALIAS_LIST
*)GetFirstNode(&CurrentScriptFile
->SubstList
)
1679 ; !IsNull(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1680 ; AliasListNode
= (ALIAS_LIST
*)GetNextNode(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1682 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, AliasListNode
->Alias
, AliasListNode
->CommandString
, TRUE
, FALSE
);
1683 StrCpyS(NewCommandLine1
, NewSize
/sizeof(CHAR16
), NewCommandLine2
);
1688 // Remove non-existent environment variables
1690 StripUnreplacedEnvironmentVariables(NewCommandLine1
);
1693 // Now cleanup any straggler intentionally ignored "%" characters
1695 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, L
"^%", L
"%", TRUE
, FALSE
);
1696 StrCpyS(NewCommandLine1
, NewSize
/sizeof(CHAR16
), NewCommandLine2
);
1698 FreePool(NewCommandLine2
);
1701 return (NewCommandLine1
);
1705 Internal function to run a command line with pipe usage.
1707 @param[in] CmdLine The pointer to the command line.
1708 @param[in] StdIn The pointer to the Standard input.
1709 @param[in] StdOut The pointer to the Standard output.
1711 @retval EFI_SUCCESS The split command is executed successfully.
1712 @retval other Some error occurs when executing the split command.
1716 IN CONST CHAR16
*CmdLine
,
1717 IN SHELL_FILE_HANDLE StdIn
,
1718 IN SHELL_FILE_HANDLE StdOut
1722 CHAR16
*NextCommandLine
;
1723 CHAR16
*OurCommandLine
;
1727 SHELL_FILE_HANDLE TempFileHandle
;
1730 ASSERT(StdOut
== NULL
);
1732 ASSERT(StrStr(CmdLine
, L
"|") != NULL
);
1734 Status
= EFI_SUCCESS
;
1735 NextCommandLine
= NULL
;
1736 OurCommandLine
= NULL
;
1740 NextCommandLine
= StrnCatGrow(&NextCommandLine
, &Size1
, StrStr(CmdLine
, L
"|")+1, 0);
1741 OurCommandLine
= StrnCatGrow(&OurCommandLine
, &Size2
, CmdLine
, StrStr(CmdLine
, L
"|") - CmdLine
);
1743 if (NextCommandLine
== NULL
|| OurCommandLine
== NULL
) {
1744 SHELL_FREE_NON_NULL(OurCommandLine
);
1745 SHELL_FREE_NON_NULL(NextCommandLine
);
1746 return (EFI_OUT_OF_RESOURCES
);
1747 } else if (StrStr(OurCommandLine
, L
"|") != NULL
|| Size1
== 0 || Size2
== 0) {
1748 SHELL_FREE_NON_NULL(OurCommandLine
);
1749 SHELL_FREE_NON_NULL(NextCommandLine
);
1750 return (EFI_INVALID_PARAMETER
);
1751 } else if (NextCommandLine
[0] == L
'a' &&
1752 (NextCommandLine
[1] == L
' ' || NextCommandLine
[1] == CHAR_NULL
)
1754 CopyMem(NextCommandLine
, NextCommandLine
+1, StrSize(NextCommandLine
) - sizeof(NextCommandLine
[0]));
1755 while (NextCommandLine
[0] == L
' ') {
1756 CopyMem(NextCommandLine
, NextCommandLine
+1, StrSize(NextCommandLine
) - sizeof(NextCommandLine
[0]));
1758 if (NextCommandLine
[0] == CHAR_NULL
) {
1759 SHELL_FREE_NON_NULL(OurCommandLine
);
1760 SHELL_FREE_NON_NULL(NextCommandLine
);
1761 return (EFI_INVALID_PARAMETER
);
1770 // make a SPLIT_LIST item and add to list
1772 Split
= AllocateZeroPool(sizeof(SPLIT_LIST
));
1773 if (Split
== NULL
) {
1774 return EFI_OUT_OF_RESOURCES
;
1776 Split
->SplitStdIn
= StdIn
;
1777 Split
->SplitStdOut
= ConvertEfiFileProtocolToShellHandle(CreateFileInterfaceMem(Unicode
), NULL
);
1778 ASSERT(Split
->SplitStdOut
!= NULL
);
1779 InsertHeadList(&ShellInfoObject
.SplitList
.Link
, &Split
->Link
);
1781 Status
= RunCommand(OurCommandLine
);
1784 // move the output from the first to the in to the second.
1786 TempFileHandle
= Split
->SplitStdOut
;
1787 if (Split
->SplitStdIn
== StdIn
) {
1788 Split
->SplitStdOut
= NULL
;
1790 Split
->SplitStdOut
= Split
->SplitStdIn
;
1792 Split
->SplitStdIn
= TempFileHandle
;
1793 ShellInfoObject
.NewEfiShellProtocol
->SetFilePosition (Split
->SplitStdIn
, 0);
1795 if (!EFI_ERROR(Status
)) {
1796 Status
= RunCommand(NextCommandLine
);
1800 // remove the top level from the ScriptList
1802 ASSERT((SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
) == Split
);
1803 RemoveEntryList(&Split
->Link
);
1806 // Note that the original StdIn is now the StdOut...
1808 if (Split
->SplitStdOut
!= NULL
) {
1809 ShellInfoObject
.NewEfiShellProtocol
->CloseFile (Split
->SplitStdOut
);
1811 if (Split
->SplitStdIn
!= NULL
) {
1812 ShellInfoObject
.NewEfiShellProtocol
->CloseFile (Split
->SplitStdIn
);
1816 FreePool(NextCommandLine
);
1817 FreePool(OurCommandLine
);
1823 Take the original command line, substitute any variables, free
1824 the original string, return the modified copy.
1826 @param[in] CmdLine pointer to the command line to update.
1828 @retval EFI_SUCCESS the function was successful.
1829 @retval EFI_OUT_OF_RESOURCES a memory allocation failed.
1832 ShellSubstituteVariables(
1837 NewCmdLine
= ShellConvertVariables(*CmdLine
);
1838 SHELL_FREE_NON_NULL(*CmdLine
);
1839 if (NewCmdLine
== NULL
) {
1840 return (EFI_OUT_OF_RESOURCES
);
1842 *CmdLine
= NewCmdLine
;
1843 return (EFI_SUCCESS
);
1847 Take the original command line, substitute any alias in the first group of space delimited characters, free
1848 the original string, return the modified copy.
1850 @param[in] CmdLine pointer to the command line to update.
1852 @retval EFI_SUCCESS the function was successful.
1853 @retval EFI_OUT_OF_RESOURCES a memory allocation failed.
1856 ShellSubstituteAliases(
1861 CHAR16
*CommandName
;
1863 UINTN PostAliasSize
;
1864 ASSERT(CmdLine
!= NULL
);
1865 ASSERT(*CmdLine
!= NULL
);
1869 if (StrStr((*CmdLine
), L
" ") == NULL
){
1870 StrnCatGrow(&CommandName
, NULL
, (*CmdLine
), 0);
1872 StrnCatGrow(&CommandName
, NULL
, (*CmdLine
), StrStr((*CmdLine
), L
" ") - (*CmdLine
));
1876 // This cannot happen 'inline' since the CmdLine can need extra space.
1879 if (!ShellCommandIsCommandOnList(CommandName
)) {
1881 // Convert via alias
1883 Status
= ShellConvertAlias(&CommandName
);
1884 if (EFI_ERROR(Status
)){
1888 NewCmdLine
= StrnCatGrow(&NewCmdLine
, &PostAliasSize
, CommandName
, 0);
1889 if (NewCmdLine
== NULL
) {
1890 SHELL_FREE_NON_NULL(CommandName
);
1891 SHELL_FREE_NON_NULL(*CmdLine
);
1892 return (EFI_OUT_OF_RESOURCES
);
1894 NewCmdLine
= StrnCatGrow(&NewCmdLine
, &PostAliasSize
, StrStr((*CmdLine
), L
" "), 0);
1895 if (NewCmdLine
== NULL
) {
1896 SHELL_FREE_NON_NULL(CommandName
);
1897 SHELL_FREE_NON_NULL(*CmdLine
);
1898 return (EFI_OUT_OF_RESOURCES
);
1901 NewCmdLine
= StrnCatGrow(&NewCmdLine
, NULL
, (*CmdLine
), 0);
1904 SHELL_FREE_NON_NULL(*CmdLine
);
1905 SHELL_FREE_NON_NULL(CommandName
);
1908 // re-assign the passed in double pointer to point to our newly allocated buffer
1910 *CmdLine
= NewCmdLine
;
1912 return (EFI_SUCCESS
);
1916 Takes the Argv[0] part of the command line and determine the meaning of it.
1918 @param[in] CmdName pointer to the command line to update.
1920 @retval Internal_Command The name is an internal command.
1921 @retval File_Sys_Change the name is a file system change.
1922 @retval Script_File_Name the name is a NSH script file.
1923 @retval Unknown_Invalid the name is unknown.
1924 @retval Efi_Application the name is an application (.EFI).
1926 SHELL_OPERATION_TYPES
1928 IN CONST CHAR16
*CmdName
1931 CHAR16
* FileWithPath
;
1932 CONST CHAR16
* TempLocation
;
1933 CONST CHAR16
* TempLocation2
;
1935 FileWithPath
= NULL
;
1937 // test for an internal command.
1939 if (ShellCommandIsCommandOnList(CmdName
)) {
1940 return (Internal_Command
);
1944 // Test for file system change request. anything ending with first : and cant have spaces.
1946 if (CmdName
[(StrLen(CmdName
)-1)] == L
':') {
1947 if ( StrStr(CmdName
, L
" ") != NULL
1948 || StrLen(StrStr(CmdName
, L
":")) > 1
1950 return (Unknown_Invalid
);
1952 return (File_Sys_Change
);
1958 if ((FileWithPath
= ShellFindFilePathEx(CmdName
, mExecutableExtensions
)) != NULL
) {
1960 // See if that file has a script file extension
1962 if (StrLen(FileWithPath
) > 4) {
1963 TempLocation
= FileWithPath
+StrLen(FileWithPath
)-4;
1964 TempLocation2
= mScriptExtension
;
1965 if (StringNoCaseCompare((VOID
*)(&TempLocation
), (VOID
*)(&TempLocation2
)) == 0) {
1966 SHELL_FREE_NON_NULL(FileWithPath
);
1967 return (Script_File_Name
);
1972 // Was a file, but not a script. we treat this as an application.
1974 SHELL_FREE_NON_NULL(FileWithPath
);
1975 return (Efi_Application
);
1978 SHELL_FREE_NON_NULL(FileWithPath
);
1980 // No clue what this is... return invalid flag...
1982 return (Unknown_Invalid
);
1986 Determine if the first item in a command line is valid.
1988 @param[in] CmdLine The command line to parse.
1990 @retval EFI_SUCCESS The item is valid.
1991 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
1992 @retval EFI_NOT_FOUND The operation type is unknown or invalid.
1996 IN CONST CHAR16
*CmdLine
2000 CHAR16
*FirstParameter
;
2006 Temp
= StrnCatGrow(&Temp
, NULL
, CmdLine
, 0);
2008 return (EFI_OUT_OF_RESOURCES
);
2011 FirstParameter
= StrStr(Temp
, L
"|");
2012 if (FirstParameter
!= NULL
) {
2013 *FirstParameter
= CHAR_NULL
;
2016 FirstParameter
= NULL
;
2019 // Process the command line
2021 Status
= ProcessCommandLineToFinal(&Temp
);
2023 if (!EFI_ERROR(Status
)) {
2024 FirstParameter
= AllocateZeroPool(StrSize(CmdLine
));
2025 if (FirstParameter
== NULL
) {
2026 SHELL_FREE_NON_NULL(Temp
);
2027 return (EFI_OUT_OF_RESOURCES
);
2029 TempWalker
= (CHAR16
*)Temp
;
2030 if (!EFI_ERROR(GetNextParameter(&TempWalker
, &FirstParameter
, StrSize(CmdLine
), TRUE
))) {
2031 if (GetOperationType(FirstParameter
) == Unknown_Invalid
) {
2032 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2033 SetLastError(SHELL_NOT_FOUND
);
2034 Status
= EFI_NOT_FOUND
;
2039 SHELL_FREE_NON_NULL(Temp
);
2040 SHELL_FREE_NON_NULL(FirstParameter
);
2045 Determine if a command line contains with a split contains only valid commands.
2047 @param[in] CmdLine The command line to parse.
2049 @retval EFI_SUCCESS CmdLine has only valid commands, application, or has no split.
2050 @retval EFI_ABORTED CmdLine has at least one invalid command or application.
2054 IN CONST CHAR16
*CmdLine
2057 CONST CHAR16
*TempSpot
;
2061 // If this was the only item, then get out
2063 if (!ContainsSplit(CmdLine
)) {
2064 return (EFI_SUCCESS
);
2068 // Verify up to the pipe or end character
2070 Status
= IsValidSplit(CmdLine
);
2071 if (EFI_ERROR(Status
)) {
2076 // recurse to verify the next item
2078 TempSpot
= FindFirstCharacter(CmdLine
, L
"|", L
'^') + 1;
2079 if (*TempSpot
== L
'a' &&
2080 (*(TempSpot
+ 1) == L
' ' || *(TempSpot
+ 1) == CHAR_NULL
)
2082 // If it's an ASCII pipe '|a'
2086 return (VerifySplit(TempSpot
));
2090 Process a split based operation.
2092 @param[in] CmdLine pointer to the command line to process
2094 @retval EFI_SUCCESS The operation was successful
2095 @return an error occurred.
2098 ProcessNewSplitCommandLine(
2099 IN CONST CHAR16
*CmdLine
2105 Status
= VerifySplit(CmdLine
);
2106 if (EFI_ERROR(Status
)) {
2113 // are we in an existing split???
2115 if (!IsListEmpty(&ShellInfoObject
.SplitList
.Link
)) {
2116 Split
= (SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
);
2119 if (Split
== NULL
) {
2120 Status
= RunSplitCommand(CmdLine
, NULL
, NULL
);
2122 Status
= RunSplitCommand(CmdLine
, Split
->SplitStdIn
, Split
->SplitStdOut
);
2124 if (EFI_ERROR(Status
)) {
2125 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_SPLIT
), ShellInfoObject
.HiiHandle
, CmdLine
);
2131 Handle a request to change the current file system.
2133 @param[in] CmdLine The passed in command line.
2135 @retval EFI_SUCCESS The operation was successful.
2139 IN CONST CHAR16
*CmdLine
2143 Status
= EFI_SUCCESS
;
2146 // make sure we are the right operation
2148 ASSERT(CmdLine
[(StrLen(CmdLine
)-1)] == L
':' && StrStr(CmdLine
, L
" ") == NULL
);
2151 // Call the protocol API to do the work
2153 Status
= ShellInfoObject
.NewEfiShellProtocol
->SetCurDir(NULL
, CmdLine
);
2156 // Report any errors
2158 if (EFI_ERROR(Status
)) {
2159 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_MAPPING
), ShellInfoObject
.HiiHandle
, CmdLine
);
2166 Reprocess the command line to direct all -? to the help command.
2168 if found, will add "help" as argv[0], and move the rest later.
2170 @param[in,out] CmdLine pointer to the command line to update
2174 IN OUT CHAR16
**CmdLine
2177 CHAR16
*CurrentParameter
;
2179 CHAR16
*NewCommandLine
;
2181 UINTN NewCmdLineSize
;
2183 Status
= EFI_SUCCESS
;
2185 CurrentParameter
= AllocateZeroPool(StrSize(*CmdLine
));
2186 if (CurrentParameter
== NULL
) {
2187 return (EFI_OUT_OF_RESOURCES
);
2191 while(Walker
!= NULL
&& *Walker
!= CHAR_NULL
) {
2192 if (!EFI_ERROR(GetNextParameter(&Walker
, &CurrentParameter
, StrSize(*CmdLine
), TRUE
))) {
2193 if (StrStr(CurrentParameter
, L
"-?") == CurrentParameter
) {
2194 CurrentParameter
[0] = L
' ';
2195 CurrentParameter
[1] = L
' ';
2196 NewCmdLineSize
= StrSize(L
"help ") + StrSize(*CmdLine
);
2197 NewCommandLine
= AllocateZeroPool(NewCmdLineSize
);
2198 if (NewCommandLine
== NULL
) {
2199 Status
= EFI_OUT_OF_RESOURCES
;
2204 // We know the space is sufficient since we just calculated it.
2206 StrnCpyS(NewCommandLine
, NewCmdLineSize
/sizeof(CHAR16
), L
"help ", 5);
2207 StrnCatS(NewCommandLine
, NewCmdLineSize
/sizeof(CHAR16
), *CmdLine
, StrLen(*CmdLine
));
2208 SHELL_FREE_NON_NULL(*CmdLine
);
2209 *CmdLine
= NewCommandLine
;
2215 SHELL_FREE_NON_NULL(CurrentParameter
);
2221 Function to update the shell variable "lasterror".
2223 @param[in] ErrorCode the error code to put into lasterror.
2227 IN CONST SHELL_STATUS ErrorCode
2230 CHAR16 LeString
[19];
2231 if (sizeof(EFI_STATUS
) == sizeof(UINT64
)) {
2232 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%Lx", ErrorCode
);
2234 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%x", ErrorCode
);
2236 DEBUG_CODE(InternalEfiShellSetEnv(L
"debuglasterror", LeString
, TRUE
););
2237 InternalEfiShellSetEnv(L
"lasterror", LeString
, TRUE
);
2239 return (EFI_SUCCESS
);
2243 Converts the command line to it's post-processed form. this replaces variables and alias' per UEFI Shell spec.
2245 @param[in,out] CmdLine pointer to the command line to update
2247 @retval EFI_SUCCESS The operation was successful
2248 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
2249 @return some other error occurred
2252 ProcessCommandLineToFinal(
2253 IN OUT CHAR16
**CmdLine
2257 TrimSpaces(CmdLine
);
2259 Status
= ShellSubstituteAliases(CmdLine
);
2260 if (EFI_ERROR(Status
)) {
2264 TrimSpaces(CmdLine
);
2266 Status
= ShellSubstituteVariables(CmdLine
);
2267 if (EFI_ERROR(Status
)) {
2270 ASSERT (*CmdLine
!= NULL
);
2272 TrimSpaces(CmdLine
);
2275 // update for help parsing
2277 if (StrStr(*CmdLine
, L
"?") != NULL
) {
2279 // This may do nothing if the ? does not indicate help.
2280 // Save all the details for in the API below.
2282 Status
= DoHelpUpdate(CmdLine
);
2285 TrimSpaces(CmdLine
);
2287 return (EFI_SUCCESS
);
2291 Run an internal shell command.
2293 This API will update the shell's environment since these commands are libraries.
2295 @param[in] CmdLine the command line to run.
2296 @param[in] FirstParameter the first parameter on the command line
2297 @param[in] ParamProtocol the shell parameters protocol pointer
2298 @param[out] CommandStatus the status from the command line.
2300 @retval EFI_SUCCESS The command was completed.
2301 @retval EFI_ABORTED The command's operation was aborted.
2305 IN CONST CHAR16
*CmdLine
,
2306 IN CHAR16
*FirstParameter
,
2307 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2308 OUT EFI_STATUS
*CommandStatus
2314 SHELL_STATUS CommandReturnedStatus
;
2319 NewCmdLine
= AllocateCopyPool (StrSize (CmdLine
), CmdLine
);
2320 if (NewCmdLine
== NULL
) {
2321 return EFI_OUT_OF_RESOURCES
;
2324 for (Walker
= NewCmdLine
; Walker
!= NULL
&& *Walker
!= CHAR_NULL
; Walker
++) {
2325 if (*Walker
== L
'^' && *(Walker
+1) == L
'#') {
2326 CopyMem(Walker
, Walker
+1, StrSize(Walker
) - sizeof(Walker
[0]));
2331 // get the argc and argv updated for internal commands
2333 Status
= UpdateArgcArgv(ParamProtocol
, NewCmdLine
, Internal_Command
, &Argv
, &Argc
);
2334 if (!EFI_ERROR(Status
)) {
2336 // Run the internal command.
2338 Status
= ShellCommandRunCommandHandler(FirstParameter
, &CommandReturnedStatus
, &LastError
);
2340 if (!EFI_ERROR(Status
)) {
2341 if (CommandStatus
!= NULL
) {
2342 if (CommandReturnedStatus
!= SHELL_SUCCESS
) {
2343 *CommandStatus
= (EFI_STATUS
)(CommandReturnedStatus
| MAX_BIT
);
2345 *CommandStatus
= EFI_SUCCESS
;
2350 // Update last error status.
2351 // some commands do not update last error.
2354 SetLastError(CommandReturnedStatus
);
2358 // Pass thru the exitcode from the app.
2360 if (ShellCommandGetExit()) {
2362 // An Exit was requested ("exit" command), pass its value up.
2364 Status
= CommandReturnedStatus
;
2365 } else if (CommandReturnedStatus
!= SHELL_SUCCESS
&& IsScriptOnlyCommand(FirstParameter
)) {
2367 // Always abort when a script only command fails for any reason
2369 Status
= EFI_ABORTED
;
2370 } else if (ShellCommandGetCurrentScriptFile() != NULL
&& CommandReturnedStatus
== SHELL_ABORTED
) {
2372 // Abort when in a script and a command aborted
2374 Status
= EFI_ABORTED
;
2380 // This is guaranteed to be called after UpdateArgcArgv no matter what else happened.
2381 // This is safe even if the update API failed. In this case, it may be a no-op.
2383 RestoreArgcArgv(ParamProtocol
, &Argv
, &Argc
);
2386 // If a script is running and the command is not a script only command, then
2387 // change return value to success so the script won't halt (unless aborted).
2389 // Script only commands have to be able halt the script since the script will
2390 // not operate if they are failing.
2392 if ( ShellCommandGetCurrentScriptFile() != NULL
2393 && !IsScriptOnlyCommand(FirstParameter
)
2394 && Status
!= EFI_ABORTED
2396 Status
= EFI_SUCCESS
;
2399 FreePool (NewCmdLine
);
2404 Function to run the command or file.
2406 @param[in] Type the type of operation being run.
2407 @param[in] CmdLine the command line to run.
2408 @param[in] FirstParameter the first parameter on the command line
2409 @param[in] ParamProtocol the shell parameters protocol pointer
2410 @param[out] CommandStatus the status from the command line.
2412 @retval EFI_SUCCESS The command was completed.
2413 @retval EFI_ABORTED The command's operation was aborted.
2417 IN SHELL_OPERATION_TYPES Type
,
2418 IN CONST CHAR16
*CmdLine
,
2419 IN CHAR16
*FirstParameter
,
2420 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2421 OUT EFI_STATUS
*CommandStatus
2425 EFI_STATUS StartStatus
;
2426 CHAR16
*CommandWithPath
;
2427 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
2428 SHELL_STATUS CalleeExitStatus
;
2430 Status
= EFI_SUCCESS
;
2431 CommandWithPath
= NULL
;
2433 CalleeExitStatus
= SHELL_INVALID_PARAMETER
;
2436 case Internal_Command
:
2437 Status
= RunInternalCommand(CmdLine
, FirstParameter
, ParamProtocol
, CommandStatus
);
2439 case Script_File_Name
:
2440 case Efi_Application
:
2442 // Process a fully qualified path
2444 if (StrStr(FirstParameter
, L
":") != NULL
) {
2445 ASSERT (CommandWithPath
== NULL
);
2446 if (ShellIsFile(FirstParameter
) == EFI_SUCCESS
) {
2447 CommandWithPath
= StrnCatGrow(&CommandWithPath
, NULL
, FirstParameter
, 0);
2452 // Process a relative path and also check in the path environment variable
2454 if (CommandWithPath
== NULL
) {
2455 CommandWithPath
= ShellFindFilePathEx(FirstParameter
, mExecutableExtensions
);
2459 // This should be impossible now.
2461 ASSERT(CommandWithPath
!= NULL
);
2464 // Make sure that path is not just a directory (or not found)
2466 if (!EFI_ERROR(ShellIsDirectory(CommandWithPath
))) {
2467 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2468 SetLastError(SHELL_NOT_FOUND
);
2471 case Script_File_Name
:
2472 Status
= RunScriptFile (CommandWithPath
, NULL
, CmdLine
, ParamProtocol
);
2474 case Efi_Application
:
2476 // Get the device path of the application image
2478 DevPath
= ShellInfoObject
.NewEfiShellProtocol
->GetDevicePathFromFilePath(CommandWithPath
);
2479 if (DevPath
== NULL
){
2480 Status
= EFI_OUT_OF_RESOURCES
;
2485 // Execute the device path
2487 Status
= InternalShellExecuteDevicePath(
2495 SHELL_FREE_NON_NULL(DevPath
);
2497 if(EFI_ERROR (Status
)) {
2498 CalleeExitStatus
= (SHELL_STATUS
) (Status
& (~MAX_BIT
));
2500 CalleeExitStatus
= (SHELL_STATUS
) StartStatus
;
2503 if (CommandStatus
!= NULL
) {
2504 *CommandStatus
= CalleeExitStatus
;
2508 // Update last error status.
2510 // Status is an EFI_STATUS. Clear top bit to convert to SHELL_STATUS
2511 SetLastError(CalleeExitStatus
);
2527 SHELL_FREE_NON_NULL(CommandWithPath
);
2533 Function to setup StdIn, StdErr, StdOut, and then run the command or file.
2535 @param[in] Type the type of operation being run.
2536 @param[in] CmdLine the command line to run.
2537 @param[in] FirstParameter the first parameter on the command line.
2538 @param[in] ParamProtocol the shell parameters protocol pointer
2539 @param[out] CommandStatus the status from the command line.
2541 @retval EFI_SUCCESS The command was completed.
2542 @retval EFI_ABORTED The command's operation was aborted.
2545 SetupAndRunCommandOrFile(
2546 IN SHELL_OPERATION_TYPES Type
,
2548 IN CHAR16
*FirstParameter
,
2549 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2550 OUT EFI_STATUS
*CommandStatus
2554 SHELL_FILE_HANDLE OriginalStdIn
;
2555 SHELL_FILE_HANDLE OriginalStdOut
;
2556 SHELL_FILE_HANDLE OriginalStdErr
;
2557 SYSTEM_TABLE_INFO OriginalSystemTableInfo
;
2558 CONST SCRIPT_FILE
*ConstScriptFile
;
2561 // Update the StdIn, StdOut, and StdErr for redirection to environment variables, files, etc... unicode and ASCII
2563 Status
= UpdateStdInStdOutStdErr(ParamProtocol
, CmdLine
, &OriginalStdIn
, &OriginalStdOut
, &OriginalStdErr
, &OriginalSystemTableInfo
);
2566 // The StdIn, StdOut, and StdErr are set up.
2567 // Now run the command, script, or application
2569 if (!EFI_ERROR(Status
)) {
2570 TrimSpaces(&CmdLine
);
2571 Status
= RunCommandOrFile(Type
, CmdLine
, FirstParameter
, ParamProtocol
, CommandStatus
);
2577 if (EFI_ERROR(Status
)) {
2578 ConstScriptFile
= ShellCommandGetCurrentScriptFile();
2579 if (ConstScriptFile
== NULL
|| ConstScriptFile
->CurrentCommand
== NULL
) {
2580 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_ERROR
), ShellInfoObject
.HiiHandle
, (VOID
*)(Status
));
2582 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_ERROR_SCRIPT
), ShellInfoObject
.HiiHandle
, (VOID
*)(Status
), ConstScriptFile
->CurrentCommand
->Line
);
2587 // put back the original StdIn, StdOut, and StdErr
2589 RestoreStdInStdOutStdErr(ParamProtocol
, &OriginalStdIn
, &OriginalStdOut
, &OriginalStdErr
, &OriginalSystemTableInfo
);
2595 Function will process and run a command line.
2597 This will determine if the command line represents an internal shell
2598 command or dispatch an external application.
2600 @param[in] CmdLine The command line to parse.
2601 @param[out] CommandStatus The status from the command line.
2603 @retval EFI_SUCCESS The command was completed.
2604 @retval EFI_ABORTED The command's operation was aborted.
2608 IN CONST CHAR16
*CmdLine
,
2609 OUT EFI_STATUS
*CommandStatus
2613 CHAR16
*CleanOriginal
;
2614 CHAR16
*FirstParameter
;
2616 SHELL_OPERATION_TYPES Type
;
2618 ASSERT(CmdLine
!= NULL
);
2619 if (StrLen(CmdLine
) == 0) {
2620 return (EFI_SUCCESS
);
2623 Status
= EFI_SUCCESS
;
2624 CleanOriginal
= NULL
;
2626 CleanOriginal
= StrnCatGrow(&CleanOriginal
, NULL
, CmdLine
, 0);
2627 if (CleanOriginal
== NULL
) {
2628 return (EFI_OUT_OF_RESOURCES
);
2631 TrimSpaces(&CleanOriginal
);
2634 // NULL out comments (leveraged from RunScriptFileHandle() ).
2635 // The # character on a line is used to denote that all characters on the same line
2636 // and to the right of the # are to be ignored by the shell.
2637 // Afterwards, again remove spaces, in case any were between the last command-parameter and '#'.
2639 for (TempWalker
= CleanOriginal
; TempWalker
!= NULL
&& *TempWalker
!= CHAR_NULL
; TempWalker
++) {
2640 if (*TempWalker
== L
'^') {
2641 if (*(TempWalker
+ 1) == L
'#') {
2644 } else if (*TempWalker
== L
'#') {
2645 *TempWalker
= CHAR_NULL
;
2649 TrimSpaces(&CleanOriginal
);
2652 // Handle case that passed in command line is just 1 or more " " characters.
2654 if (StrLen (CleanOriginal
) == 0) {
2655 SHELL_FREE_NON_NULL(CleanOriginal
);
2656 return (EFI_SUCCESS
);
2659 Status
= ProcessCommandLineToFinal(&CleanOriginal
);
2660 if (EFI_ERROR(Status
)) {
2661 SHELL_FREE_NON_NULL(CleanOriginal
);
2666 // We don't do normal processing with a split command line (output from one command input to another)
2668 if (ContainsSplit(CleanOriginal
)) {
2669 Status
= ProcessNewSplitCommandLine(CleanOriginal
);
2670 SHELL_FREE_NON_NULL(CleanOriginal
);
2675 // We need the first parameter information so we can determine the operation type
2677 FirstParameter
= AllocateZeroPool(StrSize(CleanOriginal
));
2678 if (FirstParameter
== NULL
) {
2679 SHELL_FREE_NON_NULL(CleanOriginal
);
2680 return (EFI_OUT_OF_RESOURCES
);
2682 TempWalker
= CleanOriginal
;
2683 if (!EFI_ERROR(GetNextParameter(&TempWalker
, &FirstParameter
, StrSize(CleanOriginal
), TRUE
))) {
2685 // Depending on the first parameter we change the behavior
2687 switch (Type
= GetOperationType(FirstParameter
)) {
2688 case File_Sys_Change
:
2689 Status
= ChangeMappedDrive (FirstParameter
);
2691 case Internal_Command
:
2692 case Script_File_Name
:
2693 case Efi_Application
:
2694 Status
= SetupAndRunCommandOrFile(Type
, CleanOriginal
, FirstParameter
, ShellInfoObject
.NewShellParametersProtocol
, CommandStatus
);
2698 // Whatever was typed, it was invalid.
2700 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2701 SetLastError(SHELL_NOT_FOUND
);
2705 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2706 SetLastError(SHELL_NOT_FOUND
);
2709 SHELL_FREE_NON_NULL(CleanOriginal
);
2710 SHELL_FREE_NON_NULL(FirstParameter
);
2716 Function will process and run a command line.
2718 This will determine if the command line represents an internal shell
2719 command or dispatch an external application.
2721 @param[in] CmdLine The command line to parse.
2723 @retval EFI_SUCCESS The command was completed.
2724 @retval EFI_ABORTED The command's operation was aborted.
2728 IN CONST CHAR16
*CmdLine
2731 return (RunShellCommand(CmdLine
, NULL
));
2735 STATIC CONST UINT16 InvalidChars
[] = {L
'*', L
'?', L
'<', L
'>', L
'\\', L
'/', L
'\"', 0x0001, 0x0002};
2737 Function determines if the CommandName COULD be a valid command. It does not determine whether
2738 this is a valid command. It only checks for invalid characters.
2740 @param[in] CommandName The name to check
2742 @retval TRUE CommandName could be a command name
2743 @retval FALSE CommandName could not be a valid command name
2747 IN CONST CHAR16
*CommandName
2751 if (CommandName
== NULL
) {
2756 ; Count
< sizeof(InvalidChars
) / sizeof(InvalidChars
[0])
2759 if (ScanMem16(CommandName
, StrSize(CommandName
), InvalidChars
[Count
]) != NULL
) {
2767 Function to process a NSH script file via SHELL_FILE_HANDLE.
2769 @param[in] Handle The handle to the already opened file.
2770 @param[in] Name The name of the script file.
2772 @retval EFI_SUCCESS the script completed successfully
2775 RunScriptFileHandle (
2776 IN SHELL_FILE_HANDLE Handle
,
2777 IN CONST CHAR16
*Name
2781 SCRIPT_FILE
*NewScriptFile
;
2783 UINTN PrintBuffSize
;
2784 CHAR16
*CommandLine
;
2785 CHAR16
*CommandLine2
;
2786 CHAR16
*CommandLine3
;
2787 SCRIPT_COMMAND_LIST
*LastCommand
;
2789 BOOLEAN PreScriptEchoState
;
2790 BOOLEAN PreCommandEchoState
;
2791 CONST CHAR16
*CurDir
;
2793 CHAR16 LeString
[50];
2794 LIST_ENTRY OldBufferList
;
2796 ASSERT(!ShellCommandGetScriptExit());
2798 PreScriptEchoState
= ShellCommandGetEchoState();
2799 PrintBuffSize
= PcdGet16(PcdShellPrintBufferSize
);
2801 NewScriptFile
= (SCRIPT_FILE
*)AllocateZeroPool(sizeof(SCRIPT_FILE
));
2802 if (NewScriptFile
== NULL
) {
2803 return (EFI_OUT_OF_RESOURCES
);
2809 ASSERT(NewScriptFile
->ScriptName
== NULL
);
2810 NewScriptFile
->ScriptName
= StrnCatGrow(&NewScriptFile
->ScriptName
, NULL
, Name
, 0);
2811 if (NewScriptFile
->ScriptName
== NULL
) {
2812 DeleteScriptFileStruct(NewScriptFile
);
2813 return (EFI_OUT_OF_RESOURCES
);
2817 // Save the parameters (used to replace %0 to %9 later on)
2819 NewScriptFile
->Argc
= ShellInfoObject
.NewShellParametersProtocol
->Argc
;
2820 if (NewScriptFile
->Argc
!= 0) {
2821 NewScriptFile
->Argv
= (CHAR16
**)AllocateZeroPool(NewScriptFile
->Argc
* sizeof(CHAR16
*));
2822 if (NewScriptFile
->Argv
== NULL
) {
2823 DeleteScriptFileStruct(NewScriptFile
);
2824 return (EFI_OUT_OF_RESOURCES
);
2826 for (LoopVar
= 0 ; LoopVar
< 10 && LoopVar
< NewScriptFile
->Argc
; LoopVar
++) {
2827 ASSERT(NewScriptFile
->Argv
[LoopVar
] == NULL
);
2828 NewScriptFile
->Argv
[LoopVar
] = StrnCatGrow(&NewScriptFile
->Argv
[LoopVar
], NULL
, ShellInfoObject
.NewShellParametersProtocol
->Argv
[LoopVar
], 0);
2829 if (NewScriptFile
->Argv
[LoopVar
] == NULL
) {
2830 DeleteScriptFileStruct(NewScriptFile
);
2831 return (EFI_OUT_OF_RESOURCES
);
2835 NewScriptFile
->Argv
= NULL
;
2838 InitializeListHead(&NewScriptFile
->CommandList
);
2839 InitializeListHead(&NewScriptFile
->SubstList
);
2842 // Now build the list of all script commands.
2845 while(!ShellFileHandleEof(Handle
)) {
2846 CommandLine
= ShellFileHandleReturnLine(Handle
, &Ascii
);
2848 if (CommandLine
== NULL
|| StrLen(CommandLine
) == 0 || CommandLine
[0] == '#') {
2849 SHELL_FREE_NON_NULL(CommandLine
);
2852 NewScriptFile
->CurrentCommand
= AllocateZeroPool(sizeof(SCRIPT_COMMAND_LIST
));
2853 if (NewScriptFile
->CurrentCommand
== NULL
) {
2854 SHELL_FREE_NON_NULL(CommandLine
);
2855 DeleteScriptFileStruct(NewScriptFile
);
2856 return (EFI_OUT_OF_RESOURCES
);
2859 NewScriptFile
->CurrentCommand
->Cl
= CommandLine
;
2860 NewScriptFile
->CurrentCommand
->Data
= NULL
;
2861 NewScriptFile
->CurrentCommand
->Line
= LineCount
;
2863 InsertTailList(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
2867 // Add this as the topmost script file
2869 ShellCommandSetNewScript (NewScriptFile
);
2872 // Now enumerate through the commands and run each one.
2874 CommandLine
= AllocateZeroPool(PrintBuffSize
);
2875 if (CommandLine
== NULL
) {
2876 DeleteScriptFileStruct(NewScriptFile
);
2877 return (EFI_OUT_OF_RESOURCES
);
2879 CommandLine2
= AllocateZeroPool(PrintBuffSize
);
2880 if (CommandLine2
== NULL
) {
2881 FreePool(CommandLine
);
2882 DeleteScriptFileStruct(NewScriptFile
);
2883 return (EFI_OUT_OF_RESOURCES
);
2886 for ( NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetFirstNode(&NewScriptFile
->CommandList
)
2887 ; !IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)
2888 ; // conditional increment in the body of the loop
2890 ASSERT(CommandLine2
!= NULL
);
2891 StrnCpyS( CommandLine2
,
2892 PrintBuffSize
/sizeof(CHAR16
),
2893 NewScriptFile
->CurrentCommand
->Cl
,
2894 PrintBuffSize
/sizeof(CHAR16
) - 1
2897 SaveBufferList(&OldBufferList
);
2900 // NULL out comments
2902 for (CommandLine3
= CommandLine2
; CommandLine3
!= NULL
&& *CommandLine3
!= CHAR_NULL
; CommandLine3
++) {
2903 if (*CommandLine3
== L
'^') {
2904 if ( *(CommandLine3
+1) == L
':') {
2905 CopyMem(CommandLine3
, CommandLine3
+1, StrSize(CommandLine3
) - sizeof(CommandLine3
[0]));
2906 } else if (*(CommandLine3
+1) == L
'#') {
2909 } else if (*CommandLine3
== L
'#') {
2910 *CommandLine3
= CHAR_NULL
;
2914 if (CommandLine2
!= NULL
&& StrLen(CommandLine2
) >= 1) {
2916 // Due to variability in starting the find and replace action we need to have both buffers the same.
2918 StrnCpyS( CommandLine
,
2919 PrintBuffSize
/sizeof(CHAR16
),
2921 PrintBuffSize
/sizeof(CHAR16
) - 1
2925 // Remove the %0 to %9 from the command line (if we have some arguments)
2927 if (NewScriptFile
->Argv
!= NULL
) {
2928 switch (NewScriptFile
->Argc
) {
2930 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%9", NewScriptFile
->Argv
[9], FALSE
, FALSE
);
2931 ASSERT_EFI_ERROR(Status
);
2933 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%8", NewScriptFile
->Argv
[8], FALSE
, FALSE
);
2934 ASSERT_EFI_ERROR(Status
);
2936 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%7", NewScriptFile
->Argv
[7], FALSE
, FALSE
);
2937 ASSERT_EFI_ERROR(Status
);
2939 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%6", NewScriptFile
->Argv
[6], FALSE
, FALSE
);
2940 ASSERT_EFI_ERROR(Status
);
2942 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%5", NewScriptFile
->Argv
[5], FALSE
, FALSE
);
2943 ASSERT_EFI_ERROR(Status
);
2945 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%4", NewScriptFile
->Argv
[4], FALSE
, FALSE
);
2946 ASSERT_EFI_ERROR(Status
);
2948 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%3", NewScriptFile
->Argv
[3], FALSE
, FALSE
);
2949 ASSERT_EFI_ERROR(Status
);
2951 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%2", NewScriptFile
->Argv
[2], FALSE
, FALSE
);
2952 ASSERT_EFI_ERROR(Status
);
2954 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%1", NewScriptFile
->Argv
[1], FALSE
, FALSE
);
2955 ASSERT_EFI_ERROR(Status
);
2957 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%0", NewScriptFile
->Argv
[0], FALSE
, FALSE
);
2958 ASSERT_EFI_ERROR(Status
);
2964 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%1", L
"\"\"", FALSE
, FALSE
);
2965 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%2", L
"\"\"", FALSE
, FALSE
);
2966 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%3", L
"\"\"", FALSE
, FALSE
);
2967 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%4", L
"\"\"", FALSE
, FALSE
);
2968 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%5", L
"\"\"", FALSE
, FALSE
);
2969 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%6", L
"\"\"", FALSE
, FALSE
);
2970 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%7", L
"\"\"", FALSE
, FALSE
);
2971 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PrintBuffSize
, L
"%8", L
"\"\"", FALSE
, FALSE
);
2972 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PrintBuffSize
, L
"%9", L
"\"\"", FALSE
, FALSE
);
2974 StrnCpyS( CommandLine2
,
2975 PrintBuffSize
/sizeof(CHAR16
),
2977 PrintBuffSize
/sizeof(CHAR16
) - 1
2980 LastCommand
= NewScriptFile
->CurrentCommand
;
2982 for (CommandLine3
= CommandLine2
; CommandLine3
[0] == L
' ' ; CommandLine3
++);
2984 if (CommandLine3
!= NULL
&& CommandLine3
[0] == L
':' ) {
2986 // This line is a goto target / label
2989 if (CommandLine3
!= NULL
&& StrLen(CommandLine3
) > 0) {
2990 if (CommandLine3
[0] == L
'@') {
2992 // We need to save the current echo state
2993 // and disable echo for just this command.
2995 PreCommandEchoState
= ShellCommandGetEchoState();
2996 ShellCommandSetEchoState(FALSE
);
2997 Status
= RunCommand(CommandLine3
+1);
3000 // If command was "@echo -off" or "@echo -on" then don't restore echo state
3002 if (StrCmp (L
"@echo -off", CommandLine3
) != 0 &&
3003 StrCmp (L
"@echo -on", CommandLine3
) != 0) {
3005 // Now restore the pre-'@' echo state.
3007 ShellCommandSetEchoState(PreCommandEchoState
);
3010 if (ShellCommandGetEchoState()) {
3011 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
3012 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
3013 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
3015 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
3017 ShellPrintEx(-1, -1, L
"%s\r\n", CommandLine2
);
3019 Status
= RunCommand(CommandLine3
);
3023 if (ShellCommandGetScriptExit()) {
3025 // ShellCommandGetExitCode() always returns a UINT64
3027 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%Lx", ShellCommandGetExitCode());
3028 DEBUG_CODE(InternalEfiShellSetEnv(L
"debuglasterror", LeString
, TRUE
););
3029 InternalEfiShellSetEnv(L
"lasterror", LeString
, TRUE
);
3031 ShellCommandRegisterExit(FALSE
, 0);
3032 Status
= EFI_SUCCESS
;
3033 RestoreBufferList(&OldBufferList
);
3036 if (ShellGetExecutionBreakFlag()) {
3037 RestoreBufferList(&OldBufferList
);
3040 if (EFI_ERROR(Status
)) {
3041 RestoreBufferList(&OldBufferList
);
3044 if (ShellCommandGetExit()) {
3045 RestoreBufferList(&OldBufferList
);
3050 // If that commend did not update the CurrentCommand then we need to advance it...
3052 if (LastCommand
== NewScriptFile
->CurrentCommand
) {
3053 NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetNextNode(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
3054 if (!IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)) {
3055 NewScriptFile
->CurrentCommand
->Reset
= TRUE
;
3059 NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetNextNode(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
3060 if (!IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)) {
3061 NewScriptFile
->CurrentCommand
->Reset
= TRUE
;
3064 RestoreBufferList(&OldBufferList
);
3068 FreePool(CommandLine
);
3069 FreePool(CommandLine2
);
3070 ShellCommandSetNewScript (NULL
);
3073 // Only if this was the last script reset the state.
3075 if (ShellCommandGetCurrentScriptFile()==NULL
) {
3076 ShellCommandSetEchoState(PreScriptEchoState
);
3078 return (EFI_SUCCESS
);
3082 Function to process a NSH script file.
3084 @param[in] ScriptPath Pointer to the script file name (including file system path).
3085 @param[in] Handle the handle of the script file already opened.
3086 @param[in] CmdLine the command line to run.
3087 @param[in] ParamProtocol the shell parameters protocol pointer
3089 @retval EFI_SUCCESS the script completed successfully
3093 IN CONST CHAR16
*ScriptPath
,
3094 IN SHELL_FILE_HANDLE Handle OPTIONAL
,
3095 IN CONST CHAR16
*CmdLine
,
3096 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
3100 SHELL_FILE_HANDLE FileHandle
;
3104 if (ShellIsFile(ScriptPath
) != EFI_SUCCESS
) {
3105 return (EFI_INVALID_PARAMETER
);
3109 // get the argc and argv updated for scripts
3111 Status
= UpdateArgcArgv(ParamProtocol
, CmdLine
, Script_File_Name
, &Argv
, &Argc
);
3112 if (!EFI_ERROR(Status
)) {
3114 if (Handle
== NULL
) {
3118 Status
= ShellOpenFileByName(ScriptPath
, &FileHandle
, EFI_FILE_MODE_READ
, 0);
3119 if (!EFI_ERROR(Status
)) {
3123 Status
= RunScriptFileHandle(FileHandle
, ScriptPath
);
3126 // now close the file
3128 ShellCloseFile(&FileHandle
);
3131 Status
= RunScriptFileHandle(Handle
, ScriptPath
);
3136 // This is guaranteed to be called after UpdateArgcArgv no matter what else happened.
3137 // This is safe even if the update API failed. In this case, it may be a no-op.
3139 RestoreArgcArgv(ParamProtocol
, &Argv
, &Argc
);
3145 Return the pointer to the first occurrence of any character from a list of characters.
3147 @param[in] String the string to parse
3148 @param[in] CharacterList the list of character to look for
3149 @param[in] EscapeCharacter An escape character to skip
3151 @return the location of the first character in the string
3152 @retval CHAR_NULL no instance of any character in CharacterList was found in String
3156 IN CONST CHAR16
*String
,
3157 IN CONST CHAR16
*CharacterList
,
3158 IN CONST CHAR16 EscapeCharacter
3164 for (WalkStr
= 0; WalkStr
< StrLen(String
); WalkStr
++) {
3165 if (String
[WalkStr
] == EscapeCharacter
) {
3169 for (WalkChar
= 0; WalkChar
< StrLen(CharacterList
); WalkChar
++) {
3170 if (String
[WalkStr
] == CharacterList
[WalkChar
]) {
3171 return (&String
[WalkStr
]);
3175 return (String
+ StrLen(String
));