windows-xp/Source/XPSP1/NT/termsrv/clcreator/copyfile.c

/*++

    Copyright (c) 1994  Microsoft Corporation

Module Name:

    COPYFILE.C

Abstract:

    file copy conf. dialog

Author:

    Bob Watson (a-robw)

Revision History:

    17 Feb 94    Written

--*/
//
//  Windows Include Files
//

#include <windows.h>
#include <stdio.h>
#include <malloc.h>
#include <tchar.h>      // unicode macros
//
//  app include files
//
#include "otnboot.h"
#include "otnbtdlg.h"
//
//  Debugging defines
//
#define SHOW_DEBUG_INFO     0

// local windows message

#define     NCDU_START_FILE_COPY    (WM_USER +101)

//
//  Static data for this module
//
static  BOOL    bCopying;       // 1= copying, 0 = done
static  DWORD   dwBytesCopied;  // running total of bytes copied
static  DWORD   dwTotalCBytes;  // total bytes divided by 100 (for % computation)
static  DWORD   dwCurrentPercent; // current percent copied

#define MAX_DOS_FILENAME_LENGTH (8 * sizeof(TCHAR))
#define MAX_DOS_FILE_EXT_LENGTH (3 * sizeof(TCHAR))

static
BOOL
DisplayScrunchedFilePath (
    IN  HWND    hWnd,
    IN  LPCTSTR szInPath
)
/*++

Routine Description:

    sets the window text of hWnd to be the "scrunched" version of
        the path string in szInPath. If the path string is too long
        to fit in a single line of hWnd, then directories are removed
        from the path until it does fit. The directories are removed
        from the "top" down. The root drive\dir is kept as is the
        filename and as many directories that will fit.

Arguments:

    IN  HWND    hWnd
        handle of window to put text in

    IN  LPCTSTR szInPath
        path to display in window

Return Value:

    TRUE    if no error
    FALSE   if error

--*/
{
    LPTSTR  szOutPath;
    RECT    rWindow;
    LONG    lWindowWidth;
    HDC     hDC;
    SIZE    sText;
    LONG    lRootBs, lRootBsCount;

    LPTSTR  szRootBs, szFileBs, szSrc, szDest, szDotsBs;

    GetWindowRect (hWnd, &rWindow); // get window size
    lWindowWidth = rWindow.right - rWindow.left;

    hDC = GetDC (hWnd);             // get DC for window

    szOutPath = GlobalAlloc (GPTR, ((lstrlen(szInPath) + 8) * sizeof(TCHAR)));
    if (szOutPath == NULL) {
        return FALSE;
    } else {
        //buffer allocation succeeded, so copy path to local buffer
        lstrcpy (szOutPath, szInPath);
    }

    if (IsUncPath(szOutPath)) {
        lRootBs = 4;    // the 4th backslash is the "Root" backslash for UNC
    } else {
        lRootBs = 1;    // for DOS file paths, the 1st backslash is the Root
    }

    GetTextExtentPoint32(hDC,
        szOutPath, lstrlen(szOutPath), &sText);

    szSrc = szDest = szOutPath;
    szDotsBs = szRootBs = szFileBs = NULL;
    lRootBsCount = 0;

    while (sText.cx > lWindowWidth) {
        // take dirs out until it fits
        // go through path string
        while (*szSrc != 0) {
            // see if we've passed the root
            if (szRootBs == NULL) {
                if (*szSrc == cBackslash) lRootBsCount++;
                if (lRootBsCount == lRootBs) szDotsBs = szRootBs = szDest;
            } else {
                // root's done, now were; working on the pathname
                // so we'll scope out the rest of the string
                if (*szSrc == cBackslash) szFileBs = szDest;
            }
            *szDest++ = *szSrc++;
        }
        if (szRootBs == NULL) {
            // then this is a bogus path so exit now
            break;
        }
        if (szFileBs == NULL) {
            // if the File backslash didn't get defined, then the file is
            // in the root directory and we should leave now, since there
            // isn't much to do about it.
            szFileBs = szRootBs;
            break;
        }
        // now yank a dir or two (more than one will be pulled if the dir
        // name is < 4 chars
        // if a directory hasn't been pulled, yet, go ahead
        // and take one out
        // initialize the pointers
        if (szRootBs == szDotsBs) {
            // then the ... havent been added so see if they'll fit and add em
            if ((szDotsBs+4) < szFileBs) {
                // they'll fit so addem
                szDest = szDotsBs + 1;
                *szDest++ = cPeriod;
                *szDest++ = cPeriod;
                *szDest++ = cPeriod;
                *szDest = cBackslash;
                szDotsBs = szDest;
                szSrc = ++szDest;
            } else {
                // no room to left to pull files
                break;
            }
        } else {
            // dot's have already been added so set pointers
            szSrc = szDest = szDotsBs+1;
        }
        // go to next dir
        while (*szSrc++ != cBackslash);
        // copy the rest of the string
        while (*szSrc != 0) *szDest++ = *szSrc++;

        *szDest = 0; // terminate the new string

        // get size of new string
        GetTextExtentPoint32(hDC,
            szOutPath, lstrlen(szOutPath), &sText);
    }

    // the string is as small as it's going to get so set the window text

    SetWindowText (hWnd, szOutPath);

    FREE_IF_ALLOC (szOutPath);

    return TRUE;

}

LONG
CreateDirectoryFromPath (
    IN  LPCTSTR                 szPath,
    IN  LPSECURITY_ATTRIBUTES   lpSA
)
/*++

Routine Description:

    Creates the directory specified in szPath and any other "higher"
        directories in the specified path that don't exist.

Arguments:

    IN  LPCTSTR szPath
        directory path to create (assumed to be a DOS path, not a UNC)

    IN  LPSECURITY_ATTRIBUTES   lpSA
        pointer to security attributes argument used by CreateDirectory


Return Value:

    TRUE    if directory(ies) created
    FALSE   if error (GetLastError to find out why)

--*/
{
    LPTSTR   szLocalPath;
    LPTSTR   szEnd;
    LONG     lReturn = 0L;

    szLocalPath = (LPTSTR)GlobalAlloc (GPTR, MAX_PATH_BYTES);

    if (szLocalPath == NULL) {
        SetLastError (ERROR_OUTOFMEMORY);
        return FALSE;
    } else {
        // so far so good...
        SetLastError (ERROR_SUCCESS); // initialize error value to SUCCESS
    }

    lstrcpy (szLocalPath, szPath);

    szEnd = &szLocalPath[3];

    if (*szEnd != 0) {
        // then there are sub dirs to create
        while (*szEnd != 0) {
            // go to next backslash
            while ((*szEnd != cBackslash) && (*szEnd != 0)) szEnd++;
            if (*szEnd == cBackslash) {
                // terminate path here and create directory
                *szEnd = 0;
                if (!CreateDirectory (szLocalPath, lpSA)) {
                    // see what the error was and "adjust" it if necessary
                    if (GetLastError() == ERROR_ALREADY_EXISTS) {
                        // this is OK
                        SetLastError (ERROR_SUCCESS);
                    } else {
                        lReturn = 0;
                    }
                } else {
                    // directory created successfully so update count
                    lReturn++;
                }
                // replace backslash and go to next dir
                *szEnd++ = cBackslash;
            }
        }
        // create last dir in path now
        if (!CreateDirectory (szLocalPath, lpSA)) {
            // see what the error was and "adjust" it if necessary
            if (GetLastError() == ERROR_ALREADY_EXISTS) {
                // this is OK
                SetLastError (ERROR_SUCCESS);
                lReturn++;
            } else {
                lReturn = 0;
            }
        } else {
            // directory created successfully
            lReturn++;
        }
    } else {
#ifndef TERMSRV
        // else this is a root dir only so return success.
        lReturn = 1;
#else // TERMSRV
        // for terminal server return FALSE.
        lReturn = 0;
#endif // TERMSRV

    }
    FREE_IF_ALLOC (szLocalPath);
    return lReturn;

}

static
DWORD
UpdatePercentComplete (
    IN  HWND    hwndDlg,
    IN  LPCTSTR  szFileName
)
/*++

Routine Description:

    Adds the size of the specified file to the running total of
        bytes copied and computes the current percentage of total
        copied. The display string is updated if the new percentage is
        different from the current percentage

Arguments:

    IN  HWND    hwndDlg
        Handle to dialog Box window

    IN  LPTSTR  szFileName
        filename (& path) of file whose size should be added to the
        current total bytes copied value.

Return Value:

    returns the current percentage of total bytes that have been
        copied (including this file)

--*/
{
    HANDLE  hFile;

    DWORD   dwFileSizeLow, dwFileSizeHigh;
    DWORD   dwPercent = 0;

    LPTSTR  szOutBuff;

    szOutBuff = (LPTSTR)GlobalAlloc (GPTR, MAX_PATH_BYTES);

    if (szOutBuff == NULL) return 0;

    if (dwTotalCBytes == 0) {
        SetDlgItemText (hwndDlg, NCDU_PERCENT_COMPLETE,
            GetStringResource (FMT_WORKING));
        dwPercent = 0;
    } else {
        hFile = CreateFile (
            szFileName,
            GENERIC_READ,
            (FILE_SHARE_READ | FILE_SHARE_WRITE),
            NULL,
            OPEN_EXISTING,
            FILE_ATTRIBUTE_NORMAL,
            NULL);

        if (hFile != INVALID_HANDLE_VALUE) {
            dwFileSizeLow = GetFileSize (hFile, &dwFileSizeHigh);
            if (dwFileSizeLow != 0xFFFFFFFF) {
                dwBytesCopied  += dwFileSizeLow;
                dwPercent = dwBytesCopied / dwTotalCBytes;
                if (dwPercent != dwCurrentPercent) {
                    if (dwPercent > 100) dwPercent = 100;
                    dwCurrentPercent = dwPercent;
                    _stprintf (szOutBuff,
                        GetStringResource (FMT_PERCENT_COMPLETE),
                        dwPercent);
                    SetDlgItemText (hwndDlg, NCDU_PERCENT_COMPLETE, szOutBuff);
                }
            }
            CloseHandle (hFile);
        }
    }

    FREE_IF_ALLOC (szOutBuff);

    return dwPercent;
}

static
BOOL
IsDosFileName (
    LPCTSTR   szName
)
/*++

Routine Description:

    examines string to see if it conforms to the DOS filename length
        conventions

Arguments:

        szName  filename and extension to parse


Return Value:

    TRUE     if it passes
    FALSE   if not

--*/
{
    LPTSTR   szNameBegin, szNameEnd;
    LPTSTR   szExtBegin, szExtEnd;
    LPTSTR   szDot;
    LPTSTR   szTmp;
    LPTSTR   szBack_slash;


    szBack_slash = szDot = NULL;
    szTmp = (LPTSTR)szName;

    while (*szTmp) {
        if (*szTmp == '.') szDot = szTmp;
        if (*szTmp == '\\') szBack_slash = szTmp;
        szTmp++;
    }

    // find beginning and end of each component

    if (szBack_slash) {
        // backslash char found in string, pointer points to
        // last occurance, name starts immediately after
        szNameBegin = szBack_slash + 1;
    } else {
        // no backslash char found so name starts at beginning
        // of string
        szNameBegin = (LPTSTR)szName;
    }

    if (szDot) {
        // dot char found in string
        if (szDot == szName) {
            // it's the first char in the string (i.e.
            // no filename)
            szNameEnd = (LPTSTR)szName;
            // a dot was found, then the extension starts right
            // after the dot
            szExtBegin = szDot + 1;
        } else if (szDot < szNameBegin) {
            // then there's no dot in the filename, but
            // it's somewhere else in the path
            szNameEnd = szTmp;
            // no dot so ext "begins" at the end of the string
            szExtBegin = szTmp;
        } else {
            // not the first char, and not before the filename
            // so the name ends with the dot
            szNameEnd = szDot;
            // a dot was found, then the extension starts right
            // after the dot
            szExtBegin = szDot + 1;
        }
    } else {
        // no dot was found in the string so there's no
        // file extension in this string. The end of the string
        // must be the end of the file name , and the beginning of
        // the extension (and also the end of the extension)
        szNameEnd = szTmp;
        szExtBegin = szTmp;
    }

    // the end of the file extension is always the end of the string
    szExtEnd = szTmp;

    // check the components for correct length:
    // 0 <= filename <= MAX_DOS_FILENAME_LENGTH (8)
    // 0 <= ext <= MAX_DOS_FILE_EXT_LENGTH (3)

    if ((LONG)(szNameEnd-szNameBegin) <= MAX_DOS_FILENAME_LENGTH) {
        // name is ok, check extension
        if ((LONG)(szExtEnd-szExtBegin) <= MAX_DOS_FILE_EXT_LENGTH) {
            return TRUE;
        } else {
            return FALSE;
        }
    } else {
        return FALSE;
    }
}

static
LONG
CopyDir (
    IN  HWND        hwndDlg,
    IN  LPCTSTR     szFromDir,
    IN  LPCTSTR     szToDir,
    IN  DWORD       dwFlags,
    IN  PDWORD      pdwFiles,
    IN  PDWORD      pdwDirs
)
/*++

Routine Description:

    Copies all files in the specified from directory to the specified
        to directory. Specific behavior is controlled by the flags as
        documented below.

Arguments:

    hwndDlg         window handle to dialog box
    szFromDir       directory containing files to copy
    szToDir         directory to recieve files
    dwFlags         Flags that control routine's behavior

                    CD_FLAGS_COPY_SUB_DIR   copies all sub dir's as well
                    CD_FLAGS_DONT_CREATE    default is to create dirs as needed
                    CD_FLAGS_IGNORE_ATTR    ignore attributes
                    CD_FLAGS_COPY_ATTR      copy attributes as well (default
                                                is for dest fils to be normal)
                    CD_FLAGS_IGNORE_ERROR   continue with copy even if errors occur
                    CD_FLAGS_LONG_NAMES     allows filenames longer than FAT
                    other bits are ignored
    pdwFiles        Pointer to DWORD that will get count of files copied
    pdwDirs         Pointer to DWORD that will get count of dirs created

Return Value:

    Win 32 status value
        ERROR_SUCCESS   routine completed normally

--*/
{
    LPTSTR   szFromPathName; // full path of FromDir
    LPTSTR   szFromFileName; // full path of source file
    LPTSTR   szFromFileStart; // pointer to where to attach file name to path
    LPTSTR   szSearchName;   // search file name
    LPTSTR   szToPathName;   // full path of destdir
    LPTSTR   szToFileName;   // full path of detination file name
    LPTSTR   szToFileStart;  // pointer to where to attach file name to path

    DWORD   dwFileAttributes;   // attributes of source file

    PWIN32_FIND_DATA    pwfdSearchData; // buffer used for file find ops
    HANDLE              hSearch;

    int     nMbResult;

    BOOL    bStatus;
    LONG    lStatus;

    MSG msg;

    DWORD   dwFileCopyCount;    // local counter variables
    DWORD   dwDirCreateCount;


    // allocate buffers

    szFromPathName = (LPTSTR)GlobalAlloc (GPTR, MAX_PATH * sizeof(TCHAR));
    szFromFileName = (LPTSTR)GlobalAlloc (GPTR, MAX_PATH * sizeof(TCHAR));
    szSearchName = (LPTSTR)GlobalAlloc (GPTR, MAX_PATH * sizeof(TCHAR));
    szToPathName = (LPTSTR)GlobalAlloc (GPTR, MAX_PATH * sizeof(TCHAR));
    szToFileName = (LPTSTR)GlobalAlloc (GPTR, MAX_PATH * sizeof(TCHAR));
    pwfdSearchData = (PWIN32_FIND_DATA)GlobalAlloc (GPTR, sizeof(WIN32_FIND_DATA));

    if (szFromPathName &&
        szFromFileName &&
        szSearchName &&
        szToPathName &&
        szToFileName &&
        pwfdSearchData) {

        // initialize counter fields (to support recursive calls)

        if (pdwFiles != NULL) {
            dwFileCopyCount = *pdwFiles;
        } else {
            dwFileCopyCount = 0;
        }

        if (pdwDirs != NULL) {
            dwDirCreateCount = *pdwDirs;
        } else {
            dwDirCreateCount = 0;
        }
        // get full pathnames of from & to files

        GetFullPathName (
            szFromDir,
            (DWORD)GlobalSize(szFromPathName) / sizeof(TCHAR),
            szFromPathName,
            NULL);

        GetFullPathName (
            szToDir,
            (DWORD)GlobalSize(szToPathName) / sizeof(TCHAR),
            szToPathName,
            NULL);

        lStatus = ERROR_SUCCESS;
    } else {
        lStatus = ERROR_OUTOFMEMORY;
    }

    if (lStatus == ERROR_SUCCESS) {
        // validate from dir and create target if valid

        dwFileAttributes = QuietGetFileAttributes (
            szFromPathName);

        if ((dwFileAttributes != 0xFFFFFFFF) &&
            (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
            // from directory is for real so create or check
            // target dir now

            if (dwFlags & CD_FLAGS_DONT_CREATE) {
                // if don't create, then at least validate
                dwFileAttributes = QuietGetFileAttributes (
                    szToPathName);

                if ((dwFileAttributes != 0xFFFFFFFF) &&
                    (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
                    lStatus = ERROR_SUCCESS;
                } else {
                    lStatus = ERROR_DIRECTORY;
                }
            } else {
                // create sub dirs if necessary
                if (!(dwFlags & CD_FLAGS_LONG_NAMES)) {
                    // check to see if name conforms to DOS 8.3 format
                    if (!IsDosFileName(szFromPathName)) {
                        lStatus = ERROR_FILENAME_EXCED_RANGE;
                    } else {
                        lStatus = ERROR_SUCCESS;
                    }

                } else {
                    lStatus = ERROR_SUCCESS;
                }

                if (lStatus == ERROR_SUCCESS) {
                    lStatus = CreateDirectoryFromPath (
                        szToPathName, NULL);
                    if (lStatus == 0) {
                        lStatus = GetLastError();
                        if (lStatus == ERROR_ALREADY_EXISTS) {
                            // this is OK
                            lStatus = ERROR_SUCCESS;
                            // no dirs were created so don't change the
                            // count.
                        }
                    } else {
                        // if lStatus is not 0, then it's then number of
                        // directories that were created
                        dwDirCreateCount += lStatus;
                        // now set it to the Error Status value the rest of the function
                        // is expecting
                        lStatus = ERROR_SUCCESS;
                    }
                }
            }
        } else {
            lStatus = ERROR_DIRECTORY;
        }
    }

    if (lStatus == ERROR_SUCCESS) {
        // if target directory is valid, then
        // create filename bases and start copying files

        lstrcpy (szFromFileName, szFromPathName);
        if (szFromFileName[lstrlen(szFromFileName)-1] != cBackslash) lstrcat (szFromFileName, cszBackslash);
        szFromFileStart = szFromFileName + lstrlen(szFromFileName);

        lstrcpy (szToFileName, szToPathName);
        if (szToFileName[lstrlen(szToFileName)-1] != cBackslash) lstrcat (szToFileName, cszBackslash);
        szToFileStart = szToFileName + lstrlen(szToFileName);

        // create search name

        lstrcpy (szSearchName, szFromPathName);
        lstrcat (szSearchName, cszWildcardFile);

        hSearch = FindFirstFile (
            szSearchName,
            pwfdSearchData);

        if (hSearch != INVALID_HANDLE_VALUE) {
            lStatus = ERROR_SUCCESS;
            bStatus = TRUE;
            while (((lStatus == ERROR_SUCCESS) && bStatus)  && bCopying) {
                // check & save file attributes of each file, if not
                // normal, then ignore unless flag set
                //
                lstrcpy (szFromFileStart, pwfdSearchData->cFileName); //make full path

                if (!DotOrDotDotDir(pwfdSearchData->cFileName)) { //ignore these dirs
                    dwFileAttributes = QuietGetFileAttributes(
                        szFromFileName);

                    if (dwFileAttributes != 0xFFFFFFFF) {
                        // attributes are valid, so
                        // make full pathname of source file found
                        // and dest. file to be created
                        lstrcpy (szToFileStart, pwfdSearchData->cFileName); //make full path

                        if (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
                            // if it's a dir and subdirs is true, then
                            // copy them too if the copy sub dir flag is set

                            if (dwFlags & CD_FLAGS_COPY_SUB_DIR) {
                                lStatus = CopyDir (
                                    hwndDlg,
                                    szFromFileName,
                                    szToFileName,
                                    dwFlags,
                                    &dwFileCopyCount,
                                    &dwDirCreateCount);
                            } else {
                                // ignore directories if flag not set
                            }
                        } else { // not a dir, so see if we can copy it
                            if (lStatus == ERROR_SUCCESS) {
                                // copy the file if either the ignore bit is
                                // set or the attributes are OK
                                //
                                if (!(dwFlags & CD_FLAGS_LONG_NAMES)) {
                                    // check to see if name conforms to DOS 8.3 format
                                    if (!IsDosFileName(szFromFileName)) {
                                        lStatus = ERROR_FILENAME_EXCED_RANGE;
                                    } else {
                                        lStatus = ERROR_SUCCESS;
                                    }
                                }

                                DisplayScrunchedFilePath (
                                    GetDlgItem (hwndDlg, NCDU_FROM_PATH),
                                    (LPCTSTR)_tcslwr(szFromFileName));

                                DisplayScrunchedFilePath (
                                    GetDlgItem (hwndDlg, NCDU_TO_PATH),
                                    (LPCTSTR)_tcslwr(szToFileName));

                                if (lStatus == ERROR_SUCCESS) {
                                    bStatus = CopyFile(
                                        szFromFileName,
                                        szToFileName,
                                        FALSE);         // overwrite existing file

                                    //verify file was created
                                    if (bStatus) {
                                        if (QuietGetFileAttributes(szToFileName) == 0xFFFFFFFF) {
                                            // unable to read attributes of created file
                                            // so return error
                                            lStatus = ERROR_CANNOT_MAKE;
                                        }
                                    } else {
                                        // get copy error
                                        lStatus = BOOL_TO_STATUS (bStatus);
                                    }
                                }

                                // if copy successful reset source file attributes
                                // and optionally destination file attributes

                                if (lStatus == ERROR_SUCCESS) {
                                    // set file attributes to NORMAL
                                    SetFileAttributes (
                                        szToFileName,
                                        FILE_ATTRIBUTE_NORMAL);
                                    // update filesize
                                    UpdatePercentComplete(hwndDlg, szFromFileName);
                                    // update count
                                    dwFileCopyCount++;
                                } else {
                                    // bail out here since there was a copy error
                                    nMbResult = MessageBox (
                                        hwndDlg,
                                        GetStringResource (CSZ_UNABLE_COPY),
                                        szFromFileName,
                                        MB_OKCANCEL_TASK_EXCL);
                                    if (nMbResult == IDCANCEL) {
                                        bCopying = FALSE;
                                    }
                                    // the error has already been handled so return
                                    // success to prevent the calling routine from
                                    // signalling this error
                                    lStatus = ERROR_SUCCESS;
                                }

                                // check for messages

                                while (PeekMessage (&msg, 0, 0, 0, PM_REMOVE)) {
                                    TranslateMessage (&msg);
                                    DispatchMessage (&msg);
                                }
                            }
                        }
                    } else {
                        lStatus = GetLastError();
                    }
                }

                if (dwFlags & CD_FLAGS_IGNORE_ERROR) {
                    // if ignore error, then set to success
                    lStatus = ERROR_SUCCESS;
                }

                if (lStatus == ERROR_SUCCESS) {
                    bStatus = FindNextFile (
                        hSearch,
                        pwfdSearchData);
                } else {
                    bStatus = FALSE;    // abort loop
                }
            } // end while files in dir
            FindClose (hSearch);
        } else {
            // invalid find handle so return error
            lStatus = GetLastError();
        }
    } // end of valid directory block

    FREE_IF_ALLOC(szFromPathName);
    FREE_IF_ALLOC(szFromFileName);
    FREE_IF_ALLOC(szSearchName);
    FREE_IF_ALLOC(szToPathName);
    FREE_IF_ALLOC(szToFileName);
    FREE_IF_ALLOC(pwfdSearchData);

    // set the counter fields if they were passed in

    if (pdwFiles != NULL) {
        *pdwFiles = dwFileCopyCount;
    }

    if (pdwDirs != NULL) {
        *pdwDirs = dwDirCreateCount;
    }

    return lStatus;
}

static
BOOL
CopyFileDlg_NCDU_START_FILE_COPY (
    IN  HWND    hwndDlg,
    IN  WPARAM  wParam,
    IN  LPARAM  lParam
)
/*++

Routine Description:

    Formats values from Dialog Box parameter structure to argument list of
        copy directory function

Arguments:

    IN  HWND    hwndDlg
        handle to dialog box window

    IN  WPARAM  wParam
        Not Used

    IN  LPARAM  lParam
        address of copy file structure.

Return Value:

    FALSE, always

--*/
{
    PCF_DLG_DATA pCF;

    pCF = (PCF_DLG_DATA)lParam;

#if SHOW_DEBUG_INFO
    // debug message box
    {
        LPTSTR  szMessageBuffer;
        DWORD   dwSourceAttr, dwDestAttr;
        UINT    nMbReturn;

        szMessageBuffer = GlobalAlloc (GPTR, SMALL_BUFFER_SIZE);
        if (szMessageBuffer != NULL) {
            dwSourceAttr = QuietGetFileAttributes (pCF->szSourceDir);
            dwDestAttr = QuietGetFileAttributes (pCF->szDestDir);
            _stprintf (szMessageBuffer,
                fmtPrepareToCopy,
                pCF->szDisplayName,
                pCF->szSourceDir, dwSourceAttr,
                pCF->szDestDir, dwDestAttr,
                pCF->dwCopyFlags);
            nMbReturn = MessageBox (hwndDlg,
                szMessageBuffer,
                cszDebug,
                MB_OKCANCEL_TASK_INFO);
            FREE_IF_ALLOC (szMessageBuffer);
        } else {
            nMbReturn = IDOK;
        }

        if (nMbReturn == IDCANCEL) {
            // then bail here
            EndDialog (hwndDlg, IDCANCEL);
            return TRUE;
        }
    }
#endif

    if (CopyDir (
        hwndDlg,
        pCF->szSourceDir,
        pCF->szDestDir,
        pCF->dwCopyFlags,
        &pCF->dwFilesCopied,
        &pCF->dwDirsCreated)  != ERROR_SUCCESS) {

        // display error message
        DisplayMessageBox (
            hwndDlg,
            CSZ_COPY_ERROR,
            0L,
            MB_OK_TASK_EXCL);
        bCopying = FALSE;  // to indicate error or non-completion

    }

    EndDialog (hwndDlg, (bCopying ? IDOK : IDCANCEL));

    return TRUE;
}

static
BOOL
CopyFileDlg_WM_INITDIALOG (
    IN  HWND    hwndDlg,
    IN  WPARAM  wParam,
    IN  LPARAM  lParam
)
/*++

Routine Description:

    Dialog box initialization routine.

Arguments:

    IN  HWND    hwndDlg
        Handle to dialog box window

    IN  WPARAM  wParam
        not used

    IN  LPARAM  lParam
        address of Copy file data structure passed by calling routine.

Return Value:

    FALSE   if valid param block address
    TRUE    if not

--*/
{
    PCF_DLG_DATA pCF;

    pCF = (PCF_DLG_DATA)lParam;

    if (pCF != NULL) {
        // intialize Global data
        bCopying = TRUE;

        dwBytesCopied = 0;
        dwCurrentPercent = 0;
        dwTotalCBytes = (pCF->dwTotalSize + 50) / 100;

        PositionWindow  (hwndDlg);
        SetDlgItemText (hwndDlg, NCDU_COPY_APPNAME, pCF->szDisplayName);
        SetDlgItemText (hwndDlg, NCDU_FROM_PATH, cszEmptyString);
        SetDlgItemText (hwndDlg, NCDU_TO_PATH, cszEmptyString);
        SetDlgItemText (hwndDlg, NCDU_PERCENT_COMPLETE,
            GetStringResource (FMT_ZERO_PERCENT_COMPLETE));
        SetFocus (GetDlgItem(hwndDlg, IDCANCEL));
        // start copying files
        PostMessage (hwndDlg, NCDU_START_FILE_COPY, 0, lParam);
        return FALSE;
    } else {
        // illegal parameter
        EndDialog (hwndDlg, IDCANCEL);
        return TRUE;
    }
}

static
BOOL
CopyFileDlg_WM_COMMAND (
    IN  HWND    hwndDlg,
    IN  WPARAM  wParam,
    IN  LPARAM  lParam
)
/*++

Routine Description:

    Processes WM_COMMAND messages to dialog box.
        Only IDCANCEL button is processed here (ceasing copy function)
        all other button commands are ignored (since there aren't any)

Arguments:

    IN  HWND    hwndDlg
        handle to dialog box window

    IN  WPARAM  wParam
        LOWORD   has the id of the control that issued the message

    IN  LPARAM  lParam
        Not used.

Return Value:

    if button is IDCANCEL, then FALSE
    otherwise TRUE (i.e. not processed.)

--*/
{
    switch (LOWORD(wParam)) {
        case IDCANCEL:
            switch (HIWORD(wParam)) {
                case BN_CLICKED:
                    if (DisplayMessageBox(hwndDlg,
                        NCDU_RU_SURE, 0,
                        MB_OKCANCEL_TASK_EXCL_DEF2) == IDOK) {
                        bCopying = FALSE;
                    }
                    return TRUE;

                default:
                    return FALSE;
            }

        default:    return FALSE;
    }
}

INT_PTR CALLBACK
CopyFileDlgProc (
    IN  HWND    hwndDlg,
    IN  UINT    message,
    IN  WPARAM  wParam,
    IN  LPARAM  lParam
)
/*++

Routine Description:

    Main Dialog box window proc. Processes the following windows messages:
        WM_INITDIALOG:          dialog box initialization procedure
        WM_COMMAND:             windows messages (resulting from user commands)
        NCDU_START_FILE_COPY:   local message to begin copying files

    all other messages are processed by the DefDialogProc

Arguments:

    Standard WNDPROC arguments

Return Value:

    FALSE if not processed, otherwise value returned by
        called routine.

--*/
{
    switch (message) {
        case WM_INITDIALOG: return (CopyFileDlg_WM_INITDIALOG (hwndDlg, wParam, lParam));
        case WM_COMMAND:    return (CopyFileDlg_WM_COMMAND (hwndDlg, wParam, lParam));
        case NCDU_START_FILE_COPY: return (CopyFileDlg_NCDU_START_FILE_COPY (hwndDlg, wParam, lParam));
        default:            return FALSE;
    }
}