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.
358 lines
8.7 KiB
358 lines
8.7 KiB
/*++
|
|
|
|
Copyright (c) 1991 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
Regnccls.c
|
|
|
|
Abstract:
|
|
|
|
This file contains functions needed for handling
|
|
change notifications in the classes portion of the registry
|
|
|
|
Author:
|
|
|
|
Adam P. Edwards (adamed) 14-Nov-1997
|
|
|
|
Key Functions:
|
|
|
|
BaseRegNotifyClassKey
|
|
|
|
Notes:
|
|
|
|
--*/
|
|
|
|
|
|
#ifdef LOCAL
|
|
|
|
#include <rpc.h>
|
|
#include <string.h>
|
|
#include <wchar.h>
|
|
#include "regrpc.h"
|
|
#include "localreg.h"
|
|
#include "regclass.h"
|
|
#include "regnccls.h"
|
|
#include <malloc.h>
|
|
|
|
NTSTATUS BaseRegNotifyClassKey(
|
|
IN HKEY hKey,
|
|
IN HANDLE hEvent,
|
|
IN PIO_STATUS_BLOCK pLocalIoStatusBlock,
|
|
IN DWORD dwNotifyFilter,
|
|
IN BOOLEAN fWatchSubtree,
|
|
IN BOOLEAN fAsynchronous)
|
|
{
|
|
NTSTATUS Status;
|
|
HKEY hkUser;
|
|
HKEY hkMachine;
|
|
SKeySemantics KeyInfo;
|
|
UNICODE_STRING EmptyString = {0, 0, 0};
|
|
BYTE rgNameBuf[REG_MAX_CLASSKEY_LEN + REG_CHAR_SIZE + sizeof(OBJECT_NAME_INFORMATION)];
|
|
OBJECT_ATTRIBUTES Obja;
|
|
BOOL fAllocatedPath;
|
|
|
|
//
|
|
// Set buffer to store info about this key
|
|
//
|
|
KeyInfo._pFullPath = (PKEY_NAME_INFORMATION) rgNameBuf;
|
|
KeyInfo._cbFullPath = sizeof(rgNameBuf);
|
|
KeyInfo._fAllocedNameBuf = FALSE;
|
|
|
|
//
|
|
// get information about this key
|
|
//
|
|
Status = BaseRegGetKeySemantics(hKey, &EmptyString, &KeyInfo);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Initialize conditionally freed resources
|
|
//
|
|
hkUser = NULL;
|
|
hkMachine = NULL;
|
|
|
|
fAllocatedPath = FALSE;
|
|
Obja.ObjectName = NULL;
|
|
|
|
//
|
|
// Now get handles for both user and machine versions of the key
|
|
//
|
|
Status = BaseRegGetUserAndMachineClass(
|
|
&KeyInfo,
|
|
hKey,
|
|
KEY_NOTIFY,
|
|
&hkUser,
|
|
&hkMachine);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
goto cleanup;
|
|
}
|
|
|
|
if (fWatchSubtree || (hkUser && hkMachine)) {
|
|
|
|
//
|
|
// This will return the closest ancestor to the
|
|
// nonexistent translated key -- note that it allocates memory
|
|
// to the Obja.ObjectName member, so we need to free that on
|
|
// success
|
|
//
|
|
Status = BaseRegGetBestAncestor(
|
|
&KeyInfo,
|
|
hkUser,
|
|
hkMachine,
|
|
&Obja);
|
|
|
|
fAllocatedPath = Obja.ObjectName != NULL;
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Ask for the notify on both user and machine keys (or
|
|
// the closest approximation). Note that we pass a full path --
|
|
// if we used an relative path with an object handle instead, we
|
|
// would never have an opportunity to close the object, so we would
|
|
// leak objects
|
|
//
|
|
//
|
|
Status = NtNotifyChangeMultipleKeys(
|
|
hKey,
|
|
1,
|
|
&Obja,
|
|
hEvent,
|
|
NULL,
|
|
NULL,
|
|
pLocalIoStatusBlock,
|
|
dwNotifyFilter,
|
|
fWatchSubtree,
|
|
NULL,
|
|
0,
|
|
fAsynchronous
|
|
);
|
|
|
|
} else {
|
|
|
|
Status = NtNotifyChangeKey(
|
|
hkUser ? hkUser : hkMachine,
|
|
hEvent,
|
|
NULL,
|
|
NULL,
|
|
pLocalIoStatusBlock,
|
|
dwNotifyFilter,
|
|
fWatchSubtree,
|
|
NULL,
|
|
0,
|
|
fAsynchronous
|
|
);
|
|
}
|
|
|
|
cleanup:
|
|
|
|
//if (!NT_SUCCESS(Status)) {
|
|
|
|
if (hkUser && (hkUser != hKey)) {
|
|
NtClose(hkUser);
|
|
}
|
|
|
|
if (hkMachine && (hkMachine != hKey)) {
|
|
NtClose(hkMachine);
|
|
}
|
|
//}
|
|
|
|
if (fAllocatedPath) {
|
|
RegClassHeapFree(Obja.ObjectName);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS BaseRegGetBestAncestor(
|
|
IN SKeySemantics* pKeySemantics,
|
|
IN HKEY hkUser,
|
|
IN HKEY hkMachine,
|
|
IN POBJECT_ATTRIBUTES pObja)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Finds a full object path for the closest ancestor for a key
|
|
described by a key semantics structure
|
|
|
|
|
|
Arguments:
|
|
|
|
pKeySemantics - contains information about a registry key
|
|
hkUser - handle to a user class version of the key above
|
|
hkMachine - handle to a machine class version of the key above
|
|
pObja - Object Attributes structure to initialize with a full
|
|
object path for the closest ancestor -- not that memory
|
|
is allocated for the ObjectName member of the structure
|
|
which must be freed by the caller -- caller should
|
|
check this member to see if it's non-NULL, regardless
|
|
of success code returned by function
|
|
|
|
Return Value:
|
|
|
|
Returns ERROR_SUCCESS (0) for success; error-code for failure.
|
|
|
|
--*/
|
|
{
|
|
USHORT PrefixLen;
|
|
NTSTATUS Status;
|
|
PUNICODE_STRING pKeyPath;
|
|
USHORT uMaxLen;
|
|
|
|
//
|
|
// Allocate memory for the Obja's ObjectName member
|
|
//
|
|
uMaxLen = (USHORT) pKeySemantics->_pFullPath->NameLength + REG_CLASSES_SUBTREE_PADDING;
|
|
|
|
pKeyPath = RegClassHeapAlloc(uMaxLen + sizeof(*pKeyPath));
|
|
|
|
if (!(pKeyPath)) {
|
|
return STATUS_NO_MEMORY;
|
|
}
|
|
|
|
//
|
|
// Now initialize the structure
|
|
//
|
|
pKeyPath->MaximumLength = uMaxLen;
|
|
pKeyPath->Buffer = (WCHAR*) (((PBYTE) pKeyPath) + sizeof(*pKeyPath));
|
|
|
|
//
|
|
// Now form a version of this key path in the opposite tree
|
|
//
|
|
if (pKeySemantics->_fUser) {
|
|
|
|
Status = BaseRegTranslateToMachineClassKey(
|
|
pKeySemantics,
|
|
pKeyPath,
|
|
&PrefixLen);
|
|
|
|
} else {
|
|
|
|
Status = BaseRegTranslateToUserClassKey(
|
|
pKeySemantics,
|
|
pKeyPath,
|
|
&PrefixLen);
|
|
}
|
|
|
|
//
|
|
// Make sure the caller has a reference to allocated memory
|
|
//
|
|
pObja->ObjectName = pKeyPath;
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Set up the object attributes with this translated key so
|
|
// we can use the structure to notify keys
|
|
//
|
|
InitializeObjectAttributes(
|
|
pObja,
|
|
pKeyPath,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL, // using absolute path, no hkey
|
|
NULL);
|
|
|
|
//
|
|
// If we were supplied both keys, then they both exist,
|
|
// so we can simply use the translated path above
|
|
//
|
|
if (hkUser && hkMachine) {
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// At this point, we know the translated path doesn't exist,
|
|
// since we only have a handle for one of the paths. Therefore
|
|
// we will attempt to find an approximation. Note that the
|
|
// manipulation of KeyPath below affects the Obja passed in since
|
|
// the Obja struct references KeyPath
|
|
//
|
|
do
|
|
{
|
|
WCHAR* pBufferEnd;
|
|
HKEY hkExistingKey;
|
|
|
|
//
|
|
// Find the last pathsep in the current key path
|
|
//
|
|
pBufferEnd = wcsrchr(pKeyPath->Buffer, L'\\');
|
|
|
|
//
|
|
// We should never get NULL here, because all keys
|
|
// have the ancestory \Registry\User or \Registry\Machine,
|
|
// each which have two pathseps to spare -- the loop
|
|
// terminates once that path is shorter than those prefixes,
|
|
// so we should never encounter this situation
|
|
//
|
|
ASSERT(pBufferEnd);
|
|
|
|
//
|
|
// Now truncate the string
|
|
//
|
|
*pBufferEnd = L'\0';
|
|
|
|
//
|
|
// Adjust the unicode string structure to conform
|
|
// to the truncated string
|
|
//
|
|
RtlInitUnicodeString(pKeyPath, pKeyPath->Buffer);
|
|
|
|
//
|
|
// Now attempt to open with this truncated path
|
|
//
|
|
Status = NtOpenKey(
|
|
&hkExistingKey,
|
|
KEY_NOTIFY,
|
|
pObja);
|
|
|
|
//
|
|
// If we do open it, we will close it and not pass this object
|
|
// since we want our obja to use a full path and not a relative
|
|
// path off a kernel object
|
|
//
|
|
if (NT_SUCCESS(Status)) {
|
|
NtClose(hkExistingKey);
|
|
break;
|
|
}
|
|
|
|
//
|
|
// If we get any error besides a key not found error, then our reason
|
|
// for failing the open is not because the key did not exist, but because
|
|
// of some other error, most likely access denied.
|
|
//
|
|
if (STATUS_OBJECT_NAME_NOT_FOUND != Status) {
|
|
break;
|
|
}
|
|
|
|
} while (pKeyPath->Length > PrefixLen);
|
|
|
|
cleanup:
|
|
|
|
return Status;
|
|
|
|
}
|
|
|
|
|
|
#endif // defined ( LOCAL )
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|