ShellPkg/Library/UefiShellLevel2CommandsLib/Cp.c

   1 /** @file
   2   Main file for cp shell level 2 function.
   3
   4   Copyright (c) 2009 - 2011, 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
   9
  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.
  12
  13 **/
  14
  15 #include "UefiShellLevel2CommandsLib.h"
  16
  17 /**
  18   Function to take a list of files to copy and a destination location and do
  19   the verification and copying of those files to that location.  This function
  20   will report any errors to the user and halt.
  21
  22   @param[in] FileList           A LIST_ENTRY* based list of files to move.
  23   @param[in] DestDir            The destination location.
  24   @param[in] SilentMode         TRUE to eliminate screen output.
  25   @param[in] RecursiveMode      TRUE to copy directories.
  26   @param[in] Resp               The response to the overwrite query (if always).
  27
  28   @retval SHELL_SUCCESS             the files were all moved.
  29   @retval SHELL_INVALID_PARAMETER   a parameter was invalid
  30   @retval SHELL_SECURITY_VIOLATION  a security violation ocurred
  31   @retval SHELL_WRITE_PROTECTED     the destination was write protected
  32   @retval SHELL_OUT_OF_RESOURCES    a memory allocation failed
  33 **/
  34 SHELL_STATUS
  35 EFIAPI
  36 ValidateAndCopyFiles(
  37   IN CONST EFI_SHELL_FILE_INFO  *FileList,
  38   IN CONST CHAR16               *DestDir,
  39   IN BOOLEAN                    SilentMode,
  40   IN BOOLEAN                    RecursiveMode,
  41   IN VOID                       **Resp
  42   );
  43
  44 /**
  45   Function to Copy one file to another location
  46
  47   If the destination exists the user will be prompted and the result put into *resp
  48
  49   @param[in] Source     pointer to source file name
  50   @param[in] Dest       pointer to destination file name
  51   @param[out] Resp      pointer to response from question.  Pass back on looped calling
  52   @param[in] SilentMode whether to run in quiet mode or not
  53
  54   @retval SHELL_SUCCESS   The source file was copied to the destination
  55 **/
  56 SHELL_STATUS
  57 EFIAPI
  58 CopySingleFile(
  59   IN CONST CHAR16 *Source,
  60   IN CONST CHAR16 *Dest,
  61   OUT VOID        **Resp,
  62   IN BOOLEAN      SilentMode
  63   )
  64 {
  65   VOID                *Response;
  66   UINTN               ReadSize;
  67   SHELL_FILE_HANDLE   SourceHandle;
  68   SHELL_FILE_HANDLE   DestHandle;
  69   EFI_STATUS          Status;
  70   VOID                *Buffer;
  71   CHAR16              *TempName;
  72   UINTN               Size;
  73   EFI_SHELL_FILE_INFO *List;
  74   SHELL_STATUS        ShellStatus;
  75
  76
  77   ASSERT(Resp != NULL);
  78
  79   SourceHandle  = NULL;
  80   DestHandle    = NULL;
  81   Response      = *Resp;
  82   List          = NULL;
  83
  84   ReadSize = PcdGet16(PcdShellFileOperationSize);
  85   // Why bother copying a file to itself
  86   if (StrCmp(Source, Dest) == 0) {
  87     return (SHELL_SUCCESS);
  88   }
  89
  90   //
  91   // Open destination file without create
  92   //
  93   Status = ShellOpenFileByName(Dest, &DestHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE, 0);
  94
  95   //
  96   // close file
  97   //
  98   if (DestHandle != NULL) {
  99     ShellCloseFile(&DestHandle);
 100     DestHandle   = NULL;
 101   }
 102
 103   //
 104   // if the destination file existed check response and possibly prompt user
 105   //
 106   if (!EFI_ERROR(Status)) {
 107     if (Response == NULL && !SilentMode) {
 108       Status = ShellPromptForResponseHii(ShellPromptResponseTypeYesNoAllCancel, STRING_TOKEN (STR_GEN_DEST_EXIST_OVR), gShellLevel2HiiHandle, &Response);
 109     }
 110     //
 111     // possibly return based on response
 112     //
 113     if (!SilentMode) {
 114       switch (*(SHELL_PROMPT_RESPONSE*)Response) {
 115         case ShellPromptResponseNo:
 116           //
 117           // return success here so we dont stop the process
 118           //
 119           return (SHELL_SUCCESS);
 120         case ShellPromptResponseCancel:
 121           *Resp = Response;
 122           //
 123           // indicate to stop everything
 124           //
 125           return (SHELL_ABORTED);
 126         case ShellPromptResponseAll:
 127           *Resp = Response;
 128         case ShellPromptResponseYes:
 129           break;
 130         default:
 131           return SHELL_ABORTED;
 132       }
 133     }
 134   }
 135
 136   if (ShellIsDirectory(Source) == EFI_SUCCESS) {
 137     Status = ShellCreateDirectory(Dest, &DestHandle);
 138     if (EFI_ERROR(Status)) {
 139       return (SHELL_ACCESS_DENIED);
 140     }
 141
 142     //
 143     // Now copy all the files under the directory...
 144     //
 145     TempName    = NULL;
 146     Size          = 0;
 147     StrnCatGrow(&TempName, &Size, Source, 0);
 148     StrnCatGrow(&TempName, &Size, L"\\*", 0);
 149     ShellOpenFileMetaArg((CHAR16*)TempName, EFI_FILE_MODE_READ, &List);
 150     TempName = NULL;
 151     StrnCatGrow(&TempName, &Size, Dest, 0);
 152     StrnCatGrow(&TempName, &Size, L"\\", 0);
 153     ShellStatus = ValidateAndCopyFiles(List, TempName, SilentMode, TRUE, Resp);
 154     ShellCloseFileMetaArg(&List);
 155     FreePool(TempName);
 156     Size = 0;
 157   } else {
 158     //
 159     // open file with create enabled
 160     //
 161     Status = ShellOpenFileByName(Dest, &DestHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE, 0);
 162     if (EFI_ERROR(Status)) {
 163       return (SHELL_ACCESS_DENIED);
 164     }
 165
 166     //
 167     // open source file
 168     //
 169     Status = ShellOpenFileByName(Source, &SourceHandle, EFI_FILE_MODE_READ, 0);
 170     ASSERT_EFI_ERROR(Status);
 171
 172     //
 173     // copy data between files
 174     //
 175     Buffer = AllocateZeroPool(ReadSize);
 176     ASSERT(Buffer != NULL);
 177     while (ReadSize == PcdGet16(PcdShellFileOperationSize) && !EFI_ERROR(Status)) {
 178       Status = ShellReadFile(SourceHandle, &ReadSize, Buffer);
 179       ASSERT_EFI_ERROR(Status);
 180       Status = ShellWriteFile(DestHandle, &ReadSize, Buffer);
 181     }
 182   }
 183
 184   //
 185   // close files
 186   //
 187   if (DestHandle != NULL) {
 188     ShellCloseFile(&DestHandle);
 189     DestHandle   = NULL;
 190   }
 191   if (SourceHandle != NULL) {
 192     ShellCloseFile(&SourceHandle);
 193     SourceHandle = NULL;
 194   }
 195
 196   //
 197   // return
 198   //
 199   return (SHELL_SUCCESS);
 200 }
 201
 202 /**
 203   function to take a list of files to copy and a destination location and do
 204   the verification and copying of those files to that location.  This function
 205   will report any errors to the user and halt.
 206
 207   The key is to have this function called ONLY once.  this allows for the parameter
 208   verification to happen correctly.
 209
 210   @param[in] FileList           A LIST_ENTRY* based list of files to move.
 211   @param[in] DestDir            The destination location.
 212   @param[in] SilentMode         TRUE to eliminate screen output.
 213   @param[in] RecursiveMode      TRUE to copy directories.
 214   @param[in] Resp               The response to the overwrite query (if always).
 215
 216   @retval SHELL_SUCCESS             the files were all moved.
 217   @retval SHELL_INVALID_PARAMETER   a parameter was invalid
 218   @retval SHELL_SECURITY_VIOLATION  a security violation ocurred
 219   @retval SHELL_WRITE_PROTECTED     the destination was write protected
 220   @retval SHELL_OUT_OF_RESOURCES    a memory allocation failed
 221 **/
 222 SHELL_STATUS
 223 EFIAPI
 224 ValidateAndCopyFiles(
 225   IN CONST EFI_SHELL_FILE_INFO  *FileList,
 226   IN CONST CHAR16               *DestDir,
 227   IN BOOLEAN                    SilentMode,
 228   IN BOOLEAN                    RecursiveMode,
 229   IN VOID                       **Resp
 230   )
 231 {
 232   CHAR16                    *HiiOutput;
 233   CHAR16                    *HiiResultOk;
 234   CONST EFI_SHELL_FILE_INFO *Node;
 235   SHELL_STATUS              ShellStatus;
 236   CHAR16                    *DestPath;
 237   VOID                      *Response;
 238   UINTN                     PathLen;
 239   CONST CHAR16              *Cwd;
 240   CONST CHAR16              *TempLocation;
 241   UINTN                     NewSize;
 242
 243   if (Resp == NULL) {
 244     Response = NULL;
 245   } else {
 246     Response = *Resp;
 247   }
 248
 249   DestPath    = NULL;
 250   ShellStatus = SHELL_SUCCESS;
 251   PathLen     = 0;
 252   Cwd         = ShellGetCurrentDir(NULL);
 253
 254   ASSERT(FileList != NULL);
 255   ASSERT(DestDir  != NULL);
 256
 257   //
 258   // If we are trying to copy multiple files... make sure we got a directory for the target...
 259   //
 260   if (EFI_ERROR(ShellIsDirectory(DestDir)) && FileList->Link.ForwardLink != FileList->Link.BackLink) {
 261     //
 262     // Error for destination not a directory
 263     //
 264     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_DIR), gShellLevel2HiiHandle, DestDir);
 265     return (SHELL_INVALID_PARAMETER);
 266   }
 267   for (Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&FileList->Link)
 268     ;  !IsNull(&FileList->Link, &Node->Link)
 269     ;  Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&FileList->Link, &Node->Link)
 270    ){
 271     //
 272     // skip the directory traversing stuff...
 273     //
 274     if (StrCmp(Node->FileName, L".") == 0 || StrCmp(Node->FileName, L"..") == 0) {
 275       continue;
 276     }
 277
 278     NewSize =  StrSize(DestDir);
 279     NewSize += StrSize(Node->FullName);
 280     NewSize += StrSize(Cwd);
 281     if (NewSize > PathLen) {
 282       PathLen = NewSize;
 283     }
 284
 285     //
 286     // Make sure got -r if required
 287     //
 288     if (!RecursiveMode && !EFI_ERROR(ShellIsDirectory(Node->FullName))) {
 289       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_DIR_REQ), gShellLevel2HiiHandle);
 290       return (SHELL_INVALID_PARAMETER);
 291     }
 292
 293     //
 294     // make sure got dest as dir if needed
 295     //
 296     if (!EFI_ERROR(ShellIsDirectory(Node->FullName)) && EFI_ERROR(ShellIsDirectory(DestDir))) {
 297       //
 298       // Error for destination not a directory
 299       //
 300       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_DIR), gShellLevel2HiiHandle, DestDir);
 301       return (SHELL_INVALID_PARAMETER);
 302     }
 303   }
 304
 305   HiiOutput   = HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_CP_OUTPUT), NULL);
 306   HiiResultOk = HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_GEN_RES_OK), NULL);
 307   DestPath    = AllocateZeroPool(PathLen);
 308
 309   if (DestPath == NULL || HiiOutput == NULL || HiiResultOk == NULL) {
 310     SHELL_FREE_NON_NULL(DestPath);
 311     SHELL_FREE_NON_NULL(HiiOutput);
 312     SHELL_FREE_NON_NULL(HiiResultOk);
 313     return (SHELL_OUT_OF_RESOURCES);
 314   }
 315
 316   //
 317   // Go through the list of files to copy...
 318   //
 319   for (Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&FileList->Link)
 320     ;  !IsNull(&FileList->Link, &Node->Link)
 321     ;  Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&FileList->Link, &Node->Link)
 322    ){
 323     if (ShellGetExecutionBreakFlag()) {
 324       break;
 325     }
 326     ASSERT(Node->FileName != NULL);
 327     ASSERT(Node->FullName != NULL);
 328
 329     //
 330     // skip the directory traversing stuff...
 331     //
 332     if (StrCmp(Node->FileName, L".") == 0 || StrCmp(Node->FileName, L"..") == 0) {
 333       continue;
 334     }
 335
 336     if (FileList->Link.ForwardLink == FileList->Link.BackLink // 1 item
 337       && EFI_ERROR(ShellIsDirectory(DestDir))                 // not an existing directory
 338      ) {
 339       if (StrStr(DestDir, L":") == NULL) {
 340         //
 341         // simple copy of a single file
 342         //
 343         StrCpy(DestPath, Cwd);
 344         if (DestPath[StrLen(DestPath)-1] != L'\\' && DestDir[0] != L'\\') {
 345           StrCat(DestPath, L"\\");
 346         } else if (DestPath[StrLen(DestPath)-1] == L'\\' && DestDir[0] == L'\\') {
 347           ((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL;
 348         }
 349         StrCat(DestPath, DestDir);
 350       } else {
 351         StrCpy(DestPath, DestDir);
 352       }
 353     } else {
 354       //
 355       // we have multiple files or a directory in the DestDir
 356       //
 357       if (StrStr(DestDir, L":") == NULL) {
 358         StrCpy(DestPath, Cwd);
 359         if (DestPath[StrLen(DestPath)-1] != L'\\' && DestDir[0] != L'\\') {
 360           StrCat(DestPath, L"\\");
 361         } else if (DestPath[StrLen(DestPath)-1] == L'\\' && DestDir[0] == L'\\') {
 362           ((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL;
 363         }
 364         StrCat(DestPath, DestDir);
 365         if (DestDir[StrLen(DestDir)-1] != L'\\' && Node->FileName[0] != L'\\') {
 366           StrCat(DestPath, L"\\");
 367         } else if (DestDir[StrLen(DestDir)-1] == L'\\' && Node->FileName[0] == L'\\') {
 368           ((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL;
 369         }
 370         StrCat(DestPath, Node->FileName);
 371
 372       } else {
 373         StrCpy(DestPath, DestDir);
 374         if (DestDir[StrLen(DestDir)-1] != L'\\' && Node->FileName[0] != L'\\') {
 375           StrCat(DestPath, L"\\");
 376         } else if (DestDir[StrLen(DestDir)-1] == L'\\' && Node->FileName[0] == L'\\') {
 377           ((CHAR16*)DestDir)[StrLen(DestDir)-1] = CHAR_NULL;
 378         }
 379         StrCat(DestPath, Node->FileName);
 380       }
 381     }
 382
 383     //
 384     // Make sure the path exists
 385     //
 386     if (EFI_ERROR(VerifyIntermediateDirectories(DestPath))) {
 387       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_DIR_WNF), gShellLevel2HiiHandle);
 388       ShellStatus = SHELL_DEVICE_ERROR;
 389       break;
 390     }
 391
 392     if ( !EFI_ERROR(ShellIsDirectory(Node->FullName))
 393       && !EFI_ERROR(ShellIsDirectory(DestPath))
 394       && StrniCmp(Node->FullName, DestPath, StrLen(DestPath)) == NULL
 395      ){
 396       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_PARENT), gShellLevel2HiiHandle);
 397       ShellStatus = SHELL_INVALID_PARAMETER;
 398       break;
 399     }
 400     if (StringNoCaseCompare(&Node->FullName, &DestPath) == 0) {
 401       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_SAME), gShellLevel2HiiHandle);
 402       ShellStatus = SHELL_INVALID_PARAMETER;
 403       break;
 404     }
 405
 406     if ((TempLocation = StrniCmp(Node->FullName, DestPath, StrLen(Node->FullName))) == 0
 407       && (DestPath[StrLen(Node->FullName)] == CHAR_NULL || DestPath[StrLen(Node->FullName)] == L'\\')
 408      ) {
 409       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_SAME), gShellLevel2HiiHandle);
 410       ShellStatus = SHELL_INVALID_PARAMETER;
 411       break;
 412     }
 413
 414     CleanPath(DestPath);
 415
 416     ShellPrintEx(-1, -1, HiiOutput, Node->FullName, DestPath);
 417
 418     //
 419     // copy single file...
 420     //
 421     ShellStatus = CopySingleFile(Node->FullName, DestPath, &Response, SilentMode);
 422     if (ShellStatus != SHELL_SUCCESS) {
 423       break;
 424     }
 425   }
 426   if (ShellStatus == SHELL_SUCCESS && Resp == NULL) {
 427     ShellPrintEx(-1, -1, L"%s", HiiResultOk);
 428   }
 429
 430   SHELL_FREE_NON_NULL(DestPath);
 431   SHELL_FREE_NON_NULL(HiiOutput);
 432   SHELL_FREE_NON_NULL(HiiResultOk);
 433   if (Resp == NULL) {
 434     SHELL_FREE_NON_NULL(Response);
 435   }
 436
 437   return (ShellStatus);
 438 }
 439
 440 /**
 441   Validate and if successful copy all the files from the list into
 442   destination directory.
 443
 444   @param[in] FileList       The list of files to copy.
 445   @param[in] DestDir        The directory to copy files to.
 446   @param[in] SilentMode     TRUE to eliminate screen output.
 447   @param[in] RecursiveMode  TRUE to copy directories.
 448
 449   @retval SHELL_INVALID_PARAMETER   A parameter was invalid.
 450   @retval SHELL_SUCCESS             The operation was successful.
 451 **/
 452 SHELL_STATUS
 453 EFIAPI
 454 ProcessValidateAndCopyFiles(
 455   IN       EFI_SHELL_FILE_INFO  *FileList,
 456   IN CONST CHAR16               *DestDir,
 457   IN BOOLEAN                    SilentMode,
 458   IN BOOLEAN                    RecursiveMode
 459   )
 460 {
 461   SHELL_STATUS        ShellStatus;
 462   EFI_SHELL_FILE_INFO *List;
 463   EFI_STATUS          Status;
 464   EFI_FILE_INFO       *FileInfo;
 465
 466   List = NULL;
 467
 468   Status = ShellOpenFileMetaArg((CHAR16*)DestDir, EFI_FILE_MODE_READ, &List);
 469   if (List != NULL && List->Link.ForwardLink != List->Link.BackLink) {
 470     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_MARG_ERROR), gShellLevel2HiiHandle, DestDir);
 471     ShellStatus = SHELL_INVALID_PARAMETER;
 472     ShellCloseFileMetaArg(&List);
 473   } else if (List != NULL) {
 474     ASSERT(((EFI_SHELL_FILE_INFO *)List->Link.ForwardLink) != NULL);
 475     ASSERT(((EFI_SHELL_FILE_INFO *)List->Link.ForwardLink)->FullName != NULL);
 476     FileInfo    = NULL;
 477     FileInfo = gEfiShellProtocol->GetFileInfo(((EFI_SHELL_FILE_INFO *)List->Link.ForwardLink)->Handle);
 478     ASSERT(FileInfo != NULL);
 479     if ((FileInfo->Attribute & EFI_FILE_READ_ONLY) == 0) {
 480       ShellStatus = ValidateAndCopyFiles(FileList, ((EFI_SHELL_FILE_INFO *)List->Link.ForwardLink)->FullName, SilentMode, RecursiveMode, NULL);
 481     } else {
 482       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_DEST_ERROR), gShellLevel2HiiHandle);
 483       ShellStatus = SHELL_ACCESS_DENIED;
 484     }
 485     SHELL_FREE_NON_NULL(FileInfo);
 486     ShellCloseFileMetaArg(&List);
 487   } else {
 488       ShellStatus = ValidateAndCopyFiles(FileList, DestDir, SilentMode, RecursiveMode, NULL);
 489   }
 490
 491   return (ShellStatus);
 492 }
 493
 494 STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
 495   {L"-r", TypeFlag},
 496   {L"-q", TypeFlag},
 497   {NULL, TypeMax}
 498   };
 499
 500 /**
 501   Function for 'cp' command.
 502
 503   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
 504   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
 505 **/
 506 SHELL_STATUS
 507 EFIAPI
 508 ShellCommandRunCp (
 509   IN EFI_HANDLE        ImageHandle,
 510   IN EFI_SYSTEM_TABLE  *SystemTable
 511   )
 512 {
 513   EFI_STATUS          Status;
 514   LIST_ENTRY          *Package;
 515   CHAR16              *ProblemParam;
 516   SHELL_STATUS        ShellStatus;
 517   UINTN               ParamCount;
 518   UINTN               LoopCounter;
 519   EFI_SHELL_FILE_INFO *FileList;
 520   BOOLEAN             SilentMode;
 521   BOOLEAN             RecursiveMode;
 522   CONST CHAR16        *Cwd;
 523
 524   ProblemParam        = NULL;
 525   ShellStatus         = SHELL_SUCCESS;
 526   ParamCount          = 0;
 527   FileList            = NULL;
 528
 529   //
 530   // initialize the shell lib (we must be in non-auto-init...)
 531   //
 532   Status = ShellInitialize();
 533   ASSERT_EFI_ERROR(Status);
 534
 535   Status = CommandInit();
 536   ASSERT_EFI_ERROR(Status);
 537
 538   //
 539   // parse the command line
 540   //
 541   Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
 542   if (EFI_ERROR(Status)) {
 543     if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
 544       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellLevel2HiiHandle, ProblemParam);
 545       FreePool(ProblemParam);
 546       ShellStatus = SHELL_INVALID_PARAMETER;
 547     } else {
 548       ASSERT(FALSE);
 549     }
 550   } else {
 551     //
 552     // check for "-?"
 553     //
 554     if (ShellCommandLineGetFlag(Package, L"-?")) {
 555       ASSERT(FALSE);
 556     }
 557
 558     //
 559     // Initialize SilentMode and RecursiveMode
 560     //
 561     if (gEfiShellProtocol->BatchIsActive()) {
 562       SilentMode = TRUE;
 563     } else {
 564       SilentMode = ShellCommandLineGetFlag(Package, L"-q");
 565     }
 566     RecursiveMode = ShellCommandLineGetFlag(Package, L"-r");
 567
 568     switch (ParamCount = ShellCommandLineGetCount(Package)) {
 569       case 0:
 570       case 1:
 571         //
 572         // we have insufficient parameters
 573         //
 574         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellLevel2HiiHandle);
 575         ShellStatus = SHELL_INVALID_PARAMETER;
 576         break;
 577       case 2:
 578         //
 579         // must have valid CWD for single parameter...
 580         //
 581         Cwd = ShellGetCurrentDir(NULL);
 582         if (Cwd == NULL){
 583           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_CWD), gShellLevel2HiiHandle);
 584           ShellStatus = SHELL_INVALID_PARAMETER;
 585         } else {
 586           Status = ShellOpenFileMetaArg((CHAR16*)ShellCommandLineGetRawValue(Package, 1), EFI_FILE_MODE_WRITE|EFI_FILE_MODE_READ, &FileList);
 587           if (FileList == NULL || IsListEmpty(&FileList->Link) || EFI_ERROR(Status)) {
 588             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_NF), gShellLevel2HiiHandle, ShellCommandLineGetRawValue(Package, 1));
 589             ShellStatus = SHELL_NOT_FOUND;
 590           } else  {
 591             ShellStatus = ProcessValidateAndCopyFiles(FileList, Cwd, SilentMode, RecursiveMode);
 592           }
 593         }
 594
 595         break;
 596       default:
 597         //
 598         // Make a big list of all the files...
 599         //
 600         for (ParamCount--, LoopCounter = 1 ; LoopCounter < ParamCount && ShellStatus == SHELL_SUCCESS ; LoopCounter++) {
 601           if (ShellGetExecutionBreakFlag()) {
 602             break;
 603           }
 604           Status = ShellOpenFileMetaArg((CHAR16*)ShellCommandLineGetRawValue(Package, LoopCounter), EFI_FILE_MODE_WRITE|EFI_FILE_MODE_READ, &FileList);
 605           if (EFI_ERROR(Status) || FileList == NULL || IsListEmpty(&FileList->Link)) {
 606             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_NF), gShellLevel2HiiHandle, ShellCommandLineGetRawValue(Package, 1));
 607             ShellStatus = SHELL_NOT_FOUND;
 608           }
 609         }
 610         //
 611         // now copy them all...
 612         //
 613         if (FileList != NULL && !IsListEmpty(&FileList->Link)) {
 614           ShellStatus = ProcessValidateAndCopyFiles(FileList, ShellCommandCleanPath((CHAR16*)ShellCommandLineGetRawValue(Package, ParamCount)), SilentMode, RecursiveMode);
 615           Status = ShellCloseFileMetaArg(&FileList);
 616           if (EFI_ERROR(Status) && ShellStatus == SHELL_SUCCESS) {
 617             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_FILE), gShellLevel2HiiHandle, ShellCommandLineGetRawValue(Package, 1), ShellStatus|MAX_BIT);
 618             ShellStatus = SHELL_ACCESS_DENIED;
 619           }
 620         }
 621
 622         break;
 623     } // switch on parameter count
 624
 625     if (FileList != NULL) {
 626       ShellCloseFileMetaArg(&FileList);
 627     }
 628
 629     //
 630     // free the command line package
 631     //
 632     ShellCommandLineFreeVarList (Package);
 633   }
 634
 635   if (ShellGetExecutionBreakFlag()) {
 636     return (SHELL_ABORTED);
 637   }
 638
 639   return (ShellStatus);
 640 }
 641