//=======================================================================
//
//  Copyright (c) 1998-1999 Microsoft Corporation.  All Rights Reserved.
//
//  File:   DrvInfo.cpp
//
//  Owner:  YanL
//
//  Description:
//
//      Implementation of device enumeration
//
//=======================================================================

#include <windows.h>
#include <setupapi.h>
#include <shlwapi.h>
#include <regstr.h>
#include <devguid.h>
#include <tchar.h>
//#include <atlconv.h>

#include <wustl.h>
#include <DrvInfo.h>
#define LOGGING_LEVEL 2
#include <log.h>

#include "cdmlibp.h"

#define DEVICE_INSTANCE_SIZE    128

//*********************************************************************************//
// Global UNICODE<>ANSI translation helpers
//*********************************************************************************//

#include <malloc.h>	// for _alloca


#define USES_CONVERSION int _convert = 0; _convert; UINT _acp = CP_ACP; _acp; LPCWSTR _lpw = NULL; _lpw; LPCSTR _lpa = NULL; _lpa

inline LPWSTR WINAPI AtlA2WHelper(LPWSTR lpw, LPCSTR lpa, int nChars, UINT acp)
{
	//
	// verify that no illegal character present
	// since lpw was allocated based on the size of lpa
	// don't worry about the number of chars
	//
	lpw[0] = '\0';
	MultiByteToWideChar(acp, 0, lpa, -1, lpw, nChars);
	return lpw;
}

inline LPSTR WINAPI AtlW2AHelper(LPSTR lpa, LPCWSTR lpw, int nChars, UINT acp)
{
	//
	// verify that no illegal character present
	// since lpa was allocated based on the size of lpw
	// don't worry about the number of chars
	//
	lpa[0] = '\0';
	WideCharToMultiByte(acp, 0, lpw, -1, lpa, nChars, NULL, NULL);
	return lpa;
}

#define A2W(lpa) (\
		((_lpa = lpa) == NULL) ? NULL : (\
			_convert = (lstrlenA(_lpa)+1),\
			AtlA2WHelper((LPWSTR)_alloca(_convert*2), _lpa, _convert, CP_ACP)))

#define W2A(lpw) (\
		((_lpw = lpw) == NULL) ? NULL : (\
			_convert = (lstrlenW(_lpw)+1)*2,\
			AtlW2AHelper((LPSTR)_alloca(_convert), _lpw, _convert, CP_ACP)))
#define A2CW(lpa) ((LPCWSTR)A2W(lpa))
#define W2CA(lpw) ((LPCSTR)W2A(lpw))
#ifdef _UNICODE
	#define T2A W2A
	#define A2T A2W
	inline LPWSTR T2W(LPTSTR lp) { return lp; }
	inline LPTSTR W2T(LPWSTR lp) { return lp; }
	#define T2CA W2CA
	#define A2CT A2CW
	inline LPCWSTR T2CW(LPCTSTR lp) { return lp; }
	inline LPCTSTR W2CT(LPCWSTR lp) { return lp; }
#else
	#define T2W A2W
	#define W2T W2A
	inline LPSTR T2A(LPTSTR lp) { return lp; }
	inline LPTSTR A2T(LPSTR lp) { return lp; }
	#define T2CW A2CW
	#define W2CT W2CA
	inline LPCSTR T2CA(LPCTSTR lp) { return lp; }
	inline LPCTSTR A2CT(LPCSTR lp) { return lp; }
#endif
#define OLE2T(p) W2T(p)
#define T2OLE(p) T2W(p)

#ifdef _WUV3TEST

// Check the registry to see if we have been called to fake
static bool FakeDetection()
{
	auto_hkey hkey;
	DWORD dwFake = 0;
	DWORD dwSize = sizeof(dwFake);
	if (NO_ERROR == RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGKEY_WUV3TEST, 0, KEY_READ, &hkey)) {
		RegQueryValueEx(hkey, _T("UseIni"), 0, 0, (LPBYTE)&dwFake, &dwSize);
	}
	return 1 == dwFake;
}

#endif

static bool CanOpenInf(LPCTSTR szInfFile);
static bool DriverVerFromInf(LPCTSTR szInfFile, LPCTSTR szMfg, LPCTSTR szDesc, LPTSTR szValue/*size_is(256)*/);
static bool IsOriginalFile(LPCTSTR szInfFile);


// Implementation that gets real devices quering DevMan
class CRealDrvInfo : public IDrvInfo
{
protected:
	tchar_buffer m_sDevInstID;
	auto_hdevinfo m_hDevInfo;
	SP_DEVINFO_DATA m_DevInfoData;
	FILETIME m_ftDriverDate;

protected:
	bool GetPropertySetupDi(ULONG ulProperty, tchar_buffer& bufHardwareIDs);
	bool GetPropertyReg(LPCTSTR szProperty, tchar_buffer& bufHardwareIDs);
	bool LatestDriverFileTime(LPCTSTR szInfFile, LPCTSTR szMfgName, LPCTSTR szDescription, 
		LPCTSTR szProvider, FILETIME& ftDate);

	virtual bool Init(LPCTSTR szDevInstID)
	{
		LOG_block("CRealDrvInfo::Init");
		LOG_out("[%s]", szDevInstID);

		m_hDevInfo = (HDEVINFO)SetupDiCreateDeviceInfoList(NULL, NULL);
		return_if_false(m_hDevInfo.valid()) ;

		ZeroMemory(&m_DevInfoData, sizeof(SP_DEVINFO_DATA));

		m_DevInfoData.cbSize = sizeof(SP_DEVINFO_DATA);

		return_if_false(SetupDiOpenDeviceInfo(m_hDevInfo, szDevInstID, 0, 0, &m_DevInfoData)) ;

		m_sDevInstID.resize(lstrlen(szDevInstID) + 1);
		if (!m_sDevInstID.valid()) return false;
		lstrcpy(m_sDevInstID, szDevInstID);
		m_ftDriverDate.dwHighDateTime = -1;
		return true;
	}

public:
	virtual bool GetDeviceInstanceID(tchar_buffer& bufDeviceInstanceID) 
	{
		bufDeviceInstanceID.resize(m_sDevInstID.size());
		if (!bufDeviceInstanceID.valid()) return false;
		lstrcpy(bufDeviceInstanceID, m_sDevInstID);
		return true;
	}
	virtual bool HasDriver()
	{
		tchar_buffer bufDriver;
		return GetPropertySetupDi(SPDRP_DRIVER, bufDriver);
	}
	virtual bool IsPrinter()
	{
		return IsEqualGUID(m_DevInfoData.ClassGuid, GUID_DEVCLASS_PRINTER) ? true : false;
	}
	virtual bool GetAllHardwareIDs(tchar_buffer& bufHardwareIDs);
	virtual bool GetHardwareIDs(tchar_buffer& bufHardwareIDs)
	{
		return GetPropertySetupDi(SPDRP_HARDWAREID, bufHardwareIDs);
	}
	virtual bool GetCompatIDs(tchar_buffer& bufHardwareIDs)
	{
		return GetPropertySetupDi(SPDRP_COMPATIBLEIDS, bufHardwareIDs);
	}

	virtual bool GetMatchingDeviceId(tchar_buffer& bufMatchingDeviceId)
	{
		return GetPropertyReg(REGSTR_VAL_MATCHINGDEVID, bufMatchingDeviceId);
	}
	virtual bool GetManufacturer(tchar_buffer& bufMfg)
	{
		return GetPropertySetupDi(SPDRP_MFG, bufMfg);
	}
	virtual bool GetProvider(tchar_buffer& bufProvider)
	{
		return GetPropertyReg(REGSTR_VAL_PROVIDER_NAME, bufProvider);
	}
	virtual bool GetDescription(tchar_buffer& bufDescription)
	{
		return GetPropertySetupDi(SPDRP_DEVICEDESC, bufDescription);
	}
	virtual bool GetDriverDate(FILETIME& ftDriverDate);
};

#ifdef _WUV3TEST

// Implementation that gets fake devices from wuv3test.ini
class CFakeDrvInfo : public IDrvInfo
{
protected:
	TCHAR m_szDevInstID[MAX_PATH];

protected:
	bool GetString(LPCTSTR szKeyName, tchar_buffer& buf)
	{
		buf.resize(256);
		if (!buf.valid()) return 0;
		return 0 != GetPrivateProfileString(m_szDevInstID, szKeyName, _T(""), buf, 256 / sizeof(TCHAR), _T("wuv3test.ini"));
	}
	virtual bool Init(LPCTSTR szDevInstID)
	{
		lstrcpy(m_szDevInstID, szDevInstID);
		// Lets see if this section exists at all
		tchar_buffer buf;
		return GetString(NULL, buf);
	}

public:
	virtual bool GetDeviceInstanceID(tchar_buffer& bufDeviceInstanceID) 
	{
		bufDeviceInstanceID.resize(lstrlen(m_szDevInstID) + 1);
		if (!bufDeviceInstanceID.valid()) return false;
		lstrcpy(bufDeviceInstanceID, m_szDevInstID);
		return true;
	}
	virtual bool HasDriver()
	{
		tchar_buffer bufMfg;
		return GetString(_T("Manufacturer"), bufMfg);
	}
	virtual bool IsPrinter()
	{
		return false;
	}
	virtual bool GetAllHardwareIDs(tchar_buffer& bufHardwareIDs)
	{
		return GetHardwareIDs(bufHardwareIDs);
	}
	virtual bool GetHardwareIDs(tchar_buffer& bufHardwareIDs)
	{
		return GetString(_T("HardwareIDs"), bufHardwareIDs);
	}
	virtual bool GetCompatIDs(tchar_buffer& bufHardwareIDs)
	{
		return false;
	}
	virtual bool GetMatchingDeviceId(tchar_buffer& bufMatchingDeviceId)
	{
		return GetString(_T("MatchingDeviceId"), bufMatchingDeviceId);
	}
	virtual bool GetManufacturer(tchar_buffer& bufMfg)
	{
		return GetString(_T("Manufacturer"), bufMfg);
	}
	virtual bool GetProvider(tchar_buffer& bufMfg)
	{
		return GetString(_T("Provider"), bufMfg);
	}
	virtual bool GetDescription(tchar_buffer& bufDescription)
	{
		return GetString(_T("Description"), bufDescription);
	}
	virtual bool GetDriverDate(FILETIME& ftDriverDate)
	{
		tchar_buffer bufDriverDate;
		if (!GetString(_T("DriverDate"), bufDriverDate))
			return false;
		return DriverVer2FILETIME(bufDriverDate, ftDriverDate);
	}
};
#endif

// 
// CDrvInfoEnum not inline implementation
// 
bool CDrvInfoEnum::GetDrvInfo(LPCWSTR wszDevInstID, IDrvInfo** ppDrvInfo)
{
	LOG_block("CDrvInfoEnum::GetDrvInfo");

	USES_CONVERSION;

	auto_pointer<IDrvInfo> pDrvInfo;

#ifdef _WUV3TEST
	if ( FakeDetection())
		pDrvInfo = new CFakeDrvInfo;
	else 
#endif
		pDrvInfo = new CRealDrvInfo;

	return_if_false(pDrvInfo.valid());

	return_if_false(pDrvInfo->Init(W2T(const_cast<WCHAR*>(wszDevInstID))));

	*ppDrvInfo = pDrvInfo.detach();
	return true;
}

CDrvInfoEnum::CDrvInfoEnum()
	: m_dwDeviceIndex(0)
{
#ifdef _WUV3TEST
	if (! FakeDetection())
#endif
		m_hDevInfoSet = SetupDiGetClassDevs(NULL, NULL, NULL, DIGCF_PRESENT | DIGCF_ALLCLASSES);
}

bool CDrvInfoEnum::GetNextDrvInfo(IDrvInfo** ppDrvInfo)
{
	LOG_block("CDrvInfoEnum::GetNextDrvInfo");

	auto_pointer<IDrvInfo> pDrvInfo;
	TCHAR szDevInstID[DEVICE_INSTANCE_SIZE];
	if (m_hDevInfoSet.valid()) // real
	{
		SP_DEVINFO_DATA DevInfoData;
		memset(&DevInfoData, 0, sizeof(SP_DEVINFO_DATA));
		DevInfoData.cbSize = sizeof(SP_DEVINFO_DATA);

		return_if_false(SetupDiEnumDeviceInfo(m_hDevInfoSet, m_dwDeviceIndex, &DevInfoData));

		return_if_false(SetupDiGetDeviceInstanceId(m_hDevInfoSet, &DevInfoData, szDevInstID, sizeof(szDevInstID)/sizeof(szDevInstID[0]), NULL));
		
		pDrvInfo = new CRealDrvInfo;
	}
#ifdef _WUV3TEST
	else // fake
	{
		wsprintf(szDevInstID, _T("Device%d"), (int)m_dwDeviceIndex);
		pDrvInfo = new CFakeDrvInfo;
	}
#endif
	return_if_false(pDrvInfo.valid());
	return_if_false(pDrvInfo->Init(szDevInstID));
	
	m_dwDeviceIndex ++;
	*ppDrvInfo = pDrvInfo.detach();
	return true;
}

// 
// CRealDrvInfo not inline implementation
// 
bool CRealDrvInfo::GetAllHardwareIDs(tchar_buffer& bufHardwareIDs)
{
	if (!GetHardwareIDs(bufHardwareIDs))
		return false;
	tchar_buffer bufCompatIDs;
	if (!GetCompatIDs(bufCompatIDs))
		return true; // no campats

	// find \0\0 in the first buffer
	for (LPTSTR sz = bufHardwareIDs; *sz; sz += lstrlen(sz) + 1);
	int cnOldSize = sz - (LPCTSTR)bufHardwareIDs;
	// NTBUG9#145086 size was increased by byte rather than sizeof(TCHAR)
	bufHardwareIDs.resize(cnOldSize + ((bufCompatIDs.size() + 1) * sizeof(TCHAR))); // I've found a case where there are no \0\0 at the end of compat ID
	sz = bufHardwareIDs; sz += cnOldSize;
	// NTBUG9#145086 size is # chars rather than bytes
	memcpy(sz, bufCompatIDs, bufCompatIDs.size() * sizeof(TCHAR));
	sz[bufCompatIDs.size()] = 0;
	return true;
}

bool CRealDrvInfo::GetDriverDate(FILETIME& ftDriverDate)
{
	LOG_block("CRealDrvInfo::GetDriverDate");

	if (-1 == m_ftDriverDate.dwHighDateTime)
	{
		OSVERSIONINFO	osvi;
		osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
		GetVersionEx(&osvi);

		// Check if we are on new or old schema
		bool fNew =  osvi.dwPlatformId == VER_PLATFORM_WIN32_NT || osvi.dwMajorVersion > 4 || osvi.dwMinorVersion >= 90;
		if (fNew)
		{
			// DriverVer has to be present on NT
			tchar_buffer bufDriverDate;
			return_if_false(GetPropertyReg(REGSTR_VAL_DRIVERDATE, bufDriverDate));
			return_if_false(DriverVer2FILETIME(bufDriverDate, m_ftDriverDate));
		}
		else
		{
			// Get INF File first
			tchar_buffer bufInf;
			return_if_false(GetPropertyReg(REGSTR_VAL_INFPATH, bufInf));

			if (IsOriginalFile(bufInf))
			{
				// on of the original OS drivers
				ZeroMemory(&m_ftDriverDate, sizeof(m_ftDriverDate));
			}
			else
			{
				tchar_buffer bufMfg;
				return_if_false(GetManufacturer(bufMfg));
				tchar_buffer bufDescription;
				return_if_false(GetDescription(bufDescription));
				
				TCHAR szInf[MAX_PATH]; // %systemroot%\inf\other\foo.inf or %systemroot%\inf\foo.inf
				GetWindowsDirectory(szInf, sizeOfArray(szInf));
				PathAppend(szInf, _T("inf\\other"));
				PathAppend(szInf, bufInf);
				if (!CanOpenInf(szInf))
				{
					GetWindowsDirectory(szInf, sizeOfArray(szInf));
					PathAppend(szInf, _T("inf"));
					PathAppend(szInf, bufInf);
					if (!CanOpenInf(szInf))
					{
						LOG_error("Cannot find %s", (LPCTSTR)bufInf);
						return false;
					}
				}
				
				// first try to get it from inf
				tchar_buffer bufDriverDate(256);
				if (DriverVerFromInf(szInf, bufMfg, bufDescription, bufDriverDate))
				{
					return_if_false(DriverVer2FILETIME(bufDriverDate, m_ftDriverDate))
				}
				else // enum files not
				{
					tchar_buffer bufProvider;
					if (!GetProvider(bufProvider))
					{
						bufProvider.resize(1);
						return_if_false(bufProvider.valid());
						lstrcpy(bufProvider, _T(""));
					}
					return_if_false(LatestDriverFileTime(szInf, bufMfg, bufDescription, bufProvider, m_ftDriverDate));
				}
			}
		}

	}
	ftDriverDate = m_ftDriverDate;
	return true;


}

bool CRealDrvInfo::GetPropertySetupDi(ULONG ulProperty, tchar_buffer& buf)
{
	LOG_block("CRealDrvInfo::GetPropertySetupDi");

	ULONG ulSize = 0;
	SetupDiGetDeviceRegistryProperty(m_hDevInfo, &m_DevInfoData, ulProperty, NULL, NULL, 0, &ulSize);
	return_if_false(0 != ulSize);
    // Win98 has a bug when requesting SPDRP_HARDWAREID
    // NTBUG9#182680 We make this big enough to always have a Unicode double-null at the end
    // so that we don't fault if the reg value isn't correctly terminated
	ulSize += 4; 
	buf.resize(ulSize/sizeof(TCHAR));
    buf.zero_buffer(); // NTBUG9#182680 zero the buffer so we don't get random garbage - REG_MULTI_SZ isn't always double-null terminated
	return_if_false(buf.valid());

	return_if_false(SetupDiGetDeviceRegistryProperty(m_hDevInfo, &m_DevInfoData, ulProperty, NULL, (LPBYTE)(LPTSTR)buf, ulSize - 4 , NULL));
	return true;
}

bool CRealDrvInfo::GetPropertyReg(LPCTSTR szProperty, tchar_buffer& buf)
{
	LOG_block("CRealDrvInfo::GetPropertyReg");

	//Open the device's driver key and retrieve the INF from which the driver was installed.
	auto_hkeySetupDi hKey = SetupDiOpenDevRegKey(m_hDevInfo, &m_DevInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DRV, KEY_READ);
	return_if_false(hKey.valid());
	
	ULONG ulSize = 0;
	RegQueryValueEx(hKey, szProperty, NULL, NULL, NULL, &ulSize);
	return_if_false(0 != ulSize);
	buf.resize(ulSize/sizeof(TCHAR));
	return_if_false(buf.valid());
	return_if_false( NO_ERROR == RegQueryValueEx(hKey, szProperty, NULL, NULL, (LPBYTE)(LPTSTR)buf, &ulSize));
	return true;
}

inline bool IsDriver(LPCTSTR szFile)
{
	LPCTSTR szExt = PathFindExtension(szFile);
	if (NULL == szExt)
	{
		return FALSE;
	}

	static const TCHAR* aszExt[] = {
		_T(".sys"),
		_T(".dll"),
		_T(".drv"),
		_T(".vxd"),
	};
	for(int i = 0; i < sizeOfArray(aszExt); i ++)
	{
		if(0 == lstrcmpi(aszExt[i], szExt))
			return true;
	}
	return false;
}

static UINT CALLBACK FileQueueScanCallback(
	IN PVOID pContext,			// setup api context
	IN UINT ulNotification,		// notification message
	IN UINT_PTR ulParam1,				// extra notification message information 1
	IN UINT_PTR /*Param2*/			// extra notification message information 2
) {
	if (SPFILENOTIFY_QUEUESCAN == ulNotification)
	{
		PFILETIME pftDateLatest = (PFILETIME)pContext;
		LPCTSTR szFile = (LPCTSTR)ulParam1; 
		// Is this a binary
		if (IsDriver(szFile)) 
		{
			auto_hfile hFile = CreateFile(szFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
			FILETIME ft;
			if (hFile.valid() && GetFileTime(hFile, NULL, NULL, &ft))
			{
//				#ifdef _WUV3TEST
					SYSTEMTIME st;
 					FileTimeToSystemTime(&ft, &st);
					LOG_out1("%s : %2d/%02d/%04d", szFile, (int)st.wMonth, (int)st.wDay, (int)st.wYear);
//				#endif
				if (CompareFileTime(pftDateLatest, &ft) < 0)
					*pftDateLatest = ft;

			}
		}
		else
		{
			LOG_out1("%s : not a driver", szFile);
		}
	}
	return NO_ERROR;
}

bool CRealDrvInfo::LatestDriverFileTime(
	LPCTSTR szInfFile, LPCTSTR szMfgName, LPCTSTR szDescription, LPCTSTR szProvider, FILETIME& ftDate
) {
	LOG_block("CRealDrvInfo::LatestDriverFileTime");

	SP_DEVINSTALL_PARAMS	DeviceInstallParams;
	DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
	return_if_false(SetupDiGetDeviceInstallParams(m_hDevInfo, &m_DevInfoData, &DeviceInstallParams));
	
	lstrcpy(DeviceInstallParams.DriverPath, szInfFile);
	DeviceInstallParams.Flags |= DI_ENUMSINGLEINF;

	return_if_false(SetupDiSetDeviceInstallParams(m_hDevInfo, &m_DevInfoData, &DeviceInstallParams));

	//Now build a class driver list from this INF.
	return_if_false(SetupDiBuildDriverInfoList(m_hDevInfo, &m_DevInfoData, SPDIT_CLASSDRIVER));

	//Prepare driver info struct
	SP_DRVINFO_DATA	DriverInfoData;
	ZeroMemory(&DriverInfoData, sizeof(DriverInfoData));
	DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA_V1); // 98
	DriverInfoData.DriverType	= SPDIT_CLASSDRIVER;
	DriverInfoData.Reserved	= 0;

	lstrcpyn(DriverInfoData.MfgName, szMfgName, LINE_LEN-1);
	lstrcpyn(DriverInfoData.Description, szDescription, LINE_LEN-1);
	lstrcpyn(DriverInfoData.ProviderName, szProvider, LINE_LEN-1);

	return_if_false(SetupDiSetSelectedDriver(m_hDevInfo, &m_DevInfoData, (SP_DRVINFO_DATA*)&DriverInfoData));

	auto_hspfileq hspfileq = SetupOpenFileQueue();
	return_if_false(hspfileq.valid());

	// Set custom queue to device installl params
	return_if_false(SetupDiGetDeviceInstallParams(m_hDevInfo, &m_DevInfoData, &DeviceInstallParams));

	DeviceInstallParams.FileQueue	 = hspfileq;
	DeviceInstallParams.Flags		|= DI_NOVCP;

	return_if_false(SetupDiSetDeviceInstallParams(m_hDevInfo, &m_DevInfoData, &DeviceInstallParams));

	return_if_false(SetupDiInstallDriverFiles(m_hDevInfo, &m_DevInfoData));
	
	// Parce the queue
	FILETIME ftDateTmp = {0,0};
	DWORD dwScanResult;
	return_if_false(SetupScanFileQueue(hspfileq, SPQ_SCAN_USE_CALLBACK, NULL, (PSP_FILE_CALLBACK)FileQueueScanCallback, &ftDateTmp, &dwScanResult));

//#ifdef _WUV3TEST
	SYSTEMTIME st;
 	FileTimeToSystemTime(&ftDateTmp, &st);
	LOG_out("%s - %s %2d/%02d/%04d", szMfgName, szDescription, (int)st.wMonth, (int)st.wDay, (int)st.wYear);
//#endif

	ftDate = ftDateTmp;
	return true;
}

// Date has to be in format mm-dd-yyyy or mm/dd/yyyy
bool DriverVer2FILETIME(LPCTSTR szDate, FILETIME& ftDate)
{
	LOG_block("DriverVer2FILETIME");

	LPCTSTR szMonth = szDate;
	while (*szDate && (*szDate != TEXT('-')) && (*szDate != TEXT('/')))
		szDate++;
	return_if_false(*szDate);

	LPCTSTR szDay = ++ szDate ;
	while (*szDate && (*szDate != TEXT('-')) && (*szDate != TEXT('/')))
		szDate++;
	return_if_false(*szDate);

	++ szDate; 
	SYSTEMTIME SystemTime;
	ZeroMemory(&SystemTime, sizeof(SYSTEMTIME));
	SystemTime.wMonth = (WORD)(short)StrToInt(szMonth);
	SystemTime.wDay = (WORD)(short)StrToInt(szDay);
	SystemTime.wYear = (WORD)(short)StrToInt(szDate);
	return_if_false(SystemTimeToFileTime(&SystemTime, &ftDate));
	return true;
}

static bool GetFirstStringField(HINF hInf, LPCTSTR szSection, LPCTSTR szKey, LPTSTR szValue/*size_is(256)*/)
{
	LOG_block("GetFirstStringField");

	INFCONTEXT ctx;
	return_if_false(SetupFindFirstLine(hInf, szSection, szKey, &ctx));

	return_if_false(SetupGetStringField(&ctx, 1, szValue, 256, NULL));	//Driver section

	return true;
}

static inline bool DriverVerFromInfInstallSection(HINF hInf, LPCTSTR szMfg, LPCTSTR szDesc, LPTSTR szValue/*size_is(256)*/)
{
	LOG_block("DriverVerFromInfInstallSection");
	TCHAR szDeviceSec[256];
	return_if_false(GetFirstStringField(hInf, _T("Manufacturer"), szMfg, szDeviceSec));	// Driver section

	TCHAR szInstallSec[256];
	return_if_false(GetFirstStringField(hInf, szDeviceSec, szDesc, szInstallSec));	// Install section

	return_if_false(GetFirstStringField(hInf, szInstallSec, _T("DriverVer"), szValue));	// DriverVer
	return true;
}

static bool CanOpenInf(LPCTSTR szInfFile)
{
	auto_hinf hInf = SetupOpenInfFile(szInfFile, NULL, INF_STYLE_WIN4, NULL);
	return hInf.valid();
}

static bool DriverVerFromInf(LPCTSTR szInfFile, LPCTSTR szMfg, LPCTSTR szDesc, LPTSTR szValue/*size_is(256)*/)
{
	LOG_block("DriverVerFromInf");

	auto_hinf hInf = SetupOpenInfFile(szInfFile, NULL, INF_STYLE_WIN4, NULL);
	return_if_false(hInf.valid());
	bool fFound = DriverVerFromInfInstallSection(hInf, szMfg, szDesc, szValue) ||
		GetFirstStringField(hInf, _T("Version"), _T("DriverVer"), szValue);

//#ifdef _WUV3TEST
	// RAID# 146771
	if (fFound)
		LOG_out("DriverVerFromInf - %s, return true", szValue);
	else
		LOG_out("DriverVerFromInf, return false");
//#endif
	
	return fFound;
}

static bool IsOriginalFile(LPCTSTR szInfFile)
{
	LOG_block("IsOriginalFile");
	if (0 == szInfFile || 0 == lstrlen(szInfFile))
	{
		LOG_out("empty szInfFile, return false");
	}

	// construct full title
	LPTSTR szInfTitle = PathFindFileName(szInfFile);
	const static LPCTSTR aszLayoutTitle[] = {
		_T("layout.inf"),
		_T("layout1.inf"),
		_T("layout2.inf"),
	};
	for (int i = 0; i < sizeOfArray(aszLayoutTitle); i ++)
	{
		TCHAR szLayout[MAX_PATH];
		if (! GetWindowsDirectory(szLayout, sizeOfArray(szLayout)))
		{
			lstrcat(szLayout, _T("C:\\Windows"));
		}
		PathAppend(szLayout, _T("inf"));
		PathAppend(szLayout, aszLayoutTitle[i]);
		TCHAR szDummy[16];
		if( 0 != GetPrivateProfileString(_T("SourceDisksFiles"), szInfTitle, _T(""), szDummy, sizeOfArray(szDummy), szLayout))
		{
			LOG_out("%s found in %s, return true", szInfFile, szLayout);
			return true;
		}
	}
	LOG_out("%s in not found, return false", szInfFile);
	return false;
}