/*--------------------------------------------------------------------------
ssh_interceptor_register_upper_edge()
Registers(Deregisters) the upper-edge (miniport) handlers of driver with
NDIS. After registration is done, NDIS can use these handlers for
communication with upper layer device (protocol) driver.
Arguments:
interceptor - SshInterceptor object,
enable - Register/Deregister flag.
Returns:
NDIS_STATUS_SUCCESS - operation succeeded
NDIS_STATUS_FAILURE - otherwise
Notes:
--------------------------------------------------------------------------*/
NDIS_STATUS
ssh_interceptor_register_upper_edge(SshNdisIMInterceptor interceptor,
BOOLEAN enable)
{
NDIS_STATUS status = NDIS_STATUS_SUCCESS;
NDIS_MINIPORT_CHARACTERISTICS mp_chars;
SSH_ASSERT(interceptor != NULL);
SSH_DEBUG(SSH_D_NICETOKNOW, ("ssh_interceptor_register_upper_edge()"));
if (enable == TRUE && interceptor->miniport_handle == NULL)
{
NdisZeroMemory(&mp_chars,sizeof(mp_chars));
mp_chars.MajorNdisVersion = SSH_MAJOR_NDIS_VERSION;
mp_chars.MinorNdisVersion = SSH_MINOR_NDIS_VERSION;
mp_chars.CheckForHangHandler = ssh_driver_check_for_hang;
mp_chars.HaltHandler = ssh_driver_deinitialize;
mp_chars.InitializeHandler = ssh_driver_initialize;
mp_chars.ResetHandler = ssh_driver_reset;
mp_chars.SendHandler = NULL;
#ifdef _WIN32_WCE
mp_chars.WanSendHandler = ssh_driver_send_wan_packet;
#endif /* _WIN32_WCE */
mp_chars.SendPacketsHandler = ssh_driver_send_packets;
mp_chars.TransferDataHandler = ssh_driver_transfer_data;
mp_chars.ReturnPacketHandler = ssh_driver_return_packet;
mp_chars.QueryInformationHandler = ssh_driver_query_information;
mp_chars.SetInformationHandler = ssh_driver_set_information;
status = NdisIMRegisterLayeredMiniport(interceptor->wrapper_handle,
&mp_chars,
sizeof(mp_chars),
&interceptor->miniport_handle);
if (status != NDIS_STATUS_SUCCESS)
{
interceptor->miniport_handle = NULL;
SSH_DEBUG(SSH_D_ERROR, (" - failed!"));
}
NdisMRegisterUnloadHandler(interceptor->wrapper_handle, DriverUnload);
}
if (enable == FALSE && interceptor->miniport_handle != NULL)
{
/* Deregister upper edge API */
NdisIMDeregisterLayeredMiniport(interceptor->miniport_handle);
interceptor->miniport_handle = NULL;
status = NDIS_STATUS_SUCCESS;
}
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_CHARACTERISTICS PChars;
NDIS_MINIPORT_CHARACTERISTICS MChars;
NDIS_STRING Name;
divert_init();
Status = NDIS_STATUS_SUCCESS;
NdisAllocateSpinLock(&GlobalLock);
NdisMInitializeWrapper(&NdisWrapperHandle, DriverObject, RegistryPath, NULL);
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_CHARACTERISTICS));
MChars.MajorNdisVersion = PASSTHRU_MAJOR_NDIS_VERSION;
MChars.MinorNdisVersion = PASSTHRU_MINOR_NDIS_VERSION;
MChars.InitializeHandler = MPInitialize;
MChars.QueryInformationHandler = MPQueryInformation;
MChars.SetInformationHandler = MPSetInformation;
MChars.ResetHandler = NULL;
MChars.TransferDataHandler = MPTransferData;
MChars.HaltHandler = MPHalt;
#ifdef NDIS51_MINIPORT
MChars.CancelSendPacketsHandler = MPCancelSendPackets;
MChars.PnPEventNotifyHandler = MPDevicePnPEvent;
MChars.AdapterShutdownHandler = MPAdapterShutdown;
#endif // NDIS51_MINIPORT
//
// We will disable the check for hang timeout so we do not
// need a check for hang handler!
//
MChars.CheckForHangHandler = NULL;
MChars.ReturnPacketHandler = MPReturnPacket;
//
// Either the Send or the SendPackets handler should be specified.
// If SendPackets handler is specified, SendHandler is ignored
//
MChars.SendHandler = NULL; // MPSend;
MChars.SendPacketsHandler = MPSendPackets;
Status = NdisIMRegisterLayeredMiniport(NdisWrapperHandle,
&MChars,
sizeof(MChars),
&DriverHandle);
if (Status != NDIS_STATUS_SUCCESS)
{
break;
}
#ifndef WIN9X
NdisMRegisterUnloadHandler(NdisWrapperHandle, PtUnload);
#endif
//
// Now register the protocol.
//
NdisZeroMemory(&PChars, sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
PChars.MajorNdisVersion = PASSTHRU_PROT_MAJOR_NDIS_VERSION;
PChars.MinorNdisVersion = PASSTHRU_PROT_MINOR_NDIS_VERSION;
//
// 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"Passthru"); // Protocol name
PChars.Name = Name;
PChars.OpenAdapterCompleteHandler = PtOpenAdapterComplete;
PChars.CloseAdapterCompleteHandler = PtCloseAdapterComplete;
PChars.SendCompleteHandler = PtSendComplete;
PChars.TransferDataCompleteHandler = PtTransferDataComplete;
PChars.ResetCompleteHandler = PtResetComplete;
PChars.RequestCompleteHandler = PtRequestComplete;
PChars.ReceiveHandler = PtReceive;
PChars.ReceiveCompleteHandler = PtReceiveComplete;
PChars.StatusHandler = PtStatus;
PChars.StatusCompleteHandler = PtStatusComplete;
PChars.BindAdapterHandler = PtBindAdapter;
PChars.UnbindAdapterHandler = PtUnbindAdapter;
PChars.UnloadHandler = PtUnloadProtocol;
PChars.ReceivePacketHandler = PtReceivePacket;
PChars.PnPEventHandler= PtPNPHandler;
NdisRegisterProtocol(&Status,
&ProtHandle,
&PChars,
sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
if (Status != NDIS_STATUS_SUCCESS)
{
NdisIMDeregisterLayeredMiniport(DriverHandle);
break;
}
NdisIMAssociateMiniport(DriverHandle, ProtHandle);
}
while (FALSE);
if (Status != NDIS_STATUS_SUCCESS)
{
NdisTerminateWrapper(NdisWrapperHandle, NULL);
}
return(Status);
}
NTSTATUS DriverEntry(PDRIVER_OBJECT driver, PUNICODE_STRING str)
{
DbgBreakPoint();
NTSTATUS sta;
global.contextnum = 0;
global.mininum = 0;
globalinfopool.count = 0;
global.controlobj = NULL;
NDIS_STATUS ndissta;
NDIS_HANDLE wraphandle=NULL;
NDIS_MINIPORT_CHARACTERISTICS minicha;
NDIS_PROTOCOL_CHARACTERISTICS pc;
NDIS_STRING ns = NDIS_STRING_CONST("zlzpass");
NdisZeroMemory(&global, sizeof(GLOBAL));
NdisInitializeWrapper(&wraphandle, driver, str, NULL);
if (wraphandle == NULL)
{
return STATUS_UNSUCCESSFUL;
}
NdisZeroMemory(&minicha, sizeof(NDIS_MINIPORT_CHARACTERISTICS));
minicha.MajorNdisVersion = NDIS_MINIPORT_MAJOR_VERSION;
minicha.MinorNdisVersion = NDIS_MINIPORT_MINOR_VERSION;
minicha.InitializeHandler = MPInitialize;
minicha.HaltHandler = MPHalt;
minicha.SetInformationHandler = MPSetInformation;
minicha.QueryInformationHandler = MPQueryInformation;
minicha.ReturnPacketHandler = MPReturnPacket;
minicha.ResetHandler = NULL;
minicha.CheckForHangHandler = NULL;
minicha.TransferDataHandler = MPTransferData;
minicha.SendHandler = MPSend;
ndissta=NdisIMRegisterLayeredMiniport(wraphandle, &minicha, sizeof(NDIS_MINIPORT_CHARACTERISTICS), &global.driverhandle);
if (ndissta!=NDIS_STATUS_SUCCESS)
{
return STATUS_UNSUCCESSFUL;
}
sysadddevfunc = driver->DriverExtension->AddDevice;
driver->DriverExtension->AddDevice = myAddDevice;
pc.MajorNdisVersion = 5;
pc.MinorNdisVersion = 0;
pc.Name = ns;
pc.CloseAdapterCompleteHandler = NdisProtCloseAdapterComplete;
pc.SendCompleteHandler = NdisProtSendComplete;
pc.TransferDataCompleteHandler = NdisProtTransferDataComplete;
pc.ResetCompleteHandler = NdisProtResetComplete;
pc.RequestCompleteHandler = NdisProtRequestComplete;
pc.ReceiveHandler = NdisProtReceive;
pc.ReceiveCompleteHandler = NdisProtReceiveComplete;
pc.StatusHandler = NdisProtStatus;
pc.StatusCompleteHandler = NdisProtStatusComplete;
pc.BindAdapterHandler = NdisProtBindAdapter;
pc.OpenAdapterCompleteHandler = NdisOpenAdapterComplete;
pc.UnbindAdapterHandler = NdisProtUnbindAdapter;
pc.UnloadHandler = NULL;
pc.ReceivePacketHandler = NdisProtReceivePacket;
pc.PnPEventHandler = NdisProtPnPEventHandler;
pc.CoAfRegisterNotifyHandler = NdisProtRegisterAf;
NdisRegisterProtocol(&ndissta,&global.protocolhandle, &pc, sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
if (ndissta != NDIS_STATUS_SUCCESS)
{
return STATUS_UNSUCCESSFUL;
}
NdisIMAssociateMiniport(global.driverhandle, global.protocolhandle);
sta = ZlzCreateDevice(driver,wraphandle);
if (!NT_SUCCESS(sta))
{
return STATUS_UNSUCCESSFUL;
}
NdisMRegisterUnloadHandler(wraphandle, unload);
return STATUS_SUCCESS;
}
NTSTATUS GingkoNdisDriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
{
NDIS_STATUS Status;
NDIS_PROTOCOL_CHARACTERISTICS PChars;
NDIS_MINIPORT_CHARACTERISTICS MChars;
NDIS_STRING Name;
Status = NDIS_STATUS_SUCCESS;
NdisAllocateSpinLock(&GlobalLock);
NdisMInitializeWrapper(&NdisWrapperHandle, DriverObject, RegistryPath, NULL);
KdPrint(("Calling NdisMInitializeWrapper Before\n"));
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_CHARACTERISTICS));
MChars.MajorNdisVersion = PASSTHRU_MAJOR_NDIS_VERSION;
MChars.MinorNdisVersion = PASSTHRU_MINOR_NDIS_VERSION;
MChars.InitializeHandler = GingkoNdisInitialize;
MChars.QueryInformationHandler = GingkoNdisQueryInformation;
MChars.SetInformationHandler = GingkoNdisSetInformation;
MChars.ResetHandler = NULL;
MChars.TransferDataHandler = GingkoNdisTransferData;
MChars.HaltHandler = GingkoNdisHalt;
#ifdef NDIS51_MINIPORT
MChars.CancelSendPacketsHandler = GingkoNdisCancelSendPackets;
MChars.PnPEventNotifyHandler = GingkoNdisDevicePnPEvent;
MChars.AdapterShutdownHandler = GingkoNdisAdapterShutdown;
#endif // NDIS51_MINIPORT
//
// We will disable the check for hang timeout so we do not
// need a check for hang handler!
//
MChars.CheckForHangHandler = NULL;
MChars.ReturnPacketHandler = GingkoNdisReturnPacket;
//
// Either the Send or the SendPackets handler should be specified.
// If SendPackets handler is specified, SendHandler is ignored
//
MChars.SendHandler = NULL; // MPSend;
MChars.SendPacketsHandler = GingkoNdisSendPackets;
Status = NdisIMRegisterLayeredMiniport(NdisWrapperHandle,
&MChars,
sizeof(MChars),
&DriverHandle);
KdPrint(("Calling NdisIMRegisterLayeredMiniport After\n"));
///return 0;
if (Status != NDIS_STATUS_SUCCESS)
{
break;
}
#ifndef WIN9X
NdisMRegisterUnloadHandler(NdisWrapperHandle, GingkoNdisUnload);
#endif
//
// Now register the protocol.
//
NdisZeroMemory(&PChars, sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
PChars.MajorNdisVersion = PASSTHRU_PROT_MAJOR_NDIS_VERSION;
PChars.MinorNdisVersion = PASSTHRU_PROT_MINOR_NDIS_VERSION;
//
// 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"GingkoFilter"); // Protocol name
PChars.Name = Name;
PChars.OpenAdapterCompleteHandler = GingkoNdisOpenAdapterComplete;
PChars.CloseAdapterCompleteHandler = GingkoNdisCloseAdapterComplete;
PChars.SendCompleteHandler = GingkoNdisSendComplete;
PChars.TransferDataCompleteHandler = GingkoNdisTransferDataComplete;
PChars.ResetCompleteHandler = GingkoNdisResetComplete;
PChars.RequestCompleteHandler = GingkoNdisRequestComplete;
PChars.ReceiveHandler = GingkoNdisReceive;
PChars.ReceiveCompleteHandler = GingkoNdisReceiveComplete;
PChars.StatusHandler = GingkoNdisStatus;
PChars.StatusCompleteHandler = GingkoNdisStatusComplete;
PChars.BindAdapterHandler = GingkoNdisBindAdapter;
PChars.UnbindAdapterHandler = GingkoNdisUnbindAdapter;
PChars.UnloadHandler = GingkoNdisUnloadProtocol;
PChars.ReceivePacketHandler = GingkoNdisReceivePacket;
PChars.PnPEventHandler= GingkoNdisPNPHandler;
NdisRegisterProtocol(&Status,
&ProtHandle,
&PChars,
sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
KdPrint(("Calling NdisRegisterProtocol After\n"));
if (Status != NDIS_STATUS_SUCCESS)
{
NdisIMDeregisterLayeredMiniport(DriverHandle);
break;
}
NdisIMAssociateMiniport(DriverHandle, ProtHandle);
KdPrint(("Calling NdisIMAssociateMiniport After\n"));
}
while (FALSE);
if (Status != NDIS_STATUS_SUCCESS)
{
NdisTerminateWrapper(NdisWrapperHandle, NULL);
}
return(Status);
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
{
NDIS_STATUS Status;
NDIS40_PROTOCOL_CHARACTERISTICS PChars40;
NDIS40_MINIPORT_CHARACTERISTICS MChars40;
NDIS50_PROTOCOL_CHARACTERISTICS PChars50;
NDIS51_MINIPORT_CHARACTERISTICS MChars51;
NDIS_STRING Name;
Status = NDIS_STATUS_SUCCESS;
g_ArpFw_ShareMem = NULL;
NdisAllocateSpinLock(&GlobalLock);
g_CurrentDriver = DriverObject;
LoadDynamicFunction(); //识别版本并加载额外函数
// Status = InitPacketList();
// if( Status != STATUS_SUCCESS)
// {
// return Status;
// }
NdisMInitializeWrapper(&NdisWrapperHandle, DriverObject, RegistryPath, NULL);
if(IS_NDIS51())
{
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(&MChars51, sizeof(NDIS51_MINIPORT_CHARACTERISTICS));
MChars51.MajorNdisVersion = 5;
MChars51.MinorNdisVersion = 1;
MChars51.InitializeHandler = MiniportInitialize5;
MChars51.QueryInformationHandler = MiniportQueryInformation5;
MChars51.SetInformationHandler = MiniportSetInformation5;
MChars51.ResetHandler = NULL;
MChars51.TransferDataHandler = MiniportTransferData5;
MChars51.HaltHandler = MiniportHalt5;
//NDIS51++
MChars51.CancelSendPacketsHandler = MiniportCancelSendPackets5;
MChars51.PnPEventNotifyHandler = MiniportDevicePnPEvent5;
MChars51.AdapterShutdownHandler = MiniportAdapterShutdown5;
//--NDIS51
//
// We will disable the check for hang timeout so we do not
// need a check for hang handler!
//
MChars51.CheckForHangHandler = MiniportCheckForHang5;
MChars51.ReturnPacketHandler = MiniportReturnPacket5;
//
// Either the Send or the SendPackets handler should be specified.
// If SendPackets handler is specified, SendHandler is ignored
//
MChars51.SendHandler = NULL;
MChars51.SendPacketsHandler = MiniportSendPackets5;
Status = NdisIMRegisterLayeredMiniport(NdisWrapperHandle,
(PVOID)&MChars51,
sizeof(NDIS51_MINIPORT_CHARACTERISTICS),
&DriverHandle);
if (Status != NDIS_STATUS_SUCCESS)
{
break;
}
NdisMRegisterUnloadHandler(NdisWrapperHandle, ProtocolUnload);
//
// Now register the protocol.
//
NdisZeroMemory(&PChars50, sizeof(NDIS50_PROTOCOL_CHARACTERISTICS));
PChars50.MajorNdisVersion = 5;
PChars50.MinorNdisVersion = 0;
//
// 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, PROTOCOL_NAME); // Protocol name
PChars50.Name = Name;
PChars50.OpenAdapterCompleteHandler = ProtocolOpenAdapterComplete5;
PChars50.CloseAdapterCompleteHandler = ProtocolCloseAdapterComplete5;
PChars50.SendCompleteHandler = ProtocolSendComplete5;
PChars50.TransferDataCompleteHandler = ProtocolTransferDataComplete5;
PChars50.ResetCompleteHandler = ProtocolResetComplete5;
PChars50.RequestCompleteHandler = ProtocolRequestComplete5;
PChars50.ReceiveHandler = ProtocolReceive5;
PChars50.ReceiveCompleteHandler = ProtocolReceiveComplete5;
PChars50.StatusHandler = ProtocolStatus5;
PChars50.StatusCompleteHandler = ProtocolStatusComplete5;
PChars50.BindAdapterHandler = ProtocolBindAdapter5;
PChars50.UnbindAdapterHandler = ProtocolUnbindAdapter5;
PChars50.UnloadHandler = ProtocolUnloadProtocol5;
PChars50.ReceivePacketHandler = ProtocolReceivePacket5;
PChars50.PnPEventHandler = ProtocolPNPHandler5;
NdisRegisterProtocol(&Status,
&ProtHandle,
(PVOID)&PChars50,
sizeof(NDIS50_PROTOCOL_CHARACTERISTICS));
if (Status != NDIS_STATUS_SUCCESS)
{
NdisIMDeregisterLayeredMiniport(DriverHandle);
break;
}
NdisIMAssociateMiniport(DriverHandle, ProtHandle);
}
while (FALSE);
}
else
{
do
{
//注册 Miniport
NdisZeroMemory(&MChars40, sizeof(NDIS40_MINIPORT_CHARACTERISTICS));
MChars40.MajorNdisVersion = 4;
MChars40.MinorNdisVersion = 0;
MChars40.InitializeHandler = MiniportInitialize4;
MChars40.QueryInformationHandler = MiniportQueryInformation4;
MChars40.SetInformationHandler = MiniportSetInformation4;
MChars40.ResetHandler = NULL;
MChars40.TransferDataHandler = MiniportTransferData4;
MChars40.HaltHandler = MiniportHalt4;
MChars40.CheckForHangHandler = MiniportCheckForHang4;
MChars40.ReturnPacketHandler = MiniportReturnPacket4;
MChars40.SendHandler = NULL;
MChars40.SendPacketsHandler = MiniportSendPackets4;
Status = NdisIMRegisterLayeredMiniport(NdisWrapperHandle,
(PVOID)&MChars40,
sizeof(MChars40),
&DriverHandle);
if (Status != NDIS_STATUS_SUCCESS)
{
break;
}
NdisMRegisterUnloadHandler(NdisWrapperHandle, ProtocolUnload);
//
// Now register the protocol.
//
NdisZeroMemory(&PChars40, sizeof(NDIS40_PROTOCOL_CHARACTERISTICS));
PChars40.MajorNdisVersion = 4;
PChars40.MinorNdisVersion = 0;
NdisInitUnicodeString(&Name, PROTOCOL_NAME); // Protocol name
PChars40.Name = Name;
PChars40.OpenAdapterCompleteHandler = ProtocolOpenAdapterComplete4;
PChars40.CloseAdapterCompleteHandler = ProtocolCloseAdapterComplete4;
PChars40.SendCompleteHandler = ProtocolSendComplete4;
PChars40.TransferDataCompleteHandler = ProtocolTransferDataComplete4;
PChars40.ResetCompleteHandler = ProtocolResetComplete4;
PChars40.RequestCompleteHandler = ProtocolRequestComplete4;
PChars40.ReceiveHandler = ProtocolReceive4;
PChars40.ReceiveCompleteHandler = ProtocolReceiveComplete4;
PChars40.StatusHandler = ProtocolStatus4;
PChars40.StatusCompleteHandler = ProtocolStatusComplete4;
PChars40.BindAdapterHandler = ProtocolBindAdapter4;
PChars40.UnbindAdapterHandler = ProtocolUnbindAdapter4;
PChars40.UnloadHandler = ProtocolUnloadProtocol4;
PChars40.ReceivePacketHandler = ProtocolReceivePacket4;
PChars40.PnPEventHandler = ProtocolPNPHandler4;
NdisRegisterProtocol(&Status,
&ProtHandle,
(PVOID)&PChars40,
sizeof(NDIS40_PROTOCOL_CHARACTERISTICS));
if (Status != NDIS_STATUS_SUCCESS)
{
NdisIMDeregisterLayeredMiniport(DriverHandle);
break;
}
NdisIMAssociateMiniport(DriverHandle, ProtHandle);
}
while (FALSE);
}
if (Status != NDIS_STATUS_SUCCESS)
{
NdisTerminateWrapper(NdisWrapperHandle, NULL);
NdisFreeSpinLock(&GlobalLock);
}
return(Status);
}
NDIS_STATUS
NdisMRegisterMiniport(
IN NDIS_HANDLE NdisWrapperHandle,
IN PNDIS_MINIPORT_CHARACTERISTICS MiniportCharacteristics,
IN UINT CharacteristicsLength
)
/*++
Routine Description:
Used to register a Miniport driver with the wrapper.
Arguments:
Status - Status of the operation.
NdisWrapperHandle - Handle returned by NdisWInitializeWrapper.
MiniportCharacteritics - The NDIS_MINIPORT_CHARACTERISTICS table.
CharacteristicsLength - The length of MiniportCharacteristics.
Return Value:
None.
--*/
{
NDIS_STATUS Status;
PNDIS_M_DRIVER_BLOCK MiniBlock;
PNDIS_WRAPPER_HANDLE DriverInfo = (PNDIS_WRAPPER_HANDLE)(NdisWrapperHandle);
Status = NdisIMRegisterLayeredMiniport(NdisWrapperHandle,
MiniportCharacteristics,
CharacteristicsLength,
&MiniBlock);
DBGPRINT(DBG_COMP_CONFIG, DBG_LEVEL_INFO,
("Exit mini-port register\n"));
if (Status == NDIS_STATUS_SUCCESS)
{
InitReferencePackage();
if (DriverInfo->NdisWrapperConfigurationHandle)
{
Status = ndisInitializeAllAdapterInstances((PNDIS_MAC_BLOCK)MiniBlock, NULL);
if (Status != NDIS_STATUS_SUCCESS)
{
ndisDereferenceDriver(MiniBlock);
Status = NDIS_STATUS_FAILURE;
}
}
else
{
Status = NDIS_STATUS_FAILURE;
}
InitDereferencePackage();
}
ASSERT (CURRENT_IRQL < DISPATCH_LEVEL);
return Status;
}
