/*++ Copyright (c) 1996 Microsoft Corporation Module Name: D:\nt\private\ntos\tdi\rawwan\core\ntentry.c Abstract: NT specific entry points for dispatching and handling TDI IRPs. Based on TCP source. Revision History: Who When What -------- -------- ---------------------------------------------- arvindm 04-21-97 Created Notes: --*/ #include #define _FILENUMBER 'IDTN' #define RWAN_COMPLETE_IRP(_pIrp, _Status, _Info) \ { \ (_pIrp)->IoStatus.Status = (NTSTATUS)(_Status); \ (_pIrp)->IoStatus.Information = (_Info); \ IoCompleteRequest(_pIrp, IO_NETWORK_INCREMENT); \ } NTSTATUS DriverEntry( IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING pRegistryPath ) /*++ Routine Description: This is the "init" routine called by the system when Raw WAN is loaded. We initialize all our global objects, fill in our Dispatch and Unload routine addresses in the driver object. We initialize the media/AF specific modules, and they register support for TDI protocols, at which time we create device objects. Arguments: pDriverObject - Pointer to the driver object created by the system. pRegistryPath - Pointer to our global registry path. This is ignored. Return Value: NT Status code: STATUS_SUCCESS if successful, error code otherwise. --*/ { NTSTATUS Status; RWAN_STATUS RWanStatus; PDEVICE_OBJECT pDeviceObject; UNICODE_STRING DeviceName; INT i; RWANDEBUGP(DL_FATAL, DC_WILDCARD, ("RWanDebugLevel is %d, &RWanDebugLevel at x%x\n", RWanDebugLevel, &RWanDebugLevel)); RWANDEBUGP(DL_FATAL, DC_WILDCARD, ("RWanDebugComp is x%x, &RWanDebugComp at x%x\n", RWanDebugComp, &RWanDebugComp)); RWANDEBUGP(DL_FATAL, DC_WILDCARD, ("RWanGlobals at x%x\n", &RWanGlobals)); #if DBG RWANDEBUGP(DL_FATAL, DC_WILDCARD, ("To skip everything set RWanSkipAll at x%x to 1\n", &RWanSkipAll)); if (RWanSkipAll) { RWANDEBUGP(DL_FATAL, DC_WILDCARD, ("Aborting DriverEntry\n")); return (STATUS_UNSUCCESSFUL); } NdisAllocateSpinLock(&RWanDbgLogLock); #if DBG_LOG_PACKETS NdisAllocateSpinLock(&RWanDPacketLogLock); #endif #endif // DBG RWanStatus = RWanInitGlobals(pDriverObject); if (RWanStatus != RWAN_STATUS_SUCCESS) { return (STATUS_UNSUCCESSFUL); } // // Register as an NDIS protocol. // RWAN_ZERO_MEM(&RWanNdisProtocolCharacteristics, sizeof(RWanNdisProtocolCharacteristics)); RWanNdisProtocolCharacteristics.MajorNdisVersion = RWAN_NDIS_MAJOR_VERSION; RWanNdisProtocolCharacteristics.MinorNdisVersion = RWAN_NDIS_MINOR_VERSION; RWanNdisProtocolCharacteristics.OpenAdapterCompleteHandler = RWanNdisOpenAdapterComplete; RWanNdisProtocolCharacteristics.CloseAdapterCompleteHandler = RWanNdisCloseAdapterComplete; RWanNdisProtocolCharacteristics.SendCompleteHandler = RWanNdisSendComplete; RWanNdisProtocolCharacteristics.TransferDataCompleteHandler = RWanNdisTransferDataComplete; RWanNdisProtocolCharacteristics.ResetCompleteHandler = RWanNdisResetComplete; RWanNdisProtocolCharacteristics.RequestCompleteHandler = RWanNdisRequestComplete; RWanNdisProtocolCharacteristics.ReceiveHandler = RWanNdisReceive; RWanNdisProtocolCharacteristics.ReceiveCompleteHandler = RWanNdisReceiveComplete; RWanNdisProtocolCharacteristics.StatusHandler = RWanNdisStatus; RWanNdisProtocolCharacteristics.StatusCompleteHandler = RWanNdisStatusComplete; NdisInitUnicodeString( &RWanNdisProtocolCharacteristics.Name, RWAN_NAME ); RWanNdisProtocolCharacteristics.ReceivePacketHandler = RWanNdisReceivePacket; RWanNdisProtocolCharacteristics.BindAdapterHandler = RWanNdisBindAdapter; RWanNdisProtocolCharacteristics.PnPEventHandler = RWanNdisPnPEvent; RWanNdisProtocolCharacteristics.UnbindAdapterHandler = RWanNdisUnbindAdapter; RWanNdisProtocolCharacteristics.UnloadHandler = (UNLOAD_PROTOCOL_HANDLER)RWanUnloadProtocol; #ifdef _PNP_POWER_ RWanNdisProtocolCharacteristics.PnpEventHandler = RWanNdisPnPEvent; #endif // _PNP_POWER_ RWanNdisProtocolCharacteristics.CoSendCompleteHandler = RWanNdisCoSendComplete; RWanNdisProtocolCharacteristics.CoStatusHandler = RWanNdisCoStatus; RWanNdisProtocolCharacteristics.CoReceivePacketHandler = RWanNdisCoReceivePacket; #if 0 RWanNdisProtocolCharacteristics.CoRequestHandler = RWanNdisCoRequest; RWanNdisProtocolCharacteristics.CoRequestCompleteHandler = RWanNdisCoRequestComplete; #endif RWanNdisProtocolCharacteristics.CoAfRegisterNotifyHandler = RWanNdisAfRegisterNotify; RWAN_ZERO_MEM(&RWanNdisClientCharacteristics, sizeof(RWanNdisClientCharacteristics)); RWanNdisClientCharacteristics.MajorVersion = RWAN_NDIS_MAJOR_VERSION; RWanNdisClientCharacteristics.MinorVersion = RWAN_NDIS_MINOR_VERSION; RWanNdisClientCharacteristics.ClCreateVcHandler = RWanNdisCreateVc; RWanNdisClientCharacteristics.ClDeleteVcHandler = RWanNdisDeleteVc; RWanNdisClientCharacteristics.ClOpenAfCompleteHandler = RWanNdisOpenAddressFamilyComplete; RWanNdisClientCharacteristics.ClCloseAfCompleteHandler = RWanNdisCloseAddressFamilyComplete; RWanNdisClientCharacteristics.ClRegisterSapCompleteHandler = RWanNdisRegisterSapComplete; RWanNdisClientCharacteristics.ClDeregisterSapCompleteHandler = RWanNdisDeregisterSapComplete; RWanNdisClientCharacteristics.ClMakeCallCompleteHandler = RWanNdisMakeCallComplete; RWanNdisClientCharacteristics.ClModifyCallQoSCompleteHandler = RWanNdisModifyQoSComplete; RWanNdisClientCharacteristics.ClCloseCallCompleteHandler = RWanNdisCloseCallComplete; RWanNdisClientCharacteristics.ClAddPartyCompleteHandler = RWanNdisAddPartyComplete; RWanNdisClientCharacteristics.ClDropPartyCompleteHandler = RWanNdisDropPartyComplete; RWanNdisClientCharacteristics.ClIncomingCallHandler = RWanNdisIncomingCall; RWanNdisClientCharacteristics.ClIncomingCallQoSChangeHandler = (CL_INCOMING_CALL_QOS_CHANGE_HANDLER)NULL; RWanNdisClientCharacteristics.ClIncomingCloseCallHandler = RWanNdisIncomingCloseCall; RWanNdisClientCharacteristics.ClIncomingDropPartyHandler = RWanNdisIncomingDropParty; RWanNdisClientCharacteristics.ClCallConnectedHandler = RWanNdisCallConnected; #if 1 RWanNdisClientCharacteristics.ClRequestHandler = RWanNdisCoRequest; RWanNdisClientCharacteristics.ClRequestCompleteHandler = RWanNdisCoRequestComplete; #endif NdisRegisterProtocol( &Status, &(pRWanGlobal->ProtocolHandle), &RWanNdisProtocolCharacteristics, sizeof(RWanNdisProtocolCharacteristics) ); if (Status != NDIS_STATUS_SUCCESS) { return (Status); } #if DBG if (RWanSkipAll) { RWANDEBUGP(DL_FATAL, DC_WILDCARD, ("Aborting DriverEntry\n")); NdisDeregisterProtocol( &Status, pRWanGlobal->ProtocolHandle ); return (STATUS_UNSUCCESSFUL); } #endif // DBG // // Tell all media-specific modules to initialize. // RWanStatus = RWanInitMediaSpecific(); if (RWanStatus != RWAN_STATUS_SUCCESS) { NdisDeregisterProtocol( &Status, pRWanGlobal->ProtocolHandle ); return (STATUS_UNSUCCESSFUL); } #if !BINARY_COMPATIBLE // // Initialize the Driver Object. // pDriverObject->DriverUnload = RWanUnload; pDriverObject->FastIoDispatch = NULL; for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++) { pDriverObject->MajorFunction[i] = RWanDispatch; } pDriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = RWanDispatchInternalDeviceControl; #endif // !BINARY_COMPATIBLE return (STATUS_SUCCESS); } VOID RWanUnload( IN PDRIVER_OBJECT pDriverObject ) /*++ Routine Description: This is called by the system prior to unloading us. Undo everything we did in DriverEntry. Arguments: pDriverObject - Pointer to the driver object representing us. Return Value: None --*/ { #if DBG RWanDebugLevel = DL_EXTRA_LOUD; RWanDebugComp = DC_WILDCARD; #endif RWANDEBUGP(DC_DISPATCH, DL_INFO, ("RWanUnload entered: RWanGlobals at x%x\n", &RWanGlobals)); RWanUnloadProtocol(); RWANDEBUGP(DC_DISPATCH, DL_INFO, ("RWanUnload exiting\n")); } VOID RWanUnloadProtocol( VOID ) /*++ Routine Description: Unloads the Raw WAN protocol module. We unbind from all adapters, and shut down all media specific modules. Arguments: None Return Value: None --*/ { NDIS_STATUS Status; PRWAN_NDIS_ADAPTER pAdapter; #if DBG RWAN_IRQL EntryIrq, ExitIrq; #endif // DBG RWAN_GET_ENTRY_IRQL(EntryIrq); RWAN_ACQUIRE_GLOBAL_LOCK(); if (pRWanGlobal->UnloadDone) { RWANDEBUGP(DL_INFO, DC_WILDCARD, ("UnloadProtocol: already done!\n")); RWAN_RELEASE_GLOBAL_LOCK(); return; } pRWanGlobal->UnloadDone = TRUE; #if 0 // // Commented out because of an NDIS change: if we have unclosed // adapter bindings at this time, NDIS will call our Unbind // handler for each of these, when we call NdisDeregisterProtocol // below. // while (pRWanGlobal->AdapterCount != 0) { RWAN_ASSERT (!RWAN_IS_LIST_EMPTY(&pRWanGlobal->AdapterList)); pAdapter = CONTAINING_RECORD(pRWanGlobal->AdapterList.Flink, RWAN_NDIS_ADAPTER, AdapterLink); RWAN_STRUCT_ASSERT(pAdapter, nad); RWAN_RELEASE_GLOBAL_LOCK(); RWanNdisUnbindAdapter( &Status, (NDIS_HANDLE)pAdapter, NULL // No UnbindContext implies don't complete NdisUnbindAdapter ); if (Status == NDIS_STATUS_PENDING) { // // Wait for the unbind to complete. // (VOID)RWAN_WAIT_ON_EVENT_STRUCT(&pRWanGlobal->Event); } RWAN_ACQUIRE_GLOBAL_LOCK(); } #endif // 0 RWAN_RELEASE_GLOBAL_LOCK(); RWAN_CHECK_EXIT_IRQL(EntryIrq, ExitIrq); RWANDEBUGP(DL_FATAL, DC_DISPATCH, ("RWanUnloadProtocol: will deregister protocol now\n")); NdisDeregisterProtocol( &Status, pRWanGlobal->ProtocolHandle ); RWANDEBUGP(DL_FATAL, DC_DISPATCH, ("UnloadProtocol: dereg protocol done\n")); RWanDeinitGlobals(); RWAN_CHECK_EXIT_IRQL(EntryIrq, ExitIrq); RWanShutdownMediaSpecific(); RWAN_CHECK_EXIT_IRQL(EntryIrq, ExitIrq); #if DBG RWanAuditShutdown(); #endif // DBG RWAN_CHECK_EXIT_IRQL(EntryIrq, ExitIrq); } NTSTATUS RWanDispatch( IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp ) /*++ Routine Description: System entry point for all IRPs dispatched to Raw WAN device objects. Arguments: pDeviceObject - Points to a device object created by RawWan. This device object identifies a supported Winsock 2 triple
. pIrp - Pointer to the IRP Return Value: NTSTATUS - STATUS_SUCCESS for immediate requests (such as create) that we successfully process, STATUS_PENDING for queued IRPs, and STATUS_XXX error codes for any failures. --*/ { PIO_STACK_LOCATION pIrpSp; NTSTATUS Status; #if DBG RWAN_IRQL EntryIrq, ExitIrq; #endif // DBG RWAN_GET_ENTRY_IRQL(EntryIrq); pIrpSp = IoGetCurrentIrpStackLocation(pIrp); pIrp->IoStatus.Information = 0; RWAN_ASSERT(pIrpSp->MajorFunction != IRP_MJ_INTERNAL_DEVICE_CONTROL); switch (pIrpSp->MajorFunction) { case IRP_MJ_CREATE: Status = RWanCreate(pDeviceObject, pIrp, pIrpSp); break; case IRP_MJ_CLEANUP: Status = RWanCleanup(pDeviceObject, pIrp, pIrpSp); break; case IRP_MJ_CLOSE: Status = RWanClose(pDeviceObject, pIrp, pIrpSp); break; case IRP_MJ_DEVICE_CONTROL: Status = TdiMapUserRequest(pDeviceObject, pIrp, pIrpSp); // // TBD - get rid of the call to TdiMapUserRequest - AFD will be // fixed so that we shouldn't see TDI commands come this way. // if (Status == STATUS_SUCCESS) { if (pIrpSp->MinorFunction == TDI_ASSOCIATE_ADDRESS || pIrpSp->MinorFunction == TDI_DISASSOCIATE_ADDRESS) { return (RWanDispatchInternalDeviceControl(pDeviceObject, pIrp)); } else { Status = STATUS_ACCESS_DENIED; } } else { return (RWanDispatchPrivateDeviceControl(pIrp, pIrpSp)); } break; case IRP_MJ_READ: case IRP_MJ_WRITE: default: RWANDEBUGP(DL_WARN, DC_DISPATCH, ("RWanDispatch: Unknown MajorFunction x%x\n", pIrpSp->MajorFunction)); Status = STATUS_INVALID_DEVICE_REQUEST; break; } RWAN_ASSERT(Status != TDI_PENDING); RWAN_COMPLETE_IRP(pIrp, Status, 0); RWANDEBUGP(DL_VERY_LOUD, DC_DISPATCH, ("RWanDispatch: pIrp x%x, MajorFunc %d, returning Status x%x, Info %d\n", pIrp, pIrpSp->MajorFunction, Status, pIrp->IoStatus.Information)); RWAN_CHECK_EXIT_IRQL(EntryIrq, ExitIrq); return (Status); } NTSTATUS RWanCreate( IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp, PIO_STACK_LOCATION pIrpSp ) /*++ Routine Description: This is called when a TDI client calls CreateFile. We allocate an ENDPOINT structure as our context for this endpoint. Based on parameters in the IRP, this is either an Address object, Connection object, or a Control channel. Arguments: pDeviceObject - Identifies the protocol being CreateFile'd pIrp - Pointer to IRP pIrpSp - IRP Stack location Return Value: NTSTATUS - STATUS_SUCCESS if we create the endpoint successfully, STATUS_INSUFFICIENT_RESOURCES if we fail to allocate, and STATUS_INVALID_PARAMETER if we find any parameter incorrect. --*/ { NTSTATUS Status; FILE_FULL_EA_INFORMATION * pEa; FILE_FULL_EA_INFORMATION UNALIGNED * pTargetEa; // // Device being accessed. // PRWAN_DEVICE_OBJECT pRWanDevice; // // Endpoint to represent this object creation. // PRWAN_ENDPOINT pEndpoint; // // TDI Request to be passed down to our TDI layer. // TDI_REQUEST TdiRequest; // // Parameters to be passed down to our TDI layer. // UINT Protocol; UCHAR OptionsBuffer[3]; PUCHAR pOptions; PAGED_CODE(); // // Initialize. // pEndpoint = NULL_PRWAN_ENDPOINT; do { // // Locate the TDI Protocol being opened. // pRWanDevice = *(PRWAN_DEVICE_OBJECT *)(pDeviceObject->DeviceExtension); if (pRWanDevice == NULL) { Status = STATUS_NO_SUCH_DEVICE; break; } // // Allocate and initialize an Endpoint to represent // this newly created object. // RWAN_ALLOC_MEM(pEndpoint, RWAN_ENDPOINT, sizeof(RWAN_ENDPOINT)); if (pEndpoint == NULL_PRWAN_ENDPOINT) { Status = STATUS_INSUFFICIENT_RESOURCES; break; } RWAN_ZERO_MEM(pEndpoint, sizeof(RWAN_ENDPOINT)); RWAN_SET_SIGNATURE(pEndpoint, nep); pEndpoint->RefCount = 1; pEndpoint->bCancelIrps = FALSE; KeInitializeEvent(&pEndpoint->CleanupEvent, SynchronizationEvent, FALSE); pEndpoint->pProtocol = pRWanDevice->pProtocol; RWAN_EP_DBGLOG_SET_SIGNATURE(pEndpoint); pEa = (PFILE_FULL_EA_INFORMATION)pIrp->AssociatedIrp.SystemBuffer; // // See if this is a Control Channel. // if (!pEa) { RWANDEBUGP(DL_LOUD, DC_DISPATCH, ("RWanCreate: pIrp x%x, File obj x%x, Control Channel\n", pIrp, pIrpSp->FileObject)); RWAN_ASSERT(pRWanDevice->pProtocol); pEndpoint->Handle.ControlChannel = pRWanDevice->pProtocol; pIrpSp->FileObject->FsContext = pEndpoint; pIrpSp->FileObject->FsContext2 = (PVOID)TDI_CONTROL_CHANNEL_FILE; RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'CCrC', 0, 0); Status = STATUS_SUCCESS; break; } // // See if this is an Address Object. // pTargetEa = RWanFindEa( pEa, TdiTransportAddress, TDI_TRANSPORT_ADDRESS_LENGTH ); if (pTargetEa != NULL) { RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'OArC', 0, 0); if (pTargetEa->EaValueLength < sizeof(TRANSPORT_ADDRESS)) { Status = STATUS_INVALID_PARAMETER; break; } if (!pRWanDevice->pProtocol->bAllowAddressObjects) { Status = STATUS_INVALID_DEVICE_REQUEST; break; } Protocol = pRWanDevice->pProtocol->SockProtocol; pOptions = OptionsBuffer; if ((pIrpSp->Parameters.Create.ShareAccess & FILE_SHARE_READ) || (pIrpSp->Parameters.Create.ShareAccess & FILE_SHARE_WRITE)) { *pOptions = TDI_ADDRESS_OPTION_REUSE; pOptions++; } *pOptions = TDI_OPTION_EOL; // // Call our TDI entry point. // Status = RWanTdiOpenAddress( &TdiRequest, (TRANSPORT_ADDRESS UNALIGNED *) &(pTargetEa->EaName[pTargetEa->EaNameLength + 1]), pTargetEa->EaValueLength, Protocol, OptionsBuffer ); if (NT_SUCCESS(Status)) { pEndpoint->Handle.AddressHandle = TdiRequest.Handle.AddressHandle; pIrpSp->FileObject->FsContext = pEndpoint; pIrpSp->FileObject->FsContext2 = (PVOID)TDI_TRANSPORT_ADDRESS_FILE; } break; } // // See if this is a Connection Object. // pTargetEa = RWanFindEa( pEa, TdiConnectionContext, TDI_CONNECTION_CONTEXT_LENGTH ); if (pTargetEa != NULL) { RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'OCrC', 0, 0); if (pTargetEa->EaValueLength < sizeof(CONNECTION_CONTEXT)) { Status = STATUS_INVALID_PARAMETER; break; } if (!pRWanDevice->pProtocol->bAllowConnObjects) { Status = STATUS_INVALID_DEVICE_REQUEST; break; } // // Call our TDI entry point for opening a Connection object. // Status = RWanTdiOpenConnection( &TdiRequest, *((CONNECTION_CONTEXT UNALIGNED *) &(pTargetEa->EaName[pTargetEa->EaNameLength + 1])) ); if (NT_SUCCESS(Status)) { #if DBG pEndpoint->pConnObject = RWanTdiDbgGetConnObject( TdiRequest.Handle.ConnectionContext ); #endif pEndpoint->Handle.ConnectionContext = TdiRequest.Handle.ConnectionContext; pIrpSp->FileObject->FsContext = pEndpoint; pIrpSp->FileObject->FsContext2 = (PVOID)TDI_CONNECTION_FILE; } break; } Status = STATUS_INVALID_DEVICE_REQUEST; break; } while (FALSE); if (Status != STATUS_SUCCESS) { // // Clean up. // if (pEndpoint != NULL) { RWAN_FREE_MEM(pEndpoint); pEndpoint = NULL; } } RWANDEBUGP(DL_VERY_LOUD, DC_DISPATCH, ("RWanCreate: pIrp x%x, pEndpoint x%x, Status x%x\n", pIrp, pEndpoint, Status)); return (Status); } NTSTATUS RWanCleanup( IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp, IN PIO_STACK_LOCATION pIrpSp ) /*++ Routine Description: Called to process an MJ_CLEANUP IRP. All outstanding IRPs are cancelled by calling the appropriate close routine for the object. We block until all outstanding IRPs are completed. Arguments: pDeviceObject - Not used pIrp - Pointer to IRP pIrpSp - IRP Stack location Return Value: NTSTATUS - this is the final clean-up status. --*/ { RWAN_IRQL OldIrql; PIRP pCancelIrp; PRWAN_ENDPOINT pEndpoint; TDI_REQUEST TdiRequest; NTSTATUS Status; UNREFERENCED_PARAMETER(pDeviceObject); pEndpoint = (PRWAN_ENDPOINT) pIrpSp->FileObject->FsContext; RWAN_STRUCT_ASSERT(pEndpoint, nep); IoAcquireCancelSpinLock(&OldIrql); pEndpoint->bCancelIrps = TRUE; KeResetEvent(&(pEndpoint->CleanupEvent)); RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'ealC', pIrp, pEndpoint->RefCount); IoReleaseCancelSpinLock(OldIrql); // // Prepare a Close request for the TDI layer. // TdiRequest.RequestNotifyObject = RWanCloseObjectComplete; TdiRequest.RequestContext = pIrp; switch ((INT)PtrToUint(pIrpSp->FileObject->FsContext2)) { case TDI_TRANSPORT_ADDRESS_FILE: TdiRequest.Handle.AddressHandle = pEndpoint->Handle.AddressHandle; Status = RWanTdiCloseAddress(&TdiRequest); break; case TDI_CONNECTION_FILE: TdiRequest.Handle.ConnectionContext = pEndpoint->Handle.ConnectionContext; Status = RWanTdiCloseConnection(&TdiRequest); break; case TDI_CONTROL_CHANNEL_FILE: Status = STATUS_SUCCESS; break; default: RWAN_ASSERT(FALSE); IoAcquireCancelSpinLock(&OldIrql); pEndpoint->bCancelIrps = FALSE; IoReleaseCancelSpinLock(OldIrql); return (STATUS_INVALID_PARAMETER); } if (Status != TDI_PENDING) { RWanCloseObjectComplete(pIrp, Status, 0); } // // Wait until all IRPs are completed. // Status = KeWaitForSingleObject( &(pEndpoint->CleanupEvent), UserRequest, KernelMode, FALSE, NULL ); RWAN_ASSERT(NT_SUCCESS(Status)); RWANDEBUGP(DL_VERY_LOUD, DC_DISPATCH, ("RWanCleanup: pIrp x%x, Context2 %d, pEndpoint x%x, returning Status x%x\n", pIrp, (INT)PtrToUint(pIrpSp->FileObject->FsContext2), pEndpoint, pIrp->IoStatus.Status)); return (pIrp->IoStatus.Status); } NTSTATUS RWanClose( IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp, IN PIO_STACK_LOCATION pIrpSp ) /*++ Routine Description: Called to destroy an endpoint that was created via MJ_CREATE. We'd have already processed and completed an MJ_CLEANUP, meaning that there would be no pending IRPs on this endpoint. All we need to do is deallocate the endpoint. Arguments: pDeviceObject - Identifies the protocol (not used) pIrp - Pointer to IRP pIrpSp - IRP Stack location Return Value: NT_STATUS - always STATUS_SUCCESS --*/ { PRWAN_ENDPOINT pEndpoint; KIRQL OldIrql; UNREFERENCED_PARAMETER(pDeviceObject); pEndpoint = (PRWAN_ENDPOINT) pIrpSp->FileObject->FsContext; RWAN_STRUCT_ASSERT(pEndpoint, nep); RWANDEBUGP(DL_LOUD, DC_DISPATCH, ("RWanClose: pIrp x%x, pEndpoint x%x\n", pIrp, pEndpoint)); RWAN_FREE_MEM(pEndpoint); return (STATUS_SUCCESS); } NTSTATUS RWanDispatchInternalDeviceControl( IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp ) /*++ Routine Description: Called to handle MJ_DEVICE_CONTROL IRPs sent to us. These IRPs carry TDI primitives (e.g. CONNECT, DISCONNECT, SEND, RECEIVE). We call the appropriate TDI routine to handle the specified primitive. Arguments: pDeviceObject - Identifies the protocol (Not used here) pIrp - Pointer to IRP Return Value: NTSTATUS - this is STATUS_PENDING if the IRP was successfully queued for processing, STATUS_NOT_IMPLEMENTED for unsupported TDI commands, and STATUS_INVALID_DEVICE_REQUEST for unknown commands. --*/ { PRWAN_ENDPOINT pEndpoint; KIRQL OldIrql; PIO_STACK_LOCATION pIrpSp; NTSTATUS Status; BOOLEAN bDone; #if DBG RWAN_IRQL EntryIrq, ExitIrq; #endif // DBG RWAN_GET_ENTRY_IRQL(EntryIrq); UNREFERENCED_PARAMETER(pDeviceObject); pIrpSp = IoGetCurrentIrpStackLocation(pIrp); pEndpoint = (PRWAN_ENDPOINT) pIrpSp->FileObject->FsContext; RWAN_STRUCT_ASSERT(pEndpoint, nep); RWANDEBUGP(DL_VERY_LOUD, DC_DISPATCH, ("RWanDispatchInternalDevCtl: pIrp x%x, pIrpSp x%x, pEndpoint x%x, Ctx2 %d\n", pIrp, pIrpSp, pEndpoint, (INT)PtrToUint(pIrpSp->FileObject->FsContext2))); do { if (((INT)PtrToUint(pIrpSp->FileObject->FsContext2)) == TDI_CONNECTION_FILE) { if (pIrpSp->MinorFunction == TDI_SEND) { RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'dneS', 0, 0); Status = RWanSendData(pIrp, pIrpSp); break; } if (pIrpSp->MinorFunction == TDI_RECEIVE) { RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'vceR', 0, 0); Status = RWanReceiveData(pIrp, pIrpSp); break; } bDone = TRUE; switch (pIrpSp->MinorFunction) { case TDI_ASSOCIATE_ADDRESS: RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'AssA', pIrp, pEndpoint->RefCount); Status = RWanAssociateAddress(pIrp, pIrpSp); RWAN_COMPLETE_IRP(pIrp, Status, 0); break; case TDI_DISASSOCIATE_ADDRESS: RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'AsiD', pIrp, pEndpoint->RefCount); Status = RWanDisassociateAddress(pIrp, pIrpSp); break; case TDI_CONNECT: RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'nnoC', pIrp, pEndpoint->RefCount); Status = RWanConnect(pIrp, pIrpSp); break; case TDI_DISCONNECT: RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'csiD', pIrp, pEndpoint->RefCount); Status = RWanDisconnect(pIrp, pIrpSp); break; case TDI_LISTEN: RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'tsiL', pIrp, pEndpoint->RefCount); Status = RWanListen(pIrp, pIrpSp); break; case TDI_ACCEPT: RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'eccA', pIrp, pEndpoint->RefCount); Status = RWanAccept(pIrp, pIrpSp); break; default: bDone = FALSE; #if 0 // Allow TDI_QUERY_INFORMATION on Conn endpoints to fall through RWANDEBUGP(DL_WARN, DC_DISPATCH, ("RWanDispatchInternalDevCtl: pIrp x%x, pIrpSp x%x, unknown func x%x\n", pIrp, pIrpSp, pIrpSp->MinorFunction)); Status = STATUS_INVALID_DEVICE_REQUEST; RWAN_COMPLETE_IRP(pIrp, Status, 0); #else bDone = FALSE; #endif break; } if (bDone) { break; } // // else fall through - may be something common to all types // of endpoints. // } else if (((INT)PtrToUint(pIrpSp->FileObject->FsContext2)) == TDI_TRANSPORT_ADDRESS_FILE) { if (pIrpSp->MinorFunction == TDI_SET_EVENT_HANDLER) { RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'EteS', 0, 0); Status = RWanSetEventHandler(pIrp, pIrpSp); RWAN_COMPLETE_IRP(pIrp, Status, 0); break; } } RWAN_ASSERT( (((INT)PtrToUint(pIrpSp->FileObject->FsContext2)) == TDI_TRANSPORT_ADDRESS_FILE) || (((INT)PtrToUint(pIrpSp->FileObject->FsContext2)) == TDI_CONNECTION_FILE) || (((INT)PtrToUint(pIrpSp->FileObject->FsContext2)) == TDI_CONTROL_CHANNEL_FILE) ); // // Check if this is a function common to all types of endpoints. // switch (pIrpSp->MinorFunction) { case TDI_QUERY_INFORMATION: RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'IyrQ', 0, 0); Status = RWanQueryInformation(pIrp, pIrpSp); break; case TDI_SET_INFORMATION: case TDI_ACTION: RWANDEBUGP(DL_INFO, DC_DISPATCH, ("RWanDispatchInternalDevCtl: SET_INFO/ACTION not supported\n")); RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'IteS', 0, 0); Status = STATUS_NOT_IMPLEMENTED; RWAN_COMPLETE_IRP(pIrp, Status, 0); break; default: Status = STATUS_INVALID_DEVICE_REQUEST; RWAN_COMPLETE_IRP(pIrp, Status, 0); break; } break; } while (FALSE); RWANDEBUGP(DL_VERY_LOUD, DC_DISPATCH, ("RWanDispatchInternalDevCtl: pIrp x%x, pIrpSp x%x, Maj/Min %d/%d, Status x%x\n", pIrp, pIrpSp, pIrpSp->MajorFunction, pIrpSp->MinorFunction, Status)); RWAN_CHECK_EXIT_IRQL(EntryIrq, ExitIrq); return (Status); } NTSTATUS RWanDispatchPrivateDeviceControl( IN PIRP pIrp, IN PIO_STACK_LOCATION pIrpSp ) /*++ Routine Description: Called to handle MJ_DEVICE_CONTROL IRPs sent to us that contain non-TDI primitives. Arguments: pIrp - Pointer to IRP pIrpSp - IRP Stack location Return Value: NTSTATUS - this is STATUS_PENDING if the IRP was successfully queued for processing, STATUS_NOT_IMPLEMENTED for unsupported commands, and STATUS_INVALID_DEVICE_REQUEST for unknown commands. --*/ { PRWAN_ENDPOINT pEndpoint; KIRQL OldIrql; RWAN_STATUS RWanStatus; NTSTATUS Status; PRWAN_NDIS_AF_CHARS pAfChars; PVOID pInputBuffer; PVOID pOutputBuffer; ULONG InputBufferLength; ULONG OutputBufferLength; PAGED_CODE(); pEndpoint = (PRWAN_ENDPOINT) pIrpSp->FileObject->FsContext; RWAN_STRUCT_ASSERT(pEndpoint, nep); // // Initialize. // pIrp->IoStatus.Information = 0; Status = STATUS_INVALID_DEVICE_REQUEST; // // Get some parameters from the IRP. // pInputBuffer = pIrpSp->Parameters.DeviceIoControl.Type3InputBuffer; pOutputBuffer = pIrp->UserBuffer; InputBufferLength = pIrpSp->Parameters.DeviceIoControl.InputBufferLength; OutputBufferLength = pIrpSp->Parameters.DeviceIoControl.OutputBufferLength; RWANDEBUGP(DL_INFO, DC_DISPATCH, ("PrivateDevCtl: pEndpoint x%x, CtlCode x%x, InBuf x%x/%d, OutBuf x%x/%d\n", pEndpoint, pIrpSp->Parameters.DeviceIoControl.IoControlCode, pInputBuffer, InputBufferLength, pOutputBuffer, OutputBufferLength)); // // Validate the pointers we've got. // if (InputBufferLength) { try { if (pIrp->RequestorMode != KernelMode) { ProbeForRead( pInputBuffer, InputBufferLength, sizeof(ULONG) ); } } except(EXCEPTION_EXECUTE_HANDLER) { RWAN_COMPLETE_IRP(pIrp, STATUS_INVALID_DEVICE_REQUEST, 0); return (STATUS_INVALID_DEVICE_REQUEST); } } if (OutputBufferLength) { try { if (pIrp->RequestorMode != KernelMode) { ProbeForWrite( pOutputBuffer, OutputBufferLength, sizeof(ULONG) ); } } except(EXCEPTION_EXECUTE_HANDLER) { RWAN_COMPLETE_IRP(pIrp, STATUS_INVALID_DEVICE_REQUEST, 0); return (STATUS_INVALID_DEVICE_REQUEST); } } switch (pIrpSp->Parameters.DeviceIoControl.IoControlCode) { case IOCTL_RWAN_GENERIC_GLOBAL_QUERY: case IOCTL_RWAN_GENERIC_GLOBAL_SET: Status = STATUS_NOT_IMPLEMENTED; break; case IOCTL_RWAN_GENERIC_CONN_HANDLE_QUERY: if (((INT)PtrToUint(pIrpSp->FileObject->FsContext2)) != TDI_CONNECTION_FILE) { Status = STATUS_INVALID_DEVICE_REQUEST; break; } RWanStatus = RWanHandleGenericConnQryInfo( pEndpoint->Handle.ConnectionContext, pInputBuffer, InputBufferLength, pOutputBuffer, &OutputBufferLength ); Status = RWanToNTStatus(RWanStatus); if (Status != STATUS_SUCCESS) { OutputBufferLength = 0; } break; case IOCTL_RWAN_GENERIC_ADDR_HANDLE_QUERY: case IOCTL_RWAN_GENERIC_CONN_HANDLE_SET: Status = STATUS_NOT_IMPLEMENTED; break; case IOCTL_RWAN_GENERIC_ADDR_HANDLE_SET: if (((INT)PtrToUint(pIrpSp->FileObject->FsContext2)) != TDI_TRANSPORT_ADDRESS_FILE) { Status = STATUS_INVALID_DEVICE_REQUEST; break; } RWanStatus = RWanHandleGenericAddrSetInfo( pEndpoint->Handle.AddressHandle, pInputBuffer, InputBufferLength ); Status = RWanToNTStatus(RWanStatus); OutputBufferLength = 0; break; case IOCTL_RWAN_MEDIA_SPECIFIC_GLOBAL_QUERY: // // Get the media-specific module's QueryInfo handler. // pAfChars = &(pEndpoint->pProtocol->pAfInfo->AfChars); if (pAfChars->pAfSpQueryGlobalInfo != NULL) { RWanStatus = (*pAfChars->pAfSpQueryGlobalInfo)( pEndpoint->pProtocol->pAfInfo->AfSpContext, pInputBuffer, InputBufferLength, pOutputBuffer, &OutputBufferLength ); Status = RWanToNTStatus(RWanStatus); if (Status != STATUS_SUCCESS) { OutputBufferLength = 0; } } else { Status = STATUS_NOT_IMPLEMENTED; } break; case IOCTL_RWAN_MEDIA_SPECIFIC_GLOBAL_SET: // // Get the media-specific module's SetInfo handler. // pAfChars = &(pEndpoint->pProtocol->pAfInfo->AfChars); if (pAfChars->pAfSpSetGlobalInfo != NULL) { RWanStatus = (*pAfChars->pAfSpSetGlobalInfo)( pEndpoint->pProtocol->pAfInfo->AfSpContext, pInputBuffer, InputBufferLength ); Status = RWanToNTStatus(RWanStatus); } else { Status = STATUS_NOT_IMPLEMENTED; } OutputBufferLength = 0; break; case IOCTL_RWAN_MEDIA_SPECIFIC_CONN_HANDLE_QUERY: if ((INT)PtrToUint(pIrpSp->FileObject->FsContext2) != TDI_CONNECTION_FILE) { Status = STATUS_INVALID_DEVICE_REQUEST; break; } RWanStatus = RWanHandleMediaSpecificConnQryInfo( pEndpoint->Handle.ConnectionContext, pInputBuffer, InputBufferLength, pOutputBuffer, &OutputBufferLength ); Status = RWanToNTStatus(RWanStatus); break; case IOCTL_RWAN_MEDIA_SPECIFIC_ADDR_HANDLE_QUERY: case IOCTL_RWAN_MEDIA_SPECIFIC_CONN_HANDLE_SET: Status = STATUS_NOT_IMPLEMENTED; break; case IOCTL_RWAN_MEDIA_SPECIFIC_ADDR_HANDLE_SET: if ((INT)PtrToUint(pIrpSp->FileObject->FsContext2) != TDI_TRANSPORT_ADDRESS_FILE) { Status = STATUS_INVALID_DEVICE_REQUEST; break; } RWanStatus = RWanHandleMediaSpecificAddrSetInfo( pEndpoint->Handle.AddressHandle, pInputBuffer, InputBufferLength ); Status = RWanToNTStatus(RWanStatus); OutputBufferLength = 0; break; default: OutputBufferLength = 0; Status = STATUS_INVALID_DEVICE_REQUEST; break; } RWAN_ASSERT(Status != STATUS_PENDING); RWAN_COMPLETE_IRP(pIrp, Status, OutputBufferLength); return (Status); } FILE_FULL_EA_INFORMATION UNALIGNED * RWanFindEa( IN FILE_FULL_EA_INFORMATION * pStartEa, IN CHAR * pTargetName, IN USHORT TargetNameLength ) /*++ Routine Description: Searches for a target name in an Extended Attribute list and returns it. Arguments: pStartEa - Start of the attribute list pTargetName - Pointer to name to look for TargetNameLength- Length of name Return Value: Pointer to attribute matching the target name, if found; NULL otherwise. --*/ { FILE_FULL_EA_INFORMATION UNALIGNED * pEa; FILE_FULL_EA_INFORMATION UNALIGNED * pNextEa; BOOLEAN Found; USHORT i; PAGED_CODE(); pNextEa = pStartEa; Found = FALSE; do { pEa = pNextEa; pNextEa = (FILE_FULL_EA_INFORMATION UNALIGNED *) ((PUCHAR)pNextEa + pNextEa->NextEntryOffset); if (pEa->EaNameLength == TargetNameLength) { for (i = 0; i < TargetNameLength; i++) { if (pEa->EaName[i] != pTargetName[i]) { break; } } if (i == TargetNameLength) { Found = TRUE; break; } } } while (pEa->NextEntryOffset != 0); return (Found? pEa: NULL); } NTSTATUS RWanSendData( IN PIRP pIrp, IN PIO_STACK_LOCATION pIrpSp ) /*++ Routine Description: Convert an IRP containing a TDI_SEND request to a call to our TDI dispatch routine for sends. We retain enough context to be able to complete the IRP when the send completes. Arguments: pIrp - Pointer to IRP pIrpSp - IRP Stack location Return Value: NTSTATUS - STATUS_PENDING if we managed to queue the send successfully, STATUS_CANCELLED if the IRP was cancelled. STATUS_SUCCESS if the send completed successfully, immediately. --*/ { PRWAN_ENDPOINT pEndpoint; KIRQL OldIrql; PTDI_REQUEST_KERNEL_SEND pSendRequest; TDI_REQUEST TdiRequest; NTSTATUS Status; pEndpoint = (PRWAN_ENDPOINT) pIrpSp->FileObject->FsContext; RWAN_STRUCT_ASSERT(pEndpoint, nep); pSendRequest = (PTDI_REQUEST_KERNEL_SEND) &(pIrpSp->Parameters); // // Prepare a TDI Send request. // TdiRequest.Handle.ConnectionContext = pEndpoint->Handle.ConnectionContext; TdiRequest.RequestNotifyObject = (PVOID) RWanDataRequestComplete; TdiRequest.RequestContext = (PVOID) pIrp; IoAcquireCancelSpinLock(&OldIrql); if (!pIrp->Cancel) { // // The IRP hasn't been cancelled. Set it up so that we are // informed if it does get cancelled later. // IoMarkIrpPending(pIrp); IoSetCancelRoutine(pIrp, RWanCancelRequest); RWAN_INCR_EP_REF_CNT(pEndpoint, SendIncr); // Send ref RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'DneS', pIrp, pEndpoint->RefCount); IoReleaseCancelSpinLock(OldIrql); Status = RWanTdiSendData( &TdiRequest, (USHORT)pSendRequest->SendFlags, pSendRequest->SendLength, (PNDIS_BUFFER) pIrp->MdlAddress ); if (Status != TDI_PENDING) { // // The Send either completed immediately, or failed. // pIrpSp->Control &= ~SL_PENDING_RETURNED; if (Status == TDI_SUCCESS) { // // Examples of immediate successful completion: // - A zero length send // RWanDataRequestComplete(pIrp, Status, pSendRequest->SendLength); } else { // // The Send failed, could be a resource problem. // RWANDEBUGP(DL_INFO, DC_DATA_TX, ("RWanSendData: pIrp x%x, pEndpoint x%x, TDI send fail: x%x\n", pIrp, pEndpoint, Status)); RWanDataRequestComplete(pIrp, Status, 0); } } } else { // // The IRP has been cancelled before it could reach us. // IoReleaseCancelSpinLock(OldIrql); Status = STATUS_CANCELLED; RWAN_COMPLETE_IRP(pIrp, Status, 0); } RWANDEBUGP(DL_LOUD, DC_DATA_TX, ("RWanSendData: pIrp x%x, pEndpoint x%x, ret Status x%x\n", pIrp, pEndpoint, Status)); return (Status); } NTSTATUS RWanReceiveData( IN PIRP pIrp, IN PIO_STACK_LOCATION pIrpSp ) /*++ Routine Description: Convert an IRP containing a TDI_RECEIVE request to a call to our TDI dispatch routine for receives. We retain enough context to be able to complete the IRP when the receive completes. The FileObject within the IRP refers to the connection endpoint. Arguments: pIrp - Pointer to IRP pIrpSp - IRP Stack location Return Value: NTSTATUS - STATUS_PENDING if we managed to queue the receive successfully, STATUS_CANCELLED if the IRP was cancelled. --*/ { PRWAN_ENDPOINT pEndpoint; KIRQL OldIrql; PTDI_REQUEST_KERNEL_RECEIVE pReceiveRequest; TDI_REQUEST TdiRequest; NTSTATUS Status; pEndpoint = (PRWAN_ENDPOINT) pIrpSp->FileObject->FsContext; RWAN_STRUCT_ASSERT(pEndpoint, nep); pReceiveRequest = (PTDI_REQUEST_KERNEL_RECEIVE) &(pIrpSp->Parameters); // // Prepare a TDI Receive request. // TdiRequest.Handle.ConnectionContext = pEndpoint->Handle.ConnectionContext; TdiRequest.RequestNotifyObject = (PVOID) RWanDataRequestComplete; TdiRequest.RequestContext = (PVOID) pIrp; IoAcquireCancelSpinLock(&OldIrql); if (!pIrp->Cancel) { // // The IRP hasn't been cancelled. Set it up so that we are // informed if it does get cancelled later. // IoMarkIrpPending(pIrp); IoSetCancelRoutine(pIrp, RWanCancelRequest); RWAN_INCR_EP_REF_CNT(pEndpoint, RecvIncr); // Receive ref RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'DvcR', pIrp, pEndpoint->RefCount); IoReleaseCancelSpinLock(OldIrql); Status = RWanTdiReceive( &TdiRequest, (USHORT *) &(pReceiveRequest->ReceiveFlags), &(pReceiveRequest->ReceiveLength), (PNDIS_BUFFER) pIrp->MdlAddress ); if (Status != TDI_PENDING) { // // The Receive either completed immediately, or failed. // pIrpSp->Control &= ~SL_PENDING_RETURNED; RWANDEBUGP(DL_WARN, DC_DATA_TX, ("RWanReceiveData: pIrp x%x, pEndpoint x%x, TDI recv didnt pend: x%x\n", pIrp, pEndpoint, Status)); RWanDataRequestComplete(pIrp, Status, 0); } } else { // // The IRP has been cancelled before it could reach us. // IoReleaseCancelSpinLock(OldIrql); Status = STATUS_CANCELLED; RWAN_COMPLETE_IRP(pIrp, Status, 0); } RWANDEBUGP(DL_LOUD, DC_DATA_TX, ("RWanReceiveData: pIrp x%x, pEndpoint x%x, ret Status x%x\n", pIrp, pEndpoint, Status)); return (Status); } NTSTATUS RWanAssociateAddress( IN PIRP pIrp, IN PIO_STACK_LOCATION pIrpSp ) /*++ Routine Description: Converts a TDI_ASSOCIATE_ADDRESS IRP to a call to our AssociateAddress entry point. The FileObject in the IRP refers to the Connection Object, and the AddressHandle field within the kernel request refers to the Address Object. Arguments: pIrp - Pointer to IRP pIrpSp - IRP Stack location Return Value: NTSTATUS - STATUS_SUCCESS if successful, STATUS_XXX error code otherwise. --*/ { PRWAN_ENDPOINT pConnEndpoint; PRWAN_ENDPOINT pAddrEndpoint; PTDI_REQUEST_KERNEL_ASSOCIATE pAssociateRequest; TDI_REQUEST TdiRequest; PFILE_OBJECT pFileObject; NTSTATUS Status; PAGED_CODE(); pConnEndpoint = (PRWAN_ENDPOINT) pIrpSp->FileObject->FsContext; RWAN_STRUCT_ASSERT(pConnEndpoint, nep); // // Prepare a TDI Associate Request // TdiRequest.Handle.ConnectionContext = pConnEndpoint->Handle.ConnectionContext; pAssociateRequest = (PTDI_REQUEST_KERNEL_ASSOCIATE) &(pIrpSp->Parameters); // // Reference the file corresponding to the Address object. // This is just so that it doesn't go away while we're processing // the Associate. // // The Address object is identified by its handle buried inside // the Associate request. // Status = ObReferenceObjectByHandle( pAssociateRequest->AddressHandle, GENERIC_ALL, *IoFileObjectType, pIrp->RequestorMode, &pFileObject, NULL ); if (NT_SUCCESS(Status) && (pFileObject->DeviceObject->DriverObject == pRWanGlobal->pDriverObject)) { // // Found the file object. See if it is an Address object. // if ((INT)PtrToUint(pFileObject->FsContext2) == TDI_TRANSPORT_ADDRESS_FILE) { // // Get our endpoint representing this address object. // pAddrEndpoint = (PRWAN_ENDPOINT) pFileObject->FsContext; RWAN_STRUCT_ASSERT(pAddrEndpoint, nep); // // Dispatch this to the TDI layer. // Status = RWanTdiAssociateAddress( &TdiRequest, pAddrEndpoint->Handle.AddressHandle ); RWAN_ASSERT(Status != TDI_PENDING); ObDereferenceObject(pFileObject); } else { ObDereferenceObject(pFileObject); RWANDEBUGP(DC_ADDRESS, DL_WARN, ("RWanAssociateAddress: pIrp x%x, pConnEp x%x, bad Context2 %d\n", pIrp, pConnEndpoint, (INT)PtrToUint(pFileObject->FsContext2))); Status = STATUS_INVALID_HANDLE; } } else { RWANDEBUGP(DL_WARN, DC_ADDRESS, ("RWanAssociateAddress: pIrp x%x, pConnEp x%x, bad addr handle x%x\n", pIrp, pConnEndpoint, pAssociateRequest->AddressHandle)); // // Clean up properly. // if (NT_SUCCESS(Status)) { ObDereferenceObject(pFileObject); Status = STATUS_INVALID_HANDLE; } } RWANDEBUGP(DL_VERY_LOUD, DC_ADDRESS, ("RWanAssociateAddress: pIrp x%x, pConnEp x%x, Addr Handle x%x, Status x%x\n", pIrp, pConnEndpoint, pAssociateRequest->AddressHandle, Status)); return (Status); } NTSTATUS RWanDisassociateAddress( IN PIRP pIrp, IN PIO_STACK_LOCATION pIrpSp ) /*++ Routine Description: Converts a TDI_DISASSOCIATE_ADDRESS IRP to a call to our DisassociateAddress entry point. The FileObject in the IRP refers to the Connection Object that is to be disassociated. Arguments: pIrp - Pointer to IRP pIrpSp - IRP Stack location Return Value: None --*/ { PRWAN_ENDPOINT pConnEndpoint; TDI_REQUEST TdiRequest; NTSTATUS Status; PAGED_CODE(); pConnEndpoint = (PRWAN_ENDPOINT) pIrpSp->FileObject->FsContext; RWAN_STRUCT_ASSERT(pConnEndpoint, nep); // // Prepare a TDI Disassociate Request // TdiRequest.Handle.ConnectionContext = pConnEndpoint->Handle.ConnectionContext; TdiRequest.RequestNotifyObject = (PVOID)RWanRequestComplete; TdiRequest.RequestContext = (PVOID)pIrp; Status = RWanPrepareIrpForCancel(pConnEndpoint, pIrp, RWanCancelRequest); if (NT_SUCCESS(Status)) { Status = RWanTdiDisassociateAddress(&TdiRequest); if (Status != TDI_PENDING) { RWanRequestComplete(pIrp, Status, 0); Status = TDI_PENDING; } } RWANDEBUGP(DL_VERY_LOUD, DC_ADDRESS, ("RWanDisassociateAddr: pIrp x%x, pEndp x%x, Status x%x\n", pIrp, pConnEndpoint, Status)); return (Status); } NTSTATUS RWanConnect( IN PIRP pIrp, IN PIO_STACK_LOCATION pIrpSp ) /*++ Routine Description: Convert a TDI Connect IRP to a call to our Connect entry point. The FileObject in the IRP refers to the Connection Object on which the outgoing call is to be placed. Arguments: pIrp - Pointer to IRP pIrpSp - IRP Stack location Return Value: NTSTATUS - STATUS_PENDING if a call was initiated, STATUS_XXX error code otherwise. --*/ { PRWAN_ENDPOINT pConnEndpoint; TDI_REQUEST TdiRequest; PTDI_CONNECTION_INFORMATION pRequestInformation; PTDI_CONNECTION_INFORMATION pReturnInformation; PTDI_REQUEST_KERNEL_CONNECT pConnectRequest; NTSTATUS Status; PLARGE_INTEGER pRequestTimeout; LARGE_INTEGER MillisecondTimeout; ULONG Remainder; pConnEndpoint = (PRWAN_ENDPOINT) pIrpSp->FileObject->FsContext; RWAN_STRUCT_ASSERT(pConnEndpoint, nep); // // Grab all parameters from the IRP. // pConnectRequest = (PTDI_REQUEST_KERNEL_CONNECT) &(pIrpSp->Parameters); pRequestInformation = pConnectRequest->RequestConnectionInformation; pReturnInformation = pConnectRequest->ReturnConnectionInformation; // // Prepare a TDI CONNECT Request // TdiRequest.Handle.ConnectionContext = pConnEndpoint->Handle.ConnectionContext; TdiRequest.RequestNotifyObject = (PVOID)RWanRequestComplete; TdiRequest.RequestContext = (PVOID)pIrp; pRequestTimeout = (PLARGE_INTEGER)pConnectRequest->RequestSpecific; if (pRequestTimeout != NULL) { MillisecondTimeout = RWAN_CONVERT_100NS_TO_MS(*pRequestTimeout, &Remainder); } else { MillisecondTimeout.LowPart = 0; MillisecondTimeout.HighPart = 0; } Status = RWanPrepareIrpForCancel(pConnEndpoint, pIrp, RWanCancelRequest); if (NT_SUCCESS(Status)) { Status = RWanTdiConnect( &TdiRequest, ((MillisecondTimeout.LowPart != 0)? &(MillisecondTimeout.LowPart): NULL), pRequestInformation, pReturnInformation ); if (Status != TDI_PENDING) { RWanRequestComplete(pIrp, Status, 0); Status = STATUS_PENDING; } } RWANDEBUGP(DL_LOUD, DC_CONNECT, ("RWanConnect: pIrp x%x, pEndp x%x, Status x%x\n", pIrp, pConnEndpoint, Status)); return (Status); } NTSTATUS RWanDisconnect( IN PIRP pIrp, IN PIO_STACK_LOCATION pIrpSp ) /*++ Routine Description: Convert a TDI Connect IRP to a call to our Connect entry point. The FileObject in the IRP refers to the Connection Object hosting the connection to be disconnected. Arguments: pIrp - Pointer to IRP pIrpSp - IRP Stack location Return Value: NTSTATUS - STATUS_PENDING if a disconnect was initiated, STATUS_XXX error code otherwise. --*/ { PRWAN_ENDPOINT pConnEndpoint; TDI_REQUEST TdiRequest; PTDI_CONNECTION_INFORMATION pRequestInformation; PTDI_CONNECTION_INFORMATION pReturnInformation; PTDI_REQUEST_KERNEL_DISCONNECT pDisconnectRequest; NTSTATUS Status; PLARGE_INTEGER pRequestTimeout; LARGE_INTEGER MillisecondTimeout; BOOLEAN bAbortiveDisconnect; pConnEndpoint = (PRWAN_ENDPOINT) pIrpSp->FileObject->FsContext; RWAN_STRUCT_ASSERT(pConnEndpoint, nep); // // Grab all parameters from the IRP. // pDisconnectRequest = (PTDI_REQUEST_KERNEL_DISCONNECT) &(pIrpSp->Parameters); pRequestInformation = pDisconnectRequest->RequestConnectionInformation; pReturnInformation = pDisconnectRequest->ReturnConnectionInformation; // // Prepare a TDI DISCONNECT Request // TdiRequest.Handle.ConnectionContext = pConnEndpoint->Handle.ConnectionContext; TdiRequest.RequestContext = (PVOID)pIrp; pRequestTimeout = (PLARGE_INTEGER)pDisconnectRequest->RequestSpecific; if (pRequestTimeout != NULL) { ULONG Remainder; MillisecondTimeout = RWAN_CONVERT_100NS_TO_MS(*pRequestTimeout, &Remainder); #if 0 if ((pRequestTimeout->LowPart == -1) && (pRequestTimeout->HighPart == -1)) { MillisecondTimeout.LowPart = pRequestTimeout->LowPart; MillisecondTimeout.HighPart = 0; } else { MillisecondTimeout.QuadPart = -((*pRequestTimeout).QuadPart); MillisecondTimeout = RWAN_CONVERT_100NS_TO_MS(MillisecondTimeout); } RWAN_ASSERT(MillisecondTimeout.HighPart == 0); #endif // 0 } else { MillisecondTimeout.LowPart = 0; MillisecondTimeout.HighPart = 0; } if (pDisconnectRequest->RequestFlags & TDI_DISCONNECT_ABORT) { // // Use non-generic completion routine for abortive disconnects, // because they cannot be cancelled. // bAbortiveDisconnect = TRUE; IoMarkIrpPending(pIrp); TdiRequest.RequestNotifyObject = (PVOID)RWanNonCancellableRequestComplete; Status = STATUS_SUCCESS; } else { // // Non-abortive disconnect. // bAbortiveDisconnect = FALSE; Status = RWanPrepareIrpForCancel(pConnEndpoint, pIrp, RWanCancelRequest); TdiRequest.RequestNotifyObject = (PVOID)RWanRequestComplete; } if (NT_SUCCESS(Status)) { Status = RWanTdiDisconnect( &TdiRequest, ((MillisecondTimeout.LowPart != 0)? &(MillisecondTimeout.LowPart): NULL), (USHORT)pDisconnectRequest->RequestFlags, pRequestInformation, pReturnInformation ); if (Status != TDI_PENDING) { if (bAbortiveDisconnect) { RWanNonCancellableRequestComplete(pIrp, Status, 0); } else { RWanRequestComplete(pIrp, Status, 0); } Status = STATUS_PENDING; } } RWANDEBUGP(DL_LOUD, DC_DISCON, ("RWanDisconnect: pIrp x%x, pEndp x%x, Abortive %d, Status x%x\n", pIrp, pConnEndpoint, (INT)bAbortiveDisconnect, Status)); return (Status); } NTSTATUS RWanListen( IN PIRP pIrp, IN PIO_STACK_LOCATION pIrpSp ) /*++ Routine Description: Convert a TDI Listen IRP to a call to our Listen entry point. The FileObject in the IRP refers to the Connection Object on which this Listen is posted. Arguments: pIrp - Pointer to IRP pIrpSp - IRP Stack location Return Value: NTSTATUS - STATUS_PENDING if a Listen was initiated, STATUS_XXX error code otherwise. --*/ { PRWAN_ENDPOINT pConnEndpoint; TDI_REQUEST TdiRequest; PTDI_CONNECTION_INFORMATION pRequestInformation; PTDI_CONNECTION_INFORMATION pReturnInformation; PTDI_REQUEST_KERNEL_LISTEN pListenRequest; NTSTATUS Status; pConnEndpoint = (PRWAN_ENDPOINT) pIrpSp->FileObject->FsContext; RWAN_STRUCT_ASSERT(pConnEndpoint, nep); // // Grab all parameters from the IRP. // pListenRequest = (PTDI_REQUEST_KERNEL_LISTEN) &(pIrpSp->Parameters); pRequestInformation = pListenRequest->RequestConnectionInformation; pReturnInformation = pListenRequest->ReturnConnectionInformation; // // Prepare a TDI LISTEN Request // TdiRequest.Handle.ConnectionContext = pConnEndpoint->Handle.ConnectionContext; TdiRequest.RequestNotifyObject = (PVOID)RWanRequestComplete; TdiRequest.RequestContext = (PVOID)pIrp; Status = RWanPrepareIrpForCancel(pConnEndpoint, pIrp, RWanCancelRequest); if (NT_SUCCESS(Status)) { Status = RWanTdiListen( &TdiRequest, (USHORT)pListenRequest->RequestFlags, pRequestInformation, pReturnInformation ); if (Status != TDI_PENDING) { RWanRequestComplete(pIrp, Status, 0); Status = STATUS_PENDING; } } RWANDEBUGP(DL_LOUD, DC_CONNECT, ("RWanListen: pIrp x%x, pEndp x%x, Status x%x\n", pIrp, pConnEndpoint, Status)); return (Status); } NTSTATUS RWanAccept( IN PIRP pIrp, IN PIO_STACK_LOCATION pIrpSp ) /*++ Routine Description: Convert a TDI Accept IRP to a call to our Accept entry point. Arguments: pIrp - Pointer to IRP pIrpSp - IRP Stack location Return Value: NTSTATUS - STATUS_PENDING if an Accept was initiated, STATUS_XXX error code otherwise. --*/ { PRWAN_ENDPOINT pConnEndpoint; TDI_REQUEST TdiRequest; PTDI_CONNECTION_INFORMATION pRequestInformation; PTDI_CONNECTION_INFORMATION pReturnInformation; PTDI_REQUEST_KERNEL_ACCEPT pAcceptRequest; NTSTATUS Status; pConnEndpoint = (PRWAN_ENDPOINT) pIrpSp->FileObject->FsContext; RWAN_STRUCT_ASSERT(pConnEndpoint, nep); // // Grab all parameters from the IRP. // pAcceptRequest = (PTDI_REQUEST_KERNEL_ACCEPT) &(pIrpSp->Parameters); pRequestInformation = pAcceptRequest->RequestConnectionInformation; pReturnInformation = pAcceptRequest->ReturnConnectionInformation; // // Prepare a TDI ACCEPT Request // TdiRequest.Handle.ConnectionContext = pConnEndpoint->Handle.ConnectionContext; TdiRequest.RequestNotifyObject = (PVOID)RWanRequestComplete; TdiRequest.RequestContext = (PVOID)pIrp; Status = RWanPrepareIrpForCancel(pConnEndpoint, pIrp, RWanCancelRequest); if (NT_SUCCESS(Status)) { Status = RWanTdiAccept( &TdiRequest, pRequestInformation, pReturnInformation ); if (Status != TDI_PENDING) { RWanRequestComplete(pIrp, Status, 0); Status = STATUS_PENDING; } } RWANDEBUGP(DL_LOUD, DC_CONNECT, ("RWanAccept: pIrp x%x, pEndp x%x, Status x%x\n", pIrp, pConnEndpoint, Status)); return (Status); } NTSTATUS RWanSetEventHandler( IN PIRP pIrp, IN PIO_STACK_LOCATION pIrpSp ) /*++ Routine Description: Convert a TDI Set Event Handler IRP to a call to our set event handler entry point. Arguments: pIrp - Pointer to IRP pIrpSp - IRP Stack location Return Value: NTSTATUS - STATUS_SUCCESS if the request was successful, STATUS_XXX error code otherwise. --*/ { PRWAN_ENDPOINT pEndpoint; PTDI_REQUEST_KERNEL_SET_EVENT pSetEvent; NTSTATUS Status; PAGED_CODE(); pEndpoint = (PRWAN_ENDPOINT) pIrpSp->FileObject->FsContext; RWAN_STRUCT_ASSERT(pEndpoint, nep); pSetEvent = (PTDI_REQUEST_KERNEL_SET_EVENT) &(pIrpSp->Parameters); Status = RWanTdiSetEvent( pEndpoint->Handle.AddressHandle, pSetEvent->EventType, pSetEvent->EventHandler, pSetEvent->EventContext ); RWAN_ASSERT(Status != STATUS_PENDING); RWANDEBUGP(DL_LOUD, DC_DISPATCH, ("RWanSetEventHandler: pIrp x%x, pEndp x%x, Type x%x, Status x%x\n", pIrp, pEndpoint, pSetEvent->EventType, Status)); return (Status); } NTSTATUS RWanQueryInformation( IN PIRP pIrp, IN PIO_STACK_LOCATION pIrpSp ) /*++ Routine Description: Converts a TDI Query Information IRP to a call to the QueryInformation TDI entry point. Arguments: pIrp - Pointer to IRP pIrpSp - IRP Stack location Return Value: NTSTATUS - this is STATUS_SUCCESS if the query was completed successfully, STATUS_PENDING if it will be completed later, STATUS_XXX error code otherwise. --*/ { TDI_REQUEST TdiRequest; NTSTATUS Status; PRWAN_ENDPOINT pEndpoint; PTDI_REQUEST_KERNEL_QUERY_INFORMATION pQueryInfo; UINT IsConnection; UINT DataSize; IsConnection = FALSE; DataSize = 0; pEndpoint = (PRWAN_ENDPOINT) pIrpSp->FileObject->FsContext; RWAN_STRUCT_ASSERT(pEndpoint, nep); pQueryInfo = (PTDI_REQUEST_KERNEL_QUERY_INFORMATION) &(pIrpSp->Parameters); TdiRequest.RequestNotifyObject = RWanDataRequestComplete; TdiRequest.RequestContext = pIrp; Status = STATUS_SUCCESS; switch (pQueryInfo->QueryType) { case TDI_QUERY_BROADCAST_ADDRESS: Status = STATUS_NOT_IMPLEMENTED; break; case TDI_QUERY_PROVIDER_INFO: TdiRequest.Handle.ControlChannel = pEndpoint->Handle.ControlChannel; break; case TDI_QUERY_ADDRESS_INFO: if (((INT)PtrToUint(pIrpSp->FileObject->FsContext2)) == TDI_CONNECTION_FILE) { IsConnection = TRUE; TdiRequest.Handle.ConnectionContext = pEndpoint->Handle.ConnectionContext; } else { // // Must be an address object. // RWAN_ASSERT(((INT) PtrToUint(pIrpSp->FileObject->FsContext2)) == TDI_TRANSPORT_ADDRESS_FILE); TdiRequest.Handle.AddressHandle = pEndpoint->Handle.AddressHandle; } break; case TDI_QUERY_CONNECTION_INFO: // // Must be a connection object. // RWAN_ASSERT(((INT) PtrToUint(pIrpSp->FileObject->FsContext2)) == TDI_CONNECTION_FILE); IsConnection = TRUE; TdiRequest.Handle.ConnectionContext = pEndpoint->Handle.ConnectionContext; break; case TDI_QUERY_PROVIDER_STATISTICS: // // Must be a control channel. // RWAN_ASSERT(((INT) PtrToUint(pIrpSp->FileObject->FsContext2)) == TDI_CONTROL_CHANNEL_FILE); TdiRequest.Handle.ControlChannel = pEndpoint->Handle.ControlChannel; break; default: Status = STATUS_NOT_IMPLEMENTED; break; } if (NT_SUCCESS(Status)) { Status = RWanPrepareIrpForCancel(pEndpoint, pIrp, NULL); if (NT_SUCCESS(Status)) { DataSize = RWanGetMdlChainLength(pIrp->MdlAddress); Status = RWanTdiQueryInformation( &TdiRequest, pQueryInfo->QueryType, pIrp->MdlAddress, &DataSize, IsConnection ); RWANDEBUGP(DL_LOUD, DC_DISPATCH, ("RWanQueryInformation: pIrp x%x, pEndp x%x, Type x%x, Status x%x\n", pIrp, pEndpoint, pQueryInfo->QueryType, Status)); if (Status != TDI_PENDING) { RWanDataRequestComplete(pIrp, Status, DataSize); } return (STATUS_PENDING); } else { return (Status); } } RWAN_COMPLETE_IRP(pIrp, Status, 0); return (Status); } VOID RWanCloseObjectComplete( IN PVOID Context, IN UINT Status, IN UINT Unused ) /*++ Routine Description: This is the call-back routine that processes a CloseConnection or CloseAddress completion. This is called by the core TDI provider. We dereference the endpoint; if it goes to 0, we wake up the thread that's running the CLEANUP. Arguments: Context - A pointer to the IRP for this request. Status - Final TDI status for the CloseConnection/CloseAddress Unused - Not used for this completion Return Value: None --*/ { KIRQL OldIrql; PIRP pIrp; PIO_STACK_LOCATION pIrpSp; PRWAN_ENDPOINT pEndpoint; UNREFERENCED_PARAMETER(Unused); pIrp = (PIRP)Context; pIrpSp = IoGetCurrentIrpStackLocation(pIrp); pIrp->IoStatus.Status = Status; pEndpoint = (PRWAN_ENDPOINT) pIrpSp->FileObject->FsContext; RWAN_STRUCT_ASSERT(pEndpoint, nep); IoAcquireCancelSpinLock(&OldIrql); IoSetCancelRoutine(pIrp, NULL); RWAN_DECR_EP_REF_CNT(pEndpoint, CloseComplDecr); // CloseComplete deref RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'pmCC', pIrp, pEndpoint->RefCount); if (pEndpoint->RefCount == 0) { // // The endpoint must be cleaning up. // RWANDEBUGP(DL_LOUD, DC_DISPATCH, ("RWanCloseObjectComplete: pIrp x%x, pEndpoint x%x ref count 0\n", pIrp, pEndpoint)); KeSetEvent(&(pEndpoint->CleanupEvent), 0, FALSE); } IoReleaseCancelSpinLock(OldIrql); return; } VOID RWanDataRequestComplete( IN PVOID Context, IN UINT Status, IN UINT ByteCount ) /*++ Routine Description: This is the call-back routine that processes a Send/Receive completion. This is called by the core TDI provider. We complete the send/receive IRP appropriately, and dereference our endpoint. Arguments: Context - A pointer to the IRP for this request. Status - Final TDI status for send/receive ByteCount - Actual bytes sent/received. Return Value: None --*/ { KIRQL OldIrql; PIRP pIrp; PIO_STACK_LOCATION pIrpSp; PRWAN_ENDPOINT pEndpoint; pIrp = (PIRP)Context; pIrpSp = IoGetCurrentIrpStackLocation(pIrp); pEndpoint = (PRWAN_ENDPOINT) pIrpSp->FileObject->FsContext; RWAN_STRUCT_ASSERT(pEndpoint, nep); IoAcquireCancelSpinLock(&OldIrql); IoSetCancelRoutine(pIrp, NULL); RWAN_DECR_EP_REF_CNT(pEndpoint, DataReqComplDecr); // Send/Receive deref RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'CerD', pIrp, pEndpoint->RefCount); RWANDEBUGP(DL_EXTRA_LOUD, DC_DATA_TX|DC_DATA_RX|DC_CONNECT|DC_DISCON, ("RWanDataReq compl: pIrp x%x, pEndpoint x%x, RefCnt %d, Sts x%x, ByteCnt %d\n", pIrp, pEndpoint, pEndpoint->RefCount, Status, ByteCount)); if (pEndpoint->RefCount == 0) { // // The endpoint must be cleaning up. // RWANDEBUGP(DL_LOUD, DC_DISPATCH, ("RWanDataRequestComplete: pIrp x%x, pEndpoint x%x ref count 0\n", pIrp, pEndpoint)); KeSetEvent(&(pEndpoint->CleanupEvent), 0, FALSE); } // // If the IRP was cancelled or we are cleaning up, // update the completion status. // if (pIrp->Cancel || pEndpoint->bCancelIrps) { Status = (UINT)STATUS_CANCELLED; ByteCount = 0; } IoReleaseCancelSpinLock(OldIrql); RWAN_COMPLETE_IRP(pIrp, Status, ByteCount); return; } VOID RWanRequestComplete( IN PVOID Context, IN UINT Status, IN UINT Unused ) /*++ Routine Description: This is our call-back routine for completing requests that don't include data. IRP processing is the same as that for data, except that the ByteCount is 0. Arguments: Context - A pointer to the IRP for this request. Status - Final TDI status for the request. Unused - Not used. Return Value: None --*/ { UNREFERENCED_PARAMETER(Unused); RWanDataRequestComplete(Context, Status, 0); } VOID RWanNonCancellableRequestComplete( IN PVOID Context, IN UINT Status, IN UINT Unused ) /*++ Routine Description: This is our call-back routine for completing requests based on non-cancellable IRPs (e.g. Abortive Disconnect). Arguments: Context - A pointer to the IRP for this request. Status - Final TDI status for the request. Unused - Not used. Return Value: None --*/ { PIRP pIrp; PIO_STACK_LOCATION pIrpSp; UNREFERENCED_PARAMETER(Unused); pIrp = (PIRP)Context; pIrpSp = IoGetCurrentIrpStackLocation(pIrp); // // Complete the IRP // RWAN_COMPLETE_IRP(pIrp, Status, 0); return; } VOID RWanCancelComplete( IN PVOID Context, IN UINT Unused1, IN UINT Unused2 ) /*++ Routine Description: This is called to process internal completion of an IRP cancellation. All we need to do here is to dereference the endpoint on which this happened. Arguments: Context - A pointer to the file object representing the endpoint on which the IRP was cancelled. Unused[1-2] - Not used Return Value: None --*/ { PFILE_OBJECT pFileObject; PRWAN_ENDPOINT pEndpoint; KIRQL OldIrql; UNREFERENCED_PARAMETER(Unused1); UNREFERENCED_PARAMETER(Unused2); pFileObject = (PFILE_OBJECT)Context; pEndpoint = (PRWAN_ENDPOINT)(pFileObject->FsContext); RWAN_STRUCT_ASSERT(pEndpoint, nep); IoAcquireCancelSpinLock(&OldIrql); RWAN_DECR_EP_REF_CNT(pEndpoint, CancelComplDecr); // CancelComplete deref RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'CnaC', 0, pEndpoint->RefCount); RWANDEBUGP(DL_EXTRA_LOUD, DC_DISPATCH, ("RWanCancelComplete: pEndpoint x%x, RefCount %d\n", pEndpoint, pEndpoint->RefCount)); if (pEndpoint->RefCount == 0) { // // Wake up the thread waiting for IRPs to complete // KeSetEvent(&(pEndpoint->CleanupEvent), 0, FALSE); } IoReleaseCancelSpinLock(OldIrql); return; } VOID RWanCancelRequest( IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp ) /*++ Routine Description: This is the cancel routine we attach to IRPs that we queue. This is supposed to cancel the IRP. Arguments: pDeviceObject - Pointer to the device object for this IRP pIrp - Pointer to request packet Return Value: None --*/ { PFILE_OBJECT pFileObject; PIO_STACK_LOCATION pIrpSp; PRWAN_ENDPOINT pEndpoint; NTSTATUS Status; TDI_REQUEST TdiRequest; UCHAR MinorFunction; pIrpSp = IoGetCurrentIrpStackLocation(pIrp); pFileObject = pIrpSp->FileObject; MinorFunction = pIrpSp->MinorFunction; pEndpoint = (PRWAN_ENDPOINT) pFileObject->FsContext; RWAN_STRUCT_ASSERT(pEndpoint, nep); // // This routine is entered with Cancel SpinLock acquired. // RWAN_ASSERT(pIrp->Cancel); IoSetCancelRoutine(pIrp, NULL); // // Make sure that the endpoint doesn't go away when // we release the Cancel Spinlock. // RWAN_INCR_EP_REF_CNT(pEndpoint, CancelIncr); // Cancel ref RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'RnaC', pIrp, pEndpoint->RefCount); IoReleaseCancelSpinLock(pIrp->CancelIrql); RWANDEBUGP(DL_LOUD, DC_DISPATCH, ("RWanCancelRequest: pIrp x%x, MinorFunc %d, pEndpoint x%x\n", pIrp, MinorFunction, pEndpoint)); Status = STATUS_SUCCESS; switch (MinorFunction) { case TDI_SEND: case TDI_RECEIVE: RWanAbortConnection( pEndpoint->Handle.ConnectionContext ); break; case TDI_DISASSOCIATE_ADDRESS: break; case TDI_LISTEN: // // Initiate an Unlisten. // TdiRequest.Handle.ConnectionContext = pEndpoint->Handle.ConnectionContext; TdiRequest.RequestNotifyObject = (PVOID)RWanCancelComplete; TdiRequest.RequestContext = (PVOID)pFileObject; Status = RWanTdiUnListen( &TdiRequest ); break; default: // // Initiate a Disconnect. // TdiRequest.Handle.ConnectionContext = pEndpoint->Handle.ConnectionContext; TdiRequest.RequestNotifyObject = (PVOID)RWanCancelComplete; TdiRequest.RequestContext = (PVOID)pFileObject; Status = RWanTdiDisconnect( &TdiRequest, NULL, TDI_DISCONNECT_ABORT, NULL, NULL ); break; } if (Status != TDI_PENDING) { RWanCancelComplete(pFileObject, 0, 0); } return; } NTSTATUS RWanPrepareIrpForCancel( IN PRWAN_ENDPOINT pEndpoint, IN PIRP pIrp, IN PDRIVER_CANCEL pCancelRoutine ) /*++ Routine Description: Check if an IRP has been cancelled. If so, complete it with the right status. Otherwise, set it up so that the supplied cancel routine is called if it is cancelled. This is called for non-data IRPs that are potentially going to pend. Arguments: pEndpoint - Pointer to endpoint on which this IRP arrived pIrp - Pointer to request packet pCancelRoutine - Cancellation routine to be tacked on to the IRP Return Value: NTSTATUS - this is STATUS_CANCELLED if the IRP has been cancelled already, STATUS_SUCCESS otherwise. --*/ { KIRQL OldIrql; NTSTATUS Status; IoAcquireCancelSpinLock(&OldIrql); RWAN_ASSERT(pIrp->CancelRoutine == NULL); if (!pIrp->Cancel) { // // This IRP hasn't been cancelled. Mark it as pending, because // it's going to be queued (by the caller). // IoMarkIrpPending(pIrp); IoSetCancelRoutine(pIrp, pCancelRoutine); // // Add a reference for this IRP on the endpoint. // RWAN_INCR_EP_REF_CNT(pEndpoint, NonDataIncr); // Non data IRP ref RWAN_EP_DBGLOG_ENTRY(pEndpoint, 'DnoN', pIrp, pEndpoint->RefCount); IoReleaseCancelSpinLock(OldIrql); Status = STATUS_SUCCESS; } else { // // The IRP has been cancelled already. Simply complete it. // IoReleaseCancelSpinLock(OldIrql); Status = STATUS_CANCELLED; RWAN_COMPLETE_IRP(pIrp, Status, 0); } RWANDEBUGP(DL_VERY_LOUD, DC_DISPATCH, ("RWanPrepareIrpForCancel: pIrp x%x, pEndp x%x, ret Status x%x\n", pIrp, pEndpoint, Status)); return (Status); } ULONG RWanGetMdlChainLength( IN PMDL pMdl ) /*++ Routine Description: Return the total byte count of all MDLs in a chain. Arguments: pMdl - Points to start of MDL chain. Return Value: Byte count of the MDL chain. --*/ { ULONG Count = 0; while (pMdl != NULL) { Count += MmGetMdlByteCount(pMdl); pMdl = pMdl->Next; } return (Count); } NTSTATUS RWanToNTStatus( IN RWAN_STATUS RWanStatus ) /*++ Routine Description: Map from a Raw-WAN status code to an equivalent NT status code. Arguments: RWanStatus - The RAW WAN status code. Return Value: The NT Status code. --*/ { NTSTATUS Status; switch (RWanStatus) { case RWAN_STATUS_SUCCESS: Status = STATUS_SUCCESS; break; case RWAN_STATUS_BAD_ADDRESS: Status = STATUS_INVALID_ADDRESS; break; case RWAN_STATUS_BAD_PARAMETER: Status = STATUS_INVALID_PARAMETER; break; case RWAN_STATUS_MISSING_PARAMETER: Status = STATUS_INVALID_PARAMETER; break; case RWAN_STATUS_RESOURCES: Status = STATUS_INSUFFICIENT_RESOURCES; break; case RWAN_STATUS_FAILURE: default: Status = STATUS_UNSUCCESSFUL; break; } return (Status); }