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.
627 lines
15 KiB
627 lines
15 KiB
/*++
|
|
|
|
Copyright (c) 1996 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
dmnotify.c
|
|
|
|
Abstract:
|
|
|
|
Contains notification support for the Configuration Database Manager
|
|
|
|
Each call to DmNotifyChangeKey adds a leaf to the notification tree. This
|
|
tree is expected to be sparse, so each node is implemented as a linked list of
|
|
subnodes and a linked list of leaves.
|
|
|
|
When a registry modification occurs, the tree is traversed from the root
|
|
to the leaf representing the key. Any leaves along the path are candidates
|
|
for reporting a notification event.
|
|
|
|
Author:
|
|
|
|
John Vert (jvert) 9/18/1996
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
#include "dmp.h"
|
|
|
|
typedef struct _DM_NOTIFY_BRANCH {
|
|
LIST_ENTRY SiblingList; // Links onto parent's ChildList.
|
|
LIST_ENTRY ChildList; // Links onto child's SiblingList.
|
|
LIST_ENTRY LeafList; // Links
|
|
struct _DM_NOTIFY_BRANCH *Parent; // Parent
|
|
USHORT NameLength;
|
|
WCHAR KeyName[0]; // Name component (a single keyname, not a path)
|
|
} DM_NOTIFY_BRANCH, *PDM_NOTIFY_BRANCH;
|
|
|
|
typedef struct _DM_NOTIFY_LEAF {
|
|
LIST_ENTRY SiblingList; // Links onto parent branch's ChildList
|
|
LIST_ENTRY KeyList; // Links onto DMKEY.NotifyList
|
|
LIST_ENTRY RundownList; // Passed into DmNotifyChangeKey, used for rundown
|
|
HDMKEY hKey;
|
|
DWORD CompletionFilter;
|
|
DM_NOTIFY_CALLBACK NotifyCallback;
|
|
DWORD_PTR Context1;
|
|
DWORD_PTR Context2;
|
|
PDM_NOTIFY_BRANCH Parent;
|
|
BOOL WatchTree;
|
|
} DM_NOTIFY_LEAF, *PDM_NOTIFY_LEAF;
|
|
|
|
CRITICAL_SECTION NotifyLock;
|
|
PDM_NOTIFY_BRANCH NotifyRoot=NULL;
|
|
|
|
//
|
|
// Local function prototypes
|
|
//
|
|
VOID
|
|
DmpPruneBranch(
|
|
IN PDM_NOTIFY_BRANCH Branch
|
|
);
|
|
|
|
PDM_NOTIFY_BRANCH
|
|
DmpFindKeyInBranch(
|
|
IN PDM_NOTIFY_BRANCH RootBranch,
|
|
IN OUT LPCWSTR *RelativeName,
|
|
OUT WORD *pNameLength
|
|
);
|
|
|
|
DWORD
|
|
DmpAddNotifyLeaf(
|
|
IN PDM_NOTIFY_BRANCH RootBranch,
|
|
IN PDM_NOTIFY_LEAF NewLeaf,
|
|
IN LPCWSTR RelativeName
|
|
);
|
|
|
|
VOID
|
|
DmpReportNotifyWorker(
|
|
IN PDM_NOTIFY_BRANCH RootBranch,
|
|
IN LPCWSTR RelativeName,
|
|
IN LPCWSTR FullName,
|
|
IN DWORD Filter
|
|
);
|
|
|
|
|
|
BOOL
|
|
DmpInitNotify(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Initializes the notification package for the DM.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
TRUE if successful
|
|
|
|
FALSE otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
InitializeCriticalSection(&NotifyLock);
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
DWORD
|
|
DmNotifyChangeKey(
|
|
IN HDMKEY hKey,
|
|
IN DWORD CompletionFilter,
|
|
IN BOOL WatchTree,
|
|
IN OPTIONAL PLIST_ENTRY ListHead,
|
|
IN DM_NOTIFY_CALLBACK NotifyCallback,
|
|
IN DWORD_PTR Context1,
|
|
IN DWORD_PTR Context2
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Registers a notification for a specific registry key. When the
|
|
notification event occurs, ApiReportRegistryNotify will be called.
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies the registry key handle on which the notification
|
|
should be posted.
|
|
|
|
CompletionFilter - Supplies the registry events which should trigger
|
|
the notification.
|
|
|
|
WatchTree - Supplies whether or not changes to the children of the specified
|
|
key should trigger the notification.
|
|
|
|
ListHead - If present, supplies the listhead that the new notification should be
|
|
queued to. This listhead should be passed to DmRundownList.
|
|
|
|
NotifyCallback - Supplies the notification routine that should be called
|
|
when the notification occurs.
|
|
|
|
Context1 - Supplies the first DWORD of context to be passed to ApiReportRegistryNotify
|
|
|
|
Context2 - Supplies the second DWORD of context to be passed to ApiReportRegistryNotify
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS if successful.
|
|
|
|
Win32 error otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
PDMKEY Key;
|
|
PDM_NOTIFY_LEAF Leaf;
|
|
DWORD Status;
|
|
|
|
Key = (PDMKEY)hKey;
|
|
|
|
Leaf = LocalAlloc(LMEM_FIXED, sizeof(DM_NOTIFY_LEAF));
|
|
if (Leaf == NULL) {
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
Leaf->hKey = hKey;
|
|
Leaf->CompletionFilter = CompletionFilter;
|
|
Leaf->WatchTree = WatchTree;
|
|
Leaf->NotifyCallback = NotifyCallback;
|
|
Leaf->Context1 = Context1;
|
|
Leaf->Context2 = Context2;
|
|
|
|
EnterCriticalSection(&NotifyLock);
|
|
|
|
if (NotifyRoot == NULL) {
|
|
//
|
|
// Create notify root here.
|
|
//
|
|
NotifyRoot = LocalAlloc(LMEM_FIXED, sizeof(DM_NOTIFY_BRANCH));
|
|
if (NotifyRoot == NULL) {
|
|
LeaveCriticalSection(&NotifyLock);
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
InitializeListHead(&NotifyRoot->SiblingList);
|
|
InitializeListHead(&NotifyRoot->ChildList);
|
|
InitializeListHead(&NotifyRoot->LeafList);
|
|
NotifyRoot->Parent = NULL;
|
|
}
|
|
|
|
Status = DmpAddNotifyLeaf(NotifyRoot, Leaf, Key->Name);
|
|
if (Status == ERROR_SUCCESS) {
|
|
InsertHeadList(&Key->NotifyList, &Leaf->KeyList);
|
|
if (ARGUMENT_PRESENT(ListHead)) {
|
|
InsertHeadList(ListHead, &Leaf->RundownList);
|
|
} else {
|
|
Leaf->RundownList.Flink = NULL;
|
|
Leaf->RundownList.Blink = NULL;
|
|
}
|
|
} else {
|
|
LocalFree(Leaf);
|
|
}
|
|
|
|
LeaveCriticalSection(&NotifyLock);
|
|
|
|
return(Status);
|
|
}
|
|
|
|
|
|
VOID
|
|
DmRundownList(
|
|
IN PLIST_ENTRY ListHead
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Runs down a list of leaves. Used by the API when the notify port
|
|
is closed.
|
|
|
|
Arguments:
|
|
|
|
ListHead - Supplies the head of the rundown list. This is the
|
|
same listhead passed to DmNotifyChangeKey
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PLIST_ENTRY ListEntry;
|
|
PDM_NOTIFY_LEAF Leaf;
|
|
|
|
//
|
|
// Remove all outstanding DM_NOTIFY_LEAF structures from this list.
|
|
//
|
|
EnterCriticalSection(&NotifyLock);
|
|
while (!IsListEmpty(ListHead)) {
|
|
ListEntry = RemoveHeadList(ListHead);
|
|
Leaf = CONTAINING_RECORD(ListEntry,
|
|
DM_NOTIFY_LEAF,
|
|
RundownList);
|
|
RemoveEntryList(&Leaf->SiblingList);
|
|
RemoveEntryList(&Leaf->KeyList);
|
|
|
|
//
|
|
// Attempt to prune this branch.
|
|
//
|
|
DmpPruneBranch(Leaf->Parent);
|
|
|
|
LocalFree(Leaf);
|
|
}
|
|
|
|
LeaveCriticalSection(&NotifyLock);
|
|
}
|
|
|
|
|
|
VOID
|
|
DmpRundownNotify(
|
|
IN PDMKEY Key
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Cleans up any outstanding notifications for a key when the
|
|
key is being closed.
|
|
|
|
Arguments:
|
|
|
|
Key - Supplies the key
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PLIST_ENTRY ListEntry;
|
|
PDM_NOTIFY_LEAF Leaf;
|
|
|
|
//
|
|
// Remove all outstanding DM_NOTIFY_LEAF structures from this key.
|
|
//
|
|
EnterCriticalSection(&NotifyLock);
|
|
while (!IsListEmpty(&Key->NotifyList)) {
|
|
ListEntry = RemoveHeadList(&Key->NotifyList);
|
|
Leaf = CONTAINING_RECORD(ListEntry,
|
|
DM_NOTIFY_LEAF,
|
|
KeyList);
|
|
RemoveEntryList(&Leaf->SiblingList);
|
|
if (Leaf->RundownList.Flink != NULL) {
|
|
RemoveEntryList(&Leaf->RundownList);
|
|
}
|
|
|
|
//
|
|
// Attempt to prune this branch.
|
|
//
|
|
DmpPruneBranch(Leaf->Parent);
|
|
|
|
LocalFree(Leaf);
|
|
}
|
|
|
|
LeaveCriticalSection(&NotifyLock);
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
DmpPruneBranch(
|
|
IN PDM_NOTIFY_BRANCH Branch
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Checks to see if a branch is empty and should be pruned (freed).
|
|
If the branch is empty, this routine will recursively call itself
|
|
on the parent until a non-empty branch is found.
|
|
|
|
Arguments:
|
|
|
|
Branch - Supplies the branch to be pruned.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
if ((IsListEmpty(&Branch->ChildList)) &&
|
|
(IsListEmpty(&Branch->LeafList))) {
|
|
|
|
//
|
|
// No need to keep this branch around any more. Remove
|
|
// it from its parent, then check to see if the parent
|
|
// should be pruned.
|
|
//
|
|
if (Branch->Parent == NULL) {
|
|
//
|
|
// This is the root, go ahead and free it up too.
|
|
//
|
|
CL_ASSERT(NotifyRoot == Branch);
|
|
NotifyRoot = NULL;
|
|
|
|
} else {
|
|
RemoveEntryList(&Branch->SiblingList);
|
|
DmpPruneBranch(Branch->Parent);
|
|
}
|
|
LocalFree(Branch);
|
|
}
|
|
}
|
|
|
|
|
|
DWORD
|
|
DmpAddNotifyLeaf(
|
|
IN PDM_NOTIFY_BRANCH RootBranch,
|
|
IN PDM_NOTIFY_LEAF NewLeaf,
|
|
IN LPCWSTR RelativeName
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Adds a leaf to the notification key.
|
|
|
|
If the RelativeName is empty, a leaf is created in RootBranch.
|
|
|
|
If the RelativeName is not empty, look up its first component
|
|
in RootBranch. If it's not there, create it. Then call ourselves
|
|
recursively after stripping off the first component of RelativeName
|
|
|
|
Arguments:
|
|
|
|
RootBranch - Supplies the root where the leaf is to be added
|
|
|
|
NewLeaf - Supplies the new leaf structure
|
|
|
|
RelativeName - Supplies the relative name.
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS if successful.
|
|
|
|
Win32 error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
PLIST_ENTRY ListEntry;
|
|
PDM_NOTIFY_BRANCH Branch;
|
|
USHORT NameLength;
|
|
LPCWSTR NextName;
|
|
|
|
if (RelativeName[0] == '\0') {
|
|
InsertHeadList(&RootBranch->LeafList, &NewLeaf->SiblingList);
|
|
NewLeaf->Parent = RootBranch;
|
|
return(ERROR_SUCCESS);
|
|
}
|
|
|
|
NextName = RelativeName;
|
|
Branch = DmpFindKeyInBranch(RootBranch, &NextName, &NameLength);
|
|
if (Branch == NULL) {
|
|
//
|
|
// No branch existed with this name. Create a new branch.
|
|
//
|
|
Branch = LocalAlloc(LMEM_FIXED, sizeof(DM_NOTIFY_BRANCH) + NameLength*sizeof(WCHAR));
|
|
if (Branch == NULL) {
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
InitializeListHead(&Branch->ChildList);
|
|
InitializeListHead(&Branch->LeafList);
|
|
Branch->Parent = RootBranch;
|
|
Branch->NameLength = NameLength;
|
|
CopyMemory(Branch->KeyName, RelativeName, NameLength*sizeof(WCHAR));
|
|
InsertHeadList(&RootBranch->ChildList, &Branch->SiblingList);
|
|
}
|
|
|
|
//
|
|
// Call ourselves recursively on the new branch.
|
|
//
|
|
return(DmpAddNotifyLeaf(Branch, NewLeaf, NextName));
|
|
}
|
|
|
|
|
|
VOID
|
|
DmpReportNotify(
|
|
IN LPCWSTR KeyName,
|
|
IN DWORD Filter
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Interface to the rest of DM to report a notification event on
|
|
a particular key.
|
|
|
|
Arguments:
|
|
|
|
Key - Supplies the key that was modified.
|
|
|
|
Filter - Supplies the modification type.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
if (NotifyRoot == NULL) {
|
|
return;
|
|
}
|
|
|
|
EnterCriticalSection(&NotifyLock);
|
|
|
|
if (NotifyRoot != NULL) {
|
|
DmpReportNotifyWorker(NotifyRoot,
|
|
KeyName,
|
|
KeyName,
|
|
Filter);
|
|
}
|
|
|
|
LeaveCriticalSection(&NotifyLock);
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
DmpReportNotifyWorker(
|
|
IN PDM_NOTIFY_BRANCH RootBranch,
|
|
IN LPCWSTR RelativeName,
|
|
IN LPCWSTR FullName,
|
|
IN DWORD Filter
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Recursive worker routine that drills down through the notification
|
|
tree until it reaches the supplied name. Notifications are issued
|
|
for any leaves along the path that match the event.
|
|
|
|
Arguments:
|
|
|
|
RootBranch - Supplies the branch of the tree to start with.
|
|
|
|
RelativeName - Supplies the name of the changed key, relative to Branch.
|
|
|
|
FullName - Supplies the full name of the changed key.
|
|
|
|
Filter - Supplies the type of event.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PLIST_ENTRY ListEntry;
|
|
PDM_NOTIFY_LEAF Leaf;
|
|
PDM_NOTIFY_BRANCH Branch;
|
|
LPCWSTR NextName;
|
|
WORD Dummy;
|
|
|
|
//
|
|
// First, issue notifies for any leaves at this node
|
|
//
|
|
ListEntry = RootBranch->LeafList.Flink;
|
|
while (ListEntry != &RootBranch->LeafList) {
|
|
Leaf = CONTAINING_RECORD(ListEntry,
|
|
DM_NOTIFY_LEAF,
|
|
SiblingList);
|
|
if (Leaf->CompletionFilter & Filter) {
|
|
if ( Leaf->WatchTree ||
|
|
(RelativeName[0] == '\0')) {
|
|
|
|
(Leaf->NotifyCallback)(Leaf->Context1,
|
|
Leaf->Context2,
|
|
Filter,
|
|
RelativeName);
|
|
|
|
}
|
|
}
|
|
ListEntry = ListEntry->Flink;
|
|
}
|
|
|
|
//
|
|
// Now search the child list for a subkey that matches the next component
|
|
// of the key name. If there isn't one, we are done. If there is one,
|
|
// call ourselves recursively on it.
|
|
//
|
|
if (RelativeName[0] == '\0') {
|
|
return;
|
|
}
|
|
NextName = RelativeName;
|
|
Branch = DmpFindKeyInBranch(RootBranch, &NextName, &Dummy);
|
|
if (Branch != NULL) {
|
|
DmpReportNotifyWorker(Branch, NextName, FullName, Filter);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
PDM_NOTIFY_BRANCH
|
|
DmpFindKeyInBranch(
|
|
IN PDM_NOTIFY_BRANCH RootBranch,
|
|
IN OUT LPCWSTR *RelativeName,
|
|
OUT WORD *pNameLength
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Finds the next component of a key name in a branch.
|
|
|
|
Arguments:
|
|
|
|
RootBranch - Supplies the branch to search.
|
|
|
|
RelativeName - Supplies the relative name of the key.
|
|
Returns the remaining name
|
|
|
|
NameLength - Returns the length of the next component.
|
|
|
|
Return Value:
|
|
|
|
Pointer to the found branch if successful.
|
|
|
|
NULL otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
PDM_NOTIFY_BRANCH Branch;
|
|
USHORT NameLength;
|
|
LPCWSTR NextName;
|
|
PLIST_ENTRY ListEntry;
|
|
|
|
//
|
|
// Find the first component of the relative name.
|
|
//
|
|
NextName = wcschr(*RelativeName, '\\');
|
|
if (NextName==NULL) {
|
|
NameLength = (USHORT)lstrlenW(*RelativeName);
|
|
NextName = *RelativeName + NameLength;
|
|
} else {
|
|
NameLength = (USHORT)(NextName - *RelativeName);
|
|
++NextName;
|
|
}
|
|
*pNameLength = NameLength;
|
|
|
|
//
|
|
// Search through the root's children to try and find a match on the
|
|
// first component.
|
|
//
|
|
ListEntry = RootBranch->ChildList.Flink;
|
|
while (ListEntry != &RootBranch->ChildList) {
|
|
Branch = CONTAINING_RECORD(ListEntry,
|
|
DM_NOTIFY_BRANCH,
|
|
SiblingList);
|
|
if ((NameLength == Branch->NameLength) &&
|
|
(wcsncmp(*RelativeName, Branch->KeyName, NameLength)==0)) {
|
|
|
|
//
|
|
// We have matched an existing branch. Return success.
|
|
//
|
|
*RelativeName = NextName;
|
|
return(Branch);
|
|
}
|
|
ListEntry = ListEntry->Flink;
|
|
}
|
|
*RelativeName = NextName;
|
|
|
|
return(NULL);
|
|
|
|
}
|