reactos/base/shell/cmd/copy.c

   1 /*
   2  *  COPY.C -- copy internal command.
   3  *
   4  *
   5  *  History:
   6  *
   7  *    01-Aug-98 (Rob Lake z63rrl@morgan.ucs.mun.ca)
   8  *        started
   9  *
  10  *    13-Aug-1998 (John P. Price)
  11  *        fixed memory leak problem in copy function.
  12  *        fixed copy function so it would work with wildcards in the source
  13  *
  14  *    13-Dec-1998 (Eric Kohl)
  15  *        Added COPY command to CMD.
  16  *
  17  *    26-Jan-1998 (Eric Kohl)
  18  *        Replaced CRT io functions by Win32 io functions.
  19  *
  20  *    27-Oct-1998 (Eric Kohl)
  21  *        Disabled prompting when used in batch mode.
  22  *
  23  *    03-Apr-2005 (Magnus Olsen) <magnus@greatlord.com>)
  24  *        Remove all hardcode string to En.rc
  25  *
  26  *    13-Jul-2005 (Brandon Turner) <turnerb7@msu.edu>)
  27  *        Rewrite to clean up copy and support wildcard.
  28  *
  29  *    20-Jul-2005 (Brandon Turner) <turnerb7@msu.edu>)
  30  *        Add touch syntax.  "copy arp.exe+,,"
  31  *        Copy command is now completed.
  32  */
  33
  34 #include "precomp.h"
  35
  36 #ifdef INCLUDE_CMD_COPY
  37
  38 enum
  39 {
  40     COPY_ASCII       = 0x001,   /* /A  */
  41     COPY_DECRYPT     = 0x004,   /* /D  */
  42     COPY_VERIFY      = 0x008,   /* /V  : Dummy, Never will be Impleneted */
  43     COPY_SHORTNAME   = 0x010,   /* /N  : Dummy, Never will be Impleneted */
  44     COPY_NO_PROMPT   = 0x020,   /* /Y  */
  45     COPY_PROMPT      = 0x040,   /* /-Y */
  46     COPY_RESTART     = 0x080,   /* /Z  */
  47     COPY_BINARY      = 0x100,   /* /B  */
  48 };
  49
  50 INT
  51 copy(TCHAR source[MAX_PATH],
  52      TCHAR dest[MAX_PATH],
  53      INT append,
  54      DWORD lpdwFlags,
  55      BOOL bTouch)
  56 {
  57     FILETIME srctime,NewFileTime;
  58     HANDLE hFileSrc;
  59     HANDLE hFileDest;
  60     LPBYTE buffer;
  61     DWORD  dwAttrib;
  62     DWORD  dwRead;
  63     DWORD  dwWritten;
  64     BOOL   bEof = FALSE;
  65     TCHAR TrueDest[MAX_PATH];
  66     TCHAR TempSrc[MAX_PATH];
  67     TCHAR * FileName;
  68     SYSTEMTIME CurrentTime;
  69
  70     /* Check Breaker */
  71     if(CheckCtrlBreak(BREAK_INPUT))
  72         return 0;
  73
  74     TRACE ("checking mode\n");
  75
  76     if(bTouch)
  77     {
  78         hFileSrc = CreateFile (source, GENERIC_WRITE, FILE_SHARE_READ,
  79             NULL, OPEN_EXISTING, 0, NULL);
  80         if (hFileSrc == INVALID_HANDLE_VALUE)
  81         {
  82             ConOutResPrintf(STRING_COPY_ERROR1, source);
  83             nErrorLevel = 1;
  84             return 0;
  85         }
  86
  87         GetSystemTime(&CurrentTime);
  88         SystemTimeToFileTime(&CurrentTime, &NewFileTime);
  89         if(SetFileTime(hFileSrc,(LPFILETIME) NULL, (LPFILETIME) NULL, &NewFileTime))
  90         {
  91             CloseHandle(hFileSrc);
  92             nErrorLevel = 1;
  93             return 1;
  94
  95         }
  96         else
  97         {
  98             CloseHandle(hFileSrc);
  99             return 0;
 100         }
 101     }
 102
 103     dwAttrib = GetFileAttributes (source);
 104
 105     hFileSrc = CreateFile (source, GENERIC_READ, FILE_SHARE_READ,
 106         NULL, OPEN_EXISTING, 0, NULL);
 107     if (hFileSrc == INVALID_HANDLE_VALUE)
 108     {
 109         ConOutResPrintf(STRING_COPY_ERROR1, source);
 110         nErrorLevel = 1;
 111         return 0;
 112     }
 113
 114     TRACE ("getting time\n");
 115
 116     GetFileTime (hFileSrc, &srctime, NULL, NULL);
 117
 118     TRACE ("copy: flags has %s\n",
 119         lpdwFlags & COPY_ASCII ? "ASCII" : "BINARY");
 120
 121     /* Check to see if /D or /Z are true, if so we need a middle
 122        man to copy the file too to allow us to use CopyFileEx later */
 123     if(lpdwFlags & COPY_DECRYPT)
 124     {
 125         GetEnvironmentVariable(_T("TEMP"),TempSrc,MAX_PATH);
 126         _tcscat(TempSrc,_T("\\"));
 127         FileName = _tcsrchr(source,_T('\\'));
 128         FileName++;
 129         _tcscat(TempSrc,FileName);
 130         /* This is needed to be on the end to prevent an error
 131            if the user did "copy /D /Z foo bar then it would be copied
 132            too %TEMP%\foo here and when %TEMP%\foo when it sets it up
 133            for COPY_RESTART, this would mean it is copying to itself
 134            which would error when it tried to open the handles for ReadFile
 135            and WriteFile */
 136         _tcscat(TempSrc,_T(".decrypt"));
 137         if(!CopyFileEx(source, TempSrc, NULL, NULL, FALSE, COPY_FILE_ALLOW_DECRYPTED_DESTINATION))
 138         {
 139             nErrorLevel = 1;
 140             return 0;
 141         }
 142         _tcscpy(source, TempSrc);
 143     }
 144
 145
 146     if(lpdwFlags & COPY_RESTART)
 147     {
 148         _tcscpy(TrueDest, dest);
 149         GetEnvironmentVariable(_T("TEMP"),dest,MAX_PATH);
 150         _tcscat(dest,_T("\\"));
 151         FileName = _tcsrchr(TrueDest,_T('\\'));
 152         FileName++;
 153         _tcscat(dest,FileName);
 154     }
 155
 156
 157     if (!IsExistingFile (dest))
 158     {
 159         TRACE ("opening/creating\n");
 160         hFileDest =
 161             CreateFile (dest, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
 162     }
 163     else if (!append)
 164     {
 165         TRACE ("SetFileAttributes (%s, FILE_ATTRIBUTE_NORMAL);\n", debugstr_aw(dest));
 166         SetFileAttributes (dest, FILE_ATTRIBUTE_NORMAL);
 167
 168         TRACE ("DeleteFile (%s);\n", debugstr_aw(dest));
 169         DeleteFile (dest);
 170
 171         hFileDest =     CreateFile (dest, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
 172     }
 173     else
 174     {
 175         LONG lFilePosHigh = 0;
 176
 177         if (!_tcscmp (dest, source))
 178         {
 179             CloseHandle (hFileSrc);
 180             return 0;
 181         }
 182
 183         TRACE ("opening/appending\n");
 184         SetFileAttributes (dest, FILE_ATTRIBUTE_NORMAL);
 185
 186         hFileDest =
 187             CreateFile (dest, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
 188
 189         /* Move to end of file to start writing */
 190         SetFilePointer (hFileDest, 0, &lFilePosHigh,FILE_END);
 191     }
 192
 193
 194     if (hFileDest == INVALID_HANDLE_VALUE)
 195     {
 196         CloseHandle (hFileSrc);
 197         ConOutResPuts(STRING_ERROR_PATH_NOT_FOUND);
 198         nErrorLevel = 1;
 199         return 0;
 200     }
 201
 202     /* A page-aligned buffer usually give more speed */
 203     buffer = (LPBYTE)VirtualAlloc(NULL, BUFF_SIZE, MEM_COMMIT, PAGE_READWRITE);
 204     if (buffer == NULL)
 205     {
 206         CloseHandle (hFileDest);
 207         CloseHandle (hFileSrc);
 208         ConOutResPuts(STRING_ERROR_OUT_OF_MEMORY);
 209         nErrorLevel = 1;
 210         return 0;
 211     }
 212
 213     do
 214     {
 215         ReadFile (hFileSrc, buffer, BUFF_SIZE, &dwRead, NULL);
 216         if (lpdwFlags & COPY_ASCII)
 217         {
 218             LPBYTE pEof = memchr(buffer, 0x1A, dwRead);
 219             if (pEof != NULL)
 220             {
 221                 bEof = TRUE;
 222                 dwRead = pEof-buffer+1;
 223                 break;
 224             }
 225         }
 226
 227         if (dwRead == 0)
 228             break;
 229
 230         WriteFile (hFileDest, buffer, dwRead, &dwWritten, NULL);
 231         if (dwWritten != dwRead || CheckCtrlBreak(BREAK_INPUT))
 232         {
 233             ConOutResPuts(STRING_COPY_ERROR3);
 234
 235             VirtualFree (buffer, 0, MEM_RELEASE);
 236             CloseHandle (hFileDest);
 237             CloseHandle (hFileSrc);
 238             nErrorLevel = 1;
 239             return 0;
 240         }
 241     }
 242     while (!bEof);
 243
 244     TRACE ("setting time\n");
 245     SetFileTime (hFileDest, &srctime, NULL, NULL);
 246
 247     if ((lpdwFlags & COPY_ASCII) && !bEof)
 248     {
 249         /* we're dealing with ASCII files! */
 250         buffer[0] = 0x1A;
 251         TRACE ("appending ^Z\n");
 252         WriteFile (hFileDest, buffer, sizeof(CHAR), &dwWritten, NULL);
 253     }
 254
 255     VirtualFree (buffer, 0, MEM_RELEASE);
 256     CloseHandle (hFileDest);
 257     CloseHandle (hFileSrc);
 258
 259     TRACE ("setting mode\n");
 260     SetFileAttributes (dest, dwAttrib);
 261
 262     /* Now finish off the copy if needed with CopyFileEx */
 263     if(lpdwFlags & COPY_RESTART)
 264     {
 265         if(!CopyFileEx(dest, TrueDest, NULL, NULL, FALSE, COPY_FILE_RESTARTABLE))
 266         {
 267             nErrorLevel = 1;
 268             DeleteFile(dest);
 269             return 0;
 270         }
 271         /* Take care of file in the temp folder */
 272         DeleteFile(dest);
 273
 274     }
 275
 276     if(lpdwFlags & COPY_DECRYPT)
 277         DeleteFile(TempSrc);
 278
 279     return 1;
 280 }
 281
 282
 283 static INT CopyOverwrite (LPTSTR fn)
 284 {
 285     /*ask the user if they want to override*/
 286     INT res;
 287     ConOutResPrintf(STRING_COPY_HELP1, fn);
 288     res = FilePromptYNA (0);
 289     return res;
 290 }
 291
 292 /* The following lines of copy were written by someone else
 293 (most likely Eric Kohl) and it was taken from ren.c */
 294 static void
 295 BuildFileName(
 296     LPTSTR pszSource,
 297     LPTSTR pszTarget,
 298     LPTSTR pszOutput)
 299 {
 300     /* build destination file name */
 301     while (*pszTarget != 0)
 302     {
 303         if (*pszTarget == _T('*'))
 304         {
 305             pszTarget++;
 306             while ((*pszSource != 0) && (*pszSource != *pszTarget))
 307             {
 308                 *pszOutput++ = *pszSource++;
 309             }
 310         }
 311         else if (*pszTarget == _T('?'))
 312         {
 313             pszTarget++;
 314             if (*pszSource != 0)
 315             {
 316                 *pszOutput++ = *pszSource++;
 317             }
 318         }
 319         else
 320         {
 321             *pszOutput++ = *pszTarget++;
 322             if (*pszSource != 0)
 323                 pszSource++;
 324         }
 325     }
 326
 327     *pszOutput = 0;
 328 }
 329
 330 INT cmd_copy(LPTSTR param)
 331 {
 332     LPTSTR *arg;
 333     INT argc, i, nFiles, nOverwrite = 0, nSrc = -1, nDes = -1;
 334     /* this is the path up to the folder of the src and dest ie C:\windows\ */
 335     TCHAR szDestPath[MAX_PATH];
 336     TCHAR szSrcPath[MAX_PATH];
 337     DWORD dwFlags = 0;
 338     /* If this is the type of copy where we are adding files */
 339     BOOL bAppend = FALSE;
 340     WIN32_FIND_DATA findBuffer;
 341     HANDLE hFile = NULL;
 342     BOOL bTouch = FALSE;
 343     /* Used when something like "copy c*.exe d*.exe" during the process of
 344        figuring out the new name */
 345     /* Pointer to keep track of how far through the append input(file1+file2+file3) we are */
 346     TCHAR  * appendPointer = _T("\0");
 347     /* The full path to src and dest.  This has drive letter, folders, and filename */
 348     TCHAR tmpDestPath[MAX_PATH];
 349     TCHAR tmpSrcPath[MAX_PATH];
 350     /* A bool on weather or not the destination name will be taking from the input */
 351     BOOL bSrcName = FALSE;
 352     /* Seems like a waste but it is a pointer used to copy from input to PreserveName */
 353     TCHAR * UseThisName;
 354     /* for CMDCOPY env */
 355     TCHAR *evar;
 356     int size;
 357     TCHAR * szTouch;
 358     BOOL bHasWildcard, bDone = FALSE, bMoreFiles = FALSE;
 359     BOOL bMultipleSource = FALSE, bMultipleDest = FALSE;
 360
 361
 362     /* Show help/usage info */
 363     if (!_tcsncmp(param, _T("/?"), 2))
 364     {
 365         ConOutResPaging(TRUE, STRING_COPY_HELP2);
 366         return 0;
 367     }
 368
 369     nErrorLevel = 0;
 370
 371     /* Get the envor value if it exists */
 372     evar = cmd_alloc(512 * sizeof(TCHAR));
 373     if (evar == NULL)
 374         size = 0;
 375     else
 376         size = GetEnvironmentVariable (_T("COPYCMD"), evar, 512);
 377
 378     if (size > 512)
 379     {
 380         evar = cmd_realloc(evar,size * sizeof(TCHAR) );
 381         if (evar!=NULL)
 382             size = GetEnvironmentVariable (_T("COPYCMD"), evar, size);
 383         else
 384             size=0;
 385     }
 386
 387     /* check see if we did get any env variable */
 388     if (size != 0)
 389     {
 390         int t = 0;
 391
 392         /* scan and set the flags */
 393         for (t = 0; t < size; t++)
 394         {
 395             if (_tcsncicmp(_T("/A"),&evar[t],2) == 0)
 396             {
 397                 dwFlags |=COPY_ASCII;
 398                 t++;
 399             }
 400             else if (_tcsncicmp(_T("/B"),&evar[t],2) == 0)
 401             {
 402                 dwFlags |= COPY_BINARY;
 403                 t++;
 404             }
 405             else if (_tcsncicmp(_T("/D"),&evar[t],2) == 0)
 406             {
 407                 dwFlags |= COPY_DECRYPT;
 408                 t++;
 409             }
 410             else if (_tcsncicmp(_T("/V"),&evar[t],2) == 0)
 411             {
 412                 dwFlags |= COPY_VERIFY;
 413                 t++;
 414             }
 415             else if (_tcsncicmp(_T("/N"),&evar[t],2) == 0)
 416             {
 417                 dwFlags |= COPY_SHORTNAME;
 418                 t++;
 419             }
 420             else if (_tcsncicmp(_T("/Y"),&evar[t],2) == 0)
 421             {
 422                 dwFlags |= COPY_NO_PROMPT;
 423                 t++;
 424             }
 425             else if (_tcsncicmp(_T("/-Y"),&evar[t],3) == 0)
 426             {
 427                 dwFlags |= COPY_PROMPT;
 428                 t+=2;
 429             }
 430             else if (_tcsncicmp(_T("/Z"),&evar[t],2) == 0)
 431             {
 432                 dwFlags |= COPY_PROMPT;
 433                 t++;
 434             }
 435         }
 436     }
 437     cmd_free(evar);
 438
 439
 440     /* Split the user input into array */
 441     arg = split(param, &argc, FALSE, TRUE);
 442     nFiles = argc;
 443
 444     /* Read switches and count files */
 445     for (i = 0; i < argc; i++)
 446     {
 447         if (*arg[i] == _T('/'))
 448         {
 449             if (_tcslen(arg[i]) >= 2)
 450             {
 451                 switch (_totupper(arg[i][1]))
 452                 {
 453                     case _T('A'):
 454                         dwFlags |= COPY_ASCII;
 455                         break;
 456
 457                     case _T('B'):
 458                         dwFlags |= COPY_BINARY;
 459                         break;
 460
 461                     case _T('D'):
 462                         dwFlags |= COPY_DECRYPT;
 463                         break;
 464
 465                     case _T('V'):
 466                         dwFlags |= COPY_VERIFY;
 467                         break;
 468
 469                     case _T('N'):
 470                         dwFlags |= COPY_SHORTNAME;
 471                         break;
 472
 473                     case _T('Y'):
 474                         dwFlags |= COPY_NO_PROMPT;
 475                         dwFlags &= ~COPY_PROMPT;
 476                         break;
 477
 478                     case _T('-'):
 479                         if(_tcslen(arg[i]) >= 3)
 480                             if(_totupper(arg[i][2]) == _T('Y'))
 481                             {
 482                                 dwFlags &= ~COPY_NO_PROMPT;
 483                                 dwFlags |= COPY_PROMPT;
 484                             }
 485
 486                             break;
 487
 488                     case _T('Z'):
 489                         dwFlags |= COPY_RESTART;
 490                         break;
 491
 492                     default:
 493                         /* Invalid switch */
 494                         ConOutResPrintf(STRING_ERROR_INVALID_SWITCH, _totupper(arg[i][1]));
 495                         nErrorLevel = 1;
 496                         freep (arg);
 497                         return 1;
 498                         break;
 499                 }
 500             }
 501             /* If it was a switch, subtract from total arguments */
 502             nFiles--;
 503         }
 504         else
 505         {
 506             /* If it isn't a switch then it is the source or destination */
 507             if (nSrc == -1)
 508             {
 509                 nSrc = i;
 510             }
 511             else if (*arg[i] == _T('+'))
 512             {
 513                 /* Next file should be appended */
 514                 bMoreFiles = TRUE;
 515                 nFiles -= 1;
 516             }
 517             else if (bMoreFiles)
 518             {
 519                 /* Add this file to the source string
 520                    this way we can do all checks
 521                     directly on source string later on */
 522                 TCHAR * ptr;
 523                 int length = (_tcslen(arg[nSrc]) + _tcslen(arg[i]) + 2) * sizeof(TCHAR);
 524                 ptr = cmd_alloc(length);
 525                 if (ptr)
 526                 {
 527                     _tcscpy(ptr, arg[nSrc]);
 528                     _tcscat(ptr, _T("|"));
 529                     _tcscat(ptr, arg[i]);
 530                     cmd_free(arg[nSrc]);
 531                     arg[nSrc] = ptr;
 532                     nFiles -= 1;
 533                 }
 534
 535                 bMoreFiles = FALSE;
 536             }
 537             else if(nDes == -1)
 538             {
 539                 nDes = i;
 540             }
 541         }
 542     }
 543
 544     /* keep quiet within batch files */
 545     if (bc != NULL)
 546     {
 547         dwFlags |= COPY_NO_PROMPT;
 548         dwFlags &= ~COPY_PROMPT;
 549     }
 550
 551     if (nFiles < 1)
 552     {
 553         /* There are not enough files, there has to be at least 1 */
 554         ConOutResPuts(STRING_ERROR_REQ_PARAM_MISSING);
 555         freep(arg);
 556         return 1;
 557     }
 558
 559     if (nFiles > 2)
 560     {
 561         /* There are too many file names in command */
 562         ConErrResPrintf(STRING_ERROR_TOO_MANY_PARAMETERS,_T(""));
 563         nErrorLevel = 1;
 564         freep(arg);
 565         return 1;
 566     }
 567
 568     if ((_tcschr(arg[nSrc], _T('|')) != NULL) ||
 569         (_tcschr(arg[nSrc], _T('*')) != NULL) ||
 570         (_tcschr(arg[nSrc], _T('?')) != NULL) ||
 571         IsExistingDirectory(arg[nSrc]))
 572     {
 573         bMultipleSource = TRUE;
 574     }
 575
 576     /* Reusing the number of files variable */
 577     nFiles = 0;
 578
 579     /* Check if no destination argument is passed */
 580     if (nDes == -1)
 581     {
 582         /* If no destination was entered then just use
 583         the current directory as the destination */
 584         GetCurrentDirectory(MAX_PATH, szDestPath);
 585     }
 586     else
 587     {
 588         /* Check if the destination is 'x:' */
 589         if ((arg[nDes][1] == _T(':')) && (arg[nDes][2] == _T('\0')))
 590         {
 591             GetRootPath(arg[nDes], szDestPath, MAX_PATH);
 592         }
 593         else
 594         {
 595             /* If the user entered two file names then form the full string path */
 596             GetFullPathName(arg[nDes], MAX_PATH, szDestPath, NULL);
 597         }
 598
 599         /* Make sure there is an ending slash to the path if the dest is a folder */
 600         if ((_tcschr(szDestPath, _T('*')) == NULL) &&
 601             IsExistingDirectory(szDestPath))
 602         {
 603             bMultipleDest = TRUE;
 604             if (szDestPath[_tcslen(szDestPath) -  1] != _T('\\'))
 605                 _tcscat(szDestPath, _T("\\"));
 606         }
 607
 608         /* Check if the destination uses wildcards */
 609         if ((_tcschr(arg[nDes], _T('*')) != NULL) ||
 610             (_tcschr(arg[nDes], _T('?')) != NULL))
 611         {
 612             bMultipleDest = TRUE;
 613         }
 614     }
 615
 616     if (nDes != -1) /* you can only append files when there is a destination */
 617     {
 618         if (bMultipleSource && !bMultipleDest)
 619         {
 620             /* We have multiple source files, but not multiple destination
 621                files. This means we are appending the soruce files. */
 622             bAppend = TRUE;
 623             if (_tcschr(arg[nSrc], _T('|')) != NULL)
 624                 appendPointer = arg[nSrc];
 625         }
 626     }
 627
 628     /* Save the name the user entered */
 629     UseThisName = _tcsrchr(szDestPath,_T('\\'));
 630     if (UseThisName)
 631     {
 632         /* Split the name from the path */
 633         *UseThisName++ = _T('\0');
 634
 635         /* Check if the dest path ends with '\*' or '\' */
 636         if (((UseThisName[0] == _T('*')) && (UseThisName[1] == _T('\0'))) ||
 637             (UseThisName[0] == _T('\0')))
 638         {
 639             /* In this case we will be using the same name as the source file
 640             for the destination file because destination is a folder */
 641             bSrcName = TRUE;
 642             UseThisName = NULL;
 643         }
 644     }
 645     else
 646     {
 647         /* Something's seriously wrong! */
 648         UseThisName = szDestPath;
 649     }
 650
 651     do
 652     {
 653         /* Get the full string of the path to the source file */
 654         if (_tcschr(arg[nSrc], _T('|')) != NULL)
 655         {
 656             /* Reset the source path */
 657             szSrcPath[0] = _T('\0');
 658
 659             /* Loop through the source file name and copy all
 660             the chars one at a time until it gets too + */
 661             while(TRUE)
 662             {
 663                 if (appendPointer[0] == _T('|'))
 664                 {
 665                     /* Skip the | and go to the next file name */
 666                     appendPointer++;
 667                     break;
 668                 }
 669                 else if (appendPointer[0] == _T('\0'))
 670                 {
 671                     bDone = TRUE;
 672                     break;
 673                 }
 674
 675                 _tcsncat(szSrcPath, appendPointer, 1);
 676                 appendPointer++;
 677             }
 678
 679             if (_tcschr(arg[nSrc], _T(',')) != NULL)
 680             {
 681                 /* Only time there is a , in the source is when they are using touch
 682                    Cant have a destination and can only have on ,, at the end of the string
 683                     Cant have more then one file name */
 684                 szTouch = _tcsstr(arg[nSrc], _T("|"));
 685                 if (_tcsncmp(szTouch,_T("|,,\0"), 4) || (nDes != -1))
 686                 {
 687                     ConErrResPrintf(STRING_ERROR_INVALID_PARAM_FORMAT,arg[nSrc]);
 688                     nErrorLevel = 1;
 689                     freep (arg);
 690                     return 1;
 691                 }
 692                 bTouch = TRUE;
 693                 bDone = TRUE;
 694             }
 695         }
 696         else
 697         {
 698             bDone = TRUE;
 699             _tcscpy(szSrcPath, arg[nSrc]);
 700         }
 701
 702         /* "x:" is not a valid source path format. */
 703         if ((szSrcPath[1] == _T(':')) && (szSrcPath[2] == _T('\0')))
 704         {
 705             ConOutPrintf(_T("%s\n"), szSrcPath);
 706             ConOutFormatMessage(ERROR_FILE_NOT_FOUND, szSrcPath);
 707             nErrorLevel = 1;
 708             break;
 709         }
 710
 711
 712         /* From this point on, we can assume that the shortest path is 3 letters long
 713         and that would be [DriveLetter]:\ */
 714
 715         /* Check if the path has a wildcard */
 716         bHasWildcard = (_tcschr(szSrcPath, _T('*')) != NULL);
 717
 718         /* If there is no * in the path name and it is a folder then we will
 719            need to add a wildcard to the pathname so FindFirstFile comes up
 720            with all the files in that folder */
 721         if (!bHasWildcard && IsExistingDirectory(szSrcPath))
 722         {
 723             /* If it doesnt have a \ at the end already then on needs to be added */
 724             if (szSrcPath[_tcslen(szSrcPath) -  1] != _T('\\'))
 725                 _tcscat(szSrcPath, _T("\\"));
 726             _tcscat(szSrcPath, _T("*"));
 727             bHasWildcard = TRUE;
 728         }
 729
 730         /* If the path ends with '\' add a wildcard at the end */
 731         if (szSrcPath[_tcslen(szSrcPath) -  1] == _T('\\'))
 732         {
 733             _tcscat(szSrcPath, _T("*"));
 734             bHasWildcard = TRUE;
 735         }
 736
 737         /* Get a list of all the files */
 738         hFile = FindFirstFile(szSrcPath, &findBuffer);
 739
 740         /* If it couldnt open the file handle, print out the error */
 741         if (hFile == INVALID_HANDLE_VALUE)
 742         {
 743             /* only print source name when more then one file */
 744             if (bMultipleSource)
 745                 ConOutPrintf(_T("%s\n"), szSrcPath);
 746
 747             ConOutFormatMessage(GetLastError(), szSrcPath);
 748             freep(arg);
 749             nErrorLevel = 1;
 750             return 1;
 751         }
 752
 753         /* Strip the paths back to the folder they are in */
 754         for (i = (_tcslen(szSrcPath) -  1); i > -1; i--)
 755             if (szSrcPath[i] != _T('\\'))
 756                 szSrcPath[i] = _T('\0');
 757             else
 758                 break;
 759
 760         do
 761         {
 762             /* Check Breaker */
 763             if (CheckCtrlBreak(BREAK_INPUT))
 764             {
 765                 freep(arg);
 766                 return 1;
 767             }
 768
 769             /* Set the override to yes each new file */
 770             nOverwrite = 1;
 771
 772             /* Ignore the . and .. files */
 773             if (!_tcscmp(findBuffer.cFileName, _T("."))  ||
 774                 !_tcscmp(findBuffer.cFileName, _T("..")) ||
 775                 findBuffer.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 776             {
 777                 continue;
 778             }
 779
 780             /* Copy the base folder over to a tmp string */
 781             _tcscpy(tmpDestPath, szDestPath);
 782             _tcscat(tmpDestPath, _T("\\"));
 783
 784             /* Can't put a file into a folder that isnt there */
 785             if (_tcscmp(tmpDestPath, _T("\\\\.\\")) &&
 786                 !IsExistingDirectory(tmpDestPath))
 787             {
 788                 ConOutFormatMessage(GetLastError(), szSrcPath);
 789                 freep(arg);
 790                 nErrorLevel = 1;
 791                 return 1;
 792             }
 793
 794             /* Copy over the destination path name */
 795             if (bSrcName)
 796                 _tcscat(tmpDestPath, findBuffer.cFileName);
 797             else
 798             {
 799                 /* If there is no wildcard you can use the name the user entered */
 800                 if ((_tcschr(UseThisName, _T('*')) == NULL) &&
 801                     (_tcschr(UseThisName, _T('?')) == NULL))
 802                 {
 803                     _tcscat(tmpDestPath, UseThisName);
 804                 }
 805                 else
 806                 {
 807                     TCHAR DoneFile[MAX_PATH];
 808
 809                     BuildFileName(findBuffer.cFileName,
 810                                   UseThisName,
 811                                   DoneFile);
 812
 813
 814                     /* Add the filename to the tmp string path */
 815                     _tcscat(tmpDestPath, DoneFile);
 816                 }
 817             }
 818
 819             /* Build the string path to the source file */
 820             _tcscpy(tmpSrcPath,szSrcPath);
 821             _tcscat (tmpSrcPath, findBuffer.cFileName);
 822
 823             /* Check to see if the file is the same file */
 824             if(!bTouch && !_tcscmp(tmpSrcPath, tmpDestPath))
 825             {
 826                 ConOutResPrintf(STRING_COPY_ERROR2);
 827
 828                 nErrorLevel = 1;
 829                 break;
 830             }
 831
 832             /* only print source name when more then one file */
 833             if (bMultipleSource)
 834                 ConOutPrintf(_T("%s\n"), tmpSrcPath);
 835
 836             /* Handle any overriding / prompting that needs to be done */
 837             if (((!(dwFlags & COPY_NO_PROMPT) && IsExistingFile (tmpDestPath)) || dwFlags & COPY_PROMPT) && !bTouch)
 838                 nOverwrite = CopyOverwrite(tmpDestPath);
 839             if (nOverwrite == PROMPT_NO || nOverwrite == PROMPT_BREAK)
 840                 continue;
 841             if (nOverwrite == PROMPT_ALL || (nOverwrite == PROMPT_YES && bAppend))
 842                 dwFlags |= COPY_NO_PROMPT;
 843
 844             /* Tell weather the copy was successful or not */
 845             if(copy(tmpSrcPath,tmpDestPath, bAppend, dwFlags, bTouch))
 846             {
 847                 nFiles++;
 848                 //LoadString(CMD_ModuleHandle, STRING_MOVE_ERROR1, szMsg, RC_STRING_MAX_SIZE);
 849             }
 850             else
 851             {
 852                 /* print out the error message */
 853                 ConOutResPrintf(STRING_COPY_ERROR3);
 854                 ConOutFormatMessage (GetLastError(), szSrcPath);
 855                 nErrorLevel = 1;
 856             }
 857
 858         /* Loop through all wildcard files */
 859         } while (FindNextFile(hFile, &findBuffer));
 860
 861     /* Loop through all files in src string with a + */
 862     } while(!bDone);
 863
 864     /* print out the number of files copied */
 865     ConOutResPrintf(STRING_COPY_FILE, bAppend ? 1 : nFiles);
 866
 867     if (hFile) FindClose(hFile);
 868
 869     if (arg != NULL)
 870         freep(arg);
 871
 872     return 0;
 873 }
 874
 875 #endif /* INCLUDE_CMD_COPY */