windows-xp/Source/XPSP1/NT/sdktools/winobj/wfcopy.c

/****************************************************************************/
/*                                                                          */
/*  WFCOPY.C -                                                              */
/*                                                                          */
/*      Windows File System File Copying Routines                           */
/*                                                                          */
/****************************************************************************/

#include "winfile.h"
#include "winnet.h"
#include "wnetcaps.h"			// WNetGetCaps()
#include "lfn.h"
#include "wfcopy.h"

#ifdef TRACECOPY
    #define dbg(x) DebugF x
#else
    #define dbg(x)
#endif

BOOL *pbConfirmAll;
CHAR szSpace[] = " ";
INT ManySource;

INT nCopyNumQueue;      // # of items in the queue
INT nCopyMaxQueue;      // size of the queue
PCOPYQUEUE pCopyQueue;      // copy queue buffer
BOOL bCopyReport;       // do notifications? bogus


LPSTR lpCopyBuffer;     // global memory for FileCopy() buffer
WORD wCopyBufferSize;       // size of this buffer

VOID APIENTRY wfYield(VOID);

INT  CopyMoveRetry(PSTR, INT);
VOID CopyError(PSTR, PSTR, INT, WORD, INT);
BOOL IsRootDirectory(PSTR pPath);
BOOL IsDirectory(PSTR pPath);

WORD ConfirmDialog(
                  HWND hDlg, WORD dlg,
                  LPSTR pFileDest, PLFNDTA pDTADest,
                  LPSTR pFileSource, PLFNDTA pDTASource,
                  BOOL bConfirmByDefault, BOOL *pbAll);

VOID MergePathName(LPSTR pPath, LPSTR pName);
BOOL IsInvalidPath(register LPSTR pPath);
WORD GetNextPair(register PCOPYROOT pcr, LPSTR pFrom, LPSTR pToPath, LPSTR pToSpec, WORD wFunc);
INT  CheckMultiple(LPSTR pInput);
VOID DialogEnterFileStuff(register HWND hwnd);
WORD SafeFileRemove(LPSTR szFileOEM);
BOOL IsWindowsFile(LPSTR szFileOEM);

INT_PTR APIENTRY ReplaceDlgProc(register HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam);


BOOL
APIENTRY
IsValidChar(
           BYTE ch,
           BOOL fPath
           )
{
    switch (ch) {
        case ';':       // terminator
        case ',':       // terminator
        case '|':       // pipe
        case '>':       // redir
        case '<':       // redir
        case '"':       // quote
            return FALSE;

        case '?':       // wc           we only do wilds here because they're
        case '*':       // wc           legal for qualifypath
        case '\\':      // path separator
        case ':':       // drive colon
        case '/':       // path sep
            return fPath;
    }

    // cannot be a control character or space
    return ch > ' ';
}



//--------------------------------------------------------------------------
//
// StripColon() -
//
// removes trailing colon if not a drive letter.
// this is to support DOS character devices (CON:, COM1: LPT1:).  DOS
// can't deal with these things having a colon on the end (so we strip it).
//
//--------------------------------------------------------------------------

PSTR
StripColon(
          register PSTR pPath
          )
{
    register INT cb = lstrlen(pPath);

    dbg(("StripColon(%s)\r\n",(LPSTR)pPath));

    {
        LPSTR pTailp = AnsiPrev( pPath, &(pPath[cb]) );
        if (cb > 2 && *pTailp == ':')
            *pTailp = 0;
    }

    return pPath;
}

/*--------------------------------------------------------------------------*/
/*                                      */
/*  FindFileName() -                            */
/*                                      */
/*--------------------------------------------------------------------------*/

/* Returns a pointer to the last component of a path string. */

PSTR
FindFileName(
            register PSTR pPath
            )
{
    register LPSTR pT;

    dbg(("FindFileName(%s);\r\n",(LPSTR)pPath));

    for (pT=pPath; *pPath; pPath=(LPSTR)AnsiNext(pPath)) {
        if ((pPath[0] == '\\' || pPath[0] == ':') && pPath[1])
            pT = pPath+1;
    }

    return (pT);
}


/*--------------------------------------------------------------------------*/
/*                                      */
/*  AppendToPath() -                            */
/*                                      */
/*--------------------------------------------------------------------------*/

/* Appends a filename to a path.  Checks the \ problem first
 *  (which is why one can't just use lstrcat())
 * Also don't append a \ to : so we can have drive-relative paths...
 * this last bit is no longer appropriate since we qualify first!
 *
 * is this relative junk needed anymore?  if not this can be
 * replaced with AddBackslash(); lstrcat()
 */

VOID
APIENTRY
AppendToPath(
            PSTR pPath,
            PSTR pMore
            )
{

    dbg(("AppendToPath(%s,%s);\r\n",(LPSTR)pPath,(LPSTR)pMore));

    /* Don't append a \ to empty paths. */
    if (*pPath) {
        LPSTR pPathBase = pPath;
        BYTE ch;

        while (*pPath)
            pPath++;

        ch = *AnsiPrev(pPathBase, pPath );
        if (ch != '\\')
            *pPath++='\\';
    }

    /* Skip any initial terminators on input. */
    while (*pMore == '\\')
        pMore = (LPSTR)AnsiNext(pMore);

    lstrcpy(pPath, pMore);
}


/*--------------------------------------------------------------------------*/
/*                                      */
/*  RemoveLast() -                              */
/*                                      */
/*--------------------------------------------------------------------------*/

/* Deletes the last component of a filename in a string. */

VOID
APIENTRY
RemoveLast(
          PSTR pFile
          )
{
    PSTR pT;

    dbg(("RemoveLast(%s);\r\n",(LPSTR)pFile));

    for (pT=pFile; *pFile; pFile=(LPSTR)AnsiNext(pFile)) {
        if (*pFile == '\\')
            pT = pFile;
        else if (*pFile == ':') {
            if (pFile[1] =='\\')
                pFile++;
            pT = pFile + 1;
        }
    }
    *pT = TEXT('\0');
}




// qualify a DOS (or LFN) file name based on the currently active window.
// this code is not careful to not write more than MAXPATHLEN characters
// into psz
//
// in:
//      psz     path to be qualified (of at least MAXPATHLEN characters)
//              ANSI string
//
// out:
//      psz     fully qualified version of input string based
//              on the current active window (current directory)
//

VOID
APIENTRY
QualifyPath(
           PSTR psz
           )
{
    INT cb, nSpaceLeft;
    CHAR szTemp[MAXPATHLEN];
    INT iDrive = 0;
    LPSTR pOrig;
    BOOL flfn = FALSE;

    STKCHK();

    dbg(("QualifyPath(%s);\r\n",(LPSTR)psz));

    /* Save it away. */
    strncpy(szTemp, psz, sizeof(szTemp));
    CheckSlashies(szTemp);
    StripColon(szTemp);

    nSpaceLeft = MAXPATHLEN;

    pOrig = szTemp;

    if (pOrig[0] == '\\' && pOrig[1] == '\\') {
        // leave the \\ in the buffer so that the various parts
        // of the UNC path will be qualified and appended.  Note
        // we must assume that UNCs are FAT's.
        psz[2] = 0;
        nSpaceLeft -= 3;
        goto GetComps;
    }

    if (pOrig[0] && pOrig[1]==':' && !IsDBCSLeadByte(pOrig[0])) {
        iDrive = DRIVEID(pOrig);

        /* Skip over the drive letter. */
        pOrig += 2;
    } else
        iDrive = GetSelectedDrive();

    flfn = IsLFNDrive(pOrig);
    #ifdef DEBUG
    if (flfn)
        dbg(("lfn qualify!\r\n"));
    else
        dbg(("normal qualify!\r\n"));
    #endif

    // on FAT devices, replace any illegal chars with underscores
    if (!flfn)
    {
        LPSTR pT;

        for (pT = pOrig; *pT; pT = (LPSTR)AnsiNext(pT));
        {
            if (!IsValidChar(*pT,TRUE))
                *pT = '_';
        }
    }

    if (pOrig[0]=='\\') {
        psz[0] = (CHAR)iDrive + (CHAR)'A';
        psz[1] = ':';
        psz[2] = '\\';
        psz[3] = 0;
        nSpaceLeft -= 4;
        pOrig++;
    } else {
        /* Get current dir of drive in path.  Also returns drive. */
        GetSelectedDirectory((WORD)(iDrive+1), psz);
        nSpaceLeft -= (lstrlen(psz) + 1);
    }

    GetComps:

    while (*pOrig && nSpaceLeft > 0) {
        /* If the component is parent dir, go up one dir.
         * If its the current dir, skip it, else add it normally
         */
        if (pOrig[0] == '.') {
            if (pOrig[1] == '.')
                RemoveLast(psz);
            else if (pOrig[1] && pOrig[1] != '\\')
                goto addcomponent;

            while (*pOrig && *pOrig != '\\')
                pOrig = (LPSTR)AnsiNext(pOrig);

            if (*pOrig)
                pOrig++;
        } else {
            LPSTR pT, pTT = NULL;

            addcomponent:
            AddBackslash(psz);
            nSpaceLeft--;

            pT = psz + lstrlen(psz);

            if (flfn) {
                // copy the component
                while (*pOrig && *pOrig != '\\') {
                    nSpaceLeft--;
                    if (IsDBCSLeadByte(*pT++ = *pOrig++)) {
                        if (nSpaceLeft <= 0) {
                            pT--;
                        } else {
                            *pT++ = *pOrig++;
                            nSpaceLeft--;
                        }
                    }
                }
            } else {
                // copy the filename (up to 8 chars)
                for (cb = 0; *pOrig && *pOrig != '\\' && *pOrig != '.' && nSpaceLeft > 0;) {
                    if (cb < 8) {
                        cb++;
                        nSpaceLeft--;
                        if (IsDBCSLeadByte(*pT++ = *pOrig++)) {
                            if (nSpaceLeft <= 0) {
                                pT--;
                            } else {
                                cb++;
                                *pT++ = *pOrig++;
                                nSpaceLeft--;
                            }
                        }
                    } else {
                        pOrig = AnsiNext(pOrig);
                    }
                }

                // if there's an extension, copy it, up to 3 chars
                if (*pOrig == '.' && nSpaceLeft > 0) {
                    *pT++ = '.';
                    nSpaceLeft--;
                    pOrig++;
                    for (cb = 0; *pOrig && *pOrig != '\\' && nSpaceLeft > 0;) {
                        if (*pOrig == '.')
                            cb = 3;

                        if (cb < 3) {
                            cb++;
                            nSpaceLeft--;
                            if (IsDBCSLeadByte(*pT++ = *pOrig++)) {
                                if (nSpaceLeft <= 0) {
                                    pT--;
                                } else {
                                    cb++;
                                    *pT++ = *pOrig++;
                                    nSpaceLeft--;
                                }
                            }
                        } else {
                            pOrig = AnsiNext(pOrig);
                        }
                    }
                }
            }

            // skip the backslash

            if (*pOrig)
                pOrig++;

            // null terminate for next pass...
            *pT = 0;

        }
    }

    StripBackslash(psz);

    // remove any trailing dots

    if (*(psz + lstrlen(psz) - 1) == '.')
        *(psz + lstrlen(psz) - 1) = 0;

}



/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  IsRootDirectory() -                                                     */
/*                                                                          */
/*--------------------------------------------------------------------------*/

BOOL
IsRootDirectory(
               register LPSTR pPath
               )
{
    if (!IsDBCSLeadByte( *pPath )) {
        if (!lstrcmpi(pPath+1, ":\\"))
            return (TRUE);
        if (!lstrcmpi(pPath+1, ":"))
            return TRUE;
    }
    if (!lstrcmpi(pPath, "\\"))
        return (TRUE);
    return (FALSE);
}

// returns:
//  TRUE    if pPath is a directory, including the root and
//      relative paths "." and ".."
//  FALSE   not a dir

BOOL
IsDirectory(
           PSTR pPath
           )
{
    PSTR pT;
    CHAR szTemp[MAXPATHLEN];

    STKCHK();

    if (IsRootDirectory(pPath))
        return TRUE;

    // check for "." and ".."

    pT = FindFileName(pPath);
    if (pT[0] == '.') {
        if (!pT[1] || pT[1] == '.')
            return TRUE;
    }

    lstrcpy(szTemp, pPath);
    FixAnsiPathForDos(szTemp);

    return WFIsDir(szTemp);
}


//
// note: this has the side effect of setting the
// current drive to the new disk if it is successful
//

WORD
APIENTRY
IsTheDiskReallyThere(
                    HWND hwnd,
                    register LPSTR pPath,
                    WORD wFunc
                    )
{
    INT           i;
    register INT  drive;
    CHAR szTemp[MAXPATHLEN];
    INT err = 0;
    WORD wError;

    STKCHK();

#ifdef DEBUG
    {
        char szMsg[200];

        wsprintf(szMsg, "IsTheDiskReallyThere(%s)\r\n",(LPSTR)pPath);
        OutputDebugString(szMsg);
    }
#endif

    if (pPath[1]==':' && !IsDBCSLeadByte( *pPath ))
        drive = DRIVEID(pPath);
    else
        return TRUE;

Retry:

    err = SheGetDir(drive + 1, szTemp);

    if (err)
        goto DiskNotThere;

    return TRUE;

    DiskNotThere:
    wError = (WORD)GetExtendedError();

    if (wError == 0x15) {
        // drive not ready (no disk in the drive)

        LoadString(hAppInstance, IDS_COPYERROR + wFunc, szTitle, sizeof(szTitle));
        LoadString(hAppInstance, IDS_DRIVENOTREADY, szTemp, sizeof(szTemp));
        wsprintf(szMessage, szTemp, drive + 'A');
        if (MessageBox(hwnd, szMessage, szTitle, MB_ICONEXCLAMATION | MB_RETRYCANCEL) == IDRETRY)
            goto Retry;
        else
            return FALSE;
    } else if (wError == 0x1F) {
        // general failue (disk not formatted)

        LoadString(hAppInstance, IDS_COPYERROR + wFunc, szTitle, sizeof(szTitle));
        LoadString(hAppInstance, IDS_UNFORMATTED, szTemp, sizeof(szTemp));
        wsprintf(szMessage, szTemp, drive + 'A');
        if (MessageBox(hwnd, szMessage, szTitle, MB_ICONEXCLAMATION| MB_YESNO) == IDYES) {
            HWND hwndSave;

            // this is ugly: hdlgProgress is a global that is used
            // by the copy code and the format code.  this should
            // be rewritten so it is not a global (hdlgProgress should
            // be passed to all QueryAbort() functions, etc)

            hwndSave = hdlgProgress;
            nLastDriveInd = 0;
            for (i = 0; i < cDrives; i++) {
                if (IsRemovableDrive(rgiDrive[i])) {
                    if (rgiDrive[i] == drive)
                        break;
                    nLastDriveInd++;
                }
            }
            fFormatFlags |= FF_ONLYONE;     // alow only one format

            if (FormatDiskette(hwnd) != TRUE) {
                hdlgProgress = hwndSave;
                return FALSE;
            }
            hdlgProgress = hwndSave;
            goto Retry;
        } else
            return FALSE;
    }

    LoadString(hAppInstance, IDS_COPYERROR + wFunc, szTitle, 32);
    LoadString(hAppInstance, IDS_NOSUCHDRIVE, szTemp, sizeof(szTemp));
    wsprintf(szMessage, szTemp, drive + 'A');
    MessageBox(hwnd, szMessage, szTitle, MB_ICONHAND);

    return FALSE;
}



VOID
BuildDateLine(
             LPSTR szTemp,
             PLFNDTA plfndta
             )
{
    wsprintf(szTemp, szBytes, plfndta->fd.nFileSizeLow);
    lstrcat(szTemp, szSpace);
    PutDate(&plfndta->fd.ftLastWriteTime, szTemp + lstrlen(szTemp));
    lstrcat(szTemp, szSpace);
    PutTime(&plfndta->fd.ftLastWriteTime, szTemp + lstrlen(szTemp));
}


typedef struct {
    LPSTR pFileDest;
    LPSTR pFileSource;
    PLFNDTA plfndtaDest;
    PLFNDTA plfndtaSrc;
    INT bWriteProtect;
} PARAM_REPLACEDLG, *LPPARAM_REPLACEDLG;


VOID
SetDlgItemPath(
              HWND hDlg,
              INT id,
              LPSTR pszPath
              )
{
    RECT rc;
    HDC hdc;
    HFONT hFont;
    CHAR szPath[MAXPATHLEN+1];      // can have one extra char
    HWND hwnd;

    hwnd = GetDlgItem(hDlg, id);

    if (!hwnd)
        return;

    lstrcpy(szPath, pszPath);

    GetClientRect(hwnd, &rc);

    hdc = GetDC(hDlg);
    hFont = (HANDLE)SendMessage(hwnd, WM_GETFONT, 0, 0L);
    if (hFont = SelectObject(hdc, hFont)) {
        CompactPath(hdc, szPath, (WORD)rc.right);
        SelectObject(hdc, hFont);
    }
    ReleaseDC(hDlg, hdc);
    SetWindowText(hwnd, szPath);
}



INT_PTR
APIENTRY
ReplaceDlgProc(
              register HWND hDlg,
              UINT wMsg,
              WPARAM wParam,
              LPARAM lParam
              )
{
    STKCHK();

    switch (wMsg) {
        case WM_INITDIALOG:
            {
#define lpdlgparams ((LPPARAM_REPLACEDLG)lParam)

                if (lpdlgparams->bWriteProtect) {
                    LoadString(hAppInstance, IDS_WRITEPROTECTFILE, szMessage, sizeof(szMessage));
                    SetDlgItemText(hDlg, IDD_STATUS, szMessage);
                }

                EnableWindow(GetDlgItem(hDlg, IDD_YESALL), !lpdlgparams->bWriteProtect && ManySource);

                lstrcpy(szMessage, lpdlgparams->pFileSource);
                lstrcat(szMessage, "?");
                SetDlgItemPath(hDlg, IDD_FROM, szMessage);

                if (lpdlgparams->pFileDest) {
                    BuildDateLine(szMessage, lpdlgparams->plfndtaSrc);
                    SetDlgItemText(hDlg, IDD_DATE2, szMessage);

                    SetDlgItemPath(hDlg, IDD_TO, lpdlgparams->pFileDest);
                    BuildDateLine(szMessage, lpdlgparams->plfndtaDest);
                    SetDlgItemText(hDlg, IDD_DATE1, szMessage);
                }

                break;
            }

        case WM_COMMAND:
            {
                WORD id;

                id = GET_WM_COMMAND_ID(wParam, lParam);
                switch (id) {
                    case IDD_HELP:
                        goto DoHelp;

                    case IDD_FLAGS:
                        break;

                    case IDD_YESALL:
                        *pbConfirmAll = TRUE;
                        id = IDYES;
                        // fall through
                    case IDYES:
                        // fall through
                    default:        // this is IDNO and IDCANCEL
                        EndDialog(hDlg, id);
                        return FALSE;
                }
            }
            break;

        default:
            if (wMsg == wHelpMessage) {
                DoHelp:
                WFHelp(hDlg);

                return TRUE;
            } else
                return FALSE;
    }
    return TRUE;
}





WORD
ConfirmDialog(
             HWND hDlg, WORD dlg,
             LPSTR pFileDest, PLFNDTA plfndtaDest,
             LPSTR pFileSource, PLFNDTA plfndtaSrc,
             BOOL bConfirmByDefault,
             BOOL *pbAll
             )
{
    INT w;
    PARAM_REPLACEDLG params;

    params.pFileDest = pFileDest;
    params.pFileSource = pFileSource;
    params.plfndtaDest = plfndtaDest;
    params.plfndtaSrc = plfndtaSrc;
    params.bWriteProtect = FALSE;

    pbConfirmAll = pbAll;         // set global for dialog box

    if (plfndtaDest->fd.dwFileAttributes & (ATTR_READONLY | ATTR_SYSTEM | ATTR_HIDDEN)) {
        DWORD dwSave = dwContext;

        dwContext = IDH_DLGFIRST + dlg;

        params.bWriteProtect = TRUE;
        w = (INT)DialogBoxParam(hAppInstance, MAKEINTRESOURCE(dlg), hDlg, ReplaceDlgProc, (LPARAM)&params);
        dwContext = dwSave;

        if (w == IDYES) {
            lstrcpy(szMessage, pFileDest ? (LPSTR)pFileDest : (LPSTR)pFileSource);
            FixAnsiPathForDos(szMessage);
            WFSetAttr(szMessage, plfndtaDest->fd.dwFileAttributes & ~(ATTR_READONLY|ATTR_HIDDEN|ATTR_SYSTEM));
        }

    } else if (!bConfirmByDefault || *pbConfirmAll) {
        w = IDYES;
    } else {
        DWORD dwSave = dwContext;

        dwContext = IDH_DLGFIRST + dlg;
        w = (INT)DialogBoxParam(hAppInstance, MAKEINTRESOURCE(dlg), hDlg, ReplaceDlgProc, (LPARAM)&params);
        dwContext = dwSave;
    }

    if (w == -1)
        w = DE_INSMEM;

    return (WORD)w;
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  NetCheck() -                                                            */
/*                                                                          */
/*--------------------------------------------------------------------------*/

/* check rmdirs and mkdirs with the net driver
 */

WORD
APIENTRY
NetCheck(
        LPSTR pPath,
        WORD wType
        )
{
    UNREFERENCED_PARAMETER(pPath);
    UNREFERENCED_PARAMETER(wType);

    return WN_SUCCESS;
}



/*** FIX30: This "could use some cleaning up." ***/
/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  MergePathName() -                                               */
/*                                                                          */
/*--------------------------------------------------------------------------*/

/*  Used to generate destination filenames given a pattern and an original
 *  source name.  ? is replaced by the corresponding character in the source,
 *  and * is replaced by the remainder of the source name.
 *
 *  pPath   path with wildcards to be expanded
 *  pName   mask used to expand pName
 *
 * DBCS by 07/21/90 - Yukinin
 *
 */

VOID
MergePathName(
             LPSTR pPath,
             LPSTR pName
             )
{
    INT   i;
    INT   cch;
    LPSTR pWild, p2, pEnd;
    BOOL  bNoDir  = FALSE;
    CHAR  szWildPart[13];

    // if there are no wild cards the destination path does not need merging.
    if (!IsWild(pPath))
        return;

    if (LFNMergePath(pPath,pName))
        return;

    // copy only 8.3... this part may not be fully qualified for rename
    pWild = FindFileName(pPath);

    for (p2=szWildPart,i=0; *pWild && *pWild != '.' && i<8; i++, pWild++, p2++) {
        *p2 = *pWild;
        if (IsDBCSLeadByte(*pWild)) {
            if (i == 7)
                break;
            *(++p2) = *(++pWild);
            i++;
        }
    }

    while (*pWild && *pWild != '.')
        pWild = (LPSTR)AnsiNext(pWild);

    if (*pWild == '.') {
        *p2++ = '.';
        pWild++;
        for (i=0; *pWild && i < 3; i++, pWild++, p2++) {
            *p2 = *pWild;
            if (IsDBCSLeadByte( *pWild )) {
                if (i == 2)
                    break;
                *(++p2) = *(++pWild);
                i++;
            }
        }
    }
    *p2 = 0;

    // szWildPart now has the 8.3 form of the wildcard mask

    RemoveLast(pPath);
    AddBackslash(pPath);
    for (pEnd = pPath; *pEnd; pEnd++);    // point to end of string

    pWild = szWildPart;
    cch = 8;

    merge:

    for (i=0; i < cch; i+=(IsDBCSLeadByte(*pWild)?2:1), pWild=AnsiNext(pWild)) {
        switch (*pWild) {
            case '\0':
            case ' ':
            case '.':
                break;

            case '*':
                pWild--;
                /*** FALL THRU ***/

            case '?':
                if (*pName && *pName!='.')
                    *pEnd++ = *pName++;
                continue;

            default:
                *pEnd++ = *pWild;
                if (IsDBCSLeadByte(*pWild)) {
                    *pEnd++ = pWild[1];
                    if (*pName && *pName != '.')
                        pName++;
                }
                continue;
        }
        break;
    }

    while (*pName && *pName != '.')
        pName = AnsiNext(pName);
    if (*pName)
        pName++;

    while (*pWild && *pWild != '.')
        pWild = AnsiNext(pWild);
    if (*pWild)
        pWild++;

    if (*pWild) {
        *pEnd++ = '.';
        cch = 3;
        goto merge;       // do it for the extension part now
    } else {
        if (pEnd[-1]=='.')
            pEnd[-1]=0;
        else
            pEnd[0] = TEXT('\0');
    }

    QualifyPath(pPath);
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  IsInvalidPath() -                                               */
/*                                                                          */
/*--------------------------------------------------------------------------*/

/* Checks to see if a file spec is an evil character device or if it is
 * too long...
 */

BOOL
IsInvalidPath(
             register LPSTR pPath
             )
{
    CHAR  sz[9];
    INT   n = 0;

    if (lstrlen(pPath) >= MAXPATHLEN-1)
        return (TRUE);

    pPath = FindFileName(pPath);

    while (*pPath && *pPath != '.' && *pPath != ':' && n < 8) {
        if (IsDBCSLeadByte( *pPath )) {
            if (n == 7)
                break;
            sz[n++] = *pPath;
        }
        sz[n++] = *pPath++;
    }

    sz[n] = TEXT('\0');

    if (!lstrcmpi(sz,"CON"))
        return (TRUE);

    if (!lstrcmpi(sz,"MS$MOUSE"))
        return (TRUE);

    if (!lstrcmpi(sz,"EMMXXXX0"))
        return (TRUE);

    if (!lstrcmpi(sz,"CLOCK$"))
        return (TRUE);

    return (FALSE);
}


PLFNDTA CurPDTA(PCOPYROOT pcr)
{
    if (pcr->cDepth) {
        return (pcr->rgDTA + pcr->cDepth - 1);
    } else {
        return pcr->rgDTA;
    }
}


/*--------------------------------------------------------------------------*/
/*                                      */
/*  GetNextCleanup() -                          */
/*                                      */
/*--------------------------------------------------------------------------*/

VOID
GetNextCleanup(
              PCOPYROOT pcr
              )
{
    while (pcr->cDepth) {
        WFFindClose(CurPDTA(pcr));
        pcr->cDepth--;
    }
}


/* GetNameDialog
 *
 *  Runs the dialog box to prompt the user for a new filename when copying
 *  or moving from HPFS to FAT.
 */

WORD GetNameDialog(WORD, LPSTR, LPSTR);
INT_PTR  APIENTRY GetNameDlgProc(HWND,UINT,WPARAM,LPARAM);

WORD wDialogOp;
LPSTR pszDialogFrom;
LPSTR pszDialogTo;

INT_PTR
APIENTRY
GetNameDlgProc(
              HWND hwnd,
              UINT wMsg,
              WPARAM wParam,
              LPARAM lParam
              )
{
    CHAR szT[14];
    LPSTR p;
    INT i, j, cMax, fDot;

    UNREFERENCED_PARAMETER(lParam);

    switch (wMsg) {
        case WM_INITDIALOG:
            // inform the user of the old name
            SetDlgItemText(hwnd, IDD_FROM, pszDialogFrom);

            // generate a guess for the new name
            p = FindFileName(pszDialogFrom);
            for (i = j = fDot = 0, cMax = 8; *p; p++) {
                if (*p == '.') {
                    // if there was a previous dot, step back to it
                    // this way, we get the last extension
                    if (fDot)
                        i -= j+1;

                    // set number of chars to 0, put the dot in
                    j = 0;
                    szT[i++] = '.';

                    // remember we saw a dot and set max 3 chars.
                    fDot = TRUE;
                    cMax = 3;
                } else if (j < cMax && IsValidChar(*p,FALSE)) {
                    if (IsDBCSLeadByte(*p)) {
                        szT[i] = *p++;
                        if (++j >= cMax)
                            continue;
                        ++i;
                    }
                    j++;
                    szT[i++] = *p;
                }
            }
            szT[i] = 0;
            SetDlgItemText(hwnd, IDD_TO, szT);
            SendDlgItemMessage(hwnd,IDD_TO,EM_LIMITTEXT,13,0L);

            // directory the file will go into
            RemoveLast(pszDialogTo);
            SetDlgItemText(hwnd, IDD_DIR, pszDialogTo);
            break;

        case WM_COMMAND:
            switch (GET_WM_COMMAND_ID(wParam, lParam)) {
                case IDOK:
                    GetDlgItemText(hwnd,IDD_TO,szT,14);
                    AppendToPath(pszDialogTo,szT);
                    QualifyPath(pszDialogTo);
                    EndDialog(hwnd,IDOK);
                    break;

                case IDCANCEL:
                    EndDialog(hwnd,IDCANCEL);
                    break;

                case IDD_HELP:
                    goto DoHelp;

                case IDD_TO:
                    GetDlgItemText(hwnd,IDD_TO,szT,14);
                    for (p = szT; *p; p=AnsiNext(p))
                    {
                        if (!IsValidChar(*p,FALSE))
                            break;
                    }

                    EnableWindow(GetDlgItem(hwnd,IDOK),((!*p) && (p != szT)));
                    break;

                default:
                    return FALSE;
            }
            break;

        default:
            if (wMsg == wHelpMessage) {
                DoHelp:
                WFHelp(hwnd);
                return TRUE;
            }
            return FALSE;
    }

    return TRUE;
}

WORD
GetNameDialog(
             WORD wOp,
             LPSTR pFrom,
             LPSTR pTo
             )
{
    WORD wRet = -1;
    DWORD dwSave;

    dwSave = dwContext;
    dwContext = IDH_DLGFIRST + LFNTOFATDLG;

    wDialogOp = wOp;
    pszDialogFrom = pFrom;
    pszDialogTo = pTo;

    wRet = (WORD)DialogBox(hAppInstance, MAKEINTRESOURCE(LFNTOFATDLG), hdlgProgress, GetNameDlgProc);
    dwContext = dwSave;
    return wRet;
}

/*============================================================================
;
; GetNextPair
;
; The following function determines the next pair of files to copy, rename,
; move, or delete.
;
; Parameters:
;
; pcr     - Pointer to structure for recursing directory tree
; pFrom   - Source file or directory to copy
; pToPath - Path to destination file or directory
; pToSpec - Raw destination file or directory name
; wFunc   - Operation being performed.  Can be one of:
;
;           FUNC_DELETE - Delete files in pFrom
;           FUNC_RENAME - Rename files (same directory)
;           FUNC_MOVE   - Move files in pFrom to pTo (different disk)
;           FUNC_COPY   - Copy files in pFrom to pTo
;
; Return Value:  Type of operation to perform.  Can be one of:
;
;                OPER_ERROR  - Error processing filenames
;                OPER_DOFILE - Go ahead and copy, rename, or delete file
;                OPER_MKDIR  - Make a directory specified in pTo
;                OPER_RMDIR  - Remove directory
;                0           - No more files left
;
; Revision History:
;
; Modified by C. Stevens, August, 1991.  Added logic so that we would call
; IsTheDiskReallyThere only once per drive.  Also changed some of the code
; to minimize the number of calls which access the disk.
;
============================================================================*/

WORD
GetNextPair(
           PCOPYROOT pcr,
           PSTR pFrom,
           PSTR pToPath,
           PSTR pToSpec,
           WORD wFunc
           )

{
    PSTR pT;                  /* Temporary pointer */
    WORD wOp;                 /* Return value (operation to perform */
    PLFNDTA pDTA;             /* Pointer to file DTA data */
    CHAR szOEM[MAXPATHLEN+1]; /* OEM version of string */

    STKCHK();
    *pFrom = TEXT('\0');
    dbg(("GetNextPair(-,-,%s,%s,%d);\r\n", (LPSTR)pToPath, (LPSTR)pToSpec, wFunc));

    /* Keep recursing directory structure until we get to the bottom */

    while (TRUE) {
        dbg (("    top of loop....\r\n"));
        if (pcr->cDepth) {

            /* The directory we returned last call needs to be recursed. */

            pDTA = pcr->rgDTA + pcr->cDepth - 1;   // use this DTA below

            dbg (("    pcr->cDepth=%d\r\n",pcr->cDepth));

            if (pcr->fRecurse && pcr->cDepth == 1 && !pcr->rgDTA[0].fd.cFileName[0])
                /* The last one was the recursion root. */
                goto BeginDirSearch;

            if (pcr->cDepth >= (MAXDIRDEPTH - 1)) {    // reached the limit?
                wOp = OPER_ERROR | DE_PATHTODEEP;
                goto ReturnPair;
            }

            if (pcr->fRecurse && (pDTA->fd.dwFileAttributes & ATTR_DIR) &&
                !(pDTA->fd.dwFileAttributes & ATTR_RETURNED)) {

                /* Was returned on last call, begin search. */

                pDTA->fd.dwFileAttributes |= ATTR_RETURNED;

                pcr->cDepth++;
                pDTA++;

                BeginDirSearch:

                /* Search for all subfiles in directory. */

                dbg (("    BeginDirSearch\r\n"));
                AppendToPath (pcr->sz,szStarDotStar);
                goto BeginSearch;
            }

            SkipThisFile:

            /* Search for the next matching file. */

            dbg (("    SkipThisFile:\r\n"));
            if (!WFFindNext (pDTA)) {
                dbg (("    FindNext() fails\r\n"));
                WFFindClose (pDTA);

                LeaveDirectory:

                /* This spec has been exhausted... */

                pcr->cDepth--;

                /* Remove the child file spec. */

                RemoveLast (pcr->sz);
                RemoveLast (pcr->szDest);

                if (pcr->fRecurse) {

                    /* Tell the move/copy driver it can now delete
                       the source directory if necessary. */

                    wOp = OPER_RMDIR;
                    goto ReturnPair;
                }

                /* Not recursing, get more stuff. */

                continue;
            }

            ProcessSearchResult:

            /* Got a file or dir in the DTA which matches the wild card
                originally passed in...  */

            dbg (("     ProcessSearchResult:\r\n"));
            dbg (("     found %s\r\n",(LPSTR)pDTA->fd.cFileName));
            if (pDTA->fd.dwFileAttributes & ATTR_DIR) {

                /* Ignore directories if we're not recursing. */

                if (!pcr->fRecurse)
                    goto SkipThisFile;

                /* Skip the current and parent directories. */

                if (pDTA->fd.cFileName[0]=='.') {
                    if (!pDTA->fd.cFileName[1] || pDTA->fd.cFileName[1] == '.')
                        goto SkipThisFile;
                }

                /* We need to create this directory, and then begin searching
                   for subfiles. */

                wOp = OPER_MKDIR;
                RemoveLast (pcr->sz);
                OemToAnsi (pDTA->fd.cFileName,pDTA->fd.cFileName);
                AppendToPath (pcr->sz,pDTA->fd.cFileName);
                AppendToPath (pcr->szDest,pDTA->fd.cFileName);
                goto ReturnPair;
            }

            if (pcr->fRecurse || !(pDTA->fd.dwFileAttributes & ATTR_DIR)) {

                /* Remove the original spec. */

                RemoveLast (pcr->sz);

                /* Replace it. */

                AppendToPath (pcr->sz,pDTA->fd.cFileName);

                /* Convert to ANSI. */

                pT = FindFileName (pcr->sz);
                OemToAnsi (pT,pT);

                /* If its a dir, tell the driver to create it
                   otherwise, tell the driver to "operate" on the file. */

                wOp = (WORD)((pDTA->fd.dwFileAttributes & ATTR_DIR) ? OPER_RMDIR : OPER_DOFILE);
                goto ReturnPair;
            }
            continue;
        } else {

            /* Read the next source spec out of the raw source string. */

            pcr->fRecurse = 0;
            pcr->pSource = GetNextFile (pcr->pSource,pcr->sz,sizeof(pcr->sz));
            pcr->szDest[0] = 0;
            if (!pcr->pSource)
                return (0);

            /* Fully qualify the path */

            QualifyPath(pcr->sz);

            /* Ensure the source disk really exists before doing anything.
               Only call IsTheDiskReallyThere once for each drive letter.
               Set pcr->cIsDiskThereCheck[DRIVEID] after disk has been
               checked.  Modified by C. Stevens, August 1991 */

            if (pcr->sz[1]==':' && !pcr->cIsDiskThereCheck[DRIVEID (pcr->sz)]) {
                if (!IsTheDiskReallyThere(hdlgProgress, pcr->sz, wFunc))
                    return (0);
                pcr->cIsDiskThereCheck[DRIVEID (pcr->sz)] = 1;
            }

            /* Classify the input string. */

            if (IsWild (pcr->sz)) {

                /* Wild card... operate on all matches but not recursively. */

                pcr->cDepth = 1;
                pDTA = pcr->rgDTA;
                pcr->pRoot = NULL;

                BeginSearch:

                dbg (("   BeginSearch: (on %s)\r\n",(LPSTR)pcr->sz));

                /* Quit if pcr->sz gets too big. */

                if (lstrlen (pcr->sz) - lstrlen (FindFileName (pcr->sz)) >= MAXPATHLEN)
                    goto SearchStartFail;

                lstrcpy (szOEM,pcr->sz);
                FixAnsiPathForDos (szOEM);

                /* Search for the wildcard spec in pcr->sz. */

                if (!WFFindFirst(pDTA, szOEM, ATTR_ALL)) {

                    SearchStartFail:

                    dbg(("   StartSearchFail:\r\n"));
                    if (pcr->fRecurse) {

                        /* We are inside a recursive directory delete, so
                           instead of erroring out, go back a level */

                        goto LeaveDirectory;
                    }
                    lstrcpy (pFrom,pcr->sz);

                    /* Back up as if we completed a search. */

                    RemoveLast (pcr->sz);
                    pcr->cDepth--;

                    /* Find First returned an error.  Return FileNotFound. */

                    wOp = OPER_ERROR | DE_FILENOTFOUND;
                    goto ReturnPair;
                }
                goto ProcessSearchResult;
            } else {

                /* This could be a file or a directory.  Fill in the DTA
                   structure for attrib check */

                if (!IsRootDirectory(pcr->sz)) {
                    lstrcpy(szOEM,pcr->sz);
                    FixAnsiPathForDos(szOEM);
                    if (!WFFindFirst(pcr->rgDTA, szOEM, ATTR_ALL)) {
                        wOp = OPER_ERROR | DE_FILENOTFOUND;
                        goto ReturnPair;
                    }
                    WFFindClose(pcr->rgDTA);
                }

                /* Now determine if its a file or a directory */

                pDTA = pcr->rgDTA;
                if (IsRootDirectory(pcr->sz) || (pDTA->fd.dwFileAttributes & ATTR_DIR)) {

                    /* Process directory */

                    if (wFunc == FUNC_RENAME) {
                        if (IsRootDirectory (pcr->sz))
                            wOp = OPER_ERROR | DE_ROOTDIR;
                        else
                            wOp = OPER_DOFILE;
                        goto ReturnPair;
                    }

                    /* Directory: operation is recursive. */

                    pcr->fRecurse = TRUE;
                    pcr->cDepth = 1;
                    pDTA->fd.cFileName[0] = 0;
                    pcr->pRoot = FindFileName (pcr->sz);
                    lstrcpy (pcr->szDest,pcr->pRoot);
                    wOp = OPER_MKDIR;
                    goto ReturnPair;
                } else {

                    /* Process file */

                    pcr->pRoot = NULL;
                    wOp = OPER_DOFILE;
                    goto ReturnPair;
                }
            }
        }
    }

    ReturnPair:

    /* The source filespec has been derived into pcr->sz
       that is copied to pFrom.  pcr->sz and pToSpec are merged into pTo. */

    dbg(("    ReturnPair:\r\n"));
    if (!*pFrom)
        lstrcpy(pFrom,pcr->sz);
    QualifyPath(pFrom);

    if (wFunc != FUNC_DELETE) {
        if (wFunc == FUNC_RENAME && !*pToPath) {
            lstrcpy(pToPath, pFrom);
            RemoveLast(pToPath);
            AppendToPath(pToPath, pToSpec);
        } else {
            AppendToPath(pToPath,pcr->szDest);
            if (wOp == OPER_MKDIR)
                RemoveLast(pToPath);
            AppendToPath(pToPath,pToSpec);
        }

        if ((wOp == OPER_MKDIR || wOp == OPER_DOFILE) &&
            (!IsLFNDrive(pToPath) && IsLFNDrive(pFrom))  &&
            IsLFN (FindFileName (pFrom)) &&
            (IsWild(pToSpec) || IsLFN(pToSpec))) {

            if (GetNameDialog(wOp, pFrom, pToPath) != IDOK)
                return 0;   /* User cancelled the operation, return failure */

            /* Update the "to" path with the FAT name chosen by the user. */

            if (wOp == OPER_MKDIR) {
                RemoveLast(pcr->szDest);
                AppendToPath(pcr->szDest, FindFileName(pToPath));
            }
        } else
            MergePathName(pToPath, FindFileName(pFrom));
    }

    if (wOp == OPER_MKDIR) {

        /* Make sure the new directory is not a subdir of the original... */

        while (*pFrom && *pFrom == *pToPath) {
            pFrom++;
            pToPath++;
        }
        if (!*pFrom && (!*pToPath || *pToPath == '\\')) {

            /* The two fully qualified strings are equal up to the end of the
               source directory ==> the destination is a subdir.Must return
               an error. */

            wOp = OPER_ERROR | DE_DESTSUBTREE;
        }
    }

    return wOp;
}


VOID
CdDotDot (
         PSTR szOrig
         )
{
    CHAR szTemp[MAXPATHLEN];

    STKCHK();

    lstrcpy(szTemp, szOrig);
    StripFilespec(szTemp);
    SheChangeDir(szTemp);
}

/* p is a fully qualified ANSI string. */

BOOL
IsCurrentDirectory (
                   PSTR p
                   )
{
    CHAR szTemp[MAXPATHLEN];

    STKCHK();

    SheGetDir(DRIVEID(p) + 1, szTemp);
    OemToAnsi(szTemp, szTemp);
    return (lstrcmpi(szTemp, p) == 0);
}


//
// test input for "multiple" filespec
//
// examples:
//  0   foo.bar         (single non directory file)
//  1   *.exe           (wild card)
//  1   foo.bar bletch.txt  (multiple files)
//  2   c:\         (directory)
//
// note: this may hit the disk in the directory check
//

INT
CheckMultiple(
             register PSTR pInput
             )
{
    PSTR pT;
    CHAR szTemp[MAXPATHLEN];

    /* Wildcards imply multiple files. */
    if (IsWild(pInput))
        return 1;     // wild card

    /* More than one thing implies multiple files. */
    pT = GetNextFile(pInput, szTemp, sizeof(szTemp));
    if (!pT)
        return 0;     // blank string

    StripBackslash(szTemp);

    if (IsDirectory(szTemp))
        return 2;     // directory

    pT = GetNextFile(pT, szTemp, sizeof(szTemp));

    return pT ? 1 : 0;    // several files, or just one
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  DialogEnterFileStuff() -                                                */
/*                                                                          */
/*--------------------------------------------------------------------------*/

/* Prevents the user from diddling anything other than the cancel button. */

VOID
DialogEnterFileStuff(
                    register HWND hwnd
                    )
{
    register HWND hwndT;

    /* set the focus to the cancel button so the user can hit space or esc
     */
    if (hwndT = GetDlgItem(hwnd, IDCANCEL)) {
        SetFocus(hwndT);
        SendMessage(hwnd,DM_SETDEFID,IDCANCEL,0L);
    }

    /* disable the ok button and the edit controls
     */
    if (hwndT = GetDlgItem(hwnd, IDOK))
        EnableWindow(hwndT, FALSE);

    if (hwndT = GetDlgItem(hwnd, IDD_TO))
        EnableWindow(hwndT, FALSE);

    if (hwndT = GetDlgItem(hwnd, IDD_FROM))
        EnableWindow(hwndT, FALSE);
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  Notify() -                                                              */
/*                                                                          */
/*--------------------------------------------------------------------------*/

/* Sets the status dialog item in the modeless status dialog box. */

// used for both the drag drop status dialogs and the manual user
// entry dialogs so be careful what you change

VOID
Notify(
      HWND hDlg,
      WORD idMessage,
      PSTR szFrom,
      PSTR szTo
      )
{
    CHAR szTemp[40];

    if (!bCopyReport)
        return;

    if (idMessage) {
        LoadString(hAppInstance, idMessage, szTemp, sizeof(szTemp));
        SetDlgItemText(hDlg, IDD_STATUS, szTemp);
        SetDlgItemPath(hDlg, IDD_NAME, szFrom);
    } else {
        SetDlgItemText(hDlg, IDD_STATUS, szNULL);
        SetDlgItemText(hDlg, IDD_NAME, szNULL);
    }

    // is this the drag/drop status dialog or the move/copy dialog

    SetDlgItemPath(hDlg, IDD_TONAME, szTo);

}

//
// BOOL IsWindowsFile(LPSTR szFileOEM)
//
// this is a bit strange.  kernel strips off the path info so he
// will match only on the base name of the file.  so if the base
// name matches a currently open windows file we get the full
// path string and compare against that.  that will tell
// us that we have a file that kernel has open.
//
// LFN: detect long names and ignore them?

BOOL
IsWindowsFile(
             LPSTR szFileOEM
             )
{
    HANDLE hMod;
    CHAR szModule[MAXPATHLEN];

    STKCHK();

    /* kernel can't load an lfn...
     */
    if (GetNameType(szFileOEM) == FILE_LONG)
        return FALSE;

    // kernel won't accept long paths

    lstrcpy(szModule, szFileOEM);
    StripPath(szModule);

    hMod = GetModuleHandle(szModule);

    // check for one cause that's what's returned if its MSDOS
    // but it isn't really loaded because of xl 2.1c kernel hack
    if (!hMod || hMod == (HANDLE)1)
        return FALSE;

    GetModuleFileName(hMod, szModule, sizeof(szModule));

    if (!lstrcmpi(szFileOEM, szModule))     // they are both OEM & we
        return TRUE;                    // just care about equality
    else
        return FALSE;
}


WORD
SafeFileRemove(
              LPSTR szFileOEM
              )
{
    if (IsWindowsFile(szFileOEM))
        return DE_WINDOWSFILE;
    else
        return WFRemove(szFileOEM);
}


INT
APIENTRY
WF_CreateDirectory(
                  HWND hwndParent,
                  LPSTR szDestOEM
                  )
{
    INT ret = 0;
    CHAR szTemp[MAXPATHLEN + 1];    // +1 for AddBackslash()
    LPSTR p;
    BOOL bCheckPath = IsRemoteDrive(DRIVEID(szDestOEM));

    STKCHK();

#ifdef DEBUG
    if (szDestOEM[1] != ':')
        OutputDebugString("CreateDirectory() with non qualified path\r\n");
#endif

    // now create the full dir tree on the destination

    strncpy(szTemp, szDestOEM, sizeof(szTemp)-1);

    AddBackslash(szTemp); // for the loop below

    p = szTemp + 3;   // assume we have 'X:\' to start

    // create each part of the dir in order

    while (*p) {
        while (*p && *p != '\\')
            p = AnsiNext(p);

        if (*p) {

            *p = 0;

            if (!(ret = MKDir(szTemp))) {
                if (bCheckPath) {
                    static CHAR szTempTemp[] = "temptemp.tmp";

                    BOOL bFoundFile = FALSE;
                    PSTR pEnd;
                    CHAR szTempFile[MAXPATHLEN+sizeof(szTempTemp)];
                    LFNDTA DTA;
                    HDC hDC;
                    INT fh;

                    /* Note that this assumes the dir has just been created,
                     * so it is empty (except possibly for "." and "..")
                     */
                    lstrcpy(szTempFile, szTemp);
                    pEnd = szTempFile + lstrlen(szTempFile);
                    *pEnd++ = '\\';
                    lstrcpy(pEnd, szTempTemp);
                    if (fh=_lcreat(szTempFile, 0)!= -1) {
                        _lclose(fh);
                        lstrcpy(pEnd, szStarDotStar);
                        if (WFFindFirst(&DTA, szTempFile, ATTR_ALL&(~ATTR_DIR))) {
                            do {
                                if (!lstrcmpi(DTA.fd.cFileName, szTempTemp)) {
                                    bFoundFile = TRUE;
                                    break;
                                }
                            } while (WFFindNext(&DTA)) ;
                            WFFindClose(&DTA);
                        }
                        lstrcpy(pEnd, szTempTemp);
                        WFRemove(szTempFile);
                    }

                    if (!bFoundFile) {
                        *(pEnd-1) = '\0';
                        hDC = GetDC(NULL);
                        CompactPath(hDC, szTempFile, (WORD)(GetSystemMetrics(SM_CXSCREEN)/2));
                        ReleaseDC(NULL, hDC);

                        LoadString(hAppInstance, IDS_CREATELONGDIR,
                                   szTitle, sizeof(szTitle));
                        wsprintf(szMessage, szTitle, (LPSTR)szTempFile);
                        LoadString(hAppInstance, IDS_CREATELONGDIRTITLE,
                                   szTitle, sizeof(szTitle));

                        if (MessageBox(hwndParent, szMessage, szTitle,
                                       MB_ICONHAND|MB_YESNO) != IDYES) {
                            RMDir(szTemp);
                            return (DE_OPCANCELLED);
                        }
                    }
                }

                /* Allow the WM_FILESYSCHANGE messages to be processed
                 */
                wfYield();
            }

            *p++ = '\\';
        }
    }

    return ret;   // return the last error code
}

/*============================================================================
;
; WFMoveCopyDriver
;
; The following function is the mainline function for COPYing, RENAMEing,
; DELETEing, and MOVEing single or multiple files.
;
; Parameters:
;
; pFrom - String containing list of source specs
; pTo   - String containing destination specs
; wFunc - Operation to be performed.  Possible values are:
;         FUNC_DELETE - Delete files in pFrom
;         FUNC_RENAME - Rename files (same directory)
;         FUNC_MOVE   - Move files in pFrom to pTo (different disk)
;         FUNC_COPY   - Copy files in pFrom to pTo
;
; Return Value: A 0 indicates success.
;
; Modification History:
;
; August 1991 - Modified by C. Stevens.  Added code to allow us to queue
;               calls to GetNextPair.  The purpose of this is to examine as
;               many source files at once as possible.  This keeps the source
;               disk spinning, so we don't suffer from having to wait for the
;               source disk to speed up every time we call GetNextPair.  Also
;               see the comments for WFCopy and FileCopy.  I have changed the
;               code here so we can queue the copy operations.  This allows
;               us to open several source and destination files in one go,
;               minimizing seek time to the directory track.
;
============================================================================*/

WORD
APIENTRY
WFMoveCopyDriver(
                PSTR pFrom,
                PSTR pTo,
                WORD wFunc
                )
{
    INT i;                             // Counter
    WORD ret = 0;                      // Return value from WFMoveCopyDriver
    PSTR pSpec;                        // Pointer to file spec
    WORD wAttr;                        // File attributes
    WORD oper = 0;                     // Disk operation being performed
    CHAR szDestSpec[MAXFILENAMELEN+1]; // Dest file spec
    CHAR szDest[MAXPATHLEN];           // Dest file (ANSI string)
    CHAR szDestOEM[MAXPATHLEN];        // OEM version of above
    CHAR szSource[MAXPATHLEN];         // Source file (ANSI string)
    CHAR szSourceOEM[MAXPATHLEN];      // OEM version of above
    LFNDTA DTADest;                    // DTA block for reporting dest errors
    PLFNDTA pDTA;                      // DTA pointer for source errors
    PCOPYROOT pcr;                 // Structure for searching source tree
    BOOL bReplaceAll = FALSE;          // Replace all flag
    BOOL bSubtreeDelAll = FALSE;       // Delete entire subtree flag
    BOOL bDeleteAll = FALSE;           // Delete all files flag
    BOOL bFalse = FALSE;               // For cases that aren't disableable
    INT nNumQueue;                     // Number of calls to GetNextPair
    PGETNEXTQUEUE pGetNextQueue = NULL;// Pointer to GetNextPair queue buffer
    INT CurIDS = 0;            // Current string displayed in status

    /* Initialization stuff.  Disable all file system change processing until
       we're all done */

    STKCHK();

    bCopyReport = TRUE;
    szDest[0] = szSource[0] = 0;
    DisableFSC();

    /* Change all '/' characters to '\' characters in dest spec */

    CheckSlashies(pFrom);
    bUserAbort = FALSE;

    /* Check for multiple source files */

    ManySource = CheckMultiple(pFrom);

    /* Allocate buffer for searching the source tree */

    pcr = (PCOPYROOT)LocalAlloc(LPTR, sizeof(COPYROOT));
    if (!pcr) {
        ret = DE_INSMEM;
        goto ShowMessageBox;
    }

    /* Allocate a buffer so we can queue calls to GetNextPair. */

    pGetNextQueue = (PGETNEXTQUEUE)LocalAlloc(LPTR, COPYMAXFILES * sizeof (GETNEXTQUEUE));
    if (!pGetNextQueue) {
        ret = DE_INSMEM;
        goto ShowMessageBox;
    }

    /* Skip destination specific processing if we are deleting files */

    if (wFunc != FUNC_DELETE) {

        // it is an error condition if there are multiple files
        // specified as the dest (but not a single directory)

        pSpec = GetNextFile(pTo, szMessage, MAXPATHLEN);

        if (GetNextFile(pSpec, szMessage, MAXPATHLEN) != NULL) {
            // move, copy specified with multiple destinations
            // not allowed, error case
            ret = DE_MANYDEST;
            goto ShowMessageBox;
        }

        lstrcpy(pTo, szMessage);
        QualifyPath(pTo);

        if (wFunc == FUNC_RENAME) {
            // don't let them rename multiple files to one single file

            if ((ManySource == 1) && !IsWild(pTo)) {
                ret = DE_MANYSRC1DEST;
                goto ShowMessageBox;
            }

        } else {

            /* We are either executing FUNC_COPY or FUNC_MOVE at this point.
               Check that the destination disk is there.  NOTE: There's a disk
               access here slowing us down. */

            if (!IsTheDiskReallyThere(hdlgProgress,pTo,wFunc))
                goto CancelWholeOperation;

            // deal with case where directory is implicit in source
            // move/copy: *.* -> c:\windows, c:\windows -> c:\temp
            // or foo.bar -> c:\temp

            if (!IsWild(pTo) && (ManySource || IsDirectory(pTo))) {
                AddBackslash(pTo);
                lstrcat(pTo, szStarDotStar);
            }
        }

        /* FUNC_RENAME or FUNC_MOVE FUNC_COPY with a file name dest
           (possibly including wildcards).  Save the filespec and the path
           part of the destination */

        pSpec = FindFileName(pTo);
        lstrcpy(szDestSpec,pSpec);
        lstrcpy(szDest,pTo);
        RemoveLast(szDest);

        pSpec = szDest + lstrlen(szDest);
    }
    pcr->pSource = pFrom;

    /* Disable all but the cancel button on the notify dialog */

    DialogEnterFileStuff(hdlgProgress);

    /* Set up arguments for queued copy commands */

    lpCopyBuffer = NULL;
    pCopyQueue = NULL;

    while (pcr) {

        /* Allow the user to abort the operation */

        if (WFQueryAbort())
            goto CancelWholeOperation;

        /* Now queue up a bunch of GetNextPair calls. */

        for (nNumQueue = 0; nNumQueue < COPYMAXFILES; nNumQueue++) {

            /* Clean off the last filespec for multiple file copies */

            if (wFunc != FUNC_DELETE) {
                *pSpec = TEXT('\0');
            }

            oper = GetNextPair(pcr,szSource,szDest,szDestSpec,wFunc);

            /* Check for no operation or error */

            if (!oper) {
                LocalFree((HANDLE)pcr);
                pcr = NULL;
                break;
            }
            if ((oper & OPER_MASK) == OPER_ERROR) {
                ret = LOBYTE (oper);
                oper = OPER_DOFILE;
                goto ShowMessageBox;
            }

            pGetNextQueue[nNumQueue].nOper = oper;
            lstrcpy(pGetNextQueue[nNumQueue].szSource, szSource);
            lstrcpy(pGetNextQueue[nNumQueue].szDest, szDest);
            pGetNextQueue[nNumQueue].SourceDTA = *CurPDTA(pcr);
        }

        /* Execute the queued GetNextPair calls */

        for (i = 0; i < nNumQueue; i++) {

            /* Allow the user to abort the operation */

            if (WFQueryAbort())
                goto CancelWholeOperation;

            oper = (WORD)pGetNextQueue[i].nOper;
            lstrcpy(szSource, pGetNextQueue[i].szSource);
            lstrcpy(szDest, pGetNextQueue[i].szDest);
            pDTA = &pGetNextQueue[i].SourceDTA;

            dbg(("Gonna do OPER:%x FUNC:%x '%s' and '%s'.\r\n",oper,wFunc, (LPSTR)szSource, (LPSTR)szDest));

            /* Fix up source spec */

            lstrcpy (szSourceOEM,szSource);
            FixAnsiPathForDos (szSourceOEM);
            if (IsInvalidPath (szSource)) {
                ret = DE_ACCESSDENIED;
                goto ShowMessageBox;
            }

            if (wFunc != FUNC_DELETE) {

                /* Fix up dest spec */

                lstrcpy(szDestOEM, szDest);
                FixAnsiPathForDos(szDestOEM);
                if (!lstrcmpi(szSource, szDest)) {
                    ret = DE_SAMEFILE;
                    goto ShowMessageBox;
                } else if (IsInvalidPath (szDest)) {
                    ret = DE_ACCESSDENIED | ERRORONDEST;
                    goto ShowMessageBox;
                }

                /* Check to see if we are overwriting an existing file.  If so,
                   better confirm */

                if (oper == OPER_DOFILE) {

                    // we can avoid this expensive call on dos 4.0 and up
                    // by using the extended open don't replace option

                    if (WFFindFirst(&DTADest, szDestOEM, ATTR_ALL)) {
                        WFFindClose(&DTADest);

                        if (wFunc == FUNC_RENAME) {
                            ret = DE_RENAMREPLACE;
                            goto ShowMessageBox;
                        }

                        // we need to check if we are trying to copy a file
                        // over a directory and give a reasonable error message

                        switch (wAttr = ConfirmDialog (hdlgProgress,CONFIRMREPLACE,
                                                       szDest,&DTADest,szSource,
                                                       pDTA,bConfirmReplace,
                                                       &bReplaceAll)) {

                            case IDYES: /* Perform the delete */

                                if ((wFunc == FUNC_MOVE) &&
                                    (DRIVEID(szSource) == DRIVEID(szDest))) {

                                    /* For FUNC_MOVE we need to delete the
                         * destination first.  Do that now. */

                                    if (DTADest.fd.dwFileAttributes & ATTR_DIR) {
                                        if (IsCurrentDirectory(szDestOEM))
                                            CdDotDot(szDestOEM);

                                        switch (NetCheck(szDest, WNDN_RMDIR)) {

                                            case WN_SUCCESS:

                                                /* Remove directory */

                                                ret = RMDir(szDestOEM);
                                                break;

                                            case WN_CONTINUE:
                                                break;

                                            case WN_CANCEL:
                                                goto CancelWholeOperation;
                                        }
                                    } else {
                                        ret = SafeFileRemove (szDestOEM);
                                    }
                                    if (ret) {
                                        ret |= ERRORONDEST;
                                        goto ShowMessageBox;
                                    }
                                }
                                break;

                            case IDNO:

                                /* Don't perform operation on current file */

                                continue;

                            case IDCANCEL:
                                goto CancelWholeOperation;

                            default:
                                ret = (WORD) wAttr;
                                goto ShowMessageBox;
                        }
                    }
                }
            }

            /* Now determine which operation to perform */

            switch (oper | wFunc) {

                case OPER_MKDIR | FUNC_COPY:  // Create destination directory
                case OPER_MKDIR | FUNC_MOVE:  // Create dest, verify source delete

                    CurIDS = IDS_CREATINGMSG;
                    Notify(hdlgProgress, IDS_CREATINGMSG, szDest, szNULL);

                    switch (NetCheck(szDest, WNDN_MKDIR)) {
                        case WN_SUCCESS:
                            break;

                        case WN_CONTINUE:
                            goto SkipMKDir;

                        case WN_CANCEL:
                            goto CancelWholeOperation;
                    }

                    ret = (WORD)WF_CreateDirectory(hdlgProgress, szDestOEM);

                    if (!ret)
                        /* set attributes of dest to source (not including the
                           subdir and vollabel bits) */
                        WFSetAttr(szDestOEM, pDTA->fd.dwFileAttributes & ~(ATTR_DIR|ATTR_VOLUME));

                    // if it already exits ingore the error return
                    if (ret == DE_ACCESSDENIED)
                        ret = 0;

                    if (ret)
                        ret |= ERRORONDEST;

                    /* set attributes of new directory to those of the source */

                    SkipMKDir:
                    break;

                case OPER_MKDIR | FUNC_DELETE:

                    /* Confirm removal of directory on this pass.  The directories
                       are actually removed on the OPER_RMDIR pass */

                    /* We can't delete the root directory, so don't bother
                       confirming it */

                    if (IsRootDirectory(szSource))
                        break;

                    switch (wAttr = ConfirmDialog (hdlgProgress,CONFIRMRMDIR,
                                                   NULL,pDTA,szSource, NULL,
                                                   bConfirmSubDel,
                                                   &bSubtreeDelAll)) {

                        case IDYES:
                            break;

                        case IDNO:
                        case IDCANCEL:
                            goto CancelWholeOperation;

                        default:
                            ret = (WORD) wAttr;
                            goto ShowMessageBox;
                    }
                    break;

                case OPER_RMDIR | FUNC_MOVE:
                case OPER_RMDIR | FUNC_DELETE:

                    CurIDS = IDS_REMOVINGDIRMSG;
                    Notify(hdlgProgress, IDS_REMOVINGDIRMSG, szSource, szNULL);
                    if (IsRootDirectory (szSource))
                        break;
                    if (IsCurrentDirectory (szSource))
                        CdDotDot (szSource);

                    /* We already confirmed the delete at MKDIR time, so attempt
                       to delete the directory */

                    switch (NetCheck (szSource,WNDN_RMDIR)) {

                        case WN_SUCCESS:
                            ret = RMDir (szSourceOEM);
                            break;

                        case WN_CONTINUE:
                            break;

                        case WN_CANCEL:
                            goto CancelWholeOperation;
                    }
                    break;

                case OPER_RMDIR | FUNC_COPY:
                    break;

                case OPER_DOFILE | FUNC_COPY:

                    if (IsWindowsFile(szDestOEM)) {
                        ret = DE_WINDOWSFILE | ERRORONDEST;
                        break;
                    }

                    TRY_COPY_AGAIN:

                    /* Now try to copy the file.  Do extra error processing only
                       in 2 cases:

                       1) If a floppy is full let the user stick in a new disk
                       2) If the path doesn't exist (the user typed in
                          and explicit path that doesn't exits) ask if
                          we should create it for him.

                       NOTE:  This processing is normally done by WFCopy.  But in
                              the case where LFN copy support is invoked, we have
                              to support this error condition here.  Modified by
                              C. Stevens, August 1991 */

                    ret = WFCopy(szSourceOEM, szDestOEM);

                    if (bUserAbort)
                        goto CancelWholeOperation;

                    if ((((ret & ~ERRORONDEST) == DE_NODISKSPACE) &&
                         IsRemovableDrive(DRIVEID(szDestOEM))) ||
                        ((ret & ~ERRORONDEST) == DE_PATHNOTFOUND)) {

                        ret = (WORD)CopyMoveRetry(szDestOEM, (INT)ret);
                        if (!ret)
                            goto TRY_COPY_AGAIN;
                        else
                            goto CancelWholeOperation;
                    }

                    break;

                case OPER_DOFILE | FUNC_RENAME:
                    {
                        CHAR save1,save2;
                        PSTR p;

                        if (CurIDS != IDS_RENAMINGMSG) {
                            CurIDS = IDS_RENAMINGMSG;
                            Notify(hdlgProgress, IDS_RENAMINGMSG, szNULL, szNULL);
                        }

                        /* Get raw source and dest paths.  Check to make sure the
                           paths are the same */

                        p = FindFileName(szSource);
                        save1 = *p;
                        *p = TEXT('\0');
                        p = FindFileName(szDest);
                        save2 = *p;
                        *p = TEXT('\0');
                        ret = (WORD)lstrcmpi(szSource, szDest);
                        szSource[lstrlen(szSource)] = save1;
                        szDest[lstrlen(szDest)] = save2;
                        if (ret) {
                            ret = DE_DIFFDIR;
                            break;
                        }
                        goto DoMoveRename;
                    }

                case OPER_DOFILE | FUNC_MOVE:

                    if (CurIDS != IDS_MOVINGMSG) {
                        CurIDS = IDS_MOVINGMSG;
                        Notify(hdlgProgress, IDS_MOVINGMSG, szNULL, szNULL);
                    }
                    DoMoveRename:

                    /* Don't allow the user to rename from or to the root
                       directory */

                    if (IsRootDirectory(szSource)) {
                        ret = DE_ROOTDIR;
                        break;
                    }
                    if (IsRootDirectory(szDest)) {
                        ret = DE_ROOTDIR | ERRORONDEST;
                        break;
                    }

                    if (IsCurrentDirectory(szSource))
                        CdDotDot(szSource);

                    /* Confirm the rename */

                    switch (wAttr = ConfirmDialog (hdlgProgress,
                                                   (WORD)(wFunc == FUNC_MOVE ?
                                                          CONFIRMMOVE : CONFIRMRENAME),
                                                   NULL,pDTA,szSource,NULL,FALSE,
                                                   (BOOL *)&bFalse)) {

                        case IDYES:
                            break;

                        case IDNO:
                            continue;

                        case IDCANCEL:
                            goto CancelWholeOperation;

                        default:
                            ret = (WORD) wAttr;
                            goto ShowMessageBox;
                    }

                    if (IsWindowsFile(szSourceOEM)) {
                        ret = DE_WINDOWSFILE;
                    } else {
                        if (DRIVEID(szSource) == DRIVEID(szDest)) {
                            ret = WFMove(szSourceOEM, szDestOEM);
                            if (!ret)
                                /* set attributes of dest to those of the source */
                                WFSetAttr(szDestOEM, pDTA->fd.dwFileAttributes);
                        } else {
                            // we must force all copies to go through
                            // straight so we can remove the source
                            // and have the
                            ret = WFCopy(szSourceOEM, szDestOEM);

                            if (!ret) {
                                ret = EndCopy();
                                if (!ret)
                                    WFRemove(szSourceOEM);
                            }
                            if (bUserAbort)
                                goto CancelWholeOperation;
                        }
                    }
                    break;

                case OPER_DOFILE | FUNC_DELETE:

                    if (CurIDS != IDS_DELETINGMSG) {
                        CurIDS = IDS_DELETINGMSG;
                        Notify(hdlgProgress,IDS_DELETINGMSG,szNULL, szNULL);
                    }

                    /* Confirm the delete first */

                    switch (wAttr = ConfirmDialog (hdlgProgress,CONFIRMDELETE,
                                                   NULL,pDTA,szSource,NULL,
                                                   bConfirmDelete,&bDeleteAll)) {

                        case IDYES:
                            break;

                        case IDNO:
                            continue;

                        case IDCANCEL:
                            goto CancelWholeOperation;

                        default:
                            ret = (WORD)wAttr;
                            goto ShowMessageBox;
                    }

                    /* make sure we don't delete any open windows
                       apps or dlls (lets hope this isn't too slow) */

                    ret = SafeFileRemove(szSourceOEM);
                    break;

                default:
                    ret = DE_HOWDIDTHISHAPPEN;   // internal error
                    break;
            }

            /* Report any errors which have occurred */

            if (ret) {

                ShowMessageBox:

                CopyError(szSource, szDest, ret, wFunc, oper);

                /* Continue the operation where one file is a windows file
                   in use */

                if ((ret & ~ERRORONDEST) != DE_WINDOWSFILE) {

                    CancelWholeOperation:

                    /* Force a CopyAbort in case there are any files in the
                       copy queue */

                    bUserAbort = TRUE;
                    goto ExitLoop;
                }
            }
        }
    }

    ExitLoop:

    /* Copy any outstanding files in the copy queue */

    if (!bUserAbort) {

        if (EndCopy())
            CopyAbort();
    } else
        CopyAbort();

    // this happens in error cases where we broke out of the pcr loop
    // without hitting the end

    if (pcr) {
        GetNextCleanup(pcr);
        LocalFree((HANDLE)pcr);
    }

    if (pGetNextQueue)
        LocalFree((HANDLE)pGetNextQueue);

    /* goofy way to make sure we've gotten all the WM_FILESYSCHANGE messages */
    WFQueryAbort();

    EnableFSC();

    return ret;
}


/*--------------------------------------------------------------------------*/
/*                                          */
/*  DMMoveCopyHelper() -                            */
/*                                      */
/*--------------------------------------------------------------------------*/

/* Used by Danger Mouse to do moves and copies. */

WORD
APIENTRY
DMMoveCopyHelper(
                register LPSTR pFrom,
                register LPSTR pTo,
                BOOL bCopy
                )
{
    WORD      iStatus;

    dbg(("DMMoveCopyHelper(%s,%s);\r\n",(LPSTR)pFrom,(LPSTR)pTo));

    /* Confirm mouse operations. */
    if (bConfirmMouse) {
        LoadString(hAppInstance, IDS_MOUSECONFIRM, szTitle, sizeof(szTitle));
        LoadString(hAppInstance,
                   bCopy ? IDS_COPYMOUSECONFIRM : IDS_MOVEMOUSECONFIRM,
                   szMessage, sizeof(szMessage));

        if (MessageBox(hwndFrame, szMessage, szTitle, MB_YESNO | MB_ICONEXCLAMATION) != IDYES)
            return DE_OPCANCELLED;
    }

    hdlgProgress = CreateDialog(hAppInstance, MAKEINTRESOURCE(DMSTATUSDLG), hwndFrame, ProgressDlgProc);
    if (!hdlgProgress) {
        return DE_INSMEM;
    }

    /* Set the destination directory in the dialog.
     * use IDD_TONAME 'cause IDD_TO gets disabled....
     */
    // SetDlgItemText(hdlgProgress, IDD_TONAME, pTo);

    /* The dialog title defaults to "Moving..." */
    if (bCopy) {
        LoadString(hAppInstance, IDS_COPYINGTITLE, szMessage, sizeof(szMessage));
        SetWindowText(hdlgProgress, szMessage);
    }

    /* Display and paint the status dialog. */
    EnableWindow(hwndFrame,FALSE);
    ShowWindow(hdlgProgress, SW_SHOW);
    UpdateWindow(hdlgProgress);

    /* Move/Copy things. */
    iStatus = WFMoveCopyDriver(pFrom, pTo, (WORD)(bCopy ? FUNC_COPY : FUNC_MOVE));

    /* Destroy the status dialog. */
    EnableWindow(hwndFrame,TRUE);
    DestroyWindow(hdlgProgress);

    return (iStatus);
}

WORD
APIENTRY
FileRemove(
          PSTR pSpec
          )
{
    if (DeleteFile(pSpec))
        return (WORD)0;
    else
        return (WORD)GetLastError();
}


WORD
APIENTRY
FileMove(
        PSTR pFrom,
        PSTR pTo
        )
{
    WORD result;

    TryAgain:

    if (MoveFile(pFrom, pTo))
        result = 0;
    else
        result = (WORD)GetLastError();

    // try to create the destination if it is not there

    if (result == DE_PATHNOTFOUND) {
        result = (WORD)CopyMoveRetry(pTo, (INT)result);
        if (!result)
            goto TryAgain;
        else
            return result;
    }
    return 0;
}


/*============================================================================
;
; FileCopy
;
; The following function replaces the old FileCopy function which performed
; single file copies.  This function queues copies.  The function StartCopy
; is called to initialize the copy queue if required.  If the queue is full,
; the function EndCopy is called to purge the copy queue before queueing
; up new copy commands.  Note that the function EndCopy must be called to
; purge the copy queue.
;
; Parameters:
;
; pszSource - Fully qualified source path
; pszDest   - Fully qualifies destination path
;
; returns:
;   0   success
;   dos error code for failure
;
============================================================================*/

WORD
APIENTRY
FileCopy(
        PSTR pszSource,
        PSTR pszDest
        )
{
    WORD ret;

    if (ret = StartCopy())
        return ret;       // failure

    // if the queue is full we must empty it first

    if (nCopyNumQueue >= nCopyMaxQueue) {

        // queue is full, now we empty it by really doing copies

        if (ret = EndCopy())
            return ret;    // failure

        if (ret = StartCopy())
            return ret;    // failure
    }

    // add this to the queue

    lstrcpy(pCopyQueue[nCopyNumQueue].szSource, pszSource);
    lstrcpy(pCopyQueue[nCopyNumQueue].szDest, pszDest);
    pCopyQueue[nCopyNumQueue].hSource = -1;
    pCopyQueue[nCopyNumQueue].hDest   = -1;
    pCopyQueue[nCopyNumQueue].ftLastWriteTime.dwLowDateTime = 0;
    pCopyQueue[nCopyNumQueue].ftLastWriteTime.dwHighDateTime = 0;

    nCopyNumQueue++;
    return 0;        // success
}

/*============================================================================
;
; StartCopy
;
; The following function is called automatically by WFCopy to initialize the
; copy queue.  The function is called each time by WFCopy, but will only
; initialize the first time.  The function allocates a buffer for reading and
; writing, and a buffer for storing the source and destination filenames,
; handles, and time stamps.  The function EndCopy must be called to flush the
; copy queue, and perform the actual disk transfer.
;
; Parameters: None
;
; return:
;   0   success
;   != 0    dos error code (DE_ value)
;
; Written by C. Stevens, August 1991
;
============================================================================*/

WORD
APIENTRY
StartCopy(VOID)
{
    WORD wSize;     /* Buffer size */
    register INT i; /* Counter */

    // have we already been called?

    if (lpCopyBuffer && pCopyQueue)
        return 0;     // success, buffers already allocated

    /* Allocate and lock buffer for reading and writing */

    wSize = COPYMAXBUFFERSIZE;
    while (!lpCopyBuffer) {
        lpCopyBuffer = GlobalAllocPtr(GHND, (DWORD)wSize);
        if (!lpCopyBuffer) {
            wSize /= 2;
            if (wSize < COPYMINBUFFERSIZE)
                return DE_INSMEM;   // memory failure
        }
    }
    wCopyBufferSize = wSize;

    /* Allocate and lock buffer for copy queue.  Note that magic +5 below is
       because we always have stdin, stdout, stderr, and AUX files open all
       the time, and we can't count them as available file handles */

    // someone opens files on our psp, leave them 2 handles
    // so we don't run on in the midst of copying

    nCopyMaxQueue = min(SetHandleCount(11 * 2) / 2 - 1, 10);

#ifdef DEBUG
    {
        char buf[80];
        wsprintf(buf, "SetHandleCount() -> %d\r\n", nCopyMaxQueue);
        OutputDebugString(buf);
    }
#endif

    wSize = (WORD)(nCopyMaxQueue * sizeof(COPYQUEUEENTRY));
    while (!pCopyQueue) {
        pCopyQueue = (PCOPYQUEUE)LocalAlloc(LPTR,wSize);
        if (!pCopyQueue) {
            wSize /= 2;
            if (wSize < (COPYMINFILES * sizeof(COPYQUEUEENTRY))) {
                GlobalFreePtr(lpCopyBuffer);
                lpCopyBuffer = NULL;
                return DE_INSMEM;   // memory failure
            }
        }
    }

    /* Initialize other Copy Queue variables and return success */

    nCopyMaxQueue = (int) wSize / sizeof (COPYQUEUEENTRY);
    nCopyNumQueue = 0;
    for (i = 0; i < nCopyMaxQueue; i++) {
        pCopyQueue[i].szSource[0] = 0;
        pCopyQueue[i].szDest[0]   = 0;
        pCopyQueue[i].hSource = -1;
        pCopyQueue[i].hDest   = -1;
    }
    return 0;        // success
}

// in:
//  pszFile     file to open/create
//  wAttrib     attributes to use on create
//
// returns:
//  flags register  (carry set on error)
//  *pfh        file handle or dos error code


WORD
OpenDestFile(
            PSTR pszFile,
            WORD wAttrib,
            INT *pfh
            )
{
    INT fh;
    WORD wStatus = 0;
    OFSTRUCT ofs;

    // use new extended open on dos > 4

    if (wDOSversion >= 0x0400) {
        if (wAttrib & ATTR_ATTRIBS)
            wAttrib &= ATTR_USED;
        else
            wAttrib = ATTR_ARCHIVE;

        {
            fh = OpenFile(pszFile, &ofs,
                          OF_READWRITE  | OF_SHARE_DENY_WRITE | OF_CREATE);
            if (fh == (INT)-1) {
                fh = GetLastError();
                wStatus |= CARRY_FLAG;
            } else {
                wStatus = 0;
                SetFileAttributes(pszFile, wAttrib);
            }

            // fh now contains a file handle or error code
        }

    } else {
        {
            fh = OpenFile(pszFile, &ofs,
                          OF_READWRITE  | OF_SHARE_DENY_WRITE | OF_CREATE);
            if (fh == (INT)-1) {
                fh = GetLastError();
                wStatus |= CARRY_FLAG;
            } else
                wStatus = 0;
        }
    }
    *pfh = fh;

    return wStatus;
}


/*============================================================================
;
; EndCopy
;
; The following function flushes the copy queue, attempting to copy all files
; in the queue.  The function ALWAYS frees global memory and flushes the
; queue and reports it's own errors.
;
; strategy:
;   we will do as many operations on one drive as we can, thus
;   avoiding disk spin up time (really bad on floppies).
;
; Parameters: None
;
; returns:
;   0   successful operation
;   != 0    dos error code (DE_OPCANCELLED) failure
;
; use like:
;
;    loop {
;   ret = WFCopy();
;   if (ret) {
;     ReportError(ret);
;     goto Error;
;   }
;    }
;
;    ret = EndCopy();
;    if (ret)
;      goto Error;
;
;    return success;
;
;Error:
;    CopyAbort();
;    ReportError(ret);
;
============================================================================*/

WORD
APIENTRY
EndCopy(VOID)
{
    INT i, j;           /* Counter */
    PSTR pTemp;         /* Pointer to source or dest filename */
    INT  fh;        /* File handle for DOS calls */
    WORD wStatus;       /* Status flags returned from DOS calls */
    DWORD wRead;         /* Number of bytes read from source file */
    DWORD wWrite;        /* Number of bytes written to destination file */
    FILETIME ftLastWriteTime; /* Source file date and time */
    DWORD wAttrib;       /* File attributes */

#ifdef DEBUG
    {
        char buf[80];
        wsprintf(buf, "EndCopy() nCopyNumQueue == %d\r\n", nCopyNumQueue);
        OutputDebugString(buf);
    }
#endif

    /* Open as many source files as possible.  Note we are assuming here
       that nCopyNumQueue < nCopyMaxQueue.  This should always be true
       because WFCopy calls EndCopy to purge the queue if it becomes full.
       We should never get an out of handles error opening source files or
       destination files.  If we do get an out of handles error opening
       source files, cause a fatal error and abort the copy. */

    // open all source files

    Notify(hdlgProgress, IDS_OPENINGMSG, szNULL, szNULL);

    for (i = 0; i < nCopyNumQueue; i++) {

        if (WFQueryAbort())
            return DE_OPCANCELLED;

        pTemp = pCopyQueue[i].szSource;
        {
            OFSTRUCT ofs;

            fh = OpenFile(pTemp, &ofs, OF_READ);
            if (fh == (INT)-1)
                fh = OpenFile(pTemp, &ofs, OF_SHARE_DENY_WRITE);
        }

        if (fh == (INT)-1) {

            CopyError(pCopyQueue[i].szSource, pCopyQueue[i].szDest, fh, FUNC_COPY, OPER_DOFILE);

            return DE_OPCANCELLED; // error already reported

        } else
            pCopyQueue[i].hSource = fh;

        /* Get the source file date, time, and attributes if necessary */

        fh = pCopyQueue[i].hSource;
        if (!IsSerialDevice(fh)) {
            {
                FILETIME ft;

                // Call DOS Get Date/Time of File.
                if (GetFileTime((HANDLE)LongToHandle(fh), NULL, NULL, (LPFILETIME)&ft))
                    pCopyQueue[i].ftLastWriteTime = ft;
            }

            pTemp = pCopyQueue[i].szSource;
            {
                // Call DOS Get File Attributes
                wAttrib = GetFileAttributes(pTemp);
                if (wAttrib != (DWORD)-1)
                    pCopyQueue[i].wAttrib |= (wAttrib | ATTR_ATTRIBS);
            }
        }
    }

    /* Now open as many destination files as possible.  If we get an out of
       handles error, cause a fatal abort because we already called
       Windows SetHandleCount to ensure we had enough.

       Note:  We are assuming the files do not exist when we try to open
              them, although for DOS 4.0 and above files WILL be replaced
              if they do happen to exist. */

    // open all destination files

    for (i = 0; i < nCopyNumQueue; i++) {

        if (WFQueryAbort())
            return DE_OPCANCELLED;

        TryOpen:

        wStatus = OpenDestFile(pCopyQueue[i].szDest, (WORD)pCopyQueue[i].wAttrib, (INT *)&fh);

        if (wStatus & CARRY_FLAG) {

            // error operning/creating destinaton file

            if (fh == DE_PATHNOTFOUND) {
                TryOpenDestAgain:
                // ask the user to stick in another disk

                fh = CopyMoveRetry(pCopyQueue[i].szDest, fh);
                if (!fh) {
                    goto TryOpen;
                } else {
                    // didn't happen, abort this copy

                    CopyError(pCopyQueue[i].szSource, pCopyQueue[i].szDest, (WORD)fh | ERRORONDEST, FUNC_COPY, OPER_DOFILE);
                    return DE_OPCANCELLED;   // error already reported
                }

            } else {
                // some other error condition

                CopyError(pCopyQueue[i].szSource, pCopyQueue[i].szDest, (WORD)fh | ERRORONDEST, FUNC_COPY, OPER_DOFILE);
                return DE_OPCANCELLED;  // error already reported
            }

        } else {
            pCopyQueue[i].hDest = fh;  // dest file open success
        }
    }

    /* Now copy between the open files */

    for (i = 0; i < nCopyNumQueue; i++) {

        Notify(hdlgProgress, IDS_COPYINGMSG, pCopyQueue[i].szSource, pCopyQueue[i].szDest);

        wRead = wCopyBufferSize;

        do {

            if (WFQueryAbort())
                return DE_OPCANCELLED;

            fh = pCopyQueue[i].hSource;
            {

                wRead = _lread(fh, lpCopyBuffer, wCopyBufferSize);
                if (wRead == (DWORD)-1) {
                    wStatus |= CARRY_FLAG;
                    wRead = GetLastError();
                } else
                    wStatus = 0;

                // wRead is either # bytes read or error code
            }
            if (wStatus & CARRY_FLAG) {

                // Error during file read

                CopyError(pCopyQueue[i].szSource, pCopyQueue[i].szDest, wRead, FUNC_COPY, OPER_DOFILE);

                return DE_OPCANCELLED;   // error already reported
            }

            fh = pCopyQueue[i].hDest;
            {

                // size can be zero to terminate file

                wWrite = _lwrite(fh, lpCopyBuffer, wRead);
                if (wWrite == (DWORD)-1) {
                    wStatus |= CARRY_FLAG;
                    wWrite = GetLastError();
                } else
                    wStatus = 0;

                // wWrite is either # bytes read or error code
            }
            if (wStatus & CARRY_FLAG) {

                CopyError(pCopyQueue[i].szSource, pCopyQueue[i].szDest, wWrite | ERRORONDEST, FUNC_COPY, OPER_DOFILE);

                return DE_OPCANCELLED;   // error already reported
            }

            // write did not complete and removable drive?

            if (wRead != wWrite) {

                if (IsRemovableDrive(DRIVEID(pCopyQueue[i].szDest)) &&
                    (DRIVEID(pCopyQueue[i].szDest) != DRIVEID(pCopyQueue[i].szSource))) {

                    // destination disk must be full. delete the destination
                    // files, give the user the option to insert a new disk.

                    for (j = i; j < nCopyNumQueue; j++) {

                        _lclose(pCopyQueue[j].hDest);
                        pCopyQueue[j].hDest = -1;

                        pTemp = pCopyQueue[j].szDest;
                        DeleteFile(pTemp);
                    }
                    fh = DE_NODISKSPACE;
                    goto TryOpenDestAgain;  // and try to create the destiations
                } else {

                    // not removable, error condition
                    CopyError(pCopyQueue[i].szSource, pCopyQueue[i].szDest, DE_NODISKSPACE | ERRORONDEST, FUNC_COPY, OPER_DOFILE);

                    return DE_OPCANCELLED;  // error already reported
                }

            }
            // we have moved all the data, so don't delete this on
            // clean up.

            if (!wRead)
                pCopyQueue[i].wAttrib |= ATTR_COPIED;

        } while (wRead);
    }

    // Close all destination files, set date time attribs

    Notify(hdlgProgress, IDS_CLOSINGMSG, szNULL, szNULL);

    for (i = 0; i < nCopyNumQueue; i++) {

        fh = pCopyQueue[i].hDest;
        if (!IsSerialDevice(fh)) {
            ftLastWriteTime = pCopyQueue[i].ftLastWriteTime;
            if (ftLastWriteTime.dwLowDateTime &&
                ftLastWriteTime.dwHighDateTime) {
                SetFileTime((HANDLE)LongToHandle(fh), NULL, NULL, (LPFILETIME)&ftLastWriteTime);
            }
        }

        _lclose(pCopyQueue[i].hDest);
        pCopyQueue[i].hDest = -1;

        /* Now set the file attributes if necessary */

        if (wDOSversion < 0x0400) {

            pTemp = pCopyQueue[i].szDest;
            wAttrib = pCopyQueue[i].wAttrib;

            // only set attribs if necessary (this is slow)

            if (wAttrib & ATTR_ATTRIBS) {
                wAttrib &= ATTR_USED;
                SetFileAttributes(pTemp, wAttrib);
            }
        }
    }

    // Close all source files (and delete them if necessary)


    if (pCopyQueue && (pCopyQueue[0].wAttrib & ATTR_DELSRC))
        Notify(hdlgProgress, IDS_REMOVINGMSG, szNULL, szNULL);

    for (i = 0; i < nCopyNumQueue; i++) {

        _lclose(pCopyQueue[i].hSource);
        pCopyQueue[i].hSource = -1;

        if (pCopyQueue[i].wAttrib & ATTR_DELSRC) {
            WFRemove(pCopyQueue[i].szSource);
        }
    }


    if (lpCopyBuffer) {
        GlobalFreePtr(lpCopyBuffer);
        lpCopyBuffer = NULL;
    }
    if (pCopyQueue) {
        LocalFree((HANDLE)pCopyQueue);
        pCopyQueue = NULL;
    }

    nCopyMaxQueue = 0;
    nCopyNumQueue = 0;

    return 0;        // success
}


/*============================================================================
;
; CopyError
;
; The following function reports an error during a file copy operation
;
; Parameters
;
; lpszSource - Source file name
; lpszDest   - Destination file name
; nError     - dos (or our exteneded) error code
;          0xFFFF for special case NET error
; wFunc      - Operation being performed during error.  Can be one of:
;              FUNC_DELETE - Delete files in pFrom
;              FUNC_RENAME - Rename files (same directory)
;              FUNC_MOVE   - Move files in pFrom to pTo (different disk)
;              FUNC_COPY   - Copy files in pFrom to pTo
; nOper      - Operation being performed.  Can be one of:
;              OPER_ERROR  - Error processing filenames
;              OPER_DOFILE - Go ahead and copy, rename, or delete file
;              OPER_MKDIR  - Make a directory specified in pTo
;              OPER_RMDIR  - Remove directory
;              0           - No more files left
;
; Return Value: None
;
; Written by C. Stevens, August 1991
;
============================================================================*/

VOID
CopyError(
         PSTR pszSource,
         PSTR pszDest,
         INT nError,
         WORD wFunc,
         INT nOper
         )
{
    CHAR szVerb[70];    /* Verb describing error */
    CHAR szReason[200]; /* Reason for error */
    BOOL bDest;

    bDest = nError & ERRORONDEST;    // was dest file cause of error
    nError &= ~ERRORONDEST;      // clear the dest bit

    if (nError == DE_OPCANCELLED)    // user abort
        return;

    if (!bCopyReport)        // silent, don't report errors
        return;

    LoadString(hAppInstance, IDS_COPYERROR + wFunc, szTitle, sizeof(szTitle));

    // get the verb string

    if (nOper == OPER_DOFILE || !nOper) {

        if (nError != 0xFFFF && bDest)
            // this is bogus, this could be IDS_CREATING as well...
            LoadString(hAppInstance, IDS_REPLACING, szVerb, sizeof(szVerb));
        else
            LoadString(hAppInstance, IDS_VERBS + wFunc, szVerb, sizeof(szVerb));

    } else {
        LoadString(hAppInstance, IDS_ACTIONS + (nOper >> 8), szVerb, sizeof(szVerb));
    }

    // get the reason string

    if (nError == 0xFFFF) {
        // special case LFN net error
        WNetErrorText(WN_NET_ERROR, szReason, sizeof(szReason));
    } else {
        // transform some error cases

        if (bDest) {
            if (nError != DE_ACCESSDENIED && GetFreeDiskSpace((WORD)DRIVEID(pszDest)) == 0L)
                nError = DE_NODISKSPACE;
        } else {
            if (nError == DE_ACCESSDENIED)
                nError = DE_ACCESSDENIEDSRC;    // soruce file access denied
        }

        LoadString(hAppInstance, IDS_REASONS + nError, szReason, sizeof(szReason));
    }

    // use the files names or "Selected files" if file list too long

    if (!nOper && (lstrlen(pszSource) > 64))
        LoadString(hAppInstance, IDS_SELECTEDFILES, pszSource, 32);

    wsprintf(szMessage, szVerb, (LPSTR)(bDest ? pszDest : pszSource), (LPSTR)szReason);

    MessageBox(hdlgProgress, szMessage, szTitle, MB_OK | MB_ICONSTOP);
}

/*============================================================================
;
; CopyAbort
;
; The following function aborts a queued copy operation.  The function closes
; all source and destination files, deleteing all destination files
; including and following the specified index.
;
; Parameters:
;
; nIndex - Index of first destination file to delete
;
; Return Value: None
;
; Written by C. Stevens, August 1991
;
============================================================================*/

VOID
APIENTRY
CopyAbort(VOID)
{
    INT i;
    PSTR pTemp;

    // close all source files

    for (i = 0; i < nCopyMaxQueue; i++) {
        if (pCopyQueue[i].hSource != -1)
            _lclose(pCopyQueue[i].hSource);
    }

    // close and delete (if necessary) destination files

    for (i = 0; i < nCopyMaxQueue; i++) {
        if (pCopyQueue[i].hDest != -1) {
            _lclose(pCopyQueue[i].hDest);

            if (!(pCopyQueue[i].wAttrib & ATTR_COPIED)) {
                pTemp = pCopyQueue[i].szDest;
                DeleteFile(pTemp);
            }
        }
    }

    if (lpCopyBuffer) {
        GlobalFreePtr(lpCopyBuffer);
        lpCopyBuffer = NULL;
    }
    if (pCopyQueue) {
        LocalFree((HANDLE)pCopyQueue);
        pCopyQueue = NULL;
    }

    nCopyMaxQueue = 0;   /* Clear other Copy Queue variables */
    nCopyNumQueue = 0;
}

/*============================================================================
;
; CopyMoveRetry
;
; The following function is used to retry failed move/copy operations
; due to out of disk situations or path not found errors
; on the destination.
;
; NOTE: the destination drive must be removable or this function
;   does not make a whole lot of sense
;
; Parameters:
;
; pszDest   - Fully qualified path to destination file
; nError    - Type of error which occured: DE_NODISKSPACE or DE_PATHNOTFOUND
;
; returns:
;   0   success (destination path has been created)
;   != 0    dos error code including DE_OPCANCELLED
;
============================================================================*/

INT
CopyMoveRetry(
             PSTR pszDest,
             INT nError
             )
{
    CHAR szReason[128]; /* Error message string */
    PSTR pTemp;         /* Pointer into filename */
    WORD wFlags;        /* Message box flags */
    INT  result;        /* Return from MessageBox call */

    do {     // until the destination path has been created

        GetWindowText(hdlgProgress, szTitle, sizeof(szTitle));

        if (nError == DE_PATHNOTFOUND) {

            LoadString(hAppInstance, IDS_PATHNOTTHERE, szReason, sizeof(szReason));

            /* Note the -1 below here is valid in both SBCS and DBCS because
               pszDest is fully qualified and the character preceding the
               file name must be a backslash */

            pTemp = FindFileName(pszDest) - 1;
            *pTemp = 0;
            wsprintf(szMessage, szReason, (LPSTR)pszDest);
            *pTemp = '\\';
            wFlags = MB_ICONEXCLAMATION | MB_YESNO;
        } else {
            wFlags = MB_ICONEXCLAMATION | MB_RETRYCANCEL;
            LoadString(hAppInstance, IDS_DESTFULL, szMessage, sizeof(szMessage));
        }

        result = MessageBox(hdlgProgress,szMessage,szTitle,wFlags);

        if (result == IDRETRY || result == IDYES) {

            // Allow the disk to be formatted
            if (!IsTheDiskReallyThere(hdlgProgress, pszDest, FUNC_COPY))
                return DE_OPCANCELLED;

            pTemp = FindFileName(pszDest) - 1;
            *pTemp = 0;
            result = WF_CreateDirectory(hdlgProgress, pszDest);
            *pTemp = '\\';

            // only as once if creating the destionation failed

            if (result == DE_OPCANCELLED)
                return DE_OPCANCELLED;
            if (result && (nError == DE_PATHNOTFOUND))
                return result | ERRORONDEST;
        } else
            return DE_OPCANCELLED;

    } while (result);

    return 0;        // success
}

BOOL
IsSerialDevice(
              INT hFile
              )
{
    UNREFERENCED_PARAMETER(hFile);
    return FALSE;  // BUG BUG. How to findout if its a serialdevice
}