inet::ieee80211::RecipientQosMacDataService Class Reference

#include <RecipientQosMacDataService.h>

Inheritance diagram for inet::ieee80211::RecipientQosMacDataService:

Public Member Functions
virtual std::vector< Packet * >	dataFrameReceived (Packet *dataPacket, const Ptr< const Ieee80211DataHeader > &dataHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler) override
virtual std::vector< Packet * >	controlFrameReceived (Packet *controlPacket, const Ptr< const Ieee80211MacHeader > &controlHeader, IRecipientBlockAckAgreementHandler *blockAckAgreementHandler) override
virtual std::vector< Packet * >	managementFrameReceived (Packet *mgmtPacket, const Ptr< const Ieee80211MgmtHeader > &mgmtHeader) override
Public Member Functions inherited from inet::ieee80211::IRecipientQosMacDataService
virtual	~IRecipientQosMacDataService ()

Protected Member Functions
virtual	~RecipientQosMacDataService ()
virtual void	initialize () override
virtual Packet *	defragment (std::vector< Packet * > completeFragments)
virtual Packet *	defragment (Packet *mgmtFragment)

Protected Attributes
IReassembly *	basicReassembly = nullptr
IMpduDeaggregation *	aMpduDeaggregation = nullptr
IDuplicateRemoval *	duplicateRemoval = nullptr
BlockAckReordering *	blockAckReordering = nullptr
IDefragmentation *	defragmentation = nullptr
IMsduDeaggregation *	aMsduDeaggregation = nullptr

Additional Inherited Members
Static Public Attributes inherited from inet::ieee80211::IRecipientQosMacDataService
static simsignal_t	packetDefragmentedSignal = cComponent::registerSignal("packetDefragmented")
static simsignal_t	packetDeaggregatedSignal = cComponent::registerSignal("packetDeaggregated")

Constructor & Destructor Documentation

~RecipientQosMacDataService()

inet::ieee80211::RecipientQosMacDataService::~RecipientQosMacDataService ( )

protectedvirtual

{
    delete duplicateRemoval;
    delete basicReassembly;
    delete aMsduDeaggregation;
    delete aMpduDeaggregation;
    delete blockAckReordering;
}

Member Function Documentation

controlFrameReceived()

std::vector< Packet * > inet::ieee80211::RecipientQosMacDataService::controlFrameReceived ( Packet *  controlPacket, const Ptr< const Ieee80211MacHeader > &  controlHeader, IRecipientBlockAckAgreementHandler *  blockAckAgreementHandler  )

overridevirtual

Implements inet::ieee80211::IRecipientQosMacDataService.

{
    Enter_Method("controlFrameReceived");
    if (auto blockAckReq = dynamicPtrCast<const Ieee80211BasicBlockAckReq>(controlHeader)) {
        BlockAckReordering::ReorderBuffer frames;
        if (blockAckReordering) {
            Tid tid = blockAckReq->getTidInfo();
            MacAddress originatorAddr = blockAckReq->getTransmitterAddress();
            RecipientBlockAckAgreement *agreement = blockAckAgreementHandler->getAgreement(tid, originatorAddr);
            if (agreement)
                frames = blockAckReordering->processReceivedBlockAckReq(agreement, blockAckReq);
            else
                return std::vector<Packet *>();
        }
        std::vector<Packet *> defragmentedFrames;
        if (basicReassembly) { // FIXME defragmentation
            for (auto it : frames) {
                auto fragments = it.second;
                defragmentedFrames.push_back(defragment(fragments));
            }
        }
        else {
            for (auto it : frames) {
                auto fragments = it.second;
                if (fragments.size() == 1) {
                    defragmentedFrames.push_back(fragments.at(0));
                }
                else {
                    // TODO drop?
                }
            }
        }
        std::vector<Packet *> deaggregatedFrames;
        if (aMsduDeaggregation) {
            for (auto frame : defragmentedFrames) {
                if (frame->peekAtFront<Ieee80211DataHeader>()->getAMsduPresent()) {
                    emit(packetDeaggregatedSignal, frame);
                    auto subframes = aMsduDeaggregation->deaggregateFrame(frame);
                    for (auto subframe : *subframes)
                        deaggregatedFrames.push_back(subframe);
                    delete subframes;
                }
                else
                    deaggregatedFrames.push_back(frame);
            }
        }
        // TODO MSDU Integrity, Replay Detection, RX MSDU Rate Limiting
        return deaggregatedFrames;
    }
    return std::vector<Packet *>();
}

dataFrameReceived()

std::vector< Packet * > inet::ieee80211::RecipientQosMacDataService::dataFrameReceived ( Packet *  dataPacket, const Ptr< const Ieee80211DataHeader > &  dataHeader, IRecipientBlockAckAgreementHandler *  blockAckAgreementHandler  )

overridevirtual

Implements inet::ieee80211::IRecipientQosMacDataService.

{
    Enter_Method("dataFrameReceived");
    take(dataPacket);
    // TODO A-MPDU Deaggregation, MPDU Header+CRC Validation, Address1 Filtering, Duplicate Removal, MPDU Decryption
    if (duplicateRemoval && duplicateRemoval->isDuplicate(dataHeader)) {
        EV_WARN << "Dropping duplicate packet " << *dataPacket << ".\n";
        PacketDropDetails details;
        details.setReason(DUPLICATE_DETECTED);
        emit(packetDroppedSignal, dataPacket, &details);
        delete dataPacket;
        return std::vector<Packet *>();
    }
    BlockAckReordering::ReorderBuffer frames;
    frames[dataHeader->getSequenceNumber().get()].push_back(dataPacket);
    if (blockAckReordering && blockAckAgreementHandler) {
        Tid tid = dataHeader->getTid();
        MacAddress originatorAddr = dataHeader->getTransmitterAddress();
        RecipientBlockAckAgreement *agreement = blockAckAgreementHandler->getAgreement(tid, originatorAddr);
        if (agreement)
            frames = blockAckReordering->processReceivedQoSFrame(agreement, dataPacket, dataHeader);
    }
    std::vector<Packet *> defragmentedFrames;
    if (basicReassembly) { // FIXME defragmentation
        for (auto it : frames) {
            auto fragments = it.second;
            Packet *frame = defragment(fragments);
            // TODO revise
            if (frame)
                defragmentedFrames.push_back(frame);
        }
    }
    else {
        for (auto it : frames) {
            auto fragments = it.second;
            if (fragments.size() == 1)
                defragmentedFrames.push_back(fragments.at(0));
            else ; // TODO drop?
        }
    }
    std::vector<Packet *> deaggregatedFrames;
    if (aMsduDeaggregation) {
        for (auto defragmentedFrame : defragmentedFrames) {
            auto defragmentedHeader = defragmentedFrame->peekAtFront<Ieee80211DataHeader>();
            if (defragmentedHeader->getAMsduPresent()) {
                emit(packetDeaggregatedSignal, defragmentedFrame);
                auto subframes = aMsduDeaggregation->deaggregateFrame(defragmentedFrame);
                for (auto subframe : *subframes)
                    deaggregatedFrames.push_back(subframe);
                delete subframes;
            }
            else
                deaggregatedFrames.push_back(defragmentedFrame);
        }
    }
    // TODO MSDU Integrity, Replay Detection, RX MSDU Rate Limiting
    return deaggregatedFrames;
}

defragment() [1/2]

Packet * inet::ieee80211::RecipientQosMacDataService::defragment ( Packet *  mgmtFragment )

protectedvirtual

{
    auto packet = basicReassembly->addFragment(mgmtFragment);
    if (packet && packet->hasAtFront<Ieee80211DataOrMgmtHeader>()) {
        emit(packetDefragmentedSignal, packet);
        return packet;
    }
    else
        return nullptr;
}

defragment() [2/2]

Packet * inet::ieee80211::RecipientQosMacDataService::defragment ( std::vector< Packet * >  completeFragments )

protectedvirtual

{
    for (auto fragment : completeFragments) {
        auto packet = basicReassembly->addFragment(fragment);
        if (packet != nullptr) {
            emit(packetDefragmentedSignal, packet);
            return packet;
        }
    }
    return nullptr;
}

Referenced by controlFrameReceived(), dataFrameReceived(), and managementFrameReceived().

initialize()

void inet::ieee80211::RecipientQosMacDataService::initialize ( )

overrideprotectedvirtual

{
    duplicateRemoval = new QoSDuplicateRemoval();
    basicReassembly = new BasicReassembly();
    aMsduDeaggregation = new MsduDeaggregation();
    aMpduDeaggregation = new MpduDeaggregation();
    blockAckReordering = new BlockAckReordering();
}

managementFrameReceived()

std::vector< Packet * > inet::ieee80211::RecipientQosMacDataService::managementFrameReceived ( Packet *  mgmtPacket, const Ptr< const Ieee80211MgmtHeader > &  mgmtHeader  )

overridevirtual

Implements inet::ieee80211::IRecipientQosMacDataService.

{
    Enter_Method("managementFrameReceived");
    take(mgmtPacket);
    // TODO MPDU Header+CRC Validation, Address1 Filtering, Duplicate Removal, MPDU Decryption
    if (duplicateRemoval && duplicateRemoval->isDuplicate(mgmtHeader))
        return std::vector<Packet *>();
    if (basicReassembly) { // FIXME defragmentation
        mgmtPacket = defragment(mgmtPacket);
    }
    if (auto delba = dynamicPtrCast<const Ieee80211Delba>(mgmtHeader))
        blockAckReordering->processReceivedDelba(delba);
    // TODO Defrag, MSDU Integrity, Replay Detection, RX MSDU Rate Limiting
    if (dynamicPtrCast<const Ieee80211ActionFrame>(mgmtHeader)) {
        delete mgmtPacket;
        return std::vector<Packet *>();
    }
    else
        return std::vector<Packet *>({ mgmtPacket });
}

Member Data Documentation

aMpduDeaggregation

IMpduDeaggregation* inet::ieee80211::RecipientQosMacDataService::aMpduDeaggregation = nullptr

protected

Referenced by initialize(), and ~RecipientQosMacDataService().

aMsduDeaggregation

IMsduDeaggregation* inet::ieee80211::RecipientQosMacDataService::aMsduDeaggregation = nullptr

protected

Referenced by controlFrameReceived(), dataFrameReceived(), initialize(), and ~RecipientQosMacDataService().

basicReassembly

IReassembly* inet::ieee80211::RecipientQosMacDataService::basicReassembly = nullptr

protected

Referenced by controlFrameReceived(), dataFrameReceived(), defragment(), initialize(), managementFrameReceived(), and ~RecipientQosMacDataService().

blockAckReordering

BlockAckReordering* inet::ieee80211::RecipientQosMacDataService::blockAckReordering = nullptr

protected

Referenced by controlFrameReceived(), dataFrameReceived(), initialize(), managementFrameReceived(), and ~RecipientQosMacDataService().

defragmentation

IDefragmentation* inet::ieee80211::RecipientQosMacDataService::defragmentation = nullptr

protected

duplicateRemoval

IDuplicateRemoval* inet::ieee80211::RecipientQosMacDataService::duplicateRemoval = nullptr

protected

Referenced by dataFrameReceived(), initialize(), managementFrameReceived(), and ~RecipientQosMacDataService().

---

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

• RecipientQosMacDataService.h
• RecipientQosMacDataService.cc