2 Member functions of EFI_SHELL_PROTOCOL and functions for creation,
3 manipulation, and initialization of EFI_SHELL_PROTOCOL.
5 Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
17 #include <Library/FileHandleLib.h>
20 Close an open file handle.
22 This function closes a specified file handle. All "dirty" cached file data is
23 flushed to the device, and the file is closed. In all cases the handle is
26 @param[in] FileHandle The file handle to close.
28 @retval EFI_SUCCESS The file handle was closed successfully.
33 IN SHELL_FILE_HANDLE FileHandle
36 ShellFileHandleRemove(FileHandle
);
37 return (FileHandleClose(ConvertShellHandleToEfiFileProtocol(FileHandle
)));
41 Internal worker to determine whether there is a file system somewhere
42 upon the device path specified.
44 @param[in] DevicePath The device path to test.
46 @retval TRUE gEfiSimpleFileSystemProtocolGuid was installed on a handle with this device path
47 @retval FALSE gEfiSimpleFileSystemProtocolGuid was not found.
51 InternalShellProtocolIsSimpleFileSystemPresent(
52 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
55 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
61 DevicePathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)DevicePath
;
62 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &Handle
);
64 if ((Handle
!= NULL
) && (!EFI_ERROR(Status
))) {
71 Internal worker debug helper function to print out maps as they are added.
73 @param[in] Mapping string mapping that has been added
74 @param[in] DevicePath pointer to device path that has been mapped.
76 @retval EFI_SUCCESS the operation was successful.
77 @return other an error ocurred
84 InternalShellProtocolDebugPrintMessage (
85 IN CONST CHAR16
*Mapping
,
86 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
89 EFI_DEVICE_PATH_TO_TEXT_PROTOCOL
*DevicePathToText
;
95 DevicePathToText
= NULL
;
97 Status
= gBS
->LocateProtocol(&gEfiDevicePathToTextProtocolGuid
,
99 (VOID
**)&DevicePathToText
);
100 if (Mapping
!= NULL
) {
101 DEBUG((EFI_D_INFO
, "Added new map item:\"%S\"\r\n", Mapping
));
103 if (!EFI_ERROR(Status
)) {
104 if (DevicePath
!= NULL
) {
105 Temp
= DevicePathToText
->ConvertDevicePathToText(DevicePath
, TRUE
, TRUE
);
106 DEBUG((EFI_D_INFO
, "DevicePath: %S\r\n", Temp
));
115 This function creates a mapping for a device path.
117 If both DeviecPath and Mapping are NULL, this will reset the mapping to default values.
119 @param DevicePath Points to the device path. If this is NULL and Mapping points to a valid mapping,
120 then the mapping will be deleted.
121 @param Mapping Points to the NULL-terminated mapping for the device path. Must end with a ':'
123 @retval EFI_SUCCESS Mapping created or deleted successfully.
124 @retval EFI_NO_MAPPING There is no handle that corresponds exactly to DevicePath. See the
125 boot service function LocateDevicePath().
126 @retval EFI_ACCESS_DENIED The mapping is a built-in alias.
127 @retval EFI_INVALID_PARAMETER Mapping was NULL
128 @retval EFI_INVALID_PARAMETER Mapping did not end with a ':'
129 @retval EFI_INVALID_PARAMETER DevicePath was not pointing at a device that had a SIMPLE_FILE_SYSTEM_PROTOCOL installed.
130 @retval EFI_NOT_FOUND There was no mapping found to delete
131 @retval EFI_OUT_OF_RESOURCES Memory allocation failed
136 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath OPTIONAL
,
137 IN CONST CHAR16
*Mapping
141 SHELL_MAP_LIST
*MapListNode
;
143 if (Mapping
== NULL
){
144 return (EFI_INVALID_PARAMETER
);
147 if (Mapping
[StrLen(Mapping
)-1] != ':') {
148 return (EFI_INVALID_PARAMETER
);
152 // Delete the mapping
154 if (DevicePath
== NULL
) {
155 if (IsListEmpty(&gShellMapList
.Link
)) {
156 return (EFI_NOT_FOUND
);
158 for ( MapListNode
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
159 ; !IsNull(&gShellMapList
.Link
, &MapListNode
->Link
)
160 ; MapListNode
= (SHELL_MAP_LIST
*)GetNextNode(&gShellMapList
.Link
, &MapListNode
->Link
)
162 if (StringNoCaseCompare(&MapListNode
->MapName
, &Mapping
) == 0) {
163 RemoveEntryList(&MapListNode
->Link
);
164 FreePool(MapListNode
);
165 return (EFI_SUCCESS
);
170 // We didnt find one to delete
172 return (EFI_NOT_FOUND
);
176 // make sure this is a valid to add device path
178 ///@todo add BlockIo to this test...
179 if (!InternalShellProtocolIsSimpleFileSystemPresent(DevicePath
)) {
180 return (EFI_INVALID_PARAMETER
);
184 // First make sure there is no old mapping
186 Status
= EfiShellSetMap(NULL
, Mapping
);
187 if ((Status
!= EFI_SUCCESS
) && (Status
!= EFI_NOT_FOUND
)) {
192 // now add the new one.
194 Status
= ShellCommandAddMapItemAndUpdatePath(Mapping
, DevicePath
, 0, FALSE
);
200 Gets the device path from the mapping.
202 This function gets the device path associated with a mapping.
204 @param Mapping A pointer to the mapping
206 @retval !=NULL Pointer to the device path that corresponds to the
207 device mapping. The returned pointer does not need
209 @retval NULL There is no device path associated with the
212 CONST EFI_DEVICE_PATH_PROTOCOL
*
214 EfiShellGetDevicePathFromMap(
215 IN CONST CHAR16
*Mapping
218 SHELL_MAP_LIST
*MapListItem
;
225 StrnCatGrow(&NewName
, &Size
, Mapping
, 0);
226 if (Mapping
[StrLen(Mapping
)-1] != L
':') {
227 StrnCatGrow(&NewName
, &Size
, L
":", 0);
230 MapListItem
= ShellCommandFindMapItem(NewName
);
234 if (MapListItem
!= NULL
) {
235 return (MapListItem
->DevicePath
);
241 Gets the mapping(s) that most closely matches the device path.
243 This function gets the mapping which corresponds to the device path *DevicePath. If
244 there is no exact match, then the mapping which most closely matches *DevicePath
245 is returned, and *DevicePath is updated to point to the remaining portion of the
246 device path. If there is an exact match, the mapping is returned and *DevicePath
247 points to the end-of-device-path node.
249 If there are multiple map names they will be semi-colon seperated in the
250 NULL-terminated string.
252 @param DevicePath On entry, points to a device path pointer. On
253 exit, updates the pointer to point to the
254 portion of the device path after the mapping.
256 @retval NULL No mapping was found.
257 @return !=NULL Pointer to NULL-terminated mapping. The buffer
258 is callee allocated and should be freed by the caller.
262 EfiShellGetMapFromDevicePath(
263 IN OUT EFI_DEVICE_PATH_PROTOCOL
**DevicePath
266 SHELL_MAP_LIST
*Node
;
267 CHAR16
*PathForReturn
;
269 // EFI_HANDLE PathHandle;
270 // EFI_HANDLE MapHandle;
271 // EFI_STATUS Status;
272 // EFI_DEVICE_PATH_PROTOCOL *DevicePathCopy;
273 // EFI_DEVICE_PATH_PROTOCOL *MapPathCopy;
275 if (DevicePath
== NULL
|| *DevicePath
== NULL
) {
279 PathForReturn
= NULL
;
282 for ( Node
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
283 ; !IsNull(&gShellMapList
.Link
, &Node
->Link
)
284 ; Node
= (SHELL_MAP_LIST
*)GetNextNode(&gShellMapList
.Link
, &Node
->Link
)
287 // check for exact match
289 if (DevicePathCompare(DevicePath
, &Node
->DevicePath
) == 0) {
290 ASSERT((PathForReturn
== NULL
&& PathSize
== 0) || (PathForReturn
!= NULL
));
292 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, L
";", 0);
294 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, Node
->MapName
, 0);
297 if (PathForReturn
!= NULL
) {
298 while (!IsDevicePathEndType (*DevicePath
)) {
299 *DevicePath
= NextDevicePathNode (*DevicePath
);
301 SetDevicePathEndNode (*DevicePath
);
304 ///@todo finish code for inexact matches.
305 if (PathForReturn == NULL) {
308 DevicePathCopy = DuplicateDevicePath(*DevicePath);
309 ASSERT(DevicePathCopy != NULL);
310 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &DevicePathCopy, &PathHandle);
311 ASSERT_EFI_ERROR(Status);
313 // check each of the device paths we have to get the root of the path for consist mappings
315 for ( Node = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
316 ; !IsNull(&gShellMapList.Link, &Node->Link)
317 ; Node = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &Node->Link)
319 if ((Node->Flags & SHELL_MAP_FLAGS_CONSIST) == 0) {
322 MapPathCopy = DuplicateDevicePath(Node->DevicePath);
323 ASSERT(MapPathCopy != NULL);
324 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &MapPathCopy, &MapHandle);
325 if (MapHandle == PathHandle) {
327 *DevicePath = DevicePathCopy;
330 DevicePathCopy = NULL;
331 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, Node->MapName, 0);
332 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, L";", 0);
337 // now add on the non-consistent mappings
339 for ( Node = (SHELL_MAP_LIST *)GetFirstNode(&gShellMapList.Link)
340 ; !IsNull(&gShellMapList.Link, &Node->Link)
341 ; Node = (SHELL_MAP_LIST *)GetNextNode(&gShellMapList.Link, &Node->Link)
343 if ((Node->Flags & SHELL_MAP_FLAGS_CONSIST) != 0) {
346 MapPathCopy = Node->DevicePath;
347 ASSERT(MapPathCopy != NULL);
348 Status = gBS->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid, &MapPathCopy, &MapHandle);
349 if (MapHandle == PathHandle) {
350 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, Node->MapName, 0);
351 PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, L";", 0);
358 return (AddBufferToFreeList(PathForReturn
));
362 Converts a device path to a file system-style path.
364 This function converts a device path to a file system path by replacing part, or all, of
365 the device path with the file-system mapping. If there are more than one application
366 file system mappings, the one that most closely matches Path will be used.
368 @param Path The pointer to the device path
370 @retval NULL the device path could not be found.
371 @return all The pointer of the NULL-terminated file path. The path
372 is callee-allocated and should be freed by the caller.
376 EfiShellGetFilePathFromDevicePath(
377 IN CONST EFI_DEVICE_PATH_PROTOCOL
*Path
380 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
381 EFI_DEVICE_PATH_PROTOCOL
*MapPathCopy
;
382 SHELL_MAP_LIST
*MapListItem
;
383 CHAR16
*PathForReturn
;
385 EFI_HANDLE PathHandle
;
386 EFI_HANDLE MapHandle
;
388 FILEPATH_DEVICE_PATH
*FilePath
;
390 PathForReturn
= NULL
;
393 DevicePathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)Path
;
394 ASSERT(DevicePathCopy
!= NULL
);
395 if (DevicePathCopy
== NULL
) {
399 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &PathHandle
);
401 if (EFI_ERROR(Status
)) {
405 // check each of the device paths we have to get the root of the path
407 for ( MapListItem
= (SHELL_MAP_LIST
*)GetFirstNode(&gShellMapList
.Link
)
408 ; !IsNull(&gShellMapList
.Link
, &MapListItem
->Link
)
409 ; MapListItem
= (SHELL_MAP_LIST
*)GetNextNode(&gShellMapList
.Link
, &MapListItem
->Link
)
411 MapPathCopy
= (EFI_DEVICE_PATH_PROTOCOL
*)MapListItem
->DevicePath
;
412 ASSERT(MapPathCopy
!= NULL
);
414 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &MapPathCopy
, &MapHandle
);
415 if (MapHandle
== PathHandle
) {
416 ASSERT((PathForReturn
== NULL
&& PathSize
== 0) || (PathForReturn
!= NULL
));
417 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, MapListItem
->MapName
, 0);
419 // go through all the remaining nodes in the device path
421 for ( FilePath
= (FILEPATH_DEVICE_PATH
*)DevicePathCopy
422 ; !IsDevicePathEnd (&FilePath
->Header
)
423 ; FilePath
= (FILEPATH_DEVICE_PATH
*)NextDevicePathNode (&FilePath
->Header
)
426 // all the rest should be file path nodes
428 if ((DevicePathType(&FilePath
->Header
) != MEDIA_DEVICE_PATH
) ||
429 (DevicePathSubType(&FilePath
->Header
) != MEDIA_FILEPATH_DP
)) {
430 FreePool(PathForReturn
);
431 PathForReturn
= NULL
;
435 // append the path part onto the filepath.
437 ASSERT((PathForReturn
== NULL
&& PathSize
== 0) || (PathForReturn
!= NULL
));
438 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, L
"\\", 1);
439 PathForReturn
= StrnCatGrow(&PathForReturn
, &PathSize
, FilePath
->PathName
, 0);
441 } // for loop of remaining nodes
443 if (PathForReturn
!= NULL
) {
446 } // for loop of paths to check
447 return(PathForReturn
);
451 Converts a file system style name to a device path.
453 This function converts a file system style name to a device path, by replacing any
454 mapping references to the associated device path.
456 @param Path the pointer to the path
458 @return all The pointer of the file path. The file path is callee
459 allocated and should be freed by the caller.
461 EFI_DEVICE_PATH_PROTOCOL
*
463 EfiShellGetDevicePathFromFilePath(
464 IN CONST CHAR16
*Path
471 CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
472 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopy
;
473 EFI_DEVICE_PATH_PROTOCOL
*DevicePathCopyForFree
;
474 EFI_DEVICE_PATH_PROTOCOL
*DevicePathForReturn
;
485 if (StrStr(Path
, L
":") == NULL
) {
486 Cwd
= EfiShellGetCurDir(NULL
);
491 Size
+= StrSize(Path
);
492 NewPath
= AllocateZeroPool(Size
);
493 ASSERT(NewPath
!= NULL
);
494 StrCpy(NewPath
, Cwd
);
495 if ((Path
[0] == (CHAR16
)L
'\\') &&
496 (NewPath
[StrLen(NewPath
)-1] == (CHAR16
)L
'\\')
498 ((CHAR16
*)NewPath
)[StrLen(NewPath
)-1] = CHAR_NULL
;
500 StrCat(NewPath
, Path
);
501 DevicePathForReturn
= EfiShellGetDevicePathFromFilePath(NewPath
);
503 return (DevicePathForReturn
);
508 // find the part before (but including) the : for the map name
510 ASSERT((MapName
== NULL
&& Size
== 0) || (MapName
!= NULL
));
511 MapName
= StrnCatGrow(&MapName
, &Size
, Path
, (StrStr(Path
, L
":")-Path
+1));
512 if (MapName
[StrLen(MapName
)-1] != L
':') {
518 // look up the device path in the map
520 DevicePath
= EfiShellGetDevicePathFromMap(MapName
);
521 if (DevicePath
== NULL
) {
523 // Must have been a bad Mapname
529 // make a copy for LocateDevicePath to modify (also save a pointer to call FreePool with)
531 DevicePathCopyForFree
= DevicePathCopy
= DuplicateDevicePath(DevicePath
);
532 if (DevicePathCopy
== NULL
) {
542 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
, &DevicePathCopy
, &Handle
);
543 if (EFI_ERROR(Status
)) {
544 if (DevicePathCopyForFree
!= NULL
) {
545 FreePool(DevicePathCopyForFree
);
552 // build the full device path
554 DevicePathForReturn
= FileDevicePath(Handle
, Path
+StrLen(MapName
)+1);
557 if (DevicePathCopyForFree
!= NULL
) {
558 FreePool(DevicePathCopyForFree
);
561 return (DevicePathForReturn
);
565 Gets the name of the device specified by the device handle.
567 This function gets the user-readable name of the device specified by the device
568 handle. If no user-readable name could be generated, then *BestDeviceName will be
569 NULL and EFI_NOT_FOUND will be returned.
571 If EFI_DEVICE_NAME_USE_COMPONENT_NAME is set, then the function will return the
572 device's name using the EFI_COMPONENT_NAME2_PROTOCOL, if present on
575 If EFI_DEVICE_NAME_USE_DEVICE_PATH is set, then the function will return the
576 device's name using the EFI_DEVICE_PATH_PROTOCOL, if present on DeviceHandle.
577 If both EFI_DEVICE_NAME_USE_COMPONENT_NAME and
578 EFI_DEVICE_NAME_USE_DEVICE_PATH are set, then
579 EFI_DEVICE_NAME_USE_COMPONENT_NAME will have higher priority.
581 @param DeviceHandle The handle of the device.
582 @param Flags Determines the possible sources of component names.
584 EFI_DEVICE_NAME_USE_COMPONENT_NAME
585 EFI_DEVICE_NAME_USE_DEVICE_PATH
586 @param Language A pointer to the language specified for the device
587 name, in the same format as described in the UEFI
588 specification, Appendix M
589 @param BestDeviceName On return, points to the callee-allocated NULL-
590 terminated name of the device. If no device name
591 could be found, points to NULL. The name must be
592 freed by the caller...
594 @retval EFI_SUCCESS Get the name successfully.
595 @retval EFI_NOT_FOUND Fail to get the device name.
596 @retval EFI_INVALID_PARAMETER Flags did not have a valid bit set.
597 @retval EFI_INVALID_PARAMETER BestDeviceName was NULL
598 @retval EFI_INVALID_PARAMETER DeviceHandle was NULL
602 EfiShellGetDeviceName(
603 IN EFI_HANDLE DeviceHandle
,
604 IN EFI_SHELL_DEVICE_NAME_FLAGS Flags
,
606 OUT CHAR16
**BestDeviceName
610 EFI_COMPONENT_NAME2_PROTOCOL
*CompName2
;
611 EFI_DEVICE_PATH_TO_TEXT_PROTOCOL
*DevicePathToText
;
612 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
613 EFI_HANDLE
*HandleList
;
616 CHAR16
*DeviceNameToReturn
;
620 if (BestDeviceName
== NULL
||
623 return (EFI_INVALID_PARAMETER
);
627 // make sure one of the 2 supported bits is on
629 if (((Flags
& EFI_DEVICE_NAME_USE_COMPONENT_NAME
) == 0) &&
630 ((Flags
& EFI_DEVICE_NAME_USE_DEVICE_PATH
) == 0)) {
631 return (EFI_INVALID_PARAMETER
);
634 DeviceNameToReturn
= NULL
;
635 *BestDeviceName
= NULL
;
640 if ((Flags
& EFI_DEVICE_NAME_USE_COMPONENT_NAME
) != 0) {
641 Status
= ParseHandleDatabaseByRelationship(
644 HR_DRIVER_BINDING_HANDLE
|HR_DEVICE_DRIVER
,
647 for (LoopVar
= 0; LoopVar
< HandleCount
; LoopVar
++){
649 // Go through those handles until we get one that passes for GetComponentName
651 Status
= gBS
->OpenProtocol(
653 &gEfiComponentName2ProtocolGuid
,
657 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
658 if (EFI_ERROR(Status
)) {
659 Status
= gBS
->OpenProtocol(
661 &gEfiComponentNameProtocolGuid
,
665 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
668 if (EFI_ERROR(Status
)) {
671 if (Language
== NULL
) {
672 Lang
= AllocatePool(AsciiStrSize(CompName2
->SupportedLanguages
));
674 return (EFI_OUT_OF_RESOURCES
);
676 AsciiStrCpy(Lang
, CompName2
->SupportedLanguages
);
677 TempChar
= AsciiStrStr(Lang
, ";");
678 if (TempChar
!= NULL
){
679 *TempChar
= CHAR_NULL
;
682 Lang
= AllocatePool(AsciiStrSize(Language
));
684 return (EFI_OUT_OF_RESOURCES
);
686 AsciiStrCpy(Lang
, Language
);
688 Status
= CompName2
->GetControllerName(CompName2
, DeviceHandle
, NULL
, Lang
, &DeviceNameToReturn
);
691 if (!EFI_ERROR(Status
) && DeviceNameToReturn
!= NULL
) {
695 if (HandleList
!= NULL
) {
696 FreePool(HandleList
);
698 if (DeviceNameToReturn
!= NULL
){
699 ASSERT(BestDeviceName
!= NULL
);
700 StrnCatGrow(BestDeviceName
, NULL
, DeviceNameToReturn
, 0);
701 return (EFI_SUCCESS
);
704 // dont return on fail since we will try device path if that bit is on
707 if ((Flags
& EFI_DEVICE_NAME_USE_DEVICE_PATH
) != 0) {
708 Status
= gBS
->LocateProtocol(
709 &gEfiDevicePathToTextProtocolGuid
,
711 (VOID
**)&DevicePathToText
);
713 // we now have the device path to text protocol
715 if (!EFI_ERROR(Status
)) {
716 Status
= gBS
->OpenProtocol(
718 &gEfiDevicePathProtocolGuid
,
722 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
723 if (!EFI_ERROR(Status
)) {
725 // use device path to text on the device path
727 *BestDeviceName
= DevicePathToText
->ConvertDevicePathToText(DevicePath
, TRUE
, TRUE
);
728 return (EFI_SUCCESS
);
733 // none of the selected bits worked.
735 return (EFI_NOT_FOUND
);
739 Opens the root directory of a device on a handle
741 This function opens the root directory of a device and returns a file handle to it.
743 @param DeviceHandle The handle of the device that contains the volume.
744 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
747 @retval EFI_SUCCESS Root opened successfully.
748 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
750 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
751 @retval EFI_DEVICE_ERROR The device had an error
755 EfiShellOpenRootByHandle(
756 IN EFI_HANDLE DeviceHandle
,
757 OUT SHELL_FILE_HANDLE
*FileHandle
761 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
*SimpleFileSystem
;
762 EFI_FILE_PROTOCOL
*RealFileHandle
;
763 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
766 // get the simple file system interface
768 Status
= gBS
->OpenProtocol(DeviceHandle
,
769 &gEfiSimpleFileSystemProtocolGuid
,
770 (VOID
**)&SimpleFileSystem
,
773 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
774 if (EFI_ERROR(Status
)) {
775 return (EFI_NOT_FOUND
);
778 Status
= gBS
->OpenProtocol(DeviceHandle
,
779 &gEfiDevicePathProtocolGuid
,
783 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
784 if (EFI_ERROR(Status
)) {
785 return (EFI_NOT_FOUND
);
788 // Open the root volume now...
790 Status
= SimpleFileSystem
->OpenVolume(SimpleFileSystem
, &RealFileHandle
);
791 *FileHandle
= ConvertEfiFileProtocolToShellHandle(RealFileHandle
, EfiShellGetMapFromDevicePath(&DevPath
));
796 Opens the root directory of a device.
798 This function opens the root directory of a device and returns a file handle to it.
800 @param DevicePath Points to the device path corresponding to the device where the
801 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL is installed.
802 @param FileHandle On exit, points to the file handle corresponding to the root directory on the
805 @retval EFI_SUCCESS Root opened successfully.
806 @retval EFI_NOT_FOUND EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory
808 @retval EFI_VOLUME_CORRUPTED The data structures in the volume were corrupted.
809 @retval EFI_DEVICE_ERROR The device had an error
810 @retval EFI_INVALID_PARAMETER FileHandle is NULL.
815 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
816 OUT SHELL_FILE_HANDLE
*FileHandle
822 if (FileHandle
== NULL
) {
823 return (EFI_INVALID_PARAMETER
);
827 // find the handle of the device with that device handle and the file system
830 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
,
833 if (EFI_ERROR(Status
)) {
834 return (EFI_NOT_FOUND
);
837 return (EfiShellOpenRootByHandle(Handle
, FileHandle
));
841 Returns whether any script files are currently being processed.
843 @retval TRUE There is at least one script file active.
844 @retval FALSE No script files are active now.
849 EfiShellBatchIsActive (
853 if (ShellCommandGetCurrentScriptFile() == NULL
) {
860 Worker function to open a file based on a device path. this will open the root
861 of the volume and then traverse down to the file itself.
863 @param DevicePath Device Path of the file.
864 @param FileHandle Pointer to the file upon a successful return.
865 @param OpenMode mode to open file in.
866 @param Attributes the File Attributes to use when creating a new file.
868 @retval EFI_SUCCESS the file is open and FileHandle is valid
869 @retval EFI_UNSUPPORTED the device path cotained non-path elements
870 @retval other an error ocurred.
874 InternalOpenFileDevicePath(
875 IN OUT EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
876 OUT SHELL_FILE_HANDLE
*FileHandle
,
878 IN UINT64 Attributes OPTIONAL
882 FILEPATH_DEVICE_PATH
*FilePathNode
;
884 SHELL_FILE_HANDLE ShellHandle
;
885 EFI_FILE_PROTOCOL
*Handle1
;
886 EFI_FILE_PROTOCOL
*Handle2
;
887 EFI_DEVICE_PATH_PROTOCOL
*DpCopy
;
888 FILEPATH_DEVICE_PATH
*AlignedNode
;
890 if (FileHandle
== NULL
) {
891 return (EFI_INVALID_PARAMETER
);
902 Status
= EfiShellOpenRoot(DevicePath
, &ShellHandle
);
904 if (!EFI_ERROR(Status
)) {
905 Handle1
= ConvertShellHandleToEfiFileProtocol(ShellHandle
);
907 // chop off the begining part before the file system part...
910 Status
= gBS
->LocateDevicePath(&gEfiSimpleFileSystemProtocolGuid
,
913 if (!EFI_ERROR(Status
)) {
915 // To access as a file system, the file path should only
916 // contain file path components. Follow the file path nodes
917 // and find the target file
919 for ( FilePathNode
= (FILEPATH_DEVICE_PATH
*)DevicePath
920 ; !IsDevicePathEnd (&FilePathNode
->Header
)
921 ; FilePathNode
= (FILEPATH_DEVICE_PATH
*) NextDevicePathNode (&FilePathNode
->Header
)
923 SHELL_FREE_NON_NULL(AlignedNode
);
924 AlignedNode
= AllocateCopyPool (DevicePathNodeLength(FilePathNode
), FilePathNode
);
926 // For file system access each node should be a file path component
928 if (DevicePathType (&FilePathNode
->Header
) != MEDIA_DEVICE_PATH
||
929 DevicePathSubType (&FilePathNode
->Header
) != MEDIA_FILEPATH_DP
931 Status
= EFI_UNSUPPORTED
;
936 // Open this file path node
942 // if this is the last node in the DevicePath always create (if that was requested).
944 if (IsDevicePathEnd ((NextDevicePathNode (&FilePathNode
->Header
)))) {
945 Status
= Handle2
->Open (
948 AlignedNode
->PathName
,
955 // This is not the last node and we dont want to 'create' existing
956 // directory entries...
960 // open without letting it create
961 // prevents error on existing files/directories
963 Status
= Handle2
->Open (
966 AlignedNode
->PathName
,
967 OpenMode
&~EFI_FILE_MODE_CREATE
,
971 // if above failed now open and create the 'item'
972 // if OpenMode EFI_FILE_MODE_CREATE bit was on (but disabled above)
974 if ((EFI_ERROR (Status
)) && ((OpenMode
& EFI_FILE_MODE_CREATE
) != 0)) {
975 Status
= Handle2
->Open (
978 AlignedNode
->PathName
,
985 // Close the last node
987 ShellInfoObject
.NewEfiShellProtocol
->CloseFile (Handle2
);
990 // If there's been an error, stop
992 if (EFI_ERROR (Status
)) {
998 SHELL_FREE_NON_NULL(AlignedNode
);
999 if (EFI_ERROR(Status
)) {
1000 if (Handle1
!= NULL
) {
1001 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(Handle1
);
1004 *FileHandle
= ConvertEfiFileProtocolToShellHandle(Handle1
, ShellFileHandleGetPath(ShellHandle
));
1010 Creates a file or directory by name.
1012 This function creates an empty new file or directory with the specified attributes and
1013 returns the new file's handle. If the file already exists and is read-only, then
1014 EFI_INVALID_PARAMETER will be returned.
1016 If the file already existed, it is truncated and its attributes updated. If the file is
1017 created successfully, the FileHandle is the file's handle, else, the FileHandle is NULL.
1019 If the file name begins with >v, then the file handle which is returned refers to the
1020 shell environment variable with the specified name. If the shell environment variable
1021 already exists and is non-volatile then EFI_INVALID_PARAMETER is returned.
1023 @param FileName Pointer to NULL-terminated file path
1024 @param FileAttribs The new file's attrbiutes. the different attributes are
1025 described in EFI_FILE_PROTOCOL.Open().
1026 @param FileHandle On return, points to the created file handle or directory's handle
1028 @retval EFI_SUCCESS The file was opened. FileHandle points to the new file's handle.
1029 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
1030 @retval EFI_UNSUPPORTED could not open the file path
1031 @retval EFI_NOT_FOUND the specified file could not be found on the devide, or could not
1032 file the file system on the device.
1033 @retval EFI_NO_MEDIA the device has no medium.
1034 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1036 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1038 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1039 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1040 when the media is write-protected.
1041 @retval EFI_ACCESS_DENIED The service denied access to the file.
1042 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file.
1043 @retval EFI_VOLUME_FULL The volume is full.
1048 IN CONST CHAR16
*FileName
,
1049 IN UINT64 FileAttribs
,
1050 OUT SHELL_FILE_HANDLE
*FileHandle
1053 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1057 // Is this for an environment variable
1058 // do we start with >v
1060 if (StrStr(FileName
, L
">v") == FileName
) {
1061 if (!IsVolatileEnv(FileName
+2)) {
1062 return (EFI_INVALID_PARAMETER
);
1064 *FileHandle
= CreateFileInterfaceEnv(FileName
+2);
1065 return (EFI_SUCCESS
);
1069 // We are opening a regular file.
1071 DevicePath
= EfiShellGetDevicePathFromFilePath(FileName
);
1072 if (DevicePath
== NULL
) {
1073 return (EFI_NOT_FOUND
);
1076 Status
= InternalOpenFileDevicePath(DevicePath
, FileHandle
, EFI_FILE_MODE_READ
|EFI_FILE_MODE_WRITE
|EFI_FILE_MODE_CREATE
, FileAttribs
); // 0 = no specific file attributes
1077 FreePool(DevicePath
);
1083 Opens a file or a directory by file name.
1085 This function opens the specified file in the specified OpenMode and returns a file
1087 If the file name begins with >v, then the file handle which is returned refers to the
1088 shell environment variable with the specified name. If the shell environment variable
1089 exists, is non-volatile and the OpenMode indicates EFI_FILE_MODE_WRITE, then
1090 EFI_INVALID_PARAMETER is returned.
1092 If the file name is >i, then the file handle which is returned refers to the standard
1093 input. If the OpenMode indicates EFI_FILE_MODE_WRITE, then EFI_INVALID_PARAMETER
1096 If the file name is >o, then the file handle which is returned refers to the standard
1097 output. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1100 If the file name is >e, then the file handle which is returned refers to the standard
1101 error. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER
1104 If the file name is NUL, then the file handle that is returned refers to the standard NUL
1105 file. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER is
1108 If return EFI_SUCCESS, the FileHandle is the opened file's handle, else, the
1111 @param FileName Points to the NULL-terminated UCS-2 encoded file name.
1112 @param FileHandle On return, points to the file handle.
1113 @param OpenMode File open mode. Either EFI_FILE_MODE_READ or
1114 EFI_FILE_MODE_WRITE from section 12.4 of the UEFI
1116 @retval EFI_SUCCESS The file was opened. FileHandle has the opened file's handle.
1117 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value. FileHandle is NULL.
1118 @retval EFI_UNSUPPORTED Could not open the file path. FileHandle is NULL.
1119 @retval EFI_NOT_FOUND The specified file could not be found on the device or the file
1120 system could not be found on the device. FileHandle is NULL.
1121 @retval EFI_NO_MEDIA The device has no medium. FileHandle is NULL.
1122 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
1123 longer supported. FileHandle is NULL.
1124 @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according
1125 the FileName. FileHandle is NULL.
1126 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted. FileHandle is NULL.
1127 @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write
1128 when the media is write-protected. FileHandle is NULL.
1129 @retval EFI_ACCESS_DENIED The service denied access to the file. FileHandle is NULL.
1130 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file. FileHandle
1132 @retval EFI_VOLUME_FULL The volume is full. FileHandle is NULL.
1136 EfiShellOpenFileByName(
1137 IN CONST CHAR16
*FileName
,
1138 OUT SHELL_FILE_HANDLE
*FileHandle
,
1142 EFI_DEVICE_PATH_PROTOCOL
*DevicePath
;
1148 // Is this for StdIn
1150 if (StrCmp(FileName
, L
">i") == 0) {
1152 // make sure not writing to StdIn
1154 if ((OpenMode
& EFI_FILE_MODE_WRITE
) != 0) {
1155 return (EFI_INVALID_PARAMETER
);
1157 *FileHandle
= ShellInfoObject
.NewShellParametersProtocol
->StdIn
;
1158 ASSERT(*FileHandle
!= NULL
);
1159 return (EFI_SUCCESS
);
1163 // Is this for StdOut
1165 if (StrCmp(FileName
, L
">o") == 0) {
1167 // make sure not writing to StdIn
1169 if ((OpenMode
& EFI_FILE_MODE_READ
) != 0) {
1170 return (EFI_INVALID_PARAMETER
);
1172 *FileHandle
= &FileInterfaceStdOut
;
1173 return (EFI_SUCCESS
);
1177 // Is this for NUL file
1179 if (StrCmp(FileName
, L
"NUL") == 0) {
1180 *FileHandle
= &FileInterfaceNulFile
;
1181 return (EFI_SUCCESS
);
1185 // Is this for StdErr
1187 if (StrCmp(FileName
, L
">e") == 0) {
1189 // make sure not writing to StdIn
1191 if ((OpenMode
& EFI_FILE_MODE_READ
) != 0) {
1192 return (EFI_INVALID_PARAMETER
);
1194 *FileHandle
= &FileInterfaceStdErr
;
1195 return (EFI_SUCCESS
);
1199 // Is this for an environment variable
1200 // do we start with >v
1202 if (StrStr(FileName
, L
">v") == FileName
) {
1203 if (!IsVolatileEnv(FileName
+2) &&
1204 ((OpenMode
& EFI_FILE_MODE_WRITE
) != 0)) {
1205 return (EFI_INVALID_PARAMETER
);
1207 *FileHandle
= CreateFileInterfaceEnv(FileName
+2);
1208 return (EFI_SUCCESS
);
1212 // We are opening a regular file.
1214 DevicePath
= EfiShellGetDevicePathFromFilePath(FileName
);
1215 // DEBUG_CODE(InternalShellProtocolDebugPrintMessage (NULL, DevicePath););
1216 if (DevicePath
== NULL
) {
1217 return (EFI_NOT_FOUND
);
1221 // Copy the device path, open the file, then free the memory
1223 Status
= InternalOpenFileDevicePath(DevicePath
, FileHandle
, OpenMode
, 0); // 0 = no specific file attributes
1224 FreePool(DevicePath
);
1230 Deletes the file specified by the file name.
1232 This function deletes a file.
1234 @param FileName Points to the NULL-terminated file name.
1236 @retval EFI_SUCCESS The file was closed and deleted, and the handle was closed.
1237 @retval EFI_WARN_DELETE_FAILURE The handle was closed but the file was not deleted.
1238 @sa EfiShellCreateFile
1242 EfiShellDeleteFileByName(
1243 IN CONST CHAR16
*FileName
1246 SHELL_FILE_HANDLE FileHandle
;
1250 // get a handle to the file
1252 Status
= EfiShellCreateFile(FileName
,
1255 if (EFI_ERROR(Status
)) {
1259 // now delete the file
1261 return (ShellInfoObject
.NewEfiShellProtocol
->DeleteFile(FileHandle
));
1265 Disables the page break output mode.
1269 EfiShellDisablePageBreak (
1273 ShellInfoObject
.PageBreakEnabled
= FALSE
;
1277 Enables the page break output mode.
1281 EfiShellEnablePageBreak (
1285 ShellInfoObject
.PageBreakEnabled
= TRUE
;
1289 internal worker function to load and run an image via device path.
1291 @param ParentImageHandle A handle of the image that is executing the specified
1293 @param DevicePath device path of the file to execute
1294 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1295 containing the command line. If NULL then the command-
1297 @param Environment Points to a NULL-terminated array of environment
1298 variables with the format 'x=y', where x is the
1299 environment variable name and y is the value. If this
1300 is NULL, then the current shell environment is used.
1301 @param StatusCode Points to the status code returned by the command.
1303 @retval EFI_SUCCESS The command executed successfully. The status code
1304 returned by the command is pointed to by StatusCode.
1305 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1306 @retval EFI_OUT_OF_RESOURCES Out of resources.
1307 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1311 InternalShellExecuteDevicePath(
1312 IN CONST EFI_HANDLE
*ParentImageHandle
,
1313 IN CONST EFI_DEVICE_PATH_PROTOCOL
*DevicePath
,
1314 IN CONST CHAR16
*CommandLine OPTIONAL
,
1315 IN CONST CHAR16
**Environment OPTIONAL
,
1316 OUT EFI_STATUS
*StatusCode OPTIONAL
1320 EFI_HANDLE NewHandle
;
1321 EFI_LOADED_IMAGE_PROTOCOL
*LoadedImage
;
1322 LIST_ENTRY OrigEnvs
;
1323 EFI_SHELL_PARAMETERS_PROTOCOL ShellParamsProtocol
;
1325 if (ParentImageHandle
== NULL
) {
1326 return (EFI_INVALID_PARAMETER
);
1329 InitializeListHead(&OrigEnvs
);
1334 // Load the image with:
1335 // FALSE - not from boot manager and NULL, 0 being not already in memory
1337 Status
= gBS
->LoadImage(
1340 (EFI_DEVICE_PATH_PROTOCOL
*)DevicePath
,
1345 if (EFI_ERROR(Status
)) {
1346 if (NewHandle
!= NULL
) {
1347 gBS
->UnloadImage(NewHandle
);
1351 Status
= gBS
->OpenProtocol(
1353 &gEfiLoadedImageProtocolGuid
,
1354 (VOID
**)&LoadedImage
,
1357 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
1359 if (!EFI_ERROR(Status
)) {
1360 ASSERT(LoadedImage
->LoadOptionsSize
== 0);
1361 if (CommandLine
!= NULL
) {
1362 LoadedImage
->LoadOptionsSize
= (UINT32
)StrSize(CommandLine
);
1363 LoadedImage
->LoadOptions
= (VOID
*)CommandLine
;
1367 // Save our current environment settings for later restoration if necessary
1369 if (Environment
!= NULL
) {
1370 Status
= GetEnvironmentVariableList(&OrigEnvs
);
1371 if (!EFI_ERROR(Status
)) {
1372 Status
= SetEnvironmentVariables(Environment
);
1377 // Initialize and install a shell parameters protocol on the image.
1379 ShellParamsProtocol
.StdIn
= ShellInfoObject
.NewShellParametersProtocol
->StdIn
;
1380 ShellParamsProtocol
.StdOut
= ShellInfoObject
.NewShellParametersProtocol
->StdOut
;
1381 ShellParamsProtocol
.StdErr
= ShellInfoObject
.NewShellParametersProtocol
->StdErr
;
1382 Status
= UpdateArgcArgv(&ShellParamsProtocol
, CommandLine
, NULL
, NULL
);
1383 ASSERT_EFI_ERROR(Status
);
1384 Status
= gBS
->InstallProtocolInterface(&NewHandle
, &gEfiShellParametersProtocolGuid
, EFI_NATIVE_INTERFACE
, &ShellParamsProtocol
);
1385 ASSERT_EFI_ERROR(Status
);
1387 ///@todo initialize and install ShellInterface protocol on the new image for compatibility if - PcdGetBool(PcdShellSupportOldProtocols)
1390 // now start the image and if the caller wanted the return code pass it to them...
1392 if (!EFI_ERROR(Status
)) {
1393 if (StatusCode
!= NULL
) {
1394 *StatusCode
= gBS
->StartImage(NewHandle
, NULL
, NULL
);
1396 Status
= gBS
->StartImage(NewHandle
, NULL
, NULL
);
1401 // Cleanup (and dont overwrite errors)
1403 if (EFI_ERROR(Status
)) {
1404 gBS
->UninstallProtocolInterface(NewHandle
, &gEfiShellParametersProtocolGuid
, &ShellParamsProtocol
);
1406 Status
= gBS
->UninstallProtocolInterface(NewHandle
, &gEfiShellParametersProtocolGuid
, &ShellParamsProtocol
);
1407 ASSERT_EFI_ERROR(Status
);
1411 if (!IsListEmpty(&OrigEnvs
)) {
1412 if (EFI_ERROR(Status
)) {
1413 SetEnvironmentVariableList(&OrigEnvs
);
1415 Status
= SetEnvironmentVariableList(&OrigEnvs
);
1422 Execute the command line.
1424 This function creates a nested instance of the shell and executes the specified
1425 command (CommandLine) with the specified environment (Environment). Upon return,
1426 the status code returned by the specified command is placed in StatusCode.
1428 If Environment is NULL, then the current environment is used and all changes made
1429 by the commands executed will be reflected in the current environment. If the
1430 Environment is non-NULL, then the changes made will be discarded.
1432 The CommandLine is executed from the current working directory on the current
1435 @param ParentImageHandle A handle of the image that is executing the specified
1437 @param CommandLine Points to the NULL-terminated UCS-2 encoded string
1438 containing the command line. If NULL then the command-
1440 @param Environment Points to a NULL-terminated array of environment
1441 variables with the format 'x=y', where x is the
1442 environment variable name and y is the value. If this
1443 is NULL, then the current shell environment is used.
1444 @param StatusCode Points to the status code returned by the command.
1446 @retval EFI_SUCCESS The command executed successfully. The status code
1447 returned by the command is pointed to by StatusCode.
1448 @retval EFI_INVALID_PARAMETER The parameters are invalid.
1449 @retval EFI_OUT_OF_RESOURCES Out of resources.
1450 @retval EFI_UNSUPPORTED Nested shell invocations are not allowed.
1451 @retval EFI_UNSUPPORTED The support level required for this function is not present.
1453 @sa InternalShellExecuteDevicePath
1458 IN EFI_HANDLE
*ParentImageHandle
,
1459 IN CHAR16
*CommandLine OPTIONAL
,
1460 IN CHAR16
**Environment OPTIONAL
,
1461 OUT EFI_STATUS
*StatusCode OPTIONAL
1466 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
1469 if ((PcdGet8(PcdShellSupportLevel
) < 1)) {
1470 return (EFI_UNSUPPORTED
);
1473 DevPath
= AppendDevicePath (ShellInfoObject
.ImageDevPath
, ShellInfoObject
.FileDevPath
);
1476 Temp
= gDevPathToText
->ConvertDevicePathToText(ShellInfoObject
.FileDevPath
, TRUE
, TRUE
);
1478 Temp
= gDevPathToText
->ConvertDevicePathToText(ShellInfoObject
.ImageDevPath
, TRUE
, TRUE
);
1480 Temp
= gDevPathToText
->ConvertDevicePathToText(DevPath
, TRUE
, TRUE
);
1486 ASSERT((Temp
== NULL
&& Size
== 0) || (Temp
!= NULL
));
1487 StrnCatGrow(&Temp
, &Size
, L
"Shell.efi ", 0);
1488 StrnCatGrow(&Temp
, &Size
, CommandLine
, 0);
1490 Status
= InternalShellExecuteDevicePath(
1494 (CONST CHAR16
**)Environment
,
1498 // de-allocate and return
1506 Utility cleanup function for EFI_SHELL_FILE_INFO objects.
1508 1) frees all pointers (non-NULL)
1509 2) Closes the SHELL_FILE_HANDLE
1511 @param FileListNode pointer to the list node to free
1515 InternalFreeShellFileInfoNode(
1516 IN EFI_SHELL_FILE_INFO
*FileListNode
1519 if (FileListNode
->Info
!= NULL
) {
1520 FreePool((VOID
*)FileListNode
->Info
);
1522 if (FileListNode
->FileName
!= NULL
) {
1523 FreePool((VOID
*)FileListNode
->FileName
);
1525 if (FileListNode
->FullName
!= NULL
) {
1526 FreePool((VOID
*)FileListNode
->FullName
);
1528 if (FileListNode
->Handle
!= NULL
) {
1529 ShellInfoObject
.NewEfiShellProtocol
->CloseFile(FileListNode
->Handle
);
1531 FreePool(FileListNode
);
1534 Frees the file list.
1536 This function cleans up the file list and any related data structures. It has no
1537 impact on the files themselves.
1539 @param FileList The file list to free. Type EFI_SHELL_FILE_INFO is
1540 defined in OpenFileList()
1542 @retval EFI_SUCCESS Free the file list successfully.
1543 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1547 EfiShellFreeFileList(
1548 IN EFI_SHELL_FILE_INFO
**FileList
1551 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1553 if (FileList
== NULL
|| *FileList
== NULL
) {
1554 return (EFI_INVALID_PARAMETER
);
1557 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1558 ; !IsListEmpty(&(*FileList
)->Link
)
1559 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1561 RemoveEntryList(&ShellFileListItem
->Link
);
1562 InternalFreeShellFileInfoNode(ShellFileListItem
);
1564 return(EFI_SUCCESS
);
1568 Deletes the duplicate file names files in the given file list.
1570 This function deletes the reduplicate files in the given file list.
1572 @param FileList A pointer to the first entry in the file list.
1574 @retval EFI_SUCCESS Always success.
1575 @retval EFI_INVALID_PARAMETER FileList was NULL or *FileList was NULL;
1579 EfiShellRemoveDupInFileList(
1580 IN EFI_SHELL_FILE_INFO
**FileList
1583 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1584 EFI_SHELL_FILE_INFO
*ShellFileListItem2
;
1586 if (FileList
== NULL
|| *FileList
== NULL
) {
1587 return (EFI_INVALID_PARAMETER
);
1589 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
1590 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1591 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1593 for ( ShellFileListItem2
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
1594 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem2
->Link
)
1595 ; ShellFileListItem2
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem2
->Link
)
1597 if (gUnicodeCollation
->StriColl(
1599 (CHAR16
*)ShellFileListItem
->FullName
,
1600 (CHAR16
*)ShellFileListItem2
->FullName
) == 0
1602 RemoveEntryList(&ShellFileListItem2
->Link
);
1603 InternalFreeShellFileInfoNode(ShellFileListItem2
);
1607 return (EFI_SUCCESS
);
1610 Allocates and duplicates a EFI_SHELL_FILE_INFO node.
1612 @param[in] Node The node to copy from.
1613 @param[in] Save TRUE to set Node->Handle to NULL, FALSE otherwise.
1615 @retval NULL a memory allocation error ocurred
1616 @return != NULL a pointer to the new node
1618 EFI_SHELL_FILE_INFO
*
1620 InternalDuplicateShellFileInfo(
1621 IN EFI_SHELL_FILE_INFO
*Node
,
1625 EFI_SHELL_FILE_INFO
*NewNode
;
1627 NewNode
= AllocatePool(sizeof(EFI_SHELL_FILE_INFO
));
1628 if (NewNode
== NULL
) {
1631 NewNode
->FullName
= AllocateZeroPool(StrSize(Node
->FullName
));
1633 NewNode
->FileName
= AllocateZeroPool(StrSize(Node
->FileName
));
1634 NewNode
->Info
= AllocatePool((UINTN
)Node
->Info
->Size
);
1635 if ( NewNode
->FullName
== NULL
1636 || NewNode
->FileName
== NULL
1637 || NewNode
->Info
== NULL
1641 NewNode
->Status
= Node
->Status
;
1642 NewNode
->Handle
= Node
->Handle
;
1644 Node
->Handle
= NULL
;
1646 StrCpy((CHAR16
*)NewNode
->FullName
, Node
->FullName
);
1647 StrCpy((CHAR16
*)NewNode
->FileName
, Node
->FileName
);
1648 CopyMem(NewNode
->Info
, Node
->Info
, (UINTN
)Node
->Info
->Size
);
1654 Allocates and populates a EFI_SHELL_FILE_INFO structure. if any memory operation
1655 failed it will return NULL.
1657 @param[in] BasePath the Path to prepend onto filename for FullPath
1658 @param[in] Status Status member initial value.
1659 @param[in] FullName FullName member initial value.
1660 @param[in] FileName FileName member initial value.
1661 @param[in] Handle Handle member initial value.
1662 @param[in] Info Info struct to copy.
1664 @retval NULL An error ocurred.
1665 @return a pointer to the newly allocated structure.
1667 EFI_SHELL_FILE_INFO
*
1669 CreateAndPopulateShellFileInfo(
1670 IN CONST CHAR16
*BasePath
,
1671 IN CONST EFI_STATUS Status
,
1672 IN CONST CHAR16
*FullName
,
1673 IN CONST CHAR16
*FileName
,
1674 IN CONST SHELL_FILE_HANDLE Handle
,
1675 IN CONST EFI_FILE_INFO
*Info
1678 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1685 ShellFileListItem
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1686 if (ShellFileListItem
== NULL
) {
1690 ShellFileListItem
->Info
= AllocateZeroPool((UINTN
)Info
->Size
);
1691 if (ShellFileListItem
->Info
== NULL
) {
1692 FreePool(ShellFileListItem
);
1695 CopyMem(ShellFileListItem
->Info
, Info
, (UINTN
)Info
->Size
);
1697 ShellFileListItem
->Info
= NULL
;
1699 if (FileName
!= NULL
) {
1700 ASSERT(TempString
== NULL
);
1701 ShellFileListItem
->FileName
= StrnCatGrow(&TempString
, 0, FileName
, 0);
1702 if (ShellFileListItem
->FileName
== NULL
) {
1703 FreePool(ShellFileListItem
->Info
);
1704 FreePool(ShellFileListItem
);
1708 ShellFileListItem
->FileName
= NULL
;
1712 if (BasePath
!= NULL
) {
1713 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
1714 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
1715 if (TempString
== NULL
) {
1716 FreePool((VOID
*)ShellFileListItem
->FileName
);
1717 FreePool(ShellFileListItem
->Info
);
1718 FreePool(ShellFileListItem
);
1722 if (ShellFileListItem
->FileName
!= NULL
) {
1723 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
1724 TempString
= StrnCatGrow(&TempString
, &Size
, ShellFileListItem
->FileName
, 0);
1725 if (TempString
== NULL
) {
1726 FreePool((VOID
*)ShellFileListItem
->FileName
);
1727 FreePool(ShellFileListItem
->Info
);
1728 FreePool(ShellFileListItem
);
1733 ShellFileListItem
->FullName
= TempString
;
1734 ShellFileListItem
->Status
= Status
;
1735 ShellFileListItem
->Handle
= Handle
;
1737 return (ShellFileListItem
);
1741 Find all files in a specified directory.
1743 @param FileDirHandle Handle of the directory to search.
1744 @param FileList On return, points to the list of files in the directory
1745 or NULL if there are no files in the directory.
1747 @retval EFI_SUCCESS File information was returned successfully.
1748 @retval EFI_VOLUME_CORRUPTED The file system structures have been corrupted.
1749 @retval EFI_DEVICE_ERROR The device reported an error.
1750 @retval EFI_NO_MEDIA The device media is not present.
1751 @retval EFI_INVALID_PARAMETER The FileDirHandle was not a directory.
1752 @return An error from FileHandleGetFileName().
1756 EfiShellFindFilesInDir(
1757 IN SHELL_FILE_HANDLE FileDirHandle
,
1758 OUT EFI_SHELL_FILE_INFO
**FileList
1761 EFI_SHELL_FILE_INFO
*ShellFileList
;
1762 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
1763 EFI_FILE_INFO
*FileInfo
;
1771 Status
= FileHandleGetFileName(FileDirHandle
, &BasePath
);
1772 if (EFI_ERROR(Status
)) {
1776 if (ShellFileHandleGetPath(FileDirHandle
) != NULL
) {
1779 TempString
= StrnCatGrow(&TempString
, &Size
, ShellFileHandleGetPath(FileDirHandle
), 0);
1780 TempSpot
= StrStr(TempString
, L
";");
1782 if (TempSpot
!= NULL
) {
1783 *TempSpot
= CHAR_NULL
;
1786 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
1787 BasePath
= TempString
;
1791 ShellFileList
= NULL
;
1792 ShellFileListItem
= NULL
;
1794 Status
= EFI_SUCCESS
;
1797 for ( Status
= FileHandleFindFirstFile(FileDirHandle
, &FileInfo
)
1798 ; !EFI_ERROR(Status
) && !NoFile
1799 ; Status
= FileHandleFindNextFile(FileDirHandle
, FileInfo
, &NoFile
)
1804 // allocate a new EFI_SHELL_FILE_INFO and populate it...
1806 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
1807 TempString
= StrnCatGrow(&TempString
, &Size
, BasePath
, 0);
1808 TempString
= StrnCatGrow(&TempString
, &Size
, FileInfo
->FileName
, 0);
1809 ShellFileListItem
= CreateAndPopulateShellFileInfo(
1811 EFI_SUCCESS
, // success since we didnt fail to open it...
1814 NULL
, // no handle since not open
1817 if (ShellFileList
== NULL
) {
1818 ShellFileList
= (EFI_SHELL_FILE_INFO
*)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1819 ASSERT(ShellFileList
!= NULL
);
1820 InitializeListHead(&ShellFileList
->Link
);
1822 InsertTailList(&ShellFileList
->Link
, &ShellFileListItem
->Link
);
1824 if (EFI_ERROR(Status
)) {
1825 EfiShellFreeFileList(&ShellFileList
);
1828 *FileList
= ShellFileList
;
1830 SHELL_FREE_NON_NULL(BasePath
);
1835 Updates a file name to be preceeded by the mapped drive name
1837 @param[in] BasePath the Mapped drive name to prepend
1838 @param[in,out] Path pointer to pointer to the file name to update.
1841 @retval EFI_OUT_OF_RESOURCES
1846 IN CONST CHAR16
*BasePath
,
1847 IN OUT CHAR16
**Path
1856 ASSERT(Path
!= NULL
);
1857 ASSERT(*Path
!= NULL
);
1858 ASSERT(BasePath
!= NULL
);
1861 // convert a local path to an absolute path
1863 if (StrStr(*Path
, L
":") == NULL
) {
1864 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
1865 StrnCatGrow(&Path2
, &Path2Size
, BasePath
, 0);
1866 if (Path2
== NULL
) {
1867 return (EFI_OUT_OF_RESOURCES
);
1869 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
1870 StrnCatGrow(&Path2
, &Path2Size
, (*Path
)[0] == L
'\\'?(*Path
) + 1 :*Path
, 0);
1871 if (Path2
== NULL
) {
1872 return (EFI_OUT_OF_RESOURCES
);
1879 return (EFI_SUCCESS
);
1883 If FileHandle is a directory then the function reads from FileHandle and reads in
1884 each of the FileInfo structures. If one of them matches the Pattern's first
1885 "level" then it opens that handle and calls itself on that handle.
1887 If FileHandle is a file and matches all of the remaining Pattern (which would be
1888 on its last node), then add a EFI_SHELL_FILE_INFO object for this file to fileList.
1890 Upon a EFI_SUCCESS return fromt he function any the caller is responsible to call
1891 FreeFileList with FileList.
1893 @param[in] FilePattern The FilePattern to check against.
1894 @param[in] UnicodeCollation The pointer to EFI_UNICODE_COLLATION_PROTOCOL structure
1895 @param[in] FileHandle The FileHandle to start with
1896 @param[in,out] FileList pointer to pointer to list of found files.
1897 @param[in] ParentNode The node for the parent. Same file as identified by HANDLE.
1898 @param[in] MapName The file system name this file is on.
1900 @retval EFI_SUCCESS all files were found and the FileList contains a list.
1901 @retval EFI_NOT_FOUND no files were found
1902 @retval EFI_OUT_OF_RESOURCES a memory allocation failed
1907 IN CONST CHAR16
*FilePattern
,
1908 IN EFI_UNICODE_COLLATION_PROTOCOL
*UnicodeCollation
,
1909 IN SHELL_FILE_HANDLE FileHandle
,
1910 IN OUT EFI_SHELL_FILE_INFO
**FileList
,
1911 IN CONST EFI_SHELL_FILE_INFO
*ParentNode OPTIONAL
,
1912 IN CONST CHAR16
*MapName
1916 CONST CHAR16
*NextFilePatternStart
;
1917 CHAR16
*CurrentFilePattern
;
1918 EFI_SHELL_FILE_INFO
*ShellInfo
;
1919 EFI_SHELL_FILE_INFO
*ShellInfoNode
;
1920 EFI_SHELL_FILE_INFO
*NewShellNode
;
1922 CHAR16
*NewFullName
;
1925 if ( FilePattern
== NULL
1926 || UnicodeCollation
== NULL
1929 return (EFI_INVALID_PARAMETER
);
1932 CurrentFilePattern
= NULL
;
1934 if (*FilePattern
== L
'\\') {
1938 for( NextFilePatternStart
= FilePattern
1939 ; *NextFilePatternStart
!= CHAR_NULL
&& *NextFilePatternStart
!= L
'\\'
1940 ; NextFilePatternStart
++);
1942 CurrentFilePattern
= AllocateZeroPool((NextFilePatternStart
-FilePattern
+1)*sizeof(CHAR16
));
1943 ASSERT(CurrentFilePattern
!= NULL
);
1944 StrnCpy(CurrentFilePattern
, FilePattern
, NextFilePatternStart
-FilePattern
);
1946 if (CurrentFilePattern
[0] == CHAR_NULL
1947 &&NextFilePatternStart
[0] == CHAR_NULL
1950 // Add the current parameter FileHandle to the list, then end...
1952 if (ParentNode
== NULL
) {
1953 Status
= EFI_INVALID_PARAMETER
;
1955 NewShellNode
= InternalDuplicateShellFileInfo((EFI_SHELL_FILE_INFO
*)ParentNode
, TRUE
);
1956 if (NewShellNode
== NULL
) {
1957 Status
= EFI_OUT_OF_RESOURCES
;
1959 NewShellNode
->Handle
= NULL
;
1960 if (*FileList
== NULL
) {
1961 *FileList
= AllocatePool(sizeof(EFI_SHELL_FILE_INFO
));
1962 InitializeListHead(&((*FileList
)->Link
));
1966 // Add to the returning to use list
1968 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
1970 Status
= EFI_SUCCESS
;
1974 Status
= EfiShellFindFilesInDir(FileHandle
, &ShellInfo
);
1976 if (!EFI_ERROR(Status
)){
1977 if (StrStr(NextFilePatternStart
, L
"\\") != NULL
){
1982 for ( ShellInfoNode
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&ShellInfo
->Link
)
1983 ; !IsNull (&ShellInfo
->Link
, &ShellInfoNode
->Link
)
1984 ; ShellInfoNode
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&ShellInfo
->Link
, &ShellInfoNode
->Link
)
1986 if (UnicodeCollation
->MetaiMatch(UnicodeCollation
, (CHAR16
*)ShellInfoNode
->FileName
, CurrentFilePattern
)){
1987 if (ShellInfoNode
->FullName
!= NULL
&& StrStr(ShellInfoNode
->FullName
, L
":") == NULL
) {
1988 Size
= StrSize(ShellInfoNode
->FullName
);
1989 Size
+= StrSize(MapName
) + sizeof(CHAR16
);
1990 NewFullName
= AllocateZeroPool(Size
);
1991 if (NewFullName
== NULL
) {
1992 Status
= EFI_OUT_OF_RESOURCES
;
1994 StrCpy(NewFullName
, MapName
);
1995 StrCat(NewFullName
, ShellInfoNode
->FullName
+1);
1996 FreePool((VOID
*)ShellInfoNode
->FullName
);
1997 ShellInfoNode
->FullName
= NewFullName
;
2000 if (Directory
&& !EFI_ERROR(Status
)){
2002 // should be a directory
2006 // don't open the . and .. directories
2008 if ( (StrCmp(ShellInfoNode
->FileName
, L
".") != 0)
2009 && (StrCmp(ShellInfoNode
->FileName
, L
"..") != 0)
2014 ASSERT_EFI_ERROR(Status
);
2015 if (EFI_ERROR(Status
)) {
2019 // Open the directory since we need that handle in the next recursion.
2021 ShellInfoNode
->Status
= EfiShellOpenFileByName (ShellInfoNode
->FullName
, &ShellInfoNode
->Handle
, EFI_FILE_MODE_READ
);
2024 // recurse with the next part of the pattern
2026 Status
= ShellSearchHandle(NextFilePatternStart
, UnicodeCollation
, ShellInfoNode
->Handle
, FileList
, ShellInfoNode
, MapName
);
2028 } else if (!EFI_ERROR(Status
)) {
2034 // copy the information we need into a new Node
2036 NewShellNode
= InternalDuplicateShellFileInfo(ShellInfoNode
, FALSE
);
2037 ASSERT(NewShellNode
!= NULL
);
2038 if (NewShellNode
== NULL
) {
2039 Status
= EFI_OUT_OF_RESOURCES
;
2041 if (*FileList
== NULL
) {
2042 *FileList
= AllocatePool(sizeof(EFI_SHELL_FILE_INFO
));
2043 InitializeListHead(&((*FileList
)->Link
));
2047 // Add to the returning to use list
2049 InsertTailList(&(*FileList
)->Link
, &NewShellNode
->Link
);
2052 if (EFI_ERROR(Status
)) {
2056 if (EFI_ERROR(Status
)) {
2057 EfiShellFreeFileList(&ShellInfo
);
2059 Status
= EfiShellFreeFileList(&ShellInfo
);
2064 FreePool(CurrentFilePattern
);
2069 Find files that match a specified pattern.
2071 This function searches for all files and directories that match the specified
2072 FilePattern. The FilePattern can contain wild-card characters. The resulting file
2073 information is placed in the file list FileList.
2075 Wildcards are processed
2076 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1.
2078 The files in the file list are not opened. The OpenMode field is set to 0 and the FileInfo
2079 field is set to NULL.
2081 if *FileList is not NULL then it must be a pre-existing and properly initialized list.
2083 @param FilePattern Points to a NULL-terminated shell file path, including wildcards.
2084 @param FileList On return, points to the start of a file list containing the names
2085 of all matching files or else points to NULL if no matching files
2086 were found. only on a EFI_SUCCESS return will; this be non-NULL.
2088 @retval EFI_SUCCESS Files found. FileList is a valid list.
2089 @retval EFI_NOT_FOUND No files found.
2090 @retval EFI_NO_MEDIA The device has no media
2091 @retval EFI_DEVICE_ERROR The device reported an error
2092 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted
2097 IN CONST CHAR16
*FilePattern
,
2098 OUT EFI_SHELL_FILE_INFO
**FileList
2102 CHAR16
*PatternCopy
;
2103 CHAR16
*PatternCurrentLocation
;
2104 EFI_DEVICE_PATH_PROTOCOL
*RootDevicePath
;
2105 SHELL_FILE_HANDLE RootFileHandle
;
2109 if ( FilePattern
== NULL
2111 || StrStr(FilePattern
, L
":") == NULL
2113 return (EFI_INVALID_PARAMETER
);
2115 Status
= EFI_SUCCESS
;
2116 RootDevicePath
= NULL
;
2117 RootFileHandle
= NULL
;
2119 PatternCopy
= AllocatePool(StrSize(FilePattern
));
2120 if (PatternCopy
== NULL
) {
2121 return (EFI_OUT_OF_RESOURCES
);
2123 StrCpy(PatternCopy
, FilePattern
);
2125 PatternCopy
= CleanPath(PatternCopy
);
2127 Count
= StrStr(PatternCopy
, L
":") - PatternCopy
;
2130 ASSERT(MapName
== NULL
);
2131 MapName
= StrnCatGrow(&MapName
, NULL
, PatternCopy
, Count
);
2133 if (!EFI_ERROR(Status
)) {
2134 RootDevicePath
= EfiShellGetDevicePathFromFilePath(PatternCopy
);
2135 if (RootDevicePath
== NULL
) {
2136 Status
= EFI_INVALID_PARAMETER
;
2138 Status
= EfiShellOpenRoot(RootDevicePath
, &RootFileHandle
);
2139 if (!EFI_ERROR(Status
)) {
2140 for ( PatternCurrentLocation
= PatternCopy
2141 ; *PatternCurrentLocation
!= ':'
2142 ; PatternCurrentLocation
++);
2143 PatternCurrentLocation
++;
2144 Status
= ShellSearchHandle(PatternCurrentLocation
, gUnicodeCollation
, RootFileHandle
, FileList
, NULL
, MapName
);
2146 FreePool(RootDevicePath
);
2150 SHELL_FREE_NON_NULL(PatternCopy
);
2151 SHELL_FREE_NON_NULL(MapName
);
2157 Opens the files that match the path specified.
2159 This function opens all of the files specified by Path. Wildcards are processed
2160 according to the rules specified in UEFI Shell 2.0 spec section 3.7.1. Each
2161 matching file has an EFI_SHELL_FILE_INFO structure created in a linked list.
2163 @param Path A pointer to the path string.
2164 @param OpenMode Specifies the mode used to open each file, EFI_FILE_MODE_READ or
2165 EFI_FILE_MODE_WRITE.
2166 @param FileList Points to the start of a list of files opened.
2168 @retval EFI_SUCCESS Create the file list successfully.
2169 @return Others Can't create the file list.
2173 EfiShellOpenFileList(
2176 IN OUT EFI_SHELL_FILE_INFO
**FileList
2180 EFI_SHELL_FILE_INFO
*ShellFileListItem
;
2183 CONST CHAR16
*CurDir
;
2185 ShellCommandCleanPath(Path
);
2190 ASSERT(FileList
!= NULL
);
2191 ASSERT(*FileList
!= NULL
);
2193 if (*Path
== L
'.' && *(Path
+1) == L
'\\') {
2198 // convert a local path to an absolute path
2200 if (StrStr(Path
, L
":") == NULL
) {
2201 CurDir
= EfiShellGetCurDir(NULL
);
2202 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2203 StrnCatGrow(&Path2
, &Path2Size
, CurDir
, 0);
2204 if (*Path
== L
'\\') {
2207 ASSERT((Path2
== NULL
&& Path2Size
== 0) || (Path2
!= NULL
));
2208 StrnCatGrow(&Path2
, &Path2Size
, Path
, 0);
2210 ASSERT(Path2
== NULL
);
2211 StrnCatGrow(&Path2
, NULL
, Path
, 0);
2219 Status
= EfiShellFindFiles(Path2
, FileList
);
2223 if (EFI_ERROR(Status
)) {
2228 // We had no errors so open all the files (that are not already opened...)
2230 for ( ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetFirstNode(&(*FileList
)->Link
)
2231 ; !IsNull(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2232 ; ShellFileListItem
= (EFI_SHELL_FILE_INFO
*)GetNextNode(&(*FileList
)->Link
, &ShellFileListItem
->Link
)
2234 if (ShellFileListItem
->Status
== 0 && ShellFileListItem
->Handle
== NULL
) {
2235 ShellFileListItem
->Status
= EfiShellOpenFileByName (ShellFileListItem
->FullName
, &ShellFileListItem
->Handle
, OpenMode
);
2239 return(EFI_SUCCESS
);
2243 This function updated with errata.
2245 Gets either a single or list of environment variables.
2247 If name is not NULL then this function returns the current value of the specified
2248 environment variable.
2250 If Name is NULL, then a list of all environment variable names is returned. Each is a
2251 NULL terminated string with a double NULL terminating the list.
2253 @param Name A pointer to the environment variable name. If
2254 Name is NULL, then the function will return all
2255 of the defined shell environment variables. In
2256 the case where multiple environment variables are
2257 being returned, each variable will be terminated by
2258 a NULL, and the list will be terminated by a double
2261 @return !=NULL A pointer to the returned string.
2262 The returned pointer does not need to be freed by the caller.
2264 @retval NULL The environment variable doesn't exist or there are
2265 no environment variables.
2270 IN CONST CHAR16
*Name
2278 CHAR16
*CurrentWriteLocation
;
2285 // Get all our environment variables
2287 InitializeListHead(&List
);
2288 Status
= GetEnvironmentVariableList(&List
);
2289 if (EFI_ERROR(Status
)){
2294 // Build the semi-colon delimited list. (2 passes)
2296 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&List
)
2297 ; !IsNull(&List
, &Node
->Link
)
2298 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&List
, &Node
->Link
)
2300 ASSERT(Node
->Key
!= NULL
);
2301 Size
+= StrSize(Node
->Key
);
2304 Size
+= 2*sizeof(CHAR16
);
2306 Buffer
= AllocateZeroPool(Size
);
2307 if (Buffer
== NULL
) {
2308 if (!IsListEmpty (&List
)) {
2309 FreeEnvironmentVariableList(&List
);
2313 CurrentWriteLocation
= (CHAR16
*)Buffer
;
2315 for ( Node
= (ENV_VAR_LIST
*)GetFirstNode(&List
)
2316 ; !IsNull(&List
, &Node
->Link
)
2317 ; Node
= (ENV_VAR_LIST
*)GetNextNode(&List
, &Node
->Link
)
2319 ASSERT(Node
->Key
!= NULL
);
2320 StrCpy(CurrentWriteLocation
, Node
->Key
);
2321 CurrentWriteLocation
+= StrLen(CurrentWriteLocation
) + 1;
2327 if (!IsListEmpty (&List
)) {
2328 FreeEnvironmentVariableList(&List
);
2332 // We are doing a specific environment variable
2336 // get the size we need for this EnvVariable
2338 Status
= SHELL_GET_ENVIRONMENT_VARIABLE(Name
, &Size
, Buffer
);
2339 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2341 // Allocate the space and recall the get function
2343 Buffer
= AllocateZeroPool(Size
);
2344 ASSERT(Buffer
!= NULL
);
2345 Status
= SHELL_GET_ENVIRONMENT_VARIABLE(Name
, &Size
, Buffer
);
2348 // we didnt get it (might not exist)
2349 // free the memory if we allocated any and return NULL
2351 if (EFI_ERROR(Status
)) {
2352 if (Buffer
!= NULL
) {
2360 // return the buffer
2362 return (AddBufferToFreeList(Buffer
));
2366 Internal variable setting function. Allows for setting of the read only variables.
2368 @param Name Points to the NULL-terminated environment variable name.
2369 @param Value Points to the NULL-terminated environment variable value. If the value is an
2370 empty string then the environment variable is deleted.
2371 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2373 @retval EFI_SUCCESS The environment variable was successfully updated.
2377 InternalEfiShellSetEnv(
2378 IN CONST CHAR16
*Name
,
2379 IN CONST CHAR16
*Value
,
2383 if (Value
== NULL
|| StrLen(Value
) == 0) {
2384 return (SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
));
2386 SHELL_DELETE_ENVIRONMENT_VARIABLE(Name
);
2388 return (SHELL_SET_ENVIRONMENT_VARIABLE_V(Name
, StrSize(Value
), Value
));
2390 return (SHELL_SET_ENVIRONMENT_VARIABLE_NV(Name
, StrSize(Value
), Value
));
2396 Sets the environment variable.
2398 This function changes the current value of the specified environment variable. If the
2399 environment variable exists and the Value is an empty string, then the environment
2400 variable is deleted. If the environment variable exists and the Value is not an empty
2401 string, then the value of the environment variable is changed. If the environment
2402 variable does not exist and the Value is an empty string, there is no action. If the
2403 environment variable does not exist and the Value is a non-empty string, then the
2404 environment variable is created and assigned the specified value.
2406 For a description of volatile and non-volatile environment variables, see UEFI Shell
2407 2.0 specification section 3.6.1.
2409 @param Name Points to the NULL-terminated environment variable name.
2410 @param Value Points to the NULL-terminated environment variable value. If the value is an
2411 empty string then the environment variable is deleted.
2412 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
2414 @retval EFI_SUCCESS The environment variable was successfully updated.
2419 IN CONST CHAR16
*Name
,
2420 IN CONST CHAR16
*Value
,
2424 if (Name
== NULL
|| *Name
== CHAR_NULL
) {
2425 return (EFI_INVALID_PARAMETER
);
2428 // Make sure we dont 'set' a predefined read only variable
2430 if (gUnicodeCollation
->StriColl(
2434 ||gUnicodeCollation
->StriColl(
2438 ||gUnicodeCollation
->StriColl(
2442 ||gUnicodeCollation
->StriColl(
2445 L
"uefishellsupport") == 0
2446 ||gUnicodeCollation
->StriColl(
2449 L
"uefishellversion") == 0
2450 ||gUnicodeCollation
->StriColl(
2453 L
"uefiversion") == 0
2455 return (EFI_INVALID_PARAMETER
);
2457 return (InternalEfiShellSetEnv(Name
, Value
, Volatile
));
2461 Returns the current directory on the specified device.
2463 If FileSystemMapping is NULL, it returns the current working directory. If the
2464 FileSystemMapping is not NULL, it returns the current directory associated with the
2465 FileSystemMapping. In both cases, the returned name includes the file system
2466 mapping (i.e. fs0:\current-dir).
2468 @param FileSystemMapping A pointer to the file system mapping. If NULL,
2469 then the current working directory is returned.
2471 @retval !=NULL The current directory.
2472 @retval NULL Current directory does not exist.
2477 IN CONST CHAR16
*FileSystemMapping OPTIONAL
2480 CHAR16
*PathToReturn
;
2482 SHELL_MAP_LIST
*MapListItem
;
2483 if (!IsListEmpty(&gShellMapList
.Link
)) {
2485 // if parameter is NULL, use current
2487 if (FileSystemMapping
== NULL
) {
2488 return (EfiShellGetEnv(L
"cwd"));
2491 PathToReturn
= NULL
;
2492 MapListItem
= ShellCommandFindMapItem(FileSystemMapping
);
2493 if (MapListItem
!= NULL
) {
2494 ASSERT((PathToReturn
== NULL
&& Size
== 0) || (PathToReturn
!= NULL
));
2495 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->MapName
, 0);
2496 PathToReturn
= StrnCatGrow(&PathToReturn
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
2499 return (AddBufferToFreeList(PathToReturn
));
2506 Changes the current directory on the specified device.
2508 If the FileSystem is NULL, and the directory Dir does not contain a file system's
2509 mapped name, this function changes the current working directory.
2511 If the FileSystem is NULL and the directory Dir contains a mapped name, then the
2512 current file system and the current directory on that file system are changed.
2514 If FileSystem is NULL, and Dir is not NULL, then this changes the current working file
2517 If FileSystem is not NULL and Dir is not NULL, then this function changes the current
2518 directory on the specified file system.
2520 If the current working directory or the current working file system is changed then the
2521 %cwd% environment variable will be updated
2523 @param FileSystem A pointer to the file system's mapped name. If NULL, then the current working
2524 directory is changed.
2525 @param Dir Points to the NULL-terminated directory on the device specified by FileSystem.
2527 @retval EFI_SUCCESS The operation was sucessful
2528 @retval EFI_NOT_FOUND The file system could not be found
2533 IN CONST CHAR16
*FileSystem OPTIONAL
,
2534 IN CONST CHAR16
*Dir
2538 SHELL_MAP_LIST
*MapListItem
;
2542 CHAR16
*DirectoryName
;
2549 DirectoryName
= NULL
;
2551 if ((FileSystem
== NULL
&& Dir
== NULL
) || Dir
== NULL
) {
2552 return (EFI_INVALID_PARAMETER
);
2555 if (IsListEmpty(&gShellMapList
.Link
)){
2556 return (EFI_NOT_FOUND
);
2559 DirectoryName
= StrnCatGrow(&DirectoryName
, NULL
, Dir
, 0);
2560 ASSERT(DirectoryName
!= NULL
);
2562 CleanPath(DirectoryName
);
2564 if (FileSystem
== NULL
) {
2566 // determine the file system mapping to use
2568 if (StrStr(DirectoryName
, L
":") != NULL
) {
2569 ASSERT(MapName
== NULL
);
2570 MapName
= StrnCatGrow(&MapName
, NULL
, DirectoryName
, (StrStr(DirectoryName
, L
":")-DirectoryName
+1));
2573 // find the file system mapping's entry in the list
2576 if (MapName
!= NULL
) {
2577 MapListItem
= ShellCommandFindMapItem(MapName
);
2580 // make that the current file system mapping
2582 if (MapListItem
!= NULL
) {
2583 gShellCurDir
= MapListItem
;
2586 MapListItem
= gShellCurDir
;
2589 if (MapListItem
== NULL
) {
2590 return (EFI_NOT_FOUND
);
2594 // now update the MapListItem's current directory
2596 if (MapListItem
->CurrentDirectoryPath
!= NULL
&& DirectoryName
[StrLen(DirectoryName
) - 1] != L
':') {
2597 FreePool(MapListItem
->CurrentDirectoryPath
);
2598 MapListItem
->CurrentDirectoryPath
= NULL
;
2600 if (MapName
!= NULL
) {
2601 TempLen
= StrLen(MapName
);
2602 if (TempLen
!= StrLen(DirectoryName
)) {
2603 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2604 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
+StrLen(MapName
), 0);
2607 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2608 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
2610 if ((MapListItem
->CurrentDirectoryPath
!= NULL
&& MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] != L
'\\') || (MapListItem
->CurrentDirectoryPath
== NULL
)) {
2611 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2612 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2616 // cant have a mapping in the directory...
2618 if (StrStr(DirectoryName
, L
":") != NULL
) {
2619 return (EFI_INVALID_PARAMETER
);
2622 // FileSystem != NULL
2624 MapListItem
= ShellCommandFindMapItem(FileSystem
);
2625 if (MapListItem
== NULL
) {
2626 return (EFI_INVALID_PARAMETER
);
2628 // gShellCurDir = MapListItem;
2629 if (DirectoryName
!= NULL
) {
2631 // change current dir on that file system
2634 if (MapListItem
->CurrentDirectoryPath
!= NULL
) {
2635 FreePool(MapListItem
->CurrentDirectoryPath
);
2636 DEBUG_CODE(MapListItem
->CurrentDirectoryPath
= NULL
;);
2638 // ASSERT((MapListItem->CurrentDirectoryPath == NULL && Size == 0) || (MapListItem->CurrentDirectoryPath != NULL));
2639 // MapListItem->CurrentDirectoryPath = StrnCatGrow(&MapListItem->CurrentDirectoryPath, &Size, FileSystem, 0);
2640 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2641 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2642 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2643 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, DirectoryName
, 0);
2644 if (MapListItem
->CurrentDirectoryPath
[StrLen(MapListItem
->CurrentDirectoryPath
)-1] != L
'\\') {
2645 ASSERT((MapListItem
->CurrentDirectoryPath
== NULL
&& Size
== 0) || (MapListItem
->CurrentDirectoryPath
!= NULL
));
2646 MapListItem
->CurrentDirectoryPath
= StrnCatGrow(&MapListItem
->CurrentDirectoryPath
, &Size
, L
"\\", 0);
2651 // if updated the current directory then update the environment variable
2653 if (MapListItem
== gShellCurDir
) {
2655 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
2656 StrnCatGrow(&TempString
, &Size
, MapListItem
->MapName
, 0);
2657 ASSERT((TempString
== NULL
&& Size
== 0) || (TempString
!= NULL
));
2658 StrnCatGrow(&TempString
, &Size
, MapListItem
->CurrentDirectoryPath
, 0);
2659 Status
= InternalEfiShellSetEnv(L
"cwd", TempString
, TRUE
);
2660 FreePool(TempString
);
2663 return(EFI_SUCCESS
);
2667 Return help information about a specific command.
2669 This function returns the help information for the specified command. The help text
2670 can be internal to the shell or can be from a UEFI Shell manual page.
2672 If Sections is specified, then each section name listed will be compared in a casesensitive
2673 manner, to the section names described in Appendix B. If the section exists,
2674 it will be appended to the returned help text. If the section does not exist, no
2675 information will be returned. If Sections is NULL, then all help text information
2676 available will be returned.
2678 @param Command Points to the NULL-terminated UEFI Shell command name.
2679 @param Sections Points to the NULL-terminated comma-delimited
2680 section names to return. If NULL, then all
2681 sections will be returned.
2682 @param HelpText On return, points to a callee-allocated buffer
2683 containing all specified help text.
2685 @retval EFI_SUCCESS The help text was returned.
2686 @retval EFI_OUT_OF_RESOURCES The necessary buffer could not be allocated to hold the
2688 @retval EFI_INVALID_PARAMETER HelpText is NULL
2689 @retval EFI_NOT_FOUND There is no help text available for Command.
2693 EfiShellGetHelpText(
2694 IN CONST CHAR16
*Command
,
2695 IN CONST CHAR16
*Sections OPTIONAL
,
2696 OUT CHAR16
**HelpText
2699 CONST CHAR16
*ManFileName
;
2701 ASSERT(HelpText
!= NULL
);
2703 ManFileName
= ShellCommandGetManFileNameHandler(Command
);
2705 if (ManFileName
!= NULL
) {
2706 return (ProcessManFile(ManFileName
, Command
, Sections
, NULL
, HelpText
));
2708 return (ProcessManFile(Command
, Command
, Sections
, NULL
, HelpText
));
2713 Gets the enable status of the page break output mode.
2715 User can use this function to determine current page break mode.
2717 @retval TRUE The page break output mode is enabled.
2718 @retval FALSE The page break output mode is disabled.
2722 EfiShellGetPageBreak(
2726 return(ShellInfoObject
.PageBreakEnabled
);
2730 Judges whether the active shell is the root shell.
2732 This function makes the user to know that whether the active Shell is the root shell.
2734 @retval TRUE The active Shell is the root Shell.
2735 @retval FALSE The active Shell is NOT the root Shell.
2739 EfiShellIsRootShell(
2743 return(ShellInfoObject
.RootShellInstance
);
2747 function to return a semi-colon delimeted list of all alias' in the current shell
2749 up to caller to free the memory.
2751 @retval NULL No alias' were found
2752 @retval NULL An error ocurred getting alias'
2753 @return !NULL a list of all alias'
2757 InternalEfiShellGetListAlias(
2765 CHAR16
*VariableName
;
2771 Status
= gRT
->QueryVariableInfo(EFI_VARIABLE_NON_VOLATILE
|EFI_VARIABLE_BOOTSERVICE_ACCESS
, &MaxStorSize
, &RemStorSize
, &MaxVarSize
);
2772 ASSERT_EFI_ERROR(Status
);
2774 VariableName
= AllocateZeroPool((UINTN
)MaxVarSize
);
2778 if (VariableName
== NULL
) {
2782 VariableName
[0] = CHAR_NULL
;
2785 NameSize
= (UINTN
)MaxVarSize
;
2786 Status
= gRT
->GetNextVariableName(&NameSize
, VariableName
, &Guid
);
2787 if (Status
== EFI_NOT_FOUND
){
2790 ASSERT_EFI_ERROR(Status
);
2791 if (EFI_ERROR(Status
)) {
2794 if (CompareGuid(&Guid
, &gShellAliasGuid
)){
2795 Alias
= GetVariable(VariableName
, &gShellAliasGuid
);
2796 ASSERT((RetVal
== NULL
&& RetSize
== 0) || (RetVal
!= NULL
));
2797 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, VariableName
, 0);
2798 RetVal
= StrnCatGrow(&RetVal
, &RetSize
, L
";", 0);
2801 FreePool(VariableName
);
2807 This function returns the command associated with a alias or a list of all
2810 @param[in] Alias Points to the NULL-terminated shell alias.
2811 If this parameter is NULL, then all
2812 aliases will be returned in ReturnedData.
2813 @param[out] Volatile upon return of a single command if TRUE indicates
2814 this is stored in a volatile fashion. FALSE otherwise.
2816 @return If Alias is not NULL, it will return a pointer to
2817 the NULL-terminated command for that alias.
2818 If Alias is NULL, ReturnedData points to a ';'
2819 delimited list of alias (e.g.
2820 ReturnedData = "dir;del;copy;mfp") that is NULL-terminated.
2821 @retval NULL an error ocurred
2822 @retval NULL Alias was not a valid Alias
2827 IN CONST CHAR16
*Alias
,
2828 OUT BOOLEAN
*Volatile OPTIONAL
2836 if (Alias
!= NULL
) {
2837 if (Volatile
== NULL
) {
2838 return (AddBufferToFreeList(GetVariable((CHAR16
*)Alias
, &gShellAliasGuid
)));
2842 Status
= gRT
->GetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
2843 if (Status
== EFI_BUFFER_TOO_SMALL
) {
2844 RetVal
= AllocateZeroPool(RetSize
);
2845 Status
= gRT
->GetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, &Attribs
, &RetSize
, RetVal
);
2847 if (EFI_ERROR(Status
)) {
2848 if (RetVal
!= NULL
) {
2853 if ((EFI_VARIABLE_NON_VOLATILE
& Attribs
) == EFI_VARIABLE_NON_VOLATILE
) {
2859 return (AddBufferToFreeList(RetVal
));
2861 return (AddBufferToFreeList(InternalEfiShellGetListAlias()));
2865 Changes a shell command alias.
2867 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
2869 this function does not check for built in alias'.
2871 @param[in] Command Points to the NULL-terminated shell command or existing alias.
2872 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
2873 Command refers to an alias, that alias will be deleted.
2874 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
2875 Alias being set will be stored in a non-volatile fashion.
2877 @retval EFI_SUCCESS Alias created or deleted successfully.
2878 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
2883 IN CONST CHAR16
*Command
,
2884 IN CONST CHAR16
*Alias
,
2889 // We must be trying to remove one if Alias is NULL
2891 if (Alias
== NULL
) {
2893 // remove an alias (but passed in COMMAND parameter)
2895 return (gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
));
2898 // Add and replace are the same
2901 // We dont check the error return on purpose since the variable may not exist.
2902 gRT
->SetVariable((CHAR16
*)Command
, &gShellAliasGuid
, 0, 0, NULL
);
2904 return (gRT
->SetVariable((CHAR16
*)Alias
, &gShellAliasGuid
, EFI_VARIABLE_BOOTSERVICE_ACCESS
|(Volatile
?0:EFI_VARIABLE_NON_VOLATILE
), StrSize(Command
), (VOID
*)Command
));
2909 Changes a shell command alias.
2911 This function creates an alias for a shell command or if Alias is NULL it will delete an existing alias.
2914 @param[in] Command Points to the NULL-terminated shell command or existing alias.
2915 @param[in] Alias Points to the NULL-terminated alias for the shell command. If this is NULL, and
2916 Command refers to an alias, that alias will be deleted.
2917 @param[in] Replace If TRUE and the alias already exists, then the existing alias will be replaced. If
2918 FALSE and the alias already exists, then the existing alias is unchanged and
2919 EFI_ACCESS_DENIED is returned.
2920 @param[in] Volatile if TRUE the Alias being set will be stored in a volatile fashion. if FALSE the
2921 Alias being set will be stored in a non-volatile fashion.
2923 @retval EFI_SUCCESS Alias created or deleted successfully.
2924 @retval EFI_NOT_FOUND the Alias intended to be deleted was not found
2925 @retval EFI_ACCESS_DENIED The alias is a built-in alias or already existed and Replace was set to
2931 IN CONST CHAR16
*Command
,
2932 IN CONST CHAR16
*Alias
,
2938 // cant set over a built in alias
2940 if (ShellCommandIsOnAliasList(Alias
==NULL
?Command
:Alias
)) {
2941 return (EFI_ACCESS_DENIED
);
2943 if (Command
== NULL
|| *Command
== CHAR_NULL
|| StrLen(Command
) == 0) {
2944 return (EFI_INVALID_PARAMETER
);
2947 if (EfiShellGetAlias(Command
, NULL
) != NULL
&& !Replace
) {
2948 return (EFI_ACCESS_DENIED
);
2951 return (InternalSetAlias(Command
, Alias
, Volatile
));
2954 // Pure FILE_HANDLE operations are passed to FileHandleLib
2955 // these functions are indicated by the *
2956 EFI_SHELL_PROTOCOL mShellProtocol
= {
2962 EfiShellGetHelpText
,
2963 EfiShellGetDevicePathFromMap
,
2964 EfiShellGetMapFromDevicePath
,
2965 EfiShellGetDevicePathFromFilePath
,
2966 EfiShellGetFilePathFromDevicePath
,
2970 EfiShellOpenFileList
,
2971 EfiShellFreeFileList
,
2972 EfiShellRemoveDupInFileList
,
2973 EfiShellBatchIsActive
,
2974 EfiShellIsRootShell
,
2975 EfiShellEnablePageBreak
,
2976 EfiShellDisablePageBreak
,
2977 EfiShellGetPageBreak
,
2978 EfiShellGetDeviceName
,
2979 (EFI_SHELL_GET_FILE_INFO
)FileHandleGetInfo
, //*
2980 (EFI_SHELL_SET_FILE_INFO
)FileHandleSetInfo
, //*
2981 EfiShellOpenFileByName
,
2984 (EFI_SHELL_READ_FILE
)FileHandleRead
, //*
2985 (EFI_SHELL_WRITE_FILE
)FileHandleWrite
, //*
2986 (EFI_SHELL_DELETE_FILE
)FileHandleDelete
, //*
2987 EfiShellDeleteFileByName
,
2988 (EFI_SHELL_GET_FILE_POSITION
)FileHandleGetPosition
, //*
2989 (EFI_SHELL_SET_FILE_POSITION
)FileHandleSetPosition
, //*
2990 (EFI_SHELL_FLUSH_FILE
)FileHandleFlush
, //*
2992 EfiShellFindFilesInDir
,
2993 (EFI_SHELL_GET_FILE_SIZE
)FileHandleGetSize
, //*
2995 EfiShellOpenRootByHandle
,
2997 SHELL_MAJOR_VERSION
,
3002 Function to create and install on the current handle.
3004 Will overwrite any existing ShellProtocols in the system to be sure that
3005 the current shell is in control.
3007 This must be removed via calling CleanUpShellProtocol().
3009 @param[in,out] NewShell The pointer to the pointer to the structure
3012 @retval EFI_SUCCESS The operation was successful.
3013 @return An error from LocateHandle, CreateEvent, or other core function.
3017 CreatePopulateInstallShellProtocol (
3018 IN OUT EFI_SHELL_PROTOCOL
**NewShell
3024 UINTN HandleCounter
;
3025 SHELL_PROTOCOL_HANDLE_LIST
*OldProtocolNode
;
3027 if (NewShell
== NULL
) {
3028 return (EFI_INVALID_PARAMETER
);
3033 OldProtocolNode
= NULL
;
3034 InitializeListHead(&ShellInfoObject
.OldShellList
.Link
);
3037 // Initialize EfiShellProtocol object...
3039 Status
= gBS
->CreateEvent(0,
3043 &mShellProtocol
.ExecutionBreak
);
3044 if (EFI_ERROR(Status
)) {
3049 // Get the size of the buffer we need.
3051 Status
= gBS
->LocateHandle(ByProtocol
,
3052 &gEfiShellProtocolGuid
,
3056 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3058 // Allocate and recall with buffer of correct size
3060 Buffer
= AllocateZeroPool(BufferSize
);
3061 if (Buffer
== NULL
) {
3062 return (EFI_OUT_OF_RESOURCES
);
3064 Status
= gBS
->LocateHandle(ByProtocol
,
3065 &gEfiShellProtocolGuid
,
3069 if (EFI_ERROR(Status
)) {
3074 // now overwrite each of them, but save the info to restore when we end.
3076 for (HandleCounter
= 0 ; HandleCounter
< (BufferSize
/sizeof(EFI_HANDLE
)) ; HandleCounter
++) {
3077 OldProtocolNode
= AllocateZeroPool(sizeof(SHELL_PROTOCOL_HANDLE_LIST
));
3078 ASSERT(OldProtocolNode
!= NULL
);
3079 Status
= gBS
->OpenProtocol(Buffer
[HandleCounter
],
3080 &gEfiShellProtocolGuid
,
3081 (VOID
**) &(OldProtocolNode
->Interface
),
3084 EFI_OPEN_PROTOCOL_GET_PROTOCOL
3086 if (!EFI_ERROR(Status
)) {
3088 // reinstall over the old one...
3090 OldProtocolNode
->Handle
= Buffer
[HandleCounter
];
3091 Status
= gBS
->ReinstallProtocolInterface(
3092 OldProtocolNode
->Handle
,
3093 &gEfiShellProtocolGuid
,
3094 OldProtocolNode
->Interface
,
3095 (VOID
*)(&mShellProtocol
));
3096 if (!EFI_ERROR(Status
)) {
3098 // we reinstalled sucessfully. log this so we can reverse it later.
3102 // add to the list for subsequent...
3104 InsertTailList(&ShellInfoObject
.OldShellList
.Link
, &OldProtocolNode
->Link
);
3109 } else if (Status
== EFI_NOT_FOUND
) {
3110 ASSERT(IsListEmpty(&ShellInfoObject
.OldShellList
.Link
));
3112 // no one else published yet. just publish it ourselves.
3114 Status
= gBS
->InstallProtocolInterface (
3116 &gEfiShellProtocolGuid
,
3117 EFI_NATIVE_INTERFACE
,
3118 (VOID
*)(&mShellProtocol
));
3121 if (PcdGetBool(PcdShellSupportOldProtocols
)){
3122 ///@todo support ShellEnvironment2
3123 ///@todo do we need to support ShellEnvironment (not ShellEnvironment2) also?
3126 if (!EFI_ERROR(Status
)) {
3127 *NewShell
= &mShellProtocol
;
3133 Opposite of CreatePopulateInstallShellProtocol.
3135 Free all memory and restore the system to the state it was in before calling
3136 CreatePopulateInstallShellProtocol.
3138 @param[in,out] NewShell The pointer to the new shell protocol structure.
3140 @retval EFI_SUCCESS The operation was successful.
3144 CleanUpShellProtocol (
3145 IN OUT EFI_SHELL_PROTOCOL
*NewShell
3149 SHELL_PROTOCOL_HANDLE_LIST
*Node2
;
3150 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3153 // if we need to restore old protocols...
3155 if (!IsListEmpty(&ShellInfoObject
.OldShellList
.Link
)) {
3156 for (Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*)GetFirstNode(&ShellInfoObject
.OldShellList
.Link
)
3157 ; !IsListEmpty (&ShellInfoObject
.OldShellList
.Link
)
3158 ; Node2
= (SHELL_PROTOCOL_HANDLE_LIST
*)GetFirstNode(&ShellInfoObject
.OldShellList
.Link
)
3160 RemoveEntryList(&Node2
->Link
);
3161 Status
= gBS
->ReinstallProtocolInterface(Node2
->Handle
,
3162 &gEfiShellProtocolGuid
,
3169 // no need to restore
3171 Status
= gBS
->UninstallProtocolInterface(gImageHandle
,
3172 &gEfiShellProtocolGuid
,
3175 Status
= gBS
->CloseEvent(NewShell
->ExecutionBreak
);
3176 NewShell
->ExecutionBreak
= NULL
;
3178 Status
= gBS
->OpenProtocol(
3179 gST
->ConsoleInHandle
,
3180 &gEfiSimpleTextInputExProtocolGuid
,
3184 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3186 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle1
);
3187 Status
= SimpleEx
->UnregisterKeyNotify(SimpleEx
, ShellInfoObject
.CtrlCNotifyHandle2
);
3193 Notification function for keystrokes.
3195 @param[in] KeyData The key that was pressed.
3197 @retval EFI_SUCCESS The operation was successful.
3201 NotificationFunction(
3202 IN EFI_KEY_DATA
*KeyData
3205 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3206 return (EFI_UNSUPPORTED
);
3208 return (gBS
->SignalEvent(ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
));
3212 Function to start monitoring for CTRL-C using SimpleTextInputEx. This
3213 feature's enabled state was not known when the shell initially launched.
3215 @retval EFI_SUCCESS The feature is enabled.
3216 @retval EFI_OUT_OF_RESOURCES There is not enough mnemory available.
3220 InernalEfiShellStartMonitor(
3224 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL
*SimpleEx
;
3225 EFI_KEY_DATA KeyData
;
3228 Status
= gBS
->OpenProtocol(
3229 gST
->ConsoleInHandle
,
3230 &gEfiSimpleTextInputExProtocolGuid
,
3234 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
3235 if (EFI_ERROR(Status
)) {
3240 STRING_TOKEN (STR_SHELL_NO_IN_EX
),
3241 ShellInfoObject
.HiiHandle
);
3242 return (EFI_SUCCESS
);
3245 if (ShellInfoObject
.NewEfiShellProtocol
->ExecutionBreak
== NULL
) {
3246 return (EFI_UNSUPPORTED
);
3249 KeyData
.KeyState
.KeyToggleState
= 0;
3250 KeyData
.Key
.ScanCode
= 0;
3251 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3252 KeyData
.Key
.UnicodeChar
= L
'c';
3254 Status
= SimpleEx
->RegisterKeyNotify(
3257 NotificationFunction
,
3258 &ShellInfoObject
.CtrlCNotifyHandle1
);
3260 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3261 if (!EFI_ERROR(Status
)) {
3262 Status
= SimpleEx
->RegisterKeyNotify(
3265 NotificationFunction
,
3266 &ShellInfoObject
.CtrlCNotifyHandle2
);
3268 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_LEFT_CONTROL_PRESSED
;
3269 KeyData
.Key
.UnicodeChar
= 3;
3270 if (!EFI_ERROR(Status
)) {
3271 Status
= SimpleEx
->RegisterKeyNotify(
3274 NotificationFunction
,
3275 &ShellInfoObject
.CtrlCNotifyHandle3
);
3277 KeyData
.KeyState
.KeyShiftState
= EFI_SHIFT_STATE_VALID
|EFI_RIGHT_CONTROL_PRESSED
;
3278 if (!EFI_ERROR(Status
)) {
3279 Status
= SimpleEx
->RegisterKeyNotify(
3282 NotificationFunction
,
3283 &ShellInfoObject
.CtrlCNotifyHandle4
);