VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellCommandLib/UefiShellCommandLib.c@ 81028

最後變更 在這個檔案從81028是 80721,由 vboxsync 提交於 6 年 前

Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
  • 屬性 svn:eol-style 設為 native
檔案大小: 51.3 KB
行 
1/** @file
2 Provides interface to shell internal functions for shell commands.
3
4 Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>
5 (C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR>
6 (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
7
8 SPDX-License-Identifier: BSD-2-Clause-Patent
9
10**/
11
12#include "UefiShellCommandLib.h"
13
14// STATIC local variables
15STATIC SHELL_COMMAND_INTERNAL_LIST_ENTRY mCommandList;
16STATIC SCRIPT_FILE_LIST mScriptList;
17STATIC ALIAS_LIST mAliasList;
18STATIC BOOLEAN mEchoState;
19STATIC BOOLEAN mExitRequested;
20STATIC UINT64 mExitCode;
21STATIC BOOLEAN mExitScript;
22STATIC CHAR16 *mProfileList;
23STATIC UINTN mProfileListSize;
24STATIC UINTN mFsMaxCount = 0;
25STATIC UINTN mBlkMaxCount = 0;
26STATIC BUFFER_LIST mFileHandleList;
27
28STATIC CONST CHAR8 Hex[] = {
29 '0',
30 '1',
31 '2',
32 '3',
33 '4',
34 '5',
35 '6',
36 '7',
37 '8',
38 '9',
39 'A',
40 'B',
41 'C',
42 'D',
43 'E',
44 'F'
45};
46
47// global variables required by library class.
48EFI_UNICODE_COLLATION_PROTOCOL *gUnicodeCollation = NULL;
49SHELL_MAP_LIST gShellMapList;
50SHELL_MAP_LIST *gShellCurMapping = NULL;
51
52CONST CHAR16* SupportLevel[] = {
53 L"Minimal",
54 L"Scripting",
55 L"Basic",
56 L"Interactive"
57};
58
59/**
60 Function to make sure that the global protocol pointers are valid.
61 must be called after constructor before accessing the pointers.
62**/
63EFI_STATUS
64EFIAPI
65CommandInit(
66 VOID
67 )
68{
69 UINTN NumHandles;
70 EFI_HANDLE *Handles;
71 EFI_UNICODE_COLLATION_PROTOCOL *Uc;
72 CHAR8 *BestLanguage;
73 UINTN Index;
74 EFI_STATUS Status;
75 CHAR8 *PlatformLang;
76
77 GetEfiGlobalVariable2 (EFI_PLATFORM_LANG_VARIABLE_NAME, (VOID**)&PlatformLang, NULL);
78 if (PlatformLang == NULL) {
79 return EFI_UNSUPPORTED;
80 }
81
82 if (gUnicodeCollation == NULL) {
83 Status = gBS->LocateHandleBuffer (
84 ByProtocol,
85 &gEfiUnicodeCollation2ProtocolGuid,
86 NULL,
87 &NumHandles,
88 &Handles
89 );
90 if (EFI_ERROR (Status)) {
91 NumHandles = 0;
92 Handles = NULL;
93 }
94 for (Index = 0; Index < NumHandles; Index++) {
95 //
96 // Open Unicode Collation Protocol
97 //
98 Status = gBS->OpenProtocol (
99 Handles[Index],
100 &gEfiUnicodeCollation2ProtocolGuid,
101 (VOID **) &Uc,
102 gImageHandle,
103 NULL,
104 EFI_OPEN_PROTOCOL_GET_PROTOCOL
105 );
106 if (EFI_ERROR (Status)) {
107 continue;
108 }
109
110 //
111 // Find the best matching matching language from the supported languages
112 // of Unicode Collation2 protocol.
113 //
114 BestLanguage = GetBestLanguage (
115 Uc->SupportedLanguages,
116 FALSE,
117 PlatformLang,
118 NULL
119 );
120 if (BestLanguage != NULL) {
121 FreePool (BestLanguage);
122 gUnicodeCollation = Uc;
123 break;
124 }
125 }
126 if (Handles != NULL) {
127 FreePool (Handles);
128 }
129 FreePool (PlatformLang);
130 }
131
132 return (gUnicodeCollation == NULL) ? EFI_UNSUPPORTED : EFI_SUCCESS;
133}
134
135/**
136 Constructor for the Shell Command library.
137
138 Initialize the library and determine if the underlying is a UEFI Shell 2.0 or an EFI shell.
139
140 @param ImageHandle the image handle of the process
141 @param SystemTable the EFI System Table pointer
142
143 @retval EFI_SUCCESS the initialization was complete sucessfully
144**/
145RETURN_STATUS
146EFIAPI
147ShellCommandLibConstructor (
148 IN EFI_HANDLE ImageHandle,
149 IN EFI_SYSTEM_TABLE *SystemTable
150 )
151{
152 EFI_STATUS Status;
153 InitializeListHead(&gShellMapList.Link);
154 InitializeListHead(&mCommandList.Link);
155 InitializeListHead(&mAliasList.Link);
156 InitializeListHead(&mScriptList.Link);
157 InitializeListHead(&mFileHandleList.Link);
158 mEchoState = TRUE;
159
160 mExitRequested = FALSE;
161 mExitScript = FALSE;
162 mProfileListSize = 0;
163 mProfileList = NULL;
164
165 Status = CommandInit ();
166 if (EFI_ERROR (Status)) {
167 return EFI_DEVICE_ERROR;
168 }
169
170 return (RETURN_SUCCESS);
171}
172
173/**
174 Frees list of file handles.
175
176 @param[in] List The list to free.
177**/
178VOID
179FreeFileHandleList (
180 IN BUFFER_LIST *List
181 )
182{
183 BUFFER_LIST *BufferListEntry;
184
185 if (List == NULL){
186 return;
187 }
188 //
189 // enumerate through the buffer list and free all memory
190 //
191 for ( BufferListEntry = ( BUFFER_LIST *)GetFirstNode(&List->Link)
192 ; !IsListEmpty (&List->Link)
193 ; BufferListEntry = (BUFFER_LIST *)GetFirstNode(&List->Link)
194 ){
195 RemoveEntryList(&BufferListEntry->Link);
196 ASSERT(BufferListEntry->Buffer != NULL);
197 SHELL_FREE_NON_NULL(((SHELL_COMMAND_FILE_HANDLE*)(BufferListEntry->Buffer))->Path);
198 SHELL_FREE_NON_NULL(BufferListEntry->Buffer);
199 SHELL_FREE_NON_NULL(BufferListEntry);
200 }
201}
202
203/**
204 Destructor for the library. free any resources.
205
206 @param ImageHandle the image handle of the process
207 @param SystemTable the EFI System Table pointer
208
209 @retval RETURN_SUCCESS this function always returns success
210**/
211RETURN_STATUS
212EFIAPI
213ShellCommandLibDestructor (
214 IN EFI_HANDLE ImageHandle,
215 IN EFI_SYSTEM_TABLE *SystemTable
216 )
217{
218 SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;
219 ALIAS_LIST *Node2;
220 SCRIPT_FILE_LIST *Node3;
221 SHELL_MAP_LIST *MapNode;
222 //
223 // enumerate throught the list and free all the memory
224 //
225 while (!IsListEmpty (&mCommandList.Link)) {
226 Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode(&mCommandList.Link);
227 RemoveEntryList(&Node->Link);
228 SHELL_FREE_NON_NULL(Node->CommandString);
229 FreePool(Node);
230 DEBUG_CODE(Node = NULL;);
231 }
232
233 //
234 // enumerate through the alias list and free all memory
235 //
236 while (!IsListEmpty (&mAliasList.Link)) {
237 Node2 = (ALIAS_LIST *)GetFirstNode(&mAliasList.Link);
238 RemoveEntryList(&Node2->Link);
239 SHELL_FREE_NON_NULL(Node2->CommandString);
240 SHELL_FREE_NON_NULL(Node2->Alias);
241 SHELL_FREE_NON_NULL(Node2);
242 DEBUG_CODE(Node2 = NULL;);
243 }
244
245 //
246 // enumerate throught the list and free all the memory
247 //
248 while (!IsListEmpty (&mScriptList.Link)) {
249 Node3 = (SCRIPT_FILE_LIST *)GetFirstNode(&mScriptList.Link);
250 RemoveEntryList(&Node3->Link);
251 DeleteScriptFileStruct(Node3->Data);
252 FreePool(Node3);
253 }
254
255 //
256 // enumerate throught the mappings list and free all the memory
257 //
258 if (!IsListEmpty(&gShellMapList.Link)) {
259 for (MapNode = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
260 ; !IsListEmpty (&gShellMapList.Link)
261 ; MapNode = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
262 ){
263 ASSERT(MapNode != NULL);
264 RemoveEntryList(&MapNode->Link);
265 SHELL_FREE_NON_NULL(MapNode->DevicePath);
266 SHELL_FREE_NON_NULL(MapNode->MapName);
267 SHELL_FREE_NON_NULL(MapNode->CurrentDirectoryPath);
268 FreePool(MapNode);
269 }
270 }
271 if (!IsListEmpty(&mFileHandleList.Link)){
272 FreeFileHandleList(&mFileHandleList);
273 }
274
275 if (mProfileList != NULL) {
276 FreePool(mProfileList);
277 }
278
279 gUnicodeCollation = NULL;
280 gShellCurMapping = NULL;
281
282 return (RETURN_SUCCESS);
283}
284
285/**
286 Find a dynamic command protocol instance given a command name string.
287
288 @param CommandString the command name string
289
290 @return instance the command protocol instance, if dynamic command instance found
291 @retval NULL no dynamic command protocol instance found for name
292**/
293CONST EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL *
294ShellCommandFindDynamicCommand (
295 IN CONST CHAR16 *CommandString
296 )
297{
298 EFI_STATUS Status;
299 EFI_HANDLE *CommandHandleList;
300 EFI_HANDLE *NextCommand;
301 EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL *DynamicCommand;
302
303 CommandHandleList = GetHandleListByProtocol(&gEfiShellDynamicCommandProtocolGuid);
304 if (CommandHandleList == NULL) {
305 //
306 // not found or out of resources
307 //
308 return NULL;
309 }
310
311 for (NextCommand = CommandHandleList; *NextCommand != NULL; NextCommand++) {
312 Status = gBS->HandleProtocol(
313 *NextCommand,
314 &gEfiShellDynamicCommandProtocolGuid,
315 (VOID **)&DynamicCommand
316 );
317
318 if (EFI_ERROR(Status)) {
319 continue;
320 }
321
322 if (gUnicodeCollation->StriColl(
323 gUnicodeCollation,
324 (CHAR16*)CommandString,
325 (CHAR16*)DynamicCommand->CommandName) == 0
326 ){
327 FreePool(CommandHandleList);
328 return (DynamicCommand);
329 }
330 }
331
332 FreePool(CommandHandleList);
333 return (NULL);
334}
335
336/**
337 Checks if a command exists as a dynamic command protocol instance
338
339 @param[in] CommandString The command string to check for on the list.
340**/
341BOOLEAN
342ShellCommandDynamicCommandExists (
343 IN CONST CHAR16 *CommandString
344 )
345{
346 return (BOOLEAN) ((ShellCommandFindDynamicCommand(CommandString) != NULL));
347}
348
349/**
350 Checks if a command is already on the internal command list.
351
352 @param[in] CommandString The command string to check for on the list.
353**/
354BOOLEAN
355ShellCommandIsCommandOnInternalList(
356 IN CONST CHAR16 *CommandString
357 )
358{
359 SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;
360
361 //
362 // assert for NULL parameter
363 //
364 ASSERT(CommandString != NULL);
365
366 //
367 // check for the command
368 //
369 for ( Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode(&mCommandList.Link)
370 ; !IsNull(&mCommandList.Link, &Node->Link)
371 ; Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetNextNode(&mCommandList.Link, &Node->Link)
372 ){
373 ASSERT(Node->CommandString != NULL);
374 if (gUnicodeCollation->StriColl(
375 gUnicodeCollation,
376 (CHAR16*)CommandString,
377 Node->CommandString) == 0
378 ){
379 return (TRUE);
380 }
381 }
382 return (FALSE);
383}
384
385/**
386 Checks if a command exists, either internally or through the dynamic command protocol.
387
388 @param[in] CommandString The command string to check for on the list.
389**/
390BOOLEAN
391EFIAPI
392ShellCommandIsCommandOnList(
393 IN CONST CHAR16 *CommandString
394 )
395{
396 if (ShellCommandIsCommandOnInternalList(CommandString)) {
397 return TRUE;
398 }
399
400 return ShellCommandDynamicCommandExists(CommandString);
401}
402
403/**
404 Get the help text for a dynamic command.
405
406 @param[in] CommandString The command name.
407
408 @retval NULL No help text was found.
409 @return String of help text. Caller required to free.
410**/
411CHAR16*
412ShellCommandGetDynamicCommandHelp(
413 IN CONST CHAR16 *CommandString
414 )
415{
416 EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL *DynamicCommand;
417
418 DynamicCommand = (EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL *)ShellCommandFindDynamicCommand(CommandString);
419 if (DynamicCommand == NULL) {
420 return (NULL);
421 }
422
423 //
424 // TODO: how to get proper language?
425 //
426 return DynamicCommand->GetHelp(DynamicCommand, "en");
427}
428
429/**
430 Get the help text for an internal command.
431
432 @param[in] CommandString The command name.
433
434 @retval NULL No help text was found.
435 @return String of help text. Caller reuiqred to free.
436**/
437CHAR16*
438ShellCommandGetInternalCommandHelp(
439 IN CONST CHAR16 *CommandString
440 )
441{
442 SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;
443
444 //
445 // assert for NULL parameter
446 //
447 ASSERT(CommandString != NULL);
448
449 //
450 // check for the command
451 //
452 for ( Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode(&mCommandList.Link)
453 ; !IsNull(&mCommandList.Link, &Node->Link)
454 ; Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetNextNode(&mCommandList.Link, &Node->Link)
455 ){
456 ASSERT(Node->CommandString != NULL);
457 if (gUnicodeCollation->StriColl(
458 gUnicodeCollation,
459 (CHAR16*)CommandString,
460 Node->CommandString) == 0
461 ){
462 return (HiiGetString(Node->HiiHandle, Node->ManFormatHelp, NULL));
463 }
464 }
465 return (NULL);
466}
467
468/**
469 Get the help text for a command.
470
471 @param[in] CommandString The command name.
472
473 @retval NULL No help text was found.
474 @return String of help text.Caller reuiqred to free.
475**/
476CHAR16*
477EFIAPI
478ShellCommandGetCommandHelp (
479 IN CONST CHAR16 *CommandString
480 )
481{
482 CHAR16 *HelpStr;
483 HelpStr = ShellCommandGetInternalCommandHelp(CommandString);
484
485 if (HelpStr == NULL) {
486 HelpStr = ShellCommandGetDynamicCommandHelp(CommandString);
487 }
488
489 return HelpStr;
490}
491
492
493/**
494 Registers handlers of type SHELL_RUN_COMMAND and
495 SHELL_GET_MAN_FILENAME for each shell command.
496
497 If the ShellSupportLevel is greater than the value of the
498 PcdShellSupportLevel then return RETURN_UNSUPPORTED.
499
500 Registers the handlers specified by GetHelpInfoHandler and CommandHandler
501 with the command specified by CommandString. If the command named by
502 CommandString has already been registered, then return
503 RETURN_ALREADY_STARTED.
504
505 If there are not enough resources available to register the handlers then
506 RETURN_OUT_OF_RESOURCES is returned.
507
508 If CommandString is NULL, then ASSERT().
509 If GetHelpInfoHandler is NULL, then ASSERT().
510 If CommandHandler is NULL, then ASSERT().
511 If ProfileName is NULL, then ASSERT().
512
513 @param[in] CommandString Pointer to the command name. This is the
514 name to look for on the command line in
515 the shell.
516 @param[in] CommandHandler Pointer to a function that runs the
517 specified command.
518 @param[in] GetManFileName Pointer to a function that provides man
519 filename.
520 @param[in] ShellMinSupportLevel minimum Shell Support Level which has this
521 function.
522 @param[in] ProfileName profile name to require for support of this
523 function.
524 @param[in] CanAffectLE indicates whether this command's return value
525 can change the LASTERROR environment variable.
526 @param[in] HiiHandle Handle of this command's HII entry.
527 @param[in] ManFormatHelp HII locator for the help text.
528
529 @retval RETURN_SUCCESS The handlers were registered.
530 @retval RETURN_OUT_OF_RESOURCES There are not enough resources available to
531 register the shell command.
532 @retval RETURN_UNSUPPORTED the ShellMinSupportLevel was higher than the
533 currently allowed support level.
534 @retval RETURN_ALREADY_STARTED The CommandString represents a command that
535 is already registered. Only 1 handler set for
536 a given command is allowed.
537 @sa SHELL_GET_MAN_FILENAME
538 @sa SHELL_RUN_COMMAND
539**/
540RETURN_STATUS
541EFIAPI
542ShellCommandRegisterCommandName (
543 IN CONST CHAR16 *CommandString,
544 IN SHELL_RUN_COMMAND CommandHandler,
545 IN SHELL_GET_MAN_FILENAME GetManFileName,
546 IN UINT32 ShellMinSupportLevel,
547 IN CONST CHAR16 *ProfileName,
548 IN CONST BOOLEAN CanAffectLE,
549 IN CONST EFI_HANDLE HiiHandle,
550 IN CONST EFI_STRING_ID ManFormatHelp
551 )
552{
553 SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;
554 SHELL_COMMAND_INTERNAL_LIST_ENTRY *Command;
555 SHELL_COMMAND_INTERNAL_LIST_ENTRY *PrevCommand;
556 INTN LexicalMatchValue;
557
558 //
559 // Initialize local variables.
560 //
561 Command = NULL;
562 PrevCommand = NULL;
563 LexicalMatchValue = 0;
564
565 //
566 // ASSERTs for NULL parameters
567 //
568 ASSERT(CommandString != NULL);
569 ASSERT(GetManFileName != NULL);
570 ASSERT(CommandHandler != NULL);
571 ASSERT(ProfileName != NULL);
572
573 //
574 // check for shell support level
575 //
576 if (PcdGet8(PcdShellSupportLevel) < ShellMinSupportLevel) {
577 return (RETURN_UNSUPPORTED);
578 }
579
580 //
581 // check for already on the list
582 //
583 if (ShellCommandIsCommandOnList(CommandString)) {
584 return (RETURN_ALREADY_STARTED);
585 }
586
587 //
588 // allocate memory for new struct
589 //
590 Node = AllocateZeroPool(sizeof(SHELL_COMMAND_INTERNAL_LIST_ENTRY));
591 if (Node == NULL) {
592 return RETURN_OUT_OF_RESOURCES;
593 }
594 Node->CommandString = AllocateCopyPool(StrSize(CommandString), CommandString);
595 if (Node->CommandString == NULL) {
596 FreePool (Node);
597 return RETURN_OUT_OF_RESOURCES;
598 }
599
600 Node->GetManFileName = GetManFileName;
601 Node->CommandHandler = CommandHandler;
602 Node->LastError = CanAffectLE;
603 Node->HiiHandle = HiiHandle;
604 Node->ManFormatHelp = ManFormatHelp;
605
606 if ( StrLen(ProfileName)>0
607 && ((mProfileList != NULL
608 && StrStr(mProfileList, ProfileName) == NULL) || mProfileList == NULL)
609 ){
610 ASSERT((mProfileList == NULL && mProfileListSize == 0) || (mProfileList != NULL));
611 if (mProfileList == NULL) {
612 //
613 // If this is the first make a leading ';'
614 //
615 StrnCatGrow(&mProfileList, &mProfileListSize, L";", 0);
616 }
617 StrnCatGrow(&mProfileList, &mProfileListSize, ProfileName, 0);
618 StrnCatGrow(&mProfileList, &mProfileListSize, L";", 0);
619 }
620
621 //
622 // Insert a new entry on top of the list
623 //
624 InsertHeadList (&mCommandList.Link, &Node->Link);
625
626 //
627 // Move a new registered command to its sorted ordered location in the list
628 //
629 for (Command = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode (&mCommandList.Link),
630 PrevCommand = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode (&mCommandList.Link)
631 ; !IsNull (&mCommandList.Link, &Command->Link)
632 ; Command = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetNextNode (&mCommandList.Link, &Command->Link)) {
633
634 //
635 // Get Lexical Comparison Value between PrevCommand and Command list entry
636 //
637 LexicalMatchValue = gUnicodeCollation->StriColl (
638 gUnicodeCollation,
639 PrevCommand->CommandString,
640 Command->CommandString
641 );
642
643 //
644 // Swap PrevCommand and Command list entry if PrevCommand list entry
645 // is alphabetically greater than Command list entry
646 //
647 if (LexicalMatchValue > 0){
648 Command = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *) SwapListEntries (&PrevCommand->Link, &Command->Link);
649 } else if (LexicalMatchValue < 0) {
650 //
651 // PrevCommand entry is lexically lower than Command entry
652 //
653 break;
654 }
655 }
656
657 return (RETURN_SUCCESS);
658}
659
660/**
661 Function to get the current Profile string.
662
663 @retval NULL There are no installed profiles.
664 @return A semi-colon delimited list of profiles.
665**/
666CONST CHAR16 *
667EFIAPI
668ShellCommandGetProfileList (
669 VOID
670 )
671{
672 return (mProfileList);
673}
674
675/**
676 Checks if a command string has been registered for CommandString and if so it runs
677 the previously registered handler for that command with the command line.
678
679 If CommandString is NULL, then ASSERT().
680
681 If Sections is specified, then each section name listed will be compared in a casesensitive
682 manner, to the section names described in Appendix B UEFI Shell 2.0 spec. If the section exists,
683 it will be appended to the returned help text. If the section does not exist, no
684 information will be returned. If Sections is NULL, then all help text information
685 available will be returned.
686
687 @param[in] CommandString Pointer to the command name. This is the name
688 found on the command line in the shell.
689 @param[in, out] RetVal Pointer to the return vaule from the command handler.
690
691 @param[in, out] CanAffectLE indicates whether this command's return value
692 needs to be placed into LASTERROR environment variable.
693
694 @retval RETURN_SUCCESS The handler was run.
695 @retval RETURN_NOT_FOUND The CommandString did not match a registered
696 command name.
697 @sa SHELL_RUN_COMMAND
698**/
699RETURN_STATUS
700EFIAPI
701ShellCommandRunCommandHandler (
702 IN CONST CHAR16 *CommandString,
703 IN OUT SHELL_STATUS *RetVal,
704 IN OUT BOOLEAN *CanAffectLE OPTIONAL
705 )
706{
707 SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;
708 EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL *DynamicCommand;
709
710 //
711 // assert for NULL parameters
712 //
713 ASSERT(CommandString != NULL);
714
715 //
716 // check for the command
717 //
718 for ( Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode(&mCommandList.Link)
719 ; !IsNull(&mCommandList.Link, &Node->Link)
720 ; Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetNextNode(&mCommandList.Link, &Node->Link)
721 ){
722 ASSERT(Node->CommandString != NULL);
723 if (gUnicodeCollation->StriColl(
724 gUnicodeCollation,
725 (CHAR16*)CommandString,
726 Node->CommandString) == 0
727 ){
728 if (CanAffectLE != NULL) {
729 *CanAffectLE = Node->LastError;
730 }
731 if (RetVal != NULL) {
732 *RetVal = Node->CommandHandler(NULL, gST);
733 } else {
734 Node->CommandHandler(NULL, gST);
735 }
736 return (RETURN_SUCCESS);
737 }
738 }
739
740 //
741 // An internal command was not found, try to find a dynamic command
742 //
743 DynamicCommand = (EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL *)ShellCommandFindDynamicCommand(CommandString);
744 if (DynamicCommand != NULL) {
745 if (RetVal != NULL) {
746 *RetVal = DynamicCommand->Handler(DynamicCommand, gST, gEfiShellParametersProtocol, gEfiShellProtocol);
747 } else {
748 DynamicCommand->Handler(DynamicCommand, gST, gEfiShellParametersProtocol, gEfiShellProtocol);
749 }
750 return (RETURN_SUCCESS);
751 }
752
753 return (RETURN_NOT_FOUND);
754}
755
756/**
757 Checks if a command string has been registered for CommandString and if so it
758 returns the MAN filename specified for that command.
759
760 If CommandString is NULL, then ASSERT().
761
762 @param[in] CommandString Pointer to the command name. This is the name
763 found on the command line in the shell.\
764
765 @retval NULL the commandString was not a registered command.
766 @return other the name of the MAN file.
767 @sa SHELL_GET_MAN_FILENAME
768**/
769CONST CHAR16*
770EFIAPI
771ShellCommandGetManFileNameHandler (
772 IN CONST CHAR16 *CommandString
773 )
774{
775 SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;
776
777 //
778 // assert for NULL parameters
779 //
780 ASSERT(CommandString != NULL);
781
782 //
783 // check for the command
784 //
785 for ( Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode(&mCommandList.Link)
786 ; !IsNull(&mCommandList.Link, &Node->Link)
787 ; Node = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetNextNode(&mCommandList.Link, &Node->Link)
788 ){
789 ASSERT(Node->CommandString != NULL);
790 if (gUnicodeCollation->StriColl(
791 gUnicodeCollation,
792 (CHAR16*)CommandString,
793 Node->CommandString) == 0
794 ){
795 return (Node->GetManFileName());
796 }
797 }
798 return (NULL);
799}
800
801/**
802 Get the list of all available shell internal commands. This is a linked list
803 (via LIST_ENTRY structure). enumerate through it using the BaseLib linked
804 list functions. do not modify the values.
805
806 @param[in] Sort TRUE to alphabetically sort the values first. FALSE otherwise.
807
808 @return a Linked list of all available shell commands.
809**/
810CONST COMMAND_LIST*
811EFIAPI
812ShellCommandGetCommandList (
813 IN CONST BOOLEAN Sort
814 )
815{
816// if (!Sort) {
817// return ((COMMAND_LIST*)(&mCommandList));
818// }
819 return ((COMMAND_LIST*)(&mCommandList));
820}
821
822/**
823 Registers aliases to be set as part of the initialization of the shell application.
824
825 If Command is NULL, then ASSERT().
826 If Alias is NULL, then ASSERT().
827
828 @param[in] Command Pointer to the Command
829 @param[in] Alias Pointer to Alias
830
831 @retval RETURN_SUCCESS The handlers were registered.
832 @retval RETURN_OUT_OF_RESOURCES There are not enough resources available to
833 register the shell command.
834**/
835RETURN_STATUS
836EFIAPI
837ShellCommandRegisterAlias (
838 IN CONST CHAR16 *Command,
839 IN CONST CHAR16 *Alias
840 )
841{
842 ALIAS_LIST *Node;
843 ALIAS_LIST *CommandAlias;
844 ALIAS_LIST *PrevCommandAlias;
845 INTN LexicalMatchValue;
846
847 //
848 // Asserts for NULL
849 //
850 ASSERT(Command != NULL);
851 ASSERT(Alias != NULL);
852
853 //
854 // allocate memory for new struct
855 //
856 Node = AllocateZeroPool(sizeof(ALIAS_LIST));
857 if (Node == NULL) {
858 return RETURN_OUT_OF_RESOURCES;
859 }
860 Node->CommandString = AllocateCopyPool(StrSize(Command), Command);
861 if (Node->CommandString == NULL) {
862 FreePool (Node);
863 return RETURN_OUT_OF_RESOURCES;
864 }
865 Node->Alias = AllocateCopyPool(StrSize(Alias), Alias);
866 if (Node->Alias == NULL) {
867 FreePool (Node->CommandString);
868 FreePool (Node);
869 return RETURN_OUT_OF_RESOURCES;
870 }
871
872 InsertHeadList (&mAliasList.Link, &Node->Link);
873
874 //
875 // Move a new pre-defined registered alias to its sorted ordered location in the list
876 //
877 for ( CommandAlias = (ALIAS_LIST *)GetFirstNode (&mAliasList.Link),
878 PrevCommandAlias = (ALIAS_LIST *)GetFirstNode (&mAliasList.Link)
879 ; !IsNull (&mAliasList.Link, &CommandAlias->Link)
880 ; CommandAlias = (ALIAS_LIST *) GetNextNode (&mAliasList.Link, &CommandAlias->Link) ) {
881 //
882 // Get Lexical comparison value between PrevCommandAlias and CommandAlias List Entry
883 //
884 LexicalMatchValue = gUnicodeCollation->StriColl (
885 gUnicodeCollation,
886 PrevCommandAlias->Alias,
887 CommandAlias->Alias
888 );
889
890 //
891 // Swap PrevCommandAlias and CommandAlias list entry if PrevCommandAlias list entry
892 // is alphabetically greater than CommandAlias list entry
893 //
894 if (LexicalMatchValue > 0) {
895 CommandAlias = (ALIAS_LIST *) SwapListEntries (&PrevCommandAlias->Link, &CommandAlias->Link);
896 } else if (LexicalMatchValue < 0) {
897 //
898 // PrevCommandAlias entry is lexically lower than CommandAlias entry
899 //
900 break;
901 }
902 }
903
904 return (RETURN_SUCCESS);
905}
906
907/**
908 Get the list of all shell alias commands. This is a linked list
909 (via LIST_ENTRY structure). enumerate through it using the BaseLib linked
910 list functions. do not modify the values.
911
912 @return a Linked list of all requested shell alias'.
913**/
914CONST ALIAS_LIST*
915EFIAPI
916ShellCommandGetInitAliasList (
917 VOID
918 )
919{
920 return (&mAliasList);
921}
922
923/**
924 Determine if a given alias is on the list of built in alias'.
925
926 @param[in] Alias The alias to test for
927
928 @retval TRUE The alias is a built in alias
929 @retval FALSE The alias is not a built in alias
930**/
931BOOLEAN
932EFIAPI
933ShellCommandIsOnAliasList(
934 IN CONST CHAR16 *Alias
935 )
936{
937 ALIAS_LIST *Node;
938
939 //
940 // assert for NULL parameter
941 //
942 ASSERT(Alias != NULL);
943
944 //
945 // check for the Alias
946 //
947 for ( Node = (ALIAS_LIST *)GetFirstNode(&mAliasList.Link)
948 ; !IsNull(&mAliasList.Link, &Node->Link)
949 ; Node = (ALIAS_LIST *)GetNextNode(&mAliasList.Link, &Node->Link)
950 ){
951 ASSERT(Node->CommandString != NULL);
952 ASSERT(Node->Alias != NULL);
953 if (gUnicodeCollation->StriColl(
954 gUnicodeCollation,
955 (CHAR16*)Alias,
956 Node->CommandString) == 0
957 ){
958 return (TRUE);
959 }
960 if (gUnicodeCollation->StriColl(
961 gUnicodeCollation,
962 (CHAR16*)Alias,
963 Node->Alias) == 0
964 ){
965 return (TRUE);
966 }
967 }
968 return (FALSE);
969}
970
971/**
972 Function to determine current state of ECHO. Echo determines if lines from scripts
973 and ECHO commands are enabled.
974
975 @retval TRUE Echo is currently enabled
976 @retval FALSE Echo is currently disabled
977**/
978BOOLEAN
979EFIAPI
980ShellCommandGetEchoState(
981 VOID
982 )
983{
984 return (mEchoState);
985}
986
987/**
988 Function to set current state of ECHO. Echo determines if lines from scripts
989 and ECHO commands are enabled.
990
991 If State is TRUE, Echo will be enabled.
992 If State is FALSE, Echo will be disabled.
993
994 @param[in] State How to set echo.
995**/
996VOID
997EFIAPI
998ShellCommandSetEchoState(
999 IN BOOLEAN State
1000 )
1001{
1002 mEchoState = State;
1003}
1004
1005/**
1006 Indicate that the current shell or script should exit.
1007
1008 @param[in] ScriptOnly TRUE if exiting a script; FALSE otherwise.
1009 @param[in] ErrorCode The 64 bit error code to return.
1010**/
1011VOID
1012EFIAPI
1013ShellCommandRegisterExit (
1014 IN BOOLEAN ScriptOnly,
1015 IN CONST UINT64 ErrorCode
1016 )
1017{
1018 mExitRequested = (BOOLEAN)(!mExitRequested);
1019 if (mExitRequested) {
1020 mExitScript = ScriptOnly;
1021 } else {
1022 mExitScript = FALSE;
1023 }
1024 mExitCode = ErrorCode;
1025}
1026
1027/**
1028 Retrieve the Exit indicator.
1029
1030 @retval TRUE Exit was indicated.
1031 @retval FALSE Exis was not indicated.
1032**/
1033BOOLEAN
1034EFIAPI
1035ShellCommandGetExit (
1036 VOID
1037 )
1038{
1039 return (mExitRequested);
1040}
1041
1042/**
1043 Retrieve the Exit code.
1044
1045 If ShellCommandGetExit returns FALSE than the return from this is undefined.
1046
1047 @return the value passed into RegisterExit.
1048**/
1049UINT64
1050EFIAPI
1051ShellCommandGetExitCode (
1052 VOID
1053 )
1054{
1055 return (mExitCode);
1056}
1057/**
1058 Retrieve the Exit script indicator.
1059
1060 If ShellCommandGetExit returns FALSE than the return from this is undefined.
1061
1062 @retval TRUE ScriptOnly was indicated.
1063 @retval FALSE ScriptOnly was not indicated.
1064**/
1065BOOLEAN
1066EFIAPI
1067ShellCommandGetScriptExit (
1068 VOID
1069 )
1070{
1071 return (mExitScript);
1072}
1073
1074/**
1075 Function to cleanup all memory from a SCRIPT_FILE structure.
1076
1077 @param[in] Script The pointer to the structure to cleanup.
1078**/
1079VOID
1080EFIAPI
1081DeleteScriptFileStruct (
1082 IN SCRIPT_FILE *Script
1083 )
1084{
1085 UINT8 LoopVar;
1086
1087 if (Script == NULL) {
1088 return;
1089 }
1090
1091 for (LoopVar = 0 ; LoopVar < Script->Argc ; LoopVar++) {
1092 SHELL_FREE_NON_NULL(Script->Argv[LoopVar]);
1093 }
1094 if (Script->Argv != NULL) {
1095 SHELL_FREE_NON_NULL(Script->Argv);
1096 }
1097 Script->CurrentCommand = NULL;
1098 while (!IsListEmpty (&Script->CommandList)) {
1099 Script->CurrentCommand = (SCRIPT_COMMAND_LIST *)GetFirstNode(&Script->CommandList);
1100 if (Script->CurrentCommand != NULL) {
1101 RemoveEntryList(&Script->CurrentCommand->Link);
1102 if (Script->CurrentCommand->Cl != NULL) {
1103 SHELL_FREE_NON_NULL(Script->CurrentCommand->Cl);
1104 }
1105 if (Script->CurrentCommand->Data != NULL) {
1106 SHELL_FREE_NON_NULL(Script->CurrentCommand->Data);
1107 }
1108 SHELL_FREE_NON_NULL(Script->CurrentCommand);
1109 }
1110 }
1111 SHELL_FREE_NON_NULL(Script->ScriptName);
1112 SHELL_FREE_NON_NULL(Script);
1113}
1114
1115/**
1116 Function to return a pointer to the currently running script file object.
1117
1118 @retval NULL A script file is not currently running.
1119 @return A pointer to the current script file object.
1120**/
1121SCRIPT_FILE*
1122EFIAPI
1123ShellCommandGetCurrentScriptFile (
1124 VOID
1125 )
1126{
1127 SCRIPT_FILE_LIST *List;
1128 if (IsListEmpty (&mScriptList.Link)) {
1129 return (NULL);
1130 }
1131 List = ((SCRIPT_FILE_LIST*)GetFirstNode(&mScriptList.Link));
1132 return (List->Data);
1133}
1134
1135/**
1136 Function to set a new script as the currently running one.
1137
1138 This function will correctly stack and unstack nested scripts.
1139
1140 @param[in] Script Pointer to new script information structure. if NULL
1141 will remove and de-allocate the top-most Script structure.
1142
1143 @return A pointer to the current running script file after this
1144 change. NULL if removing the final script.
1145**/
1146SCRIPT_FILE*
1147EFIAPI
1148ShellCommandSetNewScript (
1149 IN SCRIPT_FILE *Script OPTIONAL
1150 )
1151{
1152 SCRIPT_FILE_LIST *Node;
1153 if (Script == NULL) {
1154 if (IsListEmpty (&mScriptList.Link)) {
1155 return (NULL);
1156 }
1157 Node = (SCRIPT_FILE_LIST *)GetFirstNode(&mScriptList.Link);
1158 RemoveEntryList(&Node->Link);
1159 DeleteScriptFileStruct(Node->Data);
1160 FreePool(Node);
1161 } else {
1162 Node = AllocateZeroPool(sizeof(SCRIPT_FILE_LIST));
1163 if (Node == NULL) {
1164 return (NULL);
1165 }
1166 Node->Data = Script;
1167 InsertHeadList(&mScriptList.Link, &Node->Link);
1168 }
1169 return (ShellCommandGetCurrentScriptFile());
1170}
1171
1172/**
1173 Function to generate the next default mapping name.
1174
1175 If the return value is not NULL then it must be callee freed.
1176
1177 @param Type What kind of mapping name to make.
1178
1179 @retval NULL a memory allocation failed.
1180 @return a new map name string
1181**/
1182CHAR16*
1183EFIAPI
1184ShellCommandCreateNewMappingName(
1185 IN CONST SHELL_MAPPING_TYPE Type
1186 )
1187{
1188 CHAR16 *String;
1189 ASSERT(Type < MappingTypeMax);
1190
1191 String = NULL;
1192
1193 String = AllocateZeroPool(PcdGet8(PcdShellMapNameLength) * sizeof(String[0]));
1194 UnicodeSPrint(
1195 String,
1196 PcdGet8(PcdShellMapNameLength) * sizeof(String[0]),
1197 Type == MappingTypeFileSystem?L"FS%d:":L"BLK%d:",
1198 Type == MappingTypeFileSystem?mFsMaxCount++:mBlkMaxCount++);
1199
1200 return (String);
1201}
1202
1203/**
1204 Function to add a map node to the list of map items and update the "path" environment variable (optionally).
1205
1206 If Path is TRUE (during initialization only), the path environment variable will also be updated to include
1207 default paths on the new map name...
1208
1209 Path should be FALSE when this function is called from the protocol SetMap function.
1210
1211 @param[in] Name The human readable mapped name.
1212 @param[in] DevicePath The Device Path for this map.
1213 @param[in] Flags The Flags attribute for this map item.
1214 @param[in] Path TRUE to update path, FALSE to skip this step (should only be TRUE during initialization).
1215
1216 @retval EFI_SUCCESS The addition was sucessful.
1217 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
1218 @retval EFI_INVALID_PARAMETER A parameter was invalid.
1219**/
1220EFI_STATUS
1221EFIAPI
1222ShellCommandAddMapItemAndUpdatePath(
1223 IN CONST CHAR16 *Name,
1224 IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
1225 IN CONST UINT64 Flags,
1226 IN CONST BOOLEAN Path
1227 )
1228{
1229 EFI_STATUS Status;
1230 SHELL_MAP_LIST *MapListNode;
1231 CONST CHAR16 *OriginalPath;
1232 CHAR16 *NewPath;
1233 UINTN NewPathSize;
1234
1235 NewPathSize = 0;
1236 NewPath = NULL;
1237 OriginalPath = NULL;
1238 Status = EFI_SUCCESS;
1239
1240 MapListNode = AllocateZeroPool(sizeof(SHELL_MAP_LIST));
1241 if (MapListNode == NULL) {
1242 Status = EFI_OUT_OF_RESOURCES;
1243 } else {
1244 MapListNode->Flags = Flags;
1245 MapListNode->MapName = AllocateCopyPool(StrSize(Name), Name);
1246 MapListNode->DevicePath = DuplicateDevicePath(DevicePath);
1247 if ((MapListNode->MapName == NULL) || (MapListNode->DevicePath == NULL)){
1248 Status = EFI_OUT_OF_RESOURCES;
1249 } else {
1250 InsertTailList(&gShellMapList.Link, &MapListNode->Link);
1251 }
1252 }
1253 if (EFI_ERROR(Status)) {
1254 if (MapListNode != NULL) {
1255 if (MapListNode->DevicePath != NULL) {
1256 FreePool(MapListNode->DevicePath);
1257 }
1258 if (MapListNode->MapName != NULL) {
1259 FreePool(MapListNode->MapName);
1260 }
1261 FreePool(MapListNode);
1262 }
1263 } else if (Path) {
1264 //
1265 // Since there was no error and Path was TRUE
1266 // Now add the correct path for that mapping
1267 //
1268 OriginalPath = gEfiShellProtocol->GetEnv(L"path");
1269 ASSERT((NewPath == NULL && NewPathSize == 0) || (NewPath != NULL));
1270 if (OriginalPath != NULL) {
1271 StrnCatGrow(&NewPath, &NewPathSize, OriginalPath, 0);
1272 StrnCatGrow(&NewPath, &NewPathSize, L";", 0);
1273 }
1274 StrnCatGrow(&NewPath, &NewPathSize, Name, 0);
1275 StrnCatGrow(&NewPath, &NewPathSize, L"\\efi\\tools\\;", 0);
1276 StrnCatGrow(&NewPath, &NewPathSize, Name, 0);
1277 StrnCatGrow(&NewPath, &NewPathSize, L"\\efi\\boot\\;", 0);
1278 StrnCatGrow(&NewPath, &NewPathSize, Name, 0);
1279 StrnCatGrow(&NewPath, &NewPathSize, L"\\", 0);
1280
1281 Status = gEfiShellProtocol->SetEnv(L"path", NewPath, TRUE);
1282 ASSERT_EFI_ERROR(Status);
1283 FreePool(NewPath);
1284 }
1285 return (Status);
1286}
1287
1288/**
1289 Creates the default map names for each device path in the system with
1290 a protocol depending on the Type.
1291
1292 Creates the consistent map names for each device path in the system with
1293 a protocol depending on the Type.
1294
1295 Note: This will reset all mappings in the system("map -r").
1296
1297 Also sets up the default path environment variable if Type is FileSystem.
1298
1299 @retval EFI_SUCCESS All map names were created sucessfully.
1300 @retval EFI_NOT_FOUND No protocols were found in the system.
1301 @return Error returned from gBS->LocateHandle().
1302
1303 @sa LocateHandle
1304**/
1305EFI_STATUS
1306EFIAPI
1307ShellCommandCreateInitialMappingsAndPaths(
1308 VOID
1309 )
1310{
1311 EFI_STATUS Status;
1312 EFI_HANDLE *HandleList;
1313 UINTN Count;
1314 EFI_DEVICE_PATH_PROTOCOL **DevicePathList;
1315 CHAR16 *NewDefaultName;
1316 CHAR16 *NewConsistName;
1317 EFI_DEVICE_PATH_PROTOCOL **ConsistMappingTable;
1318 SHELL_MAP_LIST *MapListNode;
1319 CONST CHAR16 *CurDir;
1320 CHAR16 *SplitCurDir;
1321 CHAR16 *MapName;
1322 SHELL_MAP_LIST *MapListItem;
1323
1324 SplitCurDir = NULL;
1325 MapName = NULL;
1326 MapListItem = NULL;
1327 HandleList = NULL;
1328
1329 //
1330 // Reset the static members back to zero
1331 //
1332 mFsMaxCount = 0;
1333 mBlkMaxCount = 0;
1334
1335 gEfiShellProtocol->SetEnv(L"path", L"", TRUE);
1336
1337 //
1338 // First empty out the existing list.
1339 //
1340 if (!IsListEmpty(&gShellMapList.Link)) {
1341 for ( MapListNode = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
1342 ; !IsListEmpty(&gShellMapList.Link)
1343 ; MapListNode = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
1344 ){
1345 RemoveEntryList(&MapListNode->Link);
1346 SHELL_FREE_NON_NULL(MapListNode->DevicePath);
1347 SHELL_FREE_NON_NULL(MapListNode->MapName);
1348 SHELL_FREE_NON_NULL(MapListNode->CurrentDirectoryPath);
1349 FreePool(MapListNode);
1350 } // for loop
1351 }
1352
1353 //
1354 // Find each handle with Simple File System
1355 //
1356 HandleList = GetHandleListByProtocol(&gEfiSimpleFileSystemProtocolGuid);
1357 if (HandleList != NULL) {
1358 //
1359 // Do a count of the handles
1360 //
1361 for (Count = 0 ; HandleList[Count] != NULL ; Count++);
1362
1363 //
1364 // Get all Device Paths
1365 //
1366 DevicePathList = AllocateZeroPool(sizeof(EFI_DEVICE_PATH_PROTOCOL*) * Count);
1367 if (DevicePathList == NULL) {
1368 SHELL_FREE_NON_NULL (HandleList);
1369 return EFI_OUT_OF_RESOURCES;
1370 }
1371
1372 for (Count = 0 ; HandleList[Count] != NULL ; Count++) {
1373 DevicePathList[Count] = DevicePathFromHandle(HandleList[Count]);
1374 }
1375
1376 //
1377 // Sort all DevicePaths
1378 //
1379 PerformQuickSort(DevicePathList, Count, sizeof(EFI_DEVICE_PATH_PROTOCOL*), DevicePathCompare);
1380
1381 ShellCommandConsistMappingInitialize(&ConsistMappingTable);
1382 //
1383 // Assign new Mappings to all...
1384 //
1385 for (Count = 0 ; HandleList[Count] != NULL ; Count++) {
1386 //
1387 // Get default name first
1388 //
1389 NewDefaultName = ShellCommandCreateNewMappingName(MappingTypeFileSystem);
1390 ASSERT(NewDefaultName != NULL);
1391 Status = ShellCommandAddMapItemAndUpdatePath(NewDefaultName, DevicePathList[Count], 0, TRUE);
1392 ASSERT_EFI_ERROR(Status);
1393 FreePool(NewDefaultName);
1394
1395 //
1396 // Now do consistent name
1397 //
1398 NewConsistName = ShellCommandConsistMappingGenMappingName(DevicePathList[Count], ConsistMappingTable);
1399 if (NewConsistName != NULL) {
1400 Status = ShellCommandAddMapItemAndUpdatePath(NewConsistName, DevicePathList[Count], 0, FALSE);
1401 ASSERT_EFI_ERROR(Status);
1402 FreePool(NewConsistName);
1403 }
1404 }
1405
1406 ShellCommandConsistMappingUnInitialize(ConsistMappingTable);
1407
1408 SHELL_FREE_NON_NULL(HandleList);
1409 SHELL_FREE_NON_NULL(DevicePathList);
1410
1411 HandleList = NULL;
1412
1413 //
1414 //gShellCurMapping point to node of current file system in the gShellMapList. When reset all mappings,
1415 //all nodes in the gShellMapList will be free. Then gShellCurMapping will be a dangling pointer, So,
1416 //after created new mappings, we should reset the gShellCurMapping pointer back to node of current file system.
1417 //
1418 if (gShellCurMapping != NULL) {
1419 gShellCurMapping = NULL;
1420 CurDir = gEfiShellProtocol->GetEnv(L"cwd");
1421 if (CurDir != NULL) {
1422 MapName = AllocateCopyPool (StrSize(CurDir), CurDir);
1423 if (MapName == NULL) {
1424 return EFI_OUT_OF_RESOURCES;
1425 }
1426 SplitCurDir = StrStr (MapName, L":");
1427 if (SplitCurDir == NULL) {
1428 SHELL_FREE_NON_NULL (MapName);
1429 return EFI_UNSUPPORTED;
1430 }
1431 *(SplitCurDir + 1) = CHAR_NULL;
1432 MapListItem = ShellCommandFindMapItem (MapName);
1433 if (MapListItem != NULL) {
1434 gShellCurMapping = MapListItem;
1435 }
1436 SHELL_FREE_NON_NULL (MapName);
1437 }
1438 }
1439 } else {
1440 Count = (UINTN)-1;
1441 }
1442
1443 //
1444 // Find each handle with Block Io
1445 //
1446 HandleList = GetHandleListByProtocol(&gEfiBlockIoProtocolGuid);
1447 if (HandleList != NULL) {
1448 for (Count = 0 ; HandleList[Count] != NULL ; Count++);
1449
1450 //
1451 // Get all Device Paths
1452 //
1453 DevicePathList = AllocateZeroPool(sizeof(EFI_DEVICE_PATH_PROTOCOL*) * Count);
1454 if (DevicePathList == NULL) {
1455 SHELL_FREE_NON_NULL (HandleList);
1456 return EFI_OUT_OF_RESOURCES;
1457 }
1458
1459 for (Count = 0 ; HandleList[Count] != NULL ; Count++) {
1460 DevicePathList[Count] = DevicePathFromHandle(HandleList[Count]);
1461 }
1462
1463 //
1464 // Sort all DevicePaths
1465 //
1466 PerformQuickSort(DevicePathList, Count, sizeof(EFI_DEVICE_PATH_PROTOCOL*), DevicePathCompare);
1467
1468 //
1469 // Assign new Mappings to all...
1470 //
1471 for (Count = 0 ; HandleList[Count] != NULL ; Count++) {
1472 //
1473 // Get default name first
1474 //
1475 NewDefaultName = ShellCommandCreateNewMappingName(MappingTypeBlockIo);
1476 ASSERT(NewDefaultName != NULL);
1477 Status = ShellCommandAddMapItemAndUpdatePath(NewDefaultName, DevicePathList[Count], 0, FALSE);
1478 ASSERT_EFI_ERROR(Status);
1479 FreePool(NewDefaultName);
1480 }
1481
1482 SHELL_FREE_NON_NULL(HandleList);
1483 SHELL_FREE_NON_NULL(DevicePathList);
1484 } else if (Count == (UINTN)-1) {
1485 return (EFI_NOT_FOUND);
1486 }
1487
1488 return (EFI_SUCCESS);
1489}
1490
1491/**
1492 Add mappings for any devices without one. Do not change any existing maps.
1493
1494 @retval EFI_SUCCESS The operation was successful.
1495**/
1496EFI_STATUS
1497EFIAPI
1498ShellCommandUpdateMapping (
1499 VOID
1500 )
1501{
1502 EFI_STATUS Status;
1503 EFI_HANDLE *HandleList;
1504 UINTN Count;
1505 EFI_DEVICE_PATH_PROTOCOL **DevicePathList;
1506 CHAR16 *NewDefaultName;
1507 CHAR16 *NewConsistName;
1508 EFI_DEVICE_PATH_PROTOCOL **ConsistMappingTable;
1509
1510 HandleList = NULL;
1511 Status = EFI_SUCCESS;
1512
1513 //
1514 // remove mappings that represent removed devices.
1515 //
1516
1517 //
1518 // Find each handle with Simple File System
1519 //
1520 HandleList = GetHandleListByProtocol(&gEfiSimpleFileSystemProtocolGuid);
1521 if (HandleList != NULL) {
1522 //
1523 // Do a count of the handles
1524 //
1525 for (Count = 0 ; HandleList[Count] != NULL ; Count++);
1526
1527 //
1528 // Get all Device Paths
1529 //
1530 DevicePathList = AllocateZeroPool(sizeof(EFI_DEVICE_PATH_PROTOCOL*) * Count);
1531 if (DevicePathList == NULL) {
1532 return (EFI_OUT_OF_RESOURCES);
1533 }
1534
1535 for (Count = 0 ; HandleList[Count] != NULL ; Count++) {
1536 DevicePathList[Count] = DevicePathFromHandle(HandleList[Count]);
1537 }
1538
1539 //
1540 // Sort all DevicePaths
1541 //
1542 PerformQuickSort(DevicePathList, Count, sizeof(EFI_DEVICE_PATH_PROTOCOL*), DevicePathCompare);
1543
1544 ShellCommandConsistMappingInitialize(&ConsistMappingTable);
1545
1546 //
1547 // Assign new Mappings to remainders
1548 //
1549 for (Count = 0 ; !EFI_ERROR(Status) && HandleList[Count] != NULL && !EFI_ERROR(Status); Count++) {
1550 //
1551 // Skip ones that already have
1552 //
1553 if (gEfiShellProtocol->GetMapFromDevicePath(&DevicePathList[Count]) != NULL) {
1554 continue;
1555 }
1556 //
1557 // Get default name
1558 //
1559 NewDefaultName = ShellCommandCreateNewMappingName(MappingTypeFileSystem);
1560 if (NewDefaultName == NULL) {
1561 Status = EFI_OUT_OF_RESOURCES;
1562 break;
1563 }
1564
1565 //
1566 // Call shell protocol SetMap function now...
1567 //
1568 Status = gEfiShellProtocol->SetMap(DevicePathList[Count], NewDefaultName);
1569
1570 if (!EFI_ERROR(Status)) {
1571 //
1572 // Now do consistent name
1573 //
1574 NewConsistName = ShellCommandConsistMappingGenMappingName(DevicePathList[Count], ConsistMappingTable);
1575 if (NewConsistName != NULL) {
1576 Status = gEfiShellProtocol->SetMap(DevicePathList[Count], NewConsistName);
1577 FreePool(NewConsistName);
1578 }
1579 }
1580
1581 FreePool(NewDefaultName);
1582 }
1583 ShellCommandConsistMappingUnInitialize(ConsistMappingTable);
1584 SHELL_FREE_NON_NULL(HandleList);
1585 SHELL_FREE_NON_NULL(DevicePathList);
1586
1587 HandleList = NULL;
1588 } else {
1589 Count = (UINTN)-1;
1590 }
1591 //
1592 // Do it all over again for gEfiBlockIoProtocolGuid
1593 //
1594
1595 return (Status);
1596}
1597
1598/**
1599 Converts a SHELL_FILE_HANDLE to an EFI_FILE_PROTOCOL*.
1600
1601 @param[in] Handle The SHELL_FILE_HANDLE to convert.
1602
1603 @return a EFI_FILE_PROTOCOL* representing the same file.
1604**/
1605EFI_FILE_PROTOCOL*
1606EFIAPI
1607ConvertShellHandleToEfiFileProtocol(
1608 IN CONST SHELL_FILE_HANDLE Handle
1609 )
1610{
1611 return ((EFI_FILE_PROTOCOL*)(Handle));
1612}
1613
1614/**
1615 Converts a EFI_FILE_PROTOCOL* to an SHELL_FILE_HANDLE.
1616
1617 @param[in] Handle The pointer to EFI_FILE_PROTOCOL to convert.
1618 @param[in] Path The path to the file for verification.
1619
1620 @return A SHELL_FILE_HANDLE representing the same file.
1621 @retval NULL There was not enough memory.
1622**/
1623SHELL_FILE_HANDLE
1624EFIAPI
1625ConvertEfiFileProtocolToShellHandle(
1626 IN CONST EFI_FILE_PROTOCOL *Handle,
1627 IN CONST CHAR16 *Path
1628 )
1629{
1630 SHELL_COMMAND_FILE_HANDLE *Buffer;
1631 BUFFER_LIST *NewNode;
1632
1633 if (Path != NULL) {
1634 Buffer = AllocateZeroPool(sizeof(SHELL_COMMAND_FILE_HANDLE));
1635 if (Buffer == NULL) {
1636 return (NULL);
1637 }
1638 NewNode = AllocateZeroPool(sizeof(BUFFER_LIST));
1639 if (NewNode == NULL) {
1640 SHELL_FREE_NON_NULL(Buffer);
1641 return (NULL);
1642 }
1643 Buffer->FileHandle = (EFI_FILE_PROTOCOL*)Handle;
1644 Buffer->Path = StrnCatGrow(&Buffer->Path, NULL, Path, 0);
1645 if (Buffer->Path == NULL) {
1646 SHELL_FREE_NON_NULL(NewNode);
1647 SHELL_FREE_NON_NULL(Buffer);
1648 return (NULL);
1649 }
1650 NewNode->Buffer = Buffer;
1651
1652 InsertHeadList(&mFileHandleList.Link, &NewNode->Link);
1653 }
1654 return ((SHELL_FILE_HANDLE)(Handle));
1655}
1656
1657/**
1658 Find the path that was logged with the specified SHELL_FILE_HANDLE.
1659
1660 @param[in] Handle The SHELL_FILE_HANDLE to query on.
1661
1662 @return A pointer to the path for the file.
1663**/
1664CONST CHAR16*
1665EFIAPI
1666ShellFileHandleGetPath(
1667 IN CONST SHELL_FILE_HANDLE Handle
1668 )
1669{
1670 BUFFER_LIST *Node;
1671
1672 for (Node = (BUFFER_LIST*)GetFirstNode(&mFileHandleList.Link)
1673 ; !IsNull(&mFileHandleList.Link, &Node->Link)
1674 ; Node = (BUFFER_LIST*)GetNextNode(&mFileHandleList.Link, &Node->Link)
1675 ){
1676 if ((Node->Buffer) && (((SHELL_COMMAND_FILE_HANDLE *)Node->Buffer)->FileHandle == Handle)){
1677 return (((SHELL_COMMAND_FILE_HANDLE *)Node->Buffer)->Path);
1678 }
1679 }
1680 return (NULL);
1681}
1682
1683/**
1684 Remove a SHELL_FILE_HANDLE from the list of SHELL_FILE_HANDLES.
1685
1686 @param[in] Handle The SHELL_FILE_HANDLE to remove.
1687
1688 @retval TRUE The item was removed.
1689 @retval FALSE The item was not found.
1690**/
1691BOOLEAN
1692EFIAPI
1693ShellFileHandleRemove(
1694 IN CONST SHELL_FILE_HANDLE Handle
1695 )
1696{
1697 BUFFER_LIST *Node;
1698
1699 for (Node = (BUFFER_LIST*)GetFirstNode(&mFileHandleList.Link)
1700 ; !IsNull(&mFileHandleList.Link, &Node->Link)
1701 ; Node = (BUFFER_LIST*)GetNextNode(&mFileHandleList.Link, &Node->Link)
1702 ){
1703 if ((Node->Buffer) && (((SHELL_COMMAND_FILE_HANDLE *)Node->Buffer)->FileHandle == Handle)){
1704 RemoveEntryList(&Node->Link);
1705 SHELL_FREE_NON_NULL(((SHELL_COMMAND_FILE_HANDLE *)Node->Buffer)->Path);
1706 SHELL_FREE_NON_NULL(Node->Buffer);
1707 SHELL_FREE_NON_NULL(Node);
1708 return (TRUE);
1709 }
1710 }
1711 return (FALSE);
1712}
1713
1714/**
1715 Function to determine if a SHELL_FILE_HANDLE is at the end of the file.
1716
1717 This will NOT work on directories.
1718
1719 If Handle is NULL, then ASSERT.
1720
1721 @param[in] Handle the file handle
1722
1723 @retval TRUE the position is at the end of the file
1724 @retval FALSE the position is not at the end of the file
1725**/
1726BOOLEAN
1727EFIAPI
1728ShellFileHandleEof(
1729 IN SHELL_FILE_HANDLE Handle
1730 )
1731{
1732 EFI_FILE_INFO *Info;
1733 UINT64 Pos;
1734 BOOLEAN RetVal;
1735
1736 //
1737 // ASSERT if Handle is NULL
1738 //
1739 ASSERT(Handle != NULL);
1740
1741 gEfiShellProtocol->GetFilePosition(Handle, &Pos);
1742 Info = gEfiShellProtocol->GetFileInfo (Handle);
1743 gEfiShellProtocol->SetFilePosition(Handle, Pos);
1744
1745 if (Info == NULL) {
1746 return (FALSE);
1747 }
1748
1749 if (Pos == Info->FileSize) {
1750 RetVal = TRUE;
1751 } else {
1752 RetVal = FALSE;
1753 }
1754
1755 FreePool (Info);
1756
1757 return (RetVal);
1758}
1759
1760/**
1761 Frees any BUFFER_LIST defined type.
1762
1763 @param[in] List The BUFFER_LIST object to free.
1764**/
1765VOID
1766EFIAPI
1767FreeBufferList (
1768 IN BUFFER_LIST *List
1769 )
1770{
1771 BUFFER_LIST *BufferListEntry;
1772
1773 if (List == NULL){
1774 return;
1775 }
1776 //
1777 // enumerate through the buffer list and free all memory
1778 //
1779 for ( BufferListEntry = ( BUFFER_LIST *)GetFirstNode(&List->Link)
1780 ; !IsListEmpty (&List->Link)
1781 ; BufferListEntry = (BUFFER_LIST *)GetFirstNode(&List->Link)
1782 ){
1783 RemoveEntryList(&BufferListEntry->Link);
1784 if (BufferListEntry->Buffer != NULL) {
1785 FreePool(BufferListEntry->Buffer);
1786 }
1787 FreePool(BufferListEntry);
1788 }
1789}
1790
1791/**
1792 Dump some hexadecimal data to the screen.
1793
1794 @param[in] Indent How many spaces to indent the output.
1795 @param[in] Offset The offset of the printing.
1796 @param[in] DataSize The size in bytes of UserData.
1797 @param[in] UserData The data to print out.
1798**/
1799VOID
1800EFIAPI
1801DumpHex (
1802 IN UINTN Indent,
1803 IN UINTN Offset,
1804 IN UINTN DataSize,
1805 IN VOID *UserData
1806 )
1807{
1808 UINT8 *Data;
1809
1810 CHAR8 Val[50];
1811
1812 CHAR8 Str[20];
1813
1814 UINT8 TempByte;
1815 UINTN Size;
1816 UINTN Index;
1817
1818 Data = UserData;
1819 while (DataSize != 0) {
1820 Size = 16;
1821 if (Size > DataSize) {
1822 Size = DataSize;
1823 }
1824
1825 for (Index = 0; Index < Size; Index += 1) {
1826 TempByte = Data[Index];
1827 Val[Index * 3 + 0] = Hex[TempByte >> 4];
1828 Val[Index * 3 + 1] = Hex[TempByte & 0xF];
1829 Val[Index * 3 + 2] = (CHAR8) ((Index == 7) ? '-' : ' ');
1830 Str[Index] = (CHAR8) ((TempByte < ' ' || TempByte > '~') ? '.' : TempByte);
1831 }
1832
1833 Val[Index * 3] = 0;
1834 Str[Index] = 0;
1835 ShellPrintEx(-1, -1, L"%*a%08X: %-48a *%a*\r\n", Indent, "", Offset, Val, Str);
1836
1837 Data += Size;
1838 Offset += Size;
1839 DataSize -= Size;
1840 }
1841}
1842
1843/**
1844 Dump HEX data into buffer.
1845
1846 @param[in] Buffer HEX data to be dumped in Buffer.
1847 @param[in] Indent How many spaces to indent the output.
1848 @param[in] Offset The offset of the printing.
1849 @param[in] DataSize The size in bytes of UserData.
1850 @param[in] UserData The data to print out.
1851**/
1852CHAR16*
1853EFIAPI
1854CatSDumpHex (
1855 IN CHAR16 *Buffer,
1856 IN UINTN Indent,
1857 IN UINTN Offset,
1858 IN UINTN DataSize,
1859 IN VOID *UserData
1860 )
1861{
1862 UINT8 *Data;
1863 UINT8 TempByte;
1864 UINTN Size;
1865 UINTN Index;
1866 CHAR8 Val[50];
1867 CHAR8 Str[20];
1868 CHAR16 *RetVal;
1869 CHAR16 *TempRetVal;
1870
1871 Data = UserData;
1872 RetVal = Buffer;
1873 while (DataSize != 0) {
1874 Size = 16;
1875 if (Size > DataSize) {
1876 Size = DataSize;
1877 }
1878
1879 for (Index = 0; Index < Size; Index += 1) {
1880 TempByte = Data[Index];
1881 Val[Index * 3 + 0] = Hex[TempByte >> 4];
1882 Val[Index * 3 + 1] = Hex[TempByte & 0xF];
1883 Val[Index * 3 + 2] = (CHAR8) ((Index == 7) ? '-' : ' ');
1884 Str[Index] = (CHAR8) ((TempByte < ' ' || TempByte > 'z') ? '.' : TempByte);
1885 }
1886
1887 Val[Index * 3] = 0;
1888 Str[Index] = 0;
1889 TempRetVal = CatSPrint (RetVal, L"%*a%08X: %-48a *%a*\r\n", Indent, "", Offset, Val, Str);
1890 SHELL_FREE_NON_NULL (RetVal);
1891 RetVal = TempRetVal;
1892
1893 Data += Size;
1894 Offset += Size;
1895 DataSize -= Size;
1896 }
1897
1898 return RetVal;
1899}
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette