3060 lines
90 KiB
C++
3060 lines
90 KiB
C++
/*****************************************************************************\
|
|
* MODULE: geninf.c
|
|
*
|
|
* The module contains routines for generating a setup INF file.
|
|
*
|
|
*
|
|
* Needed Work
|
|
* -----------
|
|
* 1) look at reducing the item-list size to contiguous buffers.
|
|
*
|
|
*
|
|
* Copyright (C) 1996-1997 Microsoft Corporation
|
|
* Copyright (C) 1996-1997 Hewlett Packard
|
|
*
|
|
* History:
|
|
* 22-Nov-1996 HWP-Guys Created.
|
|
*
|
|
\*****************************************************************************/
|
|
|
|
#include "pch.h"
|
|
|
|
/******************************************************************************
|
|
** Defines
|
|
******************************************************************************/
|
|
|
|
/******************************************************************************
|
|
** Define - INF_CAT_INCREMENT
|
|
** Description - The increment in size between cat file increments
|
|
******************************************************************************/
|
|
#if (!defined(INF_CAT_INCREMENT))
|
|
#define INF_CAT_INCREMENT 16
|
|
#endif
|
|
|
|
/*****************************************************************************\
|
|
* inf_NextStr (Local Routine)
|
|
*
|
|
* Proceeds to the next string in a section-list.
|
|
*
|
|
\*****************************************************************************/
|
|
_inline LPTSTR inf_NextStr(
|
|
LPTSTR lpszStr)
|
|
{
|
|
return (lpszStr + (lstrlen(lpszStr) + 1));
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_WriteInfSct (Local Routine)
|
|
*
|
|
* Writes a section to the 9x-generated-inf-file.
|
|
*
|
|
\*****************************************************************************/
|
|
_inline BOOL inf_WriteInfSct(
|
|
HANDLE hFile,
|
|
LPCSTR lpszSct)
|
|
{
|
|
DWORD cbWr;
|
|
|
|
return WriteFile(hFile, (LPBYTE)lpszSct, lstrlenA(lpszSct), &cbWr, NULL);
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetInfMfgKey (Local Routine)
|
|
*
|
|
* Returns the first word of the drvname which is used to denote mfg-section.
|
|
*
|
|
\*****************************************************************************/
|
|
LPSTR inf_GetInfMfgKey(
|
|
LPCTSTR lpszDrvName)
|
|
{
|
|
LPTSTR lpszTmp;
|
|
LPSTR lpszMfg = NULL;
|
|
|
|
|
|
if (lpszTmp = genFindChar((LPTSTR)lpszDrvName, TEXT(' '))) {
|
|
|
|
*lpszTmp = TEXT('\0');
|
|
|
|
lpszMfg = genMBFromTC(lpszDrvName);
|
|
|
|
*lpszTmp = TEXT(' ');
|
|
|
|
} else {
|
|
|
|
lpszMfg = genMBFromTC(lpszDrvName);
|
|
}
|
|
|
|
return lpszMfg;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_WriteInfMfg (Local Routine)
|
|
*
|
|
* Writes the manufacturer section.
|
|
*
|
|
\*****************************************************************************/
|
|
_inline BOOL inf_WriteInfMfg(
|
|
HANDLE hFile,
|
|
LPCTSTR lpszDrvName)
|
|
{
|
|
DWORD cbWr;
|
|
LPSTR lpszMfg;
|
|
LPSTR lpszBuf;
|
|
DWORD cbSize;
|
|
DWORD cch;
|
|
BOOL bRet = FALSE;
|
|
|
|
|
|
if (lpszMfg = inf_GetInfMfgKey(lpszDrvName)) {
|
|
|
|
cbSize = lstrlenA(g_szInfSctMfg) + lstrlenA(lpszMfg) + 1;
|
|
|
|
if (lpszBuf = (LPSTR)genGAlloc(cbSize)) {
|
|
|
|
cch = wsprintfA(lpszBuf, g_szInfSctMfg, lpszMfg);
|
|
|
|
bRet = WriteFile(hFile, lpszBuf, cch, &cbWr, NULL);
|
|
|
|
genGFree(lpszBuf, cbSize);
|
|
}
|
|
|
|
genGFree(lpszMfg, genGSize(lpszMfg));
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_WriteInfDrv (Local Routine)
|
|
*
|
|
* Writes the driver-section.
|
|
*
|
|
\*****************************************************************************/
|
|
_inline BOOL inf_WriteInfDrv(
|
|
HANDLE hFile,
|
|
LPCTSTR lpszDrvName,
|
|
LPCTSTR lpszDrvPath)
|
|
{
|
|
DWORD cbWr;
|
|
LPTSTR lpszTmp;
|
|
LPSTR lpszName;
|
|
LPSTR lpszFile;
|
|
LPSTR lpszMfg;
|
|
LPSTR lpszBuf;
|
|
DWORD cbSize;
|
|
DWORD cch;
|
|
BOOL bRet = FALSE;
|
|
|
|
|
|
if (lpszMfg = inf_GetInfMfgKey(lpszDrvName)) {
|
|
|
|
if (lpszTmp = genFindRChar((LPTSTR)lpszDrvPath, TEXT('\\'))) {
|
|
|
|
if (lpszFile = genMBFromTC(++lpszTmp)) {
|
|
|
|
if (lpszName = genMBFromTC(lpszDrvName)) {
|
|
|
|
cbSize = lstrlenA(g_szInfSctDrv) +
|
|
lstrlenA(lpszName) +
|
|
lstrlenA(lpszFile) +
|
|
lstrlenA(lpszMfg) +
|
|
1;
|
|
|
|
if (lpszBuf = (LPSTR)genGAlloc(cbSize)) {
|
|
|
|
cch = wsprintfA(lpszBuf, g_szInfSctDrv, lpszMfg, lpszName, lpszFile);
|
|
|
|
bRet = WriteFile(hFile, lpszBuf, cch, &cbWr, NULL);
|
|
|
|
genGFree(lpszBuf, cbSize);
|
|
}
|
|
|
|
genGFree(lpszName, genGSize(lpszName));
|
|
}
|
|
|
|
genGFree(lpszFile, genGSize(lpszFile));
|
|
}
|
|
}
|
|
|
|
genGFree(lpszMfg, genGSize(lpszMfg));
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_WriteInfIns (Local Routine)
|
|
*
|
|
* Writes the install-section.
|
|
*
|
|
\*****************************************************************************/
|
|
_inline BOOL inf_WriteInfIns(
|
|
HANDLE hFile,
|
|
LPCTSTR lpszDrvPath)
|
|
{
|
|
DWORD cbWr;
|
|
LPTSTR lpszTmp;
|
|
LPSTR lpszFile;
|
|
LPSTR lpszBuf;
|
|
DWORD cbSize;
|
|
DWORD cch;
|
|
BOOL bRet = FALSE;
|
|
|
|
|
|
|
|
if (lpszTmp = genFindRChar((LPTSTR)lpszDrvPath, TEXT('\\'))) {
|
|
|
|
if (lpszFile = genMBFromTC(++lpszTmp)) {
|
|
|
|
cbSize = lstrlenA(g_szInfSctIns) +
|
|
lstrlenA(lpszFile) +
|
|
1;
|
|
|
|
if (lpszBuf = (LPSTR)genGAlloc(cbSize)) {
|
|
|
|
cch = wsprintfA(lpszBuf, g_szInfSctIns, lpszFile);
|
|
|
|
bRet = WriteFile(hFile, lpszBuf, cch, &cbWr, NULL);
|
|
|
|
genGFree(lpszBuf, cbSize);
|
|
}
|
|
|
|
genGFree(lpszFile, genGSize(lpszFile));
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_WrintInfDta (Local Routine)
|
|
*
|
|
* Writes the data-section.
|
|
*
|
|
\*****************************************************************************/
|
|
_inline BOOL inf_WriteInfDta(
|
|
HANDLE hFile,
|
|
LPTSTR lpszDtaFile,
|
|
LPTSTR lpszHlpFile)
|
|
{
|
|
DWORD cbWr;
|
|
LPTSTR lpszDta;
|
|
LPTSTR lpszHlp;
|
|
LPSTR lpszIns;
|
|
LPSTR lpszDtaName;
|
|
LPSTR lpszHlpName;
|
|
DWORD cbSize;
|
|
DWORD cch;
|
|
BOOL bRet = FALSE;
|
|
|
|
|
|
if (lpszDta = genFindRChar(lpszDtaFile, TEXT('\\'))) {
|
|
|
|
if (lpszHlp = genFindRChar(lpszHlpFile, TEXT('\\'))) {
|
|
|
|
if (lpszDtaName = genMBFromTC(++lpszDta)) {
|
|
|
|
if (lpszHlpName = genMBFromTC(++lpszHlp)) {
|
|
|
|
cbSize = lstrlenA(g_szInfSctIns) +
|
|
lstrlenA(lpszDtaName) +
|
|
lstrlenA(lpszHlpName) +
|
|
1;
|
|
|
|
|
|
if (lpszIns = (LPSTR)genGAlloc(cbSize)) {
|
|
|
|
cch = wsprintfA(lpszIns, g_szInfSctDta, lpszDtaName, lpszHlpName);
|
|
bRet = WriteFile(hFile, lpszIns, cch, &cbWr, NULL);
|
|
|
|
genGFree(lpszIns, genGSize(lpszIns));
|
|
}
|
|
|
|
genGFree(lpszHlpName, genGSize(lpszHlpName));
|
|
}
|
|
|
|
genGFree(lpszDtaName, genGSize(lpszDtaName));
|
|
}
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_WriteInfFiles (Local Routine)
|
|
*
|
|
* Writes the file-list section.
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL inf_WriteInfFiles(
|
|
HANDLE hFile,
|
|
LPTSTR lpaszFiles)
|
|
{
|
|
LPTSTR lpszPtr;
|
|
LPTSTR lpszFile;
|
|
LPSTR lpszItm;
|
|
DWORD cbWr;
|
|
DWORD cch;
|
|
CHAR szBuf[255];
|
|
BOOL bRet = FALSE;
|
|
|
|
|
|
// Write out the CopyFiles Section. This will take the
|
|
// dependent files list and alter it to delminate the
|
|
// strings with commas.
|
|
//
|
|
if ((lpszPtr = lpaszFiles) && *lpszPtr) {
|
|
|
|
WriteFile(hFile, g_szInfSctFil, lstrlenA(g_szInfSctFil), &cbWr, NULL);
|
|
|
|
while (*lpszPtr) {
|
|
|
|
if (lpszFile = genFindRChar(lpszPtr, TEXT('\\'))) {
|
|
|
|
if (lpszItm = genMBFromTC(++lpszFile)) {
|
|
|
|
cch = wsprintfA(szBuf, "%s\r\n", lpszItm);
|
|
WriteFile(hFile, szBuf, cch, &cbWr, NULL);
|
|
|
|
bRet = TRUE;
|
|
|
|
genGFree(lpszItm, genGSize(lpszItm));
|
|
}
|
|
}
|
|
|
|
lpszPtr = inf_NextStr(lpszPtr);
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_WriteInfSDF (Local Routine)
|
|
*
|
|
* Writes the file-list section.
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL inf_WriteInfSDF(
|
|
HANDLE hFile,
|
|
LPCTSTR lpaszFiles)
|
|
{
|
|
LPTSTR lpszPtr;
|
|
LPTSTR lpszFile;
|
|
LPSTR lpszItm;
|
|
DWORD cbWr;
|
|
DWORD cch;
|
|
CHAR szBuf[255];
|
|
BOOL bRet = FALSE;
|
|
|
|
|
|
// Write out the CopyFiles Section. This will take the
|
|
// dependent files list and alter it to delminate the
|
|
// strings with commas.
|
|
//
|
|
if ((lpszPtr = (LPTSTR)lpaszFiles) && *lpszPtr) {
|
|
|
|
WriteFile(hFile, g_szInfSctSDF, lstrlenA(g_szInfSctSDF), &cbWr, NULL);
|
|
|
|
while (*lpszPtr) {
|
|
|
|
if (lpszFile = genFindRChar(lpszPtr, TEXT('\\'))) {
|
|
|
|
if (lpszItm = genMBFromTC(++lpszFile)) {
|
|
|
|
cch = wsprintfA(szBuf, "%hs = 1\r\n", lpszItm);
|
|
|
|
WriteFile(hFile, szBuf, cch, &cbWr, NULL);
|
|
|
|
bRet = TRUE;
|
|
|
|
genGFree(lpszItm, genGSize(lpszItm));
|
|
}
|
|
}
|
|
|
|
lpszPtr = inf_NextStr(lpszPtr);
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_BuildW9XInf (Local Routine)
|
|
*
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_BuildW9XInf(
|
|
LPINFINFO lpInf,
|
|
LPCTSTR lpszDrvName,
|
|
LPDRIVER_INFO_3 lpdi3)
|
|
{
|
|
LPTSTR lpszInfFile;
|
|
HANDLE hFile;
|
|
LPTSTR lpszInfName = NULL;
|
|
|
|
|
|
if (lpszInfFile = genBuildFileName(lpInf->lpszDstPath, lpInf->lpszDstName, g_szDotInf)) {
|
|
|
|
hFile = CreateFile(lpszInfFile,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
|
|
|
|
if (hFile && (hFile != INVALID_HANDLE_VALUE)) {
|
|
|
|
inf_WriteInfSct(hFile, (LPCSTR)g_szInfSctVer);
|
|
inf_WriteInfMfg(hFile, lpszDrvName);
|
|
inf_WriteInfDrv(hFile, lpszDrvName, (LPCTSTR)lpdi3->pDriverPath);
|
|
inf_WriteInfIns(hFile, (LPCTSTR)lpdi3->pDriverPath);
|
|
inf_WriteInfDta(hFile, lpdi3->pDataFile, lpdi3->pHelpFile);
|
|
inf_WriteInfSct(hFile, (LPSTR)g_szInfSctSDN);
|
|
inf_WriteInfSDF(hFile, (LPCTSTR)lpdi3->pDependentFiles);
|
|
inf_WriteInfFiles(hFile, lpdi3->pDependentFiles);
|
|
inf_WriteInfSct(hFile, g_szInfSctStr);
|
|
|
|
lpszInfName = lpszInfFile;
|
|
|
|
CloseHandle(hFile);
|
|
|
|
} else {
|
|
infSetError(lpInf,GetLastError());
|
|
genGFree(lpszInfFile, genGSize(lpszInfFile));
|
|
}
|
|
}
|
|
|
|
return lpszInfName;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetW9XInfo (Local Routine)
|
|
*
|
|
* Retrieves the files (drivers) for a 9x client. This essentially takes the
|
|
* files and calls a routine to build an INF that the client will use to
|
|
* install the drivers.
|
|
*
|
|
\*****************************************************************************/
|
|
LPDRIVER_INFO_3 inf_GetW9XInfo(
|
|
LPINFINFO lpInf,
|
|
LPTSTR* ppszDrvName)
|
|
{
|
|
HANDLE hPrinter;
|
|
DWORD cbBuf;
|
|
DWORD cbNeed;
|
|
LPDRIVER_INFO_1 lpdi1;
|
|
LPDRIVER_INFO_3 lpdi3 = NULL;
|
|
|
|
|
|
*ppszDrvName = NULL;
|
|
|
|
|
|
if (OpenPrinter(lpInf->lpszFrnName, &hPrinter, NULL)) {
|
|
|
|
// First let's see how big our buffer will need to
|
|
// be in order to hold the printer-driver-name-information.
|
|
//
|
|
cbBuf = 0;
|
|
GetPrinterDriver(hPrinter, (LPTSTR)g_szEnvW9X, 1, NULL, 0, &cbBuf);
|
|
|
|
|
|
// Allocate storage for holding the driver-info structure.
|
|
//
|
|
if (cbBuf && (lpdi1 = (LPDRIVER_INFO_1)genGAlloc(cbBuf))) {
|
|
|
|
if (GetPrinterDriver(hPrinter, (LPTSTR)g_szEnvW9X, 1, (LPBYTE)lpdi1, cbBuf, &cbNeed)) {
|
|
|
|
// Get size to hold the printer-driver-files-information.
|
|
//
|
|
cbBuf = 0;
|
|
GetPrinterDriver(hPrinter, (LPTSTR)g_szEnvW9X, 3, NULL, 0, &cbBuf);
|
|
|
|
|
|
if (cbBuf && (lpdi3 = (LPDRIVER_INFO_3)genGAlloc(cbBuf))) {
|
|
|
|
if (GetPrinterDriver(hPrinter, (LPTSTR)g_szEnvW9X, 3, (LPBYTE)lpdi3, cbBuf, &cbNeed)) {
|
|
|
|
*ppszDrvName = genGAllocStr(lpdi1->pName);
|
|
|
|
} else {
|
|
|
|
genGFree(lpdi3, genGSize(lpdi3));
|
|
lpdi3 = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
genGFree(lpdi1, genGSize(lpdi1));
|
|
}
|
|
|
|
ClosePrinter(hPrinter);
|
|
}
|
|
|
|
if (lpdi3 == NULL)
|
|
infSetError(lpInf,GetLastError());
|
|
|
|
return lpdi3;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetW9XInf (Local Routine)
|
|
*
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetW9XInf(
|
|
LPINFINFO lpInf)
|
|
{
|
|
LPDRIVER_INFO_3 lpdi3;
|
|
LPTSTR lpszDrvName;
|
|
LPTSTR lpszInfFile = NULL;
|
|
|
|
|
|
if (lpdi3 = inf_GetW9XInfo(lpInf, &lpszDrvName)) {
|
|
|
|
lpszInfFile = inf_BuildW9XInf(lpInf, lpszDrvName, lpdi3);
|
|
|
|
genGFree(lpszDrvName, genGSize(lpszDrvName));
|
|
genGFree(lpdi3, genGSize(lpdi3));
|
|
}
|
|
|
|
return lpszInfFile;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetIdx (Local Routine)
|
|
*
|
|
* Quick wrapper which returns the line in the INF file where the section/key
|
|
* resides.
|
|
*
|
|
\*****************************************************************************/
|
|
_inline BOOL inf_GetIdx(
|
|
LPCTSTR lpszSct,
|
|
LPCTSTR lpszKey,
|
|
HINF hInfObj,
|
|
PINFCONTEXT pic)
|
|
{
|
|
return SetupFindFirstLine(hInfObj, lpszSct, lpszKey, pic);
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetInfInfoFileName (Local Routine)
|
|
*
|
|
* Retreive the filename from the INF-INFO index.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetInfInfoFileName(
|
|
PSP_INF_INFORMATION pii,
|
|
DWORD idx)
|
|
{
|
|
DWORD cbSize, dwBufferSize;
|
|
LPTSTR lpszInfFile;
|
|
|
|
|
|
if (SetupQueryInfFileInformation(pii, idx, NULL, 0, &cbSize)) {
|
|
|
|
dwBufferSize = (cbSize + 1) * sizeof(TCHAR);
|
|
|
|
if (lpszInfFile = (LPTSTR)genGAlloc(dwBufferSize)) {
|
|
|
|
if (SetupQueryInfFileInformation(pii, idx, lpszInfFile, cbSize, NULL))
|
|
return lpszInfFile;
|
|
|
|
genGFree(lpszInfFile, genGSize(lpszInfFile));
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetInfInfo (Local Routine)
|
|
*
|
|
* Returns a pointer to an INF-INFO struct.
|
|
*
|
|
\*****************************************************************************/
|
|
PSP_INF_INFORMATION inf_GetInfInfo(
|
|
HINF hInfObj)
|
|
{
|
|
DWORD cbSize;
|
|
BOOL bRet;
|
|
PSP_INF_INFORMATION pii;
|
|
|
|
|
|
cbSize = 0;
|
|
bRet = SetupGetInfInformation(hInfObj,
|
|
INFINFO_INF_SPEC_IS_HINF,
|
|
NULL,
|
|
0,
|
|
&cbSize);
|
|
|
|
if (bRet && cbSize && (pii = (PSP_INF_INFORMATION)genGAlloc(cbSize))) {
|
|
|
|
bRet = SetupGetInfInformation(hInfObj,
|
|
INFINFO_INF_SPEC_IS_HINF,
|
|
pii,
|
|
cbSize,
|
|
NULL);
|
|
|
|
if (bRet)
|
|
return pii;
|
|
|
|
genGFree(pii, genGSize(pii));
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_AddItem (Local Routine)
|
|
*
|
|
* Add an INF file-item to the list. If adding the new item exceeds the
|
|
* available space, then reallocate the memory and return a pointer to the
|
|
* new block.
|
|
*
|
|
\*****************************************************************************/
|
|
LPINFITEMINFO inf_AddItem(
|
|
LPINFITEMINFO lpII,
|
|
LPCTSTR lpszItmName,
|
|
LPCTSTR lpszItmPath,
|
|
BOOL bInfFile)
|
|
{
|
|
DWORD idx;
|
|
DWORD dwOldSize;
|
|
DWORD dwNewSize;
|
|
LPINFITEMINFO lpNewII;
|
|
|
|
|
|
idx = lpII->dwCount++;
|
|
|
|
if ((lpII->dwCount % INF_ITEM_BLOCK) == 0) {
|
|
|
|
dwOldSize = genGSize(lpII);
|
|
dwNewSize = dwOldSize + (sizeof(INFITEM) * INF_ITEM_BLOCK);
|
|
|
|
|
|
// If we can't realloc the memory, then we are going to free up
|
|
// our existing block and return NULL. In our implementation, if
|
|
// we can't add items, we need to fail-out.
|
|
//
|
|
lpNewII = (LPINFITEMINFO)genGRealloc(lpII, dwOldSize, dwNewSize);
|
|
|
|
if (lpNewII == NULL) {
|
|
|
|
genGFree(lpII, genGSize(lpII));
|
|
|
|
DBGMSG(DBG_ERROR, ("inf_AddItem : Out of memory"));
|
|
|
|
return NULL;
|
|
}
|
|
|
|
lpII = lpNewII;
|
|
}
|
|
|
|
|
|
// Add the item to the list. The (szOrd) parameter is
|
|
// filled in during the writing of the source-disk-files
|
|
// section. The Ord indicates which directory the file
|
|
// is located in the LAYOUT.INF.
|
|
//
|
|
lpII->aItems[idx].bInf = bInfFile;
|
|
lstrcpyn(lpII->aItems[idx].szName, lpszItmName, INF_MIN_BUFFER);
|
|
lstrcpyn(lpII->aItems[idx].szPath, lpszItmPath, MAX_PATH);
|
|
// Set the SOURCE name to NULL by default, if we find a source that has a different name
|
|
// to the target, we'll set it to the original name
|
|
lpII->aItems[idx].szSource[0] = _TEXT('\0');
|
|
|
|
return lpII;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetTextLine (Local Routine)
|
|
*
|
|
* Quick wrapper which returns the text-value of the line specified in the
|
|
* inf-object.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetTextLine(
|
|
HINF hInfObj,
|
|
PINFCONTEXT pic)
|
|
{
|
|
BOOL bOK;
|
|
DWORD cbSize;
|
|
LPTSTR lpszTxt;
|
|
|
|
|
|
cbSize = 0;
|
|
if (SetupGetLineText(pic, hInfObj, NULL, NULL, NULL, 0, &cbSize)) {
|
|
|
|
if (cbSize) {
|
|
|
|
cbSize *= sizeof(TCHAR);
|
|
|
|
if (lpszTxt = (LPTSTR)genGAlloc(cbSize)) {
|
|
|
|
bOK = SetupGetLineText(pic,
|
|
hInfObj,
|
|
NULL,
|
|
NULL,
|
|
lpszTxt,
|
|
cbSize,
|
|
NULL);
|
|
|
|
if (bOK)
|
|
return lpszTxt;
|
|
|
|
genGFree(lpszTxt, cbSize);
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetText (Local Routine)
|
|
*
|
|
* Quick wrapper which returns the text-value of the line specified in the
|
|
* inf-object. This only returns the first string if the line contains
|
|
* a field-list.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetText(
|
|
HINF hInfObj,
|
|
PINFCONTEXT pic)
|
|
{
|
|
DWORD cbSize;
|
|
LPTSTR lpszTxt;
|
|
|
|
|
|
cbSize = 0;
|
|
if (SetupGetStringField(pic, 1, NULL, 0, &cbSize)) {
|
|
|
|
if (cbSize) {
|
|
|
|
cbSize *= sizeof(TCHAR);
|
|
|
|
if (lpszTxt = (LPTSTR)genGAlloc(cbSize)) {
|
|
|
|
if (SetupGetStringField(pic, 1, lpszTxt, cbSize, NULL))
|
|
return lpszTxt;
|
|
|
|
genGFree(lpszTxt, cbSize);
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/******************************************************************************************
|
|
** inf_ScanSection (local routine)
|
|
**
|
|
** Run through all of the members of a section that match a particular Key (possibly NULL)
|
|
** Supply the callback routine we receive with the MultiString that we get from scanning
|
|
** the section.
|
|
******************************************************************************************/
|
|
BOOL inf_ScanSection(HINF hInf, // The handle to the inf file we are searching
|
|
LPCTSTR lpszSection, // The section name we are scanning from
|
|
LPCTSTR lpszKey, // The key to search the sections for
|
|
LPVOID pCookie, // The data about the inf that we have picked up
|
|
INFSCANPROC pFn // The enumeration function
|
|
) {
|
|
ASSERT(pFn);
|
|
|
|
DWORD dwFieldSize = MAX_PATH;
|
|
LPTSTR pmszFields = (LPTSTR)genGAlloc(sizeof(TCHAR)*dwFieldSize);
|
|
INFCONTEXT Context; // This is the search context we use
|
|
BOOL bRet = pmszFields && SetupFindFirstLine(hInf, lpszSection, lpszKey , &Context);
|
|
BOOL bScan = bRet;
|
|
|
|
while(bScan) {
|
|
DWORD dwRequiredSize;
|
|
|
|
// Get the Scan Line from the context
|
|
bScan = SetupGetMultiSzField( &Context, 1, pmszFields, dwFieldSize, &dwRequiredSize);
|
|
|
|
if (!bScan && GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
|
|
LPTSTR pmszTempFields = (LPTSTR)genGRealloc( pmszFields,
|
|
sizeof(TCHAR) * dwFieldSize,
|
|
sizeof(TCHAR) * dwRequiredSize );
|
|
|
|
if (pmszTempFields) {
|
|
pmszFields = pmszTempFields;
|
|
dwFieldSize = dwRequiredSize;
|
|
|
|
bRet = bScan = SetupGetMultiSzField( &Context, 1, pmszFields, dwFieldSize, &dwRequiredSize );
|
|
} else
|
|
bRet = bScan = FALSE;
|
|
}
|
|
|
|
// We find all the lpszKey Keys and then Pass the Fields through to the Enum Function
|
|
|
|
if (bScan)
|
|
bScan = bRet = (*pFn)( hInf, pmszFields, pCookie);
|
|
|
|
if (bScan)
|
|
bScan = SetupFindNextMatchLine( &Context, lpszKey, &Context );
|
|
}
|
|
|
|
if (pmszFields)
|
|
genGFree( pmszFields, dwFieldSize * sizeof(TCHAR) );
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
** Structure - ENUMMFGS
|
|
**
|
|
** This structure is used to pass info up to the enumerator function
|
|
** (inf_EnumMfgSections) and return the install sections
|
|
*******************************************************************************/
|
|
typedef struct _EnumMfgs {
|
|
LPCTSTR lpszDrv; // The driver to find
|
|
LPTSTR lpszIns; // The install section in which it is found
|
|
|
|
inline _EnumMfgs(LPCTSTR lpszDrv) : lpszDrv(lpszDrv), lpszIns(NULL) {}
|
|
} ENUMMFGS;
|
|
|
|
typedef ENUMMFGS *PENUMMFGS;
|
|
|
|
|
|
/******************************************************************************
|
|
** inf_EnumMfgSections
|
|
**
|
|
** This functions is called for every manufacturer install section in an inf
|
|
** file (there may be more than one). For each one it checks to see whether the
|
|
** required driver is inside the install section. If it is, it sets the return
|
|
** string to the install section for the driver. (Subsequent calls will be ignored).
|
|
******************************************************************************/
|
|
BOOL inf_EnumMfgSections(HINF hInf, LPCTSTR lpMfgSec, LPVOID pCookie) {
|
|
ASSERT(pCookie); // Should not be NULL
|
|
|
|
PENUMMFGS pMfgs = (PENUMMFGS)pCookie;
|
|
|
|
if (lpMfgSec && pMfgs->lpszIns == NULL) { // No matching driver has been found yet
|
|
INFCONTEXT Context; // This context is used to get the install section
|
|
|
|
if ( inf_GetIdx( lpMfgSec, pMfgs->lpszDrv, hInf, &Context) ) {
|
|
|
|
pMfgs->lpszIns = inf_GetText( hInf, &Context );
|
|
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetInsVal (Local Routine)
|
|
*
|
|
* Looks for the line indicated by section/key, and returns the text-string
|
|
* for this line. This also returns an index to the line in the inf-file.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetInsVal(
|
|
LPCTSTR lpszMfg,
|
|
LPCTSTR lpszDrv,
|
|
HINF hInfObj)
|
|
{
|
|
ENUMMFGS EnumMfgs(lpszDrv);
|
|
LPTSTR lpszIns = NULL;
|
|
|
|
if (inf_ScanSection( hInfObj, g_szMfgName, lpszMfg, (LPVOID)&EnumMfgs, inf_EnumMfgSections) )
|
|
lpszIns = EnumMfgs.lpszIns;
|
|
|
|
return lpszIns;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_RealSect (Local Routine)
|
|
*
|
|
* Looks for the real-section-mapping. Some sections could be [.platform]
|
|
* specific, so we should be able to take in the section-name and
|
|
* create a real key.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetRealSect(
|
|
LPINFINFO lpInf,
|
|
LPCTSTR lpszKey)
|
|
{
|
|
BOOL bRet;
|
|
DWORD cbSize;
|
|
LPTSTR lpszSect;
|
|
|
|
|
|
if (SetupSetPlatformPathOverride(genStrCliOverride(lpInf->idxPlt))) {
|
|
|
|
cbSize = 0;
|
|
bRet = SetupDiGetActualSectionToInstall(lpInf->hInfObj,
|
|
lpszKey,
|
|
NULL,
|
|
0,
|
|
&cbSize,
|
|
NULL);
|
|
|
|
if (bRet && cbSize) {
|
|
|
|
if (lpszSect = (LPTSTR)genGAlloc(cbSize)) {
|
|
|
|
bRet = SetupDiGetActualSectionToInstall(lpInf->hInfObj,
|
|
lpszKey,
|
|
lpszSect,
|
|
cbSize,
|
|
NULL,
|
|
NULL);
|
|
|
|
if (bRet) {
|
|
|
|
SetupSetPlatformPathOverride(NULL);
|
|
return lpszSect;
|
|
}
|
|
|
|
genGFree(lpszSect, genGSize(lpszSect));
|
|
}
|
|
}
|
|
|
|
SetupSetPlatformPathOverride(NULL);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetInfFile (Local Routine)
|
|
*
|
|
* Return the name of the inf-file. This looks for the inf-file with the
|
|
* identified (lpszSection)...if NULL is specified, the first (main) inf
|
|
* file is returned.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetInfFile(
|
|
HINF hInfObj,
|
|
LPCTSTR lpszSct)
|
|
{
|
|
PSP_INF_INFORMATION pii;
|
|
INFCONTEXT ic;
|
|
LPTSTR lpszInfFile = NULL;
|
|
|
|
|
|
if (lpszSct) {
|
|
|
|
if (inf_GetIdx(lpszSct, NULL, hInfObj, &ic))
|
|
lpszInfFile = inf_GetInfFile(ic.CurrentInf, NULL);
|
|
|
|
} else {
|
|
|
|
if (pii = inf_GetInfInfo(hInfObj)) {
|
|
|
|
lpszInfFile = inf_GetInfInfoFileName(pii, 0);
|
|
|
|
genGFree(pii, genGSize(pii));
|
|
}
|
|
}
|
|
|
|
return lpszInfFile;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetLayoutFile (Local Routine)
|
|
*
|
|
* Return the name of the Layout file.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetLayoutFile(
|
|
HINF hInf )
|
|
{
|
|
LPTSTR lpszLayoutFile = NULL;
|
|
INFCONTEXT INFContext;
|
|
PINFCONTEXT pINFContext = &INFContext;
|
|
DWORD dwBufferNeeded;
|
|
|
|
// To get the source directories correct, we need to load all included INFs
|
|
// separately. THen use their associated layout files.
|
|
if ( SetupFindFirstLine( hInf, TEXT( "Version" ), TEXT( "LayoutFile" ), &INFContext ) )
|
|
{
|
|
// Find each INF and load it & it's LAYOUT files
|
|
DWORD dwINFs = SetupGetFieldCount( &INFContext );
|
|
|
|
if ( SetupGetStringField( &INFContext, 1, NULL, 0, &dwBufferNeeded ) )
|
|
{
|
|
if (lpszLayoutFile = (LPTSTR)genGAlloc( ( dwBufferNeeded * sizeof(TCHAR) ) )) {
|
|
if ( SetupGetStringField( &INFContext, 1, lpszLayoutFile, ( dwBufferNeeded * sizeof(TCHAR) ), &dwBufferNeeded ) )
|
|
return lpszLayoutFile;
|
|
|
|
|
|
genGFree(lpszLayoutFile, genGSize(lpszLayoutFile));
|
|
} // Allocated pszINFName
|
|
} // Got the Field from the INF Line
|
|
} // Found a Layout File
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetSrcInf (Local Routine)
|
|
*
|
|
* Get the name of the src inf file given the printer friendly name. This
|
|
* will return a name without the full-path to the inf-directory.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetSrcInf(
|
|
LPINFINFO lpInf)
|
|
{
|
|
LPTSTR lpszRet = NULL;
|
|
|
|
HMODULE hLib;
|
|
PSETUPCREATE pSCreate;
|
|
PSETUPDESTROY pSDelete;
|
|
PSETUPGET pSGet;
|
|
LPWSTR lpszF;
|
|
HDEVINFO hDevInfo;
|
|
WCHAR szTmp[MAX_PATH];
|
|
DWORD cbSize = MAX_PATH;
|
|
BOOL bGet;
|
|
|
|
|
|
if (genIsWin9X(lpInf->idxPlt)) {
|
|
|
|
lpszRet = inf_GetW9XInf(lpInf);
|
|
|
|
} else {
|
|
|
|
if (hLib = LoadLibraryFromSystem32(g_szNtPrintDll)) {
|
|
|
|
if (pSCreate = (PSETUPCREATE)GetProcAddress(hLib, g_szSetupCreate)) {
|
|
|
|
if (pSGet = (PSETUPGET)GetProcAddress(hLib, g_szSetupGet)) {
|
|
|
|
if (pSDelete = (PSETUPDESTROY)GetProcAddress(hLib, g_szSetupDestroy)) {
|
|
|
|
if (hDevInfo = (*pSCreate)(NULL)) {
|
|
|
|
#ifdef UNICODE
|
|
bGet = (*pSGet)(hDevInfo, lpInf->lpszFrnName, szTmp, &cbSize);
|
|
|
|
if (bGet)
|
|
lpszRet = genGAllocStr(szTmp);
|
|
else
|
|
infSetError(lpInf,GetLastError());
|
|
|
|
#else
|
|
if (lpszF = genWCFromMB(lpInf->lpszFrnName)) {
|
|
|
|
bGet = (*pSGet)(hDevInfo, lpszF, szTmp, &cbSize);
|
|
|
|
if (bGet)
|
|
lpszRet = genMBFromWC(szTmp);
|
|
|
|
genGFree(lpszF, genGSize(lpszF));
|
|
}
|
|
#endif
|
|
|
|
(*pSDelete)(hDevInfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
FreeLibrary(hLib);
|
|
}
|
|
}
|
|
|
|
|
|
return lpszRet;
|
|
}
|
|
|
|
/*****************************************************************************\
|
|
* inf_CopyAndRenameInf (Local Routine)
|
|
*
|
|
* Opens the inf (the installed, possibly renamed inf), and queries setup for the
|
|
* original name. Copies the inf to our dest directory, renaming it to the
|
|
* original name, if we have one. Also saves the orignal file info so that we
|
|
* can rename the .cat file to the original name later.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_CopyAndRenameInf(
|
|
LPINFINFO lpInf,
|
|
LPTSTR lpszSrcInf,
|
|
LPTSTR lpszSrcInfName) {
|
|
|
|
HINF hInf;
|
|
PSP_INF_INFORMATION pii;
|
|
LPTSTR lpszDstInf = NULL;
|
|
LPTSTR lpszDstName;
|
|
DWORD dwErr;
|
|
|
|
// If this is a Win9x cab then simply return the passed in name
|
|
if (genIsWin9X(lpInf->idxPlt)) {
|
|
lpszDstInf = genGAllocStr(lpszSrcInf);
|
|
} else {
|
|
// Open the main-inf file.
|
|
//
|
|
hInf = SetupOpenInfFile(lpszSrcInf,
|
|
g_szPrinterClass,
|
|
INF_STYLE_WIN4,
|
|
(PUINT)&dwErr);
|
|
if ( hInf != INVALID_HANDLE_VALUE ) {
|
|
|
|
if (pii = inf_GetInfInfo(hInf)) {
|
|
|
|
// Set the dst name to default to the src name, just in case we don't
|
|
// succeed in getting original file info from setup.
|
|
// If we don't get original file info, we DON'T bail out, because even though
|
|
// the verification will fail on the client, the user will be prompted as to whether
|
|
// to install the unverified driver files, which is what we want - the user will
|
|
// still be able to print.
|
|
//
|
|
lpszDstName = lpszSrcInfName;
|
|
|
|
// Ask setupapi for the original names of the .inf and .cat file
|
|
//
|
|
lpInf->OriginalFileInfo.cbSize = sizeof(SP_ORIGINAL_FILE_INFO);
|
|
lpInf->OriginalFileInfo.OriginalInfName[0] = TEXT('\0');
|
|
lpInf->OriginalFileInfo.OriginalCatalogName[0] = TEXT('\0');
|
|
if (SetupQueryInfOriginalFileInformation(pii, 0, NULL, &(lpInf->OriginalFileInfo))) {
|
|
lpszDstName = (LPTSTR)&(lpInf->OriginalFileInfo.OriginalInfName);
|
|
}
|
|
|
|
// Build full-path to inf-file destination. This will be our
|
|
// new inf-file in the .\cabinets directory.
|
|
//
|
|
lpszDstInf = genBuildFileName(lpInf->lpszDstPath,
|
|
lpszDstName,
|
|
NULL);
|
|
if (lpszDstInf) {
|
|
|
|
// Make a copy of our inf to the destination-directory, which will
|
|
// effectively rename it if we were successful in getting original file info.
|
|
//
|
|
if ( !CopyFile(lpszSrcInf, lpszDstInf, FALSE) )
|
|
{
|
|
infSetError(lpInf,GetLastError());
|
|
genGFree(lpszDstInf, genGSize(lpszDstInf));
|
|
lpszDstInf = NULL;
|
|
}
|
|
} else {
|
|
infSetError(lpInf,GetLastError());
|
|
lpszDstInf = NULL;
|
|
}
|
|
|
|
genGFree(pii, genGSize(pii));
|
|
} // if (pii = ...)
|
|
else
|
|
infSetError(lpInf,GetLastError());
|
|
|
|
SetupCloseInfFile(hInf);
|
|
hInf = NULL;
|
|
|
|
} // if (hInf)
|
|
else
|
|
infSetError(lpInf,GetLastError());
|
|
}
|
|
|
|
return lpszDstInf;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetInfObj (Local Routine)
|
|
*
|
|
* Get the INF file object handle. This utilizes fields from the lpInf
|
|
* structure (lpszDstDir, lpszFriendly).
|
|
*
|
|
\*****************************************************************************/
|
|
HINF inf_GetInfObj(
|
|
LPINFINFO lpInf)
|
|
{
|
|
|
|
DWORD dwErr;
|
|
LPTSTR lpszLayName;
|
|
LPTSTR lpszInfName;
|
|
LPTSTR lpszDstInf;
|
|
LPTSTR lpszSrcInf;
|
|
LPTSTR lpszLayFile;
|
|
LPTSTR lpszLaySrc;
|
|
LPTSTR lpszTmp;
|
|
HINF hInf = INVALID_HANDLE_VALUE;
|
|
|
|
// Get main INF file and make a copy to our destination.
|
|
//
|
|
if (lpszTmp = inf_GetSrcInf(lpInf)) {
|
|
|
|
// Save our inf-filename.
|
|
//
|
|
if (lpszSrcInf = genGAllocStr(lpszTmp)) {
|
|
|
|
// Split up the SrcInf file to path and name.
|
|
//
|
|
lpszInfName = genFindRChar(lpszTmp, TEXT('\\'));
|
|
|
|
if (lpszInfName != NULL) {
|
|
|
|
*lpszInfName++ = TEXT('\0');
|
|
|
|
if (lpszDstInf = inf_CopyAndRenameInf(lpInf, lpszSrcInf, lpszInfName)) {
|
|
|
|
// Open the main-inf file.
|
|
//
|
|
hInf = SetupOpenInfFile(lpszDstInf,
|
|
g_szPrinterClass,
|
|
INF_STYLE_WIN4,
|
|
(PUINT)&dwErr);
|
|
|
|
if ( hInf == INVALID_HANDLE_VALUE )
|
|
infSetError(lpInf,GetLastError());
|
|
|
|
genGFree(lpszDstInf, genGSize(lpszDstInf));
|
|
} // if (lpszDstInf)
|
|
|
|
} // if (lpszInfName != NULL)
|
|
else
|
|
infSetError(lpInf, ERROR_PATH_NOT_FOUND);
|
|
|
|
genGFree(lpszSrcInf, genGSize(lpszSrcInf));
|
|
} // if (lpszSrcInf)
|
|
else
|
|
infSetError(lpInf,GetLastError());
|
|
|
|
genGFree(lpszTmp, genGSize(lpszTmp));
|
|
} // if (lpszTmp)
|
|
|
|
return hInf;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetInsLine (Local Routine)
|
|
*
|
|
* Returns the install-line to install.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetInsLine(
|
|
LPINFINFO lpInf,
|
|
LPCTSTR lpszMfgName)
|
|
{
|
|
LPTSTR lpszSct;
|
|
BOOL bRet;
|
|
DWORD cbSize;
|
|
LPTSTR lpszIns = NULL;
|
|
|
|
|
|
// Retrieve the install-section (raw).
|
|
//
|
|
lpszSct = inf_GetInsVal(lpszMfgName, lpInf->lpszDrvName, lpInf->hInfObj);
|
|
|
|
if (lpszSct) {
|
|
|
|
// Set the platform override so that we may be specify
|
|
// architecture section to install.
|
|
//
|
|
SetupSetPlatformPathOverride(genStrCliOverride(lpInf->idxPlt));
|
|
|
|
|
|
// Determine the size necessary to hold the install-section
|
|
// string.
|
|
//
|
|
cbSize = 0;
|
|
SetupDiGetActualSectionToInstall(lpInf->hInfObj,
|
|
lpszSct,
|
|
NULL,
|
|
0,
|
|
&cbSize,
|
|
NULL);
|
|
|
|
|
|
// Get the true install section string.
|
|
//
|
|
cbSize *= sizeof(TCHAR);
|
|
|
|
if (cbSize && (lpszIns = (LPTSTR)genGAlloc(cbSize))) {
|
|
|
|
bRet = SetupDiGetActualSectionToInstall(lpInf->hInfObj,
|
|
lpszSct,
|
|
lpszIns,
|
|
cbSize,
|
|
NULL,
|
|
NULL);
|
|
|
|
|
|
// If we failed, for some reason, then
|
|
// return NULL.
|
|
//
|
|
if (bRet == FALSE) {
|
|
|
|
genGFree(lpszIns, cbSize);
|
|
lpszIns = NULL;
|
|
}
|
|
}
|
|
|
|
SetupSetPlatformPathOverride(NULL);
|
|
|
|
genGFree(lpszSct, genGSize(lpszSct));
|
|
}
|
|
|
|
return lpszIns;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetInfName (Local Routine)
|
|
*
|
|
* Returns the name of an inf-file.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetInfName(
|
|
LPINFINFO lpInf)
|
|
{
|
|
PSP_INF_INFORMATION pii;
|
|
LPTSTR lpszFile;
|
|
LPTSTR lpszPtr;
|
|
LPTSTR lpszName = NULL;
|
|
|
|
|
|
if (lpszFile = inf_GetInfFile(lpInf->hInfObj, NULL)) {
|
|
|
|
// Seperate the path and file info.
|
|
//
|
|
if (lpszPtr = genFindRChar(lpszFile, TEXT('\\')))
|
|
lpszName = genGAllocStr(lpszPtr + 1);
|
|
|
|
genGFree(lpszFile, genGSize(lpszFile));
|
|
}
|
|
|
|
return lpszName;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_IsDrvSupported (Local Routine)
|
|
*
|
|
* Returns whether the driver-version is supported for the client-version.
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL inf_IsDrvSupported(
|
|
DWORD idxVerCli,
|
|
DWORD idxVerSpl)
|
|
{
|
|
BOOL bSupported = FALSE;
|
|
|
|
|
|
// If the client is less than NT 4.0, then we can't support any
|
|
// drivers that are kernel-mode.
|
|
//
|
|
if ((idxVerCli < IDX_SPLVER_2) && (idxVerSpl >= IDX_SPLVER_2)) {
|
|
|
|
bSupported = FALSE;
|
|
|
|
} else {
|
|
|
|
// Determine if the requesting client can handle the
|
|
// driver-version installed for this printer. Typically,
|
|
// we can support drivers if they're within one major-version
|
|
// from each other.
|
|
//
|
|
if (abs((int)idxVerCli - (int)idxVerSpl) <= 1)
|
|
bSupported = TRUE;
|
|
}
|
|
|
|
|
|
return bSupported;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetDrvPath (Local Routine)
|
|
*
|
|
* Returns a string representing the requested driverpath.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetDrvPath(
|
|
LPCTSTR lpszDrvName,
|
|
DWORD idxPlt,
|
|
DWORD idxVer)
|
|
{
|
|
BOOL bGet;
|
|
DWORD cbNeed;
|
|
DWORD cbSize;
|
|
LPCTSTR lpszEnv;
|
|
LPTSTR lpszPath = NULL;
|
|
|
|
#if 1
|
|
|
|
LPDRIVER_INFO_2 lpdi;
|
|
LPDRIVER_INFO_2 lpdiItem;
|
|
DWORD cRet;
|
|
DWORD idx;
|
|
BOOL bMatch = FALSE;
|
|
DWORD idxSpl;
|
|
LPTSTR lpszEnd;
|
|
|
|
if (lpszEnv = genStrCliEnvironment(idxPlt)) {
|
|
|
|
cbSize = 0;
|
|
EnumPrinterDrivers(NULL,
|
|
(LPTSTR)lpszEnv,
|
|
2,
|
|
NULL,
|
|
0,
|
|
&cbSize,
|
|
&cRet);
|
|
|
|
if (cbSize && (lpdi = (LPDRIVER_INFO_2)genGAlloc(cbSize))) {
|
|
|
|
cRet = 0;
|
|
bGet = EnumPrinterDrivers(NULL,
|
|
(LPTSTR)lpszEnv,
|
|
2,
|
|
(LPBYTE)lpdi,
|
|
cbSize,
|
|
&cbNeed,
|
|
&cRet);
|
|
|
|
if (bGet && cRet) {
|
|
|
|
// The goal here is to search for the driver-version
|
|
// that matches the printer-name, then look to see if
|
|
// this version will work on the requested client. Typically,
|
|
// clients can support driver-versions that are (n) to (n-1)
|
|
//
|
|
for (idx = 0; idx < cRet; idx++) {
|
|
|
|
lpdiItem = (lpdi + idx);
|
|
|
|
|
|
// Potential match?
|
|
//
|
|
if (lstrcmpi(lpdiItem->pName, lpszDrvName) == 0) {
|
|
|
|
if (lpszPath = genGAllocStr(lpdiItem->pDriverPath)) {
|
|
|
|
if (lpszEnd = genFindRChar(lpszPath, TEXT('\\'))) {
|
|
|
|
*lpszEnd = TEXT('\0');
|
|
bMatch = FALSE;
|
|
|
|
|
|
// Find the version-directory-string.
|
|
//
|
|
if (lpszEnd = genFindRChar(lpszPath, TEXT('\\'))) {
|
|
|
|
// Get the index for the driver-version.
|
|
//
|
|
if ((idxSpl = genIdxFromStrVersion(lpszEnd)) != IDX_UNKNOWN) {
|
|
|
|
bMatch = inf_IsDrvSupported(idxVer, idxSpl);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// If we're not a supported driver for the
|
|
// client, then don't use this path.
|
|
//
|
|
if (bMatch == FALSE) {
|
|
|
|
genGFree(lpszPath, genGSize(lpszPath));
|
|
lpszPath = NULL;
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Chek top see if we found a compatible driver
|
|
if ( (idx == cRet) && (bMatch == FALSE) )
|
|
// We went though the whole list without finding a match
|
|
SetLastError(ERROR_DRIVER_NOT_FOUND);
|
|
}
|
|
|
|
genGFree(lpdi, cbSize);
|
|
}
|
|
else if ( cbSize == 0 )
|
|
SetLastError(ERROR_DRIVER_NOT_FOUND);
|
|
}
|
|
|
|
return lpszPath;
|
|
|
|
#else
|
|
|
|
DWORD cbVer;
|
|
LPCTSTR lpszVer;
|
|
|
|
if (lpszEnv = genStrCliEnvironment(idxPlt)) {
|
|
|
|
if (lpszVer = genStrCliVersion(idxVer)) {
|
|
|
|
// Get the required size for storing the full-directory name.
|
|
//
|
|
cbSize = 0;
|
|
GetPrinterDriverDirectory(NULL, (LPTSTR)lpszEnv, 1, NULL, 0, &cbSize);
|
|
|
|
|
|
cbVer = (lstrlen(lpszVer) * sizeof(TCHAR));
|
|
|
|
// Allocate buffer for holding the string and version directory.
|
|
//
|
|
if (cbSize && (lpszPath = (LPTSTR)genGAlloc(cbSize + cbVer))) {
|
|
|
|
bGet = GetPrinterDriverDirectory(NULL,
|
|
(LPTSTR)lpszEnv,
|
|
1,
|
|
(LPBYTE)lpszPath,
|
|
cbSize + cbVer,
|
|
&cbNeed);
|
|
|
|
if (bGet) {
|
|
|
|
lstrcat(lpszPath, lpszVer);
|
|
|
|
return lpszPath;
|
|
}
|
|
|
|
genGFree(lpszPath, cbSize + cbVer);
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetPrcPath (Local Routine)
|
|
*
|
|
* Returns a string representing the print-processor path.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetPrcPath(
|
|
DWORD idxPlt)
|
|
{
|
|
BOOL bGet;
|
|
DWORD cbNeed;
|
|
DWORD cbSize;
|
|
LPCTSTR lpszEnv;
|
|
LPTSTR lpszPath;
|
|
|
|
|
|
if (lpszEnv = genStrCliEnvironment(idxPlt)) {
|
|
|
|
// Get the required size for storing the full-directory name.
|
|
//
|
|
cbSize = 0;
|
|
GetPrintProcessorDirectory(NULL, (LPTSTR)lpszEnv, 1, NULL, 0, &cbSize);
|
|
|
|
|
|
// Allocate buffer for holding the string.
|
|
//
|
|
if (cbSize && (lpszPath = (LPTSTR)genGAlloc(cbSize))) {
|
|
|
|
bGet = GetPrintProcessorDirectory(NULL,
|
|
(LPTSTR)lpszEnv,
|
|
1,
|
|
(LPBYTE)lpszPath,
|
|
cbSize,
|
|
&cbNeed);
|
|
|
|
if (bGet)
|
|
return lpszPath;
|
|
|
|
genGFree(lpszPath, cbSize);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetIcmPath (Local Routine)
|
|
*
|
|
* Returns a string representing the ICM color path.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetIcmPath(
|
|
DWORD idxPlt)
|
|
{
|
|
DWORD cbSize;
|
|
LPTSTR lpszPath;
|
|
|
|
|
|
// Get the required size for storing the full-directory name.
|
|
//
|
|
cbSize = 0;
|
|
GetColorDirectory(NULL, NULL, &cbSize);
|
|
|
|
|
|
// Allocate buffer for holding the string.
|
|
//
|
|
if (cbSize && (lpszPath = (LPTSTR)genGAlloc(cbSize))) {
|
|
|
|
if (GetColorDirectory(NULL, lpszPath, &cbSize))
|
|
return lpszPath;
|
|
|
|
genGFree(lpszPath, cbSize);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetSysPath (Local Routine)
|
|
*
|
|
* Returns a string representing the system directory.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetSysPath(
|
|
DWORD idxPlt)
|
|
{
|
|
DWORD cbSize;
|
|
LPTSTR lpszPath;
|
|
|
|
|
|
cbSize = (MAX_PATH * sizeof(TCHAR));
|
|
|
|
|
|
// Allocate buffer for holding the string.
|
|
//
|
|
if (lpszPath = (LPTSTR)genGAlloc(cbSize)) {
|
|
|
|
if (GetSystemDirectory(lpszPath, MAX_PATH))
|
|
return lpszPath;
|
|
|
|
genGFree(lpszPath, cbSize);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_AllocStrings (Local Routine)
|
|
*
|
|
* Initializes the fields relating to the string-fields.
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL inf_AllocStrings(
|
|
LPINFINFO lpInf,
|
|
LPINFGENPARM lpParm)
|
|
{
|
|
|
|
// Initialize the driver-name field.
|
|
//
|
|
if (lpInf->lpszDrvPath = inf_GetDrvPath(lpParm->lpszDrvName, lpInf->idxPlt, lpInf->idxVer)) {
|
|
|
|
if (lpInf->lpszDrvName = genGAllocStr(lpParm->lpszDrvName)) {
|
|
|
|
if (lpInf->lpszDstName = genGAllocStr(lpParm->lpszDstName)) {
|
|
|
|
if (lpInf->lpszDstPath = genGAllocStr(lpParm->lpszDstPath)) {
|
|
|
|
if (lpInf->lpszPrtName = genGAllocStr(lpParm->lpszPortName)) {
|
|
|
|
if (lpInf->lpszShrName = genGAllocStr(lpParm->lpszShareName)) {
|
|
|
|
if (lpInf->lpszFrnName = genGAllocStr(lpParm->lpszFriendlyName))
|
|
return TRUE;
|
|
|
|
genGFree(lpInf->lpszShrName, genGSize(lpInf->lpszShrName));
|
|
}
|
|
|
|
genGFree(lpInf->lpszPrtName, genGSize(lpInf->lpszPrtName));
|
|
}
|
|
|
|
genGFree(lpInf->lpszDstPath, genGSize(lpInf->lpszDstPath));
|
|
}
|
|
|
|
genGFree(lpInf->lpszDstName, genGSize(lpInf->lpszDstName));
|
|
}
|
|
|
|
genGFree(lpInf->lpszDrvName, genGSize(lpInf->lpszDrvName));
|
|
}
|
|
|
|
genGFree(lpInf->lpszDrvPath, genGSize(lpInf->lpszDrvPath));
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_AddInfFile (Local Routine)
|
|
*
|
|
* Adds the inf-file to the list. If this fails, then the (lpII) object
|
|
* is deleted. This keeps this consistent with the inf_AddItem() routine.
|
|
*
|
|
\*****************************************************************************/
|
|
LPINFITEMINFO inf_AddInfFile(
|
|
LPINFINFO lpInf,
|
|
LPINFITEMINFO lpII)
|
|
{
|
|
LPTSTR lpszInfFile;
|
|
LPTSTR lpszFile;
|
|
LPINFITEMINFO lpIIRet = NULL;
|
|
|
|
|
|
if (lpszInfFile = inf_GetInfFile(lpInf->hInfObj, NULL)) {
|
|
|
|
// Seperate the path and file info, and add to the list.
|
|
//
|
|
if (lpszFile = genFindRChar(lpszInfFile, TEXT('\\'))) {
|
|
|
|
*lpszFile = TEXT('\0');
|
|
lpIIRet = inf_AddItem(lpII, ++lpszFile, lpszInfFile, TRUE);
|
|
|
|
}
|
|
|
|
genGFree(lpszInfFile, genGSize(lpszInfFile));
|
|
}
|
|
|
|
return lpIIRet;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_AddCATToCountArray (Local Routine)
|
|
*
|
|
* Takes a CAT filename, and adds it to our count array (if a new one), or increments
|
|
* the count if it already is in our array.
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL inf_AddCATToCountArray(LPWSTR lpszCATName,
|
|
LPCATCOUNTARRAY lpCatCountArray) {
|
|
|
|
BOOL bReturn = TRUE;
|
|
BOOL bFound = FALSE;
|
|
UINT i;
|
|
|
|
// Alloc or realloc for more memory if needed. We alloc INF_CAT_INCREMENT items at a time, as needed.
|
|
//
|
|
// When we start there is no Next Available item defined
|
|
if (!lpCatCountArray->uNextAvailable) {
|
|
if (lpCatCountArray->lpArray = (LPCATCOUNT)genGAlloc(sizeof(CATCOUNT) * INF_CAT_INCREMENT) ) {
|
|
lpCatCountArray->uNextAvailable = INF_CAT_INCREMENT;
|
|
lpCatCountArray->uItems = 0;
|
|
}
|
|
else goto CATCOUNTFAIL;
|
|
}
|
|
|
|
// See if we have already encountered this CAT file name. If so, increment the count
|
|
// for this CAT. If not, add this CAT to our array.
|
|
//
|
|
for (i=0; i < lpCatCountArray->uItems; i++) {
|
|
if (!lstrcmp(lpszCATName, lpCatCountArray->lpArray[i].lpszCATName)) {
|
|
lpCatCountArray->lpArray[i].uCount++;
|
|
bFound = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!bFound) {
|
|
// We might need to reallocate the array, we need to do this if the new position
|
|
// becomes equal to the next available item
|
|
UINT uItem = lpCatCountArray->uItems;
|
|
|
|
if (uItem >= lpCatCountArray->uNextAvailable) {
|
|
LPCATCOUNT lpNewArray = (LPCATCOUNT)genGRealloc((LPVOID)lpCatCountArray->lpArray,
|
|
sizeof(CATCOUNT) * lpCatCountArray->uNextAvailable,
|
|
sizeof(CATCOUNT) * (uItem + INF_CAT_INCREMENT) );
|
|
if (lpNewArray) {
|
|
lpCatCountArray->lpArray = lpNewArray;
|
|
lpCatCountArray->uNextAvailable = uItem + INF_CAT_INCREMENT;
|
|
}
|
|
else goto CATCOUNTFAIL;
|
|
}
|
|
|
|
lpCatCountArray->lpArray[uItem].uCount = 1;
|
|
lpCatCountArray->lpArray[uItem].lpszCATName = genGAllocWStr(lpszCATName);
|
|
|
|
if (lpCatCountArray->lpArray[uItem].lpszCATName)
|
|
lpCatCountArray->uItems = uItem + 1;
|
|
else goto CATCOUNTFAIL;
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
CATCOUNTFAIL:
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* inf_IsIndividuallySigned (Local Routine)
|
|
*
|
|
* Returns TRUE if a driver file is individually signed
|
|
*
|
|
*******************************************************************************/
|
|
BOOL inf_IsIndividuallySigned(
|
|
LPCTSTR lpszDriverFileName) {
|
|
|
|
GUID gSubject;
|
|
SIP_DISPATCH_INFO SipDispatch;
|
|
SIP_SUBJECTINFO SubjectInfo;
|
|
DWORD cbData = 0;
|
|
BOOL bRet = FALSE;
|
|
DWORD dwEncodingType = PKCS_7_ASN_ENCODING | X509_ASN_ENCODING;
|
|
|
|
ASSERT(lpszDriverFileName);
|
|
|
|
if (!CryptSIPRetrieveSubjectGuid( // This GUID is used for passing to CryptSIPLoad
|
|
lpszDriverFileName, // which verifies the sig on the file
|
|
NULL,
|
|
&gSubject)) goto Failure;
|
|
|
|
ZeroMemory( &SipDispatch, sizeof(SipDispatch) );
|
|
SipDispatch.cbSize = sizeof(SipDispatch);
|
|
|
|
if (!CryptSIPLoad(
|
|
&gSubject,
|
|
0,
|
|
&SipDispatch)) goto Failure;
|
|
|
|
// Now that we have the SIP Dispatch, fill out the subject info
|
|
|
|
ZeroMemory( &SubjectInfo, sizeof(SubjectInfo) );
|
|
SubjectInfo.cbSize = sizeof(SubjectInfo);
|
|
SubjectInfo.pgSubjectType = (GUID *)&gSubject;
|
|
SubjectInfo.hFile = INVALID_HANDLE_VALUE;
|
|
SubjectInfo.pwsFileName = lpszDriverFileName;
|
|
SubjectInfo.dwEncodingType = dwEncodingType;
|
|
|
|
if (!SipDispatch.pfGet(
|
|
&SubjectInfo,
|
|
&dwEncodingType,
|
|
0,
|
|
&cbData,
|
|
NULL)) goto Failure;
|
|
|
|
if (cbData != 0) bRet = TRUE;
|
|
|
|
Failure:
|
|
|
|
return bRet;
|
|
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_CATCountProc (Local Routine)
|
|
*
|
|
* Callback used to count up all references to CAT files by the driver files.
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL CALLBACK inf_CATCountProc(LPCTSTR lpszName,
|
|
LPCTSTR lpszPath,
|
|
BOOL bInf,
|
|
LPVOID lpData) {
|
|
|
|
|
|
BOOL bReturn = TRUE;
|
|
LPCATCOUNTARRAY lpCatCountArray = (LPCATCOUNTARRAY)(lpData);
|
|
HCATADMIN hCatAdmin = lpCatCountArray->hCatAdmin;
|
|
LPTSTR lpszDriverFileName;
|
|
|
|
HCATINFO hCatInfo = NULL;
|
|
HCATINFO hCatInfoPrev = NULL;
|
|
CATALOG_INFO CatalogInfo;
|
|
BYTE * pbHash;
|
|
DWORD dwBytes;
|
|
WIN32_FIND_DATA ffd;
|
|
PFILEITEM pFileItem;
|
|
HANDLE hFind, hFile;
|
|
LPTSTR pFullPath, pPath, pName;
|
|
|
|
// Find the catalog file associated with this file.
|
|
// If we can't find one, that's OK, it's not an error, just a file
|
|
// with no associated .cat file. The user can decide on the client-end
|
|
// whether or not he wants to install without the verification a .cat file
|
|
// would provide...
|
|
//
|
|
|
|
if (INVALID_HANDLE_VALUE != (HANDLE)hCatAdmin) {
|
|
|
|
if (lpszDriverFileName = genBuildFileName(lpszPath, lpszName, NULL)) {
|
|
|
|
hFind = FindFirstFile(lpszDriverFileName, &ffd);
|
|
|
|
if (hFind && (hFind != INVALID_HANDLE_VALUE)) {
|
|
|
|
FindClose(hFind);
|
|
|
|
// The first thing we need to determine is whether the file is individually
|
|
// signed, if it is we don't look for a cat and up the individually signed
|
|
// count
|
|
|
|
if ( inf_IsIndividuallySigned(lpszDriverFileName) ) {
|
|
lpCatCountArray->dwIndivSigned++;
|
|
} else {
|
|
|
|
// Open the file in order to hash it.
|
|
//
|
|
if (INVALID_HANDLE_VALUE != (hFile = CreateFile(lpszDriverFileName,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL))) {
|
|
|
|
// Determine how many bytes we need for the hash
|
|
//
|
|
dwBytes = 0;
|
|
pbHash = NULL;
|
|
CryptCATAdminCalcHashFromFileHandle(hFile, &dwBytes, pbHash, 0);
|
|
|
|
if (NULL != (pbHash = (BYTE *)genGAlloc(dwBytes))) {
|
|
|
|
// Compute the hash for this file
|
|
//
|
|
if (CryptCATAdminCalcHashFromFileHandle(hFile, &dwBytes, pbHash, 0)) {
|
|
|
|
// Get the catalog file(s) associated with this file hash
|
|
//
|
|
hCatInfo = NULL;
|
|
|
|
do {
|
|
|
|
hCatInfoPrev = hCatInfo;
|
|
hCatInfo = CryptCATAdminEnumCatalogFromHash(hCatAdmin, pbHash, dwBytes, 0, &hCatInfoPrev);
|
|
|
|
if (NULL != hCatInfo) {
|
|
|
|
CatalogInfo.cbStruct = sizeof(CATALOG_INFO);
|
|
|
|
if (CryptCATCatalogInfoFromContext(hCatInfo, &CatalogInfo, 0)) {
|
|
|
|
if (!inf_AddCATToCountArray(CatalogInfo.wszCatalogFile, lpCatCountArray)) {
|
|
|
|
bReturn = FALSE;
|
|
hCatInfo = NULL; // fail out of loop
|
|
}
|
|
}
|
|
}
|
|
|
|
} while (NULL != hCatInfo);
|
|
|
|
} // if (CryptCATAdminCalcHashFromFileHandle(hFile, &dwBytes, pbHash, 0)) {
|
|
|
|
genGFree(pbHash, dwBytes);
|
|
|
|
} // if (NULL != (pbHash = (BYTE *)genGAlloc(dwBytes))) {
|
|
|
|
CloseHandle(hFile);
|
|
|
|
} // if (INVALID_HANDLE_VALUE != (hFile = CreateFile(lpszDriverFileName,
|
|
|
|
} // if ( inf_IsIndividuallySigned(hFile, lpszDriverFileName) )
|
|
|
|
} // if (hFind && (hFind != INVALID_HANDLE_VALUE)) {
|
|
|
|
genGFree(lpszDriverFileName, genGSize(lpszDriverFileName));
|
|
|
|
} // if (lpszDriverFileName = genBuildFileName(lpszPath, lpszName, NULL)) {
|
|
|
|
} // if (INVALID_HANDLE_VALUE != (HANDLE)hCatAdmin) {
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_AddCATFile (Local Routine)
|
|
*
|
|
* Adds the cat-file to the list (if any).
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL inf_AddCATFile(
|
|
LPINFINFO lpInf) {
|
|
|
|
LPTSTR lpszInfFile;
|
|
LPTSTR lpszFile;
|
|
LPTSTR lpszDstCAT;
|
|
LPTSTR lpszDstName;
|
|
LPTSTR lpszInstalledCATFileName;
|
|
LPINFITEMINFO lpIIRet;
|
|
|
|
// We initialize return to TRUE because we want to NOT fail out of the cab generation process
|
|
// at this point, even if we fail to find a CAT file. This will at least still return the driver cab
|
|
// package to the client and let the user accept or decline the package when it fails to
|
|
// verify.
|
|
//
|
|
BOOL bReturn = TRUE;
|
|
CATCOUNTARRAY CatCountArray;
|
|
|
|
CatCountArray.dwIndivSigned = 0; // The number of individually signed files
|
|
CatCountArray.uItems = 0;
|
|
CatCountArray.uNextAvailable = 0;
|
|
CatCountArray.lpArray = NULL;
|
|
|
|
// Initialize the catalog admin context handle
|
|
//
|
|
if (FALSE == CryptCATAdminAcquireContext(&(CatCountArray.hCatAdmin), NULL, 0)) {
|
|
CatCountArray.hCatAdmin = (HCATADMIN)INVALID_HANDLE_VALUE;
|
|
infSetError(lpInf,GetLastError());
|
|
return FALSE;
|
|
}
|
|
|
|
// Enumerate all the items in the inf. The enumeration callback (inf_CATCountProc)
|
|
// will count the number of references for each unique CAT file that is referenced by
|
|
// one of our driver files. We will add to the CAB file, the CAT file that is referenced
|
|
// the most times by the driver files - this CAT file SHOULD be referenced by ALL of the
|
|
// driver files, or there is no point in adding the CAT to the CAB, since the driver verification
|
|
// will fail on the client if not all files are verified by the CAT.
|
|
//
|
|
if (infEnumItems((HANDLE)lpInf, inf_CATCountProc, (LPVOID)&CatCountArray )) {
|
|
|
|
if (CatCountArray.uItems > 0) {
|
|
|
|
UINT uIndex;
|
|
|
|
// Search our CAT file array to find the CAT file that was referenced more than the others.
|
|
// This is the CAT file we want to package into the CAB.
|
|
//
|
|
UINT uIndexOfMostCommonCAT = 0;
|
|
for (uIndex=0; uIndex < CatCountArray.uItems; uIndex++) {
|
|
if (CatCountArray.lpArray[uIndexOfMostCommonCAT].uCount < CatCountArray.lpArray[uIndex].uCount)
|
|
uIndexOfMostCommonCAT = uIndex;
|
|
}
|
|
|
|
// Make sure that every file referenced this CAT file - if they all didn't,
|
|
// then it will fail verification on client - so no sense in sending the CAT
|
|
// to the CAB package
|
|
//
|
|
if (CatCountArray.lpArray[uIndexOfMostCommonCAT].uCount + CatCountArray.dwIndivSigned
|
|
>= (lpInf->lpInfItems->dwCount)) {
|
|
|
|
lpszInstalledCATFileName = CatCountArray.lpArray[uIndexOfMostCommonCAT].lpszCATName;
|
|
|
|
// If we have an original .cat file name, use it for the dest name,
|
|
// otherwise, just use the current (installed) name
|
|
//
|
|
if (lpInf->OriginalFileInfo.OriginalCatalogName[0] != TEXT('\0')) {
|
|
lpszDstName = (LPTSTR)&(lpInf->OriginalFileInfo.OriginalCatalogName);
|
|
}
|
|
else {
|
|
// Find the filename portion of the current (installed) .cat file name.
|
|
lpszDstName = genFindRChar(lpszInstalledCATFileName, TEXT('\\'));
|
|
lpszDstName++;
|
|
}
|
|
|
|
if (lpszDstCAT = genBuildFileName(lpInf->lpszDstPath,
|
|
lpszDstName,
|
|
NULL)) {
|
|
|
|
// Copy the CAT file into our directory, renaming it to the original name.
|
|
//
|
|
if ( CopyFile(lpszInstalledCATFileName, lpszDstCAT, FALSE) )
|
|
{
|
|
// Add this (renamed) file to our file list to be added to the cab.
|
|
//
|
|
lpIIRet = inf_AddItem(lpInf->lpInfItems, lpszDstName, lpInf->lpszDstPath, TRUE);
|
|
if (lpIIRet == NULL) {
|
|
infSetError(lpInf,GetLastError());
|
|
bReturn = FALSE;
|
|
}
|
|
|
|
lpInf->lpInfItems = lpIIRet;
|
|
}
|
|
else
|
|
{
|
|
infSetError(lpInf,GetLastError());
|
|
genGFree(lpInf->lpInfItems, genGSize(lpInf->lpInfItems));
|
|
lpInf->lpInfItems = NULL;
|
|
bReturn = FALSE;
|
|
}
|
|
genGFree(lpszDstCAT, genGSize(lpszDstCAT));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
DBGMSG(DBG_INFO, ("geninf: No CAT Files found for driver package.\n"));
|
|
}
|
|
}
|
|
|
|
// Free all our CAT array items here
|
|
//
|
|
|
|
if (CatCountArray.lpArray) {
|
|
|
|
UINT uItem = 0;
|
|
for (uItem = 0; uItem < CatCountArray.uItems; uItem++) {
|
|
genGFree(CatCountArray.lpArray[uItem].lpszCATName, genGSize(CatCountArray.lpArray[uItem].lpszCATName));
|
|
}
|
|
|
|
genGFree(CatCountArray.lpArray, genGSize(CatCountArray.lpArray));
|
|
}
|
|
|
|
// Release the Catalog Admin context handle, if we have one
|
|
//
|
|
if (INVALID_HANDLE_VALUE != (HANDLE)(CatCountArray.hCatAdmin)) {
|
|
CryptCATAdminReleaseContext(CatCountArray.hCatAdmin, 0);
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_SetDefDirIds (Local Routine)
|
|
*
|
|
* Sets the Default DRID values for the setup-process.
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL inf_SetDefDirIds(
|
|
LPINFINFO lpInf)
|
|
{
|
|
LPTSTR lpszDrv;
|
|
LPTSTR lpszPrc;
|
|
LPTSTR lpszSys;
|
|
LPTSTR lpszIcm;
|
|
BOOL bRet = FALSE;
|
|
|
|
|
|
if (lpszDrv = lpInf->lpszDrvPath) {
|
|
|
|
if (lpszPrc = inf_GetPrcPath(lpInf->idxPlt)) {
|
|
|
|
if (lpszSys = inf_GetSysPath(lpInf->idxPlt)) {
|
|
|
|
if (lpszIcm = inf_GetIcmPath(lpInf->idxPlt)) {
|
|
|
|
if (SetupSetDirectoryId(lpInf->hInfObj, INF_DRV_DRID, lpszDrv) &&
|
|
SetupSetDirectoryId(lpInf->hInfObj, INF_PRC_DRID, lpszPrc) &&
|
|
SetupSetDirectoryId(lpInf->hInfObj, INF_SYS_DRID, lpszSys) &&
|
|
SetupSetDirectoryId(lpInf->hInfObj, INF_ICM_DRID, lpszIcm)) {
|
|
|
|
bRet = TRUE;
|
|
}
|
|
|
|
genGFree(lpszIcm, genGSize(lpszIcm));
|
|
}
|
|
|
|
genGFree(lpszSys, genGSize(lpszSys));
|
|
}
|
|
|
|
genGFree(lpszPrc, genGSize(lpszPrc));
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_SetDirIds (Local Routine)
|
|
*
|
|
* Sets the DRID values for the setup-process.
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL inf_SetDirIds(
|
|
LPINFINFO lpInf)
|
|
{
|
|
INFCONTEXT ic;
|
|
DWORD idx;
|
|
DWORD dwCount;
|
|
WORD wEnvCli;
|
|
WORD wEnvSrv;
|
|
DWORD dwDRID;
|
|
LPTSTR lpszDir;
|
|
BOOL bRet = FALSE;
|
|
|
|
|
|
|
|
// Initialize the default directories for DRID values.
|
|
//
|
|
inf_SetDefDirIds(lpInf);
|
|
|
|
|
|
// Look through the INF-File for any overriding DRID values and
|
|
// set these.
|
|
//
|
|
if ((dwCount = SetupGetLineCount(lpInf->hInfObj, g_szDestDirs)) != (DWORD)-1) {
|
|
|
|
for (idx = 0, bRet = TRUE; (idx < dwCount) && bRet; idx++) {
|
|
|
|
if (bRet = SetupGetLineByIndex(lpInf->hInfObj, g_szDestDirs, idx, &ic)) {
|
|
|
|
if (bRet = SetupGetIntField(&ic, 1, (PINT)&dwDRID)) {
|
|
|
|
if (dwDRID < DIRID_USER)
|
|
continue;
|
|
|
|
switch (dwDRID) {
|
|
|
|
case INF_DRV_DRID:
|
|
bRet = SetupSetDirectoryId(lpInf->hInfObj, dwDRID, lpInf->lpszDrvPath);
|
|
continue;
|
|
|
|
#if 1
|
|
// We don't necessarily need to copy the procesor and system32 files
|
|
// since they are architecture specific. In this case we will let the
|
|
// files default to the skip-dir.
|
|
//
|
|
// NOTE: if do not include these files, we might need to modify the INF
|
|
// so that they are not referenced during client-side install.
|
|
//
|
|
case INF_PRC_DRID:
|
|
wEnvCli = genValCliArchitecture(lpInf->idxPlt);
|
|
wEnvSrv = genValSvrArchitecture();
|
|
|
|
if (wEnvCli == wEnvSrv) {
|
|
|
|
lpszDir = inf_GetPrcPath(lpInf->idxPlt);
|
|
|
|
} else {
|
|
|
|
lpszDir = genGAllocStr(g_szSkipDir);
|
|
}
|
|
break;
|
|
|
|
case INF_SYS_DRID:
|
|
wEnvCli = genValCliArchitecture(lpInf->idxPlt);
|
|
wEnvSrv = genValSvrArchitecture();
|
|
|
|
if (wEnvCli == wEnvSrv) {
|
|
|
|
lpszDir = inf_GetSysPath(lpInf->idxPlt);
|
|
|
|
} else {
|
|
|
|
lpszDir = genGAllocStr(g_szSkipDir);
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
case INF_ICM_DRID:
|
|
lpszDir = inf_GetIcmPath(lpInf->idxPlt);
|
|
break;
|
|
|
|
default:
|
|
lpszDir = genGAllocStr(g_szSkipDir);
|
|
}
|
|
|
|
|
|
if (lpszDir) {
|
|
|
|
bRet = SetupSetDirectoryId(lpInf->hInfObj, dwDRID, lpszDir);
|
|
|
|
genGFree(lpszDir, genGSize(lpszDir));
|
|
|
|
} else {
|
|
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_ScanFiles (Local Routine)
|
|
*
|
|
* Callback routine which returns the items in a copyfiles list.
|
|
*
|
|
\*****************************************************************************/
|
|
UINT CALLBACK inf_ScanFiles(
|
|
LPVOID lpCtxt,
|
|
UINT uNotify,
|
|
UINT_PTR Parm1,
|
|
UINT_PTR Parm2)
|
|
{
|
|
LPINFSCAN lpScan;
|
|
LPTSTR lpszPath;
|
|
LPTSTR lpszFile;
|
|
|
|
|
|
if ((lpScan = (LPINFSCAN)lpCtxt) && (lpszPath = (LPTSTR)Parm1)) {
|
|
|
|
if (lpszFile = genFindRChar(lpszPath, TEXT('\\'))) {
|
|
|
|
*lpszFile = TEXT('\0');
|
|
|
|
|
|
// If this is a skip-dir item then do not add to our
|
|
// list. This can happen for files that are not stored
|
|
// in platform-specific directories. For example, files
|
|
// stored in the SYSTEM32 directory have no architecture
|
|
// counter-part. We do not want to download the incorrect
|
|
// file for a different architecture.
|
|
//
|
|
if (lstrcmpi(lpszPath, g_szSkipDir) != 0) {
|
|
|
|
lpScan->lpII = inf_AddItem(lpScan->lpII, lpszFile + 1, lpszPath, FALSE);
|
|
|
|
}
|
|
|
|
*lpszFile = TEXT('\\');
|
|
|
|
return (lpScan->lpII ? 0 : 1);
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_BuildW9XList (Local Routine)
|
|
*
|
|
* This enumerates the W9X dependent files and adds them to our list.
|
|
*
|
|
\*****************************************************************************/
|
|
LPINFITEMINFO inf_BuildW9XList(
|
|
LPINFINFO lpInf,
|
|
LPINFSCAN lpis)
|
|
{
|
|
LPDRIVER_INFO_3 lpdi3;
|
|
LPTSTR lpszDrvName;
|
|
LPTSTR lpszItm;
|
|
BOOL bRet = FALSE;
|
|
|
|
|
|
if (lpdi3 = inf_GetW9XInfo(lpInf, &lpszDrvName)) {
|
|
|
|
if (lpszItm = lpdi3->pDependentFiles) {
|
|
|
|
bRet = TRUE;
|
|
|
|
while (*lpszItm) {
|
|
|
|
if (inf_ScanFiles(lpis, 0, (UINT_PTR)lpszItm, 0) != 0)
|
|
break;
|
|
|
|
lpszItm = inf_NextStr(lpszItm);
|
|
}
|
|
}
|
|
|
|
genGFree(lpszDrvName, genGSize(lpszDrvName));
|
|
genGFree(lpdi3, genGSize(lpdi3));
|
|
}
|
|
|
|
|
|
if (bRet == FALSE) {
|
|
genGFree(lpis->lpII, genGSize(lpis->lpII));
|
|
lpis->lpII = NULL;
|
|
}
|
|
|
|
return lpis->lpII;
|
|
}
|
|
|
|
|
|
|
|
/*******************************************************************************************
|
|
** inf_ScanSourceTarget (local routine)
|
|
**
|
|
** Get the source and target, and then run through all the inf files if there is a source
|
|
** and find the target file that matches and add the source to the database
|
|
**
|
|
*******************************************************************************************/
|
|
BOOL CALLBACK inf_ScanSourceTarget(HINF hInf,
|
|
LPCTSTR pmszFields,
|
|
LPVOID pCookie) {
|
|
ASSERT(pmszFields); // Should never be NULL, we allocate it
|
|
ASSERT(pCookie); // Should never be NULL, we pass it in after check
|
|
|
|
LPINFSCAN lpis = (LPINFSCAN)pCookie;
|
|
LPINFITEMINFO lpII = lpis->lpII;
|
|
LPCTSTR szTarget = pmszFields;
|
|
BOOL bRet = lpII != NULL;
|
|
|
|
if (*szTarget && bRet) { // There is a target file (non NULL)
|
|
LPCTSTR szSource = &pmszFields[ lstrlen(szTarget) + 1 ];
|
|
|
|
if (*szSource) {
|
|
DWORD dwIdx;
|
|
DWORD dwCount;
|
|
|
|
// We don't need to do anything if source and target name are the same, even
|
|
// if they are expressly listed in the inf file
|
|
|
|
if ( lstrcmpi ( szTarget, szSource) ) {
|
|
dwCount = lpII->dwCount;
|
|
|
|
for(dwIdx = 0; dwIdx < dwCount; ++dwIdx) {
|
|
if (!lstrcmpi( lpII->aItems[dwIdx].szName, szTarget))
|
|
// Targets match, write the source file name into the structure
|
|
lstrcpyn( lpII->aItems[dwIdx].szSource, szSource, INF_MIN_BUFFER );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/******************************************************************************************
|
|
** inf_ScanCopyFields (local routine)
|
|
**
|
|
** Run through the Copy Fields supplied by inf_ScanSection and Scan through those sections
|
|
** for Source and Destination Pairs
|
|
**
|
|
******************************************************************************************/
|
|
BOOL CALLBACK inf_ScanCopyFields(HINF hInf, LPCTSTR pmszFields, LPVOID pCookie) {
|
|
ASSERT(pmszFields);
|
|
|
|
BOOL bRet = TRUE;
|
|
|
|
while(*pmszFields && bRet) {
|
|
if (*pmszFields != TEXT('@')) // Check for an individual file install
|
|
bRet = inf_ScanSection( hInf, pmszFields, NULL, pCookie, inf_ScanSourceTarget);
|
|
|
|
pmszFields += lstrlen(pmszFields) + 1;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_BuildWNTList (Local Routine)
|
|
*
|
|
* This builds our list from the NT scan-file-queue of an inf-parser.
|
|
*
|
|
\*****************************************************************************/
|
|
LPINFITEMINFO inf_BuildWNTList(
|
|
LPINFINFO lpInf,
|
|
LPCTSTR lpszMfgName,
|
|
LPINFSCAN lpis)
|
|
{
|
|
LPTSTR lpszIns;
|
|
HSPFILEQ hFQ;
|
|
DWORD dwRet;
|
|
BOOL bRet = FALSE;
|
|
|
|
|
|
if (lpszIns = inf_GetInsLine(lpInf, lpszMfgName)) {
|
|
|
|
SetupSetPlatformPathOverride(genStrCliOverride(lpInf->idxPlt));
|
|
|
|
hFQ = SetupOpenFileQueue();
|
|
if (hFQ != INVALID_HANDLE_VALUE) {
|
|
|
|
inf_SetDirIds(lpInf);
|
|
|
|
bRet = SetupInstallFilesFromInfSection(lpInf->hInfObj,
|
|
NULL,
|
|
hFQ,
|
|
lpszIns,
|
|
NULL,
|
|
0);
|
|
|
|
if (bRet) {
|
|
// Setup the user-defined data passed to the
|
|
// enum-callback.
|
|
//
|
|
dwRet = 0;
|
|
bRet = SetupScanFileQueue(hFQ,
|
|
SPQ_SCAN_USE_CALLBACK,
|
|
0,
|
|
inf_ScanFiles,
|
|
(LPVOID)lpis,
|
|
&dwRet);
|
|
}
|
|
|
|
SetupCloseFileQueue(hFQ);
|
|
|
|
// Now that we have all of the files, we run through the inf file to see what the
|
|
// original file names where. If they are different, we insert them into
|
|
// the inf file
|
|
|
|
if (bRet)
|
|
bRet = inf_ScanSection(lpInf->hInfObj,
|
|
lpszIns,
|
|
g_szCopyFiles,
|
|
(PVOID)lpis,
|
|
inf_ScanCopyFields
|
|
);
|
|
}
|
|
|
|
SetupSetPlatformPathOverride(NULL);
|
|
|
|
genGFree(lpszIns, genGSize(lpszIns));
|
|
}
|
|
|
|
if (bRet == FALSE) {
|
|
genGFree(lpis->lpII, genGSize(lpis->lpII));
|
|
lpis->lpII = NULL;
|
|
}
|
|
|
|
|
|
return lpis->lpII;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetItemList (Local Routine)
|
|
*
|
|
* Get the items from the INF file and build our array of files from this
|
|
* search. This does quite a bit of work.
|
|
*
|
|
\*****************************************************************************/
|
|
LPINFITEMINFO inf_GetItemList(
|
|
LPINFINFO lpInf,
|
|
LPCTSTR lpszMfgName)
|
|
{
|
|
INFSCAN is;
|
|
DWORD cbSize;
|
|
BOOL bRet;
|
|
|
|
|
|
// Initialize a default-block to contain our inf-items.
|
|
//
|
|
cbSize = sizeof(INFITEMINFO) + (sizeof(INFITEM) * INF_ITEM_BLOCK);
|
|
|
|
|
|
// Setup a structure which will be utilized by either the
|
|
// setup-scan-file-queue, or our own routine to process W9X
|
|
// items.
|
|
//
|
|
if (is.lpII = (LPINFITEMINFO)genGAlloc(cbSize)) {
|
|
|
|
is.lpInf = lpInf;
|
|
|
|
// Add the inf-files to the list.
|
|
//
|
|
if (is.lpII = inf_AddInfFile(lpInf, is.lpII)) {
|
|
|
|
if (genIsWin9X(lpInf->idxPlt)) {
|
|
|
|
is.lpII = inf_BuildW9XList(lpInf, &is);
|
|
|
|
} else {
|
|
|
|
is.lpII = inf_BuildWNTList(lpInf, lpszMfgName, &is);
|
|
}
|
|
}
|
|
}
|
|
|
|
return is.lpII;
|
|
}
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetSection (Local Routine)
|
|
*
|
|
* Allocate a buffer which stores either all section-names or the list of
|
|
* items specified by (lpszSection) in an INF file. Currently, we attempt
|
|
* a realloc if the buffer is not big enough.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetSection(
|
|
LPINFINFO lpInf,
|
|
LPCTSTR lpszSct)
|
|
{
|
|
LPTSTR lpszInfFile;
|
|
DWORD dwCnt;
|
|
DWORD cch;
|
|
DWORD dwSize;
|
|
DWORD dwLimit;
|
|
LPTSTR lpszNames = NULL;
|
|
|
|
|
|
// Get the inf-file-name whith contains the specified section.
|
|
//
|
|
if (lpszInfFile = inf_GetInfFile(lpInf->hInfObj, lpszSct)) {
|
|
|
|
dwSize = 0;
|
|
dwLimit = 0;
|
|
|
|
while (dwLimit < INF_SECTION_LIMIT) {
|
|
|
|
// We'll start this allocation with an assumed max-size. Upon
|
|
// successive tries, this buffer is increased each time by the
|
|
// original buffer allocation.
|
|
//
|
|
dwSize += (INF_SECTION_BLOCK * sizeof(TCHAR));
|
|
dwLimit++;
|
|
|
|
|
|
// Alloc the buffer and attempt to get the names.
|
|
//
|
|
if (lpszNames = (LPTSTR)genGAlloc(dwSize)) {
|
|
|
|
// If a section-name is profided, use that. Otherwise,
|
|
// enumerate all section-names.
|
|
//
|
|
cch = dwSize / sizeof(TCHAR);
|
|
|
|
if (lpszSct) {
|
|
|
|
dwCnt = GetPrivateProfileSection(lpszSct,
|
|
lpszNames,
|
|
cch,
|
|
lpszInfFile);
|
|
} else {
|
|
|
|
dwCnt = GetPrivateProfileSectionNames(lpszNames,
|
|
cch,
|
|
lpszInfFile);
|
|
}
|
|
|
|
|
|
// If the call says the buffer was OK, then we can
|
|
// assume the names are retrieved. According to spec's,
|
|
// if the return-count is equal to size-2, then buffer
|
|
// isn't quite big-enough (two NULL chars).
|
|
//
|
|
if (dwCnt < (cch - 2))
|
|
goto GetSectDone;
|
|
|
|
|
|
genGFree(lpszNames, dwSize);
|
|
lpszNames = NULL;
|
|
}
|
|
}
|
|
|
|
GetSectDone:
|
|
|
|
SPLASSERT((dwLimit < INF_SECTION_LIMIT));
|
|
|
|
genGFree(lpszInfFile, genGSize(lpszInfFile));
|
|
}
|
|
|
|
return lpszNames;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetMfgName (Local Routine)
|
|
*
|
|
* Get the manufacture-name from the driver-name. Some drivers do not really
|
|
* begin with the manufacture-name. These will have to be special-cased
|
|
* to determine their cooresponding manufacturer-name.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetMfgNameExe(
|
|
LPINFINFO lpInf)
|
|
{
|
|
INFCONTEXT ic;
|
|
BOOL bFind;
|
|
LPTSTR lpszNames;
|
|
LPTSTR lpszDrvCpy;
|
|
LPTSTR lpszPtr;
|
|
LPTSTR lpszMfgName = NULL;
|
|
|
|
|
|
// Make a copy for us to muck with.
|
|
//
|
|
if (lpszDrvCpy = genGAllocStr(lpInf->lpszDrvName)) {
|
|
|
|
// Let's assume the best-case and the model-name's first word
|
|
// is the Manufacturer. All we need in this case is to find
|
|
// the first <space> in the driver-name.
|
|
//
|
|
// Find the first word to use in locating the manufacturer.
|
|
//
|
|
if (lpszPtr = genFindChar(lpszDrvCpy, TEXT(' ')))
|
|
*lpszPtr = TEXT('\0');
|
|
|
|
|
|
|
|
// Take the first-word and try to get a manufacture out
|
|
// of it.
|
|
//
|
|
if (lpszMfgName = genGAllocStr(lpszDrvCpy)) {
|
|
|
|
// Look for the module-name in the manufacturers section. This
|
|
// will return us an index into the inf-file.
|
|
//
|
|
bFind = inf_GetIdx(lpszMfgName,
|
|
lpInf->lpszDrvName,
|
|
lpInf->hInfObj,
|
|
&ic);
|
|
|
|
|
|
// If the model-manufacturer lookup failed, then we
|
|
// need to look at other model-manufacturer mappings.
|
|
//
|
|
if (bFind == FALSE) {
|
|
|
|
// Free the existing string used for this test. Since,
|
|
// we could conceptually come up with another manufacturer
|
|
// name for this model.
|
|
//
|
|
genGFree(lpszMfgName, genGSize(lpszMfgName));
|
|
lpszMfgName = NULL;
|
|
|
|
|
|
// Since we were not able to find the model-name through
|
|
// conventional means, we are going to look through every
|
|
// section-name in the Inf for the model-name.
|
|
//
|
|
if (lpszNames = inf_GetSection(lpInf, NULL)) {
|
|
|
|
lpszPtr = lpszNames;
|
|
|
|
while (*lpszPtr != TEXT('\0')) {
|
|
|
|
bFind = inf_GetIdx(lpszPtr,
|
|
lpInf->lpszDrvName,
|
|
lpInf->hInfObj,
|
|
&ic);
|
|
|
|
// See if we found a match. If so, break out
|
|
// of our loop.
|
|
//
|
|
if (bFind) {
|
|
lpszMfgName = genGAllocStr(lpszPtr);
|
|
break;
|
|
}
|
|
|
|
|
|
// Goto the next section.
|
|
//
|
|
lpszPtr = inf_NextStr(lpszPtr);
|
|
}
|
|
|
|
genGFree(lpszNames, genGSize(lpszNames));
|
|
}
|
|
}
|
|
}
|
|
|
|
genGFree(lpszDrvCpy, genGSize(lpszDrvCpy));
|
|
}
|
|
|
|
return lpszMfgName;
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_GetMfgName (Local Routine)
|
|
*
|
|
* Get the manufacture-name from the driver-name. Some drivers do not really
|
|
* begin with the manufacture-name. These will have to be special-cased
|
|
* to determine their cooresponding manufacturer-name.
|
|
*
|
|
\*****************************************************************************/
|
|
LPTSTR inf_GetMfgName(
|
|
LPINFINFO lpInf)
|
|
{
|
|
HANDLE hPrinter;
|
|
LPTSTR lpszMfgName = NULL;
|
|
|
|
|
|
if (OpenPrinter(lpInf->lpszFrnName, &hPrinter, NULL)) {
|
|
DWORD cbNeeded = 0;
|
|
LPTSTR lpszClientEnvironment = (LPTSTR)genStrCliEnvironment(lpInf->idxPlt);
|
|
|
|
GetPrinterDriver( hPrinter,
|
|
lpszClientEnvironment,
|
|
6,
|
|
NULL,
|
|
0,
|
|
&cbNeeded
|
|
);
|
|
|
|
if ( GetLastError() == ERROR_INSUFFICIENT_BUFFER ) {
|
|
LPBYTE pData;
|
|
DWORD dwSize = cbNeeded;
|
|
|
|
if ( pData = (LPBYTE) genGAlloc(cbNeeded) ) {
|
|
if (GetPrinterDriver( hPrinter,
|
|
lpszClientEnvironment,
|
|
6,
|
|
pData,
|
|
dwSize,
|
|
&cbNeeded) ) {
|
|
PDRIVER_INFO_6 pDriverInfo = (PDRIVER_INFO_6) pData;
|
|
|
|
if (pDriverInfo->pszMfgName)
|
|
lpszMfgName = genGAllocStr(pDriverInfo->pszMfgName);
|
|
else
|
|
SetLastError(ERROR_BAD_ENVIRONMENT);
|
|
|
|
}
|
|
genGFree( pData, dwSize );
|
|
}
|
|
}
|
|
|
|
ClosePrinter(hPrinter);
|
|
}
|
|
|
|
if (NULL == lpszMfgName)
|
|
lpszMfgName = inf_GetMfgNameExe(lpInf);
|
|
|
|
return lpszMfgName;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* inf_BuildItems (Local Routine)
|
|
*
|
|
* This routine builds a file-list of items that the INF setup requires.
|
|
*
|
|
\*****************************************************************************/
|
|
LPINFITEMINFO inf_BuildItems(
|
|
LPINFINFO lpInf)
|
|
{
|
|
LPTSTR lpszMfgName;
|
|
LPINFITEMINFO lpItems = NULL;
|
|
|
|
|
|
// Get the manufacturer-name that we will be dealing with. If
|
|
// we can't find the matching name that cooresponds with our driver,
|
|
// then no need to proceed.
|
|
//
|
|
if (lpszMfgName = inf_GetMfgName(lpInf)) {
|
|
|
|
// Build the item-list. If successful, then rewrite our new
|
|
// inf-files for a flat-install.
|
|
//
|
|
lpItems = inf_GetItemList(lpInf, lpszMfgName);
|
|
|
|
genGFree(lpszMfgName, genGSize(lpszMfgName));
|
|
}
|
|
|
|
return lpItems;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* infCreate
|
|
*
|
|
* Creates an INF object.
|
|
*
|
|
\*****************************************************************************/
|
|
HANDLE infCreate(
|
|
LPINFGENPARM lpParm)
|
|
{
|
|
LPINFINFO lpInf;
|
|
|
|
|
|
if (lpInf = (LPINFINFO)genGAlloc(sizeof(INFINFO))) {
|
|
|
|
lpInf->dwCliInfo = lpParm->dwCliInfo;
|
|
lpInf->idxPlt = lpParm->idxPlt;
|
|
lpInf->idxVer = lpParm->idxVer;
|
|
|
|
// Allocate our parameter-strings.
|
|
//
|
|
if ( inf_AllocStrings(lpInf, lpParm) )
|
|
return (HANDLE)lpInf;
|
|
|
|
// Since the allocate Strings failed free up the Object
|
|
genGFree(lpInf, sizeof(INFINFO));
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*****************************************************************************\
|
|
* infProcess
|
|
*
|
|
* Uses INF object to prepare for CAB.
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL infProcess(
|
|
HANDLE hInf)
|
|
{
|
|
|
|
LPINFINFO lpInf = (LPINFINFO) hInf;
|
|
|
|
// Create handle to setup-inf-object. This requires
|
|
// strings in lpInf to be allocated and correct.
|
|
//
|
|
lpInf->hInfObj = inf_GetInfObj(lpInf);
|
|
if ( lpInf->hInfObj != INVALID_HANDLE_VALUE ) {
|
|
|
|
// Retrieve the inf-name from the inf-object.
|
|
//
|
|
if (lpInf->lpszInfName = inf_GetInfName(lpInf)) {
|
|
|
|
// Build our file object-list.
|
|
//
|
|
if (lpInf->lpInfItems = inf_BuildItems(lpInf)) {
|
|
|
|
// Next, use the item list to determine the cat file and add it
|
|
// to the list. This can't be done any earlier (like in inf_BuildItems() )
|
|
// because it uses the infEnumItems callback, and so it relies on the
|
|
// item list being setup already.
|
|
//
|
|
if (genIsWin9X(lpInf->idxPlt)) {
|
|
|
|
// Do something different here for 9X?
|
|
// The server isn't caching the CAT files for 9X drivers, so
|
|
// we don't have access to them anyway.
|
|
//
|
|
return TRUE;
|
|
}
|
|
else {
|
|
if (inf_AddCATFile(lpInf)) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Some Type of failure...
|
|
infSetError(lpInf,GetLastError());
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/*****************************************************************************\
|
|
* infDestroy
|
|
*
|
|
* Destroys the INF object and all resources allocated on its behalf.
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL infDestroy(
|
|
HANDLE hInf)
|
|
{
|
|
LPINFINFO lpInf;
|
|
BOOL bFree = FALSE;
|
|
|
|
|
|
if (lpInf = (LPINFINFO)hInf) {
|
|
|
|
if (lpInf->hInfObj != INVALID_HANDLE_VALUE)
|
|
SetupCloseInfFile(lpInf->hInfObj);
|
|
|
|
if (lpInf->lpszInfName)
|
|
genGFree(lpInf->lpszInfName, genGSize(lpInf->lpszInfName));
|
|
|
|
if (lpInf->lpszFrnName)
|
|
genGFree(lpInf->lpszFrnName, genGSize(lpInf->lpszFrnName));
|
|
|
|
if (lpInf->lpszDrvName)
|
|
genGFree(lpInf->lpszDrvName, genGSize(lpInf->lpszDrvName));
|
|
|
|
if (lpInf->lpszDrvPath)
|
|
genGFree(lpInf->lpszDrvPath, genGSize(lpInf->lpszDrvPath));
|
|
|
|
if (lpInf->lpszDstName)
|
|
genGFree(lpInf->lpszDstName, genGSize(lpInf->lpszDstName));
|
|
|
|
if (lpInf->lpszDstPath)
|
|
genGFree(lpInf->lpszDstPath, genGSize(lpInf->lpszDstPath));
|
|
|
|
if (lpInf->lpszPrtName)
|
|
genGFree(lpInf->lpszPrtName, genGSize(lpInf->lpszPrtName));
|
|
|
|
if (lpInf->lpszShrName)
|
|
genGFree(lpInf->lpszShrName, genGSize(lpInf->lpszShrName));
|
|
|
|
if (lpInf->lpInfItems)
|
|
genGFree(lpInf->lpInfItems, genGSize(lpInf->lpInfItems));
|
|
|
|
bFree = genGFree(lpInf, sizeof(INFINFO));
|
|
}
|
|
|
|
return bFree;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* infEnumItems
|
|
*
|
|
* Enumerates the file-items in the INF object. Enumeration will stop if the
|
|
* user-callback returns FALSE. Otherwise, it will exhaust all files in the
|
|
* list.
|
|
*
|
|
\*****************************************************************************/
|
|
BOOL infEnumItems(
|
|
HANDLE hInf,
|
|
INFENUMPROC pfnEnum,
|
|
LPVOID lpvData)
|
|
{
|
|
LPINFINFO lpInf;
|
|
LPINFITEMINFO lpII;
|
|
DWORD dwItems;
|
|
DWORD idx;
|
|
BOOL bRet = FALSE;
|
|
|
|
|
|
if ((lpInf = (LPINFINFO)hInf) && (dwItems = lpInf->lpInfItems->dwCount)) {
|
|
|
|
for (idx = 0, lpII = lpInf->lpInfItems; idx < dwItems; idx++) {
|
|
|
|
bRet = (*pfnEnum)(lpII->aItems[idx].szName,
|
|
lpII->aItems[idx].szPath,
|
|
lpII->aItems[idx].bInf,
|
|
lpvData);
|
|
|
|
if (bRet == FALSE)
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* infGetEnvArch
|
|
*
|
|
* Returns the platform/environment type identifier.
|
|
*
|
|
\*****************************************************************************/
|
|
WORD infGetEnvArch(
|
|
HANDLE hInf)
|
|
{
|
|
LPINFINFO lpInf;
|
|
WORD wType = PROCESSOR_ARCHITECTURE_UNKNOWN;
|
|
|
|
|
|
if (lpInf = (LPINFINFO)hInf)
|
|
wType = genValCliArchitecture(lpInf->idxPlt);
|
|
|
|
return wType;
|
|
}
|
|
|
|
|
|
/*****************************************************************************\
|
|
* infGetEnvArchCurr
|
|
*
|
|
* Returns the platform/environment type for the current-architecture.
|
|
*
|
|
\*****************************************************************************/
|
|
WORD infGetEnvArchCurr(
|
|
HANDLE hInf)
|
|
{
|
|
return genValSvrArchitecture();
|
|
}
|