|
|
//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1996 - 1999
//
// File: finish.c
//
//--------------------------------------------------------------------------
#include "newdevp.h"
#include <help.h>
typedefUINT(*PDEVICEPROBLEMTEXT)( HMACHINE hMachine, DEVNODE DevNode, ULONG ProblemNumber, LPTSTR Buffer, UINT BufferSize );
BOOLIsNullDriverInstalled( DEVNODE DevNode )/*++
Routine Description:
This routine determines whether a null driver, or no driver at all, is installed for this device instance. Currently the test is that I know a null driver was installed if the "Driver" value entry doesn't exist.
Arguments:
DevNode
Return Value:
Returns TRUE if a null driver was installed for this device, otherwise returns FALSE.
--*/
{ TCHAR Buffer[1]; DWORD dwSize, dwType;
dwSize = SIZECHARS(Buffer); if (CM_Get_DevNode_Registry_Property(DevNode, CM_DRP_DRIVER, &dwType, (LPVOID)Buffer, &dwSize, 0) == CR_BUFFER_SMALL) {
return FALSE;
} else {
return TRUE;
}}
PTCHARDeviceProblemText( HMACHINE hMachine, DEVNODE DevNode, ULONG ProblemNumber ){ UINT LenChars, ReqLenChars; HMODULE hDevMgr=NULL; PTCHAR Buffer=NULL; PDEVICEPROBLEMTEXT pDeviceProblemText = NULL;
hDevMgr = LoadLibrary(TEXT("devmgr.dll")); if (hDevMgr) { pDeviceProblemText = (PVOID) GetProcAddress(hDevMgr, "DeviceProblemTextW"); }
if (pDeviceProblemText) { LenChars = (pDeviceProblemText)(hMachine, DevNode, ProblemNumber, Buffer, 0 ); if (!LenChars) { goto DPTExitCleanup; }
LenChars++; // one extra for terminating NULL
Buffer = LocalAlloc(LPTR, LenChars*sizeof(TCHAR)); if (!Buffer) { goto DPTExitCleanup; }
ReqLenChars = (pDeviceProblemText)(hMachine, DevNode, ProblemNumber, Buffer, LenChars ); if (!ReqLenChars || ReqLenChars >= LenChars) { LocalFree(Buffer); Buffer = NULL; } }
DPTExitCleanup:
if (hDevMgr) { FreeLibrary(hDevMgr); }
return Buffer;}
BOOLDeviceHasResources( DEVINST DeviceInst ){ CONFIGRET ConfigRet; ULONG lcType = NUM_LOG_CONF;
while (lcType--) { ConfigRet = CM_Get_First_Log_Conf_Ex(NULL, DeviceInst, lcType, NULL); if (ConfigRet == CR_SUCCESS) { return TRUE; } }
return FALSE;}
BOOLGetClassGuidForInf( PTSTR InfFileName, LPGUID ClassGuid ){ TCHAR ClassName[MAX_CLASS_NAME_LEN]; DWORD NumGuids;
if(!SetupDiGetINFClass(InfFileName, ClassGuid, ClassName, sizeof(ClassName)/sizeof(TCHAR), NULL)) { return FALSE; }
if (IsEqualGUID(ClassGuid, &GUID_NULL)) { //
// 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;}
BOOLIsInternetDriver( HDEVINFO hDeviceInfo, PSP_DEVINFO_DATA DeviceInfoData ){ BOOL InternetDriver = FALSE; SP_DRVINFO_DATA DriverInfoData; SP_DRVINSTALL_PARAMS DriverInstallParams;
DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA); if(SetupDiGetSelectedDriver(hDeviceInfo, DeviceInfoData, &DriverInfoData)) {
DriverInstallParams.cbSize = sizeof(SP_DRVINSTALL_PARAMS); if (SetupDiGetDriverInstallParams(hDeviceInfo, DeviceInfoData, &DriverInfoData, &DriverInstallParams ) && (DriverInstallParams.Flags & DNF_INET_DRIVER)) { InternetDriver = TRUE; } }
return InternetDriver;}
UINTQueueCallback( IN PVOID Context, IN UINT Notification, IN UINT_PTR Param1, IN UINT_PTR Param2 ){ PNEWDEVWIZ NewDevWiz = (PNEWDEVWIZ)Context;
switch (Notification) { case SPFILENOTIFY_TARGETNEWER: //
// When doing a driver rollback we expect that some of the files will
// be older then the files currently on the system since most backups
// will be of older driver packages. So when a user does a rollback we
// will hide the older vs. newer file prompt and always copy the older
// backed up file.
//
if (NewDevWiz->Flags & IDI_FLAG_ROLLBACK) { return TRUE; } break; case SPFILENOTIFY_STARTCOPY: if (NewDevWiz->hWnd) { SendMessage(NewDevWiz->hWnd, WUM_INSTALLPROGRESS, INSTALLOP_COPY, (WPARAM)((PFILEPATHS)Param1) ); } break;
case SPFILENOTIFY_STARTRENAME: if (NewDevWiz->hWnd) { SendMessage(NewDevWiz->hWnd, WUM_INSTALLPROGRESS, INSTALLOP_RENAME, (WPARAM)((PFILEPATHS)Param1) ); } break;
case SPFILENOTIFY_STARTDELETE: if (NewDevWiz->hWnd) { SendMessage(NewDevWiz->hWnd, WUM_INSTALLPROGRESS, INSTALLOP_DELETE, (WPARAM)((PFILEPATHS)Param1) ); } break;
case SPFILENOTIFY_STARTBACKUP: if (NewDevWiz->hWnd) { SendMessage(NewDevWiz->hWnd, WUM_INSTALLPROGRESS, INSTALLOP_BACKUP, (WPARAM)((PFILEPATHS)Param1) ); } break; }
return SetupDefaultQueueCallback(NewDevWiz->MessageHandlerContext, Notification, Param1, Param2 );}
LONGClassInstallerInstalls( HWND hwndParent, PNEWDEVWIZ NewDevWiz, BOOL BackupOldDrivers, BOOL ReadOnlyInstall, BOOL DontCreateQueue ){ DWORD Err = ERROR_SUCCESS; HSPFILEQ FileQueue = INVALID_HANDLE_VALUE; SP_DEVINSTALL_PARAMS DeviceInstallParams; DWORD ScanResult = 0; int FileQueueNeedsReboot = 0;
NewDevWiz->MessageHandlerContext = NULL;
//
// If we can't create our own queue and we are doing a read-only install
// then fail with ERROR_ACCESS_DENIED.
//
if (DontCreateQueue && ReadOnlyInstall) { Err = ERROR_ACCESS_DENIED; goto clean0; }
//
// verify with class installer, and class-specific coinstallers
// that the driver is not blacklisted. For DIF_ALLOW_INSTALL we
// accept ERROR_SUCCESS or ERROR_DI_DO_DEFAULT as good return codes.
//
if (!SetupDiCallClassInstaller(DIF_ALLOW_INSTALL, NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData ) && (GetLastError() != ERROR_DI_DO_DEFAULT)) {
Err = GetLastError(); goto clean0; }
//
// Create our own queue.
//
if (!DontCreateQueue) { DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS); if (!SetupDiGetDeviceInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DeviceInstallParams )) {
Err = GetLastError(); goto clean0; }
FileQueue = SetupOpenFileQueue();
if (FileQueue == INVALID_HANDLE_VALUE) { Err = ERROR_NOT_ENOUGH_MEMORY; goto clean0; }
DeviceInstallParams.Flags |= DI_NOVCP; DeviceInstallParams.FileQueue = FileQueue;
//
// Only set the DI_FLAGSEX_PREINSTALLBACKUP flag if we are doing a
// backup...not in the read only install case.
//
if (BackupOldDrivers) { DeviceInstallParams.FlagsEx |= DI_FLAGSEX_PREINSTALLBACKUP; }
SetupDiSetDeviceInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DeviceInstallParams );
//
// If the IDI_FLAG_SETRESTOREPOINT flag is set then we want to set the
// SPQ_FLAG_ABORT_IF_UNSIGNED value on the file queue. With this flag
// setup setupapi will bail out of the copy if it encounters an unsigned
// file. At that point we will set a system restore point and then
// do the copy. This way the user can back out of an unsigned driver
// install using system restore.
//
// Note that system restore is currently not supported on 64-bit so
// don't bother setting the SPQ_FLAG_ABORT_IF_UNSIGNED flag.
//
#ifndef _WIN64
if (NewDevWiz->Flags & IDI_FLAG_SETRESTOREPOINT) { SetupSetFileQueueFlags(FileQueue, SPQ_FLAG_ABORT_IF_UNSIGNED, SPQ_FLAG_ABORT_IF_UNSIGNED ); }#endif
}
//
// Install the files first in one shot.
// This allows new coinstallers to run during the install.
//
if (!SetupDiCallClassInstaller(DIF_INSTALLDEVICEFILES, NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData )) {
Err = GetLastError(); goto clean0; }
if (FileQueue != INVALID_HANDLE_VALUE) { //
// If we created our own FileQueue then we need to
// scan and possibly commit the queue
//
// If we are doing a read only install then we just queued up the files so
// that we could do a presence check on them. We will throw away the queue
// so that the files are not copied.
//
// Any other install, prune copies as needed
//
if (!SetupScanFileQueue(FileQueue, ReadOnlyInstall ? SPQ_SCAN_FILE_PRESENCE : (SPQ_SCAN_FILE_VALIDITY | SPQ_SCAN_PRUNE_COPY_QUEUE), hwndParent, NULL, NULL, &ScanResult )) {
//
// If the API failed then set the ScanResult to 0 (failure).
//
ScanResult = 0; }
if (ReadOnlyInstall && (ScanResult != 1)) { //
// ReadOnlyInstall cannot perform copies, deletes or renames
// bail now!
//
Err = ERROR_ACCESS_DENIED; goto clean0; }
//
// We will always commit the file queue, even if we pruned all of the
// files. The reason for this is that backing up of drivers, for
// driver rollback, won't work unless the file queue is committed.
//
if(NewDevWiz->Flags & IDI_FLAG_ROLLBACK) { //
// Prepare file queue for rollback
// we need the directory of the INF
// that's being used for the install
//
SP_DRVINFO_DATA DriverInfoData; SP_DRVINFO_DETAIL_DATA DriverInfoDetailData; DWORD RetVal; LPTSTR pFileName; TCHAR BackupPath[MAX_PATH];
DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA); if (SetupDiGetSelectedDriver(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DriverInfoData)) {
DriverInfoDetailData.cbSize = sizeof(SP_DRVINFO_DETAIL_DATA); if (SetupDiGetDriverInfoDetail(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DriverInfoData, &DriverInfoDetailData, sizeof(SP_DRVINFO_DETAIL_DATA), NULL) || (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) { //
// we now have path of INF we're using for the restore
//
RetVal = GetFullPathName(DriverInfoDetailData.InfFileName, MAX_PATH, BackupPath, &pFileName); if(RetVal && pFileName && (pFileName != BackupPath)) { if(*CharPrev(BackupPath,pFileName)==TEXT('\\')) { pFileName--; } *pFileName = TEXT('\0'); //
// Prepare queue for rollback
// if this fails, carry on, it'll work in a degraded way
//
SetupPrepareQueueForRestore(FileQueue,BackupPath,0); } } } }
NewDevWiz->MessageHandlerContext = SetupInitDefaultQueueCallbackEx( hwndParent, (DeviceInstallParams.Flags & DI_QUIETINSTALL) ? INVALID_HANDLE_VALUE : NewDevWiz->hWnd, WUM_INSTALLPROGRESS, 0, NULL );
if (NewDevWiz->MessageHandlerContext) { //
// Commit the file queue.
//
if (!SetupCommitFileQueue(hwndParent, FileQueue, QueueCallback, (PVOID)NewDevWiz )) {
Err = GetLastError();
if (Err == ERROR_SET_SYSTEM_RESTORE_POINT) { UINT RestorePointResourceId;
//
// If we get back ERROR_SET_SYSTEM_RESTORE_POINT then
// we better have the IDI_FLAG_SETRESTOREPOINT flag
// set.
//
ASSERT(NewDevWiz->Flags & IDI_FLAG_SETRESTOREPOINT);
if (!(DeviceInstallParams.Flags & DI_QUIETINSTALL) && NewDevWiz->hWnd) { PostMessage(NewDevWiz->hWnd, WUM_INSTALLPROGRESS, INSTALLOP_SETTEXT, (LPARAM)IDS_SYSTEMRESTORE_TEXT ); }
SetupTermDefaultQueueCallback(NewDevWiz->MessageHandlerContext);
NewDevWiz->MessageHandlerContext = SetupInitDefaultQueueCallbackEx( hwndParent, (DeviceInstallParams.Flags & DI_QUIETINSTALL) ? INVALID_HANDLE_VALUE : NewDevWiz->hWnd, WUM_INSTALLPROGRESS, 0, NULL );
if (NewDevWiz->MessageHandlerContext) { //
// Set the system restore point.
//
if (NewDevWiz->Flags & IDI_FLAG_ROLLBACK) { RestorePointResourceId = IDS_ROLLBACK_SETRESTOREPOINT; } else if (NewDevWiz->InstallType == NDWTYPE_FOUNDNEW) { RestorePointResourceId = IDS_NEW_SETRESTOREPOINT; } else { RestorePointResourceId = IDS_UPDATE_SETRESTOREPOINT; }
pSetSystemRestorePoint(TRUE, FALSE, RestorePointResourceId);
NewDevWiz->SetRestorePoint = TRUE;
if (!(DeviceInstallParams.Flags & DI_QUIETINSTALL) && NewDevWiz->hWnd) { PostMessage(NewDevWiz->hWnd, WUM_INSTALLPROGRESS, INSTALLOP_SETTEXT, (LPARAM)NULL ); }
//
// Clear the SPQ_FLAG_ABORT_IF_UNSIGNED flag so the file
// queue will be commited the next time.
//
SetupSetFileQueueFlags(FileQueue, SPQ_FLAG_ABORT_IF_UNSIGNED, 0 );
//
// Now that we have set the restore point and cleared the
// SPQ_FLAG_ABORT_IF_UNSIGNED flag from the file queue we
// can commit the queue again.
//
if (!SetupCommitFileQueue(hwndParent, FileQueue, QueueCallback, (PVOID)NewDevWiz )) { Err = GetLastError();
//
// If the error we get is ERROR_CANCELLED then
// the user has canceld out of the file copy.
// This means that no changes have been made
// to the system, so we will tell system
// restore to cancel its restore point.
//
// Also clear the SetRestorePoint BOOL since
// we didn't actually set a restore point.
//
if (Err == ERROR_CANCELLED) { pSetSystemRestorePoint(FALSE, TRUE, 0); NewDevWiz->SetRestorePoint = FALSE; }
goto clean0; } else { //
// We were successful in commiting the file queue, so check
// to see whether a reboot is required as a result of committing
// the queue (i.e. because files were in use, or the INF requested
// a reboot).
//
FileQueueNeedsReboot = SetupPromptReboot(FileQueue, NULL, TRUE); } } } else { goto clean0; } } else { //
// We were successful in commiting the file queue, so check
// to see whether a reboot is required as a result of committing
// the queue (i.e. because files were in use, or the INF requested
// a reboot).
//
FileQueueNeedsReboot = SetupPromptReboot(FileQueue, NULL, TRUE); } }
if (BackupOldDrivers) { //
// If the backup succeeded and we have a UpdateDriverInfo structure
// then we need to call SetupGetBackupInformation so we can get the
// registry key that the backup was saved into.
//
SP_BACKUP_QUEUE_PARAMS BackupQueueParams;
BackupQueueParams.cbSize = sizeof(SP_BACKUP_QUEUE_PARAMS); if (NewDevWiz->UpdateDriverInfo && SetupGetBackupInformation(FileQueue, &BackupQueueParams)) {
lstrcpy(NewDevWiz->UpdateDriverInfo->BackupRegistryKey, REGSTR_PATH_REINSTALL); lstrcat(NewDevWiz->UpdateDriverInfo->BackupRegistryKey, TEXT("\\")); lstrcat(NewDevWiz->UpdateDriverInfo->BackupRegistryKey, BackupQueueParams.ReinstallInstance); } } }
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS); if (SetupDiGetDeviceInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DeviceInstallParams )) { DWORD FileQueueFlags; //
// If we didn't copy any files when commiting the file queue then the
// SPQ_FLAG_FILES_MODIFIED flag will NOT be set. In this case set
// the DI_FLAGSEX_RESTART_DEVICE_ONLY flag so that we only stop/start
// this single device. By default setupapi will stop/start this device
// as well as any other device that was using the same driver/filter
// that this device is using.
//
if ((FileQueue != INVALID_HANDLE_VALUE) && SetupGetFileQueueFlags(FileQueue, &FileQueueFlags) && !(FileQueueFlags & SPQ_FLAG_FILES_MODIFIED)) { DeviceInstallParams.FlagsEx |= DI_FLAGSEX_RESTART_DEVICE_ONLY; }
//
// Set the DI_NOFILECOPY flag since we already copied the files during
// the DIF_INSTALLDEVICEFILES, so we don't need to copy them again during
// the DIF_INSTALLDEVICE.
//
DeviceInstallParams.Flags |= DI_NOFILECOPY; SetupDiSetDeviceInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DeviceInstallParams ); }
//
// Register any device-specific co-installers for this device,
//
if (!SetupDiCallClassInstaller(DIF_REGISTER_COINSTALLERS, NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData )) {
Err = GetLastError(); goto clean0; }
//
// install any INF/class installer-specified interfaces.
// and then finally the real "InstallDevice"!
//
if (!SetupDiCallClassInstaller(DIF_INSTALLINTERFACES, NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData ) || !SetupDiCallClassInstaller(DIF_INSTALLDEVICE, NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData )) {
Err = GetLastError(); goto clean0; }
Err = ERROR_SUCCESS;
clean0:
if (NewDevWiz->MessageHandlerContext) { SetupTermDefaultQueueCallback(NewDevWiz->MessageHandlerContext); }
//
// If the file queue said that a reboot was needed then set the
// DI_NEEDRESTART flag.
//
if (FileQueueNeedsReboot) { DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS); if (SetupDiGetDeviceInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DeviceInstallParams )) {
DeviceInstallParams.Flags |= DI_NEEDRESTART;
SetupDiSetDeviceInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DeviceInstallParams ); } }
if (FileQueue != INVALID_HANDLE_VALUE) { //
// If we have a valid file queue handle and there was an error during
// the device install then we want to delete any new INFs that were
// copied into the INF directory. We do this under the assumption that
// since there was an error during the install these INFs must be bad.
//
if (Err != ERROR_SUCCESS) { SetupUninstallNewlyCopiedInfs(FileQueue, 0, NULL ); }
//
// Clear out our file queue from the device install params. We need
// to do this or else SetupCloseFileQueue will fail because it will
// still have a ref count.
//
DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS); if (SetupDiGetDeviceInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DeviceInstallParams )) {
DeviceInstallParams.Flags &= ~DI_NOVCP; DeviceInstallParams.FileQueue = INVALID_HANDLE_VALUE;
SetupDiSetDeviceInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DeviceInstallParams ); }
SetupCloseFileQueue(FileQueue); }
return Err;}
//
// invokable only from finish page!
//
DWORDInstallDev( HWND hwndParent, PNEWDEVWIZ NewDevWiz ){ SP_DRVINFO_DATA DriverInfoData; SP_DRVINFO_DETAIL_DATA DriverInfoDetailData; SP_DEVINSTALL_PARAMS DeviceInstallParams; TCHAR ClassGuidString[MAX_GUID_STRING_LEN]; GUID ClassGuidInf; LPGUID ClassGuid; int ClassGuidNum; DWORD Error = ERROR_SUCCESS; BOOL IgnoreRebootFlags = FALSE; TCHAR Buffer[MAX_PATH*2]; PVOID pvBuffer = Buffer; ULONG DevNodeStatus = 0, Problem = 0; DWORD ClassGuidListSize, i; BOOL Backup = FALSE; BOOL DontCreateQueue = FALSE;
if (!NewDevWiz->ClassGuidSelected) { NewDevWiz->ClassGuidSelected = (LPGUID)&GUID_NULL; }
DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA); if (SetupDiGetSelectedDriver(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DriverInfoData )) { //
// Get details on this driver node, so that we can examine the INF that this
// node came from.
//
DriverInfoDetailData.cbSize = sizeof(SP_DRVINFO_DETAIL_DATA); if(!SetupDiGetDriverInfoDetail(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DriverInfoData, &DriverInfoDetailData, sizeof(DriverInfoDetailData), NULL )) { Error = GetLastError(); if (Error != ERROR_INSUFFICIENT_BUFFER) { goto clean0; } }
//
// Verif that the class is installed, if its not then
// attempt to install it.
//
NdwBuildClassInfoList(NewDevWiz, 0);
//
// fetch classguid from inf, (It may be different than what we already
// have in class guid selected).
//
if (!GetClassGuidForInf(DriverInfoDetailData.InfFileName, &ClassGuidInf)) { ClassGuidInf = *NewDevWiz->ClassGuidSelected; }
if (IsEqualGUID(&ClassGuidInf, &GUID_NULL)) { ClassGuidInf = GUID_DEVCLASS_UNKNOWN; }
//
// if the ClassGuidInf wasn't found then this class hasn't been installed yet.
// -install the class installer now.
//
ClassGuid = NewDevWiz->ClassGuidList; ClassGuidNum = NewDevWiz->ClassGuidNum; while (ClassGuidNum--) { if (IsEqualGUID(ClassGuid, &ClassGuidInf)) { break; }
ClassGuid++; }
if (ClassGuidNum < 0 && !SetupDiInstallClass(hwndParent, DriverInfoDetailData.InfFileName, NewDevWiz->SilentMode ? DI_QUIETINSTALL : 0, NULL )) { Error = GetLastError(); goto clean0; } }
//
// No selected driver, and no associated class--use "Unknown" class.
//
else { //
// If the devnode is currently running 'raw', then remember this
// fact so that we don't require a reboot later (NULL driver installation
// isn't going to change anything).
//
if (CM_Get_DevNode_Status(&DevNodeStatus, &Problem, NewDevWiz->DeviceInfoData.DevInst, 0) == CR_SUCCESS) { if (!SetupDiGetDeviceRegistryProperty(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, SPDRP_SERVICE, NULL, // regdatatype
pvBuffer, sizeof(Buffer), NULL )) { *Buffer = TEXT('\0'); }
if((DevNodeStatus & DN_STARTED) && (*Buffer == TEXT('\0'))) { IgnoreRebootFlags = TRUE; } }
if (IsEqualGUID(NewDevWiz->ClassGuidSelected, &GUID_NULL)) {
pSetupStringFromGuid(&GUID_DEVCLASS_UNKNOWN, ClassGuidString, sizeof(ClassGuidString)/sizeof(TCHAR) );
SetupDiSetDeviceRegistryProperty(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, SPDRP_CLASSGUID, (PBYTE)ClassGuidString, sizeof(ClassGuidString) ); }
ClassGuidInf = *NewDevWiz->ClassGuidSelected; }
//
// We will backup the current drivers in all cases except if any of the following are true:
//
// 1) The device is a printer
// 2) The selected driver is the currently installed driver
// 3) The DontBackupCurrentDrivers NEWDEVWIZ BOOL is TRUE
// 4) The device has a problem
//
if (IsEqualGUID(&ClassGuidInf, &GUID_DEVCLASS_PRINTER) || IsInstalledDriver(NewDevWiz, NULL) || (NewDevWiz->Flags & IDI_FLAG_NOBACKUP) || ((CM_Get_DevNode_Status(&DevNodeStatus, &Problem, NewDevWiz->DeviceInfoData.DevInst, 0) == CR_SUCCESS) && ((DevNodeStatus & DN_HAS_PROBLEM) || (DevNodeStatus & DN_PRIVATE_PROBLEM)))) {
Backup = FALSE;
} else {
Backup = TRUE; }
//
// We will always create our own queue during device install, except in the
// following specific cases.
//
// 1) The device is a printer
//
// Note that if we can't create our own queue then we cannot do any of the
// operations that need a queue, like backup, rollback, read-only install,
// or setting a restore point.
//
DontCreateQueue = IsEqualGUID(&ClassGuidInf, & GUID_DEVCLASS_PRINTER);
Error = ClassInstallerInstalls(hwndParent, NewDevWiz, Backup, (NewDevWiz->Flags & IDI_FLAG_READONLY_INSTALL), DontCreateQueue );
//
// If this is a WU/CDM install and it was successful then set
// the DriverWasUpgraded to TRUE
//
if (NewDevWiz->UpdateDriverInfo && (Error == ERROR_SUCCESS)) {
NewDevWiz->UpdateDriverInfo->DriverWasUpgraded = TRUE; }
//
// If this is a new device (currently no drivers are installed) and we encounter
// an error that is not ERROR_CANCELLED then we will install the NULL driver for
// this device and set the FAILED INSTALL flag.
//
if ((Error != ERROR_SUCCESS) && (Error != ERROR_CANCELLED)) { if (IsNullDriverInstalled(NewDevWiz->DeviceInfoData.DevInst)) {
if (SetupDiSetSelectedDriver(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, NULL )) { DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
if (SetupDiGetDeviceInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DeviceInstallParams )) { DeviceInstallParams.FlagsEx |= DI_FLAGSEX_SETFAILEDINSTALL; SetupDiSetDeviceInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DeviceInstallParams ); }
SetupDiInstallDevice(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData); } }
goto clean0; }
//
// See if the device needs to the system to be restarted before it will work.
//
if(!IgnoreRebootFlags) { DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS); if (SetupDiGetDeviceInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DeviceInstallParams ) && (DeviceInstallParams.Flags & (DI_NEEDRESTART | DI_NEEDREBOOT))) { //
// If either the DI_NEEDRESTART or the DI_NEEDREBOOT DeviceInstallParams
// flag is set, then a restart is needed.
//
NewDevWiz->Reboot |= DI_NEEDREBOOT; } else if ((CM_Get_DevNode_Status(&DevNodeStatus, &Problem, NewDevWiz->DeviceInfoData.DevInst, 0) == CR_SUCCESS) && (DevNodeStatus & DN_NEED_RESTART) || (Problem == CM_PROB_NEED_RESTART)) { //
// If the DN_NEED_RESTART devnode status flag is set, then a restart
// is needed.
//
NewDevWiz->Reboot |= DI_NEEDREBOOT; } }
clean0:
return Error;}
DWORDInstallNullDriver( HWND hDlg, PNEWDEVWIZ NewDevWiz, BOOL FailedInstall ){ SP_DEVINSTALL_PARAMS DevInstallParams; DWORD Err = ERROR_SUCCESS;
DevInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
//
// Set the DI_FLAGSEX_SETFAILEDINSTALL flag if this is a failed
// install.
//
if (FailedInstall) { if (SetupDiGetDeviceInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DevInstallParams )) { DevInstallParams.FlagsEx |= DI_FLAGSEX_SETFAILEDINSTALL; SetupDiSetDeviceInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DevInstallParams ); } }
//
// Set the selected driver to NULL
//
if (SetupDiSetSelectedDriver(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, NULL )) { //
// verify with class installer, and class-specific coinstallers
// that the driver is not blacklisted. For DIF_ALLOW_INSTALL we
// accept ERROR_SUCCESS or ERROR_DI_DO_DEFAULT as good return codes.
//
if (SetupDiCallClassInstaller(DIF_ALLOW_INSTALL, NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData ) || (GetLastError() == ERROR_DI_DO_DEFAULT)) {
//
// If the class/co-installers gave the OK then call DIF_INSTALLDEVICE.
//
if (!SetupDiCallClassInstaller(DIF_INSTALLDEVICE, NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData )) { Err = GetLastError(); }
} else { Err = GetLastError(); } }
return Err;
} // InstallNullDriver
BOOLCALLBACKAddPropSheetPageProc( IN HPROPSHEETPAGE hpage, IN LPARAM lParam ){ *((HPROPSHEETPAGE *)lParam) = hpage; return TRUE;}
voidDisplayResource( PNEWDEVWIZ NewDevWiz, HWND hWndParent ){ HINSTANCE hLib; PROPSHEETHEADER psh; HPROPSHEETPAGE hpsPages[1]; SP_PROPSHEETPAGE_REQUEST PropPageRequest; LPFNADDPROPSHEETPAGES ExtensionPropSheetPage = NULL; LPTSTR Title; SP_DEVINSTALL_PARAMS DevInstallParams;
//
// Now get the resource selection page from setupapi.dll
//
hLib = GetModuleHandle(TEXT("setupapi.dll")); if (hLib) { ExtensionPropSheetPage = (PVOID)GetProcAddress(hLib, "ExtensionPropSheetPageProc"); }
if (!ExtensionPropSheetPage) { return; }
PropPageRequest.cbSize = sizeof(SP_PROPSHEETPAGE_REQUEST); PropPageRequest.PageRequested = SPPSR_SELECT_DEVICE_RESOURCES; PropPageRequest.DeviceInfoSet = NewDevWiz->hDeviceInfo; PropPageRequest.DeviceInfoData = &NewDevWiz->DeviceInfoData;
if (!ExtensionPropSheetPage(&PropPageRequest, AddPropSheetPageProc, (LONG_PTR)hpsPages )) { // warning ?
return; }
//
// create the property sheet
//
psh.dwSize = sizeof(PROPSHEETHEADER); psh.dwFlags = PSH_PROPTITLE | PSH_NOAPPLYNOW; psh.hwndParent = hWndParent; psh.hInstance = hNewDev; psh.pszIcon = NULL;
switch (NewDevWiz->InstallType) {
case NDWTYPE_FOUNDNEW: Title = (LPTSTR)IDS_FOUNDDEVICE; break;
case NDWTYPE_UPDATE: Title = (LPTSTR)IDS_UPDATEDEVICE; break;
default: Title = TEXT(""); // unknown
}
psh.pszCaption = Title;
psh.nPages = 1; psh.phpage = hpsPages; psh.nStartPage = 0; psh.pfnCallback = NULL;
//
// Clear the Propchange pending bit in the DeviceInstall params.
//
DevInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS); if (SetupDiGetDeviceInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DevInstallParams )) { DevInstallParams.FlagsEx &= ~DI_FLAGSEX_PROPCHANGE_PENDING; SetupDiSetDeviceInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DevInstallParams ); }
if (PropertySheet(&psh) == -1) { DestroyPropertySheetPage(hpsPages[0]); }
//
// If a PropChange occurred invoke the DIF_PROPERTYCHANGE
//
if (SetupDiGetDeviceInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, &DevInstallParams )) { if (DevInstallParams.FlagsEx & DI_FLAGSEX_PROPCHANGE_PENDING) { SP_PROPCHANGE_PARAMS PropChangeParams;
PropChangeParams.ClassInstallHeader.cbSize = sizeof(SP_CLASSINSTALL_HEADER); PropChangeParams.ClassInstallHeader.InstallFunction = DIF_PROPERTYCHANGE; PropChangeParams.Scope = DICS_FLAG_GLOBAL; PropChangeParams.HwProfile = 0;
if (SetupDiSetClassInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, (PSP_CLASSINSTALL_HEADER)&PropChangeParams, sizeof(PropChangeParams) )) { SetupDiCallClassInstaller(DIF_PROPERTYCHANGE, NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData ); }
//
// Clear the class install parameters.
//
SetupDiSetClassInstallParams(NewDevWiz->hDeviceInfo, &NewDevWiz->DeviceInfoData, NULL, 0 ); } }
return;}
DWORD WINAPIInstallDevThreadProc( LPVOID lpVoid )/*++
Description:
In the Wizard, we will do the driver installation in a separate thread so that the user will see the driver instal wizard page.
--*/{ PNEWDEVWIZ NewDevWiz = (PNEWDEVWIZ)lpVoid;
//
// Do the device install
//
NewDevWiz->LastError = InstallDev(NewDevWiz->hWnd, NewDevWiz);
//
// Post a message to the window to let it know that we are finished with the install
//
PostMessage(NewDevWiz->hWnd, WUM_INSTALLCOMPLETE, TRUE, GetLastError());
return GetLastError();}
INT_PTR CALLBACKNDW_InstallDevDlgProc( HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam ){ HWND hwndParentDlg = GetParent(hDlg); PNEWDEVWIZ NewDevWiz = (PNEWDEVWIZ)GetWindowLongPtr(hDlg, DWLP_USER); LONG Error; ULONG DevNodeStatus, Problem; static HANDLE DeviceInstallThread = NULL; TCHAR Text1[MAX_PATH], Text2[MAX_PATH], Target[MAX_PATH], Format[MAX_PATH]; PTSTR p;
switch (wMsg) {
case WM_INITDIALOG: {
LPPROPSHEETPAGE lppsp = (LPPROPSHEETPAGE)lParam; NewDevWiz = (PNEWDEVWIZ)lppsp->lParam; SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)NewDevWiz);
break; }
case WM_DESTROY: break;
case WUM_INSTALLCOMPLETE: //
// This message is posted to the window when the device installation is complete.
//
WaitForSingleObject(DeviceInstallThread, INFINITE); Animate_Stop(GetDlgItem(hDlg, IDC_ANIMATE_INSTALL)); NewDevWiz->CurrCursor = NULL; PropSheet_PressButton(hwndParentDlg, PSBTN_NEXT); break;
case WUM_INSTALLPROGRESS: Text1[0] = Text2[0] = TEXT('\0');
//
// This is the message that is sent from setupapi so we can display our
// own copy progress.
//
// If wParam is 0 then the lParam is the number of files that will be
// copied.
// If wParam is 1 then that is a tick for a single file being copied,
// so the progress bar should be advanced.
//
switch (wParam) { case 0: ShowWindow(GetDlgItem(hDlg, IDC_PROGRESS_INSTALL), SW_SHOW); ShowWindow(GetDlgItem(hDlg, IDC_FILECOPY_TEXT1), SW_SHOW); ShowWindow(GetDlgItem(hDlg, IDC_FILECOPY_TEXT2), SW_SHOW); ShowWindow(GetDlgItem(hDlg, IDC_STATUS_TEXT), SW_HIDE); SetDlgItemText(hDlg, IDC_FILECOPY_TEXT1, TEXT("")); SetDlgItemText(hDlg, IDC_FILECOPY_TEXT2, TEXT("")); SendMessage(GetDlgItem(hDlg, IDC_PROGRESS_INSTALL), PBM_SETRANGE,0,MAKELPARAM(0,lParam)); SendMessage(GetDlgItem(hDlg, IDC_PROGRESS_INSTALL), PBM_SETSTEP,1,0); SendMessage(GetDlgItem(hDlg, IDC_PROGRESS_INSTALL), PBM_SETPOS,0,0); break; case 1: SendMessage(GetDlgItem(hDlg, IDC_PROGRESS_INSTALL), PBM_STEPIT,0,0); break;
case INSTALLOP_COPY: lstrcpyn(Target, ((PFILEPATHS)lParam)->Target, MAX_PATH); if (p = _tcsrchr(Target,TEXT('\\'))) { *p++ = 0; lstrcpyn(Text1, p, MAX_PATH); if (LoadString(hNewDev, IDS_FILEOP_TO, Format, SIZECHARS(Format))) { _snwprintf(Text2, MAX_PATH, Format, Target); } } else { lstrcpyn(Text1, ((PFILEPATHS)lParam)->Target, MAX_PATH); lstrcpy(Text2, TEXT("")); } break;
case INSTALLOP_RENAME: lstrcpyn(Text1, ((PFILEPATHS)lParam)->Source, MAX_PATH); if (p = _tcsrchr(((PFILEPATHS)lParam)->Target, TEXT('\\'))) { p++; } else { p = (PTSTR)((PFILEPATHS)lParam)->Target; } if (LoadString(hNewDev, IDS_FILEOP_TO, Format, SIZECHARS(Format))) { _snwprintf(Text2, MAX_PATH, Format, p); } break;
case INSTALLOP_DELETE: lstrcpyn(Target, ((PFILEPATHS)lParam)->Target, MAX_PATH); if (p = _tcsrchr(Target,TEXT('\\'))) { *p++ = 0; lstrcpyn(Text1, p, MAX_PATH); if (LoadString(hNewDev, IDS_FILEOP_FROM, Format, SIZECHARS(Format))) { _snwprintf(Text2, MAX_PATH, Format, Target); } } else { lstrcpyn(Text1, ((PFILEPATHS)lParam)->Target, MAX_PATH); lstrcpy(Text2, TEXT("")); } break;
case INSTALLOP_BACKUP: lstrcpyn(Target, ((PFILEPATHS)lParam)->Source, MAX_PATH); if (p = _tcsrchr(Target,TEXT('\\'))) { *p++ = 0; if (((PFILEPATHS)lParam)->Target == NULL) { if (LoadString(hNewDev, IDS_FILEOP_BACKUP, Format, SIZECHARS(Format))) { _snwprintf(Text1, MAX_PATH, Format, p); } } else { lstrcpyn(Text1, p, MAX_PATH); } lstrcpyn(Text2, Target, MAX_PATH); } else { if (LoadString(hNewDev, IDS_FILEOP_BACKUP, Format, SIZECHARS(Format))) { _snwprintf(Text1, MAX_PATH, Format, Target); } lstrcpy(Text2, TEXT("")); } break;
case INSTALLOP_SETTEXT: ShowWindow(GetDlgItem(hDlg, IDC_STATUS_TEXT), SW_SHOW); ShowWindow(GetDlgItem(hDlg, IDC_PROGRESS_INSTALL), SW_HIDE); ShowWindow(GetDlgItem(hDlg, IDC_FILECOPY_TEXT1), SW_HIDE);
if (lParam) { if (LoadString(hNewDev, (UINT)lParam, Text2, SIZECHARS(Text2))) { ShowWindow(GetDlgItem(hDlg, IDC_STATUS_TEXT), SW_SHOW); SetDlgItemText(hDlg, IDC_STATUS_TEXT, Text2); } } else { SetDlgItemText(hDlg, IDC_STATUS_TEXT, TEXT("")); } Text1[0] = TEXT('\0'); Text2[0] = TEXT('\0'); break; }
if ((Text1[0] != TEXT('\0')) && (Text2[0] != TEXT('\0'))) { ShowWindow(GetDlgItem(hDlg, IDC_STATUS_TEXT), SW_HIDE); ShowWindow(GetDlgItem(hDlg, IDC_FILECOPY_TEXT1), SW_SHOW); ShowWindow(GetDlgItem(hDlg, IDC_FILECOPY_TEXT2), SW_SHOW); SetDlgItemText(hDlg, IDC_FILECOPY_TEXT1, Text1); SetDlgItemText(hDlg, IDC_FILECOPY_TEXT2, Text2); } break;
case WM_NOTIFY: switch (((NMHDR FAR *)lParam)->code) {
case PSN_SETACTIVE: {
HICON hicon; SP_DRVINFO_DATA DriverInfoData;
NewDevWiz->PrevPage = IDD_NEWDEVWIZ_INSTALLDEV;
//
// This is an intermediary status page, no buttons needed.
// Set the device description
// Set the class Icon
//
PropSheet_SetWizButtons(hwndParentDlg, 0); EnableWindow(GetDlgItem(GetParent(hDlg), IDCANCEL), FALSE); ShowWindow(GetDlgItem(hDlg, IDC_PROGRESS_INSTALL), SW_HIDE); ShowWindow(GetDlgItem(hDlg, IDC_FILECOPY_TEXT1), SW_HIDE); ShowWindow(GetDlgItem(hDlg, IDC_FILECOPY_TEXT2), SW_HIDE); ShowWindow(GetDlgItem(hDlg, IDC_STATUS_TEXT), SW_HIDE);
SetDriverDescription(hDlg, IDC_NDW_DESCRIPTION, NewDevWiz);
if (SetupDiLoadClassIcon(NewDevWiz->ClassGuidSelected, &hicon, NULL)) { hicon = (HICON)SendDlgItemMessage(hDlg, IDC_CLASSICON, STM_SETICON, (WPARAM)hicon, 0L); if (hicon) { DestroyIcon(hicon); } }
NewDevWiz->CurrCursor = NewDevWiz->IdcWait; SetCursor(NewDevWiz->CurrCursor);
//
// If we are doing a silent install then do the actual install here in the PSN_SETACTIVE.
// Doing the install here means that this wizard page will never be displayed. When we
// are finished calling InstallDev() then we will jump to any FinishInstall pages that
// the class/co-installers have added, or we will jump to our finish page.
//
if (NewDevWiz->SilentMode) { //
// do the Install immediately and move to the next page
// to prevent any UI from showing.
//
NewDevWiz->hWnd = NULL; NewDevWiz->LastError =InstallDev(hDlg, NewDevWiz); NewDevWiz->CurrCursor = NULL;
//
// Add the FinishInstall Page and jump to it if the install was successful
//
if (NewDevWiz->LastError == ERROR_SUCCESS) {
NewDevWiz->WizExtFinishInstall.hPropSheet = CreateWizExtPage(IDD_WIZARDEXT_FINISHINSTALL, WizExtFinishInstallDlgProc, NewDevWiz );
if (NewDevWiz->WizExtFinishInstall.hPropSheet) {
PropSheet_AddPage(hwndParentDlg, NewDevWiz->WizExtFinishInstall.hPropSheet); }
SetDlgMsgResult(hDlg, wMsg, IDD_WIZARDEXT_FINISHINSTALL);
} else {
//
// There was an error during the install so just jump to our finish page
//
SetDlgMsgResult(hDlg, wMsg, -1); } }
//
// Post ourselves a msg, to do the actual install, this allows this
// page to show itself while the install is actually occuring.
//
else { DWORD ThreadId; NewDevWiz->hWnd = hDlg;
ShowWindow(GetDlgItem(hDlg, IDC_ANIMATE_INSTALL), SW_SHOW); Animate_Open(GetDlgItem(hDlg, IDC_ANIMATE_INSTALL), MAKEINTRESOURCE(IDA_INSTALLING)); Animate_Play(GetDlgItem(hDlg, IDC_ANIMATE_INSTALL), 0, -1, -1);
//
// Start up a separate thread to do the device installation on.
// When the driver installation is complete the InstallDevThreadProc
// will post us a WUM_INSTALLCOMPLETE message.
//
DeviceInstallThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)InstallDevThreadProc, (LPVOID)NewDevWiz, 0, &ThreadId );
//
// If the CreateThread fails then we will just call InstallDev() ourselves.
//
if (!DeviceInstallThread) {
NewDevWiz->hWnd = NULL;
//
// Do the device install
//
NewDevWiz->LastError = InstallDev(NewDevWiz->hWnd, NewDevWiz);
//
// Post a message to the window to let it know that we are finished with the install
//
PostMessage(hDlg, WUM_INSTALLCOMPLETE, TRUE, GetLastError()); } }
break; }
case PSN_WIZNEXT:
Animate_Stop(GetDlgItem(hDlg, IDC_ANIMATE_INSTALL));
//
// Add the FinishInstall Page and jump to it if the installation succeded.
//
if (NewDevWiz->LastError == ERROR_SUCCESS) {
NewDevWiz->WizExtFinishInstall.hPropSheet = CreateWizExtPage(IDD_WIZARDEXT_FINISHINSTALL, WizExtFinishInstallDlgProc, NewDevWiz );
if (NewDevWiz->WizExtFinishInstall.hPropSheet) { PropSheet_AddPage(hwndParentDlg, NewDevWiz->WizExtFinishInstall.hPropSheet); }
SetDlgMsgResult(hDlg, wMsg, IDD_WIZARDEXT_FINISHINSTALL);
} else {
//
// There was an error during the install so just jump to our finish page
//
SetDlgMsgResult(hDlg, wMsg, IDD_NEWDEVWIZ_FINISH); } break; } break;
case WM_SETCURSOR: if (NewDevWiz->CurrCursor) { SetCursor(NewDevWiz->CurrCursor); break; }
// fall thru to return(FALSE);
default: return(FALSE); }
return(TRUE);}
voidShowInstallSummary( HWND hDlg, PNEWDEVWIZ NewDevWiz ){ LONG Error; CONFIGRET ConfigRet; ULONG Len, Problem, DevNodeStatus; BOOL HasResources; HWND hwndParentDlg = GetParent(hDlg); PTCHAR ErrorMsg, ProblemText; TCHAR TextBuffer[MAX_PATH*4];
Problem = 0; *TextBuffer = TEXT('\0');
Error = NewDevWiz->LastError;
//
// On Windows Update installs we don't want to show any UI at all, even
// if there was an error during the installation.
// We can tell a WU install from a CDM install because only a WU install
// has a UpdateDriverInfo structure and is SilentMode.
// We also never want to show the finish page if this is a NonInteractive
// install.
//
if ((NewDevWiz->SilentMode && NewDevWiz->UpdateDriverInfo) || NewDevWiz->Flags & IDI_FLAG_NONINTERACTIVE) { HideWindowByMove(hwndParentDlg); PropSheet_PressButton(hwndParentDlg, PSBTN_FINISH); return; }
if (NewDevWiz->hfontTextBigBold) { SetWindowFont(GetDlgItem(hDlg, IDC_FINISH_MSG1), NewDevWiz->hfontTextBigBold, TRUE); }
if (NDWTYPE_UPDATE == NewDevWiz->InstallType) { SetDlgText(hDlg, IDC_FINISH_MSG1, IDS_FINISH_MSG1_UPGRADE, IDS_FINISH_MSG1_UPGRADE);
} else { SetDlgText(hDlg, IDC_FINISH_MSG1, IDS_FINISH_MSG1_NEW, IDS_FINISH_MSG1_NEW); }
//
// Installation failed
//
if (Error != ERROR_SUCCESS) { NewDevWiz->Installed = FALSE;
SetDlgText(hDlg, IDC_FINISH_MSG1, IDS_FINISH_MSG1_INSTALL_PROBLEM, IDS_FINISH_MSG1_INSTALL_PROBLEM); SetDlgText(hDlg, IDC_FINISH_MSG2, IDS_FINISH_PROB_MSG2, IDS_FINISH_PROB_MSG2);
#if DBG
DbgPrint("InstallDev Error =%x\n", Error);#endif
//
// Display failure message for installation
//
// We will special case the following error codes so we can give a more
// friendly description of the problem to the user:
//
// TRUST_E_SUBJECT_FORM_UNKNOWN
// ERROR_NO_ASSOCIATED_SERVICE
// TYPE_E_ELEMENTNOTFOUND
// ERROR_NOT_FOUND
//
if ((Error == TRUST_E_SUBJECT_FORM_UNKNOWN) || (Error == CERT_E_EXPIRED) || (Error == TYPE_E_ELEMENTNOTFOUND) || (Error == ERROR_NOT_FOUND)) {
LoadText(TextBuffer, sizeof(TextBuffer), IDS_FINISH_PROB_TRUST_E_SUBJECT_FORM_UNKNOWN, IDS_FINISH_PROB_TRUST_E_SUBJECT_FORM_UNKNOWN);
} else if (Error == ERROR_NO_ASSOCIATED_SERVICE) {
LoadText(TextBuffer, sizeof(TextBuffer), IDS_FINISH_PROB_ERROR_NO_ASSOCIATED_SERVICE, IDS_FINISH_PROB_ERROR_NO_ASSOCIATED_SERVICE);
} else {
LoadText(TextBuffer, sizeof(TextBuffer), IDS_NDW_ERRORFIN1_PNP, IDS_NDW_ERRORFIN1_PNP);
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, HRESULT_FROM_SETUPAPI(Error), 0, (LPTSTR)&ErrorMsg, 0, NULL )) { lstrcat(TextBuffer, TEXT("\n\n")); lstrcat(TextBuffer, ErrorMsg); LocalFree(ErrorMsg); } }
SetDlgItemText(hDlg, IDC_FINISH_MSG3, TextBuffer); }
//
// No errors installing the drivers for this device
//
else { //
// Check to see if the device itself has any problems
//
Error = CM_Get_DevNode_Status(&DevNodeStatus, &Problem, NewDevWiz->DeviceInfoData.DevInst, 0 ); if(Error != CR_SUCCESS) { //
// For some reason, we couldn't retrieve the devnode's status.
// Default status and problem values to zero.
//
DevNodeStatus = Problem = 0; }
//
// make sure the reboot flags\Problem are set correctly
//
if (NewDevWiz->Reboot || Problem == CM_PROB_NEED_RESTART) { if (Problem != CM_PROB_PARTIAL_LOG_CONF) { Problem = CM_PROB_NEED_RESTART; }
NewDevWiz->Reboot |= DI_NEEDREBOOT; }
NewDevWiz->Installed = TRUE; HasResources = DeviceHasResources(NewDevWiz->DeviceInfoData.DevInst);
//
// The device has a problem
//
if ((Error != CR_SUCCESS) || Problem) { //
// If we are going to launch the troubleshooter then change the finish text.
//
// We currently launch the troubleshooter if the device has some type of problem,
// unless the problem is CM_PROB_NEED_RESTART.
//
if (Problem && (Problem != CM_PROB_NEED_RESTART)) {
SetDlgText(hDlg, IDC_FINISH_MSG1, IDS_FINISH_MSG1_DEVICE_PROBLEM, IDS_FINISH_MSG1_DEVICE_PROBLEM); SetDlgText(hDlg, IDC_FINISH_MSG2, IDS_FINISH_PROB_MSG2, IDS_FINISH_PROB_MSG2);
NewDevWiz->LaunchTroubleShooter = TRUE; SetDlgText(hDlg, IDC_FINISH_MSG4, IDS_FINISH_PROB_MSG4, IDS_FINISH_PROB_MSG4); }
//
// Show the resource button if the device has resources and it
// has the problem CM_PROB_PARTIAL_LOG_CONF
//
if (HasResources && (Problem == CM_PROB_PARTIAL_LOG_CONF)) { ShowWindow(GetDlgItem(hDlg, IDC_NDW_DISPLAYRESOURCE), SW_SHOW); }
if (Problem == CM_PROB_NEED_RESTART) { LoadText(TextBuffer, sizeof(TextBuffer), IDS_NEEDREBOOT, IDS_NEEDREBOOT); }
else if (Problem) { ProblemText = DeviceProblemText(NULL, NewDevWiz->DeviceInfoData.DevInst, Problem );
if (ProblemText) { lstrcat(TextBuffer, TEXT("\n\n")); lstrcat(TextBuffer, ProblemText); LocalFree(ProblemText); } }
#if DBG
DbgPrint("InstallDev CM_Get_DevNode_Status()=%x DevNodeStatus=%x Problem=%x\n", Error, DevNodeStatus, Problem );#endif
}
//
// Installation was sucessful and the device does not have any problems
//
else { //
// If this was a silent install (a Rank 0 match for example) then don't show the finish
// page.
//
if (NewDevWiz->SilentMode) { HideWindowByMove(hwndParentDlg); PropSheet_PressButton(hwndParentDlg, PSBTN_FINISH); return; } }
SetDlgItemText(hDlg, IDC_FINISH_MSG3, TextBuffer); }}
INT_PTR CALLBACKNDW_FinishDlgProc( HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam ){ PNEWDEVWIZ NewDevWiz = (PNEWDEVWIZ)GetWindowLongPtr(hDlg, DWLP_USER);
switch (wMsg) { case WM_INITDIALOG: { LPPROPSHEETPAGE lppsp = (LPPROPSHEETPAGE)lParam; NewDevWiz = (PNEWDEVWIZ)lppsp->lParam; SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)NewDevWiz);
break; }
case WM_DESTROY: break;
case WM_COMMAND: switch (wParam) { case IDC_NDW_DISPLAYRESOURCE: DisplayResource(NewDevWiz, GetParent(hDlg)); break; }
break;
case WM_NOTIFY: switch (((NMHDR FAR *)lParam)->code) { case PSN_SETACTIVE: { HICON hicon; SP_DRVINFO_DATA DriverInfoData;
//
// No back button since install is already done.
// set the device description
// Hide Resources button until we know if resources exist or not.
// Set the class Icon
//
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_FINISH);
EnableWindow(GetDlgItem(GetParent(hDlg), IDCANCEL), FALSE);
ShowWindow(GetDlgItem(hDlg, IDC_NDW_DISPLAYRESOURCE), SW_HIDE);
if (NewDevWiz->LastError == ERROR_CANCELLED) {
if (NewDevWiz->SilentMode) { HideWindowByMove(GetParent(hDlg)); }
PropSheet_PressButton(GetParent(hDlg), PSBTN_CANCEL);
} else {
SetDriverDescription(hDlg, IDC_NDW_DESCRIPTION, NewDevWiz);
if (SetupDiLoadClassIcon(NewDevWiz->ClassGuidSelected, &hicon, NULL)) { hicon = (HICON)SendDlgItemMessage(hDlg, IDC_CLASSICON, STM_SETICON, (WPARAM)hicon, 0L); if (hicon) { DestroyIcon(hicon); } }
ShowInstallSummary(hDlg, NewDevWiz); } break; }
case PSN_RESET: break;
case PSN_WIZFINISH: if (NewDevWiz->LaunchTroubleShooter) {
//
// The command line that we will run is:
// rundll32 devmgr.dll, DeviceProblenWizard_RunDLL /deviceid %s
// where %s is the device instance id.
//
TCHAR szCmdLine[512]; TCHAR DeviceInstanceId[MAX_DEVICE_ID_LEN];
if (CM_Get_Device_ID(NewDevWiz->DeviceInfoData.DevInst, DeviceInstanceId, sizeof(DeviceInstanceId)/sizeof(TCHAR), 0 ) == CR_SUCCESS) {
wsprintf(szCmdLine, TEXT("devmgr.dll,DeviceProblenWizard_RunDLL /deviceid %s"), DeviceInstanceId);
ShellExecute(NULL, TEXT("open"), TEXT("RUNDLL32.EXE"), szCmdLine, NULL, SW_SHOWNORMAL ); } } break;
} break;
default: return(FALSE); }
return(TRUE);}
INT_PTR CALLBACKWizExtFinishInstallDlgProc( HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam ){ HWND hwndParentDlg = GetParent(hDlg); PNEWDEVWIZ NewDevWiz = (PNEWDEVWIZ )GetWindowLongPtr(hDlg, DWLP_USER); int PrevPageId;
switch (wMsg) {
case WM_INITDIALOG: {
LPPROPSHEETPAGE lppsp = (LPPROPSHEETPAGE)lParam; NewDevWiz = (PNEWDEVWIZ )lppsp->lParam; SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)NewDevWiz); break; }
case WM_DESTROY: break;
case WM_NOTIFY:
switch (((NMHDR FAR *)lParam)->code) {
case PSN_SETACTIVE:
PrevPageId = NewDevWiz->PrevPage; NewDevWiz->PrevPage = IDD_WIZARDEXT_FINISHINSTALL;
if (PrevPageId == IDD_NEWDEVWIZ_INSTALLDEV) { PROPSHEETPAGE psp; HPROPSHEETPAGE hPage = NULL;
//
// Moving forward on first page
//
//
// If this was a silent install and NOT a NonInteractive install
// then we need to create the FinishInstallIntro page at this
// point so we can add it to the wizard. We do this so the wizard
// has a proper intro and finish page with the FinishInstall
// pages inbetween.
//
if (NewDevWiz->SilentMode && !(NewDevWiz->Flags & IDI_FLAG_NONINTERACTIVE)) {
ZeroMemory(&psp, sizeof(PROPSHEETPAGE)); psp.dwSize = sizeof(PROPSHEETPAGE); psp.hInstance = hNewDev; psp.dwFlags = PSP_DEFAULT | PSP_USETITLE | PSP_HIDEHEADER; psp.pszTemplate = MAKEINTRESOURCE(IDD_NEWDEVWIZ_FINISHINSTALL_INTRO); psp.pfnDlgProc = FinishInstallIntroDlgProc; psp.lParam = (LPARAM)NewDevWiz;
hPage = CreatePropertySheetPage(&psp); }
//
// Add ClassWizard Extension pages for FinishInstall
//
if (AddClassWizExtPages(hwndParentDlg, NewDevWiz, &NewDevWiz->WizExtFinishInstall.DeviceWizardData, DIF_NEWDEVICEWIZARD_FINISHINSTALL, hPage )) {
//
// If this is a NonInteractive install then we need to set the last
// error at this point so the error is propagated back to the original
// caller.
//
if (NewDevWiz->Flags & IDI_FLAG_NONINTERACTIVE) {
NewDevWiz->LastError = ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION;
} else {
//
// If we have finish install pages then we should also show the finish
// page.
//
NewDevWiz->SilentMode = FALSE; } }
//
// Add the end page, which is FinishInstall end
//
NewDevWiz->WizExtFinishInstall.hPropSheetEnd = CreateWizExtPage(IDD_WIZARDEXT_FINISHINSTALL_END, WizExtFinishInstallEndDlgProc, NewDevWiz );
if (NewDevWiz->WizExtFinishInstall.hPropSheetEnd) { PropSheet_AddPage(hwndParentDlg, NewDevWiz->WizExtFinishInstall.hPropSheetEnd); } }
//
// We can't go backwards, so always go forward
//
SetDlgMsgResult(hDlg, wMsg, -1); break;
case PSN_WIZNEXT: SetDlgMsgResult(hDlg, wMsg, 0); break; } break;
default: return(FALSE); }
return(TRUE);}
INT_PTR CALLBACKWizExtFinishInstallEndDlgProc( HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam ){ HWND hwndParentDlg = GetParent(hDlg); PNEWDEVWIZ NewDevWiz = (PNEWDEVWIZ )GetWindowLongPtr(hDlg, DWLP_USER); int PrevPageId;
switch (wMsg) {
case WM_INITDIALOG: {
LPPROPSHEETPAGE lppsp = (LPPROPSHEETPAGE)lParam; NewDevWiz = (PNEWDEVWIZ )lppsp->lParam; SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)NewDevWiz); break; }
case WM_DESTROY: break;
case WM_NOTIFY:
switch (((NMHDR FAR *)lParam)->code) {
case PSN_SETACTIVE:
PrevPageId = NewDevWiz->PrevPage; NewDevWiz->PrevPage = IDD_WIZARDEXT_FINISHINSTALL_END;
//
// We can't go backwards, so always go forward
//
SetDlgMsgResult(hDlg, wMsg, IDD_NEWDEVWIZ_FINISH); break;
case PSN_WIZBACK: case PSN_WIZNEXT: SetDlgMsgResult(hDlg, wMsg, 0); break; } break;
default: return(FALSE); }
return(TRUE);}
|
