mirror of https://github.com/tongzx/nt5src
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.
7024 lines
252 KiB
7024 lines
252 KiB
/*++
|
|
|
|
Copyright (c) 1995-2001 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
syspnp.c
|
|
|
|
Abstract:
|
|
|
|
Device installation routines.
|
|
|
|
Author:
|
|
|
|
Jaime Sasson (jaimes) 6-Mar-1997
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
#include "setupp.h"
|
|
#pragma hdrstop
|
|
|
|
//
|
|
// Provide extern references to device (setup) class GUIDs instantiated in
|
|
// clasinst.c.
|
|
//
|
|
#include <devguid.h>
|
|
|
|
//
|
|
// Define and initialize a global variable, GUID_NULL
|
|
// (from coguid.h)
|
|
//
|
|
#include <initguid.h>
|
|
|
|
//
|
|
// UpdateDriverForPlugAndPlayDevices constants
|
|
//
|
|
#include <newdev.h>
|
|
|
|
DEFINE_GUID(GUID_NULL, 0L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
|
|
|
#define PNP_NEW_HW_PIPE TEXT("\\\\.\\pipe\\PNP_New_HW_Found")
|
|
#define PNP_CREATE_PIPE_EVENT TEXT("PNP_Create_Pipe_Event")
|
|
#define PNP_BATCH_PROCESSED_EVENT TEXT("PNP_Batch_Processed_Event")
|
|
#define PNP_PIPE_TIMEOUT 180000
|
|
|
|
#ifdef PRERELEASE
|
|
|
|
//
|
|
// legacy-phase1 can take a long time in certain cases
|
|
//
|
|
#define PNP_LEGACY_PHASE1_TIMEOUT 2*60*1000
|
|
#define PNP_LEGACY_PHASE2_TIMEOUT 1*60*1000
|
|
#define PNP_LEGACY_PHASE3_TIMEOUT 1*60*1000
|
|
#define PNP_ENUM_TIMEOUT 1*60*1000
|
|
#define RUNONCE_TIMEOUT 1*60*1000
|
|
#define RUNONCE_THRESHOLD 20 // * RUNONCE_TIMEOUT
|
|
|
|
#else // PRERELEASE
|
|
|
|
//
|
|
// legacy-phase1 can take a long time in certain cases
|
|
//
|
|
#define PNP_LEGACY_PHASE1_TIMEOUT 4*60*1000
|
|
#define PNP_LEGACY_PHASE2_TIMEOUT 2*60*1000
|
|
#define PNP_LEGACY_PHASE3_TIMEOUT 2*60*1000
|
|
#define PNP_ENUM_TIMEOUT 2*60*1000
|
|
#define RUNONCE_TIMEOUT 2*60*1000
|
|
#define RUNONCE_THRESHOLD 20 // * RUNONCE_TIMEOUT
|
|
|
|
#endif // PRERELEASE
|
|
|
|
//
|
|
// Declare a private INF key string recogized only by syssetup during device
|
|
// installation...
|
|
//
|
|
PWSTR szSyssetupPnPFlags = L"SyssetupPnPFlags";
|
|
//
|
|
// ...and define the flags that are valid for this value
|
|
//
|
|
#define PNPFLAG_DONOTCALLCONFIGMG 0x00000001
|
|
|
|
|
|
#define SETUP_OEM_LDR_DEVICE 0x00000001
|
|
|
|
|
|
//
|
|
// REVIEW 2000/11/08 seanch - Old behavior that we don't want to regress.
|
|
// Remove the #define below, after the network guys (jameelh) fix
|
|
// the network class installer. This should happen before beta2
|
|
//
|
|
#define BB_PNP_NETWORK_TIMEOUT 10*60*1000
|
|
#define BB_NETWORK_GUID_STRING L"{4D36E972-E325-11CE-BFC1-08002BE10318}"
|
|
|
|
#ifdef PNP_DEBUG_UI
|
|
#define UNKNOWN_DEVICE_ICON_INDEX 18
|
|
|
|
typedef struct _LISTBOX_ITEM {
|
|
HDEVINFO DevInfoSet;
|
|
SP_DEVINFO_DATA DeviceInfoData;
|
|
INT IconIndex;
|
|
WCHAR DeviceDescription[ LINE_LEN ];
|
|
} *PLISTBOX_ITEM, LISTBOX_ITEM;
|
|
|
|
|
|
typedef struct _DEVINFOSET_ELEMENT {
|
|
struct _DEVINFOSET_ELEMENT *Next;
|
|
HDEVINFO DevInfoSet;
|
|
GUID SetGuid;
|
|
} *PDEVINFOSET_ELEMENT, DEVINFOSET_ELEMENT;
|
|
|
|
|
|
PDEVINFOSET_ELEMENT DevInfoSetList = NULL;
|
|
PWSTR szUnknownDevice = NULL;
|
|
#endif // PNP_DEBUG_UI
|
|
|
|
BOOL PrivilegeAlreadySet = FALSE;
|
|
//
|
|
// pnplog.txt is the file that lists the class installers
|
|
// that hang during GUI setup, so that when GUI setup is restarted,
|
|
// the offendig class installers will not be invoked again.
|
|
// This file is created during GUI setup on %SystemRoot%, and is always
|
|
// deleted during textmode setup (the file is listed on txtsetup.sif as
|
|
// "delete on upgrade").
|
|
// This file will never exist when the system first boots into GUI setup,
|
|
// immediately after the completion of textmode setup. This is
|
|
// to ensure that an old version of pnplog.txt will not affect the
|
|
// upgrade case, or a clean install of a system that is installed on
|
|
// a directory that already contains an NT system.
|
|
//
|
|
PWSTR szPnpLogFile = L"pnplog.txt";
|
|
PWSTR szEnumDevSection = L"EnumeratedDevices";
|
|
PWSTR szLegacyClassesSection = L"LegacyClasses";
|
|
PWSTR szLegacyDevSection = L"LegacyDevices";
|
|
|
|
//
|
|
// multi-sz list of files that is passed to SfcInitProt that the initial scan
|
|
// will not replace. This is used for non-signed drivers that are specified
|
|
// by F6 during textmode setup.
|
|
//
|
|
MULTISZ EnumPtrSfcIgnoreFiles = {NULL, NULL, 0};
|
|
|
|
//
|
|
// Structure for thread parameter
|
|
//
|
|
typedef struct _PNP_THREAD_PARAMS {
|
|
HWND Window;
|
|
HWND ProgressWindow;
|
|
DWORD ThreadId;
|
|
HINF InfHandle;
|
|
UINT ProgressWindowStartAtPercent;
|
|
UINT ProgressWindowStopAtPercent;
|
|
BOOL SendWmQuit;
|
|
} PNP_THREAD_PARAMS, *PPNP_THREAD_PARAMS;
|
|
|
|
typedef struct _INF_FILE_NAME {
|
|
struct _INF_FILE_NAME *Next;
|
|
PWSTR InfName;
|
|
} *PINF_FILE_NAME, INF_FILE_NAME;
|
|
|
|
|
|
typedef struct _PNP_ENUM_DEV_THREAD_PARAMS {
|
|
HDEVINFO hDevInfo;
|
|
SP_DEVINFO_DATA DeviceInfoData;
|
|
PWSTR pDeviceDescription;
|
|
PWSTR pDeviceId;
|
|
} PNP_ENUM_DEV_THREAD_PARAMS, *PPNP_ENUM_DEV_THREAD_PARAMS;
|
|
|
|
typedef struct _PNP_PHASE1_LEGACY_DEV_THREAD_PARAMS {
|
|
HDEVINFO hDevInfo;
|
|
GUID Guid;
|
|
PWSTR pClassDescription;
|
|
HWND hwndParent;
|
|
} PNP_PHASE1_LEGACY_DEV_THREAD_PARAMS, *PPNP_PHASE1_LEGACY_DEV_THREAD_PARAMS;
|
|
|
|
|
|
typedef struct _PNP_PHASE2_LEGACY_DEV_THREAD_PARAMS {
|
|
HDEVINFO hDevInfo;
|
|
HSPFILEQ FileQ;
|
|
SP_DEVINFO_DATA DeviceInfoData;
|
|
PWSTR pClassDescription;
|
|
PWSTR pDeviceId;
|
|
} PNP_PHASE2_LEGACY_DEV_THREAD_PARAMS, *PPNP_PHASE2_LEGACY_DEV_THREAD_PARAMS;
|
|
|
|
|
|
typedef struct _PNP_PHASE3_LEGACY_DEV_THREAD_PARAMS {
|
|
HDEVINFO hDevInfo;
|
|
SP_DEVINFO_DATA DeviceInfoData;
|
|
PWSTR pDeviceId;
|
|
} PNP_PHASE3_LEGACY_DEV_THREAD_PARAMS, *PPNP_PHASE3_LEGACY_DEV_THREAD_PARAMS;
|
|
|
|
//
|
|
// private cfgmgr32 API that we use
|
|
//
|
|
|
|
DWORD
|
|
CMP_WaitNoPendingInstallEvents(
|
|
IN DWORD dwTimeout
|
|
);
|
|
|
|
//
|
|
// for run-time loading of newdev.dll
|
|
//
|
|
|
|
typedef BOOL (WINAPI *ExternalUpdateDriverForPlugAndPlayDevicesW)(
|
|
HWND hwndParent,
|
|
LPCWSTR HardwareId,
|
|
LPCWSTR FullInfPath,
|
|
DWORD InstallFlags,
|
|
PBOOL bRebootRequired OPTIONAL
|
|
);
|
|
|
|
|
|
//
|
|
// Private routine prototypes
|
|
//
|
|
|
|
VOID
|
|
SortClassGuidListForDetection(
|
|
IN OUT LPGUID GuidList,
|
|
IN ULONG GuidCount,
|
|
OUT PULONG LastBatchedDetect
|
|
);
|
|
|
|
DWORD
|
|
pPhase1InstallPnpLegacyDevicesThread(
|
|
PPNP_PHASE1_LEGACY_DEV_THREAD_PARAMS ThreadParams
|
|
);
|
|
|
|
DWORD
|
|
pPhase2InstallPnpLegacyDevicesThread(
|
|
PPNP_PHASE2_LEGACY_DEV_THREAD_PARAMS ThreadParams
|
|
);
|
|
|
|
DWORD
|
|
pPhase3InstallPnpLegacyDevicesThread(
|
|
PPNP_PHASE3_LEGACY_DEV_THREAD_PARAMS ThreadParams
|
|
);
|
|
|
|
DWORD
|
|
pInstallPnpEnumeratedDeviceThread(
|
|
PPNP_ENUM_DEV_THREAD_PARAMS ThreadParams
|
|
);
|
|
|
|
BOOL
|
|
GetDeviceConfigFlags(
|
|
HDEVINFO hDevInfo,
|
|
PSP_DEVINFO_DATA pDeviceInfoData,
|
|
DWORD* pdwConfigFlags
|
|
);
|
|
|
|
BOOL
|
|
SetDeviceConfigFlags(
|
|
HDEVINFO hDevInfo,
|
|
PSP_DEVINFO_DATA pDeviceInfoData,
|
|
DWORD dwConfigFlags
|
|
);
|
|
|
|
BOOL
|
|
InstallOEMInfs(
|
|
VOID
|
|
);
|
|
|
|
#if defined(_X86_)
|
|
VOID
|
|
SfcExcludeMigratedDrivers (
|
|
VOID
|
|
);
|
|
#endif
|
|
|
|
BOOL
|
|
CallRunOnceAndWait();
|
|
|
|
BOOL
|
|
MarkPnpDevicesAsNeedReinstall(
|
|
);
|
|
|
|
ULONG
|
|
SyssetupGetPnPFlags(
|
|
IN HDEVINFO hDevInfo,
|
|
IN PSP_DEVINFO_DATA pDeviceInfoData,
|
|
IN PSP_DRVINFO_DATA pDriverInfoData
|
|
);
|
|
|
|
BOOL
|
|
IsInstalledInfFromOem(
|
|
IN PCWSTR InfFileName
|
|
);
|
|
|
|
BOOL
|
|
IsInfInLayoutInf(
|
|
IN PCWSTR InfFileName
|
|
);
|
|
|
|
|
|
#ifdef PNP_DEBUG_UI
|
|
VOID
|
|
FreeDevInfoSetList(
|
|
IN PDEVINFOSET_ELEMENT DevInfoSetList
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function frees each element of a device info set list.
|
|
|
|
Arguments:
|
|
|
|
DevInfoSetList - The array of info sets that is to be freed.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PDEVINFOSET_ELEMENT p, q;
|
|
|
|
p = DevInfoSetList;
|
|
while( p != NULL ) {
|
|
if( ( p->DevInfoSet != NULL ) &&
|
|
( p->DevInfoSet != INVALID_HANDLE_VALUE )
|
|
) {
|
|
SetupDiDestroyDeviceInfoList(p->DevInfoSet);
|
|
}
|
|
q = p->Next;
|
|
MyFree( p );
|
|
p = q;
|
|
}
|
|
}
|
|
#endif // PNP_DEBUG_UI
|
|
|
|
#ifdef PNP_DEBUG_UI
|
|
BOOL
|
|
AddDevInfoDataToDevInfoSet(
|
|
IN OUT PDEVINFOSET_ELEMENT* DevInfoSetList,
|
|
IN PSP_DEVINFO_DATA DeviceInfoData,
|
|
IN PWSTR DeviceId,
|
|
IN HWND hwndParent
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function adds a device info data to a device info set that contains
|
|
other device info data of the same GUID. If such info set doesn't exist,
|
|
then one is created, and it will be added to the array of info sets passed
|
|
as parameter.
|
|
|
|
Arguments:
|
|
|
|
DevInfoSetList - Pointer to the array of info sets. If this function creates
|
|
a new info set, then it will be added to this array.
|
|
|
|
|
|
DeviceInfoData - Device info data to be added to an info set that has elements
|
|
with the same GUID as the device info data.
|
|
|
|
|
|
DeviceId - Id of the device being added to an info set.
|
|
|
|
|
|
hwndParent - Handle to a top level window that may be used for UI purposes
|
|
|
|
|
|
Return Value:
|
|
|
|
BOOL - This function returns TRUE if the device info data was successfully added
|
|
to a device info set. Otherwise, it returns FALSE.
|
|
|
|
--*/
|
|
{
|
|
BOOL b;
|
|
HDEVINFO hDevInfo;
|
|
PDEVINFOSET_ELEMENT p;
|
|
|
|
for( p = *DevInfoSetList; p != NULL; p = p->Next ) {
|
|
//
|
|
// Find an info set, whose elements have the same GUID as the device
|
|
// that we want to add to the list.
|
|
//
|
|
if( IsEqualGUID( &(p->SetGuid), &(DeviceInfoData->ClassGuid) ) ) {
|
|
//
|
|
// If an info set was found, then add the device to the set.
|
|
//
|
|
if( !SetupDiOpenDeviceInfo( p->DevInfoSet,
|
|
DeviceId,
|
|
hwndParent,
|
|
DIOD_INHERIT_CLASSDRVS,
|
|
NULL ) ) {
|
|
|
|
SetupDebugPrint1( L"SETUP: SetupDiOpenDeviceInfo() failed. Error = %d", GetLastError() );
|
|
return( FALSE );
|
|
}
|
|
return( TRUE );
|
|
}
|
|
}
|
|
|
|
//
|
|
// If an info set was not foud, then create one.
|
|
//
|
|
if((hDevInfo = SetupDiCreateDeviceInfoList(&(DeviceInfoData->ClassGuid), hwndParent))
|
|
== INVALID_HANDLE_VALUE) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiCreateDeviceInfoList() failed. Error = %d", GetLastError );
|
|
return( FALSE );
|
|
}
|
|
|
|
//
|
|
// Add a device info to the info set
|
|
//
|
|
if( !SetupDiOpenDeviceInfo( hDevInfo,
|
|
DeviceId,
|
|
hwndParent,
|
|
DIOD_INHERIT_CLASSDRVS,
|
|
NULL ) ) {
|
|
|
|
SetupDebugPrint1( L"SETUP: SetupDiOpenDeviceInfo() failed. Error = %d", GetLastError() );
|
|
SetupDiDestroyDeviceInfoList(hDevInfo);
|
|
return( FALSE );
|
|
}
|
|
//
|
|
// Add the newly created info set to the info set list
|
|
//
|
|
p = MyMalloc( sizeof(DEVINFOSET_ELEMENT) );
|
|
if( p == NULL ) {
|
|
SetupDebugPrint( L"SETUP: Out of memory - AddDevInfoDataToDevInfoSet()" );
|
|
SetupDiDestroyDeviceInfoList(hDevInfo);
|
|
return( FALSE );
|
|
}
|
|
|
|
p->DevInfoSet = hDevInfo;
|
|
p->SetGuid = DeviceInfoData->ClassGuid;
|
|
p->Next = *DevInfoSetList;
|
|
*DevInfoSetList = p;
|
|
|
|
return( TRUE );
|
|
}
|
|
#endif // PNP_DEBUG_UI
|
|
|
|
UINT
|
|
pOemF6ScanQueueCallback(
|
|
PVOID Context,
|
|
UINT Notification,
|
|
UINT_PTR Param1,
|
|
UINT_PTR Param2
|
|
)
|
|
{
|
|
PFILEPATHS FilePaths = (PFILEPATHS)Param1;
|
|
|
|
//
|
|
// Add the Target filename to the list of files that Sfc should ignore when
|
|
// doing it's final scan at the end of GUI setup.
|
|
//
|
|
if (Notification == SPFILENOTIFY_QUEUESCAN_EX) {
|
|
if (FilePaths->Target) {
|
|
MultiSzAppendString(&EnumPtrSfcIgnoreFiles, FilePaths->Target);
|
|
}
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
void
|
|
AddOemF6DriversToSfcIgnoreFilesList(
|
|
IN HDEVINFO hDevInfo,
|
|
IN PSP_DEVINFO_DATA pDeviceInfoData
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
hDevInfo -
|
|
|
|
pDeviceInfoData -
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
HSPFILEQ FileQueue = INVALID_HANDLE_VALUE;
|
|
SP_DRVINFO_DATA DriverInfoData;
|
|
SP_DRVINSTALL_PARAMS DriverInstallParams;
|
|
SP_DEVINSTALL_PARAMS DeviceInstallParams;
|
|
DWORD ScanResult;
|
|
|
|
//
|
|
// First check that the selected driver that we just installed is an OEM F6
|
|
// driver.
|
|
//
|
|
DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
|
|
DriverInstallParams.cbSize = sizeof(SP_DRVINSTALL_PARAMS);
|
|
if (SetupDiGetSelectedDriver(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DriverInfoData) &&
|
|
SetupDiGetDriverInstallParams(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DriverInfoData,
|
|
&DriverInstallParams) &&
|
|
(DriverInstallParams.Flags & DNF_OEM_F6_INF)) {
|
|
//
|
|
// This is an OEM F6 driver.
|
|
//
|
|
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
if (!SetupDiGetDeviceInstallParams(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DeviceInstallParams)) {
|
|
goto clean0;
|
|
}
|
|
|
|
FileQueue = SetupOpenFileQueue();
|
|
|
|
if (FileQueue == INVALID_HANDLE_VALUE) {
|
|
goto clean0;
|
|
}
|
|
|
|
DeviceInstallParams.FileQueue = FileQueue;
|
|
DeviceInstallParams.Flags |= DI_NOVCP;
|
|
|
|
//
|
|
// Set the device install params to use our file queue and call
|
|
// DIF_INSTALLDEVICEFILES to build up a list of files for this device.
|
|
//
|
|
if (SetupDiSetDeviceInstallParams(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DeviceInstallParams) &&
|
|
SetupDiCallClassInstaller(DIF_INSTALLDEVICEFILES,
|
|
hDevInfo,
|
|
pDeviceInfoData)) {
|
|
SetupScanFileQueue(FileQueue,
|
|
SPQ_SCAN_USE_CALLBACKEX,
|
|
NULL,
|
|
pOemF6ScanQueueCallback,
|
|
NULL,
|
|
&ScanResult);
|
|
}
|
|
}
|
|
|
|
clean0:
|
|
|
|
if (FileQueue != INVALID_HANDLE_VALUE) {
|
|
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
if (SetupDiGetDeviceInstallParams(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DeviceInstallParams)) {
|
|
DeviceInstallParams.Flags &= ~DI_NOVCP;
|
|
DeviceInstallParams.FileQueue = INVALID_HANDLE_VALUE;
|
|
|
|
SetupDiSetDeviceInstallParams(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DeviceInstallParams);
|
|
}
|
|
|
|
SetupCloseFileQueue(FileQueue);
|
|
}
|
|
}
|
|
|
|
|
|
BOOL
|
|
GetClassGuidForInf(
|
|
IN PCTSTR InfFileName,
|
|
OUT LPGUID ClassGuid
|
|
)
|
|
{
|
|
TCHAR ClassName[MAX_CLASS_NAME_LEN];
|
|
DWORD NumGuids;
|
|
|
|
if(!SetupDiGetINFClass(InfFileName,
|
|
ClassGuid,
|
|
ClassName,
|
|
SIZECHARS(ClassName),
|
|
NULL)) {
|
|
return FALSE;
|
|
}
|
|
|
|
if(pSetupIsGuidNull(ClassGuid)) {
|
|
//
|
|
// Then we need to retrieve the GUID associated with the INF's class name.
|
|
// (If this class name isn't installed (i.e., has no corresponding GUID),
|
|
// or if it matches with multiple GUIDs, then we abort.
|
|
//
|
|
if(!SetupDiClassGuidsFromName(ClassName, ClassGuid, 1, &NumGuids) || !NumGuids) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
InstallPnpClassInstallers(
|
|
IN HWND hwndParent,
|
|
IN HINF InfHandle,
|
|
IN HSPFILEQ FileQ
|
|
)
|
|
{
|
|
INFCONTEXT InfContext;
|
|
UINT LineCount,LineNo;
|
|
PCWSTR SectionName = L"DeviceInfsToInstall";
|
|
PCWSTR IfExistsSectionName = L"DeviceInfsToInstallIfExists";
|
|
PCWSTR InfFileName;
|
|
GUID InfClassGuid;
|
|
HKEY hClassKey;
|
|
BOOL b = TRUE;
|
|
|
|
SC_HANDLE SCMHandle, ServiceHandle;
|
|
SERVICE_STATUS ServiceStatus;
|
|
|
|
|
|
//
|
|
// Before we do anything else, we have to make sure that the Plug&Play service is up and
|
|
// running, otherwise our ConfigMgr calls will fail, and we won't be able to migrate devices.
|
|
//
|
|
if(SCMHandle = OpenSCManager(NULL, NULL, GENERIC_READ)) {
|
|
|
|
if(ServiceHandle = OpenService(SCMHandle, L"PlugPlay", SERVICE_QUERY_STATUS)) {
|
|
|
|
while(TRUE) {
|
|
|
|
if(!QueryServiceStatus(ServiceHandle, &ServiceStatus)) {
|
|
//
|
|
// Couldn't find out the status of the Plug&Play service--hope for the best
|
|
// and trudge on ahead.
|
|
//
|
|
SetupDebugPrint1( L"SETUP: QueryServiceStatus() failed. Error = %d", GetLastError() );
|
|
SetupDebugPrint( L"SETUP: Couldn't find out the status of the Plug&Play service" );
|
|
break;
|
|
}
|
|
|
|
if(ServiceStatus.dwCurrentState == SERVICE_RUNNING) {
|
|
//
|
|
// The service is up and running, we can do our business.
|
|
//
|
|
break;
|
|
}
|
|
|
|
//
|
|
// The service hasn't started yet--print a message, then wait a second
|
|
// and try again.
|
|
//
|
|
SetupDebugPrint( L"SETUP: PlugPlay service isn't running yet--sleeping 1 second..." );
|
|
|
|
Sleep(1000);
|
|
}
|
|
|
|
CloseServiceHandle(ServiceHandle);
|
|
}
|
|
|
|
CloseServiceHandle(SCMHandle);
|
|
}
|
|
|
|
//
|
|
// Get the number of lines in the section that contains the infs whose
|
|
// classes are to be installed.
|
|
// The section may be empty or non-existant; this is not an error condition.
|
|
//
|
|
LineCount = (UINT)SetupGetLineCount(InfHandle,SectionName);
|
|
if((LONG)LineCount > 0) {
|
|
for(LineNo=0; LineNo<LineCount; LineNo++) {
|
|
if(SetupGetLineByIndex(InfHandle,SectionName,LineNo,&InfContext)
|
|
&& (InfFileName = pSetupGetField(&InfContext,1))) {
|
|
if( !SetupDiInstallClass( hwndParent,
|
|
InfFileName,
|
|
DI_NOVCP | DI_FORCECOPY,
|
|
FileQ ) ) {
|
|
SetupDebugPrint2( L"SETUP: SetupDiInstallClass() failed. Filename = %ls Error = %lx.", InfFileName, GetLastError() );
|
|
b = FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Get the number of lines in the section that contains the infs whose
|
|
// classes are to be installed if they already exist.
|
|
// The section may be empty or non-existant; this is not an error condition.
|
|
//
|
|
LineCount = (UINT)SetupGetLineCount(InfHandle,IfExistsSectionName);
|
|
if((LONG)LineCount > 0) {
|
|
for(LineNo=0; LineNo<LineCount; LineNo++) {
|
|
if(SetupGetLineByIndex(InfHandle,IfExistsSectionName,LineNo,&InfContext)
|
|
&& (InfFileName = pSetupGetField(&InfContext,1))) {
|
|
|
|
//
|
|
// Check to see if this section already exists in the registry
|
|
//
|
|
if (GetClassGuidForInf(InfFileName, &InfClassGuid)) {
|
|
|
|
if (CM_Open_Class_Key(&InfClassGuid,
|
|
NULL,
|
|
KEY_READ,
|
|
RegDisposition_OpenExisting,
|
|
&hClassKey,
|
|
CM_OPEN_CLASS_KEY_INSTALLER
|
|
) == CR_SUCCESS) {
|
|
|
|
RegCloseKey(hClassKey);
|
|
|
|
//
|
|
// This class already exists so we need to reinstall it
|
|
//
|
|
if( !SetupDiInstallClass( hwndParent,
|
|
InfFileName,
|
|
DI_NOVCP | DI_FORCECOPY,
|
|
FileQ ) ) {
|
|
SetupDebugPrint2( L"SETUP: SetupDiInstallClass() failed. Filename = %ls Error = %lx.", InfFileName, GetLastError() );
|
|
b = FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return( b );
|
|
}
|
|
|
|
|
|
ULONG
|
|
FindNumberOfElementsInInfoSet(
|
|
IN HDEVINFO hDevInfo
|
|
)
|
|
{
|
|
SP_DEVINFO_DATA DeviceInfoData;
|
|
ULONG Index;
|
|
ULONG Error;
|
|
|
|
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
|
|
for( Index = 0;
|
|
SetupDiEnumDeviceInfo( hDevInfo, Index, &DeviceInfoData );
|
|
Index++ );
|
|
if( ( Error = GetLastError() ) != ERROR_NO_MORE_ITEMS ) {
|
|
//
|
|
// We were enable to enumerated all devices in the info set.
|
|
// This should not have happened.
|
|
//
|
|
SetupDebugPrint2( L"SETUP: SetupDiEnumDeviceInfo() failed. Index = %d, Error = %d", Index, Error );
|
|
}
|
|
return( Index );
|
|
}
|
|
|
|
BOOL
|
|
FlushFilesToDisk(
|
|
IN PWSTR RootPath
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function flushes the cache of a particular drive, to disk.
|
|
|
|
Arguments:
|
|
|
|
Path to the root directory of the drive whose cache is to be flushed.
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE if the operation succeeds, or FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HANDLE RootHandle;
|
|
LONG Error;
|
|
|
|
//
|
|
// Enable backup privilege.
|
|
//
|
|
if( !PrivilegeAlreadySet ) {
|
|
PrivilegeAlreadySet = pSetupEnablePrivilege(SE_BACKUP_NAME,TRUE) && pSetupEnablePrivilege(SE_RESTORE_NAME,TRUE);
|
|
}
|
|
RootHandle = CreateFile( RootPath,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_FLAG_BACKUP_SEMANTICS,
|
|
0
|
|
);
|
|
if( RootHandle == INVALID_HANDLE_VALUE ) {
|
|
SetupDebugPrint2( L"SETUP: Failed to open %ls. Error = %d", RootPath, GetLastError() );
|
|
return( FALSE );
|
|
}
|
|
|
|
//
|
|
// Flush the cache
|
|
//
|
|
Error = ( FlushFileBuffers( RootHandle ) )? ERROR_SUCCESS : GetLastError();
|
|
CloseHandle( RootHandle );
|
|
if( Error != ERROR_SUCCESS ) {
|
|
SetupDebugPrint2( L"SETUP: FlushFileBuffers() failed. Root = %ls, Error = %d", RootPath, Error );
|
|
}
|
|
return( Error == ERROR_SUCCESS );
|
|
}
|
|
|
|
|
|
BOOL
|
|
SyssetupInstallNullDriver(
|
|
IN HDEVINFO hDevInfo,
|
|
IN PSP_DEVINFO_DATA pDeviceInfoData
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function installs a the null driver for a particular device.
|
|
|
|
Arguments:
|
|
|
|
hDevInfo -
|
|
|
|
pDeviceInfoData -
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE if the null driver was successfully installed.
|
|
|
|
--*/
|
|
|
|
{
|
|
SP_DEVINSTALL_PARAMS DeviceInstallParams;
|
|
DWORD Error;
|
|
PWSTR GUIDUnknownString = L"{4D36E97E-E325-11CE-BFC1-08002BE10318}";
|
|
|
|
Error = ERROR_SUCCESS;
|
|
|
|
//
|
|
// Find out if the GUID of this device is GUID_NULL.
|
|
// If it is then set it to GUID_DEVCLASS_UNKNOWN, so that after the sysstem is installed,
|
|
// the Device Manager can include this device in the device tree.
|
|
//
|
|
if(IsEqualGUID(&(pDeviceInfoData->ClassGuid), &GUID_NULL)) {
|
|
SetupDebugPrint( L"SETUP: Setting GUID_DEVCLASS_UNKNOWN for this device" );
|
|
if( !SetupDiSetDeviceRegistryProperty( hDevInfo,
|
|
pDeviceInfoData,
|
|
SPDRP_CLASSGUID,
|
|
(PBYTE)GUIDUnknownString,
|
|
(wcslen(GUIDUnknownString) + 1)*sizeof(WCHAR) ) ) {
|
|
Error = GetLastError();
|
|
if( ((LONG)Error) < 0 ) {
|
|
//
|
|
// Setupapi error code, display it in hex
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiSetDeviceRegistryProperty(SPDRP_CLASSGUID) failed. Error = %lx", Error );
|
|
} else {
|
|
//
|
|
// win32 error code, display it in decimal
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiSetDeviceRegistryProperty(SPDRP_CLASSGUID) failed. Error = %d", Error );
|
|
}
|
|
//
|
|
// In case of error we just ignore the error
|
|
//
|
|
Error = ERROR_SUCCESS;
|
|
}
|
|
} else {
|
|
WCHAR GUIDString[ 64 ];
|
|
|
|
pSetupStringFromGuid( &(pDeviceInfoData->ClassGuid), GUIDString, sizeof( GUIDString ) / sizeof( WCHAR ) );
|
|
SetupDebugPrint1( L"SETUP: GUID = %ls", GUIDString );
|
|
}
|
|
|
|
if( !SetupDiSetSelectedDriver( hDevInfo,
|
|
pDeviceInfoData,
|
|
NULL ) ) {
|
|
|
|
Error = GetLastError();
|
|
if( ((LONG)Error) < 0 ) {
|
|
//
|
|
// Setupapi error code, display it in hex
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiSetSelectedDriver() failed. Error = %lx", Error );
|
|
} else {
|
|
//
|
|
// win32 error code, display it in decimal
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiSetSelectedDriver() failed. Error = %d", Error );
|
|
}
|
|
return( FALSE );
|
|
}
|
|
|
|
//
|
|
// Let the class installer/co-installers know they should be quiet.
|
|
//
|
|
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
if( !SetupDiGetDeviceInstallParams( hDevInfo,
|
|
pDeviceInfoData,
|
|
&DeviceInstallParams ) ) {
|
|
Error = GetLastError();
|
|
if( ((LONG)Error) < 0 ) {
|
|
//
|
|
// Setupapi error code, display it in hex
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetDeviceInstallParams() failed. Error = %lx", Error );
|
|
} else {
|
|
//
|
|
// win32 error code, display it in decimal
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetDeviceInstallParams() failed. Error = %d", Error );
|
|
}
|
|
} else {
|
|
|
|
DeviceInstallParams.Flags |= DI_QUIETINSTALL;
|
|
DeviceInstallParams.FlagsEx |= DI_FLAGSEX_RESTART_DEVICE_ONLY;
|
|
|
|
if( !SetupDiSetDeviceInstallParams( hDevInfo,
|
|
pDeviceInfoData,
|
|
&DeviceInstallParams ) ) {
|
|
Error = GetLastError();
|
|
if( ((LONG)Error) < 0 ) {
|
|
//
|
|
// Setupapi error code, display it in hex
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiSetDeviceInstallParams() failed. Error = %lx", Error );
|
|
} else {
|
|
//
|
|
// win32 error code, display it in decimal
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiSetDeviceInstallParams() failed. Error = %d", Error );
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// First, attempt to install the null driver without setting DI_FLAGSEX_SETFAILEDINSTALL.
|
|
// Installation of LEGACY_* devices should succeed in this case.
|
|
//
|
|
// We do this through the class installer, in case it needs to clean-up
|
|
// turds from a previous installation (see RAID #266793).
|
|
//
|
|
if(SetupDiCallClassInstaller(DIF_INSTALLDEVICE,
|
|
hDevInfo,
|
|
pDeviceInfoData)) {
|
|
//
|
|
// Istallation succeeded.
|
|
//
|
|
return( TRUE );
|
|
}
|
|
|
|
Error = GetLastError();
|
|
if( ((LONG)Error) < 0 ) {
|
|
//
|
|
// Setupapi error code, display it in hex
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiCallClassInstaller(DIF_INSTALLDEVICE) failed on first attempt. Error = %lx", Error );
|
|
} else {
|
|
//
|
|
// win32 error code, display it in decimal
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiCallClassInstaller(DIF_INSTALLDEVICE) failed on first attempt. Error = %d", Error );
|
|
}
|
|
SetupDebugPrint( L"SETUP: Trying a second time with DI_FLAGSEX_SETFAILEDINSTALL set." );
|
|
|
|
//
|
|
// The first attempt to install the null driver (without setting DI_FLAGSEX_SETFAILEDINSTALL)
|
|
// failed.
|
|
// So we set the flag and try it again.
|
|
//
|
|
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
if( !SetupDiGetDeviceInstallParams( hDevInfo,
|
|
pDeviceInfoData,
|
|
&DeviceInstallParams ) ) {
|
|
Error = GetLastError();
|
|
if( ((LONG)Error) < 0 ) {
|
|
//
|
|
// Setupapi error code, display it in hex
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetDeviceInstallParams() failed. Error = %lx", Error );
|
|
} else {
|
|
//
|
|
// win32 error code, display it in decimal
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetDeviceInstallParams() failed. Error = %d", Error );
|
|
}
|
|
return( FALSE );
|
|
|
|
}
|
|
DeviceInstallParams.FlagsEx |= DI_FLAGSEX_SETFAILEDINSTALL;
|
|
if( !SetupDiSetDeviceInstallParams( hDevInfo,
|
|
pDeviceInfoData,
|
|
&DeviceInstallParams ) ) {
|
|
Error = GetLastError();
|
|
if( ((LONG)Error) < 0 ) {
|
|
//
|
|
// Setupapi error code, display it in hex
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiSetDeviceInstallParams() failed. Error = %lx", Error );
|
|
} else {
|
|
//
|
|
// win32 error code, display it in decimal
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiSetDeviceInstallParams() failed. Error = %d", Error );
|
|
}
|
|
return( FALSE );
|
|
}
|
|
|
|
if(!SetupDiCallClassInstaller(DIF_INSTALLDEVICE,
|
|
hDevInfo,
|
|
pDeviceInfoData)) {
|
|
|
|
Error = GetLastError();
|
|
if( ((LONG)Error) < 0 ) {
|
|
//
|
|
// Setupapi error code, display it in hex
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiCallClassInstaller(DIF_INSTALLDEVICE) failed. Error = %lx", Error );
|
|
} else {
|
|
//
|
|
// win32 error code, display it in decimal
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiCallClassInstaller(DIF_INSTALLDEVICE) failed. Error = %d", Error );
|
|
}
|
|
return( FALSE );
|
|
}
|
|
return( TRUE );
|
|
}
|
|
|
|
BOOL
|
|
RebuildListWithoutOldInternetDrivers(
|
|
IN HDEVINFO hDevInfo,
|
|
IN PSP_DEVINFO_DATA pDeviceInfoData
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function determins whether SetupDiBuildDriverInfoList will need to be
|
|
called again with the DI_FLAGSEX_EXCLUDE_OLD_INET_DRIVERS flag set. We first
|
|
call SetupDiBuildDriverInfoList without this flag to allow old Internet drivers
|
|
to be included in the best driver selection. If an old Internet driver is
|
|
selected as the best then we need to do a validity check to verify that all
|
|
the destination files are present on the system and correctly digitally signed.
|
|
If both of these are true then we can allow this old internet driver to stay
|
|
the best driver since it won't prompt for source files.
|
|
|
|
We need to do this for the case when a user is running a previous OS and they
|
|
get a better driver from Windows Update. We can't blindly replace the Windows
|
|
Update driver with the drivers in the new OS since they might not be better.
|
|
|
|
Arguments:
|
|
|
|
|
|
hDevInfo -
|
|
|
|
pDeviceInfoData -
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE if the list needs to be rebuilt with the DI_FLAGSEX_EXCLUDE_OLD_INET_DRIVERS
|
|
flag and FALSE otherwise.
|
|
|
|
Note if this API returns FALSE it either means the best driver was not an old
|
|
internet driver or that it was but all of it's destination files are present
|
|
and correctly digitally signed so no file copy will need to take place.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL RebuildList = FALSE;
|
|
SP_DRVINFO_DATA DriverInfoData;
|
|
SP_DRVINSTALL_PARAMS DriverInstallParams;
|
|
SP_DEVINSTALL_PARAMS DeviceInstallParams;
|
|
HSPFILEQ FileQueue = INVALID_HANDLE_VALUE;
|
|
DWORD ScanResult = 0;
|
|
|
|
DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
|
|
if (SetupDiGetSelectedDriver(hDevInfo, pDeviceInfoData, &DriverInfoData)) {
|
|
DriverInstallParams.cbSize = sizeof(SP_DRVINSTALL_PARAMS);
|
|
if (SetupDiGetDriverInstallParams(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DriverInfoData,
|
|
&DriverInstallParams
|
|
) &&
|
|
(DriverInstallParams.Flags & DNF_OLD_INET_DRIVER)) {
|
|
|
|
//
|
|
// At this point we know that the best driver is an old Internet driver.
|
|
// Now do a validity check which will verify all the source files are
|
|
// present and digitally signed. We will also assume we need to rebuild
|
|
// the list at this point unless we pass the validity check below.
|
|
//
|
|
RebuildList = TRUE;
|
|
|
|
FileQueue = SetupOpenFileQueue();
|
|
|
|
if (FileQueue != INVALID_HANDLE_VALUE) {
|
|
|
|
//
|
|
// Tell setupapi to use our file queue.
|
|
//
|
|
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
if (SetupDiGetDeviceInstallParams(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DeviceInstallParams
|
|
)) {
|
|
DeviceInstallParams.Flags |= DI_NOVCP;
|
|
DeviceInstallParams.FileQueue = FileQueue;
|
|
|
|
if (SetupDiSetDeviceInstallParams(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DeviceInstallParams
|
|
)) {
|
|
if (SetupDiCallClassInstaller(DIF_INSTALLDEVICEFILES,
|
|
hDevInfo,
|
|
pDeviceInfoData
|
|
) &&
|
|
SetupScanFileQueue(FileQueue,
|
|
SPQ_SCAN_FILE_VALIDITY,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&ScanResult
|
|
) &&
|
|
((ScanResult == 1) ||
|
|
(ScanResult == 2))) {
|
|
|
|
//
|
|
// if ScanResult is 1 or 2 then no copying needs to
|
|
// take place because all the destination files are
|
|
// in their place and digitally signed.
|
|
//
|
|
RebuildList = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Clear out the file queue handle from the device install params
|
|
// so that we can close the file queue.
|
|
//
|
|
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
if (SetupDiGetDeviceInstallParams(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DeviceInstallParams
|
|
)) {
|
|
DeviceInstallParams.Flags &= ~DI_NOVCP;
|
|
DeviceInstallParams.FileQueue = INVALID_HANDLE_VALUE;
|
|
|
|
SetupDiSetDeviceInstallParams(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DeviceInstallParams
|
|
);
|
|
}
|
|
|
|
SetupCloseFileQueue(FileQueue);
|
|
}
|
|
}
|
|
}
|
|
|
|
return RebuildList;
|
|
}
|
|
|
|
BOOL
|
|
pDoesExistingDriverNeedBackup(
|
|
IN HDEVINFO hDevInfo,
|
|
IN PSP_DEVINFO_DATA pDeviceInfoData,
|
|
IN PWSTR InfPath,
|
|
IN DWORD InfPathSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function determins whether the currently install driver needs to be
|
|
backed up or not. It does this by checking if the current driver is an
|
|
oem driver, and verifying that it is not the same as the new driver
|
|
we are about to install.
|
|
|
|
Arguments:
|
|
|
|
|
|
hDevInfo -
|
|
|
|
pDeviceInfoData -
|
|
|
|
Return Value:
|
|
|
|
TRUE if the current driver needs to be backed up, FALSE otherwise.
|
|
|
|
--*/
|
|
{
|
|
BOOL bBackupCurrentDriver = FALSE;
|
|
HKEY Key = INVALID_HANDLE_VALUE;
|
|
DWORD dwType, dwData;
|
|
SP_DRVINFO_DATA DriverInfoData;
|
|
SP_DRVINFO_DETAIL_DATA DriverInfoDetailData;
|
|
|
|
if (InfPath) {
|
|
InfPath[0] = TEXT('\0');
|
|
}
|
|
|
|
//
|
|
// Open the driver key for this device.
|
|
//
|
|
Key = SetupDiOpenDevRegKey ( hDevInfo,
|
|
pDeviceInfoData,
|
|
DICS_FLAG_GLOBAL,
|
|
0,
|
|
DIREG_DRV,
|
|
KEY_READ );
|
|
|
|
if (Key != INVALID_HANDLE_VALUE) {
|
|
//
|
|
// Get the 'InfPath' value from the registry.
|
|
//
|
|
dwType = REG_SZ;
|
|
dwData = InfPathSize;
|
|
if (RegQueryValueEx(Key,
|
|
REGSTR_VAL_INFPATH,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE)InfPath,
|
|
&dwData) == ERROR_SUCCESS) {
|
|
//
|
|
// Check if this is an oem inf
|
|
//
|
|
if (IsInstalledInfFromOem(InfPath)) {
|
|
//
|
|
// Retrieve the name of the INF associated with the selected driver
|
|
// node.
|
|
//
|
|
DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
|
|
if (SetupDiGetSelectedDriver(hDevInfo, pDeviceInfoData, &DriverInfoData)) {
|
|
DriverInfoDetailData.cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
|
|
if (SetupDiGetDriverInfoDetail(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DriverInfoData,
|
|
&DriverInfoDetailData,
|
|
sizeof(DriverInfoDetailData),
|
|
NULL) ||
|
|
(GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
|
|
//
|
|
// If the two INFs are not the same then this means we
|
|
// should backup the current drivers before installing
|
|
// the new drivers.
|
|
//
|
|
if (lstrcmpi(pSetupGetFileTitle(DriverInfoDetailData.InfFileName),
|
|
InfPath) != 0) {
|
|
bBackupCurrentDriver = TRUE;
|
|
}
|
|
|
|
} else {
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetDriverInfoDetail() failed. Error = %d", GetLastError() );
|
|
}
|
|
} else {
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetSelectedDriver() failed. Error = %d", GetLastError() );
|
|
}
|
|
}
|
|
}
|
|
|
|
RegCloseKey(Key);
|
|
}
|
|
|
|
return bBackupCurrentDriver;
|
|
}
|
|
|
|
BOOL
|
|
SelectBestDriver(
|
|
IN HDEVINFO hDevInfo,
|
|
IN PSP_DEVINFO_DATA pDeviceInfoData,
|
|
OUT PBOOL pbOemF6Driver
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function selects the best driver for the specified device.
|
|
It is assumed that SetupDiBuildDriverInfoList was called before calling
|
|
this API.
|
|
|
|
This API will first check the list of driver nodes for this device and
|
|
see if any have the DNF_OEM_F6_INF flag. If they do then this INF was
|
|
specified by the user during text mode setup by doing an F6. We always
|
|
want to use these drivers, even if they are not the 'best' according to
|
|
setupapi. If there are no drivers in the list with this flag then we
|
|
fall back to the default behavior of DIF_SELECTBESTCOMPATDRV.
|
|
|
|
Arguments:
|
|
|
|
|
|
hDevInfo -
|
|
|
|
pDeviceInfoData -
|
|
|
|
Return Value:
|
|
|
|
Returns the result SetupDiCallClassInstaller with DIF_SELECTBESTCOMPATDRV.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD index;
|
|
SP_DRVINFO_DATA DriverInfoData;
|
|
SP_DRVINSTALL_PARAMS DriverInstallParams;
|
|
BOOL bFoundOemF6Driver = FALSE;
|
|
|
|
*pbOemF6Driver = FALSE;
|
|
|
|
DriverInfoData.cbSize = sizeof(DriverInfoData);
|
|
index = 0;
|
|
|
|
//
|
|
// First go through the list of drivers and see if there is an OEM F6 driver
|
|
// in the list.
|
|
//
|
|
while (SetupDiEnumDriverInfo(hDevInfo,
|
|
pDeviceInfoData,
|
|
SPDIT_COMPATDRIVER,
|
|
index++,
|
|
&DriverInfoData
|
|
)) {
|
|
DriverInstallParams.cbSize = sizeof(SP_DRVINSTALL_PARAMS);
|
|
if (SetupDiGetDriverInstallParams(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DriverInfoData,
|
|
&DriverInstallParams
|
|
) &&
|
|
(DriverInstallParams.Flags & DNF_OEM_F6_INF)) {
|
|
|
|
bFoundOemF6Driver = TRUE;
|
|
SetupDebugPrint( L"SETUP: Using Oem F6 driver for this device." );
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we found an Oem driver that was specified by F6 during text mode setup,
|
|
// then we will go through the list again and mark all drivers that are
|
|
// not OEM F6 drivers and BAD drivers. This way when we call
|
|
// DIF_SELECTBESTCOMPATDRV it will only select from the OEM F6 drivers.
|
|
//
|
|
if (bFoundOemF6Driver) {
|
|
*pbOemF6Driver = TRUE;
|
|
|
|
DriverInfoData.cbSize = sizeof(DriverInfoData);
|
|
index = 0;
|
|
|
|
while (SetupDiEnumDriverInfo(hDevInfo,
|
|
pDeviceInfoData,
|
|
SPDIT_COMPATDRIVER,
|
|
index++,
|
|
&DriverInfoData
|
|
)) {
|
|
DriverInstallParams.cbSize = sizeof(SP_DRVINSTALL_PARAMS);
|
|
if (SetupDiGetDriverInstallParams(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DriverInfoData,
|
|
&DriverInstallParams
|
|
)) {
|
|
//
|
|
// If this driver node does not have the DNF_OEM_F6_INF flag
|
|
// then set the DNF_BAD_DRIVER flag so we will skip this
|
|
// driver later when we do DIF_SELECTBESTCOMPATDRV
|
|
//
|
|
if (!(DriverInstallParams.Flags & DNF_OEM_F6_INF)) {
|
|
DriverInstallParams.Flags |= DNF_BAD_DRIVER;
|
|
|
|
SetupDiSetDriverInstallParams(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DriverInfoData,
|
|
&DriverInstallParams
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (SetupDiCallClassInstaller( DIF_SELECTBESTCOMPATDRV,
|
|
hDevInfo,
|
|
pDeviceInfoData ) );
|
|
}
|
|
|
|
BOOL
|
|
SkipDeviceInstallation(
|
|
IN HDEVINFO hDevInfo,
|
|
IN PSP_DEVINFO_DATA pDeviceInfoData,
|
|
IN HINF InfHandle,
|
|
IN PCWSTR GUIDString
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function determines whether or not the installation of a particular device should be skipped.
|
|
It should be skipped if the following conditions are met:
|
|
- The device is already installed;
|
|
- The GUID for the device is listed in [InstalledDevicesToSkip], in syssetup.inf
|
|
|
|
Arguments:
|
|
|
|
|
|
hDevInfo -
|
|
|
|
pDeviceInfoData -
|
|
|
|
InfHandle - System setup inf handle (syssetup.inf).
|
|
|
|
GUIDString - GUID associated to the device being checked (in string format).
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE if the installation of the device should be skipped. Otherwise, it returns FALSE.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL DeviceAlreadyInstalled;
|
|
BOOL SafeClassInstaller = TRUE;
|
|
WCHAR PropertyBuffer[ MAX_PATH + 1 ];
|
|
HKEY Key;
|
|
|
|
//
|
|
// Attempt to open the dev node's driver key
|
|
//
|
|
Key = SetupDiOpenDevRegKey ( hDevInfo,
|
|
pDeviceInfoData,
|
|
DICS_FLAG_GLOBAL,
|
|
0,
|
|
DIREG_DRV,
|
|
MAXIMUM_ALLOWED );
|
|
if( Key == INVALID_HANDLE_VALUE ) {
|
|
DeviceAlreadyInstalled = FALSE;
|
|
SetupDebugPrint( L"SETUP: Device not yet installed." );
|
|
} else {
|
|
RegCloseKey( Key );
|
|
DeviceAlreadyInstalled = TRUE;
|
|
SetupDebugPrint( L"SETUP: Device already installed." );
|
|
}
|
|
|
|
//
|
|
// In the case of MiniSetup, we're not doing an
|
|
// upgrade, so all we care about is if the device is
|
|
// already installed.
|
|
//
|
|
if( MiniSetup ) {
|
|
return( DeviceAlreadyInstalled );
|
|
}
|
|
|
|
if( DeviceAlreadyInstalled ) {
|
|
//
|
|
// If the device is already installed, then check if the class installer for this
|
|
// device is considered safe.
|
|
//
|
|
SafeClassInstaller = !SetupGetLineText( NULL,
|
|
InfHandle,
|
|
L"InstalledDevicesToSkip",
|
|
GUIDString,
|
|
PropertyBuffer,
|
|
sizeof( PropertyBuffer )/sizeof( WCHAR ),
|
|
NULL );
|
|
}
|
|
|
|
return( DeviceAlreadyInstalled && !SafeClassInstaller );
|
|
}
|
|
|
|
|
|
BOOL
|
|
PrecompileInfFiles(
|
|
IN HWND ProgressWindow,
|
|
IN ULONG StartAtPercent,
|
|
IN ULONG StopAtPercent
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function precompiles all the infs in %SystemRoot%\inf.
|
|
and then builds the cache.
|
|
|
|
Arguments:
|
|
|
|
ProgressWindow - Handle to the progress bar.
|
|
|
|
StartAtPercent - Starting position in the progress bar.
|
|
It indicates that from position 0 to this position
|
|
the gauge is already filled.
|
|
|
|
StopAtPercent - Ending position of the progress bar.
|
|
The pnp thread should not fill the progress bar beyond
|
|
this position
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE if at least one inf was pre-compiled. Otherwise, returns FALSE.
|
|
|
|
--*/
|
|
|
|
{
|
|
WCHAR SavedDirectory[ MAX_PATH + 1 ];
|
|
WCHAR InfDirectory[ MAX_PATH + 1 ];
|
|
UINT GaugeRange;
|
|
BOOL AlwaysFalse = FALSE;
|
|
|
|
PINF_FILE_NAME InfList = NULL;
|
|
PINF_FILE_NAME p;
|
|
|
|
WIN32_FIND_DATA FindData;
|
|
HANDLE FindHandle;
|
|
ULONG InfCount;
|
|
ULONG i = 0;
|
|
DWORD Result;
|
|
|
|
SetupDebugPrint( L"SETUP: Entering PrecompileInfFiles()" );
|
|
|
|
//
|
|
// Save current directory
|
|
//
|
|
GetCurrentDirectory( sizeof(SavedDirectory)/sizeof(WCHAR), SavedDirectory );
|
|
|
|
//
|
|
// Change current directory to %SystemRoot%\inf
|
|
//
|
|
Result = GetWindowsDirectory( InfDirectory, sizeof(InfDirectory)/sizeof(WCHAR) );
|
|
if( Result == 0) {
|
|
MYASSERT(FALSE);
|
|
return FALSE;
|
|
}
|
|
wcscat( InfDirectory, L"\\inf" );
|
|
SetCurrentDirectory( InfDirectory );
|
|
|
|
|
|
//
|
|
// Find total number of inf files
|
|
//
|
|
InfCount = 0;
|
|
FindHandle = FindFirstFile( L"*.inf", &FindData );
|
|
if( FindHandle != INVALID_HANDLE_VALUE ) {
|
|
do {
|
|
//
|
|
// Skip directories
|
|
//
|
|
if( FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) {
|
|
continue;
|
|
}
|
|
p = MyMalloc( sizeof( INF_FILE_NAME ) ) ;
|
|
if( p != NULL ) {
|
|
p->InfName = pSetupDuplicateString( &FindData.cFileName[0] );
|
|
p->Next = InfList;
|
|
InfList = p;
|
|
InfCount++;
|
|
}
|
|
} while( FindNextFile( FindHandle, &FindData ) );
|
|
|
|
FindClose( FindHandle );
|
|
} else {
|
|
SetupDebugPrint1( L"SETUP: FindFirstFile( *.inf ) failed. Error = %d", GetLastError() );
|
|
}
|
|
|
|
//
|
|
// Initialize the gauge allow for pSetupInfCacheBuild step
|
|
//
|
|
GaugeRange = ((InfCount+1)*100/(StopAtPercent-StartAtPercent));
|
|
SendMessage(ProgressWindow, WMX_PROGRESSTICKS, (InfCount+1), 0);
|
|
SendMessage(ProgressWindow,PBM_SETRANGE,0,MAKELPARAM(0,GaugeRange));
|
|
SendMessage(ProgressWindow,PBM_SETPOS,GaugeRange*StartAtPercent/100,0);
|
|
SendMessage(ProgressWindow,PBM_SETSTEP,1,0);
|
|
|
|
//
|
|
// Prcompile each inf file
|
|
//
|
|
for( i = 0;
|
|
(
|
|
//
|
|
// Tick the gauge after we finished pre-compiling an inf.
|
|
// Note that we don't tick the gauge when i == 0 (no inf was yet processed),
|
|
// but we do tick the gauge when i == InfCount (all infs were pre-compiled).
|
|
// Note also that we use the flag AlwaysFalse, to enforce that all inf will be processed,
|
|
// even when SendMessage(PBM_SETPBIT) returns a non-zero value.
|
|
//
|
|
(i != 0) &&
|
|
SendMessage(ProgressWindow,PBM_STEPIT,0,0) &&
|
|
AlwaysFalse
|
|
) ||
|
|
(i < InfCount);
|
|
i++
|
|
) {
|
|
HINF hInf;
|
|
|
|
SetupDebugPrint1( L"SETUP: Pre-compiling file: %ls", InfList->InfName );
|
|
|
|
MYASSERT(InfList);
|
|
hInf = SetupOpenInfFile( InfList->InfName,
|
|
NULL,
|
|
INF_STYLE_WIN4,
|
|
NULL );
|
|
|
|
if( hInf != INVALID_HANDLE_VALUE ) {
|
|
SetupCloseInfFile( hInf );
|
|
} else {
|
|
DWORD Error;
|
|
|
|
Error = GetLastError();
|
|
if( ((LONG)Error) < 0 ) {
|
|
//
|
|
// Setupapi error code, display it in hex
|
|
//
|
|
SetupDebugPrint2( L"SETUP: SetupOpenInfFile() failed. FileName = %ls, Error = %lx", InfList->InfName, Error );
|
|
} else {
|
|
//
|
|
// win32 error code, display it in decimal
|
|
//
|
|
SetupDebugPrint2( L"SETUP: SetupOpenInfFile() failed. FileName = %ls, Error = %d", InfList->InfName, Error );
|
|
}
|
|
}
|
|
|
|
//
|
|
// The file name is no longer needed
|
|
//
|
|
p = InfList;
|
|
InfList = InfList->Next;
|
|
if( p->InfName != NULL ) {
|
|
MyFree( p->InfName );
|
|
}
|
|
MyFree( p );
|
|
}
|
|
|
|
SetupDebugPrint2( L"SETUP: Total inf files = %d, total precompiled: %d", InfCount, i );
|
|
SetupDebugPrint( L"SETUP: Calling pSetupInfCacheBuild()" );
|
|
|
|
pSetupInfCacheBuild(INFCACHEBUILD_REBUILD);
|
|
|
|
//
|
|
// Make sure that at this point, the gauge area is filled up to the end of
|
|
// the area reserved for the pre-compilation of inf files.
|
|
//
|
|
SendMessage(ProgressWindow,PBM_SETPOS,GaugeRange*StopAtPercent/100,0);
|
|
|
|
//
|
|
// Restore current directory
|
|
//
|
|
SetCurrentDirectory( SavedDirectory );
|
|
|
|
SetupDebugPrint( L"SETUP: Leaving PrecompileInfFiles()" );
|
|
|
|
return( i != 0 );
|
|
}
|
|
|
|
|
|
BOOL
|
|
InstallLegacyDevices(
|
|
IN HWND hwndParent,
|
|
IN HWND ProgressWindow,
|
|
IN ULONG StartAtPercent,
|
|
IN ULONG StopAtPercent
|
|
)
|
|
{
|
|
ULONG Index;
|
|
HDEVINFO hDevInfo = INVALID_HANDLE_VALUE;
|
|
SP_DEVINFO_DATA DeviceInfoData;
|
|
ULONG Error;
|
|
WCHAR GUIDString[ 64 ];
|
|
BOOL b = TRUE;
|
|
HSPFILEQ FileQ = INVALID_HANDLE_VALUE;
|
|
|
|
LPGUID GuidList = NULL;
|
|
ULONG GuidCount = 32;
|
|
ULONG GuidIndex;
|
|
ULONG LastBatchedDetect;
|
|
ULONG GuidLB, GuidUB;
|
|
HDEVINFO* InfoSetArray = NULL;
|
|
BOOL AlwaysFalse = FALSE;
|
|
UINT GaugeRange;
|
|
|
|
HANDLE ThreadHandle = NULL;
|
|
DWORD ThreadId;
|
|
PPNP_PHASE1_LEGACY_DEV_THREAD_PARAMS Phase1Context;
|
|
PPNP_PHASE2_LEGACY_DEV_THREAD_PARAMS Phase2Context;
|
|
WCHAR PnpLogPath[ MAX_PATH + 1 ];
|
|
WCHAR LoggedDescription[ LINE_LEN + 1 ];
|
|
DWORD ScanQueueResult;
|
|
SP_DRVINFO_DATA DriverInfoData;
|
|
ULONG PnPFlags;
|
|
DWORD Result;
|
|
|
|
|
|
SetupDebugPrint( L"SETUP: Entering InstallLegacyDevices()" );
|
|
|
|
//
|
|
// Build path to pnp log file
|
|
//
|
|
Result = GetWindowsDirectory( PnpLogPath, sizeof(PnpLogPath)/sizeof(WCHAR) );
|
|
if( Result == 0) {
|
|
MYASSERT(FALSE);
|
|
return FALSE;
|
|
}
|
|
pSetupConcatenatePaths( PnpLogPath, szPnpLogFile, sizeof(PnpLogPath)/sizeof(WCHAR), NULL );
|
|
|
|
//
|
|
// Do the migration of legacy devices.
|
|
// This is a quick operation and doesn't need to use the progress window.
|
|
//
|
|
// This is now performed before installation of true PnP devices
|
|
//
|
|
// PnPInitializationThread(NULL);
|
|
|
|
GuidList = ( LPGUID )MyMalloc( sizeof( GUID ) * GuidCount );
|
|
if( !GuidList ) {
|
|
return( FALSE );
|
|
}
|
|
|
|
if ( !SetupDiBuildClassInfoList( 0,
|
|
GuidList,
|
|
GuidCount,
|
|
&GuidCount ) ) {
|
|
Error = GetLastError();
|
|
if( Error != ERROR_INSUFFICIENT_BUFFER ) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiBuildClassInfoList() failed. Error = %d", Error );
|
|
MyFree( GuidList );
|
|
|
|
//
|
|
// Fill the gauge up to the end of the area reserved for legacy devices.
|
|
//
|
|
GaugeRange = 100;
|
|
SendMessage(ProgressWindow,PBM_SETRANGE,0,MAKELPARAM(0,GaugeRange));
|
|
SendMessage(ProgressWindow,PBM_SETPOS,GaugeRange*StopAtPercent/100,0);
|
|
SetupDebugPrint( L"SETUP: Leaving InstallLegacyDevices()" );
|
|
return( FALSE );
|
|
}
|
|
GuidList = ( LPGUID )MyRealloc( GuidList, sizeof( GUID ) * GuidCount );
|
|
|
|
if( !SetupDiBuildClassInfoList( 0,
|
|
GuidList,
|
|
GuidCount,
|
|
&GuidCount ) ) {
|
|
MyFree( GuidList );
|
|
SetupDebugPrint1( L"SETUP: SetupDiBuildClassInfoList() failed. Error = %d", Error );
|
|
|
|
//
|
|
// Fill the gauge up to the end of the area reserved for legacy devices.
|
|
//
|
|
GaugeRange = 100;
|
|
SendMessage(ProgressWindow,PBM_SETRANGE,0,MAKELPARAM(0,GaugeRange));
|
|
SendMessage(ProgressWindow,PBM_SETPOS,GaugeRange*StopAtPercent/100,0);
|
|
SetupDebugPrint( L"SETUP: Leaving InstallLegacyDevices()" );
|
|
return( FALSE );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Sort the class GUID list based on the detection ordering specified in syssetup.inf
|
|
//
|
|
SortClassGuidListForDetection(GuidList, GuidCount, &LastBatchedDetect);
|
|
|
|
InfoSetArray = (HDEVINFO*)MyMalloc( sizeof(HDEVINFO) * GuidCount );
|
|
|
|
|
|
//
|
|
// Initialize the gauge.
|
|
// Note that since we process the device classes twice (two big 'for
|
|
// loops'), we divide the area of the gauge reserved for the gauge
|
|
// reserved for the legacy devices in 2 pieces, one for each 'for loop'.
|
|
//
|
|
GaugeRange = (2*GuidCount*100/(StopAtPercent-StartAtPercent));
|
|
SendMessage(ProgressWindow, WMX_PROGRESSTICKS, 2*GuidCount, 0);
|
|
SendMessage(ProgressWindow,PBM_SETRANGE,0,MAKELPARAM(0,GaugeRange));
|
|
SendMessage(ProgressWindow,PBM_SETPOS,GaugeRange*StartAtPercent/100,0);
|
|
SendMessage(ProgressWindow,PBM_SETSTEP,1,0);
|
|
|
|
//
|
|
// On our first pass, we process all the detections that can be batched
|
|
// together. Then, on subsequent passes, we process any non-batchable
|
|
// detections individually...
|
|
//
|
|
for(GuidLB = 0, GuidUB = LastBatchedDetect; GuidLB < GuidCount; GuidLB = ++GuidUB) {
|
|
|
|
//
|
|
// First, create a file queue
|
|
//
|
|
FileQ = SetupOpenFileQueue();
|
|
if( FileQ == INVALID_HANDLE_VALUE ) {
|
|
SetupDebugPrint1( L"SETUP: Failed to create file queue. Error = %d", GetLastError() );
|
|
}
|
|
|
|
|
|
for( GuidIndex = GuidLB;
|
|
(
|
|
//
|
|
// Tick the gauge after we finished processing all the devices of a particular class.
|
|
// Note that we don't tick the gauge when GuidIndex == 0 (no device was yet processed),
|
|
// but we do tick the gauge when GuidIndex == GuidCount (all devices of the last class
|
|
// were processed).
|
|
// Note also that we use the flag AlwaysFalse, to enforce that all classes will be processed,
|
|
// even when SendMessage(PBM_SETPBIT) returns a non-zero value.
|
|
//
|
|
(GuidIndex != GuidLB) &&
|
|
SendMessage(ProgressWindow,PBM_STEPIT,0,0) &&
|
|
AlwaysFalse
|
|
) ||
|
|
(GuidIndex <= GuidUB);
|
|
GuidIndex++ ) {
|
|
|
|
HDEVINFO hEmptyDevInfo = INVALID_HANDLE_VALUE;
|
|
WCHAR ClassDescription[ LINE_LEN + 1 ];
|
|
|
|
InfoSetArray[ GuidIndex ] = INVALID_HANDLE_VALUE;
|
|
ClassDescription[0] = (WCHAR)'\0';
|
|
if( !SetupDiGetClassDescription( &GuidList[ GuidIndex ],
|
|
ClassDescription,
|
|
sizeof(ClassDescription)/sizeof(WCHAR),
|
|
NULL ) ) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetClassDescription() failed. Error = %lx", GetLastError() );
|
|
ClassDescription[0] = (WCHAR)'\0';
|
|
}
|
|
pSetupStringFromGuid( &GuidList[ GuidIndex ], GUIDString, sizeof( GUIDString ) / sizeof( WCHAR ) );
|
|
SetupDebugPrint1( L"SETUP: Installing legacy devices of class: %ls ", ClassDescription );
|
|
SetupDebugPrint2( L"SETUP: GuidIndex = %d, Guid = %ls", GuidIndex, GUIDString );
|
|
#ifndef DBG
|
|
//
|
|
// Check if this class of devices is listed as a bad class
|
|
//
|
|
LoggedDescription[0] = L'\0';
|
|
if( (GetPrivateProfileString( szLegacyClassesSection,
|
|
GUIDString,
|
|
L"",
|
|
LoggedDescription,
|
|
sizeof(LoggedDescription)/sizeof(WCHAR),
|
|
PnpLogPath ) != 0) &&
|
|
( wcslen( LoggedDescription ) != 0 )
|
|
) {
|
|
//
|
|
// Skip the installation of this class of devices
|
|
//
|
|
SetupDebugPrint1( L"SETUP: Skipping installation of devices of class: %ls", ClassDescription );
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// Start the thread that actually does the initial part of the installation of the legacy devices (DIF_FIRSTTIMESETUP)
|
|
//
|
|
|
|
Phase1Context = MyMalloc( sizeof( PNP_PHASE1_LEGACY_DEV_THREAD_PARAMS ) );
|
|
Phase1Context->hDevInfo = INVALID_HANDLE_VALUE;
|
|
Phase1Context->Guid = GuidList[ GuidIndex ];
|
|
Phase1Context->pClassDescription = pSetupDuplicateString(ClassDescription);
|
|
Phase1Context->hwndParent = hwndParent;
|
|
|
|
|
|
ThreadHandle = NULL;
|
|
ThreadHandle = CreateThread( NULL,
|
|
0,
|
|
pPhase1InstallPnpLegacyDevicesThread,
|
|
Phase1Context,
|
|
0,
|
|
&ThreadId );
|
|
if(ThreadHandle) {
|
|
DWORD WaitResult;
|
|
DWORD ExitCode;
|
|
BOOL KeepWaiting;
|
|
|
|
KeepWaiting = TRUE;
|
|
|
|
while( KeepWaiting ) {
|
|
int Result;
|
|
|
|
//
|
|
// REVIEW 2000/11/08 seanch - Old behavior that we don't want to regress.
|
|
// Fix the network timeout after the network guys fix their class installer
|
|
//
|
|
WaitResult = WaitForSingleObject( ThreadHandle,
|
|
(_wcsicmp( GUIDString, BB_NETWORK_GUID_STRING ) == 0)? BB_PNP_NETWORK_TIMEOUT :
|
|
PNP_LEGACY_PHASE1_TIMEOUT );
|
|
if( WaitResult == WAIT_TIMEOUT ) {
|
|
HANDLE hDialogEvent;
|
|
|
|
if( hDialogEvent = OpenEvent( EVENT_MODIFY_STATE, FALSE, SETUP_HAS_OPEN_DIALOG_EVENT ) ) {
|
|
//
|
|
// Setupapi is prompting the user for a file. Don't timeout.
|
|
//
|
|
CloseHandle( hDialogEvent );
|
|
KeepWaiting = TRUE;
|
|
continue;
|
|
} else {
|
|
}
|
|
|
|
//
|
|
// Class installer is hung
|
|
//
|
|
SetupDebugPrint1( L"SETUP: Class Installer appears to be hung (phase1). ClassDescription = %ls", ClassDescription );
|
|
|
|
#ifdef PRERELEASE
|
|
//
|
|
// Ask the user if he wants to skip the installation of this class of devices
|
|
//
|
|
if( !Unattended ) {
|
|
Result = MessageBoxFromMessage( hwndParent,
|
|
MSG_CLASS_INSTALLER_HUNG_FIRSTTIMESETUP,
|
|
NULL,
|
|
IDS_WINNT_SETUP,
|
|
MB_YESNO | MB_ICONWARNING,
|
|
ClassDescription );
|
|
} else {
|
|
Result = IDYES;
|
|
}
|
|
#else
|
|
Result = IDYES;
|
|
#endif
|
|
|
|
if(Result == IDYES) {
|
|
//
|
|
// User wants to skip this class of devices.
|
|
// First find out if the thread has already returned.
|
|
//
|
|
WaitResult = WaitForSingleObject( ThreadHandle, 0 );
|
|
if( WaitResult != WAIT_OBJECT_0 ) {
|
|
//
|
|
// Thread hasn't returned yet. Skip the installation of this class of devices
|
|
//
|
|
KeepWaiting = FALSE;
|
|
SetupDebugPrint1( L"SETUP: Skipping installation of legacy devices of class: %ls", ClassDescription );
|
|
b = FALSE;
|
|
//
|
|
// Remember this class so that it won't be installed if GUI setup is
|
|
// restarted
|
|
//
|
|
WritePrivateProfileString( szLegacyClassesSection,
|
|
GUIDString,
|
|
ClassDescription,
|
|
PnpLogPath );
|
|
} else{
|
|
//
|
|
// Thread has already returned.
|
|
// There is no need to skip the installation of this class of devices.
|
|
// We assume that the user decided not to skip the installation of this class,
|
|
// and next call to WaitForSingleObject will immediately return.
|
|
//
|
|
}
|
|
}
|
|
} else if( WaitResult == WAIT_OBJECT_0 ) {
|
|
//
|
|
// Device Installation Thread completed.
|
|
//
|
|
KeepWaiting = FALSE;
|
|
if( GetExitCodeThread( ThreadHandle, &ExitCode ) ) {
|
|
if( ExitCode == ERROR_SUCCESS ) {
|
|
//
|
|
// The installation was successful
|
|
//
|
|
InfoSetArray[ GuidIndex ] = Phase1Context->hDevInfo;
|
|
} else {
|
|
//
|
|
// The installation was not successful.
|
|
// There is no need to log the error, since the thread has already done it.
|
|
//
|
|
b = FALSE;
|
|
}
|
|
} else {
|
|
//
|
|
// Unable to retrieve exit code. Assume success.
|
|
//
|
|
InfoSetArray[ GuidIndex ] = Phase1Context->hDevInfo;
|
|
SetupDebugPrint1( L"SETUP: GetExitCode() failed. Error = %d", GetLastError() );
|
|
SetupDebugPrint( L"SETUP: Unable to retrieve thread exit code. Assuming devices successfully installed (phase1)." );
|
|
}
|
|
//
|
|
// Deallocate all the memory that was passed to the thread.
|
|
//
|
|
MyFree(Phase1Context->pClassDescription);
|
|
MyFree(Phase1Context);
|
|
|
|
} else {
|
|
//
|
|
// Should not occur.
|
|
// In this case we don't deallocate any memory, since the thread may be running.
|
|
//
|
|
KeepWaiting = FALSE;
|
|
SetupDebugPrint1( L"SETUP: WaitForSingleObject() returned %d", WaitResult );
|
|
b = FALSE;
|
|
}
|
|
}
|
|
//
|
|
// The thread handle is no longer needed at this point
|
|
//
|
|
CloseHandle(ThreadHandle);
|
|
|
|
} else {
|
|
//
|
|
// Just do it synchronously.
|
|
//
|
|
Error = GetLastError();
|
|
SetupDebugPrint1( L"SETUP: CreateThread() failed (phase1). Error = %d", Error );
|
|
if( pPhase1InstallPnpLegacyDevicesThread(Phase1Context) != ERROR_SUCCESS ) {
|
|
//
|
|
// The installation was not successful.
|
|
// There is no need to log the error, since the thread has already done it.
|
|
//
|
|
b = FALSE;
|
|
} else {
|
|
InfoSetArray[ GuidIndex ] = Phase1Context->hDevInfo;
|
|
}
|
|
//
|
|
// Deallocate the memory passed as argument
|
|
//
|
|
MyFree( Phase1Context->pClassDescription );
|
|
MyFree( Phase1Context );
|
|
}
|
|
|
|
//
|
|
// Find out if we should install devices of this class.
|
|
//
|
|
if( InfoSetArray[ GuidIndex ] == INVALID_HANDLE_VALUE ) {
|
|
//
|
|
// If we should not install this class of devices, then go process the next class.
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Now enumerate each device information element added to this set, registering
|
|
// and then installing the files for each one.
|
|
//
|
|
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
|
|
for( Index = 0;
|
|
SetupDiEnumDeviceInfo( InfoSetArray[ GuidIndex ], Index, &DeviceInfoData );
|
|
Index++ ) {
|
|
WCHAR DevInstId[ MAX_DEVICE_ID_LEN ];
|
|
|
|
Error = ERROR_SUCCESS;
|
|
|
|
//
|
|
// Make sure the device is marked as 'Do not install'
|
|
//
|
|
if( !pSetupDiSetDeviceInfoContext( InfoSetArray[ GuidIndex ], &DeviceInfoData, FALSE ) ) {
|
|
SetupDebugPrint2( L"SETUP: pSetupDiSetDeviceInfoContext() failed. Error = %lx, Index = %d", GetLastError(), Index );
|
|
}
|
|
|
|
//
|
|
// Retrieve the string id for this device
|
|
//
|
|
DevInstId[0] = L'\0';
|
|
if( !SetupDiGetDeviceInstanceId( InfoSetArray[ GuidIndex ],
|
|
&DeviceInfoData,
|
|
DevInstId,
|
|
sizeof( DevInstId ) / sizeof( WCHAR ),
|
|
NULL ) ) {
|
|
SetupDebugPrint2( L"SETUP: Index = %d, SetupDiGetDeviceInstanceId() failed. Error = ", Index, GetLastError() );
|
|
|
|
}
|
|
#ifndef DBG
|
|
//
|
|
// Find out if this device is marked as a bad device
|
|
//
|
|
LoggedDescription[0] = L'\0';
|
|
if( (GetPrivateProfileString( szLegacyClassesSection,
|
|
DevInstId,
|
|
L"",
|
|
LoggedDescription,
|
|
sizeof(LoggedDescription)/sizeof(WCHAR),
|
|
PnpLogPath ) != 0) &&
|
|
( wcslen( LoggedDescription ) != 0 )
|
|
) {
|
|
//
|
|
// Skip the installation of this device
|
|
//
|
|
SetupDebugPrint1( L"SETUP: Skipping installation of legacy device: %ls", DevInstId );
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
|
|
SetupDebugPrint2( L"SETUP: Index = %d, DeviceId = %ls", Index, DevInstId );
|
|
|
|
Phase2Context = MyMalloc( sizeof( PNP_PHASE2_LEGACY_DEV_THREAD_PARAMS ) );
|
|
Phase2Context->hDevInfo = InfoSetArray[ GuidIndex ];
|
|
Phase2Context->FileQ = FileQ;
|
|
Phase2Context->DeviceInfoData = DeviceInfoData;
|
|
Phase2Context->pClassDescription = pSetupDuplicateString(ClassDescription);
|
|
Phase2Context->pDeviceId = pSetupDuplicateString(DevInstId);
|
|
|
|
ThreadHandle = NULL;;
|
|
ThreadHandle = CreateThread( NULL,
|
|
0,
|
|
pPhase2InstallPnpLegacyDevicesThread,
|
|
Phase2Context,
|
|
0,
|
|
&ThreadId );
|
|
if( ThreadHandle ) {
|
|
DWORD WaitResult;
|
|
DWORD ExitCode;
|
|
BOOL KeepWaiting;
|
|
|
|
KeepWaiting = TRUE;
|
|
while( KeepWaiting ) {
|
|
//
|
|
// REVIEW 2000/11/08 seanch - Old behavior that we don't want to regress.
|
|
// Fix the network timeout after the network guys fix their class installer
|
|
//
|
|
WaitResult = WaitForSingleObject( ThreadHandle,
|
|
(_wcsicmp( GUIDString, BB_NETWORK_GUID_STRING ) == 0)? BB_PNP_NETWORK_TIMEOUT :
|
|
PNP_LEGACY_PHASE2_TIMEOUT );
|
|
if( WaitResult == WAIT_TIMEOUT ) {
|
|
int Result;
|
|
HANDLE hDialogEvent;
|
|
|
|
if( hDialogEvent = OpenEvent( EVENT_MODIFY_STATE, FALSE, SETUP_HAS_OPEN_DIALOG_EVENT ) ) {
|
|
//
|
|
// Setupapi is prompting the user for a file. Don't timeout.
|
|
//
|
|
CloseHandle( hDialogEvent );
|
|
KeepWaiting = TRUE;
|
|
continue;
|
|
} else {
|
|
}
|
|
|
|
//
|
|
// Class installer is hung
|
|
//
|
|
SetupDebugPrint1( L"SETUP: Class Installer appears to be hung (phase2). DeviceId = %ls", DevInstId );
|
|
|
|
#ifdef PRERELEASE
|
|
//
|
|
// Ask the user if he wants to skip the installation of this device
|
|
//
|
|
if( !Unattended ) {
|
|
Result = MessageBoxFromMessage( hwndParent,
|
|
MSG_CLASS_INSTALLER_HUNG,
|
|
NULL,
|
|
IDS_WINNT_SETUP,
|
|
MB_YESNO | MB_ICONWARNING,
|
|
DevInstId );
|
|
} else {
|
|
Result = IDYES;
|
|
}
|
|
#else
|
|
Result = IDYES;
|
|
#endif
|
|
|
|
if(Result == IDYES) {
|
|
//
|
|
// User wants to skip this class of devices.
|
|
// First find out if the thread has already returned.
|
|
//
|
|
WaitResult = WaitForSingleObject( ThreadHandle, 0 );
|
|
if( WaitResult != WAIT_OBJECT_0 ) {
|
|
//
|
|
// Thread hasn't returned yet. Skip the installation of this device
|
|
//
|
|
KeepWaiting = FALSE;
|
|
SetupDebugPrint1( L"SETUP: Skipping installation of legacy device (phase2). Device = %ls", DevInstId );
|
|
b = FALSE;
|
|
//
|
|
// Remember this device so that it won't be installed if GUI setup is
|
|
// restarted
|
|
//
|
|
WritePrivateProfileString( szLegacyDevSection,
|
|
DevInstId,
|
|
ClassDescription,
|
|
PnpLogPath );
|
|
} else{
|
|
//
|
|
// Thread has already returned.
|
|
// There is no need to skip the installation of this device.
|
|
// We assume that the user decided not to skip the installation of this device,
|
|
// and next call to WaitForSingleObject will immediately return.
|
|
//
|
|
}
|
|
}
|
|
|
|
} else if( WaitResult == WAIT_OBJECT_0 ) {
|
|
//
|
|
// Device Installation Thread completed.
|
|
// Find out the outcome of this phase of the installation.
|
|
//
|
|
KeepWaiting = FALSE;
|
|
if( GetExitCodeThread( ThreadHandle, &ExitCode ) ) {
|
|
if( ExitCode ) {
|
|
//
|
|
// The installation was successful
|
|
//
|
|
} else {
|
|
//
|
|
// The installation was not successful.
|
|
// There is no need to log the error, since the thread has already done it.
|
|
//
|
|
b = FALSE;
|
|
}
|
|
} else {
|
|
//
|
|
// Unable to retrieve exit code. Assume success.
|
|
//
|
|
SetupDebugPrint1( L"SETUP: GetExitCode() failed. Error = %d", GetLastError() );
|
|
SetupDebugPrint( L"SETUP: Unable to retrieve thread exit code. Assuming device successfully installed (phase2)." );
|
|
}
|
|
//
|
|
// Deallocate the memory passed to the thread.
|
|
//
|
|
MyFree(Phase2Context->pClassDescription);
|
|
MyFree(Phase2Context->pDeviceId);
|
|
MyFree(Phase2Context);
|
|
|
|
} else {
|
|
//
|
|
// Should not occur.
|
|
// In this case we do not deallocate the memory passed to the thread, since the thread may be running.
|
|
//
|
|
KeepWaiting = FALSE;
|
|
SetupDebugPrint1( L"SETUP: WaitForSingleObject() returned %d", WaitResult );
|
|
b = FALSE;
|
|
}
|
|
}
|
|
//
|
|
// The thread handle is no longer needed at this point
|
|
//
|
|
CloseHandle(ThreadHandle);
|
|
|
|
} else {
|
|
//
|
|
// Unable to create the thread. Just do it syncronously
|
|
//
|
|
Error = GetLastError();
|
|
SetupDebugPrint1( L"SETUP: CreateThread() failed (phase2). Error = %d", Error );
|
|
if( !pPhase2InstallPnpLegacyDevicesThread(Phase2Context) ) {
|
|
//
|
|
// The installation was not successful.
|
|
// There is no need to log the error, since the thread has already done it.
|
|
//
|
|
SetupDebugPrint( L"SETUP: Device not successfully installed (phase2)." );
|
|
b = FALSE;
|
|
|
|
}
|
|
//
|
|
// Deallocate the memory that was passed as argument.
|
|
//
|
|
MyFree( Phase2Context->pClassDescription );
|
|
MyFree( Phase2Context->pDeviceId );
|
|
MyFree( Phase2Context );
|
|
}
|
|
}
|
|
//
|
|
// Find out why SetupDiEnumDeviceInfo() failed.
|
|
//
|
|
Error = GetLastError();
|
|
if( Error != ERROR_NO_MORE_ITEMS ) {
|
|
SetupDebugPrint2( L"SETUP: Device = %d, SetupDiEnumDeviceInfo() failed. Error = %d", Index, Error );
|
|
b = FALSE;
|
|
} else {
|
|
if( Index == 0 ) {
|
|
SetupDebugPrint1( L"SETUP: DeviceInfoSet is empty. ClassDescription = %ls", ClassDescription );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// If the file queue exists, then commit it.
|
|
//
|
|
if( FileQ != INVALID_HANDLE_VALUE ) {
|
|
PVOID Context;
|
|
|
|
//
|
|
// Commit file queue
|
|
//
|
|
if(Context = InitSysSetupQueueCallbackEx(hwndParent,
|
|
INVALID_HANDLE_VALUE,
|
|
0,
|
|
0,
|
|
NULL)) {
|
|
|
|
WCHAR RootPath[ MAX_PATH + 1];
|
|
|
|
if(!SetupScanFileQueue(
|
|
FileQ,
|
|
SPQ_SCAN_FILE_VALIDITY |
|
|
SPQ_SCAN_PRUNE_COPY_QUEUE |
|
|
SPQ_SCAN_PRUNE_DELREN,
|
|
hwndParent,
|
|
NULL,
|
|
NULL,
|
|
&ScanQueueResult)) {
|
|
//
|
|
// SetupScanFileQueue should really never
|
|
// fail when you don't ask it to call a
|
|
// callback routine, but if it does, just
|
|
// go ahead and commit the queue.
|
|
//
|
|
ScanQueueResult = 0;
|
|
}
|
|
|
|
|
|
if( ScanQueueResult != 1 ){
|
|
|
|
if( !SetupCommitFileQueue(hwndParent,FileQ,SysSetupQueueCallback,Context) ) {
|
|
b = FALSE;
|
|
}
|
|
}
|
|
TermSysSetupQueueCallback(Context);
|
|
GetWindowsDirectory(RootPath,sizeof(RootPath)/sizeof(WCHAR));
|
|
RootPath[3] = L'\0';
|
|
FlushFilesToDisk( RootPath );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now that the files were already copied, call the class installer
|
|
// with DIF_INSTALLDEVICE so that we can complete the installation
|
|
// of the device.
|
|
//
|
|
for( GuidIndex = GuidLB;
|
|
(
|
|
//
|
|
// Tick the gauge after we finished processing all the devices of a particular class.
|
|
// Note that we don't tick the gauge when GuidIndex == 0 (no device was yet processed),
|
|
// but we do tick the gauge when GuidIndex == GuidCount (all devices of the last class
|
|
// were processed).
|
|
// Note also that we use the flag AlwaysFalse, to enforce that all classes will be processed,
|
|
// even when SendMessage(PBM_SETPBIT) returns a non-zero value.
|
|
//
|
|
(GuidIndex != GuidLB) &&
|
|
SendMessage(ProgressWindow,PBM_STEPIT,0,0) &&
|
|
AlwaysFalse
|
|
) ||
|
|
(GuidIndex <= GuidUB);
|
|
GuidIndex++ ) {
|
|
|
|
SP_DEVINFO_DATA TempDeviceInfoData;
|
|
|
|
if( InfoSetArray[ GuidIndex ] == INVALID_HANDLE_VALUE ) {
|
|
continue;
|
|
}
|
|
//
|
|
// REVIEW 2000/11/08 seanch - Old behavior that we don't want to regress.
|
|
// Remove the line below after the network guys fix their class installer
|
|
//
|
|
pSetupStringFromGuid( &GuidList[ GuidIndex ], GUIDString, sizeof( GUIDString ) / sizeof( WCHAR ) );
|
|
|
|
TempDeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
|
|
for( Index = 0; SetupDiEnumDeviceInfo( InfoSetArray[ GuidIndex ], Index, &TempDeviceInfoData ); Index++ ) {
|
|
WCHAR DevInstId[ MAX_DEVICE_ID_LEN ];
|
|
DWORD InstallDevice;
|
|
SP_DEVINSTALL_PARAMS DeviceInstallParams;
|
|
PPNP_PHASE3_LEGACY_DEV_THREAD_PARAMS Phase3Context;
|
|
#ifdef PNP_DEBUG_UI
|
|
BOOL DeviceSuccessfullyInstalled;
|
|
#endif
|
|
|
|
//
|
|
// Retrieve the string id for this device
|
|
//
|
|
DevInstId[0] = L'\0';
|
|
if( !SetupDiGetDeviceInstanceId( InfoSetArray[ GuidIndex ],
|
|
&TempDeviceInfoData,
|
|
DevInstId,
|
|
sizeof( DevInstId ) / sizeof( WCHAR ),
|
|
NULL ) ) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetDeviceInstanceId() failed. Error = ", GetLastError() );
|
|
}
|
|
|
|
//
|
|
// Find out if we need to call DIF_INSTALLDEVICE for this device
|
|
//
|
|
InstallDevice = 0;
|
|
if( !pSetupDiGetDeviceInfoContext( InfoSetArray[ GuidIndex ], &TempDeviceInfoData, &InstallDevice ) ) {
|
|
SetupDebugPrint2( L"SETUP: pSetupDiSetDeviceInfoContext() failed. Error = %lx, DeviceId = %ls ", GetLastError(), DevInstId );
|
|
continue;
|
|
}
|
|
if( !InstallDevice ) {
|
|
//
|
|
// No need to install the device
|
|
//
|
|
SetupDebugPrint1( L"SETUP: Skipping device. DeviceId = %ls ", DevInstId );
|
|
continue;
|
|
}
|
|
|
|
#ifndef DBG
|
|
//
|
|
// Find out if this device is marked as a bad device
|
|
//
|
|
LoggedDescription[0] = L'\0';
|
|
if( (GetPrivateProfileString( szLegacyClassesSection,
|
|
DevInstId,
|
|
L"",
|
|
LoggedDescription,
|
|
sizeof(LoggedDescription)/sizeof(WCHAR),
|
|
PnpLogPath ) != 0) &&
|
|
( wcslen( LoggedDescription ) != 0 )
|
|
) {
|
|
//
|
|
// Skip the installation of this device
|
|
//
|
|
SetupDebugPrint1( L"SETUP: Skipping installation of legacy device: %ls", DevInstId );
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// Retrieve information about the driver node selected above.
|
|
//
|
|
DriverInfoData.cbSize = sizeof( SP_DRVINFO_DATA );
|
|
if( !SetupDiGetSelectedDriver( InfoSetArray[ GuidIndex ],
|
|
&TempDeviceInfoData,
|
|
&DriverInfoData ) ) {
|
|
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetSelectedDriver() failed. Error = %d", GetLastError() );
|
|
b = FALSE;
|
|
continue;
|
|
|
|
}
|
|
|
|
//
|
|
// Retrieve syssetup PnP flags (if any) the INF specifies for this
|
|
// device.
|
|
//
|
|
PnPFlags = SyssetupGetPnPFlags(InfoSetArray[ GuidIndex ],
|
|
&TempDeviceInfoData,
|
|
&DriverInfoData
|
|
);
|
|
|
|
SetupDebugPrint3( L"SETUP: Installing device: %ls, GuidIndex = %d, Index = %d", DevInstId, GuidIndex, Index );
|
|
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
if(!SetupDiGetDeviceInstallParams(InfoSetArray[ GuidIndex ], &TempDeviceInfoData, &DeviceInstallParams)) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetDeviceInstallParams() failed. Error = %d", GetLastError() );
|
|
b = FALSE;
|
|
continue;
|
|
}
|
|
|
|
DeviceInstallParams.Flags &= ~DI_FORCECOPY;
|
|
DeviceInstallParams.Flags &= ~DI_NOVCP;
|
|
DeviceInstallParams.Flags |= DI_NOFILECOPY;
|
|
DeviceInstallParams.FileQueue = NULL;
|
|
|
|
if(PnPFlags & PNPFLAG_DONOTCALLCONFIGMG) {
|
|
//
|
|
// We _do not_ honor this flag for devices reported via
|
|
// DIF_FIRSTTIMESETUP. The intent of this flag is to
|
|
// prevent us from perturbing correctly-functioning devices
|
|
// and potentially causing problems (e.g., moving PCI
|
|
// bridges or COM ports off of their boot configs). This
|
|
// concern does not apply to legacy-detected devnodes. We
|
|
// definitely _do_ want to bring these devices on-line now,
|
|
// or else devices attached to them (whether PnP or legacy)
|
|
// won't be found and installed.
|
|
//
|
|
SetupDebugPrint( L"SETUP: Clearing PNPFLAG_DONOTCALLCONFIGMG since this is a detected device." );
|
|
|
|
PnPFlags &= ~PNPFLAG_DONOTCALLCONFIGMG;
|
|
}
|
|
|
|
if(!SetupDiSetDeviceInstallParams(InfoSetArray[ GuidIndex ], &TempDeviceInfoData, &DeviceInstallParams)) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiSetDeviceInstallParams() failed. Error = %d", GetLastError() );
|
|
b = FALSE;
|
|
continue;
|
|
}
|
|
|
|
Phase3Context = MyMalloc( sizeof( PNP_PHASE3_LEGACY_DEV_THREAD_PARAMS ) );
|
|
Phase3Context->hDevInfo = InfoSetArray[ GuidIndex ];
|
|
Phase3Context->DeviceInfoData = TempDeviceInfoData;
|
|
Phase3Context->pDeviceId = pSetupDuplicateString( DevInstId );
|
|
|
|
#ifdef PNP_DEBUG_UI
|
|
DeviceSuccessfullyInstalled = FALSE;
|
|
#endif
|
|
ThreadHandle = NULL;
|
|
ThreadHandle = CreateThread( NULL,
|
|
0,
|
|
pPhase3InstallPnpLegacyDevicesThread,
|
|
Phase3Context,
|
|
0,
|
|
&ThreadId );
|
|
if( ThreadHandle ) {
|
|
DWORD WaitResult;
|
|
DWORD ExitCode;
|
|
BOOL KeepWaiting;
|
|
|
|
KeepWaiting = TRUE;
|
|
while( KeepWaiting ) {
|
|
//
|
|
// REVIEW 2000/11/08 seanch - Old behavior that we don't want to regress.
|
|
// Fix the network timeout after the network guys fix their class installer
|
|
//
|
|
WaitResult = WaitForSingleObject( ThreadHandle,
|
|
(_wcsicmp( GUIDString, BB_NETWORK_GUID_STRING ) == 0)? BB_PNP_NETWORK_TIMEOUT :
|
|
PNP_LEGACY_PHASE3_TIMEOUT );
|
|
if( WaitResult == WAIT_TIMEOUT ) {
|
|
int Result;
|
|
HANDLE hDialogEvent;
|
|
|
|
if( hDialogEvent = OpenEvent( EVENT_MODIFY_STATE, FALSE, SETUP_HAS_OPEN_DIALOG_EVENT ) ) {
|
|
//
|
|
// Setupapi is prompting the user for a file. Don't timeout.
|
|
//
|
|
CloseHandle( hDialogEvent );
|
|
KeepWaiting = TRUE;
|
|
continue;
|
|
} else {
|
|
}
|
|
|
|
//
|
|
// Class installer is hung
|
|
//
|
|
SetupDebugPrint1( L"SETUP: Class Installer appears to be hung (phase3). DeviceId = %ls", DevInstId );
|
|
|
|
#ifdef PRERELEASE
|
|
//
|
|
// Ask the user if he wants to skip the installation of this class of devices
|
|
//
|
|
if( !Unattended ) {
|
|
Result = MessageBoxFromMessage( hwndParent,
|
|
MSG_CLASS_INSTALLER_HUNG,
|
|
NULL,
|
|
IDS_WINNT_SETUP,
|
|
MB_YESNO | MB_ICONWARNING,
|
|
DevInstId );
|
|
} else {
|
|
Result = IDYES;
|
|
}
|
|
#else
|
|
Result = IDYES;
|
|
#endif
|
|
|
|
if(Result == IDYES) {
|
|
//
|
|
// User wants to skip this device.
|
|
// First find out if the thread has already returned.
|
|
//
|
|
WaitResult = WaitForSingleObject( ThreadHandle, 0 );
|
|
if( WaitResult != WAIT_OBJECT_0 ) {
|
|
//
|
|
// Thread hasn't returned yet. Skip the installation of this device
|
|
//
|
|
KeepWaiting = FALSE;
|
|
SetupDebugPrint1( L"SETUP: Skipping installation of legacy device (phase3). Device = %ls", DevInstId );
|
|
b = FALSE;
|
|
if( !SetupDiGetClassDescription( &GuidList[ GuidIndex ],
|
|
LoggedDescription,
|
|
sizeof(LoggedDescription)/sizeof(WCHAR),
|
|
NULL ) ) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetClassDescription() failed. Error = %lx", GetLastError() );
|
|
//
|
|
// Assume anything for class description, since we don't really care about it,
|
|
// for logging purposes. The class description only helps identify the problematic
|
|
// device.
|
|
//
|
|
wcscpy( LoggedDescription, L"1" );
|
|
}
|
|
//
|
|
// Remember this device so that it won't be installed if GUI setup is
|
|
// restarted
|
|
//
|
|
WritePrivateProfileString( szLegacyDevSection,
|
|
DevInstId,
|
|
LoggedDescription,
|
|
PnpLogPath );
|
|
} else{
|
|
//
|
|
// Thread has already returned.
|
|
// There is no need to skip the installation of this device.
|
|
// We assume that the user decided not to skip the installation of this device,
|
|
// and next call to WaitForSingleObject will immediately return.
|
|
//
|
|
}
|
|
}
|
|
|
|
} else if( WaitResult == WAIT_OBJECT_0 ) {
|
|
//
|
|
// Device Installation Thread completed.
|
|
// Find out the outcome of this phase of the installation.
|
|
//
|
|
KeepWaiting = FALSE;
|
|
if( GetExitCodeThread( ThreadHandle, &ExitCode ) ) {
|
|
if( ExitCode ) {
|
|
//
|
|
// The installation was successful
|
|
//
|
|
#ifdef PNP_DEBUG_UI
|
|
DeviceSuccessfullyInstalled = TRUE;
|
|
#endif
|
|
} else {
|
|
//
|
|
// The installation was not successful.
|
|
// There is no need to log the error, since the thread has already done it.
|
|
//
|
|
b = FALSE;
|
|
}
|
|
} else {
|
|
//
|
|
// Unable to retrieve exit code. Assume success.
|
|
//
|
|
SetupDebugPrint1( L"SETUP: GetExitCode() failed. Error = %d", GetLastError() );
|
|
SetupDebugPrint( L"SETUP: Unable to retrieve thread exit code. Assuming device successfully installed (phase3)." );
|
|
}
|
|
MyFree(Phase3Context->pDeviceId);
|
|
MyFree(Phase3Context);
|
|
|
|
} else {
|
|
//
|
|
// Should not occur
|
|
//
|
|
KeepWaiting = FALSE;
|
|
SetupDebugPrint1( L"SETUP: WaitForSingleObject() returned %d", WaitResult );
|
|
b = FALSE;
|
|
}
|
|
}
|
|
//
|
|
// The thread handle is no longer needed at this point
|
|
//
|
|
CloseHandle(ThreadHandle);
|
|
|
|
} else {
|
|
//
|
|
// Unable to create the thread. Just do it syncronously.
|
|
//
|
|
Error = GetLastError();
|
|
SetupDebugPrint1( L"SETUP: CreateThread() failed (phase3). Error = %d", Error );
|
|
if( !pPhase3InstallPnpLegacyDevicesThread(Phase3Context) ) {
|
|
//
|
|
// The installation was not successful.
|
|
// There is no need to log the error, since the thread has already done it.
|
|
//
|
|
b = FALSE;
|
|
|
|
} else {
|
|
#ifdef PNP_DEBUG_UI
|
|
DeviceSuccessfullyInstalled = TRUE;
|
|
#endif
|
|
}
|
|
MyFree( Phase3Context->pDeviceId );
|
|
MyFree( Phase3Context );
|
|
}
|
|
|
|
#ifdef PNP_DEBUG_UI
|
|
if( DeviceSuccessfullyInstalled ) {
|
|
//
|
|
// Add the device to an info set that has the same class as this device.
|
|
//
|
|
if( !AddDevInfoDataToDevInfoSet( &DevInfoSetList,
|
|
&TempDeviceInfoData,
|
|
DevInstId,
|
|
hwndParent ) ) {
|
|
SetupDebugPrint1( L"SETUP: AddDevInfoDataToDevInfoSet() failed. DevId = %ls", DevInstId );
|
|
b = FALSE;
|
|
continue;
|
|
}
|
|
}
|
|
#endif // PNP_DEBUG_UI
|
|
}
|
|
|
|
Error = GetLastError();
|
|
if( Error != ERROR_NO_MORE_ITEMS ) {
|
|
SetupDebugPrint2( L"SETUP: Device = %d, SetupDiEnumDeviceInfo() failed. Error = %d", Index, Error );
|
|
b = FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Get rid of the file queue, if it exists
|
|
//
|
|
if( FileQ != INVALID_HANDLE_VALUE) {
|
|
SetupCloseFileQueue(FileQ);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Make sure that at this point, the gauge area is filled up to the end of
|
|
// the area reserved for the installation of legacy devices.
|
|
//
|
|
SendMessage(ProgressWindow,PBM_SETPOS,GaugeRange*StopAtPercent/100,0);
|
|
|
|
//
|
|
// Get rid of the list of GUIDs.
|
|
//
|
|
if( GuidList != NULL ) {
|
|
MyFree( GuidList );
|
|
}
|
|
|
|
//
|
|
// Get rid of InfoSetArray, and all info sets stored on it.
|
|
//
|
|
|
|
if( InfoSetArray != NULL ) {
|
|
for( GuidIndex = 0; GuidIndex < GuidCount; GuidIndex++ ) {
|
|
if( InfoSetArray[ GuidIndex ] != INVALID_HANDLE_VALUE ) {
|
|
SetupDiDestroyDeviceInfoList( InfoSetArray[ GuidIndex ] );
|
|
}
|
|
}
|
|
MyFree( InfoSetArray );
|
|
}
|
|
SetupDebugPrint( L"SETUP: Leaving InstallLegacyDevices()" );
|
|
return( b );
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
InstallEnumeratedDevices(
|
|
IN HWND hwndParent,
|
|
IN HINF InfHandle,
|
|
IN HWND ProgressWindow,
|
|
IN ULONG StartAtPercent,
|
|
IN ULONG StopAtPercent
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function enumerates and install all new PnP devices detected during
|
|
GUI setup.
|
|
|
|
Arguments:
|
|
|
|
hwndParent - Handle to a top level window that may be used for UI purposes.
|
|
|
|
InfHandle - System setup inf handle (syssetup.inf).
|
|
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE if all enumerated hardware were installed successfully.
|
|
|
|
--*/
|
|
{
|
|
HANDLE hPipeEvent = NULL;
|
|
HANDLE hPipe = INVALID_HANDLE_VALUE;
|
|
ULONG Index = 0;
|
|
ULONG Error;
|
|
ULONG ulSize = 0;
|
|
HDEVINFO hDevInfo = INVALID_HANDLE_VALUE;
|
|
WCHAR szBuffer[MAX_PATH];
|
|
BOOL b = TRUE;
|
|
UINT GaugeRange = 100;
|
|
WCHAR RootPath[ MAX_PATH + 1];
|
|
WCHAR PnpLogPath[ MAX_PATH + 1];
|
|
PAF_DRIVERS AfDrivers;
|
|
PAF_DRIVER_ATTRIBS SelectedAfDriver;
|
|
PSP_DEVINFO_DATA pDeviceInfoData = NULL;
|
|
ULONG PnPFlags;
|
|
HANDLE hBatchEvent = NULL;
|
|
DWORD Result;
|
|
|
|
|
|
SetupDebugPrint( L"SETUP: Entering InstallEnumeratedDevices()" );
|
|
|
|
//
|
|
// Build path to pnp log file
|
|
//
|
|
Result = GetWindowsDirectory( PnpLogPath, sizeof(PnpLogPath)/sizeof(WCHAR) );
|
|
if( Result == 0) {
|
|
MYASSERT(FALSE);
|
|
return FALSE;
|
|
}
|
|
pSetupConcatenatePaths( PnpLogPath, szPnpLogFile, sizeof(PnpLogPath)/sizeof(WCHAR), NULL );
|
|
|
|
//
|
|
// Initialize RootPath with empty string
|
|
//
|
|
RootPath[0] = L'\0';
|
|
|
|
//
|
|
// Initialize answer file table
|
|
//
|
|
|
|
AfDrivers = CreateAfDriverTable();
|
|
|
|
//
|
|
// Attempt to create the event that will be used to signal the successfull
|
|
// creation of the named pipe
|
|
//
|
|
hPipeEvent = CreateEvent( NULL, TRUE, FALSE, PNP_CREATE_PIPE_EVENT );
|
|
if (hPipeEvent == NULL) {
|
|
Error = GetLastError();
|
|
if( Error != ERROR_ALREADY_EXISTS ) {
|
|
SetupDebugPrint1( L"SETUP: CreateEvent() failed. Error = %d", Error );
|
|
b = FALSE;
|
|
goto Clean0;
|
|
}
|
|
//
|
|
// If umpnpmgr has already created the event, then just open the event
|
|
//
|
|
hPipeEvent = OpenEvent(EVENT_MODIFY_STATE,
|
|
FALSE,
|
|
PNP_CREATE_PIPE_EVENT);
|
|
|
|
if (hPipeEvent == NULL) {
|
|
SetupDebugPrint1( L"SETUP: OpenEvent() failed. Error = %d", GetLastError() );
|
|
b = FALSE;
|
|
goto Clean0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Attempt to create the event that will be used to signal the completion of
|
|
// processing of the last batch of devices.
|
|
//
|
|
hBatchEvent = CreateEvent( NULL, TRUE, FALSE, PNP_BATCH_PROCESSED_EVENT );
|
|
if (hBatchEvent == NULL) {
|
|
Error = GetLastError();
|
|
if( Error != ERROR_ALREADY_EXISTS ) {
|
|
SetupDebugPrint1( L"SETUP: CreateEvent() failed. Error = %d", Error );
|
|
b = FALSE;
|
|
goto Clean0;
|
|
}
|
|
//
|
|
// If umpnpmgr has already created the event, then just open the event
|
|
//
|
|
hBatchEvent = OpenEvent(EVENT_MODIFY_STATE,
|
|
FALSE,
|
|
PNP_BATCH_PROCESSED_EVENT);
|
|
|
|
if (hBatchEvent == NULL) {
|
|
SetupDebugPrint1( L"SETUP: OpenEvent() failed. Error = %d", GetLastError() );
|
|
b = FALSE;
|
|
goto Clean0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// create the named pipe, umpnpmgr will write requests to
|
|
// this pipe if new hardware is found
|
|
//
|
|
hPipe = CreateNamedPipe(PNP_NEW_HW_PIPE,
|
|
PIPE_ACCESS_INBOUND,
|
|
PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE,
|
|
1, // only one connection
|
|
sizeof(szBuffer), // out buffer size
|
|
sizeof(szBuffer), // in buffer size
|
|
PNP_PIPE_TIMEOUT, // default timeout
|
|
NULL // default security
|
|
);
|
|
|
|
//
|
|
// signal the event now
|
|
//
|
|
SetEvent(hPipeEvent);
|
|
|
|
if (hPipe == INVALID_HANDLE_VALUE) {
|
|
SetupDebugPrint1( L"SETUP: CreateNamedPipe() failed. Error = %d", GetLastError() );
|
|
b = FALSE;
|
|
goto Clean0;
|
|
}
|
|
|
|
//
|
|
// Connect to the newly created named pipe.
|
|
// If umpnpmgr is not already connected to the named pipe, then ConnectNamedPipe()
|
|
// will succeed. Otherwise, it will fail with ERROR_PIPE_CONNECTED. Note however that
|
|
// this is not an error condition.
|
|
//
|
|
if (ConnectNamedPipe(hPipe, NULL) ||
|
|
((Error = GetLastError()) == ERROR_PIPE_CONNECTED) ) {
|
|
//
|
|
// REVIEW 2000/11/08 seanch - Old behavior that we don't want to regress.
|
|
// This is gauge related and needs to be fixed.
|
|
// We are assuming a total of 50 enumerated device.
|
|
//
|
|
BOOL AlwaysFalse = FALSE;
|
|
UINT BogusValue = 50;
|
|
|
|
//
|
|
// Initialize the gauge
|
|
// REVIEW 2000/11/08 seanch - Old behavior that we don't want to regress.
|
|
// Fix this - We are assuming a fixed number of devices
|
|
//
|
|
GaugeRange = (BogusValue*100/(StopAtPercent-StartAtPercent));
|
|
SendMessage(ProgressWindow, WMX_PROGRESSTICKS, BogusValue, 0);
|
|
SendMessage(ProgressWindow,PBM_SETRANGE,0,MAKELPARAM(0,GaugeRange));
|
|
SendMessage(ProgressWindow,PBM_SETPOS,GaugeRange*StartAtPercent/100,0);
|
|
SendMessage(ProgressWindow,PBM_SETSTEP,1,0);
|
|
|
|
//
|
|
// listen to the named pipe by submitting read
|
|
// requests until the named pipe is broken on the
|
|
// other end.
|
|
//
|
|
for( Index = 0;
|
|
//
|
|
// REVIEW 2000/11/08 seanch - Old behavior that we don't want to regress.
|
|
// This is gauge related and needs to be fixed.
|
|
// We are assuming a constant number of enumerated devices
|
|
//
|
|
( (Index != 0) &&
|
|
(Index < BogusValue) &&
|
|
SendMessage(ProgressWindow,PBM_STEPIT,0,0) &&
|
|
AlwaysFalse
|
|
) || // This is a trick to force the gauge to be upgraded after a
|
|
// device is processed, and the pipe to be read.
|
|
ReadFile( hPipe,
|
|
(LPBYTE)szBuffer, // device instance id
|
|
sizeof(szBuffer),
|
|
&ulSize,
|
|
NULL );
|
|
Index++ ) {
|
|
|
|
SP_DRVINFO_DATA DriverInfoData;
|
|
SP_DEVINSTALL_PARAMS DeviceInstallParams;
|
|
WCHAR GUIDString[ 64 ];
|
|
WCHAR ClassDescription[ LINE_LEN + 1 ];
|
|
HANDLE ThreadHandle = NULL;
|
|
DWORD ThreadId;
|
|
PPNP_ENUM_DEV_THREAD_PARAMS Context;
|
|
BOOL DeviceInstalled;
|
|
WCHAR LoggedDescription[ LINE_LEN + 1 ];
|
|
BOOL bOemF6Driver;
|
|
|
|
if (lstrlen(szBuffer) == 0) {
|
|
|
|
SetEvent(hBatchEvent);
|
|
continue;
|
|
}
|
|
SetupDebugPrint2( L"SETUP: Index = %d, DeviceId = %ls", Index, szBuffer );
|
|
//
|
|
// Check if this device is listed as a bad device
|
|
//
|
|
LoggedDescription[0] = L'\0';
|
|
if( (GetPrivateProfileString( szEnumDevSection,
|
|
szBuffer,
|
|
L"",
|
|
LoggedDescription,
|
|
sizeof(LoggedDescription)/sizeof(WCHAR),
|
|
PnpLogPath ) != 0) &&
|
|
( wcslen( LoggedDescription ) != 0 )
|
|
) {
|
|
#ifndef DBG
|
|
//
|
|
// Skip the installation of this device
|
|
//
|
|
SetupDebugPrint1( L"SETUP: Skipping installation of device %ls", szBuffer );
|
|
continue;
|
|
#endif
|
|
}
|
|
BEGIN_SECTION(LoggedDescription);
|
|
|
|
//
|
|
// Find out if we need to create an hDevinfo.
|
|
// We will need to create one if this is the first device that we are installing (Index == 0),
|
|
// or the class installer for the previous device (Index == Index - 1) is hung. If the class
|
|
// installer is hung then we cannot use the same hDevinfo, since the class installer has a lock
|
|
// on it. So we just create a new one.
|
|
// If the class installer for the previous device didn't hang, then there is no need to create
|
|
// a new hDevinfo, since we can re-use it. We do this for performance reasons.
|
|
//
|
|
if( hDevInfo == INVALID_HANDLE_VALUE ) {
|
|
//
|
|
// create a devinfo handle and device info data set to
|
|
// pass to DevInstall
|
|
//
|
|
if((hDevInfo = SetupDiCreateDeviceInfoList(NULL, hwndParent))
|
|
== INVALID_HANDLE_VALUE) {
|
|
b = FALSE;
|
|
SetupDebugPrint1( L"SETUP: SetupDiCreateDeviceInfoList() failed. Error = %d", GetLastError() );
|
|
goto Clean0;
|
|
}
|
|
pDeviceInfoData = MyMalloc(sizeof(SP_DEVINFO_DATA));
|
|
if( pDeviceInfoData == NULL ) {
|
|
b = FALSE;
|
|
SetupDebugPrint( L"SETUP: Unable to create pDeviceInfoData. MyMalloc() failed." );
|
|
goto Clean0;
|
|
}
|
|
pDeviceInfoData->cbSize = sizeof(SP_DEVINFO_DATA);
|
|
}
|
|
|
|
if(!SetupDiOpenDeviceInfo(hDevInfo, szBuffer, hwndParent, 0, pDeviceInfoData)) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiOpenDeviceInfo() failed. Error = %d", GetLastError() );
|
|
b = FALSE;
|
|
END_SECTION(LoggedDescription);
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// Answer file support: Test the answer file to see if it has a driver
|
|
// in its [DeviceDrivers] section. This overrides the NT-supplied driver,
|
|
// if one exists.
|
|
//
|
|
|
|
if (!SyssetupInstallAnswerFileDriver (
|
|
AfDrivers,
|
|
hDevInfo,
|
|
pDeviceInfoData,
|
|
&SelectedAfDriver
|
|
)) {
|
|
|
|
//
|
|
// No answer file driver, proceed with the standard device install
|
|
//
|
|
|
|
SetupDebugPrint( L"SETUP: Device was NOT installed via answer file driver" );
|
|
|
|
//
|
|
// Build a list of compatible drivers for this device
|
|
// (This call can be time consuming the first time it is called)
|
|
//
|
|
if( !SetupDiBuildDriverInfoList( hDevInfo, pDeviceInfoData, SPDIT_COMPATDRIVER ) ) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiBuildDriverInfoList() failed. Error = %d", GetLastError() );
|
|
b = FALSE;
|
|
continue;
|
|
|
|
}
|
|
|
|
//
|
|
// Select the best compatible driver for this device.
|
|
//
|
|
if( !SelectBestDriver( hDevInfo,
|
|
pDeviceInfoData,
|
|
&bOemF6Driver ) ) {
|
|
|
|
Error = GetLastError();
|
|
if( Error != ERROR_NO_COMPAT_DRIVERS ) {
|
|
|
|
SetupDebugPrint1( L"SETUP: SetupDiCallClassInstaller(DIF_SELECTBESTCOMPATDRV) failed. Error = %d", Error );
|
|
b = FALSE;
|
|
END_SECTION(LoggedDescription);
|
|
continue;
|
|
}
|
|
|
|
SetupDebugPrint( L"SETUP: Compatible driver List is empty" );
|
|
SetupDebugPrint( L"SETUP: Installing the null driver for this device" );
|
|
|
|
//
|
|
// Install the null driver for this device.
|
|
// This is to avoid the "Found New Hardware" popup when the
|
|
// user first logs on after the system is installed.
|
|
//
|
|
if( !SyssetupInstallNullDriver( hDevInfo, pDeviceInfoData ) ) {
|
|
SetupDebugPrint( L"SETUP: Unable to install null driver" );
|
|
}
|
|
|
|
END_SECTION(LoggedDescription);
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Check if we need to rebuild the driver list without including the
|
|
// old Internet drivers.
|
|
//
|
|
if (RebuildListWithoutOldInternetDrivers(hDevInfo, pDeviceInfoData)) {
|
|
|
|
SetupDiDestroyDriverInfoList( hDevInfo, pDeviceInfoData, SPDIT_COMPATDRIVER );
|
|
|
|
//
|
|
// OR in the DI_FLAGSEX_EXCLUDE_OLD_INET_DRIVERS flag so that we don't include
|
|
// old internet drivers in the list that build.
|
|
//
|
|
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
if (SetupDiGetDeviceInstallParams(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DeviceInstallParams
|
|
))
|
|
{
|
|
DeviceInstallParams.FlagsEx |= DI_FLAGSEX_EXCLUDE_OLD_INET_DRIVERS;
|
|
|
|
SetupDiSetDeviceInstallParams(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DeviceInstallParams
|
|
);
|
|
}
|
|
|
|
//
|
|
// Build a list of compatible drivers for this device
|
|
// (This call can be time consuming the first time it is called)
|
|
//
|
|
if( !SetupDiBuildDriverInfoList( hDevInfo, pDeviceInfoData, SPDIT_COMPATDRIVER ) ) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiBuildDriverInfoList() failed. Error = %d", GetLastError() );
|
|
b = FALSE;
|
|
continue;
|
|
|
|
}
|
|
|
|
//
|
|
// Select the best compatible driver for this device.
|
|
//
|
|
if( !SelectBestDriver( hDevInfo,
|
|
pDeviceInfoData,
|
|
&bOemF6Driver ) ) {
|
|
|
|
Error = GetLastError();
|
|
if( Error != ERROR_NO_COMPAT_DRIVERS ) {
|
|
|
|
SetupDebugPrint1( L"SETUP: SetupDiCallClassInstaller(DIF_SELECTBESTCOMPATDRV) failed. Error = %d", Error );
|
|
b = FALSE;
|
|
END_SECTION(LoggedDescription);
|
|
continue;
|
|
}
|
|
|
|
SetupDebugPrint( L"SETUP: Compatible driver List is empty" );
|
|
SetupDebugPrint( L"SETUP: Installing the null driver for this device" );
|
|
|
|
//
|
|
// Install the null driver for this device.
|
|
// This is to avoid the "Found New Hardware" popup when the
|
|
// user first logs on after the system is installed.
|
|
//
|
|
if( !SyssetupInstallNullDriver( hDevInfo, pDeviceInfoData ) ) {
|
|
SetupDebugPrint( L"SETUP: Unable to install null driver" );
|
|
}
|
|
|
|
END_SECTION(LoggedDescription);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
SetupDebugPrint( L"SETUP: Device was installed via answer file driver" );
|
|
}
|
|
|
|
//
|
|
// Retrieve information about the driver node selected above.
|
|
//
|
|
DriverInfoData.cbSize = sizeof( SP_DRVINFO_DATA );
|
|
if( !SetupDiGetSelectedDriver( hDevInfo,
|
|
pDeviceInfoData,
|
|
&DriverInfoData ) ) {
|
|
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetSelectedDriver() failed. Error = %d", GetLastError() );
|
|
b = FALSE;
|
|
continue;
|
|
|
|
}
|
|
//
|
|
// Get the GUID string for this device
|
|
//
|
|
GUIDString[0] = (WCHAR)'\0';
|
|
pSetupStringFromGuid( &(pDeviceInfoData->ClassGuid), GUIDString, sizeof( GUIDString ) / sizeof( WCHAR ) );
|
|
|
|
SetupDebugPrint1( L"SETUP: DriverType = %lx", DriverInfoData.DriverType );
|
|
SetupDebugPrint1( L"SETUP: Description = %ls", &(DriverInfoData.Description[0]) );
|
|
SetupDebugPrint1( L"SETUP: MfgName = %ls", &(DriverInfoData.MfgName[0]) );
|
|
SetupDebugPrint1( L"SETUP: ProviderName = %ls", &(DriverInfoData.ProviderName[0]) );
|
|
SetupDebugPrint1( L"SETUP: GUID = %ls", GUIDString );
|
|
|
|
ClassDescription[0] = (WCHAR)'\0';
|
|
if( !SetupDiGetClassDescription( &(pDeviceInfoData->ClassGuid),
|
|
ClassDescription,
|
|
sizeof(ClassDescription)/sizeof(WCHAR),
|
|
NULL ) ) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetClassDescription() failed. Error = %lx", GetLastError() );
|
|
ClassDescription[0] = (WCHAR)'\0';
|
|
}
|
|
SetupDebugPrint1( L"SETUP: DeviceClass = %ls", ClassDescription );
|
|
|
|
//
|
|
// Retrieve syssetup PnP flags (if any) the INF specifies for this
|
|
// device.
|
|
//
|
|
PnPFlags = SyssetupGetPnPFlags(hDevInfo, pDeviceInfoData, &DriverInfoData);
|
|
|
|
if( SkipDeviceInstallation( hDevInfo,
|
|
pDeviceInfoData,
|
|
InfHandle,
|
|
GUIDString ) ) {
|
|
SetupDebugPrint( L"SETUP: Skipping installation of this device" );
|
|
END_SECTION(LoggedDescription);
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// If the PnP flag was set that said we shouldn't call ConfigMgr
|
|
// for this device, then set the appropriate flag in the device's
|
|
// install params.
|
|
//
|
|
if(PnPFlags & PNPFLAG_DONOTCALLCONFIGMG) {
|
|
|
|
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
|
|
if( !SetupDiGetDeviceInstallParams( hDevInfo,
|
|
pDeviceInfoData,
|
|
&DeviceInstallParams ) ) {
|
|
Error = GetLastError();
|
|
if( ((LONG)Error) < 0 ) {
|
|
//
|
|
// Setupapi error code, display it in hex
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetDeviceInstallParams() failed. Error = %lx", Error );
|
|
} else {
|
|
//
|
|
// win32 error code, display it in decimal
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetDeviceInstallParams() failed. Error = %d", Error );
|
|
}
|
|
} else {
|
|
|
|
DeviceInstallParams.Flags |= DI_DONOTCALLCONFIGMG;
|
|
|
|
if( !SetupDiSetDeviceInstallParams( hDevInfo,
|
|
pDeviceInfoData,
|
|
&DeviceInstallParams ) ) {
|
|
Error = GetLastError();
|
|
if( ((LONG)Error) < 0 ) {
|
|
//
|
|
// Setupapi error code, display it in hex
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiSetDeviceInstallParams() failed. Error = %lx", Error );
|
|
} else {
|
|
//
|
|
// win32 error code, display it in decimal
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiSetDeviceInstallParams() failed. Error = %d", Error );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Start the thread that actually does the installation of the device
|
|
//
|
|
Context = MyMalloc( sizeof(PNP_ENUM_DEV_THREAD_PARAMS) );
|
|
Context->hDevInfo = hDevInfo;
|
|
Context->DeviceInfoData = *pDeviceInfoData;
|
|
Context->pDeviceDescription = pSetupDuplicateString(&(DriverInfoData.Description[0]));
|
|
Context->pDeviceId = pSetupDuplicateString(szBuffer);
|
|
|
|
DeviceInstalled = FALSE;
|
|
ThreadHandle = CreateThread( NULL,
|
|
0,
|
|
pInstallPnpEnumeratedDeviceThread,
|
|
Context,
|
|
0,
|
|
&ThreadId );
|
|
if(ThreadHandle) {
|
|
DWORD WaitResult;
|
|
DWORD ExitCode;
|
|
BOOL KeepWaiting;
|
|
|
|
KeepWaiting = TRUE;
|
|
while( KeepWaiting ) {
|
|
//
|
|
// REVIEW 2000/11/08 seanch - Old behavior that we don't want to regress.
|
|
// Fix the network timeout after the network guys fix their class installer
|
|
//
|
|
WaitResult = WaitForSingleObject( ThreadHandle,
|
|
(_wcsicmp( GUIDString, BB_NETWORK_GUID_STRING ) == 0)? BB_PNP_NETWORK_TIMEOUT :
|
|
PNP_ENUM_TIMEOUT );
|
|
if( WaitResult == WAIT_TIMEOUT ) {
|
|
int Result;
|
|
HANDLE hDialogEvent;
|
|
|
|
if( hDialogEvent = OpenEvent( EVENT_MODIFY_STATE, FALSE, SETUP_HAS_OPEN_DIALOG_EVENT ) ) {
|
|
//
|
|
// Setupapi is prompting the user for a file. Don't timeout.
|
|
//
|
|
CloseHandle( hDialogEvent );
|
|
KeepWaiting = TRUE;
|
|
continue;
|
|
} else {
|
|
}
|
|
|
|
//
|
|
// Class installer is hung
|
|
//
|
|
SetupDebugPrint1( L"SETUP: Class Installer appears to be hung. Device = %ls", &(DriverInfoData.Description[0]) );
|
|
|
|
#ifdef PRERELEASE
|
|
//
|
|
// Ask the user if he wants to skip the installation of this device.
|
|
//
|
|
if( !Unattended ) {
|
|
Result = MessageBoxFromMessage( hwndParent,
|
|
MSG_CLASS_INSTALLER_HUNG,
|
|
NULL,
|
|
IDS_WINNT_SETUP,
|
|
MB_YESNO | MB_ICONWARNING,
|
|
&(DriverInfoData.Description[0]) );
|
|
} else {
|
|
Result = IDYES;
|
|
}
|
|
#else
|
|
Result = IDYES;
|
|
#endif
|
|
|
|
if(Result == IDYES) {
|
|
//
|
|
// User wants to skip this device.
|
|
// First find out if the thread has already returned.
|
|
//
|
|
WaitResult = WaitForSingleObject( ThreadHandle, 0 );
|
|
if( WaitResult != WAIT_OBJECT_0 ) {
|
|
//
|
|
// Thread hasn't returned yet. Skip the installation of this device.
|
|
//
|
|
KeepWaiting = FALSE;
|
|
SetupDebugPrint1( L"SETUP: Skipping installation of enumerated device. Device = %ls", &(DriverInfoData.Description[0]) );
|
|
b = FALSE;
|
|
//
|
|
// Remember this device so that it won't be installed if GUI setup is
|
|
// restarted
|
|
//
|
|
WritePrivateProfileString( szEnumDevSection,
|
|
szBuffer,
|
|
&(DriverInfoData.Description[0]),
|
|
PnpLogPath );
|
|
//
|
|
// Since the class installer is hung, we cannot re-use the hDevInfo that was passed
|
|
// to the class installer. So we just ignore this one. We will create a new one for
|
|
// the next device to be installed.
|
|
//
|
|
hDevInfo = INVALID_HANDLE_VALUE;
|
|
pDeviceInfoData = NULL;
|
|
} else{
|
|
//
|
|
// Thread has already returned.
|
|
// There is no need to skip the installation of this device.
|
|
// We assume that the user decided not to skip the installation of this device,
|
|
// and next call to WaitForSingleObject will immediately return.
|
|
//
|
|
}
|
|
}
|
|
|
|
} else if( WaitResult == WAIT_OBJECT_0 ) {
|
|
|
|
//
|
|
// Device Installation Thread completed.
|
|
//
|
|
KeepWaiting = FALSE;
|
|
//
|
|
// Deallocate memory passed to the thread.
|
|
//
|
|
MyFree( Context->pDeviceDescription );
|
|
MyFree( Context->pDeviceId );
|
|
MyFree( Context );
|
|
if( GetExitCodeThread( ThreadHandle, &ExitCode ) ) {
|
|
if( ExitCode == ERROR_SUCCESS ) {
|
|
//
|
|
// The installation was successful
|
|
//
|
|
DeviceInstalled = TRUE;
|
|
SetupDebugPrint( L"SETUP: Device successfully installed." );
|
|
|
|
} else {
|
|
//
|
|
// The installation was not successful.
|
|
// There is no need to log the error, since the thread has already done it.
|
|
//
|
|
SetupDebugPrint( L"SETUP: Device not successfully installed." );
|
|
b = FALSE;
|
|
}
|
|
} else {
|
|
//
|
|
// Unable to retrieve exit code. Assume success.
|
|
//
|
|
SetupDebugPrint1( L"SETUP: GetExitCode() failed. Error = %d", GetLastError() );
|
|
SetupDebugPrint( L"SETUP: Unable to retrieve thread exit code. Assuming device successfully installed." );
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// Should not occur
|
|
//
|
|
KeepWaiting = FALSE;
|
|
SetupDebugPrint1( L"SETUP: WaitForSingleObject() returned %d", WaitResult );
|
|
|
|
// MyFree( Context->pDeviceDescription );
|
|
// MyFree( Context->pDeviceId );
|
|
// MyFree( Context );
|
|
b = FALSE;
|
|
|
|
}
|
|
}
|
|
//
|
|
// The thread handle is no longer needed.
|
|
//
|
|
CloseHandle(ThreadHandle);
|
|
} else {
|
|
//
|
|
// Just do it synchronously.
|
|
//
|
|
SetupDebugPrint1( L"SETUP: CreateThread() failed (enumerated device). Error = %d", GetLastError() );
|
|
|
|
if( pInstallPnpEnumeratedDeviceThread(Context) != ERROR_SUCCESS ) {
|
|
//
|
|
// The installation was not successful.
|
|
// There is no need to log the error, since the thread has already done it.
|
|
//
|
|
SetupDebugPrint( L"SETUP: Device not successfully installed." );
|
|
b = FALSE;
|
|
} else {
|
|
DeviceInstalled = TRUE;
|
|
}
|
|
MyFree( Context->pDeviceDescription );
|
|
MyFree( Context->pDeviceId );
|
|
MyFree( Context );
|
|
}
|
|
|
|
|
|
if( DeviceInstalled ) {
|
|
|
|
#ifdef PNP_DEBUG_UI
|
|
//
|
|
// Add the device to an info set that has the same class as this device.
|
|
//
|
|
if( !AddDevInfoDataToDevInfoSet( &DevInfoSetList,
|
|
pDeviceInfoData,
|
|
szBuffer,
|
|
hwndParent ) ) {
|
|
SetupDebugPrint1( L"SETUP: AddDevInfoDataToDevInfoSet() failed. DevId = %ls", szBuffer );
|
|
b = FALSE;
|
|
continue;
|
|
|
|
}
|
|
#endif // PNP_DEBUG_UI
|
|
|
|
//
|
|
// If this device came from the answer file, then change the original
|
|
// media path from the local temp dir to the original path (typically
|
|
// the floppy drive).
|
|
//
|
|
|
|
if (SelectedAfDriver) {
|
|
SyssetupFixAnswerFileDriverPath (
|
|
SelectedAfDriver,
|
|
hDevInfo,
|
|
pDeviceInfoData
|
|
);
|
|
}
|
|
|
|
//
|
|
// If the driver we just installed was an Oem F6 driver then
|
|
// we need to add it to the list of files that SfcInitProt
|
|
// will leave alone during its scan.
|
|
//
|
|
if (bOemF6Driver) {
|
|
AddOemF6DriversToSfcIgnoreFilesList(hDevInfo, pDeviceInfoData);
|
|
}
|
|
}
|
|
END_SECTION(LoggedDescription);
|
|
}
|
|
|
|
//
|
|
// Find out why we stopped reading the pipe. If it was because the connetion
|
|
// to the pipe was broken by umpnp, then there was nothing else to read from
|
|
// the pipe. Otherwise, there was an error condition.
|
|
//
|
|
if( ( Error = GetLastError() ) != ERROR_BROKEN_PIPE ) {
|
|
SetupDebugPrint1( L"SETUP: ReadFile( hPipe ) failed. Error = %d", GetLastError() );
|
|
b = FALSE;
|
|
goto Clean0;
|
|
}
|
|
|
|
} else {
|
|
SetupDebugPrint1( L"SETUP: ConnectNamedPipe() failed. Error = %d", GetLastError() );
|
|
b = FALSE;
|
|
goto Clean0;
|
|
}
|
|
|
|
|
|
Clean0:
|
|
BEGIN_SECTION(L"InstallEnumeratedDevices cleanup");
|
|
//
|
|
// Make sure that at this point the gauge is filled up to the end of the
|
|
// region reserved for the installation of the enumerated devices.
|
|
//
|
|
SendMessage(ProgressWindow,PBM_SETPOS,GaugeRange*StopAtPercent/100,0);
|
|
|
|
if (hPipe != INVALID_HANDLE_VALUE) {
|
|
DisconnectNamedPipe(hPipe);
|
|
CloseHandle(hPipe);
|
|
}
|
|
if (hPipeEvent != NULL) {
|
|
CloseHandle(hPipeEvent);
|
|
}
|
|
if (hBatchEvent != NULL) {
|
|
CloseHandle(hBatchEvent);
|
|
}
|
|
|
|
if( hDevInfo != INVALID_HANDLE_VALUE ) {
|
|
SetupDiDestroyDeviceInfoList( hDevInfo );
|
|
}
|
|
|
|
DestroyAfDriverTable (AfDrivers);
|
|
|
|
if( pDeviceInfoData != NULL ) {
|
|
MyFree( pDeviceInfoData );
|
|
}
|
|
SetupDebugPrint( L"SETUP: Leaving InstallEnumeratedDevices()" );
|
|
END_SECTION(L"InstallEnumeratedDevices cleanup");
|
|
return( b );
|
|
}
|
|
|
|
|
|
DWORD
|
|
pInstallPnpDevicesThread(
|
|
PPNP_THREAD_PARAMS ThreadParams
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the thread that does the installation of the PnP devices.
|
|
|
|
Arguments:
|
|
|
|
ThreadParams - Points to a structure that contains the information
|
|
passed to this thread.
|
|
|
|
Return Value:
|
|
|
|
Returnd TRUE if the operation succeeds, or FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL b;
|
|
PPNP_THREAD_PARAMS Context;
|
|
ULONG StartAtPercent;
|
|
ULONG StopAtPercent;
|
|
ULONG DeltaPercent;
|
|
|
|
Context = ThreadParams;
|
|
|
|
//
|
|
// Assume success.
|
|
//
|
|
b = TRUE;
|
|
|
|
//
|
|
// We don't want SetupAPI to do any RunOnce calls, as we'll do it manually
|
|
//
|
|
pSetupSetGlobalFlags(pSetupGetGlobalFlags()|PSPGF_NO_RUNONCE);
|
|
|
|
//
|
|
// Initialize some variables that are related to the progress bar.
|
|
// We divide the progress window area reserved for pnp installation in 3 regions
|
|
// of equal size, and they will be used in the following steps:
|
|
// . Pre-compilation of infs
|
|
// . Installation of enumerated devices
|
|
// . Installation of legacy devices
|
|
// . Installation of enumerated devices that may have appeared after the installation of legacy devices
|
|
//
|
|
DeltaPercent = (Context->ProgressWindowStopAtPercent - Context->ProgressWindowStartAtPercent) / 4;
|
|
StartAtPercent = Context->ProgressWindowStartAtPercent;
|
|
StopAtPercent = Context->ProgressWindowStartAtPercent + DeltaPercent;
|
|
|
|
//
|
|
// Pre-compile inf files
|
|
//
|
|
|
|
//
|
|
// Before we can start precompiling inf files, let's "seed" the INF
|
|
// directory with any OEM-supplied INFs that need to be present during
|
|
// detection. This should be really quick and doesn't require the
|
|
// updating the progress window
|
|
//
|
|
RemainingTime = CalcTimeRemaining(Phase_PrecompileInfs);
|
|
SetRemainingTime(RemainingTime);
|
|
BEGIN_SECTION(L"Installing OEM infs");
|
|
InstallOEMInfs();
|
|
//
|
|
// Add migrated drivers to the SFC exclusion list
|
|
//
|
|
#if defined(_X86_)
|
|
SfcExcludeMigratedDrivers ();
|
|
#endif
|
|
END_SECTION(L"Installing OEM infs");
|
|
|
|
BEGIN_SECTION(L"Precompiling infs");
|
|
PrecompileInfFiles( Context->ProgressWindow,
|
|
StartAtPercent,
|
|
StopAtPercent );
|
|
END_SECTION(L"Precompiling infs");
|
|
|
|
//
|
|
// This operation is very fast, so we don't need to upgrade the progress bar.
|
|
//
|
|
if( !MiniSetup ) {
|
|
BEGIN_SECTION(L"Mark PnP devices for reinstall");
|
|
MarkPnpDevicesAsNeedReinstall();
|
|
END_SECTION(L"Mark PnP devices for reinstall");
|
|
}
|
|
|
|
//
|
|
// Do the migration of legacy devices...at the moment all that PnPInit does
|
|
// is migrate all the device nodes who belong to the vid load order group to
|
|
// be put into the display class. This is the desired result.
|
|
//
|
|
// This is a quick operation and doesn't need to use the progress window.
|
|
//
|
|
PnPInitializationThread(NULL);
|
|
|
|
//
|
|
// Do installation of enumerated devices
|
|
//
|
|
StartAtPercent += DeltaPercent;
|
|
StopAtPercent += DeltaPercent;
|
|
|
|
RemainingTime = CalcTimeRemaining(Phase_InstallEnumDevices1);
|
|
SetRemainingTime(RemainingTime);
|
|
BEGIN_SECTION(L"Installing enumerated devices");
|
|
b = InstallEnumeratedDevices( Context->Window,
|
|
Context->InfHandle,
|
|
Context->ProgressWindow,
|
|
StartAtPercent,
|
|
StopAtPercent );
|
|
|
|
//
|
|
// devices installs may exist in RunOnce entries
|
|
// they are processed as a batch, as opposed to per-device
|
|
// during syssetup
|
|
//
|
|
CallRunOnceAndWait();
|
|
END_SECTION(L"Installing enumerated devices");
|
|
|
|
//
|
|
// Do the installation of legacy pnp devices.
|
|
//
|
|
StartAtPercent += DeltaPercent;
|
|
StopAtPercent += DeltaPercent;
|
|
|
|
BEGIN_SECTION(L"Installing legacy devices");
|
|
RemainingTime = CalcTimeRemaining(Phase_InstallLegacyDevices);
|
|
SetRemainingTime(RemainingTime);
|
|
b = InstallLegacyDevices( Context->Window,
|
|
Context->ProgressWindow,
|
|
StartAtPercent,
|
|
StopAtPercent ) && b;
|
|
|
|
//
|
|
// devices installs may exist in RunOnce entries
|
|
// they are processed as a batch, as opposed to per-device
|
|
// during syssetup
|
|
//
|
|
CallRunOnceAndWait();
|
|
END_SECTION(L"Installing legacy devices");
|
|
|
|
|
|
// Install the remaining enumerated devices that may have appeared after the
|
|
// installation of the legacy devices.
|
|
// Since this step uses the last region of the progress window,
|
|
// use as StopAtPercent, the value that was passed to this function,
|
|
// instead of the calulated value (by adding DeltaPorcent). This will
|
|
// ensure that at the end of this step, the gauge will be filled up
|
|
// completely. If we use the calculated value, then rounding error
|
|
// can cause the gauge not to be completelly filled up at the end of
|
|
// this step.
|
|
//
|
|
StartAtPercent += DeltaPercent;
|
|
StopAtPercent = Context->ProgressWindowStopAtPercent;
|
|
|
|
BEGIN_SECTION(L"Install enumerated devices triggered by legacy devices");
|
|
RemainingTime = CalcTimeRemaining(Phase_InstallEnumDevices2);
|
|
SetRemainingTime(RemainingTime);
|
|
b = InstallEnumeratedDevices( Context->Window,
|
|
Context->InfHandle,
|
|
Context->ProgressWindow,
|
|
StartAtPercent,
|
|
StopAtPercent ) && b;
|
|
|
|
//
|
|
// devices installs may exist in RunOnce entries
|
|
// they are processed as a batch, as opposed to per-device
|
|
// during syssetup
|
|
//
|
|
// since we will not be calling RunOnce again after this
|
|
// allow devices to call RunOnce immediately
|
|
// (other device install threads may be still running)
|
|
//
|
|
pSetupSetGlobalFlags(pSetupGetGlobalFlags()&~PSPGF_NO_RUNONCE);
|
|
CallRunOnceAndWait();
|
|
END_SECTION(L"Install enumerated devices triggered by legacy devices");
|
|
|
|
//
|
|
// Mark all non-present devices as needing re-install
|
|
// we do this a 2nd time in case a device "disappeared" due to the
|
|
// re-installation of a parent device
|
|
// This operation is very fast, so we don't need to upgrade the progress bar.
|
|
//
|
|
if( !MiniSetup ) {
|
|
MarkPnpDevicesAsNeedReinstall();
|
|
}
|
|
|
|
if( Context->SendWmQuit ) {
|
|
// #if 0
|
|
ULONG Error = ERROR_SUCCESS;
|
|
// #endif
|
|
|
|
//
|
|
// We send WM_QUIT only if this routine was started as a separate thread.
|
|
// Otherwise, the WM_QUIT will be processed by the wizard, and it will make it stop.
|
|
//
|
|
// PostThreadMessage(Context->ThreadId,WM_QUIT,b,0);
|
|
// #if 0
|
|
do {
|
|
if( !PostThreadMessage(Context->ThreadId,WM_QUIT,b,0) ) {
|
|
Error = GetLastError();
|
|
SetupDebugPrint1( L"SETUP: PostThreadMessage(WM_QUIT) failed. Error = %d", Error );
|
|
}
|
|
} while ( Error != ERROR_SUCCESS );
|
|
// #endif
|
|
}
|
|
|
|
return( b );
|
|
}
|
|
|
|
|
|
BOOL
|
|
InstallPnpDevices(
|
|
IN HWND hwndParent,
|
|
IN HINF InfHandle,
|
|
IN HWND ProgressWindow,
|
|
IN ULONG StartAtPercent,
|
|
IN ULONG StopAtPercent
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function creates and starts the thread responsible for installation of
|
|
PnP devices.
|
|
|
|
Arguments:
|
|
|
|
hwndParent - Handle to a top level window that may be used for UI purposes
|
|
|
|
InfHandle - System setup inf handle (syssetup.inf).
|
|
|
|
ProgressWindow - Handle to the progress bar.
|
|
|
|
StartAtPercent - Starting position in the progress bar.
|
|
It indicates that from position 0 to this position
|
|
the gauge is already filled.
|
|
|
|
StopAtPercent - Ending position of the progress bar.
|
|
The pnp thread should not fill the progress bar beyond
|
|
this position
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE if all the PnP devices installed successfully.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL Success = TRUE;
|
|
DWORD ThreadId;
|
|
HANDLE ThreadHandle = NULL;
|
|
PNP_THREAD_PARAMS Context;
|
|
MSG msg;
|
|
|
|
|
|
Context.ThreadId = GetCurrentThreadId();
|
|
Context.Window = hwndParent;
|
|
Context.ProgressWindow = ProgressWindow;
|
|
Context.InfHandle = InfHandle;
|
|
Context.ProgressWindowStartAtPercent = StartAtPercent;
|
|
Context.ProgressWindowStopAtPercent = StopAtPercent;
|
|
Context.SendWmQuit = TRUE;
|
|
|
|
ThreadHandle = CreateThread(
|
|
NULL,
|
|
0,
|
|
pInstallPnpDevicesThread,
|
|
&Context,
|
|
0,
|
|
&ThreadId
|
|
);
|
|
if(ThreadHandle) {
|
|
|
|
CloseHandle(ThreadHandle);
|
|
|
|
//
|
|
// Pump the message queue and wait for the thread to finish.
|
|
//
|
|
do {
|
|
GetMessage(&msg,NULL,0,0);
|
|
if(msg.message != WM_QUIT) {
|
|
DispatchMessage(&msg);
|
|
}
|
|
} while(msg.message != WM_QUIT);
|
|
|
|
Success = (BOOL)msg.wParam;
|
|
|
|
} else {
|
|
//
|
|
// Just do it synchronously.
|
|
//
|
|
Context.SendWmQuit = FALSE;
|
|
Success = pInstallPnpDevicesThread(&Context);
|
|
}
|
|
|
|
return(Success);
|
|
}
|
|
|
|
|
|
BOOL
|
|
UpdatePnpDeviceDrivers(
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function goes through all the installed devices and makes sure
|
|
it has the latest and greatest driver.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE if there are no fatal errors.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL bRet = FALSE;
|
|
HINSTANCE hInstNewDev;
|
|
ExternalUpdateDriverForPlugAndPlayDevicesW pUpdateDriverForPlugAndPlayDevicesW = NULL;
|
|
HDEVINFO DeviceInfoSet;
|
|
|
|
// We need the "UpdateDriverForPlugAndPlayDevices" function from newdev.dll.
|
|
//
|
|
if ( NULL == (hInstNewDev = LoadLibrary(L"newdev.dll")) )
|
|
{
|
|
SetupDebugPrint1(L"SETUP: Failed to load newdev.dll. Error = %d", GetLastError());
|
|
return bRet;
|
|
}
|
|
pUpdateDriverForPlugAndPlayDevicesW =
|
|
(ExternalUpdateDriverForPlugAndPlayDevicesW) GetProcAddress(hInstNewDev, "UpdateDriverForPlugAndPlayDevicesW");
|
|
if ( NULL == pUpdateDriverForPlugAndPlayDevicesW )
|
|
{
|
|
SetupDebugPrint1(L"SETUP: Failed to get UpdateDriverForPlugAndPlayDevicesW. Error = %d", GetLastError());
|
|
}
|
|
// Create a device information set that will be the container for
|
|
// the device interfaces.
|
|
//
|
|
else if ( INVALID_HANDLE_VALUE == (DeviceInfoSet = SetupDiCreateDeviceInfoList(NULL, NULL)) )
|
|
{
|
|
SetupDebugPrint1(L"SETUP: Failed SetupDiCreateDeviceInfoList(). Error = %d", GetLastError());
|
|
}
|
|
else
|
|
{
|
|
HDEVINFO NewDeviceInfoSet;
|
|
|
|
// Get the list of all present devices.
|
|
//
|
|
NewDeviceInfoSet = SetupDiGetClassDevsEx(NULL,
|
|
NULL,
|
|
NULL,
|
|
DIGCF_ALLCLASSES | DIGCF_PRESENT,
|
|
DeviceInfoSet,
|
|
NULL,
|
|
NULL);
|
|
if ( INVALID_HANDLE_VALUE == NewDeviceInfoSet )
|
|
{
|
|
SetupDebugPrint1(L"SETUP: Failed SetupDiGetClassDevsEx(). Error = %d", GetLastError());
|
|
}
|
|
else
|
|
{
|
|
SP_DEVINFO_DATA DeviceInfoData;
|
|
DWORD dwDevice;
|
|
|
|
// Once we get this far, the default return is TRUE.
|
|
//
|
|
bRet = TRUE;
|
|
|
|
// Setup the device info data structutre.
|
|
//
|
|
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
|
|
|
|
// Loop through all the devices.
|
|
//
|
|
for ( dwDevice = 0; SetupDiEnumDeviceInfo(NewDeviceInfoSet, dwDevice, &DeviceInfoData); dwDevice++ )
|
|
{
|
|
SP_DEVINSTALL_PARAMS DeviceInstallParams;
|
|
SP_DRVINFO_DATA NewDriverInfoData;
|
|
PSP_DRVINFO_DETAIL_DATA pNewDriverInfoDetailData = NULL;
|
|
DWORD cbBytesNeeded = 0;
|
|
TCHAR szDeviceID[MAX_DEVICE_ID_LEN];
|
|
|
|
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
NewDriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
|
|
|
|
if ( SetupDiGetDeviceInstallParams(NewDeviceInfoSet,
|
|
&DeviceInfoData,
|
|
&DeviceInstallParams) )
|
|
{
|
|
DeviceInstallParams.FlagsEx |= DI_FLAGSEX_EXCLUDE_OLD_INET_DRIVERS;
|
|
SetupDiSetDeviceInstallParams(NewDeviceInfoSet,
|
|
&DeviceInfoData,
|
|
&DeviceInstallParams);
|
|
}
|
|
|
|
// Build the list of possible drivers for this device.
|
|
// Select the best compatible driver for this device.
|
|
// Retrieve information about the driver node selected above.
|
|
// Get driver info details.
|
|
//
|
|
if ( ( SetupDiBuildDriverInfoList(NewDeviceInfoSet,
|
|
&DeviceInfoData,
|
|
SPDIT_COMPATDRIVER ) ) &&
|
|
|
|
( SetupDiCallClassInstaller(DIF_SELECTBESTCOMPATDRV,
|
|
NewDeviceInfoSet,
|
|
&DeviceInfoData ) ) &&
|
|
|
|
( SetupDiGetSelectedDriver(NewDeviceInfoSet,
|
|
&DeviceInfoData,
|
|
&NewDriverInfoData ) ) &&
|
|
|
|
( ( SetupDiGetDriverInfoDetail(NewDeviceInfoSet,
|
|
&DeviceInfoData,
|
|
&NewDriverInfoData,
|
|
NULL,
|
|
0,
|
|
&cbBytesNeeded) ) ||
|
|
( GetLastError() == ERROR_INSUFFICIENT_BUFFER ) ) &&
|
|
|
|
( cbBytesNeeded ) &&
|
|
|
|
( pNewDriverInfoDetailData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cbBytesNeeded) ) &&
|
|
|
|
( pNewDriverInfoDetailData->cbSize = sizeof(SP_DRVINFO_DETAIL_DATA) ) &&
|
|
|
|
( SetupDiGetDriverInfoDetail(NewDeviceInfoSet,
|
|
&DeviceInfoData,
|
|
&NewDriverInfoData,
|
|
pNewDriverInfoDetailData,
|
|
cbBytesNeeded,
|
|
NULL) ) &&
|
|
|
|
( SetupDiGetDeviceRegistryProperty(NewDeviceInfoSet,
|
|
&DeviceInfoData,
|
|
SPDRP_HARDWAREID,
|
|
NULL,
|
|
(LPBYTE) szDeviceID,
|
|
sizeof(szDeviceID),
|
|
NULL) ) )
|
|
|
|
{
|
|
HKEY hDevRegKey;
|
|
BOOL bUpdate = TRUE,
|
|
bRebootFlag;
|
|
|
|
// Get the device's regkey, so that we can get the
|
|
// version of the currently installed driver.
|
|
//
|
|
if ( INVALID_HANDLE_VALUE != (hDevRegKey = SetupDiOpenDevRegKey(NewDeviceInfoSet,
|
|
&DeviceInfoData,
|
|
DICS_FLAG_GLOBAL,
|
|
0,
|
|
DIREG_DRV,
|
|
KEY_READ)) )
|
|
{
|
|
TCHAR szInfPath[MAX_PATH],
|
|
szInfName[MAX_PATH];
|
|
DWORD dwSize = sizeof(szInfName),
|
|
dwType;
|
|
|
|
szInfPath[0] = L'\0';
|
|
GetSystemWindowsDirectory(szInfPath, sizeof(szInfPath) / sizeof(TCHAR));
|
|
|
|
if ( ( szInfPath[0] ) &&
|
|
|
|
( pSetupConcatenatePaths(szInfPath,
|
|
L"INF",
|
|
sizeof(szInfPath) / sizeof(TCHAR),
|
|
NULL) ) &&
|
|
|
|
( ERROR_SUCCESS == RegQueryValueEx(hDevRegKey,
|
|
REGSTR_VAL_INFPATH,
|
|
NULL,
|
|
&dwType,
|
|
(LPBYTE) &szInfName,
|
|
&dwSize) ) &&
|
|
|
|
( pSetupConcatenatePaths(szInfPath,
|
|
szInfName,
|
|
sizeof(szInfPath) / sizeof(TCHAR),
|
|
NULL) ) &&
|
|
|
|
( CSTR_EQUAL == CompareString(LOCALE_SYSTEM_DEFAULT,
|
|
NORM_IGNORECASE,
|
|
pNewDriverInfoDetailData->InfFileName,
|
|
-1,
|
|
szInfPath,
|
|
-1) ) )
|
|
{
|
|
// The inf we found is already in the %windir%\inf folder and is already
|
|
// installed. So we don't want to install this inf again.
|
|
//
|
|
bUpdate = FALSE;
|
|
}
|
|
|
|
// Make sure we close the key.
|
|
//
|
|
RegCloseKey(hDevRegKey);
|
|
}
|
|
|
|
// Check to see if we have the possibility of a better driver and
|
|
// try to install it if we do.
|
|
//
|
|
if ( bUpdate &&
|
|
!pUpdateDriverForPlugAndPlayDevicesW(NULL,
|
|
szDeviceID,
|
|
pNewDriverInfoDetailData->InfFileName,
|
|
0,
|
|
&bRebootFlag) )
|
|
{
|
|
SetupDebugPrint1(L"SETUP: Failed to install updated driver. Error = %d", GetLastError());
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
//else
|
|
//{
|
|
//
|
|
// SetupDebugPrint1(L"SETUP: No installed Driver. Error = %d", GetLastError());
|
|
// SetupDebugPrint(L"SETUP: No best compatible driver.");
|
|
// SetupDebugPrint(L"SETUP: Unable to get new driver info.");
|
|
// SetupDebugPrint1(L"SETUP: Unable to get new driver detail data. Error = %d", GetLastError());
|
|
//
|
|
//}
|
|
|
|
// Free this if allocated.
|
|
//
|
|
if ( pNewDriverInfoDetailData )
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, pNewDriverInfoDetailData);
|
|
}
|
|
|
|
}
|
|
|
|
// Make sure we clean up the list.
|
|
//
|
|
SetupDiDestroyDeviceInfoList(NewDeviceInfoSet);
|
|
}
|
|
|
|
// Make sure we clean up the list.
|
|
//
|
|
SetupDiDestroyDeviceInfoList(DeviceInfoSet);
|
|
}
|
|
|
|
FreeLibrary(hInstNewDev);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
#ifdef PNP_DEBUG_UI
|
|
INT
|
|
CompareListboxItems(
|
|
IN PCOMPAREITEMSTRUCT Items
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called in response to a WM_COMPAREITEM.
|
|
It compares two item of type LISTBOX_ITEM.
|
|
|
|
Arguments:
|
|
|
|
Items - Pointer to a structure that contains the information
|
|
about the items to compare.
|
|
|
|
Return Value:
|
|
|
|
-1 ... Item1 precedes Item2 in the sorted order.
|
|
0 ... Item1 and Item2 are identical in the sorted order.
|
|
1 ... Item2 precedes Item1 in the sorted order.
|
|
|
|
--*/
|
|
|
|
{
|
|
PLISTBOX_ITEM ListBoxItem1;
|
|
PLISTBOX_ITEM ListBoxItem2;
|
|
|
|
ListBoxItem1 = (PLISTBOX_ITEM)(Items->itemData1);
|
|
ListBoxItem2 = (PLISTBOX_ITEM)(Items->itemData2);
|
|
|
|
// SetupDebugPrint( L"SETUP: Entering CompareListboxItems()" );
|
|
// SetupDebugPrint( L"SETUP: IconIdex1 = %d, DeviceDescription1 = %ls", ListBoxItem1->IconIndex, ListBoxItem1->IconIndex );
|
|
// SetupDebugPrint( L"SETUP: IconIdex2 = %d, DeviceDescription1 = %ls", ListBoxItem2->IconIndex, ListBoxItem2->IconIndex );
|
|
|
|
if( ( ListBoxItem1->IconIndex > ListBoxItem2->IconIndex ) ||
|
|
( ( ListBoxItem1->IconIndex == ListBoxItem2->IconIndex ) &&
|
|
( _wcsicmp( ListBoxItem1->DeviceDescription, ListBoxItem2->DeviceDescription ) > 0 )
|
|
)
|
|
) {
|
|
// SetupDebugPrint( L"SETUP: Leaving CompareListboxItems(). Return value = 1" );
|
|
return( 1 );
|
|
} else if( ( ListBoxItem1->IconIndex < ListBoxItem2->IconIndex ) ||
|
|
( ( ListBoxItem1->IconIndex == ListBoxItem2->IconIndex ) &&
|
|
( _wcsicmp( ListBoxItem1->DeviceDescription, ListBoxItem2->DeviceDescription ) < 0 )
|
|
)
|
|
) {
|
|
// SetupDebugPrint( L"SETUP: Leaving CompareListboxItems(). Return value = -1" );
|
|
return( -1 );
|
|
} else {
|
|
// SetupDebugPrint( L"SETUP: Leaving CompareListboxItems(). Return value = 0" );
|
|
return( 0 );
|
|
}
|
|
}
|
|
#endif // PNP_DEBUG_UI
|
|
|
|
|
|
#ifdef PNP_DEBUG_UI
|
|
VOID
|
|
DrawItem(
|
|
LPDRAWITEMSTRUCT lpdis
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Draw a device description in an owner drawn list box.
|
|
|
|
Arguments:
|
|
|
|
lpdis - Pointer to the sructure that contains the item to
|
|
be drawn in the listbox.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
HDC hDc = lpdis->hDC;
|
|
int dxString, bkModeSave;
|
|
DWORD dwBackColor, dwTextColor;
|
|
UINT itemState=lpdis->itemState;
|
|
RECT rcItem=lpdis->rcItem;
|
|
SIZE size;
|
|
|
|
PLISTBOX_ITEM ListBoxItem;
|
|
PWSTR DeviceDescription;
|
|
|
|
|
|
MYASSERT( lpdis->CtlType & ODT_LISTBOX );
|
|
|
|
if((int)lpdis->itemID < 0) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// extract the DeviceDescription from DRAWITEM struct
|
|
//
|
|
ListBoxItem = (PLISTBOX_ITEM)lpdis->itemData;
|
|
DeviceDescription = ListBoxItem->DeviceDescription;
|
|
|
|
GetTextExtentPoint32(hDc,DeviceDescription,wcslen(DeviceDescription),&size);
|
|
|
|
if(lpdis->itemAction != ODA_FOCUS) {
|
|
|
|
bkModeSave = GetBkMode(hDc);
|
|
|
|
dwBackColor = SetBkColor(hDc, GetSysColor((itemState & ODS_SELECTED) ?
|
|
COLOR_HIGHLIGHT : COLOR_WINDOW));
|
|
dwTextColor = SetTextColor(hDc, GetSysColor((itemState & ODS_SELECTED) ?
|
|
COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT));
|
|
|
|
//
|
|
// fill in the background; do this before mini-icon is drawn
|
|
//
|
|
ExtTextOut(hDc, 0, 0, ETO_OPAQUE, &rcItem, NULL, 0, NULL);
|
|
|
|
//
|
|
// draw mini-icon for this device and move string accordingly
|
|
//
|
|
dxString = SetupDiDrawMiniIcon(
|
|
hDc,
|
|
rcItem,
|
|
ListBoxItem->IconIndex,
|
|
(itemState & ODS_SELECTED) ? MAKELONG(DMI_BKCOLOR, COLOR_HIGHLIGHT) : 0
|
|
);
|
|
|
|
//
|
|
// draw the text transparently on top of the background
|
|
//
|
|
SetBkMode(hDc, TRANSPARENT);
|
|
ExtTextOut(hDc, dxString + rcItem.left, rcItem.top +
|
|
((rcItem.bottom - rcItem.top) - size.cy) / 2,
|
|
0, NULL, DeviceDescription, wcslen(DeviceDescription), NULL);
|
|
|
|
//
|
|
// Restore hdc colors.
|
|
//
|
|
SetBkColor(hDc, dwBackColor);
|
|
SetTextColor(hDc, dwTextColor);
|
|
SetBkMode(hDc, bkModeSave);
|
|
}
|
|
|
|
if(lpdis->itemAction == ODA_FOCUS || (itemState & ODS_FOCUS)) {
|
|
DrawFocusRect(hDc, &rcItem);
|
|
}
|
|
}
|
|
#endif // PNP_DEBUG_UI
|
|
|
|
|
|
#ifdef PNP_DEBUG_UI
|
|
BOOL
|
|
CALLBACK
|
|
InstalledHardwareDlgProc(
|
|
IN HWND hdlg,
|
|
IN UINT msg,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Dialog procedure for the installed hardware dialog.
|
|
|
|
Arguments:
|
|
|
|
hWnd - a handle to the dialog proceedure.
|
|
|
|
msg - the message passed from Windows.
|
|
|
|
wParam - extra message dependent data.
|
|
|
|
lParam - extra message dependent data.
|
|
|
|
|
|
Return Value:
|
|
|
|
TRUE if the value was edited. FALSE if cancelled or if no
|
|
changes were made.
|
|
|
|
--*/
|
|
{
|
|
NMHDR *NotifyParams;
|
|
|
|
switch(msg) {
|
|
|
|
case WM_INITDIALOG: {
|
|
|
|
PDEVINFOSET_ELEMENT p;
|
|
|
|
// SetupDebugPrint( L"SETUP: InstalledHardwareDlgProc() received WM_INITDIALOG" );
|
|
if( UiTest ) {
|
|
//
|
|
// If testing the wizard, make sure that the page is
|
|
// displayed
|
|
//
|
|
break;
|
|
}
|
|
|
|
szUnknownDevice = MyLoadString( IDS_DEVNAME_UNK );
|
|
for( p = DevInfoSetList; p != NULL; p = p->Next ) {
|
|
ULONG Index;
|
|
ULONG Error;
|
|
|
|
for( Index = 0; ; Index++ ) {
|
|
LONG i;
|
|
PLISTBOX_ITEM ListBoxItem;
|
|
|
|
PWSTR TempString;
|
|
|
|
|
|
ListBoxItem = MyMalloc( sizeof( LISTBOX_ITEM ) );
|
|
if( ListBoxItem == NULL ) {
|
|
SetupDebugPrint( L"SETUP: Out of memory: InstalledHardwareDlgProc()" );
|
|
continue;
|
|
}
|
|
|
|
ListBoxItem->DevInfoSet = p->DevInfoSet;
|
|
ListBoxItem->DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
|
|
ListBoxItem->IconIndex = UNKNOWN_DEVICE_ICON_INDEX;
|
|
*(ListBoxItem->DeviceDescription) = L'\0';
|
|
if( szUnknownDevice != NULL ) {
|
|
wcscpy( ListBoxItem->DeviceDescription, szUnknownDevice );
|
|
}
|
|
|
|
if( SetupDiEnumDeviceInfo( p->DevInfoSet, Index, &(ListBoxItem->DeviceInfoData) ) ) {
|
|
ULONG Size;
|
|
|
|
if( SetupDiGetDeviceRegistryProperty( ListBoxItem->DevInfoSet,
|
|
&(ListBoxItem->DeviceInfoData),
|
|
SPDRP_FRIENDLYNAME,
|
|
NULL,
|
|
(PBYTE)(ListBoxItem->DeviceDescription),
|
|
LINE_LEN * sizeof( WCHAR ), // sizeof( DeviceDescription ),
|
|
NULL ) ) {
|
|
SetupDebugPrint( L"SETUP: Device = %d, Description = %ls", Index, ListBoxItem->DeviceDescription );
|
|
} else {
|
|
SetupDebugPrint( L"SETUP: Device = %d, No friendly name", Index );
|
|
if( SetupDiGetDeviceRegistryProperty( ListBoxItem->DevInfoSet,
|
|
&(ListBoxItem->DeviceInfoData),
|
|
SPDRP_DEVICEDESC,
|
|
NULL,
|
|
(PBYTE)(ListBoxItem->DeviceDescription),
|
|
LINE_LEN * sizeof( WCHAR ), // sizeof( DeviceDescription ),
|
|
NULL ) ) {
|
|
SetupDebugPrint( L"SETUP: Device = %d, Description = %ls", Index, ListBoxItem->DeviceDescription );
|
|
} else {
|
|
SetupDebugPrint( L"SETUP: Device = %d, Description = Unknown device", Index );
|
|
}
|
|
}
|
|
if( !SetupDiLoadClassIcon( &(ListBoxItem->DeviceInfoData.ClassGuid),
|
|
NULL,
|
|
&(ListBoxItem->IconIndex) ) ) {
|
|
SetupDebugPrint( L"SETUP: SetupDiLoadClassIcon() failed. Error = %d, Description = %ls", GetLastError(), ListBoxItem->DeviceDescription );
|
|
}
|
|
|
|
} else {
|
|
Error = GetLastError();
|
|
MyFree( ListBoxItem );
|
|
if( Error == ERROR_NO_MORE_ITEMS ) {
|
|
break;
|
|
} else {
|
|
SetupDebugPrint( L"SETUP: Device = %d, Description = Unknown device", Index );
|
|
}
|
|
}
|
|
|
|
i = SendDlgItemMessage( hdlg, IDC_LIST1, LB_ADDSTRING, 0, (LPARAM)ListBoxItem );
|
|
SetupDebugPrint( L"SETUP: SendDlgItemMessage() returned i = %d", i );
|
|
}
|
|
}
|
|
//
|
|
// Disable the 'Properties' button
|
|
//
|
|
// EnableWindow( GetDlgItem( hdlg, IDB_BUTTON_1 ), FALSE );
|
|
break;
|
|
}
|
|
|
|
case WM_IAMVISIBLE:
|
|
break;
|
|
|
|
case WM_SIMULATENEXT:
|
|
// Simulate the next button somehow
|
|
PropSheet_PressButton( GetParent(hdlg), PSBTN_NEXT);
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
|
|
NotifyParams = (NMHDR *)lParam;
|
|
|
|
switch(NotifyParams->code) {
|
|
|
|
case PSN_SETACTIVE:
|
|
TESTHOOK(509);
|
|
BEGIN_SECTION(L"Installed Hardware Page");
|
|
// Make page visible
|
|
SendMessage(GetParent(hdlg), WMX_BBTEXT, (WPARAM)FALSE, 0);
|
|
SetWizardButtons(hdlg,WizPageInstalledHardware);
|
|
if(Unattended) {
|
|
UnattendSetActiveDlg(hdlg,IDD_HARDWARE);
|
|
}
|
|
break;
|
|
|
|
case PSN_WIZNEXT:
|
|
case PSN_WIZFINISH:
|
|
//
|
|
// Allow next page to be activated.
|
|
//
|
|
SetWindowLong(hdlg,DWL_MSGRESULT,0);
|
|
break;
|
|
|
|
case PSN_KILLACTIVE:
|
|
WizardKillHelp(hdlg);
|
|
SetWindowLong(hdlg,DWL_MSGRESULT, FALSE);
|
|
END_SECTION(L"Installed Hardware Page");
|
|
break;
|
|
|
|
case PSN_HELP:
|
|
WizardBringUpHelp(hdlg,WizPageInstalledHardware);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_DRAWITEM:
|
|
|
|
DrawItem( (LPDRAWITEMSTRUCT)lParam );
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
{
|
|
LONG Count;
|
|
LONG i;
|
|
PLISTBOX_ITEM ListBoxItem;
|
|
|
|
// SetupDebugPrint( L"SETUP: InstalledHardwareDlgProc() received WM_DESTROY" );
|
|
Count = SendDlgItemMessage( hdlg, IDC_LIST1, LB_GETCOUNT, 0, 0);
|
|
if( Count != LB_ERR ) {
|
|
for( i = 0; i < Count; i++ ) {
|
|
ListBoxItem = (PLISTBOX_ITEM)SendDlgItemMessage( hdlg, IDC_LIST1, LB_GETITEMDATA, (WPARAM)i, 0);
|
|
if( (LONG)ListBoxItem != LB_ERR ) {
|
|
MyFree( ListBoxItem );
|
|
} else {
|
|
SetupDebugPrint( L"SETUP: SendDlgItemMessage( LB_GETITEMDATA ) failed. Index = %d, Error = %d", i, GetLastError() );
|
|
}
|
|
}
|
|
} else {
|
|
SetupDebugPrint( L"SETUP: SendDlgItemMessage( LB_GETCOUNT ) failed. Error = %d", GetLastError() );
|
|
}
|
|
return( FALSE );
|
|
}
|
|
|
|
case WM_COMPAREITEM:
|
|
return( CompareListboxItems( (PCOMPAREITEMSTRUCT)lParam ) );
|
|
|
|
case WM_COMMAND:
|
|
|
|
switch( LOWORD( wParam ) ) {
|
|
|
|
case IDC_LIST1:
|
|
{
|
|
switch( HIWORD( wParam )) {
|
|
|
|
case LBN_SELCHANGE:
|
|
{
|
|
//
|
|
// Enable the 'Properties' button
|
|
//
|
|
EnableWindow( GetDlgItem( hdlg, IDB_BUTTON_1 ),
|
|
TRUE );
|
|
return( FALSE );
|
|
}
|
|
|
|
case LBN_DBLCLK:
|
|
{
|
|
//
|
|
// Simulate that the 'Properties' button was pushed
|
|
//
|
|
SendMessage( hdlg,
|
|
WM_COMMAND,
|
|
MAKEWPARAM( IDB_BUTTON_1, BN_CLICKED ),
|
|
( LPARAM ) GetDlgItem( hdlg, IDB_BUTTON_1 ) );
|
|
return( FALSE );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case IDB_BUTTON_1:
|
|
return( FALSE );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return(FALSE);
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
#endif // PNP_DEBUG_UI
|
|
|
|
|
|
VOID
|
|
SortClassGuidListForDetection(
|
|
IN OUT LPGUID GuidList,
|
|
IN ULONG GuidCount,
|
|
OUT PULONG LastBatchedDetect
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine sorts the supplied list of GUID based on a (partial)
|
|
ordering specified in the [DetectionOrder] and [NonBatchedDetection]
|
|
sections of syssetup.inf. This allows us to maintain a detection
|
|
ordering similar to previous versions of NT, and also to allow for
|
|
class installers that may depend upon the successful installation of
|
|
devices detected by other class installers.
|
|
|
|
Arguments:
|
|
|
|
GuidList - address of the array of GUIDs to be sorted.
|
|
|
|
GuidCount - the number of GUIDs in the array. This number must be > 0.
|
|
|
|
LastBatchedDetect - Supplies the address of a variable that will
|
|
receive the index of the last GUID in the array that may be batched
|
|
together (i.e., all detections are run, all files queued into one
|
|
big queue, etc.). Any GUIDs existing at higher indices must be
|
|
processed individually, and such processing will happen _after_ the
|
|
batched detection is completed.
|
|
|
|
Return Value:
|
|
|
|
none.
|
|
|
|
--*/
|
|
{
|
|
LONG LineCount, LineIndex, GuidIndex, NextTopmost;
|
|
PCWSTR CurGuidString;
|
|
INFCONTEXT InfContext;
|
|
GUID CurGuid;
|
|
|
|
MYASSERT(GuidCount > 0);
|
|
|
|
*LastBatchedDetect = GuidCount - 1;
|
|
|
|
//
|
|
// First, sort the classes in syssetup.inf's [DetectionOrder] list to the
|
|
// front...
|
|
//
|
|
LineCount = SetupGetLineCount(SyssetupInf, L"DetectionOrder");
|
|
NextTopmost = 0;
|
|
|
|
for(LineIndex = 0; LineIndex < LineCount; LineIndex++) {
|
|
|
|
if(!SetupGetLineByIndex(SyssetupInf, L"DetectionOrder", LineIndex, &InfContext) ||
|
|
((CurGuidString = pSetupGetField(&InfContext, 1)) == NULL) ||
|
|
(pSetupGuidFromString(CurGuidString, &CurGuid) != NO_ERROR)) {
|
|
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Search through the GUID list looking for this GUID. If found, move the GUID from
|
|
// it's current position to the next topmost position.
|
|
//
|
|
for(GuidIndex = 0; GuidIndex < (LONG)GuidCount; GuidIndex++) {
|
|
|
|
if(IsEqualGUID(&CurGuid, &(GuidList[GuidIndex]))) {
|
|
|
|
if(NextTopmost != GuidIndex) {
|
|
//
|
|
// We should never be moving the GUID _down_ the list.
|
|
//
|
|
MYASSERT(NextTopmost < GuidIndex);
|
|
|
|
MoveMemory(&(GuidList[NextTopmost + 1]),
|
|
&(GuidList[NextTopmost]),
|
|
(GuidIndex - NextTopmost) * sizeof(GUID)
|
|
);
|
|
|
|
CopyMemory(&(GuidList[NextTopmost]),
|
|
&CurGuid,
|
|
sizeof(GUID)
|
|
);
|
|
}
|
|
|
|
NextTopmost++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now, move any classes in syssetup.inf's [NonBatchedDetection] list to
|
|
// the end...
|
|
//
|
|
LineCount = SetupGetLineCount(SyssetupInf, L"NonBatchedDetection");
|
|
|
|
for(LineIndex = 0; LineIndex < LineCount; LineIndex++) {
|
|
|
|
if(!SetupGetLineByIndex(SyssetupInf, L"NonBatchedDetection", LineIndex, &InfContext) ||
|
|
((CurGuidString = pSetupGetField(&InfContext, 1)) == NULL) ||
|
|
(pSetupGuidFromString(CurGuidString, &CurGuid) != NO_ERROR)) {
|
|
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Search through the GUID list looking for this GUID. If found, move
|
|
// the GUID from it's current position to the end of the list.
|
|
//
|
|
for(GuidIndex = 0; GuidIndex < (LONG)GuidCount; GuidIndex++) {
|
|
|
|
if(IsEqualGUID(&CurGuid, &(GuidList[GuidIndex]))) {
|
|
//
|
|
// We found a non-batched class--decrement our index that
|
|
// points to the last batched detection class.
|
|
//
|
|
(*LastBatchedDetect)--;
|
|
|
|
//
|
|
// Now shift all the GUIDs after this one up, and move this one
|
|
// to the last position in the array (unless, of course, it was
|
|
// already at the last position in the array).
|
|
//
|
|
if(GuidIndex < (LONG)(GuidCount - 1)) {
|
|
|
|
MoveMemory(&(GuidList[GuidIndex]),
|
|
&(GuidList[GuidIndex+1]),
|
|
(GuidCount - (GuidIndex+1)) * sizeof(GUID)
|
|
);
|
|
CopyMemory(&(GuidList[GuidCount-1]),
|
|
&CurGuid,
|
|
sizeof(GUID)
|
|
);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
DWORD
|
|
pPhase1InstallPnpLegacyDevicesThread(
|
|
PPNP_PHASE1_LEGACY_DEV_THREAD_PARAMS ThreadParams
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This thread does the initial part of the installation installation
|
|
of legacy Pnp devices of a particular class.
|
|
|
|
It invokes a class installer of a particular class with:
|
|
|
|
- DIF_FIRSTTIMESETUP
|
|
|
|
If it successds, it returns in the structure passed as argument
|
|
a device info list that contains the detected legacy devices.
|
|
|
|
Arguments:
|
|
|
|
ThreadParams - Points to a structure that contains the information
|
|
passed to this thread.
|
|
|
|
Return Value:
|
|
|
|
Returns a Win32 error code.
|
|
|
|
--*/
|
|
|
|
{
|
|
PPNP_PHASE1_LEGACY_DEV_THREAD_PARAMS Context;
|
|
|
|
LPGUID pGuid;
|
|
PWSTR pClassDescription;
|
|
|
|
HDEVINFO hEmptyDevInfo;
|
|
ULONG Error;
|
|
|
|
//
|
|
// Initialize variables
|
|
//
|
|
Context = ThreadParams;
|
|
Context->hDevInfo = INVALID_HANDLE_VALUE;
|
|
pGuid = &(Context->Guid);
|
|
pClassDescription = Context->pClassDescription;
|
|
|
|
//
|
|
// Assume success
|
|
//
|
|
Error = ERROR_SUCCESS;
|
|
|
|
//
|
|
// DIF_FIRSTTIME
|
|
//
|
|
if((hEmptyDevInfo = SetupDiCreateDeviceInfoList(pGuid,
|
|
Context->hwndParent))
|
|
== INVALID_HANDLE_VALUE) {
|
|
Error = GetLastError();
|
|
SetupDebugPrint2( L"SETUP: SetupDiCreateDeviceInfoList() failed (phase1). Error = %d, ClassDescription = %ls", Error, pClassDescription );
|
|
goto phase1_legacy_dev_thread_exit;
|
|
}
|
|
|
|
if( !SetupDiCallClassInstaller( DIF_FIRSTTIMESETUP,
|
|
hEmptyDevInfo,
|
|
NULL ) ) {
|
|
|
|
Error = GetLastError();
|
|
if( Error != ERROR_DI_DO_DEFAULT ) {
|
|
SetupDebugPrint2( L"SETUP: SetupDiCallClassInstaller(DIF_FIRSTTIMESETUP) failed (phase1). Error = %lx, ClassDescription = %ls", Error, pClassDescription );
|
|
} else {
|
|
SetupDebugPrint2( L"SETUP: SetupDiCallClassInstaller(DIF_FIRSTTIMESETUP) failed (phase1). Error = %lx, ClassDescription = %ls", Error, pClassDescription );
|
|
}
|
|
SetupDiDestroyDeviceInfoList(hEmptyDevInfo);
|
|
goto phase1_legacy_dev_thread_exit;
|
|
}
|
|
//
|
|
// Save the info set after DIF_FIRSTTIMESETUP
|
|
//
|
|
Context->hDevInfo = hEmptyDevInfo;
|
|
SetupDebugPrint1( L"SETUP: SetupDiCallClassInstaller(DIF_FIRSTTIMESETUP) succeeded (phase1). ClassDescription = %ls", pClassDescription );
|
|
|
|
phase1_legacy_dev_thread_exit:
|
|
return(Error);
|
|
}
|
|
|
|
|
|
DWORD
|
|
pPhase2InstallPnpLegacyDevicesThread(
|
|
PPNP_PHASE2_LEGACY_DEV_THREAD_PARAMS ThreadParams
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This thread does a partial installation of a legacy device.
|
|
It invokes a class installer with:
|
|
|
|
- DIF_REGISTERDEVICE
|
|
- DIF_ALLOW_INSTALL
|
|
- DIF_INSTALLDEVICEFILES
|
|
|
|
Note that the call with DIF_INSTALLDEVICEFILES only queue the files on the queue
|
|
created by the parent of this handle.
|
|
|
|
Arguments:
|
|
|
|
ThreadParams - Points to a structure that contains the information
|
|
passed to this thread.
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE is all calls to the class installer were successfull.
|
|
Otherwise, returns FALSE.
|
|
|
|
--*/
|
|
|
|
{
|
|
PPNP_PHASE2_LEGACY_DEV_THREAD_PARAMS Context;
|
|
|
|
HDEVINFO hDevInfo;
|
|
HSPFILEQ FileQ;
|
|
HSPFILEQ TempFileQ = INVALID_HANDLE_VALUE;
|
|
PSP_DEVINFO_DATA pDeviceInfoData;
|
|
PWSTR pClassDescription;
|
|
PWSTR pDeviceId;
|
|
|
|
BOOL b;
|
|
ULONG Error;
|
|
SP_DEVINSTALL_PARAMS DeviceInstallParams;
|
|
DWORD ScanQueueResult;
|
|
|
|
//
|
|
// Initialize variables
|
|
//
|
|
Context = ThreadParams;
|
|
hDevInfo = Context->hDevInfo;
|
|
FileQ = Context->FileQ;
|
|
pDeviceInfoData = &(Context->DeviceInfoData);
|
|
pClassDescription = Context->pClassDescription;
|
|
pDeviceId = Context->pDeviceId;
|
|
|
|
//
|
|
// Assume success
|
|
//
|
|
Error = ERROR_SUCCESS;
|
|
b = TRUE;
|
|
|
|
//
|
|
// Let the class installer/co-installers know they should be quiet.
|
|
//
|
|
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
if(!SetupDiGetDeviceInstallParams(hDevInfo, pDeviceInfoData, &DeviceInstallParams)) {
|
|
SetupDebugPrint2( L"SETUP: SetupDiGetDeviceInstallParams() failed (phase2). Error = %d, DeviceId = %ls", GetLastError(), pDeviceId );
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
|
|
DeviceInstallParams.Flags |= DI_QUIETINSTALL;
|
|
|
|
if(!SetupDiSetDeviceInstallParams(hDevInfo, pDeviceInfoData, &DeviceInstallParams)) {
|
|
SetupDebugPrint2( L"SETUP: SetupDiSetDeviceInstallParams() failed (phase2). Error = %d, DeviceId = %ls", GetLastError(), pDeviceId );
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
|
|
//
|
|
// Register the device
|
|
//
|
|
if( !SetupDiCallClassInstaller( DIF_REGISTERDEVICE,
|
|
hDevInfo,
|
|
pDeviceInfoData ) ) {
|
|
|
|
SetupDebugPrint2( L"SETUP: SetupDiCallClassInstaller(DIF_REGISTERDEVICE) failed (phase2). Error = %lx, DeviceId = %ls", GetLastError(), pDeviceId );
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
|
|
//
|
|
// Verify with the class installer and class-specific co-installers that the
|
|
// driver we're about to install isn't blacklisted.
|
|
//
|
|
if( !SetupDiCallClassInstaller( DIF_ALLOW_INSTALL,
|
|
hDevInfo,
|
|
pDeviceInfoData ) ) {
|
|
Error = GetLastError();
|
|
if( Error != ERROR_DI_DO_DEFAULT ) {
|
|
SetupDebugPrint2( L"SETUP: SetupDiCallClassInstaller(DIF_ALLOW_INSTALL) failed (phase2). Error = %d, DeviceId = %ls", Error, pDeviceId );
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
}
|
|
|
|
//
|
|
// In general, any devices being installed as a result of DIF_FIRSTTIMESETUP
|
|
// will be using in-box drivers, and as such, will be signed. However, it
|
|
// is possible that a built-in class installer will report a detected device
|
|
// that's using a 3rd-party, unsigned driver. The ScsiAdapter class is such
|
|
// a case. If we _do_ encounter unsigned driver packages, we want to avoid
|
|
// media prompting, just like we do when installing PnP-enumerated devices.
|
|
// Unfortunately, this is complicated in the legacy case by the fact that we
|
|
// queue all files into one big queue, then commit the queue in an all-or-
|
|
// nothing fashion. Thus, we don't have the same granularity that we have
|
|
// when installing PnP-enumerated devices in a one-at-a-time fashion.
|
|
//
|
|
// To address this, we will first queue up all files to a "temporary" queue,
|
|
// which we will then examine in a similar fashion to the way we handle the
|
|
// per-device queues for PnP-enumerated devices. If the catalog nodes
|
|
// associated with the queue are all signed, then we'll queue up those same
|
|
// files to our "real" queue. If one or more catalog nodes are not signed,
|
|
// we'll then do a queue scan based on presence checking. If all files
|
|
// required are present, then we'll add nothing to the "real" queue, but
|
|
// allow the device to be subsequently installed. If one or more required
|
|
// files are found to be missing, we're in a bad state, because queueing
|
|
// these files up to our "real" queue means the user will (potentially) see
|
|
// a driver signing warning popup and/or media prompt, either of which they
|
|
// may cancel out of. Since the legacy device install queue is one big
|
|
// queue containing fileops for all such device installs, cancelling its
|
|
// committal would result in none of the files being copied for any phase2
|
|
// install. Thus, multimedia codecs, non-motherboard legacy COM ports, and
|
|
// other (signed) system devices wouldn't get installed. Since this is
|
|
// obviously unacceptable, we instead simply skip installation for this
|
|
// device, just as if DIF_ALLOWINSTALL had failed. This isn't as bad as it
|
|
// sounds, because it would be _exceedingly_ rare if a 3rd-party driver's
|
|
// device were reported, yet all necessary files weren't present.
|
|
//
|
|
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
if(!SetupDiGetDeviceInstallParams(hDevInfo, pDeviceInfoData, &DeviceInstallParams)) {
|
|
SetupDebugPrint2( L"SETUP: SetupDiGetDeviceInstallParams() failed for TempFileQueue (phase2). Error = %d, DeviceId = %ls", GetLastError(), pDeviceId );
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
|
|
//
|
|
// Note: this code has had the following comment (and behavior) for a _long_
|
|
// time...
|
|
//
|
|
// "we may rely on this flag being set this early"
|
|
//
|
|
// The DI_FORCECOPY flag actually has no effect on any setupapi activity
|
|
// except for installation of class installer files via
|
|
// SetupDiInstallClass(Ex). However, it's possible some class-/co-installer
|
|
// has developed a dependency on its presence, and since it doesn't hurt
|
|
// anything, we'll continue to set it.
|
|
//
|
|
DeviceInstallParams.Flags |= DI_FORCECOPY;
|
|
|
|
TempFileQ = SetupOpenFileQueue();
|
|
if(TempFileQ == INVALID_HANDLE_VALUE) {
|
|
SetupDebugPrint2( L"SETUP: SetupOpenFileQueue() failed for TempFileQueue (phase2). Error = %d, DeviceId = %ls", GetLastError(), pDeviceId );
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
|
|
DeviceInstallParams.Flags |= DI_NOVCP;
|
|
DeviceInstallParams.FileQueue = TempFileQ;
|
|
|
|
if(!SetupDiSetDeviceInstallParams(hDevInfo, pDeviceInfoData, &DeviceInstallParams)) {
|
|
SetupDebugPrint2( L"SETUP: SetupDiSetDeviceInstallParams() failed for TempFileQueue (phase2). Error = %d, DeviceId = %ls", GetLastError(), pDeviceId );
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
|
|
//
|
|
// Queue the device files into our temporary file queue
|
|
//
|
|
if(SetupDiCallClassInstaller(DIF_INSTALLDEVICEFILES,
|
|
hDevInfo,
|
|
pDeviceInfoData)) {
|
|
Error = ERROR_SUCCESS;
|
|
|
|
} else {
|
|
|
|
Error = GetLastError();
|
|
|
|
if(Error == ERROR_DI_DO_DEFAULT) {
|
|
//
|
|
// This isn't actually an error
|
|
//
|
|
Error = ERROR_SUCCESS;
|
|
} else {
|
|
SetupDebugPrint2( L"SETUP: SetupDiCallClassInstaller(DIF_INSTALLDEVICEFILES) failed for TempFileQueue (phase2). Error = %lx, DeviceId = %ls", Error, pDeviceId );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Disassociate the temporary file queue from the device information
|
|
// element so that we can free it later...
|
|
//
|
|
DeviceInstallParams.Flags &= ~DI_NOVCP;
|
|
DeviceInstallParams.FileQueue = INVALID_HANDLE_VALUE;
|
|
|
|
if(!SetupDiSetDeviceInstallParams(hDevInfo, pDeviceInfoData, &DeviceInstallParams)) {
|
|
SetupDebugPrint2( L"SETUP: SetupDiSetDeviceInstallParams() failed for disassociating TempFileQueue (phase2). Error = %d, DeviceId = %ls", GetLastError(), pDeviceId );
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
|
|
if(Error == ERROR_SUCCESS) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiCallClassInstaller(DIF_INSTALLDEVICEFILES) suceeded for TempFileQueue (phase2). DeviceId = %ls", pDeviceId );
|
|
} else {
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
|
|
//
|
|
// Now that we've retrieved all files operations into our temporary file
|
|
// queue, we can "pre-verify" the catalog nodes in the queue. If an OEM
|
|
// INF in %windir%\Inf is unsigned, we scan the queue to see if all
|
|
// required files are present (although not validated) in their target
|
|
// locations. If we're doing an upgrade, and all files are in-place, we'll
|
|
// forego queue committal. If we're doing a fresh-install, and all files
|
|
// are in-place, we'll commit the empty queue on-the-spot, so that the user
|
|
// will get the driver signing popup (based on policy), thus may
|
|
// potentially abort the installation of this device. If all files aren't
|
|
// already in-place, we silently abort the device installation, as we can't
|
|
// run the risk of queueing up potentially-cancellable fileops to the
|
|
// "real" legacy device install queue.
|
|
//
|
|
if(NO_ERROR != pSetupVerifyQueuedCatalogs(TempFileQ)) {
|
|
//
|
|
// We only want to prune based on presence check for OEM INFs living in
|
|
// %windir%\Inf.
|
|
//
|
|
SP_DRVINFO_DATA DriverInfoData;
|
|
SP_DRVINFO_DETAIL_DATA DriverInfoDetailData;
|
|
|
|
//
|
|
// Retrieve the name of the INF associated with the selected driver
|
|
// node.
|
|
//
|
|
DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
|
|
if(!SetupDiGetSelectedDriver(hDevInfo, pDeviceInfoData, &DriverInfoData)) {
|
|
SetupDebugPrint2( L"SETUP: SetupDiGetSelectedDriver() failed. Error = %d, Device = %ls", GetLastError(), pDeviceId );
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
|
|
DriverInfoDetailData.cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
|
|
if(!SetupDiGetDriverInfoDetail(hDevInfo,
|
|
pDeviceInfoData,
|
|
&DriverInfoData,
|
|
&DriverInfoDetailData,
|
|
sizeof(DriverInfoDetailData),
|
|
NULL) &&
|
|
(GetLastError() != ERROR_INSUFFICIENT_BUFFER)) {
|
|
|
|
SetupDebugPrint2( L"SETUP: SetupDiGetDriverInfoDetail() failed. Error = %d, Device = %ls", GetLastError(), pDeviceId );
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
|
|
if(pSetupInfIsFromOemLocation(DriverInfoDetailData.InfFileName, TRUE) ||
|
|
IsInfInLayoutInf(DriverInfoDetailData.InfFileName)) {
|
|
//
|
|
// Either the INF lives somewhere other than %windir%\Inf, or its
|
|
// an in-box unsigned INF. In either case, we want to
|
|
// abort installation of this device, otherwise we risk having the
|
|
// user cancel the queue committal, and wipe out all the other
|
|
// detected device installs as well.
|
|
//
|
|
SetupDebugPrint2( L"SETUP: Skipping unsigned driver install for detected device (phase2). DeviceId = %ls, Inf = %ls", pDeviceId, DriverInfoDetailData.InfFileName );
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
|
|
} else {
|
|
//
|
|
// Note: it doesn't really matter whether we do an "all-or-nothing"
|
|
// scan or a pruning scan here, because we're going to abort the
|
|
// install on anything other than a fully empty (post-scan) queue.
|
|
// We request pruning here, because that fits better with the
|
|
// semantics of SPQ_SCAN_PRUNE_DELREN (this flag's semantics
|
|
// don't really fit with a non-pruning scan, as discussed in RAID
|
|
// #280543).
|
|
//
|
|
if(!SetupScanFileQueue(TempFileQ,
|
|
SPQ_SCAN_FILE_PRESENCE |
|
|
SPQ_SCAN_PRUNE_COPY_QUEUE |
|
|
SPQ_SCAN_PRUNE_DELREN,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&ScanQueueResult)) {
|
|
//
|
|
// SetupScanFileQueue failed for some reason (rare). We'll
|
|
// just commit the whole file queue...
|
|
//
|
|
ScanQueueResult = 0;
|
|
}
|
|
|
|
if(ScanQueueResult != 1) {
|
|
//
|
|
// Abort installation of this device, otherwise we risk having
|
|
// the user cancel the queue committal, and wipe out all the
|
|
// other detected device installs as well.
|
|
//
|
|
SetupDebugPrint1( L"SETUP: Skipping unsigned driver install for detected device due to missing files (phase2). DeviceId = %ls", pDeviceId );
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
|
|
if(!Upgrade) {
|
|
|
|
PVOID QCBContext;
|
|
|
|
//
|
|
// No fileops left in queue, but we're doing a fresh install,
|
|
// so we still want to give user driver signing popup (logging
|
|
// the event to setupapi.log), and let them potentially abort
|
|
// the unsigned installation...
|
|
//
|
|
QCBContext = InitSysSetupQueueCallbackEx(
|
|
DeviceInstallParams.hwndParent,
|
|
INVALID_HANDLE_VALUE,
|
|
0,
|
|
0,
|
|
NULL
|
|
);
|
|
|
|
if(!QCBContext) {
|
|
SetupDebugPrint1( L"SETUP: Failed to allocate queue callback context (phase2). DeviceId = %ls", pDeviceId );
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
|
|
if(!SetupCommitFileQueue(DeviceInstallParams.hwndParent,
|
|
TempFileQ,
|
|
SysSetupQueueCallback,
|
|
QCBContext)) {
|
|
//
|
|
// User elected not to proceed with the unsigned installation.
|
|
//
|
|
SetupDebugPrint2( L"SETUP: SetupCommitFileQueue() failed (phase2). Error = %d, Device = %ls", GetLastError(), pDeviceId );
|
|
b = FALSE;
|
|
}
|
|
|
|
TermSysSetupQueueCallback(QCBContext);
|
|
|
|
if(!b) {
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// Queue the files to be copied for this device to the "real" file queue
|
|
//
|
|
if( FileQ != INVALID_HANDLE_VALUE ) {
|
|
DeviceInstallParams.Flags |= DI_NOVCP;
|
|
DeviceInstallParams.FileQueue = FileQ;
|
|
}
|
|
|
|
if(!SetupDiSetDeviceInstallParams(hDevInfo, pDeviceInfoData, &DeviceInstallParams)) {
|
|
SetupDebugPrint2( L"SETUP: SetupDiSetDeviceInstallParams() failed (phase2). Error = %d, DeviceId = %ls", GetLastError(), pDeviceId );
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
|
|
//
|
|
// Install the device files (queue the files)
|
|
//
|
|
Error = ERROR_SUCCESS;
|
|
if( !SetupDiCallClassInstaller( DIF_INSTALLDEVICEFILES,
|
|
hDevInfo,
|
|
pDeviceInfoData ) &&
|
|
( ( Error = GetLastError() ) != ERROR_DI_DO_DEFAULT )
|
|
) {
|
|
|
|
SetupDebugPrint2( L"SETUP: SetupDiCallClassInstaller(DIF_INSTALLDEVICEFILES) failed (phase2). Error = %lx, DeviceId = %ls", Error, pDeviceId );
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
SetupDebugPrint1( L"SETUP: SetupDiCallClassInstaller(DIF_INSTALLDEVICEFILES) suceeded (phase2). DeviceId = %ls", pDeviceId );
|
|
}
|
|
|
|
//
|
|
// Mark the device as 'Do install'
|
|
//
|
|
if( !pSetupDiSetDeviceInfoContext( hDevInfo, pDeviceInfoData, TRUE ) ) {
|
|
SetupDebugPrint2( L"SETUP: pSetupDiSetDeviceInfoContext() failed (phase2). Error = %lx, DeviceId = %ls", GetLastError(), pDeviceId );
|
|
b = FALSE;
|
|
goto phase2_legacy_dev_thread_exit;
|
|
}
|
|
|
|
phase2_legacy_dev_thread_exit:
|
|
|
|
if(TempFileQ != INVALID_HANDLE_VALUE) {
|
|
SetupCloseFileQueue(TempFileQ);
|
|
}
|
|
|
|
return(b);
|
|
}
|
|
|
|
|
|
BOOL
|
|
CheckIfDeviceHasWizardPages( HDEVINFO hDevInfo,
|
|
PSP_DEVINFO_DATA pDeviceInfoData
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine invokes the class installer with
|
|
DIF_NEWDEVICEWIZARD_FINISHINSTALL to determine if the device has wizard
|
|
pages to display.
|
|
|
|
Arguments:
|
|
|
|
hDevInfo - The device info set.
|
|
pDeviceInfoData - The device that needs to be marked
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE if the device has FINISHINSTALL wizard pages, FALSE otherwise
|
|
--*/
|
|
|
|
{
|
|
SP_NEWDEVICEWIZARD_DATA ndwd = {0};
|
|
BOOL b;
|
|
|
|
// Check if this device has wizard pages that need to be shown as
|
|
// part of the install. If so, we will mark the device as
|
|
// nneding a reinstall so the UI can be display later
|
|
//
|
|
|
|
ndwd.ClassInstallHeader.cbSize = sizeof( SP_CLASSINSTALL_HEADER );
|
|
ndwd.ClassInstallHeader.InstallFunction = DIF_NEWDEVICEWIZARD_FINISHINSTALL;
|
|
|
|
// Set the install params for the function
|
|
b = SetupDiSetClassInstallParams( hDevInfo, pDeviceInfoData,
|
|
(PSP_CLASSINSTALL_HEADER) ( &ndwd ),
|
|
sizeof( ndwd ) );
|
|
if ( b ) {
|
|
|
|
// Invoke the class installer (and co-installers)
|
|
b = SetupDiCallClassInstaller( DIF_NEWDEVICEWIZARD_FINISHINSTALL,
|
|
hDevInfo,
|
|
pDeviceInfoData );
|
|
if ( b || (ERROR_DI_DO_DEFAULT == GetLastError())) {
|
|
|
|
// Retrieve the install params
|
|
b = SetupDiGetClassInstallParams( hDevInfo,
|
|
pDeviceInfoData,
|
|
(PSP_CLASSINSTALL_HEADER)&ndwd,
|
|
sizeof(ndwd),
|
|
NULL );
|
|
if ( b ) {
|
|
|
|
// Are there any pages?
|
|
if ( 0 == ndwd.NumDynamicPages ) {
|
|
b = FALSE;
|
|
}
|
|
else {
|
|
// b is already TRUE if we made it here so no need to set
|
|
UINT i;
|
|
|
|
// We don't need the pages so destroy them
|
|
for ( i = 0; i < ndwd.NumDynamicPages; i++ ) {
|
|
DestroyPropertySheetPage( ndwd.DynamicPages[i] );
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetClassInstallParams failed (phase3). Error = %lx", GetLastError() );
|
|
}
|
|
}
|
|
else if ( ERROR_DI_DO_DEFAULT != GetLastError() ) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiCallClassInstaller(DIF_NEWDEVICEWIZARD_FINISHINSTALL) failed (phase3). Error = %lx", GetLastError() );
|
|
}
|
|
}
|
|
else {
|
|
SetupDebugPrint1( L"SETUP: SetupDiSetClassInstallParams failed. Error = %lx", GetLastError() );
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
BOOL
|
|
MarkDeviceAsNeedsReinstallIfNeeded(
|
|
HDEVINFO hDevInfo,
|
|
PSP_DEVINFO_DATA pDeviceInfoData
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function checks if a device has wizard pages
|
|
(DIF_NEWDEVICEWIZARD_FINISHINSTALL pages) and sets the REINSTALL
|
|
config flag if it does.
|
|
|
|
Arguments:
|
|
|
|
hDevInfo - The device info set.
|
|
pDeviceInfoData - The device whose config flags will set.
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE if successful, FALSE on error.
|
|
|
|
--*/
|
|
{
|
|
DWORD ConfigFlags;
|
|
BOOL b = TRUE;
|
|
|
|
if (CheckIfDeviceHasWizardPages( hDevInfo, pDeviceInfoData ) ) {
|
|
|
|
SetupDebugPrint( L"SETUP: Device has wizard pages, marking as need reinstall." );
|
|
|
|
//
|
|
// Get the config flags for the device and set the reinstall bit
|
|
//
|
|
if ( !( b = GetDeviceConfigFlags(hDevInfo, pDeviceInfoData, &ConfigFlags ) ) ) {
|
|
SetupDebugPrint( L"SETUP: GetDeviceConfigFlags failed. " );
|
|
}
|
|
|
|
if ( b ) {
|
|
|
|
ConfigFlags |= CONFIGFLAG_REINSTALL;
|
|
|
|
if ( !( b = SetDeviceConfigFlags(hDevInfo, pDeviceInfoData, ConfigFlags ) ) ) {
|
|
|
|
SetupDebugPrint( L"SETUP: SetDeviceConfigFlags failed. " );
|
|
}
|
|
}
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
DWORD
|
|
pPhase3InstallPnpLegacyDevicesThread(
|
|
PPNP_PHASE3_LEGACY_DEV_THREAD_PARAMS ThreadParams
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This thread completes the installation of a legacy device.
|
|
It invokes a class installer with:
|
|
|
|
- DIF_REGISTER_COINSTALLERS
|
|
- DIF_INSTALLINTERFACES
|
|
- DIF_INSTALLDEVICE
|
|
|
|
Arguments:
|
|
|
|
ThreadParams - Points to a structure that contains the information
|
|
passed to this thread.
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE if all calls to the class installer were successfull.
|
|
Otherwise, returns FALSE.
|
|
|
|
--*/
|
|
|
|
{
|
|
PPNP_PHASE3_LEGACY_DEV_THREAD_PARAMS Context;
|
|
|
|
HDEVINFO hDevInfo;
|
|
PSP_DEVINFO_DATA pDeviceInfoData;
|
|
SP_DEVINSTALL_PARAMS DeviceInstallParams;
|
|
PWSTR pDeviceId;
|
|
|
|
BOOL b;
|
|
WCHAR DeviceDescription[MAX_PATH];
|
|
DWORD Status;
|
|
DWORD Problem;
|
|
BOOL fNewDevice = FALSE;
|
|
|
|
|
|
Context = ThreadParams;
|
|
hDevInfo = Context->hDevInfo;
|
|
pDeviceInfoData = &(Context->DeviceInfoData);
|
|
pDeviceId = Context->pDeviceId;
|
|
|
|
b = TRUE;
|
|
|
|
//
|
|
// Register any device-specific co-installers for this device.
|
|
//
|
|
if( !SetupDiCallClassInstaller(DIF_REGISTER_COINSTALLERS, hDevInfo, pDeviceInfoData ) ) {
|
|
SetupDebugPrint2( L"SETUP: SetupDiCallClassInstaller(DIF_REGISTER_COINSTALLERS) failed (phase3). Error = %d, DeviceId = %ls", GetLastError(), pDeviceId );
|
|
b = FALSE;
|
|
goto phase3_legacy_dev_thread_exit;
|
|
}
|
|
|
|
//
|
|
// Install any INF/class installer-specified interfaces.
|
|
//
|
|
if( !SetupDiCallClassInstaller(DIF_INSTALLINTERFACES, hDevInfo, pDeviceInfoData) ) {
|
|
SetupDebugPrint2( L"SETUP: SetupDiCallClassInstaller(DIF_REGISTER_INSTALLINTERFACES) failed (phase3). Error = %d, DeviceId = %ls", GetLastError(), pDeviceId );
|
|
b = FALSE;
|
|
goto phase3_legacy_dev_thread_exit;
|
|
}
|
|
|
|
//
|
|
// Before we install this device, we need to find out if it is a new
|
|
// device or a reinstall. If the problem CM_PROB_NOT_CONFIGURED is set
|
|
// then we will consider it as a new device and check if it has wizard
|
|
// pages after DIF_INSTALLDEVICE
|
|
//
|
|
if ( CR_SUCCESS == CM_Get_DevInst_Status(&Status,
|
|
&Problem,
|
|
(DEVINST)pDeviceInfoData->DevInst,
|
|
0 ) && (Problem & CM_PROB_NOT_CONFIGURED) )
|
|
{
|
|
fNewDevice = TRUE;
|
|
}
|
|
|
|
//
|
|
// Set the DI_FLAGSEX_RESTART_DEVICE_ONLY for legacy device installs. This
|
|
// flag tells setupapi to only stop/start this one device and not all
|
|
// devices that share the same drivers with this device.
|
|
//
|
|
// This is not critical if this fails since by default setupapi will just
|
|
// stop/start all devices that share drivers with this device, including
|
|
// the device itself. This can cause stop/start to take a little longer
|
|
// if there are lots of devices sharing drivers with this device.
|
|
//
|
|
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
if(SetupDiGetDeviceInstallParams(hDevInfo, pDeviceInfoData, &DeviceInstallParams)) {
|
|
|
|
DeviceInstallParams.FlagsEx |= DI_FLAGSEX_RESTART_DEVICE_ONLY;
|
|
|
|
SetupDiSetDeviceInstallParams(hDevInfo, pDeviceInfoData, &DeviceInstallParams);
|
|
}
|
|
|
|
if( !SetupDiCallClassInstaller( DIF_INSTALLDEVICE,
|
|
hDevInfo,
|
|
pDeviceInfoData ) ) {
|
|
|
|
SetupDebugPrint2( L"SETUP: SetupDiCallClassInstaller(DIF_INSTALLDEVICE) failed (phase3). Error = %lx, DeviceId = %ls", GetLastError(), pDeviceId );
|
|
b = FALSE;
|
|
goto phase3_legacy_dev_thread_exit;
|
|
}
|
|
DeviceDescription[0] = L'\0';
|
|
if( !SetupDiGetDeviceRegistryProperty( hDevInfo,
|
|
pDeviceInfoData,
|
|
SPDRP_DEVICEDESC,
|
|
NULL,
|
|
(PBYTE)DeviceDescription,
|
|
sizeof( DeviceDescription ),
|
|
NULL ) ) {
|
|
SetupDebugPrint2( L"SETUP: SetupDiGetDeviceRegistryProperty() failed. Error = %d, DeviceId = %ls", GetLastError(), pDeviceId );
|
|
}
|
|
SetupDebugPrint2( L"SETUP: Device installed. DeviceId = %ls, Description = %ls", pDeviceId, DeviceDescription );
|
|
|
|
|
|
//
|
|
// If the device has wizard pages to show (in response to
|
|
// DIF_NEWDEVICEWIZARD_FINISHINSTALL) then it needs to be marked as need
|
|
// reinstall so that pages get a chance to be shown at a later time
|
|
//
|
|
if ( fNewDevice ) {
|
|
b = MarkDeviceAsNeedsReinstallIfNeeded( hDevInfo, pDeviceInfoData);
|
|
}
|
|
|
|
|
|
phase3_legacy_dev_thread_exit:
|
|
return( b );
|
|
}
|
|
|
|
|
|
BOOL
|
|
GetDeviceConfigFlags(HDEVINFO hDevInfo, PSP_DEVINFO_DATA pDeviceInfoData,
|
|
DWORD* pdwConfigFlags)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function gets the configflags of a device.
|
|
|
|
Arguments:
|
|
|
|
hDevInfo - The device info set.
|
|
pDeviceInfoData - The device whose config flags will be retrieved.
|
|
pdwConfigFlags - The buffer that will receive the current flags.
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE if successful, FALSE on error.
|
|
|
|
--*/
|
|
{
|
|
BOOL b = TRUE;
|
|
DWORD Error;
|
|
|
|
//
|
|
// Clear the output parameter
|
|
//
|
|
*pdwConfigFlags = 0;
|
|
|
|
// Get the config flags for the device
|
|
if( !SetupDiGetDeviceRegistryProperty( hDevInfo,
|
|
pDeviceInfoData,
|
|
SPDRP_CONFIGFLAGS,
|
|
NULL,
|
|
(PBYTE)pdwConfigFlags,
|
|
sizeof( *pdwConfigFlags ),
|
|
NULL ) ) {
|
|
Error = GetLastError();
|
|
//
|
|
// ERROR_INVALID_DATA is ok. It means that the device doesn't have config flags set yet.
|
|
//
|
|
if( Error != ERROR_INVALID_DATA ) {
|
|
if( ((LONG)Error) < 0 ) {
|
|
//
|
|
// Setupapi error code, display it in hex
|
|
//
|
|
SetupDebugPrint1( L"SETUP: GetDeviceConfigFlags failed. Error = %lx", Error );
|
|
} else {
|
|
//
|
|
// win32 error code, display it in decimal
|
|
//
|
|
SetupDebugPrint1( L"SETUP: GetDeviceConfigFlags failed. Error = %d", Error );
|
|
}
|
|
b = FALSE;
|
|
}
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
BOOL
|
|
SetDeviceConfigFlags(HDEVINFO hDevInfo, PSP_DEVINFO_DATA pDeviceInfoData,
|
|
DWORD dwConfigFlags)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function sets the configflags of a device.
|
|
|
|
Arguments:
|
|
|
|
hDevInfo - The device info set.
|
|
pDeviceInfoData - The device whose config flags will set.
|
|
dwConfigFlags - The config flags to set.
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE if successful, FALSE on error.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL b = TRUE;
|
|
DWORD Error;
|
|
|
|
if( !SetupDiSetDeviceRegistryProperty( hDevInfo,
|
|
pDeviceInfoData,
|
|
SPDRP_CONFIGFLAGS,
|
|
(PBYTE)&dwConfigFlags,
|
|
sizeof( dwConfigFlags ) ) ) {
|
|
Error = GetLastError();
|
|
if( ((LONG)Error) < 0 ) {
|
|
//
|
|
// Setupapi error code, display it in hex
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetDeviceConfigFlags failed. Error = %lx", Error );
|
|
} else {
|
|
//
|
|
// win32 error code, display it in decimal
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetDeviceConfigFlags failed. Error = %d", Error );
|
|
}
|
|
b = FALSE;
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
|
|
DWORD
|
|
pInstallPnpEnumeratedDeviceThread(
|
|
PPNP_ENUM_DEV_THREAD_PARAMS ThreadParams
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the thread that does the installation of an enumerated PnP device.
|
|
|
|
Arguments:
|
|
|
|
ThreadParams - Points to a structure that contains the information
|
|
passed to this thread.
|
|
|
|
Return Value:
|
|
|
|
Returns a Win32 error code.
|
|
|
|
--*/
|
|
|
|
{
|
|
PPNP_ENUM_DEV_THREAD_PARAMS Context;
|
|
HDEVINFO hDevInfo;
|
|
PSP_DEVINFO_DATA pDeviceInfoData;
|
|
PSP_DEVINSTALL_PARAMS pDeviceInstallParams;
|
|
PWSTR pDeviceDescription;
|
|
PWSTR pDeviceId;
|
|
ULONG Error;
|
|
WCHAR RootPath[ MAX_PATH + 1];
|
|
SP_DEVINSTALL_PARAMS DeviceInstallParams;
|
|
DWORD Status;
|
|
DWORD Problem;
|
|
BOOL fNewDevice = FALSE;
|
|
DWORD ConfigFlags;
|
|
HSPFILEQ FileQ;
|
|
PVOID QContext;
|
|
HSPFILEQ SavedFileQ;
|
|
DWORD SavedFlags;
|
|
DWORD ScanQueueResult;
|
|
HWND hwndParent;
|
|
SP_DRVINFO_DATA pDriverInfoData;
|
|
HKEY hClassKey;
|
|
WCHAR InfPath[MAX_PATH];
|
|
BOOL fCommitFileQueue = TRUE;
|
|
BOOL fDriversChanged = FALSE;
|
|
DWORD FileQueueFlags;
|
|
|
|
Context = ThreadParams;
|
|
|
|
hDevInfo = Context->hDevInfo;
|
|
pDeviceInfoData = &(Context->DeviceInfoData);
|
|
pDeviceInstallParams = &DeviceInstallParams;
|
|
pDeviceDescription = Context->pDeviceDescription;
|
|
pDeviceId = Context->pDeviceId;
|
|
InfPath[0] = TEXT('\0');
|
|
|
|
Error = ERROR_SUCCESS;
|
|
|
|
//
|
|
// Queue all files to be copied into our own file queue.
|
|
//
|
|
FileQ = SetupOpenFileQueue();
|
|
|
|
if ( FileQ == (HSPFILEQ)INVALID_HANDLE_VALUE ) {
|
|
Error = GetLastError();
|
|
SetupDebugPrint2( L"SETUP: SetupOpenFileQueue() failed. Error = %d, Device = %ls", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
|
|
pDeviceInstallParams->cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
if(!SetupDiGetDeviceInstallParams(hDevInfo, pDeviceInfoData, pDeviceInstallParams)) {
|
|
Error = GetLastError();
|
|
SetupDebugPrint2( L"SETUP: SetupDiGetDeviceInstallParams() failed. Error = %d, Device = %ls", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
|
|
//
|
|
// Let the class installer/co-installers know that they should be quiet
|
|
//
|
|
pDeviceInstallParams->Flags |= DI_QUIETINSTALL;
|
|
|
|
if(!SetupDiSetDeviceInstallParams(hDevInfo, pDeviceInfoData, pDeviceInstallParams)) {
|
|
Error = GetLastError();
|
|
SetupDebugPrint2( L"SETUP: SetupDiSetDeviceInstallParams() failed. Error = %d, Device = %ls", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
|
|
//
|
|
// Install the class if it does not exist.
|
|
//
|
|
if (CM_Open_Class_Key(&pDeviceInfoData->ClassGuid,
|
|
NULL,
|
|
KEY_READ,
|
|
RegDisposition_OpenExisting,
|
|
&hClassKey,
|
|
CM_OPEN_CLASS_KEY_INSTALLER
|
|
) != CR_SUCCESS) {
|
|
|
|
HSPFILEQ ClassFileQ;
|
|
PVOID ClassQContext;
|
|
SP_DRVINFO_DETAIL_DATA DriverInfoDetailData;
|
|
|
|
ClassFileQ = SetupOpenFileQueue();
|
|
|
|
if ( ClassFileQ == (HSPFILEQ)INVALID_HANDLE_VALUE ) {
|
|
Error = GetLastError();
|
|
SetupDebugPrint2( L"SETUP: SetupOpenFileQueue() failed. Error = %d, Device = %ls", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
|
|
//
|
|
// First, we have to retrieve the name of the INF associated with the
|
|
// selected driver node.
|
|
//
|
|
pDriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
|
|
if (!SetupDiGetSelectedDriver(hDevInfo, pDeviceInfoData, &pDriverInfoData)) {
|
|
Error = GetLastError();
|
|
SetupDebugPrint2( L"SETUP: SetupDiGetSelectedDriver() failed. Error = %d, Device = %ls", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
|
|
DriverInfoDetailData.cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
|
|
if (!SetupDiGetDriverInfoDetail(hDevInfo,
|
|
pDeviceInfoData,
|
|
&pDriverInfoData,
|
|
&DriverInfoDetailData,
|
|
sizeof(DriverInfoDetailData),
|
|
NULL) &&
|
|
(GetLastError() != ERROR_INSUFFICIENT_BUFFER)) {
|
|
|
|
Error = GetLastError();
|
|
SetupDebugPrint2( L"SETUP: SetupDiGetDriverInfoDetail() failed. Error = %d, Device = %ls", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
|
|
if (!SetupDiInstallClass(NULL,
|
|
DriverInfoDetailData.InfFileName,
|
|
DI_NOVCP | DI_FORCECOPY,
|
|
ClassFileQ)) {
|
|
|
|
Error = GetLastError();
|
|
SetupDebugPrint3( L"SETUP: SetupDiInstallClass(%s) failed. Error = %d, Device = %ls", DriverInfoDetailData.InfFileName, Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
|
|
//
|
|
// Commit the file queue.
|
|
//
|
|
ClassQContext = InitSysSetupQueueCallbackEx(
|
|
NULL,
|
|
INVALID_HANDLE_VALUE,
|
|
0,0,NULL);
|
|
|
|
if( ClassQContext == NULL) {
|
|
Error = GetLastError();
|
|
SetupDebugPrint1( L"SETUP: InitSysSetupQueueCallbackEx() failed. Error = %d", Error );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
|
|
if (!SetupCommitFileQueue(
|
|
NULL,
|
|
ClassFileQ,
|
|
SysSetupQueueCallback,
|
|
ClassQContext
|
|
)) {
|
|
Error = GetLastError();
|
|
}
|
|
|
|
TermSysSetupQueueCallback(ClassQContext);
|
|
|
|
if ( ClassFileQ != (HSPFILEQ)INVALID_HANDLE_VALUE ) {
|
|
SetupCloseFileQueue( ClassFileQ );
|
|
}
|
|
|
|
if (Error == NO_ERROR) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiInstallClass() succeeded. Device = %ls", pDeviceDescription );
|
|
} else {
|
|
//
|
|
// We failed while installing the class so don't bother installing
|
|
// the device.
|
|
//
|
|
SetupDebugPrint3( L"SETUP: SetupCommitFileQueue(%s) failed while installing Class. Error = %d, Device = %ls", DriverInfoDetailData.InfFileName, Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// The class already exists.
|
|
//
|
|
RegCloseKey(hClassKey);
|
|
}
|
|
|
|
//
|
|
// Verify with the class installer and class-specific co-installers that the
|
|
// driver we're about to install isn't blacklisted.
|
|
//
|
|
if( !SetupDiCallClassInstaller(DIF_ALLOW_INSTALL,
|
|
hDevInfo,
|
|
pDeviceInfoData ) ) {
|
|
Error = GetLastError();
|
|
if( Error != ERROR_DI_DO_DEFAULT ) {
|
|
SetupDebugPrint2( L"SETUP: SetupDiCallClassInstaller(DIF_ALLOW_INSTALL) failed. Error = %d, Device = %ls", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
}
|
|
SetupDebugPrint1( L"SETUP: SetupDiCallClassInstaller(DIF_ALLOW_INSTALL) succeeded. Device = %ls", pDeviceDescription );
|
|
|
|
//
|
|
// Everything checks out. We're ready to pre-copy the driver files for this device.
|
|
//
|
|
pDeviceInstallParams->cbSize = sizeof(SP_DEVINSTALL_PARAMS);
|
|
if(!SetupDiGetDeviceInstallParams(hDevInfo, pDeviceInfoData, pDeviceInstallParams)) {
|
|
Error = GetLastError();
|
|
SetupDebugPrint2( L"SETUP: SetupDiGetDeviceInstallParams() failed. Error = %d, Device = %ls", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
|
|
pDeviceInstallParams->Flags |= DI_FORCECOPY;
|
|
|
|
SavedFileQ = pDeviceInstallParams->FileQueue;
|
|
SavedFlags = pDeviceInstallParams->Flags;
|
|
|
|
pDeviceInstallParams->FileQueue = FileQ;
|
|
pDeviceInstallParams->Flags |= DI_NOVCP;
|
|
|
|
//
|
|
// If the old, or existing, driver is an 3rd party driver and not the same
|
|
// as the current driver we are about to install, then back up the existing
|
|
// drivers.
|
|
//
|
|
if (pDoesExistingDriverNeedBackup(hDevInfo, pDeviceInfoData, InfPath, sizeof(InfPath)/sizeof(WCHAR))) {
|
|
SetupDebugPrint1( L"SETUP: Backing up 3rd party drivers for Device = %ls", pDeviceDescription );
|
|
pDeviceInstallParams->FlagsEx |= DI_FLAGSEX_PREINSTALLBACKUP;
|
|
}
|
|
|
|
//
|
|
// Remember the parent HWND because we may need it later...
|
|
//
|
|
hwndParent = pDeviceInstallParams->hwndParent;
|
|
|
|
if(!SetupDiSetDeviceInstallParams(hDevInfo, pDeviceInfoData, pDeviceInstallParams)) {
|
|
Error = GetLastError();
|
|
SetupDebugPrint2( L"SETUP: SetupDiSetDeviceInstallParams() failed. Error = %d, Device = %ls", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
|
|
//
|
|
// Install the device files
|
|
//
|
|
Error = ERROR_SUCCESS;
|
|
if( !SetupDiCallClassInstaller( DIF_INSTALLDEVICEFILES,
|
|
hDevInfo,
|
|
pDeviceInfoData ) &&
|
|
( ( Error = GetLastError() ) != ERROR_DI_DO_DEFAULT )
|
|
) {
|
|
|
|
SetupDebugPrint2( L"SETUP: SetupDiCallClassInstaller(DIF_INSTALLDEVICEFILES) failed. Error = %lx, Device = %ls ", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
|
|
}
|
|
SetupDebugPrint1( L"SETUP: SetupDiCallClassInstaller(DIF_INSTALLDEVICEFILES) succeeded. Device = %ls", pDeviceDescription );
|
|
|
|
//
|
|
// Commit the file queue.
|
|
//
|
|
QContext = InitSysSetupQueueCallbackEx(
|
|
NULL,
|
|
INVALID_HANDLE_VALUE,
|
|
0,0,NULL);
|
|
|
|
//
|
|
// "Pre-verify" the catalog nodes in the file queue. If an OEM INF in
|
|
// %windir%\Inf is unsigned, we scan the queue to see if all required files
|
|
// are present (although not validated) in their target locations. If
|
|
// we're doing an upgrade, and all files are in-place, we'll forego queue
|
|
// committal. If we're doing a fresh install, we'll still commit the
|
|
// queue, even if all files were present. This will result in a driver
|
|
// signing popup (based on policy). We do this to prevent subversion of
|
|
// driver signing due to someone "sneaking" all the files into place prior
|
|
// to GUI setup.
|
|
//
|
|
if(NO_ERROR != pSetupVerifyQueuedCatalogs(FileQ)) {
|
|
//
|
|
// We only want to prune based on presence check for OEM INFs living in
|
|
// %windir%\Inf.
|
|
//
|
|
SP_DRVINFO_DETAIL_DATA DriverInfoDetailData;
|
|
|
|
//
|
|
// Retrieve the name of the INF associated with the selected driver
|
|
// node.
|
|
//
|
|
pDriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
|
|
if (!SetupDiGetSelectedDriver(hDevInfo, pDeviceInfoData, &pDriverInfoData)) {
|
|
Error = GetLastError();
|
|
SetupDebugPrint2( L"SETUP: SetupDiGetSelectedDriver() failed. Error = %d, Device = %ls", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
|
|
DriverInfoDetailData.cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
|
|
if (!SetupDiGetDriverInfoDetail(hDevInfo,
|
|
pDeviceInfoData,
|
|
&pDriverInfoData,
|
|
&DriverInfoDetailData,
|
|
sizeof(DriverInfoDetailData),
|
|
NULL) &&
|
|
((Error = GetLastError()) != ERROR_INSUFFICIENT_BUFFER)) {
|
|
|
|
SetupDebugPrint2( L"SETUP: SetupDiGetDriverInfoDetail() failed. Error = %d, Device = %ls", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
|
|
//
|
|
// There is only one case where we want to skip commiting the file queue
|
|
// for an unsigned drivers, and all of the following must be true:
|
|
//
|
|
// - This is an upgrade.
|
|
// - The INF lives under %windir%\INF
|
|
// - The INF is NOT an in-box INF
|
|
// - The INF has the same name as the previous INF (if there was
|
|
// a previous INF)
|
|
// - No file copy operations (copy, delete, rename) need to be done.
|
|
//
|
|
if(Upgrade &&
|
|
!pSetupInfIsFromOemLocation(DriverInfoDetailData.InfFileName, TRUE) &&
|
|
!IsInfInLayoutInf(DriverInfoDetailData.InfFileName) &&
|
|
((InfPath[0] == TEXT('\0')) ||
|
|
(lstrcmpi(InfPath, pSetupGetFileTitle(DriverInfoDetailData.InfFileName)) == 0)) &&
|
|
SetupScanFileQueue(FileQ,
|
|
SPQ_SCAN_FILE_PRESENCE |
|
|
SPQ_SCAN_PRUNE_DELREN,
|
|
hwndParent,
|
|
NULL,
|
|
NULL,
|
|
&ScanQueueResult) &&
|
|
(ScanQueueResult == 1)) {
|
|
|
|
fCommitFileQueue = FALSE;
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// Prun the file queue.
|
|
//
|
|
SetupScanFileQueue(FileQ,
|
|
SPQ_SCAN_FILE_VALIDITY |
|
|
SPQ_SCAN_PRUNE_COPY_QUEUE |
|
|
SPQ_SCAN_PRUNE_DELREN,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&ScanQueueResult);
|
|
}
|
|
|
|
//
|
|
// If this device is the computer itself (i.e., the HAL, kernel, and other
|
|
// platform-specific files), then we shouldn't need to copy anything, since
|
|
// all the right files were copied during textmode setup. However, these
|
|
// files will _not_ have been pruned from the file queue if they came from
|
|
// HAL.INF because they're marked as COPYFLG_NOPRUNE in that INF. This is
|
|
// done so that doing an "update driver" from a UP HAL to an MP one works
|
|
// properly. (Pruning gets in the way here, since we consider the properly-
|
|
// signed UP files on the system to be perfectly acceptable, thus don't
|
|
// bother with copying over the MP versions.)
|
|
//
|
|
// In order to avoid re-copying the HAL, kernel, etc., we just always skip
|
|
// this queue committal if the device is of class "Computer".
|
|
//
|
|
if(IsEqualGUID(&(pDeviceInfoData->ClassGuid), &GUID_DEVCLASS_COMPUTER)) {
|
|
fCommitFileQueue = FALSE;
|
|
}
|
|
|
|
Error = ERROR_SUCCESS;
|
|
|
|
if (fCommitFileQueue) {
|
|
if (!SetupCommitFileQueue(
|
|
NULL,
|
|
FileQ,
|
|
SysSetupQueueCallback,
|
|
QContext
|
|
)) {
|
|
Error = GetLastError();
|
|
}
|
|
}
|
|
|
|
if (SetupGetFileQueueFlags(FileQ, &FileQueueFlags) &&
|
|
(FileQueueFlags & SPQ_FLAG_FILES_MODIFIED)) {
|
|
//
|
|
// One of the driver files has changed for this device. This means
|
|
// a full restart of the device, and all other devices shareing
|
|
// one of its drivers is in order.
|
|
//
|
|
fDriversChanged = TRUE;
|
|
}
|
|
|
|
TermSysSetupQueueCallback(QContext);
|
|
|
|
if (Error != ERROR_SUCCESS) {
|
|
SetupDebugPrint2( L"SETUP: SetupCommitFileQueue() failed. Error = %d, Device = %ls", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
|
|
//
|
|
// If no driver files changed then we only need to restart this device.
|
|
//
|
|
if (!fDriversChanged) {
|
|
pDeviceInstallParams->FlagsEx |= DI_FLAGSEX_RESTART_DEVICE_ONLY;
|
|
}
|
|
|
|
pDeviceInstallParams->FileQueue = SavedFileQ;
|
|
pDeviceInstallParams->Flags = (SavedFlags | DI_NOFILECOPY) ;
|
|
|
|
if(!SetupDiSetDeviceInstallParams(hDevInfo, pDeviceInfoData, pDeviceInstallParams)) {
|
|
Error = GetLastError();
|
|
SetupDebugPrint2( L"SETUP: SetupDiSetDeviceInstallParams() failed. Error = %d, Device = %ls", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
|
|
//
|
|
// Make sure that the files get flushed to disk
|
|
//
|
|
GetWindowsDirectory(RootPath,sizeof(RootPath)/sizeof(WCHAR));
|
|
RootPath[3] = L'\0';
|
|
FlushFilesToDisk( RootPath );
|
|
|
|
//
|
|
// Register any device-specific co-installers for this device.
|
|
//
|
|
if( !SetupDiCallClassInstaller(DIF_REGISTER_COINSTALLERS,
|
|
hDevInfo,
|
|
pDeviceInfoData ) ) {
|
|
Error = GetLastError();
|
|
SetupDebugPrint2( L"SETUP: SetupDiCallClassInstaller(DIF_REGISTER_COINSTALLERS) failed. Error = %d, Device = %ls", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
SetupDebugPrint1( L"SETUP: SetupDiCallClassInstaller(DIF_REGISTER_COINSTALLERS) succeeded. Device = %ls", pDeviceDescription );
|
|
|
|
//
|
|
// Install any INF/class installer-specified interfaces.
|
|
//
|
|
if( !SetupDiCallClassInstaller(DIF_INSTALLINTERFACES,
|
|
hDevInfo,
|
|
pDeviceInfoData) ) {
|
|
Error = GetLastError();
|
|
SetupDebugPrint2( L"SETUP: SetupDiCallClassInstaller(DIF_REGISTER_INSTALLINTERFACES) failed. Error = %d, Device = %ls", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
}
|
|
SetupDebugPrint1( L"SETUP: SetupDiCallClassInstaller(DIF_INSTALLINTERFACES) succeeded. Device = %ls", pDeviceDescription );
|
|
|
|
|
|
//
|
|
// Before we install this device, we need to find out if it is a new
|
|
// device or a reinstall. If the problem CM_PROB_NOT_CONFIGURED is set
|
|
// then we will consider it as a new device and check if it has wizard
|
|
// pages after DIF_INSTALLDEVICE
|
|
//
|
|
if ( CR_SUCCESS == CM_Get_DevInst_Status(&Status,
|
|
&Problem,
|
|
(DEVINST)pDeviceInfoData->DevInst,
|
|
0 ) && (Problem & CM_PROB_NOT_CONFIGURED) )
|
|
{
|
|
fNewDevice = TRUE;
|
|
}
|
|
|
|
//
|
|
// Install the device
|
|
//
|
|
Error = ERROR_SUCCESS;
|
|
if( !SetupDiCallClassInstaller( DIF_INSTALLDEVICE,
|
|
hDevInfo,
|
|
pDeviceInfoData ) &&
|
|
( ( Error = GetLastError() ) != ERROR_DI_DO_DEFAULT )
|
|
) {
|
|
|
|
SetupDebugPrint2( L"SETUP: SetupDiCallClassInstaller(DIF_INSTALLDEVICE) failed. Error = %lx, Device = %ls ", Error, pDeviceDescription );
|
|
goto enum_dev_thread_exit;
|
|
|
|
} else {
|
|
SetupDebugPrint1( L"SETUP: SetupDiCallClassInstaller(DIF_INSTALLDEVICE) suceeded. Device = %ls ", pDeviceDescription );
|
|
}
|
|
|
|
//
|
|
// If the device has wizard pages to show (in response to
|
|
// DIF_NEWDEVICEWIZARD_FINISHINSTALL) then it needs to be marked as need
|
|
// reinstall so that pages get a chance to be shown at a later time
|
|
// note that we have to do this even for a re-install
|
|
//
|
|
if (!MarkDeviceAsNeedsReinstallIfNeeded( hDevInfo, pDeviceInfoData) ) {
|
|
Error = GetLastError();
|
|
}
|
|
|
|
|
|
enum_dev_thread_exit:
|
|
if ( FileQ != (HSPFILEQ)INVALID_HANDLE_VALUE ) {
|
|
if(SetupDiGetDeviceInstallParams(hDevInfo, pDeviceInfoData, pDeviceInstallParams)) {
|
|
|
|
pDeviceInstallParams->FileQueue = INVALID_HANDLE_VALUE;
|
|
pDeviceInstallParams->Flags &= ~DI_NOVCP;
|
|
|
|
SetupDiSetDeviceInstallParams(hDevInfo, pDeviceInfoData, pDeviceInstallParams);
|
|
}
|
|
|
|
SetupCloseFileQueue( FileQ );
|
|
}
|
|
|
|
if (Error != ERROR_SUCCESS) {
|
|
//
|
|
// Device installed failed, so install the NULL driver on this device.
|
|
//
|
|
SetupDebugPrint( L"SETUP: Installing the null driver for this device" );
|
|
|
|
if( !SyssetupInstallNullDriver( hDevInfo, pDeviceInfoData ) ) {
|
|
SetupDebugPrint( L"SETUP: Unable to install null driver" );
|
|
}
|
|
}
|
|
|
|
return( Error );
|
|
}
|
|
|
|
|
|
BOOL
|
|
MarkPnpDevicesAsNeedReinstall(
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function marks all non-present Pnp devices as 'need reinstall'.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE if the null if all devices were marked successfull.
|
|
|
|
--*/
|
|
|
|
{
|
|
HDEVINFO hDevInfo;
|
|
SP_DEVINFO_DATA DeviceInfoData;
|
|
ULONG Index = 0;
|
|
BOOL b;
|
|
DWORD Error;
|
|
|
|
|
|
SetupDebugPrint( L"SETUP: Entering MarkPnpDevicesAsNeedReinstall()." );
|
|
|
|
Error = ERROR_SUCCESS;
|
|
|
|
//
|
|
// Get a list of all devices
|
|
//
|
|
hDevInfo = SetupDiGetClassDevs( NULL,
|
|
NULL,
|
|
NULL,
|
|
DIGCF_ALLCLASSES );
|
|
|
|
if( hDevInfo == INVALID_HANDLE_VALUE ) {
|
|
Error = GetLastError();
|
|
if( ((LONG)Error) < 0 ) {
|
|
//
|
|
// Setupapi error code, display it in hex
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetClassDevs(DIGCF_ALLCLASSES) failed. Error = %lx", Error );
|
|
} else {
|
|
//
|
|
// win32 error code, display it in decimal
|
|
//
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetClassDevs(DIGCF_ALLCLASSES) failed. Error = %d", Error );
|
|
}
|
|
SetupDebugPrint( L"SETUP: Leaving MarkPnpDevicesAsNeedReinstall(). No devices marked." );
|
|
return( FALSE );
|
|
}
|
|
//
|
|
// Assume success
|
|
//
|
|
b = TRUE;
|
|
|
|
//
|
|
// Now enumerate each device information element added to this set, and
|
|
// mark it as 'need reinstall' if it isn't a live devnode.
|
|
//
|
|
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
|
|
|
|
for( Index = 0;
|
|
SetupDiEnumDeviceInfo( hDevInfo, Index, &DeviceInfoData );
|
|
Index++ ) {
|
|
|
|
DWORD ConfigFlags;
|
|
ULONG Status, Problem;
|
|
|
|
if(CR_SUCCESS == CM_Get_DevInst_Status(&Status,
|
|
&Problem,
|
|
(DEVINST)DeviceInfoData.DevInst,
|
|
0))
|
|
{
|
|
//
|
|
// Since we were able to retrieve the devnode's status, we know that
|
|
// it is a live devnode (not necessarily started, but at least
|
|
// present in the hardware tree). Thus, we don't want to mark it
|
|
// as needing reinstall--it'll automatically get reinstalled as part
|
|
// of our installation of all present devices (i.e., that we get
|
|
// from the UMPNPMGR named pipe).
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Get the config flags for the device and set the reinstall bit
|
|
//
|
|
if ( !( b = GetDeviceConfigFlags(hDevInfo, &DeviceInfoData, &ConfigFlags ) ) )
|
|
{
|
|
SetupDebugPrint1( L"SETUP: GetDeviceConfigFlags failed. Index = %d", Index );
|
|
continue;
|
|
}
|
|
|
|
ConfigFlags |= CONFIGFLAG_REINSTALL;
|
|
|
|
if ( !( b = SetDeviceConfigFlags(hDevInfo, &DeviceInfoData, ConfigFlags ) ) ) {
|
|
|
|
SetupDebugPrint1( L"SETUP: SetDeviceConfigFlags failed. Index = %d", Index );
|
|
continue;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Find out why SetupDiEnumDeviceInfo() failed.
|
|
//
|
|
Error = GetLastError();
|
|
if( Error != ERROR_NO_MORE_ITEMS ) {
|
|
SetupDebugPrint2( L"SETUP: Device = %d, SetupDiEnumDeviceInfo() failed. Error = %d", Index, Error );
|
|
b = FALSE;
|
|
}
|
|
SetupDebugPrint1( L"SETUP: Leaving MarkPnpDevicesAsNeedReinstall(). Devices marked = %d", Index );
|
|
|
|
SetupDiDestroyDeviceInfoList( hDevInfo );
|
|
return( b );
|
|
}
|
|
|
|
//
|
|
// devices installs may exist in RunOnce entries
|
|
// they are processed as a batch, as opposed to per-device
|
|
// during syssetup
|
|
//
|
|
BOOL
|
|
CallRunOnceAndWait(
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function calls RunOnce and waits for a "reasonable" amount of time for it to complete
|
|
if we don't return within a reasonable amount of time, we leave RunOnce going
|
|
and continue with rest of install process
|
|
if we underestimate timeout, we can cause a whole series of "class installer appears to have hung" messages
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE if we completed successfully
|
|
FALSE should not be considered a fatal error, and can be ignored
|
|
|
|
--*/
|
|
{
|
|
static CONST TCHAR pszPathRunOnce[] = REGSTR_PATH_RUNONCE;
|
|
BOOL Success = FALSE;
|
|
STARTUPINFO StartupInfo;
|
|
PROCESS_INFORMATION ProcessInformation;
|
|
BOOL started;
|
|
TCHAR cmdline[MAX_PATH];
|
|
HKEY hKey = NULL;
|
|
LONG l;
|
|
DWORD nValues = 0;
|
|
DWORD timeout;
|
|
|
|
SetupDebugPrint( L"SETUP: Entering CallRunOnceAndWait. ");
|
|
|
|
try {
|
|
//
|
|
// First, open the key "HKLM\Software\Microsoft\Windows\CurrentVersion\RunOnce"
|
|
// to see if we have anything to do
|
|
//
|
|
if((l = RegOpenKeyEx(HKEY_LOCAL_MACHINE,pszPathRunOnce,0,KEY_QUERY_VALUE,&hKey)) != ERROR_SUCCESS) {
|
|
//
|
|
// not considered an error
|
|
//
|
|
SetupDebugPrint( L"SETUP: CallRunOnceAndWait: could not open RunOnce registry, assuming no entries. ");
|
|
Success = TRUE;
|
|
leave;
|
|
}
|
|
|
|
//
|
|
// we want to know how many items we'll be executing in RunOnce to estimate a timeout
|
|
//
|
|
l = RegQueryInfoKey(hKey,NULL,NULL,NULL,
|
|
NULL, NULL, NULL,
|
|
&nValues,
|
|
NULL, NULL, NULL, NULL);
|
|
if ( l != ERROR_SUCCESS ) {
|
|
SetupDebugPrint( L"SETUP: CallRunOnceAndWait: could not get number of entries, assuming no entries. ");
|
|
nValues = 0;
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
|
|
//
|
|
// estimating timeout is a black art
|
|
// we can try and guess for any entries in the HKLM\Software\Microsoft\Windows\CurrentVersion\RunOnce key
|
|
// but we're in the dark if any new keys are added
|
|
// we add '5' items to the timeout to "account" for this uncertainty. We also always run RunOnce
|
|
//
|
|
|
|
if (nValues == 0) {
|
|
SetupDebugPrint( L"SETUP: CallRunOnceAndWait: calling RunOnce (no detected entries). ");
|
|
nValues = 5;
|
|
} else {
|
|
SetupDebugPrint1( L"SETUP: CallRunOnceAndWait: calling RunOnce (%u known entries). ", nValues);
|
|
nValues += 5;
|
|
}
|
|
if (nValues < RUNONCE_THRESHOLD) {
|
|
timeout = nValues * RUNONCE_TIMEOUT;
|
|
} else {
|
|
timeout = RUNONCE_THRESHOLD * RUNONCE_TIMEOUT;
|
|
}
|
|
|
|
ZeroMemory(&StartupInfo,sizeof(StartupInfo));
|
|
ZeroMemory(&ProcessInformation,sizeof(ProcessInformation));
|
|
|
|
StartupInfo.cb = sizeof(StartupInfo);
|
|
lstrcpy(cmdline,TEXT("runonce -r"));
|
|
|
|
started = CreateProcess(NULL, // use application name below
|
|
cmdline, // command to execute
|
|
NULL, // default process security
|
|
NULL, // default thread security
|
|
FALSE, // don't inherit handles
|
|
0, // default flags
|
|
NULL, // inherit environment
|
|
NULL, // inherit current directory
|
|
&StartupInfo,
|
|
&ProcessInformation);
|
|
|
|
if(started) {
|
|
|
|
DWORD WaitProcStatus;
|
|
|
|
do {
|
|
|
|
WaitProcStatus = WaitForSingleObjectEx(ProcessInformation.hProcess, timeout , TRUE);
|
|
|
|
} while (WaitProcStatus == WAIT_IO_COMPLETION);
|
|
|
|
if (WaitProcStatus == WAIT_TIMEOUT) {
|
|
//
|
|
// RunOnce is still running
|
|
//
|
|
SetupDebugPrint( L"SETUP: CallRunOnceAndWait: RunOnce may have hung and has been abandoned. ");
|
|
|
|
} else if (WaitProcStatus == (DWORD)(-1)) {
|
|
//
|
|
// huh?
|
|
//
|
|
DWORD WaitProcError = GetLastError();
|
|
SetupDebugPrint1( L"SETUP: CallRunOnceAndWait: WaitForSingleObjectEx failed. Error = %lx ", WaitProcError );
|
|
|
|
} else {
|
|
//
|
|
// we ran, we waited, we returned
|
|
//
|
|
Success = TRUE;
|
|
}
|
|
|
|
CloseHandle(ProcessInformation.hThread);
|
|
CloseHandle(ProcessInformation.hProcess);
|
|
|
|
} else {
|
|
|
|
DWORD CreateProcError;
|
|
|
|
//
|
|
// The runonce task should get picked up later by someone else (e.g., at next
|
|
// login).
|
|
//
|
|
CreateProcError = GetLastError();
|
|
|
|
SetupDebugPrint1( L"SETUP: CallRunOnceAndWait: start RunOnce failed. Error = %lx ", CreateProcError );
|
|
}
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
SetupDebugPrint( L"SETUP: CallRunOnceAndWait: Exception! ");
|
|
Success = FALSE;
|
|
}
|
|
|
|
SetupDebugPrint( L"SETUP: Leaving CallRunOnceAndWait. ");
|
|
|
|
return Success;
|
|
}
|
|
|
|
//
|
|
// obsolete function from devmgr.c. keep the export in place for backwards compatibility
|
|
//
|
|
BOOL
|
|
DevInstallW(
|
|
HDEVINFO hDevInfo,
|
|
PSP_DEVINFO_DATA pDeviceInfoData
|
|
)
|
|
{
|
|
UNREFERENCED_PARAMETER(hDevInfo);
|
|
UNREFERENCED_PARAMETER(pDeviceInfoData);
|
|
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
ULONG
|
|
SyssetupGetPnPFlags(
|
|
IN HDEVINFO hDevInfo,
|
|
IN PSP_DEVINFO_DATA pDeviceInfoData,
|
|
IN PSP_DRVINFO_DATA pDriverInfoData
|
|
)
|
|
{
|
|
DWORD Err;
|
|
BOOL b;
|
|
SP_DRVINFO_DETAIL_DATA DriverInfoDetailData;
|
|
HINF hInf;
|
|
WCHAR InfSectionWithExt[255]; // MAX_SECT_NAME_LEN from setupapi\inf.h
|
|
INFCONTEXT InfContext;
|
|
ULONG ret = 0;
|
|
|
|
//
|
|
// First retrieve the name of the INF for this driver node.
|
|
//
|
|
DriverInfoDetailData.cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
|
|
|
|
if(!SetupDiGetDriverInfoDetail(hDevInfo,
|
|
pDeviceInfoData,
|
|
pDriverInfoData,
|
|
&DriverInfoDetailData,
|
|
sizeof(DriverInfoDetailData),
|
|
NULL)) {
|
|
//
|
|
// If we failed with ERROR_INSUFFICIENT_BUFFER, that's OK. We're
|
|
// guaranteed to have gotten all the static fields in the driver info
|
|
// detail structure filled in (including the INF name and section
|
|
// name fields).
|
|
//
|
|
Err = GetLastError();
|
|
MYASSERT(Err == ERROR_INSUFFICIENT_BUFFER);
|
|
if(Err != ERROR_INSUFFICIENT_BUFFER) {
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now open up the INF associated with this driver node.
|
|
//
|
|
hInf = SetupOpenInfFile(DriverInfoDetailData.InfFileName,
|
|
NULL,
|
|
INF_STYLE_WIN4,
|
|
NULL
|
|
);
|
|
|
|
if(hInf == INVALID_HANDLE_VALUE) {
|
|
//
|
|
// This will fail, for example, if the INF is an old-style INF.
|
|
//
|
|
return ret;
|
|
}
|
|
|
|
//
|
|
// Get the potentially decorated install section name.
|
|
//
|
|
b = SetupDiGetActualSectionToInstall(hInf,
|
|
DriverInfoDetailData.SectionName,
|
|
InfSectionWithExt,
|
|
SIZECHARS(InfSectionWithExt),
|
|
NULL,
|
|
NULL
|
|
);
|
|
MYASSERT(b);
|
|
if(!b) {
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Now look to see if there's a "SyssetupPnPFlags" entry in that section.
|
|
//
|
|
if(!SetupFindFirstLine(hInf,
|
|
InfSectionWithExt,
|
|
szSyssetupPnPFlags,
|
|
&InfContext)) {
|
|
//
|
|
// We didn't find such a line in this section.
|
|
//
|
|
goto clean0;
|
|
}
|
|
|
|
if(!SetupGetIntField(&InfContext, 1, (PINT)&ret)) {
|
|
//
|
|
// We failed--ensure return value is still zero.
|
|
//
|
|
ret = 0;
|
|
goto clean0;
|
|
}
|
|
|
|
clean0:
|
|
|
|
SetupCloseInfFile(hInf);
|
|
|
|
return ret;
|
|
}
|
|
|
|
//
|
|
// this function will tell umpnpmgr to stop server-side installs
|
|
//
|
|
VOID
|
|
PnpStopServerSideInstall(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
After phase-2, server-side installs kick in to pick up software-enumerated drivers
|
|
Call this when it's critical that we need to stop installing
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
Returns when it is safe to proceed.
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// since when we're called there should be nobody generating new devnodes, we're pretty safe
|
|
//
|
|
CMP_WaitNoPendingInstallEvents(INFINITE);
|
|
}
|
|
|
|
//
|
|
// this function will update HAL+kernel from NewInf
|
|
//
|
|
VOID
|
|
PnpUpdateHAL(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
At very end of MiniSetup, OEM may indicate (via Unattend) that a different HAL should be installed
|
|
This must be done very last due to that way that HAL's need to be installed, if we do this earlier
|
|
then an app or service may pick the wrong HAL/Kernel32/other
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
There is nothing meaningful that can be done if this fails
|
|
|
|
--*/
|
|
{
|
|
HDEVINFO hDevInfo = INVALID_HANDLE_VALUE;
|
|
SP_DEVINFO_DATA DevInfoData;
|
|
SP_DEVINSTALL_PARAMS DeviceInstallParams;
|
|
SP_DRVINFO_DATA DrvInfoData;
|
|
WCHAR HardwareID[MAX_PATH+2];
|
|
WCHAR InfPath[MAX_PATH];
|
|
WCHAR Answer[MAX_PATH];
|
|
WCHAR AnswerFile[2*MAX_PATH];
|
|
DWORD HardwareIdSize;
|
|
DWORD dwLen;
|
|
DWORD Error;
|
|
ULONG flags = 0;
|
|
HINSTANCE hInstNewDev = NULL;
|
|
ExternalUpdateDriverForPlugAndPlayDevicesW pUpdateDriverForPlugAndPlayDevicesW = NULL;
|
|
PWSTR pSrch = NULL;
|
|
PWSTR pHwID = NULL;
|
|
PWSTR pInfPath = NULL;
|
|
BOOL RebootFlag = FALSE;
|
|
SYSTEM_INFO info;
|
|
|
|
GetSystemDirectory(AnswerFile,MAX_PATH);
|
|
pSetupConcatenatePaths(AnswerFile,WINNT_GUI_FILE,MAX_PATH,NULL);
|
|
|
|
//
|
|
// If we determine we are only running on one processor (based on System Info)
|
|
// allow use of UpdateUPHAL
|
|
//
|
|
GetSystemInfo(&info);
|
|
|
|
Answer[0]=L'\0';
|
|
if(info.dwNumberOfProcessors==1) {
|
|
if( GetPrivateProfileString( WINNT_UNATTENDED,
|
|
WINNT_U_UPDATEUPHAL,
|
|
pwNull,
|
|
Answer,
|
|
MAX_PATH,
|
|
AnswerFile )) {
|
|
SetupDebugPrint1( L"SETUP: UpdateUPHAL=\"%ls\"",Answer);
|
|
}
|
|
}
|
|
|
|
if(!Answer[0]) {
|
|
//
|
|
// we didn't explicitly get an answer based on being UP - try catch-all
|
|
//
|
|
if( GetPrivateProfileString( WINNT_UNATTENDED,
|
|
WINNT_U_UPDATEHAL,
|
|
pwNull,
|
|
Answer,
|
|
MAX_PATH,
|
|
AnswerFile )) {
|
|
SetupDebugPrint1( L"SETUP: UpdateHAL=\"%ls\"",Answer);
|
|
}
|
|
}
|
|
if(!Answer[0]) {
|
|
//
|
|
// no update request
|
|
//
|
|
return;
|
|
}
|
|
|
|
//
|
|
// split Answer into HardwareID & INF
|
|
//
|
|
pHwID = Answer;
|
|
pSrch = wcschr(Answer,L',');
|
|
if(pSrch == NULL) {
|
|
SetupDebugPrint( L"SETUP: Required Syntax: \"hwid,inffile\"");
|
|
return;
|
|
}
|
|
pInfPath = pSrch+1;
|
|
|
|
//
|
|
// trim HardwareID & prepare as a MULTI-SZ
|
|
//
|
|
while(pHwID[0]==L' '||pHwID[0]==L'\t') {
|
|
pHwID++;
|
|
}
|
|
while(pSrch != pHwID && (pSrch[-1]==L' '||pSrch[-1]==L'\t')) {
|
|
pSrch--;
|
|
}
|
|
pSrch[0]=0;
|
|
if(!pHwID[0]) {
|
|
SetupDebugPrint( L"SETUP: Required Syntax: \"hwid,inffile\"");
|
|
return;
|
|
}
|
|
lstrcpy(HardwareID,pHwID);
|
|
HardwareIdSize = wcslen(HardwareID)+1;
|
|
HardwareID[HardwareIdSize++]=L'\0';
|
|
|
|
//
|
|
// now pre-process the INF, trim & allow %windir% expansion
|
|
//
|
|
while(pInfPath[0]==L' '||pInfPath[0]==L'\t') {
|
|
pInfPath++;
|
|
}
|
|
pSrch = pInfPath+wcslen(pInfPath);
|
|
while(pSrch != pInfPath && (pSrch[-1]==L' '||pSrch[-1]==L'\t')) {
|
|
pSrch--;
|
|
}
|
|
pSrch[0]=0;
|
|
if(!pInfPath[0]) {
|
|
SetupDebugPrint( L"SETUP: Required Syntax: \"hwid,inffile\"");
|
|
return;
|
|
}
|
|
dwLen=ExpandEnvironmentStrings(pInfPath,InfPath,MAX_PATH);
|
|
if(dwLen==0 || dwLen > MAX_PATH) {
|
|
SetupDebugPrint1( L"SETUP: Expansion of \"%ls\" failed",InfPath);
|
|
return;
|
|
}
|
|
SetupDebugPrint2( L"SETUP: Preparing to install new HAL %ls from %ls",HardwareID,InfPath);
|
|
|
|
// we need "UpdateDriverForPlugAndPlayDevices"
|
|
// make sure we can get this before changing hardware ID
|
|
//
|
|
hInstNewDev = LoadLibrary(L"newdev.dll");
|
|
if(hInstNewDev == NULL) {
|
|
SetupDebugPrint1( L"SETUP: Failed to load newdev.dll. Error = %d", GetLastError() );
|
|
goto clean0;
|
|
}
|
|
pUpdateDriverForPlugAndPlayDevicesW = (ExternalUpdateDriverForPlugAndPlayDevicesW)
|
|
GetProcAddress(hInstNewDev,
|
|
"UpdateDriverForPlugAndPlayDevicesW");
|
|
if(pUpdateDriverForPlugAndPlayDevicesW==NULL) {
|
|
SetupDebugPrint1( L"SETUP: Failed to get UpdateDriverForPlugAndPlayDevicesW. Error = %d", GetLastError() );
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// we enumerate the Computer class, GUID={4D36E966-E325-11CE-BFC1-08002BE10318}
|
|
// and should find a single DevNode, which is the one we need to update
|
|
// when we actually update, we consider this a safe thing to do
|
|
// since it should not involve any Co-Installers
|
|
//
|
|
hDevInfo = SetupDiGetClassDevs(&GUID_DEVCLASS_COMPUTER,NULL,NULL,DIGCF_PRESENT|DIGCF_PROFILE);
|
|
if(hDevInfo == INVALID_HANDLE_VALUE) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiGetClassDevs() failed. Error = %d", GetLastError() );
|
|
goto clean0;
|
|
}
|
|
DevInfoData.cbSize = sizeof(DevInfoData);
|
|
if(!SetupDiEnumDeviceInfo(hDevInfo,0,&DevInfoData)) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiEnumDeviceInfo() failed. Error = %d", GetLastError() );
|
|
SetupDiDestroyDeviceInfoList(hDevInfo);
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// change the harware ID
|
|
//
|
|
if(!SetupDiSetDeviceRegistryProperty(hDevInfo,
|
|
&DevInfoData,
|
|
SPDRP_HARDWAREID,
|
|
(PBYTE)HardwareID,
|
|
sizeof(HardwareID[0])*HardwareIdSize
|
|
)) {
|
|
SetupDebugPrint1( L"SETUP: SetupDiSetDeviceRegistryProperty() failed. Error = %d", GetLastError() );
|
|
SetupDiDestroyDeviceInfoList(hDevInfo);
|
|
goto clean0;
|
|
}
|
|
SetupDiDestroyDeviceInfoList(hDevInfo);
|
|
|
|
//
|
|
// now effect an update
|
|
//
|
|
if(!pUpdateDriverForPlugAndPlayDevicesW(NULL,HardwareID,InfPath,INSTALLFLAG_FORCE,&RebootFlag)) {
|
|
SetupDebugPrint1( L"SETUP: UpdateDriverForPlugAndPlayDevices() failed. Error = %d", GetLastError() );
|
|
} else {
|
|
SetupDebugPrint( L"SETUP: ... new HAL installed and will be active on reboot");
|
|
}
|
|
|
|
clean0:
|
|
|
|
if(hInstNewDev != NULL) {
|
|
FreeLibrary(hInstNewDev);
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
InstallOEMInfs(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine will install any OEM supplied INFs (and their corresponding
|
|
catalogs) that may have been supplied to the system during an earlier phase
|
|
of setup. For example, the OEM can currently supply an INF for unsupported
|
|
hardware during the textmode phase of setup by pressing "F6".
|
|
|
|
The list of OEM INFs to be installed is supplied to us via the answer
|
|
file in the following format:
|
|
|
|
[Data]
|
|
OEMDrivers=<driver-section-1>,<driver-section-2>,...
|
|
|
|
[driver-section-1]
|
|
OemDriverPathName=<path> (path to the driver (may use environment variables)
|
|
OemInfName=<inf name> name of the inf to be installed from the above
|
|
directory (there can be one or more infs in this directory, so
|
|
this is a comma separated list)
|
|
OemDriverFlags=<flags>
|
|
|
|
valid flags are:
|
|
SETUP_OEM_LDR_DEVICE 0x00000001
|
|
//indicates that the driver was supplied via the textmode "F6" mechanism
|
|
|
|
This function is really just a wrapper for SetupCopyOEMInf, which does
|
|
everything we need
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
TRUE indicates that all answer file-supplied drivers were installed properly
|
|
|
|
--*/
|
|
{
|
|
HINF hAnswerFile;
|
|
BOOL RetVal;
|
|
INFCONTEXT LineContext;
|
|
DWORD FieldCount, InfNameCount;
|
|
DWORD Field, InfCount;
|
|
DWORD d;
|
|
PCTSTR SectionName;
|
|
INFCONTEXT FirstLineContext,InfLineContext;
|
|
PCWSTR OemDriverPathName;
|
|
PCWSTR OemInfName;
|
|
DWORD OemFlags;
|
|
WCHAR FullInfPathBuffer[MAX_PATH];
|
|
WCHAR FullInfPathBufferWithInf[MAX_PATH];
|
|
|
|
RetVal = TRUE;
|
|
|
|
hAnswerFile = pOpenAnswerFile();
|
|
if (hAnswerFile == INVALID_HANDLE_VALUE) {
|
|
//
|
|
// if there is no answer file, then we can't continue.
|
|
//
|
|
RetVal = FALSE;
|
|
goto e0;
|
|
}
|
|
|
|
if (!SetupFindFirstLine(hAnswerFile,WINNT_DATA,WINNT_OEMDRIVERS,&LineContext)) {
|
|
//
|
|
// we were successful in doing nothing
|
|
//
|
|
RetVal = TRUE;
|
|
goto e1;
|
|
}
|
|
|
|
do {
|
|
|
|
//
|
|
// Each value on the line in the given section
|
|
// is the name of another section.
|
|
//
|
|
FieldCount = SetupGetFieldCount(&LineContext);
|
|
for(Field=1; Field<=FieldCount; Field++) {
|
|
|
|
OemDriverPathName = NULL;
|
|
OemInfName = NULL;
|
|
OemFlags = 0;
|
|
FullInfPathBuffer[0] = '\0';
|
|
FullInfPathBufferWithInf[0] = '\0';
|
|
|
|
if((SectionName = pSetupGetField(&LineContext,Field))
|
|
&& SetupFindFirstLine(hAnswerFile,SectionName,WINNT_OEMDRIVERS_PATHNAME,&FirstLineContext)) {
|
|
//
|
|
// the section points to a valid section, so process it.
|
|
//
|
|
OemDriverPathName = pSetupGetField(&FirstLineContext,1);
|
|
|
|
if (SetupFindFirstLine(hAnswerFile,SectionName,WINNT_OEMDRIVERS_FLAGS,&FirstLineContext)) {
|
|
SetupGetIntField(&FirstLineContext,1,&OemFlags);
|
|
}
|
|
|
|
if (OemDriverPathName) {
|
|
ExpandEnvironmentStrings( OemDriverPathName,
|
|
FullInfPathBuffer,
|
|
sizeof(FullInfPathBuffer)/sizeof(WCHAR) );
|
|
}
|
|
|
|
if (SetupFindFirstLine(hAnswerFile,SectionName,WINNT_OEMDRIVERS_INFNAME,&InfLineContext)) {
|
|
InfNameCount = SetupGetFieldCount(&InfLineContext);
|
|
for (InfCount = 1; InfCount <= InfNameCount; InfCount++) {
|
|
OemInfName = pSetupGetField(&InfLineContext,InfCount);
|
|
|
|
if (OemDriverPathName && OemInfName) {
|
|
|
|
wcscpy( FullInfPathBufferWithInf, FullInfPathBuffer );
|
|
pSetupConcatenatePaths(
|
|
FullInfPathBufferWithInf,
|
|
OemInfName,
|
|
sizeof(FullInfPathBufferWithInf)/sizeof(WCHAR),
|
|
0 );
|
|
|
|
if (!SetupCopyOEMInf(
|
|
FullInfPathBufferWithInf,
|
|
FullInfPathBuffer,
|
|
SPOST_PATH,
|
|
(OemFlags & SETUP_OEM_LDR_DEVICE) ? SP_COPY_OEM_F6_INF : 0,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
NULL)) {
|
|
RetVal = FALSE;
|
|
}
|
|
|
|
if (OemFlags & SETUP_OEM_LDR_DEVICE) {
|
|
//
|
|
// if this flag is set, we know that there is an
|
|
// additional oemXXX##.inf file in the system32
|
|
// directory which corresponds to the INF file we
|
|
// have already copied from this directory. We need
|
|
// to seek out that file and remove it, since the INF
|
|
// file we have just copied is "better" than that file.
|
|
//
|
|
WIN32_FIND_DATA fd;
|
|
HANDLE hFind;
|
|
WCHAR OldInfBuffer[MAX_PATH];
|
|
PWSTR p;
|
|
|
|
ExpandEnvironmentStringsW(
|
|
L"%SystemRoot%\\system32\\",
|
|
OldInfBuffer,
|
|
sizeof(OldInfBuffer)/sizeof(WCHAR));
|
|
|
|
p = wcsrchr( OldInfBuffer, L'\\' );
|
|
p += 1;
|
|
|
|
pSetupConcatenatePaths(
|
|
OldInfBuffer,
|
|
L"oem?????.inf",
|
|
sizeof(OldInfBuffer)/sizeof(WCHAR),
|
|
0 );
|
|
|
|
|
|
if ((hFind = FindFirstFile(OldInfBuffer, &fd)) != INVALID_HANDLE_VALUE) {
|
|
do {
|
|
wcscpy( p, fd.cFileName );
|
|
|
|
if (DoFilesMatch( FullInfPathBufferWithInf, OldInfBuffer )) {
|
|
SetFileAttributes(OldInfBuffer, FILE_ATTRIBUTE_NORMAL );
|
|
DeleteFile( OldInfBuffer );
|
|
}
|
|
} while(FindNextFile( hFind, &fd ));
|
|
|
|
FindClose( hFind );
|
|
|
|
}
|
|
}
|
|
} else {
|
|
RetVal = FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} while(SetupFindNextMatchLine(&LineContext,NULL,&LineContext));
|
|
|
|
|
|
e1:
|
|
SetupCloseInfFile( hAnswerFile );
|
|
e0:
|
|
return(RetVal);
|
|
}
|
|
|
|
|
|
#if defined(_X86_)
|
|
|
|
VOID
|
|
SfcExcludeMigratedDrivers (
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Adds all OEM migrated boot drivers (via unsupdrv.inf) to the SFC exclusion list
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR unsupInfPath[MAX_PATH];
|
|
TCHAR windir[MAX_PATH];
|
|
HINF unsupdrvInf;
|
|
INFCONTEXT ic;
|
|
TCHAR driverId[MAX_PATH];
|
|
TCHAR sectionFiles[MAX_PATH];
|
|
INFCONTEXT ic2;
|
|
TCHAR driverFilename[MAX_PATH];
|
|
TCHAR driverSubDir[MAX_PATH];
|
|
TCHAR driverPath[MAX_PATH];
|
|
|
|
if (!FloppylessBootPath[0] ||
|
|
!BuildPath (unsupInfPath, ARRAYSIZE(unsupInfPath), FloppylessBootPath, TEXT("$WIN_NT$.~BT")) ||
|
|
!pSetupConcatenatePaths (unsupInfPath, TEXT("unsupdrv.inf"), ARRAYSIZE(unsupInfPath), NULL)) {
|
|
return;
|
|
}
|
|
|
|
unsupdrvInf = SetupOpenInfFile (unsupInfPath, NULL, INF_STYLE_WIN4, NULL);
|
|
if (unsupdrvInf == INVALID_HANDLE_VALUE) {
|
|
return;
|
|
}
|
|
if (!GetWindowsDirectory (windir, ARRAYSIZE(windir))) {
|
|
return;
|
|
}
|
|
|
|
if(SetupFindFirstLine (
|
|
unsupdrvInf,
|
|
TEXT("Devices"),
|
|
NULL,
|
|
&ic)) {
|
|
do {
|
|
if (!SetupGetStringField (&ic, 1, driverId, ARRAYSIZE(driverId), NULL)) {
|
|
continue;
|
|
}
|
|
if (_sntprintf (sectionFiles, ARRAYSIZE(sectionFiles) - 1, TEXT("Files.%s"), driverId) < 0) {
|
|
continue;
|
|
}
|
|
sectionFiles[ARRAYSIZE(sectionFiles) - 1] = 0;
|
|
|
|
if(SetupFindFirstLine (
|
|
unsupdrvInf,
|
|
sectionFiles,
|
|
NULL,
|
|
&ic2)) {
|
|
do {
|
|
if (!SetupGetStringField (&ic2, 1, driverFilename, ARRAYSIZE(driverFilename), NULL)) {
|
|
continue;
|
|
}
|
|
if (!SetupGetStringField (&ic2, 2, driverSubDir, ARRAYSIZE(driverSubDir), NULL)) {
|
|
continue;
|
|
}
|
|
if (_sntprintf (driverPath, ARRAYSIZE(driverPath) - 1, TEXT("%s\\%s\\%s"), windir, driverSubDir, driverFilename) < 0) {
|
|
continue;
|
|
}
|
|
driverPath[ARRAYSIZE(driverPath) - 1] = 0;
|
|
if (FileExists (driverPath, NULL)) {
|
|
MultiSzAppendString(&EnumPtrSfcIgnoreFiles, driverPath);
|
|
}
|
|
} while (SetupFindNextLine(&ic2, &ic2));
|
|
}
|
|
|
|
} while (SetupFindNextLine(&ic, &ic));
|
|
}
|
|
|
|
SetupCloseInfFile (unsupdrvInf);
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
BOOL
|
|
IsInstalledInfFromOem(
|
|
IN PCWSTR InfFileName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Determine if an INF file is OEM-supplied (i.e., it's name is of the form
|
|
"OEM<n>.INF").
|
|
|
|
Arguments:
|
|
|
|
InfFileName - supplies name (may include path) of INF. No checking is done
|
|
to ensure INF lives in %windir%\Inf--this is caller's responsibility.
|
|
|
|
Return Value:
|
|
|
|
If TRUE, this is an OEM INF. If FALSE, it's an in-box INF (or possibly one
|
|
that was illegally copied directly into %windir%\Inf).
|
|
|
|
--*/
|
|
|
|
{
|
|
PCWSTR p = pSetupGetFileTitle(InfFileName);
|
|
|
|
//
|
|
// First check that the first 3 characters are OEM
|
|
//
|
|
if((*p != L'o') && (*p != L'O')) {
|
|
return FALSE;
|
|
}
|
|
p++;
|
|
if((*p != L'e') && (*p != L'E')) {
|
|
return FALSE;
|
|
}
|
|
p++;
|
|
if((*p != L'm') && (*p != L'M')) {
|
|
return FALSE;
|
|
}
|
|
p++;
|
|
|
|
//
|
|
// Now make sure that all subsequent characters up to the dot (.) are
|
|
// numeric.
|
|
//
|
|
while((*p != L'\0') && (*p != L'.')) {
|
|
|
|
if((*p < L'0') || (*p > L'9')) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
p++;
|
|
}
|
|
|
|
//
|
|
// Finally, verify that the last 4 characters are ".inf"
|
|
//
|
|
if(lstrcmpi(p, L".inf")) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// This is an OEM INF
|
|
//
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
IsInfInLayoutInf(
|
|
IN PCWSTR InfFileName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Determine if an INF file is shiped in-box with the operating system.
|
|
This is acomplished by looking up the INF name in the [SourceDisksFiles]
|
|
section of layout.inf
|
|
|
|
Arguments:
|
|
|
|
InfFileName - supplies name (may include path) of INF. No checking is done
|
|
to ensure INF lives in %windir%\Inf--this is caller's responsibility.
|
|
|
|
Return Value:
|
|
|
|
If TRUE, this is an in-box INF. If FALSE, it's not an in-box INF, this
|
|
could be an OEM<n>.INF or an inf illegaly copied into the INF directory.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL bInBoxInf = FALSE;
|
|
HINF hInf = INVALID_HANDLE_VALUE;
|
|
UINT SourceId;
|
|
|
|
hInf = SetupOpenInfFile(TEXT("layout.inf"), NULL, INF_STYLE_WIN4, NULL);
|
|
|
|
if (hInf != INVALID_HANDLE_VALUE) {
|
|
|
|
if(SetupGetSourceFileLocation(hInf,
|
|
NULL,
|
|
pSetupGetFileTitle(InfFileName),
|
|
&SourceId,
|
|
NULL,
|
|
0,
|
|
NULL)) {
|
|
bInBoxInf = TRUE;
|
|
}
|
|
|
|
SetupCloseInfFile(hInf);
|
|
}
|
|
|
|
return bInBoxInf;
|
|
}
|