2 Member functions of EFI_SHELL_PROTOCOL and functions for creation,
3 manipulation, and initialization of EFI_SHELL_PROTOCOL.
5 Copyright (c) 2009 - 2011, 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.
17 #include <Library/FileHandleLib.h>
20 Close an open file handle.
22 This function closes a specified file handle. All "dirty" cached file data is
23 flushed to the device, and the file is closed. In all cases the handle is
26 @param[in] FileHandle The file handle to close.
28 @retval EFI_SUCCESS The file handle was closed successfully.
33 IN SHELL_FILE_HANDLE FileHandle
36 ShellFileHandleRemove(FileHandle
);
37 return (FileHandleClose(ConvertShellHandleToEfiFileProtocol(FileHandle
)));
41 Internal worker to determine whether there is a BlockIo somewhere
42 upon the device path specified.
44 @param[in] DevicePath The device path to test.
46 @retval TRUE gEfiBlockIoProtocolGuid was installed on a handle with this device path
47 @retval FALSE gEfiBlockIoProtocolGuid was not found.
51 InternalShellProtocolIsBlockIoPresent(
52 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
55 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
61 DevicePathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)DevicePath
;
62 Status
= gBS
->LocateDevicePath(&gEfiBlockIoProtocolGuid
, &DevicePathCopy
, &Handle
);
64 if ((Handle
!= NULL
) && (!EFI_ERROR(Status
))) {
71 Internal worker to determine whether there is a file system somewhere
72 upon the device path specified.
74 @param[in] DevicePath The device path to test.
76 @retval TRUE gEfiSimpleFileSystemProtocolGuid was installed on a handle with this device path
77 @retval FALSE gEfiSimpleFileSystemProtocolGuid was not found.
81 InternalShellProtocolIsSimpleFileSystemPresent(
82 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
85 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
91 DevicePathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)DevicePath
;
92 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &Handle
);
94 if ((Handle
!= NULL
) && (!EFI_ERROR(Status
))) {
101 Internal worker debug helper function to print out maps as they are added.
103 @param[in] Mapping string mapping that has been added
104 @param[in] DevicePath pointer to device path that has been mapped.
106 @retval EFI_SUCCESS the operation was successful.
107 @return other an error ocurred
114 InternalShellProtocolDebugPrintMessage (
115 IN CONST CHAR16
*Mapping
,
116 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
119 EFI_DEVICE_PATH_TO_TEXT_PROTOCOL
*DevicePathToText
;
123 Status
= EFI_SUCCESS
;
125 DevicePathToText
= NULL
;
127 Status
= gBS
->LocateProtocol(&gEfiDevicePathToTextProtocolGuid
,
129 (VOID
**)&DevicePathToText
);
130 if (Mapping
!= NULL
) {
131 DEBUG((EFI_D_INFO
, "Added new map item:\"%S\"\r\n", Mapping
));
133 if (!EFI_ERROR(Status
)) {
134 if (DevicePath
!= NULL
) {
135 Temp
= DevicePathToText
->ConvertDevicePathToText(DevicePath
, TRUE
, TRUE
);
136 DEBUG((EFI_D_INFO
, "DevicePath: %S\r\n", Temp
));
145 This function creates a mapping for a device path.
147 If both DeviecPath and Mapping are NULL, this will reset the mapping to default values.
149 @param DevicePath Points to the device path. If this is NULL and Mapping points to a valid mapping,
150 then the mapping will be deleted.
151 @param Mapping Points to the NULL-terminated mapping for the device path. Must end with a ':'
153 @retval EFI_SUCCESS Mapping created or deleted successfully.
154 @retval EFI_NO_MAPPING There is no handle that corresponds exactly to DevicePath. See the
155 boot service function LocateDevicePath().
156 @retval EFI_ACCESS_DENIED The mapping is a built-in alias.
157 @retval EFI_INVALID_PARAMETER Mapping was NULL
158 @retval EFI_INVALID_PARAMETER Mapping did not end with a ':'
159 @retval EFI_INVALID_PARAMETER DevicePath was not pointing at a device that had a SIMPLE_FILE_SYSTEM_PROTOCOL installed.
160 @retval EFI_NOT_FOUND There was no mapping found to delete
161 @retval EFI_OUT_OF_RESOURCES Memory allocation failed
166 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath OPTIONAL
,
167 IN CONST CHAR16
*Mapping
171 SHELL_MAP_LIST
*MapListNode
;
173 if (Mapping
== NULL
){
174 return (EFI_INVALID_PARAMETER
);
177 if (Mapping
[StrLen(Mapping
)-1] != ':') {
178 return (EFI_INVALID_PARAMETER
);
182 // Delete the mapping
184 if (DevicePath
== NULL
) {
185 if (IsListEmpty(&gShellMapList
.Link
)) {
186 return (EFI_NOT_FOUND
);
188 for ( MapListNode
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
189 ; !IsNull(&gShellMapList
.Link
, &MapListNode
->Link
)
190 ; MapListNode
= (SHELL_MAP_LIST
*)GetNextNode(&gShellMapList
.Link
, &MapListNode
->Link
)
192 if (StringNoCaseCompare(&MapListNode
->MapName
, &Mapping
) == 0) {
193 RemoveEntryList(&MapListNode
->Link
);
194 FreePool(MapListNode
);
195 return (EFI_SUCCESS
);
200 // We didnt find one to delete
202 return (EFI_NOT_FOUND
);
206 // make sure this is a valid to add device path
208 ///@todo add BlockIo to this test...
209 if (!InternalShellProtocolIsSimpleFileSystemPresent(DevicePath
)
210 && !InternalShellProtocolIsBlockIoPresent(DevicePath
)) {
211 return (EFI_INVALID_PARAMETER
);
215 // First make sure there is no old mapping
217 Status
= EfiShellSetMap(NULL
, Mapping
);
218 if ((Status
!= EFI_SUCCESS
) && (Status
!= EFI_NOT_FOUND
)) {
223 // now add the new one.
225 Status
= ShellCommandAddMapItemAndUpdatePath(Mapping
, DevicePath
, 0, FALSE
);
231 Gets the device path from the mapping.
233 This function gets the device path associated with a mapping.
235 @param Mapping A pointer to the mapping
237 @retval !=NULL Pointer to the device path that corresponds to the
238 device mapping. The returned pointer does not need
240 @retval NULL There is no device path associated with the
243 CONST EFI_DEVICE_PATH_PROTOCOL
*
245 EfiShellGetDevicePathFromMap(
246 IN CONST CHAR16
*Mapping
249 SHELL_MAP_LIST
*MapListItem
;
256 StrnCatGrow(&NewName
, &Size
, Mapping
, 0);
257 if (Mapping
[StrLen(Mapping
)-1] != L
':') {
258 StrnCatGrow(&NewName
, &Size
, L
":", 0);
261 MapListItem
= ShellCommandFindMapItem(NewName
);
265 if (MapListItem
!= NULL
) {
266 return (MapListItem
->DevicePath
);
272 Gets the mapping(s) that most closely matches the device path.
274 This function gets the mapping which corresponds to the device path *DevicePath. If
275 there is no exact match, then the mapping which most closely matches *DevicePath
276 is returned, and *DevicePath is updated to point to the remaining portion of the
277 device path. If there is an exact match, the mapping is returned and *DevicePath
278 points to the end-of-device-path node.
280 If there are multiple map names they will be semi-colon seperated in the
281 NULL-terminated string.
283 @param DevicePath On entry, points to a device path pointer. On
284 exit, updates the pointer to point to the
285 portion of the device path after the mapping.
287 @retval NULL No mapping was found.
288 @return !=NULL Pointer to NULL-terminated mapping. The buffer
289 is callee allocated and should be freed by the caller.
293 EfiShellGetMapFromDevicePath(
294 IN OUT EFI_DEVICE_PATH_PROTOCOL
**DevicePath
297 SHELL_MAP_LIST
*Node
;
298 CHAR16
*PathForReturn
;
300 // EFI_HANDLE PathHandle;
301 // EFI_HANDLE MapHandle;
302 // EFI_STATUS Status;
303 // EFI_DEVICE_PATH_PROTOCOL *DevicePathCopy;
304 // EFI_DEVICE_PATH_PROTOCOL *MapPathCopy;
306 if (DevicePath
== NULL
|| *DevicePath
== NULL
) {
310 PathForReturn
= NULL
;
313 for ( Node
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
314 ; !IsNull(&gShellMapList
.Link
, &Node
->Link
)
315 ; Node
= (SHELL_MAP_LIST
*)GetNextNode(&gShellMapList
.Link
, &Node
->Link
)
318 // check for exact match
320 if (DevicePathCompare(DevicePath
, &Node
->DevicePath
) == 0) {
321 ASSERT((PathForReturn
== NULL
&& PathSize
== 0) || (PathForReturn
!= NULL
));
323 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, L
";", 0);
325 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, Node
->MapName
, 0);
328 if (PathForReturn
!= NULL
) {
329 while (!IsDevicePathEndType (*DevicePath
)) {
330 *DevicePath
= NextDevicePathNode (*DevicePath
);
332 SetDevicePathEndNode (*DevicePath
);
335 ///@todo finish code for inexact matches.
336 if (PathForReturn == NULL) {
339 DevicePathCopy = DuplicateDevicePath(*DevicePath);
340 ASSERT(DevicePathCopy != NULL);
341 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &DevicePathCopy, &PathHandle);
342 ASSERT_EFI_ERROR(Status);
344 // check each of the device paths we have to get the root of the path for consist mappings
346 for ( Node = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
347 ; !IsNull(&gShellMapList.Link, &Node->Link)
348 ; Node = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &Node->Link)
350 if ((Node->Flags & SHELL_MAP_FLAGS_CONSIST) == 0) {
353 MapPathCopy = DuplicateDevicePath(Node->DevicePath);
354 ASSERT(MapPathCopy != NULL);
355 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &MapPathCopy, &MapHandle);
356 if (MapHandle == PathHandle) {
358 *DevicePath = DevicePathCopy;
361 DevicePathCopy = NULL;
362 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, Node->MapName, 0);
363 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, L";", 0);
368 // now add on the non-consistent mappings
370 for ( Node = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
371 ; !IsNull(&gShellMapList.Link, &Node->Link)
372 ; Node = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &Node->Link)
374 if ((Node->Flags & SHELL_MAP_FLAGS_CONSIST) != 0) {
377 MapPathCopy = Node->DevicePath;
378 ASSERT(MapPathCopy != NULL);
379 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &MapPathCopy, &MapHandle);
380 if (MapHandle == PathHandle) {
381 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, Node->MapName, 0);
382 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, L";", 0);
389 return (AddBufferToFreeList(PathForReturn
));
393 Converts a device path to a file system-style path.
395 This function converts a device path to a file system path by replacing part, or all, of
396 the device path with the file-system mapping. If there are more than one application
397 file system mappings, the one that most closely matches Path will be used.
399 @param Path The pointer to the device path
401 @retval NULL the device path could not be found.
402 @return all The pointer of the NULL-terminated file path. The path
403 is callee-allocated and should be freed by the caller.
407 EfiShellGetFilePathFromDevicePath(
408 IN CONST EFI_DEVICE_PATH_PROTOCOL
*Path
411 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
412 EFI_DEVICE_PATH_PROTOCOL
*MapPathCopy
;
413 SHELL_MAP_LIST
*MapListItem
;
414 CHAR16
*PathForReturn
;
416 EFI_HANDLE PathHandle
;
417 EFI_HANDLE MapHandle
;
419 FILEPATH_DEVICE_PATH
*FilePath
;
420 FILEPATH_DEVICE_PATH
*AlignedNode
;
422 PathForReturn
= NULL
;
425 DevicePathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)Path
;
426 ASSERT(DevicePathCopy
!= NULL
);
427 if (DevicePathCopy
== NULL
) {
431 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &PathHandle
);
433 if (EFI_ERROR(Status
)) {
437 // check each of the device paths we have to get the root of the path
439 for ( MapListItem
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
440 ; !IsNull(&gShellMapList
.Link
, &MapListItem
->Link
)
441 ; MapListItem
= (SHELL_MAP_LIST
*)GetNextNode(&gShellMapList
.Link
, &MapListItem
->Link
)
443 MapPathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)MapListItem
->DevicePath
;
444 ASSERT(MapPathCopy
!= NULL
);
446 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &MapPathCopy
, &MapHandle
);
447 if (MapHandle
== PathHandle
) {
448 ASSERT((PathForReturn
== NULL
&& PathSize
== 0) || (PathForReturn
!= NULL
));
449 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, MapListItem
->MapName
, 0);
451 // go through all the remaining nodes in the device path
453 for ( FilePath
= (FILEPATH_DEVICE_PATH
*)DevicePathCopy
454 ; !IsDevicePathEnd (&FilePath
->Header
)
455 ; FilePath
= (FILEPATH_DEVICE_PATH
*)NextDevicePathNode (&FilePath
->Header
)
458 // all the rest should be file path nodes
460 if ((DevicePathType(&FilePath
->Header
) != MEDIA_DEVICE_PATH
) ||
461 (DevicePathSubType(&FilePath
->Header
) != MEDIA_FILEPATH_DP
)) {
462 FreePool(PathForReturn
);
463 PathForReturn
= NULL
;
467 // append the path part onto the filepath.
469 ASSERT((PathForReturn
== NULL
&& PathSize
== 0) || (PathForReturn
!= NULL
));
470 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, L
"\\", 1);
472 AlignedNode
= AllocateCopyPool (DevicePathNodeLength(FilePath
), FilePath
);
473 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, AlignedNode
->PathName
, 0);
474 FreePool(AlignedNode
);
476 } // for loop of remaining nodes
478 if (PathForReturn
!= NULL
) {
481 } // for loop of paths to check
482 return(PathForReturn
);
486 Converts a file system style name to a device path.
488 This function converts a file system style name to a device path, by replacing any
489 mapping references to the associated device path.
491 @param[in] Path The pointer to the path.
493 @return The pointer of the file path. The file path is callee
494 allocated and should be freed by the caller.
495 @retval NULL The path could not be found.
496 @retval NULL There was not enough available memory.
498 EFI_DEVICE_PATH_PROTOCOL
*
500 EfiShellGetDevicePathFromFilePath(
501 IN CONST CHAR16
*Path
508 CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
509 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
510 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopyForFree
;
511 EFI_DEVICE_PATH_PROTOCOL
*DevicePathForReturn
;
522 if (StrStr(Path
, L
":") == NULL
) {
523 Cwd
= EfiShellGetCurDir(NULL
);
528 Size
+= StrSize(Path
);
529 NewPath
= AllocateZeroPool(Size
);
530 if (NewPath
== NULL
) {
533 StrCpy(NewPath
, Cwd
);
534 if (*Path
== L
'\\') {
536 while (PathRemoveLastItem(NewPath
)) ;
538 StrCat(NewPath
, Path
);
539 DevicePathForReturn
= EfiShellGetDevicePathFromFilePath(NewPath
);
541 return (DevicePathForReturn
);
546 // find the part before (but including) the : for the map name
548 ASSERT((MapName
== NULL
&& Size
== 0) || (MapName
!= NULL
));
549 MapName
= StrnCatGrow(&MapName
, &Size
, Path
, (StrStr(Path
, L
":")-Path
+1));
550 if (MapName
== NULL
|| MapName
[StrLen(MapName
)-1] != L
':') {
555 // look up the device path in the map
557 DevicePath
= EfiShellGetDevicePathFromMap(MapName
);
558 if (DevicePath
== NULL
) {
560 // Must have been a bad Mapname
566 // make a copy for LocateDevicePath to modify (also save a pointer to call FreePool with)
568 DevicePathCopyForFree
= DevicePathCopy
= DuplicateDevicePath(DevicePath
);
569 if (DevicePathCopy
== NULL
) {
578 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &Handle
);
579 if (EFI_ERROR(Status
)) {
580 if (DevicePathCopyForFree
!= NULL
) {
581 FreePool(DevicePathCopyForFree
);
588 // build the full device path
590 if (*(Path
+StrLen(MapName
)+1) == CHAR_NULL
) {
591 DevicePathForReturn
= FileDevicePath(Handle
, L
"\\");
593 DevicePathForReturn
= FileDevicePath(Handle
, Path
+StrLen(MapName
));
597 if (DevicePathCopyForFree
!= NULL
) {
598 FreePool(DevicePathCopyForFree
);
601 return (DevicePathForReturn
);
605 Gets the name of the device specified by the device handle.
607 This function gets the user-readable name of the device specified by the device
608 handle. If no user-readable name could be generated, then *BestDeviceName will be
609 NULL and EFI_NOT_FOUND will be returned.
611 If EFI_DEVICE_NAME_USE_COMPONENT_NAME is set, then the function will return the
612 device's name using the EFI_COMPONENT_NAME2_PROTOCOL, if present on
615 If EFI_DEVICE_NAME_USE_DEVICE_PATH is set, then the function will return the
616 device's name using the EFI_DEVICE_PATH_PROTOCOL, if present on DeviceHandle.
617 If both EFI_DEVICE_NAME_USE_COMPONENT_NAME and
618 EFI_DEVICE_NAME_USE_DEVICE_PATH are set, then
619 EFI_DEVICE_NAME_USE_COMPONENT_NAME will have higher priority.
621 @param DeviceHandle The handle of the device.
622 @param Flags Determines the possible sources of component names.
624 EFI_DEVICE_NAME_USE_COMPONENT_NAME
625 EFI_DEVICE_NAME_USE_DEVICE_PATH
626 @param Language A pointer to the language specified for the device
627 name, in the same format as described in the UEFI
628 specification, Appendix M
629 @param BestDeviceName On return, points to the callee-allocated NULL-
630 terminated name of the device. If no device name
631 could be found, points to NULL. The name must be
632 freed by the caller...
634 @retval EFI_SUCCESS Get the name successfully.
635 @retval EFI_NOT_FOUND Fail to get the device name.
636 @retval EFI_INVALID_PARAMETER Flags did not have a valid bit set.
637 @retval EFI_INVALID_PARAMETER BestDeviceName was NULL
638 @retval EFI_INVALID_PARAMETER DeviceHandle was NULL
642 EfiShellGetDeviceName(
643 IN EFI_HANDLE DeviceHandle
,
644 IN EFI_SHELL_DEVICE_NAME_FLAGS Flags
,
646 OUT CHAR16
**BestDeviceName
650 EFI_COMPONENT_NAME2_PROTOCOL
*CompName2
;
651 EFI_DEVICE_PATH_TO_TEXT_PROTOCOL
*DevicePathToText
;
652 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
653 EFI_HANDLE
*HandleList
;
656 CHAR16
*DeviceNameToReturn
;
660 UINTN ParentControllerCount
;
661 EFI_HANDLE
*ParentControllerBuffer
;
662 UINTN ParentDriverCount
;
663 EFI_HANDLE
*ParentDriverBuffer
;
665 if (BestDeviceName
== NULL
||
668 return (EFI_INVALID_PARAMETER
);
672 // make sure one of the 2 supported bits is on
674 if (((Flags
& EFI_DEVICE_NAME_USE_COMPONENT_NAME
) == 0) &&
675 ((Flags
& EFI_DEVICE_NAME_USE_DEVICE_PATH
) == 0)) {
676 return (EFI_INVALID_PARAMETER
);
679 DeviceNameToReturn
= NULL
;
680 *BestDeviceName
= NULL
;
685 if ((Flags
& EFI_DEVICE_NAME_USE_COMPONENT_NAME
) != 0) {
686 Status
= ParseHandleDatabaseByRelationship(
689 HR_DRIVER_BINDING_HANDLE
|HR_DEVICE_DRIVER
,
692 for (LoopVar
= 0; LoopVar
< HandleCount
; LoopVar
++){
694 // Go through those handles until we get one that passes for GetComponentName
696 Status
= gBS
->OpenProtocol(
698 &gEfiComponentName2ProtocolGuid
,
702 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
703 if (EFI_ERROR(Status
)) {
704 Status
= gBS
->OpenProtocol(
706 &gEfiComponentNameProtocolGuid
,
710 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
713 if (EFI_ERROR(Status
)) {
716 if (Language
== NULL
) {
717 Lang
= AllocateZeroPool(AsciiStrSize(CompName2
->SupportedLanguages
));
719 return (EFI_OUT_OF_RESOURCES
);
721 AsciiStrCpy(Lang
, CompName2
->SupportedLanguages
);
722 TempChar
= AsciiStrStr(Lang
, ";");
723 if (TempChar
!= NULL
){
724 *TempChar
= CHAR_NULL
;
727 Lang
= AllocateZeroPool(AsciiStrSize(Language
));
729 return (EFI_OUT_OF_RESOURCES
);
731 AsciiStrCpy(Lang
, Language
);
733 Status
= CompName2
->GetControllerName(CompName2
, DeviceHandle
, NULL
, Lang
, &DeviceNameToReturn
);
736 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
740 if (HandleList
!= NULL
) {
741 FreePool(HandleList
);
745 // Now check the parent controller using this as the child.
747 if (DeviceNameToReturn
== NULL
){
748 PARSE_HANDLE_DATABASE_PARENTS(DeviceHandle
, &ParentControllerCount
, &ParentControllerBuffer
);
749 for (LoopVar
= 0 ; LoopVar
< ParentControllerCount
; LoopVar
++) {
750 PARSE_HANDLE_DATABASE_UEFI_DRIVERS(ParentControllerBuffer
[LoopVar
], &ParentDriverCount
, &ParentDriverBuffer
);
751 for (HandleCount
= 0 ; HandleCount
< ParentDriverCount
; HandleCount
++) {
753 // try using that driver's component name with controller and our driver as the child.
755 Status
= gBS
->OpenProtocol(
756 ParentDriverBuffer
[HandleCount
],
757 &gEfiComponentName2ProtocolGuid
,
761 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
762 if (EFI_ERROR(Status
)) {
763 Status
= gBS
->OpenProtocol(
764 ParentDriverBuffer
[HandleCount
],
765 &gEfiComponentNameProtocolGuid
,
769 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
772 if (EFI_ERROR(Status
)) {
775 if (Language
== NULL
) {
776 Lang
= AllocateZeroPool(AsciiStrSize(CompName2
->SupportedLanguages
));
778 return (EFI_OUT_OF_RESOURCES
);
780 AsciiStrCpy(Lang
, CompName2
->SupportedLanguages
);
781 TempChar
= AsciiStrStr(Lang
, ";");
782 if (TempChar
!= NULL
){
783 *TempChar
= CHAR_NULL
;
786 Lang
= AllocateZeroPool(AsciiStrSize(Language
));
788 return (EFI_OUT_OF_RESOURCES
);
790 AsciiStrCpy(Lang
, Language
);
792 Status
= CompName2
->GetControllerName(CompName2
, ParentControllerBuffer
[LoopVar
], DeviceHandle
, Lang
, &DeviceNameToReturn
);
795 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
802 SHELL_FREE_NON_NULL(ParentDriverBuffer
);
803 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
807 SHELL_FREE_NON_NULL(ParentControllerBuffer
);
810 // dont return on fail since we will try device path if that bit is on
812 if (DeviceNameToReturn
!= NULL
){
813 ASSERT(BestDeviceName
!= NULL
);
814 StrnCatGrow(BestDeviceName
, NULL
, DeviceNameToReturn
, 0);
815 return (EFI_SUCCESS
);
818 if ((Flags
& EFI_DEVICE_NAME_USE_DEVICE_PATH
) != 0) {
819 Status
= gBS
->LocateProtocol(
820 &gEfiDevicePathToTextProtocolGuid
,
822 (VOID
**)&DevicePathToText
);
824 // we now have the device path to text protocol
826 if (!EFI_ERROR(Status
)) {
827 Status
= gBS
->OpenProtocol(
829 &gEfiDevicePathProtocolGuid
,
833 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
834 if (!EFI_ERROR(Status
)) {
836 // use device path to text on the device path
838 *BestDeviceName
= DevicePathToText
->ConvertDevicePathToText(DevicePath
, TRUE
, TRUE
);
839 return (EFI_SUCCESS
);
844 // none of the selected bits worked.
846 return (EFI_NOT_FOUND
);
850 Opens the root directory of a device on a handle
852 This function opens the root directory of a device and returns a file handle to it.
854 @param DeviceHandle The handle of the device that contains the volume.
855 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
858 @retval EFI_SUCCESS Root opened successfully.
859 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
861 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
862 @retval EFI_DEVICE_ERROR The device had an error
866 EfiShellOpenRootByHandle(
867 IN EFI_HANDLE DeviceHandle
,
868 OUT SHELL_FILE_HANDLE
*FileHandle
872 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
*SimpleFileSystem
;
873 EFI_FILE_PROTOCOL
*RealFileHandle
;
874 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
877 // get the simple file system interface
879 Status
= gBS
->OpenProtocol(DeviceHandle
,
880 &gEfiSimpleFileSystemProtocolGuid
,
881 (VOID
**)&SimpleFileSystem
,
884 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
885 if (EFI_ERROR(Status
)) {
886 return (EFI_NOT_FOUND
);
889 Status
= gBS
->OpenProtocol(DeviceHandle
,
890 &gEfiDevicePathProtocolGuid
,
894 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
895 if (EFI_ERROR(Status
)) {
896 return (EFI_NOT_FOUND
);
899 // Open the root volume now...
901 Status
= SimpleFileSystem
->OpenVolume(SimpleFileSystem
, &RealFileHandle
);
902 *FileHandle
= ConvertEfiFileProtocolToShellHandle(RealFileHandle
, EfiShellGetMapFromDevicePath(&DevPath
));
907 Opens the root directory of a device.
909 This function opens the root directory of a device and returns a file handle to it.
911 @param DevicePath Points to the device path corresponding to the device where the
912 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL is installed.
913 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
916 @retval EFI_SUCCESS Root opened successfully.
917 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
919 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
920 @retval EFI_DEVICE_ERROR The device had an error
921 @retval EFI_INVALID_PARAMETER FileHandle is NULL.
926 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
927 OUT SHELL_FILE_HANDLE
*FileHandle
933 if (FileHandle
== NULL
) {
934 return (EFI_INVALID_PARAMETER
);
938 // find the handle of the device with that device handle and the file system
941 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
,
944 if (EFI_ERROR(Status
)) {
945 return (EFI_NOT_FOUND
);
948 return (EfiShellOpenRootByHandle(Handle
, FileHandle
));
952 Returns whether any script files are currently being processed.
954 @retval TRUE There is at least one script file active.
955 @retval FALSE No script files are active now.
960 EfiShellBatchIsActive (
964 if (ShellCommandGetCurrentScriptFile() == NULL
) {
971 Worker function to open a file based on a device path. this will open the root
972 of the volume and then traverse down to the file itself.
974 @param DevicePath Device Path of the file.
975 @param FileHandle Pointer to the file upon a successful return.
976 @param OpenMode mode to open file in.
977 @param Attributes the File Attributes to use when creating a new file.
979 @retval EFI_SUCCESS the file is open and FileHandle is valid
980 @retval EFI_UNSUPPORTED the device path cotained non-path elements
981 @retval other an error ocurred.
985 InternalOpenFileDevicePath(
986 IN OUT EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
987 OUT SHELL_FILE_HANDLE
*FileHandle
,
989 IN UINT64 Attributes OPTIONAL
993 FILEPATH_DEVICE_PATH
*FilePathNode
;
995 SHELL_FILE_HANDLE ShellHandle
;
996 EFI_FILE_PROTOCOL
*Handle1
;
997 EFI_FILE_PROTOCOL
*Handle2
;
998 EFI_DEVICE_PATH_PROTOCOL
*DpCopy
;
999 FILEPATH_DEVICE_PATH
*AlignedNode
;
1001 if (FileHandle
== NULL
) {
1002 return (EFI_INVALID_PARAMETER
);
1008 DpCopy
= DevicePath
;
1010 FilePathNode
= NULL
;
1013 Status
= EfiShellOpenRoot(DevicePath
, &ShellHandle
);
1015 if (!EFI_ERROR(Status
)) {
1016 Handle1
= ConvertShellHandleToEfiFileProtocol(ShellHandle
);
1017 if (Handle1
!= NULL
) {
1019 // chop off the begining part before the file system part...
1022 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
,
1025 if (!EFI_ERROR(Status
)) {
1027 // To access as a file system, the file path should only
1028 // contain file path components. Follow the file path nodes
1029 // and find the target file
1031 for ( FilePathNode
= (FILEPATH_DEVICE_PATH
*)DevicePath
1032 ; !IsDevicePathEnd (&FilePathNode
->Header
)
1033 ; FilePathNode
= (FILEPATH_DEVICE_PATH
*) NextDevicePathNode (&FilePathNode
->Header
)
1035 SHELL_FREE_NON_NULL(AlignedNode
);
1036 AlignedNode
= AllocateCopyPool (DevicePathNodeLength(FilePathNode
), FilePathNode
);
1038 // For file system access each node should be a file path component
1040 if (DevicePathType (&FilePathNode
->Header
) != MEDIA_DEVICE_PATH
||
1041 DevicePathSubType (&FilePathNode
->Header
) != MEDIA_FILEPATH_DP
1043 Status
= EFI_UNSUPPORTED
;
1048 // Open this file path node
1054 // if this is the last node in the DevicePath always create (if that was requested).
1056 if (IsDevicePathEnd ((NextDevicePathNode (&FilePathNode
->Header
)))) {
1057 Status
= Handle2
->Open (
1060 AlignedNode
->PathName
,
1067 // This is not the last node and we dont want to 'create' existing
1068 // directory entries...
1072 // open without letting it create
1073 // prevents error on existing files/directories
1075 Status
= Handle2
->Open (
1078 AlignedNode
->PathName
,
1079 OpenMode
&~EFI_FILE_MODE_CREATE
,
1083 // if above failed now open and create the 'item'
1084 // if OpenMode EFI_FILE_MODE_CREATE bit was on (but disabled above)
1086 if ((EFI_ERROR (Status
)) && ((OpenMode
& EFI_FILE_MODE_CREATE
) != 0)) {
1087 Status
= Handle2
->Open (
1090 AlignedNode
->PathName
,
1097 // Close the last node
1099 ShellInfoObject
.NewEfiShellProtocol
->CloseFile (Handle2
);
1102 // If there's been an error, stop
1104 if (EFI_ERROR (Status
)) {
1111 SHELL_FREE_NON_NULL(AlignedNode
);
1112 if (EFI_ERROR(Status
)) {
1113 if (Handle1
!= NULL
) {
1114 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(Handle1
);
1117 *FileHandle
= ConvertEfiFileProtocolToShellHandle(Handle1
, ShellFileHandleGetPath(ShellHandle
));
1123 Creates a file or directory by name.
1125 This function creates an empty new file or directory with the specified attributes and
1126 returns the new file's handle. If the file already exists and is read-only, then
1127 EFI_INVALID_PARAMETER will be returned.
1129 If the file already existed, it is truncated and its attributes updated. If the file is
1130 created successfully, the FileHandle is the file's handle, else, the FileHandle is NULL.
1132 If the file name begins with >v, then the file handle which is returned refers to the
1133 shell environment variable with the specified name. If the shell environment variable
1134 already exists and is non-volatile then EFI_INVALID_PARAMETER is returned.
1136 @param FileName Pointer to NULL-terminated file path
1137 @param FileAttribs The new file's attrbiutes. the different attributes are
1138 described in EFI_FILE_PROTOCOL.Open().
1139 @param FileHandle On return, points to the created file handle or directory's handle
1141 @retval EFI_SUCCESS The file was opened. FileHandle points to the new file's handle.
1142 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1143 @retval EFI_UNSUPPORTED could not open the file path
1144 @retval EFI_NOT_FOUND the specified file could not be found on the devide, or could not
1145 file the file system on the device.
1146 @retval EFI_NO_MEDIA the device has no medium.
1147 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1149 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1151 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1152 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1153 when the media is write-protected.
1154 @retval EFI_ACCESS_DENIED The service denied access to the file.
1155 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file.
1156 @retval EFI_VOLUME_FULL The volume is full.
1161 IN CONST CHAR16
*FileName
,
1162 IN UINT64 FileAttribs
,
1163 OUT SHELL_FILE_HANDLE
*FileHandle
1166 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1170 // Is this for an environment variable
1171 // do we start with >v
1173 if (StrStr(FileName
, L
">v") == FileName
) {
1174 if (!IsVolatileEnv(FileName
+2)) {
1175 return (EFI_INVALID_PARAMETER
);
1177 *FileHandle
= CreateFileInterfaceEnv(FileName
+2);
1178 return (EFI_SUCCESS
);
1182 // We are opening a regular file.
1184 DevicePath
= EfiShellGetDevicePathFromFilePath(FileName
);
1185 if (DevicePath
== NULL
) {
1186 return (EFI_NOT_FOUND
);
1189 Status
= InternalOpenFileDevicePath(DevicePath
, FileHandle
, EFI_FILE_MODE_READ
|EFI_FILE_MODE_WRITE
|EFI_FILE_MODE_CREATE
, FileAttribs
); // 0 = no specific file attributes
1190 FreePool(DevicePath
);
1196 Opens a file or a directory by file name.
1198 This function opens the specified file in the specified OpenMode and returns a file
1200 If the file name begins with >v, then the file handle which is returned refers to the
1201 shell environment variable with the specified name. If the shell environment variable
1202 exists, is non-volatile and the OpenMode indicates EFI_FILE_MODE_WRITE, then
1203 EFI_INVALID_PARAMETER is returned.
1205 If the file name is >i, then the file handle which is returned refers to the standard
1206 input. If the OpenMode indicates EFI_FILE_MODE_WRITE, then EFI_INVALID_PARAMETER
1209 If the file name is >o, then the file handle which is returned refers to the standard
1210 output. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1213 If the file name is >e, then the file handle which is returned refers to the standard
1214 error. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1217 If the file name is NUL, then the file handle that is returned refers to the standard NUL
1218 file. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER is
1221 If return EFI_SUCCESS, the FileHandle is the opened file's handle, else, the
1224 @param FileName Points to the NULL-terminated UCS-2 encoded file name.
1225 @param FileHandle On return, points to the file handle.
1226 @param OpenMode File open mode. Either EFI_FILE_MODE_READ or
1227 EFI_FILE_MODE_WRITE from section 12.4 of the UEFI
1229 @retval EFI_SUCCESS The file was opened. FileHandle has the opened file's handle.
1230 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value. FileHandle is NULL.
1231 @retval EFI_UNSUPPORTED Could not open the file path. FileHandle is NULL.
1232 @retval EFI_NOT_FOUND The specified file could not be found on the device or the file
1233 system could not be found on the device. FileHandle is NULL.
1234 @retval EFI_NO_MEDIA The device has no medium. FileHandle is NULL.
1235 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1236 longer supported. FileHandle is NULL.
1237 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1238 the FileName. FileHandle is NULL.
1239 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted. FileHandle is NULL.
1240 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1241 when the media is write-protected. FileHandle is NULL.
1242 @retval EFI_ACCESS_DENIED The service denied access to the file. FileHandle is NULL.
1243 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file. FileHandle
1245 @retval EFI_VOLUME_FULL The volume is full. FileHandle is NULL.
1249 EfiShellOpenFileByName(
1250 IN CONST CHAR16
*FileName
,
1251 OUT SHELL_FILE_HANDLE
*FileHandle
,
1255 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1261 // Is this for StdIn
1263 if (StrCmp(FileName
, L
">i") == 0) {
1265 // make sure not writing to StdIn
1267 if ((OpenMode
& EFI_FILE_MODE_WRITE
) != 0) {
1268 return (EFI_INVALID_PARAMETER
);
1270 *FileHandle
= ShellInfoObject
.NewShellParametersProtocol
->StdIn
;
1271 ASSERT(*FileHandle
!= NULL
);
1272 return (EFI_SUCCESS
);
1276 // Is this for StdOut
1278 if (StrCmp(FileName
, L
">o") == 0) {
1280 // make sure not writing to StdIn
1282 if ((OpenMode
& EFI_FILE_MODE_READ
) != 0) {
1283 return (EFI_INVALID_PARAMETER
);
1285 *FileHandle
= &FileInterfaceStdOut
;
1286 return (EFI_SUCCESS
);
1290 // Is this for NUL file
1292 if (StrCmp(FileName
, L
"NUL") == 0) {
1293 *FileHandle
= &FileInterfaceNulFile
;
1294 return (EFI_SUCCESS
);
1298 // Is this for StdErr
1300 if (StrCmp(FileName
, L
">e") == 0) {
1302 // make sure not writing to StdIn
1304 if ((OpenMode
& EFI_FILE_MODE_READ
) != 0) {
1305 return (EFI_INVALID_PARAMETER
);
1307 *FileHandle
= &FileInterfaceStdErr
;
1308 return (EFI_SUCCESS
);
1312 // Is this for an environment variable
1313 // do we start with >v
1315 if (StrStr(FileName
, L
">v") == FileName
) {
1316 if (!IsVolatileEnv(FileName
+2) &&
1317 ((OpenMode
& EFI_FILE_MODE_WRITE
) != 0)) {
1318 return (EFI_INVALID_PARAMETER
);
1320 *FileHandle
= CreateFileInterfaceEnv(FileName
+2);
1321 return (EFI_SUCCESS
);
1325 // We are opening a regular file.
1327 DevicePath
= EfiShellGetDevicePathFromFilePath(FileName
);
1328 // DEBUG_CODE(InternalShellProtocolDebugPrintMessage (NULL, DevicePath););
1329 if (DevicePath
== NULL
) {
1330 return (EFI_NOT_FOUND
);
1334 // Copy the device path, open the file, then free the memory
1336 Status
= InternalOpenFileDevicePath(DevicePath
, FileHandle
, OpenMode
, 0); // 0 = no specific file attributes
1337 FreePool(DevicePath
);
1343 Deletes the file specified by the file name.
1345 This function deletes a file.
1347 @param FileName Points to the NULL-terminated file name.
1349 @retval EFI_SUCCESS The file was closed and deleted, and the handle was closed.
1350 @retval EFI_WARN_DELETE_FAILURE The handle was closed but the file was not deleted.
1351 @sa EfiShellCreateFile
1355 EfiShellDeleteFileByName(
1356 IN CONST CHAR16
*FileName
1359 SHELL_FILE_HANDLE FileHandle
;
1363 // get a handle to the file
1365 Status
= EfiShellCreateFile(FileName
,
1368 if (EFI_ERROR(Status
)) {
1372 // now delete the file
1374 return (ShellInfoObject
.NewEfiShellProtocol
->DeleteFile(FileHandle
));
1378 Disables the page break output mode.
1382 EfiShellDisablePageBreak (
1386 ShellInfoObject
.PageBreakEnabled
= FALSE
;
1390 Enables the page break output mode.
1394 EfiShellEnablePageBreak (
1398 ShellInfoObject
.PageBreakEnabled
= TRUE
;
1402 internal worker function to load and run an image via device path.
1404 @param ParentImageHandle A handle of the image that is executing the specified
1406 @param DevicePath device path of the file to execute
1407 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1408 containing the command line. If NULL then the command-
1410 @param Environment Points to a NULL-terminated array of environment
1411 variables with the format 'x=y', where x is the
1412 environment variable name and y is the value. If this
1413 is NULL, then the current shell environment is used.
1414 @param StatusCode Points to the status code returned by the command.
1416 @retval EFI_SUCCESS The command executed successfully. The status code
1417 returned by the command is pointed to by StatusCode.
1418 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1419 @retval EFI_OUT_OF_RESOURCES Out of resources.
1420 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1424 InternalShellExecuteDevicePath(
1425 IN CONST EFI_HANDLE
*ParentImageHandle
,
1426 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
1427 IN CONST CHAR16
*CommandLine OPTIONAL
,
1428 IN CONST CHAR16
**Environment OPTIONAL
,
1429 OUT EFI_STATUS
*StatusCode OPTIONAL
1433 EFI_HANDLE NewHandle
;
1434 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
1435 LIST_ENTRY OrigEnvs
;
1436 EFI_SHELL_PARAMETERS_PROTOCOL ShellParamsProtocol
;
1438 if (ParentImageHandle
== NULL
) {
1439 return (EFI_INVALID_PARAMETER
);
1442 InitializeListHead(&OrigEnvs
);
1447 // Load the image with:
1448 // FALSE - not from boot manager and NULL, 0 being not already in memory
1450 Status
= gBS
->LoadImage(
1453 (EFI_DEVICE_PATH_PROTOCOL
*)DevicePath
,
1458 if (EFI_ERROR(Status
)) {
1459 if (NewHandle
!= NULL
) {
1460 gBS
->UnloadImage(NewHandle
);
1464 Status
= gBS
->OpenProtocol(
1466 &gEfiLoadedImageProtocolGuid
,
1467 (VOID
**)&LoadedImage
,
1470 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
1472 if (!EFI_ERROR(Status
)) {
1473 ASSERT(LoadedImage
->LoadOptionsSize
== 0);
1474 if (CommandLine
!= NULL
) {
1475 LoadedImage
->LoadOptionsSize
= (UINT32
)StrSize(CommandLine
);
1476 LoadedImage
->LoadOptions
= (VOID
*)CommandLine
;
1480 // Save our current environment settings for later restoration if necessary
1482 if (Environment
!= NULL
) {
1483 Status
= GetEnvironmentVariableList(&OrigEnvs
);
1484 if (!EFI_ERROR(Status
)) {
1485 Status
= SetEnvironmentVariables(Environment
);
1490 // Initialize and install a shell parameters protocol on the image.
1492 ShellParamsProtocol
.StdIn
= ShellInfoObject
.NewShellParametersProtocol
->StdIn
;
1493 ShellParamsProtocol
.StdOut
= ShellInfoObject
.NewShellParametersProtocol
->StdOut
;
1494 ShellParamsProtocol
.StdErr
= ShellInfoObject
.NewShellParametersProtocol
->StdErr
;
1495 Status
= UpdateArgcArgv(&ShellParamsProtocol
, CommandLine
, NULL
, NULL
);
1496 ASSERT_EFI_ERROR(Status
);
1497 Status
= gBS
->InstallProtocolInterface(&NewHandle
, &gEfiShellParametersProtocolGuid
, EFI_NATIVE_INTERFACE
, &ShellParamsProtocol
);
1498 ASSERT_EFI_ERROR(Status
);
1500 ///@todo initialize and install ShellInterface protocol on the new image for compatibility if - PcdGetBool(PcdShellSupportOldProtocols)
1503 // now start the image and if the caller wanted the return code pass it to them...
1505 if (!EFI_ERROR(Status
)) {
1506 if (StatusCode
!= NULL
) {
1507 *StatusCode
= gBS
->StartImage(NewHandle
, NULL
, NULL
);
1509 Status
= gBS
->StartImage(NewHandle
, NULL
, NULL
);
1514 // Cleanup (and dont overwrite errors)
1516 if (EFI_ERROR(Status
)) {
1517 gBS
->UninstallProtocolInterface(NewHandle
, &gEfiShellParametersProtocolGuid
, &ShellParamsProtocol
);
1519 Status
= gBS
->UninstallProtocolInterface(NewHandle
, &gEfiShellParametersProtocolGuid
, &ShellParamsProtocol
);
1520 ASSERT_EFI_ERROR(Status
);
1524 if (!IsListEmpty(&OrigEnvs
)) {
1525 if (EFI_ERROR(Status
)) {
1526 SetEnvironmentVariableList(&OrigEnvs
);
1528 Status
= SetEnvironmentVariableList(&OrigEnvs
);
1535 Execute the command line.
1537 This function creates a nested instance of the shell and executes the specified
1538 command (CommandLine) with the specified environment (Environment). Upon return,
1539 the status code returned by the specified command is placed in StatusCode.
1541 If Environment is NULL, then the current environment is used and all changes made
1542 by the commands executed will be reflected in the current environment. If the
1543 Environment is non-NULL, then the changes made will be discarded.
1545 The CommandLine is executed from the current working directory on the current
1548 @param ParentImageHandle A handle of the image that is executing the specified
1550 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1551 containing the command line. If NULL then the command-
1553 @param Environment Points to a NULL-terminated array of environment
1554 variables with the format 'x=y', where x is the
1555 environment variable name and y is the value. If this
1556 is NULL, then the current shell environment is used.
1557 @param StatusCode Points to the status code returned by the command.
1559 @retval EFI_SUCCESS The command executed successfully. The status code
1560 returned by the command is pointed to by StatusCode.
1561 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1562 @retval EFI_OUT_OF_RESOURCES Out of resources.
1563 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1564 @retval EFI_UNSUPPORTED The support level required for this function is not present.
1566 @sa InternalShellExecuteDevicePath
1571 IN EFI_HANDLE
*ParentImageHandle
,
1572 IN CHAR16
*CommandLine OPTIONAL
,
1573 IN CHAR16
**Environment OPTIONAL
,
1574 OUT EFI_STATUS
*StatusCode OPTIONAL
1579 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
1582 if ((PcdGet8(PcdShellSupportLevel
) < 1)) {
1583 return (EFI_UNSUPPORTED
);
1586 DevPath
= AppendDevicePath (ShellInfoObject
.ImageDevPath
, ShellInfoObject
.FileDevPath
);
1589 Temp
= gDevPathToText
->ConvertDevicePathToText(ShellInfoObject
.FileDevPath
, TRUE
, TRUE
);
1591 Temp
= gDevPathToText
->ConvertDevicePathToText(ShellInfoObject
.ImageDevPath
, TRUE
, TRUE
);
1593 Temp
= gDevPathToText
->ConvertDevicePathToText(DevPath
, TRUE
, TRUE
);
1599 ASSERT((Temp
== NULL
&& Size
== 0) || (Temp
!= NULL
));
1600 StrnCatGrow(&Temp
, &Size
, L
"Shell.efi ", 0);
1601 StrnCatGrow(&Temp
, &Size
, CommandLine
, 0);
1603 Status
= InternalShellExecuteDevicePath(
1607 (CONST CHAR16
**)Environment
,
1611 // de-allocate and return
1619 Utility cleanup function for EFI_SHELL_FILE_INFO objects.
1621 1) frees all pointers (non-NULL)
1622 2) Closes the SHELL_FILE_HANDLE
1624 @param FileListNode pointer to the list node to free
1628 InternalFreeShellFileInfoNode(
1629 IN EFI_SHELL_FILE_INFO
*FileListNode
1632 if (FileListNode
->Info
!= NULL
) {
1633 FreePool((VOID
*)FileListNode
->Info
);
1635 if (FileListNode
->FileName
!= NULL
) {
1636 FreePool((VOID
*)FileListNode
->FileName
);
1638 if (FileListNode
->FullName
!= NULL
) {
1639 FreePool((VOID
*)FileListNode
->FullName
);
1641 if (FileListNode
->Handle
!= NULL
) {
1642 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(FileListNode
->Handle
);
1644 FreePool(FileListNode
);
1647 Frees the file list.
1649 This function cleans up the file list and any related data structures. It has no
1650 impact on the files themselves.
1652 @param FileList The file list to free. Type EFI_SHELL_FILE_INFO is
1653 defined in OpenFileList()
1655 @retval EFI_SUCCESS Free the file list successfully.
1656 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1660 EfiShellFreeFileList(
1661 IN EFI_SHELL_FILE_INFO
**FileList
1664 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1666 if (FileList
== NULL
|| *FileList
== NULL
) {
1667 return (EFI_INVALID_PARAMETER
);
1670 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1671 ; !IsListEmpty(&(*FileList
)->Link
)
1672 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1674 RemoveEntryList(&ShellFileListItem
->Link
);
1675 InternalFreeShellFileInfoNode(ShellFileListItem
);
1677 return(EFI_SUCCESS
);
1681 Deletes the duplicate file names files in the given file list.
1683 This function deletes the reduplicate files in the given file list.
1685 @param FileList A pointer to the first entry in the file list.
1687 @retval EFI_SUCCESS Always success.
1688 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1692 EfiShellRemoveDupInFileList(
1693 IN EFI_SHELL_FILE_INFO
**FileList
1696 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1697 EFI_SHELL_FILE_INFO
*ShellFileListItem2
;
1699 if (FileList
== NULL
|| *FileList
== NULL
) {
1700 return (EFI_INVALID_PARAMETER
);
1702 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1703 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1704 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1706 for ( ShellFileListItem2
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1707 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem2
->Link
)
1708 ; ShellFileListItem2
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem2
->Link
)
1710 if (gUnicodeCollation
->StriColl(
1712 (CHAR16
*)ShellFileListItem
->FullName
,
1713 (CHAR16
*)ShellFileListItem2
->FullName
) == 0
1715 RemoveEntryList(&ShellFileListItem2
->Link
);
1716 InternalFreeShellFileInfoNode(ShellFileListItem2
);
1720 return (EFI_SUCCESS
);
1723 Allocates and duplicates a EFI_SHELL_FILE_INFO node.
1725 @param[in] Node The node to copy from.
1726 @param[in] Save TRUE to set Node->Handle to NULL, FALSE otherwise.
1728 @retval NULL a memory allocation error ocurred
1729 @return != NULL a pointer to the new node
1731 EFI_SHELL_FILE_INFO
*
1733 InternalDuplicateShellFileInfo(
1734 IN EFI_SHELL_FILE_INFO
*Node
,
1738 EFI_SHELL_FILE_INFO
*NewNode
;
1740 NewNode
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1741 if (NewNode
== NULL
) {
1744 NewNode
->FullName
= AllocateZeroPool(StrSize(Node
->FullName
));
1746 NewNode
->FileName
= AllocateZeroPool(StrSize(Node
->FileName
));
1747 NewNode
->Info
= AllocateZeroPool((UINTN
)Node
->Info
->Size
);
1748 if ( NewNode
->FullName
== NULL
1749 || NewNode
->FileName
== NULL
1750 || NewNode
->Info
== NULL
1754 NewNode
->Status
= Node
->Status
;
1755 NewNode
->Handle
= Node
->Handle
;
1757 Node
->Handle
= NULL
;
1759 StrCpy((CHAR16
*)NewNode
->FullName
, Node
->FullName
);
1760 StrCpy((CHAR16
*)NewNode
->FileName
, Node
->FileName
);
1761 CopyMem(NewNode
->Info
, Node
->Info
, (UINTN
)Node
->Info
->Size
);
1767 Allocates and populates a EFI_SHELL_FILE_INFO structure. if any memory operation
1768 failed it will return NULL.
1770 @param[in] BasePath the Path to prepend onto filename for FullPath
1771 @param[in] Status Status member initial value.
1772 @param[in] FullName FullName member initial value.
1773 @param[in] FileName FileName member initial value.
1774 @param[in] Handle Handle member initial value.
1775 @param[in] Info Info struct to copy.
1777 @retval NULL An error ocurred.
1778 @return a pointer to the newly allocated structure.
1780 EFI_SHELL_FILE_INFO
*
1782 CreateAndPopulateShellFileInfo(
1783 IN CONST CHAR16
*BasePath
,
1784 IN CONST EFI_STATUS Status
,
1785 IN CONST CHAR16
*FullName
,
1786 IN CONST CHAR16
*FileName
,
1787 IN CONST SHELL_FILE_HANDLE Handle
,
1788 IN CONST EFI_FILE_INFO
*Info
1791 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1798 ShellFileListItem
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1799 if (ShellFileListItem
== NULL
) {
1803 ShellFileListItem
->Info
= AllocateZeroPool((UINTN
)Info
->Size
);
1804 if (ShellFileListItem
->Info
== NULL
) {
1805 FreePool(ShellFileListItem
);
1808 CopyMem(ShellFileListItem
->Info
, Info
, (UINTN
)Info
->Size
);
1810 ShellFileListItem
->Info
= NULL
;
1812 if (FileName
!= NULL
) {
1813 ASSERT(TempString
== NULL
);
1814 ShellFileListItem
->FileName
= StrnCatGrow(&TempString
, 0, FileName
, 0);
1815 if (ShellFileListItem
->FileName
== NULL
) {
1816 FreePool(ShellFileListItem
->Info
);
1817 FreePool(ShellFileListItem
);
1821 ShellFileListItem
->FileName
= NULL
;
1825 if (BasePath
!= NULL
) {
1826 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
1827 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
1828 if (TempString
== NULL
) {
1829 FreePool((VOID
*)ShellFileListItem
->FileName
);
1830 FreePool(ShellFileListItem
->Info
);
1831 FreePool(ShellFileListItem
);
1835 if (ShellFileListItem
->FileName
!= NULL
) {
1836 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
1837 TempString
= StrnCatGrow(&TempString
, &Size
, ShellFileListItem
->FileName
, 0);
1838 if (TempString
== NULL
) {
1839 FreePool((VOID
*)ShellFileListItem
->FileName
);
1840 FreePool(ShellFileListItem
->Info
);
1841 FreePool(ShellFileListItem
);
1846 ShellFileListItem
->FullName
= TempString
;
1847 ShellFileListItem
->Status
= Status
;
1848 ShellFileListItem
->Handle
= Handle
;
1850 return (ShellFileListItem
);
1854 Find all files in a specified directory.
1856 @param FileDirHandle Handle of the directory to search.
1857 @param FileList On return, points to the list of files in the directory
1858 or NULL if there are no files in the directory.
1860 @retval EFI_SUCCESS File information was returned successfully.
1861 @retval EFI_VOLUME_CORRUPTED The file system structures have been corrupted.
1862 @retval EFI_DEVICE_ERROR The device reported an error.
1863 @retval EFI_NO_MEDIA The device media is not present.
1864 @retval EFI_INVALID_PARAMETER The FileDirHandle was not a directory.
1865 @return An error from FileHandleGetFileName().
1869 EfiShellFindFilesInDir(
1870 IN SHELL_FILE_HANDLE FileDirHandle
,
1871 OUT EFI_SHELL_FILE_INFO
**FileList
1874 EFI_SHELL_FILE_INFO
*ShellFileList
;
1875 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1876 EFI_FILE_INFO
*FileInfo
;
1884 Status
= FileHandleGetFileName(FileDirHandle
, &BasePath
);
1885 if (EFI_ERROR(Status
)) {
1889 if (ShellFileHandleGetPath(FileDirHandle
) != NULL
) {
1892 TempString
= StrnCatGrow(&TempString
, &Size
, ShellFileHandleGetPath(FileDirHandle
), 0);
1893 if (TempString
== NULL
) {
1894 return (EFI_OUT_OF_RESOURCES
);
1896 TempSpot
= StrStr(TempString
, L
";");
1898 if (TempSpot
!= NULL
) {
1899 *TempSpot
= CHAR_NULL
;
1902 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
1903 if (TempString
== NULL
) {
1904 return (EFI_OUT_OF_RESOURCES
);
1906 BasePath
= TempString
;
1910 ShellFileList
= NULL
;
1911 ShellFileListItem
= NULL
;
1913 Status
= EFI_SUCCESS
;
1916 for ( Status
= FileHandleFindFirstFile(FileDirHandle
, &FileInfo
)
1917 ; !EFI_ERROR(Status
) && !NoFile
1918 ; Status
= FileHandleFindNextFile(FileDirHandle
, FileInfo
, &NoFile
)
1923 // allocate a new EFI_SHELL_FILE_INFO and populate it...
1925 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
1926 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
1927 TempString
= StrnCatGrow(&TempString
, &Size
, FileInfo
->FileName
, 0);
1928 ShellFileListItem
= CreateAndPopulateShellFileInfo(
1930 EFI_SUCCESS
, // success since we didnt fail to open it...
1933 NULL
, // no handle since not open
1936 if (ShellFileList
== NULL
) {
1937 ShellFileList
= (EFI_SHELL_FILE_INFO
*)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1938 ASSERT(ShellFileList
!= NULL
);
1939 InitializeListHead(&ShellFileList
->Link
);
1941 InsertTailList(&ShellFileList
->Link
, &ShellFileListItem
->Link
);
1943 if (EFI_ERROR(Status
)) {
1944 EfiShellFreeFileList(&ShellFileList
);
1947 *FileList
= ShellFileList
;
1949 SHELL_FREE_NON_NULL(BasePath
);
1954 Updates a file name to be preceeded by the mapped drive name
1956 @param[in] BasePath the Mapped drive name to prepend
1957 @param[in, out] Path pointer to pointer to the file name to update.
1960 @retval EFI_OUT_OF_RESOURCES
1965 IN CONST CHAR16
*BasePath
,
1966 IN OUT CHAR16
**Path
1975 ASSERT(Path
!= NULL
);
1976 ASSERT(*Path
!= NULL
);
1977 ASSERT(BasePath
!= NULL
);
1980 // convert a local path to an absolute path
1982 if (StrStr(*Path
, L
":") == NULL
) {
1983 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
1984 StrnCatGrow(&Path2
, &Path2Size
, BasePath
, 0);
1985 if (Path2
== NULL
) {
1986 return (EFI_OUT_OF_RESOURCES
);
1988 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
1989 StrnCatGrow(&Path2
, &Path2Size
, (*Path
)[0] == L
'\\'?(*Path
) + 1 :*Path
, 0);
1990 if (Path2
== NULL
) {
1991 return (EFI_OUT_OF_RESOURCES
);
1998 return (EFI_SUCCESS
);
2002 If FileHandle is a directory then the function reads from FileHandle and reads in
2003 each of the FileInfo structures. If one of them matches the Pattern's first
2004 "level" then it opens that handle and calls itself on that handle.
2006 If FileHandle is a file and matches all of the remaining Pattern (which would be
2007 on its last node), then add a EFI_SHELL_FILE_INFO object for this file to fileList.
2009 Upon a EFI_SUCCESS return fromt he function any the caller is responsible to call
2010 FreeFileList with FileList.
2012 @param[in] FilePattern The FilePattern to check against.
2013 @param[in] UnicodeCollation The pointer to EFI_UNICODE_COLLATION_PROTOCOL structure
2014 @param[in] FileHandle The FileHandle to start with
2015 @param[in, out] FileList pointer to pointer to list of found files.
2016 @param[in] ParentNode The node for the parent. Same file as identified by HANDLE.
2017 @param[in] MapName The file system name this file is on.
2019 @retval EFI_SUCCESS all files were found and the FileList contains a list.
2020 @retval EFI_NOT_FOUND no files were found
2021 @retval EFI_OUT_OF_RESOURCES a memory allocation failed
2026 IN CONST CHAR16
*FilePattern
,
2027 IN EFI_UNICODE_COLLATION_PROTOCOL
*UnicodeCollation
,
2028 IN SHELL_FILE_HANDLE FileHandle
,
2029 IN OUT EFI_SHELL_FILE_INFO
**FileList
,
2030 IN CONST EFI_SHELL_FILE_INFO
*ParentNode OPTIONAL
,
2031 IN CONST CHAR16
*MapName
2035 CONST CHAR16
*NextFilePatternStart
;
2036 CHAR16
*CurrentFilePattern
;
2037 EFI_SHELL_FILE_INFO
*ShellInfo
;
2038 EFI_SHELL_FILE_INFO
*ShellInfoNode
;
2039 EFI_SHELL_FILE_INFO
*NewShellNode
;
2041 CHAR16
*NewFullName
;
2044 if ( FilePattern
== NULL
2045 || UnicodeCollation
== NULL
2048 return (EFI_INVALID_PARAMETER
);
2051 CurrentFilePattern
= NULL
;
2053 if (*FilePattern
== L
'\\') {
2057 for( NextFilePatternStart
= FilePattern
2058 ; *NextFilePatternStart
!= CHAR_NULL
&& *NextFilePatternStart
!= L
'\\'
2059 ; NextFilePatternStart
++);
2061 CurrentFilePattern
= AllocateZeroPool((NextFilePatternStart
-FilePattern
+1)*sizeof(CHAR16
));
2062 ASSERT(CurrentFilePattern
!= NULL
);
2063 StrnCpy(CurrentFilePattern
, FilePattern
, NextFilePatternStart
-FilePattern
);
2065 if (CurrentFilePattern
[0] == CHAR_NULL
2066 &&NextFilePatternStart
[0] == CHAR_NULL
2069 // Add the current parameter FileHandle to the list, then end...
2071 if (ParentNode
== NULL
) {
2072 Status
= EFI_INVALID_PARAMETER
;
2074 NewShellNode
= InternalDuplicateShellFileInfo((EFI_SHELL_FILE_INFO
*)ParentNode
, TRUE
);
2075 if (NewShellNode
== NULL
) {
2076 Status
= EFI_OUT_OF_RESOURCES
;
2078 NewShellNode
->Handle
= NULL
;
2079 if (*FileList
== NULL
) {
2080 *FileList
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2081 InitializeListHead(&((*FileList
)->Link
));
2085 // Add to the returning to use list
2087 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
2089 Status
= EFI_SUCCESS
;
2093 Status
= EfiShellFindFilesInDir(FileHandle
, &ShellInfo
);
2095 if (!EFI_ERROR(Status
)){
2096 if (StrStr(NextFilePatternStart
, L
"\\") != NULL
){
2101 for ( ShellInfoNode
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&ShellInfo
->Link
)
2102 ; !IsNull (&ShellInfo
->Link
, &ShellInfoNode
->Link
)
2103 ; ShellInfoNode
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&ShellInfo
->Link
, &ShellInfoNode
->Link
)
2105 if (UnicodeCollation
->MetaiMatch(UnicodeCollation
, (CHAR16
*)ShellInfoNode
->FileName
, CurrentFilePattern
)){
2106 if (ShellInfoNode
->FullName
!= NULL
&& StrStr(ShellInfoNode
->FullName
, L
":") == NULL
) {
2107 Size
= StrSize(ShellInfoNode
->FullName
);
2108 Size
+= StrSize(MapName
) + sizeof(CHAR16
);
2109 NewFullName
= AllocateZeroPool(Size
);
2110 if (NewFullName
== NULL
) {
2111 Status
= EFI_OUT_OF_RESOURCES
;
2113 StrCpy(NewFullName
, MapName
);
2114 StrCat(NewFullName
, ShellInfoNode
->FullName
+1);
2115 FreePool((VOID
*)ShellInfoNode
->FullName
);
2116 ShellInfoNode
->FullName
= NewFullName
;
2119 if (Directory
&& !EFI_ERROR(Status
) && ShellInfoNode
->FullName
!= NULL
&& ShellInfoNode
->FileName
!= NULL
){
2121 // should be a directory
2125 // don't open the . and .. directories
2127 if ( (StrCmp(ShellInfoNode
->FileName
, L
".") != 0)
2128 && (StrCmp(ShellInfoNode
->FileName
, L
"..") != 0)
2133 if (EFI_ERROR(Status
)) {
2137 // Open the directory since we need that handle in the next recursion.
2139 ShellInfoNode
->Status
= EfiShellOpenFileByName (ShellInfoNode
->FullName
, &ShellInfoNode
->Handle
, EFI_FILE_MODE_READ
);
2142 // recurse with the next part of the pattern
2144 Status
= ShellSearchHandle(NextFilePatternStart
, UnicodeCollation
, ShellInfoNode
->Handle
, FileList
, ShellInfoNode
, MapName
);
2146 } else if (!EFI_ERROR(Status
)) {
2152 // copy the information we need into a new Node
2154 NewShellNode
= InternalDuplicateShellFileInfo(ShellInfoNode
, FALSE
);
2155 ASSERT(NewShellNode
!= NULL
);
2156 if (NewShellNode
== NULL
) {
2157 Status
= EFI_OUT_OF_RESOURCES
;
2159 if (*FileList
== NULL
) {
2160 *FileList
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2161 InitializeListHead(&((*FileList
)->Link
));
2165 // Add to the returning to use list
2167 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
2170 if (EFI_ERROR(Status
)) {
2174 if (EFI_ERROR(Status
)) {
2175 EfiShellFreeFileList(&ShellInfo
);
2177 Status
= EfiShellFreeFileList(&ShellInfo
);
2182 FreePool(CurrentFilePattern
);
2187 Find files that match a specified pattern.
2189 This function searches for all files and directories that match the specified
2190 FilePattern. The FilePattern can contain wild-card characters. The resulting file
2191 information is placed in the file list FileList.
2193 Wildcards are processed
2194 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1.
2196 The files in the file list are not opened. The OpenMode field is set to 0 and the FileInfo
2197 field is set to NULL.
2199 if *FileList is not NULL then it must be a pre-existing and properly initialized list.
2201 @param FilePattern Points to a NULL-terminated shell file path, including wildcards.
2202 @param FileList On return, points to the start of a file list containing the names
2203 of all matching files or else points to NULL if no matching files
2204 were found. only on a EFI_SUCCESS return will; this be non-NULL.
2206 @retval EFI_SUCCESS Files found. FileList is a valid list.
2207 @retval EFI_NOT_FOUND No files found.
2208 @retval EFI_NO_MEDIA The device has no media
2209 @retval EFI_DEVICE_ERROR The device reported an error
2210 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted
2215 IN CONST CHAR16
*FilePattern
,
2216 OUT EFI_SHELL_FILE_INFO
**FileList
2220 CHAR16
*PatternCopy
;
2221 CHAR16
*PatternCurrentLocation
;
2222 EFI_DEVICE_PATH_PROTOCOL
*RootDevicePath
;
2223 SHELL_FILE_HANDLE RootFileHandle
;
2227 if ( FilePattern
== NULL
2229 || StrStr(FilePattern
, L
":") == NULL
2231 return (EFI_INVALID_PARAMETER
);
2233 Status
= EFI_SUCCESS
;
2234 RootDevicePath
= NULL
;
2235 RootFileHandle
= NULL
;
2237 PatternCopy
= AllocateZeroPool(StrSize(FilePattern
));
2238 if (PatternCopy
== NULL
) {
2239 return (EFI_OUT_OF_RESOURCES
);
2241 StrCpy(PatternCopy
, FilePattern
);
2243 PatternCopy
= PathCleanUpDirectories(PatternCopy
);
2245 Count
= StrStr(PatternCopy
, L
":") - PatternCopy
;
2248 ASSERT(MapName
== NULL
);
2249 MapName
= StrnCatGrow(&MapName
, NULL
, PatternCopy
, Count
);
2250 if (MapName
== NULL
) {
2251 Status
= EFI_OUT_OF_RESOURCES
;
2254 if (!EFI_ERROR(Status
)) {
2255 RootDevicePath
= EfiShellGetDevicePathFromFilePath(PatternCopy
);
2256 if (RootDevicePath
== NULL
) {
2257 Status
= EFI_INVALID_PARAMETER
;
2259 Status
= EfiShellOpenRoot(RootDevicePath
, &RootFileHandle
);
2260 if (!EFI_ERROR(Status
)) {
2261 for ( PatternCurrentLocation
= PatternCopy
2262 ; *PatternCurrentLocation
!= ':'
2263 ; PatternCurrentLocation
++);
2264 PatternCurrentLocation
++;
2265 Status
= ShellSearchHandle(PatternCurrentLocation
, gUnicodeCollation
, RootFileHandle
, FileList
, NULL
, MapName
);
2267 FreePool(RootDevicePath
);
2271 SHELL_FREE_NON_NULL(PatternCopy
);
2272 SHELL_FREE_NON_NULL(MapName
);
2278 Opens the files that match the path specified.
2280 This function opens all of the files specified by Path. Wildcards are processed
2281 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1. Each
2282 matching file has an EFI_SHELL_FILE_INFO structure created in a linked list.
2284 @param Path A pointer to the path string.
2285 @param OpenMode Specifies the mode used to open each file, EFI_FILE_MODE_READ or
2286 EFI_FILE_MODE_WRITE.
2287 @param FileList Points to the start of a list of files opened.
2289 @retval EFI_SUCCESS Create the file list successfully.
2290 @return Others Can't create the file list.
2294 EfiShellOpenFileList(
2297 IN OUT EFI_SHELL_FILE_INFO
**FileList
2301 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
2304 CONST CHAR16
*CurDir
;
2307 PathCleanUpDirectories(Path
);
2312 if (FileList
== NULL
|| *FileList
== NULL
) {
2313 return (EFI_INVALID_PARAMETER
);
2316 if (*Path
== L
'.' && *(Path
+1) == L
'\\') {
2321 // convert a local path to an absolute path
2323 if (StrStr(Path
, L
":") == NULL
) {
2324 CurDir
= EfiShellGetCurDir(NULL
);
2325 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2326 StrnCatGrow(&Path2
, &Path2Size
, CurDir
, 0);
2327 if (*Path
== L
'\\') {
2329 while (PathRemoveLastItem(Path2
)) ;
2331 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2332 StrnCatGrow(&Path2
, &Path2Size
, Path
, 0);
2334 ASSERT(Path2
== NULL
);
2335 StrnCatGrow(&Path2
, NULL
, Path
, 0);
2338 PathCleanUpDirectories (Path2
);
2343 Status
= EfiShellFindFiles(Path2
, FileList
);
2347 if (EFI_ERROR(Status
)) {
2353 // We had no errors so open all the files (that are not already opened...)
2355 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
2356 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2357 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2359 if (ShellFileListItem
->Status
== 0 && ShellFileListItem
->Handle
== NULL
) {
2360 ShellFileListItem
->Status
= EfiShellOpenFileByName (ShellFileListItem
->FullName
, &ShellFileListItem
->Handle
, OpenMode
);
2366 return (EFI_NOT_FOUND
);
2368 return(EFI_SUCCESS
);
2372 This function updated with errata.
2374 Gets either a single or list of environment variables.
2376 If name is not NULL then this function returns the current value of the specified
2377 environment variable.
2379 If Name is NULL, then a list of all environment variable names is returned. Each is a
2380 NULL terminated string with a double NULL terminating the list.
2382 @param Name A pointer to the environment variable name. If
2383 Name is NULL, then the function will return all
2384 of the defined shell environment variables. In
2385 the case where multiple environment variables are
2386 being returned, each variable will be terminated by
2387 a NULL, and the list will be terminated by a double
2390 @return !=NULL A pointer to the returned string.
2391 The returned pointer does not need to be freed by the caller.
2393 @retval NULL The environment variable doesn't exist or there are
2394 no environment variables.
2399 IN CONST CHAR16
*Name
2407 CHAR16
*CurrentWriteLocation
;
2414 // Get all our environment variables
2416 InitializeListHead(&List
);
2417 Status
= GetEnvironmentVariableList(&List
);
2418 if (EFI_ERROR(Status
)){
2423 // Build the semi-colon delimited list. (2 passes)
2425 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&List
)
2426 ; !IsNull(&List
, &Node
->Link
)
2427 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&List
, &Node
->Link
)
2429 ASSERT(Node
->Key
!= NULL
);
2430 Size
+= StrSize(Node
->Key
);
2433 Size
+= 2*sizeof(CHAR16
);
2435 Buffer
= AllocateZeroPool(Size
);
2436 if (Buffer
== NULL
) {
2437 if (!IsListEmpty (&List
)) {
2438 FreeEnvironmentVariableList(&List
);
2442 CurrentWriteLocation
= (CHAR16
*)Buffer
;
2444 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&List
)
2445 ; !IsNull(&List
, &Node
->Link
)
2446 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&List
, &Node
->Link
)
2448 ASSERT(Node
->Key
!= NULL
);
2449 StrCpy(CurrentWriteLocation
, Node
->Key
);
2450 CurrentWriteLocation
+= StrLen(CurrentWriteLocation
) + 1;
2456 if (!IsListEmpty (&List
)) {
2457 FreeEnvironmentVariableList(&List
);
2461 // We are doing a specific environment variable
2465 // get the size we need for this EnvVariable
2467 Status
= SHELL_GET_ENVIRONMENT_VARIABLE(Name
, &Size
, Buffer
);
2468 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2470 // Allocate the space and recall the get function
2472 Buffer
= AllocateZeroPool(Size
);
2473 ASSERT(Buffer
!= NULL
);
2474 Status
= SHELL_GET_ENVIRONMENT_VARIABLE(Name
, &Size
, Buffer
);
2477 // we didnt get it (might not exist)
2478 // free the memory if we allocated any and return NULL
2480 if (EFI_ERROR(Status
)) {
2481 if (Buffer
!= NULL
) {
2489 // return the buffer
2491 return (AddBufferToFreeList(Buffer
));
2495 Internal variable setting function. Allows for setting of the read only variables.
2497 @param Name Points to the NULL-terminated environment variable name.
2498 @param Value Points to the NULL-terminated environment variable value. If the value is an
2499 empty string then the environment variable is deleted.
2500 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2502 @retval EFI_SUCCESS The environment variable was successfully updated.
2506 InternalEfiShellSetEnv(
2507 IN CONST CHAR16
*Name
,
2508 IN CONST CHAR16
*Value
,
2512 if (Value
== NULL
|| StrLen(Value
) == 0) {
2513 return (SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
));
2515 SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
);
2517 return (SHELL_SET_ENVIRONMENT_VARIABLE_V(Name
, StrSize(Value
), Value
));
2519 return (SHELL_SET_ENVIRONMENT_VARIABLE_NV(Name
, StrSize(Value
), Value
));
2525 Sets the environment variable.
2527 This function changes the current value of the specified environment variable. If the
2528 environment variable exists and the Value is an empty string, then the environment
2529 variable is deleted. If the environment variable exists and the Value is not an empty
2530 string, then the value of the environment variable is changed. If the environment
2531 variable does not exist and the Value is an empty string, there is no action. If the
2532 environment variable does not exist and the Value is a non-empty string, then the
2533 environment variable is created and assigned the specified value.
2535 For a description of volatile and non-volatile environment variables, see UEFI Shell
2536 2.0 specification section 3.6.1.
2538 @param Name Points to the NULL-terminated environment variable name.
2539 @param Value Points to the NULL-terminated environment variable value. If the value is an
2540 empty string then the environment variable is deleted.
2541 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2543 @retval EFI_SUCCESS The environment variable was successfully updated.
2548 IN CONST CHAR16
*Name
,
2549 IN CONST CHAR16
*Value
,
2553 if (Name
== NULL
|| *Name
== CHAR_NULL
) {
2554 return (EFI_INVALID_PARAMETER
);
2557 // Make sure we dont 'set' a predefined read only variable
2559 if (gUnicodeCollation
->StriColl(
2563 ||gUnicodeCollation
->StriColl(
2567 ||gUnicodeCollation
->StriColl(
2571 ||gUnicodeCollation
->StriColl(
2574 L
"uefishellsupport") == 0
2575 ||gUnicodeCollation
->StriColl(
2578 L
"uefishellversion") == 0
2579 ||gUnicodeCollation
->StriColl(
2582 L
"uefiversion") == 0
2584 return (EFI_INVALID_PARAMETER
);
2586 return (InternalEfiShellSetEnv(Name
, Value
, Volatile
));
2590 Returns the current directory on the specified device.
2592 If FileSystemMapping is NULL, it returns the current working directory. If the
2593 FileSystemMapping is not NULL, it returns the current directory associated with the
2594 FileSystemMapping. In both cases, the returned name includes the file system
2595 mapping (i.e. fs0:\current-dir).
2597 @param FileSystemMapping A pointer to the file system mapping. If NULL,
2598 then the current working directory is returned.
2600 @retval !=NULL The current directory.
2601 @retval NULL Current directory does not exist.
2606 IN CONST CHAR16
*FileSystemMapping OPTIONAL
2609 CHAR16
*PathToReturn
;
2611 SHELL_MAP_LIST
*MapListItem
;
2612 if (!IsListEmpty(&gShellMapList
.Link
)) {
2614 // if parameter is NULL, use current
2616 if (FileSystemMapping
== NULL
) {
2617 return (EfiShellGetEnv(L
"cwd"));
2620 PathToReturn
= NULL
;
2621 MapListItem
= ShellCommandFindMapItem(FileSystemMapping
);
2622 if (MapListItem
!= NULL
) {
2623 ASSERT((PathToReturn
== NULL
&& Size
== 0) || (PathToReturn
!= NULL
));
2624 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->MapName
, 0);
2625 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
2628 return (AddBufferToFreeList(PathToReturn
));
2635 Changes the current directory on the specified device.
2637 If the FileSystem is NULL, and the directory Dir does not contain a file system's
2638 mapped name, this function changes the current working directory.
2640 If the FileSystem is NULL and the directory Dir contains a mapped name, then the
2641 current file system and the current directory on that file system are changed.
2643 If FileSystem is NULL, and Dir is not NULL, then this changes the current working file
2646 If FileSystem is not NULL and Dir is not NULL, then this function changes the current
2647 directory on the specified file system.
2649 If the current working directory or the current working file system is changed then the
2650 %cwd% environment variable will be updated
2652 @param FileSystem A pointer to the file system's mapped name. If NULL, then the current working
2653 directory is changed.
2654 @param Dir Points to the NULL-terminated directory on the device specified by FileSystem.
2656 @retval EFI_SUCCESS The operation was sucessful
2657 @retval EFI_NOT_FOUND The file system could not be found
2662 IN CONST CHAR16
*FileSystem OPTIONAL
,
2663 IN CONST CHAR16
*Dir
2667 SHELL_MAP_LIST
*MapListItem
;
2671 CHAR16
*DirectoryName
;
2678 DirectoryName
= NULL
;
2680 if ((FileSystem
== NULL
&& Dir
== NULL
) || Dir
== NULL
) {
2681 return (EFI_INVALID_PARAMETER
);
2684 if (IsListEmpty(&gShellMapList
.Link
)){
2685 return (EFI_NOT_FOUND
);
2688 DirectoryName
= StrnCatGrow(&DirectoryName
, NULL
, Dir
, 0);
2689 ASSERT(DirectoryName
!= NULL
);
2691 PathCleanUpDirectories(DirectoryName
);
2693 if (FileSystem
== NULL
) {
2695 // determine the file system mapping to use
2697 if (StrStr(DirectoryName
, L
":") != NULL
) {
2698 ASSERT(MapName
== NULL
);
2699 MapName
= StrnCatGrow(&MapName
, NULL
, DirectoryName
, (StrStr(DirectoryName
, L
":")-DirectoryName
+1));
2702 // find the file system mapping's entry in the list
2705 if (MapName
!= NULL
) {
2706 MapListItem
= ShellCommandFindMapItem(MapName
);
2709 // make that the current file system mapping
2711 if (MapListItem
!= NULL
) {
2712 gShellCurDir
= MapListItem
;
2715 MapListItem
= gShellCurDir
;
2718 if (MapListItem
== NULL
) {
2719 return (EFI_NOT_FOUND
);
2723 // now update the MapListItem's current directory
2725 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& DirectoryName
[StrLen(DirectoryName
) - 1] != L
':') {
2726 FreePool(MapListItem
->CurrentDirectoryPath
);
2727 MapListItem
->CurrentDirectoryPath
= NULL
;
2729 if (MapName
!= NULL
) {
2730 TempLen
= StrLen(MapName
);
2731 if (TempLen
!= StrLen(DirectoryName
)) {
2732 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2733 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
+StrLen(MapName
), 0);
2736 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2737 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
2739 if ((MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] != L
'\\') || (MapListItem
->CurrentDirectoryPath
== NULL
)) {
2740 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2741 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2745 // cant have a mapping in the directory...
2747 if (StrStr(DirectoryName
, L
":") != NULL
) {
2748 return (EFI_INVALID_PARAMETER
);
2751 // FileSystem != NULL
2753 MapListItem
= ShellCommandFindMapItem(FileSystem
);
2754 if (MapListItem
== NULL
) {
2755 return (EFI_INVALID_PARAMETER
);
2757 // gShellCurDir = MapListItem;
2758 if (DirectoryName
!= NULL
) {
2760 // change current dir on that file system
2763 if (MapListItem
->CurrentDirectoryPath
!= NULL
) {
2764 FreePool(MapListItem
->CurrentDirectoryPath
);
2765 DEBUG_CODE(MapListItem
->CurrentDirectoryPath
= NULL
;);
2767 // ASSERT((MapListItem->CurrentDirectoryPath == NULL && Size == 0) || (MapListItem->CurrentDirectoryPath != NULL));
2768 // MapListItem->CurrentDirectoryPath = StrnCatGrow(&MapListItem->CurrentDirectoryPath, &Size, FileSystem, 0);
2769 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2770 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2771 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2772 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
2773 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] != L
'\\') {
2774 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2775 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2780 // if updated the current directory then update the environment variable
2782 if (MapListItem
== gShellCurDir
) {
2784 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
2785 StrnCatGrow(&TempString
, &Size
, MapListItem
->MapName
, 0);
2786 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
2787 StrnCatGrow(&TempString
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
2788 Status
= InternalEfiShellSetEnv(L
"cwd", TempString
, TRUE
);
2789 FreePool(TempString
);
2792 return(EFI_SUCCESS
);
2796 Return help information about a specific command.
2798 This function returns the help information for the specified command. The help text
2799 can be internal to the shell or can be from a UEFI Shell manual page.
2801 If Sections is specified, then each section name listed will be compared in a casesensitive
2802 manner, to the section names described in Appendix B. If the section exists,
2803 it will be appended to the returned help text. If the section does not exist, no
2804 information will be returned. If Sections is NULL, then all help text information
2805 available will be returned.
2807 @param Command Points to the NULL-terminated UEFI Shell command name.
2808 @param Sections Points to the NULL-terminated comma-delimited
2809 section names to return. If NULL, then all
2810 sections will be returned.
2811 @param HelpText On return, points to a callee-allocated buffer
2812 containing all specified help text.
2814 @retval EFI_SUCCESS The help text was returned.
2815 @retval EFI_OUT_OF_RESOURCES The necessary buffer could not be allocated to hold the
2817 @retval EFI_INVALID_PARAMETER HelpText is NULL
2818 @retval EFI_NOT_FOUND There is no help text available for Command.
2822 EfiShellGetHelpText(
2823 IN CONST CHAR16
*Command
,
2824 IN CONST CHAR16
*Sections OPTIONAL
,
2825 OUT CHAR16
**HelpText
2828 CONST CHAR16
*ManFileName
;
2830 ASSERT(HelpText
!= NULL
);
2832 ManFileName
= ShellCommandGetManFileNameHandler(Command
);
2834 if (ManFileName
!= NULL
) {
2835 return (ProcessManFile(ManFileName
, Command
, Sections
, NULL
, HelpText
));
2837 return (ProcessManFile(Command
, Command
, Sections
, NULL
, HelpText
));
2842 Gets the enable status of the page break output mode.
2844 User can use this function to determine current page break mode.
2846 @retval TRUE The page break output mode is enabled.
2847 @retval FALSE The page break output mode is disabled.
2851 EfiShellGetPageBreak(
2855 return(ShellInfoObject
.PageBreakEnabled
);
2859 Judges whether the active shell is the root shell.
2861 This function makes the user to know that whether the active Shell is the root shell.
2863 @retval TRUE The active Shell is the root Shell.
2864 @retval FALSE The active Shell is NOT the root Shell.
2868 EfiShellIsRootShell(
2872 return(ShellInfoObject
.RootShellInstance
);
2876 function to return a semi-colon delimeted list of all alias' in the current shell
2878 up to caller to free the memory.
2880 @retval NULL No alias' were found
2881 @retval NULL An error ocurred getting alias'
2882 @return !NULL a list of all alias'
2886 InternalEfiShellGetListAlias(
2894 CHAR16
*VariableName
;
2900 Status
= gRT
->QueryVariableInfo(EFI_VARIABLE_NON_VOLATILE
|EFI_VARIABLE_BOOTSERVICE_ACCESS
, &MaxStorSize
, &RemStorSize
, &MaxVarSize
);
2901 ASSERT_EFI_ERROR(Status
);
2903 VariableName
= AllocateZeroPool((UINTN
)MaxVarSize
);
2907 if (VariableName
== NULL
) {
2911 VariableName
[0] = CHAR_NULL
;
2914 NameSize
= (UINTN
)MaxVarSize
;
2915 Status
= gRT
->GetNextVariableName(&NameSize
, VariableName
, &Guid
);
2916 if (Status
== EFI_NOT_FOUND
){
2919 ASSERT_EFI_ERROR(Status
);
2920 if (EFI_ERROR(Status
)) {
2923 if (CompareGuid(&Guid
, &gShellAliasGuid
)){
2924 Alias
= GetVariable(VariableName
, &gShellAliasGuid
);
2925 ASSERT((RetVal
== NULL
&& RetSize
== 0) || (RetVal
!= NULL
));
2926 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, VariableName
, 0);
2927 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, L
";", 0);
2930 FreePool(VariableName
);
2936 This function returns the command associated with a alias or a list of all
2939 @param[in] Alias Points to the NULL-terminated shell alias.
2940 If this parameter is NULL, then all
2941 aliases will be returned in ReturnedData.
2942 @param[out] Volatile upon return of a single command if TRUE indicates
2943 this is stored in a volatile fashion. FALSE otherwise.
2945 @return If Alias is not NULL, it will return a pointer to
2946 the NULL-terminated command for that alias.
2947 If Alias is NULL, ReturnedData points to a ';'
2948 delimited list of alias (e.g.
2949 ReturnedData = "dir;del;copy;mfp") that is NULL-terminated.
2950 @retval NULL an error ocurred
2951 @retval NULL Alias was not a valid Alias
2956 IN CONST CHAR16
*Alias
,
2957 OUT BOOLEAN
*Volatile OPTIONAL
2965 if (Alias
!= NULL
) {
2966 if (Volatile
== NULL
) {
2967 return (AddBufferToFreeList(GetVariable((CHAR16
*)Alias
, &gShellAliasGuid
)));
2971 Status
= gRT
->GetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
2972 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2973 RetVal
= AllocateZeroPool(RetSize
);
2974 Status
= gRT
->GetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
2976 if (EFI_ERROR(Status
)) {
2977 if (RetVal
!= NULL
) {
2982 if ((EFI_VARIABLE_NON_VOLATILE
& Attribs
) == EFI_VARIABLE_NON_VOLATILE
) {
2988 return (AddBufferToFreeList(RetVal
));
2990 return (AddBufferToFreeList(InternalEfiShellGetListAlias()));
2994 Changes a shell command alias.
2996 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
2998 this function does not check for built in alias'.
3000 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3001 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3002 Command refers to an alias, that alias will be deleted.
3003 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3004 Alias being set will be stored in a non-volatile fashion.
3006 @retval EFI_SUCCESS Alias created or deleted successfully.
3007 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3012 IN CONST CHAR16
*Command
,
3013 IN CONST CHAR16
*Alias
,
3018 // We must be trying to remove one if Alias is NULL
3020 if (Alias
== NULL
) {
3022 // remove an alias (but passed in COMMAND parameter)
3024 return (gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
));
3027 // Add and replace are the same
3030 // We dont check the error return on purpose since the variable may not exist.
3031 gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
);
3033 return (gRT
->SetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, EFI_VARIABLE_BOOTSERVICE_ACCESS
|(Volatile
?0:EFI_VARIABLE_NON_VOLATILE
), StrSize(Command
), (VOID
*)Command
));
3038 Changes a shell command alias.
3040 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3043 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3044 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3045 Command refers to an alias, that alias will be deleted.
3046 @param[in] Replace If TRUE and the alias already exists, then the existing alias will be replaced. If
3047 FALSE and the alias already exists, then the existing alias is unchanged and
3048 EFI_ACCESS_DENIED is returned.
3049 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3050 Alias being set will be stored in a non-volatile fashion.
3052 @retval EFI_SUCCESS Alias created or deleted successfully.
3053 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3054 @retval EFI_ACCESS_DENIED The alias is a built-in alias or already existed and Replace was set to
3060 IN CONST CHAR16
*Command
,
3061 IN CONST CHAR16
*Alias
,
3067 // cant set over a built in alias
3069 if (ShellCommandIsOnAliasList(Alias
==NULL
?Command
:Alias
)) {
3070 return (EFI_ACCESS_DENIED
);
3072 if (Command
== NULL
|| *Command
== CHAR_NULL
|| StrLen(Command
) == 0) {
3073 return (EFI_INVALID_PARAMETER
);
3076 if (EfiShellGetAlias(Command
, NULL
) != NULL
&& !Replace
) {
3077 return (EFI_ACCESS_DENIED
);
3080 return (InternalSetAlias(Command
, Alias
, Volatile
));
3083 // Pure FILE_HANDLE operations are passed to FileHandleLib
3084 // these functions are indicated by the *
3085 EFI_SHELL_PROTOCOL mShellProtocol
= {
3091 EfiShellGetHelpText
,
3092 EfiShellGetDevicePathFromMap
,
3093 EfiShellGetMapFromDevicePath
,
3094 EfiShellGetDevicePathFromFilePath
,
3095 EfiShellGetFilePathFromDevicePath
,
3099 EfiShellOpenFileList
,
3100 EfiShellFreeFileList
,
3101 EfiShellRemoveDupInFileList
,
3102 EfiShellBatchIsActive
,
3103 EfiShellIsRootShell
,
3104 EfiShellEnablePageBreak
,
3105 EfiShellDisablePageBreak
,
3106 EfiShellGetPageBreak
,
3107 EfiShellGetDeviceName
,
3108 (EFI_SHELL_GET_FILE_INFO
)FileHandleGetInfo
, //*
3109 (EFI_SHELL_SET_FILE_INFO
)FileHandleSetInfo
, //*
3110 EfiShellOpenFileByName
,
3113 (EFI_SHELL_READ_FILE
)FileHandleRead
, //*
3114 (EFI_SHELL_WRITE_FILE
)FileHandleWrite
, //*
3115 (EFI_SHELL_DELETE_FILE
)FileHandleDelete
, //*
3116 EfiShellDeleteFileByName
,
3117 (EFI_SHELL_GET_FILE_POSITION
)FileHandleGetPosition
, //*
3118 (EFI_SHELL_SET_FILE_POSITION
)FileHandleSetPosition
, //*
3119 (EFI_SHELL_FLUSH_FILE
)FileHandleFlush
, //*
3121 EfiShellFindFilesInDir
,
3122 (EFI_SHELL_GET_FILE_SIZE
)FileHandleGetSize
, //*
3124 EfiShellOpenRootByHandle
,
3126 SHELL_MAJOR_VERSION
,
3131 Function to create and install on the current handle.
3133 Will overwrite any existing ShellProtocols in the system to be sure that
3134 the current shell is in control.
3136 This must be removed via calling CleanUpShellProtocol().
3138 @param[in, out] NewShell The pointer to the pointer to the structure
3141 @retval EFI_SUCCESS The operation was successful.
3142 @return An error from LocateHandle, CreateEvent, or other core function.
3146 CreatePopulateInstallShellProtocol (
3147 IN OUT EFI_SHELL_PROTOCOL
**NewShell
3153 UINTN HandleCounter
;
3154 SHELL_PROTOCOL_HANDLE_LIST
*OldProtocolNode
;
3156 if (NewShell
== NULL
) {
3157 return (EFI_INVALID_PARAMETER
);
3162 OldProtocolNode
= NULL
;
3163 InitializeListHead(&ShellInfoObject
.OldShellList
.Link
);
3166 // Initialize EfiShellProtocol object...
3168 Status
= gBS
->CreateEvent(0,
3172 &mShellProtocol
.ExecutionBreak
);
3173 if (EFI_ERROR(Status
)) {
3178 // Get the size of the buffer we need.
3180 Status
= gBS
->LocateHandle(ByProtocol
,
3181 &gEfiShellProtocolGuid
,
3185 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3187 // Allocate and recall with buffer of correct size
3189 Buffer
= AllocateZeroPool(BufferSize
);
3190 if (Buffer
== NULL
) {
3191 return (EFI_OUT_OF_RESOURCES
);
3193 Status
= gBS
->LocateHandle(ByProtocol
,
3194 &gEfiShellProtocolGuid
,
3198 if (EFI_ERROR(Status
)) {
3203 // now overwrite each of them, but save the info to restore when we end.
3205 for (HandleCounter
= 0 ; HandleCounter
< (BufferSize
/sizeof(EFI_HANDLE
)) ; HandleCounter
++) {
3206 OldProtocolNode
= AllocateZeroPool(sizeof(SHELL_PROTOCOL_HANDLE_LIST
));
3207 ASSERT(OldProtocolNode
!= NULL
);
3208 Status
= gBS
->OpenProtocol(Buffer
[HandleCounter
],
3209 &gEfiShellProtocolGuid
,
3210 (VOID
**) &(OldProtocolNode
->Interface
),
3213 EFI_OPEN_PROTOCOL_GET_PROTOCOL
3215 if (!EFI_ERROR(Status
)) {
3217 // reinstall over the old one...
3219 OldProtocolNode
->Handle
= Buffer
[HandleCounter
];
3220 Status
= gBS
->ReinstallProtocolInterface(
3221 OldProtocolNode
->Handle
,
3222 &gEfiShellProtocolGuid
,
3223 OldProtocolNode
->Interface
,
3224 (VOID
*)(&mShellProtocol
));
3225 if (!EFI_ERROR(Status
)) {
3227 // we reinstalled sucessfully. log this so we can reverse it later.
3231 // add to the list for subsequent...
3233 InsertTailList(&ShellInfoObject
.OldShellList
.Link
, &OldProtocolNode
->Link
);
3238 } else if (Status
== EFI_NOT_FOUND
) {
3239 ASSERT(IsListEmpty(&ShellInfoObject
.OldShellList
.Link
));
3241 // no one else published yet. just publish it ourselves.
3243 Status
= gBS
->InstallProtocolInterface (
3245 &gEfiShellProtocolGuid
,
3246 EFI_NATIVE_INTERFACE
,
3247 (VOID
*)(&mShellProtocol
));
3250 if (PcdGetBool(PcdShellSupportOldProtocols
)){
3251 ///@todo support ShellEnvironment2
3252 ///@todo do we need to support ShellEnvironment (not ShellEnvironment2) also?
3255 if (!EFI_ERROR(Status
)) {
3256 *NewShell
= &mShellProtocol
;
3262 Opposite of CreatePopulateInstallShellProtocol.
3264 Free all memory and restore the system to the state it was in before calling
3265 CreatePopulateInstallShellProtocol.
3267 @param[in, out] NewShell The pointer to the new shell protocol structure.
3269 @retval EFI_SUCCESS The operation was successful.
3273 CleanUpShellProtocol (
3274 IN OUT EFI_SHELL_PROTOCOL
*NewShell
3278 SHELL_PROTOCOL_HANDLE_LIST
*Node2
;
3279 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3282 // if we need to restore old protocols...
3284 if (!IsListEmpty(&ShellInfoObject
.OldShellList
.Link
)) {
3285 for (Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*)GetFirstNode(&ShellInfoObject
.OldShellList
.Link
)
3286 ; !IsListEmpty (&ShellInfoObject
.OldShellList
.Link
)
3287 ; Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*)GetFirstNode(&ShellInfoObject
.OldShellList
.Link
)
3289 RemoveEntryList(&Node2
->Link
);
3290 Status
= gBS
->ReinstallProtocolInterface(Node2
->Handle
,
3291 &gEfiShellProtocolGuid
,
3298 // no need to restore
3300 Status
= gBS
->UninstallProtocolInterface(gImageHandle
,
3301 &gEfiShellProtocolGuid
,
3304 Status
= gBS
->CloseEvent(NewShell
->ExecutionBreak
);
3305 NewShell
->ExecutionBreak
= NULL
;
3307 Status
= gBS
->OpenProtocol(
3308 gST
->ConsoleInHandle
,
3309 &gEfiSimpleTextInputExProtocolGuid
,
3313 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3315 if (!EFI_ERROR (Status
)) {
3316 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle1
);
3317 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle2
);
3318 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle3
);
3319 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle4
);
3320 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle1
);
3321 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle2
);
3322 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle3
);
3323 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle4
);
3329 Notification function for keystrokes.
3331 @param[in] KeyData The key that was pressed.
3333 @retval EFI_SUCCESS The operation was successful.
3337 NotificationFunction(
3338 IN EFI_KEY_DATA
*KeyData
3341 // ShellPrintEx(-1,-1,L" <Notify> ");
3342 if ((KeyData
->Key
.UnicodeChar
== L
'c' || KeyData
->Key
.UnicodeChar
== 3) &&
3343 (KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
) || KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
))
3345 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3346 return (EFI_UNSUPPORTED
);
3348 return (gBS
->SignalEvent(ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
));
3349 } else if ((KeyData
->Key
.UnicodeChar
== L
's') &&
3350 (KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
) || KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
))
3352 ShellInfoObject
.HaltOutput
= TRUE
;
3354 return (EFI_SUCCESS
);
3358 Function to start monitoring for CTRL-C using SimpleTextInputEx. This
3359 feature's enabled state was not known when the shell initially launched.
3361 @retval EFI_SUCCESS The feature is enabled.
3362 @retval EFI_OUT_OF_RESOURCES There is not enough mnemory available.
3366 InernalEfiShellStartMonitor(
3370 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3371 EFI_KEY_DATA KeyData
;
3374 Status
= gBS
->OpenProtocol(
3375 gST
->ConsoleInHandle
,
3376 &gEfiSimpleTextInputExProtocolGuid
,
3380 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3381 if (EFI_ERROR(Status
)) {
3386 STRING_TOKEN (STR_SHELL_NO_IN_EX
),
3387 ShellInfoObject
.HiiHandle
);
3388 return (EFI_SUCCESS
);
3391 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3392 return (EFI_UNSUPPORTED
);
3395 KeyData
.KeyState
.KeyToggleState
= 0;
3396 KeyData
.Key
.ScanCode
= 0;
3397 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3398 KeyData
.Key
.UnicodeChar
= L
'c';
3400 Status
= SimpleEx
->RegisterKeyNotify(
3403 NotificationFunction
,
3404 &ShellInfoObject
.CtrlCNotifyHandle1
);
3406 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3407 if (!EFI_ERROR(Status
)) {
3408 Status
= SimpleEx
->RegisterKeyNotify(
3411 NotificationFunction
,
3412 &ShellInfoObject
.CtrlCNotifyHandle2
);
3414 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3415 KeyData
.Key
.UnicodeChar
= 3;
3416 if (!EFI_ERROR(Status
)) {
3417 Status
= SimpleEx
->RegisterKeyNotify(
3420 NotificationFunction
,
3421 &ShellInfoObject
.CtrlCNotifyHandle3
);
3423 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3424 if (!EFI_ERROR(Status
)) {
3425 Status
= SimpleEx
->RegisterKeyNotify(
3428 NotificationFunction
,
3429 &ShellInfoObject
.CtrlCNotifyHandle4
);