windows-server-2003/enduser/windows.com/iuengine/sysspec.cpp

//=======================================================================
//
//  Copyright (c) 1998-2000 Microsoft Corporation.  All Rights Reserved.
//
//  File:   sysspec.cpp
//
//  Description:
//
//      Implementation for the GetSystemSpec() function
//
//=======================================================================

#include "iuengine.h"
#include "iuxml.h"
#include <iucommon.h>

#include <comdef.h>
#include <osdet.h>
#include <setupapi.h>
#include <regstr.h>
#include <winspool.h>	// for DRIVER_INFO_6
#include "cdmp.h"		// for GetInstalledPrinterDriverInfo()
#include <shlwapi.h>
#include <safereg.h>
#include <safefile.h>
#include <safefunc.h>
#include <wusafefn.h>





//
// Specify a V1 structure passed to SetupDiBuildDriverInfoList
// so we will work on NT4/Win9x and don't need to
// fill in the extra V2 data on Win2K up
//
#define  USE_SP_DRVINFO_DATA_V1 1

//
// Constants
//

const TCHAR SZ_WIN32_NT[] = _T("VER_PLATFORM_WIN32_NT");
const TCHAR SZ_WIN32_WINDOWS[] = _T("VER_PLATFORM_WIN32_WINDOWS");
const CHAR	SZ_GET_SYSTEM_SPEC[] = "Determining machine configuration";

#if defined(_X86_) || defined(i386)
const TCHAR SZ_PROCESSOR[] = _T("x86");
#else // defined(_IA64_) || defined(IA64)
const TCHAR SZ_PROCESSOR[] = _T("ia64");
#endif

const TCHAR SZ_SUITE_SMALLBUSINESS[] = _T("VER_SUITE_SMALLBUSINESS");
const TCHAR SZ_SUITE_ENTERPRISE[] = _T("VER_SUITE_ENTERPRISE");
const TCHAR SZ_SUITE_BACKOFFICE[] = _T("VER_SUITE_BACKOFFICE");
const TCHAR SZ_SUITE_COMMUNICATIONS[] = _T("VER_SUITE_COMMUNICATIONS");
const TCHAR SZ_SUITE_TERMINAL[] = _T("VER_SUITE_TERMINAL");
const TCHAR SZ_SUITE_SMALLBUSINESS_RESTRICTED[] = _T("VER_SUITE_SMALLBUSINESS_RESTRICTED");
const TCHAR SZ_SUITE_EMBEDDEDNT[] = _T("VER_SUITE_EMBEDDEDNT");
const TCHAR SZ_SUITE_DATACENTER[] = _T("VER_SUITE_DATACENTER");
const TCHAR SZ_SUITE_SINGLEUSERTS[] = _T("VER_SUITE_SINGLEUSERTS");
const TCHAR SZ_SUITE_PERSONAL[] = _T("VER_SUITE_PERSONAL");
const TCHAR SZ_SUITE_BLADE[] = _T("VER_SUITE_BLADE");


const TCHAR SZ_NT_WORKSTATION[] = _T("VER_NT_WORKSTATION");
const TCHAR SZ_NT_DOMAIN_CONTROLLER[] = _T("VER_NT_DOMAIN_CONTROLLER");
const TCHAR SZ_NT_SERVER[] = _T("VER_NT_SERVER");

const TCHAR SZ_AMPERSAND[] = _T("&");


const TCHAR SZ_LICDLL[]=_T("licdll.dll");

LPCSTR  lpszIVLK_GetEncPID  = (LPCSTR)227;

typedef HRESULT (WINAPI *PFUNCGetEncryptedPID)(OUT BYTE  **ppbPid,OUT DWORD *pcbPid);


//
// DriverVer in schema uses ISO 8601 prefered format (yyyy-mm-dd)
//
const TCHAR SZ_UNKNOWN_DRIVERVER[] = _T("0000-00-00");
#define SIZEOF_DRIVERVER sizeof(SZ_UNKNOWN_DRIVERVER)
#define TCHARS_IN_DRIVERVER (ARRAYSIZE(SZ_UNKNOWN_DRIVERVER) - 1)


//forward declaration for the function which gets the PID
HRESULT GetSystemPID(BSTR &bstrPID);
HRESULT BinaryToString(BYTE *lpBinary,DWORD dwLength,LPWSTR lpString,DWORD *pdwLength);

//
// Helper functions
//

HRESULT GetMultiSzDevRegProp(HDEVINFO hDevInfoSet, PSP_DEVINFO_DATA pDevInfoData, DWORD dwProperty, LPTSTR* ppMultiSZ)
{
	LOG_Block("GetMultiSzDevRegProp");

	HRESULT hr = S_OK;
	ULONG ulSize = 0;

	if (INVALID_HANDLE_VALUE == hDevInfoSet || NULL == pDevInfoData || NULL == ppMultiSZ)
	{
		LOG_ErrorMsg(E_INVALIDARG);
		return E_INVALIDARG;
	}

	*ppMultiSZ = NULL;

	//
	// Several different errors may be set depending on the size/existance of the property,
	// but these aren't errors for us, we only care about filling in the buffer if the
	// property exists
	//
	(void) SetupDiGetDeviceRegistryProperty(hDevInfoSet, pDevInfoData, dwProperty, NULL, NULL, 0, &ulSize);

	if (0 < ulSize)
	{
		//
		// Create a zero initialized buffer 4 bytes (two Unicode characters) longer than we think we need
		// to protect ourselves from incorrect results returned by SetupDiGetDeviceRegistryProperties on
		// some platforms. In addition, Win98 requires at least one character more than what it returned
		// in ulSize, so we just make it 8 bytes over and pass four of them as an extra-sized buffer.
		//
		CleanUpFailedAllocSetHrMsg(*ppMultiSZ = (TCHAR*) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ulSize + 8));

		//
		// Get the actual hardware/compatible IDs (but don't tell SetupDiXxx about the extra four bytes of buffer)
		//
		if (!SetupDiGetDeviceRegistryProperty(hDevInfoSet, pDevInfoData, dwProperty, NULL, (LPBYTE) *ppMultiSZ, ulSize + 4, NULL))
		{
			DWORD dwError = GetLastError();
			LOG_Driver(_T("Informational: SetupDiGetDeviceRegistryProperty failed: 0x%08x"), dwError);
			if (ERROR_NO_SUCH_DEVINST == dwError || ERROR_INVALID_REG_PROPERTY == dwError || ERROR_INSUFFICIENT_BUFFER == dwError)
			{
				//
				// Return valid errors
				//
				SetHrAndGotoCleanUp(HRESULT_FROM_WIN32(dwError));
			}
			//
			// Some devices don't have the registry info we are looking for, so exit with default S_OK
			//
			goto CleanUp;
		}
	}

CleanUp:

	if (FAILED(hr))
	{
		SafeHeapFree(*ppMultiSZ);
	}

	return hr;
}

HRESULT AddIDToXml(LPCTSTR pszMultiSZ, CXmlSystemSpec& xmlSpec, DWORD dwProperty,
						  DWORD& dwRank, HANDLE_NODE& hDevices, LPCTSTR pszMatchingID, LPCTSTR pszDriverVer)
{
	LOG_Block("AddIDToXml");
	HRESULT hr = S_OK;
	BSTR bstrMultiSZ = NULL;
	BSTR bstrDriverVer = NULL;

	if (NULL == pszMultiSZ)
	{
		LOG_ErrorMsg(E_INVALIDARG);
		return E_INVALIDARG;
	}

	//
	// Open a <device> element if necessary (don't reopen for compatible IDs)
	//
	if (HANDLE_NODE_INVALID == hDevices)
	{
		CleanUpIfFailedAndSetHr(xmlSpec.AddDevice(NULL, -1, NULL, NULL, NULL, &hDevices));
	}

	for (NULL ; *pszMultiSZ; pszMultiSZ += (lstrlen(pszMultiSZ) + 1))
	{
		if (   NULL != pszMatchingID
			&& NULL != pszDriverVer
			&& 0 == lstrcmpi(pszMultiSZ, pszMatchingID)	)
		{
			LOG_Driver(_T("ID: %s Match: %s, rank: %d, DriverVer: %s"), pszMultiSZ, pszMatchingID, dwRank, pszDriverVer);
			CleanUpFailedAllocSetHrMsg(bstrMultiSZ = T2BSTR(pszMultiSZ));
			CleanUpFailedAllocSetHrMsg(bstrDriverVer = T2BSTR(pszDriverVer));
			CleanUpIfFailedAndSetHr(xmlSpec.AddHWID(hDevices, (SPDRP_COMPATIBLEIDS == dwProperty), dwRank++, bstrMultiSZ, bstrDriverVer));
			SafeSysFreeString(bstrMultiSZ);
			SafeSysFreeString(bstrDriverVer);
			//
			// We found the ID with the driver installed - don't pass any of lower rank up
			//
			hr = S_FALSE;
			break;
		}
		else
		{
			LOG_Driver(_T("ID: %s, rank: %d"), pszMultiSZ, dwRank);
			CleanUpFailedAllocSetHrMsg(bstrMultiSZ = T2BSTR(pszMultiSZ));
			CleanUpIfFailedAndSetHr(xmlSpec.AddHWID(hDevices, (SPDRP_COMPATIBLEIDS == dwProperty), dwRank++, bstrMultiSZ, NULL));
			SafeSysFreeString(bstrMultiSZ);
		}
	}

CleanUp:

	SysFreeString(bstrMultiSZ);
	SysFreeString(bstrDriverVer);
	return hr;
}

HRESULT DoesHwidMatchPrinter(
					DRIVER_INFO_6* paDriverInfo6,			// array of DRIVER_INFO_6 structs for installed printer drivers
					DWORD dwDriverInfoCount,				// count of structs in paDriverInfo6 array
					LPCTSTR pszMultiSZ,						// Hardware or Compatible MultiSZ to compare with installed printer drivers
					BOOL* pfHwidMatchesInstalledPrinter)	// [OUT] set TRUE if we match an installed printer driver
{
	LOG_Block("DoesHwidMatchPrinter");

	HRESULT hr = S_OK;

	if (NULL == pfHwidMatchesInstalledPrinter || NULL == pszMultiSZ)
	{
		LOG_ErrorMsg(E_INVALIDARG);
		return E_INVALIDARG;
	}

	*pfHwidMatchesInstalledPrinter = FALSE;

	if (NULL == paDriverInfo6 || 0 == dwDriverInfoCount)
	{
		LOG_Driver(_T("WARNING: We're missing printer information (maybe no installed printer drivers), so we won't prune"));
		goto CleanUp;
	}

	for (NULL; *pszMultiSZ; pszMultiSZ += (lstrlen(pszMultiSZ) + 1))
	{
		for (DWORD dwCount = 0; dwCount < dwDriverInfoCount; dwCount++)
		{
			if (NULL == (paDriverInfo6 + dwCount)->pszHardwareID)
			{
				continue;
			}
			//
			// Use case-insensitive compares (paDriverInfo6 is different case from bstrHwidTxtTemp)
			//
			if (0 == lstrcmpi(pszMultiSZ, (paDriverInfo6 + dwCount)->pszHardwareID))
			{
				LOG_Driver(_T("HWID (%s) matches an installed printer driver"), pszMultiSZ);
				*pfHwidMatchesInstalledPrinter = TRUE;
				goto CleanUp;
			}
		}
	}

CleanUp:

	return hr;
}

HRESULT AddPrunedDevRegProps(HDEVINFO hDevInfoSet,
									PSP_DEVINFO_DATA pDevInfoData,
									CXmlSystemSpec& xmlSpec,
									LPTSTR pszMatchingID,
									LPTSTR pszDriverVer,
									DRIVER_INFO_6* paDriverInfo6,	// OK if this is NULL (no installed printer drivers)
									DWORD dwDriverInfoCount,
									BOOL fIsSysSpecCall)			// Called by GetSystemSpec and GetPackage, with slightly different behavior
{
	LOG_Block("AddPrunedDevRegProps");
	HRESULT hr = S_OK;
	LPTSTR pszMultiHwid = NULL;
	LPTSTR pszMultiCompid = NULL;
	DWORD dwRank = 0;
	HANDLE_NODE hDevices = HANDLE_NODE_INVALID;
	BOOL fHwidMatchesInstalledPrinter = FALSE;

	//
	// Get the Hardware and Compatible Multi-SZ strings so we can prune printer devices before commiting to XML.
	//
	// Note that GetMultiSzDevRegProp may return S_OK and a NULL *ppMultiSZ if the SRDP doesn't exist.
	//
	CleanUpIfFailedAndSetHr(GetMultiSzDevRegProp(hDevInfoSet, pDevInfoData, SPDRP_HARDWAREID, &pszMultiHwid));

	CleanUpIfFailedAndSetHr(GetMultiSzDevRegProp(hDevInfoSet, pDevInfoData, SPDRP_COMPATIBLEIDS, &pszMultiCompid));

	if (fIsSysSpecCall)
	{
		//
		// We prune this device if a HWID or CompID matches a HWID of an installed printer since we
		// must avoid offering a driver that may conflict with one if the installed printer drivers.
		// Other code will write <device isPrinter="1" /> elements to the system spec XML to be used in
		// offering printer drivers. NOTE, if there is no printer driver currently installed for the given
		// HWID we will just offer the driver based on the PnP match.
		//
		if (NULL != pszMultiHwid)
		{
			CleanUpIfFailedAndSetHr(DoesHwidMatchPrinter(paDriverInfo6, dwDriverInfoCount, pszMultiHwid, &fHwidMatchesInstalledPrinter));
			if(fHwidMatchesInstalledPrinter)
			{
				goto CleanUp;
			}
		}

		if (NULL != pszMultiCompid)
		{
			CleanUpIfFailedAndSetHr(DoesHwidMatchPrinter(paDriverInfo6, dwDriverInfoCount, pszMultiCompid, &fHwidMatchesInstalledPrinter));
			if(fHwidMatchesInstalledPrinter)
			{
				goto CleanUp;
			}
		}
	}

	//
	// Add the Hardware and Compatible IDs to XML
	//
	if (NULL != pszMultiHwid)
	{
		CleanUpIfFailedAndSetHr(AddIDToXml(pszMultiHwid, xmlSpec, SPDRP_HARDWAREID, dwRank, hDevices, pszMatchingID, pszDriverVer));
	}
	//
	// Skip compatible IDs if we don't have any or already found a match (hr == S_FALSE)
	//
	if (NULL != pszMultiCompid && hr == S_OK)
	{
		CleanUpIfFailedAndSetHr(AddIDToXml(pszMultiCompid, xmlSpec, SPDRP_COMPATIBLEIDS, dwRank, hDevices, pszMatchingID, pszDriverVer));
	}

CleanUp:

	SafeHeapFree(pszMultiHwid);
	SafeHeapFree(pszMultiCompid);

	if (HANDLE_NODE_INVALID != hDevices)
	{
		xmlSpec.SafeCloseHandleNode(hDevices);
	}

	return hr;
}

static HRESULT DriverVerToIso8601(LPTSTR * ppszDriverVer)
{
	LOG_Block("DriverVerToIso8601");

	HRESULT hr = S_OK;
	TCHAR pszDVTemp[TCHARS_IN_DRIVERVER + 1];
	LPTSTR pszMonth = pszDVTemp;
	LPTSTR pszDay = NULL;
	LPTSTR pszYear = NULL;

	//
	//                     buffer:      pszDVTemp                     *ppszDriverVer
	// DriverVer: "[m]m-[d]d-yyyy" or "[m]m/[d]d/yyyy" --> ISO 8601: "yyyy-mm-dd"
	//                     index:         01   234567                 0123456789
	//                                  0 12 3 456789 ,,, etc, 
	//
	if (NULL == ppszDriverVer || NULL == *ppszDriverVer)
	{
		LOG_ErrorMsg(E_INVALIDARG);
		return E_INVALIDARG;
	}

    int nInLength = lstrlen(*ppszDriverVer);
    if (nInLength < TCHARS_IN_DRIVERVER - 2 || nInLength > TCHARS_IN_DRIVERVER)
	{
		LOG_ErrorMsg(E_INVALIDARG);
		(*ppszDriverVer)[0] = _T('\0');
		return E_INVALIDARG;
	}

	// Make sure *ppszDriverVer is large enough for ISO 8601
	//
	// **** It is VERY IMPORTANT that NO FAILURE CASE with an error of E_INVALIDARG go from before this ****
	// ****  size check to the CleanUp section below.                                                   ****
	//
	if (ARRAYSIZE(pszDVTemp) > nInLength)
	{
	    // if the size of this alloc is changed from SIZEOF_DRIVERVER, the StringCbCopy call below will need to be
	    //  changd appropriately as well.
		LPTSTR pszTemp = (LPTSTR) HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (LPVOID) *ppszDriverVer, SIZEOF_DRIVERVER);
		if (NULL == pszTemp)
		{
			CleanUpIfFailedAndSetHrMsg(E_OUTOFMEMORY);
		}
		*ppszDriverVer = pszTemp;
	}
	
	LOG_Driver(_T("In: \"%s\""), *ppszDriverVer);

	if ((_T('-') == (*ppszDriverVer)[4] || _T('/') == (*ppszDriverVer)[4]) &&
		(_T('-') == (*ppszDriverVer)[7] || _T('/') == (*ppszDriverVer)[7]))
	{
		//
		// It's probably already a valid ISO date, so do nothing
		//
		SetHrMsgAndGotoCleanUp(S_FALSE);
	}
	//
	// Unfortunately, DriverDate under HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Class (Win2K)
	// in the registry doesn't *always* pad the mm and dd fields with _T('0') for single digit months and days,
	// so we have to do this the hard way. But watch out - there's more. Win98SE (and maybe more)
	// pad with spaces, so we also have to change spaces to _T('0').
	//
	
	//
	// Copy to pszDVTemp
	//
	hr = StringCchCopyEx(pszDVTemp, ARRAYSIZE(pszDVTemp), *ppszDriverVer,
	                     NULL, NULL, MISTSAFE_STRING_FLAGS);
	CleanUpIfFailedAndSetHrMsg(hr);
	//
	// Find end of month, start of day
	//
	int i;
	for (i = 0; i < 3; i++)
	{
		if (_T('-') == pszMonth[i] || _T('/') == pszMonth[i])
		{
			pszMonth[i] = 0;
			pszDay = &pszMonth[i+1];
			break;
		}
		else if (_T(' ') == pszMonth[i])
		{
			pszMonth[i] = _T('0');
		}
		else if (!(_T('0') <= pszMonth[i] && _T('9') >= pszMonth[i]))
		{
			//
			// non-decimal characters other than _T('/') and "-"
			//
			SetHrMsgAndGotoCleanUp(E_INVALIDARG);
		}
	}
	if (NULL == pszDay || 0 == pszMonth[0])
	{
		SetHrMsgAndGotoCleanUp(E_INVALIDARG);
	}
	//
	// Find end of day, start of year
	//
	for (i = 0; i < 3; i++)
	{
		if (_T('-') == pszDay[i] || _T('/') == pszDay[i])
		{
			pszDay[i] = 0;
			pszYear = &pszDay[i+1];
			break;
		}
		else if (' ' == pszDay[i])
		{
			pszDay[i] = _T('0');
		}
		else if (!(_T('0') <= pszDay[i] && _T('9') >= pszDay[i]))
		{
			SetHrMsgAndGotoCleanUp(E_INVALIDARG);
		}
	}
	if (NULL == pszYear || 0 == pszDay[0])
	{
		SetHrMsgAndGotoCleanUp(E_INVALIDARG);
	}
	//
	// Verify year is four decimal digits
	//
	for (i = 0; i < 4 ; i++)
	{
		if (!(_T('0') <= pszYear[i] && _T('9') >= pszYear[i]) || _T('\0') == pszYear[i])
		{
			SetHrMsgAndGotoCleanUp(E_INVALIDARG);
		}
	}

	//
	// Copy back "yyyy" to start of string
	//
	hr = StringCbCopyEx(*ppszDriverVer, SIZEOF_DRIVERVER, pszYear, 
	                    NULL, NULL, MISTSAFE_STRING_FLAGS);
	CleanUpIfFailedAndSetHrMsg(hr);
	
	//
	// Copy month and pad if necessary
	//
	if (2 == lstrlen(pszMonth))
	{
		(*ppszDriverVer)[5] = pszMonth[0];
		(*ppszDriverVer)[6] = pszMonth[1];
	}
	else
	{
		(*ppszDriverVer)[5] = _T('0');
		(*ppszDriverVer)[6] = pszMonth[0];
	}
	//
	// Copy day and pad if necessary
	//
	//
	if (2 == lstrlen(pszDay))
	{
		(*ppszDriverVer)[8] = pszDay[0];
		(*ppszDriverVer)[9] = pszDay[1];
	}
	else
	{
		(*ppszDriverVer)[8] = _T('0');
		(*ppszDriverVer)[9] = pszDay[0];
	}
	// Add back the field separators: _T('-')
	//
	(*ppszDriverVer)[4] = _T('-');
	(*ppszDriverVer)[7] = _T('-');
	//
	// NULL terminate string
	//
	(*ppszDriverVer)[10] = _T('\0');

CleanUp:

	//
	// If we got garbage in, copy default date to *ppszDriverVer and return S_FALSE
	//
	if (E_INVALIDARG == hr)
	{
	    // This is safe to do because we know that this function calls HeapReAlloc
		// on this buffer if it is too small above.
	    (void) StringCbCopyEx(*ppszDriverVer, SIZEOF_DRIVERVER, SZ_UNKNOWN_DRIVERVER, 
	                   NULL, NULL, MISTSAFE_STRING_FLAGS);
		hr = S_FALSE;
	}

	LOG_Driver(_T("Out: \"%s\""), *ppszDriverVer);

	return hr;
}



static HRESULT GetFirstStringField(HINF hInf, LPCTSTR szSection, LPCTSTR szKey, LPTSTR szValue, DWORD dwcValueTCHARs)
{
	LOG_Block("GetFirstStringField");

	INFCONTEXT ctx;
	HRESULT hr = S_OK;

	if (INVALID_HANDLE_VALUE == hInf	||
		NULL == szSection				||
		NULL == szKey					||
		NULL == szValue					||
		0 == dwcValueTCHARs				)
	{
		LOG_ErrorMsg(E_INVALIDARG);
		return E_INVALIDARG;
	}

	*szValue = _T('\0');
	
	if (0 == SetupFindFirstLine(hInf, szSection, szKey, &ctx))
	{
		LOG_Error(_T("SetupFindFirstLine"));
		Win32MsgSetHrGotoCleanup(GetLastError());
	}

	if (0 == SetupGetStringField(&ctx, 1, szValue, dwcValueTCHARs, NULL))
	{
		LOG_Error(_T("SetupGetStringField"));
		Win32MsgSetHrGotoCleanup(GetLastError());
	}

CleanUp:

	if (FAILED(hr))
	{
		*szValue = _T('\0');
	}

	return hr;
}


HRESULT GetPropertyFromSetupDi(HDEVINFO hDevInfoSet, SP_DEVINFO_DATA devInfoData, ULONG ulProperty, LPTSTR* ppszProperty)
{
	LOG_Block("GetPropertyFromSetupDi");

	HRESULT hr = S_OK;
	ULONG ulSize = 0;

	if (INVALID_HANDLE_VALUE == hDevInfoSet || NULL == ppszProperty)
	{
		LOG_ErrorMsg(E_INVALIDARG);
		return E_INVALIDARG;
	}

	*ppszProperty = NULL;

	if (!SetupDiGetDeviceRegistryProperty(hDevInfoSet, &devInfoData, ulProperty, NULL, NULL, 0, &ulSize))
	{
		if (ERROR_INSUFFICIENT_BUFFER != GetLastError())
		{
			LOG_Error(_T("SetupDiGetDeviceRegistryProperty"));
			Win32MsgSetHrGotoCleanup(GetLastError());
		}
	}

	if (0 == ulSize)
	{
		LOG_Error(_T("SetupDiGetDeviceRegistryProperty returned zero size"));
		SetHrAndGotoCleanUp(E_FAIL);
	}
    // 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. Don't tell SetupDiXxxx
	// about all eight extra bytes.
	ulSize += 8;
	// NTBUG9#182680 zero the buffer so we don't get random garbage - REG_MULTI_SZ isn't always double-null terminated
	CleanUpFailedAllocSetHrMsg(*ppszProperty = (LPTSTR) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ulSize));

	if (!SetupDiGetDeviceRegistryProperty(hDevInfoSet, &devInfoData, ulProperty, NULL, (LPBYTE)*ppszProperty, ulSize - 4 , NULL))
	{
		LOG_Error(_T("SetupDiGetDeviceRegistryProperty"));
		Win32MsgSetHrGotoCleanup(GetLastError());
	}

CleanUp:

	if (FAILED(hr))
	{
		SafeHeapFree(*ppszProperty);
	}

	return hr;
}

HRESULT GetPropertyFromSetupDiReg(HDEVINFO hDevInfoSet, SP_DEVINFO_DATA devInfoData, LPCTSTR szProperty, LPTSTR *ppszData)
{
	LOG_Block("GetPropertyFromSetupDiReg");

	int cchValueSize = 0;
	HKEY hKey = (HKEY) INVALID_HANDLE_VALUE;
	HRESULT hr = S_OK;

	if (INVALID_HANDLE_VALUE == hDevInfoSet || NULL == szProperty || NULL == ppszData)
	{
		LOG_ErrorMsg(E_INVALIDARG);
		return E_INVALIDARG;
	}

	*ppszData = NULL;
	//
	// Open a software, or driver, registry key for the device. This key is located in the Class branch.
	//
	if (INVALID_HANDLE_VALUE == (hKey = SetupDiOpenDevRegKey(hDevInfoSet, &devInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DRV, KEY_READ)))
	{
		LOG_Error(_T("SetupDiOpenDevRegKey"));
		Win32MsgSetHrGotoCleanup(GetLastError());
	}
	
	hr = SafeRegQueryStringValueCch(hKey, szProperty, NULL, 0, &cchValueSize);
	if (REG_E_MORE_DATA != hr || 0 == cchValueSize)
	{
		CleanUpIfFailedAndSetHrMsg(hr);
	}

	//
	// Sanity check size of data in registry
	//
	if (MAX_INF_STRING_LEN < cchValueSize)
	{
		CleanUpIfFailedAndSetHrMsg(E_INVALIDARG);
	}

	//
	// Add extra character of zero'ed memory for safety
	//
	CleanUpFailedAllocSetHrMsg(*ppszData = (LPTSTR) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (cchValueSize + 1) * sizeof(TCHAR)));

	CleanUpIfFailedAndSetHrMsg(SafeRegQueryStringValueCch(hKey, szProperty, *ppszData, cchValueSize, &cchValueSize));

CleanUp:

	if (INVALID_HANDLE_VALUE != hKey)
	{
		RegCloseKey(hKey);
	}

	if (FAILED(hr))
	{
		SafeHeapFree(*ppszData);
	}

	return hr;
}

static HRESULT DriverVerFromInf(HINF hInf, LPTSTR pszMfg, LPTSTR pszDescription, LPTSTR* ppszDriverVer)
{
	LOG_Block("DriverVerFromInf");

	HRESULT hr;
	TCHAR szDeviceSec[MAX_PATH + 1];
	TCHAR szValue[MAX_PATH + 1];
	TCHAR szInstallSec[MAX_PATH + 1];

	if (INVALID_HANDLE_VALUE == hInf	||
		NULL == pszMfg					||
		NULL == pszDescription			||
		NULL == ppszDriverVer	)
	{
		LOG_ErrorMsg(E_INVALIDARG);
		return E_INVALIDARG;
	}

	ZeroMemory(szDeviceSec , sizeof(szDeviceSec));
	ZeroMemory(szValue , sizeof(szValue));
	ZeroMemory(szInstallSec , sizeof(szInstallSec));
	*ppszDriverVer = NULL;
	//
	// Lie about buffer size so we are always NULL terminated
	//
	CleanUpIfFailedAndSetHr(GetFirstStringField(hInf, _T("Manufacturer"), pszMfg, szDeviceSec, ARRAYSIZE(szDeviceSec) - 1));	// Driver section

	CleanUpIfFailedAndSetHr(GetFirstStringField(hInf, szDeviceSec, pszDescription, szInstallSec, ARRAYSIZE(szInstallSec) - 1));	// Install section

	CleanUpIfFailedAndSetHr(GetFirstStringField(hInf, szInstallSec, _T("DriverVer"), szValue, ARRAYSIZE(szValue) - 1));		// DriverVer

CleanUp:

	if (FAILED(hr))
	{
		//
		// if we didn't get it from the "Manufacturer" section, try the "Version" section
		//
		hr = GetFirstStringField(hInf, _T("Version"), _T("DriverVer"), szValue, MAX_PATH);
	}

	if (SUCCEEDED(hr))
	{
		if (NULL != ppszDriverVer)
		{
		    DWORD cch = (lstrlen(szValue) + 1);
			if (NULL == (*ppszDriverVer = (LPTSTR) HeapAlloc(GetProcessHeap(), 0, cch * sizeof(TCHAR))))
			{
				LOG_ErrorMsg(E_OUTOFMEMORY);
				hr = E_OUTOFMEMORY;
			}
			else
			{
				// Convert to ISO 8601 format
			    hr = StringCchCopyEx(*ppszDriverVer, cch, szValue, NULL, NULL, MISTSAFE_STRING_FLAGS);
			    if (FAILED(hr))
			    {
			        LOG_ErrorMsg(hr);
			    }
			    else
			    {
				    hr = DriverVerToIso8601(ppszDriverVer);
			    }
				if (FAILED(hr))
				{
					SafeHeapFree(*ppszDriverVer);
				}
			}
		}
	}

	return hr;
}

inline bool IsDriver(LPCTSTR szFile)
{
#if defined(DBG)
	if (NULL == szFile)
	{
		return false;
	}
#endif

	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 < ARRAYSIZE(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
{
	LOG_Block("FileQueueScanCallback");

	HRESULT hr;

	if (NULL == pContext || 0 == ulParam1)
	{
		LOG_ErrorMsg(ERROR_INVALID_PARAMETER);
		return ERROR_INVALID_PARAMETER;
	}

	if (SPFILENOTIFY_QUEUESCAN == ulNotification)
	{
		PFILETIME pftDateLatest = (PFILETIME)pContext;
		LPCTSTR szFile = (LPCTSTR)ulParam1; 
		// Is this a binary
		if (IsDriver(szFile)) 
		{
			HANDLE hFile = INVALID_HANDLE_VALUE;
			if (SUCCEEDED(hr = SafeCreateFile(&hFile, 0, szFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)))
			{
				FILETIME ft;
				if (GetFileTime(hFile, NULL, NULL, &ft))
				{
#if defined(DBG)
					SYSTEMTIME st;
 					if (FileTimeToSystemTime(&ft, &st))
					{
						LOG_Out(_T("%s : %04d-%02d-%02d"), szFile, (int)st.wYear, (int)st.wMonth, (int)st.wDay);
					}
#endif
					if (CompareFileTime(pftDateLatest, &ft) < 0)
						*pftDateLatest = ft;

				}
				else
				{
					LOG_Error(_T("GetFileTime %s"), szFile);
					LOG_ErrorMsg(GetLastError());
				}
				CloseHandle(hFile);
			}
			else
			{
				LOG_Error(_T("SafeCreateFile %s:"), szFile);
				LOG_ErrorMsg(hr);
			}
		}
		else
		{
			LOG_Out(_T("%s: not a driver"), szFile);
		}
	}

	return NO_ERROR;
}

static HRESULT LatestDriverFileTime(HDEVINFO hDevInfoSet, SP_DEVINFO_DATA devInfoData, LPTSTR pszMfg,
									LPTSTR pszDescription, LPTSTR pszProvider, LPCTSTR pszInfFile, LPTSTR* ppszDriverVer)
{
	LOG_Block("LatestDriverFileTime");

	HRESULT hr = S_OK;
	FILETIME ftDate = {0,0};
	HSPFILEQ hspfileq = INVALID_HANDLE_VALUE;
	SP_DEVINSTALL_PARAMS	DeviceInstallParams;

	if (INVALID_HANDLE_VALUE == hDevInfoSet ||
		NULL == pszMfg						||
		NULL == pszDescription				||
		NULL == pszProvider					||
		NULL == pszInfFile					||
		NULL == ppszDriverVer	)
	{
		LOG_ErrorMsg(E_INVALIDARG);
		return E_INVALIDARG;
	}

	ZeroMemory(&DeviceInstallParams, sizeof(SP_DEVINSTALL_PARAMS));
	DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);

	*ppszDriverVer = NULL;

	if (!SetupDiGetDeviceInstallParams(hDevInfoSet, &devInfoData, &DeviceInstallParams))
	{
		LOG_Error(_T("SetupDiGetDeviceInstallParams"));
		Win32MsgSetHrGotoCleanup(GetLastError());
	}

	hr = StringCchCopyEx(DeviceInstallParams.DriverPath, ARRAYSIZE(DeviceInstallParams.DriverPath),
	                     pszInfFile,
	                     NULL, NULL, MISTSAFE_STRING_FLAGS);
	CleanUpIfFailedAndSetHrMsg(hr);
	
	DeviceInstallParams.Flags |= DI_ENUMSINGLEINF;

	if (!SetupDiSetDeviceInstallParams(hDevInfoSet, &devInfoData, &DeviceInstallParams))
	{
		LOG_Error(_T("SetupDiSetDeviceInstallParams"));
		Win32MsgSetHrGotoCleanup(GetLastError());
	}

	//Now build a class driver list from this INF.
	if (!SetupDiBuildDriverInfoList(hDevInfoSet, &devInfoData, SPDIT_CLASSDRIVER))
	{
		LOG_Error(_T("SetupDiBuildDriverInfoList"));
		Win32MsgSetHrGotoCleanup(GetLastError());
	}

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

	hr = StringCchCopyEx(DriverInfoData.MfgName, ARRAYSIZE(DriverInfoData.MfgName), pszMfg, 
	                     NULL, NULL, MISTSAFE_STRING_FLAGS);
    CleanUpIfFailedAndSetHrMsg(hr);

	hr = StringCchCopyEx(DriverInfoData.Description, ARRAYSIZE(DriverInfoData.Description), pszDescription, 
	                     NULL, NULL, MISTSAFE_STRING_FLAGS);
    CleanUpIfFailedAndSetHrMsg(hr);

	hr = StringCchCopyEx(DriverInfoData.ProviderName, ARRAYSIZE(DriverInfoData.ProviderName), pszProvider, 
	                     NULL, NULL, MISTSAFE_STRING_FLAGS);
    CleanUpIfFailedAndSetHrMsg(hr);

	if (!SetupDiSetSelectedDriver(hDevInfoSet, &devInfoData, (SP_DRVINFO_DATA*)&DriverInfoData))
	{
		Win32MsgSetHrGotoCleanup(GetLastError());
	}

	if (INVALID_HANDLE_VALUE == (hspfileq = SetupOpenFileQueue()))
	{
		Win32MsgSetHrGotoCleanup(GetLastError());
	}

	// Set custom queue to device install params
	if (!SetupDiGetDeviceInstallParams(hDevInfoSet, &devInfoData, &DeviceInstallParams))
	{
		Win32MsgSetHrGotoCleanup(GetLastError());
	}

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

	if (!SetupDiSetDeviceInstallParams(hDevInfoSet, &devInfoData, &DeviceInstallParams))
	{
		Win32MsgSetHrGotoCleanup(GetLastError());
	}

	if (!SetupDiInstallDriverFiles(hDevInfoSet, &devInfoData))
	{
		Win32MsgSetHrGotoCleanup(GetLastError());
	}
	
	// Parse the queue
	DWORD dwScanResult;
	if (!SetupScanFileQueue(hspfileq, SPQ_SCAN_USE_CALLBACK, NULL, (PSP_FILE_CALLBACK)FileQueueScanCallback, &ftDate, &dwScanResult))
	{
		Win32MsgSetHrGotoCleanup(GetLastError());
	}

	SYSTEMTIME st;
 	if (!FileTimeToSystemTime(&ftDate, &st))
	{
		Win32MsgSetHrGotoCleanup(GetLastError());
	}

	if (1990 > st.wYear)
	{
		//
		// Didn't enumerate any files, or files had bogus dates. Return an error so
		// we will fallback on default "0000-00-00"
		//
		hr = E_NOTIMPL;
		LOG_ErrorMsg(hr);
		goto CleanUp;
	}

#if defined(DBG)
	LOG_Out(_T("%s - %s %04d-%02d-%02d"), pszMfg, pszDescription, (int)st.wYear, (int)st.wMonth, (int)st.wDay);
#endif

	CleanUpFailedAllocSetHrMsg(*ppszDriverVer = (LPTSTR) HeapAlloc(GetProcessHeap(), 0, SIZEOF_DRIVERVER));

	// ISO 8601 prefered format (yyyy-mm-dd)
	hr = StringCbPrintfEx(*ppszDriverVer, SIZEOF_DRIVERVER, NULL, NULL, MISTSAFE_STRING_FLAGS, 
	                      _T("%04d-%02d-%02d"), (int)st.wYear, (int)st.wMonth, (int)st.wDay);
	CleanUpIfFailedAndSetHrMsg(hr);

CleanUp:

	if (INVALID_HANDLE_VALUE != hspfileq)
	{
		SetupCloseFileQueue(hspfileq);
	}

	if (FAILED(hr))
	{
		SafeHeapFree(*ppszDriverVer);
	}

	return hr;
}

//
// Called if we don't get driver date from registry
//
static HRESULT GetDriverDateFromInf(HKEY hDevRegKey, HDEVINFO hDevInfoSet, SP_DEVINFO_DATA devInfoData, LPTSTR* ppszDriverVer)
{
	LOG_Block("GetDriverDateFromInf");
	HRESULT hr;
	UINT nRet;
	HINF hInf = INVALID_HANDLE_VALUE;
	LPTSTR pszMfg = NULL;
	LPTSTR pszDescription = NULL;
	LPTSTR pszProvider = NULL;
	TCHAR szInfName[MAX_PATH + 2];
	int cchValueSize;

	if (INVALID_HANDLE_VALUE == hDevInfoSet || (HKEY)INVALID_HANDLE_VALUE == hDevRegKey || NULL == ppszDriverVer)
	{
		LOG_ErrorMsg(E_INVALIDARG);
		return E_INVALIDARG;
	}

	*ppszDriverVer = NULL;

	//
	// Get INF File name from registry, but lie about size to make sure we are NULL terminated
	//
	ZeroMemory(szInfName, sizeof(szInfName));
	CleanUpIfFailedAndSetHrMsg(SafeRegQueryStringValueCch(hDevRegKey, REGSTR_VAL_INFPATH, szInfName, ARRAYSIZE(szInfName)-1, &cchValueSize));

	//
	// Verify the file name ends with ".inf"
	//
	if (CSTR_EQUAL != WUCompareStringI(&szInfName[lstrlen(szInfName) - 4], _T(".inf")))
	{
		CleanUpIfFailedAndSetHrMsg(E_INVALIDARG);
	}
	//
	// Look for szInfName in %windir%\inf\ or %windir%\inf\other\
	//
	TCHAR szInfFile[MAX_PATH + 1];
	nRet = GetWindowsDirectory(szInfFile, ARRAYSIZE(szInfFile));
	if (0 == nRet || ARRAYSIZE(szInfFile) < nRet)
	{
		Win32MsgSetHrGotoCleanup(GetLastError());
	}

	hr = PathCchAppend(szInfFile, ARRAYSIZE(szInfFile), _T("inf"));
	CleanUpIfFailedAndSetHrMsg(hr);	
	
	hr = PathCchAppend(szInfFile, ARRAYSIZE(szInfFile), szInfName);
	CleanUpIfFailedAndSetHrMsg(hr);	
	
	if (INVALID_HANDLE_VALUE == (hInf = SetupOpenInfFile(szInfFile, NULL, INF_STYLE_WIN4, NULL)))
	{
		nRet = GetWindowsDirectory(szInfFile, ARRAYSIZE(szInfFile));
		if (0 == nRet || ARRAYSIZE(szInfFile) < nRet)
		{
			Win32MsgSetHrGotoCleanup(GetLastError());
		}

		hr = PathCchAppend(szInfFile, ARRAYSIZE(szInfFile), _T("inf\\other"));
		CleanUpIfFailedAndSetHrMsg(hr);	

		hr = PathCchAppend(szInfFile, ARRAYSIZE(szInfFile), szInfName);
		CleanUpIfFailedAndSetHrMsg(hr);	

		if (INVALID_HANDLE_VALUE == (hInf = SetupOpenInfFile(szInfFile, NULL, INF_STYLE_WIN4, NULL)))
		{
			LOG_Driver(_T("SetupOpenInfFile %s"), szInfFile);
			Win32MsgSetHrGotoCleanup(GetLastError());
		}
	}
	
	// first try to get it from inf
	CleanUpIfFailedAndSetHr(GetPropertyFromSetupDi(hDevInfoSet, devInfoData, SPDRP_MFG, &pszMfg));
	CleanUpIfFailedAndSetHr(GetPropertyFromSetupDi(hDevInfoSet, devInfoData, SPDRP_DEVICEDESC, &pszDescription));

	if (SUCCEEDED(hr = DriverVerFromInf(hInf, pszMfg, pszDescription, ppszDriverVer)))
	{
		goto CleanUp;
	}
	//
	// Try enumerating the files as last resort
	//
	CleanUpIfFailedAndSetHr(GetPropertyFromSetupDiReg(hDevInfoSet, devInfoData, REGSTR_VAL_PROVIDER_NAME, &pszProvider));

	hr = LatestDriverFileTime(hDevInfoSet, devInfoData, pszMfg, pszDescription, pszProvider, szInfFile, ppszDriverVer);

CleanUp:

	if (INVALID_HANDLE_VALUE != hInf)
	{
		SetupCloseInfFile(hInf);
	}

	SafeHeapFree(pszMfg);
	SafeHeapFree(pszDescription);
	SafeHeapFree(pszProvider);

	if (FAILED(hr))
	{
		SafeHeapFree(*ppszDriverVer);
	}

	return hr;
}

/////////////////////////////////////////////////////////////////////////////
// Add Classes helper functionality for GetSystemSpec() and CDM functions
/////////////////////////////////////////////////////////////////////////////
HRESULT AddComputerSystemClass(CXmlSystemSpec& xmlSpec)
{
	USES_IU_CONVERSION;
	LOG_Block("AddComputerSystemClass");

	HRESULT hr;
	BSTR bstrDrive = NULL;
	BSTR bstrPID = NULL;


	PIU_DRIVEINFO pDriveInfo = NULL;
	DWORD dwNumDrives;

	IU_PLATFORM_INFO iuPlatformInfo;

	ZeroMemory( &iuPlatformInfo, sizeof(iuPlatformInfo));
	CleanUpIfFailedAndSetHr( DetectClientIUPlatform(&iuPlatformInfo) );


	if( 4 < iuPlatformInfo.osVersionInfoEx.dwMajorVersion )
	{
		BOOL bPid = TRUE;
		
		if(5 == iuPlatformInfo.osVersionInfoEx.dwMajorVersion)
		{
			if( 1 > iuPlatformInfo.osVersionInfoEx.dwMinorVersion)
				bPid = FALSE;
			else if(1 == iuPlatformInfo.osVersionInfoEx.dwMinorVersion)
			{
				if(1 > iuPlatformInfo.osVersionInfoEx.wServicePackMajor)
					bPid = FALSE;
			}
		}

		if(bPid)
			GetSystemPID(bstrPID);

		//Note: Return value  is not checked because
		//Any failure to get the PID is not considered as a failure on the GetSystemSpec method
		//If the pid attribute is missing on the supported platforms  it is still considered as 
		//an invalid pid case and no items will be returned in the catalog from the server
		//if there is any error bstrPID will  be null and it will not be added to 
		//the systemspec xml
	}


	//CleanUpIfFailedAndSetHr(GetOemBstrs(bstrManufacturer, bstrModel, bstrOEMSupportURL));
	// NTRAID#NTBUG9-277070-2001/01/12-waltw IUpdate methods should return
	// HRESULT_FROM_WIN32(ERROR_SERVICE_DISABLED) when Windows Update is disabled
	// Just pass -1 to AddComputerSystem()

	CleanUpIfFailedAndSetHr(xmlSpec.AddComputerSystem(iuPlatformInfo.bstrOEMManufacturer, iuPlatformInfo.bstrOEMModel,
				iuPlatformInfo.bstrOEMSupportURL, IsAdministrator(), IsWindowsUpdateDisabled(), IsAutoUpdateEnabled(), bstrPID));

	CleanUpIfFailedAndSetHr(GetLocalFixedDriveInfo(&dwNumDrives, &pDriveInfo));

	for (DWORD i = 0; i < dwNumDrives; i++)
	{
		CleanUpFailedAllocSetHrMsg(bstrDrive = SysAllocString(T2OLE((&pDriveInfo[i])->szDriveStr)));

		CleanUpIfFailedAndSetHr(xmlSpec.AddDriveSpace(bstrDrive, (&pDriveInfo[i])->iKBytes));
		
		SafeSysFreeString(bstrDrive);
	}

CleanUp:

	SafeHeapFree(pDriveInfo);
	SysFreeString(bstrDrive);
	SysFreeString(bstrPID);
	return hr;
}

HRESULT AddRegKeyClass(CXmlSystemSpec& xmlSpec)
{
	LOG_Block("AddRegKeysClass");

	HRESULT hr = S_OK;
	LONG lRet;
	HKEY hkSoftware;
	TCHAR szSoftware[MAX_PATH];
	DWORD dwcSoftware;
	DWORD dwIndex = 0;
	FILETIME ftLastWriteTime;
	BSTR bstrSoftware = NULL;
	BOOL fRegKeyOpened = FALSE;

	if (ERROR_SUCCESS != (lRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("SOFTWARE"), 0, KEY_READ, &hkSoftware)))
	{
		Win32MsgSetHrGotoCleanup(lRet);
	}
	else
	{
		fRegKeyOpened = TRUE;
	}

	do
	{
		dwcSoftware = MAX_PATH;
		if (ERROR_SUCCESS != (lRet = (RegEnumKeyEx(hkSoftware, dwIndex++, szSoftware, &dwcSoftware, NULL, NULL, NULL, &ftLastWriteTime))))
		{
			if (ERROR_NO_MORE_ITEMS == lRet)
			{
				break;
			}
			else
			{
				LOG_ErrorMsg(lRet);
				hr = HRESULT_FROM_WIN32(lRet);
				break;
			}
		}
		CleanUpFailedAllocSetHrMsg(bstrSoftware = T2BSTR(szSoftware));
		CleanUpIfFailedAndSetHr(xmlSpec.AddReg(bstrSoftware));
		SafeSysFreeString(bstrSoftware);

	} while (ERROR_SUCCESS == lRet);

CleanUp:

	SysFreeString(bstrSoftware);

	if (TRUE == fRegKeyOpened)
	{
		RegCloseKey(hkSoftware);
	}
	return hr;
}

HRESULT AddPlatformClass(CXmlSystemSpec& xmlSpec, IU_PLATFORM_INFO iuPlatformInfo)
{
	USES_IU_CONVERSION;
	LOG_Block("AddPlatformClass");

	HRESULT hr;
	BSTR bstrTemp = NULL;

	// NOTE: we never expect to be called on Win32s
	const TCHAR* pszPlatformName = (VER_PLATFORM_WIN32_NT == iuPlatformInfo.osVersionInfoEx.dwPlatformId)
															? SZ_WIN32_NT : SZ_WIN32_WINDOWS;

	CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(pszPlatformName));
	CleanUpIfFailedAndSetHr(xmlSpec.AddPlatform(bstrTemp));
	SafeSysFreeString(bstrTemp);

	CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(SZ_PROCESSOR));
	CleanUpIfFailedAndSetHr(xmlSpec.AddProcessor(bstrTemp));
	SafeSysFreeString(bstrTemp);


	hr = xmlSpec.AddVersion(	iuPlatformInfo.osVersionInfoEx.dwMajorVersion,
								iuPlatformInfo.osVersionInfoEx.dwMinorVersion,
								iuPlatformInfo.osVersionInfoEx.dwBuildNumber,
								(sizeof(OSVERSIONINFOEX) == iuPlatformInfo.osVersionInfoEx.dwOSVersionInfoSize)
									? iuPlatformInfo.osVersionInfoEx.wServicePackMajor : 0,
								(sizeof(OSVERSIONINFOEX) == iuPlatformInfo.osVersionInfoEx.dwOSVersionInfoSize)
									? iuPlatformInfo.osVersionInfoEx.wServicePackMinor : 0
							);
	CleanUpIfFailedAndSetHr(hr);

	//
	// If we can, add Suite and Product Type
	//
	if (sizeof(OSVERSIONINFOEX) == iuPlatformInfo.osVersionInfoEx.dwOSVersionInfoSize)
	{
		//
		// Add all suites
		//
		if (VER_SUITE_SMALLBUSINESS & iuPlatformInfo.osVersionInfoEx.wSuiteMask)
		{
			CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(SZ_SUITE_SMALLBUSINESS));
			CleanUpIfFailedAndSetHr(xmlSpec.AddSuite(bstrTemp));
			SafeSysFreeString(bstrTemp);
		}

		if (VER_SUITE_ENTERPRISE & iuPlatformInfo.osVersionInfoEx.wSuiteMask)
		{
			CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(SZ_SUITE_ENTERPRISE));
			CleanUpIfFailedAndSetHr(xmlSpec.AddSuite(bstrTemp));
			SafeSysFreeString(bstrTemp);
		}

		if (VER_SUITE_BACKOFFICE & iuPlatformInfo.osVersionInfoEx.wSuiteMask)
		{
			CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(SZ_SUITE_BACKOFFICE));
			CleanUpIfFailedAndSetHr(xmlSpec.AddSuite(bstrTemp));
			SafeSysFreeString(bstrTemp);
		}

		if (VER_SUITE_COMMUNICATIONS & iuPlatformInfo.osVersionInfoEx.wSuiteMask)
		{
			CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(SZ_SUITE_COMMUNICATIONS));
			CleanUpIfFailedAndSetHr(xmlSpec.AddSuite(bstrTemp));
			SafeSysFreeString(bstrTemp);
		}

		if (VER_SUITE_TERMINAL & iuPlatformInfo.osVersionInfoEx.wSuiteMask)
		{
			CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(SZ_SUITE_TERMINAL));
			CleanUpIfFailedAndSetHr(xmlSpec.AddSuite(bstrTemp));
			SafeSysFreeString(bstrTemp);
		}

		if (VER_SUITE_SMALLBUSINESS_RESTRICTED & iuPlatformInfo.osVersionInfoEx.wSuiteMask)
		{
			CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(SZ_SUITE_SMALLBUSINESS_RESTRICTED));
			CleanUpIfFailedAndSetHr(xmlSpec.AddSuite(bstrTemp));
			SafeSysFreeString(bstrTemp);
		}

		if (VER_SUITE_EMBEDDEDNT & iuPlatformInfo.osVersionInfoEx.wSuiteMask)
		{
			CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(SZ_SUITE_EMBEDDEDNT));
			CleanUpIfFailedAndSetHr(xmlSpec.AddSuite(bstrTemp));
			SafeSysFreeString(bstrTemp);
		}

		if (VER_SUITE_DATACENTER & iuPlatformInfo.osVersionInfoEx.wSuiteMask)
		{
			CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(SZ_SUITE_DATACENTER));
			CleanUpIfFailedAndSetHr(xmlSpec.AddSuite(bstrTemp));
			SafeSysFreeString(bstrTemp);
		}

		if (VER_SUITE_SINGLEUSERTS & iuPlatformInfo.osVersionInfoEx.wSuiteMask)
		{
			CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(SZ_SUITE_SINGLEUSERTS));
			CleanUpIfFailedAndSetHr(xmlSpec.AddSuite(bstrTemp));
			SafeSysFreeString(bstrTemp);
		}

		if (VER_SUITE_PERSONAL & iuPlatformInfo.osVersionInfoEx.wSuiteMask)
		{
			CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(SZ_SUITE_PERSONAL));
			CleanUpIfFailedAndSetHr(xmlSpec.AddSuite(bstrTemp));
			SafeSysFreeString(bstrTemp);
		}

		if (VER_SUITE_BLADE & iuPlatformInfo.osVersionInfoEx.wSuiteMask)
		{
			CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(SZ_SUITE_BLADE));
			CleanUpIfFailedAndSetHr(xmlSpec.AddSuite(bstrTemp));
			SafeSysFreeString(bstrTemp);
		}

		//
		// Add Product Type
		//
		if (VER_NT_WORKSTATION == iuPlatformInfo.osVersionInfoEx.wProductType)
		{
			CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(SZ_NT_WORKSTATION));
			CleanUpIfFailedAndSetHr(xmlSpec.AddProductType(bstrTemp));
			SafeSysFreeString(bstrTemp);
		}
		else if (VER_NT_DOMAIN_CONTROLLER == iuPlatformInfo.osVersionInfoEx.wProductType)
		{
			CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(SZ_NT_DOMAIN_CONTROLLER));
			CleanUpIfFailedAndSetHr(xmlSpec.AddProductType(bstrTemp));
			SafeSysFreeString(bstrTemp);
		}
		else if (VER_NT_SERVER == iuPlatformInfo.osVersionInfoEx.wProductType)
		{
			CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(SZ_NT_SERVER));
			CleanUpIfFailedAndSetHr(xmlSpec.AddProductType(bstrTemp));
			SafeSysFreeString(bstrTemp);
		}
		// else skip - there's a new one defined we don't know about
	}

CleanUp:

	SysFreeString(bstrTemp);
	return hr;
}

HRESULT AddLocaleClass(CXmlSystemSpec& xmlSpec, BOOL fIsUser)
{
	LOG_Block("AddLocaleClass");

	HRESULT hr;
	BSTR bstrTemp = NULL;
	HANDLE_NODE hLocale = HANDLE_NODE_INVALID;
	TCHAR szLang[256] = _T("");	// Usually ISO format five characters + NULL (en-US) but note exceptions
								// such as "el_IBM"

	CleanUpFailedAllocSetHrMsg(bstrTemp = SysAllocString(fIsUser ? L"USER" : L"OS"));
	CleanUpIfFailedAndSetHr(xmlSpec.AddLocale(bstrTemp, &hLocale));
	SafeSysFreeString(bstrTemp);

	LookupLocaleString((LPTSTR) szLang, ARRAYSIZE(szLang), fIsUser ? TRUE : FALSE);
	CleanUpFailedAllocSetHrMsg(bstrTemp = T2BSTR(szLang));
	CleanUpIfFailedAndSetHr(xmlSpec.AddLanguage(hLocale, bstrTemp));
	SafeSysFreeString(bstrTemp);
	xmlSpec.SafeCloseHandleNode(hLocale);

CleanUp:

	if (HANDLE_NODE_INVALID != hLocale)
	{
		xmlSpec.SafeCloseHandleNode(hLocale);
	}

	SysFreeString(bstrTemp);
	return hr;
}

////////////////////////////////////////////////////////////////////////////////////////
//
// NOTE: Caller must clean up heap allocations made for *ppszMatchingID and *ppszDriverVer
//
////////////////////////////////////////////////////////////////////////////////////////
HRESULT GetMatchingDeviceID(HDEVINFO hDevInfoSet, PSP_DEVINFO_DATA pDevInfoData, LPTSTR* ppszMatchingID, LPTSTR* ppszDriverVer)
{
	LOG_Block("GetMatchingDeviceID");

	HKEY hDevRegKey = (HKEY) INVALID_HANDLE_VALUE;
	HRESULT hr = S_OK;

	if (NULL == ppszMatchingID || NULL == ppszDriverVer)
	{
		LOG_ErrorMsg(E_INVALIDARG);
		return E_INVALIDARG;
	}

	OSVERSIONINFOEX verInfoEx;

	ZeroMemory(&verInfoEx, sizeof(verInfoEx));
	*ppszMatchingID = NULL;
	*ppszDriverVer = NULL;

	//
	// Get the MatchingDeviceID and DriverDate (succeedes only if driver is already installed)
	//
	if (INVALID_HANDLE_VALUE == (hDevRegKey = SetupDiOpenDevRegKey(hDevInfoSet, pDevInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DRV, KEY_READ)))
	{
		LOG_Driver(_T("Optional SetupDiOpenDevRegKey returned INVALID_HANDLE_VALUE"));
	}
	else
	{
		int cchValueSize = 0;
		hr = SafeRegQueryStringValueCch(hDevRegKey, REGSTR_VAL_MATCHINGDEVID, NULL, 0, &cchValueSize);
		if (REG_E_MORE_DATA != hr || 0 == cchValueSize)
		{
			LOG_Driver(_T("Driver doesn't have a matching ID"));
			//
			// This is not an error
			//
			hr = S_OK;
		}
		else
		{
			//
			// Sanity check size of data in registry
			//
			if (MAX_INF_STRING_LEN < cchValueSize)
			{
				CleanUpIfFailedAndSetHrMsg(E_INVALIDARG);
			}
			//
			// MatchingDeviceID
			//
			// Add extra character of zero'ed memory for safety
			//
			CleanUpFailedAllocSetHrMsg(*ppszMatchingID = (LPTSTR) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (cchValueSize + 1) * sizeof(TCHAR)));

			CleanUpIfFailedAndSetHrMsg(SafeRegQueryStringValueCch(hDevRegKey, REGSTR_VAL_MATCHINGDEVID, *ppszMatchingID, cchValueSize, &cchValueSize));
			//
			// We got the matching ID, now do our best to get DriverVer (prefer from registry)
			//
			hr = SafeRegQueryStringValueCch(hDevRegKey, REGSTR_VAL_DRIVERDATE, NULL, 0, &cchValueSize);
			if (REG_E_MORE_DATA != hr || 0 == cchValueSize)
			{
				LOG_Error(_T("No DRIVERDATE registry key, search the INF"));
				//
				// Search the INF and driver files for a date
				//
				if (FAILED(hr = GetDriverDateFromInf(hDevRegKey, hDevInfoSet, *pDevInfoData, ppszDriverVer)))
				{
					//
					// Use a default driver date
					//
					CleanUpFailedAllocSetHrMsg(*ppszDriverVer = (LPTSTR) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, SIZEOF_DRIVERVER));
                    hr = StringCbCopyEx(*ppszDriverVer, SIZEOF_DRIVERVER, SZ_UNKNOWN_DRIVERVER, 
                                        NULL, NULL, MISTSAFE_STRING_FLAGS);
                    CleanUpIfFailedAndSetHrMsg(hr);
				}
			}
			else
			{
				//
				// Sanity check size of data in registry
				//
				if (MAX_INF_STRING_LEN < cchValueSize)
				{
					CleanUpIfFailedAndSetHrMsg(E_INVALIDARG);
				}
				//
				// Get the driver date from the registry
				//
				// Add extra character of zero'ed memory for safety
				//
				CleanUpFailedAllocSetHrMsg(*ppszDriverVer = (LPTSTR) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (cchValueSize + 1) * sizeof(TCHAR)));

				CleanUpIfFailedAndSetHrMsg(SafeRegQueryStringValueCch(hDevRegKey, REGSTR_VAL_DRIVERDATE, *ppszDriverVer, cchValueSize, &cchValueSize));
				//
				// Convert to ISO 8601 format
				//
				CleanUpIfFailedAndSetHr(DriverVerToIso8601(ppszDriverVer));

#if defined(_UNICODE) || defined(UNICODE)
				//
				// 645161 Driver Ver Version to be returned to driver query.asp for WUPM 1.2 Release Timeframe
				//
				// Optionally add DriverVer version to date. NOTE: We don't attempt this unless we were able to get
				// the DriverVer date via REGSTR_VAL_DRIVERDATE. Also, this is done only for WinXP SP1 up.
				//
				verInfoEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
				if (GetVersionEx((LPOSVERSIONINFO) &verInfoEx))
				{
					if (VER_PLATFORM_WIN32_NT == verInfoEx.dwPlatformId
						&&	(
									5 < verInfoEx.dwMajorVersion	// Longhorn
								||	(5 == verInfoEx.dwMajorVersion && 1 < verInfoEx.dwMinorVersion)	// .NET Server
								||	(5 == verInfoEx.dwMajorVersion && 1 == verInfoEx.dwMinorVersion
										&& 0 < verInfoEx.wServicePackMajor)	// WinXP with SP1 or greater
							)
						)
					{
						//
						// Attempt to get the version, but fail isn't an error
						//
						cchValueSize = 0;
						HRESULT hrVer = SafeRegQueryStringValueCch(hDevRegKey, REGSTR_VAL_DRIVERVERSION, NULL, 0, &cchValueSize);
						if (REG_E_MORE_DATA != hrVer || 0 == cchValueSize)
						{
							LOG_Out(_T("No DRIVERVERSION registry key (optional)"));
						}
						else
						{
							TCHAR szTempVersion[MAX_INF_STRING_LEN];
							//
							// Sanity check size of data in registry
							//
							if (MAX_INF_STRING_LEN > cchValueSize)
							{
								if (S_OK == SafeRegQueryStringValueCch(hDevRegKey, REGSTR_VAL_DRIVERVERSION, (LPTSTR) szTempVersion, cchValueSize, &cchValueSize))
								{
									LPTSTR pszOldDriverVer = *ppszDriverVer;
									int nDate = lstrlen(*ppszDriverVer);
									//
									// Original DriverVer date + DriverVer Version + "|" + NULL
									//
									int nDriverDateAndVer = (nDate + cchValueSize + 2) * sizeof(TCHAR);
									*ppszDriverVer = (LPTSTR) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nDriverDateAndVer);
									if (NULL == *ppszDriverVer)
									{
										//
										// Log the error, but return the DriverVer date without version appended
										//
										LOG_ErrorMsg(ERROR_NOT_ENOUGH_MEMORY);
										*ppszDriverVer = pszOldDriverVer;
									}
									else
									{
										if (SUCCEEDED(hrVer = StringCchPrintf(*ppszDriverVer, nDriverDateAndVer, _T("%s|%s"), pszOldDriverVer, (LPTSTR) szTempVersion)))
										{
											SafeHeapFree(pszOldDriverVer);
										}
										else
										{
											//
											// Restore original DriverVer date and free new alloc
											//
											LOG_ErrorMsg(hrVer);
											SafeHeapFree(*ppszDriverVer);
											*ppszDriverVer = pszOldDriverVer;
										}
									}
								}
							}
						}
					}
				}
#endif
			}
		}
	}

CleanUp:

	if (INVALID_HANDLE_VALUE != hDevRegKey)
	{
		RegCloseKey(hDevRegKey);
	}

	if (FAILED(hr))
	{
		SafeHeapFree(*ppszMatchingID);
		SafeHeapFree(*ppszDriverVer);
	}

	return hr;
}			


HRESULT AddDevicesClass(CXmlSystemSpec& xmlSpec, IU_PLATFORM_INFO iuPlatformInfo, BOOL fIsSysSpecCall)
{
	USES_IU_CONVERSION;
	LOG_Block("AddDevicesClass");

	HRESULT hr = E_NOTIMPL;
	LONG lRet;
	BSTR bstrProvider = NULL;
	BSTR bstrMfgName = NULL;
	BSTR bstrName = NULL;
	BSTR bstrHardwareID = NULL;
	BSTR bstrDriverVer = NULL;
	DWORD dwDeviceIndex = 0;
	HDEVINFO hDevInfoSet = INVALID_HANDLE_VALUE;
	HANDLE_NODE hPrinterDevNode = HANDLE_NODE_INVALID;
	SP_DEVINFO_DATA devInfoData;
	LPTSTR	pszMatchingID = NULL;
	LPTSTR	pszDriverVer= NULL;
	DRIVER_INFO_6* paDriverInfo6 = NULL;
	DWORD dwDriverInfoCount = 0;

	//
	// We only enumerate drivers on Win2K up or Win98 up
	//
	if (  ( (VER_PLATFORM_WIN32_NT == iuPlatformInfo.osVersionInfoEx.dwPlatformId) &&
			(4 < iuPlatformInfo.osVersionInfoEx.dwMajorVersion)
		  )
		  ||
		  ( (VER_PLATFORM_WIN32_WINDOWS == iuPlatformInfo.osVersionInfoEx.dwPlatformId) &&
			(	(4 < iuPlatformInfo.osVersionInfoEx.dwMajorVersion)	||
				(	(4 == iuPlatformInfo.osVersionInfoEx.dwMajorVersion) &&
					(0 < iuPlatformInfo.osVersionInfoEx.dwMinorVersion)	)	)
		  )
		)
	{
		//
		// Get array of DRIVER_INFO_6 holding info on installed printer drivers. Only allocates and returns
		// memory for appropriate platforms that have printer drivers already installed.
		//
		CleanUpIfFailedAndSetHr(GetInstalledPrinterDriverInfo((OSVERSIONINFO*) &iuPlatformInfo.osVersionInfoEx, &paDriverInfo6, &dwDriverInfoCount));

		if (INVALID_HANDLE_VALUE == (hDevInfoSet = SetupDiGetClassDevs(NULL, NULL, NULL, DIGCF_PRESENT | DIGCF_ALLCLASSES)))
		{
			LOG_Error(_T("SetupDiGetClassDevs failed: 0x%08x"), GetLastError());
			return HRESULT_FROM_WIN32(GetLastError());
		}
		
		ZeroMemory(&devInfoData, sizeof(SP_DEVINFO_DATA));
		devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
		while (SetupDiEnumDeviceInfo(hDevInfoSet, dwDeviceIndex++, &devInfoData))
		{
			//
			// 656449 Controls Stops if it incounters a malformed Driver Date
			//
			// Just skip instances where getting the DriverVer returns an error
			//
			if SUCCEEDED(GetMatchingDeviceID(hDevInfoSet, &devInfoData, &pszMatchingID, &pszDriverVer))
			{
				//
				// Write the Hardware & Compatible IDs to XML
				//
				CleanUpIfFailedAndSetHr(AddPrunedDevRegProps(hDevInfoSet, &devInfoData, xmlSpec, pszMatchingID, \
													pszDriverVer, paDriverInfo6, dwDriverInfoCount, fIsSysSpecCall));
			}

			SafeHeapFree(pszMatchingID);
			SafeHeapFree(pszDriverVer);
		}
		if (ERROR_NO_MORE_ITEMS != GetLastError())
		{
				Win32MsgSetHrGotoCleanup(GetLastError());
		}
		//
		// Get the Printer "Hardware IDs" for Win2K up (already checked dwMajorVersion) & WinME
		//
		if (NULL != paDriverInfo6 && 0 != dwDriverInfoCount)
		{
			//
			// Add the driver elements for each printer driver. 
			//
			for (DWORD dwCount = 0; dwCount < dwDriverInfoCount; dwCount++)
			{
				if (   NULL == (paDriverInfo6 + dwCount)->pszHardwareID)
				{
					LOG_Driver(_T("Skiping driver with incomplete ID info"));
					continue;
				}

				//
				// Open a <device> element to write the printer info
				//
				CleanUpFailedAllocSetHrMsg(bstrProvider = T2BSTR((paDriverInfo6 + dwCount)->pszProvider));
				CleanUpFailedAllocSetHrMsg(bstrMfgName = T2BSTR((paDriverInfo6 + dwCount)->pszMfgName));
				CleanUpFailedAllocSetHrMsg(bstrName = T2BSTR((paDriverInfo6 + dwCount)->pName));
				CleanUpIfFailedAndSetHr(xmlSpec.AddDevice(NULL, 1, bstrProvider, bstrMfgName, bstrName, &hPrinterDevNode));
				//
				// Convert ftDriverDate to ISO 8601 prefered format (yyyy-mm-dd)
				//
				SYSTEMTIME systemTime;
				if (0 == FileTimeToSystemTime(&((paDriverInfo6 + dwCount)->ftDriverDate), &systemTime))
				{
					LOG_Error(_T("FileTimeToSystemTime failed:"));
					LOG_ErrorMsg(GetLastError());
					SetHrAndGotoCleanUp(HRESULT_FROM_WIN32(GetLastError()));
				}

				TCHAR szDriverVer[11];
				hr = StringCchPrintfEx(szDriverVer, ARRAYSIZE(szDriverVer), NULL, NULL, MISTSAFE_STRING_FLAGS,
				                       _T("%04d-%02d-%02d"), systemTime.wYear, systemTime.wMonth, systemTime.wDay);
				if (FAILED(hr))
				{
					LOG_Error(_T("wsprintf failed:"));
					LOG_ErrorMsg(GetLastError());
					SetHrAndGotoCleanUp(HRESULT_FROM_WIN32(GetLastError()));
				}

				// Always rank 0 and never fIsCompatible
				CleanUpFailedAllocSetHrMsg(bstrHardwareID = T2BSTR((paDriverInfo6 + dwCount)->pszHardwareID));
				CleanUpFailedAllocSetHrMsg(bstrDriverVer = T2BSTR(szDriverVer));
				CleanUpIfFailedAndSetHr(xmlSpec.AddHWID(hPrinterDevNode, FALSE, 0, bstrHardwareID, bstrDriverVer));
				xmlSpec.SafeCloseHandleNode(hPrinterDevNode);
				//
				// 514009 Apparent memory leak in getting info - Getsystemspec increases memory
				// consumption as follows - approximately 32 Kb when successfully called with all
				// class types (also approximately 8 Kb on failed call to get iexplorer server context)
				//
				// T2BSTR macro calls SysAllocString()
				//
				SafeSysFreeString(bstrProvider);
				SafeSysFreeString(bstrMfgName);
				SafeSysFreeString(bstrName);
				SafeSysFreeString(bstrHardwareID);
				SafeSysFreeString(bstrDriverVer);
			}
		}
	}

CleanUp:

	if (INVALID_HANDLE_VALUE != hDevInfoSet)
	{
		if (0 == SetupDiDestroyDeviceInfoList(hDevInfoSet))
		{
			LOG_Driver(_T("Warning: SetupDiDestroyDeviceInfoList failed: 0x%08x"), GetLastError());
		}
	}

	if (HANDLE_NODE_INVALID != hPrinterDevNode)
	{
		xmlSpec.SafeCloseHandleNode(hPrinterDevNode);
	}

	SafeHeapFree(pszMatchingID);
	SafeHeapFree(pszDriverVer);
	SafeHeapFree(paDriverInfo6);

	SysFreeString(bstrProvider);
	SysFreeString(bstrMfgName);
	SysFreeString(bstrName);
	SysFreeString(bstrHardwareID);
	SysFreeString(bstrDriverVer);

	return hr;
}

/////////////////////////////////////////////////////////////////////////////
// GetSystemSpec()
//
// Gets the basic system specs.
// Input:
// bstrXmlClasses - a list of requested classes in xml format, NULL BSTR if all.
//				    For example:
//						<?xml version=\"1.0\"?>
//						<classes xmlns=\"file://\\kingbird\winupddev\Slm\src\Specs\v4\systeminfoclassschema.xml\">
//							<computerSystem/>
//							<regKeys/>
//							<platform/>
//							<locale/>
//							<devices/>
//						</classes>
//					Where all of the classes are optional.
//
// Return:
// pbstrXmlDetectionResult - the detection result in xml format.
/////////////////////////////////////////////////////////////////////////////
HRESULT WINAPI CEngUpdate::GetSystemSpec(BSTR bstrXmlClasses, DWORD dwFlags, BSTR *pbstrXmlDetectionResult)
{
	USES_IU_CONVERSION;
	LOG_Block("GetSystemSpec");

	//
	// By default we return all <classes/>
	//
	DWORD dwClasses = (COMPUTERSYSTEM | REGKEYS	| PLATFORM | LOCALE | DEVICES);
	HRESULT hr = S_OK;
	IU_PLATFORM_INFO iuPlatformInfo;
	CXmlSystemSpec xmlSpec;

	if (NULL == pbstrXmlDetectionResult)
	{
		LOG_ErrorMsg(E_INVALIDARG);
		return E_INVALIDARG;
	}

	*pbstrXmlDetectionResult = NULL;

	//
	// We have to init iuPlatformInfo (redundant) because we may goto CleanUp before calling DetectClientIUPlatform
	//
	ZeroMemory(&iuPlatformInfo, sizeof(iuPlatformInfo));

    // Set Global Offline Flag - checked by XML Classes to disable Validation (schemas are on the net)
    if (dwFlags & FLAG_OFFLINE_MODE)
    {
        m_fOfflineMode = TRUE;
    }
    else
    {
        m_fOfflineMode = FALSE;
    }

	//
	// 494519 A call to GetSystemSpec with bstrXmlClasses that is less then 10 character suceeds, weather it is valid or invalid XML.
	//
	// If client passes us anything it must be well formed [and possibly valid] XML
	//
	// But, allow BSTRs of length 0 to be treated the same as a NULL BSTR
	//     (497059 A call to GetSystemSpec with bstrXmlClasses equal
	//     to empty string fails.)
	//
	if (NULL != bstrXmlClasses && SysStringLen(bstrXmlClasses) > 0)
	{
		CXmlSystemClass xmlClass;
		if (FAILED(hr = xmlClass.LoadXMLDocument(bstrXmlClasses, m_fOfflineMode)))
		{
			//
			// They probably passed us invalid XML
			//
			goto CleanUp;
		}

		dwClasses = xmlClass.GetClasses();
	}

	

	//
	// Add the ComputerSystem node
	//

	if (dwClasses & COMPUTERSYSTEM)
	{
		CleanUpIfFailedAndSetHr(AddComputerSystemClass(xmlSpec));
	}

	//
	// Enumerate and add the Software RegKey elements
	//
	if (dwClasses & REGKEYS)
	{
		CleanUpIfFailedAndSetHr(AddRegKeyClass(xmlSpec));
	}

	//
	// We need iuPlatformInfo for both <platform> and <devices>  elements
	//
	
	if (dwClasses & (PLATFORM | DEVICES))
	{
		CleanUpIfFailedAndSetHr(DetectClientIUPlatform(&iuPlatformInfo));
	}

	//
	// Add Platform
	//
	if (dwClasses & PLATFORM)
	{
		CleanUpIfFailedAndSetHr(AddPlatformClass(xmlSpec, iuPlatformInfo));
	}

	//
	// Add Locale information
	//
	if (dwClasses & LOCALE)
	{
		//
		// OS locale
		//
		CleanUpIfFailedAndSetHr(AddLocaleClass(xmlSpec, FALSE));
		//
		// USER locale
		//
		CleanUpIfFailedAndSetHr(AddLocaleClass(xmlSpec, TRUE));
	}

	//
	// Add devices
	//
	if (dwClasses & DEVICES)
	{
		CleanUpIfFailedAndSetHr(AddDevicesClass(xmlSpec, iuPlatformInfo, TRUE));
	}

	

CleanUp:

	//
	// Only return S_OK for success (S_FALSE sometimes drops through from above)
	//
	if (S_FALSE == hr)
	{
		hr = S_OK;
	}

	if (SUCCEEDED(hr))
	{
		//
		// Return the spec as a BSTR
		//
		hr = xmlSpec.GetSystemSpecBSTR(pbstrXmlDetectionResult);
	}

	if (SUCCEEDED(hr))
	{
		LogMessage(SZ_GET_SYSTEM_SPEC);
	}
	else
	{
		LogError(hr, SZ_GET_SYSTEM_SPEC);
		//
		// If the DOM allocates but returns error, we will leak, but
		// this is safer than calling SysFreeString()
		//
		*pbstrXmlDetectionResult = NULL;
	}

	SysFreeString(iuPlatformInfo.bstrOEMManufacturer);
	SysFreeString(iuPlatformInfo.bstrOEMModel);
	SysFreeString(iuPlatformInfo.bstrOEMSupportURL);

	return hr;
}



// Function name	: GetSystemPID
// Description	    : This method basically obtaing the encrypted version of the System PID
// This method also converts the binary blob in to string format
// Return type		: HRESULT 
// Argument         : BSTR &bstrPID  --containg the hex encoded string
// author			:a-vikuma



HRESULT GetSystemPID(BSTR &bstrPID)
{

	LOG_Block("GetSystemPID");

	HRESULT hr = S_OK;
	HMODULE hLicDll = NULL;
	PFUNCGetEncryptedPID pPIDEncrProc = NULL;
	
	BYTE *pByte = NULL;
	DWORD dwLen = 0;
	
	LPWSTR 	lpszData = NULL;
	

	if(bstrPID)
	{
		bstrPID = NULL;
	}


	//load the pid encryption library
	hLicDll = LoadLibraryFromSystemDir(SZ_LICDLL);

	if (!hLicDll)
    { 
		hr = HRESULT_FROM_WIN32(GetLastError());
        goto CleanUp;
    }

	//get the pointer to GetEncryptedPID method 
	pPIDEncrProc = (PFUNCGetEncryptedPID)GetProcAddress(hLicDll, lpszIVLK_GetEncPID);

	if (!pPIDEncrProc)
    { 
		hr = HRESULT_FROM_WIN32(GetLastError());
        goto CleanUp;
    }

	CleanUpIfFailedAndSetHrMsg(pPIDEncrProc(&pByte, &dwLen));
	
	
	DWORD dwSize = 0;
	

	//convert the binary stream to string format
	//initially get the length for the string buffer
	CleanUpIfFailedAndSetHrMsg(BinaryToString(pByte, dwLen, lpszData, &dwSize));

	//allocate memory
	CleanUpFailedAllocSetHrMsg( lpszData = (LPWSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize*sizeof(WCHAR)));

	//get the binary blob in string format
	CleanUpIfFailedAndSetHrMsg(BinaryToString(pByte, dwLen, lpszData, &dwSize));

	//convert the LPWSTR to a BSTR
	CleanUpFailedAllocSetHrMsg(bstrPID = SysAllocString(lpszData));

	
CleanUp:

	if(hLicDll)
		FreeLibrary(hLicDll);

	SafeHeapFree(lpszData);

	//LocalFree can take nulls. So not checked if pByte is null
	LocalFree(pByte);

	if(FAILED(hr))
	{
	
		SysFreeString(bstrPID);
		bstrPID = NULL;
	
	}
	return hr;

}


// Function name	: HexEncode
// Description	    : This is a helper function to convert a binary stream in to string format
// Return type		: DWORD 
// Argument         : IN BYTE const *pbIn
// Argument         : DWORD cbIn
// Argument         : WCHAR *pchOut
// Argument         : DWORD *pcchOut

DWORD HexEncode(IN BYTE const *pbIn, DWORD cbIn, WCHAR *pchOut, DWORD *pcchOut)
{
    WCHAR *pszsep;
    WCHAR *psznl;
    DWORD nCount;
    DWORD cbremain;
    DWORD cchOut = 0;

	//each byte needs two characters for encoding
    DWORD cch = 2;
    WCHAR *pch = pchOut;
    DWORD dwErr = ERROR_INSUFFICIENT_BUFFER;
	
    DWORD dwRem = *pcchOut;


	HRESULT hr = S_OK;
   
    for (nCount = 0; nCount < cbIn; nCount ++)
    {
		if (NULL != pchOut)
		{
			if (cchOut + cch + 1 > *pcchOut)
			{
				goto ErrorReturn;
			}
			hr = StringCchPrintfW(pch, dwRem, L"%02x", pbIn[nCount]);
			if(FAILED(hr))
			{
				dwErr = HRESULT_CODE(hr);
				goto ErrorReturn;
			}
			pch += cch;
			dwRem -= cch;
		}
		cchOut += cch;
    }
  
	if (NULL != pchOut)
	{

		*pch = L'\0';

	}

    *pcchOut = cchOut+1;
    dwErr = ERROR_SUCCESS;

ErrorReturn:
    return(dwErr);
}



// Function name	: BinaryToString
// Description	    : This function converts a binary stream in to a string format
// Return type		: HRESULT 
// Argument         : BYTE *lpBinary --The binary stream
// Argument         : DWORD dwLength --The length of the stream
// Argument         : LPWSTR lpString --Pointer to the string which contains the converted encoded data on return
// If this parameter is NULL the DWORD pointed ny pdwLength parameter contains to the size of the buffer needed to hold
// the encoded data
// Argument         : DWORD *pdwLength --pointer to the zise of the string buffer in no of characters


HRESULT BinaryToString(BYTE *lpBinary, DWORD dwLength, LPWSTR lpString, DWORD *pdwLength)
{

	HRESULT hr = S_OK;

	if(!lpBinary || !pdwLength)
		return E_INVALIDARG;

	DWORD dwStatus = HexEncode(lpBinary, dwLength, lpString, pdwLength);

	if(ERROR_SUCCESS != dwStatus)
	{
		hr = HRESULT_FROM_WIN32(dwStatus);

	}
	return hr;
}