You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
346 lines
10 KiB
346 lines
10 KiB
//*********************************************************************
|
|
//* Microsoft Windows **
|
|
//* Copyright(c) Microsoft Corp., 1999 **
|
|
//*********************************************************************
|
|
//
|
|
// REGISTRY.CPP - Implementation of functions to register components.
|
|
//
|
|
// HISTORY:
|
|
//
|
|
// 1/27/99 a-jaswed Created.
|
|
//
|
|
// registry functions.
|
|
|
|
#include <objbase.h>
|
|
#include <assert.h>
|
|
#include <appdefs.h>
|
|
#include "registry.h"
|
|
|
|
|
|
////////////////////////////////////////////////////////
|
|
// Internal helper functions prototypes
|
|
//
|
|
|
|
// Set the given key and its value.
|
|
BOOL setKeyAndValue(const WCHAR* pszPath,
|
|
const WCHAR* szSubkey,
|
|
const WCHAR* szValue,
|
|
const WCHAR* szName = NULL);
|
|
|
|
// Convert a CLSID into a char string.
|
|
void CLSIDtochar(const CLSID& clsid,
|
|
WCHAR* szCLSID,
|
|
int length);
|
|
|
|
// Determine if a particular subkey exists.
|
|
BOOL SubkeyExists(const WCHAR* pszPath,
|
|
const WCHAR* szSubkey);
|
|
|
|
// Delete szKeyChild and all of its descendents.
|
|
LONG recursiveDeleteKey(HKEY hKeyParent, const WCHAR* szKeyChild);
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// Public function implementation
|
|
/////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// Register the component in the registry.
|
|
//
|
|
HRESULT RegisterServer( HMODULE hModule, // DLL module handle
|
|
const CLSID& clsid, // Class ID
|
|
const WCHAR* szFriendlyName, // Friendly Name
|
|
const WCHAR* szVerIndProgID, // Programmatic
|
|
const WCHAR* szProgID) // IDs
|
|
{
|
|
// Get server location.
|
|
WCHAR szModule[512] ;
|
|
DWORD dwResult =
|
|
::GetModuleFileName(hModule,
|
|
szModule,
|
|
MAX_CHARS_IN_BUFFER(szModule)) ;
|
|
assert(dwResult != 0) ;
|
|
|
|
// Convert a CLSID into a char string.
|
|
WCHAR szCLSID[CLSID_STRING_SIZE] ;
|
|
CLSIDtochar(clsid, szCLSID, CLSID_STRING_SIZE) ;
|
|
|
|
// Build the key CLSID\\{...}
|
|
WCHAR szKey[64] ;
|
|
lstrcpy(szKey, L"CLSID\\");
|
|
lstrcat(szKey, szCLSID) ;
|
|
|
|
// Add the CLSID to the registry.
|
|
setKeyAndValue(szKey, NULL, szFriendlyName) ;
|
|
|
|
// Add server filename key
|
|
#ifdef _OUTPROC_SERVER_
|
|
setKeyAndValue(szKey, L"LocalServer32", szModule) ;
|
|
#else
|
|
setKeyAndValue(szKey, L"InprocServer32", szModule) ;
|
|
#endif
|
|
|
|
// Add the ProgID subkey under the CLSID key.
|
|
setKeyAndValue(szKey, L"ProgID", szProgID) ;
|
|
|
|
// Add the version-independent ProgID subkey under CLSID key.
|
|
setKeyAndValue( szKey, L"VersionIndependentProgID",
|
|
szVerIndProgID) ;
|
|
|
|
// Add the version-independent ProgID subkey under HKEY_CLASSES_ROOT.
|
|
setKeyAndValue(szVerIndProgID, NULL, szFriendlyName);
|
|
setKeyAndValue(szVerIndProgID, L"CLSID", szCLSID) ;
|
|
setKeyAndValue(szVerIndProgID, L"CurVer", szProgID) ;
|
|
|
|
// Add the versioned ProgID subkey under HKEY_CLASSES_ROOT.
|
|
setKeyAndValue(szProgID, NULL, szFriendlyName);
|
|
setKeyAndValue(szProgID, L"CLSID", szCLSID) ;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// Remove the component from the registry.
|
|
//
|
|
LONG UnregisterServer( const CLSID& clsid,
|
|
const WCHAR* szVerIndProgID,
|
|
const WCHAR* szProgID)
|
|
{
|
|
// Convert the CLSID into a char.
|
|
WCHAR szCLSID[CLSID_STRING_SIZE] ;
|
|
CLSIDtochar(clsid, szCLSID, CLSID_STRING_SIZE) ;
|
|
|
|
// Build the key CLSID\\{...}
|
|
WCHAR szKey[80] ;
|
|
lstrcpy(szKey, L"CLSID\\");
|
|
lstrcat(szKey, szCLSID) ;
|
|
|
|
// Check for a another server for this component.
|
|
#ifdef _OUTPROC_SERVER_
|
|
if (SubkeyExists(szKey, L"InprocServer32"))
|
|
#else
|
|
if (SubkeyExists(szKey, L"LocalServer32"))
|
|
#endif
|
|
{
|
|
// Delete only the path for this server.
|
|
#ifdef _OUTPROC_SERVER_
|
|
lstrcat(szKey, L"\\LocalServer32") ;
|
|
#else
|
|
lstrcat(szKey, L"\\InprocServer32") ;
|
|
#endif
|
|
LONG lResult = recursiveDeleteKey(HKEY_CLASSES_ROOT, szKey) ;
|
|
assert(lResult == ERROR_SUCCESS) ;
|
|
}
|
|
else
|
|
{
|
|
// Delete all related keys.
|
|
// Delete the CLSID Key - CLSID\{...}
|
|
LONG lResult = recursiveDeleteKey(HKEY_CLASSES_ROOT, szKey) ;
|
|
assert((lResult == ERROR_SUCCESS) ||
|
|
(lResult == ERROR_FILE_NOT_FOUND)) ; // Subkey may not exist.
|
|
|
|
// Delete the version-independent ProgID Key.
|
|
lResult = recursiveDeleteKey(HKEY_CLASSES_ROOT, szVerIndProgID) ;
|
|
assert((lResult == ERROR_SUCCESS) ||
|
|
(lResult == ERROR_FILE_NOT_FOUND)) ; // Subkey may not exist.
|
|
|
|
// Delete the ProgID key.
|
|
lResult = recursiveDeleteKey(HKEY_CLASSES_ROOT, szProgID) ;
|
|
assert((lResult == ERROR_SUCCESS) ||
|
|
(lResult == ERROR_FILE_NOT_FOUND)) ; // Subkey may not exist.
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Internal helper functions
|
|
///////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// Convert a CLSID to a char string.
|
|
//
|
|
void CLSIDtochar( const CLSID& clsid,
|
|
WCHAR* szCLSID,
|
|
int length)
|
|
{
|
|
assert(length >= CLSID_STRING_SIZE) ;
|
|
// Get CLSID
|
|
LPOLESTR sz = NULL ;
|
|
HRESULT hr = StringFromCLSID(clsid, &sz) ;
|
|
assert(SUCCEEDED(hr)) ;
|
|
assert(NULL != sz);
|
|
|
|
// Convert from wide characters to non-wide characters.
|
|
lstrcpyn(szCLSID, sz, length);
|
|
|
|
// Free memory.
|
|
CoTaskMemFree(sz) ;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// Delete a key and all of its descendents.
|
|
//
|
|
LONG recursiveDeleteKey(HKEY hKeyParent, // Parent of key to delete.
|
|
const WCHAR* lpszKeyChild) // Key to delete.
|
|
{
|
|
// Open the child.
|
|
HKEY hKeyChild;
|
|
LONG lRes = RegOpenKeyEx( hKeyParent, lpszKeyChild, 0,
|
|
KEY_ALL_ACCESS, &hKeyChild);
|
|
if (lRes != ERROR_SUCCESS)
|
|
{
|
|
return lRes;
|
|
}
|
|
|
|
// Enumerate all of the decendents of this child.
|
|
FILETIME time;
|
|
WCHAR szBuffer[256];
|
|
DWORD dwSize = 256;
|
|
while (RegEnumKeyEx(hKeyChild, 0, szBuffer, &dwSize, NULL,
|
|
NULL, NULL, &time) == S_OK)
|
|
{
|
|
// Delete the decendents of this child.
|
|
lRes = recursiveDeleteKey(hKeyChild, szBuffer);
|
|
if (lRes != ERROR_SUCCESS)
|
|
{
|
|
// Cleanup before exiting.
|
|
RegCloseKey(hKeyChild);
|
|
return lRes;
|
|
}
|
|
dwSize = 256;
|
|
}
|
|
|
|
// Close the child.
|
|
RegCloseKey(hKeyChild);
|
|
|
|
// Delete this child.
|
|
return RegDeleteKey(hKeyParent, lpszKeyChild);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// Determine if a particular subkey exists.
|
|
//
|
|
BOOL SubkeyExists(const WCHAR* pszPath, // Path of key to check
|
|
const WCHAR* szSubkey) // Key to check
|
|
{
|
|
HKEY hKey ;
|
|
WCHAR szKeyBuf[80] ;
|
|
|
|
// Copy keyname into buffer.
|
|
lstrcpy(szKeyBuf, pszPath) ;
|
|
|
|
// Add subkey name to buffer.
|
|
if (szSubkey != NULL)
|
|
{
|
|
lstrcat(szKeyBuf, L"\\") ;
|
|
lstrcat(szKeyBuf, szSubkey ) ;
|
|
}
|
|
|
|
// Determine if key exists by trying to open it.
|
|
LONG lResult = ::RegOpenKeyEx(HKEY_CLASSES_ROOT,
|
|
szKeyBuf,
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&hKey) ;
|
|
if (lResult == ERROR_SUCCESS)
|
|
{
|
|
RegCloseKey(hKey) ;
|
|
return TRUE ;
|
|
}
|
|
return FALSE ;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////
|
|
// Create a key and set its value.
|
|
//
|
|
// This helper function was borrowed and modifed from Kraig Brockschmidt's
|
|
// book Inside OLE.
|
|
//
|
|
BOOL setKeyAndValue(const WCHAR* szKey,
|
|
const WCHAR* szSubkey,
|
|
const WCHAR* szValue,
|
|
const WCHAR* szName)
|
|
{
|
|
HKEY hKey;
|
|
WCHAR szKeyBuf[1024] ;
|
|
|
|
// Copy keyname into buffer.
|
|
lstrcpy(szKeyBuf, szKey);
|
|
|
|
// Add subkey name to buffer.
|
|
if (szSubkey != NULL)
|
|
{
|
|
lstrcat(szKeyBuf, L"\\");
|
|
lstrcat(szKeyBuf, szSubkey );
|
|
}
|
|
|
|
// Create and open key and subkey.
|
|
long lResult = RegCreateKeyEx( HKEY_CLASSES_ROOT,
|
|
szKeyBuf,
|
|
0, NULL, REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS, NULL,
|
|
&hKey, NULL) ;
|
|
if (lResult != ERROR_SUCCESS)
|
|
{
|
|
return FALSE ;
|
|
}
|
|
|
|
// Set the Value.
|
|
if (szValue != NULL)
|
|
{
|
|
RegSetValueEx(hKey, szName, 0, REG_SZ,
|
|
(BYTE *)szValue,
|
|
BYTES_REQUIRED_BY_SZ(szValue)
|
|
);
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
return TRUE;
|
|
}
|
|
|
|
// value must be at least 1024 in size;
|
|
BOOL getKeyAndValue(const WCHAR* szKey,
|
|
const WCHAR* szSubkey,
|
|
const WCHAR* szValue,
|
|
const WCHAR* szName)
|
|
{
|
|
HKEY hKey;
|
|
WCHAR szKeyBuf[1024] ;
|
|
|
|
// Copy keyname into buffer.
|
|
lstrcpy(szKeyBuf, szKey);
|
|
|
|
// Add subkey name to buffer.
|
|
if (szSubkey != NULL)
|
|
{
|
|
lstrcat(szKeyBuf, L"\\");
|
|
lstrcat(szKeyBuf, szSubkey );
|
|
}
|
|
|
|
// open key and subkey.
|
|
long lResult = RegOpenKeyEx( HKEY_CLASSES_ROOT,
|
|
szKeyBuf,
|
|
0,
|
|
KEY_QUERY_VALUE,
|
|
&hKey) ;
|
|
if (lResult != ERROR_SUCCESS)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Get the Value.
|
|
if (szValue != NULL)
|
|
{
|
|
DWORD dwType, dwBufferSize = GETKEYANDVALUEBUFFSIZE;
|
|
lResult = RegQueryValueEx(hKey, szName, NULL, &dwType, (LPBYTE) szValue, &dwBufferSize);
|
|
if (lResult != ERROR_SUCCESS)
|
|
{
|
|
RegCloseKey(hKey);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
return TRUE;
|
|
}
|
|
|
|
|