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
));
462 AlignedNode
= AllocateCopyPool (DevicePathNodeLength(FilePath
), FilePath
);
464 // File Path Device Path Nodes 'can optionally add a "\" separator to
465 // the beginning and/or the end of the Path Name string.'
466 // (UEFI Spec 2.4 section 9.3.6.4).
467 // If necessary, add a "\", but otherwise don't
468 // (This is specified in the above section, and also implied by the
469 // UEFI Shell spec section 3.7)
470 if ((PathForReturn
[PathSize
- 1] != L
'\\') &&
471 (AlignedNode
->PathName
[0] != L
'\\')) {
472 PathForReturn
= StrnCatGrow (&PathForReturn
, &PathSize
, L
"\\", 1);
475 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, AlignedNode
->PathName
, 0);
476 FreePool(AlignedNode
);
478 } // for loop of remaining nodes
480 if (PathForReturn
!= NULL
) {
483 } // for loop of paths to check
484 return(PathForReturn
);
488 Converts a file system style name to a device path.
490 This function converts a file system style name to a device path, by replacing any
491 mapping references to the associated device path.
493 @param[in] Path The pointer to the path.
495 @return The pointer of the file path. The file path is callee
496 allocated and should be freed by the caller.
497 @retval NULL The path could not be found.
498 @retval NULL There was not enough available memory.
500 EFI_DEVICE_PATH_PROTOCOL
*
502 EfiShellGetDevicePathFromFilePath(
503 IN CONST CHAR16
*Path
510 CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
511 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
512 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopyForFree
;
513 EFI_DEVICE_PATH_PROTOCOL
*DevicePathForReturn
;
524 if (StrStr(Path
, L
":") == NULL
) {
525 Cwd
= EfiShellGetCurDir(NULL
);
530 Size
+= StrSize(Path
);
531 NewPath
= AllocateZeroPool(Size
);
532 if (NewPath
== NULL
) {
535 StrCpy(NewPath
, Cwd
);
536 if (*Path
== L
'\\') {
538 while (PathRemoveLastItem(NewPath
)) ;
540 StrCat(NewPath
, Path
);
541 DevicePathForReturn
= EfiShellGetDevicePathFromFilePath(NewPath
);
543 return (DevicePathForReturn
);
548 // find the part before (but including) the : for the map name
550 ASSERT((MapName
== NULL
&& Size
== 0) || (MapName
!= NULL
));
551 MapName
= StrnCatGrow(&MapName
, &Size
, Path
, (StrStr(Path
, L
":")-Path
+1));
552 if (MapName
== NULL
|| MapName
[StrLen(MapName
)-1] != L
':') {
557 // look up the device path in the map
559 DevicePath
= EfiShellGetDevicePathFromMap(MapName
);
560 if (DevicePath
== NULL
) {
562 // Must have been a bad Mapname
568 // make a copy for LocateDevicePath to modify (also save a pointer to call FreePool with)
570 DevicePathCopyForFree
= DevicePathCopy
= DuplicateDevicePath(DevicePath
);
571 if (DevicePathCopy
== NULL
) {
580 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &Handle
);
581 if (EFI_ERROR(Status
)) {
582 if (DevicePathCopyForFree
!= NULL
) {
583 FreePool(DevicePathCopyForFree
);
590 // build the full device path
592 if (*(Path
+StrLen(MapName
)+1) == CHAR_NULL
) {
593 DevicePathForReturn
= FileDevicePath(Handle
, L
"\\");
595 DevicePathForReturn
= FileDevicePath(Handle
, Path
+StrLen(MapName
));
599 if (DevicePathCopyForFree
!= NULL
) {
600 FreePool(DevicePathCopyForFree
);
603 return (DevicePathForReturn
);
607 Gets the name of the device specified by the device handle.
609 This function gets the user-readable name of the device specified by the device
610 handle. If no user-readable name could be generated, then *BestDeviceName will be
611 NULL and EFI_NOT_FOUND will be returned.
613 If EFI_DEVICE_NAME_USE_COMPONENT_NAME is set, then the function will return the
614 device's name using the EFI_COMPONENT_NAME2_PROTOCOL, if present on
617 If EFI_DEVICE_NAME_USE_DEVICE_PATH is set, then the function will return the
618 device's name using the EFI_DEVICE_PATH_PROTOCOL, if present on DeviceHandle.
619 If both EFI_DEVICE_NAME_USE_COMPONENT_NAME and
620 EFI_DEVICE_NAME_USE_DEVICE_PATH are set, then
621 EFI_DEVICE_NAME_USE_COMPONENT_NAME will have higher priority.
623 @param DeviceHandle The handle of the device.
624 @param Flags Determines the possible sources of component names.
626 EFI_DEVICE_NAME_USE_COMPONENT_NAME
627 EFI_DEVICE_NAME_USE_DEVICE_PATH
628 @param Language A pointer to the language specified for the device
629 name, in the same format as described in the UEFI
630 specification, Appendix M
631 @param BestDeviceName On return, points to the callee-allocated NULL-
632 terminated name of the device. If no device name
633 could be found, points to NULL. The name must be
634 freed by the caller...
636 @retval EFI_SUCCESS Get the name successfully.
637 @retval EFI_NOT_FOUND Fail to get the device name.
638 @retval EFI_INVALID_PARAMETER Flags did not have a valid bit set.
639 @retval EFI_INVALID_PARAMETER BestDeviceName was NULL
640 @retval EFI_INVALID_PARAMETER DeviceHandle was NULL
644 EfiShellGetDeviceName(
645 IN EFI_HANDLE DeviceHandle
,
646 IN EFI_SHELL_DEVICE_NAME_FLAGS Flags
,
648 OUT CHAR16
**BestDeviceName
652 EFI_COMPONENT_NAME2_PROTOCOL
*CompName2
;
653 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
654 EFI_HANDLE
*HandleList
;
657 CHAR16
*DeviceNameToReturn
;
659 UINTN ParentControllerCount
;
660 EFI_HANDLE
*ParentControllerBuffer
;
661 UINTN ParentDriverCount
;
662 EFI_HANDLE
*ParentDriverBuffer
;
664 if (BestDeviceName
== NULL
||
667 return (EFI_INVALID_PARAMETER
);
671 // make sure one of the 2 supported bits is on
673 if (((Flags
& EFI_DEVICE_NAME_USE_COMPONENT_NAME
) == 0) &&
674 ((Flags
& EFI_DEVICE_NAME_USE_DEVICE_PATH
) == 0)) {
675 return (EFI_INVALID_PARAMETER
);
678 DeviceNameToReturn
= NULL
;
679 *BestDeviceName
= NULL
;
684 if ((Flags
& EFI_DEVICE_NAME_USE_COMPONENT_NAME
) != 0) {
685 Status
= ParseHandleDatabaseByRelationship(
688 HR_DRIVER_BINDING_HANDLE
|HR_DEVICE_DRIVER
,
691 for (LoopVar
= 0; LoopVar
< HandleCount
; LoopVar
++){
693 // Go through those handles until we get one that passes for GetComponentName
695 Status
= gBS
->OpenProtocol(
697 &gEfiComponentName2ProtocolGuid
,
701 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
702 if (EFI_ERROR(Status
)) {
703 Status
= gBS
->OpenProtocol(
705 &gEfiComponentNameProtocolGuid
,
709 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
712 if (EFI_ERROR(Status
)) {
715 Lang
= GetBestLanguageForDriver(CompName2
->SupportedLanguages
, Language
, FALSE
);
716 Status
= CompName2
->GetControllerName(CompName2
, DeviceHandle
, NULL
, Lang
, &DeviceNameToReturn
);
719 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
723 if (HandleList
!= NULL
) {
724 FreePool(HandleList
);
728 // Now check the parent controller using this as the child.
730 if (DeviceNameToReturn
== NULL
){
731 PARSE_HANDLE_DATABASE_PARENTS(DeviceHandle
, &ParentControllerCount
, &ParentControllerBuffer
);
732 for (LoopVar
= 0 ; LoopVar
< ParentControllerCount
; LoopVar
++) {
733 PARSE_HANDLE_DATABASE_UEFI_DRIVERS(ParentControllerBuffer
[LoopVar
], &ParentDriverCount
, &ParentDriverBuffer
);
734 for (HandleCount
= 0 ; HandleCount
< ParentDriverCount
; HandleCount
++) {
736 // try using that driver's component name with controller and our driver as the child.
738 Status
= gBS
->OpenProtocol(
739 ParentDriverBuffer
[HandleCount
],
740 &gEfiComponentName2ProtocolGuid
,
744 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
745 if (EFI_ERROR(Status
)) {
746 Status
= gBS
->OpenProtocol(
747 ParentDriverBuffer
[HandleCount
],
748 &gEfiComponentNameProtocolGuid
,
752 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
755 if (EFI_ERROR(Status
)) {
758 Lang
= GetBestLanguageForDriver(CompName2
->SupportedLanguages
, Language
, FALSE
);
759 Status
= CompName2
->GetControllerName(CompName2
, ParentControllerBuffer
[LoopVar
], DeviceHandle
, Lang
, &DeviceNameToReturn
);
762 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
769 SHELL_FREE_NON_NULL(ParentDriverBuffer
);
770 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
774 SHELL_FREE_NON_NULL(ParentControllerBuffer
);
777 // dont return on fail since we will try device path if that bit is on
779 if (DeviceNameToReturn
!= NULL
){
780 ASSERT(BestDeviceName
!= NULL
);
781 StrnCatGrow(BestDeviceName
, NULL
, DeviceNameToReturn
, 0);
782 return (EFI_SUCCESS
);
785 if ((Flags
& EFI_DEVICE_NAME_USE_DEVICE_PATH
) != 0) {
786 Status
= gBS
->OpenProtocol(
788 &gEfiDevicePathProtocolGuid
,
792 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
793 if (!EFI_ERROR(Status
)) {
795 // use device path to text on the device path
797 *BestDeviceName
= ConvertDevicePathToText(DevicePath
, TRUE
, TRUE
);
798 return (EFI_SUCCESS
);
802 // none of the selected bits worked.
804 return (EFI_NOT_FOUND
);
808 Opens the root directory of a device on a handle
810 This function opens the root directory of a device and returns a file handle to it.
812 @param DeviceHandle The handle of the device that contains the volume.
813 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
816 @retval EFI_SUCCESS Root opened successfully.
817 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
819 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
820 @retval EFI_DEVICE_ERROR The device had an error
824 EfiShellOpenRootByHandle(
825 IN EFI_HANDLE DeviceHandle
,
826 OUT SHELL_FILE_HANDLE
*FileHandle
830 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
*SimpleFileSystem
;
831 EFI_FILE_PROTOCOL
*RealFileHandle
;
832 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
835 // get the simple file system interface
837 Status
= gBS
->OpenProtocol(DeviceHandle
,
838 &gEfiSimpleFileSystemProtocolGuid
,
839 (VOID
**)&SimpleFileSystem
,
842 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
843 if (EFI_ERROR(Status
)) {
844 return (EFI_NOT_FOUND
);
847 Status
= gBS
->OpenProtocol(DeviceHandle
,
848 &gEfiDevicePathProtocolGuid
,
852 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
853 if (EFI_ERROR(Status
)) {
854 return (EFI_NOT_FOUND
);
857 // Open the root volume now...
859 Status
= SimpleFileSystem
->OpenVolume(SimpleFileSystem
, &RealFileHandle
);
860 *FileHandle
= ConvertEfiFileProtocolToShellHandle(RealFileHandle
, EfiShellGetMapFromDevicePath(&DevPath
));
865 Opens the root directory of a device.
867 This function opens the root directory of a device and returns a file handle to it.
869 @param DevicePath Points to the device path corresponding to the device where the
870 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL is installed.
871 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
874 @retval EFI_SUCCESS Root opened successfully.
875 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
877 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
878 @retval EFI_DEVICE_ERROR The device had an error
879 @retval EFI_INVALID_PARAMETER FileHandle is NULL.
884 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
885 OUT SHELL_FILE_HANDLE
*FileHandle
891 if (FileHandle
== NULL
) {
892 return (EFI_INVALID_PARAMETER
);
896 // find the handle of the device with that device handle and the file system
899 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
,
902 if (EFI_ERROR(Status
)) {
903 return (EFI_NOT_FOUND
);
906 return (EfiShellOpenRootByHandle(Handle
, FileHandle
));
910 Returns whether any script files are currently being processed.
912 @retval TRUE There is at least one script file active.
913 @retval FALSE No script files are active now.
918 EfiShellBatchIsActive (
922 if (ShellCommandGetCurrentScriptFile() == NULL
) {
929 Worker function to open a file based on a device path. this will open the root
930 of the volume and then traverse down to the file itself.
932 @param DevicePath Device Path of the file.
933 @param FileHandle Pointer to the file upon a successful return.
934 @param OpenMode mode to open file in.
935 @param Attributes the File Attributes to use when creating a new file.
937 @retval EFI_SUCCESS the file is open and FileHandle is valid
938 @retval EFI_UNSUPPORTED the device path cotained non-path elements
939 @retval other an error ocurred.
943 InternalOpenFileDevicePath(
944 IN OUT EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
945 OUT SHELL_FILE_HANDLE
*FileHandle
,
947 IN UINT64 Attributes OPTIONAL
951 FILEPATH_DEVICE_PATH
*FilePathNode
;
953 SHELL_FILE_HANDLE ShellHandle
;
954 EFI_FILE_PROTOCOL
*Handle1
;
955 EFI_FILE_PROTOCOL
*Handle2
;
956 FILEPATH_DEVICE_PATH
*AlignedNode
;
958 if (FileHandle
== NULL
) {
959 return (EFI_INVALID_PARAMETER
);
969 Status
= EfiShellOpenRoot(DevicePath
, &ShellHandle
);
971 if (!EFI_ERROR(Status
)) {
972 Handle1
= ConvertShellHandleToEfiFileProtocol(ShellHandle
);
973 if (Handle1
!= NULL
) {
975 // chop off the begining part before the file system part...
978 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
,
981 if (!EFI_ERROR(Status
)) {
983 // To access as a file system, the file path should only
984 // contain file path components. Follow the file path nodes
985 // and find the target file
987 for ( FilePathNode
= (FILEPATH_DEVICE_PATH
*)DevicePath
988 ; !IsDevicePathEnd (&FilePathNode
->Header
)
989 ; FilePathNode
= (FILEPATH_DEVICE_PATH
*) NextDevicePathNode (&FilePathNode
->Header
)
991 SHELL_FREE_NON_NULL(AlignedNode
);
992 AlignedNode
= AllocateCopyPool (DevicePathNodeLength(FilePathNode
), FilePathNode
);
994 // For file system access each node should be a file path component
996 if (DevicePathType (&FilePathNode
->Header
) != MEDIA_DEVICE_PATH
||
997 DevicePathSubType (&FilePathNode
->Header
) != MEDIA_FILEPATH_DP
999 Status
= EFI_UNSUPPORTED
;
1004 // Open this file path node
1010 // if this is the last node in the DevicePath always create (if that was requested).
1012 if (IsDevicePathEnd ((NextDevicePathNode (&FilePathNode
->Header
)))) {
1013 Status
= Handle2
->Open (
1016 AlignedNode
->PathName
,
1023 // This is not the last node and we dont want to 'create' existing
1024 // directory entries...
1028 // open without letting it create
1029 // prevents error on existing files/directories
1031 Status
= Handle2
->Open (
1034 AlignedNode
->PathName
,
1035 OpenMode
&~EFI_FILE_MODE_CREATE
,
1039 // if above failed now open and create the 'item'
1040 // if OpenMode EFI_FILE_MODE_CREATE bit was on (but disabled above)
1042 if ((EFI_ERROR (Status
)) && ((OpenMode
& EFI_FILE_MODE_CREATE
) != 0)) {
1043 Status
= Handle2
->Open (
1046 AlignedNode
->PathName
,
1053 // Close the last node
1055 ShellInfoObject
.NewEfiShellProtocol
->CloseFile (Handle2
);
1058 // If there's been an error, stop
1060 if (EFI_ERROR (Status
)) {
1067 SHELL_FREE_NON_NULL(AlignedNode
);
1068 if (EFI_ERROR(Status
)) {
1069 if (Handle1
!= NULL
) {
1070 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(Handle1
);
1073 *FileHandle
= ConvertEfiFileProtocolToShellHandle(Handle1
, ShellFileHandleGetPath(ShellHandle
));
1079 Creates a file or directory by name.
1081 This function creates an empty new file or directory with the specified attributes and
1082 returns the new file's handle. If the file already exists and is read-only, then
1083 EFI_INVALID_PARAMETER will be returned.
1085 If the file already existed, it is truncated and its attributes updated. If the file is
1086 created successfully, the FileHandle is the file's handle, else, the FileHandle is NULL.
1088 If the file name begins with >v, then the file handle which is returned refers to the
1089 shell environment variable with the specified name. If the shell environment variable
1090 already exists and is non-volatile then EFI_INVALID_PARAMETER is returned.
1092 @param FileName Pointer to NULL-terminated file path
1093 @param FileAttribs The new file's attrbiutes. the different attributes are
1094 described in EFI_FILE_PROTOCOL.Open().
1095 @param FileHandle On return, points to the created file handle or directory's handle
1097 @retval EFI_SUCCESS The file was opened. FileHandle points to the new file's handle.
1098 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1099 @retval EFI_UNSUPPORTED could not open the file path
1100 @retval EFI_NOT_FOUND the specified file could not be found on the devide, or could not
1101 file the file system on the device.
1102 @retval EFI_NO_MEDIA the device has no medium.
1103 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1105 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1107 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1108 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1109 when the media is write-protected.
1110 @retval EFI_ACCESS_DENIED The service denied access to the file.
1111 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file.
1112 @retval EFI_VOLUME_FULL The volume is full.
1117 IN CONST CHAR16
*FileName
,
1118 IN UINT64 FileAttribs
,
1119 OUT SHELL_FILE_HANDLE
*FileHandle
1122 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1126 // Is this for an environment variable
1127 // do we start with >v
1129 if (StrStr(FileName
, L
">v") == FileName
) {
1130 if (!IsVolatileEnv(FileName
+2)) {
1131 return (EFI_INVALID_PARAMETER
);
1133 *FileHandle
= CreateFileInterfaceEnv(FileName
+2);
1134 return (EFI_SUCCESS
);
1138 // We are opening a regular file.
1140 DevicePath
= EfiShellGetDevicePathFromFilePath(FileName
);
1141 if (DevicePath
== NULL
) {
1142 return (EFI_NOT_FOUND
);
1145 Status
= InternalOpenFileDevicePath(DevicePath
, FileHandle
, EFI_FILE_MODE_READ
|EFI_FILE_MODE_WRITE
|EFI_FILE_MODE_CREATE
, FileAttribs
); // 0 = no specific file attributes
1146 FreePool(DevicePath
);
1152 Opens a file or a directory by file name.
1154 This function opens the specified file in the specified OpenMode and returns a file
1156 If the file name begins with >v, then the file handle which is returned refers to the
1157 shell environment variable with the specified name. If the shell environment variable
1158 exists, is non-volatile and the OpenMode indicates EFI_FILE_MODE_WRITE, then
1159 EFI_INVALID_PARAMETER is returned.
1161 If the file name is >i, then the file handle which is returned refers to the standard
1162 input. If the OpenMode indicates EFI_FILE_MODE_WRITE, then EFI_INVALID_PARAMETER
1165 If the file name is >o, then the file handle which is returned refers to the standard
1166 output. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1169 If the file name is >e, then the file handle which is returned refers to the standard
1170 error. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1173 If the file name is NUL, then the file handle that is returned refers to the standard NUL
1174 file. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER is
1177 If return EFI_SUCCESS, the FileHandle is the opened file's handle, else, the
1180 @param FileName Points to the NULL-terminated UCS-2 encoded file name.
1181 @param FileHandle On return, points to the file handle.
1182 @param OpenMode File open mode. Either EFI_FILE_MODE_READ or
1183 EFI_FILE_MODE_WRITE from section 12.4 of the UEFI
1185 @retval EFI_SUCCESS The file was opened. FileHandle has the opened file's handle.
1186 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value. FileHandle is NULL.
1187 @retval EFI_UNSUPPORTED Could not open the file path. FileHandle is NULL.
1188 @retval EFI_NOT_FOUND The specified file could not be found on the device or the file
1189 system could not be found on the device. FileHandle is NULL.
1190 @retval EFI_NO_MEDIA The device has no medium. FileHandle is NULL.
1191 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1192 longer supported. FileHandle is NULL.
1193 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1194 the FileName. FileHandle is NULL.
1195 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted. FileHandle is NULL.
1196 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1197 when the media is write-protected. FileHandle is NULL.
1198 @retval EFI_ACCESS_DENIED The service denied access to the file. FileHandle is NULL.
1199 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file. FileHandle
1201 @retval EFI_VOLUME_FULL The volume is full. FileHandle is NULL.
1205 EfiShellOpenFileByName(
1206 IN CONST CHAR16
*FileName
,
1207 OUT SHELL_FILE_HANDLE
*FileHandle
,
1211 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1217 // Is this for StdIn
1219 if (StrCmp(FileName
, L
">i") == 0) {
1221 // make sure not writing to StdIn
1223 if ((OpenMode
& EFI_FILE_MODE_WRITE
) != 0) {
1224 return (EFI_INVALID_PARAMETER
);
1226 *FileHandle
= ShellInfoObject
.NewShellParametersProtocol
->StdIn
;
1227 ASSERT(*FileHandle
!= NULL
);
1228 return (EFI_SUCCESS
);
1232 // Is this for StdOut
1234 if (StrCmp(FileName
, L
">o") == 0) {
1236 // make sure not writing to StdIn
1238 if ((OpenMode
& EFI_FILE_MODE_READ
) != 0) {
1239 return (EFI_INVALID_PARAMETER
);
1241 *FileHandle
= &FileInterfaceStdOut
;
1242 return (EFI_SUCCESS
);
1246 // Is this for NUL file
1248 if (StrCmp(FileName
, L
"NUL") == 0) {
1249 *FileHandle
= &FileInterfaceNulFile
;
1250 return (EFI_SUCCESS
);
1254 // Is this for StdErr
1256 if (StrCmp(FileName
, L
">e") == 0) {
1258 // make sure not writing to StdIn
1260 if ((OpenMode
& EFI_FILE_MODE_READ
) != 0) {
1261 return (EFI_INVALID_PARAMETER
);
1263 *FileHandle
= &FileInterfaceStdErr
;
1264 return (EFI_SUCCESS
);
1268 // Is this for an environment variable
1269 // do we start with >v
1271 if (StrStr(FileName
, L
">v") == FileName
) {
1272 if (!IsVolatileEnv(FileName
+2) &&
1273 ((OpenMode
& EFI_FILE_MODE_WRITE
) != 0)) {
1274 return (EFI_INVALID_PARAMETER
);
1276 *FileHandle
= CreateFileInterfaceEnv(FileName
+2);
1277 return (EFI_SUCCESS
);
1281 // We are opening a regular file.
1283 DevicePath
= EfiShellGetDevicePathFromFilePath(FileName
);
1284 // DEBUG_CODE(InternalShellProtocolDebugPrintMessage (NULL, DevicePath););
1285 if (DevicePath
== NULL
) {
1286 return (EFI_NOT_FOUND
);
1290 // Copy the device path, open the file, then free the memory
1292 Status
= InternalOpenFileDevicePath(DevicePath
, FileHandle
, OpenMode
, 0); // 0 = no specific file attributes
1293 FreePool(DevicePath
);
1299 Deletes the file specified by the file name.
1301 This function deletes a file.
1303 @param FileName Points to the NULL-terminated file name.
1305 @retval EFI_SUCCESS The file was closed and deleted, and the handle was closed.
1306 @retval EFI_WARN_DELETE_FAILURE The handle was closed but the file was not deleted.
1307 @sa EfiShellCreateFile
1311 EfiShellDeleteFileByName(
1312 IN CONST CHAR16
*FileName
1315 SHELL_FILE_HANDLE FileHandle
;
1319 // get a handle to the file
1321 Status
= EfiShellCreateFile(FileName
,
1324 if (EFI_ERROR(Status
)) {
1328 // now delete the file
1330 return (ShellInfoObject
.NewEfiShellProtocol
->DeleteFile(FileHandle
));
1334 Disables the page break output mode.
1338 EfiShellDisablePageBreak (
1342 ShellInfoObject
.PageBreakEnabled
= FALSE
;
1346 Enables the page break output mode.
1350 EfiShellEnablePageBreak (
1354 ShellInfoObject
.PageBreakEnabled
= TRUE
;
1358 internal worker function to load and run an image via device path.
1360 @param ParentImageHandle A handle of the image that is executing the specified
1362 @param DevicePath device path of the file to execute
1363 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1364 containing the command line. If NULL then the command-
1366 @param Environment Points to a NULL-terminated array of environment
1367 variables with the format 'x=y', where x is the
1368 environment variable name and y is the value. If this
1369 is NULL, then the current shell environment is used.
1371 @param[out] ExitDataSize ExitDataSize as returned from gBS->StartImage
1372 @param[out] ExitData ExitData as returned from gBS->StartImage
1374 @retval EFI_SUCCESS The command executed successfully. The status code
1375 returned by the command is pointed to by StatusCode.
1376 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1377 @retval EFI_OUT_OF_RESOURCES Out of resources.
1378 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1382 InternalShellExecuteDevicePath(
1383 IN CONST EFI_HANDLE
*ParentImageHandle
,
1384 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
1385 IN CONST CHAR16
*CommandLine OPTIONAL
,
1386 IN CONST CHAR16
**Environment OPTIONAL
,
1387 OUT UINTN
*ExitDataSize OPTIONAL
,
1388 OUT CHAR16
**ExitData OPTIONAL
1392 EFI_STATUS CleanupStatus
;
1393 EFI_HANDLE NewHandle
;
1394 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
1395 LIST_ENTRY OrigEnvs
;
1396 EFI_SHELL_PARAMETERS_PROTOCOL ShellParamsProtocol
;
1397 UINTN InternalExitDataSize
;
1398 UINTN
*ExitDataSizePtr
;
1402 // ExitDataSize is not OPTIONAL for gBS->BootServices, provide somewhere for
1403 // it to be dumped if the caller doesn't want it.
1404 if (ExitData
== NULL
) {
1405 ExitDataSizePtr
= &InternalExitDataSize
;
1407 ExitDataSizePtr
= ExitDataSize
;
1410 if (ParentImageHandle
== NULL
) {
1411 return (EFI_INVALID_PARAMETER
);
1414 InitializeListHead(&OrigEnvs
);
1419 // Load the image with:
1420 // FALSE - not from boot manager and NULL, 0 being not already in memory
1422 Status
= gBS
->LoadImage(
1425 (EFI_DEVICE_PATH_PROTOCOL
*)DevicePath
,
1430 if (EFI_ERROR(Status
)) {
1431 if (NewHandle
!= NULL
) {
1432 gBS
->UnloadImage(NewHandle
);
1436 Status
= gBS
->OpenProtocol(
1438 &gEfiLoadedImageProtocolGuid
,
1439 (VOID
**)&LoadedImage
,
1442 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
1444 if (!EFI_ERROR(Status
)) {
1445 ASSERT(LoadedImage
->LoadOptionsSize
== 0);
1446 if (CommandLine
!= NULL
) {
1447 LoadedImage
->LoadOptionsSize
= (UINT32
)StrSize(CommandLine
);
1448 LoadedImage
->LoadOptions
= (VOID
*)CommandLine
;
1452 // Save our current environment settings for later restoration if necessary
1454 if (Environment
!= NULL
) {
1455 Status
= GetEnvironmentVariableList(&OrigEnvs
);
1456 if (!EFI_ERROR(Status
)) {
1457 Status
= SetEnvironmentVariables(Environment
);
1462 // Initialize and install a shell parameters protocol on the image.
1464 ShellParamsProtocol
.StdIn
= ShellInfoObject
.NewShellParametersProtocol
->StdIn
;
1465 ShellParamsProtocol
.StdOut
= ShellInfoObject
.NewShellParametersProtocol
->StdOut
;
1466 ShellParamsProtocol
.StdErr
= ShellInfoObject
.NewShellParametersProtocol
->StdErr
;
1467 Status
= UpdateArgcArgv(&ShellParamsProtocol
, CommandLine
, NULL
, NULL
);
1468 ASSERT_EFI_ERROR(Status
);
1470 // Replace Argv[0] with the full path of the binary we're executing:
1471 // If the command line was "foo", the binary might be called "foo.efi".
1472 // "The first entry in [Argv] is always the full file path of the
1473 // executable" - UEFI Shell Spec section 2.3
1475 ImagePath
= EfiShellGetFilePathFromDevicePath (DevicePath
);
1476 // The image we're executing isn't necessarily in a filesystem - it might
1477 // be memory mapped. In this case EfiShellGetFilePathFromDevicePath will
1478 // return NULL, and we'll leave Argv[0] as UpdateArgcArgv set it.
1479 if (ImagePath
!= NULL
) {
1480 if (ShellParamsProtocol
.Argv
== NULL
) {
1481 // Command line was empty or null.
1482 // (UpdateArgcArgv sets Argv to NULL when CommandLine is "" or NULL)
1483 ShellParamsProtocol
.Argv
= AllocatePool (sizeof (CHAR16
*));
1484 if (ShellParamsProtocol
.Argv
== NULL
) {
1485 Status
= EFI_OUT_OF_RESOURCES
;
1488 ShellParamsProtocol
.Argc
= 1;
1490 // Free the string UpdateArgcArgv put in Argv[0];
1491 FreePool (ShellParamsProtocol
.Argv
[0]);
1493 ShellParamsProtocol
.Argv
[0] = ImagePath
;
1496 Status
= gBS
->InstallProtocolInterface(&NewHandle
, &gEfiShellParametersProtocolGuid
, EFI_NATIVE_INTERFACE
, &ShellParamsProtocol
);
1497 ASSERT_EFI_ERROR(Status
);
1499 ///@todo initialize and install ShellInterface protocol on the new image for compatibility if - PcdGetBool(PcdShellSupportOldProtocols)
1502 // now start the image, passing up exit data if the caller requested it
1504 if (!EFI_ERROR(Status
)) {
1505 Status
= gBS
->StartImage(
1511 CleanupStatus
= gBS
->UninstallProtocolInterface(
1513 &gEfiShellParametersProtocolGuid
,
1514 &ShellParamsProtocol
1516 ASSERT_EFI_ERROR(CleanupStatus
);
1522 // Unload image - We should only get here if we didn't call StartImage
1523 gBS
->UnloadImage (NewHandle
);
1526 // Free Argv (Allocated in UpdateArgcArgv)
1527 if (ShellParamsProtocol
.Argv
!= NULL
) {
1528 for (Index
= 0; Index
< ShellParamsProtocol
.Argc
; Index
++) {
1529 if (ShellParamsProtocol
.Argv
[Index
] != NULL
) {
1530 FreePool (ShellParamsProtocol
.Argv
[Index
]);
1533 FreePool (ShellParamsProtocol
.Argv
);
1537 // Restore environment variables
1538 if (!IsListEmpty(&OrigEnvs
)) {
1539 CleanupStatus
= SetEnvironmentVariableList(&OrigEnvs
);
1540 ASSERT_EFI_ERROR (CleanupStatus
);
1546 Execute the command line.
1548 This function creates a nested instance of the shell and executes the specified
1549 command (CommandLine) with the specified environment (Environment). Upon return,
1550 the status code returned by the specified command is placed in StatusCode.
1552 If Environment is NULL, then the current environment is used and all changes made
1553 by the commands executed will be reflected in the current environment. If the
1554 Environment is non-NULL, then the changes made will be discarded.
1556 The CommandLine is executed from the current working directory on the current
1559 @param ParentImageHandle A handle of the image that is executing the specified
1561 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1562 containing the command line. If NULL then the command-
1564 @param Environment Points to a NULL-terminated array of environment
1565 variables with the format 'x=y', where x is the
1566 environment variable name and y is the value. If this
1567 is NULL, then the current shell environment is used.
1568 @param StatusCode Points to the status code returned by the command.
1570 @retval EFI_SUCCESS The command executed successfully. The status code
1571 returned by the command is pointed to by StatusCode.
1572 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1573 @retval EFI_OUT_OF_RESOURCES Out of resources.
1574 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1575 @retval EFI_UNSUPPORTED The support level required for this function is not present.
1577 @sa InternalShellExecuteDevicePath
1582 IN EFI_HANDLE
*ParentImageHandle
,
1583 IN CHAR16
*CommandLine OPTIONAL
,
1584 IN CHAR16
**Environment OPTIONAL
,
1585 OUT EFI_STATUS
*StatusCode OPTIONAL
1590 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
1595 if ((PcdGet8(PcdShellSupportLevel
) < 1)) {
1596 return (EFI_UNSUPPORTED
);
1599 DevPath
= AppendDevicePath (ShellInfoObject
.ImageDevPath
, ShellInfoObject
.FileDevPath
);
1602 Temp
= ConvertDevicePathToText(ShellInfoObject
.FileDevPath
, TRUE
, TRUE
);
1604 Temp
= ConvertDevicePathToText(ShellInfoObject
.ImageDevPath
, TRUE
, TRUE
);
1606 Temp
= ConvertDevicePathToText(DevPath
, TRUE
, TRUE
);
1612 ASSERT((Temp
== NULL
&& Size
== 0) || (Temp
!= NULL
));
1613 StrnCatGrow(&Temp
, &Size
, L
"Shell.efi -_exit ", 0);
1614 StrnCatGrow(&Temp
, &Size
, CommandLine
, 0);
1616 Status
= InternalShellExecuteDevicePath(
1620 (CONST CHAR16
**)Environment
,
1624 if (Status
== EFI_ABORTED
) {
1625 // If the command exited with an error, the shell should put the exit
1626 // status in ExitData, preceded by a null-terminated string.
1627 ASSERT (ExitDataSize
== StrSize (ExitData
) + sizeof (SHELL_STATUS
));
1629 if (StatusCode
!= NULL
) {
1630 // Skip the null-terminated string
1631 ExitData
+= StrLen (ExitData
) + 1;
1633 // Use CopyMem to avoid alignment faults
1634 CopyMem (StatusCode
, ExitData
, sizeof (SHELL_STATUS
));
1636 // Convert from SHELL_STATUS to EFI_STATUS
1637 // EFI_STATUSes have top bit set when they are errors.
1638 // (See UEFI Spec Appendix D)
1639 if (*StatusCode
!= SHELL_SUCCESS
) {
1640 *StatusCode
= (EFI_STATUS
) *StatusCode
| MAX_BIT
;
1643 FreePool (ExitData
);
1644 Status
= EFI_SUCCESS
;
1645 } else if ((StatusCode
!= NULL
) && !EFI_ERROR(Status
)) {
1646 *StatusCode
= EFI_SUCCESS
;
1650 // de-allocate and return
1658 Utility cleanup function for EFI_SHELL_FILE_INFO objects.
1660 1) frees all pointers (non-NULL)
1661 2) Closes the SHELL_FILE_HANDLE
1663 @param FileListNode pointer to the list node to free
1667 InternalFreeShellFileInfoNode(
1668 IN EFI_SHELL_FILE_INFO
*FileListNode
1671 if (FileListNode
->Info
!= NULL
) {
1672 FreePool((VOID
*)FileListNode
->Info
);
1674 if (FileListNode
->FileName
!= NULL
) {
1675 FreePool((VOID
*)FileListNode
->FileName
);
1677 if (FileListNode
->FullName
!= NULL
) {
1678 FreePool((VOID
*)FileListNode
->FullName
);
1680 if (FileListNode
->Handle
!= NULL
) {
1681 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(FileListNode
->Handle
);
1683 FreePool(FileListNode
);
1686 Frees the file list.
1688 This function cleans up the file list and any related data structures. It has no
1689 impact on the files themselves.
1691 @param FileList The file list to free. Type EFI_SHELL_FILE_INFO is
1692 defined in OpenFileList()
1694 @retval EFI_SUCCESS Free the file list successfully.
1695 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1699 EfiShellFreeFileList(
1700 IN EFI_SHELL_FILE_INFO
**FileList
1703 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1705 if (FileList
== NULL
|| *FileList
== NULL
) {
1706 return (EFI_INVALID_PARAMETER
);
1709 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1710 ; !IsListEmpty(&(*FileList
)->Link
)
1711 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1713 RemoveEntryList(&ShellFileListItem
->Link
);
1714 InternalFreeShellFileInfoNode(ShellFileListItem
);
1716 InternalFreeShellFileInfoNode(*FileList
);
1718 return(EFI_SUCCESS
);
1722 Deletes the duplicate file names files in the given file list.
1724 This function deletes the reduplicate files in the given file list.
1726 @param FileList A pointer to the first entry in the file list.
1728 @retval EFI_SUCCESS Always success.
1729 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1733 EfiShellRemoveDupInFileList(
1734 IN EFI_SHELL_FILE_INFO
**FileList
1737 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1738 EFI_SHELL_FILE_INFO
*ShellFileListItem2
;
1739 EFI_SHELL_FILE_INFO
*TempNode
;
1741 if (FileList
== NULL
|| *FileList
== NULL
) {
1742 return (EFI_INVALID_PARAMETER
);
1744 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1745 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1746 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1748 for ( ShellFileListItem2
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1749 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem2
->Link
)
1750 ; ShellFileListItem2
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem2
->Link
)
1752 if (gUnicodeCollation
->StriColl(
1754 (CHAR16
*)ShellFileListItem
->FullName
,
1755 (CHAR16
*)ShellFileListItem2
->FullName
) == 0
1757 TempNode
= (EFI_SHELL_FILE_INFO
*)GetPreviousNode(
1759 &ShellFileListItem2
->Link
1761 RemoveEntryList(&ShellFileListItem2
->Link
);
1762 InternalFreeShellFileInfoNode(ShellFileListItem2
);
1763 // Set ShellFileListItem2 to PreviousNode so we don't access Freed
1764 // memory in GetNextNode in the loop expression above.
1765 ShellFileListItem2
= TempNode
;
1769 return (EFI_SUCCESS
);
1772 Allocates and duplicates a EFI_SHELL_FILE_INFO node.
1774 @param[in] Node The node to copy from.
1775 @param[in] Save TRUE to set Node->Handle to NULL, FALSE otherwise.
1777 @retval NULL a memory allocation error ocurred
1778 @return != NULL a pointer to the new node
1780 EFI_SHELL_FILE_INFO
*
1782 InternalDuplicateShellFileInfo(
1783 IN EFI_SHELL_FILE_INFO
*Node
,
1787 EFI_SHELL_FILE_INFO
*NewNode
;
1789 NewNode
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1790 if (NewNode
== NULL
) {
1793 NewNode
->FullName
= AllocateZeroPool(StrSize(Node
->FullName
));
1795 NewNode
->FileName
= AllocateZeroPool(StrSize(Node
->FileName
));
1796 NewNode
->Info
= AllocateZeroPool((UINTN
)Node
->Info
->Size
);
1797 if ( NewNode
->FullName
== NULL
1798 || NewNode
->FileName
== NULL
1799 || NewNode
->Info
== NULL
1803 NewNode
->Status
= Node
->Status
;
1804 NewNode
->Handle
= Node
->Handle
;
1806 Node
->Handle
= NULL
;
1808 StrCpy((CHAR16
*)NewNode
->FullName
, Node
->FullName
);
1809 StrCpy((CHAR16
*)NewNode
->FileName
, Node
->FileName
);
1810 CopyMem(NewNode
->Info
, Node
->Info
, (UINTN
)Node
->Info
->Size
);
1816 Allocates and populates a EFI_SHELL_FILE_INFO structure. if any memory operation
1817 failed it will return NULL.
1819 @param[in] BasePath the Path to prepend onto filename for FullPath
1820 @param[in] Status Status member initial value.
1821 @param[in] FileName FileName member initial value.
1822 @param[in] Handle Handle member initial value.
1823 @param[in] Info Info struct to copy.
1825 @retval NULL An error ocurred.
1826 @return a pointer to the newly allocated structure.
1828 EFI_SHELL_FILE_INFO
*
1830 CreateAndPopulateShellFileInfo(
1831 IN CONST CHAR16
*BasePath
,
1832 IN CONST EFI_STATUS Status
,
1833 IN CONST CHAR16
*FileName
,
1834 IN CONST SHELL_FILE_HANDLE Handle
,
1835 IN CONST EFI_FILE_INFO
*Info
1838 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1845 ShellFileListItem
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1846 if (ShellFileListItem
== NULL
) {
1849 if (Info
!= NULL
&& Info
->Size
!= 0) {
1850 ShellFileListItem
->Info
= AllocateZeroPool((UINTN
)Info
->Size
);
1851 if (ShellFileListItem
->Info
== NULL
) {
1852 FreePool(ShellFileListItem
);
1855 CopyMem(ShellFileListItem
->Info
, Info
, (UINTN
)Info
->Size
);
1857 ShellFileListItem
->Info
= NULL
;
1859 if (FileName
!= NULL
) {
1860 ASSERT(TempString
== NULL
);
1861 ShellFileListItem
->FileName
= StrnCatGrow(&TempString
, 0, FileName
, 0);
1862 if (ShellFileListItem
->FileName
== NULL
) {
1863 FreePool(ShellFileListItem
->Info
);
1864 FreePool(ShellFileListItem
);
1868 ShellFileListItem
->FileName
= NULL
;
1872 if (BasePath
!= NULL
) {
1873 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
1874 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
1875 if (TempString
== NULL
) {
1876 FreePool((VOID
*)ShellFileListItem
->FileName
);
1877 FreePool(ShellFileListItem
->Info
);
1878 FreePool(ShellFileListItem
);
1882 if (ShellFileListItem
->FileName
!= NULL
) {
1883 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
1884 TempString
= StrnCatGrow(&TempString
, &Size
, ShellFileListItem
->FileName
, 0);
1885 if (TempString
== NULL
) {
1886 FreePool((VOID
*)ShellFileListItem
->FileName
);
1887 FreePool(ShellFileListItem
->Info
);
1888 FreePool(ShellFileListItem
);
1893 ShellFileListItem
->FullName
= TempString
;
1894 ShellFileListItem
->Status
= Status
;
1895 ShellFileListItem
->Handle
= Handle
;
1897 return (ShellFileListItem
);
1901 Find all files in a specified directory.
1903 @param FileDirHandle Handle of the directory to search.
1904 @param FileList On return, points to the list of files in the directory
1905 or NULL if there are no files in the directory.
1907 @retval EFI_SUCCESS File information was returned successfully.
1908 @retval EFI_VOLUME_CORRUPTED The file system structures have been corrupted.
1909 @retval EFI_DEVICE_ERROR The device reported an error.
1910 @retval EFI_NO_MEDIA The device media is not present.
1911 @retval EFI_INVALID_PARAMETER The FileDirHandle was not a directory.
1912 @return An error from FileHandleGetFileName().
1916 EfiShellFindFilesInDir(
1917 IN SHELL_FILE_HANDLE FileDirHandle
,
1918 OUT EFI_SHELL_FILE_INFO
**FileList
1921 EFI_SHELL_FILE_INFO
*ShellFileList
;
1922 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1923 EFI_FILE_INFO
*FileInfo
;
1931 Status
= FileHandleGetFileName(FileDirHandle
, &BasePath
);
1932 if (EFI_ERROR(Status
)) {
1936 if (ShellFileHandleGetPath(FileDirHandle
) != NULL
) {
1939 TempString
= StrnCatGrow(&TempString
, &Size
, ShellFileHandleGetPath(FileDirHandle
), 0);
1940 if (TempString
== NULL
) {
1941 SHELL_FREE_NON_NULL(BasePath
);
1942 return (EFI_OUT_OF_RESOURCES
);
1944 TempSpot
= StrStr(TempString
, L
";");
1946 if (TempSpot
!= NULL
) {
1947 *TempSpot
= CHAR_NULL
;
1950 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
1951 if (TempString
== NULL
) {
1952 SHELL_FREE_NON_NULL(BasePath
);
1953 return (EFI_OUT_OF_RESOURCES
);
1955 SHELL_FREE_NON_NULL(BasePath
);
1956 BasePath
= TempString
;
1960 ShellFileList
= NULL
;
1961 ShellFileListItem
= NULL
;
1963 Status
= EFI_SUCCESS
;
1966 for ( Status
= FileHandleFindFirstFile(FileDirHandle
, &FileInfo
)
1967 ; !EFI_ERROR(Status
) && !NoFile
1968 ; Status
= FileHandleFindNextFile(FileDirHandle
, FileInfo
, &NoFile
)
1971 // allocate a new EFI_SHELL_FILE_INFO and populate it...
1973 ShellFileListItem
= CreateAndPopulateShellFileInfo(
1975 EFI_SUCCESS
, // success since we didnt fail to open it...
1977 NULL
, // no handle since not open
1980 if (ShellFileList
== NULL
) {
1981 ShellFileList
= (EFI_SHELL_FILE_INFO
*)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1982 ASSERT(ShellFileList
!= NULL
);
1983 InitializeListHead(&ShellFileList
->Link
);
1985 InsertTailList(&ShellFileList
->Link
, &ShellFileListItem
->Link
);
1987 if (EFI_ERROR(Status
)) {
1988 EfiShellFreeFileList(&ShellFileList
);
1991 *FileList
= ShellFileList
;
1993 SHELL_FREE_NON_NULL(BasePath
);
1998 Updates a file name to be preceeded by the mapped drive name
2000 @param[in] BasePath the Mapped drive name to prepend
2001 @param[in, out] Path pointer to pointer to the file name to update.
2004 @retval EFI_OUT_OF_RESOURCES
2009 IN CONST CHAR16
*BasePath
,
2010 IN OUT CHAR16
**Path
2019 ASSERT(Path
!= NULL
);
2020 ASSERT(*Path
!= NULL
);
2021 ASSERT(BasePath
!= NULL
);
2024 // convert a local path to an absolute path
2026 if (StrStr(*Path
, L
":") == NULL
) {
2027 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2028 StrnCatGrow(&Path2
, &Path2Size
, BasePath
, 0);
2029 if (Path2
== NULL
) {
2030 return (EFI_OUT_OF_RESOURCES
);
2032 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2033 StrnCatGrow(&Path2
, &Path2Size
, (*Path
)[0] == L
'\\'?(*Path
) + 1 :*Path
, 0);
2034 if (Path2
== NULL
) {
2035 return (EFI_OUT_OF_RESOURCES
);
2042 return (EFI_SUCCESS
);
2046 If FileHandle is a directory then the function reads from FileHandle and reads in
2047 each of the FileInfo structures. If one of them matches the Pattern's first
2048 "level" then it opens that handle and calls itself on that handle.
2050 If FileHandle is a file and matches all of the remaining Pattern (which would be
2051 on its last node), then add a EFI_SHELL_FILE_INFO object for this file to fileList.
2053 Upon a EFI_SUCCESS return fromt he function any the caller is responsible to call
2054 FreeFileList with FileList.
2056 @param[in] FilePattern The FilePattern to check against.
2057 @param[in] UnicodeCollation The pointer to EFI_UNICODE_COLLATION_PROTOCOL structure
2058 @param[in] FileHandle The FileHandle to start with
2059 @param[in, out] FileList pointer to pointer to list of found files.
2060 @param[in] ParentNode The node for the parent. Same file as identified by HANDLE.
2061 @param[in] MapName The file system name this file is on.
2063 @retval EFI_SUCCESS all files were found and the FileList contains a list.
2064 @retval EFI_NOT_FOUND no files were found
2065 @retval EFI_OUT_OF_RESOURCES a memory allocation failed
2070 IN CONST CHAR16
*FilePattern
,
2071 IN EFI_UNICODE_COLLATION_PROTOCOL
*UnicodeCollation
,
2072 IN SHELL_FILE_HANDLE FileHandle
,
2073 IN OUT EFI_SHELL_FILE_INFO
**FileList
,
2074 IN CONST EFI_SHELL_FILE_INFO
*ParentNode OPTIONAL
,
2075 IN CONST CHAR16
*MapName
2079 CONST CHAR16
*NextFilePatternStart
;
2080 CHAR16
*CurrentFilePattern
;
2081 EFI_SHELL_FILE_INFO
*ShellInfo
;
2082 EFI_SHELL_FILE_INFO
*ShellInfoNode
;
2083 EFI_SHELL_FILE_INFO
*NewShellNode
;
2085 CHAR16
*NewFullName
;
2088 if ( FilePattern
== NULL
2089 || UnicodeCollation
== NULL
2092 return (EFI_INVALID_PARAMETER
);
2095 CurrentFilePattern
= NULL
;
2097 if (*FilePattern
== L
'\\') {
2101 for( NextFilePatternStart
= FilePattern
2102 ; *NextFilePatternStart
!= CHAR_NULL
&& *NextFilePatternStart
!= L
'\\'
2103 ; NextFilePatternStart
++);
2105 CurrentFilePattern
= AllocateZeroPool((NextFilePatternStart
-FilePattern
+1)*sizeof(CHAR16
));
2106 ASSERT(CurrentFilePattern
!= NULL
);
2107 StrnCpy(CurrentFilePattern
, FilePattern
, NextFilePatternStart
-FilePattern
);
2109 if (CurrentFilePattern
[0] == CHAR_NULL
2110 &&NextFilePatternStart
[0] == CHAR_NULL
2113 // Add the current parameter FileHandle to the list, then end...
2115 if (ParentNode
== NULL
) {
2116 Status
= EFI_INVALID_PARAMETER
;
2118 NewShellNode
= InternalDuplicateShellFileInfo((EFI_SHELL_FILE_INFO
*)ParentNode
, TRUE
);
2119 if (NewShellNode
== NULL
) {
2120 Status
= EFI_OUT_OF_RESOURCES
;
2122 NewShellNode
->Handle
= NULL
;
2123 if (*FileList
== NULL
) {
2124 *FileList
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2125 InitializeListHead(&((*FileList
)->Link
));
2129 // Add to the returning to use list
2131 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
2133 Status
= EFI_SUCCESS
;
2137 Status
= EfiShellFindFilesInDir(FileHandle
, &ShellInfo
);
2139 if (!EFI_ERROR(Status
)){
2140 if (StrStr(NextFilePatternStart
, L
"\\") != NULL
){
2145 for ( ShellInfoNode
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&ShellInfo
->Link
)
2146 ; !IsNull (&ShellInfo
->Link
, &ShellInfoNode
->Link
)
2147 ; ShellInfoNode
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&ShellInfo
->Link
, &ShellInfoNode
->Link
)
2149 if (UnicodeCollation
->MetaiMatch(UnicodeCollation
, (CHAR16
*)ShellInfoNode
->FileName
, CurrentFilePattern
)){
2150 if (ShellInfoNode
->FullName
!= NULL
&& StrStr(ShellInfoNode
->FullName
, L
":") == NULL
) {
2151 Size
= StrSize(ShellInfoNode
->FullName
);
2152 Size
+= StrSize(MapName
) + sizeof(CHAR16
);
2153 NewFullName
= AllocateZeroPool(Size
);
2154 if (NewFullName
== NULL
) {
2155 Status
= EFI_OUT_OF_RESOURCES
;
2157 StrCpy(NewFullName
, MapName
);
2158 StrCat(NewFullName
, ShellInfoNode
->FullName
+1);
2159 FreePool((VOID
*)ShellInfoNode
->FullName
);
2160 ShellInfoNode
->FullName
= NewFullName
;
2163 if (Directory
&& !EFI_ERROR(Status
) && ShellInfoNode
->FullName
!= NULL
&& ShellInfoNode
->FileName
!= NULL
){
2165 // should be a directory
2169 // don't open the . and .. directories
2171 if ( (StrCmp(ShellInfoNode
->FileName
, L
".") != 0)
2172 && (StrCmp(ShellInfoNode
->FileName
, L
"..") != 0)
2177 if (EFI_ERROR(Status
)) {
2181 // Open the directory since we need that handle in the next recursion.
2183 ShellInfoNode
->Status
= EfiShellOpenFileByName (ShellInfoNode
->FullName
, &ShellInfoNode
->Handle
, EFI_FILE_MODE_READ
);
2186 // recurse with the next part of the pattern
2188 Status
= ShellSearchHandle(NextFilePatternStart
, UnicodeCollation
, ShellInfoNode
->Handle
, FileList
, ShellInfoNode
, MapName
);
2190 } else if (!EFI_ERROR(Status
)) {
2196 // copy the information we need into a new Node
2198 NewShellNode
= InternalDuplicateShellFileInfo(ShellInfoNode
, FALSE
);
2199 ASSERT(NewShellNode
!= NULL
);
2200 if (NewShellNode
== NULL
) {
2201 Status
= EFI_OUT_OF_RESOURCES
;
2203 if (*FileList
== NULL
) {
2204 *FileList
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2205 InitializeListHead(&((*FileList
)->Link
));
2209 // Add to the returning to use list
2211 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
2214 if (EFI_ERROR(Status
)) {
2218 if (EFI_ERROR(Status
)) {
2219 EfiShellFreeFileList(&ShellInfo
);
2221 Status
= EfiShellFreeFileList(&ShellInfo
);
2226 FreePool(CurrentFilePattern
);
2231 Find files that match a specified pattern.
2233 This function searches for all files and directories that match the specified
2234 FilePattern. The FilePattern can contain wild-card characters. The resulting file
2235 information is placed in the file list FileList.
2237 Wildcards are processed
2238 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1.
2240 The files in the file list are not opened. The OpenMode field is set to 0 and the FileInfo
2241 field is set to NULL.
2243 if *FileList is not NULL then it must be a pre-existing and properly initialized list.
2245 @param FilePattern Points to a NULL-terminated shell file path, including wildcards.
2246 @param FileList On return, points to the start of a file list containing the names
2247 of all matching files or else points to NULL if no matching files
2248 were found. only on a EFI_SUCCESS return will; this be non-NULL.
2250 @retval EFI_SUCCESS Files found. FileList is a valid list.
2251 @retval EFI_NOT_FOUND No files found.
2252 @retval EFI_NO_MEDIA The device has no media
2253 @retval EFI_DEVICE_ERROR The device reported an error
2254 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted
2259 IN CONST CHAR16
*FilePattern
,
2260 OUT EFI_SHELL_FILE_INFO
**FileList
2264 CHAR16
*PatternCopy
;
2265 CHAR16
*PatternCurrentLocation
;
2266 EFI_DEVICE_PATH_PROTOCOL
*RootDevicePath
;
2267 SHELL_FILE_HANDLE RootFileHandle
;
2271 if ( FilePattern
== NULL
2273 || StrStr(FilePattern
, L
":") == NULL
2275 return (EFI_INVALID_PARAMETER
);
2277 Status
= EFI_SUCCESS
;
2278 RootDevicePath
= NULL
;
2279 RootFileHandle
= NULL
;
2281 PatternCopy
= AllocateZeroPool(StrSize(FilePattern
));
2282 if (PatternCopy
== NULL
) {
2283 return (EFI_OUT_OF_RESOURCES
);
2285 StrCpy(PatternCopy
, FilePattern
);
2287 PatternCopy
= PathCleanUpDirectories(PatternCopy
);
2289 Count
= StrStr(PatternCopy
, L
":") - PatternCopy
;
2292 ASSERT(MapName
== NULL
);
2293 MapName
= StrnCatGrow(&MapName
, NULL
, PatternCopy
, Count
);
2294 if (MapName
== NULL
) {
2295 Status
= EFI_OUT_OF_RESOURCES
;
2297 RootDevicePath
= EfiShellGetDevicePathFromFilePath(PatternCopy
);
2298 if (RootDevicePath
== NULL
) {
2299 Status
= EFI_INVALID_PARAMETER
;
2301 Status
= EfiShellOpenRoot(RootDevicePath
, &RootFileHandle
);
2302 if (!EFI_ERROR(Status
)) {
2303 for ( PatternCurrentLocation
= PatternCopy
2304 ; *PatternCurrentLocation
!= ':'
2305 ; PatternCurrentLocation
++);
2306 PatternCurrentLocation
++;
2307 Status
= ShellSearchHandle(PatternCurrentLocation
, gUnicodeCollation
, RootFileHandle
, FileList
, NULL
, MapName
);
2309 FreePool(RootDevicePath
);
2313 SHELL_FREE_NON_NULL(PatternCopy
);
2314 SHELL_FREE_NON_NULL(MapName
);
2320 Opens the files that match the path specified.
2322 This function opens all of the files specified by Path. Wildcards are processed
2323 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1. Each
2324 matching file has an EFI_SHELL_FILE_INFO structure created in a linked list.
2326 @param Path A pointer to the path string.
2327 @param OpenMode Specifies the mode used to open each file, EFI_FILE_MODE_READ or
2328 EFI_FILE_MODE_WRITE.
2329 @param FileList Points to the start of a list of files opened.
2331 @retval EFI_SUCCESS Create the file list successfully.
2332 @return Others Can't create the file list.
2336 EfiShellOpenFileList(
2339 IN OUT EFI_SHELL_FILE_INFO
**FileList
2343 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
2346 CONST CHAR16
*CurDir
;
2349 PathCleanUpDirectories(Path
);
2354 if (FileList
== NULL
|| *FileList
== NULL
) {
2355 return (EFI_INVALID_PARAMETER
);
2358 if (*Path
== L
'.' && *(Path
+1) == L
'\\') {
2363 // convert a local path to an absolute path
2365 if (StrStr(Path
, L
":") == NULL
) {
2366 CurDir
= EfiShellGetCurDir(NULL
);
2367 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2368 StrnCatGrow(&Path2
, &Path2Size
, CurDir
, 0);
2369 if (*Path
== L
'\\') {
2371 while (PathRemoveLastItem(Path2
)) ;
2373 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2374 StrnCatGrow(&Path2
, &Path2Size
, Path
, 0);
2376 ASSERT(Path2
== NULL
);
2377 StrnCatGrow(&Path2
, NULL
, Path
, 0);
2380 PathCleanUpDirectories (Path2
);
2385 Status
= EfiShellFindFiles(Path2
, FileList
);
2389 if (EFI_ERROR(Status
)) {
2395 // We had no errors so open all the files (that are not already opened...)
2397 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
2398 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2399 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2401 if (ShellFileListItem
->Status
== 0 && ShellFileListItem
->Handle
== NULL
) {
2402 ShellFileListItem
->Status
= EfiShellOpenFileByName (ShellFileListItem
->FullName
, &ShellFileListItem
->Handle
, OpenMode
);
2408 return (EFI_NOT_FOUND
);
2410 return(EFI_SUCCESS
);
2414 This function updated with errata.
2416 Gets either a single or list of environment variables.
2418 If name is not NULL then this function returns the current value of the specified
2419 environment variable.
2421 If Name is NULL, then a list of all environment variable names is returned. Each is a
2422 NULL terminated string with a double NULL terminating the list.
2424 @param Name A pointer to the environment variable name. If
2425 Name is NULL, then the function will return all
2426 of the defined shell environment variables. In
2427 the case where multiple environment variables are
2428 being returned, each variable will be terminated by
2429 a NULL, and the list will be terminated by a double
2432 @return !=NULL A pointer to the returned string.
2433 The returned pointer does not need to be freed by the caller.
2435 @retval NULL The environment variable doesn't exist or there are
2436 no environment variables.
2441 IN CONST CHAR16
*Name
2449 CHAR16
*CurrentWriteLocation
;
2456 // Get all our environment variables
2458 InitializeListHead(&List
);
2459 Status
= GetEnvironmentVariableList(&List
);
2460 if (EFI_ERROR(Status
)){
2465 // Build the semi-colon delimited list. (2 passes)
2467 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&List
)
2468 ; !IsNull(&List
, &Node
->Link
)
2469 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&List
, &Node
->Link
)
2471 ASSERT(Node
->Key
!= NULL
);
2472 Size
+= StrSize(Node
->Key
);
2475 Size
+= 2*sizeof(CHAR16
);
2477 Buffer
= AllocateZeroPool(Size
);
2478 if (Buffer
== NULL
) {
2479 if (!IsListEmpty (&List
)) {
2480 FreeEnvironmentVariableList(&List
);
2484 CurrentWriteLocation
= (CHAR16
*)Buffer
;
2486 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&List
)
2487 ; !IsNull(&List
, &Node
->Link
)
2488 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&List
, &Node
->Link
)
2490 ASSERT(Node
->Key
!= NULL
);
2491 StrCpy(CurrentWriteLocation
, Node
->Key
);
2492 CurrentWriteLocation
+= StrLen(CurrentWriteLocation
) + 1;
2498 if (!IsListEmpty (&List
)) {
2499 FreeEnvironmentVariableList(&List
);
2503 // We are doing a specific environment variable
2507 // get the size we need for this EnvVariable
2509 Status
= SHELL_GET_ENVIRONMENT_VARIABLE(Name
, &Size
, Buffer
);
2510 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2512 // Allocate the space and recall the get function
2514 Buffer
= AllocateZeroPool(Size
);
2515 ASSERT(Buffer
!= NULL
);
2516 Status
= SHELL_GET_ENVIRONMENT_VARIABLE(Name
, &Size
, Buffer
);
2519 // we didnt get it (might not exist)
2520 // free the memory if we allocated any and return NULL
2522 if (EFI_ERROR(Status
)) {
2523 if (Buffer
!= NULL
) {
2531 // return the buffer
2533 return (AddBufferToFreeList(Buffer
));
2537 Internal variable setting function. Allows for setting of the read only variables.
2539 @param Name Points to the NULL-terminated environment variable name.
2540 @param Value Points to the NULL-terminated environment variable value. If the value is an
2541 empty string then the environment variable is deleted.
2542 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2544 @retval EFI_SUCCESS The environment variable was successfully updated.
2548 InternalEfiShellSetEnv(
2549 IN CONST CHAR16
*Name
,
2550 IN CONST CHAR16
*Value
,
2554 if (Value
== NULL
|| StrLen(Value
) == 0) {
2555 return (SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
));
2557 SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
);
2559 return (SHELL_SET_ENVIRONMENT_VARIABLE_V(Name
, StrSize(Value
), Value
));
2561 return (SHELL_SET_ENVIRONMENT_VARIABLE_NV(Name
, StrSize(Value
), Value
));
2567 Sets the environment variable.
2569 This function changes the current value of the specified environment variable. If the
2570 environment variable exists and the Value is an empty string, then the environment
2571 variable is deleted. If the environment variable exists and the Value is not an empty
2572 string, then the value of the environment variable is changed. If the environment
2573 variable does not exist and the Value is an empty string, there is no action. If the
2574 environment variable does not exist and the Value is a non-empty string, then the
2575 environment variable is created and assigned the specified value.
2577 For a description of volatile and non-volatile environment variables, see UEFI Shell
2578 2.0 specification section 3.6.1.
2580 @param Name Points to the NULL-terminated environment variable name.
2581 @param Value Points to the NULL-terminated environment variable value. If the value is an
2582 empty string then the environment variable is deleted.
2583 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2585 @retval EFI_SUCCESS The environment variable was successfully updated.
2590 IN CONST CHAR16
*Name
,
2591 IN CONST CHAR16
*Value
,
2595 if (Name
== NULL
|| *Name
== CHAR_NULL
) {
2596 return (EFI_INVALID_PARAMETER
);
2599 // Make sure we dont 'set' a predefined read only variable
2601 if (gUnicodeCollation
->StriColl(
2605 ||gUnicodeCollation
->StriColl(
2609 ||gUnicodeCollation
->StriColl(
2613 ||gUnicodeCollation
->StriColl(
2616 L
"uefishellsupport") == 0
2617 ||gUnicodeCollation
->StriColl(
2620 L
"uefishellversion") == 0
2621 ||gUnicodeCollation
->StriColl(
2624 L
"uefiversion") == 0
2626 return (EFI_INVALID_PARAMETER
);
2628 return (InternalEfiShellSetEnv(Name
, Value
, Volatile
));
2632 Returns the current directory on the specified device.
2634 If FileSystemMapping is NULL, it returns the current working directory. If the
2635 FileSystemMapping is not NULL, it returns the current directory associated with the
2636 FileSystemMapping. In both cases, the returned name includes the file system
2637 mapping (i.e. fs0:\current-dir).
2639 @param FileSystemMapping A pointer to the file system mapping. If NULL,
2640 then the current working directory is returned.
2642 @retval !=NULL The current directory.
2643 @retval NULL Current directory does not exist.
2648 IN CONST CHAR16
*FileSystemMapping OPTIONAL
2651 CHAR16
*PathToReturn
;
2653 SHELL_MAP_LIST
*MapListItem
;
2654 if (!IsListEmpty(&gShellMapList
.Link
)) {
2656 // if parameter is NULL, use current
2658 if (FileSystemMapping
== NULL
) {
2659 return (EfiShellGetEnv(L
"cwd"));
2662 PathToReturn
= NULL
;
2663 MapListItem
= ShellCommandFindMapItem(FileSystemMapping
);
2664 if (MapListItem
!= NULL
) {
2665 ASSERT((PathToReturn
== NULL
&& Size
== 0) || (PathToReturn
!= NULL
));
2666 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->MapName
, 0);
2667 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
2670 return (AddBufferToFreeList(PathToReturn
));
2677 Changes the current directory on the specified device.
2679 If the FileSystem is NULL, and the directory Dir does not contain a file system's
2680 mapped name, this function changes the current working directory.
2682 If the FileSystem is NULL and the directory Dir contains a mapped name, then the
2683 current file system and the current directory on that file system are changed.
2685 If FileSystem is NULL, and Dir is not NULL, then this changes the current working file
2688 If FileSystem is not NULL and Dir is not NULL, then this function changes the current
2689 directory on the specified file system.
2691 If the current working directory or the current working file system is changed then the
2692 %cwd% environment variable will be updated
2694 @param FileSystem A pointer to the file system's mapped name. If NULL, then the current working
2695 directory is changed.
2696 @param Dir Points to the NULL-terminated directory on the device specified by FileSystem.
2698 @retval EFI_SUCCESS The operation was sucessful
2699 @retval EFI_NOT_FOUND The file system could not be found
2704 IN CONST CHAR16
*FileSystem OPTIONAL
,
2705 IN CONST CHAR16
*Dir
2709 SHELL_MAP_LIST
*MapListItem
;
2713 CHAR16
*DirectoryName
;
2720 DirectoryName
= NULL
;
2722 if ((FileSystem
== NULL
&& Dir
== NULL
) || Dir
== NULL
) {
2723 return (EFI_INVALID_PARAMETER
);
2726 if (IsListEmpty(&gShellMapList
.Link
)){
2727 return (EFI_NOT_FOUND
);
2730 DirectoryName
= StrnCatGrow(&DirectoryName
, NULL
, Dir
, 0);
2731 ASSERT(DirectoryName
!= NULL
);
2733 PathCleanUpDirectories(DirectoryName
);
2735 if (FileSystem
== NULL
) {
2737 // determine the file system mapping to use
2739 if (StrStr(DirectoryName
, L
":") != NULL
) {
2740 ASSERT(MapName
== NULL
);
2741 MapName
= StrnCatGrow(&MapName
, NULL
, DirectoryName
, (StrStr(DirectoryName
, L
":")-DirectoryName
+1));
2744 // find the file system mapping's entry in the list
2747 if (MapName
!= NULL
) {
2748 MapListItem
= ShellCommandFindMapItem(MapName
);
2751 // make that the current file system mapping
2753 if (MapListItem
!= NULL
) {
2754 gShellCurDir
= MapListItem
;
2757 MapListItem
= gShellCurDir
;
2760 if (MapListItem
== NULL
) {
2761 return (EFI_NOT_FOUND
);
2765 // now update the MapListItem's current directory
2767 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& DirectoryName
[StrLen(DirectoryName
) - 1] != L
':') {
2768 FreePool(MapListItem
->CurrentDirectoryPath
);
2769 MapListItem
->CurrentDirectoryPath
= NULL
;
2771 if (MapName
!= NULL
) {
2772 TempLen
= StrLen(MapName
);
2773 if (TempLen
!= StrLen(DirectoryName
)) {
2774 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2775 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
+StrLen(MapName
), 0);
2778 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2779 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
2781 if ((MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] != L
'\\') || (MapListItem
->CurrentDirectoryPath
== NULL
)) {
2782 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2783 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2787 // cant have a mapping in the directory...
2789 if (StrStr(DirectoryName
, L
":") != NULL
) {
2790 return (EFI_INVALID_PARAMETER
);
2793 // FileSystem != NULL
2795 MapListItem
= ShellCommandFindMapItem(FileSystem
);
2796 if (MapListItem
== NULL
) {
2797 return (EFI_INVALID_PARAMETER
);
2799 // gShellCurDir = MapListItem;
2800 if (DirectoryName
!= NULL
) {
2802 // change current dir on that file system
2805 if (MapListItem
->CurrentDirectoryPath
!= NULL
) {
2806 FreePool(MapListItem
->CurrentDirectoryPath
);
2807 DEBUG_CODE(MapListItem
->CurrentDirectoryPath
= NULL
;);
2809 // ASSERT((MapListItem->CurrentDirectoryPath == NULL && Size == 0) || (MapListItem->CurrentDirectoryPath != NULL));
2810 // MapListItem->CurrentDirectoryPath = StrnCatGrow(&MapListItem->CurrentDirectoryPath, &Size, FileSystem, 0);
2811 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2812 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2813 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2814 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
2815 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] != L
'\\') {
2816 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2817 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2822 // if updated the current directory then update the environment variable
2824 if (MapListItem
== gShellCurDir
) {
2826 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
2827 StrnCatGrow(&TempString
, &Size
, MapListItem
->MapName
, 0);
2828 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
2829 StrnCatGrow(&TempString
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
2830 Status
= InternalEfiShellSetEnv(L
"cwd", TempString
, TRUE
);
2831 FreePool(TempString
);
2834 return(EFI_SUCCESS
);
2838 Return help information about a specific command.
2840 This function returns the help information for the specified command. The help text
2841 can be internal to the shell or can be from a UEFI Shell manual page.
2843 If Sections is specified, then each section name listed will be compared in a casesensitive
2844 manner, to the section names described in Appendix B. If the section exists,
2845 it will be appended to the returned help text. If the section does not exist, no
2846 information will be returned. If Sections is NULL, then all help text information
2847 available will be returned.
2849 @param Command Points to the NULL-terminated UEFI Shell command name.
2850 @param Sections Points to the NULL-terminated comma-delimited
2851 section names to return. If NULL, then all
2852 sections will be returned.
2853 @param HelpText On return, points to a callee-allocated buffer
2854 containing all specified help text.
2856 @retval EFI_SUCCESS The help text was returned.
2857 @retval EFI_OUT_OF_RESOURCES The necessary buffer could not be allocated to hold the
2859 @retval EFI_INVALID_PARAMETER HelpText is NULL
2860 @retval EFI_NOT_FOUND There is no help text available for Command.
2864 EfiShellGetHelpText(
2865 IN CONST CHAR16
*Command
,
2866 IN CONST CHAR16
*Sections OPTIONAL
,
2867 OUT CHAR16
**HelpText
2870 CONST CHAR16
*ManFileName
;
2874 ASSERT(HelpText
!= NULL
);
2877 ManFileName
= ShellCommandGetManFileNameHandler(Command
);
2879 if (ManFileName
!= NULL
) {
2880 return (ProcessManFile(ManFileName
, Command
, Sections
, NULL
, HelpText
));
2882 if ((StrLen(Command
)> 4)
2883 && (Command
[StrLen(Command
)-1] == L
'i' || Command
[StrLen(Command
)-1] == L
'I')
2884 && (Command
[StrLen(Command
)-2] == L
'f' || Command
[StrLen(Command
)-2] == L
'F')
2885 && (Command
[StrLen(Command
)-3] == L
'e' || Command
[StrLen(Command
)-3] == L
'E')
2886 && (Command
[StrLen(Command
)-4] == L
'.')
2888 FixCommand
= AllocateZeroPool(StrSize(Command
) - 4 * sizeof (CHAR16
));
2889 ASSERT(FixCommand
!= NULL
);
2891 StrnCpy(FixCommand
, Command
, StrLen(Command
)-4);
2892 Status
= ProcessManFile(FixCommand
, FixCommand
, Sections
, NULL
, HelpText
);
2893 FreePool(FixCommand
);
2896 return (ProcessManFile(Command
, Command
, Sections
, NULL
, HelpText
));
2902 Gets the enable status of the page break output mode.
2904 User can use this function to determine current page break mode.
2906 @retval TRUE The page break output mode is enabled.
2907 @retval FALSE The page break output mode is disabled.
2911 EfiShellGetPageBreak(
2915 return(ShellInfoObject
.PageBreakEnabled
);
2919 Judges whether the active shell is the root shell.
2921 This function makes the user to know that whether the active Shell is the root shell.
2923 @retval TRUE The active Shell is the root Shell.
2924 @retval FALSE The active Shell is NOT the root Shell.
2928 EfiShellIsRootShell(
2932 return(ShellInfoObject
.RootShellInstance
);
2936 function to return a semi-colon delimeted list of all alias' in the current shell
2938 up to caller to free the memory.
2940 @retval NULL No alias' were found
2941 @retval NULL An error ocurred getting alias'
2942 @return !NULL a list of all alias'
2946 InternalEfiShellGetListAlias(
2954 CHAR16
*VariableName
;
2959 Status
= gRT
->QueryVariableInfo(EFI_VARIABLE_NON_VOLATILE
|EFI_VARIABLE_BOOTSERVICE_ACCESS
, &MaxStorSize
, &RemStorSize
, &MaxVarSize
);
2960 ASSERT_EFI_ERROR(Status
);
2962 VariableName
= AllocateZeroPool((UINTN
)MaxVarSize
);
2966 if (VariableName
== NULL
) {
2970 VariableName
[0] = CHAR_NULL
;
2973 NameSize
= (UINTN
)MaxVarSize
;
2974 Status
= gRT
->GetNextVariableName(&NameSize
, VariableName
, &Guid
);
2975 if (Status
== EFI_NOT_FOUND
){
2978 ASSERT_EFI_ERROR(Status
);
2979 if (EFI_ERROR(Status
)) {
2982 if (CompareGuid(&Guid
, &gShellAliasGuid
)){
2983 ASSERT((RetVal
== NULL
&& RetSize
== 0) || (RetVal
!= NULL
));
2984 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, VariableName
, 0);
2985 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, L
";", 0);
2988 FreePool(VariableName
);
2994 This function returns the command associated with a alias or a list of all
2997 @param[in] Alias Points to the NULL-terminated shell alias.
2998 If this parameter is NULL, then all
2999 aliases will be returned in ReturnedData.
3000 @param[out] Volatile upon return of a single command if TRUE indicates
3001 this is stored in a volatile fashion. FALSE otherwise.
3003 @return If Alias is not NULL, it will return a pointer to
3004 the NULL-terminated command for that alias.
3005 If Alias is NULL, ReturnedData points to a ';'
3006 delimited list of alias (e.g.
3007 ReturnedData = "dir;del;copy;mfp") that is NULL-terminated.
3008 @retval NULL an error ocurred
3009 @retval NULL Alias was not a valid Alias
3014 IN CONST CHAR16
*Alias
,
3015 OUT BOOLEAN
*Volatile OPTIONAL
3023 if (Alias
!= NULL
) {
3024 if (Volatile
== NULL
) {
3025 return (AddBufferToFreeList(GetVariable((CHAR16
*)Alias
, &gShellAliasGuid
)));
3029 Status
= gRT
->GetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
3030 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3031 RetVal
= AllocateZeroPool(RetSize
);
3032 Status
= gRT
->GetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
3034 if (EFI_ERROR(Status
)) {
3035 if (RetVal
!= NULL
) {
3040 if ((EFI_VARIABLE_NON_VOLATILE
& Attribs
) == EFI_VARIABLE_NON_VOLATILE
) {
3046 return (AddBufferToFreeList(RetVal
));
3048 return (AddBufferToFreeList(InternalEfiShellGetListAlias()));
3052 Changes a shell command alias.
3054 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3056 this function does not check for built in alias'.
3058 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3059 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3060 Command refers to an alias, that alias will be deleted.
3061 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3062 Alias being set will be stored in a non-volatile fashion.
3064 @retval EFI_SUCCESS Alias created or deleted successfully.
3065 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3070 IN CONST CHAR16
*Command
,
3071 IN CONST CHAR16
*Alias
,
3076 // We must be trying to remove one if Alias is NULL
3078 if (Alias
== NULL
) {
3080 // remove an alias (but passed in COMMAND parameter)
3082 return (gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
));
3085 // Add and replace are the same
3088 // We dont check the error return on purpose since the variable may not exist.
3089 gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
);
3091 return (gRT
->SetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, EFI_VARIABLE_BOOTSERVICE_ACCESS
|(Volatile
?0:EFI_VARIABLE_NON_VOLATILE
), StrSize(Command
), (VOID
*)Command
));
3096 Changes a shell command alias.
3098 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3101 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3102 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3103 Command refers to an alias, that alias will be deleted.
3104 @param[in] Replace If TRUE and the alias already exists, then the existing alias will be replaced. If
3105 FALSE and the alias already exists, then the existing alias is unchanged and
3106 EFI_ACCESS_DENIED is returned.
3107 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3108 Alias being set will be stored in a non-volatile fashion.
3110 @retval EFI_SUCCESS Alias created or deleted successfully.
3111 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3112 @retval EFI_ACCESS_DENIED The alias is a built-in alias or already existed and Replace was set to
3118 IN CONST CHAR16
*Command
,
3119 IN CONST CHAR16
*Alias
,
3125 // cant set over a built in alias
3127 if (ShellCommandIsOnAliasList(Alias
==NULL
?Command
:Alias
)) {
3128 return (EFI_ACCESS_DENIED
);
3130 if (Command
== NULL
|| *Command
== CHAR_NULL
|| StrLen(Command
) == 0) {
3131 return (EFI_INVALID_PARAMETER
);
3134 if (EfiShellGetAlias(Command
, NULL
) != NULL
&& !Replace
) {
3135 return (EFI_ACCESS_DENIED
);
3138 return (InternalSetAlias(Command
, Alias
, Volatile
));
3141 // Pure FILE_HANDLE operations are passed to FileHandleLib
3142 // these functions are indicated by the *
3143 EFI_SHELL_PROTOCOL mShellProtocol
= {
3149 EfiShellGetHelpText
,
3150 EfiShellGetDevicePathFromMap
,
3151 EfiShellGetMapFromDevicePath
,
3152 EfiShellGetDevicePathFromFilePath
,
3153 EfiShellGetFilePathFromDevicePath
,
3157 EfiShellOpenFileList
,
3158 EfiShellFreeFileList
,
3159 EfiShellRemoveDupInFileList
,
3160 EfiShellBatchIsActive
,
3161 EfiShellIsRootShell
,
3162 EfiShellEnablePageBreak
,
3163 EfiShellDisablePageBreak
,
3164 EfiShellGetPageBreak
,
3165 EfiShellGetDeviceName
,
3166 (EFI_SHELL_GET_FILE_INFO
)FileHandleGetInfo
, //*
3167 (EFI_SHELL_SET_FILE_INFO
)FileHandleSetInfo
, //*
3168 EfiShellOpenFileByName
,
3171 (EFI_SHELL_READ_FILE
)FileHandleRead
, //*
3172 (EFI_SHELL_WRITE_FILE
)FileHandleWrite
, //*
3173 (EFI_SHELL_DELETE_FILE
)FileHandleDelete
, //*
3174 EfiShellDeleteFileByName
,
3175 (EFI_SHELL_GET_FILE_POSITION
)FileHandleGetPosition
, //*
3176 (EFI_SHELL_SET_FILE_POSITION
)FileHandleSetPosition
, //*
3177 (EFI_SHELL_FLUSH_FILE
)FileHandleFlush
, //*
3179 EfiShellFindFilesInDir
,
3180 (EFI_SHELL_GET_FILE_SIZE
)FileHandleGetSize
, //*
3182 EfiShellOpenRootByHandle
,
3184 SHELL_MAJOR_VERSION
,
3189 Function to create and install on the current handle.
3191 Will overwrite any existing ShellProtocols in the system to be sure that
3192 the current shell is in control.
3194 This must be removed via calling CleanUpShellProtocol().
3196 @param[in, out] NewShell The pointer to the pointer to the structure
3199 @retval EFI_SUCCESS The operation was successful.
3200 @return An error from LocateHandle, CreateEvent, or other core function.
3204 CreatePopulateInstallShellProtocol (
3205 IN OUT EFI_SHELL_PROTOCOL
**NewShell
3211 UINTN HandleCounter
;
3212 SHELL_PROTOCOL_HANDLE_LIST
*OldProtocolNode
;
3214 if (NewShell
== NULL
) {
3215 return (EFI_INVALID_PARAMETER
);
3220 OldProtocolNode
= NULL
;
3221 InitializeListHead(&ShellInfoObject
.OldShellList
.Link
);
3224 // Initialize EfiShellProtocol object...
3226 Status
= gBS
->CreateEvent(0,
3230 &mShellProtocol
.ExecutionBreak
);
3231 if (EFI_ERROR(Status
)) {
3236 // Get the size of the buffer we need.
3238 Status
= gBS
->LocateHandle(ByProtocol
,
3239 &gEfiShellProtocolGuid
,
3243 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3245 // Allocate and recall with buffer of correct size
3247 Buffer
= AllocateZeroPool(BufferSize
);
3248 if (Buffer
== NULL
) {
3249 return (EFI_OUT_OF_RESOURCES
);
3251 Status
= gBS
->LocateHandle(ByProtocol
,
3252 &gEfiShellProtocolGuid
,
3256 if (EFI_ERROR(Status
)) {
3261 // now overwrite each of them, but save the info to restore when we end.
3263 for (HandleCounter
= 0 ; HandleCounter
< (BufferSize
/sizeof(EFI_HANDLE
)) ; HandleCounter
++) {
3264 OldProtocolNode
= AllocateZeroPool(sizeof(SHELL_PROTOCOL_HANDLE_LIST
));
3265 ASSERT(OldProtocolNode
!= NULL
);
3266 Status
= gBS
->OpenProtocol(Buffer
[HandleCounter
],
3267 &gEfiShellProtocolGuid
,
3268 (VOID
**) &(OldProtocolNode
->Interface
),
3271 EFI_OPEN_PROTOCOL_GET_PROTOCOL
3273 if (!EFI_ERROR(Status
)) {
3275 // reinstall over the old one...
3277 OldProtocolNode
->Handle
= Buffer
[HandleCounter
];
3278 Status
= gBS
->ReinstallProtocolInterface(
3279 OldProtocolNode
->Handle
,
3280 &gEfiShellProtocolGuid
,
3281 OldProtocolNode
->Interface
,
3282 (VOID
*)(&mShellProtocol
));
3283 if (!EFI_ERROR(Status
)) {
3285 // we reinstalled sucessfully. log this so we can reverse it later.
3289 // add to the list for subsequent...
3291 InsertTailList(&ShellInfoObject
.OldShellList
.Link
, &OldProtocolNode
->Link
);
3296 } else if (Status
== EFI_NOT_FOUND
) {
3297 ASSERT(IsListEmpty(&ShellInfoObject
.OldShellList
.Link
));
3299 // no one else published yet. just publish it ourselves.
3301 Status
= gBS
->InstallProtocolInterface (
3303 &gEfiShellProtocolGuid
,
3304 EFI_NATIVE_INTERFACE
,
3305 (VOID
*)(&mShellProtocol
));
3308 if (PcdGetBool(PcdShellSupportOldProtocols
)){
3309 ///@todo support ShellEnvironment2
3310 ///@todo do we need to support ShellEnvironment (not ShellEnvironment2) also?
3313 if (!EFI_ERROR(Status
)) {
3314 *NewShell
= &mShellProtocol
;
3320 Opposite of CreatePopulateInstallShellProtocol.
3322 Free all memory and restore the system to the state it was in before calling
3323 CreatePopulateInstallShellProtocol.
3325 @param[in, out] NewShell The pointer to the new shell protocol structure.
3327 @retval EFI_SUCCESS The operation was successful.
3331 CleanUpShellProtocol (
3332 IN OUT EFI_SHELL_PROTOCOL
*NewShell
3336 SHELL_PROTOCOL_HANDLE_LIST
*Node2
;
3337 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3340 // if we need to restore old protocols...
3342 if (!IsListEmpty(&ShellInfoObject
.OldShellList
.Link
)) {
3343 for (Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*)GetFirstNode(&ShellInfoObject
.OldShellList
.Link
)
3344 ; !IsListEmpty (&ShellInfoObject
.OldShellList
.Link
)
3345 ; Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*)GetFirstNode(&ShellInfoObject
.OldShellList
.Link
)
3347 RemoveEntryList(&Node2
->Link
);
3348 Status
= gBS
->ReinstallProtocolInterface(Node2
->Handle
,
3349 &gEfiShellProtocolGuid
,
3356 // no need to restore
3358 Status
= gBS
->UninstallProtocolInterface(gImageHandle
,
3359 &gEfiShellProtocolGuid
,
3362 Status
= gBS
->CloseEvent(NewShell
->ExecutionBreak
);
3363 NewShell
->ExecutionBreak
= NULL
;
3365 Status
= gBS
->OpenProtocol(
3366 gST
->ConsoleInHandle
,
3367 &gEfiSimpleTextInputExProtocolGuid
,
3371 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3373 if (!EFI_ERROR (Status
)) {
3374 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle1
);
3375 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle2
);
3376 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle3
);
3377 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle4
);
3378 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle1
);
3379 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle2
);
3380 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle3
);
3381 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle4
);
3387 Notification function for keystrokes.
3389 @param[in] KeyData The key that was pressed.
3391 @retval EFI_SUCCESS The operation was successful.
3395 NotificationFunction(
3396 IN EFI_KEY_DATA
*KeyData
3399 if ( ((KeyData
->Key
.UnicodeChar
== L
'c') &&
3400 (KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
) || KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
))) ||
3401 (KeyData
->Key
.UnicodeChar
== 3)
3403 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3404 return (EFI_UNSUPPORTED
);
3406 return (gBS
->SignalEvent(ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
));
3407 } else if ((KeyData
->Key
.UnicodeChar
== L
's') &&
3408 (KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
) || KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
))
3410 ShellInfoObject
.HaltOutput
= TRUE
;
3412 return (EFI_SUCCESS
);
3416 Function to start monitoring for CTRL-C using SimpleTextInputEx. This
3417 feature's enabled state was not known when the shell initially launched.
3419 @retval EFI_SUCCESS The feature is enabled.
3420 @retval EFI_OUT_OF_RESOURCES There is not enough mnemory available.
3424 InernalEfiShellStartMonitor(
3428 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3429 EFI_KEY_DATA KeyData
;
3432 Status
= gBS
->OpenProtocol(
3433 gST
->ConsoleInHandle
,
3434 &gEfiSimpleTextInputExProtocolGuid
,
3438 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3439 if (EFI_ERROR(Status
)) {
3444 STRING_TOKEN (STR_SHELL_NO_IN_EX
),
3445 ShellInfoObject
.HiiHandle
);
3446 return (EFI_SUCCESS
);
3449 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3450 return (EFI_UNSUPPORTED
);
3453 KeyData
.KeyState
.KeyToggleState
= 0;
3454 KeyData
.Key
.ScanCode
= 0;
3455 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3456 KeyData
.Key
.UnicodeChar
= L
'c';
3458 Status
= SimpleEx
->RegisterKeyNotify(
3461 NotificationFunction
,
3462 &ShellInfoObject
.CtrlCNotifyHandle1
);
3464 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3465 if (!EFI_ERROR(Status
)) {
3466 Status
= SimpleEx
->RegisterKeyNotify(
3469 NotificationFunction
,
3470 &ShellInfoObject
.CtrlCNotifyHandle2
);
3472 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3473 KeyData
.Key
.UnicodeChar
= 3;
3474 if (!EFI_ERROR(Status
)) {
3475 Status
= SimpleEx
->RegisterKeyNotify(
3478 NotificationFunction
,
3479 &ShellInfoObject
.CtrlCNotifyHandle3
);
3481 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3482 if (!EFI_ERROR(Status
)) {
3483 Status
= SimpleEx
->RegisterKeyNotify(
3486 NotificationFunction
,
3487 &ShellInfoObject
.CtrlCNotifyHandle4
);