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 ) /*++ 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); }
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); }