projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Lars Martin Hambro <lars_martin4 AT hotmail DOT com>
[reactos.git] / reactos / base / applications / cmdutils / 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 recursively. 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 }
A free Windows-compatible Operating System