NTSTATUS
StreamEditInitDriverObjects(
_Inout_ DRIVER_OBJECT* driverObject,
const UNICODE_STRING* registryPath,
_Out_ WDFDRIVER* pDriver,
_Out_ WDFDEVICE* pDevice
)
{
NTSTATUS status;
WDF_DRIVER_CONFIG config;
PWDFDEVICE_INIT pInit = NULL;
WDF_DRIVER_CONFIG_INIT(&config, WDF_NO_EVENT_CALLBACK);
config.DriverInitFlags |= WdfDriverInitNonPnpDriver;
config.EvtDriverUnload = StreamEditEvtDriverUnload;
status = WdfDriverCreate(
driverObject,
registryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
pDriver
);
if (!NT_SUCCESS(status))
{
goto Exit;
}
pInit = WdfControlDeviceInitAllocate(*pDriver, &SDDL_DEVOBJ_KERNEL_ONLY);
if (!pInit)
{
status = STATUS_INSUFFICIENT_RESOURCES;
goto Exit;
}
WdfDeviceInitSetCharacteristics(pInit, FILE_AUTOGENERATED_DEVICE_NAME, TRUE);
WdfDeviceInitSetDeviceType(pInit, FILE_DEVICE_NETWORK);
WdfDeviceInitSetCharacteristics(pInit, FILE_DEVICE_SECURE_OPEN, TRUE);
status = WdfDeviceCreate(&pInit, WDF_NO_OBJECT_ATTRIBUTES, pDevice);
if (!NT_SUCCESS(status))
{
WdfDeviceInitFree(pInit);
goto Exit;
}
WdfControlFinishInitializing(*pDevice);
Exit:
return status;
}
NTSTATUS
DriverEntry(
IN OUT PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This routine is called by the Operating System to initialize the driver.
It creates the device object, fills in the dispatch entry points and
completes the initialization.
Arguments:
DriverObject - a pointer to the object that represents this device
driver.
RegistryPath - a pointer to our Services key in the registry.
Return Value:
STATUS_SUCCESS if initialized; an error otherwise.
--*/
{
NTSTATUS status;
WDF_DRIVER_CONFIG config;
WDFDRIVER hDriver;
PWDFDEVICE_INIT pInit = NULL;
WDF_OBJECT_ATTRIBUTES attributes;
KdPrint(("Driver Frameworks NONPNP Legacy Driver Example\n"));
KdPrint(("Driver built: %s %s\n", __DATE__, __TIME__));
WDF_DRIVER_CONFIG_INIT(
&config,
WDF_NO_EVENT_CALLBACK // This is a non-pnp driver.
);
//
// Tell the framework that this is non-pnp driver so that it doesn't
// set the default AddDevice routine.
//
config.DriverInitFlags |= WdfDriverInitNonPnpDriver;
//
// NonPnp driver must explicitly register an unload routine for
// the driver to be unloaded.
//
config.EvtDriverUnload = NonPnpEvtDriverUnload;
//
// Register a cleanup callback so that we can call WPP_CLEANUP when
// the framework driver object is deleted during driver unload.
//
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.EvtCleanupCallback = NonPnpEvtDriverContextCleanup;
//
// Create a framework driver object to represent our driver.
//
status = WdfDriverCreate(DriverObject,
RegistryPath,
&attributes,
&config,
&hDriver);
if (!NT_SUCCESS(status)) {
KdPrint (("NonPnp: WdfDriverCreate failed with status 0x%x\n", status));
return status;
}
//
// Since we are calling WPP_CLEANUP in the DriverContextCleanup
// callback we should initialize WPP Tracing after WDFDRIVER
// object is created to ensure that we cleanup WPP properly
// if we return failure status from DriverEntry. This
// eliminates the need to call WPP_CLEANUP in every path
// of DriverEntry.
//
WPP_INIT_TRACING( DriverObject, RegistryPath );
//
// On Win2K system, you will experience some delay in getting trace events
// due to the way the ETW is activated to accept trace messages.
//
KdPrint(("NonPnp: DriverEntry: tracing enabled\n"));
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_INIT,
"Driver Frameworks NONPNP Legacy Driver Example");
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_INIT,
"Driver built: %s %s", __DATE__, __TIME__);
//
//
// In order to create a control device, we first need to allocate a
// WDFDEVICE_INIT structure and set all properties.
//
pInit = WdfControlDeviceInitAllocate(
hDriver,
&SDDL_DEVOBJ_SYS_ALL_ADM_RWX_WORLD_RW_RES_R
);
if (pInit == NULL) {
status = STATUS_INSUFFICIENT_RESOURCES;
return status;
}
//
// Call NonPnpDeviceAdd to create a deviceobject to represent our
// software device.
//
status = NonPnpDeviceAdd(hDriver, pInit);
return status;
}
NTSTATUS
FilterCreateControlDevice(
WDFDEVICE Device
)
/*++
Routine Description:
This routine is called to create a control deviceobject so that application
can talk to the filter driver directly instead of going through the entire
device stack. This kind of control device object is useful if the filter
driver is underneath another driver which prevents ioctls not known to it
or if the driver's dispatch routine is owned by some other (port/class)
driver and it doesn't allow any custom ioctls.
NOTE: Since the control device is global to the driver and accessible to
all instances of the device this filter is attached to, we create only once
when the first instance of the device is started and delete it when the
last instance gets removed.
Arguments:
Device - Handle to a filter device object.
Return Value:
WDF status code
--*/
{
PWDFDEVICE_INIT pInit = NULL;
WDFDEVICE controlDevice = NULL;
WDF_OBJECT_ATTRIBUTES controlAttributes;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
BOOLEAN bCreate = FALSE;
NTSTATUS status;
WDFQUEUE queue;
DECLARE_CONST_UNICODE_STRING(ntDeviceName, NTDEVICE_NAME_STRING) ;
DECLARE_CONST_UNICODE_STRING(symbolicLinkName, SYMBOLIC_NAME_STRING) ;
PAGED_CODE();
//
// First find out whether any ControlDevice has been created. If the
// collection has more than one device then we know somebody has already
// created or in the process of creating the device.
//
WdfWaitLockAcquire(FilterDeviceCollectionLock, NULL);
if(WdfCollectionGetCount(FilterDeviceCollection) == 1) {
bCreate = TRUE;
}
WdfWaitLockRelease(FilterDeviceCollectionLock);
if(!bCreate) {
//
// Control device is already created. So return success.
//
return STATUS_SUCCESS;
}
KdPrint(("Creating Control Device\n"));
//
//
// In order to create a control device, we first need to allocate a
// WDFDEVICE_INIT structure and set all properties.
//
pInit = WdfControlDeviceInitAllocate(
WdfDeviceGetDriver(Device),
&SDDL_DEVOBJ_SYS_ALL_ADM_RWX_WORLD_RW_RES_R
);
if (pInit == NULL) {
status = STATUS_INSUFFICIENT_RESOURCES;
goto Error;
}
//
// Set exclusive to false so that more than one app can talk to the
// control device simultaneously.
//
WdfDeviceInitSetExclusive(pInit, FALSE);
status = WdfDeviceInitAssignName(pInit, &ntDeviceName);
if (!NT_SUCCESS(status)) {
goto Error;
}
//
// Specify the size of device context
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&controlAttributes,
CONTROL_DEVICE_EXTENSION);
status = WdfDeviceCreate(&pInit,
&controlAttributes,
&controlDevice);
if (!NT_SUCCESS(status)) {
goto Error;
}
//
// Create a symbolic link for the control object so that usermode can open
// the device.
//
status = WdfDeviceCreateSymbolicLink(controlDevice,
&symbolicLinkName);
if (!NT_SUCCESS(status)) {
goto Error;
}
//
// Configure the default queue associated with the control device object
// to be Serial so that request passed to EvtIoDeviceControl are serialized.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig,
WdfIoQueueDispatchSequential);
ioQueueConfig.EvtIoDeviceControl = FilterEvtIoDeviceControl;
//
// Framework by default creates non-power managed queues for
// filter drivers.
//
status = WdfIoQueueCreate(controlDevice,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue // pointer to default queue
);
if (!NT_SUCCESS(status)) {
goto Error;
}
//
// Control devices must notify WDF when they are done initializing. I/O is
// rejected until this call is made.
//
WdfControlFinishInitializing(controlDevice);
ControlDevice = controlDevice;
return STATUS_SUCCESS;
Error:
if (pInit != NULL) {
WdfDeviceInitFree(pInit);
}
if (controlDevice != NULL) {
//
// Release the reference on the newly created object, since
// we couldn't initialize it.
//
WdfObjectDelete(controlDevice);
controlDevice = NULL;
}
return status;
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
Called on loading. We create a device object to handle user-mode requests
on, and register ourselves as a protocol with NDIS.
Arguments:
pDriverObject - Pointer to driver object created by system.
pRegistryPath - Pointer to the Unicode name of the registry path
for this driver.
Return Value:
NT Status code
--*/
{
NDIS_PROTOCOL_DRIVER_CHARACTERISTICS protocolChar;
NTSTATUS status = STATUS_SUCCESS;
NDIS_STRING protoName = NDIS_STRING_CONST("NDISPROT");
WDF_DRIVER_CONFIG config;
WDFDRIVER hDriver;
PWDFDEVICE_INIT pInit = NULL;
UNREFERENCED_PARAMETER(RegistryPath);
DEBUGP(DL_LOUD, ("DriverEntry\n"));
Globals.DriverObject = DriverObject;
Globals.EthType = NPROT_ETH_TYPE;
NPROT_INIT_EVENT(&Globals.BindsComplete);
WDF_DRIVER_CONFIG_INIT(
&config,
WDF_NO_EVENT_CALLBACK // This is a non-pnp driver.
);
//
// Tell the framework that this is non-pnp driver so that it doesn't
// set the default AddDevice routine.
//
config.DriverInitFlags |= WdfDriverInitNonPnpDriver;
//
// We need an unload routine to free control device created below. For
// non-pnp drivers, framework doesn't provide Unload routine.
//
config.EvtDriverUnload = NdisProtEvtDriverUnload;
//
// Create a framework driver object to represent our driver.
//
status = WdfDriverCreate(DriverObject,
RegistryPath,
WDF_NO_OBJECT_ATTRIBUTES,
&config,
&hDriver);
if (!NT_SUCCESS(status)) {
DEBUGP(DL_ERROR, ("WdfDriverCreate failed with status 0x%x\n", status));
return status;
}
//
//
// In order to create a control device, we first need to allocate a
// WDFDEVICE_INIT structure and set all properties.
//
pInit = WdfControlDeviceInitAllocate(
hDriver,
&SDDL_DEVOBJ_SYS_ALL_ADM_RWX_WORLD_RW_RES_R
);
if (pInit == NULL) {
status = STATUS_INSUFFICIENT_RESOURCES;
return status;
}
//
// Call NdisProtDeviceAdd to create WDFDEVICE to represent our
// software device.
//
status = NdisProtCreateControlDevice(hDriver, pInit);
if (!NT_SUCCESS(status)) {
DEBUGP (DL_ERROR, ("NdisProtCreateControlDevice failed with status 0x%x\n", status));
return status;
}
//
// Initialize the protocol characterstic structure
//
NdisZeroMemory(&protocolChar,sizeof(NDIS_PROTOCOL_DRIVER_CHARACTERISTICS));
protocolChar.Header.Type = NDIS_OBJECT_TYPE_PROTOCOL_DRIVER_CHARACTERISTICS,
protocolChar.Header.Size = sizeof(NDIS_PROTOCOL_DRIVER_CHARACTERISTICS);
protocolChar.Header.Revision = NDIS_PROTOCOL_DRIVER_CHARACTERISTICS_REVISION_1;
protocolChar.MajorNdisVersion = 6;
protocolChar.MinorNdisVersion = 0;
protocolChar.Name = protoName;
protocolChar.SetOptionsHandler = NULL;
protocolChar.OpenAdapterCompleteHandlerEx = NdisprotOpenAdapterComplete;
protocolChar.CloseAdapterCompleteHandlerEx = NdisprotCloseAdapterComplete;
protocolChar.SendNetBufferListsCompleteHandler = NdisprotSendComplete;
protocolChar.OidRequestCompleteHandler = NdisprotRequestComplete;
protocolChar.StatusHandlerEx = NdisprotStatus;
protocolChar.UninstallHandler = NULL;
protocolChar.ReceiveNetBufferListsHandler = NdisprotReceiveNetBufferLists;
protocolChar.NetPnPEventHandler = NdisprotPnPEventHandler;
protocolChar.BindAdapterHandlerEx = NdisprotBindAdapter;
protocolChar.UnbindAdapterHandlerEx = NdisprotUnbindAdapter;
//
// Register as a protocol driver
//
status = NdisRegisterProtocolDriver(NULL, // driver context
&protocolChar,
&Globals.NdisProtocolHandle);
if (status != NDIS_STATUS_SUCCESS)
{
DEBUGP(DL_WARN, ("Failed to register protocol with NDIS\n"));
return STATUS_UNSUCCESSFUL;
}
NPROT_INIT_LIST_HEAD(&Globals.OpenList);
NPROT_INIT_LOCK(&Globals.GlobalLock);
Globals.PartialCancelId = NdisGeneratePartialCancelId();
Globals.PartialCancelId <<= ((sizeof(PVOID) - 1) * 8);
DEBUGP(DL_LOUD, ("DriverEntry: CancelId %lx\n", Globals.PartialCancelId));
return status;
}
