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