windows-xp/Source/XPSP1/NT/net/tcpip/driver/tcp/ntinit.c

/*++

Copyright (c) 1991  Microsoft Corporation

Module Name:

    ntinit.c

Abstract:

    NT specific routines for loading and configuring the TCP/UDP driver.

Author:

    Mike Massa (mikemas)           Aug 13, 1993

Revision History:

    Who         When        What
    --------    --------    ----------------------------------------------
    mikemas     08-13-93    created

Notes:

--*/

#include "precomp.h"

#if !MILLEN
#include <ipfilter.h>
#include <ipsec.h>
#endif // !MILLEN

#include "tdint.h"
#include "addr.h"
#include "tcp.h"
#include "tcb.h"
#include "udp.h"
#include "raw.h"
#include "tcpconn.h"
#include "mdlpool.h"
#include "pplasl.h"
#include "tcprcv.h"
#include "tcpsend.h"
#include "tlcommon.h"
#include "tcpcfg.h"
#include "secfltr.h"

#if GPC
#include <qos.h>
#include <traffic.h>
#include "gpcifc.h"
#include "ntddtc.h"

GPC_HANDLE hGpcClient[GPC_CF_MAX] = {0};
ulong GpcCfCounts[GPC_CF_MAX] = {0};
GPC_EXPORTED_CALLS GpcEntries;
GPC_CLIENT_FUNC_LIST GpcHandlers;

ulong GPCcfInfo = 0;

ulong ServiceTypeOffset = FIELD_OFFSET(CF_INFO_QOS, ToSValue);

GPC_STATUS GPCcfInfoAddNotifyIpsec(GPC_CLIENT_HANDLE ClCtxt,
                                   GPC_HANDLE GpcHandle,
                                   ULONG CfInfoSize,
                                   PVOID CfInfo,
                                   PGPC_CLIENT_HANDLE pClInfoCxt);

GPC_STATUS GPCcfInfoRemoveNotifyIpsec(GPC_CLIENT_HANDLE ClCtxt,
                                      GPC_CLIENT_HANDLE ClInfoCxt);

GPC_STATUS GPCcfInfoAddNotifyQoS(GPC_CLIENT_HANDLE ClCtxt,
                                 GPC_HANDLE GpcHandle,
                                 ULONG CfInfoSize,
                                 PVOID CfInfo,
                                 PGPC_CLIENT_HANDLE pClInfoCxt);

GPC_STATUS GPCcfInfoRemoveNotifyQoS(GPC_CLIENT_HANDLE ClCtxt,
                                    GPC_CLIENT_HANDLE ClInfoCxt);

#endif

ReservedPortListEntry *PortRangeList = NULL;

VOID
GetReservedPortList(
                    NDIS_HANDLE ConfigHandle
                    );

//
// Global variables.
//
PDRIVER_OBJECT TCPDriverObject = NULL;
PDEVICE_OBJECT TCPDeviceObject = NULL;
PDEVICE_OBJECT UDPDeviceObject = NULL;
PDEVICE_OBJECT RawIPDeviceObject = NULL;
extern PDEVICE_OBJECT IPDeviceObject;

TCPXSUM_ROUTINE tcpxsum_routine = tcpxsum;

#if ACC
PSECURITY_DESCRIPTOR TcpAdminSecurityDescriptor;
extern uint AllowUserRawAccess;

typedef ULONG SECURITY_INFORMATION;

BOOLEAN
IsRunningOnPersonal (
    VOID
    );

#endif

extern uint DisableLargeSendOffload;

//
//Place holder for Maximum duplicate acks we would like
//to see before we do fast retransmit
//
extern uint MaxDupAcks;

MM_SYSTEMSIZE systemSize;

extern uint MaxHashTableSize;
extern uint NumTcbTablePartitions;
extern uint PerPartitionSize;
extern uint LogPerPartitionSize;
#define CACHE_LINE_SIZE 64
#define CACHE_ALIGN_MASK (~(CACHE_LINE_SIZE-1))

CTELock *pTWTCBTableLock;
CTELock *pTCBTableLock;

CTELock *pSynTCBTableLock;

extern Queue *TWQueue;

extern Queue *TWTCBTable;
extern TCB **TCBTable;
extern Queue *SYNTCBTable;

extern PTIMER_WHEEL TimerWheel;
PTIMER_WHEEL OrgTimerWheel;

extern TCPConn **ConnTable;
extern uint MaxConnBlocks;
extern uint ConnPerBlock;

extern uint GlobalMaxRcvWin;

extern uint TcpHostOpts;
extern uint TcpHostSendOpts;

extern uint MaxRcvWin;

HANDLE TCPRegistrationHandle;
HANDLE UDPRegistrationHandle;
HANDLE IPRegistrationHandle;


//SynAttackProtect=0 no syn flood attack protection
//SynAttackProtect !0  syn flood attack protection
//SynAttackProtect !0 syn flood attack protection+forced(non-dynamic)

//                   delayed connect acceptance

uint SynAttackProtect;        //syn-att protection checks

                                    //  are made
uint TCPPortsExhausted;            //# of ports  exhausted
uint TCPMaxPortsExhausted;        //Max # of ports that must be exhausted
                                    //  for syn-att protection to kick in
uint TCPMaxPortsExhaustedLW;    //Low-watermark of # of ports exhausted
                                    //When reached, we revert to normal
                                    //  count for syn-ack retries
uint TCPMaxHalfOpen;            //Max # of half-open connections allowed
                                    //  before we dec. the syn-ack retries
uint TCPMaxHalfOpenRetried;        //Max # of half-open conn. that have
                                    //  been retried at least 1 time
uint TCPMaxHalfOpenRetriedLW;    //Low-watermark of the above. When
                                    //  go down to it, we revert to normal
                                    //  # of retries for syn-acks
uint TCPHalfOpen;                //# of half-open connections
uint TCPHalfOpenRetried;        //# of half-open conn. that have been
                                    //retried at least once

PDEVICE_OBJECT  IPSECDeviceObject;
PFILE_OBJECT    IPSECFileObject;

extern uint Time_Proc;

extern HANDLE TcbPool;
extern HANDLE TimewaitTcbPool;
extern HANDLE SynTcbPool;

extern void ArpUnload(PDRIVER_OBJECT);
extern CTETimer TCBTimer[];
extern BOOLEAN fTCBTimerStopping;
extern CTEBlockStruc TcpipUnloadBlock;
HANDLE AddressChangeHandle;

extern ulong DefaultTOSValue;
extern ulong DisableUserTOSSetting;
extern uint MaxSendSegments;

//
// External function prototypes
//

int
tlinit(
       void
       );

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

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

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

NTSTATUS
IPDriverEntry(
              IN PDRIVER_OBJECT DriverObject,
              IN PUNICODE_STRING RegistryPath
              );

NTSTATUS
IPPostDriverEntry(
                  IN PDRIVER_OBJECT DriverObject,
                  IN PUNICODE_STRING RegistryPath
                  );

NTSTATUS
GetRegMultiSZValue(
                   HANDLE KeyHandle,
                   PWCHAR ValueName,
                   PUNICODE_STRING ValueData
                   );

PWCHAR
EnumRegMultiSz(
               IN PWCHAR MszString,
               IN ULONG MszStringLength,
               IN ULONG StringIndex
               );


uint InitIsnGenerator();
#if !MILLEN
extern ulong g_cRandIsnStore;
#endif // !MILLEN


#if MILLEN
extern VOID InitializeWDebDebug();
#endif // MILLEN

        //
// Local funcion prototypes
//
NTSTATUS
DriverEntry(
            IN PDRIVER_OBJECT DriverObject,
            IN PUNICODE_STRING RegistryPath
            );

void *
TLRegisterProtocol(
                    uchar Protocol,
                    void *RcvHandler,
                    void *XmitHandler,
                    void *StatusHandler,
                    void *RcvCmpltHandler,
                    void *PnPHandler,
                    void *ElistHandler
                    );

IP_STATUS
TLGetIPInfo(
            IPInfo * Buffer,
            int Size
            );

uchar
TCPGetConfigInfo(
                 void
                 );

NTSTATUS
TCPInitializeParameter(
                       HANDLE KeyHandle,
                       PWCHAR ValueName,
                       PULONG Value
                       );

#if !MILLEN
NTSTATUS
IpsecInitialize(
          void
          );

NTSTATUS
IpsecDeinitialize(
            void
            );
#endif

#if !MILLEN
#ifdef i386
NTSTATUS
TCPSetChecksumRoutine(
                      VOID
                      );
#endif
#endif // !MILLEN

uint
EnumSecurityFilterValue(
                        PNDIS_STRING FilterList,
                        ulong Index,
                        ulong * FilterValue
                        );


VOID
TCPAcdBind();

#ifdef ACC

typedef ULONG SECURITY_INFORMATION;

NTSTATUS
TcpBuildDeviceAcl(
                  OUT PACL * DeviceAcl
                  );

NTSTATUS
TcpCreateAdminSecurityDescriptor(
                                 VOID
                                 );

NTSTATUS
AddNetConfigOpsAce(IN PACL Dacl,
                  OUT PACL * DeviceAcl
                  );
NTSTATUS
CreateDeviceDriverSecurityDescriptor(PVOID DeviceOrDriverObject
                                     );

#endif // ACC


#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT, DriverEntry)
#pragma alloc_text(INIT, TLRegisterProtocol)
#pragma alloc_text(INIT, TLGetIPInfo)
#pragma alloc_text(INIT, TCPGetConfigInfo)
#pragma alloc_text(INIT, TCPInitializeParameter)

#if !MILLEN
#pragma alloc_text(INIT, IpsecInitialize)
#endif

#if !MILLEN
#ifdef i386
#pragma alloc_text(INIT, TCPSetChecksumRoutine)
#endif
#endif // !MILLEN

#pragma alloc_text(PAGE, EnumSecurityFilterValue)

#pragma alloc_text(INIT, TCPAcdBind)

#ifdef ACC
#pragma alloc_text(INIT, TcpBuildDeviceAcl)
#pragma alloc_text(INIT, TcpCreateAdminSecurityDescriptor)
#pragma alloc_text(INIT, AddNetConfigOpsAce)
#pragma alloc_text(INIT, CreateDeviceDriverSecurityDescriptor)
#endif // ACC

#endif

//
// Function definitions
//
NTSTATUS
DriverEntry(
            IN PDRIVER_OBJECT DriverObject,
            IN PUNICODE_STRING RegistryPath
            )
/*++

Routine Description:

    Initialization routine for the TCP/UDP driver.

Arguments:

    DriverObject      - Pointer to the TCP driver object created by the system.
    DeviceDescription - The name of TCP's node in the registry.

Return Value:

    The final status from the initialization operation.

--*/

{
    NTSTATUS status;
    UNICODE_STRING deviceName;
    UNICODE_STRING SymbolicDeviceName;
    USHORT i;
    int initStatus;

    DEBUGMSGINIT();

    DEBUGMSG(DBG_TRACE && DBG_INIT,
        (DTEXT("+DriverEntry(%x, %x)\n"), DriverObject, RegistryPath));

    TdiInitialize();

    //
    // IP calls the security filter code, so initialize it first.
    //
    InitializeSecurityFilters();


    //
    // Initialize IP
    //
    status = IPDriverEntry(DriverObject, RegistryPath);

    if (!NT_SUCCESS(status)) {
        DEBUGMSG(DBG_ERROR && DBG_INIT,
            (DTEXT("TCPIP: IP Initialization failure %x\n"), status));
        DEBUGMSG(DBG_TRACE && DBG_INIT, (DTEXT("-DriverEntry [%x]\n"), status));
        return (status);
    }

#if !MILLEN
    //
    // Initialize IPSEC
    //
    status = IpsecInitialize();

    if (!NT_SUCCESS(status)) {
        DEBUGMSG(DBG_ERROR && DBG_INIT,
            (DTEXT("TCPIP: IPSEC Initialization failure %x\n"), status));
        DEBUGMSG(DBG_TRACE && DBG_INIT, (DTEXT("-DriverEntry [%x]\n"), status));

        goto init_failed;
    }
#endif

    //
    // Initialize TCP, UDP, and RawIP
    //
    TCPDriverObject = DriverObject;

    //
    // Create the device objects. IoCreateDevice zeroes the memory
    // occupied by the object.
    //

    RtlInitUnicodeString(&deviceName, DD_TCP_DEVICE_NAME);
    RtlInitUnicodeString(&SymbolicDeviceName, DD_TCP_SYMBOLIC_DEVICE_NAME);

    status = IoCreateDevice(
                            DriverObject,
                            0,
                            &deviceName,
                            FILE_DEVICE_NETWORK,
                            FILE_DEVICE_SECURE_OPEN,
                            FALSE,
                            &TCPDeviceObject
                            );

    if (!NT_SUCCESS(status)) {
        CTELogEvent(
                    DriverObject,
                    EVENT_TCPIP_CREATE_DEVICE_FAILED,
                    1,
                    1,
                    &deviceName.Buffer,
                    0,
                    NULL
                    );

        DEBUGMSG(DBG_ERROR && DBG_INIT,
            (DTEXT("DriverEntry: failure %x to create TCP device object %ws\n"),
            status, DD_TCP_DEVICE_NAME));

        goto init_failed;
    }

    status = IoCreateSymbolicLink(&SymbolicDeviceName, &deviceName);

    if (!NT_SUCCESS(status)) {
        CTELogEvent(
                    DriverObject,
                    EVENT_TCPIP_CREATE_DEVICE_FAILED,
                    1,
                    1,
                    &deviceName.Buffer,
                    0,
                    NULL
                    );

        DEBUGMSG(DBG_ERROR && DBG_INIT,
            (DTEXT("DriverEntry: failure %x to create TCP symbolic device link %ws\n"),
            status, DD_TCP_SYMBOLIC_DEVICE_NAME));

        goto init_failed;
    }

    RtlInitUnicodeString(&deviceName, DD_UDP_DEVICE_NAME);

    status = IoCreateDevice(
                            DriverObject,
                            0,
                            &deviceName,
                            FILE_DEVICE_NETWORK,
                            FILE_DEVICE_SECURE_OPEN,
                            FALSE,
                            &UDPDeviceObject
                            );

    if (!NT_SUCCESS(status)) {
        CTELogEvent(
                    DriverObject,
                    EVENT_TCPIP_CREATE_DEVICE_FAILED,
                    1,
                    1,
                    &deviceName.Buffer,
                    0,
                    NULL
                    );

        TCPTRACE((
                  "TCP: Failed to create UDP device object, status %lx\n",
                  status
                 ));
        goto init_failed;
    }
    RtlInitUnicodeString(&deviceName, DD_RAW_IP_DEVICE_NAME);

    status = IoCreateDevice(
                            DriverObject,
                            0,
                            &deviceName,
                            FILE_DEVICE_NETWORK,
                            FILE_DEVICE_SECURE_OPEN,
                            FALSE,
                            &RawIPDeviceObject
                            );

    if (!NT_SUCCESS(status)) {
        CTELogEvent(
                    DriverObject,
                    EVENT_TCPIP_CREATE_DEVICE_FAILED,
                    1,
                    1,
                    &deviceName.Buffer,
                    0,
                    NULL
                    );

        TCPTRACE((
                  "TCP: Failed to create Raw IP device object, status %lx\n",
                  status
                 ));
        goto init_failed;
    }
    //
    // Initialize the driver object
    //
    DriverObject->DriverUnload = ArpUnload;

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

    //
    // We special case Internal Device Controls because they are the
    // hot path for kernel-mode clients.
    //
    DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] =
        TCPDispatchInternalDeviceControl;

    //
    // Intialize the device objects.
    //
    TCPDeviceObject->Flags |= DO_DIRECT_IO;
    UDPDeviceObject->Flags |= DO_DIRECT_IO;
    RawIPDeviceObject->Flags |= DO_DIRECT_IO;

#ifdef ACC

    // Change the different devices and Objects to allow access to Network Configuration Operators

    if (!IsRunningOnPersonal()) {

        status = CreateDeviceDriverSecurityDescriptor(IPDeviceObject);
        if (!NT_SUCCESS(status)) {
            goto init_failed;
        }

        status = CreateDeviceDriverSecurityDescriptor(TCPDeviceObject);
        if (!NT_SUCCESS(status)) {
            goto init_failed;
        }

        status = CreateDeviceDriverSecurityDescriptor(IPSECDeviceObject);
        if (!NT_SUCCESS(status)) {
            goto init_failed;
        }
    }

    //
    // Create the security descriptor used for raw socket access checks.
    //
    status = TcpCreateAdminSecurityDescriptor();

    if (!NT_SUCCESS(status)) {
        goto init_failed;
    }
#endif // ACC

#if !MILLEN
#ifdef i386
    //
    // Set the checksum routine pointer according to the processor available
    //
    TCPSetChecksumRoutine();
#endif
#endif // !MILLEN

    //
    // Finally, initialize the stack.
    //
    initStatus = tlinit();

    if (initStatus == TRUE) {
        //
        // Get the automatic connection driver
        // entry points.
        //
        TCPAcdBind();

        RtlInitUnicodeString(&deviceName, DD_TCP_DEVICE_NAME);
        (void)TdiRegisterDeviceObject(&deviceName, &TCPRegistrationHandle);

        RtlInitUnicodeString(&deviceName, DD_UDP_DEVICE_NAME);
        (void)TdiRegisterDeviceObject(&deviceName, &UDPRegistrationHandle);

        RtlInitUnicodeString(&deviceName, DD_RAW_IP_DEVICE_NAME);
        (void)TdiRegisterDeviceObject(&deviceName, &IPRegistrationHandle);

        // do the ndis register protocol now after all the intialization
        // is complete, o/w we get bindadapter even before we r fully
        // initialized.
        status = IPPostDriverEntry(DriverObject, RegistryPath);
        if (!NT_SUCCESS(status)) {

            DEBUGMSG(DBG_ERROR && DBG_INIT,
                (DTEXT("TCPIP: IP post-init failure %x\n"), status));
            DEBUGMSG(DBG_TRACE && DBG_INIT, (DTEXT("-DriverEntry [%x]\n"), status));
            return (status);
        }

#if GPC
        status = GpcInitialize(&GpcEntries);

        if (!NT_SUCCESS(status)) {

            KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"GpcInitialize Failed! Status: 0x%x\n", status));

            //return status;
        } else {

            //
            // Need to register as GPC client. Try it now.
            // we register clients for QOS and IPSEC
            //

            memset(&GpcHandlers, 0, sizeof(GPC_CLIENT_FUNC_LIST));

            GpcHandlers.ClAddCfInfoNotifyHandler = GPCcfInfoAddNotifyQoS;
            GpcHandlers.ClRemoveCfInfoNotifyHandler = GPCcfInfoRemoveNotifyQoS;

            status = GpcEntries.GpcRegisterClientHandler(
                                                         GPC_CF_QOS,    // classification family
                                                          0,    // flags
                                                          1,    // default max priority
                                                          &GpcHandlers,        // client notification vector - no notifications to TCPIP required
                                                          0,    // client context, not needed
                                                          &hGpcClient[GPC_CF_QOS]);

            if (!NT_SUCCESS(status)) {
                KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"GPC registerclient QOS status %x hGpcClient %p\n",
                         status, hGpcClient[GPC_CF_QOS]));
                hGpcClient[GPC_CF_QOS] = NULL;
            }
            GpcHandlers.ClAddCfInfoNotifyHandler = GPCcfInfoAddNotifyIpsec;
            GpcHandlers.ClRemoveCfInfoNotifyHandler = GPCcfInfoRemoveNotifyIpsec;

            status = GpcEntries.GpcRegisterClientHandler(
                                                         GPC_CF_IPSEC,    // classification family
                                                          0,    // flags
                                                          GPC_PRIORITY_IPSEC,    // default max priority
                                                          &GpcHandlers,        // client notification vector - no notifications to TCPIP required
                                                          0,    // client context, not needed
                                                          &hGpcClient[GPC_CF_IPSEC]);

            if (!NT_SUCCESS(status)) {
                KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"GPC registerclient IPSEC status %x hGpcClient %p\n",
                         status, hGpcClient[GPC_CF_IPSEC]));
                hGpcClient[GPC_CF_IPSEC] = NULL;
            }
        }
#endif

        if (InitIsnGenerator() == FALSE) {
            DEBUGMSG(DBG_ERROR && DBG_INIT,
                (DTEXT("InitIsnGenerator failure. TCP/IP failing to start.\n")));
            DEBUGMSG(DBG_TRACE && DBG_INIT, (DTEXT("-DriverEntry [%x]\n"), status));
            return (STATUS_UNSUCCESSFUL);
        }

// Millennium TCPIP has debugger extensions built in!
#if MILLEN
        InitializeWDebDebug();
#endif // MILLEN

#if TRACE_EVENT
        //
        // Register with WMI for Enable/Disable Notification
        // of Trace Logging
        //
        TCPCPHandlerRoutine = NULL;

        IoWMIRegistrationControl(
                                 TCPDeviceObject,
                                 WMIREG_ACTION_REGISTER |
                                 WMIREG_FLAG_TRACE_PROVIDER |
                                 WMIREG_NOTIFY_TDI_IO
                                 );
#endif

        DEBUGMSG(DBG_TRACE && DBG_INIT, (DTEXT("-DriverEntry [SUCCESS]\n")));
        return (STATUS_SUCCESS);
    }

    DEBUGMSG(DBG_ERROR && DBG_INIT,
        (DTEXT("TCPIP: TCP initialization failed, IP still available.\n")));

    CTELogEvent(
                DriverObject,
                EVENT_TCPIP_TCP_INIT_FAILED,
                1,
                0,
                NULL,
                0,
                NULL
                );
    status = STATUS_UNSUCCESSFUL;

  init_failed:

    DEBUGMSG(DBG_ERROR && DBG_INIT,
        (DTEXT("TCPIP DriverEntry initialization failure!\n")));
    //
    // IP has successfully started, but TCP & UDP failed. Set the
    // Dispatch routine to point to IP only, since the TCP and UDP
    // devices don't exist.
    //

    if (TCPDeviceObject != NULL) {
        IoDeleteDevice(TCPDeviceObject);
    }
    if (UDPDeviceObject != NULL) {
        IoDeleteDevice(UDPDeviceObject);
    }
    if (RawIPDeviceObject != NULL) {
        IoDeleteDevice(RawIPDeviceObject);
    }
    for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++) {
        DriverObject->MajorFunction[i] = IPDispatch;
    }

#if !MILLEN
    if (IPSECFileObject) {
        IpsecDeinitialize();
    }
#endif

    return (status);
}

#if !MILLEN
#ifdef i386

NTSTATUS
TCPSetChecksumRoutine(
                      VOID
                      )
/*++

Routine Description:

    This routine sets the checksum routine function pointer to the
    appropriate routine based on the processor features available

Arguments:

    None

Return Value:

    STATUS_SUCCESS - if successful

--*/

{

    SYSTEM_PROCESSOR_INFORMATION Info;
    ULONG Length;
    ULONG Features;
    ULONG Processors;
    ULONG i;
    NTSTATUS Status;
    BOOLEAN TcpipUsePrefetch;
#if WINVER < 0x0500
    KAFFINITY OriginalAffinity;
#endif /* WINVER */

    //
    // First check to see that I have at least Intel Pentium.  This simplifies
    // the cpuid
    //

    Status = ZwQuerySystemInformation(SystemProcessorInformation,
                                      &Info,
                                      sizeof(Info),
                                      &Length);

    if (!NT_SUCCESS(Status)) {
        return (Status);
    }
    if (Info.ProcessorArchitecture != PROCESSOR_ARCHITECTURE_INTEL ||
        Info.ProcessorLevel < 5) {

        Status = STATUS_INSUFFICIENT_RESOURCES;
        return (Status);
    }
    Status = STATUS_SUCCESS;
    TcpipUsePrefetch = TRUE;

    Processors = KeNumberProcessors;
    //
    // Affinity thread to boot processor
    //

#if WINVER < 0x0500
    OriginalAffinity = KeSetAffinityThread(KeGetCurrentThread(), 1);
#else /* WINVER >= 0x0500 */
    KeSetSystemAffinityThread(1);
#endif /* WINVER */

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

        if (i != 0) {

#if WINVER < 0x0500
            KeSetAffinityThread(KeGetCurrentThread(), 1 << i);
#else /* WINVER >= 0x0500 */
            KeSetSystemAffinityThread(1 << i);
#endif /* WINVER */
        }
        _asm {
            push ebx
             mov eax, 1

            ;cpuid
                _emit 0fh
                _emit 0a2h

                mov Features, edx
                pop ebx
        }

        //
        // Check for Prefetch Present
        //
        if (!(Features & 0x02000000)) {

            //
            // All processors must have prefetch before we can use it.
            // We start with it enabled, if any processor does not have
            // it we clear it,

            TcpipUsePrefetch = FALSE;
        }
    }

#if WINVER < 0x0500
    KeSetAffinityThread(KeGetCurrentThread(), OriginalAffinity);
#else /* WINVER >= 0x0500 */
    KeRevertToUserAffinityThread();
#endif /* WINVER */

    if (TcpipUsePrefetch == TRUE) {

        tcpxsum_routine = tcpxsum_xmmi;
    }
    return (Status);
}

#endif
#endif // !MILLEN

IP_STATUS
TLGetIPInfo(
            IPInfo * Buffer,
            int Size
            )
/*++

Routine Description:

    Returns information necessary for TCP to call into IP.

Arguments:

    Buffer  - A pointer to the IP information structure.

    Size    - The size of Buffer.

Return Value:

    The IP status of the operation.

--*/

{
    return (IPGetInfo(Buffer, Size));
}

void *
TLRegisterProtocol(
                   uchar Protocol,
                   void *RcvHandler,
                   void *XmitHandler,
                   void *StatusHandler,
                   void *RcvCmpltHandler,
                   void *PnPHandler,
                   void *ElistHandler
                   )
/*++

Routine Description:

    Calls the IP driver's protocol registration function.

Arguments:

    Protocol        -  The protocol number to register.

    RcvHandler      -  Transport's packet receive handler.

    XmitHandler     -  Transport's packet transmit complete handler.

    StatusHandler   -  Transport's status update handler.

    RcvCmpltHandler -  Transport's receive complete handler

Return Value:

    A context value for the protocol to pass to IP when transmitting.

--*/

{
    return (IPRegisterProtocol(
                               Protocol,
                               RcvHandler,
                               XmitHandler,
                               StatusHandler,
                               RcvCmpltHandler,
                               PnPHandler,
                               ElistHandler));
}

//
// Interval in milliseconds between keepalive transmissions until a
// response is received.
//
#define DEFAULT_KEEPALIVE_INTERVAL  1000


//
// time to first keepalive transmission. 2 hours == 7,200,000 milliseconds
//
#define DEFAULT_KEEPALIVE_TIME      7200000


#define MIN_THRESHOLD_MAX_HO          1
#define MIN_THRESHOLD_MAX_HO_RETRIED  80

uchar
TCPGetConfigInfo(
                 void
                 )
/*++

Routine Description:

    Initializes TCP global configuration parameters.

Arguments:

    None.

Return Value:

    Zero on failure, nonzero on success.

--*/

{
    HANDLE keyHandle;
    NTSTATUS status;
    OBJECT_ATTRIBUTES objectAttributes;
    UNICODE_STRING UKeyName;
    ULONG maxConnectRexmits = 0;
    ULONG maxConnectResponseRexmits = 0;
    ULONG maxDataRexmits = 0;
    ULONG pptpmaxDataRexmits = 0;
    ULONG useRFC1122UrgentPointer = 0;
    BOOLEAN AsSystem;
    ULONG tcp1323opts = 3;        //turning off 1323 options by default
    ULONG SackOpts;
    ULONG i, j;

    DEBUGMSG(DBG_TRACE && DBG_INIT,
        (DTEXT("+TCPGetConfigInfo()\n")));

    //
    // Initialize to the defaults in case an error occurs somewhere.
    //
    KAInterval = DEFAULT_KEEPALIVE_INTERVAL;
    KeepAliveTime = DEFAULT_KEEPALIVE_TIME;
    PMTUDiscovery = TRUE;
    PMTUBHDetect = FALSE;
    DeadGWDetect = TRUE;
    DefaultRcvWin = 0;            // Automagically pick a reasonable one.

    MaxConnections = DEFAULT_MAX_CONNECTIONS;
    maxConnectRexmits = MAX_CONNECT_REXMIT_CNT;
    maxConnectResponseRexmits = MAX_CONNECT_RESPONSE_REXMIT_CNT;
    pptpmaxDataRexmits = maxDataRexmits = MAX_REXMIT_CNT;
    BSDUrgent = TRUE;
    FinWait2TO = FIN_WAIT2_TO;
    NTWMaxConnectCount = NTW_MAX_CONNECT_COUNT;
    NTWMaxConnectTime = NTW_MAX_CONNECT_TIME;
    MaxUserPort = DEFAULT_MAX_USER_PORT;

//  Default number of duplicate acks
    MaxDupAcks = 2;

    SynAttackProtect = 0;    //by default it is always off

#if MILLEN
    TCPMaxPortsExhausted = 5;
    TCPMaxHalfOpen = 100;
    TCPMaxHalfOpenRetried = 80;
#else // MILLEN
    if (!MmIsThisAnNtAsSystem()) {
        TCPMaxPortsExhausted = 5;
        TCPMaxHalfOpen = 100;
        TCPMaxHalfOpenRetried = 80;
    } else {
        TCPMaxPortsExhausted = 5;
        TCPMaxHalfOpen = 500;
        TCPMaxHalfOpenRetried = 400;
    }
#endif // !MILLEN

    SecurityFilteringEnabled = FALSE;

#ifdef ACC
    AllowUserRawAccess = FALSE;
#endif

    //
    // Read the TCP optional (hidden) registry parameters.
    //
#if !MILLEN
    RtlInitUnicodeString(
                         &UKeyName,
                         L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\Tcpip\\Parameters"
                         );
#else // !MILLEN
    RtlInitUnicodeString(
                         &UKeyName,
                         L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\VxD\\MSTCP"
                         );
#endif // MILLEN

    DEBUGMSG(DBG_INFO && DBG_INIT,
        (DTEXT("TCPGetConfigInfo: Opening key %ws\n"), UKeyName.Buffer));

    memset(&objectAttributes, 0, sizeof(OBJECT_ATTRIBUTES));

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

    status = ZwOpenKey(
                       &keyHandle,
                       KEY_READ,
                       &objectAttributes
                       );

    DEBUGMSG(!NT_SUCCESS(status) && DBG_ERROR,
        (DTEXT("TCPGetConfigInfo: failed to open TCP registry configuration: %ws\n"),
         UKeyName.Buffer));

    if (NT_SUCCESS(status)) {

        DEBUGMSG(DBG_INFO && DBG_INIT,
            (DTEXT("TCPGetConfigInfo: successfully opened registry to read.\n")));
#if !MILLEN
        TCPInitializeParameter(
                               keyHandle,
                               L"IsnStoreSize",
                               &g_cRandIsnStore
                               );
#endif // !MILLEN

        TCPInitializeParameter(
                               keyHandle,
                               L"KeepAliveInterval",
                               &KAInterval
                               );

        TCPInitializeParameter(
                               keyHandle,
                               L"KeepAliveTime",
                               &KeepAliveTime
                               );

        status = TCPInitializeParameter(
                               keyHandle,
                               L"EnablePMTUBHDetect",
                               &PMTUBHDetect
                               );

#if MILLEN
        //
        // Backwards compatibility. If 'EnablePMTUBHDetect' value does not exist,
        // then attempt to read legacy 'PMTUBlackHoleDetect'.
        //
        if (!NT_SUCCESS(status)) {
            TCPInitializeParameter(
                                   keyHandle,
                                   L"PMTUBlackHoleDetect",
                                   &PMTUBHDetect
                                   );
        }
#endif // MILLEN

        status = TCPInitializeParameter(
                                        keyHandle,
                                        L"TcpWindowSize",
                                        &DefaultRcvWin
                                        );

#if MILLEN
        //
        // Backwards compatibility. If 'TcpWindowSize' value does not exist,
        // then attempt to read legacy 'DefaultRcvWindow'.
        //
        if (!NT_SUCCESS(status)) {
            TCPInitializeParameter(
                                   keyHandle,
                                   L"DefaultRcvWindow",
                                   &DefaultRcvWin
                                   );
        }
#endif // MILLEN

        status = TCPInitializeParameter(
                                        keyHandle,
                                        L"TcpNumConnections",
                                        &MaxConnections
                                        );

#if MILLEN
        //
        // Backwards compatibility. If 'TcpNumConnections' value does not exist,
        // then attempt to read legacy 'MaxConnections'.
        //
        if (!NT_SUCCESS(status)) {
            TCPInitializeParameter(
                                   keyHandle,
                                   L"MaxConnections",
                                   &MaxConnections
                                   );
        }
#endif // MILLEN

        status = TCPInitializeParameter(
                                        keyHandle,
                                        L"TcpMaxConnectRetransmissions",
                                        &maxConnectRexmits
                                        );

#if MILLEN
        //
        // Backwards compatibility. If 'TcpMaxConnectRetransmissions' value does not exist,
        // then attempt to read legacty 'MaxConnectRetries'.
        //
        if (!NT_SUCCESS(status)) {
            TCPInitializeParameter(
                                   keyHandle,
                                   L"MaxConnectRetries",
                                   &maxConnectRexmits
                                   );
        }
#endif // MILLEN

        if (maxConnectRexmits > 255) {
            maxConnectRexmits = 255;
        }
        TCPInitializeParameter(
                               keyHandle,
                               L"TcpMaxConnectResponseRetransmissions",
                               &maxConnectResponseRexmits
                               );

        if (maxConnectResponseRexmits > 255) {
            maxConnectResponseRexmits = 255;
        }

        status = TCPInitializeParameter(
                                        keyHandle,
                                        L"TcpMaxDataRetransmissions",
                                        &maxDataRexmits
                                        );

#if MILLEN
        //
        // Backwards compatibility. If 'TcpMaxDataRetransmissions' value does not exist,
        // then attempt to read legacy 'MaxDataRetries'.
        //
        if (!NT_SUCCESS(status)) {
            TCPInitializeParameter(
                                   keyHandle,
                                   L"MaxDataRetries",
                                   &maxDataRexmits
                                   );
        }
#endif // MILLEN

        if (maxDataRexmits > 255) {
            maxDataRexmits = 255;
        }
        // Limit the MaxDupAcks to 3

        status = TCPInitializeParameter(
                                        keyHandle,
                                        L"TcpMaxDupAcks",
                                        &MaxDupAcks
                                        );

#if MILLEN
        //
        // Backwards compatibility. If 'TcpMaxDupAcks' value does not exist,
        // then attempt to read legacy 'MaxDupAcks'.
        //
        if (!NT_SUCCESS(status)) {
            TCPInitializeParameter(
                                   keyHandle,
                                   L"MaxDupAcks",
                                   &MaxDupAcks
                                   );
        }
#endif // MILLEN

        if (MaxDupAcks > 3) {
            MaxDupAcks = 3;
        }
        if (MaxDupAcks == 0) {
            MaxDupAcks = 1;
        }

#if MILLEN
        MaxConnBlocks = 16;
#else // MILLEN

        systemSize = MmQuerySystemSize();

        if (MmIsThisAnNtAsSystem()) {

            if (systemSize == MmSmallSystem) {
                MaxConnBlocks = 128;
            } else if (systemSize == MmMediumSystem) {
                MaxConnBlocks = 256;
            } else {
#if defined(_WIN64)
                MaxConnBlocks = 4096;
#else
                MaxConnBlocks = 1024;
#endif
            }
        } else {
            //for workstation, small system limit default number of connections to 4K.
            // medium system 8k
            // Large system 32k connections

            if (systemSize == MmSmallSystem) {
                MaxConnBlocks = 16;
            } else if (systemSize == MmMediumSystem) {
                MaxConnBlocks = 32;
            } else {
                MaxConnBlocks = 128;
            }
        }
#endif // !MILLEN


#if MILLEN
        NumTcbTablePartitions = 1;
#else
        NumTcbTablePartitions = (KeNumberProcessors * KeNumberProcessors);
#endif

        TCPInitializeParameter(
                               keyHandle,
                               L"NumTcbTablePartitions",
                               &NumTcbTablePartitions
                               );
        if (NumTcbTablePartitions > (MAXIMUM_PROCESSORS * MAXIMUM_PROCESSORS)) {
            NumTcbTablePartitions = (MAXIMUM_PROCESSORS * MAXIMUM_PROCESSORS);
        }
        NumTcbTablePartitions = ComputeLargerOrEqualPowerOfTwo(NumTcbTablePartitions);


        // Default to 128 TCBs per partition
        MaxHashTableSize = 128 * NumTcbTablePartitions;

        TCPInitializeParameter(
                               keyHandle,
                               L"MaxHashTableSize",
                               &MaxHashTableSize
                               );

        if (MaxHashTableSize < 64) {
            MaxHashTableSize = 64;
        } else if (MaxHashTableSize > 0xffff) {
            MaxHashTableSize = 0x10000;
        }
        MaxHashTableSize = ComputeLargerOrEqualPowerOfTwo(MaxHashTableSize);
        if (MaxHashTableSize < NumTcbTablePartitions) {
            MaxHashTableSize = NumTcbTablePartitions;
        }
        ASSERT(IsPowerOfTwo(MaxHashTableSize));

        //since hash table size is power of 2 and cache line size
        //is power of 2 and number of partion is even,
        //entries per partions will be power of 2 and multiple of
        //cache line size.

        PerPartitionSize = MaxHashTableSize / NumTcbTablePartitions;
        ASSERT(IsPowerOfTwo(PerPartitionSize));
        LogPerPartitionSize =
            ComputeShiftForLargerOrEqualPowerOfTwo(PerPartitionSize);


        TWTCBTable = CTEAllocMemBoot(MaxHashTableSize * sizeof(*TWTCBTable));
        if (TWTCBTable == NULL) {
            ZwClose(keyHandle);
            KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"Could  not allocate tw tcb table of size %x\n", MaxHashTableSize));
            DEBUGMSG(DBG_TRACE && DBG_INIT, (DTEXT("-TCPGetConfigInfo [failure]\n")));
            return (0);
        }
        for (i = 0; i < MaxHashTableSize; i++)
        {
            INITQ(&TWTCBTable[i]);
        }

        TCBTable = CTEAllocMemBoot(MaxHashTableSize * sizeof(*TCBTable));
        if (TCBTable == NULL) {
            ExFreePool(TWTCBTable);
            ZwClose(keyHandle);
            KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"Could  not allocate tcb table of size %x\n", MaxHashTableSize));
            DEBUGMSG(DBG_TRACE && DBG_INIT, (DTEXT("-TCPGetConfigInfo [failure]\n")));
            return (0);
        }

        NdisZeroMemory(TCBTable, MaxHashTableSize * sizeof(*TCBTable));

        SYNTCBTable = CTEAllocMemBoot(MaxHashTableSize * sizeof(*SYNTCBTable));
        if (SYNTCBTable == NULL) {
            ExFreePool(TWTCBTable);
            ExFreePool(TCBTable);
            ZwClose(keyHandle);
            KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"Could  not allocate syn tcb table of size %x\n", MaxHashTableSize));
            DEBUGMSG(DBG_TRACE && DBG_INIT, (DTEXT("-TCPGetConfigInfo [failure]\n")));
            return (0);
        }

        for (i = 0; i < MaxHashTableSize; i++)
        {
            INITQ(&SYNTCBTable[i]);
        }

        pSynTCBTableLock = CTEAllocMemBoot(NumTcbTablePartitions * sizeof(CTELock));
        if (pSynTCBTableLock == NULL) {
            ExFreePool(TCBTable);
            ExFreePool(TWTCBTable);
            ExFreePool(SYNTCBTable);
            ZwClose(keyHandle);
            KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"Could  not allocate twtcb lock table \n"));
            DEBUGMSG(DBG_TRACE && DBG_INIT, (DTEXT("-TCPGetConfigInfo [failure]\n")));
            return (0);
        }

        pTWTCBTableLock = CTEAllocMemBoot(NumTcbTablePartitions * sizeof(CTELock));
        if (pTWTCBTableLock == NULL) {
            ExFreePool(TCBTable);
            ExFreePool(TWTCBTable);
            ExFreePool(SYNTCBTable);
            ExFreePool(pSynTCBTableLock);
            ZwClose(keyHandle);
            KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"Could  not allocate twtcb lock table \n"));
            DEBUGMSG(DBG_TRACE && DBG_INIT, (DTEXT("-TCPGetConfigInfo [failure]\n")));
            return (0);
        }

        pTCBTableLock = CTEAllocMemBoot(NumTcbTablePartitions * sizeof(CTELock));
        if (pTCBTableLock == NULL) {
            ExFreePool(TCBTable);
            ExFreePool(TWTCBTable);
            ExFreePool(pTWTCBTableLock);
            ExFreePool(SYNTCBTable);
            ExFreePool(pSynTCBTableLock);
            ZwClose(keyHandle);
            KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"Could  not allocate tcb lock table \n"));
            DEBUGMSG(DBG_TRACE && DBG_INIT, (DTEXT("-TCPGetConfigInfo [failure]\n")));
            return (0);
        }

        TWQueue = CTEAllocMemBoot(NumTcbTablePartitions * sizeof(Queue));
        if (TWQueue == NULL) {
            ExFreePool(TCBTable);
            ExFreePool(TWTCBTable);
            ExFreePool(pTWTCBTableLock);
            ExFreePool(SYNTCBTable);
            ExFreePool(pSynTCBTableLock);
            ExFreePool(pTCBTableLock);
            ZwClose(keyHandle);
            KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"Could  not allocate Twqueue \n"));
            DEBUGMSG(DBG_TRACE && DBG_INIT, (DTEXT("-TCPGetConfigInfo [failure]\n")));
            return (0);

        }

        TimerWheel = CTEAllocMemBoot(NumTcbTablePartitions * sizeof(TIMER_WHEEL) + CACHE_LINE_SIZE);
        if (TimerWheel == NULL) {
            ExFreePool(TCBTable);
            ExFreePool(TWTCBTable);
            ExFreePool(pTWTCBTableLock);
            ExFreePool(SYNTCBTable);
            ExFreePool(pSynTCBTableLock);
            ExFreePool(pTCBTableLock);
            ExFreePool(TWQueue);
            ZwClose(keyHandle);
            KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"Could  not allocate Twqueue \n"));
            DEBUGMSG(DBG_TRACE && DBG_INIT, (DTEXT("-TCPGetConfigInfo [failure]\n")));
            return (0);
        }
        OrgTimerWheel = TimerWheel;
        (ULONG_PTR) TimerWheel = ((ULONG_PTR) TimerWheel + CACHE_LINE_SIZE) & CACHE_ALIGN_MASK;


        for (i = 0; i < NumTcbTablePartitions; i++) {
            CTEInitLock(&pTCBTableLock[i]);
            CTEInitLock(&pTWTCBTableLock[i]);
            CTEInitLock(&pSynTCBTableLock[i]);
            INITQ(&TWQueue[i])

            // Init the timer wheel
            CTEInitLock(&TimerWheel[i].tw_lock);

#ifdef  TIMER_TEST
        TimerWheel[i].tw_starttick = 0xfffff000;
#else
            TimerWheel[i].tw_starttick = 0;
#endif

            for(j = 0; j < TIMER_WHEEL_SIZE; j++) {
                INITQ(&TimerWheel[i].tw_timerslot[j])
            }
        }

        if (MaxConnections != DEFAULT_MAX_CONNECTIONS) {
            //make it even
            MaxConnBlocks = ((MaxConnections >> 1) << 1);

            //allow minimum of 1k level 1 conn blocks.
            //this gives minimum of 256K connections capability
            if (MaxConnBlocks < 1024) {
                MaxConnBlocks = 1024;
            }
        }

        ConnTable = CTEAllocMemBoot(MaxConnBlocks * sizeof(TCPConnBlock *));
        if (ConnTable == NULL) {
            ExFreePool(OrgTimerWheel);
            ExFreePool(TWQueue);
            ExFreePool(TCBTable);
            ExFreePool(TWTCBTable);
            ExFreePool(pTWTCBTableLock);
            ExFreePool(pTCBTableLock);
            ExFreePool(SYNTCBTable);
            ExFreePool(pSynTCBTableLock);
            ZwClose(keyHandle);
            KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"Could  not allocate ConnTable \n"));
            DEBUGMSG(DBG_TRACE && DBG_INIT, (DTEXT("-TCPGetConfigInfo [failure]\n")));
            return (0);
        }

        status = TCPInitializeParameter(
                                        keyHandle,
                                        L"Tcp1323Opts",
                                        &tcp1323opts
                                        );

        if (status == STATUS_SUCCESS) {

            // Check if TS  and/or WS options
            // are enabled.

            TcpHostOpts = TCP_FLAG_WS | TCP_FLAG_TS;

            if (!(tcp1323opts & TCP_FLAG_TS)) {
                TcpHostOpts &= ~TCP_FLAG_TS;
            }
            if (!(tcp1323opts & TCP_FLAG_WS)) {
                TcpHostOpts &= ~TCP_FLAG_WS;

            } else {
                MaxRcvWin = 0x3fffffff;
            }

            TcpHostSendOpts = TcpHostOpts;

        } else {
            TcpHostSendOpts = 0;
        }

        TcpHostOpts  |= TCP_FLAG_SACK;

        status = TCPInitializeParameter(
                                        keyHandle,
                                        L"SackOpts",
                                        &SackOpts
                                        );

        if (status == STATUS_SUCCESS) {
            //Check if Sack option is enabled
            //If so, set it in  global options variable

            KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"Sackopts %x\n", SackOpts));

            if (!SackOpts) {
                TcpHostOpts &= ~TCP_FLAG_SACK;
            }
        }

        TCPInitializeParameter(
                               keyHandle,
                               L"GlobalMaxTcpWindowSize",
                               &GlobalMaxRcvWin
                               );


        TCPInitializeParameter(
                               keyHandle,
                               L"SynAttackProtect",
                               (unsigned long *)&SynAttackProtect
                               );

        if (SynAttackProtect) {

            TCPInitializeParameter(
                                   keyHandle,
                                   L"TCPMaxPortsExhausted",
                                   &TCPMaxPortsExhausted
                                   );

            TCPMaxPortsExhaustedLW = MAX((TCPMaxPortsExhausted >> 1) + (TCPMaxPortsExhausted >> 2), 1);

            TCPInitializeParameter(
                                   keyHandle,
                                   L"TCPMaxHalfOpen",
                                   &TCPMaxHalfOpen
                                   );

            if (TCPMaxHalfOpen < MIN_THRESHOLD_MAX_HO) {
                TCPMaxHalfOpen = MIN_THRESHOLD_MAX_HO;
            }
            TCPInitializeParameter(
                                   keyHandle,
                                   L"TCPMaxHalfOpenRetried",
                                   &TCPMaxHalfOpenRetried
                                   );

            if ((TCPMaxHalfOpenRetried > TCPMaxHalfOpen) ||
                (TCPMaxHalfOpenRetried < MIN_THRESHOLD_MAX_HO_RETRIED)) {
                TCPMaxHalfOpenRetried = MIN_THRESHOLD_MAX_HO_RETRIED;
            }
            TCPMaxHalfOpenRetriedLW = (TCPMaxHalfOpenRetried >> 1) +
                (TCPMaxHalfOpenRetried >> 2);
        }
        //
        // If we fail, then set to same value as maxDataRexmit so that the
        // max(pptpmaxDataRexmit,maxDataRexmit) is a decent value
        // Need this since TCPInitializeParameter no longer "initializes"
        // to a default value
        //

        if (TCPInitializeParameter(keyHandle,
                                   L"PPTPTcpMaxDataRetransmissions",
                                   &pptpmaxDataRexmits) != STATUS_SUCCESS) {
            pptpmaxDataRexmits = maxDataRexmits;
        }
        if (pptpmaxDataRexmits > 255) {
            pptpmaxDataRexmits = 255;
        }

        status = TCPInitializeParameter(
                               keyHandle,
                               L"TcpUseRFC1122UrgentPointer",
                               &useRFC1122UrgentPointer
                               );

#if MILLEN
        //
        // Backwards compatibility. If TcpUseRFC1122UrgentPointer does not exist,
        // then check for BSDUrgent. These values are logical opposites.
        //
        if (!NT_SUCCESS(status)) {
            ULONG tmpBsdUrgent = TRUE;

            status = TCPInitializeParameter(
                keyHandle,
                L"BSDUrgent",
                &tmpBsdUrgent);

            if (NT_SUCCESS(status)) {
                useRFC1122UrgentPointer = !tmpBsdUrgent;
            }
        }
#endif

        if (useRFC1122UrgentPointer) {
            BSDUrgent = FALSE;
        }
        TCPInitializeParameter(
                               keyHandle,
                               L"TcpTimedWaitDelay",
                               &FinWait2TO
                               );

        if (FinWait2TO > 300) {
            FinWait2TO = 300;
        }
        FinWait2TO = MS_TO_TICKS(FinWait2TO * 1000);

        NTWMaxConnectTime = MS_TO_TICKS(NTWMaxConnectTime * 1000);

        TCPInitializeParameter(
                               keyHandle,
                               L"MaxUserPort",
                               &MaxUserPort
                               );

        if (MaxUserPort < 5000) {
            MaxUserPort = 5000;
        }
        if (MaxUserPort > 65534) {
            MaxUserPort = 65534;
        }
        GetReservedPortList(keyHandle);

        //Reserve ports if

        //
        // Read a few IP optional (hidden) registry parameters that TCP
        // cares about.
        //
        status = TCPInitializeParameter(
                               keyHandle,
                               L"EnablePMTUDiscovery",
                               &PMTUDiscovery
                               );

#if MILLEN
        //
        // Backwards compatibility. If 'EnablePMTUDiscovery' value does not exist,
        // then attempt to read legacy 'PMTUDiscovery'.
        //
        if (!NT_SUCCESS(status)) {
            TCPInitializeParameter(
                                   keyHandle,
                                   L"PMTUDiscovery",
                                   &PMTUDiscovery
                                   );
        }
#endif // MILLEN

        TCPInitializeParameter(
                               keyHandle,
                               L"EnableDeadGWDetect",
                               &DeadGWDetect
                               );

        TCPInitializeParameter(
                               keyHandle,
                               L"EnableSecurityFilters",
                               &SecurityFilteringEnabled
                               );

#ifdef ACC
        TCPInitializeParameter(
                               keyHandle,
                               L"AllowUserRawAccess",
                               &AllowUserRawAccess
                               );
#endif // ACC

        status = TCPInitializeParameter(
                                        keyHandle,
                                        L"DefaultTOSValue",
                                        &DefaultTOSValue
                                        );

#if MILLEN
        //
        // Backwards compatibility. Read 'DefaultTOS' if 'DefaultTOSValue' is
        // not present.
        //
        if (!NT_SUCCESS(status)) {
            TCPInitializeParameter(
                                   keyHandle,
                                   L"DefaultTOS",
                                   &DefaultTOSValue
                                   );
        }
#endif // MILLEN

        TCPInitializeParameter(
                               keyHandle,
                               L"DisableUserTOSSetting",
                               &DisableUserTOSSetting
                               );

        TCPInitializeParameter(
                               keyHandle,
                               L"MaxSendSegments",
                               &MaxSendSegments
                               );

        TCPInitializeParameter(
                               keyHandle,
                               L"DisableLargeSendOffload",
                               &DisableLargeSendOffload
                               );



        ZwClose(keyHandle);
    }
    MaxConnectRexmitCount = maxConnectRexmits;
    MaxConnectResponseRexmitCount = maxConnectResponseRexmits;
    MaxConnectResponseRexmitCountTmp = MaxConnectResponseRexmitCount;

    //
    // Use the greater of the two, hence both values should be valid
    //

    MaxDataRexmitCount = (maxDataRexmits > pptpmaxDataRexmits ? maxDataRexmits : pptpmaxDataRexmits);

    DEBUGMSG(DBG_TRACE && DBG_INIT, (DTEXT("-TCPGetConfigInfo [SUCCESS]\n")));
    return (1);
}

#define WORK_BUFFER_SIZE 256

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

NTSTATUS
TCPInitializeParameter(
                       HANDLE KeyHandle,
                       PWCHAR ValueName,
                       PULONG Value
                       )
/*++

Routine Description:

    Initializes a ULONG parameter from the registry or to a default
    parameter if accessing the registry value fails.

Arguments:

    KeyHandle    - An open handle to the registry key for the parameter.
    ValueName    - The UNICODE name of the registry value to read.
    Value        - The ULONG into which to put the data.
    DefaultValue - The default to assign if reading the registry fails.

Return Value:

    None.

--*/

{
    return (GetRegDWORDValue(KeyHandle, ValueName, Value));
}

VOID
GetReservedPortList(
                    NDIS_HANDLE ConfigHandle
                    )
{
    UNICODE_STRING PortList;
    PWCHAR nextRange;

    TDI_STATUS status;

    PortList.Buffer = CTEAllocMemBoot(WORK_BUFFER_SIZE * sizeof(WCHAR));

    if (!PortList.Buffer) {
        return;
    }
    PortList.Buffer[0] = UNICODE_NULL;
    PortList.Length = 0;
    PortList.MaximumLength = WORK_BUFFER_SIZE * sizeof(WCHAR);

    PortRangeList = NULL;

    if (PortList.Buffer) {

        NdisZeroMemory(PortList.Buffer, WORK_BUFFER_SIZE * sizeof(WCHAR));

        status = GetRegMultiSZValue(
                                    ConfigHandle,
                                    L"ReservedPorts",
                                    &PortList
                                    );

        if (NT_SUCCESS(status)) {

            for (nextRange = PortList.Buffer;
                 *nextRange != L'\0';
                 nextRange += wcslen(nextRange) + 1) {

                PWCHAR tmps = nextRange;
                USHORT upval = 0, loval = 0, tmpval = 0;
                BOOLEAN error = FALSE;
                ReservedPortListEntry *ListEntry;

                while (*tmps != L'\0') {
                    if (*tmps == L'-') {
                        tmps++;
                        loval = tmpval;
                        tmpval = 0;
                    }
                    if (*tmps >= L'0' && *tmps <= L'9') {
                        tmpval = tmpval * 10 + (*tmps - L'0');
                    } else {
                        error = TRUE;
                        break;
                    }
                    tmps++;
                }
                upval = tmpval;
                KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"loval %d upval %d\n", loval, upval));
                if (!error && (loval > 0) && (upval > 0) && (loval <= upval) &&
                    (upval <= MaxUserPort) && (loval <= MaxUserPort)) {

                    ListEntry = CTEAllocMemBoot(sizeof(ReservedPortListEntry));

                    if (ListEntry) {

                        //Insert this range.
                        //No need to take locks
                        //since we are at initialization.

                        ListEntry->UpperRange = upval;
                        ListEntry->LowerRange = loval;

                        ListEntry->next = PortRangeList;
                        PortRangeList = ListEntry;

                    }
                }
            }
        }
        CTEFreeMem(PortList.Buffer);

    }
}


TDI_STATUS
GetSecurityFilterList(
                      NDIS_HANDLE ConfigHandle,
                      ulong Protocol,
                      PNDIS_STRING FilterList
                      )
{
    PWCHAR parameterName;
    TDI_STATUS status;

    if (Protocol == PROTOCOL_TCP) {
        parameterName = L"TcpAllowedPorts";
    } else if (Protocol == PROTOCOL_UDP) {
        parameterName = L"UdpAllowedPorts";
    } else {
        parameterName = L"RawIpAllowedProtocols";
    }

    status = GetRegMultiSZValue(
                                ConfigHandle,
                                parameterName,
                                FilterList
                                );

    if (!NT_SUCCESS(status)) {
        FilterList->Length = 0;
    }
    return (status);
}

uint
EnumSecurityFilterValue(
                        PNDIS_STRING FilterList,
                        ulong Index,
                        ulong * FilterValue
                        )
{
    PWCHAR valueString;
    UNICODE_STRING unicodeString;
    NTSTATUS status;

    PAGED_CODE();

    valueString = EnumRegMultiSz(
                                 FilterList->Buffer,
                                 FilterList->Length,
                                 Index
                                 );

    if ((valueString == NULL) || (valueString[0] == UNICODE_NULL)) {
        return (FALSE);
    }
    RtlInitUnicodeString(&unicodeString, valueString);

    status = RtlUnicodeStringToInteger(&unicodeString, 0, FilterValue);

    if (!(NT_SUCCESS(status))) {
        TCPTRACE(("TCP: Invalid filter value %ws\n", valueString));
        return (FALSE);
    }
    return (TRUE);
}


VOID
TCPFreeupMemory()
/*++

Routine Description:

    This routine frees up the memory at the TCP layer

Arguments:

    NULL

Return Value:

    None.

--*/
{
    CTELockHandle Handle;
    PNDIS_BUFFER curTCPHeader;
    TCPConnReq *tcpConnReq;
    TCPRcvReq *tcpRcvReq;
    TCPSendReq *tcpSendReq;
    PSINGLE_LIST_ENTRY BufferLink;
    Queue *QueuePtr;
    TCPReq *ReqPtr;
    TCB *curTCB;

    //
    // Walk various lists and free assoc blocks
    //

    // DG header list
    KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"Freeing DG headers....\n"));

    MdpDestroyPool(DgHeaderPool);

    if (AddrObjTable) {
        CTEFreeMem(AddrObjTable);
    }

    PplDestroyPool(TcbPool);
    PplDestroyPool(SynTcbPool);

#ifdef ACC
    if (TcpAdminSecurityDescriptor) {
        ExFreePool(TcpAdminSecurityDescriptor);
    }
#endif

}

VOID
TCPUnload(
          IN PDRIVER_OBJECT DriverObject
          )
/*++

Routine Description:

    This routine cleans up the TCP layer.

Arguments:

    DriverObject - Pointer to driver object created by the system.

Return Value:

    None. When the function returns, the driver is unloaded.

--*/
{
    NTSTATUS status;
    uint i;

#if !MILLEN
    //
    // Deinitialize IPSEC first
    //
    status = IpsecDeinitialize();
#endif

    //
    // Shut down all timers/events
    //
    CTEInitBlockStrucEx(&TcpipUnloadBlock);
    fTCBTimerStopping = TRUE;

    for (i = 0; i < Time_Proc; i++) {
        if (!CTEStopTimer(&TCBTimer[i])) {
            KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"Could not stop TCB timer - waiting on unload event\n"));

    #if !MILLEN
            if (KeReadStateEvent(&(TcpipUnloadBlock.cbs_event))) {
                KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"Event is signaled...\n"));
            }
    #endif // !MILLEN

            (VOID) CTEBlock(&TcpipUnloadBlock);
            KeClearEvent(&TcpipUnloadBlock.cbs_event);
        }
    }
#if GPC
    //
    if (hGpcClient[GPC_CF_QOS]) {

        status = GpcEntries.GpcDeregisterClientHandler(hGpcClient[GPC_CF_QOS]);
        hGpcClient[GPC_CF_QOS] = NULL;

    }
    if (hGpcClient[GPC_CF_IPSEC]) {

        status = GpcEntries.GpcDeregisterClientHandler(hGpcClient[GPC_CF_IPSEC]);
        hGpcClient[GPC_CF_IPSEC] = NULL;

    }
    KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"Deregistering GPC\n"));

    status = GpcDeinitialize(&GpcEntries);

#endif
    //
    // Clean up all residual memory
    //
    TCPFreeupMemory();

    //
    // Deregister address notifn handler with TDI
    //
    (void)TdiDeregisterPnPHandlers(AddressChangeHandle);

    //
    // Deregister our devices with TDI
    //
    (void)TdiDeregisterDeviceObject(TCPRegistrationHandle);

    (void)TdiDeregisterDeviceObject(UDPRegistrationHandle);

    (void)TdiDeregisterDeviceObject(IPRegistrationHandle);


#if TRACE_EVENT
    //
    // Deregister with WMI
    //

    IoWMIRegistrationControl(TCPDeviceObject, WMIREG_ACTION_DEREGISTER);
#endif

    //
    // Delete devices
    //
    IoDeleteDevice(TCPDeviceObject);
    IoDeleteDevice(UDPDeviceObject);
    IoDeleteDevice(RawIPDeviceObject);
}

#if GPC

GPC_STATUS
GPCcfInfoAddNotifyIpsec(GPC_CLIENT_HANDLE ClCtxt,
                        GPC_HANDLE GpcHandle,
                        ULONG CfInfoSize,
                        PVOID CfInfo,
                        PGPC_CLIENT_HANDLE pClInfoCxt)
{
    InterlockedIncrement(&GPCcfInfo);

    IF_TCPDBG(TCP_DEBUG_GPC)
        KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"tcpip - Cfinfo Add notification %x\n", GPCcfInfo));

    InterlockedIncrement(&GpcCfCounts[GPC_CF_IPSEC]);

    IF_TCPDBG(TCP_DEBUG_GPC)
        KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"tcpip - Cfinfo Add notification IPSEC:%x\n", GpcCfCounts[GPC_CF_IPSEC]));

    return (STATUS_SUCCESS);
}

GPC_STATUS
GPCcfInfoRemoveNotifyIpsec(GPC_CLIENT_HANDLE ClCtxt,
                           GPC_CLIENT_HANDLE ClInfoCxt)
{
    InterlockedDecrement(&GPCcfInfo);

    IF_TCPDBG(TCP_DEBUG_GPC)
        KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"tcpip - Cfinfo remove notification %x\n", GPCcfInfo));

    InterlockedDecrement(&GpcCfCounts[GPC_CF_IPSEC]);

    IF_TCPDBG(TCP_DEBUG_GPC)
        KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"tcpip - Cfinfo Add notification IPSEC: %x\n", GpcCfCounts[GPC_CF_IPSEC]));

    return (STATUS_SUCCESS);
}

GPC_STATUS
GPCcfInfoAddNotifyQoS(GPC_CLIENT_HANDLE ClCtxt,
                      GPC_HANDLE GpcHandle,
                      ULONG CfInfoSize,
                      PVOID CfInfo,
                      PGPC_CLIENT_HANDLE pClInfoCxt)
{
    InterlockedIncrement(&GPCcfInfo);

    IF_TCPDBG(TCP_DEBUG_GPC)
        KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"tcpip - Cfinfo Add notification %x\n", GPCcfInfo));

    InterlockedIncrement(&GpcCfCounts[GPC_CF_QOS]);

    IF_TCPDBG(TCP_DEBUG_GPC)
        KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"tcpip - Cfinfo Add notification QOS: %x\n", GpcCfCounts[GPC_CF_QOS]));

    return (STATUS_SUCCESS);
}

GPC_STATUS
GPCcfInfoRemoveNotifyQoS(GPC_CLIENT_HANDLE ClCtxt,
                         GPC_CLIENT_HANDLE ClInfoCxt)
{
    InterlockedDecrement(&GPCcfInfo);

    IF_TCPDBG(TCP_DEBUG_GPC)
        KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"tcpip - Cfinfo remove notification %x\n", GPCcfInfo));

    InterlockedDecrement(&GpcCfCounts[GPC_CF_QOS]);

    IF_TCPDBG(TCP_DEBUG_GPC)
        KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"tcpip - Cfinfo Add notification %x\n", GpcCfCounts[GPC_CF_QOS]));

    return (STATUS_SUCCESS);
}

#endif

#if ACC

NTSTATUS
TcpBuildDeviceAcl(
                  OUT PACL * DeviceAcl
                  )
/*++

Routine Description:

    (Lifted from AFD - AfdBuildDeviceAcl)
    This routine builds an ACL which gives Administrators and LocalSystem
    principals full access. All other principals have no access.

Arguments:

    DeviceAcl - Output pointer to the new ACL.

Return Value:

    STATUS_SUCCESS or an appropriate error code.

--*/

{
    PGENERIC_MAPPING GenericMapping;
    PSID AdminsSid;
    PSID SystemSid;
    PSID NetworkSid;
    ULONG AclLength;
    NTSTATUS Status;
    ACCESS_MASK AccessMask = GENERIC_ALL;
    PACL NewAcl;

    //
    // Enable access to all the globally defined SIDs
    //

    GenericMapping = IoGetFileObjectGenericMapping();

    RtlMapGenericMask(&AccessMask, GenericMapping);

    AdminsSid = SeExports->SeAliasAdminsSid;
    SystemSid = SeExports->SeLocalSystemSid;
    NetworkSid = SeExports->SeNetworkServiceSid;

    AclLength = sizeof(ACL) +
        3 * sizeof(ACCESS_ALLOWED_ACE) +
        RtlLengthSid(AdminsSid) +
        RtlLengthSid(SystemSid) +
        RtlLengthSid(NetworkSid) -
        3 * sizeof(ULONG);

    NewAcl = CTEAllocMemBoot(AclLength);

    if (NewAcl == NULL) {
        return (STATUS_INSUFFICIENT_RESOURCES);
    }

    Status = RtlCreateAcl(NewAcl, AclLength, ACL_REVISION);
    if (!NT_SUCCESS(Status)) {
        CTEFreeMem(NewAcl);
        return (Status);
    }

    Status = RtlAddAccessAllowedAce(
                                    NewAcl,
                                    ACL_REVISION2,
                                    AccessMask,
                                    AdminsSid
                                    );

    ASSERT(NT_SUCCESS(Status));

    Status = RtlAddAccessAllowedAce(
                                    NewAcl,
                                    ACL_REVISION2,
                                    AccessMask,
                                    SystemSid
                                    );

    ASSERT(NT_SUCCESS(Status));


    // Add acl for NetworkSid!

    Status = RtlAddAccessAllowedAce(
                                    NewAcl,
                                    ACL_REVISION2,
                                    AccessMask,
                                    NetworkSid
                                    );

    ASSERT(NT_SUCCESS(Status));

    *DeviceAcl = NewAcl;

    return (STATUS_SUCCESS);

}                                // TcpBuildDeviceAcl

NTSTATUS
TcpCreateAdminSecurityDescriptor(
                                 VOID
                                 )
/*++

Routine Description:

    (Lifted from AFD - AfdCreateAdminSecurityDescriptor)
    This routine creates a security descriptor which gives access
    only to Administrtors and LocalSystem. This descriptor is used
    to access check raw endpoint opens and exclisive access to transport
    addresses.

Arguments:

    None.

Return Value:

    STATUS_SUCCESS or an appropriate error code.

--*/

{
    PACL rawAcl = NULL;
    NTSTATUS status;
    BOOLEAN memoryAllocated = FALSE;
    PSECURITY_DESCRIPTOR tcpSecurityDescriptor;
    ULONG tcpSecurityDescriptorLength;
    CHAR buffer[SECURITY_DESCRIPTOR_MIN_LENGTH];
    PSECURITY_DESCRIPTOR localSecurityDescriptor =
    (PSECURITY_DESCRIPTOR) & buffer;
    PSECURITY_DESCRIPTOR localTcpAdminSecurityDescriptor;
    SECURITY_INFORMATION securityInformation = DACL_SECURITY_INFORMATION;

    //
    // Get a pointer to the security descriptor from the TCP device object.
    //
    status = ObGetObjectSecurity(
                                 TCPDeviceObject,
                                 &tcpSecurityDescriptor,
                                 &memoryAllocated
                                 );

    if (!NT_SUCCESS(status)) {
        KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,
                 "TCP: Unable to get security descriptor, error: %x\n",
                 status
                ));
        ASSERT(memoryAllocated == FALSE);
        return (status);
    }
    //
    // Build a local security descriptor with an ACL giving only
    // administrators and system access.
    //
    status = TcpBuildDeviceAcl(&rawAcl);

    if (!NT_SUCCESS(status)) {
        KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"TCP: Unable to create Raw ACL, error: %x\n", status));
        goto error_exit;
    }
    (VOID) RtlCreateSecurityDescriptor(
                                       localSecurityDescriptor,
                                       SECURITY_DESCRIPTOR_REVISION
                                       );

    (VOID) RtlSetDaclSecurityDescriptor(
                                        localSecurityDescriptor,
                                        TRUE,
                                        rawAcl,
                                        FALSE
                                        );

    //
    // Make a copy of the TCP descriptor. This copy will be the raw descriptor.
    //
    tcpSecurityDescriptorLength = RtlLengthSecurityDescriptor(
                                                              tcpSecurityDescriptor
                                                              );

    localTcpAdminSecurityDescriptor = ExAllocatePool(
                                                     PagedPool,
                                                     tcpSecurityDescriptorLength,
                                                     );

    if (localTcpAdminSecurityDescriptor == NULL) {
        KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"TCP: couldn't allocate security descriptor\n"));
        goto error_exit;
    }
    RtlMoveMemory(
                  localTcpAdminSecurityDescriptor,
                  tcpSecurityDescriptor,
                  tcpSecurityDescriptorLength
                  );

    TcpAdminSecurityDescriptor = localTcpAdminSecurityDescriptor;

    //
    // Now apply the local descriptor to the raw descriptor.
    //
    status = SeSetSecurityDescriptorInfo(
                                         NULL,
                                         &securityInformation,
                                         localSecurityDescriptor,
                                         &TcpAdminSecurityDescriptor,
                                         PagedPool,
                                         IoGetFileObjectGenericMapping()
                                         );

    if (!NT_SUCCESS(status)) {
        KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"TCP: SeSetSecurity failed, %lx\n", status));
        ASSERT(TcpAdminSecurityDescriptor == localTcpAdminSecurityDescriptor);
        ExFreePool(TcpAdminSecurityDescriptor);
        TcpAdminSecurityDescriptor = NULL;
        goto error_exit;
    }
    if (TcpAdminSecurityDescriptor != localTcpAdminSecurityDescriptor) {
        ExFreePool(localTcpAdminSecurityDescriptor);
    }
    status = STATUS_SUCCESS;

  error_exit:

    ObReleaseObjectSecurity(
                            tcpSecurityDescriptor,
                            memoryAllocated
                            );

    if (rawAcl != NULL) {
        CTEFreeMem(rawAcl);
    }
    return (status);
}

#endif // ACC

#if !MILLEN
NTSTATUS
IpsecInitialize(
          void
          )
/*++

Routine Description:

    Initialize IPSEC.SYS.

Arguments:

    None.

Return Value:

    None.

--*/

{
    UNICODE_STRING          IPSECDeviceName;
    IPSEC_SET_TCPIP_STATUS  SetTcpipStatus;
    PIRP                    Irp;
    IO_STATUS_BLOCK         StatusBlock;
    KEVENT                  Event;
    NTSTATUS                status;

    IPSECDeviceObject = NULL;
    IPSECFileObject = NULL;

    RtlInitUnicodeString(&IPSECDeviceName, DD_IPSEC_DEVICE_NAME);

    //
    // Keep a reference to the IPSec driver so it won't unload before us.
    //
    status = IoGetDeviceObjectPointer(  &IPSECDeviceName,
                                        FILE_ALL_ACCESS,
                                        &IPSECFileObject,
                                        &IPSECDeviceObject);

    if (!NT_SUCCESS(status)) {
        IPSECFileObject = NULL;

        return (status);
    }

    SetTcpipStatus.TcpipStatus = TRUE;

    SetTcpipStatus.TcpipFreeBuff = FreeIprBuff;
    SetTcpipStatus.TcpipAllocBuff = IPAllocBuff;
    SetTcpipStatus.TcpipGetInfo = IPGetInfo;
    SetTcpipStatus.TcpipNdisRequest = IPProxyNdisRequest;
    SetTcpipStatus.TcpipSetIPSecStatus = IPSetIPSecStatus;
    SetTcpipStatus.TcpipSetIPSecPtr = SetIPSecPtr;
    SetTcpipStatus.TcpipUnSetIPSecPtr = UnSetIPSecPtr;
    SetTcpipStatus.TcpipUnSetIPSecSendPtr = UnSetIPSecSendPtr;
    SetTcpipStatus.TcpipTCPXsum = tcpxsum;

    KeInitializeEvent(&Event, SynchronizationEvent, FALSE);

    Irp = IoBuildDeviceIoControlRequest(    IOCTL_IPSEC_SET_TCPIP_STATUS,
                                            IPSECDeviceObject,
                                            &SetTcpipStatus,
                                            sizeof(IPSEC_SET_TCPIP_STATUS),
                                            NULL,
                                            0,
                                            FALSE,
                                            &Event,
                                            &StatusBlock);

    if (Irp) {
        status = IoCallDriver(IPSECDeviceObject, Irp);

        if (status == STATUS_PENDING) {
            KeWaitForSingleObject( &Event,
                                   Executive,
                                   KernelMode,
                                   FALSE,
                                   NULL);
            status = StatusBlock.Status;
        }
    } else {
        status = STATUS_INSUFFICIENT_RESOURCES;
    }

    return (status);
}

NTSTATUS
IpsecDeinitialize(
            void
            )
/*++

Routine Description:

    Deinitialize IPSEC.SYS.

Arguments:

    None.

Return Value:

    None.

--*/

{
    IPSEC_SET_TCPIP_STATUS  SetTcpipStatus;
    PIRP                    Irp;
    IO_STATUS_BLOCK         StatusBlock;
    KEVENT                  Event;
    NTSTATUS                status;

    if (!IPSECFileObject) {
        return (STATUS_SUCCESS);
    }

    RtlZeroMemory(&SetTcpipStatus, sizeof(IPSEC_SET_TCPIP_STATUS));

    KeInitializeEvent(&Event, SynchronizationEvent, FALSE);

    Irp = IoBuildDeviceIoControlRequest(    IOCTL_IPSEC_SET_TCPIP_STATUS,
                                            IPSECDeviceObject,
                                            &SetTcpipStatus,
                                            sizeof(IPSEC_SET_TCPIP_STATUS),
                                            NULL,
                                            0,
                                            FALSE,
                                            &Event,
                                            &StatusBlock);

    if (Irp) {
        status = IoCallDriver(IPSECDeviceObject, Irp);

        if (status == STATUS_PENDING) {
            KeWaitForSingleObject( &Event,
                                   Executive,
                                   KernelMode,
                                   FALSE,
                                   NULL);
            status = StatusBlock.Status;
        }
    } else {
        status = STATUS_INSUFFICIENT_RESOURCES;
    }

    ObDereferenceObject(IPSECFileObject);
    IPSECFileObject = NULL;

    return (status);
}


NTSTATUS
AddNetConfigOpsAce(IN PACL Dacl,
                  OUT PACL * DeviceAcl
                  )
/*++

Routine Description:

    This routine builds an ACL which gives adds the Network Configuration Operators group
    to the principals allowed to control the driver.

Arguments:

    Dacl - Existing DACL.
    DeviceAcl - Output pointer to the new ACL.

Return Value:

    STATUS_SUCCESS or an appropriate error code.

--*/

{
    PGENERIC_MAPPING GenericMapping;
    PSID AdminsSid = NULL;
    PSID SystemSid = NULL;
    PSID NetworkSid = NULL;
    PSID NetConfigOpsSid = NULL;
    ULONG AclLength;
    NTSTATUS Status;
    ACCESS_MASK AccessMask = GENERIC_ALL;
    PACL NewAcl = NULL;
    ULONG SidSize;
    SID_IDENTIFIER_AUTHORITY sidAuth = SECURITY_NT_AUTHORITY;
    PISID ISid;
    PACCESS_ALLOWED_ACE AceTemp;
    int i;
    //
    // Enable access to all the globally defined SIDs
    //

    GenericMapping = IoGetFileObjectGenericMapping();

    RtlMapGenericMask(&AccessMask, GenericMapping);

    AdminsSid = SeExports->SeAliasAdminsSid;
    SystemSid = SeExports->SeLocalSystemSid;
    NetworkSid = SeExports->SeNetworkServiceSid;


    SidSize = RtlLengthRequiredSid(3);
    NetConfigOpsSid = (PSID)(CTEAllocMemBoot(SidSize));

    if (NULL == NetConfigOpsSid) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    Status = RtlInitializeSid(NetConfigOpsSid, &sidAuth, 2);
    if (Status != STATUS_SUCCESS) {
        goto clean_up;
    }

    ISid = (PISID)(NetConfigOpsSid);
    ISid->SubAuthority[0] = SECURITY_BUILTIN_DOMAIN_RID;
    ISid->SubAuthority[1] = DOMAIN_ALIAS_RID_NETWORK_CONFIGURATION_OPS;

    AclLength = Dacl->AclSize;

    AclLength += sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE) - 2 * sizeof(ULONG);

    AclLength += RtlLengthSid(NetConfigOpsSid);

    NewAcl = CTEAllocMemBoot(AclLength);

    if (NewAcl == NULL) {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto clean_up;
    }

    Status = RtlCreateAcl(NewAcl, AclLength, ACL_REVISION2);

    if (!NT_SUCCESS(Status)) {
        goto clean_up;
    }

    for (i = 0; i < Dacl->AceCount; i++) {
        Status = RtlGetAce(Dacl, i, &AceTemp);

        if (NT_SUCCESS(Status)) {

            Status = RtlAddAccessAllowedAce(NewAcl,
                                            ACL_REVISION2,
                                            AceTemp->Mask,
                                            &AceTemp->SidStart);
        }

        if (!NT_SUCCESS(Status)) {
            goto clean_up;
        }
    }

    // Add Net Config Operators Ace
    Status = RtlAddAccessAllowedAce(NewAcl,
                                    ACL_REVISION2,
                                    AccessMask,
                                    NetConfigOpsSid);

    if (!NT_SUCCESS(Status)) {
        goto clean_up;
    }

    *DeviceAcl = NewAcl;

clean_up:
    if (NetConfigOpsSid) {
        CTEFreeMem(NetConfigOpsSid);
    }
    if (!NT_SUCCESS(Status) && NewAcl) {
        CTEFreeMem(NewAcl);
    }

    return (Status);
}


NTSTATUS
CreateDeviceDriverSecurityDescriptor(PVOID DeviceOrDriverObject)

/*++

Routine Description:

    Creates the SD responsible for giving access to different users.

Arguments:

    DeviceOrDriverObject - Object to which to assign the Access Rights.

Return Value:

    STATUS_SUCCESS or an appropriate error code.

--*/

{
    NTSTATUS status;
    BOOLEAN memoryAllocated = FALSE;
    PSECURITY_DESCRIPTOR SecurityDescriptor = NULL;
    ULONG SecurityDescriptorLength;
    CHAR buffer[SECURITY_DESCRIPTOR_MIN_LENGTH];
    PSECURITY_DESCRIPTOR localSecurityDescriptor =
    (PSECURITY_DESCRIPTOR) & buffer;
    SECURITY_INFORMATION securityInformation = DACL_SECURITY_INFORMATION;
    PACL Dacl = NULL;
    BOOLEAN HasDacl = FALSE;
    BOOLEAN DaclDefaulted = FALSE;
    PACL NewAcl = NULL;
    INT i;

    //
    // Get a pointer to the security descriptor from the driver/device object.
    //

    status = ObGetObjectSecurity(
                                 DeviceOrDriverObject,
                                 &SecurityDescriptor,
                                 &memoryAllocated
                                 );

    if (!NT_SUCCESS(status)) {
        KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,
                 "TCP: Unable to get security descriptor, error: %x\n",
                 status
                ));
        ASSERT(memoryAllocated == FALSE);
        return (status);
    }

    status = RtlGetDaclSecurityDescriptor(SecurityDescriptor, &HasDacl, &Dacl, &DaclDefaulted);

    if (NT_SUCCESS(status) && HasDacl)
    {
        status = AddNetConfigOpsAce(Dacl, &NewAcl);

        if (NT_SUCCESS(status)) {

            PSECURITY_DESCRIPTOR SecDesc = NULL;
            ULONG SecDescSize = 0;
            PACL AbsDacl = NULL;
            ULONG DaclSize = 0;
            PACL AbsSacl = NULL;
            ULONG ulSacl = 0;
            PSID Owner = NULL;
            ULONG OwnerSize = 0;
            PSID PrimaryGroup = NULL;
            ULONG PrimaryGroupSize = 0;
            BOOLEAN OwnerDefault = FALSE;
            BOOLEAN GroupDefault = FALSE;
            BOOLEAN HasSacl = FALSE;
            BOOLEAN SaclDefaulted = FALSE;

            SECURITY_INFORMATION secInfo = OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION;

            SecDescSize = sizeof(SecDesc) + NewAcl->AclSize;
            SecDesc = CTEAllocMemBoot(SecDescSize);

            if (SecDesc) {
                DaclSize = NewAcl->AclSize;
                AbsDacl = CTEAllocMemBoot(DaclSize);

                if (AbsDacl) {
                    status = RtlGetOwnerSecurityDescriptor(SecurityDescriptor, &Owner, &OwnerDefault);

                    if (NT_SUCCESS(status)) {
                        OwnerSize = RtlLengthSid(Owner);

                        status = RtlGetGroupSecurityDescriptor(SecurityDescriptor, &PrimaryGroup, &GroupDefault);

                        if (NT_SUCCESS(status)) {
                            PrimaryGroupSize = RtlLengthSid(PrimaryGroup);

                            status = RtlGetSaclSecurityDescriptor(SecurityDescriptor, &HasSacl, &AbsSacl, &SaclDefaulted);

                            if (NT_SUCCESS(status)) {

                                if (HasSacl) {
                                    ulSacl = AbsSacl->AclSize;
                                    secInfo |= SACL_SECURITY_INFORMATION;
                                }

                                status = RtlSelfRelativeToAbsoluteSD(SecurityDescriptor, SecDesc, &SecDescSize, AbsDacl,
                                                            &DaclSize, AbsSacl, &ulSacl, Owner, &OwnerSize, PrimaryGroup, &PrimaryGroupSize);

                                if (NT_SUCCESS(status)) {
                                    status = RtlSetDaclSecurityDescriptor(SecDesc, TRUE, NewAcl, FALSE);

                                    if (NT_SUCCESS(status)) {
                                        status = ObSetSecurityObjectByPointer(DeviceOrDriverObject, secInfo, SecDesc);
                                    }
                                }
                            }
                        }

                    } else {
                        status = STATUS_INSUFFICIENT_RESOURCES;
                    }
                } else {
                    status = STATUS_INSUFFICIENT_RESOURCES;
                }

                if (SecDesc) {
                    // Since this is a Self-Relative security descriptor, freeing it also frees
                    // Owner and PrimaryGroup.
                    CTEFreeMem(SecDesc);
                }

                if (AbsDacl) {
                    CTEFreeMem(AbsDacl);
                }
            }

            if (NewAcl) {
                CTEFreeMem(NewAcl);
            }

        }
    } else {
        KdPrintEx((DPFLTR_TCPIP_ID, DPFLTR_INFO_LEVEL,"TCP: No Dacl: %x\n", status));
    }

    ObReleaseObjectSecurity(
                            SecurityDescriptor,
                            memoryAllocated
                            );
    return (status);
}


//
// Function:    IsRunningOnPersonal
//
// Purpose:     Determines whether running on Whistler Personal
//
// Returns:     Returns true if running on Personal - FALSE otherwise
BOOLEAN
IsRunningOnPersonal(
    VOID
    )
{
    OSVERSIONINFOEXW OsVer = {0};
    ULONGLONG ConditionMask = 0;
    BOOLEAN IsPersonal = TRUE;

    OsVer.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
    OsVer.wSuiteMask = VER_SUITE_PERSONAL;
    OsVer.wProductType = VER_NT_WORKSTATION;

    VER_SET_CONDITION(ConditionMask, VER_PRODUCT_TYPE, VER_EQUAL);
    VER_SET_CONDITION(ConditionMask, VER_SUITENAME, VER_AND);

    if (RtlVerifyVersionInfo(&OsVer, VER_PRODUCT_TYPE | VER_SUITENAME,
        ConditionMask) == STATUS_REVISION_MISMATCH) {
        IsPersonal = FALSE;
    }

    return IsPersonal;
}


#endif