2 Member functions of EFI_SHELL_PROTOCOL and functions for creation,
3 manipulation, and initialization of EFI_SHELL_PROTOCOL.
5 Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
19 Close an open file handle.
21 This function closes a specified file handle. All "dirty" cached file data is
22 flushed to the device, and the file is closed. In all cases the handle is
25 @param[in] FileHandle The file handle to close.
27 @retval EFI_SUCCESS The file handle was closed successfully.
32 IN SHELL_FILE_HANDLE FileHandle
35 ShellFileHandleRemove(FileHandle
);
36 return (FileHandleClose(ConvertShellHandleToEfiFileProtocol(FileHandle
)));
40 Internal worker to determine whether there is a BlockIo somewhere
41 upon the device path specified.
43 @param[in] DevicePath The device path to test.
45 @retval TRUE gEfiBlockIoProtocolGuid was installed on a handle with this device path
46 @retval FALSE gEfiBlockIoProtocolGuid was not found.
50 InternalShellProtocolIsBlockIoPresent(
51 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
54 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
60 DevicePathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)DevicePath
;
61 Status
= gBS
->LocateDevicePath(&gEfiBlockIoProtocolGuid
, &DevicePathCopy
, &Handle
);
63 if ((Handle
!= NULL
) && (!EFI_ERROR(Status
))) {
70 Internal worker to determine whether there is a file system somewhere
71 upon the device path specified.
73 @param[in] DevicePath The device path to test.
75 @retval TRUE gEfiSimpleFileSystemProtocolGuid was installed on a handle with this device path
76 @retval FALSE gEfiSimpleFileSystemProtocolGuid was not found.
80 InternalShellProtocolIsSimpleFileSystemPresent(
81 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
84 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
90 DevicePathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)DevicePath
;
91 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &Handle
);
93 if ((Handle
!= NULL
) && (!EFI_ERROR(Status
))) {
100 Internal worker debug helper function to print out maps as they are added.
102 @param[in] Mapping string mapping that has been added
103 @param[in] DevicePath pointer to device path that has been mapped.
105 @retval EFI_SUCCESS the operation was successful.
106 @return other an error ocurred
113 InternalShellProtocolDebugPrintMessage (
114 IN CONST CHAR16
*Mapping
,
115 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
121 Status
= EFI_SUCCESS
;
124 if (Mapping
!= NULL
) {
125 DEBUG((EFI_D_INFO
, "Added new map item:\"%S\"\r\n", Mapping
));
127 Temp
= ConvertDevicePathToText(DevicePath
, TRUE
, TRUE
);
128 DEBUG((EFI_D_INFO
, "DevicePath: %S\r\n", Temp
));
136 This function creates a mapping for a device path.
138 If both DeviecPath and Mapping are NULL, this will reset the mapping to default values.
140 @param DevicePath Points to the device path. If this is NULL and Mapping points to a valid mapping,
141 then the mapping will be deleted.
142 @param Mapping Points to the NULL-terminated mapping for the device path. Must end with a ':'
144 @retval EFI_SUCCESS Mapping created or deleted successfully.
145 @retval EFI_NO_MAPPING There is no handle that corresponds exactly to DevicePath. See the
146 boot service function LocateDevicePath().
147 @retval EFI_ACCESS_DENIED The mapping is a built-in alias.
148 @retval EFI_INVALID_PARAMETER Mapping was NULL
149 @retval EFI_INVALID_PARAMETER Mapping did not end with a ':'
150 @retval EFI_INVALID_PARAMETER DevicePath was not pointing at a device that had a SIMPLE_FILE_SYSTEM_PROTOCOL installed.
151 @retval EFI_NOT_FOUND There was no mapping found to delete
152 @retval EFI_OUT_OF_RESOURCES Memory allocation failed
157 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath OPTIONAL
,
158 IN CONST CHAR16
*Mapping
162 SHELL_MAP_LIST
*MapListNode
;
164 if (Mapping
== NULL
){
165 return (EFI_INVALID_PARAMETER
);
168 if (Mapping
[StrLen(Mapping
)-1] != ':') {
169 return (EFI_INVALID_PARAMETER
);
173 // Delete the mapping
175 if (DevicePath
== NULL
) {
176 if (IsListEmpty(&gShellMapList
.Link
)) {
177 return (EFI_NOT_FOUND
);
179 for ( MapListNode
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
180 ; !IsNull(&gShellMapList
.Link
, &MapListNode
->Link
)
181 ; MapListNode
= (SHELL_MAP_LIST
*)GetNextNode(&gShellMapList
.Link
, &MapListNode
->Link
)
183 if (StringNoCaseCompare(&MapListNode
->MapName
, &Mapping
) == 0) {
184 RemoveEntryList(&MapListNode
->Link
);
185 FreePool(MapListNode
);
186 return (EFI_SUCCESS
);
191 // We didnt find one to delete
193 return (EFI_NOT_FOUND
);
197 // make sure this is a valid to add device path
199 ///@todo add BlockIo to this test...
200 if (!InternalShellProtocolIsSimpleFileSystemPresent(DevicePath
)
201 && !InternalShellProtocolIsBlockIoPresent(DevicePath
)) {
202 return (EFI_INVALID_PARAMETER
);
206 // First make sure there is no old mapping
208 Status
= EfiShellSetMap(NULL
, Mapping
);
209 if ((Status
!= EFI_SUCCESS
) && (Status
!= EFI_NOT_FOUND
)) {
214 // now add the new one.
216 Status
= ShellCommandAddMapItemAndUpdatePath(Mapping
, DevicePath
, 0, FALSE
);
222 Gets the device path from the mapping.
224 This function gets the device path associated with a mapping.
226 @param Mapping A pointer to the mapping
228 @retval !=NULL Pointer to the device path that corresponds to the
229 device mapping. The returned pointer does not need
231 @retval NULL There is no device path associated with the
234 CONST EFI_DEVICE_PATH_PROTOCOL
*
236 EfiShellGetDevicePathFromMap(
237 IN CONST CHAR16
*Mapping
240 SHELL_MAP_LIST
*MapListItem
;
247 StrnCatGrow(&NewName
, &Size
, Mapping
, 0);
248 if (Mapping
[StrLen(Mapping
)-1] != L
':') {
249 StrnCatGrow(&NewName
, &Size
, L
":", 0);
252 MapListItem
= ShellCommandFindMapItem(NewName
);
256 if (MapListItem
!= NULL
) {
257 return (MapListItem
->DevicePath
);
263 Gets the mapping(s) that most closely matches the device path.
265 This function gets the mapping which corresponds to the device path *DevicePath. If
266 there is no exact match, then the mapping which most closely matches *DevicePath
267 is returned, and *DevicePath is updated to point to the remaining portion of the
268 device path. If there is an exact match, the mapping is returned and *DevicePath
269 points to the end-of-device-path node.
271 If there are multiple map names they will be semi-colon seperated in the
272 NULL-terminated string.
274 @param DevicePath On entry, points to a device path pointer. On
275 exit, updates the pointer to point to the
276 portion of the device path after the mapping.
278 @retval NULL No mapping was found.
279 @return !=NULL Pointer to NULL-terminated mapping. The buffer
280 is callee allocated and should be freed by the caller.
284 EfiShellGetMapFromDevicePath(
285 IN OUT EFI_DEVICE_PATH_PROTOCOL
**DevicePath
288 SHELL_MAP_LIST
*Node
;
289 CHAR16
*PathForReturn
;
291 // EFI_HANDLE PathHandle;
292 // EFI_HANDLE MapHandle;
293 // EFI_STATUS Status;
294 // EFI_DEVICE_PATH_PROTOCOL *DevicePathCopy;
295 // EFI_DEVICE_PATH_PROTOCOL *MapPathCopy;
297 if (DevicePath
== NULL
|| *DevicePath
== NULL
) {
301 PathForReturn
= NULL
;
304 for ( Node
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
305 ; !IsNull(&gShellMapList
.Link
, &Node
->Link
)
306 ; Node
= (SHELL_MAP_LIST
*)GetNextNode(&gShellMapList
.Link
, &Node
->Link
)
309 // check for exact match
311 if (DevicePathCompare(DevicePath
, &Node
->DevicePath
) == 0) {
312 ASSERT((PathForReturn
== NULL
&& PathSize
== 0) || (PathForReturn
!= NULL
));
314 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, L
";", 0);
316 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, Node
->MapName
, 0);
319 if (PathForReturn
!= NULL
) {
320 while (!IsDevicePathEndType (*DevicePath
)) {
321 *DevicePath
= NextDevicePathNode (*DevicePath
);
323 SetDevicePathEndNode (*DevicePath
);
326 ///@todo finish code for inexact matches.
327 if (PathForReturn == NULL) {
330 DevicePathCopy = DuplicateDevicePath(*DevicePath);
331 ASSERT(DevicePathCopy != NULL);
332 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &DevicePathCopy, &PathHandle);
333 ASSERT_EFI_ERROR(Status);
335 // check each of the device paths we have to get the root of the path for consist mappings
337 for ( Node = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
338 ; !IsNull(&gShellMapList.Link, &Node->Link)
339 ; Node = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &Node->Link)
341 if ((Node->Flags & SHELL_MAP_FLAGS_CONSIST) == 0) {
344 MapPathCopy = DuplicateDevicePath(Node->DevicePath);
345 ASSERT(MapPathCopy != NULL);
346 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &MapPathCopy, &MapHandle);
347 if (MapHandle == PathHandle) {
349 *DevicePath = DevicePathCopy;
352 DevicePathCopy = NULL;
353 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, Node->MapName, 0);
354 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, L";", 0);
359 // now add on the non-consistent mappings
361 for ( Node = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
362 ; !IsNull(&gShellMapList.Link, &Node->Link)
363 ; Node = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &Node->Link)
365 if ((Node->Flags & SHELL_MAP_FLAGS_CONSIST) != 0) {
368 MapPathCopy = Node->DevicePath;
369 ASSERT(MapPathCopy != NULL);
370 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &MapPathCopy, &MapHandle);
371 if (MapHandle == PathHandle) {
372 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, Node->MapName, 0);
373 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, L";", 0);
380 return (AddBufferToFreeList(PathForReturn
));
384 Converts a device path to a file system-style path.
386 This function converts a device path to a file system path by replacing part, or all, of
387 the device path with the file-system mapping. If there are more than one application
388 file system mappings, the one that most closely matches Path will be used.
390 @param Path The pointer to the device path
392 @retval NULL the device path could not be found.
393 @return all The pointer of the NULL-terminated file path. The path
394 is callee-allocated and should be freed by the caller.
398 EfiShellGetFilePathFromDevicePath(
399 IN CONST EFI_DEVICE_PATH_PROTOCOL
*Path
402 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
403 EFI_DEVICE_PATH_PROTOCOL
*MapPathCopy
;
404 SHELL_MAP_LIST
*MapListItem
;
405 CHAR16
*PathForReturn
;
407 EFI_HANDLE PathHandle
;
408 EFI_HANDLE MapHandle
;
410 FILEPATH_DEVICE_PATH
*FilePath
;
411 FILEPATH_DEVICE_PATH
*AlignedNode
;
413 PathForReturn
= NULL
;
416 DevicePathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)Path
;
417 ASSERT(DevicePathCopy
!= NULL
);
418 if (DevicePathCopy
== NULL
) {
422 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &PathHandle
);
424 if (EFI_ERROR(Status
)) {
428 // check each of the device paths we have to get the root of the path
430 for ( MapListItem
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
431 ; !IsNull(&gShellMapList
.Link
, &MapListItem
->Link
)
432 ; MapListItem
= (SHELL_MAP_LIST
*)GetNextNode(&gShellMapList
.Link
, &MapListItem
->Link
)
434 MapPathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)MapListItem
->DevicePath
;
435 ASSERT(MapPathCopy
!= NULL
);
437 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &MapPathCopy
, &MapHandle
);
438 if (MapHandle
== PathHandle
) {
439 ASSERT((PathForReturn
== NULL
&& PathSize
== 0) || (PathForReturn
!= NULL
));
440 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, MapListItem
->MapName
, 0);
442 // go through all the remaining nodes in the device path
444 for ( FilePath
= (FILEPATH_DEVICE_PATH
*)DevicePathCopy
445 ; !IsDevicePathEnd (&FilePath
->Header
)
446 ; FilePath
= (FILEPATH_DEVICE_PATH
*)NextDevicePathNode (&FilePath
->Header
)
449 // all the rest should be file path nodes
451 if ((DevicePathType(&FilePath
->Header
) != MEDIA_DEVICE_PATH
) ||
452 (DevicePathSubType(&FilePath
->Header
) != MEDIA_FILEPATH_DP
)) {
453 FreePool(PathForReturn
);
454 PathForReturn
= NULL
;
458 // append the path part onto the filepath.
460 ASSERT((PathForReturn
== NULL
&& PathSize
== 0) || (PathForReturn
!= NULL
));
461 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, L
"\\", 1);
463 AlignedNode
= AllocateCopyPool (DevicePathNodeLength(FilePath
), FilePath
);
464 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, AlignedNode
->PathName
, 0);
465 FreePool(AlignedNode
);
467 } // for loop of remaining nodes
469 if (PathForReturn
!= NULL
) {
472 } // for loop of paths to check
473 return(PathForReturn
);
477 Converts a file system style name to a device path.
479 This function converts a file system style name to a device path, by replacing any
480 mapping references to the associated device path.
482 @param[in] Path The pointer to the path.
484 @return The pointer of the file path. The file path is callee
485 allocated and should be freed by the caller.
486 @retval NULL The path could not be found.
487 @retval NULL There was not enough available memory.
489 EFI_DEVICE_PATH_PROTOCOL
*
491 EfiShellGetDevicePathFromFilePath(
492 IN CONST CHAR16
*Path
499 CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
500 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
501 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopyForFree
;
502 EFI_DEVICE_PATH_PROTOCOL
*DevicePathForReturn
;
513 if (StrStr(Path
, L
":") == NULL
) {
514 Cwd
= EfiShellGetCurDir(NULL
);
519 Size
+= StrSize(Path
);
520 NewPath
= AllocateZeroPool(Size
);
521 if (NewPath
== NULL
) {
524 StrCpy(NewPath
, Cwd
);
525 if (*Path
== L
'\\') {
527 while (PathRemoveLastItem(NewPath
)) ;
529 StrCat(NewPath
, Path
);
530 DevicePathForReturn
= EfiShellGetDevicePathFromFilePath(NewPath
);
532 return (DevicePathForReturn
);
537 // find the part before (but including) the : for the map name
539 ASSERT((MapName
== NULL
&& Size
== 0) || (MapName
!= NULL
));
540 MapName
= StrnCatGrow(&MapName
, &Size
, Path
, (StrStr(Path
, L
":")-Path
+1));
541 if (MapName
== NULL
|| MapName
[StrLen(MapName
)-1] != L
':') {
546 // look up the device path in the map
548 DevicePath
= EfiShellGetDevicePathFromMap(MapName
);
549 if (DevicePath
== NULL
) {
551 // Must have been a bad Mapname
557 // make a copy for LocateDevicePath to modify (also save a pointer to call FreePool with)
559 DevicePathCopyForFree
= DevicePathCopy
= DuplicateDevicePath(DevicePath
);
560 if (DevicePathCopy
== NULL
) {
569 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &Handle
);
570 if (EFI_ERROR(Status
)) {
571 if (DevicePathCopyForFree
!= NULL
) {
572 FreePool(DevicePathCopyForFree
);
579 // build the full device path
581 if (*(Path
+StrLen(MapName
)+1) == CHAR_NULL
) {
582 DevicePathForReturn
= FileDevicePath(Handle
, L
"\\");
584 DevicePathForReturn
= FileDevicePath(Handle
, Path
+StrLen(MapName
));
588 if (DevicePathCopyForFree
!= NULL
) {
589 FreePool(DevicePathCopyForFree
);
592 return (DevicePathForReturn
);
596 Gets the name of the device specified by the device handle.
598 This function gets the user-readable name of the device specified by the device
599 handle. If no user-readable name could be generated, then *BestDeviceName will be
600 NULL and EFI_NOT_FOUND will be returned.
602 If EFI_DEVICE_NAME_USE_COMPONENT_NAME is set, then the function will return the
603 device's name using the EFI_COMPONENT_NAME2_PROTOCOL, if present on
606 If EFI_DEVICE_NAME_USE_DEVICE_PATH is set, then the function will return the
607 device's name using the EFI_DEVICE_PATH_PROTOCOL, if present on DeviceHandle.
608 If both EFI_DEVICE_NAME_USE_COMPONENT_NAME and
609 EFI_DEVICE_NAME_USE_DEVICE_PATH are set, then
610 EFI_DEVICE_NAME_USE_COMPONENT_NAME will have higher priority.
612 @param DeviceHandle The handle of the device.
613 @param Flags Determines the possible sources of component names.
615 EFI_DEVICE_NAME_USE_COMPONENT_NAME
616 EFI_DEVICE_NAME_USE_DEVICE_PATH
617 @param Language A pointer to the language specified for the device
618 name, in the same format as described in the UEFI
619 specification, Appendix M
620 @param BestDeviceName On return, points to the callee-allocated NULL-
621 terminated name of the device. If no device name
622 could be found, points to NULL. The name must be
623 freed by the caller...
625 @retval EFI_SUCCESS Get the name successfully.
626 @retval EFI_NOT_FOUND Fail to get the device name.
627 @retval EFI_INVALID_PARAMETER Flags did not have a valid bit set.
628 @retval EFI_INVALID_PARAMETER BestDeviceName was NULL
629 @retval EFI_INVALID_PARAMETER DeviceHandle was NULL
633 EfiShellGetDeviceName(
634 IN EFI_HANDLE DeviceHandle
,
635 IN EFI_SHELL_DEVICE_NAME_FLAGS Flags
,
637 OUT CHAR16
**BestDeviceName
641 EFI_COMPONENT_NAME2_PROTOCOL
*CompName2
;
642 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
643 EFI_HANDLE
*HandleList
;
646 CHAR16
*DeviceNameToReturn
;
648 UINTN ParentControllerCount
;
649 EFI_HANDLE
*ParentControllerBuffer
;
650 UINTN ParentDriverCount
;
651 EFI_HANDLE
*ParentDriverBuffer
;
653 if (BestDeviceName
== NULL
||
656 return (EFI_INVALID_PARAMETER
);
660 // make sure one of the 2 supported bits is on
662 if (((Flags
& EFI_DEVICE_NAME_USE_COMPONENT_NAME
) == 0) &&
663 ((Flags
& EFI_DEVICE_NAME_USE_DEVICE_PATH
) == 0)) {
664 return (EFI_INVALID_PARAMETER
);
667 DeviceNameToReturn
= NULL
;
668 *BestDeviceName
= NULL
;
673 if ((Flags
& EFI_DEVICE_NAME_USE_COMPONENT_NAME
) != 0) {
674 Status
= ParseHandleDatabaseByRelationship(
677 HR_DRIVER_BINDING_HANDLE
|HR_DEVICE_DRIVER
,
680 for (LoopVar
= 0; LoopVar
< HandleCount
; LoopVar
++){
682 // Go through those handles until we get one that passes for GetComponentName
684 Status
= gBS
->OpenProtocol(
686 &gEfiComponentName2ProtocolGuid
,
690 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
691 if (EFI_ERROR(Status
)) {
692 Status
= gBS
->OpenProtocol(
694 &gEfiComponentNameProtocolGuid
,
698 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
701 if (EFI_ERROR(Status
)) {
704 Lang
= GetBestLanguageForDriver(CompName2
->SupportedLanguages
, Language
, FALSE
);
705 Status
= CompName2
->GetControllerName(CompName2
, DeviceHandle
, NULL
, Lang
, &DeviceNameToReturn
);
708 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
712 if (HandleList
!= NULL
) {
713 FreePool(HandleList
);
717 // Now check the parent controller using this as the child.
719 if (DeviceNameToReturn
== NULL
){
720 PARSE_HANDLE_DATABASE_PARENTS(DeviceHandle
, &ParentControllerCount
, &ParentControllerBuffer
);
721 for (LoopVar
= 0 ; LoopVar
< ParentControllerCount
; LoopVar
++) {
722 PARSE_HANDLE_DATABASE_UEFI_DRIVERS(ParentControllerBuffer
[LoopVar
], &ParentDriverCount
, &ParentDriverBuffer
);
723 for (HandleCount
= 0 ; HandleCount
< ParentDriverCount
; HandleCount
++) {
725 // try using that driver's component name with controller and our driver as the child.
727 Status
= gBS
->OpenProtocol(
728 ParentDriverBuffer
[HandleCount
],
729 &gEfiComponentName2ProtocolGuid
,
733 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
734 if (EFI_ERROR(Status
)) {
735 Status
= gBS
->OpenProtocol(
736 ParentDriverBuffer
[HandleCount
],
737 &gEfiComponentNameProtocolGuid
,
741 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
744 if (EFI_ERROR(Status
)) {
747 Lang
= GetBestLanguageForDriver(CompName2
->SupportedLanguages
, Language
, FALSE
);
748 Status
= CompName2
->GetControllerName(CompName2
, ParentControllerBuffer
[LoopVar
], DeviceHandle
, Lang
, &DeviceNameToReturn
);
751 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
758 SHELL_FREE_NON_NULL(ParentDriverBuffer
);
759 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
763 SHELL_FREE_NON_NULL(ParentControllerBuffer
);
766 // dont return on fail since we will try device path if that bit is on
768 if (DeviceNameToReturn
!= NULL
){
769 ASSERT(BestDeviceName
!= NULL
);
770 StrnCatGrow(BestDeviceName
, NULL
, DeviceNameToReturn
, 0);
771 return (EFI_SUCCESS
);
774 if ((Flags
& EFI_DEVICE_NAME_USE_DEVICE_PATH
) != 0) {
775 Status
= gBS
->OpenProtocol(
777 &gEfiDevicePathProtocolGuid
,
781 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
782 if (!EFI_ERROR(Status
)) {
784 // use device path to text on the device path
786 *BestDeviceName
= ConvertDevicePathToText(DevicePath
, TRUE
, TRUE
);
787 return (EFI_SUCCESS
);
791 // none of the selected bits worked.
793 return (EFI_NOT_FOUND
);
797 Opens the root directory of a device on a handle
799 This function opens the root directory of a device and returns a file handle to it.
801 @param DeviceHandle The handle of the device that contains the volume.
802 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
805 @retval EFI_SUCCESS Root opened successfully.
806 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
808 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
809 @retval EFI_DEVICE_ERROR The device had an error
813 EfiShellOpenRootByHandle(
814 IN EFI_HANDLE DeviceHandle
,
815 OUT SHELL_FILE_HANDLE
*FileHandle
819 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
*SimpleFileSystem
;
820 EFI_FILE_PROTOCOL
*RealFileHandle
;
821 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
824 // get the simple file system interface
826 Status
= gBS
->OpenProtocol(DeviceHandle
,
827 &gEfiSimpleFileSystemProtocolGuid
,
828 (VOID
**)&SimpleFileSystem
,
831 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
832 if (EFI_ERROR(Status
)) {
833 return (EFI_NOT_FOUND
);
836 Status
= gBS
->OpenProtocol(DeviceHandle
,
837 &gEfiDevicePathProtocolGuid
,
841 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
842 if (EFI_ERROR(Status
)) {
843 return (EFI_NOT_FOUND
);
846 // Open the root volume now...
848 Status
= SimpleFileSystem
->OpenVolume(SimpleFileSystem
, &RealFileHandle
);
849 *FileHandle
= ConvertEfiFileProtocolToShellHandle(RealFileHandle
, EfiShellGetMapFromDevicePath(&DevPath
));
854 Opens the root directory of a device.
856 This function opens the root directory of a device and returns a file handle to it.
858 @param DevicePath Points to the device path corresponding to the device where the
859 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL is installed.
860 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
863 @retval EFI_SUCCESS Root opened successfully.
864 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
866 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
867 @retval EFI_DEVICE_ERROR The device had an error
868 @retval EFI_INVALID_PARAMETER FileHandle is NULL.
873 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
874 OUT SHELL_FILE_HANDLE
*FileHandle
880 if (FileHandle
== NULL
) {
881 return (EFI_INVALID_PARAMETER
);
885 // find the handle of the device with that device handle and the file system
888 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
,
891 if (EFI_ERROR(Status
)) {
892 return (EFI_NOT_FOUND
);
895 return (EfiShellOpenRootByHandle(Handle
, FileHandle
));
899 Returns whether any script files are currently being processed.
901 @retval TRUE There is at least one script file active.
902 @retval FALSE No script files are active now.
907 EfiShellBatchIsActive (
911 if (ShellCommandGetCurrentScriptFile() == NULL
) {
918 Worker function to open a file based on a device path. this will open the root
919 of the volume and then traverse down to the file itself.
921 @param DevicePath Device Path of the file.
922 @param FileHandle Pointer to the file upon a successful return.
923 @param OpenMode mode to open file in.
924 @param Attributes the File Attributes to use when creating a new file.
926 @retval EFI_SUCCESS the file is open and FileHandle is valid
927 @retval EFI_UNSUPPORTED the device path cotained non-path elements
928 @retval other an error ocurred.
932 InternalOpenFileDevicePath(
933 IN OUT EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
934 OUT SHELL_FILE_HANDLE
*FileHandle
,
936 IN UINT64 Attributes OPTIONAL
940 FILEPATH_DEVICE_PATH
*FilePathNode
;
942 SHELL_FILE_HANDLE ShellHandle
;
943 EFI_FILE_PROTOCOL
*Handle1
;
944 EFI_FILE_PROTOCOL
*Handle2
;
945 FILEPATH_DEVICE_PATH
*AlignedNode
;
947 if (FileHandle
== NULL
) {
948 return (EFI_INVALID_PARAMETER
);
958 Status
= EfiShellOpenRoot(DevicePath
, &ShellHandle
);
960 if (!EFI_ERROR(Status
)) {
961 Handle1
= ConvertShellHandleToEfiFileProtocol(ShellHandle
);
962 if (Handle1
!= NULL
) {
964 // chop off the begining part before the file system part...
967 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
,
970 if (!EFI_ERROR(Status
)) {
972 // To access as a file system, the file path should only
973 // contain file path components. Follow the file path nodes
974 // and find the target file
976 for ( FilePathNode
= (FILEPATH_DEVICE_PATH
*)DevicePath
977 ; !IsDevicePathEnd (&FilePathNode
->Header
)
978 ; FilePathNode
= (FILEPATH_DEVICE_PATH
*) NextDevicePathNode (&FilePathNode
->Header
)
980 SHELL_FREE_NON_NULL(AlignedNode
);
981 AlignedNode
= AllocateCopyPool (DevicePathNodeLength(FilePathNode
), FilePathNode
);
983 // For file system access each node should be a file path component
985 if (DevicePathType (&FilePathNode
->Header
) != MEDIA_DEVICE_PATH
||
986 DevicePathSubType (&FilePathNode
->Header
) != MEDIA_FILEPATH_DP
988 Status
= EFI_UNSUPPORTED
;
993 // Open this file path node
999 // if this is the last node in the DevicePath always create (if that was requested).
1001 if (IsDevicePathEnd ((NextDevicePathNode (&FilePathNode
->Header
)))) {
1002 Status
= Handle2
->Open (
1005 AlignedNode
->PathName
,
1012 // This is not the last node and we dont want to 'create' existing
1013 // directory entries...
1017 // open without letting it create
1018 // prevents error on existing files/directories
1020 Status
= Handle2
->Open (
1023 AlignedNode
->PathName
,
1024 OpenMode
&~EFI_FILE_MODE_CREATE
,
1028 // if above failed now open and create the 'item'
1029 // if OpenMode EFI_FILE_MODE_CREATE bit was on (but disabled above)
1031 if ((EFI_ERROR (Status
)) && ((OpenMode
& EFI_FILE_MODE_CREATE
) != 0)) {
1032 Status
= Handle2
->Open (
1035 AlignedNode
->PathName
,
1042 // Close the last node
1044 ShellInfoObject
.NewEfiShellProtocol
->CloseFile (Handle2
);
1047 // If there's been an error, stop
1049 if (EFI_ERROR (Status
)) {
1056 SHELL_FREE_NON_NULL(AlignedNode
);
1057 if (EFI_ERROR(Status
)) {
1058 if (Handle1
!= NULL
) {
1059 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(Handle1
);
1062 *FileHandle
= ConvertEfiFileProtocolToShellHandle(Handle1
, ShellFileHandleGetPath(ShellHandle
));
1068 Creates a file or directory by name.
1070 This function creates an empty new file or directory with the specified attributes and
1071 returns the new file's handle. If the file already exists and is read-only, then
1072 EFI_INVALID_PARAMETER will be returned.
1074 If the file already existed, it is truncated and its attributes updated. If the file is
1075 created successfully, the FileHandle is the file's handle, else, the FileHandle is NULL.
1077 If the file name begins with >v, then the file handle which is returned refers to the
1078 shell environment variable with the specified name. If the shell environment variable
1079 already exists and is non-volatile then EFI_INVALID_PARAMETER is returned.
1081 @param FileName Pointer to NULL-terminated file path
1082 @param FileAttribs The new file's attrbiutes. the different attributes are
1083 described in EFI_FILE_PROTOCOL.Open().
1084 @param FileHandle On return, points to the created file handle or directory's handle
1086 @retval EFI_SUCCESS The file was opened. FileHandle points to the new file's handle.
1087 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1088 @retval EFI_UNSUPPORTED could not open the file path
1089 @retval EFI_NOT_FOUND the specified file could not be found on the devide, or could not
1090 file the file system on the device.
1091 @retval EFI_NO_MEDIA the device has no medium.
1092 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1094 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1096 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1097 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1098 when the media is write-protected.
1099 @retval EFI_ACCESS_DENIED The service denied access to the file.
1100 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file.
1101 @retval EFI_VOLUME_FULL The volume is full.
1106 IN CONST CHAR16
*FileName
,
1107 IN UINT64 FileAttribs
,
1108 OUT SHELL_FILE_HANDLE
*FileHandle
1111 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1115 // Is this for an environment variable
1116 // do we start with >v
1118 if (StrStr(FileName
, L
">v") == FileName
) {
1119 if (!IsVolatileEnv(FileName
+2)) {
1120 return (EFI_INVALID_PARAMETER
);
1122 *FileHandle
= CreateFileInterfaceEnv(FileName
+2);
1123 return (EFI_SUCCESS
);
1127 // We are opening a regular file.
1129 DevicePath
= EfiShellGetDevicePathFromFilePath(FileName
);
1130 if (DevicePath
== NULL
) {
1131 return (EFI_NOT_FOUND
);
1134 Status
= InternalOpenFileDevicePath(DevicePath
, FileHandle
, EFI_FILE_MODE_READ
|EFI_FILE_MODE_WRITE
|EFI_FILE_MODE_CREATE
, FileAttribs
); // 0 = no specific file attributes
1135 FreePool(DevicePath
);
1141 Opens a file or a directory by file name.
1143 This function opens the specified file in the specified OpenMode and returns a file
1145 If the file name begins with >v, then the file handle which is returned refers to the
1146 shell environment variable with the specified name. If the shell environment variable
1147 exists, is non-volatile and the OpenMode indicates EFI_FILE_MODE_WRITE, then
1148 EFI_INVALID_PARAMETER is returned.
1150 If the file name is >i, then the file handle which is returned refers to the standard
1151 input. If the OpenMode indicates EFI_FILE_MODE_WRITE, then EFI_INVALID_PARAMETER
1154 If the file name is >o, then the file handle which is returned refers to the standard
1155 output. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1158 If the file name is >e, then the file handle which is returned refers to the standard
1159 error. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1162 If the file name is NUL, then the file handle that is returned refers to the standard NUL
1163 file. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER is
1166 If return EFI_SUCCESS, the FileHandle is the opened file's handle, else, the
1169 @param FileName Points to the NULL-terminated UCS-2 encoded file name.
1170 @param FileHandle On return, points to the file handle.
1171 @param OpenMode File open mode. Either EFI_FILE_MODE_READ or
1172 EFI_FILE_MODE_WRITE from section 12.4 of the UEFI
1174 @retval EFI_SUCCESS The file was opened. FileHandle has the opened file's handle.
1175 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value. FileHandle is NULL.
1176 @retval EFI_UNSUPPORTED Could not open the file path. FileHandle is NULL.
1177 @retval EFI_NOT_FOUND The specified file could not be found on the device or the file
1178 system could not be found on the device. FileHandle is NULL.
1179 @retval EFI_NO_MEDIA The device has no medium. FileHandle is NULL.
1180 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1181 longer supported. FileHandle is NULL.
1182 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1183 the FileName. FileHandle is NULL.
1184 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted. FileHandle is NULL.
1185 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1186 when the media is write-protected. FileHandle is NULL.
1187 @retval EFI_ACCESS_DENIED The service denied access to the file. FileHandle is NULL.
1188 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file. FileHandle
1190 @retval EFI_VOLUME_FULL The volume is full. FileHandle is NULL.
1194 EfiShellOpenFileByName(
1195 IN CONST CHAR16
*FileName
,
1196 OUT SHELL_FILE_HANDLE
*FileHandle
,
1200 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1206 // Is this for StdIn
1208 if (StrCmp(FileName
, L
">i") == 0) {
1210 // make sure not writing to StdIn
1212 if ((OpenMode
& EFI_FILE_MODE_WRITE
) != 0) {
1213 return (EFI_INVALID_PARAMETER
);
1215 *FileHandle
= ShellInfoObject
.NewShellParametersProtocol
->StdIn
;
1216 ASSERT(*FileHandle
!= NULL
);
1217 return (EFI_SUCCESS
);
1221 // Is this for StdOut
1223 if (StrCmp(FileName
, L
">o") == 0) {
1225 // make sure not writing to StdIn
1227 if ((OpenMode
& EFI_FILE_MODE_READ
) != 0) {
1228 return (EFI_INVALID_PARAMETER
);
1230 *FileHandle
= &FileInterfaceStdOut
;
1231 return (EFI_SUCCESS
);
1235 // Is this for NUL file
1237 if (StrCmp(FileName
, L
"NUL") == 0) {
1238 *FileHandle
= &FileInterfaceNulFile
;
1239 return (EFI_SUCCESS
);
1243 // Is this for StdErr
1245 if (StrCmp(FileName
, L
">e") == 0) {
1247 // make sure not writing to StdIn
1249 if ((OpenMode
& EFI_FILE_MODE_READ
) != 0) {
1250 return (EFI_INVALID_PARAMETER
);
1252 *FileHandle
= &FileInterfaceStdErr
;
1253 return (EFI_SUCCESS
);
1257 // Is this for an environment variable
1258 // do we start with >v
1260 if (StrStr(FileName
, L
">v") == FileName
) {
1261 if (!IsVolatileEnv(FileName
+2) &&
1262 ((OpenMode
& EFI_FILE_MODE_WRITE
) != 0)) {
1263 return (EFI_INVALID_PARAMETER
);
1265 *FileHandle
= CreateFileInterfaceEnv(FileName
+2);
1266 return (EFI_SUCCESS
);
1270 // We are opening a regular file.
1272 DevicePath
= EfiShellGetDevicePathFromFilePath(FileName
);
1273 // DEBUG_CODE(InternalShellProtocolDebugPrintMessage (NULL, DevicePath););
1274 if (DevicePath
== NULL
) {
1275 return (EFI_NOT_FOUND
);
1279 // Copy the device path, open the file, then free the memory
1281 Status
= InternalOpenFileDevicePath(DevicePath
, FileHandle
, OpenMode
, 0); // 0 = no specific file attributes
1282 FreePool(DevicePath
);
1288 Deletes the file specified by the file name.
1290 This function deletes a file.
1292 @param FileName Points to the NULL-terminated file name.
1294 @retval EFI_SUCCESS The file was closed and deleted, and the handle was closed.
1295 @retval EFI_WARN_DELETE_FAILURE The handle was closed but the file was not deleted.
1296 @sa EfiShellCreateFile
1300 EfiShellDeleteFileByName(
1301 IN CONST CHAR16
*FileName
1304 SHELL_FILE_HANDLE FileHandle
;
1308 // get a handle to the file
1310 Status
= EfiShellCreateFile(FileName
,
1313 if (EFI_ERROR(Status
)) {
1317 // now delete the file
1319 return (ShellInfoObject
.NewEfiShellProtocol
->DeleteFile(FileHandle
));
1323 Disables the page break output mode.
1327 EfiShellDisablePageBreak (
1331 ShellInfoObject
.PageBreakEnabled
= FALSE
;
1335 Enables the page break output mode.
1339 EfiShellEnablePageBreak (
1343 ShellInfoObject
.PageBreakEnabled
= TRUE
;
1347 internal worker function to load and run an image via device path.
1349 @param ParentImageHandle A handle of the image that is executing the specified
1351 @param DevicePath device path of the file to execute
1352 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1353 containing the command line. If NULL then the command-
1355 @param Environment Points to a NULL-terminated array of environment
1356 variables with the format 'x=y', where x is the
1357 environment variable name and y is the value. If this
1358 is NULL, then the current shell environment is used.
1359 @param StatusCode Points to the status code returned by the command.
1361 @param[out] ExitDataSize ExitDataSize as returned from gBS->StartImage
1362 @param[out] ExitData ExitData as returned from gBS->StartImage
1364 @retval EFI_SUCCESS The command executed successfully. The status code
1365 returned by the command is pointed to by StatusCode.
1366 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1367 @retval EFI_OUT_OF_RESOURCES Out of resources.
1368 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1372 InternalShellExecuteDevicePath(
1373 IN CONST EFI_HANDLE
*ParentImageHandle
,
1374 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
1375 IN CONST CHAR16
*CommandLine OPTIONAL
,
1376 IN CONST CHAR16
**Environment OPTIONAL
,
1377 OUT UINTN
*ExitDataSize OPTIONAL
,
1378 OUT CHAR16
**ExitData OPTIONAL
1382 EFI_STATUS CleanupStatus
;
1383 EFI_HANDLE NewHandle
;
1384 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
1385 LIST_ENTRY OrigEnvs
;
1386 EFI_SHELL_PARAMETERS_PROTOCOL ShellParamsProtocol
;
1387 UINTN InternalExitDataSize
;
1388 UINTN
*ExitDataSizePtr
;
1390 // ExitDataSize is not OPTIONAL for gBS->BootServices, provide somewhere for
1391 // it to be dumped if the caller doesn't want it.
1392 if (ExitData
== NULL
) {
1393 ExitDataSizePtr
= &InternalExitDataSize
;
1395 ExitDataSizePtr
= ExitDataSize
;
1398 if (ParentImageHandle
== NULL
) {
1399 return (EFI_INVALID_PARAMETER
);
1402 InitializeListHead(&OrigEnvs
);
1407 // Load the image with:
1408 // FALSE - not from boot manager and NULL, 0 being not already in memory
1410 Status
= gBS
->LoadImage(
1413 (EFI_DEVICE_PATH_PROTOCOL
*)DevicePath
,
1418 if (EFI_ERROR(Status
)) {
1419 if (NewHandle
!= NULL
) {
1420 gBS
->UnloadImage(NewHandle
);
1424 Status
= gBS
->OpenProtocol(
1426 &gEfiLoadedImageProtocolGuid
,
1427 (VOID
**)&LoadedImage
,
1430 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
1432 if (!EFI_ERROR(Status
)) {
1433 ASSERT(LoadedImage
->LoadOptionsSize
== 0);
1434 if (CommandLine
!= NULL
) {
1435 LoadedImage
->LoadOptionsSize
= (UINT32
)StrSize(CommandLine
);
1436 LoadedImage
->LoadOptions
= (VOID
*)CommandLine
;
1440 // Save our current environment settings for later restoration if necessary
1442 if (Environment
!= NULL
) {
1443 Status
= GetEnvironmentVariableList(&OrigEnvs
);
1444 if (!EFI_ERROR(Status
)) {
1445 Status
= SetEnvironmentVariables(Environment
);
1450 // Initialize and install a shell parameters protocol on the image.
1452 ShellParamsProtocol
.StdIn
= ShellInfoObject
.NewShellParametersProtocol
->StdIn
;
1453 ShellParamsProtocol
.StdOut
= ShellInfoObject
.NewShellParametersProtocol
->StdOut
;
1454 ShellParamsProtocol
.StdErr
= ShellInfoObject
.NewShellParametersProtocol
->StdErr
;
1455 Status
= UpdateArgcArgv(&ShellParamsProtocol
, CommandLine
, NULL
, NULL
);
1456 ASSERT_EFI_ERROR(Status
);
1457 Status
= gBS
->InstallProtocolInterface(&NewHandle
, &gEfiShellParametersProtocolGuid
, EFI_NATIVE_INTERFACE
, &ShellParamsProtocol
);
1458 ASSERT_EFI_ERROR(Status
);
1460 ///@todo initialize and install ShellInterface protocol on the new image for compatibility if - PcdGetBool(PcdShellSupportOldProtocols)
1463 // now start the image, passing up exit data if the caller requested it
1465 if (!EFI_ERROR(Status
)) {
1466 Status
= gBS
->StartImage(
1474 // Cleanup (and dont overwrite errors)
1476 if (EFI_ERROR(Status
)) {
1477 CleanupStatus
= gBS
->UninstallProtocolInterface(
1479 &gEfiShellParametersProtocolGuid
,
1480 &ShellParamsProtocol
1482 ASSERT_EFI_ERROR(CleanupStatus
);
1484 CleanupStatus
= gBS
->UninstallProtocolInterface(
1486 &gEfiShellParametersProtocolGuid
,
1487 &ShellParamsProtocol
1489 ASSERT_EFI_ERROR(CleanupStatus
);
1493 if (!IsListEmpty(&OrigEnvs
)) {
1494 if (EFI_ERROR(Status
)) {
1495 CleanupStatus
= SetEnvironmentVariableList(&OrigEnvs
);
1496 ASSERT_EFI_ERROR(CleanupStatus
);
1498 CleanupStatus
= SetEnvironmentVariableList(&OrigEnvs
);
1499 ASSERT_EFI_ERROR (CleanupStatus
);
1506 Execute the command line.
1508 This function creates a nested instance of the shell and executes the specified
1509 command (CommandLine) with the specified environment (Environment). Upon return,
1510 the status code returned by the specified command is placed in StatusCode.
1512 If Environment is NULL, then the current environment is used and all changes made
1513 by the commands executed will be reflected in the current environment. If the
1514 Environment is non-NULL, then the changes made will be discarded.
1516 The CommandLine is executed from the current working directory on the current
1519 @param ParentImageHandle A handle of the image that is executing the specified
1521 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1522 containing the command line. If NULL then the command-
1524 @param Environment Points to a NULL-terminated array of environment
1525 variables with the format 'x=y', where x is the
1526 environment variable name and y is the value. If this
1527 is NULL, then the current shell environment is used.
1528 @param StatusCode Points to the status code returned by the command.
1530 @retval EFI_SUCCESS The command executed successfully. The status code
1531 returned by the command is pointed to by StatusCode.
1532 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1533 @retval EFI_OUT_OF_RESOURCES Out of resources.
1534 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1535 @retval EFI_UNSUPPORTED The support level required for this function is not present.
1537 @sa InternalShellExecuteDevicePath
1542 IN EFI_HANDLE
*ParentImageHandle
,
1543 IN CHAR16
*CommandLine OPTIONAL
,
1544 IN CHAR16
**Environment OPTIONAL
,
1545 OUT EFI_STATUS
*StatusCode OPTIONAL
1550 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
1555 if ((PcdGet8(PcdShellSupportLevel
) < 1)) {
1556 return (EFI_UNSUPPORTED
);
1559 DevPath
= AppendDevicePath (ShellInfoObject
.ImageDevPath
, ShellInfoObject
.FileDevPath
);
1562 Temp
= ConvertDevicePathToText(ShellInfoObject
.FileDevPath
, TRUE
, TRUE
);
1564 Temp
= ConvertDevicePathToText(ShellInfoObject
.ImageDevPath
, TRUE
, TRUE
);
1566 Temp
= ConvertDevicePathToText(DevPath
, TRUE
, TRUE
);
1572 ASSERT((Temp
== NULL
&& Size
== 0) || (Temp
!= NULL
));
1573 StrnCatGrow(&Temp
, &Size
, L
"Shell.efi -_exit ", 0);
1574 StrnCatGrow(&Temp
, &Size
, CommandLine
, 0);
1576 Status
= InternalShellExecuteDevicePath(
1580 (CONST CHAR16
**)Environment
,
1584 if (Status
== EFI_ABORTED
) {
1585 // If the command exited with an error, the shell should put the exit
1586 // status in ExitData, preceded by a null-terminated string.
1587 ASSERT (ExitDataSize
== StrSize (ExitData
) + sizeof (SHELL_STATUS
));
1589 if (StatusCode
!= NULL
) {
1590 // Skip the null-terminated string
1591 ExitData
+= StrLen (ExitData
) + 1;
1593 // Use CopyMem to avoid alignment faults
1594 CopyMem (StatusCode
, ExitData
, sizeof (SHELL_STATUS
));
1596 // Convert from SHELL_STATUS to EFI_STATUS
1597 // EFI_STATUSes have top bit set when they are errors.
1598 // (See UEFI Spec Appendix D)
1599 if (*StatusCode
!= SHELL_SUCCESS
) {
1600 *StatusCode
= (EFI_STATUS
) *StatusCode
| MAX_BIT
;
1603 FreePool (ExitData
);
1604 Status
= EFI_SUCCESS
;
1605 } else if ((StatusCode
!= NULL
) && !EFI_ERROR(Status
)) {
1606 *StatusCode
= EFI_SUCCESS
;
1610 // de-allocate and return
1618 Utility cleanup function for EFI_SHELL_FILE_INFO objects.
1620 1) frees all pointers (non-NULL)
1621 2) Closes the SHELL_FILE_HANDLE
1623 @param FileListNode pointer to the list node to free
1627 InternalFreeShellFileInfoNode(
1628 IN EFI_SHELL_FILE_INFO
*FileListNode
1631 if (FileListNode
->Info
!= NULL
) {
1632 FreePool((VOID
*)FileListNode
->Info
);
1634 if (FileListNode
->FileName
!= NULL
) {
1635 FreePool((VOID
*)FileListNode
->FileName
);
1637 if (FileListNode
->FullName
!= NULL
) {
1638 FreePool((VOID
*)FileListNode
->FullName
);
1640 if (FileListNode
->Handle
!= NULL
) {
1641 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(FileListNode
->Handle
);
1643 FreePool(FileListNode
);
1646 Frees the file list.
1648 This function cleans up the file list and any related data structures. It has no
1649 impact on the files themselves.
1651 @param FileList The file list to free. Type EFI_SHELL_FILE_INFO is
1652 defined in OpenFileList()
1654 @retval EFI_SUCCESS Free the file list successfully.
1655 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1659 EfiShellFreeFileList(
1660 IN EFI_SHELL_FILE_INFO
**FileList
1663 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1665 if (FileList
== NULL
|| *FileList
== NULL
) {
1666 return (EFI_INVALID_PARAMETER
);
1669 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1670 ; !IsListEmpty(&(*FileList
)->Link
)
1671 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1673 RemoveEntryList(&ShellFileListItem
->Link
);
1674 InternalFreeShellFileInfoNode(ShellFileListItem
);
1676 InternalFreeShellFileInfoNode(*FileList
);
1678 return(EFI_SUCCESS
);
1682 Deletes the duplicate file names files in the given file list.
1684 This function deletes the reduplicate files in the given file list.
1686 @param FileList A pointer to the first entry in the file list.
1688 @retval EFI_SUCCESS Always success.
1689 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1693 EfiShellRemoveDupInFileList(
1694 IN EFI_SHELL_FILE_INFO
**FileList
1697 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1698 EFI_SHELL_FILE_INFO
*ShellFileListItem2
;
1700 if (FileList
== NULL
|| *FileList
== NULL
) {
1701 return (EFI_INVALID_PARAMETER
);
1703 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1704 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1705 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1707 for ( ShellFileListItem2
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1708 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem2
->Link
)
1709 ; ShellFileListItem2
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem2
->Link
)
1711 if (gUnicodeCollation
->StriColl(
1713 (CHAR16
*)ShellFileListItem
->FullName
,
1714 (CHAR16
*)ShellFileListItem2
->FullName
) == 0
1716 RemoveEntryList(&ShellFileListItem2
->Link
);
1717 InternalFreeShellFileInfoNode(ShellFileListItem2
);
1721 return (EFI_SUCCESS
);
1724 Allocates and duplicates a EFI_SHELL_FILE_INFO node.
1726 @param[in] Node The node to copy from.
1727 @param[in] Save TRUE to set Node->Handle to NULL, FALSE otherwise.
1729 @retval NULL a memory allocation error ocurred
1730 @return != NULL a pointer to the new node
1732 EFI_SHELL_FILE_INFO
*
1734 InternalDuplicateShellFileInfo(
1735 IN EFI_SHELL_FILE_INFO
*Node
,
1739 EFI_SHELL_FILE_INFO
*NewNode
;
1741 NewNode
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1742 if (NewNode
== NULL
) {
1745 NewNode
->FullName
= AllocateZeroPool(StrSize(Node
->FullName
));
1747 NewNode
->FileName
= AllocateZeroPool(StrSize(Node
->FileName
));
1748 NewNode
->Info
= AllocateZeroPool((UINTN
)Node
->Info
->Size
);
1749 if ( NewNode
->FullName
== NULL
1750 || NewNode
->FileName
== NULL
1751 || NewNode
->Info
== NULL
1755 NewNode
->Status
= Node
->Status
;
1756 NewNode
->Handle
= Node
->Handle
;
1758 Node
->Handle
= NULL
;
1760 StrCpy((CHAR16
*)NewNode
->FullName
, Node
->FullName
);
1761 StrCpy((CHAR16
*)NewNode
->FileName
, Node
->FileName
);
1762 CopyMem(NewNode
->Info
, Node
->Info
, (UINTN
)Node
->Info
->Size
);
1768 Allocates and populates a EFI_SHELL_FILE_INFO structure. if any memory operation
1769 failed it will return NULL.
1771 @param[in] BasePath the Path to prepend onto filename for FullPath
1772 @param[in] Status Status 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
*FileName
,
1786 IN CONST SHELL_FILE_HANDLE Handle
,
1787 IN CONST EFI_FILE_INFO
*Info
1790 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1797 ShellFileListItem
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1798 if (ShellFileListItem
== NULL
) {
1801 if (Info
!= NULL
&& Info
->Size
!= 0) {
1802 ShellFileListItem
->Info
= AllocateZeroPool((UINTN
)Info
->Size
);
1803 if (ShellFileListItem
->Info
== NULL
) {
1804 FreePool(ShellFileListItem
);
1807 CopyMem(ShellFileListItem
->Info
, Info
, (UINTN
)Info
->Size
);
1809 ShellFileListItem
->Info
= NULL
;
1811 if (FileName
!= NULL
) {
1812 ASSERT(TempString
== NULL
);
1813 ShellFileListItem
->FileName
= StrnCatGrow(&TempString
, 0, FileName
, 0);
1814 if (ShellFileListItem
->FileName
== NULL
) {
1815 FreePool(ShellFileListItem
->Info
);
1816 FreePool(ShellFileListItem
);
1820 ShellFileListItem
->FileName
= NULL
;
1824 if (BasePath
!= NULL
) {
1825 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
1826 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
1827 if (TempString
== NULL
) {
1828 FreePool((VOID
*)ShellFileListItem
->FileName
);
1829 FreePool(ShellFileListItem
->Info
);
1830 FreePool(ShellFileListItem
);
1834 if (ShellFileListItem
->FileName
!= NULL
) {
1835 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
1836 TempString
= StrnCatGrow(&TempString
, &Size
, ShellFileListItem
->FileName
, 0);
1837 if (TempString
== NULL
) {
1838 FreePool((VOID
*)ShellFileListItem
->FileName
);
1839 FreePool(ShellFileListItem
->Info
);
1840 FreePool(ShellFileListItem
);
1845 ShellFileListItem
->FullName
= TempString
;
1846 ShellFileListItem
->Status
= Status
;
1847 ShellFileListItem
->Handle
= Handle
;
1849 return (ShellFileListItem
);
1853 Find all files in a specified directory.
1855 @param FileDirHandle Handle of the directory to search.
1856 @param FileList On return, points to the list of files in the directory
1857 or NULL if there are no files in the directory.
1859 @retval EFI_SUCCESS File information was returned successfully.
1860 @retval EFI_VOLUME_CORRUPTED The file system structures have been corrupted.
1861 @retval EFI_DEVICE_ERROR The device reported an error.
1862 @retval EFI_NO_MEDIA The device media is not present.
1863 @retval EFI_INVALID_PARAMETER The FileDirHandle was not a directory.
1864 @return An error from FileHandleGetFileName().
1868 EfiShellFindFilesInDir(
1869 IN SHELL_FILE_HANDLE FileDirHandle
,
1870 OUT EFI_SHELL_FILE_INFO
**FileList
1873 EFI_SHELL_FILE_INFO
*ShellFileList
;
1874 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1875 EFI_FILE_INFO
*FileInfo
;
1883 Status
= FileHandleGetFileName(FileDirHandle
, &BasePath
);
1884 if (EFI_ERROR(Status
)) {
1888 if (ShellFileHandleGetPath(FileDirHandle
) != NULL
) {
1891 TempString
= StrnCatGrow(&TempString
, &Size
, ShellFileHandleGetPath(FileDirHandle
), 0);
1892 if (TempString
== NULL
) {
1893 SHELL_FREE_NON_NULL(BasePath
);
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 SHELL_FREE_NON_NULL(BasePath
);
1905 return (EFI_OUT_OF_RESOURCES
);
1907 SHELL_FREE_NON_NULL(BasePath
);
1908 BasePath
= TempString
;
1912 ShellFileList
= NULL
;
1913 ShellFileListItem
= NULL
;
1915 Status
= EFI_SUCCESS
;
1918 for ( Status
= FileHandleFindFirstFile(FileDirHandle
, &FileInfo
)
1919 ; !EFI_ERROR(Status
) && !NoFile
1920 ; Status
= FileHandleFindNextFile(FileDirHandle
, FileInfo
, &NoFile
)
1923 // allocate a new EFI_SHELL_FILE_INFO and populate it...
1925 ShellFileListItem
= CreateAndPopulateShellFileInfo(
1927 EFI_SUCCESS
, // success since we didnt fail to open it...
1929 NULL
, // no handle since not open
1932 if (ShellFileList
== NULL
) {
1933 ShellFileList
= (EFI_SHELL_FILE_INFO
*)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1934 ASSERT(ShellFileList
!= NULL
);
1935 InitializeListHead(&ShellFileList
->Link
);
1937 InsertTailList(&ShellFileList
->Link
, &ShellFileListItem
->Link
);
1939 if (EFI_ERROR(Status
)) {
1940 EfiShellFreeFileList(&ShellFileList
);
1943 *FileList
= ShellFileList
;
1945 SHELL_FREE_NON_NULL(BasePath
);
1950 Updates a file name to be preceeded by the mapped drive name
1952 @param[in] BasePath the Mapped drive name to prepend
1953 @param[in, out] Path pointer to pointer to the file name to update.
1956 @retval EFI_OUT_OF_RESOURCES
1961 IN CONST CHAR16
*BasePath
,
1962 IN OUT CHAR16
**Path
1971 ASSERT(Path
!= NULL
);
1972 ASSERT(*Path
!= NULL
);
1973 ASSERT(BasePath
!= NULL
);
1976 // convert a local path to an absolute path
1978 if (StrStr(*Path
, L
":") == NULL
) {
1979 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
1980 StrnCatGrow(&Path2
, &Path2Size
, BasePath
, 0);
1981 if (Path2
== NULL
) {
1982 return (EFI_OUT_OF_RESOURCES
);
1984 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
1985 StrnCatGrow(&Path2
, &Path2Size
, (*Path
)[0] == L
'\\'?(*Path
) + 1 :*Path
, 0);
1986 if (Path2
== NULL
) {
1987 return (EFI_OUT_OF_RESOURCES
);
1994 return (EFI_SUCCESS
);
1998 If FileHandle is a directory then the function reads from FileHandle and reads in
1999 each of the FileInfo structures. If one of them matches the Pattern's first
2000 "level" then it opens that handle and calls itself on that handle.
2002 If FileHandle is a file and matches all of the remaining Pattern (which would be
2003 on its last node), then add a EFI_SHELL_FILE_INFO object for this file to fileList.
2005 Upon a EFI_SUCCESS return fromt he function any the caller is responsible to call
2006 FreeFileList with FileList.
2008 @param[in] FilePattern The FilePattern to check against.
2009 @param[in] UnicodeCollation The pointer to EFI_UNICODE_COLLATION_PROTOCOL structure
2010 @param[in] FileHandle The FileHandle to start with
2011 @param[in, out] FileList pointer to pointer to list of found files.
2012 @param[in] ParentNode The node for the parent. Same file as identified by HANDLE.
2013 @param[in] MapName The file system name this file is on.
2015 @retval EFI_SUCCESS all files were found and the FileList contains a list.
2016 @retval EFI_NOT_FOUND no files were found
2017 @retval EFI_OUT_OF_RESOURCES a memory allocation failed
2022 IN CONST CHAR16
*FilePattern
,
2023 IN EFI_UNICODE_COLLATION_PROTOCOL
*UnicodeCollation
,
2024 IN SHELL_FILE_HANDLE FileHandle
,
2025 IN OUT EFI_SHELL_FILE_INFO
**FileList
,
2026 IN CONST EFI_SHELL_FILE_INFO
*ParentNode OPTIONAL
,
2027 IN CONST CHAR16
*MapName
2031 CONST CHAR16
*NextFilePatternStart
;
2032 CHAR16
*CurrentFilePattern
;
2033 EFI_SHELL_FILE_INFO
*ShellInfo
;
2034 EFI_SHELL_FILE_INFO
*ShellInfoNode
;
2035 EFI_SHELL_FILE_INFO
*NewShellNode
;
2037 CHAR16
*NewFullName
;
2040 if ( FilePattern
== NULL
2041 || UnicodeCollation
== NULL
2044 return (EFI_INVALID_PARAMETER
);
2047 CurrentFilePattern
= NULL
;
2049 if (*FilePattern
== L
'\\') {
2053 for( NextFilePatternStart
= FilePattern
2054 ; *NextFilePatternStart
!= CHAR_NULL
&& *NextFilePatternStart
!= L
'\\'
2055 ; NextFilePatternStart
++);
2057 CurrentFilePattern
= AllocateZeroPool((NextFilePatternStart
-FilePattern
+1)*sizeof(CHAR16
));
2058 ASSERT(CurrentFilePattern
!= NULL
);
2059 StrnCpy(CurrentFilePattern
, FilePattern
, NextFilePatternStart
-FilePattern
);
2061 if (CurrentFilePattern
[0] == CHAR_NULL
2062 &&NextFilePatternStart
[0] == CHAR_NULL
2065 // Add the current parameter FileHandle to the list, then end...
2067 if (ParentNode
== NULL
) {
2068 Status
= EFI_INVALID_PARAMETER
;
2070 NewShellNode
= InternalDuplicateShellFileInfo((EFI_SHELL_FILE_INFO
*)ParentNode
, TRUE
);
2071 if (NewShellNode
== NULL
) {
2072 Status
= EFI_OUT_OF_RESOURCES
;
2074 NewShellNode
->Handle
= NULL
;
2075 if (*FileList
== NULL
) {
2076 *FileList
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2077 InitializeListHead(&((*FileList
)->Link
));
2081 // Add to the returning to use list
2083 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
2085 Status
= EFI_SUCCESS
;
2089 Status
= EfiShellFindFilesInDir(FileHandle
, &ShellInfo
);
2091 if (!EFI_ERROR(Status
)){
2092 if (StrStr(NextFilePatternStart
, L
"\\") != NULL
){
2097 for ( ShellInfoNode
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&ShellInfo
->Link
)
2098 ; !IsNull (&ShellInfo
->Link
, &ShellInfoNode
->Link
)
2099 ; ShellInfoNode
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&ShellInfo
->Link
, &ShellInfoNode
->Link
)
2101 if (UnicodeCollation
->MetaiMatch(UnicodeCollation
, (CHAR16
*)ShellInfoNode
->FileName
, CurrentFilePattern
)){
2102 if (ShellInfoNode
->FullName
!= NULL
&& StrStr(ShellInfoNode
->FullName
, L
":") == NULL
) {
2103 Size
= StrSize(ShellInfoNode
->FullName
);
2104 Size
+= StrSize(MapName
) + sizeof(CHAR16
);
2105 NewFullName
= AllocateZeroPool(Size
);
2106 if (NewFullName
== NULL
) {
2107 Status
= EFI_OUT_OF_RESOURCES
;
2109 StrCpy(NewFullName
, MapName
);
2110 StrCat(NewFullName
, ShellInfoNode
->FullName
+1);
2111 FreePool((VOID
*)ShellInfoNode
->FullName
);
2112 ShellInfoNode
->FullName
= NewFullName
;
2115 if (Directory
&& !EFI_ERROR(Status
) && ShellInfoNode
->FullName
!= NULL
&& ShellInfoNode
->FileName
!= NULL
){
2117 // should be a directory
2121 // don't open the . and .. directories
2123 if ( (StrCmp(ShellInfoNode
->FileName
, L
".") != 0)
2124 && (StrCmp(ShellInfoNode
->FileName
, L
"..") != 0)
2129 if (EFI_ERROR(Status
)) {
2133 // Open the directory since we need that handle in the next recursion.
2135 ShellInfoNode
->Status
= EfiShellOpenFileByName (ShellInfoNode
->FullName
, &ShellInfoNode
->Handle
, EFI_FILE_MODE_READ
);
2138 // recurse with the next part of the pattern
2140 Status
= ShellSearchHandle(NextFilePatternStart
, UnicodeCollation
, ShellInfoNode
->Handle
, FileList
, ShellInfoNode
, MapName
);
2142 } else if (!EFI_ERROR(Status
)) {
2148 // copy the information we need into a new Node
2150 NewShellNode
= InternalDuplicateShellFileInfo(ShellInfoNode
, FALSE
);
2151 ASSERT(NewShellNode
!= NULL
);
2152 if (NewShellNode
== NULL
) {
2153 Status
= EFI_OUT_OF_RESOURCES
;
2155 if (*FileList
== NULL
) {
2156 *FileList
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2157 InitializeListHead(&((*FileList
)->Link
));
2161 // Add to the returning to use list
2163 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
2166 if (EFI_ERROR(Status
)) {
2170 if (EFI_ERROR(Status
)) {
2171 EfiShellFreeFileList(&ShellInfo
);
2173 Status
= EfiShellFreeFileList(&ShellInfo
);
2178 FreePool(CurrentFilePattern
);
2183 Find files that match a specified pattern.
2185 This function searches for all files and directories that match the specified
2186 FilePattern. The FilePattern can contain wild-card characters. The resulting file
2187 information is placed in the file list FileList.
2189 Wildcards are processed
2190 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1.
2192 The files in the file list are not opened. The OpenMode field is set to 0 and the FileInfo
2193 field is set to NULL.
2195 if *FileList is not NULL then it must be a pre-existing and properly initialized list.
2197 @param FilePattern Points to a NULL-terminated shell file path, including wildcards.
2198 @param FileList On return, points to the start of a file list containing the names
2199 of all matching files or else points to NULL if no matching files
2200 were found. only on a EFI_SUCCESS return will; this be non-NULL.
2202 @retval EFI_SUCCESS Files found. FileList is a valid list.
2203 @retval EFI_NOT_FOUND No files found.
2204 @retval EFI_NO_MEDIA The device has no media
2205 @retval EFI_DEVICE_ERROR The device reported an error
2206 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted
2211 IN CONST CHAR16
*FilePattern
,
2212 OUT EFI_SHELL_FILE_INFO
**FileList
2216 CHAR16
*PatternCopy
;
2217 CHAR16
*PatternCurrentLocation
;
2218 EFI_DEVICE_PATH_PROTOCOL
*RootDevicePath
;
2219 SHELL_FILE_HANDLE RootFileHandle
;
2223 if ( FilePattern
== NULL
2225 || StrStr(FilePattern
, L
":") == NULL
2227 return (EFI_INVALID_PARAMETER
);
2229 Status
= EFI_SUCCESS
;
2230 RootDevicePath
= NULL
;
2231 RootFileHandle
= NULL
;
2233 PatternCopy
= AllocateZeroPool(StrSize(FilePattern
));
2234 if (PatternCopy
== NULL
) {
2235 return (EFI_OUT_OF_RESOURCES
);
2237 StrCpy(PatternCopy
, FilePattern
);
2239 PatternCopy
= PathCleanUpDirectories(PatternCopy
);
2241 Count
= StrStr(PatternCopy
, L
":") - PatternCopy
;
2244 ASSERT(MapName
== NULL
);
2245 MapName
= StrnCatGrow(&MapName
, NULL
, PatternCopy
, Count
);
2246 if (MapName
== NULL
) {
2247 Status
= EFI_OUT_OF_RESOURCES
;
2249 RootDevicePath
= EfiShellGetDevicePathFromFilePath(PatternCopy
);
2250 if (RootDevicePath
== NULL
) {
2251 Status
= EFI_INVALID_PARAMETER
;
2253 Status
= EfiShellOpenRoot(RootDevicePath
, &RootFileHandle
);
2254 if (!EFI_ERROR(Status
)) {
2255 for ( PatternCurrentLocation
= PatternCopy
2256 ; *PatternCurrentLocation
!= ':'
2257 ; PatternCurrentLocation
++);
2258 PatternCurrentLocation
++;
2259 Status
= ShellSearchHandle(PatternCurrentLocation
, gUnicodeCollation
, RootFileHandle
, FileList
, NULL
, MapName
);
2261 FreePool(RootDevicePath
);
2265 SHELL_FREE_NON_NULL(PatternCopy
);
2266 SHELL_FREE_NON_NULL(MapName
);
2272 Opens the files that match the path specified.
2274 This function opens all of the files specified by Path. Wildcards are processed
2275 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1. Each
2276 matching file has an EFI_SHELL_FILE_INFO structure created in a linked list.
2278 @param Path A pointer to the path string.
2279 @param OpenMode Specifies the mode used to open each file, EFI_FILE_MODE_READ or
2280 EFI_FILE_MODE_WRITE.
2281 @param FileList Points to the start of a list of files opened.
2283 @retval EFI_SUCCESS Create the file list successfully.
2284 @return Others Can't create the file list.
2288 EfiShellOpenFileList(
2291 IN OUT EFI_SHELL_FILE_INFO
**FileList
2295 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
2298 CONST CHAR16
*CurDir
;
2301 PathCleanUpDirectories(Path
);
2306 if (FileList
== NULL
|| *FileList
== NULL
) {
2307 return (EFI_INVALID_PARAMETER
);
2310 if (*Path
== L
'.' && *(Path
+1) == L
'\\') {
2315 // convert a local path to an absolute path
2317 if (StrStr(Path
, L
":") == NULL
) {
2318 CurDir
= EfiShellGetCurDir(NULL
);
2319 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2320 StrnCatGrow(&Path2
, &Path2Size
, CurDir
, 0);
2321 if (*Path
== L
'\\') {
2323 while (PathRemoveLastItem(Path2
)) ;
2325 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2326 StrnCatGrow(&Path2
, &Path2Size
, Path
, 0);
2328 ASSERT(Path2
== NULL
);
2329 StrnCatGrow(&Path2
, NULL
, Path
, 0);
2332 PathCleanUpDirectories (Path2
);
2337 Status
= EfiShellFindFiles(Path2
, FileList
);
2341 if (EFI_ERROR(Status
)) {
2347 // We had no errors so open all the files (that are not already opened...)
2349 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
2350 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2351 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2353 if (ShellFileListItem
->Status
== 0 && ShellFileListItem
->Handle
== NULL
) {
2354 ShellFileListItem
->Status
= EfiShellOpenFileByName (ShellFileListItem
->FullName
, &ShellFileListItem
->Handle
, OpenMode
);
2360 return (EFI_NOT_FOUND
);
2362 return(EFI_SUCCESS
);
2366 This function updated with errata.
2368 Gets either a single or list of environment variables.
2370 If name is not NULL then this function returns the current value of the specified
2371 environment variable.
2373 If Name is NULL, then a list of all environment variable names is returned. Each is a
2374 NULL terminated string with a double NULL terminating the list.
2376 @param Name A pointer to the environment variable name. If
2377 Name is NULL, then the function will return all
2378 of the defined shell environment variables. In
2379 the case where multiple environment variables are
2380 being returned, each variable will be terminated by
2381 a NULL, and the list will be terminated by a double
2384 @return !=NULL A pointer to the returned string.
2385 The returned pointer does not need to be freed by the caller.
2387 @retval NULL The environment variable doesn't exist or there are
2388 no environment variables.
2393 IN CONST CHAR16
*Name
2401 CHAR16
*CurrentWriteLocation
;
2408 // Get all our environment variables
2410 InitializeListHead(&List
);
2411 Status
= GetEnvironmentVariableList(&List
);
2412 if (EFI_ERROR(Status
)){
2417 // Build the semi-colon delimited list. (2 passes)
2419 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&List
)
2420 ; !IsNull(&List
, &Node
->Link
)
2421 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&List
, &Node
->Link
)
2423 ASSERT(Node
->Key
!= NULL
);
2424 Size
+= StrSize(Node
->Key
);
2427 Size
+= 2*sizeof(CHAR16
);
2429 Buffer
= AllocateZeroPool(Size
);
2430 if (Buffer
== NULL
) {
2431 if (!IsListEmpty (&List
)) {
2432 FreeEnvironmentVariableList(&List
);
2436 CurrentWriteLocation
= (CHAR16
*)Buffer
;
2438 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&List
)
2439 ; !IsNull(&List
, &Node
->Link
)
2440 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&List
, &Node
->Link
)
2442 ASSERT(Node
->Key
!= NULL
);
2443 StrCpy(CurrentWriteLocation
, Node
->Key
);
2444 CurrentWriteLocation
+= StrLen(CurrentWriteLocation
) + 1;
2450 if (!IsListEmpty (&List
)) {
2451 FreeEnvironmentVariableList(&List
);
2455 // We are doing a specific environment variable
2459 // get the size we need for this EnvVariable
2461 Status
= SHELL_GET_ENVIRONMENT_VARIABLE(Name
, &Size
, Buffer
);
2462 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2464 // Allocate the space and recall the get function
2466 Buffer
= AllocateZeroPool(Size
);
2467 ASSERT(Buffer
!= NULL
);
2468 Status
= SHELL_GET_ENVIRONMENT_VARIABLE(Name
, &Size
, Buffer
);
2471 // we didnt get it (might not exist)
2472 // free the memory if we allocated any and return NULL
2474 if (EFI_ERROR(Status
)) {
2475 if (Buffer
!= NULL
) {
2483 // return the buffer
2485 return (AddBufferToFreeList(Buffer
));
2489 Internal variable setting function. Allows for setting of the read only variables.
2491 @param Name Points to the NULL-terminated environment variable name.
2492 @param Value Points to the NULL-terminated environment variable value. If the value is an
2493 empty string then the environment variable is deleted.
2494 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2496 @retval EFI_SUCCESS The environment variable was successfully updated.
2500 InternalEfiShellSetEnv(
2501 IN CONST CHAR16
*Name
,
2502 IN CONST CHAR16
*Value
,
2506 if (Value
== NULL
|| StrLen(Value
) == 0) {
2507 return (SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
));
2509 SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
);
2511 return (SHELL_SET_ENVIRONMENT_VARIABLE_V(Name
, StrSize(Value
), Value
));
2513 return (SHELL_SET_ENVIRONMENT_VARIABLE_NV(Name
, StrSize(Value
), Value
));
2519 Sets the environment variable.
2521 This function changes the current value of the specified environment variable. If the
2522 environment variable exists and the Value is an empty string, then the environment
2523 variable is deleted. If the environment variable exists and the Value is not an empty
2524 string, then the value of the environment variable is changed. If the environment
2525 variable does not exist and the Value is an empty string, there is no action. If the
2526 environment variable does not exist and the Value is a non-empty string, then the
2527 environment variable is created and assigned the specified value.
2529 For a description of volatile and non-volatile environment variables, see UEFI Shell
2530 2.0 specification section 3.6.1.
2532 @param Name Points to the NULL-terminated environment variable name.
2533 @param Value Points to the NULL-terminated environment variable value. If the value is an
2534 empty string then the environment variable is deleted.
2535 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2537 @retval EFI_SUCCESS The environment variable was successfully updated.
2542 IN CONST CHAR16
*Name
,
2543 IN CONST CHAR16
*Value
,
2547 if (Name
== NULL
|| *Name
== CHAR_NULL
) {
2548 return (EFI_INVALID_PARAMETER
);
2551 // Make sure we dont 'set' a predefined read only variable
2553 if (gUnicodeCollation
->StriColl(
2557 ||gUnicodeCollation
->StriColl(
2561 ||gUnicodeCollation
->StriColl(
2565 ||gUnicodeCollation
->StriColl(
2568 L
"uefishellsupport") == 0
2569 ||gUnicodeCollation
->StriColl(
2572 L
"uefishellversion") == 0
2573 ||gUnicodeCollation
->StriColl(
2576 L
"uefiversion") == 0
2578 return (EFI_INVALID_PARAMETER
);
2580 return (InternalEfiShellSetEnv(Name
, Value
, Volatile
));
2584 Returns the current directory on the specified device.
2586 If FileSystemMapping is NULL, it returns the current working directory. If the
2587 FileSystemMapping is not NULL, it returns the current directory associated with the
2588 FileSystemMapping. In both cases, the returned name includes the file system
2589 mapping (i.e. fs0:\current-dir).
2591 @param FileSystemMapping A pointer to the file system mapping. If NULL,
2592 then the current working directory is returned.
2594 @retval !=NULL The current directory.
2595 @retval NULL Current directory does not exist.
2600 IN CONST CHAR16
*FileSystemMapping OPTIONAL
2603 CHAR16
*PathToReturn
;
2605 SHELL_MAP_LIST
*MapListItem
;
2606 if (!IsListEmpty(&gShellMapList
.Link
)) {
2608 // if parameter is NULL, use current
2610 if (FileSystemMapping
== NULL
) {
2611 return (EfiShellGetEnv(L
"cwd"));
2614 PathToReturn
= NULL
;
2615 MapListItem
= ShellCommandFindMapItem(FileSystemMapping
);
2616 if (MapListItem
!= NULL
) {
2617 ASSERT((PathToReturn
== NULL
&& Size
== 0) || (PathToReturn
!= NULL
));
2618 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->MapName
, 0);
2619 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
2622 return (AddBufferToFreeList(PathToReturn
));
2629 Changes the current directory on the specified device.
2631 If the FileSystem is NULL, and the directory Dir does not contain a file system's
2632 mapped name, this function changes the current working directory.
2634 If the FileSystem is NULL and the directory Dir contains a mapped name, then the
2635 current file system and the current directory on that file system are changed.
2637 If FileSystem is NULL, and Dir is not NULL, then this changes the current working file
2640 If FileSystem is not NULL and Dir is not NULL, then this function changes the current
2641 directory on the specified file system.
2643 If the current working directory or the current working file system is changed then the
2644 %cwd% environment variable will be updated
2646 @param FileSystem A pointer to the file system's mapped name. If NULL, then the current working
2647 directory is changed.
2648 @param Dir Points to the NULL-terminated directory on the device specified by FileSystem.
2650 @retval EFI_SUCCESS The operation was sucessful
2651 @retval EFI_NOT_FOUND The file system could not be found
2656 IN CONST CHAR16
*FileSystem OPTIONAL
,
2657 IN CONST CHAR16
*Dir
2661 SHELL_MAP_LIST
*MapListItem
;
2665 CHAR16
*DirectoryName
;
2672 DirectoryName
= NULL
;
2674 if ((FileSystem
== NULL
&& Dir
== NULL
) || Dir
== NULL
) {
2675 return (EFI_INVALID_PARAMETER
);
2678 if (IsListEmpty(&gShellMapList
.Link
)){
2679 return (EFI_NOT_FOUND
);
2682 DirectoryName
= StrnCatGrow(&DirectoryName
, NULL
, Dir
, 0);
2683 ASSERT(DirectoryName
!= NULL
);
2685 PathCleanUpDirectories(DirectoryName
);
2687 if (FileSystem
== NULL
) {
2689 // determine the file system mapping to use
2691 if (StrStr(DirectoryName
, L
":") != NULL
) {
2692 ASSERT(MapName
== NULL
);
2693 MapName
= StrnCatGrow(&MapName
, NULL
, DirectoryName
, (StrStr(DirectoryName
, L
":")-DirectoryName
+1));
2696 // find the file system mapping's entry in the list
2699 if (MapName
!= NULL
) {
2700 MapListItem
= ShellCommandFindMapItem(MapName
);
2703 // make that the current file system mapping
2705 if (MapListItem
!= NULL
) {
2706 gShellCurDir
= MapListItem
;
2709 MapListItem
= gShellCurDir
;
2712 if (MapListItem
== NULL
) {
2713 return (EFI_NOT_FOUND
);
2717 // now update the MapListItem's current directory
2719 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& DirectoryName
[StrLen(DirectoryName
) - 1] != L
':') {
2720 FreePool(MapListItem
->CurrentDirectoryPath
);
2721 MapListItem
->CurrentDirectoryPath
= NULL
;
2723 if (MapName
!= NULL
) {
2724 TempLen
= StrLen(MapName
);
2725 if (TempLen
!= StrLen(DirectoryName
)) {
2726 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2727 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
+StrLen(MapName
), 0);
2730 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2731 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
2733 if ((MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] != L
'\\') || (MapListItem
->CurrentDirectoryPath
== NULL
)) {
2734 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2735 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2739 // cant have a mapping in the directory...
2741 if (StrStr(DirectoryName
, L
":") != NULL
) {
2742 return (EFI_INVALID_PARAMETER
);
2745 // FileSystem != NULL
2747 MapListItem
= ShellCommandFindMapItem(FileSystem
);
2748 if (MapListItem
== NULL
) {
2749 return (EFI_INVALID_PARAMETER
);
2751 // gShellCurDir = MapListItem;
2752 if (DirectoryName
!= NULL
) {
2754 // change current dir on that file system
2757 if (MapListItem
->CurrentDirectoryPath
!= NULL
) {
2758 FreePool(MapListItem
->CurrentDirectoryPath
);
2759 DEBUG_CODE(MapListItem
->CurrentDirectoryPath
= NULL
;);
2761 // ASSERT((MapListItem->CurrentDirectoryPath == NULL && Size == 0) || (MapListItem->CurrentDirectoryPath != NULL));
2762 // MapListItem->CurrentDirectoryPath = StrnCatGrow(&MapListItem->CurrentDirectoryPath, &Size, FileSystem, 0);
2763 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2764 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2765 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2766 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
2767 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] != L
'\\') {
2768 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2769 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2774 // if updated the current directory then update the environment variable
2776 if (MapListItem
== gShellCurDir
) {
2778 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
2779 StrnCatGrow(&TempString
, &Size
, MapListItem
->MapName
, 0);
2780 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
2781 StrnCatGrow(&TempString
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
2782 Status
= InternalEfiShellSetEnv(L
"cwd", TempString
, TRUE
);
2783 FreePool(TempString
);
2786 return(EFI_SUCCESS
);
2790 Return help information about a specific command.
2792 This function returns the help information for the specified command. The help text
2793 can be internal to the shell or can be from a UEFI Shell manual page.
2795 If Sections is specified, then each section name listed will be compared in a casesensitive
2796 manner, to the section names described in Appendix B. If the section exists,
2797 it will be appended to the returned help text. If the section does not exist, no
2798 information will be returned. If Sections is NULL, then all help text information
2799 available will be returned.
2801 @param Command Points to the NULL-terminated UEFI Shell command name.
2802 @param Sections Points to the NULL-terminated comma-delimited
2803 section names to return. If NULL, then all
2804 sections will be returned.
2805 @param HelpText On return, points to a callee-allocated buffer
2806 containing all specified help text.
2808 @retval EFI_SUCCESS The help text was returned.
2809 @retval EFI_OUT_OF_RESOURCES The necessary buffer could not be allocated to hold the
2811 @retval EFI_INVALID_PARAMETER HelpText is NULL
2812 @retval EFI_NOT_FOUND There is no help text available for Command.
2816 EfiShellGetHelpText(
2817 IN CONST CHAR16
*Command
,
2818 IN CONST CHAR16
*Sections OPTIONAL
,
2819 OUT CHAR16
**HelpText
2822 CONST CHAR16
*ManFileName
;
2826 ASSERT(HelpText
!= NULL
);
2829 ManFileName
= ShellCommandGetManFileNameHandler(Command
);
2831 if (ManFileName
!= NULL
) {
2832 return (ProcessManFile(ManFileName
, Command
, Sections
, NULL
, HelpText
));
2834 if ((StrLen(Command
)> 4)
2835 && (Command
[StrLen(Command
)-1] == L
'i' || Command
[StrLen(Command
)-1] == L
'I')
2836 && (Command
[StrLen(Command
)-2] == L
'f' || Command
[StrLen(Command
)-2] == L
'F')
2837 && (Command
[StrLen(Command
)-3] == L
'e' || Command
[StrLen(Command
)-3] == L
'E')
2838 && (Command
[StrLen(Command
)-4] == L
'.')
2840 FixCommand
= AllocateZeroPool(StrSize(Command
) - 4 * sizeof (CHAR16
));
2841 ASSERT(FixCommand
!= NULL
);
2843 StrnCpy(FixCommand
, Command
, StrLen(Command
)-4);
2844 Status
= ProcessManFile(FixCommand
, FixCommand
, Sections
, NULL
, HelpText
);
2845 FreePool(FixCommand
);
2848 return (ProcessManFile(Command
, Command
, Sections
, NULL
, HelpText
));
2854 Gets the enable status of the page break output mode.
2856 User can use this function to determine current page break mode.
2858 @retval TRUE The page break output mode is enabled.
2859 @retval FALSE The page break output mode is disabled.
2863 EfiShellGetPageBreak(
2867 return(ShellInfoObject
.PageBreakEnabled
);
2871 Judges whether the active shell is the root shell.
2873 This function makes the user to know that whether the active Shell is the root shell.
2875 @retval TRUE The active Shell is the root Shell.
2876 @retval FALSE The active Shell is NOT the root Shell.
2880 EfiShellIsRootShell(
2884 return(ShellInfoObject
.RootShellInstance
);
2888 function to return a semi-colon delimeted list of all alias' in the current shell
2890 up to caller to free the memory.
2892 @retval NULL No alias' were found
2893 @retval NULL An error ocurred getting alias'
2894 @return !NULL a list of all alias'
2898 InternalEfiShellGetListAlias(
2906 CHAR16
*VariableName
;
2911 Status
= gRT
->QueryVariableInfo(EFI_VARIABLE_NON_VOLATILE
|EFI_VARIABLE_BOOTSERVICE_ACCESS
, &MaxStorSize
, &RemStorSize
, &MaxVarSize
);
2912 ASSERT_EFI_ERROR(Status
);
2914 VariableName
= AllocateZeroPool((UINTN
)MaxVarSize
);
2918 if (VariableName
== NULL
) {
2922 VariableName
[0] = CHAR_NULL
;
2925 NameSize
= (UINTN
)MaxVarSize
;
2926 Status
= gRT
->GetNextVariableName(&NameSize
, VariableName
, &Guid
);
2927 if (Status
== EFI_NOT_FOUND
){
2930 ASSERT_EFI_ERROR(Status
);
2931 if (EFI_ERROR(Status
)) {
2934 if (CompareGuid(&Guid
, &gShellAliasGuid
)){
2935 ASSERT((RetVal
== NULL
&& RetSize
== 0) || (RetVal
!= NULL
));
2936 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, VariableName
, 0);
2937 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, L
";", 0);
2940 FreePool(VariableName
);
2946 This function returns the command associated with a alias or a list of all
2949 @param[in] Alias Points to the NULL-terminated shell alias.
2950 If this parameter is NULL, then all
2951 aliases will be returned in ReturnedData.
2952 @param[out] Volatile upon return of a single command if TRUE indicates
2953 this is stored in a volatile fashion. FALSE otherwise.
2955 @return If Alias is not NULL, it will return a pointer to
2956 the NULL-terminated command for that alias.
2957 If Alias is NULL, ReturnedData points to a ';'
2958 delimited list of alias (e.g.
2959 ReturnedData = "dir;del;copy;mfp") that is NULL-terminated.
2960 @retval NULL an error ocurred
2961 @retval NULL Alias was not a valid Alias
2966 IN CONST CHAR16
*Alias
,
2967 OUT BOOLEAN
*Volatile OPTIONAL
2975 if (Alias
!= NULL
) {
2976 if (Volatile
== NULL
) {
2977 return (AddBufferToFreeList(GetVariable((CHAR16
*)Alias
, &gShellAliasGuid
)));
2981 Status
= gRT
->GetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
2982 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2983 RetVal
= AllocateZeroPool(RetSize
);
2984 Status
= gRT
->GetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
2986 if (EFI_ERROR(Status
)) {
2987 if (RetVal
!= NULL
) {
2992 if ((EFI_VARIABLE_NON_VOLATILE
& Attribs
) == EFI_VARIABLE_NON_VOLATILE
) {
2998 return (AddBufferToFreeList(RetVal
));
3000 return (AddBufferToFreeList(InternalEfiShellGetListAlias()));
3004 Changes a shell command alias.
3006 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3008 this function does not check for built in alias'.
3010 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3011 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3012 Command refers to an alias, that alias will be deleted.
3013 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3014 Alias being set will be stored in a non-volatile fashion.
3016 @retval EFI_SUCCESS Alias created or deleted successfully.
3017 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3022 IN CONST CHAR16
*Command
,
3023 IN CONST CHAR16
*Alias
,
3028 // We must be trying to remove one if Alias is NULL
3030 if (Alias
== NULL
) {
3032 // remove an alias (but passed in COMMAND parameter)
3034 return (gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
));
3037 // Add and replace are the same
3040 // We dont check the error return on purpose since the variable may not exist.
3041 gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
);
3043 return (gRT
->SetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, EFI_VARIABLE_BOOTSERVICE_ACCESS
|(Volatile
?0:EFI_VARIABLE_NON_VOLATILE
), StrSize(Command
), (VOID
*)Command
));
3048 Changes a shell command alias.
3050 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3053 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3054 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3055 Command refers to an alias, that alias will be deleted.
3056 @param[in] Replace If TRUE and the alias already exists, then the existing alias will be replaced. If
3057 FALSE and the alias already exists, then the existing alias is unchanged and
3058 EFI_ACCESS_DENIED is returned.
3059 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3060 Alias being set will be stored in a non-volatile fashion.
3062 @retval EFI_SUCCESS Alias created or deleted successfully.
3063 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3064 @retval EFI_ACCESS_DENIED The alias is a built-in alias or already existed and Replace was set to
3070 IN CONST CHAR16
*Command
,
3071 IN CONST CHAR16
*Alias
,
3077 // cant set over a built in alias
3079 if (ShellCommandIsOnAliasList(Alias
==NULL
?Command
:Alias
)) {
3080 return (EFI_ACCESS_DENIED
);
3082 if (Command
== NULL
|| *Command
== CHAR_NULL
|| StrLen(Command
) == 0) {
3083 return (EFI_INVALID_PARAMETER
);
3086 if (EfiShellGetAlias(Command
, NULL
) != NULL
&& !Replace
) {
3087 return (EFI_ACCESS_DENIED
);
3090 return (InternalSetAlias(Command
, Alias
, Volatile
));
3093 // Pure FILE_HANDLE operations are passed to FileHandleLib
3094 // these functions are indicated by the *
3095 EFI_SHELL_PROTOCOL mShellProtocol
= {
3101 EfiShellGetHelpText
,
3102 EfiShellGetDevicePathFromMap
,
3103 EfiShellGetMapFromDevicePath
,
3104 EfiShellGetDevicePathFromFilePath
,
3105 EfiShellGetFilePathFromDevicePath
,
3109 EfiShellOpenFileList
,
3110 EfiShellFreeFileList
,
3111 EfiShellRemoveDupInFileList
,
3112 EfiShellBatchIsActive
,
3113 EfiShellIsRootShell
,
3114 EfiShellEnablePageBreak
,
3115 EfiShellDisablePageBreak
,
3116 EfiShellGetPageBreak
,
3117 EfiShellGetDeviceName
,
3118 (EFI_SHELL_GET_FILE_INFO
)FileHandleGetInfo
, //*
3119 (EFI_SHELL_SET_FILE_INFO
)FileHandleSetInfo
, //*
3120 EfiShellOpenFileByName
,
3123 (EFI_SHELL_READ_FILE
)FileHandleRead
, //*
3124 (EFI_SHELL_WRITE_FILE
)FileHandleWrite
, //*
3125 (EFI_SHELL_DELETE_FILE
)FileHandleDelete
, //*
3126 EfiShellDeleteFileByName
,
3127 (EFI_SHELL_GET_FILE_POSITION
)FileHandleGetPosition
, //*
3128 (EFI_SHELL_SET_FILE_POSITION
)FileHandleSetPosition
, //*
3129 (EFI_SHELL_FLUSH_FILE
)FileHandleFlush
, //*
3131 EfiShellFindFilesInDir
,
3132 (EFI_SHELL_GET_FILE_SIZE
)FileHandleGetSize
, //*
3134 EfiShellOpenRootByHandle
,
3136 SHELL_MAJOR_VERSION
,
3141 Function to create and install on the current handle.
3143 Will overwrite any existing ShellProtocols in the system to be sure that
3144 the current shell is in control.
3146 This must be removed via calling CleanUpShellProtocol().
3148 @param[in, out] NewShell The pointer to the pointer to the structure
3151 @retval EFI_SUCCESS The operation was successful.
3152 @return An error from LocateHandle, CreateEvent, or other core function.
3156 CreatePopulateInstallShellProtocol (
3157 IN OUT EFI_SHELL_PROTOCOL
**NewShell
3163 UINTN HandleCounter
;
3164 SHELL_PROTOCOL_HANDLE_LIST
*OldProtocolNode
;
3166 if (NewShell
== NULL
) {
3167 return (EFI_INVALID_PARAMETER
);
3172 OldProtocolNode
= NULL
;
3173 InitializeListHead(&ShellInfoObject
.OldShellList
.Link
);
3176 // Initialize EfiShellProtocol object...
3178 Status
= gBS
->CreateEvent(0,
3182 &mShellProtocol
.ExecutionBreak
);
3183 if (EFI_ERROR(Status
)) {
3188 // Get the size of the buffer we need.
3190 Status
= gBS
->LocateHandle(ByProtocol
,
3191 &gEfiShellProtocolGuid
,
3195 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3197 // Allocate and recall with buffer of correct size
3199 Buffer
= AllocateZeroPool(BufferSize
);
3200 if (Buffer
== NULL
) {
3201 return (EFI_OUT_OF_RESOURCES
);
3203 Status
= gBS
->LocateHandle(ByProtocol
,
3204 &gEfiShellProtocolGuid
,
3208 if (EFI_ERROR(Status
)) {
3213 // now overwrite each of them, but save the info to restore when we end.
3215 for (HandleCounter
= 0 ; HandleCounter
< (BufferSize
/sizeof(EFI_HANDLE
)) ; HandleCounter
++) {
3216 OldProtocolNode
= AllocateZeroPool(sizeof(SHELL_PROTOCOL_HANDLE_LIST
));
3217 ASSERT(OldProtocolNode
!= NULL
);
3218 Status
= gBS
->OpenProtocol(Buffer
[HandleCounter
],
3219 &gEfiShellProtocolGuid
,
3220 (VOID
**) &(OldProtocolNode
->Interface
),
3223 EFI_OPEN_PROTOCOL_GET_PROTOCOL
3225 if (!EFI_ERROR(Status
)) {
3227 // reinstall over the old one...
3229 OldProtocolNode
->Handle
= Buffer
[HandleCounter
];
3230 Status
= gBS
->ReinstallProtocolInterface(
3231 OldProtocolNode
->Handle
,
3232 &gEfiShellProtocolGuid
,
3233 OldProtocolNode
->Interface
,
3234 (VOID
*)(&mShellProtocol
));
3235 if (!EFI_ERROR(Status
)) {
3237 // we reinstalled sucessfully. log this so we can reverse it later.
3241 // add to the list for subsequent...
3243 InsertTailList(&ShellInfoObject
.OldShellList
.Link
, &OldProtocolNode
->Link
);
3248 } else if (Status
== EFI_NOT_FOUND
) {
3249 ASSERT(IsListEmpty(&ShellInfoObject
.OldShellList
.Link
));
3251 // no one else published yet. just publish it ourselves.
3253 Status
= gBS
->InstallProtocolInterface (
3255 &gEfiShellProtocolGuid
,
3256 EFI_NATIVE_INTERFACE
,
3257 (VOID
*)(&mShellProtocol
));
3260 if (PcdGetBool(PcdShellSupportOldProtocols
)){
3261 ///@todo support ShellEnvironment2
3262 ///@todo do we need to support ShellEnvironment (not ShellEnvironment2) also?
3265 if (!EFI_ERROR(Status
)) {
3266 *NewShell
= &mShellProtocol
;
3272 Opposite of CreatePopulateInstallShellProtocol.
3274 Free all memory and restore the system to the state it was in before calling
3275 CreatePopulateInstallShellProtocol.
3277 @param[in, out] NewShell The pointer to the new shell protocol structure.
3279 @retval EFI_SUCCESS The operation was successful.
3283 CleanUpShellProtocol (
3284 IN OUT EFI_SHELL_PROTOCOL
*NewShell
3288 SHELL_PROTOCOL_HANDLE_LIST
*Node2
;
3289 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3292 // if we need to restore old protocols...
3294 if (!IsListEmpty(&ShellInfoObject
.OldShellList
.Link
)) {
3295 for (Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*)GetFirstNode(&ShellInfoObject
.OldShellList
.Link
)
3296 ; !IsListEmpty (&ShellInfoObject
.OldShellList
.Link
)
3297 ; Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*)GetFirstNode(&ShellInfoObject
.OldShellList
.Link
)
3299 RemoveEntryList(&Node2
->Link
);
3300 Status
= gBS
->ReinstallProtocolInterface(Node2
->Handle
,
3301 &gEfiShellProtocolGuid
,
3308 // no need to restore
3310 Status
= gBS
->UninstallProtocolInterface(gImageHandle
,
3311 &gEfiShellProtocolGuid
,
3314 Status
= gBS
->CloseEvent(NewShell
->ExecutionBreak
);
3315 NewShell
->ExecutionBreak
= NULL
;
3317 Status
= gBS
->OpenProtocol(
3318 gST
->ConsoleInHandle
,
3319 &gEfiSimpleTextInputExProtocolGuid
,
3323 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3325 if (!EFI_ERROR (Status
)) {
3326 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle1
);
3327 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle2
);
3328 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle3
);
3329 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle4
);
3330 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle1
);
3331 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle2
);
3332 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle3
);
3333 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle4
);
3339 Notification function for keystrokes.
3341 @param[in] KeyData The key that was pressed.
3343 @retval EFI_SUCCESS The operation was successful.
3347 NotificationFunction(
3348 IN EFI_KEY_DATA
*KeyData
3351 if ( ((KeyData
->Key
.UnicodeChar
== L
'c') &&
3352 (KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
) || KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
))) ||
3353 (KeyData
->Key
.UnicodeChar
== 3)
3355 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3356 return (EFI_UNSUPPORTED
);
3358 return (gBS
->SignalEvent(ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
));
3359 } else if ((KeyData
->Key
.UnicodeChar
== L
's') &&
3360 (KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
) || KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
))
3362 ShellInfoObject
.HaltOutput
= TRUE
;
3364 return (EFI_SUCCESS
);
3368 Function to start monitoring for CTRL-C using SimpleTextInputEx. This
3369 feature's enabled state was not known when the shell initially launched.
3371 @retval EFI_SUCCESS The feature is enabled.
3372 @retval EFI_OUT_OF_RESOURCES There is not enough mnemory available.
3376 InernalEfiShellStartMonitor(
3380 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3381 EFI_KEY_DATA KeyData
;
3384 Status
= gBS
->OpenProtocol(
3385 gST
->ConsoleInHandle
,
3386 &gEfiSimpleTextInputExProtocolGuid
,
3390 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3391 if (EFI_ERROR(Status
)) {
3396 STRING_TOKEN (STR_SHELL_NO_IN_EX
),
3397 ShellInfoObject
.HiiHandle
);
3398 return (EFI_SUCCESS
);
3401 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3402 return (EFI_UNSUPPORTED
);
3405 KeyData
.KeyState
.KeyToggleState
= 0;
3406 KeyData
.Key
.ScanCode
= 0;
3407 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3408 KeyData
.Key
.UnicodeChar
= L
'c';
3410 Status
= SimpleEx
->RegisterKeyNotify(
3413 NotificationFunction
,
3414 &ShellInfoObject
.CtrlCNotifyHandle1
);
3416 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3417 if (!EFI_ERROR(Status
)) {
3418 Status
= SimpleEx
->RegisterKeyNotify(
3421 NotificationFunction
,
3422 &ShellInfoObject
.CtrlCNotifyHandle2
);
3424 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3425 KeyData
.Key
.UnicodeChar
= 3;
3426 if (!EFI_ERROR(Status
)) {
3427 Status
= SimpleEx
->RegisterKeyNotify(
3430 NotificationFunction
,
3431 &ShellInfoObject
.CtrlCNotifyHandle3
);
3433 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3434 if (!EFI_ERROR(Status
)) {
3435 Status
= SimpleEx
->RegisterKeyNotify(
3438 NotificationFunction
,
3439 &ShellInfoObject
.CtrlCNotifyHandle4
);