xcopy.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <wine/debug.h>
#include <wine/unicode.h>
#include "xcopy.h"

Include dependency graph for xcopy.c:

Go to the source code of this file.

Classes
struct	_EXCLUDELIST

Macros
#define	MAX_WRITECONSOLE_SIZE   65535

Typedefs
typedef struct _EXCLUDELIST	EXCLUDELIST

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (xcopy)
static WCHAR *	XCOPY_LoadMessage (UINT id)
static int WINAPIV	XCOPY_wprintf (const WCHAR *format,...)
static void	XCOPY_FailMessage (DWORD err)
static BOOL	XCOPY_CreateDirectory (const WCHAR *path)
static BOOL	XCOPY_ProcessExcludeFile (WCHAR *filename, WCHAR *endOfName)
static BOOL	XCOPY_ProcessExcludeList (WCHAR *parms)
static int	XCOPY_DoCopy (WCHAR *srcstem, WCHAR *srcspec, WCHAR *deststem, WCHAR *destspec, DWORD flags)
static BOOL	is_whitespace (WCHAR c)
static WCHAR *	skip_whitespace (WCHAR *p)
static BOOL	is_digit (WCHAR c)
static int	find_end_of_word (const WCHAR *word, WCHAR **end)
static void	strip_quotes (WCHAR *word, WCHAR **end)
static int	XCOPY_ParseCommandLine (WCHAR *suppliedsource, WCHAR *supplieddestination, DWORD *pflags)
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)
int	wmain (int argc, WCHAR *argvW[])

Variables
static ULONG	filesCopied = 0
static EXCLUDELIST *	excludeList = NULL
static FILETIME	dateRange
static const WCHAR	wchr_slash [] = {'\\', 0}
static const WCHAR	wchr_star [] = {'*', 0}
static const WCHAR	wchr_dot [] = {'.', 0}
static const WCHAR	wchr_dotdot [] = {'.', '.', 0}
static WCHAR	copyFrom [MAX_PATH]
static WCHAR	copyTo [MAX_PATH]

Macro Definition Documentation

MAX_WRITECONSOLE_SIZE

#define MAX_WRITECONSOLE_SIZE   65535

Typedef Documentation

EXCLUDELIST

typedef struct _EXCLUDELIST EXCLUDELIST

Function Documentation

find_end_of_word()

static int find_end_of_word ( const WCHAR *  word, WCHAR **  end  )

static

Definition at line 679 of file xcopy.c.

{
    BOOL in_quotes = FALSE;
    const WCHAR *ptr = word;
    for (;;) {
        for (; *ptr != '\0' && *ptr != '"' &&
                 (in_quotes || !is_whitespace(*ptr)); ptr++);
        if (*ptr == '"') {
            in_quotes = !in_quotes;
            ptr++;
        }
        /* Odd number of double quotes is illegal for XCOPY */
        if (in_quotes && *ptr == '\0')
            return RC_INITERROR;
        if (*ptr == '\0' || (!in_quotes && is_whitespace(*ptr)))
            break;
    }
    *end = (WCHAR*)ptr;
    return RC_OK;
}

Referenced by XCOPY_ParseCommandLine().

is_digit()

static BOOL is_digit ( WCHAR  c )

inlinestatic

Definition at line 670 of file xcopy.c.

{
    return c >= '0' && c <= '9';
}

is_whitespace()

static BOOL is_whitespace ( WCHAR  c )

inlinestatic

Definition at line 659 of file xcopy.c.

{
    return c == ' ' || c == '\t';
}

Referenced by find_end_of_word(), and skip_whitespace().

skip_whitespace()

static WCHAR * skip_whitespace ( WCHAR *  p )

static

Definition at line 664 of file xcopy.c.

{
    for (; *p && is_whitespace(*p); p++);
    return p;
}

strip_quotes()

static void strip_quotes ( WCHAR *  word, WCHAR **  end  )

static

Definition at line 701 of file xcopy.c.

{
    WCHAR *rp, *wp;
    for (rp = word, wp = word; *rp != '\0'; rp++) {
        if (*rp == '"')
            continue;
        if (wp < rp)
            *wp = *rp;
        wp++;
    }
    *wp = '\0';
    *end = wp;
}

Referenced by next_part(), trim(), and XCOPY_ParseCommandLine().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

xcopy

)

wmain()

int wmain	(	int	argc,
		WCHAR *	argvW[]
	)

Definition at line 1091 of file xcopy.c.

{
    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};
 
    /* Preinitialize flags based on COPYCMD */
    if (GetEnvironmentVariableW(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;
 
    /*
     * Parse the command line
     */
    if ((rc = XCOPY_ParseCommandLine(suppliedsource, supplieddestination,
                                     &flags)) != RC_OK) {
        if (rc == RC_HELP)
            return RC_OK;
        else
            return rc;
    }
 
    /* 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);
    if (rc != RC_OK) return rc;
 
    /* Extract required information from destination specification */
    rc = XCOPY_ProcessDestParm(supplieddestination, destinationstem,
                               destinationspec, sourcespec, flags);
    if (rc != RC_OK) return rc;
 
    /* 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);
    }
    return rc;
 
}

XCOPY_CreateDirectory()

static BOOL XCOPY_CreateDirectory ( const WCHAR *  path )

static

Definition at line 203 of file xcopy.c.

{
    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 (!CreateDirectoryW(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;
}

Referenced by XCOPY_CreateDirectory(), and XCOPY_DoCopy().

XCOPY_DoCopy()

static int XCOPY_DoCopy ( WCHAR *  srcstem, WCHAR *  srcspec, WCHAR *  deststem, WCHAR *  destspec, DWORD  flags  )

static

Definition at line 347 of file xcopy.c.

{
    WIN32_FIND_DATAW *finddata;
    HANDLE          h;
    BOOL            findres = TRUE;
    WCHAR           *inputpath, *outputpath;
    BOOL            copiedFile = FALSE;
    DWORD           destAttribs, srcAttribs;
    BOOL            skipFile;
    int             ret = 0;
 
    /* Allocate some working memory on heap to minimize footprint */
    finddata = HeapAlloc(GetProcessHeap(), 0, sizeof(WIN32_FIND_DATAW));
    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 = FindFirstFileW(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 = CreateFileW(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);
                CharUpperBuffW(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[]   = {'%', '1', ' ', '-', '>', ' ',
                                               '%', '2', '\n', 0};
 
                    XCOPY_wprintf(infostr, copyFrom, copyTo);
                } else {
                    const WCHAR infostr[] = {'%', '1', '\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)) {
                    SetFileAttributesW(copyTo, destAttribs & ~FILE_ATTRIBUTE_READONLY);
                }
 
                copiedFile = TRUE;
                if (flags & OPT_SIMULATE || flags & OPT_NOCOPY) {
                    /* Skip copy */
                } else if (CopyFileW(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 {
                        ret = RC_WRITEERROR;
                        goto cleanup;
                    }
                } else {
 
                    if (!skipFile) {
                        /* If keeping attributes, update the destination attributes
                           otherwise remove the read only attribute                 */
                        if (flags & OPT_KEEPATTRS) {
                            SetFileAttributesW(copyTo, srcAttribs | FILE_ATTRIBUTE_ARCHIVE);
                        } else {
                            SetFileAttributesW(copyTo,
                                     (GetFileAttributesW(copyTo) & ~FILE_ATTRIBUTE_READONLY));
                        }
 
                        /* If /M supplied, remove the archive bit after successful copy */
                        if ((srcAttribs & FILE_ATTRIBUTE_ARCHIVE) &&
                            (flags & OPT_REMOVEARCH)) {
                            SetFileAttributesW(copyFrom, (srcAttribs & ~FILE_ATTRIBUTE_ARCHIVE));
                        }
                        filesCopied++;
                    }
                }
            }
        }
 
        /* Find next file */
        findres = FindNextFileW(h, finddata);
    }
    FindClose(h);
 
    /* Search 2 - do subdirs */
    if (flags & OPT_RECURSIVE) {
 
        /* If /E is supplied, create the directory now */
        if ((flags & OPT_EMPTYDIR) &&
           !(flags & OPT_SIMULATE)) {
            XCOPY_CreateDirectory(deststem);
        }
 
        lstrcpyW(inputpath, srcstem);
        lstrcatW(inputpath, wchr_star);
        findres = TRUE;
        WINE_TRACE("Processing subdirs with spec: %s\n", wine_dbgstr_w(inputpath));
 
        h = FindFirstFileW(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);
                    lstrcatW(outputpath, wchr_slash);
                }
 
                XCOPY_DoCopy(inputpath, srcspec, outputpath, destspec, flags);
            }
 
            /* Find next one */
            findres = FindNextFileW(h, finddata);
        }
        FindClose(h);
    }
 
cleanup:
 
    /* free up memory */
    HeapFree(GetProcessHeap(), 0, finddata);
    HeapFree(GetProcessHeap(), 0, inputpath);
    HeapFree(GetProcessHeap(), 0, outputpath);
 
    return ret;
}

Referenced by wmain(), and XCOPY_DoCopy().

XCOPY_FailMessage()

static void XCOPY_FailMessage ( DWORD  err )

static

Definition at line 179 of file xcopy.c.

                                         {
    LPWSTR lpMsgBuf;
    int status;
 
    status = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                            FORMAT_MESSAGE_FROM_SYSTEM,
                            NULL, err, 0,
                            (LPWSTR) &lpMsgBuf, 0, NULL);
    if (!status) {
      WINE_FIXME("FIXME: Cannot display message for error %d, status %d\n",
                 err, GetLastError());
    } else {
      const WCHAR infostr[] = {'%', '1', '\n', 0};
      XCOPY_wprintf(infostr, lpMsgBuf);
      LocalFree ((HLOCAL)lpMsgBuf);
    }
}

Referenced by XCOPY_DoCopy(), XCOPY_ParseCommandLine(), and XCOPY_ProcessSourceParm().

XCOPY_LoadMessage()

static WCHAR * XCOPY_LoadMessage ( UINT  id )

static

Definition at line 83 of file xcopy.c.

                                         {
    static WCHAR msg[MAXSTRING];
    const WCHAR failedMsg[]  = {'F', 'a', 'i', 'l', 'e', 'd', '!', 0};
 
    if (!LoadStringW(GetModuleHandleW(NULL), id, msg, ARRAY_SIZE(msg))) {
       WINE_FIXME("LoadString failed with %d\n", GetLastError());
       lstrcpyW(msg, failedMsg);
    }
    return msg;
}

Referenced by wmain(), XCOPY_DoCopy(), XCOPY_ParseCommandLine(), XCOPY_ProcessDestParm(), and XCOPY_ProcessExcludeFile().

XCOPY_ParseCommandLine()

static int XCOPY_ParseCommandLine ( WCHAR *  suppliedsource, WCHAR *  supplieddestination, DWORD *  pflags  )

static

Definition at line 715 of file xcopy.c.

{
    const WCHAR EXCLUDE[]  = {'E', 'X', 'C', 'L', 'U', 'D', 'E', ':', 0};
    DWORD flags = *pflags;
    WCHAR *cmdline, *word, *end, *next;
    int rc = RC_INITERROR;
 
    cmdline = _wcsdup(GetCommandLineW());
    if (cmdline == NULL)
        return rc;
 
    /* Skip first arg, which is the program name */
    if ((rc = find_end_of_word(cmdline, &word)) != RC_OK)
        goto out;
    word = skip_whitespace(word);
 
    while (*word)
    {
        WCHAR first;
        if ((rc = find_end_of_word(word, &end)) != RC_OK)
            goto out;
 
        next = skip_whitespace(end);
        first = word[0];
        *end = '\0';
        strip_quotes(word, &end);
        WINE_TRACE("Processing Arg: '%s'\n", wine_dbgstr_w(word));
 
        /* First non-switch parameter is source, second is destination */
        if (first != '/') {
            if (suppliedsource[0] == 0x00) {
                lstrcpyW(suppliedsource, word);
            } else if (supplieddestination[0] == 0x00) {
                lstrcpyW(supplieddestination, word);
            } else {
                XCOPY_wprintf(XCOPY_LoadMessage(STRING_INVPARMS));
                goto out;
            }
        } 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                   */
            int skip=0;
            WCHAR *rest;
 
            while (word[0]) {
                rest = NULL;
 
                switch (toupper(word[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 'K': flags |= OPT_KEEPATTRS;     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 (CompareStringW(LOCALE_USER_DEFAULT,
                                             NORM_IGNORECASE | SORT_STRINGSORT,
                                             &word[1], 8,
                                             EXCLUDE, -1) == CSTR_EQUAL) {
                            if (XCOPY_ProcessExcludeList(&word[9])) {
                              XCOPY_FailMessage(ERROR_INVALID_PARAMETER);
                              goto out;
                            } else {
                              flags |= OPT_EXCLUDELIST;
 
                              /* Do not support concatenated switches onto exclude lists yet */
                              rest = end;
                            }
                          } else {
                              flags |= OPT_EMPTYDIR | OPT_RECURSIVE;
                          }
                          break;
 
                /* D can be /D or /D: */
                case 'D': if (word[2]==':' && is_digit(word[3])) {
                              SYSTEMTIME st;
                              WCHAR     *pos = &word[3];
                              BOOL       isError = FALSE;
                              memset(&st, 0x00, sizeof(st));
 
                              /* Microsoft xcopy's usage message implies that the date
                               * format depends on the locale, but that is false.
                               * It is hardcoded to month-day-year.
                               */
                              st.wMonth = _wtol(pos);
                              while (*pos && is_digit(*pos)) pos++;
                              if (*pos++ != '-') isError = TRUE;
 
                              if (!isError) {
                                  st.wDay = _wtol(pos);
                                  while (*pos && is_digit(*pos)) pos++;
                                  if (*pos++ != '-') isError = TRUE;
                              }
 
                              if (!isError) {
                                  st.wYear = _wtol(pos);
                                  while (*pos && is_digit(*pos)) pos++;
                                  if (st.wYear < 100) st.wYear+=2000;
                              }
 
                              /* Handle switches straight after the supplied date */
                              rest = pos;
 
                              if (!isError && SystemTimeToFileTime(&st, &dateRange)) {
                                  SYSTEMTIME st;
                                  WCHAR datestring[32], timestring[32];
 
                                  flags |= OPT_DATERANGE;
 
                                  /* Debug info: */
                                  FileTimeToSystemTime (&dateRange, &st);
                                  GetDateFormatW(0, DATE_SHORTDATE, &st, NULL, datestring,
                                                 ARRAY_SIZE(datestring));
                                  GetTimeFormatW(0, TIME_NOSECONDS, &st,
                                                 NULL, timestring, ARRAY_SIZE(timestring));
 
                                  WINE_TRACE("Date being used is: %s %s\n",
                                             wine_dbgstr_w(datestring), wine_dbgstr_w(timestring));
                              } else {
                                  XCOPY_FailMessage(ERROR_INVALID_PARAMETER);
                                  goto out;
                              }
                          } else {
                              flags |= OPT_DATENEWER;
                          }
                          break;
 
                case '-': if (toupper(word[2])=='Y') {
                              flags &= ~OPT_NOPROMPT;
                              rest = &word[3];  /* Skip over 3 characters */
                          }
                          break;
                case '?': XCOPY_wprintf(XCOPY_LoadMessage(STRING_HELP));
                          rc = RC_HELP;
                          goto out;
                case 'V':
                    WINE_FIXME("ignoring /V\n");
                    break;
                default:
                    WINE_TRACE("Unhandled parameter '%s'\n", wine_dbgstr_w(word));
                    XCOPY_wprintf(XCOPY_LoadMessage(STRING_INVPARM), word);
                    goto out;
                }
 
                /* Unless overridden above, skip over the '/' and the first character */
                if (rest == NULL) rest = &word[2];
 
                /* By now, rest should point either to the null after the
                   switch, or the beginning of the next switch if there
                   was no whitespace between them                          */
                if (!skip && *rest && *rest != '/') {
                    WINE_FIXME("Unexpected characters found and ignored '%s'\n", wine_dbgstr_w(rest));
                    skip=1;
                } else {
                    word = rest;
                }
            }
        }
        word = next;
    }
 
    /* Default the destination if not supplied */
    if (supplieddestination[0] == 0x00)
        lstrcpyW(supplieddestination, wchr_dot);
 
    *pflags = flags;
    rc = RC_OK;
 
 out:
    free(cmdline);
    return rc;
}

Referenced by wmain().

XCOPY_ProcessDestParm()

static int XCOPY_ProcessDestParm ( WCHAR *  supplieddestination, WCHAR *  stem, WCHAR *  spec, WCHAR *  srcspec, DWORD  flags  )

static

Definition at line 1005 of file xcopy.c.

{
    WCHAR  actualdestination[MAX_PATH];
    DWORD attribs;
    BOOL isDir = FALSE;
 
    /*
     * Validate the source, expanding to full path ensuring it exists
     */
    if (GetFullPathNameW(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 = GetFileAttributesW(actualdestination);
 
    if (attribs == INVALID_FILE_ATTRIBUTES) {
 
        /* If /I supplied and wildcard copy, assume directory */
        /* Also if destination ends with backslash */
        if ((flags & OPT_ASSUMEDIR &&
            (wcschr(srcspec, '?') || wcschr(srcspec, '*'))) ||
            (supplieddestination[lstrlenW(supplieddestination)-1] == '\\')) {
 
            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;
}

Referenced by wmain().

XCOPY_ProcessExcludeFile()

static BOOL XCOPY_ProcessExcludeFile ( WCHAR *  filename, WCHAR *  endOfName  )

static

Definition at line 252 of file xcopy.c.

                                                                        {
 
    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, ARRAY_SIZE(buffer), inFile) != NULL) {
        EXCLUDELIST *thisEntry;
        int length = lstrlenW(buffer);
 
        /* If more than CRLF */
        if (length > 1) {
          buffer[length-1] = 0;  /* strip CRLF */
          thisEntry = HeapAlloc(GetProcessHeap(), 0, sizeof(EXCLUDELIST));
          thisEntry->next = excludeList;
          excludeList = thisEntry;
          thisEntry->name = HeapAlloc(GetProcessHeap(), 0,
                                      (length * sizeof(WCHAR))+1);
          lstrcpyW(thisEntry->name, buffer);
          CharUpperBuffW(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;
        fclose(inFile);
        return TRUE;
    }
 
    /* Revert the input string to original form, and cleanup + return */
    *endOfName = endChar;
    fclose(inFile);
    return FALSE;
}

Referenced by XCOPY_ProcessExcludeList().

XCOPY_ProcessExcludeList()

static BOOL XCOPY_ProcessExcludeList ( WCHAR *  parms )

static

Definition at line 309 of file xcopy.c.

                                                   {
 
    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;
}

Referenced by XCOPY_ParseCommandLine().

XCOPY_ProcessSourceParm()

static int XCOPY_ProcessSourceParm ( WCHAR *  suppliedsource, WCHAR *  stem, WCHAR *  spec, DWORD  flags  )

static

Definition at line 909 of file xcopy.c.

{
    WCHAR             actualsource[MAX_PATH];
    WCHAR            *starPos;
    WCHAR            *questPos;
    DWORD             attribs;
 
    /*
     * Validate the source, expanding to full path ensuring it exists
     */
    if (GetFullPathNameW(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 = GetFileAttributesW(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];
            GetCurrentDirectoryW(ARRAY_SIZE(curdir), curdir);
            stem[0] = curdir[0];
            stem[1] = curdir[1];
            stem[2] = 0x00;
            lstrcpyW(spec, suppliedsource);
        }
    }
 
    return RC_OK;
}

Referenced by wmain().

XCOPY_wprintf()

static int WINAPIV XCOPY_wprintf ( const WCHAR *  format,   ...  )

static

Definition at line 99 of file xcopy.c.

                                                           {
 
    static WCHAR *output_bufW = NULL;
    static char  *output_bufA = NULL;
    static BOOL  toConsole    = TRUE;
    static BOOL  traceOutput  = FALSE;
#define MAX_WRITECONSOLE_SIZE 65535
 
    __ms_va_list parms;
    DWORD   nOut;
    int len;
    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*sizeof(WCHAR));
    if (!output_bufW) {
      WINE_FIXME("Out of memory - could not allocate 2 x 64K buffers\n");
      return 0;
    }
 
    __ms_va_start(parms, format);
    SetLastError(NO_ERROR);
    len = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, format, 0, 0, output_bufW,
                   MAX_WRITECONSOLE_SIZE/sizeof(*output_bufW), &parms);
    __ms_va_end(parms);
    if (len == 0 && GetLastError() != NO_ERROR) {
      WINE_FIXME("Could not format string: le=%u, fmt=%s\n", GetLastError(), wine_dbgstr_w(format));
      return 0;
    }
 
    /* Try to write as unicode whenever we think it's a console */
    if (toConsole) {
      res = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE),
                          output_bufW, len, &nOut, NULL);
    }
 
    /* If writing to console has failed (ever) we assume it's 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;
}

Referenced by wmain(), XCOPY_DoCopy(), XCOPY_FailMessage(), XCOPY_ParseCommandLine(), XCOPY_ProcessDestParm(), and XCOPY_ProcessExcludeFile().

Variable Documentation

copyFrom

WCHAR copyFrom[MAX_PATH]

static

Definition at line 75 of file xcopy.c.

Referenced by XCOPY_DoCopy().

copyTo

WCHAR copyTo[MAX_PATH]

static

Definition at line 76 of file xcopy.c.

Referenced by XCOPY_DoCopy().

dateRange

FILETIME dateRange

static

Definition at line 66 of file xcopy.c.

Referenced by XCOPY_DoCopy(), and XCOPY_ParseCommandLine().

excludeList

EXCLUDELIST* excludeList = NULL

static

Definition at line 65 of file xcopy.c.

Referenced by wmain(), XCOPY_DoCopy(), XCOPY_ProcessExcludeFile(), and XCOPY_ProcessExcludeList().

filesCopied

ULONG filesCopied = 0

static

Definition at line 64 of file xcopy.c.

Referenced by wmain(), and XCOPY_DoCopy().

wchr_dot

const WCHAR wchr_dot[] = {'.', 0}

static

Definition at line 69 of file xcopy.c.

Referenced by XCOPY_DoCopy(), and XCOPY_ParseCommandLine().

wchr_dotdot

const WCHAR wchr_dotdot[] = {'.', '.', 0}

static

Definition at line 70 of file xcopy.c.

Referenced by XCOPY_DoCopy().

wchr_slash

const WCHAR wchr_slash[] = {'\\', 0}

static

Definition at line 67 of file xcopy.c.

Referenced by XCOPY_DoCopy(), XCOPY_ProcessDestParm(), and XCOPY_ProcessSourceParm().

wchr_star

const WCHAR wchr_star[] = {'*', 0}

static

Definition at line 68 of file xcopy.c.

Referenced by XCOPY_DoCopy(), and XCOPY_ProcessSourceParm().