1668 lines
46 KiB
C
1668 lines
46 KiB
C
/*++
|
|
|
|
Copyright (c) 1995 Microsoft Corporation
|
|
All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
Utildi.c
|
|
|
|
Abstract:
|
|
|
|
Driver Setup DeviceInstaller Utility functions
|
|
|
|
Author:
|
|
|
|
Muhunthan Sivapragasam (MuhuntS) 06-Sep-1995
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
|
|
static const GUID GUID_DEVCLASS_PRINTER =
|
|
{ 0x4d36e979L, 0xe325, 0x11ce,
|
|
{ 0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1, 0x03, 0x18 } };
|
|
|
|
|
|
#if 0
|
|
TCHAR cszOEMInfGen[] = TEXT("%s\\inf\\OEM%d.INF");
|
|
TCHAR cszInfGen[] = TEXT("%s\\inf\\%s");
|
|
TCHAR cszClass[] = TEXT("Class");
|
|
TCHAR cszProvider[] = TEXT("Provider");
|
|
TCHAR cszPNF[] = TEXT ("PNF");
|
|
TCHAR cszINF[] = TEXT ("\\INF\\");
|
|
TCHAR cszInfWildCard[] = TEXT ("*.inf");
|
|
#endif
|
|
|
|
extern TCHAR cszPrinter[];
|
|
|
|
LPTSTR
|
|
GetInfQueryString(
|
|
IN PSP_INF_INFORMATION pSpInfInfo,
|
|
IN LPCTSTR pszKey
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Gets a specified string in a INF info list and put it into allocated memory
|
|
|
|
Arguments:
|
|
pSpInfInfo : Pointer to Handle to the information of an INF file
|
|
pszKey : Key of the string to be queried
|
|
|
|
Return Value:
|
|
The allocated string on success
|
|
NULL else
|
|
|
|
--*/
|
|
{
|
|
DWORD dwNeeded = 128;
|
|
LPTSTR pszStr;
|
|
|
|
if (! (pszStr = LocalAllocMem (dwNeeded * sizeof (*pszStr))))
|
|
return NULL;
|
|
|
|
if (SetupQueryInfVersionInformation(pSpInfInfo, 0, pszKey, pszStr,
|
|
dwNeeded, &dwNeeded)) {
|
|
return pszStr;
|
|
}
|
|
else {
|
|
LocalFreeMem (pszStr);
|
|
|
|
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER ) return NULL;
|
|
|
|
// Allocate Memory
|
|
if (! (pszStr = LocalAllocMem (dwNeeded * sizeof (*pszStr))))
|
|
return NULL;
|
|
|
|
if (!SetupQueryInfVersionInformation(pSpInfInfo, 0, pszKey, pszStr,
|
|
dwNeeded, &dwNeeded)){
|
|
LocalFreeMem (pszStr);
|
|
return NULL;
|
|
}
|
|
else
|
|
return pszStr;
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
SetSelectDevParams(
|
|
IN HDEVINFO hDevInfo,
|
|
IN PSP_DEVINFO_DATA pDevInfoData,
|
|
IN BOOL bWin95,
|
|
IN LPCTSTR pszModel OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Sets the select device parameters by calling setup apis
|
|
|
|
Arguments:
|
|
hDevInfo : Handle to the printer class device information list
|
|
bWin95 : TRUE if selecting Win95 driver, else WinNT driver
|
|
pszModel : Printer model we are looking for -- only for Win95 case
|
|
|
|
Return Value:
|
|
TRUE on success
|
|
FALSE else
|
|
|
|
--*/
|
|
{
|
|
SP_SELECTDEVICE_PARAMS SelectDevParams;
|
|
LPTSTR pszWin95Instn;
|
|
|
|
SelectDevParams.ClassInstallHeader.cbSize
|
|
= sizeof(SelectDevParams.ClassInstallHeader);
|
|
SelectDevParams.ClassInstallHeader.InstallFunction
|
|
= DIF_SELECTDEVICE;
|
|
|
|
//
|
|
// Get current SelectDevice parameters, and then set the fields
|
|
// we want to be different from default
|
|
//
|
|
if ( !SetupDiGetClassInstallParams(
|
|
hDevInfo,
|
|
pDevInfoData,
|
|
&SelectDevParams.ClassInstallHeader,
|
|
sizeof(SelectDevParams),
|
|
NULL) ) {
|
|
|
|
if ( GetLastError() != ERROR_NO_CLASSINSTALL_PARAMS )
|
|
return FALSE;
|
|
|
|
ZeroMemory(&SelectDevParams, sizeof(SelectDevParams)); // NEEDED 10/11 ?
|
|
SelectDevParams.ClassInstallHeader.cbSize
|
|
= sizeof(SelectDevParams.ClassInstallHeader);
|
|
SelectDevParams.ClassInstallHeader.InstallFunction
|
|
= DIF_SELECTDEVICE;
|
|
}
|
|
|
|
//
|
|
// Set the strings to use on the select driver page ..
|
|
//
|
|
LoadString(ghInst,
|
|
IDS_PRINTERWIZARD,
|
|
SelectDevParams.Title,
|
|
SIZECHARS(SelectDevParams.Title));
|
|
|
|
//
|
|
// For Win95 drivers instructions are different than NT drivers
|
|
//
|
|
if ( bWin95 ) {
|
|
|
|
pszWin95Instn = GetStringFromRcFile(IDS_WIN95DEV_INSTRUCT);
|
|
if ( !pszWin95Instn )
|
|
return FALSE;
|
|
|
|
if ( lstrlen(pszWin95Instn) + lstrlen(pszModel) + 1
|
|
> sizeof(SelectDevParams.Instructions) ) {
|
|
|
|
LocalFreeMem(pszWin95Instn);
|
|
return FALSE;
|
|
}
|
|
|
|
wsprintf(SelectDevParams.Instructions, pszWin95Instn, pszModel);
|
|
LocalFreeMem(pszWin95Instn);
|
|
} else {
|
|
|
|
LoadString(ghInst,
|
|
IDS_WINNTDEV_INSTRUCT,
|
|
SelectDevParams.Instructions,
|
|
SIZECHARS(SelectDevParams.Instructions));
|
|
}
|
|
|
|
LoadString(ghInst,
|
|
IDS_SELECTDEV_LABEL,
|
|
SelectDevParams.ListLabel,
|
|
SIZECHARS(SelectDevParams.ListLabel));
|
|
|
|
return SetupDiSetClassInstallParams(
|
|
hDevInfo,
|
|
pDevInfoData,
|
|
&SelectDevParams.ClassInstallHeader,
|
|
sizeof(SelectDevParams));
|
|
|
|
}
|
|
|
|
|
|
BOOL
|
|
PSetupSetSelectDevTitleAndInstructions(
|
|
HDEVINFO hDevInfo,
|
|
LPCTSTR pszTitle,
|
|
LPCTSTR pszSubTitle,
|
|
LPCTSTR pszInstn
|
|
)
|
|
{
|
|
SP_SELECTDEVICE_PARAMS SelectDevParams;
|
|
|
|
if ( pszTitle && lstrlen(pszTitle) + 1 > MAX_TITLE_LEN ) {
|
|
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
if ( pszSubTitle && lstrlen(pszSubTitle) + 1 > MAX_SUBTITLE_LEN ) {
|
|
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
if ( pszInstn && lstrlen(pszInstn) + 1 > MAX_INSTRUCTION_LEN ) {
|
|
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
SelectDevParams.ClassInstallHeader.cbSize
|
|
= sizeof(SelectDevParams.ClassInstallHeader);
|
|
SelectDevParams.ClassInstallHeader.InstallFunction
|
|
= DIF_SELECTDEVICE;
|
|
|
|
if ( !SetupDiGetClassInstallParams(hDevInfo,
|
|
NULL,
|
|
&SelectDevParams.ClassInstallHeader,
|
|
sizeof(SelectDevParams),
|
|
NULL) )
|
|
return FALSE;
|
|
|
|
if ( pszTitle )
|
|
lstrcpy(SelectDevParams.Title, pszTitle);
|
|
|
|
if ( pszSubTitle )
|
|
lstrcpy(SelectDevParams.SubTitle, pszSubTitle);
|
|
|
|
if ( pszInstn )
|
|
lstrcpy(SelectDevParams.Instructions, pszInstn);
|
|
|
|
return SetupDiSetClassInstallParams(
|
|
hDevInfo,
|
|
NULL,
|
|
&SelectDevParams.ClassInstallHeader,
|
|
sizeof(SelectDevParams));
|
|
|
|
}
|
|
|
|
BOOL
|
|
PSetupSelectDeviceButtons(
|
|
HDEVINFO hDevInfo,
|
|
DWORD dwFlagsSet,
|
|
DWORD dwFlagsClear
|
|
)
|
|
{
|
|
PSP_DEVINFO_DATA pDevInfoData = NULL;
|
|
SP_DEVINSTALL_PARAMS DevInstallParams;
|
|
|
|
// Check that no flags are both set & cleared
|
|
if (dwFlagsSet & dwFlagsClear)
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Get current SelectDevice parameters, and then set the fields
|
|
// we wanted changed from default
|
|
//
|
|
DevInstallParams.cbSize = sizeof(DevInstallParams);
|
|
if ( !SetupDiGetDeviceInstallParams(hDevInfo,
|
|
pDevInfoData,
|
|
&DevInstallParams) ) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Set Flag based on Argument for Web Button
|
|
if ( dwFlagsSet & SELECT_DEVICE_FROMWEB )
|
|
DevInstallParams.FlagsEx |= DI_FLAGSEX_SHOWWINDOWSUPDATE;
|
|
|
|
if ( dwFlagsClear & SELECT_DEVICE_FROMWEB )
|
|
DevInstallParams.FlagsEx &= ~DI_FLAGSEX_SHOWWINDOWSUPDATE;
|
|
|
|
if ( dwFlagsSet & SELECT_DEVICE_HAVEDISK )
|
|
DevInstallParams.Flags |= DI_SHOWOEM;
|
|
|
|
if ( dwFlagsClear & SELECT_DEVICE_HAVEDISK )
|
|
DevInstallParams.Flags &= ~DI_SHOWOEM;
|
|
|
|
return SetupDiSetDeviceInstallParams(hDevInfo,
|
|
pDevInfoData,
|
|
&DevInstallParams);
|
|
}
|
|
|
|
BOOL
|
|
SetDevInstallParams(
|
|
IN HDEVINFO hDevInfo,
|
|
IN PSP_DEVINFO_DATA pDevInfoData,
|
|
IN LPCTSTR pszDriverPath OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Sets the device installation parameters by calling setup apis
|
|
|
|
Arguments:
|
|
hDevInfo : Handle to the printer class device information list
|
|
pszDriverPath : Path where INF file should be searched
|
|
|
|
Return Value:
|
|
TRUE on success
|
|
FALSE else
|
|
|
|
--*/
|
|
{
|
|
SP_DEVINSTALL_PARAMS DevInstallParams;
|
|
|
|
//
|
|
// Get current SelectDevice parameters, and then set the fields
|
|
// we wanted changed from default
|
|
//
|
|
DevInstallParams.cbSize = sizeof(DevInstallParams);
|
|
if ( !SetupDiGetDeviceInstallParams(hDevInfo,
|
|
pDevInfoData,
|
|
&DevInstallParams) ) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Drivers are class drivers,
|
|
// ntprint.inf is sorted do not waste time sorting,
|
|
// show Have Disk button,
|
|
// use our strings on the select driver page
|
|
//
|
|
DevInstallParams.Flags |= DI_SHOWCLASS | DI_INF_IS_SORTED
|
|
| DI_SHOWOEM
|
|
| DI_USECI_SELECTSTRINGS;
|
|
|
|
if ( pszDriverPath && *pszDriverPath )
|
|
lstrcpy(DevInstallParams.DriverPath, pszDriverPath);
|
|
|
|
return SetupDiSetDeviceInstallParams(hDevInfo,
|
|
pDevInfoData,
|
|
&DevInstallParams);
|
|
}
|
|
|
|
|
|
BOOL
|
|
PSetupBuildDriversFromPath(
|
|
IN HDEVINFO hDevInfo,
|
|
IN LPCTSTR pszDriverPath,
|
|
IN BOOL bEnumSingleInf
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Builds the list of printer drivers from infs from a specified path.
|
|
Path could specify a directory or a single inf.
|
|
|
|
Arguments:
|
|
hDevInfo : Handle to the printer class device information list
|
|
pszDriverPath : Path where INF file should be searched
|
|
bEnumSingleInf : If TRUE pszDriverPath is a filename instead of path
|
|
|
|
Return Value:
|
|
TRUE on success
|
|
FALSE else
|
|
|
|
--*/
|
|
{
|
|
SP_DEVINSTALL_PARAMS DevInstallParams;
|
|
|
|
//
|
|
// Get current SelectDevice parameters, and then set the fields
|
|
// we wanted changed from default
|
|
//
|
|
DevInstallParams.cbSize = sizeof(DevInstallParams);
|
|
if ( !SetupDiGetDeviceInstallParams(hDevInfo,
|
|
NULL,
|
|
&DevInstallParams) ) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
DevInstallParams.Flags |= DI_INF_IS_SORTED;
|
|
|
|
if ( bEnumSingleInf )
|
|
DevInstallParams.Flags |= DI_ENUMSINGLEINF;
|
|
|
|
lstrcpy(DevInstallParams.DriverPath, pszDriverPath);
|
|
|
|
SetupDiDestroyDriverInfoList(hDevInfo,
|
|
NULL,
|
|
SPDIT_CLASSDRIVER);
|
|
|
|
return SetupDiSetDeviceInstallParams(hDevInfo,
|
|
NULL,
|
|
&DevInstallParams) &&
|
|
SetupDiBuildDriverInfoList(hDevInfo, NULL, SPDIT_CLASSDRIVER);
|
|
}
|
|
|
|
|
|
BOOL
|
|
DestroyOnlyPrinterDeviceInfoList(
|
|
IN HDEVINFO hDevInfo
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
This routine should be called at the end to destroy the printer device
|
|
info list
|
|
|
|
Arguments:
|
|
hDevInfo : Handle to the printer class device information list
|
|
|
|
Return Value:
|
|
TRUE on success, FALSE on error
|
|
|
|
--*/
|
|
{
|
|
|
|
return hDevInfo == INVALID_HANDLE_VALUE
|
|
? TRUE : SetupDiDestroyDeviceInfoList(hDevInfo);
|
|
}
|
|
|
|
|
|
BOOL
|
|
PSetupDestroyPrinterDeviceInfoList(
|
|
IN HDEVINFO hDevInfo
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
This routine should be called at the end to destroy the printer device
|
|
info list
|
|
|
|
Arguments:
|
|
hDevInfo : Handle to the printer class device information list
|
|
|
|
Return Value:
|
|
TRUE on success, FALSE on error
|
|
|
|
--*/
|
|
{
|
|
// Cleanup and CDM Context created by windows update.
|
|
DestroyCodedownload( gpCodeDownLoadInfo );
|
|
gpCodeDownLoadInfo = NULL;
|
|
|
|
return DestroyOnlyPrinterDeviceInfoList(hDevInfo);
|
|
}
|
|
|
|
|
|
HDEVINFO
|
|
CreatePrinterDeviceInfoList(
|
|
IN HWND hwnd
|
|
)
|
|
{
|
|
return SetupDiCreateDeviceInfoList((LPGUID)&GUID_DEVCLASS_PRINTER, hwnd);
|
|
}
|
|
|
|
|
|
HDEVINFO
|
|
PSetupCreatePrinterDeviceInfoList(
|
|
IN HWND hwnd
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
This routine should be called at the beginning to do the initialization
|
|
It returns a handle which will be used on any subsequent calls to the
|
|
driver setup routines.
|
|
|
|
Arguments:
|
|
None
|
|
|
|
Return Value:
|
|
On success a handle to an empty printer device information set.
|
|
|
|
If the function fails INVALID_HANDLE_VALUE is returned
|
|
|
|
--*/
|
|
{
|
|
HDEVINFO hDevInfo;
|
|
|
|
hDevInfo = SetupDiCreateDeviceInfoList((LPGUID)&GUID_DEVCLASS_PRINTER, hwnd);
|
|
|
|
if ( hDevInfo != INVALID_HANDLE_VALUE ) {
|
|
|
|
if ( !SetSelectDevParams(hDevInfo, NULL, FALSE, NULL) ||
|
|
!SetDevInstallParams(hDevInfo, NULL, NULL) ) {
|
|
|
|
DestroyOnlyPrinterDeviceInfoList(hDevInfo);
|
|
hDevInfo = INVALID_HANDLE_VALUE;
|
|
}
|
|
}
|
|
|
|
return hDevInfo;
|
|
}
|
|
|
|
|
|
HPROPSHEETPAGE
|
|
PSetupCreateDrvSetupPage(
|
|
IN HDEVINFO hDevInfo,
|
|
IN HWND hwnd
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Returns the print driver selection property page
|
|
|
|
Arguments:
|
|
hDevInfo : Handle to the printer class device information list
|
|
hwnd : Window handle that owns the UI
|
|
|
|
Return Value:
|
|
Handle to the property page, NULL on failure -- use GetLastError()
|
|
|
|
--*/
|
|
{
|
|
SP_INSTALLWIZARD_DATA InstallWizardData;
|
|
|
|
ZeroMemory(&InstallWizardData, sizeof(InstallWizardData));
|
|
InstallWizardData.ClassInstallHeader.cbSize
|
|
= sizeof(InstallWizardData.ClassInstallHeader);
|
|
InstallWizardData.ClassInstallHeader.InstallFunction
|
|
= DIF_INSTALLWIZARD;
|
|
|
|
InstallWizardData.DynamicPageFlags = DYNAWIZ_FLAG_PAGESADDED;
|
|
InstallWizardData.hwndWizardDlg = hwnd;
|
|
|
|
return SetupDiGetWizardPage(hDevInfo,
|
|
NULL,
|
|
&InstallWizardData,
|
|
SPWPT_SELECTDEVICE,
|
|
0);
|
|
}
|
|
PPSETUP_LOCAL_DATA
|
|
BuildInternalData(
|
|
IN HDEVINFO hDevInfo,
|
|
IN PSP_DEVINFO_DATA pSpDevInfoData
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Fills out the selected driver info in the SELECTED_DRV_INFO structure
|
|
|
|
Arguments:
|
|
hDevInfo : Handle to the printer class device information list
|
|
pSpDevInfoData : Gives the selected device info element.
|
|
|
|
Return Value:
|
|
On success a non-NULL pointer to PSETUP_LOCAL_DATA struct
|
|
NULL on error
|
|
|
|
--*/
|
|
{
|
|
PSP_DRVINFO_DETAIL_DATA pDrvInfoDetailData;
|
|
PSP_DRVINSTALL_PARAMS pDrvInstallParams;
|
|
PPSETUP_LOCAL_DATA pLocalData;
|
|
PSELECTED_DRV_INFO pDrvInfo;
|
|
SP_DRVINFO_DATA DrvInfoData;
|
|
DWORD dwNeeded;
|
|
BOOL bRet = FALSE;
|
|
|
|
pLocalData = (PPSETUP_LOCAL_DATA) LocalAllocMem(sizeof(*pLocalData));
|
|
pDrvInfoDetailData = (PSP_DRVINFO_DETAIL_DATA)
|
|
LocalAllocMem(sizeof(*pDrvInfoDetailData));
|
|
pDrvInstallParams = (PSP_DRVINSTALL_PARAMS) LocalAllocMem(sizeof(*pDrvInstallParams));
|
|
|
|
if ( !pLocalData || !pDrvInstallParams || !pDrvInfoDetailData )
|
|
goto Cleanup;
|
|
|
|
pDrvInfo = &pLocalData->DrvInfo;
|
|
pLocalData->DrvInfo.pDevInfoData = pSpDevInfoData;
|
|
pLocalData->signature = PSETUP_SIGNATURE;
|
|
|
|
DrvInfoData.cbSize = sizeof(DrvInfoData);
|
|
if ( !SetupDiGetSelectedDriver(hDevInfo, pSpDevInfoData, &DrvInfoData) )
|
|
goto Cleanup;
|
|
|
|
// Need to Check the flag in the DrvInstallParms
|
|
pDrvInstallParams->cbSize = sizeof(*pDrvInstallParams);
|
|
if ( !SetupDiGetDriverInstallParams(hDevInfo,
|
|
pSpDevInfoData,
|
|
&DrvInfoData,
|
|
pDrvInstallParams) ) {
|
|
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Did the user press the "Web" button
|
|
//
|
|
if ( pDrvInstallParams->Flags & DNF_INET_DRIVER )
|
|
pDrvInfo->Flags |= SDFLAG_CDM_DRIVER;
|
|
|
|
LocalFreeMem(pDrvInstallParams);
|
|
pDrvInstallParams = NULL;
|
|
|
|
dwNeeded = sizeof(*pDrvInfoDetailData);
|
|
pDrvInfoDetailData->cbSize = dwNeeded;
|
|
|
|
if ( !SetupDiGetDriverInfoDetail(hDevInfo,
|
|
pSpDevInfoData,
|
|
&DrvInfoData,
|
|
pDrvInfoDetailData,
|
|
dwNeeded,
|
|
&dwNeeded) ) {
|
|
|
|
if ( GetLastError() != ERROR_INSUFFICIENT_BUFFER ) {
|
|
|
|
goto Cleanup;
|
|
}
|
|
|
|
LocalFreeMem(pDrvInfoDetailData);
|
|
pDrvInfoDetailData = (PSP_DRVINFO_DETAIL_DATA) LocalAllocMem(dwNeeded);
|
|
|
|
if ( !pDrvInfoDetailData )
|
|
goto Cleanup;
|
|
|
|
pDrvInfoDetailData->cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
|
|
|
|
if ( !SetupDiGetDriverInfoDetail(hDevInfo,
|
|
pSpDevInfoData,
|
|
&DrvInfoData,
|
|
pDrvInfoDetailData,
|
|
dwNeeded,
|
|
NULL) ) {
|
|
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
pDrvInfo->pszInfName = AllocStr(pDrvInfoDetailData->InfFileName);
|
|
pDrvInfo->pszDriverSection = AllocStr(pDrvInfoDetailData->SectionName);
|
|
pDrvInfo->pszModelName = AllocStr(DrvInfoData.Description);
|
|
pDrvInfo->pszManufacturer = AllocStr(DrvInfoData.MfgName);
|
|
pDrvInfo->pszProvider = AllocStr(DrvInfoData.ProviderName);
|
|
pDrvInfo->ftDriverDate = DrvInfoData.DriverDate;
|
|
pDrvInfo->dwlDriverVersion = DrvInfoData.DriverVersion;
|
|
|
|
if ( pDrvInfoDetailData->HardwareID && *pDrvInfoDetailData->HardwareID ) {
|
|
|
|
pDrvInfo->pszHardwareID = AllocStr(pDrvInfoDetailData->HardwareID);
|
|
if(!pDrvInfo->pszHardwareID)
|
|
goto Cleanup;
|
|
}
|
|
|
|
bRet = pDrvInfo->pszInfName &&
|
|
pDrvInfo->pszDriverSection &&
|
|
pDrvInfo->pszModelName &&
|
|
pDrvInfo->pszProvider &&
|
|
pDrvInfo->pszManufacturer;
|
|
|
|
Cleanup:
|
|
LocalFreeMem(pDrvInfoDetailData);
|
|
LocalFreeMem(pDrvInstallParams);
|
|
|
|
if ( bRet ) {
|
|
return pLocalData;
|
|
} else {
|
|
|
|
//
|
|
// On failure we will leave the old private local data around
|
|
//
|
|
DestroyLocalData(pLocalData);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
|
|
PPSETUP_LOCAL_DATA
|
|
PSetupGetSelectedDriverInfo(
|
|
IN HDEVINFO hDevInfo
|
|
)
|
|
{
|
|
return BuildInternalData(hDevInfo, NULL);
|
|
}
|
|
|
|
|
|
#if 0
|
|
DWORD GetDriverNumber (HDEVINFO hDevInfo)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine returns the number of drivers in a particular INF file
|
|
|
|
Arguments:
|
|
|
|
hDevInfo : Handle got by calling PSetupCreateDrvSetupParams
|
|
|
|
Return Value:
|
|
Number of drivers (from 1 if no error happens)
|
|
|
|
++*/
|
|
{
|
|
SP_DRVINFO_DATA DrvInfoData;
|
|
DWORD dwLast = 0;
|
|
DWORD dwMiddle;
|
|
DWORD dwLastFailed = 10;
|
|
|
|
DrvInfoData.cbSize = sizeof (DrvInfoData);
|
|
|
|
// Expand the number
|
|
while (SetupDiEnumDriverInfo (hDevInfo, NULL,SPDIT_CLASSDRIVER,
|
|
dwLastFailed, &DrvInfoData)) {
|
|
dwLast = dwLastFailed;
|
|
dwLastFailed *= 2;
|
|
}
|
|
|
|
if (GetLastError() == ERROR_NO_MORE_ITEMS) {
|
|
// We've got an boundary, the number is between dwLast and dwLastFailed
|
|
|
|
while (dwLastFailed - dwLast > 1) {
|
|
dwMiddle = (dwLastFailed + dwLast) / 2;
|
|
if (!SetupDiEnumDriverInfo (hDevInfo, NULL,SPDIT_CLASSDRIVER,
|
|
dwMiddle, &DrvInfoData)) {
|
|
if (GetLastError() == ERROR_NO_MORE_ITEMS)
|
|
dwLastFailed = dwMiddle;
|
|
else
|
|
// Some other errors. Ignore them by assuming the driver number is 0
|
|
return 0;
|
|
}
|
|
else dwLast = dwMiddle;
|
|
}
|
|
return dwLast + 1;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
BOOL
|
|
IsSubSet (
|
|
IN HDEVINFO hDevInfoA,
|
|
IN HDEVINFO hDevInfoB
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine checks if the driver list in hDevInfoA is a subset of
|
|
the driver list in hDevInfoB
|
|
|
|
Arguments:
|
|
|
|
hDevInfoA : The handle of the driver list A
|
|
hDevInfoB : The handle of the driver list B
|
|
|
|
Return Value:
|
|
TRUE if A is a subset of B, FALSE else
|
|
|
|
++*/
|
|
|
|
{
|
|
SP_DRVINFO_DATA DrvInfoDataA;
|
|
SP_DRVINFO_DATA DrvInfoDataB;
|
|
DWORD j,k;
|
|
DWORD lastUnmatched;
|
|
BOOL found;
|
|
BOOL bRet = FALSE;
|
|
BOOL bSameMfgName;
|
|
|
|
DrvInfoDataA.cbSize = sizeof (DrvInfoDataA);
|
|
DrvInfoDataB.cbSize = sizeof (DrvInfoDataB);
|
|
|
|
j = 0;
|
|
lastUnmatched = 0;
|
|
|
|
// Get a set of driver data
|
|
while (bRet = SetupDiEnumDriverInfo (hDevInfoA, NULL,
|
|
SPDIT_CLASSDRIVER, j, &DrvInfoDataA)) {
|
|
//Compare the old one with the new driver set to see if it is in the set
|
|
|
|
k = lastUnmatched;
|
|
found = FALSE;
|
|
bSameMfgName = FALSE;
|
|
|
|
while (SetupDiEnumDriverInfo (hDevInfoB, NULL, SPDIT_CLASSDRIVER, k,
|
|
&DrvInfoDataB) && !found) {
|
|
|
|
if (lstrcmpi (DrvInfoDataA.MfgName, DrvInfoDataB.MfgName)) {
|
|
if (bSameMfgName) {
|
|
// This means, we've scanned all the entries with the
|
|
// same manufacture name, but none of them matches
|
|
// So the list A contains an entry which the list B
|
|
// does not. Stop,
|
|
return FALSE;
|
|
}
|
|
// Different Manufacture name, never visit it again
|
|
k++;
|
|
lastUnmatched = k;
|
|
}
|
|
else {
|
|
bSameMfgName = TRUE; // Set the flag
|
|
|
|
// Manufacture matched
|
|
if (DrvInfoDataB.DriverType == DrvInfoDataA.DriverType &&
|
|
!lstrcmpi (DrvInfoDataB.Description, DrvInfoDataA.Description)) {
|
|
found = TRUE;
|
|
// A match
|
|
if (lastUnmatched == k) { // Continuous match
|
|
k++;
|
|
lastUnmatched = k;
|
|
}
|
|
else {
|
|
// It is a match, but some models in the new list is not on the
|
|
// old list
|
|
// Don't update lastUnmatched, because we've to revisit it again.
|
|
k++;
|
|
}
|
|
}
|
|
else { // does not match
|
|
k++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Can not delete the existing driver, quit the loop
|
|
if (!found) return FALSE;
|
|
|
|
// Otherwise, check the next existing driver in the list A
|
|
j++;
|
|
}
|
|
|
|
if (GetLastError() == ERROR_NO_MORE_ITEMS)
|
|
// All the drivers in the list A have been found in list B
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
CopyOEMInfFileAndGiveUniqueName(
|
|
IN HDEVINFO hDevInfo,
|
|
IN PSP_DEVINFO_DATA pSpDevInfoData,
|
|
IN LPTSTR pszInfFile
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine checks if an OEM driver list is a subset of the driver
|
|
to be installed and if so
|
|
copies the OEM printer inf file to "<systemroot>\Inf\OEM<n>.INF".
|
|
Where n is the first unused file number.
|
|
|
|
|
|
Arguments:
|
|
|
|
hDevInfo : Handle got by calling PSetupCreateDrvSetupParams
|
|
pszInfFile : Fully qualified path of OEM inf file
|
|
|
|
Return Value:
|
|
TRUE if no error, FALSE else
|
|
|
|
++*/
|
|
{
|
|
HANDLE hFile = INVALID_HANDLE_VALUE;
|
|
TCHAR szNewFileName[MAX_PATH];
|
|
TCHAR szSystemDir[MAX_PATH];
|
|
DWORD i,j;
|
|
BOOL bRet = FALSE;
|
|
SP_DRVINFO_DATA DrvInfoData;
|
|
DWORD dwNeeded;
|
|
PSP_INF_INFORMATION pSpInfInfo = NULL;
|
|
LPTSTR pszProviderName = NULL;
|
|
LPTSTR pszNewProvider = NULL;
|
|
LPTSTR pszInfFullName = NULL;
|
|
LPTSTR pszInfName = NULL;
|
|
HDEVINFO hOldDevInfo = INVALID_HANDLE_VALUE;
|
|
SP_DEVINSTALL_PARAMS DevInstallParams;
|
|
DWORD dwNumNewDrivers;
|
|
DWORD dwNumOldDrivers;
|
|
DWORD dwLen;
|
|
WIN32_FIND_DATA FindData;
|
|
HANDLE hFindFile = INVALID_HANDLE_VALUE;
|
|
HANDLE hInfFile = INVALID_HANDLE_VALUE;
|
|
UINT uErrorLine;
|
|
DWORD dwInfNeeded = 2048;
|
|
// Since to get file list takes long time,
|
|
// so we try to use the previous values to
|
|
// Allocate the memeory first.
|
|
|
|
DevInstallParams.cbSize = sizeof(DevInstallParams);
|
|
DevInstallParams.DriverPath[0] = 0;
|
|
DrvInfoData.cbSize = sizeof (DrvInfoData);
|
|
|
|
//
|
|
// Check DeviceInstallParams to see if OEM driver list is built
|
|
//
|
|
if ( !SetupDiGetDeviceInstallParams(hDevInfo,
|
|
pSpDevInfoData,
|
|
&DevInstallParams) )
|
|
return FALSE;
|
|
|
|
|
|
// If DriverPath is clear then not an OEM driver
|
|
if ( !DevInstallParams.DriverPath[0] ) {
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
if (!GetSystemDirectory(szSystemDir, SIZECHARS (szSystemDir)))
|
|
return FALSE;
|
|
|
|
dwLen = lstrlen (szSystemDir);
|
|
|
|
// 2 mean equal. If pszInfFile is in the system directory, don't copy it
|
|
if (2 == CompareString(LOCALE_SYSTEM_DEFAULT,
|
|
NORM_IGNORECASE,
|
|
szSystemDir,
|
|
dwLen,
|
|
pszInfFile,
|
|
dwLen))
|
|
return TRUE;
|
|
|
|
|
|
if ( !GetWindowsDirectory(szSystemDir,SIZECHARS(szSystemDir)))
|
|
goto Cleanup;
|
|
|
|
|
|
// Check to see if there is any existing .INF files which are subsets of the
|
|
// new driver to be installed
|
|
if (! PSetupBuildDriversFromPath(hDevInfo, pszInfFile, TRUE)) goto Cleanup;
|
|
|
|
dwNumNewDrivers = GetDriverNumber (hDevInfo);
|
|
|
|
// Get a set of driver data
|
|
if (!SetupDiEnumDriverInfo (hDevInfo, NULL, SPDIT_CLASSDRIVER, 0, &DrvInfoData))
|
|
goto Cleanup;
|
|
|
|
if (! (pszNewProvider = AllocStr (DrvInfoData.ProviderName))) goto Cleanup;
|
|
|
|
|
|
// Allocate enough memeory for the full path
|
|
if (! (pszInfFullName = LocalAllocMem ((lstrlen (szSystemDir) + lstrlen (cszINF)
|
|
+ MAX_PATH + 1) * sizeof (TCHAR))))
|
|
goto Cleanup;
|
|
|
|
lstrcpy (pszInfFullName, szSystemDir);
|
|
lstrcat (pszInfFullName, cszINF);
|
|
|
|
// pszInfName always points to the begining of the name
|
|
pszInfName = pszInfFullName + lstrlen (pszInfFullName);
|
|
lstrcpy (pszInfName, cszInfWildCard);
|
|
|
|
hFindFile = FindFirstFile (pszInfFullName, &FindData);
|
|
if (hFindFile != INVALID_HANDLE_VALUE) {
|
|
|
|
do {
|
|
//
|
|
// Skip directories
|
|
//
|
|
if(FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
|
continue;
|
|
}
|
|
|
|
// We've got a name
|
|
lstrcpy (pszInfName, FindData.cFileName);
|
|
|
|
hInfFile = SetupOpenInfFile(pszInfFullName,
|
|
cszPrinter,
|
|
INF_STYLE_WIN4 | INF_STYLE_OLDNT,
|
|
&uErrorLine);
|
|
if (hInfFile == INVALID_HANDLE_VALUE)
|
|
continue;
|
|
|
|
// We've opened a file which has a printer as the class name
|
|
|
|
if (! (pSpInfInfo = LocalAllocMem (dwInfNeeded * sizeof (TCHAR)))) goto NextFile;
|
|
|
|
// use dwNeeded so that dwInfNeeded is modified only when the buffer is insufficient
|
|
dwNeeded = dwInfNeeded;
|
|
if (!SetupGetInfInformation (hInfFile, INFINFO_INF_SPEC_IS_HINF, pSpInfInfo,
|
|
dwInfNeeded, &dwNeeded)) {
|
|
if (ERROR_INSUFFICIENT_BUFFER == GetLastError ()) {
|
|
LocalFree (pSpInfInfo);
|
|
if (! (pSpInfInfo = LocalAllocMem (dwNeeded * sizeof (TCHAR)))) goto NextFile;
|
|
dwInfNeeded = dwNeeded;
|
|
|
|
if (!SetupGetInfInformation (hInfFile, INFINFO_INF_SPEC_IS_HINF,
|
|
pSpInfInfo, dwInfNeeded, &dwNeeded))
|
|
goto NextFile;
|
|
}
|
|
else goto NextFile;
|
|
|
|
}
|
|
|
|
if (! (pszProviderName = GetInfQueryString(pSpInfInfo, cszProvider)))
|
|
goto NextFile;
|
|
|
|
if (!lstrcmpi (pszNewProvider, pszProviderName)) {
|
|
// If both INF files are from the same provider, try to check if it can be deleted
|
|
|
|
if ((hOldDevInfo = SetupDiCreateDeviceInfoList(
|
|
(LPGUID)&GUID_DEVCLASS_PRINTER, NULL)) == INVALID_HANDLE_VALUE)
|
|
goto NextFile;
|
|
|
|
if (! PSetupBuildDriversFromPath(hOldDevInfo, pszInfFullName, TRUE))
|
|
goto NextFile;
|
|
|
|
dwNumOldDrivers = GetDriverNumber (hOldDevInfo);
|
|
|
|
// It is not possible to be a subset of the new one
|
|
if (dwNumOldDrivers >= dwNumNewDrivers) {
|
|
if (IsSubSet (hDevInfo, hOldDevInfo)) {
|
|
// No need to copy the new one
|
|
bRet = TRUE;
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
if (dwNumOldDrivers <= dwNumNewDrivers) {
|
|
if (IsSubSet (hOldDevInfo, hDevInfo)) {
|
|
// All the drivers in the current file have been found in the new
|
|
// driver file, delete the old file
|
|
DeleteFile (pszInfFullName);
|
|
// and its corresponding .PNF file
|
|
lstrcpyn (pszInfName + lstrlen (pszInfName) - 3, cszPNF, 4);
|
|
DeleteFile (pszInfFullName);
|
|
}
|
|
}
|
|
|
|
// Else Close the file and continue on the next one
|
|
} // End of provider name comparison
|
|
|
|
|
|
NextFile:
|
|
if (hInfFile != INVALID_HANDLE_VALUE) {
|
|
SetupCloseInfFile (hInfFile);
|
|
hInfFile = INVALID_HANDLE_VALUE;
|
|
}
|
|
if (hOldDevInfo != INVALID_HANDLE_VALUE) {
|
|
SetupDiDestroyDeviceInfoList (hOldDevInfo);
|
|
hOldDevInfo = INVALID_HANDLE_VALUE;
|
|
}
|
|
if (hFile != INVALID_HANDLE_VALUE) {
|
|
CloseHandle (hFile);
|
|
hFile = INVALID_HANDLE_VALUE;
|
|
}
|
|
// Clear the pointers so that the clean up won't free them again
|
|
LocalFreeMem (pSpInfInfo);
|
|
pSpInfInfo = NULL;
|
|
|
|
} // End of the loop
|
|
while (FindNextFile(hFindFile,&FindData));
|
|
}
|
|
|
|
// All the duplicate files are deleted. Let's create a new one
|
|
|
|
for ( i = 0 ; i < 10000 ; ++i ) {
|
|
|
|
wsprintf(szNewFileName, cszOEMInfGen, szSystemDir, i);
|
|
|
|
//
|
|
// By using the CREATE_NEW flag we reserve the file name and
|
|
// will not end up overwriting another file which gets created
|
|
// by another setup (some inf) thread
|
|
//
|
|
hFile = CreateFile(szNewFileName,
|
|
0,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
CREATE_NEW,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
|
|
if ( hFile != INVALID_HANDLE_VALUE ) {
|
|
CloseHandle(hFile);
|
|
hFile = INVALID_HANDLE_VALUE;
|
|
|
|
bRet = CopyFile(pszInfFile, szNewFileName, FALSE);
|
|
goto Cleanup;
|
|
}
|
|
else if ( GetLastError() != ERROR_FILE_EXISTS )
|
|
break;
|
|
}
|
|
|
|
Cleanup:
|
|
if (hFindFile != INVALID_HANDLE_VALUE)
|
|
FindClose (hFindFile);
|
|
if (hInfFile != INVALID_HANDLE_VALUE)
|
|
SetupCloseInfFile (hInfFile);
|
|
if (hOldDevInfo != INVALID_HANDLE_VALUE)
|
|
SetupDiDestroyDeviceInfoList (hOldDevInfo);
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
|
CloseHandle (hFile);
|
|
LocalFreeMem (pszInfFullName);
|
|
LocalFreeMem (pszNewProvider);
|
|
LocalFreeMem (pszProviderName);
|
|
LocalFreeMem (pSpInfInfo);
|
|
return bRet;
|
|
}
|
|
#endif
|
|
|
|
|
|
BOOL
|
|
PSetupSelectDriver(
|
|
IN HDEVINFO hDevInfo
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Display manufacturer/model information and have the user select a
|
|
printer driver. Selected driver is remembered and PSetupGetSelectedDriver
|
|
call will give the selected driver.
|
|
|
|
Arguments:
|
|
hDevInfo - Handle to the printer class device information list
|
|
|
|
Return Value:
|
|
TRUE on success, FALSE on error
|
|
|
|
--*/
|
|
{
|
|
|
|
return BuildClassDriverList(hDevInfo) &&
|
|
SetupDiSelectDevice(hDevInfo, NULL);
|
|
}
|
|
|
|
VOID
|
|
GetDriverPath(
|
|
IN HDEVINFO hDevInfo,
|
|
IN PPSETUP_LOCAL_DATA pLocalData,
|
|
OUT TCHAR szDriverPath[MAX_PATH]
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Gets the path where driver files should be searched first to copy from
|
|
|
|
Arguments:
|
|
pszDriverPath : Pointer to a buffer of MAX_PATH size. Gives path where
|
|
system was installed from
|
|
|
|
Return Value:
|
|
Nothing
|
|
|
|
--*/
|
|
{
|
|
BOOL bOemDriver = FALSE;
|
|
LPTSTR *List, psz;
|
|
DWORD dwCount;
|
|
LPTSTR pszTempPath = NULL;
|
|
|
|
//
|
|
// For OEM drivers look at the place where the inf came from, else
|
|
// look at the place we installed NT from
|
|
//
|
|
if ( pLocalData &&
|
|
!(IsSystemNTPrintInf(pLocalData->DrvInfo.pszInfName) || (pLocalData->DrvInfo.Flags & SDFLAG_CDM_DRIVER ))) {
|
|
|
|
lstrcpy(szDriverPath, pLocalData->DrvInfo.pszInfName);
|
|
if ( psz = FileNamePart(szDriverPath) ) {
|
|
|
|
*psz = TEXT('\0');
|
|
return;
|
|
}
|
|
}
|
|
|
|
pszTempPath = GetSystemInstallPath();
|
|
if ( pszTempPath != NULL )
|
|
{
|
|
lstrcpy(szDriverPath, pszTempPath);
|
|
LocalFreeMem(pszTempPath);
|
|
}
|
|
else
|
|
// Default put A:\ since we have to give something to setup
|
|
lstrcpy(szDriverPath, TEXT("A:\\"));
|
|
}
|
|
|
|
BOOL
|
|
BuildClassDriverList(
|
|
IN HDEVINFO hDevInfo
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Build the class driver list.
|
|
|
|
Note: If driver list is already built this comes back immediately
|
|
|
|
Arguments:
|
|
hDevInfo : Handle to the printer class device information list
|
|
|
|
Return Value:
|
|
TRUE on success, FALSE on error
|
|
|
|
--*/
|
|
{
|
|
DWORD dwLastError;
|
|
SP_DRVINFO_DATA DrvInfoData;
|
|
//
|
|
// Build the class driver list and also make sure there is atleast one driver
|
|
//
|
|
if ( !SetupDiBuildDriverInfoList(hDevInfo, NULL, SPDIT_CLASSDRIVER) )
|
|
return FALSE;
|
|
|
|
DrvInfoData.cbSize = sizeof(DrvInfoData);
|
|
|
|
if ( !SetupDiEnumDriverInfo(hDevInfo,
|
|
NULL,
|
|
SPDIT_CLASSDRIVER,
|
|
0,
|
|
&DrvInfoData) &&
|
|
GetLastError() == ERROR_NO_MORE_ITEMS ) {
|
|
|
|
SetLastError(SPAPI_E_DI_BAD_PATH);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
PSetupRefreshDriverList(
|
|
IN HDEVINFO hDevInfo
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Destroy current driver list and build new one if currently an OEM driver
|
|
list is associated. This way if you go back after choosing HaveDisk you
|
|
would still see drivers from inf directory instead of the OEM inf ...
|
|
|
|
Arguments:
|
|
hDevInfo : Handle to the printer class device information list
|
|
|
|
Return Value:
|
|
TRUE on success, FALSE on error
|
|
|
|
--*/
|
|
{
|
|
SP_DEVINSTALL_PARAMS DevInstallParams = { 0 };
|
|
|
|
DevInstallParams.cbSize = sizeof(DevInstallParams);
|
|
|
|
//
|
|
// Check DeviceInstallParams to see if OEM driver list is built
|
|
//
|
|
if ( SetupDiGetDeviceInstallParams(hDevInfo,
|
|
NULL,
|
|
&DevInstallParams) &&
|
|
!DevInstallParams.DriverPath[0] ) {
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Destroy current list and build another one
|
|
//
|
|
SetupDiDestroyDriverInfoList(hDevInfo,
|
|
NULL,
|
|
SPDIT_CLASSDRIVER);
|
|
|
|
DevInstallParams.DriverPath[0] = sZero;
|
|
|
|
return SetupDiSetDeviceInstallParams(hDevInfo,
|
|
NULL,
|
|
&DevInstallParams) &&
|
|
|
|
BuildClassDriverList(hDevInfo);
|
|
}
|
|
|
|
BOOL
|
|
IsNTPrintInf(
|
|
IN LPCTSTR pszInfName
|
|
)
|
|
/*
|
|
|
|
Function: IsNTPrintInf
|
|
|
|
Purpose: Verifies is the inf file being copied is a system inf - ntprint.inf.
|
|
|
|
Parameters:
|
|
pszInfName - the fully qualified inf name that is being installed.
|
|
|
|
Notes: This is needed to make the decision of whether to zero or even copy the inf
|
|
with SetupCopyOEMInf.
|
|
Should we be doing a deeper comparison than this to decide?
|
|
|
|
*/
|
|
{
|
|
BOOL bRet = FALSE;
|
|
PTCHAR pFileName = FileNamePart( pszInfName );
|
|
|
|
if( pFileName )
|
|
{
|
|
bRet = ( 0 == lstrcmpi( pFileName, cszNtprintInf ) );
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
BOOL
|
|
IsSystemNTPrintInf(
|
|
IN PCTSTR pszInfName
|
|
)
|
|
/*
|
|
|
|
Function: IsSystemNTPrintInf
|
|
|
|
Purpose: Verifies if the inf file the one system printer inf : %windir\inf\ntprint.inf.
|
|
|
|
Parameters:
|
|
pszInfName - the fully qualified inf name that is being verified.
|
|
|
|
Notes: Needed to decide whether to downrank our inbox drivers
|
|
|
|
*/
|
|
{
|
|
BOOL bRet = FALSE;
|
|
TCHAR szSysInf[MAX_PATH] = {0};
|
|
UINT Len;
|
|
PCTSTR pRelInfPath = _T("inf\\ntprint.inf");
|
|
|
|
Len = GetSystemWindowsDirectory(szSysInf, MAX_PATH);
|
|
|
|
if (
|
|
(Len != 0) &&
|
|
(Len + _tcslen(pRelInfPath) + 2 < MAX_PATH)
|
|
)
|
|
{
|
|
if (szSysInf[Len-1] != _T('\\'))
|
|
{
|
|
szSysInf[Len++] = _T('\\');
|
|
}
|
|
_tcscat(szSysInf, pRelInfPath);
|
|
if (!_tcsicmp(szSysInf, pszInfName))
|
|
{
|
|
bRet = TRUE;
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
BOOL
|
|
PSetupIsOemDriver(
|
|
IN HDEVINFO hDevInfo,
|
|
IN PPSETUP_LOCAL_DATA pLocalData,
|
|
IN PBOOL pbIsOemDriver
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Returns indication if the currently selected driver list
|
|
is an OEM driver list.
|
|
|
|
Arguments:
|
|
hDevInfo : Handle to the printer class device information list
|
|
pLocalData : Gives the selected driver information
|
|
pbIsOemDriver : Pointer to bool where to return OEM driver indicator.
|
|
Set to TRUE if driver is an OEM driver.
|
|
Set to FALSE if driver is not an OEM driver.
|
|
|
|
Return Value:
|
|
TRUE on success, FALSE on error.
|
|
|
|
--*/
|
|
{
|
|
TCHAR szSystemDir[MAX_PATH];
|
|
BOOL bRet = FALSE;
|
|
DWORD dwLen;
|
|
|
|
//
|
|
// Ideally Setup API should have an export for this. But rather than
|
|
// waiting for them to do this let me write the code and get it done with
|
|
//
|
|
if ( pLocalData &&
|
|
( pLocalData->DrvInfo.Flags & SDFLAG_CDM_DRIVER ) )
|
|
{
|
|
*pbIsOemDriver = FALSE;
|
|
bRet = TRUE;
|
|
}
|
|
else if ( dwLen = GetSystemWindowsDirectory(szSystemDir, SIZECHARS(szSystemDir)) )
|
|
{
|
|
bRet = TRUE;
|
|
|
|
//
|
|
// If Inf is not under %windir% then it is OEM
|
|
//
|
|
*pbIsOemDriver = lstrncmpi(pLocalData->DrvInfo.pszInfName,
|
|
szSystemDir,
|
|
dwLen) != 0;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
BOOL
|
|
PSetupPreSelectDriver(
|
|
IN HDEVINFO hDevInfo,
|
|
IN LPCTSTR pszManufacturer,
|
|
IN LPCTSTR pszModel
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Preselect a manufacturer and model for the driver dialog
|
|
|
|
If same model is found select it, else if a manufacturer is given and
|
|
a match in manufacturer is found select first driver for the manufacturer.
|
|
|
|
Arguments:
|
|
hDevInfo : Handle to the printer class device information list
|
|
pszManufacturer : Manufacterer name to preselect
|
|
pszModel : Model name to preselect
|
|
|
|
Return Value:
|
|
TRUE on a model or manufacturer match
|
|
FALSE else
|
|
|
|
--*/
|
|
{
|
|
SP_DRVINFO_DATA DrvInfoData;
|
|
DWORD dwIndex, dwManf, dwMod;
|
|
|
|
if ( !BuildClassDriverList(hDevInfo) ) {
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
dwIndex = 0;
|
|
|
|
//
|
|
// To do only one check later
|
|
//
|
|
if ( pszManufacturer && !*pszManufacturer )
|
|
pszManufacturer = NULL;
|
|
|
|
if ( pszModel && !*pszModel )
|
|
pszModel = NULL;
|
|
|
|
//
|
|
// If no model/manf given select first driver
|
|
//
|
|
if ( pszManufacturer || pszModel ) {
|
|
|
|
dwManf = dwMod = MAX_DWORD;
|
|
DrvInfoData.cbSize = sizeof(DrvInfoData);
|
|
|
|
while ( SetupDiEnumDriverInfo(hDevInfo, NULL, SPDIT_CLASSDRIVER,
|
|
dwIndex, &DrvInfoData) ) {
|
|
|
|
if ( pszManufacturer &&
|
|
dwManf == MAX_DWORD &&
|
|
!lstrcmpi(pszManufacturer, DrvInfoData.MfgName) ) {
|
|
|
|
dwManf = dwIndex;
|
|
}
|
|
|
|
if ( pszModel &&
|
|
!lstrcmpi(pszModel, DrvInfoData.Description) ) {
|
|
|
|
dwMod = dwIndex;
|
|
break; // the for loop
|
|
}
|
|
|
|
DrvInfoData.cbSize = sizeof(DrvInfoData);
|
|
++dwIndex;
|
|
}
|
|
|
|
if ( dwMod != MAX_DWORD ) {
|
|
|
|
dwIndex = dwMod;
|
|
} else if ( dwManf != MAX_DWORD ) {
|
|
|
|
dwIndex = dwManf;
|
|
} else {
|
|
|
|
SetLastError(ERROR_UNKNOWN_PRINTER_DRIVER);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
DrvInfoData.cbSize = sizeof(DrvInfoData);
|
|
if ( SetupDiEnumDriverInfo(hDevInfo, NULL, SPDIT_CLASSDRIVER,
|
|
dwIndex, &DrvInfoData) &&
|
|
SetupDiSetSelectedDriver(hDevInfo, NULL, &DrvInfoData) ) {
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
PPSETUP_LOCAL_DATA
|
|
PSetupDriverInfoFromName(
|
|
IN HDEVINFO hDevInfo,
|
|
IN LPCTSTR pszModel
|
|
)
|
|
{
|
|
return PSetupPreSelectDriver(hDevInfo, NULL, pszModel) ?
|
|
BuildInternalData(hDevInfo, NULL) :
|
|
NULL;
|
|
}
|
|
|
|
|
|
LPDRIVER_INFO_6
|
|
Win95DriverInfo6FromName(
|
|
IN HDEVINFO hDevInfo,
|
|
IN PPSETUP_LOCAL_DATA* ppLocalData,
|
|
IN LPCTSTR pszModel,
|
|
IN LPCTSTR pszzPreviousNames
|
|
)
|
|
{
|
|
LPDRIVER_INFO_6 pDriverInfo6=NULL;
|
|
PPSETUP_LOCAL_DATA pLocalData;
|
|
BOOL bFound;
|
|
LPCTSTR pszName;
|
|
|
|
bFound = PSetupPreSelectDriver(hDevInfo, NULL, pszModel);
|
|
for ( pszName = pszzPreviousNames ;
|
|
!bFound && pszName && *pszName ;
|
|
pszName += lstrlen(pszName) + 1 ) {
|
|
|
|
bFound = PSetupPreSelectDriver(hDevInfo, NULL, pszName);
|
|
}
|
|
|
|
if ( !bFound )
|
|
return NULL;
|
|
|
|
if ( (pLocalData = BuildInternalData(hDevInfo, NULL)) &&
|
|
ParseInf(hDevInfo, pLocalData, PlatformWin95, NULL, 0) ) {
|
|
|
|
pDriverInfo6 = CloneDriverInfo6(&pLocalData->InfInfo.DriverInfo6,
|
|
pLocalData->InfInfo.cbDriverInfo6);
|
|
*ppLocalData = pLocalData;
|
|
}
|
|
|
|
if (!pDriverInfo6 && pLocalData)
|
|
{
|
|
DestroyLocalData(pLocalData);
|
|
*ppLocalData = NULL;
|
|
}
|
|
|
|
return pDriverInfo6;
|
|
}
|
|
|
|
|
|
BOOL
|
|
PSetupDestroySelectedDriverInfo(
|
|
IN PPSETUP_LOCAL_DATA pLocalData
|
|
)
|
|
{
|
|
ASSERT(pLocalData && pLocalData->signature == PSETUP_SIGNATURE);
|
|
DestroyLocalData(pLocalData);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
PSetupGetDriverInfForPrinter(
|
|
IN HDEVINFO hDevInfo,
|
|
IN LPCTSTR pszPrinterName,
|
|
IN OUT LPTSTR pszInfName,
|
|
IN OUT LPDWORD pcbInfNameSize
|
|
)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
DWORD dwSize, dwIndex;
|
|
HANDLE hPrinter;
|
|
LPTSTR pszInf;
|
|
PPSETUP_LOCAL_DATA pLocalData = NULL;
|
|
LPDRIVER_INFO_6 pDriverInfo6 = NULL;
|
|
SP_DRVINFO_DATA DrvInfoData;
|
|
|
|
|
|
if ( !OpenPrinter((LPTSTR)pszPrinterName, &hPrinter, NULL) )
|
|
return FALSE;
|
|
|
|
if ( !BuildClassDriverList(hDevInfo) )
|
|
goto Cleanup;
|
|
|
|
GetPrinterDriver(hPrinter,
|
|
NULL,
|
|
6,
|
|
NULL,
|
|
0,
|
|
&dwSize);
|
|
|
|
if ( GetLastError() != ERROR_INSUFFICIENT_BUFFER )
|
|
goto Cleanup;
|
|
|
|
if ( !((LPBYTE)pDriverInfo6 = LocalAllocMem(dwSize)) ||
|
|
!GetPrinterDriver(hPrinter,
|
|
NULL,
|
|
6,
|
|
(LPBYTE)pDriverInfo6,
|
|
dwSize,
|
|
&dwSize) ) {
|
|
|
|
goto Cleanup;
|
|
}
|
|
|
|
dwIndex = 0;
|
|
|
|
DrvInfoData.cbSize = sizeof(DrvInfoData);
|
|
|
|
while ( SetupDiEnumDriverInfo(hDevInfo, NULL, SPDIT_CLASSDRIVER,
|
|
dwIndex, &DrvInfoData) ) {
|
|
|
|
//
|
|
// Is the driver name same?
|
|
//
|
|
if ( !lstrcmpi(pDriverInfo6->pName, DrvInfoData.Description) ) {
|
|
|
|
if ( !SetupDiSetSelectedDriver(hDevInfo, NULL, &DrvInfoData) ||
|
|
!(pLocalData = BuildInternalData(hDevInfo, NULL)) ||
|
|
!ParseInf(hDevInfo, pLocalData, MyPlatform, NULL, 0) ) {
|
|
|
|
if ( pLocalData ) {
|
|
|
|
DestroyLocalData(pLocalData);
|
|
pLocalData = NULL;
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Are the DRIVER_INFO_6's identical?
|
|
//
|
|
if ( IdenticalDriverInfo6(&pLocalData->InfInfo.DriverInfo6,
|
|
pDriverInfo6) )
|
|
break;
|
|
|
|
DestroyLocalData(pLocalData);
|
|
pLocalData = NULL;
|
|
}
|
|
|
|
DrvInfoData.cbSize = sizeof(DrvInfoData);
|
|
++dwIndex;
|
|
}
|
|
|
|
if ( pLocalData == NULL ) {
|
|
|
|
SetLastError(ERROR_UNKNOWN_PRINTER_DRIVER);
|
|
goto Cleanup;
|
|
}
|
|
|
|
pszInf= pLocalData->DrvInfo.pszInfName;
|
|
dwSize = *pcbInfNameSize;
|
|
*pcbInfNameSize = (lstrlen(pszInf) + 1) * sizeof(TCHAR);
|
|
|
|
if ( dwSize < *pcbInfNameSize ) {
|
|
|
|
SetLastError(ERROR_INSUFFICIENT_BUFFER);
|
|
goto Cleanup;
|
|
}
|
|
|
|
lstrcpy(pszInfName, pszInf);
|
|
bRet = TRUE;
|
|
|
|
Cleanup:
|
|
ClosePrinter(hPrinter);
|
|
LocalFreeMem(pDriverInfo6);
|
|
DestroyLocalData(pLocalData);
|
|
|
|
return bRet;
|
|
}
|