/** @file | |
Main file for ls shell level 2 function. | |
(C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR> | |
Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR> | |
SPDX-License-Identifier: BSD-2-Clause-Patent | |
**/ | |
#include "UefiShellLevel2CommandsLib.h" | |
#include <Guid/FileSystemInfo.h> | |
UINTN mDayOfMonth[] = { 31, 28, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30 }; | |
/** | |
print out the standard format output volume entry. | |
@param[in] TheList a list of files from the volume. | |
**/ | |
EFI_STATUS | |
PrintSfoVolumeInfoTableEntry ( | |
IN CONST EFI_SHELL_FILE_INFO *TheList | |
) | |
{ | |
EFI_STATUS Status; | |
EFI_SHELL_FILE_INFO *Node; | |
CHAR16 *DirectoryName; | |
EFI_FILE_SYSTEM_INFO *SysInfo; | |
UINTN SysInfoSize; | |
SHELL_FILE_HANDLE ShellFileHandle; | |
EFI_FILE_PROTOCOL *EfiFpHandle; | |
// | |
// Get the first valid handle (directories) | |
// | |
for ( Node = (EFI_SHELL_FILE_INFO *)GetFirstNode (&TheList->Link) | |
; !IsNull (&TheList->Link, &Node->Link) && Node->Handle == NULL | |
; Node = (EFI_SHELL_FILE_INFO *)GetNextNode (&TheList->Link, &Node->Link) | |
) | |
{ | |
} | |
if (Node->Handle == NULL) { | |
DirectoryName = GetFullyQualifiedPath (((EFI_SHELL_FILE_INFO *)GetFirstNode (&TheList->Link))->FullName); | |
// | |
// We need to open something up to get system information | |
// | |
Status = gEfiShellProtocol->OpenFileByName ( | |
DirectoryName, | |
&ShellFileHandle, | |
EFI_FILE_MODE_READ | |
); | |
ASSERT_EFI_ERROR (Status); | |
FreePool (DirectoryName); | |
// | |
// Get the Volume Info from ShellFileHandle | |
// | |
SysInfo = NULL; | |
SysInfoSize = 0; | |
EfiFpHandle = ConvertShellHandleToEfiFileProtocol (ShellFileHandle); | |
Status = EfiFpHandle->GetInfo ( | |
EfiFpHandle, | |
&gEfiFileSystemInfoGuid, | |
&SysInfoSize, | |
SysInfo | |
); | |
if (Status == EFI_BUFFER_TOO_SMALL) { | |
SysInfo = AllocateZeroPool (SysInfoSize); | |
Status = EfiFpHandle->GetInfo ( | |
EfiFpHandle, | |
&gEfiFileSystemInfoGuid, | |
&SysInfoSize, | |
SysInfo | |
); | |
} | |
ASSERT_EFI_ERROR (Status); | |
gEfiShellProtocol->CloseFile (ShellFileHandle); | |
} else { | |
// | |
// Get the Volume Info from Node->Handle | |
// | |
SysInfo = NULL; | |
SysInfoSize = 0; | |
EfiFpHandle = ConvertShellHandleToEfiFileProtocol (Node->Handle); | |
Status = EfiFpHandle->GetInfo ( | |
EfiFpHandle, | |
&gEfiFileSystemInfoGuid, | |
&SysInfoSize, | |
SysInfo | |
); | |
if (Status == EFI_BUFFER_TOO_SMALL) { | |
SysInfo = AllocateZeroPool (SysInfoSize); | |
Status = EfiFpHandle->GetInfo ( | |
EfiFpHandle, | |
&gEfiFileSystemInfoGuid, | |
&SysInfoSize, | |
SysInfo | |
); | |
} | |
ASSERT_EFI_ERROR (Status); | |
} | |
ShellPrintHiiEx ( | |
-1, | |
-1, | |
NULL, | |
STRING_TOKEN (STR_GEN_SFO_HEADER), | |
gShellLevel2HiiHandle, | |
L"ls" | |
); | |
// | |
// print VolumeInfo table | |
// | |
ASSERT (SysInfo != NULL); | |
ShellPrintHiiEx ( | |
0, | |
gST->ConOut->Mode->CursorRow, | |
NULL, | |
STRING_TOKEN (STR_LS_SFO_VOLINFO), | |
gShellLevel2HiiHandle, | |
SysInfo->VolumeLabel, | |
SysInfo->VolumeSize, | |
SysInfo->ReadOnly ? L"TRUE" : L"FALSE", | |
SysInfo->FreeSpace, | |
SysInfo->BlockSize | |
); | |
SHELL_FREE_NON_NULL (SysInfo); | |
return (Status); | |
} | |
/** | |
print out the info on a single file. | |
@param[in] Sfo TRUE if in SFO, false otherwise. | |
@param[in] TheNode the EFI_SHELL_FILE_INFO node to print out information on. | |
@param[in] Files incremented if a file is printed. | |
@param[in] Size incremented by file size. | |
@param[in] Dirs incremented if a directory is printed. | |
**/ | |
VOID | |
PrintFileInformation ( | |
IN CONST BOOLEAN Sfo, | |
IN CONST EFI_SHELL_FILE_INFO *TheNode, | |
IN UINT64 *Files, | |
IN UINT64 *Size, | |
IN UINT64 *Dirs | |
) | |
{ | |
ASSERT (Files != NULL); | |
ASSERT (Size != NULL); | |
ASSERT (Dirs != NULL); | |
ASSERT (TheNode != NULL); | |
if (Sfo) { | |
// | |
// Print the FileInfo Table | |
// | |
ShellPrintHiiEx ( | |
0, | |
gST->ConOut->Mode->CursorRow, | |
NULL, | |
STRING_TOKEN (STR_LS_SFO_FILEINFO), | |
gShellLevel2HiiHandle, | |
TheNode->FullName, | |
TheNode->Info->FileSize, | |
TheNode->Info->PhysicalSize, | |
(TheNode->Info->Attribute & EFI_FILE_ARCHIVE) != 0 ? L"a" : L"", | |
(TheNode->Info->Attribute & EFI_FILE_DIRECTORY) != 0 ? L"d" : L"", | |
(TheNode->Info->Attribute & EFI_FILE_HIDDEN) != 0 ? L"h" : L"", | |
(TheNode->Info->Attribute & EFI_FILE_READ_ONLY) != 0 ? L"r" : L"", | |
(TheNode->Info->Attribute & EFI_FILE_SYSTEM) != 0 ? L"s" : L"", | |
TheNode->Info->CreateTime.Hour, | |
TheNode->Info->CreateTime.Minute, | |
TheNode->Info->CreateTime.Second, | |
TheNode->Info->CreateTime.Day, | |
TheNode->Info->CreateTime.Month, | |
TheNode->Info->CreateTime.Year, | |
TheNode->Info->LastAccessTime.Hour, | |
TheNode->Info->LastAccessTime.Minute, | |
TheNode->Info->LastAccessTime.Second, | |
TheNode->Info->LastAccessTime.Day, | |
TheNode->Info->LastAccessTime.Month, | |
TheNode->Info->LastAccessTime.Year, | |
TheNode->Info->ModificationTime.Hour, | |
TheNode->Info->ModificationTime.Minute, | |
TheNode->Info->ModificationTime.Second, | |
TheNode->Info->ModificationTime.Day, | |
TheNode->Info->ModificationTime.Month, | |
TheNode->Info->ModificationTime.Year | |
); | |
} else { | |
// | |
// print this one out... | |
// first print the universal start, next print the type specific name format, last print the CRLF | |
// | |
ShellPrintHiiEx ( | |
-1, | |
-1, | |
NULL, | |
STRING_TOKEN (STR_LS_LINE_START_ALL), | |
gShellLevel2HiiHandle, | |
&TheNode->Info->ModificationTime, | |
(TheNode->Info->Attribute & EFI_FILE_DIRECTORY) != 0 ? L"<DIR>" : L"", | |
(TheNode->Info->Attribute & EFI_FILE_READ_ONLY) != 0 ? L'r' : L' ', | |
TheNode->Info->FileSize | |
); | |
if (TheNode->Info->Attribute & EFI_FILE_DIRECTORY) { | |
(*Dirs)++; | |
ShellPrintHiiEx ( | |
-1, | |
-1, | |
NULL, | |
STRING_TOKEN (STR_LS_LINE_END_DIR), | |
gShellLevel2HiiHandle, | |
TheNode->FileName | |
); | |
} else { | |
(*Files)++; | |
(*Size) += TheNode->Info->FileSize; | |
if ( (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16 *)L".nsh", (CHAR16 *)&(TheNode->FileName[StrLen (TheNode->FileName) - 4])) == 0) | |
|| (gUnicodeCollation->StriColl (gUnicodeCollation, (CHAR16 *)L".efi", (CHAR16 *)&(TheNode->FileName[StrLen (TheNode->FileName) - 4])) == 0) | |
) | |
{ | |
ShellPrintHiiEx ( | |
-1, | |
-1, | |
NULL, | |
STRING_TOKEN (STR_LS_LINE_END_EXE), | |
gShellLevel2HiiHandle, | |
TheNode->FileName | |
); | |
} else { | |
ShellPrintHiiEx ( | |
-1, | |
-1, | |
NULL, | |
STRING_TOKEN (STR_LS_LINE_END_FILE), | |
gShellLevel2HiiHandle, | |
TheNode->FileName | |
); | |
} | |
} | |
} | |
} | |
/** | |
print out the header when not using standard format output. | |
@param[in] Path String with starting path. | |
**/ | |
VOID | |
PrintNonSfoHeader ( | |
IN CONST CHAR16 *Path | |
) | |
{ | |
CHAR16 *DirectoryName; | |
// | |
// get directory name from path... | |
// | |
DirectoryName = GetFullyQualifiedPath (Path); | |
if (DirectoryName != NULL) { | |
// | |
// print header | |
// | |
ShellPrintHiiEx ( | |
0, | |
gST->ConOut->Mode->CursorRow, | |
NULL, | |
STRING_TOKEN (STR_LS_HEADER_LINE1), | |
gShellLevel2HiiHandle, | |
DirectoryName | |
); | |
SHELL_FREE_NON_NULL (DirectoryName); | |
} | |
} | |
/** | |
print out the footer when not using standard format output. | |
@param[in] Files The number of files. | |
@param[in] Size The size of files in bytes. | |
@param[in] Dirs The number of directories. | |
**/ | |
VOID | |
PrintNonSfoFooter ( | |
IN UINT64 Files, | |
IN UINT64 Size, | |
IN UINT64 Dirs | |
) | |
{ | |
// | |
// print footer | |
// | |
ShellPrintHiiEx ( | |
-1, | |
-1, | |
NULL, | |
STRING_TOKEN (STR_LS_FOOTER_LINE), | |
gShellLevel2HiiHandle, | |
Files, | |
Size, | |
Dirs | |
); | |
} | |
/** | |
Change the file time to local time based on the timezone. | |
@param[in] Time The file time. | |
@param[in] LocalTimeZone Local time zone. | |
**/ | |
VOID | |
FileTimeToLocalTime ( | |
IN EFI_TIME *Time, | |
IN INT16 LocalTimeZone | |
) | |
{ | |
INTN MinuteDiff; | |
INTN TempMinute; | |
INTN HourNumberOfTempMinute; | |
INTN TempHour; | |
INTN DayNumberOfTempHour; | |
INTN TempDay; | |
INTN MonthNumberOfTempDay; | |
INTN TempMonth; | |
INTN YearNumberOfTempMonth; | |
INTN MonthRecord; | |
ASSERT ((Time->TimeZone >= -1440) && (Time->TimeZone <= 1440)); | |
ASSERT ((LocalTimeZone >= -1440) && (LocalTimeZone <= 1440)); | |
ASSERT ((Time->Month >= 1) && (Time->Month <= 12)); | |
if (Time->TimeZone == LocalTimeZone) { | |
// | |
// if the file timezone is equal to the local timezone, there is no need to adjust the file time. | |
// | |
return; | |
} | |
if (((Time->Year % 4 == 0) && (Time->Year / 100 != 0)) || (Time->Year % 400 == 0)) { | |
// | |
// Day in February of leap year is 29. | |
// | |
mDayOfMonth[1] = 29; | |
} | |
MinuteDiff = Time->TimeZone - LocalTimeZone; | |
TempMinute = Time->Minute + MinuteDiff; | |
// | |
// Calculate Time->Minute | |
// TempHour will be used to calculate Time->Hour | |
// | |
HourNumberOfTempMinute = TempMinute / 60; | |
if (TempMinute < 0) { | |
HourNumberOfTempMinute--; | |
} | |
TempHour = Time->Hour + HourNumberOfTempMinute; | |
Time->Minute = (UINT8)(TempMinute - 60 * HourNumberOfTempMinute); | |
// | |
// Calculate Time->Hour | |
// TempDay will be used to calculate Time->Day | |
// | |
DayNumberOfTempHour = TempHour / 24; | |
if (TempHour < 0) { | |
DayNumberOfTempHour--; | |
} | |
TempDay = Time->Day + DayNumberOfTempHour; | |
Time->Hour = (UINT8)(TempHour - 24 * DayNumberOfTempHour); | |
// | |
// Calculate Time->Day | |
// TempMonth will be used to calculate Time->Month | |
// | |
MonthNumberOfTempDay = (TempDay - 1) / (INTN)mDayOfMonth[Time->Month - 1]; | |
MonthRecord = (INTN)(Time->Month); | |
if (TempDay - 1 < 0) { | |
MonthNumberOfTempDay--; | |
MonthRecord--; | |
} | |
TempMonth = Time->Month + MonthNumberOfTempDay; | |
Time->Day = (UINT8)(TempDay - (INTN)mDayOfMonth[(MonthRecord - 1 + 12) % 12] * MonthNumberOfTempDay); | |
// | |
// Calculate Time->Month, Time->Year | |
// | |
YearNumberOfTempMonth = (TempMonth - 1) / 12; | |
if (TempMonth - 1 < 0) { | |
YearNumberOfTempMonth--; | |
} | |
Time->Month = (UINT8)(TempMonth - 12 * (YearNumberOfTempMonth)); | |
Time->Year = (UINT16)(Time->Year + YearNumberOfTempMonth); | |
} | |
/** | |
print out the list of files and directories from the LS command | |
@param[in] Rec TRUE to automatically recurse into each found directory | |
FALSE to only list the specified directory. | |
@param[in] Attribs List of required Attribute for display. | |
If 0 then all non-system and non-hidden files will be printed. | |
@param[in] Sfo TRUE to use Standard Format Output, FALSE otherwise | |
@param[in] RootPath String with starting path to search in. | |
@param[in] SearchString String with search string. | |
@param[in] Found Set to TRUE, if anyone were found. | |
@param[in] Count The count of bits enabled in Attribs. | |
@param[in] TimeZone The current time zone offset. | |
@param[in] ListUnfiltered TRUE to request listing the directory contents | |
unfiltered. | |
@retval SHELL_SUCCESS the printing was sucessful. | |
**/ | |
SHELL_STATUS | |
PrintLsOutput ( | |
IN CONST BOOLEAN Rec, | |
IN CONST UINT64 Attribs, | |
IN CONST BOOLEAN Sfo, | |
IN CONST CHAR16 *RootPath, | |
IN CONST CHAR16 *SearchString, | |
IN BOOLEAN *Found, | |
IN CONST UINTN Count, | |
IN CONST INT16 TimeZone, | |
IN CONST BOOLEAN ListUnfiltered | |
) | |
{ | |
EFI_STATUS Status; | |
EFI_SHELL_FILE_INFO *ListHead; | |
EFI_SHELL_FILE_INFO *Node; | |
SHELL_STATUS ShellStatus; | |
UINT64 FileCount; | |
UINT64 DirCount; | |
UINT64 FileSize; | |
UINTN LongestPath; | |
CHAR16 *CorrectedPath; | |
BOOLEAN FoundOne; | |
BOOLEAN HeaderPrinted; | |
EFI_TIME LocalTime; | |
HeaderPrinted = FALSE; | |
FileCount = 0; | |
DirCount = 0; | |
FileSize = 0; | |
ListHead = NULL; | |
ShellStatus = SHELL_SUCCESS; | |
LongestPath = 0; | |
CorrectedPath = NULL; | |
if (Found != NULL) { | |
FoundOne = *Found; | |
} else { | |
FoundOne = FALSE; | |
} | |
CorrectedPath = StrnCatGrow (&CorrectedPath, &LongestPath, RootPath, 0); | |
if (CorrectedPath == NULL) { | |
return SHELL_OUT_OF_RESOURCES; | |
} | |
if ( (CorrectedPath[StrLen (CorrectedPath)-1] != L'\\') | |
&& (CorrectedPath[StrLen (CorrectedPath)-1] != L'/')) | |
{ | |
CorrectedPath = StrnCatGrow (&CorrectedPath, &LongestPath, L"\\", 0); | |
} | |
CorrectedPath = StrnCatGrow (&CorrectedPath, &LongestPath, SearchString, 0); | |
if (CorrectedPath == NULL) { | |
return (SHELL_OUT_OF_RESOURCES); | |
} | |
PathCleanUpDirectories (CorrectedPath); | |
Status = ShellOpenFileMetaArg ((CHAR16 *)CorrectedPath, EFI_FILE_MODE_READ, &ListHead); | |
if (!EFI_ERROR (Status)) { | |
if ((ListHead == NULL) || IsListEmpty (&ListHead->Link)) { | |
SHELL_FREE_NON_NULL (CorrectedPath); | |
return (SHELL_SUCCESS); | |
} | |
if (Sfo && (Found == NULL)) { | |
PrintSfoVolumeInfoTableEntry (ListHead); | |
} | |
if (!Sfo) { | |
// | |
// Sort the file list by FileName, stably. | |
// | |
// If the call below fails, then the EFI_SHELL_FILE_INFO list anchored to | |
// ListHead will not be changed in any way. | |
// | |
ShellSortFileList ( | |
&ListHead, | |
NULL, // Duplicates | |
ShellSortFileListByFileName | |
); | |
} | |
for ( Node = (EFI_SHELL_FILE_INFO *)GetFirstNode (&ListHead->Link), LongestPath = 0 | |
; !IsNull (&ListHead->Link, &Node->Link) | |
; Node = (EFI_SHELL_FILE_INFO *)GetNextNode (&ListHead->Link, &Node->Link) | |
) | |
{ | |
if (ShellGetExecutionBreakFlag ()) { | |
ShellStatus = SHELL_ABORTED; | |
break; | |
} | |
ASSERT (Node != NULL); | |
// | |
// Change the file time to local time. | |
// | |
Status = gRT->GetTime (&LocalTime, NULL); | |
if (!EFI_ERROR (Status) && (LocalTime.TimeZone != EFI_UNSPECIFIED_TIMEZONE)) { | |
if ((Node->Info->CreateTime.TimeZone != EFI_UNSPECIFIED_TIMEZONE) && | |
((Node->Info->CreateTime.Month >= 1) && (Node->Info->CreateTime.Month <= 12))) | |
{ | |
// | |
// FileTimeToLocalTime () requires Month is in a valid range, other buffer out-of-band access happens. | |
// | |
FileTimeToLocalTime (&Node->Info->CreateTime, LocalTime.TimeZone); | |
} | |
if ((Node->Info->LastAccessTime.TimeZone != EFI_UNSPECIFIED_TIMEZONE) && | |
((Node->Info->LastAccessTime.Month >= 1) && (Node->Info->LastAccessTime.Month <= 12))) | |
{ | |
FileTimeToLocalTime (&Node->Info->LastAccessTime, LocalTime.TimeZone); | |
} | |
if ((Node->Info->ModificationTime.TimeZone != EFI_UNSPECIFIED_TIMEZONE) && | |
((Node->Info->ModificationTime.Month >= 1) && (Node->Info->ModificationTime.Month <= 12))) | |
{ | |
FileTimeToLocalTime (&Node->Info->ModificationTime, LocalTime.TimeZone); | |
} | |
} | |
if (LongestPath < StrSize (Node->FullName)) { | |
LongestPath = StrSize (Node->FullName); | |
} | |
ASSERT (Node->Info != NULL); | |
ASSERT ((Node->Info->Attribute & EFI_FILE_VALID_ATTR) == Node->Info->Attribute); | |
if (Attribs == 0) { | |
// | |
// NOT system & NOT hidden | |
// | |
if ( (Node->Info->Attribute & EFI_FILE_SYSTEM) | |
|| (Node->Info->Attribute & EFI_FILE_HIDDEN) | |
) | |
{ | |
continue; | |
} | |
} else if ((Attribs != EFI_FILE_VALID_ATTR) || | |
(Count == 5)) | |
{ | |
// | |
// Only matches the bits which "Attribs" contains, not | |
// all files/directories with any of the bits. | |
// Count == 5 is used to tell the difference between a user | |
// specifying all bits (EX: -arhsda) and just specifying | |
// -a (means display all files with any attribute). | |
// | |
if ((Node->Info->Attribute & Attribs) != Attribs) { | |
continue; | |
} | |
} | |
if (!Sfo && !HeaderPrinted) { | |
PathRemoveLastItem (CorrectedPath); | |
PrintNonSfoHeader (CorrectedPath); | |
} | |
PrintFileInformation (Sfo, Node, &FileCount, &FileSize, &DirCount); | |
FoundOne = TRUE; | |
HeaderPrinted = TRUE; | |
} | |
if (!Sfo && (ShellStatus != SHELL_ABORTED) && HeaderPrinted) { | |
PrintNonSfoFooter (FileCount, FileSize, DirCount); | |
} | |
} | |
if (Rec && (ShellStatus != SHELL_ABORTED)) { | |
// | |
// Re-Open all the files under the starting path for directories that didnt necessarily match our file filter | |
// | |
ShellCloseFileMetaArg (&ListHead); | |
CorrectedPath[0] = CHAR_NULL; | |
CorrectedPath = StrnCatGrow (&CorrectedPath, &LongestPath, RootPath, 0); | |
if (CorrectedPath == NULL) { | |
return SHELL_OUT_OF_RESOURCES; | |
} | |
if ( (CorrectedPath[StrLen (CorrectedPath)-1] != L'\\') | |
&& (CorrectedPath[StrLen (CorrectedPath)-1] != L'/')) | |
{ | |
CorrectedPath = StrnCatGrow (&CorrectedPath, &LongestPath, L"\\", 0); | |
} | |
CorrectedPath = StrnCatGrow (&CorrectedPath, &LongestPath, L"*", 0); | |
Status = ShellOpenFileMetaArg ((CHAR16 *)CorrectedPath, EFI_FILE_MODE_READ, &ListHead); | |
if (!EFI_ERROR (Status)) { | |
for ( Node = (EFI_SHELL_FILE_INFO *)GetFirstNode (&ListHead->Link) | |
; !IsNull (&ListHead->Link, &Node->Link) && ShellStatus == SHELL_SUCCESS | |
; Node = (EFI_SHELL_FILE_INFO *)GetNextNode (&ListHead->Link, &Node->Link) | |
) | |
{ | |
if (ShellGetExecutionBreakFlag ()) { | |
ShellStatus = SHELL_ABORTED; | |
break; | |
} | |
// | |
// recurse on any directory except the traversing ones... | |
// | |
if ( ((Node->Info->Attribute & EFI_FILE_DIRECTORY) == EFI_FILE_DIRECTORY) | |
&& (StrCmp (Node->FileName, L".") != 0) | |
&& (StrCmp (Node->FileName, L"..") != 0) | |
) | |
{ | |
ShellStatus = PrintLsOutput ( | |
Rec, | |
Attribs, | |
Sfo, | |
Node->FullName, | |
SearchString, | |
&FoundOne, | |
Count, | |
TimeZone, | |
FALSE | |
); | |
// | |
// Since it's running recursively, we have to break immediately when returned SHELL_ABORTED | |
// | |
if (ShellStatus == SHELL_ABORTED) { | |
break; | |
} | |
} | |
} | |
} | |
} | |
SHELL_FREE_NON_NULL (CorrectedPath); | |
ShellCloseFileMetaArg (&ListHead); | |
if ((Found == NULL) && !FoundOne) { | |
if (ListUnfiltered) { | |
// | |
// When running "ls" without any filtering request, avoid outputing | |
// "File not found" when the directory is entirely empty, but print | |
// header and footer stating "0 File(s), 0 Dir(s)". | |
// | |
if (!Sfo) { | |
PrintNonSfoHeader (RootPath); | |
if (ShellStatus != SHELL_ABORTED) { | |
PrintNonSfoFooter (FileCount, FileSize, DirCount); | |
} | |
} | |
} else { | |
return (SHELL_NOT_FOUND); | |
} | |
} | |
if (Found != NULL) { | |
*Found = FoundOne; | |
} | |
return (ShellStatus); | |
} | |
STATIC CONST SHELL_PARAM_ITEM LsParamList[] = { | |
{ L"-r", TypeFlag }, | |
{ L"-a", TypeStart }, | |
{ L"-sfo", TypeFlag }, | |
{ NULL, TypeMax } | |
}; | |
/** | |
Function for 'ls' command. | |
@param[in] ImageHandle Handle to the Image (NULL if Internal). | |
@param[in] SystemTable Pointer to the System Table (NULL if Internal). | |
**/ | |
SHELL_STATUS | |
EFIAPI | |
ShellCommandRunLs ( | |
IN EFI_HANDLE ImageHandle, | |
IN EFI_SYSTEM_TABLE *SystemTable | |
) | |
{ | |
EFI_STATUS Status; | |
LIST_ENTRY *Package; | |
CHAR16 *ProblemParam; | |
CONST CHAR16 *Attribs; | |
SHELL_STATUS ShellStatus; | |
UINT64 RequiredAttributes; | |
CONST CHAR16 *PathName; | |
CONST CHAR16 *CurDir; | |
UINTN Count; | |
CHAR16 *FullPath; | |
UINTN Size; | |
EFI_TIME TheTime; | |
CHAR16 *SearchString; | |
BOOLEAN ListUnfiltered; | |
Size = 0; | |
FullPath = NULL; | |
ProblemParam = NULL; | |
Attribs = NULL; | |
ShellStatus = SHELL_SUCCESS; | |
RequiredAttributes = 0; | |
PathName = NULL; | |
SearchString = NULL; | |
CurDir = NULL; | |
Count = 0; | |
ListUnfiltered = FALSE; | |
// | |
// initialize the shell lib (we must be in non-auto-init...) | |
// | |
Status = ShellInitialize (); | |
ASSERT_EFI_ERROR (Status); | |
// | |
// Fix local copies of the protocol pointers | |
// | |
Status = CommandInit (); | |
ASSERT_EFI_ERROR (Status); | |
// | |
// parse the command line | |
// | |
Status = ShellCommandLineParse (LsParamList, &Package, &ProblemParam, TRUE); | |
if (EFI_ERROR (Status)) { | |
if ((Status == EFI_VOLUME_CORRUPTED) && (ProblemParam != NULL)) { | |
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellLevel2HiiHandle, L"ls", ProblemParam); | |
FreePool (ProblemParam); | |
ShellStatus = SHELL_INVALID_PARAMETER; | |
} else { | |
ASSERT (FALSE); | |
} | |
} else { | |
// | |
// check for "-?" | |
// | |
if (ShellCommandLineGetFlag (Package, L"-?")) { | |
ASSERT (FALSE); | |
} | |
if (ShellCommandLineGetCount (Package) > 2) { | |
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel2HiiHandle, L"ls"); | |
ShellStatus = SHELL_INVALID_PARAMETER; | |
} else { | |
// | |
// check for -a | |
// | |
if (ShellCommandLineGetFlag (Package, L"-a")) { | |
for ( Attribs = ShellCommandLineGetValue (Package, L"-a") | |
; Attribs != NULL && *Attribs != CHAR_NULL && ShellStatus == SHELL_SUCCESS | |
; Attribs++ | |
) | |
{ | |
switch (*Attribs) { | |
case L'a': | |
case L'A': | |
RequiredAttributes |= EFI_FILE_ARCHIVE; | |
Count++; | |
continue; | |
case L's': | |
case L'S': | |
RequiredAttributes |= EFI_FILE_SYSTEM; | |
Count++; | |
continue; | |
case L'h': | |
case L'H': | |
RequiredAttributes |= EFI_FILE_HIDDEN; | |
Count++; | |
continue; | |
case L'r': | |
case L'R': | |
RequiredAttributes |= EFI_FILE_READ_ONLY; | |
Count++; | |
continue; | |
case L'd': | |
case L'D': | |
RequiredAttributes |= EFI_FILE_DIRECTORY; | |
Count++; | |
continue; | |
default: | |
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_ATTRIBUTE), gShellLevel2HiiHandle, L"ls", ShellCommandLineGetValue (Package, L"-a")); | |
ShellStatus = SHELL_INVALID_PARAMETER; | |
break; | |
} // switch | |
} // for loop | |
// | |
// if nothing is specified all are specified | |
// | |
if (RequiredAttributes == 0) { | |
RequiredAttributes = EFI_FILE_VALID_ATTR; | |
} | |
} // if -a present | |
if (ShellStatus == SHELL_SUCCESS) { | |
PathName = ShellCommandLineGetRawValue (Package, 1); | |
if (PathName == NULL) { | |
// | |
// Nothing specified... must start from current directory | |
// | |
CurDir = gEfiShellProtocol->GetCurDir (NULL); | |
if (CurDir == NULL) { | |
ShellStatus = SHELL_NOT_FOUND; | |
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_CWD), gShellLevel2HiiHandle, L"ls"); | |
} | |
ListUnfiltered = TRUE; | |
// | |
// Copy to the 2 strings for starting path and file search string | |
// | |
ASSERT (SearchString == NULL); | |
ASSERT (FullPath == NULL); | |
StrnCatGrow (&SearchString, NULL, L"*", 0); | |
StrnCatGrow (&FullPath, NULL, CurDir, 0); | |
Size = FullPath != NULL ? StrSize (FullPath) : 0; | |
StrnCatGrow (&FullPath, &Size, L"\\", 0); | |
} else { | |
if ((StrStr (PathName, L":") == NULL) && (gEfiShellProtocol->GetCurDir (NULL) == NULL)) { | |
// | |
// If we got something and it doesnt have a fully qualified path, then we needed to have a CWD. | |
// | |
ShellStatus = SHELL_NOT_FOUND; | |
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_CWD), gShellLevel2HiiHandle, L"ls"); | |
} else { | |
// | |
// We got a valid fully qualified path or we have a CWD | |
// | |
ASSERT ((FullPath == NULL && Size == 0) || (FullPath != NULL)); | |
if (StrStr (PathName, L":") == NULL) { | |
StrnCatGrow (&FullPath, &Size, gEfiShellProtocol->GetCurDir (NULL), 0); | |
if (FullPath == NULL) { | |
ShellCommandLineFreeVarList (Package); | |
return SHELL_OUT_OF_RESOURCES; | |
} | |
Size = FullPath != NULL ? StrSize (FullPath) : 0; | |
StrnCatGrow (&FullPath, &Size, L"\\", 0); | |
} | |
StrnCatGrow (&FullPath, &Size, PathName, 0); | |
if (FullPath == NULL) { | |
ShellCommandLineFreeVarList (Package); | |
return SHELL_OUT_OF_RESOURCES; | |
} | |
if (ShellIsDirectory (PathName) == EFI_SUCCESS) { | |
// | |
// is listing ends with a directory, then we list all files in that directory | |
// | |
ListUnfiltered = TRUE; | |
StrnCatGrow (&SearchString, NULL, L"*", 0); | |
} else { | |
// | |
// must split off the search part that applies to files from the end of the directory part | |
// | |
StrnCatGrow (&SearchString, NULL, FullPath, 0); | |
if (SearchString == NULL) { | |
FreePool (FullPath); | |
ShellCommandLineFreeVarList (Package); | |
return SHELL_OUT_OF_RESOURCES; | |
} | |
PathRemoveLastItem (FullPath); | |
CopyMem (SearchString, SearchString + StrLen (FullPath), StrSize (SearchString + StrLen (FullPath))); | |
} | |
} | |
} | |
Status = gRT->GetTime (&TheTime, NULL); | |
if (EFI_ERROR (Status)) { | |
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_UEFI_FUNC_WARN), gShellLevel2HiiHandle, L"ls", L"gRT->GetTime", Status); | |
TheTime.TimeZone = EFI_UNSPECIFIED_TIMEZONE; | |
} | |
if (ShellStatus == SHELL_SUCCESS) { | |
ShellStatus = PrintLsOutput ( | |
ShellCommandLineGetFlag (Package, L"-r"), | |
RequiredAttributes, | |
ShellCommandLineGetFlag (Package, L"-sfo"), | |
FullPath, | |
SearchString, | |
NULL, | |
Count, | |
TheTime.TimeZone, | |
ListUnfiltered | |
); | |
if (ShellStatus == SHELL_NOT_FOUND) { | |
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_LS_FILE_NOT_FOUND), gShellLevel2HiiHandle, L"ls", FullPath); | |
} else if (ShellStatus == SHELL_INVALID_PARAMETER) { | |
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"ls", FullPath); | |
} else if (ShellStatus == SHELL_ABORTED) { | |
// | |
// Ignore aborting. | |
// | |
} else if (ShellStatus != SHELL_SUCCESS) { | |
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"ls", FullPath); | |
} | |
} | |
} | |
} | |
} | |
// | |
// Free memory allocated | |
// | |
SHELL_FREE_NON_NULL (SearchString); | |
SHELL_FREE_NON_NULL (FullPath); | |
ShellCommandLineFreeVarList (Package); | |
return (ShellStatus); | |
} |