You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2328 lines
58 KiB
2328 lines
58 KiB
/*++
|
|
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
dll.c
|
|
|
|
Abstract:
|
|
|
|
Initialization/de-initialization of setupapi.dll
|
|
|
|
Author:
|
|
|
|
Lonny McMichael (lonnym) 10-May-1995
|
|
|
|
Revision History:
|
|
|
|
Jamie Hunter (JamieHun) Apr-25-2002
|
|
Security code review
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
HANDLE MyDllModuleHandle;
|
|
|
|
OSVERSIONINFOEX OSVersionInfo;
|
|
|
|
//
|
|
// TLS Data
|
|
//
|
|
DWORD TlsIndex = (DWORD)(-1); // no data
|
|
PSETUP_TLS pLastTlsAlloc = NULL; // for cleanup
|
|
|
|
|
|
//
|
|
// Static strings we retreive once. Listed in order they are retrieved
|
|
//
|
|
PCTSTR OsLoaderRelativePath = NULL; // (can be NULL)
|
|
PCTSTR OsSystemPartitionRoot = NULL; // eg: \\?\GLOBALROOT\Device\HarddiskVolume1
|
|
PCTSTR ProcessFileName = NULL; // Filename of app calling setupapi
|
|
PCTSTR WindowsDirectory = NULL; // %windir%, GetSystemWindowsDirectory()
|
|
PCTSTR InfDirectory = NULL; // %windir%\INF
|
|
PCTSTR System16Directory = NULL; // %windir%\SYSTEM
|
|
PCTSTR LastGoodDirectory = NULL; // %windir%\LastGood
|
|
PCTSTR SystemDirectory = NULL; // <sys>, %windir%\SYSTEM or %windir%\System32
|
|
PCTSTR WindowsBackupDirectory = NULL; // <sys>\ReinstallBackups
|
|
PCTSTR ConfigDirectory = NULL; // <sys>\CONFIG
|
|
PCTSTR DriversDirectory = NULL; // <sys>\DRIVERS
|
|
PCTSTR SystemSourcePath = NULL; // location system installed from
|
|
PCTSTR ServicePackSourcePath = NULL; // location service pack installed from (can be NULL)
|
|
PCTSTR ServicePackCachePath = NULL; // location service pack files are cached
|
|
PCTSTR DriverCacheSourcePath = NULL; // location of driver cache (can be NULL)
|
|
BOOL GuiSetupInProgress = FALSE; // set if we determine we're in GUI setup
|
|
PCTSTR InfSearchPaths = NULL; // Multi-sz list of fully-qualified directories where INFs are to be searched for.
|
|
#ifndef _WIN64
|
|
BOOL IsWow64 = FALSE; // set if we're running under WOW64
|
|
#endif
|
|
CRITICAL_SECTION InitMutex; // for one-time initializations
|
|
CRITICAL_SECTION ImageHlpMutex; // for dealing with IMAGEHLP library
|
|
CRITICAL_SECTION DelayedComponentMutex; // for any delayed initialization of certain components
|
|
CRITICAL_SECTION PlatformPathOverrideCritSect;
|
|
CRITICAL_SECTION LogUseCountCs;
|
|
CRITICAL_SECTION MruCritSect;
|
|
CRITICAL_SECTION NetConnectionListCritSect;
|
|
BOOL InInitialization = FALSE;
|
|
DWORD DoneInitialization = 0; // bitmask of items we've initialized
|
|
DWORD DoneCleanup = 0; // bitmask of items we've cleaned up
|
|
DWORD DoneComponentInitialize = 0; // bitmask of components we've done delayed initialization
|
|
DWORD FailedComponentInitialize = 0; // bitmask of components we've failed initialization
|
|
HANDLE GlobalNoDriverPromptsEventFlag = NULL; // event that acts as a flag during setup
|
|
INT DoneCriticalSections = 0;
|
|
DWORD Seed;
|
|
|
|
CRITICAL_SECTION * CriticalSectionList[] = {
|
|
&InitMutex,
|
|
&ImageHlpMutex,
|
|
&DelayedComponentMutex,
|
|
&PlatformPathOverrideCritSect,
|
|
&LogUseCountCs,
|
|
&MruCritSect,
|
|
&NetConnectionListCritSect,
|
|
NULL
|
|
};
|
|
|
|
#define DONEINIT_TLS (0x0000001)
|
|
#define DONEINIT_UTILS (0x0000002)
|
|
#define DONEINIT_MEM (0x0000004)
|
|
#define DONEINIT_CTRL (0x0000008)
|
|
#define DONEINIT_FUSION (0x0000010)
|
|
#define DONEINIT_STUBS (0x0000020)
|
|
#define DONEINIT_COMMON (0x0000040)
|
|
#define DONEINIT_DIAMOND (0x0000080)
|
|
#define DONEINIT_LOGGING (0x0000100)
|
|
#define DONEINIT_CFGMGR32 (0x0000200)
|
|
#define DONEINIT_COMPLETE (0x8000000)
|
|
|
|
|
|
|
|
//
|
|
// various control flags
|
|
//
|
|
DWORD GlobalSetupFlags = 0;
|
|
DWORD GlobalSetupFlagsOverride = PSPGF_MINIMAL_EMBEDDED | PSPGF_NO_SCE_EMBEDDED; // flags that cannot be modified
|
|
|
|
//
|
|
// Declare a (non-CONST) array of strings that specifies what lines to look for
|
|
// in an INF's [ControlFlags] section when determining whether a particular device
|
|
// ID should be excluded. These lines are of the form "ExcludeFromSelect[.<suffix>]",
|
|
// where <suffix> is determined and filled in during process attach as an optimization.
|
|
//
|
|
// The max string length (including NULL) is 32, and there can be a maximum of 3
|
|
// such strings. E.g.: ExcludeFromSelect, ExcludeFromSelect.NT, ExcludeFromSelect.NTAmd64
|
|
//
|
|
// WARNING!! Be very careful when mucking with the order/number of these entries. Check
|
|
// the assumptions made in devdrv.c!pSetupShouldDevBeExcluded.
|
|
//
|
|
TCHAR pszExcludeFromSelectList[3][32] = { INFSTR_KEY_EXCLUDEFROMSELECT,
|
|
INFSTR_KEY_EXCLUDEFROMSELECT,
|
|
INFSTR_KEY_EXCLUDEFROMSELECT
|
|
};
|
|
|
|
DWORD ExcludeFromSelectListUb; // contains the number of strings in the above list (2 or 3).
|
|
|
|
|
|
#ifndef _WIN64
|
|
BOOL
|
|
GetIsWow64 (
|
|
VOID
|
|
);
|
|
#endif
|
|
|
|
BOOL
|
|
CommonProcessAttach(
|
|
IN BOOL Attach
|
|
);
|
|
|
|
PCTSTR
|
|
GetDriverCacheSourcePath(
|
|
VOID
|
|
);
|
|
|
|
PCTSTR
|
|
pSetupGetOsLoaderPath(
|
|
VOID
|
|
);
|
|
|
|
PCTSTR
|
|
pSetupGetSystemPartitionRoot(
|
|
VOID
|
|
);
|
|
|
|
PCTSTR
|
|
pSetupGetProcessPath(
|
|
VOID
|
|
);
|
|
|
|
BOOL
|
|
pGetGuiSetupInProgress(
|
|
VOID
|
|
);
|
|
|
|
|
|
BOOL
|
|
CfgmgrEntry(
|
|
PVOID hModule,
|
|
ULONG Reason,
|
|
PCONTEXT pContext
|
|
);
|
|
|
|
|
|
BOOL
|
|
ThreadTlsInitialize(
|
|
IN BOOL Init
|
|
);
|
|
|
|
VOID
|
|
ThreadTlsCleanup(
|
|
);
|
|
|
|
BOOL
|
|
IsNoDriverPrompts(
|
|
VOID
|
|
);
|
|
|
|
DWORD
|
|
GetEmbeddedFlags(
|
|
VOID
|
|
);
|
|
|
|
DWORD
|
|
GetSeed(
|
|
VOID
|
|
);
|
|
|
|
|
|
BOOL
|
|
ProcessAttach(
|
|
IN HANDLE DllHandle,
|
|
IN DWORD Reason,
|
|
IN LPVOID Reserved
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Handles DLL_PROCESS_ATTACH in a way that can be unwound
|
|
|
|
Arguments:
|
|
|
|
Reserved = 'Reserved' value passed into DllMain
|
|
|
|
Return Value:
|
|
|
|
TRUE if processed initialized
|
|
FALSE if partially/not initialized
|
|
|
|
--*/
|
|
{
|
|
BOOL b = FALSE;
|
|
|
|
if(DoneCleanup) {
|
|
//
|
|
// if we get here, this means someone lied to us
|
|
//
|
|
MYASSERT(!DoneCleanup);
|
|
DoneInitialization &= ~DoneCleanup;
|
|
DoneCleanup = 0;
|
|
}
|
|
//
|
|
// nothing should already be initialized
|
|
//
|
|
MYASSERT(!DoneInitialization);
|
|
|
|
try {
|
|
MyDllModuleHandle = DllHandle;
|
|
|
|
//
|
|
// initialize TLS before anything else - hence why we use LocalAlloc
|
|
//
|
|
TlsIndex = TlsAlloc();
|
|
if (TlsIndex!=(DWORD)(-1)) {
|
|
DoneInitialization |= DONEINIT_TLS;
|
|
} else {
|
|
leave;
|
|
}
|
|
|
|
//
|
|
// always do pSetupInitializeUtils and MemoryInitializeEx first
|
|
// (pSetupInitializeUtils sets up memory functions)
|
|
//
|
|
if(pSetupInitializeUtils()) {
|
|
DoneInitialization |= DONEINIT_UTILS;
|
|
} else {
|
|
leave;
|
|
}
|
|
if(MemoryInitializeEx(TRUE)) {
|
|
DoneInitialization |= DONEINIT_MEM;
|
|
} else {
|
|
leave;
|
|
}
|
|
if(spFusionInitialize()) {
|
|
DoneInitialization |= DONEINIT_FUSION;
|
|
}
|
|
//
|
|
// Dynamically load proc addresses of NT-specific APIs
|
|
// must be before CommonProcessAttach etc
|
|
// however memory must be initialized
|
|
//
|
|
InitializeStubFnPtrs();
|
|
DoneInitialization |= DONEINIT_STUBS;
|
|
//
|
|
// most of the remaining initialization
|
|
//
|
|
if(CommonProcessAttach(TRUE)) {
|
|
DoneInitialization |= DONEINIT_COMMON;
|
|
} else {
|
|
leave;
|
|
}
|
|
if(DiamondProcessAttach(TRUE)) {
|
|
DoneInitialization |= DONEINIT_DIAMOND;
|
|
} else {
|
|
leave;
|
|
}
|
|
if(InitializeContextLogging(TRUE)) {
|
|
DoneInitialization |= DONEINIT_LOGGING;
|
|
} else {
|
|
leave;
|
|
}
|
|
|
|
//
|
|
// Since we've incorporated cfgmgr32 into setupapi, we need
|
|
// to make sure it gets initialized just like it did when it was
|
|
// its own DLL. - must do AFTER everything else
|
|
//
|
|
if(CfgmgrEntry(DllHandle, Reason, Reserved)) {
|
|
DoneInitialization |= DONEINIT_CFGMGR32;
|
|
}
|
|
DoneInitialization |= DONEINIT_COMPLETE;
|
|
b = TRUE;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
void
|
|
DestroySetupTlsData(
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Destroy all TLS data from every thread
|
|
calling any cleanup routines as required
|
|
|
|
Arguments:
|
|
|
|
NONE
|
|
|
|
Return Value:
|
|
|
|
NONE
|
|
|
|
--*/
|
|
{
|
|
PSETUP_TLS pTLS;
|
|
|
|
if(pLastTlsAlloc) {
|
|
pLastTlsAlloc->Prev->Next = NULL;
|
|
while(pLastTlsAlloc) {
|
|
pTLS = pLastTlsAlloc;
|
|
pLastTlsAlloc = pTLS->Next;
|
|
TlsSetValue(TlsIndex,pTLS); // switch specific data into this thread
|
|
ThreadTlsCleanup();
|
|
LocalFree(pTLS);
|
|
}
|
|
}
|
|
TlsSetValue(TlsIndex,NULL); // don't leave invalid pointer hanging around
|
|
}
|
|
|
|
void
|
|
ProcessDetach(
|
|
IN HANDLE DllHandle,
|
|
IN DWORD Reason,
|
|
IN LPVOID Reserved
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Handles DLL_PROCESS_DETACH
|
|
|
|
Arguments:
|
|
|
|
Reserved = 'Reserved' value passed into DllMain
|
|
Which is actually TRUE for Process Exit, FALSE otherwise
|
|
|
|
Return Value:
|
|
|
|
None
|
|
--*/
|
|
{
|
|
DWORD ToCleanup = DoneInitialization & ~ DoneCleanup;
|
|
if(!ToCleanup) {
|
|
//
|
|
// nothing to cleanup
|
|
//
|
|
return;
|
|
}
|
|
try {
|
|
if (ToCleanup & DONEINIT_COMPLETE) {
|
|
DoneCleanup |= DONEINIT_COMPLETE;
|
|
}
|
|
|
|
if(DoneInitialization & DONEINIT_TLS) {
|
|
//
|
|
// cleanup all remaining Tls data
|
|
//
|
|
if(!Reserved) {
|
|
//
|
|
// only do this for FreeLibrary/ failed LoadLibrary
|
|
//
|
|
DestroySetupTlsData();
|
|
}
|
|
}
|
|
if(ToCleanup & DONEINIT_TLS) {
|
|
//
|
|
// destroy our allocated TLS index
|
|
// do this now so that we don't try allocating
|
|
// TLS storage during this cleanup
|
|
//
|
|
TlsFree(TlsIndex);
|
|
TlsIndex = (DWORD)(-1);
|
|
DoneCleanup |= DONEINIT_TLS;
|
|
}
|
|
|
|
//
|
|
// do things generally in reverse order of ProcessAttach
|
|
//
|
|
|
|
// Since we've incorporated cfgmgr32 into setupapi, we need
|
|
// to make sure it gets uninitialized just like it did when it was
|
|
// its own DLL. - must do BEFORE anything else
|
|
//
|
|
if(ToCleanup & DONEINIT_CFGMGR32) {
|
|
CfgmgrEntry(DllHandle, Reason, Reserved);
|
|
DoneCleanup |= DONEINIT_CFGMGR32;
|
|
}
|
|
|
|
if(ToCleanup & DONEINIT_DIAMOND) {
|
|
DiamondProcessAttach(FALSE);
|
|
DoneCleanup |= DONEINIT_DIAMOND;
|
|
}
|
|
|
|
#if 0 // see ComponentCleanup at end of file
|
|
ComponentCleanup(DoneComponentInitialize);
|
|
#endif
|
|
if(ToCleanup & DONEINIT_FUSION) {
|
|
//
|
|
// Fusion cleanup
|
|
// only do full if this is FreeLibrary (or failed attach)
|
|
//
|
|
spFusionUninitialize((Reserved == NULL) ? TRUE : FALSE);
|
|
DoneCleanup |= DONEINIT_FUSION;
|
|
}
|
|
|
|
if(ToCleanup & DONEINIT_COMMON) {
|
|
//
|
|
// Most of remaining cleanup
|
|
//
|
|
CommonProcessAttach(FALSE);
|
|
DoneCleanup |= DONEINIT_COMMON;
|
|
}
|
|
if(ToCleanup & DONEINIT_STUBS) {
|
|
//
|
|
// Clean up stub functions
|
|
//
|
|
CleanUpStubFns();
|
|
DoneCleanup |= DONEINIT_STUBS;
|
|
}
|
|
if(ToCleanup & DONEINIT_LOGGING) {
|
|
//
|
|
// Clean up context logging
|
|
//
|
|
InitializeContextLogging(FALSE);
|
|
DoneCleanup |= DONEINIT_LOGGING;
|
|
}
|
|
//
|
|
// *THESE MUST ALWAYS BE* very last things, in this order
|
|
//
|
|
if(ToCleanup & DONEINIT_MEM) {
|
|
//
|
|
// Clean up context logging
|
|
//
|
|
MemoryInitializeEx(FALSE);
|
|
DoneCleanup |= DONEINIT_MEM;
|
|
}
|
|
if(ToCleanup & DONEINIT_UTILS) {
|
|
//
|
|
// Clean up context logging
|
|
//
|
|
pSetupUninitializeUtils();
|
|
DoneCleanup |= DONEINIT_UTILS;
|
|
}
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
}
|
|
}
|
|
|
|
//
|
|
// Called by CRT when _DllMainCRTStartup is the DLL entry point
|
|
//
|
|
BOOL
|
|
WINAPI
|
|
DllMain(
|
|
IN HANDLE DllHandle,
|
|
IN DWORD Reason,
|
|
IN LPVOID Reserved
|
|
)
|
|
{
|
|
BOOL b;
|
|
|
|
InInitialization = TRUE;
|
|
|
|
b = TRUE;
|
|
|
|
switch(Reason) {
|
|
|
|
case DLL_PROCESS_ATTACH:
|
|
b = ProcessAttach(DllHandle,Reason,Reserved);
|
|
if(!b) {
|
|
ProcessDetach(DllHandle,DLL_THREAD_DETACH,NULL);
|
|
}
|
|
break;
|
|
|
|
case DLL_THREAD_ATTACH:
|
|
//
|
|
// don't do anything here
|
|
// any TLS must be done on demand
|
|
// via SetupGetTlsData
|
|
//
|
|
break;
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
//
|
|
// any TLS cleanup must be done in ThreadTlsCleanup
|
|
//
|
|
ProcessDetach(DllHandle,Reason,Reserved);
|
|
break;
|
|
|
|
case DLL_THREAD_DETACH:
|
|
ThreadTlsInitialize(FALSE);
|
|
break;
|
|
}
|
|
|
|
InInitialization = FALSE;
|
|
return(b);
|
|
}
|
|
|
|
PSETUP_TLS
|
|
SetupGetTlsData(
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called to obtain a pointer to TLS data
|
|
|
|
Arguments:
|
|
|
|
NONE
|
|
|
|
Return Value:
|
|
|
|
Pointer to TLS data, or NULL
|
|
|
|
--*/
|
|
{
|
|
PSETUP_TLS pTLS;
|
|
|
|
if (TlsIndex==(DWORD)(-1)) {
|
|
return NULL;
|
|
}
|
|
pTLS = (PSETUP_TLS)TlsGetValue(TlsIndex);
|
|
if (!pTLS) {
|
|
ThreadTlsInitialize(TRUE);
|
|
pTLS = (PSETUP_TLS)TlsGetValue(TlsIndex);
|
|
}
|
|
return pTLS;
|
|
}
|
|
|
|
VOID
|
|
ThreadTlsCleanup(
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called to uninitialize some pTLS data
|
|
might be a different thread to initialize
|
|
but SetupAPI TLS data will have been switched in
|
|
|
|
Arguments:
|
|
|
|
pTLS - data to cleanup
|
|
|
|
Return Value:
|
|
|
|
NONE.
|
|
|
|
--*/
|
|
{
|
|
DiamondTlsInit(FALSE);
|
|
ContextLoggingTlsInit(FALSE);
|
|
}
|
|
|
|
BOOL
|
|
ThreadTlsUnlink(
|
|
IN PSETUP_TLS pTLS
|
|
)
|
|
{
|
|
BOOL b;
|
|
try {
|
|
EnterCriticalSection(&InitMutex);
|
|
if(pTLS->Next == pTLS->Prev) {
|
|
pLastTlsAlloc = NULL;
|
|
} else {
|
|
pTLS->Prev->Next = pTLS->Next;
|
|
pTLS->Next->Prev = pTLS->Prev;
|
|
pLastTlsAlloc = pTLS->Prev; // anything but pTLS
|
|
}
|
|
LeaveCriticalSection(&InitMutex);
|
|
b = TRUE;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
b = FALSE;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
PSETUP_TLS
|
|
ThreadTlsCreate(
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called to create pTLS data for this thread
|
|
|
|
Arguments:
|
|
|
|
NONE
|
|
|
|
Return Value:
|
|
|
|
per-thread data, or NULL on failure
|
|
|
|
--*/
|
|
{
|
|
BOOL b;
|
|
PSETUP_TLS pTLS;
|
|
if (TlsIndex==(DWORD)(-1)) {
|
|
return NULL;
|
|
}
|
|
pTLS = (PSETUP_TLS)LocalAlloc(LMEM_ZEROINIT,sizeof(SETUP_TLS));
|
|
if(!pTLS) {
|
|
return NULL;
|
|
}
|
|
b = TlsSetValue(TlsIndex,pTLS);
|
|
if(!b) {
|
|
LocalFree(pTLS);
|
|
return NULL;
|
|
}
|
|
try {
|
|
EnterCriticalSection(&InitMutex);
|
|
if(pLastTlsAlloc) {
|
|
pTLS->Prev = pLastTlsAlloc;
|
|
pTLS->Next = pTLS->Prev->Next;
|
|
pTLS->Prev->Next = pTLS;
|
|
pTLS->Next->Prev = pTLS;
|
|
} else {
|
|
pTLS->Next = pTLS;
|
|
pTLS->Prev = pTLS;
|
|
}
|
|
pLastTlsAlloc = pTLS;
|
|
LeaveCriticalSection(&InitMutex);
|
|
b = TRUE;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
b = FALSE;
|
|
}
|
|
if(!b) {
|
|
LocalFree(pTLS);
|
|
TlsSetValue(TlsIndex,NULL);
|
|
return NULL;
|
|
}
|
|
//
|
|
// TLS data initialized, now specific Init routines
|
|
//
|
|
b = DiamondTlsInit(TRUE);
|
|
if(b) {
|
|
b = ContextLoggingTlsInit(TRUE);
|
|
if(b) {
|
|
//
|
|
// all done ok
|
|
//
|
|
return pTLS;
|
|
}
|
|
//
|
|
// cleanup DiamondTlsInit
|
|
//
|
|
DiamondTlsInit(FALSE);
|
|
}
|
|
//
|
|
// cleanup memory
|
|
//
|
|
TlsSetValue(TlsIndex,NULL);
|
|
if(ThreadTlsUnlink(pTLS)) {
|
|
LocalFree(pTLS);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
BOOL
|
|
ThreadTlsInitialize(
|
|
IN BOOL Init
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called with TRUE to initialize TLS, if FALSE, to uninitialize
|
|
|
|
Arguments:
|
|
|
|
Init - indicates if we are to initialize vs uninitialize
|
|
|
|
Return Value:
|
|
|
|
NONE.
|
|
|
|
--*/
|
|
{
|
|
BOOL b = FALSE;
|
|
PSETUP_TLS pTLS = NULL;
|
|
if (TlsIndex!=(DWORD)(-1)) {
|
|
if (Init) {
|
|
pTLS = ThreadTlsCreate();
|
|
b = pTLS ? TRUE : FALSE;
|
|
} else {
|
|
pTLS = (PSETUP_TLS)TlsGetValue(TlsIndex);
|
|
if(pTLS) {
|
|
ThreadTlsCleanup();
|
|
TlsSetValue(TlsIndex,NULL);
|
|
if(ThreadTlsUnlink(pTLS)) {
|
|
LocalFree(pTLS);
|
|
}
|
|
}
|
|
b = TRUE;
|
|
}
|
|
}
|
|
return b;
|
|
}
|
|
|
|
BOOL
|
|
IsInteractiveWindowStation(
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Determine if we are running on an interactive station vs non-interactive station (i.e., service)
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
True if interactive
|
|
|
|
--*/
|
|
{
|
|
HWINSTA winsta;
|
|
USEROBJECTFLAGS flags;
|
|
BOOL interactive = TRUE; // true unless we determine otherwise
|
|
DWORD lenNeeded;
|
|
|
|
winsta = GetProcessWindowStation();
|
|
if(!winsta) {
|
|
return interactive;
|
|
}
|
|
if(GetUserObjectInformation(winsta,UOI_FLAGS,&flags,sizeof(flags),&lenNeeded)) {
|
|
interactive = (flags.dwFlags & WSF_VISIBLE) ? TRUE : FALSE;
|
|
}
|
|
//
|
|
// don't call CLoseWindowStation
|
|
//
|
|
return interactive;
|
|
}
|
|
|
|
BOOL
|
|
CommonProcessAttach(
|
|
IN BOOL Attach
|
|
)
|
|
{
|
|
BOOL b;
|
|
TCHAR Buffer[MAX_PATH+32];
|
|
PTCHAR p;
|
|
UINT u;
|
|
|
|
b = !Attach;
|
|
|
|
if(Attach) {
|
|
|
|
try {
|
|
|
|
//
|
|
// (remaining) critical sections
|
|
//
|
|
while(CriticalSectionList[DoneCriticalSections]) {
|
|
InitializeCriticalSection(CriticalSectionList[DoneCriticalSections]);
|
|
//
|
|
// increment only if we get here (exception can occur)
|
|
//
|
|
DoneCriticalSections++;
|
|
}
|
|
#ifndef _WIN64
|
|
IsWow64 = GetIsWow64();
|
|
#endif
|
|
//
|
|
// flag indicating we're running in context of GUI setup
|
|
//
|
|
GuiSetupInProgress = pGetGuiSetupInProgress();
|
|
//
|
|
// determine if we're interactive or not
|
|
//
|
|
if(!IsInteractiveWindowStation()) {
|
|
GlobalSetupFlagsOverride |= PSPGF_NONINTERACTIVE; // don't allow this to be changed
|
|
GlobalSetupFlags |= PSPGF_NONINTERACTIVE; // actual value
|
|
}
|
|
if(IsNoDriverPrompts()) {
|
|
GlobalSetupFlagsOverride |= PSPGF_UNATTENDED_SETUP; // don't allow this to be changed
|
|
GlobalSetupFlags |= PSPGF_UNATTENDED_SETUP; // actual value
|
|
}
|
|
|
|
GlobalSetupFlags |= GetEmbeddedFlags();
|
|
|
|
Seed = GetSeed();
|
|
|
|
pSetupInitNetConnectionList(TRUE);
|
|
pSetupInitPlatformPathOverrideSupport(TRUE);
|
|
OsLoaderRelativePath = pSetupGetOsLoaderPath(); // ok to fail
|
|
OsSystemPartitionRoot = pSetupGetSystemPartitionRoot(); // ok to fail
|
|
|
|
//
|
|
// Fill in system and windows directories.
|
|
//
|
|
if ((ProcessFileName = pSetupGetProcessPath()) == NULL) {
|
|
goto cleanAll;
|
|
}
|
|
|
|
//
|
|
// determine %windir%
|
|
//
|
|
if(((u = GetSystemWindowsDirectory(Buffer,MAX_PATH)) == 0) || u>MAX_PATH) {
|
|
goto cleanAll;
|
|
}
|
|
p = Buffer + u; // offset past directory to do all the sub-directories
|
|
|
|
//
|
|
// %windir% ==> WindowsDirectory
|
|
//
|
|
if((WindowsDirectory = DuplicateString(Buffer)) == NULL) {
|
|
goto cleanAll;
|
|
}
|
|
|
|
//
|
|
// %windir%\INF ==> InfDirectory
|
|
//
|
|
*p = 0;
|
|
if(!pSetupConcatenatePaths(Buffer,TEXT("INF"),MAX_PATH,NULL)
|
|
|| ((InfDirectory = DuplicateString(Buffer)) == NULL)) {
|
|
goto cleanAll;
|
|
}
|
|
|
|
//
|
|
// %windir%\SYSTEM ==> System16Directory
|
|
//
|
|
*p = 0;
|
|
if(!pSetupConcatenatePaths(Buffer,TEXT("SYSTEM"),MAX_PATH,NULL)
|
|
|| ((System16Directory = DuplicateString(Buffer))==NULL)) {
|
|
goto cleanAll;
|
|
}
|
|
|
|
//
|
|
// %windir%\LastGood ==> LastGoodDirectory
|
|
//
|
|
*p = 0;
|
|
if(!pSetupConcatenatePaths(Buffer,SP_LASTGOOD_NAME,MAX_PATH,NULL)
|
|
|| ((LastGoodDirectory = DuplicateString(Buffer))==NULL)) {
|
|
goto cleanAll;
|
|
}
|
|
|
|
//
|
|
// determine system directory
|
|
//
|
|
if(((u = GetSystemDirectory(Buffer,MAX_PATH)) == 0) || u>MAX_PATH) {
|
|
goto cleanAll;
|
|
}
|
|
p = Buffer + u; // offset past directory to do all the sub-directories
|
|
|
|
//
|
|
// <sys> ==> SystemDirectory (%windir%\System or %windir%\System32)
|
|
//
|
|
if((SystemDirectory = DuplicateString(Buffer)) == NULL) {
|
|
goto cleanAll;
|
|
}
|
|
|
|
//
|
|
// <sys>\ReinstallBackups ==> WindowsBackupDirectory
|
|
//
|
|
*p = 0;
|
|
if(!pSetupConcatenatePaths(Buffer,TEXT("ReinstallBackups"),MAX_PATH,NULL)
|
|
|| ((WindowsBackupDirectory = DuplicateString(Buffer))==NULL)) {
|
|
goto cleanAll;
|
|
}
|
|
|
|
//
|
|
// <sys>\CONFIG ==> ConfigDirectory
|
|
//
|
|
*p = 0;
|
|
if(!pSetupConcatenatePaths(Buffer,TEXT("CONFIG"),MAX_PATH,NULL)
|
|
|| ((ConfigDirectory = DuplicateString(Buffer))==NULL)) {
|
|
goto cleanAll;
|
|
}
|
|
|
|
//
|
|
// <sys>\DRIVERS ==> DriversDirectory
|
|
//
|
|
*p = 0;
|
|
if(!pSetupConcatenatePaths(Buffer,TEXT("DRIVERS"),MAX_PATH,NULL)
|
|
|| ((DriversDirectory = DuplicateString(Buffer))==NULL)) {
|
|
goto cleanAll;
|
|
}
|
|
|
|
//
|
|
// location system installed from
|
|
//
|
|
if((SystemSourcePath = GetSystemSourcePath())==NULL) {
|
|
goto cleanAll;
|
|
}
|
|
|
|
//
|
|
// location service pack installed from (may be NULL)
|
|
//
|
|
ServicePackSourcePath = GetServicePackSourcePath();
|
|
//
|
|
// location of local disk cached files (may be NULL)
|
|
// files here have precedence over everything else
|
|
//
|
|
ServicePackCachePath = GetServicePackCachePath();
|
|
//
|
|
// location of driver cache (may be NULL)
|
|
//
|
|
DriverCacheSourcePath = GetDriverCacheSourcePath();
|
|
|
|
//
|
|
// determine driver search path
|
|
//
|
|
if((InfSearchPaths = AllocAndReturnDriverSearchList(INFINFO_INF_PATH_LIST_SEARCH))==NULL) {
|
|
goto cleanAll;
|
|
}
|
|
|
|
//
|
|
// note that InitMiniIconList, InitDrvSearchInProgressList, and
|
|
// InitDrvSignPolicyList need to be explicitly cleaned up on failure
|
|
//
|
|
|
|
//
|
|
// initialize mini icons
|
|
//
|
|
if(!InitMiniIconList()) {
|
|
goto cleanAll;
|
|
}
|
|
|
|
//
|
|
// allows aborting of search
|
|
//
|
|
if(!InitDrvSearchInProgressList()) {
|
|
DestroyMiniIconList();
|
|
goto cleanAll;
|
|
}
|
|
|
|
//
|
|
// global list of device setup classes subject to driver signing policy
|
|
//
|
|
if(!InitDrvSignPolicyList()) {
|
|
DestroyMiniIconList();
|
|
DestroyDrvSearchInProgressList();
|
|
goto cleanAll;
|
|
}
|
|
|
|
//
|
|
// common version initialization
|
|
//
|
|
ZeroMemory(&OSVersionInfo,sizeof(OSVersionInfo));
|
|
OSVersionInfo.dwOSVersionInfoSize = sizeof(OSVersionInfo);
|
|
if((!GetVersionEx((LPOSVERSIONINFO)&OSVersionInfo))
|
|
|| (OSVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT)) {
|
|
//
|
|
// should never get here
|
|
//
|
|
MYASSERT(FALSE);
|
|
DestroyMiniIconList();
|
|
DestroyDrvSearchInProgressList();
|
|
DestroyDrvSignPolicyList();
|
|
goto cleanAll;
|
|
}
|
|
|
|
//
|
|
// Fill in our ExcludeFromSelect string list which
|
|
// we pre-compute as an optimization.
|
|
//
|
|
if(OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) {
|
|
lstrcat(pszExcludeFromSelectList[1],
|
|
pszNtSuffix
|
|
);
|
|
lstrcat(pszExcludeFromSelectList[2],
|
|
pszNtPlatformSuffix
|
|
);
|
|
ExcludeFromSelectListUb = 3;
|
|
} else {
|
|
lstrcat(pszExcludeFromSelectList[1],
|
|
pszWinSuffix
|
|
);
|
|
ExcludeFromSelectListUb = 2;
|
|
}
|
|
//
|
|
// Now lower-case all the strings in this list, so that it
|
|
// doesn't have to be done at each string table lookup.
|
|
//
|
|
for(u = 0; u < ExcludeFromSelectListUb; u++) {
|
|
CharLower(pszExcludeFromSelectList[u]);
|
|
}
|
|
|
|
b = TRUE;
|
|
cleanAll: ;
|
|
} except (EXCEPTION_EXECUTE_HANDLER) {
|
|
//
|
|
// Unexpected exception occurred, drop into cleanup
|
|
//
|
|
}
|
|
if(b) {
|
|
//
|
|
// succeeded
|
|
//
|
|
goto Done;
|
|
}
|
|
} else {
|
|
//
|
|
// Detach
|
|
//
|
|
DestroyMiniIconList();
|
|
DestroyDrvSearchInProgressList();
|
|
DestroyDrvSignPolicyList();
|
|
if(GlobalNoDriverPromptsEventFlag) {
|
|
CloseHandle(GlobalNoDriverPromptsEventFlag);
|
|
}
|
|
}
|
|
while(DoneCriticalSections--) {
|
|
DeleteCriticalSection(CriticalSectionList[DoneCriticalSections]);
|
|
}
|
|
if (InfSearchPaths) {
|
|
MyFree(InfSearchPaths);
|
|
InfSearchPaths = NULL;
|
|
}
|
|
if (DriverCacheSourcePath) {
|
|
MyFree(DriverCacheSourcePath);
|
|
DriverCacheSourcePath = NULL;
|
|
}
|
|
if (ServicePackSourcePath) {
|
|
MyFree(ServicePackSourcePath);
|
|
ServicePackSourcePath = NULL;
|
|
}
|
|
if (ServicePackCachePath) {
|
|
MyFree(ServicePackCachePath);
|
|
ServicePackCachePath = NULL;
|
|
}
|
|
if (SystemSourcePath) {
|
|
MyFree(SystemSourcePath);
|
|
SystemSourcePath = NULL;
|
|
}
|
|
if (SystemDirectory) {
|
|
MyFree(SystemDirectory);
|
|
SystemDirectory = NULL;
|
|
|
|
if (WindowsBackupDirectory) {
|
|
MyFree(WindowsBackupDirectory);
|
|
WindowsBackupDirectory = NULL;
|
|
}
|
|
if (ConfigDirectory) {
|
|
MyFree(ConfigDirectory);
|
|
ConfigDirectory = NULL;
|
|
}
|
|
if (DriversDirectory) {
|
|
MyFree(DriversDirectory);
|
|
DriversDirectory = NULL;
|
|
}
|
|
}
|
|
if (WindowsDirectory) {
|
|
MyFree(WindowsDirectory);
|
|
WindowsDirectory = NULL;
|
|
|
|
if (InfDirectory) {
|
|
MyFree(InfDirectory);
|
|
InfDirectory = NULL;
|
|
}
|
|
if (System16Directory) {
|
|
MyFree(System16Directory);
|
|
System16Directory = NULL;
|
|
}
|
|
if (LastGoodDirectory) {
|
|
MyFree(LastGoodDirectory);
|
|
} LastGoodDirectory = NULL;
|
|
}
|
|
if (ProcessFileName) {
|
|
MyFree(ProcessFileName);
|
|
ProcessFileName = NULL;
|
|
}
|
|
if (OsLoaderRelativePath) {
|
|
MyFree(OsLoaderRelativePath);
|
|
OsLoaderRelativePath = NULL;
|
|
}
|
|
if (OsSystemPartitionRoot) {
|
|
MyFree(OsSystemPartitionRoot);
|
|
OsSystemPartitionRoot = NULL;
|
|
}
|
|
pSetupInitNetConnectionList(FALSE);
|
|
pSetupInitPlatformPathOverrideSupport(FALSE);
|
|
Done:
|
|
return(b);
|
|
}
|
|
|
|
#if MEM_DBG
|
|
#undef GetSystemSourcePath // defined again below
|
|
#endif
|
|
|
|
PCTSTR
|
|
GetSystemSourcePath(
|
|
TRACK_ARG_DECLARE
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine returns a newly-allocated buffer containing the source path from
|
|
which the system was installed, or "A:\" if that value cannot be determined.
|
|
This value is retrieved from the following registry location:
|
|
|
|
\HKLM\Software\Microsoft\Windows\CurrentVersion\Setup
|
|
|
|
SourcePath : REG_SZ : "\\ntamd64\1300fre.wks" // for example.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is a pointer to the path string.
|
|
This memory must be freed via MyFree().
|
|
|
|
If the function fails due to out-of-memory, the return value is NULL.
|
|
|
|
--*/
|
|
{
|
|
HKEY hKey;
|
|
TCHAR CharBuffer[CSTRLEN(REGSTR_PATH_SETUP) + SIZECHARS(REGSTR_KEY_SETUP)];
|
|
DWORD Err, DataType, DataSize;
|
|
PTSTR Value;
|
|
PCTSTR ReturnVal;
|
|
|
|
TRACK_PUSH
|
|
|
|
CopyMemory(CharBuffer,
|
|
pszPathSetup,
|
|
sizeof(pszPathSetup) - sizeof(TCHAR)
|
|
);
|
|
CopyMemory((PBYTE)CharBuffer + (sizeof(pszPathSetup) - sizeof(TCHAR)),
|
|
pszKeySetup,
|
|
sizeof(pszKeySetup)
|
|
);
|
|
|
|
if((Err = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
CharBuffer,
|
|
0,
|
|
KEY_READ,
|
|
&hKey)) == ERROR_SUCCESS) {
|
|
//
|
|
// Attempt to read the the "SourcePath" value.
|
|
//
|
|
Err = QueryRegistryValue(hKey, pszSourcePath, &Value, &DataType, &DataSize);
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
ReturnVal = NULL;
|
|
|
|
if(Err == NO_ERROR) {
|
|
|
|
ReturnVal = Value;
|
|
|
|
}
|
|
|
|
if(!ReturnVal && Err != ERROR_NOT_ENOUGH_MEMORY) {
|
|
//
|
|
// We failed to retrieve the SourcePath value, and it wasn't due to an out-of-memory
|
|
// condition. Fall back to our default of "A:\".
|
|
//
|
|
ReturnVal = DuplicateString(pszOemInfDefaultPath);
|
|
}
|
|
|
|
TRACK_POP
|
|
|
|
return ReturnVal;
|
|
}
|
|
|
|
#if MEM_DBG
|
|
#define GetSystemSourcePath() GetSystemSourcePath(TRACK_ARG_CALL)
|
|
#endif
|
|
|
|
|
|
|
|
#if MEM_DBG
|
|
#undef GetServicePackSourcePath // defined again below
|
|
#undef GetServicePackCachePath // defined again below
|
|
#endif
|
|
|
|
PCTSTR
|
|
GetServicePackSourcePath(
|
|
TRACK_ARG_DECLARE
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine returns a newly-allocated buffer containing the service pack source path
|
|
where we should look for service pack source files, or "CDM" if that value cannot be determined.
|
|
This value is retrieved from the following registry location:
|
|
|
|
\HKLM\Software\Microsoft\Windows\CurrentVersion\Setup
|
|
|
|
ServicePackSourcePath : REG_SZ : "\\ntamd64\1300fre.wks" // for example.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is a pointer to the path string.
|
|
This memory must be freed via MyFree().
|
|
|
|
If the function fails due to out-of-memory, the return value is NULL.
|
|
|
|
--*/
|
|
{
|
|
HKEY hKey;
|
|
TCHAR CharBuffer[CSTRLEN(REGSTR_PATH_SETUP) + SIZECHARS(REGSTR_KEY_SETUP)];
|
|
DWORD Err, DataType, DataSize;
|
|
PTSTR Value;
|
|
PCTSTR ReturnStr = NULL;
|
|
|
|
TRACK_PUSH
|
|
|
|
CopyMemory(CharBuffer,
|
|
pszPathSetup,
|
|
sizeof(pszPathSetup) - sizeof(TCHAR)
|
|
);
|
|
CopyMemory((PBYTE)CharBuffer + (sizeof(pszPathSetup) - sizeof(TCHAR)),
|
|
pszKeySetup,
|
|
sizeof(pszKeySetup)
|
|
);
|
|
|
|
if((Err = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
CharBuffer,
|
|
0,
|
|
KEY_READ,
|
|
&hKey)) == ERROR_SUCCESS) {
|
|
//
|
|
// Attempt to read the the "ServicePackSourcePath" value.
|
|
//
|
|
Err = QueryRegistryValue(hKey, pszSvcPackPath, &Value, &DataType, &DataSize);
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
if(Err == NO_ERROR) {
|
|
|
|
ReturnStr = Value;
|
|
|
|
}
|
|
|
|
if(!ReturnStr && Err != ERROR_NOT_ENOUGH_MEMORY) {
|
|
//
|
|
// We failed to retrieve the ServicePackSourcePath value, and it wasn't due to an out-of-memory
|
|
// condition. Fall back to the SourcePath value in the registry
|
|
//
|
|
|
|
ReturnStr = GetSystemSourcePath();
|
|
}
|
|
|
|
TRACK_POP
|
|
|
|
return ReturnStr;
|
|
}
|
|
|
|
PCTSTR
|
|
GetServicePackCachePath(
|
|
TRACK_ARG_DECLARE
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine returns a newly-allocated buffer containing the service pack cache path
|
|
where we should look for files ahead of anything else
|
|
|
|
This value is retrieved from the following registry location:
|
|
|
|
\HKLM\Software\Microsoft\Windows\CurrentVersion\Setup
|
|
|
|
ServicePackCachePath : REG_SZ : "c:\windows\foo" // for example.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is a pointer to the path string.
|
|
This memory must be freed via MyFree().
|
|
|
|
If the function fails due to out-of-memory, the return value is NULL.
|
|
|
|
--*/
|
|
{
|
|
HKEY hKey;
|
|
TCHAR CharBuffer[CSTRLEN(REGSTR_PATH_SETUP) + SIZECHARS(REGSTR_KEY_SETUP)];
|
|
DWORD Err, DataType, DataSize;
|
|
PTSTR Value;
|
|
PCTSTR ReturnStr = NULL;
|
|
|
|
TRACK_PUSH
|
|
|
|
CopyMemory(CharBuffer,
|
|
pszPathSetup,
|
|
sizeof(pszPathSetup) - sizeof(TCHAR)
|
|
);
|
|
CopyMemory((PBYTE)CharBuffer + (sizeof(pszPathSetup) - sizeof(TCHAR)),
|
|
pszKeySetup,
|
|
sizeof(pszKeySetup)
|
|
);
|
|
|
|
if((Err = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
CharBuffer,
|
|
0,
|
|
KEY_READ,
|
|
&hKey)) == ERROR_SUCCESS) {
|
|
//
|
|
// Attempt to read the the "ServicePackCachePath" value.
|
|
//
|
|
Err = QueryRegistryValue(hKey, pszSvcPackCachePath, &Value, &DataType, &DataSize);
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
if(Err == NO_ERROR) {
|
|
|
|
ReturnStr = Value;
|
|
|
|
}
|
|
|
|
TRACK_POP
|
|
|
|
return ReturnStr;
|
|
}
|
|
|
|
#if MEM_DBG
|
|
#define GetServicePackSourcePath() GetServicePackSourcePath(TRACK_ARG_CALL)
|
|
#define GetServicePackCachePath() GetServicePackCachePath(TRACK_ARG_CALL)
|
|
#endif
|
|
|
|
|
|
|
|
PCTSTR
|
|
GetDriverCacheSourcePath(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine returns a newly-allocated buffer containing the source path to the local driver cache
|
|
cab-file.
|
|
|
|
This value is retrieved from the following registry location:
|
|
|
|
\HKLM\Software\Microsoft\Windows\CurrentVersion\Setup
|
|
|
|
DriverCachePath : REG_SZ : "\\ntamd64\1300fre.wks" // for example.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is a pointer to the path string.
|
|
This memory must be freed via MyFree().
|
|
|
|
If the function fails due to out-of-memory, the return value is NULL.
|
|
|
|
--*/
|
|
{
|
|
HKEY hKey;
|
|
TCHAR CharBuffer[CSTRLEN(REGSTR_PATH_SETUP) + SIZECHARS(REGSTR_KEY_SETUP)];
|
|
DWORD Err, DataType, DataSize;
|
|
PTSTR Value;
|
|
TCHAR Path[MAX_PATH];
|
|
|
|
CopyMemory(CharBuffer,
|
|
pszPathSetup,
|
|
sizeof(pszPathSetup) - sizeof(TCHAR)
|
|
);
|
|
CopyMemory((PBYTE)CharBuffer + (sizeof(pszPathSetup) - sizeof(TCHAR)),
|
|
pszKeySetup,
|
|
sizeof(pszKeySetup)
|
|
);
|
|
|
|
if((Err = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
CharBuffer,
|
|
0,
|
|
KEY_READ,
|
|
&hKey)) == ERROR_SUCCESS) {
|
|
//
|
|
// Attempt to read the the "DriverCachePath" value.
|
|
//
|
|
Err = QueryRegistryValue(hKey, pszDriverCachePath, &Value, &DataType, &DataSize);
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
if(Err == NO_ERROR) {
|
|
if(Value) {
|
|
|
|
ExpandEnvironmentStrings(Value,Path,MAX_PATH);
|
|
|
|
MyFree(Value);
|
|
|
|
Value = NULL;
|
|
|
|
if (*Path) {
|
|
Value = DuplicateString( Path );
|
|
}
|
|
|
|
return (PCTSTR)Value;
|
|
}
|
|
} else if(Err == ERROR_NOT_ENOUGH_MEMORY) {
|
|
return NULL;
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOL
|
|
pSetupSetSystemSourcePath(
|
|
IN PCTSTR NewSourcePath,
|
|
IN PCTSTR NewSvcPackSourcePath
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is used to override the system source path used by setupapi (as
|
|
retrieved by GetSystemSourcePath during DLL initialization). This is used by
|
|
syssetup.dll to set the system source path appropriately during GUI-mode setup,
|
|
so that the device installer APIs will copy files from the correct source location.
|
|
|
|
We do the same thing for the service pack source path
|
|
|
|
NOTE: This routine IS NOT thread safe!
|
|
|
|
Arguments:
|
|
|
|
NewSourcePath - supplies the new source path to be used.
|
|
NewSvcPackSourcePath - supplies the new svcpack source path to be used.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is TRUE.
|
|
If the function fails (due to out-of-memory), the return value is FALSE.
|
|
|
|
--*/
|
|
{
|
|
PCTSTR p,q;
|
|
|
|
p = (PCTSTR)DuplicateString(NewSourcePath);
|
|
q = (PCTSTR)DuplicateString(NewSvcPackSourcePath);
|
|
|
|
if(p) {
|
|
MyFree(SystemSourcePath);
|
|
SystemSourcePath = p;
|
|
}
|
|
|
|
if (q) {
|
|
MyFree(ServicePackSourcePath);
|
|
ServicePackSourcePath = q;
|
|
}
|
|
|
|
if (!p || !q) {
|
|
//
|
|
// failed due to out of memory!
|
|
//
|
|
return(FALSE);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
PCTSTR
|
|
pSetupGetOsLoaderPath(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine returns a newly-allocated buffer containing the path to the OsLoader
|
|
(relative to the system partition drive). This value is retrieved from the
|
|
following registry location:
|
|
|
|
HKLM\System\Setup
|
|
OsLoaderPath : REG_SZ : <path> // e.g., "\os\winnt40"
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
If the registry entry is found, the return value is a pointer to the string containing
|
|
the path. The caller must free this buffer via MyFree().
|
|
|
|
If the registry entry is not found, or memory cannot be allocated for the buffer, the
|
|
return value is NULL.
|
|
|
|
--*/
|
|
{
|
|
HKEY hKey;
|
|
PTSTR Value;
|
|
DWORD Err, DataType, DataSize;
|
|
|
|
if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
TEXT("SYSTEM\\Setup"),
|
|
0,
|
|
KEY_READ,
|
|
&hKey) == ERROR_SUCCESS) {
|
|
|
|
Err = QueryRegistryValue(hKey, TEXT("OsLoaderPath"), &Value, &DataType, &DataSize);
|
|
|
|
RegCloseKey(hKey);
|
|
|
|
return (Err == NO_ERROR) ? (PCTSTR)Value : NULL;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
PCTSTR
|
|
pSetupGetSystemPartitionRoot(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine returns a newly-allocated buffer containing the path to the OsLoader
|
|
(relative to the system partition drive). This value is retrieved from the
|
|
following registry location:
|
|
|
|
HKLM\System\Setup
|
|
SystemPartition : REG_SZ : <path> // e.g., "\Device\HarddiskVolume1"
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
If the registry entry is found, the return value is a pointer to the string containing
|
|
the path. The caller must free this buffer via MyFree().
|
|
|
|
If the registry entry is not found, or memory cannot be allocated for the buffer, the
|
|
return value is NULL.
|
|
|
|
--*/
|
|
{
|
|
#ifdef UNICODE
|
|
HKEY hKey;
|
|
PTSTR Value;
|
|
DWORD Err, DataType, DataSize;
|
|
TCHAR Path[MAX_PATH];
|
|
|
|
if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
TEXT("SYSTEM\\Setup"),
|
|
0,
|
|
KEY_READ,
|
|
&hKey) == ERROR_SUCCESS) {
|
|
|
|
Err = QueryRegistryValue(hKey, TEXT("SystemPartition"), &Value, &DataType, &DataSize);
|
|
|
|
RegCloseKey(hKey);
|
|
|
|
if(Err == NO_ERROR) {
|
|
//
|
|
// prepend \\?\GLOBALROOT\
|
|
//
|
|
lstrcpy(Path,TEXT("\\\\?\\GLOBALROOT\\"));
|
|
if(pSetupConcatenatePaths(Path,Value,MAX_PATH,NULL)) {
|
|
MyFree(Value);
|
|
Value = DuplicateString(Path);
|
|
if(!Value) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
} else {
|
|
Err = GetLastError();
|
|
MyFree(Value);
|
|
}
|
|
}
|
|
|
|
return (Err == NO_ERROR) ? (PCTSTR)Value : NULL;
|
|
}
|
|
#endif
|
|
|
|
return NULL;
|
|
}
|
|
|
|
PCTSTR
|
|
pSetupGetProcessPath(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Get the name of the EXE that we're running in.
|
|
|
|
Arguments:
|
|
|
|
NONE.
|
|
|
|
Return Value:
|
|
|
|
Pointer to a dynamically allocated string containing the name.
|
|
|
|
--*/
|
|
|
|
{
|
|
LPTSTR modname;
|
|
|
|
modname = MyMalloc(MAX_PATH * sizeof(TCHAR));
|
|
|
|
if(modname != NULL) {
|
|
if(GetModuleFileName(NULL, modname, MAX_PATH) > 0) {
|
|
LPTSTR modname2;
|
|
modname2 = MyRealloc(modname, (lstrlen(modname)+1)*sizeof(TCHAR));
|
|
if(modname2) {
|
|
modname = modname2;
|
|
}
|
|
return modname;
|
|
} else {
|
|
#ifdef PRERELEASE
|
|
OutputDebugStringA("GetModuleFileName returned 0\r\n");
|
|
DebugBreak();
|
|
#endif
|
|
MyFree(modname);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
BOOL
|
|
pGetGuiSetupInProgress(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine determines if we're doing a gui-mode setup.
|
|
|
|
This value is retrieved from the following registry location:
|
|
|
|
\HKLM\System\Setup\
|
|
|
|
SystemSetupInProgress : REG_DWORD : 0x00 (where nonzero means we're doing a gui-setup)
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is a pointer to the path string.
|
|
This memory must be freed via MyFree().
|
|
|
|
If the function fails due to out-of-memory, the return value is NULL.
|
|
|
|
--*/
|
|
{
|
|
HKEY hKey;
|
|
TCHAR CharBuffer[CSTRLEN(REGSTR_PATH_SETUP) + SIZECHARS(REGSTR_KEY_SETUP)];
|
|
DWORD Err, DataType, DataSize = sizeof(DWORD);
|
|
DWORD Value;
|
|
|
|
if((Err = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
TEXT("System\\Setup"),
|
|
0,
|
|
KEY_READ,
|
|
&hKey)) == ERROR_SUCCESS) {
|
|
//
|
|
// Attempt to read the the "DriverCachePath" value.
|
|
//
|
|
Err = RegQueryValueEx(
|
|
hKey,
|
|
TEXT("SystemSetupInProgress"),
|
|
NULL,
|
|
&DataType,
|
|
(LPBYTE)&Value,
|
|
&DataSize);
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
if(Err == NO_ERROR) {
|
|
if(Value) {
|
|
return(TRUE);
|
|
}
|
|
}
|
|
|
|
return(FALSE);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
BOOL
|
|
pGetGuiSetupInProgress(
|
|
VOID
|
|
)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
#endif
|
|
|
|
VOID pSetupSetGlobalFlags(
|
|
IN DWORD Value
|
|
)
|
|
/*++
|
|
|
|
exported as a private function
|
|
|
|
Routine Description:
|
|
|
|
Sets global flags to change certain setupapi features,
|
|
such as "should we call runonce after installing every device" (set if we will manually call it)
|
|
or "should we backup every file"
|
|
Used to initialize value
|
|
|
|
Arguments:
|
|
|
|
Value: combination of:
|
|
|
|
PSPGF_NO_RUNONCE - set to inhibit runonce calls (e.g., during GUI-
|
|
mode setup)
|
|
|
|
PSPGF_NO_BACKUP - set to inhibit automatic backup (e.g., during
|
|
GUI-mode setup)
|
|
|
|
PSPGF_NONINTERACTIVE - set to inhibit _all_ UI (e.g., for server-side
|
|
device installation)
|
|
|
|
PSPGF_SERVER_SIDE_RUNONCE - batch RunOnce entries for server-side
|
|
processing (for use only by umpnpmgr)
|
|
|
|
PSPGF_NO_VERIFY_INF - set to inhibit verification (digital signature) of
|
|
INF files until after the cyrpto DLLs have been registered.
|
|
|
|
PSPGF_UNATTENDED_SETUP - similar to NONINTERACTIVE - but specific to unattended setup
|
|
|
|
PSPGF_AUTOFAIL_VERIFIES - automatically fail all calls to crypto
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
pSetupModifyGlobalFlags((DWORD)(-1),Value);
|
|
}
|
|
|
|
VOID
|
|
pSetupModifyGlobalFlags(
|
|
IN DWORD Flags,
|
|
IN DWORD Value
|
|
)
|
|
/*++
|
|
|
|
exported as a private function
|
|
|
|
Routine Description:
|
|
|
|
Modifies global setup flags
|
|
|
|
such as "should we call runonce after installing every device" (set if we will manually call it)
|
|
or "should we backup every file"
|
|
only modifies specified flags to given value
|
|
|
|
Arguments:
|
|
|
|
Flags: what actual flags to modify, combination of:
|
|
|
|
PSPGF_NO_RUNONCE - set to inhibit runonce calls (e.g., during GUI-
|
|
mode setup)
|
|
|
|
PSPGF_NO_BACKUP - set to inhibit automatic backup (e.g., during
|
|
GUI-mode setup)
|
|
|
|
PSPGF_NONINTERACTIVE - set to inhibit _all_ UI (e.g., for server-side
|
|
device installation)
|
|
|
|
PSPGF_SERVER_SIDE_RUNONCE - batch RunOnce entries for server-side
|
|
processing (for use only by umpnpmgr)
|
|
|
|
PSPGF_NO_VERIFY_INF - set to inhibit verification (digital signature) of
|
|
INF files until after the cyrpto DLLs have been registered.
|
|
|
|
PSPGF_UNATTENDED_SETUP - similar to PSPGF_NONINTERACTIVE, but specific to setup
|
|
|
|
PSPGF_AUTOFAIL_VERIFIES - automatically fail all calls to crypto
|
|
|
|
Value: new value of bits specified in Flags
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
Flags &= ~GlobalSetupFlagsOverride; // exclusion
|
|
#ifdef UNICODE
|
|
if((Flags & PSPGF_NO_VERIFY_INF) && !(Value & PSPGF_NO_VERIFY_INF) && (GlobalSetupFlags & PSPGF_NO_VERIFY_INF)) {
|
|
Seed = GetSeed();
|
|
}
|
|
#endif
|
|
GlobalSetupFlags = (Value & Flags) | (GlobalSetupFlags & ~Flags);
|
|
}
|
|
|
|
DWORD pSetupGetGlobalFlags(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
exported as a private function, also called internally
|
|
|
|
Routine Description:
|
|
|
|
Return flags previously set
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return value:
|
|
|
|
Flags (combination of values described above for pSetupSetGlobalFlags)
|
|
|
|
--*/
|
|
{
|
|
return GlobalSetupFlags;
|
|
}
|
|
|
|
BOOL
|
|
WINAPI
|
|
SetupSetNonInteractiveMode(
|
|
IN BOOL NonInteractiveFlag
|
|
)
|
|
/*++
|
|
|
|
Global access to the flag PSPGF_NONINTERACTIVE
|
|
|
|
Routine Description:
|
|
|
|
Set/Reset the NonInteractiveMode flag, and return previous flag value
|
|
(can't clear override)
|
|
|
|
Arguments:
|
|
|
|
New flag value
|
|
|
|
Return value:
|
|
|
|
Old flag value
|
|
|
|
--*/
|
|
{
|
|
BOOL f = (GlobalSetupFlags & PSPGF_NONINTERACTIVE) ? TRUE : FALSE;
|
|
if (NonInteractiveFlag) {
|
|
pSetupModifyGlobalFlags(PSPGF_NONINTERACTIVE,PSPGF_NONINTERACTIVE);
|
|
} else {
|
|
pSetupModifyGlobalFlags(PSPGF_NONINTERACTIVE,0);
|
|
}
|
|
return f;
|
|
}
|
|
|
|
BOOL
|
|
WINAPI
|
|
SetupGetNonInteractiveMode(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Global access to the flag PSPGF_NONINTERACTIVE
|
|
|
|
Routine Description:
|
|
|
|
Get current flag value
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return value:
|
|
|
|
Current flag value
|
|
|
|
--*/
|
|
{
|
|
return (GlobalSetupFlags & PSPGF_NONINTERACTIVE) ? TRUE : FALSE;
|
|
}
|
|
|
|
#ifndef _WIN64
|
|
BOOL
|
|
GetIsWow64 (
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Determine if we're running on WOW64 or not (not supported on ANSI builds)
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return value:
|
|
|
|
TRUE if running under WOW64 (and special Wow64 features available)
|
|
|
|
--*/
|
|
{
|
|
#ifdef UNICODE
|
|
ULONG_PTR ul = 0;
|
|
NTSTATUS st;
|
|
|
|
//
|
|
// If this call succeeds and sets ul non-zero
|
|
// it's a 32-bit process running on Win64
|
|
//
|
|
|
|
st = NtQueryInformationProcess(NtCurrentProcess(),
|
|
ProcessWow64Information,
|
|
&ul,
|
|
sizeof(ul),
|
|
NULL);
|
|
|
|
if (NT_SUCCESS(st) && (0 != ul)) {
|
|
// 32-bit code running on Win64
|
|
return TRUE;
|
|
}
|
|
#endif
|
|
return FALSE;
|
|
}
|
|
#endif // _WIN64
|
|
|
|
#if 0 // deleted code
|
|
//
|
|
// this will be useful at somepoint, but not used right now
|
|
//
|
|
BOOL
|
|
InitComponents(
|
|
DWORD Components
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called at a point we want certain components initialized
|
|
|
|
Arguments:
|
|
|
|
bitmask of components to initialize
|
|
|
|
Return value:
|
|
|
|
TRUE if all initialized ok
|
|
|
|
--*/
|
|
{
|
|
BOOL success = FALSE;
|
|
PSETUP_TLS pPerThread = SetupGetTlsData();
|
|
BOOL locked = FALSE;
|
|
|
|
if(!pPerThread) {
|
|
MYASSERT(pPerThread);
|
|
return FALSE;
|
|
}
|
|
|
|
try {
|
|
EnterCriticalSection(&DelayedComponentMutex);
|
|
locked = TRUE;
|
|
Components &= ~ DoneComponentInitialize;
|
|
Components &= ~ pPerThread->PerThreadDoneComponent;
|
|
|
|
if (!Components) {
|
|
//
|
|
// already done
|
|
//
|
|
success = TRUE;
|
|
leave;
|
|
}
|
|
if (Components & FailedComponentInitialize) {
|
|
//
|
|
// previously failed
|
|
//
|
|
leave;
|
|
}
|
|
if (Components & pPerThread->PerThreadFailedComponent) {
|
|
//
|
|
// previously failed
|
|
//
|
|
leave;
|
|
}
|
|
MYASSERT(((DoneComponentInitialize | pPerThread->PerThreadDoneComponent) & Components) == Components);
|
|
MYASSERT(((FailedComponentInitialize | pPerThread->PerThreadFailedComponent) & Components) == 0);
|
|
success = TRUE;
|
|
|
|
} except (EXCEPTION_EXECUTE_HANDLER) {
|
|
MYASSERT(FALSE);
|
|
}
|
|
if(locked) {
|
|
LeaveCriticalSection(&DelayedComponentMutex);
|
|
}
|
|
return success;
|
|
}
|
|
|
|
VOID
|
|
ComponentCleanup(
|
|
DWORD Components
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Called to cleanup components
|
|
|
|
Arguments:
|
|
|
|
bitmask of components to uninitialize
|
|
|
|
Return value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
PSETUP_TLS pPerThread = SetupGetTlsData();
|
|
BOOL locked = FALSE;
|
|
|
|
try {
|
|
EnterCriticalSection(&DelayedComponentMutex);
|
|
locked = TRUE;
|
|
Components &= (DoneComponentInitialize | (pPerThread? pPerThread->PerThreadDoneComponent : 0));
|
|
if (!Components) {
|
|
//
|
|
// already done
|
|
//
|
|
leave;
|
|
}
|
|
|
|
} except (EXCEPTION_EXECUTE_HANDLER) {
|
|
MYASSERT(FALSE);
|
|
}
|
|
MYASSERT(((DoneComponentInitialize | (pPerThread ? pPerThread->PerThreadDoneComponent : 0)) & Components) == 0);
|
|
if(locked) {
|
|
LeaveCriticalSection(&DelayedComponentMutex);
|
|
}
|
|
}
|
|
#endif // deleted code
|
|
|
|
#ifdef UNICODE
|
|
BOOL
|
|
pSetupSetNoDriverPrompts(
|
|
BOOL Flag
|
|
)
|
|
/*++
|
|
|
|
exported as a private function
|
|
|
|
Routine Description:
|
|
|
|
Sets system into headless/non-headless mode
|
|
|
|
Arguments:
|
|
|
|
Flag - indicating mode
|
|
|
|
--*/
|
|
{
|
|
//
|
|
//
|
|
if(!GuiSetupInProgress) {
|
|
return FALSE;
|
|
}
|
|
if(GlobalNoDriverPromptsEventFlag == NULL) {
|
|
GlobalNoDriverPromptsEventFlag = CreateEvent(NULL,TRUE,Flag,SETUP_NODRIVERPROMPTS_MODE);
|
|
if(GlobalNoDriverPromptsEventFlag == NULL) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
if(Flag) {
|
|
//
|
|
// force this process's setupapi to be non-interative, and any future setupapi's
|
|
//
|
|
GlobalSetupFlagsOverride |= PSPGF_UNATTENDED_SETUP; // don't allow this to be changed
|
|
GlobalSetupFlags |= PSPGF_UNATTENDED_SETUP; // actual value
|
|
SetEvent(GlobalNoDriverPromptsEventFlag);
|
|
} else {
|
|
//
|
|
// can't reset flag for this/existing processes, but can reset it for all future processes
|
|
//
|
|
ResetEvent(GlobalNoDriverPromptsEventFlag);
|
|
}
|
|
return TRUE;
|
|
}
|
|
#endif
|
|
|
|
BOOL
|
|
IsNoDriverPrompts(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
internal
|
|
|
|
Routine Description:
|
|
|
|
Obtains headless state
|
|
|
|
Arguments:
|
|
|
|
Flag - indicating mode
|
|
|
|
--*/
|
|
{
|
|
#ifdef UNICODE
|
|
if(!GuiSetupInProgress) {
|
|
return FALSE;
|
|
}
|
|
if(GlobalNoDriverPromptsEventFlag == NULL) {
|
|
GlobalNoDriverPromptsEventFlag = OpenEvent(SYNCHRONIZE,FALSE,SETUP_NODRIVERPROMPTS_MODE);
|
|
if(GlobalNoDriverPromptsEventFlag == NULL) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
//
|
|
// poll event, returning TRUE if it's signalled
|
|
//
|
|
return WaitForSingleObject(GlobalNoDriverPromptsEventFlag,0) == WAIT_OBJECT_0;
|
|
#else
|
|
return FALSE;
|
|
#endif
|
|
}
|
|
|
|
|
|
DWORD
|
|
GetEmbeddedFlags(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine determines whether or not we are running on an embedded
|
|
product, and if so, whether:
|
|
|
|
* The "minimize setupapi footprint" option is enabled. This causes us to
|
|
modify our default behaviors as follows:
|
|
|
|
1. Never call any crypto APIs, and just assume everything is signed
|
|
2. Never generate PNFs.
|
|
|
|
* The "disable SCE" option is enabled. This causes us to avoid all use of
|
|
the Security Configuration Editor (SCE) routines (as the corresponding
|
|
DLLs won't be available on that embedded configuration).
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return value:
|
|
|
|
Combination of the following flags:
|
|
|
|
PSPGF_MINIMAL_EMBEDDED if we're running in "minimize footprint" mode
|
|
|
|
PSPGF_NO_SCE_EMBEDDED if we're running in "disable SCE" mode
|
|
|
|
--*/
|
|
{
|
|
OSVERSIONINFOEX osvix;
|
|
DWORDLONG dwlConditionMask = 0;
|
|
HKEY hKey;
|
|
TCHAR CharBuffer[CSTRLEN(REGSTR_PATH_SETUP) + SIZECHARS(REGSTR_KEY_SETUP)];
|
|
DWORD RegDataType, Data, DataSize;
|
|
DWORD Flags;
|
|
|
|
//
|
|
// Are we on the embedded product suite?
|
|
//
|
|
ZeroMemory(&osvix, sizeof(OSVERSIONINFOEX));
|
|
osvix.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
|
|
osvix.wSuiteMask = VER_SUITE_EMBEDDEDNT;
|
|
VER_SET_CONDITION(dwlConditionMask, VER_SUITENAME, VER_OR);
|
|
|
|
if(!VerifyVersionInfo(&osvix,
|
|
VER_SUITENAME,
|
|
dwlConditionMask)) {
|
|
return 0;
|
|
}
|
|
|
|
Flags = 0;
|
|
|
|
//
|
|
// OK, we running on embedded. Now we need to find out whether or not we
|
|
// should run in "minimal footprint" mode. This is stored in a REG_DWORD
|
|
// value entry called "MinimizeFootprint" under
|
|
// HKLM\Software\Microsoft\Windows\CurrentVersion\Setup.
|
|
//
|
|
CopyMemory(CharBuffer,
|
|
pszPathSetup,
|
|
sizeof(pszPathSetup) - sizeof(TCHAR)
|
|
);
|
|
CopyMemory((PBYTE)CharBuffer + (sizeof(pszPathSetup) - sizeof(TCHAR)),
|
|
pszKeySetup,
|
|
sizeof(pszKeySetup)
|
|
);
|
|
|
|
if(ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
CharBuffer,
|
|
0,
|
|
KEY_READ,
|
|
&hKey)) {
|
|
DataSize = sizeof(Data);
|
|
|
|
if((ERROR_SUCCESS == RegQueryValueEx(hKey,
|
|
pszMinimizeFootprint,
|
|
NULL,
|
|
&RegDataType,
|
|
(LPBYTE)&Data,
|
|
&DataSize))
|
|
&& (RegDataType == REG_DWORD) && (DataSize == sizeof(Data))) {
|
|
|
|
Flags |= PSPGF_MINIMAL_EMBEDDED;
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
//
|
|
// Now look under HKLM\Software\Microsoft\EmbeddedNT\Security for a
|
|
// DisableSCE REG_DWORD value entry, indicating we shouldn't call SCE.
|
|
//
|
|
if(ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
pszEmbeddedNTSecurity,
|
|
0,
|
|
KEY_READ,
|
|
&hKey)) {
|
|
DataSize = sizeof(Data);
|
|
|
|
if((ERROR_SUCCESS == RegQueryValueEx(hKey,
|
|
pszDisableSCE,
|
|
NULL,
|
|
&RegDataType,
|
|
(LPBYTE)&Data,
|
|
&DataSize))
|
|
&& (RegDataType == REG_DWORD) && (DataSize == sizeof(Data))) {
|
|
|
|
Flags |= PSPGF_NO_SCE_EMBEDDED;
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
return Flags;
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
DWORD
|
|
GetSeed(
|
|
VOID
|
|
)
|
|
{
|
|
HKEY hKey;
|
|
DWORD val = 0;
|
|
DWORD valsize, valdatatype;
|
|
|
|
if(GlobalSetupFlags & PSPGF_MINIMAL_EMBEDDED) {
|
|
return val;
|
|
}
|
|
|
|
if(ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
L"System\\WPA\\PnP",
|
|
0,
|
|
KEY_READ,
|
|
&hKey)) {
|
|
|
|
valsize = sizeof(val);
|
|
if((ERROR_SUCCESS != RegQueryValueEx(hKey,
|
|
L"seed",
|
|
NULL,
|
|
&valdatatype,
|
|
(PBYTE)&val,
|
|
&valsize))
|
|
|| (valdatatype != REG_DWORD) || (valsize != sizeof(val))) {
|
|
|
|
val = 0;
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
return val;
|
|
}
|
|
#endif
|
|
|