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 if (AlignedNode
== NULL
) {
470 FreePool (PathForReturn
);
474 // File Path Device Path Nodes 'can optionally add a "\" separator to
475 // the beginning and/or the end of the Path Name string.'
476 // (UEFI Spec 2.4 section 9.3.6.4).
477 // If necessary, add a "\", but otherwise don't
478 // (This is specified in the above section, and also implied by the
479 // UEFI Shell spec section 3.7)
480 if ((PathSize
!= 0) &&
481 (PathForReturn
!= NULL
) &&
482 (PathForReturn
[PathSize
- 1] != L
'\\') &&
483 (AlignedNode
->PathName
[0] != L
'\\')) {
484 PathForReturn
= StrnCatGrow (&PathForReturn
, &PathSize
, L
"\\", 1);
487 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, AlignedNode
->PathName
, 0);
488 FreePool(AlignedNode
);
489 } // for loop of remaining nodes
491 if (PathForReturn
!= NULL
) {
494 } // for loop of paths to check
495 return(PathForReturn
);
499 Converts a file system style name to a device path.
501 This function converts a file system style name to a device path, by replacing any
502 mapping references to the associated device path.
504 @param[in] Path The pointer to the path.
506 @return The pointer of the file path. The file path is callee
507 allocated and should be freed by the caller.
508 @retval NULL The path could not be found.
509 @retval NULL There was not enough available memory.
511 EFI_DEVICE_PATH_PROTOCOL
*
513 EfiShellGetDevicePathFromFilePath(
514 IN CONST CHAR16
*Path
521 CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
522 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
523 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopyForFree
;
524 EFI_DEVICE_PATH_PROTOCOL
*DevicePathForReturn
;
535 if (StrStr(Path
, L
":") == NULL
) {
536 Cwd
= EfiShellGetCurDir(NULL
);
540 Size
= StrSize(Cwd
) + StrSize(Path
);
541 NewPath
= AllocateZeroPool(Size
);
542 if (NewPath
== NULL
) {
545 StrCpyS(NewPath
, Size
/sizeof(CHAR16
), Cwd
);
546 StrCatS(NewPath
, Size
/sizeof(CHAR16
), L
"\\");
547 if (*Path
== L
'\\') {
549 while (PathRemoveLastItem(NewPath
)) ;
551 StrCatS(NewPath
, Size
/sizeof(CHAR16
), Path
);
552 DevicePathForReturn
= EfiShellGetDevicePathFromFilePath(NewPath
);
554 return (DevicePathForReturn
);
559 // find the part before (but including) the : for the map name
561 ASSERT((MapName
== NULL
&& Size
== 0) || (MapName
!= NULL
));
562 MapName
= StrnCatGrow(&MapName
, &Size
, Path
, (StrStr(Path
, L
":")-Path
+1));
563 if (MapName
== NULL
|| MapName
[StrLen(MapName
)-1] != L
':') {
568 // look up the device path in the map
570 DevicePath
= EfiShellGetDevicePathFromMap(MapName
);
571 if (DevicePath
== NULL
) {
573 // Must have been a bad Mapname
579 // make a copy for LocateDevicePath to modify (also save a pointer to call FreePool with)
581 DevicePathCopyForFree
= DevicePathCopy
= DuplicateDevicePath(DevicePath
);
582 if (DevicePathCopy
== NULL
) {
591 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &Handle
);
592 if (EFI_ERROR(Status
)) {
593 if (DevicePathCopyForFree
!= NULL
) {
594 FreePool(DevicePathCopyForFree
);
601 // build the full device path
603 if (*(Path
+StrLen(MapName
)+1) == CHAR_NULL
) {
604 DevicePathForReturn
= FileDevicePath(Handle
, L
"\\");
606 DevicePathForReturn
= FileDevicePath(Handle
, Path
+StrLen(MapName
));
610 if (DevicePathCopyForFree
!= NULL
) {
611 FreePool(DevicePathCopyForFree
);
614 return (DevicePathForReturn
);
618 Gets the name of the device specified by the device handle.
620 This function gets the user-readable name of the device specified by the device
621 handle. If no user-readable name could be generated, then *BestDeviceName will be
622 NULL and EFI_NOT_FOUND will be returned.
624 If EFI_DEVICE_NAME_USE_COMPONENT_NAME is set, then the function will return the
625 device's name using the EFI_COMPONENT_NAME2_PROTOCOL, if present on
628 If EFI_DEVICE_NAME_USE_DEVICE_PATH is set, then the function will return the
629 device's name using the EFI_DEVICE_PATH_PROTOCOL, if present on DeviceHandle.
630 If both EFI_DEVICE_NAME_USE_COMPONENT_NAME and
631 EFI_DEVICE_NAME_USE_DEVICE_PATH are set, then
632 EFI_DEVICE_NAME_USE_COMPONENT_NAME will have higher priority.
634 @param DeviceHandle The handle of the device.
635 @param Flags Determines the possible sources of component names.
637 EFI_DEVICE_NAME_USE_COMPONENT_NAME
638 EFI_DEVICE_NAME_USE_DEVICE_PATH
639 @param Language A pointer to the language specified for the device
640 name, in the same format as described in the UEFI
641 specification, Appendix M
642 @param BestDeviceName On return, points to the callee-allocated NULL-
643 terminated name of the device. If no device name
644 could be found, points to NULL. The name must be
645 freed by the caller...
647 @retval EFI_SUCCESS Get the name successfully.
648 @retval EFI_NOT_FOUND Fail to get the device name.
649 @retval EFI_INVALID_PARAMETER Flags did not have a valid bit set.
650 @retval EFI_INVALID_PARAMETER BestDeviceName was NULL
651 @retval EFI_INVALID_PARAMETER DeviceHandle was NULL
655 EfiShellGetDeviceName(
656 IN EFI_HANDLE DeviceHandle
,
657 IN EFI_SHELL_DEVICE_NAME_FLAGS Flags
,
659 OUT CHAR16
**BestDeviceName
663 EFI_COMPONENT_NAME2_PROTOCOL
*CompName2
;
664 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
665 EFI_HANDLE
*HandleList
;
668 CHAR16
*DeviceNameToReturn
;
670 UINTN ParentControllerCount
;
671 EFI_HANDLE
*ParentControllerBuffer
;
672 UINTN ParentDriverCount
;
673 EFI_HANDLE
*ParentDriverBuffer
;
675 if (BestDeviceName
== NULL
||
678 return (EFI_INVALID_PARAMETER
);
682 // make sure one of the 2 supported bits is on
684 if (((Flags
& EFI_DEVICE_NAME_USE_COMPONENT_NAME
) == 0) &&
685 ((Flags
& EFI_DEVICE_NAME_USE_DEVICE_PATH
) == 0)) {
686 return (EFI_INVALID_PARAMETER
);
689 DeviceNameToReturn
= NULL
;
690 *BestDeviceName
= NULL
;
695 if ((Flags
& EFI_DEVICE_NAME_USE_COMPONENT_NAME
) != 0) {
696 Status
= ParseHandleDatabaseByRelationship(
699 HR_DRIVER_BINDING_HANDLE
|HR_DEVICE_DRIVER
,
702 for (LoopVar
= 0; LoopVar
< HandleCount
; LoopVar
++){
704 // Go through those handles until we get one that passes for GetComponentName
706 Status
= gBS
->OpenProtocol(
708 &gEfiComponentName2ProtocolGuid
,
712 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
713 if (EFI_ERROR(Status
)) {
714 Status
= gBS
->OpenProtocol(
716 &gEfiComponentNameProtocolGuid
,
720 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
723 if (EFI_ERROR(Status
)) {
726 Lang
= GetBestLanguageForDriver(CompName2
->SupportedLanguages
, Language
, FALSE
);
727 Status
= CompName2
->GetControllerName(CompName2
, DeviceHandle
, NULL
, Lang
, &DeviceNameToReturn
);
730 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
734 if (HandleList
!= NULL
) {
735 FreePool(HandleList
);
739 // Now check the parent controller using this as the child.
741 if (DeviceNameToReturn
== NULL
){
742 PARSE_HANDLE_DATABASE_PARENTS(DeviceHandle
, &ParentControllerCount
, &ParentControllerBuffer
);
743 for (LoopVar
= 0 ; LoopVar
< ParentControllerCount
; LoopVar
++) {
744 PARSE_HANDLE_DATABASE_UEFI_DRIVERS(ParentControllerBuffer
[LoopVar
], &ParentDriverCount
, &ParentDriverBuffer
);
745 for (HandleCount
= 0 ; HandleCount
< ParentDriverCount
; HandleCount
++) {
747 // try using that driver's component name with controller and our driver as the child.
749 Status
= gBS
->OpenProtocol(
750 ParentDriverBuffer
[HandleCount
],
751 &gEfiComponentName2ProtocolGuid
,
755 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
756 if (EFI_ERROR(Status
)) {
757 Status
= gBS
->OpenProtocol(
758 ParentDriverBuffer
[HandleCount
],
759 &gEfiComponentNameProtocolGuid
,
763 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
766 if (EFI_ERROR(Status
)) {
769 Lang
= GetBestLanguageForDriver(CompName2
->SupportedLanguages
, Language
, FALSE
);
770 Status
= CompName2
->GetControllerName(CompName2
, ParentControllerBuffer
[LoopVar
], DeviceHandle
, Lang
, &DeviceNameToReturn
);
773 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
780 SHELL_FREE_NON_NULL(ParentDriverBuffer
);
781 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
785 SHELL_FREE_NON_NULL(ParentControllerBuffer
);
788 // dont return on fail since we will try device path if that bit is on
790 if (DeviceNameToReturn
!= NULL
){
791 ASSERT(BestDeviceName
!= NULL
);
792 StrnCatGrow(BestDeviceName
, NULL
, DeviceNameToReturn
, 0);
793 return (EFI_SUCCESS
);
796 if ((Flags
& EFI_DEVICE_NAME_USE_DEVICE_PATH
) != 0) {
797 Status
= gBS
->OpenProtocol(
799 &gEfiDevicePathProtocolGuid
,
803 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
804 if (!EFI_ERROR(Status
)) {
806 // use device path to text on the device path
808 *BestDeviceName
= ConvertDevicePathToText(DevicePath
, TRUE
, TRUE
);
809 return (EFI_SUCCESS
);
813 // none of the selected bits worked.
815 return (EFI_NOT_FOUND
);
819 Opens the root directory of a device on a handle
821 This function opens the root directory of a device and returns a file handle to it.
823 @param DeviceHandle The handle of the device that contains the volume.
824 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
827 @retval EFI_SUCCESS Root opened successfully.
828 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
830 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
831 @retval EFI_DEVICE_ERROR The device had an error
835 EfiShellOpenRootByHandle(
836 IN EFI_HANDLE DeviceHandle
,
837 OUT SHELL_FILE_HANDLE
*FileHandle
841 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
*SimpleFileSystem
;
842 EFI_FILE_PROTOCOL
*RealFileHandle
;
843 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
846 // get the simple file system interface
848 Status
= gBS
->OpenProtocol(DeviceHandle
,
849 &gEfiSimpleFileSystemProtocolGuid
,
850 (VOID
**)&SimpleFileSystem
,
853 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
854 if (EFI_ERROR(Status
)) {
855 return (EFI_NOT_FOUND
);
858 Status
= gBS
->OpenProtocol(DeviceHandle
,
859 &gEfiDevicePathProtocolGuid
,
863 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
864 if (EFI_ERROR(Status
)) {
865 return (EFI_NOT_FOUND
);
868 // Open the root volume now...
870 Status
= SimpleFileSystem
->OpenVolume(SimpleFileSystem
, &RealFileHandle
);
871 *FileHandle
= ConvertEfiFileProtocolToShellHandle(RealFileHandle
, EfiShellGetMapFromDevicePath(&DevPath
));
876 Opens the root directory of a device.
878 This function opens the root directory of a device and returns a file handle to it.
880 @param DevicePath Points to the device path corresponding to the device where the
881 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL is installed.
882 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
885 @retval EFI_SUCCESS Root opened successfully.
886 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
888 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
889 @retval EFI_DEVICE_ERROR The device had an error
890 @retval EFI_INVALID_PARAMETER FileHandle is NULL.
895 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
896 OUT SHELL_FILE_HANDLE
*FileHandle
902 if (FileHandle
== NULL
) {
903 return (EFI_INVALID_PARAMETER
);
907 // find the handle of the device with that device handle and the file system
910 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
,
913 if (EFI_ERROR(Status
)) {
914 return (EFI_NOT_FOUND
);
917 return (EfiShellOpenRootByHandle(Handle
, FileHandle
));
921 Returns whether any script files are currently being processed.
923 @retval TRUE There is at least one script file active.
924 @retval FALSE No script files are active now.
929 EfiShellBatchIsActive (
933 if (ShellCommandGetCurrentScriptFile() == NULL
) {
940 Worker function to open a file based on a device path. this will open the root
941 of the volume and then traverse down to the file itself.
943 @param DevicePath Device Path of the file.
944 @param FileHandle Pointer to the file upon a successful return.
945 @param OpenMode mode to open file in.
946 @param Attributes the File Attributes to use when creating a new file.
948 @retval EFI_SUCCESS the file is open and FileHandle is valid
949 @retval EFI_UNSUPPORTED the device path cotained non-path elements
950 @retval other an error ocurred.
954 InternalOpenFileDevicePath(
955 IN OUT EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
956 OUT SHELL_FILE_HANDLE
*FileHandle
,
958 IN UINT64 Attributes OPTIONAL
962 FILEPATH_DEVICE_PATH
*FilePathNode
;
964 SHELL_FILE_HANDLE ShellHandle
;
965 EFI_FILE_PROTOCOL
*Handle1
;
966 EFI_FILE_PROTOCOL
*Handle2
;
967 FILEPATH_DEVICE_PATH
*AlignedNode
;
969 if (FileHandle
== NULL
) {
970 return (EFI_INVALID_PARAMETER
);
980 Status
= EfiShellOpenRoot(DevicePath
, &ShellHandle
);
982 if (!EFI_ERROR(Status
)) {
983 Handle1
= ConvertShellHandleToEfiFileProtocol(ShellHandle
);
984 if (Handle1
!= NULL
) {
986 // chop off the begining part before the file system part...
989 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
,
992 if (!EFI_ERROR(Status
)) {
994 // To access as a file system, the file path should only
995 // contain file path components. Follow the file path nodes
996 // and find the target file
998 for ( FilePathNode
= (FILEPATH_DEVICE_PATH
*)DevicePath
999 ; !IsDevicePathEnd (&FilePathNode
->Header
)
1000 ; FilePathNode
= (FILEPATH_DEVICE_PATH
*) NextDevicePathNode (&FilePathNode
->Header
)
1002 SHELL_FREE_NON_NULL(AlignedNode
);
1003 AlignedNode
= AllocateCopyPool (DevicePathNodeLength(FilePathNode
), FilePathNode
);
1005 // For file system access each node should be a file path component
1007 if (DevicePathType (&FilePathNode
->Header
) != MEDIA_DEVICE_PATH
||
1008 DevicePathSubType (&FilePathNode
->Header
) != MEDIA_FILEPATH_DP
1010 Status
= EFI_UNSUPPORTED
;
1015 // Open this file path node
1021 // if this is the last node in the DevicePath always create (if that was requested).
1023 if (IsDevicePathEnd ((NextDevicePathNode (&FilePathNode
->Header
)))) {
1024 Status
= Handle2
->Open (
1027 AlignedNode
->PathName
,
1034 // This is not the last node and we dont want to 'create' existing
1035 // directory entries...
1039 // open without letting it create
1040 // prevents error on existing files/directories
1042 Status
= Handle2
->Open (
1045 AlignedNode
->PathName
,
1046 OpenMode
&~EFI_FILE_MODE_CREATE
,
1050 // if above failed now open and create the 'item'
1051 // if OpenMode EFI_FILE_MODE_CREATE bit was on (but disabled above)
1053 if ((EFI_ERROR (Status
)) && ((OpenMode
& EFI_FILE_MODE_CREATE
) != 0)) {
1054 Status
= Handle2
->Open (
1057 AlignedNode
->PathName
,
1064 // Close the last node
1066 ShellInfoObject
.NewEfiShellProtocol
->CloseFile (Handle2
);
1069 // If there's been an error, stop
1071 if (EFI_ERROR (Status
)) {
1078 SHELL_FREE_NON_NULL(AlignedNode
);
1079 if (EFI_ERROR(Status
)) {
1080 if (Handle1
!= NULL
) {
1081 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(Handle1
);
1084 *FileHandle
= ConvertEfiFileProtocolToShellHandle(Handle1
, ShellFileHandleGetPath(ShellHandle
));
1090 Creates a file or directory by name.
1092 This function creates an empty new file or directory with the specified attributes and
1093 returns the new file's handle. If the file already exists and is read-only, then
1094 EFI_INVALID_PARAMETER will be returned.
1096 If the file already existed, it is truncated and its attributes updated. If the file is
1097 created successfully, the FileHandle is the file's handle, else, the FileHandle is NULL.
1099 If the file name begins with >v, then the file handle which is returned refers to the
1100 shell environment variable with the specified name. If the shell environment variable
1101 already exists and is non-volatile then EFI_INVALID_PARAMETER is returned.
1103 @param FileName Pointer to NULL-terminated file path
1104 @param FileAttribs The new file's attrbiutes. the different attributes are
1105 described in EFI_FILE_PROTOCOL.Open().
1106 @param FileHandle On return, points to the created file handle or directory's handle
1108 @retval EFI_SUCCESS The file was opened. FileHandle points to the new file's handle.
1109 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1110 @retval EFI_UNSUPPORTED could not open the file path
1111 @retval EFI_NOT_FOUND the specified file could not be found on the devide, or could not
1112 file the file system on the device.
1113 @retval EFI_NO_MEDIA the device has no medium.
1114 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1116 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1118 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1119 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1120 when the media is write-protected.
1121 @retval EFI_ACCESS_DENIED The service denied access to the file.
1122 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file.
1123 @retval EFI_VOLUME_FULL The volume is full.
1128 IN CONST CHAR16
*FileName
,
1129 IN UINT64 FileAttribs
,
1130 OUT SHELL_FILE_HANDLE
*FileHandle
1133 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1138 // Is this for an environment variable
1139 // do we start with >v
1141 if (StrStr(FileName
, L
">v") == FileName
) {
1142 Status
= IsVolatileEnv (FileName
+ 2, &Volatile
);
1143 if (EFI_ERROR (Status
)) {
1147 return (EFI_INVALID_PARAMETER
);
1149 *FileHandle
= CreateFileInterfaceEnv(FileName
+2);
1150 return (EFI_SUCCESS
);
1154 // We are opening a regular file.
1156 DevicePath
= EfiShellGetDevicePathFromFilePath(FileName
);
1157 if (DevicePath
== NULL
) {
1158 return (EFI_NOT_FOUND
);
1161 Status
= InternalOpenFileDevicePath(DevicePath
, FileHandle
, EFI_FILE_MODE_READ
|EFI_FILE_MODE_WRITE
|EFI_FILE_MODE_CREATE
, FileAttribs
);
1162 FreePool(DevicePath
);
1168 Register a GUID and a localized human readable name for it.
1170 If Guid is not assigned a name, then assign GuidName to Guid. This list of GUID
1171 names must be used whenever a shell command outputs GUID information.
1173 This function is only available when the major and minor versions in the
1174 EfiShellProtocol are greater than or equal to 2 and 1, respectively.
1176 @param[in] Guid A pointer to the GUID being registered.
1177 @param[in] GuidName A pointer to the localized name for the GUID being registered.
1179 @retval EFI_SUCCESS The operation was successful.
1180 @retval EFI_INVALID_PARAMETER Guid was NULL.
1181 @retval EFI_INVALID_PARAMETER GuidName was NULL.
1182 @retval EFI_ACCESS_DENIED Guid already is assigned a name.
1186 EfiShellRegisterGuidName(
1187 IN CONST EFI_GUID
*Guid
,
1188 IN CONST CHAR16
*GuidName
1191 return (AddNewGuidNameMapping(Guid
, GuidName
, NULL
));
1195 Opens a file or a directory by file name.
1197 This function opens the specified file in the specified OpenMode and returns a file
1199 If the file name begins with >v, then the file handle which is returned refers to the
1200 shell environment variable with the specified name. If the shell environment variable
1201 exists, is non-volatile and the OpenMode indicates EFI_FILE_MODE_WRITE, then
1202 EFI_INVALID_PARAMETER is returned.
1204 If the file name is >i, then the file handle which is returned refers to the standard
1205 input. If the OpenMode indicates EFI_FILE_MODE_WRITE, then EFI_INVALID_PARAMETER
1208 If the file name is >o, then the file handle which is returned refers to the standard
1209 output. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1212 If the file name is >e, then the file handle which is returned refers to the standard
1213 error. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1216 If the file name is NUL, then the file handle that is returned refers to the standard NUL
1217 file. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER is
1220 If return EFI_SUCCESS, the FileHandle is the opened file's handle, else, the
1223 @param FileName Points to the NULL-terminated UCS-2 encoded file name.
1224 @param FileHandle On return, points to the file handle.
1225 @param OpenMode File open mode. Either EFI_FILE_MODE_READ or
1226 EFI_FILE_MODE_WRITE from section 12.4 of the UEFI
1228 @retval EFI_SUCCESS The file was opened. FileHandle has the opened file's handle.
1229 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value. FileHandle is NULL.
1230 @retval EFI_UNSUPPORTED Could not open the file path. FileHandle is NULL.
1231 @retval EFI_NOT_FOUND The specified file could not be found on the device or the file
1232 system could not be found on the device. FileHandle is NULL.
1233 @retval EFI_NO_MEDIA The device has no medium. FileHandle is NULL.
1234 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1235 longer supported. FileHandle is NULL.
1236 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1237 the FileName. FileHandle is NULL.
1238 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted. FileHandle is NULL.
1239 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1240 when the media is write-protected. FileHandle is NULL.
1241 @retval EFI_ACCESS_DENIED The service denied access to the file. FileHandle is NULL.
1242 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file. FileHandle
1244 @retval EFI_VOLUME_FULL The volume is full. FileHandle is NULL.
1248 EfiShellOpenFileByName(
1249 IN CONST CHAR16
*FileName
,
1250 OUT SHELL_FILE_HANDLE
*FileHandle
,
1254 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1261 // Is this for StdIn
1263 if (StrCmp(FileName
, L
">i") == 0) {
1265 // make sure not writing to StdIn
1267 if ((OpenMode
& EFI_FILE_MODE_WRITE
) != 0) {
1268 return (EFI_INVALID_PARAMETER
);
1270 *FileHandle
= ShellInfoObject
.NewShellParametersProtocol
->StdIn
;
1271 ASSERT(*FileHandle
!= NULL
);
1272 return (EFI_SUCCESS
);
1276 // Is this for StdOut
1278 if (StrCmp(FileName
, L
">o") == 0) {
1280 // make sure not writing to StdIn
1282 if ((OpenMode
& EFI_FILE_MODE_READ
) != 0) {
1283 return (EFI_INVALID_PARAMETER
);
1285 *FileHandle
= &FileInterfaceStdOut
;
1286 return (EFI_SUCCESS
);
1290 // Is this for NUL file
1292 if (StrCmp(FileName
, L
"NUL") == 0) {
1293 *FileHandle
= &FileInterfaceNulFile
;
1294 return (EFI_SUCCESS
);
1298 // Is this for StdErr
1300 if (StrCmp(FileName
, L
">e") == 0) {
1302 // make sure not writing to StdIn
1304 if ((OpenMode
& EFI_FILE_MODE_READ
) != 0) {
1305 return (EFI_INVALID_PARAMETER
);
1307 *FileHandle
= &FileInterfaceStdErr
;
1308 return (EFI_SUCCESS
);
1312 // Is this for an environment variable
1313 // do we start with >v
1315 if (StrStr(FileName
, L
">v") == FileName
) {
1316 Status
= IsVolatileEnv (FileName
+ 2, &Volatile
);
1317 if (EFI_ERROR (Status
)) {
1321 ((OpenMode
& EFI_FILE_MODE_WRITE
) != 0)) {
1322 return (EFI_INVALID_PARAMETER
);
1324 *FileHandle
= CreateFileInterfaceEnv(FileName
+2);
1325 return (EFI_SUCCESS
);
1329 // We are opening a regular file.
1331 DevicePath
= EfiShellGetDevicePathFromFilePath(FileName
);
1332 // DEBUG_CODE(InternalShellProtocolDebugPrintMessage (NULL, DevicePath););
1333 if (DevicePath
== NULL
) {
1334 return (EFI_NOT_FOUND
);
1338 // Copy the device path, open the file, then free the memory
1340 Status
= InternalOpenFileDevicePath(DevicePath
, FileHandle
, OpenMode
, 0); // 0 = no specific file attributes
1341 FreePool(DevicePath
);
1347 Deletes the file specified by the file name.
1349 This function deletes a file.
1351 @param FileName Points to the NULL-terminated file name.
1353 @retval EFI_SUCCESS The file was closed and deleted, and the handle was closed.
1354 @retval EFI_WARN_DELETE_FAILURE The handle was closed but the file was not deleted.
1355 @sa EfiShellCreateFile
1359 EfiShellDeleteFileByName(
1360 IN CONST CHAR16
*FileName
1363 SHELL_FILE_HANDLE FileHandle
;
1369 // get a handle to the file
1371 Status
= EfiShellCreateFile(FileName
,
1374 if (EFI_ERROR(Status
)) {
1378 // now delete the file
1380 ShellFileHandleRemove(FileHandle
);
1381 return (ShellInfoObject
.NewEfiShellProtocol
->DeleteFile(FileHandle
));
1385 Disables the page break output mode.
1389 EfiShellDisablePageBreak (
1393 ShellInfoObject
.PageBreakEnabled
= FALSE
;
1397 Enables the page break output mode.
1401 EfiShellEnablePageBreak (
1405 ShellInfoObject
.PageBreakEnabled
= TRUE
;
1409 internal worker function to load and run an image via device path.
1411 @param ParentImageHandle A handle of the image that is executing the specified
1413 @param DevicePath device path of the file to execute
1414 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1415 containing the command line. If NULL then the command-
1417 @param Environment Points to a NULL-terminated array of environment
1418 variables with the format 'x=y', where x is the
1419 environment variable name and y is the value. If this
1420 is NULL, then the current shell environment is used.
1422 @param[out] StartImageStatus Returned status from gBS->StartImage.
1424 @retval EFI_SUCCESS The command executed successfully. The status code
1425 returned by the command is pointed to by StatusCode.
1426 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1427 @retval EFI_OUT_OF_RESOURCES Out of resources.
1428 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1432 InternalShellExecuteDevicePath(
1433 IN CONST EFI_HANDLE
*ParentImageHandle
,
1434 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
1435 IN CONST CHAR16
*CommandLine OPTIONAL
,
1436 IN CONST CHAR16
**Environment OPTIONAL
,
1437 OUT EFI_STATUS
*StartImageStatus OPTIONAL
1441 EFI_STATUS StartStatus
;
1442 EFI_STATUS CleanupStatus
;
1443 EFI_HANDLE NewHandle
;
1444 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
1445 LIST_ENTRY OrigEnvs
;
1446 EFI_SHELL_PARAMETERS_PROTOCOL ShellParamsProtocol
;
1452 if (ParentImageHandle
== NULL
) {
1453 return (EFI_INVALID_PARAMETER
);
1456 InitializeListHead(&OrigEnvs
);
1457 ZeroMem(&ShellParamsProtocol
, sizeof(EFI_SHELL_PARAMETERS_PROTOCOL
));
1461 NewCmdLine
= AllocateCopyPool (StrSize (CommandLine
), CommandLine
);
1462 if (NewCmdLine
== NULL
) {
1463 return EFI_OUT_OF_RESOURCES
;
1466 for (Walker
= NewCmdLine
; Walker
!= NULL
&& *Walker
!= CHAR_NULL
; Walker
++) {
1467 if (*Walker
== L
'^' && *(Walker
+1) == L
'#') {
1468 CopyMem(Walker
, Walker
+1, StrSize(Walker
) - sizeof(Walker
[0]));
1473 // Load the image with:
1474 // FALSE - not from boot manager and NULL, 0 being not already in memory
1476 Status
= gBS
->LoadImage(
1479 (EFI_DEVICE_PATH_PROTOCOL
*)DevicePath
,
1484 if (EFI_ERROR(Status
)) {
1485 if (NewHandle
!= NULL
) {
1486 gBS
->UnloadImage(NewHandle
);
1488 FreePool (NewCmdLine
);
1491 Status
= gBS
->OpenProtocol(
1493 &gEfiLoadedImageProtocolGuid
,
1494 (VOID
**)&LoadedImage
,
1497 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
1499 if (!EFI_ERROR(Status
)) {
1501 // If the image is not an app abort it.
1503 if (LoadedImage
->ImageCodeType
!= EfiLoaderCode
){
1508 STRING_TOKEN (STR_SHELL_IMAGE_NOT_APP
),
1509 ShellInfoObject
.HiiHandle
1514 ASSERT(LoadedImage
->LoadOptionsSize
== 0);
1515 if (NewCmdLine
!= NULL
) {
1516 LoadedImage
->LoadOptionsSize
= (UINT32
)StrSize(NewCmdLine
);
1517 LoadedImage
->LoadOptions
= (VOID
*)NewCmdLine
;
1521 // Save our current environment settings for later restoration if necessary
1523 if (Environment
!= NULL
) {
1524 Status
= GetEnvironmentVariableList(&OrigEnvs
);
1525 if (!EFI_ERROR(Status
)) {
1526 Status
= SetEnvironmentVariables(Environment
);
1531 // Initialize and install a shell parameters protocol on the image.
1533 ShellParamsProtocol
.StdIn
= ShellInfoObject
.NewShellParametersProtocol
->StdIn
;
1534 ShellParamsProtocol
.StdOut
= ShellInfoObject
.NewShellParametersProtocol
->StdOut
;
1535 ShellParamsProtocol
.StdErr
= ShellInfoObject
.NewShellParametersProtocol
->StdErr
;
1536 Status
= UpdateArgcArgv(&ShellParamsProtocol
, NewCmdLine
, Efi_Application
, NULL
, NULL
);
1537 ASSERT_EFI_ERROR(Status
);
1539 // Replace Argv[0] with the full path of the binary we're executing:
1540 // If the command line was "foo", the binary might be called "foo.efi".
1541 // "The first entry in [Argv] is always the full file path of the
1542 // executable" - UEFI Shell Spec section 2.3
1544 ImagePath
= EfiShellGetFilePathFromDevicePath (DevicePath
);
1545 // The image we're executing isn't necessarily in a filesystem - it might
1546 // be memory mapped. In this case EfiShellGetFilePathFromDevicePath will
1547 // return NULL, and we'll leave Argv[0] as UpdateArgcArgv set it.
1548 if (ImagePath
!= NULL
) {
1549 if (ShellParamsProtocol
.Argv
== NULL
) {
1550 // Command line was empty or null.
1551 // (UpdateArgcArgv sets Argv to NULL when CommandLine is "" or NULL)
1552 ShellParamsProtocol
.Argv
= AllocatePool (sizeof (CHAR16
*));
1553 if (ShellParamsProtocol
.Argv
== NULL
) {
1554 Status
= EFI_OUT_OF_RESOURCES
;
1557 ShellParamsProtocol
.Argc
= 1;
1559 // Free the string UpdateArgcArgv put in Argv[0];
1560 FreePool (ShellParamsProtocol
.Argv
[0]);
1562 ShellParamsProtocol
.Argv
[0] = ImagePath
;
1565 Status
= gBS
->InstallProtocolInterface(&NewHandle
, &gEfiShellParametersProtocolGuid
, EFI_NATIVE_INTERFACE
, &ShellParamsProtocol
);
1566 ASSERT_EFI_ERROR(Status
);
1568 ///@todo initialize and install ShellInterface protocol on the new image for compatibility if - PcdGetBool(PcdShellSupportOldProtocols)
1571 // now start the image and if the caller wanted the return code pass it to them...
1573 if (!EFI_ERROR(Status
)) {
1574 StartStatus
= gBS
->StartImage(
1579 if (StartImageStatus
!= NULL
) {
1580 *StartImageStatus
= StartStatus
;
1583 CleanupStatus
= gBS
->UninstallProtocolInterface(
1585 &gEfiShellParametersProtocolGuid
,
1586 &ShellParamsProtocol
1588 ASSERT_EFI_ERROR(CleanupStatus
);
1594 // Unload image - We should only get here if we didn't call StartImage
1595 gBS
->UnloadImage (NewHandle
);
1598 // Free Argv (Allocated in UpdateArgcArgv)
1599 if (ShellParamsProtocol
.Argv
!= NULL
) {
1600 for (Index
= 0; Index
< ShellParamsProtocol
.Argc
; Index
++) {
1601 if (ShellParamsProtocol
.Argv
[Index
] != NULL
) {
1602 FreePool (ShellParamsProtocol
.Argv
[Index
]);
1605 FreePool (ShellParamsProtocol
.Argv
);
1609 // Restore environment variables
1610 if (!IsListEmpty(&OrigEnvs
)) {
1611 CleanupStatus
= SetEnvironmentVariableList(&OrigEnvs
);
1612 ASSERT_EFI_ERROR (CleanupStatus
);
1615 FreePool (NewCmdLine
);
1621 internal worker function to load and run an image in the current shell.
1623 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1624 containing the command line. If NULL then the command-
1626 @param Environment Points to a NULL-terminated array of environment
1627 variables with the format 'x=y', where x is the
1628 environment variable name and y is the value. If this
1629 is NULL, then the current shell environment is used.
1631 @param[out] StartImageStatus Returned status from the command line.
1633 @retval EFI_SUCCESS The command executed successfully. The status code
1634 returned by the command is pointed to by StatusCode.
1635 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1636 @retval EFI_OUT_OF_RESOURCES Out of resources.
1637 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1641 InternalShellExecute(
1642 IN CONST CHAR16
*CommandLine OPTIONAL
,
1643 IN CONST CHAR16
**Environment OPTIONAL
,
1644 OUT EFI_STATUS
*StartImageStatus OPTIONAL
1648 EFI_STATUS CleanupStatus
;
1649 LIST_ENTRY OrigEnvs
;
1651 InitializeListHead(&OrigEnvs
);
1654 // Save our current environment settings for later restoration if necessary
1656 if (Environment
!= NULL
) {
1657 Status
= GetEnvironmentVariableList(&OrigEnvs
);
1658 if (!EFI_ERROR(Status
)) {
1659 Status
= SetEnvironmentVariables(Environment
);
1665 Status
= RunShellCommand(CommandLine
, StartImageStatus
);
1667 // Restore environment variables
1668 if (!IsListEmpty(&OrigEnvs
)) {
1669 CleanupStatus
= SetEnvironmentVariableList(&OrigEnvs
);
1670 ASSERT_EFI_ERROR (CleanupStatus
);
1677 Determine if the UEFI Shell is currently running with nesting enabled or disabled.
1679 @retval FALSE nesting is required
1680 @retval other nesting is enabled
1698 if (ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoNest
) {
1701 Status
= SHELL_GET_ENVIRONMENT_VARIABLE(mNoNestingEnvVarName
, &TempSize
, Temp
);
1702 if (Status
== EFI_BUFFER_TOO_SMALL
) {
1703 Temp
= AllocateZeroPool(TempSize
+ sizeof(CHAR16
));
1705 Status
= SHELL_GET_ENVIRONMENT_VARIABLE(mNoNestingEnvVarName
, &TempSize
, Temp
);
1708 Temp2
= StrnCatGrow(&Temp2
, NULL
, mNoNestingTrue
, 0);
1709 if (Temp
!= NULL
&& Temp2
!= NULL
&& StringNoCaseCompare(&Temp
, &Temp2
) == 0) {
1711 // Use the no nesting method.
1717 SHELL_FREE_NON_NULL(Temp
);
1718 SHELL_FREE_NON_NULL(Temp2
);
1723 Execute the command line.
1725 This function creates a nested instance of the shell and executes the specified
1726 command (CommandLine) with the specified environment (Environment). Upon return,
1727 the status code returned by the specified command is placed in StatusCode.
1729 If Environment is NULL, then the current environment is used and all changes made
1730 by the commands executed will be reflected in the current environment. If the
1731 Environment is non-NULL, then the changes made will be discarded.
1733 The CommandLine is executed from the current working directory on the current
1736 @param ParentImageHandle A handle of the image that is executing the specified
1738 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1739 containing the command line. If NULL then the command-
1741 @param Environment Points to a NULL-terminated array of environment
1742 variables with the format 'x=y', where x is the
1743 environment variable name and y is the value. If this
1744 is NULL, then the current shell environment is used.
1745 @param StatusCode Points to the status code returned by the CommandLine.
1747 @retval EFI_SUCCESS The command executed successfully. The status code
1748 returned by the command is pointed to by StatusCode.
1749 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1750 @retval EFI_OUT_OF_RESOURCES Out of resources.
1751 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1752 @retval EFI_UNSUPPORTED The support level required for this function is not present.
1754 @sa InternalShellExecuteDevicePath
1759 IN EFI_HANDLE
*ParentImageHandle
,
1760 IN CHAR16
*CommandLine OPTIONAL
,
1761 IN CHAR16
**Environment OPTIONAL
,
1762 OUT EFI_STATUS
*StatusCode OPTIONAL
1767 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
1770 if ((PcdGet8(PcdShellSupportLevel
) < 1)) {
1771 return (EFI_UNSUPPORTED
);
1774 if (NestingEnabled()) {
1775 DevPath
= AppendDevicePath (ShellInfoObject
.ImageDevPath
, ShellInfoObject
.FileDevPath
);
1778 Temp
= ConvertDevicePathToText(ShellInfoObject
.FileDevPath
, TRUE
, TRUE
);
1780 Temp
= ConvertDevicePathToText(ShellInfoObject
.ImageDevPath
, TRUE
, TRUE
);
1782 Temp
= ConvertDevicePathToText(DevPath
, TRUE
, TRUE
);
1788 ASSERT((Temp
== NULL
&& Size
== 0) || (Temp
!= NULL
));
1789 StrnCatGrow(&Temp
, &Size
, L
"Shell.efi -_exit ", 0);
1790 StrnCatGrow(&Temp
, &Size
, CommandLine
, 0);
1792 Status
= InternalShellExecuteDevicePath(
1796 (CONST CHAR16
**)Environment
,
1800 // de-allocate and return
1805 Status
= InternalShellExecute(
1806 (CONST CHAR16
*)CommandLine
,
1807 (CONST CHAR16
**)Environment
,
1815 Utility cleanup function for EFI_SHELL_FILE_INFO objects.
1817 1) frees all pointers (non-NULL)
1818 2) Closes the SHELL_FILE_HANDLE
1820 @param FileListNode pointer to the list node to free
1824 InternalFreeShellFileInfoNode(
1825 IN EFI_SHELL_FILE_INFO
*FileListNode
1828 if (FileListNode
->Info
!= NULL
) {
1829 FreePool((VOID
*)FileListNode
->Info
);
1831 if (FileListNode
->FileName
!= NULL
) {
1832 FreePool((VOID
*)FileListNode
->FileName
);
1834 if (FileListNode
->FullName
!= NULL
) {
1835 FreePool((VOID
*)FileListNode
->FullName
);
1837 if (FileListNode
->Handle
!= NULL
) {
1838 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(FileListNode
->Handle
);
1840 FreePool(FileListNode
);
1843 Frees the file list.
1845 This function cleans up the file list and any related data structures. It has no
1846 impact on the files themselves.
1848 @param FileList The file list to free. Type EFI_SHELL_FILE_INFO is
1849 defined in OpenFileList()
1851 @retval EFI_SUCCESS Free the file list successfully.
1852 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1856 EfiShellFreeFileList(
1857 IN EFI_SHELL_FILE_INFO
**FileList
1860 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1862 if (FileList
== NULL
|| *FileList
== NULL
) {
1863 return (EFI_INVALID_PARAMETER
);
1866 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1867 ; !IsListEmpty(&(*FileList
)->Link
)
1868 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1870 RemoveEntryList(&ShellFileListItem
->Link
);
1871 InternalFreeShellFileInfoNode(ShellFileListItem
);
1873 InternalFreeShellFileInfoNode(*FileList
);
1875 return(EFI_SUCCESS
);
1879 Deletes the duplicate file names files in the given file list.
1881 This function deletes the reduplicate files in the given file list.
1883 @param FileList A pointer to the first entry in the file list.
1885 @retval EFI_SUCCESS Always success.
1886 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1890 EfiShellRemoveDupInFileList(
1891 IN EFI_SHELL_FILE_INFO
**FileList
1894 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1895 EFI_SHELL_FILE_INFO
*ShellFileListItem2
;
1896 EFI_SHELL_FILE_INFO
*TempNode
;
1898 if (FileList
== NULL
|| *FileList
== NULL
) {
1899 return (EFI_INVALID_PARAMETER
);
1901 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1902 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1903 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1905 for ( ShellFileListItem2
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1906 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem2
->Link
)
1907 ; ShellFileListItem2
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem2
->Link
)
1909 if (gUnicodeCollation
->StriColl(
1911 (CHAR16
*)ShellFileListItem
->FullName
,
1912 (CHAR16
*)ShellFileListItem2
->FullName
) == 0
1914 TempNode
= (EFI_SHELL_FILE_INFO
*)GetPreviousNode(
1916 &ShellFileListItem2
->Link
1918 RemoveEntryList(&ShellFileListItem2
->Link
);
1919 InternalFreeShellFileInfoNode(ShellFileListItem2
);
1920 // Set ShellFileListItem2 to PreviousNode so we don't access Freed
1921 // memory in GetNextNode in the loop expression above.
1922 ShellFileListItem2
= TempNode
;
1926 return (EFI_SUCCESS
);
1930 // This is the same structure as the external version, but it has no CONST qualifiers.
1933 LIST_ENTRY Link
; ///< Linked list members.
1934 EFI_STATUS Status
; ///< Status of opening the file. Valid only if Handle != NULL.
1935 CHAR16
*FullName
; ///< Fully qualified filename.
1936 CHAR16
*FileName
; ///< name of this file.
1937 SHELL_FILE_HANDLE Handle
; ///< Handle for interacting with the opened file or NULL if closed.
1938 EFI_FILE_INFO
*Info
; ///< Pointer to the FileInfo struct for this file or NULL.
1939 } EFI_SHELL_FILE_INFO_NO_CONST
;
1942 Allocates and duplicates a EFI_SHELL_FILE_INFO node.
1944 @param[in] Node The node to copy from.
1945 @param[in] Save TRUE to set Node->Handle to NULL, FALSE otherwise.
1947 @retval NULL a memory allocation error ocurred
1948 @return != NULL a pointer to the new node
1950 EFI_SHELL_FILE_INFO
*
1952 InternalDuplicateShellFileInfo(
1953 IN EFI_SHELL_FILE_INFO
*Node
,
1957 EFI_SHELL_FILE_INFO_NO_CONST
*NewNode
;
1960 // try to confirm that the objects are in sync
1962 ASSERT(sizeof(EFI_SHELL_FILE_INFO_NO_CONST
) == sizeof(EFI_SHELL_FILE_INFO
));
1964 NewNode
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1965 if (NewNode
== NULL
) {
1968 NewNode
->FullName
= AllocateCopyPool(StrSize(Node
->FullName
), Node
->FullName
);
1969 NewNode
->FileName
= AllocateCopyPool(StrSize(Node
->FileName
), Node
->FileName
);
1970 NewNode
->Info
= AllocateCopyPool((UINTN
)Node
->Info
->Size
, Node
->Info
);
1971 if ( NewNode
->FullName
== NULL
1972 || NewNode
->FileName
== NULL
1973 || NewNode
->Info
== NULL
1975 SHELL_FREE_NON_NULL(NewNode
->FullName
);
1976 SHELL_FREE_NON_NULL(NewNode
->FileName
);
1977 SHELL_FREE_NON_NULL(NewNode
->Info
);
1978 SHELL_FREE_NON_NULL(NewNode
);
1981 NewNode
->Status
= Node
->Status
;
1982 NewNode
->Handle
= Node
->Handle
;
1984 Node
->Handle
= NULL
;
1987 return((EFI_SHELL_FILE_INFO
*)NewNode
);
1991 Allocates and populates a EFI_SHELL_FILE_INFO structure. if any memory operation
1992 failed it will return NULL.
1994 @param[in] BasePath the Path to prepend onto filename for FullPath
1995 @param[in] Status Status member initial value.
1996 @param[in] FileName FileName member initial value.
1997 @param[in] Handle Handle member initial value.
1998 @param[in] Info Info struct to copy.
2000 @retval NULL An error ocurred.
2001 @return a pointer to the newly allocated structure.
2003 EFI_SHELL_FILE_INFO
*
2005 CreateAndPopulateShellFileInfo(
2006 IN CONST CHAR16
*BasePath
,
2007 IN CONST EFI_STATUS Status
,
2008 IN CONST CHAR16
*FileName
,
2009 IN CONST SHELL_FILE_HANDLE Handle
,
2010 IN CONST EFI_FILE_INFO
*Info
2013 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
2020 ShellFileListItem
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2021 if (ShellFileListItem
== NULL
) {
2024 if (Info
!= NULL
&& Info
->Size
!= 0) {
2025 ShellFileListItem
->Info
= AllocateZeroPool((UINTN
)Info
->Size
);
2026 if (ShellFileListItem
->Info
== NULL
) {
2027 FreePool(ShellFileListItem
);
2030 CopyMem(ShellFileListItem
->Info
, Info
, (UINTN
)Info
->Size
);
2032 ShellFileListItem
->Info
= NULL
;
2034 if (FileName
!= NULL
) {
2035 ASSERT(TempString
== NULL
);
2036 ShellFileListItem
->FileName
= StrnCatGrow(&TempString
, 0, FileName
, 0);
2037 if (ShellFileListItem
->FileName
== NULL
) {
2038 FreePool(ShellFileListItem
->Info
);
2039 FreePool(ShellFileListItem
);
2043 ShellFileListItem
->FileName
= NULL
;
2047 if (BasePath
!= NULL
) {
2048 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
2049 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
2050 if (TempString
== NULL
) {
2051 FreePool((VOID
*)ShellFileListItem
->FileName
);
2052 SHELL_FREE_NON_NULL(ShellFileListItem
->Info
);
2053 FreePool(ShellFileListItem
);
2057 if (ShellFileListItem
->FileName
!= NULL
) {
2058 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
2059 TempString
= StrnCatGrow(&TempString
, &Size
, ShellFileListItem
->FileName
, 0);
2060 if (TempString
== NULL
) {
2061 FreePool((VOID
*)ShellFileListItem
->FileName
);
2062 FreePool(ShellFileListItem
->Info
);
2063 FreePool(ShellFileListItem
);
2068 TempString
= PathCleanUpDirectories(TempString
);
2070 ShellFileListItem
->FullName
= TempString
;
2071 ShellFileListItem
->Status
= Status
;
2072 ShellFileListItem
->Handle
= Handle
;
2074 return (ShellFileListItem
);
2078 Find all files in a specified directory.
2080 @param FileDirHandle Handle of the directory to search.
2081 @param FileList On return, points to the list of files in the directory
2082 or NULL if there are no files in the directory.
2084 @retval EFI_SUCCESS File information was returned successfully.
2085 @retval EFI_VOLUME_CORRUPTED The file system structures have been corrupted.
2086 @retval EFI_DEVICE_ERROR The device reported an error.
2087 @retval EFI_NO_MEDIA The device media is not present.
2088 @retval EFI_INVALID_PARAMETER The FileDirHandle was not a directory.
2089 @return An error from FileHandleGetFileName().
2093 EfiShellFindFilesInDir(
2094 IN SHELL_FILE_HANDLE FileDirHandle
,
2095 OUT EFI_SHELL_FILE_INFO
**FileList
2098 EFI_SHELL_FILE_INFO
*ShellFileList
;
2099 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
2100 EFI_FILE_INFO
*FileInfo
;
2109 Status
= FileHandleGetFileName(FileDirHandle
, &BasePath
);
2110 if (EFI_ERROR(Status
)) {
2114 if (ShellFileHandleGetPath(FileDirHandle
) != NULL
) {
2117 TempString
= StrnCatGrow(&TempString
, &Size
, ShellFileHandleGetPath(FileDirHandle
), 0);
2118 if (TempString
== NULL
) {
2119 SHELL_FREE_NON_NULL(BasePath
);
2120 return (EFI_OUT_OF_RESOURCES
);
2122 TempSpot
= StrStr(TempString
, L
";");
2124 if (TempSpot
!= NULL
) {
2125 *TempSpot
= CHAR_NULL
;
2128 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
2129 if (TempString
== NULL
) {
2130 SHELL_FREE_NON_NULL(BasePath
);
2131 return (EFI_OUT_OF_RESOURCES
);
2133 SHELL_FREE_NON_NULL(BasePath
);
2134 BasePath
= TempString
;
2138 ShellFileList
= NULL
;
2139 ShellFileListItem
= NULL
;
2141 Status
= EFI_SUCCESS
;
2144 for ( Status
= FileHandleFindFirstFile(FileDirHandle
, &FileInfo
)
2145 ; !EFI_ERROR(Status
) && !NoFile
2146 ; Status
= FileHandleFindNextFile(FileDirHandle
, FileInfo
, &NoFile
)
2148 if (ShellFileList
== NULL
) {
2149 ShellFileList
= (EFI_SHELL_FILE_INFO
*)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2150 if (ShellFileList
== NULL
) {
2151 SHELL_FREE_NON_NULL (BasePath
);
2152 return EFI_OUT_OF_RESOURCES
;
2154 InitializeListHead(&ShellFileList
->Link
);
2157 // allocate a new EFI_SHELL_FILE_INFO and populate it...
2159 ShellFileListItem
= CreateAndPopulateShellFileInfo(
2161 EFI_SUCCESS
, // success since we didnt fail to open it...
2163 NULL
, // no handle since not open
2165 if (ShellFileListItem
== NULL
) {
2166 Status
= EFI_OUT_OF_RESOURCES
;
2168 // Free resources outside the loop.
2172 InsertTailList(&ShellFileList
->Link
, &ShellFileListItem
->Link
);
2174 if (EFI_ERROR(Status
)) {
2175 EfiShellFreeFileList(&ShellFileList
);
2178 *FileList
= ShellFileList
;
2180 SHELL_FREE_NON_NULL(BasePath
);
2185 Get the GUID value from a human readable name.
2187 If GuidName is a known GUID name, then update Guid to have the correct value for
2190 This function is only available when the major and minor versions in the
2191 EfiShellProtocol are greater than or equal to 2 and 1, respectively.
2193 @param[in] GuidName A pointer to the localized name for the GUID being queried.
2194 @param[out] Guid A pointer to the GUID structure to be filled in.
2196 @retval EFI_SUCCESS The operation was successful.
2197 @retval EFI_INVALID_PARAMETER Guid was NULL.
2198 @retval EFI_INVALID_PARAMETER GuidName was NULL.
2199 @retval EFI_NOT_FOUND GuidName is not a known GUID Name.
2203 EfiShellGetGuidFromName(
2204 IN CONST CHAR16
*GuidName
,
2211 if (Guid
== NULL
|| GuidName
== NULL
) {
2212 return (EFI_INVALID_PARAMETER
);
2215 Status
= GetGuidFromStringName(GuidName
, NULL
, &NewGuid
);
2217 if (!EFI_ERROR(Status
)) {
2218 CopyGuid(NewGuid
, Guid
);
2225 Get the human readable name for a GUID from the value.
2227 If Guid is assigned a name, then update *GuidName to point to the name. The callee
2228 should not modify the value.
2230 This function is only available when the major and minor versions in the
2231 EfiShellProtocol are greater than or equal to 2 and 1, respectively.
2233 @param[in] Guid A pointer to the GUID being queried.
2234 @param[out] GuidName A pointer to a pointer the localized to name for the GUID being requested
2236 @retval EFI_SUCCESS The operation was successful.
2237 @retval EFI_INVALID_PARAMETER Guid was NULL.
2238 @retval EFI_INVALID_PARAMETER GuidName was NULL.
2239 @retval EFI_NOT_FOUND Guid is not assigned a name.
2243 EfiShellGetGuidName(
2244 IN CONST EFI_GUID
*Guid
,
2245 OUT CONST CHAR16
**GuidName
2250 if (Guid
== NULL
|| GuidName
== NULL
) {
2251 return (EFI_INVALID_PARAMETER
);
2254 Name
= GetStringNameFromGuid(Guid
, NULL
);
2255 if (Name
== NULL
|| StrLen(Name
) == 0) {
2256 SHELL_FREE_NON_NULL(Name
);
2257 return (EFI_NOT_FOUND
);
2260 *GuidName
= AddBufferToFreeList(Name
);
2262 return (EFI_SUCCESS
);
2266 Updates a file name to be preceeded by the mapped drive name
2268 @param[in] BasePath the Mapped drive name to prepend
2269 @param[in, out] Path pointer to pointer to the file name to update.
2272 @retval EFI_OUT_OF_RESOURCES
2277 IN CONST CHAR16
*BasePath
,
2278 IN OUT CHAR16
**Path
2287 ASSERT(Path
!= NULL
);
2288 ASSERT(*Path
!= NULL
);
2289 ASSERT(BasePath
!= NULL
);
2292 // convert a local path to an absolute path
2294 if (StrStr(*Path
, L
":") == NULL
) {
2295 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2296 StrnCatGrow(&Path2
, &Path2Size
, BasePath
, 0);
2297 if (Path2
== NULL
) {
2298 return (EFI_OUT_OF_RESOURCES
);
2300 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2301 StrnCatGrow(&Path2
, &Path2Size
, (*Path
)[0] == L
'\\'?(*Path
) + 1 :*Path
, 0);
2302 if (Path2
== NULL
) {
2303 return (EFI_OUT_OF_RESOURCES
);
2310 return (EFI_SUCCESS
);
2314 If FileHandle is a directory then the function reads from FileHandle and reads in
2315 each of the FileInfo structures. If one of them matches the Pattern's first
2316 "level" then it opens that handle and calls itself on that handle.
2318 If FileHandle is a file and matches all of the remaining Pattern (which would be
2319 on its last node), then add a EFI_SHELL_FILE_INFO object for this file to fileList.
2321 Upon a EFI_SUCCESS return fromt he function any the caller is responsible to call
2322 FreeFileList with FileList.
2324 @param[in] FilePattern The FilePattern to check against.
2325 @param[in] UnicodeCollation The pointer to EFI_UNICODE_COLLATION_PROTOCOL structure
2326 @param[in] FileHandle The FileHandle to start with
2327 @param[in, out] FileList pointer to pointer to list of found files.
2328 @param[in] ParentNode The node for the parent. Same file as identified by HANDLE.
2329 @param[in] MapName The file system name this file is on.
2331 @retval EFI_SUCCESS all files were found and the FileList contains a list.
2332 @retval EFI_NOT_FOUND no files were found
2333 @retval EFI_OUT_OF_RESOURCES a memory allocation failed
2338 IN CONST CHAR16
*FilePattern
,
2339 IN EFI_UNICODE_COLLATION_PROTOCOL
*UnicodeCollation
,
2340 IN SHELL_FILE_HANDLE FileHandle
,
2341 IN OUT EFI_SHELL_FILE_INFO
**FileList
,
2342 IN CONST EFI_SHELL_FILE_INFO
*ParentNode OPTIONAL
,
2343 IN CONST CHAR16
*MapName
2347 CONST CHAR16
*NextFilePatternStart
;
2348 CHAR16
*CurrentFilePattern
;
2349 EFI_SHELL_FILE_INFO
*ShellInfo
;
2350 EFI_SHELL_FILE_INFO
*ShellInfoNode
;
2351 EFI_SHELL_FILE_INFO
*NewShellNode
;
2352 EFI_FILE_INFO
*FileInfo
;
2354 CHAR16
*NewFullName
;
2357 if ( FilePattern
== NULL
2358 || UnicodeCollation
== NULL
2361 return (EFI_INVALID_PARAMETER
);
2364 CurrentFilePattern
= NULL
;
2366 if (*FilePattern
== L
'\\') {
2370 for( NextFilePatternStart
= FilePattern
2371 ; *NextFilePatternStart
!= CHAR_NULL
&& *NextFilePatternStart
!= L
'\\'
2372 ; NextFilePatternStart
++);
2374 CurrentFilePattern
= AllocateZeroPool((NextFilePatternStart
-FilePattern
+1)*sizeof(CHAR16
));
2375 if (CurrentFilePattern
== NULL
) {
2376 return EFI_OUT_OF_RESOURCES
;
2379 StrnCpyS(CurrentFilePattern
, NextFilePatternStart
-FilePattern
+1, FilePattern
, NextFilePatternStart
-FilePattern
);
2381 if (CurrentFilePattern
[0] == CHAR_NULL
2382 &&NextFilePatternStart
[0] == CHAR_NULL
2385 // we want the parent or root node (if no parent)
2387 if (ParentNode
== NULL
) {
2389 // We want the root node. create the node.
2391 FileInfo
= FileHandleGetInfo(FileHandle
);
2392 NewShellNode
= CreateAndPopulateShellFileInfo(
2399 SHELL_FREE_NON_NULL(FileInfo
);
2402 // Add the current parameter FileHandle to the list, then end...
2404 NewShellNode
= InternalDuplicateShellFileInfo((EFI_SHELL_FILE_INFO
*)ParentNode
, TRUE
);
2406 if (NewShellNode
== NULL
) {
2407 Status
= EFI_OUT_OF_RESOURCES
;
2409 NewShellNode
->Handle
= NULL
;
2410 if (*FileList
== NULL
) {
2411 *FileList
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2412 InitializeListHead(&((*FileList
)->Link
));
2416 // Add to the returning to use list
2418 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
2420 Status
= EFI_SUCCESS
;
2423 Status
= EfiShellFindFilesInDir(FileHandle
, &ShellInfo
);
2425 if (!EFI_ERROR(Status
)){
2426 if (StrStr(NextFilePatternStart
, L
"\\") != NULL
){
2431 for ( ShellInfoNode
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&ShellInfo
->Link
)
2432 ; !IsNull (&ShellInfo
->Link
, &ShellInfoNode
->Link
)
2433 ; ShellInfoNode
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&ShellInfo
->Link
, &ShellInfoNode
->Link
)
2435 if (UnicodeCollation
->MetaiMatch(UnicodeCollation
, (CHAR16
*)ShellInfoNode
->FileName
, CurrentFilePattern
)){
2436 if (ShellInfoNode
->FullName
!= NULL
&& StrStr(ShellInfoNode
->FullName
, L
":") == NULL
) {
2437 Size
= StrSize (ShellInfoNode
->FullName
) + StrSize (MapName
);
2438 NewFullName
= AllocateZeroPool(Size
);
2439 if (NewFullName
== NULL
) {
2440 Status
= EFI_OUT_OF_RESOURCES
;
2442 StrCpyS(NewFullName
, Size
/ sizeof(CHAR16
), MapName
);
2443 StrCatS(NewFullName
, Size
/ sizeof(CHAR16
), ShellInfoNode
->FullName
);
2444 FreePool ((VOID
*) ShellInfoNode
->FullName
);
2445 ShellInfoNode
->FullName
= NewFullName
;
2448 if (Directory
&& !EFI_ERROR(Status
) && ShellInfoNode
->FullName
!= NULL
&& ShellInfoNode
->FileName
!= NULL
){
2450 // should be a directory
2454 // don't open the . and .. directories
2456 if ( (StrCmp(ShellInfoNode
->FileName
, L
".") != 0)
2457 && (StrCmp(ShellInfoNode
->FileName
, L
"..") != 0)
2462 if (EFI_ERROR(Status
)) {
2466 // Open the directory since we need that handle in the next recursion.
2468 ShellInfoNode
->Status
= EfiShellOpenFileByName (ShellInfoNode
->FullName
, &ShellInfoNode
->Handle
, EFI_FILE_MODE_READ
);
2471 // recurse with the next part of the pattern
2473 Status
= ShellSearchHandle(NextFilePatternStart
, UnicodeCollation
, ShellInfoNode
->Handle
, FileList
, ShellInfoNode
, MapName
);
2474 EfiShellClose(ShellInfoNode
->Handle
);
2475 ShellInfoNode
->Handle
= NULL
;
2477 } else if (!EFI_ERROR(Status
)) {
2483 // copy the information we need into a new Node
2485 NewShellNode
= InternalDuplicateShellFileInfo(ShellInfoNode
, FALSE
);
2486 if (NewShellNode
== NULL
) {
2487 Status
= EFI_OUT_OF_RESOURCES
;
2489 if (*FileList
== NULL
) {
2490 *FileList
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2491 InitializeListHead(&((*FileList
)->Link
));
2495 // Add to the returning to use list
2497 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
2500 if (EFI_ERROR(Status
)) {
2504 if (EFI_ERROR(Status
)) {
2505 EfiShellFreeFileList(&ShellInfo
);
2507 Status
= EfiShellFreeFileList(&ShellInfo
);
2512 FreePool(CurrentFilePattern
);
2517 Find files that match a specified pattern.
2519 This function searches for all files and directories that match the specified
2520 FilePattern. The FilePattern can contain wild-card characters. The resulting file
2521 information is placed in the file list FileList.
2523 Wildcards are processed
2524 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1.
2526 The files in the file list are not opened. The OpenMode field is set to 0 and the FileInfo
2527 field is set to NULL.
2529 if *FileList is not NULL then it must be a pre-existing and properly initialized list.
2531 @param FilePattern Points to a NULL-terminated shell file path, including wildcards.
2532 @param FileList On return, points to the start of a file list containing the names
2533 of all matching files or else points to NULL if no matching files
2534 were found. only on a EFI_SUCCESS return will; this be non-NULL.
2536 @retval EFI_SUCCESS Files found. FileList is a valid list.
2537 @retval EFI_NOT_FOUND No files found.
2538 @retval EFI_NO_MEDIA The device has no media
2539 @retval EFI_DEVICE_ERROR The device reported an error
2540 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted
2545 IN CONST CHAR16
*FilePattern
,
2546 OUT EFI_SHELL_FILE_INFO
**FileList
2550 CHAR16
*PatternCopy
;
2551 CHAR16
*PatternCurrentLocation
;
2552 EFI_DEVICE_PATH_PROTOCOL
*RootDevicePath
;
2553 SHELL_FILE_HANDLE RootFileHandle
;
2557 if ( FilePattern
== NULL
2559 || StrStr(FilePattern
, L
":") == NULL
2561 return (EFI_INVALID_PARAMETER
);
2563 Status
= EFI_SUCCESS
;
2564 RootDevicePath
= NULL
;
2565 RootFileHandle
= NULL
;
2567 PatternCopy
= AllocateCopyPool(StrSize(FilePattern
), FilePattern
);
2568 if (PatternCopy
== NULL
) {
2569 return (EFI_OUT_OF_RESOURCES
);
2572 PatternCopy
= PathCleanUpDirectories(PatternCopy
);
2574 Count
= StrStr(PatternCopy
, L
":") - PatternCopy
+ 1;
2575 ASSERT (Count
<= StrLen (PatternCopy
));
2577 ASSERT(MapName
== NULL
);
2578 MapName
= StrnCatGrow(&MapName
, NULL
, PatternCopy
, Count
);
2579 if (MapName
== NULL
) {
2580 Status
= EFI_OUT_OF_RESOURCES
;
2582 RootDevicePath
= EfiShellGetDevicePathFromFilePath(PatternCopy
);
2583 if (RootDevicePath
== NULL
) {
2584 Status
= EFI_INVALID_PARAMETER
;
2586 Status
= EfiShellOpenRoot(RootDevicePath
, &RootFileHandle
);
2587 if (!EFI_ERROR(Status
)) {
2588 for ( PatternCurrentLocation
= PatternCopy
2589 ; *PatternCurrentLocation
!= ':'
2590 ; PatternCurrentLocation
++);
2591 PatternCurrentLocation
++;
2592 Status
= ShellSearchHandle(PatternCurrentLocation
, gUnicodeCollation
, RootFileHandle
, FileList
, NULL
, MapName
);
2593 EfiShellClose(RootFileHandle
);
2595 FreePool(RootDevicePath
);
2599 SHELL_FREE_NON_NULL(PatternCopy
);
2600 SHELL_FREE_NON_NULL(MapName
);
2606 Opens the files that match the path specified.
2608 This function opens all of the files specified by Path. Wildcards are processed
2609 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1. Each
2610 matching file has an EFI_SHELL_FILE_INFO structure created in a linked list.
2612 @param Path A pointer to the path string.
2613 @param OpenMode Specifies the mode used to open each file, EFI_FILE_MODE_READ or
2614 EFI_FILE_MODE_WRITE.
2615 @param FileList Points to the start of a list of files opened.
2617 @retval EFI_SUCCESS Create the file list successfully.
2618 @return Others Can't create the file list.
2622 EfiShellOpenFileList(
2625 IN OUT EFI_SHELL_FILE_INFO
**FileList
2629 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
2632 CONST CHAR16
*CurDir
;
2635 PathCleanUpDirectories(Path
);
2640 if (FileList
== NULL
|| *FileList
== NULL
) {
2641 return (EFI_INVALID_PARAMETER
);
2644 if (*Path
== L
'.' && *(Path
+1) == L
'\\') {
2649 // convert a local path to an absolute path
2651 if (StrStr(Path
, L
":") == NULL
) {
2652 CurDir
= EfiShellGetCurDir(NULL
);
2653 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2654 StrnCatGrow(&Path2
, &Path2Size
, CurDir
, 0);
2655 StrnCatGrow(&Path2
, &Path2Size
, L
"\\", 0);
2656 if (*Path
== L
'\\') {
2658 while (PathRemoveLastItem(Path2
)) ;
2660 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2661 StrnCatGrow(&Path2
, &Path2Size
, Path
, 0);
2663 ASSERT(Path2
== NULL
);
2664 StrnCatGrow(&Path2
, NULL
, Path
, 0);
2667 PathCleanUpDirectories (Path2
);
2672 Status
= EfiShellFindFiles(Path2
, FileList
);
2676 if (EFI_ERROR(Status
)) {
2682 // We had no errors so open all the files (that are not already opened...)
2684 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
2685 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2686 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2688 if (ShellFileListItem
->Status
== 0 && ShellFileListItem
->Handle
== NULL
) {
2689 ShellFileListItem
->Status
= EfiShellOpenFileByName (ShellFileListItem
->FullName
, &ShellFileListItem
->Handle
, OpenMode
);
2695 return (EFI_NOT_FOUND
);
2697 return(EFI_SUCCESS
);
2701 Gets the environment variable and Attributes, or list of environment variables. Can be
2702 used instead of GetEnv().
2704 This function returns the current value of the specified environment variable and
2705 the Attributes. If no variable name was specified, then all of the known
2706 variables will be returned.
2708 @param[in] Name A pointer to the environment variable name. If Name is NULL,
2709 then the function will return all of the defined shell
2710 environment variables. In the case where multiple environment
2711 variables are being returned, each variable will be terminated
2712 by a NULL, and the list will be terminated by a double NULL.
2713 @param[out] Attributes If not NULL, a pointer to the returned attributes bitmask for
2714 the environment variable. In the case where Name is NULL, and
2715 multiple environment variables are being returned, Attributes
2718 @retval NULL The environment variable doesn't exist.
2719 @return A non-NULL value points to the variable's value. The returned
2720 pointer does not need to be freed by the caller.
2725 IN CONST CHAR16
*Name
,
2726 OUT UINT32
*Attributes OPTIONAL
2733 CHAR16
*CurrentWriteLocation
;
2741 // Build the semi-colon delimited list. (2 passes)
2743 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&gShellEnvVarList
.Link
)
2744 ; !IsNull(&gShellEnvVarList
.Link
, &Node
->Link
)
2745 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&gShellEnvVarList
.Link
, &Node
->Link
)
2747 ASSERT(Node
->Key
!= NULL
);
2748 Size
+= StrSize(Node
->Key
);
2751 Size
+= 2*sizeof(CHAR16
);
2753 Buffer
= AllocateZeroPool(Size
);
2754 if (Buffer
== NULL
) {
2757 CurrentWriteLocation
= (CHAR16
*)Buffer
;
2759 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&gShellEnvVarList
.Link
)
2760 ; !IsNull(&gShellEnvVarList
.Link
, &Node
->Link
)
2761 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&gShellEnvVarList
.Link
, &Node
->Link
)
2763 ASSERT(Node
->Key
!= NULL
);
2764 StrCpyS( CurrentWriteLocation
,
2765 (Size
)/sizeof(CHAR16
) - (CurrentWriteLocation
- ((CHAR16
*)Buffer
)),
2768 CurrentWriteLocation
+= StrLen(CurrentWriteLocation
) + 1;
2773 // We are doing a specific environment variable
2775 Status
= ShellFindEnvVarInList(Name
, (CHAR16
**)&Buffer
, &Size
, Attributes
);
2777 if (EFI_ERROR(Status
)){
2779 // get the size we need for this EnvVariable
2781 Status
= SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(Name
, Attributes
, &Size
, Buffer
);
2782 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2784 // Allocate the space and recall the get function
2786 Buffer
= AllocateZeroPool(Size
);
2787 Status
= SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(Name
, Attributes
, &Size
, Buffer
);
2790 // we didnt get it (might not exist)
2791 // free the memory if we allocated any and return NULL
2793 if (EFI_ERROR(Status
)) {
2794 if (Buffer
!= NULL
) {
2800 // If we did not find the environment variable in the gShellEnvVarList
2801 // but get it from UEFI variable storage successfully then we need update
2802 // the gShellEnvVarList.
2804 ShellFreeEnvVarList ();
2805 Status
= ShellInitEnvVarList ();
2806 ASSERT (Status
== EFI_SUCCESS
);
2812 // return the buffer
2814 return (AddBufferToFreeList(Buffer
));
2818 Gets either a single or list of environment variables.
2820 If name is not NULL then this function returns the current value of the specified
2821 environment variable.
2823 If Name is NULL, then a list of all environment variable names is returned. Each is a
2824 NULL terminated string with a double NULL terminating the list.
2826 @param Name A pointer to the environment variable name. If
2827 Name is NULL, then the function will return all
2828 of the defined shell environment variables. In
2829 the case where multiple environment variables are
2830 being returned, each variable will be terminated by
2831 a NULL, and the list will be terminated by a double
2834 @retval !=NULL A pointer to the returned string.
2835 The returned pointer does not need to be freed by the caller.
2837 @retval NULL The environment variable doesn't exist or there are
2838 no environment variables.
2843 IN CONST CHAR16
*Name
2846 return (EfiShellGetEnvEx(Name
, NULL
));
2850 Internal variable setting function. Allows for setting of the read only variables.
2852 @param Name Points to the NULL-terminated environment variable name.
2853 @param Value Points to the NULL-terminated environment variable value. If the value is an
2854 empty string then the environment variable is deleted.
2855 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2857 @retval EFI_SUCCESS The environment variable was successfully updated.
2861 InternalEfiShellSetEnv(
2862 IN CONST CHAR16
*Name
,
2863 IN CONST CHAR16
*Value
,
2869 if (Value
== NULL
|| StrLen(Value
) == 0) {
2870 Status
= SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
);
2871 if (!EFI_ERROR(Status
)) {
2872 ShellRemvoeEnvVarFromList(Name
);
2875 SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
);
2876 Status
= ShellAddEnvVarToList(
2877 Name
, Value
, StrSize(Value
),
2878 EFI_VARIABLE_BOOTSERVICE_ACCESS
| (Volatile
? 0 : EFI_VARIABLE_NON_VOLATILE
)
2880 if (!EFI_ERROR (Status
)) {
2882 ? SHELL_SET_ENVIRONMENT_VARIABLE_V(Name
, StrSize(Value
), Value
)
2883 : SHELL_SET_ENVIRONMENT_VARIABLE_NV(Name
, StrSize(Value
), Value
);
2884 if (EFI_ERROR (Status
)) {
2885 ShellRemvoeEnvVarFromList(Name
);
2893 Sets the environment variable.
2895 This function changes the current value of the specified environment variable. If the
2896 environment variable exists and the Value is an empty string, then the environment
2897 variable is deleted. If the environment variable exists and the Value is not an empty
2898 string, then the value of the environment variable is changed. If the environment
2899 variable does not exist and the Value is an empty string, there is no action. If the
2900 environment variable does not exist and the Value is a non-empty string, then the
2901 environment variable is created and assigned the specified value.
2903 For a description of volatile and non-volatile environment variables, see UEFI Shell
2904 2.0 specification section 3.6.1.
2906 @param Name Points to the NULL-terminated environment variable name.
2907 @param Value Points to the NULL-terminated environment variable value. If the value is an
2908 empty string then the environment variable is deleted.
2909 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2911 @retval EFI_SUCCESS The environment variable was successfully updated.
2916 IN CONST CHAR16
*Name
,
2917 IN CONST CHAR16
*Value
,
2921 if (Name
== NULL
|| *Name
== CHAR_NULL
) {
2922 return (EFI_INVALID_PARAMETER
);
2925 // Make sure we dont 'set' a predefined read only variable
2927 if (gUnicodeCollation
->StriColl(
2931 ||gUnicodeCollation
->StriColl(
2935 ||gUnicodeCollation
->StriColl(
2939 ||gUnicodeCollation
->StriColl(
2942 L
"uefishellsupport") == 0
2943 ||gUnicodeCollation
->StriColl(
2946 L
"uefishellversion") == 0
2947 ||gUnicodeCollation
->StriColl(
2950 L
"uefiversion") == 0
2951 ||(!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoNest
&&
2952 gUnicodeCollation
->StriColl(
2955 (CHAR16
*)mNoNestingEnvVarName
) == 0)
2957 return (EFI_INVALID_PARAMETER
);
2959 return (InternalEfiShellSetEnv(Name
, Value
, Volatile
));
2963 Returns the current directory on the specified device.
2965 If FileSystemMapping is NULL, it returns the current working directory. If the
2966 FileSystemMapping is not NULL, it returns the current directory associated with the
2967 FileSystemMapping. In both cases, the returned name includes the file system
2968 mapping (i.e. fs0:\current-dir).
2970 Note that the current directory string should exclude the tailing backslash character.
2972 @param FileSystemMapping A pointer to the file system mapping. If NULL,
2973 then the current working directory is returned.
2975 @retval !=NULL The current directory.
2976 @retval NULL Current directory does not exist.
2981 IN CONST CHAR16
*FileSystemMapping OPTIONAL
2984 CHAR16
*PathToReturn
;
2986 SHELL_MAP_LIST
*MapListItem
;
2987 if (!IsListEmpty(&gShellMapList
.Link
)) {
2989 // if parameter is NULL, use current
2991 if (FileSystemMapping
== NULL
) {
2992 return (EfiShellGetEnv(L
"cwd"));
2995 PathToReturn
= NULL
;
2996 MapListItem
= ShellCommandFindMapItem(FileSystemMapping
);
2997 if (MapListItem
!= NULL
) {
2998 ASSERT((PathToReturn
== NULL
&& Size
== 0) || (PathToReturn
!= NULL
));
2999 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->MapName
, 0);
3000 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
3003 return (AddBufferToFreeList(PathToReturn
));
3010 Changes the current directory on the specified device.
3012 If the FileSystem is NULL, and the directory Dir does not contain a file system's
3013 mapped name, this function changes the current working directory.
3015 If the FileSystem is NULL and the directory Dir contains a mapped name, then the
3016 current file system and the current directory on that file system are changed.
3018 If FileSystem is NULL, and Dir is not NULL, then this changes the current working file
3021 If FileSystem is not NULL and Dir is not NULL, then this function changes the current
3022 directory on the specified file system.
3024 If the current working directory or the current working file system is changed then the
3025 %cwd% environment variable will be updated
3027 Note that the current directory string should exclude the tailing backslash character.
3029 @param FileSystem A pointer to the file system's mapped name. If NULL, then the current working
3030 directory is changed.
3031 @param Dir Points to the NULL-terminated directory on the device specified by FileSystem.
3033 @retval EFI_SUCCESS The operation was sucessful
3034 @retval EFI_NOT_FOUND The file system could not be found
3039 IN CONST CHAR16
*FileSystem OPTIONAL
,
3040 IN CONST CHAR16
*Dir
3044 SHELL_MAP_LIST
*MapListItem
;
3048 CHAR16
*DirectoryName
;
3055 DirectoryName
= NULL
;
3057 if ((FileSystem
== NULL
&& Dir
== NULL
) || Dir
== NULL
) {
3058 return (EFI_INVALID_PARAMETER
);
3061 if (IsListEmpty(&gShellMapList
.Link
)){
3062 return (EFI_NOT_FOUND
);
3065 DirectoryName
= StrnCatGrow(&DirectoryName
, NULL
, Dir
, 0);
3066 ASSERT(DirectoryName
!= NULL
);
3068 PathCleanUpDirectories(DirectoryName
);
3070 if (FileSystem
== NULL
) {
3072 // determine the file system mapping to use
3074 if (StrStr(DirectoryName
, L
":") != NULL
) {
3075 ASSERT(MapName
== NULL
);
3076 MapName
= StrnCatGrow(&MapName
, NULL
, DirectoryName
, (StrStr(DirectoryName
, L
":")-DirectoryName
+1));
3079 // find the file system mapping's entry in the list
3082 if (MapName
!= NULL
) {
3083 MapListItem
= ShellCommandFindMapItem(MapName
);
3086 // make that the current file system mapping
3088 if (MapListItem
!= NULL
) {
3089 gShellCurDir
= MapListItem
;
3092 MapListItem
= gShellCurDir
;
3095 if (MapListItem
== NULL
) {
3096 FreePool (DirectoryName
);
3097 SHELL_FREE_NON_NULL(MapName
);
3098 return (EFI_NOT_FOUND
);
3102 // now update the MapListItem's current directory
3104 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& DirectoryName
[StrLen(DirectoryName
) - 1] != L
':') {
3105 FreePool(MapListItem
->CurrentDirectoryPath
);
3106 MapListItem
->CurrentDirectoryPath
= NULL
;
3108 if (MapName
!= NULL
) {
3109 TempLen
= StrLen(MapName
);
3110 if (TempLen
!= StrLen(DirectoryName
)) {
3111 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3112 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
+StrLen(MapName
), 0);
3116 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3117 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
3119 if ((MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] == L
'\\') || (MapListItem
->CurrentDirectoryPath
== NULL
)) {
3120 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3121 if (MapListItem
->CurrentDirectoryPath
!= NULL
) {
3122 MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] = CHAR_NULL
;
3127 // cant have a mapping in the directory...
3129 if (StrStr(DirectoryName
, L
":") != NULL
) {
3130 FreePool (DirectoryName
);
3131 return (EFI_INVALID_PARAMETER
);
3134 // FileSystem != NULL
3136 MapListItem
= ShellCommandFindMapItem(FileSystem
);
3137 if (MapListItem
== NULL
) {
3138 FreePool (DirectoryName
);
3139 return (EFI_INVALID_PARAMETER
);
3141 // gShellCurDir = MapListItem;
3142 if (DirectoryName
!= NULL
) {
3144 // change current dir on that file system
3147 if (MapListItem
->CurrentDirectoryPath
!= NULL
) {
3148 FreePool(MapListItem
->CurrentDirectoryPath
);
3149 DEBUG_CODE(MapListItem
->CurrentDirectoryPath
= NULL
;);
3151 // ASSERT((MapListItem->CurrentDirectoryPath == NULL && Size == 0) || (MapListItem->CurrentDirectoryPath != NULL));
3152 // MapListItem->CurrentDirectoryPath = StrnCatGrow(&MapListItem->CurrentDirectoryPath, &Size, FileSystem, 0);
3153 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3154 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
3155 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3156 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
3157 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] == L
'\\') {
3158 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3159 MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] = CHAR_NULL
;
3163 FreePool (DirectoryName
);
3165 // if updated the current directory then update the environment variable
3167 if (MapListItem
== gShellCurDir
) {
3169 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
3170 StrnCatGrow(&TempString
, &Size
, MapListItem
->MapName
, 0);
3171 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
3172 StrnCatGrow(&TempString
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
3173 Status
= InternalEfiShellSetEnv(L
"cwd", TempString
, TRUE
);
3174 FreePool(TempString
);
3177 return(EFI_SUCCESS
);
3181 Return help information about a specific command.
3183 This function returns the help information for the specified command. The help text
3184 can be internal to the shell or can be from a UEFI Shell manual page.
3186 If Sections is specified, then each section name listed will be compared in a casesensitive
3187 manner, to the section names described in Appendix B. If the section exists,
3188 it will be appended to the returned help text. If the section does not exist, no
3189 information will be returned. If Sections is NULL, then all help text information
3190 available will be returned.
3192 @param Command Points to the NULL-terminated UEFI Shell command name.
3193 @param Sections Points to the NULL-terminated comma-delimited
3194 section names to return. If NULL, then all
3195 sections will be returned.
3196 @param HelpText On return, points to a callee-allocated buffer
3197 containing all specified help text.
3199 @retval EFI_SUCCESS The help text was returned.
3200 @retval EFI_OUT_OF_RESOURCES The necessary buffer could not be allocated to hold the
3202 @retval EFI_INVALID_PARAMETER HelpText is NULL
3203 @retval EFI_NOT_FOUND There is no help text available for Command.
3207 EfiShellGetHelpText(
3208 IN CONST CHAR16
*Command
,
3209 IN CONST CHAR16
*Sections OPTIONAL
,
3210 OUT CHAR16
**HelpText
3213 CONST CHAR16
*ManFileName
;
3217 ASSERT(HelpText
!= NULL
);
3220 ManFileName
= ShellCommandGetManFileNameHandler(Command
);
3222 if (ManFileName
!= NULL
) {
3223 return (ProcessManFile(ManFileName
, Command
, Sections
, NULL
, HelpText
));
3225 if ((StrLen(Command
)> 4)
3226 && (Command
[StrLen(Command
)-1] == L
'i' || Command
[StrLen(Command
)-1] == L
'I')
3227 && (Command
[StrLen(Command
)-2] == L
'f' || Command
[StrLen(Command
)-2] == L
'F')
3228 && (Command
[StrLen(Command
)-3] == L
'e' || Command
[StrLen(Command
)-3] == L
'E')
3229 && (Command
[StrLen(Command
)-4] == L
'.')
3231 FixCommand
= AllocateZeroPool(StrSize(Command
) - 4 * sizeof (CHAR16
));
3232 if (FixCommand
== NULL
) {
3233 return EFI_OUT_OF_RESOURCES
;
3236 StrnCpyS( FixCommand
,
3237 (StrSize(Command
) - 4 * sizeof (CHAR16
))/sizeof(CHAR16
),
3241 Status
= ProcessManFile(FixCommand
, FixCommand
, Sections
, NULL
, HelpText
);
3242 FreePool(FixCommand
);
3245 return (ProcessManFile(Command
, Command
, Sections
, NULL
, HelpText
));
3251 Gets the enable status of the page break output mode.
3253 User can use this function to determine current page break mode.
3255 @retval TRUE The page break output mode is enabled.
3256 @retval FALSE The page break output mode is disabled.
3260 EfiShellGetPageBreak(
3264 return(ShellInfoObject
.PageBreakEnabled
);
3268 Judges whether the active shell is the root shell.
3270 This function makes the user to know that whether the active Shell is the root shell.
3272 @retval TRUE The active Shell is the root Shell.
3273 @retval FALSE The active Shell is NOT the root Shell.
3277 EfiShellIsRootShell(
3281 return(ShellInfoObject
.RootShellInstance
);
3285 function to return a semi-colon delimeted list of all alias' in the current shell
3287 up to caller to free the memory.
3289 @retval NULL No alias' were found
3290 @retval NULL An error ocurred getting alias'
3291 @return !NULL a list of all alias'
3295 InternalEfiShellGetListAlias(
3301 CHAR16
*VariableName
;
3303 UINTN NameBufferSize
;
3307 NameBufferSize
= INIT_NAME_BUFFER_SIZE
;
3308 VariableName
= AllocateZeroPool(NameBufferSize
);
3312 if (VariableName
== NULL
) {
3316 VariableName
[0] = CHAR_NULL
;
3319 NameSize
= NameBufferSize
;
3320 Status
= gRT
->GetNextVariableName(&NameSize
, VariableName
, &Guid
);
3321 if (Status
== EFI_NOT_FOUND
){
3323 } else if (Status
== EFI_BUFFER_TOO_SMALL
) {
3324 NameBufferSize
= NameSize
> NameBufferSize
* 2 ? NameSize
: NameBufferSize
* 2;
3325 SHELL_FREE_NON_NULL(VariableName
);
3326 VariableName
= AllocateZeroPool(NameBufferSize
);
3327 if (VariableName
== NULL
) {
3328 Status
= EFI_OUT_OF_RESOURCES
;
3329 SHELL_FREE_NON_NULL(RetVal
);
3334 NameSize
= NameBufferSize
;
3335 Status
= gRT
->GetNextVariableName(&NameSize
, VariableName
, &Guid
);
3338 if (EFI_ERROR (Status
)) {
3339 SHELL_FREE_NON_NULL(RetVal
);
3344 if (CompareGuid(&Guid
, &gShellAliasGuid
)){
3345 ASSERT((RetVal
== NULL
&& RetSize
== 0) || (RetVal
!= NULL
));
3346 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, VariableName
, 0);
3347 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, L
";", 0);
3350 SHELL_FREE_NON_NULL(VariableName
);
3356 Convert a null-terminated unicode string, in-place, to all lowercase.
3359 @param Str The null-terminated string to be converted to all lowercase.
3361 @return The null-terminated string converted into all lowercase.
3370 for (Index
= 0; Str
[Index
] != L
'\0'; Index
++) {
3371 if (Str
[Index
] >= L
'A' && Str
[Index
] <= L
'Z') {
3372 Str
[Index
] -= (CHAR16
)(L
'A' - L
'a');
3379 This function returns the command associated with a alias or a list of all
3382 @param[in] Alias Points to the NULL-terminated shell alias.
3383 If this parameter is NULL, then all
3384 aliases will be returned in ReturnedData.
3385 @param[out] Volatile upon return of a single command if TRUE indicates
3386 this is stored in a volatile fashion. FALSE otherwise.
3388 @return If Alias is not NULL, it will return a pointer to
3389 the NULL-terminated command for that alias.
3390 If Alias is NULL, ReturnedData points to a ';'
3391 delimited list of alias (e.g.
3392 ReturnedData = "dir;del;copy;mfp") that is NULL-terminated.
3393 @retval NULL an error ocurred
3394 @retval NULL Alias was not a valid Alias
3399 IN CONST CHAR16
*Alias
,
3400 OUT BOOLEAN
*Volatile OPTIONAL
3410 // Convert to lowercase to make aliases case-insensitive
3411 if (Alias
!= NULL
) {
3412 AliasLower
= AllocateCopyPool (StrSize (Alias
), Alias
);
3413 if (AliasLower
== NULL
) {
3416 ToLower (AliasLower
);
3418 if (Volatile
== NULL
) {
3419 GetVariable2 (AliasLower
, &gShellAliasGuid
, (VOID
**)&AliasVal
, NULL
);
3420 FreePool(AliasLower
);
3421 return (AddBufferToFreeList(AliasVal
));
3425 Status
= gRT
->GetVariable(AliasLower
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
3426 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3427 RetVal
= AllocateZeroPool(RetSize
);
3428 Status
= gRT
->GetVariable(AliasLower
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
3430 if (EFI_ERROR(Status
)) {
3431 if (RetVal
!= NULL
) {
3434 FreePool(AliasLower
);
3437 if ((EFI_VARIABLE_NON_VOLATILE
& Attribs
) == EFI_VARIABLE_NON_VOLATILE
) {
3443 FreePool (AliasLower
);
3444 return (AddBufferToFreeList(RetVal
));
3446 return (AddBufferToFreeList(InternalEfiShellGetListAlias()));
3450 Changes a shell command alias.
3452 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3454 this function does not check for built in alias'.
3456 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3457 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3458 Command refers to an alias, that alias will be deleted.
3459 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3460 Alias being set will be stored in a non-volatile fashion.
3462 @retval EFI_SUCCESS Alias created or deleted successfully.
3463 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3468 IN CONST CHAR16
*Command
,
3469 IN CONST CHAR16
*Alias
,
3476 // Convert to lowercase to make aliases case-insensitive
3477 if (Alias
!= NULL
) {
3478 AliasLower
= AllocateCopyPool (StrSize (Alias
), Alias
);
3479 if (AliasLower
== NULL
) {
3480 return EFI_OUT_OF_RESOURCES
;
3482 ToLower (AliasLower
);
3488 // We must be trying to remove one if Alias is NULL
3490 if (Alias
== NULL
) {
3492 // remove an alias (but passed in COMMAND parameter)
3494 Status
= (gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
));
3497 // Add and replace are the same
3500 // We dont check the error return on purpose since the variable may not exist.
3501 gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
);
3503 Status
= (gRT
->SetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, EFI_VARIABLE_BOOTSERVICE_ACCESS
|(Volatile
?0:EFI_VARIABLE_NON_VOLATILE
), StrSize(Command
), (VOID
*)Command
));
3506 if (Alias
!= NULL
) {
3507 FreePool (AliasLower
);
3513 Changes a shell command alias.
3515 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3518 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3519 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3520 Command refers to an alias, that alias will be deleted.
3521 @param[in] Replace If TRUE and the alias already exists, then the existing alias will be replaced. If
3522 FALSE and the alias already exists, then the existing alias is unchanged and
3523 EFI_ACCESS_DENIED is returned.
3524 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3525 Alias being set will be stored in a non-volatile fashion.
3527 @retval EFI_SUCCESS Alias created or deleted successfully.
3528 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3529 @retval EFI_ACCESS_DENIED The alias is a built-in alias or already existed and Replace was set to
3531 @retval EFI_INVALID_PARAMETER Command is null or the empty string.
3536 IN CONST CHAR16
*Command
,
3537 IN CONST CHAR16
*Alias
,
3542 if (ShellCommandIsOnAliasList(Alias
==NULL
?Command
:Alias
)) {
3544 // cant set over a built in alias
3546 return (EFI_ACCESS_DENIED
);
3547 } else if (Command
== NULL
|| *Command
== CHAR_NULL
|| StrLen(Command
) == 0) {
3549 // Command is null or empty
3551 return (EFI_INVALID_PARAMETER
);
3552 } else if (EfiShellGetAlias(Command
, NULL
) != NULL
&& !Replace
) {
3554 // Alias already exists, Replace not set
3556 return (EFI_ACCESS_DENIED
);
3558 return (InternalSetAlias(Command
, Alias
, Volatile
));
3562 // Pure FILE_HANDLE operations are passed to FileHandleLib
3563 // these functions are indicated by the *
3564 EFI_SHELL_PROTOCOL mShellProtocol
= {
3570 EfiShellGetHelpText
,
3571 EfiShellGetDevicePathFromMap
,
3572 EfiShellGetMapFromDevicePath
,
3573 EfiShellGetDevicePathFromFilePath
,
3574 EfiShellGetFilePathFromDevicePath
,
3578 EfiShellOpenFileList
,
3579 EfiShellFreeFileList
,
3580 EfiShellRemoveDupInFileList
,
3581 EfiShellBatchIsActive
,
3582 EfiShellIsRootShell
,
3583 EfiShellEnablePageBreak
,
3584 EfiShellDisablePageBreak
,
3585 EfiShellGetPageBreak
,
3586 EfiShellGetDeviceName
,
3587 (EFI_SHELL_GET_FILE_INFO
)FileHandleGetInfo
, //*
3588 (EFI_SHELL_SET_FILE_INFO
)FileHandleSetInfo
, //*
3589 EfiShellOpenFileByName
,
3592 (EFI_SHELL_READ_FILE
)FileHandleRead
, //*
3593 (EFI_SHELL_WRITE_FILE
)FileHandleWrite
, //*
3594 (EFI_SHELL_DELETE_FILE
)FileHandleDelete
, //*
3595 EfiShellDeleteFileByName
,
3596 (EFI_SHELL_GET_FILE_POSITION
)FileHandleGetPosition
, //*
3597 (EFI_SHELL_SET_FILE_POSITION
)FileHandleSetPosition
, //*
3598 (EFI_SHELL_FLUSH_FILE
)FileHandleFlush
, //*
3600 EfiShellFindFilesInDir
,
3601 (EFI_SHELL_GET_FILE_SIZE
)FileHandleGetSize
, //*
3603 EfiShellOpenRootByHandle
,
3605 SHELL_MAJOR_VERSION
,
3606 SHELL_MINOR_VERSION
,
3608 // New for UEFI Shell 2.1
3609 EfiShellRegisterGuidName
,
3610 EfiShellGetGuidName
,
3611 EfiShellGetGuidFromName
,
3616 Function to create and install on the current handle.
3618 Will overwrite any existing ShellProtocols in the system to be sure that
3619 the current shell is in control.
3621 This must be removed via calling CleanUpShellProtocol().
3623 @param[in, out] NewShell The pointer to the pointer to the structure
3626 @retval EFI_SUCCESS The operation was successful.
3627 @return An error from LocateHandle, CreateEvent, or other core function.
3631 CreatePopulateInstallShellProtocol (
3632 IN OUT EFI_SHELL_PROTOCOL
**NewShell
3638 UINTN HandleCounter
;
3639 SHELL_PROTOCOL_HANDLE_LIST
*OldProtocolNode
;
3640 EFI_SHELL_PROTOCOL
*OldShell
;
3642 if (NewShell
== NULL
) {
3643 return (EFI_INVALID_PARAMETER
);
3648 OldProtocolNode
= NULL
;
3649 InitializeListHead(&ShellInfoObject
.OldShellList
.Link
);
3652 // Initialize EfiShellProtocol object...
3654 Status
= gBS
->CreateEvent(0,
3658 &mShellProtocol
.ExecutionBreak
);
3659 if (EFI_ERROR(Status
)) {
3664 // Get the size of the buffer we need.
3666 Status
= gBS
->LocateHandle(ByProtocol
,
3667 &gEfiShellProtocolGuid
,
3671 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3673 // Allocate and recall with buffer of correct size
3675 Buffer
= AllocateZeroPool(BufferSize
);
3676 if (Buffer
== NULL
) {
3677 return (EFI_OUT_OF_RESOURCES
);
3679 Status
= gBS
->LocateHandle(ByProtocol
,
3680 &gEfiShellProtocolGuid
,
3684 if (EFI_ERROR(Status
)) {
3689 // now overwrite each of them, but save the info to restore when we end.
3691 for (HandleCounter
= 0 ; HandleCounter
< (BufferSize
/sizeof(EFI_HANDLE
)) ; HandleCounter
++) {
3692 Status
= gBS
->OpenProtocol(Buffer
[HandleCounter
],
3693 &gEfiShellProtocolGuid
,
3694 (VOID
**) &OldShell
,
3697 EFI_OPEN_PROTOCOL_GET_PROTOCOL
3699 if (!EFI_ERROR(Status
)) {
3700 OldProtocolNode
= AllocateZeroPool(sizeof(SHELL_PROTOCOL_HANDLE_LIST
));
3701 if (OldProtocolNode
== NULL
) {
3702 if (!IsListEmpty (&ShellInfoObject
.OldShellList
.Link
)) {
3703 CleanUpShellProtocol (&mShellProtocol
);
3705 Status
= EFI_OUT_OF_RESOURCES
;
3709 // reinstall over the old one...
3711 OldProtocolNode
->Handle
= Buffer
[HandleCounter
];
3712 OldProtocolNode
->Interface
= OldShell
;
3713 Status
= gBS
->ReinstallProtocolInterface(
3714 OldProtocolNode
->Handle
,
3715 &gEfiShellProtocolGuid
,
3716 OldProtocolNode
->Interface
,
3717 (VOID
*)(&mShellProtocol
));
3718 if (!EFI_ERROR(Status
)) {
3720 // we reinstalled sucessfully. log this so we can reverse it later.
3724 // add to the list for subsequent...
3726 InsertTailList(&ShellInfoObject
.OldShellList
.Link
, &OldProtocolNode
->Link
);
3731 } else if (Status
== EFI_NOT_FOUND
) {
3732 ASSERT(IsListEmpty(&ShellInfoObject
.OldShellList
.Link
));
3734 // no one else published yet. just publish it ourselves.
3736 Status
= gBS
->InstallProtocolInterface (
3738 &gEfiShellProtocolGuid
,
3739 EFI_NATIVE_INTERFACE
,
3740 (VOID
*)(&mShellProtocol
));
3743 if (PcdGetBool(PcdShellSupportOldProtocols
)){
3744 ///@todo support ShellEnvironment2
3745 ///@todo do we need to support ShellEnvironment (not ShellEnvironment2) also?
3748 if (!EFI_ERROR(Status
)) {
3749 *NewShell
= &mShellProtocol
;
3755 Opposite of CreatePopulateInstallShellProtocol.
3757 Free all memory and restore the system to the state it was in before calling
3758 CreatePopulateInstallShellProtocol.
3760 @param[in, out] NewShell The pointer to the new shell protocol structure.
3762 @retval EFI_SUCCESS The operation was successful.
3765 CleanUpShellProtocol (
3766 IN OUT EFI_SHELL_PROTOCOL
*NewShell
3769 SHELL_PROTOCOL_HANDLE_LIST
*Node2
;
3772 // if we need to restore old protocols...
3774 if (!IsListEmpty(&ShellInfoObject
.OldShellList
.Link
)) {
3775 for (Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*) GetFirstNode (&ShellInfoObject
.OldShellList
.Link
)
3776 ; !IsListEmpty (&ShellInfoObject
.OldShellList
.Link
)
3777 ; Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*) GetFirstNode (&ShellInfoObject
.OldShellList
.Link
)
3779 RemoveEntryList (&Node2
->Link
);
3780 gBS
->ReinstallProtocolInterface (Node2
->Handle
, &gEfiShellProtocolGuid
, NewShell
, Node2
->Interface
);
3785 // no need to restore
3787 gBS
->UninstallProtocolInterface (gImageHandle
, &gEfiShellProtocolGuid
, NewShell
);
3793 Cleanup the shell environment.
3795 @param[in, out] NewShell The pointer to the new shell protocol structure.
3797 @retval EFI_SUCCESS The operation was successful.
3800 CleanUpShellEnvironment (
3801 IN OUT EFI_SHELL_PROTOCOL
*NewShell
3805 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3807 CleanUpShellProtocol (NewShell
);
3809 Status
= gBS
->CloseEvent(NewShell
->ExecutionBreak
);
3810 NewShell
->ExecutionBreak
= NULL
;
3812 Status
= gBS
->OpenProtocol(
3813 gST
->ConsoleInHandle
,
3814 &gEfiSimpleTextInputExProtocolGuid
,
3818 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3820 if (!EFI_ERROR (Status
)) {
3821 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle1
);
3822 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle2
);
3823 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle3
);
3824 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle4
);
3825 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle1
);
3826 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle2
);
3827 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle3
);
3828 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle4
);
3834 Notification function for keystrokes.
3836 @param[in] KeyData The key that was pressed.
3838 @retval EFI_SUCCESS The operation was successful.
3842 NotificationFunction(
3843 IN EFI_KEY_DATA
*KeyData
3846 if ( ((KeyData
->Key
.UnicodeChar
== L
'c') &&
3847 (KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
) || KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
))) ||
3848 (KeyData
->Key
.UnicodeChar
== 3)
3850 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3851 return (EFI_UNSUPPORTED
);
3853 return (gBS
->SignalEvent(ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
));
3854 } else if ((KeyData
->Key
.UnicodeChar
== L
's') &&
3855 (KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
) || KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
))
3857 ShellInfoObject
.HaltOutput
= TRUE
;
3859 return (EFI_SUCCESS
);
3863 Function to start monitoring for CTRL-C using SimpleTextInputEx. This
3864 feature's enabled state was not known when the shell initially launched.
3866 @retval EFI_SUCCESS The feature is enabled.
3867 @retval EFI_OUT_OF_RESOURCES There is not enough mnemory available.
3871 InernalEfiShellStartMonitor(
3875 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3876 EFI_KEY_DATA KeyData
;
3879 Status
= gBS
->OpenProtocol(
3880 gST
->ConsoleInHandle
,
3881 &gEfiSimpleTextInputExProtocolGuid
,
3885 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3886 if (EFI_ERROR(Status
)) {
3891 STRING_TOKEN (STR_SHELL_NO_IN_EX
),
3892 ShellInfoObject
.HiiHandle
);
3893 return (EFI_SUCCESS
);
3896 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3897 return (EFI_UNSUPPORTED
);
3900 KeyData
.KeyState
.KeyToggleState
= 0;
3901 KeyData
.Key
.ScanCode
= 0;
3902 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3903 KeyData
.Key
.UnicodeChar
= L
'c';
3905 Status
= SimpleEx
->RegisterKeyNotify(
3908 NotificationFunction
,
3909 &ShellInfoObject
.CtrlCNotifyHandle1
);
3911 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3912 if (!EFI_ERROR(Status
)) {
3913 Status
= SimpleEx
->RegisterKeyNotify(
3916 NotificationFunction
,
3917 &ShellInfoObject
.CtrlCNotifyHandle2
);
3919 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3920 KeyData
.Key
.UnicodeChar
= 3;
3921 if (!EFI_ERROR(Status
)) {
3922 Status
= SimpleEx
->RegisterKeyNotify(
3925 NotificationFunction
,
3926 &ShellInfoObject
.CtrlCNotifyHandle3
);
3928 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3929 if (!EFI_ERROR(Status
)) {
3930 Status
= SimpleEx
->RegisterKeyNotify(
3933 NotificationFunction
,
3934 &ShellInfoObject
.CtrlCNotifyHandle4
);