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 - 2015, 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 FreePool(MapListNode
);
189 return (EFI_SUCCESS
);
194 // We didnt find one to delete
196 return (EFI_NOT_FOUND
);
200 // make sure this is a valid to add device path
202 ///@todo add BlockIo to this test...
203 if (!InternalShellProtocolIsSimpleFileSystemPresent(DevicePath
)
204 && !InternalShellProtocolIsBlockIoPresent(DevicePath
)) {
205 return (EFI_INVALID_PARAMETER
);
209 // First make sure there is no old mapping
211 Status
= EfiShellSetMap(NULL
, Mapping
);
212 if ((Status
!= EFI_SUCCESS
) && (Status
!= EFI_NOT_FOUND
)) {
217 // now add the new one.
219 Status
= ShellCommandAddMapItemAndUpdatePath(Mapping
, DevicePath
, 0, FALSE
);
225 Gets the device path from the mapping.
227 This function gets the device path associated with a mapping.
229 @param Mapping A pointer to the mapping
231 @retval !=NULL Pointer to the device path that corresponds to the
232 device mapping. The returned pointer does not need
234 @retval NULL There is no device path associated with the
237 CONST EFI_DEVICE_PATH_PROTOCOL
*
239 EfiShellGetDevicePathFromMap(
240 IN CONST CHAR16
*Mapping
243 SHELL_MAP_LIST
*MapListItem
;
250 StrnCatGrow(&NewName
, &Size
, Mapping
, 0);
251 if (Mapping
[StrLen(Mapping
)-1] != L
':') {
252 StrnCatGrow(&NewName
, &Size
, L
":", 0);
255 MapListItem
= ShellCommandFindMapItem(NewName
);
259 if (MapListItem
!= NULL
) {
260 return (MapListItem
->DevicePath
);
266 Gets the mapping(s) that most closely matches the device path.
268 This function gets the mapping which corresponds to the device path *DevicePath. If
269 there is no exact match, then the mapping which most closely matches *DevicePath
270 is returned, and *DevicePath is updated to point to the remaining portion of the
271 device path. If there is an exact match, the mapping is returned and *DevicePath
272 points to the end-of-device-path node.
274 If there are multiple map names they will be semi-colon seperated in the
275 NULL-terminated string.
277 @param DevicePath On entry, points to a device path pointer. On
278 exit, updates the pointer to point to the
279 portion of the device path after the mapping.
281 @retval NULL No mapping was found.
282 @return !=NULL Pointer to NULL-terminated mapping. The buffer
283 is callee allocated and should be freed by the caller.
287 EfiShellGetMapFromDevicePath(
288 IN OUT EFI_DEVICE_PATH_PROTOCOL
**DevicePath
291 SHELL_MAP_LIST
*Node
;
292 CHAR16
*PathForReturn
;
294 // EFI_HANDLE PathHandle;
295 // EFI_HANDLE MapHandle;
296 // EFI_STATUS Status;
297 // EFI_DEVICE_PATH_PROTOCOL *DevicePathCopy;
298 // EFI_DEVICE_PATH_PROTOCOL *MapPathCopy;
300 if (DevicePath
== NULL
|| *DevicePath
== NULL
) {
304 PathForReturn
= NULL
;
307 for ( Node
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
308 ; !IsNull(&gShellMapList
.Link
, &Node
->Link
)
309 ; Node
= (SHELL_MAP_LIST
*)GetNextNode(&gShellMapList
.Link
, &Node
->Link
)
312 // check for exact match
314 if (DevicePathCompare(DevicePath
, &Node
->DevicePath
) == 0) {
315 ASSERT((PathForReturn
== NULL
&& PathSize
== 0) || (PathForReturn
!= NULL
));
317 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, L
";", 0);
319 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, Node
->MapName
, 0);
322 if (PathForReturn
!= NULL
) {
323 while (!IsDevicePathEndType (*DevicePath
)) {
324 *DevicePath
= NextDevicePathNode (*DevicePath
);
326 SetDevicePathEndNode (*DevicePath
);
329 ///@todo finish code for inexact matches.
330 if (PathForReturn == NULL) {
333 DevicePathCopy = DuplicateDevicePath(*DevicePath);
334 ASSERT(DevicePathCopy != NULL);
335 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &DevicePathCopy, &PathHandle);
336 ASSERT_EFI_ERROR(Status);
338 // check each of the device paths we have to get the root of the path for consist mappings
340 for ( Node = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
341 ; !IsNull(&gShellMapList.Link, &Node->Link)
342 ; Node = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &Node->Link)
344 if ((Node->Flags & SHELL_MAP_FLAGS_CONSIST) == 0) {
347 MapPathCopy = DuplicateDevicePath(Node->DevicePath);
348 ASSERT(MapPathCopy != NULL);
349 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &MapPathCopy, &MapHandle);
350 if (MapHandle == PathHandle) {
352 *DevicePath = DevicePathCopy;
355 DevicePathCopy = NULL;
356 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, Node->MapName, 0);
357 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, L";", 0);
362 // now add on the non-consistent mappings
364 for ( Node = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
365 ; !IsNull(&gShellMapList.Link, &Node->Link)
366 ; Node = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &Node->Link)
368 if ((Node->Flags & SHELL_MAP_FLAGS_CONSIST) != 0) {
371 MapPathCopy = Node->DevicePath;
372 ASSERT(MapPathCopy != NULL);
373 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &MapPathCopy, &MapHandle);
374 if (MapHandle == PathHandle) {
375 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, Node->MapName, 0);
376 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, L";", 0);
383 return (AddBufferToFreeList(PathForReturn
));
387 Converts a device path to a file system-style path.
389 This function converts a device path to a file system path by replacing part, or all, of
390 the device path with the file-system mapping. If there are more than one application
391 file system mappings, the one that most closely matches Path will be used.
393 @param Path The pointer to the device path
395 @retval NULL the device path could not be found.
396 @return all The pointer of the NULL-terminated file path. The path
397 is callee-allocated and should be freed by the caller.
401 EfiShellGetFilePathFromDevicePath(
402 IN CONST EFI_DEVICE_PATH_PROTOCOL
*Path
405 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
406 EFI_DEVICE_PATH_PROTOCOL
*MapPathCopy
;
407 SHELL_MAP_LIST
*MapListItem
;
408 CHAR16
*PathForReturn
;
410 EFI_HANDLE PathHandle
;
411 EFI_HANDLE MapHandle
;
413 FILEPATH_DEVICE_PATH
*FilePath
;
414 FILEPATH_DEVICE_PATH
*AlignedNode
;
416 PathForReturn
= NULL
;
419 DevicePathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)Path
;
420 ASSERT(DevicePathCopy
!= NULL
);
421 if (DevicePathCopy
== NULL
) {
425 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &PathHandle
);
427 if (EFI_ERROR(Status
)) {
431 // check each of the device paths we have to get the root of the path
433 for ( MapListItem
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
434 ; !IsNull(&gShellMapList
.Link
, &MapListItem
->Link
)
435 ; MapListItem
= (SHELL_MAP_LIST
*)GetNextNode(&gShellMapList
.Link
, &MapListItem
->Link
)
437 MapPathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)MapListItem
->DevicePath
;
438 ASSERT(MapPathCopy
!= NULL
);
440 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &MapPathCopy
, &MapHandle
);
441 if (MapHandle
== PathHandle
) {
442 ASSERT((PathForReturn
== NULL
&& PathSize
== 0) || (PathForReturn
!= NULL
));
443 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, MapListItem
->MapName
, 0);
445 // go through all the remaining nodes in the device path
447 for ( FilePath
= (FILEPATH_DEVICE_PATH
*)DevicePathCopy
448 ; !IsDevicePathEnd (&FilePath
->Header
)
449 ; FilePath
= (FILEPATH_DEVICE_PATH
*)NextDevicePathNode (&FilePath
->Header
)
452 // all the rest should be file path nodes
454 if ((DevicePathType(&FilePath
->Header
) != MEDIA_DEVICE_PATH
) ||
455 (DevicePathSubType(&FilePath
->Header
) != MEDIA_FILEPATH_DP
)) {
456 FreePool(PathForReturn
);
457 PathForReturn
= NULL
;
461 // append the path part onto the filepath.
463 ASSERT((PathForReturn
== NULL
&& PathSize
== 0) || (PathForReturn
!= NULL
));
465 AlignedNode
= AllocateCopyPool (DevicePathNodeLength(FilePath
), FilePath
);
466 ASSERT (AlignedNode
!= NULL
);
468 // File Path Device Path Nodes 'can optionally add a "\" separator to
469 // the beginning and/or the end of the Path Name string.'
470 // (UEFI Spec 2.4 section 9.3.6.4).
471 // If necessary, add a "\", but otherwise don't
472 // (This is specified in the above section, and also implied by the
473 // UEFI Shell spec section 3.7)
474 if ((PathSize
!= 0) &&
475 (PathForReturn
!= NULL
) &&
476 (PathForReturn
[PathSize
- 1] != L
'\\') &&
477 (AlignedNode
->PathName
[0] != L
'\\')) {
478 PathForReturn
= StrnCatGrow (&PathForReturn
, &PathSize
, L
"\\", 1);
481 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, AlignedNode
->PathName
, 0);
482 FreePool(AlignedNode
);
484 } // for loop of remaining nodes
486 if (PathForReturn
!= NULL
) {
489 } // for loop of paths to check
490 return(PathForReturn
);
494 Converts a file system style name to a device path.
496 This function converts a file system style name to a device path, by replacing any
497 mapping references to the associated device path.
499 @param[in] Path The pointer to the path.
501 @return The pointer of the file path. The file path is callee
502 allocated and should be freed by the caller.
503 @retval NULL The path could not be found.
504 @retval NULL There was not enough available memory.
506 EFI_DEVICE_PATH_PROTOCOL
*
508 EfiShellGetDevicePathFromFilePath(
509 IN CONST CHAR16
*Path
516 CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
517 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
518 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopyForFree
;
519 EFI_DEVICE_PATH_PROTOCOL
*DevicePathForReturn
;
530 if (StrStr(Path
, L
":") == NULL
) {
531 Cwd
= EfiShellGetCurDir(NULL
);
535 Size
= StrSize(Cwd
) + StrSize(Path
) - sizeof(CHAR16
);
536 NewPath
= AllocateZeroPool(Size
);
537 if (NewPath
== NULL
) {
540 StrCpyS(NewPath
, Size
/sizeof(CHAR16
), Cwd
);
541 if (*Path
== L
'\\') {
543 while (PathRemoveLastItem(NewPath
)) ;
545 StrCatS(NewPath
, Size
/sizeof(CHAR16
), Path
);
546 DevicePathForReturn
= EfiShellGetDevicePathFromFilePath(NewPath
);
548 return (DevicePathForReturn
);
553 // find the part before (but including) the : for the map name
555 ASSERT((MapName
== NULL
&& Size
== 0) || (MapName
!= NULL
));
556 MapName
= StrnCatGrow(&MapName
, &Size
, Path
, (StrStr(Path
, L
":")-Path
+1));
557 if (MapName
== NULL
|| MapName
[StrLen(MapName
)-1] != L
':') {
562 // look up the device path in the map
564 DevicePath
= EfiShellGetDevicePathFromMap(MapName
);
565 if (DevicePath
== NULL
) {
567 // Must have been a bad Mapname
573 // make a copy for LocateDevicePath to modify (also save a pointer to call FreePool with)
575 DevicePathCopyForFree
= DevicePathCopy
= DuplicateDevicePath(DevicePath
);
576 if (DevicePathCopy
== NULL
) {
585 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &Handle
);
586 if (EFI_ERROR(Status
)) {
587 if (DevicePathCopyForFree
!= NULL
) {
588 FreePool(DevicePathCopyForFree
);
595 // build the full device path
597 if (*(Path
+StrLen(MapName
)+1) == CHAR_NULL
) {
598 DevicePathForReturn
= FileDevicePath(Handle
, L
"\\");
600 DevicePathForReturn
= FileDevicePath(Handle
, Path
+StrLen(MapName
));
604 if (DevicePathCopyForFree
!= NULL
) {
605 FreePool(DevicePathCopyForFree
);
608 return (DevicePathForReturn
);
612 Gets the name of the device specified by the device handle.
614 This function gets the user-readable name of the device specified by the device
615 handle. If no user-readable name could be generated, then *BestDeviceName will be
616 NULL and EFI_NOT_FOUND will be returned.
618 If EFI_DEVICE_NAME_USE_COMPONENT_NAME is set, then the function will return the
619 device's name using the EFI_COMPONENT_NAME2_PROTOCOL, if present on
622 If EFI_DEVICE_NAME_USE_DEVICE_PATH is set, then the function will return the
623 device's name using the EFI_DEVICE_PATH_PROTOCOL, if present on DeviceHandle.
624 If both EFI_DEVICE_NAME_USE_COMPONENT_NAME and
625 EFI_DEVICE_NAME_USE_DEVICE_PATH are set, then
626 EFI_DEVICE_NAME_USE_COMPONENT_NAME will have higher priority.
628 @param DeviceHandle The handle of the device.
629 @param Flags Determines the possible sources of component names.
631 EFI_DEVICE_NAME_USE_COMPONENT_NAME
632 EFI_DEVICE_NAME_USE_DEVICE_PATH
633 @param Language A pointer to the language specified for the device
634 name, in the same format as described in the UEFI
635 specification, Appendix M
636 @param BestDeviceName On return, points to the callee-allocated NULL-
637 terminated name of the device. If no device name
638 could be found, points to NULL. The name must be
639 freed by the caller...
641 @retval EFI_SUCCESS Get the name successfully.
642 @retval EFI_NOT_FOUND Fail to get the device name.
643 @retval EFI_INVALID_PARAMETER Flags did not have a valid bit set.
644 @retval EFI_INVALID_PARAMETER BestDeviceName was NULL
645 @retval EFI_INVALID_PARAMETER DeviceHandle was NULL
649 EfiShellGetDeviceName(
650 IN EFI_HANDLE DeviceHandle
,
651 IN EFI_SHELL_DEVICE_NAME_FLAGS Flags
,
653 OUT CHAR16
**BestDeviceName
657 EFI_COMPONENT_NAME2_PROTOCOL
*CompName2
;
658 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
659 EFI_HANDLE
*HandleList
;
662 CHAR16
*DeviceNameToReturn
;
664 UINTN ParentControllerCount
;
665 EFI_HANDLE
*ParentControllerBuffer
;
666 UINTN ParentDriverCount
;
667 EFI_HANDLE
*ParentDriverBuffer
;
669 if (BestDeviceName
== NULL
||
672 return (EFI_INVALID_PARAMETER
);
676 // make sure one of the 2 supported bits is on
678 if (((Flags
& EFI_DEVICE_NAME_USE_COMPONENT_NAME
) == 0) &&
679 ((Flags
& EFI_DEVICE_NAME_USE_DEVICE_PATH
) == 0)) {
680 return (EFI_INVALID_PARAMETER
);
683 DeviceNameToReturn
= NULL
;
684 *BestDeviceName
= NULL
;
689 if ((Flags
& EFI_DEVICE_NAME_USE_COMPONENT_NAME
) != 0) {
690 Status
= ParseHandleDatabaseByRelationship(
693 HR_DRIVER_BINDING_HANDLE
|HR_DEVICE_DRIVER
,
696 for (LoopVar
= 0; LoopVar
< HandleCount
; LoopVar
++){
698 // Go through those handles until we get one that passes for GetComponentName
700 Status
= gBS
->OpenProtocol(
702 &gEfiComponentName2ProtocolGuid
,
706 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
707 if (EFI_ERROR(Status
)) {
708 Status
= gBS
->OpenProtocol(
710 &gEfiComponentNameProtocolGuid
,
714 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
717 if (EFI_ERROR(Status
)) {
720 Lang
= GetBestLanguageForDriver(CompName2
->SupportedLanguages
, Language
, FALSE
);
721 Status
= CompName2
->GetControllerName(CompName2
, DeviceHandle
, NULL
, Lang
, &DeviceNameToReturn
);
724 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
728 if (HandleList
!= NULL
) {
729 FreePool(HandleList
);
733 // Now check the parent controller using this as the child.
735 if (DeviceNameToReturn
== NULL
){
736 PARSE_HANDLE_DATABASE_PARENTS(DeviceHandle
, &ParentControllerCount
, &ParentControllerBuffer
);
737 for (LoopVar
= 0 ; LoopVar
< ParentControllerCount
; LoopVar
++) {
738 PARSE_HANDLE_DATABASE_UEFI_DRIVERS(ParentControllerBuffer
[LoopVar
], &ParentDriverCount
, &ParentDriverBuffer
);
739 for (HandleCount
= 0 ; HandleCount
< ParentDriverCount
; HandleCount
++) {
741 // try using that driver's component name with controller and our driver as the child.
743 Status
= gBS
->OpenProtocol(
744 ParentDriverBuffer
[HandleCount
],
745 &gEfiComponentName2ProtocolGuid
,
749 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
750 if (EFI_ERROR(Status
)) {
751 Status
= gBS
->OpenProtocol(
752 ParentDriverBuffer
[HandleCount
],
753 &gEfiComponentNameProtocolGuid
,
757 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
760 if (EFI_ERROR(Status
)) {
763 Lang
= GetBestLanguageForDriver(CompName2
->SupportedLanguages
, Language
, FALSE
);
764 Status
= CompName2
->GetControllerName(CompName2
, ParentControllerBuffer
[LoopVar
], DeviceHandle
, Lang
, &DeviceNameToReturn
);
767 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
774 SHELL_FREE_NON_NULL(ParentDriverBuffer
);
775 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
779 SHELL_FREE_NON_NULL(ParentControllerBuffer
);
782 // dont return on fail since we will try device path if that bit is on
784 if (DeviceNameToReturn
!= NULL
){
785 ASSERT(BestDeviceName
!= NULL
);
786 StrnCatGrow(BestDeviceName
, NULL
, DeviceNameToReturn
, 0);
787 return (EFI_SUCCESS
);
790 if ((Flags
& EFI_DEVICE_NAME_USE_DEVICE_PATH
) != 0) {
791 Status
= gBS
->OpenProtocol(
793 &gEfiDevicePathProtocolGuid
,
797 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
798 if (!EFI_ERROR(Status
)) {
800 // use device path to text on the device path
802 *BestDeviceName
= ConvertDevicePathToText(DevicePath
, TRUE
, TRUE
);
803 return (EFI_SUCCESS
);
807 // none of the selected bits worked.
809 return (EFI_NOT_FOUND
);
813 Opens the root directory of a device on a handle
815 This function opens the root directory of a device and returns a file handle to it.
817 @param DeviceHandle The handle of the device that contains the volume.
818 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
821 @retval EFI_SUCCESS Root opened successfully.
822 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
824 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
825 @retval EFI_DEVICE_ERROR The device had an error
829 EfiShellOpenRootByHandle(
830 IN EFI_HANDLE DeviceHandle
,
831 OUT SHELL_FILE_HANDLE
*FileHandle
835 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
*SimpleFileSystem
;
836 EFI_FILE_PROTOCOL
*RealFileHandle
;
837 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
840 // get the simple file system interface
842 Status
= gBS
->OpenProtocol(DeviceHandle
,
843 &gEfiSimpleFileSystemProtocolGuid
,
844 (VOID
**)&SimpleFileSystem
,
847 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
848 if (EFI_ERROR(Status
)) {
849 return (EFI_NOT_FOUND
);
852 Status
= gBS
->OpenProtocol(DeviceHandle
,
853 &gEfiDevicePathProtocolGuid
,
857 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
858 if (EFI_ERROR(Status
)) {
859 return (EFI_NOT_FOUND
);
862 // Open the root volume now...
864 Status
= SimpleFileSystem
->OpenVolume(SimpleFileSystem
, &RealFileHandle
);
865 *FileHandle
= ConvertEfiFileProtocolToShellHandle(RealFileHandle
, EfiShellGetMapFromDevicePath(&DevPath
));
870 Opens the root directory of a device.
872 This function opens the root directory of a device and returns a file handle to it.
874 @param DevicePath Points to the device path corresponding to the device where the
875 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL is installed.
876 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
879 @retval EFI_SUCCESS Root opened successfully.
880 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
882 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
883 @retval EFI_DEVICE_ERROR The device had an error
884 @retval EFI_INVALID_PARAMETER FileHandle is NULL.
889 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
890 OUT SHELL_FILE_HANDLE
*FileHandle
896 if (FileHandle
== NULL
) {
897 return (EFI_INVALID_PARAMETER
);
901 // find the handle of the device with that device handle and the file system
904 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
,
907 if (EFI_ERROR(Status
)) {
908 return (EFI_NOT_FOUND
);
911 return (EfiShellOpenRootByHandle(Handle
, FileHandle
));
915 Returns whether any script files are currently being processed.
917 @retval TRUE There is at least one script file active.
918 @retval FALSE No script files are active now.
923 EfiShellBatchIsActive (
927 if (ShellCommandGetCurrentScriptFile() == NULL
) {
934 Worker function to open a file based on a device path. this will open the root
935 of the volume and then traverse down to the file itself.
937 @param DevicePath Device Path of the file.
938 @param FileHandle Pointer to the file upon a successful return.
939 @param OpenMode mode to open file in.
940 @param Attributes the File Attributes to use when creating a new file.
942 @retval EFI_SUCCESS the file is open and FileHandle is valid
943 @retval EFI_UNSUPPORTED the device path cotained non-path elements
944 @retval other an error ocurred.
948 InternalOpenFileDevicePath(
949 IN OUT EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
950 OUT SHELL_FILE_HANDLE
*FileHandle
,
952 IN UINT64 Attributes OPTIONAL
956 FILEPATH_DEVICE_PATH
*FilePathNode
;
958 SHELL_FILE_HANDLE ShellHandle
;
959 EFI_FILE_PROTOCOL
*Handle1
;
960 EFI_FILE_PROTOCOL
*Handle2
;
961 FILEPATH_DEVICE_PATH
*AlignedNode
;
963 if (FileHandle
== NULL
) {
964 return (EFI_INVALID_PARAMETER
);
974 Status
= EfiShellOpenRoot(DevicePath
, &ShellHandle
);
976 if (!EFI_ERROR(Status
)) {
977 Handle1
= ConvertShellHandleToEfiFileProtocol(ShellHandle
);
978 if (Handle1
!= NULL
) {
980 // chop off the begining part before the file system part...
983 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
,
986 if (!EFI_ERROR(Status
)) {
988 // To access as a file system, the file path should only
989 // contain file path components. Follow the file path nodes
990 // and find the target file
992 for ( FilePathNode
= (FILEPATH_DEVICE_PATH
*)DevicePath
993 ; !IsDevicePathEnd (&FilePathNode
->Header
)
994 ; FilePathNode
= (FILEPATH_DEVICE_PATH
*) NextDevicePathNode (&FilePathNode
->Header
)
996 SHELL_FREE_NON_NULL(AlignedNode
);
997 AlignedNode
= AllocateCopyPool (DevicePathNodeLength(FilePathNode
), FilePathNode
);
999 // For file system access each node should be a file path component
1001 if (DevicePathType (&FilePathNode
->Header
) != MEDIA_DEVICE_PATH
||
1002 DevicePathSubType (&FilePathNode
->Header
) != MEDIA_FILEPATH_DP
1004 Status
= EFI_UNSUPPORTED
;
1009 // Open this file path node
1015 // if this is the last node in the DevicePath always create (if that was requested).
1017 if (IsDevicePathEnd ((NextDevicePathNode (&FilePathNode
->Header
)))) {
1018 Status
= Handle2
->Open (
1021 AlignedNode
->PathName
,
1028 // This is not the last node and we dont want to 'create' existing
1029 // directory entries...
1033 // open without letting it create
1034 // prevents error on existing files/directories
1036 Status
= Handle2
->Open (
1039 AlignedNode
->PathName
,
1040 OpenMode
&~EFI_FILE_MODE_CREATE
,
1044 // if above failed now open and create the 'item'
1045 // if OpenMode EFI_FILE_MODE_CREATE bit was on (but disabled above)
1047 if ((EFI_ERROR (Status
)) && ((OpenMode
& EFI_FILE_MODE_CREATE
) != 0)) {
1048 Status
= Handle2
->Open (
1051 AlignedNode
->PathName
,
1058 // Close the last node
1060 ShellInfoObject
.NewEfiShellProtocol
->CloseFile (Handle2
);
1063 // If there's been an error, stop
1065 if (EFI_ERROR (Status
)) {
1072 SHELL_FREE_NON_NULL(AlignedNode
);
1073 if (EFI_ERROR(Status
)) {
1074 if (Handle1
!= NULL
) {
1075 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(Handle1
);
1078 *FileHandle
= ConvertEfiFileProtocolToShellHandle(Handle1
, ShellFileHandleGetPath(ShellHandle
));
1084 Creates a file or directory by name.
1086 This function creates an empty new file or directory with the specified attributes and
1087 returns the new file's handle. If the file already exists and is read-only, then
1088 EFI_INVALID_PARAMETER will be returned.
1090 If the file already existed, it is truncated and its attributes updated. If the file is
1091 created successfully, the FileHandle is the file's handle, else, the FileHandle is NULL.
1093 If the file name begins with >v, then the file handle which is returned refers to the
1094 shell environment variable with the specified name. If the shell environment variable
1095 already exists and is non-volatile then EFI_INVALID_PARAMETER is returned.
1097 @param FileName Pointer to NULL-terminated file path
1098 @param FileAttribs The new file's attrbiutes. the different attributes are
1099 described in EFI_FILE_PROTOCOL.Open().
1100 @param FileHandle On return, points to the created file handle or directory's handle
1102 @retval EFI_SUCCESS The file was opened. FileHandle points to the new file's handle.
1103 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1104 @retval EFI_UNSUPPORTED could not open the file path
1105 @retval EFI_NOT_FOUND the specified file could not be found on the devide, or could not
1106 file the file system on the device.
1107 @retval EFI_NO_MEDIA the device has no medium.
1108 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1110 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1112 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1113 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1114 when the media is write-protected.
1115 @retval EFI_ACCESS_DENIED The service denied access to the file.
1116 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file.
1117 @retval EFI_VOLUME_FULL The volume is full.
1122 IN CONST CHAR16
*FileName
,
1123 IN UINT64 FileAttribs
,
1124 OUT SHELL_FILE_HANDLE
*FileHandle
1127 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1131 // Is this for an environment variable
1132 // do we start with >v
1134 if (StrStr(FileName
, L
">v") == FileName
) {
1135 if (!IsVolatileEnv(FileName
+2)) {
1136 return (EFI_INVALID_PARAMETER
);
1138 *FileHandle
= CreateFileInterfaceEnv(FileName
+2);
1139 return (EFI_SUCCESS
);
1143 // We are opening a regular file.
1145 DevicePath
= EfiShellGetDevicePathFromFilePath(FileName
);
1146 if (DevicePath
== NULL
) {
1147 return (EFI_NOT_FOUND
);
1150 Status
= InternalOpenFileDevicePath(DevicePath
, FileHandle
, EFI_FILE_MODE_READ
|EFI_FILE_MODE_WRITE
|EFI_FILE_MODE_CREATE
, FileAttribs
);
1151 FreePool(DevicePath
);
1157 Register a GUID and a localized human readable name for it.
1159 If Guid is not assigned a name, then assign GuidName to Guid. This list of GUID
1160 names must be used whenever a shell command outputs GUID information.
1162 This function is only available when the major and minor versions in the
1163 EfiShellProtocol are greater than or equal to 2 and 1, respectively.
1165 @param[in] Guid A pointer to the GUID being registered.
1166 @param[in] GuidName A pointer to the localized name for the GUID being registered.
1168 @retval EFI_SUCCESS The operation was successful.
1169 @retval EFI_INVALID_PARAMETER Guid was NULL.
1170 @retval EFI_INVALID_PARAMETER GuidName was NULL.
1171 @retval EFI_ACCESS_DENIED Guid already is assigned a name.
1175 EfiShellRegisterGuidName(
1176 IN CONST EFI_GUID
*Guid
,
1177 IN CONST CHAR16
*GuidName
1180 return (AddNewGuidNameMapping(Guid
, GuidName
, NULL
));
1184 Opens a file or a directory by file name.
1186 This function opens the specified file in the specified OpenMode and returns a file
1188 If the file name begins with >v, then the file handle which is returned refers to the
1189 shell environment variable with the specified name. If the shell environment variable
1190 exists, is non-volatile and the OpenMode indicates EFI_FILE_MODE_WRITE, then
1191 EFI_INVALID_PARAMETER is returned.
1193 If the file name is >i, then the file handle which is returned refers to the standard
1194 input. If the OpenMode indicates EFI_FILE_MODE_WRITE, then EFI_INVALID_PARAMETER
1197 If the file name is >o, then the file handle which is returned refers to the standard
1198 output. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1201 If the file name is >e, then the file handle which is returned refers to the standard
1202 error. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1205 If the file name is NUL, then the file handle that is returned refers to the standard NUL
1206 file. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER is
1209 If return EFI_SUCCESS, the FileHandle is the opened file's handle, else, the
1212 @param FileName Points to the NULL-terminated UCS-2 encoded file name.
1213 @param FileHandle On return, points to the file handle.
1214 @param OpenMode File open mode. Either EFI_FILE_MODE_READ or
1215 EFI_FILE_MODE_WRITE from section 12.4 of the UEFI
1217 @retval EFI_SUCCESS The file was opened. FileHandle has the opened file's handle.
1218 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value. FileHandle is NULL.
1219 @retval EFI_UNSUPPORTED Could not open the file path. FileHandle is NULL.
1220 @retval EFI_NOT_FOUND The specified file could not be found on the device or the file
1221 system could not be found on the device. FileHandle is NULL.
1222 @retval EFI_NO_MEDIA The device has no medium. FileHandle is NULL.
1223 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1224 longer supported. FileHandle is NULL.
1225 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1226 the FileName. FileHandle is NULL.
1227 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted. FileHandle is NULL.
1228 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1229 when the media is write-protected. FileHandle is NULL.
1230 @retval EFI_ACCESS_DENIED The service denied access to the file. FileHandle is NULL.
1231 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file. FileHandle
1233 @retval EFI_VOLUME_FULL The volume is full. FileHandle is NULL.
1237 EfiShellOpenFileByName(
1238 IN CONST CHAR16
*FileName
,
1239 OUT SHELL_FILE_HANDLE
*FileHandle
,
1243 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1249 // Is this for StdIn
1251 if (StrCmp(FileName
, L
">i") == 0) {
1253 // make sure not writing to StdIn
1255 if ((OpenMode
& EFI_FILE_MODE_WRITE
) != 0) {
1256 return (EFI_INVALID_PARAMETER
);
1258 *FileHandle
= ShellInfoObject
.NewShellParametersProtocol
->StdIn
;
1259 ASSERT(*FileHandle
!= NULL
);
1260 return (EFI_SUCCESS
);
1264 // Is this for StdOut
1266 if (StrCmp(FileName
, L
">o") == 0) {
1268 // make sure not writing to StdIn
1270 if ((OpenMode
& EFI_FILE_MODE_READ
) != 0) {
1271 return (EFI_INVALID_PARAMETER
);
1273 *FileHandle
= &FileInterfaceStdOut
;
1274 return (EFI_SUCCESS
);
1278 // Is this for NUL file
1280 if (StrCmp(FileName
, L
"NUL") == 0) {
1281 *FileHandle
= &FileInterfaceNulFile
;
1282 return (EFI_SUCCESS
);
1286 // Is this for StdErr
1288 if (StrCmp(FileName
, L
">e") == 0) {
1290 // make sure not writing to StdIn
1292 if ((OpenMode
& EFI_FILE_MODE_READ
) != 0) {
1293 return (EFI_INVALID_PARAMETER
);
1295 *FileHandle
= &FileInterfaceStdErr
;
1296 return (EFI_SUCCESS
);
1300 // Is this for an environment variable
1301 // do we start with >v
1303 if (StrStr(FileName
, L
">v") == FileName
) {
1304 if (!IsVolatileEnv(FileName
+2) &&
1305 ((OpenMode
& EFI_FILE_MODE_WRITE
) != 0)) {
1306 return (EFI_INVALID_PARAMETER
);
1308 *FileHandle
= CreateFileInterfaceEnv(FileName
+2);
1309 return (EFI_SUCCESS
);
1313 // We are opening a regular file.
1315 DevicePath
= EfiShellGetDevicePathFromFilePath(FileName
);
1316 // DEBUG_CODE(InternalShellProtocolDebugPrintMessage (NULL, DevicePath););
1317 if (DevicePath
== NULL
) {
1318 return (EFI_NOT_FOUND
);
1322 // Copy the device path, open the file, then free the memory
1324 Status
= InternalOpenFileDevicePath(DevicePath
, FileHandle
, OpenMode
, 0); // 0 = no specific file attributes
1325 FreePool(DevicePath
);
1331 Deletes the file specified by the file name.
1333 This function deletes a file.
1335 @param FileName Points to the NULL-terminated file name.
1337 @retval EFI_SUCCESS The file was closed and deleted, and the handle was closed.
1338 @retval EFI_WARN_DELETE_FAILURE The handle was closed but the file was not deleted.
1339 @sa EfiShellCreateFile
1343 EfiShellDeleteFileByName(
1344 IN CONST CHAR16
*FileName
1347 SHELL_FILE_HANDLE FileHandle
;
1353 // get a handle to the file
1355 Status
= EfiShellCreateFile(FileName
,
1358 if (EFI_ERROR(Status
)) {
1362 // now delete the file
1364 return (ShellInfoObject
.NewEfiShellProtocol
->DeleteFile(FileHandle
));
1368 Disables the page break output mode.
1372 EfiShellDisablePageBreak (
1376 ShellInfoObject
.PageBreakEnabled
= FALSE
;
1380 Enables the page break output mode.
1384 EfiShellEnablePageBreak (
1388 ShellInfoObject
.PageBreakEnabled
= TRUE
;
1392 internal worker function to load and run an image via device path.
1394 @param ParentImageHandle A handle of the image that is executing the specified
1396 @param DevicePath device path of the file to execute
1397 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1398 containing the command line. If NULL then the command-
1400 @param Environment Points to a NULL-terminated array of environment
1401 variables with the format 'x=y', where x is the
1402 environment variable name and y is the value. If this
1403 is NULL, then the current shell environment is used.
1405 @param[out] StartImageStatus Returned status from gBS->StartImage.
1407 @retval EFI_SUCCESS The command executed successfully. The status code
1408 returned by the command is pointed to by StatusCode.
1409 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1410 @retval EFI_OUT_OF_RESOURCES Out of resources.
1411 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1415 InternalShellExecuteDevicePath(
1416 IN CONST EFI_HANDLE
*ParentImageHandle
,
1417 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
1418 IN CONST CHAR16
*CommandLine OPTIONAL
,
1419 IN CONST CHAR16
**Environment OPTIONAL
,
1420 OUT EFI_STATUS
*StartImageStatus OPTIONAL
1424 EFI_STATUS StartStatus
;
1425 EFI_STATUS CleanupStatus
;
1426 EFI_HANDLE NewHandle
;
1427 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
1428 LIST_ENTRY OrigEnvs
;
1429 EFI_SHELL_PARAMETERS_PROTOCOL ShellParamsProtocol
;
1435 if (ParentImageHandle
== NULL
) {
1436 return (EFI_INVALID_PARAMETER
);
1439 InitializeListHead(&OrigEnvs
);
1443 NewCmdLine
= AllocateCopyPool (StrSize (CommandLine
), CommandLine
);
1444 if (NewCmdLine
== NULL
) {
1445 return EFI_OUT_OF_RESOURCES
;
1448 for (Walker
= NewCmdLine
; Walker
!= NULL
&& *Walker
!= CHAR_NULL
; Walker
++) {
1449 if (*Walker
== L
'^' && *(Walker
+1) == L
'#') {
1450 CopyMem(Walker
, Walker
+1, StrSize(Walker
) - sizeof(Walker
[0]));
1455 // Load the image with:
1456 // FALSE - not from boot manager and NULL, 0 being not already in memory
1458 Status
= gBS
->LoadImage(
1461 (EFI_DEVICE_PATH_PROTOCOL
*)DevicePath
,
1466 if (EFI_ERROR(Status
)) {
1467 if (NewHandle
!= NULL
) {
1468 gBS
->UnloadImage(NewHandle
);
1472 Status
= gBS
->OpenProtocol(
1474 &gEfiLoadedImageProtocolGuid
,
1475 (VOID
**)&LoadedImage
,
1478 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
1480 if (!EFI_ERROR(Status
)) {
1481 ASSERT(LoadedImage
->LoadOptionsSize
== 0);
1482 if (NewCmdLine
!= NULL
) {
1483 LoadedImage
->LoadOptionsSize
= (UINT32
)StrSize(NewCmdLine
);
1484 LoadedImage
->LoadOptions
= (VOID
*)NewCmdLine
;
1488 // Save our current environment settings for later restoration if necessary
1490 if (Environment
!= NULL
) {
1491 Status
= GetEnvironmentVariableList(&OrigEnvs
);
1492 if (!EFI_ERROR(Status
)) {
1493 Status
= SetEnvironmentVariables(Environment
);
1498 // Initialize and install a shell parameters protocol on the image.
1500 ShellParamsProtocol
.StdIn
= ShellInfoObject
.NewShellParametersProtocol
->StdIn
;
1501 ShellParamsProtocol
.StdOut
= ShellInfoObject
.NewShellParametersProtocol
->StdOut
;
1502 ShellParamsProtocol
.StdErr
= ShellInfoObject
.NewShellParametersProtocol
->StdErr
;
1503 Status
= UpdateArgcArgv(&ShellParamsProtocol
, NewCmdLine
, NULL
, NULL
);
1504 ASSERT_EFI_ERROR(Status
);
1506 // Replace Argv[0] with the full path of the binary we're executing:
1507 // If the command line was "foo", the binary might be called "foo.efi".
1508 // "The first entry in [Argv] is always the full file path of the
1509 // executable" - UEFI Shell Spec section 2.3
1511 ImagePath
= EfiShellGetFilePathFromDevicePath (DevicePath
);
1512 // The image we're executing isn't necessarily in a filesystem - it might
1513 // be memory mapped. In this case EfiShellGetFilePathFromDevicePath will
1514 // return NULL, and we'll leave Argv[0] as UpdateArgcArgv set it.
1515 if (ImagePath
!= NULL
) {
1516 if (ShellParamsProtocol
.Argv
== NULL
) {
1517 // Command line was empty or null.
1518 // (UpdateArgcArgv sets Argv to NULL when CommandLine is "" or NULL)
1519 ShellParamsProtocol
.Argv
= AllocatePool (sizeof (CHAR16
*));
1520 if (ShellParamsProtocol
.Argv
== NULL
) {
1521 Status
= EFI_OUT_OF_RESOURCES
;
1524 ShellParamsProtocol
.Argc
= 1;
1526 // Free the string UpdateArgcArgv put in Argv[0];
1527 FreePool (ShellParamsProtocol
.Argv
[0]);
1529 ShellParamsProtocol
.Argv
[0] = ImagePath
;
1532 Status
= gBS
->InstallProtocolInterface(&NewHandle
, &gEfiShellParametersProtocolGuid
, EFI_NATIVE_INTERFACE
, &ShellParamsProtocol
);
1533 ASSERT_EFI_ERROR(Status
);
1535 ///@todo initialize and install ShellInterface protocol on the new image for compatibility if - PcdGetBool(PcdShellSupportOldProtocols)
1538 // now start the image and if the caller wanted the return code pass it to them...
1540 if (!EFI_ERROR(Status
)) {
1541 StartStatus
= gBS
->StartImage(
1546 if (StartImageStatus
!= NULL
) {
1547 *StartImageStatus
= StartStatus
;
1550 CleanupStatus
= gBS
->UninstallProtocolInterface(
1552 &gEfiShellParametersProtocolGuid
,
1553 &ShellParamsProtocol
1555 ASSERT_EFI_ERROR(CleanupStatus
);
1561 // Unload image - We should only get here if we didn't call StartImage
1562 gBS
->UnloadImage (NewHandle
);
1565 // Free Argv (Allocated in UpdateArgcArgv)
1566 if (ShellParamsProtocol
.Argv
!= NULL
) {
1567 for (Index
= 0; Index
< ShellParamsProtocol
.Argc
; Index
++) {
1568 if (ShellParamsProtocol
.Argv
[Index
] != NULL
) {
1569 FreePool (ShellParamsProtocol
.Argv
[Index
]);
1572 FreePool (ShellParamsProtocol
.Argv
);
1576 // Restore environment variables
1577 if (!IsListEmpty(&OrigEnvs
)) {
1578 CleanupStatus
= SetEnvironmentVariableList(&OrigEnvs
);
1579 ASSERT_EFI_ERROR (CleanupStatus
);
1582 FreePool (NewCmdLine
);
1587 Execute the command line.
1589 This function creates a nested instance of the shell and executes the specified
1590 command (CommandLine) with the specified environment (Environment). Upon return,
1591 the status code returned by the specified command is placed in StatusCode.
1593 If Environment is NULL, then the current environment is used and all changes made
1594 by the commands executed will be reflected in the current environment. If the
1595 Environment is non-NULL, then the changes made will be discarded.
1597 The CommandLine is executed from the current working directory on the current
1600 @param ParentImageHandle A handle of the image that is executing the specified
1602 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1603 containing the command line. If NULL then the command-
1605 @param Environment Points to a NULL-terminated array of environment
1606 variables with the format 'x=y', where x is the
1607 environment variable name and y is the value. If this
1608 is NULL, then the current shell environment is used.
1609 @param StatusCode Points to the status code returned by the command.
1611 @retval EFI_SUCCESS The command executed successfully. The status code
1612 returned by the command is pointed to by StatusCode.
1613 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1614 @retval EFI_OUT_OF_RESOURCES Out of resources.
1615 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1616 @retval EFI_UNSUPPORTED The support level required for this function is not present.
1618 @sa InternalShellExecuteDevicePath
1623 IN EFI_HANDLE
*ParentImageHandle
,
1624 IN CHAR16
*CommandLine OPTIONAL
,
1625 IN CHAR16
**Environment OPTIONAL
,
1626 OUT EFI_STATUS
*StatusCode OPTIONAL
1631 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
1634 if ((PcdGet8(PcdShellSupportLevel
) < 1)) {
1635 return (EFI_UNSUPPORTED
);
1638 DevPath
= AppendDevicePath (ShellInfoObject
.ImageDevPath
, ShellInfoObject
.FileDevPath
);
1641 Temp
= ConvertDevicePathToText(ShellInfoObject
.FileDevPath
, TRUE
, TRUE
);
1643 Temp
= ConvertDevicePathToText(ShellInfoObject
.ImageDevPath
, TRUE
, TRUE
);
1645 Temp
= ConvertDevicePathToText(DevPath
, TRUE
, TRUE
);
1651 ASSERT((Temp
== NULL
&& Size
== 0) || (Temp
!= NULL
));
1652 StrnCatGrow(&Temp
, &Size
, L
"Shell.efi -_exit ", 0);
1653 StrnCatGrow(&Temp
, &Size
, CommandLine
, 0);
1655 Status
= InternalShellExecuteDevicePath(
1659 (CONST CHAR16
**)Environment
,
1663 // de-allocate and return
1671 Utility cleanup function for EFI_SHELL_FILE_INFO objects.
1673 1) frees all pointers (non-NULL)
1674 2) Closes the SHELL_FILE_HANDLE
1676 @param FileListNode pointer to the list node to free
1680 InternalFreeShellFileInfoNode(
1681 IN EFI_SHELL_FILE_INFO
*FileListNode
1684 if (FileListNode
->Info
!= NULL
) {
1685 FreePool((VOID
*)FileListNode
->Info
);
1687 if (FileListNode
->FileName
!= NULL
) {
1688 FreePool((VOID
*)FileListNode
->FileName
);
1690 if (FileListNode
->FullName
!= NULL
) {
1691 FreePool((VOID
*)FileListNode
->FullName
);
1693 if (FileListNode
->Handle
!= NULL
) {
1694 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(FileListNode
->Handle
);
1696 FreePool(FileListNode
);
1699 Frees the file list.
1701 This function cleans up the file list and any related data structures. It has no
1702 impact on the files themselves.
1704 @param FileList The file list to free. Type EFI_SHELL_FILE_INFO is
1705 defined in OpenFileList()
1707 @retval EFI_SUCCESS Free the file list successfully.
1708 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1712 EfiShellFreeFileList(
1713 IN EFI_SHELL_FILE_INFO
**FileList
1716 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1718 if (FileList
== NULL
|| *FileList
== NULL
) {
1719 return (EFI_INVALID_PARAMETER
);
1722 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1723 ; !IsListEmpty(&(*FileList
)->Link
)
1724 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1726 RemoveEntryList(&ShellFileListItem
->Link
);
1727 InternalFreeShellFileInfoNode(ShellFileListItem
);
1729 InternalFreeShellFileInfoNode(*FileList
);
1731 return(EFI_SUCCESS
);
1735 Deletes the duplicate file names files in the given file list.
1737 This function deletes the reduplicate files in the given file list.
1739 @param FileList A pointer to the first entry in the file list.
1741 @retval EFI_SUCCESS Always success.
1742 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1746 EfiShellRemoveDupInFileList(
1747 IN EFI_SHELL_FILE_INFO
**FileList
1750 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1751 EFI_SHELL_FILE_INFO
*ShellFileListItem2
;
1752 EFI_SHELL_FILE_INFO
*TempNode
;
1754 if (FileList
== NULL
|| *FileList
== NULL
) {
1755 return (EFI_INVALID_PARAMETER
);
1757 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1758 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1759 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1761 for ( ShellFileListItem2
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1762 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem2
->Link
)
1763 ; ShellFileListItem2
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem2
->Link
)
1765 if (gUnicodeCollation
->StriColl(
1767 (CHAR16
*)ShellFileListItem
->FullName
,
1768 (CHAR16
*)ShellFileListItem2
->FullName
) == 0
1770 TempNode
= (EFI_SHELL_FILE_INFO
*)GetPreviousNode(
1772 &ShellFileListItem2
->Link
1774 RemoveEntryList(&ShellFileListItem2
->Link
);
1775 InternalFreeShellFileInfoNode(ShellFileListItem2
);
1776 // Set ShellFileListItem2 to PreviousNode so we don't access Freed
1777 // memory in GetNextNode in the loop expression above.
1778 ShellFileListItem2
= TempNode
;
1782 return (EFI_SUCCESS
);
1786 // This is the same structure as the external version, but it has no CONST qualifiers.
1789 LIST_ENTRY Link
; ///< Linked list members.
1790 EFI_STATUS Status
; ///< Status of opening the file. Valid only if Handle != NULL.
1791 CHAR16
*FullName
; ///< Fully qualified filename.
1792 CHAR16
*FileName
; ///< name of this file.
1793 SHELL_FILE_HANDLE Handle
; ///< Handle for interacting with the opened file or NULL if closed.
1794 EFI_FILE_INFO
*Info
; ///< Pointer to the FileInfo struct for this file or NULL.
1795 } EFI_SHELL_FILE_INFO_NO_CONST
;
1798 Allocates and duplicates a EFI_SHELL_FILE_INFO node.
1800 @param[in] Node The node to copy from.
1801 @param[in] Save TRUE to set Node->Handle to NULL, FALSE otherwise.
1803 @retval NULL a memory allocation error ocurred
1804 @return != NULL a pointer to the new node
1806 EFI_SHELL_FILE_INFO
*
1808 InternalDuplicateShellFileInfo(
1809 IN EFI_SHELL_FILE_INFO
*Node
,
1813 EFI_SHELL_FILE_INFO_NO_CONST
*NewNode
;
1816 // try to confirm that the objects are in sync
1818 ASSERT(sizeof(EFI_SHELL_FILE_INFO_NO_CONST
) == sizeof(EFI_SHELL_FILE_INFO
));
1820 NewNode
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1821 if (NewNode
== NULL
) {
1824 NewNode
->FullName
= AllocateCopyPool(StrSize(Node
->FullName
), Node
->FullName
);
1825 NewNode
->FileName
= AllocateCopyPool(StrSize(Node
->FileName
), Node
->FileName
);
1826 NewNode
->Info
= AllocateCopyPool((UINTN
)Node
->Info
->Size
, Node
->Info
);
1827 if ( NewNode
->FullName
== NULL
1828 || NewNode
->FileName
== NULL
1829 || NewNode
->Info
== NULL
1831 SHELL_FREE_NON_NULL(NewNode
->FullName
);
1832 SHELL_FREE_NON_NULL(NewNode
->FileName
);
1833 SHELL_FREE_NON_NULL(NewNode
->Info
);
1834 SHELL_FREE_NON_NULL(NewNode
);
1837 NewNode
->Status
= Node
->Status
;
1838 NewNode
->Handle
= Node
->Handle
;
1840 Node
->Handle
= NULL
;
1843 return((EFI_SHELL_FILE_INFO
*)NewNode
);
1847 Allocates and populates a EFI_SHELL_FILE_INFO structure. if any memory operation
1848 failed it will return NULL.
1850 @param[in] BasePath the Path to prepend onto filename for FullPath
1851 @param[in] Status Status member initial value.
1852 @param[in] FileName FileName member initial value.
1853 @param[in] Handle Handle member initial value.
1854 @param[in] Info Info struct to copy.
1856 @retval NULL An error ocurred.
1857 @return a pointer to the newly allocated structure.
1859 EFI_SHELL_FILE_INFO
*
1861 CreateAndPopulateShellFileInfo(
1862 IN CONST CHAR16
*BasePath
,
1863 IN CONST EFI_STATUS Status
,
1864 IN CONST CHAR16
*FileName
,
1865 IN CONST SHELL_FILE_HANDLE Handle
,
1866 IN CONST EFI_FILE_INFO
*Info
1869 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1876 ShellFileListItem
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1877 if (ShellFileListItem
== NULL
) {
1880 if (Info
!= NULL
&& Info
->Size
!= 0) {
1881 ShellFileListItem
->Info
= AllocateZeroPool((UINTN
)Info
->Size
);
1882 if (ShellFileListItem
->Info
== NULL
) {
1883 FreePool(ShellFileListItem
);
1886 CopyMem(ShellFileListItem
->Info
, Info
, (UINTN
)Info
->Size
);
1888 ShellFileListItem
->Info
= NULL
;
1890 if (FileName
!= NULL
) {
1891 ASSERT(TempString
== NULL
);
1892 ShellFileListItem
->FileName
= StrnCatGrow(&TempString
, 0, FileName
, 0);
1893 if (ShellFileListItem
->FileName
== NULL
) {
1894 FreePool(ShellFileListItem
->Info
);
1895 FreePool(ShellFileListItem
);
1899 ShellFileListItem
->FileName
= NULL
;
1903 if (BasePath
!= NULL
) {
1904 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
1905 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
1906 if (TempString
== NULL
) {
1907 FreePool((VOID
*)ShellFileListItem
->FileName
);
1908 SHELL_FREE_NON_NULL(ShellFileListItem
->Info
);
1909 FreePool(ShellFileListItem
);
1913 if (ShellFileListItem
->FileName
!= NULL
) {
1914 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
1915 TempString
= StrnCatGrow(&TempString
, &Size
, ShellFileListItem
->FileName
, 0);
1916 if (TempString
== NULL
) {
1917 FreePool((VOID
*)ShellFileListItem
->FileName
);
1918 FreePool(ShellFileListItem
->Info
);
1919 FreePool(ShellFileListItem
);
1924 TempString
= PathCleanUpDirectories(TempString
);
1926 ShellFileListItem
->FullName
= TempString
;
1927 ShellFileListItem
->Status
= Status
;
1928 ShellFileListItem
->Handle
= Handle
;
1930 return (ShellFileListItem
);
1934 Find all files in a specified directory.
1936 @param FileDirHandle Handle of the directory to search.
1937 @param FileList On return, points to the list of files in the directory
1938 or NULL if there are no files in the directory.
1940 @retval EFI_SUCCESS File information was returned successfully.
1941 @retval EFI_VOLUME_CORRUPTED The file system structures have been corrupted.
1942 @retval EFI_DEVICE_ERROR The device reported an error.
1943 @retval EFI_NO_MEDIA The device media is not present.
1944 @retval EFI_INVALID_PARAMETER The FileDirHandle was not a directory.
1945 @return An error from FileHandleGetFileName().
1949 EfiShellFindFilesInDir(
1950 IN SHELL_FILE_HANDLE FileDirHandle
,
1951 OUT EFI_SHELL_FILE_INFO
**FileList
1954 EFI_SHELL_FILE_INFO
*ShellFileList
;
1955 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1956 EFI_FILE_INFO
*FileInfo
;
1965 Status
= FileHandleGetFileName(FileDirHandle
, &BasePath
);
1966 if (EFI_ERROR(Status
)) {
1970 if (ShellFileHandleGetPath(FileDirHandle
) != NULL
) {
1973 TempString
= StrnCatGrow(&TempString
, &Size
, ShellFileHandleGetPath(FileDirHandle
), 0);
1974 if (TempString
== NULL
) {
1975 SHELL_FREE_NON_NULL(BasePath
);
1976 return (EFI_OUT_OF_RESOURCES
);
1978 TempSpot
= StrStr(TempString
, L
";");
1980 if (TempSpot
!= NULL
) {
1981 *TempSpot
= CHAR_NULL
;
1984 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
1985 if (TempString
== NULL
) {
1986 SHELL_FREE_NON_NULL(BasePath
);
1987 return (EFI_OUT_OF_RESOURCES
);
1989 SHELL_FREE_NON_NULL(BasePath
);
1990 BasePath
= TempString
;
1994 ShellFileList
= NULL
;
1995 ShellFileListItem
= NULL
;
1997 Status
= EFI_SUCCESS
;
2000 for ( Status
= FileHandleFindFirstFile(FileDirHandle
, &FileInfo
)
2001 ; !EFI_ERROR(Status
) && !NoFile
2002 ; Status
= FileHandleFindNextFile(FileDirHandle
, FileInfo
, &NoFile
)
2005 // allocate a new EFI_SHELL_FILE_INFO and populate it...
2007 ShellFileListItem
= CreateAndPopulateShellFileInfo(
2009 EFI_SUCCESS
, // success since we didnt fail to open it...
2011 NULL
, // no handle since not open
2014 if (ShellFileList
== NULL
) {
2015 ShellFileList
= (EFI_SHELL_FILE_INFO
*)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2016 ASSERT(ShellFileList
!= NULL
);
2017 InitializeListHead(&ShellFileList
->Link
);
2019 InsertTailList(&ShellFileList
->Link
, &ShellFileListItem
->Link
);
2021 if (EFI_ERROR(Status
)) {
2022 EfiShellFreeFileList(&ShellFileList
);
2025 *FileList
= ShellFileList
;
2027 SHELL_FREE_NON_NULL(BasePath
);
2032 Get the GUID value from a human readable name.
2034 If GuidName is a known GUID name, then update Guid to have the correct value for
2037 This function is only available when the major and minor versions in the
2038 EfiShellProtocol are greater than or equal to 2 and 1, respectively.
2040 @param[in] GuidName A pointer to the localized name for the GUID being queried.
2041 @param[out] Guid A pointer to the GUID structure to be filled in.
2043 @retval EFI_SUCCESS The operation was successful.
2044 @retval EFI_INVALID_PARAMETER Guid was NULL.
2045 @retval EFI_INVALID_PARAMETER GuidName was NULL.
2046 @retval EFI_NOT_FOUND GuidName is not a known GUID Name.
2050 EfiShellGetGuidFromName(
2051 IN CONST CHAR16
*GuidName
,
2058 if (Guid
== NULL
|| GuidName
== NULL
) {
2059 return (EFI_INVALID_PARAMETER
);
2062 Status
= GetGuidFromStringName(GuidName
, NULL
, &NewGuid
);
2064 if (!EFI_ERROR(Status
)) {
2065 CopyGuid(NewGuid
, Guid
);
2072 Get the human readable name for a GUID from the value.
2074 If Guid is assigned a name, then update *GuidName to point to the name. The callee
2075 should not modify the value.
2077 This function is only available when the major and minor versions in the
2078 EfiShellProtocol are greater than or equal to 2 and 1, respectively.
2080 @param[in] Guid A pointer to the GUID being queried.
2081 @param[out] GuidName A pointer to a pointer the localized to name for the GUID being requested
2083 @retval EFI_SUCCESS The operation was successful.
2084 @retval EFI_INVALID_PARAMETER Guid was NULL.
2085 @retval EFI_INVALID_PARAMETER GuidName was NULL.
2086 @retval EFI_NOT_FOUND Guid is not assigned a name.
2090 EfiShellGetGuidName(
2091 IN CONST EFI_GUID
*Guid
,
2092 OUT CONST CHAR16
**GuidName
2097 if (Guid
== NULL
|| GuidName
== NULL
) {
2098 return (EFI_INVALID_PARAMETER
);
2101 Name
= GetStringNameFromGuid(Guid
, NULL
);
2102 if (Name
== NULL
|| StrLen(Name
) == 0) {
2103 SHELL_FREE_NON_NULL(Name
);
2104 return (EFI_NOT_FOUND
);
2107 *GuidName
= AddBufferToFreeList(Name
);
2109 return (EFI_SUCCESS
);
2113 Updates a file name to be preceeded by the mapped drive name
2115 @param[in] BasePath the Mapped drive name to prepend
2116 @param[in, out] Path pointer to pointer to the file name to update.
2119 @retval EFI_OUT_OF_RESOURCES
2124 IN CONST CHAR16
*BasePath
,
2125 IN OUT CHAR16
**Path
2134 ASSERT(Path
!= NULL
);
2135 ASSERT(*Path
!= NULL
);
2136 ASSERT(BasePath
!= NULL
);
2139 // convert a local path to an absolute path
2141 if (StrStr(*Path
, L
":") == NULL
) {
2142 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2143 StrnCatGrow(&Path2
, &Path2Size
, BasePath
, 0);
2144 if (Path2
== NULL
) {
2145 return (EFI_OUT_OF_RESOURCES
);
2147 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2148 StrnCatGrow(&Path2
, &Path2Size
, (*Path
)[0] == L
'\\'?(*Path
) + 1 :*Path
, 0);
2149 if (Path2
== NULL
) {
2150 return (EFI_OUT_OF_RESOURCES
);
2157 return (EFI_SUCCESS
);
2161 If FileHandle is a directory then the function reads from FileHandle and reads in
2162 each of the FileInfo structures. If one of them matches the Pattern's first
2163 "level" then it opens that handle and calls itself on that handle.
2165 If FileHandle is a file and matches all of the remaining Pattern (which would be
2166 on its last node), then add a EFI_SHELL_FILE_INFO object for this file to fileList.
2168 Upon a EFI_SUCCESS return fromt he function any the caller is responsible to call
2169 FreeFileList with FileList.
2171 @param[in] FilePattern The FilePattern to check against.
2172 @param[in] UnicodeCollation The pointer to EFI_UNICODE_COLLATION_PROTOCOL structure
2173 @param[in] FileHandle The FileHandle to start with
2174 @param[in, out] FileList pointer to pointer to list of found files.
2175 @param[in] ParentNode The node for the parent. Same file as identified by HANDLE.
2176 @param[in] MapName The file system name this file is on.
2178 @retval EFI_SUCCESS all files were found and the FileList contains a list.
2179 @retval EFI_NOT_FOUND no files were found
2180 @retval EFI_OUT_OF_RESOURCES a memory allocation failed
2185 IN CONST CHAR16
*FilePattern
,
2186 IN EFI_UNICODE_COLLATION_PROTOCOL
*UnicodeCollation
,
2187 IN SHELL_FILE_HANDLE FileHandle
,
2188 IN OUT EFI_SHELL_FILE_INFO
**FileList
,
2189 IN CONST EFI_SHELL_FILE_INFO
*ParentNode OPTIONAL
,
2190 IN CONST CHAR16
*MapName
2194 CONST CHAR16
*NextFilePatternStart
;
2195 CHAR16
*CurrentFilePattern
;
2196 EFI_SHELL_FILE_INFO
*ShellInfo
;
2197 EFI_SHELL_FILE_INFO
*ShellInfoNode
;
2198 EFI_SHELL_FILE_INFO
*NewShellNode
;
2199 EFI_FILE_INFO
*FileInfo
;
2201 CHAR16
*NewFullName
;
2204 if ( FilePattern
== NULL
2205 || UnicodeCollation
== NULL
2208 return (EFI_INVALID_PARAMETER
);
2211 CurrentFilePattern
= NULL
;
2213 if (*FilePattern
== L
'\\') {
2217 for( NextFilePatternStart
= FilePattern
2218 ; *NextFilePatternStart
!= CHAR_NULL
&& *NextFilePatternStart
!= L
'\\'
2219 ; NextFilePatternStart
++);
2221 CurrentFilePattern
= AllocateZeroPool((NextFilePatternStart
-FilePattern
+1)*sizeof(CHAR16
));
2222 ASSERT(CurrentFilePattern
!= NULL
);
2223 StrnCpyS(CurrentFilePattern
, NextFilePatternStart
-FilePattern
+1, FilePattern
, NextFilePatternStart
-FilePattern
);
2225 if (CurrentFilePattern
[0] == CHAR_NULL
2226 &&NextFilePatternStart
[0] == CHAR_NULL
2229 // we want the parent or root node (if no parent)
2231 if (ParentNode
== NULL
) {
2233 // We want the root node. create the node.
2235 FileInfo
= FileHandleGetInfo(FileHandle
);
2236 NewShellNode
= CreateAndPopulateShellFileInfo(
2243 SHELL_FREE_NON_NULL(FileInfo
);
2246 // Add the current parameter FileHandle to the list, then end...
2248 NewShellNode
= InternalDuplicateShellFileInfo((EFI_SHELL_FILE_INFO
*)ParentNode
, TRUE
);
2250 if (NewShellNode
== NULL
) {
2251 Status
= EFI_OUT_OF_RESOURCES
;
2253 NewShellNode
->Handle
= NULL
;
2254 if (*FileList
== NULL
) {
2255 *FileList
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2256 InitializeListHead(&((*FileList
)->Link
));
2260 // Add to the returning to use list
2262 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
2264 Status
= EFI_SUCCESS
;
2267 Status
= EfiShellFindFilesInDir(FileHandle
, &ShellInfo
);
2269 if (!EFI_ERROR(Status
)){
2270 if (StrStr(NextFilePatternStart
, L
"\\") != NULL
){
2275 for ( ShellInfoNode
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&ShellInfo
->Link
)
2276 ; !IsNull (&ShellInfo
->Link
, &ShellInfoNode
->Link
)
2277 ; ShellInfoNode
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&ShellInfo
->Link
, &ShellInfoNode
->Link
)
2279 if (UnicodeCollation
->MetaiMatch(UnicodeCollation
, (CHAR16
*)ShellInfoNode
->FileName
, CurrentFilePattern
)){
2280 if (ShellInfoNode
->FullName
!= NULL
&& StrStr(ShellInfoNode
->FullName
, L
":") == NULL
) {
2281 Size
= StrSize(ShellInfoNode
->FullName
);
2282 Size
+= StrSize(MapName
) + sizeof(CHAR16
);
2283 NewFullName
= AllocateZeroPool(Size
);
2284 if (NewFullName
== NULL
) {
2285 Status
= EFI_OUT_OF_RESOURCES
;
2287 StrCpyS(NewFullName
, Size
/sizeof(CHAR16
), MapName
);
2288 StrCatS(NewFullName
, Size
/sizeof(CHAR16
), ShellInfoNode
->FullName
+1);
2289 FreePool((VOID
*)ShellInfoNode
->FullName
);
2290 ShellInfoNode
->FullName
= NewFullName
;
2293 if (Directory
&& !EFI_ERROR(Status
) && ShellInfoNode
->FullName
!= NULL
&& ShellInfoNode
->FileName
!= NULL
){
2295 // should be a directory
2299 // don't open the . and .. directories
2301 if ( (StrCmp(ShellInfoNode
->FileName
, L
".") != 0)
2302 && (StrCmp(ShellInfoNode
->FileName
, L
"..") != 0)
2307 if (EFI_ERROR(Status
)) {
2311 // Open the directory since we need that handle in the next recursion.
2313 ShellInfoNode
->Status
= EfiShellOpenFileByName (ShellInfoNode
->FullName
, &ShellInfoNode
->Handle
, EFI_FILE_MODE_READ
);
2316 // recurse with the next part of the pattern
2318 Status
= ShellSearchHandle(NextFilePatternStart
, UnicodeCollation
, ShellInfoNode
->Handle
, FileList
, ShellInfoNode
, MapName
);
2320 } else if (!EFI_ERROR(Status
)) {
2326 // copy the information we need into a new Node
2328 NewShellNode
= InternalDuplicateShellFileInfo(ShellInfoNode
, FALSE
);
2329 ASSERT(NewShellNode
!= NULL
);
2330 if (NewShellNode
== NULL
) {
2331 Status
= EFI_OUT_OF_RESOURCES
;
2333 if (*FileList
== NULL
) {
2334 *FileList
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
2335 InitializeListHead(&((*FileList
)->Link
));
2339 // Add to the returning to use list
2341 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
2344 if (EFI_ERROR(Status
)) {
2348 if (EFI_ERROR(Status
)) {
2349 EfiShellFreeFileList(&ShellInfo
);
2351 Status
= EfiShellFreeFileList(&ShellInfo
);
2356 FreePool(CurrentFilePattern
);
2361 Find files that match a specified pattern.
2363 This function searches for all files and directories that match the specified
2364 FilePattern. The FilePattern can contain wild-card characters. The resulting file
2365 information is placed in the file list FileList.
2367 Wildcards are processed
2368 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1.
2370 The files in the file list are not opened. The OpenMode field is set to 0 and the FileInfo
2371 field is set to NULL.
2373 if *FileList is not NULL then it must be a pre-existing and properly initialized list.
2375 @param FilePattern Points to a NULL-terminated shell file path, including wildcards.
2376 @param FileList On return, points to the start of a file list containing the names
2377 of all matching files or else points to NULL if no matching files
2378 were found. only on a EFI_SUCCESS return will; this be non-NULL.
2380 @retval EFI_SUCCESS Files found. FileList is a valid list.
2381 @retval EFI_NOT_FOUND No files found.
2382 @retval EFI_NO_MEDIA The device has no media
2383 @retval EFI_DEVICE_ERROR The device reported an error
2384 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted
2389 IN CONST CHAR16
*FilePattern
,
2390 OUT EFI_SHELL_FILE_INFO
**FileList
2394 CHAR16
*PatternCopy
;
2395 CHAR16
*PatternCurrentLocation
;
2396 EFI_DEVICE_PATH_PROTOCOL
*RootDevicePath
;
2397 SHELL_FILE_HANDLE RootFileHandle
;
2401 if ( FilePattern
== NULL
2403 || StrStr(FilePattern
, L
":") == NULL
2405 return (EFI_INVALID_PARAMETER
);
2407 Status
= EFI_SUCCESS
;
2408 RootDevicePath
= NULL
;
2409 RootFileHandle
= NULL
;
2411 PatternCopy
= AllocateCopyPool(StrSize(FilePattern
), FilePattern
);
2412 if (PatternCopy
== NULL
) {
2413 return (EFI_OUT_OF_RESOURCES
);
2416 PatternCopy
= PathCleanUpDirectories(PatternCopy
);
2418 Count
= StrStr(PatternCopy
, L
":") - PatternCopy
;
2421 ASSERT(MapName
== NULL
);
2422 MapName
= StrnCatGrow(&MapName
, NULL
, PatternCopy
, Count
);
2423 if (MapName
== NULL
) {
2424 Status
= EFI_OUT_OF_RESOURCES
;
2426 RootDevicePath
= EfiShellGetDevicePathFromFilePath(PatternCopy
);
2427 if (RootDevicePath
== NULL
) {
2428 Status
= EFI_INVALID_PARAMETER
;
2430 Status
= EfiShellOpenRoot(RootDevicePath
, &RootFileHandle
);
2431 if (!EFI_ERROR(Status
)) {
2432 for ( PatternCurrentLocation
= PatternCopy
2433 ; *PatternCurrentLocation
!= ':'
2434 ; PatternCurrentLocation
++);
2435 PatternCurrentLocation
++;
2436 Status
= ShellSearchHandle(PatternCurrentLocation
, gUnicodeCollation
, RootFileHandle
, FileList
, NULL
, MapName
);
2438 FreePool(RootDevicePath
);
2442 SHELL_FREE_NON_NULL(PatternCopy
);
2443 SHELL_FREE_NON_NULL(MapName
);
2449 Opens the files that match the path specified.
2451 This function opens all of the files specified by Path. Wildcards are processed
2452 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1. Each
2453 matching file has an EFI_SHELL_FILE_INFO structure created in a linked list.
2455 @param Path A pointer to the path string.
2456 @param OpenMode Specifies the mode used to open each file, EFI_FILE_MODE_READ or
2457 EFI_FILE_MODE_WRITE.
2458 @param FileList Points to the start of a list of files opened.
2460 @retval EFI_SUCCESS Create the file list successfully.
2461 @return Others Can't create the file list.
2465 EfiShellOpenFileList(
2468 IN OUT EFI_SHELL_FILE_INFO
**FileList
2472 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
2475 CONST CHAR16
*CurDir
;
2478 PathCleanUpDirectories(Path
);
2483 if (FileList
== NULL
|| *FileList
== NULL
) {
2484 return (EFI_INVALID_PARAMETER
);
2487 if (*Path
== L
'.' && *(Path
+1) == L
'\\') {
2492 // convert a local path to an absolute path
2494 if (StrStr(Path
, L
":") == NULL
) {
2495 CurDir
= EfiShellGetCurDir(NULL
);
2496 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2497 StrnCatGrow(&Path2
, &Path2Size
, CurDir
, 0);
2498 if (*Path
== L
'\\') {
2500 while (PathRemoveLastItem(Path2
)) ;
2502 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2503 StrnCatGrow(&Path2
, &Path2Size
, Path
, 0);
2505 ASSERT(Path2
== NULL
);
2506 StrnCatGrow(&Path2
, NULL
, Path
, 0);
2509 PathCleanUpDirectories (Path2
);
2514 Status
= EfiShellFindFiles(Path2
, FileList
);
2518 if (EFI_ERROR(Status
)) {
2524 // We had no errors so open all the files (that are not already opened...)
2526 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
2527 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2528 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2530 if (ShellFileListItem
->Status
== 0 && ShellFileListItem
->Handle
== NULL
) {
2531 ShellFileListItem
->Status
= EfiShellOpenFileByName (ShellFileListItem
->FullName
, &ShellFileListItem
->Handle
, OpenMode
);
2537 return (EFI_NOT_FOUND
);
2539 return(EFI_SUCCESS
);
2543 Gets the environment variable and Attributes, or list of environment variables. Can be
2544 used instead of GetEnv().
2546 This function returns the current value of the specified environment variable and
2547 the Attributes. If no variable name was specified, then all of the known
2548 variables will be returned.
2550 @param[in] Name A pointer to the environment variable name. If Name is NULL,
2551 then the function will return all of the defined shell
2552 environment variables. In the case where multiple environment
2553 variables are being returned, each variable will be terminated
2554 by a NULL, and the list will be terminated by a double NULL.
2555 @param[out] Attributes If not NULL, a pointer to the returned attributes bitmask for
2556 the environment variable. In the case where Name is NULL, and
2557 multiple environment variables are being returned, Attributes
2560 @retval NULL The environment variable doesn't exist.
2561 @return A non-NULL value points to the variable's value. The returned
2562 pointer does not need to be freed by the caller.
2567 IN CONST CHAR16
*Name
,
2568 OUT UINT32
*Attributes OPTIONAL
2576 CHAR16
*CurrentWriteLocation
;
2583 // Get all our environment variables
2585 InitializeListHead(&List
);
2586 Status
= GetEnvironmentVariableList(&List
);
2587 if (EFI_ERROR(Status
)){
2592 // Build the semi-colon delimited list. (2 passes)
2594 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&List
)
2595 ; !IsNull(&List
, &Node
->Link
)
2596 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&List
, &Node
->Link
)
2598 ASSERT(Node
->Key
!= NULL
);
2599 Size
+= StrSize(Node
->Key
);
2602 Size
+= 2*sizeof(CHAR16
);
2604 Buffer
= AllocateZeroPool(Size
);
2605 if (Buffer
== NULL
) {
2606 if (!IsListEmpty (&List
)) {
2607 FreeEnvironmentVariableList(&List
);
2611 CurrentWriteLocation
= (CHAR16
*)Buffer
;
2613 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&List
)
2614 ; !IsNull(&List
, &Node
->Link
)
2615 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&List
, &Node
->Link
)
2617 ASSERT(Node
->Key
!= NULL
);
2618 StrCpyS( CurrentWriteLocation
,
2619 (Size
)/sizeof(CHAR16
) - (CurrentWriteLocation
- ((CHAR16
*)Buffer
)),
2622 CurrentWriteLocation
+= StrLen(CurrentWriteLocation
) + 1;
2628 if (!IsListEmpty (&List
)) {
2629 FreeEnvironmentVariableList(&List
);
2633 // We are doing a specific environment variable
2637 // get the size we need for this EnvVariable
2639 Status
= SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(Name
, Attributes
, &Size
, Buffer
);
2640 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2642 // Allocate the space and recall the get function
2644 Buffer
= AllocateZeroPool(Size
);
2645 Status
= SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(Name
, Attributes
, &Size
, Buffer
);
2648 // we didnt get it (might not exist)
2649 // free the memory if we allocated any and return NULL
2651 if (EFI_ERROR(Status
)) {
2652 if (Buffer
!= NULL
) {
2660 // return the buffer
2662 return (AddBufferToFreeList(Buffer
));
2666 Gets either a single or list of environment variables.
2668 If name is not NULL then this function returns the current value of the specified
2669 environment variable.
2671 If Name is NULL, then a list of all environment variable names is returned. Each is a
2672 NULL terminated string with a double NULL terminating the list.
2674 @param Name A pointer to the environment variable name. If
2675 Name is NULL, then the function will return all
2676 of the defined shell environment variables. In
2677 the case where multiple environment variables are
2678 being returned, each variable will be terminated by
2679 a NULL, and the list will be terminated by a double
2682 @retval !=NULL A pointer to the returned string.
2683 The returned pointer does not need to be freed by the caller.
2685 @retval NULL The environment variable doesn't exist or there are
2686 no environment variables.
2691 IN CONST CHAR16
*Name
2694 return (EfiShellGetEnvEx(Name
, NULL
));
2698 Internal variable setting function. Allows for setting of the read only variables.
2700 @param Name Points to the NULL-terminated environment variable name.
2701 @param Value Points to the NULL-terminated environment variable value. If the value is an
2702 empty string then the environment variable is deleted.
2703 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2705 @retval EFI_SUCCESS The environment variable was successfully updated.
2709 InternalEfiShellSetEnv(
2710 IN CONST CHAR16
*Name
,
2711 IN CONST CHAR16
*Value
,
2715 if (Value
== NULL
|| StrLen(Value
) == 0) {
2716 return (SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
));
2718 SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
);
2720 return (SHELL_SET_ENVIRONMENT_VARIABLE_V(Name
, StrSize(Value
), Value
));
2722 return (SHELL_SET_ENVIRONMENT_VARIABLE_NV(Name
, StrSize(Value
), Value
));
2728 Sets the environment variable.
2730 This function changes the current value of the specified environment variable. If the
2731 environment variable exists and the Value is an empty string, then the environment
2732 variable is deleted. If the environment variable exists and the Value is not an empty
2733 string, then the value of the environment variable is changed. If the environment
2734 variable does not exist and the Value is an empty string, there is no action. If the
2735 environment variable does not exist and the Value is a non-empty string, then the
2736 environment variable is created and assigned the specified value.
2738 For a description of volatile and non-volatile environment variables, see UEFI Shell
2739 2.0 specification section 3.6.1.
2741 @param Name Points to the NULL-terminated environment variable name.
2742 @param Value Points to the NULL-terminated environment variable value. If the value is an
2743 empty string then the environment variable is deleted.
2744 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2746 @retval EFI_SUCCESS The environment variable was successfully updated.
2751 IN CONST CHAR16
*Name
,
2752 IN CONST CHAR16
*Value
,
2756 if (Name
== NULL
|| *Name
== CHAR_NULL
) {
2757 return (EFI_INVALID_PARAMETER
);
2760 // Make sure we dont 'set' a predefined read only variable
2762 if (gUnicodeCollation
->StriColl(
2766 ||gUnicodeCollation
->StriColl(
2770 ||gUnicodeCollation
->StriColl(
2774 ||gUnicodeCollation
->StriColl(
2777 L
"uefishellsupport") == 0
2778 ||gUnicodeCollation
->StriColl(
2781 L
"uefishellversion") == 0
2782 ||gUnicodeCollation
->StriColl(
2785 L
"uefiversion") == 0
2787 return (EFI_INVALID_PARAMETER
);
2789 return (InternalEfiShellSetEnv(Name
, Value
, Volatile
));
2793 Returns the current directory on the specified device.
2795 If FileSystemMapping is NULL, it returns the current working directory. If the
2796 FileSystemMapping is not NULL, it returns the current directory associated with the
2797 FileSystemMapping. In both cases, the returned name includes the file system
2798 mapping (i.e. fs0:\current-dir).
2800 @param FileSystemMapping A pointer to the file system mapping. If NULL,
2801 then the current working directory is returned.
2803 @retval !=NULL The current directory.
2804 @retval NULL Current directory does not exist.
2809 IN CONST CHAR16
*FileSystemMapping OPTIONAL
2812 CHAR16
*PathToReturn
;
2814 SHELL_MAP_LIST
*MapListItem
;
2815 if (!IsListEmpty(&gShellMapList
.Link
)) {
2817 // if parameter is NULL, use current
2819 if (FileSystemMapping
== NULL
) {
2820 return (EfiShellGetEnv(L
"cwd"));
2823 PathToReturn
= NULL
;
2824 MapListItem
= ShellCommandFindMapItem(FileSystemMapping
);
2825 if (MapListItem
!= NULL
) {
2826 ASSERT((PathToReturn
== NULL
&& Size
== 0) || (PathToReturn
!= NULL
));
2827 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->MapName
, 0);
2828 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
2831 return (AddBufferToFreeList(PathToReturn
));
2838 Changes the current directory on the specified device.
2840 If the FileSystem is NULL, and the directory Dir does not contain a file system's
2841 mapped name, this function changes the current working directory.
2843 If the FileSystem is NULL and the directory Dir contains a mapped name, then the
2844 current file system and the current directory on that file system are changed.
2846 If FileSystem is NULL, and Dir is not NULL, then this changes the current working file
2849 If FileSystem is not NULL and Dir is not NULL, then this function changes the current
2850 directory on the specified file system.
2852 If the current working directory or the current working file system is changed then the
2853 %cwd% environment variable will be updated
2855 @param FileSystem A pointer to the file system's mapped name. If NULL, then the current working
2856 directory is changed.
2857 @param Dir Points to the NULL-terminated directory on the device specified by FileSystem.
2859 @retval EFI_SUCCESS The operation was sucessful
2860 @retval EFI_NOT_FOUND The file system could not be found
2865 IN CONST CHAR16
*FileSystem OPTIONAL
,
2866 IN CONST CHAR16
*Dir
2870 SHELL_MAP_LIST
*MapListItem
;
2874 CHAR16
*DirectoryName
;
2881 DirectoryName
= NULL
;
2883 if ((FileSystem
== NULL
&& Dir
== NULL
) || Dir
== NULL
) {
2884 return (EFI_INVALID_PARAMETER
);
2887 if (IsListEmpty(&gShellMapList
.Link
)){
2888 return (EFI_NOT_FOUND
);
2891 DirectoryName
= StrnCatGrow(&DirectoryName
, NULL
, Dir
, 0);
2892 ASSERT(DirectoryName
!= NULL
);
2894 PathCleanUpDirectories(DirectoryName
);
2896 if (FileSystem
== NULL
) {
2898 // determine the file system mapping to use
2900 if (StrStr(DirectoryName
, L
":") != NULL
) {
2901 ASSERT(MapName
== NULL
);
2902 MapName
= StrnCatGrow(&MapName
, NULL
, DirectoryName
, (StrStr(DirectoryName
, L
":")-DirectoryName
+1));
2905 // find the file system mapping's entry in the list
2908 if (MapName
!= NULL
) {
2909 MapListItem
= ShellCommandFindMapItem(MapName
);
2912 // make that the current file system mapping
2914 if (MapListItem
!= NULL
) {
2915 gShellCurDir
= MapListItem
;
2918 MapListItem
= gShellCurDir
;
2921 if (MapListItem
== NULL
) {
2922 return (EFI_NOT_FOUND
);
2926 // now update the MapListItem's current directory
2928 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& DirectoryName
[StrLen(DirectoryName
) - 1] != L
':') {
2929 FreePool(MapListItem
->CurrentDirectoryPath
);
2930 MapListItem
->CurrentDirectoryPath
= NULL
;
2932 if (MapName
!= NULL
) {
2933 TempLen
= StrLen(MapName
);
2934 if (TempLen
!= StrLen(DirectoryName
)) {
2935 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2936 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
+StrLen(MapName
), 0);
2939 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2940 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
2942 if ((MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] != L
'\\') || (MapListItem
->CurrentDirectoryPath
== NULL
)) {
2943 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2944 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2948 // cant have a mapping in the directory...
2950 if (StrStr(DirectoryName
, L
":") != NULL
) {
2951 return (EFI_INVALID_PARAMETER
);
2954 // FileSystem != NULL
2956 MapListItem
= ShellCommandFindMapItem(FileSystem
);
2957 if (MapListItem
== NULL
) {
2958 return (EFI_INVALID_PARAMETER
);
2960 // gShellCurDir = MapListItem;
2961 if (DirectoryName
!= NULL
) {
2963 // change current dir on that file system
2966 if (MapListItem
->CurrentDirectoryPath
!= NULL
) {
2967 FreePool(MapListItem
->CurrentDirectoryPath
);
2968 DEBUG_CODE(MapListItem
->CurrentDirectoryPath
= NULL
;);
2970 // ASSERT((MapListItem->CurrentDirectoryPath == NULL && Size == 0) || (MapListItem->CurrentDirectoryPath != NULL));
2971 // MapListItem->CurrentDirectoryPath = StrnCatGrow(&MapListItem->CurrentDirectoryPath, &Size, FileSystem, 0);
2972 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2973 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2974 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2975 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
2976 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] != L
'\\') {
2977 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2978 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2983 // if updated the current directory then update the environment variable
2985 if (MapListItem
== gShellCurDir
) {
2987 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
2988 StrnCatGrow(&TempString
, &Size
, MapListItem
->MapName
, 0);
2989 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
2990 StrnCatGrow(&TempString
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
2991 Status
= InternalEfiShellSetEnv(L
"cwd", TempString
, TRUE
);
2992 FreePool(TempString
);
2995 return(EFI_SUCCESS
);
2999 Return help information about a specific command.
3001 This function returns the help information for the specified command. The help text
3002 can be internal to the shell or can be from a UEFI Shell manual page.
3004 If Sections is specified, then each section name listed will be compared in a casesensitive
3005 manner, to the section names described in Appendix B. If the section exists,
3006 it will be appended to the returned help text. If the section does not exist, no
3007 information will be returned. If Sections is NULL, then all help text information
3008 available will be returned.
3010 @param Command Points to the NULL-terminated UEFI Shell command name.
3011 @param Sections Points to the NULL-terminated comma-delimited
3012 section names to return. If NULL, then all
3013 sections will be returned.
3014 @param HelpText On return, points to a callee-allocated buffer
3015 containing all specified help text.
3017 @retval EFI_SUCCESS The help text was returned.
3018 @retval EFI_OUT_OF_RESOURCES The necessary buffer could not be allocated to hold the
3020 @retval EFI_INVALID_PARAMETER HelpText is NULL
3021 @retval EFI_NOT_FOUND There is no help text available for Command.
3025 EfiShellGetHelpText(
3026 IN CONST CHAR16
*Command
,
3027 IN CONST CHAR16
*Sections OPTIONAL
,
3028 OUT CHAR16
**HelpText
3031 CONST CHAR16
*ManFileName
;
3035 ASSERT(HelpText
!= NULL
);
3038 ManFileName
= ShellCommandGetManFileNameHandler(Command
);
3040 if (ManFileName
!= NULL
) {
3041 return (ProcessManFile(ManFileName
, Command
, Sections
, NULL
, HelpText
));
3043 if ((StrLen(Command
)> 4)
3044 && (Command
[StrLen(Command
)-1] == L
'i' || Command
[StrLen(Command
)-1] == L
'I')
3045 && (Command
[StrLen(Command
)-2] == L
'f' || Command
[StrLen(Command
)-2] == L
'F')
3046 && (Command
[StrLen(Command
)-3] == L
'e' || Command
[StrLen(Command
)-3] == L
'E')
3047 && (Command
[StrLen(Command
)-4] == L
'.')
3049 FixCommand
= AllocateZeroPool(StrSize(Command
) - 4 * sizeof (CHAR16
));
3050 ASSERT(FixCommand
!= NULL
);
3052 StrnCpyS( FixCommand
,
3053 (StrSize(Command
) - 4 * sizeof (CHAR16
))/sizeof(CHAR16
),
3057 Status
= ProcessManFile(FixCommand
, FixCommand
, Sections
, NULL
, HelpText
);
3058 FreePool(FixCommand
);
3061 return (ProcessManFile(Command
, Command
, Sections
, NULL
, HelpText
));
3067 Gets the enable status of the page break output mode.
3069 User can use this function to determine current page break mode.
3071 @retval TRUE The page break output mode is enabled.
3072 @retval FALSE The page break output mode is disabled.
3076 EfiShellGetPageBreak(
3080 return(ShellInfoObject
.PageBreakEnabled
);
3084 Judges whether the active shell is the root shell.
3086 This function makes the user to know that whether the active Shell is the root shell.
3088 @retval TRUE The active Shell is the root Shell.
3089 @retval FALSE The active Shell is NOT the root Shell.
3093 EfiShellIsRootShell(
3097 return(ShellInfoObject
.RootShellInstance
);
3101 function to return a semi-colon delimeted list of all alias' in the current shell
3103 up to caller to free the memory.
3105 @retval NULL No alias' were found
3106 @retval NULL An error ocurred getting alias'
3107 @return !NULL a list of all alias'
3111 InternalEfiShellGetListAlias(
3117 CHAR16
*VariableName
;
3119 UINTN NameBufferSize
;
3123 NameBufferSize
= INIT_NAME_BUFFER_SIZE
;
3124 VariableName
= AllocateZeroPool(NameBufferSize
);
3128 if (VariableName
== NULL
) {
3132 VariableName
[0] = CHAR_NULL
;
3135 NameSize
= NameBufferSize
;
3136 Status
= gRT
->GetNextVariableName(&NameSize
, VariableName
, &Guid
);
3137 if (Status
== EFI_NOT_FOUND
){
3139 } else if (Status
== EFI_BUFFER_TOO_SMALL
) {
3140 NameBufferSize
= NameSize
> NameBufferSize
* 2 ? NameSize
: NameBufferSize
* 2;
3141 SHELL_FREE_NON_NULL(VariableName
);
3142 VariableName
= AllocateZeroPool(NameBufferSize
);
3143 if (VariableName
== NULL
) {
3144 Status
= EFI_OUT_OF_RESOURCES
;
3145 SHELL_FREE_NON_NULL(RetVal
);
3150 NameSize
= NameBufferSize
;
3151 Status
= gRT
->GetNextVariableName(&NameSize
, VariableName
, &Guid
);
3154 if (EFI_ERROR (Status
)) {
3155 SHELL_FREE_NON_NULL(RetVal
);
3160 if (CompareGuid(&Guid
, &gShellAliasGuid
)){
3161 ASSERT((RetVal
== NULL
&& RetSize
== 0) || (RetVal
!= NULL
));
3162 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, VariableName
, 0);
3163 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, L
";", 0);
3166 SHELL_FREE_NON_NULL(VariableName
);
3172 Convert a null-terminated unicode string, in-place, to all lowercase.
3175 @param Str The null-terminated string to be converted to all lowercase.
3177 @return The null-terminated string converted into all lowercase.
3186 for (Index
= 0; Str
[Index
] != L
'\0'; Index
++) {
3187 if (Str
[Index
] >= L
'A' && Str
[Index
] <= L
'Z') {
3188 Str
[Index
] -= (CHAR16
)(L
'A' - L
'a');
3195 This function returns the command associated with a alias or a list of all
3198 @param[in] Alias Points to the NULL-terminated shell alias.
3199 If this parameter is NULL, then all
3200 aliases will be returned in ReturnedData.
3201 @param[out] Volatile upon return of a single command if TRUE indicates
3202 this is stored in a volatile fashion. FALSE otherwise.
3204 @return If Alias is not NULL, it will return a pointer to
3205 the NULL-terminated command for that alias.
3206 If Alias is NULL, ReturnedData points to a ';'
3207 delimited list of alias (e.g.
3208 ReturnedData = "dir;del;copy;mfp") that is NULL-terminated.
3209 @retval NULL an error ocurred
3210 @retval NULL Alias was not a valid Alias
3215 IN CONST CHAR16
*Alias
,
3216 OUT BOOLEAN
*Volatile OPTIONAL
3225 // Convert to lowercase to make aliases case-insensitive
3226 if (Alias
!= NULL
) {
3227 AliasLower
= AllocateCopyPool (StrSize (Alias
), Alias
);
3228 ASSERT (AliasLower
!= NULL
);
3229 ToLower (AliasLower
);
3231 if (Volatile
== NULL
) {
3232 return (AddBufferToFreeList(GetVariable(AliasLower
, &gShellAliasGuid
)));
3236 Status
= gRT
->GetVariable(AliasLower
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
3237 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3238 RetVal
= AllocateZeroPool(RetSize
);
3239 Status
= gRT
->GetVariable(AliasLower
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
3241 if (EFI_ERROR(Status
)) {
3242 if (RetVal
!= NULL
) {
3247 if ((EFI_VARIABLE_NON_VOLATILE
& Attribs
) == EFI_VARIABLE_NON_VOLATILE
) {
3253 FreePool (AliasLower
);
3254 return (AddBufferToFreeList(RetVal
));
3256 return (AddBufferToFreeList(InternalEfiShellGetListAlias()));
3260 Changes a shell command alias.
3262 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3264 this function does not check for built in alias'.
3266 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3267 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3268 Command refers to an alias, that alias will be deleted.
3269 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3270 Alias being set will be stored in a non-volatile fashion.
3272 @retval EFI_SUCCESS Alias created or deleted successfully.
3273 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3278 IN CONST CHAR16
*Command
,
3279 IN CONST CHAR16
*Alias
,
3286 // Convert to lowercase to make aliases case-insensitive
3287 if (Alias
!= NULL
) {
3288 AliasLower
= AllocateCopyPool (StrSize (Alias
), Alias
);
3289 ASSERT (AliasLower
!= NULL
);
3290 ToLower (AliasLower
);
3296 // We must be trying to remove one if Alias is NULL
3298 if (Alias
== NULL
) {
3300 // remove an alias (but passed in COMMAND parameter)
3302 Status
= (gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
));
3305 // Add and replace are the same
3308 // We dont check the error return on purpose since the variable may not exist.
3309 gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
);
3311 Status
= (gRT
->SetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, EFI_VARIABLE_BOOTSERVICE_ACCESS
|(Volatile
?0:EFI_VARIABLE_NON_VOLATILE
), StrSize(Command
), (VOID
*)Command
));
3314 if (Alias
!= NULL
) {
3315 FreePool (AliasLower
);
3321 Changes a shell command alias.
3323 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
3326 @param[in] Command Points to the NULL-terminated shell command or existing alias.
3327 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
3328 Command refers to an alias, that alias will be deleted.
3329 @param[in] Replace If TRUE and the alias already exists, then the existing alias will be replaced. If
3330 FALSE and the alias already exists, then the existing alias is unchanged and
3331 EFI_ACCESS_DENIED is returned.
3332 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
3333 Alias being set will be stored in a non-volatile fashion.
3335 @retval EFI_SUCCESS Alias created or deleted successfully.
3336 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
3337 @retval EFI_ACCESS_DENIED The alias is a built-in alias or already existed and Replace was set to
3339 @retval EFI_INVALID_PARAMETER Command is null or the empty string.
3344 IN CONST CHAR16
*Command
,
3345 IN CONST CHAR16
*Alias
,
3350 if (ShellCommandIsOnAliasList(Alias
==NULL
?Command
:Alias
)) {
3352 // cant set over a built in alias
3354 return (EFI_ACCESS_DENIED
);
3355 } else if (Command
== NULL
|| *Command
== CHAR_NULL
|| StrLen(Command
) == 0) {
3357 // Command is null or empty
3359 return (EFI_INVALID_PARAMETER
);
3360 } else if (EfiShellGetAlias(Command
, NULL
) != NULL
&& !Replace
) {
3362 // Alias already exists, Replace not set
3364 return (EFI_ACCESS_DENIED
);
3366 return (InternalSetAlias(Command
, Alias
, Volatile
));
3370 // Pure FILE_HANDLE operations are passed to FileHandleLib
3371 // these functions are indicated by the *
3372 EFI_SHELL_PROTOCOL mShellProtocol
= {
3378 EfiShellGetHelpText
,
3379 EfiShellGetDevicePathFromMap
,
3380 EfiShellGetMapFromDevicePath
,
3381 EfiShellGetDevicePathFromFilePath
,
3382 EfiShellGetFilePathFromDevicePath
,
3386 EfiShellOpenFileList
,
3387 EfiShellFreeFileList
,
3388 EfiShellRemoveDupInFileList
,
3389 EfiShellBatchIsActive
,
3390 EfiShellIsRootShell
,
3391 EfiShellEnablePageBreak
,
3392 EfiShellDisablePageBreak
,
3393 EfiShellGetPageBreak
,
3394 EfiShellGetDeviceName
,
3395 (EFI_SHELL_GET_FILE_INFO
)FileHandleGetInfo
, //*
3396 (EFI_SHELL_SET_FILE_INFO
)FileHandleSetInfo
, //*
3397 EfiShellOpenFileByName
,
3400 (EFI_SHELL_READ_FILE
)FileHandleRead
, //*
3401 (EFI_SHELL_WRITE_FILE
)FileHandleWrite
, //*
3402 (EFI_SHELL_DELETE_FILE
)FileHandleDelete
, //*
3403 EfiShellDeleteFileByName
,
3404 (EFI_SHELL_GET_FILE_POSITION
)FileHandleGetPosition
, //*
3405 (EFI_SHELL_SET_FILE_POSITION
)FileHandleSetPosition
, //*
3406 (EFI_SHELL_FLUSH_FILE
)FileHandleFlush
, //*
3408 EfiShellFindFilesInDir
,
3409 (EFI_SHELL_GET_FILE_SIZE
)FileHandleGetSize
, //*
3411 EfiShellOpenRootByHandle
,
3413 SHELL_MAJOR_VERSION
,
3414 SHELL_MINOR_VERSION
,
3416 // New for UEFI Shell 2.1
3417 EfiShellRegisterGuidName
,
3418 EfiShellGetGuidName
,
3419 EfiShellGetGuidFromName
,
3424 Function to create and install on the current handle.
3426 Will overwrite any existing ShellProtocols in the system to be sure that
3427 the current shell is in control.
3429 This must be removed via calling CleanUpShellProtocol().
3431 @param[in, out] NewShell The pointer to the pointer to the structure
3434 @retval EFI_SUCCESS The operation was successful.
3435 @return An error from LocateHandle, CreateEvent, or other core function.
3439 CreatePopulateInstallShellProtocol (
3440 IN OUT EFI_SHELL_PROTOCOL
**NewShell
3446 UINTN HandleCounter
;
3447 SHELL_PROTOCOL_HANDLE_LIST
*OldProtocolNode
;
3449 if (NewShell
== NULL
) {
3450 return (EFI_INVALID_PARAMETER
);
3455 OldProtocolNode
= NULL
;
3456 InitializeListHead(&ShellInfoObject
.OldShellList
.Link
);
3459 // Initialize EfiShellProtocol object...
3461 Status
= gBS
->CreateEvent(0,
3465 &mShellProtocol
.ExecutionBreak
);
3466 if (EFI_ERROR(Status
)) {
3471 // Get the size of the buffer we need.
3473 Status
= gBS
->LocateHandle(ByProtocol
,
3474 &gEfiShellProtocolGuid
,
3478 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3480 // Allocate and recall with buffer of correct size
3482 Buffer
= AllocateZeroPool(BufferSize
);
3483 if (Buffer
== NULL
) {
3484 return (EFI_OUT_OF_RESOURCES
);
3486 Status
= gBS
->LocateHandle(ByProtocol
,
3487 &gEfiShellProtocolGuid
,
3491 if (EFI_ERROR(Status
)) {
3496 // now overwrite each of them, but save the info to restore when we end.
3498 for (HandleCounter
= 0 ; HandleCounter
< (BufferSize
/sizeof(EFI_HANDLE
)) ; HandleCounter
++) {
3499 OldProtocolNode
= AllocateZeroPool(sizeof(SHELL_PROTOCOL_HANDLE_LIST
));
3500 ASSERT(OldProtocolNode
!= NULL
);
3501 Status
= gBS
->OpenProtocol(Buffer
[HandleCounter
],
3502 &gEfiShellProtocolGuid
,
3503 (VOID
**) &(OldProtocolNode
->Interface
),
3506 EFI_OPEN_PROTOCOL_GET_PROTOCOL
3508 if (!EFI_ERROR(Status
)) {
3510 // reinstall over the old one...
3512 OldProtocolNode
->Handle
= Buffer
[HandleCounter
];
3513 Status
= gBS
->ReinstallProtocolInterface(
3514 OldProtocolNode
->Handle
,
3515 &gEfiShellProtocolGuid
,
3516 OldProtocolNode
->Interface
,
3517 (VOID
*)(&mShellProtocol
));
3518 if (!EFI_ERROR(Status
)) {
3520 // we reinstalled sucessfully. log this so we can reverse it later.
3524 // add to the list for subsequent...
3526 InsertTailList(&ShellInfoObject
.OldShellList
.Link
, &OldProtocolNode
->Link
);
3531 } else if (Status
== EFI_NOT_FOUND
) {
3532 ASSERT(IsListEmpty(&ShellInfoObject
.OldShellList
.Link
));
3534 // no one else published yet. just publish it ourselves.
3536 Status
= gBS
->InstallProtocolInterface (
3538 &gEfiShellProtocolGuid
,
3539 EFI_NATIVE_INTERFACE
,
3540 (VOID
*)(&mShellProtocol
));
3543 if (PcdGetBool(PcdShellSupportOldProtocols
)){
3544 ///@todo support ShellEnvironment2
3545 ///@todo do we need to support ShellEnvironment (not ShellEnvironment2) also?
3548 if (!EFI_ERROR(Status
)) {
3549 *NewShell
= &mShellProtocol
;
3555 Opposite of CreatePopulateInstallShellProtocol.
3557 Free all memory and restore the system to the state it was in before calling
3558 CreatePopulateInstallShellProtocol.
3560 @param[in, out] NewShell The pointer to the new shell protocol structure.
3562 @retval EFI_SUCCESS The operation was successful.
3566 CleanUpShellProtocol (
3567 IN OUT EFI_SHELL_PROTOCOL
*NewShell
3571 SHELL_PROTOCOL_HANDLE_LIST
*Node2
;
3572 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3575 // if we need to restore old protocols...
3577 if (!IsListEmpty(&ShellInfoObject
.OldShellList
.Link
)) {
3578 for (Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*)GetFirstNode(&ShellInfoObject
.OldShellList
.Link
)
3579 ; !IsListEmpty (&ShellInfoObject
.OldShellList
.Link
)
3580 ; Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*)GetFirstNode(&ShellInfoObject
.OldShellList
.Link
)
3582 RemoveEntryList(&Node2
->Link
);
3583 Status
= gBS
->ReinstallProtocolInterface(Node2
->Handle
,
3584 &gEfiShellProtocolGuid
,
3591 // no need to restore
3593 Status
= gBS
->UninstallProtocolInterface(gImageHandle
,
3594 &gEfiShellProtocolGuid
,
3597 Status
= gBS
->CloseEvent(NewShell
->ExecutionBreak
);
3598 NewShell
->ExecutionBreak
= NULL
;
3600 Status
= gBS
->OpenProtocol(
3601 gST
->ConsoleInHandle
,
3602 &gEfiSimpleTextInputExProtocolGuid
,
3606 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3608 if (!EFI_ERROR (Status
)) {
3609 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle1
);
3610 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle2
);
3611 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle3
);
3612 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle4
);
3613 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle1
);
3614 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle2
);
3615 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle3
);
3616 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlSNotifyHandle4
);
3622 Notification function for keystrokes.
3624 @param[in] KeyData The key that was pressed.
3626 @retval EFI_SUCCESS The operation was successful.
3630 NotificationFunction(
3631 IN EFI_KEY_DATA
*KeyData
3634 if ( ((KeyData
->Key
.UnicodeChar
== L
'c') &&
3635 (KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
) || KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
))) ||
3636 (KeyData
->Key
.UnicodeChar
== 3)
3638 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3639 return (EFI_UNSUPPORTED
);
3641 return (gBS
->SignalEvent(ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
));
3642 } else if ((KeyData
->Key
.UnicodeChar
== L
's') &&
3643 (KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
) || KeyData
->KeyState
.KeyShiftState
== (EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
))
3645 ShellInfoObject
.HaltOutput
= TRUE
;
3647 return (EFI_SUCCESS
);
3651 Function to start monitoring for CTRL-C using SimpleTextInputEx. This
3652 feature's enabled state was not known when the shell initially launched.
3654 @retval EFI_SUCCESS The feature is enabled.
3655 @retval EFI_OUT_OF_RESOURCES There is not enough mnemory available.
3659 InernalEfiShellStartMonitor(
3663 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3664 EFI_KEY_DATA KeyData
;
3667 Status
= gBS
->OpenProtocol(
3668 gST
->ConsoleInHandle
,
3669 &gEfiSimpleTextInputExProtocolGuid
,
3673 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3674 if (EFI_ERROR(Status
)) {
3679 STRING_TOKEN (STR_SHELL_NO_IN_EX
),
3680 ShellInfoObject
.HiiHandle
);
3681 return (EFI_SUCCESS
);
3684 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3685 return (EFI_UNSUPPORTED
);
3688 KeyData
.KeyState
.KeyToggleState
= 0;
3689 KeyData
.Key
.ScanCode
= 0;
3690 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3691 KeyData
.Key
.UnicodeChar
= L
'c';
3693 Status
= SimpleEx
->RegisterKeyNotify(
3696 NotificationFunction
,
3697 &ShellInfoObject
.CtrlCNotifyHandle1
);
3699 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3700 if (!EFI_ERROR(Status
)) {
3701 Status
= SimpleEx
->RegisterKeyNotify(
3704 NotificationFunction
,
3705 &ShellInfoObject
.CtrlCNotifyHandle2
);
3707 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3708 KeyData
.Key
.UnicodeChar
= 3;
3709 if (!EFI_ERROR(Status
)) {
3710 Status
= SimpleEx
->RegisterKeyNotify(
3713 NotificationFunction
,
3714 &ShellInfoObject
.CtrlCNotifyHandle3
);
3716 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3717 if (!EFI_ERROR(Status
)) {
3718 Status
= SimpleEx
->RegisterKeyNotify(
3721 NotificationFunction
,
3722 &ShellInfoObject
.CtrlCNotifyHandle4
);