/**
returns a fully qualified directory (contains a map drive at the begining)
path from a unknown directory path.
If Path is already fully qualified this will return a duplicat otherwise this
will use get the current directory and use that to build the fully qualified
version.
if the return value is not NULL it must be caller freed.
@param[in] Path The unknown Path Value
@retval NULL A memory allocation failed
@retval NULL A fully qualified path could not be discovered.
@retval other An allocated pointer to a fuly qualified path.
**/
CHAR16*
GetFullyQualifiedPath(
IN CONST CHAR16* Path
)
{
CHAR16 *PathToReturn;
UINTN Size;
CONST CHAR16 *CurDir;
PathToReturn = NULL;
Size = 0;
ASSERT((PathToReturn == NULL && Size == 0) || (PathToReturn != NULL));
//
// convert a local path to an absolute path
//
if (StrStr(Path, L":") == NULL) {
CurDir = gEfiShellProtocol->GetCurDir(NULL);
StrnCatGrow(&PathToReturn, &Size, CurDir, 0);
StrnCatGrow(&PathToReturn, &Size, L"\\", 0);
if (*Path == L'\\') {
Path++;
}
}
StrnCatGrow(&PathToReturn, &Size, Path, 0);
PathCleanUpDirectories(PathToReturn);
if (PathToReturn == NULL) {
return NULL;
}
while (PathToReturn[StrLen(PathToReturn)-1] == L'*') {
PathToReturn[StrLen(PathToReturn)-1] = CHAR_NULL;
}
return (PathToReturn);
}
/**
function to take a list of files to move and a destination location and do
the verification and moving of those files to that location. This function
will report any errors to the user and continue to move the rest of the files.
@param[in] FileList A LIST_ENTRY* based list of files to move
@param[out] Resp pointer to response from question. Pass back on looped calling
@param[in] DestParameter the originally specified destination location
@retval SHELL_SUCCESS the files were all moved.
@retval SHELL_INVALID_PARAMETER a parameter was invalid
@retval SHELL_SECURITY_VIOLATION a security violation ocurred
@retval SHELL_WRITE_PROTECTED the destination was write protected
@retval SHELL_OUT_OF_RESOURCES a memory allocation failed
**/
SHELL_STATUS
EFIAPI
ValidateAndMoveFiles(
IN EFI_SHELL_FILE_INFO *FileList,
OUT VOID **Resp,
IN CONST CHAR16 *DestParameter
)
{
EFI_STATUS Status;
CHAR16 *HiiOutput;
CHAR16 *HiiResultOk;
CHAR16 *DestPath;
CHAR16 *FullDestPath;
CONST CHAR16 *Cwd;
CHAR16 *FullCwd;
SHELL_STATUS ShellStatus;
EFI_SHELL_FILE_INFO *Node;
VOID *Response;
UINT64 Attr;
CHAR16 *CleanFilePathStr;
ASSERT(FileList != NULL);
ASSERT(DestParameter != NULL);
DestPath = NULL;
FullDestPath = NULL;
Cwd = ShellGetCurrentDir(NULL);
Response = *Resp;
Attr = 0;
CleanFilePathStr = NULL;
FullCwd = NULL;
if (Cwd != NULL) {
FullCwd = AllocateZeroPool(StrSize(Cwd) + sizeof(CHAR16));
if (FullCwd == NULL) {
return SHELL_OUT_OF_RESOURCES;
} else {
StrCpyS(FullCwd, StrSize(Cwd)/sizeof(CHAR16)+1, Cwd);
StrCatS(FullCwd, StrSize(Cwd)/sizeof(CHAR16)+1, L"\\");
}
}
Status = ShellLevel2StripQuotes (DestParameter, &CleanFilePathStr);
if (EFI_ERROR (Status)) {
SHELL_FREE_NON_NULL(FullCwd);
if (Status == EFI_OUT_OF_RESOURCES) {
return SHELL_OUT_OF_RESOURCES;
} else {
return SHELL_INVALID_PARAMETER;
}
}
ASSERT (CleanFilePathStr != NULL);
//
// Get and validate the destination location
//
ShellStatus = GetDestinationLocation(CleanFilePathStr, &DestPath, FullCwd, (BOOLEAN)(FileList->Link.ForwardLink == FileList->Link.BackLink), &Attr);
FreePool (CleanFilePathStr);
if (ShellStatus != SHELL_SUCCESS) {
SHELL_FREE_NON_NULL (FullCwd);
return (ShellStatus);
}
DestPath = PathCleanUpDirectories(DestPath);
if (DestPath == NULL) {
FreePool (FullCwd);
return (SHELL_OUT_OF_RESOURCES);
}
HiiOutput = HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_MV_OUTPUT), NULL);
HiiResultOk = HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_GEN_RES_OK), NULL);
if (HiiOutput == NULL || HiiResultOk == NULL) {
SHELL_FREE_NON_NULL(DestPath);
SHELL_FREE_NON_NULL(HiiOutput);
SHELL_FREE_NON_NULL(HiiResultOk);
SHELL_FREE_NON_NULL(FullCwd);
return (SHELL_OUT_OF_RESOURCES);
}
//
// Go through the list of files and directories to move...
//
for (Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&FileList->Link)
; !IsNull(&FileList->Link, &Node->Link)
; Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&FileList->Link, &Node->Link)
){
if (ShellGetExecutionBreakFlag()) {
break;
}
//
// These should never be NULL
//
ASSERT(Node->FileName != NULL);
ASSERT(Node->FullName != NULL);
ASSERT(Node->Info != NULL);
//
// skip the directory traversing stuff...
//
if (StrCmp(Node->FileName, L".") == 0 || StrCmp(Node->FileName, L"..") == 0) {
continue;
}
SHELL_FREE_NON_NULL(FullDestPath);
FullDestPath = NULL;
if (ShellIsDirectory(DestPath)==EFI_SUCCESS) {
CreateFullDestPath((CONST CHAR16 **)&DestPath, &FullDestPath, Node->FileName);
}
//
// Validate that the move is valid
//
if (!IsValidMove(Node->FullName, FullCwd, FullDestPath!=NULL? FullDestPath:DestPath, Node->Info->Attribute, Attr, Node->Status)) {
ShellStatus = SHELL_INVALID_PARAMETER;
continue;
}
ShellPrintEx(-1, -1, HiiOutput, Node->FullName, FullDestPath!=NULL? FullDestPath:DestPath);
//
// See if destination exists
//
if (!EFI_ERROR(ShellFileExists(FullDestPath!=NULL? FullDestPath:DestPath))) {
if (Response == NULL) {
ShellPromptForResponseHii(ShellPromptResponseTypeYesNoAllCancel, STRING_TOKEN (STR_GEN_DEST_EXIST_OVR), gShellLevel2HiiHandle, &Response);
}
switch (*(SHELL_PROMPT_RESPONSE*)Response) {
case ShellPromptResponseNo:
FreePool(Response);
Response = NULL;
continue;
case ShellPromptResponseCancel:
*Resp = Response;
//
// indicate to stop everything
//
SHELL_FREE_NON_NULL(FullCwd);
return (SHELL_ABORTED);
case ShellPromptResponseAll:
*Resp = Response;
break;
case ShellPromptResponseYes:
FreePool(Response);
Response = NULL;
break;
default:
FreePool(Response);
SHELL_FREE_NON_NULL(FullCwd);
return SHELL_ABORTED;
}
Status = ShellDeleteFileByName(FullDestPath!=NULL? FullDestPath:DestPath);
}
if (IsBetweenFileSystem(Node->FullName, FullCwd, DestPath)) {
while (FullDestPath == NULL && DestPath != NULL && DestPath[0] != CHAR_NULL && DestPath[StrLen(DestPath) - 1] == L'\\') {
DestPath[StrLen(DestPath) - 1] = CHAR_NULL;
}
Status = MoveBetweenFileSystems(Node, FullDestPath!=NULL? FullDestPath:DestPath, &Response);
} else {
Status = MoveWithinFileSystems(Node, DestPath, &Response);
//
// Display error status
//
if (EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, L"mv", Status);
}
}
//
// Check our result
//
if (EFI_ERROR(Status)) {
ShellStatus = SHELL_INVALID_PARAMETER;
if (Status == EFI_SECURITY_VIOLATION) {
ShellStatus = SHELL_SECURITY_VIOLATION;
} else if (Status == EFI_WRITE_PROTECTED) {
ShellStatus = SHELL_WRITE_PROTECTED;
} else if (Status == EFI_OUT_OF_RESOURCES) {
ShellStatus = SHELL_OUT_OF_RESOURCES;
} else if (Status == EFI_DEVICE_ERROR) {
ShellStatus = SHELL_DEVICE_ERROR;
} else if (Status == EFI_ACCESS_DENIED) {
ShellStatus = SHELL_ACCESS_DENIED;
}
} else {
ShellPrintEx(-1, -1, L"%s", HiiResultOk);
}
} // main for loop
SHELL_FREE_NON_NULL(FullDestPath);
SHELL_FREE_NON_NULL(DestPath);
SHELL_FREE_NON_NULL(HiiOutput);
SHELL_FREE_NON_NULL(HiiResultOk);
SHELL_FREE_NON_NULL(FullCwd);
return (ShellStatus);
}
/**
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.
@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
)
{
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);
}
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)) {
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) {
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);
//
// 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) {
return (SHELL_NOT_FOUND);
}
if (Found != NULL) {
*Found = FoundOne;
}
return (ShellStatus);
}
/**
Function for 'cp' 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
ShellCommandRunCp (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
LIST_ENTRY *Package;
CHAR16 *ProblemParam;
SHELL_STATUS ShellStatus;
UINTN ParamCount;
UINTN LoopCounter;
EFI_SHELL_FILE_INFO *FileList;
BOOLEAN SilentMode;
BOOLEAN RecursiveMode;
CONST CHAR16 *Cwd;
ProblemParam = NULL;
ShellStatus = SHELL_SUCCESS;
ParamCount = 0;
FileList = NULL;
//
// initialize the shell lib (we must be in non-auto-init...)
//
Status = ShellInitialize();
ASSERT_EFI_ERROR(Status);
Status = CommandInit();
ASSERT_EFI_ERROR(Status);
//
// parse the command line
//
Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
if (EFI_ERROR(Status)) {
if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellLevel2HiiHandle, ProblemParam);
FreePool(ProblemParam);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
ASSERT(FALSE);
}
} else {
//
// check for "-?"
//
if (ShellCommandLineGetFlag(Package, L"-?")) {
ASSERT(FALSE);
}
//
// Initialize SilentMode and RecursiveMode
//
if (gEfiShellProtocol->BatchIsActive()) {
SilentMode = TRUE;
} else {
SilentMode = ShellCommandLineGetFlag(Package, L"-q");
}
RecursiveMode = ShellCommandLineGetFlag(Package, L"-r");
switch (ParamCount = ShellCommandLineGetCount(Package)) {
case 0:
case 1:
//
// we have insufficient parameters
//
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellLevel2HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
break;
case 2:
//
// must have valid CWD for single parameter...
//
Cwd = ShellGetCurrentDir(NULL);
if (Cwd == NULL){
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_CWD), gShellLevel2HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
Status = ShellOpenFileMetaArg((CHAR16*)ShellCommandLineGetRawValue(Package, 1), EFI_FILE_MODE_WRITE|EFI_FILE_MODE_READ, &FileList);
if (FileList == NULL || IsListEmpty(&FileList->Link) || EFI_ERROR(Status)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_NF), gShellLevel2HiiHandle, ShellCommandLineGetRawValue(Package, 1));
ShellStatus = SHELL_NOT_FOUND;
} else {
ShellStatus = ProcessValidateAndCopyFiles(FileList, Cwd, SilentMode, RecursiveMode);
}
}
break;
default:
//
// Make a big list of all the files...
//
for (ParamCount--, LoopCounter = 1 ; LoopCounter < ParamCount && ShellStatus == SHELL_SUCCESS ; LoopCounter++) {
if (ShellGetExecutionBreakFlag()) {
break;
}
Status = ShellOpenFileMetaArg((CHAR16*)ShellCommandLineGetRawValue(Package, LoopCounter), EFI_FILE_MODE_WRITE|EFI_FILE_MODE_READ, &FileList);
if (EFI_ERROR(Status) || FileList == NULL || IsListEmpty(&FileList->Link)) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_NF), gShellLevel2HiiHandle, ShellCommandLineGetRawValue(Package, LoopCounter));
ShellStatus = SHELL_NOT_FOUND;
}
}
if (ShellStatus != SHELL_SUCCESS) {
Status = ShellCloseFileMetaArg(&FileList);
} else {
//
// now copy them all...
//
if (FileList != NULL && !IsListEmpty(&FileList->Link)) {
ShellStatus = ProcessValidateAndCopyFiles(FileList, PathCleanUpDirectories((CHAR16*)ShellCommandLineGetRawValue(Package, ParamCount)), SilentMode, RecursiveMode);
Status = ShellCloseFileMetaArg(&FileList);
if (EFI_ERROR(Status) && ShellStatus == SHELL_SUCCESS) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_FILE), gShellLevel2HiiHandle, ShellCommandLineGetRawValue(Package, ParamCount), ShellStatus|MAX_BIT);
ShellStatus = SHELL_ACCESS_DENIED;
}
}
}
break;
} // switch on parameter count
if (FileList != NULL) {
ShellCloseFileMetaArg(&FileList);
}
//
// free the command line package
//
ShellCommandLineFreeVarList (Package);
}
if (ShellGetExecutionBreakFlag()) {
return (SHELL_ABORTED);
}
return (ShellStatus);
}
/**
function to take a list of files to copy and a destination location and do
the verification and copying of those files to that location. This function
will report any errors to the user and halt.
The key is to have this function called ONLY once. this allows for the parameter
verification to happen correctly.
@param[in] FileList A LIST_ENTRY* based list of files to move.
@param[in] DestDir The destination location.
@param[in] SilentMode TRUE to eliminate screen output.
@param[in] RecursiveMode TRUE to copy directories.
@param[in] Resp The response to the overwrite query (if always).
@retval SHELL_SUCCESS the files were all moved.
@retval SHELL_INVALID_PARAMETER a parameter was invalid
@retval SHELL_SECURITY_VIOLATION a security violation ocurred
@retval SHELL_WRITE_PROTECTED the destination was write protected
@retval SHELL_OUT_OF_RESOURCES a memory allocation failed
**/
SHELL_STATUS
EFIAPI
ValidateAndCopyFiles(
IN CONST EFI_SHELL_FILE_INFO *FileList,
IN CONST CHAR16 *DestDir,
IN BOOLEAN SilentMode,
IN BOOLEAN RecursiveMode,
IN VOID **Resp
)
{
CHAR16 *HiiOutput;
CHAR16 *HiiResultOk;
CONST EFI_SHELL_FILE_INFO *Node;
SHELL_STATUS ShellStatus;
CHAR16 *DestPath;
VOID *Response;
UINTN PathLen;
CONST CHAR16 *Cwd;
CONST CHAR16 *TempLocation;
UINTN NewSize;
if (Resp == NULL) {
Response = NULL;
} else {
Response = *Resp;
}
DestPath = NULL;
ShellStatus = SHELL_SUCCESS;
PathLen = 0;
Cwd = ShellGetCurrentDir(NULL);
ASSERT(FileList != NULL);
ASSERT(DestDir != NULL);
//
// We already verified that this was present.
//
ASSERT(Cwd != NULL);
//
// If we are trying to copy multiple files... make sure we got a directory for the target...
//
if (EFI_ERROR(ShellIsDirectory(DestDir)) && FileList->Link.ForwardLink != FileList->Link.BackLink) {
//
// Error for destination not a directory
//
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_DIR), gShellLevel2HiiHandle, DestDir);
return (SHELL_INVALID_PARAMETER);
}
for (Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&FileList->Link)
; !IsNull(&FileList->Link, &Node->Link)
; Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&FileList->Link, &Node->Link)
){
//
// skip the directory traversing stuff...
//
if (StrCmp(Node->FileName, L".") == 0 || StrCmp(Node->FileName, L"..") == 0) {
continue;
}
NewSize = StrSize(DestDir);
NewSize += StrSize(Node->FullName);
NewSize += StrSize(Cwd);
if (NewSize > PathLen) {
PathLen = NewSize;
}
//
// Make sure got -r if required
//
if (!RecursiveMode && !EFI_ERROR(ShellIsDirectory(Node->FullName))) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_DIR_REQ), gShellLevel2HiiHandle);
return (SHELL_INVALID_PARAMETER);
}
//
// make sure got dest as dir if needed
//
if (!EFI_ERROR(ShellIsDirectory(Node->FullName)) && EFI_ERROR(ShellIsDirectory(DestDir))) {
//
// Error for destination not a directory
//
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_DIR), gShellLevel2HiiHandle, DestDir);
return (SHELL_INVALID_PARAMETER);
}
}
HiiOutput = HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_CP_OUTPUT), NULL);
HiiResultOk = HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_GEN_RES_OK), NULL);
DestPath = AllocateZeroPool(PathLen);
if (DestPath == NULL || HiiOutput == NULL || HiiResultOk == NULL) {
SHELL_FREE_NON_NULL(DestPath);
SHELL_FREE_NON_NULL(HiiOutput);
SHELL_FREE_NON_NULL(HiiResultOk);
return (SHELL_OUT_OF_RESOURCES);
}
//
// Go through the list of files to copy...
//
for (Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&FileList->Link)
; !IsNull(&FileList->Link, &Node->Link)
; Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&FileList->Link, &Node->Link)
){
if (ShellGetExecutionBreakFlag()) {
break;
}
ASSERT(Node->FileName != NULL);
ASSERT(Node->FullName != NULL);
//
// skip the directory traversing stuff...
//
if (StrCmp(Node->FileName, L".") == 0 || StrCmp(Node->FileName, L"..") == 0) {
continue;
}
if (FileList->Link.ForwardLink == FileList->Link.BackLink // 1 item
&& EFI_ERROR(ShellIsDirectory(DestDir)) // not an existing directory
) {
if (StrStr(DestDir, L":") == NULL) {
//
// simple copy of a single file
//
StrCpy(DestPath, Cwd);
if (DestPath[StrLen(DestPath)-1] != L'\\' && DestDir[0] != L'\\') {
StrCat(DestPath, L"\\");
} else if (DestPath[StrLen(DestPath)-1] == L'\\' && DestDir[0] == L'\\') {
((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL;
}
StrCat(DestPath, DestDir);
} else {
StrCpy(DestPath, DestDir);
}
} else {
//
// we have multiple files or a directory in the DestDir
//
//
// Check for leading slash
//
if (DestDir[0] == L'\\') {
//
// Copy to the root of CWD
//
StrCpy(DestPath, Cwd);
while (PathRemoveLastItem(DestPath));
StrCat(DestPath, DestDir+1);
StrCat(DestPath, Node->FileName);
} else if (StrStr(DestDir, L":") == NULL) {
StrCpy(DestPath, Cwd);
if (DestPath[StrLen(DestPath)-1] != L'\\' && DestDir[0] != L'\\') {
StrCat(DestPath, L"\\");
} else if (DestPath[StrLen(DestPath)-1] == L'\\' && DestDir[0] == L'\\') {
((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL;
}
StrCat(DestPath, DestDir);
if (DestDir[StrLen(DestDir)-1] != L'\\' && Node->FileName[0] != L'\\') {
StrCat(DestPath, L"\\");
} else if (DestDir[StrLen(DestDir)-1] == L'\\' && Node->FileName[0] == L'\\') {
((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL;
}
StrCat(DestPath, Node->FileName);
} else {
StrCpy(DestPath, DestDir);
if (DestDir[StrLen(DestDir)-1] != L'\\' && Node->FileName[0] != L'\\') {
StrCat(DestPath, L"\\");
} else if (DestDir[StrLen(DestDir)-1] == L'\\' && Node->FileName[0] == L'\\') {
((CHAR16*)DestDir)[StrLen(DestDir)-1] = CHAR_NULL;
}
StrCat(DestPath, Node->FileName);
}
}
//
// Make sure the path exists
//
if (EFI_ERROR(VerifyIntermediateDirectories(DestPath))) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_DIR_WNF), gShellLevel2HiiHandle);
ShellStatus = SHELL_DEVICE_ERROR;
break;
}
if ( !EFI_ERROR(ShellIsDirectory(Node->FullName))
&& !EFI_ERROR(ShellIsDirectory(DestPath))
&& StrniCmp(Node->FullName, DestPath, StrLen(DestPath)) == NULL
){
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_PARENT), gShellLevel2HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
break;
}
if (StringNoCaseCompare(&Node->FullName, &DestPath) == 0) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_SAME), gShellLevel2HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
break;
}
if ((TempLocation = StrniCmp(Node->FullName, DestPath, StrLen(Node->FullName))) == 0
&& (DestPath[StrLen(Node->FullName)] == CHAR_NULL || DestPath[StrLen(Node->FullName)] == L'\\')
) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_SAME), gShellLevel2HiiHandle);
ShellStatus = SHELL_INVALID_PARAMETER;
break;
}
PathCleanUpDirectories(DestPath);
ShellPrintEx(-1, -1, HiiOutput, Node->FullName, DestPath);
//
// copy single file...
//
ShellStatus = CopySingleFile(Node->FullName, DestPath, &Response, SilentMode);
if (ShellStatus != SHELL_SUCCESS) {
break;
}
}
if (ShellStatus == SHELL_SUCCESS && Resp == NULL) {
ShellPrintEx(-1, -1, L"%s", HiiResultOk);
}
SHELL_FREE_NON_NULL(DestPath);
SHELL_FREE_NON_NULL(HiiOutput);
SHELL_FREE_NON_NULL(HiiResultOk);
if (Resp == NULL) {
SHELL_FREE_NON_NULL(Response);
}
return (ShellStatus);
}
/**
Function for 'cd' 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
ShellCommandRunCd (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
LIST_ENTRY *Package;
CONST CHAR16 *Cwd;
CHAR16 *Path;
CHAR16 *Drive;
CHAR16 *ProblemParam;
SHELL_STATUS ShellStatus;
CONST CHAR16 *Param1;
CHAR16 *Param1Copy;
CHAR16 *Walker;
CHAR16 *Splitter;
CHAR16 *TempBuffer;
UINTN TotalSize;
ProblemParam = NULL;
ShellStatus = SHELL_SUCCESS;
Cwd = NULL;
Path = NULL;
Drive = NULL;
Splitter = NULL;
TempBuffer = NULL;
TotalSize = 0;
Status = CommandInit();
ASSERT_EFI_ERROR(Status);
//
// initialize the shell lib (we must be in non-auto-init...)
//
Status = ShellInitialize();
ASSERT_EFI_ERROR(Status);
//
// parse the command line
//
Status = ShellCommandLineParse (EmptyParamList, &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"cd", ProblemParam);
FreePool(ProblemParam);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
ASSERT(FALSE);
}
}
//
// check for "-?"
//
if (ShellCommandLineGetFlag(Package, L"-?")) {
ASSERT(FALSE);
} else if (ShellCommandLineGetRawValue(Package, 2) != NULL) {
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel2HiiHandle, L"cd");
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
//
// remember that param 0 is the command name
// If there are 0 value parameters, then print the current directory
// else If there are 2 value parameters, then print the error message
// else If there is 1 value paramerer , then change the directory
//
Cwd = ShellGetCurrentDir (NULL);
if (Cwd == NULL) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN(STR_GEN_NO_CWD), gShellLevel2HiiHandle, L"cd");
ShellStatus = SHELL_NOT_FOUND;
} else {
Param1 = ShellCommandLineGetRawValue (Package, 1);
if (Param1 == NULL) {
//
// display the current directory
//
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN(STR_CD_PRINT), gShellLevel2HiiHandle, Cwd);
} else {
Param1Copy = CatSPrint (NULL, L"%s", Param1, NULL);
for (Walker = Param1Copy; Walker != NULL && *Walker != CHAR_NULL; Walker++) {
if (*Walker == L'\"') {
CopyMem (Walker, Walker + 1, StrSize(Walker) - sizeof(Walker[0]));
}
}
if (Param1Copy != NULL && IsCurrentFileSystem (Param1Copy, Cwd)) {
Status = ReplaceDriveWithCwd (&Param1Copy,Cwd);
if (!EFI_ERROR (Status)) {
Param1Copy = PathCleanUpDirectories (Param1Copy);
}
} else {
//
// Can't use cd command to change filesystem.
//
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_CD_NF), gShellLevel2HiiHandle, L"cd");
Status = EFI_NOT_FOUND;
}
if (!EFI_ERROR(Status) && Param1Copy != NULL) {
Splitter = StrStr (Cwd, L":");
if (Param1Copy[0] == L'\\') {
//
// Absolute Path on current drive letter.
//
TotalSize = ((Splitter - Cwd + 1) * sizeof(CHAR16)) + StrSize(Param1Copy);
TempBuffer = AllocateZeroPool (TotalSize);
if (TempBuffer == NULL) {
Status = EFI_OUT_OF_RESOURCES;
} else {
StrnCpyS (TempBuffer, TotalSize / sizeof(CHAR16), Cwd, (Splitter - Cwd + 1));
StrCatS (TempBuffer, TotalSize / sizeof(CHAR16), Param1Copy);
FreePool (Param1Copy);
Param1Copy = TempBuffer;
TempBuffer = NULL;
}
} else {
if (StrStr (Param1Copy,L":") == NULL) {
TotalSize = StrSize (Cwd) + StrSize (Param1Copy);
TempBuffer = AllocateZeroPool (TotalSize);
if (TempBuffer == NULL) {
Status = EFI_OUT_OF_RESOURCES;
} else {
StrCpyS (TempBuffer, TotalSize / sizeof (CHAR16), Cwd);
StrCatS (TempBuffer, TotalSize / sizeof (CHAR16), L"\\");
StrCatS (TempBuffer, TotalSize / sizeof (CHAR16), Param1Copy);
FreePool (Param1Copy);
Param1Copy = PathCleanUpDirectories (TempBuffer);
}
}
}
}
if (!EFI_ERROR(Status)) {
Status = ExtractDriveAndPath (Param1Copy, &Drive, &Path);
}
if (!EFI_ERROR (Status) && Drive != NULL && Path != NULL) {
if (EFI_ERROR(ShellIsDirectory (Param1Copy))) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN(STR_GEN_NOT_DIR), gShellLevel2HiiHandle, L"cd", Param1Copy);
ShellStatus = SHELL_NOT_FOUND;
} else {
Status = gEfiShellProtocol->SetCurDir (Drive, Path + 1);
if (EFI_ERROR (Status)) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN(STR_GEN_DIR_NF), gShellLevel2HiiHandle, L"cd", Param1Copy);
ShellStatus = SHELL_NOT_FOUND;
}
}
}
if (Drive != NULL) {
FreePool (Drive);
}
if (Path != NULL) {
FreePool (Path);
}
FreePool (Param1Copy);
}
}
}
//
// free the command line package
//
ShellCommandLineFreeVarList (Package);
//
// return the status
//
return (ShellStatus);
}
/**
Function for 'mkdir' 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
ShellCommandRunMkDir (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
CONST CHAR16 *NewDirName;
CHAR16 *NewDirNameCopy;
CHAR16 *SplitName;
CHAR16 SaveSplitChar;
UINTN DirCreateCount;
LIST_ENTRY *Package;
CHAR16 *ProblemParam;
SHELL_FILE_HANDLE FileHandle;
SHELL_STATUS ShellStatus;
ShellStatus = SHELL_SUCCESS;
NewDirNameCopy = NULL;
SplitName = NULL;
SaveSplitChar = CHAR_NULL;
//
// initialize the shell lib (we must be in non-auto-init...)
//
Status = ShellInitialize();
ASSERT_EFI_ERROR(Status);
//
// parse the command line
//
Status = ShellCommandLineParse (EmptyParamList, &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"mkdir", ProblemParam);
FreePool(ProblemParam);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
ASSERT(FALSE);
}
} else {
//
// check for "-?"
//
if (ShellCommandLineGetFlag(Package, L"-?")) {
ASSERT(FALSE);
}
//
// create a set of directories
//
if (ShellCommandLineGetRawValue(Package, 1) == NULL) {
//
// we didnt get a single parameter
//
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellLevel2HiiHandle, L"mkdir");
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
for ( DirCreateCount = 1
;
; DirCreateCount++
){
//
// loop through each directory specified
//
NewDirName = ShellCommandLineGetRawValue(Package, DirCreateCount);
if (NewDirName == NULL) {
break;
}
//
// check if that already exists... if yes fail
//
FileHandle = NULL;
Status = ShellOpenFileByName(NewDirName,
&FileHandle,
EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE,
EFI_FILE_DIRECTORY
);
if (!EFI_ERROR(Status)) {
ShellCloseFile(&FileHandle);
ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MKDIR_ALREADY), gShellLevel2HiiHandle, NewDirName);
ShellStatus = SHELL_INVALID_PARAMETER;
} else {
ASSERT(FileHandle == NULL);
//
// create the nested directory from parent to child.
// if NewDirName = test1\test2\test3, first create "test1\" directory, then "test1\test2\", finally "test1\test2\test3".
//
NewDirNameCopy = AllocateCopyPool (StrSize(NewDirName), NewDirName);
NewDirNameCopy = PathCleanUpDirectories (NewDirNameCopy);
if(NewDirNameCopy == NULL) {
ShellStatus = SHELL_OUT_OF_RESOURCES;
break;
}
SplitName = NewDirNameCopy;
while (SplitName != NULL) {
SplitName = StrStr (SplitName + 1, L"\\");
if (SplitName != NULL) {
SaveSplitChar = *(SplitName + 1);
*(SplitName + 1) = '\0';
}
//
// check if current nested directory already exists... continue to create the child directory.
//
Status = ShellOpenFileByName (NewDirNameCopy,
&FileHandle,
EFI_FILE_MODE_READ,
EFI_FILE_DIRECTORY
);
if (!EFI_ERROR(Status)) {
ShellCloseFile (&FileHandle);
} else {
Status = ShellCreateDirectory (NewDirNameCopy, &FileHandle);
if (EFI_ERROR(Status)) {
break;
}
if (FileHandle != NULL) {
gEfiShellProtocol->CloseFile (FileHandle);
}
}
if (SplitName != NULL) {
*(SplitName + 1) = SaveSplitChar;
}
}
if (EFI_ERROR(Status)) {
ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_MKDIR_CREATEFAIL), gShellLevel2HiiHandle, NewDirName);
ShellStatus = SHELL_ACCESS_DENIED;
break;
}
SHELL_FREE_NON_NULL (NewDirNameCopy);
}
}
}
}
//
// free the command line package
//
ShellCommandLineFreeVarList (Package);
return (ShellStatus);
}
