Implements IEEE 802.11 Distributed Coordination Function. More...

#include <Dcf.h>

Inheritance diagram for inet::ieee80211::Dcf:

Public Member Functions
virtual	~Dcf ()

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 ()

Protected Member Functions
virtual int	numInitStages () const override

virtual void	initialize (int stage) override

virtual void	handleMessage (cMessage *msg) override

virtual void	sendUp (const std::vector< Ieee80211Frame * > &completeFrames)

virtual bool	hasFrameToTransmit ()

virtual bool	isReceptionInProgress ()

virtual FrameSequenceContext *	buildContext ()

virtual void	recipientProcessReceivedFrame (Ieee80211Frame *frame)

virtual void	recipientProcessControlFrame (Ieee80211Frame *frame)

virtual void	recipientProcessTransmittedControlResponseFrame (Ieee80211Frame *frame)

virtual void	channelGranted (IChannelAccess *channelAccess) override

virtual void	transmitFrame (Ieee80211Frame *frame, simtime_t ifs) override

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	scheduleStartRxTimer (simtime_t timeout) override

virtual void	transmissionComplete (Ieee80211Frame *frame) override

virtual void	transmitControlResponseFrame (Ieee80211Frame responseFrame, Ieee80211Frame receivedFrame) override

virtual void	processMgmtFrame (Ieee80211ManagementFrame *mgmtFrame) override

virtual bool	isSentByUs (Ieee80211Frame *frame) const

virtual bool	isForUs (Ieee80211Frame *frame) const

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

cMessage *	startRxTimer = nullptr

IRx *	rx = nullptr

ITx *	tx = nullptr

IRateSelection *	rateSelection = nullptr

Dcaf *	dcfChannelAccess = nullptr

IOriginatorMacDataService *	originatorDataService = nullptr

IRecipientMacDataService *	recipientDataService = nullptr

AckHandler *	ackHandler = nullptr

IOriginatorAckPolicy *	originatorAckPolicy = nullptr

IRecipientAckProcedure *	recipientAckProcedure = nullptr

IRecipientAckPolicy *	recipientAckPolicy = nullptr

IRtsProcedure *	rtsProcedure = nullptr

IRtsPolicy *	rtsPolicy = nullptr

ICtsProcedure *	ctsProcedure = nullptr

ICtsPolicy *	ctsPolicy = nullptr

NonQoSRecoveryProcedure *	recoveryProcedure = nullptr

ITransmitLifetimeHandler *	transmitLifetimeHandler = nullptr

DcfReceiveLifetimeHandler *	receiveLifetimeHandler = nullptr

OriginatorProtectionMechanism *	originatorProtectionMechanism = nullptr

PendingQueue *	pendingQueue = nullptr

InProgressFrames *	inProgressFrames = nullptr

IFrameSequenceHandler *	frameSequenceHandler = nullptr

StationRetryCounters *	stationRetryCounters = nullptr

Protected Attributes inherited from inet::ieee80211::ModeSetListener
Ieee80211ModeSet *	modeSet = nullptr

Detailed Description

Implements IEEE 802.11 Distributed Coordination Function.

Constructor & Destructor Documentation

inet::ieee80211::Dcf::~Dcf ( )

virtual

 {
     cancelAndDelete(startRxTimer);
     delete rtsProcedure;
     delete recipientAckProcedure;
     delete ackHandler;
     delete stationRetryCounters;
     delete ctsProcedure;
     delete frameSequenceHandler;
     delete inProgressFrames;
     delete pendingQueue;
 }

Member Function Documentation

FrameSequenceContext * inet::ieee80211::Dcf::buildContext ( )

protectedvirtual

Referenced by channelGranted().

 {
     auto nonQoSContext = new NonQoSContext(originatorAckPolicy);
     return new FrameSequenceContext(mac->getAddress(), modeSet, inProgressFrames, rtsProcedure, rtsPolicy, nonQoSContext, nullptr);
 }

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

overrideprotectedvirtual

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

 {
     ASSERT(dcfChannelAccess == channelAccess);
     if (!frameSequenceHandler->isSequenceRunning())
         frameSequenceHandler->startFrameSequence(new DcfFs(), buildContext(), this);
 }

void inet::ieee80211::Dcf::corruptedFrameReceived ( )

overridevirtual

Implements inet::ieee80211::ICoordinationFunction.

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

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

void inet::ieee80211::Dcf::frameSequenceFinished ( )

overrideprotectedvirtual

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

 {
     dcfChannelAccess->releaseChannel(this);
     if (hasFrameToTransmit())
         dcfChannelAccess->requestChannel(this);
     mac->sendDownPendingRadioConfigMsg(); // TODO: review
 }

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

overrideprotectedvirtual

 {
     if (msg == startRxTimer) {
         if (!isReceptionInProgress())
             frameSequenceHandler->handleStartRxTimeout();
     }
     else
         throw cRuntimeError("Unknown msg type");
 }

bool inet::ieee80211::Dcf::hasFrameToTransmit ( )

protectedvirtual

Referenced by frameSequenceFinished().

 {
     return !pendingQueue->isEmpty() || inProgressFrames->hasInProgressFrames();
 }

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

overrideprotectedvirtual

Reimplemented from inet::ieee80211::ModeSetListener.

 {
     ModeSetListener::initialize(stage);
     if (stage == INITSTAGE_LINK_LAYER_2) {
         startRxTimer = new cMessage("startRxTimeout");
         mac = check_and_cast<Ieee80211Mac *>(getContainingNicModule(this)->getSubmodule("mac"));
         dataAndMgmtRateControl = dynamic_cast<IRateControl *>(getSubmodule(("rateControl")));
         tx = check_and_cast<ITx *>(getModuleByPath(par("txModule")));
         rx = check_and_cast<IRx *>(getModuleByPath(par("rxModule")));
         dcfChannelAccess = check_and_cast<Dcaf *>(getSubmodule("channelAccess"));
         originatorDataService = check_and_cast<IOriginatorMacDataService *>(getSubmodule(("originatorMacDataService")));
         recipientDataService = check_and_cast<IRecipientMacDataService*>(getSubmodule("recipientMacDataService"));
         recoveryProcedure = check_and_cast<NonQoSRecoveryProcedure *>(getSubmodule("recoveryProcedure"));
         rateSelection = check_and_cast<IRateSelection*>(getSubmodule("rateSelection"));
         pendingQueue = new PendingQueue(par("maxQueueSize"), nullptr, par("prioritizeMulticast") ? PendingQueue::Priority::PRIORITIZE_MULTICAST_OVER_DATA : PendingQueue::Priority::PRIORITIZE_MGMT_OVER_DATA);
         rtsProcedure = new RtsProcedure();
         rtsPolicy = check_and_cast<IRtsPolicy *>(getSubmodule("rtsPolicy"));
         recipientAckProcedure = new RecipientAckProcedure();
         recipientAckPolicy = check_and_cast<IRecipientAckPolicy *>(getSubmodule("recipientAckPolicy"));
         originatorAckPolicy = check_and_cast<IOriginatorAckPolicy *>(getSubmodule("originatorAckPolicy"));
         frameSequenceHandler = new FrameSequenceHandler();
         ackHandler = new AckHandler();
         ctsProcedure = new CtsProcedure();
         ctsPolicy = check_and_cast<ICtsPolicy *>(getSubmodule("ctsPolicy"));
         stationRetryCounters = new StationRetryCounters();
         inProgressFrames = new InProgressFrames(pendingQueue, originatorDataService, ackHandler);
         originatorProtectionMechanism = check_and_cast<OriginatorProtectionMechanism*>(getSubmodule("originatorProtectionMechanism"));
     }
 }

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

protectedvirtual

Referenced by processLowerFrame().

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

bool inet::ieee80211::Dcf::isReceptionInProgress ( )

protectedvirtual

Referenced by handleMessage().

 {
     return rx->isReceptionInProgress();
 }

bool inet::ieee80211::Dcf::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::Dcf::numInitStages ( ) const

inlineoverrideprotectedvirtual

Reimplemented from inet::ieee80211::ModeSetListener.

102 { return NUM_INIT_STAGES; }

inet::NUM_INIT_STAGES

The number of initialization stages.

Definition: InitStages.h:116

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

overrideprotectedvirtual

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

 {
     ASSERT(failedFrame->getType() != ST_DATA_WITH_QOS);
     ASSERT(ackHandler->getAckStatus(failedFrame) == AckHandler::Status::WAITING_FOR_ACK);
     EV_INFO << "Data/Mgmt frame transmission failed\n";
     recoveryProcedure->dataOrMgmtFrameTransmissionFailed(failedFrame, stationRetryCounters);
     bool retryLimitReached = recoveryProcedure->isRetryLimitReached(failedFrame);
     if (dataAndMgmtRateControl) {
         int retryCount = recoveryProcedure->getRetryCount(failedFrame);
         dataAndMgmtRateControl->frameTransmitted(failedFrame, retryCount, false, retryLimitReached);
     }
     ackHandler->processFailedFrame(failedFrame);
     if (retryLimitReached) {
         emit(NF_LINK_BREAK, failedFrame);
         recoveryProcedure->retryLimitReached(failedFrame);
         inProgressFrames->dropFrame(failedFrame);
         emit(NF_PACKET_DROP, failedFrame);
     }
     else
         failedFrame->setRetry(true);
 }

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

overrideprotectedvirtual

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

 {
     if (frame->getType() == ST_ACK) {
         auto lastTransmittedDataOrMgmtFrame = check_and_cast<Ieee80211DataOrMgmtFrame*>(lastTransmittedFrame);
         if (dataAndMgmtRateControl) {
             int retryCount = lastTransmittedFrame->getRetry() ? recoveryProcedure->getRetryCount(lastTransmittedDataOrMgmtFrame) : 0;
             dataAndMgmtRateControl->frameTransmitted(frame, retryCount, true, false);
         }
         recoveryProcedure->ackFrameReceived(lastTransmittedDataOrMgmtFrame, stationRetryCounters);
         ackHandler->processReceivedAck(check_and_cast<Ieee80211ACKFrame *>(frame), lastTransmittedDataOrMgmtFrame);
         inProgressFrames->dropFrame(lastTransmittedDataOrMgmtFrame);
     }
     else if (frame->getType() == ST_RTS)
         ; // void
     else if (frame->getType() == ST_CTS)
         recoveryProcedure->ctsFrameReceived(stationRetryCounters);
     else
         throw cRuntimeError("Unknown frame type");
 }

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

overrideprotectedvirtual

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

 {
     EV_INFO << "RTS frame transmission failed\n";
     recoveryProcedure->rtsFrameTransmissionFailed(protectedFrame, stationRetryCounters);
     EV_INFO << "For the current frame exchange, we have CW = " << dcfChannelAccess->getCw() << " SRC = " << recoveryProcedure->getShortRetryCount(protectedFrame) << " LRC = " << recoveryProcedure->getLongRetryCount(protectedFrame) << " SSRC = " << stationRetryCounters->getStationShortRetryCount() << " and SLRC = " << stationRetryCounters->getStationLongRetryCount() << std::endl;
     if (recoveryProcedure->isRtsFrameRetryLimitReached(protectedFrame)) {
         emit(NF_LINK_BREAK, protectedFrame);
         recoveryProcedure->retryLimitReached(protectedFrame);
         inProgressFrames->dropFrame(protectedFrame);
         emit(NF_PACKET_DROP, protectedFrame);
     }
 }

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

overrideprotectedvirtual

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

 {
     if (auto dataOrMgmtFrame = dynamic_cast<Ieee80211DataOrMgmtFrame *>(transmittedFrame)) {
         EV_INFO << "For the current frame exchange, we have CW = " << dcfChannelAccess->getCw() << " SRC = " << recoveryProcedure->getShortRetryCount(dataOrMgmtFrame) << " LRC = " << recoveryProcedure->getLongRetryCount(dataOrMgmtFrame) << " SSRC = " << stationRetryCounters->getStationShortRetryCount() << " and SLRC = " << stationRetryCounters->getStationLongRetryCount() << std::endl;
         if (originatorAckPolicy->isAckNeeded(dataOrMgmtFrame)) {
             ackHandler->processTransmittedDataOrMgmtFrame(dataOrMgmtFrame);
         }
         else if (dataOrMgmtFrame->getReceiverAddress().isMulticast()) {
             recoveryProcedure->multicastFrameTransmitted(stationRetryCounters);
             inProgressFrames->dropFrame(dataOrMgmtFrame);
         }
     }
     else if (auto rtsFrame = dynamic_cast<Ieee80211RTSFrame *>(transmittedFrame)) {
         auto protectedFrame = inProgressFrames->getFrameToTransmit(); // TODO: kludge
         EV_INFO << "For the current frame exchange, we have CW = " << dcfChannelAccess->getCw() << " SRC = " << recoveryProcedure->getShortRetryCount(protectedFrame) << " LRC = " << recoveryProcedure->getLongRetryCount(protectedFrame) << " SSRC = " << stationRetryCounters->getStationShortRetryCount() << " and SLRC = " << stationRetryCounters->getStationLongRetryCount() << std::endl;
         rtsProcedure->processTransmittedRts(rtsFrame);
     }
 }

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

overridevirtual

Implements inet::ieee80211::ICoordinationFunction.

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

 {
     Enter_Method_Silent();
     if (frameSequenceHandler->isSequenceRunning()) {
         // TODO: always call processResponses
         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 (isForUs(frame))
         recipientProcessReceivedFrame(frame);
     else {
         EV_INFO << "This frame is not for us" << std::endl;
         delete frame;
     }
 }

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

overrideprotectedvirtual

Implements inet::ieee80211::IProcedureCallback.

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

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

overridevirtual

Implements inet::ieee80211::ICoordinationFunction.

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

 {
     Enter_Method("processUpperFrame(%s)", frame->getName());
     EV_INFO << "Processing upper frame: " << frame->getName() << endl;
     if (pendingQueue->insert(frame)) {
         EV_INFO << "Frame " << frame->getName() << " has been inserted into the PendingQueue." << endl;
         EV_DETAIL << "Requesting channel" << endl;
         dcfChannelAccess->requestChannel(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::Dcf::recipientProcessControlFrame ( Ieee80211Frame * frame )

protectedvirtual

Referenced by recipientProcessReceivedFrame().

 {
     if (auto rtsFrame = dynamic_cast<Ieee80211RTSFrame *>(frame))
         ctsProcedure->processReceivedRts(rtsFrame, ctsPolicy, this);
     else
         throw cRuntimeError("Unknown control frame");
 }

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

protectedvirtual

Referenced by processLowerFrame().

 {
     if (auto dataOrMgmtFrame = dynamic_cast<Ieee80211DataOrMgmtFrame *>(frame))
         recipientAckProcedure->processReceivedFrame(dataOrMgmtFrame, recipientAckPolicy, this);
     if (auto dataFrame = dynamic_cast<Ieee80211DataFrame*>(frame))
         sendUp(recipientDataService->dataFrameReceived(dataFrame));
     else if (auto mgmtFrame = dynamic_cast<Ieee80211ManagementFrame*>(frame))
         sendUp(recipientDataService->managementFrameReceived(mgmtFrame));
     else { // TODO: else if (auto ctrlFrame = dynamic_cast<Ieee80211ControlFrame*>(frame))
         sendUp(recipientDataService->controlFrameReceived(frame));
         recipientProcessControlFrame(frame);
         delete frame;
     }
 }

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

protectedvirtual

Referenced by transmissionComplete().

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

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

overrideprotectedvirtual

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

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

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

protectedvirtual

Referenced by recipientProcessReceivedFrame().

 {
     for (auto frame : completeFrames)
         mac->sendUp(frame);
 }

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

overrideprotectedvirtual

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

 {
     if (frameSequenceHandler->isSequenceRunning())
         frameSequenceHandler->transmissionComplete();
     else
         recipientProcessTransmittedControlResponseFrame(frame);
     delete frame;
 }

void inet::ieee80211::Dcf::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 dataOrMgmtFrame = dynamic_cast<Ieee80211DataOrMgmtFrame*>(receivedFrame))
         responseMode = rateSelection->computeResponseAckFrameMode(dataOrMgmtFrame);
     else
         throw cRuntimeError("Unknown received frame type");
     RateSelection::setFrameMode(responseFrame, responseMode);
     tx->transmitFrame(responseFrame, modeSet->getSifsTime(), this);
     delete responseFrame;
 }

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

overrideprotectedvirtual

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

 {
     RateSelection::setFrameMode(frame, rateSelection->computeMode(frame));
     frame->setDuration(originatorProtectionMechanism->computeDurationField(frame, inProgressFrames->getPendingFrameFor(frame)));
     tx->transmitFrame(frame, ifs, this);
 }