NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT pDriverObject,
IN PUNICODE_STRING pRegistryPath
)
/*++
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 = {0};
NTSTATUS status = STATUS_SUCCESS;
NDIS_STRING protoName = NDIS_STRING_CONST("NDISPROT");
UNICODE_STRING ntDeviceName;
UNICODE_STRING win32DeviceName;
BOOLEAN fSymbolicLink = FALSE;
PDEVICE_OBJECT deviceObject = NULL;
NDIS_HANDLE ProtocolDriverContext={0};
UNREFERENCED_PARAMETER(pRegistryPath);
DEBUGP(DL_LOUD, ("DriverEntry\n"));
Globals.pDriverObject = pDriverObject;
Globals.EthType = NPROT_ETH_TYPE;
NPROT_INIT_EVENT(&Globals.BindsComplete);
do
{
//
// Create our device object using which an application can
// access NDIS devices.
//
RtlInitUnicodeString(&ntDeviceName, NT_DEVICE_NAME);
status = IoCreateDevice (pDriverObject,
0,
&ntDeviceName,
FILE_DEVICE_NETWORK,
FILE_DEVICE_SECURE_OPEN,
FALSE,
&deviceObject);
if (!NT_SUCCESS (status))
{
//
// Either not enough memory to create a deviceobject or another
// deviceobject with the same name exits. This could happen
// if you install another instance of this device.
//
break;
}
RtlInitUnicodeString(&win32DeviceName, DOS_DEVICE_NAME);
status = IoCreateSymbolicLink(&win32DeviceName, &ntDeviceName);
if (!NT_SUCCESS(status))
{
break;
}
fSymbolicLink = TRUE;
deviceObject->Flags |= DO_DIRECT_IO;
Globals.ControlDeviceObject = deviceObject;
NPROT_INIT_LIST_HEAD(&Globals.OpenList);
NPROT_INIT_LOCK(&Globals.GlobalLock);
//
// Initialize the protocol characterstic structure
//
#if (NDIS_SUPPORT_NDIS630)
{C_ASSERT(sizeof(protocolChar) >= NDIS_SIZEOF_PROTOCOL_DRIVER_CHARACTERISTICS_REVISION_2);}
protocolChar.Header.Type = NDIS_OBJECT_TYPE_PROTOCOL_DRIVER_CHARACTERISTICS,
protocolChar.Header.Size = NDIS_SIZEOF_PROTOCOL_DRIVER_CHARACTERISTICS_REVISION_2;
protocolChar.Header.Revision = NDIS_PROTOCOL_DRIVER_CHARACTERISTICS_REVISION_2;
#elif (NDIS_SUPPORT_NDIS6)
{C_ASSERT(sizeof(protocolChar) >= NDIS_SIZEOF_PROTOCOL_DRIVER_CHARACTERISTICS_REVISION_1);}
protocolChar.Header.Type = NDIS_OBJECT_TYPE_PROTOCOL_DRIVER_CHARACTERISTICS,
protocolChar.Header.Size = NDIS_SIZEOF_PROTOCOL_DRIVER_CHARACTERISTICS_REVISION_1;
protocolChar.Header.Revision = NDIS_PROTOCOL_DRIVER_CHARACTERISTICS_REVISION_1;
#endif // NDIS MINIPORT VERSION
protocolChar.MajorNdisVersion = NDIS_PROT_MAJOR_VERSION;
protocolChar.MinorNdisVersion = NDIS_PROT_MINOR_VERSION;
protocolChar.MajorDriverVersion = MAJOR_DRIVER_VERSION;
protocolChar.MinorDriverVersion = MINOR_DRIVER_VERISON;
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(ProtocolDriverContext, // driver context
&protocolChar,
&Globals.NdisProtocolHandle);
if (status != NDIS_STATUS_SUCCESS)
{
DEBUGP(DL_WARN, ("Failed to register protocol with NDIS\n"));
status = STATUS_UNSUCCESSFUL;
break;
}
Globals.PartialCancelId = NdisGeneratePartialCancelId();
Globals.PartialCancelId <<= ((sizeof(PVOID) - 1) * 8);
DEBUGP(DL_LOUD, ("DriverEntry: CancelId %lx\n", Globals.PartialCancelId));
//
// Now set only the dispatch points we would like to handle.
//
pDriverObject->MajorFunction[IRP_MJ_CREATE] = NdisprotOpen;
pDriverObject->MajorFunction[IRP_MJ_CLOSE] = NdisprotClose;
pDriverObject->MajorFunction[IRP_MJ_READ] = NdisprotRead;
pDriverObject->MajorFunction[IRP_MJ_WRITE] = NdisprotWrite;
pDriverObject->MajorFunction[IRP_MJ_CLEANUP] = NdisprotCleanup;
pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = NdisprotIoControl;
pDriverObject->DriverUnload = NdisprotUnload;
status = STATUS_SUCCESS;
}
while (FALSE);
if (!NT_SUCCESS(status))
{
if (deviceObject)
{
KeEnterCriticalRegion();
#pragma prefast(suppress:28107, "The deviceObject is held within the critical section")
IoDeleteDevice(deviceObject);
KeLeaveCriticalRegion();
Globals.ControlDeviceObject = NULL;
}
if (fSymbolicLink)
{
IoDeleteSymbolicLink(&win32DeviceName);
fSymbolicLink = FALSE;
}
if (Globals.NdisProtocolHandle)
{
NdisDeregisterProtocolDriver(Globals.NdisProtocolHandle);
Globals.NdisProtocolHandle = 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;
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
First entry point to be called, when this driver is loaded.
Register with NDIS as an intermediate driver.
Arguments:
DriverObject - pointer to the system's driver object structure
for this driver
RegistryPath - system's registry path for this driver
Return Value:
STATUS_SUCCESS if all initialization is successful, STATUS_XXX
error code if not.
--*/
{
NDIS_STATUS Status;
NDIS_PROTOCOL_DRIVER_CHARACTERISTICS PChars;
NDIS_MINIPORT_DRIVER_CHARACTERISTICS MChars;
NDIS_HANDLE MiniportDriverContext;
NDIS_HANDLE ProtocolDriverContext;
NDIS_STRING Name;
NdisInitializeListHead(&AdapterList);
NdisInitializeListHead(&VElanList);
MiniportDriverContext=NULL;
ProtocolDriverContext=NULL;
MUX_INIT_MUTEX(&GlobalMutex);
MUX_INIT_MUTEX(&ControlDeviceMutex);
NdisAllocateSpinLock(&GlobalLock);
do
{
//
// Register the miniport with NDIS. Note that it is the
// miniport which was started as a driver and not the protocol.
// Also the miniport must be registered prior to the protocol
// since the protocol's BindAdapter handler can be initiated
// anytime and when it is, it must be ready to
// start driver instances.
//
NdisZeroMemory(&MChars, sizeof(NDIS_MINIPORT_DRIVER_CHARACTERISTICS));
MChars.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
MChars.Header.Size = sizeof(NDIS_MINIPORT_DRIVER_CHARACTERISTICS);
MChars.Header.Revision = NDIS_MINIPORT_DRIVER_CHARACTERISTICS_REVISION_1;
MChars.MajorNdisVersion = MUX_MAJOR_NDIS_VERSION;
MChars.MinorNdisVersion = MUX_MINOR_NDIS_VERSION;
MChars.MajorDriverVersion = MUX_MAJOR_DRIVER_VERSION;
MChars.MinorDriverVersion = MUX_MINOR_DRIVER_VERSION;
MChars.SetOptionsHandler = MpSetOptions;
MChars.InitializeHandlerEx = MPInitialize;
MChars.UnloadHandler = MPUnload;
MChars.HaltHandlerEx = MPHalt;
MChars.OidRequestHandler = MPOidRequest;
MChars.CancelSendHandler = MPCancelSendNetBufferLists;
MChars.DevicePnPEventNotifyHandler = MPDevicePnPEvent;
MChars.ShutdownHandlerEx = MPAdapterShutdown;
MChars.CancelOidRequestHandler = MPCancelOidRequest;
//
// We will disable the check for hang timeout so we do not
// need a check for hang handler!
//
MChars.CheckForHangHandlerEx = NULL;
MChars.ReturnNetBufferListsHandler = MPReturnNetBufferLists;
MChars.SendNetBufferListsHandler = MPSendNetBufferLists;
MChars.PauseHandler = MPPause;
MChars.RestartHandler = MPRestart;
MChars.Flags = NDIS_INTERMEDIATE_DRIVER;
Status = NdisMRegisterMiniportDriver(DriverObject,
RegistryPath,
MiniportDriverContext,
&MChars,
&DriverHandle);
if (Status != NDIS_STATUS_SUCCESS)
{
break;
}
//
// Now register the protocol.
//
NdisZeroMemory(&PChars, sizeof(NDIS_PROTOCOL_DRIVER_CHARACTERISTICS));
PChars.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
PChars.Header.Size = sizeof(NDIS_PROTOCOL_DRIVER_CHARACTERISTICS);
PChars.Header.Revision = NDIS_PROTOCOL_DRIVER_CHARACTERISTICS_REVISION_1;
PChars.MajorNdisVersion = MUX_PROT_MAJOR_NDIS_VERSION;
PChars.MinorNdisVersion = MUX_PROT_MINOR_NDIS_VERSION;
PChars.MajorDriverVersion = MUX_MAJOR_DRIVER_VERSION;
PChars.MinorDriverVersion = MUX_MINOR_DRIVER_VERSION;
PChars.SetOptionsHandler = PtSetOptions;
//
// Make sure the protocol-name matches the service-name
// (from the INF) under which this protocol is installed.
// This is needed to ensure that NDIS can correctly determine
// the binding and call us to bind to miniports below.
//
NdisInitUnicodeString(&Name, L"MUXP"); // Protocol name
PChars.Name = Name;
PChars.OpenAdapterCompleteHandlerEx = PtOpenAdapterComplete;
PChars.CloseAdapterCompleteHandlerEx = PtCloseAdapterComplete;
PChars.ReceiveNetBufferListsHandler = PtReceiveNBL;
PChars.SendNetBufferListsCompleteHandler = PtSendNBLComplete;
PChars.OidRequestCompleteHandler = PtRequestComplete;
PChars.StatusHandlerEx = PtStatus;
PChars.BindAdapterHandlerEx = PtBindAdapter;
PChars.UnbindAdapterHandlerEx = PtUnbindAdapter;
PChars.NetPnPEventHandler= PtPNPHandler;
Status = NdisRegisterProtocolDriver(ProtocolDriverContext,
&PChars,
&ProtHandle);
if (Status != NDIS_STATUS_SUCCESS)
{
NdisMDeregisterMiniportDriver(DriverHandle);
break;
}
//
// Let NDIS know of the association between our protocol
// and miniport entities.
//
NdisIMAssociateMiniport(DriverHandle, ProtHandle);
}while (FALSE);
return(Status);
}
// Win32 driver entry point
NDIS_STATUS DriverEntry(DRIVER_OBJECT *driver_object, UNICODE_STRING *registry_path)
{
NDIS_PROTOCOL_DRIVER_CHARACTERISTICS t;
NDIS_STATUS ret = NDIS_STATUS_FAILURE;
SL_UNICODE *protocol_name = NULL;
NDIS_HANDLE protocol_handle = NULL;
SL_CTX *sl_ctx = NULL;
DEVICE_OBJECT *device_object = NULL;
SlZero(sl, sizeof(SL_CTX));
// Register the NDIS protocol
protocol_name = SlNewUnicode(SL_PROTOCOL_NAME);
if (protocol_name == NULL)
{
goto LABEL_CLEANUP;
}
SlZero(&t, sizeof(t));
t.Header.Type = NDIS_OBJECT_TYPE_PROTOCOL_DRIVER_CHARACTERISTICS;
t.Header.Revision = NDIS_PROTOCOL_DRIVER_CHARACTERISTICS_REVISION_2;
t.Header.Size = NDIS_SIZEOF_PROTOCOL_DRIVER_CHARACTERISTICS_REVISION_2;
t.MajorNdisVersion = 6;
t.MinorNdisVersion = 20;
t.Name = protocol_name->String;
t.BindAdapterHandlerEx = SlNdisBindAdapterExProc;
t.UnbindAdapterHandlerEx = SlNdisUnbindAdapterExProc;
t.OpenAdapterCompleteHandlerEx = SlNdisOpenAdapterCompleteExProc;
t.CloseAdapterCompleteHandlerEx = SlNdisCloseAdapterCompleteExProc;
t.NetPnPEventHandler = SlNdisNetPnPEventProc;
t.UninstallHandler = SlNdisUninstallProc;
t.OidRequestCompleteHandler = SlNdisOidRequestCompleteProc;
t.StatusHandlerEx = SlNdisStatusExProc;
t.ReceiveNetBufferListsHandler = SlNdisReceiveNetBufferListsProc;
t.SendNetBufferListsCompleteHandler = SlNdisSendNetBufferListsCompleteProc;
// Create an adapters list
sl->DriverObject = driver_object;
sl->AdapterList = SlNewList();
ret = NdisRegisterProtocolDriver(NULL, &t, &protocol_handle);
if (NG(ret))
{
protocol_handle = NULL;
goto LABEL_CLEANUP;
}
SlZero(driver_object->MajorFunction, sizeof(driver_object->MajorFunction));
driver_object->MajorFunction[IRP_MJ_CREATE] = SlDeviceOpenProc;
driver_object->MajorFunction[IRP_MJ_CLOSE] = SlDeviceCloseProc;
driver_object->MajorFunction[IRP_MJ_READ] = SlDeviceReadProc;
driver_object->MajorFunction[IRP_MJ_WRITE] = SlDeviceWriteProc;
driver_object->MajorFunction[IRP_MJ_DEVICE_CONTROL] = SlDeviceIoControlProc;
driver_object->DriverUnload = SlUnloadProc;
// Initialize the SL context
sl->ProtocolHandle = protocol_handle;
// Create a basic device
sl->BasicDevice = SlNewDevice(SL_BASIC_DEVICE_NAME, SL_BASIC_DEVICE_NAME_SYMBOLIC);
if (sl->BasicDevice == NULL)
{
ret = NDIS_STATUS_FAILURE;
goto LABEL_CLEANUP;
}
sl->BasicDevice->IsBasicDevice = true;
LABEL_CLEANUP:
SlFreeUnicode(protocol_name);
if (NG(ret))
{
SlUnloadProc(driver_object);
}
return ret;
}
