/*++

Copyright (c) 1991  Microsoft Corporation

Module Name:

    tcpip\ip\mcastini.c

Abstract:

    Initialization for IP Multicasting

Author:

    Amritansh Raghav

Revision History:

    AmritanR    Created

Notes:

--*/

#include "precomp.h"

#if IPMCAST
#define __FILE_SIG__    INI_SIG

#include "ipmcast.h"
#include "ipmcstxt.h"
#include "mcastioc.h"
#include "mcastmfe.h"

//
// Storage for extern declarations
//

//#pragma data_seg("PAGE")

LIST_ENTRY g_lePendingNotification;
LIST_ENTRY g_lePendingIrpQueue;
GROUP_ENTRY g_rgGroupTable[GROUP_TABLE_SIZE];

NPAGED_LOOKASIDE_LIST g_llGroupBlocks;
NPAGED_LOOKASIDE_LIST g_llSourceBlocks;
NPAGED_LOOKASIDE_LIST g_llOifBlocks;
NPAGED_LOOKASIDE_LIST g_llMsgBlocks;

PVOID g_pvCodeSectionHandle, g_pvDataSectionHandle;

KTIMER g_ktTimer;
KDPC g_kdTimerDpc;
DWORD g_ulNextHashIndex;

DWORD g_dwMcastState;
DWORD g_dwNumThreads;
LONG g_lNumOpens;
KEVENT g_keStateEvent;
FAST_MUTEX  g_StartStopMutex;
RT_LOCK g_rlStateLock;

//#pragma data_seg()

//
// Forward declarations of functions
//

BOOLEAN
SetupExternalName(
    PUNICODE_STRING pusNtName,
    BOOLEAN bCreate
    );

NTSTATUS
InitializeMcastData(
    VOID
    );

NTSTATUS
InitializeIpMcast(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath,
    OUT PDEVICE_OBJECT * ppIpMcastDevice
    );

NTSTATUS
IpMcastDispatch(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

NTSTATUS
StartDriver(
    VOID
    );

NTSTATUS
StopDriver(
    VOID
    );

VOID
McastTimerRoutine(
    PKDPC Dpc,
    PVOID DeferredContext,
    PVOID SystemArgument1,
    PVOID SystemArgument2
    );

NTSTATUS
OpenRegKeyEx(
    OUT PHANDLE phHandle,
    IN PUNICODE_STRING pusKeyName
    );

NTSTATUS
GetRegDWORDValue(
    HANDLE KeyHandle,
    PWCHAR ValueName,
    PULONG ValueData
    );

BOOLEAN
EnterDriverCode(
    IN  DWORD   dwIoCode
    );

VOID
ExitDriverCode(
    IN  DWORD   dwIoCode
    );

//////////////////////////////////////////////////////////////////////////////
//                                                                          //
// Routines                                                                 //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////

//
// The code is only called on initialization
//

#pragma alloc_text(INIT, InitializeIpMcast)

NTSTATUS
InitializeIpMcast(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath,
    OUT PDEVICE_OBJECT * ppIpMcastDevice
    )

/*++

Routine Description:

    Reads the registry value for multicast forwarding. If enabled,
    creates the IPMcast device object.  Does other MCast specific
    initialization

Locks:

Arguments:

    pIpMcastDevice  Pointer to created device

Return Value:

    STATUS_SUCCESS or an error status

--*/

{
    UNICODE_STRING usDeviceName, usParamString, usTempString;
    NTSTATUS nStatus;
    HANDLE hRegKey;
    DWORD dwMcastEnable, dwVal;
    USHORT usRegLen;
    PWCHAR pwcBuffer;

    RtInitializeDebug();

    usRegLen = RegistryPath->Length +
        (sizeof(WCHAR) * (wcslen(L"\\Parameters") + 2));

    //
    // use a random tag
    //

    pwcBuffer = ExAllocatePoolWithTag(NonPagedPool,
                                      usRegLen,
                                      MSG_TAG);

    if(pwcBuffer is NULL)
    {

        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlZeroMemory(pwcBuffer,
                  usRegLen);

    usParamString.MaximumLength = usRegLen;
    usParamString.Buffer = pwcBuffer;

    RtlCopyUnicodeString(&usParamString,
                         RegistryPath);

    RtlInitUnicodeString(&usTempString,
                         L"\\Parameters");

    RtlAppendUnicodeStringToString(&usParamString,
                                   &usTempString);

    nStatus = OpenRegKeyEx(&hRegKey,
                           &usParamString);

    ExFreePool(pwcBuffer);

    if(nStatus is STATUS_SUCCESS)
    {
#if RT_TRACE_DEBUG

        nStatus = GetRegDWORDValue(hRegKey,
                                   L"DebugLevel",
                                   &dwVal);

        if(nStatus is STATUS_SUCCESS)
        {
            g_byDebugLevel = (BYTE) dwVal;
        }
        nStatus = GetRegDWORDValue(hRegKey,
                                   L"DebugComp",
                                   &dwVal);

        if(nStatus is STATUS_SUCCESS)
        {
            g_fDebugComp = dwVal;
        }
#endif

#if DBG
        nStatus = GetRegDWORDValue(hRegKey,
                                   L"DebugBreak",
                                   &dwVal);

        if((nStatus is STATUS_SUCCESS) and
           (dwVal is 1))
        {
            DbgBreakPoint();
        }
#endif

        ZwClose(hRegKey);
    }

    TraceEnter(GLOBAL, "InitializeIpMcast");

    //
    // Read the value for multicast forwarding
    //

    //
    // The g_dwMcastStart controls whether any forwarding actually happens
    // It gets set to 1 one an NtCreateFile is done on the Multicast Device.
    // It gets reset when the handle is closed
    //

    g_dwMcastState = MCAST_STOPPED;
    g_dwNumThreads = 0;
    g_lNumOpens = 0;

    //
    // Handles to code and data sections
    //

    g_pvCodeSectionHandle = NULL;
    g_pvDataSectionHandle = NULL;

    //
    // Used for the timer routine. Tells the DPC which index to start in in the
    // group hash table
    //

    g_ulNextHashIndex = 0;

    //
    // Create the device
    //

    RtlInitUnicodeString(&usDeviceName,
                         DD_IPMCAST_DEVICE_NAME);

    nStatus = IoCreateDevice(DriverObject,
                             0,
                             &usDeviceName,
                             FILE_DEVICE_NETWORK,
                             FILE_DEVICE_SECURE_OPEN,
                             FALSE,
                             ppIpMcastDevice);

    if(!NT_SUCCESS(nStatus))
    {
        Trace(GLOBAL, ERROR,
              ("InitializeIpMcast: IP initialization failed: Unable to create device object %ws, status %lx.\n",
               DD_IPMCAST_DEVICE_NAME,
               nStatus));

        TraceLeave(GLOBAL, "InitializeIpMcast");

        return nStatus;
    }

    //
    // Create a symbolic link in Dos Space
    //

    if(!SetupExternalName(&usDeviceName, TRUE))
    {
        Trace(GLOBAL, ERROR,
              ("InitializeIpMcast: Win32 device name could not be created\n"));

        IoDeleteDevice(*ppIpMcastDevice);

        TraceLeave(GLOBAL, "InitializeIpMcast");

        return STATUS_UNSUCCESSFUL;
    }

    RtInitializeSpinLock(&g_rlStateLock);

    KeInitializeEvent(&(g_keStateEvent),
                      SynchronizationEvent,
                      FALSE);

    ExInitializeFastMutex(&g_StartStopMutex);

    return STATUS_SUCCESS;
}

VOID
DeinitializeIpMcast(
    IN  PDEVICE_OBJECT DeviceObject
    )
{
    StopDriver();

    IoDeleteDevice(DeviceObject);
}

#pragma alloc_text(PAGE, SetupExternalName)

BOOLEAN
SetupExternalName(
    PUNICODE_STRING pusNtName,
    BOOLEAN bCreate
    )
{
    UNICODE_STRING usSymbolicLinkName;
    WCHAR rgwcBuffer[100];

    PAGED_CODE();

    //
    // Form the full symbolic link name we wish to create.
    //

    usSymbolicLinkName.Buffer = rgwcBuffer;

    RtlInitUnicodeString(&usSymbolicLinkName,
                         WIN32_IPMCAST_SYMBOLIC_LINK);

    if(bCreate)
    {
        if(!NT_SUCCESS(IoCreateSymbolicLink(&usSymbolicLinkName,
                                             pusNtName)))
        {
            return FALSE;
        }

    }
    else
    {
        IoDeleteSymbolicLink(&usSymbolicLinkName);
    }

    return TRUE;
}

#pragma alloc_text(PAGE, InitializeMcastData)

NTSTATUS
InitializeMcastData(
    VOID
    )
{
    LARGE_INTEGER liDueTime;
    ULONG ulCnt;
    NTSTATUS nStatus;

    if(g_pvCodeSectionHandle)
    {
        MmLockPagableSectionByHandle(g_pvCodeSectionHandle);
    }else
    {
        g_pvCodeSectionHandle = MmLockPagableCodeSection(McastTimerRoutine);

        if(g_pvCodeSectionHandle is NULL)
        {
            RtAssert(FALSE);
        }
    }

    for(ulCnt = 0; ulCnt < GROUP_TABLE_SIZE; ulCnt++)
    {
        InitializeListHead(&(g_rgGroupTable[ulCnt].leHashHead));
        InitRwLock(&(g_rgGroupTable[ulCnt].rwlLock));

#if DBG
        g_rgGroupTable[ulCnt].ulGroupCount = 0;
        g_rgGroupTable[ulCnt].ulCacheHits = 0;
        g_rgGroupTable[ulCnt].ulCacheMisses = 0;
#endif

        g_rgGroupTable[ulCnt].pGroup = NULL;
    }

    InitializeListHead(&g_lePendingNotification);
    InitializeListHead(&g_lePendingIrpQueue);

    ExInitializeNPagedLookasideList(&g_llGroupBlocks,
                                    NULL,
                                    NULL,
                                    0,
                                    sizeof(GROUP),
                                    GROUP_TAG,
                                    GROUP_LOOKASIDE_DEPTH);

    ExInitializeNPagedLookasideList(&g_llSourceBlocks,
                                    NULL,
                                    NULL,
                                    0,
                                    sizeof(SOURCE),
                                    SOURCE_TAG,
                                    SOURCE_LOOKASIDE_DEPTH);

    ExInitializeNPagedLookasideList(&g_llOifBlocks,
                                    NULL,
                                    NULL,
                                    0,
                                    sizeof(OUT_IF),
                                    OIF_TAG,
                                    OIF_LOOKASIDE_DEPTH);

    ExInitializeNPagedLookasideList(&g_llMsgBlocks,
                                    NULL,
                                    NULL,
                                    0,
                                    sizeof(NOTIFICATION_MSG),
                                    MSG_TAG,
                                    MSG_LOOKASIDE_DEPTH);

    KeInitializeDpc(&g_kdTimerDpc,
                    McastTimerRoutine,
                    NULL);

    KeInitializeTimer(&g_ktTimer);

    liDueTime = RtlEnlargedUnsignedMultiply(TIMER_IN_MILLISECS,
                                            SYS_UNITS_IN_ONE_MILLISEC);

    liDueTime = RtlLargeIntegerNegate(liDueTime);

    KeSetTimerEx(&g_ktTimer,
                 liDueTime,
                 0,
                 &g_kdTimerDpc);

    return STATUS_SUCCESS;
}

#pragma alloc_text(PAGE, IpMcastDispatch)

NTSTATUS
IpMcastDispatch(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

    The functions which handles the IRPs sent to the driver
    The IOCTLS are further dispatched using a function table

    THIS CODE IS PAGEABLE so it CAN NOT ACQUIRE ANY LOCKS

Locks:

    Must be at passive

Arguments:

Return Value:

    NO_ERROR

--*/

{
    PIO_STACK_LOCATION irpStack;
    ULONG ulInputBuffLen;
    ULONG ulOutputBuffLen;
    ULONG ioControlCode;
    NTSTATUS ntStatus;
    KIRQL kiIrql;
    BOOLEAN bEnter;

    UNREFERENCED_PARAMETER(DeviceObject);

    PAGED_CODE();

    TraceEnter(GLOBAL, "IpMcastDispatch");

    Irp->IoStatus.Information = 0;

    //
    // Get a pointer to the current location in the Irp. This is where
    // the function codes and parameters are located.
    //

    irpStack = IoGetCurrentIrpStackLocation(Irp);

    //
    // Get the pointer to the input/output buffer and it's length
    //

    ulInputBuffLen = irpStack->Parameters.DeviceIoControl.InputBufferLength;
    ulOutputBuffLen = irpStack->Parameters.DeviceIoControl.OutputBufferLength;

    switch (irpStack->MajorFunction)
    {
        case IRP_MJ_CREATE:
        {
            Trace(GLOBAL, TRACE,
                  ("IpMcastDispatch: IRP_MJ_CREATE\n"));

            //
            // Make sure that the user is not attempting to sneak around the
            // security checks. Make sure that FileObject->RelatedFileObject is
            // NULL and that the FileName length is zero!
            //

            if((irpStack->FileObject->RelatedFileObject isnot NULL) or
               (irpStack->FileObject->FileName.Length isnot 0))
            {
                ntStatus = STATUS_ACCESS_DENIED;

                break;
            }

            InterlockedIncrement(&g_lNumOpens);

            ntStatus = STATUS_SUCCESS;

            break;
        }

        case IRP_MJ_CLOSE:
        {
            Trace(GLOBAL, TRACE,
                  ("IpMcastDispatch: IRP_MJ_CLOSE\n"));

            ntStatus = STATUS_SUCCESS;

            break;
        }

        case IRP_MJ_CLEANUP:
        {
            Trace(GLOBAL, TRACE,
                  ("IpMcastDispatch: IRP_MJ_CLEANUP\n"));

            if((InterlockedDecrement(&g_lNumOpens) is 0) and
               (g_dwMcastState isnot MCAST_STOPPED))
            {
                StopDriver();
            }
            ntStatus = STATUS_SUCCESS;

            break;
        }

        case IRP_MJ_DEVICE_CONTROL:
        {
            DWORD dwState;
            ULONG ulControl;

            //
            // The assumption is that IOCTL_IPMCAST_START_STOP will be
            // serialized wrt to 2 calls, i.e we wont get a stop when a start
            // is in progress and we will not get a start when a stop has been
            // issued. No assumption is made about IOCTL_IPMCAST_START_STOP's
            // serialization with other IRPS.
            // So when we are in this code we assume that we wont get
            // a close beneath us
            //

            ioControlCode = irpStack->Parameters.DeviceIoControl.IoControlCode;
            ulControl = IoGetFunctionCodeFromCtlCode(ioControlCode);

            bEnter = EnterDriverCode(ioControlCode);

            if(!bEnter)
            {
                // keep devioctl testers happy
                KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,
                      "IpMcastDispatch: Driver is not started\n"));

                ntStatus = STATUS_NO_SUCH_DEVICE;

                break;
            }

            switch (ioControlCode)
            {
                case IOCTL_IPMCAST_SET_MFE:
                {
                    ntStatus = SetMfe(Irp,
                                      ulInputBuffLen,
                                      ulOutputBuffLen);

                    break;
                }

                case IOCTL_IPMCAST_GET_MFE:
                {
                    ntStatus = GetMfe(Irp,
                                      ulInputBuffLen,
                                      ulOutputBuffLen);

                    break;
                }

                case IOCTL_IPMCAST_DELETE_MFE:
                {
                    ntStatus = DeleteMfe(Irp,
                                         ulInputBuffLen,
                                         ulOutputBuffLen);

                    break;
                }

                case IOCTL_IPMCAST_SET_TTL:
                {
                    ntStatus = SetTtl(Irp,
                                      ulInputBuffLen,
                                      ulOutputBuffLen);

                    break;
                }

                case IOCTL_IPMCAST_GET_TTL:
                {
                    ntStatus = GetTtl(Irp,
                                      ulInputBuffLen,
                                      ulOutputBuffLen);

                    break;
                }

                case IOCTL_IPMCAST_POST_NOTIFICATION:
                {
                    ntStatus = ProcessNotification(Irp,
                                                   ulInputBuffLen,
                                                   ulOutputBuffLen);

                    break;
                }

                case IOCTL_IPMCAST_START_STOP:
                {
                    ntStatus = StartStopDriver(Irp,
                                               ulInputBuffLen,
                                               ulOutputBuffLen);

                    break;
                }

                case IOCTL_IPMCAST_SET_IF_STATE:
                {
                    ntStatus = SetIfState(Irp,
                                          ulInputBuffLen,
                                          ulOutputBuffLen);

                    break;
                }

                default:
                {
                    // Keep devioctl testers happy
                    KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,
                          "IpMcastDispatch: unknown IRP_MJ_DEVICE_CONTROL - 0x%X which evaluates to a code of %d\n",
                           ioControlCode, ulControl));

                    ntStatus = STATUS_INVALID_PARAMETER;

                    break;
                }
            }

            ExitDriverCode(ioControlCode);

            break;
        }

        default:
        {
            Trace(GLOBAL, ERROR,
                  ("IpMcastDispatch: unknown IRP_MJ_XX - %x\n",
                   irpStack->MajorFunction));

            ntStatus = STATUS_INVALID_PARAMETER;

            break;
        }
    }

    //
    // Fill in status into IRP
    //

    //
    // This bit commented out because we cant touch the irp since it
    // may have been completed
    //
    // Trace(GLOBAL, INFO,
    //       ("IpMcastDispatch: Returning status %x info %d\n",
    //        ntStatus, Irp->IoStatus.Information));

    if(ntStatus isnot STATUS_PENDING)
    {
        Irp->IoStatus.Status = ntStatus;

        IoCompleteRequest(Irp, IO_NETWORK_INCREMENT);
    }

    TraceLeave(GLOBAL, "IpMcastDispatch");

    return ntStatus;
}

NTSTATUS
StartDriver(
    VOID
    )
{
    KIRQL   irql;

    TraceEnter(GLOBAL, "StartDriver");

    RtAcquireSpinLock(&g_rlStateLock,
                      &irql);

    if(g_dwMcastState is MCAST_STARTED)
    {
        RtReleaseSpinLock(&g_rlStateLock,
                          irql);

        return STATUS_SUCCESS;
    }

    RtReleaseSpinLock(&g_rlStateLock,
                      irql);

    InitializeMcastData();

    g_dwMcastState = MCAST_STARTED;

    TraceLeave(GLOBAL, "StartDriver");

    return STATUS_SUCCESS;
}

//
// MUST BE PAGED IN
//

#pragma alloc_text(PAGEIPMc, StopDriver)

NTSTATUS
StopDriver(
    VOID
    )
{
    DWORD i;
    KIRQL irql;
    PLIST_ENTRY pleGrpNode, pleSrcNode;
    PGROUP pGroup;
    PSOURCE pSource;
    BOOLEAN bWait;
    NTSTATUS nStatus;

    TraceEnter(GLOBAL, "StopDriver");

    //
    // Set the state to  STOPPING
    //

    RtAcquireSpinLock(&g_rlStateLock,
                      &irql);

    if(g_dwMcastState isnot MCAST_STARTED)
    {
        Trace(GLOBAL, ERROR,
              ("StopDriver: Called when state is %d\n", g_dwMcastState));

        // RtAssert(FALSE);

        RtReleaseSpinLock(&g_rlStateLock,
                          irql);

        TraceLeave(GLOBAL, "StopDriver");

        return STATUS_SUCCESS;
    }
    else
    {
        g_dwMcastState = MCAST_STOPPED;
    }

    RtReleaseSpinLock(&g_rlStateLock,
                      irql);

    //
    // First of all, kill the timer
    //

    i = 0;

    while(KeCancelTimer(&g_ktTimer) is FALSE)
    {
        LARGE_INTEGER liTimeOut;

        //
        // Hmm, timer was not in the system queue.
        // Set the wait to 2, 4, 6... secs
        //

        liTimeOut.QuadPart = (LONGLONG) ((i + 1) * 2 * 1000 * 1000 * 10 * -1);

        KeDelayExecutionThread(UserMode,
                               FALSE,
                               &liTimeOut);

        i++;
    }

    //
    // Delete all the (S,G) entries
    //

    for(i = 0; i < GROUP_TABLE_SIZE; i++)
    {
        //
        // Lock out the bucket
        //

        EnterWriter(&g_rgGroupTable[i].rwlLock,
                    &irql);

        pleGrpNode = g_rgGroupTable[i].leHashHead.Flink;

        while(pleGrpNode isnot & (g_rgGroupTable[i].leHashHead))
        {
            pGroup = CONTAINING_RECORD(pleGrpNode, GROUP, leHashLink);

            pleGrpNode = pleGrpNode->Flink;

            pleSrcNode = pGroup->leSrcHead.Flink;

            while(pleSrcNode isnot & pGroup->leSrcHead)
            {
                pSource = CONTAINING_RECORD(pleSrcNode, SOURCE, leGroupLink);

                pleSrcNode = pleSrcNode->Flink;

                //
                // Ref and lock the source, since we need to pass it that
                // way to RemoveSource
                //

                ReferenceSource(pSource);

                RtAcquireSpinLockAtDpcLevel(&(pSource->mlLock));

                RemoveSource(pGroup->dwGroup,
                             pSource->dwSource,
                             pSource->dwSrcMask,
                             pGroup,
                             pSource);
            }
        }

        ExitWriter(&g_rgGroupTable[i].rwlLock,
                   irql);
    }

    //
    // Complete any pendying IRP
    //

    ClearPendingIrps();

    //
    // Free any pending messages
    //

    ClearPendingNotifications();

    //
    // Wait for everyone to leave the code
    //

    RtAcquireSpinLock(&g_rlStateLock,
                      &irql);

    //
    // Need to wait if the number of threads isnot 0
    //

    bWait = (g_dwNumThreads isnot 0);

    RtReleaseSpinLock(&g_rlStateLock,
                      irql);

    if(bWait)
    {
        nStatus = KeWaitForSingleObject(&g_keStateEvent,
                                        Executive,
                                        KernelMode,
                                        FALSE,
                                        NULL);

        RtAssert(nStatus is STATUS_SUCCESS);
    }

    //
    // Clear out the last of the data structures
    //

    ExDeleteNPagedLookasideList(&g_llGroupBlocks);

    ExDeleteNPagedLookasideList(&g_llSourceBlocks);

    ExDeleteNPagedLookasideList(&g_llOifBlocks);

    ExDeleteNPagedLookasideList(&g_llMsgBlocks);

    //
    // Page out the code and data
    //

    MmUnlockPagableImageSection(g_pvCodeSectionHandle);

    g_pvCodeSectionHandle = NULL;

    //MmUnlockPagableImageSection(g_pvDataSectionHandle);

    g_pvDataSectionHandle = NULL;

    TraceLeave(GLOBAL, "StopDriver");

    return STATUS_SUCCESS;
}

BOOLEAN
EnterDriverCode(
    DWORD dwIoCode
    )
{
    KIRQL irql;
    BOOLEAN bEnter;

    RtAcquireSpinLock(&g_rlStateLock,
                      &irql);

    if((g_dwMcastState is MCAST_STARTED) or
       (dwIoCode is IOCTL_IPMCAST_START_STOP))
    {
        g_dwNumThreads++;

        bEnter = TRUE;

    }
    else
    {

        bEnter = FALSE;
    }

    RtReleaseSpinLock(&g_rlStateLock,
                      irql);

    if(dwIoCode is IOCTL_IPMCAST_START_STOP)
    {
        ExAcquireFastMutex(&g_StartStopMutex);
    }

    return bEnter;
}

VOID
ExitDriverCode(
    DWORD dwIoCode
    )
{
    KIRQL irql;

    RtAcquireSpinLock(&g_rlStateLock,
                      &irql);

    g_dwNumThreads--;

    if((g_dwMcastState is MCAST_STOPPED) and
       (g_dwNumThreads is 0))
    {

        KeSetEvent(&g_keStateEvent,
                   0,
                   FALSE);
    }

    RtReleaseSpinLock(&g_rlStateLock,
                      irql);

    if(dwIoCode is IOCTL_IPMCAST_START_STOP)
    {
        ExReleaseFastMutex(&g_StartStopMutex);
    }

}

#pragma alloc_text(PAGE, OpenRegKeyEx)

NTSTATUS
OpenRegKeyEx(
    OUT PHANDLE phHandle,
    IN PUNICODE_STRING pusKeyName
    )
{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;

    PAGED_CODE();

    RtlZeroMemory(&ObjectAttributes,
                  sizeof(OBJECT_ATTRIBUTES));

    InitializeObjectAttributes(&ObjectAttributes,
                               pusKeyName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);

    Status = ZwOpenKey(phHandle,
                       KEY_READ,
                       &ObjectAttributes);

    return Status;
}

#endif // IPMCAST