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 }

Public Member Functions
virtual	~QoSAckHandler ()
virtual void	processReceivedAck (Ieee80211ACKFrame *ack, Ieee80211DataOrMgmtFrame *ackedFrame)
virtual std::set< std::pair< MACAddress, std::pair< Tid, SequenceControlField > > >	processReceivedBlockAck (Ieee80211BlockAck *blockAck)
virtual void	frameGotInProgress (Ieee80211DataOrMgmtFrame *dataOrMgmtFrame) override
virtual void	processTransmittedDataOrMgmtFrame (Ieee80211DataOrMgmtFrame *frame)
virtual void	processTransmittedBlockAckReq (Ieee80211BlockAckReq *blockAckReq)
virtual void	processFailedFrame (Ieee80211DataOrMgmtFrame *dataOrMgmtFrame)
virtual Status	getQoSDataAckStatus (Ieee80211DataFrame *frame)
virtual Status	getMgmtOrNonQoSAckStatus (Ieee80211DataOrMgmtFrame *frame)
virtual int	getNumberOfFramesWithStatus (Status status)
virtual bool	isEligibleToTransmit (Ieee80211DataOrMgmtFrame *frame) override
virtual bool	isOutstandingFrame (Ieee80211DataOrMgmtFrame *frame) override
Public Member Functions inherited from inet::ieee80211::IAckHandler
virtual	~IAckHandler ()

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

Protected Member Functions
virtual Status &	getQoSDataAckStatus (const QoSKey &id)
virtual Status &	getMgmtOrNonQoSAckStatus (const Key &id)
std::string	getStatusString (Status status)
void	printAckStatuses ()

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

Member Typedef Documentation

typedef std::pair<MACAddress, SequenceControlField> inet::ieee80211::QoSAckHandler::Key

protected

typedef std::pair<MACAddress, std::pair<Tid, SequenceControlField> > inet::ieee80211::QoSAckHandler::QoSKey

protected

Member Enumeration Documentation

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

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

Constructor & Destructor Documentation

virtual inet::ieee80211::QoSAckHandler::~QoSAckHandler ( )

inlinevirtual

{ }

Member Function Documentation

void inet::ieee80211::QoSAckHandler::frameGotInProgress ( Ieee80211DataOrMgmtFrame *  dataOrMgmtFrame )

overridevirtual

Implements inet::ieee80211::IAckHandler.

{
    if (dataOrMgmtFrame->getType() == ST_DATA_WITH_QOS) {
        auto dataFrame = check_and_cast<Ieee80211DataFrame*>(dataOrMgmtFrame);
        auto id = std::make_pair(dataFrame->getReceiverAddress(), std::make_pair(dataFrame->getTid(), SequenceControlField(dataFrame->getSequenceNumber(), dataFrame->getFragmentNumber())));
        Status& 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(dataOrMgmtFrame->getReceiverAddress(), SequenceControlField(dataOrMgmtFrame->getSequenceNumber(), dataOrMgmtFrame->getFragmentNumber()));
        Status& status = getMgmtOrNonQoSAckStatus(id);
        ASSERT(status != Status::WAITING_FOR_NORMAL_ACK);
        mgmtAckStatuses[id] = Status::FRAME_NOT_YET_TRANSMITTED;
    }
}

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

protectedvirtual

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

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

QoSAckHandler::Status inet::ieee80211::QoSAckHandler::getMgmtOrNonQoSAckStatus ( Ieee80211DataOrMgmtFrame *  frame )

virtual

{
    auto id = std::make_pair(frame->getReceiverAddress(), SequenceControlField(frame->getSequenceNumber(), frame->getFragmentNumber()));
    auto it = mgmtAckStatuses.find(id);
    if (it == mgmtAckStatuses.end()) {
        mgmtAckStatuses[id] = Status::FRAME_NOT_YET_TRANSMITTED;
        return Status::FRAME_NOT_YET_TRANSMITTED;
    }
    return it->second;
}

int inet::ieee80211::QoSAckHandler::getNumberOfFramesWithStatus ( Status  status )

virtual

{
    int count = 0;
    for (auto ackStatus : ackStatuses)
        if (ackStatus.second == status)
            count++;
    return count;
}

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

protectedvirtual

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

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

QoSAckHandler::Status inet::ieee80211::QoSAckHandler::getQoSDataAckStatus ( Ieee80211DataFrame *  frame )

virtual

{
    auto id = std::make_pair(frame->getReceiverAddress(), std::make_pair(frame->getTid(), SequenceControlField(frame->getSequenceNumber(), frame->getFragmentNumber())));
    auto it = ackStatuses.find(id);
    if (it == ackStatuses.end()) {
        ackStatuses[id] = Status::FRAME_NOT_YET_TRANSMITTED;
        return Status::FRAME_NOT_YET_TRANSMITTED;
    }
    return it->second;
}

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

protected

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

bool inet::ieee80211::QoSAckHandler::isEligibleToTransmit ( Ieee80211DataOrMgmtFrame *  frame )

overridevirtual

Implements inet::ieee80211::IAckHandler.

{
    QoSAckHandler::Status status;
    if (frame->getType() == ST_DATA_WITH_QOS) {
        auto dataFrame = check_and_cast<Ieee80211DataFrame*>(frame);
        status = getQoSDataAckStatus(dataFrame);
    }
    else
        status = getMgmtOrNonQoSAckStatus(frame);
    return status == QoSAckHandler::Status::BLOCK_ACK_ARRIVED_UNACKED || status == QoSAckHandler::Status::NORMAL_ACK_NOT_ARRIVED || status == QoSAckHandler::Status::FRAME_NOT_YET_TRANSMITTED;
}

bool inet::ieee80211::QoSAckHandler::isOutstandingFrame ( Ieee80211DataOrMgmtFrame *  frame )

overridevirtual

Implements inet::ieee80211::IAckHandler.

{
    if (frame->getType() == ST_DATA_WITH_QOS) {
        auto dataFrame = check_and_cast<Ieee80211DataFrame*>(frame);
        auto status = getQoSDataAckStatus(dataFrame);
        return status == QoSAckHandler::Status::BLOCK_ACK_NOT_YET_REQUESTED;
    }
    else
        return false;
}

void inet::ieee80211::QoSAckHandler::printAckStatuses ( )

protected

Referenced by processReceivedBlockAck().

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

void inet::ieee80211::QoSAckHandler::processFailedFrame ( Ieee80211DataOrMgmtFrame *  dataOrMgmtFrame )

virtual

{
    if (dataOrMgmtFrame->getType() == ST_DATA_WITH_QOS) {
        auto dataFrame = check_and_cast<Ieee80211DataFrame*>(dataOrMgmtFrame);
        ASSERT(getQoSDataAckStatus(dataFrame) == Status::WAITING_FOR_NORMAL_ACK);
        auto id = std::make_pair(dataFrame->getReceiverAddress(), std::make_pair(dataFrame->getTid(), SequenceControlField(dataFrame->getSequenceNumber(), dataFrame->getFragmentNumber())));
        Status &status = getQoSDataAckStatus(id);
        status = Status::NORMAL_ACK_NOT_ARRIVED;
    }
    else {
        ASSERT(getMgmtOrNonQoSAckStatus(dataOrMgmtFrame) == Status::WAITING_FOR_NORMAL_ACK);
        Status &status = getMgmtOrNonQoSAckStatus(std::make_pair(dataOrMgmtFrame->getReceiverAddress(), SequenceControlField(dataOrMgmtFrame->getSequenceNumber(), dataOrMgmtFrame->getFragmentNumber())));
        status = Status::NORMAL_ACK_NOT_ARRIVED;
    }
}

void inet::ieee80211::QoSAckHandler::processReceivedAck ( Ieee80211ACKFrame *  ack, Ieee80211DataOrMgmtFrame *  ackedFrame  )

virtual

{
    if (ackedFrame->getType() == ST_DATA_WITH_QOS) {
        auto dataFrame = check_and_cast<Ieee80211DataFrame*>(ackedFrame);
        auto id = std::make_pair(dataFrame->getReceiverAddress(), std::make_pair(dataFrame->getTid(), SequenceControlField(dataFrame->getSequenceNumber(), dataFrame->getFragmentNumber())));
        Status &status = getQoSDataAckStatus(id);
        if (status == Status::FRAME_NOT_YET_TRANSMITTED)
            throw cRuntimeError("ackedFrame = %s is not yet transmitted", dataFrame->getName());
        status = Status::NORMAL_ACK_ARRIVED;
    }
    else {
        Status &status = getMgmtOrNonQoSAckStatus(std::make_pair(ackedFrame->getReceiverAddress(), SequenceControlField(ackedFrame->getSequenceNumber(), ackedFrame->getFragmentNumber())));
        if (status == Status::FRAME_NOT_YET_TRANSMITTED)
            throw cRuntimeError("ackedFrame = %s is not yet transmitted", ackedFrame->getName());
        status = Status::NORMAL_ACK_ARRIVED;
    }
}

std::set< std::pair< MACAddress, std::pair< Tid, SequenceControlField > > > inet::ieee80211::QoSAckHandler::processReceivedBlockAck ( Ieee80211BlockAck *  blockAck )

virtual

{
    printAckStatuses();
    MACAddress receiverAddr = blockAck->getTransmitterAddress();
    std::set<QoSKey> ackedFrames;
    // Table 8-16—BlockAckReq frame variant encoding
    if (auto basicBlockAck = dynamic_cast<Ieee80211BasicBlockAck *>(blockAck)) {
        int 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) % 4096, fragNum)));
                Status& status = getQoSDataAckStatus(id);
                if (status == Status::WAITING_FOR_BLOCK_ACK) {
                    bool acked = bitmap.getBit(fragNum) == 1;
                    if (acked) ackedFrames.insert(id);
                    status = acked ? Status::BLOCK_ACK_ARRIVED_ACKED : Status::BLOCK_ACK_ARRIVED_UNACKED;
                }
                else ; // TODO: erroneous BlockAck
            }
        }
    }
    else if (auto compressedBlockAck = dynamic_cast<Ieee80211CompressedBlockAck *>(blockAck)) {
        int 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, 0)));
            Status& status = getQoSDataAckStatus(id);
            if (status == Status::WAITING_FOR_BLOCK_ACK) {
                bool acked = bitmap.getBit(seqNum) == 1;
                status = 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");
    }
    printAckStatuses();
    return ackedFrames;
}

void inet::ieee80211::QoSAckHandler::processTransmittedBlockAckReq ( Ieee80211BlockAckReq *  blockAckReq )

virtual

{
    //printAckStatuses();
    for (auto &ackStatus : ackStatuses) {
        auto tid = ackStatus.first.second.first;
        auto seqCtrlField = ackStatus.first.second.second;
        auto &status = ackStatus.second;
        if (auto basicBlockAckReq = dynamic_cast<Ieee80211BasicBlockAckReq *>(blockAckReq)) {
            if (basicBlockAckReq->getTidInfo() == tid) {
                int startingSeqNum = basicBlockAckReq->getStartingSequenceNumber();
                if (status == Status::BLOCK_ACK_NOT_YET_REQUESTED && seqCtrlField.getSequenceNumber() >= startingSeqNum)
                    status = Status::WAITING_FOR_BLOCK_ACK;
            }
        }
        else if (auto compressedBlockAckReq = dynamic_cast<Ieee80211CompressedBlockAckReq *>(blockAckReq)) {
            if (compressedBlockAckReq->getTidInfo() == tid) {
                int startingSeqNum = compressedBlockAckReq->getStartingSequenceNumber();
                if (status == Status::BLOCK_ACK_NOT_YET_REQUESTED && 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");
    }
    //printAckStatuses();
}

void inet::ieee80211::QoSAckHandler::processTransmittedDataOrMgmtFrame ( Ieee80211DataOrMgmtFrame *  frame )

virtual

{
    if (frame->getType() == ST_DATA_WITH_QOS) {
        auto dataFrame = check_and_cast<Ieee80211DataFrame*>(frame);
        auto id = std::make_pair(dataFrame->getReceiverAddress(), std::make_pair(dataFrame->getTid(), SequenceControlField(dataFrame->getSequenceNumber(), dataFrame->getFragmentNumber())));
        switch (dataFrame->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", dataFrame->getAckPolicy());
        }
    }
    else
        mgmtAckStatuses[std::make_pair(frame->getReceiverAddress(), SequenceControlField(frame->getSequenceNumber(), frame->getFragmentNumber()))] = Status::WAITING_FOR_NORMAL_ACK;
}

Member Data Documentation

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

protected

Referenced by frameGotInProgress(), getNumberOfFramesWithStatus(), getQoSDataAckStatus(), processTransmittedBlockAckReq(), and processTransmittedDataOrMgmtFrame().

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

protected

Referenced by frameGotInProgress(), getMgmtOrNonQoSAckStatus(), and processTransmittedDataOrMgmtFrame().

---

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

• QoSAckHandler.h
• QoSAckHandler.cc