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 ((PathSize
!= 0) &&
471 (PathForReturn
!= NULL
) &&
472 (PathForReturn
[PathSize
- 1] != L
'\\') &&
473 (AlignedNode
->PathName
[0] != L
'\\')) {
474 PathForReturn
= StrnCatGrow (&PathForReturn
, &PathSize
, L
"\\", 1);
477 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, AlignedNode
->PathName
, 0);
478 FreePool(AlignedNode
);
480 } // for loop of remaining nodes
482 if (PathForReturn
!= NULL
) {
485 } // for loop of paths to check
486 return(PathForReturn
);
490 Converts a file system style name to a device path.
492 This function converts a file system style name to a device path, by replacing any
493 mapping references to the associated device path.
495 @param[in] Path The pointer to the path.
497 @return The pointer of the file path. The file path is callee
498 allocated and should be freed by the caller.
499 @retval NULL The path could not be found.
500 @retval NULL There was not enough available memory.
502 EFI_DEVICE_PATH_PROTOCOL
*
504 EfiShellGetDevicePathFromFilePath(
505 IN CONST CHAR16
*Path
512 CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
513 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
514 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopyForFree
;
515 EFI_DEVICE_PATH_PROTOCOL
*DevicePathForReturn
;
526 if (StrStr(Path
, L
":") == NULL
) {
527 Cwd
= EfiShellGetCurDir(NULL
);
532 Size
+= StrSize(Path
);
533 NewPath
= AllocateZeroPool(Size
);
534 if (NewPath
== NULL
) {
537 StrCpy(NewPath
, Cwd
);
538 if (*Path
== L
'\\') {
540 while (PathRemoveLastItem(NewPath
)) ;
542 StrCat(NewPath
, Path
);
543 DevicePathForReturn
= EfiShellGetDevicePathFromFilePath(NewPath
);
545 return (DevicePathForReturn
);
550 // find the part before (but including) the : for the map name
552 ASSERT((MapName
== NULL
&& Size
== 0) || (MapName
!= NULL
));
553 MapName
= StrnCatGrow(&MapName
, &Size
, Path
, (StrStr(Path
, L
":")-Path
+1));
554 if (MapName
== NULL
|| MapName
[StrLen(MapName
)-1] != L
':') {
559 // look up the device path in the map
561 DevicePath
= EfiShellGetDevicePathFromMap(MapName
);
562 if (DevicePath
== NULL
) {
564 // Must have been a bad Mapname
570 // make a copy for LocateDevicePath to modify (also save a pointer to call FreePool with)
572 DevicePathCopyForFree
= DevicePathCopy
= DuplicateDevicePath(DevicePath
);
573 if (DevicePathCopy
== NULL
) {
582 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &Handle
);
583 if (EFI_ERROR(Status
)) {
584 if (DevicePathCopyForFree
!= NULL
) {
585 FreePool(DevicePathCopyForFree
);
592 // build the full device path
594 if (*(Path
+StrLen(MapName
)+1) == CHAR_NULL
) {
595 DevicePathForReturn
= FileDevicePath(Handle
, L
"\\");
597 DevicePathForReturn
= FileDevicePath(Handle
, Path
+StrLen(MapName
));
601 if (DevicePathCopyForFree
!= NULL
) {
602 FreePool(DevicePathCopyForFree
);
605 return (DevicePathForReturn
);
609 Gets the name of the device specified by the device handle.
611 This function gets the user-readable name of the device specified by the device
612 handle. If no user-readable name could be generated, then *BestDeviceName will be
613 NULL and EFI_NOT_FOUND will be returned.
615 If EFI_DEVICE_NAME_USE_COMPONENT_NAME is set, then the function will return the
616 device's name using the EFI_COMPONENT_NAME2_PROTOCOL, if present on
619 If EFI_DEVICE_NAME_USE_DEVICE_PATH is set, then the function will return the
620 device's name using the EFI_DEVICE_PATH_PROTOCOL, if present on DeviceHandle.
621 If both EFI_DEVICE_NAME_USE_COMPONENT_NAME and
622 EFI_DEVICE_NAME_USE_DEVICE_PATH are set, then
623 EFI_DEVICE_NAME_USE_COMPONENT_NAME will have higher priority.
625 @param DeviceHandle The handle of the device.
626 @param Flags Determines the possible sources of component names.
628 EFI_DEVICE_NAME_USE_COMPONENT_NAME
629 EFI_DEVICE_NAME_USE_DEVICE_PATH
630 @param Language A pointer to the language specified for the device
631 name, in the same format as described in the UEFI
632 specification, Appendix M
633 @param BestDeviceName On return, points to the callee-allocated NULL-
634 terminated name of the device. If no device name
635 could be found, points to NULL. The name must be
636 freed by the caller...
638 @retval EFI_SUCCESS Get the name successfully.
639 @retval EFI_NOT_FOUND Fail to get the device name.
640 @retval EFI_INVALID_PARAMETER Flags did not have a valid bit set.
641 @retval EFI_INVALID_PARAMETER BestDeviceName was NULL
642 @retval EFI_INVALID_PARAMETER DeviceHandle was NULL
646 EfiShellGetDeviceName(
647 IN EFI_HANDLE DeviceHandle
,
648 IN EFI_SHELL_DEVICE_NAME_FLAGS Flags
,
650 OUT CHAR16
**BestDeviceName
654 EFI_COMPONENT_NAME2_PROTOCOL
*CompName2
;
655 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
656 EFI_HANDLE
*HandleList
;
659 CHAR16
*DeviceNameToReturn
;
661 UINTN ParentControllerCount
;
662 EFI_HANDLE
*ParentControllerBuffer
;
663 UINTN ParentDriverCount
;
664 EFI_HANDLE
*ParentDriverBuffer
;
666 if (BestDeviceName
== NULL
||
669 return (EFI_INVALID_PARAMETER
);
673 // make sure one of the 2 supported bits is on
675 if (((Flags
& EFI_DEVICE_NAME_USE_COMPONENT_NAME
) == 0) &&
676 ((Flags
& EFI_DEVICE_NAME_USE_DEVICE_PATH
) == 0)) {
677 return (EFI_INVALID_PARAMETER
);
680 DeviceNameToReturn
= NULL
;
681 *BestDeviceName
= NULL
;
686 if ((Flags
& EFI_DEVICE_NAME_USE_COMPONENT_NAME
) != 0) {
687 Status
= ParseHandleDatabaseByRelationship(
690 HR_DRIVER_BINDING_HANDLE
|HR_DEVICE_DRIVER
,
693 for (LoopVar
= 0; LoopVar
< HandleCount
; LoopVar
++){
695 // Go through those handles until we get one that passes for GetComponentName
697 Status
= gBS
->OpenProtocol(
699 &gEfiComponentName2ProtocolGuid
,
703 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
704 if (EFI_ERROR(Status
)) {
705 Status
= gBS
->OpenProtocol(
707 &gEfiComponentNameProtocolGuid
,
711 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
714 if (EFI_ERROR(Status
)) {
717 Lang
= GetBestLanguageForDriver(CompName2
->SupportedLanguages
, Language
, FALSE
);
718 Status
= CompName2
->GetControllerName(CompName2
, DeviceHandle
, NULL
, Lang
, &DeviceNameToReturn
);
721 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
725 if (HandleList
!= NULL
) {
726 FreePool(HandleList
);
730 // Now check the parent controller using this as the child.
732 if (DeviceNameToReturn
== NULL
){
733 PARSE_HANDLE_DATABASE_PARENTS(DeviceHandle
, &ParentControllerCount
, &ParentControllerBuffer
);
734 for (LoopVar
= 0 ; LoopVar
< ParentControllerCount
; LoopVar
++) {
735 PARSE_HANDLE_DATABASE_UEFI_DRIVERS(ParentControllerBuffer
[LoopVar
], &ParentDriverCount
, &ParentDriverBuffer
);
736 for (HandleCount
= 0 ; HandleCount
< ParentDriverCount
; HandleCount
++) {
738 // try using that driver's component name with controller and our driver as the child.
740 Status
= gBS
->OpenProtocol(
741 ParentDriverBuffer
[HandleCount
],
742 &gEfiComponentName2ProtocolGuid
,
746 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
747 if (EFI_ERROR(Status
)) {
748 Status
= gBS
->OpenProtocol(
749 ParentDriverBuffer
[HandleCount
],
750 &gEfiComponentNameProtocolGuid
,
754 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
757 if (EFI_ERROR(Status
)) {
760 Lang
= GetBestLanguageForDriver(CompName2
->SupportedLanguages
, Language
, FALSE
);
761 Status
= CompName2
->GetControllerName(CompName2
, ParentControllerBuffer
[LoopVar
], DeviceHandle
, Lang
, &DeviceNameToReturn
);
764 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
771 SHELL_FREE_NON_NULL(ParentDriverBuffer
);
772 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
776 SHELL_FREE_NON_NULL(ParentControllerBuffer
);
779 // dont return on fail since we will try device path if that bit is on
781 if (DeviceNameToReturn
!= NULL
){
782 ASSERT(BestDeviceName
!= NULL
);
783 StrnCatGrow(BestDeviceName
, NULL
, DeviceNameToReturn
, 0);
784 return (EFI_SUCCESS
);
787 if ((Flags
& EFI_DEVICE_NAME_USE_DEVICE_PATH
) != 0) {
788 Status
= gBS
->OpenProtocol(
790 &gEfiDevicePathProtocolGuid
,
794 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
795 if (!EFI_ERROR(Status
)) {
797 // use device path to text on the device path
799 *BestDeviceName
= ConvertDevicePathToText(DevicePath
, TRUE
, TRUE
);
800 return (EFI_SUCCESS
);
804 // none of the selected bits worked.
806 return (EFI_NOT_FOUND
);
810 Opens the root directory of a device on a handle
812 This function opens the root directory of a device and returns a file handle to it.
814 @param DeviceHandle The handle of the device that contains the volume.
815 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
818 @retval EFI_SUCCESS Root opened successfully.
819 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
821 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
822 @retval EFI_DEVICE_ERROR The device had an error
826 EfiShellOpenRootByHandle(
827 IN EFI_HANDLE DeviceHandle
,
828 OUT SHELL_FILE_HANDLE
*FileHandle
832 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
*SimpleFileSystem
;
833 EFI_FILE_PROTOCOL
*RealFileHandle
;
834 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
837 // get the simple file system interface
839 Status
= gBS
->OpenProtocol(DeviceHandle
,
840 &gEfiSimpleFileSystemProtocolGuid
,
841 (VOID
**)&SimpleFileSystem
,
844 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
845 if (EFI_ERROR(Status
)) {
846 return (EFI_NOT_FOUND
);
849 Status
= gBS
->OpenProtocol(DeviceHandle
,
850 &gEfiDevicePathProtocolGuid
,
854 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
855 if (EFI_ERROR(Status
)) {
856 return (EFI_NOT_FOUND
);
859 // Open the root volume now...
861 Status
= SimpleFileSystem
->OpenVolume(SimpleFileSystem
, &RealFileHandle
);
862 *FileHandle
= ConvertEfiFileProtocolToShellHandle(RealFileHandle
, EfiShellGetMapFromDevicePath(&DevPath
));
867 Opens the root directory of a device.
869 This function opens the root directory of a device and returns a file handle to it.
871 @param DevicePath Points to the device path corresponding to the device where the
872 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL is installed.
873 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
876 @retval EFI_SUCCESS Root opened successfully.
877 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
879 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
880 @retval EFI_DEVICE_ERROR The device had an error
881 @retval EFI_INVALID_PARAMETER FileHandle is NULL.
886 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
887 OUT SHELL_FILE_HANDLE
*FileHandle
893 if (FileHandle
== NULL
) {
894 return (EFI_INVALID_PARAMETER
);
898 // find the handle of the device with that device handle and the file system
901 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
,
904 if (EFI_ERROR(Status
)) {
905 return (EFI_NOT_FOUND
);
908 return (EfiShellOpenRootByHandle(Handle
, FileHandle
));
912 Returns whether any script files are currently being processed.
914 @retval TRUE There is at least one script file active.
915 @retval FALSE No script files are active now.
920 EfiShellBatchIsActive (
924 if (ShellCommandGetCurrentScriptFile() == NULL
) {
931 Worker function to open a file based on a device path. this will open the root
932 of the volume and then traverse down to the file itself.
934 @param DevicePath Device Path of the file.
935 @param FileHandle Pointer to the file upon a successful return.
936 @param OpenMode mode to open file in.
937 @param Attributes the File Attributes to use when creating a new file.
939 @retval EFI_SUCCESS the file is open and FileHandle is valid
940 @retval EFI_UNSUPPORTED the device path cotained non-path elements
941 @retval other an error ocurred.
945 InternalOpenFileDevicePath(
946 IN OUT EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
947 OUT SHELL_FILE_HANDLE
*FileHandle
,
949 IN UINT64 Attributes OPTIONAL
953 FILEPATH_DEVICE_PATH
*FilePathNode
;
955 SHELL_FILE_HANDLE ShellHandle
;
956 EFI_FILE_PROTOCOL
*Handle1
;
957 EFI_FILE_PROTOCOL
*Handle2
;
958 FILEPATH_DEVICE_PATH
*AlignedNode
;
960 if (FileHandle
== NULL
) {
961 return (EFI_INVALID_PARAMETER
);
971 Status
= EfiShellOpenRoot(DevicePath
, &ShellHandle
);
973 if (!EFI_ERROR(Status
)) {
974 Handle1
= ConvertShellHandleToEfiFileProtocol(ShellHandle
);
975 if (Handle1
!= NULL
) {
977 // chop off the begining part before the file system part...
980 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
,
983 if (!EFI_ERROR(Status
)) {
985 // To access as a file system, the file path should only
986 // contain file path components. Follow the file path nodes
987 // and find the target file
989 for ( FilePathNode
= (FILEPATH_DEVICE_PATH
*)DevicePath
990 ; !IsDevicePathEnd (&FilePathNode
->Header
)
991 ; FilePathNode
= (FILEPATH_DEVICE_PATH
*) NextDevicePathNode (&FilePathNode
->Header
)
993 SHELL_FREE_NON_NULL(AlignedNode
);
994 AlignedNode
= AllocateCopyPool (DevicePathNodeLength(FilePathNode
), FilePathNode
);
996 // For file system access each node should be a file path component
998 if (DevicePathType (&FilePathNode
->Header
) != MEDIA_DEVICE_PATH
||
999 DevicePathSubType (&FilePathNode
->Header
) != MEDIA_FILEPATH_DP
1001 Status
= EFI_UNSUPPORTED
;
1006 // Open this file path node
1012 // if this is the last node in the DevicePath always create (if that was requested).
1014 if (IsDevicePathEnd ((NextDevicePathNode (&FilePathNode
->Header
)))) {
1015 Status
= Handle2
->Open (
1018 AlignedNode
->PathName
,
1025 // This is not the last node and we dont want to 'create' existing
1026 // directory entries...
1030 // open without letting it create
1031 // prevents error on existing files/directories
1033 Status
= Handle2
->Open (
1036 AlignedNode
->PathName
,
1037 OpenMode
&~EFI_FILE_MODE_CREATE
,
1041 // if above failed now open and create the 'item'
1042 // if OpenMode EFI_FILE_MODE_CREATE bit was on (but disabled above)
1044 if ((EFI_ERROR (Status
)) && ((OpenMode
& EFI_FILE_MODE_CREATE
) != 0)) {
1045 Status
= Handle2
->Open (
1048 AlignedNode
->PathName
,
1055 // Close the last node
1057 ShellInfoObject
.NewEfiShellProtocol
->CloseFile (Handle2
);
1060 // If there's been an error, stop
1062 if (EFI_ERROR (Status
)) {
1069 SHELL_FREE_NON_NULL(AlignedNode
);
1070 if (EFI_ERROR(Status
)) {
1071 if (Handle1
!= NULL
) {
1072 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(Handle1
);
1075 *FileHandle
= ConvertEfiFileProtocolToShellHandle(Handle1
, ShellFileHandleGetPath(ShellHandle
));
1081 Creates a file or directory by name.
1083 This function creates an empty new file or directory with the specified attributes and
1084 returns the new file's handle. If the file already exists and is read-only, then
1085 EFI_INVALID_PARAMETER will be returned.
1087 If the file already existed, it is truncated and its attributes updated. If the file is
1088 created successfully, the FileHandle is the file's handle, else, the FileHandle is NULL.
1090 If the file name begins with >v, then the file handle which is returned refers to the
1091 shell environment variable with the specified name. If the shell environment variable
1092 already exists and is non-volatile then EFI_INVALID_PARAMETER is returned.
1094 @param FileName Pointer to NULL-terminated file path
1095 @param FileAttribs The new file's attrbiutes. the different attributes are
1096 described in EFI_FILE_PROTOCOL.Open().
1097 @param FileHandle On return, points to the created file handle or directory's handle
1099 @retval EFI_SUCCESS The file was opened. FileHandle points to the new file's handle.
1100 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1101 @retval EFI_UNSUPPORTED could not open the file path
1102 @retval EFI_NOT_FOUND the specified file could not be found on the devide, or could not
1103 file the file system on the device.
1104 @retval EFI_NO_MEDIA the device has no medium.
1105 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1107 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1109 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1110 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1111 when the media is write-protected.
1112 @retval EFI_ACCESS_DENIED The service denied access to the file.
1113 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file.
1114 @retval EFI_VOLUME_FULL The volume is full.
1119 IN CONST CHAR16
*FileName
,
1120 IN UINT64 FileAttribs
,
1121 OUT SHELL_FILE_HANDLE
*FileHandle
1124 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1128 // Is this for an environment variable
1129 // do we start with >v
1131 if (StrStr(FileName
, L
">v") == FileName
) {
1132 if (!IsVolatileEnv(FileName
+2)) {
1133 return (EFI_INVALID_PARAMETER
);
1135 *FileHandle
= CreateFileInterfaceEnv(FileName
+2);
1136 return (EFI_SUCCESS
);
1140 // We are opening a regular file.
1142 DevicePath
= EfiShellGetDevicePathFromFilePath(FileName
);
1143 if (DevicePath
== NULL
) {
1144 return (EFI_NOT_FOUND
);
1147 Status
= InternalOpenFileDevicePath(DevicePath
, FileHandle
, EFI_FILE_MODE_READ
|EFI_FILE_MODE_WRITE
|EFI_FILE_MODE_CREATE
, FileAttribs
); // 0 = no specific file attributes
1148 FreePool(DevicePath
);
1154 Opens a file or a directory by file name.
1156 This function opens the specified file in the specified OpenMode and returns a file
1158 If the file name begins with >v, then the file handle which is returned refers to the
1159 shell environment variable with the specified name. If the shell environment variable
1160 exists, is non-volatile and the OpenMode indicates EFI_FILE_MODE_WRITE, then
1161 EFI_INVALID_PARAMETER is returned.
1163 If the file name is >i, then the file handle which is returned refers to the standard
1164 input. If the OpenMode indicates EFI_FILE_MODE_WRITE, then EFI_INVALID_PARAMETER
1167 If the file name is >o, then the file handle which is returned refers to the standard
1168 output. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1171 If the file name is >e, then the file handle which is returned refers to the standard
1172 error. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1175 If the file name is NUL, then the file handle that is returned refers to the standard NUL
1176 file. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER is
1179 If return EFI_SUCCESS, the FileHandle is the opened file's handle, else, the
1182 @param FileName Points to the NULL-terminated UCS-2 encoded file name.
1183 @param FileHandle On return, points to the file handle.
1184 @param OpenMode File open mode. Either EFI_FILE_MODE_READ or
1185 EFI_FILE_MODE_WRITE from section 12.4 of the UEFI
1187 @retval EFI_SUCCESS The file was opened. FileHandle has the opened file's handle.
1188 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value. FileHandle is NULL.
1189 @retval EFI_UNSUPPORTED Could not open the file path. FileHandle is NULL.
1190 @retval EFI_NOT_FOUND The specified file could not be found on the device or the file
1191 system could not be found on the device. FileHandle is NULL.
1192 @retval EFI_NO_MEDIA The device has no medium. FileHandle is NULL.
1193 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1194 longer supported. FileHandle is NULL.
1195 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1196 the FileName. FileHandle is NULL.
1197 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted. FileHandle is NULL.
1198 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1199 when the media is write-protected. FileHandle is NULL.
1200 @retval EFI_ACCESS_DENIED The service denied access to the file. FileHandle is NULL.
1201 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file. FileHandle
1203 @retval EFI_VOLUME_FULL The volume is full. FileHandle is NULL.
1207 EfiShellOpenFileByName(
1208 IN CONST CHAR16
*FileName
,
1209 OUT SHELL_FILE_HANDLE
*FileHandle
,
1213 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1219 // Is this for StdIn
1221 if (StrCmp(FileName
, L
">i") == 0) {
1223 // make sure not writing to StdIn
1225 if ((OpenMode
& EFI_FILE_MODE_WRITE
) != 0) {
1226 return (EFI_INVALID_PARAMETER
);
1228 *FileHandle
= ShellInfoObject
.NewShellParametersProtocol
->StdIn
;
1229 ASSERT(*FileHandle
!= NULL
);
1230 return (EFI_SUCCESS
);
1234 // Is this for StdOut
1236 if (StrCmp(FileName
, L
">o") == 0) {
1238 // make sure not writing to StdIn
1240 if ((OpenMode
& EFI_FILE_MODE_READ
) != 0) {
1241 return (EFI_INVALID_PARAMETER
);
1243 *FileHandle
= &FileInterfaceStdOut
;
1244 return (EFI_SUCCESS
);
1248 // Is this for NUL file
1250 if (StrCmp(FileName
, L
"NUL") == 0) {
1251 *FileHandle
= &FileInterfaceNulFile
;
1252 return (EFI_SUCCESS
);
1256 // Is this for StdErr
1258 if (StrCmp(FileName
, L
">e") == 0) {
1260 // make sure not writing to StdIn
1262 if ((OpenMode
& EFI_FILE_MODE_READ
) != 0) {
1263 return (EFI_INVALID_PARAMETER
);
1265 *FileHandle
= &FileInterfaceStdErr
;
1266 return (EFI_SUCCESS
);
1270 // Is this for an environment variable
1271 // do we start with >v
1273 if (StrStr(FileName
, L
">v") == FileName
) {
1274 if (!IsVolatileEnv(FileName
+2) &&
1275 ((OpenMode
& EFI_FILE_MODE_WRITE
) != 0)) {
1276 return (EFI_INVALID_PARAMETER
);
1278 *FileHandle
= CreateFileInterfaceEnv(FileName
+2);
1279 return (EFI_SUCCESS
);
1283 // We are opening a regular file.
1285 DevicePath
= EfiShellGetDevicePathFromFilePath(FileName
);
1286 // DEBUG_CODE(InternalShellProtocolDebugPrintMessage (NULL, DevicePath););
1287 if (DevicePath
== NULL
) {
1288 return (EFI_NOT_FOUND
);
1292 // Copy the device path, open the file, then free the memory
1294 Status
= InternalOpenFileDevicePath(DevicePath
, FileHandle
, OpenMode
, 0); // 0 = no specific file attributes
1295 FreePool(DevicePath
);
1301 Deletes the file specified by the file name.
1303 This function deletes a file.
1305 @param FileName Points to the NULL-terminated file name.
1307 @retval EFI_SUCCESS The file was closed and deleted, and the handle was closed.
1308 @retval EFI_WARN_DELETE_FAILURE The handle was closed but the file was not deleted.
1309 @sa EfiShellCreateFile
1313 EfiShellDeleteFileByName(
1314 IN CONST CHAR16
*FileName
1317 SHELL_FILE_HANDLE FileHandle
;
1321 // get a handle to the file
1323 Status
= EfiShellCreateFile(FileName
,
1326 if (EFI_ERROR(Status
)) {
1330 // now delete the file
1332 return (ShellInfoObject
.NewEfiShellProtocol
->DeleteFile(FileHandle
));
1336 Disables the page break output mode.
1340 EfiShellDisablePageBreak (
1344 ShellInfoObject
.PageBreakEnabled
= FALSE
;
1348 Enables the page break output mode.
1352 EfiShellEnablePageBreak (
1356 ShellInfoObject
.PageBreakEnabled
= TRUE
;
1360 internal worker function to load and run an image via device path.
1362 @param ParentImageHandle A handle of the image that is executing the specified
1364 @param DevicePath device path of the file to execute
1365 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1366 containing the command line. If NULL then the command-
1368 @param Environment Points to a NULL-terminated array of environment
1369 variables with the format 'x=y', where x is the
1370 environment variable name and y is the value. If this
1371 is NULL, then the current shell environment is used.
1373 @param[out] StartImageStatus Returned status from gBS->StartImage.
1374 @param[out] ExitDataSize ExitDataSize as returned from gBS->StartImage
1375 @param[out] ExitData ExitData as returned from gBS->StartImage
1377 @retval EFI_SUCCESS The command executed successfully. The status code
1378 returned by the command is pointed to by StatusCode.
1379 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1380 @retval EFI_OUT_OF_RESOURCES Out of resources.
1381 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1385 InternalShellExecuteDevicePath(
1386 IN CONST EFI_HANDLE
*ParentImageHandle
,
1387 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
1388 IN CONST CHAR16
*CommandLine OPTIONAL
,
1389 IN CONST CHAR16
**Environment OPTIONAL
,
1390 OUT EFI_STATUS
*StartImageStatus OPTIONAL
,
1391 OUT UINTN
*ExitDataSize OPTIONAL
,
1392 OUT CHAR16
**ExitData OPTIONAL
1396 EFI_STATUS StartStatus
;
1397 EFI_STATUS CleanupStatus
;
1398 EFI_HANDLE NewHandle
;
1399 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
1400 LIST_ENTRY OrigEnvs
;
1401 EFI_SHELL_PARAMETERS_PROTOCOL ShellParamsProtocol
;
1402 UINTN InternalExitDataSize
;
1403 UINTN
*ExitDataSizePtr
;
1407 // ExitDataSize is not OPTIONAL for gBS->BootServices, provide somewhere for
1408 // it to be dumped if the caller doesn't want it.
1409 if (ExitData
== NULL
) {
1410 ExitDataSizePtr
= &InternalExitDataSize
;
1412 ExitDataSizePtr
= ExitDataSize
;
1415 if (ParentImageHandle
== NULL
) {
1416 return (EFI_INVALID_PARAMETER
);
1419 InitializeListHead(&OrigEnvs
);
1424 // Load the image with:
1425 // FALSE - not from boot manager and NULL, 0 being not already in memory
1427 Status
= gBS
->LoadImage(
1430 (EFI_DEVICE_PATH_PROTOCOL
*)DevicePath
,
1435 if (EFI_ERROR(Status
)) {
1436 if (NewHandle
!= NULL
) {
1437 gBS
->UnloadImage(NewHandle
);
1441 Status
= gBS
->OpenProtocol(
1443 &gEfiLoadedImageProtocolGuid
,
1444 (VOID
**)&LoadedImage
,
1447 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
1449 if (!EFI_ERROR(Status
)) {
1450 ASSERT(LoadedImage
->LoadOptionsSize
== 0);
1451 if (CommandLine
!= NULL
) {
1452 LoadedImage
->LoadOptionsSize
= (UINT32
)StrSize(CommandLine
);
1453 LoadedImage
->LoadOptions
= (VOID
*)CommandLine
;
1457 // Save our current environment settings for later restoration if necessary
1459 if (Environment
!= NULL
) {
1460 Status
= GetEnvironmentVariableList(&OrigEnvs
);
1461 if (!EFI_ERROR(Status
)) {
1462 Status
= SetEnvironmentVariables(Environment
);
1467 // Initialize and install a shell parameters protocol on the image.
1469 ShellParamsProtocol
.StdIn
= ShellInfoObject
.NewShellParametersProtocol
->StdIn
;
1470 ShellParamsProtocol
.StdOut
= ShellInfoObject
.NewShellParametersProtocol
->StdOut
;
1471 ShellParamsProtocol
.StdErr
= ShellInfoObject
.NewShellParametersProtocol
->StdErr
;
1472 Status
= UpdateArgcArgv(&ShellParamsProtocol
, CommandLine
, NULL
, NULL
);
1473 ASSERT_EFI_ERROR(Status
);
1475 // Replace Argv[0] with the full path of the binary we're executing:
1476 // If the command line was "foo", the binary might be called "foo.efi".
1477 // "The first entry in [Argv] is always the full file path of the
1478 // executable" - UEFI Shell Spec section 2.3
1480 ImagePath
= EfiShellGetFilePathFromDevicePath (DevicePath
);
1481 // The image we're executing isn't necessarily in a filesystem - it might
1482 // be memory mapped. In this case EfiShellGetFilePathFromDevicePath will
1483 // return NULL, and we'll leave Argv[0] as UpdateArgcArgv set it.
1484 if (ImagePath
!= NULL
) {
1485 if (ShellParamsProtocol
.Argv
== NULL
) {
1486 // Command line was empty or null.
1487 // (UpdateArgcArgv sets Argv to NULL when CommandLine is "" or NULL)
1488 ShellParamsProtocol
.Argv
= AllocatePool (sizeof (CHAR16
*));
1489 if (ShellParamsProtocol
.Argv
== NULL
) {
1490 Status
= EFI_OUT_OF_RESOURCES
;
1493 ShellParamsProtocol
.Argc
= 1;
1495 // Free the string UpdateArgcArgv put in Argv[0];
1496 FreePool (ShellParamsProtocol
.Argv
[0]);
1498 ShellParamsProtocol
.Argv
[0] = ImagePath
;
1501 Status
= gBS
->InstallProtocolInterface(&NewHandle
, &gEfiShellParametersProtocolGuid
, EFI_NATIVE_INTERFACE
, &ShellParamsProtocol
);
1502 ASSERT_EFI_ERROR(Status
);
1504 ///@todo initialize and install ShellInterface protocol on the new image for compatibility if - PcdGetBool(PcdShellSupportOldProtocols)
1507 // now start the image, passing up exit data if the caller requested it
1509 if (!EFI_ERROR(Status
)) {
1510 StartStatus
= gBS
->StartImage(
1515 if (StartImageStatus
!= NULL
) {
1516 *StartImageStatus
= StartStatus
;
1519 CleanupStatus
= gBS
->UninstallProtocolInterface(
1521 &gEfiShellParametersProtocolGuid
,
1522 &ShellParamsProtocol
1524 ASSERT_EFI_ERROR(CleanupStatus
);
1530 // Unload image - We should only get here if we didn't call StartImage
1531 gBS
->UnloadImage (NewHandle
);
1534 // Free Argv (Allocated in UpdateArgcArgv)
1535 if (ShellParamsProtocol
.Argv
!= NULL
) {
1536 for (Index
= 0; Index
< ShellParamsProtocol
.Argc
; Index
++) {
1537 if (ShellParamsProtocol
.Argv
[Index
] != NULL
) {
1538 FreePool (ShellParamsProtocol
.Argv
[Index
]);
1541 FreePool (ShellParamsProtocol
.Argv
);
1545 // Restore environment variables
1546 if (!IsListEmpty(&OrigEnvs
)) {
1547 CleanupStatus
= SetEnvironmentVariableList(&OrigEnvs
);
1548 ASSERT_EFI_ERROR (CleanupStatus
);
1554 Execute the command line.
1556 This function creates a nested instance of the shell and executes the specified
1557 command (CommandLine) with the specified environment (Environment). Upon return,
1558 the status code returned by the specified command is placed in StatusCode.
1560 If Environment is NULL, then the current environment is used and all changes made
1561 by the commands executed will be reflected in the current environment. If the
1562 Environment is non-NULL, then the changes made will be discarded.
1564 The CommandLine is executed from the current working directory on the current
1567 @param ParentImageHandle A handle of the image that is executing the specified
1569 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1570 containing the command line. If NULL then the command-
1572 @param Environment Points to a NULL-terminated array of environment
1573 variables with the format 'x=y', where x is the
1574 environment variable name and y is the value. If this
1575 is NULL, then the current shell environment is used.
1576 @param StatusCode Points to the status code returned by the command.
1578 @retval EFI_SUCCESS The command executed successfully. The status code
1579 returned by the command is pointed to by StatusCode.
1580 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1581 @retval EFI_OUT_OF_RESOURCES Out of resources.
1582 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1583 @retval EFI_UNSUPPORTED The support level required for this function is not present.
1585 @sa InternalShellExecuteDevicePath
1590 IN EFI_HANDLE
*ParentImageHandle
,
1591 IN CHAR16
*CommandLine OPTIONAL
,
1592 IN CHAR16
**Environment OPTIONAL
,
1593 OUT EFI_STATUS
*StatusCode OPTIONAL
1598 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
1603 if ((PcdGet8(PcdShellSupportLevel
) < 1)) {
1604 return (EFI_UNSUPPORTED
);
1607 DevPath
= AppendDevicePath (ShellInfoObject
.ImageDevPath
, ShellInfoObject
.FileDevPath
);
1610 Temp
= ConvertDevicePathToText(ShellInfoObject
.FileDevPath
, TRUE
, TRUE
);
1612 Temp
= ConvertDevicePathToText(ShellInfoObject
.ImageDevPath
, TRUE
, TRUE
);
1614 Temp
= ConvertDevicePathToText(DevPath
, TRUE
, TRUE
);
1620 ASSERT((Temp
== NULL
&& Size
== 0) || (Temp
!= NULL
));
1621 StrnCatGrow(&Temp
, &Size
, L
"Shell.efi -_exit ", 0);
1622 StrnCatGrow(&Temp
, &Size
, CommandLine
, 0);
1624 Status
= InternalShellExecuteDevicePath(
1628 (CONST CHAR16
**)Environment
,
1633 if (Status
== EFI_ABORTED
) {
1634 // If the command exited with an error, the shell should put the exit
1635 // status in ExitData, preceded by a null-terminated string.
1636 ASSERT (ExitDataSize
== StrSize (ExitData
) + sizeof (SHELL_STATUS
));
1638 if (StatusCode
!= NULL
) {
1639 // Skip the null-terminated string
1640 ExitData
+= StrLen (ExitData
) + 1;
1642 // Use CopyMem to avoid alignment faults
1643 CopyMem (StatusCode
, ExitData
, sizeof (SHELL_STATUS
));
1645 // Convert from SHELL_STATUS to EFI_STATUS
1646 // EFI_STATUSes have top bit set when they are errors.
1647 // (See UEFI Spec Appendix D)
1648 if (*StatusCode
!= SHELL_SUCCESS
) {
1649 *StatusCode
= (EFI_STATUS
) *StatusCode
| MAX_BIT
;
1652 FreePool (ExitData
);
1653 Status
= EFI_SUCCESS
;
1657 // de-allocate and return
1665 Utility cleanup function for EFI_SHELL_FILE_INFO objects.
1667 1) frees all pointers (non-NULL)
1668 2) Closes the SHELL_FILE_HANDLE
1670 @param FileListNode pointer to the list node to free
1674 InternalFreeShellFileInfoNode(
1675 IN EFI_SHELL_FILE_INFO
*FileListNode
1678 if (FileListNode
->Info
!= NULL
) {
1679 FreePool((VOID
*)FileListNode
->Info
);
1681 if (FileListNode
->FileName
!= NULL
) {
1682 FreePool((VOID
*)FileListNode
->FileName
);
1684 if (FileListNode
->FullName
!= NULL
) {
1685 FreePool((VOID
*)FileListNode
->FullName
);
1687 if (FileListNode
->Handle
!= NULL
) {
1688 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(FileListNode
->Handle
);
1690 FreePool(FileListNode
);
1693 Frees the file list.
1695 This function cleans up the file list and any related data structures. It has no
1696 impact on the files themselves.
1698 @param FileList The file list to free. Type EFI_SHELL_FILE_INFO is
1699 defined in OpenFileList()
1701 @retval EFI_SUCCESS Free the file list successfully.
1702 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1706 EfiShellFreeFileList(
1707 IN EFI_SHELL_FILE_INFO
**FileList
1710 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1712 if (FileList
== NULL
|| *FileList
== NULL
) {
1713 return (EFI_INVALID_PARAMETER
);
1716 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1717 ; !IsListEmpty(&(*FileList
)->Link
)
1718 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1720 RemoveEntryList(&ShellFileListItem
->Link
);
1721 InternalFreeShellFileInfoNode(ShellFileListItem
);
1723 InternalFreeShellFileInfoNode(*FileList
);
1725 return(EFI_SUCCESS
);
1729 Deletes the duplicate file names files in the given file list.
1731 This function deletes the reduplicate files in the given file list.
1733 @param FileList A pointer to the first entry in the file list.
1735 @retval EFI_SUCCESS Always success.
1736 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1740 EfiShellRemoveDupInFileList(
1741 IN EFI_SHELL_FILE_INFO
**FileList
1744 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1745 EFI_SHELL_FILE_INFO
*ShellFileListItem2
;
1746 EFI_SHELL_FILE_INFO
*TempNode
;
1748 if (FileList
== NULL
|| *FileList
== NULL
) {
1749 return (EFI_INVALID_PARAMETER
);
1751 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1752 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1753 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1755 for ( ShellFileListItem2
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1756 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem2
->Link
)
1757 ; ShellFileListItem2
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem2
->Link
)
1759 if (gUnicodeCollation
->StriColl(
1761 (CHAR16
*)ShellFileListItem
->FullName
,
1762 (CHAR16
*)ShellFileListItem2
->FullName
) == 0
1764 TempNode
= (EFI_SHELL_FILE_INFO
*)GetPreviousNode(
1766 &ShellFileListItem2
->Link
1768 RemoveEntryList(&ShellFileListItem2
->Link
);
1769 InternalFreeShellFileInfoNode(ShellFileListItem2
);
1770 // Set ShellFileListItem2 to PreviousNode so we don't access Freed
1771 // memory in GetNextNode in the loop expression above.
1772 ShellFileListItem2
= TempNode
;
1776 return (EFI_SUCCESS
);
1780 // This is the same structure as the external version, but it has no CONST qualifiers.
1783 LIST_ENTRY Link
; ///< Linked list members.
1784 EFI_STATUS Status
; ///< Status of opening the file. Valid only if Handle != NULL.
1785 CHAR16
*FullName
; ///< Fully qualified filename.
1786 CHAR16
*FileName
; ///< name of this file.
1787 SHELL_FILE_HANDLE Handle
; ///< Handle for interacting with the opened file or NULL if closed.
1788 EFI_FILE_INFO
*Info
; ///< Pointer to the FileInfo struct for this file or NULL.
1789 } EFI_SHELL_FILE_INFO_NO_CONST
;
1792 Allocates and duplicates a EFI_SHELL_FILE_INFO node.
1794 @param[in] Node The node to copy from.
1795 @param[in] Save TRUE to set Node->Handle to NULL, FALSE otherwise.
1797 @retval NULL a memory allocation error ocurred
1798 @return != NULL a pointer to the new node
1800 EFI_SHELL_FILE_INFO
*
1802 InternalDuplicateShellFileInfo(
1803 IN EFI_SHELL_FILE_INFO
*Node
,
1807 EFI_SHELL_FILE_INFO_NO_CONST
*NewNode
;
1810 // try to confirm that the objects are in sync
1812 ASSERT(sizeof(EFI_SHELL_FILE_INFO_NO_CONST
) == sizeof(EFI_SHELL_FILE_INFO
));
1814 NewNode
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1815 if (NewNode
== NULL
) {
1818 NewNode
->FullName
= AllocateZeroPool(StrSize(Node
->FullName
));
1820 NewNode
->FileName
= AllocateZeroPool(StrSize(Node
->FileName
));
1821 NewNode
->Info
= AllocateZeroPool((UINTN
)Node
->Info
->Size
);
1822 if ( NewNode
->FullName
== NULL
1823 || NewNode
->FileName
== NULL
1824 || NewNode
->Info
== NULL
1826 SHELL_FREE_NON_NULL(NewNode
->FullName
);
1827 SHELL_FREE_NON_NULL(NewNode
->FileName
);
1828 SHELL_FREE_NON_NULL(NewNode
->Info
);
1829 SHELL_FREE_NON_NULL(NewNode
);
1832 NewNode
->Status
= Node
->Status
;
1833 NewNode
->Handle
= Node
->Handle
;
1835 Node
->Handle
= NULL
;
1837 StrCpy((CHAR16
*)NewNode
->FullName
, Node
->FullName
);
1838 StrCpy((CHAR16
*)NewNode
->FileName
, Node
->FileName
);
1839 CopyMem(NewNode
->Info
, Node
->Info
, (UINTN
)Node
->Info
->Size
);
1841 return((EFI_SHELL_FILE_INFO
*)NewNode
);
1845 Allocates and populates a EFI_SHELL_FILE_INFO structure. if any memory operation
1846 failed it will return NULL.
1848 @param[in] BasePath the Path to prepend onto filename for FullPath
1849 @param[in] Status Status member initial value.
1850 @param[in] FileName FileName member initial value.
1851 @param[in] Handle Handle member initial value.
1852 @param[in] Info Info struct to copy.
1854 @retval NULL An error ocurred.
1855 @return a pointer to the newly allocated structure.
1857 EFI_SHELL_FILE_INFO
*
1859 CreateAndPopulateShellFileInfo(
1860 IN CONST CHAR16
*BasePath
,
1861 IN CONST EFI_STATUS Status
,
1862 IN CONST CHAR16
*FileName
,
1863 IN CONST SHELL_FILE_HANDLE Handle
,
1864 IN CONST EFI_FILE_INFO
*Info
1867 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1874 ShellFileListItem
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1875 if (ShellFileListItem
== NULL
) {
1878 if (Info
!= NULL
&& Info
->Size
!= 0) {
1879 ShellFileListItem
->Info
= AllocateZeroPool((UINTN
)Info
->Size
);
1880 if (ShellFileListItem
->Info
== NULL
) {
1881 FreePool(ShellFileListItem
);
1884 CopyMem(ShellFileListItem
->Info
, Info
, (UINTN
)Info
->Size
);
1886 ShellFileListItem
->Info
= NULL
;
1888 if (FileName
!= NULL
) {
1889 ASSERT(TempString
== NULL
);
1890 ShellFileListItem
->FileName
= StrnCatGrow(&TempString
, 0, FileName
, 0);
1891 if (ShellFileListItem
->FileName
== NULL
) {
1892 FreePool(ShellFileListItem
->Info
);
1893 FreePool(ShellFileListItem
);
1897 ShellFileListItem
->FileName
= NULL
;
1901 if (BasePath
!= NULL
) {
1902 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
1903 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
1904 if (TempString
== NULL
) {
1905 FreePool((VOID
*)ShellFileListItem
->FileName
);
1906 SHELL_FREE_NON_NULL(ShellFileListItem
->Info
);
1907 FreePool(ShellFileListItem
);
1911 if (ShellFileListItem
->FileName
!= NULL
) {
1912 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
1913 TempString
= StrnCatGrow(&TempString
, &Size
, ShellFileListItem
->FileName
, 0);
1914 if (TempString
== NULL
) {
1915 FreePool((VOID
*)ShellFileListItem
->FileName
);
1916 FreePool(ShellFileListItem
->Info
);
1917 FreePool(ShellFileListItem
);
1922 TempString
= PathCleanUpDirectories(TempString
);
1924 ShellFileListItem
->FullName
= TempString
;
1925 ShellFileListItem
->Status
= Status
;
1926 ShellFileListItem
->Handle
= Handle
;
1928 return (ShellFileListItem
);
1932 Find all files in a specified directory.
1934 @param FileDirHandle Handle of the directory to search.
1935 @param FileList On return, points to the list of files in the directory
1936 or NULL if there are no files in the directory.
1938 @retval EFI_SUCCESS File information was returned successfully.
1939 @retval EFI_VOLUME_CORRUPTED The file system structures have been corrupted.
1940 @retval EFI_DEVICE_ERROR The device reported an error.
1941 @retval EFI_NO_MEDIA The device media is not present.
1942 @retval EFI_INVALID_PARAMETER The FileDirHandle was not a directory.
1943 @return An error from FileHandleGetFileName().
1947 EfiShellFindFilesInDir(
1948 IN SHELL_FILE_HANDLE FileDirHandle
,
1949 OUT EFI_SHELL_FILE_INFO
**FileList
1952 EFI_SHELL_FILE_INFO
*ShellFileList
;
1953 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1954 EFI_FILE_INFO
*FileInfo
;
1962 Status
= FileHandleGetFileName(FileDirHandle
, &BasePath
);
1963 if (EFI_ERROR(Status
)) {
1967 if (ShellFileHandleGetPath(FileDirHandle
) != NULL
) {
1970 TempString
= StrnCatGrow(&TempString
, &Size
, ShellFileHandleGetPath(FileDirHandle
), 0);
1971 if (TempString
== NULL
) {
1972 SHELL_FREE_NON_NULL(BasePath
);
1973 return (EFI_OUT_OF_RESOURCES
);
1975 TempSpot
= StrStr(TempString
, L
";");
1977 if (TempSpot
!= NULL
) {
1978 *TempSpot
= CHAR_NULL
;
1981 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
1982 if (TempString
== NULL
) {
1983 SHELL_FREE_NON_NULL(BasePath
);
1984 return (EFI_OUT_OF_RESOURCES
);
1986 SHELL_FREE_NON_NULL(BasePath
);
1987 BasePath
= TempString
;
1991 ShellFileList
= NULL
;
1992 ShellFileListItem
= NULL
;
1994 Status
= EFI_SUCCESS
;
1997 for ( Status
= FileHandleFindFirstFile(FileDirHandle
, &FileInfo
)
1998 ; !EFI_ERROR(Status
) && !NoFile
1999 ; Status
= FileHandleFindNextFile(FileDirHandle
, FileInfo
, &NoFile
)
2002 // allocate a new EFI_SHELL_FILE_INFO and populate it...
2004 ShellFileListItem
= CreateAndPopulateShellFileInfo(
2006 EFI_SUCCESS
, // success since we didnt fail to open it...
2008 NULL
, // no handle since not open
2011 if (ShellFileList
== NULL
) {
2012 ShellFileList
= (EFI_SHELL_FILE_INFO
*)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2013 ASSERT(ShellFileList
!= NULL
);
2014 InitializeListHead(&ShellFileList
->Link
);
2016 InsertTailList(&ShellFileList
->Link
, &ShellFileListItem
->Link
);
2018 if (EFI_ERROR(Status
)) {
2019 EfiShellFreeFileList(&ShellFileList
);
2022 *FileList
= ShellFileList
;
2024 SHELL_FREE_NON_NULL(BasePath
);
2029 Updates a file name to be preceeded by the mapped drive name
2031 @param[in] BasePath the Mapped drive name to prepend
2032 @param[in, out] Path pointer to pointer to the file name to update.
2035 @retval EFI_OUT_OF_RESOURCES
2040 IN CONST CHAR16
*BasePath
,
2041 IN OUT CHAR16
**Path
2050 ASSERT(Path
!= NULL
);
2051 ASSERT(*Path
!= NULL
);
2052 ASSERT(BasePath
!= NULL
);
2055 // convert a local path to an absolute path
2057 if (StrStr(*Path
, L
":") == NULL
) {
2058 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2059 StrnCatGrow(&Path2
, &Path2Size
, BasePath
, 0);
2060 if (Path2
== NULL
) {
2061 return (EFI_OUT_OF_RESOURCES
);
2063 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2064 StrnCatGrow(&Path2
, &Path2Size
, (*Path
)[0] == L
'\\'?(*Path
) + 1 :*Path
, 0);
2065 if (Path2
== NULL
) {
2066 return (EFI_OUT_OF_RESOURCES
);
2073 return (EFI_SUCCESS
);
2077 If FileHandle is a directory then the function reads from FileHandle and reads in
2078 each of the FileInfo structures. If one of them matches the Pattern's first
2079 "level" then it opens that handle and calls itself on that handle.
2081 If FileHandle is a file and matches all of the remaining Pattern (which would be
2082 on its last node), then add a EFI_SHELL_FILE_INFO object for this file to fileList.
2084 Upon a EFI_SUCCESS return fromt he function any the caller is responsible to call
2085 FreeFileList with FileList.
2087 @param[in] FilePattern The FilePattern to check against.
2088 @param[in] UnicodeCollation The pointer to EFI_UNICODE_COLLATION_PROTOCOL structure
2089 @param[in] FileHandle The FileHandle to start with
2090 @param[in, out] FileList pointer to pointer to list of found files.
2091 @param[in] ParentNode The node for the parent. Same file as identified by HANDLE.
2092 @param[in] MapName The file system name this file is on.
2094 @retval EFI_SUCCESS all files were found and the FileList contains a list.
2095 @retval EFI_NOT_FOUND no files were found
2096 @retval EFI_OUT_OF_RESOURCES a memory allocation failed
2101 IN CONST CHAR16
*FilePattern
,
2102 IN EFI_UNICODE_COLLATION_PROTOCOL
*UnicodeCollation
,
2103 IN SHELL_FILE_HANDLE FileHandle
,
2104 IN OUT EFI_SHELL_FILE_INFO
**FileList
,
2105 IN CONST EFI_SHELL_FILE_INFO
*ParentNode OPTIONAL
,
2106 IN CONST CHAR16
*MapName
2110 CONST CHAR16
*NextFilePatternStart
;
2111 CHAR16
*CurrentFilePattern
;
2112 EFI_SHELL_FILE_INFO
*ShellInfo
;
2113 EFI_SHELL_FILE_INFO
*ShellInfoNode
;
2114 EFI_SHELL_FILE_INFO
*NewShellNode
;
2115 EFI_FILE_INFO
*FileInfo
;
2117 CHAR16
*NewFullName
;
2120 if ( FilePattern
== NULL
2121 || UnicodeCollation
== NULL
2124 return (EFI_INVALID_PARAMETER
);
2127 CurrentFilePattern
= NULL
;
2129 if (*FilePattern
== L
'\\') {
2133 for( NextFilePatternStart
= FilePattern
2134 ; *NextFilePatternStart
!= CHAR_NULL
&& *NextFilePatternStart
!= L
'\\'
2135 ; NextFilePatternStart
++);
2137 CurrentFilePattern
= AllocateZeroPool((NextFilePatternStart
-FilePattern
+1)*sizeof(CHAR16
));
2138 ASSERT(CurrentFilePattern
!= NULL
);
2139 StrnCpy(CurrentFilePattern
, FilePattern
, NextFilePatternStart
-FilePattern
);
2141 if (CurrentFilePattern
[0] == CHAR_NULL
2142 &&NextFilePatternStart
[0] == CHAR_NULL
2145 // we want the parent or root node (if no parent)
2147 if (ParentNode
== NULL
) {
2149 // We want the root node. create the node.
2151 FileInfo
= FileHandleGetInfo(FileHandle
);
2152 NewShellNode
= CreateAndPopulateShellFileInfo(
2159 SHELL_FREE_NON_NULL(FileInfo
);
2162 // Add the current parameter FileHandle to the list, then end...
2164 NewShellNode
= InternalDuplicateShellFileInfo((EFI_SHELL_FILE_INFO
*)ParentNode
, TRUE
);
2166 if (NewShellNode
== NULL
) {
2167 Status
= EFI_OUT_OF_RESOURCES
;
2169 NewShellNode
->Handle
= NULL
;
2170 if (*FileList
== NULL
) {
2171 *FileList
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2172 InitializeListHead(&((*FileList
)->Link
));
2176 // Add to the returning to use list
2178 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
2180 Status
= EFI_SUCCESS
;
2183 Status
= EfiShellFindFilesInDir(FileHandle
, &ShellInfo
);
2185 if (!EFI_ERROR(Status
)){
2186 if (StrStr(NextFilePatternStart
, L
"\\") != NULL
){
2191 for ( ShellInfoNode
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&ShellInfo
->Link
)
2192 ; !IsNull (&ShellInfo
->Link
, &ShellInfoNode
->Link
)
2193 ; ShellInfoNode
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&ShellInfo
->Link
, &ShellInfoNode
->Link
)
2195 if (UnicodeCollation
->MetaiMatch(UnicodeCollation
, (CHAR16
*)ShellInfoNode
->FileName
, CurrentFilePattern
)){
2196 if (ShellInfoNode
->FullName
!= NULL
&& StrStr(ShellInfoNode
->FullName
, L
":") == NULL
) {
2197 Size
= StrSize(ShellInfoNode
->FullName
);
2198 Size
+= StrSize(MapName
) + sizeof(CHAR16
);
2199 NewFullName
= AllocateZeroPool(Size
);
2200 if (NewFullName
== NULL
) {
2201 Status
= EFI_OUT_OF_RESOURCES
;
2203 StrCpy(NewFullName
, MapName
);
2204 StrCat(NewFullName
, ShellInfoNode
->FullName
+1);
2205 FreePool((VOID
*)ShellInfoNode
->FullName
);
2206 ShellInfoNode
->FullName
= NewFullName
;
2209 if (Directory
&& !EFI_ERROR(Status
) && ShellInfoNode
->FullName
!= NULL
&& ShellInfoNode
->FileName
!= NULL
){
2211 // should be a directory
2215 // don't open the . and .. directories
2217 if ( (StrCmp(ShellInfoNode
->FileName
, L
".") != 0)
2218 && (StrCmp(ShellInfoNode
->FileName
, L
"..") != 0)
2223 if (EFI_ERROR(Status
)) {
2227 // Open the directory since we need that handle in the next recursion.
2229 ShellInfoNode
->Status
= EfiShellOpenFileByName (ShellInfoNode
->FullName
, &ShellInfoNode
->Handle
, EFI_FILE_MODE_READ
);
2232 // recurse with the next part of the pattern
2234 Status
= ShellSearchHandle(NextFilePatternStart
, UnicodeCollation
, ShellInfoNode
->Handle
, FileList
, ShellInfoNode
, MapName
);
2236 } else if (!EFI_ERROR(Status
)) {
2242 // copy the information we need into a new Node
2244 NewShellNode
= InternalDuplicateShellFileInfo(ShellInfoNode
, FALSE
);
2245 ASSERT(NewShellNode
!= NULL
);
2246 if (NewShellNode
== NULL
) {
2247 Status
= EFI_OUT_OF_RESOURCES
;
2249 if (*FileList
== NULL
) {
2250 *FileList
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2251 InitializeListHead(&((*FileList
)->Link
));
2255 // Add to the returning to use list
2257 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
2260 if (EFI_ERROR(Status
)) {
2264 if (EFI_ERROR(Status
)) {
2265 EfiShellFreeFileList(&ShellInfo
);
2267 Status
= EfiShellFreeFileList(&ShellInfo
);
2272 FreePool(CurrentFilePattern
);
2277 Find files that match a specified pattern.
2279 This function searches for all files and directories that match the specified
2280 FilePattern. The FilePattern can contain wild-card characters. The resulting file
2281 information is placed in the file list FileList.
2283 Wildcards are processed
2284 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1.
2286 The files in the file list are not opened. The OpenMode field is set to 0 and the FileInfo
2287 field is set to NULL.
2289 if *FileList is not NULL then it must be a pre-existing and properly initialized list.
2291 @param FilePattern Points to a NULL-terminated shell file path, including wildcards.
2292 @param FileList On return, points to the start of a file list containing the names
2293 of all matching files or else points to NULL if no matching files
2294 were found. only on a EFI_SUCCESS return will; this be non-NULL.
2296 @retval EFI_SUCCESS Files found. FileList is a valid list.
2297 @retval EFI_NOT_FOUND No files found.
2298 @retval EFI_NO_MEDIA The device has no media
2299 @retval EFI_DEVICE_ERROR The device reported an error
2300 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted
2305 IN CONST CHAR16
*FilePattern
,
2306 OUT EFI_SHELL_FILE_INFO
**FileList
2310 CHAR16
*PatternCopy
;
2311 CHAR16
*PatternCurrentLocation
;
2312 EFI_DEVICE_PATH_PROTOCOL
*RootDevicePath
;
2313 SHELL_FILE_HANDLE RootFileHandle
;
2317 if ( FilePattern
== NULL
2319 || StrStr(FilePattern
, L
":") == NULL
2321 return (EFI_INVALID_PARAMETER
);
2323 Status
= EFI_SUCCESS
;
2324 RootDevicePath
= NULL
;
2325 RootFileHandle
= NULL
;
2327 PatternCopy
= AllocateZeroPool(StrSize(FilePattern
));
2328 if (PatternCopy
== NULL
) {
2329 return (EFI_OUT_OF_RESOURCES
);
2331 StrCpy(PatternCopy
, FilePattern
);
2333 PatternCopy
= PathCleanUpDirectories(PatternCopy
);
2335 Count
= StrStr(PatternCopy
, L
":") - PatternCopy
;
2338 ASSERT(MapName
== NULL
);
2339 MapName
= StrnCatGrow(&MapName
, NULL
, PatternCopy
, Count
);
2340 if (MapName
== NULL
) {
2341 Status
= EFI_OUT_OF_RESOURCES
;
2343 RootDevicePath
= EfiShellGetDevicePathFromFilePath(PatternCopy
);
2344 if (RootDevicePath
== NULL
) {
2345 Status
= EFI_INVALID_PARAMETER
;
2347 Status
= EfiShellOpenRoot(RootDevicePath
, &RootFileHandle
);
2348 if (!EFI_ERROR(Status
)) {
2349 for ( PatternCurrentLocation
= PatternCopy
2350 ; *PatternCurrentLocation
!= ':'
2351 ; PatternCurrentLocation
++);
2352 PatternCurrentLocation
++;
2353 Status
= ShellSearchHandle(PatternCurrentLocation
, gUnicodeCollation
, RootFileHandle
, FileList
, NULL
, MapName
);
2355 FreePool(RootDevicePath
);
2359 SHELL_FREE_NON_NULL(PatternCopy
);
2360 SHELL_FREE_NON_NULL(MapName
);
2366 Opens the files that match the path specified.
2368 This function opens all of the files specified by Path. Wildcards are processed
2369 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1. Each
2370 matching file has an EFI_SHELL_FILE_INFO structure created in a linked list.
2372 @param Path A pointer to the path string.
2373 @param OpenMode Specifies the mode used to open each file, EFI_FILE_MODE_READ or
2374 EFI_FILE_MODE_WRITE.
2375 @param FileList Points to the start of a list of files opened.
2377 @retval EFI_SUCCESS Create the file list successfully.
2378 @return Others Can't create the file list.
2382 EfiShellOpenFileList(
2385 IN OUT EFI_SHELL_FILE_INFO
**FileList
2389 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
2392 CONST CHAR16
*CurDir
;
2395 PathCleanUpDirectories(Path
);
2400 if (FileList
== NULL
|| *FileList
== NULL
) {
2401 return (EFI_INVALID_PARAMETER
);
2404 if (*Path
== L
'.' && *(Path
+1) == L
'\\') {
2409 // convert a local path to an absolute path
2411 if (StrStr(Path
, L
":") == NULL
) {
2412 CurDir
= EfiShellGetCurDir(NULL
);
2413 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2414 StrnCatGrow(&Path2
, &Path2Size
, CurDir
, 0);
2415 if (*Path
== L
'\\') {
2417 while (PathRemoveLastItem(Path2
)) ;
2419 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2420 StrnCatGrow(&Path2
, &Path2Size
, Path
, 0);
2422 ASSERT(Path2
== NULL
);
2423 StrnCatGrow(&Path2
, NULL
, Path
, 0);
2426 PathCleanUpDirectories (Path2
);
2431 Status
= EfiShellFindFiles(Path2
, FileList
);
2435 if (EFI_ERROR(Status
)) {
2441 // We had no errors so open all the files (that are not already opened...)
2443 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
2444 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2445 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2447 if (ShellFileListItem
->Status
== 0 && ShellFileListItem
->Handle
== NULL
) {
2448 ShellFileListItem
->Status
= EfiShellOpenFileByName (ShellFileListItem
->FullName
, &ShellFileListItem
->Handle
, OpenMode
);
2454 return (EFI_NOT_FOUND
);
2456 return(EFI_SUCCESS
);
2460 This function updated with errata.
2462 Gets either a single or list of environment variables.
2464 If name is not NULL then this function returns the current value of the specified
2465 environment variable.
2467 If Name is NULL, then a list of all environment variable names is returned. Each is a
2468 NULL terminated string with a double NULL terminating the list.
2470 @param Name A pointer to the environment variable name. If
2471 Name is NULL, then the function will return all
2472 of the defined shell environment variables. In
2473 the case where multiple environment variables are
2474 being returned, each variable will be terminated by
2475 a NULL, and the list will be terminated by a double
2478 @return !=NULL A pointer to the returned string.
2479 The returned pointer does not need to be freed by the caller.
2481 @retval NULL The environment variable doesn't exist or there are
2482 no environment variables.
2487 IN CONST CHAR16
*Name
2495 CHAR16
*CurrentWriteLocation
;
2502 // Get all our environment variables
2504 InitializeListHead(&List
);
2505 Status
= GetEnvironmentVariableList(&List
);
2506 if (EFI_ERROR(Status
)){
2511 // Build the semi-colon delimited list. (2 passes)
2513 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&List
)
2514 ; !IsNull(&List
, &Node
->Link
)
2515 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&List
, &Node
->Link
)
2517 ASSERT(Node
->Key
!= NULL
);
2518 Size
+= StrSize(Node
->Key
);
2521 Size
+= 2*sizeof(CHAR16
);
2523 Buffer
= AllocateZeroPool(Size
);
2524 if (Buffer
== NULL
) {
2525 if (!IsListEmpty (&List
)) {
2526 FreeEnvironmentVariableList(&List
);
2530 CurrentWriteLocation
= (CHAR16
*)Buffer
;
2532 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&List
)
2533 ; !IsNull(&List
, &Node
->Link
)
2534 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&List
, &Node
->Link
)
2536 ASSERT(Node
->Key
!= NULL
);
2537 StrCpy(CurrentWriteLocation
, Node
->Key
);
2538 CurrentWriteLocation
+= StrLen(CurrentWriteLocation
) + 1;
2544 if (!IsListEmpty (&List
)) {
2545 FreeEnvironmentVariableList(&List
);
2549 // We are doing a specific environment variable
2553 // get the size we need for this EnvVariable
2555 Status
= SHELL_GET_ENVIRONMENT_VARIABLE(Name
, &Size
, Buffer
);
2556 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2558 // Allocate the space and recall the get function
2560 Buffer
= AllocateZeroPool(Size
);
2561 ASSERT(Buffer
!= NULL
);
2562 Status
= SHELL_GET_ENVIRONMENT_VARIABLE(Name
, &Size
, Buffer
);
2565 // we didnt get it (might not exist)
2566 // free the memory if we allocated any and return NULL
2568 if (EFI_ERROR(Status
)) {
2569 if (Buffer
!= NULL
) {
2577 // return the buffer
2579 return (AddBufferToFreeList(Buffer
));
2583 Internal variable setting function. Allows for setting of the read only variables.
2585 @param Name Points to the NULL-terminated environment variable name.
2586 @param Value Points to the NULL-terminated environment variable value. If the value is an
2587 empty string then the environment variable is deleted.
2588 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2590 @retval EFI_SUCCESS The environment variable was successfully updated.
2594 InternalEfiShellSetEnv(
2595 IN CONST CHAR16
*Name
,
2596 IN CONST CHAR16
*Value
,
2600 if (Value
== NULL
|| StrLen(Value
) == 0) {
2601 return (SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
));
2603 SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
);
2605 return (SHELL_SET_ENVIRONMENT_VARIABLE_V(Name
, StrSize(Value
), Value
));
2607 return (SHELL_SET_ENVIRONMENT_VARIABLE_NV(Name
, StrSize(Value
), Value
));
2613 Sets the environment variable.
2615 This function changes the current value of the specified environment variable. If the
2616 environment variable exists and the Value is an empty string, then the environment
2617 variable is deleted. If the environment variable exists and the Value is not an empty
2618 string, then the value of the environment variable is changed. If the environment
2619 variable does not exist and the Value is an empty string, there is no action. If the
2620 environment variable does not exist and the Value is a non-empty string, then the
2621 environment variable is created and assigned the specified value.
2623 For a description of volatile and non-volatile environment variables, see UEFI Shell
2624 2.0 specification section 3.6.1.
2626 @param Name Points to the NULL-terminated environment variable name.
2627 @param Value Points to the NULL-terminated environment variable value. If the value is an
2628 empty string then the environment variable is deleted.
2629 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2631 @retval EFI_SUCCESS The environment variable was successfully updated.
2636 IN CONST CHAR16
*Name
,
2637 IN CONST CHAR16
*Value
,
2641 if (Name
== NULL
|| *Name
== CHAR_NULL
) {
2642 return (EFI_INVALID_PARAMETER
);
2645 // Make sure we dont 'set' a predefined read only variable
2647 if (gUnicodeCollation
->StriColl(
2651 ||gUnicodeCollation
->StriColl(
2655 ||gUnicodeCollation
->StriColl(
2659 ||gUnicodeCollation
->StriColl(
2662 L
"uefishellsupport") == 0
2663 ||gUnicodeCollation
->StriColl(
2666 L
"uefishellversion") == 0
2667 ||gUnicodeCollation
->StriColl(
2670 L
"uefiversion") == 0
2672 return (EFI_INVALID_PARAMETER
);
2674 return (InternalEfiShellSetEnv(Name
, Value
, Volatile
));
2678 Returns the current directory on the specified device.
2680 If FileSystemMapping is NULL, it returns the current working directory. If the
2681 FileSystemMapping is not NULL, it returns the current directory associated with the
2682 FileSystemMapping. In both cases, the returned name includes the file system
2683 mapping (i.e. fs0:\current-dir).
2685 @param FileSystemMapping A pointer to the file system mapping. If NULL,
2686 then the current working directory is returned.
2688 @retval !=NULL The current directory.
2689 @retval NULL Current directory does not exist.
2694 IN CONST CHAR16
*FileSystemMapping OPTIONAL
2697 CHAR16
*PathToReturn
;
2699 SHELL_MAP_LIST
*MapListItem
;
2700 if (!IsListEmpty(&gShellMapList
.Link
)) {
2702 // if parameter is NULL, use current
2704 if (FileSystemMapping
== NULL
) {
2705 return (EfiShellGetEnv(L
"cwd"));
2708 PathToReturn
= NULL
;
2709 MapListItem
= ShellCommandFindMapItem(FileSystemMapping
);
2710 if (MapListItem
!= NULL
) {
2711 ASSERT((PathToReturn
== NULL
&& Size
== 0) || (PathToReturn
!= NULL
));
2712 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->MapName
, 0);
2713 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
2716 return (AddBufferToFreeList(PathToReturn
));
2723 Changes the current directory on the specified device.
2725 If the FileSystem is NULL, and the directory Dir does not contain a file system's
2726 mapped name, this function changes the current working directory.
2728 If the FileSystem is NULL and the directory Dir contains a mapped name, then the
2729 current file system and the current directory on that file system are changed.
2731 If FileSystem is NULL, and Dir is not NULL, then this changes the current working file
2734 If FileSystem is not NULL and Dir is not NULL, then this function changes the current
2735 directory on the specified file system.
2737 If the current working directory or the current working file system is changed then the
2738 %cwd% environment variable will be updated
2740 @param FileSystem A pointer to the file system's mapped name. If NULL, then the current working
2741 directory is changed.
2742 @param Dir Points to the NULL-terminated directory on the device specified by FileSystem.
2744 @retval EFI_SUCCESS The operation was sucessful
2745 @retval EFI_NOT_FOUND The file system could not be found
2750 IN CONST CHAR16
*FileSystem OPTIONAL
,
2751 IN CONST CHAR16
*Dir
2755 SHELL_MAP_LIST
*MapListItem
;
2759 CHAR16
*DirectoryName
;
2766 DirectoryName
= NULL
;
2768 if ((FileSystem
== NULL
&& Dir
== NULL
) || Dir
== NULL
) {
2769 return (EFI_INVALID_PARAMETER
);
2772 if (IsListEmpty(&gShellMapList
.Link
)){
2773 return (EFI_NOT_FOUND
);
2776 DirectoryName
= StrnCatGrow(&DirectoryName
, NULL
, Dir
, 0);
2777 ASSERT(DirectoryName
!= NULL
);
2779 PathCleanUpDirectories(DirectoryName
);
2781 if (FileSystem
== NULL
) {
2783 // determine the file system mapping to use
2785 if (StrStr(DirectoryName
, L
":") != NULL
) {
2786 ASSERT(MapName
== NULL
);
2787 MapName
= StrnCatGrow(&MapName
, NULL
, DirectoryName
, (StrStr(DirectoryName
, L
":")-DirectoryName
+1));
2790 // find the file system mapping's entry in the list
2793 if (MapName
!= NULL
) {
2794 MapListItem
= ShellCommandFindMapItem(MapName
);
2797 // make that the current file system mapping
2799 if (MapListItem
!= NULL
) {
2800 gShellCurDir
= MapListItem
;
2803 MapListItem
= gShellCurDir
;
2806 if (MapListItem
== NULL
) {
2807 return (EFI_NOT_FOUND
);
2811 // now update the MapListItem's current directory
2813 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& DirectoryName
[StrLen(DirectoryName
) - 1] != L
':') {
2814 FreePool(MapListItem
->CurrentDirectoryPath
);
2815 MapListItem
->CurrentDirectoryPath
= NULL
;
2817 if (MapName
!= NULL
) {
2818 TempLen
= StrLen(MapName
);
2819 if (TempLen
!= StrLen(DirectoryName
)) {
2820 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2821 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
+StrLen(MapName
), 0);
2824 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2825 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
2827 if ((MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] != L
'\\') || (MapListItem
->CurrentDirectoryPath
== NULL
)) {
2828 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2829 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2833 // cant have a mapping in the directory...
2835 if (StrStr(DirectoryName
, L
":") != NULL
) {
2836 return (EFI_INVALID_PARAMETER
);
2839 // FileSystem != NULL
2841 MapListItem
= ShellCommandFindMapItem(FileSystem
);
2842 if (MapListItem
== NULL
) {
2843 return (EFI_INVALID_PARAMETER
);
2845 // gShellCurDir = MapListItem;
2846 if (DirectoryName
!= NULL
) {
2848 // change current dir on that file system
2851 if (MapListItem
->CurrentDirectoryPath
!= NULL
) {
2852 FreePool(MapListItem
->CurrentDirectoryPath
);
2853 DEBUG_CODE(MapListItem
->CurrentDirectoryPath
= NULL
;);
2855 // ASSERT((MapListItem->CurrentDirectoryPath == NULL && Size == 0) || (MapListItem->CurrentDirectoryPath != NULL));
2856 // MapListItem->CurrentDirectoryPath = StrnCatGrow(&MapListItem->CurrentDirectoryPath, &Size, FileSystem, 0);
2857 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2858 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2859 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2860 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
2861 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] != L
'\\') {
2862 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2863 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2868 // if updated the current directory then update the environment variable
2870 if (MapListItem
== gShellCurDir
) {
2872 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
2873 StrnCatGrow(&TempString
, &Size
, MapListItem
->MapName
, 0);
2874 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
2875 StrnCatGrow(&TempString
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
2876 Status
= InternalEfiShellSetEnv(L
"cwd", TempString
, TRUE
);
2877 FreePool(TempString
);
2880 return(EFI_SUCCESS
);
2884 Return help information about a specific command.
2886 This function returns the help information for the specified command. The help text
2887 can be internal to the shell or can be from a UEFI Shell manual page.
2889 If Sections is specified, then each section name listed will be compared in a casesensitive
2890 manner, to the section names described in Appendix B. If the section exists,
2891 it will be appended to the returned help text. If the section does not exist, no
2892 information will be returned. If Sections is NULL, then all help text information
2893 available will be returned.
2895 @param Command Points to the NULL-terminated UEFI Shell command name.
2896 @param Sections Points to the NULL-terminated comma-delimited
2897 section names to return. If NULL, then all
2898 sections will be returned.
2899 @param HelpText On return, points to a callee-allocated buffer
2900 containing all specified help text.
2902 @retval EFI_SUCCESS The help text was returned.
2903 @retval EFI_OUT_OF_RESOURCES The necessary buffer could not be allocated to hold the
2905 @retval EFI_INVALID_PARAMETER HelpText is NULL
2906 @retval EFI_NOT_FOUND There is no help text available for Command.
2910 EfiShellGetHelpText(
2911 IN CONST CHAR16
*Command
,
2912 IN CONST CHAR16
*Sections OPTIONAL
,
2913 OUT CHAR16
**HelpText
2916 CONST CHAR16
*ManFileName
;
2920 ASSERT(HelpText
!= NULL
);
2923 ManFileName
= ShellCommandGetManFileNameHandler(Command
);
2925 if (ManFileName
!= NULL
) {
2926 return (ProcessManFile(ManFileName
, Command
, Sections
, NULL
, HelpText
));
2928 if ((StrLen(Command
)> 4)
2929 && (Command
[StrLen(Command
)-1] == L
'i' || Command
[StrLen(Command
)-1] == L
'I')
2930 && (Command
[StrLen(Command
)-2] == L
'f' || Command
[StrLen(Command
)-2] == L
'F')
2931 && (Command
[StrLen(Command
)-3] == L
'e' || Command
[StrLen(Command
)-3] == L
'E')
2932 && (Command
[StrLen(Command
)-4] == L
'.')
2934 FixCommand
= AllocateZeroPool(StrSize(Command
) - 4 * sizeof (CHAR16
));
2935 ASSERT(FixCommand
!= NULL
);
2937 StrnCpy(FixCommand
, Command
, StrLen(Command
)-4);
2938 Status
= ProcessManFile(FixCommand
, FixCommand
, Sections
, NULL
, HelpText
);
2939 FreePool(FixCommand
);
2942 return (ProcessManFile(Command
, Command
, Sections
, NULL
, HelpText
));
2948 Gets the enable status of the page break output mode.
2950 User can use this function to determine current page break mode.
2952 @retval TRUE The page break output mode is enabled.
2953 @retval FALSE The page break output mode is disabled.
2957 EfiShellGetPageBreak(
2961 return(ShellInfoObject
.PageBreakEnabled
);
2965 Judges whether the active shell is the root shell.
2967 This function makes the user to know that whether the active Shell is the root shell.
2969 @retval TRUE The active Shell is the root Shell.
2970 @retval FALSE The active Shell is NOT the root Shell.
2974 EfiShellIsRootShell(
2978 return(ShellInfoObject
.RootShellInstance
);
2982 function to return a semi-colon delimeted list of all alias' in the current shell
2984 up to caller to free the memory.
2986 @retval NULL No alias' were found
2987 @retval NULL An error ocurred getting alias'
2988 @return !NULL a list of all alias'
2992 InternalEfiShellGetListAlias(
3000 CHAR16
*VariableName
;
3005 Status
= gRT
->QueryVariableInfo(EFI_VARIABLE_NON_VOLATILE
|EFI_VARIABLE_BOOTSERVICE_ACCESS
, &MaxStorSize
, &RemStorSize
, &MaxVarSize
);
3006 ASSERT_EFI_ERROR(Status
);
3008 VariableName
= AllocateZeroPool((UINTN
)MaxVarSize
);
3012 if (VariableName
== NULL
) {
3016 VariableName
[0] = CHAR_NULL
;
3019 NameSize
= (UINTN
)MaxVarSize
;
3020 Status
= gRT
->GetNextVariableName(&NameSize
, VariableName
, &Guid
);
3021 if (Status
== EFI_NOT_FOUND
){
3024 ASSERT_EFI_ERROR(Status
);
3025 if (EFI_ERROR(Status
)) {
3028 if (CompareGuid(&Guid
, &gShellAliasGuid
)){
3029 ASSERT((RetVal
== NULL
&& RetSize
== 0) || (RetVal
!= NULL
));
3030 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, VariableName
, 0);
3031 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, L
";", 0);
3034 FreePool(VariableName
);
3040 Convert a null-terminated unicode string, in-place, to all lowercase.
3043 @param Str The null-terminated string to be converted to all lowercase.
3045 @return The null-terminated string converted into all lowercase.
3054 for (Index
= 0; Str
[Index
] != L
'\0'; Index
++) {
3055 if (Str
[Index
] >= L
'A' && Str
[Index
] <= L
'Z') {
3056 Str
[Index
] -= (CHAR16
)(L
'A' - L
'a');
3063 This function returns the command associated with a alias or a list of all
3066 @param[in] Alias Points to the NULL-terminated shell alias.
3067 If this parameter is NULL, then all
3068 aliases will be returned in ReturnedData.
3069 @param[out] Volatile upon return of a single command if TRUE indicates
3070 this is stored in a volatile fashion. FALSE otherwise.
3072 @return If Alias is not NULL, it will return a pointer to
3073 the NULL-terminated command for that alias.
3074 If Alias is NULL, ReturnedData points to a ';'
3075 delimited list of alias (e.g.
3076 ReturnedData = "dir;del;copy;mfp") that is NULL-terminated.
3077 @retval NULL an error ocurred
3078 @retval NULL Alias was not a valid Alias
3083 IN CONST CHAR16
*Alias
,
3084 OUT BOOLEAN
*Volatile OPTIONAL
3093 // Convert to lowercase to make aliases case-insensitive
3094 if (Alias
!= NULL
) {
3095 AliasLower
= AllocateCopyPool (StrSize (Alias
), Alias
);
3096 ASSERT (AliasLower
!= NULL
);
3097 ToLower (AliasLower
);
3099 if (Volatile
== NULL
) {
3100 return (AddBufferToFreeList(GetVariable(AliasLower
, &gShellAliasGuid
)));
3104 Status
= gRT
->GetVariable(AliasLower
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
3105 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3106 RetVal
= AllocateZeroPool(RetSize
);
3107 Status
= gRT
->GetVariable(AliasLower
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
3109 if (EFI_ERROR(Status
)) {
3110 if (RetVal
!= NULL
) {
3115 if ((EFI_VARIABLE_NON_VOLATILE
& Attribs
) == EFI_VARIABLE_NON_VOLATILE
) {
3121 FreePool (AliasLower
);
3122 return (AddBufferToFreeList(RetVal
));
3124 return (AddBufferToFreeList(InternalEfiShellGetListAlias()));
3128 Changes a shell command alias.
3130 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3132 this function does not check for built in alias'.
3134 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3135 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3136 Command refers to an alias, that alias will be deleted.
3137 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3138 Alias being set will be stored in a non-volatile fashion.
3140 @retval EFI_SUCCESS Alias created or deleted successfully.
3141 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3146 IN CONST CHAR16
*Command
,
3147 IN CONST CHAR16
*Alias
,
3154 // Convert to lowercase to make aliases case-insensitive
3155 if (Alias
!= NULL
) {
3156 AliasLower
= AllocateCopyPool (StrSize (Alias
), Alias
);
3157 ASSERT (AliasLower
!= NULL
);
3158 ToLower (AliasLower
);
3164 // We must be trying to remove one if Alias is NULL
3166 if (Alias
== NULL
) {
3168 // remove an alias (but passed in COMMAND parameter)
3170 Status
= (gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
));
3173 // Add and replace are the same
3176 // We dont check the error return on purpose since the variable may not exist.
3177 gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
);
3179 Status
= (gRT
->SetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, EFI_VARIABLE_BOOTSERVICE_ACCESS
|(Volatile
?0:EFI_VARIABLE_NON_VOLATILE
), StrSize(Command
), (VOID
*)Command
));
3182 if (Alias
!= NULL
) {
3183 FreePool (AliasLower
);
3189 Changes a shell command alias.
3191 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3194 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3195 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3196 Command refers to an alias, that alias will be deleted.
3197 @param[in] Replace If TRUE and the alias already exists, then the existing alias will be replaced. If
3198 FALSE and the alias already exists, then the existing alias is unchanged and
3199 EFI_ACCESS_DENIED is returned.
3200 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3201 Alias being set will be stored in a non-volatile fashion.
3203 @retval EFI_SUCCESS Alias created or deleted successfully.
3204 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3205 @retval EFI_ACCESS_DENIED The alias is a built-in alias or already existed and Replace was set to
3207 @retval EFI_INVALID_PARAMETER Command is null or the empty string.
3212 IN CONST CHAR16
*Command
,
3213 IN CONST CHAR16
*Alias
,
3218 if (ShellCommandIsOnAliasList(Alias
==NULL
?Command
:Alias
)) {
3220 // cant set over a built in alias
3222 return (EFI_ACCESS_DENIED
);
3223 } else if (Command
== NULL
|| *Command
== CHAR_NULL
|| StrLen(Command
) == 0) {
3225 // Command is null or empty
3227 return (EFI_INVALID_PARAMETER
);
3228 } else if (EfiShellGetAlias(Command
, NULL
) != NULL
&& !Replace
) {
3230 // Alias already exists, Replace not set
3232 return (EFI_ACCESS_DENIED
);
3234 return (InternalSetAlias(Command
, Alias
, Volatile
));
3238 // Pure FILE_HANDLE operations are passed to FileHandleLib
3239 // these functions are indicated by the *
3240 EFI_SHELL_PROTOCOL mShellProtocol
= {
3246 EfiShellGetHelpText
,
3247 EfiShellGetDevicePathFromMap
,
3248 EfiShellGetMapFromDevicePath
,
3249 EfiShellGetDevicePathFromFilePath
,
3250 EfiShellGetFilePathFromDevicePath
,
3254 EfiShellOpenFileList
,
3255 EfiShellFreeFileList
,
3256 EfiShellRemoveDupInFileList
,
3257 EfiShellBatchIsActive
,
3258 EfiShellIsRootShell
,
3259 EfiShellEnablePageBreak
,
3260 EfiShellDisablePageBreak
,
3261 EfiShellGetPageBreak
,
3262 EfiShellGetDeviceName
,
3263 (EFI_SHELL_GET_FILE_INFO
)FileHandleGetInfo
, //*
3264 (EFI_SHELL_SET_FILE_INFO
)FileHandleSetInfo
, //*
3265 EfiShellOpenFileByName
,
3268 (EFI_SHELL_READ_FILE
)FileHandleRead
, //*
3269 (EFI_SHELL_WRITE_FILE
)FileHandleWrite
, //*
3270 (EFI_SHELL_DELETE_FILE
)FileHandleDelete
, //*
3271 EfiShellDeleteFileByName
,
3272 (EFI_SHELL_GET_FILE_POSITION
)FileHandleGetPosition
, //*
3273 (EFI_SHELL_SET_FILE_POSITION
)FileHandleSetPosition
, //*
3274 (EFI_SHELL_FLUSH_FILE
)FileHandleFlush
, //*
3276 EfiShellFindFilesInDir
,
3277 (EFI_SHELL_GET_FILE_SIZE
)FileHandleGetSize
, //*
3279 EfiShellOpenRootByHandle
,
3281 SHELL_MAJOR_VERSION
,
3286 Function to create and install on the current handle.
3288 Will overwrite any existing ShellProtocols in the system to be sure that
3289 the current shell is in control.
3291 This must be removed via calling CleanUpShellProtocol().
3293 @param[in, out] NewShell The pointer to the pointer to the structure
3296 @retval EFI_SUCCESS The operation was successful.
3297 @return An error from LocateHandle, CreateEvent, or other core function.
3301 CreatePopulateInstallShellProtocol (
3302 IN OUT EFI_SHELL_PROTOCOL
**NewShell
3308 UINTN HandleCounter
;
3309 SHELL_PROTOCOL_HANDLE_LIST
*OldProtocolNode
;
3311 if (NewShell
== NULL
) {
3312 return (EFI_INVALID_PARAMETER
);
3317 OldProtocolNode
= NULL
;
3318 InitializeListHead(&ShellInfoObject
.OldShellList
.Link
);
3321 // Initialize EfiShellProtocol object...
3323 Status
= gBS
->CreateEvent(0,
3327 &mShellProtocol
.ExecutionBreak
);
3328 if (EFI_ERROR(Status
)) {
3333 // Get the size of the buffer we need.
3335 Status
= gBS
->LocateHandle(ByProtocol
,
3336 &gEfiShellProtocolGuid
,
3340 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3342 // Allocate and recall with buffer of correct size
3344 Buffer
= AllocateZeroPool(BufferSize
);
3345 if (Buffer
== NULL
) {
3346 return (EFI_OUT_OF_RESOURCES
);
3348 Status
= gBS
->LocateHandle(ByProtocol
,
3349 &gEfiShellProtocolGuid
,
3353 if (EFI_ERROR(Status
)) {
3358 // now overwrite each of them, but save the info to restore when we end.
3360 for (HandleCounter
= 0 ; HandleCounter
< (BufferSize
/sizeof(EFI_HANDLE
)) ; HandleCounter
++) {
3361 OldProtocolNode
= AllocateZeroPool(sizeof(SHELL_PROTOCOL_HANDLE_LIST
));
3362 ASSERT(OldProtocolNode
!= NULL
);
3363 Status
= gBS
->OpenProtocol(Buffer
[HandleCounter
],
3364 &gEfiShellProtocolGuid
,
3365 (VOID
**) &(OldProtocolNode
->Interface
),
3368 EFI_OPEN_PROTOCOL_GET_PROTOCOL
3370 if (!EFI_ERROR(Status
)) {
3372 // reinstall over the old one...
3374 OldProtocolNode
->Handle
= Buffer
[HandleCounter
];
3375 Status
= gBS
->ReinstallProtocolInterface(
3376 OldProtocolNode
->Handle
,
3377 &gEfiShellProtocolGuid
,
3378 OldProtocolNode
->Interface
,
3379 (VOID
*)(&mShellProtocol
));
3380 if (!EFI_ERROR(Status
)) {
3382 // we reinstalled sucessfully. log this so we can reverse it later.
3386 // add to the list for subsequent...
3388 InsertTailList(&ShellInfoObject
.OldShellList
.Link
, &OldProtocolNode
->Link
);
3393 } else if (Status
== EFI_NOT_FOUND
) {
3394 ASSERT(IsListEmpty(&ShellInfoObject
.OldShellList
.Link
));
3396 // no one else published yet. just publish it ourselves.
3398 Status
= gBS
->InstallProtocolInterface (
3400 &gEfiShellProtocolGuid
,
3401 EFI_NATIVE_INTERFACE
,
3402 (VOID
*)(&mShellProtocol
));
3405 if (PcdGetBool(PcdShellSupportOldProtocols
)){
3406 ///@todo support ShellEnvironment2
3407 ///@todo do we need to support ShellEnvironment (not ShellEnvironment2) also?
3410 if (!EFI_ERROR(Status
)) {
3411 *NewShell
= &mShellProtocol
;
3417 Opposite of CreatePopulateInstallShellProtocol.
3419 Free all memory and restore the system to the state it was in before calling
3420 CreatePopulateInstallShellProtocol.
3422 @param[in, out] NewShell The pointer to the new shell protocol structure.
3424 @retval EFI_SUCCESS The operation was successful.
3428 CleanUpShellProtocol (
3429 IN OUT EFI_SHELL_PROTOCOL
*NewShell
3433 SHELL_PROTOCOL_HANDLE_LIST
*Node2
;
3434 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3437 // if we need to restore old protocols...
3439 if (!IsListEmpty(&ShellInfoObject
.OldShellList
.Link
)) {
3440 for (Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*)GetFirstNode(&ShellInfoObject
.OldShellList
.Link
)
3441 ; !IsListEmpty (&ShellInfoObject
.OldShellList
.Link
)
3442 ; Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*)GetFirstNode(&ShellInfoObject
.OldShellList
.Link
)
3444 RemoveEntryList(&Node2
->Link
);
3445 Status
= gBS
->ReinstallProtocolInterface(Node2
->Handle
,
3446 &gEfiShellProtocolGuid
,
3453 // no need to restore
3455 Status
= gBS
->UninstallProtocolInterface(gImageHandle
,
3456 &gEfiShellProtocolGuid
,
3459 Status
= gBS
->CloseEvent(NewShell
->ExecutionBreak
);
3460 NewShell
->ExecutionBreak
= NULL
;
3462 Status
= gBS
->OpenProtocol(
3463 gST
->ConsoleInHandle
,
3464 &gEfiSimpleTextInputExProtocolGuid
,
3468 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3470 if (!EFI_ERROR (Status
)) {
3471 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle1
);
3472 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle2
);
3473 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle3
);
3474 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle4
);
3475 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle1
);
3476 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle2
);
3477 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle3
);
3478 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle4
);
3484 Notification function for keystrokes.
3486 @param[in] KeyData The key that was pressed.
3488 @retval EFI_SUCCESS The operation was successful.
3492 NotificationFunction(
3493 IN EFI_KEY_DATA
*KeyData
3496 if ( ((KeyData
->Key
.UnicodeChar
== L
'c') &&
3497 (KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
) || KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
))) ||
3498 (KeyData
->Key
.UnicodeChar
== 3)
3500 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3501 return (EFI_UNSUPPORTED
);
3503 return (gBS
->SignalEvent(ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
));
3504 } else if ((KeyData
->Key
.UnicodeChar
== L
's') &&
3505 (KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
) || KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
))
3507 ShellInfoObject
.HaltOutput
= TRUE
;
3509 return (EFI_SUCCESS
);
3513 Function to start monitoring for CTRL-C using SimpleTextInputEx. This
3514 feature's enabled state was not known when the shell initially launched.
3516 @retval EFI_SUCCESS The feature is enabled.
3517 @retval EFI_OUT_OF_RESOURCES There is not enough mnemory available.
3521 InernalEfiShellStartMonitor(
3525 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3526 EFI_KEY_DATA KeyData
;
3529 Status
= gBS
->OpenProtocol(
3530 gST
->ConsoleInHandle
,
3531 &gEfiSimpleTextInputExProtocolGuid
,
3535 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3536 if (EFI_ERROR(Status
)) {
3541 STRING_TOKEN (STR_SHELL_NO_IN_EX
),
3542 ShellInfoObject
.HiiHandle
);
3543 return (EFI_SUCCESS
);
3546 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3547 return (EFI_UNSUPPORTED
);
3550 KeyData
.KeyState
.KeyToggleState
= 0;
3551 KeyData
.Key
.ScanCode
= 0;
3552 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3553 KeyData
.Key
.UnicodeChar
= L
'c';
3555 Status
= SimpleEx
->RegisterKeyNotify(
3558 NotificationFunction
,
3559 &ShellInfoObject
.CtrlCNotifyHandle1
);
3561 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3562 if (!EFI_ERROR(Status
)) {
3563 Status
= SimpleEx
->RegisterKeyNotify(
3566 NotificationFunction
,
3567 &ShellInfoObject
.CtrlCNotifyHandle2
);
3569 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3570 KeyData
.Key
.UnicodeChar
= 3;
3571 if (!EFI_ERROR(Status
)) {
3572 Status
= SimpleEx
->RegisterKeyNotify(
3575 NotificationFunction
,
3576 &ShellInfoObject
.CtrlCNotifyHandle3
);
3578 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3579 if (!EFI_ERROR(Status
)) {
3580 Status
= SimpleEx
->RegisterKeyNotify(
3583 NotificationFunction
,
3584 &ShellInfoObject
.CtrlCNotifyHandle4
);