#include <nt.h>    // For shutdown privilege.
#include <ntrtl.h>
#include <nturtl.h>

#include <windows.h>
#include "getbin.h"

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <locale.h>
#include <process.h>
#include <windows.h>

#define MV_FLAGS (MOVEFILE_REPLACE_EXISTING | MOVEFILE_DELAY_UNTIL_REBOOT)

#define CCH_BUF             512
#define RES_DLGOPTIONS      1

#define VerbosePrintf   if (gbVerbose) printf

char *gszVERSION = "16.1";
INT_PTR CALLBACK OptionsDlgProc (HWND, UINT, WPARAM, LPARAM);


CONST CHAR szDEFSAVEEXT[] = "lst";
CONST CHAR szSAVEEXT[] = "SaveExtension";
CONST CHAR szDEFCOPYEXT[] = "dll";
CONST CHAR szJUNKEXT[] = "yuk";
CONST CHAR szDEST[] = "Dest";
CONST CHAR szSYMS[] = "Symbols";
CONST CHAR szSOURCE[] = "Source";
CONST CHAR szSYSTEM32[] = "SYSTEM32";
CONST CHAR szSYMBOLS[] = "SYMBOLS";
CONST CHAR szGETBIN[] = "Getbin";
CONST CHAR szGETBINDIR[] = "GetbinSourceDir";
CONST CHAR szWINDIR[] = "windir";

CHAR szTRYRENAME[] = "TryRename";
CHAR szTRYCOPY[] = "TryCopy";
CHAR szPOLL[] = "Poll";
CHAR szREBOOT[] = "Reboot";
CHAR szSAVEPREVIOUS[] = "SavePrevious";
CHAR szRESTORECMD[] = "Restore.Cmd";
CHAR szCOPYDBGTOO[] = "CopyDbgToo";
CHAR szCOPYSOURCETYPE[] = "CopySourceType";

BOOL gbTryRename = TRUE;
BOOL gbDelayCopy = FALSE;
BOOL gbTryCopy = TRUE;
BOOL gbPoll = FALSE;
BOOL gbVerbose = FALSE;
BOOL gbReboot = FALSE;
BOOL gbSavePrevious = FALSE;
BOOL gbRestoreCmd = FALSE;
BOOL gbCopyDbgToo = FALSE;
BOOL gbForceTempCopy = FALSE;
HANDLE ghRestoreCmd = NULL; // file handle for Restore.Cmd

BOOL giCopySourceType = IDD_COPY_COMMAND;

CHAR gszDestDir[CCH_BUF];          // typically "c:\winnt\system32"
CHAR gszDriverDestDir[CCH_BUF+8];  // typically "c:\winnt\system32\drivers"
CHAR gszSymsDir[CCH_BUF];
CHAR gszSourceDir[CCH_BUF];
CHAR gszWinDir[CCH_BUF];
CHAR gszSaveExtension[4];
CHAR gszCopyExtension[4];

#define GB_FILE_ITSELF         0
#define GB_ASSOCIATED_DBG_FILE 1
#define GB_ASSOCIATED_PDB_FILE 2

BOOL DoGetbin(LPSTR szFileName, DWORD dwAssociatedFile);

void PrintUsage(void) {
    printf("Getbin version %s\n", gszVERSION);
    printf("usage: getbin [-c] [-d] [-D] [-l] [-r] [-t] [-w] <filename> [[-w] <filename>]...\n");
    printf("    -c create Restore.Cmd\n");
    printf("    -d delay copy until reboot\n");
    printf("    -D copy DBG/PDB files too\n");
    printf("    -l copy old file to *.lst\n");
    printf("    -w <filename> : wait for <filename> to be updated\n");
    printf("    -r reboot after copy\n");
    printf("    -t copy when date of src is newer\n");
    printf("    -T Force temp copy when using -d\n");
    printf("    -v old-style verbose output\n");
    printf("usage: getbin -o\n");
    printf("       GUI biset options\n");

}

int __cdecl main (int argc, char *argv[])
{
    DWORD dwRet;
    int iArg = 1;
    int nFiles = 0;
    UINT Codepage;
    char achCodepage[6] = ".OCP";


    if (argc <= 1) {
        PrintUsage();
        ActivateKeyboardLayout((HKL)(HKL_NEXT), KLF_SETFORPROCESS);
        exit(0);
    }

    /*
     * This is mainly here as a good example of how to set a character-mode
     * application's codepage.
     * This affects C-runtime routines such as mbtowc(), mbstowcs(), wctomb(),
     * wcstombs(), mblen(), _mbstrlen(), isprint(), isalpha() etc.
     * To make sure these C-runtimes come from msvcrt.dll, use TARGETLIBS in
     * the sources file, together with TARGETTYPE=PROGRAM (and not UMAPPL?)
     */
    if (Codepage = GetConsoleOutputCP()) {
        sprintf(achCodepage, ".%3.4d", Codepage);
    }
    setlocale(LC_ALL, achCodepage);

    /*
     * chcp to a different codepage and test what isalpha() determines.
     *  cp437:d0 is not a char (Box Drawings Up Double And Horizontal Single)
     *  cp850:d0 is a char     (Latin Small Letter Eth)
     *  cp852:d0 is a char     (Latin Small Letter D With Stroke)
     * cp1251:d0 is a char     (Cyrillic Capital Letter Er)
     * cp1252:d0 is a char     (Latin Capital Letter Eth)
     */
    isalpha(0xd0);

    dwRet = GetEnvironmentVariable( szWINDIR, gszWinDir, sizeof(gszWinDir)/sizeof(gszWinDir[0]));
    if (!dwRet) {
        gszWinDir[0] = '\0';
    }

    /*
     * Get the defaults
     *
     * Destination Directory
     */
    if (GetProfileString(szGETBIN, szDEST, "", gszDestDir, sizeof(gszDestDir)) < 2) {
        if (gszWinDir[0] == '\0') {
            printf("Getbin: can not read environment string %s.\n", szWINDIR);
            exit(0);
        }
        sprintf(gszDestDir, "%s\\%s", gszWinDir, szSYSTEM32);
    }
    _strupr(gszDestDir);
    strcpy(gszDriverDestDir, gszDestDir);
    strcat(gszDriverDestDir, "\\drivers");

    if (GetProfileString(szGETBIN, szSYMS, "", gszSymsDir, sizeof(gszSymsDir)) < 2) {
        if (szWINDIR[0] == '\0') {
            printf("Getbin: can not read environment string %s.\n", szWINDIR);
            exit(0);
        }
        sprintf(gszSymsDir, "%s\\%s", gszWinDir, szSYMBOLS);
    }
    _strupr(gszSymsDir);

    GetProfileString(szGETBIN, szSOURCE, "", gszSourceDir, sizeof(gszSourceDir));

    gbTryRename = GetProfileInt(szGETBIN, szTRYRENAME, gbTryRename);
    gbTryCopy = GetProfileInt(szGETBIN, szTRYCOPY, gbTryCopy);
    gbPoll = GetProfileInt(szGETBIN, szPOLL, gbPoll);
    gbReboot = GetProfileInt(szGETBIN, szREBOOT, gbReboot);
    gbSavePrevious = GetProfileInt(szGETBIN, szSAVEPREVIOUS, gbSavePrevious);
    gbRestoreCmd = GetProfileInt(szGETBIN, szRESTORECMD, gbRestoreCmd);
    if (gbRestoreCmd) {
        gbSavePrevious = TRUE;
    }

    gbCopyDbgToo = GetProfileInt(szGETBIN, szCOPYDBGTOO, gbCopyDbgToo);
    giCopySourceType = GetProfileInt(szGETBIN, szCOPYSOURCETYPE, giCopySourceType);
    GetProfileString(szGETBIN, szSAVEEXT, szDEFSAVEEXT, gszSaveExtension, sizeof(gszSaveExtension));

    /*
     * Compute the flags
     */

// printf("argc %lX %s %s %s\n", argc, argv[0], argv[1], argv[2] );
    for (iArg=1; iArg<argc; iArg++) {
        if (argv[iArg][0] == '-') {
            switch (argv[iArg][1]) {
            case 'c':
                gbRestoreCmd = TRUE;
                // need to save the previous files then!
                gbSavePrevious = TRUE;
                break;
            case 'D':
                gbCopyDbgToo = TRUE;
                break;
            case 'd':
                gbDelayCopy = TRUE;
                break;
            case 'r':
                gbReboot = TRUE;
                break;
            case 'l':
                gbSavePrevious = TRUE;
                break;
            case 't':
                giCopySourceType;   //!!!
                break;
            case 'T':
                gbForceTempCopy = TRUE;
                break;
            case 'o':
                DialogBox(GetModuleHandle(NULL), MAKEINTRESOURCE(RES_DLGOPTIONS), NULL, OptionsDlgProc);
                return 1;
                break;
            case 'v':
                gbVerbose = TRUE;
                break;
            case 'w':
                gbPoll = TRUE;
                break;

            default:
                printf("ERROR: Invalid flag %c\n", argv[iArg][1]);
            case '?':
                PrintUsage();
                exit(0);
                break;
            }
        } else {
            if (!DoGetbin(argv[iArg], GB_FILE_ITSELF)) {
                gbReboot = FALSE;
            } else if (gbCopyDbgToo) {
                // got the binary, so now get the DBG & PDB file
                BOOL bGotDbg, bGotPdb;

                bGotDbg = DoGetbin(argv[iArg], GB_ASSOCIATED_DBG_FILE);
                bGotPdb = DoGetbin(argv[iArg], GB_ASSOCIATED_PDB_FILE);
                if (!bGotDbg && !bGotPdb) {
                    // if we didn't get either, then fail to reboot.
                    gbReboot = FALSE;
                }
            }
            nFiles++;
        }
    }

    if (nFiles == 0) {
        printf("ERROR: No files specified\n");
        PrintUsage();
        exit(0);
    }

    /*
     * Reboot if requested
     */
    if (gbReboot) {
        BOOLEAN PreviousPriv;

        printf("\nRebooting system\n");
        Sleep(5000);
        RtlAdjustPrivilege(SE_SHUTDOWN_PRIVILEGE, TRUE, FALSE, &PreviousPriv);
        ExitWindowsEx(EWX_FORCE|EWX_REBOOT, 0);
    }

    CloseHandle(ghRestoreCmd);

    return 1;
}

#define ENTER 0x0d

BOOL fConfirm(char *pszQuestion)
{
    int ch, chLast;

    chLast = 0;
    printf ("%s [yn] ", pszQuestion);
    while ( TRUE ) {

        ch = _getch();
        ch = tolower( ch );

        if (ch == ENTER && (chLast == 'y' || chLast == 'n')) {
            putchar('\n');
            return (chLast == 'y');
        }

        if (ch != 0) {
            if (ch == 'y' || ch == 'n') {
                putchar(ch);
                putchar('\b');
            }
        }
        chLast = ch;
    }
}

#define F_TIME 0x01
#define F_DATE 0x02

LPWSTR DateTimeString(
    CONST FILETIME *pft,
    DWORD Flags)
{
    SYSTEMTIME DateTime;
    FILETIME LocalFileTime;
    static WCHAR wszDateTime[80];
    int cch;

    FileTimeToLocalFileTime(pft, &LocalFileTime);
    FileTimeToSystemTime(&LocalFileTime, &DateTime);

    if (Flags == 0) {
        Flags = F_TIME;
    }
    if (Flags & F_DATE) {
        cch = GetDateFormatW(LOCALE_USER_DEFAULT,
                             LOCALE_NOUSEROVERRIDE,
                             &DateTime,
                             NULL,
                             wszDateTime,
                             sizeof(wszDateTime)/sizeof(wszDateTime[0]) - 1);
        wszDateTime[cch-1] = '\t';
    } else {
        cch = 0;
    }

    if (Flags & F_TIME) {
        GetTimeFormatW(LOCALE_USER_DEFAULT,
                       LOCALE_NOUSEROVERRIDE,
                       &DateTime,
                       NULL,
                       &wszDateTime[cch],
                       sizeof(wszDateTime)/sizeof(wszDateTime[0]) - cch);
    }
    return wszDateTime;
}

DWORD PrintFileSize(
    CONST LPSTR pszFile)
{
    HANDLE hFindNext;
    WIN32_FIND_DATA FindFileData;

    hFindNext = FindFirstFile(pszFile, &FindFileData);
    if (hFindNext != INVALID_HANDLE_VALUE) {
        FindClose(hFindNext);
    }
    printf("Size %ld\n", FindFileData.nFileSizeLow);
    return FindFileData.nFileSizeLow;
}

/*
 * Poll for a file, returns TRUE when the file is ready to be fetched, FALSE if not
 */
BOOL PollForFile(
    CONST LPSTR szSrc,
    CONST LPSTR szDest,
    CONST LPSTR szSourceFile)  // just for re-printing the name when !gbVerbose
{
    FILETIME ftLastWriteSrc = {0, 0};
    FILETIME ftLastWriteDest = {0, 0};
    HANDLE hFindNext;
    WIN32_FIND_DATA FindFileData;
    FILETIME ft;
    SYSTEMTIME DateTime;
    OFSTRUCT OpenBuff;

    /*
     * Get last write time of destination (ftLastWriteDest)
     */
    hFindNext = FindFirstFile(szDest, &FindFileData);
    if (hFindNext != INVALID_HANDLE_VALUE) {
        FindClose(hFindNext);
        ftLastWriteDest = FindFileData.ftLastWriteTime;
        printf("\n  Time of destination = %ws\n",
               DateTimeString(&ftLastWriteDest, F_DATE|F_TIME));
    } else {
        printf("Can't find destination %s\n", szDest);
    }

    /*
     * Give the user a chance to pull down the current source if it is already
     * more recent than the destination.
     * If they want an even more recent source, Wait until the source file
     * starts getting updated.
     */
    while (TRUE) {
        hFindNext = FindFirstFile(szSrc, &FindFileData);
        if (hFindNext != INVALID_HANDLE_VALUE) {
            FindClose(hFindNext);
            if ((ftLastWriteSrc.dwHighDateTime | ftLastWriteSrc.dwLowDateTime) == 0) {
                ftLastWriteSrc = FindFileData.ftLastWriteTime;
                printf("  Time of source      = %ws\n",
                       DateTimeString(&ftLastWriteSrc, F_DATE|F_TIME));
                if (CompareFileTime(&ftLastWriteSrc, &ftLastWriteDest) > 0) {
                    // Source is more recent!
                    if (fConfirm("  Source is more recent, fetch it now?")) {
                        return TRUE;
                    }
                }
                printf("  Polling for a new %s", szSrc);
                fflush(stdout);
            } else {
                if (CompareFileTime(&FindFileData.ftLastWriteTime, &ftLastWriteSrc) > 0) {
                    // it got updated!
                    break;
                }
            }
        } else {
            /*
             * Source not there yet, we want to grab it as soon as it is ready
             */
            ftLastWriteSrc.dwLowDateTime = 1;
        }
        printf(".");
        Sleep(1000);
    }

    /*
     * The source is being written, so wait until the write stops
     * (When the write has finished, we will be able to open it exclusively)
     */
    do {
        HANDLE hTmp;
#ifdef DBG_POLL
        /*
         * This debug stuff show if & how the source file's timestamps & size
         * vary each time we go around the loop.
         */
        DWORD dwSizeH, dwSizeL;
        FILETIME ftC, ftA, ftW;
        ftC = FindFileData.ftCreationTime;
        ftA = FindFileData.ftLastAccessTime;
        ftW = FindFileData.ftLastWriteTime;
        dwSizeH = FindFileData.nFileSizeHigh;
        dwSizeL = FindFileData.nFileSizeLow;

        hFindNext = FindFirstFile(szSrc, &FindFileData);
        if (hFindNext == INVALID_HANDLE_VALUE) {
            break;
        }
        FindClose(hFindNext);

        /*
         * Some debug output each time we see that the src file has
         * changed size or timestamps.
         */
        if ((CompareFileTime(&ftA, &FindFileData.ftLastAccessTime) != 0) ||
            (CompareFileTime(&ftW, &FindFileData.ftLastWriteTime) != 0) ||
            (CompareFileTime(&ftC, &FindFileData.ftCreationTime) != 0) ||
            (dwSizeH != FindFileData.nFileSizeHigh) ||
            (dwSizeL != FindFileData.nFileSizeLow)) {
            printf("Create %ws   ",
                   DateTimeString(&FindFileData.ftCreationTime, F_TIME));
            printf("Access %ws   ",
                   DateTimeString(&FindFileData.ftLastAccessTime, F_TIME));
            ft = FindFileData.ftLastWriteTime;
            printf("Write %ws   ", DateTimeString(&ft, F_TIME));
            printf("Size %ld\n", dwSizeL);
        }
#endif

        /*
         * If we can open the file for writing, no other process has it open
         */
        hTmp = CreateFileA(
                          szSrc,
                          GENERIC_READ | GENERIC_WRITE,  // write access
                          0,                             // no sharing
                          NULL,                          // no Security Attributes
                          OPEN_EXISTING,                 // of course
                          FILE_ATTRIBUTE_NORMAL |        // whatever
                          FILE_FLAG_NO_BUFFERING,        // why not?
                          NULL);                         // no template
        if (hTmp != INVALID_HANDLE_VALUE) {
            CloseHandle(hTmp);
            break;
        }

        /*
         * If the share is read-only, the trick above won't work so we wait
         * for 1 second and then take it.
         */
        if (GetLastError() == ERROR_ACCESS_DENIED) {
            int i;
            printf("\n  %s is read-only, delay 5 seconds", szSrc);
            fflush(stdout);
            for (i = 0; i < 5; i++) {
                Sleep(1000);
                printf(".");
            }
            break;
        }
        printf("+");
        Sleep(500);
    } while (TRUE);

    /*
     * One last delay (for splitsym etc.)
     */
    Sleep(500);

    /*
     * Find out how big the file is now, just for the heck of it.
     */
    hFindNext = FindFirstFile(szSrc, &FindFileData);
    if (hFindNext != INVALID_HANDLE_VALUE) {
        FindClose(hFindNext);
    }
    VerbosePrintf("  Size %ld\n", FindFileData.nFileSizeLow);
    if (!gbVerbose) {
        printf("\n%s", szSourceFile);
        fflush(stdout);
    }
    return TRUE;
}

BOOL DoGetbin(
     LPSTR szFileName,
     DWORD dwAssociatedFile)
{
    BOOL bNetDrive = FALSE;
    BOOL bRet;
    BOOL bSkipDebugFiles = FALSE;
    DWORD dwRet;
    CHAR szDest[CCH_BUF];  // !! to go
    CHAR szTempFile[CCH_BUF];
    CHAR szSrc[CCH_BUF];
    CHAR szBackup[CCH_BUF];
    CHAR szSourceFile[CCH_BUF];
    CHAR szExt[10];
    PCHAR pszSrc = szSrc;
    PCHAR pszDot;
    WIN32_FIND_DATA FindFileData;

    /*
     * Get the source and destination files
     */
    strcpy( szSourceFile, szFileName );

    /*
     * Add the default extension if no extension of this file
     */
    pszDot = strrchr(szSourceFile, '.');
    if (pszDot == NULL) {
        pszDot = szSourceFile + strlen(szSourceFile);
        *pszDot = '.';
        strcpy( pszDot+1, szDEFCOPYEXT);
    }
    strcpy( szExt, pszDot+1);

    if ((_stricmp(szSourceFile, "win32k.sys") == 0) ||
            (_stricmp(szSourceFile, "user.exe") == 0)) {
        bSkipDebugFiles = TRUE;
    }

    switch (dwAssociatedFile) {
    case GB_ASSOCIATED_DBG_FILE:
        strcpy(pszDot+1, "dbg");
        sprintf(szDest, "%s\\%s\\%s", gszSymsDir, szExt, szSourceFile);
        sprintf(szSrc,  "%s\\symbols\\retail\\%s\\%s", gszSourceDir, szExt, szSourceFile);
        break;

    case GB_ASSOCIATED_PDB_FILE:
        strcpy(pszDot+1, "pdb");
        sprintf(szDest, "%s\\%s\\%s", gszSymsDir, szExt, szSourceFile);
        sprintf(szSrc,  "%s\\symbols\\retail\\%s\\%s", gszSourceDir, szExt, szSourceFile);
        break;

    case GB_FILE_ITSELF:
        if ((_stricmp(szExt, "sys") == 0) && !bSkipDebugFiles) {
            // seems like it's a driver, but not win32k.sys
            sprintf(szDest, "%s\\%s", gszDriverDestDir, szSourceFile);
        } else {
            sprintf(szDest, "%s\\%s", gszDestDir, szSourceFile);
        }
        sprintf(szSrc,  "%s\\%s", gszSourceDir, szSourceFile);
        break;

    default:
        printf("Internal error in Getbin() - bad dwAssociatedFile %d\n",
               dwAssociatedFile);
        return FALSE;
    }


    /*
     * Source -> Dest
     */
    if (gbVerbose) {
        printf("%s -> %s", szSrc, szDest);
    } else {
        printf("%s", szSourceFile);
    }
    fflush(stdout);

    if ((bSkipDebugFiles) && (dwAssociatedFile != GB_FILE_ITSELF)) {
        if (gbVerbose) {
            VerbosePrintf("  not copying %s\n", szSourceFile);
            return TRUE;
        } else {
            printf(" Skipped\n");
            return TRUE;
        }
    }

    /*
     * Backup the original if requested
     */
    if (gbSavePrevious) {
        PCHAR pch;

        strcpy(szBackup, szDest);
        // find LAST dot
        pch = strrchr(szBackup, '.');
        pch++;

        strcpy(pch, gszSaveExtension);

        if (pch) {
            bRet = CopyFile(szDest, szBackup, FALSE);
            if (!bRet) {
                dwRet = GetLastError();
                if (dwRet == ERROR_FILE_NOT_FOUND) {
                    if (gbVerbose) {
                        printf("\n  No existing file to back up, continuing anyway\n");
                    } else {
                        printf(" [Can't backup]");
                    }
                } else {
                    printf("\n  Unable to make backup copy  %ld\n", dwRet);

                    // don't worry about failing to back up DBG/PDB files
                    if (dwAssociatedFile == GB_FILE_ITSELF) {
                        printf("\n");
                        return FALSE;
                    }
                }
            } else {
                if (gbVerbose) {
                    printf("\n  Backed up to: %s", szBackup);
                } else {
                    printf(" [Backed up]", szBackup);
                }
            }
        }
        fflush(stdout);
    }


    if (gbDelayCopy) {
        gbTryCopy = FALSE;
        gbTryRename = FALSE;
    }

    if (gbPoll) {
        PollForFile(szSrc, szDest, szSourceFile);
        gbPoll = FALSE;
    }

    /*
     * Try a regular copy
     */
    if (gbTryCopy) {
        VerbosePrintf("\n  Try Reg copy... ");
        fflush(stdout);
TryCopy:

        bRet = CopyFile(szSrc, szDest, FALSE);

        if (bRet) {
            if (gbVerbose) {
                PrintFileSize(szSrc);
                printf("\n  ==== Succeeded ====\n");
            } else {
                printf(" COPIED\n");
            }
            return TRUE;
        } else {
            dwRet = GetLastError();

            switch (dwRet) {
            case ERROR_FILE_NOT_FOUND:
                printf(" ERROR: File not found\n");
                return FALSE;

            case ERROR_ACCESS_DENIED:
            case ERROR_SHARING_VIOLATION:
                // Need to do delay copy
                break;

            default:
                printf("\n  ERROR: CopyFile(%s, %s, FALSE) Failed %ld\n",
                       szSrc, szDest, dwRet);
                return FALSE;
            }
        }
    }

    /*
     * Try a rename copy
     */
    if (gbTryRename) {
        VerbosePrintf("  Try Rename");
        bRet = MoveFileEx(szDest, szJUNKEXT, MOVEFILE_REPLACE_EXISTING);
        if (bRet) {
            if (!gbVerbose) {
                printf("[Renamed]");
            }
            fflush(stdout);
            gbTryRename = FALSE;
            goto TryCopy;
        } else {
            VerbosePrintf("\n");
            dwRet = GetLastError();

            switch (dwRet) {
            case ERROR_FILE_NOT_FOUND:
                printf(" ERROR: File not found\n");
                return FALSE;

            case ERROR_ACCESS_DENIED:
            case ERROR_SHARING_VIOLATION:
                // Need to do delay copy
                break;

            default:
                printf("\n  ERROR: Rename: MoveFileEx(%s, %s, MOVEFILE_REPLACE_EXISTING) failed %d\n",
                       szDest, szJUNKEXT, dwRet);
                return FALSE;
            }
        }
    }

    VerbosePrintf("\n  Trying delayed copy... ");
    if (_strnicmp(szFileName, "ntoskrnl", 8) == 0) {
        printf("\n"
               "  ===================== WARNING =====================\n");
        printf("  !Delayed copy of ntoskrnl.exe requires TWO reboots!\n");
        printf("  ===================================================\n");
    }

    if (!gbForceTempCopy) {
        /*
         * Determine source drive type
         */
        if (szSrc[0] == '\\' && szSrc[0] == '\\') {
            bNetDrive = TRUE;
        } else if (szSrc[1] == ':') {
            CHAR szRoot[5];

            szRoot[0] = szSrc[0];
            szRoot[1] = ':';
            szRoot[1] = '\\';

            if (GetDriveType(szRoot) == DRIVE_REMOTE)
                bNetDrive = TRUE;
        }
    }

    /*
     * If the source is a network path then copy it locally to temp file
     */
    if (gbForceTempCopy || bNetDrive) {
//        if (!GetTempPath(sizeof(szTempPath)/sizeof(szTempPath[0]), szTempPath)) {
//            printf("ERROR; GetTempPath Failed %ld\n", GetLastError());
//            return FALSE;
//        }

        if (!GetTempFileName(gszDestDir, "upd", 0, szTempFile)) {
            printf("ERROR; GetTempFileName Failed %ld\n", GetLastError());
            return FALSE;
        }

        bRet = CopyFile(szSrc, szTempFile, FALSE);
        if (!bRet) {
            dwRet = GetLastError();

            switch (dwRet) {
            case ERROR_FILE_NOT_FOUND:
                printf(" ERROR: File not found\n");
                return FALSE;

            default:
                printf("\n  ERROR: CopyFile(%s, %s, FALSE) failed %ld\n",
                       szSrc, szTempFile, dwRet);
                return FALSE;
            }
        }
        pszSrc = szTempFile;
        VerbosePrintf("  (temp file: %s)\n", pszSrc);
    }

    bRet = MoveFileEx(pszSrc, szDest, MV_FLAGS);

    if (bRet) {
        if (gbVerbose) {
            printf("  ==== Succeeded ====  (file will be copied during reboot)\n");
        } else {
            printf(" COPIED\n");
        }
    } else {
        printf("\n  ERROR: MoveFileEx(%s, %s, 0x%x) failed %ld\n",
               pszSrc, szDest, MV_FLAGS, GetLastError());
        return FALSE;
    }

    /*
     * Create the Restore.Cmd file if requested.
     */
    if (gbRestoreCmd) {
        char szBuff[CCH_BUF * 2];
        DWORD nb, nbWritten;

        if (ghRestoreCmd == NULL) {
            sprintf(szBuff, "%s\\%s", gszWinDir, szRESTORECMD);
            ghRestoreCmd = CreateFile(szBuff, GENERIC_WRITE, 0,
                                      (LPSECURITY_ATTRIBUTES)NULL, CREATE_ALWAYS,
                                      FILE_ATTRIBUTE_NORMAL,
                                      (HANDLE)NULL);
            if (ghRestoreCmd == INVALID_HANDLE_VALUE) {
                printf("ERROR: Create file failed: %ld\n", GetLastError());
                return FALSE;
            }
        }
        nb = sprintf(szBuff, "del %s\nmv %s %s\n", szDest, szBackup, szDest);
        bRet = WriteFile(ghRestoreCmd, szBuff, nb, &nbWritten, NULL);
        if (!bRet) {
            printf("  ERROR: WriteFile failed %ld\n", GetLastError());
        }
    }

    return bRet;
}


INT_PTR CALLBACK OptionsDlgProc (HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
    CHAR szNew[CCH_BUF];
    BOOL fRet;

    switch (msg) {
    case WM_INITDIALOG:
        SendDlgItemMessage( hDlg, IDD_DEST, WM_SETTEXT, 0, (LPARAM)gszDestDir);
        SetDlgItemText( hDlg, IDD_SOURCE, gszSourceDir);
        SetDlgItemText( hDlg, IDD_SYMS, gszSymsDir);

        if (gbTryRename)
            CheckDlgButton( hDlg, IDD_RENAME, TRUE);
        if (gbTryCopy)
            CheckDlgButton( hDlg, IDD_REG_COPY, TRUE);
        if (gbPoll)
            CheckDlgButton( hDlg, IDD_POLL, TRUE);
        if (gbReboot)
            CheckDlgButton( hDlg, IDD_REBOOT, TRUE);

        CheckDlgButton( hDlg, giCopySourceType, TRUE);

        SetDlgItemText( hDlg, IDD_SAVEEXTENSION, gszSaveExtension);
        SetDlgItemText( hDlg, IDD_COPYEXTENSION, szDEFCOPYEXT);
        if (gbSavePrevious) {
            if (gbRestoreCmd) {
                CheckDlgButton( hDlg, IDD_RESTORECMD, TRUE);
            }
            CheckDlgButton( hDlg, IDD_SAVEPREVIOUS, TRUE);
        } else {
            EnableWindow( GetDlgItem( hDlg, IDD_SAVEEXTENSION), FALSE);
            CheckDlgButton( hDlg, IDD_RESTORECMD, FALSE);
            EnableWindow( GetDlgItem( hDlg, IDD_RESTORECMD), FALSE);
            gbRestoreCmd = FALSE;
        }
        if (gbCopyDbgToo) {
            CheckDlgButton( hDlg, IDD_DBGTOO, TRUE);
        }
        SendDlgItemMessage( hDlg, IDD_SAVEEXTENSION, EM_LIMITTEXT, sizeof(gszSaveExtension)-1, 0);
        SendDlgItemMessage( hDlg, IDD_COPYEXTENSION, EM_LIMITTEXT, sizeof(gszCopyExtension)-1, 0);

        break;

    case WM_COMMAND:

        switch (LOWORD(wParam)) {
        CHAR szString[8];

        case IDOK:

            // Write out the new defaults
            if (GetDlgItemText(hDlg, IDD_SOURCE, szNew, sizeof(szNew))) {
                _strupr(szNew);
                WriteProfileString(szGETBIN, szSOURCE, szNew);
            }

            if (GetDlgItemText(hDlg, IDD_DEST, szNew, sizeof(szNew))) {
                _strupr(szNew);
                WriteProfileString(szGETBIN, szDEST, szNew);
            }

            if (GetDlgItemText(hDlg, IDD_SYMS, szNew, sizeof(szNew))) {
                _strupr(szNew);
                WriteProfileString(szGETBIN, szSYMS, szNew);
            }

            fRet = IsDlgButtonChecked( hDlg, IDD_RENAME);
            WriteProfileString(szGETBIN, szTRYRENAME, fRet ? "1" : "0");

            fRet = IsDlgButtonChecked( hDlg, IDD_REG_COPY);
            WriteProfileString(szGETBIN, szTRYCOPY, fRet ? "1" : "0");

            fRet = IsDlgButtonChecked( hDlg, IDD_POLL);
            WriteProfileString(szGETBIN, szPOLL, fRet ? "1" : "0");

            fRet = IsDlgButtonChecked( hDlg, IDD_REBOOT);
            WriteProfileString(szGETBIN, szREBOOT, fRet ? "1" : "0");

            fRet = IsDlgButtonChecked( hDlg, IDD_SAVEPREVIOUS);
            WriteProfileString(szGETBIN, szSAVEPREVIOUS, fRet ? "1" : "0");
            if (fRet && GetDlgItemText(hDlg, IDD_SAVEEXTENSION, szNew, sizeof(szNew))) {
                _strupr(szNew);
                WriteProfileString(szGETBIN, szSAVEEXT, szNew);
            }

            fRet = IsDlgButtonChecked( hDlg, IDD_RESTORECMD);
            WriteProfileString(szGETBIN, szRESTORECMD, fRet ? "1" : "0");


            fRet = IsDlgButtonChecked( hDlg, IDD_DBGTOO);
            WriteProfileString(szGETBIN, szCOPYDBGTOO, fRet ? "1" : "0");


            if (IsDlgButtonChecked( hDlg, IDD_COPY_DATE)) {
                giCopySourceType = IDD_COPY_DATE;
            } else if (IsDlgButtonChecked( hDlg, IDD_COPY_LIST)) {
                giCopySourceType = IDD_COPY_LIST;
            } else {
                giCopySourceType = IDD_COPY_COMMAND;
            }

            _itoa(giCopySourceType, szString, 10);
            WriteProfileString(szGETBIN, szCOPYSOURCETYPE, szString);

            // FALL THROUGH!

        case IDCANCEL:
            EndDialog(hDlg, FALSE);
            break;

        case IDD_SAVEPREVIOUS:
            if (HIWORD(wParam) == BN_CLICKED) {
                fRet = IsDlgButtonChecked( hDlg, IDD_SAVEPREVIOUS);
                EnableWindow( GetDlgItem( hDlg, IDD_SAVEEXTENSION), fRet);

                if (!fRet) {
                    CheckDlgButton( hDlg, IDD_RESTORECMD, FALSE);
                }
                EnableWindow( GetDlgItem( hDlg, IDD_RESTORECMD), fRet);
            }
            break;

        default:
            return (FALSE);
        }
        break;
        break;

    }

    return FALSE;
}