2 Provides interface to shell internal functions for shell commands.
4 Copyright (c) 2013-2014, Hewlett-Packard Development Company, L.P.<BR>
5 Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
16 #include "UefiShellCommandLib.h"
18 // STATIC local variables
19 STATIC SHELL_COMMAND_INTERNAL_LIST_ENTRY mCommandList
;
20 STATIC SCRIPT_FILE_LIST mScriptList
;
21 STATIC ALIAS_LIST mAliasList
;
22 STATIC BOOLEAN mEchoState
;
23 STATIC BOOLEAN mExitRequested
;
24 STATIC UINT64 mExitCode
;
25 STATIC BOOLEAN mExitScript
;
26 STATIC CHAR16
*mProfileList
;
27 STATIC UINTN mProfileListSize
;
28 STATIC UINTN mFsMaxCount
= 0;
29 STATIC UINTN mBlkMaxCount
= 0;
30 STATIC BUFFER_LIST mFileHandleList
;
32 // global variables required by library class.
33 EFI_UNICODE_COLLATION_PROTOCOL
*gUnicodeCollation
= NULL
;
34 SHELL_MAP_LIST gShellMapList
;
35 SHELL_MAP_LIST
*gShellCurDir
= NULL
;
37 CONST CHAR16
* SupportLevel
[] = {
45 Function to make sure that the global protocol pointers are valid.
46 must be called after constructor before accessing the pointers.
55 if (gUnicodeCollation
== NULL
) {
56 Status
= gBS
->LocateProtocol(&gEfiUnicodeCollation2ProtocolGuid
, NULL
, (VOID
**)&gUnicodeCollation
);
57 if (EFI_ERROR(Status
)) {
58 return (EFI_DEVICE_ERROR
);
65 Constructor for the Shell Command library.
67 Initialize the library and determine if the underlying is a UEFI Shell 2.0 or an EFI shell.
69 @param ImageHandle the image handle of the process
70 @param SystemTable the EFI System Table pointer
72 @retval EFI_SUCCESS the initialization was complete sucessfully
76 ShellCommandLibConstructor (
77 IN EFI_HANDLE ImageHandle
,
78 IN EFI_SYSTEM_TABLE
*SystemTable
82 InitializeListHead(&gShellMapList
.Link
);
83 InitializeListHead(&mCommandList
.Link
);
84 InitializeListHead(&mAliasList
.Link
);
85 InitializeListHead(&mScriptList
.Link
);
86 InitializeListHead(&mFileHandleList
.Link
);
89 mExitRequested
= FALSE
;
94 if (gUnicodeCollation
== NULL
) {
95 Status
= gBS
->LocateProtocol(&gEfiUnicodeCollation2ProtocolGuid
, NULL
, (VOID
**)&gUnicodeCollation
);
96 if (EFI_ERROR(Status
)) {
97 return (EFI_DEVICE_ERROR
);
101 return (RETURN_SUCCESS
);
105 Frees list of file handles.
107 @param[in] List The list to free.
115 BUFFER_LIST
*BufferListEntry
;
121 // enumerate through the buffer list and free all memory
123 for ( BufferListEntry
= ( BUFFER_LIST
*)GetFirstNode(&List
->Link
)
124 ; !IsListEmpty (&List
->Link
)
125 ; BufferListEntry
= (BUFFER_LIST
*)GetFirstNode(&List
->Link
)
127 RemoveEntryList(&BufferListEntry
->Link
);
128 ASSERT(BufferListEntry
->Buffer
!= NULL
);
129 SHELL_FREE_NON_NULL(((SHELL_COMMAND_FILE_HANDLE
*)(BufferListEntry
->Buffer
))->Path
);
130 SHELL_FREE_NON_NULL(BufferListEntry
->Buffer
);
131 SHELL_FREE_NON_NULL(BufferListEntry
);
136 Destructor for the library. free any resources.
138 @param ImageHandle the image handle of the process
139 @param SystemTable the EFI System Table pointer
141 @retval RETURN_SUCCESS this function always returns success
145 ShellCommandLibDestructor (
146 IN EFI_HANDLE ImageHandle
,
147 IN EFI_SYSTEM_TABLE
*SystemTable
150 SHELL_COMMAND_INTERNAL_LIST_ENTRY
*Node
;
152 SCRIPT_FILE_LIST
*Node3
;
153 SHELL_MAP_LIST
*MapNode
;
155 // enumerate throught the list and free all the memory
157 while (!IsListEmpty (&mCommandList
.Link
)) {
158 Node
= (SHELL_COMMAND_INTERNAL_LIST_ENTRY
*)GetFirstNode(&mCommandList
.Link
);
159 RemoveEntryList(&Node
->Link
);
160 SHELL_FREE_NON_NULL(Node
->CommandString
);
162 DEBUG_CODE(Node
= NULL
;);
166 // enumerate through the alias list and free all memory
168 while (!IsListEmpty (&mAliasList
.Link
)) {
169 Node2
= (ALIAS_LIST
*)GetFirstNode(&mAliasList
.Link
);
170 RemoveEntryList(&Node2
->Link
);
171 SHELL_FREE_NON_NULL(Node2
->CommandString
);
172 SHELL_FREE_NON_NULL(Node2
->Alias
);
173 SHELL_FREE_NON_NULL(Node2
);
174 DEBUG_CODE(Node2
= NULL
;);
178 // enumerate throught the list and free all the memory
180 while (!IsListEmpty (&mScriptList
.Link
)) {
181 Node3
= (SCRIPT_FILE_LIST
*)GetFirstNode(&mScriptList
.Link
);
182 RemoveEntryList(&Node3
->Link
);
183 DeleteScriptFileStruct(Node3
->Data
);
188 // enumerate throught the mappings list and free all the memory
190 if (!IsListEmpty(&gShellMapList
.Link
)) {
191 for (MapNode
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
192 ; !IsListEmpty (&gShellMapList
.Link
)
193 ; MapNode
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
195 ASSERT(MapNode
!= NULL
);
196 RemoveEntryList(&MapNode
->Link
);
197 SHELL_FREE_NON_NULL(MapNode
->DevicePath
);
198 SHELL_FREE_NON_NULL(MapNode
->MapName
);
199 SHELL_FREE_NON_NULL(MapNode
->CurrentDirectoryPath
);
203 if (!IsListEmpty(&mFileHandleList
.Link
)){
204 FreeFileHandleList(&mFileHandleList
);
207 if (mProfileList
!= NULL
) {
208 FreePool(mProfileList
);
211 gUnicodeCollation
= NULL
;
214 return (RETURN_SUCCESS
);
218 Find a dynamic command protocol instance given a command name string.
220 @param CommandString the command name string
222 @return instance the command protocol instance, if dynamic command instance found
223 @retval NULL no dynamic command protocol instance found for name
225 CONST EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL
*
227 ShellCommandFindDynamicCommand (
228 IN CONST CHAR16
*CommandString
232 EFI_HANDLE
*CommandHandleList
;
233 EFI_HANDLE
*NextCommand
;
234 EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL
*DynamicCommand
;
236 CommandHandleList
= GetHandleListByProtocol(&gEfiShellDynamicCommandProtocolGuid
);
237 if (CommandHandleList
== NULL
) {
239 // not found or out of resources
244 for (NextCommand
= CommandHandleList
; *NextCommand
!= NULL
; NextCommand
++) {
245 Status
= gBS
->HandleProtocol(
247 &gEfiShellDynamicCommandProtocolGuid
,
248 (VOID
**)&DynamicCommand
251 if (EFI_ERROR(Status
)) {
255 if (gUnicodeCollation
->StriColl(
257 (CHAR16
*)CommandString
,
258 (CHAR16
*)DynamicCommand
->CommandName
) == 0
260 FreePool(CommandHandleList
);
261 return (DynamicCommand
);
265 FreePool(CommandHandleList
);
270 Checks if a command exists as a dynamic command protocol instance
272 @param[in] CommandString The command string to check for on the list.
276 ShellCommandDynamicCommandExists (
277 IN CONST CHAR16
*CommandString
280 return (BOOLEAN
) ((ShellCommandFindDynamicCommand(CommandString
) != NULL
));
284 Checks if a command is already on the internal command list.
286 @param[in] CommandString The command string to check for on the list.
290 ShellCommandIsCommandOnInternalList(
291 IN CONST CHAR16
*CommandString
294 SHELL_COMMAND_INTERNAL_LIST_ENTRY
*Node
;
297 // assert for NULL parameter
299 ASSERT(CommandString
!= NULL
);
302 // check for the command
304 for ( Node
= (SHELL_COMMAND_INTERNAL_LIST_ENTRY
*)GetFirstNode(&mCommandList
.Link
)
305 ; !IsNull(&mCommandList
.Link
, &Node
->Link
)
306 ; Node
= (SHELL_COMMAND_INTERNAL_LIST_ENTRY
*)GetNextNode(&mCommandList
.Link
, &Node
->Link
)
308 ASSERT(Node
->CommandString
!= NULL
);
309 if (gUnicodeCollation
->StriColl(
311 (CHAR16
*)CommandString
,
312 Node
->CommandString
) == 0
321 Checks if a command exists, either internally or through the dynamic command protocol.
323 @param[in] CommandString The command string to check for on the list.
327 ShellCommandIsCommandOnList(
328 IN CONST CHAR16
*CommandString
331 if (ShellCommandIsCommandOnInternalList(CommandString
)) {
335 return ShellCommandDynamicCommandExists(CommandString
);
339 Get the help text for a dynamic command.
341 @param[in] CommandString The command name.
343 @retval NULL No help text was found.
344 @return String of help text. Caller required to free.
348 ShellCommandGetDynamicCommandHelp(
349 IN CONST CHAR16
*CommandString
352 EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL
*DynamicCommand
;
354 DynamicCommand
= (EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL
*)ShellCommandFindDynamicCommand(CommandString
);
355 if (DynamicCommand
== NULL
) {
360 // TODO: how to get proper language?
362 return DynamicCommand
->GetHelp(DynamicCommand
, "en");
366 Get the help text for an internal command.
368 @param[in] CommandString The command name.
370 @retval NULL No help text was found.
371 @return String of help text. Caller reuiqred to free.
375 ShellCommandGetInternalCommandHelp(
376 IN CONST CHAR16
*CommandString
379 SHELL_COMMAND_INTERNAL_LIST_ENTRY
*Node
;
382 // assert for NULL parameter
384 ASSERT(CommandString
!= NULL
);
387 // check for the command
389 for ( Node
= (SHELL_COMMAND_INTERNAL_LIST_ENTRY
*)GetFirstNode(&mCommandList
.Link
)
390 ; !IsNull(&mCommandList
.Link
, &Node
->Link
)
391 ; Node
= (SHELL_COMMAND_INTERNAL_LIST_ENTRY
*)GetNextNode(&mCommandList
.Link
, &Node
->Link
)
393 ASSERT(Node
->CommandString
!= NULL
);
394 if (gUnicodeCollation
->StriColl(
396 (CHAR16
*)CommandString
,
397 Node
->CommandString
) == 0
399 return (HiiGetString(Node
->HiiHandle
, Node
->ManFormatHelp
, NULL
));
406 Get the help text for a command.
408 @param[in] CommandString The command name.
410 @retval NULL No help text was found.
411 @return String of help text.Caller reuiqred to free.
415 ShellCommandGetCommandHelp (
416 IN CONST CHAR16
*CommandString
420 HelpStr
= ShellCommandGetInternalCommandHelp(CommandString
);
422 if (HelpStr
== NULL
) {
423 HelpStr
= ShellCommandGetDynamicCommandHelp(CommandString
);
431 Registers handlers of type SHELL_RUN_COMMAND and
432 SHELL_GET_MAN_FILENAME for each shell command.
434 If the ShellSupportLevel is greater than the value of the
435 PcdShellSupportLevel then return RETURN_UNSUPPORTED.
437 Registers the handlers specified by GetHelpInfoHandler and CommandHandler
438 with the command specified by CommandString. If the command named by
439 CommandString has already been registered, then return
440 RETURN_ALREADY_STARTED.
442 If there are not enough resources available to register the handlers then
443 RETURN_OUT_OF_RESOURCES is returned.
445 If CommandString is NULL, then ASSERT().
446 If GetHelpInfoHandler is NULL, then ASSERT().
447 If CommandHandler is NULL, then ASSERT().
448 If ProfileName is NULL, then ASSERT().
450 @param[in] CommandString Pointer to the command name. This is the
451 name to look for on the command line in
453 @param[in] CommandHandler Pointer to a function that runs the
455 @param[in] GetManFileName Pointer to a function that provides man
457 @param[in] ShellMinSupportLevel minimum Shell Support Level which has this
459 @param[in] ProfileName profile name to require for support of this
461 @param[in] CanAffectLE indicates whether this command's return value
462 can change the LASTERROR environment variable.
463 @param[in] HiiHandle Handle of this command's HII entry.
464 @param[in] ManFormatHelp HII locator for the help text.
466 @retval RETURN_SUCCESS The handlers were registered.
467 @retval RETURN_OUT_OF_RESOURCES There are not enough resources available to
468 register the shell command.
469 @retval RETURN_UNSUPPORTED the ShellMinSupportLevel was higher than the
470 currently allowed support level.
471 @retval RETURN_ALREADY_STARTED The CommandString represents a command that
472 is already registered. Only 1 handler set for
473 a given command is allowed.
474 @sa SHELL_GET_MAN_FILENAME
475 @sa SHELL_RUN_COMMAND
479 ShellCommandRegisterCommandName (
480 IN CONST CHAR16
*CommandString
,
481 IN SHELL_RUN_COMMAND CommandHandler
,
482 IN SHELL_GET_MAN_FILENAME GetManFileName
,
483 IN UINT32 ShellMinSupportLevel
,
484 IN CONST CHAR16
*ProfileName
,
485 IN CONST BOOLEAN CanAffectLE
,
486 IN CONST EFI_HANDLE HiiHandle
,
487 IN CONST EFI_STRING_ID ManFormatHelp
490 SHELL_COMMAND_INTERNAL_LIST_ENTRY
*Node
;
491 SHELL_COMMAND_INTERNAL_LIST_ENTRY
*Command
;
492 SHELL_COMMAND_INTERNAL_LIST_ENTRY
*PrevCommand
;
493 INTN LexicalMatchValue
;
496 // Initialize local variables.
500 LexicalMatchValue
= 0;
503 // ASSERTs for NULL parameters
505 ASSERT(CommandString
!= NULL
);
506 ASSERT(GetManFileName
!= NULL
);
507 ASSERT(CommandHandler
!= NULL
);
508 ASSERT(ProfileName
!= NULL
);
511 // check for shell support level
513 if (PcdGet8(PcdShellSupportLevel
) < ShellMinSupportLevel
) {
514 return (RETURN_UNSUPPORTED
);
518 // check for already on the list
520 if (ShellCommandIsCommandOnList(CommandString
)) {
521 return (RETURN_ALREADY_STARTED
);
525 // allocate memory for new struct
527 Node
= AllocateZeroPool(sizeof(SHELL_COMMAND_INTERNAL_LIST_ENTRY
));
528 ASSERT(Node
!= NULL
);
529 Node
->CommandString
= AllocateZeroPool(StrSize(CommandString
));
530 ASSERT(Node
->CommandString
!= NULL
);
533 // populate the new struct
535 StrCpy(Node
->CommandString
, CommandString
);
537 Node
->GetManFileName
= GetManFileName
;
538 Node
->CommandHandler
= CommandHandler
;
539 Node
->LastError
= CanAffectLE
;
540 Node
->HiiHandle
= HiiHandle
;
541 Node
->ManFormatHelp
= ManFormatHelp
;
543 if ( StrLen(ProfileName
)>0
544 && ((mProfileList
!= NULL
545 && StrStr(mProfileList
, ProfileName
) == NULL
) || mProfileList
== NULL
)
547 ASSERT((mProfileList
== NULL
&& mProfileListSize
== 0) || (mProfileList
!= NULL
));
548 if (mProfileList
== NULL
) {
550 // If this is the first make a leading ';'
552 StrnCatGrow(&mProfileList
, &mProfileListSize
, L
";", 0);
554 StrnCatGrow(&mProfileList
, &mProfileListSize
, ProfileName
, 0);
555 StrnCatGrow(&mProfileList
, &mProfileListSize
, L
";", 0);
559 // Insert a new entry on top of the list
561 InsertHeadList (&mCommandList
.Link
, &Node
->Link
);
564 // Move a new registered command to its sorted ordered location in the list
566 for (Command
= (SHELL_COMMAND_INTERNAL_LIST_ENTRY
*)GetFirstNode (&mCommandList
.Link
),
567 PrevCommand
= (SHELL_COMMAND_INTERNAL_LIST_ENTRY
*)GetFirstNode (&mCommandList
.Link
)
568 ; !IsNull (&mCommandList
.Link
, &Command
->Link
)
569 ; Command
= (SHELL_COMMAND_INTERNAL_LIST_ENTRY
*)GetNextNode (&mCommandList
.Link
, &Command
->Link
)) {
572 // Get Lexical Comparison Value between PrevCommand and Command list entry
574 LexicalMatchValue
= gUnicodeCollation
->StriColl (
576 PrevCommand
->CommandString
,
577 Command
->CommandString
581 // Swap PrevCommand and Command list entry if PrevCommand list entry
582 // is alphabetically greater than Command list entry
584 if (LexicalMatchValue
> 0){
585 Command
= (SHELL_COMMAND_INTERNAL_LIST_ENTRY
*) SwapListEntries (&PrevCommand
->Link
, &Command
->Link
);
586 } else if (LexicalMatchValue
< 0) {
588 // PrevCommand entry is lexically lower than Command entry
594 return (RETURN_SUCCESS
);
598 Function to get the current Profile string.
600 @retval NULL There are no installed profiles.
601 @return A semi-colon delimited list of profiles.
605 ShellCommandGetProfileList (
609 return (mProfileList
);
613 Checks if a command string has been registered for CommandString and if so it runs
614 the previously registered handler for that command with the command line.
616 If CommandString is NULL, then ASSERT().
618 If Sections is specified, then each section name listed will be compared in a casesensitive
619 manner, to the section names described in Appendix B UEFI Shell 2.0 spec. If the section exists,
620 it will be appended to the returned help text. If the section does not exist, no
621 information will be returned. If Sections is NULL, then all help text information
622 available will be returned.
624 @param[in] CommandString Pointer to the command name. This is the name
625 found on the command line in the shell.
626 @param[in, out] RetVal Pointer to the return vaule from the command handler.
628 @param[in, out] CanAffectLE indicates whether this command's return value
629 needs to be placed into LASTERROR environment variable.
631 @retval RETURN_SUCCESS The handler was run.
632 @retval RETURN_NOT_FOUND The CommandString did not match a registered
634 @sa SHELL_RUN_COMMAND
638 ShellCommandRunCommandHandler (
639 IN CONST CHAR16
*CommandString
,
640 IN OUT SHELL_STATUS
*RetVal
,
641 IN OUT BOOLEAN
*CanAffectLE OPTIONAL
644 SHELL_COMMAND_INTERNAL_LIST_ENTRY
*Node
;
645 EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL
*DynamicCommand
;
648 // assert for NULL parameters
650 ASSERT(CommandString
!= NULL
);
653 // check for the command
655 for ( Node
= (SHELL_COMMAND_INTERNAL_LIST_ENTRY
*)GetFirstNode(&mCommandList
.Link
)
656 ; !IsNull(&mCommandList
.Link
, &Node
->Link
)
657 ; Node
= (SHELL_COMMAND_INTERNAL_LIST_ENTRY
*)GetNextNode(&mCommandList
.Link
, &Node
->Link
)
659 ASSERT(Node
->CommandString
!= NULL
);
660 if (gUnicodeCollation
->StriColl(
662 (CHAR16
*)CommandString
,
663 Node
->CommandString
) == 0
665 if (CanAffectLE
!= NULL
) {
666 *CanAffectLE
= Node
->LastError
;
668 if (RetVal
!= NULL
) {
669 *RetVal
= Node
->CommandHandler(NULL
, gST
);
671 Node
->CommandHandler(NULL
, gST
);
673 return (RETURN_SUCCESS
);
678 // An internal command was not found, try to find a dynamic command
680 DynamicCommand
= (EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL
*)ShellCommandFindDynamicCommand(CommandString
);
681 if (DynamicCommand
!= NULL
) {
682 if (RetVal
!= NULL
) {
683 *RetVal
= DynamicCommand
->Handler(DynamicCommand
, gST
, gEfiShellParametersProtocol
, gEfiShellProtocol
);
685 DynamicCommand
->Handler(DynamicCommand
, gST
, gEfiShellParametersProtocol
, gEfiShellProtocol
);
687 return (RETURN_SUCCESS
);
690 return (RETURN_NOT_FOUND
);
694 Checks if a command string has been registered for CommandString and if so it
695 returns the MAN filename specified for that command.
697 If CommandString is NULL, then ASSERT().
699 @param[in] CommandString Pointer to the command name. This is the name
700 found on the command line in the shell.\
702 @retval NULL the commandString was not a registered command.
703 @return other the name of the MAN file.
704 @sa SHELL_GET_MAN_FILENAME
708 ShellCommandGetManFileNameHandler (
709 IN CONST CHAR16
*CommandString
712 SHELL_COMMAND_INTERNAL_LIST_ENTRY
*Node
;
715 // assert for NULL parameters
717 ASSERT(CommandString
!= NULL
);
720 // check for the command
722 for ( Node
= (SHELL_COMMAND_INTERNAL_LIST_ENTRY
*)GetFirstNode(&mCommandList
.Link
)
723 ; !IsNull(&mCommandList
.Link
, &Node
->Link
)
724 ; Node
= (SHELL_COMMAND_INTERNAL_LIST_ENTRY
*)GetNextNode(&mCommandList
.Link
, &Node
->Link
)
726 ASSERT(Node
->CommandString
!= NULL
);
727 if (gUnicodeCollation
->StriColl(
729 (CHAR16
*)CommandString
,
730 Node
->CommandString
) == 0
732 return (Node
->GetManFileName());
739 Get the list of all available shell internal commands. This is a linked list
740 (via LIST_ENTRY structure). enumerate through it using the BaseLib linked
741 list functions. do not modify the values.
743 @param[in] Sort TRUE to alphabetically sort the values first. FALSE otherwise.
745 @return a Linked list of all available shell commands.
749 ShellCommandGetCommandList (
750 IN CONST BOOLEAN Sort
754 // return ((COMMAND_LIST*)(&mCommandList));
756 return ((COMMAND_LIST
*)(&mCommandList
));
760 Registers aliases to be set as part of the initialization of the shell application.
762 If Command is NULL, then ASSERT().
763 If Alias is NULL, then ASSERT().
765 @param[in] Command Pointer to the Command
766 @param[in] Alias Pointer to Alias
768 @retval RETURN_SUCCESS The handlers were registered.
769 @retval RETURN_OUT_OF_RESOURCES There are not enough resources available to
770 register the shell command.
774 ShellCommandRegisterAlias (
775 IN CONST CHAR16
*Command
,
776 IN CONST CHAR16
*Alias
780 ALIAS_LIST
*CommandAlias
;
781 ALIAS_LIST
*PrevCommandAlias
;
782 INTN LexicalMatchValue
;
787 ASSERT(Command
!= NULL
);
788 ASSERT(Alias
!= NULL
);
791 // allocate memory for new struct
793 Node
= AllocateZeroPool(sizeof(ALIAS_LIST
));
794 ASSERT(Node
!= NULL
);
795 Node
->CommandString
= AllocateZeroPool(StrSize(Command
));
796 Node
->Alias
= AllocateZeroPool(StrSize(Alias
));
797 ASSERT(Node
->CommandString
!= NULL
);
798 ASSERT(Node
->Alias
!= NULL
);
801 // populate the new struct
803 StrCpy(Node
->CommandString
, Command
);
804 StrCpy(Node
->Alias
, Alias
);
806 InsertHeadList (&mAliasList
.Link
, &Node
->Link
);
809 // Move a new pre-defined registered alias to its sorted ordered location in the list
811 for ( CommandAlias
= (ALIAS_LIST
*)GetFirstNode (&mAliasList
.Link
),
812 PrevCommandAlias
= (ALIAS_LIST
*)GetFirstNode (&mAliasList
.Link
)
813 ; !IsNull (&mAliasList
.Link
, &CommandAlias
->Link
)
814 ; CommandAlias
= (ALIAS_LIST
*) GetNextNode (&mAliasList
.Link
, &CommandAlias
->Link
) ) {
816 // Get Lexical comparison value between PrevCommandAlias and CommandAlias List Entry
818 LexicalMatchValue
= gUnicodeCollation
->StriColl (
820 PrevCommandAlias
->Alias
,
825 // Swap PrevCommandAlias and CommandAlias list entry if PrevCommandAlias list entry
826 // is alphabetically greater than CommandAlias list entry
828 if (LexicalMatchValue
> 0) {
829 CommandAlias
= (ALIAS_LIST
*) SwapListEntries (&PrevCommandAlias
->Link
, &CommandAlias
->Link
);
830 } else if (LexicalMatchValue
< 0) {
832 // PrevCommandAlias entry is lexically lower than CommandAlias entry
838 return (RETURN_SUCCESS
);
842 Get the list of all shell alias commands. This is a linked list
843 (via LIST_ENTRY structure). enumerate through it using the BaseLib linked
844 list functions. do not modify the values.
846 @return a Linked list of all requested shell alias'.
850 ShellCommandGetInitAliasList (
854 return (&mAliasList
);
858 Determine if a given alias is on the list of built in alias'.
860 @param[in] Alias The alias to test for
862 @retval TRUE The alias is a built in alias
863 @retval FALSE The alias is not a built in alias
867 ShellCommandIsOnAliasList(
868 IN CONST CHAR16
*Alias
874 // assert for NULL parameter
876 ASSERT(Alias
!= NULL
);
879 // check for the Alias
881 for ( Node
= (ALIAS_LIST
*)GetFirstNode(&mAliasList
.Link
)
882 ; !IsNull(&mAliasList
.Link
, &Node
->Link
)
883 ; Node
= (ALIAS_LIST
*)GetNextNode(&mAliasList
.Link
, &Node
->Link
)
885 ASSERT(Node
->CommandString
!= NULL
);
886 ASSERT(Node
->Alias
!= NULL
);
887 if (gUnicodeCollation
->StriColl(
890 Node
->CommandString
) == 0
894 if (gUnicodeCollation
->StriColl(
906 Function to determine current state of ECHO. Echo determins if lines from scripts
907 and ECHO commands are enabled.
909 @retval TRUE Echo is currently enabled
910 @retval FALSE Echo is currently disabled
914 ShellCommandGetEchoState(
922 Function to set current state of ECHO. Echo determins if lines from scripts
923 and ECHO commands are enabled.
925 If State is TRUE, Echo will be enabled.
926 If State is FALSE, Echo will be disabled.
928 @param[in] State How to set echo.
932 ShellCommandSetEchoState(
940 Indicate that the current shell or script should exit.
942 @param[in] ScriptOnly TRUE if exiting a script; FALSE otherwise.
943 @param[in] ErrorCode The 64 bit error code to return.
947 ShellCommandRegisterExit (
948 IN BOOLEAN ScriptOnly
,
949 IN CONST UINT64 ErrorCode
952 mExitRequested
= (BOOLEAN
)(!mExitRequested
);
953 if (mExitRequested
) {
954 mExitScript
= ScriptOnly
;
958 mExitCode
= ErrorCode
;
962 Retrieve the Exit indicator.
964 @retval TRUE Exit was indicated.
965 @retval FALSE Exis was not indicated.
969 ShellCommandGetExit (
973 return (mExitRequested
);
977 Retrieve the Exit code.
979 If ShellCommandGetExit returns FALSE than the return from this is undefined.
981 @return the value passed into RegisterExit.
985 ShellCommandGetExitCode (
992 Retrieve the Exit script indicator.
994 If ShellCommandGetExit returns FALSE than the return from this is undefined.
996 @retval TRUE ScriptOnly was indicated.
997 @retval FALSE ScriptOnly was not indicated.
1001 ShellCommandGetScriptExit (
1005 return (mExitScript
);
1009 Function to cleanup all memory from a SCRIPT_FILE structure.
1011 @param[in] Script The pointer to the structure to cleanup.
1015 DeleteScriptFileStruct (
1016 IN SCRIPT_FILE
*Script
1021 if (Script
== NULL
) {
1025 for (LoopVar
= 0 ; LoopVar
< Script
->Argc
; LoopVar
++) {
1026 SHELL_FREE_NON_NULL(Script
->Argv
[LoopVar
]);
1028 if (Script
->Argv
!= NULL
) {
1029 SHELL_FREE_NON_NULL(Script
->Argv
);
1031 Script
->CurrentCommand
= NULL
;
1032 while (!IsListEmpty (&Script
->CommandList
)) {
1033 Script
->CurrentCommand
= (SCRIPT_COMMAND_LIST
*)GetFirstNode(&Script
->CommandList
);
1034 if (Script
->CurrentCommand
!= NULL
) {
1035 RemoveEntryList(&Script
->CurrentCommand
->Link
);
1036 if (Script
->CurrentCommand
->Cl
!= NULL
) {
1037 SHELL_FREE_NON_NULL(Script
->CurrentCommand
->Cl
);
1039 if (Script
->CurrentCommand
->Data
!= NULL
) {
1040 SHELL_FREE_NON_NULL(Script
->CurrentCommand
->Data
);
1042 SHELL_FREE_NON_NULL(Script
->CurrentCommand
);
1045 SHELL_FREE_NON_NULL(Script
->ScriptName
);
1046 SHELL_FREE_NON_NULL(Script
);
1050 Function to return a pointer to the currently running script file object.
1052 @retval NULL A script file is not currently running.
1053 @return A pointer to the current script file object.
1057 ShellCommandGetCurrentScriptFile (
1061 SCRIPT_FILE_LIST
*List
;
1062 if (IsListEmpty (&mScriptList
.Link
)) {
1065 List
= ((SCRIPT_FILE_LIST
*)GetFirstNode(&mScriptList
.Link
));
1066 return (List
->Data
);
1070 Function to set a new script as the currently running one.
1072 This function will correctly stack and unstack nested scripts.
1074 @param[in] Script Pointer to new script information structure. if NULL
1075 will remove and de-allocate the top-most Script structure.
1077 @return A pointer to the current running script file after this
1078 change. NULL if removing the final script.
1082 ShellCommandSetNewScript (
1083 IN SCRIPT_FILE
*Script OPTIONAL
1086 SCRIPT_FILE_LIST
*Node
;
1087 if (Script
== NULL
) {
1088 if (IsListEmpty (&mScriptList
.Link
)) {
1091 Node
= (SCRIPT_FILE_LIST
*)GetFirstNode(&mScriptList
.Link
);
1092 RemoveEntryList(&Node
->Link
);
1093 DeleteScriptFileStruct(Node
->Data
);
1096 Node
= AllocateZeroPool(sizeof(SCRIPT_FILE_LIST
));
1100 Node
->Data
= Script
;
1101 InsertHeadList(&mScriptList
.Link
, &Node
->Link
);
1103 return (ShellCommandGetCurrentScriptFile());
1107 Function to generate the next default mapping name.
1109 If the return value is not NULL then it must be callee freed.
1111 @param Type What kind of mapping name to make.
1113 @retval NULL a memory allocation failed.
1114 @return a new map name string
1118 ShellCommandCreateNewMappingName(
1119 IN CONST SHELL_MAPPING_TYPE Type
1123 ASSERT(Type
< MappingTypeMax
);
1127 String
= AllocateZeroPool(PcdGet8(PcdShellMapNameLength
) * sizeof(String
[0]));
1130 PcdGet8(PcdShellMapNameLength
) * sizeof(String
[0]),
1131 Type
== MappingTypeFileSystem
?L
"FS%d:":L
"BLK%d:",
1132 Type
== MappingTypeFileSystem
?mFsMaxCount
++:mBlkMaxCount
++);
1138 Function to add a map node to the list of map items and update the "path" environment variable (optionally).
1140 If Path is TRUE (during initialization only), the path environment variable will also be updated to include
1141 default paths on the new map name...
1143 Path should be FALSE when this function is called from the protocol SetMap function.
1145 @param[in] Name The human readable mapped name.
1146 @param[in] DevicePath The Device Path for this map.
1147 @param[in] Flags The Flags attribute for this map item.
1148 @param[in] Path TRUE to update path, FALSE to skip this step (should only be TRUE during initialization).
1150 @retval EFI_SUCCESS The addition was sucessful.
1151 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
1152 @retval EFI_INVALID_PARAMETER A parameter was invalid.
1156 ShellCommandAddMapItemAndUpdatePath(
1157 IN CONST CHAR16
*Name
,
1158 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
1159 IN CONST UINT64 Flags
,
1160 IN CONST BOOLEAN Path
1164 SHELL_MAP_LIST
*MapListNode
;
1165 CONST CHAR16
*OriginalPath
;
1171 OriginalPath
= NULL
;
1172 Status
= EFI_SUCCESS
;
1174 MapListNode
= AllocateZeroPool(sizeof(SHELL_MAP_LIST
));
1175 if (MapListNode
== NULL
) {
1176 Status
= EFI_OUT_OF_RESOURCES
;
1178 MapListNode
->Flags
= Flags
;
1179 MapListNode
->MapName
= AllocateZeroPool(StrSize(Name
));
1180 MapListNode
->DevicePath
= DuplicateDevicePath(DevicePath
);
1181 if ((MapListNode
->MapName
== NULL
) || (MapListNode
->DevicePath
== NULL
)){
1182 Status
= EFI_OUT_OF_RESOURCES
;
1184 StrCpy(MapListNode
->MapName
, Name
);
1185 InsertTailList(&gShellMapList
.Link
, &MapListNode
->Link
);
1188 if (EFI_ERROR(Status
)) {
1189 if (MapListNode
!= NULL
) {
1190 if (MapListNode
->DevicePath
!= NULL
) {
1191 FreePool(MapListNode
->DevicePath
);
1193 if (MapListNode
->MapName
!= NULL
) {
1194 FreePool(MapListNode
->MapName
);
1196 FreePool(MapListNode
);
1200 // Since there was no error and Path was TRUE
1201 // Now add the correct path for that mapping
1203 OriginalPath
= gEfiShellProtocol
->GetEnv(L
"path");
1204 ASSERT((NewPath
== NULL
&& NewPathSize
== 0) || (NewPath
!= NULL
));
1205 if (OriginalPath
!= NULL
) {
1206 StrnCatGrow(&NewPath
, &NewPathSize
, OriginalPath
, 0);
1208 StrnCatGrow(&NewPath
, &NewPathSize
, L
".\\", 0);
1210 StrnCatGrow(&NewPath
, &NewPathSize
, L
";", 0);
1211 StrnCatGrow(&NewPath
, &NewPathSize
, Name
, 0);
1212 StrnCatGrow(&NewPath
, &NewPathSize
, L
"\\efi\\tools\\;", 0);
1213 StrnCatGrow(&NewPath
, &NewPathSize
, Name
, 0);
1214 StrnCatGrow(&NewPath
, &NewPathSize
, L
"\\efi\\boot\\;", 0);
1215 StrnCatGrow(&NewPath
, &NewPathSize
, Name
, 0);
1216 StrnCatGrow(&NewPath
, &NewPathSize
, L
"\\", 0);
1218 Status
= gEfiShellProtocol
->SetEnv(L
"path", NewPath
, TRUE
);
1219 ASSERT_EFI_ERROR(Status
);
1226 Creates the default map names for each device path in the system with
1227 a protocol depending on the Type.
1229 Creates the consistent map names for each device path in the system with
1230 a protocol depending on the Type.
1232 Note: This will reset all mappings in the system("map -r").
1234 Also sets up the default path environment variable if Type is FileSystem.
1236 @retval EFI_SUCCESS All map names were created sucessfully.
1237 @retval EFI_NOT_FOUND No protocols were found in the system.
1238 @return Error returned from gBS->LocateHandle().
1244 ShellCommandCreateInitialMappingsAndPaths(
1249 EFI_HANDLE
*HandleList
;
1251 EFI_DEVICE_PATH_PROTOCOL
**DevicePathList
;
1252 CHAR16
*NewDefaultName
;
1253 CHAR16
*NewConsistName
;
1254 EFI_DEVICE_PATH_PROTOCOL
**ConsistMappingTable
;
1255 SHELL_MAP_LIST
*MapListNode
;
1260 // Reset the static members back to zero
1265 gEfiShellProtocol
->SetEnv(L
"path", L
"", TRUE
);
1268 // First empty out the existing list.
1270 if (!IsListEmpty(&gShellMapList
.Link
)) {
1271 for ( MapListNode
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
1272 ; !IsListEmpty(&gShellMapList
.Link
)
1273 ; MapListNode
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
1275 RemoveEntryList(&MapListNode
->Link
);
1276 FreePool(MapListNode
);
1281 // Find each handle with Simple File System
1283 HandleList
= GetHandleListByProtocol(&gEfiSimpleFileSystemProtocolGuid
);
1284 if (HandleList
!= NULL
) {
1286 // Do a count of the handles
1288 for (Count
= 0 ; HandleList
[Count
] != NULL
; Count
++);
1291 // Get all Device Paths
1293 DevicePathList
= AllocateZeroPool(sizeof(EFI_DEVICE_PATH_PROTOCOL
*) * Count
);
1294 ASSERT(DevicePathList
!= NULL
);
1296 for (Count
= 0 ; HandleList
[Count
] != NULL
; Count
++) {
1297 DevicePathList
[Count
] = DevicePathFromHandle(HandleList
[Count
]);
1301 // Sort all DevicePaths
1303 PerformQuickSort(DevicePathList
, Count
, sizeof(EFI_DEVICE_PATH_PROTOCOL
*), DevicePathCompare
);
1305 ShellCommandConsistMappingInitialize(&ConsistMappingTable
);
1307 // Assign new Mappings to all...
1309 for (Count
= 0 ; HandleList
[Count
] != NULL
; Count
++) {
1311 // Get default name first
1313 NewDefaultName
= ShellCommandCreateNewMappingName(MappingTypeFileSystem
);
1314 ASSERT(NewDefaultName
!= NULL
);
1315 Status
= ShellCommandAddMapItemAndUpdatePath(NewDefaultName
, DevicePathList
[Count
], 0, TRUE
);
1316 ASSERT_EFI_ERROR(Status
);
1317 FreePool(NewDefaultName
);
1320 // Now do consistent name
1322 NewConsistName
= ShellCommandConsistMappingGenMappingName(DevicePathList
[Count
], ConsistMappingTable
);
1323 if (NewConsistName
!= NULL
) {
1324 Status
= ShellCommandAddMapItemAndUpdatePath(NewConsistName
, DevicePathList
[Count
], 0, FALSE
);
1325 ASSERT_EFI_ERROR(Status
);
1326 FreePool(NewConsistName
);
1330 ShellCommandConsistMappingUnInitialize(ConsistMappingTable
);
1332 SHELL_FREE_NON_NULL(HandleList
);
1333 SHELL_FREE_NON_NULL(DevicePathList
);
1341 // Find each handle with Block Io
1343 HandleList
= GetHandleListByProtocol(&gEfiBlockIoProtocolGuid
);
1344 if (HandleList
!= NULL
) {
1345 for (Count
= 0 ; HandleList
[Count
] != NULL
; Count
++);
1348 // Get all Device Paths
1350 DevicePathList
= AllocateZeroPool(sizeof(EFI_DEVICE_PATH_PROTOCOL
*) * Count
);
1351 ASSERT(DevicePathList
!= NULL
);
1353 for (Count
= 0 ; HandleList
[Count
] != NULL
; Count
++) {
1354 DevicePathList
[Count
] = DevicePathFromHandle(HandleList
[Count
]);
1358 // Sort all DevicePaths
1360 PerformQuickSort(DevicePathList
, Count
, sizeof(EFI_DEVICE_PATH_PROTOCOL
*), DevicePathCompare
);
1363 // Assign new Mappings to all...
1365 for (Count
= 0 ; HandleList
[Count
] != NULL
; Count
++) {
1367 // Get default name first
1369 NewDefaultName
= ShellCommandCreateNewMappingName(MappingTypeBlockIo
);
1370 ASSERT(NewDefaultName
!= NULL
);
1371 Status
= ShellCommandAddMapItemAndUpdatePath(NewDefaultName
, DevicePathList
[Count
], 0, FALSE
);
1372 ASSERT_EFI_ERROR(Status
);
1373 FreePool(NewDefaultName
);
1376 SHELL_FREE_NON_NULL(HandleList
);
1377 SHELL_FREE_NON_NULL(DevicePathList
);
1378 } else if (Count
== (UINTN
)-1) {
1379 return (EFI_NOT_FOUND
);
1382 return (EFI_SUCCESS
);
1386 Add mappings for any devices without one. Do not change any existing maps.
1388 @retval EFI_SUCCESS The operation was successful.
1392 ShellCommandUpdateMapping (
1397 EFI_HANDLE
*HandleList
;
1399 EFI_DEVICE_PATH_PROTOCOL
**DevicePathList
;
1400 CHAR16
*NewDefaultName
;
1401 CHAR16
*NewConsistName
;
1402 EFI_DEVICE_PATH_PROTOCOL
**ConsistMappingTable
;
1405 Status
= EFI_SUCCESS
;
1408 // remove mappings that represent removed devices.
1412 // Find each handle with Simple File System
1414 HandleList
= GetHandleListByProtocol(&gEfiSimpleFileSystemProtocolGuid
);
1415 if (HandleList
!= NULL
) {
1417 // Do a count of the handles
1419 for (Count
= 0 ; HandleList
[Count
] != NULL
; Count
++);
1422 // Get all Device Paths
1424 DevicePathList
= AllocateZeroPool(sizeof(EFI_DEVICE_PATH_PROTOCOL
*) * Count
);
1425 if (DevicePathList
== NULL
) {
1426 return (EFI_OUT_OF_RESOURCES
);
1429 for (Count
= 0 ; HandleList
[Count
] != NULL
; Count
++) {
1430 DevicePathList
[Count
] = DevicePathFromHandle(HandleList
[Count
]);
1434 // Sort all DevicePaths
1436 PerformQuickSort(DevicePathList
, Count
, sizeof(EFI_DEVICE_PATH_PROTOCOL
*), DevicePathCompare
);
1438 ShellCommandConsistMappingInitialize(&ConsistMappingTable
);
1441 // Assign new Mappings to remainders
1443 for (Count
= 0 ; !EFI_ERROR(Status
) && HandleList
[Count
] != NULL
&& !EFI_ERROR(Status
); Count
++) {
1445 // Skip ones that already have
1447 if (gEfiShellProtocol
->GetMapFromDevicePath(&DevicePathList
[Count
]) != NULL
) {
1453 NewDefaultName
= ShellCommandCreateNewMappingName(MappingTypeFileSystem
);
1454 if (NewDefaultName
== NULL
) {
1455 Status
= EFI_OUT_OF_RESOURCES
;
1460 // Call shell protocol SetMap function now...
1462 Status
= gEfiShellProtocol
->SetMap(DevicePathList
[Count
], NewDefaultName
);
1464 if (!EFI_ERROR(Status
)) {
1466 // Now do consistent name
1468 NewConsistName
= ShellCommandConsistMappingGenMappingName(DevicePathList
[Count
], ConsistMappingTable
);
1469 if (NewConsistName
!= NULL
) {
1470 Status
= gEfiShellProtocol
->SetMap(DevicePathList
[Count
], NewConsistName
);
1471 FreePool(NewConsistName
);
1475 FreePool(NewDefaultName
);
1477 ShellCommandConsistMappingUnInitialize(ConsistMappingTable
);
1478 SHELL_FREE_NON_NULL(HandleList
);
1479 SHELL_FREE_NON_NULL(DevicePathList
);
1486 // Do it all over again for gEfiBlockIoProtocolGuid
1493 Converts a SHELL_FILE_HANDLE to an EFI_FILE_PROTOCOL*.
1495 @param[in] Handle The SHELL_FILE_HANDLE to convert.
1497 @return a EFI_FILE_PROTOCOL* representing the same file.
1501 ConvertShellHandleToEfiFileProtocol(
1502 IN CONST SHELL_FILE_HANDLE Handle
1505 return ((EFI_FILE_PROTOCOL
*)(Handle
));
1509 Converts a EFI_FILE_PROTOCOL* to an SHELL_FILE_HANDLE.
1511 @param[in] Handle The pointer to EFI_FILE_PROTOCOL to convert.
1512 @param[in] Path The path to the file for verification.
1514 @return A SHELL_FILE_HANDLE representing the same file.
1515 @retval NULL There was not enough memory.
1519 ConvertEfiFileProtocolToShellHandle(
1520 IN CONST EFI_FILE_PROTOCOL
*Handle
,
1521 IN CONST CHAR16
*Path
1524 SHELL_COMMAND_FILE_HANDLE
*Buffer
;
1525 BUFFER_LIST
*NewNode
;
1528 Buffer
= AllocateZeroPool(sizeof(SHELL_COMMAND_FILE_HANDLE
));
1529 if (Buffer
== NULL
) {
1532 NewNode
= AllocateZeroPool(sizeof(BUFFER_LIST
));
1533 if (NewNode
== NULL
) {
1534 SHELL_FREE_NON_NULL(Buffer
);
1537 Buffer
->FileHandle
= (EFI_FILE_PROTOCOL
*)Handle
;
1538 Buffer
->Path
= StrnCatGrow(&Buffer
->Path
, NULL
, Path
, 0);
1539 if (Buffer
->Path
== NULL
) {
1540 SHELL_FREE_NON_NULL(NewNode
);
1541 SHELL_FREE_NON_NULL(Buffer
);
1544 NewNode
->Buffer
= Buffer
;
1546 InsertHeadList(&mFileHandleList
.Link
, &NewNode
->Link
);
1548 return ((SHELL_FILE_HANDLE
)(Handle
));
1552 Find the path that was logged with the specified SHELL_FILE_HANDLE.
1554 @param[in] Handle The SHELL_FILE_HANDLE to query on.
1556 @return A pointer to the path for the file.
1560 ShellFileHandleGetPath(
1561 IN CONST SHELL_FILE_HANDLE Handle
1566 for (Node
= (BUFFER_LIST
*)GetFirstNode(&mFileHandleList
.Link
)
1567 ; !IsNull(&mFileHandleList
.Link
, &Node
->Link
)
1568 ; Node
= (BUFFER_LIST
*)GetNextNode(&mFileHandleList
.Link
, &Node
->Link
)
1570 if ((Node
->Buffer
) && (((SHELL_COMMAND_FILE_HANDLE
*)Node
->Buffer
)->FileHandle
== Handle
)){
1571 return (((SHELL_COMMAND_FILE_HANDLE
*)Node
->Buffer
)->Path
);
1578 Remove a SHELL_FILE_HANDLE from the list of SHELL_FILE_HANDLES.
1580 @param[in] Handle The SHELL_FILE_HANDLE to remove.
1582 @retval TRUE The item was removed.
1583 @retval FALSE The item was not found.
1587 ShellFileHandleRemove(
1588 IN CONST SHELL_FILE_HANDLE Handle
1593 for (Node
= (BUFFER_LIST
*)GetFirstNode(&mFileHandleList
.Link
)
1594 ; !IsNull(&mFileHandleList
.Link
, &Node
->Link
)
1595 ; Node
= (BUFFER_LIST
*)GetNextNode(&mFileHandleList
.Link
, &Node
->Link
)
1597 if ((Node
->Buffer
) && (((SHELL_COMMAND_FILE_HANDLE
*)Node
->Buffer
)->FileHandle
== Handle
)){
1598 RemoveEntryList(&Node
->Link
);
1599 SHELL_FREE_NON_NULL(((SHELL_COMMAND_FILE_HANDLE
*)Node
->Buffer
)->Path
);
1600 SHELL_FREE_NON_NULL(Node
->Buffer
);
1601 SHELL_FREE_NON_NULL(Node
);
1609 Function to determine if a SHELL_FILE_HANDLE is at the end of the file.
1611 This will NOT work on directories.
1613 If Handle is NULL, then ASSERT.
1615 @param[in] Handle the file handle
1617 @retval TRUE the position is at the end of the file
1618 @retval FALSE the position is not at the end of the file
1623 IN SHELL_FILE_HANDLE Handle
1626 EFI_FILE_INFO
*Info
;
1631 // ASSERT if Handle is NULL
1633 ASSERT(Handle
!= NULL
);
1635 gEfiShellProtocol
->GetFilePosition(Handle
, &Pos
);
1636 Info
= gEfiShellProtocol
->GetFileInfo (Handle
);
1637 ASSERT(Info
!= NULL
);
1638 gEfiShellProtocol
->SetFilePosition(Handle
, Pos
);
1644 if (Pos
== Info
->FileSize
) {
1656 Frees any BUFFER_LIST defined type.
1658 @param[in] List The BUFFER_LIST object to free.
1663 IN BUFFER_LIST
*List
1666 BUFFER_LIST
*BufferListEntry
;
1672 // enumerate through the buffer list and free all memory
1674 for ( BufferListEntry
= ( BUFFER_LIST
*)GetFirstNode(&List
->Link
)
1675 ; !IsListEmpty (&List
->Link
)
1676 ; BufferListEntry
= (BUFFER_LIST
*)GetFirstNode(&List
->Link
)
1678 RemoveEntryList(&BufferListEntry
->Link
);
1679 if (BufferListEntry
->Buffer
!= NULL
) {
1680 FreePool(BufferListEntry
->Buffer
);
1682 FreePool(BufferListEntry
);