archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 7b07a90fc1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7b07a90fc1'
${ noResults }
windows-server-2003/net/http/sys/init.c

2814 lines
78 KiB
Raw Blame History

/*++
Copyright (c) 1998-2002 Microsoft Corporation
Module Name:
init.c
Abstract:
This module performs initialization for the UL device driver.
Author:
Keith Moore (keithmo) 10-Jun-1998
Revision History:
--*/
#include "precomp.h"
PDRIVER_OBJECT g_UlDriverObject = NULL;
//
// Private constants.
//
#define DEFAULT_THREAD_AFFINITY_MASK ((1ui64 << KeNumberProcessors) - 1)
//
// Private types.
//
//
// Private prototypes.
//
NTSTATUS
UlpApplySecurityToDeviceObjects(
VOID
);
NTSTATUS
UlpSetDeviceObjectSecurity(
IN PDEVICE_OBJECT pDeviceObject,
IN SECURITY_INFORMATION SecurityInformation,
IN PSECURITY_DESCRIPTOR pSecurityDescriptor
);
ULONG
UlpReadUrlC14nConfig(
HANDLE parametersHandle
);
VOID
UlpReadErrorLogConfig(
HANDLE parametersHandle
);
VOID
UlpReadRegistry (
IN PUL_CONFIG pConfig
);
VOID
UlpTerminateModules(
VOID
);
VOID
UlpUnload (
IN PDRIVER_OBJECT DriverObject
);
//
// Private globals.
//
#if DBG
ULONG g_UlpForceInitFailure = 0;
#endif // DBG
#ifdef ALLOC_PRAGMA
#pragma alloc_text( INIT, DriverEntry )
#pragma alloc_text( INIT, UlpApplySecurityToDeviceObjects )
#pragma alloc_text( INIT, UlpSetDeviceObjectSecurity )
#pragma alloc_text( INIT, UlpReadUrlC14nConfig )
#pragma alloc_text( INIT, UlpReadRegistry )
#pragma alloc_text( INIT, UlpReadErrorLogConfig )
#pragma alloc_text( PAGE, UlpUnload )
#pragma alloc_text( PAGE, UlpTerminateModules )
//
// Note that UlpTerminateModules() must be "page" if driver unloading
// is enabled (it's called from UlpUnload), but can be "init" otherwise
// (it's only called after initialization failure).
//
#pragma alloc_text( PAGE, UlpTerminateModules )
#endif // ALLOC_PRAGMA
//
// Public functions.
//
/***************************************************************************++
Routine Description:
This is the initialization routine for the UL device driver.
Arguments:
DriverObject - Supplies a pointer to driver object created by the
system.
RegistryPath - Supplies the name of the driver's configuration
registry tree.
Return Value:
NTSTATUS - Completion status.
--***************************************************************************/
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
{
NTSTATUS status;
UNICODE_STRING deviceName;
OBJECT_ATTRIBUTES objectAttributes;
UL_CONFIG config;
SYSTEM_BASIC_INFORMATION sbi;
UNREFERENCED_PARAMETER(RegistryPath);
//
// Sanity check.
//
PAGED_CODE();
g_UlDriverObject = DriverObject;
//
// Grab the number of processors in the system.
//
g_UlNumberOfProcessors = KeNumberProcessors;
g_UlThreadAffinityMask = DEFAULT_THREAD_AFFINITY_MASK;
//
// Grab the largest cache line size in the system
//
g_UlCacheLineSize = KeGetRecommendedSharedDataAlignment();
for (g_UlCacheLineBits = 0;
(1U << g_UlCacheLineBits) < g_UlCacheLineSize;
++g_UlCacheLineBits)
{}
ASSERT(g_UlCacheLineSize <= (1U << g_UlCacheLineBits));
status = NtQuerySystemInformation(
SystemBasicInformation,
&sbi,
sizeof(sbi),
NULL);
ASSERT(NT_SUCCESS(status));
//
// Capture total physical memory, in terms of megabytes.
//
g_UlTotalPhysicalMemMB = PAGES_TO_MEGABYTES(sbi.NumberOfPhysicalPages);
//
// Estimate the total number of NPP available in bytes since Landy
// doesn't want to export MmSizeOfNonPagedPoolInBytes.
//
// CODEWORK: Whenever we have a mechanism for discovering the
// NonPagedPool size, use that instead of the total physical
// RAM on the system.
//
#if defined(_WIN64)
//
// On IA64, assume NPP can be 50% of total physical memory.
//
g_UlTotalNonPagedPoolBytes = MEGABYTES_TO_BYTES(g_UlTotalPhysicalMemMB/2);
#else
//
// On X86, assume NPP is either 50% of total physical memory or 256MB,
// whichever is less.
//
g_UlTotalNonPagedPoolBytes = MEGABYTES_TO_BYTES(
MIN(256, g_UlTotalPhysicalMemMB/2)
);
#endif
//
// Snag a pointer to the system process.
//
g_pUlSystemProcess = (PKPROCESS)IoGetCurrentProcess();
//
// Temporarily initialize the IS_HTTP_*() macros.
// Will be initialized properly by InitializeHttpUtil() later.
//
HttpCmnInitializeHttpCharsTable(FALSE);
//
// Read registry information.
//
UlpReadRegistry( &config );
#if DBG
//
// Give anyone using the kernel debugger a chance to abort
// initialization.
//
if (g_UlpForceInitFailure != 0)
{
status = STATUS_UNSUCCESSFUL;
goto fatal;
}
#endif // DBG
//
// Initialize the global trace logs.
//
CREATE_REF_TRACE_LOG( g_pMondoGlobalTraceLog,
16384 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pPoolAllocTraceLog,
16384 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pUriTraceLog,
2048 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pTdiTraceLog,
32768 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pHttpRequestTraceLog,
2048 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pHttpConnectionTraceLog,
2048 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pHttpResponseTraceLog,
2048 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pAppPoolTraceLog,
2048 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pAppPoolProcessTraceLog,
2048 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pConfigGroupTraceLog,
2048 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pControlChannelTraceLog,
2048 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pThreadTraceLog,
16384 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pMdlTraceLog,
2048 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pFilterTraceLog,
2048 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pSiteCounterTraceLog,
2048 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pConnectionCountTraceLog,
2048 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pConfigGroupInfoTraceLog,
2048 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pChunkTrackerTraceLog,
2048 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pWorkItemTraceLog,
32768 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_REF_TRACE_LOG( g_pEndpointUsageTraceLog,
16384 - REF_TRACE_OVERHEAD,
0, TRACELOG_HIGH_PRIORITY,
UL_REF_TRACE_LOG_POOL_TAG );
CREATE_IRP_TRACE_LOG( g_pIrpTraceLog,
32768 - REF_TRACE_OVERHEAD, 0 );
CREATE_TIME_TRACE_LOG( g_pTimeTraceLog,
32768 - REF_TRACE_OVERHEAD, 0 );
CREATE_APP_POOL_TIME_TRACE_LOG( g_pAppPoolTimeTraceLog,
32768 - REF_TRACE_OVERHEAD, 0 );
CREATE_STRING_LOG( g_pGlobalStringLog, 5 * 1024 * 1024, 0, FALSE );
CREATE_UC_TRACE_LOG( g_pUcTraceLog,
16384 - REF_TRACE_OVERHEAD, 0 );
//
// Create an object directory to contain our device objects.
//
status = UlInitUnicodeStringEx( &deviceName, HTTP_DIRECTORY_NAME );
if (!NT_SUCCESS(status))
{
goto fatal;
}
InitializeObjectAttributes(
&objectAttributes, // ObjectAttributes
&deviceName, // ObjectName
OBJ_CASE_INSENSITIVE | // Attributes
OBJ_KERNEL_HANDLE,
NULL, // RootDirectory
NULL // SecurityDescriptor
);
status = ZwCreateDirectoryObject(
&g_UlDirectoryObject, // DirectoryHandle
DIRECTORY_ALL_ACCESS, // AccessMask
&objectAttributes // ObjectAttributes
);
if (!NT_SUCCESS(status))
{
goto fatal;
}
//
// Create the control channel device object.
//
status = UlInitUnicodeStringEx( &deviceName, HTTP_CONTROL_DEVICE_NAME );
if (!NT_SUCCESS(status))
{
goto fatal;
}
status = IoCreateDevice(
DriverObject, // DriverObject
0, // DeviceExtension
&deviceName, // DeviceName
FILE_DEVICE_NETWORK, // DeviceType
0, // DeviceCharacteristics
FALSE, // Exclusive
&g_pUlControlDeviceObject // DeviceObject
);
if (!NT_SUCCESS(status))
{
goto fatal;
}
//
// Create the filter device object.
//
status = UlInitUnicodeStringEx( &deviceName, HTTP_FILTER_DEVICE_NAME );
if (!NT_SUCCESS(status))
{
goto fatal;
}
status = IoCreateDevice(
DriverObject, // DriverObject
0, // DeviceExtension
&deviceName, // DeviceName
FILE_DEVICE_NETWORK, // DeviceType
0, // DeviceCharacteristics
FALSE, // Exclusive
&g_pUlFilterDeviceObject // DeviceObject
);
if (!NT_SUCCESS(status))
{
goto fatal;
}
g_pUlFilterDeviceObject->StackSize = DEFAULT_IRP_STACK_SIZE;
//
// Create the app pool device object.
//
status = UlInitUnicodeStringEx( &deviceName, HTTP_APP_POOL_DEVICE_NAME );
if (!NT_SUCCESS(status))
{
goto fatal;
}
status = IoCreateDevice(
DriverObject, // DriverObject
0, // DeviceExtension
&deviceName, // DeviceName
FILE_DEVICE_NETWORK, // DeviceType
0, // DeviceCharacteristics
FALSE, // Exclusive
&g_pUlAppPoolDeviceObject // DeviceObject
);
if (!NT_SUCCESS(status))
{
goto fatal;
}
g_pUlAppPoolDeviceObject->StackSize = DEFAULT_IRP_STACK_SIZE;
//
// Initialize the driver object with this driver's entrypoints.
//
DriverObject->MajorFunction[IRP_MJ_CREATE] = &UlCreate;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = &UlClose;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = &UlCleanup;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = &UlDeviceControl;
DriverObject->MajorFunction[IRP_MJ_QUERY_SECURITY] = &UlQuerySecurityDispatch;
DriverObject->MajorFunction[IRP_MJ_SET_SECURITY] = &UlSetSecurityDispatch;
DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = &UlEtwDispatch;
DriverObject->FastIoDispatch = &UlFastIoDispatch;
DriverObject->DriverUnload = NULL;
//
// Initialize global data.
//
status = UlInitializeData(&config);
if (!NT_SUCCESS(status))
{
goto fatal;
}
//
// Create the thread pool.
//
status = UlInitializeThreadPool(config.ThreadsPerCpu);
if (!NT_SUCCESS(status))
{
goto fatal;
}
//
// Initialize common TDI code.
//
status = UxInitializeTdi();
if (!NT_SUCCESS(status))
{
goto fatal;
}
//
// Initialize server connection code.
//
status = UlInitializeTdi();
if (!NT_SUCCESS(status))
{
goto fatal;
}
//
// Initialize George.
//
status = UlLargeMemInitialize();
if (!NT_SUCCESS(status))
{
goto fatal;
}
//
// Initialize Keith.
//
status = UlInitializeControlChannel();
if (!NT_SUCCESS(status))
{
goto fatal;
}
//
// Initialize Henry.
//
status = InitializeHttpUtil();
if (!NT_SUCCESS(status))
{
goto fatal;
}
status = InitializeParser();
if (!NT_SUCCESS(status))
{
goto fatal;
}
status = UlInitializeOpaqueIdTable();
if (!NT_SUCCESS(status))
{
goto fatal;
}
status = InitializeFileCache();
if (!NT_SUCCESS(status))
{
goto fatal;
}
//
// Initialize Michael.
//
status = UlInitializeFilterChannel(&config);
if (!NT_SUCCESS(status))
{
goto fatal;
}
//
// Initialize Alex.
//
status = UlInitializeUriCache(&config);
if (!NT_SUCCESS(status))
{
goto fatal;
}
status = UlInitializeDateCache();
if (!NT_SUCCESS(status))
{
goto fatal;
}
//
// Initialize Paul.
//
status = UlInitializeCG();
if (!NT_SUCCESS(status))
{
goto fatal;
}
status = UlInitializeAP();
if (!NT_SUCCESS(status))
{
goto fatal;
}
//
// Initialize Ali
//
status = UlInitializeLogUtil();
if (!NT_SUCCESS(status))
{
goto fatal;
}
status = UlInitializeLogs();
if (!NT_SUCCESS(status))
{
goto fatal;
}
status = UlInitializeBinaryLog();
if (!NT_SUCCESS(status))
{
goto fatal;
}
status = UlInitializeErrorLog();
if (!NT_SUCCESS(status))
{
goto fatal;
}
status = UlTcInitialize();
if (!NT_SUCCESS(status))
{
goto fatal;
}
status = UlInitGlobalConnectionLimits();
if (!NT_SUCCESS(status))
{
goto fatal;
}
status = UlInitializeHttpConnection();
if (!NT_SUCCESS(status))
{
goto fatal;
}
//
// Initialize Eric.
//
status = UlInitializeCounters();
if (!NT_SUCCESS(status))
{
goto fatal;
}
UlInitializeTimeoutMonitor();
//
// Initialize ETW Tracing
//
UlEtwInitLog( g_pUlControlDeviceObject );
//
// Initialize HTTP client
//
if(config.EnableHttpClient)
{
//
// All of the client code live under a "section" called PAGEUC. This
// section is paged by default & gets locked down when there is an app
// that uses the client APIs (specifically, opens a handle to a server).
//
// There are two ways of demand locking this section. We can either use
// MmLockPagableCodeSection or MmLockPagableSectionByHandle. It's a lot
// cheaper to use MmLockPagableSectionByHandle.
//
// So, during our DriverEntry, we first lock the entire PAGEUC section
// to obtain the handle. We then immediately unlock it, but remember
// the handle. This allows us to use MmLockPagableSectionByHandle for
// subsequent locks, which is much faster.
//
// In order to use MmLockPagableCodeSection, we'll pick one function
// that lives under this section --> UcpTdiReceiveHandler
//
g_ClientImageHandle =
MmLockPagableCodeSection((PVOID)((ULONG_PTR)UcpTdiReceiveHandler));
MmUnlockPagableImageSection(g_ClientImageHandle);
//
// Create the server device object
//
status = UlInitUnicodeStringEx(&deviceName, HTTP_SERVER_DEVICE_NAME);
if(!NT_SUCCESS(status))
{
goto fatal;
}
status = IoCreateDevice(DriverObject,
0,
&deviceName,
FILE_DEVICE_NETWORK,
0,
FALSE,
&g_pUcServerDeviceObject
);
if(!NT_SUCCESS(status))
{
goto fatal;
}
g_pUcServerDeviceObject->StackSize ++;
//
// Initialize the client connection code.
//
status = UcInitializeServerInformation();
if(!NT_SUCCESS(status))
{
goto fatal;
}
status = UcInitializeClientConnections();
if(!NT_SUCCESS(status))
{
goto fatal;
}
status = UcInitializeSSPI();
if(!NT_SUCCESS(status))
{
goto fatal;
}
status = UcInitializeHttpRequests();
if (!NT_SUCCESS(status))
{
goto fatal;
}
}
else
{
// Disable all the client IOCTLs.
UlSetDummyIoctls();
}
//
// Apply security to the device objects.
//
status = UlpApplySecurityToDeviceObjects();
if (!NT_SUCCESS(status))
{
goto fatal;
}
//
// Initialize Namespace.
// Note: This initialization must be done after
// UlpApplySecurityToDeviceObjects() has been called.
// Otherwise, g_pAdminAllSystemAll will not be initialzied.
// UlInitializeNamespace() uses that global security descriptor.
//
status = UlInitializeNamespace();
if (!NT_SUCCESS(status))
{
goto fatal;
}
#if DBG
//
// Give anyone using the kernel debugger one final chance to abort
// initialization.
//
if (g_UlpForceInitFailure != 0)
{
status = STATUS_UNSUCCESSFUL;
goto fatal;
}
#endif // DBG
//
// Set DriverUnload only after everything has succeeded to synchronize
// DriverEntry and DriverUnload. In theory however, the DriverUnload
// routine can still be called once we set it, but that can't be fixed
// by the drivers, it needs to be fixed by IO or SCM.
//
DriverObject->DriverUnload = &UlpUnload;
return STATUS_SUCCESS;
//
// Fatal error handlers.
//
fatal:
ASSERT( !NT_SUCCESS(status) );
UlpTerminateModules();
return status;
} // DriverEntry
//
// Private functions.
//
/***************************************************************************++
Routine Description:
Applies the appropriate security descriptors to the global device
objects created at initialization time.
Return Value:
NTSTATUS - Completion status.
--***************************************************************************/
NTSTATUS
UlpApplySecurityToDeviceObjects(
VOID
)
{
NTSTATUS status;
SECURITY_DESCRIPTOR securityDescriptor;
PGENERIC_MAPPING pFileObjectGenericMapping;
ACCESS_MASK fileReadWrite;
ACCESS_MASK fileAll;
SID_MASK_PAIR sidMaskPairs[4];
//
// Sanity check.
//
PAGED_CODE();
ASSERT( IS_VALID_DEVICE_OBJECT( g_pUlControlDeviceObject ) );
ASSERT( IS_VALID_DEVICE_OBJECT( g_pUlFilterDeviceObject ) );
ASSERT( IS_VALID_DEVICE_OBJECT( g_pUlAppPoolDeviceObject ) );
//
// Gain access to the predefined SIDs and other security-related
// goodies exported by the kernel.
//
//SeEnableAccessToExports();
//
// Map a couple of generic file access types to their corresponding
// object-specific rights.
//
pFileObjectGenericMapping = IoGetFileObjectGenericMapping();
ASSERT( pFileObjectGenericMapping != NULL );
//
// FILE_READ & FILE_WRITE
//
fileReadWrite = GENERIC_READ | GENERIC_WRITE;
RtlMapGenericMask(
&fileReadWrite,
pFileObjectGenericMapping
);
//
// FILE_ALL
//
fileAll = GENERIC_ALL;
RtlMapGenericMask(
&fileAll,
pFileObjectGenericMapping
);
//
// Build a restrictive security descriptor for the filter device
// object:
//
// Full access for NT AUTHORITY\SYSTEM
// Full access for BUILTIN\Administrators
//
sidMaskPairs[0].pSid = SeExports->SeLocalSystemSid;
sidMaskPairs[0].AccessMask = fileAll;
sidMaskPairs[0].AceFlags = 0;
sidMaskPairs[1].pSid = SeExports->SeAliasAdminsSid;
sidMaskPairs[1].AccessMask = fileAll;
sidMaskPairs[1].AceFlags = 0;
status = UlCreateSecurityDescriptor(
&securityDescriptor, // pSecurityDescriptor
&sidMaskPairs[0], // pSidMaskPairs
2 // NumSidMaskPairs
);
if (!NT_SUCCESS(status))
{
return status;
}
//
// Filter object
//
status = UlpSetDeviceObjectSecurity(
g_pUlFilterDeviceObject,
DACL_SECURITY_INFORMATION,
&securityDescriptor
);
UlCleanupSecurityDescriptor(&securityDescriptor);
if (!NT_SUCCESS(status))
{
return status;
}
//
// We want a global security descriptor that allows fileAll to
// System and Administrators and nothing else for world. Incidently,
// the filter device object provides this exact feature. We'll save
// a pointer to this security descriptor.
//
// WARNING: If we ever change the ACL on the Filter Device Object, we'll
// have to create a new security descriptor for this.
//
//
g_pAdminAllSystemAll = g_pUlFilterDeviceObject->SecurityDescriptor;
//
// Build a slightly less restrictive security descriptor for the
// other device objects.
//
// Full access for NT AUTHORITY\SYSTEM
// Full access for BUILTIN\Administrators
// Read/Write access for Authenticated users
// Read/Write access for Guest.
//
sidMaskPairs[2].pSid = SeExports->SeAuthenticatedUsersSid;
sidMaskPairs[2].AccessMask = fileReadWrite;
sidMaskPairs[2].AceFlags = 0;
sidMaskPairs[3].pSid = SeExports->SeAliasGuestsSid;
sidMaskPairs[3].AccessMask = fileReadWrite;
sidMaskPairs[3].AceFlags = 0;
status = UlCreateSecurityDescriptor(
&securityDescriptor,
&sidMaskPairs[0], // pSidMaskPairs
4 // NumSidMaskPairs
);
if (!NT_SUCCESS(status))
{
return status;
}
for(;;)
{
//
// App Pool
//
status = UlpSetDeviceObjectSecurity(
g_pUlAppPoolDeviceObject,
DACL_SECURITY_INFORMATION,
&securityDescriptor
);
if (!NT_SUCCESS(status))
{
break;
}
//
// Control Channel
//
status = UlpSetDeviceObjectSecurity(
g_pUlControlDeviceObject,
DACL_SECURITY_INFORMATION,
&securityDescriptor
);
if (!NT_SUCCESS(status))
{
break;
}
//
// Server
//
if(g_pUcServerDeviceObject)
{
status = UlpSetDeviceObjectSecurity(
g_pUcServerDeviceObject,
DACL_SECURITY_INFORMATION,
&securityDescriptor
);
}
break;
}
UlCleanupSecurityDescriptor(&securityDescriptor);
return status;
} // UlpApplySecurityToDeviceObjects
/***************************************************************************++
Routine Description:
Applies the specified security descriptor to the specified device
object.
Arguments:
pDeviceObject - Supplies the device object to manipulate.
SecurityInformation - Supplies the level of information to change.
pSecurityDescriptor - Supplies the new security descriptor for the
device object.
Return Value:
NTSTATUS - Completion status.
--***************************************************************************/
NTSTATUS
UlpSetDeviceObjectSecurity(
IN PDEVICE_OBJECT pDeviceObject,
IN SECURITY_INFORMATION SecurityInformation,
IN PSECURITY_DESCRIPTOR pSecurityDescriptor
)
{
NTSTATUS status;
HANDLE handle;
//
// Sanity check.
//
PAGED_CODE();
ASSERT( IS_VALID_DEVICE_OBJECT( pDeviceObject ) );
ASSERT( RtlValidSecurityDescriptor( pSecurityDescriptor ) );
//
// Open a handle to the device object.
//
status = ObOpenObjectByPointer(
pDeviceObject, // Object
OBJ_CASE_INSENSITIVE | // HandleAttributes
OBJ_KERNEL_HANDLE,
NULL, // PassedAccessState
MAXIMUM_ALLOWED, // DesiredAccess
NULL, // ObjectType
KernelMode, // AccessMode
&handle // Handle
);
if (NT_SUCCESS(status))
{
status = NtSetSecurityObject(
handle, // Handle
SecurityInformation, // SecurityInformation
pSecurityDescriptor // SecurityDescriptor
);
ZwClose( handle );
}
return status;
} // UlpSetDeviceObjectSecurity
//
// Read URL processing parameters.
//
ULONG
UlpReadUrlC14nConfig(
HANDLE parametersHandle
)
{
LONG tmp;
LONG DefaultBoolRegValue = -123; // sane values are 0 and 1
LONG EnableDbcs;
LONG FavorUtf8;
LONG EnableNonUtf8 ;
LONG PercentUAllowed ;
LONG AllowRestrictedChars ;
LONG UrlSegmentMaxLength;
LONG UrlSegmentMaxCount;
NTSTATUS status;
UNICODE_STRING registryPathNLS;
HANDLE codePageHandle;
UNICODE_STRING ACPCodeString;
ULONG ACPCode = 0;
PKEY_VALUE_PARTIAL_INFORMATION pInfo;
//
// Tune defaults based on whether we are running on a DBCS system.
// Since we do not have a convenient API to do so, use this algorithm:
//
// 1- Get ACP from the registry at:
// HKLM\System\CurrentControlSet\Control\NLS\CodePage
// 2- check against the list of DBCS in:
// http://www.microsoft.com/globaldev/reference/WinCP.asp
//
// TODO - use kernel mode API when provided.
//
EnableDbcs = FALSE;
status = UlInitUnicodeStringEx(&registryPathNLS, REGISTRY_NLS_PATH);
if(NT_SUCCESS(status))
{
status = UlOpenRegistry(
&registryPathNLS,
&codePageHandle,
REGISTRY_NLS_CODEPAGE_KEY
);
if (NT_SUCCESS(status))
{
pInfo = NULL;
status = UlReadGenericParameter(
codePageHandle,
REGISTRY_ACP_NAME,
&pInfo
);
if (NT_SUCCESS(status))
{
ASSERT(pInfo);
if (pInfo->Type == REG_SZ)
{
status = UlInitUnicodeStringEx(
&ACPCodeString,
(PWSTR)pInfo->Data
);
if (NT_SUCCESS(status))
{
status = HttpWideStringToULong(
ACPCodeString.Buffer,
ACPCodeString.Length / sizeof(WCHAR),
FALSE,
10,
NULL,
&ACPCode
);
if (NT_SUCCESS(status))
{
//
// Check if this is one of the known DBCS codes:
//
if ((ACPCode == CP_JAPANESE_SHIFT_JIS) ||
(ACPCode == CP_SIMPLIFIED_CHINESE_GBK) ||
(ACPCode == CP_KOREAN) ||
(ACPCode == CP_TRADITIONAL_CHINESE_BIG5))
{
EnableDbcs = TRUE;
}
else
{
EnableDbcs = FALSE;
}
}
}
}
//
// Free up the returned value.
//
UL_FREE_POOL( pInfo, UL_REGISTRY_DATA_POOL_TAG );
}
ZwClose( codePageHandle );
}
}
//
// Now check if we have registry overrides for each of these.
//
EnableNonUtf8 = UlReadLongParameter(
parametersHandle,
REGISTRY_ENABLE_NON_UTF8_URL,
DefaultBoolRegValue);
if (EnableNonUtf8 != DefaultBoolRegValue)
{
//
// A registry setting is present; use it.
//
EnableNonUtf8 = (BOOLEAN) (EnableNonUtf8 != 0);
}
else
{
EnableNonUtf8 = DEFAULT_ENABLE_NON_UTF8_URL;
}
if (EnableNonUtf8)
{
FavorUtf8 = UlReadLongParameter(
parametersHandle,
REGISTRY_FAVOR_UTF8_URL,
DefaultBoolRegValue
);
if (FavorUtf8 != DefaultBoolRegValue)
{
//
// A registry setting is present; use it.
//
FavorUtf8 = (BOOLEAN) (FavorUtf8 != 0);
}
else
{
FavorUtf8 = DEFAULT_FAVOR_UTF8_URL;
}
}
else
{
//
// We can't do DBCS or favor UTF-8 if we accept UTF-8 only.
//
EnableDbcs = FALSE;
FavorUtf8 = FALSE;
}
PercentUAllowed = UlReadLongParameter(
parametersHandle,
REGISTRY_PERCENT_U_ALLOWED,
DefaultBoolRegValue);
if (PercentUAllowed != DefaultBoolRegValue)
{
//
// A registry setting is present; use it.
//
PercentUAllowed = (BOOLEAN) (PercentUAllowed != 0);
}
else
{
PercentUAllowed = DEFAULT_PERCENT_U_ALLOWED;
}
AllowRestrictedChars = UlReadLongParameter(
parametersHandle,
REGISTRY_ALLOW_RESTRICTED_CHARS,
DefaultBoolRegValue);
if (AllowRestrictedChars != DefaultBoolRegValue)
{
//
// A registry setting is present; use it.
//
AllowRestrictedChars = (BOOLEAN) (AllowRestrictedChars != 0);
}
else
{
AllowRestrictedChars = DEFAULT_ALLOW_RESTRICTED_CHARS;
}
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_URL_SEGMENT_MAX_LENGTH,
DEFAULT_URL_SEGMENT_MAX_LENGTH
);
if (tmp == 0)
{
// 0 in the registry turns this feature off
UrlSegmentMaxLength = C14N_URL_SEGMENT_UNLIMITED_LENGTH;
}
else if (tmp < WCSLEN_LIT(L"/x") || tmp > UNICODE_STRING_MAX_WCHAR_LEN)
{
UrlSegmentMaxLength = DEFAULT_URL_SEGMENT_MAX_LENGTH;
}
else
{
UrlSegmentMaxLength = tmp;
}
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_URL_SEGMENT_MAX_COUNT,
DEFAULT_URL_SEGMENT_MAX_COUNT
);
if (tmp == 0)
{
// 0 in the registry turns this feature off
UrlSegmentMaxCount = C14N_URL_SEGMENT_UNLIMITED_COUNT;
}
else if (tmp < 2 || tmp > UNICODE_STRING_MAX_WCHAR_LEN / WCSLEN_LIT(L"/x"))
{
UrlSegmentMaxCount = DEFAULT_URL_SEGMENT_MAX_COUNT;
}
else
{
UrlSegmentMaxCount = tmp;
}
//
// Initialize the default Url Canonicalization settings
//
HttpInitializeDefaultUrlC14nConfigEncoding(
&g_UrlC14nConfig,
(BOOLEAN) EnableNonUtf8,
(BOOLEAN) FavorUtf8,
(BOOLEAN) EnableDbcs
);
g_UrlC14nConfig.PercentUAllowed = (BOOLEAN) PercentUAllowed;
g_UrlC14nConfig.AllowRestrictedChars = (BOOLEAN) AllowRestrictedChars;
g_UrlC14nConfig.CodePage = ACPCode;
g_UrlC14nConfig.UrlSegmentMaxLength = UrlSegmentMaxLength;
g_UrlC14nConfig.UrlSegmentMaxCount = UrlSegmentMaxCount;
return ACPCode;
} // UlpReadUrlC14nConfig
/***************************************************************************++
Routine Description:
Reads the error logging config from registry and initializes the
global config structure.
Arguments:
parametersHandle - Supplies the reg handle to the http param folder.
--***************************************************************************/
VOID
UlpReadErrorLogConfig(
HANDLE parametersHandle
)
{
LONG tmp;
NTSTATUS Status;
PKEY_VALUE_PARTIAL_INFORMATION pInfo;
PAGED_CODE();
//
// First see whether it's enabled or not.
//
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_ERROR_LOGGING_ENABLED,
DEFAULT_ENABLE_ERROR_LOGGING
);
if (tmp == 0)
{
g_UlErrLoggingConfig.Enabled = FALSE;
}
else if (tmp == 1)
{
g_UlErrLoggingConfig.Enabled = TRUE;
}
else
{
g_UlErrLoggingConfig.Enabled = DEFAULT_ENABLE_ERROR_LOGGING;
}
//
// Now try to read the whole config if it is enabled.
//
if (g_UlErrLoggingConfig.Enabled == TRUE)
{
//
// Rollover size.
//
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_ERROR_LOGGING_TRUNCATION_SIZE,
0
);
if (tmp < 0)
{
//
// Interpret the neg values as infinite.
//
g_UlErrLoggingConfig.TruncateSize = HTTP_LIMIT_INFINITE;
}
else if (tmp < DEFAULT_MIN_ERROR_FILE_TRUNCATION_SIZE)
{
//
// If the it is invalid, set it to default.
//
g_UlErrLoggingConfig.TruncateSize = DEFAULT_ERROR_FILE_TRUNCATION_SIZE;
}
else
{
g_UlErrLoggingConfig.TruncateSize = (ULONG) tmp;
}
//
// Error logging directory.
//
g_UlErrLoggingConfig.Dir.Buffer = g_UlErrLoggingConfig._DirBuffer;
g_UlErrLoggingConfig.Dir.Length = 0;
g_UlErrLoggingConfig.Dir.MaximumLength =
(USHORT) sizeof(g_UlErrLoggingConfig._DirBuffer);
//
// Lets make sure the buffer is big enough to hold.
//
ASSERT(sizeof(g_UlErrLoggingConfig._DirBuffer)
>= (( MAX_PATH // From reg
+ UL_ERROR_LOG_SUB_DIR_LENGTH // SubDir
+ 1 // UnicodeNull
) * sizeof(WCHAR))
);
pInfo = NULL;
Status = UlReadGenericParameter(
parametersHandle,
REGISTRY_ERROR_LOGGING_DIRECTORY,
&pInfo
);
if (NT_SUCCESS(Status))
{
ASSERT(pInfo);
if (pInfo->Type == REG_EXPAND_SZ || pInfo->Type == REG_SZ)
{
USHORT RegDirLength = (USHORT) wcslen((PWCHAR) pInfo->Data);
if (RegDirLength <= MAX_PATH)
{
//
// Copy the beginning portion from the registry.
//
Status = UlBuildErrorLoggingDirStr(
(PCWSTR) pInfo->Data,
&g_UlErrLoggingConfig.Dir
);
ASSERT(NT_SUCCESS(Status));
//
// Check the user's directory.
//
Status = UlCheckErrorLogConfig(&g_UlErrLoggingConfig);
if (NT_SUCCESS(Status))
{
//
// Good to go.
//
UL_FREE_POOL( pInfo, UL_REGISTRY_DATA_POOL_TAG );
return;
}
}
}
//
// Free up the returned value.
//
UL_FREE_POOL( pInfo, UL_REGISTRY_DATA_POOL_TAG );
}
//
// Fall back to the default directory.
//
ASSERT(wcslen(DEFAULT_ERROR_LOGGING_DIR) <= MAX_PATH);
Status = UlBuildErrorLoggingDirStr(
DEFAULT_ERROR_LOGGING_DIR,
&g_UlErrLoggingConfig.Dir
);
ASSERT(NT_SUCCESS(Status));
Status = UlCheckErrorLogConfig(&g_UlErrLoggingConfig);
if (!NT_SUCCESS(Status))
{
//
// This call should not fail.
//
ASSERT(!"Invalid default error logging config !");
g_UlErrLoggingConfig.Enabled = FALSE;
}
}
return;
}
/***************************************************************************++
Routine Description:
Reads the UL section of the registry. Any values contained in the
registry override defaults.
BUGBUG: the limits on many of these settings seem particularly arbitrary,
not to mention undocumented.
Arguments:
pConfig - Supplies a pointer to a UL_CONFIG structure that receives
init-time configuration parameters. These are basically
parameters that do not need to persist in the driver once
initialization is complete.
--***************************************************************************/
VOID
UlpReadRegistry(
IN PUL_CONFIG pConfig
)
{
HANDLE parametersHandle;
NTSTATUS status;
LONG tmp;
LONGLONG tmp64;
UNICODE_STRING registryPath;
UNICODE_STRING registryPathComputerName;
PKEY_VALUE_PARTIAL_INFORMATION pInfo;
PKEY_VALUE_PARTIAL_INFORMATION pValue;
HANDLE computerNameHandle;
ULONG ACPCode;
//
// Sanity check.
//
PAGED_CODE();
//
// Establish defaults.
//
pConfig->ThreadsPerCpu = DEFAULT_THREADS_PER_CPU;
pConfig->IrpContextLookasideDepth = DEFAULT_IRP_CONTEXT_LOOKASIDE_DEPTH;
pConfig->ReceiveBufferLookasideDepth = DEFAULT_RCV_BUFFER_LOOKASIDE_DEPTH;
pConfig->ResourceLookasideDepth = DEFAULT_RESOURCE_LOOKASIDE_DEPTH;
pConfig->RequestBufferLookasideDepth = DEFAULT_REQ_BUFFER_LOOKASIDE_DEPTH;
pConfig->InternalRequestLookasideDepth = DEFAULT_INT_REQUEST_LOOKASIDE_DEPTH;
pConfig->ResponseBufferLookasideDepth = DEFAULT_RESP_BUFFER_LOOKASIDE_DEPTH;
pConfig->SendTrackerLookasideDepth = DEFAULT_SEND_TRACKER_LOOKASIDE_DEPTH;
pConfig->LogFileBufferLookasideDepth = DEFAULT_LOG_BUFFER_LOOKASIDE_DEPTH;
pConfig->LogDataBufferLookasideDepth = DEFAULT_LOG_DATA_BUFFER_LOOKASIDE_DEPTH;
pConfig->ErrorLogBufferLookasideDepth = DEFAULT_ERROR_LOG_BUFFER_LOOKASIDE_DEPTH;
pConfig->FilterWriteTrackerLookasideDepth = DEFAULT_LOOKASIDE_DEPTH;
pConfig->UriConfig.EnableCache = DEFAULT_CACHE_ENABLED;
pConfig->UriConfig.MaxCacheUriCount = DEFAULT_MAX_CACHE_URI_COUNT;
pConfig->UriConfig.MaxCacheMegabyteCount = DEFAULT_MAX_CACHE_MEGABYTE_COUNT;
pConfig->UriConfig.MaxUriBytes = DEFAULT_MAX_URI_BYTES;
pConfig->UriConfig.ScavengerPeriod = DEFAULT_CACHE_SCAVENGER_PERIOD;
pConfig->EnableHttpClient = DEFAULT_HTTP_CLIENT_ENABLED;
//
// Open the registry.
//
status = UlInitUnicodeStringEx( &registryPath, REGISTRY_UL_INFORMATION );
if(!NT_SUCCESS(status))
{
return;
}
status = UlOpenRegistry( &registryPath, &parametersHandle, NULL );
if(!NT_SUCCESS(status))
{
return;
}
#if DBG
//
// Read the debug flags.
//
g_UlDebug = (ULONGLONG)
UlReadLongLongParameter(
parametersHandle,
REGISTRY_DEBUG_FLAGS,
(LONGLONG)g_UlDebug
);
//
// Force a breakpoint if so requested.
//
if (UlReadLongParameter(
parametersHandle,
REGISTRY_BREAK_ON_STARTUP,
DEFAULT_BREAK_ON_STARTUP) != 0 )
{
DbgBreakPoint();
}
//
// Read the break-on-error flags.
//
g_UlBreakOnError = (BOOLEAN) UlReadLongParameter(
parametersHandle,
REGISTRY_BREAK_ON_ERROR,
g_UlBreakOnError
) != 0;
g_UlVerboseErrors = (BOOLEAN) UlReadLongParameter(
parametersHandle,
REGISTRY_VERBOSE_ERRORS,
g_UlVerboseErrors
) != 0;
//
// Break-on-error implies verbose-errors.
//
if (g_UlBreakOnError)
{
g_UlVerboseErrors = TRUE;
}
#endif // DBG
//
// Read the thread pool parameters.
//
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_THREADS_PER_CPU,
(LONG)pConfig->ThreadsPerCpu
);
if (tmp > MAX_THREADS_PER_CPU || tmp <= 0)
{
tmp = DEFAULT_THREADS_PER_CPU;
}
pConfig->ThreadsPerCpu = (USHORT)tmp;
//
// Other configuration parameters. (Lookaside depths are USHORTs)
//
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_IDLE_CONNECTIONS_LOW_MARK,
(LONG)g_UlIdleConnectionsLowMark
);
if (tmp > UL_MAX_SLIST_DEPTH || tmp < 1)
{
//
// If the low mark is bad, don't even try to read the high mark.
//
g_UlIdleConnectionsLowMark = DEFAULT_IDLE_CONNECTIONS_LOW_MARK;
g_UlIdleConnectionsHighMark = DEFAULT_IDLE_CONNECTIONS_HIGH_MARK;
}
else
{
g_UlIdleConnectionsLowMark = (USHORT)tmp;
//
// Now read the high mark, again if it is bad, discard the low mark
// as well.
//
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_IDLE_CONNECTIONS_HIGH_MARK,
(LONG)g_UlIdleConnectionsHighMark
);
if (tmp < g_UlIdleConnectionsLowMark ||
tmp > UL_MAX_SLIST_DEPTH
)
{
g_UlIdleConnectionsLowMark = DEFAULT_IDLE_CONNECTIONS_LOW_MARK;
g_UlIdleConnectionsHighMark = DEFAULT_IDLE_CONNECTIONS_HIGH_MARK;
}
else
{
g_UlIdleConnectionsHighMark = (USHORT)tmp;
}
}
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_IDLE_LIST_TRIMMER_PERIOD,
(LONG)g_UlIdleListTrimmerPeriod
);
if (tmp > (24 * 60 * 60) || tmp < 5)
{
tmp = DEFAULT_IDLE_LIST_TRIMMER_PERIOD;
}
g_UlIdleListTrimmerPeriod = (ULONG)tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_MAX_ENDPOINTS,
(LONG)g_UlMaxEndpoints
);
if (tmp > 1024 || tmp < 0)
{
tmp = DEFAULT_MAX_ENDPOINTS;
}
g_UlMaxEndpoints = (USHORT)tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_IRP_CONTEXT_LOOKASIDE_DEPTH,
(LONG)pConfig->IrpContextLookasideDepth
);
if (tmp > UL_MAX_SLIST_DEPTH || tmp < 0)
{
tmp = DEFAULT_IRP_CONTEXT_LOOKASIDE_DEPTH;
}
pConfig->IrpContextLookasideDepth = (USHORT)tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_RCV_BUFFER_LOOKASIDE_DEPTH,
(LONG)pConfig->ReceiveBufferLookasideDepth
);
if (tmp > UL_MAX_SLIST_DEPTH || tmp < 0)
{
tmp = DEFAULT_RCV_BUFFER_LOOKASIDE_DEPTH;
}
pConfig->ReceiveBufferLookasideDepth = (USHORT)tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_REQ_BUFFER_LOOKASIDE_DEPTH,
(LONG)pConfig->RequestBufferLookasideDepth
);
if (tmp > UL_MAX_SLIST_DEPTH || tmp < 0)
{
tmp = DEFAULT_REQ_BUFFER_LOOKASIDE_DEPTH;
}
pConfig->RequestBufferLookasideDepth = (USHORT)tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_INT_REQUEST_LOOKASIDE_DEPTH,
(LONG)pConfig->InternalRequestLookasideDepth
);
if (tmp > UL_MAX_SLIST_DEPTH || tmp < 0)
{
tmp = DEFAULT_INT_REQUEST_LOOKASIDE_DEPTH;
}
pConfig->InternalRequestLookasideDepth = (USHORT)tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_RESP_BUFFER_LOOKASIDE_DEPTH,
(LONG)pConfig->ResponseBufferLookasideDepth
);
if (tmp > UL_MAX_SLIST_DEPTH || tmp < 0)
{
tmp = DEFAULT_RESP_BUFFER_LOOKASIDE_DEPTH;
}
pConfig->ResponseBufferLookasideDepth = (USHORT)tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_SEND_TRACKER_LOOKASIDE_DEPTH,
(LONG)pConfig->SendTrackerLookasideDepth
);
if (tmp > UL_MAX_SLIST_DEPTH || tmp < 0)
{
tmp = DEFAULT_SEND_TRACKER_LOOKASIDE_DEPTH;
}
pConfig->SendTrackerLookasideDepth = (USHORT)tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_LOG_BUFFER_LOOKASIDE_DEPTH,
(LONG)pConfig->LogFileBufferLookasideDepth
);
if (tmp > UL_MAX_SLIST_DEPTH || tmp < 0)
{
tmp = DEFAULT_LOG_BUFFER_LOOKASIDE_DEPTH;
}
pConfig->LogFileBufferLookasideDepth = (USHORT)tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_LOG_DATA_BUFFER_LOOKASIDE_DEPTH,
(LONG)pConfig->LogDataBufferLookasideDepth
);
if (tmp > UL_MAX_SLIST_DEPTH || tmp < 0)
{
tmp = DEFAULT_LOG_DATA_BUFFER_LOOKASIDE_DEPTH;
}
pConfig->LogDataBufferLookasideDepth = (USHORT)tmp;
g_UlOptForIntrMod = (BOOLEAN) UlReadLongParameter(
parametersHandle,
REGISTRY_OPT_FOR_INTR_MOD,
(LONG)g_UlOptForIntrMod
) != 0;
g_UlEnableNagling = (BOOLEAN) UlReadLongParameter(
parametersHandle,
REGISTRY_ENABLE_NAGLING,
(LONG)g_UlEnableNagling
) != 0;
g_UlEnableThreadAffinity = (BOOLEAN) UlReadLongParameter(
parametersHandle,
REGISTRY_ENABLE_THREAD_AFFINITY,
(LONG)g_UlEnableThreadAffinity
) != 0;
tmp64 = UlReadLongLongParameter(
parametersHandle,
REGISTRY_THREAD_AFFINITY_MASK,
g_UlThreadAffinityMask
);
if ((ULONGLONG)tmp64 > DEFAULT_THREAD_AFFINITY_MASK
|| (ULONGLONG)tmp64 == 0)
{
tmp64 = DEFAULT_THREAD_AFFINITY_MASK;
}
g_UlThreadAffinityMask = (ULONGLONG)tmp64;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_MAX_WORK_QUEUE_DEPTH,
(LONG)g_UlMaxWorkQueueDepth
);
if (tmp > UL_MAX_SLIST_DEPTH || tmp < 0)
{
tmp = DEFAULT_MAX_WORK_QUEUE_DEPTH;
}
g_UlMaxWorkQueueDepth = (USHORT)tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_MIN_WORK_DEQUEUE_DEPTH,
(LONG)g_UlMinWorkDequeueDepth
);
if (tmp > UL_MAX_SLIST_DEPTH || tmp < 0)
{
tmp = DEFAULT_MIN_WORK_DEQUEUE_DEPTH;
}
g_UlMinWorkDequeueDepth = (USHORT)tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_MAX_COPY_THRESHOLD,
(LONG)g_UlMaxCopyThreshold
);
if (tmp > (128 * 1024) || tmp < 0)
{
tmp = DEFAULT_MAX_COPY_THRESHOLD;
}
g_UlMaxCopyThreshold = tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_MAX_BUFFERED_SENDS,
(LONG)g_UlMaxBufferedSends
);
if (tmp > 64 || tmp < 0)
{
tmp = DEFAULT_MAX_BUFFERED_SENDS;
}
g_UlMaxBufferedSends = tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_MAX_BYTES_PER_SEND,
(LONG)g_UlMaxBytesPerSend
);
if (tmp > 0xFFFFF || tmp < 0)
{
tmp = DEFAULT_MAX_BYTES_PER_SEND;
}
g_UlMaxBytesPerSend = tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_MAX_BYTES_PER_READ,
(LONG)g_UlMaxBytesPerRead
);
if (tmp > 0xFFFFF || tmp < 0)
{
tmp = DEFAULT_MAX_BYTES_PER_READ;
}
g_UlMaxBytesPerRead = tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_MAX_PIPELINED_REQUESTS,
(LONG)g_UlMaxPipelinedRequests
);
if (tmp > 1024 || tmp < 0)
{
tmp = DEFAULT_MAX_PIPELINED_REQUESTS;
}
g_UlMaxPipelinedRequests = tmp;
g_UlEnableCopySend = (BOOLEAN) UlReadLongParameter(
parametersHandle,
REGISTRY_ENABLE_COPY_SEND,
DEFAULT_ENABLE_COPY_SEND
) != 0;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_CONNECTION_SEND_LIMIT,
(LONG)g_UlConnectionSendLimit
);
if (tmp > (1024 * 1024) || tmp < 0)
{
tmp = DEFAULT_CONNECTION_SEND_LIMIT;
}
g_UlConnectionSendLimit = tmp;
tmp64 = UlReadLongLongParameter(
parametersHandle,
REGISTRY_GLOBAL_SEND_LIMIT,
g_UlGlobalSendLimit
);
if (tmp64 > (LONGLONG)g_UlTotalNonPagedPoolBytes / 2 ||
tmp64 < (LONGLONG)g_UlConnectionSendLimit)
{
tmp64 = DEFAULT_GLOBAL_SEND_LIMIT;
}
g_UlGlobalSendLimit = tmp64;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_OPAQUE_ID_TABLE_SIZE,
(LONG)g_UlOpaqueIdTableSize
);
if (tmp > 0xFFFF || tmp <= 0)
{
tmp = DEFAULT_OPAQUE_ID_TABLE_SIZE;
}
g_UlOpaqueIdTableSize = tmp;
//
// MaxInternalUrlLength is a hint for allocating the inline buffer
// of WCHARs to hold the URL at the end of a UL_INTERNAL_REQUEST.
// Note: This is not the maximum possible length of a URL received off
// the wire; that's MaxFieldLength.
//
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_MAX_INTERNAL_URL_LENGTH,
g_UlMaxInternalUrlLength
);
//
// Round up to an even number, as it measures the size in bytes
// of a WCHAR array
//
tmp = (tmp + 1) & ~1;
#define MIN_MAX_INTERNAL_URL_LENGTH (64 * sizeof(WCHAR))
#define MAX_MAX_INTERNAL_URL_LENGTH (MAX_PATH * sizeof(WCHAR))
tmp = min(tmp, MAX_MAX_INTERNAL_URL_LENGTH);
tmp = max(tmp, MIN_MAX_INTERNAL_URL_LENGTH);
ASSERT(MIN_MAX_INTERNAL_URL_LENGTH <= tmp
&& tmp <= MAX_MAX_INTERNAL_URL_LENGTH);
g_UlMaxInternalUrlLength = tmp;
//
// MAX allowed field length in HTTP requests, in bytes
//
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_MAX_FIELD_LENGTH,
(LONG)g_UlMaxFieldLength
);
// Set a 64KB-2 hard upper limit for each individual header.
// Note: the length fields in HTTP_KNOWN_HEADER and HTTP_UNKNOWN_HEADER
// are USHORTs. We have to allow a terminating '\0' in the data
// we pass up, hence -2.
tmp = min(tmp, ANSI_STRING_MAX_CHAR_LEN);
tmp = max(tmp, 64);
ASSERT(64 <= tmp && tmp <= ANSI_STRING_MAX_CHAR_LEN);
g_UlMaxFieldLength = tmp;
//
// MaxRequestBytes is the total size of all the headers, including
// the initial verb/URL/version line.
//
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_MAX_REQUEST_BYTES,
g_UlMaxRequestBytes
);
// Set a 16MB hard upper limit for all the headers. Don't want to
// set it bigger than this to minimize Denial of Service attacks.
// If you really want to send a lot of data, send it in the entity body.
tmp = min(tmp, (16 * 1024 * 1024));
tmp = max(tmp, 256);
ASSERT(256 <= tmp && tmp <= (16 * 1024 * 1024));
g_UlMaxRequestBytes = tmp;
// An individual field can't be bigger than the aggregated fields
if (g_UlMaxRequestBytes < g_UlMaxFieldLength)
{
g_UlMaxFieldLength = g_UlMaxRequestBytes;
}
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_DISABLE_LOG_BUFFERING,
(LONG)g_UlDisableLogBuffering
);
g_UlDisableLogBuffering = (BOOLEAN) (tmp != 0);
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_LOG_BUFFER_SIZE,
(LONG)g_UlLogBufferSize
);
if (tmp > MAXIMUM_ALLOWED_LOG_BUFFER_SIZE
|| tmp < MINIMUM_ALLOWED_LOG_BUFFER_SIZE )
{
// Basically this value will be discarted by the logging code
// instead systems granularity size (64K) will be used.
tmp = DEFAULT_LOG_BUFFER_SIZE;
}
tmp -= tmp % 4096; // Align down to 4k
g_UlLogBufferSize = (ULONG) tmp;
//
// read the resource lookaside config
//
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_RESOURCE_LOOKASIDE_DEPTH,
(LONG)pConfig->ResourceLookasideDepth
);
if (tmp > UL_MAX_SLIST_DEPTH || tmp < 0)
{
tmp = DEFAULT_RESOURCE_LOOKASIDE_DEPTH;
}
pConfig->ResourceLookasideDepth = (USHORT)tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_MAX_REQUESTS_QUEUED,
g_UlMaxRequestsQueued
);
if (tmp > UL_MAX_REQUESTS_QUEUED || tmp < UL_MIN_REQUESTS_QUEUED)
{
tmp = DEFAULT_MAX_REQUESTS_QUEUED;
}
g_UlMaxRequestsQueued = tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_MAX_ZOMBIE_HTTP_CONN_COUNT,
g_UlMaxZombieHttpConnectionCount
);
if (tmp > 0xFFFF || tmp < 0)
{
tmp = DEFAULT_MAX_ZOMBIE_HTTP_CONN_COUNT;
}
g_UlMaxZombieHttpConnectionCount = tmp;
//
// Max UL_CONNECTION override
//
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_MAX_CONNECTIONS,
g_MaxConnections
);
// Restrict from 1K min to 2M max
if (tmp > 0x1F0000 || tmp < 0x400 )
{
tmp = HTTP_LIMIT_INFINITE;
}
g_MaxConnections = tmp;
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_RCV_BUFFER_SIZE,
g_UlReceiveBufferSize
);
if (tmp > 0xFFFF || tmp < 128)
{
tmp = DEFAULT_RCV_BUFFER_SIZE;
}
g_UlReceiveBufferSize = ALIGN_UP( tmp, PVOID );
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_RESP_BUFFER_SIZE,
g_UlResponseBufferSize
);
if (tmp > 0xFFFF || tmp < 128)
{
tmp = DEFAULT_RESP_BUFFER_SIZE;
}
g_UlResponseBufferSize = tmp;
ACPCode = UlpReadUrlC14nConfig(parametersHandle);
//
// Should we disable the Server: response header?
//
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_DISABLE_SERVER_HEADER,
(LONG)g_UlDisableServerHeader
);
if (tmp >= 0 && tmp <= 2)
{
g_UlDisableServerHeader = (ULONG) tmp;
}
//
// Read error logging config.
//
UlpReadErrorLogConfig(parametersHandle);
//
// Read the ComputerName from the Registry.
//
wcsncpy(g_UlComputerName, L"<server>", MAX_COMPUTER_NAME_LEN);
status = UlInitUnicodeStringEx( &registryPathComputerName,
REGISTRY_COMPUTER_NAME_PATH );
if (NT_SUCCESS(status))
{
status = UlOpenRegistry(
&registryPathComputerName,
&computerNameHandle,
REGISTRY_COMPUTER_NAME
);
if (NT_SUCCESS(status))
{
pInfo = NULL;
status = UlReadGenericParameter(
computerNameHandle,
REGISTRY_COMPUTER_NAME,
&pInfo
);
if (NT_SUCCESS(status))
{
ASSERT(pInfo);
if (pInfo->Type == REG_SZ)
{
wcsncpy(g_UlComputerName,
(PWCHAR)pInfo->Data,
MAX_COMPUTER_NAME_LEN
);
//
// Make sure we're NULL terminated. This will truncate
// the name from the registry.
//
g_UlComputerName[MAX_COMPUTER_NAME_LEN] = L'\0';
}
//
// Free up the returned value.
//
UL_FREE_POOL( pInfo, UL_REGISTRY_DATA_POOL_TAG );
}
ZwClose( computerNameHandle );
}
}
//
// Read URI Cache parameters
//
pConfig->UriConfig.EnableCache = (BOOLEAN) UlReadLongParameter(
parametersHandle,
REGISTRY_CACHE_ENABLED,
DEFAULT_CACHE_ENABLED
) != 0;
pConfig->UriConfig.MaxCacheUriCount = UlReadLongParameter(
parametersHandle,
REGISTRY_MAX_CACHE_URI_COUNT,
DEFAULT_MAX_CACHE_URI_COUNT
);
pConfig->UriConfig.MaxCacheMegabyteCount = UlReadLongParameter(
parametersHandle,
REGISTRY_MAX_CACHE_MEGABYTE_COUNT,
DEFAULT_MAX_CACHE_MEGABYTE_COUNT
);
tmp = UlReadLongParameter(
parametersHandle,
REGISTRY_MAX_URI_BYTES,
DEFAULT_MAX_URI_BYTES
);
if (tmp < (4 * 1024) || tmp > (16 * 1024 * 1024))
{
tmp = DEFAULT_MAX_URI_BYTES;
}
pConfig->UriConfig.MaxUriBytes = tmp;
pConfig->UriConfig.ScavengerPeriod = UlReadLongParameter(
parametersHandle,
REGISTRY_CACHE_SCAVENGER_PERIOD,
DEFAULT_CACHE_SCAVENGER_PERIOD
);
pConfig->UriConfig.HashTableBits = UlReadLongParameter(
parametersHandle,
REGISTRY_HASH_TABLE_BITS,
DEFAULT_HASH_TABLE_BITS
);
#if 0
pConfig->EnableHttpClient = (BOOLEAN) UlReadLongParameter(
parametersHandle,
REGISTRY_HTTP_CLIENT_ENABLED,
DEFAULT_HTTP_CLIENT_ENABLED
) != 0;
#endif
g_HttpClientEnabled = pConfig->EnableHttpClient;
//
// Read list of IP addresses for ListenOnlyList
//
pValue = NULL;
status = UlReadGenericParameter(
parametersHandle,
REGISTRY_LISTEN_ONLY_LIST,
&pValue
);
if (NT_SUCCESS(status) && REG_MULTI_SZ == pValue->Type)
{
// If UlRegMultiSzToUlAddrArray fails then we simply use
// the default.
status = UlRegMultiSzToUlAddrArray(
(PWSTR)pValue->Data,
&g_pTdiListenAddresses,
&g_TdiListenAddrCount
);
if ( STATUS_INVALID_PARAMETER == status )
{
//
// Write event log message that ListenOnlyList was found, but
// no entries could be converted.
//
UlWriteEventLogEntry(
EVENT_HTTP_LISTEN_ONLY_ALL_CONVERT_FAILED,
0,
0,
NULL,
0,
NULL
);
}
}
if ( pValue )
{
UL_FREE_POOL( pValue, UL_REGISTRY_DATA_POOL_TAG );
pValue = NULL;
}
//
// Make sure we can always buffer enough bytes for an entire request
// header.
//
g_UlMaxBufferedBytes = MAX(g_UlMaxBufferedBytes, g_UlMaxRequestBytes);
//
// Scavenger Config - MB to reclaim each time
//
g_UlScavengerTrimMB = UlReadLongParameter(
parametersHandle,
REGISTRY_SCAVENGER_TRIM_MB,
DEFAULT_SCAVENGER_TRIM_MB
);
//
// Dump configuration on checked builds.
//
#if DBG
DbgPrint( "Http.sys Configuration:\n" );
// These settings are only present on checked builds
DbgPrint( " g_UlDebug = 0x%016I64x\n", g_UlDebug );
DbgPrint( " g_UlBreakOnError = %lu\n", g_UlBreakOnError );
DbgPrint( " g_UlVerboseErrors = %lu\n", g_UlVerboseErrors );
// These settings are present on all builds
DbgPrint( " g_UlComputerName = %ls\n", g_UlComputerName );
DbgPrint( " g_UlIdleConnectionsHighMark = %lu\n", g_UlIdleConnectionsHighMark );
DbgPrint( " g_UlIdleConnectionsLowMark = %lu\n", g_UlIdleConnectionsLowMark );
DbgPrint( " g_UlIdleListTrimmerPeriod = %lu\n", g_UlIdleListTrimmerPeriod );
DbgPrint( " g_UlMaxEndpoints = %lu\n", g_UlMaxEndpoints );
DbgPrint( " g_UlOptForIntrMod = %lu\n", g_UlOptForIntrMod );
DbgPrint( " g_UlEnableNagling = %lu\n", g_UlEnableNagling );
DbgPrint( " g_UlEnableThreadAffinity = %lu\n", g_UlEnableThreadAffinity );
DbgPrint( " g_UlThreadAffinityMask = 0x%I64x\n", g_UlThreadAffinityMask );
DbgPrint( " g_UlMaxCopyThreshold = %lu\n", g_UlMaxCopyThreshold );
DbgPrint( " g_UlMaxBufferedSends = %lu\n", g_UlMaxBufferedSends );
DbgPrint( " g_UlMaxBytesPerSend = %lu\n", g_UlMaxBytesPerSend );
DbgPrint( " g_UlMaxBytesPerRead = %lu\n", g_UlMaxBytesPerRead );
DbgPrint( " g_UlMaxPipelinedRequests = %lu\n", g_UlMaxPipelinedRequests );
DbgPrint( " g_UlEnableCopySend = %lu\n", g_UlEnableCopySend );
DbgPrint( " g_UlConnectionSendLimit = %lu\n", g_UlConnectionSendLimit );
DbgPrint( " g_UlGlobalSendLimit = %I64u\n", g_UlGlobalSendLimit );
DbgPrint( " g_UlOpaqueIdTableSize = %lu\n", g_UlOpaqueIdTableSize );
DbgPrint( " g_UlMaxRequestsQueued = %lu\n", g_UlMaxRequestsQueued );
DbgPrint( " g_UlMaxRequestBytes = %lu\n", g_UlMaxRequestBytes );
DbgPrint( " g_UlReceiveBufferSize = %lu\n", g_UlReceiveBufferSize );
DbgPrint( " g_UlResponseBufferSize = %lu\n", g_UlResponseBufferSize );
DbgPrint( " g_UlMaxFieldLength = %lu\n", g_UlMaxFieldLength );
DbgPrint( " g_MaxConnections = 0x%lx\n", g_MaxConnections );
DbgPrint( " g_UlDisableLogBuffering = %lu\n", g_UlDisableLogBuffering );
DbgPrint( " g_UlLogBufferSize = %lu\n", g_UlLogBufferSize );
DbgPrint( " CodePage = %lu\n", ACPCode );
DbgPrint( " EnableNonUtf8 = %lu\n", g_UrlC14nConfig.EnableNonUtf8 );
DbgPrint( " FavorUtf8 = %lu\n", g_UrlC14nConfig.FavorUtf8 );
DbgPrint( " EnableDbcs = %lu\n", g_UrlC14nConfig.EnableDbcs );
DbgPrint( " PercentUAllowed = %lu\n", g_UrlC14nConfig.PercentUAllowed );
DbgPrint( " AllowRestrictedChars = %lu\n", g_UrlC14nConfig.AllowRestrictedChars );
DbgPrint( " HostnameDecodeOrder = 0x%lx\n", g_UrlC14nConfig.HostnameDecodeOrder );
DbgPrint( " AbsPathDecodeOrder = 0x%lx\n", g_UrlC14nConfig.AbsPathDecodeOrder );
DbgPrint( " UrlSegmentMaxLength = %lu\n", g_UrlC14nConfig.UrlSegmentMaxLength );
DbgPrint( " UrlSegmentMaxCount = %lu\n", g_UrlC14nConfig.UrlSegmentMaxCount );
DbgPrint( " g_UlMaxInternalUrlLength = %lu\n", g_UlMaxInternalUrlLength );
DbgPrint( " g_UlMaxZombieHttpConnCount = %lu\n", g_UlMaxZombieHttpConnectionCount );
DbgPrint( " g_UlDisableServerHeader = %lu\n", g_UlDisableServerHeader );
DbgPrint( " ThreadsPerCpu = %lu\n", pConfig->ThreadsPerCpu );
DbgPrint( " IrpContextLookasideDepth = %lu\n", pConfig->IrpContextLookasideDepth );
DbgPrint( " ReceiveBufferLookasideDepth = %lu\n", pConfig->ReceiveBufferLookasideDepth );
DbgPrint( " ResourceLookasideDepth = %lu\n", pConfig->ResourceLookasideDepth );
DbgPrint( " RequestBufferLookasideDepth = %lu\n", pConfig->RequestBufferLookasideDepth );
DbgPrint( " IntlRequestLookasideDepth = %lu\n", pConfig->InternalRequestLookasideDepth );
DbgPrint( " ResponseBufferLookasideDepth = %lu\n", pConfig->ResponseBufferLookasideDepth );
DbgPrint( " SendTrackerLookasideDepth = %lu\n", pConfig->SendTrackerLookasideDepth );
DbgPrint( " LogFileBufferLookasideDepth = %lu\n", pConfig->LogFileBufferLookasideDepth );
DbgPrint( " LogDataBufferLookasideDepth = %lu\n", pConfig->LogDataBufferLookasideDepth );
DbgPrint( " WriteTrackerLookasideDepth = %lu\n", pConfig->FilterWriteTrackerLookasideDepth );
DbgPrint( " EnableCache = %lu\n", pConfig->UriConfig.EnableCache );
DbgPrint( " MaxCacheUriCount = %lu\n", pConfig->UriConfig.MaxCacheUriCount );
DbgPrint( " MaxCacheMegabyteCount = %lu\n", pConfig->UriConfig.MaxCacheMegabyteCount );
DbgPrint( " ScavengerPeriod = %lu\n", pConfig->UriConfig.ScavengerPeriod );
DbgPrint( " HashTableBits = %ld\n", pConfig->UriConfig.HashTableBits);
DbgPrint( " MaxUriBytes = %lu\n", pConfig->UriConfig.MaxUriBytes );
DbgPrint( " ScavengerTrimMB = %ld\n", g_UlScavengerTrimMB);
#endif // DBG
//
// Cleanup.
//
ZwClose( parametersHandle );
} // UlpReadRegistry
/***************************************************************************++
Routine Description:
Unload routine called by the IO subsystem when UL is getting
unloaded.
--***************************************************************************/
VOID
UlpUnload(
IN PDRIVER_OBJECT DriverObject
)
{
UNREFERENCED_PARAMETER(DriverObject);
//
// Sanity check.
//
PAGED_CODE();
UL_ENTER_DRIVER("http!UlpUnload", NULL);
#if DBG
KdPrint(( "UlpUnload called.\n" ));
#endif // DBG
//
// Terminate the UL modules.
//
UlpTerminateModules();
//
// Flush all kernel DPCs to ensure our periodic timer DPCs cannot
// get called after we unload.
//
KeFlushQueuedDpcs();
UL_LEAVE_DRIVER("UlpUnload");
#if DBG
//
// Terminate any debug-specific data after UL_LEAVE_DRIVER
//
UlDbgTerminateDebugData( );
#endif // DBG
#if DBG
KdPrint(( "\n"
"------\n"
"http!UlpUnload finished.\n"
"------\n" ));
#endif // DBG
} // UlpUnload
/***************************************************************************++
Routine Description:
Terminates the various UL modules in the correct order.
--***************************************************************************/
VOID
UlpTerminateModules(
VOID
)
{
//
// Sanity check.
//
PAGED_CODE();
//
// Wait for endpoints to go away, so we're sure all I/O is done.
//
UlWaitForEndpointDrain();
//
// Kill Michael.
//
UlTerminateDateCache();
UlTerminateUriCache();
UlTerminateFilterChannel();
//
// Kill Henry.
//
TerminateFileCache();
//
// Kill Paul.
//
UlTerminateCG();
UlTerminateAP();
//
// Kill Keith.
//
UlTerminateControlChannel();
//
// TerminateLogs Blocks until all Io To Be Complete
//
// Note:CG should be terminated before Logs.
// Otherwise we won't stop issuing the buffer writes.
// ThreadPool should be terminated after Logs.
// Otherwise our Completion APCs won't be completed back.
//
//
// Kill ETW Logging
//
UlEtwUnRegisterLog( g_pUlControlDeviceObject );
//
// Kill Ali
//
UlTerminateLogs();
UlTerminateBinaryLog();
UlTerminateErrorLog();
UlTerminateLogUtil();
UlTcTerminate();
UlTerminateHttpConnection();
//
// Kill Eric.
//
UlTerminateCounters();
UlTerminateTimeoutMonitor();
//
// Kill George.
//
UlLargeMemTerminate();
//
// Kill TDI.
//
UxTerminateTdi();
UlTerminateTdi();
//
// Kill the thread pool.
//
UlTerminateThreadPool();
//
// Kill the opaque Ids
//
UlTerminateOpaqueIdTable();
//
// Kill any global data.
//
UlTerminateData();
//
// Kill Listen-Only address list
//
if ( g_pTdiListenAddresses )
{
ASSERT( 0 != g_TdiListenAddrCount );
UlFreeUlAddr( g_pTdiListenAddresses );
}
//
// Kill namespace.
//
UlTerminateNamespace();
//
// Kill Client.
//
if (g_ClientImageHandle)
{
//
// g_ClientImageHandle != NULL <=> client code was initialized.
// Call client terminate functions now.
//
g_ClientImageHandle = NULL;
UcTerminateServerInformation();
UcTerminateClientConnections();
UcTerminateHttpRequests();
}
//
// Delete our device objects.
//
if (g_pUlAppPoolDeviceObject != NULL)
{
IoDeleteDevice( g_pUlAppPoolDeviceObject );
}
if (g_pUlFilterDeviceObject != NULL)
{
IoDeleteDevice( g_pUlFilterDeviceObject );
}
if (g_pUlControlDeviceObject != NULL)
{
IoDeleteDevice( g_pUlControlDeviceObject );
}
if (g_pUcServerDeviceObject != NULL)
{
IoDeleteDevice( g_pUcServerDeviceObject );
}
//
// Delete the directory container.
//
if (g_UlDirectoryObject != NULL)
{
ZwClose( g_UlDirectoryObject );
}
//
// Delete the global trace logs.
//
DESTROY_REF_TRACE_LOG( g_pEndpointUsageTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pTdiTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pHttpRequestTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pHttpConnectionTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pHttpResponseTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pAppPoolTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pAppPoolProcessTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pConfigGroupTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pControlChannelTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pThreadTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pMdlTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pFilterTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pUriTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_IRP_TRACE_LOG( g_pIrpTraceLog );
DESTROY_TIME_TRACE_LOG( g_pTimeTraceLog );
DESTROY_APP_POOL_TIME_TRACE_LOG( g_pAppPoolTimeTraceLog );
DESTROY_REF_TRACE_LOG( g_pSiteCounterTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pConnectionCountTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pConfigGroupInfoTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pChunkTrackerTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pWorkItemTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pPoolAllocTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_REF_TRACE_LOG( g_pMondoGlobalTraceLog, UL_REF_TRACE_LOG_POOL_TAG );
DESTROY_STRING_LOG( g_pGlobalStringLog );
DESTROY_UC_TRACE_LOG( g_pUcTraceLog);
} // UlpTerminateModules