Merge develop changes prior to upcoming WDK release (May 2024)

1 files changed, 602 insertions, 0 deletions

diff --git a/network/wwan/cxwmbclass/rxqueue.cpp b/network/wwan/cxwmbclass/rxqueue.cpp
new file mode 100644
index 00000000..836201a5
--- /dev/null
+++ b/network/wwan/cxwmbclass/rxqueue.cpp
@@ -0,0 +1,602 @@
+//
+//    Copyright (C) Microsoft.  All rights reserved.
+//
+
+#include "precomp.h"
+
+#include "device.h"
+#include "rxqueue.h"
+
+#define MBB_NTH_GET_FIRST_NDP_OFFSET(IS32BIT, NTH) \
+    ((IS32BIT) ? MBB_NTH32_GET_FIRST_NDP_OFFSET((PNCM_NTH32)NTH) : MBB_NTH16_GET_FIRST_NDP_OFFSET((PNCM_NTH16)NTH))
+
+void MbbNotifyRxReady(_In_ NETPACKETQUEUE RxQueue)
+{
+    PMBB_RXQUEUE_CONTEXT rxQueueContext = MbbGetRxQueueContext(RxQueue);
+    if (InterlockedExchange(&rxQueueContext->NotificationEnabled, FALSE) == TRUE)
+    {
+        NetRxQueueNotifyMoreReceivedPacketsAvailable(RxQueue);
+    }
+}
+
+VOID MbbRecvCleanup(_In_ PMBB_NDIS_RECEIVE_CONTEXT Receive)
+{
+    MbbBusReturnReceiveBuffer(Receive->BusHandle, Receive->BusContext, Receive->Mdl);
+
+    WdfObjectDelete(Receive->ReceiveLookasideBufferMemory);
+}
+
+VOID MbbRecvReturnNdp(_In_ PMBB_NDIS_RECEIVE_CONTEXT ReceiveContext, _In_opt_ PMBB_RECEIVE_NDP_CONTEXT ReceiveNdpContext)
+{
+    LONG newCompletedCount = InterlockedIncrement(&ReceiveContext->CompletedNdpCount);
+    if (newCompletedCount == ReceiveContext->TotalNdpCount)
+    {
+        MbbRecvCleanup(ReceiveContext);
+    }
+    if (ReceiveNdpContext != NULL)
+    {
+        WdfObjectDelete(ReceiveNdpContext->ReceiveNdpLookasideBufferMemory);
+    }
+}
+
+_Use_decl_annotations_ VOID MbbRecvCancelNdps(PWMBCLASS_DEVICE_CONTEXT DeviceContext, ULONG SessionId)
+{
+    LIST_ENTRY tempList;
+    PLIST_ENTRY listEntry;
+    PLIST_ENTRY nextEntry;
+    PMBB_RECEIVE_NDP_CONTEXT receiveNdpContext = NULL;
+    PWMBCLASS_NETADAPTER_CONTEXT netAdapterContext = DeviceContext->Sessions[SessionId].NetAdapterContext;
+
+    InitializeListHead(&tempList);
+
+    WdfSpinLockAcquire(DeviceContext->Sessions[SessionId].WdfRecvSpinLock);
+    InsertHeadList(&netAdapterContext->ReceiveNdpList, &tempList);
+    RemoveEntryList(&netAdapterContext->ReceiveNdpList);
+    InitializeListHead(&netAdapterContext->ReceiveNdpList);
+    // Cannot cache the received Ndps anymore
+    netAdapterContext->AllowRxTraffic = FALSE;
+    WdfSpinLockRelease(DeviceContext->Sessions[SessionId].WdfRecvSpinLock);
+
+    for (listEntry = tempList.Flink; listEntry != &tempList; listEntry = nextEntry)
+    {
+        nextEntry = listEntry->Flink;
+        receiveNdpContext = CONTAINING_RECORD(listEntry, MBB_RECEIVE_NDP_CONTEXT, ReceiveNdpNode);
+        MbbRecvReturnNdp(receiveNdpContext->ReceiveContext, receiveNdpContext);
+    }
+}
+
+void MbbReceiveDssData(__in PWMBCLASS_DEVICE_CONTEXT DeviceContext, __in ULONG SessionId, __in_bcount_opt(InBufferSize) PUCHAR InBuffer, __in ULONG InBufferSize)
+{
+    NTSTATUS status;
+    WDFMEMORY data;
+
+    status = WdfMemoryCreatePreallocated(WDF_NO_OBJECT_ATTRIBUTES, InBuffer, InBufferSize, &data);
+
+    if (NT_SUCCESS(status))
+    {
+        DeviceContext->DSSPacketsReceivedCount++;
+
+        MbbDeviceReceiveDeviceServiceSessionData(DeviceContext->WdfDevice, SessionId, data);
+        WdfObjectDelete(data);
+    }
+}
+
+NTSTATUS
+MbbRecvNdpUnpackDss32(_In_ PMBB_NDIS_RECEIVE_CONTEXT ReceiveContext, _In_ PNCM_NTH32 Nth, _In_ PNCM_NDP32 Ndp)
+{
+    UNREFERENCED_PARAMETER(Nth);
+    NTSTATUS status = STATUS_SUCCESS;
+    ULONG datagramCount = MBB_NDP32_GET_DATAGRAM_COUNT(Ndp);
+    ULONG sessionId = MBB_NDP32_GET_SESSIONID(Ndp);
+    for (ULONG index = 0; index < datagramCount; index++)
+    {
+        if (MBB_NTB32_IS_END_DATAGRAM(Nth, Ndp, index))
+            break;
+
+        // Forward to the dss receive handler
+        MbbReceiveDssData(
+            ReceiveContext->WmbDeviceContext, sessionId, (PUCHAR)MBB_NDP32_GET_DATAGRAM(Nth, Ndp, index), MBB_NDP32_GET_DATAGRAM_LENGTH(Ndp, index));
+    }
+
+    MbbRecvReturnNdp(ReceiveContext, NULL);
+    return status;
+}
+
+NTSTATUS
+MbbRecvNdpUnpackDss16(_In_ PMBB_NDIS_RECEIVE_CONTEXT ReceiveContext, _In_ PNCM_NTH16 Nth, _In_ PNCM_NDP16 Ndp)
+{
+    UNREFERENCED_PARAMETER(Nth);
+    NTSTATUS status = STATUS_SUCCESS;
+    ULONG datagramCount = MBB_NDP16_GET_DATAGRAM_COUNT(Ndp);
+    ULONG sessionId = MBB_NDP16_GET_SESSIONID(Ndp);
+    for (ULONG index = 0; index < datagramCount; index++)
+    {
+        if (MBB_NTB16_IS_END_DATAGRAM(Nth, Ndp, index))
+            break;
+
+        // Forward to the dss receive handler
+        MbbReceiveDssData(
+            ReceiveContext->WmbDeviceContext, sessionId, (PUCHAR)MBB_NDP16_GET_DATAGRAM(Nth, Ndp, index), MBB_NDP16_GET_DATAGRAM_LENGTH(Ndp, index));
+    }
+    MbbRecvReturnNdp(ReceiveContext, NULL);
+    return status;
+}
+
+NTSTATUS
+MbbRecvAddNdp(_In_ PMBB_NDIS_RECEIVE_CONTEXT ReceiveContext, _In_ PVOID Nth, _In_ PVOID Ndp, _In_ ULONG SessionId)
+{
+    NTSTATUS status = STATUS_SUCCESS;
+    PWMBCLASS_DEVICE_CONTEXT deviceContext = ReceiveContext->WmbDeviceContext;
+    PWMBCLASS_NETADAPTER_CONTEXT netAdapterContext = NULL;
+    WDFMEMORY ndpContextMemory;
+    PMBB_RECEIVE_NDP_CONTEXT ndpContext = NULL;
+    size_t ndpContextSize;
+    BOOLEAN returnNdp = FALSE;
+
+    WdfSpinLockAcquire(deviceContext->Sessions[SessionId].WdfRecvSpinLock);
+    do
+    {
+        netAdapterContext = deviceContext->Sessions[SessionId].NetAdapterContext;
+        if (netAdapterContext == NULL)
+        {
+            returnNdp = TRUE;
+            break;
+        }
+
+        if (!NT_SUCCESS(status = WdfMemoryCreateFromLookaside(netAdapterContext->ReceiveNdpLookasideList, &ndpContextMemory)))
+        {
+            returnNdp = TRUE;
+            break;
+        }
+
+        ndpContext = (PMBB_RECEIVE_NDP_CONTEXT)WdfMemoryGetBuffer(ndpContextMemory, &ndpContextSize);
+        RtlZeroMemory(ndpContext, ndpContextSize);
+        ndpContext->Nth = Nth;
+        ndpContext->Ndp = Ndp;
+        ndpContext->ReceiveContext = ReceiveContext;
+        ndpContext->ReceiveNdpLookasideBufferMemory = ndpContextMemory;
+        ndpContext->NetAdapterContext = netAdapterContext;
+        if (netAdapterContext->AllowRxTraffic)
+        {
+            InsertTailList(&netAdapterContext->ReceiveNdpList, &ndpContext->ReceiveNdpNode);
+        }
+        else
+        {
+            returnNdp = TRUE;
+            break;
+        }
+
+        // If RxQueueCreate hasn't completed yet, we only queue the received Ndp and don't need notify RxReady
+        if (netAdapterContext->RxQueue)
+        {
+            MbbNotifyRxReady(netAdapterContext->RxQueue);
+        }
+    } while (FALSE);
+    WdfSpinLockRelease(deviceContext->Sessions[SessionId].WdfRecvSpinLock);
+
+    if (returnNdp)
+    {
+        MbbRecvReturnNdp(ReceiveContext, ndpContext);
+    }
+    return status;
+}
+
+VOID MbbRecvNtbParse(_In_ PMBB_NDIS_RECEIVE_CONTEXT ReceiveContext)
+{
+    NTSTATUS status = STATUS_SUCCESS;
+    PNCM_NTH32 nth32;
+    PNCM_NTH16 nth16;
+    PNCM_NDP32 ndp32;
+    PNCM_NDP16 ndp16;
+    PVOID nth = ReceiveContext->ReceiveNtbBuffer;
+
+    if (MBB_NTB_IS_32BIT(nth))
+    {
+        nth32 = (PNCM_NTH32)nth;
+        for (ndp32 = MBB_NTH32_GET_FIRST_NDP(nth32); ndp32 != NULL; ndp32 = MBB_NDP32_GET_NEXT_NDP(nth32, ndp32))
+        {
+            if (MBB_NDP32_GET_SIGNATURE_TYPE(ndp32) == NCM_NDP32_VENDOR)
+            {
+                status = MbbRecvNdpUnpackDss32(ReceiveContext, nth32, ndp32);
+                if (!NT_SUCCESS(status))
+                {
+                }
+            }
+            else if (MBB_NDP32_GET_SIGNATURE_TYPE(ndp32) == NCM_NDP32_IPS)
+            {
+                status = MbbRecvAddNdp(ReceiveContext, nth32, ndp32, MBB_NDP32_GET_SESSIONID(ndp32));
+                if (!NT_SUCCESS(status))
+                {
+                }
+            }
+            else
+            {
+                MbbRecvReturnNdp(ReceiveContext, NULL);
+            }
+        }
+    }
+    else if (MBB_NTB_IS_16BIT(nth))
+    {
+        nth16 = (PNCM_NTH16)nth;
+        for (ndp16 = MBB_NTH16_GET_FIRST_NDP(nth16); ndp16 != NULL; ndp16 = MBB_NDP16_GET_NEXT_NDP(nth16, ndp16))
+        {
+            if (MBB_NDP16_GET_SIGNATURE_TYPE(ndp16) == NCM_NDP16_VENDOR)
+            {
+                status = MbbRecvNdpUnpackDss16(ReceiveContext, nth16, ndp16);
+                if (!NT_SUCCESS(status))
+                {
+                }
+            }
+            else if (MBB_NDP16_GET_SIGNATURE_TYPE(ndp16) == NCM_NDP16_IPS)
+            {
+                status = MbbRecvAddNdp(ReceiveContext, nth16, ndp16, MBB_NDP32_GET_SESSIONID(ndp16));
+                if (!NT_SUCCESS(status))
+                {
+                }
+            }
+            else
+            {
+                MbbRecvReturnNdp(ReceiveContext, NULL);
+            }
+        }
+    }
+}
+
+NTSTATUS
+MbbRecvNtbUnpackIpNdp32(_In_ PMBB_RECEIVE_NDP_CONTEXT ReceiveNdpContext, _In_ PNCM_NTH32 Nth32, _In_ PNCM_NDP32 Ndp32, _Inout_ ULONG* IncompletedDatagramIndex, _In_ PMBB_RXQUEUE_CONTEXT RxQueueContext)
+{
+    PCHAR incompletedDatagram;
+    ULONG incompletedDatagramLength;
+    NET_PACKET* packet;
+    NET_FRAGMENT* fragment;
+    NET_FRAGMENT_RETURN_CONTEXT* returnContext;
+    NET_FRAGMENT_VIRTUAL_ADDRESS* virtualAddress;
+    NTSTATUS status = STATUS_SUCCESS;
+    ULONG datagramCount = MBB_NDP32_GET_DATAGRAM_COUNT(Ndp32);
+
+    NET_RING * pr = NetRingCollectionGetPacketRing(RxQueueContext->DatapathDescriptor);
+    NET_RING * fr = NetRingCollectionGetFragmentRing(RxQueueContext->DatapathDescriptor);
+
+    while ((incompletedDatagram = MBB_NDP32_GET_DATAGRAM(Nth32, Ndp32, *IncompletedDatagramIndex)) != NULL)
+    {
+        if (*IncompletedDatagramIndex >= datagramCount)
+        {
+            break;
+        }
+
+        if (fr->BeginIndex == fr->EndIndex)
+        {
+            status = STATUS_BUFFER_OVERFLOW;
+            break;
+        }
+
+        incompletedDatagramLength = MBB_NDP32_GET_DATAGRAM_LENGTH(Ndp32, *IncompletedDatagramIndex);
+        
+        UINT32 const fragmentIndex = fr->BeginIndex;
+        fragment = NetRingGetFragmentAtIndex(fr, fragmentIndex);
+        fragment->Capacity = incompletedDatagramLength;
+        fragment->ValidLength = incompletedDatagramLength;
+        fragment->Offset = 0;
+
+        returnContext = NetExtensionGetFragmentReturnContext(&RxQueueContext->ReturnContextExtension, fragmentIndex);
+        virtualAddress =
+            NetExtensionGetFragmentVirtualAddress(&RxQueueContext->VirtualAddressExtension, fragmentIndex);
+
+
+        returnContext->Handle = (NET_FRAGMENT_RETURN_CONTEXT_HANDLE)ReceiveNdpContext;
+        virtualAddress->VirtualAddress = incompletedDatagram;
+
+        (ReceiveNdpContext->IndicatedPackets)++;
+        (*IncompletedDatagramIndex)++;
+
+        UINT32 const packetIndex = pr->BeginIndex;
+        packet = NetRingGetPacketAtIndex(pr, packetIndex);
+        packet->FragmentIndex = fragmentIndex;
+        packet->FragmentCount = 1;
+        packet->Layout = {};
+
+        pr->BeginIndex = NetRingIncrementIndex(pr, pr->BeginIndex);
+        fr->BeginIndex = NetRingIncrementIndex(fr, fr->BeginIndex);    
+    }
+    return status;
+}
+
+NTSTATUS
+MbbRecvNtbUnpackIpNdp16(_In_ PMBB_RECEIVE_NDP_CONTEXT ReceiveNdpContext, _In_ PNCM_NTH16 Nth16, _In_ PNCM_NDP16 Ndp16, _Inout_ ULONG* IncompletedDatagramIndex, _In_ PMBB_RXQUEUE_CONTEXT RxQueueContext)
+{
+    PCHAR incompletedDatagram;
+    ULONG incompletedDatagramLength;
+    NET_PACKET* packet;
+    NET_FRAGMENT* fragment;
+    NET_FRAGMENT_RETURN_CONTEXT* returnContext;
+    NET_FRAGMENT_VIRTUAL_ADDRESS* virtualAddress;
+    NTSTATUS status = STATUS_SUCCESS;
+    ULONG datagramCount = MBB_NDP16_GET_DATAGRAM_COUNT(Ndp16);
+
+    NET_RING * pr = NetRingCollectionGetPacketRing(RxQueueContext->DatapathDescriptor);
+    NET_RING * fr = NetRingCollectionGetFragmentRing(RxQueueContext->DatapathDescriptor);
+
+    while ((incompletedDatagram = MBB_NDP16_GET_DATAGRAM(Nth16, Ndp16, *IncompletedDatagramIndex)) != NULL)
+    {
+        if (*IncompletedDatagramIndex >= datagramCount)
+        {
+            break;
+        }
+
+        if (fr->BeginIndex == fr->EndIndex)
+        {
+            status = STATUS_BUFFER_OVERFLOW;
+            break;
+        }
+
+        incompletedDatagramLength = MBB_NDP16_GET_DATAGRAM_LENGTH(Ndp16, *IncompletedDatagramIndex);
+
+        UINT32 const fragmentIndex = fr->BeginIndex;
+        fragment = NetRingGetFragmentAtIndex(fr, fragmentIndex);
+        fragment->Capacity = incompletedDatagramLength;
+        fragment->ValidLength = incompletedDatagramLength;
+        fragment->Offset = 0;
+
+        returnContext = NetExtensionGetFragmentReturnContext(&RxQueueContext->ReturnContextExtension, fragmentIndex);
+        virtualAddress =
+            NetExtensionGetFragmentVirtualAddress(&RxQueueContext->VirtualAddressExtension, fragmentIndex);
+
+        returnContext->Handle = (NET_FRAGMENT_RETURN_CONTEXT_HANDLE)ReceiveNdpContext;
+        virtualAddress->VirtualAddress = incompletedDatagram;
+
+        (ReceiveNdpContext->IndicatedPackets)++;
+        (*IncompletedDatagramIndex)++;
+
+        UINT32 const packetIndex = pr->BeginIndex;
+        packet = NetRingGetPacketAtIndex(pr, packetIndex);
+        packet->FragmentIndex = fragmentIndex;
+        packet->FragmentCount = 1;
+        packet->Layout = {};
+
+        pr->BeginIndex = NetRingIncrementIndex(pr, pr->BeginIndex);
+        fr->BeginIndex = NetRingIncrementIndex(fr, fr->BeginIndex); 
+    }
+
+    return status;
+}
+
+NTSTATUS
+MbbRecvNdpUnpackIps(_In_ PMBB_RECEIVE_NDP_CONTEXT ReceiveNdpContext, _In_ PMBB_RXQUEUE_CONTEXT RxQueueContext)
+{
+    NTSTATUS status = STATUS_SUCCESS;
+    PNCM_NTH32 nth32;
+    PNCM_NTH16 nth16;
+    PNCM_NDP32 ndp32;
+    PNCM_NDP16 ndp16;
+    PMBB_NDIS_RECEIVE_CONTEXT receiveContext = ReceiveNdpContext->ReceiveContext;
+    PVOID nth = receiveContext->ReceiveNtbBuffer;
+
+    if (MBB_NTB_IS_32BIT(nth))
+    {
+        nth32 = (PNCM_NTH32)nth;
+        ndp32 = (PNCM_NDP32)ReceiveNdpContext->Ndp;
+        status = MbbRecvNtbUnpackIpNdp32(ReceiveNdpContext, nth32, ndp32, &ReceiveNdpContext->CurrentDatagramIndex, RxQueueContext);
+    }
+    else if (MBB_NTB_IS_16BIT(nth))
+    {
+        nth16 = (PNCM_NTH16)nth;
+        ndp16 = (PNCM_NDP16)ReceiveNdpContext->Ndp;
+        status = MbbRecvNtbUnpackIpNdp16(ReceiveNdpContext, nth16, ndp16, &ReceiveNdpContext->CurrentDatagramIndex, RxQueueContext);
+    }
+
+    return status;
+}
+
+PMBB_NDIS_RECEIVE_CONTEXT
+MbbRecvQQueueReceive(_In_ PWMBCLASS_DEVICE_CONTEXT DeviceContext, _In_ MBB_RECEIVE_CONTEXT BusContext, _In_ PMDL Mdl, _In_reads_(sizeof(NCM_NTH32)) PUCHAR ReceiveNtbBuffer)
+{
+    PMBB_NDIS_RECEIVE_CONTEXT receiveContext = NULL;
+    WDFMEMORY receiveContextMemory;
+    size_t receiveContextSize;
+    NTSTATUS status = STATUS_SUCCESS;
+
+    do
+    {
+        if (!NT_SUCCESS(status = WdfMemoryCreateFromLookaside(DeviceContext->ReceiveLookasideList, &receiveContextMemory)))
+        {
+            break;
+        }
+
+        receiveContext = (PMBB_NDIS_RECEIVE_CONTEXT)WdfMemoryGetBuffer(receiveContextMemory, &receiveContextSize);
+        RtlZeroMemory(receiveContext, receiveContextSize);
+
+        receiveContext->Mdl = Mdl;
+        receiveContext->WmbDeviceContext = DeviceContext;
+        receiveContext->BusHandle = DeviceContext->BusHandle;
+        receiveContext->BusContext = BusContext;
+        receiveContext->ReceiveLookasideList = DeviceContext->ReceiveLookasideList;
+        receiveContext->ReceiveLookasideBufferMemory = receiveContextMemory;
+        receiveContext->ReceiveNtbBuffer = ReceiveNtbBuffer;
+        receiveContext->NtbSequence = MBB_NTB_GET_SEQUENCE(ReceiveNtbBuffer);
+    } while (FALSE);
+
+    return receiveContext;
+}
+
+VOID MbbNdisReceiveCallback(_In_ MBB_PROTOCOL_HANDLE ProtocolHandle, _In_ MBB_RECEIVE_CONTEXT ReceiveContext, _In_ PMDL Mdl)
+{
+    PUCHAR dataBuffer;
+    ULONG dataLength;
+    PVOID nth;
+    BOOLEAN returnBuffer = TRUE;
+    PWMBCLASS_DEVICE_CONTEXT deviceContext = (PWMBCLASS_DEVICE_CONTEXT)ProtocolHandle;
+    PMBB_NDIS_RECEIVE_CONTEXT receive = NULL;
+    ULONG ndpCount = 1;
+    NTSTATUS status = STATUS_SUCCESS;
+    do
+    {
+        if ((dataBuffer = (PUCHAR)MmGetSystemAddressForMdlSafe(Mdl, NormalPagePriority | MdlMappingNoExecute)) == NULL)
+        {
+            status = STATUS_RESOURCE_DATA_NOT_FOUND;
+            break;
+        }
+        dataLength = MmGetMdlByteCount(Mdl);
+
+        nth = dataBuffer;
+
+        if (!NT_SUCCESS(status = MbbNtbValidate(nth, dataLength, deviceContext->BusParams.CurrentMode32Bit, &ndpCount)))
+        {
+            {
+                ULONG i;
+                ULONG j;
+
+                PUCHAR buffer = (PUCHAR)nth;
+
+                for (i = 0; i < dataLength; i += 16)
+                {
+                    UCHAR numString[16 * 3 + 1];
+                    UCHAR asciiBuffer[40];
+                    UCHAR value = 0;
+                    const char translateTable[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+
+                    RtlZeroMemory(numString, sizeof(numString));
+                    RtlZeroMemory(asciiBuffer, sizeof(asciiBuffer));
+
+                    for (j = 0; j < 16; j++)
+                    {
+                        if (i + j >= dataLength)
+                        {
+                            //
+                            //  past the end, just put spaces
+                            //
+                            numString[j * 3] = ' ';
+                            numString[j * 3 + 1] = ' ';
+                            numString[j * 3 + 2] = ' ';
+                        }
+                        else
+                        {
+                            value = buffer[i + j];
+
+                            numString[j * 3] = translateTable[value >> 4];
+                            numString[j * 3 + 1] = translateTable[value & 0xf];
+                            numString[j * 3 + 2] = ' ';
+
+                            if ((buffer[i + j] >= 32) && (buffer[i + j] < 128))
+                            {
+                                asciiBuffer[j] = value;
+                            }
+                            else
+                            {
+                                asciiBuffer[j] = '.';
+                            }
+                        }
+                    }
+                }
+            }
+            break;
+        }
+
+        if ((receive = MbbRecvQQueueReceive(deviceContext, ReceiveContext, Mdl, (PUCHAR)nth)) == NULL)
+        {
+            status = STATUS_INSUFFICIENT_RESOURCES;
+            break;
+        }
+
+        returnBuffer = FALSE;
+        receive->TotalNdpCount = ndpCount;
+
+        // Receive DSS, IPs will be received in EvtRxQueueAdvance
+        MbbRecvNtbParse(receive);
+    } while (FALSE);
+
+    if (returnBuffer)
+    {
+        if (receive != NULL)
+        {
+            MbbRecvCleanup(receive);
+        }
+        else
+        {
+            MbbBusReturnReceiveBuffer(deviceContext->BusHandle, ReceiveContext, Mdl);
+        }
+    }
+}
+
+void EvtRxQueueDestroy(_In_ WDFOBJECT RxQueue)
+{
+    PMBB_RXQUEUE_CONTEXT rxQueueContext = MbbGetRxQueueContext(RxQueue);
+    PWMBCLASS_NETADAPTER_CONTEXT netAdapterContext = rxQueueContext->NetAdapterContext;
+    netAdapterContext->RxQueue = NULL;
+}
+
+VOID EvtRxQueueSetNotificationEnabled(_In_ NETPACKETQUEUE RxQueue, _In_ BOOLEAN NotificationEnabled)
+{
+    PMBB_RXQUEUE_CONTEXT txQueueContext = MbbGetRxQueueContext(RxQueue);
+    InterlockedExchange(&txQueueContext->NotificationEnabled, NotificationEnabled);
+}
+
+void EvtRxQueueAdvance(_In_ NETPACKETQUEUE RxQueue)
+{
+    PMBB_RXQUEUE_CONTEXT rxQueueContext = MbbGetRxQueueContext(RxQueue);
+    PWMBCLASS_NETADAPTER_CONTEXT netAdapterContext = rxQueueContext->NetAdapterContext;
+    WDFSPINLOCK wdfRecvSpinLock = netAdapterContext->WmbDeviceContext->Sessions[netAdapterContext->SessionId].WdfRecvSpinLock;
+    PMBB_RECEIVE_NDP_CONTEXT receiveNdpContext;
+    NTSTATUS status = STATUS_SUCCESS;
+
+    WdfSpinLockAcquire(wdfRecvSpinLock);
+    while (!IsListEmpty(&netAdapterContext->ReceiveNdpList))
+    {
+        receiveNdpContext = CONTAINING_RECORD(RemoveHeadList(&netAdapterContext->ReceiveNdpList), MBB_RECEIVE_NDP_CONTEXT, ReceiveNdpNode);
+        receiveNdpContext->ReceiveNdpNode.Flink = receiveNdpContext->ReceiveNdpNode.Blink = NULL;
+        WdfSpinLockRelease(wdfRecvSpinLock);
+
+        status = MbbRecvNdpUnpackIps(receiveNdpContext, rxQueueContext);
+        if (status == STATUS_BUFFER_OVERFLOW)
+        {
+            WdfSpinLockAcquire(wdfRecvSpinLock);
+            InsertHeadList(&netAdapterContext->ReceiveNdpList, &receiveNdpContext->ReceiveNdpNode);
+            break;
+        }
+        else
+        {
+            if (!NT_SUCCESS(status))
+            {
+            }
+        }
+
+        WdfSpinLockAcquire(wdfRecvSpinLock);
+    }
+    WdfSpinLockRelease(wdfRecvSpinLock);
+}
+
+void EvtRxQueueCancel(_In_ NETPACKETQUEUE RxQueue)
+{
+    PMBB_RXQUEUE_CONTEXT rxQueueContext = MbbGetRxQueueContext(RxQueue);
+    PWMBCLASS_NETADAPTER_CONTEXT netAdapterContext = rxQueueContext->NetAdapterContext;
+    PWMBCLASS_DEVICE_CONTEXT deviceContext = netAdapterContext->WmbDeviceContext;
+    NET_RING_COLLECTION const* rings = rxQueueContext->DatapathDescriptor;
+
+    NET_RING * pr = NetRingCollectionGetPacketRing(rings);
+
+    while (pr->BeginIndex != pr->EndIndex)
+    {
+        NET_PACKET * packet = NetRingGetPacketAtIndex(pr, pr->BeginIndex);
+        packet->Ignore = 1;
+        pr->BeginIndex = NetRingIncrementIndex(pr, pr->BeginIndex);
+    }
+
+    NET_RING * fr = NetRingCollectionGetFragmentRing(rings);
+    fr->BeginIndex = fr->EndIndex; 
+
+    // Cancel received Ndps which may be received after EvtRxQueueCancel started, these Ndps may never be processed by EvtRxQueueAdvance
+    MbbRecvCancelNdps(deviceContext, netAdapterContext->SessionId);
+}
+
+VOID EvtAdapterReturnRxBuffer(_In_ NETADAPTER Adapter, _In_ NET_FRAGMENT_RETURN_CONTEXT_HANDLE RxBufferReturnContext)
+{
+    PMBB_RECEIVE_NDP_CONTEXT receiveNdpContext = (PMBB_RECEIVE_NDP_CONTEXT)RxBufferReturnContext;
+    UNREFERENCED_PARAMETER(Adapter);
+    NT_ASSERT(receiveNdpContext->IndicatedPackets);
+
+    receiveNdpContext->IndicatedPackets--;
+    if ((receiveNdpContext->IndicatedPackets == 0) && (receiveNdpContext->ReceiveNdpNode.Blink == NULL) &&
+        (receiveNdpContext->ReceiveNdpNode.Flink == NULL))
+    {
+        MbbRecvReturnNdp(receiveNdpContext->ReceiveContext, receiveNdpContext);
+    }
+}