windows-server-2003/base/ntsetup/win95upg/migisol/migisol.c

/*++

Copyright (c) 1997 Microsoft Corporation

Module Name:

    migisol.c

Abstract:

    Implements an EXE that is used to run migration DLLs in a
    separate address space (sandboxing).

Author:

    Jim Schmidt (jimschm)   04-Aug-1997

Revision History:

    jimschm     19-Mar-2001 Removed DVD check because it is now
                            in a migration dll
    jimschm     02-Jun-1999 Added DVD checking support to avoid
                            setup crash on a Win9x blue screen
    jimschm     18-Mar-1999 Added cleanup for cases where text mode
                            fails and the user returns to Win9x.

    jimschm     23-Sep-1998 Converted to new IPC mechanism

--*/

#include "pch.h"
#include "master.h"
#include "plugin.h"
#include "migui.h"
#include "ntui.h"
#include "unattend.h"

BOOL g_ReportPhase = FALSE;
BOOL g_MigrationPhase = FALSE;
TCHAR g_DllName[MAX_TCHAR_PATH] = "";

P_INITIALIZE_NT InitializeNT;
P_MIGRATE_USER_NT MigrateUserNT;
P_MIGRATE_SYSTEM_NT MigrateSystemNT;
P_QUERY_VERSION QueryVersion;
P_INITIALIZE_9X Initialize9x;
P_MIGRATE_USER_9X MigrateUser9x;
P_MIGRATE_SYSTEM_9X MigrateSystem9x;

BOOL
WriteDiskSectors(
    IN TCHAR  Drive,
    IN UINT   StartSector,
    IN UINT   SectorCount,
    IN UINT   SectorSize,
    IN LPBYTE Buffer
    );

BOOL
WINAPI
MigUtil_Entry (
    HINSTANCE hinstDLL,
    DWORD fdwReason,
    PVOID lpvReserved
    );

BOOL
IsNEC98(
    VOID
    );


#define NO_GUI_ERROR 0

//
// Local functions
//

BOOL
PackExeNames(
    PGROWBUFFER GrowBuf,
    PCSTR p
    );

BOOL
PackDword(
    PGROWBUFFER GrowBuf,
    DWORD dw
    );

BOOL
PackQuadWord(
    PGROWBUFFER GrowBuf,
    LONGLONG qw
    );

BOOL
PackIntArray(
    PGROWBUFFER GrowBuf,
    PINT Array
    );

BOOL
PackString (
    PGROWBUFFER GrowBuf,
    PCSTR String
    );

BOOL
PackBinary (
    PGROWBUFFER GrowBuf,
    PBYTE Data,
    DWORD DataSize
    );

HINF
pGetInfHandleFromFileNameW (
    PCWSTR UnattendFile
    );

VOID
ProcessCommands (
    VOID
    );

BOOL
pParseCommandLine (
    VOID
    );

VOID
DoInitializeNT (
    PCWSTR Args
    );

VOID
DoInitialize9x (
    PCSTR Args
    );

VOID
DoMigrateUserNT (
    PCWSTR Args
    );

VOID
DoQueryVersion (
    PCSTR Args
    );

VOID
DoMigrateUser9x (
    PCSTR Args
    );

VOID
DoMigrateSystemNT (
    PCWSTR Args
    );

VOID
DoMigrateSystem9x (
    PCSTR Args
    );

HWND
pFindParentWindow (
    IN      PCTSTR WindowTitle,
    IN      DWORD ProcessId
    );

static HINSTANCE g_hLibrary;
HANDLE g_hHeap;
HINSTANCE g_hInst;


#ifdef DEBUG
#define DBG_MIGISOL "MigIsol"
#endif


INT
WINAPI
WinMain (
    HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    PSTR AnsiCmdLine,
    INT CmdShow
    )

/*++

Routine Description:

  The entry point to migisol.exe.  The entire body of code is wrapped
  in a try/except block to catch all problems with any migration DLLs.

Arguments:

  hInstance     - The instance handle of this EXE
  hPrevInstance - The previous instance handle of this EXE if it is
                  running, or NULL if no other instances exist.
  AnsiCmdLine   - The command line (ANSI version)
  CmdShow       - The ShowWindow command passed by the shell

Return Value:

  Returns -1 if an error occurred, or 0 if the exe completed. The exe
  will automatically terminate with 0 if the migration DLL throws an
  exception.

--*/

{
    TCHAR OurDir[MAX_TCHAR_PATH];
    PTSTR p;

    __try {
        g_hInst = hInstance;
        g_hHeap = GetProcessHeap();

        *OurDir = 0;

        GetModuleFileName (NULL, OurDir, ARRAYSIZE(OurDir));

        p = _tcsrchr (OurDir, TEXT('\\'));
        if (p) {
            *p = 0;
            if (!_tcschr (OurDir, TEXT('\\'))) {
                p[0] = TEXT('\\');
                p[1] = 0;
            }

            SetCurrentDirectory (OurDir);

            //
            // Force a specific setupapi.dll to be loaded
            //

            StringCopy (AppendWack (OurDir), TEXT("setupapi.dll"));
            LoadLibraryEx (
                    OurDir,
                    NULL,
                    LOAD_WITH_ALTERED_SEARCH_PATH
                    );
        }

        // Initialize utility library
        if (!MigUtil_Entry (g_hInst, DLL_PROCESS_ATTACH, NULL)) {
            FreeLibrary (g_hLibrary);
            return -1;
        }

        DEBUGMSG ((DBG_MIGISOL, "migisol.exe started"));

        if (!pParseCommandLine()) {
            FreeLibrary (g_hLibrary);
            return -1;
        }

        DEBUGMSG ((DBG_MIGISOL, "CmdLine parsed"));

        if (!OpenIpc (FALSE, NULL, NULL, NULL)) {
            DEBUGMSG ((DBG_MIGISOL, "OpenIpc failed"));
            FreeLibrary (g_hLibrary);
            return -1;
        }

        __try {
            DEBUGMSG ((DBG_MIGISOL, "Processing commands"));
            ProcessCommands();
        }

        __except (TRUE) {
            LOG ((LOG_ERROR, "Upgrade Pack process is terminating because of an exception in WinMain"));
        }

        CloseIpc();
        FreeLibrary (g_hLibrary);

        DEBUGMSG ((DBG_MIGISOL, "migisol.exe terminating"));

        if (!MigUtil_Entry (g_hInst, DLL_PROCESS_DETACH, NULL)) {
            return -1;
        }
    }

    __except (TRUE) {
    }

    return 0;
}

#define WINNT32_SECTOR_SIZE             512
#define WINNT32_FAT_BOOT_SECTOR_COUNT   1
#define WINNT32_FAT_BOOT_SIZE           (WINNT32_SECTOR_SIZE * WINNT32_FAT_BOOT_SECTOR_COUNT)
#define FILE_ATTRIBUTE_RHS              (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM)


BOOL
pWriteFATBootSector (
    IN      PCTSTR BootDataFile,
    IN      TCHAR BootDriveLetter
    )
{
    HANDLE BootDataHandle;
    BYTE Data[WINNT32_FAT_BOOT_SIZE];
    DWORD BytesRead;
    BOOL Success = FALSE;

    if (GetFileAttributes (BootDataFile) == INVALID_ATTRIBUTES) {
        DEBUGMSG ((DBG_ERROR, "Can't find %s", BootDataFile));
        return FALSE;
    }

    BootDataHandle = CreateFile (
                        BootDataFile,
                        GENERIC_READ,
                        FILE_SHARE_READ,
                        NULL,
                        OPEN_EXISTING,
                        FILE_FLAG_SEQUENTIAL_SCAN,
                        NULL
                        );
    if (BootDataHandle == INVALID_HANDLE_VALUE) {
        DEBUGMSG ((DBG_ERROR, "Can't open %s", BootDataFile));
        return FALSE;
    }

    Success = ReadFile (BootDataHandle, Data, WINNT32_FAT_BOOT_SIZE, &BytesRead, NULL) &&
              (BytesRead == WINNT32_FAT_BOOT_SIZE);

    CloseHandle (BootDataHandle);

    if (Success) {
        //
        // write the boot sector with this data; don't save NT boot sector
        //
        Success = WriteDiskSectors (
                        BootDriveLetter,
                        0,
                        WINNT32_FAT_BOOT_SECTOR_COUNT,
                        WINNT32_SECTOR_SIZE,
                        Data
                        );
        DEBUGMSG_IF ((
            !Success,
            DBG_ERROR,
            "WriteDiskSectors failed for %c!",
            BootDriveLetter
            ));
    }
    ELSE_DEBUGMSG ((DBG_ERROR, "Unexpected boot sector size %u in %s", BytesRead, BootDataFile));

    return Success;
}

VOID
pCleanUpUndoDirectory (
    CHAR BootDrive
    )
/*++

Routine Description:

  This function delete recursively all files and directories
  include and in %windir%\undo directory.

Arguments:

  none

Return Value:

  none

--*/
{
    TCHAR PathBuffer[MAX_PATH];
    TCHAR Answer[MAX_PATH];
    TCHAR NullPath[] = {0};

    DEBUGMSG((DBG_MIGISOL, "Cleanup routine of undo directory"));

    if(!BootDrive){
        if (!GetWindowsDirectory (PathBuffer, ARRAYSIZE(PathBuffer))) {
            DEBUGMSG((DBG_MIGISOL, "GetWindowsDirectory failed"));
            return;
        }
        BootDrive = PathBuffer[0];
    }

    wsprintf(PathBuffer, TEXT("%c:\\$win_nt$.~bt\\winnt.sif"), BootDrive);

    GetPrivateProfileString(
        S_WIN9XUPGUSEROPTIONS,
        S_PATH_FOR_BACKUP,
        NullPath,
        Answer,
        ARRAYSIZE(Answer),
        PathBuffer);

    if(!Answer[0]) {
        DEBUGMSG ((DBG_MIGISOL, "Failed to retrieve directory path"));
        return;
    }

    wsprintf(PathBuffer, TEXT("%c:\\$win_nt$.~bt\\dataloss"), BootDrive);
    if (DoesFileExist (PathBuffer)) {
        LOG ((
            LOG_INFORMATION,
            "Data loss was detected because of a failure to restore one or more files. "
                "The data can be recovered from backup files in %s.",
            Answer
            ));
        return;
    }

    SetFileAttributes(Answer, FILE_ATTRIBUTE_NORMAL);
    RemoveCompleteDirectory (Answer);

    DEBUGMSG ((DBG_MIGISOL, "Cleaned %s directory", Answer));
}

VOID
pCleanUpAfterTextModeFailure (
    VOID
    )
{
    TCHAR squiggleBtDir[] = TEXT("?:\\$win_nt$.~bt");
    TCHAR squiggleLsDir[] = TEXT("?:\\$win_nt$.~ls");
    TCHAR squiggleBuDir[] = TEXT("?:\\$win_nt$.~bu"); // for NEC98
    TCHAR drvLtr[] = TEXT("?:\\$DRVLTR$.~_~");
    TCHAR setupLdr[] = TEXT("?:\\$LDR$");
    TCHAR txtSetupSif[] = TEXT("?:\\TXTSETUP.SIF");
    PCTSTR bootSectDat;
    TCHAR setupTempDir[MAX_PATH];
    TCHAR bootIni[] = TEXT("?:\\boot.ini");
    TCHAR ntLdr[] = TEXT("?:\\NTLDR");
    TCHAR ntDetectCom[] = TEXT("?:\\NTDETECT.COM");
    TCHAR bootFontBin[] = TEXT("?:\\BOOTFONT.BIN");
    TCHAR bootSectDos[] = TEXT("?:\\BootSect.dos");
    TCHAR renamedFile1[] = TEXT("?:\\boot~tmp.$$1");
    TCHAR renamedFile2[] = TEXT("?:\\boot~tmp.$$2");
    TCHAR renamedFile3[] = TEXT("?:\\boot~tmp.$$3");
    BOOL noLdr = FALSE;
    BOOL noNtDetect = FALSE;
    BOOL noBootFontBin = FALSE;
    DWORD Drives;
    TCHAR DriveLetter;
    DWORD Bit;
    TCHAR Root[] = TEXT("?:\\");
    TCHAR Scratch[MAX_PATH];
    PCTSTR bootSectBak;
    PCTSTR bootIniBak;
    PCTSTR ntldrBak;
    PCTSTR bootFontBak;
    PCTSTR ntdetectBak;
    TCHAR WinDir[MAX_PATH];
    DWORD Type;
    DWORD Attribs;
    FILE_ENUM e;
    HANDLE WinInit;
    CHAR AnsiBuffer[MAX_PATH + 10];
    DWORD Dummy;
    PTSTR Write;
    BOOL prepareBootIni = FALSE;
    CHAR SystemDirPath[MAX_PATH];
    TCHAR bootDriveLetter;
    PCTSTR bootSectorFile;
    BOOL bootLoaderWritten;
    HKEY key;
    BOOL dontTouchBootCode = FALSE;

    if (ISNT()) {
        return;
    }

    DEBUGMSG ((DBG_MIGISOL, "Entering cleanup routine"));

    SuppressAllLogPopups (TRUE);

    //
    // Reinitialize system restore
    //

    key = OpenRegKeyStr (TEXT("HKLM\\SYSTEM\\CurrentControlSet\\Services\\VxD\\VxDMon"));
    if (key) {
        RegSetValueEx (key, TEXT("FirstRun"), 0, REG_SZ, (PCBYTE) "Y", 2);
        CloseRegKey (key);
    }

    //
    // Prepare windir and temp dir paths, get the bitmask of drive letters
    //
    // We need to know the system drive to be repaired, since win98 on NEC98
    // can boot up from any partition that can be installed.
    //

    GetSystemDirectory (SystemDirPath, MAX_PATH);

    if (!GetWindowsDirectory (setupTempDir, sizeof (setupTempDir) / sizeof (setupTempDir[0]))) {
        DEBUGMSG ((DBG_ERROR, "Can't get Windows dir"));
        return;
    } else {
        StringCopy (WinDir, setupTempDir);
    }
    StringCopy (AppendWack (setupTempDir), TEXT("setup"));

    Drives = GetLogicalDrives();

    bootDriveLetter = IsNEC98() ? SystemDirPath[0] : TEXT('C');

    if (WinDir[0] != bootDriveLetter) {
        dontTouchBootCode = TRUE;
    }

    //
    // Create paths
    //

    bootIniBak = JoinPaths (setupTempDir, S_BOOTINI_BACKUP);
    ntldrBak = JoinPaths (setupTempDir, S_NTLDR_BACKUP);
    ntdetectBak = JoinPaths (setupTempDir, S_NTDETECT_BACKUP);
    bootSectBak = JoinPaths (setupTempDir, S_BOOTSECT_BACKUP);
    bootFontBak = JoinPaths (setupTempDir, S_BOOTFONT_BACKUP);

    //
    // Deltree $win_nt$.~bt and $win_nt$.~ls
    //

    for (Bit = 1, DriveLetter = TEXT('A') ; Bit ; Bit <<= 1, DriveLetter++) {

        if (!(Drives & Bit)) {
            continue;
        }

        Root[0] = DriveLetter;
        Type = GetDriveType (Root);

        if (Type == DRIVE_FIXED || Type == DRIVE_UNKNOWN) {
            //
            // Clean this drive
            //

            squiggleBtDir[0] = DriveLetter;
            squiggleLsDir[0] = DriveLetter;

            RemoveCompleteDirectory (squiggleBtDir);
            RemoveCompleteDirectory (squiggleLsDir);

            //
            // On NEC98, there may be another temp directry to be clean up.
            //
            if (IsNEC98()) {
                squiggleBuDir[0] = DriveLetter;
                RemoveCompleteDirectory (squiggleBuDir);
            }
        }
    }

    DEBUGMSG ((DBG_MIGISOL, "Cleaned squiggle dirs"));

    //
    // Repair boot.ini (do not necessarily restore it to its original form though)
    // and clean the root of the drive.
    //

    for (Bit = 1, DriveLetter = TEXT('A') ; Bit ; Bit <<= 1, DriveLetter++) {

        if (!(Drives & Bit)) {
            continue;
        }

        //
        // On NEC98, there may be multiple boot files in each partition.
        // So we will just take care the system that booted up.
        //
        if (IsNEC98() && (DriveLetter != SystemDirPath[0])) {
            continue;
        }

        Root[0] = DriveLetter;
        Type = GetDriveType (Root);

        if (Type == DRIVE_FIXED || Type == DRIVE_UNKNOWN) {
            //
            // Remove setup from boot.ini if it is on this drive,
            // and clean root of the drive.
            //

            squiggleBtDir[0] = DriveLetter;
            squiggleLsDir[0] = DriveLetter;
            bootIni[0] = DriveLetter;
            drvLtr[0] = DriveLetter;
            setupLdr[0] = DriveLetter;
            ntLdr[0] = DriveLetter;
            ntDetectCom[0] = DriveLetter;
            bootFontBin[0] = DriveLetter;
            txtSetupSif[0] = DriveLetter;
            bootSectDos[0] = DriveLetter;
            renamedFile1[0] = DriveLetter;
            renamedFile2[0] = DriveLetter;
            renamedFile3[0] = DriveLetter;

            SetFileAttributes (drvLtr, FILE_ATTRIBUTE_NORMAL);
            DeleteFile (drvLtr);

            SetFileAttributes (setupLdr, FILE_ATTRIBUTE_NORMAL);
            DeleteFile (setupLdr);

            SetFileAttributes (txtSetupSif, FILE_ATTRIBUTE_NORMAL);
            DeleteFile (txtSetupSif);

            //
            // If this is the boot drive, and if we have a bootsect.bak and
            // boot.bak in the setup temp directory, then that means Win9x had
            // an initial boot.ini, and we must restore it. Otherwise there
            // was no boot.ini.
            //

            if (!dontTouchBootCode && DriveLetter == bootDriveLetter) {
                DEBUGMSG ((DBG_MIGISOL, "Processing boot drive %c", bootDriveLetter));

                //
                // test for existence of bootini.bak/bootsect.bak (we don't
                // care about the attributes).
                //


                Attribs = GetFileAttributes (bootIniBak);
                DEBUGMSG ((DBG_MIGISOL, "Attributes of %s: 0x%08X", bootIniBak, Attribs));
                if (Attribs != INVALID_ATTRIBUTES) {
                    DEBUGMSG ((DBG_MIGISOL, "Attributes of %s: 0x%08X", bootSectBak, Attribs));
                    Attribs = GetFileAttributes (bootSectBak);
                }

                //
                // if pair exists, then get attributes of real boot.ini file
                //

                if (Attribs != INVALID_ATTRIBUTES) {
                    Attribs = GetFileAttributes (bootIni);
                    if (Attribs == INVALID_ATTRIBUTES) {
                        Attribs = FILE_ATTRIBUTE_RHS;
                    }

                    //
                    // Restore ntdetect.com, ntldr, boot sector, and original
                    // boot.ini.
                    //

                    DEBUGMSG ((DBG_MIGISOL, "Restoring dual-boot environment"));

                    if (pWriteFATBootSector (bootSectBak, bootDriveLetter)) {
                        SetFileAttributes (bootIni, FILE_ATTRIBUTE_NORMAL);
                        CopyFile (bootIniBak, bootIni, FALSE);  // ignore failure
                        SetFileAttributes (bootIni, Attribs);

                        //
                        // Restore ntldr and ntdetect.com [as a pair]
                        //

                        if (DoesFileExist (ntldrBak) && DoesFileExist (ntdetectBak)) {
                            //
                            // wipe away collisions with our temp file names,
                            // then move current working loader to temp files
                            //

                            if (DoesFileExist (ntLdr)) {
                                SetFileAttributes (renamedFile1, FILE_ATTRIBUTE_NORMAL);
                                DeleteFile (renamedFile1);
                                MoveFile (ntLdr, renamedFile1);
                                noLdr = FALSE;
                            } else {
                                noLdr = TRUE;
                            }

                            if (DoesFileExist (ntDetectCom)) {
                                SetFileAttributes (renamedFile2, FILE_ATTRIBUTE_NORMAL);
                                DeleteFile (renamedFile2);
                                MoveFile (ntDetectCom, renamedFile2);
                                noNtDetect = FALSE;
                            } else {
                                noNtDetect = TRUE;
                            }

                            if (DoesFileExist (bootFontBin)) {
                                SetFileAttributes (renamedFile3, FILE_ATTRIBUTE_NORMAL);
                                DeleteFile (renamedFile3);
                                MoveFile (bootFontBin, renamedFile3);
                                noBootFontBin = FALSE;
                            } else {
                                noBootFontBin = TRUE;
                            }

                            //
                            // now attempt to copy backup files to loader location
                            //

                            bootLoaderWritten = FALSE;

                            if (CopyFile (ntldrBak, ntLdr, FALSE)) {
                                bootLoaderWritten = CopyFile (ntdetectBak, ntDetectCom, FALSE);
                                DEBUGMSG_IF ((!bootLoaderWritten, DBG_ERROR, "Can't copy %s to %s", ntdetectBak, ntDetectCom));

                                if (bootLoaderWritten && DoesFileExist (bootFontBak)) {
                                    bootLoaderWritten = CopyFile (bootFontBak, bootFontBin, FALSE);
                                    DEBUGMSG_IF ((!bootLoaderWritten, DBG_ERROR, "Can't copy %s to %s", bootFontBak, bootFontBin));
                                }
                            }
                            ELSE_DEBUGMSG ((DBG_ERROR, "Can't copy %s to %s", ntldrBak, ntLdr));

                            if (bootLoaderWritten) {
                                //
                                // success -- remove temp files
                                //

                                SetFileAttributes (renamedFile1, FILE_ATTRIBUTE_NORMAL);
                                DeleteFile (renamedFile1);

                                SetFileAttributes (renamedFile2, FILE_ATTRIBUTE_NORMAL);
                                DeleteFile (renamedFile2);

                                SetFileAttributes (renamedFile3, FILE_ATTRIBUTE_NORMAL);
                                DeleteFile (renamedFile3);

                            } else {
                                //
                                // fail -- restore temp files. If restoration
                                // fails, then generate a working boot.ini.
                                //

                                SetFileAttributes (ntLdr, FILE_ATTRIBUTE_NORMAL);
                                DeleteFile (ntLdr);

                                SetFileAttributes (ntDetectCom, FILE_ATTRIBUTE_NORMAL);
                                DeleteFile (ntDetectCom);

                                SetFileAttributes (bootFontBin, FILE_ATTRIBUTE_NORMAL);
                                DeleteFile (bootFontBin);

                                if (!noLdr) {
                                    if (!MoveFile (renamedFile1, ntLdr)) {
                                        prepareBootIni = TRUE;
                                        DEBUGMSG ((DBG_ERROR, "Can't restore %s to %s", renamedFile1, ntLdr));
                                    }
                                }

                                if (!noNtDetect) {
                                    if (!MoveFile (renamedFile2, ntDetectCom)) {
                                        prepareBootIni = TRUE;
                                        DEBUGMSG ((DBG_ERROR, "Can't restore %s to %s", renamedFile2, ntDetectCom));
                                    }
                                }

                                if (!noBootFontBin) {
                                    if (!MoveFile (renamedFile3, bootFontBin)) {
                                        prepareBootIni = TRUE;
                                        DEBUGMSG ((DBG_ERROR, "Can't restore %s to %s", renamedFile3, bootFontBin));
                                    }
                                }
                            }
                        }
                    } else {
                        LOG ((LOG_WARNING, "Unable to restore dual-boot loader"));
                    }

                } else {
                    //
                    // Remove the NT boot code. Delete ntdetect.com,
                    // bootfont.bin and ntldr. If any part of this code fails,
                    // make a boot.ini that will work. (ntdetect.com won't
                    // be needed.)
                    //

                    SetFileAttributes (ntDetectCom, FILE_ATTRIBUTE_NORMAL);
                    DeleteFile (ntDetectCom);

                    Attribs = GetFileAttributes (bootIni);

                    if (Attribs != INVALID_ATTRIBUTES) {

                        SetFileAttributes (bootIni, FILE_ATTRIBUTE_NORMAL);
                        prepareBootIni = TRUE;

                        //
                        // SystemDrive is not only C: on NEC98. Also, boot.ini
                        // should be always sitting on system drive but boot
                        // drive during setup, if these are separated.
                        // So we must take care the boot files on system drive.
                        //

                        if (GetFileAttributes (bootSectBak) != INVALID_ATTRIBUTES) {
                            bootSectorFile = bootSectBak;
                        } else {
                            bootSectorFile = bootSectDos;
                        }

                        if (pWriteFATBootSector (bootSectorFile, bootDriveLetter)) {
                            DEBUGMSG ((DBG_MIGISOL, "Successfully restored FAT boot sector"));
                            //
                            // restored original boot sector, NT boot files not required any longer
                            //
                            DeleteFile (bootIni);

                            SetFileAttributes (ntLdr, FILE_ATTRIBUTE_NORMAL);
                            DeleteFile (ntLdr);

                            SetFileAttributes (bootSectDos, FILE_ATTRIBUTE_NORMAL);
                            DeleteFile (bootSectDos);

                            SetFileAttributes (ntDetectCom, FILE_ATTRIBUTE_NORMAL);
                            DeleteFile (ntDetectCom);

                            SetFileAttributes (bootFontBin, FILE_ATTRIBUTE_NORMAL);
                            DeleteFile (bootFontBin);

                            prepareBootIni = FALSE;
                        } else {
                            //
                            // make sure this boot file is not accidentally
                            // deleted by the end-user
                            //
                            SetFileAttributes (ntLdr, FILE_ATTRIBUTE_RHS);

                            DEBUGMSG ((DBG_ERROR, "Cannot restore FAT boot sector from %s", bootSectDos));
                        }
                    }
                    ELSE_DEBUGMSG ((DBG_MIGISOL, "Skipping removal of boot.ini because it is not present"));
                }

                //
                // If we have any failure, this code here will make a boot
                // sector & loader that at least boots Win9x.
                //

                if (prepareBootIni) {
                    bootSectDat = JoinPaths (squiggleBtDir, TEXT("BOOTSECT.DAT"));

                    WritePrivateProfileString (TEXT("Boot Loader"), TEXT("Default"), Root, bootIni);
                    WritePrivateProfileString (TEXT("Operating Systems"), bootSectDat, NULL, bootIni);

                    GetPrivateProfileString (TEXT("Operating Systems"), Root, TEXT(""), Scratch, MAX_PATH, bootIni);

                    if (!Scratch[0]) {
                        //
                        // This should never ever occur, but for unknown cases we have this
                        //

                        WritePrivateProfileString (TEXT("Operating Systems"), Root, TEXT("Microsoft Windows"), bootIni);
                    }

                    WritePrivateProfileString (NULL, NULL, NULL, bootIni);
                    SetFileAttributes (bootIni, Attribs);

                    prepareBootIni = FALSE;
                    FreePathString (bootSectDat);
                }
            }
        }
    }

    //
    // Remove setup's temp dir as best we can.  This leaves some junk around,
    // but we will fix that on the next reboot.
    //

    RemoveCompleteDirectory (setupTempDir);

    //
    // put all remaining files in wininit.ini\[rename] they will be
    // automatically removed at next reboot
    //

    StringCopy (Scratch, WinDir);
    StringCopy (AppendWack (Scratch), TEXT("wininit.ini"));

    //
    // append "manually" since using WritePrivateProfileString will just
    // overwrite previous setting
    //

    if (EnumFirstFile (&e, setupTempDir, NULL)) {
        WinInit = CreateFile (
                    Scratch,
                    GENERIC_WRITE,
                    0,
                    NULL,
                    OPEN_ALWAYS,
                    FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
                    NULL
                    );
        if (WinInit != INVALID_HANDLE_VALUE) {

            StringCopyA (AnsiBuffer, "\r\n[rename]");
            if (WriteFile (WinInit, AnsiBuffer, _mbslen (AnsiBuffer), &Dummy, NULL)) {

                StringCopyA (AnsiBuffer, "\r\nNUL=");
                Write = GetEndOfString (AnsiBuffer);

                do {
#ifdef UNICODE
                    KnownSizeUnicodeToDbcs (Write, e.FullPath);
#else
                    StringCopyA (Write, e.FullPath);
#endif
                    if (!WriteFile (WinInit, AnsiBuffer, _mbslen (AnsiBuffer), &Dummy, NULL)) {
                        break;
                    }
                } while (EnumNextFile (&e));
            }

            CloseHandle (WinInit);
        }
        ELSE_DEBUGMSG ((DBG_MIGISOL, "Cannot create wininit.ini"));
    }
    ELSE_DEBUGMSG ((DBG_MIGISOL, "No files found in temp dir"));

    FreePathString (bootIniBak);
    FreePathString (ntldrBak);
    FreePathString (ntdetectBak);
    FreePathString (bootSectBak);
    FreePathString (bootFontBak);

    DEBUGMSG ((DBG_MIGISOL, "Leaving cleanup routine"));
}


BOOL
pParseCommandLine (
    VOID
    )

/*++

Routine Description:

  Prepares the global variables g_hLibrary, g_ReportPhase, g_MigrationPhase,
  g_DllName and the migration DLL entry points (Initialize9x, etc.)

Arguments:

  none

Return Value:

  TRUE if the module was successfully loaded, or FALSE if a parsing
  error or load error occurred.

--*/

{
    PCTSTR CmdLine;
    PCTSTR *argv;
    INT argc;
    INT i;
    PCTSTR p;
    TCHAR drive;

    CmdLine = GetCommandLine();
    argv = CommandLineToArgv (CmdLine, &argc);
    if (!argv) {
        DEBUGMSG ((DBG_MIGISOL, "Parse error"));
        return FALSE;
    }

    //
    // Parse command line
    //

    for (i = 1 ; i < argc ; i++) {
        if (argv[i][0] == TEXT('-') || argv[i][0] == TEXT('/')) {
            p = _tcsinc (argv[i]);
            switch (_totlower (_tcsnextc (p))) {
            case 'r':
                // Report-phase
                g_ReportPhase = TRUE;
                break;

            case 'm':
                // Migration-phase
                g_MigrationPhase = TRUE;
                break;

            case 'b':
                drive = '\0';
                p = _tcsinc(p);
                if(p && ':' == _tcsnextc(p)){
                    p = _tcsinc(p);
                    if(p){
                        drive = (TCHAR)_tcsnextc(p);
                    }
                }
                pCleanUpUndoDirectory(drive);
            case 'c':
                // Restore Win9x
                pCleanUpAfterTextModeFailure();
                return FALSE;
            }
        }
        else if (!g_DllName[0]) {
            StringCopy (g_DllName, argv[i]);
        } else {
            DEBUGMSG ((DBG_MIGISOL, "Broken arg: %s", argv[i]));
            return FALSE;
        }
    }

    //
    // Verify expected options exist
    //

    // One must be FALSE while the other must be TRUE
    if (g_ReportPhase == g_MigrationPhase) {
        DEBUGMSG ((DBG_MIGISOL, "Too many args"));
        return FALSE;
    }

    if (!g_DllName[0]) {
        DEBUGMSG ((DBG_MIGISOL, "No operation"));
        return FALSE;
    }

    //
    // Load migration DLL
    //

    g_hLibrary = LoadLibraryEx (
                    g_DllName,
                    NULL,
                    LOAD_WITH_ALTERED_SEARCH_PATH
                    );

    // If it fails, assume the DLL does not want to be loaded
    if (!g_hLibrary) {
        LOG ((LOG_ERROR, "Cannot load %s, rc=%u", g_DllName, GetLastError()));
        return FALSE;
    }

    // Get proc addresses for NT-side functions
    InitializeNT    = (P_INITIALIZE_NT)     GetProcAddress (g_hLibrary, PLUGIN_INITIALIZE_NT);
    MigrateUserNT   = (P_MIGRATE_USER_NT)   GetProcAddress (g_hLibrary, PLUGIN_MIGRATE_USER_NT);
    MigrateSystemNT = (P_MIGRATE_SYSTEM_NT) GetProcAddress (g_hLibrary, PLUGIN_MIGRATE_SYSTEM_NT);

    // Get proc addresses for 9x-side functions
    QueryVersion    = (P_QUERY_VERSION)     GetProcAddress (g_hLibrary, PLUGIN_QUERY_VERSION);
    Initialize9x    = (P_INITIALIZE_9X)     GetProcAddress (g_hLibrary, PLUGIN_INITIALIZE_9X);
    MigrateUser9x   = (P_MIGRATE_USER_9X)   GetProcAddress (g_hLibrary, PLUGIN_MIGRATE_USER_9X);
    MigrateSystem9x = (P_MIGRATE_SYSTEM_9X) GetProcAddress (g_hLibrary, PLUGIN_MIGRATE_SYSTEM_9X);

    // If any function does not exist, ignore the out-of-spec DLL
    if (!QueryVersion || !Initialize9x || !MigrateUser9x || !MigrateSystem9x ||
        !InitializeNT || !MigrateUserNT || !MigrateSystemNT
        ) {

        LOG ((LOG_ERROR, "Cannot load %s, one or more functions missing", g_DllName));
        return FALSE;
    }

    return TRUE;
}


VOID
ProcessCommands (
    VOID
    )

/*++

Routine Description:

  ProcessCommands waits on the IPC pipe for a command message.  When
  a command message is received, it is dispatched to the processing
  function.  If a terminate command is received, the EXE terminates.

  If no command is received in one second, the EXE terminates.  Therefore,
  Setup must always be ready to feed the EXE commands.

Arguments:

  none

Return Value:

  none

--*/

{
    DWORD Command;
    PBYTE Data;
    DWORD DataSize;

    DEBUGMSG ((DBG_MIGISOL, "Starting to process %s", g_DllName));

    do {

        // We wait for an interval: w95upgnt.dll or w95upg.dll should be ready
        // to feed us continuously.


        //
        // Receive command, don't care about size, OK to fail.
        //

        if (!GetIpcCommand (
                IPC_GET_COMMAND_WIN9X,
                &Command,
                &Data,
                &DataSize
                )) {
            DEBUGMSG ((DBG_WARNING, "MIGISOL: No command recieved"));
            break;
        }

        DEBUGMSG ((DBG_NAUSEA, "MigIsol - Command recieved: %u", Command));

        switch (Command) {

        case IPC_QUERY:
            if (g_MigrationPhase) {
            } else {
                DoQueryVersion ((PCSTR) Data);
            }
            break;

        case IPC_INITIALIZE:
            if (g_MigrationPhase) {
                DoInitializeNT ((PCWSTR) Data);
            } else {
                DoInitialize9x ((PCSTR) Data);
            }
            break;

        case IPC_MIGRATEUSER:
            if (g_MigrationPhase) {
                DoMigrateUserNT ((PCWSTR) Data);
            } else {
                DoMigrateUser9x ((PCSTR) Data);
            }
            break;

        case IPC_MIGRATESYSTEM:
            if (g_MigrationPhase) {
                DoMigrateSystemNT ((PCWSTR) Data);
            } else {
                DoMigrateSystem9x ((PCSTR) Data);
            }
            break;

        case IPC_TERMINATE:
            DEBUGMSG ((DBG_MIGISOL, "Processing of %s is complete", g_DllName));
            return;

        default:
            DEBUGMSG ((DBG_MIGISOL, "ProcessCommands: Unrecognized command -- terminating"));
            return;
        }

        if (Data) {
            MemFree (g_hHeap, 0, Data);
            Data = NULL;
        }

    } while (Command != IPC_TERMINATE);
}


VOID
DoInitializeNT (
    PCWSTR Args
    )

/*++

Routine Description:

  Calls migration DLL's InitializeNT function.  This function unpacks
  the arguments passed by Setup, calls the migration DLL and returns
  the status code back to Setup.

Arguments:

  Args  - A pointer to the argument buffer sent by Setup.  This buffer
          is received with the initialize command.

Return Value:

  none

--*/

{
    PCWSTR WorkingDir = NULL;
    PCWSTR SourceDirs = NULL;
    PCWSTR EndOfSourceDirs;
    PDWORD ReservedSize;
    PVOID Reserved;
    DWORD rc = RPC_S_CALL_FAILED;
    DWORD TechnicalLogId = 0;
    DWORD GuiLogId = 0;

    //
    // Set pointers of IN parameters
    //

    WorkingDir = Args;
    SourceDirs = wcschr (Args, 0) + 1;
    EndOfSourceDirs = SourceDirs;
    while (*EndOfSourceDirs) {
        EndOfSourceDirs = wcschr (EndOfSourceDirs, 0);
        EndOfSourceDirs++;
    }
    ReservedSize = (PDWORD) (EndOfSourceDirs + 1);
    if (*ReservedSize) {
        Reserved = (PVOID) (ReservedSize + 1);
    } else {
        Reserved = NULL;
    }

    //
    // Set CWD
    //
    SetCurrentDirectoryW(WorkingDir);

    //
    // Call migration DLL function
    //

    __try {
        rc = InitializeNT (WorkingDir, SourceDirs, Reserved);
    }
    __except (TRUE) {
        // Send log message
        DEBUGMSG ((DBG_MIGISOL, "%s threw an exception in InitializeNT", g_DllName));
        rc = ERROR_NOACCESS;
        TechnicalLogId = MSG_EXCEPTION_MIGRATE_INIT_NT;
    }

    //
    // No OUT parameters to send
    //

    SendIpcCommandResults (rc, TechnicalLogId, GuiLogId, NULL, 0);
}


HINF
pGetInfHandleFromFileNameW (
    PCWSTR UnattendFile
    )

/*++

Routine Description:

  pGetInfHandleFromFileName uses the Setup APIs to open the specified
  UnattendFile.

Arguments:

  UnattendFile  - A pointer to the UNICODE file name specifying the unattend
                  file.  This string is converted to ANSI and the ANSI version
                  of SetupOpenInfFile is called.

Return Value:

  The INF handle, or NULL (*not* INVALID_HANDLE_VALUE) if the file could not
  be opened.

--*/

{
    CHAR AnsiUnattendFile[MAX_MBCHAR_PATH];
    HINF UnattendHandle;

    KnownSizeWtoA (AnsiUnattendFile, UnattendFile);
    UnattendHandle = SetupOpenInfFileA (AnsiUnattendFile, NULL, INF_STYLE_OLDNT|INF_STYLE_WIN4, NULL);

    if (UnattendHandle == INVALID_HANDLE_VALUE) {
        DEBUGMSG ((DBG_ERROR, "pGetInfHandleFromFileNameW: Could not open %s", UnattendFile));
        UnattendHandle = NULL;
    }

    return UnattendHandle;
}

VOID
DoMigrateUserNT (
    PCWSTR Args
    )

/*++

Routine Description:

  Calls migration DLL's MigrateUserNT function.  This function unpacks
  the arguments passed by Setup, calls the migration DLL and returns
  the status code back to Setup.

Arguments:

  Args  - A pointer to the argument buffer sent by Setup.  This buffer
          is received with the IPC_MIGRATEUSER command.

Return Value:

  none

--*/

{
    PCWSTR UnattendFile;
    PCWSTR UserRegKey;
    PCWSTR UserName;
    PCWSTR UserDomain;
    PCWSTR FixedUserName;
    PCWSTR UserProfileDir;
    WCHAR OrgProfileDir[MAX_WCHAR_PATH];
    HINF UnattendHandle = NULL;
    HKEY UserRegHandle = NULL;
    DWORD rc;
    PVOID Reserved;
    PDWORD ReservedBytesPtr;
    DWORD TechnicalLogId = 0;
    DWORD GuiLogId = 0;

    __try {
        //
        // Preserve USERPROFILE environment variable
        //

        GetEnvironmentVariableW (S_USERPROFILEW, OrgProfileDir, MAX_WCHAR_PATH);

        //
        // Set pointers of IN parameters
        //

        UnattendFile     = Args;
        UserRegKey       = wcschr (UnattendFile, 0) + 1;
        UserName         = wcschr (UserRegKey, 0) + 1;
        UserDomain       = wcschr (UserName, 0) + 1;
        FixedUserName    = wcschr (UserDomain, 0) + 1;
        UserProfileDir   = wcschr (FixedUserName, 0) + 1;
        ReservedBytesPtr = (PDWORD) (wcschr (UserProfileDir, 0) + 1);

        if (*ReservedBytesPtr) {
            Reserved = (PVOID) (ReservedBytesPtr + 1);
        } else {
            Reserved = NULL;
        }

        //
        // Set USERPROFILE
        //

        if (UserProfileDir[0]) {
            WCHAR DebugDir[MAX_WCHAR_PATH];

            SetEnvironmentVariableW (S_USERPROFILEW, UserProfileDir);
            DEBUGMSG ((DBG_MIGISOL, "USERPROFILE set to %ls", UserProfileDir));

            GetEnvironmentVariableW (S_USERPROFILEW, DebugDir, MAX_WCHAR_PATH);
            DEBUGMSG ((DBG_MIGISOL, "USERPROFILE set to %ls", DebugDir));
        }

        //
        // Get UnattendHandle and UserRegHandle
        //

        UnattendHandle = pGetInfHandleFromFileNameW (UnattendFile);
        UserRegHandle = OpenRegKeyStrW (UserRegKey);

        if (!UnattendHandle || !UserRegHandle) {
            // Send log message and failure code
            rc = ERROR_OPEN_FAILED;

        } else {

            //
            // Call migration DLL function
            //

            __try {
                rc = MigrateUserNT (
                        UnattendHandle,
                        UserRegHandle,
                        UserName[0] ? UserName : NULL,
                        Reserved
                        );
            }
            __except (TRUE) {
                // Send log message and failure code
                DEBUGMSG ((DBG_MIGISOL, "%s threw an exception in MigrateUserNT", g_DllName));
                rc = ERROR_NOACCESS;
                TechnicalLogId = MSG_EXCEPTION_MIGRATE_USER_NT;
            }
        }

        //
        // No OUT parameters to send
        //

        if (UserRegHandle) {
            CloseRegKey (UserRegHandle);
            UserRegHandle = NULL;
        }

        SendIpcCommandResults (rc, TechnicalLogId, GuiLogId, NULL, 0);

    }

    __finally {
        //
        // Clean up
        //

        SetEnvironmentVariableW (S_USERPROFILEW, OrgProfileDir);

        if (UserRegHandle) {
            CloseRegKey (UserRegHandle);
        }

        if (UnattendHandle != INVALID_HANDLE_VALUE) {
            SetupCloseInfFile (UnattendHandle);
        }
    }
}


VOID
DoMigrateSystemNT (
    PCWSTR Args
    )

/*++

Routine Description:

  Calls migration DLL's MigrateSystemNT function.  This function unpacks
  the arguments passed by Setup, calls the migration DLL and returns
  the status code back to Setup.

Arguments:

  Args  - A pointer to the argument buffer sent by Setup.  This buffer
          is received with the IPC_MIGRATESYSTEM command.

Return Value:

  none

--*/

{
    PCWSTR UnattendFile;
    HINF UnattendHandle = NULL;
    DWORD rc;
    PVOID Reserved;
    PDWORD ReservedBytesPtr;
    DWORD TechnicalLogId = 0;
    DWORD GuiLogId = 0;

    __try {
        //
        // Set pointers of IN parameters
        //

        UnattendFile    = Args;
        ReservedBytesPtr = (PDWORD) (wcschr (UnattendFile, 0) + 1);

        if (*ReservedBytesPtr) {
            Reserved = (PVOID) (ReservedBytesPtr + 1);
        } else {
            Reserved = NULL;
        }

        //
        // Get UnattendHandle and UserRegHandle
        //

        UnattendHandle = pGetInfHandleFromFileNameW (UnattendFile);

        if (!UnattendHandle) {
            rc = ERROR_OPEN_FAILED;
        } else {

            //
            // Call migration DLL function
            //

            __try {
                rc = MigrateSystemNT (UnattendHandle, Reserved);
            }
            __except (TRUE) {
                DEBUGMSG ((DBG_MIGISOL, "%s threw an exception in MigrateSystemNT", g_DllName));
                rc = ERROR_NOACCESS;
                TechnicalLogId = MSG_EXCEPTION_MIGRATE_SYSTEM_NT;
            }
        }

        //
        // No OUT parameters to send
        //

        SendIpcCommandResults (rc, TechnicalLogId, GuiLogId, NULL, 0);

    }

    __finally {
        if (UnattendHandle != INVALID_HANDLE_VALUE) {
            SetupCloseInfFile (UnattendHandle);
        }
    }
}



VOID
DoQueryVersion (
    PCSTR Args
    )

/*++

Routine Description:

  Calls migration DLL's QueryVersion function.  This function unpacks
  the arguments passed by Setup, calls the migration DLL and returns
  the status code back to Setup.

Arguments:

  Args  - A pointer to the argument buffer sent by Setup.  This buffer
          is received with the IPC_QUERY command.

Return Value:

  none

--*/

{
    DWORD rc = RPC_S_CALL_FAILED;
    GROWBUFFER GrowBuf = GROWBUF_INIT;
    PSTR ProductId = NULL;
    UINT DllVersion = 0;
    PDWORD CodePageArray = NULL;
    PCSTR ExeNames = NULL;
    PCSTR WorkingDir;
    PVENDORINFO VendorInfo = NULL;
    DWORD TechnicalLogId = 0;
    DWORD GuiLogId = 0;

    DEBUGMSG ((DBG_MIGISOL, "Entering DoQueryVersion"));

    __try {
        //
        // Set pointers of IN parameters
        //
        WorkingDir = (PSTR)Args;                  // CWD for this process

        //
        // Change CWD
        //
        SetCurrentDirectory(WorkingDir);

        //
        // Call migration DLL function
        //
        __try {
            DEBUGMSG ((DBG_MIGISOL, "QueryVersion: WorkingDir=%s", WorkingDir));

            rc = QueryVersion (
                    &ProductId,
                    &DllVersion,
                    &CodePageArray,
                    &ExeNames,
                    &VendorInfo
                    );

            DEBUGMSG ((DBG_MIGISOL, "QueryVersion rc=%u", rc));
            DEBUGMSG ((DBG_MIGISOL, "VendorInfo=0x%X", VendorInfo));
        }
        __except (TRUE) {
            DEBUGMSG ((
                DBG_MIGISOL,
                "%s threw an exception in QueryVersion",
                g_DllName
                ));

            TechnicalLogId = MSG_MIGDLL_QUERYVERSION_EXCEPTION_LOG;
            rc = ERROR_NOACCESS;
        }

        //
        // Unless we know failure occurred, return out parameters
        //
        if (rc == ERROR_SUCCESS) {
            //
            // Pack product id string
            //
            if (!PackString (&GrowBuf, ProductId)) {
                DEBUGMSG ((DBG_MIGISOL, "QueryVersion PackProductId failed"));
                rc = GetLastError();
                __leave;
            }

            //
            // Pack DLL version
            //
            if (!PackDword(&GrowBuf, DllVersion)) {
                rc = GetLastError();
                DEBUGMSG ((DBG_MIGISOL, "QueryVersion DllVersion failed"));
                __leave;
            }

            //
            // Pack CP array
            //
            if (!PackIntArray(&GrowBuf, CodePageArray)) {
                rc = GetLastError();
                DEBUGMSG ((DBG_MIGISOL, "QueryVersion PackIntArray failed"));
                __leave;
            }

            //
            // Pack Exe Names
            //
            if (!PackExeNames(&GrowBuf, ExeNames)) {
                rc = GetLastError();
                DEBUGMSG ((DBG_MIGISOL, "QueryVersion PackExeNames failed"));
                __leave;
            }


            //
            // Pack PVENDORINFO
            //
            if (!PackDword(&GrowBuf, (DWORD) VendorInfo)) {
                rc = GetLastError();
                DEBUGMSG ((DBG_MIGISOL, "QueryVersion VendorInfo failed"));
                __leave;
            }

            if (VendorInfo) {
                if (!PackBinary (&GrowBuf, (PBYTE) VendorInfo, sizeof (VENDORINFO))) {
                    rc = GetLastError();
                    DEBUGMSG ((DBG_MIGISOL, "QueryVersion VendorInfo failed"));
                    __leave;
                }
            }
        }

        //
        // Send the packed parameters
        //
        if (!SendIpcCommandResults (
                rc,
                TechnicalLogId,
                GuiLogId,
                GrowBuf.End ? GrowBuf.Buf : NULL,
                GrowBuf.End
                )) {

            DEBUGMSG ((
                DBG_ERROR,
                "DoQueryVersion failed to send command response"
                ));

            LOG ((LOG_ERROR, "Upgrade Pack process could not send reply data"));
        }
    }
    __finally {
        FreeGrowBuffer(&GrowBuf);
    }

    DEBUGMSG ((DBG_MIGISOL, "Leaving DoQueryVersion, rc=%u", rc));
}


VOID
DoInitialize9x (
    PCSTR Args
    )

/*++

Routine Description:

  Calls migration DLL's Initialize9x function.  This function unpacks
  the arguments passed by Setup, calls the migration DLL and returns
  the status code back to Setup.

Arguments:

  Args  - A pointer to the argument buffer sent by Setup.  This buffer
          is received with the IPC_INITIALIZE command.

Return Value:

  none

--*/

{
    DWORD rc = RPC_S_CALL_FAILED;
    PSTR WorkingDir = NULL;
    PSTR SourceDirs = NULL;
    PVOID Reserved;
    DWORD ReservedSize;
    PCSTR p;
    DWORD TechnicalLogId = 0;
    DWORD GuiLogId = 0;
    GROWBUFFER GrowBuf = GROWBUF_INIT;

    DEBUGMSG ((DBG_MIGISOL, "Entering DoInitialize9x"));

    __try {
        //
        // Set pointers of IN parameters
        //
        WorkingDir = (PSTR)Args;               // CWD for this process
        SourceDirs = GetEndOfStringA (WorkingDir) + 1; // arg for Initialize9x

        p = SourceDirs;
        while (*p) {
            p = GetEndOfStringA (p);
            p++;
        }

        p++;

        ReservedSize = *((PDWORD) p);
        p = (PCSTR) ((PBYTE) p + sizeof (DWORD));

        if (ReservedSize) {
            Reserved = (PVOID) p;
            p = (PCSTR) ((PBYTE) p + ReservedSize);
        } else {
            Reserved = NULL;
        }

        //
        // Change CWD
        //
        SetCurrentDirectory(WorkingDir);

        //
        // Call migration DLL function
        //
        __try {
            rc = Initialize9x (
                    WorkingDir,
                    SourceDirs,
                    Reserved
                    );
        }
        __except (TRUE) {
            //
            // Send log message
            //
            DEBUGMSG ((DBG_MIGISOL,
                "%s threw an exception in Initialize9x",
                g_DllName));

            TechnicalLogId = MSG_MIGDLL_INITIALIZE9X_EXCEPTION_LOG;
            rc = ERROR_NOACCESS;
        }

        //
        // Send reserved
        //

        if (rc == ERROR_SUCCESS) {

            //
            // Pack reserved parameter
            //

            // Set ReservedSize to zero for now because the Reserved arg is an IN only
            ReservedSize = 0;

            if (!PackBinary (&GrowBuf, (PBYTE) Reserved, ReservedSize)) {
                rc = GetLastError();
                DEBUGMSG ((DBG_MIGISOL, "Initialize9x reserved failed"));
                __leave;
            }
        }

        //
        // Send the packed parameters
        //
        if (!SendIpcCommandResults (
                rc,
                TechnicalLogId,
                GuiLogId,
                GrowBuf.End ? GrowBuf.Buf : NULL,
                GrowBuf.End
                )) {

            DEBUGMSG ((
                DBG_ERROR,
                "DoInitializeNT failed to send command response"
                ));

            LOG ((LOG_ERROR, "Upgrade Pack process could not send reply data"));
        }
    }
    __finally {
        FreeGrowBuffer (&GrowBuf);
    }

    DEBUGMSG ((DBG_MIGISOL, "Leaving DoInitialize9x, rc=%u", rc));
}


VOID
DoMigrateUser9x (
    IN      PCSTR Args
    )

/*++

Routine Description:

  Calls migration DLL's MigrateUser9x function.  This function unpacks
  the arguments passed by Setup, calls the migration DLL and returns
  the status code back to Setup.

Arguments:

  Args  - A pointer to the argument buffer sent by Setup.  This buffer
          is received with the IPC_MIGRATEUSER command.

Return Value:

  none

--*/

{
    PCSTR ParentWndTitle = NULL;
    HWND ParentWnd;
    PCSTR UnattendFile = NULL;
    PCSTR UserRegKey = NULL;
    PCSTR UserName = NULL;
    HKEY UserRegHandle = NULL;
    DWORD rc = RPC_S_CALL_FAILED;
    DWORD ProcessId;
    DWORD GuiLogId = 0;
    DWORD TechnicalLogId = 0;

    DEBUGMSG ((DBG_MIGISOL, "Entering DoMigrateUser9x"));

    __try {
        //
        // Set pointers of IN parameters
        //
        ParentWndTitle  = Args;
        UnattendFile    = GetEndOfStringA (ParentWndTitle) + 1;
        ProcessId       = *((PDWORD) UnattendFile);
        UnattendFile    = (PCSTR) ((PBYTE) UnattendFile + sizeof (DWORD));
        UserRegKey      = GetEndOfStringA (UnattendFile) + 1;
        UserName        = GetEndOfStringA (UserRegKey) + 1;

        //
        // Get UserRegHandle
        //

        UserRegHandle = OpenRegKeyStr(UserRegKey);

        if (!UserRegHandle) {
            rc = ERROR_OPEN_FAILED;
        } else {

            ParentWnd = pFindParentWindow (ParentWndTitle, ProcessId);

            //
            // Call migration DLL function
            //

            __try {
                rc = MigrateUser9x(
                        ParentWnd,
                        UnattendFile,
                        UserRegHandle,
                        *UserName ? UserName : NULL,
                        NULL
                        );
            }
            __except (TRUE) {
                //
                // Send log message
                //
                DEBUGMSG ((
                    DBG_MIGISOL,
                    "%s threw an exception in MigrateUser9x",
                    g_DllName
                    ));

                TechnicalLogId = MSG_MIGDLL_MIGRATEUSER9X_EXCEPTION_LOG;
                rc = ERROR_NOACCESS;
            }
        }

        //
        // No need to return out parameters
        //

        if (UserRegHandle) {
            CloseRegKey (UserRegHandle);
            UserRegHandle = NULL;
        }

        SendIpcCommandResults (rc, TechnicalLogId, GuiLogId, NULL, 0);
    }
    __finally {
        //
        // Free resources
        //
        if (UserRegHandle) {
            CloseRegKey (UserRegHandle);
        }
    }

    DEBUGMSG ((DBG_MIGISOL, "Leaving MigrateUser9x , rc=%u", rc));
}


VOID
DoMigrateSystem9x(
    IN      PCSTR Args
    )

/*++

Routine Description:

  Calls migration DLL's MigrateSystem9x function.  This function unpacks
  the arguments passed by Setup, calls the migration DLL and returns
  the status code back to Setup.

Arguments:

  Args  - A pointer to the argument buffer sent by Setup.  This buffer
          is received with the IPC_MIGRATESYSTEM command.

Return Value:

  none

--*/

{
    PCSTR ParentWndTitle = NULL;
    DWORD ProcessId;
    PCSTR UnattendFile = NULL;
    HWND ParentWnd = NULL;
    DWORD rc = RPC_S_CALL_FAILED;
    DWORD TechnicalLogId = 0;
    DWORD GuiLogId = 0;

    DEBUGMSG ((DBG_MIGISOL, "Entering DoMigrateSystem9x"));

    //
    // Set pointers of IN parameters
    //

    ParentWndTitle    = Args;
    UnattendFile      = GetEndOfStringA (ParentWndTitle) + 1;
    ProcessId         = *((PDWORD) UnattendFile);
    UnattendFile      = (PCSTR) ((PBYTE) UnattendFile + sizeof (DWORD));

    //
    // Get ParentWnd
    //
    ParentWnd = pFindParentWindow (ParentWndTitle, ProcessId);

    //
    // Call migration DLL function
    //
    __try {
        rc = MigrateSystem9x(
                ParentWnd,
                UnattendFile,
                NULL
                );
    }
    __except (TRUE) {
        //
        // Send log message
        //
        DEBUGMSG ((
            DBG_MIGISOL,
            "%s threw an exception in MigrateSystem9x",
            g_DllName
            ));

        TechnicalLogId = MSG_MIGDLL_MIGRATESYSTEM9X_EXCEPTION_LOG;
        rc = ERROR_NOACCESS;
    }

    //
    // No need to return out parameters
    //

    SendIpcCommandResults (rc, TechnicalLogId, GuiLogId, NULL, 0);

    DEBUGMSG ((DBG_MIGISOL, "Leaving DoMigrateSystem9x, rc=%u", rc));
}



//
// Function packs a DWORD into a GrowBuffer.

BOOL
PackDword(
    PGROWBUFFER GrowBuf,
    DWORD dw
    )
{
    PVOID p;
    p = GrowBuffer (GrowBuf, sizeof(DWORD));
    if (!p) {
        return FALSE;
    }
    CopyMemory (p, (PVOID)(&dw), sizeof(dw));
    return TRUE;
}



//
// Function packs a LONGLONG into a GrowBuffer
BOOL
PackQuadWord(
        PGROWBUFFER GrowBuf,
        LONGLONG qw)
{
    return (
        PackDword(GrowBuf, (DWORD)qw) &&
        PackDword(GrowBuf, (DWORD)(qw >> 32)));
}


//
// Function packs 1) a NULL ptr, or 2) array of int terminated by -1, into a
// GrowBuffer.
//
BOOL
PackIntArray(
    PGROWBUFFER GrowBuf,
    PINT Array
    )
{
    DWORD Count;
    PDWORD ArrayPos;

    if (!Array) {
        if (!GrowBufAppendDword (GrowBuf, 0)) {
            return FALSE;
        }
    } else {
        __try {
            Count = 1;
            for (ArrayPos = Array ; (*ArrayPos) != -1 ; ArrayPos++) {
                Count++;
            }
        }
        __except (TRUE) {
            LOG ((LOG_ERROR, "Upgrade Pack %s provided an invalid code page array", g_DllName));
            SetLastError (ERROR_NOACCESS);
            return FALSE;
        }

        if (!GrowBufAppendDword (GrowBuf, Count)) {
            return FALSE;
        }

        for (ArrayPos = Array ; Count ; ArrayPos++, Count--) {
            if (!GrowBufAppendDword (GrowBuf, (DWORD) (UINT) (*ArrayPos))) {
                return FALSE;
            }
        }
    }

    return TRUE;
}


//
// Function packs 1) a NULL pointer, or 2) a multi-sz, into a GrowBuffer.
//
BOOL
PackExeNames(
    PGROWBUFFER GrowBuf,
    PCSTR ExeNames
    )
{
    PCSTR p;

    if (ExeNames) {
        __try {
            for (p = ExeNames ; *p ; p = GetEndOfStringA (p) + 1) {
            }
        }
        __except (TRUE) {
            LOG ((LOG_ERROR, "Upgrade Pack %s provided an invalid file list", g_DllName));
            SetLastError (ERROR_NOACCESS);
            return FALSE;
        }

        // Append non-empty strings
        for (p = ExeNames ; *p ; p = GetEndOfStringA (p) + 1) {
            if (!MultiSzAppendA (GrowBuf, p)) {
                return FALSE;
            }
        }
    }

    // Append a final empty string
    if (!MultiSzAppendA(GrowBuf, "")) {
        return FALSE;
    }

    return TRUE;
}

BOOL
PackString (
    PGROWBUFFER GrowBuf,
    PCSTR String
    )
{
    __try {
        if (!MultiSzAppendA (GrowBuf, String)) {
            return FALSE;
        }
    }
    __except (TRUE) {
        DEBUGMSG ((
            DBG_ERROR,
            "%s provided an invalid ProductID string (%xh)",
            g_DllName,
            String
            ));

        LOG ((LOG_ERROR, "Upgrade Pack %s provided an invalid product ID", g_DllName));

        SetLastError (ERROR_NOACCESS);
        return FALSE;
    }

    return TRUE;
}

BOOL
PackBinary (
    PGROWBUFFER GrowBuf,
    PBYTE Data,
    DWORD DataSize
    )
{
    PBYTE Buf;

    if (!PackDword (GrowBuf, DataSize)) {
        return FALSE;
    }

    if (!DataSize) {
        return TRUE;
    }

    Buf = GrowBuffer (GrowBuf, DataSize);
    if (!Buf) {
        return FALSE;
    }

    __try {
        CopyMemory (Buf, Data, DataSize);
    }
    __except (TRUE) {
        DEBUGMSG ((
            DBG_ERROR,
            "%s provided an invalid binary parameter (%xh)",
            g_DllName,
            Data
            ));

        LOG ((LOG_ERROR, "Upgrade Pack %s provided an invalid binary parameter", g_DllName));

        SetLastError (ERROR_NOACCESS);
        return FALSE;
    }

    return TRUE;
}



typedef struct {
    PCTSTR WindowTitle;
    DWORD ProcessId;
    HWND Match;
} FINDWINDOW_STRUCT, *PFINDWINDOW_STRUCT;


BOOL
CALLBACK
pEnumWndProc (
    HWND hwnd,
    LPARAM lParam
    )

/*++

Routine Description:

  A callback that is called for every top level window on the system.
  It is used with pFindParentWindow to locate a specific window.

Arguments:

  hwnd      - Specifies the handle of the current enumerated window
  lParam    - Specifies a pointer to a FINDWINDOW_STRUCT variable that
              holds WindowTitle and ProcessId, and receives the
              handle if a match is found.

Return Value:

  The handle to the matching window, or NULL if no window has the
  specified title and process ID.

--*/

{
    TCHAR Title[MAX_TCHAR_PATH];
    DWORD ProcessId;
    PFINDWINDOW_STRUCT p;

    p = (PFINDWINDOW_STRUCT) lParam;

    GetWindowText (hwnd, Title, MAX_TCHAR_PATH);
    GetWindowThreadProcessId (hwnd, &ProcessId);

    DEBUGMSG ((DBG_MIGISOL, "Testing window: %s, ID=%x against %s, %x",
              Title, ProcessId, p->WindowTitle, p->ProcessId));

    if (!StringCompare (Title, p->WindowTitle) &&
        ProcessId == p->ProcessId) {

        p->Match = hwnd;
        LogReInit (&hwnd, NULL);

        DEBUGMSG ((DBG_MIGISOL, "Window found: %s, ID=%u", Title, ProcessId));
        return FALSE;
    }

    return TRUE;
}


HWND
pFindParentWindow (
    IN      PCTSTR WindowTitle,
    IN      DWORD ProcessId
    )

/*++

Routine Description:

  Locates the wizard window by enumerating all top-level windows.
  The first one to match the supplied title and process ID is used.

Arguments:

  WindowTitle   - Specifies the name of the window to find.
  ProcessId     - Specifies the ID of the process who owns the window.  If
                  zero is specified, NULL is returned.

Return Value:

  The handle to the matching window, or NULL if no window has the
  specified title and process ID.

--*/

{
    FINDWINDOW_STRUCT FindWndStruct;

    // If no process ID, we cannot have a match
    if (!ProcessId) {
        return NULL;
    }

    ZeroMemory (&FindWndStruct, sizeof (FindWndStruct));
    FindWndStruct.WindowTitle = WindowTitle;
    FindWndStruct.ProcessId   = ProcessId;

    EnumWindows (pEnumWndProc, (LPARAM) &FindWndStruct);

    return FindWndStruct.Match;
}


//
// Check platform that I'm runnig on. Copyed from winnt32[au].dll.
//   TRUE  - NEC98
//   FALSE - others(includes x86)
//

BOOL
IsNEC98(
    VOID
    )
{
    static BOOL Checked = FALSE;
    static BOOL Is98;

    if(!Checked) {

        Is98 = ((GetKeyboardType(0) == 7) && ((GetKeyboardType(1) & 0xff00) == 0x0d00));

        Checked = TRUE;
    }

    return(Is98);
}