windows-xp/Source/XPSP1/NT/net/rras/ip/ipinip/driver.c

/*++

Copyright (c) 1995  Microsoft Corporation

Module Name:

    net\ip\ipinip\driver.c

Abstract:

    IP in IP driver shell

Revision History:

    Gurdeep Singh Pall          8/2/95  Created

--*/

#define __FILE_SIG__    DRIVER_SIG

#include "inc.h"

#pragma alloc_text(INIT, DriverEntry)

NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT  DriverObject,
    IN PUNICODE_STRING RegistryPath
    )

/*++

Routine Description

    Installable driver initialization entry point.
    This entry point is called directly by the I/O system and must be named
    "Driver Entry"
    The function is discardable since it is only called once
    On checked builds we read some values from registry and initialize the
    debugging
    We create a DEVICE_OBJECT for ourselves to field the IOCTLs, create 
    a DOS name for the device and initialize some events and spinlocks

Locks 

    None

Arguments

    DriverObject    Pointer to I/O subsystem created driver object
    RegistryPath    Points to driver key in HKLM\CCS\Services...

Return Value

    STATUS_SUCCESS  if everything went as planned or some status code from
                    ntstatus.h

--*/

{
    NTSTATUS        nStatus;
    PDEVICE_OBJECT  pDeviceObject;
    UNICODE_STRING  usDeviceName;
    DWORD           dwVal, i;
    HANDLE          hRegKey;

    WCHAR           ParametersRegistryPath[] =
        L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\IpInIp\\Parameters";

    RtInitializeDebug();

    //
    // Read the registry for parameters
    //

    nStatus = OpenRegKey(&hRegKey,
                         ParametersRegistryPath);

    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, "DriverEntry");

    //
    // Initialize some globals
    //
    
    g_dwDriverState = DRIVER_STOPPED;
    g_ulNumThreads  = 0;
    g_ulNumOpens    = 0;

    g_hIpRegistration = NULL;

    //
    // Create the device
    //

    RtlInitUnicodeString(&usDeviceName,
                         DD_IPINIP_DEVICE_NAME);

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

    if (!NT_SUCCESS(nStatus))
    {
        Trace(GLOBAL, ERROR,
              ("DriverEntry: Cant create device object %ws, status %lx.\n",
               DD_IPINIP_DEVICE_NAME,
               nStatus));

        TraceLeave(GLOBAL, "DriverEntry");

        return nStatus;
    }

    //
    // Initialize the driver object
    //

    DriverObject->DriverUnload   = IpIpUnload;
    DriverObject->FastIoDispatch = NULL;

    for(i=0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
    {
        DriverObject->MajorFunction[i] = IpIpDispatch;
    }


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

        IoDeleteDevice(pDeviceObject);

        TraceLeave(GLOBAL, "DriverEntry");

        return  STATUS_UNSUCCESSFUL;
    }

    //
    // Lock and event needed to keep track of threads in the driver
    //

    RtInitializeSpinLock(&g_rlStateLock);

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

    //
    // Many threads may be waiting for us to start so this needs to be a
    // NotificationEvent
    //

    KeInitializeEvent(&(g_keStartEvent),
                      NotificationEvent,
                      FALSE);

    InitRwLock(&g_rwlTunnelLock);

    InitializeListHead(&g_leTunnelList);

    InitializeListHead(&g_lePendingMessageList);
    InitializeListHead(&g_lePendingIrpList);

    //
    // Register with IP
    //

    nStatus = RegisterWithIp();

    if(nStatus isnot STATUS_SUCCESS)
    {
        Trace(GLOBAL, ERROR,
              ("DriverEntry: RegisterWithIP failed\n"));

        IoDeleteDevice(pDeviceObject);

        TraceLeave(GLOBAL, "InitializeDriver");

        return FALSE;
    }

    g_pIpIpDevice = pDeviceObject;

    TraceLeave(GLOBAL, "DriverEntry");

    return nStatus;
}



#pragma alloc_text(PAGE, IpIpDispatch)

NTSTATUS
IpIpDispatch(
    IN PDEVICE_OBJECT    DeviceObject,
    IN PIRP              Irp
    )

/*++

Routine Description

    The functions which handles the IRPs sent to the driver

Locks

    This code is PAGEABLE so can not acquire locks
 
Arguments
      

Return Value

    STATUS_SUCCESS 

--*/

{
    PIO_STACK_LOCATION	irpStack;
    ULONG		        ulInputBuffLen;
    ULONG		        ulOutputBuffLen;
    ULONG		        ioControlCode;
    NTSTATUS	        nStatus;
    KIRQL               kiIrql;
    LARGE_INTEGER       liTimeOut;
    BOOLEAN             bEnter;
    
    
    PAGED_CODE();
 
    TraceEnter(GLOBAL, "IpIpDispatch");

    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,
                  ("IpIpDispatch: IRP_MJ_CREATE\n"));

            //
            // We start the driver when the first CreateFile is done
            // But we need to serialize the Creates
            //

            nStatus = StartDriver();
        
            if(nStatus is STATUS_PENDING)
            {
                //
                // Means someone is trying to start the driver
                // We wait for some time (since we are at PASSIVE)
                //

                liTimeOut.QuadPart = START_TIMEOUT;
                
                nStatus = KeWaitForSingleObject(&g_keStartEvent,
                                                UserRequest,
                                                KernelMode,
                                                FALSE,
                                                &liTimeOut);
                
                if(nStatus isnot STATUS_SUCCESS)
                {
                    //
                    // We timed out - bad things are happening here
                    //
                    
                    Trace(GLOBAL, ERROR,
                          ("IpIpDispatch: Timeout trying to start driver\n"));

                    nStatus = STATUS_UNSUCCESSFUL;
                }
                else
                { 
                    //
                    // Make sure the driver actually started
                    //

                    bEnter = EnterDriverCode();

                    ExitDriverCode();

                    if(!bEnter)
                    {
                        Trace(GLOBAL, ERROR,
                              ("IpIpDispatch: Wait successful, but unable to start driver\n"));

                        nStatus = STATUS_UNSUCCESSFUL;
                    }
                }

            }                    

            break;
        }

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

            //
            // We handle cleanup and not close
            //
            
            nStatus = STATUS_SUCCESS;

            break;
        }
        
        case IRP_MJ_CLEANUP:
        {
            Trace(GLOBAL, TRACE,
                  ("IpIpDispatch: IRP_MJ_CLEANUP\n"));

            StopDriver();

            nStatus = STATUS_SUCCESS;
            
            break;
        }

        case IRP_MJ_DEVICE_CONTROL:
        {
            DWORD   dwState;
            ULONG   ulControl;

            //
            // Get the control code and our code
            //
            
            ioControlCode = irpStack->Parameters.DeviceIoControl.IoControlCode;
            
            //
            // If the driver is stopping, dont process anything else
            //
            
            bEnter =  EnterDriverCode();
            
            if(!bEnter)
            {
                Trace(GLOBAL, ERROR,
                      ("IpIpDispatch: Driver is not started\n"));
                
                nStatus = STATUS_NO_SUCH_DEVICE;
                
                break;
            }
            
            switch(ioControlCode)
            {
                case IOCTL_IPINIP_CREATE_TUNNEL:
                {
                    nStatus = AddTunnelInterface(Irp,
                                                 ulInputBuffLen,
                                                 ulOutputBuffLen);
                    
                    break;
                }

                case IOCTL_IPINIP_DELETE_TUNNEL:
                {
                    nStatus = DeleteTunnelInterface(Irp,
                                                    ulInputBuffLen,
                                                    ulOutputBuffLen);
                    
                    break;
                }

                case IOCTL_IPINIP_SET_TUNNEL_INFO:
                {
                    nStatus = SetTunnelInfo(Irp,
                                            ulInputBuffLen,
                                            ulOutputBuffLen);
                    
                    break;
                }
                
                case IOCTL_IPINIP_GET_TUNNEL_TABLE:
                {
                    nStatus = GetTunnelTable(Irp,
                                             ulInputBuffLen,
                                             ulOutputBuffLen);
                    
                    break;
                }
               
                case IOCTL_IPINIP_NOTIFICATION:
                {
                    nStatus = ProcessNotification(Irp,
                                                  ulInputBuffLen,
                                                  ulOutputBuffLen);

                    break;
                }
 
                default:
                {
                    Trace(GLOBAL, ERROR,
                          ("IpIpDispatch: Unknown IRP_MJ_DEVICE_CONTROL %x\n",
                           ioControlCode));
                
                    nStatus = STATUS_INVALID_PARAMETER;
                }
            }        

            ExitDriverCode();
            
            break;
        }

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

            nStatus = STATUS_INVALID_PARAMETER;

            break;
        }
    }

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

        IoCompleteRequest(Irp,
                          IO_NETWORK_INCREMENT);
    }

    TraceLeave(GLOBAL, "IpIpDispatch");

    return nStatus;
}


VOID
IpIpUnload(
    PDRIVER_OBJECT DriverObject
    )

/*++

Routine Description

    Called by the I/O subsystem, when our driver is being unloaded
    
Locks


Arguments


Return Value

    None

--*/

{
    UNICODE_STRING  usDeviceName;
    BOOLEAN         bWait;
    KIRQL           kiIrql;
    NDIS_STATUS     nsStatus;
    NTSTATUS        nStatus;

    TraceEnter(GLOBAL,"IpIpUnload");

    //
    // The driver must have stopped before it came here
    //

    RtAssert(g_dwDriverState is DRIVER_STOPPED);

    RemoveAllTunnels();

    //
    // Clear out IP's state
    //
    
    DeregisterWithIp();

    //
    // Remove ourself from NT and DOS namespace
    //
    
    RtlInitUnicodeString(&usDeviceName,
                         DD_IPINIP_DEVICE_NAME);

    SetupExternalName(&usDeviceName, 
                      WIN32_IPINIP_SYMBOLIC_LINK,
                      FALSE);


    //
    // Clean out address blocks, if any
    //

    while(!IsListEmpty(&g_leAddressList))
    {
        PADDRESS_BLOCK  pAddrBlock;
        PLIST_ENTRY     pleNode;

        pleNode = RemoveHeadList(&g_leAddressList);

        pAddrBlock = CONTAINING_RECORD(pleNode,
                                       ADDRESS_BLOCK,
                                       leAddressLink);

        RtFree(pAddrBlock);
    }

    //
    // See if we have any free memory
    //

    RtAuditMemory();
    
    //
    // Delete the device object
    //
    
    IoDeleteDevice(DriverObject->DeviceObject);

    TraceLeave(GLOBAL,"IpIpUnload");
}

#pragma alloc_text(PAGE, SetupExternalName)

BOOLEAN
SetupExternalName(
    PUNICODE_STRING  pusNtName,
    PWCHAR           pwcDosName,
    BOOLEAN          bCreate
    )

/*++

Routine Description

    Setup or delete a symbolic link to DOS namespace
    
Locks

Arguments

    pusNtName   Name in NT space
    pwcDosName  Name in DOS space
    bCreate     Set to TRUE to create, FALSE to delete
    
Return Value

    TRUE    if successful
    FALSE   otherwise

--*/

{
    UNICODE_STRING  usSymbolicLinkName;
    WCHAR           rgwcBuffer[100];

    PAGED_CODE();

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

    usSymbolicLinkName.Buffer = rgwcBuffer;

    RtlInitUnicodeString(&usSymbolicLinkName,
                         pwcDosName);

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

    return TRUE;
}

NTSTATUS
StartDriver(
    VOID
    )

/*++

Routine Description
      
    Main routine to start the driver. We call this when we get CREATE irp
    If the driver has started, we return success. If someone is starting the
    driver, we return pending. The caller then needs to wait on g_keStartEvent
    We try and start the driver. If all goes well, we set the event and
    everyone parties on from there
    
Locks 

    The function takes the g_rlStateLock to check the state and increment
    the number of CREATEs it has received (open handles)
    
Arguments

    None

Return Value

    STATUS_SUCCESS  if the driver started
    STATUS_PENDING  if the driver is being started by some other thread's

--*/

{
    KIRQL               kiOldIrql;
    NTSTATUS            nStatus;
    DWORD               dwState;
    OPEN_CONTEXT        TdixContext;
    WORK_QUEUE_ITEM     WorkItem;
    KEVENT              keTempEvent;
 
    TraceEnter(GLOBAL, "StartDriver");

    RtAcquireSpinLock(&g_rlStateLock,
                      &kiOldIrql);

    g_ulNumOpens++;

    if(g_ulNumOpens isnot 1)
    {
        if(g_dwDriverState is DRIVER_STARTING)
        {
            //
            // Someone is trying to start the driver
            //

            Trace(GLOBAL, INFO,
                  ("StartDriver: Driver is being started by someone else\n"));

            nStatus = STATUS_PENDING;
        }
        else
        {
            //
            // If we are not the first CreateFile, and the driver is not 
            // starting then the driver must already be running
            //

            RtAssert(g_dwDriverState is DRIVER_STARTED);

            nStatus = STATUS_SUCCESS;
        }

        RtReleaseSpinLock(&g_rlStateLock,
                          kiOldIrql);
    
        return nStatus;
    }

    //
    // The first CreateFile
    //

    RtAssert(g_dwDriverState is DRIVER_STOPPED);

    //
    // Set the state to starting, release the lock and actually start 
    // the driver
    //

    g_dwDriverState = DRIVER_STARTING;

    RtReleaseSpinLock(&g_rlStateLock,
                      kiOldIrql);

    dwState = DRIVER_STARTED;

    //
    // Initialize the event and work item to start TDI
    //

    KeInitializeEvent(&keTempEvent,
                      SynchronizationEvent,
                      FALSE);

    TdixContext.pkeEvent = &keTempEvent;

    ExInitializeWorkItem(&WorkItem,
                         TdixInitialize,
                         &TdixContext);

    //
    // Start TDI in the system context so that we the handles are not
    // associated with the current process
    //

    ExQueueWorkItem(&WorkItem,
                    DelayedWorkQueue);

    //
    // Wait for TDI to get done
    //

   nStatus = KeWaitForSingleObject(TdixContext.pkeEvent,
                                   UserRequest,
                                   KernelMode,
                                   FALSE,
                                   NULL);

    if((nStatus isnot STATUS_SUCCESS) or
       (TdixContext.nStatus isnot STATUS_SUCCESS))
    {
        Trace(GLOBAL, ERROR,
              ("StartDriver: TdixInitialize failed with %x %x\n",
               nStatus, TdixContext.nStatus));

        dwState = DRIVER_STOPPED;
    }
   
    if(dwState is DRIVER_STARTED)
    {
        LARGE_INTEGER   liDueTime;

        KeInitializeDpc(&g_kdTimerDpc,
                        IpIpTimerRoutine,
                        NULL);

        KeInitializeTimer(&g_ktTimer);

        liDueTime = RtlEnlargedUnsignedMultiply(TIMER_IN_MILLISECS,
                                                SYS_UNITS_IN_ONE_MILLISEC);

        liDueTime = RtlLargeIntegerNegate(liDueTime);

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

    RtAcquireSpinLock(&g_rlStateLock,
                      &kiOldIrql);

    g_dwDriverState = dwState;
  
    //
    // Someone may have been waiting for us to start
    //
 
    KeSetEvent(&g_keStartEvent,
               0,
               FALSE); 

    RtReleaseSpinLock(&g_rlStateLock,
                      kiOldIrql);

    TraceLeave(GLOBAL, "StartDriver");

    return nStatus;
}

    
VOID
StopDriver(
    VOID
    )

/*++

Routine Description

    Called when we get an IRP_MJ_CLEANUP. It is the inverse of StartDriver
    If this is the last thread, we set the state to STOPPED and wait till
    all threads of execution have exited the driver.
    We then clean out resources
  
Locks 

    The function takes the g_rlStateLock
    
Arguments
      
    None
    
Return Value

    None
    
--*/
{
    KIRQL           kiOldIrql;
    NTSTATUS        nStatus;
    BOOLEAN         bWait;
    ULONG           i;
    OPEN_CONTEXT    TdixContext;
    WORK_QUEUE_ITEM WorkItem;
    KEVENT          keTempEvent;
    PIO_WORKITEM    pIoWorkItem;
 
    TraceEnter(GLOBAL, "StopDriver");

    //
    // Acquire the state and ref count spin lock
    //
    
    RtAcquireSpinLock(&g_rlStateLock,
                      &kiOldIrql);

    g_ulNumOpens--;

    if(g_ulNumOpens isnot 0)
    {
        //
        // Other people still around
        //

        RtReleaseSpinLock(&g_rlStateLock,
                          kiOldIrql);

        TraceLeave(GLOBAL, "StopDriver");

        return;
    }


    //
    // Set the state to stopping. Any reader will
    // return on seeing this. So essentially we are not
    // allowing any new readers in
    //
    
    g_dwDriverState = DRIVER_STOPPED;

    //
    // However there may already be readers. We wait
    // if there are any
    //
    
    bWait = (g_ulNumThreads > 0);

    RtReleaseSpinLock(&g_rlStateLock,
                      kiOldIrql);

    //
    // Now do a wait. We can do this since we are at PASSIVE
    //

    if(bWait)
    {
        Trace(GLOBAL, INFO,
              ("StopDriver: Need to wait for threads to exit\n"));

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

        }while((nStatus is STATUS_USER_APC) or 
               (nStatus is STATUS_ALERTED) or 
               (nStatus is STATUS_TIMEOUT));
    }

    //
    // Undo 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++;
    }

    //
    // Initialize the event and work item to stop TDI
    //

    KeInitializeEvent(&keTempEvent,
                      SynchronizationEvent,
                      FALSE);

    TdixContext.pkeEvent = &keTempEvent;

    pIoWorkItem = IoAllocateWorkItem(g_pIpIpDevice);

    //
    // Must have a work item - no failure code path
    //

    RtAssert(pIoWorkItem);

    IoQueueWorkItem(pIoWorkItem,
                    TdixDeinitialize,
                    DelayedWorkQueue,
                    &TdixContext);

    //
    // Wait for TDI to get done
    //

    nStatus = KeWaitForSingleObject(TdixContext.pkeEvent,
                                    UserRequest,
                                    KernelMode,
                                    FALSE,
                                    NULL);

    RtAssert(nStatus is STATUS_SUCCESS);

    IoFreeWorkItem(pIoWorkItem);

    //
    // Cleanup all resources
    //
   
    while(!IsListEmpty(&g_lePendingMessageList))
    {
        PLIST_ENTRY         pleNode;
        PPENDING_MESSAGE    pMessage;

        //
        // We have some old info
        // Remove it off the pending list
        //

        pleNode = RemoveHeadList(&g_lePendingMessageList);

        //
        // Get a pointer to the structure
        //

        pMessage = CONTAINING_RECORD(pleNode,
                                     PENDING_MESSAGE,
                                     leMessageLink);

        //
        // Free the allocated message
        //

        FreeMessage(pMessage);
    }

    ClearPendingIrps();
 
    TraceLeave(GLOBAL, "StopDriver");
}



NTSTATUS
RegisterWithIp(
    VOID
    )

/*++

Routine Description

    Registers the ARP module with IP

Locks


Arguments


Return Value


--*/

{
    NDIS_STRING     nsIpIpName;
    WCHAR           pwszName[] = IPINIP_ARP_NAME;
    IP_STATUS       Status;
    IPInfo          Info;

    TraceEnter(GLOBAL, "RegisterWithIP");

    Status = IPGetInfo(&Info,
                       sizeof(Info));

    if(Status isnot IP_SUCCESS)
    {
        Trace(GLOBAL, ERROR,
              ("RegisterWithIp: Couldnt get IPInfo %x\n", Status));

        TraceLeave(GLOBAL,
                   "RegisterWithIP");

        return STATUS_UNSUCCESSFUL;
    }

    g_pfnOpenRce    = Info.ipi_openrce;
    g_pfnCloseRce   = Info.ipi_closerce;

    nsIpIpName.MaximumLength  = sizeof(pwszName);
    nsIpIpName.Length         = sizeof(IPINIP_ARP_NAME) - sizeof(WCHAR);
    nsIpIpName.Buffer         = pwszName;

    Status = IPRegisterARP(&nsIpIpName,
                           IP_ARP_BIND_VERSION,
                           IpIpBindAdapter,
                           &g_pfnIpAddInterface,
                           &g_pfnIpDeleteInterface,
                           &g_pfnIpBindComplete,
                           &g_pfnIpAddLink,
                           &g_pfnIpDeleteLink,
                           &g_pfnIpChangeIndex,
                           &g_pfnIpReserveIndex,
                           &g_pfnIpDereserveIndex,
                           &g_hIpRegistration);
    
    if(Status isnot IP_SUCCESS)
    {
        Trace(GLOBAL, ERROR,
              ("RegisterWithIp: Couldnt register with IP\n"));

        TraceLeave(GLOBAL,
                   "RegisterWithIP");

        return STATUS_UNSUCCESSFUL;
    }

    TraceLeave(GLOBAL,
               "RegisterWithIP");

    return STATUS_SUCCESS;
}

VOID
DeregisterWithIp(
    VOID
    )

/*++

Routine Description

   DeRegisters the ARP module with IP

Locks


Arguments


Return Value

--*/

{
    NTSTATUS    nStatus;

    TraceEnter(GLOBAL, "DeregisterWithIp");

    nStatus = IPDeregisterARP(g_hIpRegistration);

    if(nStatus isnot STATUS_SUCCESS)    
    {
        Trace(GLOBAL, ERROR,
              ("DeregisterWithIp: Couldnt deregister with IP. Error %x\n",
               nStatus));

    }

    g_pfnIpAddInterface     = NULL;
    g_pfnIpDeleteInterface  = NULL;
    g_pfnIpBindComplete     = NULL;
    g_pfnIpRcv              = NULL;
    g_pfnIpRcvComplete      = NULL;
    g_pfnIpSendComplete     = NULL;
    g_pfnIpTDComplete       = NULL;
    g_pfnIpStatus           = NULL;
    g_pfnIpRcvPkt           = NULL;
    g_pfnIpPnp              = NULL;
    g_hIpRegistration       = NULL;

    TraceLeave(GLOBAL, "DeregisterWithIp");
}

#pragma alloc_text(PAGE, OpenRegKey)

NTSTATUS
OpenRegKey(
    PHANDLE  HandlePtr,
    PWCHAR  KeyName
    )
{
    NTSTATUS           Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING    UKeyName;

    PAGED_CODE();

    RtlInitUnicodeString(&UKeyName, KeyName);

    RtlZeroMemory(&ObjectAttributes,
                  sizeof(OBJECT_ATTRIBUTES));

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

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

    return Status;
}


#pragma alloc_text(PAGE, GetRegDWORDValue)

NTSTATUS
GetRegDWORDValue(
    HANDLE           KeyHandle,
    PWCHAR           ValueName,
    PULONG           ValueData
    )
{
    NTSTATUS                    status;
    ULONG                       resultLength;
    PKEY_VALUE_FULL_INFORMATION keyValueFullInformation;
    UCHAR                       keybuf[128];
    UNICODE_STRING              UValueName;

    PAGED_CODE();

    RtlInitUnicodeString(&UValueName, ValueName);

    keyValueFullInformation = (PKEY_VALUE_FULL_INFORMATION)keybuf;
    RtlZeroMemory(keyValueFullInformation, sizeof(keyValueFullInformation));


    status = ZwQueryValueKey(KeyHandle,
                             &UValueName,
                             KeyValueFullInformation,
                             keyValueFullInformation,
                             128,
                             &resultLength);

    if (NT_SUCCESS(status)) {
        if (keyValueFullInformation->Type != REG_DWORD) {
            status = STATUS_INVALID_PARAMETER_MIX;
        } else {
            *ValueData = *((ULONG UNALIGNED *)((PCHAR)keyValueFullInformation +
                             keyValueFullInformation->DataOffset));
        }
    }

    return status;
}

BOOLEAN
EnterDriverCode(
    VOID
    )
{
    KIRQL   irql;
    BOOLEAN bEnter;

    RtAcquireSpinLock(&g_rlStateLock,
                      &irql);

    if(g_dwDriverState is DRIVER_STARTED)
    {
        g_ulNumThreads++;

        bEnter = TRUE;
    }
    else
    {
        bEnter = FALSE;
    }

    RtReleaseSpinLock(&g_rlStateLock,
                         irql);

    return bEnter;
}


VOID
ExitDriverCode(
    VOID
    )
{
    KIRQL   irql;

    RtAcquireSpinLock(&g_rlStateLock,
                      &irql);

    g_ulNumThreads--;

    if((g_dwDriverState is DRIVER_STOPPED) and
       (g_ulNumThreads is 0))
    {
        KeSetEvent(&g_keStateEvent,
                   0,
                   FALSE);
    }

    RtReleaseSpinLock(&g_rlStateLock,
                      irql);

}

VOID
ClearPendingIrps(
    VOID
    )
    
/*++

Routine Description:

    Called at cleanup time to return any pending IRPs    

Locks:

    Acquires the IoCancelSpinLock since it controls the pending irp list

Arguments:

    None

Return Value:

    None

--*/

{
    KIRQL   irql;

    TraceEnter(GLOBAL, "ClearPendingIrps");

    IoAcquireCancelSpinLock (&irql);

    while(!IsListEmpty(&g_lePendingIrpList))
    {
        PLIST_ENTRY pleNode;
        PIRP        pIrp;

        pleNode = RemoveHeadList(&g_lePendingIrpList);

        pIrp = CONTAINING_RECORD(pleNode,
                                 IRP,
                                 Tail.Overlay.ListEntry);

        IoSetCancelRoutine(pIrp,
                           NULL);

        pIrp->IoStatus.Status       = STATUS_NO_SUCH_DEVICE;
        pIrp->IoStatus.Information  = 0;

        //
        // release lock to complete the IRP
        //

        IoReleaseCancelSpinLock(irql);

        IoCompleteRequest(pIrp,
                          IO_NETWORK_INCREMENT);

        //
        // Reaquire the lock
        //

        IoAcquireCancelSpinLock(&irql);
    }

    IoReleaseCancelSpinLock(irql);
}