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;
838 // Start LoopVar at 1 to ignore Argv[0] which is the name of this binary
839 // (probably "Shell.efi")
840 for (LoopVar
= 1 ; LoopVar
< gEfiShellParametersProtocol
->Argc
; LoopVar
++) {
841 CurrentArg
= gEfiShellParametersProtocol
->Argv
[LoopVar
];
842 if (UnicodeCollation
->StriColl (
847 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
= TRUE
;
849 else if (UnicodeCollation
->StriColl (
854 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
= TRUE
;
856 else if (UnicodeCollation
->StriColl (
861 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleOut
= TRUE
;
863 else if (UnicodeCollation
->StriColl (
868 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
= TRUE
;
870 else if (UnicodeCollation
->StriColl (
875 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
= TRUE
;
877 else if (UnicodeCollation
->StriColl (
882 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoMap
= TRUE
;
884 else if (UnicodeCollation
->StriColl (
889 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoVersion
= TRUE
;
891 else if (UnicodeCollation
->StriColl (
896 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Delay
= TRUE
;
897 // Check for optional delay value following "-delay"
898 DelayValueStr
= gEfiShellParametersProtocol
->Argv
[LoopVar
+ 1];
899 if (DelayValueStr
!= NULL
){
900 if (*DelayValueStr
== L
':') {
903 if (!EFI_ERROR(ShellConvertStringToUint64 (
909 ShellInfoObject
.ShellInitSettings
.Delay
= (UINTN
)DelayValue
;
913 } else if (UnicodeCollation
->StriColl (
918 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Exit
= TRUE
;
919 } else if (StrnCmp (L
"-", CurrentArg
, 1) == 0) {
920 // Unrecognised option
921 ShellPrintHiiEx(-1, -1, NULL
,
922 STRING_TOKEN (STR_GEN_PROBLEM
),
923 ShellInfoObject
.HiiHandle
,
926 return EFI_INVALID_PARAMETER
;
928 ShellInfoObject
.ShellInitSettings
.FileName
= AllocateZeroPool(StrSize(CurrentArg
));
929 if (ShellInfoObject
.ShellInitSettings
.FileName
== NULL
) {
930 return (EFI_OUT_OF_RESOURCES
);
933 // We found `file-name`.
935 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
= 1;
937 StrCpy (ShellInfoObject
.ShellInitSettings
.FileName
, CurrentArg
);
940 // Add `file-name-options`
941 for (Size
= 0 ; LoopVar
< gEfiShellParametersProtocol
->Argc
; LoopVar
++) {
942 ASSERT((ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
&& Size
== 0) || (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
));
943 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileOptions
,
947 if (ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
) {
948 SHELL_FREE_NON_NULL(ShellInfoObject
.ShellInitSettings
.FileName
);
949 return (EFI_OUT_OF_RESOURCES
);
951 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileOptions
,
953 gEfiShellParametersProtocol
->Argv
[LoopVar
],
955 if (ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
) {
956 SHELL_FREE_NON_NULL(ShellInfoObject
.ShellInitSettings
.FileName
);
957 return (EFI_OUT_OF_RESOURCES
);
963 // "-nointerrupt" overrides "-delay"
964 if (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
) {
965 ShellInfoObject
.ShellInitSettings
.Delay
= 0;
972 Handles all interaction with the default startup script.
974 this will check that the correct command line parameters were passed, handle the delay, and then start running the script.
976 @param ImagePath the path to the image for shell. first place to look for the startup script
977 @param FilePath the path to the file for shell. second place to look for the startup script.
979 @param[out] ExitStatus The exit code of the script. Ignored if NULL.
981 @retval EFI_SUCCESS the variable is initialized.
986 IN EFI_DEVICE_PATH_PROTOCOL
*ImagePath
,
987 IN EFI_DEVICE_PATH_PROTOCOL
*FilePath
,
988 OUT SHELL_STATUS
*ExitStatus
994 SHELL_FILE_HANDLE FileHandle
;
995 EFI_DEVICE_PATH_PROTOCOL
*NewPath
;
996 EFI_DEVICE_PATH_PROTOCOL
*NamePath
;
997 CHAR16
*FileStringPath
;
1000 CONST CHAR16
*MapName
;
1002 Key
.UnicodeChar
= CHAR_NULL
;
1006 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
&& ShellInfoObject
.ShellInitSettings
.FileName
!= NULL
) {
1008 // launch something else instead
1010 NewSize
= StrSize(ShellInfoObject
.ShellInitSettings
.FileName
);
1011 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
1012 NewSize
+= StrSize(ShellInfoObject
.ShellInitSettings
.FileOptions
) + sizeof(CHAR16
);
1014 FileStringPath
= AllocateZeroPool(NewSize
);
1015 if (FileStringPath
== NULL
) {
1016 return (EFI_OUT_OF_RESOURCES
);
1018 StrCpy(FileStringPath
, ShellInfoObject
.ShellInitSettings
.FileName
);
1019 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
1020 StrCat(FileStringPath
, L
" ");
1021 StrCat(FileStringPath
, ShellInfoObject
.ShellInitSettings
.FileOptions
);
1023 Status
= RunCommand(FileStringPath
, ExitStatus
);
1024 FreePool(FileStringPath
);
1030 // for shell level 0 we do no scripts
1031 // Without the Startup bit overriding we allow for nostartup to prevent scripts
1033 if ( (PcdGet8(PcdShellSupportLevel
) < 1)
1034 || (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
&& !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
)
1036 return (EFI_SUCCESS
);
1039 gST
->ConOut
->EnableCursor(gST
->ConOut
, FALSE
);
1041 // print out our warning and see if they press a key
1043 for ( Status
= EFI_UNSUPPORTED
, Delay
= ShellInfoObject
.ShellInitSettings
.Delay
1044 ; Delay
!= 0 && EFI_ERROR(Status
)
1047 ShellPrintHiiEx(0, gST
->ConOut
->Mode
->CursorRow
, NULL
, STRING_TOKEN (STR_SHELL_STARTUP_QUESTION
), ShellInfoObject
.HiiHandle
, Delay
);
1048 gBS
->Stall (1000000);
1049 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
1050 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
1053 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CRLF
), ShellInfoObject
.HiiHandle
);
1054 gST
->ConOut
->EnableCursor(gST
->ConOut
, TRUE
);
1059 if (Status
== EFI_SUCCESS
&& Key
.UnicodeChar
== 0 && Key
.ScanCode
== SCAN_ESC
) {
1060 return (EFI_SUCCESS
);
1064 // Try the first location (must be file system)
1066 MapName
= ShellInfoObject
.NewEfiShellProtocol
->GetMapFromDevicePath(&ImagePath
);
1067 if (MapName
!= NULL
) {
1068 FileStringPath
= NULL
;
1070 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, MapName
, 0);
1071 if (FileStringPath
== NULL
) {
1072 Status
= EFI_OUT_OF_RESOURCES
;
1074 TempSpot
= StrStr(FileStringPath
, L
";");
1075 if (TempSpot
!= NULL
) {
1076 *TempSpot
= CHAR_NULL
;
1078 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, ((FILEPATH_DEVICE_PATH
*)FilePath
)->PathName
, 0);
1079 PathRemoveLastItem(FileStringPath
);
1080 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, mStartupScript
, 0);
1081 Status
= ShellInfoObject
.NewEfiShellProtocol
->OpenFileByName(FileStringPath
, &FileHandle
, EFI_FILE_MODE_READ
);
1082 FreePool(FileStringPath
);
1085 if (EFI_ERROR(Status
)) {
1086 NamePath
= FileDevicePath (NULL
, mStartupScript
);
1087 NewPath
= AppendDevicePathNode (ImagePath
, NamePath
);
1093 Status
= InternalOpenFileDevicePath(NewPath
, &FileHandle
, EFI_FILE_MODE_READ
, 0);
1097 // If we got a file, run it
1099 if (!EFI_ERROR(Status
) && FileHandle
!= NULL
) {
1100 Status
= RunScriptFile (
1104 ShellInfoObject
.NewShellParametersProtocol
,
1107 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(FileHandle
);
1109 FileStringPath
= ShellFindFilePath(mStartupScript
);
1110 if (FileStringPath
== NULL
) {
1112 // we return success since we dont need to have a startup script
1114 Status
= EFI_SUCCESS
;
1115 ASSERT(FileHandle
== NULL
);
1117 Status
= RunScriptFile(
1121 ShellInfoObject
.NewShellParametersProtocol
,
1124 FreePool(FileStringPath
);
1133 Function to perform the shell prompt looping. It will do a single prompt,
1134 dispatch the result, and then return. It is expected that the caller will
1135 call this function in a loop many times.
1138 @retval RETURN_ABORTED
1149 CONST CHAR16
*CurDir
;
1156 // Get screen setting to decide size of the command line buffer
1158 gST
->ConOut
->QueryMode (gST
->ConOut
, gST
->ConOut
->Mode
->Mode
, &Column
, &Row
);
1159 BufferSize
= Column
* Row
* sizeof (CHAR16
);
1160 CmdLine
= AllocateZeroPool (BufferSize
);
1161 if (CmdLine
== NULL
) {
1162 return EFI_OUT_OF_RESOURCES
;
1165 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
1170 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, gST
->ConOut
->Mode
->CursorRow
);
1172 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
1173 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
1175 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
1179 // Read a line from the console
1181 Status
= ShellInfoObject
.NewEfiShellProtocol
->ReadFile(ShellInfoObject
.NewShellParametersProtocol
->StdIn
, &BufferSize
, CmdLine
);
1184 // Null terminate the string and parse it
1186 if (!EFI_ERROR (Status
)) {
1187 CmdLine
[BufferSize
/ sizeof (CHAR16
)] = CHAR_NULL
;
1188 Status
= RunCommand(CmdLine
, NULL
);
1192 // Done with this command
1199 Add a buffer to the Buffer To Free List for safely returning buffers to other
1200 places without risking letting them modify internal shell information.
1202 @param Buffer Something to pass to FreePool when the shell is exiting.
1206 AddBufferToFreeList(
1210 BUFFER_LIST
*BufferListEntry
;
1212 if (Buffer
== NULL
) {
1216 BufferListEntry
= AllocateZeroPool(sizeof(BUFFER_LIST
));
1217 ASSERT(BufferListEntry
!= NULL
);
1218 BufferListEntry
->Buffer
= Buffer
;
1219 InsertTailList(&ShellInfoObject
.BufferToFreeList
.Link
, &BufferListEntry
->Link
);
1224 Add a buffer to the Line History List
1226 @param Buffer The line buffer to add.
1230 AddLineToCommandHistory(
1231 IN CONST CHAR16
*Buffer
1236 Node
= AllocateZeroPool(sizeof(BUFFER_LIST
));
1237 ASSERT(Node
!= NULL
);
1238 Node
->Buffer
= AllocateZeroPool(StrSize(Buffer
));
1239 ASSERT(Node
->Buffer
!= NULL
);
1240 StrCpy(Node
->Buffer
, Buffer
);
1242 InsertTailList(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
, &Node
->Link
);
1246 Checks if a string is an alias for another command. If yes, then it replaces the alias name
1247 with the correct command name.
1249 @param[in, out] CommandString Upon entry the potential alias. Upon return the
1250 command name if it was an alias. If it was not
1251 an alias it will be unchanged. This function may
1252 change the buffer to fit the command name.
1254 @retval EFI_SUCCESS The name was changed.
1255 @retval EFI_SUCCESS The name was not an alias.
1256 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
1261 IN OUT CHAR16
**CommandString
1264 CONST CHAR16
*NewString
;
1266 NewString
= ShellInfoObject
.NewEfiShellProtocol
->GetAlias(*CommandString
, NULL
);
1267 if (NewString
== NULL
) {
1268 return (EFI_SUCCESS
);
1270 FreePool(*CommandString
);
1271 *CommandString
= AllocateZeroPool(StrSize(NewString
));
1272 if (*CommandString
== NULL
) {
1273 return (EFI_OUT_OF_RESOURCES
);
1275 StrCpy(*CommandString
, NewString
);
1276 return (EFI_SUCCESS
);
1280 Parse for the next instance of one string within another string. Can optionally make sure that
1281 the string was not escaped (^ character) per the shell specification.
1283 @param[in] SourceString The string to search within
1284 @param[in] FindString The string to look for
1285 @param[in] CheckForEscapeCharacter TRUE to skip escaped instances of FinfString, otherwise will return even escaped instances
1290 IN CONST CHAR16
*SourceString
,
1291 IN CONST CHAR16
*FindString
,
1292 IN CONST BOOLEAN CheckForEscapeCharacter
1296 if (SourceString
== NULL
) {
1299 Temp
= StrStr(SourceString
, FindString
);
1302 // If nothing found, or we dont care about escape characters
1304 if (Temp
== NULL
|| !CheckForEscapeCharacter
) {
1309 // If we found an escaped character, try again on the remainder of the string
1311 if ((Temp
> (SourceString
)) && *(Temp
-1) == L
'^') {
1312 return FindNextInstance(Temp
+1, FindString
, CheckForEscapeCharacter
);
1316 // we found the right character
1322 This function will eliminate unreplaced (and therefore non-found) environment variables.
1324 @param[in,out] CmdLine The command line to update.
1328 StripUnreplacedEnvironmentVariables(
1329 IN OUT CHAR16
*CmdLine
1332 CHAR16
*FirstPercent
;
1334 CHAR16
*SecondPercent
;
1335 CHAR16
*SecondQuote
;
1336 CHAR16
*CurrentLocator
;
1338 for (CurrentLocator
= CmdLine
; CurrentLocator
!= NULL
; ) {
1339 FirstQuote
= FindNextInstance(CurrentLocator
, L
"\"", TRUE
);
1340 FirstPercent
= FindNextInstance(CurrentLocator
, L
"%", TRUE
);
1341 SecondPercent
= FirstPercent
!=NULL
?FindNextInstance(FirstPercent
+1, L
"%", TRUE
):NULL
;
1342 if (FirstPercent
== NULL
|| SecondPercent
== NULL
) {
1344 // If we ever dont have 2 % we are done.
1349 if (FirstQuote
< FirstPercent
) {
1350 SecondQuote
= FirstQuote
!= NULL
?FindNextInstance(FirstQuote
+1, L
"\"", TRUE
):NULL
;
1352 // Quote is first found
1355 if (SecondQuote
< FirstPercent
) {
1357 // restart after the pair of "
1359 CurrentLocator
= SecondQuote
+ 1;
1360 } else /* FirstPercent < SecondQuote */{
1362 // Restart on the first percent
1364 CurrentLocator
= FirstPercent
;
1368 ASSERT(FirstPercent
< FirstQuote
);
1369 if (SecondPercent
< FirstQuote
) {
1371 // We need to remove from FirstPercent to SecondPercent
1373 CopyMem(FirstPercent
, SecondPercent
+ 1, StrSize(SecondPercent
+ 1));
1376 // dont need to update the locator. both % characters are gone.
1380 ASSERT(FirstQuote
< SecondPercent
);
1381 CurrentLocator
= FirstQuote
;
1383 return (EFI_SUCCESS
);
1387 Function allocates a new command line and replaces all instances of environment
1388 variable names that are correctly preset to their values.
1390 If the return value is not NULL the memory must be caller freed.
1392 @param[in] OriginalCommandLine The original command line
1394 @retval NULL An error ocurred.
1395 @return The new command line with no environment variables present.
1399 ShellConvertVariables (
1400 IN CONST CHAR16
*OriginalCommandLine
1403 CONST CHAR16
*MasterEnvList
;
1405 CHAR16
*NewCommandLine1
;
1406 CHAR16
*NewCommandLine2
;
1410 SCRIPT_FILE
*CurrentScriptFile
;
1411 ALIAS_LIST
*AliasListNode
;
1413 ASSERT(OriginalCommandLine
!= NULL
);
1416 NewSize
= StrSize(OriginalCommandLine
);
1417 CurrentScriptFile
= ShellCommandGetCurrentScriptFile();
1420 ///@todo update this to handle the %0 - %9 for scripting only (borrow from line 1256 area) ? ? ?
1423 // calculate the size required for the post-conversion string...
1425 if (CurrentScriptFile
!= NULL
) {
1426 for (AliasListNode
= (ALIAS_LIST
*)GetFirstNode(&CurrentScriptFile
->SubstList
)
1427 ; !IsNull(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1428 ; AliasListNode
= (ALIAS_LIST
*)GetNextNode(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1430 for (Temp
= StrStr(OriginalCommandLine
, AliasListNode
->Alias
)
1432 ; Temp
= StrStr(Temp
+1, AliasListNode
->Alias
)
1435 // we need a preceeding and if there is space no ^ preceeding (if no space ignore)
1437 if ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2)) {
1438 NewSize
+= StrSize(AliasListNode
->CommandString
);
1444 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1445 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
//&& *(MasterEnvList+1) != CHAR_NULL
1446 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1448 if (StrSize(MasterEnvList
) > ItemSize
) {
1449 ItemSize
= StrSize(MasterEnvList
);
1451 for (Temp
= StrStr(OriginalCommandLine
, MasterEnvList
)
1453 ; Temp
= StrStr(Temp
+1, MasterEnvList
)
1456 // we need a preceeding and following % and if there is space no ^ preceeding (if no space ignore)
1458 if (*(Temp
-1) == L
'%' && *(Temp
+StrLen(MasterEnvList
)) == L
'%' &&
1459 ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2))) {
1460 NewSize
+=StrSize(EfiShellGetEnv(MasterEnvList
));
1466 // now do the replacements...
1468 NewCommandLine1
= AllocateZeroPool(NewSize
);
1469 NewCommandLine2
= AllocateZeroPool(NewSize
);
1470 ItemTemp
= AllocateZeroPool(ItemSize
+(2*sizeof(CHAR16
)));
1471 if (NewCommandLine1
== NULL
|| NewCommandLine2
== NULL
|| ItemTemp
== NULL
) {
1472 SHELL_FREE_NON_NULL(NewCommandLine1
);
1473 SHELL_FREE_NON_NULL(NewCommandLine2
);
1474 SHELL_FREE_NON_NULL(ItemTemp
);
1477 StrCpy(NewCommandLine1
, OriginalCommandLine
);
1478 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1479 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
//&& *(MasterEnvList+1) != CHAR_NULL
1480 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1482 StrCpy(ItemTemp
, L
"%");
1483 StrCat(ItemTemp
, MasterEnvList
);
1484 StrCat(ItemTemp
, L
"%");
1485 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, ItemTemp
, EfiShellGetEnv(MasterEnvList
), TRUE
, FALSE
);
1486 StrCpy(NewCommandLine1
, NewCommandLine2
);
1488 if (CurrentScriptFile
!= NULL
) {
1489 for (AliasListNode
= (ALIAS_LIST
*)GetFirstNode(&CurrentScriptFile
->SubstList
)
1490 ; !IsNull(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1491 ; AliasListNode
= (ALIAS_LIST
*)GetNextNode(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1493 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, AliasListNode
->Alias
, AliasListNode
->CommandString
, TRUE
, FALSE
);
1494 StrCpy(NewCommandLine1
, NewCommandLine2
);
1498 // Remove non-existant environment variables in scripts only
1500 StripUnreplacedEnvironmentVariables(NewCommandLine1
);
1504 // Now cleanup any straggler intentionally ignored "%" characters
1506 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, L
"^%", L
"%", TRUE
, FALSE
);
1507 StrCpy(NewCommandLine1
, NewCommandLine2
);
1509 FreePool(NewCommandLine2
);
1512 return (NewCommandLine1
);
1516 Internal function to run a command line with pipe usage.
1518 @param[in] CmdLine The pointer to the command line.
1519 @param[in] StdIn The pointer to the Standard input.
1520 @param[in] StdOut The pointer to the Standard output.
1522 @param[out] ExitStatus The exit code of the last command in the pipeline.
1525 @retval EFI_SUCCESS The split command is executed successfully.
1526 @retval other Some error occurs when executing the split command.
1531 IN CONST CHAR16
*CmdLine
,
1532 IN SHELL_FILE_HANDLE
*StdIn
,
1533 IN SHELL_FILE_HANDLE
*StdOut
,
1534 OUT SHELL_STATUS
*ExitStatus
1538 CHAR16
*NextCommandLine
;
1539 CHAR16
*OurCommandLine
;
1543 SHELL_FILE_HANDLE
*TempFileHandle
;
1546 ASSERT(StdOut
== NULL
);
1548 ASSERT(StrStr(CmdLine
, L
"|") != NULL
);
1550 Status
= EFI_SUCCESS
;
1551 NextCommandLine
= NULL
;
1552 OurCommandLine
= NULL
;
1556 NextCommandLine
= StrnCatGrow(&NextCommandLine
, &Size1
, StrStr(CmdLine
, L
"|")+1, 0);
1557 OurCommandLine
= StrnCatGrow(&OurCommandLine
, &Size2
, CmdLine
, StrStr(CmdLine
, L
"|") - CmdLine
);
1559 if (NextCommandLine
== NULL
|| OurCommandLine
== NULL
) {
1560 SHELL_FREE_NON_NULL(OurCommandLine
);
1561 SHELL_FREE_NON_NULL(NextCommandLine
);
1562 return (EFI_OUT_OF_RESOURCES
);
1563 } else if (StrStr(OurCommandLine
, L
"|") != NULL
|| Size1
== 0 || Size2
== 0) {
1564 SHELL_FREE_NON_NULL(OurCommandLine
);
1565 SHELL_FREE_NON_NULL(NextCommandLine
);
1566 return (EFI_INVALID_PARAMETER
);
1567 } else if (NextCommandLine
[0] != CHAR_NULL
&&
1568 NextCommandLine
[0] == L
'a' &&
1569 NextCommandLine
[1] == L
' '
1571 CopyMem(NextCommandLine
, NextCommandLine
+1, StrSize(NextCommandLine
) - sizeof(NextCommandLine
[0]));
1579 // make a SPLIT_LIST item and add to list
1581 Split
= AllocateZeroPool(sizeof(SPLIT_LIST
));
1582 ASSERT(Split
!= NULL
);
1583 Split
->SplitStdIn
= StdIn
;
1584 Split
->SplitStdOut
= ConvertEfiFileProtocolToShellHandle(CreateFileInterfaceMem(Unicode
), NULL
);
1585 ASSERT(Split
->SplitStdOut
!= NULL
);
1586 InsertHeadList(&ShellInfoObject
.SplitList
.Link
, &Split
->Link
);
1588 Status
= RunCommand(OurCommandLine
, NULL
);
1591 // move the output from the first to the in to the second.
1593 TempFileHandle
= Split
->SplitStdOut
;
1594 if (Split
->SplitStdIn
== StdIn
) {
1595 Split
->SplitStdOut
= NULL
;
1597 Split
->SplitStdOut
= Split
->SplitStdIn
;
1599 Split
->SplitStdIn
= TempFileHandle
;
1600 ShellInfoObject
.NewEfiShellProtocol
->SetFilePosition(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdIn
), 0);
1602 if (!EFI_ERROR(Status
)) {
1603 Status
= RunCommand(NextCommandLine
, ExitStatus
);
1607 // remove the top level from the ScriptList
1609 ASSERT((SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
) == Split
);
1610 RemoveEntryList(&Split
->Link
);
1613 // Note that the original StdIn is now the StdOut...
1615 if (Split
->SplitStdOut
!= NULL
&& Split
->SplitStdOut
!= StdIn
) {
1616 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdOut
));
1618 if (Split
->SplitStdIn
!= NULL
) {
1619 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdIn
));
1623 FreePool(NextCommandLine
);
1624 FreePool(OurCommandLine
);
1630 Take the original command line, substitute any variables, free
1631 the original string, return the modified copy.
1633 @param[in] CmdLine pointer to the command line to update.
1635 @retval EFI_SUCCESS the function was successful.
1636 @retval EFI_OUT_OF_RESOURCES a memory allocation failed.
1640 ShellSubstituteVariables(
1645 NewCmdLine
= ShellConvertVariables(*CmdLine
);
1646 SHELL_FREE_NON_NULL(*CmdLine
);
1647 if (NewCmdLine
== NULL
) {
1648 return (EFI_OUT_OF_RESOURCES
);
1650 *CmdLine
= NewCmdLine
;
1651 return (EFI_SUCCESS
);
1655 Take the original command line, substitute any alias in the first group of space delimited characters, free
1656 the original string, return the modified copy.
1658 @param[in] CmdLine pointer to the command line to update.
1660 @retval EFI_SUCCESS the function was successful.
1661 @retval EFI_OUT_OF_RESOURCES a memory allocation failed.
1665 ShellSubstituteAliases(
1670 CHAR16
*CommandName
;
1672 UINTN PostAliasSize
;
1673 ASSERT(CmdLine
!= NULL
);
1674 ASSERT(*CmdLine
!= NULL
);
1678 if (StrStr((*CmdLine
), L
" ") == NULL
){
1679 StrnCatGrow(&CommandName
, NULL
, (*CmdLine
), 0);
1681 StrnCatGrow(&CommandName
, NULL
, (*CmdLine
), StrStr((*CmdLine
), L
" ") - (*CmdLine
));
1685 // This cannot happen 'inline' since the CmdLine can need extra space.
1688 if (!ShellCommandIsCommandOnList(CommandName
)) {
1690 // Convert via alias
1692 Status
= ShellConvertAlias(&CommandName
);
1693 if (EFI_ERROR(Status
)){
1697 NewCmdLine
= StrnCatGrow(&NewCmdLine
, &PostAliasSize
, CommandName
, 0);
1698 if (NewCmdLine
== NULL
) {
1699 SHELL_FREE_NON_NULL(CommandName
);
1700 SHELL_FREE_NON_NULL(*CmdLine
);
1701 return (EFI_OUT_OF_RESOURCES
);
1703 NewCmdLine
= StrnCatGrow(&NewCmdLine
, &PostAliasSize
, StrStr((*CmdLine
), L
" "), 0);
1704 if (NewCmdLine
== NULL
) {
1705 SHELL_FREE_NON_NULL(CommandName
);
1706 SHELL_FREE_NON_NULL(*CmdLine
);
1707 return (EFI_OUT_OF_RESOURCES
);
1710 NewCmdLine
= StrnCatGrow(&NewCmdLine
, NULL
, (*CmdLine
), 0);
1713 SHELL_FREE_NON_NULL(*CmdLine
);
1714 SHELL_FREE_NON_NULL(CommandName
);
1717 // re-assign the passed in double pointer to point to our newly allocated buffer
1719 *CmdLine
= NewCmdLine
;
1721 return (EFI_SUCCESS
);
1725 Takes the Argv[0] part of the command line and determine the meaning of it.
1727 @param[in] CmdName pointer to the command line to update.
1729 @retval Internal_Command The name is an internal command.
1730 @retval File_Sys_Change the name is a file system change.
1731 @retval Script_File_Name the name is a NSH script file.
1732 @retval Unknown_Invalid the name is unknown.
1733 @retval Efi_Application the name is an application (.EFI).
1735 SHELL_OPERATION_TYPES
1738 IN CONST CHAR16
*CmdName
1741 CHAR16
* FileWithPath
;
1742 CONST CHAR16
* TempLocation
;
1743 CONST CHAR16
* TempLocation2
;
1745 FileWithPath
= NULL
;
1747 // test for an internal command.
1749 if (ShellCommandIsCommandOnList(CmdName
)) {
1750 return (Internal_Command
);
1754 // Test for file system change request. anything ending with first : and cant have spaces.
1756 if (CmdName
[(StrLen(CmdName
)-1)] == L
':') {
1757 if ( StrStr(CmdName
, L
" ") != NULL
1758 || StrLen(StrStr(CmdName
, L
":")) > 1
1760 return (Unknown_Invalid
);
1762 return (File_Sys_Change
);
1768 if ((FileWithPath
= ShellFindFilePathEx(CmdName
, mExecutableExtensions
)) != NULL
) {
1770 // See if that file has a script file extension
1772 if (StrLen(FileWithPath
) > 4) {
1773 TempLocation
= FileWithPath
+StrLen(FileWithPath
)-4;
1774 TempLocation2
= mScriptExtension
;
1775 if (StringNoCaseCompare((VOID
*)(&TempLocation
), (VOID
*)(&TempLocation2
)) == 0) {
1776 SHELL_FREE_NON_NULL(FileWithPath
);
1777 return (Script_File_Name
);
1782 // Was a file, but not a script. we treat this as an application.
1784 SHELL_FREE_NON_NULL(FileWithPath
);
1785 return (Efi_Application
);
1788 SHELL_FREE_NON_NULL(FileWithPath
);
1790 // No clue what this is... return invalid flag...
1792 return (Unknown_Invalid
);
1796 Determine if the first item in a command line is valid.
1798 @param[in] CmdLine The command line to parse.
1800 @retval EFI_SUCCESS The item is valid.
1801 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
1802 @retval EFI_NOT_FOUND The operation type is unknown or invalid.
1807 IN CONST CHAR16
*CmdLine
1811 CHAR16
*FirstParameter
;
1817 Temp
= StrnCatGrow(&Temp
, NULL
, CmdLine
, 0);
1819 return (EFI_OUT_OF_RESOURCES
);
1822 FirstParameter
= StrStr(Temp
, L
"|");
1823 if (FirstParameter
!= NULL
) {
1824 *FirstParameter
= CHAR_NULL
;
1827 FirstParameter
= NULL
;
1830 // Process the command line
1832 Status
= ProcessCommandLineToFinal(&Temp
);
1834 if (!EFI_ERROR(Status
)) {
1835 FirstParameter
= AllocateZeroPool(StrSize(CmdLine
));
1836 if (FirstParameter
== NULL
) {
1837 SHELL_FREE_NON_NULL(Temp
);
1838 return (EFI_OUT_OF_RESOURCES
);
1840 TempWalker
= (CHAR16
*)Temp
;
1841 GetNextParameter(&TempWalker
, &FirstParameter
);
1843 if (GetOperationType(FirstParameter
) == Unknown_Invalid
) {
1844 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
1845 SetLastError(SHELL_NOT_FOUND
);
1846 Status
= EFI_NOT_FOUND
;
1850 SHELL_FREE_NON_NULL(Temp
);
1851 SHELL_FREE_NON_NULL(FirstParameter
);
1856 Determine if a command line contains with a split contains only valid commands.
1858 @param[in] CmdLine The command line to parse.
1860 @retval EFI_SUCCESS CmdLine has only valid commands, application, or has no split.
1861 @retval EFI_ABORTED CmdLine has at least one invalid command or application.
1866 IN CONST CHAR16
*CmdLine
1869 CONST CHAR16
*TempSpot
;
1873 // Verify up to the pipe or end character
1875 Status
= IsValidSplit(CmdLine
);
1876 if (EFI_ERROR(Status
)) {
1881 // If this was the only item, then get out
1883 if (!ContainsSplit(CmdLine
)) {
1884 return (EFI_SUCCESS
);
1888 // recurse to verify the next item
1890 TempSpot
= FindSplit(CmdLine
)+1;
1891 return (VerifySplit(TempSpot
));
1895 Process a split based operation.
1897 @param[in] CmdLine Pointer to the command line to process
1898 @param[out] ExitStatus The exit status of the command. Ignored if NULL.
1899 Invalid if this function returns an error.
1901 @retval EFI_SUCCESS The operation was successful
1902 @return an error occured.
1906 ProcessNewSplitCommandLine(
1907 IN CONST CHAR16
*CmdLine
,
1908 OUT SHELL_STATUS
*ExitStatus
1914 Status
= VerifySplit(CmdLine
);
1915 if (EFI_ERROR(Status
)) {
1922 // are we in an existing split???
1924 if (!IsListEmpty(&ShellInfoObject
.SplitList
.Link
)) {
1925 Split
= (SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
);
1928 if (Split
== NULL
) {
1929 Status
= RunSplitCommand(CmdLine
, NULL
, NULL
, ExitStatus
);
1931 Status
= RunSplitCommand(
1938 if (EFI_ERROR(Status
)) {
1939 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_SPLIT
), ShellInfoObject
.HiiHandle
, CmdLine
);
1945 Handle a request to change the current file system.
1947 @param[in] CmdLine The passed in command line.
1949 @retval EFI_SUCCESS The operation was successful.
1954 IN CONST CHAR16
*CmdLine
1958 Status
= EFI_SUCCESS
;
1961 // make sure we are the right operation
1963 ASSERT(CmdLine
[(StrLen(CmdLine
)-1)] == L
':' && StrStr(CmdLine
, L
" ") == NULL
);
1966 // Call the protocol API to do the work
1968 Status
= ShellInfoObject
.NewEfiShellProtocol
->SetCurDir(NULL
, CmdLine
);
1971 // Report any errors
1973 if (EFI_ERROR(Status
)) {
1974 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_MAPPING
), ShellInfoObject
.HiiHandle
, CmdLine
);
1981 Reprocess the command line to direct all -? to the help command.
1983 if found, will add "help" as argv[0], and move the rest later.
1985 @param[in,out] CmdLine pointer to the command line to update
1990 IN OUT CHAR16
**CmdLine
1993 CHAR16
*CurrentParameter
;
1996 CHAR16
*NewCommandLine
;
1999 Status
= EFI_SUCCESS
;
2001 CurrentParameter
= AllocateZeroPool(StrSize(*CmdLine
));
2002 if (CurrentParameter
== NULL
) {
2003 return (EFI_OUT_OF_RESOURCES
);
2007 while(Walker
!= NULL
&& *Walker
!= CHAR_NULL
) {
2008 LastWalker
= Walker
;
2009 GetNextParameter(&Walker
, &CurrentParameter
);
2010 if (StrStr(CurrentParameter
, L
"-?") == CurrentParameter
) {
2011 LastWalker
[0] = L
' ';
2012 LastWalker
[1] = L
' ';
2013 NewCommandLine
= AllocateZeroPool(StrSize(L
"help ") + StrSize(*CmdLine
));
2014 if (NewCommandLine
== NULL
) {
2015 Status
= EFI_OUT_OF_RESOURCES
;
2018 StrCpy(NewCommandLine
, L
"help ");
2019 StrCat(NewCommandLine
, *CmdLine
);
2020 SHELL_FREE_NON_NULL(*CmdLine
);
2021 *CmdLine
= NewCommandLine
;
2026 SHELL_FREE_NON_NULL(CurrentParameter
);
2032 Function to update the shell variable "lasterror".
2034 @param[in] ErrorCode the error code to put into lasterror.
2039 IN CONST SHELL_STATUS ErrorCode
2042 CHAR16 LeString
[19];
2043 if (sizeof(EFI_STATUS
) == sizeof(UINT64
)) {
2044 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%Lx", ErrorCode
);
2046 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%x", ErrorCode
);
2048 DEBUG_CODE(InternalEfiShellSetEnv(L
"debuglasterror", LeString
, TRUE
););
2049 InternalEfiShellSetEnv(L
"lasterror", LeString
, TRUE
);
2051 return (EFI_SUCCESS
);
2055 Converts the command line to it's post-processed form. this replaces variables and alias' per UEFI Shell spec.
2057 @param[in,out] CmdLine pointer to the command line to update
2059 @retval EFI_SUCCESS The operation was successful
2060 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
2061 @return some other error occured
2065 ProcessCommandLineToFinal(
2066 IN OUT CHAR16
**CmdLine
2070 TrimSpaces(CmdLine
);
2072 Status
= ShellSubstituteAliases(CmdLine
);
2073 if (EFI_ERROR(Status
)) {
2077 TrimSpaces(CmdLine
);
2079 Status
= ShellSubstituteVariables(CmdLine
);
2080 if (EFI_ERROR(Status
)) {
2084 TrimSpaces(CmdLine
);
2087 // update for help parsing
2089 if (StrStr(*CmdLine
, L
"?") != NULL
) {
2091 // This may do nothing if the ? does not indicate help.
2092 // Save all the details for in the API below.
2094 Status
= DoHelpUpdate(CmdLine
);
2097 TrimSpaces(CmdLine
);
2099 return (EFI_SUCCESS
);
2103 Run an internal shell command.
2105 This API will upadate the shell's environment since these commands are libraries.
2107 @param[in] CmdLine the command line to run.
2108 @param[in] FirstParameter the first parameter on the command line
2109 @param[in] ParamProtocol the shell parameters protocol pointer
2111 @param[out] ExitStatus The exit code of the command. Ignored if NULL.
2113 @retval EFI_SUCCESS The command was completed.
2114 @retval EFI_ABORTED The command's operation was aborted.
2119 IN CONST CHAR16
*CmdLine
,
2120 IN CHAR16
*FirstParameter
,
2121 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2122 OUT SHELL_STATUS
*ExitStatus OPTIONAL
2128 SHELL_STATUS CommandReturnedStatus
;
2132 // get the argc and argv updated for internal commands
2134 Status
= UpdateArgcArgv(ParamProtocol
, CmdLine
, &Argv
, &Argc
);
2135 if (!EFI_ERROR(Status
)) {
2137 // Run the internal command.
2139 Status
= ShellCommandRunCommandHandler(FirstParameter
, &CommandReturnedStatus
, &LastError
);
2141 if (!EFI_ERROR(Status
)) {
2143 // Update last error status.
2144 // some commands do not update last error.
2147 SetLastError(CommandReturnedStatus
);
2149 if (ExitStatus
!= NULL
) {
2150 *ExitStatus
= CommandReturnedStatus
;
2154 // Pass thru the exitcode from the app.
2156 if (ShellCommandGetExit()) {
2158 // An Exit was requested ("exit" command), pass its value up.
2160 Status
= CommandReturnedStatus
;
2161 } else if (CommandReturnedStatus
!= SHELL_SUCCESS
&& IsScriptOnlyCommand(FirstParameter
)) {
2163 // Always abort when a script only command fails for any reason
2165 Status
= EFI_ABORTED
;
2166 } else if (ShellCommandGetCurrentScriptFile() != NULL
&& CommandReturnedStatus
== SHELL_ABORTED
) {
2168 // Abort when in a script and a command aborted
2170 Status
= EFI_ABORTED
;
2176 // This is guarenteed to be called after UpdateArgcArgv no matter what else happened.
2177 // This is safe even if the update API failed. In this case, it may be a no-op.
2179 RestoreArgcArgv(ParamProtocol
, &Argv
, &Argc
);
2182 // If a script is running and the command is not a scipt only command, then
2183 // change return value to success so the script won't halt (unless aborted).
2185 // Script only commands have to be able halt the script since the script will
2186 // not operate if they are failing.
2188 if ( ShellCommandGetCurrentScriptFile() != NULL
2189 && !IsScriptOnlyCommand(FirstParameter
)
2190 && Status
!= EFI_ABORTED
2192 Status
= EFI_SUCCESS
;
2199 Function to run the command or file.
2201 @param[in] Type the type of operation being run.
2202 @param[in] CmdLine the command line to run.
2203 @param[in] FirstParameter the first parameter on the command line
2204 @param[in] ParamProtocol the shell parameters protocol pointer
2206 @param[out] ExitStatus The exit code of the command or file.
2209 @retval EFI_SUCCESS The command was completed.
2210 @retval EFI_ABORTED The command's operation was aborted.
2215 IN SHELL_OPERATION_TYPES Type
,
2216 IN CONST CHAR16
*CmdLine
,
2217 IN CHAR16
*FirstParameter
,
2218 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2219 OUT SHELL_STATUS
*ExitStatus
2223 CHAR16
*CommandWithPath
;
2224 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
2225 SHELL_STATUS CalleeExitStatus
;
2227 Status
= EFI_SUCCESS
;
2228 CommandWithPath
= NULL
;
2230 CalleeExitStatus
= SHELL_INVALID_PARAMETER
;
2233 case Internal_Command
:
2234 Status
= RunInternalCommand(
2241 case Script_File_Name
:
2242 case Efi_Application
:
2244 // Process a fully qualified path
2246 if (StrStr(FirstParameter
, L
":") != NULL
) {
2247 ASSERT (CommandWithPath
== NULL
);
2248 if (ShellIsFile(FirstParameter
) == EFI_SUCCESS
) {
2249 CommandWithPath
= StrnCatGrow(&CommandWithPath
, NULL
, FirstParameter
, 0);
2254 // Process a relative path and also check in the path environment variable
2256 if (CommandWithPath
== NULL
) {
2257 CommandWithPath
= ShellFindFilePathEx(FirstParameter
, mExecutableExtensions
);
2261 // This should be impossible now.
2263 ASSERT(CommandWithPath
!= NULL
);
2266 // Make sure that path is not just a directory (or not found)
2268 if (!EFI_ERROR(ShellIsDirectory(CommandWithPath
))) {
2269 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2270 SetLastError(SHELL_NOT_FOUND
);
2273 case Script_File_Name
:
2274 Status
= RunScriptFile (
2282 case Efi_Application
:
2284 // Get the device path of the application image
2286 DevPath
= ShellInfoObject
.NewEfiShellProtocol
->GetDevicePathFromFilePath(CommandWithPath
);
2287 if (DevPath
== NULL
){
2288 Status
= EFI_OUT_OF_RESOURCES
;
2293 // Execute the device path
2295 Status
= InternalShellExecuteDevicePath(
2304 SHELL_FREE_NON_NULL(DevPath
);
2306 if(EFI_ERROR (Status
)) {
2307 CalleeExitStatus
= (SHELL_STATUS
) (Status
& (~MAX_BIT
));
2309 CalleeExitStatus
= SHELL_SUCCESS
;
2313 // Update last error status.
2315 // Status is an EFI_STATUS. Clear top bit to convert to SHELL_STATUS
2316 SetLastError(CalleeExitStatus
);
2332 SHELL_FREE_NON_NULL(CommandWithPath
);
2334 if (ExitStatus
!= NULL
) {
2335 *ExitStatus
= CalleeExitStatus
;
2342 Function to setup StdIn, StdErr, StdOut, and then run the command or file.
2344 @param[in] Type the type of operation being run.
2345 @param[in] CmdLine the command line to run.
2346 @param[in] FirstParameter the first parameter on the command line.
2347 @param[in] ParamProtocol the shell parameters protocol pointer
2349 @param[out] ExitStatus The exit code of the command or file.
2352 @retval EFI_SUCCESS The command was completed.
2353 @retval EFI_ABORTED The command's operation was aborted.
2357 SetupAndRunCommandOrFile(
2358 IN SHELL_OPERATION_TYPES Type
,
2360 IN CHAR16
*FirstParameter
,
2361 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2362 OUT SHELL_STATUS
*ExitStatus
2366 SHELL_FILE_HANDLE OriginalStdIn
;
2367 SHELL_FILE_HANDLE OriginalStdOut
;
2368 SHELL_FILE_HANDLE OriginalStdErr
;
2369 SYSTEM_TABLE_INFO OriginalSystemTableInfo
;
2372 // Update the StdIn, StdOut, and StdErr for redirection to environment variables, files, etc... unicode and ASCII
2374 Status
= UpdateStdInStdOutStdErr(ParamProtocol
, CmdLine
, &OriginalStdIn
, &OriginalStdOut
, &OriginalStdErr
, &OriginalSystemTableInfo
);
2377 // The StdIn, StdOut, and StdErr are set up.
2378 // Now run the command, script, or application
2380 if (!EFI_ERROR(Status
)) {
2381 Status
= RunCommandOrFile(
2393 if (EFI_ERROR(Status
)) {
2394 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_ERROR
), ShellInfoObject
.HiiHandle
, (VOID
*)(Status
));
2398 // put back the original StdIn, StdOut, and StdErr
2400 RestoreStdInStdOutStdErr(ParamProtocol
, &OriginalStdIn
, &OriginalStdOut
, &OriginalStdErr
, &OriginalSystemTableInfo
);
2406 Function will process and run a command line.
2408 This will determine if the command line represents an internal shell
2409 command or dispatch an external application.
2411 @param[in] CmdLine The command line to parse.
2412 @param[out] ExitStatus The exit code of the command. Ignored if NULL.
2414 @retval EFI_SUCCESS The command was completed.
2415 @retval EFI_ABORTED The command's operation was aborted.
2420 IN CONST CHAR16
*CmdLine
,
2421 OUT SHELL_STATUS
*ExitStatus
2425 CHAR16
*CleanOriginal
;
2426 CHAR16
*FirstParameter
;
2428 SHELL_OPERATION_TYPES Type
;
2430 ASSERT(CmdLine
!= NULL
);
2431 if (StrLen(CmdLine
) == 0) {
2432 return (EFI_SUCCESS
);
2435 Status
= EFI_SUCCESS
;
2436 CleanOriginal
= NULL
;
2438 CleanOriginal
= StrnCatGrow(&CleanOriginal
, NULL
, CmdLine
, 0);
2439 if (CleanOriginal
== NULL
) {
2440 return (EFI_OUT_OF_RESOURCES
);
2443 TrimSpaces(&CleanOriginal
);
2446 // Handle case that passed in command line is just 1 or more " " characters.
2448 if (StrLen (CleanOriginal
) == 0) {
2449 SHELL_FREE_NON_NULL(CleanOriginal
);
2450 return (EFI_SUCCESS
);
2453 Status
= ProcessCommandLineToFinal(&CleanOriginal
);
2454 if (EFI_ERROR(Status
)) {
2455 SHELL_FREE_NON_NULL(CleanOriginal
);
2460 // We dont do normal processing with a split command line (output from one command input to another)
2462 if (ContainsSplit(CleanOriginal
)) {
2463 Status
= ProcessNewSplitCommandLine(CleanOriginal
, ExitStatus
);
2464 SHELL_FREE_NON_NULL(CleanOriginal
);
2469 // We need the first parameter information so we can determine the operation type
2471 FirstParameter
= AllocateZeroPool(StrSize(CleanOriginal
));
2472 if (FirstParameter
== NULL
) {
2473 SHELL_FREE_NON_NULL(CleanOriginal
);
2474 return (EFI_OUT_OF_RESOURCES
);
2476 TempWalker
= CleanOriginal
;
2477 GetNextParameter(&TempWalker
, &FirstParameter
);
2480 // Depending on the first parameter we change the behavior
2482 switch (Type
= GetOperationType(FirstParameter
)) {
2483 case File_Sys_Change
:
2484 Status
= ChangeMappedDrive (FirstParameter
);
2486 case Internal_Command
:
2487 case Script_File_Name
:
2488 case Efi_Application
:
2489 Status
= SetupAndRunCommandOrFile(
2493 ShellInfoObject
.NewShellParametersProtocol
,
2499 // Whatever was typed, it was invalid.
2501 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, FirstParameter
);
2502 SetLastError(SHELL_NOT_FOUND
);
2506 SHELL_FREE_NON_NULL(CleanOriginal
);
2507 SHELL_FREE_NON_NULL(FirstParameter
);
2512 STATIC CONST UINT16 InvalidChars
[] = {L
'*', L
'?', L
'<', L
'>', L
'\\', L
'/', L
'\"', 0x0001, 0x0002};
2514 Function determins if the CommandName COULD be a valid command. It does not determine whether
2515 this is a valid command. It only checks for invalid characters.
2517 @param[in] CommandName The name to check
2519 @retval TRUE CommandName could be a command name
2520 @retval FALSE CommandName could not be a valid command name
2525 IN CONST CHAR16
*CommandName
2529 if (CommandName
== NULL
) {
2534 ; Count
< sizeof(InvalidChars
) / sizeof(InvalidChars
[0])
2537 if (ScanMem16(CommandName
, StrSize(CommandName
), InvalidChars
[Count
]) != NULL
) {
2545 Function to process a NSH script file via SHELL_FILE_HANDLE.
2547 @param[in] Handle The handle to the already opened file.
2548 @param[in] Name The name of the script file.
2550 @param[out] ExitStatus The exit code of the script. Ignored if NULL.
2552 @retval EFI_SUCCESS the script completed sucessfully
2556 RunScriptFileHandle (
2557 IN SHELL_FILE_HANDLE Handle
,
2558 IN CONST CHAR16
*Name
,
2559 OUT SHELL_STATUS
*ExitStatus
2563 SCRIPT_FILE
*NewScriptFile
;
2565 CHAR16
*CommandLine
;
2566 CHAR16
*CommandLine2
;
2567 CHAR16
*CommandLine3
;
2568 SCRIPT_COMMAND_LIST
*LastCommand
;
2570 BOOLEAN PreScriptEchoState
;
2571 BOOLEAN PreCommandEchoState
;
2572 CONST CHAR16
*CurDir
;
2574 CHAR16 LeString
[50];
2575 SHELL_STATUS CalleeExitStatus
;
2577 ASSERT(!ShellCommandGetScriptExit());
2579 CalleeExitStatus
= SHELL_SUCCESS
;
2581 PreScriptEchoState
= ShellCommandGetEchoState();
2583 NewScriptFile
= (SCRIPT_FILE
*)AllocateZeroPool(sizeof(SCRIPT_FILE
));
2584 if (NewScriptFile
== NULL
) {
2585 return (EFI_OUT_OF_RESOURCES
);
2591 ASSERT(NewScriptFile
->ScriptName
== NULL
);
2592 NewScriptFile
->ScriptName
= StrnCatGrow(&NewScriptFile
->ScriptName
, NULL
, Name
, 0);
2593 if (NewScriptFile
->ScriptName
== NULL
) {
2594 DeleteScriptFileStruct(NewScriptFile
);
2595 return (EFI_OUT_OF_RESOURCES
);
2599 // Save the parameters (used to replace %0 to %9 later on)
2601 NewScriptFile
->Argc
= ShellInfoObject
.NewShellParametersProtocol
->Argc
;
2602 if (NewScriptFile
->Argc
!= 0) {
2603 NewScriptFile
->Argv
= (CHAR16
**)AllocateZeroPool(NewScriptFile
->Argc
* sizeof(CHAR16
*));
2604 if (NewScriptFile
->Argv
== NULL
) {
2605 DeleteScriptFileStruct(NewScriptFile
);
2606 return (EFI_OUT_OF_RESOURCES
);
2608 for (LoopVar
= 0 ; LoopVar
< 10 && LoopVar
< NewScriptFile
->Argc
; LoopVar
++) {
2609 ASSERT(NewScriptFile
->Argv
[LoopVar
] == NULL
);
2610 NewScriptFile
->Argv
[LoopVar
] = StrnCatGrow(&NewScriptFile
->Argv
[LoopVar
], NULL
, ShellInfoObject
.NewShellParametersProtocol
->Argv
[LoopVar
], 0);
2611 if (NewScriptFile
->Argv
[LoopVar
] == NULL
) {
2612 DeleteScriptFileStruct(NewScriptFile
);
2613 return (EFI_OUT_OF_RESOURCES
);
2617 NewScriptFile
->Argv
= NULL
;
2620 InitializeListHead(&NewScriptFile
->CommandList
);
2621 InitializeListHead(&NewScriptFile
->SubstList
);
2624 // Now build the list of all script commands.
2627 while(!ShellFileHandleEof(Handle
)) {
2628 CommandLine
= ShellFileHandleReturnLine(Handle
, &Ascii
);
2630 if (CommandLine
== NULL
|| StrLen(CommandLine
) == 0 || CommandLine
[0] == '#') {
2631 SHELL_FREE_NON_NULL(CommandLine
);
2634 NewScriptFile
->CurrentCommand
= AllocateZeroPool(sizeof(SCRIPT_COMMAND_LIST
));
2635 if (NewScriptFile
->CurrentCommand
== NULL
) {
2636 SHELL_FREE_NON_NULL(CommandLine
);
2637 DeleteScriptFileStruct(NewScriptFile
);
2638 return (EFI_OUT_OF_RESOURCES
);
2641 NewScriptFile
->CurrentCommand
->Cl
= CommandLine
;
2642 NewScriptFile
->CurrentCommand
->Data
= NULL
;
2643 NewScriptFile
->CurrentCommand
->Line
= LineCount
;
2645 InsertTailList(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
2649 // Add this as the topmost script file
2651 ShellCommandSetNewScript (NewScriptFile
);
2654 // Now enumerate through the commands and run each one.
2656 CommandLine
= AllocateZeroPool(PcdGet16(PcdShellPrintBufferSize
));
2657 if (CommandLine
== NULL
) {
2658 DeleteScriptFileStruct(NewScriptFile
);
2659 return (EFI_OUT_OF_RESOURCES
);
2661 CommandLine2
= AllocateZeroPool(PcdGet16(PcdShellPrintBufferSize
));
2662 if (CommandLine2
== NULL
) {
2663 FreePool(CommandLine
);
2664 DeleteScriptFileStruct(NewScriptFile
);
2665 return (EFI_OUT_OF_RESOURCES
);
2668 for ( NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetFirstNode(&NewScriptFile
->CommandList
)
2669 ; !IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)
2670 ; // conditional increment in the body of the loop
2672 ASSERT(CommandLine2
!= NULL
);
2673 StrCpy(CommandLine2
, NewScriptFile
->CurrentCommand
->Cl
);
2676 // NULL out comments
2678 for (CommandLine3
= CommandLine2
; CommandLine3
!= NULL
&& *CommandLine3
!= CHAR_NULL
; CommandLine3
++) {
2679 if (*CommandLine3
== L
'^') {
2680 if (*(CommandLine3
+1) == L
'#' || *(CommandLine3
+1) == L
':') {
2681 CopyMem(CommandLine3
, CommandLine3
+1, StrSize(CommandLine3
) - sizeof(CommandLine3
[0]));
2683 } else if (*CommandLine3
== L
'#') {
2684 *CommandLine3
= CHAR_NULL
;
2688 if (CommandLine2
!= NULL
&& StrLen(CommandLine2
) >= 1) {
2690 // Due to variability in starting the find and replace action we need to have both buffers the same.
2692 StrCpy(CommandLine
, CommandLine2
);
2695 // Remove the %0 to %9 from the command line (if we have some arguments)
2697 if (NewScriptFile
->Argv
!= NULL
) {
2698 switch (NewScriptFile
->Argc
) {
2700 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%9", NewScriptFile
->Argv
[9], FALSE
, TRUE
);
2701 ASSERT_EFI_ERROR(Status
);
2703 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%8", NewScriptFile
->Argv
[8], FALSE
, TRUE
);
2704 ASSERT_EFI_ERROR(Status
);
2706 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%7", NewScriptFile
->Argv
[7], FALSE
, TRUE
);
2707 ASSERT_EFI_ERROR(Status
);
2709 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%6", NewScriptFile
->Argv
[6], FALSE
, TRUE
);
2710 ASSERT_EFI_ERROR(Status
);
2712 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%5", NewScriptFile
->Argv
[5], FALSE
, TRUE
);
2713 ASSERT_EFI_ERROR(Status
);
2715 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%4", NewScriptFile
->Argv
[4], FALSE
, TRUE
);
2716 ASSERT_EFI_ERROR(Status
);
2718 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%3", NewScriptFile
->Argv
[3], FALSE
, TRUE
);
2719 ASSERT_EFI_ERROR(Status
);
2721 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%2", NewScriptFile
->Argv
[2], FALSE
, TRUE
);
2722 ASSERT_EFI_ERROR(Status
);
2724 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%1", NewScriptFile
->Argv
[1], FALSE
, TRUE
);
2725 ASSERT_EFI_ERROR(Status
);
2727 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%0", NewScriptFile
->Argv
[0], FALSE
, TRUE
);
2728 ASSERT_EFI_ERROR(Status
);
2734 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%1", L
"\"\"", FALSE
, FALSE
);
2735 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%2", L
"\"\"", FALSE
, FALSE
);
2736 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%3", L
"\"\"", FALSE
, FALSE
);
2737 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%4", L
"\"\"", FALSE
, FALSE
);
2738 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%5", L
"\"\"", FALSE
, FALSE
);
2739 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%6", L
"\"\"", FALSE
, FALSE
);
2740 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%7", L
"\"\"", FALSE
, FALSE
);
2741 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%8", L
"\"\"", FALSE
, FALSE
);
2742 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%9", L
"\"\"", FALSE
, FALSE
);
2744 StrCpy(CommandLine2
, CommandLine
);
2746 LastCommand
= NewScriptFile
->CurrentCommand
;
2748 for (CommandLine3
= CommandLine2
; CommandLine3
[0] == L
' ' ; CommandLine3
++);
2750 if (CommandLine3
!= NULL
&& CommandLine3
[0] == L
':' ) {
2752 // This line is a goto target / label
2755 if (CommandLine3
!= NULL
&& StrLen(CommandLine3
) > 0) {
2756 if (CommandLine3
[0] == L
'@') {
2758 // We need to save the current echo state
2759 // and disable echo for just this command.
2761 PreCommandEchoState
= ShellCommandGetEchoState();
2762 ShellCommandSetEchoState(FALSE
);
2763 Status
= RunCommand(CommandLine3
+1, NULL
);
2766 // If command was "@echo -off" or "@echo -on" then don't restore echo state
2768 if (StrCmp (L
"@echo -off", CommandLine3
) != 0 &&
2769 StrCmp (L
"@echo -on", CommandLine3
) != 0) {
2771 // Now restore the pre-'@' echo state.
2773 ShellCommandSetEchoState(PreCommandEchoState
);
2776 if (ShellCommandGetEchoState()) {
2777 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
2778 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
2779 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
2781 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
2783 ShellPrintEx(-1, -1, L
"%s\r\n", CommandLine2
);
2785 Status
= RunCommand(CommandLine3
, NULL
);
2789 if (ShellCommandGetScriptExit()) {
2791 // ShellCommandGetExitCode() always returns a UINT64
2793 CalleeExitStatus
= (SHELL_STATUS
) ShellCommandGetExitCode();
2794 UnicodeSPrint(LeString
, sizeof(LeString
), L
"0x%Lx", CalleeExitStatus
);
2795 DEBUG_CODE(InternalEfiShellSetEnv(L
"debuglasterror", LeString
, TRUE
););
2796 InternalEfiShellSetEnv(L
"lasterror", LeString
, TRUE
);
2798 ShellCommandRegisterExit(FALSE
, 0);
2799 Status
= EFI_SUCCESS
;
2802 if (ShellGetExecutionBreakFlag()) {
2805 if (EFI_ERROR(Status
)) {
2806 CalleeExitStatus
= (SHELL_STATUS
) Status
;
2809 if (ShellCommandGetExit()) {
2810 CalleeExitStatus
= (SHELL_STATUS
) ShellCommandGetExitCode();
2815 // If that commend did not update the CurrentCommand then we need to advance it...
2817 if (LastCommand
== NewScriptFile
->CurrentCommand
) {
2818 NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetNextNode(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
2819 if (!IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)) {
2820 NewScriptFile
->CurrentCommand
->Reset
= TRUE
;
2824 NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetNextNode(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
2825 if (!IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)) {
2826 NewScriptFile
->CurrentCommand
->Reset
= TRUE
;
2832 FreePool(CommandLine
);
2833 FreePool(CommandLine2
);
2834 ShellCommandSetNewScript (NULL
);
2837 // Only if this was the last script reset the state.
2839 if (ShellCommandGetCurrentScriptFile()==NULL
) {
2840 ShellCommandSetEchoState(PreScriptEchoState
);
2843 if (ExitStatus
!= NULL
) {
2844 *ExitStatus
= CalleeExitStatus
;
2847 return (EFI_SUCCESS
);
2851 Function to process a NSH script file.
2853 @param[in] ScriptPath Pointer to the script file name (including file system path).
2854 @param[in] Handle the handle of the script file already opened.
2855 @param[in] CmdLine the command line to run.
2856 @param[in] ParamProtocol the shell parameters protocol pointer
2858 @param[out] ExitStatus The exit code of the script. Ignored if NULL.
2860 @retval EFI_SUCCESS the script completed sucessfully
2865 IN CONST CHAR16
*ScriptPath
,
2866 IN SHELL_FILE_HANDLE Handle OPTIONAL
,
2867 IN CONST CHAR16
*CmdLine
,
2868 IN EFI_SHELL_PARAMETERS_PROTOCOL
*ParamProtocol
,
2869 OUT SHELL_STATUS
*ExitStatus
2873 SHELL_FILE_HANDLE FileHandle
;
2877 if (ShellIsFile(ScriptPath
) != EFI_SUCCESS
) {
2878 return (EFI_INVALID_PARAMETER
);
2882 // get the argc and argv updated for scripts
2884 Status
= UpdateArgcArgv(ParamProtocol
, CmdLine
, &Argv
, &Argc
);
2885 if (!EFI_ERROR(Status
)) {
2887 if (Handle
== NULL
) {
2891 Status
= ShellOpenFileByName(ScriptPath
, &FileHandle
, EFI_FILE_MODE_READ
, 0);
2892 if (!EFI_ERROR(Status
)) {
2896 Status
= RunScriptFileHandle(FileHandle
, ScriptPath
, ExitStatus
);
2899 // now close the file
2901 ShellCloseFile(&FileHandle
);
2904 Status
= RunScriptFileHandle(Handle
, ScriptPath
, ExitStatus
);
2909 // This is guarenteed to be called after UpdateArgcArgv no matter what else happened.
2910 // This is safe even if the update API failed. In this case, it may be a no-op.
2912 RestoreArgcArgv(ParamProtocol
, &Argv
, &Argc
);