inet::ieee80211::BlockAckReordering Class Reference

#include <BlockAckReordering.h>

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

Public Member Functions
virtual	~BlockAckReordering ()
void	processReceivedDelba (Ieee80211Delba *delba)
ReorderBuffer	processReceivedQoSFrame (RecipientBlockAckAgreement *agreement, Ieee80211DataFrame *dataFrame)
ReorderBuffer	processReceivedBlockAckReq (Ieee80211BlockAckReq *frame)

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

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

Member Typedef Documentation

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

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

Constructor & Destructor Documentation

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

virtual

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

Member Function Documentation

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

protected

Referenced by collectConsecutiveCompleteFollowingMpdus().

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

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

protected

Referenced by processReceivedBlockAckReq().

{
    ASSERT(startingSequenceNumber != -1);
    ReorderBuffer completePrecedingMpdus;
    const auto& buffer = receiveBuffer->getBuffer();
    for (auto it : buffer) { // collects complete preceding MPDUs
        int sequenceNumber = it.first;
        auto fragments = it.second;
        if (isSequenceNumberLess(sequenceNumber, startingSequenceNumber, receiveBuffer->getNextExpectedSequenceNumber(), receiveBuffer->getBufferSize()))
            if (isComplete(fragments))
                completePrecedingMpdus[sequenceNumber] = fragments;
    }
    return completePrecedingMpdus;
}

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

protected

Referenced by processReceivedBlockAckReq().

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

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

protected

Referenced by processReceivedQoSFrame().

{
    SequenceNumber 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;
}

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

protected

Referenced by processReceivedQoSFrame().

{
    Fragments earliestFragments = Fragments();
    SequenceNumber earliestSeqNum = 0;
    const auto& buffer = receiveBuffer->getBuffer();
    for (auto it : buffer) {
        if (isComplete(it.second)) {
            earliestFragments = it.second;
            earliestSeqNum = earliestFragments.at(0)->getSequenceNumber();
            break;
        }
    }
    if (earliestFragments.size() > 0) {
        for (auto it : buffer) {
            SequenceNumber currentSeqNum = it.second.at(0)->getSequenceNumber();
            if (isSequenceNumberLess(currentSeqNum, earliestSeqNum, receiveBuffer->getNextExpectedSequenceNumber(), receiveBuffer->getBufferSize())) {
                if (isComplete(it.second)) {
                    earliestFragments = it.second;
                    earliestSeqNum = currentSeqNum;
                }
            }
        }
    }
    return earliestFragments;
}

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

protected

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

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

void inet::ieee80211::BlockAckReordering::passedUp ( ReceiveBuffer *  receiveBuffer, int  sequenceNumber  )

protected

Referenced by processReceivedQoSFrame(), and releaseReceiveBuffer().

{
    // 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) % 4096);
    receiveBuffer->remove(sequenceNumber);
}

BlockAckReordering::ReorderBuffer inet::ieee80211::BlockAckReordering::processReceivedBlockAckReq

(

Ieee80211BlockAckReq *

frame

)

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

{
    // The originator shall use the Block Ack starting sequence control to signal the first MPDU in the block for
    // which an acknowledgment is expected.
    int startingSequenceNumber = -1;
    Tid tid = -1;
    if (auto basicReq = dynamic_cast<Ieee80211BasicBlockAckReq*>(frame)) {
        tid = basicReq->getTidInfo();
        startingSequenceNumber = basicReq->getStartingSequenceNumber();
    }
    else if (auto compressedReq = dynamic_cast<Ieee80211CompressedBlockAck*>(frame)) {
        tid = compressedReq->getTidInfo();
        startingSequenceNumber = compressedReq->getStartingSequenceNumber();
    }
    else {
        throw cRuntimeError("Multi-Tid BlockAckReq is currently an unimplemented feature");
    }
    auto id = std::make_pair(tid, frame->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  && isSequenceNumberLess(receiveBuffer->getNextExpectedSequenceNumber(), startingSequenceNumber, receiveBuffer->getNextExpectedSequenceNumber(), receiveBuffer->getBufferSize()))
            receiveBuffer->setNextExpectedSequenceNumber(startingSequenceNumber);
        // The recipient shall then release any buffers held by preceding MPDUs.
        releaseReceiveBuffer(receiveBuffer, completePrecedingMpdus);
        releaseReceiveBuffer(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();
}

void inet::ieee80211::BlockAckReordering::processReceivedDelba

(

Ieee80211Delba *

delba

)

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

{
    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;
}

BlockAckReordering::ReorderBuffer inet::ieee80211::BlockAckReordering::processReceivedQoSFrame	(	RecipientBlockAckAgreement *	agreement,
		Ieee80211DataFrame *	dataFrame
	)

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

{
    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(dataFrame)) {
        if (dataFrame->getAckPolicy() == BLOCK_ACK)
            agreement->blockAckPolicyFrameReceived(dataFrame);
        auto earliestCompleteMsduOrAMsdu = getEarliestCompleteMsduOrAMsduIfExists(receiveBuffer);
        if (earliestCompleteMsduOrAMsdu.size() > 0) {
            int earliestSequenceNumber = earliestCompleteMsduOrAMsdu.at(0)->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(receiveBuffer, earliestSequenceNumber);
                return ReorderBuffer({std::make_pair(earliestSequenceNumber, 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(receiveBuffer, earliestSequenceNumber);
                return ReorderBuffer({std::make_pair(earliestSequenceNumber, Fragments(earliestCompleteMsduOrAMsdu))});
            }
        }
    }
    else
        delete dataFrame;
    return ReorderBuffer({});
}

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

protected

Referenced by processReceivedBlockAckReq().

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

Member Data Documentation

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