able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/ntsetup/win95upg/w95upg/init9x/init9x.c

2035 lines
49 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
init9x.c
Abstract:
Code that initializes all libraries used on the Win9x side of the upgrade.
Author:
Jim Schmidt (jimschm) 30-Dec-1997
Revision History:
marcw 21-Jul-1999 Examine the boot sector.
marcw 15-Jul-1999 Added pSafeToUpgrade.
ovidiut 08-Mar-1999 Add call to UndoChangedFileProps
Jim Schmidt (jimschm) 30-Mar-1998 IsServerInstall
--*/
#include "pch.h"
#include "n98boot.h"
#include "init9xp.h"
//
// Process globals
//
BOOL g_Terminated = FALSE;
HANDLE g_hHeap = NULL;
HINSTANCE g_hInst = NULL;
HWND g_ParentWnd = NULL;
PRODUCTTYPE *g_ProductType;
extern DWORD g_MasterSequencer;
READ_DISK_SECTORS_PROC ReadDiskSectors;
//
// Paths
//
// Filled in DllMain
TCHAR g_DllDir[MAX_TCHAR_PATH];
TCHAR g_UpgradeSources[MAX_TCHAR_PATH];
// Filled in Winnt32PlugInInit
PTSTR g_TempDir;
PTSTR g_Win9xSifDir;
PTSTR g_TempDirWack;
PTSTR g_WinDir;
PTSTR g_WinDirWack;
PTSTR g_WinDrive;
PTSTR g_PlugInDir;
PTSTR g_PlugInDirWack;
PTSTR g_PlugInTempDir;
PTSTR g_SystemDir;
PTSTR g_SystemDirWack;
PTSTR g_System32Dir;
PTSTR g_System32DirWack;
PTSTR g_ProgramFilesDir;
PTSTR g_ProgramFilesDirWack;
PTSTR g_ProgramFilesCommonDir;
PTSTR g_Win95UpgInfFile;
PTSTR g_RecycledDirWack;
PTSTR g_ProfileDirNt;
PTSTR g_ProfileDir;
PTSTR g_ProfileDirWack;
PTSTR g_CommonProfileDir;
PTSTR g_DriversDir;
PTSTR g_InfDir;
PTSTR g_HelpDir;
PTSTR g_HelpDirWack;
PTSTR g_CatRootDir;
PTSTR g_CatRootDirWack;
PTSTR g_FontsDir;
PTSTR g_ViewersDir;
PTSTR g_ColorDir;
PTSTR g_SharedDir;
PTSTR g_SpoolDir;
PTSTR g_SpoolDriversDir;
PTSTR g_PrintProcDir;
HINF g_Win95UpgInf = INVALID_HANDLE_VALUE;
HINF g_TxtSetupSif = INVALID_HANDLE_VALUE;
PCTSTR g_ProfileName = NULL;
TCHAR g_Win95Name[MAX_TCHAR_PATH];
INT g_TempDirWackChars;
INT g_WinDirWackChars;
INT g_HelpDirWackChars;
INT g_CatRootDirWackChars;
INT g_SystemDirWackChars;
INT g_System32DirWackChars;
INT g_ProgramFilesDirWackChars;
INT g_PlugInDirWackChars;
INT g_RecycledDirWackChars;
INT g_ProfileDirWackChars;
BOOL g_ToolMode = FALSE;
//
// HWND for use by migrate.dlls.
//
HWND g_pluginHwnd;
//
// Info from WINNT32
//
PCTSTR g_SourceDirectories[MAX_SOURCE_COUNT];
DWORD g_SourceDirectoryCount;
PCTSTR * g_SourceDirectoriesFromWinnt32;
PDWORD g_SourceDirectoryCountFromWinnt32;
PCTSTR g_OptionalDirectories[MAX_SOURCE_COUNT];
DWORD g_OptionalDirectoryCount;
PCTSTR * g_OptionalDirectoriesFromWinnt32;
PDWORD g_OptionalDirectoryCountFromWinnt32;
PCTSTR * g_UnattendScriptFile;
PCTSTR * g_CmdLineOptions;
BOOL * g_UnattendedFlagPtr;
BOOL * g_CancelFlagPtr;
BOOL * g_AbortFlagPtr;
BOOL * g_UpgradeFlagPtr;
BOOL * g_MakeLocalSourcePtr;
BOOL * g_CdRomInstallPtr;
BOOL * g_BlockOnNotEnoughSpace;
PDWORD g_LocalSourceDrive;
PLONGLONG g_LocalSourceSpace;
PLONGLONG g_WinDirSpace;
PCTSTR g_AdministratorStr;
BOOL * g_ForceNTFSConversion;
PUINT g_RamNeeded;
PUINT g_RamAvailable;
UINT * g_ProductFlavor;
BOOL g_PersonalSKU;
PDWORD g_SetupFlags;
PTSTR g_DynamicUpdateLocalDir;
PTSTR g_DynamicUpdateDrivers;
BOOL * g_UnattendSwitchSpecified;
//
// Info for config.c
//
BOOL g_GoodDrive = FALSE; // cmdLine option: Skip Valid HDD check.
BOOL g_NoFear = FALSE; // cmdLine option: Skip Beta 1 Warnings...
POOLHANDLE g_UserOptionPool = NULL;
BOOL g_UseSystemFont = FALSE; // force use of sys font for variable text
BOOL g_Stress; // used for private stress options
POOLHANDLE g_GlobalPool; // for globals that are allocated for the lifetime of the DLL
//
// PC-98 additions
//
//
// Define and Globals for NEC98. These items are used to call 98ptn32.dll.
//
typedef int (CALLBACK WIN95_PLUGIN_98PTN32_GETBOOTDRIVE_PROTOTYPE)(void);
typedef WIN95_PLUGIN_98PTN32_GETBOOTDRIVE_PROTOTYPE * PWIN95_PLUGIN_98PTN32_GETBOOTDRIVE;
typedef BOOL (CALLBACK WIN95_PLUGIN_98PTN32_SETBOOTFLAG_PROTOTYPE)(int, WORD);
typedef WIN95_PLUGIN_98PTN32_SETBOOTFLAG_PROTOTYPE * PWIN95_PLUGIN_98PTN32_SETBOOTFLAG;
typedef BOOL (CALLBACK WIN95_PLUGIN_98PTN32_SETPTNNAME_PROTOTYPE)(int, WORD);
typedef WIN95_PLUGIN_98PTN32_SETPTNNAME_PROTOTYPE * PWIN95_PLUGIN_98PTN32_SETPTNNAME;
PWIN95_PLUGIN_98PTN32_SETBOOTFLAG SetBootFlag;
PWIN95_PLUGIN_98PTN32_GETBOOTDRIVE GetBootDrive;
PWIN95_PLUGIN_98PTN32_SETPTNNAME SetPtnName;
#define WIN95_98PTN32_GETBOOTDRIVE TEXT("GetBootDriveLetter32")
#define WIN95_98PTN32_SETBOOTFLAG TEXT("SetBootable95ptn32")
#define WIN95_98PTN32_SETPTNNAME TEXT("SetPartitionName32")
#define PC98_DLL_NAME TEXT("98PTN32.DLL")
HINSTANCE g_Pc98ModuleHandle = NULL;
#define SB_BOOTABLE 0x0001
#define SB_UNBOOTABLE 0x0002
#define MSK_BOOTABLE 0x000f
#define SB_AUTO 0x0010
#define MSK_AUTO 0x00f0
#define WIN9X_DOS_NAME 0
#define WINNT5_NAME 1
BOOL IsServerInstall (VOID);
VOID pCleanUpShellFolderTemp (VOID);
//
// The following macro expansion was designed to simplify library
// maintenence. The library name in LIBLIST is used in two ways:
// (1) the routine is automatically prototyped, and (2) an array
// of function pointers is automatically created. Each function
// listed in LIBLIST is called whenever the dll entry point is called.
//
// To add a new library to this DLL, follow these steps:
//
// 1. Make a directory and have the target built in win95upg\lib\i386.
// Your new library must have an entry point declared like DllEntryPoint.
// 2. Add the target library to the sources in win95upg\w95upg\dll\i386.
// 3. Add your library's entry point name to the list below. It will
// get called at load of w95upg.dll and at termination of w95upg.dll.
//
//
// IMPORTANT: MigUtil_Entry *must* be first; other libs are dependent on its
// initialization.
//
#define LIBLIST \
LIBRARY_NAME(MigUtil_Entry) \
LIBRARY_NAME(Win95Reg_Entry) \
LIBRARY_NAME(MemDb_Entry) \
LIBRARY_NAME(FileEnum_Entry) \
LIBRARY_NAME(Common9x_Entry) \
LIBRARY_NAME(MigApp_Entry) \
LIBRARY_NAME(HwComp_Entry) \
LIBRARY_NAME(BuildInf_Entry) \
LIBRARY_NAME(SysMig_Entry) \
LIBRARY_NAME(DosMig_Entry) \
LIBRARY_NAME(UI_Entry) \
LIBRARY_NAME(Ras_Entry) \
LIBRARY_NAME(MigDll9x_Entry) \
//
// Declare prototype types
//
typedef BOOL (WINAPI INITROUTINE_PROTOTYPE)(HINSTANCE, DWORD, LPVOID);
typedef INITROUTINE_PROTOTYPE * INITROUTINE;
//
// Declare the actual prototypes of the entry points
//
#define LIBRARY_NAME(x) INITROUTINE_PROTOTYPE x;
LIBLIST
#undef LIBRARY_NAME
//
// Declare an array of function pointers to the entry pointes
//
#define LIBRARY_NAME(x) x,
static INITROUTINE g_InitRoutine[] = {LIBLIST /*,*/ NULL};
#undef LIBRARY_NAME
//
// Declare variable to track number of libraries successfully loaded
//
static int g_LibCount = 0;
//
// Persistent strings buffer holds strings that we use for the
// life of the DLL.
//
static PGROWBUFFER g_PersistentStrings;
//
// Implementation
//
BOOL
FirstInitRoutine (
HINSTANCE hInstance
)
/*++
Routine Description:
pFirstInitRoutine is the very first function called during the
initialization of the DLL. It sets up globals such as the heap
pointer and instance handle. This routine must be called before
any library entry point is called.
Arguments:
hInstance - (OS-supplied) instance handle for the DLL
Return Value:
Returns TRUE if the global variables could be initialized, or FALSE
if an error occurred.
--*/
{
PTSTR p;
//
// Get the process heap & instance handle
//
if (g_ToolMode) {
g_hHeap = GetProcessHeap ();
}
else {
g_hHeap = HeapCreate(0, 0x20000, 0);
if (!g_hHeap) {
LOG ((LOG_ERROR, "Cannot create a private heap."));
g_hHeap = GetProcessHeap();
}
}
g_hInst = hInstance;
//
// No DLL_THREAD_ATTACH or DLL_THREAD_DETECH needed
//
DisableThreadLibraryCalls (hInstance);
//
// Init common controls
//
InitCommonControls();
//
// Get DLL path and strip directory
//
GetModuleFileName (hInstance, g_DllDir, MAX_TCHAR_PATH);
p = _tcsrchr (g_DllDir, TEXT('\\'));
MYASSERT (p);
*p = 0;
if (g_ToolMode) {
StringCopy (g_UpgradeSources, g_DllDir);
}
return TRUE;
}
BOOL
InitLibs (
HINSTANCE hInstance,
DWORD dwReason,
PVOID lpReserved
)
/*++
Routine Description:
pInitLibs calls all library entry points in the g_InitRoutine array.
If an entry point fails, all libraries are unloaded in reverse order
and pInitLibs returns FALSE.
Arguments:
hInstance - (OS-supplied) instance handle for the DLL
dwReason - (OS-supplied) indicates attach or detatch from process or
thread -- in this case always DLL_PROCESS_ATTACH
lpReserved - (OS-supplied) unused
Return Value:
Returns TRUE if all libraries successfully initialized, or FALSE if
a library could not initialize. If TRUE is returned, pTerminateLibs
must be called for the DLL_PROCESS_DETACH message.
--*/
{
InitCommonControls();
if(!pSetupInitializeUtils()) {
return FALSE;
}
SET_RESETLOG();
// Init each LIB
for (g_LibCount = 0 ; g_InitRoutine[g_LibCount] != NULL ; g_LibCount++) {
if (!g_InitRoutine[g_LibCount] (hInstance, dwReason, lpReserved)) {
TerminateLibs (hInstance, DLL_PROCESS_DETACH, lpReserved);
return FALSE;
}
}
return TRUE;
}
BOOL
FinalInitRoutine (
VOID
)
/*++
Routine Description:
pFinalInitRoutine completes all initialization that requires completely
initialized libraries.
Arguments:
none
Return Value:
TRUE if initialization completed successfully, or FALSE if an error occurred.
--*/
{
TCHAR Buffer[MAX_TCHAR_PATH];
PTSTR p;
//
// Load common message strings
//
g_PersistentStrings = CreateAllocTable();
if (!g_PersistentStrings) {
return FALSE;
}
// Get Administrator account name
g_AdministratorStr = GetStringResourceEx (g_PersistentStrings, MSG_ADMINISTRATOR_ACCOUNT);
if (!g_AdministratorStr) {
g_AdministratorStr = S_EMPTY;
}
//
// Obtain PC-98 helper routine addresses
//
if(ISPC98()){
//
// Generate directory of WINNT32
//
StringCopy (Buffer, g_UpgradeSources);
p = _tcsrchr (Buffer, TEXT('\\'));
MYASSERT (p);
StringCopy (_tcsinc(p), PC98_DLL_NAME);
//
// Load library
//
g_Pc98ModuleHandle = LoadLibraryEx(
Buffer,
NULL,
LOAD_WITH_ALTERED_SEARCH_PATH
);
if(!g_Pc98ModuleHandle){
LOG ((LOG_ERROR, "Cannot load %s", Buffer));
return FALSE;
}
//
// Get entry points
//
(FARPROC)SetBootFlag = GetProcAddress (g_Pc98ModuleHandle, WIN95_98PTN32_SETBOOTFLAG);
if(!SetBootFlag){
LOG ((LOG_ERROR, "Cannot get %s address from %s", WIN95_98PTN32_SETBOOTFLAG, Buffer));
return FALSE;
}
(FARPROC)GetBootDrive = GetProcAddress (g_Pc98ModuleHandle, WIN95_98PTN32_GETBOOTDRIVE);
if(!GetBootDrive){
LOG ((LOG_ERROR, "Cannot get %s address from %s", WIN95_98PTN32_GETBOOTDRIVE, Buffer));
return FALSE;
}
(FARPROC)SetPtnName = GetProcAddress (g_Pc98ModuleHandle, WIN95_98PTN32_SETPTNNAME);
if(!SetPtnName){
LOG ((LOG_ERROR, "Cannot get %s address from %s", WIN95_98PTN32_SETPTNNAME, Buffer));
return FALSE;
}
//
// Update boot drive
//
DEBUGMSG_IF ((
GetBootDrive() != g_BootDriveLetterA,
DBG_VERBOSE,
"Boot drive letter is %c:, different from A:",
GetBootDrive()
));
g_BootDriveLetterW = g_BootDriveLetterA = (char)GetBootDrive();
*((PSTR) g_BootDrivePathA) = g_BootDriveLetterA;
*((PWSTR) g_BootDrivePathW) = g_BootDriveLetterW;
}
//
// Allocate a global pool
//
g_GlobalPool = PoolMemInitNamedPool ("Global Pool");
//
// Declare temporary memdb keys
//
#ifndef PRERELEASE
if (!MemDbCreateTemporaryKey (MEMDB_TMP_HIVE)) {
LOG((LOG_ERROR, TEXT("Cannot create temporary key!")));
}
#endif
pCleanUpShellFolderTemp();
return TRUE;
}
VOID
pCleanUpShellFolderTemp (
VOID
)
{
DRIVELETTERS driveLetters;
UINT u;
TCHAR dir1[] = S_SHELL_TEMP_NORMAL_PATH;
TCHAR dir2[] = S_SHELL_TEMP_LONG_PATH;
InitializeDriveLetterStructure (&driveLetters);
for (u = 0 ; u < NUMDRIVELETTERS ; u++) {
if (driveLetters.Type[u] == DRIVE_FIXED) {
dir1[0] = driveLetters.Letter[u];
dir2[0] = driveLetters.Letter[u];
RemoveCompleteDirectory (dir1);
RemoveCompleteDirectory (dir2);
}
}
}
VOID
FirstCleanupRoutine (
VOID
)
/*++
Routine Description:
pFirstCleanupRoutine is called to perform any cleanup that requires
libraries to still be loaded.
Arguments:
none
Return Value:
none
--*/
{
g_Terminated = TRUE;
//
// Clean up drive structures
//
CleanUpAccessibleDrives();
//
// Clean up our fake NT environment block
//
TerminateNtEnvironment();
CleanUp9xEnvironmentVariables();
//
// Free standard pools
//
if (g_GlobalPool) {
PoolMemDestroyPool (g_GlobalPool);
g_GlobalPool = NULL;
}
if (g_PersistentStrings) {
DestroyAllocTable (g_PersistentStrings);
g_PersistentStrings = NULL;
}
if (g_UserOptionPool) {
PoolMemDestroyPool(g_UserOptionPool);
g_UserOptionPool = NULL;
}
//
// Close all files
//
CleanUpKnownGoodIconMap();
if (g_Win95UpgInf != INVALID_HANDLE_VALUE) {
InfCloseInfFile (g_Win95UpgInf);
g_Win95UpgInf = INVALID_HANDLE_VALUE;
}
if (g_TxtSetupSif != INVALID_HANDLE_VALUE) {
InfCloseInfFile (g_TxtSetupSif);
g_TxtSetupSif = INVALID_HANDLE_VALUE;
}
CleanupMigDb();
}
VOID
TerminateLibs (
HINSTANCE hInstance,
DWORD dwReason,
LPVOID lpReserved
)
/*++
Routine Description:
TerminateLibs is called to unload all libraries in the reverse order
that they were initialized. Each entry point of successfully
initialized library is called.
Arguments:
hInstance - (OS-supplied) instance handle for the DLL
dwReason - (OS-supplied) indicates attach or detatch from process or
thread -- in this case always DLL_PROCESS_DETACH
lpReserved - (OS-supplied) unused
Return Value:
none
--*/
{
INT i;
for (i = g_LibCount - 1 ; i >= 0 ; i--) {
g_InitRoutine[i] (hInstance, dwReason, lpReserved);
}
g_LibCount = 0;
pSetupUninitializeUtils();
}
VOID
FinalCleanupRoutine (
VOID
)
/*++
Routine Description:
FinalCleanupRoutine is after all library entry points have been
called for cleanup. This routine cleans up all resources that a
library will not clean up.
Arguments:
none
Return Value:
none
--*/
{
}
BOOL
pSafeToUpgrade (
VOID
)
/*++
Routine Description:
pSafeToUpgrade ensures that we are willing to upgrade the machine. If
certain conditions exist (particularily other OSes on other partitions) we
may inadvertantly destroy data used by the other Operating System.
Arguments:
None.
Return Value:
TRUE if we believe it is safe to upgrade the machine, FALSE otherwise.
--*/
{
BOOL rUpgradeSafe = TRUE;
//
// ignore this check for now, allow machines that have multiple OSes installed to be upgraded
// if they have another OS on the SAME drive, setup will stop at the report,
// after disk analyze phase
//
#if 0
PTSTR p;
GROWBUFFER buf = GROWBUF_INIT;
UINT size;
MULTISZ_ENUM e;
TCHAR winDriveMatch[20];
PCTSTR group;
PCTSTR message;
BOOL ntBootSector = FALSE;
BYTE bootSector[FAT_BOOT_SECTOR_SIZE];
TCHAR cmpBuffer[6];
UINT i;
//
// Look to see if there is an NT boot sector on the machine.
//
__try {
if (ReadDiskSectors (
*g_BootDrive,
FAT_STARTING_SECTOR,
FAT_BOOT_SECTOR_COUNT,
FAT_BOOT_SECTOR_SIZE,
bootSector
)) {
cmpBuffer[5] = 0;
for (i = 0;i < FAT_BOOT_SECTOR_SIZE - 4; i++) {
if (bootSector[i] == 'n' || bootSector[i] == 'N') {
StringCopyByteCount (cmpBuffer, (PTSTR) (bootSector + i), 6);
if (StringIMatch (cmpBuffer, TEXT("ntldr"))) {
ntBootSector = TRUE;
break;
}
}
}
}
}
__except (1) {
ntBootSector = FALSE;
}
if (ntBootSector) {
//
// See if there is another OS listed in BOOT.ini.
//
p = JoinPaths (g_BootDrive, S_BOOTINI);
size = 4096;
GrowBuffer (&buf, size);
*buf.Buf = 0;
while (GetPrivateProfileSection (S_OPERATING_SYSTEMS, buf.Buf, 4096, p) == size -2) {
size += 4096;
GrowBuffer (&buf, size);
}
FreePathString (p);
if (EnumFirstMultiSz (&e, buf.Buf)) {
wsprintf (winDriveMatch, TEXT("%s\\"), g_WinDrive);
do {
p = (PTSTR) _tcschr (e.CurrentString, TEXT('='));
if (p) {
*p = 0;
}
if (!StringIMatchCharCount(winDriveMatch, e.CurrentString, 3)) {
if (!g_ConfigOptions.IgnoreOtherOS) {
g_OtherOsExists = TRUE;
group = BuildMessageGroup (MSG_INSTALL_NOTES_ROOT, MSG_OTHER_OS_WARNING_SUBGROUP, NULL);
message = GetStringResource (MSG_OTHER_OS_WARNING);
if (message && group) {
MsgMgr_ObjectMsg_Add (TEXT("*BootIniFound"), group, message);
}
FreeText (group);
FreeStringResource (message);
rUpgradeSafe = FALSE;
//
// Let the user know why they won't be upgrading today.
//
break;
}
}
if (p) {
*p = TEXT('=');
}
} while (EnumNextMultiSz (&e));
}
FreeGrowBuffer (&buf);
}
#endif
return rUpgradeSafe;
}
BOOL
pGetInfEntry (
IN PCTSTR Section,
IN PCTSTR Key,
OUT PTSTR Buffer
)
/*++
Routine Description:
Given a section and key, pGetInfEntry gets a value from win95upg.inf.
Arguments:
Section - Specifies the section contianing Key
Key - Specifies the key containing a value
Buffer - Receives the value specified in win95upg.inf for Section and Key
Return Value:
TRUE if a value was obtained, or FALSE if the value does not exist.
--*/
{
GetPrivateProfileString (
Section,
Key,
S_EMPTY,
Buffer,
MAX_TCHAR_PATH,
g_Win95UpgInfFile
);
Buffer[MAX_TCHAR_PATH-1] = 0;
if (!(*Buffer)) {
LOG ((
LOG_ERROR,
"Cannot obtain %s in [%s] in %s.",
Key,
Section,
g_Win95UpgInfFile
));
return FALSE;
}
return TRUE;
}
PTSTR
pCreateDirectoryFromInf (
IN PCTSTR Key,
IN PCTSTR BaseDir,
IN BOOL Empty
)
/*++
Routine Description:
pCreateDirectoryFromInf obtains a directory for the sequencer specified
by Key. If Key is valid, the BaseDir is combined with the value stored
in win95upg.inf to form a complete path. The path is created and the
path string is returned to the caller.
If g_ToolMode is TRUE, then we don't have an INF to read, and we make
all the directories point to the name "Setup."
Arguments:
Key - Specifies the key (normally a number) that exists in the [Win95.Directories]
section of win95upg.inf.
BaseDir - Specifies the base directory to build the path from.
Empty - TRUE if directory should be emptied, FALSE if it should be created
if it does not already exist
Return Value:
A pointer to the path, or NULL if the specified key doesn't exist or the
path could not be created.
The caller must free a non-NULL return value with FreePathString.
--*/
{
TCHAR FileName[MAX_TCHAR_PATH];
PTSTR Buffer;
BOOL b;
LONG rc;
if (g_ToolMode) {
StringCopy (FileName, TEXT("Setup"));
} else if (!pGetInfEntry (
SECTION_MIGRATION_DIRECTORIES,
Key,
FileName
)) {
LOG ((LOG_ERROR, "%s does not exist in [%s] of %s",Key, SECTION_MIGRATION_DIRECTORIES, FileName));
return FALSE;
}
Buffer = JoinPathsEx (g_GlobalPool, BaseDir, FileName);
if (Empty) {
b = CreateEmptyDirectory (Buffer);
} else {
b = MakeSurePathExists (Buffer, TRUE) == ERROR_SUCCESS;
}
if (!b) {
rc = GetLastError();
if (rc != ERROR_SUCCESS && rc != ERROR_ALREADY_EXISTS) {
LOG ((LOG_ERROR, "Cannot create %s", Buffer));
FreePathStringEx (g_GlobalPool, Buffer);
return NULL;
}
}
return Buffer;
}
BOOL
pGetProductFlavor (
VOID
)
{
DWORD i;
TCHAR buf[12];
PTSTR path;
DWORD count;
DWORD rc = ERROR_INVALID_PARAMETER; // when *g_SourceDirectoryCountFromWinnt32 == 0
BOOL b = FALSE;
for (i = 0; i < *g_SourceDirectoryCountFromWinnt32; i++) {
path = JoinPaths (g_SourceDirectoriesFromWinnt32[i], TEXT("dosnet.inf"));
count = GetPrivateProfileString (
TEXT("Miscellaneous"),
S_PRODUCTTYPE,
TEXT(""),
buf,
12,
path
);
rc = GetLastError ();
FreePathString (path);
if (count == 1 && buf[0] >= TEXT('0') && buf[0] <= TEXT('9')) {
*g_ProductFlavor = buf[0] - TEXT('0');
b = TRUE;
break;
}
}
if (!b && g_ToolMode) {
b = TRUE;
}
SetLastError (rc);
return b;
}
//
// Exported functions called from WINNT32
//
DWORD
Winnt32Init (
IN PWINNT32_WIN9XUPG_INIT_INFORMATION_BLOCK Info
)
/*++
Routine Description:
Winnt32Init is called when WINNT32 first loads w95upg.dll, before
any wizard pages are displayed. The structure supplies pointers to
WINNT32's variables that will be filled with valid values as WINNT32
runs.
This routine copies the inbound values to our own private structures.
We do not count on WINNT32 to maintain the Info structure after we
return.
In addition to obtaining the WINNT32 variable pointers, this routine
generates all paths needed by the w95upg.dll to do its work.
Arguments:
Win9xInfo - Specifies the WINNT32 variables the upgrade module needs access
to.
Return Value:
A Win32 status code indicating outcome.
--*/
{
DWORD rc = ERROR_SUCCESS;
PCTSTR TempStr = NULL;
PCTSTR RegStr = NULL;
PTSTR TempStr2;
TCHAR TempPath[MAX_TCHAR_PATH];
HKEY Key;
PCTSTR RegData;
HKEY h;
INFSTRUCT is = INITINFSTRUCT_GROWBUFFER;
UINT index;
UINT index2;
#if 0
PDWORD data;
#endif
DEBUGMSG ((
DBG_VERBOSE,
"ProductType: %u\n"
"BuildNumber: %u\n"
"ProductVersion: %u\n"
"Debug: %u\n"
"PreRelease: %u\n"
"UpdatesLocalDir: %s\n",
*Info->BaseInfo->ProductType,
Info->BaseInfo->BuildNumber,
Info->BaseInfo->ProductVersion,
Info->BaseInfo->Debug,
Info->BaseInfo->PreRelease,
Info->DynamicUpdateLocalDir ? Info->DynamicUpdateLocalDir : TEXT("<none>")
));
__try {
//
// Open win95upg.inf in i386\winnt32\win9x
//
g_Win95UpgInfFile = JoinPathsEx (g_GlobalPool, g_UpgradeSources, STR_WIN95UPG_INF);
g_Win95UpgInf = InfOpenInfFile (g_Win95UpgInfFile);
if (g_Win95UpgInf == INVALID_HANDLE_VALUE) {
if (!g_ToolMode) {
LOG ((LOG_ERROR, "Cannot open %s", g_Win95UpgInfFile));
rc = ERROR_FILE_NOT_FOUND;
__leave;
}
}
InitializeKnownGoodIconMap();
MsgMgr_InitStringMap ();
//
// Get name of platform
//
if (ISWIN95_GOLDEN()) {
TempStr = GetStringResource (MSG_CHICAGO);
} else if (ISWIN95_OSR2()) {
TempStr = GetStringResource (MSG_NASHVILLE);
} else if (ISMEMPHIS()) {
TempStr = GetStringResource (MSG_MEMPHIS);
} else if (ISMILLENNIUM()) {
TempStr = GetStringResource (MSG_MILLENNIUM);
} else {
//
// We don't know what this is. We'll check the registry. If there isn't a name there, we'll
// use an 'unknown' case name.
//
h = OpenRegKeyStr (TEXT("HKLM\\Software\\Microsoft\\Windows\\CurrentVersion"));
if (h && h != INVALID_HANDLE_VALUE) {
RegStr = GetRegValueString (h, TEXT("ProductName"));
CloseRegKey (h);
}
if (!RegStr) {
TempStr = GetStringResource (MSG_UNKOWN_WINDOWS);
}
}
if (!TempStr && !RegStr) {
rc = GetLastError();
__leave;
}
StringCopy (g_Win95Name, TempStr ? TempStr : RegStr);
if (TempStr) {
FreeStringResource (TempStr);
}
if (RegStr) {
MemFree (g_hHeap, 0, RegStr);
}
MemDbSetValueEx (
MEMDB_CATEGORY_STATE,
MEMDB_ITEM_PLATFORM_NAME,
g_Win95Name,
NULL,
0,
NULL
);
//
// Get %WinDir%, with and without wack
//
if (!GetWindowsDirectory (TempPath, MAX_TCHAR_PATH)) {
return GetLastError ();
}
g_WinDir = PoolMemDuplicateString (g_GlobalPool, TempPath);
g_WinDirWack = JoinPathsEx (g_GlobalPool, g_WinDir, S_EMPTY);
g_WinDirWackChars = CharCount (g_WinDirWack);
g_InfDir = JoinPaths (g_WinDir, S_INFDIR);
g_HelpDir = JoinPaths (g_WinDir, S_HELPDIR);
g_HelpDirWack = JoinPaths (g_HelpDir, S_EMPTY);
g_HelpDirWackChars = CharCount (g_HelpDirWack);
g_CatRootDir = JoinPaths (g_WinDir, S_CATROOTDIR);
g_CatRootDirWack = JoinPaths (g_CatRootDir, S_EMPTY);
g_CatRootDirWackChars = CharCount (g_CatRootDirWack);
g_FontsDir = JoinPaths (g_WinDir, S_FONTSDIR);
g_SharedDir = g_WinDir;
//
// Get Windows drive
//
SplitPath (g_WinDir, &TempStr2, NULL, NULL, NULL);
g_WinDrive = PoolMemDuplicateString (g_GlobalPool, TempStr2);
FreePathString (TempStr2);
//
// Get user profile dir
//
g_ProfileDir = JoinPathsEx (g_GlobalPool, g_WinDir, S_PROFILES);
g_ProfileDirWack = JoinPathsEx (g_GlobalPool, g_ProfileDir, S_EMPTY);
g_ProfileDirWackChars = CharCount (g_ProfileDirWack);
g_CommonProfileDir = JoinPathsEx (g_GlobalPool, g_WinDir, TEXT("All Users"));
//
// Get System dir, with and without wack
//
GetSystemDirectory(TempPath, MAX_TCHAR_PATH);
g_SystemDir = PoolMemDuplicateString (g_GlobalPool, TempPath);
g_SystemDirWack = JoinPathsEx (g_GlobalPool, g_SystemDir, S_EMPTY);
g_SystemDirWackChars = CharCount (g_SystemDirWack);
//
// Get System32 dir
//
g_System32Dir = JoinPathsEx (g_GlobalPool, g_WinDir, STR_SYSTEM32);
g_System32DirWack = JoinPathsEx (g_GlobalPool, g_System32Dir, S_EMPTY);
g_System32DirWackChars = CharCount (g_System32DirWack);
g_DriversDir = JoinPaths (g_System32Dir, S_DRIVERSDIR);
g_ViewersDir = JoinPaths (g_System32Dir, S_VIEWERSDIR);
g_SpoolDir = JoinPaths (g_System32Dir, S_SPOOLDIR);
g_SpoolDriversDir = JoinPaths (g_SpoolDir, S_SPOOLDRIVERSDIR);
g_ColorDir = JoinPaths (g_SpoolDriversDir,S_COLORDIR);
g_PrintProcDir = JoinPaths (g_SpoolDir, S_PRINTPROCDIR);
//
// Get Program Files dir
//
g_ProgramFilesDir = NULL;
g_ProgramFilesCommonDir = NULL;
Key = OpenRegKeyStr (TEXT("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion"));
if (Key) {
RegData = GetRegValueString (Key, TEXT("ProgramFilesDir"));
if (RegData) {
g_ProgramFilesDir = PoolMemDuplicateString (g_GlobalPool, RegData);
MemFree (g_hHeap, 0, RegData);
}
}
if (!g_ProgramFilesDir) {
TempStr = (PTSTR) GetStringResource (MSG_PROGRAM_FILES_DIR);
MYASSERT (TempStr);
g_ProgramFilesDir = PoolMemDuplicateString (g_GlobalPool, TempStr);
MYASSERT (g_ProgramFilesDir);
g_ProgramFilesDir[0] = g_SystemDir[0];
FreeStringResource (TempStr);
}
DEBUGMSG ((DBG_VERBOSE, "Program Files Dir is %s", g_ProgramFilesDir));
//
// Get Program Files\Common Files dir
//
g_ProgramFilesDirWack = JoinPathsEx (g_GlobalPool, g_ProgramFilesDir, S_EMPTY);
MYASSERT (g_ProgramFilesDirWack);
g_ProgramFilesDirWackChars = CharCount (g_ProgramFilesDirWack);
if (Key) {
RegData = GetRegValueString (Key, TEXT("CommonFilesDir"));
if (RegData) {
g_ProgramFilesCommonDir = PoolMemDuplicateString (g_GlobalPool, RegData);
MemFree (g_hHeap, 0, RegData);
}
}
if (!g_ProgramFilesCommonDir) {
TempStr = JoinPaths (g_ProgramFilesDir, S_COMMONDIR);
g_ProgramFilesCommonDir = PoolMemDuplicateString (g_GlobalPool, TempStr);
FreePathString (TempStr);
}
if (Key) {
CloseRegKey (Key);
}
DEBUGMSG ((DBG_VERBOSE, "Common Program Files Dir is %s", g_ProgramFilesCommonDir));
//
// Create temporary directory path, with and without wack
//
g_TempDir = pCreateDirectoryFromInf (KEY_TEMP_BASE, g_WinDir, FALSE);
if (!g_TempDir) {
rc = GetLastError();
__leave;
}
g_Win9xSifDir = JoinPathsEx (g_GlobalPool, g_TempDir,S_WIN9XSIF);
g_TempDirWack = JoinPathsEx (g_GlobalPool, g_TempDir, S_EMPTY);
g_TempDirWackChars = CharCount (g_TempDirWack);
//
// Build plugin dir, with and without wack
//
g_PlugInDir = PoolMemDuplicateString (g_GlobalPool, g_TempDir);
g_PlugInDirWack = JoinPathsEx (g_GlobalPool, g_PlugInDir, S_EMPTY);
g_PlugInDirWackChars = CharCount (g_PlugInDirWack);
//
// Create plugin temp dir, with and without wack.
//
g_PlugInTempDir = JoinPathsEx (g_GlobalPool, g_PlugInDir, TEXT("temp"));
//
// Create recycled dir, with wack
//
g_RecycledDirWack = JoinPathsEx (g_GlobalPool, g_WinDrive, TEXT("recycled\\"));
g_RecycledDirWackChars = CharCount (g_RecycledDirWack);
//
// Copy WINNT32 settings to globals
//
// NOTE: If more args are added to WINNT32's Info struct, you should
// adjust the InitToolMode code below to match.
//
//
g_UnattendedFlagPtr = Info->BaseInfo->UnattendedFlag;
g_CancelFlagPtr = Info->BaseInfo->CancelledFlag;
g_AbortFlagPtr = Info->BaseInfo->AbortedFlag;
g_UpgradeFlagPtr = Info->BaseInfo->UpgradeFlag;
g_MakeLocalSourcePtr = Info->BaseInfo->LocalSourceModeFlag;
g_CdRomInstallPtr = Info->BaseInfo->CdRomInstallFlag;
g_UnattendScriptFile = Info->BaseInfo->UnattendedScriptFile;
g_CmdLineOptions = Info->BaseInfo->UpgradeOptions;
g_BlockOnNotEnoughSpace = Info->BaseInfo->NotEnoughSpaceBlockFlag;
g_LocalSourceDrive = Info->BaseInfo->LocalSourceDrive;
g_LocalSourceSpace = Info->BaseInfo->LocalSourceSpaceRequired;
g_ProductType = Info->BaseInfo->ProductType;
g_SourceDirectoryCountFromWinnt32 = Info->BaseInfo->SourceDirectoryCount;
g_SourceDirectoriesFromWinnt32 = Info->BaseInfo->SourceDirectories;
g_ForceNTFSConversion = Info->BaseInfo->ForceNTFSConversion;
g_Boot16 = Info->BaseInfo->Boot16;
g_UnattendSwitchSpecified = Info->BaseInfo->UnattendSwitchSpecified;
//
// ProductFlavor is not initialized at this point yet, but it will be below
//
g_ProductFlavor = Info->BaseInfo->ProductFlavor;
g_SetupFlags = Info->BaseInfo->SetupFlags;
g_WinDirSpace = Info->WinDirSpace;
g_RamNeeded = Info->RequiredMb;
g_RamAvailable = Info->AvailableMb;
g_OptionalDirectoryCountFromWinnt32 = Info->OptionalDirectoryCount;
g_OptionalDirectoriesFromWinnt32 = Info->OptionalDirectories;
g_UpginfsUpdated = Info->UpginfsUpdated;
ReadDiskSectors = Info->ReadDiskSectors;
if (!pGetProductFlavor ()) {
LOG ((LOG_ERROR, "Cannot get ProductType key from dosnet.inf"));
rc = GetLastError ();
__leave;
}
if (*g_ProductFlavor != PROFESSIONAL_PRODUCTTYPE && *g_ProductFlavor != PERSONAL_PRODUCTTYPE) {
*g_ProductType = NT_SERVER;
} else {
*g_ProductType = NT_WORKSTATION;
g_PersonalSKU = (*g_ProductFlavor == PERSONAL_PRODUCTTYPE);
}
if (IsServerInstall()) {
rc = ERROR_REQUEST_ABORTED;
__leave;
}
//
// NOTE: If more args are added to WINNT32's Info struct, you should
// adjust the InitToolMode code below to match.
//
if (Info->DynamicUpdateLocalDir && *Info->DynamicUpdateLocalDir) {
g_DynamicUpdateLocalDir = DuplicateTextEx (g_GlobalPool, Info->DynamicUpdateLocalDir, 0, NULL);
}
if (Info->DynamicUpdateDrivers && *Info->DynamicUpdateDrivers) {
g_DynamicUpdateDrivers = DuplicateTextEx (g_GlobalPool, Info->DynamicUpdateDrivers, 0, NULL);
}
g_UserOptionPool = PoolMemInitNamedPool ("User Options");
//
// Initialize Win9x environment table
//
Init9xEnvironmentVariables();
//
// Make sure that we really want to upgrade this machine.
//
if (!g_ToolMode && !pSafeToUpgrade ()) {
*Info->UpgradeFailureReason = REASON_UPGRADE_OTHER_OS_FOUND;
rc = ERROR_REQUEST_ABORTED;
__leave;
}
//
// winnt32 doesn't scrub the source directories for duplicates..We, however, do.
//
g_SourceDirectoryCount = 0;
for (index = 0 ; index < *g_SourceDirectoryCountFromWinnt32; index++) {
for (index2 = 0; index2 < g_SourceDirectoryCount; index2++) {
if (StringIMatch(
g_SourceDirectories[index2],
g_SourceDirectoriesFromWinnt32[index]
)) {
DEBUGMSG ((
DBG_WARNING,
"Duplicate Source Directory %s removed from list!!",
g_SourceDirectories[index2]
));
break;
}
}
if (index2 == g_SourceDirectoryCount) {
//
// No matching directory found, add to list..
//
g_SourceDirectories[g_SourceDirectoryCount++] = g_SourceDirectoriesFromWinnt32[index];
}
}
//
// Do the samescrubbing with optional directories.
//
g_OptionalDirectoryCount = 0;
for (index = 0 ; index < *g_OptionalDirectoryCountFromWinnt32; index++) {
for (index2 = 0; index2 < g_OptionalDirectoryCount; index2++) {
if (StringIMatch(
g_OptionalDirectories[index2],
g_OptionalDirectoriesFromWinnt32[index]
)) {
DEBUGMSG ((
DBG_WARNING,
"Duplicate Optional Directory %s removed from list!!",
g_OptionalDirectories[index2]
));
break;
}
}
if (index2 == g_OptionalDirectoryCount) {
//
// No matching directory found, add to list..
//
g_OptionalDirectories[g_OptionalDirectoryCount++] = g_OptionalDirectoriesFromWinnt32[index];
}
}
//
// block upgrades from Win95
//
if (!g_ToolMode && !ISATLEASTWIN98()) {
rc = ERROR_REQUEST_ABORTED;
ResourceMessageBox (NULL, MSG_PLATFORM_UPGRADE_UNSUPPORTED, MB_OK, NULL);
__leave;
}
rc = ERROR_SUCCESS;
}
__finally {
if (rc != ERROR_SUCCESS && rc != ERROR_REQUEST_ABORTED) {
if (g_Win95UpgInf != INVALID_HANDLE_VALUE) {
InfCloseInfFile (g_Win95UpgInf);
g_Win95UpgInf = INVALID_HANDLE_VALUE;
}
}
}
return rc;
}
BOOL
InitToolMode (
HINSTANCE Instance
)
/*++
Routine Description:
InitToolMode is called by Win9x-side tools (not by shipping setup code).
It initializes the libraries and simulates WINNT32 init.
Arguments:
None.
Return Value:
TRUE if init was successful, FALSE otherwise.
--*/
{
DWORD dwReason;
PVOID lpReserved;
WINNT32_PLUGIN_INIT_INFORMATION_BLOCK BaseInfo;
WINNT32_WIN9XUPG_INIT_INFORMATION_BLOCK InfoBlock;
static BOOL AlwaysFalseFlag = FALSE;
static BOOL AlwaysTrueFlag = TRUE;
static PRODUCTTYPE ProductType = NT_WORKSTATION;
static UINT SourceDirs = 1;
static PCTSTR SourceDirMultiSz = TEXT(".\0");
static UINT ProductFlavor = PERSONAL_PRODUCTTYPE;
static UINT AlwaysZero = 0;
g_ToolMode = TRUE;
//
// Simulate DllMain
//
dwReason = DLL_PROCESS_ATTACH;
lpReserved = NULL;
//
// Initialize DLL globals
//
if (!FirstInitRoutine (Instance)) {
return FALSE;
}
//
// Initialize all libraries
//
if (!InitLibs (Instance, dwReason, lpReserved)) {
return FALSE;
}
//
// Final initialization
//
if (!FinalInitRoutine ()) {
return FALSE;
}
//
// Simulate WINNT32 init
//
ZeroMemory (&BaseInfo, sizeof (BaseInfo));
ZeroMemory (&InfoBlock, sizeof (InfoBlock));
BaseInfo.UnattendedFlag = &AlwaysFalseFlag;
BaseInfo.CancelledFlag = &AlwaysFalseFlag;
BaseInfo.AbortedFlag = &AlwaysFalseFlag;
BaseInfo.UpgradeFlag = &AlwaysTrueFlag;
BaseInfo.LocalSourceModeFlag = &AlwaysFalseFlag;
BaseInfo.CdRomInstallFlag = &AlwaysFalseFlag;
BaseInfo.UnattendedScriptFile = NULL;
BaseInfo.UpgradeOptions = NULL;
BaseInfo.NotEnoughSpaceBlockFlag = &AlwaysFalseFlag;
BaseInfo.LocalSourceDrive = NULL;
BaseInfo.LocalSourceSpaceRequired = 0;
BaseInfo.ProductType = &ProductType;
BaseInfo.SourceDirectoryCount = &SourceDirs;
BaseInfo.SourceDirectories = &SourceDirMultiSz;
BaseInfo.ForceNTFSConversion = &AlwaysFalseFlag;
BaseInfo.Boot16 = &AlwaysFalseFlag;
BaseInfo.ProductFlavor = &ProductFlavor;
InfoBlock.BaseInfo = &BaseInfo;
InfoBlock.WinDirSpace = 0;
InfoBlock.RequiredMb = 0;
InfoBlock.AvailableMb = 0;
InfoBlock.OptionalDirectories = NULL;
InfoBlock.OptionalDirectoryCount = &AlwaysZero;
return ERROR_SUCCESS == Winnt32Init (&InfoBlock);
}
VOID
TerminateToolMode (
HINSTANCE Instance
)
{
DWORD dwReason;
PVOID lpReserved;
//
// Simulate DllMain
//
dwReason = DLL_PROCESS_DETACH;
lpReserved = NULL;
//
// Call the cleanup routine that requires library APIs
//
FirstCleanupRoutine();
//
// Clean up all libraries
//
TerminateLibs (Instance, dwReason, lpReserved);
//
// Do any remaining clean up
//
FinalCleanupRoutine();
}
DWORD
Winnt32WriteParamsWorker (
IN PCTSTR WinntSifFile
)
/*++
Routine Description:
Winnt32WriteParamsWorker is called just before WINNT32 begins to modify the
boot sector and copy files. Our job here is to take the specified
WINNT.SIF file, read it in, merge in our changes, and write it back
out.
Arguments:
WinntSifFile - Specifies path to WINNT.SIF. By this time, the WINNT.SIF
file has some values already set.
Return Value:
A Win32 status code indicating outcome.
--*/
{
static TCHAR SifBuf[MAX_TCHAR_PATH];
//
// This can take a while (especially writing the INF to disk.)
// Display a wait cursor.
//
TurnOnWaitCursor();
__try {
//
// We finally got the WINNT.SIF file location. Merge any
// settings that are already there, then save it to disk.
// If it saves OK, start using profile APIs.
//
if (!MergeInf (WinntSifFile))
return GetLastError();
if (!WriteInfToDisk (WinntSifFile))
return GetLastError();
StringCopy (SifBuf, WinntSifFile);
g_ProfileName = SifBuf;
if (!REPORTONLY()) {
//
// Go ahead and save ntsetup.dat at this time as well.. to ensure that we
// get rid of the BuildInf stuff.
//
MemDbSetValue (
MEMDB_CATEGORY_STATE TEXT("\\") MEMDB_ITEM_MASTER_SEQUENCER,
g_MasterSequencer
);
if (!MemDbSave (UI_GetMemDbDat())) {
return GetLastError();
}
}
#ifdef PRERELEASE
if (g_ConfigOptions.DevPause) {
OkBox (g_ParentWnd, (DWORD) TEXT("Developer Pause"));
}
#endif
}
__finally {
TurnOffWaitCursor();
}
return ERROR_SUCCESS;
}
VOID
Winnt32CleanupWorker (
VOID
)
/*++
Routine Description:
If the user cancels Setup, Winnt32Cleanup is called while WINNT32 is
displaying the wizard page "Setup is undoing changes it made to your
computer." We must stop all processing and clean up.
If WINNT32 completes all of its work, Winnt32Cleanup is called as
the process exists.
We get called even on fresh install, so we must verify we are upgrading.
Arguments:
none
Return Value:
none
--*/
{
HKEY Key;
TCHAR Path[MAX_TCHAR_PATH];
TCHAR src[MAX_PATH];
TCHAR dest[MAX_PATH];
DWORD attribs;
TCHAR drive[] = TEXT(":?");
UINT u;
DEBUGMSG ((DBG_VERBOSE, "Winnt32Cleanup initiated"));
TerminateWinntSifBuilder();
UI_Cleanup();
//
// If the cancel flag pointer is set, we must undo everything!!
//
if (CANCELLED()) {
DeleteDirectoryContents(g_PlugInTempDir);
RemoveDirectory(g_PlugInTempDir);
DeleteDirectoryContents(g_TempDir);
RemoveDirectory(g_TempDir);
//
// Enumerate all drives and try to delete user~tmp.@0?
//
pCleanUpShellFolderTemp();
//
// if some files were already affected, undo those modifications
//
UndoChangedFileProps ();
} else {
//
// Put boot.ini in uninstall image
//
if (g_BootDrivePath && g_TempDir) {
StringCopy (src, g_BootDrivePath);
StringCopy (AppendWack (src), S_BOOTINI);
StringCopy (dest, g_TempDir);
StringCopy (AppendWack (dest), TEXT("uninstall\\boot.ini"));
attribs = GetFileAttributes (src);
SetFileAttributes (src, FILE_ATTRIBUTE_NORMAL);
CopyFile (src, dest, FALSE);
SetFileAttributes (src, attribs);
StringCopy (src, g_BootDrivePath);
StringCopy (AppendWack (src), TEXT("$ldr$"));
StringCopy (dest, g_TempDir);
StringCopy (AppendWack (dest), TEXT("uninstall\\$ldr$"));
attribs = GetFileAttributes (src);
SetFileAttributes (src, FILE_ATTRIBUTE_NORMAL);
CopyFile (src, dest, FALSE);
SetFileAttributes (src, attribs);
if (g_ConfigOptions.EnableBackup) {
//
// Put autochk.exe in c:\$win_nt$.~bt\i386
//
StringCopy (dest, g_BootDrivePath);
StringCat (dest, TEXT("$win_nt$.~bt\\i386\\autochk.exe"));
MakeSurePathExists (dest, FALSE);
for (u = 0 ; u < g_SourceDirectoryCount ; u++) {
StringCopy (src, g_SourceDirectories[u]);
StringCopy (AppendWack (src), "autochk.exe");
if (DoesFileExist (src)) {
break;
}
}
if (u == g_SourceDirectoryCount) {
LOG ((LOG_WARNING, "autochk.exe not found in sources"));
} else {
if (!CopyFile (src, dest, FALSE)) {
LOG ((LOG_WARNING, "autochk.exe could not be copied from %s to %s; not fatal", src, dest));
}
}
}
} else {
MYASSERT (FALSE);
}
//
// Put cleanup code in Run key
//
Key = CreateRegKeyStr (TEXT("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunServicesOnce"));
MYASSERT (Key);
if (Key) {
wsprintf(
Path,
TEXT("\"%s\\migisol.exe\" -%c"),
g_TempDir,
g_ConfigOptions.EnableBackup? 'b': 'c'
);
if(g_ConfigOptions.EnableBackup){
drive[1] = g_BootDrivePath[0];
StringCat(Path, drive);
}
DEBUGMSG ((DBG_VERBOSE, Path));
if(ERROR_SUCCESS != RegSetValueEx (Key, TEXT("WINNT32"), 0, REG_SZ, (PBYTE) Path, SizeOfString (Path))){
DEBUGMSG ((DBG_ERROR, "RegSetValueEx is failed to setup RunServicesOnce with migisol.exe"));
}
CloseRegKey (Key);
}
}
SafeModeShutDown ();
DEBUGMSG ((DBG_VERBOSE, "Winnt32Cleanup completed"));
}
BOOL
Winnt32SetAutoBootWorker (
IN INT DrvLetter
)
/*++
Routine Description:
Winnt32SetAutoBootWorker is called by WINNT32 on both upgrade and fresh install
to modify the boot partition of a NEC PC-9800 Partition Control Table.
Arguments:
none
Return Value:
TRUE if the partition control table was updated, or FALSE if it wasn't,
or an error occurred.
--*/
{
INT Win95BootDrive;
INT rc = TRUE;
if(ISPC98()) {
if (!g_Pc98ModuleHandle) {
LOG ((LOG_ERROR, "PC98: External module not loaded! Can't update auto boot."));
return FALSE;
}
//
// Set the NT 5 drive as "Bootable" and "Auto boot"
//
if (!SetBootFlag (DrvLetter, SB_BOOTABLE | SB_AUTO)) {
LOG ((LOG_ERROR, "PC98: Unable to set target partition as BOOTABLE and AUTO."));
return FALSE;
}
DrvLetter = _totupper (DrvLetter);
Win95BootDrive = _totupper ((UINT) g_BootDriveLetter);
if ( Win95BootDrive != DrvLetter) {
if ( *g_Boot16 == BOOT16_YES ) {
//
// In this case, we do not create "MS-DOS" entry into BOOT.INI.
// Set partition name to Win95 boot drive and NT5 system drive, instead of NT5 Boot menu (boot.ini).
//
rc = SetPtnName (Win95BootDrive, WIN9X_DOS_NAME);
if (!rc) {
LOG ((LOG_ERROR, "PC98: Unable to set partition name into NEC98 boot menu. (WIN9X_DOS_NAME)"));
}
rc = SetPtnName (DrvLetter, WINNT5_NAME);
if (!rc) {
LOG ((LOG_ERROR, "PC98: Unable to set partition name into NEC98 boot menu. (WINNT5_NAME)"));
}
} else {
//
// Set to Win95 drive as "Unbootable"
//
rc = SetBootFlag (Win95BootDrive, SB_UNBOOTABLE);
if (!rc) {
LOG ((LOG_ERROR, "PC98: Unable to set target partition as UNBOOTABLE."));
}
}
}
return rc;
}
return FALSE;
}
BOOL
IsServerInstall (
VOID
)
/*++
Routine Description:
IsServerInstall checks win95upg.inf to see if ProductType is set to zero,
indicating workstation. If this test passes incorrectly, a test in
wizproc.c will catch the upgrade to server.
Arguments:
None.
Return Value:
TRUE if this win95upg.inf is for server.
--*/
{
PCTSTR ArgArray[1];
BOOL b;
if (g_ToolMode) {
return FALSE;
}
//
// Block upgrades of Server
//
b = FALSE;
if (*g_ProductFlavor != PROFESSIONAL_PRODUCTTYPE && *g_ProductFlavor != PERSONAL_PRODUCTTYPE) {
ArgArray[0] = g_Win95Name;
ResourceMessageBox (
g_ParentWnd,
MSG_SERVER_UPGRADE_UNSUPPORTED_INIT,
MB_OK|MB_ICONSTOP|MB_SETFOREGROUND,
ArgArray
);
b = TRUE;
}
return b;
}
Reference in a new issue Copy permalink