803 lines
22 KiB
C++
803 lines
22 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1996.
|
|
//
|
|
// registry.cxx
|
|
//
|
|
// Registry related routines
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "act.hxx"
|
|
|
|
#ifdef SERVER_HANDLER
|
|
BOOL gbDisableEmbeddingServerHandler = FALSE;
|
|
#endif // SERVER_HANDLER
|
|
|
|
BOOL gbSAFERROTChecksEnabled = TRUE;
|
|
BOOL gbSAFERAAAChecksEnabled = TRUE;
|
|
|
|
BOOL gbDynamicIPChangesEnabled = TRUE; // On in whistler; was off by default in W2K
|
|
DWORD gdwTimeoutPeriodForStaleMids = 10 * 60 * 1000; // ten minutes
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// ReadStringValue
|
|
//
|
|
// Returns the named value string under the specified open registry key.
|
|
//
|
|
// Returns :
|
|
//
|
|
// ERROR_SUCCESS, ERROR_FILE_NOT_FOUND, ERROR_BAD_FORMAT, ERROR_OUTOFMEMORY,
|
|
// ERROR_BAD_PATHNAME, or other more esoteric win32 error code.
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
DWORD
|
|
ReadStringValue(
|
|
IN HKEY hKey,
|
|
IN WCHAR * pwszValueName,
|
|
OUT WCHAR ** ppwszString )
|
|
{
|
|
DWORD Status;
|
|
DWORD Type;
|
|
DWORD StringSize;
|
|
WCHAR * pwszScan;
|
|
WCHAR * pwszSource;
|
|
WCHAR wszString[64];
|
|
|
|
*ppwszString = 0;
|
|
|
|
StringSize = sizeof(wszString);
|
|
|
|
Status = RegQueryValueEx(
|
|
hKey,
|
|
pwszValueName,
|
|
NULL,
|
|
&Type,
|
|
(BYTE *) wszString,
|
|
&StringSize );
|
|
|
|
if ( (ERROR_SUCCESS == Status) &&
|
|
(Type != REG_SZ) && (Type != REG_MULTI_SZ) && (Type != REG_EXPAND_SZ) )
|
|
Status = ERROR_BAD_FORMAT;
|
|
|
|
if ( (Status != ERROR_SUCCESS) && (Status != ERROR_MORE_DATA) )
|
|
return Status;
|
|
|
|
// Allocate one extra WCHAR for an extra null at the end.
|
|
*ppwszString = (WCHAR *) PrivMemAlloc( StringSize + sizeof(WCHAR) );
|
|
|
|
if ( ! *ppwszString )
|
|
return ERROR_OUTOFMEMORY;
|
|
|
|
if ( ERROR_MORE_DATA == Status )
|
|
{
|
|
Status = RegQueryValueEx(
|
|
hKey,
|
|
pwszValueName,
|
|
NULL,
|
|
&Type,
|
|
(BYTE *) *ppwszString,
|
|
&StringSize );
|
|
|
|
if ( Status != ERROR_SUCCESS )
|
|
{
|
|
PrivMemFree( *ppwszString );
|
|
*ppwszString = 0;
|
|
return Status;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
memcpy( *ppwszString, wszString, StringSize );
|
|
}
|
|
|
|
//
|
|
// Put an extra null at the end. This allows using identical logic for both
|
|
// REG_SZ and REG_MULTI_SZ values like RemoteServerNames instead of special
|
|
// casing it.
|
|
//
|
|
(*ppwszString)[StringSize/sizeof(WCHAR)] = 0;
|
|
|
|
//
|
|
// Don't bother with any of the following conversions for multi strings.
|
|
// They better be in the correct format.
|
|
//
|
|
if ( REG_MULTI_SZ == Type )
|
|
return Status;
|
|
|
|
pwszScan = pwszSource = *ppwszString;
|
|
|
|
//
|
|
// The original OLE sources had logic for stripping out a quoted
|
|
// value. I have no idea on the origin of this or if it is still
|
|
// important. It shouldn't hurt anything to keep it in to save
|
|
// us from some nasty compatability problem.
|
|
// - DKays, 8/96
|
|
//
|
|
|
|
if ( L'\"' == *pwszScan )
|
|
{
|
|
pwszScan++;
|
|
|
|
// Copy everything between the quotes.
|
|
while ( *pwszScan && (*pwszScan != L'\"') )
|
|
*pwszSource++ = *pwszScan++;
|
|
|
|
*pwszSource = 0;
|
|
}
|
|
|
|
//
|
|
// Leading and trailing whitespace would hose us for some values, like
|
|
// RemoteServerName or RunAs. These are stripped here. Once again, only
|
|
// good things can happen if we put this logic in.
|
|
//
|
|
|
|
pwszScan = *ppwszString;
|
|
|
|
while ( *pwszScan && ((L' ' == *pwszScan) || (L'\t' == *pwszScan)) )
|
|
pwszScan++;
|
|
|
|
if ( ! *pwszScan )
|
|
{
|
|
PrivMemFree( *ppwszString );
|
|
*ppwszString = 0;
|
|
return ERROR_BAD_PATHNAME;
|
|
}
|
|
|
|
if ( *ppwszString < pwszScan )
|
|
lstrcpyW( *ppwszString, pwszScan );
|
|
|
|
pwszScan = *ppwszString + lstrlenW(*ppwszString);
|
|
|
|
while ( (pwszScan != *ppwszString) &&
|
|
((L' ' == pwszScan[-1]) || (L'\t' == pwszScan[-1])) )
|
|
pwszScan--;
|
|
|
|
*pwszScan = 0;
|
|
|
|
//
|
|
// Finally, handle environment string expansion if necessary.
|
|
// Remember to add the extra trailing null again.
|
|
//
|
|
if ( REG_EXPAND_SZ == Type )
|
|
{
|
|
WCHAR * pwszExpandedString;
|
|
DWORD ExpandedStringSize;
|
|
|
|
pwszExpandedString = 0;
|
|
StringSize /= sizeof(WCHAR);
|
|
|
|
for (;;)
|
|
{
|
|
PrivMemFree( pwszExpandedString );
|
|
pwszExpandedString = (WCHAR *) PrivMemAlloc( (StringSize + 1) * sizeof(WCHAR) );
|
|
|
|
if ( ! pwszExpandedString )
|
|
{
|
|
Status = ERROR_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
|
|
ExpandedStringSize = ExpandEnvironmentStrings(
|
|
*ppwszString,
|
|
pwszExpandedString,
|
|
StringSize );
|
|
|
|
if ( ! ExpandedStringSize )
|
|
{
|
|
Status = GetLastError();
|
|
break;
|
|
}
|
|
|
|
if ( ExpandedStringSize > StringSize )
|
|
{
|
|
StringSize = ExpandedStringSize;
|
|
continue;
|
|
}
|
|
|
|
Status = ERROR_SUCCESS;
|
|
break;
|
|
}
|
|
|
|
PrivMemFree( *ppwszString );
|
|
|
|
if ( ERROR_SUCCESS == Status )
|
|
{
|
|
pwszExpandedString[lstrlenW(pwszExpandedString)+1] = 0;
|
|
*ppwszString = pwszExpandedString;
|
|
}
|
|
else
|
|
{
|
|
PrivMemFree( pwszExpandedString );
|
|
*ppwszString = 0;
|
|
}
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// ReadStringKeyValue
|
|
//
|
|
// Reads the unnamed named value string for the specified subkey name
|
|
// under the given open registry key.
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
DWORD
|
|
ReadStringKeyValue(
|
|
IN HKEY hKey,
|
|
IN WCHAR * pwszKeyName,
|
|
OUT WCHAR ** ppwszString )
|
|
{
|
|
DWORD Status;
|
|
HKEY hSubKey;
|
|
|
|
Status = RegOpenKeyEx(
|
|
hKey,
|
|
pwszKeyName,
|
|
NULL,
|
|
KEY_READ,
|
|
&hSubKey );
|
|
|
|
if ( Status != ERROR_SUCCESS )
|
|
return Status;
|
|
|
|
Status = ReadStringValue( hSubKey, L"", ppwszString );
|
|
|
|
RegCloseKey( hSubKey );
|
|
|
|
return Status;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// ReadSecurityDescriptor
|
|
//
|
|
// Converts a security descriptor from self relative to absolute form.
|
|
// Stuffs in an owner and a group.
|
|
//
|
|
// Notes :
|
|
//
|
|
// REGDB_E_INVALIDVALUE is returned when there is something
|
|
// at the specified value, but it is not a security descriptor.
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
DWORD
|
|
ReadSecurityDescriptor(
|
|
IN HKEY hKey,
|
|
IN WCHAR * pwszValue,
|
|
OUT CSecDescriptor ** ppCSecDescriptor )
|
|
|
|
{
|
|
PSID pGroupSid;
|
|
PSID pOwnerSid;
|
|
DWORD Size;
|
|
DWORD Type;
|
|
DWORD Status;
|
|
DWORD Size2;
|
|
SECURITY_DESCRIPTOR* pSD = NULL;
|
|
CSecDescriptor* pCSecDescriptor = NULL;
|
|
|
|
// Find put how much memory to allocate for the security descriptor.
|
|
|
|
Size = 0;
|
|
*ppCSecDescriptor = NULL;
|
|
|
|
Status = RegQueryValueEx( hKey, pwszValue, 0, &Type, 0, &Size );
|
|
|
|
Size2 = Size;
|
|
|
|
if ( Status != ERROR_SUCCESS )
|
|
return Status;
|
|
|
|
if ( Type != REG_BINARY || (Size < sizeof(SECURITY_DESCRIPTOR)) )
|
|
return ERROR_BAD_FORMAT;
|
|
|
|
//
|
|
// Allocate memory for the security descriptor plus the owner and
|
|
// group SIDs.
|
|
//
|
|
|
|
#ifdef _WIN64
|
|
{
|
|
DWORD deltaSize = sizeof( SECURITY_DESCRIPTOR ) - sizeof( SECURITY_DESCRIPTOR_RELATIVE );
|
|
ASSERT( deltaSize < sizeof( SECURITY_DESCRIPTOR ) );
|
|
deltaSize = (DWORD) OLE2INT_ROUND_UP( deltaSize, sizeof(PVOID) );
|
|
|
|
Size2 += deltaSize;
|
|
}
|
|
#endif // _WIN64
|
|
|
|
// Allocate sd buffer and wrapper class
|
|
pSD = (SECURITY_DESCRIPTOR *) PrivMemAlloc( Size2 );
|
|
if (!pSD)
|
|
return ERROR_OUTOFMEMORY;
|
|
|
|
// Read the security descriptor.
|
|
Status = RegQueryValueEx( hKey, pwszValue, 0, &Type, (PBYTE) pSD, &Size );
|
|
|
|
if ( Status != ERROR_SUCCESS )
|
|
goto ReadSecurityDescriptorEnd;
|
|
|
|
if ( Type != REG_BINARY )
|
|
{
|
|
Status = ERROR_BAD_FORMAT;
|
|
goto ReadSecurityDescriptorEnd;
|
|
}
|
|
|
|
//
|
|
// Fix up the security descriptor.
|
|
//
|
|
|
|
#ifdef _WIN64
|
|
if ( MakeAbsoluteSD2( pSD, &Size2 ) == FALSE ) {
|
|
Status = ERROR_BAD_FORMAT;
|
|
goto ReadSecurityDescriptorEnd;
|
|
}
|
|
#else // !_WIN64
|
|
|
|
pSD->Control &= ~SE_SELF_RELATIVE;
|
|
pSD->Sacl = NULL;
|
|
|
|
if ( pSD->Dacl != NULL )
|
|
{
|
|
if ( (Size < sizeof(ACL) + sizeof(SECURITY_DESCRIPTOR)) ||
|
|
((ULONG) pSD->Dacl > Size - sizeof(ACL)) )
|
|
{
|
|
Status = ERROR_BAD_FORMAT;
|
|
goto ReadSecurityDescriptorEnd;
|
|
}
|
|
|
|
pSD->Dacl = (ACL *) (((char *) pSD) + ((ULONG) pSD->Dacl));
|
|
|
|
if ( pSD->Dacl->AclSize + sizeof(SECURITY_DESCRIPTOR) > Size )
|
|
{
|
|
Status = ERROR_BAD_FORMAT;
|
|
goto ReadSecurityDescriptorEnd;
|
|
}
|
|
}
|
|
|
|
// Set up the owner and group SIDs.
|
|
if ( pSD->Group == 0 ||
|
|
((ULONG)pSD->Group) + sizeof(SID) > Size ||
|
|
pSD->Owner == 0 ||
|
|
((ULONG)pSD->Owner) + sizeof(SID) > Size )
|
|
{
|
|
Status = ERROR_BAD_FORMAT;
|
|
goto ReadSecurityDescriptorEnd;
|
|
}
|
|
|
|
pSD->Group = (SID *) (((BYTE *) pSD) + (ULONG) (pSD)->Group);
|
|
pSD->Owner = (SID *) (((BYTE *) pSD) + (ULONG) (pSD)->Owner);
|
|
|
|
#endif // !_WIN64
|
|
|
|
ReadSecurityDescriptorEnd:
|
|
|
|
if ( Status != ERROR_SUCCESS )
|
|
{
|
|
if ( pSD )
|
|
PrivMemFree( pSD );
|
|
|
|
return Status;
|
|
}
|
|
|
|
// Allocate wrapper class for refcount semantics
|
|
pCSecDescriptor = new CSecDescriptor(pSD);
|
|
if (!pCSecDescriptor)
|
|
{
|
|
PrivMemFree(pSD);
|
|
return ERROR_OUTOFMEMORY;
|
|
}
|
|
|
|
ASSERT( IsValidSecurityDescriptor( pCSecDescriptor->GetSD()) );
|
|
|
|
// New class has refcount of 1, owned by the caller
|
|
*ppCSecDescriptor = pCSecDescriptor;
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// InitSCMRegistry
|
|
//
|
|
// Opens global registry keys and settings.
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
HRESULT
|
|
InitSCMRegistry()
|
|
{
|
|
HRESULT hr;
|
|
LONG err;
|
|
DWORD dwDisp;
|
|
|
|
ReadRemoteActivationKeys();
|
|
|
|
ReadRemoteBindingHandleCacheKeys();
|
|
|
|
ReadSAFERKeys();
|
|
|
|
ReadDynamicIPChangesKeys();
|
|
|
|
// Now read the actual values from the registry
|
|
// Check if Embedding Server Handler is enabled
|
|
#ifdef SERVER_HANDLER
|
|
HKEY hkeyOle;
|
|
err = RegOpenKeyExA( HKEY_LOCAL_MACHINE,
|
|
"SOFTWARE\\Microsoft\\OLE\\DisableEmbeddingServerHandler",
|
|
NULL,
|
|
KEY_QUERY_VALUE,
|
|
&hkeyOle );
|
|
|
|
if (err == ERROR_SUCCESS)
|
|
{
|
|
gbDisableEmbeddingServerHandler=TRUE;
|
|
RegCloseKey(hkeyOle);
|
|
}
|
|
#endif // SERVER_HANDLER
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// ReadRemoteActivationKeys
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
void ReadRemoteActivationKeys()
|
|
{
|
|
DWORD err;
|
|
HKEY hOle;
|
|
|
|
// Read the DefaultLaunchPermission value (if present) from the registry
|
|
if ((err = RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\OLE", NULL, KEY_READ,
|
|
&hOle)) == ERROR_SUCCESS)
|
|
{
|
|
DWORD dwStatus;
|
|
CSecDescriptor* pSecDescriptor = NULL;
|
|
|
|
dwStatus = ReadSecurityDescriptor( hOle,
|
|
L"DefaultLaunchPermission",
|
|
&pSecDescriptor);
|
|
if (dwStatus == ERROR_SUCCESS)
|
|
{
|
|
ASSERT(pSecDescriptor);
|
|
SetDefaultLaunchPermissions(pSecDescriptor);
|
|
pSecDescriptor->DecRefCount();
|
|
}
|
|
else
|
|
{
|
|
// In case of a non-existent or malformed descriptor, reset
|
|
// current perms to NULL - this blocks everybody.
|
|
ASSERT(!pSecDescriptor);
|
|
SetDefaultLaunchPermissions(NULL);
|
|
}
|
|
|
|
RegCloseKey(hOle);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// GetActivationFailureLoggingLevel
|
|
//
|
|
// Returns current activation failure logging level as specified
|
|
// by a certain key in the Registry.
|
|
//
|
|
// History:
|
|
//
|
|
// a-sergiv 6-17-99 Created
|
|
//
|
|
// Returns :
|
|
//
|
|
// 0 = Discretionary logging. Log by default, client can override
|
|
// 1 = Always log. Log all errors no matter what client specified
|
|
// 2 = Never log. Never log error no matter what client speciied
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
|
|
DWORD
|
|
GetActivationFailureLoggingLevel()
|
|
{
|
|
DWORD err;
|
|
DWORD dwSize;
|
|
DWORD dwType;
|
|
HKEY hOle;
|
|
DWORD dwLevel = 0;
|
|
|
|
if ((err = RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\OLE", NULL, KEY_READ,
|
|
&hOle)) == ERROR_SUCCESS)
|
|
{
|
|
dwSize = sizeof(DWORD);
|
|
|
|
if ((err = RegQueryValueEx(hOle, L"ActivationFailureLoggingLevel",
|
|
NULL, &dwType, (BYTE *) &dwLevel, &dwSize))
|
|
== ERROR_SUCCESS)
|
|
{
|
|
// Valid values are 0, 1 and 2. The variable is unsigned.
|
|
// Assume 0 if invalid value is specified.
|
|
|
|
if(dwLevel > 2)
|
|
dwLevel = 0;
|
|
}
|
|
else
|
|
{
|
|
// Assume 0 if not specified
|
|
|
|
dwLevel = 0;
|
|
}
|
|
|
|
RegCloseKey(hOle);
|
|
}
|
|
|
|
return dwLevel;
|
|
}
|
|
|
|
//
|
|
// ReadRegistryIntegerValue
|
|
//
|
|
// Tries to read a numeric value from the specified value under the key.
|
|
// Returns FALSE if it doesn't exist or is of the wrong type, TRUE
|
|
// otherwise.
|
|
//
|
|
BOOL ReadRegistryIntegerValue(HKEY hkey, WCHAR* pwszValue, DWORD* pdwValue)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
DWORD error;
|
|
DWORD dwSize = sizeof(DWORD);
|
|
DWORD dwType;
|
|
DWORD dwValue;
|
|
|
|
error = RegQueryValueExW(hkey,
|
|
pwszValue,
|
|
NULL,
|
|
&dwType,
|
|
(BYTE*)&dwValue,
|
|
&dwSize);
|
|
if (error == ERROR_SUCCESS &&
|
|
dwType == REG_DWORD)
|
|
{
|
|
*pdwValue = dwValue;
|
|
bResult = TRUE;
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// ReadRemoteBindingHandleCacheKeys
|
|
//
|
|
// Reads optional values from the registry to control the behavior of the
|
|
// remote binding handle cache (gpRemoteMachineList).
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
void
|
|
ReadRemoteBindingHandleCacheKeys()
|
|
{
|
|
HKEY hOle;
|
|
DWORD error;
|
|
|
|
error = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
L"SOFTWARE\\Microsoft\\OLE",
|
|
NULL,
|
|
KEY_READ,
|
|
&hOle);
|
|
if (error == ERROR_SUCCESS)
|
|
{
|
|
DWORD dwValue;
|
|
|
|
if (ReadRegistryIntegerValue(hOle, L"RemoteHandleCacheMaxSize", &dwValue))
|
|
{
|
|
gdwRemoteBindingHandleCacheMaxSize = dwValue;
|
|
}
|
|
|
|
if (ReadRegistryIntegerValue(hOle, L"RemoteHandleCacheMaxLifetime", &dwValue))
|
|
{
|
|
gdwRemoteBindingHandleCacheMaxLifetime = dwValue;
|
|
}
|
|
|
|
if (ReadRegistryIntegerValue(hOle, L"RemoteHandleCacheMaxIdleTimeout", &dwValue))
|
|
{
|
|
gdwRemoteBindingHandleCacheIdleTimeout = dwValue;
|
|
}
|
|
|
|
// This one not really a "binding handle cache" knob.
|
|
// CODEWORK: all of this registry knob reading code needs to be
|
|
// cleaned-up and rewritten.
|
|
if (ReadRegistryIntegerValue(hOle, L"StaleMidTimeout", &dwValue))
|
|
{
|
|
gdwTimeoutPeriodForStaleMids = dwValue;
|
|
}
|
|
|
|
RegCloseKey(hOle);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// ReadSAFERKeys
|
|
//
|
|
// Reads optional values from the registry to control aspects of our
|
|
// SAFER windows support
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
void
|
|
ReadSAFERKeys()
|
|
{
|
|
HKEY hOle;
|
|
DWORD error;
|
|
DWORD dwType;
|
|
DWORD dwSize;
|
|
WCHAR wszYN[5];
|
|
|
|
error = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
L"SOFTWARE\\Microsoft\\OLE",
|
|
NULL,
|
|
KEY_READ,
|
|
&hOle);
|
|
if (error == ERROR_SUCCESS)
|
|
{
|
|
dwSize = sizeof(wszYN) / sizeof(WCHAR);
|
|
|
|
error = RegQueryValueEx(hOle,
|
|
L"SRPRunningObjectChecks",
|
|
NULL,
|
|
&dwType,
|
|
(BYTE*)wszYN,
|
|
&dwSize);
|
|
if (error == ERROR_SUCCESS && (wszYN[0] == L'n' || wszYN[0] == L'N'))
|
|
{
|
|
gbSAFERROTChecksEnabled = FALSE;
|
|
}
|
|
|
|
dwSize = sizeof(wszYN) / sizeof(WCHAR);
|
|
|
|
error = RegQueryValueEx(hOle,
|
|
L"SRPActivateAsActivatorChecks",
|
|
NULL,
|
|
&dwType,
|
|
(BYTE*)wszYN,
|
|
&dwSize);
|
|
if (error == ERROR_SUCCESS && (wszYN[0] == L'n' || wszYN[0] == L'N'))
|
|
{
|
|
gbSAFERAAAChecksEnabled = FALSE;
|
|
}
|
|
|
|
CloseHandle(hOle);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// ReadDynamicIPChangesKeys
|
|
//
|
|
// Reads optional values from the registry to control aspects of our
|
|
// dynamic IP change support.
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
void
|
|
ReadDynamicIPChangesKeys()
|
|
{
|
|
HKEY hOle;
|
|
DWORD error;
|
|
DWORD dwType;
|
|
DWORD dwSize;
|
|
WCHAR wszYN[5];
|
|
|
|
error = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
L"SOFTWARE\\Microsoft\\OLE",
|
|
NULL,
|
|
KEY_READ,
|
|
&hOle);
|
|
if (error == ERROR_SUCCESS)
|
|
{
|
|
dwSize = sizeof(wszYN) / sizeof(WCHAR);
|
|
|
|
error = RegQueryValueEx(hOle,
|
|
L"EnableSystemDynamicIPTracking",
|
|
NULL,
|
|
&dwType,
|
|
(BYTE*)wszYN,
|
|
&dwSize);
|
|
// note: in w2k, this code turned the flag on only if the registry
|
|
// value was "y" or "Y". In whistler I have reversed these semantics.
|
|
if (error == ERROR_SUCCESS && (wszYN[0] == L'n' || wszYN[0] == L'N'))
|
|
{
|
|
gbDynamicIPChangesEnabled = FALSE;
|
|
}
|
|
|
|
CloseHandle(hOle);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// CRegistryWatcher::CRegistryWatcher
|
|
//
|
|
// Constructor for CRegistryWatcher.
|
|
//
|
|
// If allocation of the event fails, or opening the key fails, or registering
|
|
// for the notify fails, then Changed() always returns S_OK (yes, it changed).
|
|
// This doesn't affect correctness, only speed.
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
CRegistryWatcher::CRegistryWatcher(HKEY hKeyRoot, const WCHAR *wszSubKey)
|
|
{
|
|
_fValid = FALSE;
|
|
|
|
_hEvent = CreateEvent(NULL, FALSE, TRUE, NULL);
|
|
if (!_hEvent)
|
|
return;
|
|
|
|
LONG res = RegOpenKeyEx(hKeyRoot, wszSubKey, 0, KEY_NOTIFY, &_hWatchedKey);
|
|
if (res != ERROR_SUCCESS)
|
|
{
|
|
Cleanup();
|
|
return;
|
|
}
|
|
|
|
_fValid = TRUE;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// CRegistryWatcher::CRegistryWatcher
|
|
//
|
|
// Determine if the registry key being watched has changed. Returns
|
|
// S_OK if it has changed, S_FALSE if not, and an error if something
|
|
// failed.
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
HRESULT CRegistryWatcher::Changed()
|
|
{
|
|
if (!_fValid)
|
|
return S_OK;
|
|
|
|
// _hEvent is auto-reset, so only one thread will re-register.
|
|
if (WAIT_OBJECT_0 == WaitForSingleObject(_hEvent, 0))
|
|
{
|
|
LONG res = RegNotifyChangeKeyValue(_hWatchedKey,
|
|
TRUE,
|
|
REG_NOTIFY_CHANGE_NAME | REG_NOTIFY_CHANGE_LAST_SET,
|
|
_hEvent,
|
|
TRUE);
|
|
if (res != ERROR_SUCCESS)
|
|
{
|
|
// Could not re-register, so we can't watch the key anymore.
|
|
_fValid = FALSE;
|
|
return HRESULT_FROM_WIN32(res);
|
|
}
|
|
else
|
|
return S_OK;
|
|
}
|
|
else
|
|
return S_FALSE;
|
|
}
|
|
|
|
void CRegistryWatcher::Cleanup()
|
|
{
|
|
if (_hEvent)
|
|
{
|
|
CloseHandle(_hEvent);
|
|
_hEvent = NULL;
|
|
}
|
|
|
|
if (_hWatchedKey)
|
|
{
|
|
RegCloseKey(_hWatchedKey);
|
|
_hWatchedKey = NULL;
|
|
}
|
|
}
|