+/*
+ * XCOPY - Wine-compatible xcopy program
+ *
+ * Copyright (C) 2007 J. Edmeades
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+/*
+ * FIXME:
+ * This should now support all options listed in the xcopy help from
+ * windows XP except:
+ * /Z - Copy from network drives in restartable mode
+ * /X - Copy file audit settings (sets /O)
+ * /O - Copy file ownership + ACL info
+ * /G - Copy encrypted files to unencrypted destination
+ * /V - Verifies files
+ */
+
+/*
+ * Notes:
+ * Apparently, valid return codes are:
+ * 0 - OK
+ * 1 - No files found to copy
+ * 2 - CTRL+C during copy
+ * 4 - Initialization error, or invalid source specification
+ * 5 - Disk write error
+ */
+
+
+#include <stdio.h>
+#include <windows.h>
+#include <wine/debug.h>
+#include "xcopy.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(xcopy);
+
+/* Prototypes */
+static int XCOPY_ProcessSourceParm(WCHAR *suppliedsource, WCHAR *stem,
+ WCHAR *spec, DWORD flags);
+static int XCOPY_ProcessDestParm(WCHAR *supplieddestination, WCHAR *stem,
+ WCHAR *spec, WCHAR *srcspec, DWORD flags);
+static int XCOPY_DoCopy(WCHAR *srcstem, WCHAR *srcspec,
+ WCHAR *deststem, WCHAR *destspec,
+ DWORD flags);
+static BOOL XCOPY_CreateDirectory(const WCHAR* path);
+static BOOL XCOPY_ProcessExcludeList(WCHAR* parms);
+static BOOL XCOPY_ProcessExcludeFile(WCHAR* filename, WCHAR* endOfName);
+static WCHAR *XCOPY_LoadMessage(UINT id);
+static void XCOPY_FailMessage(DWORD err);
+static int XCOPY_wprintf(const WCHAR *format, ...);
+
+/* Typedefs */
+typedef struct _EXCLUDELIST
+{
+ struct _EXCLUDELIST *next;
+ WCHAR *name;
+} EXCLUDELIST;
+
+
+/* Global variables */
+static ULONG filesCopied = 0; /* Number of files copied */
+static EXCLUDELIST *excludeList = NULL; /* Excluded strings list */
+static FILETIME dateRange; /* Date range to copy after*/
+static const WCHAR wchr_slash[] = {'\\', 0};
+static const WCHAR wchr_star[] = {'*', 0};
+static const WCHAR wchr_dot[] = {'.', 0};
+static const WCHAR wchr_dotdot[] = {'.', '.', 0};
+
+/* Constants (Mostly for widechars) */
+
+
+/* To minimize stack usage during recursion, some temporary variables
+ made global */
+static WCHAR copyFrom[MAX_PATH];
+static WCHAR copyTo[MAX_PATH];
+
+
+/* =========================================================================
+ main - Main entrypoint for the xcopy command
+
+ Processes the args, and drives the actual copying
+ ========================================================================= */
+int wmain (int argc, WCHAR *argvW[])
+{
+ int rc = 0;
+ WCHAR suppliedsource[MAX_PATH] = {0}; /* As supplied on the cmd line */
+ WCHAR supplieddestination[MAX_PATH] = {0};
+ WCHAR sourcestem[MAX_PATH] = {0}; /* Stem of source */
+ WCHAR sourcespec[MAX_PATH] = {0}; /* Filespec of source */
+ WCHAR destinationstem[MAX_PATH] = {0}; /* Stem of destination */
+ WCHAR destinationspec[MAX_PATH] = {0}; /* Filespec of destination */
+ WCHAR copyCmd[MAXSTRING]; /* COPYCMD env var */
+ DWORD flags = 0; /* Option flags */
+ const WCHAR PROMPTSTR1[] = {'/', 'Y', 0};
+ const WCHAR PROMPTSTR2[] = {'/', 'y', 0};
+ const WCHAR COPYCMD[] = {'C', 'O', 'P', 'Y', 'C', 'M', 'D', 0};
+ const WCHAR EXCLUDE[] = {'E', 'X', 'C', 'L', 'U', 'D', 'E', ':', 0};
+
+ /*
+ * Parse the command line
+ */
+
+ /* Confirm at least one parameter */
+ if (argc < 2) {
+ XCOPY_wprintf(XCOPY_LoadMessage(STRING_INVPARMS));
+ return RC_INITERROR;
+ }
+
+ /* Preinitialize flags based on COPYCMD */
+ if (GetEnvironmentVariable(COPYCMD, copyCmd, MAXSTRING)) {
+ if (wcsstr(copyCmd, PROMPTSTR1) != NULL ||
+ wcsstr(copyCmd, PROMPTSTR2) != NULL) {
+ flags |= OPT_NOPROMPT;
+ }
+ }
+
+ /* FIXME: On UNIX, files starting with a '.' are treated as hidden under
+ wine, but on windows these can be normal files. At least one installer
+ uses files such as .packlist and (validly) expects them to be copied.
+ Under wine, if we do not copy hidden files by default then they get
+ lose */
+ flags |= OPT_COPYHIDSYS;
+
+ /* Skip first arg, which is the program name */
+ argvW++;
+
+ while (argc > 1)
+ {
+ argc--;
+ WINE_TRACE("Processing Arg: '%s'\n", wine_dbgstr_w(*argvW));
+
+ /* First non-switch parameter is source, second is destination */
+ if (*argvW[0] != '/') {
+ if (suppliedsource[0] == 0x00) {
+ lstrcpyW(suppliedsource, *argvW);
+ } else if (supplieddestination[0] == 0x00) {
+ lstrcpyW(supplieddestination, *argvW);
+ } else {
+ XCOPY_wprintf(XCOPY_LoadMessage(STRING_INVPARMS));
+ return RC_INITERROR;
+ }
+ } else {
+ /* Process all the switch options
+ Note: Windows docs say /P prompts when dest is created
+ but tests show it is done for each src file
+ regardless of the destination */
+ switch (toupper(argvW[0][1])) {
+ case 'I': flags |= OPT_ASSUMEDIR; break;
+ case 'S': flags |= OPT_RECURSIVE; break;
+ case 'Q': flags |= OPT_QUIET; break;
+ case 'F': flags |= OPT_FULL; break;
+ case 'L': flags |= OPT_SIMULATE; break;
+ case 'W': flags |= OPT_PAUSE; break;
+ case 'T': flags |= OPT_NOCOPY | OPT_RECURSIVE; break;
+ case 'Y': flags |= OPT_NOPROMPT; break;
+ case 'N': flags |= OPT_SHORTNAME; break;
+ case 'U': flags |= OPT_MUSTEXIST; break;
+ case 'R': flags |= OPT_REPLACEREAD; break;
+ case 'H': flags |= OPT_COPYHIDSYS; break;
+ case 'C': flags |= OPT_IGNOREERRORS; break;
+ case 'P': flags |= OPT_SRCPROMPT; break;
+ case 'A': flags |= OPT_ARCHIVEONLY; break;
+ case 'M': flags |= OPT_ARCHIVEONLY |
+ OPT_REMOVEARCH; break;
+
+ /* E can be /E or /EXCLUDE */
+ case 'E': if (CompareString (LOCALE_USER_DEFAULT,
+ NORM_IGNORECASE | SORT_STRINGSORT,
+ &argvW[0][1], 8,
+ EXCLUDE, -1) == 2) {
+ if (XCOPY_ProcessExcludeList(&argvW[0][9])) {
+ XCOPY_FailMessage(ERROR_INVALID_PARAMETER);
+ return RC_INITERROR;
+ } else flags |= OPT_EXCLUDELIST;
+ } else flags |= OPT_EMPTYDIR | OPT_RECURSIVE;
+ break;
+
+ /* D can be /D or /D: */
+ case 'D': if ((argvW[0][2])==':' && isdigit(argvW[0][3])) {
+ SYSTEMTIME st;
+ WCHAR *pos = &argvW[0][3];
+ BOOL isError = FALSE;
+ memset(&st, 0x00, sizeof(st));
+
+ /* Parse the arg : Month */
+ st.wMonth = _wtol(pos);
+ while (*pos && isdigit(*pos)) pos++;
+ if (*pos++ != '-') isError = TRUE;
+
+ /* Parse the arg : Day */
+ if (!isError) {
+ st.wDay = _wtol(pos);
+ while (*pos && isdigit(*pos)) pos++;
+ if (*pos++ != '-') isError = TRUE;
+ }
+
+ /* Parse the arg : Day */
+ if (!isError) {
+ st.wYear = _wtol(pos);
+ if (st.wYear < 100) st.wYear+=2000;
+ }
+
+ if (!isError && SystemTimeToFileTime(&st, &dateRange)) {
+ SYSTEMTIME st;
+ WCHAR datestring[32], timestring[32];
+
+ flags |= OPT_DATERANGE;
+
+ /* Debug info: */
+ FileTimeToSystemTime (&dateRange, &st);
+ GetDateFormat (0, DATE_SHORTDATE, &st, NULL, datestring,
+ sizeof(datestring));
+ GetTimeFormat (0, TIME_NOSECONDS, &st,
+ NULL, timestring, sizeof(timestring));
+
+ WINE_TRACE("Date being used is: %s %s\n",
+ wine_dbgstr_w(datestring), wine_dbgstr_w(timestring));
+ } else {
+ XCOPY_FailMessage(ERROR_INVALID_PARAMETER);
+ return RC_INITERROR;
+ }
+ } else {
+ flags |= OPT_DATENEWER;
+ }
+ break;
+
+ case '-': if (toupper(argvW[0][2])=='Y')
+ flags &= ~OPT_NOPROMPT; break;
+ case '?': XCOPY_wprintf(XCOPY_LoadMessage(STRING_HELP));
+ return RC_OK;
+ default:
+ WINE_TRACE("Unhandled parameter '%s'\n", wine_dbgstr_w(*argvW));
+ XCOPY_wprintf(XCOPY_LoadMessage(STRING_INVPARM), *argvW);
+ return RC_INITERROR;
+ }
+ }
+ argvW++;
+ }
+
+ /* Default the destination if not supplied */
+ if (supplieddestination[0] == 0x00)
+ lstrcpyW(supplieddestination, wchr_dot);
+
+ /* Trace out the supplied information */
+ WINE_TRACE("Supplied parameters:\n");
+ WINE_TRACE("Source : '%s'\n", wine_dbgstr_w(suppliedsource));
+ WINE_TRACE("Destination : '%s'\n", wine_dbgstr_w(supplieddestination));
+
+ /* Extract required information from source specification */
+ rc = XCOPY_ProcessSourceParm(suppliedsource, sourcestem, sourcespec, flags);
+
+ /* Extract required information from destination specification */
+ rc = XCOPY_ProcessDestParm(supplieddestination, destinationstem,
+ destinationspec, sourcespec, flags);
+
+ /* Trace out the resulting information */
+ WINE_TRACE("Resolved parameters:\n");
+ WINE_TRACE("Source Stem : '%s'\n", wine_dbgstr_w(sourcestem));
+ WINE_TRACE("Source Spec : '%s'\n", wine_dbgstr_w(sourcespec));
+ WINE_TRACE("Dest Stem : '%s'\n", wine_dbgstr_w(destinationstem));
+ WINE_TRACE("Dest Spec : '%s'\n", wine_dbgstr_w(destinationspec));
+
+ /* Pause if necessary */
+ if (flags & OPT_PAUSE) {
+ DWORD count;
+ char pausestr[10];
+
+ XCOPY_wprintf(XCOPY_LoadMessage(STRING_PAUSE));
+ ReadFile (GetStdHandle(STD_INPUT_HANDLE), pausestr, sizeof(pausestr),
+ &count, NULL);
+ }
+
+ /* Now do the hard work... */
+ rc = XCOPY_DoCopy(sourcestem, sourcespec,
+ destinationstem, destinationspec,
+ flags);
+
+ /* Clear up exclude list allocated memory */
+ while (excludeList) {
+ EXCLUDELIST *pos = excludeList;
+ excludeList = excludeList -> next;
+ HeapFree(GetProcessHeap(), 0, pos->name);
+ HeapFree(GetProcessHeap(), 0, pos);
+ }
+
+ /* Finished - print trailer and exit */
+ if (flags & OPT_SIMULATE) {
+ XCOPY_wprintf(XCOPY_LoadMessage(STRING_SIMCOPY), filesCopied);
+ } else if (!(flags & OPT_NOCOPY)) {
+ XCOPY_wprintf(XCOPY_LoadMessage(STRING_COPY), filesCopied);
+ }
+ if (rc == RC_OK && filesCopied == 0) rc = RC_NOFILES;
+ return rc;
+
+}
+
+
+/* =========================================================================
+ XCOPY_ProcessSourceParm - Takes the supplied source parameter, and
+ converts it into a stem and a filespec
+ ========================================================================= */
+static int XCOPY_ProcessSourceParm(WCHAR *suppliedsource, WCHAR *stem,
+ WCHAR *spec, DWORD flags)
+{
+ WCHAR actualsource[MAX_PATH];
+ WCHAR *starPos;
+ WCHAR *questPos;
+ DWORD attribs;
+
+ /*
+ * Validate the source, expanding to full path ensuring it exists
+ */
+ if (GetFullPathName(suppliedsource, MAX_PATH, actualsource, NULL) == 0) {
+ WINE_FIXME("Unexpected failure expanding source path (%d)\n", GetLastError());
+ return RC_INITERROR;
+ }
+
+ /* If full names required, convert to using the full path */
+ if (flags & OPT_FULL) {
+ lstrcpyW(suppliedsource, actualsource);
+ }
+
+ /*
+ * Work out the stem of the source
+ */
+
+ /* If a directory is supplied, use that as-is (either fully or
+ partially qualified)
+ If a filename is supplied + a directory or drive path, use that
+ as-is
+ Otherwise
+ If no directory or path specified, add eg. C:
+ stem is Drive/Directory is bit up to last \ (or first :)
+ spec is bit after that */
+
+ starPos = wcschr(suppliedsource, '*');
+ questPos = wcschr(suppliedsource, '?');
+ if (starPos || questPos) {
+ attribs = 0x00; /* Ensures skips invalid or directory check below */
+ } else {
+ attribs = GetFileAttributes(actualsource);
+ }
+
+ if (attribs == INVALID_FILE_ATTRIBUTES) {
+ XCOPY_FailMessage(GetLastError());
+ return RC_INITERROR;
+
+ /* Directory:
+ stem should be exactly as supplied plus a '\', unless it was
+ eg. C: in which case no slash required */
+ } else if (attribs & FILE_ATTRIBUTE_DIRECTORY) {
+ WCHAR lastChar;
+
+ WINE_TRACE("Directory supplied\n");
+ lstrcpyW(stem, suppliedsource);
+ lastChar = stem[lstrlenW(stem)-1];
+ if (lastChar != '\\' && lastChar != ':') {
+ lstrcatW(stem, wchr_slash);
+ }
+ lstrcpyW(spec, wchr_star);
+
+ /* File or wildcard search:
+ stem should be:
+ Up to and including last slash if directory path supplied
+ If c:filename supplied, just the c:
+ Otherwise stem should be the current drive letter + ':' */
+ } else {
+ WCHAR *lastDir;
+
+ WINE_TRACE("Filename supplied\n");
+ lastDir = wcsrchr(suppliedsource, '\\');
+
+ if (lastDir) {
+ lstrcpyW(stem, suppliedsource);
+ stem[(lastDir-suppliedsource) + 1] = 0x00;
+ lstrcpyW(spec, (lastDir+1));
+ } else if (suppliedsource[1] == ':') {
+ lstrcpyW(stem, suppliedsource);
+ stem[2] = 0x00;
+ lstrcpyW(spec, suppliedsource+2);
+ } else {
+ WCHAR curdir[MAXSTRING];
+ GetCurrentDirectory (sizeof(curdir), curdir);
+ stem[0] = curdir[0];
+ stem[1] = curdir[1];
+ stem[2] = 0x00;
+ lstrcpyW(spec, suppliedsource);
+ }
+ }
+
+ return RC_OK;
+}
+
+/* =========================================================================
+ XCOPY_ProcessDestParm - Takes the supplied destination parameter, and
+ converts it into a stem
+ ========================================================================= */
+static int XCOPY_ProcessDestParm(WCHAR *supplieddestination, WCHAR *stem, WCHAR *spec,
+ WCHAR *srcspec, DWORD flags)
+{
+ WCHAR actualdestination[MAX_PATH];
+ DWORD attribs;
+ BOOL isDir = FALSE;
+
+ /*
+ * Validate the source, expanding to full path ensuring it exists
+ */
+ if (GetFullPathName(supplieddestination, MAX_PATH, actualdestination, NULL) == 0) {
+ WINE_FIXME("Unexpected failure expanding source path (%d)\n", GetLastError());
+ return RC_INITERROR;
+ }
+
+ /* Destination is either a directory or a file */
+ attribs = GetFileAttributes(actualdestination);
+
+ if (attribs == INVALID_FILE_ATTRIBUTES) {
+
+ /* If /I supplied and wildcard copy, assume directory */
+ if (flags & OPT_ASSUMEDIR &&
+ (wcschr(srcspec, '?') || wcschr(srcspec, '*'))) {
+
+ isDir = TRUE;
+
+ } else {
+ DWORD count;
+ char answer[10] = "";
+ WCHAR fileChar[2];
+ WCHAR dirChar[2];
+
+ /* Read the F and D characters from the resource file */
+ wcscpy(fileChar, XCOPY_LoadMessage(STRING_FILE_CHAR));
+ wcscpy(dirChar, XCOPY_LoadMessage(STRING_DIR_CHAR));
+
+ while (answer[0] != fileChar[0] && answer[0] != dirChar[0]) {
+ XCOPY_wprintf(XCOPY_LoadMessage(STRING_QISDIR), supplieddestination);
+
+ ReadFile(GetStdHandle(STD_INPUT_HANDLE), answer, sizeof(answer), &count, NULL);
+ WINE_TRACE("User answer %c\n", answer[0]);
+
+ answer[0] = toupper(answer[0]);
+ }
+
+ if (answer[0] == dirChar[0]) {
+ isDir = TRUE;
+ } else {
+ isDir = FALSE;
+ }
+ }
+ } else {
+ isDir = (attribs & FILE_ATTRIBUTE_DIRECTORY);
+ }
+
+ if (isDir) {
+ lstrcpyW(stem, actualdestination);
+ *spec = 0x00;
+
+ /* Ensure ends with a '\' */
+ if (stem[lstrlenW(stem)-1] != '\\') {
+ lstrcatW(stem, wchr_slash);
+ }
+
+ } else {
+ WCHAR drive[MAX_PATH];
+ WCHAR dir[MAX_PATH];
+ WCHAR fname[MAX_PATH];
+ WCHAR ext[MAX_PATH];
+ _wsplitpath(actualdestination, drive, dir, fname, ext);
+ lstrcpyW(stem, drive);
+ lstrcatW(stem, dir);
+ lstrcpyW(spec, fname);
+ lstrcatW(spec, ext);
+ }
+ return RC_OK;
+}
+
+/* =========================================================================
+ XCOPY_DoCopy - Recursive function to copy files based on input parms
+ of a stem and a spec
+
+ This works by using FindFirstFile supplying the source stem and spec.
+ If results are found, any non-directory ones are processed
+ Then, if /S or /E is supplied, another search is made just for
+ directories, and this function is called again for that directory
+
+ ========================================================================= */
+static int XCOPY_DoCopy(WCHAR *srcstem, WCHAR *srcspec,
+ WCHAR *deststem, WCHAR *destspec,
+ DWORD flags)
+{
+ WIN32_FIND_DATA *finddata;
+ HANDLE h;
+ BOOL findres = TRUE;
+ WCHAR *inputpath, *outputpath;
+ BOOL copiedFile = FALSE;
+ DWORD destAttribs, srcAttribs;
+ BOOL skipFile;
+
+ /* Allocate some working memory on heap to minimize footprint */
+ finddata = HeapAlloc(GetProcessHeap(), 0, sizeof(WIN32_FIND_DATA));
+ inputpath = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
+ outputpath = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
+
+ /* Build the search info into a single parm */
+ lstrcpyW(inputpath, srcstem);
+ lstrcatW(inputpath, srcspec);
+
+ /* Search 1 - Look for matching files */
+ h = FindFirstFile(inputpath, finddata);
+ while (h != INVALID_HANDLE_VALUE && findres) {
+
+ skipFile = FALSE;
+
+ /* Ignore . and .. */
+ if (lstrcmpW(finddata->cFileName, wchr_dot)==0 ||
+ lstrcmpW(finddata->cFileName, wchr_dotdot)==0 ||
+ finddata->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+
+ WINE_TRACE("Skipping directory, . or .. (%s)\n", wine_dbgstr_w(finddata->cFileName));
+ } else {
+
+ /* Get the filename information */
+ lstrcpyW(copyFrom, srcstem);
+ if (flags & OPT_SHORTNAME) {
+ lstrcatW(copyFrom, finddata->cAlternateFileName);
+ } else {
+ lstrcatW(copyFrom, finddata->cFileName);
+ }
+
+ lstrcpyW(copyTo, deststem);
+ if (*destspec == 0x00) {
+ if (flags & OPT_SHORTNAME) {
+ lstrcatW(copyTo, finddata->cAlternateFileName);
+ } else {
+ lstrcatW(copyTo, finddata->cFileName);
+ }
+ } else {
+ lstrcatW(copyTo, destspec);
+ }
+
+ /* Do the copy */
+ WINE_TRACE("ACTION: Copy '%s' -> '%s'\n", wine_dbgstr_w(copyFrom),
+ wine_dbgstr_w(copyTo));
+ if (!copiedFile && !(flags & OPT_SIMULATE)) XCOPY_CreateDirectory(deststem);
+
+ /* See if allowed to copy it */
+ srcAttribs = GetFileAttributesW(copyFrom);
+ WINE_TRACE("Source attribs: %d\n", srcAttribs);
+
+ if ((srcAttribs & FILE_ATTRIBUTE_HIDDEN) ||
+ (srcAttribs & FILE_ATTRIBUTE_SYSTEM)) {
+
+ if (!(flags & OPT_COPYHIDSYS)) {
+ skipFile = TRUE;
+ }
+ }
+
+ if (!(srcAttribs & FILE_ATTRIBUTE_ARCHIVE) &&
+ (flags & OPT_ARCHIVEONLY)) {
+ skipFile = TRUE;
+ }
+
+ /* See if file exists */
+ destAttribs = GetFileAttributesW(copyTo);
+ WINE_TRACE("Dest attribs: %d\n", srcAttribs);
+
+ /* Check date ranges if a destination file already exists */
+ if (!skipFile && (flags & OPT_DATERANGE) &&
+ (CompareFileTime(&finddata->ftLastWriteTime, &dateRange) < 0)) {
+ WINE_TRACE("Skipping file as modified date too old\n");
+ skipFile = TRUE;
+ }
+
+ /* If just /D supplied, only overwrite if src newer than dest */
+ if (!skipFile && (flags & OPT_DATENEWER) &&
+ (destAttribs != INVALID_FILE_ATTRIBUTES)) {
+ HANDLE h = CreateFile(copyTo, GENERIC_READ, FILE_SHARE_READ,
+ NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
+ NULL);
+ if (h != INVALID_HANDLE_VALUE) {
+ FILETIME writeTime;
+ GetFileTime(h, NULL, NULL, &writeTime);
+
+ if (CompareFileTime(&finddata->ftLastWriteTime, &writeTime) <= 0) {
+ WINE_TRACE("Skipping file as dest newer or same date\n");
+ skipFile = TRUE;
+ }
+ CloseHandle(h);
+ }
+ }
+
+ /* See if exclude list provided. Note since filenames are case
+ insensitive, need to uppercase the filename before doing
+ strstr */
+ if (!skipFile && (flags & OPT_EXCLUDELIST)) {
+ EXCLUDELIST *pos = excludeList;
+ WCHAR copyFromUpper[MAX_PATH];
+
+ /* Uppercase source filename */
+ lstrcpyW(copyFromUpper, copyFrom);
+ CharUpperBuff(copyFromUpper, lstrlenW(copyFromUpper));
+
+ /* Loop through testing each exclude line */
+ while (pos) {
+ if (wcsstr(copyFromUpper, pos->name) != NULL) {
+ WINE_TRACE("Skipping file as matches exclude '%s'\n",
+ wine_dbgstr_w(pos->name));
+ skipFile = TRUE;
+ pos = NULL;
+ } else {
+ pos = pos->next;
+ }
+ }
+ }
+
+ /* Prompt each file if necessary */
+ if (!skipFile && (flags & OPT_SRCPROMPT)) {
+ DWORD count;
+ char answer[10];
+ BOOL answered = FALSE;
+ WCHAR yesChar[2];
+ WCHAR noChar[2];
+
+ /* Read the Y and N characters from the resource file */
+ wcscpy(yesChar, XCOPY_LoadMessage(STRING_YES_CHAR));
+ wcscpy(noChar, XCOPY_LoadMessage(STRING_NO_CHAR));
+
+ while (!answered) {
+ XCOPY_wprintf(XCOPY_LoadMessage(STRING_SRCPROMPT), copyFrom);
+ ReadFile (GetStdHandle(STD_INPUT_HANDLE), answer, sizeof(answer),
+ &count, NULL);
+
+ answered = TRUE;
+ if (toupper(answer[0]) == noChar[0])
+ skipFile = TRUE;
+ else if (toupper(answer[0]) != yesChar[0])
+ answered = FALSE;
+ }
+ }
+
+ if (!skipFile &&
+ destAttribs != INVALID_FILE_ATTRIBUTES && !(flags & OPT_NOPROMPT)) {
+ DWORD count;
+ char answer[10];
+ BOOL answered = FALSE;
+ WCHAR yesChar[2];
+ WCHAR allChar[2];
+ WCHAR noChar[2];
+
+ /* Read the A,Y and N characters from the resource file */
+ wcscpy(yesChar, XCOPY_LoadMessage(STRING_YES_CHAR));
+ wcscpy(allChar, XCOPY_LoadMessage(STRING_ALL_CHAR));
+ wcscpy(noChar, XCOPY_LoadMessage(STRING_NO_CHAR));
+
+ while (!answered) {
+ XCOPY_wprintf(XCOPY_LoadMessage(STRING_OVERWRITE), copyTo);
+ ReadFile (GetStdHandle(STD_INPUT_HANDLE), answer, sizeof(answer),
+ &count, NULL);
+
+ answered = TRUE;
+ if (toupper(answer[0]) == allChar[0])
+ flags |= OPT_NOPROMPT;
+ else if (toupper(answer[0]) == noChar[0])
+ skipFile = TRUE;
+ else if (toupper(answer[0]) != yesChar[0])
+ answered = FALSE;
+ }
+ }
+
+ /* See if it has to exist! */
+ if (destAttribs == INVALID_FILE_ATTRIBUTES && (flags & OPT_MUSTEXIST)) {
+ skipFile = TRUE;
+ }
+
+ /* Output a status message */
+ if (!skipFile) {
+ if (flags & OPT_QUIET) {
+ /* Skip message */
+ } else if (flags & OPT_FULL) {
+ const WCHAR infostr[] = {'%', 's', ' ', '-', '>', ' ',
+ '%', 's', '\n', 0};
+
+ XCOPY_wprintf(infostr, copyFrom, copyTo);
+ } else {
+ const WCHAR infostr[] = {'%', 's', '\n', 0};
+ XCOPY_wprintf(infostr, copyFrom);
+ }
+
+ /* If allowing overwriting of read only files, remove any
+ write protection */
+ if ((destAttribs & FILE_ATTRIBUTE_READONLY) &&
+ (flags & OPT_REPLACEREAD)) {
+ SetFileAttributes(copyTo, destAttribs & ~FILE_ATTRIBUTE_READONLY);
+ }
+
+ copiedFile = TRUE;
+ if (flags & OPT_SIMULATE || flags & OPT_NOCOPY) {
+ /* Skip copy */
+ } else if (CopyFile(copyFrom, copyTo, FALSE) == 0) {
+
+ DWORD error = GetLastError();
+ XCOPY_wprintf(XCOPY_LoadMessage(STRING_COPYFAIL),
+ copyFrom, copyTo, error);
+ XCOPY_FailMessage(error);
+
+ if (flags & OPT_IGNOREERRORS) {
+ skipFile = TRUE;
+ } else {
+ return RC_WRITEERROR;
+ }
+ }
+
+ /* If /M supplied, remove the archive bit after successful copy */
+ if (!skipFile) {
+ if ((srcAttribs & FILE_ATTRIBUTE_ARCHIVE) &&
+ (flags & OPT_REMOVEARCH)) {
+ SetFileAttributes(copyFrom, (srcAttribs & ~FILE_ATTRIBUTE_ARCHIVE));
+ }
+ filesCopied++;
+ }
+ }
+ }
+
+ /* Find next file */
+ findres = FindNextFile(h, finddata);
+ }
+ FindClose(h);
+
+ /* Search 2 - do subdirs */
+ if (flags & OPT_RECURSIVE) {
+ lstrcpyW(inputpath, srcstem);
+ lstrcatW(inputpath, wchr_star);
+ findres = TRUE;
+ WINE_TRACE("Processing subdirs with spec: %s\n", wine_dbgstr_w(inputpath));
+
+ h = FindFirstFile(inputpath, finddata);
+ while (h != INVALID_HANDLE_VALUE && findres) {
+
+ /* Only looking for dirs */
+ if ((finddata->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
+ (lstrcmpW(finddata->cFileName, wchr_dot) != 0) &&
+ (lstrcmpW(finddata->cFileName, wchr_dotdot) != 0)) {
+
+ WINE_TRACE("Handling subdir: %s\n", wine_dbgstr_w(finddata->cFileName));
+
+ /* Make up recursive information */
+ lstrcpyW(inputpath, srcstem);
+ lstrcatW(inputpath, finddata->cFileName);
+ lstrcatW(inputpath, wchr_slash);
+
+ lstrcpyW(outputpath, deststem);
+ if (*destspec == 0x00) {
+ lstrcatW(outputpath, finddata->cFileName);
+
+ /* If /E is supplied, create the directory now */
+ if ((flags & OPT_EMPTYDIR) &&
+ !(flags & OPT_SIMULATE))
+ XCOPY_CreateDirectory(outputpath);
+
+ lstrcatW(outputpath, wchr_slash);
+ }
+
+ XCOPY_DoCopy(inputpath, srcspec, outputpath, destspec, flags);
+ }
+
+ /* Find next one */
+ findres = FindNextFile(h, finddata);
+ }
+ }
+
+ /* free up memory */
+ HeapFree(GetProcessHeap(), 0, finddata);
+ HeapFree(GetProcessHeap(), 0, inputpath);
+ HeapFree(GetProcessHeap(), 0, outputpath);
+
+ return 0;
+}
+
+/* =========================================================================
+ * Routine copied from cmd.exe md command -
+ * This works recursivly. so creating dir1\dir2\dir3 will create dir1 and
+ * dir2 if they do not already exist.
+ * ========================================================================= */
+static BOOL XCOPY_CreateDirectory(const WCHAR* path)
+{
+ int len;
+ WCHAR *new_path;
+ BOOL ret = TRUE;
+
+ new_path = HeapAlloc(GetProcessHeap(),0, sizeof(WCHAR) * (lstrlenW(path)+1));
+ lstrcpyW(new_path,path);
+
+ while ((len = lstrlenW(new_path)) && new_path[len - 1] == '\\')
+ new_path[len - 1] = 0;
+
+ while (!CreateDirectory(new_path,NULL))
+ {
+ WCHAR *slash;
+ DWORD last_error = GetLastError();
+ if (last_error == ERROR_ALREADY_EXISTS)
+ break;
+
+ if (last_error != ERROR_PATH_NOT_FOUND)
+ {
+ ret = FALSE;
+ break;
+ }
+
+ if (!(slash = wcsrchr(new_path,'\\')) && ! (slash = wcsrchr(new_path,'/')))
+ {
+ ret = FALSE;
+ break;
+ }
+
+ len = slash - new_path;
+ new_path[len] = 0;
+ if (!XCOPY_CreateDirectory(new_path))
+ {
+ ret = FALSE;
+ break;
+ }
+ new_path[len] = '\\';
+ }
+ HeapFree(GetProcessHeap(),0,new_path);
+ return ret;
+}
+
+/* =========================================================================
+ * Process the /EXCLUDE: file list, building up a list of substrings to
+ * avoid copying
+ * Returns TRUE on any failure
+ * ========================================================================= */
+static BOOL XCOPY_ProcessExcludeList(WCHAR* parms) {
+
+ WCHAR *filenameStart = parms;
+
+ WINE_TRACE("/EXCLUDE parms: '%s'\n", wine_dbgstr_w(parms));
+ excludeList = NULL;
+
+ while (*parms && *parms != ' ' && *parms != '/') {
+
+ /* If found '+' then process the file found so far */
+ if (*parms == '+') {
+ if (XCOPY_ProcessExcludeFile(filenameStart, parms)) {
+ return TRUE;
+ }
+ filenameStart = parms+1;
+ }
+ parms++;
+ }
+
+ if (filenameStart != parms) {
+ if (XCOPY_ProcessExcludeFile(filenameStart, parms)) {
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+/* =========================================================================
+ * Process a single file from the /EXCLUDE: file list, building up a list
+ * of substrings to avoid copying
+ * Returns TRUE on any failure
+ * ========================================================================= */
+static BOOL XCOPY_ProcessExcludeFile(WCHAR* filename, WCHAR* endOfName) {
+
+ WCHAR endChar = *endOfName;
+ WCHAR buffer[MAXSTRING];
+ FILE *inFile = NULL;
+ const WCHAR readTextMode[] = {'r', 't', 0};
+
+ /* Null terminate the filename (temporarily updates the filename hence
+ parms not const) */
+ *endOfName = 0x00;
+
+ /* Open the file */
+ inFile = _wfopen(filename, readTextMode);
+ if (inFile == NULL) {
+ XCOPY_wprintf(XCOPY_LoadMessage(STRING_OPENFAIL), filename);
+ *endOfName = endChar;
+ return TRUE;
+ }
+
+ /* Process line by line */
+ while (fgetws(buffer, sizeof(buffer), inFile) != NULL) {
+ EXCLUDELIST *thisEntry;
+ int length = lstrlenW(buffer);
+
+ /* Strip CRLF */
+ buffer[length-1] = 0x00;
+
+ /* If more than CRLF */
+ if (length > 1) {
+ thisEntry = HeapAlloc(GetProcessHeap(), 0, sizeof(EXCLUDELIST));
+ thisEntry->next = excludeList;
+ excludeList = thisEntry;
+ thisEntry->name = HeapAlloc(GetProcessHeap(), 0,
+ (length * sizeof(WCHAR))+1);
+ lstrcpyW(thisEntry->name, buffer);
+ CharUpperBuff(thisEntry->name, length);
+ WINE_TRACE("Read line : '%s'\n", wine_dbgstr_w(thisEntry->name));
+ }
+ }
+
+ /* See if EOF or error occurred */
+ if (!feof(inFile)) {
+ XCOPY_wprintf(XCOPY_LoadMessage(STRING_READFAIL), filename);
+ *endOfName = endChar;
+ return TRUE;
+ }
+
+ /* Revert the input string to original form, and cleanup + return */
+ *endOfName = endChar;
+ fclose(inFile);
+ return FALSE;
+}
+
+/* =========================================================================
+ * Load a string from the resource file, handling any error
+ * Returns string retrieved from resource file
+ * ========================================================================= */
+static WCHAR *XCOPY_LoadMessage(UINT id) {
+ static WCHAR msg[MAXSTRING];
+ const WCHAR failedMsg[] = {'F', 'a', 'i', 'l', 'e', 'd', '!', 0};
+
+ if (!LoadString(GetModuleHandle(NULL), id, msg, sizeof(msg))) {
+ WINE_FIXME("LoadString failed with %d\n", GetLastError());
+ lstrcpyW(msg, failedMsg);
+ }
+ return msg;
+}
+
+/* =========================================================================
+ * Load a string for a system error and writes it to the screen
+ * Returns string retrieved from resource file
+ * ========================================================================= */
+static void XCOPY_FailMessage(DWORD err) {
+ LPWSTR lpMsgBuf;
+ int status;
+
+ status = FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER |
+ FORMAT_MESSAGE_FROM_SYSTEM,
+ NULL, err, 0,
+ (LPTSTR) &lpMsgBuf, 0, NULL);
+ if (!status) {
+ WINE_FIXME("FIXME: Cannot display message for error %d, status %d\n",
+ err, GetLastError());
+ } else {
+ const WCHAR infostr[] = {'%', 's', '\n', 0};
+ XCOPY_wprintf(infostr, lpMsgBuf);
+ LocalFree ((HLOCAL)lpMsgBuf);
+ }
+}
+
+/* =========================================================================
+ * Output a formatted unicode string. Ideally this will go to the console
+ * and hence required WriteConsoleW to output it, however if file i/o is
+ * redirected, it needs to be WriteFile'd using OEM (not ANSI) format
+ * ========================================================================= */
+int XCOPY_wprintf(const WCHAR *format, ...) {
+
+ static WCHAR *output_bufW = NULL;
+ static char *output_bufA = NULL;
+ static BOOL toConsole = TRUE;
+ static BOOL traceOutput = FALSE;
+#define MAX_WRITECONSOLE_SIZE 65535
+
+ va_list parms;
+ DWORD len, nOut;
+ DWORD res = 0;
+
+ /*
+ * Allocate buffer to use when writing to console
+ * Note: Not freed - memory will be allocated once and released when
+ * xcopy ends
+ */
+
+ if (!output_bufW) output_bufW = HeapAlloc(GetProcessHeap(), 0,
+ MAX_WRITECONSOLE_SIZE);
+ if (!output_bufW) {
+ WINE_FIXME("Out of memory - could not allocate 2 x 64K buffers\n");
+ return 0;
+ }
+
+ /* Use wvsprintf to store output into unicode buffer */
+ va_start(parms, format);
+ len = vswprintf(output_bufW, format, parms);
+ va_end(parms);
+
+ /* Try to write as unicode all the time we think its a console */
+ if (toConsole) {
+ res = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE),
+ output_bufW, len, &nOut, NULL);
+ }
+
+ /* If writing to console has failed (ever) we assume its file
+ i/o so convert to OEM codepage and output */
+ if (!res) {
+ BOOL usedDefaultChar = FALSE;
+ DWORD convertedChars;
+
+ toConsole = FALSE;
+
+ /*
+ * Allocate buffer to use when writing to file. Not freed, as above
+ */
+ if (!output_bufA) output_bufA = HeapAlloc(GetProcessHeap(), 0,
+ MAX_WRITECONSOLE_SIZE);
+ if (!output_bufA) {
+ WINE_FIXME("Out of memory - could not allocate 2 x 64K buffers\n");
+ return 0;
+ }
+
+ /* Convert to OEM, then output */
+ convertedChars = WideCharToMultiByte(GetConsoleOutputCP(), 0, output_bufW,
+ len, output_bufA, MAX_WRITECONSOLE_SIZE,
+ "?", &usedDefaultChar);
+ WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), output_bufA, convertedChars,
+ &nOut, FALSE);
+ }
+
+ /* Trace whether screen or console */
+ if (!traceOutput) {
+ WINE_TRACE("Writing to console? (%d)\n", toConsole);
+ traceOutput = TRUE;
+ }
+ return nOut;
+}
projects / reactos.git / commitdiff