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
NonPnpDeviceAdd(
IN WDFDRIVER Driver,
IN PWDFDEVICE_INIT DeviceInit
)
/*++
Routine Description:
Called by the DriverEntry to create a control-device. This call is
responsible for freeing the memory for DeviceInit.
Arguments:
DriverObject - a pointer to the object that represents this device
driver.
DeviceInit - Pointer to a driver-allocated WDFDEVICE_INIT structure.
Return Value:
STATUS_SUCCESS if initialized; an error otherwise.
--*/
{
NTSTATUS status;
WDF_OBJECT_ATTRIBUTES attributes;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
WDF_FILEOBJECT_CONFIG fileConfig;
WDFQUEUE queue;
WDFDEVICE controlDevice;
DECLARE_CONST_UNICODE_STRING(ntDeviceName, NTDEVICE_NAME_STRING) ;
DECLARE_CONST_UNICODE_STRING(symbolicLinkName, SYMBOLIC_NAME_STRING) ;
UNREFERENCED_PARAMETER( Driver );
PAGED_CODE();
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_INIT,
"NonPnpDeviceAdd DeviceInit %p\n", DeviceInit);
//
// Set exclusive to TRUE so that no more than one app can talk to the
// control device at any time.
//
WdfDeviceInitSetExclusive(DeviceInit, TRUE);
WdfDeviceInitSetIoType(DeviceInit, WdfDeviceIoBuffered);
status = WdfDeviceInitAssignName(DeviceInit, &ntDeviceName);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT, "WdfDeviceInitAssignName failed %!STATUS!", status);
goto End;
}
WdfControlDeviceInitSetShutdownNotification(DeviceInit,
NonPnpShutdown,
WdfDeviceShutdown);
//
// Initialize WDF_FILEOBJECT_CONFIG_INIT struct to tell the
// framework whether you are interested in handling Create, Close and
// Cleanup requests that gets generated when an application or another
// kernel component opens an handle to the device. If you don't register
// the framework default behaviour would be to complete these requests
// with STATUS_SUCCESS. A driver might be interested in registering these
// events if it wants to do security validation and also wants to maintain
// per handle (fileobject) context.
//
WDF_FILEOBJECT_CONFIG_INIT(
&fileConfig,
NonPnpEvtDeviceFileCreate,
NonPnpEvtFileClose,
WDF_NO_EVENT_CALLBACK // not interested in Cleanup
);
WdfDeviceInitSetFileObjectConfig(DeviceInit,
&fileConfig,
WDF_NO_OBJECT_ATTRIBUTES);
//
// In order to support METHOD_NEITHER Device controls, or
// NEITHER device I/O type, we need to register for the
// EvtDeviceIoInProcessContext callback so that we can handle the request
// in the calling threads context.
//
WdfDeviceInitSetIoInCallerContextCallback(DeviceInit,
NonPnpEvtDeviceIoInCallerContext);
//
// Specify the size of device context
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes,
CONTROL_DEVICE_EXTENSION);
status = WdfDeviceCreate(&DeviceInit,
&attributes,
&controlDevice);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT, "WdfDeviceCreate failed %!STATUS!", status);
goto End;
}
//
// Create a symbolic link for the control object so that usermode can open
// the device.
//
status = WdfDeviceCreateSymbolicLink(controlDevice,
&symbolicLinkName);
if (!NT_SUCCESS(status)) {
//
// Control device will be deleted automatically by the framework.
//
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT, "WdfDeviceCreateSymbolicLink failed %!STATUS!", status);
goto End;
}
//
// Configure a default queue so that requests that are not
// configure-fowarded using WdfDeviceConfigureRequestDispatching to goto
// other queues get dispatched here.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig,
WdfIoQueueDispatchSequential);
ioQueueConfig.EvtIoRead = FileEvtIoRead;
ioQueueConfig.EvtIoWrite = FileEvtIoWrite;
ioQueueConfig.EvtIoDeviceControl = FileEvtIoDeviceControl;
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
//
// Since we are using Zw function set execution level to passive so that
// framework ensures that our Io callbacks called at only passive-level
// even if the request came in at DISPATCH_LEVEL from another driver.
//
//attributes.ExecutionLevel = WdfExecutionLevelPassive;
//
// By default, Static Driver Verifier (SDV) displays a warning if it
// doesn't find the EvtIoStop callback on a power-managed queue.
// The 'assume' below causes SDV to suppress this warning. If the driver
// has not explicitly set PowerManaged to WdfFalse, the framework creates
// power-managed queues when the device is not a filter driver. Normally
// the EvtIoStop is required for power-managed queues, but for this driver
// it is not needed b/c the driver doesn't hold on to the requests or
// forward them to other drivers. This driver completes the requests
// directly in the queue's handlers. If the EvtIoStop callback is not
// implemented, the framework waits for all driver-owned requests to be
// done before moving in the Dx/sleep states or before removing the
// device, which is the correct behavior for this type of driver.
// If the requests were taking an indeterminate amount of time to complete,
// or if the driver forwarded the requests to a lower driver/another stack,
// the queue should have an EvtIoStop/EvtIoResume.
//
__analysis_assume(ioQueueConfig.EvtIoStop != 0);
status = WdfIoQueueCreate(controlDevice,
&ioQueueConfig,
&attributes,
&queue // pointer to default queue
);
__analysis_assume(ioQueueConfig.EvtIoStop == 0);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT, "WdfIoQueueCreate failed %!STATUS!", status);
goto End;
}
//
// Control devices must notify WDF when they are done initializing. I/O is
// rejected until this call is made.
//
WdfControlFinishInitializing(controlDevice);
End:
//
// If the device is created successfully, framework would clear the
// DeviceInit value. Otherwise device create must have failed so we
// should free the memory ourself.
//
if (DeviceInit != NULL) {
WdfDeviceInitFree(DeviceInit);
}
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
NdisProtCreateControlDevice(
IN WDFDRIVER Driver,
IN PWDFDEVICE_INIT DeviceInit
)
/*++
Routine Description:
Called by the DriverEntry to create a control-device. This call is
responsible for freeing the memory for DeviceInit.
Arguments:
Driver - a pointer to the framework object that represents this device
driver.
DeviceInit - Pointer to a driver-allocated WDFDEVICE_INIT structure.
Return Value:
STATUS_SUCCESS if initialized; an error otherwise.
--*/
{
NTSTATUS status;
WDF_OBJECT_ATTRIBUTES objectAttribs;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
WDF_FILEOBJECT_CONFIG fileConfig;
WDFDEVICE controlDevice = NULL;
WDFQUEUE queue;
DECLARE_CONST_UNICODE_STRING(ntDeviceName, NT_DEVICE_NAME) ;
DECLARE_CONST_UNICODE_STRING(dosDeviceName, DOS_DEVICE_NAME) ;
UNREFERENCED_PARAMETER( Driver );
DEBUGP(DL_LOUD, ("NdisProtCreateControlDevice DeviceInit %p\n", DeviceInit));
//
// I/O type is Buffered by default. We want to do direct I/O for Reads
// and Writes so set it explicitly.
//
WdfDeviceInitSetIoType(DeviceInit, WdfDeviceIoDirect);
status = WdfDeviceInitAssignName(DeviceInit, &ntDeviceName);
if (!NT_SUCCESS(status)) {
goto Error;
}
//
// Initialize WDF_FILEOBJECT_CONFIG_INIT struct to tell the
// framework whether you are interested in handle Create, Close and
// Cleanup requests that gets genereated when an application or another
// kernel component opens an handle to the device. If you don't register,
// the framework default behaviour would be complete these requests
// with STATUS_SUCCESS. A driver might be interested in registering these
// events if it wants to do security validation and also wants to maintain
// per handle (fileobject) context.
//
WDF_FILEOBJECT_CONFIG_INIT(
&fileConfig,
NdisProtEvtDeviceFileCreate,
NdisProtEvtFileClose,
NdisProtEvtFileCleanup
);
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&objectAttribs,
FILE_OBJECT_CONTEXT);
WdfDeviceInitSetFileObjectConfig(DeviceInit,
&fileConfig,
&objectAttribs);
WDF_OBJECT_ATTRIBUTES_INIT(&objectAttribs);
status = WdfDeviceCreate(&DeviceInit,
&objectAttribs,
&controlDevice);
if (!NT_SUCCESS(status)) {
goto Error;
}
//
// DeviceInit is set to NULL if the device is created successfully.
//
//
// Create a symbolic link for the control object so that usermode can open
// the device.
//
status = WdfDeviceCreateSymbolicLink(controlDevice, &dosDeviceName);
if (!NT_SUCCESS(status)) {
goto Error;
}
//
// Configure a default queue associated with the control device to
// to receive read, write, and ioctl requests in parallel.
// A default queue gets all the requests that are not
// configure-fowarded using WdfDeviceConfigureRequestDispatching.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig,
WdfIoQueueDispatchParallel);
ioQueueConfig.EvtIoWrite = NdisProtEvtIoWrite;
ioQueueConfig.EvtIoRead = NdisProtEvtIoRead;
ioQueueConfig.EvtIoDeviceControl = NdisProtEvtIoDeviceControl;
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);
//
// Create our device object using which an application can
// access NDIS devices.
//
Globals.ControlDevice = controlDevice;
return status;
Error:
if(DeviceInit != NULL) {
//
// Free the WDFDEVICE_INIT structure only if the device
// creation fails. Otherwise framework frees the memory
// itself.
//
WdfDeviceInitFree(DeviceInit);
}
return status;
}
