2 Provides interface to shell functionality for shell commands and applications.
4 Copyright (c) 2006 - 2012, 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>
19 #define FIND_XXXXX_FILE_BUFFER_SIZE (SIZE_OF_EFI_FILE_INFO + MAX_FILE_NAME_LEN)
24 SHELL_PARAM_ITEM EmptyParamList
[] = {
27 SHELL_PARAM_ITEM SfoParamList
[] = {
31 EFI_SHELL_ENVIRONMENT2
*mEfiShellEnvironment2
;
32 EFI_SHELL_INTERFACE
*mEfiShellInterface
;
33 EFI_SHELL_PROTOCOL
*gEfiShellProtocol
;
34 EFI_SHELL_PARAMETERS_PROTOCOL
*gEfiShellParametersProtocol
;
35 EFI_HANDLE mEfiShellEnvironment2Handle
;
36 FILE_HANDLE_FUNCTION_MAP FileFunctionMap
;
39 Check if a Unicode character is a hexadecimal character.
41 This internal function checks if a Unicode character is a
42 numeric character. The valid hexadecimal characters are
43 L'0' to L'9', L'a' to L'f', or L'A' to L'F'.
45 @param Char The character to check against.
47 @retval TRUE If the Char is a hexadecmial character.
48 @retval FALSE If the Char is not a hexadecmial character.
53 ShellIsHexaDecimalDigitCharacter (
57 return (BOOLEAN
) ((Char
>= L
'0' && Char
<= L
'9') || (Char
>= L
'A' && Char
<= L
'F') || (Char
>= L
'a' && Char
<= L
'f'));
61 Check if a Unicode character is a decimal character.
63 This internal function checks if a Unicode character is a
64 decimal character. The valid characters are
68 @param Char The character to check against.
70 @retval TRUE If the Char is a hexadecmial character.
71 @retval FALSE If the Char is not a hexadecmial character.
76 ShellIsDecimalDigitCharacter (
80 return (BOOLEAN
) (Char
>= L
'0' && Char
<= L
'9');
84 Helper function to find ShellEnvironment2 for constructor.
86 @param[in] ImageHandle A copy of the calling image's handle.
88 @retval EFI_OUT_OF_RESOURCES Memory allocation failed.
93 IN EFI_HANDLE ImageHandle
103 Status
= gBS
->OpenProtocol(ImageHandle
,
104 &gEfiShellEnvironment2Guid
,
105 (VOID
**)&mEfiShellEnvironment2
,
108 EFI_OPEN_PROTOCOL_GET_PROTOCOL
111 // look for the mEfiShellEnvironment2 protocol at a higher level
113 if (EFI_ERROR (Status
) || !(CompareGuid (&mEfiShellEnvironment2
->SESGuid
, &gEfiShellEnvironment2ExtGuid
))){
115 // figure out how big of a buffer we need.
117 Status
= gBS
->LocateHandle (ByProtocol
,
118 &gEfiShellEnvironment2Guid
,
119 NULL
, // ignored for ByProtocol
124 // maybe it's not there???
126 if (Status
== EFI_BUFFER_TOO_SMALL
) {
127 Buffer
= (EFI_HANDLE
*)AllocateZeroPool(BufferSize
);
128 if (Buffer
== NULL
) {
129 return (EFI_OUT_OF_RESOURCES
);
131 Status
= gBS
->LocateHandle (ByProtocol
,
132 &gEfiShellEnvironment2Guid
,
133 NULL
, // ignored for ByProtocol
138 if (!EFI_ERROR (Status
) && Buffer
!= NULL
) {
140 // now parse the list of returned handles
142 Status
= EFI_NOT_FOUND
;
143 for (HandleIndex
= 0; HandleIndex
< (BufferSize
/sizeof(Buffer
[0])); HandleIndex
++) {
144 Status
= gBS
->OpenProtocol(Buffer
[HandleIndex
],
145 &gEfiShellEnvironment2Guid
,
146 (VOID
**)&mEfiShellEnvironment2
,
149 EFI_OPEN_PROTOCOL_GET_PROTOCOL
151 if (CompareGuid (&mEfiShellEnvironment2
->SESGuid
, &gEfiShellEnvironment2ExtGuid
)) {
152 mEfiShellEnvironment2Handle
= Buffer
[HandleIndex
];
153 Status
= EFI_SUCCESS
;
159 if (Buffer
!= NULL
) {
166 Function to do most of the work of the constructor. Allows for calling
167 multiple times without complete re-initialization.
169 @param[in] ImageHandle A copy of the ImageHandle.
170 @param[in] SystemTable A pointer to the SystemTable for the application.
172 @retval EFI_SUCCESS The operationw as successful.
176 ShellLibConstructorWorker (
177 IN EFI_HANDLE ImageHandle
,
178 IN EFI_SYSTEM_TABLE
*SystemTable
184 // UEFI 2.0 shell interfaces (used preferentially)
186 Status
= gBS
->OpenProtocol(
188 &gEfiShellProtocolGuid
,
189 (VOID
**)&gEfiShellProtocol
,
192 EFI_OPEN_PROTOCOL_GET_PROTOCOL
194 if (EFI_ERROR(Status
)) {
196 // Search for the shell protocol
198 Status
= gBS
->LocateProtocol(
199 &gEfiShellProtocolGuid
,
201 (VOID
**)&gEfiShellProtocol
203 if (EFI_ERROR(Status
)) {
204 gEfiShellProtocol
= NULL
;
207 Status
= gBS
->OpenProtocol(
209 &gEfiShellParametersProtocolGuid
,
210 (VOID
**)&gEfiShellParametersProtocol
,
213 EFI_OPEN_PROTOCOL_GET_PROTOCOL
215 if (EFI_ERROR(Status
)) {
216 gEfiShellParametersProtocol
= NULL
;
219 if (gEfiShellParametersProtocol
== NULL
|| gEfiShellProtocol
== NULL
) {
221 // Moved to seperate function due to complexity
223 Status
= ShellFindSE2(ImageHandle
);
225 if (EFI_ERROR(Status
)) {
226 DEBUG((DEBUG_ERROR
, "Status: 0x%08x\r\n", Status
));
227 mEfiShellEnvironment2
= NULL
;
229 Status
= gBS
->OpenProtocol(ImageHandle
,
230 &gEfiShellInterfaceGuid
,
231 (VOID
**)&mEfiShellInterface
,
234 EFI_OPEN_PROTOCOL_GET_PROTOCOL
236 if (EFI_ERROR(Status
)) {
237 mEfiShellInterface
= NULL
;
242 // only success getting 2 of either the old or new, but no 1/2 and 1/2
244 if ((mEfiShellEnvironment2
!= NULL
&& mEfiShellInterface
!= NULL
) ||
245 (gEfiShellProtocol
!= NULL
&& gEfiShellParametersProtocol
!= NULL
) ) {
246 if (gEfiShellProtocol
!= NULL
) {
247 FileFunctionMap
.GetFileInfo
= gEfiShellProtocol
->GetFileInfo
;
248 FileFunctionMap
.SetFileInfo
= gEfiShellProtocol
->SetFileInfo
;
249 FileFunctionMap
.ReadFile
= gEfiShellProtocol
->ReadFile
;
250 FileFunctionMap
.WriteFile
= gEfiShellProtocol
->WriteFile
;
251 FileFunctionMap
.CloseFile
= gEfiShellProtocol
->CloseFile
;
252 FileFunctionMap
.DeleteFile
= gEfiShellProtocol
->DeleteFile
;
253 FileFunctionMap
.GetFilePosition
= gEfiShellProtocol
->GetFilePosition
;
254 FileFunctionMap
.SetFilePosition
= gEfiShellProtocol
->SetFilePosition
;
255 FileFunctionMap
.FlushFile
= gEfiShellProtocol
->FlushFile
;
256 FileFunctionMap
.GetFileSize
= gEfiShellProtocol
->GetFileSize
;
258 FileFunctionMap
.GetFileInfo
= (EFI_SHELL_GET_FILE_INFO
)FileHandleGetInfo
;
259 FileFunctionMap
.SetFileInfo
= (EFI_SHELL_SET_FILE_INFO
)FileHandleSetInfo
;
260 FileFunctionMap
.ReadFile
= (EFI_SHELL_READ_FILE
)FileHandleRead
;
261 FileFunctionMap
.WriteFile
= (EFI_SHELL_WRITE_FILE
)FileHandleWrite
;
262 FileFunctionMap
.CloseFile
= (EFI_SHELL_CLOSE_FILE
)FileHandleClose
;
263 FileFunctionMap
.DeleteFile
= (EFI_SHELL_DELETE_FILE
)FileHandleDelete
;
264 FileFunctionMap
.GetFilePosition
= (EFI_SHELL_GET_FILE_POSITION
)FileHandleGetPosition
;
265 FileFunctionMap
.SetFilePosition
= (EFI_SHELL_SET_FILE_POSITION
)FileHandleSetPosition
;
266 FileFunctionMap
.FlushFile
= (EFI_SHELL_FLUSH_FILE
)FileHandleFlush
;
267 FileFunctionMap
.GetFileSize
= (EFI_SHELL_GET_FILE_SIZE
)FileHandleGetSize
;
269 return (EFI_SUCCESS
);
271 return (EFI_NOT_FOUND
);
274 Constructor for the Shell library.
276 Initialize the library and determine if the underlying is a UEFI Shell 2.0 or an EFI shell.
278 @param ImageHandle the image handle of the process
279 @param SystemTable the EFI System Table pointer
281 @retval EFI_SUCCESS the initialization was complete sucessfully
282 @return others an error ocurred during initialization
286 ShellLibConstructor (
287 IN EFI_HANDLE ImageHandle
,
288 IN EFI_SYSTEM_TABLE
*SystemTable
291 mEfiShellEnvironment2
= NULL
;
292 gEfiShellProtocol
= NULL
;
293 gEfiShellParametersProtocol
= NULL
;
294 mEfiShellInterface
= NULL
;
295 mEfiShellEnvironment2Handle
= NULL
;
298 // verify that auto initialize is not set false
300 if (PcdGetBool(PcdShellLibAutoInitialize
) == 0) {
301 return (EFI_SUCCESS
);
304 return (ShellLibConstructorWorker(ImageHandle
, SystemTable
));
308 Destructor for the library. free any resources.
310 @param[in] ImageHandle A copy of the ImageHandle.
311 @param[in] SystemTable A pointer to the SystemTable for the application.
313 @retval EFI_SUCCESS The operation was successful.
314 @return An error from the CloseProtocol function.
319 IN EFI_HANDLE ImageHandle
,
320 IN EFI_SYSTEM_TABLE
*SystemTable
323 if (mEfiShellEnvironment2
!= NULL
) {
324 gBS
->CloseProtocol(mEfiShellEnvironment2Handle
==NULL
?ImageHandle
:mEfiShellEnvironment2Handle
,
325 &gEfiShellEnvironment2Guid
,
328 mEfiShellEnvironment2
= NULL
;
330 if (mEfiShellInterface
!= NULL
) {
331 gBS
->CloseProtocol(ImageHandle
,
332 &gEfiShellInterfaceGuid
,
335 mEfiShellInterface
= NULL
;
337 if (gEfiShellProtocol
!= NULL
) {
338 gBS
->CloseProtocol(ImageHandle
,
339 &gEfiShellProtocolGuid
,
342 gEfiShellProtocol
= NULL
;
344 if (gEfiShellParametersProtocol
!= NULL
) {
345 gBS
->CloseProtocol(ImageHandle
,
346 &gEfiShellParametersProtocolGuid
,
349 gEfiShellParametersProtocol
= NULL
;
351 mEfiShellEnvironment2Handle
= NULL
;
353 return (EFI_SUCCESS
);
357 This function causes the shell library to initialize itself. If the shell library
358 is already initialized it will de-initialize all the current protocol poitners and
359 re-populate them again.
361 When the library is used with PcdShellLibAutoInitialize set to true this function
362 will return EFI_SUCCESS and perform no actions.
364 This function is intended for internal access for shell commands only.
366 @retval EFI_SUCCESS the initialization was complete sucessfully
375 // if auto initialize is not false then skip
377 if (PcdGetBool(PcdShellLibAutoInitialize
) != 0) {
378 return (EFI_SUCCESS
);
382 // deinit the current stuff
384 ASSERT_EFI_ERROR(ShellLibDestructor(gImageHandle
, gST
));
387 // init the new stuff
389 return (ShellLibConstructorWorker(gImageHandle
, gST
));
393 This function will retrieve the information about the file for the handle
394 specified and store it in allocated pool memory.
396 This function allocates a buffer to store the file's information. It is the
397 caller's responsibility to free the buffer
399 @param FileHandle The file handle of the file for which information is
402 @retval NULL information could not be retrieved.
404 @return the information about the file
409 IN SHELL_FILE_HANDLE FileHandle
412 return (FileFunctionMap
.GetFileInfo(FileHandle
));
416 This function sets the information about the file for the opened handle
419 @param[in] FileHandle The file handle of the file for which information
422 @param[in] FileInfo The information to set.
424 @retval EFI_SUCCESS The information was set.
425 @retval EFI_INVALID_PARAMETER A parameter was out of range or invalid.
426 @retval EFI_UNSUPPORTED The FileHandle does not support FileInfo.
427 @retval EFI_NO_MEDIA The device has no medium.
428 @retval EFI_DEVICE_ERROR The device reported an error.
429 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
430 @retval EFI_WRITE_PROTECTED The file or medium is write protected.
431 @retval EFI_ACCESS_DENIED The file was opened read only.
432 @retval EFI_VOLUME_FULL The volume is full.
437 IN SHELL_FILE_HANDLE FileHandle
,
438 IN EFI_FILE_INFO
*FileInfo
441 return (FileFunctionMap
.SetFileInfo(FileHandle
, FileInfo
));
445 This function will open a file or directory referenced by DevicePath.
447 This function opens a file with the open mode according to the file path. The
448 Attributes is valid only for EFI_FILE_MODE_CREATE.
450 @param FilePath on input the device path to the file. On output
451 the remaining device path.
452 @param DeviceHandle pointer to the system device handle.
453 @param FileHandle pointer to the file handle.
454 @param OpenMode the mode to open the file with.
455 @param Attributes the file's file attributes.
457 @retval EFI_SUCCESS The information was set.
458 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
459 @retval EFI_UNSUPPORTED Could not open the file path.
460 @retval EFI_NOT_FOUND The specified file could not be found on the
461 device or the file system could not be found on
463 @retval EFI_NO_MEDIA The device has no medium.
464 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the
465 medium is no longer supported.
466 @retval EFI_DEVICE_ERROR The device reported an error.
467 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
468 @retval EFI_WRITE_PROTECTED The file or medium is write protected.
469 @retval EFI_ACCESS_DENIED The file was opened read only.
470 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the
472 @retval EFI_VOLUME_FULL The volume is full.
476 ShellOpenFileByDevicePath(
477 IN OUT EFI_DEVICE_PATH_PROTOCOL
**FilePath
,
478 OUT EFI_HANDLE
*DeviceHandle
,
479 OUT SHELL_FILE_HANDLE
*FileHandle
,
486 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
*EfiSimpleFileSystemProtocol
;
487 EFI_FILE_PROTOCOL
*Handle1
;
488 EFI_FILE_PROTOCOL
*Handle2
;
490 if (FilePath
== NULL
|| FileHandle
== NULL
|| DeviceHandle
== NULL
) {
491 return (EFI_INVALID_PARAMETER
);
495 // which shell interface should we use
497 if (gEfiShellProtocol
!= NULL
) {
499 // use UEFI Shell 2.0 method.
501 FileName
= gEfiShellProtocol
->GetFilePathFromDevicePath(*FilePath
);
502 if (FileName
== NULL
) {
503 return (EFI_INVALID_PARAMETER
);
505 Status
= ShellOpenFileByName(FileName
, FileHandle
, OpenMode
, Attributes
);
512 // use old shell method.
514 Status
= gBS
->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid
,
517 if (EFI_ERROR (Status
)) {
520 Status
= gBS
->OpenProtocol(*DeviceHandle
,
521 &gEfiSimpleFileSystemProtocolGuid
,
522 (VOID
**)&EfiSimpleFileSystemProtocol
,
525 EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
526 if (EFI_ERROR (Status
)) {
529 Status
= EfiSimpleFileSystemProtocol
->OpenVolume(EfiSimpleFileSystemProtocol
, &Handle1
);
530 if (EFI_ERROR (Status
)) {
536 // go down directories one node at a time.
538 while (!IsDevicePathEnd (*FilePath
)) {
540 // For file system access each node should be a file path component
542 if (DevicePathType (*FilePath
) != MEDIA_DEVICE_PATH
||
543 DevicePathSubType (*FilePath
) != MEDIA_FILEPATH_DP
546 return (EFI_INVALID_PARAMETER
);
549 // Open this file path node
555 // Try to test opening an existing file
557 Status
= Handle2
->Open (
560 ((FILEPATH_DEVICE_PATH
*)*FilePath
)->PathName
,
561 OpenMode
&~EFI_FILE_MODE_CREATE
,
566 // see if the error was that it needs to be created
568 if ((EFI_ERROR (Status
)) && (OpenMode
!= (OpenMode
&~EFI_FILE_MODE_CREATE
))) {
569 Status
= Handle2
->Open (
572 ((FILEPATH_DEVICE_PATH
*)*FilePath
)->PathName
,
578 // Close the last node
580 Handle2
->Close (Handle2
);
582 if (EFI_ERROR(Status
)) {
589 *FilePath
= NextDevicePathNode (*FilePath
);
593 // This is a weak spot since if the undefined SHELL_FILE_HANDLE format changes this must change also!
595 *FileHandle
= (VOID
*)Handle1
;
596 return (EFI_SUCCESS
);
600 This function will open a file or directory referenced by filename.
602 If return is EFI_SUCCESS, the Filehandle is the opened file's handle;
603 otherwise, the Filehandle is NULL. The Attributes is valid only for
604 EFI_FILE_MODE_CREATE.
606 if FileName is NULL then ASSERT()
608 @param FileName pointer to file name
609 @param FileHandle pointer to the file handle.
610 @param OpenMode the mode to open the file with.
611 @param Attributes the file's file attributes.
613 @retval EFI_SUCCESS The information was set.
614 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
615 @retval EFI_UNSUPPORTED Could not open the file path.
616 @retval EFI_NOT_FOUND The specified file could not be found on the
617 device or the file system could not be found
619 @retval EFI_NO_MEDIA The device has no medium.
620 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the
621 medium is no longer supported.
622 @retval EFI_DEVICE_ERROR The device reported an error.
623 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
624 @retval EFI_WRITE_PROTECTED The file or medium is write protected.
625 @retval EFI_ACCESS_DENIED The file was opened read only.
626 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the
628 @retval EFI_VOLUME_FULL The volume is full.
633 IN CONST CHAR16
*FileName
,
634 OUT SHELL_FILE_HANDLE
*FileHandle
,
639 EFI_HANDLE DeviceHandle
;
640 EFI_DEVICE_PATH_PROTOCOL
*FilePath
;
642 EFI_FILE_INFO
*FileInfo
;
645 // ASSERT if FileName is NULL
647 ASSERT(FileName
!= NULL
);
649 if (FileName
== NULL
) {
650 return (EFI_INVALID_PARAMETER
);
653 if (gEfiShellProtocol
!= NULL
) {
654 if ((OpenMode
& EFI_FILE_MODE_CREATE
) == EFI_FILE_MODE_CREATE
&& (Attributes
& EFI_FILE_DIRECTORY
) == EFI_FILE_DIRECTORY
) {
655 return ShellCreateDirectory(FileName
, FileHandle
);
658 // Use UEFI Shell 2.0 method
660 Status
= gEfiShellProtocol
->OpenFileByName(FileName
,
663 if (StrCmp(FileName
, L
"NUL") != 0 && !EFI_ERROR(Status
) && ((OpenMode
& EFI_FILE_MODE_CREATE
) != 0)){
664 FileInfo
= FileFunctionMap
.GetFileInfo(*FileHandle
);
665 ASSERT(FileInfo
!= NULL
);
666 FileInfo
->Attribute
= Attributes
;
667 Status
= FileFunctionMap
.SetFileInfo(*FileHandle
, FileInfo
);
673 // Using EFI Shell version
674 // this means convert name to path and call that function
675 // since this will use EFI method again that will open it.
677 ASSERT(mEfiShellEnvironment2
!= NULL
);
678 FilePath
= mEfiShellEnvironment2
->NameToPath ((CHAR16
*)FileName
);
679 if (FilePath
!= NULL
) {
680 return (ShellOpenFileByDevicePath(&FilePath
,
686 return (EFI_DEVICE_ERROR
);
689 This function create a directory
691 If return is EFI_SUCCESS, the Filehandle is the opened directory's handle;
692 otherwise, the Filehandle is NULL. If the directory already existed, this
693 function opens the existing directory.
695 @param DirectoryName pointer to directory name
696 @param FileHandle pointer to the file handle.
698 @retval EFI_SUCCESS The information was set.
699 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.
700 @retval EFI_UNSUPPORTED Could not open the file path.
701 @retval EFI_NOT_FOUND The specified file could not be found on the
702 device or the file system could not be found
704 @retval EFI_NO_MEDIA The device has no medium.
705 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the
706 medium is no longer supported.
707 @retval EFI_DEVICE_ERROR The device reported an error.
708 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
709 @retval EFI_WRITE_PROTECTED The file or medium is write protected.
710 @retval EFI_ACCESS_DENIED The file was opened read only.
711 @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the
713 @retval EFI_VOLUME_FULL The volume is full.
714 @sa ShellOpenFileByName
718 ShellCreateDirectory(
719 IN CONST CHAR16
*DirectoryName
,
720 OUT SHELL_FILE_HANDLE
*FileHandle
723 if (gEfiShellProtocol
!= NULL
) {
725 // Use UEFI Shell 2.0 method
727 return (gEfiShellProtocol
->CreateFile(DirectoryName
,
732 return (ShellOpenFileByName(DirectoryName
,
734 EFI_FILE_MODE_READ
| EFI_FILE_MODE_WRITE
| EFI_FILE_MODE_CREATE
,
741 This function reads information from an opened file.
743 If FileHandle is not a directory, the function reads the requested number of
744 bytes from the file at the file's current position and returns them in Buffer.
745 If the read goes beyond the end of the file, the read length is truncated to the
746 end of the file. The file's current position is increased by the number of bytes
747 returned. If FileHandle is a directory, the function reads the directory entry
748 at the file's current position and returns the entry in Buffer. If the Buffer
749 is not large enough to hold the current directory entry, then
750 EFI_BUFFER_TOO_SMALL is returned and the current file position is not updated.
751 BufferSize is set to be the size of the buffer needed to read the entry. On
752 success, the current position is updated to the next directory entry. If there
753 are no more directory entries, the read returns a zero-length buffer.
754 EFI_FILE_INFO is the structure returned as the directory entry.
756 @param FileHandle the opened file handle
757 @param BufferSize on input the size of buffer in bytes. on return
758 the number of bytes written.
759 @param Buffer the buffer to put read data into.
761 @retval EFI_SUCCESS Data was read.
762 @retval EFI_NO_MEDIA The device has no media.
763 @retval EFI_DEVICE_ERROR The device reported an error.
764 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
765 @retval EFI_BUFFER_TO_SMALL Buffer is too small. ReadSize contains required
772 IN SHELL_FILE_HANDLE FileHandle
,
773 IN OUT UINTN
*BufferSize
,
777 return (FileFunctionMap
.ReadFile(FileHandle
, BufferSize
, Buffer
));
782 Write data to a file.
784 This function writes the specified number of bytes to the file at the current
785 file position. The current file position is advanced the actual number of bytes
786 written, which is returned in BufferSize. Partial writes only occur when there
787 has been a data error during the write attempt (such as "volume space full").
788 The file is automatically grown to hold the data if required. Direct writes to
789 opened directories are not supported.
791 @param FileHandle The opened file for writing
792 @param BufferSize on input the number of bytes in Buffer. On output
793 the number of bytes written.
794 @param Buffer the buffer containing data to write is stored.
796 @retval EFI_SUCCESS Data was written.
797 @retval EFI_UNSUPPORTED Writes to an open directory are not supported.
798 @retval EFI_NO_MEDIA The device has no media.
799 @retval EFI_DEVICE_ERROR The device reported an error.
800 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
801 @retval EFI_WRITE_PROTECTED The device is write-protected.
802 @retval EFI_ACCESS_DENIED The file was open for read only.
803 @retval EFI_VOLUME_FULL The volume is full.
808 IN SHELL_FILE_HANDLE FileHandle
,
809 IN OUT UINTN
*BufferSize
,
813 return (FileFunctionMap
.WriteFile(FileHandle
, BufferSize
, Buffer
));
817 Close an open file handle.
819 This function closes a specified file handle. All "dirty" cached file data is
820 flushed to the device, and the file is closed. In all cases the handle is
823 @param FileHandle the file handle to close.
825 @retval EFI_SUCCESS the file handle was closed sucessfully.
830 IN SHELL_FILE_HANDLE
*FileHandle
833 return (FileFunctionMap
.CloseFile(*FileHandle
));
837 Delete a file and close the handle
839 This function closes and deletes a file. In all cases the file handle is closed.
840 If the file cannot be deleted, the warning code EFI_WARN_DELETE_FAILURE is
841 returned, but the handle is still closed.
843 @param FileHandle the file handle to delete
845 @retval EFI_SUCCESS the file was closed sucessfully
846 @retval EFI_WARN_DELETE_FAILURE the handle was closed, but the file was not
848 @retval INVALID_PARAMETER One of the parameters has an invalid value.
853 IN SHELL_FILE_HANDLE
*FileHandle
856 return (FileFunctionMap
.DeleteFile(*FileHandle
));
860 Set the current position in a file.
862 This function sets the current file position for the handle to the position
863 supplied. With the exception of seeking to position 0xFFFFFFFFFFFFFFFF, only
864 absolute positioning is supported, and seeking past the end of the file is
865 allowed (a subsequent write would grow the file). Seeking to position
866 0xFFFFFFFFFFFFFFFF causes the current position to be set to the end of the file.
867 If FileHandle is a directory, the only position that may be set is zero. This
868 has the effect of starting the read process of the directory entries over.
870 @param FileHandle The file handle on which the position is being set
871 @param Position Byte position from begining of file
873 @retval EFI_SUCCESS Operation completed sucessfully.
874 @retval EFI_UNSUPPORTED the seek request for non-zero is not valid on
876 @retval INVALID_PARAMETER One of the parameters has an invalid value.
880 ShellSetFilePosition (
881 IN SHELL_FILE_HANDLE FileHandle
,
885 return (FileFunctionMap
.SetFilePosition(FileHandle
, Position
));
889 Gets a file's current position
891 This function retrieves the current file position for the file handle. For
892 directories, the current file position has no meaning outside of the file
893 system driver and as such the operation is not supported. An error is returned
894 if FileHandle is a directory.
896 @param FileHandle The open file handle on which to get the position.
897 @param Position Byte position from begining of file.
899 @retval EFI_SUCCESS the operation completed sucessfully.
900 @retval INVALID_PARAMETER One of the parameters has an invalid value.
901 @retval EFI_UNSUPPORTED the request is not valid on directories.
905 ShellGetFilePosition (
906 IN SHELL_FILE_HANDLE FileHandle
,
910 return (FileFunctionMap
.GetFilePosition(FileHandle
, Position
));
913 Flushes data on a file
915 This function flushes all modified data associated with a file to a device.
917 @param FileHandle The file handle on which to flush data
919 @retval EFI_SUCCESS The data was flushed.
920 @retval EFI_NO_MEDIA The device has no media.
921 @retval EFI_DEVICE_ERROR The device reported an error.
922 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
923 @retval EFI_WRITE_PROTECTED The file or medium is write protected.
924 @retval EFI_ACCESS_DENIED The file was opened for read only.
929 IN SHELL_FILE_HANDLE FileHandle
932 return (FileFunctionMap
.FlushFile(FileHandle
));
935 /** Retrieve first entry from a directory.
937 This function takes an open directory handle and gets information from the
938 first entry in the directory. A buffer is allocated to contain
939 the information and a pointer to the buffer is returned in *Buffer. The
940 caller can use ShellFindNextFile() to get subsequent directory entries.
942 The buffer will be freed by ShellFindNextFile() when the last directory
943 entry is read. Otherwise, the caller must free the buffer, using FreePool,
944 when finished with it.
946 @param[in] DirHandle The file handle of the directory to search.
947 @param[out] Buffer The pointer to the buffer for the file's information.
949 @retval EFI_SUCCESS Found the first file.
950 @retval EFI_NOT_FOUND Cannot find the directory.
951 @retval EFI_NO_MEDIA The device has no media.
952 @retval EFI_DEVICE_ERROR The device reported an error.
953 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
954 @return Others status of ShellGetFileInfo, ShellSetFilePosition,
960 IN SHELL_FILE_HANDLE DirHandle
,
961 OUT EFI_FILE_INFO
**Buffer
965 // pass to file handle lib
967 return (FileHandleFindFirstFile(DirHandle
, Buffer
));
969 /** Retrieve next entries from a directory.
971 To use this function, the caller must first call the ShellFindFirstFile()
972 function to get the first directory entry. Subsequent directory entries are
973 retrieved by using the ShellFindNextFile() function. This function can
974 be called several times to get each entry from the directory. If the call of
975 ShellFindNextFile() retrieved the last directory entry, the next call of
976 this function will set *NoFile to TRUE and free the buffer.
978 @param[in] DirHandle The file handle of the directory.
979 @param[out] Buffer The pointer to buffer for file's information.
980 @param[out] NoFile The pointer to boolean when last file is found.
982 @retval EFI_SUCCESS Found the next file, or reached last file
983 @retval EFI_NO_MEDIA The device has no media.
984 @retval EFI_DEVICE_ERROR The device reported an error.
985 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
990 IN SHELL_FILE_HANDLE DirHandle
,
991 OUT EFI_FILE_INFO
*Buffer
,
996 // pass to file handle lib
998 return (FileHandleFindNextFile(DirHandle
, Buffer
, NoFile
));
1001 Retrieve the size of a file.
1003 if FileHandle is NULL then ASSERT()
1004 if Size is NULL then ASSERT()
1006 This function extracts the file size info from the FileHandle's EFI_FILE_INFO
1009 @param FileHandle file handle from which size is retrieved
1010 @param Size pointer to size
1012 @retval EFI_SUCCESS operation was completed sucessfully
1013 @retval EFI_DEVICE_ERROR cannot access the file
1018 IN SHELL_FILE_HANDLE FileHandle
,
1022 return (FileFunctionMap
.GetFileSize(FileHandle
, Size
));
1025 Retrieves the status of the break execution flag
1027 this function is useful to check whether the application is being asked to halt by the shell.
1029 @retval TRUE the execution break is enabled
1030 @retval FALSE the execution break is not enabled
1034 ShellGetExecutionBreakFlag(
1039 // Check for UEFI Shell 2.0 protocols
1041 if (gEfiShellProtocol
!= NULL
) {
1044 // We are using UEFI Shell 2.0; see if the event has been triggered
1046 if (gBS
->CheckEvent(gEfiShellProtocol
->ExecutionBreak
) != EFI_SUCCESS
) {
1053 // using EFI Shell; call the function to check
1055 if (mEfiShellEnvironment2
!= NULL
) {
1056 return (mEfiShellEnvironment2
->GetExecutionBreak());
1062 return the value of an environment variable
1064 this function gets the value of the environment variable set by the
1065 ShellSetEnvironmentVariable function
1067 @param EnvKey The key name of the environment variable.
1069 @retval NULL the named environment variable does not exist.
1070 @return != NULL pointer to the value of the environment variable
1074 ShellGetEnvironmentVariable (
1075 IN CONST CHAR16
*EnvKey
1079 // Check for UEFI Shell 2.0 protocols
1081 if (gEfiShellProtocol
!= NULL
) {
1082 return (gEfiShellProtocol
->GetEnv(EnvKey
));
1086 // Check for EFI shell
1088 if (mEfiShellEnvironment2
!= NULL
) {
1089 return (mEfiShellEnvironment2
->GetEnv((CHAR16
*)EnvKey
));
1095 set the value of an environment variable
1097 This function changes the current value of the specified environment variable. If the
1098 environment variable exists and the Value is an empty string, then the environment
1099 variable is deleted. If the environment variable exists and the Value is not an empty
1100 string, then the value of the environment variable is changed. If the environment
1101 variable does not exist and the Value is an empty string, there is no action. If the
1102 environment variable does not exist and the Value is a non-empty string, then the
1103 environment variable is created and assigned the specified value.
1105 This is not supported pre-UEFI Shell 2.0.
1107 @param EnvKey The key name of the environment variable.
1108 @param EnvVal The Value of the environment variable
1109 @param Volatile Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).
1111 @retval EFI_SUCCESS the operation was completed sucessfully
1112 @retval EFI_UNSUPPORTED This operation is not allowed in pre UEFI 2.0 Shell environments
1116 ShellSetEnvironmentVariable (
1117 IN CONST CHAR16
*EnvKey
,
1118 IN CONST CHAR16
*EnvVal
,
1123 // Check for UEFI Shell 2.0 protocols
1125 if (gEfiShellProtocol
!= NULL
) {
1126 return (gEfiShellProtocol
->SetEnv(EnvKey
, EnvVal
, Volatile
));
1130 // This feature does not exist under EFI shell
1132 return (EFI_UNSUPPORTED
);
1136 Cause the shell to parse and execute a command line.
1138 This function creates a nested instance of the shell and executes the specified
1139 command (CommandLine) with the specified environment (Environment). Upon return,
1140 the status code returned by the specified command is placed in StatusCode.
1141 If Environment is NULL, then the current environment is used and all changes made
1142 by the commands executed will be reflected in the current environment. If the
1143 Environment is non-NULL, then the changes made will be discarded.
1144 The CommandLine is executed from the current working directory on the current
1147 The EnvironmentVariables and Status parameters are ignored in a pre-UEFI Shell 2.0
1148 environment. The values pointed to by the parameters will be unchanged by the
1149 ShellExecute() function. The Output parameter has no effect in a
1150 UEFI Shell 2.0 environment.
1152 @param[in] ParentHandle The parent image starting the operation.
1153 @param[in] CommandLine The pointer to a NULL terminated command line.
1154 @param[in] Output True to display debug output. False to hide it.
1155 @param[in] EnvironmentVariables Optional pointer to array of environment variables
1156 in the form "x=y". If NULL, the current set is used.
1157 @param[out] Status The status of the run command line.
1159 @retval EFI_SUCCESS The operation completed sucessfully. Status
1160 contains the status code returned.
1161 @retval EFI_INVALID_PARAMETER A parameter contains an invalid value.
1162 @retval EFI_OUT_OF_RESOURCES Out of resources.
1163 @retval EFI_UNSUPPORTED The operation is not allowed.
1168 IN EFI_HANDLE
*ParentHandle
,
1169 IN CHAR16
*CommandLine OPTIONAL
,
1170 IN BOOLEAN Output OPTIONAL
,
1171 IN CHAR16
**EnvironmentVariables OPTIONAL
,
1172 OUT EFI_STATUS
*Status OPTIONAL
1176 // Check for UEFI Shell 2.0 protocols
1178 if (gEfiShellProtocol
!= NULL
) {
1180 // Call UEFI Shell 2.0 version (not using Output parameter)
1182 return (gEfiShellProtocol
->Execute(ParentHandle
,
1184 EnvironmentVariables
,
1189 // Check for EFI shell
1191 if (mEfiShellEnvironment2
!= NULL
) {
1193 // Call EFI Shell version (not using EnvironmentVariables or Status parameters)
1194 // Due to oddity in the EFI shell we want to dereference the ParentHandle here
1196 return (mEfiShellEnvironment2
->Execute(*ParentHandle
,
1201 return (EFI_UNSUPPORTED
);
1204 Retreives the current directory path
1206 If the DeviceName is NULL, it returns the current device's current directory
1207 name. If the DeviceName is not NULL, it returns the current directory name
1210 @param DeviceName the name of the drive to get directory on
1212 @retval NULL the directory does not exist
1213 @return != NULL the directory
1217 ShellGetCurrentDir (
1218 IN CHAR16
* CONST DeviceName OPTIONAL
1222 // Check for UEFI Shell 2.0 protocols
1224 if (gEfiShellProtocol
!= NULL
) {
1225 return (gEfiShellProtocol
->GetCurDir(DeviceName
));
1229 // Check for EFI shell
1231 if (mEfiShellEnvironment2
!= NULL
) {
1232 return (mEfiShellEnvironment2
->CurDir(DeviceName
));
1238 sets (enabled or disabled) the page break mode
1240 when page break mode is enabled the screen will stop scrolling
1241 and wait for operator input before scrolling a subsequent screen.
1243 @param CurrentState TRUE to enable and FALSE to disable
1247 ShellSetPageBreakMode (
1248 IN BOOLEAN CurrentState
1252 // check for enabling
1254 if (CurrentState
!= 0x00) {
1256 // check for UEFI Shell 2.0
1258 if (gEfiShellProtocol
!= NULL
) {
1260 // Enable with UEFI 2.0 Shell
1262 gEfiShellProtocol
->EnablePageBreak();
1266 // Check for EFI shell
1268 if (mEfiShellEnvironment2
!= NULL
) {
1270 // Enable with EFI Shell
1272 mEfiShellEnvironment2
->EnablePageBreak (DEFAULT_INIT_ROW
, DEFAULT_AUTO_LF
);
1278 // check for UEFI Shell 2.0
1280 if (gEfiShellProtocol
!= NULL
) {
1282 // Disable with UEFI 2.0 Shell
1284 gEfiShellProtocol
->DisablePageBreak();
1288 // Check for EFI shell
1290 if (mEfiShellEnvironment2
!= NULL
) {
1292 // Disable with EFI Shell
1294 mEfiShellEnvironment2
->DisablePageBreak ();
1302 /// version of EFI_SHELL_FILE_INFO struct, except has no CONST pointers.
1303 /// This allows for the struct to be populated.
1310 SHELL_FILE_HANDLE Handle
;
1311 EFI_FILE_INFO
*Info
;
1312 } EFI_SHELL_FILE_INFO_NO_CONST
;
1315 Converts a EFI shell list of structures to the coresponding UEFI Shell 2.0 type of list.
1317 if OldStyleFileList is NULL then ASSERT()
1319 this function will convert a SHELL_FILE_ARG based list into a callee allocated
1320 EFI_SHELL_FILE_INFO based list. it is up to the caller to free the memory via
1321 the ShellCloseFileMetaArg function.
1323 @param[in] FileList the EFI shell list type
1324 @param[in, out] ListHead the list to add to
1326 @retval the resultant head of the double linked new format list;
1330 InternalShellConvertFileListType (
1331 IN LIST_ENTRY
*FileList
,
1332 IN OUT LIST_ENTRY
*ListHead
1335 SHELL_FILE_ARG
*OldInfo
;
1337 EFI_SHELL_FILE_INFO_NO_CONST
*NewInfo
;
1342 ASSERT(FileList
!= NULL
);
1343 ASSERT(ListHead
!= NULL
);
1346 // enumerate through each member of the old list and copy
1348 for (Link
= FileList
->ForwardLink
; Link
!= FileList
; Link
= Link
->ForwardLink
) {
1349 OldInfo
= CR (Link
, SHELL_FILE_ARG
, Link
, SHELL_FILE_ARG_SIGNATURE
);
1350 ASSERT(OldInfo
!= NULL
);
1353 // Skip ones that failed to open...
1355 if (OldInfo
->Status
!= EFI_SUCCESS
) {
1360 // make sure the old list was valid
1362 ASSERT(OldInfo
->Info
!= NULL
);
1363 ASSERT(OldInfo
->FullName
!= NULL
);
1364 ASSERT(OldInfo
->FileName
!= NULL
);
1367 // allocate a new EFI_SHELL_FILE_INFO object
1369 NewInfo
= AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1370 if (NewInfo
== NULL
) {
1371 ShellCloseFileMetaArg((EFI_SHELL_FILE_INFO
**)(&ListHead
));
1377 // copy the simple items
1379 NewInfo
->Handle
= OldInfo
->Handle
;
1380 NewInfo
->Status
= OldInfo
->Status
;
1382 // old shell checks for 0 not NULL
1383 OldInfo
->Handle
= 0;
1386 // allocate new space to copy strings and structure
1388 NewInfo
->FullName
= AllocateZeroPool(StrSize(OldInfo
->FullName
));
1389 NewInfo
->FileName
= AllocateZeroPool(StrSize(OldInfo
->FileName
));
1390 NewInfo
->Info
= AllocateZeroPool((UINTN
)OldInfo
->Info
->Size
);
1393 // make sure all the memory allocations were sucessful
1395 if (NULL
== NewInfo
->FullName
|| NewInfo
->FileName
== NULL
|| NewInfo
->Info
== NULL
) {
1396 ShellCloseFileMetaArg((EFI_SHELL_FILE_INFO
**)(&ListHead
));
1402 // Copt the strings and structure
1404 StrCpy(NewInfo
->FullName
, OldInfo
->FullName
);
1405 StrCpy(NewInfo
->FileName
, OldInfo
->FileName
);
1406 gBS
->CopyMem (NewInfo
->Info
, OldInfo
->Info
, (UINTN
)OldInfo
->Info
->Size
);
1409 // add that to the list
1411 InsertTailList(ListHead
, &NewInfo
->Link
);
1416 Opens a group of files based on a path.
1418 This function uses the Arg to open all the matching files. Each matched
1419 file has a SHELL_FILE_ARG structure to record the file information. These
1420 structures are placed on the list ListHead. Users can get the SHELL_FILE_ARG
1421 structures from ListHead to access each file. This function supports wildcards
1422 and will process '?' and '*' as such. the list must be freed with a call to
1423 ShellCloseFileMetaArg().
1425 If you are NOT appending to an existing list *ListHead must be NULL. If
1426 *ListHead is NULL then it must be callee freed.
1428 @param Arg pointer to path string
1429 @param OpenMode mode to open files with
1430 @param ListHead head of linked list of results
1432 @retval EFI_SUCCESS the operation was sucessful and the list head
1433 contains the list of opened files
1434 @return != EFI_SUCCESS the operation failed
1436 @sa InternalShellConvertFileListType
1440 ShellOpenFileMetaArg (
1443 IN OUT EFI_SHELL_FILE_INFO
**ListHead
1447 LIST_ENTRY mOldStyleFileList
;
1450 // ASSERT that Arg and ListHead are not NULL
1452 ASSERT(Arg
!= NULL
);
1453 ASSERT(ListHead
!= NULL
);
1456 // Check for UEFI Shell 2.0 protocols
1458 if (gEfiShellProtocol
!= NULL
) {
1459 if (*ListHead
== NULL
) {
1460 *ListHead
= (EFI_SHELL_FILE_INFO
*)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1461 if (*ListHead
== NULL
) {
1462 return (EFI_OUT_OF_RESOURCES
);
1464 InitializeListHead(&((*ListHead
)->Link
));
1466 Status
= gEfiShellProtocol
->OpenFileList(Arg
,
1469 if (EFI_ERROR(Status
)) {
1470 gEfiShellProtocol
->RemoveDupInFileList(ListHead
);
1472 Status
= gEfiShellProtocol
->RemoveDupInFileList(ListHead
);
1474 if (*ListHead
!= NULL
&& IsListEmpty(&(*ListHead
)->Link
)) {
1475 FreePool(*ListHead
);
1477 return (EFI_NOT_FOUND
);
1483 // Check for EFI shell
1485 if (mEfiShellEnvironment2
!= NULL
) {
1487 // make sure the list head is initialized
1489 InitializeListHead(&mOldStyleFileList
);
1492 // Get the EFI Shell list of files
1494 Status
= mEfiShellEnvironment2
->FileMetaArg(Arg
, &mOldStyleFileList
);
1495 if (EFI_ERROR(Status
)) {
1500 if (*ListHead
== NULL
) {
1501 *ListHead
= (EFI_SHELL_FILE_INFO
*)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO
));
1502 if (*ListHead
== NULL
) {
1503 return (EFI_OUT_OF_RESOURCES
);
1505 InitializeListHead(&((*ListHead
)->Link
));
1509 // Convert that to equivalent of UEFI Shell 2.0 structure
1511 InternalShellConvertFileListType(&mOldStyleFileList
, &(*ListHead
)->Link
);
1514 // Free the EFI Shell version that was converted.
1516 mEfiShellEnvironment2
->FreeFileList(&mOldStyleFileList
);
1518 if ((*ListHead
)->Link
.ForwardLink
== (*ListHead
)->Link
.BackLink
&& (*ListHead
)->Link
.BackLink
== &((*ListHead
)->Link
)) {
1519 FreePool(*ListHead
);
1521 Status
= EFI_NOT_FOUND
;
1526 return (EFI_UNSUPPORTED
);
1529 Free the linked list returned from ShellOpenFileMetaArg.
1531 if ListHead is NULL then ASSERT().
1533 @param ListHead the pointer to free.
1535 @retval EFI_SUCCESS the operation was sucessful.
1539 ShellCloseFileMetaArg (
1540 IN OUT EFI_SHELL_FILE_INFO
**ListHead
1546 // ASSERT that ListHead is not NULL
1548 ASSERT(ListHead
!= NULL
);
1551 // Check for UEFI Shell 2.0 protocols
1553 if (gEfiShellProtocol
!= NULL
) {
1554 return (gEfiShellProtocol
->FreeFileList(ListHead
));
1555 } else if (mEfiShellEnvironment2
!= NULL
) {
1557 // Since this is EFI Shell version we need to free our internally made copy
1560 for ( Node
= GetFirstNode(&(*ListHead
)->Link
)
1561 ; *ListHead
!= NULL
&& !IsListEmpty(&(*ListHead
)->Link
)
1562 ; Node
= GetFirstNode(&(*ListHead
)->Link
)) {
1563 RemoveEntryList(Node
);
1564 ((EFI_FILE_PROTOCOL
*)((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
)->Handle
)->Close(((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
)->Handle
);
1565 FreePool(((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
)->FullName
);
1566 FreePool(((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
)->FileName
);
1567 FreePool(((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
)->Info
);
1568 FreePool((EFI_SHELL_FILE_INFO_NO_CONST
*)Node
);
1573 return (EFI_UNSUPPORTED
);
1577 Find a file by searching the CWD and then the path.
1579 If FileName is NULL then ASSERT.
1581 If the return value is not NULL then the memory must be caller freed.
1583 @param FileName Filename string.
1585 @retval NULL the file was not found
1586 @return !NULL the full path to the file.
1591 IN CONST CHAR16
*FileName
1595 SHELL_FILE_HANDLE Handle
;
1599 CONST CHAR16
*Walker
;
1606 // First make sure its not an absolute path.
1608 Status
= ShellOpenFileByName(FileName
, &Handle
, EFI_FILE_MODE_READ
, 0);
1609 if (!EFI_ERROR(Status
)){
1610 if (FileHandleIsDirectory(Handle
) != EFI_SUCCESS
) {
1611 ASSERT(RetVal
== NULL
);
1612 RetVal
= StrnCatGrow(&RetVal
, NULL
, FileName
, 0);
1613 ShellCloseFile(&Handle
);
1616 ShellCloseFile(&Handle
);
1620 Path
= ShellGetEnvironmentVariable(L
"cwd");
1622 Size
= StrSize(Path
);
1623 Size
+= StrSize(FileName
);
1624 TestPath
= AllocateZeroPool(Size
);
1625 if (TestPath
== NULL
) {
1628 StrCpy(TestPath
, Path
);
1629 StrCat(TestPath
, FileName
);
1630 Status
= ShellOpenFileByName(TestPath
, &Handle
, EFI_FILE_MODE_READ
, 0);
1631 if (!EFI_ERROR(Status
)){
1632 if (FileHandleIsDirectory(Handle
) != EFI_SUCCESS
) {
1633 ASSERT(RetVal
== NULL
);
1634 RetVal
= StrnCatGrow(&RetVal
, NULL
, TestPath
, 0);
1635 ShellCloseFile(&Handle
);
1639 ShellCloseFile(&Handle
);
1644 Path
= ShellGetEnvironmentVariable(L
"path");
1646 Size
= StrSize(Path
)+sizeof(CHAR16
);
1647 Size
+= StrSize(FileName
);
1648 TestPath
= AllocateZeroPool(Size
);
1649 if (TestPath
== NULL
) {
1652 Walker
= (CHAR16
*)Path
;
1654 CopyMem(TestPath
, Walker
, StrSize(Walker
));
1655 if (TestPath
!= NULL
) {
1656 TempChar
= StrStr(TestPath
, L
";");
1657 if (TempChar
!= NULL
) {
1658 *TempChar
= CHAR_NULL
;
1660 if (TestPath
[StrLen(TestPath
)-1] != L
'\\') {
1661 StrCat(TestPath
, L
"\\");
1663 if (FileName
[0] == L
'\\') {
1666 StrCat(TestPath
, FileName
);
1667 if (StrStr(Walker
, L
";") != NULL
) {
1668 Walker
= StrStr(Walker
, L
";") + 1;
1672 Status
= ShellOpenFileByName(TestPath
, &Handle
, EFI_FILE_MODE_READ
, 0);
1673 if (!EFI_ERROR(Status
)){
1674 if (FileHandleIsDirectory(Handle
) != EFI_SUCCESS
) {
1675 ASSERT(RetVal
== NULL
);
1676 RetVal
= StrnCatGrow(&RetVal
, NULL
, TestPath
, 0);
1677 ShellCloseFile(&Handle
);
1680 ShellCloseFile(&Handle
);
1684 } while (Walker
!= NULL
&& Walker
[0] != CHAR_NULL
);
1691 Find a file by searching the CWD and then the path with a variable set of file
1692 extensions. If the file is not found it will append each extension in the list
1693 in the order provided and return the first one that is successful.
1695 If FileName is NULL, then ASSERT.
1696 If FileExtension is NULL, then behavior is identical to ShellFindFilePath.
1698 If the return value is not NULL then the memory must be caller freed.
1700 @param[in] FileName Filename string.
1701 @param[in] FileExtension Semi-colon delimeted list of possible extensions.
1703 @retval NULL The file was not found.
1704 @retval !NULL The path to the file.
1708 ShellFindFilePathEx (
1709 IN CONST CHAR16
*FileName
,
1710 IN CONST CHAR16
*FileExtension
1715 CONST CHAR16
*ExtensionWalker
;
1720 ASSERT(FileName
!= NULL
);
1721 if (FileExtension
== NULL
) {
1722 return (ShellFindFilePath(FileName
));
1724 RetVal
= ShellFindFilePath(FileName
);
1725 if (RetVal
!= NULL
) {
1728 Size
= StrSize(FileName
);
1729 Size
+= StrSize(FileExtension
);
1730 TestPath
= AllocateZeroPool(Size
);
1731 if (TestPath
== NULL
) {
1734 for (ExtensionWalker
= FileExtension
, TempChar2
= (CHAR16
*)FileExtension
; TempChar2
!= NULL
; ExtensionWalker
= TempChar2
+ 1){
1735 StrCpy(TestPath
, FileName
);
1736 if (ExtensionWalker
!= NULL
) {
1737 StrCat(TestPath
, ExtensionWalker
);
1739 TempChar
= StrStr(TestPath
, L
";");
1740 if (TempChar
!= NULL
) {
1741 *TempChar
= CHAR_NULL
;
1743 RetVal
= ShellFindFilePath(TestPath
);
1744 if (RetVal
!= NULL
) {
1747 ASSERT(ExtensionWalker
!= NULL
);
1748 TempChar2
= StrStr(ExtensionWalker
, L
";");
1757 SHELL_PARAM_TYPE Type
;
1759 UINTN OriginalPosition
;
1760 } SHELL_PARAM_PACKAGE
;
1763 Checks the list of valid arguments and returns TRUE if the item was found. If the
1764 return value is TRUE then the type parameter is set also.
1766 if CheckList is NULL then ASSERT();
1767 if Name is NULL then ASSERT();
1768 if Type is NULL then ASSERT();
1770 @param Name pointer to Name of parameter found
1771 @param CheckList List to check against
1772 @param Type pointer to type of parameter if it was found
1774 @retval TRUE the Parameter was found. Type is valid.
1775 @retval FALSE the Parameter was not found. Type is not valid.
1779 InternalIsOnCheckList (
1780 IN CONST CHAR16
*Name
,
1781 IN CONST SHELL_PARAM_ITEM
*CheckList
,
1782 OUT SHELL_PARAM_TYPE
*Type
1785 SHELL_PARAM_ITEM
*TempListItem
;
1789 // ASSERT that all 3 pointer parameters aren't NULL
1791 ASSERT(CheckList
!= NULL
);
1792 ASSERT(Type
!= NULL
);
1793 ASSERT(Name
!= NULL
);
1796 // question mark and page break mode are always supported
1798 if ((StrCmp(Name
, L
"-?") == 0) ||
1799 (StrCmp(Name
, L
"-b") == 0)
1806 // Enumerate through the list
1808 for (TempListItem
= (SHELL_PARAM_ITEM
*)CheckList
; TempListItem
->Name
!= NULL
; TempListItem
++) {
1810 // If the Type is TypeStart only check the first characters of the passed in param
1811 // If it matches set the type and return TRUE
1813 if (TempListItem
->Type
== TypeStart
) {
1814 if (StrnCmp(Name
, TempListItem
->Name
, StrLen(TempListItem
->Name
)) == 0) {
1815 *Type
= TempListItem
->Type
;
1819 TempString
= StrnCatGrow(&TempString
, NULL
, Name
, StrLen(TempListItem
->Name
));
1820 if (TempString
!= NULL
) {
1821 if (StringNoCaseCompare(&TempString
, &TempListItem
->Name
) == 0) {
1822 *Type
= TempListItem
->Type
;
1823 FreePool(TempString
);
1826 FreePool(TempString
);
1828 } else if (StringNoCaseCompare(&Name
, &TempListItem
->Name
) == 0) {
1829 *Type
= TempListItem
->Type
;
1837 Checks the string for indicators of "flag" status. this is a leading '/', '-', or '+'
1839 @param[in] Name pointer to Name of parameter found
1840 @param[in] AlwaysAllowNumbers TRUE to allow numbers, FALSE to not.
1842 @retval TRUE the Parameter is a flag.
1843 @retval FALSE the Parameter not a flag.
1848 IN CONST CHAR16
*Name
,
1849 IN BOOLEAN AlwaysAllowNumbers
1853 // ASSERT that Name isn't NULL
1855 ASSERT(Name
!= NULL
);
1858 // If we accept numbers then dont return TRUE. (they will be values)
1860 if (((Name
[0] == L
'-' || Name
[0] == L
'+') && ShellIsHexaDecimalDigitCharacter(Name
[1])) && AlwaysAllowNumbers
) {
1865 // If the Name has a /, +, or - as the first character return TRUE
1867 if ((Name
[0] == L
'/') ||
1868 (Name
[0] == L
'-') ||
1877 Checks the command line arguments passed against the list of valid ones.
1879 If no initialization is required, then return RETURN_SUCCESS.
1881 @param[in] CheckList pointer to list of parameters to check
1882 @param[out] CheckPackage pointer to pointer to list checked values
1883 @param[out] ProblemParam optional pointer to pointer to unicode string for
1884 the paramater that caused failure. If used then the
1885 caller is responsible for freeing the memory.
1886 @param[in] AutoPageBreak will automatically set PageBreakEnabled for "b" parameter
1887 @param[in] Argv pointer to array of parameters
1888 @param[in] Argc Count of parameters in Argv
1889 @param[in] AlwaysAllowNumbers TRUE to allow numbers always, FALSE otherwise.
1891 @retval EFI_SUCCESS The operation completed sucessfully.
1892 @retval EFI_OUT_OF_RESOURCES A memory allocation failed
1893 @retval EFI_INVALID_PARAMETER A parameter was invalid
1894 @retval EFI_VOLUME_CORRUPTED the command line was corrupt. an argument was
1895 duplicated. the duplicated command line argument
1896 was returned in ProblemParam if provided.
1897 @retval EFI_NOT_FOUND a argument required a value that was missing.
1898 the invalid command line argument was returned in
1899 ProblemParam if provided.
1903 InternalCommandLineParse (
1904 IN CONST SHELL_PARAM_ITEM
*CheckList
,
1905 OUT LIST_ENTRY
**CheckPackage
,
1906 OUT CHAR16
**ProblemParam OPTIONAL
,
1907 IN BOOLEAN AutoPageBreak
,
1908 IN CONST CHAR16
**Argv
,
1910 IN BOOLEAN AlwaysAllowNumbers
1914 SHELL_PARAM_TYPE CurrentItemType
;
1915 SHELL_PARAM_PACKAGE
*CurrentItemPackage
;
1919 CONST CHAR16
*TempPointer
;
1921 CurrentItemPackage
= NULL
;
1927 // If there is only 1 item we dont need to do anything
1930 *CheckPackage
= NULL
;
1931 return (EFI_SUCCESS
);
1937 ASSERT(CheckList
!= NULL
);
1938 ASSERT(Argv
!= NULL
);
1941 // initialize the linked list
1943 *CheckPackage
= (LIST_ENTRY
*)AllocateZeroPool(sizeof(LIST_ENTRY
));
1944 if (*CheckPackage
== NULL
) {
1945 return (EFI_OUT_OF_RESOURCES
);
1948 InitializeListHead(*CheckPackage
);
1951 // loop through each of the arguments
1953 for (LoopCounter
= 0 ; LoopCounter
< Argc
; ++LoopCounter
) {
1954 if (Argv
[LoopCounter
] == NULL
) {
1956 // do nothing for NULL argv
1958 } else if (InternalIsOnCheckList(Argv
[LoopCounter
], CheckList
, &CurrentItemType
)) {
1960 // We might have leftover if last parameter didnt have optional value
1962 if (GetItemValue
!= 0) {
1964 InsertHeadList(*CheckPackage
, &CurrentItemPackage
->Link
);
1969 CurrentItemPackage
= AllocateZeroPool(sizeof(SHELL_PARAM_PACKAGE
));
1970 if (CurrentItemPackage
== NULL
) {
1971 ShellCommandLineFreeVarList(*CheckPackage
);
1972 *CheckPackage
= NULL
;
1973 return (EFI_OUT_OF_RESOURCES
);
1975 CurrentItemPackage
->Name
= AllocateZeroPool(StrSize(Argv
[LoopCounter
]));
1976 if (CurrentItemPackage
->Name
== NULL
) {
1977 ShellCommandLineFreeVarList(*CheckPackage
);
1978 *CheckPackage
= NULL
;
1979 return (EFI_OUT_OF_RESOURCES
);
1981 StrCpy(CurrentItemPackage
->Name
, Argv
[LoopCounter
]);
1982 CurrentItemPackage
->Type
= CurrentItemType
;
1983 CurrentItemPackage
->OriginalPosition
= (UINTN
)(-1);
1984 CurrentItemPackage
->Value
= NULL
;
1987 // Does this flag require a value
1989 switch (CurrentItemPackage
->Type
) {
1991 // possibly trigger the next loop(s) to populate the value of this item
1997 case TypeDoubleValue
:
2002 GetItemValue
= (UINTN
)(-1);
2007 // this item has no value expected; we are done
2009 InsertHeadList(*CheckPackage
, &CurrentItemPackage
->Link
);
2010 ASSERT(GetItemValue
== 0);
2013 } else if (GetItemValue
!= 0 && !InternalIsFlag(Argv
[LoopCounter
], AlwaysAllowNumbers
)) {
2014 ASSERT(CurrentItemPackage
!= NULL
);
2016 // get the item VALUE for a previous flag
2018 if (StrStr(Argv
[LoopCounter
], L
" ") == NULL
) {
2019 CurrentItemPackage
->Value
= ReallocatePool(ValueSize
, ValueSize
+ StrSize(Argv
[LoopCounter
]) + sizeof(CHAR16
), CurrentItemPackage
->Value
);
2020 ASSERT(CurrentItemPackage
->Value
!= NULL
);
2021 if (ValueSize
== 0) {
2022 StrCpy(CurrentItemPackage
->Value
, Argv
[LoopCounter
]);
2024 StrCat(CurrentItemPackage
->Value
, L
" ");
2025 StrCat(CurrentItemPackage
->Value
, Argv
[LoopCounter
]);
2027 ValueSize
+= StrSize(Argv
[LoopCounter
]) + sizeof(CHAR16
);
2030 // the parameter has spaces. must be quoted.
2032 CurrentItemPackage
->Value
= ReallocatePool(ValueSize
, ValueSize
+ StrSize(Argv
[LoopCounter
]) + sizeof(CHAR16
) + sizeof(CHAR16
) + sizeof(CHAR16
), CurrentItemPackage
->Value
);
2033 ASSERT(CurrentItemPackage
->Value
!= NULL
);
2034 if (ValueSize
== 0) {
2035 StrCpy(CurrentItemPackage
->Value
, L
"\"");
2036 StrCat(CurrentItemPackage
->Value
, Argv
[LoopCounter
]);
2037 StrCat(CurrentItemPackage
->Value
, L
"\"");
2039 StrCat(CurrentItemPackage
->Value
, L
" ");
2040 StrCat(CurrentItemPackage
->Value
, L
"\"");
2041 StrCat(CurrentItemPackage
->Value
, Argv
[LoopCounter
]);
2042 StrCat(CurrentItemPackage
->Value
, L
"\"");
2044 ValueSize
+= StrSize(Argv
[LoopCounter
]) + sizeof(CHAR16
);
2047 if (GetItemValue
== 0) {
2048 InsertHeadList(*CheckPackage
, &CurrentItemPackage
->Link
);
2050 } else if (!InternalIsFlag(Argv
[LoopCounter
], AlwaysAllowNumbers
) ){ //|| ProblemParam == NULL) {
2052 // add this one as a non-flag
2055 TempPointer
= Argv
[LoopCounter
];
2056 if ((*TempPointer
== L
'^' && *(TempPointer
+1) == L
'-')
2057 || (*TempPointer
== L
'^' && *(TempPointer
+1) == L
'/')
2058 || (*TempPointer
== L
'^' && *(TempPointer
+1) == L
'+')
2062 CurrentItemPackage
= AllocateZeroPool(sizeof(SHELL_PARAM_PACKAGE
));
2063 if (CurrentItemPackage
== NULL
) {
2064 ShellCommandLineFreeVarList(*CheckPackage
);
2065 *CheckPackage
= NULL
;
2066 return (EFI_OUT_OF_RESOURCES
);
2068 CurrentItemPackage
->Name
= NULL
;
2069 CurrentItemPackage
->Type
= TypePosition
;
2070 CurrentItemPackage
->Value
= AllocateZeroPool(StrSize(TempPointer
));
2071 if (CurrentItemPackage
->Value
== NULL
) {
2072 ShellCommandLineFreeVarList(*CheckPackage
);
2073 *CheckPackage
= NULL
;
2074 return (EFI_OUT_OF_RESOURCES
);
2076 StrCpy(CurrentItemPackage
->Value
, TempPointer
);
2077 CurrentItemPackage
->OriginalPosition
= Count
++;
2078 InsertHeadList(*CheckPackage
, &CurrentItemPackage
->Link
);
2081 // this was a non-recognised flag... error!
2083 if (ProblemParam
!= NULL
) {
2084 *ProblemParam
= AllocateZeroPool(StrSize(Argv
[LoopCounter
]));
2085 if (*ProblemParam
!= NULL
) {
2086 StrCpy(*ProblemParam
, Argv
[LoopCounter
]);
2089 ShellCommandLineFreeVarList(*CheckPackage
);
2090 *CheckPackage
= NULL
;
2091 return (EFI_VOLUME_CORRUPTED
);
2094 if (GetItemValue
!= 0) {
2096 InsertHeadList(*CheckPackage
, &CurrentItemPackage
->Link
);
2099 // support for AutoPageBreak
2101 if (AutoPageBreak
&& ShellCommandLineGetFlag(*CheckPackage
, L
"-b")) {
2102 ShellSetPageBreakMode(TRUE
);
2104 return (EFI_SUCCESS
);
2108 Checks the command line arguments passed against the list of valid ones.
2109 Optionally removes NULL values first.
2111 If no initialization is required, then return RETURN_SUCCESS.
2113 @param[in] CheckList The pointer to list of parameters to check.
2114 @param[out] CheckPackage The package of checked values.
2115 @param[out] ProblemParam Optional pointer to pointer to unicode string for
2116 the paramater that caused failure.
2117 @param[in] AutoPageBreak Will automatically set PageBreakEnabled.
2118 @param[in] AlwaysAllowNumbers Will never fail for number based flags.
2120 @retval EFI_SUCCESS The operation completed sucessfully.
2121 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
2122 @retval EFI_INVALID_PARAMETER A parameter was invalid.
2123 @retval EFI_VOLUME_CORRUPTED The command line was corrupt.
2124 @retval EFI_DEVICE_ERROR The commands contained 2 opposing arguments. One
2125 of the command line arguments was returned in
2126 ProblemParam if provided.
2127 @retval EFI_NOT_FOUND A argument required a value that was missing.
2128 The invalid command line argument was returned in
2129 ProblemParam if provided.
2133 ShellCommandLineParseEx (
2134 IN CONST SHELL_PARAM_ITEM
*CheckList
,
2135 OUT LIST_ENTRY
**CheckPackage
,
2136 OUT CHAR16
**ProblemParam OPTIONAL
,
2137 IN BOOLEAN AutoPageBreak
,
2138 IN BOOLEAN AlwaysAllowNumbers
2142 // ASSERT that CheckList and CheckPackage aren't NULL
2144 ASSERT(CheckList
!= NULL
);
2145 ASSERT(CheckPackage
!= NULL
);
2148 // Check for UEFI Shell 2.0 protocols
2150 if (gEfiShellParametersProtocol
!= NULL
) {
2151 return (InternalCommandLineParse(CheckList
,
2155 (CONST CHAR16
**) gEfiShellParametersProtocol
->Argv
,
2156 gEfiShellParametersProtocol
->Argc
,
2157 AlwaysAllowNumbers
));
2161 // ASSERT That EFI Shell is not required
2163 ASSERT (mEfiShellInterface
!= NULL
);
2164 return (InternalCommandLineParse(CheckList
,
2168 (CONST CHAR16
**) mEfiShellInterface
->Argv
,
2169 mEfiShellInterface
->Argc
,
2170 AlwaysAllowNumbers
));
2174 Frees shell variable list that was returned from ShellCommandLineParse.
2176 This function will free all the memory that was used for the CheckPackage
2177 list of postprocessed shell arguments.
2179 this function has no return value.
2181 if CheckPackage is NULL, then return
2183 @param CheckPackage the list to de-allocate
2187 ShellCommandLineFreeVarList (
2188 IN LIST_ENTRY
*CheckPackage
2194 // check for CheckPackage == NULL
2196 if (CheckPackage
== NULL
) {
2201 // for each node in the list
2203 for ( Node
= GetFirstNode(CheckPackage
)
2204 ; !IsListEmpty(CheckPackage
)
2205 ; Node
= GetFirstNode(CheckPackage
)
2208 // Remove it from the list
2210 RemoveEntryList(Node
);
2213 // if it has a name free the name
2215 if (((SHELL_PARAM_PACKAGE
*)Node
)->Name
!= NULL
) {
2216 FreePool(((SHELL_PARAM_PACKAGE
*)Node
)->Name
);
2220 // if it has a value free the value
2222 if (((SHELL_PARAM_PACKAGE
*)Node
)->Value
!= NULL
) {
2223 FreePool(((SHELL_PARAM_PACKAGE
*)Node
)->Value
);
2227 // free the node structure
2229 FreePool((SHELL_PARAM_PACKAGE
*)Node
);
2232 // free the list head node
2234 FreePool(CheckPackage
);
2237 Checks for presence of a flag parameter
2239 flag arguments are in the form of "-<Key>" or "/<Key>", but do not have a value following the key
2241 if CheckPackage is NULL then return FALSE.
2242 if KeyString is NULL then ASSERT()
2244 @param CheckPackage The package of parsed command line arguments
2245 @param KeyString the Key of the command line argument to check for
2247 @retval TRUE the flag is on the command line
2248 @retval FALSE the flag is not on the command line
2252 ShellCommandLineGetFlag (
2253 IN CONST LIST_ENTRY
* CONST CheckPackage
,
2254 IN CONST CHAR16
* CONST KeyString
2261 // return FALSE for no package or KeyString is NULL
2263 if (CheckPackage
== NULL
|| KeyString
== NULL
) {
2268 // enumerate through the list of parametrs
2270 for ( Node
= GetFirstNode(CheckPackage
)
2271 ; !IsNull (CheckPackage
, Node
)
2272 ; Node
= GetNextNode(CheckPackage
, Node
)
2275 // If the Name matches, return TRUE (and there may be NULL name)
2277 if (((SHELL_PARAM_PACKAGE
*)Node
)->Name
!= NULL
) {
2279 // If Type is TypeStart then only compare the begining of the strings
2281 if (((SHELL_PARAM_PACKAGE
*)Node
)->Type
== TypeStart
) {
2282 if (StrnCmp(KeyString
, ((SHELL_PARAM_PACKAGE
*)Node
)->Name
, StrLen(KeyString
)) == 0) {
2286 TempString
= StrnCatGrow(&TempString
, NULL
, KeyString
, StrLen(((SHELL_PARAM_PACKAGE
*)Node
)->Name
));
2287 if (TempString
!= NULL
) {
2288 if (StringNoCaseCompare(&KeyString
, &((SHELL_PARAM_PACKAGE
*)Node
)->Name
) == 0) {
2289 FreePool(TempString
);
2292 FreePool(TempString
);
2294 } else if (StringNoCaseCompare(&KeyString
, &((SHELL_PARAM_PACKAGE
*)Node
)->Name
) == 0) {
2302 Returns value from command line argument.
2304 Value parameters are in the form of "-<Key> value" or "/<Key> value".
2306 If CheckPackage is NULL, then return NULL.
2308 @param[in] CheckPackage The package of parsed command line arguments.
2309 @param[in] KeyString The Key of the command line argument to check for.
2311 @retval NULL The flag is not on the command line.
2312 @retval !=NULL The pointer to unicode string of the value.
2316 ShellCommandLineGetValue (
2317 IN CONST LIST_ENTRY
*CheckPackage
,
2318 IN CHAR16
*KeyString
2325 // return NULL for no package or KeyString is NULL
2327 if (CheckPackage
== NULL
|| KeyString
== NULL
) {
2332 // enumerate through the list of parametrs
2334 for ( Node
= GetFirstNode(CheckPackage
)
2335 ; !IsNull (CheckPackage
, Node
)
2336 ; Node
= GetNextNode(CheckPackage
, Node
)
2339 // If the Name matches, return TRUE (and there may be NULL name)
2341 if (((SHELL_PARAM_PACKAGE
*)Node
)->Name
!= NULL
) {
2343 // If Type is TypeStart then only compare the begining of the strings
2345 if (((SHELL_PARAM_PACKAGE
*)Node
)->Type
== TypeStart
) {
2346 if (StrnCmp(KeyString
, ((SHELL_PARAM_PACKAGE
*)Node
)->Name
, StrLen(KeyString
)) == 0) {
2347 return (((SHELL_PARAM_PACKAGE
*)Node
)->Name
+ StrLen(KeyString
));
2350 TempString
= StrnCatGrow(&TempString
, NULL
, KeyString
, StrLen(((SHELL_PARAM_PACKAGE
*)Node
)->Name
));
2351 if (TempString
!= NULL
) {
2352 if (StringNoCaseCompare(&KeyString
, &((SHELL_PARAM_PACKAGE
*)Node
)->Name
) == 0) {
2353 FreePool(TempString
);
2354 return (((SHELL_PARAM_PACKAGE
*)Node
)->Name
+ StrLen(KeyString
));
2356 FreePool(TempString
);
2358 } else if (StringNoCaseCompare(&KeyString
, &((SHELL_PARAM_PACKAGE
*)Node
)->Name
) == 0) {
2359 return (((SHELL_PARAM_PACKAGE
*)Node
)->Value
);
2367 Returns raw value from command line argument.
2369 Raw value parameters are in the form of "value" in a specific position in the list.
2371 If CheckPackage is NULL, then return NULL.
2373 @param[in] CheckPackage The package of parsed command line arguments.
2374 @param[in] Position The position of the value.
2376 @retval NULL The flag is not on the command line.
2377 @retval !=NULL The pointer to unicode string of the value.
2381 ShellCommandLineGetRawValue (
2382 IN CONST LIST_ENTRY
* CONST CheckPackage
,
2389 // check for CheckPackage == NULL
2391 if (CheckPackage
== NULL
) {
2396 // enumerate through the list of parametrs
2398 for ( Node
= GetFirstNode(CheckPackage
)
2399 ; !IsNull (CheckPackage
, Node
)
2400 ; Node
= GetNextNode(CheckPackage
, Node
)
2403 // If the position matches, return the value
2405 if (((SHELL_PARAM_PACKAGE
*)Node
)->OriginalPosition
== Position
) {
2406 return (((SHELL_PARAM_PACKAGE
*)Node
)->Value
);
2413 returns the number of command line value parameters that were parsed.
2415 this will not include flags.
2417 @param[in] CheckPackage The package of parsed command line arguments.
2419 @retval (UINTN)-1 No parsing has ocurred
2420 @return other The number of value parameters found
2424 ShellCommandLineGetCount(
2425 IN CONST LIST_ENTRY
*CheckPackage
2431 if (CheckPackage
== NULL
) {
2434 for ( Node1
= GetFirstNode(CheckPackage
), Count
= 0
2435 ; !IsNull (CheckPackage
, Node1
)
2436 ; Node1
= GetNextNode(CheckPackage
, Node1
)
2438 if (((SHELL_PARAM_PACKAGE
*)Node1
)->Name
== NULL
) {
2446 Determins if a parameter is duplicated.
2448 If Param is not NULL then it will point to a callee allocated string buffer
2449 with the parameter value if a duplicate is found.
2451 If CheckPackage is NULL, then ASSERT.
2453 @param[in] CheckPackage The package of parsed command line arguments.
2454 @param[out] Param Upon finding one, a pointer to the duplicated parameter.
2456 @retval EFI_SUCCESS No parameters were duplicated.
2457 @retval EFI_DEVICE_ERROR A duplicate was found.
2461 ShellCommandLineCheckDuplicate (
2462 IN CONST LIST_ENTRY
*CheckPackage
,
2469 ASSERT(CheckPackage
!= NULL
);
2471 for ( Node1
= GetFirstNode(CheckPackage
)
2472 ; !IsNull (CheckPackage
, Node1
)
2473 ; Node1
= GetNextNode(CheckPackage
, Node1
)
2475 for ( Node2
= GetNextNode(CheckPackage
, Node1
)
2476 ; !IsNull (CheckPackage
, Node2
)
2477 ; Node2
= GetNextNode(CheckPackage
, Node2
)
2479 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) {
2480 if (Param
!= NULL
) {
2482 *Param
= StrnCatGrow(Param
, NULL
, ((SHELL_PARAM_PACKAGE
*)Node1
)->Name
, 0);
2484 return (EFI_DEVICE_ERROR
);
2488 return (EFI_SUCCESS
);
2492 This is a find and replace function. Upon successful return the NewString is a copy of
2493 SourceString with each instance of FindTarget replaced with ReplaceWith.
2495 If SourceString and NewString overlap the behavior is undefined.
2497 If the string would grow bigger than NewSize it will halt and return error.
2499 @param[in] SourceString The string with source buffer.
2500 @param[in, out] NewString The string with resultant buffer.
2501 @param[in] NewSize The size in bytes of NewString.
2502 @param[in] FindTarget The string to look for.
2503 @param[in] ReplaceWith The string to replace FindTarget with.
2504 @param[in] SkipPreCarrot If TRUE will skip a FindTarget that has a '^'
2505 immediately before it.
2506 @param[in] ParameterReplacing If TRUE will add "" around items with spaces.
2508 @retval EFI_INVALID_PARAMETER SourceString was NULL.
2509 @retval EFI_INVALID_PARAMETER NewString was NULL.
2510 @retval EFI_INVALID_PARAMETER FindTarget was NULL.
2511 @retval EFI_INVALID_PARAMETER ReplaceWith was NULL.
2512 @retval EFI_INVALID_PARAMETER FindTarget had length < 1.
2513 @retval EFI_INVALID_PARAMETER SourceString had length < 1.
2514 @retval EFI_BUFFER_TOO_SMALL NewSize was less than the minimum size to hold
2515 the new string (truncation occurred).
2516 @retval EFI_SUCCESS The string was successfully copied with replacement.
2520 ShellCopySearchAndReplace(
2521 IN CHAR16 CONST
*SourceString
,
2522 IN OUT CHAR16
*NewString
,
2524 IN CONST CHAR16
*FindTarget
,
2525 IN CONST CHAR16
*ReplaceWith
,
2526 IN CONST BOOLEAN SkipPreCarrot
,
2527 IN CONST BOOLEAN ParameterReplacing
2533 if ( (SourceString
== NULL
)
2534 || (NewString
== NULL
)
2535 || (FindTarget
== NULL
)
2536 || (ReplaceWith
== NULL
)
2537 || (StrLen(FindTarget
) < 1)
2538 || (StrLen(SourceString
) < 1)
2540 return (EFI_INVALID_PARAMETER
);
2543 if (StrStr(ReplaceWith
, L
" ") == NULL
|| !ParameterReplacing
) {
2544 Replace
= StrnCatGrow(&Replace
, NULL
, ReplaceWith
, 0);
2546 Replace
= AllocateZeroPool(StrSize(ReplaceWith
) + 2*sizeof(CHAR16
));
2547 if (Replace
!= NULL
) {
2548 UnicodeSPrint(Replace
, StrSize(ReplaceWith
) + 2*sizeof(CHAR16
), L
"\"%s\"", ReplaceWith
);
2551 if (Replace
== NULL
) {
2552 return (EFI_OUT_OF_RESOURCES
);
2554 NewString
= SetMem16(NewString
, NewSize
, CHAR_NULL
);
2555 while (*SourceString
!= CHAR_NULL
) {
2557 // if we find the FindTarget and either Skip == FALSE or Skip and we
2558 // dont have a carrot do a replace...
2560 if (StrnCmp(SourceString
, FindTarget
, StrLen(FindTarget
)) == 0
2561 && ((SkipPreCarrot
&& *(SourceString
-1) != L
'^') || !SkipPreCarrot
)
2563 SourceString
+= StrLen(FindTarget
);
2564 Size
= StrSize(NewString
);
2565 if ((Size
+ (StrLen(Replace
)*sizeof(CHAR16
))) > NewSize
) {
2567 return (EFI_BUFFER_TOO_SMALL
);
2569 StrCat(NewString
, Replace
);
2571 Size
= StrSize(NewString
);
2572 if (Size
+ sizeof(CHAR16
) > NewSize
) {
2574 return (EFI_BUFFER_TOO_SMALL
);
2576 StrnCat(NewString
, SourceString
, 1);
2581 return (EFI_SUCCESS
);
2585 Internal worker function to output a string.
2587 This function will output a string to the correct StdOut.
2589 @param[in] String The string to print out.
2591 @retval EFI_SUCCESS The operation was sucessful.
2592 @retval !EFI_SUCCESS The operation failed.
2597 IN CONST CHAR16
*String
2601 Size
= StrSize(String
) - sizeof(CHAR16
);
2603 return (EFI_SUCCESS
);
2605 if (gEfiShellParametersProtocol
!= NULL
) {
2606 return (gEfiShellProtocol
->WriteFile(gEfiShellParametersProtocol
->StdOut
, &Size
, (VOID
*)String
));
2608 if (mEfiShellInterface
!= NULL
) {
2610 // Divide in half for old shell. Must be string length not size.
2613 return (mEfiShellInterface
->StdOut
->Write(mEfiShellInterface
->StdOut
, &Size
, (VOID
*)String
));
2616 return (EFI_UNSUPPORTED
);
2620 Print at a specific location on the screen.
2622 This function will move the cursor to a given screen location and print the specified string
2624 If -1 is specified for either the Row or Col the current screen location for BOTH
2627 if either Row or Col is out of range for the current console, then ASSERT
2628 if Format is NULL, then ASSERT
2630 In addition to the standard %-based flags as supported by UefiLib Print() this supports
2631 the following additional flags:
2632 %N - Set output attribute to normal
2633 %H - Set output attribute to highlight
2634 %E - Set output attribute to error
2635 %B - Set output attribute to blue color
2636 %V - Set output attribute to green color
2638 Note: The background color is controlled by the shell command cls.
2640 @param[in] Col the column to print at
2641 @param[in] Row the row to print at
2642 @param[in] Format the format string
2643 @param[in] Marker the marker for the variable argument list
2645 @return EFI_SUCCESS The operation was successful.
2646 @return EFI_DEVICE_ERROR The console device reported an error.
2650 InternalShellPrintWorker(
2651 IN INT32 Col OPTIONAL
,
2652 IN INT32 Row OPTIONAL
,
2653 IN CONST CHAR16
*Format
,
2658 CHAR16
*ResumeLocation
;
2659 CHAR16
*FormatWalker
;
2660 UINTN OriginalAttribute
;
2661 CHAR16
*mPostReplaceFormat
;
2662 CHAR16
*mPostReplaceFormat2
;
2664 mPostReplaceFormat
= AllocateZeroPool (PcdGet16 (PcdShellPrintBufferSize
));
2665 mPostReplaceFormat2
= AllocateZeroPool (PcdGet16 (PcdShellPrintBufferSize
));
2667 if (mPostReplaceFormat
== NULL
|| mPostReplaceFormat2
== NULL
) {
2668 SHELL_FREE_NON_NULL(mPostReplaceFormat
);
2669 SHELL_FREE_NON_NULL(mPostReplaceFormat2
);
2670 return (EFI_OUT_OF_RESOURCES
);
2673 Status
= EFI_SUCCESS
;
2674 OriginalAttribute
= gST
->ConOut
->Mode
->Attribute
;
2677 // Back and forth each time fixing up 1 of our flags...
2679 Status
= ShellCopySearchAndReplace(Format
, mPostReplaceFormat
, PcdGet16 (PcdShellPrintBufferSize
), L
"%N", L
"%%N", FALSE
, FALSE
);
2680 ASSERT_EFI_ERROR(Status
);
2681 Status
= ShellCopySearchAndReplace(mPostReplaceFormat
, mPostReplaceFormat2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%E", L
"%%E", FALSE
, FALSE
);
2682 ASSERT_EFI_ERROR(Status
);
2683 Status
= ShellCopySearchAndReplace(mPostReplaceFormat2
, mPostReplaceFormat
, PcdGet16 (PcdShellPrintBufferSize
), L
"%H", L
"%%H", FALSE
, FALSE
);
2684 ASSERT_EFI_ERROR(Status
);
2685 Status
= ShellCopySearchAndReplace(mPostReplaceFormat
, mPostReplaceFormat2
, PcdGet16 (PcdShellPrintBufferSize
), L
"%B", L
"%%B", FALSE
, FALSE
);
2686 ASSERT_EFI_ERROR(Status
);
2687 Status
= ShellCopySearchAndReplace(mPostReplaceFormat2
, mPostReplaceFormat
, PcdGet16 (PcdShellPrintBufferSize
), L
"%V", L
"%%V", FALSE
, FALSE
);
2688 ASSERT_EFI_ERROR(Status
);
2691 // Use the last buffer from replacing to print from...
2693 UnicodeVSPrint (mPostReplaceFormat2
, PcdGet16 (PcdShellPrintBufferSize
), mPostReplaceFormat
, Marker
);
2695 if (Col
!= -1 && Row
!= -1) {
2696 Status
= gST
->ConOut
->SetCursorPosition(gST
->ConOut
, Col
, Row
);
2699 FormatWalker
= mPostReplaceFormat2
;
2700 while (*FormatWalker
!= CHAR_NULL
) {
2702 // Find the next attribute change request
2704 ResumeLocation
= StrStr(FormatWalker
, L
"%");
2705 if (ResumeLocation
!= NULL
) {
2706 *ResumeLocation
= CHAR_NULL
;
2709 // print the current FormatWalker string
2711 if (StrLen(FormatWalker
)>0) {
2712 Status
= InternalPrintTo(FormatWalker
);
2713 if (EFI_ERROR(Status
)) {
2719 // update the attribute
2721 if (ResumeLocation
!= NULL
) {
2722 if (*(ResumeLocation
-1) == L
'^') {
2724 // Move cursor back 1 position to overwrite the ^
2726 gST
->ConOut
->SetCursorPosition(gST
->ConOut
, gST
->ConOut
->Mode
->CursorColumn
- 1, gST
->ConOut
->Mode
->CursorRow
);
2729 // Print a simple '%' symbol
2731 Status
= InternalPrintTo(L
"%");
2732 ResumeLocation
= ResumeLocation
- 1;
2734 switch (*(ResumeLocation
+1)) {
2736 gST
->ConOut
->SetAttribute(gST
->ConOut
, OriginalAttribute
);
2739 gST
->ConOut
->SetAttribute(gST
->ConOut
, EFI_TEXT_ATTR(EFI_YELLOW
, ((OriginalAttribute
&(BIT4
|BIT5
|BIT6
))>>4)));
2742 gST
->ConOut
->SetAttribute(gST
->ConOut
, EFI_TEXT_ATTR(EFI_WHITE
, ((OriginalAttribute
&(BIT4
|BIT5
|BIT6
))>>4)));
2745 gST
->ConOut
->SetAttribute(gST
->ConOut
, EFI_TEXT_ATTR(EFI_BLUE
, ((OriginalAttribute
&(BIT4
|BIT5
|BIT6
))>>4)));
2748 gST
->ConOut
->SetAttribute(gST
->ConOut
, EFI_TEXT_ATTR(EFI_GREEN
, ((OriginalAttribute
&(BIT4
|BIT5
|BIT6
))>>4)));
2752 // Print a simple '%' symbol
2754 Status
= InternalPrintTo(L
"%");
2755 if (EFI_ERROR(Status
)) {
2758 ResumeLocation
= ResumeLocation
- 1;
2764 // reset to normal now...
2770 // update FormatWalker to Resume + 2 (skip the % and the indicator)
2772 FormatWalker
= ResumeLocation
+ 2;
2775 gST
->ConOut
->SetAttribute(gST
->ConOut
, OriginalAttribute
);
2777 SHELL_FREE_NON_NULL(mPostReplaceFormat
);
2778 SHELL_FREE_NON_NULL(mPostReplaceFormat2
);
2783 Print at a specific location on the screen.
2785 This function will move the cursor to a given screen location and print the specified string.
2787 If -1 is specified for either the Row or Col the current screen location for BOTH
2790 If either Row or Col is out of range for the current console, then ASSERT.
2791 If Format is NULL, then ASSERT.
2793 In addition to the standard %-based flags as supported by UefiLib Print() this supports
2794 the following additional flags:
2795 %N - Set output attribute to normal
2796 %H - Set output attribute to highlight
2797 %E - Set output attribute to error
2798 %B - Set output attribute to blue color
2799 %V - Set output attribute to green color
2801 Note: The background color is controlled by the shell command cls.
2803 @param[in] Col the column to print at
2804 @param[in] Row the row to print at
2805 @param[in] Format the format string
2806 @param[in] ... The variable argument list.
2808 @return EFI_SUCCESS The printing was successful.
2809 @return EFI_DEVICE_ERROR The console device reported an error.
2814 IN INT32 Col OPTIONAL
,
2815 IN INT32 Row OPTIONAL
,
2816 IN CONST CHAR16
*Format
,
2822 if (Format
== NULL
) {
2823 return (EFI_INVALID_PARAMETER
);
2825 VA_START (Marker
, Format
);
2826 RetVal
= InternalShellPrintWorker(Col
, Row
, Format
, Marker
);
2832 Print at a specific location on the screen.
2834 This function will move the cursor to a given screen location and print the specified string.
2836 If -1 is specified for either the Row or Col the current screen location for BOTH
2839 If either Row or Col is out of range for the current console, then ASSERT.
2840 If Format is NULL, then ASSERT.
2842 In addition to the standard %-based flags as supported by UefiLib Print() this supports
2843 the following additional flags:
2844 %N - Set output attribute to normal.
2845 %H - Set output attribute to highlight.
2846 %E - Set output attribute to error.
2847 %B - Set output attribute to blue color.
2848 %V - Set output attribute to green color.
2850 Note: The background color is controlled by the shell command cls.
2852 @param[in] Col The column to print at.
2853 @param[in] Row The row to print at.
2854 @param[in] Language The language of the string to retrieve. If this parameter
2855 is NULL, then the current platform language is used.
2856 @param[in] HiiFormatStringId The format string Id for getting from Hii.
2857 @param[in] HiiFormatHandle The format string Handle for getting from Hii.
2858 @param[in] ... The variable argument list.
2860 @return EFI_SUCCESS The printing was successful.
2861 @return EFI_DEVICE_ERROR The console device reported an error.
2866 IN INT32 Col OPTIONAL
,
2867 IN INT32 Row OPTIONAL
,
2868 IN CONST CHAR8
*Language OPTIONAL
,
2869 IN CONST EFI_STRING_ID HiiFormatStringId
,
2870 IN CONST EFI_HANDLE HiiFormatHandle
,
2875 CHAR16
*HiiFormatString
;
2878 VA_START (Marker
, HiiFormatHandle
);
2879 HiiFormatString
= HiiGetString(HiiFormatHandle
, HiiFormatStringId
, Language
);
2880 ASSERT(HiiFormatString
!= NULL
);
2882 RetVal
= InternalShellPrintWorker(Col
, Row
, HiiFormatString
, Marker
);
2884 SHELL_FREE_NON_NULL(HiiFormatString
);
2891 Function to determine if a given filename represents a file or a directory.
2893 @param[in] DirName Path to directory to test.
2895 @retval EFI_SUCCESS The Path represents a directory
2896 @retval EFI_NOT_FOUND The Path does not represent a directory
2897 @retval EFI_OUT_OF_RESOURCES A memory allocation failed.
2898 @return The path failed to open
2903 IN CONST CHAR16
*DirName
2907 SHELL_FILE_HANDLE Handle
;
2908 CHAR16
*TempLocation
;
2909 CHAR16
*TempLocation2
;
2911 ASSERT(DirName
!= NULL
);
2914 TempLocation
= NULL
;
2916 Status
= ShellOpenFileByName(DirName
, &Handle
, EFI_FILE_MODE_READ
, 0);
2917 if (EFI_ERROR(Status
)) {
2919 // try good logic first.
2921 if (gEfiShellProtocol
!= NULL
) {
2922 TempLocation
= StrnCatGrow(&TempLocation
, NULL
, DirName
, 0);
2923 if (TempLocation
== NULL
) {
2924 ShellCloseFile(&Handle
);
2925 return (EFI_OUT_OF_RESOURCES
);
2927 TempLocation2
= StrStr(TempLocation
, L
":");
2928 if (TempLocation2
!= NULL
&& StrLen(StrStr(TempLocation
, L
":")) == 2) {
2929 *(TempLocation2
+1) = CHAR_NULL
;
2931 if (gEfiShellProtocol
->GetDevicePathFromMap(TempLocation
) != NULL
) {
2932 FreePool(TempLocation
);
2933 return (EFI_SUCCESS
);
2935 FreePool(TempLocation
);
2938 // probably a map name?!?!!?
2940 TempLocation
= StrStr(DirName
, L
"\\");
2941 if (TempLocation
!= NULL
&& *(TempLocation
+1) == CHAR_NULL
) {
2942 return (EFI_SUCCESS
);
2948 if (FileHandleIsDirectory(Handle
) == EFI_SUCCESS
) {
2949 ShellCloseFile(&Handle
);
2950 return (EFI_SUCCESS
);
2952 ShellCloseFile(&Handle
);
2953 return (EFI_NOT_FOUND
);
2957 Function to determine if a given filename represents a file.
2959 @param[in] Name Path to file to test.
2961 @retval EFI_SUCCESS The Path represents a file.
2962 @retval EFI_NOT_FOUND The Path does not represent a file.
2963 @retval other The path failed to open.
2968 IN CONST CHAR16
*Name
2972 SHELL_FILE_HANDLE Handle
;
2974 ASSERT(Name
!= NULL
);
2978 Status
= ShellOpenFileByName(Name
, &Handle
, EFI_FILE_MODE_READ
, 0);
2979 if (EFI_ERROR(Status
)) {
2983 if (FileHandleIsDirectory(Handle
) != EFI_SUCCESS
) {
2984 ShellCloseFile(&Handle
);
2985 return (EFI_SUCCESS
);
2987 ShellCloseFile(&Handle
);
2988 return (EFI_NOT_FOUND
);
2992 Function to determine if a given filename represents a file.
2994 This will search the CWD and then the Path.
2996 If Name is NULL, then ASSERT.
2998 @param[in] Name Path to file to test.
3000 @retval EFI_SUCCESS The Path represents a file.
3001 @retval EFI_NOT_FOUND The Path does not represent a file.
3002 @retval other The path failed to open.
3007 IN CONST CHAR16
*Name
3013 if (!EFI_ERROR(ShellIsFile(Name
))) {
3014 return (EFI_SUCCESS
);
3017 NewName
= ShellFindFilePath(Name
);
3018 if (NewName
== NULL
) {
3019 return (EFI_NOT_FOUND
);
3021 Status
= ShellIsFile(NewName
);
3027 Function to determine whether a string is decimal or hex representation of a number
3028 and return the number converted from the string.
3030 @param[in] String String representation of a number
3033 @retval (UINTN)(-1) An error ocurred.
3038 IN CONST CHAR16
*String
3046 if (!InternalShellIsHexOrDecimalNumber(String
, Hex
, TRUE
)) {
3050 if (!EFI_ERROR(ShellConvertStringToUint64(String
, &RetVal
, Hex
, TRUE
))) {
3051 return ((UINTN
)RetVal
);
3053 return ((UINTN
)(-1));
3057 Safely append with automatic string resizing given length of Destination and
3058 desired length of copy from Source.
3060 append the first D characters of Source to the end of Destination, where D is
3061 the lesser of Count and the StrLen() of Source. If appending those D characters
3062 will fit within Destination (whose Size is given as CurrentSize) and
3063 still leave room for a NULL terminator, then those characters are appended,
3064 starting at the original terminating NULL of Destination, and a new terminating
3067 If appending D characters onto Destination will result in a overflow of the size
3068 given in CurrentSize the string will be grown such that the copy can be performed
3069 and CurrentSize will be updated to the new size.
3071 If Source is NULL, there is nothing to append, just return the current buffer in
3074 if Destination is NULL, then ASSERT()
3075 if Destination's current length (including NULL terminator) is already more then
3076 CurrentSize, then ASSERT()
3078 @param[in, out] Destination The String to append onto
3079 @param[in, out] CurrentSize on call the number of bytes in Destination. On
3080 return possibly the new size (still in bytes). if NULL
3081 then allocate whatever is needed.
3082 @param[in] Source The String to append from
3083 @param[in] Count Maximum number of characters to append. if 0 then
3086 @return Destination return the resultant string.
3091 IN OUT CHAR16
**Destination
,
3092 IN OUT UINTN
*CurrentSize
,
3093 IN CONST CHAR16
*Source
,
3097 UINTN DestinationStartSize
;
3103 ASSERT(Destination
!= NULL
);
3106 // If there's nothing to do then just return Destination
3108 if (Source
== NULL
) {
3109 return (*Destination
);
3113 // allow for un-initialized pointers, based on size being 0
3115 if (CurrentSize
!= NULL
&& *CurrentSize
== 0) {
3116 *Destination
= NULL
;
3120 // allow for NULL pointers address as Destination
3122 if (*Destination
!= NULL
) {
3123 ASSERT(CurrentSize
!= 0);
3124 DestinationStartSize
= StrSize(*Destination
);
3125 ASSERT(DestinationStartSize
<= *CurrentSize
);
3127 DestinationStartSize
= 0;
3128 // ASSERT(*CurrentSize == 0);
3132 // Append all of Source?
3135 Count
= StrLen(Source
);
3139 // Test and grow if required
3141 if (CurrentSize
!= NULL
) {
3142 NewSize
= *CurrentSize
;
3143 while (NewSize
< (DestinationStartSize
+ (Count
*sizeof(CHAR16
)))) {
3144 NewSize
+= 2 * Count
* sizeof(CHAR16
);
3146 *Destination
= ReallocatePool(*CurrentSize
, NewSize
, *Destination
);
3147 *CurrentSize
= NewSize
;
3149 *Destination
= AllocateZeroPool((Count
+1)*sizeof(CHAR16
));
3153 // Now use standard StrnCat on a big enough buffer
3155 if (*Destination
== NULL
) {
3158 return StrnCat(*Destination
, Source
, Count
);
3162 Prompt the user and return the resultant answer to the requestor.
3164 This function will display the requested question on the shell prompt and then
3165 wait for an apropriate answer to be input from the console.
3167 if the SHELL_PROMPT_REQUEST_TYPE is SHELL_PROMPT_REQUEST_TYPE_YESNO, ShellPromptResponseTypeQuitContinue
3168 or SHELL_PROMPT_REQUEST_TYPE_YESNOCANCEL then *Response is of type SHELL_PROMPT_RESPONSE.
3170 if the SHELL_PROMPT_REQUEST_TYPE is ShellPromptResponseTypeFreeform then *Response is of type
3173 In either case *Response must be callee freed if Response was not NULL;
3175 @param Type What type of question is asked. This is used to filter the input
3176 to prevent invalid answers to question.
3177 @param Prompt Pointer to string prompt to use to request input.
3178 @param Response Pointer to Response which will be populated upon return.
3180 @retval EFI_SUCCESS The operation was sucessful.
3181 @retval EFI_UNSUPPORTED The operation is not supported as requested.
3182 @retval EFI_INVALID_PARAMETER A parameter was invalid.
3183 @return other The operation failed.
3187 ShellPromptForResponse (
3188 IN SHELL_PROMPT_REQUEST_TYPE Type
,
3189 IN CHAR16
*Prompt OPTIONAL
,
3190 IN OUT VOID
**Response OPTIONAL
3196 SHELL_PROMPT_RESPONSE
*Resp
;
3200 Status
= EFI_UNSUPPORTED
;
3204 if (Type
!= ShellPromptResponseTypeFreeform
) {
3205 Resp
= (SHELL_PROMPT_RESPONSE
*)AllocateZeroPool(sizeof(SHELL_PROMPT_RESPONSE
));
3207 return (EFI_OUT_OF_RESOURCES
);
3212 case ShellPromptResponseTypeQuitContinue
:
3213 if (Prompt
!= NULL
) {
3214 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3217 // wait for valid response
3219 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3220 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3221 ASSERT_EFI_ERROR(Status
);
3222 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3223 if (Key
.UnicodeChar
== L
'Q' || Key
.UnicodeChar
==L
'q') {
3224 *Resp
= ShellPromptResponseQuit
;
3226 *Resp
= ShellPromptResponseContinue
;
3229 case ShellPromptResponseTypeYesNoCancel
:
3230 if (Prompt
!= NULL
) {
3231 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3234 // wait for valid response
3236 *Resp
= ShellPromptResponseMax
;
3237 while (*Resp
== ShellPromptResponseMax
) {
3238 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3239 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3240 ASSERT_EFI_ERROR(Status
);
3241 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3242 switch (Key
.UnicodeChar
) {
3245 *Resp
= ShellPromptResponseYes
;
3249 *Resp
= ShellPromptResponseNo
;
3253 *Resp
= ShellPromptResponseCancel
;
3257 break; case ShellPromptResponseTypeYesNoAllCancel
:
3258 if (Prompt
!= NULL
) {
3259 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3262 // wait for valid response
3264 *Resp
= ShellPromptResponseMax
;
3265 while (*Resp
== ShellPromptResponseMax
) {
3266 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3267 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3268 ASSERT_EFI_ERROR(Status
);
3269 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3270 switch (Key
.UnicodeChar
) {
3273 *Resp
= ShellPromptResponseYes
;
3277 *Resp
= ShellPromptResponseNo
;
3281 *Resp
= ShellPromptResponseAll
;
3285 *Resp
= ShellPromptResponseCancel
;
3290 case ShellPromptResponseTypeEnterContinue
:
3291 case ShellPromptResponseTypeAnyKeyContinue
:
3292 if (Prompt
!= NULL
) {
3293 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3296 // wait for valid response
3298 *Resp
= ShellPromptResponseMax
;
3299 while (*Resp
== ShellPromptResponseMax
) {
3300 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3301 if (Type
== ShellPromptResponseTypeEnterContinue
) {
3302 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3303 ASSERT_EFI_ERROR(Status
);
3304 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3305 if (Key
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
3306 *Resp
= ShellPromptResponseContinue
;
3310 if (Type
== ShellPromptResponseTypeAnyKeyContinue
) {
3311 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3312 ASSERT_EFI_ERROR(Status
);
3313 *Resp
= ShellPromptResponseContinue
;
3318 case ShellPromptResponseTypeYesNo
:
3319 if (Prompt
!= NULL
) {
3320 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3323 // wait for valid response
3325 *Resp
= ShellPromptResponseMax
;
3326 while (*Resp
== ShellPromptResponseMax
) {
3327 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3328 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3329 ASSERT_EFI_ERROR(Status
);
3330 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3331 switch (Key
.UnicodeChar
) {
3334 *Resp
= ShellPromptResponseYes
;
3338 *Resp
= ShellPromptResponseNo
;
3343 case ShellPromptResponseTypeFreeform
:
3344 if (Prompt
!= NULL
) {
3345 ShellPrintEx(-1, -1, L
"%s", Prompt
);
3348 gBS
->WaitForEvent (1, &gST
->ConIn
->WaitForKey
, &EventIndex
);
3349 Status
= gST
->ConIn
->ReadKeyStroke (gST
->ConIn
, &Key
);
3350 ASSERT_EFI_ERROR(Status
);
3351 ShellPrintEx(-1, -1, L
"%c", Key
.UnicodeChar
);
3352 if (Key
.UnicodeChar
== CHAR_CARRIAGE_RETURN
) {
3355 ASSERT((Buffer
== NULL
&& Size
== 0) || (Buffer
!= NULL
));
3356 StrnCatGrow(&Buffer
, &Size
, &Key
.UnicodeChar
, 1);
3360 // This is the location to add new prompt types.
3366 if (Response
!= NULL
) {
3369 } else if (Buffer
!= NULL
) {
3376 if (Buffer
!= NULL
) {
3381 ShellPrintEx(-1, -1, L
"\r\n");
3386 Prompt the user and return the resultant answer to the requestor.
3388 This function is the same as ShellPromptForResponse, except that the prompt is
3389 automatically pulled from HII.
3391 @param Type What type of question is asked. This is used to filter the input
3392 to prevent invalid answers to question.
3393 @param[in] HiiFormatStringId The format string Id for getting from Hii.
3394 @param[in] HiiFormatHandle The format string Handle for getting from Hii.
3395 @param Response Pointer to Response which will be populated upon return.
3397 @retval EFI_SUCCESS the operation was sucessful.
3398 @return other the operation failed.
3400 @sa ShellPromptForResponse
3404 ShellPromptForResponseHii (
3405 IN SHELL_PROMPT_REQUEST_TYPE Type
,
3406 IN CONST EFI_STRING_ID HiiFormatStringId
,
3407 IN CONST EFI_HANDLE HiiFormatHandle
,
3408 IN OUT VOID
**Response
3414 Prompt
= HiiGetString(HiiFormatHandle
, HiiFormatStringId
, NULL
);
3415 Status
= ShellPromptForResponse(Type
, Prompt
, Response
);
3421 Function to determin if an entire string is a valid number.
3423 If Hex it must be preceeded with a 0x or has ForceHex, set TRUE.
3425 @param[in] String The string to evaluate.
3426 @param[in] ForceHex TRUE - always assume hex.
3427 @param[in] StopAtSpace TRUE to halt upon finding a space, FALSE to keep going.
3429 @retval TRUE It is all numeric (dec/hex) characters.
3430 @retval FALSE There is a non-numeric character.
3434 InternalShellIsHexOrDecimalNumber (
3435 IN CONST CHAR16
*String
,
3436 IN CONST BOOLEAN ForceHex
,
3437 IN CONST BOOLEAN StopAtSpace
3443 // chop off a single negative sign
3445 if (String
!= NULL
&& *String
== L
'-') {
3449 if (String
== NULL
) {
3454 // chop leading zeroes
3456 while(String
!= NULL
&& *String
== L
'0'){
3460 // allow '0x' or '0X', but not 'x' or 'X'
3462 if (String
!= NULL
&& (*String
== L
'x' || *String
== L
'X')) {
3463 if (*(String
-1) != L
'0') {
3465 // we got an x without a preceeding 0
3471 } else if (ForceHex
) {
3478 // loop through the remaining characters and use the lib function
3480 for ( ; String
!= NULL
&& *String
!= CHAR_NULL
&& !(StopAtSpace
&& *String
== L
' ') ; String
++){
3482 if (!ShellIsHexaDecimalDigitCharacter(*String
)) {
3486 if (!ShellIsDecimalDigitCharacter(*String
)) {
3496 Function to determine if a given filename exists.
3498 @param[in] Name Path to test.
3500 @retval EFI_SUCCESS The Path represents a file.
3501 @retval EFI_NOT_FOUND The Path does not represent a file.
3502 @retval other The path failed to open.
3507 IN CONST CHAR16
*Name
3511 EFI_SHELL_FILE_INFO
*List
;
3513 ASSERT(Name
!= NULL
);
3516 Status
= ShellOpenFileMetaArg((CHAR16
*)Name
, EFI_FILE_MODE_READ
, &List
);
3517 if (EFI_ERROR(Status
)) {
3521 ShellCloseFileMetaArg(&List
);
3523 return (EFI_SUCCESS
);
3527 Convert a Unicode character to upper case only if
3528 it maps to a valid small-case ASCII character.
3530 This internal function only deal with Unicode character
3531 which maps to a valid small-case ASCII character, i.e.
3532 L'a' to L'z'. For other Unicode character, the input character
3533 is returned directly.
3535 @param Char The character to convert.
3537 @retval LowerCharacter If the Char is with range L'a' to L'z'.
3538 @retval Unchanged Otherwise.
3543 InternalShellCharToUpper (
3547 if (Char
>= L
'a' && Char
<= L
'z') {
3548 return (CHAR16
) (Char
- (L
'a' - L
'A'));
3555 Convert a Unicode character to numerical value.
3557 This internal function only deal with Unicode character
3558 which maps to a valid hexadecimal ASII character, i.e.
3559 L'0' to L'9', L'a' to L'f' or L'A' to L'F'. For other
3560 Unicode character, the value returned does not make sense.
3562 @param Char The character to convert.
3564 @return The numerical value converted.
3569 InternalShellHexCharToUintn (
3573 if (ShellIsDecimalDigitCharacter (Char
)) {
3577 return (UINTN
) (10 + InternalShellCharToUpper (Char
) - L
'A');
3581 Convert a Null-terminated Unicode hexadecimal string to a value of type UINT64.
3583 This function returns a value of type UINTN by interpreting the contents
3584 of the Unicode string specified by String as a hexadecimal number.
3585 The format of the input Unicode string String is:
3587 [spaces][zeros][x][hexadecimal digits].
3589 The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F].
3590 The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix.
3591 If "x" appears in the input string, it must be prefixed with at least one 0.
3592 The function will ignore the pad space, which includes spaces or tab characters,
3593 before [zeros], [x] or [hexadecimal digit]. The running zero before [x] or
3594 [hexadecimal digit] will be ignored. Then, the decoding starts after [x] or the
3595 first valid hexadecimal digit. Then, the function stops at the first character that is
3596 a not a valid hexadecimal character or NULL, whichever one comes first.
3598 If String has only pad spaces, then zero is returned.
3599 If String has no leading pad spaces, leading zeros or valid hexadecimal digits,
3600 then zero is returned.
3602 @param[in] String A pointer to a Null-terminated Unicode string.
3603 @param[out] Value Upon a successful return the value of the conversion.
3604 @param[in] StopAtSpace FALSE to skip spaces.
3606 @retval EFI_SUCCESS The conversion was successful.
3607 @retval EFI_INVALID_PARAMETER A parameter was NULL or invalid.
3608 @retval EFI_DEVICE_ERROR An overflow occured.
3612 InternalShellStrHexToUint64 (
3613 IN CONST CHAR16
*String
,
3615 IN CONST BOOLEAN StopAtSpace
3620 if (String
== NULL
|| StrSize(String
) == 0 || Value
== NULL
) {
3621 return (EFI_INVALID_PARAMETER
);
3625 // Ignore the pad spaces (space or tab)
3627 while ((*String
== L
' ') || (*String
== L
'\t')) {
3632 // Ignore leading Zeros after the spaces
3634 while (*String
== L
'0') {
3638 if (InternalShellCharToUpper (*String
) == L
'X') {
3639 if (*(String
- 1) != L
'0') {
3651 // Skip spaces if requested
3653 while (StopAtSpace
&& *String
== L
' ') {
3657 while (ShellIsHexaDecimalDigitCharacter (*String
)) {
3659 // If the Hex Number represented by String overflows according
3660 // to the range defined by UINTN, then ASSERT().
3662 if (!(Result
<= (RShiftU64((((UINT64
) ~0) - InternalShellHexCharToUintn (*String
)), 4)))) {
3663 // if (!(Result <= ((((UINT64) ~0) - InternalShellHexCharToUintn (*String)) >> 4))) {
3664 return (EFI_DEVICE_ERROR
);
3667 Result
= (LShiftU64(Result
, 4));
3668 Result
+= InternalShellHexCharToUintn (*String
);
3672 // stop at spaces if requested
3674 if (StopAtSpace
&& *String
== L
' ') {
3680 return (EFI_SUCCESS
);
3684 Convert a Null-terminated Unicode decimal string to a value of
3687 This function returns a value of type UINT64 by interpreting the contents
3688 of the Unicode string specified by String as a decimal number. The format
3689 of the input Unicode string String is:
3691 [spaces] [decimal digits].
3693 The valid decimal digit character is in the range [0-9]. The
3694 function will ignore the pad space, which includes spaces or
3695 tab characters, before [decimal digits]. The running zero in the
3696 beginning of [decimal digits] will be ignored. Then, the function
3697 stops at the first character that is a not a valid decimal character
3698 or a Null-terminator, whichever one comes first.
3700 If String has only pad spaces, then 0 is returned.
3701 If String has no pad spaces or valid decimal digits,
3704 @param[in] String A pointer to a Null-terminated Unicode string.
3705 @param[out] Value Upon a successful return the value of the conversion.
3706 @param[in] StopAtSpace FALSE to skip spaces.
3708 @retval EFI_SUCCESS The conversion was successful.
3709 @retval EFI_INVALID_PARAMETER A parameter was NULL or invalid.
3710 @retval EFI_DEVICE_ERROR An overflow occured.
3714 InternalShellStrDecimalToUint64 (
3715 IN CONST CHAR16
*String
,
3717 IN CONST BOOLEAN StopAtSpace
3722 if (String
== NULL
|| StrSize (String
) == 0 || Value
== NULL
) {
3723 return (EFI_INVALID_PARAMETER
);
3727 // Ignore the pad spaces (space or tab)
3729 while ((*String
== L
' ') || (*String
== L
'\t')) {
3734 // Ignore leading Zeros after the spaces
3736 while (*String
== L
'0') {
3743 // Skip spaces if requested
3745 while (StopAtSpace
&& *String
== L
' ') {
3748 while (ShellIsDecimalDigitCharacter (*String
)) {
3750 // If the number represented by String overflows according
3751 // to the range defined by UINT64, then ASSERT().
3754 if (!(Result
<= (DivU64x32((((UINT64
) ~0) - (*String
- L
'0')),10)))) {
3755 return (EFI_DEVICE_ERROR
);
3758 Result
= MultU64x32(Result
, 10) + (*String
- L
'0');
3762 // Stop at spaces if requested
3764 if (StopAtSpace
&& *String
== L
' ') {
3771 return (EFI_SUCCESS
);
3775 Function to verify and convert a string to its numerical value.
3777 If Hex it must be preceeded with a 0x, 0X, or has ForceHex set TRUE.
3779 @param[in] String The string to evaluate.
3780 @param[out] Value Upon a successful return the value of the conversion.
3781 @param[in] ForceHex TRUE - always assume hex.
3782 @param[in] StopAtSpace FALSE to skip spaces.
3784 @retval EFI_SUCCESS The conversion was successful.
3785 @retval EFI_INVALID_PARAMETER String contained an invalid character.
3786 @retval EFI_NOT_FOUND String was a number, but Value was NULL.
3790 ShellConvertStringToUint64(
3791 IN CONST CHAR16
*String
,
3793 IN CONST BOOLEAN ForceHex
,
3794 IN CONST BOOLEAN StopAtSpace
3798 CONST CHAR16
*Walker
;
3804 if (!InternalShellIsHexOrDecimalNumber(String
, Hex
, StopAtSpace
)) {
3807 if (!InternalShellIsHexOrDecimalNumber(String
, Hex
, StopAtSpace
)) {
3808 return (EFI_INVALID_PARAMETER
);
3811 return (EFI_INVALID_PARAMETER
);
3816 // Chop off leading spaces
3818 for (Walker
= String
; Walker
!= NULL
&& *Walker
!= CHAR_NULL
&& *Walker
== L
' '; Walker
++);
3821 // make sure we have something left that is numeric.
3823 if (Walker
== NULL
|| *Walker
== CHAR_NULL
|| !InternalShellIsHexOrDecimalNumber(Walker
, Hex
, StopAtSpace
)) {
3824 return (EFI_INVALID_PARAMETER
);
3828 // do the conversion.
3830 if (Hex
|| StrnCmp(Walker
, L
"0x", 2) == 0 || StrnCmp(Walker
, L
"0X", 2) == 0){
3831 Status
= InternalShellStrHexToUint64(Walker
, &RetVal
, StopAtSpace
);
3833 Status
= InternalShellStrDecimalToUint64(Walker
, &RetVal
, StopAtSpace
);
3836 if (Value
== NULL
&& !EFI_ERROR(Status
)) {
3837 return (EFI_NOT_FOUND
);
3840 if (Value
!= NULL
) {
3848 Function to determin if an entire string is a valid number.
3850 If Hex it must be preceeded with a 0x or has ForceHex, set TRUE.
3852 @param[in] String The string to evaluate.
3853 @param[in] ForceHex TRUE - always assume hex.
3854 @param[in] StopAtSpace TRUE to halt upon finding a space, FALSE to keep going.
3856 @retval TRUE It is all numeric (dec/hex) characters.
3857 @retval FALSE There is a non-numeric character.
3861 ShellIsHexOrDecimalNumber (
3862 IN CONST CHAR16
*String
,
3863 IN CONST BOOLEAN ForceHex
,
3864 IN CONST BOOLEAN StopAtSpace
3867 if (ShellConvertStringToUint64(String
, NULL
, ForceHex
, StopAtSpace
) == EFI_NOT_FOUND
) {
3874 Function to read a single line from a SHELL_FILE_HANDLE. The \n is not included in the returned
3875 buffer. The returned buffer must be callee freed.
3877 If the position upon start is 0, then the Ascii Boolean will be set. This should be
3878 maintained and not changed for all operations with the same file.
3880 @param[in] Handle SHELL_FILE_HANDLE to read from.
3881 @param[in, out] Ascii Boolean value for indicating whether the file is
3882 Ascii (TRUE) or UCS2 (FALSE).
3884 @return The line of text from the file.
3885 @retval NULL There was not enough memory available.
3887 @sa ShellFileHandleReadLine
3891 ShellFileHandleReturnLine(
3892 IN SHELL_FILE_HANDLE Handle
,
3893 IN OUT BOOLEAN
*Ascii
3903 Status
= ShellFileHandleReadLine(Handle
, RetVal
, &Size
, FALSE
, Ascii
);
3904 if (Status
== EFI_BUFFER_TOO_SMALL
) {
3905 RetVal
= AllocateZeroPool(Size
);
3906 if (RetVal
== NULL
) {
3909 Status
= ShellFileHandleReadLine(Handle
, RetVal
, &Size
, FALSE
, Ascii
);
3912 if (EFI_ERROR(Status
) && (RetVal
!= NULL
)) {
3920 Function to read a single line (up to but not including the \n) from a SHELL_FILE_HANDLE.
3922 If the position upon start is 0, then the Ascii Boolean will be set. This should be
3923 maintained and not changed for all operations with the same file.
3925 @param[in] Handle SHELL_FILE_HANDLE to read from.
3926 @param[in, out] Buffer The pointer to buffer to read into.
3927 @param[in, out] Size The pointer to number of bytes in Buffer.
3928 @param[in] Truncate If the buffer is large enough, this has no effect.
3929 If the buffer is is too small and Truncate is TRUE,
3930 the line will be truncated.
3931 If the buffer is is too small and Truncate is FALSE,
3932 then no read will occur.
3934 @param[in, out] Ascii Boolean value for indicating whether the file is
3935 Ascii (TRUE) or UCS2 (FALSE).
3937 @retval EFI_SUCCESS The operation was successful. The line is stored in
3939 @retval EFI_INVALID_PARAMETER Handle was NULL.
3940 @retval EFI_INVALID_PARAMETER Size was NULL.
3941 @retval EFI_BUFFER_TOO_SMALL Size was not large enough to store the line.
3942 Size was updated to the minimum space required.
3946 ShellFileHandleReadLine(
3947 IN SHELL_FILE_HANDLE Handle
,
3948 IN OUT CHAR16
*Buffer
,
3950 IN BOOLEAN Truncate
,
3951 IN OUT BOOLEAN
*Ascii
3958 UINT64 OriginalFilePosition
;
3964 return (EFI_INVALID_PARAMETER
);
3966 if (Buffer
== NULL
) {
3969 *Buffer
= CHAR_NULL
;
3971 gEfiShellProtocol
->GetFilePosition(Handle
, &OriginalFilePosition
);
3972 if (OriginalFilePosition
== 0) {
3973 CharSize
= sizeof(CHAR16
);
3974 Status
= gEfiShellProtocol
->ReadFile(Handle
, &CharSize
, &CharBuffer
);
3975 ASSERT_EFI_ERROR(Status
);
3976 if (CharBuffer
== gUnicodeFileTag
) {
3980 gEfiShellProtocol
->SetFilePosition(Handle
, OriginalFilePosition
);
3984 for (CountSoFar
= 0;;CountSoFar
++){
3987 CharSize
= sizeof(CHAR8
);
3989 CharSize
= sizeof(CHAR16
);
3991 Status
= gEfiShellProtocol
->ReadFile(Handle
, &CharSize
, &CharBuffer
);
3992 if ( EFI_ERROR(Status
)
3994 || (CharBuffer
== L
'\n' && !(*Ascii
))
3995 || (CharBuffer
== '\n' && *Ascii
)
4000 // if we have space save it...
4002 if ((CountSoFar
+1)*sizeof(CHAR16
) < *Size
){
4003 ASSERT(Buffer
!= NULL
);
4004 ((CHAR16
*)Buffer
)[CountSoFar
] = CharBuffer
;
4005 ((CHAR16
*)Buffer
)[CountSoFar
+1] = CHAR_NULL
;
4010 // if we ran out of space tell when...
4012 if ((CountSoFar
+1)*sizeof(CHAR16
) > *Size
){
4013 *Size
= (CountSoFar
+1)*sizeof(CHAR16
);
4015 gEfiShellProtocol
->SetFilePosition(Handle
, OriginalFilePosition
);
4017 DEBUG((DEBUG_WARN
, "The line was truncated in ShellFileHandleReadLine"));
4019 return (EFI_BUFFER_TOO_SMALL
);
4021 while(Buffer
[StrLen(Buffer
)-1] == L
'\r') {
4022 Buffer
[StrLen(Buffer
)-1] = CHAR_NULL
;