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 @param DeviceName the name of the drive to get directory on
1281 @retval NULL the directory does not exist
1282 @return != NULL the directory
1286 ShellGetCurrentDir (
1287 IN CHAR16
* CONST DeviceName OPTIONAL
1291 // Check for UEFI Shell 2.0 protocols
1293 if (gEfiShellProtocol
!= NULL
) {
1294 return (gEfiShellProtocol
->GetCurDir(DeviceName
));
1298 // Check for EFI shell
1300 if (mEfiShellEnvironment2
!= NULL
) {
1301 return (mEfiShellEnvironment2
->CurDir(DeviceName
));
1307 sets (enabled or disabled) the page break mode
1309 when page break mode is enabled the screen will stop scrolling
1310 and wait for operator input before scrolling a subsequent screen.
1312 @param CurrentState TRUE to enable and FALSE to disable
1316 ShellSetPageBreakMode (
1317 IN BOOLEAN CurrentState
1321 // check for enabling
1323 if (CurrentState
!= 0x00) {
1325 // check for UEFI Shell 2.0
1327 if (gEfiShellProtocol
!= NULL
) {
1329 // Enable with UEFI 2.0 Shell
1331 gEfiShellProtocol
->EnablePageBreak();
1335 // Check for EFI shell
1337 if (mEfiShellEnvironment2
!= NULL
) {
1339 // Enable with EFI Shell
1341 mEfiShellEnvironment2
->EnablePageBreak (DEFAULT_INIT_ROW
, DEFAULT_AUTO_LF
);
1347 // check for UEFI Shell 2.0
1349 if (gEfiShellProtocol
!= NULL
) {
1351 // Disable with UEFI 2.0 Shell
1353 gEfiShellProtocol
->DisablePageBreak();
1357 // Check for EFI shell
1359 if (mEfiShellEnvironment2
!= NULL
) {
1361 // Disable with EFI Shell
1363 mEfiShellEnvironment2
->DisablePageBreak ();
1371 /// version of EFI_SHELL_FILE_INFO struct, except has no CONST pointers.
1372 /// This allows for the struct to be populated.
1379 SHELL_FILE_HANDLE Handle
;
1380 EFI_FILE_INFO
*Info
;
1381 } EFI_SHELL_FILE_INFO_NO_CONST
;
1384 Converts a EFI shell list of structures to the coresponding UEFI Shell 2.0 type of list.
1386 if OldStyleFileList is NULL then ASSERT()
1388 this function will convert a SHELL_FILE_ARG based list into a callee allocated
1389 EFI_SHELL_FILE_INFO based list. it is up to the caller to free the memory via
1390 the ShellCloseFileMetaArg function.
1392 @param[in] FileList the EFI shell list type
1393 @param[in, out] ListHead the list to add to
1395 @retval the resultant head of the double linked new format list;
1399 InternalShellConvertFileListType (
1400 IN LIST_ENTRY
*FileList
,
1401 IN OUT LIST_ENTRY
*ListHead
1404 SHELL_FILE_ARG
*OldInfo
;
1406 EFI_SHELL_FILE_INFO_NO_CONST
*NewInfo
;
1411 ASSERT(FileList
!= NULL
);
1412 ASSERT(ListHead
!= NULL
);
1415 // enumerate through each member of the old list and copy
1417 for (Link
= FileList
->ForwardLink
; Link
!= FileList
; Link
= Link
->ForwardLink
) {
1418 OldInfo
= CR (Link
, SHELL_FILE_ARG
, Link
, SHELL_FILE_ARG_SIGNATURE
);
1419 ASSERT(OldInfo
!= NULL
);
1422 // Skip ones that failed to open...
1424 if (OldInfo
->Status
!= EFI_SUCCESS
) {
1429 // make sure the old list was valid
1431 ASSERT(OldInfo
->Info
!= NULL
);
1432 ASSERT(OldInfo
->FullName
!= NULL
);
1433 ASSERT(OldInfo
->FileName
!= NULL
);
1436 // allocate a new EFI_SHELL_FILE_INFO object
1438 NewInfo
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1439 if (NewInfo
== NULL
) {
1440 ShellCloseFileMetaArg((EFI_SHELL_FILE_INFO
**)(&ListHead
));
1446 // copy the simple items
1448 NewInfo
->Handle
= OldInfo
->Handle
;
1449 NewInfo
->Status
= OldInfo
->Status
;
1451 // old shell checks for 0 not NULL
1452 OldInfo
->Handle
= 0;
1455 // allocate new space to copy strings and structure
1457 NewInfo
->FullName
= AllocateCopyPool(StrSize(OldInfo
->FullName
), OldInfo
->FullName
);
1458 NewInfo
->FileName
= AllocateCopyPool(StrSize(OldInfo
->FileName
), OldInfo
->FileName
);
1459 NewInfo
->Info
= AllocateCopyPool((UINTN
)OldInfo
->Info
->Size
, OldInfo
->Info
);
1462 // make sure all the memory allocations were sucessful
1464 if (NULL
== NewInfo
->FullName
|| NewInfo
->FileName
== NULL
|| NewInfo
->Info
== NULL
) {
1466 // Free the partially allocated new node
1468 SHELL_FREE_NON_NULL(NewInfo
->FullName
);
1469 SHELL_FREE_NON_NULL(NewInfo
->FileName
);
1470 SHELL_FREE_NON_NULL(NewInfo
->Info
);
1471 SHELL_FREE_NON_NULL(NewInfo
);
1474 // Free the previously converted stuff
1476 ShellCloseFileMetaArg((EFI_SHELL_FILE_INFO
**)(&ListHead
));
1482 // add that to the list
1484 InsertTailList(ListHead
, &NewInfo
->Link
);
1489 Opens a group of files based on a path.
1491 This function uses the Arg to open all the matching files. Each matched
1492 file has a SHELL_FILE_INFO structure to record the file information. These
1493 structures are placed on the list ListHead. Users can get the SHELL_FILE_INFO
1494 structures from ListHead to access each file. This function supports wildcards
1495 and will process '?' and '*' as such. the list must be freed with a call to
1496 ShellCloseFileMetaArg().
1498 If you are NOT appending to an existing list *ListHead must be NULL. If
1499 *ListHead is NULL then it must be callee freed.
1501 @param Arg pointer to path string
1502 @param OpenMode mode to open files with
1503 @param ListHead head of linked list of results
1505 @retval EFI_SUCCESS the operation was sucessful and the list head
1506 contains the list of opened files
1507 @return != EFI_SUCCESS the operation failed
1509 @sa InternalShellConvertFileListType
1513 ShellOpenFileMetaArg (
1516 IN OUT EFI_SHELL_FILE_INFO
**ListHead
1520 LIST_ENTRY mOldStyleFileList
;
1521 CHAR16
*CleanFilePathStr
;
1524 // ASSERT that Arg and ListHead are not NULL
1526 ASSERT(Arg
!= NULL
);
1527 ASSERT(ListHead
!= NULL
);
1529 CleanFilePathStr
= NULL
;
1531 Status
= InternalShellStripQuotes (Arg
, &CleanFilePathStr
);
1532 if (EFI_ERROR (Status
)) {
1537 // Check for UEFI Shell 2.0 protocols
1539 if (gEfiShellProtocol
!= NULL
) {
1540 if (*ListHead
== NULL
) {
1541 *ListHead
= (EFI_SHELL_FILE_INFO
*)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1542 if (*ListHead
== NULL
) {
1543 FreePool(CleanFilePathStr
);
1544 return (EFI_OUT_OF_RESOURCES
);
1546 InitializeListHead(&((*ListHead
)->Link
));
1548 Status
= gEfiShellProtocol
->OpenFileList(CleanFilePathStr
,
1551 if (EFI_ERROR(Status
)) {
1552 gEfiShellProtocol
->RemoveDupInFileList(ListHead
);
1554 Status
= gEfiShellProtocol
->RemoveDupInFileList(ListHead
);
1556 if (*ListHead
!= NULL
&& IsListEmpty(&(*ListHead
)->Link
)) {
1557 FreePool(*ListHead
);
1558 FreePool(CleanFilePathStr
);
1560 return (EFI_NOT_FOUND
);
1562 FreePool(CleanFilePathStr
);
1567 // Check for EFI shell
1569 if (mEfiShellEnvironment2
!= NULL
) {
1571 // make sure the list head is initialized
1573 InitializeListHead(&mOldStyleFileList
);
1576 // Get the EFI Shell list of files
1578 Status
= mEfiShellEnvironment2
->FileMetaArg(CleanFilePathStr
, &mOldStyleFileList
);
1579 if (EFI_ERROR(Status
)) {
1581 FreePool(CleanFilePathStr
);
1585 if (*ListHead
== NULL
) {
1586 *ListHead
= (EFI_SHELL_FILE_INFO
*)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1587 if (*ListHead
== NULL
) {
1588 FreePool(CleanFilePathStr
);
1589 return (EFI_OUT_OF_RESOURCES
);
1591 InitializeListHead(&((*ListHead
)->Link
));
1595 // Convert that to equivalent of UEFI Shell 2.0 structure
1597 InternalShellConvertFileListType(&mOldStyleFileList
, &(*ListHead
)->Link
);
1600 // Free the EFI Shell version that was converted.
1602 mEfiShellEnvironment2
->FreeFileList(&mOldStyleFileList
);
1604 if ((*ListHead
)->Link
.ForwardLink
== (*ListHead
)->Link
.BackLink
&& (*ListHead
)->Link
.BackLink
== &((*ListHead
)->Link
)) {
1605 FreePool(*ListHead
);
1607 Status
= EFI_NOT_FOUND
;
1609 FreePool(CleanFilePathStr
);
1613 FreePool(CleanFilePathStr
);
1614 return (EFI_UNSUPPORTED
);
1617 Free the linked list returned from ShellOpenFileMetaArg.
1619 if ListHead is NULL then ASSERT().
1621 @param ListHead the pointer to free.
1623 @retval EFI_SUCCESS the operation was sucessful.
1627 ShellCloseFileMetaArg (
1628 IN OUT EFI_SHELL_FILE_INFO
**ListHead
1634 // ASSERT that ListHead is not NULL
1636 ASSERT(ListHead
!= NULL
);
1639 // Check for UEFI Shell 2.0 protocols
1641 if (gEfiShellProtocol
!= NULL
) {
1642 return (gEfiShellProtocol
->FreeFileList(ListHead
));
1643 } else if (mEfiShellEnvironment2
!= NULL
) {
1645 // Since this is EFI Shell version we need to free our internally made copy
1648 for ( Node
= GetFirstNode(&(*ListHead
)->Link
)
1649 ; *ListHead
!= NULL
&& !IsListEmpty(&(*ListHead
)->Link
)
1650 ; Node
= GetFirstNode(&(*ListHead
)->Link
)) {
1651 RemoveEntryList(Node
);
1652 ((EFI_FILE_PROTOCOL
*)((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
)->Handle
)->Close(((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
)->Handle
);
1653 FreePool(((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
)->FullName
);
1654 FreePool(((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
)->FileName
);
1655 FreePool(((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
)->Info
);
1656 FreePool((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
);
1658 SHELL_FREE_NON_NULL(*ListHead
);
1662 return (EFI_UNSUPPORTED
);
1666 Find a file by searching the CWD and then the path.
1668 If FileName is NULL then ASSERT.
1670 If the return value is not NULL then the memory must be caller freed.
1672 @param FileName Filename string.
1674 @retval NULL the file was not found
1675 @return !NULL the full path to the file.
1680 IN CONST CHAR16
*FileName
1684 SHELL_FILE_HANDLE Handle
;
1688 CONST CHAR16
*Walker
;
1695 // First make sure its not an absolute path.
1697 Status
= ShellOpenFileByName(FileName
, &Handle
, EFI_FILE_MODE_READ
, 0);
1698 if (!EFI_ERROR(Status
)){
1699 if (FileHandleIsDirectory(Handle
) != EFI_SUCCESS
) {
1700 ASSERT(RetVal
== NULL
);
1701 RetVal
= StrnCatGrow(&RetVal
, NULL
, FileName
, 0);
1702 ShellCloseFile(&Handle
);
1705 ShellCloseFile(&Handle
);
1709 Path
= ShellGetEnvironmentVariable(L
"cwd");
1711 Size
= StrSize(Path
);
1712 Size
+= StrSize(FileName
);
1713 TestPath
= AllocateZeroPool(Size
);
1714 if (TestPath
== NULL
) {
1717 StrCpyS(TestPath
, Size
/sizeof(CHAR16
), Path
);
1718 StrCatS(TestPath
, Size
/sizeof(CHAR16
), FileName
);
1719 Status
= ShellOpenFileByName(TestPath
, &Handle
, EFI_FILE_MODE_READ
, 0);
1720 if (!EFI_ERROR(Status
)){
1721 if (FileHandleIsDirectory(Handle
) != EFI_SUCCESS
) {
1722 ASSERT(RetVal
== NULL
);
1723 RetVal
= StrnCatGrow(&RetVal
, NULL
, TestPath
, 0);
1724 ShellCloseFile(&Handle
);
1728 ShellCloseFile(&Handle
);
1733 Path
= ShellGetEnvironmentVariable(L
"path");
1735 Size
= StrSize(Path
)+sizeof(CHAR16
);
1736 Size
+= StrSize(FileName
);
1737 TestPath
= AllocateZeroPool(Size
);
1738 if (TestPath
== NULL
) {
1741 Walker
= (CHAR16
*)Path
;
1743 CopyMem(TestPath
, Walker
, StrSize(Walker
));
1744 if (TestPath
!= NULL
) {
1745 TempChar
= StrStr(TestPath
, L
";");
1746 if (TempChar
!= NULL
) {
1747 *TempChar
= CHAR_NULL
;
1749 if (TestPath
[StrLen(TestPath
)-1] != L
'\\') {
1750 StrCatS(TestPath
, Size
/sizeof(CHAR16
), L
"\\");
1752 if (FileName
[0] == L
'\\') {
1755 StrCatS(TestPath
, Size
/sizeof(CHAR16
), FileName
);
1756 if (StrStr(Walker
, L
";") != NULL
) {
1757 Walker
= StrStr(Walker
, L
";") + 1;
1761 Status
= ShellOpenFileByName(TestPath
, &Handle
, EFI_FILE_MODE_READ
, 0);
1762 if (!EFI_ERROR(Status
)){
1763 if (FileHandleIsDirectory(Handle
) != EFI_SUCCESS
) {
1764 ASSERT(RetVal
== NULL
);
1765 RetVal
= StrnCatGrow(&RetVal
, NULL
, TestPath
, 0);
1766 ShellCloseFile(&Handle
);
1769 ShellCloseFile(&Handle
);
1773 } while (Walker
!= NULL
&& Walker
[0] != CHAR_NULL
);
1780 Find a file by searching the CWD and then the path with a variable set of file
1781 extensions. If the file is not found it will append each extension in the list
1782 in the order provided and return the first one that is successful.
1784 If FileName is NULL, then ASSERT.
1785 If FileExtension is NULL, then behavior is identical to ShellFindFilePath.
1787 If the return value is not NULL then the memory must be caller freed.
1789 @param[in] FileName Filename string.
1790 @param[in] FileExtension Semi-colon delimeted list of possible extensions.
1792 @retval NULL The file was not found.
1793 @retval !NULL The path to the file.
1797 ShellFindFilePathEx (
1798 IN CONST CHAR16
*FileName
,
1799 IN CONST CHAR16
*FileExtension
1804 CONST CHAR16
*ExtensionWalker
;
1809 ASSERT(FileName
!= NULL
);
1810 if (FileExtension
== NULL
) {
1811 return (ShellFindFilePath(FileName
));
1813 RetVal
= ShellFindFilePath(FileName
);
1814 if (RetVal
!= NULL
) {
1817 Size
= StrSize(FileName
);
1818 Size
+= StrSize(FileExtension
);
1819 TestPath
= AllocateZeroPool(Size
);
1820 if (TestPath
== NULL
) {
1823 for (ExtensionWalker
= FileExtension
, TempChar2
= (CHAR16
*)FileExtension
; TempChar2
!= NULL
; ExtensionWalker
= TempChar2
+ 1){
1824 StrCpyS(TestPath
, Size
/sizeof(CHAR16
), FileName
);
1825 if (ExtensionWalker
!= NULL
) {
1826 StrCatS(TestPath
, Size
/sizeof(CHAR16
), ExtensionWalker
);
1828 TempChar
= StrStr(TestPath
, L
";");
1829 if (TempChar
!= NULL
) {
1830 *TempChar
= CHAR_NULL
;
1832 RetVal
= ShellFindFilePath(TestPath
);
1833 if (RetVal
!= NULL
) {
1836 ASSERT(ExtensionWalker
!= NULL
);
1837 TempChar2
= StrStr(ExtensionWalker
, L
";");
1846 SHELL_PARAM_TYPE Type
;
1848 UINTN OriginalPosition
;
1849 } SHELL_PARAM_PACKAGE
;
1852 Checks the list of valid arguments and returns TRUE if the item was found. If the
1853 return value is TRUE then the type parameter is set also.
1855 if CheckList is NULL then ASSERT();
1856 if Name is NULL then ASSERT();
1857 if Type is NULL then ASSERT();
1859 @param Name pointer to Name of parameter found
1860 @param CheckList List to check against
1861 @param Type pointer to type of parameter if it was found
1863 @retval TRUE the Parameter was found. Type is valid.
1864 @retval FALSE the Parameter was not found. Type is not valid.
1868 InternalIsOnCheckList (
1869 IN CONST CHAR16
*Name
,
1870 IN CONST SHELL_PARAM_ITEM
*CheckList
,
1871 OUT SHELL_PARAM_TYPE
*Type
1874 SHELL_PARAM_ITEM
*TempListItem
;
1878 // ASSERT that all 3 pointer parameters aren't NULL
1880 ASSERT(CheckList
!= NULL
);
1881 ASSERT(Type
!= NULL
);
1882 ASSERT(Name
!= NULL
);
1885 // question mark and page break mode are always supported
1887 if ((StrCmp(Name
, L
"-?") == 0) ||
1888 (StrCmp(Name
, L
"-b") == 0)
1895 // Enumerate through the list
1897 for (TempListItem
= (SHELL_PARAM_ITEM
*)CheckList
; TempListItem
->Name
!= NULL
; TempListItem
++) {
1899 // If the Type is TypeStart only check the first characters of the passed in param
1900 // If it matches set the type and return TRUE
1902 if (TempListItem
->Type
== TypeStart
) {
1903 if (StrnCmp(Name
, TempListItem
->Name
, StrLen(TempListItem
->Name
)) == 0) {
1904 *Type
= TempListItem
->Type
;
1908 TempString
= StrnCatGrow(&TempString
, NULL
, Name
, StrLen(TempListItem
->Name
));
1909 if (TempString
!= NULL
) {
1910 if (StringNoCaseCompare(&TempString
, &TempListItem
->Name
) == 0) {
1911 *Type
= TempListItem
->Type
;
1912 FreePool(TempString
);
1915 FreePool(TempString
);
1917 } else if (StringNoCaseCompare(&Name
, &TempListItem
->Name
) == 0) {
1918 *Type
= TempListItem
->Type
;
1926 Checks the string for indicators of "flag" status. this is a leading '/', '-', or '+'
1928 @param[in] Name pointer to Name of parameter found
1929 @param[in] AlwaysAllowNumbers TRUE to allow numbers, FALSE to not.
1930 @param[in] TimeNumbers TRUE to allow numbers with ":", FALSE otherwise.
1932 @retval TRUE the Parameter is a flag.
1933 @retval FALSE the Parameter not a flag.
1938 IN CONST CHAR16
*Name
,
1939 IN CONST BOOLEAN AlwaysAllowNumbers
,
1940 IN CONST BOOLEAN TimeNumbers
1944 // ASSERT that Name isn't NULL
1946 ASSERT(Name
!= NULL
);
1949 // If we accept numbers then dont return TRUE. (they will be values)
1951 if (((Name
[0] == L
'-' || Name
[0] == L
'+') && InternalShellIsHexOrDecimalNumber(Name
+1, FALSE
, FALSE
, TimeNumbers
)) && AlwaysAllowNumbers
) {
1956 // If the Name has a /, +, or - as the first character return TRUE
1958 if ((Name
[0] == L
'/') ||
1959 (Name
[0] == L
'-') ||
1968 Checks the command line arguments passed against the list of valid ones.
1970 If no initialization is required, then return RETURN_SUCCESS.
1972 @param[in] CheckList pointer to list of parameters to check
1973 @param[out] CheckPackage pointer to pointer to list checked values
1974 @param[out] ProblemParam optional pointer to pointer to unicode string for
1975 the paramater that caused failure. If used then the
1976 caller is responsible for freeing the memory.
1977 @param[in] AutoPageBreak will automatically set PageBreakEnabled for "b" parameter
1978 @param[in] Argv pointer to array of parameters
1979 @param[in] Argc Count of parameters in Argv
1980 @param[in] AlwaysAllowNumbers TRUE to allow numbers always, FALSE otherwise.
1982 @retval EFI_SUCCESS The operation completed sucessfully.
1983 @retval EFI_OUT_OF_RESOURCES A memory allocation failed
1984 @retval EFI_INVALID_PARAMETER A parameter was invalid
1985 @retval EFI_VOLUME_CORRUPTED the command line was corrupt. an argument was
1986 duplicated. the duplicated command line argument
1987 was returned in ProblemParam if provided.
1988 @retval EFI_NOT_FOUND a argument required a value that was missing.
1989 the invalid command line argument was returned in
1990 ProblemParam if provided.
1994 InternalCommandLineParse (
1995 IN CONST SHELL_PARAM_ITEM
*CheckList
,
1996 OUT LIST_ENTRY
**CheckPackage
,
1997 OUT CHAR16
**ProblemParam OPTIONAL
,
1998 IN BOOLEAN AutoPageBreak
,
1999 IN CONST CHAR16
**Argv
,
2001 IN BOOLEAN AlwaysAllowNumbers
2005 SHELL_PARAM_TYPE CurrentItemType
;
2006 SHELL_PARAM_PACKAGE
*CurrentItemPackage
;
2010 CONST CHAR16
*TempPointer
;
2011 UINTN CurrentValueSize
;
2013 CurrentItemPackage
= NULL
;
2019 // If there is only 1 item we dont need to do anything
2022 *CheckPackage
= NULL
;
2023 return (EFI_SUCCESS
);
2029 ASSERT(CheckList
!= NULL
);
2030 ASSERT(Argv
!= NULL
);
2033 // initialize the linked list
2035 *CheckPackage
= (LIST_ENTRY
*)AllocateZeroPool(sizeof(LIST_ENTRY
));
2036 if (*CheckPackage
== NULL
) {
2037 return (EFI_OUT_OF_RESOURCES
);
2040 InitializeListHead(*CheckPackage
);
2043 // loop through each of the arguments
2045 for (LoopCounter
= 0 ; LoopCounter
< Argc
; ++LoopCounter
) {
2046 if (Argv
[LoopCounter
] == NULL
) {
2048 // do nothing for NULL argv
2050 } else if (InternalIsOnCheckList(Argv
[LoopCounter
], CheckList
, &CurrentItemType
)) {
2052 // We might have leftover if last parameter didnt have optional value
2054 if (GetItemValue
!= 0) {
2056 InsertHeadList(*CheckPackage
, &CurrentItemPackage
->Link
);
2061 CurrentItemPackage
= AllocateZeroPool(sizeof(SHELL_PARAM_PACKAGE
));
2062 if (CurrentItemPackage
== NULL
) {
2063 ShellCommandLineFreeVarList(*CheckPackage
);
2064 *CheckPackage
= NULL
;
2065 return (EFI_OUT_OF_RESOURCES
);
2067 CurrentItemPackage
->Name
= AllocateCopyPool(StrSize(Argv
[LoopCounter
]), Argv
[LoopCounter
]);
2068 if (CurrentItemPackage
->Name
== NULL
) {
2069 ShellCommandLineFreeVarList(*CheckPackage
);
2070 *CheckPackage
= NULL
;
2071 return (EFI_OUT_OF_RESOURCES
);
2073 CurrentItemPackage
->Type
= CurrentItemType
;
2074 CurrentItemPackage
->OriginalPosition
= (UINTN
)(-1);
2075 CurrentItemPackage
->Value
= NULL
;
2078 // Does this flag require a value
2080 switch (CurrentItemPackage
->Type
) {
2082 // possibly trigger the next loop(s) to populate the value of this item
2089 case TypeDoubleValue
:
2094 GetItemValue
= (UINTN
)(-1);
2099 // this item has no value expected; we are done
2101 InsertHeadList(*CheckPackage
, &CurrentItemPackage
->Link
);
2102 ASSERT(GetItemValue
== 0);
2105 } else if (GetItemValue
!= 0 && CurrentItemPackage
!= NULL
&& !InternalIsFlag(Argv
[LoopCounter
], AlwaysAllowNumbers
, (BOOLEAN
)(CurrentItemPackage
->Type
== TypeTimeValue
))) {
2107 // get the item VALUE for a previous flag
2109 CurrentValueSize
= ValueSize
+ StrSize(Argv
[LoopCounter
]) + sizeof(CHAR16
);
2110 CurrentItemPackage
->Value
= ReallocatePool(ValueSize
, CurrentValueSize
, CurrentItemPackage
->Value
);
2111 ASSERT(CurrentItemPackage
->Value
!= NULL
);
2112 if (ValueSize
== 0) {
2113 StrCpyS( CurrentItemPackage
->Value
,
2114 CurrentValueSize
/sizeof(CHAR16
),
2118 StrCatS( CurrentItemPackage
->Value
,
2119 CurrentValueSize
/sizeof(CHAR16
),
2122 StrCatS( CurrentItemPackage
->Value
,
2123 CurrentValueSize
/sizeof(CHAR16
),
2127 ValueSize
+= StrSize(Argv
[LoopCounter
]) + sizeof(CHAR16
);
2130 if (GetItemValue
== 0) {
2131 InsertHeadList(*CheckPackage
, &CurrentItemPackage
->Link
);
2133 } else if (!InternalIsFlag(Argv
[LoopCounter
], AlwaysAllowNumbers
, FALSE
)){
2135 // add this one as a non-flag
2138 TempPointer
= Argv
[LoopCounter
];
2139 if ((*TempPointer
== L
'^' && *(TempPointer
+1) == L
'-')
2140 || (*TempPointer
== L
'^' && *(TempPointer
+1) == L
'/')
2141 || (*TempPointer
== L
'^' && *(TempPointer
+1) == L
'+')
2145 CurrentItemPackage
= AllocateZeroPool(sizeof(SHELL_PARAM_PACKAGE
));
2146 if (CurrentItemPackage
== NULL
) {
2147 ShellCommandLineFreeVarList(*CheckPackage
);
2148 *CheckPackage
= NULL
;
2149 return (EFI_OUT_OF_RESOURCES
);
2151 CurrentItemPackage
->Name
= NULL
;
2152 CurrentItemPackage
->Type
= TypePosition
;
2153 CurrentItemPackage
->Value
= AllocateCopyPool(StrSize(TempPointer
), TempPointer
);
2154 if (CurrentItemPackage
->Value
== NULL
) {
2155 ShellCommandLineFreeVarList(*CheckPackage
);
2156 *CheckPackage
= NULL
;
2157 return (EFI_OUT_OF_RESOURCES
);
2159 CurrentItemPackage
->OriginalPosition
= Count
++;
2160 InsertHeadList(*CheckPackage
, &CurrentItemPackage
->Link
);
2163 // this was a non-recognised flag... error!
2165 if (ProblemParam
!= NULL
) {
2166 *ProblemParam
= AllocateCopyPool(StrSize(Argv
[LoopCounter
]), Argv
[LoopCounter
]);
2168 ShellCommandLineFreeVarList(*CheckPackage
);
2169 *CheckPackage
= NULL
;
2170 return (EFI_VOLUME_CORRUPTED
);
2173 if (GetItemValue
!= 0) {
2175 InsertHeadList(*CheckPackage
, &CurrentItemPackage
->Link
);
2178 // support for AutoPageBreak
2180 if (AutoPageBreak
&& ShellCommandLineGetFlag(*CheckPackage
, L
"-b")) {
2181 ShellSetPageBreakMode(TRUE
);
2183 return (EFI_SUCCESS
);
2187 Checks the command line arguments passed against the list of valid ones.
2188 Optionally removes NULL values first.
2190 If no initialization is required, then return RETURN_SUCCESS.
2192 @param[in] CheckList The pointer to list of parameters to check.
2193 @param[out] CheckPackage The package of checked values.
2194 @param[out] ProblemParam Optional pointer to pointer to unicode string for
2195 the paramater that caused failure.
2196 @param[in] AutoPageBreak Will automatically set PageBreakEnabled.
2197 @param[in] AlwaysAllowNumbers Will never fail for number based flags.
2199 @retval EFI_SUCCESS The operation completed sucessfully.
2200 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
2201 @retval EFI_INVALID_PARAMETER A parameter was invalid.
2202 @retval EFI_VOLUME_CORRUPTED The command line was corrupt.
2203 @retval EFI_DEVICE_ERROR The commands contained 2 opposing arguments. One
2204 of the command line arguments was returned in
2205 ProblemParam if provided.
2206 @retval EFI_NOT_FOUND A argument required a value that was missing.
2207 The invalid command line argument was returned in
2208 ProblemParam if provided.
2212 ShellCommandLineParseEx (
2213 IN CONST SHELL_PARAM_ITEM
*CheckList
,
2214 OUT LIST_ENTRY
**CheckPackage
,
2215 OUT CHAR16
**ProblemParam OPTIONAL
,
2216 IN BOOLEAN AutoPageBreak
,
2217 IN BOOLEAN AlwaysAllowNumbers
2221 // ASSERT that CheckList and CheckPackage aren't NULL
2223 ASSERT(CheckList
!= NULL
);
2224 ASSERT(CheckPackage
!= NULL
);
2227 // Check for UEFI Shell 2.0 protocols
2229 if (gEfiShellParametersProtocol
!= NULL
) {
2230 return (InternalCommandLineParse(CheckList
,
2234 (CONST CHAR16
**) gEfiShellParametersProtocol
->Argv
,
2235 gEfiShellParametersProtocol
->Argc
,
2236 AlwaysAllowNumbers
));
2240 // ASSERT That EFI Shell is not required
2242 ASSERT (mEfiShellInterface
!= NULL
);
2243 return (InternalCommandLineParse(CheckList
,
2247 (CONST CHAR16
**) mEfiShellInterface
->Argv
,
2248 mEfiShellInterface
->Argc
,
2249 AlwaysAllowNumbers
));
2253 Frees shell variable list that was returned from ShellCommandLineParse.
2255 This function will free all the memory that was used for the CheckPackage
2256 list of postprocessed shell arguments.
2258 this function has no return value.
2260 if CheckPackage is NULL, then return
2262 @param CheckPackage the list to de-allocate
2266 ShellCommandLineFreeVarList (
2267 IN LIST_ENTRY
*CheckPackage
2273 // check for CheckPackage == NULL
2275 if (CheckPackage
== NULL
) {
2280 // for each node in the list
2282 for ( Node
= GetFirstNode(CheckPackage
)
2283 ; !IsListEmpty(CheckPackage
)
2284 ; Node
= GetFirstNode(CheckPackage
)
2287 // Remove it from the list
2289 RemoveEntryList(Node
);
2292 // if it has a name free the name
2294 if (((SHELL_PARAM_PACKAGE
*)Node
)->Name
!= NULL
) {
2295 FreePool(((SHELL_PARAM_PACKAGE
*)Node
)->Name
);
2299 // if it has a value free the value
2301 if (((SHELL_PARAM_PACKAGE
*)Node
)->Value
!= NULL
) {
2302 FreePool(((SHELL_PARAM_PACKAGE
*)Node
)->Value
);
2306 // free the node structure
2308 FreePool((SHELL_PARAM_PACKAGE
*)Node
);
2311 // free the list head node
2313 FreePool(CheckPackage
);
2316 Checks for presence of a flag parameter
2318 flag arguments are in the form of "-<Key>" or "/<Key>", but do not have a value following the key
2320 if CheckPackage is NULL then return FALSE.
2321 if KeyString is NULL then ASSERT()
2323 @param CheckPackage The package of parsed command line arguments
2324 @param KeyString the Key of the command line argument to check for
2326 @retval TRUE the flag is on the command line
2327 @retval FALSE the flag is not on the command line
2331 ShellCommandLineGetFlag (
2332 IN CONST LIST_ENTRY
* CONST CheckPackage
,
2333 IN CONST CHAR16
* CONST KeyString
2340 // return FALSE for no package or KeyString is NULL
2342 if (CheckPackage
== NULL
|| KeyString
== NULL
) {
2347 // enumerate through the list of parametrs
2349 for ( Node
= GetFirstNode(CheckPackage
)
2350 ; !IsNull (CheckPackage
, Node
)
2351 ; Node
= GetNextNode(CheckPackage
, Node
)
2354 // If the Name matches, return TRUE (and there may be NULL name)
2356 if (((SHELL_PARAM_PACKAGE
*)Node
)->Name
!= NULL
) {
2358 // If Type is TypeStart then only compare the begining of the strings
2360 if (((SHELL_PARAM_PACKAGE
*)Node
)->Type
== TypeStart
) {
2361 if (StrnCmp(KeyString
, ((SHELL_PARAM_PACKAGE
*)Node
)->Name
, StrLen(KeyString
)) == 0) {
2365 TempString
= StrnCatGrow(&TempString
, NULL
, KeyString
, StrLen(((SHELL_PARAM_PACKAGE
*)Node
)->Name
));
2366 if (TempString
!= NULL
) {
2367 if (StringNoCaseCompare(&KeyString
, &((SHELL_PARAM_PACKAGE
*)Node
)->Name
) == 0) {
2368 FreePool(TempString
);
2371 FreePool(TempString
);
2373 } else if (StringNoCaseCompare(&KeyString
, &((SHELL_PARAM_PACKAGE
*)Node
)->Name
) == 0) {
2381 Returns value from command line argument.
2383 Value parameters are in the form of "-<Key> value" or "/<Key> value".
2385 If CheckPackage is NULL, then return NULL.
2387 @param[in] CheckPackage The package of parsed command line arguments.
2388 @param[in] KeyString The Key of the command line argument to check for.
2390 @retval NULL The flag is not on the command line.
2391 @retval !=NULL The pointer to unicode string of the value.
2395 ShellCommandLineGetValue (
2396 IN CONST LIST_ENTRY
*CheckPackage
,
2397 IN CHAR16
*KeyString
2404 // return NULL for no package or KeyString is NULL
2406 if (CheckPackage
== NULL
|| KeyString
== NULL
) {
2411 // enumerate through the list of parametrs
2413 for ( Node
= GetFirstNode(CheckPackage
)
2414 ; !IsNull (CheckPackage
, Node
)
2415 ; Node
= GetNextNode(CheckPackage
, Node
)
2418 // If the Name matches, return TRUE (and there may be NULL name)
2420 if (((SHELL_PARAM_PACKAGE
*)Node
)->Name
!= NULL
) {
2422 // If Type is TypeStart then only compare the begining of the strings
2424 if (((SHELL_PARAM_PACKAGE
*)Node
)->Type
== TypeStart
) {
2425 if (StrnCmp(KeyString
, ((SHELL_PARAM_PACKAGE
*)Node
)->Name
, StrLen(KeyString
)) == 0) {
2426 return (((SHELL_PARAM_PACKAGE
*)Node
)->Name
+ StrLen(KeyString
));
2429 TempString
= StrnCatGrow(&TempString
, NULL
, KeyString
, StrLen(((SHELL_PARAM_PACKAGE
*)Node
)->Name
));
2430 if (TempString
!= NULL
) {
2431 if (StringNoCaseCompare(&KeyString
, &((SHELL_PARAM_PACKAGE
*)Node
)->Name
) == 0) {
2432 FreePool(TempString
);
2433 return (((SHELL_PARAM_PACKAGE
*)Node
)->Name
+ StrLen(KeyString
));
2435 FreePool(TempString
);
2437 } else if (StringNoCaseCompare(&KeyString
, &((SHELL_PARAM_PACKAGE
*)Node
)->Name
) == 0) {
2438 return (((SHELL_PARAM_PACKAGE
*)Node
)->Value
);
2446 Returns raw value from command line argument.
2448 Raw value parameters are in the form of "value" in a specific position in the list.
2450 If CheckPackage is NULL, then return NULL.
2452 @param[in] CheckPackage The package of parsed command line arguments.
2453 @param[in] Position The position of the value.
2455 @retval NULL The flag is not on the command line.
2456 @retval !=NULL The pointer to unicode string of the value.
2460 ShellCommandLineGetRawValue (
2461 IN CONST LIST_ENTRY
* CONST CheckPackage
,
2468 // check for CheckPackage == NULL
2470 if (CheckPackage
== NULL
) {
2475 // enumerate through the list of parametrs
2477 for ( Node
= GetFirstNode(CheckPackage
)
2478 ; !IsNull (CheckPackage
, Node
)
2479 ; Node
= GetNextNode(CheckPackage
, Node
)
2482 // If the position matches, return the value
2484 if (((SHELL_PARAM_PACKAGE
*)Node
)->OriginalPosition
== Position
) {
2485 return (((SHELL_PARAM_PACKAGE
*)Node
)->Value
);
2492 returns the number of command line value parameters that were parsed.
2494 this will not include flags.
2496 @param[in] CheckPackage The package of parsed command line arguments.
2498 @retval (UINTN)-1 No parsing has ocurred
2499 @return other The number of value parameters found
2503 ShellCommandLineGetCount(
2504 IN CONST LIST_ENTRY
*CheckPackage
2510 if (CheckPackage
== NULL
) {
2513 for ( Node1
= GetFirstNode(CheckPackage
), Count
= 0
2514 ; !IsNull (CheckPackage
, Node1
)
2515 ; Node1
= GetNextNode(CheckPackage
, Node1
)
2517 if (((SHELL_PARAM_PACKAGE
*)Node1
)->Name
== NULL
) {
2525 Determines if a parameter is duplicated.
2527 If Param is not NULL then it will point to a callee allocated string buffer
2528 with the parameter value if a duplicate is found.
2530 If CheckPackage is NULL, then ASSERT.
2532 @param[in] CheckPackage The package of parsed command line arguments.
2533 @param[out] Param Upon finding one, a pointer to the duplicated parameter.
2535 @retval EFI_SUCCESS No parameters were duplicated.
2536 @retval EFI_DEVICE_ERROR A duplicate was found.
2540 ShellCommandLineCheckDuplicate (
2541 IN CONST LIST_ENTRY
*CheckPackage
,
2548 ASSERT(CheckPackage
!= NULL
);
2550 for ( Node1
= GetFirstNode(CheckPackage
)
2551 ; !IsNull (CheckPackage
, Node1
)
2552 ; Node1
= GetNextNode(CheckPackage
, Node1
)
2554 for ( Node2
= GetNextNode(CheckPackage
, Node1
)
2555 ; !IsNull (CheckPackage
, Node2
)
2556 ; Node2
= GetNextNode(CheckPackage
, Node2
)
2558 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) {
2559 if (Param
!= NULL
) {
2561 *Param
= StrnCatGrow(Param
, NULL
, ((SHELL_PARAM_PACKAGE
*)Node1
)->Name
, 0);
2563 return (EFI_DEVICE_ERROR
);
2567 return (EFI_SUCCESS
);
2571 This is a find and replace function. Upon successful return the NewString is a copy of
2572 SourceString with each instance of FindTarget replaced with ReplaceWith.
2574 If SourceString and NewString overlap the behavior is undefined.
2576 If the string would grow bigger than NewSize it will halt and return error.
2578 @param[in] SourceString The string with source buffer.
2579 @param[in, out] NewString The string with resultant buffer.
2580 @param[in] NewSize The size in bytes of NewString.
2581 @param[in] FindTarget The string to look for.
2582 @param[in] ReplaceWith The string to replace FindTarget with.
2583 @param[in] SkipPreCarrot If TRUE will skip a FindTarget that has a '^'
2584 immediately before it.
2585 @param[in] ParameterReplacing If TRUE will add "" around items with spaces.
2587 @retval EFI_INVALID_PARAMETER SourceString was NULL.
2588 @retval EFI_INVALID_PARAMETER NewString was NULL.
2589 @retval EFI_INVALID_PARAMETER FindTarget was NULL.
2590 @retval EFI_INVALID_PARAMETER ReplaceWith was NULL.
2591 @retval EFI_INVALID_PARAMETER FindTarget had length < 1.
2592 @retval EFI_INVALID_PARAMETER SourceString had length < 1.
2593 @retval EFI_BUFFER_TOO_SMALL NewSize was less than the minimum size to hold
2594 the new string (truncation occurred).
2595 @retval EFI_SUCCESS The string was successfully copied with replacement.
2599 ShellCopySearchAndReplace(
2600 IN CHAR16 CONST
*SourceString
,
2601 IN OUT CHAR16
*NewString
,
2603 IN CONST CHAR16
*FindTarget
,
2604 IN CONST CHAR16
*ReplaceWith
,
2605 IN CONST BOOLEAN SkipPreCarrot
,
2606 IN CONST BOOLEAN ParameterReplacing
2612 if ( (SourceString
== NULL
)
2613 || (NewString
== NULL
)
2614 || (FindTarget
== NULL
)
2615 || (ReplaceWith
== NULL
)
2616 || (StrLen(FindTarget
) < 1)
2617 || (StrLen(SourceString
) < 1)
2619 return (EFI_INVALID_PARAMETER
);
2622 if (StrStr(ReplaceWith
, L
" ") == NULL
|| !ParameterReplacing
) {
2623 Replace
= StrnCatGrow(&Replace
, NULL
, ReplaceWith
, 0);
2625 Replace
= AllocateZeroPool(StrSize(ReplaceWith
) + 2*sizeof(CHAR16
));
2626 if (Replace
!= NULL
) {
2627 UnicodeSPrint(Replace
, StrSize(ReplaceWith
) + 2*sizeof(CHAR16
), L
"\"%s\"", ReplaceWith
);
2630 if (Replace
== NULL
) {
2631 return (EFI_OUT_OF_RESOURCES
);
2633 NewString
= ZeroMem(NewString
, NewSize
);
2634 while (*SourceString
!= CHAR_NULL
) {
2636 // if we find the FindTarget and either Skip == FALSE or Skip and we
2637 // dont have a carrot do a replace...
2639 if (StrnCmp(SourceString
, FindTarget
, StrLen(FindTarget
)) == 0
2640 && ((SkipPreCarrot
&& *(SourceString
-1) != L
'^') || !SkipPreCarrot
)
2642 SourceString
+= StrLen(FindTarget
);
2643 Size
= StrSize(NewString
);
2644 if ((Size
+ (StrLen(Replace
)*sizeof(CHAR16
))) > NewSize
) {
2646 return (EFI_BUFFER_TOO_SMALL
);
2648 StrCatS(NewString
, NewSize
/sizeof(CHAR16
), Replace
);
2650 Size
= StrSize(NewString
);
2651 if (Size
+ sizeof(CHAR16
) > NewSize
) {
2653 return (EFI_BUFFER_TOO_SMALL
);
2655 StrnCatS(NewString
, NewSize
/sizeof(CHAR16
), SourceString
, 1);
2660 return (EFI_SUCCESS
);
2664 Internal worker function to output a string.
2666 This function will output a string to the correct StdOut.
2668 @param[in] String The string to print out.
2670 @retval EFI_SUCCESS The operation was sucessful.
2671 @retval !EFI_SUCCESS The operation failed.
2676 IN CONST CHAR16
*String
2680 Size
= StrSize(String
) - sizeof(CHAR16
);
2682 return (EFI_SUCCESS
);
2684 if (gEfiShellParametersProtocol
!= NULL
) {
2685 return (gEfiShellProtocol
->WriteFile(gEfiShellParametersProtocol
->StdOut
, &Size
, (VOID
*)String
));
2687 if (mEfiShellInterface
!= NULL
) {
2688 if (mEfiShellInterface
->RedirArgc
== 0) {
2690 // Divide in half for old shell. Must be string length not size.
2692 Size
/=2; // Divide in half only when no redirection.
2694 return (mEfiShellInterface
->StdOut
->Write(mEfiShellInterface
->StdOut
, &Size
, (VOID
*)String
));
2697 return (EFI_UNSUPPORTED
);
2701 Print at a specific location on the screen.
2703 This function will move the cursor to a given screen location and print the specified string
2705 If -1 is specified for either the Row or Col the current screen location for BOTH
2708 if either Row or Col is out of range for the current console, then ASSERT
2709 if Format is NULL, then ASSERT
2711 In addition to the standard %-based flags as supported by UefiLib Print() this supports
2712 the following additional flags:
2713 %N - Set output attribute to normal
2714 %H - Set output attribute to highlight
2715 %E - Set output attribute to error
2716 %B - Set output attribute to blue color
2717 %V - Set output attribute to green color
2719 Note: The background color is controlled by the shell command cls.
2721 @param[in] Col the column to print at
2722 @param[in] Row the row to print at
2723 @param[in] Format the format string
2724 @param[in] Marker the marker for the variable argument list
2726 @return EFI_SUCCESS The operation was successful.
2727 @return EFI_DEVICE_ERROR The console device reported an error.
2731 InternalShellPrintWorker(
2732 IN INT32 Col OPTIONAL
,
2733 IN INT32 Row OPTIONAL
,
2734 IN CONST CHAR16
*Format
,
2739 CHAR16
*ResumeLocation
;
2740 CHAR16
*FormatWalker
;
2741 UINTN OriginalAttribute
;
2742 CHAR16
*mPostReplaceFormat
;
2743 CHAR16
*mPostReplaceFormat2
;
2745 mPostReplaceFormat
= AllocateZeroPool (PcdGet16 (PcdShellPrintBufferSize
));
2746 mPostReplaceFormat2
= AllocateZeroPool (PcdGet16 (PcdShellPrintBufferSize
));
2748 if (mPostReplaceFormat
== NULL
|| mPostReplaceFormat2
== NULL
) {
2749 SHELL_FREE_NON_NULL(mPostReplaceFormat
);
2750 SHELL_FREE_NON_NULL(mPostReplaceFormat2
);
2751 return (EFI_OUT_OF_RESOURCES
);
2754 Status
= EFI_SUCCESS
;
2755 OriginalAttribute
= gST
->ConOut
->Mode
->Attribute
;
2758 // Back and forth each time fixing up 1 of our flags...
2760 Status
= ShellCopySearchAndReplace(Format
, mPostReplaceFormat
, PcdGet16 (PcdShellPrintBufferSize
), L
"%N", L
"%%N", FALSE
, FALSE
);
2761 ASSERT_EFI_ERROR(Status
);
2762 Status
= ShellCopySearchAndReplace(mPostReplaceFormat
, mPostReplaceFormat2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%E", L
"%%E", FALSE
, FALSE
);
2763 ASSERT_EFI_ERROR(Status
);
2764 Status
= ShellCopySearchAndReplace(mPostReplaceFormat2
, mPostReplaceFormat
, PcdGet16 (PcdShellPrintBufferSize
), L
"%H", L
"%%H", FALSE
, FALSE
);
2765 ASSERT_EFI_ERROR(Status
);
2766 Status
= ShellCopySearchAndReplace(mPostReplaceFormat
, mPostReplaceFormat2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%B", L
"%%B", FALSE
, FALSE
);
2767 ASSERT_EFI_ERROR(Status
);
2768 Status
= ShellCopySearchAndReplace(mPostReplaceFormat2
, mPostReplaceFormat
, PcdGet16 (PcdShellPrintBufferSize
), L
"%V", L
"%%V", FALSE
, FALSE
);
2769 ASSERT_EFI_ERROR(Status
);
2772 // Use the last buffer from replacing to print from...
2774 UnicodeVSPrint (mPostReplaceFormat2
, PcdGet16 (PcdShellPrintBufferSize
), mPostReplaceFormat
, Marker
);
2776 if (Col
!= -1 && Row
!= -1) {
2777 Status
= gST
->ConOut
->SetCursorPosition(gST
->ConOut
, Col
, Row
);
2780 FormatWalker
= mPostReplaceFormat2
;
2781 while (*FormatWalker
!= CHAR_NULL
) {
2783 // Find the next attribute change request
2785 ResumeLocation
= StrStr(FormatWalker
, L
"%");
2786 if (ResumeLocation
!= NULL
) {
2787 *ResumeLocation
= CHAR_NULL
;
2790 // print the current FormatWalker string
2792 if (StrLen(FormatWalker
)>0) {
2793 Status
= InternalPrintTo(FormatWalker
);
2794 if (EFI_ERROR(Status
)) {
2800 // update the attribute
2802 if (ResumeLocation
!= NULL
) {
2803 if (*(ResumeLocation
-1) == L
'^') {
2805 // Move cursor back 1 position to overwrite the ^
2807 gST
->ConOut
->SetCursorPosition(gST
->ConOut
, gST
->ConOut
->Mode
->CursorColumn
- 1, gST
->ConOut
->Mode
->CursorRow
);
2810 // Print a simple '%' symbol
2812 Status
= InternalPrintTo(L
"%");
2813 ResumeLocation
= ResumeLocation
- 1;
2815 switch (*(ResumeLocation
+1)) {
2817 gST
->ConOut
->SetAttribute(gST
->ConOut
, OriginalAttribute
);
2820 gST
->ConOut
->SetAttribute(gST
->ConOut
, EFI_TEXT_ATTR(EFI_YELLOW
, ((OriginalAttribute
&(BIT4
|BIT5
|BIT6
))>>4)));
2823 gST
->ConOut
->SetAttribute(gST
->ConOut
, EFI_TEXT_ATTR(EFI_WHITE
, ((OriginalAttribute
&(BIT4
|BIT5
|BIT6
))>>4)));
2826 gST
->ConOut
->SetAttribute(gST
->ConOut
, EFI_TEXT_ATTR(EFI_BLUE
, ((OriginalAttribute
&(BIT4
|BIT5
|BIT6
))>>4)));
2829 gST
->ConOut
->SetAttribute(gST
->ConOut
, EFI_TEXT_ATTR(EFI_GREEN
, ((OriginalAttribute
&(BIT4
|BIT5
|BIT6
))>>4)));
2833 // Print a simple '%' symbol
2835 Status
= InternalPrintTo(L
"%");
2836 if (EFI_ERROR(Status
)) {
2839 ResumeLocation
= ResumeLocation
- 1;
2845 // reset to normal now...
2851 // update FormatWalker to Resume + 2 (skip the % and the indicator)
2853 FormatWalker
= ResumeLocation
+ 2;
2856 gST
->ConOut
->SetAttribute(gST
->ConOut
, OriginalAttribute
);
2858 SHELL_FREE_NON_NULL(mPostReplaceFormat
);
2859 SHELL_FREE_NON_NULL(mPostReplaceFormat2
);
2864 Print at a specific location on the screen.
2866 This function will move the cursor to a given screen location and print the specified string.
2868 If -1 is specified for either the Row or Col the current screen location for BOTH
2871 If either Row or Col is out of range for the current console, then ASSERT.
2872 If Format is NULL, then ASSERT.
2874 In addition to the standard %-based flags as supported by UefiLib Print() this supports
2875 the following additional flags:
2876 %N - Set output attribute to normal
2877 %H - Set output attribute to highlight
2878 %E - Set output attribute to error
2879 %B - Set output attribute to blue color
2880 %V - Set output attribute to green color
2882 Note: The background color is controlled by the shell command cls.
2884 @param[in] Col the column to print at
2885 @param[in] Row the row to print at
2886 @param[in] Format the format string
2887 @param[in] ... The variable argument list.
2889 @return EFI_SUCCESS The printing was successful.
2890 @return EFI_DEVICE_ERROR The console device reported an error.
2895 IN INT32 Col OPTIONAL
,
2896 IN INT32 Row OPTIONAL
,
2897 IN CONST CHAR16
*Format
,
2903 if (Format
== NULL
) {
2904 return (EFI_INVALID_PARAMETER
);
2906 VA_START (Marker
, Format
);
2907 RetVal
= InternalShellPrintWorker(Col
, Row
, Format
, Marker
);
2913 Print at a specific location on the screen.
2915 This function will move the cursor to a given screen location and print the specified string.
2917 If -1 is specified for either the Row or Col the current screen location for BOTH
2920 If either Row or Col is out of range for the current console, then ASSERT.
2921 If Format is NULL, then ASSERT.
2923 In addition to the standard %-based flags as supported by UefiLib Print() this supports
2924 the following additional flags:
2925 %N - Set output attribute to normal.
2926 %H - Set output attribute to highlight.
2927 %E - Set output attribute to error.
2928 %B - Set output attribute to blue color.
2929 %V - Set output attribute to green color.
2931 Note: The background color is controlled by the shell command cls.
2933 @param[in] Col The column to print at.
2934 @param[in] Row The row to print at.
2935 @param[in] Language The language of the string to retrieve. If this parameter
2936 is NULL, then the current platform language is used.
2937 @param[in] HiiFormatStringId The format string Id for getting from Hii.
2938 @param[in] HiiFormatHandle The format string Handle for getting from Hii.
2939 @param[in] ... The variable argument list.
2941 @return EFI_SUCCESS The printing was successful.
2942 @return EFI_DEVICE_ERROR The console device reported an error.
2947 IN INT32 Col OPTIONAL
,
2948 IN INT32 Row OPTIONAL
,
2949 IN CONST CHAR8
*Language OPTIONAL
,
2950 IN CONST EFI_STRING_ID HiiFormatStringId
,
2951 IN CONST EFI_HANDLE HiiFormatHandle
,
2956 CHAR16
*HiiFormatString
;
2959 VA_START (Marker
, HiiFormatHandle
);
2960 HiiFormatString
= HiiGetString(HiiFormatHandle
, HiiFormatStringId
, Language
);
2961 ASSERT(HiiFormatString
!= NULL
);
2963 RetVal
= InternalShellPrintWorker(Col
, Row
, HiiFormatString
, Marker
);
2965 SHELL_FREE_NON_NULL(HiiFormatString
);
2972 Function to determine if a given filename represents a file or a directory.
2974 @param[in] DirName Path to directory to test.
2976 @retval EFI_SUCCESS The Path represents a directory
2977 @retval EFI_NOT_FOUND The Path does not represent a directory
2978 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
2979 @return The path failed to open
2984 IN CONST CHAR16
*DirName
2988 SHELL_FILE_HANDLE Handle
;
2989 CHAR16
*TempLocation
;
2990 CHAR16
*TempLocation2
;
2992 ASSERT(DirName
!= NULL
);
2995 TempLocation
= NULL
;
2997 Status
= ShellOpenFileByName(DirName
, &Handle
, EFI_FILE_MODE_READ
, 0);
2998 if (EFI_ERROR(Status
)) {
3000 // try good logic first.
3002 if (gEfiShellProtocol
!= NULL
) {
3003 TempLocation
= StrnCatGrow(&TempLocation
, NULL
, DirName
, 0);
3004 if (TempLocation
== NULL
) {
3005 ShellCloseFile(&Handle
);
3006 return (EFI_OUT_OF_RESOURCES
);
3008 TempLocation2
= StrStr(TempLocation
, L
":");
3009 if (TempLocation2
!= NULL
&& StrLen(StrStr(TempLocation
, L
":")) == 2) {
3010 *(TempLocation2
+1) = CHAR_NULL
;
3012 if (gEfiShellProtocol
->GetDevicePathFromMap(TempLocation
) != NULL
) {
3013 FreePool(TempLocation
);
3014 return (EFI_SUCCESS
);
3016 FreePool(TempLocation
);
3019 // probably a map name?!?!!?
3021 TempLocation
= StrStr(DirName
, L
"\\");
3022 if (TempLocation
!= NULL
&& *(TempLocation
+1) == CHAR_NULL
) {
3023 return (EFI_SUCCESS
);
3029 if (FileHandleIsDirectory(Handle
) == EFI_SUCCESS
) {
3030 ShellCloseFile(&Handle
);
3031 return (EFI_SUCCESS
);
3033 ShellCloseFile(&Handle
);
3034 return (EFI_NOT_FOUND
);
3038 Function to determine if a given filename represents a file.
3040 @param[in] Name Path to file to test.
3042 @retval EFI_SUCCESS The Path represents a file.
3043 @retval EFI_NOT_FOUND The Path does not represent a file.
3044 @retval other The path failed to open.
3049 IN CONST CHAR16
*Name
3053 SHELL_FILE_HANDLE Handle
;
3055 ASSERT(Name
!= NULL
);
3059 Status
= ShellOpenFileByName(Name
, &Handle
, EFI_FILE_MODE_READ
, 0);
3060 if (EFI_ERROR(Status
)) {
3064 if (FileHandleIsDirectory(Handle
) != EFI_SUCCESS
) {
3065 ShellCloseFile(&Handle
);
3066 return (EFI_SUCCESS
);
3068 ShellCloseFile(&Handle
);
3069 return (EFI_NOT_FOUND
);
3073 Function to determine if a given filename represents a file.
3075 This will search the CWD and then the Path.
3077 If Name is NULL, then ASSERT.
3079 @param[in] Name Path to file to test.
3081 @retval EFI_SUCCESS The Path represents a file.
3082 @retval EFI_NOT_FOUND The Path does not represent a file.
3083 @retval other The path failed to open.
3088 IN CONST CHAR16
*Name
3094 if (!EFI_ERROR(ShellIsFile(Name
))) {
3095 return (EFI_SUCCESS
);
3098 NewName
= ShellFindFilePath(Name
);
3099 if (NewName
== NULL
) {
3100 return (EFI_NOT_FOUND
);
3102 Status
= ShellIsFile(NewName
);
3108 Function return the number converted from a hex representation of a number.
3110 Note: this function cannot be used when (UINTN)(-1), (0xFFFFFFFF) may be a valid
3111 result. Use ShellConvertStringToUint64 instead.
3113 @param[in] String String representation of a number.
3115 @return The unsigned integer result of the conversion.
3116 @retval (UINTN)(-1) An error occured.
3121 IN CONST CHAR16
*String
3126 if (!EFI_ERROR(ShellConvertStringToUint64(String
, &RetVal
, TRUE
, TRUE
))) {
3127 return ((UINTN
)RetVal
);
3130 return ((UINTN
)(-1));
3134 Function to determine whether a string is decimal or hex representation of a number
3135 and return the number converted from the string. Spaces are always skipped.
3137 @param[in] String String representation of a number
3140 @retval (UINTN)(-1) An error ocurred.
3145 IN CONST CHAR16
*String
3153 if (!InternalShellIsHexOrDecimalNumber(String
, Hex
, TRUE
, FALSE
)) {
3157 if (!EFI_ERROR(ShellConvertStringToUint64(String
, &RetVal
, Hex
, TRUE
))) {
3158 return ((UINTN
)RetVal
);
3160 return ((UINTN
)(-1));
3164 Safely append with automatic string resizing given length of Destination and
3165 desired length of copy from Source.
3167 append the first D characters of Source to the end of Destination, where D is
3168 the lesser of Count and the StrLen() of Source. If appending those D characters
3169 will fit within Destination (whose Size is given as CurrentSize) and
3170 still leave room for a NULL terminator, then those characters are appended,
3171 starting at the original terminating NULL of Destination, and a new terminating
3174 If appending D characters onto Destination will result in a overflow of the size
3175 given in CurrentSize the string will be grown such that the copy can be performed
3176 and CurrentSize will be updated to the new size.
3178 If Source is NULL, there is nothing to append, just return the current buffer in
3181 if Destination is NULL, then ASSERT()
3182 if Destination's current length (including NULL terminator) is already more then
3183 CurrentSize, then ASSERT()
3185 @param[in, out] Destination The String to append onto
3186 @param[in, out] CurrentSize on call the number of bytes in Destination. On
3187 return possibly the new size (still in bytes). if NULL
3188 then allocate whatever is needed.
3189 @param[in] Source The String to append from
3190 @param[in] Count Maximum number of characters to append. if 0 then
3193 @return Destination return the resultant string.
3198 IN OUT CHAR16
**Destination
,
3199 IN OUT UINTN
*CurrentSize
,
3200 IN CONST CHAR16
*Source
,
3204 UINTN DestinationStartSize
;
3210 ASSERT(Destination
!= NULL
);
3213 // If there's nothing to do then just return Destination
3215 if (Source
== NULL
) {
3216 return (*Destination
);
3220 // allow for un-initialized pointers, based on size being 0
3222 if (CurrentSize
!= NULL
&& *CurrentSize
== 0) {
3223 *Destination
= NULL
;
3227 // allow for NULL pointers address as Destination
3229 if (*Destination
!= NULL
) {
3230 ASSERT(CurrentSize
!= 0);
3231 DestinationStartSize
= StrSize(*Destination
);
3232 ASSERT(DestinationStartSize
<= *CurrentSize
);
3234 DestinationStartSize
= 0;
3235 // ASSERT(*CurrentSize == 0);
3239 // Append all of Source?
3242 Count
= StrLen(Source
);
3246 // Test and grow if required
3248 if (CurrentSize
!= NULL
) {
3249 NewSize
= *CurrentSize
;
3250 if (NewSize
< DestinationStartSize
+ (Count
* sizeof(CHAR16
))) {
3251 while (NewSize
< (DestinationStartSize
+ (Count
*sizeof(CHAR16
)))) {
3252 NewSize
+= 2 * Count
* sizeof(CHAR16
);
3254 *Destination
= ReallocatePool(*CurrentSize
, NewSize
, *Destination
);
3255 *CurrentSize
= NewSize
;
3258 NewSize
= (Count
+1)*sizeof(CHAR16
);
3259 *Destination
= AllocateZeroPool(NewSize
);
3263 // Now use standard StrnCat on a big enough buffer
3265 if (*Destination
== NULL
) {
3269 StrnCatS(*Destination
, NewSize
/sizeof(CHAR16
), Source
, Count
);
3270 return *Destination
;
3274 Prompt the user and return the resultant answer to the requestor.
3276 This function will display the requested question on the shell prompt and then
3277 wait for an apropriate answer to be input from the console.
3279 if the SHELL_PROMPT_REQUEST_TYPE is SHELL_PROMPT_REQUEST_TYPE_YESNO, ShellPromptResponseTypeQuitContinue
3280 or SHELL_PROMPT_REQUEST_TYPE_YESNOCANCEL then *Response is of type SHELL_PROMPT_RESPONSE.
3282 if the SHELL_PROMPT_REQUEST_TYPE is ShellPromptResponseTypeFreeform then *Response is of type
3285 In either case *Response must be callee freed if Response was not NULL;
3287 @param Type What type of question is asked. This is used to filter the input
3288 to prevent invalid answers to question.
3289 @param Prompt Pointer to string prompt to use to request input.
3290 @param Response Pointer to Response which will be populated upon return.
3292 @retval EFI_SUCCESS The operation was sucessful.
3293 @retval EFI_UNSUPPORTED The operation is not supported as requested.
3294 @retval EFI_INVALID_PARAMETER A parameter was invalid.
3295 @return other The operation failed.
3299 ShellPromptForResponse (
3300 IN SHELL_PROMPT_REQUEST_TYPE Type
,
3301 IN CHAR16
*Prompt OPTIONAL
,
3302 IN OUT VOID
**Response OPTIONAL
3308 SHELL_PROMPT_RESPONSE
*Resp
;
3312 Status
= EFI_UNSUPPORTED
;
3316 if (Type
!= ShellPromptResponseTypeFreeform
) {
3317 Resp
= (SHELL_PROMPT_RESPONSE
*)AllocateZeroPool(sizeof(SHELL_PROMPT_RESPONSE
));
3319 return (EFI_OUT_OF_RESOURCES
);
3324 case ShellPromptResponseTypeQuitContinue
:
3325 if (Prompt
!= NULL
) {
3326 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3329 // wait for valid response
3331 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3332 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3333 if (EFI_ERROR(Status
)) {
3336 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3337 if (Key
.UnicodeChar
== L
'Q' || Key
.UnicodeChar
==L
'q') {
3338 *Resp
= ShellPromptResponseQuit
;
3340 *Resp
= ShellPromptResponseContinue
;
3343 case ShellPromptResponseTypeYesNoCancel
:
3344 if (Prompt
!= NULL
) {
3345 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3348 // wait for valid response
3350 *Resp
= ShellPromptResponseMax
;
3351 while (*Resp
== ShellPromptResponseMax
) {
3352 if (ShellGetExecutionBreakFlag()) {
3353 Status
= EFI_ABORTED
;
3356 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3357 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3358 if (EFI_ERROR(Status
)) {
3361 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3362 switch (Key
.UnicodeChar
) {
3365 *Resp
= ShellPromptResponseYes
;
3369 *Resp
= ShellPromptResponseNo
;
3373 *Resp
= ShellPromptResponseCancel
;
3377 break; case ShellPromptResponseTypeYesNoAllCancel
:
3378 if (Prompt
!= NULL
) {
3379 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3382 // wait for valid response
3384 *Resp
= ShellPromptResponseMax
;
3385 while (*Resp
== ShellPromptResponseMax
) {
3386 if (ShellGetExecutionBreakFlag()) {
3387 Status
= EFI_ABORTED
;
3390 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3391 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3392 if (EFI_ERROR(Status
)) {
3395 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3396 switch (Key
.UnicodeChar
) {
3399 *Resp
= ShellPromptResponseYes
;
3403 *Resp
= ShellPromptResponseNo
;
3407 *Resp
= ShellPromptResponseAll
;
3411 *Resp
= ShellPromptResponseCancel
;
3416 case ShellPromptResponseTypeEnterContinue
:
3417 case ShellPromptResponseTypeAnyKeyContinue
:
3418 if (Prompt
!= NULL
) {
3419 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3422 // wait for valid response
3424 *Resp
= ShellPromptResponseMax
;
3425 while (*Resp
== ShellPromptResponseMax
) {
3426 if (ShellGetExecutionBreakFlag()) {
3427 Status
= EFI_ABORTED
;
3430 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3431 if (Type
== ShellPromptResponseTypeEnterContinue
) {
3432 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3433 if (EFI_ERROR(Status
)) {
3436 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3437 if (Key
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
3438 *Resp
= ShellPromptResponseContinue
;
3442 if (Type
== ShellPromptResponseTypeAnyKeyContinue
) {
3443 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3444 ASSERT_EFI_ERROR(Status
);
3445 *Resp
= ShellPromptResponseContinue
;
3450 case ShellPromptResponseTypeYesNo
:
3451 if (Prompt
!= NULL
) {
3452 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3455 // wait for valid response
3457 *Resp
= ShellPromptResponseMax
;
3458 while (*Resp
== ShellPromptResponseMax
) {
3459 if (ShellGetExecutionBreakFlag()) {
3460 Status
= EFI_ABORTED
;
3463 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3464 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3465 if (EFI_ERROR(Status
)) {
3468 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3469 switch (Key
.UnicodeChar
) {
3472 *Resp
= ShellPromptResponseYes
;
3476 *Resp
= ShellPromptResponseNo
;
3481 case ShellPromptResponseTypeFreeform
:
3482 if (Prompt
!= NULL
) {
3483 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3486 if (ShellGetExecutionBreakFlag()) {
3487 Status
= EFI_ABORTED
;
3490 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3491 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3492 if (EFI_ERROR(Status
)) {
3495 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3496 if (Key
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
3499 ASSERT((Buffer
== NULL
&& Size
== 0) || (Buffer
!= NULL
));
3500 StrnCatGrow(&Buffer
, &Size
, &Key
.UnicodeChar
, 1);
3504 // This is the location to add new prompt types.
3505 // If your new type loops remember to add ExecutionBreak support.
3511 if (Response
!= NULL
) {
3514 } else if (Buffer
!= NULL
) {
3521 if (Buffer
!= NULL
) {
3526 ShellPrintEx(-1, -1, L
"\r\n");
3531 Prompt the user and return the resultant answer to the requestor.
3533 This function is the same as ShellPromptForResponse, except that the prompt is
3534 automatically pulled from HII.
3536 @param Type What type of question is asked. This is used to filter the input
3537 to prevent invalid answers to question.
3538 @param[in] HiiFormatStringId The format string Id for getting from Hii.
3539 @param[in] HiiFormatHandle The format string Handle for getting from Hii.
3540 @param Response Pointer to Response which will be populated upon return.
3542 @retval EFI_SUCCESS the operation was sucessful.
3543 @return other the operation failed.
3545 @sa ShellPromptForResponse
3549 ShellPromptForResponseHii (
3550 IN SHELL_PROMPT_REQUEST_TYPE Type
,
3551 IN CONST EFI_STRING_ID HiiFormatStringId
,
3552 IN CONST EFI_HANDLE HiiFormatHandle
,
3553 IN OUT VOID
**Response
3559 Prompt
= HiiGetString(HiiFormatHandle
, HiiFormatStringId
, NULL
);
3560 Status
= ShellPromptForResponse(Type
, Prompt
, Response
);
3566 Function to determin if an entire string is a valid number.
3568 If Hex it must be preceeded with a 0x or has ForceHex, set TRUE.
3570 @param[in] String The string to evaluate.
3571 @param[in] ForceHex TRUE - always assume hex.
3572 @param[in] StopAtSpace TRUE to halt upon finding a space, FALSE to keep going.
3573 @param[in] TimeNumbers TRUE to allow numbers with ":", FALSE otherwise.
3575 @retval TRUE It is all numeric (dec/hex) characters.
3576 @retval FALSE There is a non-numeric character.
3580 InternalShellIsHexOrDecimalNumber (
3581 IN CONST CHAR16
*String
,
3582 IN CONST BOOLEAN ForceHex
,
3583 IN CONST BOOLEAN StopAtSpace
,
3584 IN CONST BOOLEAN TimeNumbers
3590 // chop off a single negative sign
3592 if (String
!= NULL
&& *String
== L
'-') {
3596 if (String
== NULL
) {
3601 // chop leading zeroes
3603 while(String
!= NULL
&& *String
== L
'0'){
3607 // allow '0x' or '0X', but not 'x' or 'X'
3609 if (String
!= NULL
&& (*String
== L
'x' || *String
== L
'X')) {
3610 if (*(String
-1) != L
'0') {
3612 // we got an x without a preceeding 0
3618 } else if (ForceHex
) {
3625 // loop through the remaining characters and use the lib function
3627 for ( ; String
!= NULL
&& *String
!= CHAR_NULL
&& !(StopAtSpace
&& *String
== L
' ') ; String
++){
3628 if (TimeNumbers
&& (String
[0] == L
':')) {
3632 if (!ShellIsHexaDecimalDigitCharacter(*String
)) {
3636 if (!ShellIsDecimalDigitCharacter(*String
)) {
3646 Function to determine if a given filename exists.
3648 @param[in] Name Path to test.
3650 @retval EFI_SUCCESS The Path represents a file.
3651 @retval EFI_NOT_FOUND The Path does not represent a file.
3652 @retval other The path failed to open.
3657 IN CONST CHAR16
*Name
3661 EFI_SHELL_FILE_INFO
*List
;
3663 ASSERT(Name
!= NULL
);
3666 Status
= ShellOpenFileMetaArg((CHAR16
*)Name
, EFI_FILE_MODE_READ
, &List
);
3667 if (EFI_ERROR(Status
)) {
3671 ShellCloseFileMetaArg(&List
);
3673 return (EFI_SUCCESS
);
3677 Convert a Unicode character to upper case only if
3678 it maps to a valid small-case ASCII character.
3680 This internal function only deal with Unicode character
3681 which maps to a valid small-case ASCII character, i.e.
3682 L'a' to L'z'. For other Unicode character, the input character
3683 is returned directly.
3685 @param Char The character to convert.
3687 @retval LowerCharacter If the Char is with range L'a' to L'z'.
3688 @retval Unchanged Otherwise.
3693 InternalShellCharToUpper (
3697 if (Char
>= L
'a' && Char
<= L
'z') {
3698 return (CHAR16
) (Char
- (L
'a' - L
'A'));
3705 Convert a Unicode character to numerical value.
3707 This internal function only deal with Unicode character
3708 which maps to a valid hexadecimal ASII character, i.e.
3709 L'0' to L'9', L'a' to L'f' or L'A' to L'F'. For other
3710 Unicode character, the value returned does not make sense.
3712 @param Char The character to convert.
3714 @return The numerical value converted.
3719 InternalShellHexCharToUintn (
3723 if (ShellIsDecimalDigitCharacter (Char
)) {
3727 return (UINTN
) (10 + InternalShellCharToUpper (Char
) - L
'A');
3731 Convert a Null-terminated Unicode hexadecimal string to a value of type UINT64.
3733 This function returns a value of type UINT64 by interpreting the contents
3734 of the Unicode string specified by String as a hexadecimal number.
3735 The format of the input Unicode string String is:
3737 [spaces][zeros][x][hexadecimal digits].
3739 The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F].
3740 The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix.
3741 If "x" appears in the input string, it must be prefixed with at least one 0.
3742 The function will ignore the pad space, which includes spaces or tab characters,
3743 before [zeros], [x] or [hexadecimal digit]. The running zero before [x] or
3744 [hexadecimal digit] will be ignored. Then, the decoding starts after [x] or the
3745 first valid hexadecimal digit. Then, the function stops at the first character that is
3746 a not a valid hexadecimal character or NULL, whichever one comes first.
3748 If String has only pad spaces, then zero is returned.
3749 If String has no leading pad spaces, leading zeros or valid hexadecimal digits,
3750 then zero is returned.
3752 @param[in] String A pointer to a Null-terminated Unicode string.
3753 @param[out] Value Upon a successful return the value of the conversion.
3754 @param[in] StopAtSpace FALSE to skip spaces.
3756 @retval EFI_SUCCESS The conversion was successful.
3757 @retval EFI_INVALID_PARAMETER A parameter was NULL or invalid.
3758 @retval EFI_DEVICE_ERROR An overflow occured.
3762 InternalShellStrHexToUint64 (
3763 IN CONST CHAR16
*String
,
3765 IN CONST BOOLEAN StopAtSpace
3770 if (String
== NULL
|| StrSize(String
) == 0 || Value
== NULL
) {
3771 return (EFI_INVALID_PARAMETER
);
3775 // Ignore the pad spaces (space or tab)
3777 while ((*String
== L
' ') || (*String
== L
'\t')) {
3782 // Ignore leading Zeros after the spaces
3784 while (*String
== L
'0') {
3788 if (InternalShellCharToUpper (*String
) == L
'X') {
3789 if (*(String
- 1) != L
'0') {
3801 // there is a space where there should't be
3803 if (*String
== L
' ') {
3804 return (EFI_INVALID_PARAMETER
);
3807 while (ShellIsHexaDecimalDigitCharacter (*String
)) {
3809 // If the Hex Number represented by String overflows according
3810 // to the range defined by UINT64, then return EFI_DEVICE_ERROR.
3812 if (!(Result
<= (RShiftU64((((UINT64
) ~0) - InternalShellHexCharToUintn (*String
)), 4)))) {
3813 // if (!(Result <= ((((UINT64) ~0) - InternalShellHexCharToUintn (*String)) >> 4))) {
3814 return (EFI_DEVICE_ERROR
);
3817 Result
= (LShiftU64(Result
, 4));
3818 Result
+= InternalShellHexCharToUintn (*String
);
3822 // stop at spaces if requested
3824 if (StopAtSpace
&& *String
== L
' ') {
3830 return (EFI_SUCCESS
);
3834 Convert a Null-terminated Unicode decimal string to a value of
3837 This function returns a value of type UINT64 by interpreting the contents
3838 of the Unicode string specified by String as a decimal number. The format
3839 of the input Unicode string String is:
3841 [spaces] [decimal digits].
3843 The valid decimal digit character is in the range [0-9]. The
3844 function will ignore the pad space, which includes spaces or
3845 tab characters, before [decimal digits]. The running zero in the
3846 beginning of [decimal digits] will be ignored. Then, the function
3847 stops at the first character that is a not a valid decimal character
3848 or a Null-terminator, whichever one comes first.
3850 If String has only pad spaces, then 0 is returned.
3851 If String has no pad spaces or valid decimal digits,
3854 @param[in] String A pointer to a Null-terminated Unicode string.
3855 @param[out] Value Upon a successful return the value of the conversion.
3856 @param[in] StopAtSpace FALSE to skip spaces.
3858 @retval EFI_SUCCESS The conversion was successful.
3859 @retval EFI_INVALID_PARAMETER A parameter was NULL or invalid.
3860 @retval EFI_DEVICE_ERROR An overflow occured.
3864 InternalShellStrDecimalToUint64 (
3865 IN CONST CHAR16
*String
,
3867 IN CONST BOOLEAN StopAtSpace
3872 if (String
== NULL
|| StrSize (String
) == 0 || Value
== NULL
) {
3873 return (EFI_INVALID_PARAMETER
);
3877 // Ignore the pad spaces (space or tab)
3879 while ((*String
== L
' ') || (*String
== L
'\t')) {
3884 // Ignore leading Zeros after the spaces
3886 while (*String
== L
'0') {
3893 // Stop upon space if requested
3894 // (if the whole value was 0)
3896 if (StopAtSpace
&& *String
== L
' ') {
3898 return (EFI_SUCCESS
);
3901 while (ShellIsDecimalDigitCharacter (*String
)) {
3903 // If the number represented by String overflows according
3904 // to the range defined by UINT64, then return EFI_DEVICE_ERROR.
3907 if (!(Result
<= (DivU64x32((((UINT64
) ~0) - (*String
- L
'0')),10)))) {
3908 return (EFI_DEVICE_ERROR
);
3911 Result
= MultU64x32(Result
, 10) + (*String
- L
'0');
3915 // Stop at spaces if requested
3917 if (StopAtSpace
&& *String
== L
' ') {
3924 return (EFI_SUCCESS
);
3928 Function to verify and convert a string to its numerical value.
3930 If Hex it must be preceeded with a 0x, 0X, or has ForceHex set TRUE.
3932 @param[in] String The string to evaluate.
3933 @param[out] Value Upon a successful return the value of the conversion.
3934 @param[in] ForceHex TRUE - always assume hex.
3935 @param[in] StopAtSpace FALSE to skip spaces.
3937 @retval EFI_SUCCESS The conversion was successful.
3938 @retval EFI_INVALID_PARAMETER String contained an invalid character.
3939 @retval EFI_NOT_FOUND String was a number, but Value was NULL.
3943 ShellConvertStringToUint64(
3944 IN CONST CHAR16
*String
,
3946 IN CONST BOOLEAN ForceHex
,
3947 IN CONST BOOLEAN StopAtSpace
3951 CONST CHAR16
*Walker
;
3957 if (!InternalShellIsHexOrDecimalNumber(String
, Hex
, StopAtSpace
, FALSE
)) {
3960 if (!InternalShellIsHexOrDecimalNumber(String
, Hex
, StopAtSpace
, FALSE
)) {
3961 return (EFI_INVALID_PARAMETER
);
3964 return (EFI_INVALID_PARAMETER
);
3969 // Chop off leading spaces
3971 for (Walker
= String
; Walker
!= NULL
&& *Walker
!= CHAR_NULL
&& *Walker
== L
' '; Walker
++);
3974 // make sure we have something left that is numeric.
3976 if (Walker
== NULL
|| *Walker
== CHAR_NULL
|| !InternalShellIsHexOrDecimalNumber(Walker
, Hex
, StopAtSpace
, FALSE
)) {
3977 return (EFI_INVALID_PARAMETER
);
3981 // do the conversion.
3983 if (Hex
|| StrnCmp(Walker
, L
"0x", 2) == 0 || StrnCmp(Walker
, L
"0X", 2) == 0){
3984 Status
= InternalShellStrHexToUint64(Walker
, &RetVal
, StopAtSpace
);
3986 Status
= InternalShellStrDecimalToUint64(Walker
, &RetVal
, StopAtSpace
);
3989 if (Value
== NULL
&& !EFI_ERROR(Status
)) {
3990 return (EFI_NOT_FOUND
);
3993 if (Value
!= NULL
) {
4001 Function to determin if an entire string is a valid number.
4003 If Hex it must be preceeded with a 0x or has ForceHex, set TRUE.
4005 @param[in] String The string to evaluate.
4006 @param[in] ForceHex TRUE - always assume hex.
4007 @param[in] StopAtSpace TRUE to halt upon finding a space, FALSE to keep going.
4009 @retval TRUE It is all numeric (dec/hex) characters.
4010 @retval FALSE There is a non-numeric character.
4014 ShellIsHexOrDecimalNumber (
4015 IN CONST CHAR16
*String
,
4016 IN CONST BOOLEAN ForceHex
,
4017 IN CONST BOOLEAN StopAtSpace
4020 if (ShellConvertStringToUint64(String
, NULL
, ForceHex
, StopAtSpace
) == EFI_NOT_FOUND
) {
4027 Function to read a single line from a SHELL_FILE_HANDLE. The \n is not included in the returned
4028 buffer. The returned buffer must be callee freed.
4030 If the position upon start is 0, then the Ascii Boolean will be set. This should be
4031 maintained and not changed for all operations with the same file.
4033 @param[in] Handle SHELL_FILE_HANDLE to read from.
4034 @param[in, out] Ascii Boolean value for indicating whether the file is
4035 Ascii (TRUE) or UCS2 (FALSE).
4037 @return The line of text from the file.
4038 @retval NULL There was not enough memory available.
4040 @sa ShellFileHandleReadLine
4044 ShellFileHandleReturnLine(
4045 IN SHELL_FILE_HANDLE Handle
,
4046 IN OUT BOOLEAN
*Ascii
4056 Status
= ShellFileHandleReadLine(Handle
, RetVal
, &Size
, FALSE
, Ascii
);
4057 if (Status
== EFI_BUFFER_TOO_SMALL
) {
4058 RetVal
= AllocateZeroPool(Size
);
4059 if (RetVal
== NULL
) {
4062 Status
= ShellFileHandleReadLine(Handle
, RetVal
, &Size
, FALSE
, Ascii
);
4065 if (EFI_ERROR(Status
) && (RetVal
!= NULL
)) {
4073 Function to read a single line (up to but not including the \n) from a SHELL_FILE_HANDLE.
4075 If the position upon start is 0, then the Ascii Boolean will be set. This should be
4076 maintained and not changed for all operations with the same file.
4078 @param[in] Handle SHELL_FILE_HANDLE to read from.
4079 @param[in, out] Buffer The pointer to buffer to read into.
4080 @param[in, out] Size The pointer to number of bytes in Buffer.
4081 @param[in] Truncate If the buffer is large enough, this has no effect.
4082 If the buffer is is too small and Truncate is TRUE,
4083 the line will be truncated.
4084 If the buffer is is too small and Truncate is FALSE,
4085 then no read will occur.
4087 @param[in, out] Ascii Boolean value for indicating whether the file is
4088 Ascii (TRUE) or UCS2 (FALSE).
4090 @retval EFI_SUCCESS The operation was successful. The line is stored in
4092 @retval EFI_INVALID_PARAMETER Handle was NULL.
4093 @retval EFI_INVALID_PARAMETER Size was NULL.
4094 @retval EFI_BUFFER_TOO_SMALL Size was not large enough to store the line.
4095 Size was updated to the minimum space required.
4099 ShellFileHandleReadLine(
4100 IN SHELL_FILE_HANDLE Handle
,
4101 IN OUT CHAR16
*Buffer
,
4103 IN BOOLEAN Truncate
,
4104 IN OUT BOOLEAN
*Ascii
4111 UINT64 OriginalFilePosition
;
4117 return (EFI_INVALID_PARAMETER
);
4119 if (Buffer
== NULL
) {
4122 *Buffer
= CHAR_NULL
;
4124 gEfiShellProtocol
->GetFilePosition(Handle
, &OriginalFilePosition
);
4125 if (OriginalFilePosition
== 0) {
4126 CharSize
= sizeof(CHAR16
);
4127 Status
= gEfiShellProtocol
->ReadFile(Handle
, &CharSize
, &CharBuffer
);
4128 ASSERT_EFI_ERROR(Status
);
4129 if (CharBuffer
== gUnicodeFileTag
) {
4133 gEfiShellProtocol
->SetFilePosition(Handle
, OriginalFilePosition
);
4137 for (CountSoFar
= 0;;CountSoFar
++){
4140 CharSize
= sizeof(CHAR8
);
4142 CharSize
= sizeof(CHAR16
);
4144 Status
= gEfiShellProtocol
->ReadFile(Handle
, &CharSize
, &CharBuffer
);
4145 if ( EFI_ERROR(Status
)
4147 || (CharBuffer
== L
'\n' && !(*Ascii
))
4148 || (CharBuffer
== '\n' && *Ascii
)
4153 // if we have space save it...
4155 if ((CountSoFar
+1)*sizeof(CHAR16
) < *Size
){
4156 ASSERT(Buffer
!= NULL
);
4157 ((CHAR16
*)Buffer
)[CountSoFar
] = CharBuffer
;
4158 ((CHAR16
*)Buffer
)[CountSoFar
+1] = CHAR_NULL
;
4163 // if we ran out of space tell when...
4165 if ((CountSoFar
+1)*sizeof(CHAR16
) > *Size
){
4166 *Size
= (CountSoFar
+1)*sizeof(CHAR16
);
4168 gEfiShellProtocol
->SetFilePosition(Handle
, OriginalFilePosition
);
4170 DEBUG((DEBUG_WARN
, "The line was truncated in ShellFileHandleReadLine"));
4172 return (EFI_BUFFER_TOO_SMALL
);
4174 while(Buffer
[StrLen(Buffer
)-1] == L
'\r') {
4175 Buffer
[StrLen(Buffer
)-1] = CHAR_NULL
;
4182 Function to print help file / man page content in the spec from the UEFI Shell protocol GetHelpText function.
4184 @param[in] CommandToGetHelpOn Pointer to a string containing the command name of help file to be printed.
4185 @param[in] SectionToGetHelpOn Pointer to the section specifier(s).
4186 @param[in] PrintCommandText If TRUE, prints the command followed by the help content, otherwise prints
4187 the help content only.
4188 @retval EFI_DEVICE_ERROR The help data format was incorrect.
4189 @retval EFI_NOT_FOUND The help data could not be found.
4190 @retval EFI_SUCCESS The operation was successful.
4195 IN CONST CHAR16
*CommandToGetHelpOn
,
4196 IN CONST CHAR16
*SectionToGetHelpOn
,
4197 IN BOOLEAN PrintCommandText
4206 // Get the string to print based
4208 Status
= gEfiShellProtocol
->GetHelpText (CommandToGetHelpOn
, SectionToGetHelpOn
, &OutText
);
4211 // make sure we got a valid string
4213 if (EFI_ERROR(Status
)){
4216 if (OutText
== NULL
|| StrLen(OutText
) == 0) {
4217 return EFI_NOT_FOUND
;
4221 // Chop off trailing stuff we dont need
4223 while (OutText
[StrLen(OutText
)-1] == L
'\r' || OutText
[StrLen(OutText
)-1] == L
'\n' || OutText
[StrLen(OutText
)-1] == L
' ') {
4224 OutText
[StrLen(OutText
)-1] = CHAR_NULL
;
4228 // Print this out to the console
4230 if (PrintCommandText
) {
4231 ShellPrintEx(-1, -1, L
"%H%-14s%N- %s\r\n", CommandToGetHelpOn
, OutText
);
4233 ShellPrintEx(-1, -1, L
"%N%s\r\n", OutText
);
4236 SHELL_FREE_NON_NULL(OutText
);
4242 Function to delete a file by name
4244 @param[in] FileName Pointer to file name to delete.
4246 @retval EFI_SUCCESS the file was deleted sucessfully
4247 @retval EFI_WARN_DELETE_FAILURE the handle was closed, but the file was not
4249 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
4250 @retval EFI_NOT_FOUND The specified file could not be found on the
4251 device or the file system could not be found
4253 @retval EFI_NO_MEDIA The device has no medium.
4254 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the
4255 medium is no longer supported.
4256 @retval EFI_DEVICE_ERROR The device reported an error.
4257 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
4258 @retval EFI_WRITE_PROTECTED The file or medium is write protected.
4259 @retval EFI_ACCESS_DENIED The file was opened read only.
4260 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the
4262 @retval other The file failed to open
4266 ShellDeleteFileByName(
4267 IN CONST CHAR16
*FileName
4271 SHELL_FILE_HANDLE FileHandle
;
4273 Status
= ShellFileExists(FileName
);
4275 if (Status
== EFI_SUCCESS
){
4276 Status
= ShellOpenFileByName(FileName
, &FileHandle
, EFI_FILE_MODE_READ
| EFI_FILE_MODE_WRITE
| EFI_FILE_MODE_CREATE
, 0x0);
4277 if (Status
== EFI_SUCCESS
){
4278 Status
= ShellDeleteFile(&FileHandle
);
4287 Cleans off all the quotes in the string.
4289 @param[in] OriginalString pointer to the string to be cleaned.
4290 @param[out] CleanString The new string with all quotes removed.
4291 Memory allocated in the function and free
4294 @retval EFI_SUCCESS The operation was successful.
4298 InternalShellStripQuotes (
4299 IN CONST CHAR16
*OriginalString
,
4300 OUT CHAR16
**CleanString
4305 if (OriginalString
== NULL
|| CleanString
== NULL
) {
4306 return EFI_INVALID_PARAMETER
;
4309 *CleanString
= AllocateCopyPool (StrSize (OriginalString
), OriginalString
);
4310 if (*CleanString
== NULL
) {
4311 return EFI_OUT_OF_RESOURCES
;
4314 for (Walker
= *CleanString
; Walker
!= NULL
&& *Walker
!= CHAR_NULL
; Walker
++) {
4315 if (*Walker
== L
'\"') {
4316 CopyMem(Walker
, Walker
+1, StrSize(Walker
) - sizeof(Walker
[0]));