git.oblomov.eu Git - wine/blob - programs/xcopy/xcopy.c

   1 /*
   2  * XCOPY - Wine-compatible xcopy program
   3  *
   4  * Copyright (C) 2007 J. Edmeades
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 /*
  22  * FIXME:
  23  * This should now support all options listed in the xcopy help from
  24  * windows XP except:
  25  *  /Z - Copy from network drives in restartable mode
  26  *  /X - Copy file audit settings (sets /O)
  27  *  /O - Copy file ownership + ACL info
  28  *  /G - Copy encrypted files to unencrypted destination
  29  *  /V - Verifies files
  30  */
  31
  32 /*
  33  * Notes:
  34  * Apparently, valid return codes are:
  35  *   0 - OK
  36  *   1 - No files found to copy
  37  *   2 - CTRL+C during copy
  38  *   4 - Initialization error, or invalid source specification
  39  *   5 - Disk write error
  40  */
  41
  42
  43 #include <stdio.h>
  44 #include <windows.h>
  45 #include <wine/debug.h>
  46 #include <wine/unicode.h>
  47 #include "xcopy.h"
  48
  49 WINE_DEFAULT_DEBUG_CHANNEL(xcopy);
  50
  51
  52 /* Typedefs */
  53 typedef struct _EXCLUDELIST
  54 {
  55   struct _EXCLUDELIST *next;
  56   WCHAR               *name;
  57 } EXCLUDELIST;
  58
  59
  60 /* Global variables */
  61 static ULONG filesCopied           = 0;              /* Number of files copied  */
  62 static EXCLUDELIST *excludeList    = NULL;           /* Excluded strings list   */
  63 static FILETIME dateRange;                           /* Date range to copy after*/
  64 static const WCHAR wchr_slash[]   = {'\\', 0};
  65 static const WCHAR wchr_star[]    = {'*', 0};
  66 static const WCHAR wchr_dot[]     = {'.', 0};
  67 static const WCHAR wchr_dotdot[]  = {'.', '.', 0};
  68
  69
  70 /* To minimize stack usage during recursion, some temporary variables
  71    made global                                                        */
  72 static WCHAR copyFrom[MAX_PATH];
  73 static WCHAR copyTo[MAX_PATH];
  74
  75
  76 /* =========================================================================
  77  * Load a string from the resource file, handling any error
  78  * Returns string retrieved from resource file
  79  * ========================================================================= */
  80 static WCHAR *XCOPY_LoadMessage(UINT id) {
  81     static WCHAR msg[MAXSTRING];
  82     const WCHAR failedMsg[]  = {'F', 'a', 'i', 'l', 'e', 'd', '!', 0};
  83
  84     if (!LoadStringW(GetModuleHandleW(NULL), id, msg, sizeof(msg)/sizeof(WCHAR))) {
  85        WINE_FIXME("LoadString failed with %d\n", GetLastError());
  86        lstrcpyW(msg, failedMsg);
  87     }
  88     return msg;
  89 }
  90
  91 /* =========================================================================
  92  * Output a formatted unicode string. Ideally this will go to the console
  93  *  and hence required WriteConsoleW to output it, however if file i/o is
  94  *  redirected, it needs to be WriteFile'd using OEM (not ANSI) format
  95  * ========================================================================= */
  96 static int __cdecl XCOPY_wprintf(const WCHAR *format, ...) {
  97
  98     static WCHAR *output_bufW = NULL;
  99     static char  *output_bufA = NULL;
 100     static BOOL  toConsole    = TRUE;
 101     static BOOL  traceOutput  = FALSE;
 102 #define MAX_WRITECONSOLE_SIZE 65535
 103
 104     __ms_va_list parms;
 105     DWORD   nOut;
 106     int len;
 107     DWORD   res = 0;
 108
 109     /*
 110      * Allocate buffer to use when writing to console
 111      * Note: Not freed - memory will be allocated once and released when
 112      *         xcopy ends
 113      */
 114
 115     if (!output_bufW) output_bufW = HeapAlloc(GetProcessHeap(), 0,
 116                                               MAX_WRITECONSOLE_SIZE);
 117     if (!output_bufW) {
 118       WINE_FIXME("Out of memory - could not allocate 2 x 64K buffers\n");
 119       return 0;
 120     }
 121
 122     __ms_va_start(parms, format);
 123     SetLastError(NO_ERROR);
 124     len = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, format, 0, 0, output_bufW,
 125                    MAX_WRITECONSOLE_SIZE/sizeof(*output_bufW), &parms);
 126     __ms_va_end(parms);
 127     if (len == 0 && GetLastError() != NO_ERROR) {
 128       WINE_FIXME("Could not format string: le=%u, fmt=%s\n", GetLastError(), wine_dbgstr_w(format));
 129       return 0;
 130     }
 131
 132     /* Try to write as unicode whenever we think it's a console */
 133     if (toConsole) {
 134       res = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE),
 135                           output_bufW, len, &nOut, NULL);
 136     }
 137
 138     /* If writing to console has failed (ever) we assume it's file
 139        i/o so convert to OEM codepage and output                  */
 140     if (!res) {
 141       BOOL usedDefaultChar = FALSE;
 142       DWORD convertedChars;
 143
 144       toConsole = FALSE;
 145
 146       /*
 147        * Allocate buffer to use when writing to file. Not freed, as above
 148        */
 149       if (!output_bufA) output_bufA = HeapAlloc(GetProcessHeap(), 0,
 150                                                 MAX_WRITECONSOLE_SIZE);
 151       if (!output_bufA) {
 152         WINE_FIXME("Out of memory - could not allocate 2 x 64K buffers\n");
 153         return 0;
 154       }
 155
 156       /* Convert to OEM, then output */
 157       convertedChars = WideCharToMultiByte(GetConsoleOutputCP(), 0, output_bufW,
 158                           len, output_bufA, MAX_WRITECONSOLE_SIZE,
 159                           "?", &usedDefaultChar);
 160       WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), output_bufA, convertedChars,
 161                 &nOut, FALSE);
 162     }
 163
 164     /* Trace whether screen or console */
 165     if (!traceOutput) {
 166       WINE_TRACE("Writing to console? (%d)\n", toConsole);
 167       traceOutput = TRUE;
 168     }
 169     return nOut;
 170 }
 171
 172 /* =========================================================================
 173  * Load a string for a system error and writes it to the screen
 174  * Returns string retrieved from resource file
 175  * ========================================================================= */
 176 static void XCOPY_FailMessage(DWORD err) {
 177     LPWSTR lpMsgBuf;
 178     int status;
 179
 180     status = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
 181                             FORMAT_MESSAGE_FROM_SYSTEM,
 182                             NULL, err, 0,
 183                             (LPWSTR) &lpMsgBuf, 0, NULL);
 184     if (!status) {
 185       WINE_FIXME("FIXME: Cannot display message for error %d, status %d\n",
 186                  err, GetLastError());
 187     } else {
 188       const WCHAR infostr[] = {'%', '1', '\n', 0};
 189       XCOPY_wprintf(infostr, lpMsgBuf);
 190       LocalFree ((HLOCAL)lpMsgBuf);
 191     }
 192 }
 193
 194
 195 /* =========================================================================
 196  * Routine copied from cmd.exe md command -
 197  * This works recursively. so creating dir1\dir2\dir3 will create dir1 and
 198  * dir2 if they do not already exist.
 199  * ========================================================================= */
 200 static BOOL XCOPY_CreateDirectory(const WCHAR* path)
 201 {
 202     int len;
 203     WCHAR *new_path;
 204     BOOL ret = TRUE;
 205
 206     new_path = HeapAlloc(GetProcessHeap(),0, sizeof(WCHAR) * (lstrlenW(path)+1));
 207     lstrcpyW(new_path,path);
 208
 209     while ((len = lstrlenW(new_path)) && new_path[len - 1] == '\\')
 210         new_path[len - 1] = 0;
 211
 212     while (!CreateDirectoryW(new_path,NULL))
 213     {
 214         WCHAR *slash;
 215         DWORD last_error = GetLastError();
 216         if (last_error == ERROR_ALREADY_EXISTS)
 217             break;
 218
 219         if (last_error != ERROR_PATH_NOT_FOUND)
 220         {
 221             ret = FALSE;
 222             break;
 223         }
 224
 225         if (!(slash = wcsrchr(new_path,'\\')) && ! (slash = wcsrchr(new_path,'/')))
 226         {
 227             ret = FALSE;
 228             break;
 229         }
 230
 231         len = slash - new_path;
 232         new_path[len] = 0;
 233         if (!XCOPY_CreateDirectory(new_path))
 234         {
 235             ret = FALSE;
 236             break;
 237         }
 238         new_path[len] = '\\';
 239     }
 240     HeapFree(GetProcessHeap(),0,new_path);
 241     return ret;
 242 }
 243
 244 /* =========================================================================
 245  * Process a single file from the /EXCLUDE: file list, building up a list
 246  * of substrings to avoid copying
 247  * Returns TRUE on any failure
 248  * ========================================================================= */
 249 static BOOL XCOPY_ProcessExcludeFile(WCHAR* filename, WCHAR* endOfName) {
 250
 251     WCHAR   endChar = *endOfName;
 252     WCHAR   buffer[MAXSTRING];
 253     FILE   *inFile  = NULL;
 254     const WCHAR readTextMode[]  = {'r', 't', 0};
 255
 256     /* Null terminate the filename (temporarily updates the filename hence
 257          parms not const)                                                 */
 258     *endOfName = 0x00;
 259
 260     /* Open the file */
 261     inFile = _wfopen(filename, readTextMode);
 262     if (inFile == NULL) {
 263         XCOPY_wprintf(XCOPY_LoadMessage(STRING_OPENFAIL), filename);
 264         *endOfName = endChar;
 265         return TRUE;
 266     }
 267
 268     /* Process line by line */
 269     while (fgetws(buffer, sizeof(buffer)/sizeof(WCHAR), inFile) != NULL) {
 270         EXCLUDELIST *thisEntry;
 271         int length = lstrlenW(buffer);
 272
 273         /* Strip CRLF */
 274         buffer[length-1] = 0x00;
 275
 276         /* If more than CRLF */
 277         if (length > 1) {
 278           thisEntry = HeapAlloc(GetProcessHeap(), 0, sizeof(EXCLUDELIST));
 279           thisEntry->next = excludeList;
 280           excludeList = thisEntry;
 281           thisEntry->name = HeapAlloc(GetProcessHeap(), 0,
 282                                       (length * sizeof(WCHAR))+1);
 283           lstrcpyW(thisEntry->name, buffer);
 284           CharUpperBuffW(thisEntry->name, length);
 285           WINE_TRACE("Read line : '%s'\n", wine_dbgstr_w(thisEntry->name));
 286         }
 287     }
 288
 289     /* See if EOF or error occurred */
 290     if (!feof(inFile)) {
 291         XCOPY_wprintf(XCOPY_LoadMessage(STRING_READFAIL), filename);
 292         *endOfName = endChar;
 293         return TRUE;
 294     }
 295
 296     /* Revert the input string to original form, and cleanup + return */
 297     *endOfName = endChar;
 298     fclose(inFile);
 299     return FALSE;
 300 }
 301
 302 /* =========================================================================
 303  * Process the /EXCLUDE: file list, building up a list of substrings to
 304  * avoid copying
 305  * Returns TRUE on any failure
 306  * ========================================================================= */
 307 static BOOL XCOPY_ProcessExcludeList(WCHAR* parms) {
 308
 309     WCHAR *filenameStart = parms;
 310
 311     WINE_TRACE("/EXCLUDE parms: '%s'\n", wine_dbgstr_w(parms));
 312     excludeList = NULL;
 313
 314     while (*parms && *parms != ' ' && *parms != '/') {
 315
 316         /* If found '+' then process the file found so far */
 317         if (*parms == '+') {
 318             if (XCOPY_ProcessExcludeFile(filenameStart, parms)) {
 319                 return TRUE;
 320             }
 321             filenameStart = parms+1;
 322         }
 323         parms++;
 324     }
 325
 326     if (filenameStart != parms) {
 327         if (XCOPY_ProcessExcludeFile(filenameStart, parms)) {
 328             return TRUE;
 329         }
 330     }
 331
 332     return FALSE;
 333 }
 334
 335 /* =========================================================================
 336    XCOPY_DoCopy - Recursive function to copy files based on input parms
 337      of a stem and a spec
 338
 339       This works by using FindFirstFile supplying the source stem and spec.
 340       If results are found, any non-directory ones are processed
 341       Then, if /S or /E is supplied, another search is made just for
 342       directories, and this function is called again for that directory
 343
 344    ========================================================================= */
 345 static int XCOPY_DoCopy(WCHAR *srcstem, WCHAR *srcspec,
 346                         WCHAR *deststem, WCHAR *destspec,
 347                         DWORD flags)
 348 {
 349     WIN32_FIND_DATAW *finddata;
 350     HANDLE          h;
 351     BOOL            findres = TRUE;
 352     WCHAR           *inputpath, *outputpath;
 353     BOOL            copiedFile = FALSE;
 354     DWORD           destAttribs, srcAttribs;
 355     BOOL            skipFile;
 356     int             ret = 0;
 357
 358     /* Allocate some working memory on heap to minimize footprint */
 359     finddata = HeapAlloc(GetProcessHeap(), 0, sizeof(WIN32_FIND_DATAW));
 360     inputpath = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
 361     outputpath = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
 362
 363     /* Build the search info into a single parm */
 364     lstrcpyW(inputpath, srcstem);
 365     lstrcatW(inputpath, srcspec);
 366
 367     /* Search 1 - Look for matching files */
 368     h = FindFirstFileW(inputpath, finddata);
 369     while (h != INVALID_HANDLE_VALUE && findres) {
 370
 371         skipFile = FALSE;
 372
 373         /* Ignore . and .. */
 374         if (lstrcmpW(finddata->cFileName, wchr_dot)==0 ||
 375             lstrcmpW(finddata->cFileName, wchr_dotdot)==0 ||
 376             finddata->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
 377
 378             WINE_TRACE("Skipping directory, . or .. (%s)\n", wine_dbgstr_w(finddata->cFileName));
 379         } else {
 380
 381             /* Get the filename information */
 382             lstrcpyW(copyFrom, srcstem);
 383             if (flags & OPT_SHORTNAME) {
 384               lstrcatW(copyFrom, finddata->cAlternateFileName);
 385             } else {
 386               lstrcatW(copyFrom, finddata->cFileName);
 387             }
 388
 389             lstrcpyW(copyTo, deststem);
 390             if (*destspec == 0x00) {
 391                 if (flags & OPT_SHORTNAME) {
 392                     lstrcatW(copyTo, finddata->cAlternateFileName);
 393                 } else {
 394                     lstrcatW(copyTo, finddata->cFileName);
 395                 }
 396             } else {
 397                 lstrcatW(copyTo, destspec);
 398             }
 399
 400             /* Do the copy */
 401             WINE_TRACE("ACTION: Copy '%s' -> '%s'\n", wine_dbgstr_w(copyFrom),
 402                                                       wine_dbgstr_w(copyTo));
 403             if (!copiedFile && !(flags & OPT_SIMULATE)) XCOPY_CreateDirectory(deststem);
 404
 405             /* See if allowed to copy it */
 406             srcAttribs = GetFileAttributesW(copyFrom);
 407             WINE_TRACE("Source attribs: %d\n", srcAttribs);
 408
 409             if ((srcAttribs & FILE_ATTRIBUTE_HIDDEN) ||
 410                 (srcAttribs & FILE_ATTRIBUTE_SYSTEM)) {
 411
 412                 if (!(flags & OPT_COPYHIDSYS)) {
 413                     skipFile = TRUE;
 414                 }
 415             }
 416
 417             if (!(srcAttribs & FILE_ATTRIBUTE_ARCHIVE) &&
 418                 (flags & OPT_ARCHIVEONLY)) {
 419                 skipFile = TRUE;
 420             }
 421
 422             /* See if file exists */
 423             destAttribs = GetFileAttributesW(copyTo);
 424             WINE_TRACE("Dest attribs: %d\n", srcAttribs);
 425
 426             /* Check date ranges if a destination file already exists */
 427             if (!skipFile && (flags & OPT_DATERANGE) &&
 428                 (CompareFileTime(&finddata->ftLastWriteTime, &dateRange) < 0)) {
 429                 WINE_TRACE("Skipping file as modified date too old\n");
 430                 skipFile = TRUE;
 431             }
 432
 433             /* If just /D supplied, only overwrite if src newer than dest */
 434             if (!skipFile && (flags & OPT_DATENEWER) &&
 435                (destAttribs != INVALID_FILE_ATTRIBUTES)) {
 436                 HANDLE h = CreateFileW(copyTo, GENERIC_READ, FILE_SHARE_READ,
 437                                       NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
 438                                       NULL);
 439                 if (h != INVALID_HANDLE_VALUE) {
 440                     FILETIME writeTime;
 441                     GetFileTime(h, NULL, NULL, &writeTime);
 442
 443                     if (CompareFileTime(&finddata->ftLastWriteTime, &writeTime) <= 0) {
 444                         WINE_TRACE("Skipping file as dest newer or same date\n");
 445                         skipFile = TRUE;
 446                     }
 447                     CloseHandle(h);
 448                 }
 449             }
 450
 451             /* See if exclude list provided. Note since filenames are case
 452                insensitive, need to uppercase the filename before doing
 453                strstr                                                     */
 454             if (!skipFile && (flags & OPT_EXCLUDELIST)) {
 455                 EXCLUDELIST *pos = excludeList;
 456                 WCHAR copyFromUpper[MAX_PATH];
 457
 458                 /* Uppercase source filename */
 459                 lstrcpyW(copyFromUpper, copyFrom);
 460                 CharUpperBuffW(copyFromUpper, lstrlenW(copyFromUpper));
 461
 462                 /* Loop through testing each exclude line */
 463                 while (pos) {
 464                     if (wcsstr(copyFromUpper, pos->name) != NULL) {
 465                         WINE_TRACE("Skipping file as matches exclude '%s'\n",
 466                                    wine_dbgstr_w(pos->name));
 467                         skipFile = TRUE;
 468                         pos = NULL;
 469                     } else {
 470                         pos = pos->next;
 471                     }
 472                 }
 473             }
 474
 475             /* Prompt each file if necessary */
 476             if (!skipFile && (flags & OPT_SRCPROMPT)) {
 477                 DWORD count;
 478                 char  answer[10];
 479                 BOOL  answered = FALSE;
 480                 WCHAR yesChar[2];
 481                 WCHAR noChar[2];
 482
 483                 /* Read the Y and N characters from the resource file */
 484                 wcscpy(yesChar, XCOPY_LoadMessage(STRING_YES_CHAR));
 485                 wcscpy(noChar, XCOPY_LoadMessage(STRING_NO_CHAR));
 486
 487                 while (!answered) {
 488                     XCOPY_wprintf(XCOPY_LoadMessage(STRING_SRCPROMPT), copyFrom);
 489                     ReadFile (GetStdHandle(STD_INPUT_HANDLE), answer, sizeof(answer),
 490                               &count, NULL);
 491
 492                     answered = TRUE;
 493                     if (toupper(answer[0]) == noChar[0])
 494                         skipFile = TRUE;
 495                     else if (toupper(answer[0]) != yesChar[0])
 496                         answered = FALSE;
 497                 }
 498             }
 499
 500             if (!skipFile &&
 501                 destAttribs != INVALID_FILE_ATTRIBUTES && !(flags & OPT_NOPROMPT)) {
 502                 DWORD count;
 503                 char  answer[10];
 504                 BOOL  answered = FALSE;
 505                 WCHAR yesChar[2];
 506                 WCHAR allChar[2];
 507                 WCHAR noChar[2];
 508
 509                 /* Read the A,Y and N characters from the resource file */
 510                 wcscpy(yesChar, XCOPY_LoadMessage(STRING_YES_CHAR));
 511                 wcscpy(allChar, XCOPY_LoadMessage(STRING_ALL_CHAR));
 512                 wcscpy(noChar, XCOPY_LoadMessage(STRING_NO_CHAR));
 513
 514                 while (!answered) {
 515                     XCOPY_wprintf(XCOPY_LoadMessage(STRING_OVERWRITE), copyTo);
 516                     ReadFile (GetStdHandle(STD_INPUT_HANDLE), answer, sizeof(answer),
 517                               &count, NULL);
 518
 519                     answered = TRUE;
 520                     if (toupper(answer[0]) == allChar[0])
 521                         flags |= OPT_NOPROMPT;
 522                     else if (toupper(answer[0]) == noChar[0])
 523                         skipFile = TRUE;
 524                     else if (toupper(answer[0]) != yesChar[0])
 525                         answered = FALSE;
 526                 }
 527             }
 528
 529             /* See if it has to exist! */
 530             if (destAttribs == INVALID_FILE_ATTRIBUTES && (flags & OPT_MUSTEXIST)) {
 531                 skipFile = TRUE;
 532             }
 533
 534             /* Output a status message */
 535             if (!skipFile) {
 536                 if (flags & OPT_QUIET) {
 537                     /* Skip message */
 538                 } else if (flags & OPT_FULL) {
 539                     const WCHAR infostr[]   = {'%', '1', ' ', '-', '>', ' ',
 540                                                '%', '2', '\n', 0};
 541
 542                     XCOPY_wprintf(infostr, copyFrom, copyTo);
 543                 } else {
 544                     const WCHAR infostr[] = {'%', '1', '\n', 0};
 545                     XCOPY_wprintf(infostr, copyFrom);
 546                 }
 547
 548                 /* If allowing overwriting of read only files, remove any
 549                    write protection                                       */
 550                 if ((destAttribs & FILE_ATTRIBUTE_READONLY) &&
 551                     (flags & OPT_REPLACEREAD)) {
 552                     SetFileAttributesW(copyTo, destAttribs & ~FILE_ATTRIBUTE_READONLY);
 553                 }
 554
 555                 copiedFile = TRUE;
 556                 if (flags & OPT_SIMULATE || flags & OPT_NOCOPY) {
 557                     /* Skip copy */
 558                 } else if (CopyFileW(copyFrom, copyTo, FALSE) == 0) {
 559
 560                     DWORD error = GetLastError();
 561                     XCOPY_wprintf(XCOPY_LoadMessage(STRING_COPYFAIL),
 562                            copyFrom, copyTo, error);
 563                     XCOPY_FailMessage(error);
 564
 565                     if (flags & OPT_IGNOREERRORS) {
 566                         skipFile = TRUE;
 567                     } else {
 568                         ret = RC_WRITEERROR;
 569                         goto cleanup;
 570                     }
 571                 }
 572
 573                 /* If /M supplied, remove the archive bit after successful copy */
 574                 if (!skipFile) {
 575                     if ((srcAttribs & FILE_ATTRIBUTE_ARCHIVE) &&
 576                         (flags & OPT_REMOVEARCH)) {
 577                         SetFileAttributesW(copyFrom, (srcAttribs & ~FILE_ATTRIBUTE_ARCHIVE));
 578                     }
 579                     filesCopied++;
 580                 }
 581             }
 582         }
 583
 584         /* Find next file */
 585         findres = FindNextFileW(h, finddata);
 586     }
 587     FindClose(h);
 588
 589     /* Search 2 - do subdirs */
 590     if (flags & OPT_RECURSIVE) {
 591         lstrcpyW(inputpath, srcstem);
 592         lstrcatW(inputpath, wchr_star);
 593         findres = TRUE;
 594         WINE_TRACE("Processing subdirs with spec: %s\n", wine_dbgstr_w(inputpath));
 595
 596         h = FindFirstFileW(inputpath, finddata);
 597         while (h != INVALID_HANDLE_VALUE && findres) {
 598
 599             /* Only looking for dirs */
 600             if ((finddata->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
 601                 (lstrcmpW(finddata->cFileName, wchr_dot) != 0) &&
 602                 (lstrcmpW(finddata->cFileName, wchr_dotdot) != 0)) {
 603
 604                 WINE_TRACE("Handling subdir: %s\n", wine_dbgstr_w(finddata->cFileName));
 605
 606                 /* Make up recursive information */
 607                 lstrcpyW(inputpath, srcstem);
 608                 lstrcatW(inputpath, finddata->cFileName);
 609                 lstrcatW(inputpath, wchr_slash);
 610
 611                 lstrcpyW(outputpath, deststem);
 612                 if (*destspec == 0x00) {
 613                     lstrcatW(outputpath, finddata->cFileName);
 614
 615                     /* If /E is supplied, create the directory now */
 616                     if ((flags & OPT_EMPTYDIR) &&
 617                         !(flags & OPT_SIMULATE))
 618                         XCOPY_CreateDirectory(outputpath);
 619
 620                     lstrcatW(outputpath, wchr_slash);
 621                 }
 622
 623                 XCOPY_DoCopy(inputpath, srcspec, outputpath, destspec, flags);
 624             }
 625
 626             /* Find next one */
 627             findres = FindNextFileW(h, finddata);
 628         }
 629     }
 630
 631 cleanup:
 632
 633     /* free up memory */
 634     HeapFree(GetProcessHeap(), 0, finddata);
 635     HeapFree(GetProcessHeap(), 0, inputpath);
 636     HeapFree(GetProcessHeap(), 0, outputpath);
 637
 638     return ret;
 639 }
 640
 641
 642 /* =========================================================================
 643    XCOPY_ParseCommandLine - Parses the command line
 644    ========================================================================= */
 645 static BOOL is_whitespace(WCHAR c)
 646 {
 647     return c == ' ' || c == '\t';
 648 }
 649
 650 static WCHAR *skip_whitespace(WCHAR *p)
 651 {
 652     for (; *p && is_whitespace(*p); p++);
 653     return p;
 654 }
 655
 656 /* Windows XCOPY uses a simplified command line parsing algorithm
 657    that lacks the escaped-quote logic of build_argv(), because
 658    literal double quotes are illegal in any of its arguments.
 659    Example: 'XCOPY "c:\DIR A" "c:DIR B\"' is OK. */
 660 static int find_end_of_word(const WCHAR *word, WCHAR **end)
 661 {
 662     BOOL in_quotes = 0;
 663     const WCHAR *ptr = word;
 664     for (;;) {
 665         for (; *ptr != '\0' && *ptr != '"' &&
 666                  (in_quotes || !is_whitespace(*ptr)); ptr++);
 667         if (*ptr == '"') {
 668             in_quotes = !in_quotes;
 669             ptr++;
 670         }
 671         /* Odd number of double quotes is illegal for XCOPY */
 672         if (in_quotes && *ptr == '\0')
 673             return RC_INITERROR;
 674         if (*ptr == '\0' || (!in_quotes && is_whitespace(*ptr)))
 675             break;
 676     }
 677     *end = (WCHAR*)ptr;
 678     return RC_OK;
 679 }
 680
 681 /* Remove all double quotes from a word */
 682 static void strip_quotes(WCHAR *word, WCHAR **end)
 683 {
 684     WCHAR *rp, *wp;
 685     for (rp = word, wp = word; *rp != '\0'; rp++) {
 686         if (*rp == '"')
 687             continue;
 688         if (wp < rp)
 689             *wp = *rp;
 690         wp++;
 691     }
 692     *wp = '\0';
 693     *end = wp;
 694 }
 695
 696 static int XCOPY_ParseCommandLine(WCHAR *suppliedsource,
 697                                   WCHAR *supplieddestination, DWORD *pflags)
 698 {
 699     const WCHAR EXCLUDE[]  = {'E', 'X', 'C', 'L', 'U', 'D', 'E', ':', 0};
 700     DWORD flags = *pflags;
 701     WCHAR *cmdline, *word, *end, *next;
 702     int rc = RC_INITERROR;
 703
 704     cmdline = _wcsdup(GetCommandLineW());
 705     if (cmdline == NULL)
 706         return rc;
 707
 708     /* Skip first arg, which is the program name */
 709     if ((rc = find_end_of_word(cmdline, &word)) != RC_OK)
 710         goto out;
 711     word = skip_whitespace(word);
 712
 713     while (*word)
 714     {
 715         WCHAR first;
 716         if ((rc = find_end_of_word(word, &end)) != RC_OK)
 717             goto out;
 718
 719         next = skip_whitespace(end);
 720         first = word[0];
 721         *end = '\0';
 722         strip_quotes(word, &end);
 723         WINE_TRACE("Processing Arg: '%s'\n", wine_dbgstr_w(word));
 724
 725         /* First non-switch parameter is source, second is destination */
 726         if (first != '/') {
 727             if (suppliedsource[0] == 0x00) {
 728                 lstrcpyW(suppliedsource, word);
 729             } else if (supplieddestination[0] == 0x00) {
 730                 lstrcpyW(supplieddestination, word);
 731             } else {
 732                 XCOPY_wprintf(XCOPY_LoadMessage(STRING_INVPARMS));
 733                 goto out;
 734             }
 735         } else {
 736             /* Process all the switch options
 737                  Note: Windows docs say /P prompts when dest is created
 738                        but tests show it is done for each src file
 739                        regardless of the destination                   */
 740             switch (toupper(word[1])) {
 741             case 'I': flags |= OPT_ASSUMEDIR;     break;
 742             case 'S': flags |= OPT_RECURSIVE;     break;
 743             case 'Q': flags |= OPT_QUIET;         break;
 744             case 'F': flags |= OPT_FULL;          break;
 745             case 'L': flags |= OPT_SIMULATE;      break;
 746             case 'W': flags |= OPT_PAUSE;         break;
 747             case 'T': flags |= OPT_NOCOPY | OPT_RECURSIVE; break;
 748             case 'Y': flags |= OPT_NOPROMPT;      break;
 749             case 'N': flags |= OPT_SHORTNAME;     break;
 750             case 'U': flags |= OPT_MUSTEXIST;     break;
 751             case 'R': flags |= OPT_REPLACEREAD;   break;
 752             case 'H': flags |= OPT_COPYHIDSYS;    break;
 753             case 'C': flags |= OPT_IGNOREERRORS;  break;
 754             case 'P': flags |= OPT_SRCPROMPT;     break;
 755             case 'A': flags |= OPT_ARCHIVEONLY;   break;
 756             case 'M': flags |= OPT_ARCHIVEONLY |
 757                                OPT_REMOVEARCH;    break;
 758
 759             /* E can be /E or /EXCLUDE */
 760             case 'E': if (CompareStringW(LOCALE_USER_DEFAULT,
 761                                          NORM_IGNORECASE | SORT_STRINGSORT,
 762                                          &word[1], 8,
 763                                          EXCLUDE, -1) == 2) {
 764                         if (XCOPY_ProcessExcludeList(&word[9])) {
 765                           XCOPY_FailMessage(ERROR_INVALID_PARAMETER);
 766                           goto out;
 767                         } else flags |= OPT_EXCLUDELIST;
 768                       } else flags |= OPT_EMPTYDIR | OPT_RECURSIVE;
 769                       break;
 770
 771             /* D can be /D or /D: */
 772             case 'D': if (word[2]==':' && isdigit(word[3])) {
 773                           SYSTEMTIME st;
 774                           WCHAR     *pos = &word[3];
 775                           BOOL       isError = FALSE;
 776                           memset(&st, 0x00, sizeof(st));
 777
 778                           /* Parse the arg : Month */
 779                           st.wMonth = _wtol(pos);
 780                           while (*pos && isdigit(*pos)) pos++;
 781                           if (*pos++ != '-') isError = TRUE;
 782
 783                           /* Parse the arg : Day */
 784                           if (!isError) {
 785                               st.wDay = _wtol(pos);
 786                               while (*pos && isdigit(*pos)) pos++;
 787                               if (*pos++ != '-') isError = TRUE;
 788                           }
 789
 790                           /* Parse the arg : Day */
 791                           if (!isError) {
 792                               st.wYear = _wtol(pos);
 793                               while (*pos && isdigit(*pos)) pos++;
 794                               if (st.wYear < 100) st.wYear+=2000;
 795                           }
 796
 797                           if (!isError && SystemTimeToFileTime(&st, &dateRange)) {
 798                               SYSTEMTIME st;
 799                               WCHAR datestring[32], timestring[32];
 800
 801                               flags |= OPT_DATERANGE;
 802
 803                               /* Debug info: */
 804                               FileTimeToSystemTime (&dateRange, &st);
 805                               GetDateFormatW(0, DATE_SHORTDATE, &st, NULL, datestring,
 806                                              sizeof(datestring)/sizeof(WCHAR));
 807                               GetTimeFormatW(0, TIME_NOSECONDS, &st,
 808                                              NULL, timestring, sizeof(timestring)/sizeof(WCHAR));
 809
 810                               WINE_TRACE("Date being used is: %s %s\n",
 811                                          wine_dbgstr_w(datestring), wine_dbgstr_w(timestring));
 812                           } else {
 813                               XCOPY_FailMessage(ERROR_INVALID_PARAMETER);
 814                               goto out;
 815                           }
 816                       } else {
 817                           flags |= OPT_DATENEWER;
 818                       }
 819                       break;
 820
 821             case '-': if (toupper(word[2])=='Y')
 822                           flags &= ~OPT_NOPROMPT; break;
 823             case '?': XCOPY_wprintf(XCOPY_LoadMessage(STRING_HELP));
 824                       rc = RC_HELP;
 825                       goto out;
 826             default:
 827                 WINE_TRACE("Unhandled parameter '%s'\n", wine_dbgstr_w(word));
 828                 XCOPY_wprintf(XCOPY_LoadMessage(STRING_INVPARM), word);
 829                 goto out;
 830             }
 831         }
 832         word = next;
 833     }
 834
 835     /* Default the destination if not supplied */
 836     if (supplieddestination[0] == 0x00)
 837         lstrcpyW(supplieddestination, wchr_dot);
 838
 839     *pflags = flags;
 840     rc = RC_OK;
 841
 842  out:
 843     free(cmdline);
 844     return rc;
 845 }
 846
 847
 848 /* =========================================================================
 849    XCOPY_ProcessSourceParm - Takes the supplied source parameter, and
 850      converts it into a stem and a filespec
 851    ========================================================================= */
 852 static int XCOPY_ProcessSourceParm(WCHAR *suppliedsource, WCHAR *stem,
 853                                    WCHAR *spec, DWORD flags)
 854 {
 855     WCHAR             actualsource[MAX_PATH];
 856     WCHAR            *starPos;
 857     WCHAR            *questPos;
 858     DWORD             attribs;
 859
 860     /*
 861      * Validate the source, expanding to full path ensuring it exists
 862      */
 863     if (GetFullPathNameW(suppliedsource, MAX_PATH, actualsource, NULL) == 0) {
 864         WINE_FIXME("Unexpected failure expanding source path (%d)\n", GetLastError());
 865         return RC_INITERROR;
 866     }
 867
 868     /* If full names required, convert to using the full path */
 869     if (flags & OPT_FULL) {
 870         lstrcpyW(suppliedsource, actualsource);
 871     }
 872
 873     /*
 874      * Work out the stem of the source
 875      */
 876
 877     /* If a directory is supplied, use that as-is (either fully or
 878           partially qualified)
 879        If a filename is supplied + a directory or drive path, use that
 880           as-is
 881        Otherwise
 882           If no directory or path specified, add eg. C:
 883           stem is Drive/Directory is bit up to last \ (or first :)
 884           spec is bit after that                                         */
 885
 886     starPos = wcschr(suppliedsource, '*');
 887     questPos = wcschr(suppliedsource, '?');
 888     if (starPos || questPos) {
 889         attribs = 0x00;  /* Ensures skips invalid or directory check below */
 890     } else {
 891         attribs = GetFileAttributesW(actualsource);
 892     }
 893
 894     if (attribs == INVALID_FILE_ATTRIBUTES) {
 895         XCOPY_FailMessage(GetLastError());
 896         return RC_INITERROR;
 897
 898     /* Directory:
 899          stem should be exactly as supplied plus a '\', unless it was
 900           eg. C: in which case no slash required */
 901     } else if (attribs & FILE_ATTRIBUTE_DIRECTORY) {
 902         WCHAR lastChar;
 903
 904         WINE_TRACE("Directory supplied\n");
 905         lstrcpyW(stem, suppliedsource);
 906         lastChar = stem[lstrlenW(stem)-1];
 907         if (lastChar != '\\' && lastChar != ':') {
 908             lstrcatW(stem, wchr_slash);
 909         }
 910         lstrcpyW(spec, wchr_star);
 911
 912     /* File or wildcard search:
 913          stem should be:
 914            Up to and including last slash if directory path supplied
 915            If c:filename supplied, just the c:
 916            Otherwise stem should be the current drive letter + ':' */
 917     } else {
 918         WCHAR *lastDir;
 919
 920         WINE_TRACE("Filename supplied\n");
 921         lastDir   = wcsrchr(suppliedsource, '\\');
 922
 923         if (lastDir) {
 924             lstrcpyW(stem, suppliedsource);
 925             stem[(lastDir-suppliedsource) + 1] = 0x00;
 926             lstrcpyW(spec, (lastDir+1));
 927         } else if (suppliedsource[1] == ':') {
 928             lstrcpyW(stem, suppliedsource);
 929             stem[2] = 0x00;
 930             lstrcpyW(spec, suppliedsource+2);
 931         } else {
 932             WCHAR curdir[MAXSTRING];
 933             GetCurrentDirectoryW(sizeof(curdir)/sizeof(WCHAR), curdir);
 934             stem[0] = curdir[0];
 935             stem[1] = curdir[1];
 936             stem[2] = 0x00;
 937             lstrcpyW(spec, suppliedsource);
 938         }
 939     }
 940
 941     return RC_OK;
 942 }
 943
 944 /* =========================================================================
 945    XCOPY_ProcessDestParm - Takes the supplied destination parameter, and
 946      converts it into a stem
 947    ========================================================================= */
 948 static int XCOPY_ProcessDestParm(WCHAR *supplieddestination, WCHAR *stem, WCHAR *spec,
 949                                  WCHAR *srcspec, DWORD flags)
 950 {
 951     WCHAR  actualdestination[MAX_PATH];
 952     DWORD attribs;
 953     BOOL isDir = FALSE;
 954
 955     /*
 956      * Validate the source, expanding to full path ensuring it exists
 957      */
 958     if (GetFullPathNameW(supplieddestination, MAX_PATH, actualdestination, NULL) == 0) {
 959         WINE_FIXME("Unexpected failure expanding source path (%d)\n", GetLastError());
 960         return RC_INITERROR;
 961     }
 962
 963     /* Destination is either a directory or a file */
 964     attribs = GetFileAttributesW(actualdestination);
 965
 966     if (attribs == INVALID_FILE_ATTRIBUTES) {
 967
 968         /* If /I supplied and wildcard copy, assume directory */
 969         /* Also if destination ends with backslash */
 970         if ((flags & OPT_ASSUMEDIR &&
 971             (wcschr(srcspec, '?') || wcschr(srcspec, '*'))) ||
 972             (supplieddestination[lstrlenW(supplieddestination)-1] == '\\')) {
 973
 974             isDir = TRUE;
 975
 976         } else {
 977             DWORD count;
 978             char  answer[10] = "";
 979             WCHAR fileChar[2];
 980             WCHAR dirChar[2];
 981
 982             /* Read the F and D characters from the resource file */
 983             wcscpy(fileChar, XCOPY_LoadMessage(STRING_FILE_CHAR));
 984             wcscpy(dirChar, XCOPY_LoadMessage(STRING_DIR_CHAR));
 985
 986             while (answer[0] != fileChar[0] && answer[0] != dirChar[0]) {
 987                 XCOPY_wprintf(XCOPY_LoadMessage(STRING_QISDIR), supplieddestination);
 988
 989                 ReadFile(GetStdHandle(STD_INPUT_HANDLE), answer, sizeof(answer), &count, NULL);
 990                 WINE_TRACE("User answer %c\n", answer[0]);
 991
 992                 answer[0] = toupper(answer[0]);
 993             }
 994
 995             if (answer[0] == dirChar[0]) {
 996                 isDir = TRUE;
 997             } else {
 998                 isDir = FALSE;
 999             }
1000         }
1001     } else {
1002         isDir = (attribs & FILE_ATTRIBUTE_DIRECTORY);
1003     }
1004
1005     if (isDir) {
1006         lstrcpyW(stem, actualdestination);
1007         *spec = 0x00;
1008
1009         /* Ensure ends with a '\' */
1010         if (stem[lstrlenW(stem)-1] != '\\') {
1011             lstrcatW(stem, wchr_slash);
1012         }
1013
1014     } else {
1015         WCHAR drive[MAX_PATH];
1016         WCHAR dir[MAX_PATH];
1017         WCHAR fname[MAX_PATH];
1018         WCHAR ext[MAX_PATH];
1019         _wsplitpath(actualdestination, drive, dir, fname, ext);
1020         lstrcpyW(stem, drive);
1021         lstrcatW(stem, dir);
1022         lstrcpyW(spec, fname);
1023         lstrcatW(spec, ext);
1024     }
1025     return RC_OK;
1026 }
1027
1028
1029 /* =========================================================================
1030    main - Main entrypoint for the xcopy command
1031
1032      Processes the args, and drives the actual copying
1033    ========================================================================= */
1034 int wmain (int argc, WCHAR *argvW[])
1035 {
1036     int     rc = 0;
1037     WCHAR   suppliedsource[MAX_PATH] = {0};   /* As supplied on the cmd line */
1038     WCHAR   supplieddestination[MAX_PATH] = {0};
1039     WCHAR   sourcestem[MAX_PATH] = {0};       /* Stem of source          */
1040     WCHAR   sourcespec[MAX_PATH] = {0};       /* Filespec of source      */
1041     WCHAR   destinationstem[MAX_PATH] = {0};  /* Stem of destination     */
1042     WCHAR   destinationspec[MAX_PATH] = {0};  /* Filespec of destination */
1043     WCHAR   copyCmd[MAXSTRING];               /* COPYCMD env var         */
1044     DWORD   flags = 0;                        /* Option flags            */
1045     const WCHAR PROMPTSTR1[]  = {'/', 'Y', 0};
1046     const WCHAR PROMPTSTR2[]  = {'/', 'y', 0};
1047     const WCHAR COPYCMD[]  = {'C', 'O', 'P', 'Y', 'C', 'M', 'D', 0};
1048
1049     /* Preinitialize flags based on COPYCMD */
1050     if (GetEnvironmentVariableW(COPYCMD, copyCmd, MAXSTRING)) {
1051         if (wcsstr(copyCmd, PROMPTSTR1) != NULL ||
1052             wcsstr(copyCmd, PROMPTSTR2) != NULL) {
1053             flags |= OPT_NOPROMPT;
1054         }
1055     }
1056
1057     /* FIXME: On UNIX, files starting with a '.' are treated as hidden under
1058        wine, but on windows these can be normal files. At least one installer
1059        uses files such as .packlist and (validly) expects them to be copied.
1060        Under wine, if we do not copy hidden files by default then they get
1061        lose                                                                   */
1062     flags |= OPT_COPYHIDSYS;
1063
1064     /*
1065      * Parse the command line
1066      */
1067     if ((rc = XCOPY_ParseCommandLine(suppliedsource, supplieddestination,
1068                                      &flags)) != RC_OK) {
1069         if (rc == RC_HELP)
1070             return RC_OK;
1071         else
1072             return rc;
1073     }
1074
1075     /* Trace out the supplied information */
1076     WINE_TRACE("Supplied parameters:\n");
1077     WINE_TRACE("Source      : '%s'\n", wine_dbgstr_w(suppliedsource));
1078     WINE_TRACE("Destination : '%s'\n", wine_dbgstr_w(supplieddestination));
1079
1080     /* Extract required information from source specification */
1081     rc = XCOPY_ProcessSourceParm(suppliedsource, sourcestem, sourcespec, flags);
1082     if (rc != RC_OK) return rc;
1083
1084     /* Extract required information from destination specification */
1085     rc = XCOPY_ProcessDestParm(supplieddestination, destinationstem,
1086                                destinationspec, sourcespec, flags);
1087     if (rc != RC_OK) return rc;
1088
1089     /* Trace out the resulting information */
1090     WINE_TRACE("Resolved parameters:\n");
1091     WINE_TRACE("Source Stem : '%s'\n", wine_dbgstr_w(sourcestem));
1092     WINE_TRACE("Source Spec : '%s'\n", wine_dbgstr_w(sourcespec));
1093     WINE_TRACE("Dest   Stem : '%s'\n", wine_dbgstr_w(destinationstem));
1094     WINE_TRACE("Dest   Spec : '%s'\n", wine_dbgstr_w(destinationspec));
1095
1096     /* Pause if necessary */
1097     if (flags & OPT_PAUSE) {
1098         DWORD count;
1099         char pausestr[10];
1100
1101         XCOPY_wprintf(XCOPY_LoadMessage(STRING_PAUSE));
1102         ReadFile (GetStdHandle(STD_INPUT_HANDLE), pausestr, sizeof(pausestr),
1103                   &count, NULL);
1104     }
1105
1106     /* Now do the hard work... */
1107     rc = XCOPY_DoCopy(sourcestem, sourcespec,
1108                 destinationstem, destinationspec,
1109                 flags);
1110
1111     /* Clear up exclude list allocated memory */
1112     while (excludeList) {
1113         EXCLUDELIST *pos = excludeList;
1114         excludeList = excludeList -> next;
1115         HeapFree(GetProcessHeap(), 0, pos->name);
1116         HeapFree(GetProcessHeap(), 0, pos);
1117     }
1118
1119     /* Finished - print trailer and exit */
1120     if (flags & OPT_SIMULATE) {
1121         XCOPY_wprintf(XCOPY_LoadMessage(STRING_SIMCOPY), filesCopied);
1122     } else if (!(flags & OPT_NOCOPY)) {
1123         XCOPY_wprintf(XCOPY_LoadMessage(STRING_COPY), filesCopied);
1124     }
1125     if (rc == RC_OK && filesCopied == 0) rc = RC_NOFILES;
1126     return rc;
1127
1128 }