767 lines
26 KiB
C
767 lines
26 KiB
C
//
|
|
// DEVNODE.C
|
|
//
|
|
#include "sigverif.h"
|
|
|
|
//
|
|
// Given the full path to a driver, add it to the file list.
|
|
//
|
|
void AddDriverFileToList(LPTSTR lpDirName, LPTSTR lpFullPathName)
|
|
{
|
|
LPFILENODE lpFileNode = NULL;
|
|
TCHAR szFullPath[MAX_PATH];
|
|
TCHAR szDirName[MAX_PATH];
|
|
TCHAR szFileName[MAX_PATH];
|
|
LPTSTR lpFilePart;
|
|
BOOL bRet;
|
|
|
|
*szFullPath = 0;
|
|
*szDirName = 0;
|
|
*szFileName = 0;
|
|
|
|
// If no directory is passed in, try to get the full path
|
|
if (!lpDirName || !*lpDirName) {
|
|
bRet = GetFullPathName(lpFullPathName, MAX_PATH, szDirName, &lpFilePart);
|
|
if (bRet) {
|
|
lstrcpy(szFullPath, szDirName);
|
|
|
|
if (lpFilePart && *lpFilePart) {
|
|
lstrcpy(szFileName, lpFilePart);
|
|
*lpFilePart = 0;
|
|
if (lstrlen(szDirName) > 3)
|
|
*(lpFilePart - 1) = 0;
|
|
}
|
|
}
|
|
} else { // Use the directory and filename that was passed in to us
|
|
// Expand out lpDirName in case there are any ".." entries
|
|
if (!GetFullPathName(lpDirName, MAX_PATH, szDirName, NULL))
|
|
lstrcpy(szDirName, lpDirName);
|
|
lstrcpy(szFileName, lpFullPathName);
|
|
}
|
|
|
|
if (*szDirName && *szFileName && !IsFileAlreadyInList(szDirName, szFileName)) {
|
|
// Create a filenode, based on the directory and filename
|
|
lpFileNode = CreateFileNode(szDirName, szFileName);
|
|
|
|
if (lpFileNode) {
|
|
InsertFileNodeIntoList(lpFileNode);
|
|
|
|
// Increment the total number of files we've found that meet the search criteria.
|
|
g_App.dwFiles++;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Some Services have "\\SystemRoot" in their ImagePath entry, so I have to
|
|
// handle that as if it were the MyGetWindowsDirectory string instead.
|
|
//
|
|
BOOL CheckPathForSystemRoot(LPTSTR lpPathName)
|
|
{
|
|
TCHAR szSystemRoot[MAX_PATH];
|
|
TCHAR szTempBuffer[MAX_PATH];
|
|
|
|
//
|
|
// Check for "\\SystemRoot" and convert to MyGetWindowsDirectory path
|
|
//
|
|
szSystemRoot[0] = 0;
|
|
MyLoadString(szSystemRoot, IDS_SYSTEMROOT);
|
|
if (!_tcsnicmp(lpPathName, szSystemRoot, lstrlen(szSystemRoot))) {
|
|
MyGetWindowsDirectory(szTempBuffer, MAX_PATH);
|
|
lstrcat(szTempBuffer, lpPathName + lstrlen(szSystemRoot));
|
|
lstrcpy(lpPathName, szTempBuffer);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void GetFilesFromInfSection(HINF hInf, LPTSTR lpFileName, LPTSTR lpSectionName)
|
|
{
|
|
TCHAR szTarget[MAX_PATH];
|
|
TCHAR szBuffer[MAX_PATH];
|
|
LPTSTR lpBuffer;
|
|
LPTSTR lpString, lpSeparator;
|
|
BOOL bRet;
|
|
DWORD dwRequiredSize;
|
|
INFCONTEXT iContext;
|
|
|
|
ZeroMemory(szTarget, sizeof(szTarget));
|
|
SetupGetTargetPath(hInf, NULL, lpSectionName, szTarget, sizeof(szTarget), NULL);
|
|
|
|
// HYDRA HACK!!!
|
|
//
|
|
// Check to see if the target is %WINDIR% and if %WINDIR% has been redirected, change it back!!
|
|
// We have the real %WINDIR% stored in g_App.szWinDir, so we can stuff that into szTarget.
|
|
// We just have to remember to put back whatever was at the end of szTarget.
|
|
//
|
|
GetWindowsDirectory(szBuffer, MAX_PATH);
|
|
if (!_tcsnicmp(szBuffer, szTarget, lstrlen(szBuffer)) && _tcsicmp(g_App.szWinDir, szBuffer)) {
|
|
lstrcpy(szBuffer, szTarget + lstrlen(szBuffer));
|
|
lstrcpy(szTarget, g_App.szWinDir);
|
|
lstrcat(szTarget, szBuffer);
|
|
}
|
|
|
|
ZeroMemory(&iContext, sizeof(INFCONTEXT));
|
|
bRet = SetupFindFirstLine(hInf, lpSectionName, NULL, &iContext);
|
|
|
|
while (bRet && !g_App.bStopScan) {
|
|
dwRequiredSize = 0;
|
|
bRet = SetupGetLineText(&iContext, NULL, NULL, NULL, NULL, 0, &dwRequiredSize);
|
|
if (dwRequiredSize) {
|
|
|
|
lpBuffer = MALLOC((dwRequiredSize + 1) * sizeof(TCHAR));
|
|
|
|
if (lpBuffer) {
|
|
|
|
bRet = SetupGetLineText(&iContext, NULL, NULL, NULL, lpBuffer, dwRequiredSize, NULL);
|
|
|
|
if (bRet) {
|
|
lpString = lpBuffer;
|
|
|
|
if (lpString && *lpString) {
|
|
// If there's a comma, then terminate the string at the comma
|
|
lpSeparator = _tcschr(lpString, TEXT(','));
|
|
if (lpSeparator) {
|
|
// Null terminate at the comma, so the first entry is a null-terminated string
|
|
*lpSeparator = 0;
|
|
}
|
|
|
|
// Make sure we didn't just terminate ourselves.
|
|
if (*lpString) {
|
|
AddDriverFileToList(szTarget, lpString);
|
|
}
|
|
}
|
|
}
|
|
|
|
FREE(lpBuffer);
|
|
}
|
|
}
|
|
|
|
bRet = SetupFindNextLine(&iContext, &iContext);
|
|
}
|
|
}
|
|
|
|
void GetStuffFromInfSection(LPTSTR lpFileName, LPTSTR lpSectionName)
|
|
{
|
|
TCHAR szFullPath[MAX_PATH];
|
|
TCHAR szTarget[MAX_PATH];
|
|
TCHAR szKeyName[MAX_PATH];
|
|
LPTSTR lpString = NULL;
|
|
LPTSTR lpSeparator = NULL;
|
|
LPTSTR lpBuffer = NULL;
|
|
DWORD dwRequiredSize;
|
|
HINF hInf;
|
|
BOOL bRet;
|
|
UINT uError;
|
|
|
|
szFullPath[0] = 0;
|
|
GetFullPathName(lpFileName, MAX_PATH, szFullPath, NULL);
|
|
|
|
//
|
|
// Try opening the INF in the usual INF directory
|
|
//
|
|
hInf = SetupOpenInfFile(szFullPath, NULL, INF_STYLE_WIN4, &uError);
|
|
if (hInf == INVALID_HANDLE_VALUE) {
|
|
//
|
|
// We didn't find it in the INF directory, so try the INF\OTHER directory.
|
|
//
|
|
MyLoadString(szKeyName, IDS_OTHER);
|
|
lstrcat(szKeyName, lpFileName);
|
|
GetFullPathName(szKeyName, MAX_PATH, szFullPath, NULL);
|
|
|
|
hInf = SetupOpenInfFile(szFullPath, NULL, INF_STYLE_WIN4, &uError);
|
|
if (hInf == INVALID_HANDLE_VALUE) {
|
|
// Add the INF to the file list so it shows up as unscanned.
|
|
AddDriverFileToList(NULL, lpFileName);
|
|
return;
|
|
}
|
|
// The INF must exist, so add it to the file list for verification!
|
|
AddDriverFileToList(NULL, szFullPath);
|
|
} else {
|
|
// The INF must exist, so add it to the file list for verification!
|
|
AddDriverFileToList(NULL, szFullPath);
|
|
}
|
|
|
|
MyLoadString(szKeyName, IDS_COPYFILES);
|
|
dwRequiredSize = 0;
|
|
bRet = SetupGetLineText(NULL, hInf, lpSectionName, szKeyName, NULL, 0, &dwRequiredSize);
|
|
if (dwRequiredSize) {
|
|
|
|
lpBuffer = MALLOC((dwRequiredSize + 1) * sizeof(TCHAR));
|
|
|
|
if (lpBuffer) {
|
|
|
|
bRet = SetupGetLineText(NULL, hInf, lpSectionName, szKeyName, lpBuffer, dwRequiredSize, NULL);
|
|
if (!bRet) {
|
|
//MyMessageBox(TEXT("SetupGetLineText Failed!"));
|
|
FREE(lpBuffer);
|
|
return;
|
|
}
|
|
}
|
|
|
|
lpString = lpBuffer;
|
|
}
|
|
|
|
ZeroMemory(szTarget, sizeof(szTarget));
|
|
SetupGetTargetPath(hInf, NULL, lpSectionName, szTarget, sizeof(szTarget), NULL);
|
|
|
|
while (lpString && *lpString && !g_App.bStopScan) {
|
|
// If there's a comma, then bump lpSeparator to after the comma
|
|
lpSeparator = _tcschr(lpString, TEXT(','));
|
|
if (lpSeparator) {
|
|
// Null terminate at the comma, so the first entry is a null-terminated string
|
|
*lpSeparator = 0;
|
|
lpSeparator++;
|
|
}
|
|
|
|
//
|
|
// If the section has an '@' symbol, then it is directly referencing a filename
|
|
// Otherwise, it's a section and we need to process that via GetFilesFromInfSection()
|
|
//
|
|
if (*lpString == TEXT('@')) {
|
|
lpString++;
|
|
if (*lpString) {
|
|
AddDriverFileToList(szTarget, lpString);
|
|
}
|
|
} else GetFilesFromInfSection(hInf, lpFileName, lpString);
|
|
|
|
lpString = lpSeparator;
|
|
}
|
|
|
|
if (lpBuffer) {
|
|
|
|
FREE(lpBuffer);
|
|
}
|
|
|
|
SetupCloseInfFile(hInf);
|
|
}
|
|
|
|
void FillDeviceStatus(PDEVICETREE DeviceTree, PDEVTREENODE DeviceTreeNode)
|
|
{
|
|
DEVINST DeviceInstance = DeviceTreeNode->DevInst;
|
|
TCHAR LineBuffer[MAX_PATH*2];
|
|
TCHAR szBuffer[MAX_PATH];
|
|
TCHAR szBuffer2[MAX_PATH];
|
|
TCHAR szRegBuffer[MAX_PATH];
|
|
HKEY hServiceKey;
|
|
DWORD dwType, dwSize;
|
|
LONG lRet;
|
|
CONFIGRET ConfigRet;
|
|
|
|
ZeroMemory(szBuffer, sizeof(szBuffer));
|
|
dwSize = sizeof(szBuffer);
|
|
ConfigRet = CM_Get_DevNode_Registry_Property_Ex(DeviceInstance,
|
|
CM_DRP_CLASS,
|
|
NULL,
|
|
(PVOID)szBuffer,
|
|
&dwSize,
|
|
0,
|
|
NULL);
|
|
//
|
|
// We don't want to pick up PNP printers, since we get their drivers from
|
|
// EnumPrinterDrivers (and NTPRINT.INF has a DestinationID of 66000)
|
|
//
|
|
if (!lstrcmp(szBuffer, TEXT("Printer")))
|
|
return;
|
|
|
|
ZeroMemory(szBuffer, sizeof(szBuffer));
|
|
dwSize = sizeof(DeviceTreeNode->Driver);
|
|
ConfigRet = CM_Get_DevNode_Registry_Property_Ex(DeviceInstance,
|
|
CM_DRP_DRIVER,
|
|
NULL,
|
|
(PVOID)DeviceTreeNode->Driver,
|
|
&dwSize,
|
|
0,
|
|
NULL);
|
|
if (ConfigRet != CR_SUCCESS) {
|
|
MyLoadString(szBuffer, IDS_QUESTIONMARK);
|
|
}
|
|
|
|
//wsprintf(LineBuffer, TEXT("Driver: %s"), DeviceTreeNode->Driver);
|
|
//MyMessageBox(LineBuffer);
|
|
|
|
if (DeviceTreeNode->Driver && *DeviceTreeNode->Driver) {
|
|
MyLoadString(szRegBuffer, IDS_REG_CLASS);
|
|
lstrcat(szRegBuffer, DeviceTreeNode->Driver);
|
|
lRet = RegOpenKey(HKEY_LOCAL_MACHINE, szRegBuffer, &hServiceKey);
|
|
if (lRet != ERROR_SUCCESS) {
|
|
// If the NT5 registry path doesn't work, try the Win9x path.
|
|
MyLoadString(szRegBuffer, IDS_REG_CLASS2);
|
|
lstrcat(szRegBuffer, DeviceTreeNode->Driver);
|
|
lRet = RegOpenKey(HKEY_LOCAL_MACHINE, szRegBuffer, &hServiceKey);
|
|
}
|
|
if (lRet == ERROR_SUCCESS) {
|
|
//
|
|
// Get the INF file and section to determine what files get copied for this driver
|
|
//
|
|
dwSize = sizeof(szBuffer);
|
|
MyLoadString(szRegBuffer, IDS_REG_INFPATH);
|
|
lRet = RegQueryValueEx(hServiceKey, szRegBuffer, NULL, &dwType, (PVOID)szBuffer, &dwSize);
|
|
if (lRet == ERROR_SUCCESS) {
|
|
lstrcpy(LineBuffer, szBuffer);
|
|
dwSize = sizeof(szBuffer);
|
|
MyLoadString(szRegBuffer, IDS_REG_INFSECTION);
|
|
lRet = RegQueryValueEx(hServiceKey, szRegBuffer, NULL, &dwType, (PVOID)szBuffer, &dwSize);
|
|
if (lRet == ERROR_SUCCESS) {
|
|
//
|
|
// Now look for an "InfSectionExt" value, which we need to stick on the end of InfSection.
|
|
//
|
|
dwSize = sizeof(szBuffer2);
|
|
MyLoadString(szRegBuffer, IDS_REG_INFSECTIONEXT);
|
|
lRet = RegQueryValueEx(hServiceKey, szRegBuffer, NULL, &dwType, (PVOID)szBuffer2, &dwSize);
|
|
if (lRet == ERROR_SUCCESS) {
|
|
lstrcat(szBuffer, szBuffer2);
|
|
}
|
|
GetStuffFromInfSection(LineBuffer, szBuffer);
|
|
}
|
|
}
|
|
|
|
// Make sure the reg key gets closed!!
|
|
RegCloseKey(hServiceKey);
|
|
}
|
|
}
|
|
|
|
dwSize = sizeof(szBuffer);
|
|
ConfigRet = CM_Get_DevNode_Registry_Property_Ex(DeviceInstance,
|
|
CM_DRP_SERVICE,
|
|
NULL,
|
|
(PVOID)szBuffer,
|
|
&dwSize,
|
|
0,
|
|
NULL);
|
|
if (ConfigRet != CR_SUCCESS) {
|
|
MyLoadString(szBuffer, IDS_QUESTIONMARK);
|
|
}
|
|
|
|
//wsprintf(LineBuffer, TEXT("Service:\t\t%s"), szBuffer);
|
|
//MyMessageBox(LineBuffer);
|
|
|
|
if (*szBuffer) {
|
|
MyLoadString(szRegBuffer, IDS_REG_SERVICES);
|
|
lstrcat(szRegBuffer, szBuffer);
|
|
lRet = RegOpenKey(HKEY_LOCAL_MACHINE, szRegBuffer, &hServiceKey);
|
|
if (lRet == ERROR_SUCCESS) {
|
|
dwSize = sizeof(szBuffer);
|
|
MyLoadString(szRegBuffer, IDS_REG_IMAGEPATH);
|
|
lRet = RegQueryValueEx(hServiceKey, szRegBuffer, NULL, &dwType, (PVOID)szBuffer, &dwSize);
|
|
if (lRet == ERROR_SUCCESS) {
|
|
if (!CheckPathForSystemRoot(szBuffer)) {
|
|
MyGetWindowsDirectory(LineBuffer, MAX_PATH);
|
|
if (*szBuffer != TEXT('\\'))
|
|
lstrcat(LineBuffer, TEXT("\\"));
|
|
lstrcat(LineBuffer, szBuffer);
|
|
} else lstrcpy(LineBuffer, szBuffer);
|
|
|
|
// Add this file to the master lpFileList!!
|
|
AddDriverFileToList(NULL, LineBuffer);
|
|
}
|
|
|
|
// Make sure the reg key is closed!!
|
|
RegCloseKey(hServiceKey);
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL AddChildDevices(PDEVICETREE DeviceTree, PDEVTREENODE ParentNode)
|
|
{
|
|
CONFIGRET ConfigRet;
|
|
DEVINST DeviceInstance;
|
|
PDEVTREENODE pDeviceTreeNode;
|
|
DEVTREENODE DeviceTreeNode;
|
|
DWORD dwSize;
|
|
TCHAR szBuffer[MAX_PATH];
|
|
|
|
|
|
ConfigRet = CM_Get_Child_Ex(&DeviceInstance,
|
|
ParentNode->DevInst,
|
|
0,
|
|
NULL
|
|
);
|
|
|
|
while (ConfigRet == CR_SUCCESS) {
|
|
pDeviceTreeNode = NULL;
|
|
ZeroMemory(&DeviceTreeNode, sizeof(DEVTREENODE));
|
|
DeviceTreeNode.DevInst = DeviceInstance;
|
|
|
|
//
|
|
// Fetch the class, if it doesn't exist, skip it.
|
|
//
|
|
|
|
dwSize = sizeof(szBuffer);
|
|
ConfigRet = CM_Get_DevNode_Registry_Property_Ex(DeviceInstance,
|
|
CM_DRP_CLASSGUID,
|
|
NULL,
|
|
&szBuffer,
|
|
&dwSize,
|
|
0,
|
|
NULL);
|
|
|
|
pDeviceTreeNode = MALLOC(sizeof(DEVTREENODE));
|
|
|
|
if (pDeviceTreeNode) {
|
|
|
|
*pDeviceTreeNode = DeviceTreeNode;
|
|
|
|
pDeviceTreeNode->Sibling = ParentNode->Child;
|
|
ParentNode->Child = pDeviceTreeNode;
|
|
|
|
dwSize = sizeof(szBuffer);
|
|
ConfigRet = CM_Get_DevNode_Registry_Property_Ex(DeviceInstance,
|
|
CM_DRP_DEVICEDESC,
|
|
NULL,
|
|
(PVOID)szBuffer,
|
|
&dwSize,
|
|
0,
|
|
NULL);
|
|
if (ConfigRet != CR_SUCCESS) {
|
|
MyLoadString(szBuffer, IDS_UNKNOWN);
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Do Child DevNodes
|
|
//
|
|
if (pDeviceTreeNode) {
|
|
FillDeviceStatus(DeviceTree, pDeviceTreeNode);
|
|
AddChildDevices(DeviceTree, pDeviceTreeNode);
|
|
}
|
|
|
|
|
|
//
|
|
// We're done this branch, now get the next sibling ...
|
|
//
|
|
ConfigRet = CM_Get_Sibling_Ex(&DeviceInstance,
|
|
DeviceInstance,
|
|
0,
|
|
NULL);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void DestroyDeviceTree(PDEVTREENODE pDevTreeNode, PDEVTREENODE pRootNode)
|
|
{
|
|
PDEVTREENODE pTreeNode;
|
|
|
|
while (pDevTreeNode) {
|
|
if (pDevTreeNode->Child)
|
|
DestroyDeviceTree(pDevTreeNode->Child, pRootNode);
|
|
|
|
pTreeNode = pDevTreeNode->Sibling;
|
|
|
|
if (pDevTreeNode != pRootNode)
|
|
FREE(pDevTreeNode);
|
|
|
|
pDevTreeNode = pTreeNode;
|
|
}
|
|
}
|
|
|
|
void BuildDriverFileList(void)
|
|
{
|
|
CONFIGRET ConfigRet;
|
|
DEVICETREE DeviceTree;
|
|
TCHAR szBuffer[MAX_PATH];
|
|
|
|
//
|
|
// Get the root devnode.
|
|
//
|
|
ZeroMemory(&DeviceTree, sizeof(DEVICETREE));
|
|
|
|
ConfigRet = CM_Locate_DevNode_Ex(&DeviceTree.RootNode.DevInst,
|
|
NULL,
|
|
CM_LOCATE_DEVNODE_NORMAL,
|
|
NULL
|
|
);
|
|
|
|
if (ConfigRet != CR_SUCCESS) {
|
|
//MyErrorBoxId(IDS_ROOTDEVNODE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Make sure we are in the %WINDIR%\INF directory so the driver INFs get populated properly
|
|
// First we switch into the %WINDIR% directory
|
|
//
|
|
if (MyGetWindowsDirectory(szBuffer, MAX_PATH)) {
|
|
if (SetCurrentDirectory(szBuffer)) {
|
|
// Now go into the INF directory
|
|
MyLoadString(szBuffer, IDS_INFPATH);
|
|
SetCurrentDirectory(szBuffer);
|
|
}
|
|
}
|
|
|
|
AddChildDevices(&DeviceTree, &DeviceTree.RootNode);
|
|
|
|
DestroyDeviceTree(&DeviceTree.RootNode, &DeviceTree.RootNode);
|
|
}
|
|
|
|
void BuildPrinterFileList(void)
|
|
{
|
|
BOOL bRet;
|
|
DWORD dwBytesNeeded = 0;
|
|
DWORD dwDrivers = 0;
|
|
LPBYTE lpBuffer = NULL, lpTemp = NULL;
|
|
LPTSTR lpFileName;
|
|
DRIVER_INFO_3 DriverInfo;
|
|
PDRIVER_INFO_3 lpDriverInfo;
|
|
TCHAR szBuffer[MAX_PATH];
|
|
|
|
ZeroMemory(&DriverInfo, sizeof(DRIVER_INFO_3));
|
|
bRet = EnumPrinterDrivers( NULL,
|
|
SIGVERIF_PRINTER_ENV,
|
|
3,
|
|
(LPBYTE) &DriverInfo,
|
|
sizeof(DRIVER_INFO_3),
|
|
&dwBytesNeeded,
|
|
&dwDrivers);
|
|
|
|
if (!bRet && dwBytesNeeded > 0) {
|
|
|
|
lpBuffer = MALLOC(dwBytesNeeded);
|
|
|
|
//
|
|
// If we can't get any memory then just bail out of this function
|
|
//
|
|
if (!lpBuffer) {
|
|
|
|
return;
|
|
}
|
|
|
|
bRet = EnumPrinterDrivers( NULL,
|
|
SIGVERIF_PRINTER_ENV,
|
|
3,
|
|
(LPBYTE) lpBuffer,
|
|
dwBytesNeeded,
|
|
&dwBytesNeeded,
|
|
&dwDrivers);
|
|
}
|
|
|
|
//wsprintf(szBuffer, TEXT("dwBytesNeeded: %d, dwDrivers: %d"), dwBytesNeeded, dwDrivers);
|
|
//MyMessageBox(szBuffer);
|
|
|
|
if (dwDrivers > 0) {
|
|
// By default, go into the System directory, since Win9x doesn't give full paths to drivers.
|
|
GetSystemDirectory(szBuffer, MAX_PATH);
|
|
SetCurrentDirectory(szBuffer);
|
|
|
|
for (lpTemp = lpBuffer; dwDrivers > 0; dwDrivers--) {
|
|
lpDriverInfo = (PDRIVER_INFO_3) lpTemp;
|
|
if (lpDriverInfo->pName) {
|
|
if (lpDriverInfo->pDriverPath && *lpDriverInfo->pDriverPath) {
|
|
AddDriverFileToList(NULL, lpDriverInfo->pDriverPath);
|
|
}
|
|
if (lpDriverInfo->pDataFile && *lpDriverInfo->pDataFile) {
|
|
AddDriverFileToList(NULL, lpDriverInfo->pDataFile);
|
|
}
|
|
if (lpDriverInfo->pConfigFile && *lpDriverInfo->pConfigFile) {
|
|
AddDriverFileToList(NULL, lpDriverInfo->pConfigFile);
|
|
}
|
|
if (lpDriverInfo->pHelpFile && *lpDriverInfo->pHelpFile) {
|
|
AddDriverFileToList(NULL, lpDriverInfo->pHelpFile);
|
|
}
|
|
|
|
//MyMessageBox(lpDriverInfo->pName);
|
|
lpFileName = lpDriverInfo->pDependentFiles;
|
|
while (lpFileName && *lpFileName) {
|
|
AddDriverFileToList(NULL, lpFileName);
|
|
for (;*lpFileName;lpFileName++);
|
|
lpFileName++;
|
|
}
|
|
}
|
|
|
|
lpTemp += sizeof(DRIVER_INFO_3);
|
|
}
|
|
}
|
|
|
|
if (lpBuffer) {
|
|
|
|
FREE(lpBuffer);
|
|
}
|
|
}
|
|
|
|
BOOL GetBVTFileList(LPTSTR lpDirName, LPTSTR lpFileName)
|
|
{
|
|
TCHAR szBuffer[MAX_PATH];
|
|
LPTSTR lpString, lpFilePart;
|
|
|
|
//
|
|
// If the user specified the "/BVT:" switch, we want to grab the string after it
|
|
//
|
|
MyLoadString(szBuffer, IDS_BVT);
|
|
lpString = MyStrStr(GetCommandLine(), szBuffer);
|
|
if (lpString && *lpString) {
|
|
// Switch back into the original startup directory
|
|
SetCurrentDirectory(g_App.szAppDir);
|
|
|
|
lpString += lstrlen(szBuffer);
|
|
if (!EXIST(lpString)) {
|
|
//MyMessageBox(lpString);
|
|
return FALSE;
|
|
}
|
|
GetFullPathName(lpString, MAX_PATH, lpDirName, &lpFilePart);
|
|
lstrcpy(lpFileName, lpDirName);
|
|
*lpFilePart = 0;
|
|
SetCurrentDirectory(lpDirName);
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL IsNTServer(void)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
HKEY hKey;
|
|
LONG lRet;
|
|
DWORD dwSize, dwType;
|
|
TCHAR szBuffer[MAX_PATH];
|
|
TCHAR szRegBuffer[MAX_PATH];
|
|
|
|
// Open HKLM\System\CurrentControlSet\Control\ProductOptions
|
|
MyLoadString(szRegBuffer, IDS_REG_PRODUCTOPTIONS);
|
|
lRet = RegOpenKey(HKEY_LOCAL_MACHINE, szRegBuffer, &hKey);
|
|
if (lRet == ERROR_SUCCESS) {
|
|
// Now we need to query the ProductType value
|
|
ZeroMemory(szBuffer, sizeof(szBuffer));
|
|
dwSize = sizeof(szBuffer);
|
|
MyLoadString(szRegBuffer, IDS_REG_PRODUCTTYPE);
|
|
lRet = RegQueryValueEx(hKey, szRegBuffer, NULL, &dwType, (PVOID)szBuffer, &dwSize);
|
|
if (lRet == ERROR_SUCCESS) {
|
|
// Check to see if ProductType contained "ServerNT"
|
|
MyLoadString(szRegBuffer, IDS_PRODUCT_SERVER);
|
|
if (!_tcsnicmp(szRegBuffer, szBuffer, lstrlen(szRegBuffer))) {
|
|
// If so, then we want to return TRUE!
|
|
bRet = TRUE;
|
|
}
|
|
}
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
BOOL IsProcessorAlpha(void)
|
|
{
|
|
OSVERSIONINFO osinfo;
|
|
SYSTEM_INFO sysinfo;
|
|
|
|
ZeroMemory(&osinfo, sizeof(OSVERSIONINFO));
|
|
osinfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
|
|
GetVersionEx(&osinfo);
|
|
|
|
if (osinfo.dwPlatformId == VER_PLATFORM_WIN32_NT) {
|
|
ZeroMemory(&sysinfo, sizeof(SYSTEM_INFO));
|
|
GetSystemInfo(&sysinfo);
|
|
if (sysinfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_ALPHA) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void BuildCoreFileList(void)
|
|
{
|
|
LPFILENODE lpFileNode;
|
|
TCHAR szInfName[MAX_PATH];
|
|
TCHAR szSectionName[MAX_PATH];
|
|
TCHAR szBuffer[MAX_PATH];
|
|
BOOL bRet = TRUE;
|
|
|
|
// Check to see if the "/BVT:" switch was specified for a custom file list
|
|
// If so, then don't verify that the file is digitally signed.
|
|
if (GetBVTFileList(szBuffer, szInfName)) {
|
|
GetCurrentDirectory(MAX_PATH, szBuffer);
|
|
|
|
MyLoadString(szSectionName, IDS_MASTERFILELIST);
|
|
GetStuffFromInfSection(szInfName, szSectionName);
|
|
|
|
if (IsNTServer()) {
|
|
SetCurrentDirectory(szBuffer);
|
|
MyLoadString(szSectionName, IDS_SERVERFILELIST);
|
|
GetStuffFromInfSection(szInfName, szSectionName);
|
|
}
|
|
|
|
if (!IsProcessorAlpha()) {
|
|
SetCurrentDirectory(szBuffer);
|
|
MyLoadString(szSectionName, IDS_X86FILELIST);
|
|
GetStuffFromInfSection(szInfName, szSectionName);
|
|
}
|
|
} else {
|
|
// The user didn't use "/BVT:", so grab the corelist filename from our resources
|
|
// Make sure we are in the %WINDIR%\INF directory so lpFileNode gets created properly
|
|
|
|
// First switch into the %WINDIR% directory
|
|
bRet = MyGetWindowsDirectory(szBuffer, MAX_PATH);
|
|
if (bRet) {
|
|
bRet = SetCurrentDirectory(szBuffer);
|
|
if (bRet) {
|
|
// Now go into the %WINDIR%\INF directory.
|
|
MyLoadString(szBuffer, IDS_INFPATH);
|
|
bRet = SetCurrentDirectory(szBuffer);
|
|
}
|
|
}
|
|
|
|
// If we actually get into %WINDIR%\INF, then we verify the core list and party on it!
|
|
if (bRet) {
|
|
// Get the name of the INF containing the core file list
|
|
MyLoadString(szInfName, IDS_COREFILELIST);
|
|
|
|
//
|
|
// Verify that the core file list is digitally signed before using it.
|
|
//
|
|
lpFileNode = CreateFileNode(NULL, szInfName);
|
|
if (lpFileNode) {
|
|
|
|
// If we don't already have an g_App.hCatAdmin handle, acquire one.
|
|
if (g_App.hCatAdmin || CryptCATAdminAcquireContext(&g_App.hCatAdmin, NULL, 0)) {
|
|
|
|
bRet = VerifyFileNode(lpFileNode);
|
|
|
|
if (bRet) {
|
|
GetCurrentDirectory(MAX_PATH, szBuffer);
|
|
|
|
MyLoadString(szSectionName, IDS_MASTERFILELIST);
|
|
GetStuffFromInfSection(szInfName, szSectionName);
|
|
|
|
if (IsNTServer()) {
|
|
SetCurrentDirectory(szBuffer);
|
|
MyLoadString(szSectionName, IDS_SERVERFILELIST);
|
|
GetStuffFromInfSection(szInfName, szSectionName);
|
|
}
|
|
|
|
if (!IsProcessorAlpha()) {
|
|
SetCurrentDirectory(szBuffer);
|
|
MyLoadString(szSectionName, IDS_X86FILELIST);
|
|
GetStuffFromInfSection(szInfName, szSectionName);
|
|
}
|
|
}
|
|
|
|
// If we had an g_App.hCatAdmin, free it and set it to zero so we can acquire a new one in the future.
|
|
if (g_App.hCatAdmin) {
|
|
|
|
CryptCATAdminReleaseContext(g_App.hCatAdmin,0);
|
|
g_App.hCatAdmin = (HCATADMIN) NULL;
|
|
}
|
|
|
|
} else bRet = FALSE;
|
|
|
|
// Free the memory for this file node
|
|
DestroyFileNode(lpFileNode);
|
|
|
|
} else {
|
|
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bRet) {
|
|
|
|
MyErrorBoxId(IDS_COREFILELIST_NOTSIGNED);
|
|
}
|
|
}
|