windows-xp/Source/XPSP1/NT/com/ole32/olethunk/tools/clschk/classchk.cxx

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1993.
//
//  File:       classchk.cxx
//
// Classchk is a program for verifying that the contents of the registry are
// OKY-DOKY as far as OLE is concerned.
//
// In general, we verify that all CLSID's are of the correct length, all string
// parameters are NULL terminated.
//
// There are several phases of checking.
//
// 1) Checking that PROGID entries that have CLSID sections match.
// 2) Checking that PROGID entries have correct and existing protocol entries
// 3) Checking that PROGID entries
//
//  History:    5-31-95   kevinro   Created
//
//----------------------------------------------------------------------------

#include <windows.h>
#include <stdio.h>
#include <ctype.h>
#include "classchk.h"

//
// The following registry values are used quite a few times in this program.
// These global variables keep us from needing to open them constantly.
//

HKEY hkey_clsid = 0;

DWORD g_VerbosityLevel = VERB_LEVEL_WARN | VERB_LEVEL_ERROR;

#define StrICmp(x,y) (CompareString(LOCALE_USER_DEFAULT,NORM_IGNORECASE,x,-1,y,-1) - 2)
//+---------------------------------------------------------------------------
//
//  Function:   ReadRegistryString
//
//  Synopsis:	Reads a string from the registry
//
//  Effects:
//
// 	This function reads in a string from the registry, and does some basic
// 	consistency checking on it, such as verifying the length and NULL
// 	terminatation.
//
//
//  Arguments:  [hkeyRoot] --
//		[pszSubKeyName] --
//		[pszValueName] --
//		[pszValue] --
//		[pcbValue] --
//
//  Returns:	ERROR_SUCCESS		Everything peachy
//		ERROR_FILE_NOT_FOUND	Couldn't read entry from registry
//		CLASSCHK_SOMETHINGODD	Something about the string is wrong
//		(other)			Return value from registry
//
//  Signals:
//
//  Modifies:
//
//  Algorithm:
//
//  History:    5-31-95   kevinro   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
DWORD ReadRegistryString( HKEY hkeyRoot, LPSTR pszSubKeyName, LPSTR pszValueName, LPSTR pszValue, PULONG pcbValue)
{
	LONG lRetValue;
	DWORD dwType;
	DWORD dwReturn = ERROR_SUCCESS;
	HKEY hkey = hkeyRoot;

	if(pszSubKeyName != NULL)
	{
		lRetValue = RegOpenKeyEx(hkeyRoot,
					 pszSubKeyName,
					 NULL,
					 KEY_READ,
				 	 &hkey);

                //
		// It is common to see keys that don't exist. Let the caller decide if it is
		// important or not.
		//
		if(lRetValue != ERROR_SUCCESS)
		{
			VERBOSITY(VERB_LEVEL_TRACE,printf("Unable to open subkey %s to read value %s\n",pszSubKeyName,pszValueName););
			return lRetValue;
		}
	}

	lRetValue = RegQueryValueEx(hkey,
				    pszValueName,
				    NULL,		// Must be NULL according to spec
				    &dwType,
				    (BYTE *)pszValue,
				    pcbValue);
	if(hkeyRoot != hkey)
	{
		//
		//  Always close the new subkey if we opened it
		//
		RegCloseKey(hkey);
	}

	switch(lRetValue)
	{
		case ERROR_SUCCESS:
			//
			// Read the value, everything A-OK
			//
			break;
		case ERROR_MORE_DATA:
			VERBOSITY(VERB_LEVEL_WARN,printf("The value '%s' is larger than expected. May be a problem\n",pszValueName);)
			return lRetValue;
			break;

		case ERROR_FILE_NOT_FOUND:
			//
			// This may be expected, so don't report any errors. Let the caller handle that
			//
			return lRetValue;
		default:
			VERBOSITY(VERB_LEVEL_WARN,printf("RegQueryValueEx() for '%s' returned unexpected error 0x%x\n",pszValueName,lRetValue);)
			return lRetValue;
	}

	//
	// We expect this type to be REG_SZ. If it isn't, complain
	//
	if(dwType != REG_SZ)
	{
		VERBOSITY(VERB_LEVEL_WARN,printf("The value for '%s' is type 0x%x, was expecting REG_SZ (0x%x)\n",pszValueName,dwType,REG_SZ);)
		dwReturn = CLASSCHK_SOMETHINGODD;
	}

	//
	// We expect the value to be NULL terminated
	//
	if(pszValue[(*pcbValue)-1] != 0)
	{

		VERBOSITY(VERB_LEVEL_WARN,printf("The value for '%s' may not be NULL terminated.\n",pszValueName);)
	}

	//
	// We expect strlen to be the same as the length returned (which includes the NULL)
	//
	if((strlen(pszValue) + 1) != *pcbValue)
	{
		VERBOSITY(VERB_LEVEL_WARN,printf("The string value for '%s' may not have the correct length\n",pszValueName);)
		if(dwType == REG_SZ)
		{
			VERBOSITY(VERB_LEVEL_WARN,printf("The string value is '%s'\n",pszValue);)
		}
		dwReturn = CLASSCHK_SOMETHINGODD;
	}

	return dwReturn;
}

//+---------------------------------------------------------------------------
//
//  Function:   AllHexDigits
//
//  Synopsis:   Verify that all of the digits specified are hexidecimal
//
//  Effects:
//
//  Arguments:  [pszString] -- String to check
//		[chString] -- Number of characters
//
//  Requires:
//
//  Returns:    TRUE	All hex digits
//		FALSE	Not all hex digits
//
//  History:    5-31-95   kevinro   Created
//----------------------------------------------------------------------------
BOOL AllHexDigits(LPSTR pszString, ULONG chString)
{
	while(chString--)
	{
		if(!isxdigit(pszString[chString]))
		{
			return FALSE;
		}
	}
	return TRUE;
}


//+---------------------------------------------------------------------------
//
//  Function:   CheckForValidGuid
//
//  Synopsis:   Given a string, determine if the string is a GUID
//
//  Arguments:  [pszValue] -- String to check
//
//  History:    5-31-95   kevinro   Created
//
//----------------------------------------------------------------------------
DWORD CheckForValidGuid(LPSTR pszValue)
{
	DWORD dwResult = 0;
	if((strlen(pszValue) != 38) || (pszValue[0] != '{') || (pszValue[37] != '}'))
	{
	    dwResult = CLASSCHK_SOMETHINGODD;
	}
	else
	{
	    // Check the internals of the GUID.
	    if(!AllHexDigits(&pszValue[1],8) ||
	       pszValue[9] != '-' ||				
	       !AllHexDigits(&pszValue[10],4) ||
	       pszValue[14] != '-' ||
	       !AllHexDigits(&pszValue[15],4) ||
	       pszValue[19] != '-' ||
	       !AllHexDigits(&pszValue[20],4) ||
	       pszValue[24] != '-' ||
	       !AllHexDigits(&pszValue[25],12) )
	    {
		dwResult = CLASSCHK_SOMETHINGODD;
	    }	
	}
	return dwResult;	
}

//+---------------------------------------------------------------------------
//
//  Function:   ReadRegistryGuid
//
//  Synopsis:   Read a GUID from the registry, and check to see if it is valid.
//
//  Arguments:  [hkey] -- Key to start from
//		[pszSubKeyName] -- Subkey relative to hkey (NULL if hkey)
//		[pszValueName] -- Value name (NULL if default value)
//		[pszValue] -- Pointer to return buffer
//		[pcbValue] -- Size of return buffer in characters
//
//  Returns:    ERROR_SUCCESS		Read and verified GUID
//		(other)			Something is wrong
//		ERROR_FILE_NOT_FOUND	Key didn't exist
//		CLASSCHK_SOMETHINGODD	Read key, but something is wrong with it.
//
//  History:    5-31-95   kevinro   Created
//
//----------------------------------------------------------------------------
DWORD ReadRegistryGuid( HKEY hkey, LPSTR pszSubKeyName, LPSTR pszValueName, LPSTR pszValue, PULONG pcbValue)
{
	DWORD dwResult;
	//
	// First, just read the value from the registry.
	//
	dwResult = ReadRegistryString(hkey, pszSubKeyName, pszValueName, pszValue, pcbValue);

	if(dwResult == ERROR_SUCCESS)
	{
	    //
	    // Do some additional basic checking, such as the length being correct, and the
	    // GUID correctly formed.
	    //
	    dwResult = CheckForValidGuid(pszValue);
	    if(dwResult != ERROR_SUCCESS)
	    {
		VERBOSITY(VERB_LEVEL_ERROR,printf("*** Malformed GUID '%s' ***\n",pszValue);)
	    }

	}
	return dwResult;
}

//+---------------------------------------------------------------------------
//
//  Function:   ReadRegistryFile
//
//  Synopsis:   Read a registry entry which is supposed to be a file,
//		and determine if the file exists
//
//  Arguments:  [hkey] -- Key to start from
//		[pszSubKeyName] -- Subkey relative to hkey (NULL if hkey)
//		[pszValueName] -- Value name (NULL if default value)
//		[pszValue] -- Pointer to return buffer
//		[pcbValue] -- Size of return buffer in characters
//
//  Returns:    ERROR_SUCCESS		Read and verified
//		(other)			Something is wrong
//		ERROR_FILE_NOT_FOUND	Key didn't exist
//		CLASSCHK_SOMETHINGODD	Read key, but something is wrong with it.
//
//  History:    5-31-95   kevinro   Created
//
//----------------------------------------------------------------------------

ReadRegistryFile(HKEY hkey, LPSTR pszSubKeyName, LPSTR pszValueName, LPSTR pszValue, PULONG pcbValue)
{
	DWORD dwResult;
	//
	// First, just read the value from the registry.
	//
	dwResult = ReadRegistryString(hkey, pszSubKeyName, pszValueName, pszValue, pcbValue);

	if (dwResult == ERROR_SUCCESS)
	{
		char achFoundPath[MAX_PATH];
		char *pszFileNamePart;
		//
		// Some apps append a switch at the end.
		// If there is a switch, terminate the path at that point
		//
		if(pszFileNamePart = strchr(pszValue,'/'))
		{
			*pszFileNamePart = 0;
		}
		else if(pszFileNamePart = strchr(pszValue,'-'))
		{
		    //
		    // Some applications also use the '-' character
		    // as a switch delimiter. If this character is in
		    // the string, and the previous character is a space,
		    // then assume it is a delimiter. This isn't foolproof,
		    // but it should work most of the time.
		    //
		    if(pszFileNamePart[-1] == ' ')
		    {
			*pszFileNamePart = 0;
		    }
		}

		if(SearchPath(NULL,pszValue,NULL,MAX_PATH,achFoundPath,&pszFileNamePart) == 0)
		{
			//
			// Didn't find the name in the path.
			//
			VERBOSITY(VERB_LEVEL_ERROR,printf("*** Could not find path '%s' ***\n",pszValue));
			dwResult = CLASSCHK_SOMETHINGODD;

		}
		else
		{
			VERBOSITY(VERB_LEVEL_TRACE,printf("Found path %s (%s)\n",achFoundPath,pszValue));
		}

	}

	return dwResult;
}

//+---------------------------------------------------------------------------
//
//  Function:   CheckProgID
//
//  Synopsis:
//
// Given a PROGID entry, do some checking to insure the entry is sane. Of the things to check,
// we should check to insure the name string is readable. If there is a CLSID entry, we should
// check to see if it has a CLSID in it.
//
//
//  Arguments:  [pszProgID] -- PROGID string to check
//
//  History:    5-31-95   kevinro   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
DWORD CheckProgID(LPSTR pszProgID)
{

    LONG lRetValue = 0;
    char achValue[MAX_PATH];
    DWORD cbValue;
    DWORD dwRetValue;
    HKEY progidKey = NULL;


    lRetValue = RegOpenKeyEx(HKEY_CLASSES_ROOT,
			     pszProgID,
			     NULL,
			     KEY_READ,
			     &progidKey);

    if(lRetValue == ERROR_SUCCESS)
    {
	cbValue = MAX_PATH;
	
	//
	// Read the default key value for the PROGID. Normally, this should be the name of the class name
	// or program name that would be shown.
	//
	dwRetValue = ReadRegistryString(progidKey,NULL,NULL,achValue,&cbValue);

	if(dwRetValue == CLASSCHK_SOMETHINGODD)
	{
		VERBOSITY(VERB_LEVEL_WHINE,printf("HKEY_CLASSES_ROOT\\%s found odd description '%s'\n",pszProgID,achValue);)
	}

	cbValue = MAX_PATH;

	dwRetValue = ReadRegistryGuid(progidKey,"CLSID",NULL,achValue,&cbValue);

	switch(dwRetValue)
	{
		case ERROR_SUCCESS:
			break;
		case ERROR_FILE_NOT_FOUND:
			// Not all of these entries will have a CLSID section
			break;
		default:
			VERBOSITY(VERB_LEVEL_ERROR,
					  printf("*** Possible invalid CLSID in HKEY_CLASSES_ROOT\\%s\\CLSID\n",pszProgID);)
	}

	if(dwRetValue == ERROR_SUCCESS)
	{
		char achValue2[MAX_PATH];
		DWORD cbValue2 = MAX_PATH;
		//
		// We appear to have a valid CLSID. Check for existence of the CLSID. We are actually only
		// interested in it being found or not.
		//
		dwRetValue = ReadRegistryString(hkey_clsid,achValue,NULL,achValue2,&cbValue2);
		if(dwRetValue == ERROR_FILE_NOT_FOUND)
		{
			VERBOSITY(VERB_LEVEL_ERROR,printf("ProgID %s has CLSID %s. Unable to find HKEY_CLASSES_ROOT\\CLSID\\%s\n",pszProgID,achValue,achValue);)
		}
	}

	//
	// Check to see if there is an OLE 1.0 section that specifies protocol\stdfileediting\server
	//
	cbValue = MAX_PATH;
	dwRetValue = ReadRegistryFile(progidKey,"protocol\\stdfileediting\\server",NULL,achValue,&cbValue);
	if(dwRetValue == CLASSCHK_SOMETHINGODD)
	{
	    VERBOSITY(VERB_LEVEL_ERROR,printf("HKEY_CLASSES_ROOT\\%s\\Protocol\\StdFileEditing\\server may have invalid entry\n",pszProgID);)
	}
		
    }
    else
    {
    	VERBOSITY(VERB_LEVEL_WARN,printf("Unable to open HKEY_CLASSES_ROOT\\%s\n",pszProgID);)
    }

    if(progidKey != NULL)
    {
	RegCloseKey(progidKey);
    }
    	
    return 0;
}



//
// Given an extention (ie something that starts with a '.'), determine if the mapping to PROGID is correct
//
DWORD CheckExtentionToProgID(LPSTR pszExtention)
{

	LONG lRetValue = 0;
	char achValue[MAX_PATH];
	DWORD cbValue;
	DWORD dwRetValue;
	HKEY subKey = NULL;
	HKEY progidKey = NULL;


	lRetValue = RegOpenKeyEx(HKEY_CLASSES_ROOT,
							 pszExtention,
							 NULL,
							 KEY_READ,
							 &subKey);

	if(lRetValue == ERROR_SUCCESS)
	{
		cbValue = MAX_PATH;
	
		//
		// Read the default key value for the extention. Normally, this should point to a
		// PROGID.
		//
		dwRetValue = ReadRegistryString(subKey,NULL,NULL,achValue,&cbValue);
		VERBOSITY(VERB_LEVEL_TRACE,printf("HKEY_CLASSES_ROOT\\%s = %s\n",pszExtention,achValue);)

		if(dwRetValue == CLASSCHK_SOMETHINGODD)
		{
			VERBOSITY(VERB_LEVEL_WARN,printf("Reading HKEY_CLASSES_ROOT\\%s found something odd\n",pszExtention);)
		}
		
		//
		// If it is an extension, the value should be a PROGID.Take a look to see if it is.
		//
		lRetValue = RegOpenKeyEx(HKEY_CLASSES_ROOT,
								 achValue,
							 	 NULL,
							 	 KEY_READ,
							 	 &progidKey);
		//
		// It should have been there. If it wasn't, then report a strangeness
		//

		switch(lRetValue)
		{
			case ERROR_SUCCESS:
				//
				// The PROGID actually existed. We will verify its contents later.
				//
				break;
			case ERROR_FILE_NOT_FOUND:
				//
				// The PROGID doesn't exist. This could be a potential problem in the registry. Report it.
				//
				VERBOSITY(VERB_LEVEL_ERROR,
						  printf("HKEY_CLASSES_ROOT\\%s **** PROGID '%s' didn't exist ***\n*** Check Registry ***\n",
						  pszExtention,
						  achValue);)
				break;
			default:
				VERBOSITY(VERB_LEVEL_WARN,printf("Unexpected error opening HKEY_CLASSES_ROOT\\%s (error 0x%x)\n",achValue,lRetValue);)

		}


	}
	else
	{
		VERBOSITY(VERB_LEVEL_WARN,printf("Unable to open HKEY_CLASSES_ROOT\\%s\n",pszExtention);)
	}


	if(subKey != NULL) RegCloseKey(subKey);
	if(progidKey != NULL) RegCloseKey(progidKey);
		
	
	return 0;
}


//+---------------------------------------------------------------------------
//
//  Function:   CheckOLE1CLSID
//
//  Synopsis:   CheckOLE1CLSID looks at CLSID's that are typically OLE 1.0.
//		This includes checking for AutoConvert, checking the PROGID,
//		and checking that the Ole1Class key exists.
//
//  Arguments:  [pszCLSID] -- Name of OLE 1.0 CLASSID to check
//
//  History:    5-31-95   kevinro   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
DWORD CheckOLE1CLSID(LPSTR pszCLSID)
{
    LONG lRetValue = 0;
    char achValue[MAX_PATH];
    DWORD cbValue;
    DWORD dwRetValue;
    HKEY subKey = NULL;
    BOOL fFoundAServer = FALSE;
    char achValue2[MAX_PATH];
    DWORD cbValue2 = MAX_PATH;

    lRetValue = RegOpenKeyEx(hkey_clsid,pszCLSID,NULL,KEY_READ,&subKey);

    if(lRetValue != ERROR_SUCCESS)
    {
    	VERBOSITY(VERB_LEVEL_ERROR,printf("Unable to open HKEY_CLASSES_ROOT\\CLSID\\%s error 0x%x\n",pszCLSID,lRetValue);)
    	return CLASSCHK_SOMETHINGODD;
    }

    //
    // Check to insure that there is an Ole1Class entry
    //

    cbValue = MAX_PATH;
    dwRetValue = ReadRegistryString(subKey,"Ole1Class",NULL,achValue,&cbValue);
    switch(dwRetValue)
    {
    	case ERROR_FILE_NOT_FOUND:
    		VERBOSITY(VERB_LEVEL_WARN,printf("HKEY_CLASSES_ROOT\\CLSID\\%s is missing its Ole1Class key\n",pszCLSID);)
    		break;
    	case CLASSCHK_SOMETHINGODD:
    		VERBOSITY(VERB_LEVEL_WARN,printf("HKEY_CLASSES_ROOT\\CLSID\\%s\\Ole1Class key is odd\n",pszCLSID);)

    }

    //
    // Quite often, there will be a AutoConvertTo key, which is supposed to be a GUID
    //
    cbValue = MAX_PATH;
    dwRetValue = ReadRegistryGuid(subKey,"AutoConvertTo",NULL,achValue,&cbValue);
    switch(dwRetValue)
    {
    	case ERROR_SUCCESS:
    		//
    		// The CLSID should normally point to another class, such as the 2.0 version. Check to
    		// insure the CLSID exists
    		//
    		dwRetValue = ReadRegistryString(hkey_clsid,achValue,NULL,achValue2,&cbValue2);
    		if(dwRetValue != ERROR_SUCCESS)
    		{
		    VERBOSITY(VERB_LEVEL_WARN,printf("HKEY_CLASSES_ROOT\\CLSID\\%s\\AutoConvertTo key is odd\n",pszCLSID);)
		    switch(dwRetValue)
    		    {
			case ERROR_FILE_NOT_FOUND:

			    VERBOSITY(VERB_LEVEL_WARN,printf("HKEY_CLASSES_ROOT\\CLSID\\%s doesn't appear to exist\n",achValue);)
			    break;
		    }
    		}

    		break;
    	case ERROR_FILE_NOT_FOUND:
    		//
    		// This entry isn't required. If it doesn't exist, no big deal.
    		//
    		break;
    	case CLASSCHK_SOMETHINGODD:
    		VERBOSITY(VERB_LEVEL_WARN,printf("HKEY_CLASSES_ROOT\\CLSID\\%s\\AutoConvertTo key is odd\n",pszCLSID);)
		break;

    }

    //
    // It would be abnormal to find a missing PROGID key
    //
    cbValue = MAX_PATH;
    dwRetValue = ReadRegistryString(subKey,"ProgID",NULL,achValue,&cbValue);
    switch(dwRetValue)
    {
    	case ERROR_SUCCESS:
	    //
	    // The PROGID should normally point to a valid PROGID
	    //
	    cbValue2 = MAX_PATH;
	    dwRetValue = ReadRegistryString(HKEY_CLASSES_ROOT,achValue,NULL,achValue2,&cbValue2);
	    if(dwRetValue != ERROR_SUCCESS)
	    {
		VERBOSITY(VERB_LEVEL_ERROR,printf("HKEY_CLASSES_ROOT\\CLSID\\%s\\PROGID key is odd\n",pszCLSID);)
		switch(dwRetValue)
		{
		    case ERROR_FILE_NOT_FOUND:

			VERBOSITY(VERB_LEVEL_ERROR,printf("HKEY_CLASSES_ROOT\\%s doesn't appear to exist\n",achValue);)
			break;
		}
	    }

	break;
    	case ERROR_FILE_NOT_FOUND:
    		//
    		// This entry is required.
    		//
    		VERBOSITY(VERB_LEVEL_ERROR,printf("HKEY_CLASSES_ROOT\\CLSID\\%s\\PROGID key is missing\n",pszCLSID);)

    		break;
    	case CLASSCHK_SOMETHINGODD:
    		VERBOSITY(VERB_LEVEL_WARN,printf("HKEY_CLASSES_ROOT\\CLSID\\%s\\Ole1Class key is odd\n",pszCLSID);)

    }

    return dwRetValue;
}


//+---------------------------------------------------------------------------
//
//  Function:   CheckForDLL
//
//  Synopsis:   Given a CLSID, its hkey, and the name of the DLL value,
//		determine if the DLL exists as a file, and if the threading
//		model value is appropriate.
//
//  Arguments:  [pszCLSID] -- 	Name of the CLSID (for debug output)
//		[hkeyCLSID] --  HKEY for the clsid
//		[pszDLLKey] -- 	Name of the subkey to check for
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Algorithm:
//
//  History:    5-31-95   kevinro   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
DWORD CheckForDLL(LPSTR pszCLSID, HKEY hkeyCLSID, LPSTR pszDLLKey)
{
    LONG lRetValue = 0;
    char achValue[MAX_PATH];
    DWORD cbValue;
    DWORD dwRetValue;
    char achThreadModel[MAX_PATH];
    DWORD cbThreadModel = MAX_PATH;
    //
    // The DLL name should be in
    //
    cbValue = MAX_PATH;
    dwRetValue = ReadRegistryFile(hkeyCLSID,pszDLLKey,NULL,achValue,&cbValue);

    switch(dwRetValue)
    {
    	case ERROR_FILE_NOT_FOUND:
    	//
    	// The registry key didn't exist. Thats normally OK.
    	//
    		return dwRetValue;
    	case CLASSCHK_SOMETHINGODD:
    		VERBOSITY(VERB_LEVEL_WARN,printf("HKEY_CLASSES_ROOT\\CLSID\\%s\\%s key is odd\n",pszCLSID,pszDLLKey);)
    		return dwRetValue;
    }

    //
    // If the DLL exists, check to see if the ThreadingModelKey is valid
    //
    dwRetValue = ReadRegistryString(hkeyCLSID,pszDLLKey,"ThreadingModel",achThreadModel,&cbThreadModel);
    switch(dwRetValue)
    {
    	case ERROR_FILE_NOT_FOUND:
	    //
	    // The registry key didn't exist. Thats normally OK.
	    //
	    return ERROR_SUCCESS;
    	case CLASSCHK_SOMETHINGODD:
	    VERBOSITY(VERB_LEVEL_WARN,printf("HKEY_CLASSES_ROOT\\CLSID\\%s\\%s\\ThreadingModel value is odd\n",pszCLSID,pszDLLKey);)
	    return dwRetValue;
    }

    //
    // Check to insure the threading model is something we understand
    //
    if( StrICmp( achThreadModel, "Apartment") &&
    	StrICmp( achThreadModel, "Both") &&
    	StrICmp( achThreadModel, "Free"))
    {
    	VERBOSITY(VERB_LEVEL_WARN,printf("HKEY_CLASSES_ROOT\\CLSID\\%s\\%s\\ThreadingModel value is %s\n",pszCLSID,pszDLLKey,achThreadModel);)
    	VERBOSITY(VERB_LEVEL_WARN,printf("Expected 'Apartment','Both', or 'Free'");)
    	return CLASSCHK_SOMETHINGODD;
    }
    return ERROR_SUCCESS;
						 	
}

//+---------------------------------------------------------------------------
//
//  Function:   CheckCLSIDEntry
//
//  Synopsis:   Given the name of a CLSID entry, verify that the entry is
//		valid by looking for the 'usual' key information, and
//		cross checking it against things that we assert should be
//		true.
//  Effects:
//
//  Arguments:  [pszCLSID] -- CLSID in a string form. Used to open key
//
//  History:    5-31-95   kevinro   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
DWORD CheckCLSIDEntry(LPSTR pszCLSID)
{
    LONG lRetValue = 0;
    char achValue[MAX_PATH];
    DWORD cbValue;
    char achPROGID[MAX_PATH];
    DWORD cbPROGID = MAX_PATH;
    char achPROGIDPath[MAX_PATH];
    DWORD cbPROGIDPath = MAX_PATH;
    char achPROGIDValue[MAX_PATH];
    DWORD cbPROGIDValue = MAX_PATH;

    LPSTR pszLocalServer = "LocalServer32";
    DWORD dwRetValue;
    HKEY subKey = NULL;
    BOOL fFoundAServer = FALSE;

    lRetValue = RegOpenKeyEx(hkey_clsid,
			     pszCLSID,
			     NULL,
			     KEY_READ,
			     &subKey);

    if(lRetValue != ERROR_SUCCESS)
    {
	VERBOSITY(VERB_LEVEL_ERROR,printf("Unable to open HKEY_CLASSES_ROOT\\CLSID\\%s error 0x%x\n",pszCLSID,lRetValue);)
	return CLASSCHK_SOMETHINGODD;
    }

    //
    // Basic sanity check: Is the description string a valid string
    //
    cbValue = MAX_PATH;
    dwRetValue = ReadRegistryString(subKey,NULL,NULL,achValue,&cbValue);
    if(dwRetValue != ERROR_SUCCESS)
    {
	VERBOSITY(VERB_LEVEL_WHINE,printf("HKEY_CLASSES_ROOT\\CLSID\\%s has odd description string\n",pszCLSID);)
    }

    //
    // A CLSID entry typically has several values. Least of which is supposed to be one or more of the following:
    // InprocHandler
    // InprocServer
    // LocalServer
    // InprocHandler32
    // InprocServer32
    // LocalServer32
    //
    // It may also have an optional PROGID entry, which we can use to verify that that the LocalServer and
    // the protocol\StdFileEditing\server entries match.
    //
    // Another couple of things to watch for include checking the Inproc entries for ThreadingModel,
    //
    // Yet another thing to look at is the value of the CLSID itself. If the first 4 digits are 0003 or 0004, then
    // the CLSID is for an OLE 1.0 class, and we need to do a seperate check
    //
    if((strncmp(&pszCLSID[1],"0003",4) == 0) || (strncmp(&pszCLSID[1],"0004",4) == 0) )
    {
    	//
    	// In theory, this is supposed to be an OLE1CLASS. Check it seperately
    	//
    	RegCloseKey(subKey);
    	return CheckOLE1CLSID(pszCLSID);
    }

    dwRetValue = CheckForDLL(pszCLSID, subKey, "InprocHandler");
    dwRetValue = CheckForDLL(pszCLSID, subKey, "InprocHandler32");

    dwRetValue = CheckForDLL(pszCLSID, subKey, "InprocServer");
    if(dwRetValue != ERROR_FILE_NOT_FOUND) fFoundAServer++;

    dwRetValue = CheckForDLL(pszCLSID, subKey, "InprocServer32");
    if(dwRetValue != ERROR_FILE_NOT_FOUND) fFoundAServer++;

    //
    // First, check for LocalServer32. If that doesn't exist, then try for
    // LocalServer.
    //

    cbValue = MAX_PATH;
    dwRetValue = ReadRegistryFile(subKey,pszLocalServer,NULL,achValue,&cbValue);
    if(dwRetValue == ERROR_FILE_NOT_FOUND)
    {
    	cbValue = MAX_PATH;
    	pszLocalServer = "LocalServer";
    	dwRetValue = ReadRegistryFile(subKey,pszLocalServer,NULL,achValue,&cbValue);
    	if(dwRetValue == CLASSCHK_SOMETHINGODD)
    	{
    		VERBOSITY(VERB_LEVEL_WARN,printf("HKEY_CLASSES_ROOT\\CLSID\\%s\\LocalServer32 is odd\n",pszCLSID);)

    	}
    }
    else if(dwRetValue ==  CLASSCHK_SOMETHINGODD)
    {
    	VERBOSITY(VERB_LEVEL_WARN,printf("HKEY_CLASSES_ROOT\\CLSID\\%s\\%s is odd\n",pszCLSID,pszLocalServer);)

    }

    if(dwRetValue == ERROR_SUCCESS)
    {
    	fFoundAServer++;
    	//
    	// We have a valid LocalServer. Lets get the PROGID's version of the local server, and compare the
    	// two. They should compare.
    	//
    	dwRetValue = ReadRegistryString(subKey,"PROGID",NULL,achPROGID,&cbPROGID);
    	switch(dwRetValue)
    	{
	    case ERROR_FILE_NOT_FOUND:
		//
		// Most CLSID's should indeed have a PROGID, but it isn't 100% required.
		//
		VERBOSITY(VERB_LEVEL_WHINE,printf("HKEY_CLASSES_ROOT\\CLSID\\%s missing a PROGID entry\n",pszCLSID);)
		break;
	    case CLASSCHK_SOMETHINGODD:
		VERBOSITY(VERB_LEVEL_WARN,printf("HKEY_CLASSES_ROOT\\CLSID\\%s PROGID entry is odd\n",pszCLSID);)
		break;
	    default:
		sprintf(achPROGIDPath,"%s\\protocol\\stdfileediting\\server",achPROGID);
		dwRetValue = ReadRegistryFile(HKEY_CLASSES_ROOT,achPROGIDPath,NULL,achPROGIDValue,&cbPROGIDValue);
		//
		// The only thing we are interested in checking is if the two strings compare.
		//
		if(dwRetValue == ERROR_SUCCESS)
		{
		    if(StrICmp(achPROGIDValue,achValue) != 0)
		    {
			VERBOSITY(VERB_LEVEL_ERROR,printf("HKEY_CLASSES_ROOT\\CLSID\\%s is inconsistent with its PROGID\n",pszCLSID);)
			VERBOSITY(VERB_LEVEL_ERROR,printf("HKEY_CLASSES_ROOT\\%s = '%s'\n",achPROGIDPath,achPROGIDValue);)
			VERBOSITY(VERB_LEVEL_ERROR,printf("HKEY_CLASSES_ROOT\\CLSID\\%s\\%s = '%s'\n",pszCLSID,pszLocalServer,achValue);)

		    }
		}
    	}
    }

    if(!fFoundAServer)
    {
    	VERBOSITY(VERB_LEVEL_ERROR,printf("*** Unable to find a valid server for HKEY_CLASSES_ROOT\\CLSID\\%s ***\n",pszCLSID);)
    }

    RegCloseKey(subKey);

    return dwRetValue;
}


//+---------------------------------------------------------------------------
//
//  Function:   EnumerateClsidRoot
//
//  Synopsis:   Enumerate and check each entry in the CLSID section
//
//  History:    5-31-95   kevinro   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
DWORD EnumerateClsidRoot()
{
	LONG lRetValue = 0;
	DWORD iSubKey = 0;
	char achKeyName[MAX_PATH];
	DWORD cbKeyName;
	FILETIME filetime;

	while(1)
	{
		cbKeyName = MAX_PATH;

		lRetValue = RegEnumKeyEx(hkey_clsid,
					 iSubKey,
					 achKeyName,
		 			 &cbKeyName,
		 			 NULL,
		 			 NULL,
		 			 NULL,
					 &filetime);

		if(lRetValue == ERROR_NO_MORE_ITEMS)
		{
			// End of enumeration
			break;
		}

		if(lRetValue != ERROR_SUCCESS)
		{
			VERBOSITY(VERB_LEVEL_ERROR,printf("EnumerateClsidRoot:RegEnumKeyEx returned %x\n",lRetValue);)
			return CLASSCHK_ERROR;
		}

		//
		// Each of the sub keys enumerated here is expected to be a GUID. If it isn't a GUID, then it
		// might be some other random garbage that we don't care about.
		//

		if(CheckForValidGuid(achKeyName) == ERROR_SUCCESS)
		{
			CheckCLSIDEntry(achKeyName);
		}

		iSubKey++;
	}

	return 0;
}


//+---------------------------------------------------------------------------
//
//  Function:   EnumerateClassesRoot
//
//  Synopsis:   Enumerate the root of HKEY_CLASSES, and check each entry
//		based on what we think it should be.
//
//  History:    5-31-95   kevinro   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
DWORD EnumerateClassesRoot()
{
	LONG lRetValue = 0;
	DWORD iSubKey = 0;
	char achKeyName[MAX_PATH];
	DWORD cbKeyName;
	FILETIME filetime;

	while(1)
	{
		cbKeyName = MAX_PATH;
		lRetValue = RegEnumKeyEx(HKEY_CLASSES_ROOT,
					 iSubKey,
					 achKeyName,
					 &cbKeyName,
					 NULL,
					 NULL,
					 NULL,
					 &filetime);

		if(lRetValue == ERROR_NO_MORE_ITEMS)
		{
			// End of enumeration
			break;
		}

		if(lRetValue != ERROR_SUCCESS)
		{
			VERBOSITY(VERB_LEVEL_ERROR,printf("EnumerateClassesRoot:RegEnumKeyEx returned %x\n",lRetValue);)
			return CLASSCHK_ERROR;
		}

		//
		// We expect to find two basic things at the HKEY_CLASSES_ROOT level.
		// First are extention mappings, second are PROGID's. There is also
		// the special cases of CLSID, Interface, and FileType, which are
		// checked differently
		//

		if(StrICmp(achKeyName,"CLSID") == 0)
		{
			// The CLSID section is done later
		}
		else if(StrICmp(achKeyName,"Interface") == 0)
		{
			// The interface section is done later
		}
		else if(StrICmp(achKeyName,"FileType") == 0)
		{
			// The FileType entry is done later
		}
		else if(achKeyName[0] == '.')
		{
			// File extentions start with dots.
			// Call the Check Extention function here
			CheckExtentionToProgID(achKeyName);
		}
		else
		{
			// Assume it may be a PROGID. Call the PROGID function here.

			CheckProgID(achKeyName);
		}
		

		iSubKey++;
	}

	return 0;
}

//+---------------------------------------------------------------------------
//
//  Function:   main
//
//  Synopsis:   Main entry point for program. Does what main entry points
//		usually do.
//
//  Arguments:  [argc] --
//		[argv] --
//
//  History:    5-31-95   kevinro   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
int _cdecl main(int argc, char *argv[])
{
	LONG lRetValue = 0;

	//
	// HKEY_CLASSES_ROOT is often used.
	//
	lRetValue = RegOpenKeyEx(HKEY_CLASSES_ROOT,
				 "CLSID",
				 NULL,
				 KEY_READ,
				 &hkey_clsid);

	if(lRetValue != ERROR_SUCCESS)
	{
		printf("Couldn't open HKEY_CLASSES_ROOT\\CLSID\n");
		return(1);
	}

	//
	// Enumerate different parts of the registry, reporting
	// errors as we go.
	//
	EnumerateClassesRoot();
	EnumerateClsidRoot();

	RegCloseKey(hkey_clsid);	
	return 0;

}