windows-xp/Source/XPSP1/NT/enduser/windows.com/wuv3/wudetect/wudetect.cpp

/////////////////////////////////////////////////////////////////////////////
// WUDetect.cpp
//
// Copyright (C) Microsoft Corp. 1998
// All rights reserved
//
/////////////////////////////////////////////////////////////////////////////
//
// Description:
//   DLL loaded by the install engine that exposes entry points
//   that can determines the installation status of legacy or complex
//   components.  The dll name and entry points are specified for a
//   component in the CIF file.
/////////////////////////////////////////////////////////////////////////////

#include "wudetect.h"
//#include <stdio.h>
//#include <tTCHAR.h>

//#include <nt.h>
//#include <ntrtl.h>
//#include <nturtl.h>

//#include <windows.h>
//#include <objbase.h>

//#include <inseng.h>
//#include <detdlls.h>
//#include <utils2.h>


/////////////////////////////////////////////////////////////////////////////
// dwKeyType
//   Determines the registry root (HKLM, HKCU, etc) that the key lies under.
//
// Parameters:
//
// Comments :
/////////////////////////////////////////////////////////////////////////////

inline DWORD dwKeyType(TCHAR *szBuf, HKEY *phKey, TCHAR * szKeyName, DWORD dwSize)
{
	DWORD dwStatus = ERROR_SUCCESS;
	TCHAR szRootType[MAX_PATH];

	if ( (GetStringField2(szBuf, 0, szRootType, sizeof(szRootType)/sizeof(TCHAR)) == 0) ||
	     (GetStringField2(szBuf, 1, szKeyName, dwSize) == 0) )
	{
		dwStatus = ERROR_BADKEY;
	}
	else if ( lstrcmpi(HKEY_LOCAL_MACHINE_ROOT, szRootType) == 0 )
	{
		*phKey = HKEY_LOCAL_MACHINE; 
	}
	else if ( lstrcmpi(HKEY_CURRENT_USER_ROOT, szRootType) == 0 )
	{
		*phKey = HKEY_CURRENT_USER; 
	}
	else if ( lstrcmpi(HKEY_CLASSES_ROOT_ROOT, szRootType) == 0 )
	{
		*phKey = HKEY_CLASSES_ROOT; 
	}
	else if ( lstrcmpi(HKEY_CURRENT_CONFIG_ROOT, szRootType) == 0 )
	{
		*phKey = HKEY_CURRENT_CONFIG; 
	}
	else if ( lstrcmpi(HKEY_USERS_ROOT, szRootType) == 0 )
	{
		*phKey = HKEY_USERS; 
	}
	else if ( lstrcmpi(HKEY_PERFORMANCE_DATA_ROOT, szRootType) == 0 )
	{
		*phKey = HKEY_PERFORMANCE_DATA;
	}
	else if ( lstrcmpi(HKEY_DYN_DATA_ROOT, szRootType) == 0 )
	{
		*phKey = HKEY_DYN_DATA; 
	}
	else
	{
		dwStatus = ERROR_BADKEY;
	}

	return dwStatus;
}

/////////////////////////////////////////////////////////////////////////////
// dwParseValue
//
//   Parses out the registry key name, value, and type that needs to
//   be opened to determine the installation status of the component.
/////////////////////////////////////////////////////////////////////////////

inline DWORD dwParseValue(TCHAR * szBuf, TargetRegValue & targetValue)
{
	DWORD dwStatus = ERROR_BADKEY;
	TCHAR szType[MAX_PATH]; // BUGBUG - get real value
	TCHAR szValue[MAX_PATH]; // BUGBUG - get real value

	// get the data type
	if ( (GetStringField2(szBuf, 0, targetValue.szName, sizeof(targetValue.szName)/sizeof(TCHAR)) != 0) &&
		 (GetStringField2(szBuf, 1, szType, sizeof(szType)/sizeof(TCHAR)) != 0) )
	{
		if ( lstrcmpi(REG_NONE_TYPE, szType) == 0 )
		{
			targetValue.type = REG_NONE; 
			dwStatus = ERROR_SUCCESS;
		}
		else 
		{
			if ( GetStringField2(szBuf, 2, szValue, sizeof(szValue)/sizeof(TCHAR)) != 0 )
			{
				if ( lstrcmpi(REG_DWORD_TYPE, szType) == 0 )
				{
					targetValue.type = REG_DWORD; 
					targetValue.dw = _ttol(szValue);
					dwStatus = ERROR_SUCCESS;
				}
				else if ( lstrcmpi(REG_SZ_TYPE, szType) == 0 )
				{
					targetValue.type = REG_SZ; 
					lstrcpy(targetValue.sz, szValue);
					dwStatus = ERROR_SUCCESS;
				}
			}
		}
	}

	return dwStatus;
}

/////////////////////////////////////////////////////////////////////////////
// fCompareVersion
//
// Returns: 1,0,-1 depending on whether dwVersion1 is greater than, equal, or
// less than dwVersion2.
/////////////////////////////////////////////////////////////////////////////

inline int nCompareVersion(IN  DWORD dwVer1,
						   IN  DWORD dwBuild1,
			               IN  DWORD dwVer2,
						   IN  DWORD dwBuild2)
{
	int nResult = 0;

	if ( dwVer1 > dwVer2 )
	{
		nResult = 1;
	}
	else if ( dwVer1 < dwVer2 )
	{
		nResult = -1;
	}
	else if ( dwBuild1 > dwBuild2 ) // dwVer1 == dwVer2
	{
		nResult = 1;
	}
	else if ( dwBuild1 < dwBuild2 ) // dwVer1 == dwVer2
	{
		nResult = -1;
	}

	return nResult;
}

/////////////////////////////////////////////////////////////////////////////
// GetCifEntry
//   Get an entry from the CIF file.
//
// Comments :
//   We get the value differently depending on whether we are being
//   called by IE 4 or IE 5 Active Setup.
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
//
// Function FGetCifEntry
//---------------------------------------------------------------------------
//
// Return Value --- TRUE if Successfully retrieved CIF file value
//                  FALSE if failed
// Parameter 
//          TCHAR* pszParamName --- [IN] Name of the CIF file
//          TCHAR* pszParamValue --- [OUT] Value of the CIF file
//          DWORD cbParamValue --- size of the pszParamValue in TCHAR
// NOTE: This function calls GetCustomData to retrieve the value of CIF file
//       GetCustomData is defined in inseng.h which takes only ANSI strings.
//       Thus, UNICODE version of this function needed to convert parameters 
//       to and from ANSI compatibles.
// NOTE: This is a global function. Don't mixed with member function of 
//       CExpressionParser::fGetCifEntry
//
/////////////////////////////////////////////////////////////////////////////
//
// Modified by RogerJ, 03/09/00
// Original Creator Unknown (YanL?)
// Modification --- UNICODE and Win64 enabled
//
/////////////////////////////////////////////////////////////////////////////

inline bool FGetCifEntry(DETECTION_STRUCT* pDetection,
						 TCHAR *pszParamName,
						 TCHAR *pszParamValue, 
						 DWORD cbParamValue)
// pszParamName is [IN], pszParamValue is [OUT], the function GetCustomData requires
// LPSTR for both parameters, string conversion is necessary in the UNICODE case
{
#ifdef UNICODE	
	bool fSucceed;
	char pszParamNameANSI[MAX_PATH];
	char pszParamValueANSI[MAX_PATH];


	// do UNICODE to ANSI string conversion	
	// only pszParamName [IN] parameter need to be converted
	// wcstombs and mbstowcs do not ensure the last character is NULL
	// ensure manually
	wcstombs(pszParamNameANSI,pszParamName,MAX_PATH-1);
	pszParamNameANSI[MAX_PATH-1]=NULL;

	// make actual function call
    fSucceed= (ERROR_SUCCESS == pDetection->pCifComp->GetCustomData(pszParamNameANSI, 
														pszParamValueANSI, 
														cbParamValue));
	// do ANSI to UNICODE string conversion
	// only pszParamValue [OUT] parameter need to be converted
	mbstowcs(pszParamValue,pszParamValueANSI,cbParamValue-1);
	pszParamValue[cbParamValue-1]=(TCHAR)NULL;
	return fSucceed;


#else

	return (ERROR_SUCCESS == pDetection->pCifComp->GetCustomData(pszParamName, 
														pszParamValue, 
														cbParamValue));
#endif
}


/////////////////////////////////////////////////////////////////////////////
// RegKeyExists (EXPORT)
//   This API will determine if an application exists based on the
//   existence of a registry key and perhaps a value.
//
// Parameters:
//
// Comments :
/////////////////////////////////////////////////////////////////////////////

DWORD WINAPI RegKeyExists(DETECTION_STRUCT *pDetection)
{
	DWORD dwInstallStatus = DET_NOTINSTALLED;
	HKEY hKeyRoot;
	HKEY hKey;
	DWORD type;
	TCHAR szTargetKeyName[MAX_PATH];
	TCHAR szTargetKeyValue[MAX_PATH];
	TCHAR szBuf[MAX_PATH];
	DWORD dwStatus;
	//DWORD dwLen;
	
    // make sure the struct is of the expected size
    if ( (pDetection->dwSize >= sizeof(DETECTION_STRUCT)) )
	{
		// get the registry key name from the components section of the
		// CIF file.
		if ( FGetCifEntry(pDetection, DETREG_KEY, szBuf, sizeof(szBuf)/sizeof(TCHAR)) )
		{
			if ( (dwStatus = dwKeyType(szBuf, &hKeyRoot, szTargetKeyName, sizeof(szTargetKeyName)/sizeof(TCHAR))) == ERROR_SUCCESS )
			{
			   // determine if we should log transmissions
			   if ( RegOpenKeyEx(  hKeyRoot,
									szTargetKeyName,
									0,
									KEY_QUERY_VALUE,
									&hKey) == ERROR_SUCCESS )
			   {
					if ( FGetCifEntry(pDetection, DETREG_VALUE, szTargetKeyValue, sizeof(szTargetKeyValue)/sizeof(TCHAR)) )
					{
						TargetRegValue targetValue;
						

						dwStatus = dwParseValue(szTargetKeyValue, targetValue);

						if ( dwStatus == ERROR_SUCCESS )
						{
    						ActualKeyValue keyvalue;
							DWORD size = sizeof(keyvalue);

							if ( RegQueryValueEx(hKey,
												   targetValue.szName,
												   0,
												   &type,
												   (BYTE *)&keyvalue,
												   &size) == ERROR_SUCCESS )
							{
								switch ( targetValue.type )
								{
								case REG_NONE:
									{
										dwInstallStatus = DET_INSTALLED;
										break;
									}
								case REG_DWORD:
									{
										if ( (type == REG_DWORD) || 
										     ((type == REG_BINARY) && (size >= sizeof(DWORD))) )
										{
											// see if we have a match
											if ( targetValue.dw == keyvalue.dw )
											{
												*pDetection->pdwInstalledVer = 1; 
												*pDetection->pdwInstalledBuild = 1; 
												dwInstallStatus = DET_INSTALLED;
											}
										}
										break;
									}
								case REG_SZ:
									{
										if ( type == REG_SZ )
										{
										   if ( lstrcmpi(targetValue.sz, keyvalue.sz) == 0 )
										   {
											   *pDetection->pdwInstalledVer = 1; 
											   *pDetection->pdwInstalledBuild = 1; 
											   dwInstallStatus = DET_INSTALLED;
										   }
										}
										break;
									}
								} // switch
							}
						}
					}
					else
					{
						// no REG value so, REGPATH is sufficient to determine
						// installation.
					   *pDetection->pdwInstalledVer = 1; 
					   *pDetection->pdwInstalledBuild = 1; 
					   dwInstallStatus = DET_INSTALLED;
					}
					RegCloseKey(hKey);
			   }
		   }
		}
	}

	return dwInstallStatus;
}


/////////////////////////////////////////////////////////////////////////////
// RegKeyVersion (EXPORT)
//
//   This API will determine if an application exists based on the
//   existence of a version number in the registry.
/////////////////////////////////////////////////////////////////////////////

DWORD WINAPI RegKeyVersion(DETECTION_STRUCT *pDetection)
{
	DWORD dwInstallStatus = DET_NOTINSTALLED;
	HKEY hKeyRoot;
	HKEY hKey;
	DWORD type;
	TCHAR szTargetKeyName[MAX_PATH];
	TCHAR szTargetKeyValue[MAX_PATH];
	TCHAR szAskVersion[MAX_PATH];
	//TCHAR szVersion[MAX_VERSION_STRING_LEN];
	TCHAR szBuf[MAX_PATH];
	//DWORD dwStatus;
	//DWORD dwLen;
	DWORD dwVer;
	DWORD dwBuild;
	DWORD dwAskVer;
	DWORD dwAskBuild;
	
    // make sure the struct is of the expected size
    if ( pDetection->dwSize < sizeof(DETECTION_STRUCT) )
	{
		goto cleanup;
	}

	// get the registry key name from the components section of the
	// CIF file.
	if ( FGetCifEntry(pDetection, DETREG_KEY, szBuf, sizeof(szBuf)/sizeof(TCHAR)) &&
		 (dwKeyType(szBuf, &hKeyRoot, szTargetKeyName, sizeof(szTargetKeyName)/sizeof(TCHAR)) == ERROR_SUCCESS) )
	{
	   if ( RegOpenKeyEx(  hKeyRoot,
							szTargetKeyName,
							0,
							KEY_QUERY_VALUE,
							&hKey) == ERROR_SUCCESS )
	   {
			if ( FGetCifEntry(pDetection, DETREG_VERSION, szBuf, sizeof(szBuf)/sizeof(TCHAR)) &&
	            (GetStringField2(szBuf, 0, szTargetKeyValue, sizeof(szTargetKeyValue)/sizeof(TCHAR)) != 0) )
			{
				DWORD size = sizeof(szBuf);

				if (GetStringField2(szBuf, 1, szAskVersion, sizeof(szAskVersion)/sizeof(TCHAR)) != 0)
				{
					fConvertDotVersionStrToDwords(szAskVersion, &dwAskVer, &dwAskBuild);
				}
				else
				{
					dwAskVer = pDetection->dwAskVer;
					dwAskBuild = pDetection->dwAskBuild;
				}

				if ( RegQueryValueEx(hKey,
									   szTargetKeyValue,
									   0,
									   &type,
									   (BYTE *)szBuf,
									   &size) == ERROR_SUCCESS )
				{
					if ( type == REG_SZ )
					{
						fConvertDotVersionStrToDwords(szBuf, &dwVer, &dwBuild);

						if ( nCompareVersion(dwVer, dwBuild, dwAskVer, dwAskBuild) >= 0 )
						{
							*pDetection->pdwInstalledVer = 1; 
							*pDetection->pdwInstalledBuild = 1; 
							dwInstallStatus = DET_INSTALLED;
						}
					}
				}
			}
			RegCloseKey(hKey);
	   }
	}

cleanup:
	return dwInstallStatus;
}


/////////////////////////////////////////////////////////////////////////////
// RegKeySubStr (EXPORT)
//
//   This API will determine if an application exists based on the
//   existence of one of a number of sub strings in the data.
/////////////////////////////////////////////////////////////////////////////

DWORD WINAPI RegKeySubStr(DETECTION_STRUCT *pDetection)
{
	DWORD dwInstallStatus = DET_NOTINSTALLED;
	HKEY hKeyRoot;
	HKEY hKey;
	DWORD type;
	TCHAR szTargetKeyName[MAX_PATH];
	TCHAR szTargetKeyValue[MAX_PATH];
	TCHAR szKeyMissingStatus[MAX_PATH];
	TCHAR szData[MAX_PATH];
	TCHAR szSubStr[MAX_PATH];
	//TCHAR szTmp[MAX_PATH];
	TCHAR szBuf[MAX_PATH];
	//DWORD dwStatus;
	//DWORD dwLen;
	//DWORD dwVer;
	//DWORD dwBuild;
	
    // make sure the struct is of the expected size
    if ( pDetection->dwSize < sizeof(DETECTION_STRUCT) )
	{
		goto cleanup;
	}

	// get the registry key name from the components section of the
	// CIF file.
	if ( FGetCifEntry(pDetection, DETREG_KEY, szBuf, sizeof(szBuf)/sizeof(TCHAR)) &&
		 (dwKeyType(szBuf, &hKeyRoot, szTargetKeyName, sizeof(szTargetKeyName)/sizeof(TCHAR)) == ERROR_SUCCESS) )
	{
	   if ( RegOpenKeyEx(  hKeyRoot,
							szTargetKeyName,
							0,
							KEY_QUERY_VALUE,
							&hKey) == ERROR_SUCCESS )
	   {
			if ( FGetCifEntry(pDetection, DETREG_SUBSTR, szBuf, sizeof(szBuf)/sizeof(TCHAR)) &&
	            (GetStringField2(szBuf, 0, szTargetKeyValue, sizeof(szTargetKeyValue)/sizeof(TCHAR)) != 0) &&
	            (GetStringField2(szBuf, 1, szKeyMissingStatus, sizeof(szKeyMissingStatus)/sizeof(TCHAR)) != 0) )
			{
				DWORD size = sizeof(szData);

				if ( RegQueryValueEx(hKey,
									   szTargetKeyValue,
									   0,
									   &type,
									   (BYTE *)szData,
									   &size) == ERROR_SUCCESS )
				{
					if ( type == REG_SZ )
					{
						_tcslwr(szData);

						// iterate thru the substrings looking for a match.
						int index = 2;
						while ( GetStringField2(szBuf, index, szSubStr, sizeof(szSubStr)/sizeof(TCHAR)) != 0 )
						{
							_tcslwr(szSubStr);

							if ( _tcsstr(szData, szSubStr) != NULL )
							{
								*pDetection->pdwInstalledVer = 1; 
								*pDetection->pdwInstalledBuild = 1;
								dwInstallStatus = DET_INSTALLED;
								goto quit_while;
							}
							index++;
						}
quit_while:;
					}
				}
				else
				{
					// if we get an error, assume the key does not exist.  Note that if
					// the status is DETFIELD_NOT_INSTALLED then we don't have to do 
					// anything since that is the default status.
					if ( lstrcmpi(DETFIELD_INSTALLED, szKeyMissingStatus) == 0 )
					{
						dwInstallStatus = DET_INSTALLED;
					}
				}
			}
			RegCloseKey(hKey);
	   }
	}

cleanup:
	return dwInstallStatus;
}


/////////////////////////////////////////////////////////////////////////////
// MinFileVersion (EXPORT)
//   This API will determine if an application exists based on the
//   minimum version of a file.
//
// Parameters:
//
// Comments :
/////////////////////////////////////////////////////////////////////////////

DWORD WINAPI MinFileVersion(DETECTION_STRUCT *pDetection)
{
	DWORD dwInstallStatus = DET_INSTALLED;
	TCHAR szDllName[MAX_PATH];
	TCHAR szVersion[MAX_PATH];
    DWORD dwSize;
    DWORD dwHandle;
    TCHAR *pszVerInfo[MAX_PATH];
    VS_FIXEDFILEINFO	*vsVerInfo;
    UINT				uLen;
	
    // make sure the struct is of the expected size
    if ( pDetection->dwSize >= sizeof(DETECTION_STRUCT) )
	{
		// get the dll name and version from the components section of the
		// CIF file.
		if ( FGetCifEntry(pDetection, DETREG_KEY, szDllName, sizeof(szDllName)/sizeof(TCHAR)) )
		{
            if ( FGetCifEntry(pDetection, DETREG_VALUE, szVersion, sizeof(szVersion)/sizeof(TCHAR)) )
            {
                PTSTR pszPoint = szDllName;
                PTSTR pszPoint2 = szDllName;
                TCHAR szNewDllName[MAX_PATH];
                                        
                while (*pszPoint != '\0')
                {
                    if (*pszPoint == '%')
                    {
                        *pszPoint = '\0';
                        pszPoint += 1;

                        pszPoint2 = pszPoint;
                        
                        while (pszPoint2 != '\0')
                        {
                            if (*pszPoint2 == '%')
                            {
                                *pszPoint2 = '\0';
                                pszPoint2 += 1;
                                break;
                            }
                            pszPoint2 += 1;
                        }
                        break;
                    }
                    pszPoint += 1;
                }

                if (lstrcmpi(pszPoint, TEXT("11")) == 0)
                {
                    TCHAR szSystemDir[MAX_PATH];
                    GetSystemDirectory(szSystemDir, sizeof(szSystemDir)/sizeof(TCHAR));
                    lstrcpy(szNewDllName, szSystemDir);
                    if ((lstrlen(szSystemDir) + lstrlen(pszPoint2)) < sizeof(szNewDllName)/sizeof(TCHAR))
                    {
                        lstrcat(szNewDllName, pszPoint2);
                    }
                }

                dwSize = GetFileVersionInfoSize(szNewDllName, &dwHandle);
                if (dwSize > 0)
                {
		            if(dwSize > MAX_PATH)
			            dwSize = MAX_PATH;

		            GetFileVersionInfo(szNewDllName, dwHandle, dwSize, &pszVerInfo);
		            VerQueryValue(&pszVerInfo, TEXT("\\"), (void **) &vsVerInfo, &uLen);

                    DWORD dwDllVersion[4];
                    DWORD dwCheckVersion[4];

                    dwDllVersion[0] = HIWORD(vsVerInfo->dwProductVersionMS);
                    dwDllVersion[1] = LOWORD(vsVerInfo->dwProductVersionMS);
                    dwDllVersion[2] = HIWORD(vsVerInfo->dwProductVersionLS);
                    dwDllVersion[3] = LOWORD(vsVerInfo->dwProductVersionLS);

                    pszPoint = szVersion;
                    pszPoint2 = szVersion;

                    INT i = 0;

                    while (*pszPoint != '\0')
                    {
                        if (*pszPoint == ',')
                        {
                            *pszPoint = '\0';
                            dwCheckVersion[i] = _ttol(pszPoint2);
                            i += 1;
                            pszPoint2 = pszPoint + 1;
                        }
                        pszPoint += 1;
                    }
                    dwCheckVersion[i] = _ttol(pszPoint2);

                    for (i = 0; i < 4; i += 1)
                    {
                        if (dwDllVersion[i] < dwCheckVersion[i])
                        {
                            dwInstallStatus = DET_NOTINSTALLED;
                        }
                    }
                } else {
					dwInstallStatus = DET_NOTINSTALLED;
				}

                *pDetection->pdwInstalledVer = 1; 
                *pDetection->pdwInstalledBuild = 1; 
            }
		}
	}

	return dwInstallStatus;
}


/////////////////////////////////////////////////////////////////////////////
// Expression (EXPORT)
//
//   This API will evaluate a boolean expression where every operand is a
//   detection operation.
/////////////////////////////////////////////////////////////////////////////

const DWORD MAX_EXPRESSION_LEN = 1024;

DWORD WINAPI Expression(DETECTION_STRUCT *pDetection)
{
	DWORD dwInstallStatus = DET_NOTINSTALLED;
	//HKEY hKeyRoot;
	//HKEY hKey;
	//DWORD type;
	//TCHAR szTargetKeyName[MAX_PATH];
	//TCHAR szTargetKeyValue[MAX_PATH];
	//TCHAR szKeyMissingStatus[MAX_PATH];
	//TCHAR szData[MAX_PATH];
	//TCHAR szSubStr[MAX_PATH];
	//TCHAR szTmp[MAX_PATH];
	TCHAR szExpression[MAX_EXPRESSION_LEN];
	//DWORD dwStatus;
	//DWORD dwLen;
	//DWORD dwVer;
	//DWORD dwBuild;
	
    // make sure the struct is of the expected size
    if ( pDetection->dwSize < sizeof(DETECTION_STRUCT) )
	{
		goto cleanup;
	}

	// get the expression.
	if ( FGetCifEntry(pDetection, DET_EXPRESSION, szExpression, sizeof(szExpression)/sizeof(TCHAR)) )
	{
		CExpressionParser expression(pDetection);
		bool fResult = TRUE;
		HRESULT hr = expression.fEvalExpression(szExpression, &fResult);

		if ( SUCCEEDED(hr) && fResult)
		{
			*pDetection->pdwInstalledVer = 1; 
            *pDetection->pdwInstalledBuild = 1; 
			dwInstallStatus = DET_INSTALLED;
		}
	}

cleanup:
	return dwInstallStatus;
}