inet::ieee80211::SingleProtectionMechanism Class Reference

#include <SingleProtectionMechanism.h>

Inheritance diagram for inet::ieee80211::SingleProtectionMechanism:

Public Member Functions
virtual	~SingleProtectionMechanism ()
virtual simtime_t	computeDurationField (Packet *packet, const Ptr< const Ieee80211MacHeader > &header, Packet *pendingPacket, const Ptr< const Ieee80211DataOrMgmtHeader > &pendingHeader, TxopProcedure *txop, IRecipientQosAckPolicy *ackPolicy)

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual simtime_t	computeRtsDurationField (Packet *rtsPacket, const Ptr< const Ieee80211RtsFrame > &rtsFrame, Packet *pendingPacket, const Ptr< const Ieee80211DataOrMgmtHeader > &pendingHeader, TxopProcedure *txop, IRecipientQosAckPolicy *ackPolicy)
virtual simtime_t	computeCtsDurationField (const Ptr< const Ieee80211CtsFrame > &ctsFrame)
virtual simtime_t	computeBlockAckReqDurationField (Packet *packet, const Ptr< const Ieee80211BlockAckReq > &blockAckReq)
virtual simtime_t	computeBlockAckDurationField (const Ptr< const Ieee80211BlockAck > &blockAck)
virtual simtime_t	computeDataOrMgmtFrameDurationField (Packet *packet, const Ptr< const Ieee80211DataOrMgmtHeader > &dataOrMgmtHeader, Packet *pendingPacket, const Ptr< const Ieee80211DataOrMgmtHeader > &pendingHeader, TxopProcedure *txop, IRecipientQosAckPolicy *ackPolicy)
Protected Member Functions inherited from inet::ieee80211::ModeSetListener
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override

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

Constructor & Destructor Documentation

~SingleProtectionMechanism()

virtual inet::ieee80211::SingleProtectionMechanism::~SingleProtectionMechanism ( )

inlinevirtual

{}

Member Function Documentation

computeBlockAckDurationField()

simtime_t inet::ieee80211::SingleProtectionMechanism::computeBlockAckDurationField ( const Ptr< const Ieee80211BlockAck > &  blockAck )

protectedvirtual

{
    throw cRuntimeError("Unimplemented");
}

Referenced by computeDurationField().

computeBlockAckReqDurationField()

simtime_t inet::ieee80211::SingleProtectionMechanism::computeBlockAckReqDurationField ( Packet *  packet, const Ptr< const Ieee80211BlockAckReq > &  blockAckReq  )

protectedvirtual

{
    // TODO ACK or BlockAck frame, as applicable
    if (dynamicPtrCast<const Ieee80211BasicBlockAckReq>(blockAckReq)) {
        simtime_t blockAckFrameDuration = rateSelection->computeResponseBlockAckFrameMode(packet, blockAckReq)->getDuration(LENGTH_BASIC_BLOCKACK);
        simtime_t blockAckReqDurationPerId = blockAckFrameDuration + modeSet->getSifsTime();
        return blockAckReqDurationPerId;
    }
    else
        throw cRuntimeError("Compressed and Multi-Tid Block Ack Requests are not supported");
}

Referenced by computeDurationField().

computeCtsDurationField()

simtime_t inet::ieee80211::SingleProtectionMechanism::computeCtsDurationField ( const Ptr< const Ieee80211CtsFrame > &  ctsFrame )

protectedvirtual

{
    throw cRuntimeError("Self CTS is not supported");
}

Referenced by computeDurationField().

computeDataOrMgmtFrameDurationField()

simtime_t inet::ieee80211::SingleProtectionMechanism::computeDataOrMgmtFrameDurationField ( Packet *  packet, const Ptr< const Ieee80211DataOrMgmtHeader > &  dataOrMgmtHeader, Packet *  pendingPacket, const Ptr< const Ieee80211DataOrMgmtHeader > &  pendingHeader, TxopProcedure *  txop, IRecipientQosAckPolicy *  ackPolicy  )

protectedvirtual

{
    bool mgmtFrame = false;
    bool mgmtFrameWithNoAck = false;
    bool groupAddressed = dataOrMgmtHeader->getReceiverAddress().isMulticast();
    if (dynamicPtrCast<const Ieee80211MgmtHeader>(dataOrMgmtHeader)) {
        mgmtFrame = true;
        mgmtFrameWithNoAck = false; // FIXME ack policy?
    }
    bool nonQoSData = dataOrMgmtHeader->getType() == ST_DATA;
    bool individuallyAddressedDataWithNormalAck = false;
    bool individuallyAddressedDataWithNoAckOrBlockAck = false;
    if (auto dataHeader = dynamicPtrCast<const Ieee80211DataHeader>(dataOrMgmtHeader)) {
        individuallyAddressedDataWithNormalAck = !groupAddressed && dataHeader->getAckPolicy() == AckPolicy::NORMAL_ACK;
        individuallyAddressedDataWithNoAckOrBlockAck = !groupAddressed && (dataHeader->getAckPolicy() == AckPolicy::NO_ACK || dataHeader->getAckPolicy() == AckPolicy::BLOCK_ACK);
    }
    if (mgmtFrame || nonQoSData || individuallyAddressedDataWithNormalAck) {
        simtime_t ackFrameDuration = rateSelection->computeResponseAckFrameMode(packet, dataOrMgmtHeader)->getDuration(LENGTH_ACK);
        if (txop->isFinalFragment(dataOrMgmtHeader)) {
            return ackFrameDuration + modeSet->getSifsTime();
        }
        else {
            simtime_t ackFrameDuration = rateSelection->computeResponseAckFrameMode(packet, dataOrMgmtHeader)->getDuration(LENGTH_ACK);
            simtime_t duration = ackFrameDuration + modeSet->getSifsTime();
            if (pendingHeader) {
                auto pendingFrameMode = rateSelection->computeMode(pendingPacket, pendingHeader, txop);
                simtime_t pendingFrameDuration = pendingFrameMode->getDuration(pendingPacket->getDataLength());
                duration += pendingFrameDuration + modeSet->getSifsTime();
                if (ackPolicy->isAckNeeded(pendingHeader)) {
                    RateSelection::setFrameMode(pendingPacket, pendingHeader, pendingFrameMode); // KLUDGE
                    simtime_t ackToPendingFrameDuration = rateSelection->computeResponseAckFrameMode(pendingPacket, pendingHeader)->getDuration(LENGTH_ACK);
                    duration += ackToPendingFrameDuration + modeSet->getSifsTime();
                }
            }
            return duration;
        }
    }
    if (individuallyAddressedDataWithNoAckOrBlockAck || mgmtFrameWithNoAck || groupAddressed) {
        if (txop->isFinalFragment(dataOrMgmtHeader))
            return 0;
        else {
            simtime_t duration = 0;
            if (pendingHeader) {
                auto pendingFrameMode = rateSelection->computeMode(pendingPacket, pendingHeader, txop);
                simtime_t pendingFrameDuration = pendingFrameMode->getDuration(pendingPacket->getDataLength());
                duration = pendingFrameDuration + modeSet->getSifsTime();
                if (ackPolicy->isAckNeeded(pendingHeader)) {
                    RateSelection::setFrameMode(pendingPacket, pendingHeader, pendingFrameMode); // KLUDGE
                    simtime_t ackToPendingFrameDuration = rateSelection->computeResponseAckFrameMode(pendingPacket, pendingHeader)->getDuration(LENGTH_ACK);
                    duration += ackToPendingFrameDuration + modeSet->getSifsTime();
                }
            }
            return duration;
        }
    }
    throw cRuntimeError("Unknown frame");
}

Referenced by computeDurationField().

computeDurationField()

simtime_t inet::ieee80211::SingleProtectionMechanism::computeDurationField ( Packet *  packet, const Ptr< const Ieee80211MacHeader > &  header, Packet *  pendingPacket, const Ptr< const Ieee80211DataOrMgmtHeader > &  pendingHeader, TxopProcedure *  txop, IRecipientQosAckPolicy *  ackPolicy  )

virtual

{
    if (auto rtsFrame = dynamicPtrCast<const Ieee80211RtsFrame>(header))
        return computeRtsDurationField(packet, rtsFrame, pendingPacket, pendingHeader, txop, ackPolicy);
    else if (auto ctsFrame = dynamicPtrCast<const Ieee80211CtsFrame>(header))
        return computeCtsDurationField(ctsFrame);
    else if (auto blockAckReq = dynamicPtrCast<const Ieee80211BlockAckReq>(header))
        return computeBlockAckReqDurationField(packet, blockAckReq);
    else if (auto blockAck = dynamicPtrCast<const Ieee80211BlockAck>(header))
        return computeBlockAckDurationField(blockAck);
    else if (auto dataOrMgmtHeader = dynamicPtrCast<const Ieee80211DataOrMgmtHeader>(header))
        return computeDataOrMgmtFrameDurationField(packet, dataOrMgmtHeader, pendingPacket, pendingHeader, txop, ackPolicy);
    else
        throw cRuntimeError("Unknown frame type");
}

computeRtsDurationField()

simtime_t inet::ieee80211::SingleProtectionMechanism::computeRtsDurationField ( Packet *  rtsPacket, const Ptr< const Ieee80211RtsFrame > &  rtsFrame, Packet *  pendingPacket, const Ptr< const Ieee80211DataOrMgmtHeader > &  pendingHeader, TxopProcedure *  txop, IRecipientQosAckPolicy *  ackPolicy  )

protectedvirtual

{
    // TODO We assume that the RTS frame is not part of a dual clear-to-send
    auto pendingFrameMode = rateSelection->computeMode(pendingPacket, pendingHeader, txop);
    simtime_t pendingFrameDuration = pendingFrameMode->getDuration(pendingPacket->getDataLength());
    simtime_t ctsFrameDuration = rateSelection->computeResponseCtsFrameMode(rtsPacket, rtsFrame)->getDuration(LENGTH_CTS);
    simtime_t durationId = ctsFrameDuration + modeSet->getSifsTime() + pendingFrameDuration + modeSet->getSifsTime();
    if (auto dataOrMgmtHeader = dynamicPtrCast<const Ieee80211DataOrMgmtHeader>(pendingHeader)) {
        if (ackPolicy->isAckNeeded(dataOrMgmtHeader)) {
            RateSelection::setFrameMode(pendingPacket, dataOrMgmtHeader, pendingFrameMode); // KLUDGE
            simtime_t ackFrameDuration = rateSelection->computeResponseAckFrameMode(pendingPacket, dataOrMgmtHeader)->getDuration(LENGTH_ACK);
            durationId += ackFrameDuration + modeSet->getSifsTime();
        }
    }
    return durationId;
}

Referenced by computeDurationField().

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::ieee80211::ModeSetListener.

{
    ModeSetListener::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        rateSelection = check_and_cast<IQosRateSelection *>(getModuleByPath(par("rateSelectionModule")));
    }
}

numInitStages()

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

inlineoverrideprotectedvirtual

Reimplemented from inet::ieee80211::ModeSetListener.

{ return NUM_INIT_STAGES; }

Member Data Documentation

rateSelection

IQosRateSelection* inet::ieee80211::SingleProtectionMechanism::rateSelection = nullptr

protected

Referenced by computeBlockAckReqDurationField(), computeDataOrMgmtFrameDurationField(), computeRtsDurationField(), and initialize().

---

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

• SingleProtectionMechanism.h
• SingleProtectionMechanism.cc