2 Provides interface to shell functionality for shell commands and applications.
4 Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15 #include "UefiShellLib.h"
16 #include <ShellBase.h>
17 #include <Library/SortLib.h>
18 #include <Library/BaseLib.h>
20 #define FIND_XXXXX_FILE_BUFFER_SIZE (SIZE_OF_EFI_FILE_INFO + MAX_FILE_NAME_LEN)
25 SHELL_PARAM_ITEM EmptyParamList
[] = {
28 SHELL_PARAM_ITEM SfoParamList
[] = {
32 EFI_SHELL_ENVIRONMENT2
*mEfiShellEnvironment2
;
33 EFI_SHELL_INTERFACE
*mEfiShellInterface
;
34 EFI_SHELL_PROTOCOL
*gEfiShellProtocol
;
35 EFI_SHELL_PARAMETERS_PROTOCOL
*gEfiShellParametersProtocol
;
36 EFI_HANDLE mEfiShellEnvironment2Handle
;
37 FILE_HANDLE_FUNCTION_MAP FileFunctionMap
;
40 Check if a Unicode character is a hexadecimal character.
42 This internal function checks if a Unicode character is a
43 numeric character. The valid hexadecimal characters are
44 L'0' to L'9', L'a' to L'f', or L'A' to L'F'.
46 @param Char The character to check against.
48 @retval TRUE If the Char is a hexadecmial character.
49 @retval FALSE If the Char is not a hexadecmial character.
54 ShellIsHexaDecimalDigitCharacter (
58 return (BOOLEAN
) ((Char
>= L
'0' && Char
<= L
'9') || (Char
>= L
'A' && Char
<= L
'F') || (Char
>= L
'a' && Char
<= L
'f'));
62 Check if a Unicode character is a decimal character.
64 This internal function checks if a Unicode character is a
65 decimal character. The valid characters are
69 @param Char The character to check against.
71 @retval TRUE If the Char is a hexadecmial character.
72 @retval FALSE If the Char is not a hexadecmial character.
77 ShellIsDecimalDigitCharacter (
81 return (BOOLEAN
) (Char
>= L
'0' && Char
<= L
'9');
85 Helper function to find ShellEnvironment2 for constructor.
87 @param[in] ImageHandle A copy of the calling image's handle.
89 @retval EFI_OUT_OF_RESOURCES Memory allocation failed.
94 IN EFI_HANDLE ImageHandle
104 Status
= gBS
->OpenProtocol(ImageHandle
,
105 &gEfiShellEnvironment2Guid
,
106 (VOID
**)&mEfiShellEnvironment2
,
109 EFI_OPEN_PROTOCOL_GET_PROTOCOL
112 // look for the mEfiShellEnvironment2 protocol at a higher level
114 if (EFI_ERROR (Status
) || !(CompareGuid (&mEfiShellEnvironment2
->SESGuid
, &gEfiShellEnvironment2ExtGuid
))){
116 // figure out how big of a buffer we need.
118 Status
= gBS
->LocateHandle (ByProtocol
,
119 &gEfiShellEnvironment2Guid
,
120 NULL
, // ignored for ByProtocol
125 // maybe it's not there???
127 if (Status
== EFI_BUFFER_TOO_SMALL
) {
128 Buffer
= (EFI_HANDLE
*)AllocateZeroPool(BufferSize
);
129 if (Buffer
== NULL
) {
130 return (EFI_OUT_OF_RESOURCES
);
132 Status
= gBS
->LocateHandle (ByProtocol
,
133 &gEfiShellEnvironment2Guid
,
134 NULL
, // ignored for ByProtocol
139 if (!EFI_ERROR (Status
) && Buffer
!= NULL
) {
141 // now parse the list of returned handles
143 Status
= EFI_NOT_FOUND
;
144 for (HandleIndex
= 0; HandleIndex
< (BufferSize
/sizeof(Buffer
[0])); HandleIndex
++) {
145 Status
= gBS
->OpenProtocol(Buffer
[HandleIndex
],
146 &gEfiShellEnvironment2Guid
,
147 (VOID
**)&mEfiShellEnvironment2
,
150 EFI_OPEN_PROTOCOL_GET_PROTOCOL
152 if (CompareGuid (&mEfiShellEnvironment2
->SESGuid
, &gEfiShellEnvironment2ExtGuid
)) {
153 mEfiShellEnvironment2Handle
= Buffer
[HandleIndex
];
154 Status
= EFI_SUCCESS
;
160 if (Buffer
!= NULL
) {
167 Function to do most of the work of the constructor. Allows for calling
168 multiple times without complete re-initialization.
170 @param[in] ImageHandle A copy of the ImageHandle.
171 @param[in] SystemTable A pointer to the SystemTable for the application.
173 @retval EFI_SUCCESS The operationw as successful.
177 ShellLibConstructorWorker (
178 IN EFI_HANDLE ImageHandle
,
179 IN EFI_SYSTEM_TABLE
*SystemTable
185 // UEFI 2.0 shell interfaces (used preferentially)
187 Status
= gBS
->OpenProtocol(
189 &gEfiShellProtocolGuid
,
190 (VOID
**)&gEfiShellProtocol
,
193 EFI_OPEN_PROTOCOL_GET_PROTOCOL
195 if (EFI_ERROR(Status
)) {
197 // Search for the shell protocol
199 Status
= gBS
->LocateProtocol(
200 &gEfiShellProtocolGuid
,
202 (VOID
**)&gEfiShellProtocol
204 if (EFI_ERROR(Status
)) {
205 gEfiShellProtocol
= NULL
;
208 Status
= gBS
->OpenProtocol(
210 &gEfiShellParametersProtocolGuid
,
211 (VOID
**)&gEfiShellParametersProtocol
,
214 EFI_OPEN_PROTOCOL_GET_PROTOCOL
216 if (EFI_ERROR(Status
)) {
217 gEfiShellParametersProtocol
= NULL
;
220 if (gEfiShellParametersProtocol
== NULL
|| gEfiShellProtocol
== NULL
) {
222 // Moved to seperate function due to complexity
224 Status
= ShellFindSE2(ImageHandle
);
226 if (EFI_ERROR(Status
)) {
227 DEBUG((DEBUG_ERROR
, "Status: 0x%08x\r\n", Status
));
228 mEfiShellEnvironment2
= NULL
;
230 Status
= gBS
->OpenProtocol(ImageHandle
,
231 &gEfiShellInterfaceGuid
,
232 (VOID
**)&mEfiShellInterface
,
235 EFI_OPEN_PROTOCOL_GET_PROTOCOL
237 if (EFI_ERROR(Status
)) {
238 mEfiShellInterface
= NULL
;
243 // only success getting 2 of either the old or new, but no 1/2 and 1/2
245 if ((mEfiShellEnvironment2
!= NULL
&& mEfiShellInterface
!= NULL
) ||
246 (gEfiShellProtocol
!= NULL
&& gEfiShellParametersProtocol
!= NULL
) ) {
247 if (gEfiShellProtocol
!= NULL
) {
248 FileFunctionMap
.GetFileInfo
= gEfiShellProtocol
->GetFileInfo
;
249 FileFunctionMap
.SetFileInfo
= gEfiShellProtocol
->SetFileInfo
;
250 FileFunctionMap
.ReadFile
= gEfiShellProtocol
->ReadFile
;
251 FileFunctionMap
.WriteFile
= gEfiShellProtocol
->WriteFile
;
252 FileFunctionMap
.CloseFile
= gEfiShellProtocol
->CloseFile
;
253 FileFunctionMap
.DeleteFile
= gEfiShellProtocol
->DeleteFile
;
254 FileFunctionMap
.GetFilePosition
= gEfiShellProtocol
->GetFilePosition
;
255 FileFunctionMap
.SetFilePosition
= gEfiShellProtocol
->SetFilePosition
;
256 FileFunctionMap
.FlushFile
= gEfiShellProtocol
->FlushFile
;
257 FileFunctionMap
.GetFileSize
= gEfiShellProtocol
->GetFileSize
;
259 FileFunctionMap
.GetFileInfo
= (EFI_SHELL_GET_FILE_INFO
)FileHandleGetInfo
;
260 FileFunctionMap
.SetFileInfo
= (EFI_SHELL_SET_FILE_INFO
)FileHandleSetInfo
;
261 FileFunctionMap
.ReadFile
= (EFI_SHELL_READ_FILE
)FileHandleRead
;
262 FileFunctionMap
.WriteFile
= (EFI_SHELL_WRITE_FILE
)FileHandleWrite
;
263 FileFunctionMap
.CloseFile
= (EFI_SHELL_CLOSE_FILE
)FileHandleClose
;
264 FileFunctionMap
.DeleteFile
= (EFI_SHELL_DELETE_FILE
)FileHandleDelete
;
265 FileFunctionMap
.GetFilePosition
= (EFI_SHELL_GET_FILE_POSITION
)FileHandleGetPosition
;
266 FileFunctionMap
.SetFilePosition
= (EFI_SHELL_SET_FILE_POSITION
)FileHandleSetPosition
;
267 FileFunctionMap
.FlushFile
= (EFI_SHELL_FLUSH_FILE
)FileHandleFlush
;
268 FileFunctionMap
.GetFileSize
= (EFI_SHELL_GET_FILE_SIZE
)FileHandleGetSize
;
270 return (EFI_SUCCESS
);
272 return (EFI_NOT_FOUND
);
275 Constructor for the Shell library.
277 Initialize the library and determine if the underlying is a UEFI Shell 2.0 or an EFI shell.
279 @param ImageHandle the image handle of the process
280 @param SystemTable the EFI System Table pointer
282 @retval EFI_SUCCESS the initialization was complete sucessfully
283 @return others an error ocurred during initialization
287 ShellLibConstructor (
288 IN EFI_HANDLE ImageHandle
,
289 IN EFI_SYSTEM_TABLE
*SystemTable
292 mEfiShellEnvironment2
= NULL
;
293 gEfiShellProtocol
= NULL
;
294 gEfiShellParametersProtocol
= NULL
;
295 mEfiShellInterface
= NULL
;
296 mEfiShellEnvironment2Handle
= NULL
;
299 // verify that auto initialize is not set false
301 if (PcdGetBool(PcdShellLibAutoInitialize
) == 0) {
302 return (EFI_SUCCESS
);
305 return (ShellLibConstructorWorker(ImageHandle
, SystemTable
));
309 Destructor for the library. free any resources.
311 @param[in] ImageHandle A copy of the ImageHandle.
312 @param[in] SystemTable A pointer to the SystemTable for the application.
314 @retval EFI_SUCCESS The operation was successful.
315 @return An error from the CloseProtocol function.
320 IN EFI_HANDLE ImageHandle
,
321 IN EFI_SYSTEM_TABLE
*SystemTable
324 if (mEfiShellEnvironment2
!= NULL
) {
325 gBS
->CloseProtocol(mEfiShellEnvironment2Handle
==NULL
?ImageHandle
:mEfiShellEnvironment2Handle
,
326 &gEfiShellEnvironment2Guid
,
329 mEfiShellEnvironment2
= NULL
;
331 if (mEfiShellInterface
!= NULL
) {
332 gBS
->CloseProtocol(ImageHandle
,
333 &gEfiShellInterfaceGuid
,
336 mEfiShellInterface
= NULL
;
338 if (gEfiShellProtocol
!= NULL
) {
339 gBS
->CloseProtocol(ImageHandle
,
340 &gEfiShellProtocolGuid
,
343 gEfiShellProtocol
= NULL
;
345 if (gEfiShellParametersProtocol
!= NULL
) {
346 gBS
->CloseProtocol(ImageHandle
,
347 &gEfiShellParametersProtocolGuid
,
350 gEfiShellParametersProtocol
= NULL
;
352 mEfiShellEnvironment2Handle
= NULL
;
354 return (EFI_SUCCESS
);
358 This function causes the shell library to initialize itself. If the shell library
359 is already initialized it will de-initialize all the current protocol poitners and
360 re-populate them again.
362 When the library is used with PcdShellLibAutoInitialize set to true this function
363 will return EFI_SUCCESS and perform no actions.
365 This function is intended for internal access for shell commands only.
367 @retval EFI_SUCCESS the initialization was complete sucessfully
376 // if auto initialize is not false then skip
378 if (PcdGetBool(PcdShellLibAutoInitialize
) != 0) {
379 return (EFI_SUCCESS
);
383 // deinit the current stuff
385 ASSERT_EFI_ERROR(ShellLibDestructor(gImageHandle
, gST
));
388 // init the new stuff
390 return (ShellLibConstructorWorker(gImageHandle
, gST
));
394 This function will retrieve the information about the file for the handle
395 specified and store it in allocated pool memory.
397 This function allocates a buffer to store the file's information. It is the
398 caller's responsibility to free the buffer
400 @param FileHandle The file handle of the file for which information is
403 @retval NULL information could not be retrieved.
405 @return the information about the file
410 IN SHELL_FILE_HANDLE FileHandle
413 return (FileFunctionMap
.GetFileInfo(FileHandle
));
417 This function sets the information about the file for the opened handle
420 @param[in] FileHandle The file handle of the file for which information
423 @param[in] FileInfo The information to set.
425 @retval EFI_SUCCESS The information was set.
426 @retval EFI_INVALID_PARAMETER A parameter was out of range or invalid.
427 @retval EFI_UNSUPPORTED The FileHandle does not support FileInfo.
428 @retval EFI_NO_MEDIA The device has no medium.
429 @retval EFI_DEVICE_ERROR The device reported an error.
430 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
431 @retval EFI_WRITE_PROTECTED The file or medium is write protected.
432 @retval EFI_ACCESS_DENIED The file was opened read only.
433 @retval EFI_VOLUME_FULL The volume is full.
438 IN SHELL_FILE_HANDLE FileHandle
,
439 IN EFI_FILE_INFO
*FileInfo
442 return (FileFunctionMap
.SetFileInfo(FileHandle
, FileInfo
));
446 This function will open a file or directory referenced by DevicePath.
448 This function opens a file with the open mode according to the file path. The
449 Attributes is valid only for EFI_FILE_MODE_CREATE.
451 @param FilePath on input the device path to the file. On output
452 the remaining device path.
453 @param DeviceHandle pointer to the system device handle.
454 @param FileHandle pointer to the file handle.
455 @param OpenMode the mode to open the file with.
456 @param Attributes the file's file attributes.
458 @retval EFI_SUCCESS The information was set.
459 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
460 @retval EFI_UNSUPPORTED Could not open the file path.
461 @retval EFI_NOT_FOUND The specified file could not be found on the
462 device or the file system could not be found on
464 @retval EFI_NO_MEDIA The device has no medium.
465 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the
466 medium is no longer supported.
467 @retval EFI_DEVICE_ERROR The device reported an error.
468 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
469 @retval EFI_WRITE_PROTECTED The file or medium is write protected.
470 @retval EFI_ACCESS_DENIED The file was opened read only.
471 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the
473 @retval EFI_VOLUME_FULL The volume is full.
477 ShellOpenFileByDevicePath(
478 IN OUT EFI_DEVICE_PATH_PROTOCOL
**FilePath
,
479 OUT EFI_HANDLE
*DeviceHandle
,
480 OUT SHELL_FILE_HANDLE
*FileHandle
,
487 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
*EfiSimpleFileSystemProtocol
;
488 EFI_FILE_PROTOCOL
*Handle1
;
489 EFI_FILE_PROTOCOL
*Handle2
;
490 CHAR16
*FnafPathName
;
493 if (FilePath
== NULL
|| FileHandle
== NULL
|| DeviceHandle
== NULL
) {
494 return (EFI_INVALID_PARAMETER
);
498 // which shell interface should we use
500 if (gEfiShellProtocol
!= NULL
) {
502 // use UEFI Shell 2.0 method.
504 FileName
= gEfiShellProtocol
->GetFilePathFromDevicePath(*FilePath
);
505 if (FileName
== NULL
) {
506 return (EFI_INVALID_PARAMETER
);
508 Status
= ShellOpenFileByName(FileName
, FileHandle
, OpenMode
, Attributes
);
515 // use old shell method.
517 Status
= gBS
->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid
,
520 if (EFI_ERROR (Status
)) {
523 Status
= gBS
->OpenProtocol(*DeviceHandle
,
524 &gEfiSimpleFileSystemProtocolGuid
,
525 (VOID
**)&EfiSimpleFileSystemProtocol
,
528 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
529 if (EFI_ERROR (Status
)) {
532 Status
= EfiSimpleFileSystemProtocol
->OpenVolume(EfiSimpleFileSystemProtocol
, &Handle1
);
533 if (EFI_ERROR (Status
)) {
539 // go down directories one node at a time.
541 while (!IsDevicePathEnd (*FilePath
)) {
543 // For file system access each node should be a file path component
545 if (DevicePathType (*FilePath
) != MEDIA_DEVICE_PATH
||
546 DevicePathSubType (*FilePath
) != MEDIA_FILEPATH_DP
549 return (EFI_INVALID_PARAMETER
);
552 // Open this file path node
558 // File Name Alignment Fix (FNAF)
559 // Handle2->Open may be incapable of handling a unaligned CHAR16 data.
560 // The structure pointed to by FilePath may be not CHAR16 aligned.
561 // This code copies the potentially unaligned PathName data from the
562 // FilePath structure to the aligned FnafPathName for use in the
563 // calls to Handl2->Open.
567 // Determine length of PathName, in bytes.
569 PathLen
= DevicePathNodeLength (*FilePath
) - SIZE_OF_FILEPATH_DEVICE_PATH
;
572 // Allocate memory for the aligned copy of the string Extra allocation is to allow for forced alignment
573 // Copy bytes from possibly unaligned location to aligned location
575 FnafPathName
= AllocateCopyPool(PathLen
, (UINT8
*)((FILEPATH_DEVICE_PATH
*)*FilePath
)->PathName
);
576 if (FnafPathName
== NULL
) {
577 return EFI_OUT_OF_RESOURCES
;
581 // Try to test opening an existing file
583 Status
= Handle2
->Open (
587 OpenMode
&~EFI_FILE_MODE_CREATE
,
592 // see if the error was that it needs to be created
594 if ((EFI_ERROR (Status
)) && (OpenMode
!= (OpenMode
&~EFI_FILE_MODE_CREATE
))) {
595 Status
= Handle2
->Open (
605 // Free the alignment buffer
607 FreePool(FnafPathName
);
610 // Close the last node
612 Handle2
->Close (Handle2
);
614 if (EFI_ERROR(Status
)) {
621 *FilePath
= NextDevicePathNode (*FilePath
);
625 // This is a weak spot since if the undefined SHELL_FILE_HANDLE format changes this must change also!
627 *FileHandle
= (VOID
*)Handle1
;
628 return (EFI_SUCCESS
);
632 This function will open a file or directory referenced by filename.
634 If return is EFI_SUCCESS, the Filehandle is the opened file's handle;
635 otherwise, the Filehandle is NULL. The Attributes is valid only for
636 EFI_FILE_MODE_CREATE.
638 if FileName is NULL then ASSERT()
640 @param FileName pointer to file name
641 @param FileHandle pointer to the file handle.
642 @param OpenMode the mode to open the file with.
643 @param Attributes the file's file attributes.
645 @retval EFI_SUCCESS The information was set.
646 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
647 @retval EFI_UNSUPPORTED Could not open the file path.
648 @retval EFI_NOT_FOUND The specified file could not be found on the
649 device or the file system could not be found
651 @retval EFI_NO_MEDIA The device has no medium.
652 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the
653 medium is no longer supported.
654 @retval EFI_DEVICE_ERROR The device reported an error.
655 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
656 @retval EFI_WRITE_PROTECTED The file or medium is write protected.
657 @retval EFI_ACCESS_DENIED The file was opened read only.
658 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the
660 @retval EFI_VOLUME_FULL The volume is full.
665 IN CONST CHAR16
*FileName
,
666 OUT SHELL_FILE_HANDLE
*FileHandle
,
671 EFI_HANDLE DeviceHandle
;
672 EFI_DEVICE_PATH_PROTOCOL
*FilePath
;
674 EFI_FILE_INFO
*FileInfo
;
675 CHAR16
*FileNameCopy
;
678 // ASSERT if FileName is NULL
680 ASSERT(FileName
!= NULL
);
682 if (FileName
== NULL
) {
683 return (EFI_INVALID_PARAMETER
);
686 if (gEfiShellProtocol
!= NULL
) {
687 if ((OpenMode
& EFI_FILE_MODE_CREATE
) == EFI_FILE_MODE_CREATE
) {
690 // Create only a directory
692 if ((Attributes
& EFI_FILE_DIRECTORY
) == EFI_FILE_DIRECTORY
) {
693 return ShellCreateDirectory(FileName
, FileHandle
);
697 // Create the directory to create the file in
699 FileNameCopy
= AllocateCopyPool (StrSize (FileName
), FileName
);
700 if (FileName
== NULL
) {
701 return (EFI_OUT_OF_RESOURCES
);
703 PathCleanUpDirectories (FileNameCopy
);
704 if (PathRemoveLastItem (FileNameCopy
)) {
705 if (!EFI_ERROR(ShellCreateDirectory (FileNameCopy
, FileHandle
))) {
706 ShellCloseFile (FileHandle
);
709 SHELL_FREE_NON_NULL (FileNameCopy
);
713 // Use UEFI Shell 2.0 method to create the file
715 Status
= gEfiShellProtocol
->OpenFileByName(FileName
,
718 if (StrCmp(FileName
, L
"NUL") != 0 && !EFI_ERROR(Status
) && ((OpenMode
& EFI_FILE_MODE_CREATE
) != 0)){
719 FileInfo
= FileFunctionMap
.GetFileInfo(*FileHandle
);
720 ASSERT(FileInfo
!= NULL
);
721 FileInfo
->Attribute
= Attributes
;
722 Status
= FileFunctionMap
.SetFileInfo(*FileHandle
, FileInfo
);
728 // Using EFI Shell version
729 // this means convert name to path and call that function
730 // since this will use EFI method again that will open it.
732 ASSERT(mEfiShellEnvironment2
!= NULL
);
733 FilePath
= mEfiShellEnvironment2
->NameToPath ((CHAR16
*)FileName
);
734 if (FilePath
!= NULL
) {
735 return (ShellOpenFileByDevicePath(&FilePath
,
741 return (EFI_DEVICE_ERROR
);
744 This function create a directory
746 If return is EFI_SUCCESS, the Filehandle is the opened directory's handle;
747 otherwise, the Filehandle is NULL. If the directory already existed, this
748 function opens the existing directory.
750 @param DirectoryName pointer to directory name
751 @param FileHandle pointer to the file handle.
753 @retval EFI_SUCCESS The information was set.
754 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
755 @retval EFI_UNSUPPORTED Could not open the file path.
756 @retval EFI_NOT_FOUND The specified file could not be found on the
757 device or the file system could not be found
759 @retval EFI_NO_MEDIA The device has no medium.
760 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the
761 medium is no longer supported.
762 @retval EFI_DEVICE_ERROR The device reported an error.
763 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
764 @retval EFI_WRITE_PROTECTED The file or medium is write protected.
765 @retval EFI_ACCESS_DENIED The file was opened read only.
766 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the
768 @retval EFI_VOLUME_FULL The volume is full.
769 @sa ShellOpenFileByName
773 ShellCreateDirectory(
774 IN CONST CHAR16
*DirectoryName
,
775 OUT SHELL_FILE_HANDLE
*FileHandle
778 if (gEfiShellProtocol
!= NULL
) {
780 // Use UEFI Shell 2.0 method
782 return (gEfiShellProtocol
->CreateFile(DirectoryName
,
787 return (ShellOpenFileByName(DirectoryName
,
789 EFI_FILE_MODE_READ
| EFI_FILE_MODE_WRITE
| EFI_FILE_MODE_CREATE
,
796 This function reads information from an opened file.
798 If FileHandle is not a directory, the function reads the requested number of
799 bytes from the file at the file's current position and returns them in Buffer.
800 If the read goes beyond the end of the file, the read length is truncated to the
801 end of the file. The file's current position is increased by the number of bytes
802 returned. If FileHandle is a directory, the function reads the directory entry
803 at the file's current position and returns the entry in Buffer. If the Buffer
804 is not large enough to hold the current directory entry, then
805 EFI_BUFFER_TOO_SMALL is returned and the current file position is not updated.
806 BufferSize is set to be the size of the buffer needed to read the entry. On
807 success, the current position is updated to the next directory entry. If there
808 are no more directory entries, the read returns a zero-length buffer.
809 EFI_FILE_INFO is the structure returned as the directory entry.
811 @param FileHandle the opened file handle
812 @param BufferSize on input the size of buffer in bytes. on return
813 the number of bytes written.
814 @param Buffer the buffer to put read data into.
816 @retval EFI_SUCCESS Data was read.
817 @retval EFI_NO_MEDIA The device has no media.
818 @retval EFI_DEVICE_ERROR The device reported an error.
819 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
820 @retval EFI_BUFFER_TO_SMALL Buffer is too small. ReadSize contains required
827 IN SHELL_FILE_HANDLE FileHandle
,
828 IN OUT UINTN
*BufferSize
,
832 return (FileFunctionMap
.ReadFile(FileHandle
, BufferSize
, Buffer
));
837 Write data to a file.
839 This function writes the specified number of bytes to the file at the current
840 file position. The current file position is advanced the actual number of bytes
841 written, which is returned in BufferSize. Partial writes only occur when there
842 has been a data error during the write attempt (such as "volume space full").
843 The file is automatically grown to hold the data if required. Direct writes to
844 opened directories are not supported.
846 @param FileHandle The opened file for writing
847 @param BufferSize on input the number of bytes in Buffer. On output
848 the number of bytes written.
849 @param Buffer the buffer containing data to write is stored.
851 @retval EFI_SUCCESS Data was written.
852 @retval EFI_UNSUPPORTED Writes to an open directory are not supported.
853 @retval EFI_NO_MEDIA The device has no media.
854 @retval EFI_DEVICE_ERROR The device reported an error.
855 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
856 @retval EFI_WRITE_PROTECTED The device is write-protected.
857 @retval EFI_ACCESS_DENIED The file was open for read only.
858 @retval EFI_VOLUME_FULL The volume is full.
863 IN SHELL_FILE_HANDLE FileHandle
,
864 IN OUT UINTN
*BufferSize
,
868 return (FileFunctionMap
.WriteFile(FileHandle
, BufferSize
, Buffer
));
872 Close an open file handle.
874 This function closes a specified file handle. All "dirty" cached file data is
875 flushed to the device, and the file is closed. In all cases the handle is
878 @param FileHandle the file handle to close.
880 @retval EFI_SUCCESS the file handle was closed sucessfully.
885 IN SHELL_FILE_HANDLE
*FileHandle
888 return (FileFunctionMap
.CloseFile(*FileHandle
));
892 Delete a file and close the handle
894 This function closes and deletes a file. In all cases the file handle is closed.
895 If the file cannot be deleted, the warning code EFI_WARN_DELETE_FAILURE is
896 returned, but the handle is still closed.
898 @param FileHandle the file handle to delete
900 @retval EFI_SUCCESS the file was closed sucessfully
901 @retval EFI_WARN_DELETE_FAILURE the handle was closed, but the file was not
903 @retval INVALID_PARAMETER One of the parameters has an invalid value.
908 IN SHELL_FILE_HANDLE
*FileHandle
911 return (FileFunctionMap
.DeleteFile(*FileHandle
));
915 Set the current position in a file.
917 This function sets the current file position for the handle to the position
918 supplied. With the exception of seeking to position 0xFFFFFFFFFFFFFFFF, only
919 absolute positioning is supported, and seeking past the end of the file is
920 allowed (a subsequent write would grow the file). Seeking to position
921 0xFFFFFFFFFFFFFFFF causes the current position to be set to the end of the file.
922 If FileHandle is a directory, the only position that may be set is zero. This
923 has the effect of starting the read process of the directory entries over.
925 @param FileHandle The file handle on which the position is being set
926 @param Position Byte position from begining of file
928 @retval EFI_SUCCESS Operation completed sucessfully.
929 @retval EFI_UNSUPPORTED the seek request for non-zero is not valid on
931 @retval INVALID_PARAMETER One of the parameters has an invalid value.
935 ShellSetFilePosition (
936 IN SHELL_FILE_HANDLE FileHandle
,
940 return (FileFunctionMap
.SetFilePosition(FileHandle
, Position
));
944 Gets a file's current position
946 This function retrieves the current file position for the file handle. For
947 directories, the current file position has no meaning outside of the file
948 system driver and as such the operation is not supported. An error is returned
949 if FileHandle is a directory.
951 @param FileHandle The open file handle on which to get the position.
952 @param Position Byte position from begining of file.
954 @retval EFI_SUCCESS the operation completed sucessfully.
955 @retval INVALID_PARAMETER One of the parameters has an invalid value.
956 @retval EFI_UNSUPPORTED the request is not valid on directories.
960 ShellGetFilePosition (
961 IN SHELL_FILE_HANDLE FileHandle
,
965 return (FileFunctionMap
.GetFilePosition(FileHandle
, Position
));
968 Flushes data on a file
970 This function flushes all modified data associated with a file to a device.
972 @param FileHandle The file handle on which to flush data
974 @retval EFI_SUCCESS The data was flushed.
975 @retval EFI_NO_MEDIA The device has no media.
976 @retval EFI_DEVICE_ERROR The device reported an error.
977 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
978 @retval EFI_WRITE_PROTECTED The file or medium is write protected.
979 @retval EFI_ACCESS_DENIED The file was opened for read only.
984 IN SHELL_FILE_HANDLE FileHandle
987 return (FileFunctionMap
.FlushFile(FileHandle
));
990 /** Retrieve first entry from a directory.
992 This function takes an open directory handle and gets information from the
993 first entry in the directory. A buffer is allocated to contain
994 the information and a pointer to the buffer is returned in *Buffer. The
995 caller can use ShellFindNextFile() to get subsequent directory entries.
997 The buffer will be freed by ShellFindNextFile() when the last directory
998 entry is read. Otherwise, the caller must free the buffer, using FreePool,
999 when finished with it.
1001 @param[in] DirHandle The file handle of the directory to search.
1002 @param[out] Buffer The pointer to the buffer for the file's information.
1004 @retval EFI_SUCCESS Found the first file.
1005 @retval EFI_NOT_FOUND Cannot find the directory.
1006 @retval EFI_NO_MEDIA The device has no media.
1007 @retval EFI_DEVICE_ERROR The device reported an error.
1008 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1009 @return Others status of ShellGetFileInfo, ShellSetFilePosition,
1014 ShellFindFirstFile (
1015 IN SHELL_FILE_HANDLE DirHandle
,
1016 OUT EFI_FILE_INFO
**Buffer
1020 // pass to file handle lib
1022 return (FileHandleFindFirstFile(DirHandle
, Buffer
));
1024 /** Retrieve next entries from a directory.
1026 To use this function, the caller must first call the ShellFindFirstFile()
1027 function to get the first directory entry. Subsequent directory entries are
1028 retrieved by using the ShellFindNextFile() function. This function can
1029 be called several times to get each entry from the directory. If the call of
1030 ShellFindNextFile() retrieved the last directory entry, the next call of
1031 this function will set *NoFile to TRUE and free the buffer.
1033 @param[in] DirHandle The file handle of the directory.
1034 @param[out] Buffer The pointer to buffer for file's information.
1035 @param[out] NoFile The pointer to boolean when last file is found.
1037 @retval EFI_SUCCESS Found the next file, or reached last file
1038 @retval EFI_NO_MEDIA The device has no media.
1039 @retval EFI_DEVICE_ERROR The device reported an error.
1040 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
1045 IN SHELL_FILE_HANDLE DirHandle
,
1046 OUT EFI_FILE_INFO
*Buffer
,
1051 // pass to file handle lib
1053 return (FileHandleFindNextFile(DirHandle
, Buffer
, NoFile
));
1056 Retrieve the size of a file.
1058 if FileHandle is NULL then ASSERT()
1059 if Size is NULL then ASSERT()
1061 This function extracts the file size info from the FileHandle's EFI_FILE_INFO
1064 @param FileHandle file handle from which size is retrieved
1065 @param Size pointer to size
1067 @retval EFI_SUCCESS operation was completed sucessfully
1068 @retval EFI_DEVICE_ERROR cannot access the file
1073 IN SHELL_FILE_HANDLE FileHandle
,
1077 return (FileFunctionMap
.GetFileSize(FileHandle
, Size
));
1080 Retrieves the status of the break execution flag
1082 this function is useful to check whether the application is being asked to halt by the shell.
1084 @retval TRUE the execution break is enabled
1085 @retval FALSE the execution break is not enabled
1089 ShellGetExecutionBreakFlag(
1094 // Check for UEFI Shell 2.0 protocols
1096 if (gEfiShellProtocol
!= NULL
) {
1099 // We are using UEFI Shell 2.0; see if the event has been triggered
1101 if (gBS
->CheckEvent(gEfiShellProtocol
->ExecutionBreak
) != EFI_SUCCESS
) {
1108 // using EFI Shell; call the function to check
1110 if (mEfiShellEnvironment2
!= NULL
) {
1111 return (mEfiShellEnvironment2
->GetExecutionBreak());
1117 return the value of an environment variable
1119 this function gets the value of the environment variable set by the
1120 ShellSetEnvironmentVariable function
1122 @param EnvKey The key name of the environment variable.
1124 @retval NULL the named environment variable does not exist.
1125 @return != NULL pointer to the value of the environment variable
1129 ShellGetEnvironmentVariable (
1130 IN CONST CHAR16
*EnvKey
1134 // Check for UEFI Shell 2.0 protocols
1136 if (gEfiShellProtocol
!= NULL
) {
1137 return (gEfiShellProtocol
->GetEnv(EnvKey
));
1141 // Check for EFI shell
1143 if (mEfiShellEnvironment2
!= NULL
) {
1144 return (mEfiShellEnvironment2
->GetEnv((CHAR16
*)EnvKey
));
1150 set the value of an environment variable
1152 This function changes the current value of the specified environment variable. If the
1153 environment variable exists and the Value is an empty string, then the environment
1154 variable is deleted. If the environment variable exists and the Value is not an empty
1155 string, then the value of the environment variable is changed. If the environment
1156 variable does not exist and the Value is an empty string, there is no action. If the
1157 environment variable does not exist and the Value is a non-empty string, then the
1158 environment variable is created and assigned the specified value.
1160 This is not supported pre-UEFI Shell 2.0.
1162 @param EnvKey The key name of the environment variable.
1163 @param EnvVal The Value of the environment variable
1164 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
1166 @retval EFI_SUCCESS the operation was completed sucessfully
1167 @retval EFI_UNSUPPORTED This operation is not allowed in pre UEFI 2.0 Shell environments
1171 ShellSetEnvironmentVariable (
1172 IN CONST CHAR16
*EnvKey
,
1173 IN CONST CHAR16
*EnvVal
,
1178 // Check for UEFI Shell 2.0 protocols
1180 if (gEfiShellProtocol
!= NULL
) {
1181 return (gEfiShellProtocol
->SetEnv(EnvKey
, EnvVal
, Volatile
));
1185 // This feature does not exist under EFI shell
1187 return (EFI_UNSUPPORTED
);
1191 Cause the shell to parse and execute a command line.
1193 This function creates a nested instance of the shell and executes the specified
1194 command (CommandLine) with the specified environment (Environment). Upon return,
1195 the status code returned by the specified command is placed in StatusCode.
1196 If Environment is NULL, then the current environment is used and all changes made
1197 by the commands executed will be reflected in the current environment. If the
1198 Environment is non-NULL, then the changes made will be discarded.
1199 The CommandLine is executed from the current working directory on the current
1202 The EnvironmentVariables pararemeter is ignored in a pre-UEFI Shell 2.0
1203 environment. The values pointed to by the parameters will be unchanged by the
1204 ShellExecute() function. The Output parameter has no effect in a
1205 UEFI Shell 2.0 environment.
1207 @param[in] ParentHandle The parent image starting the operation.
1208 @param[in] CommandLine The pointer to a NULL terminated command line.
1209 @param[in] Output True to display debug output. False to hide it.
1210 @param[in] EnvironmentVariables Optional pointer to array of environment variables
1211 in the form "x=y". If NULL, the current set is used.
1212 @param[out] Status The status of the run command line.
1214 @retval EFI_SUCCESS The operation completed sucessfully. Status
1215 contains the status code returned.
1216 @retval EFI_INVALID_PARAMETER A parameter contains an invalid value.
1217 @retval EFI_OUT_OF_RESOURCES Out of resources.
1218 @retval EFI_UNSUPPORTED The operation is not allowed.
1223 IN EFI_HANDLE
*ParentHandle
,
1224 IN CHAR16
*CommandLine OPTIONAL
,
1225 IN BOOLEAN Output OPTIONAL
,
1226 IN CHAR16
**EnvironmentVariables OPTIONAL
,
1227 OUT EFI_STATUS
*Status OPTIONAL
1230 EFI_STATUS CmdStatus
;
1232 // Check for UEFI Shell 2.0 protocols
1234 if (gEfiShellProtocol
!= NULL
) {
1236 // Call UEFI Shell 2.0 version (not using Output parameter)
1238 return (gEfiShellProtocol
->Execute(ParentHandle
,
1240 EnvironmentVariables
,
1245 // Check for EFI shell
1247 if (mEfiShellEnvironment2
!= NULL
) {
1249 // Call EFI Shell version.
1250 // Due to oddity in the EFI shell we want to dereference the ParentHandle here
1252 CmdStatus
= (mEfiShellEnvironment2
->Execute(*ParentHandle
,
1256 // No Status output parameter so just use the returned status
1258 if (Status
!= NULL
) {
1259 *Status
= CmdStatus
;
1262 // If there was an error, we can't tell if it was from the command or from
1263 // the Execute() function, so we'll just assume the shell ran successfully
1264 // and the error came from the command.
1269 return (EFI_UNSUPPORTED
);
1273 Retreives the current directory path
1275 If the DeviceName is NULL, it returns the current device's current directory
1276 name. If the DeviceName is not NULL, it returns the current directory name
1279 Note that the current directory string should exclude the tailing backslash character.
1281 @param DeviceName the name of the drive to get directory on
1283 @retval NULL the directory does not exist
1284 @return != NULL the directory
1288 ShellGetCurrentDir (
1289 IN CHAR16
* CONST DeviceName OPTIONAL
1293 // Check for UEFI Shell 2.0 protocols
1295 if (gEfiShellProtocol
!= NULL
) {
1296 return (gEfiShellProtocol
->GetCurDir(DeviceName
));
1300 // Check for EFI shell
1302 if (mEfiShellEnvironment2
!= NULL
) {
1303 return (mEfiShellEnvironment2
->CurDir(DeviceName
));
1309 sets (enabled or disabled) the page break mode
1311 when page break mode is enabled the screen will stop scrolling
1312 and wait for operator input before scrolling a subsequent screen.
1314 @param CurrentState TRUE to enable and FALSE to disable
1318 ShellSetPageBreakMode (
1319 IN BOOLEAN CurrentState
1323 // check for enabling
1325 if (CurrentState
!= 0x00) {
1327 // check for UEFI Shell 2.0
1329 if (gEfiShellProtocol
!= NULL
) {
1331 // Enable with UEFI 2.0 Shell
1333 gEfiShellProtocol
->EnablePageBreak();
1337 // Check for EFI shell
1339 if (mEfiShellEnvironment2
!= NULL
) {
1341 // Enable with EFI Shell
1343 mEfiShellEnvironment2
->EnablePageBreak (DEFAULT_INIT_ROW
, DEFAULT_AUTO_LF
);
1349 // check for UEFI Shell 2.0
1351 if (gEfiShellProtocol
!= NULL
) {
1353 // Disable with UEFI 2.0 Shell
1355 gEfiShellProtocol
->DisablePageBreak();
1359 // Check for EFI shell
1361 if (mEfiShellEnvironment2
!= NULL
) {
1363 // Disable with EFI Shell
1365 mEfiShellEnvironment2
->DisablePageBreak ();
1373 /// version of EFI_SHELL_FILE_INFO struct, except has no CONST pointers.
1374 /// This allows for the struct to be populated.
1381 SHELL_FILE_HANDLE Handle
;
1382 EFI_FILE_INFO
*Info
;
1383 } EFI_SHELL_FILE_INFO_NO_CONST
;
1386 Converts a EFI shell list of structures to the coresponding UEFI Shell 2.0 type of list.
1388 if OldStyleFileList is NULL then ASSERT()
1390 this function will convert a SHELL_FILE_ARG based list into a callee allocated
1391 EFI_SHELL_FILE_INFO based list. it is up to the caller to free the memory via
1392 the ShellCloseFileMetaArg function.
1394 @param[in] FileList the EFI shell list type
1395 @param[in, out] ListHead the list to add to
1397 @retval the resultant head of the double linked new format list;
1401 InternalShellConvertFileListType (
1402 IN LIST_ENTRY
*FileList
,
1403 IN OUT LIST_ENTRY
*ListHead
1406 SHELL_FILE_ARG
*OldInfo
;
1408 EFI_SHELL_FILE_INFO_NO_CONST
*NewInfo
;
1413 ASSERT(FileList
!= NULL
);
1414 ASSERT(ListHead
!= NULL
);
1417 // enumerate through each member of the old list and copy
1419 for (Link
= FileList
->ForwardLink
; Link
!= FileList
; Link
= Link
->ForwardLink
) {
1420 OldInfo
= CR (Link
, SHELL_FILE_ARG
, Link
, SHELL_FILE_ARG_SIGNATURE
);
1421 ASSERT(OldInfo
!= NULL
);
1424 // Skip ones that failed to open...
1426 if (OldInfo
->Status
!= EFI_SUCCESS
) {
1431 // make sure the old list was valid
1433 ASSERT(OldInfo
->Info
!= NULL
);
1434 ASSERT(OldInfo
->FullName
!= NULL
);
1435 ASSERT(OldInfo
->FileName
!= NULL
);
1438 // allocate a new EFI_SHELL_FILE_INFO object
1440 NewInfo
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1441 if (NewInfo
== NULL
) {
1442 ShellCloseFileMetaArg((EFI_SHELL_FILE_INFO
**)(&ListHead
));
1448 // copy the simple items
1450 NewInfo
->Handle
= OldInfo
->Handle
;
1451 NewInfo
->Status
= OldInfo
->Status
;
1453 // old shell checks for 0 not NULL
1454 OldInfo
->Handle
= 0;
1457 // allocate new space to copy strings and structure
1459 NewInfo
->FullName
= AllocateCopyPool(StrSize(OldInfo
->FullName
), OldInfo
->FullName
);
1460 NewInfo
->FileName
= AllocateCopyPool(StrSize(OldInfo
->FileName
), OldInfo
->FileName
);
1461 NewInfo
->Info
= AllocateCopyPool((UINTN
)OldInfo
->Info
->Size
, OldInfo
->Info
);
1464 // make sure all the memory allocations were sucessful
1466 if (NULL
== NewInfo
->FullName
|| NewInfo
->FileName
== NULL
|| NewInfo
->Info
== NULL
) {
1468 // Free the partially allocated new node
1470 SHELL_FREE_NON_NULL(NewInfo
->FullName
);
1471 SHELL_FREE_NON_NULL(NewInfo
->FileName
);
1472 SHELL_FREE_NON_NULL(NewInfo
->Info
);
1473 SHELL_FREE_NON_NULL(NewInfo
);
1476 // Free the previously converted stuff
1478 ShellCloseFileMetaArg((EFI_SHELL_FILE_INFO
**)(&ListHead
));
1484 // add that to the list
1486 InsertTailList(ListHead
, &NewInfo
->Link
);
1491 Opens a group of files based on a path.
1493 This function uses the Arg to open all the matching files. Each matched
1494 file has a SHELL_FILE_INFO structure to record the file information. These
1495 structures are placed on the list ListHead. Users can get the SHELL_FILE_INFO
1496 structures from ListHead to access each file. This function supports wildcards
1497 and will process '?' and '*' as such. the list must be freed with a call to
1498 ShellCloseFileMetaArg().
1500 If you are NOT appending to an existing list *ListHead must be NULL. If
1501 *ListHead is NULL then it must be callee freed.
1503 @param Arg pointer to path string
1504 @param OpenMode mode to open files with
1505 @param ListHead head of linked list of results
1507 @retval EFI_SUCCESS the operation was sucessful and the list head
1508 contains the list of opened files
1509 @return != EFI_SUCCESS the operation failed
1511 @sa InternalShellConvertFileListType
1515 ShellOpenFileMetaArg (
1518 IN OUT EFI_SHELL_FILE_INFO
**ListHead
1522 LIST_ENTRY mOldStyleFileList
;
1523 CHAR16
*CleanFilePathStr
;
1526 // ASSERT that Arg and ListHead are not NULL
1528 ASSERT(Arg
!= NULL
);
1529 ASSERT(ListHead
!= NULL
);
1531 CleanFilePathStr
= NULL
;
1533 Status
= InternalShellStripQuotes (Arg
, &CleanFilePathStr
);
1534 if (EFI_ERROR (Status
)) {
1539 // Check for UEFI Shell 2.0 protocols
1541 if (gEfiShellProtocol
!= NULL
) {
1542 if (*ListHead
== NULL
) {
1543 *ListHead
= (EFI_SHELL_FILE_INFO
*)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1544 if (*ListHead
== NULL
) {
1545 FreePool(CleanFilePathStr
);
1546 return (EFI_OUT_OF_RESOURCES
);
1548 InitializeListHead(&((*ListHead
)->Link
));
1550 Status
= gEfiShellProtocol
->OpenFileList(CleanFilePathStr
,
1553 if (EFI_ERROR(Status
)) {
1554 gEfiShellProtocol
->RemoveDupInFileList(ListHead
);
1556 Status
= gEfiShellProtocol
->RemoveDupInFileList(ListHead
);
1558 if (*ListHead
!= NULL
&& IsListEmpty(&(*ListHead
)->Link
)) {
1559 FreePool(*ListHead
);
1560 FreePool(CleanFilePathStr
);
1562 return (EFI_NOT_FOUND
);
1564 FreePool(CleanFilePathStr
);
1569 // Check for EFI shell
1571 if (mEfiShellEnvironment2
!= NULL
) {
1573 // make sure the list head is initialized
1575 InitializeListHead(&mOldStyleFileList
);
1578 // Get the EFI Shell list of files
1580 Status
= mEfiShellEnvironment2
->FileMetaArg(CleanFilePathStr
, &mOldStyleFileList
);
1581 if (EFI_ERROR(Status
)) {
1583 FreePool(CleanFilePathStr
);
1587 if (*ListHead
== NULL
) {
1588 *ListHead
= (EFI_SHELL_FILE_INFO
*)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1589 if (*ListHead
== NULL
) {
1590 FreePool(CleanFilePathStr
);
1591 return (EFI_OUT_OF_RESOURCES
);
1593 InitializeListHead(&((*ListHead
)->Link
));
1597 // Convert that to equivalent of UEFI Shell 2.0 structure
1599 InternalShellConvertFileListType(&mOldStyleFileList
, &(*ListHead
)->Link
);
1602 // Free the EFI Shell version that was converted.
1604 mEfiShellEnvironment2
->FreeFileList(&mOldStyleFileList
);
1606 if ((*ListHead
)->Link
.ForwardLink
== (*ListHead
)->Link
.BackLink
&& (*ListHead
)->Link
.BackLink
== &((*ListHead
)->Link
)) {
1607 FreePool(*ListHead
);
1609 Status
= EFI_NOT_FOUND
;
1611 FreePool(CleanFilePathStr
);
1615 FreePool(CleanFilePathStr
);
1616 return (EFI_UNSUPPORTED
);
1619 Free the linked list returned from ShellOpenFileMetaArg.
1621 if ListHead is NULL then ASSERT().
1623 @param ListHead the pointer to free.
1625 @retval EFI_SUCCESS the operation was sucessful.
1629 ShellCloseFileMetaArg (
1630 IN OUT EFI_SHELL_FILE_INFO
**ListHead
1636 // ASSERT that ListHead is not NULL
1638 ASSERT(ListHead
!= NULL
);
1641 // Check for UEFI Shell 2.0 protocols
1643 if (gEfiShellProtocol
!= NULL
) {
1644 return (gEfiShellProtocol
->FreeFileList(ListHead
));
1645 } else if (mEfiShellEnvironment2
!= NULL
) {
1647 // Since this is EFI Shell version we need to free our internally made copy
1650 for ( Node
= GetFirstNode(&(*ListHead
)->Link
)
1651 ; *ListHead
!= NULL
&& !IsListEmpty(&(*ListHead
)->Link
)
1652 ; Node
= GetFirstNode(&(*ListHead
)->Link
)) {
1653 RemoveEntryList(Node
);
1654 ((EFI_FILE_PROTOCOL
*)((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
)->Handle
)->Close(((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
)->Handle
);
1655 FreePool(((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
)->FullName
);
1656 FreePool(((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
)->FileName
);
1657 FreePool(((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
)->Info
);
1658 FreePool((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
);
1660 SHELL_FREE_NON_NULL(*ListHead
);
1664 return (EFI_UNSUPPORTED
);
1668 Find a file by searching the CWD and then the path.
1670 If FileName is NULL then ASSERT.
1672 If the return value is not NULL then the memory must be caller freed.
1674 @param FileName Filename string.
1676 @retval NULL the file was not found
1677 @return !NULL the full path to the file.
1682 IN CONST CHAR16
*FileName
1686 SHELL_FILE_HANDLE Handle
;
1690 CONST CHAR16
*Walker
;
1697 // First make sure its not an absolute path.
1699 Status
= ShellOpenFileByName(FileName
, &Handle
, EFI_FILE_MODE_READ
, 0);
1700 if (!EFI_ERROR(Status
)){
1701 if (FileHandleIsDirectory(Handle
) != EFI_SUCCESS
) {
1702 ASSERT(RetVal
== NULL
);
1703 RetVal
= StrnCatGrow(&RetVal
, NULL
, FileName
, 0);
1704 ShellCloseFile(&Handle
);
1707 ShellCloseFile(&Handle
);
1711 Path
= ShellGetEnvironmentVariable(L
"cwd");
1713 Size
= StrSize(Path
) + sizeof(CHAR16
);
1714 Size
+= StrSize(FileName
);
1715 TestPath
= AllocateZeroPool(Size
);
1716 if (TestPath
== NULL
) {
1719 StrCpyS(TestPath
, Size
/sizeof(CHAR16
), Path
);
1720 StrCatS(TestPath
, Size
/sizeof(CHAR16
), L
"\\");
1721 StrCatS(TestPath
, Size
/sizeof(CHAR16
), FileName
);
1722 Status
= ShellOpenFileByName(TestPath
, &Handle
, EFI_FILE_MODE_READ
, 0);
1723 if (!EFI_ERROR(Status
)){
1724 if (FileHandleIsDirectory(Handle
) != EFI_SUCCESS
) {
1725 ASSERT(RetVal
== NULL
);
1726 RetVal
= StrnCatGrow(&RetVal
, NULL
, TestPath
, 0);
1727 ShellCloseFile(&Handle
);
1731 ShellCloseFile(&Handle
);
1736 Path
= ShellGetEnvironmentVariable(L
"path");
1738 Size
= StrSize(Path
)+sizeof(CHAR16
);
1739 Size
+= StrSize(FileName
);
1740 TestPath
= AllocateZeroPool(Size
);
1741 if (TestPath
== NULL
) {
1744 Walker
= (CHAR16
*)Path
;
1746 CopyMem(TestPath
, Walker
, StrSize(Walker
));
1747 if (TestPath
!= NULL
) {
1748 TempChar
= StrStr(TestPath
, L
";");
1749 if (TempChar
!= NULL
) {
1750 *TempChar
= CHAR_NULL
;
1752 if (TestPath
[StrLen(TestPath
)-1] != L
'\\') {
1753 StrCatS(TestPath
, Size
/sizeof(CHAR16
), L
"\\");
1755 if (FileName
[0] == L
'\\') {
1758 StrCatS(TestPath
, Size
/sizeof(CHAR16
), FileName
);
1759 if (StrStr(Walker
, L
";") != NULL
) {
1760 Walker
= StrStr(Walker
, L
";") + 1;
1764 Status
= ShellOpenFileByName(TestPath
, &Handle
, EFI_FILE_MODE_READ
, 0);
1765 if (!EFI_ERROR(Status
)){
1766 if (FileHandleIsDirectory(Handle
) != EFI_SUCCESS
) {
1767 ASSERT(RetVal
== NULL
);
1768 RetVal
= StrnCatGrow(&RetVal
, NULL
, TestPath
, 0);
1769 ShellCloseFile(&Handle
);
1772 ShellCloseFile(&Handle
);
1776 } while (Walker
!= NULL
&& Walker
[0] != CHAR_NULL
);
1783 Find a file by searching the CWD and then the path with a variable set of file
1784 extensions. If the file is not found it will append each extension in the list
1785 in the order provided and return the first one that is successful.
1787 If FileName is NULL, then ASSERT.
1788 If FileExtension is NULL, then behavior is identical to ShellFindFilePath.
1790 If the return value is not NULL then the memory must be caller freed.
1792 @param[in] FileName Filename string.
1793 @param[in] FileExtension Semi-colon delimeted list of possible extensions.
1795 @retval NULL The file was not found.
1796 @retval !NULL The path to the file.
1800 ShellFindFilePathEx (
1801 IN CONST CHAR16
*FileName
,
1802 IN CONST CHAR16
*FileExtension
1807 CONST CHAR16
*ExtensionWalker
;
1812 ASSERT(FileName
!= NULL
);
1813 if (FileExtension
== NULL
) {
1814 return (ShellFindFilePath(FileName
));
1816 RetVal
= ShellFindFilePath(FileName
);
1817 if (RetVal
!= NULL
) {
1820 Size
= StrSize(FileName
);
1821 Size
+= StrSize(FileExtension
);
1822 TestPath
= AllocateZeroPool(Size
);
1823 if (TestPath
== NULL
) {
1826 for (ExtensionWalker
= FileExtension
, TempChar2
= (CHAR16
*)FileExtension
; TempChar2
!= NULL
; ExtensionWalker
= TempChar2
+ 1){
1827 StrCpyS(TestPath
, Size
/sizeof(CHAR16
), FileName
);
1828 if (ExtensionWalker
!= NULL
) {
1829 StrCatS(TestPath
, Size
/sizeof(CHAR16
), ExtensionWalker
);
1831 TempChar
= StrStr(TestPath
, L
";");
1832 if (TempChar
!= NULL
) {
1833 *TempChar
= CHAR_NULL
;
1835 RetVal
= ShellFindFilePath(TestPath
);
1836 if (RetVal
!= NULL
) {
1839 ASSERT(ExtensionWalker
!= NULL
);
1840 TempChar2
= StrStr(ExtensionWalker
, L
";");
1849 SHELL_PARAM_TYPE Type
;
1851 UINTN OriginalPosition
;
1852 } SHELL_PARAM_PACKAGE
;
1855 Checks the list of valid arguments and returns TRUE if the item was found. If the
1856 return value is TRUE then the type parameter is set also.
1858 if CheckList is NULL then ASSERT();
1859 if Name is NULL then ASSERT();
1860 if Type is NULL then ASSERT();
1862 @param Name pointer to Name of parameter found
1863 @param CheckList List to check against
1864 @param Type pointer to type of parameter if it was found
1866 @retval TRUE the Parameter was found. Type is valid.
1867 @retval FALSE the Parameter was not found. Type is not valid.
1871 InternalIsOnCheckList (
1872 IN CONST CHAR16
*Name
,
1873 IN CONST SHELL_PARAM_ITEM
*CheckList
,
1874 OUT SHELL_PARAM_TYPE
*Type
1877 SHELL_PARAM_ITEM
*TempListItem
;
1881 // ASSERT that all 3 pointer parameters aren't NULL
1883 ASSERT(CheckList
!= NULL
);
1884 ASSERT(Type
!= NULL
);
1885 ASSERT(Name
!= NULL
);
1888 // question mark and page break mode are always supported
1890 if ((StrCmp(Name
, L
"-?") == 0) ||
1891 (StrCmp(Name
, L
"-b") == 0)
1898 // Enumerate through the list
1900 for (TempListItem
= (SHELL_PARAM_ITEM
*)CheckList
; TempListItem
->Name
!= NULL
; TempListItem
++) {
1902 // If the Type is TypeStart only check the first characters of the passed in param
1903 // If it matches set the type and return TRUE
1905 if (TempListItem
->Type
== TypeStart
) {
1906 if (StrnCmp(Name
, TempListItem
->Name
, StrLen(TempListItem
->Name
)) == 0) {
1907 *Type
= TempListItem
->Type
;
1911 TempString
= StrnCatGrow(&TempString
, NULL
, Name
, StrLen(TempListItem
->Name
));
1912 if (TempString
!= NULL
) {
1913 if (StringNoCaseCompare(&TempString
, &TempListItem
->Name
) == 0) {
1914 *Type
= TempListItem
->Type
;
1915 FreePool(TempString
);
1918 FreePool(TempString
);
1920 } else if (StringNoCaseCompare(&Name
, &TempListItem
->Name
) == 0) {
1921 *Type
= TempListItem
->Type
;
1929 Checks the string for indicators of "flag" status. this is a leading '/', '-', or '+'
1931 @param[in] Name pointer to Name of parameter found
1932 @param[in] AlwaysAllowNumbers TRUE to allow numbers, FALSE to not.
1933 @param[in] TimeNumbers TRUE to allow numbers with ":", FALSE otherwise.
1935 @retval TRUE the Parameter is a flag.
1936 @retval FALSE the Parameter not a flag.
1941 IN CONST CHAR16
*Name
,
1942 IN CONST BOOLEAN AlwaysAllowNumbers
,
1943 IN CONST BOOLEAN TimeNumbers
1947 // ASSERT that Name isn't NULL
1949 ASSERT(Name
!= NULL
);
1952 // If we accept numbers then dont return TRUE. (they will be values)
1954 if (((Name
[0] == L
'-' || Name
[0] == L
'+') && InternalShellIsHexOrDecimalNumber(Name
+1, FALSE
, FALSE
, TimeNumbers
)) && AlwaysAllowNumbers
) {
1959 // If the Name has a /, +, or - as the first character return TRUE
1961 if ((Name
[0] == L
'/') ||
1962 (Name
[0] == L
'-') ||
1971 Checks the command line arguments passed against the list of valid ones.
1973 If no initialization is required, then return RETURN_SUCCESS.
1975 @param[in] CheckList pointer to list of parameters to check
1976 @param[out] CheckPackage pointer to pointer to list checked values
1977 @param[out] ProblemParam optional pointer to pointer to unicode string for
1978 the paramater that caused failure. If used then the
1979 caller is responsible for freeing the memory.
1980 @param[in] AutoPageBreak will automatically set PageBreakEnabled for "b" parameter
1981 @param[in] Argv pointer to array of parameters
1982 @param[in] Argc Count of parameters in Argv
1983 @param[in] AlwaysAllowNumbers TRUE to allow numbers always, FALSE otherwise.
1985 @retval EFI_SUCCESS The operation completed sucessfully.
1986 @retval EFI_OUT_OF_RESOURCES A memory allocation failed
1987 @retval EFI_INVALID_PARAMETER A parameter was invalid
1988 @retval EFI_VOLUME_CORRUPTED the command line was corrupt. an argument was
1989 duplicated. the duplicated command line argument
1990 was returned in ProblemParam if provided.
1991 @retval EFI_NOT_FOUND a argument required a value that was missing.
1992 the invalid command line argument was returned in
1993 ProblemParam if provided.
1997 InternalCommandLineParse (
1998 IN CONST SHELL_PARAM_ITEM
*CheckList
,
1999 OUT LIST_ENTRY
**CheckPackage
,
2000 OUT CHAR16
**ProblemParam OPTIONAL
,
2001 IN BOOLEAN AutoPageBreak
,
2002 IN CONST CHAR16
**Argv
,
2004 IN BOOLEAN AlwaysAllowNumbers
2008 SHELL_PARAM_TYPE CurrentItemType
;
2009 SHELL_PARAM_PACKAGE
*CurrentItemPackage
;
2013 CONST CHAR16
*TempPointer
;
2014 UINTN CurrentValueSize
;
2016 CurrentItemPackage
= NULL
;
2022 // If there is only 1 item we dont need to do anything
2025 *CheckPackage
= NULL
;
2026 return (EFI_SUCCESS
);
2032 ASSERT(CheckList
!= NULL
);
2033 ASSERT(Argv
!= NULL
);
2036 // initialize the linked list
2038 *CheckPackage
= (LIST_ENTRY
*)AllocateZeroPool(sizeof(LIST_ENTRY
));
2039 if (*CheckPackage
== NULL
) {
2040 return (EFI_OUT_OF_RESOURCES
);
2043 InitializeListHead(*CheckPackage
);
2046 // loop through each of the arguments
2048 for (LoopCounter
= 0 ; LoopCounter
< Argc
; ++LoopCounter
) {
2049 if (Argv
[LoopCounter
] == NULL
) {
2051 // do nothing for NULL argv
2053 } else if (InternalIsOnCheckList(Argv
[LoopCounter
], CheckList
, &CurrentItemType
)) {
2055 // We might have leftover if last parameter didnt have optional value
2057 if (GetItemValue
!= 0) {
2059 InsertHeadList(*CheckPackage
, &CurrentItemPackage
->Link
);
2064 CurrentItemPackage
= AllocateZeroPool(sizeof(SHELL_PARAM_PACKAGE
));
2065 if (CurrentItemPackage
== NULL
) {
2066 ShellCommandLineFreeVarList(*CheckPackage
);
2067 *CheckPackage
= NULL
;
2068 return (EFI_OUT_OF_RESOURCES
);
2070 CurrentItemPackage
->Name
= AllocateCopyPool(StrSize(Argv
[LoopCounter
]), Argv
[LoopCounter
]);
2071 if (CurrentItemPackage
->Name
== NULL
) {
2072 ShellCommandLineFreeVarList(*CheckPackage
);
2073 *CheckPackage
= NULL
;
2074 return (EFI_OUT_OF_RESOURCES
);
2076 CurrentItemPackage
->Type
= CurrentItemType
;
2077 CurrentItemPackage
->OriginalPosition
= (UINTN
)(-1);
2078 CurrentItemPackage
->Value
= NULL
;
2081 // Does this flag require a value
2083 switch (CurrentItemPackage
->Type
) {
2085 // possibly trigger the next loop(s) to populate the value of this item
2092 case TypeDoubleValue
:
2097 GetItemValue
= (UINTN
)(-1);
2102 // this item has no value expected; we are done
2104 InsertHeadList(*CheckPackage
, &CurrentItemPackage
->Link
);
2105 ASSERT(GetItemValue
== 0);
2108 } else if (GetItemValue
!= 0 && CurrentItemPackage
!= NULL
&& !InternalIsFlag(Argv
[LoopCounter
], AlwaysAllowNumbers
, (BOOLEAN
)(CurrentItemPackage
->Type
== TypeTimeValue
))) {
2110 // get the item VALUE for a previous flag
2112 CurrentValueSize
= ValueSize
+ StrSize(Argv
[LoopCounter
]) + sizeof(CHAR16
);
2113 CurrentItemPackage
->Value
= ReallocatePool(ValueSize
, CurrentValueSize
, CurrentItemPackage
->Value
);
2114 ASSERT(CurrentItemPackage
->Value
!= NULL
);
2115 if (ValueSize
== 0) {
2116 StrCpyS( CurrentItemPackage
->Value
,
2117 CurrentValueSize
/sizeof(CHAR16
),
2121 StrCatS( CurrentItemPackage
->Value
,
2122 CurrentValueSize
/sizeof(CHAR16
),
2125 StrCatS( CurrentItemPackage
->Value
,
2126 CurrentValueSize
/sizeof(CHAR16
),
2130 ValueSize
+= StrSize(Argv
[LoopCounter
]) + sizeof(CHAR16
);
2133 if (GetItemValue
== 0) {
2134 InsertHeadList(*CheckPackage
, &CurrentItemPackage
->Link
);
2136 } else if (!InternalIsFlag(Argv
[LoopCounter
], AlwaysAllowNumbers
, FALSE
)){
2138 // add this one as a non-flag
2141 TempPointer
= Argv
[LoopCounter
];
2142 if ((*TempPointer
== L
'^' && *(TempPointer
+1) == L
'-')
2143 || (*TempPointer
== L
'^' && *(TempPointer
+1) == L
'/')
2144 || (*TempPointer
== L
'^' && *(TempPointer
+1) == L
'+')
2148 CurrentItemPackage
= AllocateZeroPool(sizeof(SHELL_PARAM_PACKAGE
));
2149 if (CurrentItemPackage
== NULL
) {
2150 ShellCommandLineFreeVarList(*CheckPackage
);
2151 *CheckPackage
= NULL
;
2152 return (EFI_OUT_OF_RESOURCES
);
2154 CurrentItemPackage
->Name
= NULL
;
2155 CurrentItemPackage
->Type
= TypePosition
;
2156 CurrentItemPackage
->Value
= AllocateCopyPool(StrSize(TempPointer
), TempPointer
);
2157 if (CurrentItemPackage
->Value
== NULL
) {
2158 ShellCommandLineFreeVarList(*CheckPackage
);
2159 *CheckPackage
= NULL
;
2160 return (EFI_OUT_OF_RESOURCES
);
2162 CurrentItemPackage
->OriginalPosition
= Count
++;
2163 InsertHeadList(*CheckPackage
, &CurrentItemPackage
->Link
);
2166 // this was a non-recognised flag... error!
2168 if (ProblemParam
!= NULL
) {
2169 *ProblemParam
= AllocateCopyPool(StrSize(Argv
[LoopCounter
]), Argv
[LoopCounter
]);
2171 ShellCommandLineFreeVarList(*CheckPackage
);
2172 *CheckPackage
= NULL
;
2173 return (EFI_VOLUME_CORRUPTED
);
2176 if (GetItemValue
!= 0) {
2178 InsertHeadList(*CheckPackage
, &CurrentItemPackage
->Link
);
2181 // support for AutoPageBreak
2183 if (AutoPageBreak
&& ShellCommandLineGetFlag(*CheckPackage
, L
"-b")) {
2184 ShellSetPageBreakMode(TRUE
);
2186 return (EFI_SUCCESS
);
2190 Checks the command line arguments passed against the list of valid ones.
2191 Optionally removes NULL values first.
2193 If no initialization is required, then return RETURN_SUCCESS.
2195 @param[in] CheckList The pointer to list of parameters to check.
2196 @param[out] CheckPackage The package of checked values.
2197 @param[out] ProblemParam Optional pointer to pointer to unicode string for
2198 the paramater that caused failure.
2199 @param[in] AutoPageBreak Will automatically set PageBreakEnabled.
2200 @param[in] AlwaysAllowNumbers Will never fail for number based flags.
2202 @retval EFI_SUCCESS The operation completed sucessfully.
2203 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
2204 @retval EFI_INVALID_PARAMETER A parameter was invalid.
2205 @retval EFI_VOLUME_CORRUPTED The command line was corrupt.
2206 @retval EFI_DEVICE_ERROR The commands contained 2 opposing arguments. One
2207 of the command line arguments was returned in
2208 ProblemParam if provided.
2209 @retval EFI_NOT_FOUND A argument required a value that was missing.
2210 The invalid command line argument was returned in
2211 ProblemParam if provided.
2215 ShellCommandLineParseEx (
2216 IN CONST SHELL_PARAM_ITEM
*CheckList
,
2217 OUT LIST_ENTRY
**CheckPackage
,
2218 OUT CHAR16
**ProblemParam OPTIONAL
,
2219 IN BOOLEAN AutoPageBreak
,
2220 IN BOOLEAN AlwaysAllowNumbers
2224 // ASSERT that CheckList and CheckPackage aren't NULL
2226 ASSERT(CheckList
!= NULL
);
2227 ASSERT(CheckPackage
!= NULL
);
2230 // Check for UEFI Shell 2.0 protocols
2232 if (gEfiShellParametersProtocol
!= NULL
) {
2233 return (InternalCommandLineParse(CheckList
,
2237 (CONST CHAR16
**) gEfiShellParametersProtocol
->Argv
,
2238 gEfiShellParametersProtocol
->Argc
,
2239 AlwaysAllowNumbers
));
2243 // ASSERT That EFI Shell is not required
2245 ASSERT (mEfiShellInterface
!= NULL
);
2246 return (InternalCommandLineParse(CheckList
,
2250 (CONST CHAR16
**) mEfiShellInterface
->Argv
,
2251 mEfiShellInterface
->Argc
,
2252 AlwaysAllowNumbers
));
2256 Frees shell variable list that was returned from ShellCommandLineParse.
2258 This function will free all the memory that was used for the CheckPackage
2259 list of postprocessed shell arguments.
2261 this function has no return value.
2263 if CheckPackage is NULL, then return
2265 @param CheckPackage the list to de-allocate
2269 ShellCommandLineFreeVarList (
2270 IN LIST_ENTRY
*CheckPackage
2276 // check for CheckPackage == NULL
2278 if (CheckPackage
== NULL
) {
2283 // for each node in the list
2285 for ( Node
= GetFirstNode(CheckPackage
)
2286 ; !IsListEmpty(CheckPackage
)
2287 ; Node
= GetFirstNode(CheckPackage
)
2290 // Remove it from the list
2292 RemoveEntryList(Node
);
2295 // if it has a name free the name
2297 if (((SHELL_PARAM_PACKAGE
*)Node
)->Name
!= NULL
) {
2298 FreePool(((SHELL_PARAM_PACKAGE
*)Node
)->Name
);
2302 // if it has a value free the value
2304 if (((SHELL_PARAM_PACKAGE
*)Node
)->Value
!= NULL
) {
2305 FreePool(((SHELL_PARAM_PACKAGE
*)Node
)->Value
);
2309 // free the node structure
2311 FreePool((SHELL_PARAM_PACKAGE
*)Node
);
2314 // free the list head node
2316 FreePool(CheckPackage
);
2319 Checks for presence of a flag parameter
2321 flag arguments are in the form of "-<Key>" or "/<Key>", but do not have a value following the key
2323 if CheckPackage is NULL then return FALSE.
2324 if KeyString is NULL then ASSERT()
2326 @param CheckPackage The package of parsed command line arguments
2327 @param KeyString the Key of the command line argument to check for
2329 @retval TRUE the flag is on the command line
2330 @retval FALSE the flag is not on the command line
2334 ShellCommandLineGetFlag (
2335 IN CONST LIST_ENTRY
* CONST CheckPackage
,
2336 IN CONST CHAR16
* CONST KeyString
2343 // return FALSE for no package or KeyString is NULL
2345 if (CheckPackage
== NULL
|| KeyString
== NULL
) {
2350 // enumerate through the list of parametrs
2352 for ( Node
= GetFirstNode(CheckPackage
)
2353 ; !IsNull (CheckPackage
, Node
)
2354 ; Node
= GetNextNode(CheckPackage
, Node
)
2357 // If the Name matches, return TRUE (and there may be NULL name)
2359 if (((SHELL_PARAM_PACKAGE
*)Node
)->Name
!= NULL
) {
2361 // If Type is TypeStart then only compare the begining of the strings
2363 if (((SHELL_PARAM_PACKAGE
*)Node
)->Type
== TypeStart
) {
2364 if (StrnCmp(KeyString
, ((SHELL_PARAM_PACKAGE
*)Node
)->Name
, StrLen(KeyString
)) == 0) {
2368 TempString
= StrnCatGrow(&TempString
, NULL
, KeyString
, StrLen(((SHELL_PARAM_PACKAGE
*)Node
)->Name
));
2369 if (TempString
!= NULL
) {
2370 if (StringNoCaseCompare(&KeyString
, &((SHELL_PARAM_PACKAGE
*)Node
)->Name
) == 0) {
2371 FreePool(TempString
);
2374 FreePool(TempString
);
2376 } else if (StringNoCaseCompare(&KeyString
, &((SHELL_PARAM_PACKAGE
*)Node
)->Name
) == 0) {
2384 Returns value from command line argument.
2386 Value parameters are in the form of "-<Key> value" or "/<Key> value".
2388 If CheckPackage is NULL, then return NULL.
2390 @param[in] CheckPackage The package of parsed command line arguments.
2391 @param[in] KeyString The Key of the command line argument to check for.
2393 @retval NULL The flag is not on the command line.
2394 @retval !=NULL The pointer to unicode string of the value.
2398 ShellCommandLineGetValue (
2399 IN CONST LIST_ENTRY
*CheckPackage
,
2400 IN CHAR16
*KeyString
2407 // return NULL for no package or KeyString is NULL
2409 if (CheckPackage
== NULL
|| KeyString
== NULL
) {
2414 // enumerate through the list of parametrs
2416 for ( Node
= GetFirstNode(CheckPackage
)
2417 ; !IsNull (CheckPackage
, Node
)
2418 ; Node
= GetNextNode(CheckPackage
, Node
)
2421 // If the Name matches, return TRUE (and there may be NULL name)
2423 if (((SHELL_PARAM_PACKAGE
*)Node
)->Name
!= NULL
) {
2425 // If Type is TypeStart then only compare the begining of the strings
2427 if (((SHELL_PARAM_PACKAGE
*)Node
)->Type
== TypeStart
) {
2428 if (StrnCmp(KeyString
, ((SHELL_PARAM_PACKAGE
*)Node
)->Name
, StrLen(KeyString
)) == 0) {
2429 return (((SHELL_PARAM_PACKAGE
*)Node
)->Name
+ StrLen(KeyString
));
2432 TempString
= StrnCatGrow(&TempString
, NULL
, KeyString
, StrLen(((SHELL_PARAM_PACKAGE
*)Node
)->Name
));
2433 if (TempString
!= NULL
) {
2434 if (StringNoCaseCompare(&KeyString
, &((SHELL_PARAM_PACKAGE
*)Node
)->Name
) == 0) {
2435 FreePool(TempString
);
2436 return (((SHELL_PARAM_PACKAGE
*)Node
)->Name
+ StrLen(KeyString
));
2438 FreePool(TempString
);
2440 } else if (StringNoCaseCompare(&KeyString
, &((SHELL_PARAM_PACKAGE
*)Node
)->Name
) == 0) {
2441 return (((SHELL_PARAM_PACKAGE
*)Node
)->Value
);
2449 Returns raw value from command line argument.
2451 Raw value parameters are in the form of "value" in a specific position in the list.
2453 If CheckPackage is NULL, then return NULL.
2455 @param[in] CheckPackage The package of parsed command line arguments.
2456 @param[in] Position The position of the value.
2458 @retval NULL The flag is not on the command line.
2459 @retval !=NULL The pointer to unicode string of the value.
2463 ShellCommandLineGetRawValue (
2464 IN CONST LIST_ENTRY
* CONST CheckPackage
,
2471 // check for CheckPackage == NULL
2473 if (CheckPackage
== NULL
) {
2478 // enumerate through the list of parametrs
2480 for ( Node
= GetFirstNode(CheckPackage
)
2481 ; !IsNull (CheckPackage
, Node
)
2482 ; Node
= GetNextNode(CheckPackage
, Node
)
2485 // If the position matches, return the value
2487 if (((SHELL_PARAM_PACKAGE
*)Node
)->OriginalPosition
== Position
) {
2488 return (((SHELL_PARAM_PACKAGE
*)Node
)->Value
);
2495 returns the number of command line value parameters that were parsed.
2497 this will not include flags.
2499 @param[in] CheckPackage The package of parsed command line arguments.
2501 @retval (UINTN)-1 No parsing has ocurred
2502 @return other The number of value parameters found
2506 ShellCommandLineGetCount(
2507 IN CONST LIST_ENTRY
*CheckPackage
2513 if (CheckPackage
== NULL
) {
2516 for ( Node1
= GetFirstNode(CheckPackage
), Count
= 0
2517 ; !IsNull (CheckPackage
, Node1
)
2518 ; Node1
= GetNextNode(CheckPackage
, Node1
)
2520 if (((SHELL_PARAM_PACKAGE
*)Node1
)->Name
== NULL
) {
2528 Determines if a parameter is duplicated.
2530 If Param is not NULL then it will point to a callee allocated string buffer
2531 with the parameter value if a duplicate is found.
2533 If CheckPackage is NULL, then ASSERT.
2535 @param[in] CheckPackage The package of parsed command line arguments.
2536 @param[out] Param Upon finding one, a pointer to the duplicated parameter.
2538 @retval EFI_SUCCESS No parameters were duplicated.
2539 @retval EFI_DEVICE_ERROR A duplicate was found.
2543 ShellCommandLineCheckDuplicate (
2544 IN CONST LIST_ENTRY
*CheckPackage
,
2551 ASSERT(CheckPackage
!= NULL
);
2553 for ( Node1
= GetFirstNode(CheckPackage
)
2554 ; !IsNull (CheckPackage
, Node1
)
2555 ; Node1
= GetNextNode(CheckPackage
, Node1
)
2557 for ( Node2
= GetNextNode(CheckPackage
, Node1
)
2558 ; !IsNull (CheckPackage
, Node2
)
2559 ; Node2
= GetNextNode(CheckPackage
, Node2
)
2561 if ((((SHELL_PARAM_PACKAGE
*)Node1
)->Name
!= NULL
) && (((SHELL_PARAM_PACKAGE
*)Node2
)->Name
!= NULL
) && StrCmp(((SHELL_PARAM_PACKAGE
*)Node1
)->Name
, ((SHELL_PARAM_PACKAGE
*)Node2
)->Name
) == 0) {
2562 if (Param
!= NULL
) {
2564 *Param
= StrnCatGrow(Param
, NULL
, ((SHELL_PARAM_PACKAGE
*)Node1
)->Name
, 0);
2566 return (EFI_DEVICE_ERROR
);
2570 return (EFI_SUCCESS
);
2574 This is a find and replace function. Upon successful return the NewString is a copy of
2575 SourceString with each instance of FindTarget replaced with ReplaceWith.
2577 If SourceString and NewString overlap the behavior is undefined.
2579 If the string would grow bigger than NewSize it will halt and return error.
2581 @param[in] SourceString The string with source buffer.
2582 @param[in, out] NewString The string with resultant buffer.
2583 @param[in] NewSize The size in bytes of NewString.
2584 @param[in] FindTarget The string to look for.
2585 @param[in] ReplaceWith The string to replace FindTarget with.
2586 @param[in] SkipPreCarrot If TRUE will skip a FindTarget that has a '^'
2587 immediately before it.
2588 @param[in] ParameterReplacing If TRUE will add "" around items with spaces.
2590 @retval EFI_INVALID_PARAMETER SourceString was NULL.
2591 @retval EFI_INVALID_PARAMETER NewString was NULL.
2592 @retval EFI_INVALID_PARAMETER FindTarget was NULL.
2593 @retval EFI_INVALID_PARAMETER ReplaceWith was NULL.
2594 @retval EFI_INVALID_PARAMETER FindTarget had length < 1.
2595 @retval EFI_INVALID_PARAMETER SourceString had length < 1.
2596 @retval EFI_BUFFER_TOO_SMALL NewSize was less than the minimum size to hold
2597 the new string (truncation occurred).
2598 @retval EFI_SUCCESS The string was successfully copied with replacement.
2602 ShellCopySearchAndReplace(
2603 IN CHAR16 CONST
*SourceString
,
2604 IN OUT CHAR16
*NewString
,
2606 IN CONST CHAR16
*FindTarget
,
2607 IN CONST CHAR16
*ReplaceWith
,
2608 IN CONST BOOLEAN SkipPreCarrot
,
2609 IN CONST BOOLEAN ParameterReplacing
2615 if ( (SourceString
== NULL
)
2616 || (NewString
== NULL
)
2617 || (FindTarget
== NULL
)
2618 || (ReplaceWith
== NULL
)
2619 || (StrLen(FindTarget
) < 1)
2620 || (StrLen(SourceString
) < 1)
2622 return (EFI_INVALID_PARAMETER
);
2625 if (StrStr(ReplaceWith
, L
" ") == NULL
|| !ParameterReplacing
) {
2626 Replace
= StrnCatGrow(&Replace
, NULL
, ReplaceWith
, 0);
2628 Replace
= AllocateZeroPool(StrSize(ReplaceWith
) + 2*sizeof(CHAR16
));
2629 if (Replace
!= NULL
) {
2630 UnicodeSPrint(Replace
, StrSize(ReplaceWith
) + 2*sizeof(CHAR16
), L
"\"%s\"", ReplaceWith
);
2633 if (Replace
== NULL
) {
2634 return (EFI_OUT_OF_RESOURCES
);
2636 NewString
= ZeroMem(NewString
, NewSize
);
2637 while (*SourceString
!= CHAR_NULL
) {
2639 // if we find the FindTarget and either Skip == FALSE or Skip and we
2640 // dont have a carrot do a replace...
2642 if (StrnCmp(SourceString
, FindTarget
, StrLen(FindTarget
)) == 0
2643 && ((SkipPreCarrot
&& *(SourceString
-1) != L
'^') || !SkipPreCarrot
)
2645 SourceString
+= StrLen(FindTarget
);
2646 Size
= StrSize(NewString
);
2647 if ((Size
+ (StrLen(Replace
)*sizeof(CHAR16
))) > NewSize
) {
2649 return (EFI_BUFFER_TOO_SMALL
);
2651 StrCatS(NewString
, NewSize
/sizeof(CHAR16
), Replace
);
2653 Size
= StrSize(NewString
);
2654 if (Size
+ sizeof(CHAR16
) > NewSize
) {
2656 return (EFI_BUFFER_TOO_SMALL
);
2658 StrnCatS(NewString
, NewSize
/sizeof(CHAR16
), SourceString
, 1);
2663 return (EFI_SUCCESS
);
2667 Internal worker function to output a string.
2669 This function will output a string to the correct StdOut.
2671 @param[in] String The string to print out.
2673 @retval EFI_SUCCESS The operation was sucessful.
2674 @retval !EFI_SUCCESS The operation failed.
2679 IN CONST CHAR16
*String
2683 Size
= StrSize(String
) - sizeof(CHAR16
);
2685 return (EFI_SUCCESS
);
2687 if (gEfiShellParametersProtocol
!= NULL
) {
2688 return (gEfiShellProtocol
->WriteFile(gEfiShellParametersProtocol
->StdOut
, &Size
, (VOID
*)String
));
2690 if (mEfiShellInterface
!= NULL
) {
2691 if (mEfiShellInterface
->RedirArgc
== 0) {
2693 // Divide in half for old shell. Must be string length not size.
2695 Size
/=2; // Divide in half only when no redirection.
2697 return (mEfiShellInterface
->StdOut
->Write(mEfiShellInterface
->StdOut
, &Size
, (VOID
*)String
));
2700 return (EFI_UNSUPPORTED
);
2704 Print at a specific location on the screen.
2706 This function will move the cursor to a given screen location and print the specified string
2708 If -1 is specified for either the Row or Col the current screen location for BOTH
2711 if either Row or Col is out of range for the current console, then ASSERT
2712 if Format is NULL, then ASSERT
2714 In addition to the standard %-based flags as supported by UefiLib Print() this supports
2715 the following additional flags:
2716 %N - Set output attribute to normal
2717 %H - Set output attribute to highlight
2718 %E - Set output attribute to error
2719 %B - Set output attribute to blue color
2720 %V - Set output attribute to green color
2722 Note: The background color is controlled by the shell command cls.
2724 @param[in] Col the column to print at
2725 @param[in] Row the row to print at
2726 @param[in] Format the format string
2727 @param[in] Marker the marker for the variable argument list
2729 @return EFI_SUCCESS The operation was successful.
2730 @return EFI_DEVICE_ERROR The console device reported an error.
2734 InternalShellPrintWorker(
2735 IN INT32 Col OPTIONAL
,
2736 IN INT32 Row OPTIONAL
,
2737 IN CONST CHAR16
*Format
,
2742 CHAR16
*ResumeLocation
;
2743 CHAR16
*FormatWalker
;
2744 UINTN OriginalAttribute
;
2745 CHAR16
*mPostReplaceFormat
;
2746 CHAR16
*mPostReplaceFormat2
;
2748 mPostReplaceFormat
= AllocateZeroPool (PcdGet16 (PcdShellPrintBufferSize
));
2749 mPostReplaceFormat2
= AllocateZeroPool (PcdGet16 (PcdShellPrintBufferSize
));
2751 if (mPostReplaceFormat
== NULL
|| mPostReplaceFormat2
== NULL
) {
2752 SHELL_FREE_NON_NULL(mPostReplaceFormat
);
2753 SHELL_FREE_NON_NULL(mPostReplaceFormat2
);
2754 return (EFI_OUT_OF_RESOURCES
);
2757 Status
= EFI_SUCCESS
;
2758 OriginalAttribute
= gST
->ConOut
->Mode
->Attribute
;
2761 // Back and forth each time fixing up 1 of our flags...
2763 Status
= ShellCopySearchAndReplace(Format
, mPostReplaceFormat
, PcdGet16 (PcdShellPrintBufferSize
), L
"%N", L
"%%N", FALSE
, FALSE
);
2764 ASSERT_EFI_ERROR(Status
);
2765 Status
= ShellCopySearchAndReplace(mPostReplaceFormat
, mPostReplaceFormat2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%E", L
"%%E", FALSE
, FALSE
);
2766 ASSERT_EFI_ERROR(Status
);
2767 Status
= ShellCopySearchAndReplace(mPostReplaceFormat2
, mPostReplaceFormat
, PcdGet16 (PcdShellPrintBufferSize
), L
"%H", L
"%%H", FALSE
, FALSE
);
2768 ASSERT_EFI_ERROR(Status
);
2769 Status
= ShellCopySearchAndReplace(mPostReplaceFormat
, mPostReplaceFormat2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%B", L
"%%B", FALSE
, FALSE
);
2770 ASSERT_EFI_ERROR(Status
);
2771 Status
= ShellCopySearchAndReplace(mPostReplaceFormat2
, mPostReplaceFormat
, PcdGet16 (PcdShellPrintBufferSize
), L
"%V", L
"%%V", FALSE
, FALSE
);
2772 ASSERT_EFI_ERROR(Status
);
2775 // Use the last buffer from replacing to print from...
2777 UnicodeVSPrint (mPostReplaceFormat2
, PcdGet16 (PcdShellPrintBufferSize
), mPostReplaceFormat
, Marker
);
2779 if (Col
!= -1 && Row
!= -1) {
2780 Status
= gST
->ConOut
->SetCursorPosition(gST
->ConOut
, Col
, Row
);
2783 FormatWalker
= mPostReplaceFormat2
;
2784 while (*FormatWalker
!= CHAR_NULL
) {
2786 // Find the next attribute change request
2788 ResumeLocation
= StrStr(FormatWalker
, L
"%");
2789 if (ResumeLocation
!= NULL
) {
2790 *ResumeLocation
= CHAR_NULL
;
2793 // print the current FormatWalker string
2795 if (StrLen(FormatWalker
)>0) {
2796 Status
= InternalPrintTo(FormatWalker
);
2797 if (EFI_ERROR(Status
)) {
2803 // update the attribute
2805 if (ResumeLocation
!= NULL
) {
2806 if (*(ResumeLocation
-1) == L
'^') {
2808 // Move cursor back 1 position to overwrite the ^
2810 gST
->ConOut
->SetCursorPosition(gST
->ConOut
, gST
->ConOut
->Mode
->CursorColumn
- 1, gST
->ConOut
->Mode
->CursorRow
);
2813 // Print a simple '%' symbol
2815 Status
= InternalPrintTo(L
"%");
2816 ResumeLocation
= ResumeLocation
- 1;
2818 switch (*(ResumeLocation
+1)) {
2820 gST
->ConOut
->SetAttribute(gST
->ConOut
, OriginalAttribute
);
2823 gST
->ConOut
->SetAttribute(gST
->ConOut
, EFI_TEXT_ATTR(EFI_YELLOW
, ((OriginalAttribute
&(BIT4
|BIT5
|BIT6
))>>4)));
2826 gST
->ConOut
->SetAttribute(gST
->ConOut
, EFI_TEXT_ATTR(EFI_WHITE
, ((OriginalAttribute
&(BIT4
|BIT5
|BIT6
))>>4)));
2829 gST
->ConOut
->SetAttribute(gST
->ConOut
, EFI_TEXT_ATTR(EFI_BLUE
, ((OriginalAttribute
&(BIT4
|BIT5
|BIT6
))>>4)));
2832 gST
->ConOut
->SetAttribute(gST
->ConOut
, EFI_TEXT_ATTR(EFI_GREEN
, ((OriginalAttribute
&(BIT4
|BIT5
|BIT6
))>>4)));
2836 // Print a simple '%' symbol
2838 Status
= InternalPrintTo(L
"%");
2839 if (EFI_ERROR(Status
)) {
2842 ResumeLocation
= ResumeLocation
- 1;
2848 // reset to normal now...
2854 // update FormatWalker to Resume + 2 (skip the % and the indicator)
2856 FormatWalker
= ResumeLocation
+ 2;
2859 gST
->ConOut
->SetAttribute(gST
->ConOut
, OriginalAttribute
);
2861 SHELL_FREE_NON_NULL(mPostReplaceFormat
);
2862 SHELL_FREE_NON_NULL(mPostReplaceFormat2
);
2867 Print at a specific location on the screen.
2869 This function will move the cursor to a given screen location and print the specified string.
2871 If -1 is specified for either the Row or Col the current screen location for BOTH
2874 If either Row or Col is out of range for the current console, then ASSERT.
2875 If Format is NULL, then ASSERT.
2877 In addition to the standard %-based flags as supported by UefiLib Print() this supports
2878 the following additional flags:
2879 %N - Set output attribute to normal
2880 %H - Set output attribute to highlight
2881 %E - Set output attribute to error
2882 %B - Set output attribute to blue color
2883 %V - Set output attribute to green color
2885 Note: The background color is controlled by the shell command cls.
2887 @param[in] Col the column to print at
2888 @param[in] Row the row to print at
2889 @param[in] Format the format string
2890 @param[in] ... The variable argument list.
2892 @return EFI_SUCCESS The printing was successful.
2893 @return EFI_DEVICE_ERROR The console device reported an error.
2898 IN INT32 Col OPTIONAL
,
2899 IN INT32 Row OPTIONAL
,
2900 IN CONST CHAR16
*Format
,
2906 if (Format
== NULL
) {
2907 return (EFI_INVALID_PARAMETER
);
2909 VA_START (Marker
, Format
);
2910 RetVal
= InternalShellPrintWorker(Col
, Row
, Format
, Marker
);
2916 Print at a specific location on the screen.
2918 This function will move the cursor to a given screen location and print the specified string.
2920 If -1 is specified for either the Row or Col the current screen location for BOTH
2923 If either Row or Col is out of range for the current console, then ASSERT.
2924 If Format is NULL, then ASSERT.
2926 In addition to the standard %-based flags as supported by UefiLib Print() this supports
2927 the following additional flags:
2928 %N - Set output attribute to normal.
2929 %H - Set output attribute to highlight.
2930 %E - Set output attribute to error.
2931 %B - Set output attribute to blue color.
2932 %V - Set output attribute to green color.
2934 Note: The background color is controlled by the shell command cls.
2936 @param[in] Col The column to print at.
2937 @param[in] Row The row to print at.
2938 @param[in] Language The language of the string to retrieve. If this parameter
2939 is NULL, then the current platform language is used.
2940 @param[in] HiiFormatStringId The format string Id for getting from Hii.
2941 @param[in] HiiFormatHandle The format string Handle for getting from Hii.
2942 @param[in] ... The variable argument list.
2944 @return EFI_SUCCESS The printing was successful.
2945 @return EFI_DEVICE_ERROR The console device reported an error.
2950 IN INT32 Col OPTIONAL
,
2951 IN INT32 Row OPTIONAL
,
2952 IN CONST CHAR8
*Language OPTIONAL
,
2953 IN CONST EFI_STRING_ID HiiFormatStringId
,
2954 IN CONST EFI_HANDLE HiiFormatHandle
,
2959 CHAR16
*HiiFormatString
;
2962 VA_START (Marker
, HiiFormatHandle
);
2963 HiiFormatString
= HiiGetString(HiiFormatHandle
, HiiFormatStringId
, Language
);
2964 ASSERT(HiiFormatString
!= NULL
);
2966 RetVal
= InternalShellPrintWorker(Col
, Row
, HiiFormatString
, Marker
);
2968 SHELL_FREE_NON_NULL(HiiFormatString
);
2975 Function to determine if a given filename represents a file or a directory.
2977 @param[in] DirName Path to directory to test.
2979 @retval EFI_SUCCESS The Path represents a directory
2980 @retval EFI_NOT_FOUND The Path does not represent a directory
2981 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
2982 @return The path failed to open
2987 IN CONST CHAR16
*DirName
2991 SHELL_FILE_HANDLE Handle
;
2992 CHAR16
*TempLocation
;
2993 CHAR16
*TempLocation2
;
2995 ASSERT(DirName
!= NULL
);
2998 TempLocation
= NULL
;
3000 Status
= ShellOpenFileByName(DirName
, &Handle
, EFI_FILE_MODE_READ
, 0);
3001 if (EFI_ERROR(Status
)) {
3003 // try good logic first.
3005 if (gEfiShellProtocol
!= NULL
) {
3006 TempLocation
= StrnCatGrow(&TempLocation
, NULL
, DirName
, 0);
3007 if (TempLocation
== NULL
) {
3008 ShellCloseFile(&Handle
);
3009 return (EFI_OUT_OF_RESOURCES
);
3011 TempLocation2
= StrStr(TempLocation
, L
":");
3012 if (TempLocation2
!= NULL
&& StrLen(StrStr(TempLocation
, L
":")) == 2) {
3013 *(TempLocation2
+1) = CHAR_NULL
;
3015 if (gEfiShellProtocol
->GetDevicePathFromMap(TempLocation
) != NULL
) {
3016 FreePool(TempLocation
);
3017 return (EFI_SUCCESS
);
3019 FreePool(TempLocation
);
3022 // probably a map name?!?!!?
3024 TempLocation
= StrStr(DirName
, L
"\\");
3025 if (TempLocation
!= NULL
&& *(TempLocation
+1) == CHAR_NULL
) {
3026 return (EFI_SUCCESS
);
3032 if (FileHandleIsDirectory(Handle
) == EFI_SUCCESS
) {
3033 ShellCloseFile(&Handle
);
3034 return (EFI_SUCCESS
);
3036 ShellCloseFile(&Handle
);
3037 return (EFI_NOT_FOUND
);
3041 Function to determine if a given filename represents a file.
3043 @param[in] Name Path to file to test.
3045 @retval EFI_SUCCESS The Path represents a file.
3046 @retval EFI_NOT_FOUND The Path does not represent a file.
3047 @retval other The path failed to open.
3052 IN CONST CHAR16
*Name
3056 SHELL_FILE_HANDLE Handle
;
3058 ASSERT(Name
!= NULL
);
3062 Status
= ShellOpenFileByName(Name
, &Handle
, EFI_FILE_MODE_READ
, 0);
3063 if (EFI_ERROR(Status
)) {
3067 if (FileHandleIsDirectory(Handle
) != EFI_SUCCESS
) {
3068 ShellCloseFile(&Handle
);
3069 return (EFI_SUCCESS
);
3071 ShellCloseFile(&Handle
);
3072 return (EFI_NOT_FOUND
);
3076 Function to determine if a given filename represents a file.
3078 This will search the CWD and then the Path.
3080 If Name is NULL, then ASSERT.
3082 @param[in] Name Path to file to test.
3084 @retval EFI_SUCCESS The Path represents a file.
3085 @retval EFI_NOT_FOUND The Path does not represent a file.
3086 @retval other The path failed to open.
3091 IN CONST CHAR16
*Name
3097 if (!EFI_ERROR(ShellIsFile(Name
))) {
3098 return (EFI_SUCCESS
);
3101 NewName
= ShellFindFilePath(Name
);
3102 if (NewName
== NULL
) {
3103 return (EFI_NOT_FOUND
);
3105 Status
= ShellIsFile(NewName
);
3111 Function return the number converted from a hex representation of a number.
3113 Note: this function cannot be used when (UINTN)(-1), (0xFFFFFFFF) may be a valid
3114 result. Use ShellConvertStringToUint64 instead.
3116 @param[in] String String representation of a number.
3118 @return The unsigned integer result of the conversion.
3119 @retval (UINTN)(-1) An error occured.
3124 IN CONST CHAR16
*String
3129 if (!EFI_ERROR(ShellConvertStringToUint64(String
, &RetVal
, TRUE
, TRUE
))) {
3130 return ((UINTN
)RetVal
);
3133 return ((UINTN
)(-1));
3137 Function to determine whether a string is decimal or hex representation of a number
3138 and return the number converted from the string. Spaces are always skipped.
3140 @param[in] String String representation of a number
3143 @retval (UINTN)(-1) An error ocurred.
3148 IN CONST CHAR16
*String
3156 if (!InternalShellIsHexOrDecimalNumber(String
, Hex
, TRUE
, FALSE
)) {
3160 if (!EFI_ERROR(ShellConvertStringToUint64(String
, &RetVal
, Hex
, TRUE
))) {
3161 return ((UINTN
)RetVal
);
3163 return ((UINTN
)(-1));
3167 Safely append with automatic string resizing given length of Destination and
3168 desired length of copy from Source.
3170 append the first D characters of Source to the end of Destination, where D is
3171 the lesser of Count and the StrLen() of Source. If appending those D characters
3172 will fit within Destination (whose Size is given as CurrentSize) and
3173 still leave room for a NULL terminator, then those characters are appended,
3174 starting at the original terminating NULL of Destination, and a new terminating
3177 If appending D characters onto Destination will result in a overflow of the size
3178 given in CurrentSize the string will be grown such that the copy can be performed
3179 and CurrentSize will be updated to the new size.
3181 If Source is NULL, there is nothing to append, just return the current buffer in
3184 if Destination is NULL, then ASSERT()
3185 if Destination's current length (including NULL terminator) is already more then
3186 CurrentSize, then ASSERT()
3188 @param[in, out] Destination The String to append onto
3189 @param[in, out] CurrentSize on call the number of bytes in Destination. On
3190 return possibly the new size (still in bytes). if NULL
3191 then allocate whatever is needed.
3192 @param[in] Source The String to append from
3193 @param[in] Count Maximum number of characters to append. if 0 then
3196 @return Destination return the resultant string.
3201 IN OUT CHAR16
**Destination
,
3202 IN OUT UINTN
*CurrentSize
,
3203 IN CONST CHAR16
*Source
,
3207 UINTN DestinationStartSize
;
3213 ASSERT(Destination
!= NULL
);
3216 // If there's nothing to do then just return Destination
3218 if (Source
== NULL
) {
3219 return (*Destination
);
3223 // allow for un-initialized pointers, based on size being 0
3225 if (CurrentSize
!= NULL
&& *CurrentSize
== 0) {
3226 *Destination
= NULL
;
3230 // allow for NULL pointers address as Destination
3232 if (*Destination
!= NULL
) {
3233 ASSERT(CurrentSize
!= 0);
3234 DestinationStartSize
= StrSize(*Destination
);
3235 ASSERT(DestinationStartSize
<= *CurrentSize
);
3237 DestinationStartSize
= 0;
3238 // ASSERT(*CurrentSize == 0);
3242 // Append all of Source?
3245 Count
= StrLen(Source
);
3249 // Test and grow if required
3251 if (CurrentSize
!= NULL
) {
3252 NewSize
= *CurrentSize
;
3253 if (NewSize
< DestinationStartSize
+ (Count
* sizeof(CHAR16
))) {
3254 while (NewSize
< (DestinationStartSize
+ (Count
*sizeof(CHAR16
)))) {
3255 NewSize
+= 2 * Count
* sizeof(CHAR16
);
3257 *Destination
= ReallocatePool(*CurrentSize
, NewSize
, *Destination
);
3258 *CurrentSize
= NewSize
;
3261 NewSize
= (Count
+1)*sizeof(CHAR16
);
3262 *Destination
= AllocateZeroPool(NewSize
);
3266 // Now use standard StrnCat on a big enough buffer
3268 if (*Destination
== NULL
) {
3272 StrnCatS(*Destination
, NewSize
/sizeof(CHAR16
), Source
, Count
);
3273 return *Destination
;
3277 Prompt the user and return the resultant answer to the requestor.
3279 This function will display the requested question on the shell prompt and then
3280 wait for an apropriate answer to be input from the console.
3282 if the SHELL_PROMPT_REQUEST_TYPE is SHELL_PROMPT_REQUEST_TYPE_YESNO, ShellPromptResponseTypeQuitContinue
3283 or SHELL_PROMPT_REQUEST_TYPE_YESNOCANCEL then *Response is of type SHELL_PROMPT_RESPONSE.
3285 if the SHELL_PROMPT_REQUEST_TYPE is ShellPromptResponseTypeFreeform then *Response is of type
3288 In either case *Response must be callee freed if Response was not NULL;
3290 @param Type What type of question is asked. This is used to filter the input
3291 to prevent invalid answers to question.
3292 @param Prompt Pointer to string prompt to use to request input.
3293 @param Response Pointer to Response which will be populated upon return.
3295 @retval EFI_SUCCESS The operation was sucessful.
3296 @retval EFI_UNSUPPORTED The operation is not supported as requested.
3297 @retval EFI_INVALID_PARAMETER A parameter was invalid.
3298 @return other The operation failed.
3302 ShellPromptForResponse (
3303 IN SHELL_PROMPT_REQUEST_TYPE Type
,
3304 IN CHAR16
*Prompt OPTIONAL
,
3305 IN OUT VOID
**Response OPTIONAL
3311 SHELL_PROMPT_RESPONSE
*Resp
;
3315 Status
= EFI_UNSUPPORTED
;
3319 if (Type
!= ShellPromptResponseTypeFreeform
) {
3320 Resp
= (SHELL_PROMPT_RESPONSE
*)AllocateZeroPool(sizeof(SHELL_PROMPT_RESPONSE
));
3322 return (EFI_OUT_OF_RESOURCES
);
3327 case ShellPromptResponseTypeQuitContinue
:
3328 if (Prompt
!= NULL
) {
3329 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3332 // wait for valid response
3334 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3335 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3336 if (EFI_ERROR(Status
)) {
3339 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3340 if (Key
.UnicodeChar
== L
'Q' || Key
.UnicodeChar
==L
'q') {
3341 *Resp
= ShellPromptResponseQuit
;
3343 *Resp
= ShellPromptResponseContinue
;
3346 case ShellPromptResponseTypeYesNoCancel
:
3347 if (Prompt
!= NULL
) {
3348 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3351 // wait for valid response
3353 *Resp
= ShellPromptResponseMax
;
3354 while (*Resp
== ShellPromptResponseMax
) {
3355 if (ShellGetExecutionBreakFlag()) {
3356 Status
= EFI_ABORTED
;
3359 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3360 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3361 if (EFI_ERROR(Status
)) {
3364 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3365 switch (Key
.UnicodeChar
) {
3368 *Resp
= ShellPromptResponseYes
;
3372 *Resp
= ShellPromptResponseNo
;
3376 *Resp
= ShellPromptResponseCancel
;
3380 break; case ShellPromptResponseTypeYesNoAllCancel
:
3381 if (Prompt
!= NULL
) {
3382 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3385 // wait for valid response
3387 *Resp
= ShellPromptResponseMax
;
3388 while (*Resp
== ShellPromptResponseMax
) {
3389 if (ShellGetExecutionBreakFlag()) {
3390 Status
= EFI_ABORTED
;
3393 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3394 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3395 if (EFI_ERROR(Status
)) {
3398 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3399 switch (Key
.UnicodeChar
) {
3402 *Resp
= ShellPromptResponseYes
;
3406 *Resp
= ShellPromptResponseNo
;
3410 *Resp
= ShellPromptResponseAll
;
3414 *Resp
= ShellPromptResponseCancel
;
3419 case ShellPromptResponseTypeEnterContinue
:
3420 case ShellPromptResponseTypeAnyKeyContinue
:
3421 if (Prompt
!= NULL
) {
3422 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3425 // wait for valid response
3427 *Resp
= ShellPromptResponseMax
;
3428 while (*Resp
== ShellPromptResponseMax
) {
3429 if (ShellGetExecutionBreakFlag()) {
3430 Status
= EFI_ABORTED
;
3433 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3434 if (Type
== ShellPromptResponseTypeEnterContinue
) {
3435 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3436 if (EFI_ERROR(Status
)) {
3439 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3440 if (Key
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
3441 *Resp
= ShellPromptResponseContinue
;
3445 if (Type
== ShellPromptResponseTypeAnyKeyContinue
) {
3446 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3447 ASSERT_EFI_ERROR(Status
);
3448 *Resp
= ShellPromptResponseContinue
;
3453 case ShellPromptResponseTypeYesNo
:
3454 if (Prompt
!= NULL
) {
3455 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3458 // wait for valid response
3460 *Resp
= ShellPromptResponseMax
;
3461 while (*Resp
== ShellPromptResponseMax
) {
3462 if (ShellGetExecutionBreakFlag()) {
3463 Status
= EFI_ABORTED
;
3466 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3467 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3468 if (EFI_ERROR(Status
)) {
3471 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3472 switch (Key
.UnicodeChar
) {
3475 *Resp
= ShellPromptResponseYes
;
3479 *Resp
= ShellPromptResponseNo
;
3484 case ShellPromptResponseTypeFreeform
:
3485 if (Prompt
!= NULL
) {
3486 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3489 if (ShellGetExecutionBreakFlag()) {
3490 Status
= EFI_ABORTED
;
3493 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3494 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3495 if (EFI_ERROR(Status
)) {
3498 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3499 if (Key
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
3502 ASSERT((Buffer
== NULL
&& Size
== 0) || (Buffer
!= NULL
));
3503 StrnCatGrow(&Buffer
, &Size
, &Key
.UnicodeChar
, 1);
3507 // This is the location to add new prompt types.
3508 // If your new type loops remember to add ExecutionBreak support.
3514 if (Response
!= NULL
) {
3517 } else if (Buffer
!= NULL
) {
3524 if (Buffer
!= NULL
) {
3529 ShellPrintEx(-1, -1, L
"\r\n");
3534 Prompt the user and return the resultant answer to the requestor.
3536 This function is the same as ShellPromptForResponse, except that the prompt is
3537 automatically pulled from HII.
3539 @param Type What type of question is asked. This is used to filter the input
3540 to prevent invalid answers to question.
3541 @param[in] HiiFormatStringId The format string Id for getting from Hii.
3542 @param[in] HiiFormatHandle The format string Handle for getting from Hii.
3543 @param Response Pointer to Response which will be populated upon return.
3545 @retval EFI_SUCCESS the operation was sucessful.
3546 @return other the operation failed.
3548 @sa ShellPromptForResponse
3552 ShellPromptForResponseHii (
3553 IN SHELL_PROMPT_REQUEST_TYPE Type
,
3554 IN CONST EFI_STRING_ID HiiFormatStringId
,
3555 IN CONST EFI_HANDLE HiiFormatHandle
,
3556 IN OUT VOID
**Response
3562 Prompt
= HiiGetString(HiiFormatHandle
, HiiFormatStringId
, NULL
);
3563 Status
= ShellPromptForResponse(Type
, Prompt
, Response
);
3569 Function to determin if an entire string is a valid number.
3571 If Hex it must be preceeded with a 0x or has ForceHex, set TRUE.
3573 @param[in] String The string to evaluate.
3574 @param[in] ForceHex TRUE - always assume hex.
3575 @param[in] StopAtSpace TRUE to halt upon finding a space, FALSE to keep going.
3576 @param[in] TimeNumbers TRUE to allow numbers with ":", FALSE otherwise.
3578 @retval TRUE It is all numeric (dec/hex) characters.
3579 @retval FALSE There is a non-numeric character.
3583 InternalShellIsHexOrDecimalNumber (
3584 IN CONST CHAR16
*String
,
3585 IN CONST BOOLEAN ForceHex
,
3586 IN CONST BOOLEAN StopAtSpace
,
3587 IN CONST BOOLEAN TimeNumbers
3593 // chop off a single negative sign
3595 if (String
!= NULL
&& *String
== L
'-') {
3599 if (String
== NULL
) {
3604 // chop leading zeroes
3606 while(String
!= NULL
&& *String
== L
'0'){
3610 // allow '0x' or '0X', but not 'x' or 'X'
3612 if (String
!= NULL
&& (*String
== L
'x' || *String
== L
'X')) {
3613 if (*(String
-1) != L
'0') {
3615 // we got an x without a preceeding 0
3621 } else if (ForceHex
) {
3628 // loop through the remaining characters and use the lib function
3630 for ( ; String
!= NULL
&& *String
!= CHAR_NULL
&& !(StopAtSpace
&& *String
== L
' ') ; String
++){
3631 if (TimeNumbers
&& (String
[0] == L
':')) {
3635 if (!ShellIsHexaDecimalDigitCharacter(*String
)) {
3639 if (!ShellIsDecimalDigitCharacter(*String
)) {
3649 Function to determine if a given filename exists.
3651 @param[in] Name Path to test.
3653 @retval EFI_SUCCESS The Path represents a file.
3654 @retval EFI_NOT_FOUND The Path does not represent a file.
3655 @retval other The path failed to open.
3660 IN CONST CHAR16
*Name
3664 EFI_SHELL_FILE_INFO
*List
;
3666 ASSERT(Name
!= NULL
);
3669 Status
= ShellOpenFileMetaArg((CHAR16
*)Name
, EFI_FILE_MODE_READ
, &List
);
3670 if (EFI_ERROR(Status
)) {
3674 ShellCloseFileMetaArg(&List
);
3676 return (EFI_SUCCESS
);
3680 Convert a Unicode character to upper case only if
3681 it maps to a valid small-case ASCII character.
3683 This internal function only deal with Unicode character
3684 which maps to a valid small-case ASCII character, i.e.
3685 L'a' to L'z'. For other Unicode character, the input character
3686 is returned directly.
3688 @param Char The character to convert.
3690 @retval LowerCharacter If the Char is with range L'a' to L'z'.
3691 @retval Unchanged Otherwise.
3696 InternalShellCharToUpper (
3700 if (Char
>= L
'a' && Char
<= L
'z') {
3701 return (CHAR16
) (Char
- (L
'a' - L
'A'));
3708 Convert a Unicode character to numerical value.
3710 This internal function only deal with Unicode character
3711 which maps to a valid hexadecimal ASII character, i.e.
3712 L'0' to L'9', L'a' to L'f' or L'A' to L'F'. For other
3713 Unicode character, the value returned does not make sense.
3715 @param Char The character to convert.
3717 @return The numerical value converted.
3722 InternalShellHexCharToUintn (
3726 if (ShellIsDecimalDigitCharacter (Char
)) {
3730 return (UINTN
) (10 + InternalShellCharToUpper (Char
) - L
'A');
3734 Convert a Null-terminated Unicode hexadecimal string to a value of type UINT64.
3736 This function returns a value of type UINT64 by interpreting the contents
3737 of the Unicode string specified by String as a hexadecimal number.
3738 The format of the input Unicode string String is:
3740 [spaces][zeros][x][hexadecimal digits].
3742 The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F].
3743 The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix.
3744 If "x" appears in the input string, it must be prefixed with at least one 0.
3745 The function will ignore the pad space, which includes spaces or tab characters,
3746 before [zeros], [x] or [hexadecimal digit]. The running zero before [x] or
3747 [hexadecimal digit] will be ignored. Then, the decoding starts after [x] or the
3748 first valid hexadecimal digit. Then, the function stops at the first character that is
3749 a not a valid hexadecimal character or NULL, whichever one comes first.
3751 If String has only pad spaces, then zero is returned.
3752 If String has no leading pad spaces, leading zeros or valid hexadecimal digits,
3753 then zero is returned.
3755 @param[in] String A pointer to a Null-terminated Unicode string.
3756 @param[out] Value Upon a successful return the value of the conversion.
3757 @param[in] StopAtSpace FALSE to skip spaces.
3759 @retval EFI_SUCCESS The conversion was successful.
3760 @retval EFI_INVALID_PARAMETER A parameter was NULL or invalid.
3761 @retval EFI_DEVICE_ERROR An overflow occured.
3765 InternalShellStrHexToUint64 (
3766 IN CONST CHAR16
*String
,
3768 IN CONST BOOLEAN StopAtSpace
3773 if (String
== NULL
|| StrSize(String
) == 0 || Value
== NULL
) {
3774 return (EFI_INVALID_PARAMETER
);
3778 // Ignore the pad spaces (space or tab)
3780 while ((*String
== L
' ') || (*String
== L
'\t')) {
3785 // Ignore leading Zeros after the spaces
3787 while (*String
== L
'0') {
3791 if (InternalShellCharToUpper (*String
) == L
'X') {
3792 if (*(String
- 1) != L
'0') {
3804 // there is a space where there should't be
3806 if (*String
== L
' ') {
3807 return (EFI_INVALID_PARAMETER
);
3810 while (ShellIsHexaDecimalDigitCharacter (*String
)) {
3812 // If the Hex Number represented by String overflows according
3813 // to the range defined by UINT64, then return EFI_DEVICE_ERROR.
3815 if (!(Result
<= (RShiftU64((((UINT64
) ~0) - InternalShellHexCharToUintn (*String
)), 4)))) {
3816 // if (!(Result <= ((((UINT64) ~0) - InternalShellHexCharToUintn (*String)) >> 4))) {
3817 return (EFI_DEVICE_ERROR
);
3820 Result
= (LShiftU64(Result
, 4));
3821 Result
+= InternalShellHexCharToUintn (*String
);
3825 // stop at spaces if requested
3827 if (StopAtSpace
&& *String
== L
' ') {
3833 return (EFI_SUCCESS
);
3837 Convert a Null-terminated Unicode decimal string to a value of
3840 This function returns a value of type UINT64 by interpreting the contents
3841 of the Unicode string specified by String as a decimal number. The format
3842 of the input Unicode string String is:
3844 [spaces] [decimal digits].
3846 The valid decimal digit character is in the range [0-9]. The
3847 function will ignore the pad space, which includes spaces or
3848 tab characters, before [decimal digits]. The running zero in the
3849 beginning of [decimal digits] will be ignored. Then, the function
3850 stops at the first character that is a not a valid decimal character
3851 or a Null-terminator, whichever one comes first.
3853 If String has only pad spaces, then 0 is returned.
3854 If String has no pad spaces or valid decimal digits,
3857 @param[in] String A pointer to a Null-terminated Unicode string.
3858 @param[out] Value Upon a successful return the value of the conversion.
3859 @param[in] StopAtSpace FALSE to skip spaces.
3861 @retval EFI_SUCCESS The conversion was successful.
3862 @retval EFI_INVALID_PARAMETER A parameter was NULL or invalid.
3863 @retval EFI_DEVICE_ERROR An overflow occured.
3867 InternalShellStrDecimalToUint64 (
3868 IN CONST CHAR16
*String
,
3870 IN CONST BOOLEAN StopAtSpace
3875 if (String
== NULL
|| StrSize (String
) == 0 || Value
== NULL
) {
3876 return (EFI_INVALID_PARAMETER
);
3880 // Ignore the pad spaces (space or tab)
3882 while ((*String
== L
' ') || (*String
== L
'\t')) {
3887 // Ignore leading Zeros after the spaces
3889 while (*String
== L
'0') {
3896 // Stop upon space if requested
3897 // (if the whole value was 0)
3899 if (StopAtSpace
&& *String
== L
' ') {
3901 return (EFI_SUCCESS
);
3904 while (ShellIsDecimalDigitCharacter (*String
)) {
3906 // If the number represented by String overflows according
3907 // to the range defined by UINT64, then return EFI_DEVICE_ERROR.
3910 if (!(Result
<= (DivU64x32((((UINT64
) ~0) - (*String
- L
'0')),10)))) {
3911 return (EFI_DEVICE_ERROR
);
3914 Result
= MultU64x32(Result
, 10) + (*String
- L
'0');
3918 // Stop at spaces if requested
3920 if (StopAtSpace
&& *String
== L
' ') {
3927 return (EFI_SUCCESS
);
3931 Function to verify and convert a string to its numerical value.
3933 If Hex it must be preceeded with a 0x, 0X, or has ForceHex set TRUE.
3935 @param[in] String The string to evaluate.
3936 @param[out] Value Upon a successful return the value of the conversion.
3937 @param[in] ForceHex TRUE - always assume hex.
3938 @param[in] StopAtSpace FALSE to skip spaces.
3940 @retval EFI_SUCCESS The conversion was successful.
3941 @retval EFI_INVALID_PARAMETER String contained an invalid character.
3942 @retval EFI_NOT_FOUND String was a number, but Value was NULL.
3946 ShellConvertStringToUint64(
3947 IN CONST CHAR16
*String
,
3949 IN CONST BOOLEAN ForceHex
,
3950 IN CONST BOOLEAN StopAtSpace
3954 CONST CHAR16
*Walker
;
3960 if (!InternalShellIsHexOrDecimalNumber(String
, Hex
, StopAtSpace
, FALSE
)) {
3963 if (!InternalShellIsHexOrDecimalNumber(String
, Hex
, StopAtSpace
, FALSE
)) {
3964 return (EFI_INVALID_PARAMETER
);
3967 return (EFI_INVALID_PARAMETER
);
3972 // Chop off leading spaces
3974 for (Walker
= String
; Walker
!= NULL
&& *Walker
!= CHAR_NULL
&& *Walker
== L
' '; Walker
++);
3977 // make sure we have something left that is numeric.
3979 if (Walker
== NULL
|| *Walker
== CHAR_NULL
|| !InternalShellIsHexOrDecimalNumber(Walker
, Hex
, StopAtSpace
, FALSE
)) {
3980 return (EFI_INVALID_PARAMETER
);
3984 // do the conversion.
3986 if (Hex
|| StrnCmp(Walker
, L
"0x", 2) == 0 || StrnCmp(Walker
, L
"0X", 2) == 0){
3987 Status
= InternalShellStrHexToUint64(Walker
, &RetVal
, StopAtSpace
);
3989 Status
= InternalShellStrDecimalToUint64(Walker
, &RetVal
, StopAtSpace
);
3992 if (Value
== NULL
&& !EFI_ERROR(Status
)) {
3993 return (EFI_NOT_FOUND
);
3996 if (Value
!= NULL
) {
4004 Function to determin if an entire string is a valid number.
4006 If Hex it must be preceeded with a 0x or has ForceHex, set TRUE.
4008 @param[in] String The string to evaluate.
4009 @param[in] ForceHex TRUE - always assume hex.
4010 @param[in] StopAtSpace TRUE to halt upon finding a space, FALSE to keep going.
4012 @retval TRUE It is all numeric (dec/hex) characters.
4013 @retval FALSE There is a non-numeric character.
4017 ShellIsHexOrDecimalNumber (
4018 IN CONST CHAR16
*String
,
4019 IN CONST BOOLEAN ForceHex
,
4020 IN CONST BOOLEAN StopAtSpace
4023 if (ShellConvertStringToUint64(String
, NULL
, ForceHex
, StopAtSpace
) == EFI_NOT_FOUND
) {
4030 Function to read a single line from a SHELL_FILE_HANDLE. The \n is not included in the returned
4031 buffer. The returned buffer must be callee freed.
4033 If the position upon start is 0, then the Ascii Boolean will be set. This should be
4034 maintained and not changed for all operations with the same file.
4036 @param[in] Handle SHELL_FILE_HANDLE to read from.
4037 @param[in, out] Ascii Boolean value for indicating whether the file is
4038 Ascii (TRUE) or UCS2 (FALSE).
4040 @return The line of text from the file.
4041 @retval NULL There was not enough memory available.
4043 @sa ShellFileHandleReadLine
4047 ShellFileHandleReturnLine(
4048 IN SHELL_FILE_HANDLE Handle
,
4049 IN OUT BOOLEAN
*Ascii
4059 Status
= ShellFileHandleReadLine(Handle
, RetVal
, &Size
, FALSE
, Ascii
);
4060 if (Status
== EFI_BUFFER_TOO_SMALL
) {
4061 RetVal
= AllocateZeroPool(Size
);
4062 if (RetVal
== NULL
) {
4065 Status
= ShellFileHandleReadLine(Handle
, RetVal
, &Size
, FALSE
, Ascii
);
4068 if (EFI_ERROR(Status
) && (RetVal
!= NULL
)) {
4076 Function to read a single line (up to but not including the \n) from a SHELL_FILE_HANDLE.
4078 If the position upon start is 0, then the Ascii Boolean will be set. This should be
4079 maintained and not changed for all operations with the same file.
4081 @param[in] Handle SHELL_FILE_HANDLE to read from.
4082 @param[in, out] Buffer The pointer to buffer to read into.
4083 @param[in, out] Size The pointer to number of bytes in Buffer.
4084 @param[in] Truncate If the buffer is large enough, this has no effect.
4085 If the buffer is is too small and Truncate is TRUE,
4086 the line will be truncated.
4087 If the buffer is is too small and Truncate is FALSE,
4088 then no read will occur.
4090 @param[in, out] Ascii Boolean value for indicating whether the file is
4091 Ascii (TRUE) or UCS2 (FALSE).
4093 @retval EFI_SUCCESS The operation was successful. The line is stored in
4095 @retval EFI_INVALID_PARAMETER Handle was NULL.
4096 @retval EFI_INVALID_PARAMETER Size was NULL.
4097 @retval EFI_BUFFER_TOO_SMALL Size was not large enough to store the line.
4098 Size was updated to the minimum space required.
4102 ShellFileHandleReadLine(
4103 IN SHELL_FILE_HANDLE Handle
,
4104 IN OUT CHAR16
*Buffer
,
4106 IN BOOLEAN Truncate
,
4107 IN OUT BOOLEAN
*Ascii
4114 UINT64 OriginalFilePosition
;
4120 return (EFI_INVALID_PARAMETER
);
4122 if (Buffer
== NULL
) {
4125 *Buffer
= CHAR_NULL
;
4127 gEfiShellProtocol
->GetFilePosition(Handle
, &OriginalFilePosition
);
4128 if (OriginalFilePosition
== 0) {
4129 CharSize
= sizeof(CHAR16
);
4130 Status
= gEfiShellProtocol
->ReadFile(Handle
, &CharSize
, &CharBuffer
);
4131 ASSERT_EFI_ERROR(Status
);
4132 if (CharBuffer
== gUnicodeFileTag
) {
4136 gEfiShellProtocol
->SetFilePosition(Handle
, OriginalFilePosition
);
4140 for (CountSoFar
= 0;;CountSoFar
++){
4143 CharSize
= sizeof(CHAR8
);
4145 CharSize
= sizeof(CHAR16
);
4147 Status
= gEfiShellProtocol
->ReadFile(Handle
, &CharSize
, &CharBuffer
);
4148 if ( EFI_ERROR(Status
)
4150 || (CharBuffer
== L
'\n' && !(*Ascii
))
4151 || (CharBuffer
== '\n' && *Ascii
)
4156 // if we have space save it...
4158 if ((CountSoFar
+1)*sizeof(CHAR16
) < *Size
){
4159 ASSERT(Buffer
!= NULL
);
4160 ((CHAR16
*)Buffer
)[CountSoFar
] = CharBuffer
;
4161 ((CHAR16
*)Buffer
)[CountSoFar
+1] = CHAR_NULL
;
4166 // if we ran out of space tell when...
4168 if ((CountSoFar
+1)*sizeof(CHAR16
) > *Size
){
4169 *Size
= (CountSoFar
+1)*sizeof(CHAR16
);
4171 gEfiShellProtocol
->SetFilePosition(Handle
, OriginalFilePosition
);
4173 DEBUG((DEBUG_WARN
, "The line was truncated in ShellFileHandleReadLine"));
4175 return (EFI_BUFFER_TOO_SMALL
);
4177 while(Buffer
[StrLen(Buffer
)-1] == L
'\r') {
4178 Buffer
[StrLen(Buffer
)-1] = CHAR_NULL
;
4185 Function to print help file / man page content in the spec from the UEFI Shell protocol GetHelpText function.
4187 @param[in] CommandToGetHelpOn Pointer to a string containing the command name of help file to be printed.
4188 @param[in] SectionToGetHelpOn Pointer to the section specifier(s).
4189 @param[in] PrintCommandText If TRUE, prints the command followed by the help content, otherwise prints
4190 the help content only.
4191 @retval EFI_DEVICE_ERROR The help data format was incorrect.
4192 @retval EFI_NOT_FOUND The help data could not be found.
4193 @retval EFI_SUCCESS The operation was successful.
4198 IN CONST CHAR16
*CommandToGetHelpOn
,
4199 IN CONST CHAR16
*SectionToGetHelpOn
,
4200 IN BOOLEAN PrintCommandText
4209 // Get the string to print based
4211 Status
= gEfiShellProtocol
->GetHelpText (CommandToGetHelpOn
, SectionToGetHelpOn
, &OutText
);
4214 // make sure we got a valid string
4216 if (EFI_ERROR(Status
)){
4219 if (OutText
== NULL
|| StrLen(OutText
) == 0) {
4220 return EFI_NOT_FOUND
;
4224 // Chop off trailing stuff we dont need
4226 while (OutText
[StrLen(OutText
)-1] == L
'\r' || OutText
[StrLen(OutText
)-1] == L
'\n' || OutText
[StrLen(OutText
)-1] == L
' ') {
4227 OutText
[StrLen(OutText
)-1] = CHAR_NULL
;
4231 // Print this out to the console
4233 if (PrintCommandText
) {
4234 ShellPrintEx(-1, -1, L
"%H%-14s%N- %s\r\n", CommandToGetHelpOn
, OutText
);
4236 ShellPrintEx(-1, -1, L
"%N%s\r\n", OutText
);
4239 SHELL_FREE_NON_NULL(OutText
);
4245 Function to delete a file by name
4247 @param[in] FileName Pointer to file name to delete.
4249 @retval EFI_SUCCESS the file was deleted sucessfully
4250 @retval EFI_WARN_DELETE_FAILURE the handle was closed, but the file was not
4252 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
4253 @retval EFI_NOT_FOUND The specified file could not be found on the
4254 device or the file system could not be found
4256 @retval EFI_NO_MEDIA The device has no medium.
4257 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the
4258 medium is no longer supported.
4259 @retval EFI_DEVICE_ERROR The device reported an error.
4260 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
4261 @retval EFI_WRITE_PROTECTED The file or medium is write protected.
4262 @retval EFI_ACCESS_DENIED The file was opened read only.
4263 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the
4265 @retval other The file failed to open
4269 ShellDeleteFileByName(
4270 IN CONST CHAR16
*FileName
4274 SHELL_FILE_HANDLE FileHandle
;
4276 Status
= ShellFileExists(FileName
);
4278 if (Status
== EFI_SUCCESS
){
4279 Status
= ShellOpenFileByName(FileName
, &FileHandle
, EFI_FILE_MODE_READ
| EFI_FILE_MODE_WRITE
| EFI_FILE_MODE_CREATE
, 0x0);
4280 if (Status
== EFI_SUCCESS
){
4281 Status
= ShellDeleteFile(&FileHandle
);
4290 Cleans off all the quotes in the string.
4292 @param[in] OriginalString pointer to the string to be cleaned.
4293 @param[out] CleanString The new string with all quotes removed.
4294 Memory allocated in the function and free
4297 @retval EFI_SUCCESS The operation was successful.
4301 InternalShellStripQuotes (
4302 IN CONST CHAR16
*OriginalString
,
4303 OUT CHAR16
**CleanString
4308 if (OriginalString
== NULL
|| CleanString
== NULL
) {
4309 return EFI_INVALID_PARAMETER
;
4312 *CleanString
= AllocateCopyPool (StrSize (OriginalString
), OriginalString
);
4313 if (*CleanString
== NULL
) {
4314 return EFI_OUT_OF_RESOURCES
;
4317 for (Walker
= *CleanString
; Walker
!= NULL
&& *Walker
!= CHAR_NULL
; Walker
++) {
4318 if (*Walker
== L
'\"') {
4319 CopyMem(Walker
, Walker
+1, StrSize(Walker
) - sizeof(Walker
[0]));