windows-xp/Source/XPSP1/NT/base/screg/winreg/server/regnckey.c

/*++

Copyright (c) 1992  Microsoft Corporation

Module Name:

    Regnckey.c

Abstract:

    This module contains the Win32 Registry APIs to notify a caller about
    a changed Key value. That is:

        - RegNotifyChangeKey

Author:

    David J. Gilman (davegi) 10-Feb-1992


Notes:


    The RegNotifyChangeKey server creates an event and calls
    NtNotifyChangeKey asynchronously with that event.  It then
    places the event (plus some other client information, such
    as a named pipe and a client event) in a "Notification List"
    and returns to the client.

    A Notification List is a list of events controled by a
    handler thread. The handler thread waits on the events in
    the list. When an event is signaled the handler thread
    identifies the client to which the event belongs, and
    gives the client (via named pipe) the corresponding client
    event.

    Since there is a limit on the number of events on which a
    thread can wait, there may be several Notification Lists.

    Since all the calls to RegNotifyChangeKey in a client
    process use the same named pipe, we maintain only one copy
    of each pipe. Pipe information is maintained in a symbol table
    for fast lookup.



Revision History:

    02-Apr-1992     Ramon J. San Andres (ramonsa)
                    Changed to use RPC.


--*/

#include <rpc.h>
#include "regrpc.h"
#include "localreg.h"
#include <string.h>


#ifndef REMOTE_NOTIFICATION_DISABLED
//
//  Strings used for generating named pipe names
//
#define NAMED_PIPE_HERE     L"\\Device\\NamedPipe\\"
#define NAMED_PIPE_THERE    L"\\DosDevices\\UNC\\"


//
//  Pipe names are maintained in a symbol table. The symbol table has
//  one entry for each different pipe given by a client.  The entry
//  is maintained for as long as there is at least one entry in a
//  Notification List referencing it.
//
typedef struct _PIPE_ENTRY *PPIPE_ENTRY;

typedef struct _PIPE_ENTRY {

    PPIPE_ENTRY             Previous;
    PPIPE_ENTRY             Next;
    UNICODE_STRING          PipeName;
    DWORD                   ReferenceCount;
    PSECURITY_DESCRIPTOR    SecurityDescriptor;

} PIPE_ENTRY;




//
//  The PIPE_SYMBOL_TABLE structure contains the symbol table for
//  all the pipes being used by the clients of
//  RegNotifyChangeKey
//
#define BUCKETS_IN_SYMBOL_TABLE     211

typedef struct _PIPE_SYMBOL_TABLE   *PPIPE_SYMBOL_TABLE;

typedef struct _PIPE_SYMBOL_TABLE {

    PPIPE_ENTRY             Bucket[ BUCKETS_IN_SYMBOL_TABLE ];

} PIPE_SYMBOL_TABLE;




//
//  Information about a pending event is maintained in a
//  NOTIFICATION_ENTRY structure.
//
typedef struct _NOTIFICATION_ENTRY *PNOTIFICATION_ENTRY;

typedef struct _NOTIFICATION_ENTRY {

    DWORD                   ClientEvent;    //  Event in client side
    HANDLE                  hKey;           //  Key handle
    DWORD                   Flags;          //  Misc. flags
    PPIPE_ENTRY             PipeEntry;      //  Pipe Entry

} NOTIFICATION_ENTRY;


//
//  Flag values
//
#define CLIENT_IS_DEAD       0x00000001
#define MUST_NOTIFY          0x00000002
#define NOTIFICATION_FAILED  0x00000004



//
//  The pending events are maintained in notification lists. Each
//  notification list contains:
//
//  Previous        -   Previous in chain
//  Next            -   Next in chain
//  EventsInUse     -   Number of entries being used in this list
//  EventHandle     -   Array of event handles
//  ClientEvent     -   Array of events in client
//  PipeEntry       -   Array of pointers to pipe entries in symbol table
//
//
//  The first event in the EventHandle list is the event used to wake
//  up the thread whenever we add new entries to the list.
//
//  The array entries 0..EventsInUse-1 contain the pending events.
//  New events are always added at position EventsInUse. When removing
//  an event, all the arrays are shifted.
//
//  Whenever EventsInUse == 1, the list is empty of client events and
//  it can be removed (together with its thread).
//
//
//  Notification Lists are kept in a doubly-linked list. A new
//  Notification List is created and added to the chain whenever an
//  event is added and all the existing lists are full.  Notification
//  lists are deleted when the last event in the list is signaled.
//
//
typedef struct _NOTIFICATION_LIST *PNOTIFICATION_LIST;

typedef struct _NOTIFICATION_LIST {

    PNOTIFICATION_LIST      Previous;
    PNOTIFICATION_LIST      Next;
    DWORD                   EventsInUse;
    HANDLE                  HandlerThread;
    CLIENT_ID               HandlerClientId;
    DWORD                   PendingNotifications;
    HANDLE                  EventHandle[ MAXIMUM_WAIT_OBJECTS ];
    NOTIFICATION_ENTRY      Event[ MAXIMUM_WAIT_OBJECTS ];
    DWORD                   TimeOutCount;
    BOOLEAN                 ResetCount;

} NOTIFICATION_LIST;

#define MAX_TIMEOUT_COUNT   128


#if DBG
    #define BIGDBG 0
#else
    #define BIGDBG 0
#endif

#define HASH(a,b)   Hash(a,b)



// *****************************************************************
//
//                    Static Variables
//
// *****************************************************************



//
//  Head of chain of Notification lists
//
PNOTIFICATION_LIST      NotificationListChainHead;

//
//  The critical sesction protects all the global structures.
//
RTL_CRITICAL_SECTION    NotificationCriticalSection;

//
//  Symbol table for named pipes in use.
//
PIPE_SYMBOL_TABLE       PipeSymbolTable;

//
//  Our machine name is used for determining if requests are local
//  or remote.
//
WCHAR                   OurMachineNameBuffer[ MAX_PATH ];
UNICODE_STRING          OurMachineName;

//
//  The I/O Status Block is updated by the NtNotifyChangeKey API
//  upon notification.  We cannot put this structure on the stack
//  because at notification time this stack might belong to someone
//  else. We can use a single variable because we don't care about
//  its contents so it's ok if several people mess with it at the
//  same time.
//
IO_STATUS_BLOCK         IoStatusBlock;





// *****************************************************************
//
//                    Local Prototypes
//
// *****************************************************************



LONG
CreateNotificationList (
    OUT PNOTIFICATION_LIST  *NotificationListUsed
    );

LONG
DeleteNotificationList (
    IN OUT  PNOTIFICATION_LIST  NotificationList
    );

LONG
AddEvent (
    IN  HKEY                     hKey,
    IN  HANDLE                   EventHandle,
    IN  DWORD                    ClientEvent,
    IN  PUNICODE_STRING          PipeName,
    IN  PRPC_SECURITY_ATTRIBUTES pRpcSa OPTIONAL,
    OUT PNOTIFICATION_LIST      *NotificationListUsed
    );

LONG
RemoveEvent (
    IN      HANDLE              EventHandle,
    IN OUT  PNOTIFICATION_LIST  NotificationList
    );

LONG
GetAvailableNotificationList (
    OUT PNOTIFICATION_LIST  *NotificationListUsed
    );

LONG
AddEntryToNotificationList(
    IN OUT  PNOTIFICATION_LIST       NotificationList,
    IN      HKEY                     hKey,
    IN      HANDLE                   EventHandle,
    IN      DWORD                    ClientEvent,
    IN      PUNICODE_STRING          PipeName,
    IN      PRPC_SECURITY_ATTRIBUTES pRpcSa     OPTIONAL
    );

LONG
RemoveEntryFromNotificationList (
    IN OUT  PNOTIFICATION_LIST  NotificationList,
    IN      DWORD               EntryIndex
    );

LONG
CompactNotificationList (
    IN OUT  PNOTIFICATION_LIST  NotificationList
    );

VOID
AddNotificationListToChain(
    IN OUT  PNOTIFICATION_LIST  NotificationList
    );

VOID
RemoveNotificationListFromChain(
    IN OUT  PNOTIFICATION_LIST  NotificationList
    );

LONG
GetFullPipeName(
    IN      PUNICODE_STRING         MachineName,
    IN      PUNICODE_STRING         PipeName,
    IN OUT  PUNICODE_STRING         FullPipeName
    );

LONG
CreatePipeEntry (
    IN  PUNICODE_STRING          PipeName,
    IN  PRPC_SECURITY_ATTRIBUTES pRpcSa     OPTIONAL,
    OUT PPIPE_ENTRY              *PipeEntryUsed
    );

LONG
DeletePipeEntry(
    IN OUT PPIPE_ENTRY  PipeEntry
    );

LONG
AddPipe(
    IN  PUNICODE_STRING          PipeName,
    IN  PRPC_SECURITY_ATTRIBUTES pRpcSa     OPTIONAL,
    OUT PPIPE_ENTRY              *PipeEntryUsed
    );

LONG
RemovePipe(
    IN OUT PPIPE_ENTRY  PipeEntry
    );

LONG
AddPipeEntryToSymbolTable(
    IN OUT  PPIPE_ENTRY PipeEntry
    );

LONG
RemovePipeEntryFromSymbolTable(
    IN OUT  PPIPE_ENTRY PipeEntry
    );

LONG
LookForPipeEntryInSymbolTable(
    IN  PUNICODE_STRING PipeName,
    OUT PPIPE_ENTRY     *PipeEntryUsed
    );

DWORD
Hash(
    IN  PUNICODE_STRING  Symbol,
    IN  DWORD            Buckets
    );

VOID
NotificationHandler(
    IN  PNOTIFICATION_LIST  NotificationList
    );

DWORD
NotificationListMaintenance(
    IN OUT  PNOTIFICATION_LIST  NotificationList
    );

LONG
SendEventToClient(
    IN  DWORD           ClientEvent,
    IN  PPIPE_ENTRY     PipeEntry
    );

#if BIGDBG
VOID
DumpNotificationLists(
    );

VOID
DumpPipeTable(
    );

#endif

#endif // REMOTE_NOTIFICATION_DISABLED



// *****************************************************************
//
//                    BaseRegNotifyChangeKeyValue
//
// *****************************************************************





BOOL
InitializeRegNotifyChangeKeyValue(
    )
/*++

Routine Description:


    Initializes the static data structures used by the
    RegNotifyChangeKeyValue server. Called once at program
    initialization.

Arguments:

    None

Return Value:

    BOOLEAN -   TRUE if successful.


--*/

{
#ifdef REMOTE_NOTIFICATION_DISABLED

    return( TRUE );

#else   // REMOTE_NOTIFICATION_DISABLED

    NTSTATUS        NtStatus;
    DWORD           Bucket;
    DWORD           MachineNameLength;


    NotificationListChainHead = NULL;

    //
    //  Determine our machine name
    //
    MachineNameLength = MAX_PATH;
    if ( !GetComputerNameW( OurMachineNameBuffer, &MachineNameLength ) ) {
        return FALSE;
    }

    OurMachineName.Buffer        = OurMachineNameBuffer;
    OurMachineName.Length        = (USHORT)(MachineNameLength * sizeof(WCHAR));
    OurMachineName.MaximumLength = (USHORT)(MAX_PATH * sizeof(WCHAR));


    //
    //  Initialize Notification critical section
    //
    NtStatus = RtlInitializeCriticalSection(
                    &NotificationCriticalSection
                    );

    if ( !NT_SUCCESS( NtStatus ) ) {
        return FALSE;
    }


    //
    //  Initialize the pipe symbol table
    //
    for ( Bucket = 0; Bucket < BUCKETS_IN_SYMBOL_TABLE; Bucket++ ) {
        PipeSymbolTable.Bucket[Bucket] = NULL;
    }

    return TRUE;
#endif   // REMOTE_NOTIFICATION_DISABLED
}




error_status_t
BaseRegNotifyChangeKeyValue(
    IN  HKEY                     hKey,
    IN  BOOLEAN                  fWatchSubtree,
    IN  DWORD                    dwNotifyFilter,
    IN  DWORD                    hEvent,
    IN  PUNICODE_STRING          MachineName,
    IN  PUNICODE_STRING          PipeName,
    IN  PRPC_SECURITY_ATTRIBUTES pRpcSa OPTIONAL
    )

/*++

Routine Description:

    This API is used to watch a key or sub-tree for changes. It is
    asynchronous. It is possible to filter the criteria by which the
    notification occurs.


Arguments:

    hKey - Supplies a handle to a key that has been previously opened with
        KEY_NOTIFY access.

    fWatchSubtree - Supplies a boolean value that if TRUE causes the
        system to monitor the key and all of its decsendants.  A value of
        FALSE causes the system to monitor only the specified key.

    dwNotifyFilter - Supplies a set of flags that specify the filter
        conditions the system uses to satisfy a change notification.

        REG_NOTIFY_CHANGE_KEYNAME - Any key name changes that occur
            in a key or subtree being watched will satisfy a
            change notification wait.  This includes creations
            and deletions.

        REG_NOTIFY_CHANGE_ATTRIBUTES - Any attribute changes that occur
            in a key or subtree being watched will satisfy a
            change notification.

        REG_NOTIFY_CHANGE_LAST_WRITE - Any last write time changes that
            occur in a key or subtree being watched will satisfy a
            change notification.

        REG_NOTIFY_CHANGE_SECURITY - Any security descriptor changes
            that occur in a key or subtree being watched will
            satisfy a change notification.


    hEvent - Supplies a DWORD which represents an event that will have to
             be communicated to the client (via named pipe) when a key
             has to be notified.


    PipeName - Supplies the name of the pipe used for communicating
            the notification to the client.

    pRpcSa - Supplies the optional security attributes of the named
            pipe.

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/

{

#ifdef REMOTE_NOTIFICATION_DISABLED

    return ERROR_INVALID_PARAMETER;

#else   // REMOTE_NOTIFICATION_DISABLED

    NTSTATUS            NtStatus;
    HANDLE              EventHandle;
    PNOTIFICATION_LIST  NotificationList;
    LONG                Error;
    UNICODE_STRING      FullPipeName;


    RPC_IMPERSONATE_CLIENT( NULL );

    //
    //  Enter the critical section
    //
    NtStatus = RtlEnterCriticalSection( &NotificationCriticalSection );
    if ( !NT_SUCCESS( NtStatus ) ) {
        return (error_status_t)RtlNtStatusToDosError( NtStatus );
    }

    try {

#if BIGDBG
        DbgPrint( "WINREG: RegNotify entered\n" );

        //DbgPrint( "WINREG: Notification requested. HKEY 0x%x, Client 0x%x, pipe %wZ\n",
        //           hKey, hEvent, PipeName );
        //DbgPrint( "       Watch subtree: 0x%x, filter 0x%x\n", fWatchSubtree, dwNotifyFilter );

#endif


        //
        //  Subtract the NULL from the Length of all the strings.
        //  This was added by the client so that RPC would transmit
        //  the whole thing.
        //
        if ( MachineName->Length > 0 ) {
            MachineName->Length -= sizeof(UNICODE_NULL );
        }
        if ( PipeName->Length > 0 ) {
            PipeName->Length -= sizeof(UNICODE_NULL );
        }

        //
        //  Construct the full pipe name based on the machine name
        //  and the pipe name given.
        //
        FullPipeName.Buffer = RtlAllocateHeap(
                                RtlProcessHeap( ), 0,
                                MAX_PATH * sizeof(WCHAR)
                                );

        if ( !FullPipeName.Buffer ) {

            Error = ERROR_OUTOFMEMORY;

        } else {


            FullPipeName.Length         = 0;
            FullPipeName.MaximumLength  = MAX_PATH * sizeof(WCHAR);


            Error = GetFullPipeName(
                        MachineName,
                        PipeName,
                        &FullPipeName
                        );

            if ( Error == ERROR_SUCCESS ) {

                //
                //  Create an event on which we will wait for completion of
                //  the API.
                //
                NtStatus = NtCreateEvent(
                                &EventHandle,
                                (ACCESS_MASK)EVENT_ALL_ACCESS,
                                NULL,
                                SynchronizationEvent,
                                FALSE
                                );

                if ( NT_SUCCESS( NtStatus ) ) {

                    //
                    //  Add the event to a Notification List
                    //
                    Error = AddEvent(
                                hKey,
                                EventHandle,
                                hEvent,
                                &FullPipeName,
                                pRpcSa,
                                &NotificationList
                                );

                    if ( Error == ERROR_SUCCESS ) {

                        //
                        //  Call the NT API
                        //
                        NtStatus = NtNotifyChangeKey(
                                        hKey,
                                        EventHandle,
                                        NULL,
                                        NULL,
                                        &IoStatusBlock,
                                        dwNotifyFilter,
                                        ( BOOLEAN ) fWatchSubtree,
                                        NULL,
                                        0,
                                        TRUE
                                        );

                        if ( NT_SUCCESS( NtStatus ) ||
                             (NtStatus == STATUS_PENDING) ) {

                            Error = ERROR_SUCCESS;

                        } else {

                            //
                            //  Could not request notification, remove the
                            //  event from the notification list.
                            //
                            Error = RemoveEvent(
                                        EventHandle,
                                        NotificationList
                                        );

                            ASSERT( Error == ERROR_SUCCESS );

                            Error = RtlNtStatusToDosError( NtStatus );
                        }

                    } else {

                        //
                        //  Could not add the event to any notification
                        //  list.
                        //
                        NtStatus = NtClose( EventHandle );
                        ASSERT( NT_SUCCESS( NtStatus ) );
                    }

                } else {

                    Error = RtlNtStatusToDosError( NtStatus );
                }
            }

            RtlFreeHeap(
                RtlProcessHeap( ), 0,
                FullPipeName.Buffer
                );
        }

    } except ( NtStatus = GetExceptionCode() ) {

#if DBG
        DbgPrint( "WINREG Error: Exception %x in BaseRegNotifyChangeKeyValue\n",
                  NtStatus );
        DbgBreakPoint();
#endif
        Error = RtlNtStatusToDosError( NtStatus );

    }

#if BIGDBG
    DbgPrint( "WINREG: RegNotify left\n" );
#endif

    NtStatus = RtlLeaveCriticalSection( &NotificationCriticalSection );
    ASSERT( NT_SUCCESS( NtStatus ) );

    RPC_REVERT_TO_SELF();
    return (error_status_t)Error;
#endif   // REMOTE_NOTIFICATION_DISABLED
}




BOOL
CleanDeadClientInfo(
    HKEY    hKey
    )
/*++

Routine Description:

    When a client dies, this function searches the notification lists to
    see if we the client has some pending notifications. We flag the
    entries in the notification lists and signal the events so that
    the notification handler can get rid of these orphans.

Arguments:

    hKey    -   Client's hKey

Return Value:

    BOOL - Returns TRUE unless something REALLY weird happened.


--*/

{
#ifdef REMOTE_NOTIFICATION_DISABLED

    return( TRUE );

#else // REMOTE_NOTIFICATION_DISABLED

    NTSTATUS            NtStatus;
    PNOTIFICATION_LIST  NotificationList;
    PNOTIFICATION_ENTRY Event;
    DWORD               Index;
    BOOL                Ok               = TRUE;
    BOOL                FoundDeadClients;

    //
    //  Enter the critical section
    //
    NtStatus = RtlEnterCriticalSection( &NotificationCriticalSection );
    if ( !NT_SUCCESS( NtStatus ) ) {
        return FALSE;
    }

#if BIGDBG
    DbgPrint( "WINREG: Dead client, hKey 0x%x\n", hKey );
#endif

    try {

        //
        //  Traverse all the lists looking for orphans.
        //
        for ( NotificationList = NotificationListChainHead;
              NotificationList;
              NotificationList = NotificationList->Next ) {

            FoundDeadClients = FALSE;
            Event = NotificationList->Event;

            //
            //  Examine all the entries of the list to see if any
            //  entry is an orphan.
            //
            for ( Index = 1;
                  Index < NotificationList->EventsInUse;
                  Index++ ) {

                //
                //  If this entry is an orphan, flag it as such and
                //  signal the event so that the notification handler
                //  can clean it up.
                //
                if ( Event->hKey == hKey ) {

#if BIGDBG
                    DbgPrint( "WINREG:  Found notification orphan, hKey 0x%x Client 0x%x\n",
                              hKey, Event->ClientEvent );
#endif
                    Event->Flags |= CLIENT_IS_DEAD;

                    FoundDeadClients = TRUE;
                }

                Event++;
            }

            if ( FoundDeadClients ) {
                NtStatus = NtSetEvent( NotificationList->EventHandle[0], NULL );
                ASSERT( NT_SUCCESS( NtStatus ) );
            }
        }

    } except ( NtStatus = GetExceptionCode() ) {

#if DBG
        DbgPrint( "WINREG Error: Exception %x in CleanDeadClientInfo\n",
                  NtStatus );
        DbgBreakPoint();
#endif

        Ok = FALSE;

    }

#if BIGDBG
    DbgPrint( "WINREG: Dead client left\n" );
#endif

    NtStatus = RtlLeaveCriticalSection( &NotificationCriticalSection );
    ASSERT( NT_SUCCESS( NtStatus ) );

    return Ok;
#endif // REMOTE_NOTIFICATION_DISABLED
}


// *****************************************************************
//
//                  Notification List funcions
//
// *****************************************************************



#ifndef REMOTE_NOTIFICATION_DISABLED

LONG
CreateNotificationList (
    OUT PNOTIFICATION_LIST  *NotificationListUsed
    )
/*++

Routine Description:

    Creates a new Notification List and its handler thread.

Arguments:

    NotificationListUsed    -   Supplies pointer to pointer to Notification List

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/

{

    PNOTIFICATION_LIST  NotificationList;
    DWORD               Index;
    NTSTATUS            NtStatus;
    LONG                Error;

#if BIGDBG
    DbgPrint( "WINREG: Creating new notification list\n" );
#endif

    //
    //  Allocate memory for the new Notification List
    //
    NotificationList = RtlAllocateHeap(
                            RtlProcessHeap( ), 0,
                            sizeof( NOTIFICATION_LIST )
                            );

    if ( !NotificationList ) {
        return ERROR_OUTOFMEMORY;
    }


    //
    //  Create the "Wake up" event handle, which is used to wake
    //  up the handler thread whenever new events are added to
    //  the notification list.
    //
    NtStatus = NtCreateEvent(
                    &(NotificationList->EventHandle[0] ),
                    (ACCESS_MASK)EVENT_ALL_ACCESS,
                    NULL,
                    SynchronizationEvent,
                    FALSE
                    );

    if ( NT_SUCCESS( NtStatus ) ) {

        //
        //  Mark rest of entries as "available"
        //
        for ( Index = 1; Index < MAXIMUM_WAIT_OBJECTS; Index++ ) {
            NotificationList->EventHandle[Index] = NULL;
        }

        //
        //  Set initial number of EventInUse to 1 (which is the
        //  index to the next available spot in the list).
        //
        NotificationList->EventsInUse = 1;

        //
        //  Set chain links
        //
        NotificationList->Previous  = NULL;
        NotificationList->Next      = NULL;

        NotificationList->PendingNotifications = 0;

        //
        //  Now that everything has been initialized, create the
        //  handler thread for the list.
        //
        NotificationList->HandlerThread =
                                CreateThread(
                                        NULL,
                                        (32 * 1024),
                                        (LPTHREAD_START_ROUTINE)NotificationHandler,
                                        NotificationList,
                                        0,
                                        (LPDWORD)&(NotificationList->HandlerClientId)
                                        );

        if ( NotificationList->HandlerThread != NULL ) {

            *NotificationListUsed = NotificationList;

            Error = ERROR_SUCCESS;

        } else {

            //
            //  Could not create thread, close the event that we just
            //  created.
            //
            Error = GetLastError();

#if DBG
            DbgPrint( "WINREG Error: Cannot create notification thread, error %d\n",
                      Error );
            DbgBreakPoint();
#endif

            NtStatus = NtClose( NotificationList->EventHandle[0] );

            ASSERT( NT_SUCCESS( NtStatus ) );
        }

    } else {

#if DBG
        DbgPrint( "WINREG Error: Cannot create notification event, status 0x%x\n",
                  NtStatus );
        DbgBreakPoint();
#endif

        Error = RtlNtStatusToDosError( NtStatus );
    }

    //
    //  If something went wrong, free up the notification list
    //
    if ( Error != ERROR_SUCCESS ) {
        RtlFreeHeap(
            RtlProcessHeap( ), 0,
            NotificationList
            );
        *NotificationListUsed = NULL;
    }

    return Error;
}




LONG
DeleteNotificationList (
    IN OUT  PNOTIFICATION_LIST  NotificationList
    )
/*++

Routine Description:

    Deletes a Notification List. The handler thread is not terminated
    because it is the handler thread who deletes notification lists,
    commiting suicide afterwards.

Arguments:

    NotificationList    -   Supplies pointer to Notification List

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/

{
    NTSTATUS    NtStatus;

#if BIGDBG
    DbgPrint( "WINREG: Removing empty notification list\n" );
#endif

    //
    //  The only event in the list must be the "wakeup" event
    //
    ASSERT( NotificationList->EventsInUse == 1 );

    //
    //  Delete the "wake up" event
    //
    NtStatus = NtClose( NotificationList->EventHandle[0] );
    ASSERT( NT_SUCCESS( NtStatus ) );

    //
    //  Free up the heap used by the Notification List
    //
    RtlFreeHeap(
         RtlProcessHeap( ), 0,
         NotificationList
         );

    return ERROR_SUCCESS;
}




LONG
AddEvent (
    IN  HKEY                     hKey,
    IN  HANDLE                   EventHandle,
    IN  DWORD                    ClientEvent,
    IN  PUNICODE_STRING          PipeName,
    IN  PRPC_SECURITY_ATTRIBUTES pRpcSa OPTIONAL,
    OUT PNOTIFICATION_LIST      *NotificationListUsed
    )
/*++

Routine Description:

    Adds an event to the first notification list with an available slot.

    If no notification list has an available slot, a new notification list
    (an its handler thread) is created.


Arguments:

    hKey        -   Supplies registry key handle

    EventHandle -   Supplies an event on which the handler thread of the
                    Notification List has to wait.

    ClientEvent -   Supplies the event which has to be communicated to the
                    client when out EventHandle is signaled. This event is
                    communicated to the client via named pipe.

    PipeNameU   -   Supplies the name of the pipe for communicating with the
                    client.

    pRpcSa      -   Supplies the optional security attributes of the named
                    pipe.

    NotificationListused -   Supplies a pointer where the address of the
                             Notification List in which the event is put
                             is placed.

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/

{
    PNOTIFICATION_LIST  NotificationList;
    LONG                Error;
    NTSTATUS            NtStatus;

    ASSERT( EventHandle != NULL );
    ASSERT( PipeName && PipeName->Buffer );
    ASSERT( NotificationListUsed );


    //
    //  Get a Notification List with an available entry.
    //
    Error = GetAvailableNotificationList(
                    &NotificationList
                    );

    if ( Error == ERROR_SUCCESS ) {

        //
        //  Add the entry
        //
        Error = AddEntryToNotificationList(
                        NotificationList,
                        hKey,
                        EventHandle,
                        ClientEvent,
                        PipeName,
                        pRpcSa
                        );

        if ( Error == ERROR_SUCCESS ) {

            //
            //  A new entry has been added, we have to wake up the
            //  handler thread so that it will wait on the newly added
            //  event.
            //
            NtStatus = NtSetEvent( NotificationList->EventHandle[0], NULL );
            ASSERT( NT_SUCCESS( NtStatus ) );

            *NotificationListUsed = NotificationList;

        } else {

#if DBG
            DbgPrint( "WINREG: Could not add notification entry! Error %d\n ", Error);
#endif
        }

    } else {

#if DBG
        DbgPrint( "WINREG: Could not get a notification list! Error %d\n ", Error);
#endif

    }

    return Error;
}




LONG
RemoveEvent (
    IN      HANDLE              EventHandle,
    IN OUT  PNOTIFICATION_LIST  NotificationList
    )

/*++

Routine Description:

    Removes an event from the notification list. The caller must
    make sure that the event handle given does live in the
    Notification List specified.

    This function is called if the notification is aborted for some
    reason (e.g. the NT notification API fails).

Arguments:

    EventHandle         -   Supplies the event to remove.

    NotificationList    -   Supplies the Notification List in which
                            the event lives.

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/

{
    LONG        Error;
    DWORD       EntryIndex;

    //
    //  Search for the entry that we have to remove.
    //
    for ( EntryIndex = 1;
          EntryIndex < NotificationList->EventsInUse;
          EntryIndex++ ) {

        if ( EventHandle == NotificationList->EventHandle[ EntryIndex ] ) {
            break;
        }
    }

    ASSERT( EntryIndex < NotificationList->EventsInUse );

    if ( EntryIndex < NotificationList->EventsInUse ) {

        //
        //  Found entry, remove it
        //
        Error = RemoveEntryFromNotificationList(
                    NotificationList,
                    EntryIndex
                    );

        //
        //  Note that we are leaving a hole in the Notification list,
        //  the handler will eventually compact it.
        //

    } else {

        Error = ERROR_ARENA_TRASHED;

    }

    return Error;
}




LONG
GetAvailableNotificationList (
    OUT PNOTIFICATION_LIST  *NotificationListUsed
    )
/*++

Routine Description:

    Gets a Notification List with an available entry.

Arguments:

    NotificationList    -   Supplies pointer to where the Notification
                            List pointer will be placed.

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/
{
    LONG                Error = ERROR_SUCCESS;
    PNOTIFICATION_LIST  NotificationList;

    //
    //  Traverse the chain of Notification lists until we find a Notification
    //  list with an available entry.
    //
    for ( NotificationList = NotificationListChainHead;
          NotificationList && NotificationList->EventsInUse >= MAXIMUM_WAIT_OBJECTS;
          NotificationList = NotificationList->Next );


    //
    //  If we did not find a Notification List with an available spot,
    //  create a new Notification List and add it to the chain.
    //
    if ( !NotificationList ) {

        Error = CreateNotificationList( &NotificationList );

        if ( Error == ERROR_SUCCESS ) {

            ASSERT( NotificationList );

            AddNotificationListToChain( NotificationList );
        }
    }

    *NotificationListUsed = NotificationList;

    return Error;
}




LONG
AddEntryToNotificationList(
        IN OUT  PNOTIFICATION_LIST       NotificationList,
        IN      HKEY                     hKey,
        IN      HANDLE                   EventHandle,
        IN      DWORD                    ClientEvent,
        IN      PUNICODE_STRING          PipeName,
        IN      PRPC_SECURITY_ATTRIBUTES pRpcSa     OPTIONAL
        )
/*++

Routine Description:

    Adds an entry to a notification list.

    Calls to this function must be protected by the critical
    section of the Notification List.


Arguments:

    NotificationList    -   Supplies pointer to Notification List

    hKey                -   Supplies registry key handle

    EventHandle         -   Supplies the event handle

    ClientEvent         -   Supplies the client's event

    PipeName            -   Supplies name of pipe.

    pRpcSa              -   Supplies security attributes for the pipe

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/
{
    LONG                Error;
    PPIPE_ENTRY         PipeEntry;
    DWORD               Index;
    PNOTIFICATION_ENTRY Event;


    //
    //  Add the pipe information to the pipe symbol table
    //
    Error = AddPipe( PipeName, pRpcSa, &PipeEntry );

    if ( Error == ERROR_SUCCESS ) {

        //
        //  Add the event in the next available spot in the list,
        //  and increment the number of events in use by the
        //  list.
        //
        Index = NotificationList->EventsInUse++;

        Event = &(NotificationList->Event[ Index ]);

        NotificationList->EventHandle[ Index ] = EventHandle;

        Event->ClientEvent = ClientEvent;
        Event->hKey        = hKey;
        Event->Flags       = 0;
        Event->PipeEntry   = PipeEntry;

    } else {

#if BIGDBG
        DbgPrint( "WINREG: Could not create pipe entry for %wZ\n",
                  PipeName );
#endif

    }

    return Error;
}




LONG
RemoveEntryFromNotificationList (
    IN OUT  PNOTIFICATION_LIST  NotificationList,
    IN      DWORD               EntryIndex
    )
/*++

Routine Description:


    Removes an entry from a Notification List. It leaves a hole
    in the list, i.e. the list is not compacted.

Arguments:

    NotificationList    -   Supplies pointer to Notification List.

    EntryIndex          -   Supplies index of entry to remove.

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/

{
    LONG    Error;

    ASSERT( EntryIndex < NotificationList->EventsInUse );
    ASSERT( NotificationList->EventHandle[ EntryIndex ] != NULL );

    //
    //  Remove the entry from the pipe symbol table.
    //
    Error = RemovePipe( NotificationList->Event[ EntryIndex ].PipeEntry );

    if ( Error == ERROR_SUCCESS ) {

        //
        //  We "remove" the entry from the notification list by
        //  invalidating its handle. Note that we don't decrement
        //  the counter of entries in the notification list because
        //  that is used for indexing the next available entry.
        //  The counter will be fixed by the compaction function.
        //
        NotificationList->EventHandle[ EntryIndex ]     = NULL;
        NotificationList->Event[ EntryIndex ].PipeEntry = NULL;
    }

    return Error;
}




LONG
CompactNotificationList (
    IN OUT  PNOTIFICATION_LIST  NotificationList
    )
/*++

Routine Description:


    Compacts (i.e. removes holes from) a Notification List.

Arguments:

    NotificationList    -   Supplies pointer to Notification List.

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/

{
    DWORD   ToIndex;
    DWORD   FromIndex;
    DWORD   Index;
    DWORD   EntriesToMove;
    PVOID   Src;
    PVOID   Dst;

#if BIGDBG
    DbgPrint( "    * Compacting notification list\n" );
#endif

    for ( ToIndex = 1; ToIndex < NotificationList->EventsInUse; ToIndex++ ) {

#if BIGDBG
        DbgPrint( "        - %d\n", ToIndex );
#endif
        //
        //  If we find a hole, we compact the arrays i.e. shift them to
        //  remove the hole.
        //
        if ( NotificationList->EventHandle[ ToIndex ] == NULL ) {

            //
            //  Found the beginning of a hole, search for the next
            //  entry in use.
            //
            for ( FromIndex = ToIndex+1;
                  (FromIndex < NotificationList->EventsInUse) &&
                  (NotificationList->EventHandle[ FromIndex ] == NULL );
                  FromIndex++ ) {
            }

            //
            //  If there is something to shift, shift it
            //
            if ( FromIndex < NotificationList->EventsInUse ) {

                EntriesToMove = NotificationList->EventsInUse - FromIndex;

                Src = (PVOID)&(NotificationList->EventHandle[ FromIndex ] );
                Dst = (PVOID)&(NotificationList->EventHandle[ ToIndex ] );

                RtlMoveMemory(
                         Dst,
                         Src,
                         EntriesToMove * sizeof( HANDLE )
                         );

                Src = &(NotificationList->Event[ FromIndex ] );
                Dst = &(NotificationList->Event[ ToIndex ] );

                RtlMoveMemory(
                         Dst,
                         Src,
                         EntriesToMove * sizeof( NOTIFICATION_ENTRY )
                         );

                //
                //  Clear the rest of the entries, just to keep things
                //  clean.
                //
                for ( Index = ToIndex + EntriesToMove;
                      Index < NotificationList->EventsInUse;
                      Index++ ) {

                    NotificationList->EventHandle[ Index ] = NULL;
                }

                NotificationList->EventsInUse -= (FromIndex - ToIndex);


            } else {

                //
                //  Nothing to shift, this will become the
                //  first available entry of the list.
                //
                NotificationList->EventsInUse = ToIndex;
            }
        }
    }

#if BIGDBG
    DbgPrint( "    * Compacted.\n" );
#endif


    return ERROR_SUCCESS;
}





VOID
AddNotificationListToChain(
    IN OUT  PNOTIFICATION_LIST  NotificationList
    )

/*++

Routine Description:

    Adds a Notification list to the chain of Notification Lists.

    The new list is put at the head of the chain.

Arguments:

    NotificationList    -   Supplies the Notification list to add


Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/

{

    NotificationList->Previous = NULL;
    NotificationList->Next     = NotificationListChainHead;

    if ( NotificationListChainHead ) {
        NotificationListChainHead->Previous = NotificationList;
    }

    NotificationListChainHead = NotificationList;
}




VOID
RemoveNotificationListFromChain(
    IN OUT  PNOTIFICATION_LIST  NotificationList
    )
/*++

Routine Description:

    Removes a Notification list from the chain


Arguments:

    NotificationList    -   Supplies the Notification list to remove


Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/

{

    if ( NotificationList->Previous ) {
        (NotificationList->Previous)->Next = NotificationList->Next;
    }

    if ( NotificationList->Next ) {
        (NotificationList->Next)->Previous = NotificationList->Previous;
    }


    //
    //  If this is at the head of the chain, Let the next
    //  list be the new head.
    //
    if ( NotificationListChainHead == NotificationList ) {
        NotificationListChainHead = NotificationList->Next;
    }
}



// *****************************************************************
//
//                  Pipe Symbol Table functions
//
// *****************************************************************


LONG
GetFullPipeName (
    IN  PUNICODE_STRING          MachineName,
    IN  PUNICODE_STRING          PipeName,
    OUT PUNICODE_STRING          FullPipeName
    )
/*++

Routine Description:

    Makes a fully qualified pipe name from the supplied machine
    name and pipe name.

Arguments:

    PipeName        -   Supplies the pipe name

    MachineName     -   Supplies the client's machine name

    FullPipeName    -   Supplies the full pipe name

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/

{
    LONG            Error = ERROR_SUCCESS;
    NTSTATUS        NtStatus;

    ASSERT( PipeName->Buffer     && MachineName->Buffer &&
            PipeName->Length > 0 && MachineName->Length > 0 );

    if( !PipeName->Buffer     || !MachineName->Buffer ||
        PipeName->Length == 0 || MachineName->Length == 0 ) {
        Error =  ERROR_INVALID_PARAMETER;
    }

    if ( Error == ERROR_SUCCESS ) {

        //
        //  If the client's machine name and our machine name match,
        //  then we form a local named pipe path, otherwise we
        //  form a remote named pipe path.
        //
        if ( RtlEqualUnicodeString(
                        MachineName,
                        &OurMachineName,
                        TRUE
                        ) ) {


            //
            //  Pipe is local
            //
            RtlMoveMemory(
                    FullPipeName->Buffer,
                    NAMED_PIPE_HERE,
                    sizeof( NAMED_PIPE_HERE )
                    );

            FullPipeName->Length = sizeof( NAMED_PIPE_HERE ) - sizeof(UNICODE_NULL);


        } else {

            //
            //  Pipe is remote
            //
            RtlMoveMemory(
                    FullPipeName->Buffer,
                    NAMED_PIPE_THERE,
                    sizeof( NAMED_PIPE_THERE )
                    );

            FullPipeName->Length = sizeof( NAMED_PIPE_THERE ) - sizeof(UNICODE_NULL);

            NtStatus = RtlAppendUnicodeStringToString(
                                FullPipeName,
                                MachineName
                                );

            ASSERT( NT_SUCCESS( NtStatus ) );

            if ( NT_SUCCESS( NtStatus ) ) {

                NtStatus = RtlAppendUnicodeToString(
                                    FullPipeName,
                                    L"\\Pipe\\"
                                    );

                ASSERT( NT_SUCCESS( NtStatus ) );

                if ( !NT_SUCCESS( NtStatus ) ) {
                    Error = RtlNtStatusToDosError( NtStatus );
                }

            } else {

                Error = RtlNtStatusToDosError( NtStatus );
            }
        }

        if ( Error == ERROR_SUCCESS ) {

            NtStatus = RtlAppendUnicodeStringToString(
                                FullPipeName,
                                PipeName
                                );

            ASSERT( NT_SUCCESS( NtStatus ) );

            if ( !NT_SUCCESS( NtStatus ) ) {
                Error = RtlNtStatusToDosError( NtStatus );
            }
        }
    }

    return Error;
}






LONG
CreatePipeEntry (
    IN  PUNICODE_STRING          PipeName,
    IN  PRPC_SECURITY_ATTRIBUTES pRpcSa     OPTIONAL,
    OUT PPIPE_ENTRY              *PipeEntryUsed
    )
/*++

Routine Description:

    Creates a pipe entry

Arguments:

    PipeName    -   Supplies the pipe name

    pRpcSa      -   Supplies the optional security attributes for the pipe

    PipeEntry   -   Supplies pointer to pointer to pipe entry.

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/

{

    PPIPE_ENTRY PipeEntry;
    LONG        Error;
    ULONG       LengthSd;

    ASSERT( PipeName && PipeName->Buffer );

    //
    //  Validate the security descriptor if one was provided
    //
    if ( pRpcSa ) {
        if ( !RtlValidSecurityDescriptor(
                pRpcSa->RpcSecurityDescriptor.lpSecurityDescriptor
                ) ) {

            return ERROR_INVALID_PARAMETER;
        }
    }


    //
    //  Allocate space for the Pipe Entry
    //
    PipeEntry = RtlAllocateHeap(
                    RtlProcessHeap( ), 0,
                    sizeof( PIPE_ENTRY )
                    );

    if ( !PipeEntry ) {
        return ERROR_OUTOFMEMORY;
    }


    //
    //  Allocate space for the pipe's name
    //
    PipeEntry->PipeName.Buffer = RtlAllocateHeap(
                                    RtlProcessHeap( ), 0,
                                    PipeName->Length + sizeof( UNICODE_NULL )
                                    );

    PipeEntry->PipeName.MaximumLength = PipeName->Length + (USHORT)sizeof( UNICODE_NULL );

    if ( PipeEntry->PipeName.Buffer ) {

        //
        //  Copy the pipe name
        //
        RtlCopyUnicodeString(
                &(PipeEntry->PipeName),
                PipeName
                );

        PipeEntry->Previous = NULL;
        PipeEntry->Next     = NULL;

        PipeEntry->ReferenceCount = 0;

        //
        //  Allocate space for the security descriptor if one
        //  is provided.
        //
        if ( pRpcSa ) {

            LengthSd = RtlLengthSecurityDescriptor(
                            pRpcSa->RpcSecurityDescriptor.lpSecurityDescriptor
                            );

            PipeEntry->SecurityDescriptor = RtlAllocateHeap(
                                                RtlProcessHeap( ), 0,
                                                LengthSd
                                                );


            if ( PipeEntry->SecurityDescriptor ) {

                //
                //  Copy the security descriptor
                //
                RtlMoveMemory (
                        PipeEntry->SecurityDescriptor,
                        pRpcSa->RpcSecurityDescriptor.lpSecurityDescriptor,
                        LengthSd
                        );

                *PipeEntryUsed = PipeEntry;

                return ERROR_SUCCESS;

            } else {

                Error = ERROR_OUTOFMEMORY;
            }

            RtlFreeHeap(
                 RtlProcessHeap( ), 0,
                 PipeEntry->PipeName.Buffer
                 );

        } else {

            PipeEntry->SecurityDescriptor = NULL;

            *PipeEntryUsed = PipeEntry;

            return ERROR_SUCCESS;
        }

    } else {

        Error = ERROR_OUTOFMEMORY;
    }


    RtlFreeHeap(
         RtlProcessHeap( ), 0,
         PipeEntry
         );

    return Error;
}



LONG
DeletePipeEntry(
    IN OUT PPIPE_ENTRY  PipeEntry
    )

/*++

Routine Description:


    Deletes a pipe entry

Arguments:

    PipeEntry   -   Supplies pointer to pipe entry

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/

{

#if BIGDBG
    DbgPrint( "    * In DeletePipeEntry\n" );
#endif

    ASSERT( PipeEntry );
    ASSERT( PipeEntry->PipeName.Buffer );

    if ( PipeEntry->PipeName.Buffer ) {
        RtlFreeHeap(
             RtlProcessHeap( ), 0,
            PipeEntry->PipeName.Buffer
            );
    }

    if ( PipeEntry->SecurityDescriptor != NULL ) {
        RtlFreeHeap(
             RtlProcessHeap( ), 0,
             PipeEntry->SecurityDescriptor
             );
    }

    RtlFreeHeap(
         RtlProcessHeap( ), 0,
         PipeEntry
         );


#if BIGDBG
    DbgPrint( "    * Deleted PipeEntry.\n" );
#endif

    return ERROR_SUCCESS;
}




LONG
AddPipe(
    IN  PUNICODE_STRING          PipeName,
    IN  PRPC_SECURITY_ATTRIBUTES pRpcSa     OPTIONAL,
    OUT PPIPE_ENTRY              *PipeEntryUsed
    )

/*++

Routine Description:

    Adds a new entry to the pipe symbol table

Arguments:

    PipeName    -   Supplies the pipe name

    pRpcSa      -   Supplies the optional security attributes for the pipe

    PipeEntry   -   Supplies pointer to pointer to pipe entry in the
                    symbol table.

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/

{
    PPIPE_ENTRY PipeEntry;
    LONG        Error;


    //
    //  Look for the pipe name in the symbol table
    //
    Error  = LookForPipeEntryInSymbolTable( PipeName, &PipeEntry );

    if ( Error == ERROR_SUCCESS ) {

        //
        //  If the pipe is not in the symbol table, add it
        //
        if ( !PipeEntry ) {

            //
            //  Create a new pipe entry
            //
            Error = CreatePipeEntry(
                        PipeName,
                        pRpcSa,
                        &PipeEntry
                        );

            if ( Error == ERROR_SUCCESS ) {

                //
                //  Add the entry to the symbol table
                //
                Error = AddPipeEntryToSymbolTable(
                            PipeEntry
                            );

                if ( Error != ERROR_SUCCESS ) {

                    //
                    //  Could not add pipe entry, delete it.
                    //
                    DeletePipeEntry( PipeEntry );
                    PipeEntry = NULL;
                }
            }
        }

        //
        //  If got a pipe entry, increment its reference count
        //
        if ( PipeEntry ) {

            PipeEntry->ReferenceCount++;
            *PipeEntryUsed = PipeEntry;
        }
    }

#if BIGDBG
        DbgPrint( "Added Pipe %Z:\n", PipeName );
        DumpPipeTable();
#endif

    return Error;
}




LONG
RemovePipe(
    IN OUT PPIPE_ENTRY  PipeEntry
    )

/*++

Routine Description:

    Decrements the reference count of a pipe entry and removes the
    entry if the reference count reaches zero.

Arguments:

    PipeEntry   -   Supplies pointer to pipe entry in the symbol table

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/

{

    LONG        Error = ERROR_SUCCESS;
    PPIPE_ENTRY Entry = PipeEntry;

    ASSERT( Entry );
    ASSERT( Entry->ReferenceCount > 0 );

#if BIGDBG
    DbgPrint( "    * In RemovePipe - Ref. count %d\n", Entry->ReferenceCount );
#endif

    //
    //  Decrement the reference count
    //
    Entry->ReferenceCount--;

    //
    //  If the reference count is zero, we can delete the
    //  entry
    //
    if ( Entry->ReferenceCount == 0 ) {

        //
        //  Remove the pipe entry from the symbol table
        //
        Error = RemovePipeEntryFromSymbolTable(
                    Entry
                    );

        if ( Error == ERROR_SUCCESS ) {

            //
            //  Delete the pipe entry
            //
            ASSERT( PipeEntry > (PPIPE_ENTRY)0x100 );
            Error = DeletePipeEntry( Entry );
        }
    }

#if BIGDBG
    DbgPrint( "    * Pipe Removed.\n" );
#endif

    return Error;
}



LONG
AddPipeEntryToSymbolTable(
    IN OUT  PPIPE_ENTRY PipeEntry
    )

/*++

Routine Description:


    Adds a pipe entry to the symbol table at the specified bucket.

    Entries are always added at the head of the chain.

    Calls to this function must be protected by the critical section
    of the pipe symbol table.

Arguments:

    PipeEntry   -   Supplies pointer to pipe entry

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/

{
    DWORD   Bucket;

    Bucket = HASH( &(PipeEntry->PipeName), BUCKETS_IN_SYMBOL_TABLE );

    PipeEntry->Previous = NULL;
    PipeEntry->Next     = PipeSymbolTable.Bucket[ Bucket ];

    if ( PipeSymbolTable.Bucket[ Bucket ] ) {
        (PipeSymbolTable.Bucket[ Bucket ])->Previous = PipeEntry;
    }

    PipeSymbolTable.Bucket[ Bucket ] = PipeEntry;

    return ERROR_SUCCESS;
}




LONG
RemovePipeEntryFromSymbolTable(
    IN OUT  PPIPE_ENTRY PipeEntry
    )

/*++

Routine Description:


    Removes a pipe entry from the symbol table at the specified bucket

    Calls to this function must be protected by the critical section
    of the pipe symbol table.

Arguments:

    PipeEntry   -   Supplies pointer to pipe entry

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/

{
    DWORD   Bucket;

#if BIGDBG
    DbgPrint( "    * In RemovePipeEntryFromSymbolTable\n" );
#endif

    ASSERT( PipeEntry > (PPIPE_ENTRY)0x100 );

    Bucket = HASH( &(PipeEntry->PipeName), BUCKETS_IN_SYMBOL_TABLE );

    ASSERT( PipeEntry > (PPIPE_ENTRY)0x100 );
    ASSERT( Bucket < BUCKETS_IN_SYMBOL_TABLE );

    //
    //  Remove the entry from the chain
    //
    if ( PipeEntry->Previous ) {
        (PipeEntry->Previous)->Next = PipeEntry->Next;
    }

    if ( PipeEntry->Next ) {
        (PipeEntry->Next)->Previous = PipeEntry->Previous;
    }


    //
    //  If this entry is at the head of the chain, Let the next
    //  entry be the new head.
    //
    ASSERT( PipeSymbolTable.Bucket[ Bucket ] != NULL );
    if ( PipeSymbolTable.Bucket[ Bucket ] == PipeEntry ) {
        PipeSymbolTable.Bucket[ Bucket ] = PipeEntry->Next;
    }

    PipeEntry->Next     = NULL;
    PipeEntry->Previous = NULL;

    ASSERT( PipeEntry > (PPIPE_ENTRY)0x100 );

#if BIGDBG
    DbgPrint( "    * Piped entry removed from symbol table.\n" );
#endif

    return ERROR_SUCCESS;
}




LONG
LookForPipeEntryInSymbolTable(
    IN  PUNICODE_STRING PipeName,
    OUT PPIPE_ENTRY     *PipeEntryUsed
    )
/*++

Routine Description:

    Looks for an entry corresponding to the given name in a particular
    bucket of the pipe symbol table.

    Note that this function always returns ERROR_SUCCESS. To find out
    if the pipe is in the chain or not the returned parameter has to
    be checked.

    Calls to this function must be protected by the critical section
    of the pipe symbol table.

Arguments:

    PipeName    -   Supplies the pipe name

    Bucket      -   Supplies the bucket

    PipeEntry   -   Supplies pointer to pointer to pipe entry.

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/
{
    PPIPE_ENTRY  PipeEntry;
    DWORD        Bucket;

    Bucket = HASH( PipeName, BUCKETS_IN_SYMBOL_TABLE );

    //
    //  Look for the entry
    //
    for ( PipeEntry = PipeSymbolTable.Bucket[ Bucket ];
          PipeEntry && !RtlEqualUnicodeString( PipeName, &(PipeEntry->PipeName), TRUE);
          PipeEntry = PipeEntry->Next );


    *PipeEntryUsed = PipeEntry;

    return ERROR_SUCCESS;
}




DWORD
Hash(
    IN  PUNICODE_STRING  Symbol,
    IN  DWORD            Buckets
    )
/*++

Routine Description:


    Obtains a hash value for a given symbol

Arguments:


    Symbol      -   Supplies the symbol to hash

    Buckets     -   Supplies the number of buckets in the sybol table.

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.


--*/
{
    DWORD   n;
    DWORD   HashValue;
    WCHAR   c;
    LPWSTR  s;

#if BIGDBG
    DbgPrint( "    * Hashing\n" );
#endif

    n         = Symbol->Length/sizeof(WCHAR);
    s         = Symbol->Buffer;
    HashValue = 0;

    while (n--) {

        c = *s++;

        HashValue = HashValue + (c << 1) + (c >> 1) + c;
    }

    return HashValue % Buckets;

}







// *****************************************************************
//
//                  Notification List Handler
//
// *****************************************************************



VOID
NotificationHandler(
    IN  PNOTIFICATION_LIST  NotificationList
    )

/*++

Routine Description:

    Handler of a Notification List.

Arguments:


    NotificationList    -   Supplies pointer to the Notification List
                            to handle.

Return Value:

    None

--*/

{

    NTSTATUS        NtStatus;
    DWORD           NumberOfEvents;
    HANDLE          Thread;
    BOOLEAN         KeepOnGoing = TRUE;
    DWORD           Index;
    LARGE_INTEGER   TimeOut;


    ASSERT( NotificationList );

    //
    //  Initially we'll wait on only one event, i.e. the
    //  "wake up" event
    //
    NumberOfEvents = 1;
    NotificationList->TimeOutCount = 0;
    NotificationList->ResetCount = FALSE;

    while ( KeepOnGoing ) {

        TimeOut.QuadPart = Int32x32To64( -10000,
                                         5000*NotificationList->TimeOutCount );

        //
        //  Wait for some event
        //
        NtStatus = NtWaitForMultipleObjects(
                        (CHAR)NumberOfEvents,
                        NotificationList->EventHandle,
                        WaitAny,
                        FALSE,
                        (NotificationList->PendingNotifications > 0) ?
                            &TimeOut : NULL
                        );

        Index = (DWORD)NtStatus;

        if ( (Index < 0) || (Index >= NumberOfEvents) ) {
            Index = 0;
        }

        ASSERT( Index < NumberOfEvents );

        NtStatus = RtlEnterCriticalSection( &NotificationCriticalSection );
        ASSERT( NT_SUCCESS( NtStatus ) );

#if BIGDBG
        DbgPrint( "WINREG: Notification handler signaled, Index %d\n", Index );
#endif

        try {

            //
            //  If an event was triggered, mark it as a pending notification so
            //  that the NotificationListMaintenance function will notify
            //  the client.
            //
            if ( Index > 0 ) {
                NotificationList->PendingNotifications++;
                NotificationList->Event[Index].Flags |= MUST_NOTIFY;
            }

            //
            //  Notify all the clients with pending notifications and
            //  remove entries for dead clients.
            //
            NumberOfEvents = NotificationListMaintenance( NotificationList );

            if( NotificationList->PendingNotifications != 0 ) {
                if( NotificationList->ResetCount ) {
                    NotificationList->TimeOutCount = 1;
                    NotificationList->ResetCount = FALSE;
                } else {
                    if( NotificationList->TimeOutCount == 0 ) {
                        NotificationList->TimeOutCount = 1;
                    } else {
                        if( NotificationList->TimeOutCount != MAX_TIMEOUT_COUNT ) {
                            NotificationList->TimeOutCount =
                                          NotificationList->TimeOutCount << 1;
                        }
                    }
                }
            } else {
                NotificationList->TimeOutCount = 0;
            }

            //
            //  If the list is empty, then try to take it out of the chain, and
            //  if successful, our job is done.
            //
            if ( NumberOfEvents == 1 ) {

#if BIGDBG
                DbgPrint( "    * Removing the notification list!\n" );
#endif
                //
                //  Make sure that the list is empty.
                //
                ASSERT( NotificationList->EventsInUse == 1 );
                if (NotificationList->EventsInUse == 1) {

                    //
                    //  The list is empty, remove the list from the chain
                    //  and delete it.
                    //
                    RemoveNotificationListFromChain( NotificationList );
                    Thread = NotificationList->HandlerThread;
                    DeleteNotificationList( NotificationList );

                    //
                    //  The list is gone, we can die.
                    //
                    KeepOnGoing = FALSE;
                }
            }

        } except ( NtStatus = GetExceptionCode() ) {

#if DBG
            DbgPrint( "WINREG Error: Exception %x in NotificationHandler\n",
                      NtStatus );
            DbgBreakPoint();
#endif

        }


#if BIGDBG
        if ( KeepOnGoing ) {
            DbgPrint( "WINREG: Notification handler waiting...\n" );
        } else {
            DbgPrint( "WINREG: Notification handler dying...\n" );
        }
#endif

        NtStatus = RtlLeaveCriticalSection( &NotificationCriticalSection );
        ASSERT( NT_SUCCESS( NtStatus ) );

    }

    //
    //  The list is gone, and so must we.
    //
    ExitThread( 0 );

    ASSERT( FALSE );

}



DWORD
NotificationListMaintenance(
    IN OUT  PNOTIFICATION_LIST  NotificationList
    )
/*++

Routine Description:

    Performs all the maintenance necessary in the notification list.
    The maintenance consists of:

    - Notifying all clients with pending notifications.

    - Removing entries in the list for dead clients.

    - Compacting the notification list.

Arguments:


    NotificationList    -   Supplies pointer to the Notification List

Return Value:

    DWORD   -   The new number of events in the list

--*/

{

    LONG                Error;
    DWORD               NumberOfEvents;
    DWORD               Index;
    BOOLEAN             Remove;
    PNOTIFICATION_ENTRY Event;
    NTSTATUS            NtStatus;
    PPIPE_ENTRY         PipeEntry;

#if BIGDBG
    DbgPrint( "    * In NotificationListMaintenance\n" );
    DumpNotificationLists();
#endif

    //
    //  Traverse the list notifying clients if necessary and removing
    //  events that are no longer needed, either because they have
    //  already been notified or because the client is dead.
    //
    for (Index = 1; Index < NotificationList->EventsInUse; Index++ ) {

#if BIGDBG
        DbgPrint( "      - %d\n", Index );
#endif
        Remove = FALSE;
        Event  = &(NotificationList->Event[ Index ]);

        if ( Event->Flags & CLIENT_IS_DEAD ) {

            //
            //  No client, must remove the entry.
            //
            Remove = TRUE;

        } else if ( Event->Flags & MUST_NOTIFY ) {

            //
            //  Must notify this client
            //
            Error = SendEventToClient(
                        Event->ClientEvent,
                        Event->PipeEntry
                        );

            if (Error == ERROR_SUCCESS) {
                //
                //  If successfully notified, remove the entry.
                //
                Remove = TRUE;
                Event->Flags &= ~NOTIFICATION_FAILED;
            } else {
                //
                //  If couldn't notify, set ResetCount if the notification
                //  failed for the first time
                //
                if( ( Event->Flags & NOTIFICATION_FAILED ) == 0 ) {
                    NotificationList->ResetCount = TRUE;
                    Event->Flags |= NOTIFICATION_FAILED;
                }
            }
        }

        //
        //  Remove the entry if no longer needed.
        //
        if ( Remove ) {

            //
            //  Remove the pipe entry
            //
            PipeEntry = Event->PipeEntry;
            RemovePipe( PipeEntry );

            Event->PipeEntry = NULL;

            //
            //  Remove the event
            //
#if BIGDBG
            DbgPrint( "        Cleanup\n" );
#endif

            NtStatus = NtClose( NotificationList->EventHandle[ Index ] );
            ASSERT( NT_SUCCESS( NtStatus ) );
            NotificationList->EventHandle[ Index ] = NULL;

            //
            //  If this was a pending notification, decrement the
            //  counter.
            //
            if ( Event->Flags & MUST_NOTIFY ) {
                NotificationList->PendingNotifications--;
            }
        }
    }


    //
    //  Compact the list.
    //
    Error = CompactNotificationList( NotificationList );

    ASSERT( Error == ERROR_SUCCESS );

    //
    //  Get the new number of entries in the list
    //
    NumberOfEvents = NotificationList->EventsInUse;

#if BIGDBG
    DbgPrint( "    * Maintenance Done (%d)\n", NumberOfEvents );
#endif

    return NumberOfEvents;
}





LONG
SendEventToClient(
    IN  DWORD           ClientEvent,
    IN  PPIPE_ENTRY     PipeEntry
    )
/*++

Routine Description:

    Sends an event to the client via the client's named pipe

Arguments:


    PipeEntry       -   Supplies the pipe entry for the client's named
                        pipe.

    ClientEvent     -   Supplies the event that has to be sent to the
                        client.

Return Value:

    LONG -  Returns ERROR_SUCCESS (0); error-code for failure.

--*/

{

    HANDLE              Handle;
    LONG                Error = ERROR_SUCCESS;
    OBJECT_ATTRIBUTES   Obja;
    NTSTATUS            NtStatus;

    ASSERT( PipeEntry != NULL );
    ASSERT( PipeEntry->PipeName.Buffer != NULL );

    //
    // Initialize the Obja structure for the named pipe
    //
    InitializeObjectAttributes(
        &Obja,
        &(PipeEntry->PipeName),
        OBJ_CASE_INSENSITIVE,
        NULL,
        PipeEntry->SecurityDescriptor
        );


    //
    // Open our side of the pipe
    //
    NtStatus = NtOpenFile(
                    &Handle,
                    GENERIC_WRITE | SYNCHRONIZE,
                    &Obja,
                    &IoStatusBlock,
                    FILE_SHARE_WRITE,
                    FILE_NON_DIRECTORY_FILE
                    );


    if ( NT_SUCCESS( NtStatus ) ) {

        //
        //  Write the event
        //
        NtStatus = NtWriteFile(
                        Handle,
                        NULL,
                        NULL,
                        NULL,
                        &IoStatusBlock,
                        &ClientEvent,
                        sizeof(ClientEvent),
                        NULL,
                        NULL
                        );

        if ( NtStatus == STATUS_PENDING ) {
            NtStatus = NtWaitForSingleObject(
                            Handle,
                            FALSE,
                            NULL );
        }

        if ( NT_SUCCESS( NtStatus ) ) {
#if BIGDBG
            DbgPrint( "    --> Client Notified, Event 0x%x\n", ClientEvent );
#endif
            Error = ERROR_SUCCESS;
        } else {
            Error = RtlNtStatusToDosError( NtStatus );
        }


        //
        //  Close our side of the pipe
        //
        NtStatus = NtClose( Handle );
        ASSERT( NT_SUCCESS( NtStatus ) );

    } else {

        //
        //  If we couldn't open the pipe because the pipe does
        //  not exist, there's no point in keep trying.
        //
        if ( NtStatus == STATUS_OBJECT_NAME_NOT_FOUND ) {
            Error = ERROR_SUCCESS;
        } else {
            Error = RtlNtStatusToDosError( NtStatus );
#if DBG
            DbgPrint( "WINREG: Cannot Open pipe %Z, event %x, status %x\n",
                  &(PipeEntry->PipeName), ClientEvent, NtStatus );
#endif
        }
    }

#if DBG
    if (Error != ERROR_SUCCESS ) {
        DbgPrint( "WINREG: Could not notify client, Error %d\n", Error );
    }
#endif

    return Error;
}


#if BIGDBG

// *****************************************************************
//
//                      Debug Stuff
//
// *****************************************************************


VOID
DumpNotificationLists(
    )
/*++

Routine Description:

    Dumps the notification lists

Arguments:


    None

Return Value:

    None

--*/

{
    PNOTIFICATION_LIST  NotificationList;
    PNOTIFICATION_ENTRY Event;
    DWORD               Index;

    DbgPrint( "        Notification list dump: \n\n" );

    for ( NotificationList = NotificationListChainHead;
          NotificationList;
          NotificationList = NotificationList->Next ) {

        DbgPrint( "        Notification List at 0x%x\n", NotificationList );
        DbgPrint( "        Pending notifications: %d\n", NotificationList->PendingNotifications );

        Event = &(NotificationList->Event[1]);

        for ( Index = 1; Index < NotificationList->EventsInUse; Index++ ) {

            DbgPrint( "          Event %d EventHandle 0x%x Client 0x%x",
                            Index,
                            NotificationList->EventHandle[ Index ],
                            Event->ClientEvent );

            if ( Event->Flags & CLIENT_IS_DEAD ) {
                DbgPrint( " (Dead)\n" );
            } else if ( Event->Flags & MUST_NOTIFY ) {
                DbgPrint( " (Notify)\n" );
            } else {
                DbgPrint( "\n" );
            }

            Event++;
        }

        DbgPrint( "\n");
    }

    DbgPrint( "\n");
}


VOID
DumpPipeTable(
    )
/*++

Routine Description:

    Dumps the pipe table

Arguments:


    None

Return Value:

    None

--*/

{
    DWORD       i;
    PPIPE_ENTRY Entry;

    DbgPrint( "\n\n      Pipes:\n\n" );

    for ( i=0; i < BUCKETS_IN_SYMBOL_TABLE; i++ ) {

        Entry = PipeSymbolTable.Bucket[i];
        if ( Entry ) {
            DbgPrint( "        Bucket %d:\n",i );
            while ( Entry ) {
                DbgPrint( "        %Z (%d)\n", &(Entry->PipeName), Entry->ReferenceCount );
                Entry = Entry->Next;
            }
        }
    }

    DbgPrint( "\n" );
}


#endif  // BIGDBG

#endif   // REMOTE_NOTIFICATION_DISABLED