2 This is THE shell (application)
4 Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
18 // Initialize the global structure
20 SHELL_INFO ShellInfoObject
= {
62 STATIC CONST CHAR16 mScriptExtension
[] = L
".NSH";
63 STATIC CONST CHAR16 mExecutableExtensions
[] = L
".NSH;.EFI";
64 STATIC CONST CHAR16 mStartupScript
[] = L
"startup.nsh";
67 Function to start monitoring for CTRL-S using SimpleTextInputEx. This
68 feature's enabled state was not known when the shell initially launched.
70 @retval EFI_SUCCESS The feature is enabled.
71 @retval EFI_OUT_OF_RESOURCES There is not enough mnemory available.
75 InternalEfiShellStartCtrlSMonitor(
79 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
83 Status
= gBS
->OpenProtocol(
85 &gEfiSimpleTextInputExProtocolGuid
,
89 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
90 if (EFI_ERROR(Status
)) {
95 STRING_TOKEN (STR_SHELL_NO_IN_EX
),
96 ShellInfoObject
.HiiHandle
);
100 KeyData
.KeyState
.KeyToggleState
= 0;
101 KeyData
.Key
.ScanCode
= 0;
102 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
103 KeyData
.Key
.UnicodeChar
= L
's';
105 Status
= SimpleEx
->RegisterKeyNotify(
108 NotificationFunction
,
109 &ShellInfoObject
.CtrlSNotifyHandle1
);
111 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
112 if (!EFI_ERROR(Status
)) {
113 Status
= SimpleEx
->RegisterKeyNotify(
116 NotificationFunction
,
117 &ShellInfoObject
.CtrlSNotifyHandle2
);
119 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
120 KeyData
.Key
.UnicodeChar
= 19;
122 if (!EFI_ERROR(Status
)) {
123 Status
= SimpleEx
->RegisterKeyNotify(
126 NotificationFunction
,
127 &ShellInfoObject
.CtrlSNotifyHandle2
);
129 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
130 if (!EFI_ERROR(Status
)) {
131 Status
= SimpleEx
->RegisterKeyNotify(
134 NotificationFunction
,
135 &ShellInfoObject
.CtrlSNotifyHandle2
);
143 The entry point for the application.
145 @param[in] ImageHandle The firmware allocated handle for the EFI image.
146 @param[in] SystemTable A pointer to the EFI System Table.
148 @retval EFI_SUCCESS The entry point is executed successfully.
149 @retval other Some error occurs when executing this entry point.
155 IN EFI_HANDLE ImageHandle
,
156 IN EFI_SYSTEM_TABLE
*SystemTable
162 EFI_HANDLE ConInHandle
;
163 EFI_SIMPLE_TEXT_INPUT_PROTOCOL
*OldConIn
;
165 if (PcdGet8(PcdShellSupportLevel
) > 3) {
166 return (EFI_UNSUPPORTED
);
172 Status
= gST
->ConOut
->ClearScreen(gST
->ConOut
);
173 if (EFI_ERROR(Status
)) {
178 // Populate the global structure from PCDs
180 ShellInfoObject
.ImageDevPath
= NULL
;
181 ShellInfoObject
.FileDevPath
= NULL
;
182 ShellInfoObject
.PageBreakEnabled
= PcdGetBool(PcdShellPageBreakDefault
);
183 ShellInfoObject
.ViewingSettings
.InsertMode
= PcdGetBool(PcdShellInsertModeDefault
);
184 ShellInfoObject
.LogScreenCount
= PcdGet8 (PcdShellScreenLogCount
);
187 // verify we dont allow for spec violation
189 ASSERT(ShellInfoObject
.LogScreenCount
>= 3);
192 // Initialize the LIST ENTRY objects...
194 InitializeListHead(&ShellInfoObject
.BufferToFreeList
.Link
);
195 InitializeListHead(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
);
196 InitializeListHead(&ShellInfoObject
.SplitList
.Link
);
199 // Check PCDs for optional features that are not implemented yet.
201 if ( PcdGetBool(PcdShellSupportOldProtocols
)
202 || !FeaturePcdGet(PcdShellRequireHiiPlatform
)
203 || FeaturePcdGet(PcdShellSupportFrameworkHii
)
205 return (EFI_UNSUPPORTED
);
209 // turn off the watchdog timer
211 gBS
->SetWatchdogTimer (0, 0, 0, NULL
);
214 // install our console logger. This will keep a log of the output for back-browsing
216 Status
= ConsoleLoggerInstall(ShellInfoObject
.LogScreenCount
, &ShellInfoObject
.ConsoleInfo
);
217 if (!EFI_ERROR(Status
)) {
219 // Enable the cursor to be visible
221 gST
->ConOut
->EnableCursor (gST
->ConOut
, TRUE
);
224 // If supporting EFI 1.1 we need to install HII protocol
225 // only do this if PcdShellRequireHiiPlatform == FALSE
227 // remove EFI_UNSUPPORTED check above when complete.
228 ///@todo add support for Framework HII
231 // install our (solitary) HII package
233 ShellInfoObject
.HiiHandle
= HiiAddPackages (&gEfiCallerIdGuid
, gImageHandle
, ShellStrings
, NULL
);
234 if (ShellInfoObject
.HiiHandle
== NULL
) {
235 if (PcdGetBool(PcdShellSupportFrameworkHii
)) {
236 ///@todo Add our package into Framework HII
238 if (ShellInfoObject
.HiiHandle
== NULL
) {
239 return (EFI_NOT_STARTED
);
244 // create and install the EfiShellParametersProtocol
246 Status
= CreatePopulateInstallShellParametersProtocol(&ShellInfoObject
.NewShellParametersProtocol
, &ShellInfoObject
.RootShellInstance
);
247 ASSERT_EFI_ERROR(Status
);
248 ASSERT(ShellInfoObject
.NewShellParametersProtocol
!= NULL
);
251 // create and install the EfiShellProtocol
253 Status
= CreatePopulateInstallShellProtocol(&ShellInfoObject
.NewEfiShellProtocol
);
254 ASSERT_EFI_ERROR(Status
);
255 ASSERT(ShellInfoObject
.NewEfiShellProtocol
!= NULL
);
258 // Now initialize the shell library (it requires Shell Parameters protocol)
260 Status
= ShellInitialize();
261 ASSERT_EFI_ERROR(Status
);
263 Status
= CommandInit();
264 ASSERT_EFI_ERROR(Status
);
267 // Check the command line
269 Status
= ProcessCommandLine();
272 // If shell support level is >= 1 create the mappings and paths
274 if (PcdGet8(PcdShellSupportLevel
) >= 1) {
275 Status
= ShellCommandCreateInitialMappingsAndPaths();
279 // save the device path for the loaded image and the device path for the filepath (under loaded image)
280 // These are where to look for the startup.nsh file
282 Status
= GetDevicePathsForImageAndFile(&ShellInfoObject
.ImageDevPath
, &ShellInfoObject
.FileDevPath
);
283 ASSERT_EFI_ERROR(Status
);
286 // Display the version
288 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoVersion
) {
291 gST
->ConOut
->Mode
->CursorRow
,
293 STRING_TOKEN (STR_VER_OUTPUT_MAIN
),
294 ShellInfoObject
.HiiHandle
,
295 SupportLevel
[PcdGet8(PcdShellSupportLevel
)],
296 gEfiShellProtocol
->MajorVersion
,
297 gEfiShellProtocol
->MinorVersion
,
298 (gST
->Hdr
.Revision
&0xffff0000)>>16,
299 (gST
->Hdr
.Revision
&0x0000ffff),
301 gST
->FirmwareRevision
306 // Display the mapping
308 if (PcdGet8(PcdShellSupportLevel
) >= 2 && !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoMap
) {
309 Status
= RunCommand(L
"map");
310 ASSERT_EFI_ERROR(Status
);
314 // init all the built in alias'
316 Status
= SetBuiltInAlias();
317 ASSERT_EFI_ERROR(Status
);
320 // Initialize environment variables
322 if (ShellCommandGetProfileList() != NULL
) {
323 Status
= InternalEfiShellSetEnv(L
"profiles", ShellCommandGetProfileList(), TRUE
);
324 ASSERT_EFI_ERROR(Status
);
328 TempString
= AllocateZeroPool(Size
);
330 UnicodeSPrint(TempString
, Size
, L
"%d", PcdGet8(PcdShellSupportLevel
));
331 Status
= InternalEfiShellSetEnv(L
"uefishellsupport", TempString
, TRUE
);
332 ASSERT_EFI_ERROR(Status
);
334 UnicodeSPrint(TempString
, Size
, L
"%d.%d", ShellInfoObject
.NewEfiShellProtocol
->MajorVersion
, ShellInfoObject
.NewEfiShellProtocol
->MinorVersion
);
335 Status
= InternalEfiShellSetEnv(L
"uefishellversion", TempString
, TRUE
);
336 ASSERT_EFI_ERROR(Status
);
338 UnicodeSPrint(TempString
, Size
, L
"%d.%d", (gST
->Hdr
.Revision
& 0xFFFF0000) >> 16, gST
->Hdr
.Revision
& 0x0000FFFF);
339 Status
= InternalEfiShellSetEnv(L
"uefiversion", TempString
, TRUE
);
340 ASSERT_EFI_ERROR(Status
);
342 FreePool(TempString
);
344 if (!EFI_ERROR(Status
)) {
345 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
) {
347 // Set up the event for CTRL-C monitoring...
349 Status
= InernalEfiShellStartMonitor();
352 if (!EFI_ERROR(Status
) && !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
354 // Set up the event for CTRL-S monitoring...
356 Status
= InternalEfiShellStartCtrlSMonitor();
359 if (!EFI_ERROR(Status
) && ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
361 // close off the gST->ConIn
363 OldConIn
= gST
->ConIn
;
364 ConInHandle
= gST
->ConsoleInHandle
;
365 gST
->ConIn
= CreateSimpleTextInOnFile((SHELL_FILE_HANDLE
)&FileInterfaceNulFile
, &gST
->ConsoleInHandle
);
371 if (!EFI_ERROR(Status
) && PcdGet8(PcdShellSupportLevel
) >= 1) {
373 // process the startup script or launch the called app.
375 Status
= DoStartupScript(ShellInfoObject
.ImageDevPath
, ShellInfoObject
.FileDevPath
);
378 if (!ShellCommandGetExit() && (PcdGet8(PcdShellSupportLevel
) >= 3 || PcdGetBool(PcdShellForceConsole
)) && !EFI_ERROR(Status
) && !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
380 // begin the UI waiting loop
384 // clean out all the memory allocated for CONST <something> * return values
385 // between each shell prompt presentation
387 if (!IsListEmpty(&ShellInfoObject
.BufferToFreeList
.Link
)){
388 FreeBufferList(&ShellInfoObject
.BufferToFreeList
);
392 // Reset page break back to default.
394 ShellInfoObject
.PageBreakEnabled
= PcdGetBool(PcdShellPageBreakDefault
);
395 ShellInfoObject
.ConsoleInfo
->Enabled
= TRUE
;
396 ShellInfoObject
.ConsoleInfo
->RowCounter
= 0;
399 // Reset the CTRL-C event (yes we ignore the return values)
401 Status
= gBS
->CheckEvent (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
);
406 Status
= DoShellPrompt();
407 } while (!ShellCommandGetExit());
409 if (OldConIn
!= NULL
&& ConInHandle
!= NULL
) {
410 CloseSimpleTextInOnFile (gST
->ConIn
);
411 gST
->ConIn
= OldConIn
;
412 gST
->ConsoleInHandle
= ConInHandle
;
418 // uninstall protocols / free memory / etc...
420 if (ShellInfoObject
.UserBreakTimer
!= NULL
) {
421 gBS
->CloseEvent(ShellInfoObject
.UserBreakTimer
);
422 DEBUG_CODE(ShellInfoObject
.UserBreakTimer
= NULL
;);
424 if (ShellInfoObject
.ImageDevPath
!= NULL
) {
425 FreePool(ShellInfoObject
.ImageDevPath
);
426 DEBUG_CODE(ShellInfoObject
.ImageDevPath
= NULL
;);
428 if (ShellInfoObject
.FileDevPath
!= NULL
) {
429 FreePool(ShellInfoObject
.FileDevPath
);
430 DEBUG_CODE(ShellInfoObject
.FileDevPath
= NULL
;);
432 if (ShellInfoObject
.NewShellParametersProtocol
!= NULL
) {
433 CleanUpShellParametersProtocol(ShellInfoObject
.NewShellParametersProtocol
);
434 DEBUG_CODE(ShellInfoObject
.NewShellParametersProtocol
= NULL
;);
436 if (ShellInfoObject
.NewEfiShellProtocol
!= NULL
){
437 if (ShellInfoObject
.NewEfiShellProtocol
->IsRootShell()){
438 ShellInfoObject
.NewEfiShellProtocol
->SetEnv(L
"cwd", L
"", TRUE
);
440 CleanUpShellProtocol(ShellInfoObject
.NewEfiShellProtocol
);
441 DEBUG_CODE(ShellInfoObject
.NewEfiShellProtocol
= NULL
;);
444 if (!IsListEmpty(&ShellInfoObject
.BufferToFreeList
.Link
)){
445 FreeBufferList(&ShellInfoObject
.BufferToFreeList
);
448 if (!IsListEmpty(&ShellInfoObject
.SplitList
.Link
)){
449 ASSERT(FALSE
); ///@todo finish this de-allocation.
452 if (ShellInfoObject
.ShellInitSettings
.FileName
!= NULL
) {
453 FreePool(ShellInfoObject
.ShellInitSettings
.FileName
);
454 DEBUG_CODE(ShellInfoObject
.ShellInitSettings
.FileName
= NULL
;);
457 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
458 FreePool(ShellInfoObject
.ShellInitSettings
.FileOptions
);
459 DEBUG_CODE(ShellInfoObject
.ShellInitSettings
.FileOptions
= NULL
;);
462 if (ShellInfoObject
.HiiHandle
!= NULL
) {
463 HiiRemovePackages(ShellInfoObject
.HiiHandle
);
464 DEBUG_CODE(ShellInfoObject
.HiiHandle
= NULL
;);
467 if (!IsListEmpty(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
)){
468 FreeBufferList(&ShellInfoObject
.ViewingSettings
.CommandHistory
);
471 ASSERT(ShellInfoObject
.ConsoleInfo
!= NULL
);
472 if (ShellInfoObject
.ConsoleInfo
!= NULL
) {
473 ConsoleLoggerUninstall(ShellInfoObject
.ConsoleInfo
);
474 FreePool(ShellInfoObject
.ConsoleInfo
);
475 DEBUG_CODE(ShellInfoObject
.ConsoleInfo
= NULL
;);
482 Sets all the alias' that were registered with the ShellCommandLib library.
484 @retval EFI_SUCCESS all init commands were run sucessfully.
492 CONST ALIAS_LIST
*List
;
496 // Get all the commands we want to run
498 List
= ShellCommandGetInitAliasList();
501 // for each command in the List
503 for ( Node
= (ALIAS_LIST
*)GetFirstNode(&List
->Link
)
504 ; !IsNull (&List
->Link
, &Node
->Link
)
505 ; Node
= (ALIAS_LIST
*)GetNextNode(&List
->Link
, &Node
->Link
)
508 // install the alias'
510 Status
= InternalSetAlias(Node
->CommandString
, Node
->Alias
, TRUE
);
511 ASSERT_EFI_ERROR(Status
);
513 return (EFI_SUCCESS
);
517 Internal function to determine if 2 command names are really the same.
519 @param[in] Command1 The pointer to the first command name.
520 @param[in] Command2 The pointer to the second command name.
522 @retval TRUE The 2 command names are the same.
523 @retval FALSE The 2 command names are not the same.
528 IN CONST CHAR16
*Command1
,
529 IN CONST CHAR16
*Command2
532 if (StringNoCaseCompare(&Command1
, &Command2
) == 0) {
539 Internal function to determine if a command is a script only command.
541 @param[in] CommandName The pointer to the command name.
543 @retval TRUE The command is a script only command.
544 @retval FALSE The command is not a script only command.
549 IN CONST CHAR16
*CommandName
552 if (IsCommand(CommandName
, L
"for")
553 ||IsCommand(CommandName
, L
"endfor")
554 ||IsCommand(CommandName
, L
"if")
555 ||IsCommand(CommandName
, L
"else")
556 ||IsCommand(CommandName
, L
"endif")
557 ||IsCommand(CommandName
, L
"goto")) {
564 This function will populate the 2 device path protocol parameters based on the
565 global gImageHandle. The DevPath will point to the device path for the handle that has
566 loaded image protocol installed on it. The FilePath will point to the device path
567 for the file that was loaded.
569 @param[in,out] DevPath On a sucessful return the device path to the loaded image.
570 @param[in,out] FilePath On a sucessful return the device path to the file.
572 @retval EFI_SUCCESS The 2 device paths were sucessfully returned.
573 @retval other A error from gBS->HandleProtocol.
579 GetDevicePathsForImageAndFile (
580 IN OUT EFI_DEVICE_PATH_PROTOCOL
**DevPath
,
581 IN OUT EFI_DEVICE_PATH_PROTOCOL
**FilePath
585 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
586 EFI_DEVICE_PATH_PROTOCOL
*ImageDevicePath
;
588 ASSERT(DevPath
!= NULL
);
589 ASSERT(FilePath
!= NULL
);
591 Status
= gBS
->OpenProtocol (
593 &gEfiLoadedImageProtocolGuid
,
594 (VOID
**)&LoadedImage
,
597 EFI_OPEN_PROTOCOL_GET_PROTOCOL
599 if (!EFI_ERROR (Status
)) {
600 Status
= gBS
->OpenProtocol (
601 LoadedImage
->DeviceHandle
,
602 &gEfiDevicePathProtocolGuid
,
603 (VOID
**)&ImageDevicePath
,
606 EFI_OPEN_PROTOCOL_GET_PROTOCOL
608 if (!EFI_ERROR (Status
)) {
609 *DevPath
= DuplicateDevicePath (ImageDevicePath
);
610 *FilePath
= DuplicateDevicePath (LoadedImage
->FilePath
);
612 LoadedImage
->DeviceHandle
,
613 &gEfiDevicePathProtocolGuid
,
619 &gEfiLoadedImageProtocolGuid
,
626 STATIC CONST SHELL_PARAM_ITEM mShellParamList
[] = {
627 {L
"-nostartup", TypeFlag
},
628 {L
"-startup", TypeFlag
},
629 {L
"-noconsoleout", TypeFlag
},
630 {L
"-noconsolein", TypeFlag
},
631 {L
"-nointerrupt", TypeFlag
},
632 {L
"-nomap", TypeFlag
},
633 {L
"-noversion", TypeFlag
},
634 {L
"-startup", TypeFlag
},
635 {L
"-delay", TypeValue
},
640 Process all Uefi Shell 2.0 command line options.
642 see Uefi Shell 2.0 section 3.2 for full details.
644 the command line must resemble the following:
646 shell.efi [ShellOpt-options] [options] [file-name [file-name-options]]
648 ShellOpt-options Options which control the initialization behavior of the shell.
649 These options are read from the EFI global variable "ShellOpt"
650 and are processed before options or file-name.
652 options Options which control the initialization behavior of the shell.
654 file-name The name of a UEFI shell application or script to be executed
655 after initialization is complete. By default, if file-name is
656 specified, then -nostartup is implied. Scripts are not supported
659 file-name-options The command-line options that are passed to file-name when it
662 This will initialize the ShellInfoObject.ShellInitSettings global variable.
664 @retval EFI_SUCCESS The variable is initialized.
675 CONST CHAR16
*TempConst
;
678 CHAR16
*ProblemParam
;
684 Status
= ShellCommandLineParse (mShellParamList
, &Package
, NULL
, FALSE
);
688 TempConst
= ShellCommandLineGetRawValue(Package
, Count
++);
689 if (TempConst
!= NULL
&& StrLen(TempConst
)) {
690 ShellInfoObject
.ShellInitSettings
.FileName
= AllocateZeroPool(StrSize(TempConst
));
691 if (ShellInfoObject
.ShellInitSettings
.FileName
== NULL
) {
692 return (EFI_OUT_OF_RESOURCES
);
694 StrCpy(ShellInfoObject
.ShellInitSettings
.FileName
, TempConst
);
695 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
= 1;
696 for (LoopVar
= 0 ; LoopVar
< gEfiShellParametersProtocol
->Argc
; LoopVar
++) {
697 if (StrCmp(gEfiShellParametersProtocol
->Argv
[LoopVar
], ShellInfoObject
.ShellInitSettings
.FileName
)==0) {
700 // We found the file... add the rest of the params...
702 for ( ; LoopVar
< gEfiShellParametersProtocol
->Argc
; LoopVar
++) {
703 ASSERT((ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
&& Size
== 0) || (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
));
704 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileOptions
,
708 if (ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
) {
709 SHELL_FREE_NON_NULL(ShellInfoObject
.ShellInitSettings
.FileName
);
710 return (EFI_OUT_OF_RESOURCES
);
712 StrnCatGrow(&ShellInfoObject
.ShellInitSettings
.FileOptions
,
714 gEfiShellParametersProtocol
->Argv
[LoopVar
],
716 if (ShellInfoObject
.ShellInitSettings
.FileOptions
== NULL
) {
717 SHELL_FREE_NON_NULL(ShellInfoObject
.ShellInitSettings
.FileName
);
718 return (EFI_OUT_OF_RESOURCES
);
724 ShellCommandLineFreeVarList(Package
);
726 Status
= ShellCommandLineParse (mShellParamList
, &Package
, &ProblemParam
, FALSE
);
727 if (EFI_ERROR(Status
)) {
728 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_PROBLEM
), ShellInfoObject
.HiiHandle
, ProblemParam
);
729 FreePool(ProblemParam
);
730 ShellCommandLineFreeVarList(Package
);
731 return (EFI_INVALID_PARAMETER
);
735 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
= ShellCommandLineGetFlag(Package
, L
"-startup");
736 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
= ShellCommandLineGetFlag(Package
, L
"-nostartup");
737 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleOut
= ShellCommandLineGetFlag(Package
, L
"-noconsoleout");
738 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
= ShellCommandLineGetFlag(Package
, L
"-noconsolein");
739 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
= ShellCommandLineGetFlag(Package
, L
"-nointerrupt");
740 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoMap
= ShellCommandLineGetFlag(Package
, L
"-nomap");
741 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoVersion
= ShellCommandLineGetFlag(Package
, L
"-noversion");
742 ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Delay
= ShellCommandLineGetFlag(Package
, L
"-delay");
744 ShellInfoObject
.ShellInitSettings
.Delay
= 5;
746 if (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoInterrupt
) {
747 ShellInfoObject
.ShellInitSettings
.Delay
= 0;
748 } else if (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Delay
) {
749 TempConst
= ShellCommandLineGetValue(Package
, L
"-delay");
750 if (TempConst
!= NULL
&& *TempConst
== L
':') {
753 if (TempConst
!= NULL
&& !EFI_ERROR(ShellConvertStringToUint64(TempConst
, &Intermediate
, FALSE
, FALSE
))) {
754 ShellInfoObject
.ShellInitSettings
.Delay
= (UINTN
)Intermediate
;
757 ShellCommandLineFreeVarList(Package
);
763 Handles all interaction with the default startup script.
765 this will check that the correct command line parameters were passed, handle the delay, and then start running the script.
767 @param ImagePath the path to the image for shell. first place to look for the startup script
768 @param FilePath the path to the file for shell. second place to look for the startup script.
770 @retval EFI_SUCCESS the variable is initialized.
775 EFI_DEVICE_PATH_PROTOCOL
*ImagePath
,
776 EFI_DEVICE_PATH_PROTOCOL
*FilePath
782 SHELL_FILE_HANDLE FileHandle
;
783 EFI_DEVICE_PATH_PROTOCOL
*NewPath
;
784 EFI_DEVICE_PATH_PROTOCOL
*NamePath
;
785 CHAR16
*FileStringPath
;
788 CONST CHAR16
*MapName
;
790 Key
.UnicodeChar
= CHAR_NULL
;
794 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
&& ShellInfoObject
.ShellInitSettings
.FileName
!= NULL
) {
796 // launch something else instead
798 NewSize
= StrSize(ShellInfoObject
.ShellInitSettings
.FileName
);
799 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
800 NewSize
+= StrSize(ShellInfoObject
.ShellInitSettings
.FileOptions
) + sizeof(CHAR16
);
802 FileStringPath
= AllocateZeroPool(NewSize
);
803 if (FileStringPath
== NULL
) {
804 return (EFI_OUT_OF_RESOURCES
);
806 StrCpy(FileStringPath
, ShellInfoObject
.ShellInitSettings
.FileName
);
807 if (ShellInfoObject
.ShellInitSettings
.FileOptions
!= NULL
) {
808 StrCat(FileStringPath
, L
" ");
809 StrCat(FileStringPath
, ShellInfoObject
.ShellInitSettings
.FileOptions
);
811 Status
= RunCommand(FileStringPath
);
812 FreePool(FileStringPath
);
818 // for shell level 0 we do no scripts
819 // Without the Startup bit overriding we allow for nostartup to prevent scripts
821 if ( (PcdGet8(PcdShellSupportLevel
) < 1)
822 || (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoStartup
&& !ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.Startup
)
824 return (EFI_SUCCESS
);
828 // print out our warning and see if they press a key
830 for ( Status
= EFI_UNSUPPORTED
, Delay
= ShellInfoObject
.ShellInitSettings
.Delay
* 10
831 ; Delay
!= 0 && EFI_ERROR(Status
)
834 ShellPrintHiiEx(0, gST
->ConOut
->Mode
->CursorRow
, NULL
, STRING_TOKEN (STR_SHELL_STARTUP_QUESTION
), ShellInfoObject
.HiiHandle
, Delay
/10);
836 if (!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoConsoleIn
) {
837 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
840 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CRLF
), ShellInfoObject
.HiiHandle
);
845 if (Status
== EFI_SUCCESS
&& Key
.UnicodeChar
== 0 && Key
.ScanCode
== SCAN_ESC
) {
846 return (EFI_SUCCESS
);
850 // Try the first location (must be file system)
852 MapName
= ShellInfoObject
.NewEfiShellProtocol
->GetMapFromDevicePath(&ImagePath
);
853 if (MapName
!= NULL
) {
854 FileStringPath
= NULL
;
856 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, MapName
, 0);
857 TempSpot
= StrStr(FileStringPath
, L
";");
858 if (TempSpot
!= NULL
) {
859 *TempSpot
= CHAR_NULL
;
861 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, ((FILEPATH_DEVICE_PATH
*)FilePath
)->PathName
, 0);
862 ChopLastSlash(FileStringPath
);
863 FileStringPath
= StrnCatGrow(&FileStringPath
, &NewSize
, mStartupScript
, 0);
864 Status
= ShellInfoObject
.NewEfiShellProtocol
->OpenFileByName(FileStringPath
, &FileHandle
, EFI_FILE_MODE_READ
);
865 FreePool(FileStringPath
);
867 if (EFI_ERROR(Status
)) {
868 NamePath
= FileDevicePath (NULL
, mStartupScript
);
869 NewPath
= AppendDevicePathNode (ImagePath
, NamePath
);
875 Status
= InternalOpenFileDevicePath(NewPath
, &FileHandle
, EFI_FILE_MODE_READ
, 0);
879 // If we got a file, run it
881 if (!EFI_ERROR(Status
) && FileHandle
!= NULL
) {
882 Status
= RunScriptFileHandle (FileHandle
, mStartupScript
);
883 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(FileHandle
);
885 FileStringPath
= ShellFindFilePath(mStartupScript
);
886 if (FileStringPath
== NULL
) {
888 // we return success since we dont need to have a startup script
890 Status
= EFI_SUCCESS
;
891 ASSERT(FileHandle
== NULL
);
893 Status
= RunScriptFile(FileStringPath
);
894 FreePool(FileStringPath
);
903 Function to perform the shell prompt looping. It will do a single prompt,
904 dispatch the result, and then return. It is expected that the caller will
905 call this function in a loop many times.
908 @retval RETURN_ABORTED
919 CONST CHAR16
*CurDir
;
926 // Get screen setting to decide size of the command line buffer
928 gST
->ConOut
->QueryMode (gST
->ConOut
, gST
->ConOut
->Mode
->Mode
, &Column
, &Row
);
929 BufferSize
= Column
* Row
* sizeof (CHAR16
);
930 CmdLine
= AllocateZeroPool (BufferSize
);
931 if (CmdLine
== NULL
) {
932 return EFI_OUT_OF_RESOURCES
;
935 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
940 gST
->ConOut
->SetCursorPosition (gST
->ConOut
, 0, gST
->ConOut
->Mode
->CursorRow
);
942 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
943 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
945 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
949 // Read a line from the console
951 Status
= ShellInfoObject
.NewEfiShellProtocol
->ReadFile(ShellInfoObject
.NewShellParametersProtocol
->StdIn
, &BufferSize
, CmdLine
);
954 // Null terminate the string and parse it
956 if (!EFI_ERROR (Status
)) {
957 CmdLine
[BufferSize
/ sizeof (CHAR16
)] = CHAR_NULL
;
958 Status
= RunCommand(CmdLine
);
962 // Done with this command
969 Add a buffer to the Buffer To Free List for safely returning buffers to other
970 places without risking letting them modify internal shell information.
972 @param Buffer Something to pass to FreePool when the shell is exiting.
980 BUFFER_LIST
*BufferListEntry
;
982 if (Buffer
== NULL
) {
986 BufferListEntry
= AllocateZeroPool(sizeof(BUFFER_LIST
));
987 ASSERT(BufferListEntry
!= NULL
);
988 BufferListEntry
->Buffer
= Buffer
;
989 InsertTailList(&ShellInfoObject
.BufferToFreeList
.Link
, &BufferListEntry
->Link
);
994 Add a buffer to the Line History List
996 @param Buffer The line buffer to add.
1000 AddLineToCommandHistory(
1001 IN CONST CHAR16
*Buffer
1006 Node
= AllocateZeroPool(sizeof(BUFFER_LIST
));
1007 ASSERT(Node
!= NULL
);
1008 Node
->Buffer
= AllocateZeroPool(StrSize(Buffer
));
1009 ASSERT(Node
->Buffer
!= NULL
);
1010 StrCpy(Node
->Buffer
, Buffer
);
1012 InsertTailList(&ShellInfoObject
.ViewingSettings
.CommandHistory
.Link
, &Node
->Link
);
1016 Checks if a string is an alias for another command. If yes, then it replaces the alias name
1017 with the correct command name.
1019 @param[in,out] CommandString Upon entry the potential alias. Upon return the
1020 command name if it was an alias. If it was not
1021 an alias it will be unchanged. This function may
1022 change the buffer to fit the command name.
1024 @retval EFI_SUCCESS The name was changed.
1025 @retval EFI_SUCCESS The name was not an alias.
1026 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
1031 IN OUT CHAR16
**CommandString
1034 CONST CHAR16
*NewString
;
1036 NewString
= ShellInfoObject
.NewEfiShellProtocol
->GetAlias(*CommandString
, NULL
);
1037 if (NewString
== NULL
) {
1038 return (EFI_SUCCESS
);
1040 FreePool(*CommandString
);
1041 *CommandString
= AllocateZeroPool(StrSize(NewString
));
1042 if (*CommandString
== NULL
) {
1043 return (EFI_OUT_OF_RESOURCES
);
1045 StrCpy(*CommandString
, NewString
);
1046 return (EFI_SUCCESS
);
1050 Function allocates a new command line and replaces all instances of environment
1051 variable names that are correctly preset to their values.
1053 If the return value is not NULL the memory must be caller freed.
1055 @param[in] OriginalCommandLine The original command line
1057 @retval NULL An error ocurred.
1058 @return The new command line with no environment variables present.
1062 ShellConvertVariables (
1063 IN CONST CHAR16
*OriginalCommandLine
1066 CONST CHAR16
*MasterEnvList
;
1068 CHAR16
*NewCommandLine1
;
1069 CHAR16
*NewCommandLine2
;
1073 SCRIPT_FILE
*CurrentScriptFile
;
1074 ALIAS_LIST
*AliasListNode
;
1076 ASSERT(OriginalCommandLine
!= NULL
);
1079 NewSize
= StrSize(OriginalCommandLine
);
1080 CurrentScriptFile
= ShellCommandGetCurrentScriptFile();
1083 ///@todo update this to handle the %0 - %9 for scripting only (borrow from line 1256 area) ? ? ?
1086 // calculate the size required for the post-conversion string...
1088 if (CurrentScriptFile
!= NULL
) {
1089 for (AliasListNode
= (ALIAS_LIST
*)GetFirstNode(&CurrentScriptFile
->SubstList
)
1090 ; !IsNull(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1091 ; AliasListNode
= (ALIAS_LIST
*)GetNextNode(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1093 for (Temp
= StrStr(OriginalCommandLine
, AliasListNode
->Alias
)
1095 ; Temp
= StrStr(Temp
+1, AliasListNode
->Alias
)
1098 // we need a preceeding and if there is space no ^ preceeding (if no space ignore)
1100 if ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2)) {
1101 NewSize
+= StrSize(AliasListNode
->CommandString
);
1107 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1108 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
//&& *(MasterEnvList+1) != CHAR_NULL
1109 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1111 if (StrSize(MasterEnvList
) > ItemSize
) {
1112 ItemSize
= StrSize(MasterEnvList
);
1114 for (Temp
= StrStr(OriginalCommandLine
, MasterEnvList
)
1116 ; Temp
= StrStr(Temp
+1, MasterEnvList
)
1119 // we need a preceeding and following % and if there is space no ^ preceeding (if no space ignore)
1121 if (*(Temp
-1) == L
'%' && *(Temp
+StrLen(MasterEnvList
)) == L
'%' &&
1122 ((((Temp
-OriginalCommandLine
)>2) && *(Temp
-2) != L
'^') || ((Temp
-OriginalCommandLine
)<=2))) {
1123 NewSize
+=StrSize(EfiShellGetEnv(MasterEnvList
));
1129 // Quick out if none were found...
1131 if (NewSize
== StrSize(OriginalCommandLine
)) {
1132 ASSERT(Temp
== NULL
);
1133 Temp
= StrnCatGrow(&Temp
, NULL
, OriginalCommandLine
, 0);
1138 // now do the replacements...
1140 NewCommandLine1
= AllocateZeroPool(NewSize
);
1141 NewCommandLine2
= AllocateZeroPool(NewSize
);
1142 ItemTemp
= AllocateZeroPool(ItemSize
+(2*sizeof(CHAR16
)));
1143 if (NewCommandLine1
== NULL
|| NewCommandLine2
== NULL
|| ItemTemp
== NULL
) {
1144 SHELL_FREE_NON_NULL(NewCommandLine1
);
1145 SHELL_FREE_NON_NULL(NewCommandLine2
);
1146 SHELL_FREE_NON_NULL(ItemTemp
);
1149 StrCpy(NewCommandLine1
, OriginalCommandLine
);
1150 for (MasterEnvList
= EfiShellGetEnv(NULL
)
1151 ; MasterEnvList
!= NULL
&& *MasterEnvList
!= CHAR_NULL
//&& *(MasterEnvList+1) != CHAR_NULL
1152 ; MasterEnvList
+= StrLen(MasterEnvList
) + 1
1154 StrCpy(ItemTemp
, L
"%");
1155 StrCat(ItemTemp
, MasterEnvList
);
1156 StrCat(ItemTemp
, L
"%");
1157 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, ItemTemp
, EfiShellGetEnv(MasterEnvList
), TRUE
, FALSE
);
1158 StrCpy(NewCommandLine1
, NewCommandLine2
);
1160 if (CurrentScriptFile
!= NULL
) {
1161 for (AliasListNode
= (ALIAS_LIST
*)GetFirstNode(&CurrentScriptFile
->SubstList
)
1162 ; !IsNull(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1163 ; AliasListNode
= (ALIAS_LIST
*)GetNextNode(&CurrentScriptFile
->SubstList
, &AliasListNode
->Link
)
1165 ShellCopySearchAndReplace(NewCommandLine1
, NewCommandLine2
, NewSize
, AliasListNode
->Alias
, AliasListNode
->CommandString
, TRUE
, FALSE
);
1166 StrCpy(NewCommandLine1
, NewCommandLine2
);
1170 FreePool(NewCommandLine2
);
1173 return (NewCommandLine1
);
1177 Internal function to run a command line with pipe usage.
1179 @param[in] CmdLine The pointer to the command line.
1180 @param[in] StdIn The pointer to the Standard input.
1181 @param[in] StdOut The pointer to the Standard output.
1183 @retval EFI_SUCCESS The split command is executed successfully.
1184 @retval other Some error occurs when executing the split command.
1189 IN CONST CHAR16
*CmdLine
,
1190 IN SHELL_FILE_HANDLE
*StdIn
,
1191 IN SHELL_FILE_HANDLE
*StdOut
1195 CHAR16
*NextCommandLine
;
1196 CHAR16
*OurCommandLine
;
1200 SHELL_FILE_HANDLE
*TempFileHandle
;
1203 ASSERT(StdOut
== NULL
);
1205 ASSERT(StrStr(CmdLine
, L
"|") != NULL
);
1207 Status
= EFI_SUCCESS
;
1208 NextCommandLine
= NULL
;
1209 OurCommandLine
= NULL
;
1213 NextCommandLine
= StrnCatGrow(&NextCommandLine
, &Size1
, StrStr(CmdLine
, L
"|")+1, 0);
1214 OurCommandLine
= StrnCatGrow(&OurCommandLine
, &Size2
, CmdLine
, StrStr(CmdLine
, L
"|") - CmdLine
);
1215 if (NextCommandLine
[0] != CHAR_NULL
&&
1216 NextCommandLine
[0] == L
'a' &&
1217 NextCommandLine
[1] == L
' '
1219 CopyMem(NextCommandLine
, NextCommandLine
+1, StrSize(NextCommandLine
) - sizeof(NextCommandLine
[0]));
1227 // make a SPLIT_LIST item and add to list
1229 Split
= AllocateZeroPool(sizeof(SPLIT_LIST
));
1230 ASSERT(Split
!= NULL
);
1231 Split
->SplitStdIn
= StdIn
;
1232 Split
->SplitStdOut
= ConvertEfiFileProtocolToShellHandle(CreateFileInterfaceMem(Unicode
), NULL
);
1233 ASSERT(Split
->SplitStdOut
!= NULL
);
1234 InsertHeadList(&ShellInfoObject
.SplitList
.Link
, &Split
->Link
);
1236 ASSERT(StrStr(OurCommandLine
, L
"|") == NULL
);
1237 Status
= RunCommand(OurCommandLine
);
1240 // move the output from the first to the in to the second.
1242 TempFileHandle
= Split
->SplitStdOut
;
1243 if (Split
->SplitStdIn
== StdIn
) {
1244 Split
->SplitStdOut
= NULL
;
1246 Split
->SplitStdOut
= Split
->SplitStdIn
;
1248 Split
->SplitStdIn
= TempFileHandle
;
1249 ShellInfoObject
.NewEfiShellProtocol
->SetFilePosition(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdIn
), 0);
1251 if (!EFI_ERROR(Status
)) {
1252 Status
= RunCommand(NextCommandLine
);
1256 // remove the top level from the ScriptList
1258 ASSERT((SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
) == Split
);
1259 RemoveEntryList(&Split
->Link
);
1262 // Note that the original StdIn is now the StdOut...
1264 if (Split
->SplitStdOut
!= NULL
&& Split
->SplitStdOut
!= StdIn
) {
1265 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdOut
));
1267 if (Split
->SplitStdIn
!= NULL
) {
1268 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(ConvertShellHandleToEfiFileProtocol(Split
->SplitStdIn
));
1272 FreePool(NextCommandLine
);
1273 FreePool(OurCommandLine
);
1279 Function will process and run a command line.
1281 This will determine if the command line represents an internal shell
1282 command or dispatch an external application.
1284 @param[in] CmdLine The command line to parse.
1286 @retval EFI_SUCCESS The command was completed.
1287 @retval EFI_ABORTED The command's operation was aborted.
1292 IN CONST CHAR16
*CmdLine
1296 CHAR16
*CommandName
;
1297 SHELL_STATUS ShellStatus
;
1301 CHAR16 LeString
[11];
1302 CHAR16
*PostAliasCmdLine
;
1303 UINTN PostAliasSize
;
1304 CHAR16
*PostVariableCmdLine
;
1305 CHAR16
*CommandWithPath
;
1306 CONST EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
1307 CONST CHAR16
*TempLocation
;
1308 CONST CHAR16
*TempLocation2
;
1309 SHELL_FILE_HANDLE OriginalStdIn
;
1310 SHELL_FILE_HANDLE OriginalStdOut
;
1311 SHELL_FILE_HANDLE OriginalStdErr
;
1312 SYSTEM_TABLE_INFO OriginalSystemTableInfo
;
1313 CHAR16
*TempLocation3
;
1316 CHAR16
*CleanOriginal
;
1319 ASSERT(CmdLine
!= NULL
);
1320 if (StrLen(CmdLine
) == 0) {
1321 return (EFI_SUCCESS
);
1325 PostVariableCmdLine
= NULL
;
1326 PostAliasCmdLine
= NULL
;
1327 CommandWithPath
= NULL
;
1329 Status
= EFI_SUCCESS
;
1330 CleanOriginal
= NULL
;
1333 CleanOriginal
= StrnCatGrow(&CleanOriginal
, NULL
, CmdLine
, 0);
1334 while (CleanOriginal
[StrLen(CleanOriginal
)-1] == L
' ') {
1335 CleanOriginal
[StrLen(CleanOriginal
)-1] = CHAR_NULL
;
1337 while (CleanOriginal
[0] == L
' ') {
1338 CopyMem(CleanOriginal
, CleanOriginal
+1, StrSize(CleanOriginal
) - sizeof(CleanOriginal
[0]));
1342 if (StrStr(CleanOriginal
, L
" ") == NULL
){
1343 StrnCatGrow(&CommandName
, NULL
, CleanOriginal
, 0);
1345 StrnCatGrow(&CommandName
, NULL
, CleanOriginal
, StrStr(CleanOriginal
, L
" ") - CleanOriginal
);
1348 ASSERT(PostAliasCmdLine
== NULL
);
1349 if (!ShellCommandIsCommandOnList(CommandName
)) {
1351 // Convert via alias
1353 Status
= ShellConvertAlias(&CommandName
);
1355 PostAliasCmdLine
= StrnCatGrow(&PostAliasCmdLine
, &PostAliasSize
, CommandName
, 0);
1356 PostAliasCmdLine
= StrnCatGrow(&PostAliasCmdLine
, &PostAliasSize
, StrStr(CleanOriginal
, L
" "), 0);
1357 ASSERT_EFI_ERROR(Status
);
1359 PostAliasCmdLine
= StrnCatGrow(&PostAliasCmdLine
, NULL
, CleanOriginal
, 0);
1362 if (CleanOriginal
!= NULL
) {
1363 FreePool(CleanOriginal
);
1364 CleanOriginal
= NULL
;
1367 if (CommandName
!= NULL
) {
1368 FreePool(CommandName
);
1372 PostVariableCmdLine
= ShellConvertVariables(PostAliasCmdLine
);
1375 // we can now free the modified by alias command line
1377 if (PostAliasCmdLine
!= NULL
) {
1378 FreePool(PostAliasCmdLine
);
1379 PostAliasCmdLine
= NULL
;
1382 if (PostVariableCmdLine
== NULL
) {
1383 return (EFI_OUT_OF_RESOURCES
);
1386 while (PostVariableCmdLine
[StrLen(PostVariableCmdLine
)-1] == L
' ') {
1387 PostVariableCmdLine
[StrLen(PostVariableCmdLine
)-1] = CHAR_NULL
;
1389 while (PostVariableCmdLine
[0] == L
' ') {
1390 CopyMem(PostVariableCmdLine
, PostVariableCmdLine
+1, StrSize(PostVariableCmdLine
) - sizeof(PostVariableCmdLine
[0]));
1394 // We dont do normal processing with a split command line (output from one command input to another)
1396 TempLocation3
= NULL
;
1397 if (StrStr(PostVariableCmdLine
, L
"|") != NULL
) {
1398 for (TempLocation3
= PostVariableCmdLine
; TempLocation3
!= NULL
&& *TempLocation3
!= CHAR_NULL
; TempLocation3
++) {
1399 if (*TempLocation3
== L
'^' && *(TempLocation3
+1) == L
'|') {
1401 } else if (*TempLocation3
== L
'|') {
1406 if (TempLocation3
!= NULL
&& *TempLocation3
!= CHAR_NULL
) {
1408 // are we in an existing split???
1410 if (!IsListEmpty(&ShellInfoObject
.SplitList
.Link
)) {
1411 Split
= (SPLIT_LIST
*)GetFirstNode(&ShellInfoObject
.SplitList
.Link
);
1414 if (Split
== NULL
) {
1415 Status
= RunSplitCommand(PostVariableCmdLine
, NULL
, NULL
);
1417 Status
= RunSplitCommand(PostVariableCmdLine
, Split
->SplitStdIn
, Split
->SplitStdOut
);
1422 // If this is a mapped drive change handle that...
1424 if (PostVariableCmdLine
[(StrLen(PostVariableCmdLine
)-1)] == L
':' && StrStr(PostVariableCmdLine
, L
" ") == NULL
) {
1425 Status
= ShellInfoObject
.NewEfiShellProtocol
->SetCurDir(NULL
, PostVariableCmdLine
);
1426 if (EFI_ERROR(Status
)) {
1427 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_MAPPING
), ShellInfoObject
.HiiHandle
, PostVariableCmdLine
);
1429 FreePool(PostVariableCmdLine
);
1433 ///@todo update this section to divide into 3 ways - run internal command, run split (above), and run an external file...
1434 /// We waste a lot of time doing processing like StdIn,StdOut,Argv,Argc for things that are external files...
1438 Status
= UpdateStdInStdOutStdErr(ShellInfoObject
.NewShellParametersProtocol
, PostVariableCmdLine
, &OriginalStdIn
, &OriginalStdOut
, &OriginalStdErr
, &OriginalSystemTableInfo
);
1439 if (EFI_ERROR(Status
)) {
1440 if (Status
== EFI_NOT_FOUND
) {
1441 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_REDUNDA_REDIR
), ShellInfoObject
.HiiHandle
);
1443 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_INVALID_REDIR
), ShellInfoObject
.HiiHandle
);
1446 while (PostVariableCmdLine
[StrLen(PostVariableCmdLine
)-1] == L
' ') {
1447 PostVariableCmdLine
[StrLen(PostVariableCmdLine
)-1] = CHAR_NULL
;
1449 while (PostVariableCmdLine
[0] == L
' ') {
1450 CopyMem(PostVariableCmdLine
, PostVariableCmdLine
+1, StrSize(PostVariableCmdLine
) - sizeof(PostVariableCmdLine
[0]));
1454 // get the argc and argv updated for internal commands
1456 Status
= UpdateArgcArgv(ShellInfoObject
.NewShellParametersProtocol
, PostVariableCmdLine
, &Argv
, &Argc
);
1457 ASSERT_EFI_ERROR(Status
);
1459 for (Count
= 0 ; Count
< ShellInfoObject
.NewShellParametersProtocol
->Argc
; Count
++) {
1460 if (StrStr(ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count
], L
"-?") == ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count
]
1461 || (ShellInfoObject
.NewShellParametersProtocol
->Argv
[0][0] == L
'?' && ShellInfoObject
.NewShellParametersProtocol
->Argv
[0][1] == CHAR_NULL
)
1464 // We need to redo the arguments since a parameter was -?
1465 // move them all down 1 to the end, then up one then replace the first with help
1467 FreePool(ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count
]);
1468 ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count
] = NULL
;
1469 for (Count2
= Count
; (Count2
+ 1) < ShellInfoObject
.NewShellParametersProtocol
->Argc
; Count2
++) {
1470 ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count2
] = ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count2
+1];
1472 ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count2
] = NULL
;
1473 for (Count2
= ShellInfoObject
.NewShellParametersProtocol
->Argc
-1 ; Count2
> 0 ; Count2
--) {
1474 ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count2
] = ShellInfoObject
.NewShellParametersProtocol
->Argv
[Count2
-1];
1476 ShellInfoObject
.NewShellParametersProtocol
->Argv
[0] = NULL
;
1477 ShellInfoObject
.NewShellParametersProtocol
->Argv
[0] = StrnCatGrow(&ShellInfoObject
.NewShellParametersProtocol
->Argv
[0], NULL
, L
"help", 0);
1485 if (ShellCommandIsCommandOnList(ShellInfoObject
.NewShellParametersProtocol
->Argv
[0])) {
1487 // Run the command (which was converted if it was an alias)
1489 if (!EFI_ERROR(Status
)) {
1490 Status
= ShellCommandRunCommandHandler(ShellInfoObject
.NewShellParametersProtocol
->Argv
[0], &ShellStatus
, &LastError
);
1491 ASSERT_EFI_ERROR(Status
);
1492 UnicodeSPrint(LeString
, sizeof(LeString
)*sizeof(LeString
[0]), L
"0x%08x", ShellStatus
);
1493 DEBUG_CODE(InternalEfiShellSetEnv(L
"DebugLasterror", LeString
, TRUE
););
1495 InternalEfiShellSetEnv(L
"Lasterror", LeString
, TRUE
);
1498 // Pass thru the exitcode from the app.
1500 if (ShellCommandGetExit()) {
1501 Status
= ShellStatus
;
1502 } else if (ShellStatus
!= 0 && IsScriptOnlyCommand(ShellInfoObject
.NewShellParametersProtocol
->Argv
[0])) {
1503 Status
= EFI_ABORTED
;
1508 // run an external file (or script)
1510 if (StrStr(ShellInfoObject
.NewShellParametersProtocol
->Argv
[0], L
":") != NULL
) {
1511 ASSERT (CommandWithPath
== NULL
);
1512 if (ShellIsFile(ShellInfoObject
.NewShellParametersProtocol
->Argv
[0]) == EFI_SUCCESS
) {
1513 CommandWithPath
= StrnCatGrow(&CommandWithPath
, NULL
, ShellInfoObject
.NewShellParametersProtocol
->Argv
[0], 0);
1516 if (CommandWithPath
== NULL
) {
1517 CommandWithPath
= ShellFindFilePathEx(ShellInfoObject
.NewShellParametersProtocol
->Argv
[0], mExecutableExtensions
);
1519 if (CommandWithPath
== NULL
|| ShellIsDirectory(CommandWithPath
) == EFI_SUCCESS
) {
1520 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_NOT_FOUND
), ShellInfoObject
.HiiHandle
, ShellInfoObject
.NewShellParametersProtocol
->Argv
[0]);
1523 // Check if it's a NSH (script) file.
1525 TempLocation
= CommandWithPath
+StrLen(CommandWithPath
)-4;
1526 TempLocation2
= mScriptExtension
;
1527 if ((StrLen(CommandWithPath
) > 4) && (StringNoCaseCompare((VOID
*)(&TempLocation
), (VOID
*)(&TempLocation2
)) == 0)) {
1528 Status
= RunScriptFile (CommandWithPath
);
1530 DevPath
= ShellInfoObject
.NewEfiShellProtocol
->GetDevicePathFromFilePath(CommandWithPath
);
1531 ASSERT(DevPath
!= NULL
);
1532 Status
= InternalShellExecuteDevicePath(
1535 PostVariableCmdLine
,
1542 CommandName
= StrnCatGrow(&CommandName
, NULL
, ShellInfoObject
.NewShellParametersProtocol
->Argv
[0], 0);
1544 RestoreArgcArgv(ShellInfoObject
.NewShellParametersProtocol
, &Argv
, &Argc
);
1546 RestoreStdInStdOutStdErr(ShellInfoObject
.NewShellParametersProtocol
, &OriginalStdIn
, &OriginalStdOut
, &OriginalStdErr
, &OriginalSystemTableInfo
);
1548 if (CommandName
!= NULL
) {
1549 if (ShellCommandGetCurrentScriptFile() != NULL
&& !IsScriptOnlyCommand(CommandName
)) {
1551 // if this is NOT a scipt only command return success so the script won't quit.
1552 // prevent killing the script - this is the only place where we know the actual command name (after alias and variable replacement...)
1554 Status
= EFI_SUCCESS
;
1559 SHELL_FREE_NON_NULL(CommandName
);
1560 SHELL_FREE_NON_NULL(CommandWithPath
);
1561 SHELL_FREE_NON_NULL(PostVariableCmdLine
);
1566 STATIC CONST UINT16 InvalidChars
[] = {L
'*', L
'?', L
'<', L
'>', L
'\\', L
'/', L
'\"', 0x0001, 0x0002};
1568 Function determins if the CommandName COULD be a valid command. It does not determine whether
1569 this is a valid command. It only checks for invalid characters.
1571 @param[in] CommandName The name to check
1573 @retval TRUE CommandName could be a command name
1574 @retval FALSE CommandName could not be a valid command name
1579 IN CONST CHAR16
*CommandName
1583 if (CommandName
== NULL
) {
1588 ; Count
< sizeof(InvalidChars
) / sizeof(InvalidChars
[0])
1591 if (ScanMem16(CommandName
, StrSize(CommandName
), InvalidChars
[Count
]) != NULL
) {
1599 Function to process a NSH script file via SHELL_FILE_HANDLE.
1601 @param[in] Handle The handle to the already opened file.
1602 @param[in] Name The name of the script file.
1604 @retval EFI_SUCCESS the script completed sucessfully
1608 RunScriptFileHandle (
1609 IN SHELL_FILE_HANDLE Handle
,
1610 IN CONST CHAR16
*Name
1614 SCRIPT_FILE
*NewScriptFile
;
1616 CHAR16
*CommandLine
;
1617 CHAR16
*CommandLine2
;
1618 CHAR16
*CommandLine3
;
1619 SCRIPT_COMMAND_LIST
*LastCommand
;
1621 BOOLEAN PreScriptEchoState
;
1622 CONST CHAR16
*CurDir
;
1625 ASSERT(!ShellCommandGetScriptExit());
1627 PreScriptEchoState
= ShellCommandGetEchoState();
1629 NewScriptFile
= (SCRIPT_FILE
*)AllocateZeroPool(sizeof(SCRIPT_FILE
));
1630 if (NewScriptFile
== NULL
) {
1631 return (EFI_OUT_OF_RESOURCES
);
1637 ASSERT(NewScriptFile
->ScriptName
== NULL
);
1638 NewScriptFile
->ScriptName
= StrnCatGrow(&NewScriptFile
->ScriptName
, NULL
, Name
, 0);
1639 if (NewScriptFile
->ScriptName
== NULL
) {
1640 DeleteScriptFileStruct(NewScriptFile
);
1641 return (EFI_OUT_OF_RESOURCES
);
1645 // Save the parameters (used to replace %0 to %9 later on)
1647 NewScriptFile
->Argc
= ShellInfoObject
.NewShellParametersProtocol
->Argc
;
1648 if (NewScriptFile
->Argc
!= 0) {
1649 NewScriptFile
->Argv
= (CHAR16
**)AllocateZeroPool(NewScriptFile
->Argc
* sizeof(CHAR16
*));
1650 if (NewScriptFile
->Argv
== NULL
) {
1651 DeleteScriptFileStruct(NewScriptFile
);
1652 return (EFI_OUT_OF_RESOURCES
);
1654 for (LoopVar
= 0 ; LoopVar
< 10 && LoopVar
< NewScriptFile
->Argc
; LoopVar
++) {
1655 ASSERT(NewScriptFile
->Argv
[LoopVar
] == NULL
);
1656 NewScriptFile
->Argv
[LoopVar
] = StrnCatGrow(&NewScriptFile
->Argv
[LoopVar
], NULL
, ShellInfoObject
.NewShellParametersProtocol
->Argv
[LoopVar
], 0);
1657 if (NewScriptFile
->Argv
[LoopVar
] == NULL
) {
1658 DeleteScriptFileStruct(NewScriptFile
);
1659 return (EFI_OUT_OF_RESOURCES
);
1663 NewScriptFile
->Argv
= NULL
;
1666 InitializeListHead(&NewScriptFile
->CommandList
);
1667 InitializeListHead(&NewScriptFile
->SubstList
);
1670 // Now build the list of all script commands.
1673 while(!ShellFileHandleEof(Handle
)) {
1674 CommandLine
= ShellFileHandleReturnLine(Handle
, &Ascii
);
1676 if (CommandLine
== NULL
|| StrLen(CommandLine
) == 0) {
1679 NewScriptFile
->CurrentCommand
= AllocateZeroPool(sizeof(SCRIPT_COMMAND_LIST
));
1680 if (NewScriptFile
->CurrentCommand
== NULL
) {
1681 DeleteScriptFileStruct(NewScriptFile
);
1682 return (EFI_OUT_OF_RESOURCES
);
1685 NewScriptFile
->CurrentCommand
->Cl
= CommandLine
;
1686 NewScriptFile
->CurrentCommand
->Data
= NULL
;
1687 NewScriptFile
->CurrentCommand
->Line
= LineCount
;
1689 InsertTailList(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
1693 // Add this as the topmost script file
1695 ShellCommandSetNewScript (NewScriptFile
);
1698 // Now enumerate through the commands and run each one.
1700 CommandLine
= AllocateZeroPool(PcdGet16(PcdShellPrintBufferSize
));
1701 if (CommandLine
== NULL
) {
1702 DeleteScriptFileStruct(NewScriptFile
);
1703 return (EFI_OUT_OF_RESOURCES
);
1705 CommandLine2
= AllocateZeroPool(PcdGet16(PcdShellPrintBufferSize
));
1706 if (CommandLine2
== NULL
) {
1707 FreePool(CommandLine
);
1708 DeleteScriptFileStruct(NewScriptFile
);
1709 return (EFI_OUT_OF_RESOURCES
);
1712 for ( NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetFirstNode(&NewScriptFile
->CommandList
)
1713 ; !IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)
1714 ; // conditional increment in the body of the loop
1716 ASSERT(CommandLine2
!= NULL
);
1717 StrCpy(CommandLine2
, NewScriptFile
->CurrentCommand
->Cl
);
1720 // NULL out comments
1722 for (CommandLine3
= CommandLine2
; CommandLine3
!= NULL
&& *CommandLine3
!= CHAR_NULL
; CommandLine3
++) {
1723 if (*CommandLine3
== L
'^') {
1724 if (*(CommandLine3
+1) == L
'#' || *(CommandLine3
+1) == L
':') {
1725 CopyMem(CommandLine3
, CommandLine3
+1, StrSize(CommandLine3
) - sizeof(CommandLine3
[0]));
1727 } else if (*CommandLine3
== L
'#') {
1728 *CommandLine3
= CHAR_NULL
;
1732 if (CommandLine2
!= NULL
&& StrLen(CommandLine2
) >= 1) {
1734 // Due to variability in starting the find and replace action we need to have both buffers the same.
1736 StrCpy(CommandLine
, CommandLine2
);
1739 // Remove the %0 to %9 from the command line (if we have some arguments)
1741 if (NewScriptFile
->Argv
!= NULL
) {
1742 switch (NewScriptFile
->Argc
) {
1744 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%9", NewScriptFile
->Argv
[9], FALSE
, TRUE
);
1745 ASSERT_EFI_ERROR(Status
);
1747 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%8", NewScriptFile
->Argv
[8], FALSE
, TRUE
);
1748 ASSERT_EFI_ERROR(Status
);
1750 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%7", NewScriptFile
->Argv
[7], FALSE
, TRUE
);
1751 ASSERT_EFI_ERROR(Status
);
1753 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%6", NewScriptFile
->Argv
[6], FALSE
, TRUE
);
1754 ASSERT_EFI_ERROR(Status
);
1756 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%5", NewScriptFile
->Argv
[5], FALSE
, TRUE
);
1757 ASSERT_EFI_ERROR(Status
);
1759 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%4", NewScriptFile
->Argv
[4], FALSE
, TRUE
);
1760 ASSERT_EFI_ERROR(Status
);
1762 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%3", NewScriptFile
->Argv
[3], FALSE
, TRUE
);
1763 ASSERT_EFI_ERROR(Status
);
1765 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%2", NewScriptFile
->Argv
[2], FALSE
, TRUE
);
1766 ASSERT_EFI_ERROR(Status
);
1768 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%1", NewScriptFile
->Argv
[1], FALSE
, TRUE
);
1769 ASSERT_EFI_ERROR(Status
);
1771 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%0", NewScriptFile
->Argv
[0], FALSE
, TRUE
);
1772 ASSERT_EFI_ERROR(Status
);
1778 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%1", L
"\"\"", FALSE
, FALSE
);
1779 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%2", L
"\"\"", FALSE
, FALSE
);
1780 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%3", L
"\"\"", FALSE
, FALSE
);
1781 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%4", L
"\"\"", FALSE
, FALSE
);
1782 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%5", L
"\"\"", FALSE
, FALSE
);
1783 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%6", L
"\"\"", FALSE
, FALSE
);
1784 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%7", L
"\"\"", FALSE
, FALSE
);
1785 Status
= ShellCopySearchAndReplace(CommandLine
, CommandLine2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%8", L
"\"\"", FALSE
, FALSE
);
1786 Status
= ShellCopySearchAndReplace(CommandLine2
, CommandLine
, PcdGet16 (PcdShellPrintBufferSize
), L
"%9", L
"\"\"", FALSE
, FALSE
);
1788 StrCpy(CommandLine2
, CommandLine
);
1790 LastCommand
= NewScriptFile
->CurrentCommand
;
1792 for (CommandLine3
= CommandLine2
; CommandLine3
[0] == L
' ' ; CommandLine3
++);
1794 if (CommandLine3
!= NULL
&& CommandLine3
[0] == L
':' ) {
1796 // This line is a goto target / label
1799 if (CommandLine3
!= NULL
&& StrLen(CommandLine3
) > 0) {
1800 if (ShellCommandGetEchoState()) {
1801 CurDir
= ShellInfoObject
.NewEfiShellProtocol
->GetEnv(L
"cwd");
1802 if (CurDir
!= NULL
&& StrLen(CurDir
) > 1) {
1803 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_CURDIR
), ShellInfoObject
.HiiHandle
, CurDir
);
1805 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_SHELL_SHELL
), ShellInfoObject
.HiiHandle
);
1807 ShellPrintEx(-1, -1, L
"%s\r\n", CommandLine2
);
1809 Status
= RunCommand(CommandLine3
);
1812 if (ShellCommandGetScriptExit()) {
1813 ShellCommandRegisterExit(FALSE
);
1814 Status
= EFI_SUCCESS
;
1817 if (EFI_ERROR(Status
)) {
1820 if (ShellCommandGetExit()) {
1825 // If that commend did not update the CurrentCommand then we need to advance it...
1827 if (LastCommand
== NewScriptFile
->CurrentCommand
) {
1828 NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetNextNode(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
1829 if (!IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)) {
1830 NewScriptFile
->CurrentCommand
->Reset
= TRUE
;
1834 NewScriptFile
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetNextNode(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
);
1835 if (!IsNull(&NewScriptFile
->CommandList
, &NewScriptFile
->CurrentCommand
->Link
)) {
1836 NewScriptFile
->CurrentCommand
->Reset
= TRUE
;
1842 FreePool(CommandLine
);
1843 FreePool(CommandLine2
);
1844 ShellCommandSetNewScript (NULL
);
1847 // Only if this was the last script reset the state.
1849 if (ShellCommandGetCurrentScriptFile()==NULL
) {
1850 ShellCommandSetEchoState(PreScriptEchoState
);
1852 return (EFI_SUCCESS
);
1856 Function to process a NSH script file.
1858 @param[in] ScriptPath Pointer to the script file name (including file system path).
1860 @retval EFI_SUCCESS the script completed sucessfully
1865 IN CONST CHAR16
*ScriptPath
1869 SHELL_FILE_HANDLE FileHandle
;
1871 if (ShellIsFile(ScriptPath
) != EFI_SUCCESS
) {
1872 return (EFI_INVALID_PARAMETER
);
1875 Status
= ShellOpenFileByName(ScriptPath
, &FileHandle
, EFI_FILE_MODE_READ
, 0);
1876 if (EFI_ERROR(Status
)) {
1880 Status
= RunScriptFileHandle(FileHandle
, ScriptPath
);
1882 ShellCloseFile(&FileHandle
);