2 This is THE shell (application)
4 Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
5 (C) Copyright 2013-2014, Hewlett-Packard Development Company, L.P.
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 Find a command line contains a split operation
106 @param[in] CmdLine The command line to parse.
108 @retval A pointer to the | character in CmdLine or NULL if not present.
113 IN CONST CHAR16
*CmdLine
116 CONST CHAR16
*TempSpot
;
118 if (StrStr(CmdLine
, L
"|") != NULL
) {
119 for (TempSpot
= CmdLine
; TempSpot
!= NULL
&& *TempSpot
!= CHAR_NULL
; TempSpot
++) {
120 if (*TempSpot
== L
'^' && *(TempSpot
+1) == L
'|') {
122 } else if (*TempSpot
== L
'|') {
131 Determine if a command line contains a split operation
133 @param[in] CmdLine The command line to parse.
135 @retval TRUE CmdLine has a valid split.
136 @retval FALSE CmdLine does not have a valid split.
141 IN CONST CHAR16
*CmdLine
144 CONST CHAR16
*TempSpot
;
145 TempSpot
= FindSplit(CmdLine
);
146 return (BOOLEAN
) ((TempSpot
!= NULL
) && (*TempSpot
!= CHAR_NULL
));
150 Function to start monitoring for CTRL-S using SimpleTextInputEx. This
151 feature's enabled state was not known when the shell initially launched.
153 @retval EFI_SUCCESS The feature is enabled.
154 @retval EFI_OUT_OF_RESOURCES There is not enough mnemory available.
158 InternalEfiShellStartCtrlSMonitor(
162 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
163 EFI_KEY_DATA KeyData
;
166 Status
= gBS
->OpenProtocol(
167 gST
->ConsoleInHandle
,
168 &gEfiSimpleTextInputExProtocolGuid
,
172 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
173 if (EFI_ERROR(Status
)) {
178 STRING_TOKEN (STR_SHELL_NO_IN_EX
),
179 ShellInfoObject
.HiiHandle
);
180 return (EFI_SUCCESS
);
183 KeyData
.KeyState
.KeyToggleState
= 0;
184 KeyData
.Key
.ScanCode
= 0;
185 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
186 KeyData
.Key
.UnicodeChar
= L
's';
188 Status
= SimpleEx
->RegisterKeyNotify(
191 NotificationFunction
,
192 &ShellInfoObject
.CtrlSNotifyHandle1
);
194 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
195 if (!EFI_ERROR(Status
)) {
196 Status
= SimpleEx
->RegisterKeyNotify(
199 NotificationFunction
,
200 &ShellInfoObject
.CtrlSNotifyHandle2
);
202 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
203 KeyData
.Key
.UnicodeChar
= 19;
205 if (!EFI_ERROR(Status
)) {
206 Status
= SimpleEx
->RegisterKeyNotify(
209 NotificationFunction
,
210 &ShellInfoObject
.CtrlSNotifyHandle3
);
212 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
213 if (!EFI_ERROR(Status
)) {
214 Status
= SimpleEx
->RegisterKeyNotify(
217 NotificationFunction
,
218 &ShellInfoObject
.CtrlSNotifyHandle4
);
226 The entry point for the application.
228 @param[in] ImageHandle The firmware allocated handle for the EFI image.
229 @param[in] SystemTable A pointer to the EFI System Table.
231 @retval EFI_SUCCESS The entry point is executed successfully.
232 @retval other Some error occurs when executing this entry point.
238 IN EFI_HANDLE ImageHandle
,
239 IN EFI_SYSTEM_TABLE
*SystemTable
245 EFI_HANDLE ConInHandle
;
246 EFI_SIMPLE_TEXT_INPUT_PROTOCOL
*OldConIn
;
249 SHELL_STATUS ExitStatus
;
251 if (PcdGet8(PcdShellSupportLevel
) > 3) {
252 return (EFI_UNSUPPORTED
);
258 Status
= gST
->ConOut
->ClearScreen(gST
->ConOut
);
259 if (EFI_ERROR(Status
)) {
264 // Populate the global structure from PCDs
266 ShellInfoObject
.ImageDevPath
= NULL
;
267 ShellInfoObject
.FileDevPath
= NULL
;
268 ShellInfoObject
.PageBreakEnabled
= PcdGetBool(PcdShellPageBreakDefault
);
269 ShellInfoObject
.ViewingSettings
.InsertMode
= PcdGetBool(PcdShellInsertModeDefault
);
270 ShellInfoObject
.LogScreenCount
= PcdGet8 (PcdShellScreenLogCount
);
273 // verify we dont allow for spec violation
275 ASSERT(ShellInfoObject
.LogScreenCount
>= 3);
278 // Initialize the LIST ENTRY objects...
280 InitializeListHead(&ShellInfoObject
.BufferToFreeList
.Link
);
281 InitializeListHead(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
);
282 InitializeListHead(&ShellInfoObject
.SplitList
.Link
);
285 // Check PCDs for optional features that are not implemented yet.
287 if ( PcdGetBool(PcdShellSupportOldProtocols
)
288 || !FeaturePcdGet(PcdShellRequireHiiPlatform
)
289 || FeaturePcdGet(PcdShellSupportFrameworkHii
)
291 return (EFI_UNSUPPORTED
);
295 // turn off the watchdog timer
297 gBS
->SetWatchdogTimer (0, 0, 0, NULL
);
300 // install our console logger. This will keep a log of the output for back-browsing
302 Status
= ConsoleLoggerInstall(ShellInfoObject
.LogScreenCount
, &ShellInfoObject
.ConsoleInfo
);
303 if(EFI_ERROR (Status
)) {
304 ExitStatus
= (SHELL_STATUS
) (Status
& (~MAX_BIT
));
306 ExitStatus
= SHELL_SUCCESS
;
309 if (!EFI_ERROR(Status
)) {
311 // Enable the cursor to be visible
313 gST
->ConOut
->EnableCursor (gST
->ConOut
, TRUE
);
316 // If supporting EFI 1.1 we need to install HII protocol
317 // only do this if PcdShellRequireHiiPlatform == FALSE
319 // remove EFI_UNSUPPORTED check above when complete.
320 ///@todo add support for Framework HII
323 // install our (solitary) HII package
325 ShellInfoObject
.HiiHandle
= HiiAddPackages (&gEfiCallerIdGuid
, gImageHandle
, ShellStrings
, NULL
);
326 if (ShellInfoObject
.HiiHandle
== NULL
) {
327 if (PcdGetBool(PcdShellSupportFrameworkHii
)) {
328 ///@todo Add our package into Framework HII
330 if (ShellInfoObject
.HiiHandle
== NULL
) {
331 Status
= EFI_NOT_STARTED
;
337 // create and install the EfiShellParametersProtocol
339 Status
= CreatePopulateInstallShellParametersProtocol(&ShellInfoObject
.NewShellParametersProtocol
, &ShellInfoObject
.RootShellInstance
);
340 ASSERT_EFI_ERROR(Status
);
341 ASSERT(ShellInfoObject
.NewShellParametersProtocol
!= NULL
);
344 // create and install the EfiShellProtocol
346 Status
= CreatePopulateInstallShellProtocol(&ShellInfoObject
.NewEfiShellProtocol
);
347 ASSERT_EFI_ERROR(Status
);
348 ASSERT(ShellInfoObject
.NewEfiShellProtocol
!= NULL
);
351 // Now initialize the shell library (it requires Shell Parameters protocol)
353 Status
= ShellInitialize();
354 ASSERT_EFI_ERROR(Status
);
356 Status
= CommandInit();
357 ASSERT_EFI_ERROR(Status
);
360 // Check the command line
362 Status
= ProcessCommandLine ();
363 if (EFI_ERROR (Status
)) {
368 // If shell support level is >= 1 create the mappings and paths
370 if (PcdGet8(PcdShellSupportLevel
) >= 1) {
371 Status
= ShellCommandCreateInitialMappingsAndPaths();
375 // save the device path for the loaded image and the device path for the filepath (under loaded image)
376 // These are where to look for the startup.nsh file
378 Status
= GetDevicePathsForImageAndFile(&ShellInfoObject
.ImageDevPath
, &ShellInfoObject
.FileDevPath
);
379 ASSERT_EFI_ERROR(Status
);
382 // Display the version
384 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoVersion
) {
387 gST
->ConOut
->Mode
->CursorRow
,
389 STRING_TOKEN (STR_VER_OUTPUT_MAIN_SHELL
),
390 ShellInfoObject
.HiiHandle
,
391 SupportLevel
[PcdGet8(PcdShellSupportLevel
)],
392 gEfiShellProtocol
->MajorVersion
,
393 gEfiShellProtocol
->MinorVersion
400 STRING_TOKEN (STR_VER_OUTPUT_MAIN_SUPPLIER
),
401 ShellInfoObject
.HiiHandle
,
402 (CHAR16
*) PcdGetPtr (PcdShellSupplier
)
409 STRING_TOKEN (STR_VER_OUTPUT_MAIN_UEFI
),
410 ShellInfoObject
.HiiHandle
,
411 (gST
->Hdr
.Revision
&0xffff0000)>>16,
412 (gST
->Hdr
.Revision
&0x0000ffff),
414 gST
->FirmwareRevision
419 // Display the mapping
421 if (PcdGet8(PcdShellSupportLevel
) >= 2 && !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoMap
) {
422 Status
= RunCommand(L
"map", NULL
);
423 ASSERT_EFI_ERROR(Status
);
427 // init all the built in alias'
429 Status
= SetBuiltInAlias();
430 ASSERT_EFI_ERROR(Status
);
433 // Initialize environment variables
435 if (ShellCommandGetProfileList() != NULL
) {
436 Status
= InternalEfiShellSetEnv(L
"profiles", ShellCommandGetProfileList(), TRUE
);
437 ASSERT_EFI_ERROR(Status
);
441 TempString
= AllocateZeroPool(Size
);
443 UnicodeSPrint(TempString
, Size
, L
"%d", PcdGet8(PcdShellSupportLevel
));
444 Status
= InternalEfiShellSetEnv(L
"uefishellsupport", TempString
, TRUE
);
445 ASSERT_EFI_ERROR(Status
);
447 UnicodeSPrint(TempString
, Size
, L
"%d.%d", ShellInfoObject
.NewEfiShellProtocol
->MajorVersion
, ShellInfoObject
.NewEfiShellProtocol
->MinorVersion
);
448 Status
= InternalEfiShellSetEnv(L
"uefishellversion", TempString
, TRUE
);
449 ASSERT_EFI_ERROR(Status
);
451 UnicodeSPrint(TempString
, Size
, L
"%d.%d", (gST
->Hdr
.Revision
& 0xFFFF0000) >> 16, gST
->Hdr
.Revision
& 0x0000FFFF);
452 Status
= InternalEfiShellSetEnv(L
"uefiversion", TempString
, TRUE
);
453 ASSERT_EFI_ERROR(Status
);
455 FreePool(TempString
);
457 if (!EFI_ERROR(Status
)) {
458 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
) {
460 // Set up the event for CTRL-C monitoring...
462 Status
= InernalEfiShellStartMonitor();
465 if (!EFI_ERROR(Status
) && !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
467 // Set up the event for CTRL-S monitoring...
469 Status
= InternalEfiShellStartCtrlSMonitor();
472 if (!EFI_ERROR(Status
) && ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
474 // close off the gST->ConIn
476 OldConIn
= gST
->ConIn
;
477 ConInHandle
= gST
->ConsoleInHandle
;
478 gST
->ConIn
= CreateSimpleTextInOnFile((SHELL_FILE_HANDLE
)&FileInterfaceNulFile
, &gST
->ConsoleInHandle
);
484 if (!EFI_ERROR(Status
) && PcdGet8(PcdShellSupportLevel
) >= 1) {
486 // process the startup script or launch the called app.
488 Status
= DoStartupScript(
489 ShellInfoObject
.ImageDevPath
,
490 ShellInfoObject
.FileDevPath
,
495 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Exit
&& !ShellCommandGetExit() && (PcdGet8(PcdShellSupportLevel
) >= 3 || PcdGetBool(PcdShellForceConsole
)) && !EFI_ERROR(Status
) && !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
497 // begin the UI waiting loop
501 // clean out all the memory allocated for CONST <something> * return values
502 // between each shell prompt presentation
504 if (!IsListEmpty(&ShellInfoObject
.BufferToFreeList
.Link
)){
505 FreeBufferList(&ShellInfoObject
.BufferToFreeList
);
509 // Reset page break back to default.
511 ShellInfoObject
.PageBreakEnabled
= PcdGetBool(PcdShellPageBreakDefault
);
512 ShellInfoObject
.ConsoleInfo
->Enabled
= TRUE
;
513 ShellInfoObject
.ConsoleInfo
->RowCounter
= 0;
516 // Reset the CTRL-C event (yes we ignore the return values)
518 Status
= gBS
->CheckEvent (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
);
523 Status
= DoShellPrompt();
524 } while (!ShellCommandGetExit());
525 ExitStatus
= (SHELL_STATUS
) ShellCommandGetExitCode();
527 if (OldConIn
!= NULL
&& ConInHandle
!= NULL
) {
528 CloseSimpleTextInOnFile (gST
->ConIn
);
529 gST
->ConIn
= OldConIn
;
530 gST
->ConsoleInHandle
= ConInHandle
;
537 // uninstall protocols / free memory / etc...
539 if (ShellInfoObject
.UserBreakTimer
!= NULL
) {
540 gBS
->CloseEvent(ShellInfoObject
.UserBreakTimer
);
541 DEBUG_CODE(ShellInfoObject
.UserBreakTimer
= NULL
;);
543 if (ShellInfoObject
.ImageDevPath
!= NULL
) {
544 FreePool(ShellInfoObject
.ImageDevPath
);
545 DEBUG_CODE(ShellInfoObject
.ImageDevPath
= NULL
;);
547 if (ShellInfoObject
.FileDevPath
!= NULL
) {
548 FreePool(ShellInfoObject
.FileDevPath
);
549 DEBUG_CODE(ShellInfoObject
.FileDevPath
= NULL
;);
551 if (ShellInfoObject
.NewShellParametersProtocol
!= NULL
) {
552 CleanUpShellParametersProtocol(ShellInfoObject
.NewShellParametersProtocol
);
553 DEBUG_CODE(ShellInfoObject
.NewShellParametersProtocol
= NULL
;);
555 if (ShellInfoObject
.NewEfiShellProtocol
!= NULL
){
556 if (ShellInfoObject
.NewEfiShellProtocol
->IsRootShell()){
557 InternalEfiShellSetEnv(L
"cwd", NULL
, TRUE
);
559 CleanUpShellProtocol(ShellInfoObject
.NewEfiShellProtocol
);
560 DEBUG_CODE(ShellInfoObject
.NewEfiShellProtocol
= NULL
;);
563 if (!IsListEmpty(&ShellInfoObject
.BufferToFreeList
.Link
)){
564 FreeBufferList(&ShellInfoObject
.BufferToFreeList
);
567 if (!IsListEmpty(&ShellInfoObject
.SplitList
.Link
)){
568 ASSERT(FALSE
); ///@todo finish this de-allocation.
571 if (ShellInfoObject
.ShellInitSettings
.FileName
!= NULL
) {
572 FreePool(ShellInfoObject
.ShellInitSettings
.FileName
);
573 DEBUG_CODE(ShellInfoObject
.ShellInitSettings
.FileName
= NULL
;);
576 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
577 FreePool(ShellInfoObject
.ShellInitSettings
.FileOptions
);
578 DEBUG_CODE(ShellInfoObject
.ShellInitSettings
.FileOptions
= NULL
;);
581 if (ShellInfoObject
.HiiHandle
!= NULL
) {
582 HiiRemovePackages(ShellInfoObject
.HiiHandle
);
583 DEBUG_CODE(ShellInfoObject
.HiiHandle
= NULL
;);
586 if (!IsListEmpty(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
)){
587 FreeBufferList(&ShellInfoObject
.ViewingSettings
.CommandHistory
);
590 ASSERT(ShellInfoObject
.ConsoleInfo
!= NULL
);
591 if (ShellInfoObject
.ConsoleInfo
!= NULL
) {
592 ConsoleLoggerUninstall(ShellInfoObject
.ConsoleInfo
);
593 FreePool(ShellInfoObject
.ConsoleInfo
);
594 DEBUG_CODE(ShellInfoObject
.ConsoleInfo
= NULL
;);
597 if (!EFI_ERROR (Status
)) {
598 // If the command exited with an error, we pass this error out in the ExitData
599 // so that it can be retrieved by the EfiShellExecute function (which may
600 // start the shell with gBS->StartImage)
601 if (ExitStatus
!= SHELL_SUCCESS
) {
602 // Allocate a buffer for exit data to pass to gBS->Exit().
603 // This buffer will contain the empty string immediately followed by
604 // the shell's exit status. (The empty string is required by the UEFI spec)
605 ExitDataSize
= (sizeof (CHAR16
) + sizeof (SHELL_STATUS
));
606 ExitData
= AllocatePool (ExitDataSize
);
607 if (ExitData
== NULL
) {
608 return EFI_OUT_OF_RESOURCES
;
611 // Use CopyMem to avoid alignment faults
612 CopyMem ((ExitData
+ 1), &ExitStatus
, sizeof (ExitStatus
));
614 gBS
->Exit (ImageHandle
, EFI_ABORTED
, ExitDataSize
, ExitData
);
627 Sets all the alias' that were registered with the ShellCommandLib library.
629 @retval EFI_SUCCESS all init commands were run sucessfully.
637 CONST ALIAS_LIST
*List
;
641 // Get all the commands we want to run
643 List
= ShellCommandGetInitAliasList();
646 // for each command in the List
648 for ( Node
= (ALIAS_LIST
*)GetFirstNode(&List
->Link
)
649 ; !IsNull (&List
->Link
, &Node
->Link
)
650 ; Node
= (ALIAS_LIST
*)GetNextNode(&List
->Link
, &Node
->Link
)
653 // install the alias'
655 Status
= InternalSetAlias(Node
->CommandString
, Node
->Alias
, TRUE
);
656 ASSERT_EFI_ERROR(Status
);
658 return (EFI_SUCCESS
);
662 Internal function to determine if 2 command names are really the same.
664 @param[in] Command1 The pointer to the first command name.
665 @param[in] Command2 The pointer to the second command name.
667 @retval TRUE The 2 command names are the same.
668 @retval FALSE The 2 command names are not the same.
673 IN CONST CHAR16
*Command1
,
674 IN CONST CHAR16
*Command2
677 if (StringNoCaseCompare(&Command1
, &Command2
) == 0) {
684 Internal function to determine if a command is a script only command.
686 @param[in] CommandName The pointer to the command name.
688 @retval TRUE The command is a script only command.
689 @retval FALSE The command is not a script only command.
694 IN CONST CHAR16
*CommandName
697 if (IsCommand(CommandName
, L
"for")
698 ||IsCommand(CommandName
, L
"endfor")
699 ||IsCommand(CommandName
, L
"if")
700 ||IsCommand(CommandName
, L
"else")
701 ||IsCommand(CommandName
, L
"endif")
702 ||IsCommand(CommandName
, L
"goto")) {
709 This function will populate the 2 device path protocol parameters based on the
710 global gImageHandle. The DevPath will point to the device path for the handle that has
711 loaded image protocol installed on it. The FilePath will point to the device path
712 for the file that was loaded.
714 @param[in, out] DevPath On a sucessful return the device path to the loaded image.
715 @param[in, out] FilePath On a sucessful return the device path to the file.
717 @retval EFI_SUCCESS The 2 device paths were sucessfully returned.
718 @retval other A error from gBS->HandleProtocol.
724 GetDevicePathsForImageAndFile (
725 IN OUT EFI_DEVICE_PATH_PROTOCOL
**DevPath
,
726 IN OUT EFI_DEVICE_PATH_PROTOCOL
**FilePath
730 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
731 EFI_DEVICE_PATH_PROTOCOL
*ImageDevicePath
;
733 ASSERT(DevPath
!= NULL
);
734 ASSERT(FilePath
!= NULL
);
736 Status
= gBS
->OpenProtocol (
738 &gEfiLoadedImageProtocolGuid
,
739 (VOID
**)&LoadedImage
,
742 EFI_OPEN_PROTOCOL_GET_PROTOCOL
744 if (!EFI_ERROR (Status
)) {
745 Status
= gBS
->OpenProtocol (
746 LoadedImage
->DeviceHandle
,
747 &gEfiDevicePathProtocolGuid
,
748 (VOID
**)&ImageDevicePath
,
751 EFI_OPEN_PROTOCOL_GET_PROTOCOL
753 if (!EFI_ERROR (Status
)) {
754 *DevPath
= DuplicateDevicePath (ImageDevicePath
);
755 *FilePath
= DuplicateDevicePath (LoadedImage
->FilePath
);
757 LoadedImage
->DeviceHandle
,
758 &gEfiDevicePathProtocolGuid
,
764 &gEfiLoadedImageProtocolGuid
,
772 Process all Uefi Shell 2.0 command line options.
774 see Uefi Shell 2.0 section 3.2 for full details.
776 the command line must resemble the following:
778 shell.efi [ShellOpt-options] [options] [file-name [file-name-options]]
780 ShellOpt-options Options which control the initialization behavior of the shell.
781 These options are read from the EFI global variable "ShellOpt"
782 and are processed before options or file-name.
784 options Options which control the initialization behavior of the shell.
786 file-name The name of a UEFI shell application or script to be executed
787 after initialization is complete. By default, if file-name is
788 specified, then -nostartup is implied. Scripts are not supported
791 file-name-options The command-line options that are passed to file-name when it
794 This will initialize the ShellInfoObject.ShellInitSettings global variable.
796 @retval EFI_SUCCESS The variable is initialized.
807 CHAR16
*DelayValueStr
;
810 EFI_UNICODE_COLLATION_PROTOCOL
*UnicodeCollation
;
812 // `file-name-options` will contain arguments to `file-name` that we don't
813 // know about. This would cause ShellCommandLineParse to error, so we parse
814 // arguments manually, ignoring those after the first thing that doesn't look
815 // like a shell option (which is assumed to be `file-name`).
817 Status
= gBS
->LocateProtocol (
818 &gEfiUnicodeCollationProtocolGuid
,
820 (VOID
**) &UnicodeCollation
822 if (EFI_ERROR (Status
)) {
826 // Set default options
827 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
= FALSE
;
828 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
= FALSE
;
829 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleOut
= FALSE
;
830 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
= FALSE
;
831 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
= FALSE
;
832 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoMap
= FALSE
;
833 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoVersion
= FALSE
;
834 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Delay
= FALSE
;
835 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Exit
= FALSE
;
836 ShellInfoObject
.ShellInitSettings
.Delay
= 5;
839 // Start LoopVar at 0 to parse only optional arguments at Argv[0]
840 // and parse other parameters from Argv[1]. This is for use case that
841 // UEFI Shell boot option is created, and OptionalData is provided
842 // that starts with shell command-line options.
844 for (LoopVar
= 0 ; LoopVar
< gEfiShellParametersProtocol
->Argc
; LoopVar
++) {
845 CurrentArg
= gEfiShellParametersProtocol
->Argv
[LoopVar
];
846 if (UnicodeCollation
->StriColl (
851 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
= TRUE
;
853 else if (UnicodeCollation
->StriColl (
858 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
= TRUE
;
860 else if (UnicodeCollation
->StriColl (
865 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleOut
= TRUE
;
867 else if (UnicodeCollation
->StriColl (
872 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
= TRUE
;
874 else if (UnicodeCollation
->StriColl (
879 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
= TRUE
;
881 else if (UnicodeCollation
->StriColl (
886 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoMap
= TRUE
;
888 else if (UnicodeCollation
->StriColl (
893 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoVersion
= TRUE
;
895 else if (UnicodeCollation
->StriColl (
900 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Delay
= TRUE
;
901 // Check for optional delay value following "-delay"
902 DelayValueStr
= gEfiShellParametersProtocol
->Argv
[LoopVar
+ 1];
903 if (DelayValueStr
!= NULL
){
904 if (*DelayValueStr
== L
':') {
907 if (!EFI_ERROR(ShellConvertStringToUint64 (
913 ShellInfoObject
.ShellInitSettings
.Delay
= (UINTN
)DelayValue
;
917 } else if (UnicodeCollation
->StriColl (
922 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Exit
= TRUE
;
923 } else if (StrnCmp (L
"-", CurrentArg
, 1) == 0) {
924 // Unrecognised option
925 ShellPrintHiiEx(-1, -1, NULL
,
926 STRING_TOKEN (STR_GEN_PROBLEM
),
927 ShellInfoObject
.HiiHandle
,
930 return EFI_INVALID_PARAMETER
;
933 // First argument should be Shell.efi image name
939 ShellInfoObject
.ShellInitSettings
.FileName
= AllocateZeroPool(StrSize(CurrentArg
));
940 if (ShellInfoObject
.ShellInitSettings
.FileName
== NULL
) {
941 return (EFI_OUT_OF_RESOURCES
);
944 // We found `file-name`.
946 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
= 1;
948 StrCpy (ShellInfoObject
.ShellInitSettings
.FileName
, CurrentArg
);
951 // Add `file-name-options`
952 for (Size
= 0 ; LoopVar
< gEfiShellParametersProtocol
->Argc
; LoopVar
++) {
953 ASSERT((ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
&& Size
== 0) || (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
));
954 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileOptions
,
958 if (ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
) {
959 SHELL_FREE_NON_NULL(ShellInfoObject
.ShellInitSettings
.FileName
);
960 return (EFI_OUT_OF_RESOURCES
);
962 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileOptions
,
964 gEfiShellParametersProtocol
->Argv
[LoopVar
],
966 if (ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
) {
967 SHELL_FREE_NON_NULL(ShellInfoObject
.ShellInitSettings
.FileName
);
968 return (EFI_OUT_OF_RESOURCES
);
974 // "-nointerrupt" overrides "-delay"
975 if (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
) {
976 ShellInfoObject
.ShellInitSettings
.Delay
= 0;
983 Handles all interaction with the default startup script.
985 this will check that the correct command line parameters were passed, handle the delay, and then start running the script.
987 @param ImagePath the path to the image for shell. first place to look for the startup script
988 @param FilePath the path to the file for shell. second place to look for the startup script.
990 @param[out] ExitStatus The exit code of the script. Ignored if NULL.
992 @retval EFI_SUCCESS the variable is initialized.
997 IN EFI_DEVICE_PATH_PROTOCOL
*ImagePath
,
998 IN EFI_DEVICE_PATH_PROTOCOL
*FilePath
,
999 OUT SHELL_STATUS
*ExitStatus
1005 SHELL_FILE_HANDLE FileHandle
;
1006 EFI_DEVICE_PATH_PROTOCOL
*NewPath
;
1007 EFI_DEVICE_PATH_PROTOCOL
*NamePath
;
1008 CHAR16
*FileStringPath
;
1011 CONST CHAR16
*MapName
;
1013 Key
.UnicodeChar
= CHAR_NULL
;
1017 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
&& ShellInfoObject
.ShellInitSettings
.FileName
!= NULL
) {
1019 // launch something else instead
1021 NewSize
= StrSize(ShellInfoObject
.ShellInitSettings
.FileName
);
1022 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
1023 NewSize
+= StrSize(ShellInfoObject
.ShellInitSettings
.FileOptions
) + sizeof(CHAR16
);
1025 FileStringPath
= AllocateZeroPool(NewSize
);
1026 if (FileStringPath
== NULL
) {
1027 return (EFI_OUT_OF_RESOURCES
);
1029 StrCpy(FileStringPath
, ShellInfoObject
.ShellInitSettings
.FileName
);
1030 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
1031 StrCat(FileStringPath
, L
" ");
1032 StrCat(FileStringPath
, ShellInfoObject
.ShellInitSettings
.FileOptions
);
1034 Status
= RunCommand(FileStringPath
, ExitStatus
);
1035 FreePool(FileStringPath
);
1041 // for shell level 0 we do no scripts
1042 // Without the Startup bit overriding we allow for nostartup to prevent scripts
1044 if ( (PcdGet8(PcdShellSupportLevel
) < 1)
1045 || (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
&& !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
)
1047 return (EFI_SUCCESS
);
1050 gST
->ConOut
->EnableCursor(gST
->ConOut
, FALSE
);
1052 // print out our warning and see if they press a key
1054 for ( Status
= EFI_UNSUPPORTED
, Delay
= ShellInfoObject
.ShellInitSettings
.Delay
1055 ; Delay
!= 0 && EFI_ERROR(Status
)
1058 ShellPrintHiiEx(0, gST
->ConOut
->Mode
->CursorRow
, NULL
, STRING_TOKEN (STR_SHELL_STARTUP_QUESTION
), ShellInfoObject
.HiiHandle
, Delay
);
1059 gBS
->Stall (1000000);
1060 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
1061 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
1064 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CRLF
), ShellInfoObject
.HiiHandle
);
1065 gST
->ConOut
->EnableCursor(gST
->ConOut
, TRUE
);
1070 if (Status
== EFI_SUCCESS
&& Key
.UnicodeChar
== 0 && Key
.ScanCode
== SCAN_ESC
) {
1071 return (EFI_SUCCESS
);
1075 // Try the first location (must be file system)
1077 MapName
= ShellInfoObject
.NewEfiShellProtocol
->GetMapFromDevicePath(&ImagePath
);
1078 if (MapName
!= NULL
) {
1079 FileStringPath
= NULL
;
1081 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, MapName
, 0);
1082 if (FileStringPath
== NULL
) {
1083 Status
= EFI_OUT_OF_RESOURCES
;
1085 TempSpot
= StrStr(FileStringPath
, L
";");
1086 if (TempSpot
!= NULL
) {
1087 *TempSpot
= CHAR_NULL
;
1089 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, ((FILEPATH_DEVICE_PATH
*)FilePath
)->PathName
, 0);
1090 PathRemoveLastItem(FileStringPath
);
1091 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, mStartupScript
, 0);
1092 Status
= ShellInfoObject
.NewEfiShellProtocol
->OpenFileByName(FileStringPath
, &FileHandle
, EFI_FILE_MODE_READ
);
1093 FreePool(FileStringPath
);
1096 if (EFI_ERROR(Status
)) {
1097 NamePath
= FileDevicePath (NULL
, mStartupScript
);
1098 NewPath
= AppendDevicePathNode (ImagePath
, NamePath
);
1104 Status
= InternalOpenFileDevicePath(NewPath
, &FileHandle
, EFI_FILE_MODE_READ
, 0);
1108 // If we got a file, run it
1110 if (!EFI_ERROR(Status
) && FileHandle
!= NULL
) {
1111 Status
= RunScriptFile (
1115 ShellInfoObject
.NewShellParametersProtocol
,
1118 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(FileHandle
);
1120 FileStringPath
= ShellFindFilePath(mStartupScript
);
1121 if (FileStringPath
== NULL
) {
1123 // we return success since we dont need to have a startup script
1125 Status
= EFI_SUCCESS
;
1126 ASSERT(FileHandle
== NULL
);
1128 Status
= RunScriptFile(
1132 ShellInfoObject
.NewShellParametersProtocol
,
1135 FreePool(FileStringPath
);
1144 Function to perform the shell prompt looping. It will do a single prompt,
1145 dispatch the result, and then return. It is expected that the caller will
1146 call this function in a loop many times.
1149 @retval RETURN_ABORTED
1160 CONST CHAR16
*CurDir
;
1167 // Get screen setting to decide size of the command line buffer
1169 gST
->ConOut
->QueryMode (gST
->ConOut
, gST
->ConOut
->Mode
->Mode
, &Column
, &Row
);
1170 BufferSize
= Column
* Row
* sizeof (CHAR16
);
1171 CmdLine
= AllocateZeroPool (BufferSize
);
1172 if (CmdLine
== NULL
) {
1173 return EFI_OUT_OF_RESOURCES
;
1176 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
1181 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, gST
->ConOut
->Mode
->CursorRow
);
1183 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
1184 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
1186 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
1190 // Read a line from the console
1192 Status
= ShellInfoObject
.NewEfiShellProtocol
->ReadFile(ShellInfoObject
.NewShellParametersProtocol
->StdIn
, &BufferSize
, CmdLine
);
1195 // Null terminate the string and parse it
1197 if (!EFI_ERROR (Status
)) {
1198 CmdLine
[BufferSize
/ sizeof (CHAR16
)] = CHAR_NULL
;
1199 Status
= RunCommand(CmdLine
, NULL
);
1203 // Done with this command
1210 Add a buffer to the Buffer To Free List for safely returning buffers to other
1211 places without risking letting them modify internal shell information.
1213 @param Buffer Something to pass to FreePool when the shell is exiting.
1217 AddBufferToFreeList(
1221 BUFFER_LIST
*BufferListEntry
;
1223 if (Buffer
== NULL
) {
1227 BufferListEntry
= AllocateZeroPool(sizeof(BUFFER_LIST
));
1228 ASSERT(BufferListEntry
!= NULL
);
1229 BufferListEntry
->Buffer
= Buffer
;
1230 InsertTailList(&ShellInfoObject
.BufferToFreeList
.Link
, &BufferListEntry
->Link
);
1235 Add a buffer to the Line History List
1237 @param Buffer The line buffer to add.
1241 AddLineToCommandHistory(
1242 IN CONST CHAR16
*Buffer
1247 Node
= AllocateZeroPool(sizeof(BUFFER_LIST
));
1248 ASSERT(Node
!= NULL
);
1249 Node
->Buffer
= AllocateZeroPool(StrSize(Buffer
));
1250 ASSERT(Node
->Buffer
!= NULL
);
1251 StrCpy(Node
->Buffer
, Buffer
);
1253 InsertTailList(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
, &Node
->Link
);
1257 Checks if a string is an alias for another command. If yes, then it replaces the alias name
1258 with the correct command name.
1260 @param[in, out] CommandString Upon entry the potential alias. Upon return the
1261 command name if it was an alias. If it was not
1262 an alias it will be unchanged. This function may
1263 change the buffer to fit the command name.
1265 @retval EFI_SUCCESS The name was changed.
1266 @retval EFI_SUCCESS The name was not an alias.
1267 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
1272 IN OUT CHAR16
**CommandString
1275 CONST CHAR16
*NewString
;
1277 NewString
= ShellInfoObject
.NewEfiShellProtocol
->GetAlias(*CommandString
, NULL
);
1278 if (NewString
== NULL
) {
1279 return (EFI_SUCCESS
);
1281 FreePool(*CommandString
);
1282 *CommandString
= AllocateZeroPool(StrSize(NewString
));
1283 if (*CommandString
== NULL
) {
1284 return (EFI_OUT_OF_RESOURCES
);
1286 StrCpy(*CommandString
, NewString
);
1287 return (EFI_SUCCESS
);
1291 Parse for the next instance of one string within another string. Can optionally make sure that
1292 the string was not escaped (^ character) per the shell specification.
1294 @param[in] SourceString The string to search within
1295 @param[in] FindString The string to look for
1296 @param[in] CheckForEscapeCharacter TRUE to skip escaped instances of FinfString, otherwise will return even escaped instances
1301 IN CONST CHAR16
*SourceString
,
1302 IN CONST CHAR16
*FindString
,
1303 IN CONST BOOLEAN CheckForEscapeCharacter
1307 if (SourceString
== NULL
) {
1310 Temp
= StrStr(SourceString
, FindString
);
1313 // If nothing found, or we dont care about escape characters
1315 if (Temp
== NULL
|| !CheckForEscapeCharacter
) {
1320 // If we found an escaped character, try again on the remainder of the string
1322 if ((Temp
> (SourceString
)) && *(Temp
-1) == L
'^') {
1323 return FindNextInstance(Temp
+1, FindString
, CheckForEscapeCharacter
);
1327 // we found the right character
1333 This function will eliminate unreplaced (and therefore non-found) environment variables.
1335 @param[in,out] CmdLine The command line to update.
1339 StripUnreplacedEnvironmentVariables(
1340 IN OUT CHAR16
*CmdLine
1343 CHAR16
*FirstPercent
;
1345 CHAR16
*SecondPercent
;
1346 CHAR16
*SecondQuote
;
1347 CHAR16
*CurrentLocator
;
1349 for (CurrentLocator
= CmdLine
; CurrentLocator
!= NULL
; ) {
1350 FirstQuote
= FindNextInstance(CurrentLocator
, L
"\"", TRUE
);
1351 FirstPercent
= FindNextInstance(CurrentLocator
, L
"%", TRUE
);
1352 SecondPercent
= FirstPercent
!=NULL
?FindNextInstance(FirstPercent
+1, L
"%", TRUE
):NULL
;
1353 if (FirstPercent
== NULL
|| SecondPercent
== NULL
) {
1355 // If we ever dont have 2 % we are done.
1360 if (FirstQuote
< FirstPercent
) {
1361 SecondQuote
= FirstQuote
!= NULL
?FindNextInstance(FirstQuote
+1, L
"\"", TRUE
):NULL
;
1363 // Quote is first found
1366 if (SecondQuote
< FirstPercent
) {
1368 // restart after the pair of "
1370 CurrentLocator
= SecondQuote
+ 1;
1371 } else /* FirstPercent < SecondQuote */{
1373 // Restart on the first percent
1375 CurrentLocator
= FirstPercent
;
1379 ASSERT(FirstPercent
< FirstQuote
);
1380 if (SecondPercent
< FirstQuote
) {
1382 // We need to remove from FirstPercent to SecondPercent
1384 CopyMem(FirstPercent
, SecondPercent
+ 1, StrSize(SecondPercent
+ 1));
1387 // dont need to update the locator. both % characters are gone.
1391 ASSERT(FirstQuote
< SecondPercent
);
1392 CurrentLocator
= FirstQuote
;
1394 return (EFI_SUCCESS
);
1398 Function allocates a new command line and replaces all instances of environment
1399 variable names that are correctly preset to their values.
1401 If the return value is not NULL the memory must be caller freed.
1403 @param[in] OriginalCommandLine The original command line
1405 @retval NULL An error ocurred.
1406 @return The new command line with no environment variables present.
1410 ShellConvertVariables (
1411 IN CONST CHAR16
*OriginalCommandLine
1414 CONST CHAR16
*MasterEnvList
;
1416 CHAR16
*NewCommandLine1
;
1417 CHAR16
*NewCommandLine2
;
1421 SCRIPT_FILE
*CurrentScriptFile
;
1422 ALIAS_LIST
*AliasListNode
;
1424 ASSERT(OriginalCommandLine
!= NULL
);
1427 NewSize
= StrSize(OriginalCommandLine
);
1428 CurrentScriptFile
= ShellCommandGetCurrentScriptFile();
1431 ///@todo update this to handle the %0 - %9 for scripting only (borrow from line 1256 area) ? ? ?
1434 // calculate the size required for the post-conversion string...
1436 if (CurrentScriptFile
!= NULL
) {
1437 for (AliasListNode
= (ALIAS_LIST
*)GetFirstNode(&CurrentScriptFile
->SubstList
)
1438 ; !IsNull(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1439 ; AliasListNode
= (ALIAS_LIST
*)GetNextNode(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1441 for (Temp
= StrStr(OriginalCommandLine
, AliasListNode
->Alias
)
1443 ; Temp
= StrStr(Temp
+1, AliasListNode
->Alias
)
1446 // we need a preceeding and if there is space no ^ preceeding (if no space ignore)
1448 if ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2)) {
1449 NewSize
+= StrSize(AliasListNode
->CommandString
);
1455 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1456 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
//&& *(MasterEnvList+1) != CHAR_NULL
1457 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1459 if (StrSize(MasterEnvList
) > ItemSize
) {
1460 ItemSize
= StrSize(MasterEnvList
);
1462 for (Temp
= StrStr(OriginalCommandLine
, MasterEnvList
)
1464 ; Temp
= StrStr(Temp
+1, MasterEnvList
)
1467 // we need a preceeding and following % and if there is space no ^ preceeding (if no space ignore)
1469 if (*(Temp
-1) == L
'%' && *(Temp
+StrLen(MasterEnvList
)) == L
'%' &&
1470 ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2))) {
1471 NewSize
+=StrSize(EfiShellGetEnv(MasterEnvList
));
1477 // now do the replacements...
1479 NewCommandLine1
= AllocateZeroPool(NewSize
);
1480 NewCommandLine2
= AllocateZeroPool(NewSize
);
1481 ItemTemp
= AllocateZeroPool(ItemSize
+(2*sizeof(CHAR16
)));
1482 if (NewCommandLine1
== NULL
|| NewCommandLine2
== NULL
|| ItemTemp
== NULL
) {
1483 SHELL_FREE_NON_NULL(NewCommandLine1
);
1484 SHELL_FREE_NON_NULL(NewCommandLine2
);
1485 SHELL_FREE_NON_NULL(ItemTemp
);
1488 StrCpy(NewCommandLine1
, OriginalCommandLine
);
1489 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1490 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
//&& *(MasterEnvList+1) != CHAR_NULL
1491 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1493 StrCpy(ItemTemp
, L
"%");
1494 StrCat(ItemTemp
, MasterEnvList
);
1495 StrCat(ItemTemp
, L
"%");
1496 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, ItemTemp
, EfiShellGetEnv(MasterEnvList
), TRUE
, FALSE
);
1497 StrCpy(NewCommandLine1
, NewCommandLine2
);
1499 if (CurrentScriptFile
!= NULL
) {
1500 for (AliasListNode
= (ALIAS_LIST
*)GetFirstNode(&CurrentScriptFile
->SubstList
)
1501 ; !IsNull(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1502 ; AliasListNode
= (ALIAS_LIST
*)GetNextNode(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1504 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, AliasListNode
->Alias
, AliasListNode
->CommandString
, TRUE
, FALSE
);
1505 StrCpy(NewCommandLine1
, NewCommandLine2
);
1509 // Remove non-existant environment variables in scripts only
1511 StripUnreplacedEnvironmentVariables(NewCommandLine1
);
1515 // Now cleanup any straggler intentionally ignored "%" characters
1517 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, L
"^%", L
"%", TRUE
, FALSE
);
1518 StrCpy(NewCommandLine1
, NewCommandLine2
);
1520 FreePool(NewCommandLine2
);
1523 return (NewCommandLine1
);
1527 Internal function to run a command line with pipe usage.
1529 @param[in] CmdLine The pointer to the command line.
1530 @param[in] StdIn The pointer to the Standard input.
1531 @param[in] StdOut The pointer to the Standard output.
1533 @param[out] ExitStatus The exit code of the last command in the pipeline.
1536 @retval EFI_SUCCESS The split command is executed successfully.
1537 @retval other Some error occurs when executing the split command.
1542 IN CONST CHAR16
*CmdLine
,
1543 IN SHELL_FILE_HANDLE
*StdIn
,
1544 IN SHELL_FILE_HANDLE
*StdOut
,
1545 OUT SHELL_STATUS
*ExitStatus
1549 CHAR16
*NextCommandLine
;
1550 CHAR16
*OurCommandLine
;
1554 SHELL_FILE_HANDLE
*TempFileHandle
;
1557 ASSERT(StdOut
== NULL
);
1559 ASSERT(StrStr(CmdLine
, L
"|") != NULL
);
1561 Status
= EFI_SUCCESS
;
1562 NextCommandLine
= NULL
;
1563 OurCommandLine
= NULL
;
1567 NextCommandLine
= StrnCatGrow(&NextCommandLine
, &Size1
, StrStr(CmdLine
, L
"|")+1, 0);
1568 OurCommandLine
= StrnCatGrow(&OurCommandLine
, &Size2
, CmdLine
, StrStr(CmdLine
, L
"|") - CmdLine
);
1570 if (NextCommandLine
== NULL
|| OurCommandLine
== NULL
) {
1571 SHELL_FREE_NON_NULL(OurCommandLine
);
1572 SHELL_FREE_NON_NULL(NextCommandLine
);
1573 return (EFI_OUT_OF_RESOURCES
);
1574 } else if (StrStr(OurCommandLine
, L
"|") != NULL
|| Size1
== 0 || Size2
== 0) {
1575 SHELL_FREE_NON_NULL(OurCommandLine
);
1576 SHELL_FREE_NON_NULL(NextCommandLine
);
1577 return (EFI_INVALID_PARAMETER
);
1578 } else if (NextCommandLine
[0] != CHAR_NULL
&&
1579 NextCommandLine
[0] == L
'a' &&
1580 NextCommandLine
[1] == L
' '
1582 CopyMem(NextCommandLine
, NextCommandLine
+1, StrSize(NextCommandLine
) - sizeof(NextCommandLine
[0]));
1590 // make a SPLIT_LIST item and add to list
1592 Split
= AllocateZeroPool(sizeof(SPLIT_LIST
));
1593 ASSERT(Split
!= NULL
);
1594 Split
->SplitStdIn
= StdIn
;
1595 Split
->SplitStdOut
= ConvertEfiFileProtocolToShellHandle(CreateFileInterfaceMem(Unicode
), NULL
);
1596 ASSERT(Split
->SplitStdOut
!= NULL
);
1597 InsertHeadList(&ShellInfoObject
.SplitList
.Link
, &Split
->Link
);
1599 Status
= RunCommand(OurCommandLine
, NULL
);
1602 // move the output from the first to the in to the second.
1604 TempFileHandle
= Split
->SplitStdOut
;
1605 if (Split
->SplitStdIn
== StdIn
) {
1606 Split
->SplitStdOut
= NULL
;
1608 Split
->SplitStdOut
= Split
->SplitStdIn
;
1610 Split
->SplitStdIn
= TempFileHandle
;
1611 ShellInfoObject
.NewEfiShellProtocol
->SetFilePosition(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdIn
), 0);
1613 if (!EFI_ERROR(Status
)) {
1614 Status
= RunCommand(NextCommandLine
, ExitStatus
);
1618 // remove the top level from the ScriptList
1620 ASSERT((SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
) == Split
);
1621 RemoveEntryList(&Split
->Link
);
1624 // Note that the original StdIn is now the StdOut...
1626 if (Split
->SplitStdOut
!= NULL
&& Split
->SplitStdOut
!= StdIn
) {
1627 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdOut
));
1629 if (Split
->SplitStdIn
!= NULL
) {
1630 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdIn
));
1634 FreePool(NextCommandLine
);
1635 FreePool(OurCommandLine
);
1641 Take the original command line, substitute any variables, free
1642 the original string, return the modified copy.
1644 @param[in] CmdLine pointer to the command line to update.
1646 @retval EFI_SUCCESS the function was successful.
1647 @retval EFI_OUT_OF_RESOURCES a memory allocation failed.
1651 ShellSubstituteVariables(
1656 NewCmdLine
= ShellConvertVariables(*CmdLine
);
1657 SHELL_FREE_NON_NULL(*CmdLine
);
1658 if (NewCmdLine
== NULL
) {
1659 return (EFI_OUT_OF_RESOURCES
);
1661 *CmdLine
= NewCmdLine
;
1662 return (EFI_SUCCESS
);
1666 Take the original command line, substitute any alias in the first group of space delimited characters, free
1667 the original string, return the modified copy.
1669 @param[in] CmdLine pointer to the command line to update.
1671 @retval EFI_SUCCESS the function was successful.
1672 @retval EFI_OUT_OF_RESOURCES a memory allocation failed.
1676 ShellSubstituteAliases(
1681 CHAR16
*CommandName
;
1683 UINTN PostAliasSize
;
1684 ASSERT(CmdLine
!= NULL
);
1685 ASSERT(*CmdLine
!= NULL
);
1689 if (StrStr((*CmdLine
), L
" ") == NULL
){
1690 StrnCatGrow(&CommandName
, NULL
, (*CmdLine
), 0);
1692 StrnCatGrow(&CommandName
, NULL
, (*CmdLine
), StrStr((*CmdLine
), L
" ") - (*CmdLine
));
1696 // This cannot happen 'inline' since the CmdLine can need extra space.
1699 if (!ShellCommandIsCommandOnList(CommandName
)) {
1701 // Convert via alias
1703 Status
= ShellConvertAlias(&CommandName
);
1704 if (EFI_ERROR(Status
)){
1708 NewCmdLine
= StrnCatGrow(&NewCmdLine
, &PostAliasSize
, CommandName
, 0);
1709 if (NewCmdLine
== NULL
) {
1710 SHELL_FREE_NON_NULL(CommandName
);
1711 SHELL_FREE_NON_NULL(*CmdLine
);
1712 return (EFI_OUT_OF_RESOURCES
);
1714 NewCmdLine
= StrnCatGrow(&NewCmdLine
, &PostAliasSize
, StrStr((*CmdLine
), L
" "), 0);
1715 if (NewCmdLine
== NULL
) {
1716 SHELL_FREE_NON_NULL(CommandName
);
1717 SHELL_FREE_NON_NULL(*CmdLine
);
1718 return (EFI_OUT_OF_RESOURCES
);
1721 NewCmdLine
= StrnCatGrow(&NewCmdLine
, NULL
, (*CmdLine
), 0);
1724 SHELL_FREE_NON_NULL(*CmdLine
);
1725 SHELL_FREE_NON_NULL(CommandName
);
1728 // re-assign the passed in double pointer to point to our newly allocated buffer
1730 *CmdLine
= NewCmdLine
;
1732 return (EFI_SUCCESS
);
1736 Takes the Argv[0] part of the command line and determine the meaning of it.
1738 @param[in] CmdName pointer to the command line to update.
1740 @retval Internal_Command The name is an internal command.
1741 @retval File_Sys_Change the name is a file system change.
1742 @retval Script_File_Name the name is a NSH script file.
1743 @retval Unknown_Invalid the name is unknown.
1744 @retval Efi_Application the name is an application (.EFI).
1746 SHELL_OPERATION_TYPES
1749 IN CONST CHAR16
*CmdName
1752 CHAR16
* FileWithPath
;
1753 CONST CHAR16
* TempLocation
;
1754 CONST CHAR16
* TempLocation2
;
1756 FileWithPath
= NULL
;
1758 // test for an internal command.
1760 if (ShellCommandIsCommandOnList(CmdName
)) {
1761 return (Internal_Command
);
1765 // Test for file system change request. anything ending with first : and cant have spaces.
1767 if (CmdName
[(StrLen(CmdName
)-1)] == L
':') {
1768 if ( StrStr(CmdName
, L
" ") != NULL
1769 || StrLen(StrStr(CmdName
, L
":")) > 1
1771 return (Unknown_Invalid
);
1773 return (File_Sys_Change
);
1779 if ((FileWithPath
= ShellFindFilePathEx(CmdName
, mExecutableExtensions
)) != NULL
) {
1781 // See if that file has a script file extension
1783 if (StrLen(FileWithPath
) > 4) {
1784 TempLocation
= FileWithPath
+StrLen(FileWithPath
)-4;
1785 TempLocation2
= mScriptExtension
;
1786 if (StringNoCaseCompare((VOID
*)(&TempLocation
), (VOID
*)(&TempLocation2
)) == 0) {
1787 SHELL_FREE_NON_NULL(FileWithPath
);
1788 return (Script_File_Name
);
1793 // Was a file, but not a script. we treat this as an application.
1795 SHELL_FREE_NON_NULL(FileWithPath
);
1796 return (Efi_Application
);
1799 SHELL_FREE_NON_NULL(FileWithPath
);
1801 // No clue what this is... return invalid flag...
1803 return (Unknown_Invalid
);
1807 Determine if the first item in a command line is valid.
1809 @param[in] CmdLine The command line to parse.
1811 @retval EFI_SUCCESS The item is valid.
1812 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
1813 @retval EFI_NOT_FOUND The operation type is unknown or invalid.
1818 IN CONST CHAR16
*CmdLine
1822 CHAR16
*FirstParameter
;
1828 Temp
= StrnCatGrow(&Temp
, NULL
, CmdLine
, 0);
1830 return (EFI_OUT_OF_RESOURCES
);
1833 FirstParameter
= StrStr(Temp
, L
"|");
1834 if (FirstParameter
!= NULL
) {
1835 *FirstParameter
= CHAR_NULL
;
1838 FirstParameter
= NULL
;
1841 // Process the command line
1843 Status
= ProcessCommandLineToFinal(&Temp
);
1845 if (!EFI_ERROR(Status
)) {
1846 FirstParameter
= AllocateZeroPool(StrSize(CmdLine
));
1847 if (FirstParameter
== NULL
) {
1848 SHELL_FREE_NON_NULL(Temp
);
1849 return (EFI_OUT_OF_RESOURCES
);
1851 TempWalker
= (CHAR16
*)Temp
;
1852 GetNextParameter(&TempWalker
, &FirstParameter
);
1854 if (GetOperationType(FirstParameter
) == Unknown_Invalid
) {
1855 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
1856 SetLastError(SHELL_NOT_FOUND
);
1857 Status
= EFI_NOT_FOUND
;
1861 SHELL_FREE_NON_NULL(Temp
);
1862 SHELL_FREE_NON_NULL(FirstParameter
);
1867 Determine if a command line contains with a split contains only valid commands.
1869 @param[in] CmdLine The command line to parse.
1871 @retval EFI_SUCCESS CmdLine has only valid commands, application, or has no split.
1872 @retval EFI_ABORTED CmdLine has at least one invalid command or application.
1877 IN CONST CHAR16
*CmdLine
1880 CONST CHAR16
*TempSpot
;
1884 // Verify up to the pipe or end character
1886 Status
= IsValidSplit(CmdLine
);
1887 if (EFI_ERROR(Status
)) {
1892 // If this was the only item, then get out
1894 if (!ContainsSplit(CmdLine
)) {
1895 return (EFI_SUCCESS
);
1899 // recurse to verify the next item
1901 TempSpot
= FindSplit(CmdLine
)+1;
1902 return (VerifySplit(TempSpot
));
1906 Process a split based operation.
1908 @param[in] CmdLine Pointer to the command line to process
1909 @param[out] ExitStatus The exit status of the command. Ignored if NULL.
1910 Invalid if this function returns an error.
1912 @retval EFI_SUCCESS The operation was successful
1913 @return an error occured.
1917 ProcessNewSplitCommandLine(
1918 IN CONST CHAR16
*CmdLine
,
1919 OUT SHELL_STATUS
*ExitStatus
1925 Status
= VerifySplit(CmdLine
);
1926 if (EFI_ERROR(Status
)) {
1933 // are we in an existing split???
1935 if (!IsListEmpty(&ShellInfoObject
.SplitList
.Link
)) {
1936 Split
= (SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
);
1939 if (Split
== NULL
) {
1940 Status
= RunSplitCommand(CmdLine
, NULL
, NULL
, ExitStatus
);
1942 Status
= RunSplitCommand(
1949 if (EFI_ERROR(Status
)) {
1950 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_SPLIT
), ShellInfoObject
.HiiHandle
, CmdLine
);
1956 Handle a request to change the current file system.
1958 @param[in] CmdLine The passed in command line.
1960 @retval EFI_SUCCESS The operation was successful.
1965 IN CONST CHAR16
*CmdLine
1969 Status
= EFI_SUCCESS
;
1972 // make sure we are the right operation
1974 ASSERT(CmdLine
[(StrLen(CmdLine
)-1)] == L
':' && StrStr(CmdLine
, L
" ") == NULL
);
1977 // Call the protocol API to do the work
1979 Status
= ShellInfoObject
.NewEfiShellProtocol
->SetCurDir(NULL
, CmdLine
);
1982 // Report any errors
1984 if (EFI_ERROR(Status
)) {
1985 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_MAPPING
), ShellInfoObject
.HiiHandle
, CmdLine
);
1992 Reprocess the command line to direct all -? to the help command.
1994 if found, will add "help" as argv[0], and move the rest later.
1996 @param[in,out] CmdLine pointer to the command line to update
2001 IN OUT CHAR16
**CmdLine
2004 CHAR16
*CurrentParameter
;
2007 CHAR16
*NewCommandLine
;
2010 Status
= EFI_SUCCESS
;
2012 CurrentParameter
= AllocateZeroPool(StrSize(*CmdLine
));
2013 if (CurrentParameter
== NULL
) {
2014 return (EFI_OUT_OF_RESOURCES
);
2018 while(Walker
!= NULL
&& *Walker
!= CHAR_NULL
) {
2019 LastWalker
= Walker
;
2020 GetNextParameter(&Walker
, &CurrentParameter
);
2021 if (StrStr(CurrentParameter
, L
"-?") == CurrentParameter
) {
2022 LastWalker
[0] = L
' ';
2023 LastWalker
[1] = L
' ';
2024 NewCommandLine
= AllocateZeroPool(StrSize(L
"help ") + StrSize(*CmdLine
));
2025 if (NewCommandLine
== NULL
) {
2026 Status
= EFI_OUT_OF_RESOURCES
;
2029 StrCpy(NewCommandLine
, L
"help ");
2030 StrCat(NewCommandLine
, *CmdLine
);
2031 SHELL_FREE_NON_NULL(*CmdLine
);
2032 *CmdLine
= NewCommandLine
;
2037 SHELL_FREE_NON_NULL(CurrentParameter
);
2043 Function to update the shell variable "lasterror".
2045 @param[in] ErrorCode the error code to put into lasterror.
2050 IN CONST SHELL_STATUS ErrorCode
2053 CHAR16 LeString
[19];
2054 if (sizeof(EFI_STATUS
) == sizeof(UINT64
)) {
2055 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%Lx", ErrorCode
);
2057 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%x", ErrorCode
);
2059 DEBUG_CODE(InternalEfiShellSetEnv(L
"debuglasterror", LeString
, TRUE
););
2060 InternalEfiShellSetEnv(L
"lasterror", LeString
, TRUE
);
2062 return (EFI_SUCCESS
);
2066 Converts the command line to it's post-processed form. this replaces variables and alias' per UEFI Shell spec.
2068 @param[in,out] CmdLine pointer to the command line to update
2070 @retval EFI_SUCCESS The operation was successful
2071 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
2072 @return some other error occured
2076 ProcessCommandLineToFinal(
2077 IN OUT CHAR16
**CmdLine
2081 TrimSpaces(CmdLine
);
2083 Status
= ShellSubstituteAliases(CmdLine
);
2084 if (EFI_ERROR(Status
)) {
2088 TrimSpaces(CmdLine
);
2090 Status
= ShellSubstituteVariables(CmdLine
);
2091 if (EFI_ERROR(Status
)) {
2095 TrimSpaces(CmdLine
);
2098 // update for help parsing
2100 if (StrStr(*CmdLine
, L
"?") != NULL
) {
2102 // This may do nothing if the ? does not indicate help.
2103 // Save all the details for in the API below.
2105 Status
= DoHelpUpdate(CmdLine
);
2108 TrimSpaces(CmdLine
);
2110 return (EFI_SUCCESS
);
2114 Run an internal shell command.
2116 This API will upadate the shell's environment since these commands are libraries.
2118 @param[in] CmdLine the command line to run.
2119 @param[in] FirstParameter the first parameter on the command line
2120 @param[in] ParamProtocol the shell parameters protocol pointer
2122 @param[out] ExitStatus The exit code of the command. Ignored if NULL.
2124 @retval EFI_SUCCESS The command was completed.
2125 @retval EFI_ABORTED The command's operation was aborted.
2130 IN CONST CHAR16
*CmdLine
,
2131 IN CHAR16
*FirstParameter
,
2132 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2133 OUT SHELL_STATUS
*ExitStatus OPTIONAL
2139 SHELL_STATUS CommandReturnedStatus
;
2143 // get the argc and argv updated for internal commands
2145 Status
= UpdateArgcArgv(ParamProtocol
, CmdLine
, &Argv
, &Argc
);
2146 if (!EFI_ERROR(Status
)) {
2148 // Run the internal command.
2150 Status
= ShellCommandRunCommandHandler(FirstParameter
, &CommandReturnedStatus
, &LastError
);
2152 if (!EFI_ERROR(Status
)) {
2154 // Update last error status.
2155 // some commands do not update last error.
2158 SetLastError(CommandReturnedStatus
);
2160 if (ExitStatus
!= NULL
) {
2161 *ExitStatus
= CommandReturnedStatus
;
2165 // Pass thru the exitcode from the app.
2167 if (ShellCommandGetExit()) {
2169 // An Exit was requested ("exit" command), pass its value up.
2171 Status
= CommandReturnedStatus
;
2172 } else if (CommandReturnedStatus
!= SHELL_SUCCESS
&& IsScriptOnlyCommand(FirstParameter
)) {
2174 // Always abort when a script only command fails for any reason
2176 Status
= EFI_ABORTED
;
2177 } else if (ShellCommandGetCurrentScriptFile() != NULL
&& CommandReturnedStatus
== SHELL_ABORTED
) {
2179 // Abort when in a script and a command aborted
2181 Status
= EFI_ABORTED
;
2187 // This is guarenteed to be called after UpdateArgcArgv no matter what else happened.
2188 // This is safe even if the update API failed. In this case, it may be a no-op.
2190 RestoreArgcArgv(ParamProtocol
, &Argv
, &Argc
);
2193 // If a script is running and the command is not a scipt only command, then
2194 // change return value to success so the script won't halt (unless aborted).
2196 // Script only commands have to be able halt the script since the script will
2197 // not operate if they are failing.
2199 if ( ShellCommandGetCurrentScriptFile() != NULL
2200 && !IsScriptOnlyCommand(FirstParameter
)
2201 && Status
!= EFI_ABORTED
2203 Status
= EFI_SUCCESS
;
2210 Function to run the command or file.
2212 @param[in] Type the type of operation being run.
2213 @param[in] CmdLine the command line to run.
2214 @param[in] FirstParameter the first parameter on the command line
2215 @param[in] ParamProtocol the shell parameters protocol pointer
2217 @param[out] ExitStatus The exit code of the command or file.
2220 @retval EFI_SUCCESS The command was completed.
2221 @retval EFI_ABORTED The command's operation was aborted.
2226 IN SHELL_OPERATION_TYPES Type
,
2227 IN CONST CHAR16
*CmdLine
,
2228 IN CHAR16
*FirstParameter
,
2229 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2230 OUT SHELL_STATUS
*ExitStatus
2234 CHAR16
*CommandWithPath
;
2235 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
2236 SHELL_STATUS CalleeExitStatus
;
2238 Status
= EFI_SUCCESS
;
2239 CommandWithPath
= NULL
;
2241 CalleeExitStatus
= SHELL_INVALID_PARAMETER
;
2244 case Internal_Command
:
2245 Status
= RunInternalCommand(
2252 case Script_File_Name
:
2253 case Efi_Application
:
2255 // Process a fully qualified path
2257 if (StrStr(FirstParameter
, L
":") != NULL
) {
2258 ASSERT (CommandWithPath
== NULL
);
2259 if (ShellIsFile(FirstParameter
) == EFI_SUCCESS
) {
2260 CommandWithPath
= StrnCatGrow(&CommandWithPath
, NULL
, FirstParameter
, 0);
2265 // Process a relative path and also check in the path environment variable
2267 if (CommandWithPath
== NULL
) {
2268 CommandWithPath
= ShellFindFilePathEx(FirstParameter
, mExecutableExtensions
);
2272 // This should be impossible now.
2274 ASSERT(CommandWithPath
!= NULL
);
2277 // Make sure that path is not just a directory (or not found)
2279 if (!EFI_ERROR(ShellIsDirectory(CommandWithPath
))) {
2280 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2281 SetLastError(SHELL_NOT_FOUND
);
2284 case Script_File_Name
:
2285 Status
= RunScriptFile (
2293 case Efi_Application
:
2295 // Get the device path of the application image
2297 DevPath
= ShellInfoObject
.NewEfiShellProtocol
->GetDevicePathFromFilePath(CommandWithPath
);
2298 if (DevPath
== NULL
){
2299 Status
= EFI_OUT_OF_RESOURCES
;
2304 // Execute the device path
2306 Status
= InternalShellExecuteDevicePath(
2315 SHELL_FREE_NON_NULL(DevPath
);
2317 if(EFI_ERROR (Status
)) {
2318 CalleeExitStatus
= (SHELL_STATUS
) (Status
& (~MAX_BIT
));
2320 CalleeExitStatus
= SHELL_SUCCESS
;
2324 // Update last error status.
2326 // Status is an EFI_STATUS. Clear top bit to convert to SHELL_STATUS
2327 SetLastError(CalleeExitStatus
);
2343 SHELL_FREE_NON_NULL(CommandWithPath
);
2345 if (ExitStatus
!= NULL
) {
2346 *ExitStatus
= CalleeExitStatus
;
2353 Function to setup StdIn, StdErr, StdOut, and then run the command or file.
2355 @param[in] Type the type of operation being run.
2356 @param[in] CmdLine the command line to run.
2357 @param[in] FirstParameter the first parameter on the command line.
2358 @param[in] ParamProtocol the shell parameters protocol pointer
2360 @param[out] ExitStatus The exit code of the command or file.
2363 @retval EFI_SUCCESS The command was completed.
2364 @retval EFI_ABORTED The command's operation was aborted.
2368 SetupAndRunCommandOrFile(
2369 IN SHELL_OPERATION_TYPES Type
,
2371 IN CHAR16
*FirstParameter
,
2372 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2373 OUT SHELL_STATUS
*ExitStatus
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 Status
= RunCommandOrFile(
2404 if (EFI_ERROR(Status
)) {
2405 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_ERROR
), ShellInfoObject
.HiiHandle
, (VOID
*)(Status
));
2409 // put back the original StdIn, StdOut, and StdErr
2411 RestoreStdInStdOutStdErr(ParamProtocol
, &OriginalStdIn
, &OriginalStdOut
, &OriginalStdErr
, &OriginalSystemTableInfo
);
2417 Function will process and run a command line.
2419 This will determine if the command line represents an internal shell
2420 command or dispatch an external application.
2422 @param[in] CmdLine The command line to parse.
2423 @param[out] ExitStatus The exit code of the command. Ignored if NULL.
2425 @retval EFI_SUCCESS The command was completed.
2426 @retval EFI_ABORTED The command's operation was aborted.
2431 IN CONST CHAR16
*CmdLine
,
2432 OUT SHELL_STATUS
*ExitStatus
2436 CHAR16
*CleanOriginal
;
2437 CHAR16
*FirstParameter
;
2439 SHELL_OPERATION_TYPES Type
;
2441 ASSERT(CmdLine
!= NULL
);
2442 if (StrLen(CmdLine
) == 0) {
2443 return (EFI_SUCCESS
);
2446 Status
= EFI_SUCCESS
;
2447 CleanOriginal
= NULL
;
2449 CleanOriginal
= StrnCatGrow(&CleanOriginal
, NULL
, CmdLine
, 0);
2450 if (CleanOriginal
== NULL
) {
2451 return (EFI_OUT_OF_RESOURCES
);
2454 TrimSpaces(&CleanOriginal
);
2457 // Handle case that passed in command line is just 1 or more " " characters.
2459 if (StrLen (CleanOriginal
) == 0) {
2460 SHELL_FREE_NON_NULL(CleanOriginal
);
2461 return (EFI_SUCCESS
);
2464 Status
= ProcessCommandLineToFinal(&CleanOriginal
);
2465 if (EFI_ERROR(Status
)) {
2466 SHELL_FREE_NON_NULL(CleanOriginal
);
2471 // We dont do normal processing with a split command line (output from one command input to another)
2473 if (ContainsSplit(CleanOriginal
)) {
2474 Status
= ProcessNewSplitCommandLine(CleanOriginal
, ExitStatus
);
2475 SHELL_FREE_NON_NULL(CleanOriginal
);
2480 // We need the first parameter information so we can determine the operation type
2482 FirstParameter
= AllocateZeroPool(StrSize(CleanOriginal
));
2483 if (FirstParameter
== NULL
) {
2484 SHELL_FREE_NON_NULL(CleanOriginal
);
2485 return (EFI_OUT_OF_RESOURCES
);
2487 TempWalker
= CleanOriginal
;
2488 GetNextParameter(&TempWalker
, &FirstParameter
);
2491 // Depending on the first parameter we change the behavior
2493 switch (Type
= GetOperationType(FirstParameter
)) {
2494 case File_Sys_Change
:
2495 Status
= ChangeMappedDrive (FirstParameter
);
2497 case Internal_Command
:
2498 case Script_File_Name
:
2499 case Efi_Application
:
2500 Status
= SetupAndRunCommandOrFile(
2504 ShellInfoObject
.NewShellParametersProtocol
,
2510 // Whatever was typed, it was invalid.
2512 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2513 SetLastError(SHELL_NOT_FOUND
);
2517 SHELL_FREE_NON_NULL(CleanOriginal
);
2518 SHELL_FREE_NON_NULL(FirstParameter
);
2523 STATIC CONST UINT16 InvalidChars
[] = {L
'*', L
'?', L
'<', L
'>', L
'\\', L
'/', L
'\"', 0x0001, 0x0002};
2525 Function determins if the CommandName COULD be a valid command. It does not determine whether
2526 this is a valid command. It only checks for invalid characters.
2528 @param[in] CommandName The name to check
2530 @retval TRUE CommandName could be a command name
2531 @retval FALSE CommandName could not be a valid command name
2536 IN CONST CHAR16
*CommandName
2540 if (CommandName
== NULL
) {
2545 ; Count
< sizeof(InvalidChars
) / sizeof(InvalidChars
[0])
2548 if (ScanMem16(CommandName
, StrSize(CommandName
), InvalidChars
[Count
]) != NULL
) {
2556 Function to process a NSH script file via SHELL_FILE_HANDLE.
2558 @param[in] Handle The handle to the already opened file.
2559 @param[in] Name The name of the script file.
2561 @param[out] ExitStatus The exit code of the script. Ignored if NULL.
2563 @retval EFI_SUCCESS the script completed sucessfully
2567 RunScriptFileHandle (
2568 IN SHELL_FILE_HANDLE Handle
,
2569 IN CONST CHAR16
*Name
,
2570 OUT SHELL_STATUS
*ExitStatus
2574 SCRIPT_FILE
*NewScriptFile
;
2576 CHAR16
*CommandLine
;
2577 CHAR16
*CommandLine2
;
2578 CHAR16
*CommandLine3
;
2579 SCRIPT_COMMAND_LIST
*LastCommand
;
2581 BOOLEAN PreScriptEchoState
;
2582 BOOLEAN PreCommandEchoState
;
2583 CONST CHAR16
*CurDir
;
2585 CHAR16 LeString
[50];
2586 SHELL_STATUS CalleeExitStatus
;
2588 ASSERT(!ShellCommandGetScriptExit());
2590 CalleeExitStatus
= SHELL_SUCCESS
;
2592 PreScriptEchoState
= ShellCommandGetEchoState();
2594 NewScriptFile
= (SCRIPT_FILE
*)AllocateZeroPool(sizeof(SCRIPT_FILE
));
2595 if (NewScriptFile
== NULL
) {
2596 return (EFI_OUT_OF_RESOURCES
);
2602 ASSERT(NewScriptFile
->ScriptName
== NULL
);
2603 NewScriptFile
->ScriptName
= StrnCatGrow(&NewScriptFile
->ScriptName
, NULL
, Name
, 0);
2604 if (NewScriptFile
->ScriptName
== NULL
) {
2605 DeleteScriptFileStruct(NewScriptFile
);
2606 return (EFI_OUT_OF_RESOURCES
);
2610 // Save the parameters (used to replace %0 to %9 later on)
2612 NewScriptFile
->Argc
= ShellInfoObject
.NewShellParametersProtocol
->Argc
;
2613 if (NewScriptFile
->Argc
!= 0) {
2614 NewScriptFile
->Argv
= (CHAR16
**)AllocateZeroPool(NewScriptFile
->Argc
* sizeof(CHAR16
*));
2615 if (NewScriptFile
->Argv
== NULL
) {
2616 DeleteScriptFileStruct(NewScriptFile
);
2617 return (EFI_OUT_OF_RESOURCES
);
2619 for (LoopVar
= 0 ; LoopVar
< 10 && LoopVar
< NewScriptFile
->Argc
; LoopVar
++) {
2620 ASSERT(NewScriptFile
->Argv
[LoopVar
] == NULL
);
2621 NewScriptFile
->Argv
[LoopVar
] = StrnCatGrow(&NewScriptFile
->Argv
[LoopVar
], NULL
, ShellInfoObject
.NewShellParametersProtocol
->Argv
[LoopVar
], 0);
2622 if (NewScriptFile
->Argv
[LoopVar
] == NULL
) {
2623 DeleteScriptFileStruct(NewScriptFile
);
2624 return (EFI_OUT_OF_RESOURCES
);
2628 NewScriptFile
->Argv
= NULL
;
2631 InitializeListHead(&NewScriptFile
->CommandList
);
2632 InitializeListHead(&NewScriptFile
->SubstList
);
2635 // Now build the list of all script commands.
2638 while(!ShellFileHandleEof(Handle
)) {
2639 CommandLine
= ShellFileHandleReturnLine(Handle
, &Ascii
);
2641 if (CommandLine
== NULL
|| StrLen(CommandLine
) == 0 || CommandLine
[0] == '#') {
2642 SHELL_FREE_NON_NULL(CommandLine
);
2645 NewScriptFile
->CurrentCommand
= AllocateZeroPool(sizeof(SCRIPT_COMMAND_LIST
));
2646 if (NewScriptFile
->CurrentCommand
== NULL
) {
2647 SHELL_FREE_NON_NULL(CommandLine
);
2648 DeleteScriptFileStruct(NewScriptFile
);
2649 return (EFI_OUT_OF_RESOURCES
);
2652 NewScriptFile
->CurrentCommand
->Cl
= CommandLine
;
2653 NewScriptFile
->CurrentCommand
->Data
= NULL
;
2654 NewScriptFile
->CurrentCommand
->Line
= LineCount
;
2656 InsertTailList(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
2660 // Add this as the topmost script file
2662 ShellCommandSetNewScript (NewScriptFile
);
2665 // Now enumerate through the commands and run each one.
2667 CommandLine
= AllocateZeroPool(PcdGet16(PcdShellPrintBufferSize
));
2668 if (CommandLine
== NULL
) {
2669 DeleteScriptFileStruct(NewScriptFile
);
2670 return (EFI_OUT_OF_RESOURCES
);
2672 CommandLine2
= AllocateZeroPool(PcdGet16(PcdShellPrintBufferSize
));
2673 if (CommandLine2
== NULL
) {
2674 FreePool(CommandLine
);
2675 DeleteScriptFileStruct(NewScriptFile
);
2676 return (EFI_OUT_OF_RESOURCES
);
2679 for ( NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetFirstNode(&NewScriptFile
->CommandList
)
2680 ; !IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)
2681 ; // conditional increment in the body of the loop
2683 ASSERT(CommandLine2
!= NULL
);
2684 StrCpy(CommandLine2
, NewScriptFile
->CurrentCommand
->Cl
);
2687 // NULL out comments
2689 for (CommandLine3
= CommandLine2
; CommandLine3
!= NULL
&& *CommandLine3
!= CHAR_NULL
; CommandLine3
++) {
2690 if (*CommandLine3
== L
'^') {
2691 if (*(CommandLine3
+1) == L
'#' || *(CommandLine3
+1) == L
':') {
2692 CopyMem(CommandLine3
, CommandLine3
+1, StrSize(CommandLine3
) - sizeof(CommandLine3
[0]));
2694 } else if (*CommandLine3
== L
'#') {
2695 *CommandLine3
= CHAR_NULL
;
2699 if (CommandLine2
!= NULL
&& StrLen(CommandLine2
) >= 1) {
2701 // Due to variability in starting the find and replace action we need to have both buffers the same.
2703 StrCpy(CommandLine
, CommandLine2
);
2706 // Remove the %0 to %9 from the command line (if we have some arguments)
2708 if (NewScriptFile
->Argv
!= NULL
) {
2709 switch (NewScriptFile
->Argc
) {
2711 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%9", NewScriptFile
->Argv
[9], FALSE
, TRUE
);
2712 ASSERT_EFI_ERROR(Status
);
2714 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%8", NewScriptFile
->Argv
[8], FALSE
, TRUE
);
2715 ASSERT_EFI_ERROR(Status
);
2717 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%7", NewScriptFile
->Argv
[7], FALSE
, TRUE
);
2718 ASSERT_EFI_ERROR(Status
);
2720 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%6", NewScriptFile
->Argv
[6], FALSE
, TRUE
);
2721 ASSERT_EFI_ERROR(Status
);
2723 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%5", NewScriptFile
->Argv
[5], FALSE
, TRUE
);
2724 ASSERT_EFI_ERROR(Status
);
2726 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%4", NewScriptFile
->Argv
[4], FALSE
, TRUE
);
2727 ASSERT_EFI_ERROR(Status
);
2729 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%3", NewScriptFile
->Argv
[3], FALSE
, TRUE
);
2730 ASSERT_EFI_ERROR(Status
);
2732 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%2", NewScriptFile
->Argv
[2], FALSE
, TRUE
);
2733 ASSERT_EFI_ERROR(Status
);
2735 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%1", NewScriptFile
->Argv
[1], FALSE
, TRUE
);
2736 ASSERT_EFI_ERROR(Status
);
2738 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%0", NewScriptFile
->Argv
[0], FALSE
, TRUE
);
2739 ASSERT_EFI_ERROR(Status
);
2745 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%1", L
"\"\"", FALSE
, FALSE
);
2746 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%2", L
"\"\"", FALSE
, FALSE
);
2747 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%3", L
"\"\"", FALSE
, FALSE
);
2748 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%4", L
"\"\"", FALSE
, FALSE
);
2749 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%5", L
"\"\"", FALSE
, FALSE
);
2750 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%6", L
"\"\"", FALSE
, FALSE
);
2751 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%7", L
"\"\"", FALSE
, FALSE
);
2752 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%8", L
"\"\"", FALSE
, FALSE
);
2753 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%9", L
"\"\"", FALSE
, FALSE
);
2755 StrCpy(CommandLine2
, CommandLine
);
2757 LastCommand
= NewScriptFile
->CurrentCommand
;
2759 for (CommandLine3
= CommandLine2
; CommandLine3
[0] == L
' ' ; CommandLine3
++);
2761 if (CommandLine3
!= NULL
&& CommandLine3
[0] == L
':' ) {
2763 // This line is a goto target / label
2766 if (CommandLine3
!= NULL
&& StrLen(CommandLine3
) > 0) {
2767 if (CommandLine3
[0] == L
'@') {
2769 // We need to save the current echo state
2770 // and disable echo for just this command.
2772 PreCommandEchoState
= ShellCommandGetEchoState();
2773 ShellCommandSetEchoState(FALSE
);
2774 Status
= RunCommand(CommandLine3
+1, NULL
);
2777 // If command was "@echo -off" or "@echo -on" then don't restore echo state
2779 if (StrCmp (L
"@echo -off", CommandLine3
) != 0 &&
2780 StrCmp (L
"@echo -on", CommandLine3
) != 0) {
2782 // Now restore the pre-'@' echo state.
2784 ShellCommandSetEchoState(PreCommandEchoState
);
2787 if (ShellCommandGetEchoState()) {
2788 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
2789 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
2790 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
2792 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
2794 ShellPrintEx(-1, -1, L
"%s\r\n", CommandLine2
);
2796 Status
= RunCommand(CommandLine3
, NULL
);
2800 if (ShellCommandGetScriptExit()) {
2802 // ShellCommandGetExitCode() always returns a UINT64
2804 CalleeExitStatus
= (SHELL_STATUS
) ShellCommandGetExitCode();
2805 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%Lx", CalleeExitStatus
);
2806 DEBUG_CODE(InternalEfiShellSetEnv(L
"debuglasterror", LeString
, TRUE
););
2807 InternalEfiShellSetEnv(L
"lasterror", LeString
, TRUE
);
2809 ShellCommandRegisterExit(FALSE
, 0);
2810 Status
= EFI_SUCCESS
;
2813 if (ShellGetExecutionBreakFlag()) {
2816 if (EFI_ERROR(Status
)) {
2817 CalleeExitStatus
= (SHELL_STATUS
) Status
;
2820 if (ShellCommandGetExit()) {
2821 CalleeExitStatus
= (SHELL_STATUS
) ShellCommandGetExitCode();
2826 // If that commend did not update the CurrentCommand then we need to advance it...
2828 if (LastCommand
== NewScriptFile
->CurrentCommand
) {
2829 NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetNextNode(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
2830 if (!IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)) {
2831 NewScriptFile
->CurrentCommand
->Reset
= TRUE
;
2835 NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetNextNode(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
2836 if (!IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)) {
2837 NewScriptFile
->CurrentCommand
->Reset
= TRUE
;
2843 FreePool(CommandLine
);
2844 FreePool(CommandLine2
);
2845 ShellCommandSetNewScript (NULL
);
2848 // Only if this was the last script reset the state.
2850 if (ShellCommandGetCurrentScriptFile()==NULL
) {
2851 ShellCommandSetEchoState(PreScriptEchoState
);
2854 if (ExitStatus
!= NULL
) {
2855 *ExitStatus
= CalleeExitStatus
;
2858 return (EFI_SUCCESS
);
2862 Function to process a NSH script file.
2864 @param[in] ScriptPath Pointer to the script file name (including file system path).
2865 @param[in] Handle the handle of the script file already opened.
2866 @param[in] CmdLine the command line to run.
2867 @param[in] ParamProtocol the shell parameters protocol pointer
2869 @param[out] ExitStatus The exit code of the script. Ignored if NULL.
2871 @retval EFI_SUCCESS the script completed sucessfully
2876 IN CONST CHAR16
*ScriptPath
,
2877 IN SHELL_FILE_HANDLE Handle OPTIONAL
,
2878 IN CONST CHAR16
*CmdLine
,
2879 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2880 OUT SHELL_STATUS
*ExitStatus
2884 SHELL_FILE_HANDLE FileHandle
;
2888 if (ShellIsFile(ScriptPath
) != EFI_SUCCESS
) {
2889 return (EFI_INVALID_PARAMETER
);
2893 // get the argc and argv updated for scripts
2895 Status
= UpdateArgcArgv(ParamProtocol
, CmdLine
, &Argv
, &Argc
);
2896 if (!EFI_ERROR(Status
)) {
2898 if (Handle
== NULL
) {
2902 Status
= ShellOpenFileByName(ScriptPath
, &FileHandle
, EFI_FILE_MODE_READ
, 0);
2903 if (!EFI_ERROR(Status
)) {
2907 Status
= RunScriptFileHandle(FileHandle
, ScriptPath
, ExitStatus
);
2910 // now close the file
2912 ShellCloseFile(&FileHandle
);
2915 Status
= RunScriptFileHandle(Handle
, ScriptPath
, ExitStatus
);
2920 // This is guarenteed to be called after UpdateArgcArgv no matter what else happened.
2921 // This is safe even if the update API failed. In this case, it may be a no-op.
2923 RestoreArgcArgv(ParamProtocol
, &Argv
, &Argc
);