/*++ Copyright (c) 1996 Microsoft Corporation Module Name: adapter.c - Adapter Interface routines. Abstract: Handlers for adapter events are here. The only exception is the CoReceivePacket handler, which is in arppkt.c. Revision History: Who When What -------- -------- ---------------------------------------------- arvindm 08-12-96 Created Notes: --*/ #include #define _FILENUMBER 'PADA' ULONG MCastSendOk = 0; ULONG MCastSendFail = 0; ULONG MCastRcv = 0; INT AtmArpBindAdapterHandler( OUT PNDIS_STATUS pStatus, IN NDIS_HANDLE BindContext, IN PNDIS_STRING pDeviceName, IN PVOID SystemSpecific1, IN PVOID SystemSpecific2 ) /*++ Routine Description: This is called by NDIS when it has an adapter for which there is a binding to the ATMARP client. We first allocate an Adapter structure. Then we open our configuration section for this adapter and save the handle in the Adapter structure. Finally, we open the adapter. We don't do anything more for this adapter until NDIS notifies us of the presence of a Call manager (via our AfRegisterNotify handler). Arguments: pStatus - Place to return status of this call BindContext - Not used, because we don't pend this call pDeviceName - The name of the adapter we are requested to bind to SystemSpecific1 - Opaque to us; to be used to access configuration info SystemSpecific2 - Opaque to us; not used. Return Value: Always TRUE. We set *pStatus to an error code if something goes wrong before we call NdisOpenAdapter, otherwise NDIS_STATUS_PENDING. --*/ { PATMARP_ADAPTER pAdapter; // Pointer to new adapter structure PATMARP_ADAPTER * ppAdapter; // Used in case we need to delink NDIS_STATUS Status; NDIS_STATUS OpenStatus; UINT MediumIndex; ULONG Length; PNDIS_STRING pAdapterConfigString; #ifdef ATMARP_WIN98 PANSI_STRING pAnsiConfigString; NDIS_STRING UnicodeConfigString; #endif AADEBUGP(AAD_LOUD, ("BindAdapter: Context 0x%x, pDevName 0x%x, SS1 0x%x, SS2 0x%x\n", BindContext, pDeviceName, SystemSpecific1, SystemSpecific2)); #if DBG if (AaSkipAll) { AADEBUGP(AAD_ERROR, ("BindAdapter: aborting\n")); *pStatus = NDIS_STATUS_NOT_RECOGNIZED; return ((INT)TRUE); } #endif // DBG // // Initialize. // pAdapter = NULL_PATMARP_ADAPTER; Status = NDIS_STATUS_SUCCESS; #ifdef ATMARP_WIN98 UnicodeConfigString.Buffer = NULL; #endif do { #ifndef ATMARP_WIN98 pAdapterConfigString = (PNDIS_STRING)SystemSpecific1; #else // // SS1 is a pointer to an ANSI string. Convert it to Unicode. // pAnsiConfigString = (PANSI_STRING)SystemSpecific1; AA_ALLOC_MEM(UnicodeConfigString.Buffer, WCHAR, sizeof(WCHAR)*(pAnsiConfigString->MaximumLength)); if (UnicodeConfigString.Buffer == NULL) { Status = NDIS_STATUS_RESOURCES; break; } UnicodeConfigString.MaximumLength = sizeof(WCHAR) * (pAnsiConfigString->MaximumLength); UnicodeConfigString.Length = 0; NdisAnsiStringToUnicodeString(&UnicodeConfigString, pAnsiConfigString); pAdapterConfigString = &UnicodeConfigString; #endif // // Check if this is a device we have already bound to. // if (AtmArpIsDeviceAlreadyBound(pDeviceName)) { Status = NDIS_STATUS_NOT_ACCEPTED; AADEBUGP(AAD_WARNING, ("BindAdapter: already bound to %Z\n", pDeviceName)); break; } // // Allocate an Adapter structure // Length = sizeof(ATMARP_ADAPTER) + pDeviceName->MaximumLength + sizeof(WCHAR) + pAdapterConfigString->MaximumLength; AA_ALLOC_MEM(pAdapter, ATMARP_ADAPTER, Length); if (pAdapter == NULL_PATMARP_ADAPTER) { Status = NDIS_STATUS_RESOURCES; break; } // // Initialize the Adapter structure // AA_SET_MEM(pAdapter, 0, Length); #if DBG pAdapter->aaa_sig = aaa_signature; #endif // DBG AA_INIT_BLOCK_STRUCT(&(pAdapter->Block)); pAdapter->SystemSpecific1 = SystemSpecific1; pAdapter->SystemSpecific2 = SystemSpecific2; pAdapter->BindContext = BindContext; pAdapter->DeviceName.MaximumLength = pDeviceName->MaximumLength; pAdapter->DeviceName.Length = pDeviceName->Length; pAdapter->DeviceName.Buffer = (PWCHAR)((PUCHAR)pAdapter + sizeof(ATMARP_ADAPTER)); AA_COPY_MEM(pAdapter->DeviceName.Buffer, pDeviceName->Buffer, pDeviceName->Length); // // Copy in the string to be used when we want to open our // configuration key for this adapter. // pAdapter->ConfigString.MaximumLength = pAdapterConfigString->MaximumLength; pAdapter->ConfigString.Length = pAdapterConfigString->Length; pAdapter->ConfigString.Buffer = (PWCHAR)((PUCHAR)pAdapter + sizeof(ATMARP_ADAPTER)+ pDeviceName->MaximumLength) + sizeof(WCHAR); AA_COPY_MEM(pAdapter->ConfigString.Buffer, pAdapterConfigString->Buffer, pAdapterConfigString->Length); AA_INIT_BLOCK_STRUCT(&pAdapter->UnbindBlock); AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo); // // Link this Adapter structure to the global list of adapters. // pAtmArpGlobalInfo->AdapterCount++; pAdapter->pNextAdapter = pAtmArpGlobalInfo->pAdapterList; pAtmArpGlobalInfo->pAdapterList = pAdapter; AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo); // // Open the adapter // pAdapter->Medium = NdisMediumAtm; NdisOpenAdapter( &Status, &OpenStatus, &(pAdapter->NdisAdapterHandle), &(MediumIndex), // place to return selected medium index &pAdapter->Medium, // Array of medium types 1, // Size of Media list pAtmArpGlobalInfo->ProtocolHandle, (NDIS_HANDLE)pAdapter, // our context for the adapter binding pDeviceName, 0, // Open options (PSTRING)NULL // Addressing Info... ); if (Status != NDIS_STATUS_PENDING) { AtmArpOpenAdapterCompleteHandler( (NDIS_HANDLE)pAdapter, Status, OpenStatus ); } Status = NDIS_STATUS_PENDING; break; } while (FALSE); if (Status != NDIS_STATUS_PENDING) { // // We didn't make it upto NdisOpenAdapter. Clean up. // AADEBUGP(AAD_WARNING, ("BindAdapter: failed with Status 0x%x\n", Status)); if (pAdapter != NULL_PATMARP_ADAPTER) { // // Free it. We know we haven't linked it to the global // list of adapters. // AA_FREE_MEM(pAdapter); } } #ifdef ATMARP_WIN98 if (UnicodeConfigString.Buffer != NULL) { AA_FREE_MEM(UnicodeConfigString.Buffer); } #endif // ATMARP_WIN98 *pStatus = Status; AADEBUGP(AAD_INFO, ("BindAdapterHandler: returning Status 0x%x\n", Status)); return ((INT)TRUE); } VOID AtmArpUnbindAdapterHandler( OUT PNDIS_STATUS pStatus, IN NDIS_HANDLE ProtocolBindingContext, IN NDIS_HANDLE UnbindContext ) /*++ Routine Description: This routine is called by NDIS when it wants us to unbind from an adapter. Or, this may be called from within our Unload handler. We undo the sequence of operations we performed in our BindAdapter handler. Arguments: pStatus - Place to return status of this operation ProtocolBindingContext - Our context for this adapter binding, which is a pointer to an ATMARP Adapter structure. UnbindContext - This is NULL if this routine is called from within our Unload handler. Otherwise (i.e. NDIS called us), we retain this for later use when calling NdisCompleteUnbindAdapter. Return Value: None. We set *pStatus to NDIS_STATUS_PENDING always. --*/ { PATMARP_ADAPTER pAdapter; PATMARP_INTERFACE pInterface; PATMARP_INTERFACE pNextInterface; NDIS_STATUS Status; #if DBG AA_IRQL EntryIrq, ExitIrq; #endif AA_GET_ENTRY_IRQL(EntryIrq); pAdapter = (PATMARP_ADAPTER)ProtocolBindingContext; AA_STRUCT_ASSERT(pAdapter, aaa); AADEBUGP(AAD_INFO, ("UnbindAdapterHandler: pAdapter 0x%x, UnbindContext 0x%x\n", pAdapter, UnbindContext)); *pStatus = NDIS_STATUS_PENDING; AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo); // // Save the unbind context for a possible later call to // NdisCompleteUnbindAdapter. // pAdapter->UnbindContext = UnbindContext; pAdapter->Flags |= AA_ADAPTER_FLAGS_UNBINDING; // // Wait for any AF register processing to finish. // while (pAdapter->Flags & AA_ADAPTER_FLAGS_PROCESSING_AF) { AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo); AADEBUGP(AAD_FATAL, ("UnbindAdapter: pAdapter %x, Afregister going on!!!\n", pAdapter)); Status = AA_WAIT_ON_BLOCK_STRUCT(&(pAdapter->UnbindBlock)); AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo); } AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo); // // If there are no Interfaces on this adapter, we are done. // if (pAdapter->pInterfaceList == NULL_PATMARP_INTERFACE) { AtmArpCompleteUnbindAdapter(pAdapter); AA_CHECK_EXIT_IRQL(EntryIrq, ExitIrq); return; } // // Mark all interfaces on this adapter. // for (pInterface = pAdapter->pInterfaceList; pInterface != NULL_PATMARP_INTERFACE; pInterface = pNextInterface) { pNextInterface = pInterface->pNextInterface; AA_ACQUIRE_IF_LOCK(pInterface); pInterface->AdminState = pInterface->State = IF_STATUS_DOWN; pInterface->LastChangeTime = GetTimeTicks(); AA_RELEASE_IF_LOCK(pInterface); } // // Now, bring down each of these interfaces. For each interface, // we tear down the ARP table, and shut down the Call Manager // interface. When this is complete, we will call IP's DelInterface // entry point. // for (pInterface = pAdapter->pInterfaceList; pInterface != NULL_PATMARP_INTERFACE; pInterface = pNextInterface) { pNextInterface = pInterface->pNextInterface; AtmArpShutdownInterface(pInterface); } AA_CHECK_EXIT_IRQL(EntryIrq, ExitIrq); return; } VOID AtmArpCompleteUnbindAdapter( IN PATMARP_ADAPTER pAdapter ) /*++ Routine Description: Complete the process of adapter unbinding. All Interfaces on this adapter are assumed to have been removed. If we are unbinding from the adapter as a result of NDIS' call to our UnbindAdapter handler, we complete that here. Arguments: pAdapter - Pointer to the adapter being unbound. Return Value: None --*/ { NDIS_HANDLE UnbindContext; PATMARP_ADAPTER * ppAdapter; NDIS_STATUS Status; UnbindContext = pAdapter->UnbindContext; AADEBUGP(AAD_INFO, ("CompleteUnbindAdapter: pAdapter 0x%x, UnbindContext 0x%x\n", pAdapter, UnbindContext)); AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo); if (pAdapter->Flags & AA_ADAPTER_FLAGS_CLOSING) { AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo); return; } pAdapter->Flags |= AA_ADAPTER_FLAGS_CLOSING; AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo); #if ATMOFFLOAD // // Disable offload if enabled... // AtmArpDisableOffload(pAdapter); #endif // ATMOFFLOAD NdisCloseAdapter( &Status, pAdapter->NdisAdapterHandle ); if (Status != NDIS_STATUS_PENDING) { AtmArpCloseAdapterCompleteHandler( (NDIS_HANDLE) pAdapter, Status ); } } VOID AtmArpOpenAdapterCompleteHandler( IN NDIS_HANDLE ProtocolBindingContext, IN NDIS_STATUS Status, IN NDIS_STATUS OpenErrorStatus ) /*++ Routine Description: This is called by NDIS when a previous call to NdisOpenAdapter that had pended has completed. We now complete the BindAdapter that lead to this. Arguments: ProtocolBindingContext - Our context for this adapter binding, which is a pointer to an ATMARP Adapter structure. Status - Status of OpenAdapter OpenErrorStatus - Error code in case of failure. Return Value: None --*/ { PATMARP_ADAPTER pAdapter; PATMARP_ADAPTER * ppAdapter; NDIS_HANDLE BindAdapterContext; pAdapter = (PATMARP_ADAPTER)ProtocolBindingContext; AA_STRUCT_ASSERT(pAdapter, aaa); BindAdapterContext = pAdapter->BindContext; if (Status != NDIS_STATUS_SUCCESS) { // // Remove the adapter from the global list. // AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo); ppAdapter = &(pAtmArpGlobalInfo->pAdapterList); while (*ppAdapter != pAdapter) { ppAdapter = &((*ppAdapter)->pNextAdapter); } *ppAdapter = pAdapter->pNextAdapter; pAtmArpGlobalInfo->AdapterCount--; AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo); AA_FREE_MEM(pAdapter); } #if ATMOFFLOAD else { // // Query and enable offloading // Status = AtmArpQueryAndEnableOffload(pAdapter); if (Status != NDIS_STATUS_SUCCESS) { // // AtmArpQueryAndEnableOffload is not supposed to return unless // there's a fatal error -- we don't expect this. // AA_ASSERT(FALSE); } } #endif //ATMOFFLOAD AADEBUGP(AAD_INFO, ("OpenAdapterComplete: pAdapter 0x%x, Status 0x%x\n", pAdapter, Status)); (*(pAtmArpGlobalInfo->pIPBindCompleteRtn))( Status, BindAdapterContext ); return; } VOID AtmArpCloseAdapterCompleteHandler( IN NDIS_HANDLE ProtocolBindingContext, IN NDIS_STATUS Status ) /*++ Routine Description: This is called by NDIS when a previous call to NdisCloseAdapter that had pended has completed. The thread that called NdisCloseAdapter would have blocked itself, so we simply wake it up now. Arguments: ProtocolBindingContext - Our context for this adapter binding, which is a pointer to an ATMARP Adapter structure. Status - Status of CloseAdapter Return Value: None --*/ { PATMARP_ADAPTER pAdapter; NDIS_HANDLE UnbindContext; PATMARP_ADAPTER * ppAdapter; pAdapter = (PATMARP_ADAPTER)ProtocolBindingContext; AA_STRUCT_ASSERT(pAdapter, aaa); UnbindContext = pAdapter->UnbindContext; AADEBUGP(AAD_INFO, ("CloseAdapterCompleteHandler: pAdapter 0x%x, UnbindContext 0x%x\n", pAdapter, UnbindContext)); pAdapter->NdisAdapterHandle = NULL; // // Remove the adapter from the global list. // AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo); ppAdapter = &(pAtmArpGlobalInfo->pAdapterList); while (*ppAdapter != pAdapter) { ppAdapter = &((*ppAdapter)->pNextAdapter); } *ppAdapter = pAdapter->pNextAdapter; pAtmArpGlobalInfo->AdapterCount--; AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo); // // Free any structures attached to the adapter structure. // if (pAdapter->pDescrString != (PUCHAR)NULL) { AA_FREE_MEM(pAdapter->pDescrString); } if (pAdapter->IPConfigString.Buffer != NULL) { AA_FREE_MEM(pAdapter->IPConfigString.Buffer); } // // Release the adapter structure. // AA_FREE_MEM(pAdapter); // // If NDIS had requested us to Unbind, complete the // request now. // if (UnbindContext != (NDIS_HANDLE)NULL) { NdisCompleteUnbindAdapter( UnbindContext, NDIS_STATUS_SUCCESS ); } else { // // We initiated the unbind from our Unload handler, // which would have been waiting for us to complete. // Wake up that thread now. // AA_SIGNAL_BLOCK_STRUCT(&(pAtmArpGlobalInfo->Block), NDIS_STATUS_SUCCESS); } } VOID AtmArpSendCompleteHandler( IN NDIS_HANDLE ProtocolBindingContext, IN PNDIS_PACKET pNdisPacket, IN NDIS_STATUS Status ) /*++ Routine Description: This is the Connection-less Send Complete handler, which signals completion of such a Send. Since we don't ever use this feature, we don't expect this routine to be called. Arguments: Return Value: None --*/ { AADEBUGP(AAD_ERROR, ("SendCompleteHandler unexpected\n")); AA_ASSERT(FALSE); } VOID AtmArpTransferDataCompleteHandler( IN NDIS_HANDLE ProtocolBindingContext, IN PNDIS_PACKET pNdisPacket, IN NDIS_STATUS Status, IN UINT BytesTransferred ) /*++ Routine Description: This is the Connection-less Transfer Data Complete handler, which signals completion of a call to NdisTransferData. Since we never call NdisTransferData, this routine should never get called. Arguments: Return Value: None --*/ { AADEBUGP(AAD_ERROR, ("TransferDataComplete Handler unexpected!\n")); AA_ASSERT(FALSE); } VOID AtmArpResetCompleteHandler( IN NDIS_HANDLE ProtocolBindingContext, IN NDIS_STATUS Status ) /*++ Routine Description: This routine is called when the miniport indicates that a Reset operation has just completed. We ignore this event. Arguments: ProtocolBindingContext - Our context for this adapter binding, which is a pointer to an ATMARP Adapter structure. Status - Status of the reset operation. Return Value: None --*/ { PATMARP_ADAPTER pAdapter; pAdapter = (PATMARP_ADAPTER)ProtocolBindingContext; AA_STRUCT_ASSERT(pAdapter, aaa); AADEBUGP(AAD_INFO, ("Reset Complete on Adapter 0x%x\n", pAdapter)); } VOID AtmArpRequestCompleteHandler( IN NDIS_HANDLE ProtocolBindingContext, IN PNDIS_REQUEST pNdisRequest, IN NDIS_STATUS Status ) /*++ Routine Description: This is called by NDIS when a previous call we made to NdisRequest() has completed. We would be blocked on our adapter structure, waiting for this to happen -- wake up the blocked thread. Arguments: ProtocolBindingContext - Pointer to our Adapter structure pNdisRequest - The request that completed Status - Status of the request. Return Value: None --*/ { PATMARP_ADAPTER pAdapter; pAdapter = (PATMARP_ADAPTER)ProtocolBindingContext; AA_STRUCT_ASSERT(pAdapter, aaa); AA_SIGNAL_BLOCK_STRUCT(&(pAdapter->Block), Status); return; } NDIS_STATUS AtmArpReceiveHandler( IN NDIS_HANDLE ProtocolBindingContext, IN NDIS_HANDLE MacReceiveContext, IN PVOID pHeaderBuffer, IN UINT HeaderBufferSize, IN PVOID pLookAheadBuffer, IN UINT LookaheadBufferSize, IN UINT PacketSize ) /*++ Routine Description: This is our Connection-less receive handler. Since we only use Connection oriented services, this routine should never get called. Arguments: Return Value: None --*/ { AADEBUGP(AAD_ERROR, ("Connectionless ReceiveHandler unexpected\n")); AA_ASSERT(FALSE); return(NDIS_STATUS_NOT_RECOGNIZED); } VOID AtmArpReceiveCompleteHandler( IN NDIS_HANDLE ProtocolBindingContext ) /*++ Routine Description: This is called by NDIS when the miniport is done with receiving a bunch of packets, meaning that it is now time to start processing them. We simply pass this on to IP (on all IF's configured on this adapter). Arguments: ProtocolBindingContext - Our context for this adapter binding, which is a pointer to an ATMARP Adapter structure. Return Value: None --*/ { PATMARP_ADAPTER pAdapter; PATMARP_INTERFACE pInterface; pAdapter = (PATMARP_ADAPTER)ProtocolBindingContext; AA_STRUCT_ASSERT(pAdapter, aaa); for (pInterface = pAdapter->pInterfaceList; pInterface != NULL_PATMARP_INTERFACE; pInterface = pInterface->pNextInterface) { (*(pInterface->IPRcvCmpltHandler))(); } } INT AtmArpReceivePacketHandler( IN NDIS_HANDLE ProtocolBindingContext, IN PNDIS_PACKET pNdisPacket ) /*++ Routine Description: This is the Connectionless receive handler, which should never be called, since we only use Connection Oriented miniport services. Arguments: Return Value: Reference count on the received packet. We always return 0. --*/ { AADEBUGP(AAD_ERROR, ("ReceivePacket Handler unexpected!\n")); AA_ASSERT(FALSE); return(0); } VOID AtmArpStatusHandler( IN NDIS_HANDLE ProtocolBindingContext, IN NDIS_STATUS GeneralStatus, IN PVOID pStatusBuffer, IN UINT StatusBufferSize ) /*++ Routine Description: This routine is called when the miniport indicates an adapter-wide status change. We ignore this. Arguments: Return Value: None --*/ { AADEBUGP(AAD_INFO, ("Status Handler: Bind Ctx 0x%x, Status 0x%x\n", ProtocolBindingContext, GeneralStatus)); } VOID AtmArpStatusCompleteHandler( IN NDIS_HANDLE ProtocolBindingContext ) /*++ Routine Description: This routine is called when the miniport wants to tell us about completion of a status change (?). Ignore this. Arguments: Return Value: None --*/ { AADEBUGP(AAD_INFO, ("Status Complete Handler: Bind Ctx 0x%x\n", ProtocolBindingContext)); } VOID AtmArpCoSendCompleteHandler( IN NDIS_STATUS Status, IN NDIS_HANDLE ProtocolVcContext, IN PNDIS_PACKET pNdisPacket ) /*++ Routine Description: This routine is called by NDIS when the ATM miniport is finished with a packet we had previously sent via NdisCoSendPackets. We first check if this packet was generated by us (e.g. ATMARP protocol packet): if so, we free this here. Otherwise (packet sent by the IP layer), we first remove any header buffer that we had attached to the packet and free it, before calling IP's entry point for Transmit Complete. Arguments: Status - Status of the NdisCoSendPackets. ProtocolVcContext - Our context for the VC on which the packet was sent (i.e. pointer to ATMARP VC). pNdisPacket - The packet whose "send" is being completed. Return Value: None --*/ { PATMARP_VC pVc; PATMARP_INTERFACE pInterface; PacketContext *PC; // IP/ARP Info about this packet PNDIS_BUFFER pNdisBuffer; // First Buffer in this packet UINT TotalLength; AA_HEADER_TYPE HdrType; ATMARP_VC_ENCAPSULATION_TYPE Encapsulation; ULONG rc; pVc = (PATMARP_VC)ProtocolVcContext; AA_STRUCT_ASSERT(pVc, avc); #ifdef VC_REFS_ON_SENDS AA_ACQUIRE_VC_LOCK(pVc); pInterface = pVc->pInterface; Encapsulation = pVc->FlowSpec.Encapsulation; rc = AtmArpDereferenceVc(pVc); // SendComplete if (rc != 0) { pVc->OutstandingSends--; if (AA_IS_FLAG_SET( pVc->Flags, AA_VC_CLOSE_STATE_MASK, AA_VC_CLOSE_STATE_CLOSING) && (pVc->OutstandingSends == 0)) { AtmArpCloseCall(pVc); // // VC lock is released above. // } else { AA_RELEASE_VC_LOCK(pVc); } } #else pInterface = pVc->pInterface; Encapsulation = pVc->FlowSpec.Encapsulation; #endif // VC_REFS_ON_SENDS AA_ASSERT(pNdisPacket->Private.Head != NULL); #if DBG #if DBG_CO_SEND { PULONG pContext; extern ULONG OutstandingSends; pContext = (PULONG)&(pNdisPacket->WrapperReserved[0]);; // Check for duplicate completion: AA_ASSERT(*pContext != 'BbBb'); *pContext = 'BbBb'; NdisInterlockedDecrement(&OutstandingSends); } #endif // DBG_CO_SEND #endif // DBG NdisQueryPacket( pNdisPacket, NULL, // we don't need PhysicalBufferCount NULL, // we don't need BufferCount NULL, // we don't need FirstBuffer (yet) &TotalLength ); if (Status == NDIS_STATUS_SUCCESS) { AA_IF_STAT_ADD(pInterface, OutOctets, TotalLength); } else if (Status == NDIS_STATUS_RESOURCES) { AA_IF_STAT_INCR(pInterface, OutDiscards); } else if (Status != NDIS_STATUS_SUCCESS) { AA_IF_STAT_INCR(pInterface, OutErrors); } PC = (PacketContext *)pNdisPacket->ProtocolReserved; AADEBUGP(AAD_EXTRA_LOUD, ("CoSend complete[%s]: VC 0x%x, Pkt 0x%x, Status 0x%x:\n", ((PC->pc_common.pc_owner != PACKET_OWNER_LINK)? "IP": "ARP"), pVc, pNdisPacket, Status)); // // Check who generated this packet. // if (PC->pc_common.pc_owner != PACKET_OWNER_LINK) { // // Belongs to IP. Check if we had prepended an LLC/SNAP header. // if (Encapsulation == ENCAPSULATION_TYPE_LLCSNAP) { PUCHAR pPacket; UINT Length; #ifdef BACK_FILL NdisQueryPacket(pNdisPacket, NULL, NULL, &pNdisBuffer, NULL); AA_ASSERT(pNdisBuffer != NULL); NdisQueryBuffer(pNdisBuffer, &pPacket, &Length); // // Commmon part first: find the header type, and update // statistics. // if (pPacket[5] == LLC_SNAP_OUI2) { HdrType = AA_HEADER_TYPE_UNICAST; if (Status == NDIS_STATUS_SUCCESS) { AA_IF_STAT_INCR(pInterface, OutUnicastPkts); } } else { HdrType = AA_HEADER_TYPE_NUNICAST; if (Status == NDIS_STATUS_SUCCESS) { AA_IF_STAT_INCR(pInterface, OutNonUnicastPkts); INCR_STAT(MCastSendOk); } else { INCR_STAT(MCastSendFail); } } // // Now check if we had attached a header buffer or not. // if (AtmArpDoBackFill && AA_BACK_FILL_POSSIBLE(pNdisBuffer)) { ULONG HeaderLength; // // We would have back-filled IP's buffer with the LLC/SNAP // header. Remove the back-fill. // HeaderLength = ((HdrType == AA_HEADER_TYPE_UNICAST)? sizeof(AtmArpLlcSnapHeader) : #ifdef IPMCAST sizeof(AtmArpMcType1ShortHeader)); #else 0); #endif // IPMCAST (PUCHAR)pNdisBuffer->MappedSystemVa += HeaderLength; pNdisBuffer->ByteOffset += HeaderLength; pNdisBuffer->ByteCount -= HeaderLength; } else { // // The first buffer would be our header buffer. Remove // it from the packet and return to our pool. // NdisUnchainBufferAtFront(pNdisPacket, &pNdisBuffer); AtmArpFreeHeader(pInterface, pNdisBuffer, HdrType); } #else // // Free the LLC/SNAP header buffer. // NdisUnchainBufferAtFront(pNdisPacket, &pNdisBuffer); AA_ASSERT(pNdisBuffer != NULL); NdisQueryBuffer(pNdisBuffer, &pPacket, &Length); if (pPacket[5] == LLC_SNAP_OUI2) { HdrType = AA_HEADER_TYPE_UNICAST; if (Status == NDIS_STATUS_SUCCESS) { AA_IF_STAT_INCR(pInterface, OutUnicastPkts); } } else { HdrType = AA_HEADER_TYPE_NUNICAST; if (Status == NDIS_STATUS_SUCCESS) { AA_IF_STAT_INCR(pInterface, OutNonUnicastPkts); INCR_STAT(MCastSendOk); } else { INCR_STAT(MCastSendFail); } } AtmArpFreeHeader(pInterface, pNdisBuffer, HdrType); #endif // BACK_FILL } #ifdef PERF AadLogSendComplete(pNdisPacket); #endif // PERF // // Inform IP of send completion. // (*(pInterface->IPTxCmpltHandler))( pInterface->IPContext, pNdisPacket, Status ); } else { // // Packet generated by the ATMARP module. This would be an // ATMARP protocol packet, so free the NDIS buffer now. // NdisUnchainBufferAtFront(pNdisPacket, &pNdisBuffer); AA_ASSERT(pNdisBuffer != NULL); #if DBG { ULONG ArpPktLength; PUCHAR ArpPktStart; NdisQueryBuffer(pNdisBuffer, (PVOID)&ArpPktStart, &ArpPktLength); AADEBUGPDUMP(AAD_EXTRA_LOUD+100, ArpPktStart, ArpPktLength); } #endif // DBG AtmArpFreeProtoBuffer(pInterface, pNdisBuffer); AtmArpFreePacket(pInterface, pNdisPacket); } return; } VOID AtmArpCoStatusHandler( IN NDIS_HANDLE ProtocolBindingContext, IN NDIS_HANDLE ProtocolVcContext OPTIONAL, IN NDIS_STATUS GeneralStatus, IN PVOID pStatusBuffer, IN UINT StatusBufferSize ) /*++ Routine Description: This routine is called when the miniport indicates a status change, possibly on a VC. Ignore this. Arguments: Return Value: None --*/ { AADEBUGP(AAD_INFO, ("CoStatus Handler: Bind Ctx 0x%x, VC Ctx 0x%x, Status 0x%x\n", ProtocolBindingContext, ProtocolVcContext, GeneralStatus)); } /*++ AtmArpCoReceivePacketHandler -- is in arppkt.c --*/ #ifdef _PNP_POWER_ NDIS_STATUS AtmArpPnPReconfigHandler( IN PATMARP_ADAPTER pAdapter OPTIONAL, IN PNET_PNP_EVENT pNetPnPEvent ) /*++ Routine Description: Handle a reconfig message on the specified adapter. If no adapter is specified, it is a global parameter that has changed. Arguments: pAdapter - Pointer to our adapter structure pNetPnPEvent - Pointer to reconfig event Return Value: NDIS_STATUS_SUCCESS always, for now. --*/ { ATMARPC_PNP_RECONFIG_REQUEST UNALIGNED * pArpReconfigReq; PIP_PNP_RECONFIG_REQUEST pIpReconfigReq; NDIS_STATUS Status; pIpReconfigReq = (PIP_PNP_RECONFIG_REQUEST)pNetPnPEvent->Buffer; AA_ASSERT(pIpReconfigReq->arpConfigOffset != 0); pArpReconfigReq = (ATMARPC_PNP_RECONFIG_REQUEST UNALIGNED *) ((PUCHAR)pIpReconfigReq + pIpReconfigReq->arpConfigOffset); AADEBUGP(AAD_WARNING, ("AtmArpPnPReconfig: pIpReconfig 0x%x, arpConfigOffset 0x%x\n", pIpReconfigReq, pIpReconfigReq->arpConfigOffset)); do { PATMARP_INTERFACE pInterface; PATMARP_INTERFACE pNextInterface; NDIS_STRING IPReconfigString; // // Locate the IP interface string passed in... // ULONG uOffset = pArpReconfigReq->IfKeyOffset; if (uOffset == 0) { Status = NDIS_STATUS_FAILURE; break; } else { // // ((PUCHAR)pArpReconfigReq + uOffset) points to a // "counted unicode string", which means that it's an array // of words, with the 1st word being the length in characters of // the string (there is no terminating null) and the following // words being the string itself. // We need to create an NDIS_STRING based on this buffer in order // to compare it with each interface's config string. // PWCH pwc = (PWCH) ((PUCHAR)pArpReconfigReq + uOffset); IPReconfigString.Length = sizeof(WCHAR)*pwc[0]; IPReconfigString.MaximumLength = IPReconfigString.Length; IPReconfigString.Buffer = pwc+1; } // // Do we have a binding context? // if (pAdapter == NULL_PATMARP_ADAPTER) { Status = NDIS_STATUS_FAILURE; break; } // // We wrap the search in a try-except clause because the passed-in // structure could be bogus. Note that we will only test at most // as many characters of the passed-in string as the lengths of // our internal set of interface config strings. // try { // // Find the interface associated with this request. // AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo); for (pInterface = pAdapter->pInterfaceList; pInterface != NULL_PATMARP_INTERFACE; pInterface = pNextInterface) { BOOLEAN IsEqual = FALSE; pNextInterface = pInterface->pNextInterface; AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo); // // Compare the IPReconfigString // JJ TODO: NdisEqualUnicodeString must be called in PASSIVE level // we know that the reconfig call is done at passive level, // but how to assert that fact here? // AA_ASSERT(EntryIrq == PASSIVE_LEVEL); // IsEqual = NdisEqualUnicodeString( &IPReconfigString, &(pInterface->IPConfigString), TRUE // case insensitive ); AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo); if (IsEqual) { break; // found it! } } AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo); } except (EXCEPTION_EXECUTE_HANDLER) { Status = NDIS_STATUS_FAILURE; break; } // // JJ We should find the interface if this adapter has any interfaces // at all -- else it means that we're being sent bogus reconfig // information. // AA_ASSERT(pInterface!= NULL || pAdapter->pInterfaceList==NULL); if (pInterface != NULL_PATMARP_INTERFACE) { AA_ACQUIRE_IF_LOCK(pInterface); // // Set it's state to indicate that a reconfig is pending. // and save away pNetPnPEvent for completion later. // if ( pInterface->ReconfigState != RECONFIG_NOT_IN_PROGRESS || pInterface->pReconfigEvent != NULL) { AA_RELEASE_IF_LOCK(pInterface); // // We should not get here because this means that // we were asked to reconfigure when there was a // pending reconfiguration, which is not supposed to happen. // Status = NDIS_STATUS_FAILURE; AA_ASSERT(FALSE); } else { pInterface->ReconfigState = RECONFIG_SHUTDOWN_PENDING; pInterface->pReconfigEvent = pNetPnPEvent; pInterface->AdminState = IF_STATUS_DOWN; AtmArpReferenceInterface(pInterface); // Reconfig AA_RELEASE_IF_LOCK(pInterface); // // Initiate shutdown in preparation of a restart. // AtmArpShutdown is responsible for // completing the ndis reconfig request asynchronously. // AtmArpShutdownInterface(pInterface); Status = NDIS_STATUS_PENDING; } } else { // // We didn't find the interface, fail the request... // Status = NDIS_STATUS_FAILURE; } } while (FALSE); return (Status); } NDIS_STATUS AtmArpPnPEventHandler( IN NDIS_HANDLE ProtocolBindingContext, IN PNET_PNP_EVENT pNetPnPEvent ) /*++ Routine Description: This is the NDIS entry point called when NDIS wants to inform us about a PNP/PM event happening on an adapter. If the event is for us, we consume it. Otherwise, we pass this event along to IP along the first Interface on this adapter. When IP is done with it, it will call our IfPnPEventComplete routine. Arguments: ProtocolBindingContext - Our context for this adapter binding, which is a pointer to an ATMARP Adapter structure. pNetPnPEvent - Pointer to the event. Return Value: None --*/ { PATMARP_ADAPTER pAdapter; PATMARP_INTERFACE pInterface; NDIS_STATUS Status; PIP_PNP_RECONFIG_REQUEST pIpReconfigReq; ULONG Length; pAdapter = (PATMARP_ADAPTER)ProtocolBindingContext; #ifdef NT do { pIpReconfigReq = (PIP_PNP_RECONFIG_REQUEST)pNetPnPEvent->Buffer; Length = pNetPnPEvent->BufferLength; // // Is this directed to us? // if (pNetPnPEvent->NetEvent == NetEventReconfigure) { if (Length < sizeof(IP_PNP_RECONFIG_REQUEST)) { Status = NDIS_STATUS_RESOURCES; break; } if (pIpReconfigReq->arpConfigOffset != 0) { Status = AtmArpPnPReconfigHandler(pAdapter, pNetPnPEvent); break; } } // // This belongs to IP. Do we have a binding context? // if (pAdapter == NULL_PATMARP_ADAPTER) { Status = NDIS_STATUS_FAILURE; break; } AA_STRUCT_ASSERT(pAdapter, aaa); pInterface = pAdapter->pInterfaceList; if ((pInterface != NULL_PATMARP_INTERFACE) && (pInterface->IPContext != NULL)) { AA_ASSERT(pInterface->IPPnPEventHandler != NULL); Status = (*pInterface->IPPnPEventHandler)( pInterface->IPContext, pNetPnPEvent ); } else { Status = NDIS_STATUS_SUCCESS; } break; } while (FALSE); #else Status = NDIS_STATUS_SUCCESS; #endif // NT AADEBUGP(AAD_INFO, ("PnPEventHandler: pIF 0x%x, pEvent 0x%x, Evt 0x%x, Status 0x%x\n", pInterface, pNetPnPEvent, pNetPnPEvent->NetEvent, Status)); return (Status); } #endif // _PNP_POWER_ NDIS_STATUS AtmArpSendAdapterNdisRequest( IN PATMARP_ADAPTER pAdapter, IN PNDIS_REQUEST pNdisRequest, IN NDIS_REQUEST_TYPE RequestType, IN NDIS_OID Oid, IN PVOID pBuffer, IN ULONG BufferLength ) /*++ Routine Description: Send an NDIS Request to query an adapter for information. If the request pends, block on the ATMARP Adapter structure till it completes. Arguments: pAdapter - Points to ATMARP Adapter structure pNdisRequest - Pointer to NDIS request structure RequestType - Set/Query information Oid - OID to be passed in the request pBuffer - place for value(s) BufferLength - length of above Return Value: The NDIS status of the request. --*/ { NDIS_STATUS Status; // // Fill in the NDIS Request structure // pNdisRequest->RequestType = RequestType; if (RequestType == NdisRequestQueryInformation) { pNdisRequest->DATA.QUERY_INFORMATION.Oid = Oid; pNdisRequest->DATA.QUERY_INFORMATION.InformationBuffer = pBuffer; pNdisRequest->DATA.QUERY_INFORMATION.InformationBufferLength = BufferLength; pNdisRequest->DATA.QUERY_INFORMATION.BytesWritten = 0; pNdisRequest->DATA.QUERY_INFORMATION.BytesNeeded = BufferLength; } else { pNdisRequest->DATA.SET_INFORMATION.Oid = Oid; pNdisRequest->DATA.SET_INFORMATION.InformationBuffer = pBuffer; pNdisRequest->DATA.SET_INFORMATION.InformationBufferLength = BufferLength; pNdisRequest->DATA.SET_INFORMATION.BytesRead = 0; pNdisRequest->DATA.SET_INFORMATION.BytesNeeded = 0; } AA_INIT_BLOCK_STRUCT(&(pAdapter->Block)); NdisRequest( &Status, pAdapter->NdisAdapterHandle, pNdisRequest ); if (Status == NDIS_STATUS_PENDING) { Status = AA_WAIT_ON_BLOCK_STRUCT(&(pAdapter->Block)); } return (Status); } NDIS_STATUS AtmArpGetAdapterInfo( IN PATMARP_ADAPTER pAdapter ) /*++ Routine Description: Query an adapter for hardware-specific information that we need: - burnt in hardware address (ESI part) - Max packet size - line rate Arguments: pAdapter - Pointer to ATMARP adapter structure Return Value: NDIS_STATUS_SUCCESS on success. Failure code on some non-ignorable failure (such as device doesn't support MTU >= 8196). --*/ { NDIS_STATUS Status; NDIS_REQUEST NdisRequest; ULONG Value; // // Initialize. // AA_SET_MEM(pAdapter->MacAddress, 0, AA_ATM_ESI_LEN); do { // // Description string: we first query this with a 0 length buffer // length, so that we get the actual # of bytes needed. Then we // allocate a buffer for the descriptor string, and use that to // get the actual string. // Status = AtmArpSendAdapterNdisRequest( pAdapter, &NdisRequest, NdisRequestQueryInformation, OID_GEN_CO_VENDOR_DESCRIPTION, (PVOID)(pAdapter->pDescrString), 0 ); if ((Status == NDIS_STATUS_INVALID_LENGTH) || (Status == NDIS_STATUS_BUFFER_TOO_SHORT)) { // // Now allocate a buffer of the right length. // pAdapter->DescrLength = NdisRequest.DATA.QUERY_INFORMATION.BytesNeeded; AA_ALLOC_MEM(pAdapter->pDescrString, UCHAR, pAdapter->DescrLength); if (pAdapter->pDescrString != (PUCHAR)NULL) { Status = AtmArpSendAdapterNdisRequest( pAdapter, &NdisRequest, NdisRequestQueryInformation, OID_GEN_CO_VENDOR_DESCRIPTION, (PVOID)(pAdapter->pDescrString), pAdapter->DescrLength ); } else { pAdapter->DescrLength = 0; } AADEBUGP(AAD_LOUD, ("GetAdapterInfo: Query VENDOR Descr2 ret 0x%x, DescrLen %d\n", Status, pAdapter->DescrLength)); } else { AADEBUGP(AAD_LOUD, ("GetAdapterInfo: Query VENDOR Descr1 ret 0x%x\n", Status)); } // // MAC Address: // Status = AtmArpSendAdapterNdisRequest( pAdapter, &NdisRequest, NdisRequestQueryInformation, OID_ATM_HW_CURRENT_ADDRESS, (PVOID)(pAdapter->MacAddress), AA_ATM_ESI_LEN ); // // Max Frame Size: // Status = AtmArpSendAdapterNdisRequest( pAdapter, &NdisRequest, NdisRequestQueryInformation, OID_ATM_MAX_AAL5_PACKET_SIZE, (PVOID)(&(pAdapter->MaxPacketSize)), sizeof(ULONG) ); if (Status != NDIS_STATUS_SUCCESS) { // // Use the default. // pAdapter->MaxPacketSize = AA_DEF_ATM_MAX_PACKET_SIZE; } if (pAdapter->MaxPacketSize > AA_MAX_ATM_MAX_PACKET_SIZE) { pAdapter->MaxPacketSize = AA_MAX_ATM_MAX_PACKET_SIZE; } // // Check that the adapter support the minimum. // if (pAdapter->MaxPacketSize < AA_MIN_ATM_MAX_PACKET_SIZE) { AADEBUGP(AAD_FATAL, ("GetAdapterInfo: (FATAL) MaxPacketSize of (%lu) is too small.\n", pAdapter->MaxPacketSize)); Status = NDIS_STATUS_RESOURCES; break; } // // Link speed: // Status = AtmArpSendAdapterNdisRequest( pAdapter, &NdisRequest, NdisRequestQueryInformation, OID_GEN_CO_LINK_SPEED, (PVOID)(&(pAdapter->LineRate)), sizeof(pAdapter->LineRate) ); if ((Status != NDIS_STATUS_SUCCESS) || (pAdapter->LineRate.Inbound == 0) || (pAdapter->LineRate.Outbound == 0)) { // // Use the default. // pAdapter->LineRate.Outbound = pAdapter->LineRate.Inbound = AA_DEF_ATM_LINE_RATE; AADEBUGP(AAD_LOUD, ("Using default line rate %d bytes/sec\n", AA_DEF_ATM_LINE_RATE)); } else { // // Convert from 100 bits/sec to bytes/sec // pAdapter->LineRate.Outbound = (pAdapter->LineRate.Outbound * 100)/8; pAdapter->LineRate.Inbound = (pAdapter->LineRate.Inbound * 100)/8; AADEBUGP(AAD_LOUD, ("Got line rates from miniport: In %d, Out %d bytes/sec\n", pAdapter->LineRate.Outbound, pAdapter->LineRate.Inbound)); } Status = NDIS_STATUS_SUCCESS; } while(FALSE); return Status; } NDIS_STATUS AtmArpSendNdisRequest( IN PATMARP_ADAPTER pAdapter, IN PNDIS_REQUEST pNdisRequest, IN NDIS_REQUEST_TYPE RequestType, IN NDIS_OID Oid, IN PVOID pBuffer, IN ULONG BufferLength ) /*++ Routine Description: Send an NDIS (non-Connection Oriented) request to the Miniport. We allocate an NDIS_REQUEST structure, link the supplied buffer to it, and send the request. If the request does not pend, we call our completion routine from here. Arguments: pAdapter - Pointer to our Adapter structure representing the adapter to which the request is to be sent pNdisRequest - Pointer to NDIS request structure RequestType - Set/Query information Oid - OID to be passed in the request pBuffer - place for value(s) BufferLength - length of above Return Value: Status of the NdisRequest. --*/ { NDIS_STATUS Status; // // Fill in the NDIS Request structure // pNdisRequest->RequestType = RequestType; if (RequestType == NdisRequestQueryInformation) { pNdisRequest->DATA.QUERY_INFORMATION.Oid = Oid; pNdisRequest->DATA.QUERY_INFORMATION.InformationBuffer = pBuffer; pNdisRequest->DATA.QUERY_INFORMATION.InformationBufferLength = BufferLength; pNdisRequest->DATA.QUERY_INFORMATION.BytesWritten = 0; pNdisRequest->DATA.QUERY_INFORMATION.BytesNeeded = BufferLength; } else { pNdisRequest->DATA.SET_INFORMATION.Oid = Oid; pNdisRequest->DATA.SET_INFORMATION.InformationBuffer = pBuffer; pNdisRequest->DATA.SET_INFORMATION.InformationBufferLength = BufferLength; pNdisRequest->DATA.SET_INFORMATION.BytesRead = 0; pNdisRequest->DATA.SET_INFORMATION.BytesNeeded = 0; } NdisRequest( &Status, pAdapter->NdisAdapterHandle, pNdisRequest); return (Status); } VOID AtmArpShutdownInterface( IN PATMARP_INTERFACE pInterface ) /*++ Routine Description: Bring down the specified ARP interface. We tear down the ARP table, and shut down the Call Manager interface. When this is complete, we will call IP's DelInterface entry point. Arguments: pInterface - Points to the Interface to be shut down. Return Value: None --*/ { IP_STATUS Status; INT i; ULONG rc; PATMARP_IP_ENTRY pIpEntry; PATMARP_ATM_ENTRY pAtmEntry; PATMARP_ATM_ENTRY pNextAtmEntry; PATMARP_VC pVc; PATMARP_VC pNextVc; PATMARP_ADAPTER pAdapter; BOOLEAN WasRunning; #if DBG AA_IRQL EntryIrq, ExitIrq; #endif AA_GET_ENTRY_IRQL(EntryIrq); AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo); pAdapter = pInterface->pAdapter; // // Wait for any AF register processing to finish. // while (pAdapter->Flags & AA_ADAPTER_FLAGS_PROCESSING_AF) { AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo); AADEBUGP(AAD_FATAL, ("ShutdownIf: IF %p, pAdapter %x, Afregister going on!!!\n", pInterface, pAdapter)); Status = AA_WAIT_ON_BLOCK_STRUCT(&(pAdapter->UnbindBlock)); AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo); } AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo); // // Stop any timer running on this interface // AA_ACQUIRE_IF_LOCK(pInterface); if (AtmArpStopTimer(&(pInterface->Timer), pInterface)) { rc = AtmArpDereferenceInterface(pInterface); // Timer ref AA_ASSERT(rc != 0); } #ifdef IPMCAST // // Stop any Multicast timer running on this interface // if (AtmArpStopTimer(&(pInterface->McTimer), pInterface)) { rc = AtmArpDereferenceInterface(pInterface); // Timer ref AA_ASSERT(rc != 0); } #endif AA_RELEASE_IF_LOCK(pInterface); // // Deregister all SAPs so that we don't get any more // incoming calls. // AtmArpDeregisterSaps(pInterface); AA_CHECK_EXIT_IRQL(EntryIrq, ExitIrq); // // We set the ARP Table state to "down" -- this will ensure that it // will not grow while we are shutting down. // AA_ACQUIRE_IF_TABLE_LOCK(pInterface); pInterface->ArpTableUp = FALSE; // // Go through the ARP Table and abort all IP entries // for (i = 0; i < ATMARP_TABLE_SIZE; i++) { while (pInterface->pArpTable[i] != NULL_PATMARP_IP_ENTRY) { pIpEntry = pInterface->pArpTable[i]; AA_ACQUIRE_IE_LOCK_DPC(pIpEntry); AA_REF_IE(pIpEntry, IE_REFTYPE_TMP); // Shutdown Interface AA_RELEASE_IE_LOCK_DPC(pIpEntry); AA_RELEASE_IF_TABLE_LOCK(pInterface); AA_ACQUIRE_IE_LOCK(pIpEntry); if (AA_DEREF_IE(pIpEntry, IE_REFTYPE_TMP)) // Shutdown Interface { AtmArpAbortIPEntry(pIpEntry); // // IE Lock is released within the above. // } AA_ACQUIRE_IF_TABLE_LOCK(pInterface); } } AA_RELEASE_IF_TABLE_LOCK(pInterface); AA_CHECK_EXIT_IRQL(EntryIrq, ExitIrq); #ifdef IPMCAST // // Delete all Join Entries // AA_ACQUIRE_IF_LOCK(pInterface); { PATMARP_IPMC_JOIN_ENTRY pJoinEntry; PATMARP_IPMC_JOIN_ENTRY pNextJoinEntry; for (pJoinEntry = pInterface->pJoinList; pJoinEntry != NULL_PATMARP_IPMC_JOIN_ENTRY; pJoinEntry = pNextJoinEntry) { WasRunning = AtmArpStopTimer(&(pJoinEntry->Timer), pInterface); pNextJoinEntry = pJoinEntry->pNextJoinEntry; if (WasRunning) { rc = AA_DEREF_JE(pJoinEntry); // ShutdownIF: timer stopped } else { rc = pJoinEntry->RefCount; } if (rc != 0) { (VOID)AA_DEREF_JE(pJoinEntry); // ShutdownIF: kill Join Entry } } pInterface->pJoinList = NULL_PATMARP_IPMC_JOIN_ENTRY; } AA_RELEASE_IF_LOCK(pInterface); #endif // // We set the AtmEntry list state to "down" (this will ensure that it // will not grow while we are shutting down), then // go through the list of ATM Entries on this interface, and // abort all of them. // AA_ACQUIRE_IF_ATM_LIST_LOCK(pInterface); pInterface->AtmEntryListUp = FALSE; pNextAtmEntry = pInterface->pAtmEntryList; if (pNextAtmEntry != NULL_PATMARP_ATM_ENTRY) { AA_ACQUIRE_AE_LOCK_DPC(pNextAtmEntry); AA_REF_AE(pNextAtmEntry, AE_REFTYPE_TMP); // ShutdownInterface AA_RELEASE_AE_LOCK_DPC(pNextAtmEntry); } while (pNextAtmEntry != NULL_PATMARP_ATM_ENTRY) { pAtmEntry = pNextAtmEntry; pNextAtmEntry = pAtmEntry->pNext; // // Note that we still have the lock to pInterface when // we aquire the lock to pAtmEntry below. This order of aquiring // locks must be strictly followed everywhere in order to prevent // a deadlock. // // We can't release the LIST_LOCK without first addrefing pAtmEntry, // otherwise while both locks are free someone else can delref and // possibly deallocate pAtmEntry. // if (pNextAtmEntry != NULL_PATMARP_ATM_ENTRY) { AA_ACQUIRE_AE_LOCK_DPC(pNextAtmEntry); AA_REF_AE(pNextAtmEntry, AE_REFTYPE_TMP); // ShutdownInterface AA_RELEASE_AE_LOCK_DPC(pNextAtmEntry); } AA_RELEASE_IF_ATM_LIST_LOCK(pInterface); AA_CHECK_EXIT_IRQL(EntryIrq, ExitIrq); AA_ACQUIRE_AE_LOCK(pAtmEntry); if (AA_DEREF_AE(pAtmEntry, AE_REFTYPE_TMP) != 0) // ShutdownInterface { AtmArpInvalidateAtmEntry( pAtmEntry, TRUE // we ARE shutting down ); // // The ATM Entry lock is released within the above. // } AA_CHECK_EXIT_IRQL(EntryIrq, ExitIrq); AA_ACQUIRE_IF_ATM_LIST_LOCK(pInterface); } AA_RELEASE_IF_ATM_LIST_LOCK(pInterface); AA_CHECK_EXIT_IRQL(EntryIrq, ExitIrq); // // Go through the list of unresolved VCs on this interface, // and close all of them. // AA_ACQUIRE_IF_LOCK(pInterface); pVc = pInterface->pUnresolvedVcs; pInterface->pUnresolvedVcs = NULL_PATMARP_VC; while (pVc != NULL_PATMARP_VC) { pNextVc = pVc->pNextVc; AA_RELEASE_IF_LOCK(pInterface); AA_ACQUIRE_VC_LOCK(pVc); if (AtmArpDereferenceVc(pVc) != 0) // Unresolved VC list entry { AtmArpCloseCall(pVc); // // the VC lock is released within the above. // } pVc = pNextVc; AA_ACQUIRE_IF_LOCK(pInterface); } AA_RELEASE_IF_LOCK(pInterface); AA_CHECK_EXIT_IRQL(EntryIrq, ExitIrq); // // Close the Call Manager interface. // AtmArpCloseCallMgr(pInterface); } BOOLEAN AtmArpIsDeviceAlreadyBound( IN PNDIS_STRING pDeviceName ) /*++ Routine Description: Check if we have already bound to a device (adapter). Arguments: pDeviceName - Points to device name to be checked. Return Value: TRUE iff we already have an Adapter structure representing this device. --*/ { PATMARP_ADAPTER pAdapter; BOOLEAN bFound = FALSE; AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo); for (pAdapter = pAtmArpGlobalInfo->pAdapterList; pAdapter != NULL_PATMARP_ADAPTER; pAdapter = pAdapter->pNextAdapter) { if ((pDeviceName->Length == pAdapter->DeviceName.Length) && (AA_MEM_CMP(pDeviceName->Buffer, pAdapter->DeviceName.Buffer, pDeviceName->Length) == 0)) { bFound = TRUE; break; } } AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo); return (bFound); } #if ATMOFFLOAD NDIS_STATUS AtmArpQueryAndEnableOffload( IN PATMARP_ADAPTER pAdapter ) /*++ Routine Description: Query the capabilities of the adapter and set all recognized offload capabilities. Set pMaxOffLoadSize and pMinSegmentCount to the corresponding values, and also set pInterface->OffloadFlags to the set of enabled tasks. Arguments: pAdapter - The adapter on which to enable offloading. Return Value: TRUE iff the operation was either succesful or no tasks were enabled. False if there was a fatal error. --*/ { NDIS_STATUS Status = STATUS_BUFFER_OVERFLOW; PNDIS_TASK_OFFLOAD_HEADER pHeader = NULL; AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo); pAdapter->Offload.Flags = 0; pAdapter->Offload.MaxOffLoadSize = 0; pAdapter->Offload.MinSegmentCount = 0; AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo); do { PNDIS_TASK_OFFLOAD pTask; ULONG Flags = 0; UINT MaxOffLoadSize = 0; UINT MinSegmentCount = 0; NDIS_TASK_IPSEC ipsecCaps; UINT BufferSize = 0; NDIS_REQUEST NdisRequest; // // Query capabilities // { NDIS_TASK_OFFLOAD_HEADER Header; AA_SET_MEM(&Header, 0, sizeof(Header)); Header.EncapsulationFormat.Flags.FixedHeaderSize = 1; Header.EncapsulationFormat.EncapsulationHeaderSize = AA_PKT_LLC_SNAP_HEADER_LENGTH; Header.EncapsulationFormat.Encapsulation = LLC_SNAP_ROUTED_Encapsulation; Header.Version = NDIS_TASK_OFFLOAD_VERSION; Header.Size = sizeof(Header); AADEBUGP(AAD_INFO, ("Querying for Task offload\n")); Status = AtmArpSendAdapterNdisRequest( pAdapter, &NdisRequest, NdisRequestQueryInformation, OID_TCP_TASK_OFFLOAD, &Header, sizeof(Header) ); if ((Status == NDIS_STATUS_INVALID_LENGTH) || (Status == NDIS_STATUS_BUFFER_TOO_SHORT)) { // // Alloc the proper-sized buffer and query a 2nd time... // BufferSize = NdisRequest.DATA.QUERY_INFORMATION.BytesNeeded; AA_ALLOC_MEM(pHeader, NDIS_TASK_OFFLOAD_HEADER, BufferSize); if (pHeader != NULL) { *pHeader = Header; // struct copy. Status = AtmArpSendAdapterNdisRequest( pAdapter, &NdisRequest, NdisRequestQueryInformation, OID_TCP_TASK_OFFLOAD, pHeader, BufferSize ); } } } if (Status != NDIS_STATUS_SUCCESS) { AADEBUGP(AAD_INFO, ("Query Offload failed. Status=%x\n", Status)); break; } if ( pHeader == NULL || pHeader->OffsetFirstTask == 0) { AADEBUGP(AAD_INFO, ("No tasks to offload\n")); break; } AA_ASSERT(pHeader->OffsetFirstTask == sizeof(NDIS_TASK_OFFLOAD_HEADER)); AADEBUGP(AAD_WARNING, ("Something to Offload. Offload buffer size %x\n", BufferSize)); // // Parse the buffer for Checksum and tcplargesend offload capabilities // for ( pTask = (NDIS_TASK_OFFLOAD *) ((UCHAR *)pHeader + pHeader->OffsetFirstTask); 1; // we break when done pTask = (PNDIS_TASK_OFFLOAD) ((PUCHAR)pTask + pTask->OffsetNextTask)) { if (pTask->Task == TcpIpChecksumNdisTask) { // //this adapter supports checksum offload //check if tcp and/or ip chksums bits are present // PNDIS_TASK_TCP_IP_CHECKSUM ChecksumInfo = (PNDIS_TASK_TCP_IP_CHECKSUM) pTask->TaskBuffer; // if (ChecksumInfo->V4Transmit.V4Checksum) (commented out in arpc.c) { AADEBUGP(AAD_INFO, ("V4 Checksum offload\n")); if (ChecksumInfo->V4Transmit.TcpChecksum) { Flags |= TCP_XMT_CHECKSUM_OFFLOAD; AADEBUGP(AAD_INFO, (" Tcp Checksum offload\n")); } if (ChecksumInfo->V4Transmit.IpChecksum) { Flags |= IP_XMT_CHECKSUM_OFFLOAD; AADEBUGP(AAD_INFO, (" IP xmt Checksum offload\n")); } if (ChecksumInfo->V4Receive.TcpChecksum) { Flags |= TCP_RCV_CHECKSUM_OFFLOAD; AADEBUGP(AAD_INFO, (" Tcp Rcv Checksum offload\n")); } if (ChecksumInfo->V4Receive.IpChecksum) { Flags |= IP_RCV_CHECKSUM_OFFLOAD; AADEBUGP(AAD_INFO, (" IP rcv Checksum offload\n")); } } } else if (pTask->Task == TcpLargeSendNdisTask) { PNDIS_TASK_TCP_LARGE_SEND TcpLargeSend, in_LargeSend = (PNDIS_TASK_TCP_LARGE_SEND)pTask->TaskBuffer; Flags |= TCP_LARGE_SEND_OFFLOAD; MaxOffLoadSize = in_LargeSend->MaxOffLoadSize; MinSegmentCount = in_LargeSend->MinSegmentCount; AADEBUGP(AAD_INFO, (" Tcp large send!! \n")); } else if (pTask->Task == IpSecNdisTask) { PNDIS_TASK_IPSEC pIPSecCaps = (PNDIS_TASK_IPSEC) pTask->TaskBuffer; // // Save off the capabilities for setting them later. // ipsecCaps = *pIPSecCaps; // // CryptoOnly is assumed if we have IpSecNdisTask // Flags |= IPSEC_OFFLOAD_CRYPTO_ONLY; // // Do Support first // if (pIPSecCaps->Supported.AH_ESP_COMBINED) { Flags |= IPSEC_OFFLOAD_AH_ESP; AADEBUGP(AAD_INFO, ("AH_ESP\n")); } if (pIPSecCaps->Supported.TRANSPORT_TUNNEL_COMBINED) { Flags |= IPSEC_OFFLOAD_TPT_TUNNEL; AADEBUGP(AAD_INFO, ("TPT_TUNNEL\n")); } if (pIPSecCaps->Supported.V4_OPTIONS) { Flags |= IPSEC_OFFLOAD_V4_OPTIONS; AADEBUGP(AAD_INFO, ("V4_OPTIONS\n")); } if (pIPSecCaps->Supported.RESERVED) { pIPSecCaps->Supported.RESERVED = 0; //Flags |= IPSEC_OFFLOAD_QUERY_SPI; AADEBUGP(AAD_INFO, ("QUERY_SPI\n")); } // // Do V4AH next // if (pIPSecCaps->V4AH.MD5) { Flags |= IPSEC_OFFLOAD_AH_MD5; AADEBUGP(AAD_INFO, ("MD5\n")); } if (pIPSecCaps->V4AH.SHA_1) { Flags |= IPSEC_OFFLOAD_AH_SHA_1; AADEBUGP(AAD_INFO, ("SHA\n")); } if (pIPSecCaps->V4AH.Transport) { Flags |= IPSEC_OFFLOAD_AH_TPT; AADEBUGP(AAD_INFO, ("AH_TRANSPORT\n")); } if (pIPSecCaps->V4AH.Tunnel) { Flags |= IPSEC_OFFLOAD_AH_TUNNEL; AADEBUGP(AAD_INFO, ("AH_TUNNEL\n")); } if (pIPSecCaps->V4AH.Send) { Flags |= IPSEC_OFFLOAD_AH_XMT; AADEBUGP(AAD_INFO, ("AH_XMT\n")); } if (pIPSecCaps->V4AH.Receive) { Flags |= IPSEC_OFFLOAD_AH_RCV; AADEBUGP(AAD_INFO, ("AH_RCV\n")); } // // Do V4ESP next // if (pIPSecCaps->V4ESP.DES) { Flags |= IPSEC_OFFLOAD_ESP_DES; AADEBUGP(AAD_INFO, ("ESP_DES\n")); } if (pIPSecCaps->V4ESP.RESERVED) { pIPSecCaps->V4ESP.RESERVED = 0; //Flags |= IPSEC_OFFLOAD_ESP_DES_40; AADEBUGP(AAD_INFO, ("ESP_DES_40\n")); } if (pIPSecCaps->V4ESP.TRIPLE_DES) { Flags |= IPSEC_OFFLOAD_ESP_3_DES; AADEBUGP(AAD_INFO, ("ESP_3_DES\n")); } if (pIPSecCaps->V4ESP.NULL_ESP) { Flags |= IPSEC_OFFLOAD_ESP_NONE; AADEBUGP(AAD_INFO, ("ESP_NONE\n")); } if (pIPSecCaps->V4ESP.Transport) { Flags |= IPSEC_OFFLOAD_ESP_TPT; AADEBUGP(AAD_INFO, ("ESP_TRANSPORT\n")); } if (pIPSecCaps->V4ESP.Tunnel) { Flags |= IPSEC_OFFLOAD_ESP_TUNNEL; AADEBUGP(AAD_INFO, ("ESP_TUNNEL\n")); } if (pIPSecCaps->V4ESP.Send) { Flags |= IPSEC_OFFLOAD_ESP_XMT; AADEBUGP(AAD_INFO, ("ESP_XMT\n")); } if (pIPSecCaps->V4ESP.Receive) { Flags |= IPSEC_OFFLOAD_ESP_RCV; AADEBUGP(AAD_INFO, ("ESP_RCV\n")); } } if (pTask->OffsetNextTask == 0) { break; // No more tasks. } } // for // // Done parsing supported tasks. // Now construct the set of tasks we actually want to enable. // if (Flags) { UINT *pPrevOffset = &pHeader->OffsetFirstTask; AADEBUGP(AAD_WARNING, ("Enabling H/W capabilities: %lx\n", Flags)); // // Zero out the buffer beyond the task offload header structure // AA_SET_MEM(pTask, 0, BufferSize-sizeof(*pHeader)); pHeader->OffsetFirstTask = 0; pTask = (NDIS_TASK_OFFLOAD *) (pHeader+1); if ((Flags & TCP_XMT_CHECKSUM_OFFLOAD) || (Flags & IP_XMT_CHECKSUM_OFFLOAD) || (Flags & TCP_RCV_CHECKSUM_OFFLOAD) || (Flags & IP_RCV_CHECKSUM_OFFLOAD)) { PNDIS_TASK_TCP_IP_CHECKSUM ChksumBuf = (PNDIS_TASK_TCP_IP_CHECKSUM)pTask->TaskBuffer; *pPrevOffset = (UINT) ((PUCHAR)pTask - (PUCHAR)pHeader); pPrevOffset = &pTask->OffsetNextTask; pTask->Task = TcpIpChecksumNdisTask; pTask->TaskBufferLength = sizeof(NDIS_TASK_TCP_IP_CHECKSUM); if (Flags & TCP_XMT_CHECKSUM_OFFLOAD) { ChksumBuf->V4Transmit.TcpChecksum = 1; //ChksumBuf->V4Transmit.V4Checksum = 1; } if (Flags & IP_XMT_CHECKSUM_OFFLOAD) { ChksumBuf->V4Transmit.IpChecksum = 1; //ChksumBuf->V4Transmit.V4Checksum = 1; } if (Flags & TCP_RCV_CHECKSUM_OFFLOAD) { ChksumBuf->V4Receive.TcpChecksum = 1; //ChksumBuf->V4Receive.V4Checksum = 1; } if (Flags & IP_RCV_CHECKSUM_OFFLOAD) { ChksumBuf->V4Receive.IpChecksum = 1; //ChksumBuf->V4Receive.V4Checksum = 1; } // // Point to place where next task goes... // pTask = (PNDIS_TASK_OFFLOAD) (ChksumBuf+1); } if (Flags & TCP_LARGE_SEND_OFFLOAD) { PNDIS_TASK_TCP_LARGE_SEND out_LargeSend = (PNDIS_TASK_TCP_LARGE_SEND)pTask->TaskBuffer; *pPrevOffset = (UINT) ((PUCHAR)pTask - (PUCHAR)pHeader); pPrevOffset = &pTask->OffsetNextTask; pTask->Task = TcpLargeSendNdisTask; pTask->TaskBufferLength = sizeof(NDIS_TASK_TCP_LARGE_SEND); out_LargeSend->MaxOffLoadSize = MaxOffLoadSize; out_LargeSend->MinSegmentCount = MinSegmentCount; // // Point to place where next task goes... // pTask = (PNDIS_TASK_OFFLOAD) (out_LargeSend+1); } if ((Flags & (IPSEC_OFFLOAD_AH_XMT | IPSEC_OFFLOAD_AH_RCV | IPSEC_OFFLOAD_ESP_XMT | IPSEC_OFFLOAD_ESP_RCV))) { PNDIS_TASK_IPSEC pIPSecCaps = (PNDIS_TASK_IPSEC)pTask->TaskBuffer; *pPrevOffset = (UINT) ((PUCHAR)pTask - (PUCHAR)pHeader); pPrevOffset = &pTask->OffsetNextTask; // // plunk down the advertised capabilities // pTask->Task = IpSecNdisTask; pTask->TaskBufferLength = sizeof(NDIS_TASK_IPSEC); // // Point to place where next task goes... // pTask = (PNDIS_TASK_OFFLOAD) (pIPSecCaps+1); } } // // Having constructed the set of tasks to enable, we actually attempt // to enable them... // if (pHeader->OffsetFirstTask) { // // At least one task to enable, let's enable ... // UINT SetBufferSize = (UINT) ((PUCHAR)pTask - (PUCHAR)pHeader); AA_ASSERT(SetBufferSize <= BufferSize); AADEBUGP(AAD_WARNING, ("Setting offload tasks: %x bytes. Miniport returned %x bytes\n", SetBufferSize, BufferSize)); Status = AtmArpSendAdapterNdisRequest( pAdapter, &NdisRequest, NdisRequestSetInformation, OID_TCP_TASK_OFFLOAD, pHeader, SetBufferSize ); if (Status != NDIS_STATUS_SUCCESS) { AADEBUGP(AAD_WARNING, ("ARP: Failed to set offload tasks: %lx, status: %lx\n", Flags, Status)); } else { AADEBUGP(AAD_WARNING, ("ARP: Succeeded setting offload tasks: %lx:\n", Flags)); AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo); pAdapter->Offload.Flags = Flags; pAdapter->Offload.MaxOffLoadSize = MaxOffLoadSize; pAdapter->Offload.MinSegmentCount = MinSegmentCount; AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo); } } } while (FALSE); if (pHeader != NULL) { AA_FREE_MEM(pHeader); } // // We return success unless there was a fatal error and there was none... // return NDIS_STATUS_SUCCESS; } VOID AtmArpDisableOffload( IN PATMARP_ADAPTER pAdapter ) /*++ Routine Description: Disable offload capabilities, if enabled for this interface. Arguments: pAdapter - The adapter on which to disable offloading. Return Value: TRUE iff the operation was either succesful or no tasks were enabled. False if there was a fatal error. --*/ { ULONG Flags; AA_ACQUIRE_GLOBAL_LOCK(pAtmArpGlobalInfo); Flags = pAdapter->Offload.Flags; pAdapter->Offload.Flags = 0; pAdapter->Offload.MaxOffLoadSize = 0; pAdapter->Offload.MinSegmentCount = 0; AA_RELEASE_GLOBAL_LOCK(pAtmArpGlobalInfo); if (Flags) { NDIS_REQUEST NdisRequest; NDIS_TASK_OFFLOAD_HEADER Header; AA_SET_MEM(&Header, 0, sizeof(Header)); Header.EncapsulationFormat.Flags.FixedHeaderSize = 1; Header.EncapsulationFormat.EncapsulationHeaderSize = 2; Header.EncapsulationFormat.Encapsulation = LLC_SNAP_ROUTED_Encapsulation; Header.Version = NDIS_TASK_OFFLOAD_VERSION; Header.Size = sizeof(Header); // // Header.OffsetFirstTask == 0 tells the miniport to disable all tasks. // AADEBUGP(AAD_WARNING, ("Disabling all offloaded tasks for this adapter\n")); AtmArpSendAdapterNdisRequest( pAdapter, &NdisRequest, NdisRequestSetInformation, OID_TCP_TASK_OFFLOAD, &Header, sizeof(Header) ); } } #endif // ATMOFFLOAD