inet::ieee80211::QosAckHandler Class Reference

#include <QosAckHandler.h>

Inheritance diagram for inet::ieee80211::QosAckHandler:

Public Types
enum	Status {   Status::FRAME_NOT_YET_TRANSMITTED, Status::NO_ACK_REQUIRED, Status::BLOCK_ACK_NOT_YET_REQUESTED, Status::WAITING_FOR_NORMAL_ACK,   Status::WAITING_FOR_BLOCK_ACK, Status::NORMAL_ACK_NOT_ARRIVED, Status::NORMAL_ACK_ARRIVED, Status::BLOCK_ACK_ARRIVED_UNACKED,   Status::BLOCK_ACK_ARRIVED_ACKED, Status::BLOCK_ACK_NOT_ARRIVED }

Public Member Functions
virtual	~QosAckHandler ()
virtual void	processReceivedAck (const Ptr< const Ieee80211AckFrame > &ack, const Ptr< const Ieee80211DataOrMgmtHeader > &ackedHeader)
virtual std::set< std::pair< MacAddress, std::pair< Tid, SequenceControlField > > >	processReceivedBlockAck (const Ptr< const Ieee80211BlockAck > &blockAck)
virtual void	processFailedBlockAckReq (const Ptr< const Ieee80211BlockAckReq > &blockAckReq)
virtual void	frameGotInProgress (const Ptr< const Ieee80211DataOrMgmtHeader > &dataOrMgmtHeader) override
virtual void	processTransmittedDataOrMgmtFrame (const Ptr< const Ieee80211DataOrMgmtHeader > &header)
virtual void	processTransmittedBlockAckReq (const Ptr< const Ieee80211BlockAckReq > &blockAckReq)
virtual void	processFailedFrame (const Ptr< const Ieee80211DataOrMgmtHeader > &dataOrMgmtHeader)
virtual void	dropFrame (const Ptr< const Ieee80211DataOrMgmtHeader > &dataOrMgmtHeader)
virtual void	dropFrames (std::set< std::pair< MacAddress, std::pair< Tid, SequenceControlField >>> seqAndFragNums)
virtual Status	getQoSDataAckStatus (const Ptr< const Ieee80211DataHeader > &header)
virtual Status	getMgmtOrNonQoSAckStatus (const Ptr< const Ieee80211DataOrMgmtHeader > &header)
virtual bool	isEligibleToTransmit (const Ptr< const Ieee80211DataOrMgmtHeader > &header) override
virtual bool	isOutstandingFrame (const Ptr< const Ieee80211DataOrMgmtHeader > &header) override
Public Member Functions inherited from inet::ieee80211::IAckHandler
virtual	~IAckHandler ()

Static Public Member Functions
static std::string	getStatusString (Status status)

Protected Types
typedef std::pair< MacAddress, std::pair< Tid, SequenceControlField > >	QoSKey
typedef std::pair< MacAddress, SequenceControlField >	Key

Protected Member Functions
virtual void	initialize (int stage) override
virtual Status	getQoSDataAckStatus (const QoSKey &id)
virtual Status	getMgmtOrNonQoSAckStatus (const Key &id)
void	printAckStatuses ()

Protected Attributes
std::map< QoSKey, Status >	ackStatuses
std::map< Key, Status >	mgmtAckStatuses

Member Typedef Documentation

Key

typedef std::pair<MacAddress, SequenceControlField> inet::ieee80211::QosAckHandler::Key

protected

QoSKey

typedef std::pair<MacAddress, std::pair<Tid, SequenceControlField> > inet::ieee80211::QosAckHandler::QoSKey

protected

Member Enumeration Documentation

Status

enum inet::ieee80211::QosAckHandler::Status

strong

Enumerator
FRAME_NOT_YET_TRANSMITTED
NO_ACK_REQUIRED
BLOCK_ACK_NOT_YET_REQUESTED
WAITING_FOR_NORMAL_ACK
WAITING_FOR_BLOCK_ACK
NORMAL_ACK_NOT_ARRIVED
NORMAL_ACK_ARRIVED
BLOCK_ACK_ARRIVED_UNACKED
BLOCK_ACK_ARRIVED_ACKED
BLOCK_ACK_NOT_ARRIVED

                      {
        FRAME_NOT_YET_TRANSMITTED,
        NO_ACK_REQUIRED,
        BLOCK_ACK_NOT_YET_REQUESTED,
        WAITING_FOR_NORMAL_ACK,
        WAITING_FOR_BLOCK_ACK,
        NORMAL_ACK_NOT_ARRIVED,
        NORMAL_ACK_ARRIVED,
        BLOCK_ACK_ARRIVED_UNACKED,
        BLOCK_ACK_ARRIVED_ACKED,
        BLOCK_ACK_NOT_ARRIVED
    };

Constructor & Destructor Documentation

~QosAckHandler()

virtual inet::ieee80211::QosAckHandler::~QosAckHandler ( )

inlinevirtual

{}

Member Function Documentation

dropFrame()

void inet::ieee80211::QosAckHandler::dropFrame ( const Ptr< const Ieee80211DataOrMgmtHeader > &  dataOrMgmtHeader )

virtual

{
    if (dataOrMgmtHeader->getType() == ST_DATA_WITH_QOS) {
        auto dataHeader = dynamicPtrCast<const Ieee80211DataHeader>(dataOrMgmtHeader);
        auto id = std::make_pair(dataHeader->getReceiverAddress(), std::make_pair(dataHeader->getTid(), SequenceControlField(dataHeader->getSequenceNumber().get(), dataHeader->getFragmentNumber())));
        ackStatuses.erase(id);
    }
    else {
        auto id = std::make_pair(dataOrMgmtHeader->getReceiverAddress(), SequenceControlField(dataOrMgmtHeader->getSequenceNumber().get(), dataOrMgmtHeader->getFragmentNumber()));
        mgmtAckStatuses.erase(id);
    }
}

dropFrames()

void inet::ieee80211::QosAckHandler::dropFrames ( std::set< std::pair< MacAddress, std::pair< Tid, SequenceControlField >>>  seqAndFragNums )

virtual

{
    for (auto it : seqAndFragNums)
        ackStatuses.erase(it);
}

frameGotInProgress()

void inet::ieee80211::QosAckHandler::frameGotInProgress ( const Ptr< const Ieee80211DataOrMgmtHeader > &  dataOrMgmtHeader )

overridevirtual

Implements inet::ieee80211::IAckHandler.

{
    if (dataOrMgmtHeader->getType() == ST_DATA_WITH_QOS) {
        auto dataHeader = dynamicPtrCast<const Ieee80211DataHeader>(dataOrMgmtHeader);
        auto id = std::make_pair(dataHeader->getReceiverAddress(), std::make_pair(dataHeader->getTid(), SequenceControlField(dataHeader->getSequenceNumber().get(), dataHeader->getFragmentNumber())));
        auto status = getQoSDataAckStatus(id);
        ASSERT(status != Status::WAITING_FOR_NORMAL_ACK && status != Status::BLOCK_ACK_NOT_YET_REQUESTED && status != Status::WAITING_FOR_BLOCK_ACK);
        ackStatuses[id] = Status::FRAME_NOT_YET_TRANSMITTED;
    }
    else {
        auto id = std::make_pair(dataOrMgmtHeader->getReceiverAddress(), SequenceControlField(dataOrMgmtHeader->getSequenceNumber().get(), dataOrMgmtHeader->getFragmentNumber()));
        auto status = getMgmtOrNonQoSAckStatus(id);
        ASSERT(status != Status::WAITING_FOR_NORMAL_ACK);
        mgmtAckStatuses[id] = Status::FRAME_NOT_YET_TRANSMITTED;
    }
}

getMgmtOrNonQoSAckStatus() [1/2]

QosAckHandler::Status inet::ieee80211::QosAckHandler::getMgmtOrNonQoSAckStatus ( const Key &  id )

protectedvirtual

{
    auto it = mgmtAckStatuses.find(id);
    return (it != mgmtAckStatuses.end()) ? it->second : Status::FRAME_NOT_YET_TRANSMITTED;
}

Referenced by frameGotInProgress(), getMgmtOrNonQoSAckStatus(), isEligibleToTransmit(), processFailedFrame(), and processReceivedAck().

getMgmtOrNonQoSAckStatus() [2/2]

QosAckHandler::Status inet::ieee80211::QosAckHandler::getMgmtOrNonQoSAckStatus ( const Ptr< const Ieee80211DataOrMgmtHeader > &  header )

virtual

{
    auto id = std::make_pair(header->getReceiverAddress(), SequenceControlField(header->getSequenceNumber().get(), header->getFragmentNumber()));
    return getMgmtOrNonQoSAckStatus(id);
}

getQoSDataAckStatus() [1/2]

QosAckHandler::Status inet::ieee80211::QosAckHandler::getQoSDataAckStatus ( const Ptr< const Ieee80211DataHeader > &  header )

virtual

{
    auto id = std::make_pair(header->getReceiverAddress(), std::make_pair(header->getTid(), SequenceControlField(header->getSequenceNumber().get(), header->getFragmentNumber())));
    return getQoSDataAckStatus(id);
}

getQoSDataAckStatus() [2/2]

QosAckHandler::Status inet::ieee80211::QosAckHandler::getQoSDataAckStatus ( const QoSKey &  id )

protectedvirtual

{
    auto it = ackStatuses.find(id);
    return (it != ackStatuses.end()) ? it->second : Status::FRAME_NOT_YET_TRANSMITTED;
}

Referenced by frameGotInProgress(), getQoSDataAckStatus(), isEligibleToTransmit(), isOutstandingFrame(), processFailedBlockAckReq(), processFailedFrame(), processReceivedAck(), and processReceivedBlockAck().

getStatusString()

std::string inet::ieee80211::QosAckHandler::getStatusString ( Status  status )

static

{
    switch (status) {
        case Status::FRAME_NOT_YET_TRANSMITTED: return "FRAME_NOT_YET_TRANSMITTED";
        case Status::NO_ACK_REQUIRED: return "NO_ACK_REQUIRED";
        case Status::BLOCK_ACK_NOT_YET_REQUESTED: return "BLOCK_ACK_NOT_YET_REQUESTED";
        case Status::WAITING_FOR_NORMAL_ACK: return "WAITING_FOR_NORMAL_ACK";
        case Status::NORMAL_ACK_NOT_ARRIVED: return "NORMAL_ACK_NOT_ARRIVED";
        case Status::BLOCK_ACK_ARRIVED_UNACKED: return "BLOCK_ACK_ARRIVED_UNACKED";
        case Status::BLOCK_ACK_ARRIVED_ACKED: return "BLOCK_ACK_ARRIVED_ACKED";
        case Status::WAITING_FOR_BLOCK_ACK: return "WAITING_FOR_BLOCK_ACK";
        case Status::NORMAL_ACK_ARRIVED: return "NORMAL_ACK_ARRIVED";
        default: throw cRuntimeError("Unknown status");
    }
}

Referenced by inet::ieee80211::operator<<(), and printAckStatuses().

initialize()

void inet::ieee80211::QosAckHandler::initialize ( int  stage )

overrideprotectedvirtual

{
    if (stage == INITSTAGE_LOCAL) {
        WATCH_MAP(ackStatuses);
        WATCH_MAP(mgmtAckStatuses);
    }
}

isEligibleToTransmit()

bool inet::ieee80211::QosAckHandler::isEligibleToTransmit ( const Ptr< const Ieee80211DataOrMgmtHeader > &  header )

overridevirtual

Implements inet::ieee80211::IAckHandler.

{
    QosAckHandler::Status status;
    if (header->getType() == ST_DATA_WITH_QOS) {
        auto dataHeader = dynamicPtrCast<const Ieee80211DataHeader>(header);
        status = getQoSDataAckStatus(dataHeader);
    }
    else
        status = getMgmtOrNonQoSAckStatus(header);
    return status == QosAckHandler::Status::NO_ACK_REQUIRED ||
           status == QosAckHandler::Status::NORMAL_ACK_NOT_ARRIVED ||
           status == QosAckHandler::Status::BLOCK_ACK_NOT_ARRIVED ||
           status == QosAckHandler::Status::BLOCK_ACK_ARRIVED_UNACKED ||
           status == QosAckHandler::Status::FRAME_NOT_YET_TRANSMITTED;
}

isOutstandingFrame()

bool inet::ieee80211::QosAckHandler::isOutstandingFrame ( const Ptr< const Ieee80211DataOrMgmtHeader > &  header )

overridevirtual

Implements inet::ieee80211::IAckHandler.

{
    if (header->getType() == ST_DATA_WITH_QOS) {
        auto dataHeader = dynamicPtrCast<const Ieee80211DataHeader>(header);
        auto status = getQoSDataAckStatus(dataHeader);
        return status == QosAckHandler::Status::BLOCK_ACK_NOT_YET_REQUESTED;
    }
    else
        return false;
}

printAckStatuses()

void inet::ieee80211::QosAckHandler::printAckStatuses ( )

protected

{
    for (auto ackStatus : ackStatuses) {
        std::cout << "Seq Num = " << ackStatus.first.second.second.getSequenceNumber() << " " << "Frag Num = " << (int)ackStatus.first.second.second.getFragmentNumber() << std::endl;
        std::cout << "Status = " << getStatusString(ackStatus.second) << std::endl;
    }
    std::cout << "=========================================" << std::endl;
}

processFailedBlockAckReq()

void inet::ieee80211::QosAckHandler::processFailedBlockAckReq ( const Ptr< const Ieee80211BlockAckReq > &  blockAckReq )

virtual

{
    if (auto basicBlockAckReq = dynamicPtrCast<const Ieee80211BasicBlockAckReq>(blockAckReq)) {
        auto startingSeqNum = basicBlockAckReq->getStartingSequenceNumber();
        for (int seqNum = 0; seqNum < 64; seqNum++) {
            for (int fragNum = 0; fragNum < 16; fragNum++) { // TODO declare these const values
                MacAddress receiverAddr = blockAckReq->getReceiverAddress();
                auto id = std::make_pair(receiverAddr, std::make_pair(basicBlockAckReq->getTidInfo(), SequenceControlField((startingSeqNum + seqNum).get(), fragNum)));
                auto status = getQoSDataAckStatus(id);
                if (status == Status::WAITING_FOR_BLOCK_ACK)
                    ackStatuses[id] = Status::BLOCK_ACK_NOT_ARRIVED;
            }
        }
    }
    else if (auto compressedBlockAckReq = dynamicPtrCast<const Ieee80211CompressedBlockAckReq>(blockAckReq)) {
        auto startingSeqNum = compressedBlockAckReq->getStartingSequenceNumber();
        for (int seqNum = 0; seqNum < 64; seqNum++) {
            MacAddress receiverAddr = blockAckReq->getReceiverAddress();
            auto id = std::make_pair(receiverAddr, std::make_pair(compressedBlockAckReq->getTidInfo(), SequenceControlField((startingSeqNum + seqNum).get(), 0)));
            auto status = getQoSDataAckStatus(id);
            if (status == Status::WAITING_FOR_BLOCK_ACK)
                ackStatuses[id] = Status::BLOCK_ACK_NOT_ARRIVED;
        }
    }
    else
        throw cRuntimeError("Unknown block ack request");
}

processFailedFrame()

void inet::ieee80211::QosAckHandler::processFailedFrame ( const Ptr< const Ieee80211DataOrMgmtHeader > &  dataOrMgmtHeader )

virtual

{
    if (dataOrMgmtHeader->getType() == ST_DATA_WITH_QOS) {
        auto dataHeader = dynamicPtrCast<const Ieee80211DataHeader>(dataOrMgmtHeader);
        auto id = std::make_pair(dataHeader->getReceiverAddress(), std::make_pair(dataHeader->getTid(), SequenceControlField(dataHeader->getSequenceNumber().get(), dataHeader->getFragmentNumber())));
        auto status = getQoSDataAckStatus(id);
        if (status == Status::WAITING_FOR_NORMAL_ACK)
            ackStatuses[id] = Status::NORMAL_ACK_NOT_ARRIVED;
        else if (status == Status::WAITING_FOR_BLOCK_ACK)
            ackStatuses[id] = Status::BLOCK_ACK_NOT_ARRIVED;
        else
            throw cRuntimeError("Invalid ACK status");
    }
    else {
        ASSERT(getMgmtOrNonQoSAckStatus(dataOrMgmtHeader) == Status::WAITING_FOR_NORMAL_ACK);
        auto id = std::make_pair(dataOrMgmtHeader->getReceiverAddress(), SequenceControlField(dataOrMgmtHeader->getSequenceNumber().get(), dataOrMgmtHeader->getFragmentNumber()));
        mgmtAckStatuses[id] = Status::NORMAL_ACK_NOT_ARRIVED;
    }
}

processReceivedAck()

void inet::ieee80211::QosAckHandler::processReceivedAck ( const Ptr< const Ieee80211AckFrame > &  ack, const Ptr< const Ieee80211DataOrMgmtHeader > &  ackedHeader  )

virtual

{
    if (ackedHeader->getType() == ST_DATA_WITH_QOS) {
        auto dataHeader = dynamicPtrCast<const Ieee80211DataHeader>(ackedHeader);
        auto id = std::make_pair(dataHeader->getReceiverAddress(), std::make_pair(dataHeader->getTid(), SequenceControlField(dataHeader->getSequenceNumber().get(), dataHeader->getFragmentNumber())));
        auto status = getQoSDataAckStatus(id);
        if (status == Status::FRAME_NOT_YET_TRANSMITTED)
            throw cRuntimeError("ackedFrame = %s is not yet transmitted", dataHeader->getName());
        ackStatuses[id] = Status::NORMAL_ACK_ARRIVED;
    }
    else {
        auto id = std::make_pair(ackedHeader->getReceiverAddress(), SequenceControlField(ackedHeader->getSequenceNumber().get(), ackedHeader->getFragmentNumber()));
        auto status = getMgmtOrNonQoSAckStatus(id);
        if (status == Status::FRAME_NOT_YET_TRANSMITTED)
            throw cRuntimeError("ackedFrame = %s is not yet transmitted", ackedHeader->getName());
        mgmtAckStatuses[id] = Status::NORMAL_ACK_ARRIVED;
    }
}

processReceivedBlockAck()

std::set< std::pair< MacAddress, std::pair< Tid, SequenceControlField > > > inet::ieee80211::QosAckHandler::processReceivedBlockAck ( const Ptr< const Ieee80211BlockAck > &  blockAck )

virtual

{
    MacAddress receiverAddr = blockAck->getTransmitterAddress();
    std::set<QoSKey> ackedFrames;
    // Table 8-16—BlockAckReq frame variant encoding
    if (auto basicBlockAck = dynamicPtrCast<const Ieee80211BasicBlockAck>(blockAck)) {
        auto startingSeqNum = basicBlockAck->getStartingSequenceNumber();
        for (int seqNum = 0; seqNum < 64; seqNum++) {
            BitVector bitmap = basicBlockAck->getBlockAckBitmap(seqNum);
            for (int fragNum = 0; fragNum < 16; fragNum++) { // TODO declare these const values
                auto id = std::make_pair(receiverAddr, std::make_pair(basicBlockAck->getTidInfo(), SequenceControlField((startingSeqNum + seqNum).get(), fragNum)));
                auto status = getQoSDataAckStatus(id);
                if (status == Status::WAITING_FOR_BLOCK_ACK) {
                    bool acked = bitmap.getBit(fragNum) == 1;
                    if (acked) ackedFrames.insert(id);
                    ackStatuses[id] = acked ? Status::BLOCK_ACK_ARRIVED_ACKED : Status::BLOCK_ACK_ARRIVED_UNACKED;
                }
                else ; // TODO erroneous BlockAck
            }
        }
    }
    else if (auto compressedBlockAck = dynamicPtrCast<const Ieee80211CompressedBlockAck>(blockAck)) {
        auto startingSeqNum = compressedBlockAck->getStartingSequenceNumber();
        BitVector bitmap = compressedBlockAck->getBlockAckBitmap();
        for (int seqNum = 0; seqNum < 64; seqNum++) {
            auto id = std::make_pair(receiverAddr, std::make_pair(compressedBlockAck->getTidInfo(), SequenceControlField((startingSeqNum + seqNum).get(), 0)));
            auto status = getQoSDataAckStatus(id);
            if (status == Status::WAITING_FOR_BLOCK_ACK) {
                bool acked = bitmap.getBit(seqNum) == 1;
                ackStatuses[id] = acked ? Status::BLOCK_ACK_ARRIVED_ACKED : Status::BLOCK_ACK_ARRIVED_UNACKED;
                if (acked) ackedFrames.insert(id);
            }
            else ; // TODO erroneous BlockAck
        }
    }
    else {
        throw cRuntimeError("Multi-TID BlockReq is unimplemented");
    }
    return ackedFrames;
}

processTransmittedBlockAckReq()

void inet::ieee80211::QosAckHandler::processTransmittedBlockAckReq ( const Ptr< const Ieee80211BlockAckReq > &  blockAckReq )

virtual

{
    for (auto& ackStatus : ackStatuses) {
        auto tid = ackStatus.first.second.first;
        auto seqCtrlField = ackStatus.first.second.second;
        auto& status = ackStatus.second;
        if (auto basicBlockAckReq = dynamicPtrCast<const Ieee80211BasicBlockAckReq>(blockAckReq)) {
            if (basicBlockAckReq->getTidInfo() == tid) {
                auto startingSeqNum = basicBlockAckReq->getStartingSequenceNumber();
                if (status == Status::BLOCK_ACK_NOT_YET_REQUESTED && SequenceNumberCyclic(seqCtrlField.getSequenceNumber()) >= startingSeqNum)
                    status = Status::WAITING_FOR_BLOCK_ACK;
            }
        }
        else if (auto compressedBlockAckReq = dynamicPtrCast<const Ieee80211CompressedBlockAckReq>(blockAckReq)) {
            if (compressedBlockAckReq->getTidInfo() == tid) {
                auto startingSeqNum = compressedBlockAckReq->getStartingSequenceNumber();
                if (status == Status::BLOCK_ACK_NOT_YET_REQUESTED && SequenceNumberCyclic(seqCtrlField.getSequenceNumber()) >= startingSeqNum && seqCtrlField.getFragmentNumber() == 0) // TODO ASSERT(seqCtrlField.second == 0)?
                    status = Status::WAITING_FOR_BLOCK_ACK;
            }
        }
        else
            throw cRuntimeError("Multi-TID BlockReq is unimplemented");
    }
}

processTransmittedDataOrMgmtFrame()

void inet::ieee80211::QosAckHandler::processTransmittedDataOrMgmtFrame ( const Ptr< const Ieee80211DataOrMgmtHeader > &  header )

virtual

{
    if (header->getType() == ST_DATA_WITH_QOS) {
        auto dataHeader = dynamicPtrCast<const Ieee80211DataHeader>(header);
        auto id = std::make_pair(dataHeader->getReceiverAddress(), std::make_pair(dataHeader->getTid(), SequenceControlField(dataHeader->getSequenceNumber().get(), dataHeader->getFragmentNumber())));
        switch (dataHeader->getAckPolicy()) {
            case NORMAL_ACK : ackStatuses[id] = Status::WAITING_FOR_NORMAL_ACK; break;
            case BLOCK_ACK : ackStatuses[id] = Status::BLOCK_ACK_NOT_YET_REQUESTED; break;
            case NO_ACK : ackStatuses[id] = Status::NO_ACK_REQUIRED; break;
            case NO_EXPLICIT_ACK : throw cRuntimeError("Unimplemented"); /* TODO ACKED by default? */ break;
            default: throw cRuntimeError("Unknown Ack Policy = %d", dataHeader->getAckPolicy());
        }
    }
    else
        mgmtAckStatuses[std::make_pair(header->getReceiverAddress(), SequenceControlField(header->getSequenceNumber().get(), header->getFragmentNumber()))] = Status::WAITING_FOR_NORMAL_ACK;
}

Member Data Documentation

ackStatuses

std::map<QoSKey, Status> inet::ieee80211::QosAckHandler::ackStatuses

protected

Referenced by dropFrame(), dropFrames(), frameGotInProgress(), getQoSDataAckStatus(), initialize(), printAckStatuses(), processFailedBlockAckReq(), processFailedFrame(), processReceivedAck(), processReceivedBlockAck(), processTransmittedBlockAckReq(), and processTransmittedDataOrMgmtFrame().

mgmtAckStatuses

std::map<Key, Status> inet::ieee80211::QosAckHandler::mgmtAckStatuses

protected

Referenced by dropFrame(), frameGotInProgress(), getMgmtOrNonQoSAckStatus(), initialize(), processFailedFrame(), processReceivedAck(), and processTransmittedDataOrMgmtFrame().

---

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

• QosAckHandler.h
• QosAckHandler.cc