2 Member functions of EFI_SHELL_PROTOCOL and functions for creation,
3 manipulation, and initialization of EFI_SHELL_PROTOCOL.
5 (C) Copyright 2014 Hewlett-Packard Development Company, L.P.<BR>
6 Copyright (c) 2009 - 2016, Intel Corporation. All rights reserved.<BR>
7 This program and the accompanying materials
8 are licensed and made available under the terms and conditions of the BSD License
9 which accompanies this distribution. The full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
19 #define INIT_NAME_BUFFER_SIZE 128
22 Close an open file handle.
24 This function closes a specified file handle. All "dirty" cached file data is
25 flushed to the device, and the file is closed. In all cases the handle is
28 @param[in] FileHandle The file handle to close.
30 @retval EFI_SUCCESS The file handle was closed successfully.
35 IN SHELL_FILE_HANDLE FileHandle
38 ShellFileHandleRemove(FileHandle
);
39 return (FileHandleClose(ConvertShellHandleToEfiFileProtocol(FileHandle
)));
43 Internal worker to determine whether there is a BlockIo somewhere
44 upon the device path specified.
46 @param[in] DevicePath The device path to test.
48 @retval TRUE gEfiBlockIoProtocolGuid was installed on a handle with this device path
49 @retval FALSE gEfiBlockIoProtocolGuid was not found.
53 InternalShellProtocolIsBlockIoPresent(
54 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
57 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
63 DevicePathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)DevicePath
;
64 Status
= gBS
->LocateDevicePath(&gEfiBlockIoProtocolGuid
, &DevicePathCopy
, &Handle
);
66 if ((Handle
!= NULL
) && (!EFI_ERROR(Status
))) {
73 Internal worker to determine whether there is a file system somewhere
74 upon the device path specified.
76 @param[in] DevicePath The device path to test.
78 @retval TRUE gEfiSimpleFileSystemProtocolGuid was installed on a handle with this device path
79 @retval FALSE gEfiSimpleFileSystemProtocolGuid was not found.
83 InternalShellProtocolIsSimpleFileSystemPresent(
84 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
87 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
93 DevicePathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)DevicePath
;
94 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &Handle
);
96 if ((Handle
!= NULL
) && (!EFI_ERROR(Status
))) {
103 Internal worker debug helper function to print out maps as they are added.
105 @param[in] Mapping string mapping that has been added
106 @param[in] DevicePath pointer to device path that has been mapped.
108 @retval EFI_SUCCESS the operation was successful.
109 @return other an error ocurred
116 InternalShellProtocolDebugPrintMessage (
117 IN CONST CHAR16
*Mapping
,
118 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
124 Status
= EFI_SUCCESS
;
127 if (Mapping
!= NULL
) {
128 DEBUG((EFI_D_INFO
, "Added new map item:\"%S\"\r\n", Mapping
));
130 Temp
= ConvertDevicePathToText(DevicePath
, TRUE
, TRUE
);
131 DEBUG((EFI_D_INFO
, "DevicePath: %S\r\n", Temp
));
139 This function creates a mapping for a device path.
141 If both DeviecPath and Mapping are NULL, this will reset the mapping to default values.
143 @param DevicePath Points to the device path. If this is NULL and Mapping points to a valid mapping,
144 then the mapping will be deleted.
145 @param Mapping Points to the NULL-terminated mapping for the device path. Must end with a ':'
147 @retval EFI_SUCCESS Mapping created or deleted successfully.
148 @retval EFI_NO_MAPPING There is no handle that corresponds exactly to DevicePath. See the
149 boot service function LocateDevicePath().
150 @retval EFI_ACCESS_DENIED The mapping is a built-in alias.
151 @retval EFI_INVALID_PARAMETER Mapping was NULL
152 @retval EFI_INVALID_PARAMETER Mapping did not end with a ':'
153 @retval EFI_INVALID_PARAMETER DevicePath was not pointing at a device that had a SIMPLE_FILE_SYSTEM_PROTOCOL installed.
154 @retval EFI_NOT_FOUND There was no mapping found to delete
155 @retval EFI_OUT_OF_RESOURCES Memory allocation failed
160 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath OPTIONAL
,
161 IN CONST CHAR16
*Mapping
165 SHELL_MAP_LIST
*MapListNode
;
167 if (Mapping
== NULL
){
168 return (EFI_INVALID_PARAMETER
);
171 if (Mapping
[StrLen(Mapping
)-1] != ':') {
172 return (EFI_INVALID_PARAMETER
);
176 // Delete the mapping
178 if (DevicePath
== NULL
) {
179 if (IsListEmpty(&gShellMapList
.Link
)) {
180 return (EFI_NOT_FOUND
);
182 for ( MapListNode
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
183 ; !IsNull(&gShellMapList
.Link
, &MapListNode
->Link
)
184 ; MapListNode
= (SHELL_MAP_LIST
*)GetNextNode(&gShellMapList
.Link
, &MapListNode
->Link
)
186 if (StringNoCaseCompare(&MapListNode
->MapName
, &Mapping
) == 0) {
187 RemoveEntryList(&MapListNode
->Link
);
188 SHELL_FREE_NON_NULL(MapListNode
->DevicePath
);
189 SHELL_FREE_NON_NULL(MapListNode
->MapName
);
190 SHELL_FREE_NON_NULL(MapListNode
->CurrentDirectoryPath
);
191 FreePool(MapListNode
);
192 return (EFI_SUCCESS
);
197 // We didnt find one to delete
199 return (EFI_NOT_FOUND
);
203 // make sure this is a valid to add device path
205 ///@todo add BlockIo to this test...
206 if (!InternalShellProtocolIsSimpleFileSystemPresent(DevicePath
)
207 && !InternalShellProtocolIsBlockIoPresent(DevicePath
)) {
208 return (EFI_INVALID_PARAMETER
);
212 // First make sure there is no old mapping
214 Status
= EfiShellSetMap(NULL
, Mapping
);
215 if ((Status
!= EFI_SUCCESS
) && (Status
!= EFI_NOT_FOUND
)) {
220 // now add the new one.
222 Status
= ShellCommandAddMapItemAndUpdatePath(Mapping
, DevicePath
, 0, FALSE
);
228 Gets the device path from the mapping.
230 This function gets the device path associated with a mapping.
232 @param Mapping A pointer to the mapping
234 @retval !=NULL Pointer to the device path that corresponds to the
235 device mapping. The returned pointer does not need
237 @retval NULL There is no device path associated with the
240 CONST EFI_DEVICE_PATH_PROTOCOL
*
242 EfiShellGetDevicePathFromMap(
243 IN CONST CHAR16
*Mapping
246 SHELL_MAP_LIST
*MapListItem
;
253 StrnCatGrow(&NewName
, &Size
, Mapping
, 0);
254 if (Mapping
[StrLen(Mapping
)-1] != L
':') {
255 StrnCatGrow(&NewName
, &Size
, L
":", 0);
258 MapListItem
= ShellCommandFindMapItem(NewName
);
262 if (MapListItem
!= NULL
) {
263 return (MapListItem
->DevicePath
);
269 Gets the mapping(s) that most closely matches the device path.
271 This function gets the mapping which corresponds to the device path *DevicePath. If
272 there is no exact match, then the mapping which most closely matches *DevicePath
273 is returned, and *DevicePath is updated to point to the remaining portion of the
274 device path. If there is an exact match, the mapping is returned and *DevicePath
275 points to the end-of-device-path node.
277 If there are multiple map names they will be semi-colon seperated in the
278 NULL-terminated string.
280 @param DevicePath On entry, points to a device path pointer. On
281 exit, updates the pointer to point to the
282 portion of the device path after the mapping.
284 @retval NULL No mapping was found.
285 @return !=NULL Pointer to NULL-terminated mapping. The buffer
286 is callee allocated and should be freed by the caller.
290 EfiShellGetMapFromDevicePath(
291 IN OUT EFI_DEVICE_PATH_PROTOCOL
**DevicePath
294 SHELL_MAP_LIST
*Node
;
295 CHAR16
*PathForReturn
;
297 // EFI_HANDLE PathHandle;
298 // EFI_HANDLE MapHandle;
299 // EFI_STATUS Status;
300 // EFI_DEVICE_PATH_PROTOCOL *DevicePathCopy;
301 // EFI_DEVICE_PATH_PROTOCOL *MapPathCopy;
303 if (DevicePath
== NULL
|| *DevicePath
== NULL
) {
307 PathForReturn
= NULL
;
310 for ( Node
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
311 ; !IsNull(&gShellMapList
.Link
, &Node
->Link
)
312 ; Node
= (SHELL_MAP_LIST
*)GetNextNode(&gShellMapList
.Link
, &Node
->Link
)
315 // check for exact match
317 if (DevicePathCompare(DevicePath
, &Node
->DevicePath
) == 0) {
318 ASSERT((PathForReturn
== NULL
&& PathSize
== 0) || (PathForReturn
!= NULL
));
320 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, L
";", 0);
322 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, Node
->MapName
, 0);
325 if (PathForReturn
!= NULL
) {
326 while (!IsDevicePathEndType (*DevicePath
)) {
327 *DevicePath
= NextDevicePathNode (*DevicePath
);
329 SetDevicePathEndNode (*DevicePath
);
332 ///@todo finish code for inexact matches.
333 if (PathForReturn == NULL) {
336 DevicePathCopy = DuplicateDevicePath(*DevicePath);
337 ASSERT(DevicePathCopy != NULL);
338 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &DevicePathCopy, &PathHandle);
339 ASSERT_EFI_ERROR(Status);
341 // check each of the device paths we have to get the root of the path for consist mappings
343 for ( Node = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
344 ; !IsNull(&gShellMapList.Link, &Node->Link)
345 ; Node = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &Node->Link)
347 if ((Node->Flags & SHELL_MAP_FLAGS_CONSIST) == 0) {
350 MapPathCopy = DuplicateDevicePath(Node->DevicePath);
351 ASSERT(MapPathCopy != NULL);
352 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &MapPathCopy, &MapHandle);
353 if (MapHandle == PathHandle) {
355 *DevicePath = DevicePathCopy;
358 DevicePathCopy = NULL;
359 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, Node->MapName, 0);
360 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, L";", 0);
365 // now add on the non-consistent mappings
367 for ( Node = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
368 ; !IsNull(&gShellMapList.Link, &Node->Link)
369 ; Node = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &Node->Link)
371 if ((Node->Flags & SHELL_MAP_FLAGS_CONSIST) != 0) {
374 MapPathCopy = Node->DevicePath;
375 ASSERT(MapPathCopy != NULL);
376 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &MapPathCopy, &MapHandle);
377 if (MapHandle == PathHandle) {
378 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, Node->MapName, 0);
379 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, L";", 0);
386 return (AddBufferToFreeList(PathForReturn
));
390 Converts a device path to a file system-style path.
392 This function converts a device path to a file system path by replacing part, or all, of
393 the device path with the file-system mapping. If there are more than one application
394 file system mappings, the one that most closely matches Path will be used.
396 @param Path The pointer to the device path
398 @retval NULL the device path could not be found.
399 @return all The pointer of the NULL-terminated file path. The path
400 is callee-allocated and should be freed by the caller.
404 EfiShellGetFilePathFromDevicePath(
405 IN CONST EFI_DEVICE_PATH_PROTOCOL
*Path
408 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
409 EFI_DEVICE_PATH_PROTOCOL
*MapPathCopy
;
410 SHELL_MAP_LIST
*MapListItem
;
411 CHAR16
*PathForReturn
;
413 EFI_HANDLE PathHandle
;
414 EFI_HANDLE MapHandle
;
416 FILEPATH_DEVICE_PATH
*FilePath
;
417 FILEPATH_DEVICE_PATH
*AlignedNode
;
419 PathForReturn
= NULL
;
422 DevicePathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)Path
;
423 ASSERT(DevicePathCopy
!= NULL
);
424 if (DevicePathCopy
== NULL
) {
428 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &PathHandle
);
430 if (EFI_ERROR(Status
)) {
434 // check each of the device paths we have to get the root of the path
436 for ( MapListItem
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
437 ; !IsNull(&gShellMapList
.Link
, &MapListItem
->Link
)
438 ; MapListItem
= (SHELL_MAP_LIST
*)GetNextNode(&gShellMapList
.Link
, &MapListItem
->Link
)
440 MapPathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)MapListItem
->DevicePath
;
441 ASSERT(MapPathCopy
!= NULL
);
443 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &MapPathCopy
, &MapHandle
);
444 if (MapHandle
== PathHandle
) {
445 ASSERT((PathForReturn
== NULL
&& PathSize
== 0) || (PathForReturn
!= NULL
));
446 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, MapListItem
->MapName
, 0);
448 // go through all the remaining nodes in the device path
450 for ( FilePath
= (FILEPATH_DEVICE_PATH
*)DevicePathCopy
451 ; !IsDevicePathEnd (&FilePath
->Header
)
452 ; FilePath
= (FILEPATH_DEVICE_PATH
*)NextDevicePathNode (&FilePath
->Header
)
455 // If any node is not a file path node, then the conversion can not be completed
457 if ((DevicePathType(&FilePath
->Header
) != MEDIA_DEVICE_PATH
) ||
458 (DevicePathSubType(&FilePath
->Header
) != MEDIA_FILEPATH_DP
)) {
459 FreePool(PathForReturn
);
464 // append the path part onto the filepath.
466 ASSERT((PathForReturn
== NULL
&& PathSize
== 0) || (PathForReturn
!= NULL
));
468 AlignedNode
= AllocateCopyPool (DevicePathNodeLength(FilePath
), FilePath
);
469 ASSERT (AlignedNode
!= NULL
);
471 // File Path Device Path Nodes 'can optionally add a "\" separator to
472 // the beginning and/or the end of the Path Name string.'
473 // (UEFI Spec 2.4 section 9.3.6.4).
474 // If necessary, add a "\", but otherwise don't
475 // (This is specified in the above section, and also implied by the
476 // UEFI Shell spec section 3.7)
477 if ((PathSize
!= 0) &&
478 (PathForReturn
!= NULL
) &&
479 (PathForReturn
[PathSize
- 1] != L
'\\') &&
480 (AlignedNode
->PathName
[0] != L
'\\')) {
481 PathForReturn
= StrnCatGrow (&PathForReturn
, &PathSize
, L
"\\", 1);
484 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, AlignedNode
->PathName
, 0);
485 FreePool(AlignedNode
);
486 } // for loop of remaining nodes
488 if (PathForReturn
!= NULL
) {
491 } // for loop of paths to check
492 return(PathForReturn
);
496 Converts a file system style name to a device path.
498 This function converts a file system style name to a device path, by replacing any
499 mapping references to the associated device path.
501 @param[in] Path The pointer to the path.
503 @return The pointer of the file path. The file path is callee
504 allocated and should be freed by the caller.
505 @retval NULL The path could not be found.
506 @retval NULL There was not enough available memory.
508 EFI_DEVICE_PATH_PROTOCOL
*
510 EfiShellGetDevicePathFromFilePath(
511 IN CONST CHAR16
*Path
518 CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
519 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
520 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopyForFree
;
521 EFI_DEVICE_PATH_PROTOCOL
*DevicePathForReturn
;
532 if (StrStr(Path
, L
":") == NULL
) {
533 Cwd
= EfiShellGetCurDir(NULL
);
537 Size
= StrSize(Cwd
) + StrSize(Path
);
538 NewPath
= AllocateZeroPool(Size
);
539 if (NewPath
== NULL
) {
542 StrCpyS(NewPath
, Size
/sizeof(CHAR16
), Cwd
);
543 StrCatS(NewPath
, Size
/sizeof(CHAR16
), L
"\\");
544 if (*Path
== L
'\\') {
546 while (PathRemoveLastItem(NewPath
)) ;
548 StrCatS(NewPath
, Size
/sizeof(CHAR16
), Path
);
549 DevicePathForReturn
= EfiShellGetDevicePathFromFilePath(NewPath
);
551 return (DevicePathForReturn
);
556 // find the part before (but including) the : for the map name
558 ASSERT((MapName
== NULL
&& Size
== 0) || (MapName
!= NULL
));
559 MapName
= StrnCatGrow(&MapName
, &Size
, Path
, (StrStr(Path
, L
":")-Path
+1));
560 if (MapName
== NULL
|| MapName
[StrLen(MapName
)-1] != L
':') {
565 // look up the device path in the map
567 DevicePath
= EfiShellGetDevicePathFromMap(MapName
);
568 if (DevicePath
== NULL
) {
570 // Must have been a bad Mapname
576 // make a copy for LocateDevicePath to modify (also save a pointer to call FreePool with)
578 DevicePathCopyForFree
= DevicePathCopy
= DuplicateDevicePath(DevicePath
);
579 if (DevicePathCopy
== NULL
) {
588 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &Handle
);
589 if (EFI_ERROR(Status
)) {
590 if (DevicePathCopyForFree
!= NULL
) {
591 FreePool(DevicePathCopyForFree
);
598 // build the full device path
600 if (*(Path
+StrLen(MapName
)+1) == CHAR_NULL
) {
601 DevicePathForReturn
= FileDevicePath(Handle
, L
"\\");
603 DevicePathForReturn
= FileDevicePath(Handle
, Path
+StrLen(MapName
));
607 if (DevicePathCopyForFree
!= NULL
) {
608 FreePool(DevicePathCopyForFree
);
611 return (DevicePathForReturn
);
615 Gets the name of the device specified by the device handle.
617 This function gets the user-readable name of the device specified by the device
618 handle. If no user-readable name could be generated, then *BestDeviceName will be
619 NULL and EFI_NOT_FOUND will be returned.
621 If EFI_DEVICE_NAME_USE_COMPONENT_NAME is set, then the function will return the
622 device's name using the EFI_COMPONENT_NAME2_PROTOCOL, if present on
625 If EFI_DEVICE_NAME_USE_DEVICE_PATH is set, then the function will return the
626 device's name using the EFI_DEVICE_PATH_PROTOCOL, if present on DeviceHandle.
627 If both EFI_DEVICE_NAME_USE_COMPONENT_NAME and
628 EFI_DEVICE_NAME_USE_DEVICE_PATH are set, then
629 EFI_DEVICE_NAME_USE_COMPONENT_NAME will have higher priority.
631 @param DeviceHandle The handle of the device.
632 @param Flags Determines the possible sources of component names.
634 EFI_DEVICE_NAME_USE_COMPONENT_NAME
635 EFI_DEVICE_NAME_USE_DEVICE_PATH
636 @param Language A pointer to the language specified for the device
637 name, in the same format as described in the UEFI
638 specification, Appendix M
639 @param BestDeviceName On return, points to the callee-allocated NULL-
640 terminated name of the device. If no device name
641 could be found, points to NULL. The name must be
642 freed by the caller...
644 @retval EFI_SUCCESS Get the name successfully.
645 @retval EFI_NOT_FOUND Fail to get the device name.
646 @retval EFI_INVALID_PARAMETER Flags did not have a valid bit set.
647 @retval EFI_INVALID_PARAMETER BestDeviceName was NULL
648 @retval EFI_INVALID_PARAMETER DeviceHandle was NULL
652 EfiShellGetDeviceName(
653 IN EFI_HANDLE DeviceHandle
,
654 IN EFI_SHELL_DEVICE_NAME_FLAGS Flags
,
656 OUT CHAR16
**BestDeviceName
660 EFI_COMPONENT_NAME2_PROTOCOL
*CompName2
;
661 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
662 EFI_HANDLE
*HandleList
;
665 CHAR16
*DeviceNameToReturn
;
667 UINTN ParentControllerCount
;
668 EFI_HANDLE
*ParentControllerBuffer
;
669 UINTN ParentDriverCount
;
670 EFI_HANDLE
*ParentDriverBuffer
;
672 if (BestDeviceName
== NULL
||
675 return (EFI_INVALID_PARAMETER
);
679 // make sure one of the 2 supported bits is on
681 if (((Flags
& EFI_DEVICE_NAME_USE_COMPONENT_NAME
) == 0) &&
682 ((Flags
& EFI_DEVICE_NAME_USE_DEVICE_PATH
) == 0)) {
683 return (EFI_INVALID_PARAMETER
);
686 DeviceNameToReturn
= NULL
;
687 *BestDeviceName
= NULL
;
692 if ((Flags
& EFI_DEVICE_NAME_USE_COMPONENT_NAME
) != 0) {
693 Status
= ParseHandleDatabaseByRelationship(
696 HR_DRIVER_BINDING_HANDLE
|HR_DEVICE_DRIVER
,
699 for (LoopVar
= 0; LoopVar
< HandleCount
; LoopVar
++){
701 // Go through those handles until we get one that passes for GetComponentName
703 Status
= gBS
->OpenProtocol(
705 &gEfiComponentName2ProtocolGuid
,
709 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
710 if (EFI_ERROR(Status
)) {
711 Status
= gBS
->OpenProtocol(
713 &gEfiComponentNameProtocolGuid
,
717 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
720 if (EFI_ERROR(Status
)) {
723 Lang
= GetBestLanguageForDriver(CompName2
->SupportedLanguages
, Language
, FALSE
);
724 Status
= CompName2
->GetControllerName(CompName2
, DeviceHandle
, NULL
, Lang
, &DeviceNameToReturn
);
727 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
731 if (HandleList
!= NULL
) {
732 FreePool(HandleList
);
736 // Now check the parent controller using this as the child.
738 if (DeviceNameToReturn
== NULL
){
739 PARSE_HANDLE_DATABASE_PARENTS(DeviceHandle
, &ParentControllerCount
, &ParentControllerBuffer
);
740 for (LoopVar
= 0 ; LoopVar
< ParentControllerCount
; LoopVar
++) {
741 PARSE_HANDLE_DATABASE_UEFI_DRIVERS(ParentControllerBuffer
[LoopVar
], &ParentDriverCount
, &ParentDriverBuffer
);
742 for (HandleCount
= 0 ; HandleCount
< ParentDriverCount
; HandleCount
++) {
744 // try using that driver's component name with controller and our driver as the child.
746 Status
= gBS
->OpenProtocol(
747 ParentDriverBuffer
[HandleCount
],
748 &gEfiComponentName2ProtocolGuid
,
752 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
753 if (EFI_ERROR(Status
)) {
754 Status
= gBS
->OpenProtocol(
755 ParentDriverBuffer
[HandleCount
],
756 &gEfiComponentNameProtocolGuid
,
760 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
763 if (EFI_ERROR(Status
)) {
766 Lang
= GetBestLanguageForDriver(CompName2
->SupportedLanguages
, Language
, FALSE
);
767 Status
= CompName2
->GetControllerName(CompName2
, ParentControllerBuffer
[LoopVar
], DeviceHandle
, Lang
, &DeviceNameToReturn
);
770 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
777 SHELL_FREE_NON_NULL(ParentDriverBuffer
);
778 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
782 SHELL_FREE_NON_NULL(ParentControllerBuffer
);
785 // dont return on fail since we will try device path if that bit is on
787 if (DeviceNameToReturn
!= NULL
){
788 ASSERT(BestDeviceName
!= NULL
);
789 StrnCatGrow(BestDeviceName
, NULL
, DeviceNameToReturn
, 0);
790 return (EFI_SUCCESS
);
793 if ((Flags
& EFI_DEVICE_NAME_USE_DEVICE_PATH
) != 0) {
794 Status
= gBS
->OpenProtocol(
796 &gEfiDevicePathProtocolGuid
,
800 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
801 if (!EFI_ERROR(Status
)) {
803 // use device path to text on the device path
805 *BestDeviceName
= ConvertDevicePathToText(DevicePath
, TRUE
, TRUE
);
806 return (EFI_SUCCESS
);
810 // none of the selected bits worked.
812 return (EFI_NOT_FOUND
);
816 Opens the root directory of a device on a handle
818 This function opens the root directory of a device and returns a file handle to it.
820 @param DeviceHandle The handle of the device that contains the volume.
821 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
824 @retval EFI_SUCCESS Root opened successfully.
825 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
827 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
828 @retval EFI_DEVICE_ERROR The device had an error
832 EfiShellOpenRootByHandle(
833 IN EFI_HANDLE DeviceHandle
,
834 OUT SHELL_FILE_HANDLE
*FileHandle
838 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
*SimpleFileSystem
;
839 EFI_FILE_PROTOCOL
*RealFileHandle
;
840 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
843 // get the simple file system interface
845 Status
= gBS
->OpenProtocol(DeviceHandle
,
846 &gEfiSimpleFileSystemProtocolGuid
,
847 (VOID
**)&SimpleFileSystem
,
850 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
851 if (EFI_ERROR(Status
)) {
852 return (EFI_NOT_FOUND
);
855 Status
= gBS
->OpenProtocol(DeviceHandle
,
856 &gEfiDevicePathProtocolGuid
,
860 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
861 if (EFI_ERROR(Status
)) {
862 return (EFI_NOT_FOUND
);
865 // Open the root volume now...
867 Status
= SimpleFileSystem
->OpenVolume(SimpleFileSystem
, &RealFileHandle
);
868 *FileHandle
= ConvertEfiFileProtocolToShellHandle(RealFileHandle
, EfiShellGetMapFromDevicePath(&DevPath
));
873 Opens the root directory of a device.
875 This function opens the root directory of a device and returns a file handle to it.
877 @param DevicePath Points to the device path corresponding to the device where the
878 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL is installed.
879 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
882 @retval EFI_SUCCESS Root opened successfully.
883 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
885 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
886 @retval EFI_DEVICE_ERROR The device had an error
887 @retval EFI_INVALID_PARAMETER FileHandle is NULL.
892 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
893 OUT SHELL_FILE_HANDLE
*FileHandle
899 if (FileHandle
== NULL
) {
900 return (EFI_INVALID_PARAMETER
);
904 // find the handle of the device with that device handle and the file system
907 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
,
910 if (EFI_ERROR(Status
)) {
911 return (EFI_NOT_FOUND
);
914 return (EfiShellOpenRootByHandle(Handle
, FileHandle
));
918 Returns whether any script files are currently being processed.
920 @retval TRUE There is at least one script file active.
921 @retval FALSE No script files are active now.
926 EfiShellBatchIsActive (
930 if (ShellCommandGetCurrentScriptFile() == NULL
) {
937 Worker function to open a file based on a device path. this will open the root
938 of the volume and then traverse down to the file itself.
940 @param DevicePath Device Path of the file.
941 @param FileHandle Pointer to the file upon a successful return.
942 @param OpenMode mode to open file in.
943 @param Attributes the File Attributes to use when creating a new file.
945 @retval EFI_SUCCESS the file is open and FileHandle is valid
946 @retval EFI_UNSUPPORTED the device path cotained non-path elements
947 @retval other an error ocurred.
951 InternalOpenFileDevicePath(
952 IN OUT EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
953 OUT SHELL_FILE_HANDLE
*FileHandle
,
955 IN UINT64 Attributes OPTIONAL
959 FILEPATH_DEVICE_PATH
*FilePathNode
;
961 SHELL_FILE_HANDLE ShellHandle
;
962 EFI_FILE_PROTOCOL
*Handle1
;
963 EFI_FILE_PROTOCOL
*Handle2
;
964 FILEPATH_DEVICE_PATH
*AlignedNode
;
966 if (FileHandle
== NULL
) {
967 return (EFI_INVALID_PARAMETER
);
977 Status
= EfiShellOpenRoot(DevicePath
, &ShellHandle
);
979 if (!EFI_ERROR(Status
)) {
980 Handle1
= ConvertShellHandleToEfiFileProtocol(ShellHandle
);
981 if (Handle1
!= NULL
) {
983 // chop off the begining part before the file system part...
986 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
,
989 if (!EFI_ERROR(Status
)) {
991 // To access as a file system, the file path should only
992 // contain file path components. Follow the file path nodes
993 // and find the target file
995 for ( FilePathNode
= (FILEPATH_DEVICE_PATH
*)DevicePath
996 ; !IsDevicePathEnd (&FilePathNode
->Header
)
997 ; FilePathNode
= (FILEPATH_DEVICE_PATH
*) NextDevicePathNode (&FilePathNode
->Header
)
999 SHELL_FREE_NON_NULL(AlignedNode
);
1000 AlignedNode
= AllocateCopyPool (DevicePathNodeLength(FilePathNode
), FilePathNode
);
1002 // For file system access each node should be a file path component
1004 if (DevicePathType (&FilePathNode
->Header
) != MEDIA_DEVICE_PATH
||
1005 DevicePathSubType (&FilePathNode
->Header
) != MEDIA_FILEPATH_DP
1007 Status
= EFI_UNSUPPORTED
;
1012 // Open this file path node
1018 // if this is the last node in the DevicePath always create (if that was requested).
1020 if (IsDevicePathEnd ((NextDevicePathNode (&FilePathNode
->Header
)))) {
1021 Status
= Handle2
->Open (
1024 AlignedNode
->PathName
,
1031 // This is not the last node and we dont want to 'create' existing
1032 // directory entries...
1036 // open without letting it create
1037 // prevents error on existing files/directories
1039 Status
= Handle2
->Open (
1042 AlignedNode
->PathName
,
1043 OpenMode
&~EFI_FILE_MODE_CREATE
,
1047 // if above failed now open and create the 'item'
1048 // if OpenMode EFI_FILE_MODE_CREATE bit was on (but disabled above)
1050 if ((EFI_ERROR (Status
)) && ((OpenMode
& EFI_FILE_MODE_CREATE
) != 0)) {
1051 Status
= Handle2
->Open (
1054 AlignedNode
->PathName
,
1061 // Close the last node
1063 ShellInfoObject
.NewEfiShellProtocol
->CloseFile (Handle2
);
1066 // If there's been an error, stop
1068 if (EFI_ERROR (Status
)) {
1075 SHELL_FREE_NON_NULL(AlignedNode
);
1076 if (EFI_ERROR(Status
)) {
1077 if (Handle1
!= NULL
) {
1078 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(Handle1
);
1081 *FileHandle
= ConvertEfiFileProtocolToShellHandle(Handle1
, ShellFileHandleGetPath(ShellHandle
));
1087 Creates a file or directory by name.
1089 This function creates an empty new file or directory with the specified attributes and
1090 returns the new file's handle. If the file already exists and is read-only, then
1091 EFI_INVALID_PARAMETER will be returned.
1093 If the file already existed, it is truncated and its attributes updated. If the file is
1094 created successfully, the FileHandle is the file's handle, else, the FileHandle is NULL.
1096 If the file name begins with >v, then the file handle which is returned refers to the
1097 shell environment variable with the specified name. If the shell environment variable
1098 already exists and is non-volatile then EFI_INVALID_PARAMETER is returned.
1100 @param FileName Pointer to NULL-terminated file path
1101 @param FileAttribs The new file's attrbiutes. the different attributes are
1102 described in EFI_FILE_PROTOCOL.Open().
1103 @param FileHandle On return, points to the created file handle or directory's handle
1105 @retval EFI_SUCCESS The file was opened. FileHandle points to the new file's handle.
1106 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1107 @retval EFI_UNSUPPORTED could not open the file path
1108 @retval EFI_NOT_FOUND the specified file could not be found on the devide, or could not
1109 file the file system on the device.
1110 @retval EFI_NO_MEDIA the device has no medium.
1111 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1113 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1115 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1116 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1117 when the media is write-protected.
1118 @retval EFI_ACCESS_DENIED The service denied access to the file.
1119 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file.
1120 @retval EFI_VOLUME_FULL The volume is full.
1125 IN CONST CHAR16
*FileName
,
1126 IN UINT64 FileAttribs
,
1127 OUT SHELL_FILE_HANDLE
*FileHandle
1130 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1135 // Is this for an environment variable
1136 // do we start with >v
1138 if (StrStr(FileName
, L
">v") == FileName
) {
1139 Status
= IsVolatileEnv (FileName
+ 2, &Volatile
);
1140 if (EFI_ERROR (Status
)) {
1144 return (EFI_INVALID_PARAMETER
);
1146 *FileHandle
= CreateFileInterfaceEnv(FileName
+2);
1147 return (EFI_SUCCESS
);
1151 // We are opening a regular file.
1153 DevicePath
= EfiShellGetDevicePathFromFilePath(FileName
);
1154 if (DevicePath
== NULL
) {
1155 return (EFI_NOT_FOUND
);
1158 Status
= InternalOpenFileDevicePath(DevicePath
, FileHandle
, EFI_FILE_MODE_READ
|EFI_FILE_MODE_WRITE
|EFI_FILE_MODE_CREATE
, FileAttribs
);
1159 FreePool(DevicePath
);
1165 Register a GUID and a localized human readable name for it.
1167 If Guid is not assigned a name, then assign GuidName to Guid. This list of GUID
1168 names must be used whenever a shell command outputs GUID information.
1170 This function is only available when the major and minor versions in the
1171 EfiShellProtocol are greater than or equal to 2 and 1, respectively.
1173 @param[in] Guid A pointer to the GUID being registered.
1174 @param[in] GuidName A pointer to the localized name for the GUID being registered.
1176 @retval EFI_SUCCESS The operation was successful.
1177 @retval EFI_INVALID_PARAMETER Guid was NULL.
1178 @retval EFI_INVALID_PARAMETER GuidName was NULL.
1179 @retval EFI_ACCESS_DENIED Guid already is assigned a name.
1183 EfiShellRegisterGuidName(
1184 IN CONST EFI_GUID
*Guid
,
1185 IN CONST CHAR16
*GuidName
1188 return (AddNewGuidNameMapping(Guid
, GuidName
, NULL
));
1192 Opens a file or a directory by file name.
1194 This function opens the specified file in the specified OpenMode and returns a file
1196 If the file name begins with >v, then the file handle which is returned refers to the
1197 shell environment variable with the specified name. If the shell environment variable
1198 exists, is non-volatile and the OpenMode indicates EFI_FILE_MODE_WRITE, then
1199 EFI_INVALID_PARAMETER is returned.
1201 If the file name is >i, then the file handle which is returned refers to the standard
1202 input. If the OpenMode indicates EFI_FILE_MODE_WRITE, then EFI_INVALID_PARAMETER
1205 If the file name is >o, then the file handle which is returned refers to the standard
1206 output. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1209 If the file name is >e, then the file handle which is returned refers to the standard
1210 error. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1213 If the file name is NUL, then the file handle that is returned refers to the standard NUL
1214 file. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER is
1217 If return EFI_SUCCESS, the FileHandle is the opened file's handle, else, the
1220 @param FileName Points to the NULL-terminated UCS-2 encoded file name.
1221 @param FileHandle On return, points to the file handle.
1222 @param OpenMode File open mode. Either EFI_FILE_MODE_READ or
1223 EFI_FILE_MODE_WRITE from section 12.4 of the UEFI
1225 @retval EFI_SUCCESS The file was opened. FileHandle has the opened file's handle.
1226 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value. FileHandle is NULL.
1227 @retval EFI_UNSUPPORTED Could not open the file path. FileHandle is NULL.
1228 @retval EFI_NOT_FOUND The specified file could not be found on the device or the file
1229 system could not be found on the device. FileHandle is NULL.
1230 @retval EFI_NO_MEDIA The device has no medium. FileHandle is NULL.
1231 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1232 longer supported. FileHandle is NULL.
1233 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1234 the FileName. FileHandle is NULL.
1235 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted. FileHandle is NULL.
1236 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1237 when the media is write-protected. FileHandle is NULL.
1238 @retval EFI_ACCESS_DENIED The service denied access to the file. FileHandle is NULL.
1239 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file. FileHandle
1241 @retval EFI_VOLUME_FULL The volume is full. FileHandle is NULL.
1245 EfiShellOpenFileByName(
1246 IN CONST CHAR16
*FileName
,
1247 OUT SHELL_FILE_HANDLE
*FileHandle
,
1251 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1258 // Is this for StdIn
1260 if (StrCmp(FileName
, L
">i") == 0) {
1262 // make sure not writing to StdIn
1264 if ((OpenMode
& EFI_FILE_MODE_WRITE
) != 0) {
1265 return (EFI_INVALID_PARAMETER
);
1267 *FileHandle
= ShellInfoObject
.NewShellParametersProtocol
->StdIn
;
1268 ASSERT(*FileHandle
!= NULL
);
1269 return (EFI_SUCCESS
);
1273 // Is this for StdOut
1275 if (StrCmp(FileName
, L
">o") == 0) {
1277 // make sure not writing to StdIn
1279 if ((OpenMode
& EFI_FILE_MODE_READ
) != 0) {
1280 return (EFI_INVALID_PARAMETER
);
1282 *FileHandle
= &FileInterfaceStdOut
;
1283 return (EFI_SUCCESS
);
1287 // Is this for NUL file
1289 if (StrCmp(FileName
, L
"NUL") == 0) {
1290 *FileHandle
= &FileInterfaceNulFile
;
1291 return (EFI_SUCCESS
);
1295 // Is this for StdErr
1297 if (StrCmp(FileName
, L
">e") == 0) {
1299 // make sure not writing to StdIn
1301 if ((OpenMode
& EFI_FILE_MODE_READ
) != 0) {
1302 return (EFI_INVALID_PARAMETER
);
1304 *FileHandle
= &FileInterfaceStdErr
;
1305 return (EFI_SUCCESS
);
1309 // Is this for an environment variable
1310 // do we start with >v
1312 if (StrStr(FileName
, L
">v") == FileName
) {
1313 Status
= IsVolatileEnv (FileName
+ 2, &Volatile
);
1314 if (EFI_ERROR (Status
)) {
1318 ((OpenMode
& EFI_FILE_MODE_WRITE
) != 0)) {
1319 return (EFI_INVALID_PARAMETER
);
1321 *FileHandle
= CreateFileInterfaceEnv(FileName
+2);
1322 return (EFI_SUCCESS
);
1326 // We are opening a regular file.
1328 DevicePath
= EfiShellGetDevicePathFromFilePath(FileName
);
1329 // DEBUG_CODE(InternalShellProtocolDebugPrintMessage (NULL, DevicePath););
1330 if (DevicePath
== NULL
) {
1331 return (EFI_NOT_FOUND
);
1335 // Copy the device path, open the file, then free the memory
1337 Status
= InternalOpenFileDevicePath(DevicePath
, FileHandle
, OpenMode
, 0); // 0 = no specific file attributes
1338 FreePool(DevicePath
);
1344 Deletes the file specified by the file name.
1346 This function deletes a file.
1348 @param FileName Points to the NULL-terminated file name.
1350 @retval EFI_SUCCESS The file was closed and deleted, and the handle was closed.
1351 @retval EFI_WARN_DELETE_FAILURE The handle was closed but the file was not deleted.
1352 @sa EfiShellCreateFile
1356 EfiShellDeleteFileByName(
1357 IN CONST CHAR16
*FileName
1360 SHELL_FILE_HANDLE FileHandle
;
1366 // get a handle to the file
1368 Status
= EfiShellCreateFile(FileName
,
1371 if (EFI_ERROR(Status
)) {
1375 // now delete the file
1377 ShellFileHandleRemove(FileHandle
);
1378 return (ShellInfoObject
.NewEfiShellProtocol
->DeleteFile(FileHandle
));
1382 Disables the page break output mode.
1386 EfiShellDisablePageBreak (
1390 ShellInfoObject
.PageBreakEnabled
= FALSE
;
1394 Enables the page break output mode.
1398 EfiShellEnablePageBreak (
1402 ShellInfoObject
.PageBreakEnabled
= TRUE
;
1406 internal worker function to load and run an image via device path.
1408 @param ParentImageHandle A handle of the image that is executing the specified
1410 @param DevicePath device path of the file to execute
1411 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1412 containing the command line. If NULL then the command-
1414 @param Environment Points to a NULL-terminated array of environment
1415 variables with the format 'x=y', where x is the
1416 environment variable name and y is the value. If this
1417 is NULL, then the current shell environment is used.
1419 @param[out] StartImageStatus Returned status from gBS->StartImage.
1421 @retval EFI_SUCCESS The command executed successfully. The status code
1422 returned by the command is pointed to by StatusCode.
1423 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1424 @retval EFI_OUT_OF_RESOURCES Out of resources.
1425 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1429 InternalShellExecuteDevicePath(
1430 IN CONST EFI_HANDLE
*ParentImageHandle
,
1431 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
1432 IN CONST CHAR16
*CommandLine OPTIONAL
,
1433 IN CONST CHAR16
**Environment OPTIONAL
,
1434 OUT EFI_STATUS
*StartImageStatus OPTIONAL
1438 EFI_STATUS StartStatus
;
1439 EFI_STATUS CleanupStatus
;
1440 EFI_HANDLE NewHandle
;
1441 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
1442 LIST_ENTRY OrigEnvs
;
1443 EFI_SHELL_PARAMETERS_PROTOCOL ShellParamsProtocol
;
1449 if (ParentImageHandle
== NULL
) {
1450 return (EFI_INVALID_PARAMETER
);
1453 InitializeListHead(&OrigEnvs
);
1454 ZeroMem(&ShellParamsProtocol
, sizeof(EFI_SHELL_PARAMETERS_PROTOCOL
));
1458 NewCmdLine
= AllocateCopyPool (StrSize (CommandLine
), CommandLine
);
1459 if (NewCmdLine
== NULL
) {
1460 return EFI_OUT_OF_RESOURCES
;
1463 for (Walker
= NewCmdLine
; Walker
!= NULL
&& *Walker
!= CHAR_NULL
; Walker
++) {
1464 if (*Walker
== L
'^' && *(Walker
+1) == L
'#') {
1465 CopyMem(Walker
, Walker
+1, StrSize(Walker
) - sizeof(Walker
[0]));
1470 // Load the image with:
1471 // FALSE - not from boot manager and NULL, 0 being not already in memory
1473 Status
= gBS
->LoadImage(
1476 (EFI_DEVICE_PATH_PROTOCOL
*)DevicePath
,
1481 if (EFI_ERROR(Status
)) {
1482 if (NewHandle
!= NULL
) {
1483 gBS
->UnloadImage(NewHandle
);
1485 FreePool (NewCmdLine
);
1488 Status
= gBS
->OpenProtocol(
1490 &gEfiLoadedImageProtocolGuid
,
1491 (VOID
**)&LoadedImage
,
1494 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
1496 if (!EFI_ERROR(Status
)) {
1498 // If the image is not an app abort it.
1500 if (LoadedImage
->ImageCodeType
!= EfiLoaderCode
){
1505 STRING_TOKEN (STR_SHELL_IMAGE_NOT_APP
),
1506 ShellInfoObject
.HiiHandle
1511 ASSERT(LoadedImage
->LoadOptionsSize
== 0);
1512 if (NewCmdLine
!= NULL
) {
1513 LoadedImage
->LoadOptionsSize
= (UINT32
)StrSize(NewCmdLine
);
1514 LoadedImage
->LoadOptions
= (VOID
*)NewCmdLine
;
1518 // Save our current environment settings for later restoration if necessary
1520 if (Environment
!= NULL
) {
1521 Status
= GetEnvironmentVariableList(&OrigEnvs
);
1522 if (!EFI_ERROR(Status
)) {
1523 Status
= SetEnvironmentVariables(Environment
);
1528 // Initialize and install a shell parameters protocol on the image.
1530 ShellParamsProtocol
.StdIn
= ShellInfoObject
.NewShellParametersProtocol
->StdIn
;
1531 ShellParamsProtocol
.StdOut
= ShellInfoObject
.NewShellParametersProtocol
->StdOut
;
1532 ShellParamsProtocol
.StdErr
= ShellInfoObject
.NewShellParametersProtocol
->StdErr
;
1533 Status
= UpdateArgcArgv(&ShellParamsProtocol
, NewCmdLine
, Efi_Application
, NULL
, NULL
);
1534 ASSERT_EFI_ERROR(Status
);
1536 // Replace Argv[0] with the full path of the binary we're executing:
1537 // If the command line was "foo", the binary might be called "foo.efi".
1538 // "The first entry in [Argv] is always the full file path of the
1539 // executable" - UEFI Shell Spec section 2.3
1541 ImagePath
= EfiShellGetFilePathFromDevicePath (DevicePath
);
1542 // The image we're executing isn't necessarily in a filesystem - it might
1543 // be memory mapped. In this case EfiShellGetFilePathFromDevicePath will
1544 // return NULL, and we'll leave Argv[0] as UpdateArgcArgv set it.
1545 if (ImagePath
!= NULL
) {
1546 if (ShellParamsProtocol
.Argv
== NULL
) {
1547 // Command line was empty or null.
1548 // (UpdateArgcArgv sets Argv to NULL when CommandLine is "" or NULL)
1549 ShellParamsProtocol
.Argv
= AllocatePool (sizeof (CHAR16
*));
1550 if (ShellParamsProtocol
.Argv
== NULL
) {
1551 Status
= EFI_OUT_OF_RESOURCES
;
1554 ShellParamsProtocol
.Argc
= 1;
1556 // Free the string UpdateArgcArgv put in Argv[0];
1557 FreePool (ShellParamsProtocol
.Argv
[0]);
1559 ShellParamsProtocol
.Argv
[0] = ImagePath
;
1562 Status
= gBS
->InstallProtocolInterface(&NewHandle
, &gEfiShellParametersProtocolGuid
, EFI_NATIVE_INTERFACE
, &ShellParamsProtocol
);
1563 ASSERT_EFI_ERROR(Status
);
1565 ///@todo initialize and install ShellInterface protocol on the new image for compatibility if - PcdGetBool(PcdShellSupportOldProtocols)
1568 // now start the image and if the caller wanted the return code pass it to them...
1570 if (!EFI_ERROR(Status
)) {
1571 StartStatus
= gBS
->StartImage(
1576 if (StartImageStatus
!= NULL
) {
1577 *StartImageStatus
= StartStatus
;
1580 CleanupStatus
= gBS
->UninstallProtocolInterface(
1582 &gEfiShellParametersProtocolGuid
,
1583 &ShellParamsProtocol
1585 ASSERT_EFI_ERROR(CleanupStatus
);
1591 // Unload image - We should only get here if we didn't call StartImage
1592 gBS
->UnloadImage (NewHandle
);
1595 // Free Argv (Allocated in UpdateArgcArgv)
1596 if (ShellParamsProtocol
.Argv
!= NULL
) {
1597 for (Index
= 0; Index
< ShellParamsProtocol
.Argc
; Index
++) {
1598 if (ShellParamsProtocol
.Argv
[Index
] != NULL
) {
1599 FreePool (ShellParamsProtocol
.Argv
[Index
]);
1602 FreePool (ShellParamsProtocol
.Argv
);
1606 // Restore environment variables
1607 if (!IsListEmpty(&OrigEnvs
)) {
1608 CleanupStatus
= SetEnvironmentVariableList(&OrigEnvs
);
1609 ASSERT_EFI_ERROR (CleanupStatus
);
1612 FreePool (NewCmdLine
);
1618 internal worker function to load and run an image in the current shell.
1620 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1621 containing the command line. If NULL then the command-
1623 @param Environment Points to a NULL-terminated array of environment
1624 variables with the format 'x=y', where x is the
1625 environment variable name and y is the value. If this
1626 is NULL, then the current shell environment is used.
1628 @param[out] StartImageStatus Returned status from the command line.
1630 @retval EFI_SUCCESS The command executed successfully. The status code
1631 returned by the command is pointed to by StatusCode.
1632 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1633 @retval EFI_OUT_OF_RESOURCES Out of resources.
1634 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1638 InternalShellExecute(
1639 IN CONST CHAR16
*CommandLine OPTIONAL
,
1640 IN CONST CHAR16
**Environment OPTIONAL
,
1641 OUT EFI_STATUS
*StartImageStatus OPTIONAL
1645 EFI_STATUS CleanupStatus
;
1646 LIST_ENTRY OrigEnvs
;
1648 InitializeListHead(&OrigEnvs
);
1651 // Save our current environment settings for later restoration if necessary
1653 if (Environment
!= NULL
) {
1654 Status
= GetEnvironmentVariableList(&OrigEnvs
);
1655 if (!EFI_ERROR(Status
)) {
1656 Status
= SetEnvironmentVariables(Environment
);
1662 Status
= RunShellCommand(CommandLine
, StartImageStatus
);
1664 // Restore environment variables
1665 if (!IsListEmpty(&OrigEnvs
)) {
1666 CleanupStatus
= SetEnvironmentVariableList(&OrigEnvs
);
1667 ASSERT_EFI_ERROR (CleanupStatus
);
1674 Determine if the UEFI Shell is currently running with nesting enabled or disabled.
1676 @retval FALSE nesting is required
1677 @retval other nesting is enabled
1695 if (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoNest
) {
1698 Status
= SHELL_GET_ENVIRONMENT_VARIABLE(mNoNestingEnvVarName
, &TempSize
, Temp
);
1699 if (Status
== EFI_BUFFER_TOO_SMALL
) {
1700 Temp
= AllocateZeroPool(TempSize
+ sizeof(CHAR16
));
1702 Status
= SHELL_GET_ENVIRONMENT_VARIABLE(mNoNestingEnvVarName
, &TempSize
, Temp
);
1705 Temp2
= StrnCatGrow(&Temp2
, NULL
, mNoNestingTrue
, 0);
1706 if (Temp
!= NULL
&& Temp2
!= NULL
&& StringNoCaseCompare(&Temp
, &Temp2
) == 0) {
1708 // Use the no nesting method.
1714 SHELL_FREE_NON_NULL(Temp
);
1715 SHELL_FREE_NON_NULL(Temp2
);
1720 Execute the command line.
1722 This function creates a nested instance of the shell and executes the specified
1723 command (CommandLine) with the specified environment (Environment). Upon return,
1724 the status code returned by the specified command is placed in StatusCode.
1726 If Environment is NULL, then the current environment is used and all changes made
1727 by the commands executed will be reflected in the current environment. If the
1728 Environment is non-NULL, then the changes made will be discarded.
1730 The CommandLine is executed from the current working directory on the current
1733 @param ParentImageHandle A handle of the image that is executing the specified
1735 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1736 containing the command line. If NULL then the command-
1738 @param Environment Points to a NULL-terminated array of environment
1739 variables with the format 'x=y', where x is the
1740 environment variable name and y is the value. If this
1741 is NULL, then the current shell environment is used.
1742 @param StatusCode Points to the status code returned by the CommandLine.
1744 @retval EFI_SUCCESS The command executed successfully. The status code
1745 returned by the command is pointed to by StatusCode.
1746 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1747 @retval EFI_OUT_OF_RESOURCES Out of resources.
1748 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1749 @retval EFI_UNSUPPORTED The support level required for this function is not present.
1751 @sa InternalShellExecuteDevicePath
1756 IN EFI_HANDLE
*ParentImageHandle
,
1757 IN CHAR16
*CommandLine OPTIONAL
,
1758 IN CHAR16
**Environment OPTIONAL
,
1759 OUT EFI_STATUS
*StatusCode OPTIONAL
1764 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
1767 if ((PcdGet8(PcdShellSupportLevel
) < 1)) {
1768 return (EFI_UNSUPPORTED
);
1771 if (NestingEnabled()) {
1772 DevPath
= AppendDevicePath (ShellInfoObject
.ImageDevPath
, ShellInfoObject
.FileDevPath
);
1775 Temp
= ConvertDevicePathToText(ShellInfoObject
.FileDevPath
, TRUE
, TRUE
);
1777 Temp
= ConvertDevicePathToText(ShellInfoObject
.ImageDevPath
, TRUE
, TRUE
);
1779 Temp
= ConvertDevicePathToText(DevPath
, TRUE
, TRUE
);
1785 ASSERT((Temp
== NULL
&& Size
== 0) || (Temp
!= NULL
));
1786 StrnCatGrow(&Temp
, &Size
, L
"Shell.efi -_exit ", 0);
1787 StrnCatGrow(&Temp
, &Size
, CommandLine
, 0);
1789 Status
= InternalShellExecuteDevicePath(
1793 (CONST CHAR16
**)Environment
,
1797 // de-allocate and return
1802 Status
= InternalShellExecute(
1803 (CONST CHAR16
*)CommandLine
,
1804 (CONST CHAR16
**)Environment
,
1812 Utility cleanup function for EFI_SHELL_FILE_INFO objects.
1814 1) frees all pointers (non-NULL)
1815 2) Closes the SHELL_FILE_HANDLE
1817 @param FileListNode pointer to the list node to free
1821 InternalFreeShellFileInfoNode(
1822 IN EFI_SHELL_FILE_INFO
*FileListNode
1825 if (FileListNode
->Info
!= NULL
) {
1826 FreePool((VOID
*)FileListNode
->Info
);
1828 if (FileListNode
->FileName
!= NULL
) {
1829 FreePool((VOID
*)FileListNode
->FileName
);
1831 if (FileListNode
->FullName
!= NULL
) {
1832 FreePool((VOID
*)FileListNode
->FullName
);
1834 if (FileListNode
->Handle
!= NULL
) {
1835 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(FileListNode
->Handle
);
1837 FreePool(FileListNode
);
1840 Frees the file list.
1842 This function cleans up the file list and any related data structures. It has no
1843 impact on the files themselves.
1845 @param FileList The file list to free. Type EFI_SHELL_FILE_INFO is
1846 defined in OpenFileList()
1848 @retval EFI_SUCCESS Free the file list successfully.
1849 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1853 EfiShellFreeFileList(
1854 IN EFI_SHELL_FILE_INFO
**FileList
1857 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1859 if (FileList
== NULL
|| *FileList
== NULL
) {
1860 return (EFI_INVALID_PARAMETER
);
1863 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1864 ; !IsListEmpty(&(*FileList
)->Link
)
1865 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1867 RemoveEntryList(&ShellFileListItem
->Link
);
1868 InternalFreeShellFileInfoNode(ShellFileListItem
);
1870 InternalFreeShellFileInfoNode(*FileList
);
1872 return(EFI_SUCCESS
);
1876 Deletes the duplicate file names files in the given file list.
1878 This function deletes the reduplicate files in the given file list.
1880 @param FileList A pointer to the first entry in the file list.
1882 @retval EFI_SUCCESS Always success.
1883 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1887 EfiShellRemoveDupInFileList(
1888 IN EFI_SHELL_FILE_INFO
**FileList
1891 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1892 EFI_SHELL_FILE_INFO
*ShellFileListItem2
;
1893 EFI_SHELL_FILE_INFO
*TempNode
;
1895 if (FileList
== NULL
|| *FileList
== NULL
) {
1896 return (EFI_INVALID_PARAMETER
);
1898 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1899 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1900 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1902 for ( ShellFileListItem2
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1903 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem2
->Link
)
1904 ; ShellFileListItem2
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem2
->Link
)
1906 if (gUnicodeCollation
->StriColl(
1908 (CHAR16
*)ShellFileListItem
->FullName
,
1909 (CHAR16
*)ShellFileListItem2
->FullName
) == 0
1911 TempNode
= (EFI_SHELL_FILE_INFO
*)GetPreviousNode(
1913 &ShellFileListItem2
->Link
1915 RemoveEntryList(&ShellFileListItem2
->Link
);
1916 InternalFreeShellFileInfoNode(ShellFileListItem2
);
1917 // Set ShellFileListItem2 to PreviousNode so we don't access Freed
1918 // memory in GetNextNode in the loop expression above.
1919 ShellFileListItem2
= TempNode
;
1923 return (EFI_SUCCESS
);
1927 // This is the same structure as the external version, but it has no CONST qualifiers.
1930 LIST_ENTRY Link
; ///< Linked list members.
1931 EFI_STATUS Status
; ///< Status of opening the file. Valid only if Handle != NULL.
1932 CHAR16
*FullName
; ///< Fully qualified filename.
1933 CHAR16
*FileName
; ///< name of this file.
1934 SHELL_FILE_HANDLE Handle
; ///< Handle for interacting with the opened file or NULL if closed.
1935 EFI_FILE_INFO
*Info
; ///< Pointer to the FileInfo struct for this file or NULL.
1936 } EFI_SHELL_FILE_INFO_NO_CONST
;
1939 Allocates and duplicates a EFI_SHELL_FILE_INFO node.
1941 @param[in] Node The node to copy from.
1942 @param[in] Save TRUE to set Node->Handle to NULL, FALSE otherwise.
1944 @retval NULL a memory allocation error ocurred
1945 @return != NULL a pointer to the new node
1947 EFI_SHELL_FILE_INFO
*
1949 InternalDuplicateShellFileInfo(
1950 IN EFI_SHELL_FILE_INFO
*Node
,
1954 EFI_SHELL_FILE_INFO_NO_CONST
*NewNode
;
1957 // try to confirm that the objects are in sync
1959 ASSERT(sizeof(EFI_SHELL_FILE_INFO_NO_CONST
) == sizeof(EFI_SHELL_FILE_INFO
));
1961 NewNode
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1962 if (NewNode
== NULL
) {
1965 NewNode
->FullName
= AllocateCopyPool(StrSize(Node
->FullName
), Node
->FullName
);
1966 NewNode
->FileName
= AllocateCopyPool(StrSize(Node
->FileName
), Node
->FileName
);
1967 NewNode
->Info
= AllocateCopyPool((UINTN
)Node
->Info
->Size
, Node
->Info
);
1968 if ( NewNode
->FullName
== NULL
1969 || NewNode
->FileName
== NULL
1970 || NewNode
->Info
== NULL
1972 SHELL_FREE_NON_NULL(NewNode
->FullName
);
1973 SHELL_FREE_NON_NULL(NewNode
->FileName
);
1974 SHELL_FREE_NON_NULL(NewNode
->Info
);
1975 SHELL_FREE_NON_NULL(NewNode
);
1978 NewNode
->Status
= Node
->Status
;
1979 NewNode
->Handle
= Node
->Handle
;
1981 Node
->Handle
= NULL
;
1984 return((EFI_SHELL_FILE_INFO
*)NewNode
);
1988 Allocates and populates a EFI_SHELL_FILE_INFO structure. if any memory operation
1989 failed it will return NULL.
1991 @param[in] BasePath the Path to prepend onto filename for FullPath
1992 @param[in] Status Status member initial value.
1993 @param[in] FileName FileName member initial value.
1994 @param[in] Handle Handle member initial value.
1995 @param[in] Info Info struct to copy.
1997 @retval NULL An error ocurred.
1998 @return a pointer to the newly allocated structure.
2000 EFI_SHELL_FILE_INFO
*
2002 CreateAndPopulateShellFileInfo(
2003 IN CONST CHAR16
*BasePath
,
2004 IN CONST EFI_STATUS Status
,
2005 IN CONST CHAR16
*FileName
,
2006 IN CONST SHELL_FILE_HANDLE Handle
,
2007 IN CONST EFI_FILE_INFO
*Info
2010 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
2017 ShellFileListItem
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2018 if (ShellFileListItem
== NULL
) {
2021 if (Info
!= NULL
&& Info
->Size
!= 0) {
2022 ShellFileListItem
->Info
= AllocateZeroPool((UINTN
)Info
->Size
);
2023 if (ShellFileListItem
->Info
== NULL
) {
2024 FreePool(ShellFileListItem
);
2027 CopyMem(ShellFileListItem
->Info
, Info
, (UINTN
)Info
->Size
);
2029 ShellFileListItem
->Info
= NULL
;
2031 if (FileName
!= NULL
) {
2032 ASSERT(TempString
== NULL
);
2033 ShellFileListItem
->FileName
= StrnCatGrow(&TempString
, 0, FileName
, 0);
2034 if (ShellFileListItem
->FileName
== NULL
) {
2035 FreePool(ShellFileListItem
->Info
);
2036 FreePool(ShellFileListItem
);
2040 ShellFileListItem
->FileName
= NULL
;
2044 if (BasePath
!= NULL
) {
2045 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
2046 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
2047 if (TempString
== NULL
) {
2048 FreePool((VOID
*)ShellFileListItem
->FileName
);
2049 SHELL_FREE_NON_NULL(ShellFileListItem
->Info
);
2050 FreePool(ShellFileListItem
);
2054 if (ShellFileListItem
->FileName
!= NULL
) {
2055 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
2056 TempString
= StrnCatGrow(&TempString
, &Size
, ShellFileListItem
->FileName
, 0);
2057 if (TempString
== NULL
) {
2058 FreePool((VOID
*)ShellFileListItem
->FileName
);
2059 FreePool(ShellFileListItem
->Info
);
2060 FreePool(ShellFileListItem
);
2065 TempString
= PathCleanUpDirectories(TempString
);
2067 ShellFileListItem
->FullName
= TempString
;
2068 ShellFileListItem
->Status
= Status
;
2069 ShellFileListItem
->Handle
= Handle
;
2071 return (ShellFileListItem
);
2075 Find all files in a specified directory.
2077 @param FileDirHandle Handle of the directory to search.
2078 @param FileList On return, points to the list of files in the directory
2079 or NULL if there are no files in the directory.
2081 @retval EFI_SUCCESS File information was returned successfully.
2082 @retval EFI_VOLUME_CORRUPTED The file system structures have been corrupted.
2083 @retval EFI_DEVICE_ERROR The device reported an error.
2084 @retval EFI_NO_MEDIA The device media is not present.
2085 @retval EFI_INVALID_PARAMETER The FileDirHandle was not a directory.
2086 @return An error from FileHandleGetFileName().
2090 EfiShellFindFilesInDir(
2091 IN SHELL_FILE_HANDLE FileDirHandle
,
2092 OUT EFI_SHELL_FILE_INFO
**FileList
2095 EFI_SHELL_FILE_INFO
*ShellFileList
;
2096 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
2097 EFI_FILE_INFO
*FileInfo
;
2106 Status
= FileHandleGetFileName(FileDirHandle
, &BasePath
);
2107 if (EFI_ERROR(Status
)) {
2111 if (ShellFileHandleGetPath(FileDirHandle
) != NULL
) {
2114 TempString
= StrnCatGrow(&TempString
, &Size
, ShellFileHandleGetPath(FileDirHandle
), 0);
2115 if (TempString
== NULL
) {
2116 SHELL_FREE_NON_NULL(BasePath
);
2117 return (EFI_OUT_OF_RESOURCES
);
2119 TempSpot
= StrStr(TempString
, L
";");
2121 if (TempSpot
!= NULL
) {
2122 *TempSpot
= CHAR_NULL
;
2125 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
2126 if (TempString
== NULL
) {
2127 SHELL_FREE_NON_NULL(BasePath
);
2128 return (EFI_OUT_OF_RESOURCES
);
2130 SHELL_FREE_NON_NULL(BasePath
);
2131 BasePath
= TempString
;
2135 ShellFileList
= NULL
;
2136 ShellFileListItem
= NULL
;
2138 Status
= EFI_SUCCESS
;
2141 for ( Status
= FileHandleFindFirstFile(FileDirHandle
, &FileInfo
)
2142 ; !EFI_ERROR(Status
) && !NoFile
2143 ; Status
= FileHandleFindNextFile(FileDirHandle
, FileInfo
, &NoFile
)
2146 // allocate a new EFI_SHELL_FILE_INFO and populate it...
2148 ShellFileListItem
= CreateAndPopulateShellFileInfo(
2150 EFI_SUCCESS
, // success since we didnt fail to open it...
2152 NULL
, // no handle since not open
2155 if (ShellFileList
== NULL
) {
2156 ShellFileList
= (EFI_SHELL_FILE_INFO
*)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2157 ASSERT(ShellFileList
!= NULL
);
2158 InitializeListHead(&ShellFileList
->Link
);
2160 InsertTailList(&ShellFileList
->Link
, &ShellFileListItem
->Link
);
2162 if (EFI_ERROR(Status
)) {
2163 EfiShellFreeFileList(&ShellFileList
);
2166 *FileList
= ShellFileList
;
2168 SHELL_FREE_NON_NULL(BasePath
);
2173 Get the GUID value from a human readable name.
2175 If GuidName is a known GUID name, then update Guid to have the correct value for
2178 This function is only available when the major and minor versions in the
2179 EfiShellProtocol are greater than or equal to 2 and 1, respectively.
2181 @param[in] GuidName A pointer to the localized name for the GUID being queried.
2182 @param[out] Guid A pointer to the GUID structure to be filled in.
2184 @retval EFI_SUCCESS The operation was successful.
2185 @retval EFI_INVALID_PARAMETER Guid was NULL.
2186 @retval EFI_INVALID_PARAMETER GuidName was NULL.
2187 @retval EFI_NOT_FOUND GuidName is not a known GUID Name.
2191 EfiShellGetGuidFromName(
2192 IN CONST CHAR16
*GuidName
,
2199 if (Guid
== NULL
|| GuidName
== NULL
) {
2200 return (EFI_INVALID_PARAMETER
);
2203 Status
= GetGuidFromStringName(GuidName
, NULL
, &NewGuid
);
2205 if (!EFI_ERROR(Status
)) {
2206 CopyGuid(NewGuid
, Guid
);
2213 Get the human readable name for a GUID from the value.
2215 If Guid is assigned a name, then update *GuidName to point to the name. The callee
2216 should not modify the value.
2218 This function is only available when the major and minor versions in the
2219 EfiShellProtocol are greater than or equal to 2 and 1, respectively.
2221 @param[in] Guid A pointer to the GUID being queried.
2222 @param[out] GuidName A pointer to a pointer the localized to name for the GUID being requested
2224 @retval EFI_SUCCESS The operation was successful.
2225 @retval EFI_INVALID_PARAMETER Guid was NULL.
2226 @retval EFI_INVALID_PARAMETER GuidName was NULL.
2227 @retval EFI_NOT_FOUND Guid is not assigned a name.
2231 EfiShellGetGuidName(
2232 IN CONST EFI_GUID
*Guid
,
2233 OUT CONST CHAR16
**GuidName
2238 if (Guid
== NULL
|| GuidName
== NULL
) {
2239 return (EFI_INVALID_PARAMETER
);
2242 Name
= GetStringNameFromGuid(Guid
, NULL
);
2243 if (Name
== NULL
|| StrLen(Name
) == 0) {
2244 SHELL_FREE_NON_NULL(Name
);
2245 return (EFI_NOT_FOUND
);
2248 *GuidName
= AddBufferToFreeList(Name
);
2250 return (EFI_SUCCESS
);
2254 Updates a file name to be preceeded by the mapped drive name
2256 @param[in] BasePath the Mapped drive name to prepend
2257 @param[in, out] Path pointer to pointer to the file name to update.
2260 @retval EFI_OUT_OF_RESOURCES
2265 IN CONST CHAR16
*BasePath
,
2266 IN OUT CHAR16
**Path
2275 ASSERT(Path
!= NULL
);
2276 ASSERT(*Path
!= NULL
);
2277 ASSERT(BasePath
!= NULL
);
2280 // convert a local path to an absolute path
2282 if (StrStr(*Path
, L
":") == NULL
) {
2283 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2284 StrnCatGrow(&Path2
, &Path2Size
, BasePath
, 0);
2285 if (Path2
== NULL
) {
2286 return (EFI_OUT_OF_RESOURCES
);
2288 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2289 StrnCatGrow(&Path2
, &Path2Size
, (*Path
)[0] == L
'\\'?(*Path
) + 1 :*Path
, 0);
2290 if (Path2
== NULL
) {
2291 return (EFI_OUT_OF_RESOURCES
);
2298 return (EFI_SUCCESS
);
2302 If FileHandle is a directory then the function reads from FileHandle and reads in
2303 each of the FileInfo structures. If one of them matches the Pattern's first
2304 "level" then it opens that handle and calls itself on that handle.
2306 If FileHandle is a file and matches all of the remaining Pattern (which would be
2307 on its last node), then add a EFI_SHELL_FILE_INFO object for this file to fileList.
2309 Upon a EFI_SUCCESS return fromt he function any the caller is responsible to call
2310 FreeFileList with FileList.
2312 @param[in] FilePattern The FilePattern to check against.
2313 @param[in] UnicodeCollation The pointer to EFI_UNICODE_COLLATION_PROTOCOL structure
2314 @param[in] FileHandle The FileHandle to start with
2315 @param[in, out] FileList pointer to pointer to list of found files.
2316 @param[in] ParentNode The node for the parent. Same file as identified by HANDLE.
2317 @param[in] MapName The file system name this file is on.
2319 @retval EFI_SUCCESS all files were found and the FileList contains a list.
2320 @retval EFI_NOT_FOUND no files were found
2321 @retval EFI_OUT_OF_RESOURCES a memory allocation failed
2326 IN CONST CHAR16
*FilePattern
,
2327 IN EFI_UNICODE_COLLATION_PROTOCOL
*UnicodeCollation
,
2328 IN SHELL_FILE_HANDLE FileHandle
,
2329 IN OUT EFI_SHELL_FILE_INFO
**FileList
,
2330 IN CONST EFI_SHELL_FILE_INFO
*ParentNode OPTIONAL
,
2331 IN CONST CHAR16
*MapName
2335 CONST CHAR16
*NextFilePatternStart
;
2336 CHAR16
*CurrentFilePattern
;
2337 EFI_SHELL_FILE_INFO
*ShellInfo
;
2338 EFI_SHELL_FILE_INFO
*ShellInfoNode
;
2339 EFI_SHELL_FILE_INFO
*NewShellNode
;
2340 EFI_FILE_INFO
*FileInfo
;
2342 CHAR16
*NewFullName
;
2345 if ( FilePattern
== NULL
2346 || UnicodeCollation
== NULL
2349 return (EFI_INVALID_PARAMETER
);
2352 CurrentFilePattern
= NULL
;
2354 if (*FilePattern
== L
'\\') {
2358 for( NextFilePatternStart
= FilePattern
2359 ; *NextFilePatternStart
!= CHAR_NULL
&& *NextFilePatternStart
!= L
'\\'
2360 ; NextFilePatternStart
++);
2362 CurrentFilePattern
= AllocateZeroPool((NextFilePatternStart
-FilePattern
+1)*sizeof(CHAR16
));
2363 ASSERT(CurrentFilePattern
!= NULL
);
2364 StrnCpyS(CurrentFilePattern
, NextFilePatternStart
-FilePattern
+1, FilePattern
, NextFilePatternStart
-FilePattern
);
2366 if (CurrentFilePattern
[0] == CHAR_NULL
2367 &&NextFilePatternStart
[0] == CHAR_NULL
2370 // we want the parent or root node (if no parent)
2372 if (ParentNode
== NULL
) {
2374 // We want the root node. create the node.
2376 FileInfo
= FileHandleGetInfo(FileHandle
);
2377 NewShellNode
= CreateAndPopulateShellFileInfo(
2384 SHELL_FREE_NON_NULL(FileInfo
);
2387 // Add the current parameter FileHandle to the list, then end...
2389 NewShellNode
= InternalDuplicateShellFileInfo((EFI_SHELL_FILE_INFO
*)ParentNode
, TRUE
);
2391 if (NewShellNode
== NULL
) {
2392 Status
= EFI_OUT_OF_RESOURCES
;
2394 NewShellNode
->Handle
= NULL
;
2395 if (*FileList
== NULL
) {
2396 *FileList
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2397 InitializeListHead(&((*FileList
)->Link
));
2401 // Add to the returning to use list
2403 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
2405 Status
= EFI_SUCCESS
;
2408 Status
= EfiShellFindFilesInDir(FileHandle
, &ShellInfo
);
2410 if (!EFI_ERROR(Status
)){
2411 if (StrStr(NextFilePatternStart
, L
"\\") != NULL
){
2416 for ( ShellInfoNode
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&ShellInfo
->Link
)
2417 ; !IsNull (&ShellInfo
->Link
, &ShellInfoNode
->Link
)
2418 ; ShellInfoNode
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&ShellInfo
->Link
, &ShellInfoNode
->Link
)
2420 if (UnicodeCollation
->MetaiMatch(UnicodeCollation
, (CHAR16
*)ShellInfoNode
->FileName
, CurrentFilePattern
)){
2421 if (ShellInfoNode
->FullName
!= NULL
&& StrStr(ShellInfoNode
->FullName
, L
":") == NULL
) {
2422 Size
= StrSize(ShellInfoNode
->FullName
);
2423 Size
+= StrSize(MapName
) + sizeof(CHAR16
);
2424 NewFullName
= AllocateZeroPool(Size
);
2425 if (NewFullName
== NULL
) {
2426 Status
= EFI_OUT_OF_RESOURCES
;
2428 StrCpyS(NewFullName
, Size
/sizeof(CHAR16
), MapName
);
2429 StrCatS(NewFullName
, Size
/sizeof(CHAR16
), ShellInfoNode
->FullName
+1);
2430 FreePool((VOID
*)ShellInfoNode
->FullName
);
2431 ShellInfoNode
->FullName
= NewFullName
;
2434 if (Directory
&& !EFI_ERROR(Status
) && ShellInfoNode
->FullName
!= NULL
&& ShellInfoNode
->FileName
!= NULL
){
2436 // should be a directory
2440 // don't open the . and .. directories
2442 if ( (StrCmp(ShellInfoNode
->FileName
, L
".") != 0)
2443 && (StrCmp(ShellInfoNode
->FileName
, L
"..") != 0)
2448 if (EFI_ERROR(Status
)) {
2452 // Open the directory since we need that handle in the next recursion.
2454 ShellInfoNode
->Status
= EfiShellOpenFileByName (ShellInfoNode
->FullName
, &ShellInfoNode
->Handle
, EFI_FILE_MODE_READ
);
2457 // recurse with the next part of the pattern
2459 Status
= ShellSearchHandle(NextFilePatternStart
, UnicodeCollation
, ShellInfoNode
->Handle
, FileList
, ShellInfoNode
, MapName
);
2460 EfiShellClose(ShellInfoNode
->Handle
);
2461 ShellInfoNode
->Handle
= NULL
;
2463 } else if (!EFI_ERROR(Status
)) {
2469 // copy the information we need into a new Node
2471 NewShellNode
= InternalDuplicateShellFileInfo(ShellInfoNode
, FALSE
);
2472 ASSERT(NewShellNode
!= NULL
);
2473 if (NewShellNode
== NULL
) {
2474 Status
= EFI_OUT_OF_RESOURCES
;
2476 if (*FileList
== NULL
) {
2477 *FileList
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2478 InitializeListHead(&((*FileList
)->Link
));
2482 // Add to the returning to use list
2484 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
2487 if (EFI_ERROR(Status
)) {
2491 if (EFI_ERROR(Status
)) {
2492 EfiShellFreeFileList(&ShellInfo
);
2494 Status
= EfiShellFreeFileList(&ShellInfo
);
2499 FreePool(CurrentFilePattern
);
2504 Find files that match a specified pattern.
2506 This function searches for all files and directories that match the specified
2507 FilePattern. The FilePattern can contain wild-card characters. The resulting file
2508 information is placed in the file list FileList.
2510 Wildcards are processed
2511 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1.
2513 The files in the file list are not opened. The OpenMode field is set to 0 and the FileInfo
2514 field is set to NULL.
2516 if *FileList is not NULL then it must be a pre-existing and properly initialized list.
2518 @param FilePattern Points to a NULL-terminated shell file path, including wildcards.
2519 @param FileList On return, points to the start of a file list containing the names
2520 of all matching files or else points to NULL if no matching files
2521 were found. only on a EFI_SUCCESS return will; this be non-NULL.
2523 @retval EFI_SUCCESS Files found. FileList is a valid list.
2524 @retval EFI_NOT_FOUND No files found.
2525 @retval EFI_NO_MEDIA The device has no media
2526 @retval EFI_DEVICE_ERROR The device reported an error
2527 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted
2532 IN CONST CHAR16
*FilePattern
,
2533 OUT EFI_SHELL_FILE_INFO
**FileList
2537 CHAR16
*PatternCopy
;
2538 CHAR16
*PatternCurrentLocation
;
2539 EFI_DEVICE_PATH_PROTOCOL
*RootDevicePath
;
2540 SHELL_FILE_HANDLE RootFileHandle
;
2544 if ( FilePattern
== NULL
2546 || StrStr(FilePattern
, L
":") == NULL
2548 return (EFI_INVALID_PARAMETER
);
2550 Status
= EFI_SUCCESS
;
2551 RootDevicePath
= NULL
;
2552 RootFileHandle
= NULL
;
2554 PatternCopy
= AllocateCopyPool(StrSize(FilePattern
), FilePattern
);
2555 if (PatternCopy
== NULL
) {
2556 return (EFI_OUT_OF_RESOURCES
);
2559 PatternCopy
= PathCleanUpDirectories(PatternCopy
);
2561 Count
= StrStr(PatternCopy
, L
":") - PatternCopy
;
2564 ASSERT(MapName
== NULL
);
2565 MapName
= StrnCatGrow(&MapName
, NULL
, PatternCopy
, Count
);
2566 if (MapName
== NULL
) {
2567 Status
= EFI_OUT_OF_RESOURCES
;
2569 RootDevicePath
= EfiShellGetDevicePathFromFilePath(PatternCopy
);
2570 if (RootDevicePath
== NULL
) {
2571 Status
= EFI_INVALID_PARAMETER
;
2573 Status
= EfiShellOpenRoot(RootDevicePath
, &RootFileHandle
);
2574 if (!EFI_ERROR(Status
)) {
2575 for ( PatternCurrentLocation
= PatternCopy
2576 ; *PatternCurrentLocation
!= ':'
2577 ; PatternCurrentLocation
++);
2578 PatternCurrentLocation
++;
2579 Status
= ShellSearchHandle(PatternCurrentLocation
, gUnicodeCollation
, RootFileHandle
, FileList
, NULL
, MapName
);
2580 EfiShellClose(RootFileHandle
);
2582 FreePool(RootDevicePath
);
2586 SHELL_FREE_NON_NULL(PatternCopy
);
2587 SHELL_FREE_NON_NULL(MapName
);
2593 Opens the files that match the path specified.
2595 This function opens all of the files specified by Path. Wildcards are processed
2596 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1. Each
2597 matching file has an EFI_SHELL_FILE_INFO structure created in a linked list.
2599 @param Path A pointer to the path string.
2600 @param OpenMode Specifies the mode used to open each file, EFI_FILE_MODE_READ or
2601 EFI_FILE_MODE_WRITE.
2602 @param FileList Points to the start of a list of files opened.
2604 @retval EFI_SUCCESS Create the file list successfully.
2605 @return Others Can't create the file list.
2609 EfiShellOpenFileList(
2612 IN OUT EFI_SHELL_FILE_INFO
**FileList
2616 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
2619 CONST CHAR16
*CurDir
;
2622 PathCleanUpDirectories(Path
);
2627 if (FileList
== NULL
|| *FileList
== NULL
) {
2628 return (EFI_INVALID_PARAMETER
);
2631 if (*Path
== L
'.' && *(Path
+1) == L
'\\') {
2636 // convert a local path to an absolute path
2638 if (StrStr(Path
, L
":") == NULL
) {
2639 CurDir
= EfiShellGetCurDir(NULL
);
2640 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2641 StrnCatGrow(&Path2
, &Path2Size
, CurDir
, 0);
2642 StrnCatGrow(&Path2
, &Path2Size
, L
"\\", 0);
2643 if (*Path
== L
'\\') {
2645 while (PathRemoveLastItem(Path2
)) ;
2647 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2648 StrnCatGrow(&Path2
, &Path2Size
, Path
, 0);
2650 ASSERT(Path2
== NULL
);
2651 StrnCatGrow(&Path2
, NULL
, Path
, 0);
2654 PathCleanUpDirectories (Path2
);
2659 Status
= EfiShellFindFiles(Path2
, FileList
);
2663 if (EFI_ERROR(Status
)) {
2669 // We had no errors so open all the files (that are not already opened...)
2671 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
2672 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2673 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2675 if (ShellFileListItem
->Status
== 0 && ShellFileListItem
->Handle
== NULL
) {
2676 ShellFileListItem
->Status
= EfiShellOpenFileByName (ShellFileListItem
->FullName
, &ShellFileListItem
->Handle
, OpenMode
);
2682 return (EFI_NOT_FOUND
);
2684 return(EFI_SUCCESS
);
2688 Gets the environment variable and Attributes, or list of environment variables. Can be
2689 used instead of GetEnv().
2691 This function returns the current value of the specified environment variable and
2692 the Attributes. If no variable name was specified, then all of the known
2693 variables will be returned.
2695 @param[in] Name A pointer to the environment variable name. If Name is NULL,
2696 then the function will return all of the defined shell
2697 environment variables. In the case where multiple environment
2698 variables are being returned, each variable will be terminated
2699 by a NULL, and the list will be terminated by a double NULL.
2700 @param[out] Attributes If not NULL, a pointer to the returned attributes bitmask for
2701 the environment variable. In the case where Name is NULL, and
2702 multiple environment variables are being returned, Attributes
2705 @retval NULL The environment variable doesn't exist.
2706 @return A non-NULL value points to the variable's value. The returned
2707 pointer does not need to be freed by the caller.
2712 IN CONST CHAR16
*Name
,
2713 OUT UINT32
*Attributes OPTIONAL
2720 CHAR16
*CurrentWriteLocation
;
2728 // Build the semi-colon delimited list. (2 passes)
2730 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&gShellEnvVarList
.Link
)
2731 ; !IsNull(&gShellEnvVarList
.Link
, &Node
->Link
)
2732 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&gShellEnvVarList
.Link
, &Node
->Link
)
2734 ASSERT(Node
->Key
!= NULL
);
2735 Size
+= StrSize(Node
->Key
);
2738 Size
+= 2*sizeof(CHAR16
);
2740 Buffer
= AllocateZeroPool(Size
);
2741 if (Buffer
== NULL
) {
2744 CurrentWriteLocation
= (CHAR16
*)Buffer
;
2746 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&gShellEnvVarList
.Link
)
2747 ; !IsNull(&gShellEnvVarList
.Link
, &Node
->Link
)
2748 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&gShellEnvVarList
.Link
, &Node
->Link
)
2750 ASSERT(Node
->Key
!= NULL
);
2751 StrCpyS( CurrentWriteLocation
,
2752 (Size
)/sizeof(CHAR16
) - (CurrentWriteLocation
- ((CHAR16
*)Buffer
)),
2755 CurrentWriteLocation
+= StrLen(CurrentWriteLocation
) + 1;
2760 // We are doing a specific environment variable
2762 Status
= ShellFindEnvVarInList(Name
, (CHAR16
**)&Buffer
, &Size
, Attributes
);
2764 if (EFI_ERROR(Status
)){
2766 // get the size we need for this EnvVariable
2768 Status
= SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(Name
, Attributes
, &Size
, Buffer
);
2769 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2771 // Allocate the space and recall the get function
2773 Buffer
= AllocateZeroPool(Size
);
2774 Status
= SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(Name
, Attributes
, &Size
, Buffer
);
2777 // we didnt get it (might not exist)
2778 // free the memory if we allocated any and return NULL
2780 if (EFI_ERROR(Status
)) {
2781 if (Buffer
!= NULL
) {
2787 // If we did not find the environment variable in the gShellEnvVarList
2788 // but get it from UEFI variable storage successfully then we need update
2789 // the gShellEnvVarList.
2791 ShellFreeEnvVarList ();
2792 Status
= ShellInitEnvVarList ();
2793 ASSERT (Status
== EFI_SUCCESS
);
2799 // return the buffer
2801 return (AddBufferToFreeList(Buffer
));
2805 Gets either a single or list of environment variables.
2807 If name is not NULL then this function returns the current value of the specified
2808 environment variable.
2810 If Name is NULL, then a list of all environment variable names is returned. Each is a
2811 NULL terminated string with a double NULL terminating the list.
2813 @param Name A pointer to the environment variable name. If
2814 Name is NULL, then the function will return all
2815 of the defined shell environment variables. In
2816 the case where multiple environment variables are
2817 being returned, each variable will be terminated by
2818 a NULL, and the list will be terminated by a double
2821 @retval !=NULL A pointer to the returned string.
2822 The returned pointer does not need to be freed by the caller.
2824 @retval NULL The environment variable doesn't exist or there are
2825 no environment variables.
2830 IN CONST CHAR16
*Name
2833 return (EfiShellGetEnvEx(Name
, NULL
));
2837 Internal variable setting function. Allows for setting of the read only variables.
2839 @param Name Points to the NULL-terminated environment variable name.
2840 @param Value Points to the NULL-terminated environment variable value. If the value is an
2841 empty string then the environment variable is deleted.
2842 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2844 @retval EFI_SUCCESS The environment variable was successfully updated.
2848 InternalEfiShellSetEnv(
2849 IN CONST CHAR16
*Name
,
2850 IN CONST CHAR16
*Value
,
2856 if (Value
== NULL
|| StrLen(Value
) == 0) {
2857 Status
= SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
);
2858 if (!EFI_ERROR(Status
)) {
2859 ShellRemvoeEnvVarFromList(Name
);
2862 SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
);
2863 Status
= ShellAddEnvVarToList(
2864 Name
, Value
, StrSize(Value
),
2865 EFI_VARIABLE_BOOTSERVICE_ACCESS
| (Volatile
? 0 : EFI_VARIABLE_NON_VOLATILE
)
2867 if (!EFI_ERROR (Status
)) {
2869 ? SHELL_SET_ENVIRONMENT_VARIABLE_V(Name
, StrSize(Value
), Value
)
2870 : SHELL_SET_ENVIRONMENT_VARIABLE_NV(Name
, StrSize(Value
), Value
);
2871 if (EFI_ERROR (Status
)) {
2872 ShellRemvoeEnvVarFromList(Name
);
2880 Sets the environment variable.
2882 This function changes the current value of the specified environment variable. If the
2883 environment variable exists and the Value is an empty string, then the environment
2884 variable is deleted. If the environment variable exists and the Value is not an empty
2885 string, then the value of the environment variable is changed. If the environment
2886 variable does not exist and the Value is an empty string, there is no action. If the
2887 environment variable does not exist and the Value is a non-empty string, then the
2888 environment variable is created and assigned the specified value.
2890 For a description of volatile and non-volatile environment variables, see UEFI Shell
2891 2.0 specification section 3.6.1.
2893 @param Name Points to the NULL-terminated environment variable name.
2894 @param Value Points to the NULL-terminated environment variable value. If the value is an
2895 empty string then the environment variable is deleted.
2896 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2898 @retval EFI_SUCCESS The environment variable was successfully updated.
2903 IN CONST CHAR16
*Name
,
2904 IN CONST CHAR16
*Value
,
2908 if (Name
== NULL
|| *Name
== CHAR_NULL
) {
2909 return (EFI_INVALID_PARAMETER
);
2912 // Make sure we dont 'set' a predefined read only variable
2914 if (gUnicodeCollation
->StriColl(
2918 ||gUnicodeCollation
->StriColl(
2922 ||gUnicodeCollation
->StriColl(
2926 ||gUnicodeCollation
->StriColl(
2929 L
"uefishellsupport") == 0
2930 ||gUnicodeCollation
->StriColl(
2933 L
"uefishellversion") == 0
2934 ||gUnicodeCollation
->StriColl(
2937 L
"uefiversion") == 0
2938 ||(!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoNest
&&
2939 gUnicodeCollation
->StriColl(
2942 (CHAR16
*)mNoNestingEnvVarName
) == 0)
2944 return (EFI_INVALID_PARAMETER
);
2946 return (InternalEfiShellSetEnv(Name
, Value
, Volatile
));
2950 Returns the current directory on the specified device.
2952 If FileSystemMapping is NULL, it returns the current working directory. If the
2953 FileSystemMapping is not NULL, it returns the current directory associated with the
2954 FileSystemMapping. In both cases, the returned name includes the file system
2955 mapping (i.e. fs0:\current-dir).
2957 Note that the current directory string should exclude the tailing backslash character.
2959 @param FileSystemMapping A pointer to the file system mapping. If NULL,
2960 then the current working directory is returned.
2962 @retval !=NULL The current directory.
2963 @retval NULL Current directory does not exist.
2968 IN CONST CHAR16
*FileSystemMapping OPTIONAL
2971 CHAR16
*PathToReturn
;
2973 SHELL_MAP_LIST
*MapListItem
;
2974 if (!IsListEmpty(&gShellMapList
.Link
)) {
2976 // if parameter is NULL, use current
2978 if (FileSystemMapping
== NULL
) {
2979 return (EfiShellGetEnv(L
"cwd"));
2982 PathToReturn
= NULL
;
2983 MapListItem
= ShellCommandFindMapItem(FileSystemMapping
);
2984 if (MapListItem
!= NULL
) {
2985 ASSERT((PathToReturn
== NULL
&& Size
== 0) || (PathToReturn
!= NULL
));
2986 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->MapName
, 0);
2987 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
2990 return (AddBufferToFreeList(PathToReturn
));
2997 Changes the current directory on the specified device.
2999 If the FileSystem is NULL, and the directory Dir does not contain a file system's
3000 mapped name, this function changes the current working directory.
3002 If the FileSystem is NULL and the directory Dir contains a mapped name, then the
3003 current file system and the current directory on that file system are changed.
3005 If FileSystem is NULL, and Dir is not NULL, then this changes the current working file
3008 If FileSystem is not NULL and Dir is not NULL, then this function changes the current
3009 directory on the specified file system.
3011 If the current working directory or the current working file system is changed then the
3012 %cwd% environment variable will be updated
3014 Note that the current directory string should exclude the tailing backslash character.
3016 @param FileSystem A pointer to the file system's mapped name. If NULL, then the current working
3017 directory is changed.
3018 @param Dir Points to the NULL-terminated directory on the device specified by FileSystem.
3020 @retval EFI_SUCCESS The operation was sucessful
3021 @retval EFI_NOT_FOUND The file system could not be found
3026 IN CONST CHAR16
*FileSystem OPTIONAL
,
3027 IN CONST CHAR16
*Dir
3031 SHELL_MAP_LIST
*MapListItem
;
3035 CHAR16
*DirectoryName
;
3042 DirectoryName
= NULL
;
3044 if ((FileSystem
== NULL
&& Dir
== NULL
) || Dir
== NULL
) {
3045 return (EFI_INVALID_PARAMETER
);
3048 if (IsListEmpty(&gShellMapList
.Link
)){
3049 return (EFI_NOT_FOUND
);
3052 DirectoryName
= StrnCatGrow(&DirectoryName
, NULL
, Dir
, 0);
3053 ASSERT(DirectoryName
!= NULL
);
3055 PathCleanUpDirectories(DirectoryName
);
3057 if (FileSystem
== NULL
) {
3059 // determine the file system mapping to use
3061 if (StrStr(DirectoryName
, L
":") != NULL
) {
3062 ASSERT(MapName
== NULL
);
3063 MapName
= StrnCatGrow(&MapName
, NULL
, DirectoryName
, (StrStr(DirectoryName
, L
":")-DirectoryName
+1));
3066 // find the file system mapping's entry in the list
3069 if (MapName
!= NULL
) {
3070 MapListItem
= ShellCommandFindMapItem(MapName
);
3073 // make that the current file system mapping
3075 if (MapListItem
!= NULL
) {
3076 gShellCurDir
= MapListItem
;
3079 MapListItem
= gShellCurDir
;
3082 if (MapListItem
== NULL
) {
3083 FreePool (DirectoryName
);
3084 SHELL_FREE_NON_NULL(MapName
);
3085 return (EFI_NOT_FOUND
);
3089 // now update the MapListItem's current directory
3091 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& DirectoryName
[StrLen(DirectoryName
) - 1] != L
':') {
3092 FreePool(MapListItem
->CurrentDirectoryPath
);
3093 MapListItem
->CurrentDirectoryPath
= NULL
;
3095 if (MapName
!= NULL
) {
3096 TempLen
= StrLen(MapName
);
3097 if (TempLen
!= StrLen(DirectoryName
)) {
3098 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3099 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
+StrLen(MapName
), 0);
3103 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3104 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
3106 if ((MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] == L
'\\') || (MapListItem
->CurrentDirectoryPath
== NULL
)) {
3107 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3108 if (MapListItem
->CurrentDirectoryPath
!= NULL
) {
3109 MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] = CHAR_NULL
;
3114 // cant have a mapping in the directory...
3116 if (StrStr(DirectoryName
, L
":") != NULL
) {
3117 FreePool (DirectoryName
);
3118 return (EFI_INVALID_PARAMETER
);
3121 // FileSystem != NULL
3123 MapListItem
= ShellCommandFindMapItem(FileSystem
);
3124 if (MapListItem
== NULL
) {
3125 FreePool (DirectoryName
);
3126 return (EFI_INVALID_PARAMETER
);
3128 // gShellCurDir = MapListItem;
3129 if (DirectoryName
!= NULL
) {
3131 // change current dir on that file system
3134 if (MapListItem
->CurrentDirectoryPath
!= NULL
) {
3135 FreePool(MapListItem
->CurrentDirectoryPath
);
3136 DEBUG_CODE(MapListItem
->CurrentDirectoryPath
= NULL
;);
3138 // ASSERT((MapListItem->CurrentDirectoryPath == NULL && Size == 0) || (MapListItem->CurrentDirectoryPath != NULL));
3139 // MapListItem->CurrentDirectoryPath = StrnCatGrow(&MapListItem->CurrentDirectoryPath, &Size, FileSystem, 0);
3140 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3141 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
3142 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3143 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
3144 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] == L
'\\') {
3145 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3146 MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] = CHAR_NULL
;
3150 FreePool (DirectoryName
);
3152 // if updated the current directory then update the environment variable
3154 if (MapListItem
== gShellCurDir
) {
3156 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
3157 StrnCatGrow(&TempString
, &Size
, MapListItem
->MapName
, 0);
3158 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
3159 StrnCatGrow(&TempString
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
3160 Status
= InternalEfiShellSetEnv(L
"cwd", TempString
, TRUE
);
3161 FreePool(TempString
);
3164 return(EFI_SUCCESS
);
3168 Return help information about a specific command.
3170 This function returns the help information for the specified command. The help text
3171 can be internal to the shell or can be from a UEFI Shell manual page.
3173 If Sections is specified, then each section name listed will be compared in a casesensitive
3174 manner, to the section names described in Appendix B. If the section exists,
3175 it will be appended to the returned help text. If the section does not exist, no
3176 information will be returned. If Sections is NULL, then all help text information
3177 available will be returned.
3179 @param Command Points to the NULL-terminated UEFI Shell command name.
3180 @param Sections Points to the NULL-terminated comma-delimited
3181 section names to return. If NULL, then all
3182 sections will be returned.
3183 @param HelpText On return, points to a callee-allocated buffer
3184 containing all specified help text.
3186 @retval EFI_SUCCESS The help text was returned.
3187 @retval EFI_OUT_OF_RESOURCES The necessary buffer could not be allocated to hold the
3189 @retval EFI_INVALID_PARAMETER HelpText is NULL
3190 @retval EFI_NOT_FOUND There is no help text available for Command.
3194 EfiShellGetHelpText(
3195 IN CONST CHAR16
*Command
,
3196 IN CONST CHAR16
*Sections OPTIONAL
,
3197 OUT CHAR16
**HelpText
3200 CONST CHAR16
*ManFileName
;
3204 ASSERT(HelpText
!= NULL
);
3207 ManFileName
= ShellCommandGetManFileNameHandler(Command
);
3209 if (ManFileName
!= NULL
) {
3210 return (ProcessManFile(ManFileName
, Command
, Sections
, NULL
, HelpText
));
3212 if ((StrLen(Command
)> 4)
3213 && (Command
[StrLen(Command
)-1] == L
'i' || Command
[StrLen(Command
)-1] == L
'I')
3214 && (Command
[StrLen(Command
)-2] == L
'f' || Command
[StrLen(Command
)-2] == L
'F')
3215 && (Command
[StrLen(Command
)-3] == L
'e' || Command
[StrLen(Command
)-3] == L
'E')
3216 && (Command
[StrLen(Command
)-4] == L
'.')
3218 FixCommand
= AllocateZeroPool(StrSize(Command
) - 4 * sizeof (CHAR16
));
3219 ASSERT(FixCommand
!= NULL
);
3221 StrnCpyS( FixCommand
,
3222 (StrSize(Command
) - 4 * sizeof (CHAR16
))/sizeof(CHAR16
),
3226 Status
= ProcessManFile(FixCommand
, FixCommand
, Sections
, NULL
, HelpText
);
3227 FreePool(FixCommand
);
3230 return (ProcessManFile(Command
, Command
, Sections
, NULL
, HelpText
));
3236 Gets the enable status of the page break output mode.
3238 User can use this function to determine current page break mode.
3240 @retval TRUE The page break output mode is enabled.
3241 @retval FALSE The page break output mode is disabled.
3245 EfiShellGetPageBreak(
3249 return(ShellInfoObject
.PageBreakEnabled
);
3253 Judges whether the active shell is the root shell.
3255 This function makes the user to know that whether the active Shell is the root shell.
3257 @retval TRUE The active Shell is the root Shell.
3258 @retval FALSE The active Shell is NOT the root Shell.
3262 EfiShellIsRootShell(
3266 return(ShellInfoObject
.RootShellInstance
);
3270 function to return a semi-colon delimeted list of all alias' in the current shell
3272 up to caller to free the memory.
3274 @retval NULL No alias' were found
3275 @retval NULL An error ocurred getting alias'
3276 @return !NULL a list of all alias'
3280 InternalEfiShellGetListAlias(
3286 CHAR16
*VariableName
;
3288 UINTN NameBufferSize
;
3292 NameBufferSize
= INIT_NAME_BUFFER_SIZE
;
3293 VariableName
= AllocateZeroPool(NameBufferSize
);
3297 if (VariableName
== NULL
) {
3301 VariableName
[0] = CHAR_NULL
;
3304 NameSize
= NameBufferSize
;
3305 Status
= gRT
->GetNextVariableName(&NameSize
, VariableName
, &Guid
);
3306 if (Status
== EFI_NOT_FOUND
){
3308 } else if (Status
== EFI_BUFFER_TOO_SMALL
) {
3309 NameBufferSize
= NameSize
> NameBufferSize
* 2 ? NameSize
: NameBufferSize
* 2;
3310 SHELL_FREE_NON_NULL(VariableName
);
3311 VariableName
= AllocateZeroPool(NameBufferSize
);
3312 if (VariableName
== NULL
) {
3313 Status
= EFI_OUT_OF_RESOURCES
;
3314 SHELL_FREE_NON_NULL(RetVal
);
3319 NameSize
= NameBufferSize
;
3320 Status
= gRT
->GetNextVariableName(&NameSize
, VariableName
, &Guid
);
3323 if (EFI_ERROR (Status
)) {
3324 SHELL_FREE_NON_NULL(RetVal
);
3329 if (CompareGuid(&Guid
, &gShellAliasGuid
)){
3330 ASSERT((RetVal
== NULL
&& RetSize
== 0) || (RetVal
!= NULL
));
3331 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, VariableName
, 0);
3332 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, L
";", 0);
3335 SHELL_FREE_NON_NULL(VariableName
);
3341 Convert a null-terminated unicode string, in-place, to all lowercase.
3344 @param Str The null-terminated string to be converted to all lowercase.
3346 @return The null-terminated string converted into all lowercase.
3355 for (Index
= 0; Str
[Index
] != L
'\0'; Index
++) {
3356 if (Str
[Index
] >= L
'A' && Str
[Index
] <= L
'Z') {
3357 Str
[Index
] -= (CHAR16
)(L
'A' - L
'a');
3364 This function returns the command associated with a alias or a list of all
3367 @param[in] Alias Points to the NULL-terminated shell alias.
3368 If this parameter is NULL, then all
3369 aliases will be returned in ReturnedData.
3370 @param[out] Volatile upon return of a single command if TRUE indicates
3371 this is stored in a volatile fashion. FALSE otherwise.
3373 @return If Alias is not NULL, it will return a pointer to
3374 the NULL-terminated command for that alias.
3375 If Alias is NULL, ReturnedData points to a ';'
3376 delimited list of alias (e.g.
3377 ReturnedData = "dir;del;copy;mfp") that is NULL-terminated.
3378 @retval NULL an error ocurred
3379 @retval NULL Alias was not a valid Alias
3384 IN CONST CHAR16
*Alias
,
3385 OUT BOOLEAN
*Volatile OPTIONAL
3395 // Convert to lowercase to make aliases case-insensitive
3396 if (Alias
!= NULL
) {
3397 AliasLower
= AllocateCopyPool (StrSize (Alias
), Alias
);
3398 ASSERT (AliasLower
!= NULL
);
3399 ToLower (AliasLower
);
3401 if (Volatile
== NULL
) {
3402 GetVariable2 (AliasLower
, &gShellAliasGuid
, (VOID
**)&AliasVal
, NULL
);
3403 FreePool(AliasLower
);
3404 return (AddBufferToFreeList(AliasVal
));
3408 Status
= gRT
->GetVariable(AliasLower
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
3409 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3410 RetVal
= AllocateZeroPool(RetSize
);
3411 Status
= gRT
->GetVariable(AliasLower
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
3413 if (EFI_ERROR(Status
)) {
3414 if (RetVal
!= NULL
) {
3417 FreePool(AliasLower
);
3420 if ((EFI_VARIABLE_NON_VOLATILE
& Attribs
) == EFI_VARIABLE_NON_VOLATILE
) {
3426 FreePool (AliasLower
);
3427 return (AddBufferToFreeList(RetVal
));
3429 return (AddBufferToFreeList(InternalEfiShellGetListAlias()));
3433 Changes a shell command alias.
3435 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3437 this function does not check for built in alias'.
3439 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3440 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3441 Command refers to an alias, that alias will be deleted.
3442 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3443 Alias being set will be stored in a non-volatile fashion.
3445 @retval EFI_SUCCESS Alias created or deleted successfully.
3446 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3451 IN CONST CHAR16
*Command
,
3452 IN CONST CHAR16
*Alias
,
3459 // Convert to lowercase to make aliases case-insensitive
3460 if (Alias
!= NULL
) {
3461 AliasLower
= AllocateCopyPool (StrSize (Alias
), Alias
);
3462 ASSERT (AliasLower
!= NULL
);
3463 ToLower (AliasLower
);
3469 // We must be trying to remove one if Alias is NULL
3471 if (Alias
== NULL
) {
3473 // remove an alias (but passed in COMMAND parameter)
3475 Status
= (gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
));
3478 // Add and replace are the same
3481 // We dont check the error return on purpose since the variable may not exist.
3482 gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
);
3484 Status
= (gRT
->SetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, EFI_VARIABLE_BOOTSERVICE_ACCESS
|(Volatile
?0:EFI_VARIABLE_NON_VOLATILE
), StrSize(Command
), (VOID
*)Command
));
3487 if (Alias
!= NULL
) {
3488 FreePool (AliasLower
);
3494 Changes a shell command alias.
3496 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3499 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3500 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3501 Command refers to an alias, that alias will be deleted.
3502 @param[in] Replace If TRUE and the alias already exists, then the existing alias will be replaced. If
3503 FALSE and the alias already exists, then the existing alias is unchanged and
3504 EFI_ACCESS_DENIED is returned.
3505 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3506 Alias being set will be stored in a non-volatile fashion.
3508 @retval EFI_SUCCESS Alias created or deleted successfully.
3509 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3510 @retval EFI_ACCESS_DENIED The alias is a built-in alias or already existed and Replace was set to
3512 @retval EFI_INVALID_PARAMETER Command is null or the empty string.
3517 IN CONST CHAR16
*Command
,
3518 IN CONST CHAR16
*Alias
,
3523 if (ShellCommandIsOnAliasList(Alias
==NULL
?Command
:Alias
)) {
3525 // cant set over a built in alias
3527 return (EFI_ACCESS_DENIED
);
3528 } else if (Command
== NULL
|| *Command
== CHAR_NULL
|| StrLen(Command
) == 0) {
3530 // Command is null or empty
3532 return (EFI_INVALID_PARAMETER
);
3533 } else if (EfiShellGetAlias(Command
, NULL
) != NULL
&& !Replace
) {
3535 // Alias already exists, Replace not set
3537 return (EFI_ACCESS_DENIED
);
3539 return (InternalSetAlias(Command
, Alias
, Volatile
));
3543 // Pure FILE_HANDLE operations are passed to FileHandleLib
3544 // these functions are indicated by the *
3545 EFI_SHELL_PROTOCOL mShellProtocol
= {
3551 EfiShellGetHelpText
,
3552 EfiShellGetDevicePathFromMap
,
3553 EfiShellGetMapFromDevicePath
,
3554 EfiShellGetDevicePathFromFilePath
,
3555 EfiShellGetFilePathFromDevicePath
,
3559 EfiShellOpenFileList
,
3560 EfiShellFreeFileList
,
3561 EfiShellRemoveDupInFileList
,
3562 EfiShellBatchIsActive
,
3563 EfiShellIsRootShell
,
3564 EfiShellEnablePageBreak
,
3565 EfiShellDisablePageBreak
,
3566 EfiShellGetPageBreak
,
3567 EfiShellGetDeviceName
,
3568 (EFI_SHELL_GET_FILE_INFO
)FileHandleGetInfo
, //*
3569 (EFI_SHELL_SET_FILE_INFO
)FileHandleSetInfo
, //*
3570 EfiShellOpenFileByName
,
3573 (EFI_SHELL_READ_FILE
)FileHandleRead
, //*
3574 (EFI_SHELL_WRITE_FILE
)FileHandleWrite
, //*
3575 (EFI_SHELL_DELETE_FILE
)FileHandleDelete
, //*
3576 EfiShellDeleteFileByName
,
3577 (EFI_SHELL_GET_FILE_POSITION
)FileHandleGetPosition
, //*
3578 (EFI_SHELL_SET_FILE_POSITION
)FileHandleSetPosition
, //*
3579 (EFI_SHELL_FLUSH_FILE
)FileHandleFlush
, //*
3581 EfiShellFindFilesInDir
,
3582 (EFI_SHELL_GET_FILE_SIZE
)FileHandleGetSize
, //*
3584 EfiShellOpenRootByHandle
,
3586 SHELL_MAJOR_VERSION
,
3587 SHELL_MINOR_VERSION
,
3589 // New for UEFI Shell 2.1
3590 EfiShellRegisterGuidName
,
3591 EfiShellGetGuidName
,
3592 EfiShellGetGuidFromName
,
3597 Function to create and install on the current handle.
3599 Will overwrite any existing ShellProtocols in the system to be sure that
3600 the current shell is in control.
3602 This must be removed via calling CleanUpShellProtocol().
3604 @param[in, out] NewShell The pointer to the pointer to the structure
3607 @retval EFI_SUCCESS The operation was successful.
3608 @return An error from LocateHandle, CreateEvent, or other core function.
3612 CreatePopulateInstallShellProtocol (
3613 IN OUT EFI_SHELL_PROTOCOL
**NewShell
3619 UINTN HandleCounter
;
3620 SHELL_PROTOCOL_HANDLE_LIST
*OldProtocolNode
;
3622 if (NewShell
== NULL
) {
3623 return (EFI_INVALID_PARAMETER
);
3628 OldProtocolNode
= NULL
;
3629 InitializeListHead(&ShellInfoObject
.OldShellList
.Link
);
3632 // Initialize EfiShellProtocol object...
3634 Status
= gBS
->CreateEvent(0,
3638 &mShellProtocol
.ExecutionBreak
);
3639 if (EFI_ERROR(Status
)) {
3644 // Get the size of the buffer we need.
3646 Status
= gBS
->LocateHandle(ByProtocol
,
3647 &gEfiShellProtocolGuid
,
3651 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3653 // Allocate and recall with buffer of correct size
3655 Buffer
= AllocateZeroPool(BufferSize
);
3656 if (Buffer
== NULL
) {
3657 return (EFI_OUT_OF_RESOURCES
);
3659 Status
= gBS
->LocateHandle(ByProtocol
,
3660 &gEfiShellProtocolGuid
,
3664 if (EFI_ERROR(Status
)) {
3669 // now overwrite each of them, but save the info to restore when we end.
3671 for (HandleCounter
= 0 ; HandleCounter
< (BufferSize
/sizeof(EFI_HANDLE
)) ; HandleCounter
++) {
3672 OldProtocolNode
= AllocateZeroPool(sizeof(SHELL_PROTOCOL_HANDLE_LIST
));
3673 ASSERT(OldProtocolNode
!= NULL
);
3674 Status
= gBS
->OpenProtocol(Buffer
[HandleCounter
],
3675 &gEfiShellProtocolGuid
,
3676 (VOID
**) &(OldProtocolNode
->Interface
),
3679 EFI_OPEN_PROTOCOL_GET_PROTOCOL
3681 if (!EFI_ERROR(Status
)) {
3683 // reinstall over the old one...
3685 OldProtocolNode
->Handle
= Buffer
[HandleCounter
];
3686 Status
= gBS
->ReinstallProtocolInterface(
3687 OldProtocolNode
->Handle
,
3688 &gEfiShellProtocolGuid
,
3689 OldProtocolNode
->Interface
,
3690 (VOID
*)(&mShellProtocol
));
3691 if (!EFI_ERROR(Status
)) {
3693 // we reinstalled sucessfully. log this so we can reverse it later.
3697 // add to the list for subsequent...
3699 InsertTailList(&ShellInfoObject
.OldShellList
.Link
, &OldProtocolNode
->Link
);
3704 } else if (Status
== EFI_NOT_FOUND
) {
3705 ASSERT(IsListEmpty(&ShellInfoObject
.OldShellList
.Link
));
3707 // no one else published yet. just publish it ourselves.
3709 Status
= gBS
->InstallProtocolInterface (
3711 &gEfiShellProtocolGuid
,
3712 EFI_NATIVE_INTERFACE
,
3713 (VOID
*)(&mShellProtocol
));
3716 if (PcdGetBool(PcdShellSupportOldProtocols
)){
3717 ///@todo support ShellEnvironment2
3718 ///@todo do we need to support ShellEnvironment (not ShellEnvironment2) also?
3721 if (!EFI_ERROR(Status
)) {
3722 *NewShell
= &mShellProtocol
;
3728 Opposite of CreatePopulateInstallShellProtocol.
3730 Free all memory and restore the system to the state it was in before calling
3731 CreatePopulateInstallShellProtocol.
3733 @param[in, out] NewShell The pointer to the new shell protocol structure.
3735 @retval EFI_SUCCESS The operation was successful.
3739 CleanUpShellProtocol (
3740 IN OUT EFI_SHELL_PROTOCOL
*NewShell
3744 SHELL_PROTOCOL_HANDLE_LIST
*Node2
;
3745 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3748 // if we need to restore old protocols...
3750 if (!IsListEmpty(&ShellInfoObject
.OldShellList
.Link
)) {
3751 for (Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*)GetFirstNode(&ShellInfoObject
.OldShellList
.Link
)
3752 ; !IsListEmpty (&ShellInfoObject
.OldShellList
.Link
)
3753 ; Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*)GetFirstNode(&ShellInfoObject
.OldShellList
.Link
)
3755 RemoveEntryList(&Node2
->Link
);
3756 Status
= gBS
->ReinstallProtocolInterface(Node2
->Handle
,
3757 &gEfiShellProtocolGuid
,
3764 // no need to restore
3766 Status
= gBS
->UninstallProtocolInterface(gImageHandle
,
3767 &gEfiShellProtocolGuid
,
3770 Status
= gBS
->CloseEvent(NewShell
->ExecutionBreak
);
3771 NewShell
->ExecutionBreak
= NULL
;
3773 Status
= gBS
->OpenProtocol(
3774 gST
->ConsoleInHandle
,
3775 &gEfiSimpleTextInputExProtocolGuid
,
3779 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3781 if (!EFI_ERROR (Status
)) {
3782 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle1
);
3783 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle2
);
3784 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle3
);
3785 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle4
);
3786 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle1
);
3787 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle2
);
3788 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle3
);
3789 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle4
);
3795 Notification function for keystrokes.
3797 @param[in] KeyData The key that was pressed.
3799 @retval EFI_SUCCESS The operation was successful.
3803 NotificationFunction(
3804 IN EFI_KEY_DATA
*KeyData
3807 if ( ((KeyData
->Key
.UnicodeChar
== L
'c') &&
3808 (KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
) || KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
))) ||
3809 (KeyData
->Key
.UnicodeChar
== 3)
3811 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3812 return (EFI_UNSUPPORTED
);
3814 return (gBS
->SignalEvent(ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
));
3815 } else if ((KeyData
->Key
.UnicodeChar
== L
's') &&
3816 (KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
) || KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
))
3818 ShellInfoObject
.HaltOutput
= TRUE
;
3820 return (EFI_SUCCESS
);
3824 Function to start monitoring for CTRL-C using SimpleTextInputEx. This
3825 feature's enabled state was not known when the shell initially launched.
3827 @retval EFI_SUCCESS The feature is enabled.
3828 @retval EFI_OUT_OF_RESOURCES There is not enough mnemory available.
3832 InernalEfiShellStartMonitor(
3836 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3837 EFI_KEY_DATA KeyData
;
3840 Status
= gBS
->OpenProtocol(
3841 gST
->ConsoleInHandle
,
3842 &gEfiSimpleTextInputExProtocolGuid
,
3846 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3847 if (EFI_ERROR(Status
)) {
3852 STRING_TOKEN (STR_SHELL_NO_IN_EX
),
3853 ShellInfoObject
.HiiHandle
);
3854 return (EFI_SUCCESS
);
3857 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3858 return (EFI_UNSUPPORTED
);
3861 KeyData
.KeyState
.KeyToggleState
= 0;
3862 KeyData
.Key
.ScanCode
= 0;
3863 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3864 KeyData
.Key
.UnicodeChar
= L
'c';
3866 Status
= SimpleEx
->RegisterKeyNotify(
3869 NotificationFunction
,
3870 &ShellInfoObject
.CtrlCNotifyHandle1
);
3872 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3873 if (!EFI_ERROR(Status
)) {
3874 Status
= SimpleEx
->RegisterKeyNotify(
3877 NotificationFunction
,
3878 &ShellInfoObject
.CtrlCNotifyHandle2
);
3880 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3881 KeyData
.Key
.UnicodeChar
= 3;
3882 if (!EFI_ERROR(Status
)) {
3883 Status
= SimpleEx
->RegisterKeyNotify(
3886 NotificationFunction
,
3887 &ShellInfoObject
.CtrlCNotifyHandle3
);
3889 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3890 if (!EFI_ERROR(Status
)) {
3891 Status
= SimpleEx
->RegisterKeyNotify(
3894 NotificationFunction
,
3895 &ShellInfoObject
.CtrlCNotifyHandle4
);