Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ce47f986d8
NT4/private/windows/spooler/splsetup/util.c

1771 lines
47 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*++
Copyright (c) 1995 Microsoft Corporation
All rights reserved.
Module Name:
Util.c
Abstract:
Driver Setup UI Utility functions
Author:
Muhunthan Sivapragasam (MuhuntS) 06-Sep-1995
Revision History:
--*/
#include "precomp.h"
//
// Keys to search for in ntprint.inf
//
TCHAR cszDataSection[] = TEXT("DataSection");
TCHAR cszDriverFile[] = TEXT("DriverFile");
TCHAR cszConfigFile[] = TEXT("ConfigFile");
TCHAR cszDataFile[] = TEXT("DataFile");
TCHAR cszHelpFile[] = TEXT("HelpFile");
TCHAR cszDefaultDataType[] = TEXT("DefaultDataType");
TCHAR cszLanguageMonitor[] = TEXT("LanguageMonitor");
TCHAR cszCopyFiles[] = TEXT("CopyFiles");
TCHAR cszComma[] = TEXT(",");
TCHAR cszPrinterInf[] = TEXT("printer.inf");
TCHAR cszNtprintInf[] = TEXT("ntprint.inf");
TCHAR sComma = TEXT(',');
TCHAR sHash = TEXT('@');
TCHAR sBackSlash = TEXT('\\');
TCHAR sZero = TEXT('\0');
//
// Native environment name used by spooler
//
PLATFORMINFO PlatformEnv[] = {
{ TEXT("Windows NT Alpha_AXP") },
{ TEXT("Windows NT x86") },
{ TEXT("Windows NT R4000") },
{ TEXT("Windows NT PowerPC") },
{ TEXT("Windows 4.0") }
};
//
// Platform override strings to be used to upgrade non-native architecture
// printer drivers
//
PLATFORMINFO PlatformOverride[] = {
{ TEXT("alpha") },
{ TEXT("i386") },
{ TEXT("mips") },
{ TEXT("ppc") },
{ TEXT("") } // will not be accessed
};
PLATFORM MyPlatform =
#if defined(_ALPHA_)
PlatformAlpha;
#elif defined(_MIPS_)
PlatformMIPS;
#elif defined(_PPC_)
PlatformPPC;
#elif defined(_X86_)
PlatformX86;
#endif
//
// Forward declaration
//
VOID
InfGetDependentFiles(
IN HINF hInf,
IN LPCTSTR pszDriverSection,
IN LPCTSTR pszDataSection,
IN BOOL bDataSection,
OUT LPTSTR *ppszData,
IN OUT LPBOOL pbFail
);
PVOID
AllocMem(
IN UINT cbSize
)
{
return LocalAlloc(LPTR, cbSize);
}
VOID
FreeMem(
IN PVOID p
)
{
LocalFree(p);
}
LPTSTR
AllocStr(
LPCTSTR pszStr
)
/*++
Routine Description:
Allocate memory and make a copy of a string field
Arguments:
pszStr : String to copy
Return Value:
Pointer to the copied string. Memory is allocated.
--*/
{
LPTSTR pszRet = NULL;
if ( pszStr && *pszStr ) {
pszRet = AllocMem((lstrlen(pszStr) + 1) * sizeof(*pszRet));
if ( pszRet )
lstrcpy(pszRet, pszStr);
}
return pszRet;
}
VOID
FreeStr(
LPTSTR pszStr
)
/*++
Routine Description:
Free memory allocated for a string
Arguments:
pszStr : String to free memory
Return Value:
Nothing
--*/
{
if ( pszStr )
FreeMem((PVOID)pszStr);
}
VOID
InfGetString(
IN PINFCONTEXT pInfContext,
IN DWORD dwFieldIndex,
OUT LPTSTR *ppszField,
IN OUT LPBOOL pbFail
)
/*++
Routine Description:
Allocates memory and gets a string field from an Inf file
Arguments:
lpInfContext : Inf context for the line
dwFieldIndex : Index of the field within the specified line
ppszField : Pointer to the field to allocate memory and copy
pbFail : Set on error, could be TRUE when called
Return Value:
Nothing; If *pbFail is not TRUE memory is allocated and the field is copied
--*/
{
TCHAR Buffer[MAX_PATH];
DWORD dwNeeded;
if ( *pbFail )
return;
if ( SetupGetStringField(pInfContext,
dwFieldIndex,
Buffer,
sizeof(Buffer)/sizeof(Buffer[0]),
&dwNeeded) ) {
*ppszField = AllocStr(Buffer);
return;
}
if ( GetLastError() != ERROR_INSUFFICIENT_BUFFER ||
!(*ppszField = AllocMem(dwNeeded*sizeof(Buffer[0]))) ) {
*pbFail = TRUE;
return;
}
if ( !SetupGetStringField(pInfContext,
dwFieldIndex,
*ppszField,
dwNeeded,
&dwNeeded) ) {
*pbFail = TRUE;
}
}
VOID
InfGetMultiSz(
IN PINFCONTEXT pInfContext,
IN DWORD dwFieldIndex,
OUT LPTSTR *ppszField,
IN OUT LPBOOL pbFail
)
/*++
Routine Description:
Allocates memory and gets a multi-sz field from an Inf file
Arguments:
lpInfContext : Inf context for the line
dwFieldIndex : Index of the field within the specified line
ppszField : Pointer to the field to allocate memory and copy
pbFail : Set on error, could be TRUE when called
Return Value:
Nothing; If *pbFail is not TRUE memory is allocated and the field is copied
--*/
{
TCHAR Buffer[MAX_PATH];
DWORD dwNeeded;
if ( *pbFail )
return;
if ( SetupGetMultiSzField(pInfContext,
dwFieldIndex,
Buffer,
sizeof(Buffer)/sizeof(Buffer[0]),
&dwNeeded) ) {
*ppszField = AllocMem(dwNeeded*sizeof(Buffer[0]));
if ( *ppszField )
CopyMemory(*ppszField, Buffer, dwNeeded * sizeof(Buffer[0]));
else
*pbFail = TRUE;
return;
}
if ( GetLastError() != ERROR_INSUFFICIENT_BUFFER ||
!(*ppszField = AllocMem(dwNeeded * sizeof(Buffer[0]))) ) {
*pbFail = TRUE;
return;
}
if ( !SetupGetMultiSzField(pInfContext,
dwFieldIndex,
*ppszField,
dwNeeded,
&dwNeeded) ) {
*pbFail = TRUE;
}
}
VOID
InfGetDriverInfoString(
IN HINF hInf,
IN LPCTSTR pszDriverSection,
IN LPCTSTR pszDataSection, OPTIONAL
IN BOOL bDataSection,
IN LPCTSTR pszKey,
OUT LPTSTR *ppszData,
IN LPCTSTR pszDefaultData,
IN OUT LPBOOL pbFail
)
/*++
Routine Description:
Allocates memory and gets a driver info field from an inf file
Arguments:
hInf : Handle to the Inf file
pszDriverSection : Section name for the driver
pszDataSection : Data section for the driver (optional)
bDataSection : Specifies if there is a data section
pszKey : Key value of the field to look for
*ppszData : Pointer to allocate memory and copy the data field
pszDefaultData : If key found this is the default value, coule be NULL
*pbFail : Set on error, could be TRUE when called
Return Value:
Nothing; If *pbFail is not TRUE memory is allocated and the field is copied
--*/
{
INFCONTEXT InfContext;
if ( *pbFail )
return;
if ( SetupFindFirstLine(hInf, pszDriverSection,
pszKey, &InfContext) ||
(bDataSection && SetupFindFirstLine(hInf,
pszDataSection,
pszKey,
&InfContext)) ) {
InfGetString(&InfContext, 1, ppszData, pbFail);
} else if ( pszDefaultData && *pszDefaultData ) {
if ( !(*ppszData = AllocStr(pszDefaultData)) )
*pbFail = TRUE;
} else
*ppszData = NULL;
}
VOID
PSetupDestroyDriverInfo3(
IN LPDRIVER_INFO_3 pDriverInfo3
)
/*++
Routine Description:
Frees memory allocated for a DRIVER_INFO_3 structure and all the string
fields in it
Arguments:
pDriverInfo3 : Pointer to the DRIVER_INFO_3 structure to free memory
Return Value:
None
--*/
{
if ( pDriverInfo3 ) {
FreeStr(pDriverInfo3->pName);
FreeStr(pDriverInfo3->pDriverPath);
FreeStr(pDriverInfo3->pDataFile);
FreeStr(pDriverInfo3->pConfigFile);
FreeStr(pDriverInfo3->pHelpFile);
FreeStr(pDriverInfo3->pMonitorName);
FreeStr(pDriverInfo3->pDefaultDataType);
if ( pDriverInfo3->pDependentFiles )
FreeMem(pDriverInfo3->pDependentFiles);
FreeMem(pDriverInfo3);
}
}
LPDRIVER_INFO_3
InfGetDriverInfo3(
IN HINF hInf,
IN LPCTSTR pszModelName,
IN LPCTSTR pszDriverSection
)
/*++
Routine Description:
Copies driver information from an Inf file to a DriverInfo3 structure.
The following fields are filled on successful return
pName
pDriverPath
pDataFile
pConfigFile
pHelpFile
pMonitorName
pDefaultDataType
Arguments:
hInf : Handle to the inf file to parse
pszModelName : Selected driver model name
pszDriverSection : Section name for the selected driver model
Return Value:
TRUE -- No error retrieving the driver information. Above mentioned
fields are filled, with memory allocation
FALSE -- Error
--*/
{
PDRIVER_INFO_3 pDriverInfo3;
LPTSTR pszDataSection;
BOOL bFail = FALSE, bDataSection = FALSE;
INFCONTEXT Context;
pszDataSection = NULL;
pDriverInfo3 = (PDRIVER_INFO_3) AllocMem(sizeof(DRIVER_INFO_3));
if ( !pDriverInfo3 ) {
bFail = TRUE;
goto Cleanup;
}
ZeroMemory(pDriverInfo3, sizeof(DRIVER_INFO_3));
pDriverInfo3->pName = AllocStr(pszModelName);
if ( !pDriverInfo3->pName )
bFail = TRUE;
//
// Does the driver section have a data section name specified?
//
if ( SetupFindFirstLine(hInf, pszDriverSection,
cszDataSection, &Context) ) {
InfGetString(&Context, 1, &pszDataSection, &bFail);
bDataSection = TRUE;
}
//
// If DataFile key is not found data file is same as driver section name
//
InfGetDriverInfoString(hInf,
pszDriverSection,
pszDataSection,
bDataSection,
cszDataFile,
&pDriverInfo3->pDataFile,
pszDriverSection,
&bFail);
//
// If DriverFile key is not found driver file is the driver section name
//
InfGetDriverInfoString(hInf,
pszDriverSection,
pszDataSection,
bDataSection,
cszDriverFile,
&pDriverInfo3->pDriverPath,
pszDriverSection,
&bFail);
//
// If ConfigFile key is not found config file is same as driver file
//
InfGetDriverInfoString(hInf,
pszDriverSection,
pszDataSection,
bDataSection,
cszConfigFile,
&pDriverInfo3->pConfigFile,
pDriverInfo3->pDriverPath,
&bFail);
//
// Help file is optional, and by default NULL
//
InfGetDriverInfoString(hInf,
pszDriverSection,
pszDataSection,
bDataSection,
cszHelpFile,
&pDriverInfo3->pHelpFile,
NULL,
&bFail);
//
// Monitor name is optional, and by default none
//
InfGetDriverInfoString(hInf,
pszDriverSection,
pszDataSection,
bDataSection,
cszLanguageMonitor,
&pDriverInfo3->pMonitorName,
NULL,
&bFail);
//
// Language monitor field is of the form "Monitor Name, Monitor.dll"
// we will replace , with \0 so that we can get dll name and install
// print monitor too
//
if ( pDriverInfo3->pMonitorName ) {
if ( !lstrtok(pDriverInfo3->pMonitorName, cszComma) ) {
bFail = TRUE;
goto Cleanup;
}
}
//
// Default data type is optional, and by default none
//
InfGetDriverInfoString(hInf,
pszDriverSection,
pszDataSection,
bDataSection,
cszDefaultDataType,
&pDriverInfo3->pDefaultDataType,
NULL,
&bFail);
InfGetDependentFiles(hInf,
pszDriverSection,
pszDataSection,
bDataSection,
&pDriverInfo3->pDependentFiles,
&bFail);
Cleanup:
FreeStr(pszDataSection);
//
// On failure free all the fields filled by this routine
//
if ( bFail || !pDriverInfo3->pDependentFiles ) {
PSetupDestroyDriverInfo3(pDriverInfo3);
pDriverInfo3 = NULL;
}
return pDriverInfo3;
}
LPDRIVER_INFO_3
PSetupGetDriverInfo3(
IN PSELECTED_DRV_INFO pSelectedDrvInfo
)
/*++
Routine Description:
Gets the selected drivers information in a DRIVER_INFO_3 structure
Arguments:
pSelectedDrvInfo : Points to a valid SELECTED_DRV_INFO
Return Value:
Pointer to the DRIVER_INFO_3 structure. Memory is allocated for it.
--*/
{
HINF hInf;
LPDRIVER_INFO_3 pDriverInfo3;
if ( !pSelectedDrvInfo ||
!pSelectedDrvInfo->pszInfFile ||
!*pSelectedDrvInfo->pszInfFile ||
!pSelectedDrvInfo->pszModelName ||
!*pSelectedDrvInfo->pszModelName ||
!pSelectedDrvInfo->pszDriverSection ||
!*pSelectedDrvInfo->pszDriverSection ) {
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
hInf = SetupOpenInfFile(pSelectedDrvInfo->pszInfFile,
NULL,
INF_STYLE_WIN4,
NULL);
if ( hInf == INVALID_HANDLE_VALUE ) {
return NULL;
}
pDriverInfo3 = InfGetDriverInfo3(hInf,
pSelectedDrvInfo->pszModelName,
pSelectedDrvInfo->pszDriverSection);
SetupCloseInfFile(hInf);
return pDriverInfo3;
}
VOID
GetFilesInSection(
IN HINF hInf,
IN LPCTSTR szSection,
IN OUT LPTSTR pszFiles[],
IN OUT LPDWORD pdwFileCount,
IN OUT LPBOOL pbFail
)
/*++
Routine Description:
Gets all the filenames in a section (the section consists of list of
filenames one per line) of an Inf file.
Arguments:
HINF : Inf handle
szSection : Section name
pszFiles : Array to build the filenames
pFileCount : Pointer to file count (for files in pszFiles list)
pbFail : Set on error
Return Value:
Nothing; On error *pbFail is set. Else filenames are added in the list
allocating memory for them
--*/
{
INFCONTEXT InfContext;
LONG Index, Count;
Count = SetupGetLineCount(hInf, szSection);
if ( Count == -1 ) {
*pbFail = TRUE;
return;
}
for ( Index = 0 ; Index < Count ; ++Index ) {
SetupGetLineByIndex(hInf, szSection, Index, &InfContext);
InfGetString(&InfContext, 1, pszFiles+*pdwFileCount, pbFail);
if ( *pbFail )
return;
++(*pdwFileCount);
}
}
VOID
BuildFileList(
IN HINF hInf,
IN LPCTSTR szFileList,
IN LPTSTR pszFiles[],
IN OUT LPDWORD pdwFileCount,
IN OUT LPBOOL pbFail
)
/*++
Routine Description:
Build the list of filenames to be copied from a CopyFiles field from
the Inf file
Arguments:
hInf : Inf file handle
szFileList : CopyFiles field read from the Inf file
pszFiles : Array to build the filenames (there may be some entries)
pdwFileCount: File count (for files in pszFiles list)
pbFail : Set on error
Return Value:
Nothing; On error *pbFail is set. Else memory is allocated for filenames
and they are put in the pszFiles list
--*/
{
while ( !*pbFail && szFileList && *szFileList ) {
//
// Anything following @ is a filename, others are section name
// giving list of filenames
//
if ( szFileList[0] == sHash ) {
pszFiles[*pdwFileCount] = AllocStr(szFileList+1);
if ( !pszFiles[*pdwFileCount] )
*pbFail = TRUE;
else
++(*pdwFileCount);
} else {
GetFilesInSection(hInf, szFileList, pszFiles, pdwFileCount, pbFail);
}
szFileList += lstrlen(szFileList) + 1;
}
}
VOID
BuildDependentFilesFromFileList(
IN LPTSTR pszFiles[],
IN DWORD dwFileCount,
OUT LPTSTR *pszData,
IN OUT LPBOOL pbFail
)
/*++
Routine Description:
Build the dependent files field (a MultiSz field of filenames) from an
array of filenames
Arguments:
pszFiles : Array of filenames
dwFileCount : File count (for files in pszFiles list)
pszData : Pointer to the DependentFiles field
pbFail : Set on error
Return Value:
Nothing; On error *pbFail is set. Else memory is allocated to *pszData
and DependentFiles field built
--*/
{
DWORD dwIndex, cbLen;
if ( *pbFail )
return;
for ( dwIndex = cbLen = 0 ; dwIndex < dwFileCount ; ++dwIndex)
cbLen += lstrlen(pszFiles[dwIndex]) + 1;
// For the last \0
++cbLen;
if ( *pszData = AllocMem(cbLen*sizeof(TCHAR)) ) {
for ( dwIndex = cbLen = 0 ; dwIndex < dwFileCount ; ++dwIndex) {
lstrcpy(*pszData+cbLen, pszFiles[dwIndex]);
cbLen += lstrlen(pszFiles[dwIndex]) + 1;
}
(*pszData)[cbLen] = 0;
} else {
*pbFail = TRUE;
}
}
VOID
InfGetDependentFiles(
IN HINF hInf,
IN LPCTSTR szDriverSection,
IN LPCTSTR szDataSection, OPTIONAL
IN BOOL bDataSection,
OUT LPTSTR *pszData,
IN OUT LPBOOL pbFail
)
/*++
Routine Description:
Build the dependent files field (MultiSz) for a driver. Dependent files
are all the files specified in the CopyFiles section of the driver,
data (optional) sections.
Anything following @ is a filename, others are section names
ex.
CopyFiles=@A_PNT518.PPD,PSCRIPT
[PSCRIPT]
PSCRIPT.DRV
PSCRIPT.HLP
PSCRIPT.INI
TESTPS.TXT
DependentFiles returned is
"A_PNT518.SPD\0PSCRIPT.DRV\0PSCRIPT.HLP\0PSCRIPT.INI\0TESTPS.TXT\0\0"
Arguments:
hInf : Inf file handle
szDriverSection : Driver section name
szDataSection : Data section name (optional)
bDataSection : Is ther a data section?
pszData : Pointer to the DependentFiles field
pbFail : Set on error
Return Value:
Nothing; On error *pbFail is set. Else memory is allocated to *pszData
and DependentFiles field built
--*/
{
INFCONTEXT InfContext;
LPTSTR szFileList1 = NULL, szFileList2 = NULL, p1, *pszFiles = NULL;
DWORD dwFileCount=0, dwCount;
if ( *pbFail )
return;
//
// Get the CopyFiles lines in the driver, data sections
//
if ( SetupFindFirstLine(hInf, szDriverSection,
cszCopyFiles, &InfContext) ) {
InfGetMultiSz(&InfContext, 1, &szFileList1, pbFail);
}
if ( bDataSection &&
SetupFindFirstLine(hInf, szDataSection,
cszCopyFiles, &InfContext) ) {
InfGetMultiSz(&InfContext, 1, &szFileList2, pbFail);
}
if ( *pbFail )
goto Cleanup;
//
// Find the total number of filenames we have
//
for ( p1 = szFileList1 ; p1 && *p1 ; p1 += lstrlen(p1) + 1 ) {
//
// Anything starting with @ is a filename, else a section name
//
if ( p1[0] == sHash )
++dwFileCount;
else {
dwCount = SetupGetLineCount(hInf, p1);
if ( dwCount == -1 ) {
*pbFail = TRUE;
dwFileCount = 0;
goto Cleanup;
}
dwFileCount += dwCount;
}
}
for ( p1 = szFileList2 ; p1 && *p1 ; p1 += lstrlen(p1) + 1 ) {
//
// Anything starting with @ is a filename, else a section name
//
if ( p1[0] == sHash )
++dwFileCount;
else {
dwCount = SetupGetLineCount(hInf, p1);
if ( dwCount == -1 ) {
*pbFail = TRUE;
dwFileCount = 0;
goto Cleanup;
}
dwFileCount += dwCount;
}
}
if ( dwFileCount ) {
//
// Build the list of filenames
//
if ( !(pszFiles = AllocMem(dwFileCount * sizeof(LPTSTR))) ) {
*pbFail = TRUE;
goto Cleanup;
}
dwFileCount = 0;
BuildFileList(hInf, szFileList1, pszFiles, &dwFileCount, pbFail);
BuildFileList(hInf, szFileList2, pszFiles, &dwFileCount, pbFail);
//
// Convert list of filenames to a MultiSz field
//
BuildDependentFilesFromFileList(pszFiles, dwFileCount, pszData, pbFail);
}
Cleanup:
FreeStr(szFileList1);
FreeStr(szFileList2);
while ( dwFileCount )
FreeStr(pszFiles[--dwFileCount]);
if ( pszFiles )
FreeMem(pszFiles);
}
VOID
CheckAndEnqueueOneFile(
IN LPCTSTR pszFileName,
IN LPCTSTR pszzDependentFiles, OPTIONAL
IN HSPFILEQ CopyQueue,
IN LPCTSTR pszSourcePath,
IN LPCTSTR pszTargetPath,
IN LPCTSTR pszDiskName, OPTIONAL
IN OUT LPBOOL lpFail
)
/*++
Routine Description:
Ensure that a file is enqueue only once for copying. To do so we check
if the given file name also appears in the list of dependent files and
enqueue it only if it does not.
Arguments:
pszFileName : File name to be checked and enqueued
pszzDependentFiles : Dependent files (multi-sz) list
pszSourcePath : Source directory to look for the files
pszTargetPath : Target directory to copy the files to
pszDiskName : Title of the disk where files are
lpBool : Will be set to TRUE on error
Return Value:
Nothing
--*/
{
LPCTSTR psz;
if ( *lpFail )
return;
//
// If the file also appears as a dependent file do not enqueue it
//
if ( pszzDependentFiles ) {
for ( psz = pszzDependentFiles ; *psz ; psz += lstrlen(psz) + 1 )
if ( !lstrcmp(pszFileName, psz) )
return;
}
*lpFail = !SetupQueueCopy(
CopyQueue,
pszSourcePath,
NULL, // Path relative to source
pszFileName,
pszDiskName,
NULL, // Source Tag file
pszTargetPath,
NULL, // Target file name
0); // Copy style flags
}
BOOL
CopyPrinterDriverFiles(
IN LPDRIVER_INFO_3 pDriverInfo3,
IN LPCTSTR pszSourcePath,
IN LPCTSTR pszDiskName,
IN LPCTSTR pszTargetPath,
IN HWND hwnd,
IN BOOL bForgetSource
)
/*++
Routine Description:
Copy printer driver files to a specified directory using SetupQueue APIs
Arguments:
pDriverInfo3 : Points to a valid SELECTED_DRV_INFO
szTargetPath : Target directory to copy to
szSourcePath : Source directory to look for the files, if none is
specified will use the one from prev. operation
pszDiskName : Title of the disk where files are
hwnd : Windows handle of current top-level window
bForgetSource : TRUE if the path where driver files were copied from
should not be remembered for future use
Return Value:
TRUE on succes
FALSE else, use GetLastError() to get the error code
--*/
{
HSPFILEQ CopyQueue;
PVOID QueueContext = NULL;
BOOL bFail = FALSE;
DWORD dwOldCount, dwNewCount, dwIndex;
LPTSTR psz, *List = NULL;
//
// Valid DriverInfo3
//
if ( !pDriverInfo3 ||
!pDriverInfo3->pDriverPath ||
!pDriverInfo3->pDataFile ||
!pDriverInfo3->pConfigFile )
return FALSE;
//
// If no additions should be made to the source list findout the count
//
if ( bForgetSource ) {
dwOldCount = 0;
if ( !SetupQuerySourceList(SRCLIST_USER | SRCLIST_SYSTEM,
&List, &dwOldCount) ) {
return FALSE;
}
SetupFreeSourceList(&List, dwOldCount);
}
//
// Create a setup file copy queue.
//
CopyQueue = SetupOpenFileQueue();
if( CopyQueue == INVALID_HANDLE_VALUE ) {
goto Cleanup;
}
CheckAndEnqueueOneFile(pDriverInfo3->pDriverPath,
pDriverInfo3->pDependentFiles,
CopyQueue,
pszSourcePath,
pszTargetPath,
pszDiskName,
&bFail);
CheckAndEnqueueOneFile(pDriverInfo3->pDataFile,
pDriverInfo3->pDependentFiles,
CopyQueue,
pszSourcePath,
pszTargetPath,
pszDiskName,
&bFail);
CheckAndEnqueueOneFile(pDriverInfo3->pConfigFile,
pDriverInfo3->pDependentFiles,
CopyQueue,
pszSourcePath,
pszTargetPath,
pszDiskName,
&bFail);
if ( pDriverInfo3->pHelpFile && *pDriverInfo3->pHelpFile )
CheckAndEnqueueOneFile(pDriverInfo3->pHelpFile,
pDriverInfo3->pDependentFiles,
CopyQueue,
pszSourcePath,
pszTargetPath,
pszDiskName,
&bFail);
//
// Add each file in the dependent files field to the setup queue
//
if ( pDriverInfo3->pDependentFiles ) {
for ( psz = pDriverInfo3->pDependentFiles ;
*psz ;
psz += lstrlen(psz) + 1 )
CheckAndEnqueueOneFile(psz,
NULL,
CopyQueue,
pszSourcePath,
pszTargetPath,
pszDiskName,
&bFail);
}
if ( bFail )
goto Cleanup;
//
// Commit the file queue. This gets all files copied over.
//
QueueContext = SetupInitDefaultQueueCallback(hwnd);
if( !QueueContext ) {
goto Cleanup;
}
bFail = !SetupCommitFileQueue(hwnd,
CopyQueue,
SetupDefaultQueueCallback,
QueueContext);
//
// If bForegetSource is set fix source list
//
if ( bForgetSource &&
SetupQuerySourceList(SRCLIST_USER | SRCLIST_SYSTEM,
&List, &dwNewCount) ) {
dwOldCount = dwNewCount - dwOldCount;
if ( dwOldCount < dwNewCount )
for ( dwIndex = 0 ; dwIndex < dwOldCount ; ++dwIndex ) {
SetupRemoveFromSourceList(SRCLIST_SYSIFADMIN,
List[dwIndex]);
}
SetupFreeSourceList(&List, dwNewCount);
}
Cleanup:
if ( CopyQueue != INVALID_HANDLE_VALUE )
SetupCloseFileQueue(CopyQueue);
if ( QueueContext )
SetupTermDefaultQueueCallback(QueueContext);
return !bFail;
}
LPTSTR
GetStringFromRcFile(
UINT uId
)
/*++
Routine Description:
Load a string from the .rc file and make a copy of it by doing AllocStr
Arguments:
uId : Identifier for the string to be loaded
Return Value:
String value loaded, NULL on error. Caller should free the memory
--*/
{
TCHAR buffer[MAX_SETUP_LEN];
LoadString(ghInst, uId, buffer, sizeof(buffer)/sizeof(buffer[0]));
return AllocStr(buffer);
}
BOOL
PSetupGetPathToSearch(
IN HWND hwnd,
IN LPCTSTR pszTitle,
IN LPCTSTR pszDiskName,
IN LPCTSTR pszFileName,
OUT TCHAR szPath[MAX_PATH]
)
/*++
Routine Description:
Get path to search for some files by prompting the user
Arguments:
hwnd : Window handle of current top-level window
pszTitle : Title for the UI
pszDiskName : Diskname ot prompt the user
pszFileName : Name of the file we are looking for (NULL ok)
pszPath : Buffer to get the path entered by the user
Return Value:
TRUE on succesfully getting a path from user
FALSE else, Do GetLastError() to get the error
--*/
{
DWORD dwReturn, dwNeeded;
dwReturn = SetupPromptForDisk(hwnd,
pszTitle,
pszDiskName,
NULL,
pszFileName,
NULL,
IDF_NOBEEP,
szPath,
MAX_PATH,
&dwNeeded);
if ( dwReturn == DPROMPT_SUCCESS ) {
//
// Remove this from source list so that next time we are looking for
// native drivers we do not end up picking from wrong source
//
SetupRemoveFromSourceList(SRCLIST_SYSIFADMIN, szPath);
//
// Terminate with a \ at the end
//
dwNeeded = lstrlen(szPath);
if ( *(szPath + dwNeeded - 1) != sBackSlash &&
dwNeeded < MAX_PATH - 2 ) {
*(szPath + dwNeeded) = sBackSlash;
*(szPath + dwNeeded + 1) = sZero;
}
return TRUE;
}
if ( dwReturn == DPROMPT_OUTOFMEMORY ||
dwReturn == DPROMPT_BUFFERTOOSMALL ) {
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
} else {
SetLastError(ERROR_CANCELLED);
}
return FALSE;
}
DWORD
InvokeSetup(
IN HWND hwnd,
IN LPCTSTR pszOption,
IN LPCTSTR pszInfFile,
IN LPCTSTR pszSourcePath,
IN LPCTSTR pszServerName OPTIONAL
)
/*++
Routine Description:
Invoke setup to do an install operation associated with an INF.
Will be used to install drivers from printer.inf, monitors from monitor.inf
Arguments:
hwnd : Window handle of current top-level window
pszOption : Option from the INF file to install
pszInfFile : Name of the INF file to be used for the setup
pszSourcePath : Location where the required files are available
pszServerName : Server to install printer driver on (NULL if local)
Return Value:
ERROR_SUCCESS on succesfully installing the driver
Erro code on failure
--*/
{
TCHAR szCmd[] = TEXT("%s\\SETUP.EXE -f -s %s -i %s \
-c ExternalInstallOption /t STF_LANGUAGE = ENG /t OPTION = \"%s\" \
/t STF_PRINTSERVER = \"%s\" /t ADDCOPY = YES /t DOCOPY = YES \
/t DOCONFIG = YES /w %d");
MSG Msg;
DWORD dwSize, dwLastError = ERROR_SUCCESS;
LPTSTR pszSetupCmd = NULL;
TCHAR szSystemPath[MAX_PATH];
STARTUPINFO StartupInfo;
PROCESS_INFORMATION ProcessInformation;
//
// Setup.exe is in the system path
//
GetSystemDirectory(szSystemPath,
sizeof(szSystemPath)/sizeof(szSystemPath[0]));
if ( !pszServerName )
pszServerName = TEXT("");
dwSize = lstrlen(pszOption) + 1 + lstrlen(pszSourcePath) + 1 +
lstrlen(pszServerName) + 1+
lstrlen(szSystemPath) + 1 +
lstrlen(pszInfFile) + 1;
dwSize *= sizeof(TCHAR);
//
// 20 for window handle in ASCII
//
dwSize += sizeof(szCmd) + 20;
pszSetupCmd = (LPTSTR) AllocMem(dwSize);
if ( !pszSetupCmd ) {
dwLastError = GetLastError();
goto Cleanup;
}
//
// Noe print the command to invoke setup with all the arguments
//
wsprintf(pszSetupCmd, szCmd, szSystemPath, pszSourcePath,
pszInfFile, pszOption, pszServerName, hwnd);
//
// Invoke setup as a separate process
//
ZeroMemory(&StartupInfo, sizeof(StartupInfo));
StartupInfo.cb = sizeof(StartupInfo);
StartupInfo.wShowWindow = SW_SHOW;
if ( !CreateProcess(NULL, pszSetupCmd, NULL, NULL, FALSE, 0, NULL,
NULL, &StartupInfo, &ProcessInformation) ) {
dwLastError = GetLastError();
goto Cleanup;
}
EnableWindow (hwnd, FALSE);
while ( MsgWaitForMultipleObjects(1, (LPHANDLE)&ProcessInformation,
FALSE, (DWORD)-1, QS_ALLINPUT) ) {
//
// This message loop is a duplicate of main
// message loop with the exception of using
// PeekMessage instead of waiting inside of
// GetMessage. Process wait will actually
// be done in MsgWaitForMultipleObjects api.
//
while ( PeekMessage (&Msg, NULL, 0, 0, PM_REMOVE)) {
TranslateMessage (&Msg);
DispatchMessage (&Msg);
}
}
//
// Did setup complete succesfully?
//
GetExitCodeProcess(ProcessInformation.hProcess, &dwLastError);
if ( dwLastError ) {
SetLastError(dwLastError=(DWORD)STG_E_UNKNOWN);
}
CloseHandle (ProcessInformation.hProcess);
CloseHandle (ProcessInformation.hThread);
EnableWindow (hwnd, TRUE);
SetForegroundWindow(hwnd);
Cleanup:
if ( pszSetupCmd )
FreeMem(pszSetupCmd);
return dwLastError;
}
DWORD
InstallNt3xDriver(
IN HWND hwnd,
IN LPCTSTR pszDriverName,
IN PLATFORM platform,
IN LPCTSTR pszServerName,
IN LPCTSTR pszDiskName
)
{
LPTSTR pszTitle = NULL, pszFormat;
TCHAR szSourcePath[MAX_PATH], szInfPath[MAX_PATH];
DWORD dwLastError;
//
// Build strings to use in the path dialog ..
//
pszFormat = GetStringFromRcFile(IDS_DRIVERS_FOR_PLATFORM);
if ( pszFormat ) {
pszTitle = AllocMem((lstrlen(pszFormat) + lstrlen(pszDiskName) + 2)
* sizeof(*pszTitle));
if ( pszTitle )
wsprintf(pszTitle, pszFormat, pszDiskName);
}
//
// Ask the user where the printer.inf, printer driver files reside
//
if ( !PSetupGetPathToSearch(hwnd, pszTitle, pszDiskName,
cszPrinterInf, szSourcePath) ) {
dwLastError = GetLastError();
goto Cleanup;
}
if ( MAX_PATH > lstrlen(szSourcePath) + lstrlen(cszPrinterInf) + 1 ) {
lstrcpy(szInfPath, szSourcePath);
lstrcat(szInfPath, cszPrinterInf);
} else {
SetLastError(dwLastError=ERROR_INSUFFICIENT_BUFFER);
goto Cleanup;
}
dwLastError = InvokeSetup(hwnd,
pszDriverName,
szInfPath,
szSourcePath,
pszServerName);
Cleanup:
FreeStr(pszTitle);
FreeStr(pszFormat);
return dwLastError;
}
DWORD
PSetupInstallPrinterDriver(
IN HANDLE h,
IN PSELECTED_DRV_INFO pSelectedDrvInfo,
IN PLATFORM platform,
IN BOOL bNt3xDriver,
IN LPCTSTR pszServerName,
IN HWND hwnd,
IN LPCTSTR pszDiskName
)
/*++
Routine Description:
Copies all the necessary driver files to the printer driver directory so
that an AddPrinterDriver call could be made.
Arguments:
h : Handle to the printer class device information list
pSelectedDrvInfo: Points to the selected driver info
platform : Platform for which driver needs to be installed
bNt3xDriver : TRUE if installation is from printer.inf
(NULL for local)
pszServerName : Server for which driver is to be installed (NULL : local)
hwnd : Window handle of current top-level window. If this
routine needes to put up any UI, this window will
become the dialog's owner.
pszDiskName : Disk name to prompt for (ONLY for non 4.0 driver)
Return Value:
On succesfully copying files ERROR_SUCCESS, else the error code
--*/
{
DWORD dwRet;
Retry:
//
// For Win95 drivers we need to parse their INFs,
// For Nt 3x driver we need to call setup
// For non native environemnt dirvers ask user for path
//
if ( platform == PlatformWin95 ) {
dwRet = InstallWin95Driver(hwnd, pSelectedDrvInfo->pszModelName,
pszServerName, pszDiskName);
} else if ( bNt3xDriver ) {
dwRet = InstallNt3xDriver(hwnd,
pSelectedDrvInfo->pszModelName,
platform,
pszServerName,
pszDiskName);
} else {
dwRet = InstallDriverFromCurrentInf(h,
hwnd,
pSelectedDrvInfo,
platform,
pszServerName);
}
if ( dwRet == ERROR_EXE_MACHINE_TYPE_MISMATCH ) {
int i;
TCHAR szTitle[256], szMsg[256];
LoadString(ghInst,
IDS_INVALID_DRIVER,
szTitle,
sizeof(szTitle)/sizeof(szTitle[0]));
LoadString(ghInst,
IDS_WRONG_ARCHITECTURE,
szMsg,
sizeof(szMsg)/sizeof(szMsg[0]));
i = MessageBox(hwnd,
szMsg,
szTitle,
MB_RETRYCANCEL | MB_ICONSTOP | MB_DEFBUTTON1 | MB_APPLMODAL);
if ( i == IDRETRY )
goto Retry;
else {
SetLastError(dwRet =ERROR_CANCELLED);
}
}
return dwRet;
}
BOOL
PSetupIsDriverInstalled(
IN LPCTSTR pszServerName,
IN LPCTSTR pszDriverName,
IN PLATFORM platform,
IN DWORD dwMajorVersion
)
/*++
Routine Description:
Findsout if a particular version of a printer driver is already installed
in the system by querying spooler
Arguments:
pszServerName : Server name (NULL for local)
szDriverName : Driver name
platform : platform for which we want to check the driver
dwMajorVersion : Version no
Return Value:
TRUE if driver is installed,
FALSE else (on error too)
--*/
{
BOOL bReturn = FALSE;
DWORD dwReturned, dwNeeded;
LPBYTE p = NULL;
LPDRIVER_INFO_2 pDriverInfo2;
if ( !EnumPrinterDrivers((LPTSTR)pszServerName,
PlatformEnv[platform].pszName,
2,
NULL,
0,
&dwNeeded,
&dwReturned) &&
GetLastError() == ERROR_INSUFFICIENT_BUFFER ) {
p = AllocMem(dwNeeded);
if ( !p ||
!EnumPrinterDrivers((LPTSTR)pszServerName,
PlatformEnv[platform].pszName,
2,
p,
dwNeeded,
&dwNeeded,
&dwReturned) ) {
goto Cleanup;
}
for ( dwNeeded = 0, pDriverInfo2 = (LPDRIVER_INFO_2) p ;
dwNeeded < dwReturned ;
++dwNeeded, (LPBYTE) pDriverInfo2 += sizeof(DRIVER_INFO_2) ) {
if ( pDriverInfo2->cVersion == dwMajorVersion &&
!lstrcmp(pDriverInfo2->pName, pszDriverName) ) {
bReturn = TRUE;
goto Cleanup;
}
}
}
Cleanup:
if ( p )
FreeMem(p);
return bReturn;
}
PLATFORM
PSetupThisPlatform(
VOID
)
{
return MyPlatform;
}
BOOL
AddPrinterDriverUsingDriverInfo2(
IN LPCTSTR pszServerName,
IN LPDRIVER_INFO_3 pDriverInfo3
)
{
DRIVER_INFO_2 DriverInfo2;
DriverInfo2.cVersion = 0; //Not used by spooler
DriverInfo2.pName = pDriverInfo3->pName;
DriverInfo2.pEnvironment = pDriverInfo3->pEnvironment;
DriverInfo2.pDriverPath = pDriverInfo3->pDriverPath;
DriverInfo2.pDataFile = pDriverInfo3->pDataFile;
DriverInfo2.pConfigFile = pDriverInfo3->pConfigFile;
return AddPrinterDriver((LPTSTR)pszServerName,
2,
(LPBYTE)&DriverInfo2);
}
DWORD
InstallDriverFromCurrentInf(
IN HANDLE h,
IN HWND hwnd,
IN PSELECTED_DRV_INFO pSelectedDrvInfo,
IN PLATFORM platform,
IN LPCTSTR pszServerName
)
{
TCHAR szTargetPath[MAX_PATH],
szSourcePath[MAX_PATH],
szPathOnSource[MAX_PATH];
HINF hPrinterInf = INVALID_HANDLE_VALUE;
HSPFILEQ CopyQueue = INVALID_HANDLE_VALUE;
PVOID QueueContext = NULL;
BOOL bRet = FALSE, bFail = FALSE, bAddMon = FALSE;
LPDRIVER_INFO_3 pDriverInfo3 = NULL;
DWORD dwNeeded;
LPTSTR pMonitorDll = NULL,
szSecnWithExt[MAX_SECT_NAME_LEN];
HANDLE hMonInfo = NULL;
//
// Open INF file and append layout.inf specified in Version section
//
hPrinterInf = SetupOpenInfFile(pSelectedDrvInfo->pszInfFile,
NULL,
INF_STYLE_WIN4,
NULL);
if ( hPrinterInf == INVALID_HANDLE_VALUE )
goto Cleanup;
SetupOpenAppendInfFile(NULL, hPrinterInf, NULL);
//
// To support same INFs to install both NT and Win95 drivers actual
// section to install could be different than the one corresponding
// to the selected driver.
// Also note setup does not reset PlatformPath override. So we need to
// call this always
//
if ( !SetupDiGetActualSectionToInstall(
hPrinterInf,
pSelectedDrvInfo->pszDriverSection,
(LPTSTR)szSecnWithExt,
sizeof(szSecnWithExt)/sizeof(szSecnWithExt[0]),
&dwNeeded,
NULL) ||
!SetupSetPlatformPathOverride(PlatformOverride[platform].pszName) ) {
goto Cleanup;
}
pDriverInfo3 = InfGetDriverInfo3(hPrinterInf,
pSelectedDrvInfo->pszModelName,
(LPTSTR)szSecnWithExt);
if ( !pDriverInfo3 ) {
goto Cleanup;
}
pDriverInfo3->pEnvironment = PlatformEnv[platform].pszName;
CopyQueue = SetupOpenFileQueue();
if( CopyQueue == INVALID_HANDLE_VALUE ) {
goto Cleanup;
}
if ( platform == MyPlatform ) {
GetDriverPath(h, szSourcePath);
if ( pDriverInfo3->pMonitorName ) {
//
// The code which parses INF puts monitor dll name after \0
//
pMonitorDll = pDriverInfo3->pMonitorName +
lstrlen(pDriverInfo3->pMonitorName) + 1;
if ( !GetSystemDirectory(szTargetPath,
sizeof(szTargetPath)/sizeof(szTargetPath[0])) ||
!FindPathOnSource(pMonitorDll,
hPrinterInf,
szPathOnSource,
sizeof(szPathOnSource)/sizeof(szPathOnSource[0])) ||
!SetupQueueCopy(CopyQueue,
szSourcePath,
szPathOnSource,
pMonitorDll,
NULL,
NULL,
szTargetPath,
NULL,
0) ) {
goto Cleanup;
}
bAddMon = TRUE;
}
}
if ( !GetPrinterDriverDirectory((LPTSTR)pszServerName,
pDriverInfo3->pEnvironment,
1,
(LPBYTE)szTargetPath,
sizeof(szTargetPath),
&dwNeeded) ||
!SetupSetDirectoryId(hPrinterInf,
PRINTER_DRIVER_DIRECTORY_ID,
szTargetPath) ) {
goto Cleanup;
}
if ( !SetupInstallFilesFromInfSection(hPrinterInf,
NULL,
CopyQueue,
(LPTSTR)szSecnWithExt,
platform == MyPlatform ? szSourcePath : NULL,
0) ||
!(QueueContext = SetupInitDefaultQueueCallback(hwnd)) ||
!SetupCommitFileQueue(hwnd,
CopyQueue,
SetupDefaultQueueCallback,
QueueContext) ) {
goto Cleanup;
}
if ( bAddMon &&
!AddPrintMonitor(pDriverInfo3->pMonitorName, pMonitorDll) ) {
goto Cleanup;
}
bRet = AddPrinterDriver((LPTSTR)pszServerName, 3, (LPBYTE)pDriverInfo3);
if ( !bRet && GetLastError() == ERROR_INVALID_LEVEL ) {
bRet = AddPrinterDriverUsingDriverInfo2(pszServerName, pDriverInfo3);
}
Cleanup:
PSetupDestroyMonitorInfo(hMonInfo);
PSetupDestroyDriverInfo3(pDriverInfo3);
if ( hPrinterInf != INVALID_HANDLE_VALUE )
SetupCloseInfFile(hPrinterInf);
if ( CopyQueue != INVALID_HANDLE_VALUE )
SetupCloseFileQueue(CopyQueue);
if ( QueueContext )
SetupTermDefaultQueueCallback(QueueContext);
return bRet ? ERROR_SUCCESS : GetLastError();
}
Reference in New Issue Copy Permalink