// Initialize the control device
void NeoInitControlDevice()
{
char name_kernel[MAX_SIZE];
char name_win32[MAX_SIZE];
UNICODE *unicode_kernel, *unicode_win32;
DEVICE_OBJECT *control_device_object;
NDIS_HANDLE ndis_control_handle;
NDIS_DEVICE_OBJECT_ATTRIBUTES t;
if (ctx == NULL)
{
return;
}
// Initialize the dispatch table
NeoZero(ctx->DispatchTable, sizeof(PDRIVER_DISPATCH) * IRP_MJ_MAXIMUM_FUNCTION);
// Register the handler
ctx->DispatchTable[IRP_MJ_CREATE] =
ctx->DispatchTable[IRP_MJ_CLOSE] =
ctx->DispatchTable[IRP_MJ_READ] =
ctx->DispatchTable[IRP_MJ_WRITE] =
ctx->DispatchTable[IRP_MJ_DEVICE_CONTROL] = NeoNdisDispatch;
ctx->Opened = FALSE;
// Generate the device name
sprintf(name_kernel, NDIS_NEO_DEVICE_NAME, ctx->HardwareID);
unicode_kernel = NewUnicode(name_kernel);
sprintf(name_win32, NDIS_NEO_DEVICE_NAME_WIN32, ctx->HardwareID);
unicode_win32 = NewUnicode(name_win32);
// Register the device
NeoZero(&t, sizeof(t));
t.Header.Type = NDIS_OBJECT_TYPE_DEVICE_OBJECT_ATTRIBUTES;
t.Header.Revision = NDIS_DEVICE_OBJECT_ATTRIBUTES_REVISION_1;
t.Header.Size = NDIS_SIZEOF_DEVICE_OBJECT_ATTRIBUTES_REVISION_1;
t.DeviceName = GetUnicode(unicode_kernel);
t.SymbolicName = GetUnicode(unicode_win32);
t.MajorFunctions = ctx->DispatchTable;
NdisRegisterDeviceEx(ndis_miniport_driver_handle, &t,
&control_device_object,
&ndis_control_handle);
ctx->NdisControlDevice = control_device_object;
ctx->NdisControl = ndis_control_handle;
// Initialize the display name
if (strlen(ctx->HardwareID) > 11)
{
sprintf(ctx->HardwarePrintableID, NDIS_NEO_HARDWARE_ID, ctx->HardwareID_Raw + 11);
}
else
{
sprintf(ctx->HardwarePrintableID, NDIS_NEO_HARDWARE_ID, ctx->HardwareID_Raw);
}
}
/*
* --------------------------------------------------------------------------
* Creates the communication device between user and kernel, and also
* initializes the data associated data structures.
* --------------------------------------------------------------------------
*/
NDIS_STATUS
OvsCreateDeviceObject(NDIS_HANDLE ovsExtDriverHandle)
{
NDIS_STATUS status = NDIS_STATUS_SUCCESS;
UNICODE_STRING deviceName;
UNICODE_STRING symbolicDeviceName;
PDRIVER_DISPATCH dispatchTable[IRP_MJ_MAXIMUM_FUNCTION+1];
NDIS_DEVICE_OBJECT_ATTRIBUTES deviceAttributes;
OVS_LOG_TRACE("ovsExtDriverHandle: %p", ovsExtDriverHandle);
RtlZeroMemory(dispatchTable,
(IRP_MJ_MAXIMUM_FUNCTION + 1) * sizeof (PDRIVER_DISPATCH));
dispatchTable[IRP_MJ_CREATE] = OvsOpenCloseDevice;
dispatchTable[IRP_MJ_CLOSE] = OvsOpenCloseDevice;
dispatchTable[IRP_MJ_CLEANUP] = OvsCleanupDevice;
dispatchTable[IRP_MJ_DEVICE_CONTROL] = OvsDeviceControl;
NdisInitUnicodeString(&deviceName, OVS_DEVICE_NAME_NT);
NdisInitUnicodeString(&symbolicDeviceName, OVS_DEVICE_NAME_DOS);
RtlZeroMemory(&deviceAttributes, sizeof (NDIS_DEVICE_OBJECT_ATTRIBUTES));
OVS_INIT_OBJECT_HEADER(&deviceAttributes.Header,
NDIS_OBJECT_TYPE_DEVICE_OBJECT_ATTRIBUTES,
NDIS_DEVICE_OBJECT_ATTRIBUTES_REVISION_1,
sizeof (NDIS_DEVICE_OBJECT_ATTRIBUTES));
deviceAttributes.DeviceName = &deviceName;
deviceAttributes.SymbolicName = &symbolicDeviceName;
deviceAttributes.MajorFunctions = dispatchTable;
deviceAttributes.ExtensionSize = sizeof (OVS_DEVICE_EXTENSION);
status = NdisRegisterDeviceEx(ovsExtDriverHandle,
&deviceAttributes,
&gOvsDeviceObject,
&gOvsDeviceHandle);
if (status != NDIS_STATUS_SUCCESS) {
POVS_DEVICE_EXTENSION ovsExt =
(POVS_DEVICE_EXTENSION)NdisGetDeviceReservedExtension(gOvsDeviceObject);
ASSERT(gOvsDeviceObject != NULL);
ASSERT(gOvsDeviceHandle != NULL);
if (ovsExt) {
ovsExt->numberOpenInstance = 0;
}
} else {
/* Initialize the associated data structures. */
OvsInit();
}
OVS_LOG_TRACE("DeviceObject: %p", gOvsDeviceObject);
return status;
}
//------------------------------------------------------------------------------
static void registerDrvIntf(NDIS_HANDLE driverHandle_p)
{
NDIS_STATUS status = NDIS_STATUS_SUCCESS;
UNICODE_STRING deviceName;
UNICODE_STRING deviceLinkUnicodeString;
NDIS_DEVICE_OBJECT_ATTRIBUTES deviceObjectAttributes;
PDRIVER_DISPATCH dispatchTable[IRP_MJ_MAXIMUM_FUNCTION + 1];
DEBUG_LVL_ALWAYS_TRACE("PLK %s()...\n", __func__);
plkDriverInstance_l.driverHandle = driverHandle_p;
NdisZeroMemory(dispatchTable, (IRP_MJ_MAXIMUM_FUNCTION + 1) * sizeof(PDRIVER_DISPATCH));
dispatchTable[IRP_MJ_CREATE] = powerlinkCreate;
dispatchTable[IRP_MJ_CLEANUP] = powerlinkCleanup;
dispatchTable[IRP_MJ_CLOSE] = powerlinkClose;
dispatchTable[IRP_MJ_DEVICE_CONTROL] = powerlinkIoctl;
NdisInitUnicodeString(&deviceName, PLK_DEV_STRING);
NdisInitUnicodeString(&deviceLinkUnicodeString, PLK_LINK_NAME);
NdisZeroMemory(&deviceObjectAttributes, sizeof(NDIS_DEVICE_OBJECT_ATTRIBUTES));
// type implicit from the context
deviceObjectAttributes.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
deviceObjectAttributes.Header.Revision = NDIS_DEVICE_OBJECT_ATTRIBUTES_REVISION_1;
deviceObjectAttributes.Header.Size = sizeof(NDIS_DEVICE_OBJECT_ATTRIBUTES);
deviceObjectAttributes.DeviceName = &deviceName;
deviceObjectAttributes.SymbolicName = &deviceLinkUnicodeString;
deviceObjectAttributes.MajorFunctions = &dispatchTable[0];
deviceObjectAttributes.ExtensionSize = 0;
deviceObjectAttributes.DefaultSDDLString = NULL;
deviceObjectAttributes.DeviceClassGuid = 0;
status = NdisRegisterDeviceEx(driverHandle_p,
&deviceObjectAttributes,
&plkDriverInstance_l.pDrvDeviceObject,
&plkDriverInstance_l.pDrvDeviceHandle);
if (status != NDIS_STATUS_SUCCESS)
{
DEBUG_LVL_ERROR_TRACE("%s() Failed to register interface device (0x%X)\n", status);
return;
}
plkDriverInstance_l.pDrvDeviceObject->Flags |= DO_BUFFERED_IO;
DEBUG_LVL_ALWAYS_TRACE("PLK %s() - OK\n", __func__);
}
NDIS_STATUS
FilterRegisterDevice(
VOID
)
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
UNICODE_STRING DeviceName;
UNICODE_STRING DeviceLinkUnicodeString;
PDRIVER_DISPATCH DispatchTable[IRP_MJ_MAXIMUM_FUNCTION+1];
NDIS_DEVICE_OBJECT_ATTRIBUTES DeviceAttribute;
PFILTER_DEVICE_EXTENSION FilterDeviceExtension;
DEBUGP(DL_TRACE, "==>FilterRegisterDevice\n");
NdisZeroMemory(DispatchTable, (IRP_MJ_MAXIMUM_FUNCTION+1) * sizeof(PDRIVER_DISPATCH));
DispatchTable[IRP_MJ_CREATE] = FilterDispatch;
DispatchTable[IRP_MJ_CLEANUP] = FilterDispatch;
DispatchTable[IRP_MJ_CLOSE] = FilterDispatch;
DispatchTable[IRP_MJ_DEVICE_CONTROL] = FilterDeviceIoControl;
DispatchTable[IRP_MJ_INTERNAL_DEVICE_CONTROL] = FilterInternalDeviceIoControl;
NdisInitUnicodeString(&DeviceName, NETMAP_NDIS_NTDEVICE_STRING);
NdisInitUnicodeString(&DeviceLinkUnicodeString, NETMAP_NDIS_LINKNAME_STRING);
//
// Create a device object and register our dispatch handlers
//
NdisZeroMemory(&DeviceAttribute, sizeof(NDIS_DEVICE_OBJECT_ATTRIBUTES));
DeviceAttribute.Header.Type = NDIS_OBJECT_TYPE_DEVICE_OBJECT_ATTRIBUTES;
DeviceAttribute.Header.Revision = NDIS_DEVICE_OBJECT_ATTRIBUTES_REVISION_1;
DeviceAttribute.Header.Size = sizeof(NDIS_DEVICE_OBJECT_ATTRIBUTES);
DeviceAttribute.DeviceName = &DeviceName;
DeviceAttribute.SymbolicName = &DeviceLinkUnicodeString;
DeviceAttribute.MajorFunctions = &DispatchTable[0];
DeviceAttribute.ExtensionSize = sizeof(FILTER_DEVICE_EXTENSION);
Status = NdisRegisterDeviceEx(
FilterDriverHandle,
&DeviceAttribute,
&DeviceObject,
&NdisFilterDeviceHandle
);
if (Status == NDIS_STATUS_SUCCESS)
{
FilterDeviceExtension = NdisGetDeviceReservedExtension(DeviceObject);
FilterDeviceExtension->Signature = 'FTDR';
FilterDeviceExtension->Handle = FilterDriverHandle;
}
DEBUGP(DL_TRACE, "<==FilterRegisterDevice: %x\n", Status);
return (Status);
}
NDIS_STATUS
PtRegisterDevice(
VOID
)
/*++
Routine Description:
Register an ioctl interface - a device object to be used for this
purpose is created by NDIS when we call NdisMRegisterDevice.
This routine is called whenever a new miniport instance is
initialized. However, we only create one global device object,
when the first miniport instance is initialized. This routine
handles potential race conditions with PtDeregisterDevice via
the ControlDeviceMutex.
NOTE: do not call this from DriverEntry; it will prevent the driver
from being unloaded (e.g. on uninstall).
Arguments:
None
Return Value:
NDIS_STATUS_SUCCESS if we successfully register a device object.
--*/
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
UNICODE_STRING DeviceName;
UNICODE_STRING DeviceLinkUnicodeString;
NDIS_DEVICE_OBJECT_ATTRIBUTES DeviceObjectAttributes;
PDRIVER_DISPATCH DispatchTable[IRP_MJ_MAXIMUM_FUNCTION+1];
DBGPRINT(MUX_LOUD, ("==>PtRegisterDevice\n"));
MUX_ACQUIRE_MUTEX(&ControlDeviceMutex);
++MiniportCount;
if (1 == MiniportCount)
{
NdisZeroMemory(DispatchTable, (IRP_MJ_MAXIMUM_FUNCTION+1) * sizeof(PDRIVER_DISPATCH));
DispatchTable[IRP_MJ_CREATE] = PtDispatch;
DispatchTable[IRP_MJ_CLEANUP] = PtDispatch;
DispatchTable[IRP_MJ_CLOSE] = PtDispatch;
DispatchTable[IRP_MJ_DEVICE_CONTROL] = PtDispatch;
NdisInitUnicodeString(&DeviceName, NTDEVICE_STRING);
NdisInitUnicodeString(&DeviceLinkUnicodeString, GLOBAL_LINKNAME_STRING);
NdisZeroMemory(&DeviceObjectAttributes, sizeof(NDIS_DEVICE_OBJECT_ATTRIBUTES));
DeviceObjectAttributes.Header.Type = NDIS_OBJECT_TYPE_DEFAULT; // type implicit from the context
DeviceObjectAttributes.Header.Revision = NDIS_DEVICE_OBJECT_ATTRIBUTES_REVISION_1;
DeviceObjectAttributes.Header.Size = sizeof(NDIS_DEVICE_OBJECT_ATTRIBUTES);
DeviceObjectAttributes.DeviceName = &DeviceName;
DeviceObjectAttributes.SymbolicName = &DeviceLinkUnicodeString;
DeviceObjectAttributes.MajorFunctions = &DispatchTable[0];
DeviceObjectAttributes.ExtensionSize = 0;
DeviceObjectAttributes.DefaultSDDLString = NULL;
DeviceObjectAttributes.DeviceClassGuid = 0;
Status = NdisRegisterDeviceEx(
DriverHandle,
&DeviceObjectAttributes,
&ControlDeviceObject,
&NdisDeviceHandle);
}
MUX_RELEASE_MUTEX(&ControlDeviceMutex);
DBGPRINT(MUX_INFO, ("<==PtRegisterDevice: %x\n", Status));
return (Status);
}
NDIS_STATUS
NDISFilterDriverRegisterDevice(OUT PFILTER_DEVICE_EXTENSION *Extension)
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
UNICODE_STRING DeviceName;
UNICODE_STRING DeviceLinkUnicodeString;
PDRIVER_DISPATCH DispatchTable[IRP_MJ_MAXIMUM_FUNCTION+1];
NDIS_DEVICE_OBJECT_ATTRIBUTES DeviceAttribute;
PFILTER_DEVICE_EXTENSION FilterDeviceExtension;
PDRIVER_OBJECT DriverObject;
DEBUGP(DL_TRACE, "==>NDISFilterDriverRegisterDevice\n");
NdisZeroMemory(DispatchTable, (IRP_MJ_MAXIMUM_FUNCTION+1) * sizeof(PDRIVER_DISPATCH));
DispatchTable[IRP_MJ_CREATE] = NDISFilterDriverDispatch;
DispatchTable[IRP_MJ_CLEANUP] = NDISFilterDriverDispatch;
DispatchTable[IRP_MJ_CLOSE] = NDISFilterDriverDispatch;
DispatchTable[IRP_MJ_DEVICE_CONTROL] = NDISFilterDriverDeviceIoControl;
NdisInitUnicodeString(&DeviceName, NTDEVICE_STRING);
NdisInitUnicodeString(&DeviceLinkUnicodeString, LINKNAME_STRING);
//
// Create a device object and register our dispatch handlers
//
NdisZeroMemory(&DeviceAttribute, sizeof(NDIS_DEVICE_OBJECT_ATTRIBUTES));
DeviceAttribute.Header.Type = NDIS_OBJECT_TYPE_DEVICE_OBJECT_ATTRIBUTES;
DeviceAttribute.Header.Revision = NDIS_DEVICE_OBJECT_ATTRIBUTES_REVISION_1;
DeviceAttribute.Header.Size = sizeof(NDIS_DEVICE_OBJECT_ATTRIBUTES);
DeviceAttribute.DeviceName = &DeviceName;
DeviceAttribute.SymbolicName = &DeviceLinkUnicodeString;
DeviceAttribute.MajorFunctions = &DispatchTable[0];
DeviceAttribute.ExtensionSize = sizeof(FILTER_DEVICE_EXTENSION);
Status = NdisRegisterDeviceEx(
FilterDriverHandle,
&DeviceAttribute,
&DeviceObject,
&NdisFilterDeviceHandle
);
if (Status == NDIS_STATUS_SUCCESS)
{
*Extension = FilterDeviceExtension = NdisGetDeviceReservedExtension(DeviceObject);
FilterDeviceExtension->Signature = 'FTDR';
FilterDeviceExtension->Handle = FilterDriverHandle;
KeInitializeSpinLock(&FilterDeviceExtension->QLock);
PRULES_LISTS FilterRules = ExAllocatePool(PagedPool, sizeof(RULES_LISTS));
FilterRules->IsActive = FALSE;
FilterRules->FirstRuleIPv4 = NULL;
FilterRules->FirstRuleIPv6 = NULL;
FilterDeviceExtension->FilterRules = FilterRules;
//
// Workaround NDIS bug
//
DriverObject = (PDRIVER_OBJECT)FilterDriverObject;
}
DEBUGP(DL_TRACE, "<==NDISFilterDriverRegisterDevice: %x\n", Status);
return (Status);
}
