inet::ieee80211::BlockAckReordering Class Reference

#include <BlockAckReordering.h>

Public Types
typedef std::vector< Packet * >	Fragments
typedef std::map< SequenceNumber, Fragments >	ReorderBuffer

Public Member Functions
virtual	~BlockAckReordering ()
void	processReceivedDelba (const Ptr< const Ieee80211Delba > &delba)
ReorderBuffer	processReceivedQoSFrame (RecipientBlockAckAgreement *agreement, Packet *dataPacket, const Ptr< const Ieee80211DataHeader > &dataHeader)
ReorderBuffer	processReceivedBlockAckReq (RecipientBlockAckAgreement *agreement, const Ptr< const Ieee80211BlockAckReq > &blockAckReq)

Protected Member Functions
ReorderBuffer	collectCompletePrecedingMpdus (ReceiveBuffer *receiveBuffer, SequenceNumberCyclic startingSequenceNumber)
ReorderBuffer	collectConsecutiveCompleteFollowingMpdus (ReceiveBuffer *receiveBuffer, SequenceNumberCyclic startingSequenceNumber)
std::vector< Packet * >	getEarliestCompleteMsduOrAMsduIfExists (ReceiveBuffer *receiveBuffer)
bool	isComplete (const Fragments &fragments)
void	passedUp (RecipientBlockAckAgreement *agreement, ReceiveBuffer *receiveBuffer, SequenceNumberCyclic sequenceNumber)
void	releaseReceiveBuffer (RecipientBlockAckAgreement *agreement, ReceiveBuffer *receiveBuffer, const ReorderBuffer &reorderBuffer)
ReceiveBuffer *	createReceiveBufferIfNecessary (RecipientBlockAckAgreement *agreement)
bool	addMsduIfComplete (ReceiveBuffer *receiveBuffer, ReorderBuffer &reorderBuffer, SequenceNumberCyclic seqNum)

Protected Attributes
std::map< std::pair< Tid, MacAddress >, ReceiveBuffer * >	receiveBuffers

Member Typedef Documentation

Fragments

typedef std::vector<Packet *> inet::ieee80211::BlockAckReordering::Fragments

ReorderBuffer

typedef std::map<SequenceNumber, Fragments> inet::ieee80211::BlockAckReordering::ReorderBuffer

Constructor & Destructor Documentation

~BlockAckReordering()

inet::ieee80211::BlockAckReordering::~BlockAckReordering ( )

virtual

{
    for (auto receiveBuffer : receiveBuffers)
        delete receiveBuffer.second;
}

Member Function Documentation

addMsduIfComplete()

bool inet::ieee80211::BlockAckReordering::addMsduIfComplete ( ReceiveBuffer *  receiveBuffer, ReorderBuffer &  reorderBuffer, SequenceNumberCyclic  seqNum  )

protected

{
    const auto& buffer = receiveBuffer->getBuffer();
    auto it = buffer.find(seqNum.get());
    if (it != buffer.end()) {
        auto fragments = it->second;
        if (isComplete(fragments)) {
            reorderBuffer[seqNum.get()] = fragments;
            return true;
        }
    }
    return false;
}

Referenced by collectConsecutiveCompleteFollowingMpdus().

collectCompletePrecedingMpdus()

BlockAckReordering::ReorderBuffer inet::ieee80211::BlockAckReordering::collectCompletePrecedingMpdus ( ReceiveBuffer *  receiveBuffer, SequenceNumberCyclic  startingSequenceNumber  )

protected

{
    ReorderBuffer completePrecedingMpdus;
    const auto& buffer = receiveBuffer->getBuffer();
    for (auto it : buffer) { // collects complete preceding MPDUs
        auto sequenceNumber = it.first;
        auto fragments = it.second;
        if (SequenceNumberCyclic(sequenceNumber) < startingSequenceNumber)
            if (isComplete(fragments))
                completePrecedingMpdus[sequenceNumber] = fragments;
    }
    return completePrecedingMpdus;
}

Referenced by processReceivedBlockAckReq().

collectConsecutiveCompleteFollowingMpdus()

BlockAckReordering::ReorderBuffer inet::ieee80211::BlockAckReordering::collectConsecutiveCompleteFollowingMpdus ( ReceiveBuffer *  receiveBuffer, SequenceNumberCyclic  startingSequenceNumber  )

protected

{
    ReorderBuffer framesToPassUp;
    for (int i = 0; i < receiveBuffer->getBufferSize(); i++) {
        if (!addMsduIfComplete(receiveBuffer, framesToPassUp, startingSequenceNumber + i))
            return framesToPassUp;
    }
    return framesToPassUp;
}

Referenced by processReceivedBlockAckReq().

createReceiveBufferIfNecessary()

ReceiveBuffer * inet::ieee80211::BlockAckReordering::createReceiveBufferIfNecessary ( RecipientBlockAckAgreement *  agreement )

protected

{
    SequenceNumberCyclic startingSequenceNumber = agreement->getStartingSequenceNumber();
    int bufferSize = agreement->getBufferSize();
    Tid tid = agreement->getBlockAckRecord()->getTid();
    MacAddress originatorAddr = agreement->getBlockAckRecord()->getOriginatorAddress();
    auto id = std::make_pair(tid, originatorAddr);
    auto it = receiveBuffers.find(id);
    if (it == receiveBuffers.end()) {
        ReceiveBuffer *buffer = new ReceiveBuffer(bufferSize, startingSequenceNumber);
        receiveBuffers[id] = buffer;
        return buffer;
    }
    else
        return it->second;
}

Referenced by processReceivedQoSFrame().

getEarliestCompleteMsduOrAMsduIfExists()

std::vector< Packet * > inet::ieee80211::BlockAckReordering::getEarliestCompleteMsduOrAMsduIfExists ( ReceiveBuffer *  receiveBuffer )

protected

{
    Fragments earliestFragments = Fragments();
    SequenceNumberCyclic earliestSeqNum = SequenceNumberCyclic(0);
    const auto& buffer = receiveBuffer->getBuffer();
    for (auto it : buffer) {
        if (isComplete(it.second)) {
            earliestFragments = it.second;
            earliestSeqNum = earliestFragments.at(0)->peekAtFront<Ieee80211DataOrMgmtHeader>()->getSequenceNumber();
            break;
        }
    }
    if (earliestFragments.size() > 0) {
        for (auto it : buffer) {
            SequenceNumberCyclic currentSeqNum = it.second.at(0)->peekAtFront<Ieee80211DataOrMgmtHeader>()->getSequenceNumber();
            if (currentSeqNum < earliestSeqNum) {
                if (isComplete(it.second)) {
                    earliestFragments = it.second;
                    earliestSeqNum = currentSeqNum;
                }
            }
        }
    }
    return earliestFragments;
}

Referenced by processReceivedQoSFrame().

isComplete()

bool inet::ieee80211::BlockAckReordering::isComplete ( const Fragments &  fragments )

protected

{
    int largestFragmentNumber = -1;
    std::set<FragmentNumber> fragNums; // possible duplicate frames
    for (auto fragment : fragments) {
        const auto& header = fragment->peekAtFront<Ieee80211DataHeader>();
        if (!header->getMoreFragments())
            largestFragmentNumber = header->getFragmentNumber();
        fragNums.insert(header->getFragmentNumber());
    }
    return largestFragmentNumber != -1 && largestFragmentNumber + 1 == (int)fragNums.size();
}

Referenced by addMsduIfComplete(), collectCompletePrecedingMpdus(), and getEarliestCompleteMsduOrAMsduIfExists().

passedUp()

void inet::ieee80211::BlockAckReordering::passedUp ( RecipientBlockAckAgreement *  agreement, ReceiveBuffer *  receiveBuffer, SequenceNumberCyclic  sequenceNumber  )

protected

{
    // Each time that the recipient passes an MSDU or A-MSDU for a Block Ack agreement up to the next MAC
    // process, the NextExpectedSequenceNumber for that Block Ack agreement is set to the sequence number of the
    // MSDU or A-MSDU that was passed up to the next MAC process plus one.
    receiveBuffer->setNextExpectedSequenceNumber(sequenceNumber + 1);
    receiveBuffer->dropFramesUntil(sequenceNumber);
    receiveBuffer->removeFrame(sequenceNumber);
    agreement->getBlockAckRecord()->removeAckStates(sequenceNumber);
}

Referenced by processReceivedQoSFrame(), and releaseReceiveBuffer().

processReceivedBlockAckReq()

BlockAckReordering::ReorderBuffer inet::ieee80211::BlockAckReordering::processReceivedBlockAckReq	(	RecipientBlockAckAgreement *	agreement,
		const Ptr< const Ieee80211BlockAckReq > &	blockAckReq
	)

{
    // The originator shall use the Block Ack starting sequence control to signal the first MPDU in the block for
    // which an acknowledgment is expected.
    SequenceNumberCyclic startingSequenceNumber;
    Tid tid = -1;
    if (auto basicReq = dynamicPtrCast<const Ieee80211BasicBlockAckReq>(blockAckReq)) {
        tid = basicReq->getTidInfo();
        startingSequenceNumber = basicReq->getStartingSequenceNumber();
    }
    else if (auto compressedReq = dynamicPtrCast<const Ieee80211CompressedBlockAck>(blockAckReq)) {
        tid = compressedReq->getTidInfo();
        startingSequenceNumber = compressedReq->getStartingSequenceNumber();
    }
    else {
        throw cRuntimeError("Multi-Tid BlockAckReq is currently an unimplemented feature");
    }
    auto id = std::make_pair(tid, blockAckReq->getTransmitterAddress());
    auto it = receiveBuffers.find(id);
    if (it != receiveBuffers.end()) {
        ReceiveBuffer *receiveBuffer = it->second;
        // MPDUs in the recipient’s buffer with a sequence control value that
        // precedes the starting sequence control value are called preceding MPDUs.
        // The recipient shall reassemble any complete MSDUs from buffered preceding
        // MPDUs and indicate these to its higher layer.
        auto completePrecedingMpdus = collectCompletePrecedingMpdus(receiveBuffer, startingSequenceNumber);
        // Upon arrival of a BlockAckReq frame, the recipient shall pass up the MSDUs and A-MSDUs starting with
        // the starting sequence number sequentially until there is an incomplete or missing MSDU
        // or A-MSDU in the buffer.
        auto consecutiveCompleteFollowingMpdus = collectConsecutiveCompleteFollowingMpdus(receiveBuffer, startingSequenceNumber);
        // If no MSDUs or A-MSDUs are passed up to the next MAC process after the receipt
        // of the BlockAckReq frame and the starting sequence number of the BlockAckReq frame is newer than the
        // NextExpectedSequenceNumber for that Block Ack agreement, then the NextExpectedSequenceNumber for
        // that Block Ack agreement is set to the sequence number of the BlockAckReq frame.
        int numOfMsdusToPassUp = completePrecedingMpdus.size() + consecutiveCompleteFollowingMpdus.size();
        if (numOfMsdusToPassUp == 0 && receiveBuffer->getNextExpectedSequenceNumber() < startingSequenceNumber)
            receiveBuffer->setNextExpectedSequenceNumber(startingSequenceNumber);
        // The recipient shall then release any buffers held by preceding MPDUs.
        releaseReceiveBuffer(agreement, receiveBuffer, completePrecedingMpdus);
        releaseReceiveBuffer(agreement, receiveBuffer, consecutiveCompleteFollowingMpdus);
        // The recipient shall pass MSDUs and A-MSDUs up to the next MAC process in order of increasing sequence
        // number.
        completePrecedingMpdus.insert(consecutiveCompleteFollowingMpdus.begin(), consecutiveCompleteFollowingMpdus.end());
        return completePrecedingMpdus;
    }
    return ReorderBuffer();
}

Referenced by inet::ieee80211::RecipientQosMacDataService::controlFrameReceived().

processReceivedDelba()

void inet::ieee80211::BlockAckReordering::processReceivedDelba

(

const Ptr< const Ieee80211Delba > &

delba

)

{
    Tid tid = delba->getTid();
    MacAddress originatorAddr = delba->getTransmitterAddress();
    auto id = std::make_pair(tid, originatorAddr);
    auto it = receiveBuffers.find(id);
    if (it != receiveBuffers.end()) {
        delete it->second;
        receiveBuffers.erase(it);
    }
    else
        EV_DETAIL << "Receive buffer is not found" << endl;
}

Referenced by inet::ieee80211::RecipientQosMacDataService::managementFrameReceived().

processReceivedQoSFrame()

BlockAckReordering::ReorderBuffer inet::ieee80211::BlockAckReordering::processReceivedQoSFrame	(	RecipientBlockAckAgreement *	agreement,
		Packet *	dataPacket,
		const Ptr< const Ieee80211DataHeader > &	dataHeader
	)

{
    ReceiveBuffer *receiveBuffer = createReceiveBufferIfNecessary(agreement);
    // The reception of QoS data frames using Normal Ack policy shall not be used by the
    // recipient to reset the timer to detect Block Ack timeout (see 10.5.4).
    // This allows the recipient to delete the Block Ack if the originator does not switch
    // back to using Block Ack.
    if (receiveBuffer->insertFrame(dataPacket, dataHeader)) {
        if (dataHeader->getAckPolicy() == BLOCK_ACK)
            agreement->blockAckPolicyFrameReceived(dataHeader);
        auto earliestCompleteMsduOrAMsdu = getEarliestCompleteMsduOrAMsduIfExists(receiveBuffer);
        if (earliestCompleteMsduOrAMsdu.size() > 0) {
            auto earliestSequenceNumber = earliestCompleteMsduOrAMsdu.at(0)->peekAtFront<Ieee80211DataHeader>()->getSequenceNumber();
            // If, after an MPDU is received, the receive buffer is full, the complete MSDU or A-MSDU with the earliest
            // sequence number shall be passed up to the next MAC process.
            if (receiveBuffer->isFull()) {
                passedUp(agreement, receiveBuffer, earliestSequenceNumber);
                return ReorderBuffer({ std::make_pair(earliestSequenceNumber.get(), Fragments(earliestCompleteMsduOrAMsdu)) });
            }
            // If, after an MPDU is received, the receive buffer is not full, but the sequence number of the complete MSDU or
            // A-MSDU in the buffer with the lowest sequence number is equal to the NextExpectedSequenceNumber for
            // that Block Ack agreement, then the MPDU shall be passed up to the next MAC process.
            else if (earliestSequenceNumber == receiveBuffer->getNextExpectedSequenceNumber()) {
                passedUp(agreement, receiveBuffer, earliestSequenceNumber);
                return ReorderBuffer({ std::make_pair(earliestSequenceNumber.get(), Fragments(earliestCompleteMsduOrAMsdu)) });
            }
        }
    }
    else
        delete dataPacket;
    return ReorderBuffer({});
}

Referenced by inet::ieee80211::RecipientQosMacDataService::dataFrameReceived().

releaseReceiveBuffer()

void inet::ieee80211::BlockAckReordering::releaseReceiveBuffer ( RecipientBlockAckAgreement *  agreement, ReceiveBuffer *  receiveBuffer, const ReorderBuffer &  reorderBuffer  )

protected

{
    for (auto it : reorderBuffer) {
        auto sequenceNumber = it.first;
        passedUp(agreement, receiveBuffer, SequenceNumberCyclic(sequenceNumber));
    }
}

Referenced by processReceivedBlockAckReq().

Member Data Documentation

receiveBuffers

std::map<std::pair<Tid, MacAddress>, ReceiveBuffer *> inet::ieee80211::BlockAckReordering::receiveBuffers

protected

Referenced by createReceiveBufferIfNecessary(), processReceivedBlockAckReq(), processReceivedDelba(), and ~BlockAckReordering().

---

The documentation for this class was generated from the following files:

• BlockAckReordering.h
• BlockAckReordering.cc