inet::ieee80211::Hcf Class Reference

Implements IEEE 802.11 Hybrid Coordination Function. More...

#include <Hcf.h>

Inheritance diagram for inet::ieee80211::Hcf:

Public Member Functions
virtual	~Hcf ()
virtual void	processUpperFrame (Ieee80211DataOrMgmtFrame *frame) override
virtual void	processLowerFrame (Ieee80211Frame *frame) override
virtual void	corruptedFrameReceived () override
Public Member Functions inherited from inet::ieee80211::ICoordinationFunction
virtual	~ICoordinationFunction ()
Public Member Functions inherited from inet::ieee80211::IFrameSequenceHandler::ICallback
virtual	~ICallback ()
Public Member Functions inherited from inet::ieee80211::IChannelAccess::ICallback
virtual	~ICallback ()
Public Member Functions inherited from inet::ieee80211::ITx::ICallback
virtual	~ICallback ()
Public Member Functions inherited from inet::ieee80211::IProcedureCallback
virtual	~IProcedureCallback ()
Public Member Functions inherited from inet::ieee80211::IBlockAckAgreementHandlerCallback
virtual	~IBlockAckAgreementHandlerCallback ()

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
void	startFrameSequence (AccessCategory ac)
void	handleInternalCollision (std::vector< Edcaf * > internallyCollidedEdcafs)
void	sendUp (const std::vector< Ieee80211Frame * > &completeFrames)
FrameSequenceContext *	buildContext (AccessCategory ac)
virtual bool	hasFrameToTransmit ()
virtual bool	hasFrameToTransmit (AccessCategory ac)
virtual bool	isReceptionInProgress ()
virtual void	recipientProcessReceivedFrame (Ieee80211Frame *frame)
virtual void	recipientProcessReceivedControlFrame (Ieee80211Frame *frame)
virtual void	recipientProcessReceivedManagementFrame (Ieee80211ManagementFrame *frame)
virtual void	recipientProcessTransmittedControlResponseFrame (Ieee80211Frame *frame)
virtual void	originatorProcessTransmittedManagementFrame (Ieee80211ManagementFrame *mgmtFrame, AccessCategory ac)
virtual void	originatorProcessTransmittedControlFrame (Ieee80211Frame *controlFrame, AccessCategory ac)
virtual void	originatorProcessTransmittedDataFrame (Ieee80211DataFrame *dataFrame, AccessCategory ac)
virtual void	originatorProcessReceivedManagementFrame (Ieee80211ManagementFrame *frame, Ieee80211Frame *lastTransmittedFrame, AccessCategory ac)
virtual void	originatorProcessReceivedControlFrame (Ieee80211Frame *frame, Ieee80211Frame *lastTransmittedFrame, AccessCategory ac)
virtual void	originatorProcessReceivedDataFrame (Ieee80211DataFrame *frame, Ieee80211Frame *lastTransmittedFrame, AccessCategory ac)
virtual void	setFrameMode (Ieee80211Frame *frame, const IIeee80211Mode *mode) const
virtual bool	isSentByUs (Ieee80211Frame *frame) const
virtual bool	isForUs (Ieee80211Frame *frame) const
virtual void	originatorProcessRtsProtectionFailed (Ieee80211DataOrMgmtFrame *protectedFrame) override
virtual void	originatorProcessTransmittedFrame (Ieee80211Frame *transmittedFrame) override
virtual void	originatorProcessReceivedFrame (Ieee80211Frame *frame, Ieee80211Frame *lastTransmittedFrame) override
virtual void	originatorProcessFailedFrame (Ieee80211DataOrMgmtFrame *failedFrame) override
virtual void	frameSequenceFinished () override
virtual void	transmitFrame (Ieee80211Frame *frame, simtime_t ifs) override
virtual void	scheduleStartRxTimer (simtime_t timeout) override
virtual void	channelGranted (IChannelAccess *channelAccess) override
virtual void	transmissionComplete (Ieee80211Frame *frame) override
virtual void	transmitControlResponseFrame (Ieee80211Frame *responseFrame, Ieee80211Frame *receivedFrame) override
virtual void	processMgmtFrame (Ieee80211ManagementFrame *mgmtFrame) override
virtual void	scheduleInactivityTimer (simtime_t timeout) override
Protected Member Functions inherited from inet::ieee80211::ModeSetListener
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override

Protected Attributes
Ieee80211Mac *	mac = nullptr
IRateControl *	dataAndMgmtRateControl = nullptr
int	numEdcafs = -1
cMessage *	startRxTimer = nullptr
cMessage *	inactivityTimer = nullptr
IRx *	rx = nullptr
ITx *	tx = nullptr
IQoSRateSelection *	rateSelection = nullptr
Edca *	edca = nullptr
Hcca *	hcca = nullptr
IOriginatorMacDataService *	originatorDataService = nullptr
IRecipientQoSMacDataService *	recipientDataService = nullptr
IRecipientAckProcedure *	recipientAckProcedure = nullptr
IOriginatorQoSAckPolicy *	originatorAckPolicy = nullptr
IRecipientQoSAckPolicy *	recipientAckPolicy = nullptr
IRtsProcedure *	rtsProcedure = nullptr
IRtsPolicy *	rtsPolicy = nullptr
ICtsProcedure *	ctsProcedure = nullptr
ICtsPolicy *	ctsPolicy = nullptr
IOriginatorBlockAckProcedure *	originatorBlockAckProcedure = nullptr
IRecipientBlockAckProcedure *	recipientBlockAckProcedure = nullptr
EdcaTransmitLifetimeHandler *	lifetimeHandler = nullptr
std::vector< QoSRecoveryProcedure * >	edcaDataRecoveryProcedures
NonQoSRecoveryProcedure *	edcaMgmtAndNonQoSRecoveryProcedure = nullptr
IOriginatorBlockAckAgreementHandler *	originatorBlockAckAgreementHandler = nullptr
IOriginatorBlockAckAgreementPolicy *	originatorBlockAckAgreementPolicy = nullptr
IRecipientBlockAckAgreementHandler *	recipientBlockAckAgreementHandler = nullptr
IRecipientBlockAckAgreementPolicy *	recipientBlockAckAgreementPolicy = nullptr
std::vector< QoSAckHandler * >	edcaAckHandlers
std::vector< TxopProcedure * >	edcaTxops
TxopProcedure *	hccaTxop = nullptr
std::vector< PendingQueue * >	edcaPendingQueues
PendingQueue *	hccaPendingQueue = nullptr
std::vector< InProgressFrames * >	edcaInProgressFrames
InProgressFrames *	hccaInProgressFrame = nullptr
IFrameSequenceHandler *	frameSequenceHandler = nullptr
std::vector< StationRetryCounters * >	stationRetryCounters
SingleProtectionMechanism *	singleProtectionMechanism = nullptr
Protected Attributes inherited from inet::ieee80211::ModeSetListener
Ieee80211ModeSet *	modeSet = nullptr

Detailed Description

Implements IEEE 802.11 Hybrid Coordination Function.

Constructor & Destructor Documentation

inet::ieee80211::Hcf::~Hcf ( )

virtual

{
    cancelAndDelete(startRxTimer);
    cancelAndDelete(inactivityTimer);
    delete recipientAckProcedure;
    delete ctsProcedure;
    delete rtsProcedure;
    delete originatorBlockAckAgreementHandler;
    delete recipientBlockAckAgreementHandler;
    delete originatorBlockAckProcedure;
    delete recipientBlockAckProcedure;
    delete frameSequenceHandler;
    for (auto inProgressFrames : edcaInProgressFrames)
        delete inProgressFrames;
    for (auto pendingQueue : edcaPendingQueues)
        delete pendingQueue;
    for (auto ackHandler : edcaAckHandlers)
        delete ackHandler;
    for (auto retryCounter : stationRetryCounters)
        delete retryCounter;
}

Member Function Documentation

FrameSequenceContext * inet::ieee80211::Hcf::buildContext ( AccessCategory  ac )

protected

Referenced by startFrameSequence().

{
    auto qosContext = new QoSContext(originatorAckPolicy, originatorBlockAckProcedure, originatorBlockAckAgreementHandler, edcaTxops[ac]);
    return new FrameSequenceContext(mac->getAddress(), modeSet, edcaInProgressFrames[ac], rtsProcedure, rtsPolicy, nullptr, qosContext);
}

void inet::ieee80211::Hcf::channelGranted ( IChannelAccess *  channelAccess )

overrideprotectedvirtual

Implements inet::ieee80211::IChannelAccess::ICallback.

{
    auto edcaf = check_and_cast<Edcaf*>(channelAccess);
    if (edcaf) {
        AccessCategory ac = edcaf->getAccessCategory();
        EV_DETAIL << "Channel access granted to the " << printAccessCategory(ac) << " queue" << std::endl;
        edcaTxops[ac]->startTxop(ac);
        auto internallyCollidedEdcafs = edca->getInternallyCollidedEdcafs();
        if (internallyCollidedEdcafs.size() > 0) {
            EV_INFO << "Internal collision happened with the following queues:" << std::endl;
            handleInternalCollision(internallyCollidedEdcafs);
        }
        startFrameSequence(ac);
    }
    else
        throw cRuntimeError("Channel access granted but channel owner not found!");
}

void inet::ieee80211::Hcf::corruptedFrameReceived ( )

overridevirtual

Implements inet::ieee80211::ICoordinationFunction.

Referenced by inet::ieee80211::Ieee80211Mac::handleLowerPacket().

{
    if (frameSequenceHandler->isSequenceRunning()) {
        if (!startRxTimer->isScheduled())
            frameSequenceHandler->handleStartRxTimeout();
    }
}

void inet::ieee80211::Hcf::frameSequenceFinished ( )

overrideprotectedvirtual

Implements inet::ieee80211::IFrameSequenceHandler::ICallback.

{
    auto edcaf = edca->getChannelOwner();
    if (edcaf) {
        bool startContention = hasFrameToTransmit(); // TODO: outstanding frame
        edcaf->releaseChannel(this);
        mac->sendDownPendingRadioConfigMsg(); // TODO: review
        AccessCategory ac = edcaf->getAccessCategory();
        edcaTxops[ac]->stopTxop();
        if (startContention)
            edcaf->requestChannel(this);
    }
    else if (hcca->isOwning()) {
        hcca->releaseChannel(this);
        mac->sendDownPendingRadioConfigMsg(); // TODO: review
        throw cRuntimeError("Hcca is unimplemented!");
    }
    else
        throw cRuntimeError("Frame sequence finished but channel owner not found!");
}

void inet::ieee80211::Hcf::handleInternalCollision ( std::vector< Edcaf * >  internallyCollidedEdcafs )

protected

Referenced by channelGranted().

{
    for (auto edcaf : internallyCollidedEdcafs) {
        AccessCategory ac = edcaf->getAccessCategory();
        Ieee80211DataOrMgmtFrame *internallyCollidedFrame = edcaInProgressFrames[ac]->getFrameToTransmit();
        EV_INFO << printAccessCategory(ac) << " (" << internallyCollidedFrame->getName() << ")" << endl;
        bool retryLimitReached = false;
        if (auto dataFrame = dynamic_cast<Ieee80211DataFrame *>(internallyCollidedFrame)) { // TODO: QoSDataFrame
            edcaDataRecoveryProcedures[ac]->dataFrameTransmissionFailed(dataFrame);
            retryLimitReached = edcaDataRecoveryProcedures[ac]->isRetryLimitReached(dataFrame);
        }
        else if (auto mgmtFrame = dynamic_cast<Ieee80211ManagementFrame*>(internallyCollidedFrame)) {
            ASSERT(ac == AccessCategory::AC_BE);
            edcaMgmtAndNonQoSRecoveryProcedure->dataOrMgmtFrameTransmissionFailed(mgmtFrame, stationRetryCounters[AccessCategory::AC_BE]);
            retryLimitReached = edcaMgmtAndNonQoSRecoveryProcedure->isRetryLimitReached(mgmtFrame);
        }
        else // TODO: + NonQoSDataFrame
            throw cRuntimeError("Unknown frame");
        if (retryLimitReached) {
            EV_DETAIL << "The frame has reached its retry limit. Dropping it" << std::endl;
            emit(NF_LINK_BREAK, internallyCollidedFrame);
            emit(NF_PACKET_DROP, internallyCollidedFrame);
            if (auto dataFrame = dynamic_cast<Ieee80211DataFrame *>(internallyCollidedFrame))
                edcaDataRecoveryProcedures[ac]->retryLimitReached(dataFrame);
            else if (auto mgmtFrame = dynamic_cast<Ieee80211ManagementFrame*>(internallyCollidedFrame))
                edcaMgmtAndNonQoSRecoveryProcedure->retryLimitReached(mgmtFrame);
            else ; // TODO: + NonQoSDataFrame
            edcaInProgressFrames[ac]->dropFrame(internallyCollidedFrame);
            if (hasFrameToTransmit(ac))
                edcaf->requestChannel(this);
        }
        else
            edcaf->requestChannel(this);
    }
}

void inet::ieee80211::Hcf::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

{
    if (msg == startRxTimer) {
        if (!isReceptionInProgress())
            frameSequenceHandler->handleStartRxTimeout();
    }
    else if (msg == inactivityTimer) {
        if (originatorBlockAckAgreementHandler && recipientBlockAckAgreementHandler) {
            originatorBlockAckAgreementHandler->blockAckAgreementExpired(this, this);
            recipientBlockAckAgreementHandler->blockAckAgreementExpired(this, this);
        }
        else
            throw cRuntimeError("Unknown event");
    }
    else
        throw cRuntimeError("Unknown msg type");
}

bool inet::ieee80211::Hcf::hasFrameToTransmit ( )

protectedvirtual

Referenced by frameSequenceFinished(), and handleInternalCollision().

{
    auto edcaf = edca->getChannelOwner();
    if (edcaf) {
        AccessCategory ac = edcaf->getAccessCategory();
        return !edcaPendingQueues[ac]->isEmpty() || edcaInProgressFrames[ac]->hasInProgressFrames();
    }
    else
        throw cRuntimeError("Hcca is unimplemented");
}

bool inet::ieee80211::Hcf::hasFrameToTransmit ( AccessCategory  ac )

protectedvirtual

{
    auto edcaf = edca->getChannelOwner();
    if (edcaf) {
        AccessCategory ac = edcaf->getAccessCategory();
        return !edcaPendingQueues[ac]->isEmpty() || edcaInProgressFrames[ac]->hasInProgressFrames();
    }
    else
        throw cRuntimeError("Hcca is unimplemented");
}

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

overrideprotectedvirtual

Reimplemented from inet::ieee80211::ModeSetListener.

{
    ModeSetListener::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        mac = check_and_cast<Ieee80211Mac *>(getContainingNicModule(this)->getSubmodule("mac"));
        startRxTimer = new cMessage("startRxTimeout");
        inactivityTimer = new cMessage("blockAckInactivityTimer");
        numEdcafs = par("numEdcafs");
        edca = check_and_cast<Edca *>(getSubmodule("edca"));
        hcca = check_and_cast<Hcca *>(getSubmodule("hcca"));
        tx = check_and_cast<ITx *>(getModuleByPath(par("txModule")));
        rx = check_and_cast<IRx *>(getModuleByPath(par("rxModule")));
        dataAndMgmtRateControl = dynamic_cast<IRateControl*>(getSubmodule("rateControl"));
        originatorBlockAckAgreementPolicy = dynamic_cast<IOriginatorBlockAckAgreementPolicy*>(getSubmodule("originatorBlockAckAgreementPolicy"));
        recipientBlockAckAgreementPolicy = dynamic_cast<IRecipientBlockAckAgreementPolicy*>(getSubmodule("recipientBlockAckAgreementPolicy"));
        rateSelection = check_and_cast<IQoSRateSelection *>(getSubmodule("rateSelection"));
        frameSequenceHandler = new FrameSequenceHandler();
        originatorDataService = check_and_cast<IOriginatorMacDataService *>(getSubmodule(("originatorMacDataService")));
        recipientDataService = check_and_cast<IRecipientQoSMacDataService*>(getSubmodule("recipientMacDataService"));
        originatorAckPolicy = check_and_cast<IOriginatorQoSAckPolicy*>(getSubmodule("originatorAckPolicy"));
        recipientAckPolicy = check_and_cast<IRecipientQoSAckPolicy*>(getSubmodule("recipientAckPolicy"));
        edcaMgmtAndNonQoSRecoveryProcedure = check_and_cast<NonQoSRecoveryProcedure *>(getSubmodule("edcaMgmtAndNonQoSRecoveryProcedure"));
        singleProtectionMechanism = check_and_cast<SingleProtectionMechanism*>(getSubmodule("singleProtectionMechanism"));
        rtsProcedure = new RtsProcedure();
        rtsPolicy = check_and_cast<IRtsPolicy*>(getSubmodule("rtsPolicy"));
        recipientAckProcedure = new RecipientAckProcedure();
        ctsProcedure = new CtsProcedure();
        ctsPolicy = check_and_cast<ICtsPolicy*>(getSubmodule("ctsPolicy"));
        if (originatorBlockAckAgreementPolicy && recipientBlockAckAgreementPolicy) {
            recipientBlockAckAgreementHandler = new RecipientBlockAckAgreementHandler();
            originatorBlockAckAgreementHandler = new OriginatorBlockAckAgreementHandler();
            originatorBlockAckProcedure = new OriginatorBlockAckProcedure();
            recipientBlockAckProcedure = new RecipientBlockAckProcedure();
        }
        for (int ac = 0; ac < numEdcafs; ac++) {
            edcaPendingQueues.push_back(new PendingQueue(par("maxQueueSize"), nullptr, par("prioritizeMulticast") ? PendingQueue::Priority::PRIORITIZE_MULTICAST_OVER_DATA : PendingQueue::Priority::PRIORITIZE_MGMT_OVER_DATA));
            edcaDataRecoveryProcedures.push_back(check_and_cast<QoSRecoveryProcedure *>(getSubmodule("edcaDataRecoveryProcedures", ac)));
            edcaAckHandlers.push_back(new QoSAckHandler());
            edcaInProgressFrames.push_back(new InProgressFrames(edcaPendingQueues[ac], originatorDataService, edcaAckHandlers[ac]));
            edcaTxops.push_back(check_and_cast<TxopProcedure *>(getSubmodule("edcaTxopProcedures", ac)));
            stationRetryCounters.push_back(new StationRetryCounters());
        }
    }
}

bool inet::ieee80211::Hcf::isForUs ( Ieee80211Frame *  frame ) const

protectedvirtual

Referenced by processLowerFrame().

{
    return frame->getReceiverAddress() == mac->getAddress() || (frame->getReceiverAddress().isMulticast() && !isSentByUs(frame));
}

bool inet::ieee80211::Hcf::isReceptionInProgress ( )

protectedvirtual

Referenced by handleMessage().

{
    return rx->isReceptionInProgress();
}

bool inet::ieee80211::Hcf::isSentByUs ( Ieee80211Frame *  frame ) const

protectedvirtual

Referenced by isForUs().

{
    // FIXME:
    // Check the roles of the Addr3 field when aggregation is applied
    // Table 8-19—Address field contents
    if (auto dataOrMgmtFrame = dynamic_cast<Ieee80211DataOrMgmtFrame *>(frame))
        return dataOrMgmtFrame->getAddress3() == mac->getAddress();
    else
        return false;
}

virtual int inet::ieee80211::Hcf::numInitStages ( ) const

inlineoverrideprotectedvirtual

Reimplemented from inet::ieee80211::ModeSetListener.

{ return NUM_INIT_STAGES; }

void inet::ieee80211::Hcf::originatorProcessFailedFrame ( Ieee80211DataOrMgmtFrame *  failedFrame )

overrideprotectedvirtual

Implements inet::ieee80211::IFrameSequenceHandler::ICallback.

{
    auto edcaf = edca->getChannelOwner();
    if (edcaf) {
        AccessCategory ac = edcaf->getAccessCategory();
        bool retryLimitReached = false;
        if (auto dataFrame = dynamic_cast<Ieee80211DataFrame *>(failedFrame)) {
            EV_INFO << "Data frame transmission failed\n";
            if (dataFrame->getAckPolicy() == NORMAL_ACK) {
                edcaDataRecoveryProcedures[ac]->dataFrameTransmissionFailed(dataFrame);
                retryLimitReached = edcaDataRecoveryProcedures[ac]->isRetryLimitReached(dataFrame);
                if (dataAndMgmtRateControl) {
                    int retryCount = edcaDataRecoveryProcedures[ac]->getRetryCount(dataFrame);
                    dataAndMgmtRateControl->frameTransmitted(dataFrame, retryCount, false, retryLimitReached);
                }
            }
            else if (dataFrame->getAckPolicy() == BLOCK_ACK) {
                // TODO:
                // bool lifetimeExpired = lifetimeHandler->isLifetimeExpired(failedFrame);
                // if (lifetimeExpired) {
                //    inProgressFrames->dropFrame(failedFrame);
                // }
            }
            else
                throw cRuntimeError("Unimplemented!");
        }
        else if (auto mgmtFrame = dynamic_cast<Ieee80211ManagementFrame*>(failedFrame)) { // TODO: + NonQoS frames
            EV_INFO << "Management frame transmission failed\n";
            edcaMgmtAndNonQoSRecoveryProcedure->dataOrMgmtFrameTransmissionFailed(mgmtFrame, stationRetryCounters[ac]);
            retryLimitReached = edcaMgmtAndNonQoSRecoveryProcedure->isRetryLimitReached(mgmtFrame);
            if (dataAndMgmtRateControl) {
                int retryCount = edcaMgmtAndNonQoSRecoveryProcedure->getRetryCount(mgmtFrame);
                dataAndMgmtRateControl->frameTransmitted(mgmtFrame, retryCount, false, retryLimitReached);
            }
        }
        else
            throw cRuntimeError("Unknown frame"); // TODO: qos, nonqos
        edcaAckHandlers[ac]->processFailedFrame(failedFrame);
        if (retryLimitReached) {
            if (auto dataFrame = dynamic_cast<Ieee80211DataFrame *>(failedFrame))
                edcaDataRecoveryProcedures[ac]->retryLimitReached(dataFrame);
            else if (auto mgmtFrame = dynamic_cast<Ieee80211ManagementFrame*>(failedFrame))
                edcaMgmtAndNonQoSRecoveryProcedure->retryLimitReached(mgmtFrame);
            edcaInProgressFrames[ac]->dropFrame(failedFrame);
            emit(NF_LINK_BREAK, failedFrame);
            emit(NF_PACKET_DROP, failedFrame);
        }
        else
            failedFrame->setRetry(true);
    }
    else
        throw cRuntimeError("Hcca is unimplemented!");
}

void inet::ieee80211::Hcf::originatorProcessReceivedControlFrame ( Ieee80211Frame *  frame, Ieee80211Frame *  lastTransmittedFrame, AccessCategory  ac  )

protectedvirtual

Referenced by originatorProcessReceivedFrame().

{
    if (auto ackFrame = dynamic_cast<Ieee80211ACKFrame *>(frame)) {
        if (auto dataFrame = dynamic_cast<Ieee80211DataFrame *>(lastTransmittedFrame)) {
            if (dataAndMgmtRateControl) {
                int retryCount;
                if (dataFrame->getRetry())
                    retryCount = edcaDataRecoveryProcedures[ac]->getRetryCount(dataFrame);
                else
                    retryCount = 0;
                edcaDataRecoveryProcedures[ac]->ackFrameReceived(dataFrame);
                dataAndMgmtRateControl->frameTransmitted(dataFrame, retryCount, true, false);
            }
        }
        else if (auto mgmtFrame = dynamic_cast<Ieee80211ManagementFrame *>(lastTransmittedFrame)) {
            if (dataAndMgmtRateControl) {
                int retryCount = edcaMgmtAndNonQoSRecoveryProcedure->getRetryCount(dataFrame);
                dataAndMgmtRateControl->frameTransmitted(mgmtFrame, retryCount, true, false);
            }
            edcaMgmtAndNonQoSRecoveryProcedure->ackFrameReceived(mgmtFrame, stationRetryCounters[ac]);
        }
        else
            throw cRuntimeError("Unknown frame"); // TODO: qos, nonqos frame
        edcaAckHandlers[ac]->processReceivedAck(ackFrame, check_and_cast<Ieee80211DataOrMgmtFrame*>(lastTransmittedFrame));
        edcaInProgressFrames[ac]->dropFrame(check_and_cast<Ieee80211DataOrMgmtFrame*>(lastTransmittedFrame));
    }
    else if (auto blockAck = dynamic_cast<Ieee80211BasicBlockAck *>(frame)) {
        EV_INFO << "BasicBlockAck has arrived" << std::endl;
        edcaDataRecoveryProcedures[ac]->blockAckFrameReceived();
        auto ackedSeqAndFragNums = edcaAckHandlers[ac]->processReceivedBlockAck(blockAck);
        if (originatorBlockAckAgreementHandler)
            originatorBlockAckAgreementHandler->processReceivedBlockAck(blockAck, this);
        EV_INFO << "It has acknowledged the following frames:" << std::endl;
        // FIXME
//        for (auto seqCtrlField : ackedSeqAndFragNums)
//            EV_INFO << "Fragment number = " << seqCtrlField.getSequenceNumber() << " Sequence number = " << (int)seqCtrlField.getFragmentNumber() << std::endl;
        edcaInProgressFrames[ac]->dropFrames(ackedSeqAndFragNums);
    }
    else if (dynamic_cast<Ieee80211RTSFrame*>(frame))
        ; // void
    else if (dynamic_cast<Ieee80211CTSFrame*>(frame))
        edcaDataRecoveryProcedures[ac]->ctsFrameReceived();
    else if (frame->getType() == ST_DATA_WITH_QOS)
        ; // void
    else if (dynamic_cast<Ieee80211BasicBlockAckReq*>(frame))
        ; // void
    else
        throw cRuntimeError("Unknown control frame");
}

void inet::ieee80211::Hcf::originatorProcessReceivedDataFrame ( Ieee80211DataFrame *  frame, Ieee80211Frame *  lastTransmittedFrame, AccessCategory  ac  )

protectedvirtual

Referenced by originatorProcessReceivedFrame().

{
    throw cRuntimeError("Unknown data frame");
}

void inet::ieee80211::Hcf::originatorProcessReceivedFrame ( Ieee80211Frame *  frame, Ieee80211Frame *  lastTransmittedFrame  )

overrideprotectedvirtual

Implements inet::ieee80211::IFrameSequenceHandler::ICallback.

{
    auto edcaf = edca->getChannelOwner();
    if (edcaf) {
        AccessCategory ac = edcaf->getAccessCategory();
        if (auto dataFrame = dynamic_cast<Ieee80211DataFrame*>(frame))
            originatorProcessReceivedDataFrame(dataFrame, lastTransmittedFrame, ac);
        else if (auto mgmtFrame = dynamic_cast<Ieee80211ManagementFrame *>(frame))
            originatorProcessReceivedManagementFrame(mgmtFrame, lastTransmittedFrame, ac);
        else
            originatorProcessReceivedControlFrame(frame, lastTransmittedFrame, ac);
    }
    else
        throw cRuntimeError("Hcca is unimplemented!");
}

void inet::ieee80211::Hcf::originatorProcessReceivedManagementFrame ( Ieee80211ManagementFrame *  frame, Ieee80211Frame *  lastTransmittedFrame, AccessCategory  ac  )

protectedvirtual

Referenced by originatorProcessReceivedFrame().

{
    throw cRuntimeError("Unknown management frame");
}

void inet::ieee80211::Hcf::originatorProcessRtsProtectionFailed ( Ieee80211DataOrMgmtFrame *  protectedFrame )

overrideprotectedvirtual

Implements inet::ieee80211::IFrameSequenceHandler::ICallback.

{
    auto edcaf = edca->getChannelOwner();
    if (edcaf) {
        EV_INFO << "RTS frame transmission failed\n";
        AccessCategory ac = edcaf->getAccessCategory();
        bool retryLimitReached = false;
        if (auto dataFrame = dynamic_cast<Ieee80211DataFrame *>(protectedFrame)) {
            edcaDataRecoveryProcedures[ac]->rtsFrameTransmissionFailed(dataFrame);
            retryLimitReached = edcaDataRecoveryProcedures[ac]->isRtsFrameRetryLimitReached(dataFrame);
        }
        else if (auto mgmtFrame = dynamic_cast<Ieee80211ManagementFrame *>(protectedFrame)) {
            edcaMgmtAndNonQoSRecoveryProcedure->rtsFrameTransmissionFailed(mgmtFrame, stationRetryCounters[ac]);
            retryLimitReached = edcaMgmtAndNonQoSRecoveryProcedure->isRtsFrameRetryLimitReached(dataFrame);
        }
        else
            throw cRuntimeError("Unknown frame"); // TODO: QoSDataFrame, NonQoSDataFrame
        if (retryLimitReached) {
            if (auto dataFrame = dynamic_cast<Ieee80211DataFrame *>(protectedFrame))
                edcaDataRecoveryProcedures[ac]->retryLimitReached(dataFrame);
            else if (auto mgmtFrame = dynamic_cast<Ieee80211ManagementFrame*>(protectedFrame))
                edcaMgmtAndNonQoSRecoveryProcedure->retryLimitReached(mgmtFrame);
            else ; // TODO: nonqos data
            edcaInProgressFrames[ac]->dropFrame(protectedFrame);
            emit(NF_LINK_BREAK, protectedFrame);
            emit(NF_PACKET_DROP, protectedFrame);
        }
    }
    else
        throw cRuntimeError("Hcca is unimplemented!");
}

void inet::ieee80211::Hcf::originatorProcessTransmittedControlFrame ( Ieee80211Frame *  controlFrame, AccessCategory  ac  )

protectedvirtual

Referenced by originatorProcessTransmittedFrame().

{
    if (auto blockAckReq = dynamic_cast<Ieee80211BlockAckReq*>(controlFrame))
        edcaAckHandlers[ac]->processTransmittedBlockAckReq(blockAckReq);
    else if (auto rtsFrame = dynamic_cast<Ieee80211RTSFrame*>(controlFrame))
        rtsProcedure->processTransmittedRts(rtsFrame);
    else
        throw cRuntimeError("Unknown control frame");
}

void inet::ieee80211::Hcf::originatorProcessTransmittedDataFrame ( Ieee80211DataFrame *  dataFrame, AccessCategory  ac  )

protectedvirtual

Referenced by originatorProcessTransmittedFrame().

{
    edcaAckHandlers[ac]->processTransmittedDataOrMgmtFrame(dataFrame);
    if (originatorBlockAckAgreementHandler)
        originatorBlockAckAgreementHandler->processTransmittedDataFrame(dataFrame, originatorBlockAckAgreementPolicy, this);
    if (dataFrame->getAckPolicy() == NO_ACK)
        edcaInProgressFrames[ac]->dropFrame(dataFrame);
}

void inet::ieee80211::Hcf::originatorProcessTransmittedFrame ( Ieee80211Frame *  transmittedFrame )

overrideprotectedvirtual

Implements inet::ieee80211::IFrameSequenceHandler::ICallback.

{
    auto edcaf = edca->getChannelOwner();
    if (edcaf) {
        AccessCategory ac = edcaf->getAccessCategory();
        if (transmittedFrame->getReceiverAddress().isMulticast()) {
            edcaDataRecoveryProcedures[ac]->multicastFrameTransmitted();
            if (auto transmittedDataOrMgmtFrame = dynamic_cast<Ieee80211DataOrMgmtFrame*>(transmittedFrame))
                edcaInProgressFrames[ac]->dropFrame(transmittedDataOrMgmtFrame);
        }
        else if (auto dataFrame = dynamic_cast<Ieee80211DataFrame*>(transmittedFrame))
            originatorProcessTransmittedDataFrame(dataFrame, ac);
        else if (auto mgmtFrame = dynamic_cast<Ieee80211ManagementFrame*>(transmittedFrame))
            originatorProcessTransmittedManagementFrame(mgmtFrame, ac);
        else // TODO: Ieee80211ControlFrame
            originatorProcessTransmittedControlFrame(transmittedFrame, ac);
    }
    else if (hcca->isOwning())
        throw cRuntimeError("Hcca is unimplemented");
    else
        throw cRuntimeError("Frame transmitted but channel owner not found");
}

void inet::ieee80211::Hcf::originatorProcessTransmittedManagementFrame ( Ieee80211ManagementFrame *  mgmtFrame, AccessCategory  ac  )

protectedvirtual

Referenced by originatorProcessTransmittedFrame().

{
    if (originatorAckPolicy->isAckNeeded(mgmtFrame))
        edcaAckHandlers[ac]->processTransmittedDataOrMgmtFrame(mgmtFrame);
    if (auto addbaReq = dynamic_cast<Ieee80211AddbaRequest*>(mgmtFrame)) {
        if (originatorBlockAckAgreementHandler)
            originatorBlockAckAgreementHandler->processTransmittedAddbaReq(addbaReq);
    }
    else if (auto addbaResp = dynamic_cast<Ieee80211AddbaResponse*>(mgmtFrame))
        recipientBlockAckAgreementHandler->processTransmittedAddbaResp(addbaResp, this);
    else if (auto delba = dynamic_cast<Ieee80211Delba *>(mgmtFrame)) {
        if (delba->getInitiator())
            originatorBlockAckAgreementHandler->processTransmittedDelba(delba);
        else
            recipientBlockAckAgreementHandler->processTransmittedDelba(delba);
    }
    else ; // TODO: other mgmt frames if needed
}

void inet::ieee80211::Hcf::processLowerFrame ( Ieee80211Frame *  frame )

overridevirtual

Implements inet::ieee80211::ICoordinationFunction.

Referenced by inet::ieee80211::Ieee80211Mac::processLowerFrame().

{
    Enter_Method_Silent();
    auto edcaf = edca->getChannelOwner();
    if (edcaf && frameSequenceHandler->isSequenceRunning()) {
        // TODO: always call processResponse?
        if ((!isForUs(frame) && !startRxTimer->isScheduled()) || isForUs(frame))
            frameSequenceHandler->processResponse(frame);
        else {
            EV_INFO << "This frame is not for us" << std::endl;
            delete frame;
        }
        cancelEvent(startRxTimer);
    }
    else if (hcca->isOwning())
        throw cRuntimeError("Hcca is unimplemented!");
    else if (isForUs(frame))
        recipientProcessReceivedFrame(frame);
    else {
        EV_INFO << "This frame is not for us" << std::endl;
        delete frame;
    }
}

void inet::ieee80211::Hcf::processMgmtFrame ( Ieee80211ManagementFrame *  mgmtFrame )

overrideprotectedvirtual

Implements inet::ieee80211::IProcedureCallback.

{
    processUpperFrame(mgmtFrame);
}

void inet::ieee80211::Hcf::processUpperFrame ( Ieee80211DataOrMgmtFrame *  frame )

overridevirtual

Implements inet::ieee80211::ICoordinationFunction.

Referenced by processMgmtFrame(), and inet::ieee80211::Ieee80211Mac::processUpperFrame().

{
    Enter_Method("processUpperFrame(%s)", frame->getName());
    EV_INFO << "Processing upper frame: " << frame->getName() << endl;
    // TODO:
    // A QoS STA should send individually addressed Management frames that are addressed to a non-QoS STA
    // using the access category AC_BE and shall send all other management frames using the access category
    // AC_VO. A QoS STA that does not send individually addressed Management frames that are addressed to a
    // non-QoS STA using the access category AC_BE shall send them using the access category AC_VO.
    // Management frames are exempted from any and all restrictions on transmissions arising from admission
    // control procedures.
    AccessCategory ac = AccessCategory(-1);
    if (dynamic_cast<Ieee80211ManagementFrame *>(frame)) // TODO: + non-QoS frames
        ac = AccessCategory::AC_VO;
    else if (auto dataFrame = dynamic_cast<Ieee80211DataFrame *>(frame))
        ac = edca->classifyFrame(dataFrame);
    else
        throw cRuntimeError("Unknown message type");
    EV_INFO << "The upper frame has been classified as a " << printAccessCategory(ac) << " frame." << endl;
    if (edcaPendingQueues[ac]->insert(frame)) {
        EV_INFO << "Frame " << frame->getName() << " has been inserted into the PendingQueue." << endl;
        auto edcaf = edca->getChannelOwner();
        if (edcaf == nullptr || edcaf->getAccessCategory() != ac) {
            EV_DETAIL << "Requesting channel for access category " << printAccessCategory(ac) << endl;
            edca->requestChannelAccess(ac, this);
        }
    }
    else {
        EV_INFO << "Frame " << frame->getName() << " has been dropped because the PendingQueue is full." << endl;
        emit(NF_PACKET_DROP, frame);
        delete frame;
    }
}

void inet::ieee80211::Hcf::recipientProcessReceivedControlFrame ( Ieee80211Frame *  frame )

protectedvirtual

Referenced by recipientProcessReceivedFrame().

{
    if (auto rtsFrame = dynamic_cast<Ieee80211RTSFrame *>(frame))
        ctsProcedure->processReceivedRts(rtsFrame, ctsPolicy, this);
    else if (auto blockAckRequest = dynamic_cast<Ieee80211BasicBlockAckReq*>(frame)) {
        if (recipientBlockAckProcedure)
            recipientBlockAckProcedure->processReceivedBlockAckReq(blockAckRequest, recipientAckPolicy, recipientBlockAckAgreementHandler, this);
    }
    else if (dynamic_cast<Ieee80211ACKFrame*>(frame))
        EV_WARN << "ACK frame received after timeout, ignoring it.\n"; // drop it, it is an ACK frame that is received after the ACKTimeout
    else
        throw cRuntimeError("Unknown control frame");
}

void inet::ieee80211::Hcf::recipientProcessReceivedFrame ( Ieee80211Frame *  frame )

protectedvirtual

Referenced by processLowerFrame().

{
    if (auto dataOrMgmtFrame = dynamic_cast<Ieee80211DataOrMgmtFrame *>(frame))
        recipientAckProcedure->processReceivedFrame(dataOrMgmtFrame, check_and_cast<IRecipientAckPolicy*>(recipientAckPolicy), this);
    if (auto dataFrame = dynamic_cast<Ieee80211DataFrame*>(frame)) {
        if (dataFrame->getType() == ST_DATA_WITH_QOS && recipientBlockAckAgreementHandler)
            recipientBlockAckAgreementHandler->qosFrameReceived(dataFrame, this);
        sendUp(recipientDataService->dataFrameReceived(dataFrame, recipientBlockAckAgreementHandler));
    }
    else if (auto mgmtFrame = dynamic_cast<Ieee80211ManagementFrame*>(frame)) {
        sendUp(recipientDataService->managementFrameReceived(mgmtFrame));
        recipientProcessReceivedManagementFrame(mgmtFrame);
        if (dynamic_cast<Ieee80211ActionFrame *>(mgmtFrame))
            delete mgmtFrame;
    }
    else { // TODO: else if (auto ctrlFrame = dynamic_cast<Ieee80211ControlFrame*>(frame))
        sendUp(recipientDataService->controlFrameReceived(frame, recipientBlockAckAgreementHandler));
        recipientProcessReceivedControlFrame(frame);
        delete frame;
    }
}

void inet::ieee80211::Hcf::recipientProcessReceivedManagementFrame ( Ieee80211ManagementFrame *  frame )

protectedvirtual

Referenced by recipientProcessReceivedFrame().

{
    if (recipientBlockAckAgreementHandler && originatorBlockAckAgreementHandler) {
        if (auto addbaRequest = dynamic_cast<Ieee80211AddbaRequest *>(frame))
            recipientBlockAckAgreementHandler->processReceivedAddbaRequest(addbaRequest, recipientBlockAckAgreementPolicy, this);
        else if (auto addbaResp = dynamic_cast<Ieee80211AddbaResponse *>(frame))
            originatorBlockAckAgreementHandler->processReceivedAddbaResp(addbaResp, originatorBlockAckAgreementPolicy, this);
        else if (auto delba = dynamic_cast<Ieee80211Delba*>(frame)) {
            if (delba->getInitiator())
                recipientBlockAckAgreementHandler->processReceivedDelba(delba, recipientBlockAckAgreementPolicy);
            else
                originatorBlockAckAgreementHandler->processReceivedDelba(delba, originatorBlockAckAgreementPolicy);
        }
        else
            ; // Beacon, etc
    }
    else
        ; // Optional modules
}

void inet::ieee80211::Hcf::recipientProcessTransmittedControlResponseFrame ( Ieee80211Frame *  frame )

protectedvirtual

Referenced by transmissionComplete().

{
    if (auto ctsFrame = dynamic_cast<Ieee80211CTSFrame*>(frame))
        ctsProcedure->processTransmittedCts(ctsFrame);
    else if (auto blockAck = dynamic_cast<Ieee80211BlockAck*>(frame)) {
        if (recipientBlockAckProcedure)
            recipientBlockAckProcedure->processTransmittedBlockAck(blockAck);
    }
    else if (auto ackFrame = dynamic_cast<Ieee80211ACKFrame*>(frame))
        recipientAckProcedure->processTransmittedAck(ackFrame);
    else
        throw cRuntimeError("Unknown control response frame");
}

void inet::ieee80211::Hcf::scheduleInactivityTimer ( simtime_t  timeout )

overrideprotectedvirtual

Implements inet::ieee80211::IBlockAckAgreementHandlerCallback.

{
    Enter_Method_Silent();
    if (inactivityTimer->isScheduled())
        cancelEvent(inactivityTimer);
    scheduleAt(simTime() + timeout, inactivityTimer);
}

void inet::ieee80211::Hcf::scheduleStartRxTimer ( simtime_t  timeout )

overrideprotectedvirtual

Implements inet::ieee80211::IFrameSequenceHandler::ICallback.

{
    Enter_Method_Silent();
    scheduleAt(simTime() + timeout, startRxTimer);
}

void inet::ieee80211::Hcf::sendUp ( const std::vector< Ieee80211Frame * > &  completeFrames )

protected

Referenced by recipientProcessReceivedFrame().

{
    for (auto frame : completeFrames) {
        // FIXME: mgmt module does not handle addba req ..
        if (!dynamic_cast<Ieee80211ActionFrame *>(frame))
            mac->sendUp(frame);
    }
}

void inet::ieee80211::Hcf::setFrameMode ( Ieee80211Frame *  frame, const IIeee80211Mode *  mode  ) const

protectedvirtual

Referenced by transmitControlResponseFrame(), and transmitFrame().

 {
    ASSERT(mode != nullptr);
    delete frame->removeControlInfo();
    Ieee80211TransmissionRequest *ctrl = new Ieee80211TransmissionRequest();
    ctrl->setMode(mode);
    frame->setControlInfo(ctrl);
}

void inet::ieee80211::Hcf::startFrameSequence ( AccessCategory  ac )

protected

Referenced by channelGranted().

{
    frameSequenceHandler->startFrameSequence(new HcfFs(), buildContext(ac), this);
}

void inet::ieee80211::Hcf::transmissionComplete ( Ieee80211Frame *  frame )

overrideprotectedvirtual

Implements inet::ieee80211::ITx::ICallback.

{
    auto edcaf = edca->getChannelOwner();
    if (edcaf)
        frameSequenceHandler->transmissionComplete();
    else if (hcca->isOwning())
        throw cRuntimeError("Hcca is unimplemented!");
    else
        recipientProcessTransmittedControlResponseFrame(frame);
    delete frame;
}

void inet::ieee80211::Hcf::transmitControlResponseFrame ( Ieee80211Frame *  responseFrame, Ieee80211Frame *  receivedFrame  )

overrideprotectedvirtual

Implements inet::ieee80211::IProcedureCallback.

{
    const IIeee80211Mode *responseMode = nullptr;
    if (auto rtsFrame = dynamic_cast<Ieee80211RTSFrame*>(receivedFrame))
        responseMode = rateSelection->computeResponseCtsFrameMode(rtsFrame);
    else if (auto blockAckReq = dynamic_cast<Ieee80211BasicBlockAckReq*>(receivedFrame))
        responseMode = rateSelection->computeResponseBlockAckFrameMode(blockAckReq);
    else if (auto dataOrMgmtFrame = dynamic_cast<Ieee80211DataOrMgmtFrame*>(receivedFrame))
        responseMode = rateSelection->computeResponseAckFrameMode(dataOrMgmtFrame);
    else
        throw cRuntimeError("Unknown received frame type");
    setFrameMode(responseFrame, responseMode);
    tx->transmitFrame(responseFrame, modeSet->getSifsTime(), this);
    delete responseFrame;
}

void inet::ieee80211::Hcf::transmitFrame ( Ieee80211Frame *  frame, simtime_t  ifs  )

overrideprotectedvirtual

Implements inet::ieee80211::IFrameSequenceHandler::ICallback.

{
    auto channelOwner = edca->getChannelOwner();
    if (channelOwner) {
        AccessCategory ac = channelOwner->getAccessCategory();
        auto txop = edcaTxops[ac];
        if (auto dataFrame = dynamic_cast<Ieee80211DataFrame*>(frame)) {
            OriginatorBlockAckAgreement *agreement = nullptr;
            if (originatorBlockAckAgreementHandler)
                agreement = originatorBlockAckAgreementHandler->getAgreement(dataFrame->getReceiverAddress(), dataFrame->getTid());
            auto ackPolicy = originatorAckPolicy->computeAckPolicy(dataFrame, agreement);
            dataFrame->setAckPolicy(ackPolicy);
        }
        setFrameMode(frame, rateSelection->computeMode(frame, txop));
        if (txop->getProtectionMechanism() == TxopProcedure::ProtectionMechanism::SINGLE_PROTECTION)
            frame->setDuration(singleProtectionMechanism->computeDurationField(frame, edcaInProgressFrames[ac]->getPendingFrameFor(frame), edcaTxops[ac], recipientAckPolicy));
        else if (txop->getProtectionMechanism() == TxopProcedure::ProtectionMechanism::MULTIPLE_PROTECTION)
            throw cRuntimeError("Multiple protection is unsupported");
        else
            throw cRuntimeError("Undefined protection mechanism");
        tx->transmitFrame(frame, ifs, this);
    }
    else
        throw cRuntimeError("Hcca is unimplemented");
}

Member Data Documentation

ICtsPolicy* inet::ieee80211::Hcf::ctsPolicy = nullptr

protected

Referenced by initialize(), and recipientProcessReceivedControlFrame().

ICtsProcedure* inet::ieee80211::Hcf::ctsProcedure = nullptr

protected

Referenced by initialize(), recipientProcessReceivedControlFrame(), recipientProcessTransmittedControlResponseFrame(), and ~Hcf().

IRateControl* inet::ieee80211::Hcf::dataAndMgmtRateControl = nullptr

protected

Referenced by initialize(), originatorProcessFailedFrame(), and originatorProcessReceivedControlFrame().

Edca* inet::ieee80211::Hcf::edca = nullptr

protected

Referenced by channelGranted(), frameSequenceFinished(), hasFrameToTransmit(), initialize(), originatorProcessFailedFrame(), originatorProcessReceivedFrame(), originatorProcessRtsProtectionFailed(), originatorProcessTransmittedFrame(), processLowerFrame(), processUpperFrame(), transmissionComplete(), and transmitFrame().

std::vector<QoSAckHandler *> inet::ieee80211::Hcf::edcaAckHandlers

protected

Referenced by initialize(), originatorProcessFailedFrame(), originatorProcessReceivedControlFrame(), originatorProcessTransmittedControlFrame(), originatorProcessTransmittedDataFrame(), originatorProcessTransmittedManagementFrame(), and ~Hcf().

std::vector<QoSRecoveryProcedure*> inet::ieee80211::Hcf::edcaDataRecoveryProcedures

protected

Referenced by handleInternalCollision(), initialize(), originatorProcessFailedFrame(), originatorProcessReceivedControlFrame(), originatorProcessRtsProtectionFailed(), and originatorProcessTransmittedFrame().

std::vector<InProgressFrames *> inet::ieee80211::Hcf::edcaInProgressFrames

protected

Referenced by buildContext(), handleInternalCollision(), hasFrameToTransmit(), initialize(), originatorProcessFailedFrame(), originatorProcessReceivedControlFrame(), originatorProcessRtsProtectionFailed(), originatorProcessTransmittedDataFrame(), originatorProcessTransmittedFrame(), transmitFrame(), and ~Hcf().

NonQoSRecoveryProcedure* inet::ieee80211::Hcf::edcaMgmtAndNonQoSRecoveryProcedure = nullptr

protected

Referenced by handleInternalCollision(), initialize(), originatorProcessFailedFrame(), originatorProcessReceivedControlFrame(), and originatorProcessRtsProtectionFailed().

std::vector<PendingQueue *> inet::ieee80211::Hcf::edcaPendingQueues

protected

Referenced by hasFrameToTransmit(), initialize(), processUpperFrame(), and ~Hcf().

std::vector<TxopProcedure*> inet::ieee80211::Hcf::edcaTxops

protected

Referenced by buildContext(), channelGranted(), frameSequenceFinished(), initialize(), and transmitFrame().

IFrameSequenceHandler* inet::ieee80211::Hcf::frameSequenceHandler = nullptr

protected

Referenced by corruptedFrameReceived(), handleMessage(), initialize(), processLowerFrame(), startFrameSequence(), transmissionComplete(), and ~Hcf().

Hcca* inet::ieee80211::Hcf::hcca = nullptr

protected

Referenced by frameSequenceFinished(), initialize(), originatorProcessTransmittedFrame(), processLowerFrame(), and transmissionComplete().

InProgressFrames* inet::ieee80211::Hcf::hccaInProgressFrame = nullptr

protected

PendingQueue* inet::ieee80211::Hcf::hccaPendingQueue = nullptr

protected

TxopProcedure* inet::ieee80211::Hcf::hccaTxop = nullptr

protected

cMessage* inet::ieee80211::Hcf::inactivityTimer = nullptr

protected

Referenced by handleMessage(), initialize(), scheduleInactivityTimer(), and ~Hcf().

EdcaTransmitLifetimeHandler* inet::ieee80211::Hcf::lifetimeHandler = nullptr

protected

Ieee80211Mac* inet::ieee80211::Hcf::mac = nullptr

protected

Referenced by buildContext(), frameSequenceFinished(), initialize(), isForUs(), isSentByUs(), and sendUp().

int inet::ieee80211::Hcf::numEdcafs = -1

protected

Referenced by initialize().

IOriginatorQoSAckPolicy* inet::ieee80211::Hcf::originatorAckPolicy = nullptr

protected

Referenced by buildContext(), initialize(), originatorProcessTransmittedManagementFrame(), and transmitFrame().

IOriginatorBlockAckAgreementHandler* inet::ieee80211::Hcf::originatorBlockAckAgreementHandler = nullptr

protected

Referenced by buildContext(), handleMessage(), initialize(), originatorProcessReceivedControlFrame(), originatorProcessTransmittedDataFrame(), originatorProcessTransmittedManagementFrame(), recipientProcessReceivedManagementFrame(), transmitFrame(), and ~Hcf().

IOriginatorBlockAckAgreementPolicy* inet::ieee80211::Hcf::originatorBlockAckAgreementPolicy = nullptr

protected

Referenced by initialize(), originatorProcessTransmittedDataFrame(), and recipientProcessReceivedManagementFrame().

IOriginatorBlockAckProcedure* inet::ieee80211::Hcf::originatorBlockAckProcedure = nullptr

protected

Referenced by buildContext(), initialize(), and ~Hcf().

IOriginatorMacDataService* inet::ieee80211::Hcf::originatorDataService = nullptr

protected

Referenced by initialize().

IQoSRateSelection* inet::ieee80211::Hcf::rateSelection = nullptr

protected

Referenced by initialize(), transmitControlResponseFrame(), and transmitFrame().

IRecipientQoSAckPolicy* inet::ieee80211::Hcf::recipientAckPolicy = nullptr

protected

Referenced by initialize(), recipientProcessReceivedControlFrame(), recipientProcessReceivedFrame(), and transmitFrame().

IRecipientAckProcedure* inet::ieee80211::Hcf::recipientAckProcedure = nullptr

protected

Referenced by initialize(), recipientProcessReceivedFrame(), recipientProcessTransmittedControlResponseFrame(), and ~Hcf().

IRecipientBlockAckAgreementHandler* inet::ieee80211::Hcf::recipientBlockAckAgreementHandler = nullptr

protected

Referenced by handleMessage(), initialize(), originatorProcessTransmittedManagementFrame(), recipientProcessReceivedControlFrame(), recipientProcessReceivedFrame(), recipientProcessReceivedManagementFrame(), and ~Hcf().

IRecipientBlockAckAgreementPolicy* inet::ieee80211::Hcf::recipientBlockAckAgreementPolicy = nullptr

protected

Referenced by initialize(), and recipientProcessReceivedManagementFrame().

IRecipientBlockAckProcedure* inet::ieee80211::Hcf::recipientBlockAckProcedure = nullptr

protected

Referenced by initialize(), recipientProcessReceivedControlFrame(), recipientProcessTransmittedControlResponseFrame(), and ~Hcf().

IRecipientQoSMacDataService* inet::ieee80211::Hcf::recipientDataService = nullptr

protected

Referenced by initialize(), and recipientProcessReceivedFrame().

IRtsPolicy* inet::ieee80211::Hcf::rtsPolicy = nullptr

protected

Referenced by buildContext(), and initialize().

IRtsProcedure* inet::ieee80211::Hcf::rtsProcedure = nullptr

protected

Referenced by buildContext(), initialize(), originatorProcessTransmittedControlFrame(), and ~Hcf().

IRx* inet::ieee80211::Hcf::rx = nullptr

protected

Referenced by initialize(), and isReceptionInProgress().

SingleProtectionMechanism* inet::ieee80211::Hcf::singleProtectionMechanism = nullptr

protected

Referenced by initialize(), and transmitFrame().

cMessage* inet::ieee80211::Hcf::startRxTimer = nullptr

protected

Referenced by corruptedFrameReceived(), handleMessage(), initialize(), processLowerFrame(), scheduleStartRxTimer(), and ~Hcf().

std::vector<StationRetryCounters*> inet::ieee80211::Hcf::stationRetryCounters

protected

Referenced by handleInternalCollision(), initialize(), originatorProcessFailedFrame(), originatorProcessReceivedControlFrame(), originatorProcessRtsProtectionFailed(), and ~Hcf().

ITx* inet::ieee80211::Hcf::tx = nullptr

protected

Referenced by initialize(), transmitControlResponseFrame(), and transmitFrame().

---

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

• Hcf.h
• Hcf.cc