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
);
2438 Size
+= StrSize(MapName
) + sizeof(CHAR16
);
2439 NewFullName
= AllocateZeroPool(Size
);
2440 if (NewFullName
== NULL
) {
2441 Status
= EFI_OUT_OF_RESOURCES
;
2443 StrCpyS(NewFullName
, Size
/sizeof(CHAR16
), MapName
);
2444 StrCatS(NewFullName
, Size
/sizeof(CHAR16
), ShellInfoNode
->FullName
+1);
2445 FreePool((VOID
*)ShellInfoNode
->FullName
);
2446 ShellInfoNode
->FullName
= NewFullName
;
2449 if (Directory
&& !EFI_ERROR(Status
) && ShellInfoNode
->FullName
!= NULL
&& ShellInfoNode
->FileName
!= NULL
){
2451 // should be a directory
2455 // don't open the . and .. directories
2457 if ( (StrCmp(ShellInfoNode
->FileName
, L
".") != 0)
2458 && (StrCmp(ShellInfoNode
->FileName
, L
"..") != 0)
2463 if (EFI_ERROR(Status
)) {
2467 // Open the directory since we need that handle in the next recursion.
2469 ShellInfoNode
->Status
= EfiShellOpenFileByName (ShellInfoNode
->FullName
, &ShellInfoNode
->Handle
, EFI_FILE_MODE_READ
);
2472 // recurse with the next part of the pattern
2474 Status
= ShellSearchHandle(NextFilePatternStart
, UnicodeCollation
, ShellInfoNode
->Handle
, FileList
, ShellInfoNode
, MapName
);
2475 EfiShellClose(ShellInfoNode
->Handle
);
2476 ShellInfoNode
->Handle
= NULL
;
2478 } else if (!EFI_ERROR(Status
)) {
2484 // copy the information we need into a new Node
2486 NewShellNode
= InternalDuplicateShellFileInfo(ShellInfoNode
, FALSE
);
2487 if (NewShellNode
== NULL
) {
2488 Status
= EFI_OUT_OF_RESOURCES
;
2490 if (*FileList
== NULL
) {
2491 *FileList
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2492 InitializeListHead(&((*FileList
)->Link
));
2496 // Add to the returning to use list
2498 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
2501 if (EFI_ERROR(Status
)) {
2505 if (EFI_ERROR(Status
)) {
2506 EfiShellFreeFileList(&ShellInfo
);
2508 Status
= EfiShellFreeFileList(&ShellInfo
);
2513 FreePool(CurrentFilePattern
);
2518 Find files that match a specified pattern.
2520 This function searches for all files and directories that match the specified
2521 FilePattern. The FilePattern can contain wild-card characters. The resulting file
2522 information is placed in the file list FileList.
2524 Wildcards are processed
2525 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1.
2527 The files in the file list are not opened. The OpenMode field is set to 0 and the FileInfo
2528 field is set to NULL.
2530 if *FileList is not NULL then it must be a pre-existing and properly initialized list.
2532 @param FilePattern Points to a NULL-terminated shell file path, including wildcards.
2533 @param FileList On return, points to the start of a file list containing the names
2534 of all matching files or else points to NULL if no matching files
2535 were found. only on a EFI_SUCCESS return will; this be non-NULL.
2537 @retval EFI_SUCCESS Files found. FileList is a valid list.
2538 @retval EFI_NOT_FOUND No files found.
2539 @retval EFI_NO_MEDIA The device has no media
2540 @retval EFI_DEVICE_ERROR The device reported an error
2541 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted
2546 IN CONST CHAR16
*FilePattern
,
2547 OUT EFI_SHELL_FILE_INFO
**FileList
2551 CHAR16
*PatternCopy
;
2552 CHAR16
*PatternCurrentLocation
;
2553 EFI_DEVICE_PATH_PROTOCOL
*RootDevicePath
;
2554 SHELL_FILE_HANDLE RootFileHandle
;
2558 if ( FilePattern
== NULL
2560 || StrStr(FilePattern
, L
":") == NULL
2562 return (EFI_INVALID_PARAMETER
);
2564 Status
= EFI_SUCCESS
;
2565 RootDevicePath
= NULL
;
2566 RootFileHandle
= NULL
;
2568 PatternCopy
= AllocateCopyPool(StrSize(FilePattern
), FilePattern
);
2569 if (PatternCopy
== NULL
) {
2570 return (EFI_OUT_OF_RESOURCES
);
2573 PatternCopy
= PathCleanUpDirectories(PatternCopy
);
2575 Count
= StrStr(PatternCopy
, L
":") - PatternCopy
;
2578 ASSERT(MapName
== NULL
);
2579 MapName
= StrnCatGrow(&MapName
, NULL
, PatternCopy
, Count
);
2580 if (MapName
== NULL
) {
2581 Status
= EFI_OUT_OF_RESOURCES
;
2583 RootDevicePath
= EfiShellGetDevicePathFromFilePath(PatternCopy
);
2584 if (RootDevicePath
== NULL
) {
2585 Status
= EFI_INVALID_PARAMETER
;
2587 Status
= EfiShellOpenRoot(RootDevicePath
, &RootFileHandle
);
2588 if (!EFI_ERROR(Status
)) {
2589 for ( PatternCurrentLocation
= PatternCopy
2590 ; *PatternCurrentLocation
!= ':'
2591 ; PatternCurrentLocation
++);
2592 PatternCurrentLocation
++;
2593 Status
= ShellSearchHandle(PatternCurrentLocation
, gUnicodeCollation
, RootFileHandle
, FileList
, NULL
, MapName
);
2594 EfiShellClose(RootFileHandle
);
2596 FreePool(RootDevicePath
);
2600 SHELL_FREE_NON_NULL(PatternCopy
);
2601 SHELL_FREE_NON_NULL(MapName
);
2607 Opens the files that match the path specified.
2609 This function opens all of the files specified by Path. Wildcards are processed
2610 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1. Each
2611 matching file has an EFI_SHELL_FILE_INFO structure created in a linked list.
2613 @param Path A pointer to the path string.
2614 @param OpenMode Specifies the mode used to open each file, EFI_FILE_MODE_READ or
2615 EFI_FILE_MODE_WRITE.
2616 @param FileList Points to the start of a list of files opened.
2618 @retval EFI_SUCCESS Create the file list successfully.
2619 @return Others Can't create the file list.
2623 EfiShellOpenFileList(
2626 IN OUT EFI_SHELL_FILE_INFO
**FileList
2630 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
2633 CONST CHAR16
*CurDir
;
2636 PathCleanUpDirectories(Path
);
2641 if (FileList
== NULL
|| *FileList
== NULL
) {
2642 return (EFI_INVALID_PARAMETER
);
2645 if (*Path
== L
'.' && *(Path
+1) == L
'\\') {
2650 // convert a local path to an absolute path
2652 if (StrStr(Path
, L
":") == NULL
) {
2653 CurDir
= EfiShellGetCurDir(NULL
);
2654 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2655 StrnCatGrow(&Path2
, &Path2Size
, CurDir
, 0);
2656 StrnCatGrow(&Path2
, &Path2Size
, L
"\\", 0);
2657 if (*Path
== L
'\\') {
2659 while (PathRemoveLastItem(Path2
)) ;
2661 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2662 StrnCatGrow(&Path2
, &Path2Size
, Path
, 0);
2664 ASSERT(Path2
== NULL
);
2665 StrnCatGrow(&Path2
, NULL
, Path
, 0);
2668 PathCleanUpDirectories (Path2
);
2673 Status
= EfiShellFindFiles(Path2
, FileList
);
2677 if (EFI_ERROR(Status
)) {
2683 // We had no errors so open all the files (that are not already opened...)
2685 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
2686 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2687 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2689 if (ShellFileListItem
->Status
== 0 && ShellFileListItem
->Handle
== NULL
) {
2690 ShellFileListItem
->Status
= EfiShellOpenFileByName (ShellFileListItem
->FullName
, &ShellFileListItem
->Handle
, OpenMode
);
2696 return (EFI_NOT_FOUND
);
2698 return(EFI_SUCCESS
);
2702 Gets the environment variable and Attributes, or list of environment variables. Can be
2703 used instead of GetEnv().
2705 This function returns the current value of the specified environment variable and
2706 the Attributes. If no variable name was specified, then all of the known
2707 variables will be returned.
2709 @param[in] Name A pointer to the environment variable name. If Name is NULL,
2710 then the function will return all of the defined shell
2711 environment variables. In the case where multiple environment
2712 variables are being returned, each variable will be terminated
2713 by a NULL, and the list will be terminated by a double NULL.
2714 @param[out] Attributes If not NULL, a pointer to the returned attributes bitmask for
2715 the environment variable. In the case where Name is NULL, and
2716 multiple environment variables are being returned, Attributes
2719 @retval NULL The environment variable doesn't exist.
2720 @return A non-NULL value points to the variable's value. The returned
2721 pointer does not need to be freed by the caller.
2726 IN CONST CHAR16
*Name
,
2727 OUT UINT32
*Attributes OPTIONAL
2734 CHAR16
*CurrentWriteLocation
;
2742 // Build the semi-colon delimited list. (2 passes)
2744 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&gShellEnvVarList
.Link
)
2745 ; !IsNull(&gShellEnvVarList
.Link
, &Node
->Link
)
2746 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&gShellEnvVarList
.Link
, &Node
->Link
)
2748 ASSERT(Node
->Key
!= NULL
);
2749 Size
+= StrSize(Node
->Key
);
2752 Size
+= 2*sizeof(CHAR16
);
2754 Buffer
= AllocateZeroPool(Size
);
2755 if (Buffer
== NULL
) {
2758 CurrentWriteLocation
= (CHAR16
*)Buffer
;
2760 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&gShellEnvVarList
.Link
)
2761 ; !IsNull(&gShellEnvVarList
.Link
, &Node
->Link
)
2762 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&gShellEnvVarList
.Link
, &Node
->Link
)
2764 ASSERT(Node
->Key
!= NULL
);
2765 StrCpyS( CurrentWriteLocation
,
2766 (Size
)/sizeof(CHAR16
) - (CurrentWriteLocation
- ((CHAR16
*)Buffer
)),
2769 CurrentWriteLocation
+= StrLen(CurrentWriteLocation
) + 1;
2774 // We are doing a specific environment variable
2776 Status
= ShellFindEnvVarInList(Name
, (CHAR16
**)&Buffer
, &Size
, Attributes
);
2778 if (EFI_ERROR(Status
)){
2780 // get the size we need for this EnvVariable
2782 Status
= SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(Name
, Attributes
, &Size
, Buffer
);
2783 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2785 // Allocate the space and recall the get function
2787 Buffer
= AllocateZeroPool(Size
);
2788 Status
= SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(Name
, Attributes
, &Size
, Buffer
);
2791 // we didnt get it (might not exist)
2792 // free the memory if we allocated any and return NULL
2794 if (EFI_ERROR(Status
)) {
2795 if (Buffer
!= NULL
) {
2801 // If we did not find the environment variable in the gShellEnvVarList
2802 // but get it from UEFI variable storage successfully then we need update
2803 // the gShellEnvVarList.
2805 ShellFreeEnvVarList ();
2806 Status
= ShellInitEnvVarList ();
2807 ASSERT (Status
== EFI_SUCCESS
);
2813 // return the buffer
2815 return (AddBufferToFreeList(Buffer
));
2819 Gets either a single or list of environment variables.
2821 If name is not NULL then this function returns the current value of the specified
2822 environment variable.
2824 If Name is NULL, then a list of all environment variable names is returned. Each is a
2825 NULL terminated string with a double NULL terminating the list.
2827 @param Name A pointer to the environment variable name. If
2828 Name is NULL, then the function will return all
2829 of the defined shell environment variables. In
2830 the case where multiple environment variables are
2831 being returned, each variable will be terminated by
2832 a NULL, and the list will be terminated by a double
2835 @retval !=NULL A pointer to the returned string.
2836 The returned pointer does not need to be freed by the caller.
2838 @retval NULL The environment variable doesn't exist or there are
2839 no environment variables.
2844 IN CONST CHAR16
*Name
2847 return (EfiShellGetEnvEx(Name
, NULL
));
2851 Internal variable setting function. Allows for setting of the read only variables.
2853 @param Name Points to the NULL-terminated environment variable name.
2854 @param Value Points to the NULL-terminated environment variable value. If the value is an
2855 empty string then the environment variable is deleted.
2856 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2858 @retval EFI_SUCCESS The environment variable was successfully updated.
2862 InternalEfiShellSetEnv(
2863 IN CONST CHAR16
*Name
,
2864 IN CONST CHAR16
*Value
,
2870 if (Value
== NULL
|| StrLen(Value
) == 0) {
2871 Status
= SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
);
2872 if (!EFI_ERROR(Status
)) {
2873 ShellRemvoeEnvVarFromList(Name
);
2876 SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
);
2877 Status
= ShellAddEnvVarToList(
2878 Name
, Value
, StrSize(Value
),
2879 EFI_VARIABLE_BOOTSERVICE_ACCESS
| (Volatile
? 0 : EFI_VARIABLE_NON_VOLATILE
)
2881 if (!EFI_ERROR (Status
)) {
2883 ? SHELL_SET_ENVIRONMENT_VARIABLE_V(Name
, StrSize(Value
), Value
)
2884 : SHELL_SET_ENVIRONMENT_VARIABLE_NV(Name
, StrSize(Value
), Value
);
2885 if (EFI_ERROR (Status
)) {
2886 ShellRemvoeEnvVarFromList(Name
);
2894 Sets the environment variable.
2896 This function changes the current value of the specified environment variable. If the
2897 environment variable exists and the Value is an empty string, then the environment
2898 variable is deleted. If the environment variable exists and the Value is not an empty
2899 string, then the value of the environment variable is changed. If the environment
2900 variable does not exist and the Value is an empty string, there is no action. If the
2901 environment variable does not exist and the Value is a non-empty string, then the
2902 environment variable is created and assigned the specified value.
2904 For a description of volatile and non-volatile environment variables, see UEFI Shell
2905 2.0 specification section 3.6.1.
2907 @param Name Points to the NULL-terminated environment variable name.
2908 @param Value Points to the NULL-terminated environment variable value. If the value is an
2909 empty string then the environment variable is deleted.
2910 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2912 @retval EFI_SUCCESS The environment variable was successfully updated.
2917 IN CONST CHAR16
*Name
,
2918 IN CONST CHAR16
*Value
,
2922 if (Name
== NULL
|| *Name
== CHAR_NULL
) {
2923 return (EFI_INVALID_PARAMETER
);
2926 // Make sure we dont 'set' a predefined read only variable
2928 if (gUnicodeCollation
->StriColl(
2932 ||gUnicodeCollation
->StriColl(
2936 ||gUnicodeCollation
->StriColl(
2940 ||gUnicodeCollation
->StriColl(
2943 L
"uefishellsupport") == 0
2944 ||gUnicodeCollation
->StriColl(
2947 L
"uefishellversion") == 0
2948 ||gUnicodeCollation
->StriColl(
2951 L
"uefiversion") == 0
2952 ||(!ShellInfoObject
.ShellInitSettings
.BitUnion
.Bits
.NoNest
&&
2953 gUnicodeCollation
->StriColl(
2956 (CHAR16
*)mNoNestingEnvVarName
) == 0)
2958 return (EFI_INVALID_PARAMETER
);
2960 return (InternalEfiShellSetEnv(Name
, Value
, Volatile
));
2964 Returns the current directory on the specified device.
2966 If FileSystemMapping is NULL, it returns the current working directory. If the
2967 FileSystemMapping is not NULL, it returns the current directory associated with the
2968 FileSystemMapping. In both cases, the returned name includes the file system
2969 mapping (i.e. fs0:\current-dir).
2971 Note that the current directory string should exclude the tailing backslash character.
2973 @param FileSystemMapping A pointer to the file system mapping. If NULL,
2974 then the current working directory is returned.
2976 @retval !=NULL The current directory.
2977 @retval NULL Current directory does not exist.
2982 IN CONST CHAR16
*FileSystemMapping OPTIONAL
2985 CHAR16
*PathToReturn
;
2987 SHELL_MAP_LIST
*MapListItem
;
2988 if (!IsListEmpty(&gShellMapList
.Link
)) {
2990 // if parameter is NULL, use current
2992 if (FileSystemMapping
== NULL
) {
2993 return (EfiShellGetEnv(L
"cwd"));
2996 PathToReturn
= NULL
;
2997 MapListItem
= ShellCommandFindMapItem(FileSystemMapping
);
2998 if (MapListItem
!= NULL
) {
2999 ASSERT((PathToReturn
== NULL
&& Size
== 0) || (PathToReturn
!= NULL
));
3000 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->MapName
, 0);
3001 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
3004 return (AddBufferToFreeList(PathToReturn
));
3011 Changes the current directory on the specified device.
3013 If the FileSystem is NULL, and the directory Dir does not contain a file system's
3014 mapped name, this function changes the current working directory.
3016 If the FileSystem is NULL and the directory Dir contains a mapped name, then the
3017 current file system and the current directory on that file system are changed.
3019 If FileSystem is NULL, and Dir is not NULL, then this changes the current working file
3022 If FileSystem is not NULL and Dir is not NULL, then this function changes the current
3023 directory on the specified file system.
3025 If the current working directory or the current working file system is changed then the
3026 %cwd% environment variable will be updated
3028 Note that the current directory string should exclude the tailing backslash character.
3030 @param FileSystem A pointer to the file system's mapped name. If NULL, then the current working
3031 directory is changed.
3032 @param Dir Points to the NULL-terminated directory on the device specified by FileSystem.
3034 @retval EFI_SUCCESS The operation was sucessful
3035 @retval EFI_NOT_FOUND The file system could not be found
3040 IN CONST CHAR16
*FileSystem OPTIONAL
,
3041 IN CONST CHAR16
*Dir
3045 SHELL_MAP_LIST
*MapListItem
;
3049 CHAR16
*DirectoryName
;
3056 DirectoryName
= NULL
;
3058 if ((FileSystem
== NULL
&& Dir
== NULL
) || Dir
== NULL
) {
3059 return (EFI_INVALID_PARAMETER
);
3062 if (IsListEmpty(&gShellMapList
.Link
)){
3063 return (EFI_NOT_FOUND
);
3066 DirectoryName
= StrnCatGrow(&DirectoryName
, NULL
, Dir
, 0);
3067 ASSERT(DirectoryName
!= NULL
);
3069 PathCleanUpDirectories(DirectoryName
);
3071 if (FileSystem
== NULL
) {
3073 // determine the file system mapping to use
3075 if (StrStr(DirectoryName
, L
":") != NULL
) {
3076 ASSERT(MapName
== NULL
);
3077 MapName
= StrnCatGrow(&MapName
, NULL
, DirectoryName
, (StrStr(DirectoryName
, L
":")-DirectoryName
+1));
3080 // find the file system mapping's entry in the list
3083 if (MapName
!= NULL
) {
3084 MapListItem
= ShellCommandFindMapItem(MapName
);
3087 // make that the current file system mapping
3089 if (MapListItem
!= NULL
) {
3090 gShellCurDir
= MapListItem
;
3093 MapListItem
= gShellCurDir
;
3096 if (MapListItem
== NULL
) {
3097 FreePool (DirectoryName
);
3098 SHELL_FREE_NON_NULL(MapName
);
3099 return (EFI_NOT_FOUND
);
3103 // now update the MapListItem's current directory
3105 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& DirectoryName
[StrLen(DirectoryName
) - 1] != L
':') {
3106 FreePool(MapListItem
->CurrentDirectoryPath
);
3107 MapListItem
->CurrentDirectoryPath
= NULL
;
3109 if (MapName
!= NULL
) {
3110 TempLen
= StrLen(MapName
);
3111 if (TempLen
!= StrLen(DirectoryName
)) {
3112 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3113 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
+StrLen(MapName
), 0);
3117 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3118 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
3120 if ((MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] == L
'\\') || (MapListItem
->CurrentDirectoryPath
== NULL
)) {
3121 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3122 if (MapListItem
->CurrentDirectoryPath
!= NULL
) {
3123 MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] = CHAR_NULL
;
3128 // cant have a mapping in the directory...
3130 if (StrStr(DirectoryName
, L
":") != NULL
) {
3131 FreePool (DirectoryName
);
3132 return (EFI_INVALID_PARAMETER
);
3135 // FileSystem != NULL
3137 MapListItem
= ShellCommandFindMapItem(FileSystem
);
3138 if (MapListItem
== NULL
) {
3139 FreePool (DirectoryName
);
3140 return (EFI_INVALID_PARAMETER
);
3142 // gShellCurDir = MapListItem;
3143 if (DirectoryName
!= NULL
) {
3145 // change current dir on that file system
3148 if (MapListItem
->CurrentDirectoryPath
!= NULL
) {
3149 FreePool(MapListItem
->CurrentDirectoryPath
);
3150 DEBUG_CODE(MapListItem
->CurrentDirectoryPath
= NULL
;);
3152 // ASSERT((MapListItem->CurrentDirectoryPath == NULL && Size == 0) || (MapListItem->CurrentDirectoryPath != NULL));
3153 // MapListItem->CurrentDirectoryPath = StrnCatGrow(&MapListItem->CurrentDirectoryPath, &Size, FileSystem, 0);
3154 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3155 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
3156 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3157 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
3158 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] == L
'\\') {
3159 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
3160 MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] = CHAR_NULL
;
3164 FreePool (DirectoryName
);
3166 // if updated the current directory then update the environment variable
3168 if (MapListItem
== gShellCurDir
) {
3170 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
3171 StrnCatGrow(&TempString
, &Size
, MapListItem
->MapName
, 0);
3172 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
3173 StrnCatGrow(&TempString
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
3174 Status
= InternalEfiShellSetEnv(L
"cwd", TempString
, TRUE
);
3175 FreePool(TempString
);
3178 return(EFI_SUCCESS
);
3182 Return help information about a specific command.
3184 This function returns the help information for the specified command. The help text
3185 can be internal to the shell or can be from a UEFI Shell manual page.
3187 If Sections is specified, then each section name listed will be compared in a casesensitive
3188 manner, to the section names described in Appendix B. If the section exists,
3189 it will be appended to the returned help text. If the section does not exist, no
3190 information will be returned. If Sections is NULL, then all help text information
3191 available will be returned.
3193 @param Command Points to the NULL-terminated UEFI Shell command name.
3194 @param Sections Points to the NULL-terminated comma-delimited
3195 section names to return. If NULL, then all
3196 sections will be returned.
3197 @param HelpText On return, points to a callee-allocated buffer
3198 containing all specified help text.
3200 @retval EFI_SUCCESS The help text was returned.
3201 @retval EFI_OUT_OF_RESOURCES The necessary buffer could not be allocated to hold the
3203 @retval EFI_INVALID_PARAMETER HelpText is NULL
3204 @retval EFI_NOT_FOUND There is no help text available for Command.
3208 EfiShellGetHelpText(
3209 IN CONST CHAR16
*Command
,
3210 IN CONST CHAR16
*Sections OPTIONAL
,
3211 OUT CHAR16
**HelpText
3214 CONST CHAR16
*ManFileName
;
3218 ASSERT(HelpText
!= NULL
);
3221 ManFileName
= ShellCommandGetManFileNameHandler(Command
);
3223 if (ManFileName
!= NULL
) {
3224 return (ProcessManFile(ManFileName
, Command
, Sections
, NULL
, HelpText
));
3226 if ((StrLen(Command
)> 4)
3227 && (Command
[StrLen(Command
)-1] == L
'i' || Command
[StrLen(Command
)-1] == L
'I')
3228 && (Command
[StrLen(Command
)-2] == L
'f' || Command
[StrLen(Command
)-2] == L
'F')
3229 && (Command
[StrLen(Command
)-3] == L
'e' || Command
[StrLen(Command
)-3] == L
'E')
3230 && (Command
[StrLen(Command
)-4] == L
'.')
3232 FixCommand
= AllocateZeroPool(StrSize(Command
) - 4 * sizeof (CHAR16
));
3233 if (FixCommand
== NULL
) {
3234 return EFI_OUT_OF_RESOURCES
;
3237 StrnCpyS( FixCommand
,
3238 (StrSize(Command
) - 4 * sizeof (CHAR16
))/sizeof(CHAR16
),
3242 Status
= ProcessManFile(FixCommand
, FixCommand
, Sections
, NULL
, HelpText
);
3243 FreePool(FixCommand
);
3246 return (ProcessManFile(Command
, Command
, Sections
, NULL
, HelpText
));
3252 Gets the enable status of the page break output mode.
3254 User can use this function to determine current page break mode.
3256 @retval TRUE The page break output mode is enabled.
3257 @retval FALSE The page break output mode is disabled.
3261 EfiShellGetPageBreak(
3265 return(ShellInfoObject
.PageBreakEnabled
);
3269 Judges whether the active shell is the root shell.
3271 This function makes the user to know that whether the active Shell is the root shell.
3273 @retval TRUE The active Shell is the root Shell.
3274 @retval FALSE The active Shell is NOT the root Shell.
3278 EfiShellIsRootShell(
3282 return(ShellInfoObject
.RootShellInstance
);
3286 function to return a semi-colon delimeted list of all alias' in the current shell
3288 up to caller to free the memory.
3290 @retval NULL No alias' were found
3291 @retval NULL An error ocurred getting alias'
3292 @return !NULL a list of all alias'
3296 InternalEfiShellGetListAlias(
3302 CHAR16
*VariableName
;
3304 UINTN NameBufferSize
;
3308 NameBufferSize
= INIT_NAME_BUFFER_SIZE
;
3309 VariableName
= AllocateZeroPool(NameBufferSize
);
3313 if (VariableName
== NULL
) {
3317 VariableName
[0] = CHAR_NULL
;
3320 NameSize
= NameBufferSize
;
3321 Status
= gRT
->GetNextVariableName(&NameSize
, VariableName
, &Guid
);
3322 if (Status
== EFI_NOT_FOUND
){
3324 } else if (Status
== EFI_BUFFER_TOO_SMALL
) {
3325 NameBufferSize
= NameSize
> NameBufferSize
* 2 ? NameSize
: NameBufferSize
* 2;
3326 SHELL_FREE_NON_NULL(VariableName
);
3327 VariableName
= AllocateZeroPool(NameBufferSize
);
3328 if (VariableName
== NULL
) {
3329 Status
= EFI_OUT_OF_RESOURCES
;
3330 SHELL_FREE_NON_NULL(RetVal
);
3335 NameSize
= NameBufferSize
;
3336 Status
= gRT
->GetNextVariableName(&NameSize
, VariableName
, &Guid
);
3339 if (EFI_ERROR (Status
)) {
3340 SHELL_FREE_NON_NULL(RetVal
);
3345 if (CompareGuid(&Guid
, &gShellAliasGuid
)){
3346 ASSERT((RetVal
== NULL
&& RetSize
== 0) || (RetVal
!= NULL
));
3347 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, VariableName
, 0);
3348 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, L
";", 0);
3351 SHELL_FREE_NON_NULL(VariableName
);
3357 Convert a null-terminated unicode string, in-place, to all lowercase.
3360 @param Str The null-terminated string to be converted to all lowercase.
3362 @return The null-terminated string converted into all lowercase.
3371 for (Index
= 0; Str
[Index
] != L
'\0'; Index
++) {
3372 if (Str
[Index
] >= L
'A' && Str
[Index
] <= L
'Z') {
3373 Str
[Index
] -= (CHAR16
)(L
'A' - L
'a');
3380 This function returns the command associated with a alias or a list of all
3383 @param[in] Alias Points to the NULL-terminated shell alias.
3384 If this parameter is NULL, then all
3385 aliases will be returned in ReturnedData.
3386 @param[out] Volatile upon return of a single command if TRUE indicates
3387 this is stored in a volatile fashion. FALSE otherwise.
3389 @return If Alias is not NULL, it will return a pointer to
3390 the NULL-terminated command for that alias.
3391 If Alias is NULL, ReturnedData points to a ';'
3392 delimited list of alias (e.g.
3393 ReturnedData = "dir;del;copy;mfp") that is NULL-terminated.
3394 @retval NULL an error ocurred
3395 @retval NULL Alias was not a valid Alias
3400 IN CONST CHAR16
*Alias
,
3401 OUT BOOLEAN
*Volatile OPTIONAL
3411 // Convert to lowercase to make aliases case-insensitive
3412 if (Alias
!= NULL
) {
3413 AliasLower
= AllocateCopyPool (StrSize (Alias
), Alias
);
3414 if (AliasLower
== NULL
) {
3417 ToLower (AliasLower
);
3419 if (Volatile
== NULL
) {
3420 GetVariable2 (AliasLower
, &gShellAliasGuid
, (VOID
**)&AliasVal
, NULL
);
3421 FreePool(AliasLower
);
3422 return (AddBufferToFreeList(AliasVal
));
3426 Status
= gRT
->GetVariable(AliasLower
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
3427 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3428 RetVal
= AllocateZeroPool(RetSize
);
3429 Status
= gRT
->GetVariable(AliasLower
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
3431 if (EFI_ERROR(Status
)) {
3432 if (RetVal
!= NULL
) {
3435 FreePool(AliasLower
);
3438 if ((EFI_VARIABLE_NON_VOLATILE
& Attribs
) == EFI_VARIABLE_NON_VOLATILE
) {
3444 FreePool (AliasLower
);
3445 return (AddBufferToFreeList(RetVal
));
3447 return (AddBufferToFreeList(InternalEfiShellGetListAlias()));
3451 Changes a shell command alias.
3453 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3455 this function does not check for built in alias'.
3457 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3458 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3459 Command refers to an alias, that alias will be deleted.
3460 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3461 Alias being set will be stored in a non-volatile fashion.
3463 @retval EFI_SUCCESS Alias created or deleted successfully.
3464 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3469 IN CONST CHAR16
*Command
,
3470 IN CONST CHAR16
*Alias
,
3477 // Convert to lowercase to make aliases case-insensitive
3478 if (Alias
!= NULL
) {
3479 AliasLower
= AllocateCopyPool (StrSize (Alias
), Alias
);
3480 if (AliasLower
== NULL
) {
3481 return EFI_OUT_OF_RESOURCES
;
3483 ToLower (AliasLower
);
3489 // We must be trying to remove one if Alias is NULL
3491 if (Alias
== NULL
) {
3493 // remove an alias (but passed in COMMAND parameter)
3495 Status
= (gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
));
3498 // Add and replace are the same
3501 // We dont check the error return on purpose since the variable may not exist.
3502 gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
);
3504 Status
= (gRT
->SetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, EFI_VARIABLE_BOOTSERVICE_ACCESS
|(Volatile
?0:EFI_VARIABLE_NON_VOLATILE
), StrSize(Command
), (VOID
*)Command
));
3507 if (Alias
!= NULL
) {
3508 FreePool (AliasLower
);
3514 Changes a shell command alias.
3516 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3519 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3520 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3521 Command refers to an alias, that alias will be deleted.
3522 @param[in] Replace If TRUE and the alias already exists, then the existing alias will be replaced. If
3523 FALSE and the alias already exists, then the existing alias is unchanged and
3524 EFI_ACCESS_DENIED is returned.
3525 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3526 Alias being set will be stored in a non-volatile fashion.
3528 @retval EFI_SUCCESS Alias created or deleted successfully.
3529 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3530 @retval EFI_ACCESS_DENIED The alias is a built-in alias or already existed and Replace was set to
3532 @retval EFI_INVALID_PARAMETER Command is null or the empty string.
3537 IN CONST CHAR16
*Command
,
3538 IN CONST CHAR16
*Alias
,
3543 if (ShellCommandIsOnAliasList(Alias
==NULL
?Command
:Alias
)) {
3545 // cant set over a built in alias
3547 return (EFI_ACCESS_DENIED
);
3548 } else if (Command
== NULL
|| *Command
== CHAR_NULL
|| StrLen(Command
) == 0) {
3550 // Command is null or empty
3552 return (EFI_INVALID_PARAMETER
);
3553 } else if (EfiShellGetAlias(Command
, NULL
) != NULL
&& !Replace
) {
3555 // Alias already exists, Replace not set
3557 return (EFI_ACCESS_DENIED
);
3559 return (InternalSetAlias(Command
, Alias
, Volatile
));
3563 // Pure FILE_HANDLE operations are passed to FileHandleLib
3564 // these functions are indicated by the *
3565 EFI_SHELL_PROTOCOL mShellProtocol
= {
3571 EfiShellGetHelpText
,
3572 EfiShellGetDevicePathFromMap
,
3573 EfiShellGetMapFromDevicePath
,
3574 EfiShellGetDevicePathFromFilePath
,
3575 EfiShellGetFilePathFromDevicePath
,
3579 EfiShellOpenFileList
,
3580 EfiShellFreeFileList
,
3581 EfiShellRemoveDupInFileList
,
3582 EfiShellBatchIsActive
,
3583 EfiShellIsRootShell
,
3584 EfiShellEnablePageBreak
,
3585 EfiShellDisablePageBreak
,
3586 EfiShellGetPageBreak
,
3587 EfiShellGetDeviceName
,
3588 (EFI_SHELL_GET_FILE_INFO
)FileHandleGetInfo
, //*
3589 (EFI_SHELL_SET_FILE_INFO
)FileHandleSetInfo
, //*
3590 EfiShellOpenFileByName
,
3593 (EFI_SHELL_READ_FILE
)FileHandleRead
, //*
3594 (EFI_SHELL_WRITE_FILE
)FileHandleWrite
, //*
3595 (EFI_SHELL_DELETE_FILE
)FileHandleDelete
, //*
3596 EfiShellDeleteFileByName
,
3597 (EFI_SHELL_GET_FILE_POSITION
)FileHandleGetPosition
, //*
3598 (EFI_SHELL_SET_FILE_POSITION
)FileHandleSetPosition
, //*
3599 (EFI_SHELL_FLUSH_FILE
)FileHandleFlush
, //*
3601 EfiShellFindFilesInDir
,
3602 (EFI_SHELL_GET_FILE_SIZE
)FileHandleGetSize
, //*
3604 EfiShellOpenRootByHandle
,
3606 SHELL_MAJOR_VERSION
,
3607 SHELL_MINOR_VERSION
,
3609 // New for UEFI Shell 2.1
3610 EfiShellRegisterGuidName
,
3611 EfiShellGetGuidName
,
3612 EfiShellGetGuidFromName
,
3617 Function to create and install on the current handle.
3619 Will overwrite any existing ShellProtocols in the system to be sure that
3620 the current shell is in control.
3622 This must be removed via calling CleanUpShellProtocol().
3624 @param[in, out] NewShell The pointer to the pointer to the structure
3627 @retval EFI_SUCCESS The operation was successful.
3628 @return An error from LocateHandle, CreateEvent, or other core function.
3632 CreatePopulateInstallShellProtocol (
3633 IN OUT EFI_SHELL_PROTOCOL
**NewShell
3639 UINTN HandleCounter
;
3640 SHELL_PROTOCOL_HANDLE_LIST
*OldProtocolNode
;
3641 EFI_SHELL_PROTOCOL
*OldShell
;
3643 if (NewShell
== NULL
) {
3644 return (EFI_INVALID_PARAMETER
);
3649 OldProtocolNode
= NULL
;
3650 InitializeListHead(&ShellInfoObject
.OldShellList
.Link
);
3653 // Initialize EfiShellProtocol object...
3655 Status
= gBS
->CreateEvent(0,
3659 &mShellProtocol
.ExecutionBreak
);
3660 if (EFI_ERROR(Status
)) {
3665 // Get the size of the buffer we need.
3667 Status
= gBS
->LocateHandle(ByProtocol
,
3668 &gEfiShellProtocolGuid
,
3672 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3674 // Allocate and recall with buffer of correct size
3676 Buffer
= AllocateZeroPool(BufferSize
);
3677 if (Buffer
== NULL
) {
3678 return (EFI_OUT_OF_RESOURCES
);
3680 Status
= gBS
->LocateHandle(ByProtocol
,
3681 &gEfiShellProtocolGuid
,
3685 if (EFI_ERROR(Status
)) {
3690 // now overwrite each of them, but save the info to restore when we end.
3692 for (HandleCounter
= 0 ; HandleCounter
< (BufferSize
/sizeof(EFI_HANDLE
)) ; HandleCounter
++) {
3693 Status
= gBS
->OpenProtocol(Buffer
[HandleCounter
],
3694 &gEfiShellProtocolGuid
,
3695 (VOID
**) &OldShell
,
3698 EFI_OPEN_PROTOCOL_GET_PROTOCOL
3700 if (!EFI_ERROR(Status
)) {
3701 OldProtocolNode
= AllocateZeroPool(sizeof(SHELL_PROTOCOL_HANDLE_LIST
));
3702 if (OldProtocolNode
== NULL
) {
3703 if (!IsListEmpty (&ShellInfoObject
.OldShellList
.Link
)) {
3704 CleanUpShellProtocol (&mShellProtocol
);
3706 Status
= EFI_OUT_OF_RESOURCES
;
3710 // reinstall over the old one...
3712 OldProtocolNode
->Handle
= Buffer
[HandleCounter
];
3713 OldProtocolNode
->Interface
= OldShell
;
3714 Status
= gBS
->ReinstallProtocolInterface(
3715 OldProtocolNode
->Handle
,
3716 &gEfiShellProtocolGuid
,
3717 OldProtocolNode
->Interface
,
3718 (VOID
*)(&mShellProtocol
));
3719 if (!EFI_ERROR(Status
)) {
3721 // we reinstalled sucessfully. log this so we can reverse it later.
3725 // add to the list for subsequent...
3727 InsertTailList(&ShellInfoObject
.OldShellList
.Link
, &OldProtocolNode
->Link
);
3732 } else if (Status
== EFI_NOT_FOUND
) {
3733 ASSERT(IsListEmpty(&ShellInfoObject
.OldShellList
.Link
));
3735 // no one else published yet. just publish it ourselves.
3737 Status
= gBS
->InstallProtocolInterface (
3739 &gEfiShellProtocolGuid
,
3740 EFI_NATIVE_INTERFACE
,
3741 (VOID
*)(&mShellProtocol
));
3744 if (PcdGetBool(PcdShellSupportOldProtocols
)){
3745 ///@todo support ShellEnvironment2
3746 ///@todo do we need to support ShellEnvironment (not ShellEnvironment2) also?
3749 if (!EFI_ERROR(Status
)) {
3750 *NewShell
= &mShellProtocol
;
3756 Opposite of CreatePopulateInstallShellProtocol.
3758 Free all memory and restore the system to the state it was in before calling
3759 CreatePopulateInstallShellProtocol.
3761 @param[in, out] NewShell The pointer to the new shell protocol structure.
3763 @retval EFI_SUCCESS The operation was successful.
3766 CleanUpShellProtocol (
3767 IN OUT EFI_SHELL_PROTOCOL
*NewShell
3770 SHELL_PROTOCOL_HANDLE_LIST
*Node2
;
3773 // if we need to restore old protocols...
3775 if (!IsListEmpty(&ShellInfoObject
.OldShellList
.Link
)) {
3776 for (Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*) GetFirstNode (&ShellInfoObject
.OldShellList
.Link
)
3777 ; !IsListEmpty (&ShellInfoObject
.OldShellList
.Link
)
3778 ; Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*) GetFirstNode (&ShellInfoObject
.OldShellList
.Link
)
3780 RemoveEntryList (&Node2
->Link
);
3781 gBS
->ReinstallProtocolInterface (Node2
->Handle
, &gEfiShellProtocolGuid
, NewShell
, Node2
->Interface
);
3786 // no need to restore
3788 gBS
->UninstallProtocolInterface (gImageHandle
, &gEfiShellProtocolGuid
, NewShell
);
3794 Cleanup the shell environment.
3796 @param[in, out] NewShell The pointer to the new shell protocol structure.
3798 @retval EFI_SUCCESS The operation was successful.
3801 CleanUpShellEnvironment (
3802 IN OUT EFI_SHELL_PROTOCOL
*NewShell
3806 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3808 CleanUpShellProtocol (NewShell
);
3810 Status
= gBS
->CloseEvent(NewShell
->ExecutionBreak
);
3811 NewShell
->ExecutionBreak
= NULL
;
3813 Status
= gBS
->OpenProtocol(
3814 gST
->ConsoleInHandle
,
3815 &gEfiSimpleTextInputExProtocolGuid
,
3819 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3821 if (!EFI_ERROR (Status
)) {
3822 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle1
);
3823 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle2
);
3824 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle3
);
3825 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle4
);
3826 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle1
);
3827 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle2
);
3828 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle3
);
3829 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle4
);
3835 Notification function for keystrokes.
3837 @param[in] KeyData The key that was pressed.
3839 @retval EFI_SUCCESS The operation was successful.
3843 NotificationFunction(
3844 IN EFI_KEY_DATA
*KeyData
3847 if ( ((KeyData
->Key
.UnicodeChar
== L
'c') &&
3848 (KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
) || KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
))) ||
3849 (KeyData
->Key
.UnicodeChar
== 3)
3851 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3852 return (EFI_UNSUPPORTED
);
3854 return (gBS
->SignalEvent(ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
));
3855 } else if ((KeyData
->Key
.UnicodeChar
== L
's') &&
3856 (KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
) || KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
))
3858 ShellInfoObject
.HaltOutput
= TRUE
;
3860 return (EFI_SUCCESS
);
3864 Function to start monitoring for CTRL-C using SimpleTextInputEx. This
3865 feature's enabled state was not known when the shell initially launched.
3867 @retval EFI_SUCCESS The feature is enabled.
3868 @retval EFI_OUT_OF_RESOURCES There is not enough mnemory available.
3872 InernalEfiShellStartMonitor(
3876 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3877 EFI_KEY_DATA KeyData
;
3880 Status
= gBS
->OpenProtocol(
3881 gST
->ConsoleInHandle
,
3882 &gEfiSimpleTextInputExProtocolGuid
,
3886 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3887 if (EFI_ERROR(Status
)) {
3892 STRING_TOKEN (STR_SHELL_NO_IN_EX
),
3893 ShellInfoObject
.HiiHandle
);
3894 return (EFI_SUCCESS
);
3897 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3898 return (EFI_UNSUPPORTED
);
3901 KeyData
.KeyState
.KeyToggleState
= 0;
3902 KeyData
.Key
.ScanCode
= 0;
3903 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3904 KeyData
.Key
.UnicodeChar
= L
'c';
3906 Status
= SimpleEx
->RegisterKeyNotify(
3909 NotificationFunction
,
3910 &ShellInfoObject
.CtrlCNotifyHandle1
);
3912 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3913 if (!EFI_ERROR(Status
)) {
3914 Status
= SimpleEx
->RegisterKeyNotify(
3917 NotificationFunction
,
3918 &ShellInfoObject
.CtrlCNotifyHandle2
);
3920 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3921 KeyData
.Key
.UnicodeChar
= 3;
3922 if (!EFI_ERROR(Status
)) {
3923 Status
= SimpleEx
->RegisterKeyNotify(
3926 NotificationFunction
,
3927 &ShellInfoObject
.CtrlCNotifyHandle3
);
3929 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3930 if (!EFI_ERROR(Status
)) {
3931 Status
= SimpleEx
->RegisterKeyNotify(
3934 NotificationFunction
,
3935 &ShellInfoObject
.CtrlCNotifyHandle4
);