able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/rdr2/rdbss/ntinit.c

1443 lines
39 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
RxInit.c
Abstract:
This module implements the DRIVER_INITIALIZATION routine for the RDBSS.
Also, the routines for pagingio resource selection/allocation are here; since
we have to delete the resources when we unload, having them here simply centralizes
all the pagingio resource stuff.
Finally, the routines that are here that implement the wrapper's version of
network provider order. Basically, the wrapper MUST implement the same concept of
network provider order as the MUP so that the UI will work as expected. So, we
read the provider order from the registry at init time and memorize the order. Then,
we can assign the correct order when minirdrs register. Obviously, provider order is
not an issue in MONOLITHIC mode.
Author:
Joe Linn [JoeLinn] 20-jul-1994
Revision History:
--*/
#include "precomp.h"
#pragma hdrstop
#include "ntverp.h"
#include "NtDdNfs2.h"
#include "netevent.h"
//
// The local debug trace level
//
#define Dbg (0)
ULONG RxBuildNumber = VER_PRODUCTBUILD;
#ifdef RX_PRIVATE_BUILD
ULONG RxPrivateBuild = 1;
#else
ULONG RxPrivateBuild = 0;
#endif
#ifdef MONOLITHIC_MINIRDR
RDBSS_DEVICE_OBJECT RxSpaceForTheWrappersDeviceObject;
#endif
#define LANMAN_WORKSTATION_PARAMETERS \
L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\LanmanWorkStation\\Parameters"
BOOLEAN DisableByteRangeLockingOnReadOnlyFiles = FALSE;
VOID
RxReadRegistryParameters();
NPAGED_LOOKASIDE_LIST RxContextLookasideList;
VOID
RxGetRegistryParameters(
IN PUNICODE_STRING RegistryPath
);
NTSTATUS
RxInitializeRegistrationStructures(
void
);
VOID
RxUninitializeRegistrationStructures(
void
);
VOID
RxAbbreviatedWriteLogEntry__ (
IN NTSTATUS Status,
IN ULONG OneExtraUlong
);
#define RxAbbreviatedWriteLogEntry(STATUS__) RxAbbreviatedWriteLogEntry__(STATUS__,__LINE__)
NTSTATUS
RxGetStringRegistryParameter(
HANDLE ParametersHandle,
PWCHAR ParameterName,
PUNICODE_STRING ParamString,
PKEY_VALUE_PARTIAL_INFORMATION Value,
ULONG ValueSize,
BOOLEAN LogFailure
);
NTSTATUS
RxGetUlongRegistryParameter(
HANDLE ParametersHandle,
PWCHAR ParameterName,
PULONG ParamUlong,
PKEY_VALUE_PARTIAL_INFORMATION Value,
ULONG ValueSize,
BOOLEAN LogFailure
);
//this type and variable are used for unwinding the initialization so that stuff doesn't go thru the cracks
// the way that this works is that stuff is done in the reverse order of the enumeration. that way i can just
// use a switch-no-break to unwind.
typedef enum _RX_INIT_STATES {
RXINIT_ALL_INITIALIZATION_COMPLETED,
RXINIT_CONSTRUCTED_PROVIDERORDER,
RXINIT_CREATED_LOG,
RXINIT_CREATED_DEVICE_OBJECT,
RXINIT_CREATED_FIRST_LINK,
RXINIT_START
} RX_INIT_STATES;
VOID
RxInitUnwind(
IN PDRIVER_OBJECT DriverObject,
IN RX_INIT_STATES RxInitState
);
#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT, RxDriverEntry)
#pragma alloc_text(INIT, RxGetRegistryParameters)
#pragma alloc_text(INIT, RxGetStringRegistryParameter)
#pragma alloc_text(INIT, RxGetUlongRegistryParameter)
#pragma alloc_text(INIT, RxAbbreviatedWriteLogEntry__)
#pragma alloc_text(PAGE, RxUnload)
#pragma alloc_text(PAGE, RxInitUnwind)
#pragma alloc_text(PAGE, RxGetNetworkProviderPriority)
#pragma alloc_text(PAGE, RxInitializeRegistrationStructures)
#pragma alloc_text(PAGE, RxUninitializeRegistrationStructures)
#pragma alloc_text(PAGE, RxInitializeMinirdrDispatchTable)
#pragma alloc_text(PAGE, __RxFillAndInstallFastIoDispatch)
#pragma alloc_text(PAGE, RxReadRegistryParameters)
#endif
#define RX_SYMLINK_NAME L"\\??\\fsWrap"
BOOLEAN EnableWmiLog = FALSE;
NTSTATUS
RxDriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This is the initialization routine for the Rx file system
device driver. This routine creates the device object for the FileSystem
device and performs all other driver initialization.
Arguments:
DriverObject - Pointer to driver object created by the system.
Return Value:
RXSTATUS - The function value is the final status from the initialization
operation.
--*/
{
NTSTATUS Status;
RX_INIT_STATES RxInitState = 0;
#ifndef MONOLITHIC_MINIRDR
UNICODE_STRING UnicodeString,LinkName;
#endif
//Structure checks
RxCheckFcbStructuresForAlignment(); //this will bugcheck if things are bad
//
// Initialize the global data structures
ZeroAndInitializeNodeType( &RxData, RDBSS_NTC_DATA_HEADER, sizeof(RDBSS_DATA));
RxData.DriverObject = DriverObject;
ZeroAndInitializeNodeType( &RxDeviceFCB, RDBSS_NTC_DEVICE_FCB, sizeof(FCB));
KeInitializeSpinLock( &RxStrucSupSpinLock );
RxExports.pRxStrucSupSpinLock = &RxStrucSupSpinLock;
RxInitializeDebugSupport();
try {
Status = RXINIT_START;
#ifndef MONOLITHIC_MINIRDR
//
// Create a symbolic link from \\dosdevices\fswrap to the rdbss device object name
RtlInitUnicodeString(&LinkName, RX_SYMLINK_NAME);
RtlInitUnicodeString(&UnicodeString, DD_NFS2_DEVICE_NAME_U);
IoDeleteSymbolicLink(&LinkName);
Status = IoCreateSymbolicLink(&LinkName, &UnicodeString);
if (!NT_SUCCESS( Status )) {
try_return( Status );
}
RxInitState = RXINIT_CREATED_FIRST_LINK;
//
// Create the device object.
Status = IoCreateDevice(DriverObject,
sizeof(RDBSS_DEVICE_OBJECT) - sizeof(DEVICE_OBJECT),
&UnicodeString,
FILE_DEVICE_NETWORK_FILE_SYSTEM,
FILE_REMOTE_DEVICE,
FALSE,
(PDEVICE_OBJECT *)(&RxFileSystemDeviceObject));
if (!NT_SUCCESS( Status )) {
try_return( Status );
}
RxInitState = RXINIT_CREATED_DEVICE_OBJECT;
#else
// in monolithic mode, the wrapper doesn't really need a device object but
// we allocate stuff in the wrapper's device object in order to appropriately throttle
// thread usage per device object.
RxFileSystemDeviceObject = &RxSpaceForTheWrappersDeviceObject;
RtlZeroMemory(RxFileSystemDeviceObject,sizeof(RxSpaceForTheWrappersDeviceObject));
#endif
//
// Initialize the trace and logging facilities. loginit is a big allocation.
RxInitializeDebugTrace();
RxInitializeLog();
RxInitState = RXINIT_CREATED_LOG;
RxGetRegistryParameters(RegistryPath);
RxDbgTrace(0, (DEBUG_TRACE_ALWAYS), ("Constants %08lx %08lx\n",
RX_CONTEXT_FLAG_WAIT,
RX_CONTEXT_CREATE_FLAG_ADDEDBACKSLASH
));
RxReadRegistryParameters();
//
// Initialize the minirdr registration facilities.
Status = RxInitializeRegistrationStructures();
if (!NT_SUCCESS( Status )) {
try_return( Status );
}
RxInitState = RXINIT_CONSTRUCTED_PROVIDERORDER;
try_exit: NOTHING;
} finally {
if (Status != STATUS_SUCCESS) {
RxLogFailure (
RxFileSystemDeviceObject,
NULL,
EVENT_RDR_UNEXPECTED_ERROR,
Status);
RxInitUnwind(DriverObject,RxInitState);
}
}
if (Status != STATUS_SUCCESS) {
return(Status);
}
//
//
//
//
// ##### ## # # #### ###### #####
// # # # # ## # # # # # #
// # # # # # # # # ##### # #
// # # ###### # # # # ### # #####
// # # # # # ## # # # # #
// ##### # # # # #### ###### # #
//
//
//
// EVERYTHING FROM HERE DOWN BETTER WORK BECAUSE THERE IS NO MORE UNWINDING!!!
//
//
RxInitializeDispatcher();
RxInitializeBackoffPackage();
// Initialize the look aside list for RxContext allocation
ExInitializeNPagedLookasideList(
&RxContextLookasideList,
ExAllocatePoolWithTag,
ExFreePool,
0,
sizeof(RX_CONTEXT),
RX_IRPC_POOLTAG,
4);
// Initialize the list of transport Irps to an empty list
InitializeListHead(&RxIrpsList);
KeInitializeSpinLock(&RxIrpsListSpinLock);
// Initialize the list of active contexts to an empty list
InitializeListHead(&RxActiveContexts);
// Initialize the list of srv call downs active
InitializeListHead(&RxSrvCalldownList);
// a fastmutex is used to serialize access to the Qs that serialize blocking pipe operations
ExInitializeFastMutex(&RxContextPerFileSerializationMutex);
// and to serialize access to the Qs that serialize some pagingio operations
ExInitializeFastMutex(&RxLowIoPagingIoSyncMutex);
// Initialize the scavenger mutex
KeInitializeMutex(&RxScavengerMutex,1);
// Initialize the global serialization Mutex.
KeInitializeMutex(&RxSerializationMutex,1);
//
// Initialize the wrapper's overflow queue
//
{
PRDBSS_DEVICE_OBJECT MyDo = (PRDBSS_DEVICE_OBJECT)RxFileSystemDeviceObject;
LONG Index;
for (Index = 0; Index < MaximumWorkQueue; Index++) {
MyDo->OverflowQueueCount[Index] = 0;
InitializeListHead( &MyDo->OverflowQueue[Index] );
MyDo->PostedRequestCount[Index] = 0;
}
KeInitializeSpinLock( &MyDo->OverflowQueueSpinLock );
}
//
// Initialize dispatch vector for driver object AND ALSO FOR the devicefcb
RxInitializeDispatchVectors(DriverObject);
ExInitializeResourceLite( &RxData.Resource );
//
// Set up global pointer to our process.
RxData.OurProcess = PsGetCurrentProcess();
//
// Put in a bunch of sanity checks about various structures...hey, it's init code!
IF_DEBUG {
ULONG FcbStateBufferingMask = FCB_STATE_BUFFERING_STATE_MASK;
ULONG MinirdrBufStateCommandMask = MINIRDR_BUFSTATE_COMMAND_MASK;
USHORT EightBitsPerChar = 8;
//we could put in defines for the ULONG/USHORTS here...but they don't change often
ASSERT ( MRDRBUFSTCMD_MAXXX == (sizeof(ULONG)*EightBitsPerChar) );
ASSERT (!(FcbStateBufferingMask&MinirdrBufStateCommandMask));
}
//
// Setup the timer subsystem
RxInitializeRxTimer();
#ifndef MONOLITHIC_MINIRDR
Status = IoWMIRegistrationControl ((PDEVICE_OBJECT)RxFileSystemDeviceObject, WMIREG_ACTION_REGISTER);
if (Status != STATUS_SUCCESS) {
DbgPrint("Rdbss fails to register WMI %lx\n",Status);
} else {
EnableWmiLog = TRUE;
}
#endif
return( STATUS_SUCCESS );
}
//
// Unload routine
//
VOID
RxUnload(
IN PDRIVER_OBJECT DriverObject
)
/*++
Routine Description:
This is the unload routine for the RDBSS.
Arguments:
DriverObject - pointer to the driver object for the RDBSS
Return Value:
None
--*/
{
//UNICODE_STRING LinkName;
PAGED_CODE();
RxTearDownRxTimer();
//remember this
// RdrUnloadSecurity();
RxDbgTrace( 0, (DEBUG_TRACE_ALWAYS), ("RxUnload: DriverObject =%08lx\n", DriverObject ));
ExDeleteResourceLite(&RxData.Resource);
RxUninitializeBackoffPackage();
RxTearDownDispatcher();
RxTearDownDebugSupport();
ExDeleteNPagedLookasideList(
&RxContextLookasideList);
RxInitUnwind(DriverObject, RXINIT_ALL_INITIALIZATION_COMPLETED);
if (EnableWmiLog) {
NTSTATUS Status;
Status = IoWMIRegistrationControl ((PDEVICE_OBJECT)RxFileSystemDeviceObject, WMIREG_ACTION_DEREGISTER);
if (Status != STATUS_SUCCESS) {
DbgPrint("Rdbss fails to deregister WMI %lx\n",Status);
}
}
}
#if DBG
PCHAR RxUnwindFollower = NULL;
#define UNWIND_CASE(x) case x: RxUnwindFollower = #x;
#else
#define UNWIND_CASE(x) case x:
#endif
VOID
RxInitUnwind(
IN PDRIVER_OBJECT DriverObject,
IN RX_INIT_STATES RxInitState
)
/*++
Routine Description:
This routine does the common uninit work for unwinding from a bad driver entry or for unloading.
Arguments:
RxInitState - tells how far we got into the intialization
Return Value:
None
--*/
{
#ifndef MONOLITHIC_MINIRDR
UNICODE_STRING LinkName;
#endif
PAGED_CODE();
switch (RxInitState) {
UNWIND_CASE(RXINIT_ALL_INITIALIZATION_COMPLETED)
//Nothing extra to do...this is just so that the constant in RxUnload doesn't change.......
//lack of break intentional
UNWIND_CASE(RXINIT_CONSTRUCTED_PROVIDERORDER)
RxUninitializeRegistrationStructures();
//lack of break intentional
UNWIND_CASE(RXINIT_CREATED_LOG)
RxUninitializeLog();
//lack of break intentional
#ifndef MONOLITHIC_MINIRDR
UNWIND_CASE(RXINIT_CREATED_DEVICE_OBJECT)
IoDeleteDevice((PDEVICE_OBJECT)RxFileSystemDeviceObject);
//lack of break intentional
UNWIND_CASE(RXINIT_CREATED_FIRST_LINK)
RtlInitUnicodeString(&LinkName, RX_SYMLINK_NAME);
IoDeleteSymbolicLink(&LinkName);
// lack of break intentional
#endif
UNWIND_CASE(RXINIT_START)
//RdrUninitializeDiscardableCode();
//DbgBreakPoint();
break;
}
}
VOID
RxAbbreviatedWriteLogEntry__ (
IN NTSTATUS Status,
IN ULONG OneExtraUlong
)
/*++
Routine Description:
This routine write a log entry with most of the fields set to fixed values.
Arguments:
Status - the status to be stored in the log record
OneExtraUlong - a key for finding out what happened
Return Value:
none.
--*/
{
//RxLogFailureWithBuffer (
// RxFileSystemDeviceObject,
// NULL,
// EVENT_RDR_CANT_READ_REGISTRY,
// Status,
// &OneExtraUlong,
// sizeof(ULONG)
// );
}
VOID
RxGetRegistryParameters(
PUNICODE_STRING RegistryPath
)
{
ULONG Storage[256];
UNICODE_STRING UnicodeString;
HANDLE ConfigHandle;
HANDLE ParametersHandle;
NTSTATUS Status;
//ULONG BytesRead;
OBJECT_ATTRIBUTES ObjectAttributes;
PKEY_VALUE_FULL_INFORMATION Value = (PKEY_VALUE_FULL_INFORMATION)Storage;
PAGED_CODE(); //INIT
InitializeObjectAttributes(
&ObjectAttributes,
RegistryPath, // name
OBJ_CASE_INSENSITIVE, // attributes
NULL, // root
NULL // security descriptor
);
Status = ZwOpenKey (&ConfigHandle, KEY_READ, &ObjectAttributes);
if (!NT_SUCCESS(Status)) {
//RxLogFailure (
// RxFileSystemDeviceObject,
// NULL,
// EVENT_RDR_CANT_READ_REGISTRY,
// Status);
return;
}
RtlInitUnicodeString(&UnicodeString, L"Parameters");
InitializeObjectAttributes(
&ObjectAttributes,
&UnicodeString,
OBJ_CASE_INSENSITIVE,
ConfigHandle,
NULL
);
Status = ZwOpenKey (&ParametersHandle, KEY_READ, &ObjectAttributes);
if (!NT_SUCCESS(Status)) {
//RxLogFailure (
// RxFileSystemDeviceObject,
// NULL,
// EVENT_RDR_CANT_READ_REGISTRY,
// Status);
ZwClose(ConfigHandle);
return;
}
#ifdef RDBSSLOG
RxGetStringRegistryParameter(ParametersHandle,
L"InitialDebugString",
&UnicodeString,
(PKEY_VALUE_PARTIAL_INFORMATION) Storage,
sizeof(Storage),
FALSE
);
//DbgPrint("String From Registry %wZ, buffer = %08lx\n",&UnicodeString,UnicodeString.Buffer);
if (UnicodeString.Length && UnicodeString.Length<320) {
PWCH u = UnicodeString.Buffer;
ULONG l;
PCH p = (PCH)u;
for (l=0;l<UnicodeString.Length;l++) {
*p++ = (CHAR)*u++;
*p = 0;
}
DbgPrint("InitialDebugString From Registry as singlebytestring: <%s>\n",UnicodeString.Buffer);
RxDebugControlCommand((PCH)UnicodeString.Buffer);
}
#endif //RDBSSLOG
ZwClose(ParametersHandle);
ZwClose(ConfigHandle);
}
NTSTATUS
RxGetStringRegistryParameter(
HANDLE ParametersHandle,
PWCHAR ParameterName,
PUNICODE_STRING ParamString,
PKEY_VALUE_PARTIAL_INFORMATION Value,
ULONG ValueSize,
BOOLEAN LogFailure
)
{
UNICODE_STRING UnicodeString;
NTSTATUS Status;
ULONG BytesRead;
PAGED_CODE(); //INIT
RtlInitUnicodeString(&UnicodeString, ParameterName);
Status = ZwQueryValueKey(ParametersHandle,
&UnicodeString,
KeyValuePartialInformation,
Value,
ValueSize,
&BytesRead);
ParamString->Length = 0;
ParamString->Buffer = NULL;
if (NT_SUCCESS(Status)) {
ParamString->Buffer = (PWCH)(&Value->Data[0]);
//the datalength actually accounts for the trailing null
ParamString->Length = ((USHORT)Value->DataLength) - sizeof(WCHAR);
ParamString->MaximumLength = ParamString->Length;
return STATUS_SUCCESS;
}
if (!LogFailure) { return Status; }
RxLogFailure (
RxFileSystemDeviceObject,
NULL,
EVENT_RDR_CANT_READ_REGISTRY,
Status);
return Status;
}
NTSTATUS
RxGetUlongRegistryParameter(
HANDLE ParametersHandle,
PWCHAR ParameterName,
PULONG ParamUlong,
PKEY_VALUE_PARTIAL_INFORMATION Value,
ULONG ValueSize,
BOOLEAN LogFailure
)
{
UNICODE_STRING UnicodeString;
NTSTATUS Status;
ULONG BytesRead;
PAGED_CODE(); //INIT
RtlInitUnicodeString(&UnicodeString, ParameterName);
Status = ZwQueryValueKey(ParametersHandle,
&UnicodeString,
KeyValuePartialInformation,
Value,
ValueSize,
&BytesRead);
if (NT_SUCCESS(Status)) {
if (Value->Type == REG_DWORD) {
PULONG ConfigValue = (PULONG)&Value->Data[0];
*ParamUlong = *((PULONG)ConfigValue);
DbgPrint("readRegistryvalue %wZ = %08lx\n",&UnicodeString,*ParamUlong);
return(STATUS_SUCCESS);
} else {
Status = STATUS_INVALID_PARAMETER;
}
}
if (!LogFailure) { return Status; }
RxLogFailureWithBuffer (
RxFileSystemDeviceObject,
NULL,
EVENT_RDR_CANT_READ_REGISTRY,
Status,
ParameterName,
(USHORT)(wcslen(ParameterName)*sizeof(WCHAR))
);
return Status;
}
/*-------------------------------
This set of routines implements the network provider order in the wrapper.
The way that this works is somewhat complicated. First, we go to the registry
to get the provider order; it is stored at key=PROVIDERORDER_REGISTRY_KEY and
value=L"ProviderOrder". This is a list of service providers whereas what we need
are the device names. So, for each ServiceProverName, we go to the registry to
get the device name at key=SERVICE_REGISTRY_KEY, subkey=ServiceProverName,
subsubkey=NETWORK_PROVIDER_SUBKEY, and value=L"Devicename".
We build a linked list of these guys. Later when a minirdr registers, we look
on this list for the corresponding device name and that gives us the priority.
simple? i think NOT.
----------------------------------*/
#ifndef MONOLITHIC_MINIRDR
NTSTATUS
RxAccrueProviderFromServiceName (
HANDLE ServicesHandle,
PUNICODE_STRING ServiceName,
ULONG Priority,
PWCHAR ProviderInfoNameBuffer,
ULONG ProviderInfoNameBufferLength
);
NTSTATUS
RxConstructProviderOrder (
void
);
VOID
RxDestructProviderOrder (
void
);
#ifdef ALLOC_PRAGMA
#pragma alloc_text(INIT, RxAccrueProviderFromServiceName)
#pragma alloc_text(INIT, RxConstructProviderOrder)
#pragma alloc_text(PAGE, RxDestructProviderOrder)
#endif
#define PROVIDERORDER_REGISTRY_KEY L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\NetworkProvider\\Order"
#define SERVICE_REGISTRY_KEY L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\"
#define NETWORK_PROVIDER_SUBKEY L"\\networkprovider"
typedef struct _RX_UNC_PROVIDER_HEADER {
union {
LIST_ENTRY;
LIST_ENTRY Links;
};
ULONG Priority;
union {
UNICODE_STRING;
UNICODE_STRING DeviceName;
};
} RX_UNC_PROVIDER_HEADER;
typedef struct _RX_UNC_PROVIDER {
RX_UNC_PROVIDER_HEADER;
KEY_VALUE_PARTIAL_INFORMATION Info;
} RX_UNC_PROVIDER, *PRX_UNC_PROVIDER;
LIST_ENTRY RxUncProviders;
ULONG
RxGetNetworkProviderPriority(
IN PUNICODE_STRING DeviceName
)
/*++
Routine Description:
This routine is called at minirdr registration time to find out the priority
of the provider with the given DeviceName. It simply looks it up on a list.
Arguments:
DeviceName - name of the device whose priority is to be found
Return Value:
the network provider priority that the MUP will use.
--*/
{
PLIST_ENTRY Entry;
PAGED_CODE();
RxLog(("FindUncProvider %wZ \n",DeviceName));
RxWmiLog(LOG,
RxGetNetworkProviderPriority,
LOGUSTR(*DeviceName));
for (Entry = RxUncProviders.Flink;
Entry != &RxUncProviders;
) {
PRX_UNC_PROVIDER UncProvider = (PRX_UNC_PROVIDER)Entry;
Entry = Entry->Flink;
if ( RtlEqualUnicodeString( DeviceName, &UncProvider->DeviceName, TRUE )) {
return(UncProvider->Priority);
}
}
// no corresponding entry was found
return(0x7effffff); //got this constant from the MUP........
}
NTSTATUS
RxAccrueProviderFromServiceName (
HANDLE ServicesHandle,
PUNICODE_STRING ServiceName,
ULONG Priority,
PWCHAR ProviderInfoNameBuffer,
ULONG ProviderInfoNameBufferLength
)
/*++
Routine Description:
This routine has the responsibility to look up the device name corresponding
to a particular provider name; if successful, the device name and the corresponding
priority are recorded on the UncProvider List.
Arguments:
HANDLE ServicesHandle - a handle to the services root in the registry
PUNICODE_STRING ServiceName - the name of the service relative to the servicehandle
ULONG Priority, - the priority of this provider
PWCHAR ProviderInfoNameBuffer, - a buffer that can be used to accrue the subkey name
ULONG ProviderInfoNameBufferLength - and the length
Return Value:
STATUS_SUCCESS if everything worked elsewise an error status.
--*/
{
NTSTATUS Status;
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING ProviderInfoName,ProviderInfoKey,ParameterDeviceName;
HANDLE NetworkProviderInfoHandle = INVALID_HANDLE_VALUE;
KEY_VALUE_PARTIAL_INFORMATION InitialValuePartialInformation;
ULONG DummyBytesRead,ProviderLength;
PRX_UNC_PROVIDER UncProvider = NULL;
PAGED_CODE();
RxLog(("SvcNm %wZ",ServiceName));
RxWmiLog(LOG,
RxAccrueProviderFromServiceName_1,
LOGUSTR(*ServiceName));
//
// Form the correct keyname using the bufferspace provided
ProviderInfoName.Buffer = ProviderInfoNameBuffer;
ProviderInfoName.Length = 0;
ProviderInfoName.MaximumLength = (USHORT)ProviderInfoNameBufferLength;
Status = RtlAppendUnicodeStringToString(&ProviderInfoName,ServiceName);
if (Status != STATUS_SUCCESS) {
DbgPrint("Could append1: %08lx %wZ\n",Status,&ProviderInfoName);
//RxAbbreviatedWriteLogEntry(Status);
goto FINALLY;
}
RtlInitUnicodeString(&ProviderInfoKey, NETWORK_PROVIDER_SUBKEY);
Status = RtlAppendUnicodeStringToString(&ProviderInfoName,&ProviderInfoKey);
if (Status != STATUS_SUCCESS) {
DbgPrint("Could append2: %08lx %wZ\n",Status,&ProviderInfoName);
RxAbbreviatedWriteLogEntry(Status);
goto FINALLY;
}
//
// Open the key in preparation for reeading the devicename value
//DbgPrint("RxAccrueProviderFromServiceName providerinfoname %wZ\n",&ProviderInfoName);
InitializeObjectAttributes(
&ObjectAttributes,
&ProviderInfoName, // name
OBJ_CASE_INSENSITIVE, // attributes
ServicesHandle, // root
NULL // security descriptor
);
Status = ZwOpenKey (&NetworkProviderInfoHandle, KEY_READ, &ObjectAttributes);
if (!NT_SUCCESS(Status)) {
DbgPrint("NetWorkProviderInfoFailed: %08lx %wZ\n",Status,&ProviderInfoName);
RxAbbreviatedWriteLogEntry(Status);
goto FINALLY;
}
//
// Read the devicename. we do this in two steps. first, we do a partial read to find out
// how big the name really is. Then, we allocate a UncProviderEntry of the correctsize and make
// a second call to fill it in.
//DbgPrint("RxAccrueProviderFromServiceName ServiceName %wZ; worked\n",ServiceName);
RtlInitUnicodeString(&ParameterDeviceName, L"DeviceName");
Status = ZwQueryValueKey(NetworkProviderInfoHandle,
&ParameterDeviceName,
KeyValuePartialInformation,
&InitialValuePartialInformation,
sizeof(InitialValuePartialInformation),
&DummyBytesRead);
if (Status==STATUS_BUFFER_OVERFLOW) {
Status=STATUS_SUCCESS;
}
if (Status!=STATUS_SUCCESS) {
RxAbbreviatedWriteLogEntry(Status);
goto FINALLY;
}
//DbgPrint("RxAccrueProviderFromServiceName ServiceName %wZ; worked; devicenamesize=%08lx\n",
// ServiceName,InitialValuePartialInformation.DataLength);
ProviderLength = sizeof(RX_UNC_PROVIDER)+InitialValuePartialInformation.DataLength;
UncProvider = RxAllocatePoolWithTag(PagedPool | POOL_COLD_ALLOCATION ,ProviderLength,RX_MRX_POOLTAG);
if (UncProvider==NULL) {
Status = STATUS_INSUFFICIENT_RESOURCES;
DbgPrint("UncProviderAllocationFailed: %08lx %wZ\n",Status,&ProviderInfoName);
RxAbbreviatedWriteLogEntry(Status);
goto FINALLY;
}
Status = ZwQueryValueKey(NetworkProviderInfoHandle,
&ParameterDeviceName,
KeyValuePartialInformation,
&UncProvider->Info,
ProviderLength,
&DummyBytesRead);
if (Status!=STATUS_SUCCESS) {
RxAbbreviatedWriteLogEntry(Status);
goto FINALLY;
}
//
// Finish filling in the UncProviderEntry and link it in
UncProvider->Buffer = (PWCHAR)(&UncProvider->Info.Data[0]);
UncProvider->Length = (USHORT)(UncProvider->Info.DataLength-sizeof(WCHAR)); //dont include trailing NULL
UncProvider->MaximumLength = UncProvider->Length;
UncProvider->Priority = Priority;
InsertTailList(&RxUncProviders,&UncProvider->Links);
RxLog(("Dvc p=%lx Nm %wZ",UncProvider->Priority,&UncProvider->DeviceName));
RxWmiLog(LOG,
RxAccrueProviderFromServiceName_2,
LOGULONG(UncProvider->Priority)
LOGUSTR(UncProvider->DeviceName));
UncProvider = NULL;
FINALLY:
//
// if we obtained a handle to ...\\services\<sevicename>\providerinfo then close it
if (NetworkProviderInfoHandle!=INVALID_HANDLE_VALUE) ZwClose(NetworkProviderInfoHandle);
if (UncProvider != NULL) {
RxFreePool(UncProvider);
}
return Status;
}
NTSTATUS
RxConstructProviderOrder(
void
)
/*++
Routine Description:
This routine has the responsibility to build the list of network providers
that is used to look up provider priority at minirdr registration time. It does this
by first reading the providerorder string fron the registry; then for each provider
listed in the string, a helper routine is called to lookup the corresponding device
name and insert an entry on the provider list.
Arguments:
none.
Return Value:
STATUS_SUCCESS if everything worked elsewise an error status.
--*/
{
KEY_VALUE_PARTIAL_INFORMATION InitialValuePartialInformation;
UNICODE_STRING ProviderOrderValueName;
ULONG DummyBytesRead;
PBYTE ProviderOrderStringBuffer;
PBYTE ServiceNameStringBuffer = NULL;
ULONG ProviderOrderStringLength,ServiceNameStringLength,AllocationLength;
UNICODE_STRING UnicodeString;
UNICODE_STRING ProviderOrder;
PWCHAR ScanPtr,FinalScanPtr;
HANDLE NPOrderHandle = INVALID_HANDLE_VALUE;
HANDLE ServiceRootHandle = INVALID_HANDLE_VALUE;
NTSTATUS Status;
OBJECT_ATTRIBUTES ObjectAttributes;
ULONG Priority = 0;
PAGED_CODE();
RxLog(("RxConstructProviderOrder"));
RxWmiLog(LOG,
RxConstructProviderOrder_1,
LOGULONG(Priority));
InitializeListHead(&RxUncProviders);
//
// Start by opening the service registry key. This is the root key of all services
// and is used for relative opens by the helper routine so that string manipulation
// is reduced.
RtlInitUnicodeString(&UnicodeString, SERVICE_REGISTRY_KEY);
InitializeObjectAttributes(
&ObjectAttributes,
&UnicodeString, // name
OBJ_CASE_INSENSITIVE, // attributes
NULL, // root
NULL // security descriptor
);
Status = ZwOpenKey (&ServiceRootHandle, KEY_READ, &ObjectAttributes);
if (!NT_SUCCESS(Status)) {
DbgPrint("ServiceRootOpenFailed: %08lx %wZ\n",Status,&UnicodeString);
RxAbbreviatedWriteLogEntry(Status);
goto FINALLY;
}
//
// Now open up the key where we find the provider order string
RtlInitUnicodeString(&UnicodeString, PROVIDERORDER_REGISTRY_KEY);
InitializeObjectAttributes(
&ObjectAttributes,
&UnicodeString, // name
OBJ_CASE_INSENSITIVE, // attributes
NULL, // root
NULL // security descriptor
);
Status = ZwOpenKey (&NPOrderHandle, KEY_READ, &ObjectAttributes);
if (!NT_SUCCESS(Status)) {
DbgPrint("NetProviderOpenFailed: %08lx %wZ\n",Status,&UnicodeString);
RxAbbreviatedWriteLogEntry(Status);
goto FINALLY;
}
//
//Find out how long the provider order string is
RtlInitUnicodeString(&ProviderOrderValueName, L"ProviderOrder");
Status = ZwQueryValueKey(NPOrderHandle,
&ProviderOrderValueName,
KeyValuePartialInformation,
&InitialValuePartialInformation,
sizeof(InitialValuePartialInformation),
&DummyBytesRead);
if (Status==STATUS_BUFFER_OVERFLOW) {
Status=STATUS_SUCCESS;
}
if (Status!=STATUS_SUCCESS) {
DbgPrint("ProviderOrderStringPartialInfoFailed: %08lx %wZ\n",Status,&ProviderOrderValueName);
RxAbbreviatedWriteLogEntry(Status);
goto FINALLY;
}
//
// allocate two buffers: one buffer will hold the provider string -- ProviderOrderStringBuffer.
// it has to be as long as the providerorder string plus enough extra for the registry
// structure used in the call. the second buffer is used to hold the servicename key--it has
// to be as long as any element of the provider string plus enough extra to hold the suffix
// NETWORK_PROVIDER_SUBKEY. in order to only parse the string once, we just allocate for a complete
// additional copy of the provider string. we actually combine these into a single allocation.
ProviderOrderStringLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + InitialValuePartialInformation.DataLength;
ProviderOrderStringLength = QuadAlign(ProviderOrderStringLength +2*sizeof(WCHAR)); //chars added below
ServiceNameStringLength = sizeof(NETWORK_PROVIDER_SUBKEY) + InitialValuePartialInformation.DataLength;
ServiceNameStringLength = QuadAlign(ServiceNameStringLength);
AllocationLength = ProviderOrderStringLength + ServiceNameStringLength;
RxLog(("prov string=%lx,alloc=%lx\n",
InitialValuePartialInformation.DataLength,
AllocationLength));
RxWmiLog(LOG,
RxConstructProviderOrder_2,
LOGULONG(InitialValuePartialInformation.DataLength)
LOGULONG(AllocationLength));
ServiceNameStringBuffer = RxAllocatePoolWithTag(PagedPool | POOL_COLD_ALLOCATION,AllocationLength,RX_MRX_POOLTAG);
if (ServiceNameStringBuffer==NULL) {
Status = STATUS_INSUFFICIENT_RESOURCES;
RxAbbreviatedWriteLogEntry(Status);
goto FINALLY;
}
ProviderOrderStringBuffer = ServiceNameStringBuffer+ServiceNameStringLength;
//
// now do the final read to get the providerorder string
RxGetStringRegistryParameter(NPOrderHandle,
L"ProviderOrder",
&ProviderOrder,
(PKEY_VALUE_PARTIAL_INFORMATION) ProviderOrderStringBuffer,
ProviderOrderStringLength,
FALSE
);
if (ProviderOrder.Buffer == NULL) {
Status = STATUS_UNSUCCESSFUL;
RxAbbreviatedWriteLogEntry(Status);
goto FINALLY;
}
//
// comma-terminate the string for easier living. then scan down the string
// looking for comma terminated entries. for each entry found, try to accrue
// it to the list
ProviderOrder.Buffer[ProviderOrder.Length/sizeof(WCHAR)] = L',';
ScanPtr = ProviderOrder.Buffer;
FinalScanPtr = ScanPtr+(ProviderOrder.Length/sizeof(WCHAR));
for (;;) {
UNICODE_STRING ServiceName;
// check for loop termination
if (ScanPtr >= FinalScanPtr) { break; }
if (*ScanPtr==L',') { ScanPtr++; continue; }
// parse for a servicename
ServiceName.Buffer = ScanPtr;
for (;*ScanPtr!=L',';ScanPtr++) {
//DbgPrint("Considering %c\n",*ScanPtr);
}
ASSERT(*ScanPtr==L',');
ServiceName.Length = (USHORT)(sizeof(WCHAR)*(ScanPtr - ServiceName.Buffer));
//DbgPrint("Length %08lx\n",ServiceName.Length);
//DbgPrint("ServiceName %wZ\n",&ServiceName);
// accrue it to the list
Priority++;
Status = RxAccrueProviderFromServiceName(ServiceRootHandle,
&ServiceName,
Priority,
(PWCHAR)ServiceNameStringBuffer,
ServiceNameStringLength );
if (Status == STATUS_INSUFFICIENT_RESOURCES) {
goto FINALLY; //a log entry has already been generated
} else {
Status = STATUS_SUCCESS;
}
}
FINALLY:
//
// give back anything that we got in this procedure
if (NPOrderHandle!=INVALID_HANDLE_VALUE) ZwClose(NPOrderHandle);
if (ServiceRootHandle!=INVALID_HANDLE_VALUE) ZwClose(ServiceRootHandle);
if (ServiceNameStringBuffer!=NULL) RxFreePool(ServiceNameStringBuffer);
//
// if things didn't work, then we won't start....so give back
// the stuff that we have
if (!NT_SUCCESS(Status)) {
RxDestructProviderOrder();
}
return Status;
}
VOID
RxDestructProviderOrder(
void
)
{
PLIST_ENTRY Entry;
PAGED_CODE();
//DbgPrint("RxDestructProviderOrder \n");
for (Entry = RxUncProviders.Flink;
Entry != &RxUncProviders;
) {
PRX_UNC_PROVIDER UncProvider = (PRX_UNC_PROVIDER)Entry;
Entry = Entry->Flink;
//DbgPrint("RxDO UncP %wZ p=%x\n",&UncProvider->DeviceName,UncProvider->Priority);
RxFreePool(UncProvider);
}
return;
}
#else
ULONG
RxGetNetworkProviderPriority(
PUNICODE_STRING DeviceName
)
{
PAGED_CODE(); //DUPLICATE
return(1); //this number is irrelevant for monolithic
}
#endif //#ifndef MONOLITHIC_MINIRDR
NTSTATUS
RxInitializeRegistrationStructures(
void
)
{
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
ExInitializeFastMutex(&RxData.MinirdrRegistrationMutex);
RxData.NumberOfMinirdrsRegistered = 0;
RxData.NumberOfMinirdrsStarted = 0;
InitializeListHead( &RxData.RegisteredMiniRdrs );
#ifndef MONOLITHIC_MINIRDR
Status = RxConstructProviderOrder();
#endif
return(Status);
}
VOID
RxUninitializeRegistrationStructures(
void
)
{
PAGED_CODE();
#ifndef MONOLITHIC_MINIRDR
RxDestructProviderOrder();
#endif
}
VOID
RxInitializeMinirdrDispatchTable(
IN PDRIVER_OBJECT DriverObject
)
{
PAGED_CODE();
#ifndef MONOLITHIC_MINIRDR
{ULONG i;
//finally, fill in the dispatch tables for normal guys.........
for (i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; i++) {
DriverObject->MajorFunction[i] = RxData.DriverObject->MajorFunction[i];
}}
DriverObject->FastIoDispatch = RxData.DriverObject->FastIoDispatch;
#endif
}
VOID
NTAPI
__RxFillAndInstallFastIoDispatch(
IN PRDBSS_DEVICE_OBJECT RxDeviceObject,
IN OUT PFAST_IO_DISPATCH FastIoDispatch,
IN ULONG FastIoDispatchSize
)
/*++
Routine Description:
This routine fills out a fastiodispatch vector to be identical with
that normal one and installs it into the driver object associated with
the device object passed.
Arguments:
RxDeviceObject - the device object that is to have its driver's fastiodispatch changed
FastIoDispatch - the fastiodispatch table to fill in and use
FastIoDispatchSize - the size of the table passed
Return Value:
NONE
--*/
{
ULONG TableSize = min(FastIoDispatchSize,
RxFastIoDispatch.SizeOfFastIoDispatch);
PAGED_CODE();
#ifndef MONOLITHIC_MINIRDR
RtlCopyMemory(FastIoDispatch,&RxFastIoDispatch,TableSize);
FastIoDispatch->SizeOfFastIoDispatch = TableSize;
RxDeviceObject->DriverObject->FastIoDispatch = FastIoDispatch;
return;
#endif
}
VOID
RxReadRegistryParameters(
void
)
{
ULONG Storage[16];
UNICODE_STRING UnicodeString;
HANDLE ParametersHandle;
NTSTATUS Status;
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING WorkStationParametersRegistryKeyName;
PKEY_VALUE_PARTIAL_INFORMATION Value = (PKEY_VALUE_PARTIAL_INFORMATION)Storage;
ULONG ValueSize;
ULONG BytesRead;
PAGED_CODE(); //INIT
RtlInitUnicodeString(&WorkStationParametersRegistryKeyName,
LANMAN_WORKSTATION_PARAMETERS);
ValueSize = sizeof(Storage);
InitializeObjectAttributes(
&ObjectAttributes,
&WorkStationParametersRegistryKeyName, // name
OBJ_CASE_INSENSITIVE, // attributes
NULL, // root
NULL // security descriptor
);
Status = ZwOpenKey (&ParametersHandle, KEY_READ, &ObjectAttributes);
if (!NT_SUCCESS(Status)) {
//RxLogFailure (
// RxFileSystemDeviceObject,
// NULL,
// EVENT_RDR_CANT_READ_REGISTRY,
// Status);
return;
}
RtlInitUnicodeString(&UnicodeString, L"DisableByteRangeLockingOnReadOnlyFiles");
Status = ZwQueryValueKey(ParametersHandle,
&UnicodeString,
KeyValuePartialInformation,
Value,
ValueSize,
&BytesRead);
if (NT_SUCCESS(Status)) {
if (Value->Type == REG_DWORD) {
PULONG ConfigValue = (PULONG)&Value->Data[0];
DisableByteRangeLockingOnReadOnlyFiles =
(BOOLEAN) (*((PULONG)ConfigValue) != 0);
}
}
ZwClose(ParametersHandle);
}

Reference in a new issue Copy permalink