inet::ieee80211::Ieee80211Mac Class Reference

Implements the IEEE 802.11 MAC. More...

#include <Ieee80211Mac.h>

Inheritance diagram for inet::ieee80211::Ieee80211Mac:

Public Member Functions
	Ieee80211Mac ()
virtual	~Ieee80211Mac ()
virtual const MACAddress &	getAddress () const
virtual void	sendUp (cMessage *message) override
virtual void	sendFrame (Ieee80211Frame *frameToSend)
virtual void	sendDownPendingRadioConfigMsg ()
Public Member Functions inherited from inet::OperationalBase
	OperationalBase ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int) override
void	receiveSignal (cComponent *source, simsignal_t signalID, long value, cObject *details) override
void	configureRadioMode (IRadio::RadioMode radioMode)
virtual InterfaceEntry *	createInterfaceEntry () override
virtual const MACAddress &	isInterfaceRegistered ()
virtual void	handleUpperCommand (cMessage *msg) override
	Handle commands (msg kind+control info) coming from upper layers. More...
virtual void	handleSelfMessage (cMessage *msg) override
	Handle timer self messages. More...
virtual void	handleUpperPacket (cPacket *msg) override
	Handle messages from upper layer. More...
virtual void	handleLowerPacket (cPacket *msg) override
	Handle messages from lower (physical) layer. More...
virtual bool	handleNodeStart (IDoneCallback *doneCallback) override
virtual bool	handleNodeShutdown (IDoneCallback *doneCallback) override
virtual void	handleNodeCrash () override
virtual void	processUpperFrame (Ieee80211DataOrMgmtFrame *frame)
virtual void	processLowerFrame (Ieee80211Frame *frame)
Protected Member Functions inherited from inet::MACProtocolBase
	MACProtocolBase ()
virtual void	registerInterface ()
virtual void	sendDown (cMessage *message)
virtual bool	isUpperMessage (cMessage *message) override
virtual bool	isLowerMessage (cMessage *message) override
virtual bool	isInitializeStage (int stage) override
virtual bool	isNodeStartStage (int stage) override
virtual bool	isNodeShutdownStage (int stage) override
Protected Member Functions inherited from inet::LayeredProtocolBase
virtual void	handleMessageWhenUp (cMessage *message) override
virtual void	handleLowerCommand (cMessage *message)
Protected Member Functions inherited from inet::OperationalBase
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual void	setOperational (bool isOperational)

Protected Attributes
MACAddress	address
bool	qosSta = false
IRx *	rx = nullptr
ITx *	tx = nullptr
IRadio *	radio = nullptr
const Ieee80211ModeSet *	modeSet = nullptr
IRadio::TransmissionState	transmissionState = IRadio::TransmissionState::TRANSMISSION_STATE_UNDEFINED
Dcf *	dcf = nullptr
Pcf *	pcf = nullptr
Hcf *	hcf = nullptr
Mcf *	mcf = nullptr
cMessage *	pendingRadioConfigMsg = nullptr
Protected Attributes inherited from inet::OperationalBase
bool	isOperational
simtime_t	lastChange

Static Protected Attributes
static simsignal_t	stateSignal = SIMSIGNAL_NULL
static simsignal_t	radioStateSignal = SIMSIGNAL_NULL

Additional Inherited Members
Public Attributes inherited from inet::MACProtocolBase
InterfaceEntry *	interfaceEntry
int	upperLayerInGateId
	Gate ids. More...
int	upperLayerOutGateId
int	lowerLayerInGateId
int	lowerLayerOutGateId
Static Public Attributes inherited from inet::LayeredProtocolBase
static simsignal_t	packetSentToUpperSignal = registerSignal("packetSentToUpper")
static simsignal_t	packetReceivedFromUpperSignal = registerSignal("packetReceivedFromUpper")
static simsignal_t	packetFromUpperDroppedSignal = registerSignal("packetFromUpperDropped")
static simsignal_t	packetSentToLowerSignal = registerSignal("packetSentToLower")
static simsignal_t	packetReceivedFromLowerSignal = registerSignal("packetReceivedFromLower")
static simsignal_t	packetFromLowerDroppedSignal = registerSignal("packetFromLowerDropped")

Detailed Description

Implements the IEEE 802.11 MAC.

The features, standards compliance and exact operation of the MAC depend on the plugged-in components (see IUpperMac, IRx, ITx, IContention and other interface classes).

Constructor & Destructor Documentation

inet::ieee80211::Ieee80211Mac::Ieee80211Mac

(

)

{
}

inet::ieee80211::Ieee80211Mac::~Ieee80211Mac ( )

virtual

{
    if (pendingRadioConfigMsg)
        delete pendingRadioConfigMsg;
}

Member Function Documentation

void inet::ieee80211::Ieee80211Mac::configureRadioMode ( IRadio::RadioMode  radioMode )

protected

Referenced by receiveSignal(), and sendFrame().

{
    if (radio->getRadioMode() != radioMode) {
        ConfigureRadioCommand *configureCommand = new ConfigureRadioCommand();
        configureCommand->setRadioMode(radioMode);
        cMessage *message = new cMessage("configureRadioMode", RADIO_C_CONFIGURE);
        message->setControlInfo(configureCommand);
        sendDown(message);
    }
}

InterfaceEntry * inet::ieee80211::Ieee80211Mac::createInterfaceEntry ( )

overrideprotectedvirtual

Implements inet::MACProtocolBase.

{
    InterfaceEntry *e = new InterfaceEntry(this);
    // address
    e->setMACAddress(address);
    e->setInterfaceToken(address.formInterfaceIdentifier());
    e->setMtu(par("mtu").longValue());
    // capabilities
    e->setBroadcast(true);
    e->setMulticast(true);
    e->setPointToPoint(false);
    return e;
}

virtual const MACAddress& inet::ieee80211::Ieee80211Mac::getAddress ( ) const

inlinevirtual

Referenced by inet::ieee80211::Dcf::buildContext(), inet::ieee80211::Hcf::buildContext(), inet::ieee80211::Tx::initialize(), inet::ieee80211::Dcf::isForUs(), inet::ieee80211::Hcf::isForUs(), inet::ieee80211::Dcf::isSentByUs(), and inet::ieee80211::Hcf::isSentByUs().

{ return address; }

void inet::ieee80211::Ieee80211Mac::handleLowerPacket ( cPacket *  msg )

overrideprotectedvirtual

Handle messages from lower (physical) layer.

Implements inet::LayeredProtocolBase.

{
    auto frame = check_and_cast<Ieee80211Frame *>(msg);
    if (rx->lowerFrameReceived(frame)) {
        processLowerFrame(frame);
    }
    else { // corrupted frame received
        if (qosSta)
            hcf->corruptedFrameReceived();
        else
            dcf->corruptedFrameReceived();
    }
}

void inet::ieee80211::Ieee80211Mac::handleNodeCrash ( )

overrideprotectedvirtual

Reimplemented from inet::OperationalBase.

Referenced by handleNodeShutdown().

{
}

bool inet::ieee80211::Ieee80211Mac::handleNodeShutdown ( IDoneCallback *  doneCallback )

overrideprotectedvirtual

Reimplemented from inet::OperationalBase.

{
    bool ret = MACProtocolBase::handleNodeStart(doneCallback);
    handleNodeCrash();
    return ret;
}

bool inet::ieee80211::Ieee80211Mac::handleNodeStart ( IDoneCallback *  doneCallback )

overrideprotectedvirtual

Reimplemented from inet::OperationalBase.

{
    if (!doneCallback)
        return true;    // do nothing when called from initialize()

    bool ret = MACProtocolBase::handleNodeStart(doneCallback);
    radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
    return ret;
}

void inet::ieee80211::Ieee80211Mac::handleSelfMessage ( cMessage *  msg )

overrideprotectedvirtual

Handle timer self messages.

Reimplemented from inet::LayeredProtocolBase.

{
    ASSERT(false);
}

void inet::ieee80211::Ieee80211Mac::handleUpperCommand ( cMessage *  msg )

overrideprotectedvirtual

Handle commands (msg kind+control info) coming from upper layers.

Reimplemented from inet::LayeredProtocolBase.

{
    if (msg->getKind() == RADIO_C_CONFIGURE) {
        EV_DEBUG << "Passing on command " << msg->getName() << " to physical layer\n";
        if (pendingRadioConfigMsg != nullptr) {
            // merge contents of the old command into the new one, then delete it
            Ieee80211ConfigureRadioCommand *oldConfigureCommand = check_and_cast<Ieee80211ConfigureRadioCommand *>(pendingRadioConfigMsg->getControlInfo());
            Ieee80211ConfigureRadioCommand *newConfigureCommand = check_and_cast<Ieee80211ConfigureRadioCommand *>(msg->getControlInfo());
            if (newConfigureCommand->getChannelNumber() == -1 && oldConfigureCommand->getChannelNumber() != -1)
                newConfigureCommand->setChannelNumber(oldConfigureCommand->getChannelNumber());
            if (std::isnan(newConfigureCommand->getBitrate().get()) && !std::isnan(oldConfigureCommand->getBitrate().get()))
                newConfigureCommand->setBitrate(oldConfigureCommand->getBitrate());
            delete pendingRadioConfigMsg;
            pendingRadioConfigMsg = nullptr;
        }

        if (rx->isMediumFree()) {    // TODO: this should be just the physical channel sense!!!!
            EV_DEBUG << "Sending it down immediately\n";
            // PhyControlInfo *phyControlInfo = dynamic_cast<PhyControlInfo *>(msg->getControlInfo());
            // if (phyControlInfo)
            // phyControlInfo->setAdaptiveSensitivity(true);
            // end dynamic power
            sendDown(msg);
        }
        else {
            // TODO: waiting potentially indefinitely?! wtf?!
            EV_DEBUG << "Delaying " << msg->getName() << " until next IDLE or DEFER state\n";
            pendingRadioConfigMsg = msg;
        }
    }
    else {
        throw cRuntimeError("Unrecognized command from mgmt layer: (%s)%s msgkind=%d", msg->getClassName(), msg->getName(), msg->getKind());
    }
}

void inet::ieee80211::Ieee80211Mac::handleUpperPacket ( cPacket *  msg )

overrideprotectedvirtual

Handle messages from upper layer.

Implements inet::LayeredProtocolBase.

{
    processUpperFrame(check_and_cast<Ieee80211DataOrMgmtFrame *>(msg));
}

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

overrideprotectedvirtual

Reimplemented from inet::MACProtocolBase.

{
    MACProtocolBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        qosSta = par("qosStation");
        cModule *radioModule = gate("lowerLayerOut")->getNextGate()->getOwnerModule();
        radioModule->subscribe(IRadio::radioModeChangedSignal, this);
        radioModule->subscribe(IRadio::receptionStateChangedSignal, this);
        radioModule->subscribe(IRadio::transmissionStateChangedSignal, this);
        radioModule->subscribe(IRadio::receivedSignalPartChangedSignal, this);
        radio = check_and_cast<IRadio *>(radioModule);
        rx = check_and_cast<IRx *>(getSubmodule("rx"));
        tx = check_and_cast<ITx *>(getSubmodule("tx"));
        const char *addressString = par("address");
        if (!strcmp(addressString, "auto")) {
            // change module parameter from "auto" to concrete address
            par("address").setStringValue(MACAddress::generateAutoAddress().str().c_str());
            addressString = par("address");
        }
        address.setAddress(addressString);
        modeSet = Ieee80211ModeSet::getModeSet(par("modeSet").stringValue());
    }
    else if (stage == INITSTAGE_LINK_LAYER) {
        registerInterface();
        emit(NF_MODESET_CHANGED, modeSet);
        if (isOperational)
            radio->setRadioMode(IRadio::RADIO_MODE_RECEIVER);
        if (isInterfaceRegistered().isUnspecified())// TODO: do we need multi-MAC feature? if so, should they share interfaceEntry??  --Andras
            registerInterface();
    }
    else if (stage == INITSTAGE_LINK_LAYER_2) {
        rx = check_and_cast<IRx *>(getSubmodule("rx"));
        tx = check_and_cast<ITx *>(getSubmodule("tx"));
        dcf = check_and_cast<Dcf *>(getSubmodule("dcf"));
        hcf = check_and_cast<Hcf *>(getSubmodule("hcf"));
    }
}

const MACAddress & inet::ieee80211::Ieee80211Mac::isInterfaceRegistered ( )

protectedvirtual

Referenced by initialize().

{
    // if (!par("multiMac").boolValue())
    //    return MACAddress::UNSPECIFIED_ADDRESS;
    IInterfaceTable *ift = findModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
    if (!ift)
        return MACAddress::UNSPECIFIED_ADDRESS;
    cModule *interfaceModule = findModuleUnderContainingNode(this);
    if (!interfaceModule)
        throw cRuntimeError("NIC module not found in the host");
    std::string interfaceName = utils::stripnonalnum(interfaceModule->getFullName());
    InterfaceEntry *e = ift->getInterfaceByName(interfaceName.c_str());
    if (e)
        return e->getMacAddress();
    return MACAddress::UNSPECIFIED_ADDRESS;
}

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

inlineoverrideprotectedvirtual

Reimplemented from inet::OperationalBase.

{return NUM_INIT_STAGES;}

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

protectedvirtual

Referenced by handleLowerPacket().

{
    Enter_Method("processLowerFrame(\"%s\")", frame->getName());
    take(frame);
    if (qosSta)
        hcf->processLowerFrame(frame);
    else
        dcf->processLowerFrame(frame);
}

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

protectedvirtual

Referenced by handleUpperPacket().

{
    Enter_Method("processUpperFrame(\"%s\")", frame->getName());
    take(frame);
    EV_INFO << "Frame " << frame << " received from higher layer, receiver = " << frame->getReceiverAddress() << "\n";
    ASSERT(!frame->getReceiverAddress().isUnspecified());
    if (qosSta)
        hcf->processUpperFrame(frame);
    else
        dcf->processUpperFrame(frame);
}

void inet::ieee80211::Ieee80211Mac::receiveSignal ( cComponent *  source, simsignal_t  signalID, long  value, cObject *  details  )

overrideprotected

{
    Enter_Method_Silent("receiveSignal()");
    if (signalID == IRadio::receptionStateChangedSignal) {
        rx->receptionStateChanged((IRadio::ReceptionState)value);
    }
    else if (signalID == IRadio::transmissionStateChangedSignal) {
        auto oldTransmissionState = transmissionState;
        transmissionState = (IRadio::TransmissionState)value;
        bool transmissionFinished = (oldTransmissionState == IRadio::TRANSMISSION_STATE_TRANSMITTING && transmissionState == IRadio::TRANSMISSION_STATE_IDLE);
        if (transmissionFinished) {
            tx->radioTransmissionFinished();
            EV_DEBUG << "changing radio to receiver mode\n";
            configureRadioMode(IRadio::RADIO_MODE_RECEIVER); // FIXME: this is in a very wrong place!!! should be done explicitly from UpperMac!
        }
        rx->transmissionStateChanged(transmissionState);
    }
    else if (signalID == IRadio::receivedSignalPartChangedSignal) {
        rx->receivedSignalPartChanged((IRadioSignal::SignalPart)value);
    }
}

void inet::ieee80211::Ieee80211Mac::sendDownPendingRadioConfigMsg ( )

virtual

Referenced by inet::ieee80211::Dcf::frameSequenceFinished(), inet::ieee80211::Hcf::frameSequenceFinished(), and inet::ieee80211::Contention::handleWithFSM().

{
    if (pendingRadioConfigMsg != nullptr) {
        sendDown(pendingRadioConfigMsg);
        pendingRadioConfigMsg = nullptr;
    }
}

void inet::ieee80211::Ieee80211Mac::sendFrame ( Ieee80211Frame *  frameToSend )

virtual

Referenced by inet::ieee80211::Tx::handleMessage().

{
    Enter_Method("sendFrame(\"%s\")", frame->getName());
    take(frame);
    configureRadioMode(IRadio::RADIO_MODE_TRANSMITTER);
    sendDown(frame);
}

void inet::ieee80211::Ieee80211Mac::sendUp ( cMessage *  message )

overridevirtual

Reimplemented from inet::MACProtocolBase.

Referenced by inet::ieee80211::Dcf::sendUp(), and inet::ieee80211::Hcf::sendUp().

{
    Enter_Method("sendUp(\"%s\")", msg->getName());
    take(msg);
    MACProtocolBase::sendUp(msg);
}

Member Data Documentation

MACAddress inet::ieee80211::Ieee80211Mac::address

protected

Referenced by createInterfaceEntry(), and initialize().

Dcf* inet::ieee80211::Ieee80211Mac::dcf = nullptr

protected

Referenced by handleLowerPacket(), initialize(), processLowerFrame(), and processUpperFrame().

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

protected

Referenced by handleLowerPacket(), initialize(), processLowerFrame(), and processUpperFrame().

Mcf* inet::ieee80211::Ieee80211Mac::mcf = nullptr

protected

const Ieee80211ModeSet* inet::ieee80211::Ieee80211Mac::modeSet = nullptr

protected

Referenced by initialize().

Pcf* inet::ieee80211::Ieee80211Mac::pcf = nullptr

protected

cMessage* inet::ieee80211::Ieee80211Mac::pendingRadioConfigMsg = nullptr

protected

Referenced by handleUpperCommand(), sendDownPendingRadioConfigMsg(), and ~Ieee80211Mac().

bool inet::ieee80211::Ieee80211Mac::qosSta = false

protected

Referenced by handleLowerPacket(), initialize(), processLowerFrame(), and processUpperFrame().

IRadio* inet::ieee80211::Ieee80211Mac::radio = nullptr

protected

Referenced by configureRadioMode(), handleNodeStart(), and initialize().

simsignal_t inet::ieee80211::Ieee80211Mac::radioStateSignal = SIMSIGNAL_NULL

staticprotected

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

protected

Referenced by handleLowerPacket(), handleUpperCommand(), initialize(), and receiveSignal().

simsignal_t inet::ieee80211::Ieee80211Mac::stateSignal = SIMSIGNAL_NULL

staticprotected

IRadio::TransmissionState inet::ieee80211::Ieee80211Mac::transmissionState = IRadio::TransmissionState::TRANSMISSION_STATE_UNDEFINED

protected

Referenced by receiveSignal().

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

protected

Referenced by initialize(), and receiveSignal().

---

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

• Ieee80211Mac.h
• Ieee80211Mac.cc