inet::IdealMac Class Reference

Implements a simplified ideal MAC. More...

#include <IdealMac.h>

Inheritance diagram for inet::IdealMac:

Public Member Functions
	IdealMac ()
virtual	~IdealMac ()
Public Member Functions inherited from inet::OperationalBase
	OperationalBase ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Member Functions
virtual void	startTransmitting (cPacket *msg)
virtual bool	dropFrameNotForUs (IdealMacFrame *frame)
virtual IdealMacFrame *	encapsulate (cPacket *msg)
virtual cPacket *	decapsulate (IdealMacFrame *frame)
virtual void	initializeMACAddress ()
virtual void	acked (IdealMacFrame *frame)
virtual void	getNextMsgFromHL ()
virtual void	receiveSignal (cComponent *src, simsignal_t id, long value, cObject *details) override
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	flushQueue ()
	implements MacBase functions More...
virtual void	clearQueue ()
virtual InterfaceEntry *	createInterfaceEntry () override
virtual void	handleUpperPacket (cPacket *msg) override
	implements MACProtocolBase functions More...
virtual void	handleLowerPacket (cPacket *msg) override
virtual void	handleSelfMessage (cMessage *message) override
Protected Member Functions inherited from inet::MACProtocolBase
	MACProtocolBase ()
virtual void	registerInterface ()
virtual void	sendUp (cMessage *message)
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	handleUpperCommand (cMessage *message)
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 bool	handleNodeStart (IDoneCallback *doneCallback)
virtual bool	handleNodeShutdown (IDoneCallback *doneCallback)
virtual void	handleNodeCrash ()
virtual void	setOperational (bool isOperational)

Protected Attributes
int	headerLength = 0
double	bitrate = 0
bool	promiscuous = false
MACAddress	address
bool	fullDuplex = false
bool	useAck = true
IRadio *	radio = nullptr
IRadio::TransmissionState	transmissionState = IRadio::TRANSMISSION_STATE_UNDEFINED
IPassiveQueue *	queueModule = nullptr
int	outStandingRequests = 0
cPacket *	lastSentPk = nullptr
simtime_t	ackTimeout
cMessage *	ackTimeoutMsg = nullptr
Protected Attributes inherited from inet::OperationalBase
bool	isOperational
simtime_t	lastChange

Static Protected Attributes
static simsignal_t	dropPkNotForUsSignal = registerSignal("dropPkNotForUs")

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 a simplified ideal MAC.

See the NED file for details.

Constructor & Destructor Documentation

inet::IdealMac::IdealMac

(

)

{
}

inet::IdealMac::~IdealMac ( )

virtual

{
    delete lastSentPk;
    cancelAndDelete(ackTimeoutMsg);
}

Member Function Documentation

void inet::IdealMac::acked ( IdealMacFrame *  frame )

protectedvirtual

Referenced by handleLowerPacket().

{
    Enter_Method_Silent();
    ASSERT(useAck);

    EV_DEBUG << "IdealMac::acked(" << frame->getFullName() << ") is ";

    if (lastSentPk && lastSentPk->getTreeId() == frame->getTreeId()) {
        EV_DEBUG << "accepted\n";
        cancelEvent(ackTimeoutMsg);
        delete lastSentPk;
        lastSentPk = nullptr;
        getNextMsgFromHL();
    }
    else
        EV_DEBUG << "unaccepted\n";
}

void inet::IdealMac::clearQueue ( )

protectedvirtual

{
    ASSERT(queueModule);
    queueModule->clear();
}

InterfaceEntry * inet::IdealMac::createInterfaceEntry ( )

overrideprotectedvirtual

Implements inet::MACProtocolBase.

{
    InterfaceEntry *e = new InterfaceEntry(this);

    // data rate
    e->setDatarate(bitrate);

    // generate a link-layer address to be used as interface token for IPv6
    e->setMACAddress(address);
    e->setInterfaceToken(address.formInterfaceIdentifier());

    // MTU: typical values are 576 (Internet de facto), 1500 (Ethernet-friendly),
    // 4000 (on some point-to-point links), 4470 (Cisco routers default, FDDI compatible)
    e->setMtu(par("mtu").longValue());

    // capabilities
    e->setMulticast(true);
    e->setBroadcast(true);

    return e;
}

cPacket * inet::IdealMac::decapsulate ( IdealMacFrame *  frame )

protectedvirtual

Referenced by handleLowerPacket().

{
    // decapsulate and attach control info
    cPacket *packet = frame->decapsulate();
    Ieee802Ctrl *etherctrl = new Ieee802Ctrl();
    etherctrl->setSrc(frame->getSrc());
    etherctrl->setDest(frame->getDest());
    packet->setControlInfo(etherctrl);

    delete frame;
    return packet;
}

bool inet::IdealMac::dropFrameNotForUs ( IdealMacFrame *  frame )

protectedvirtual

Referenced by handleLowerPacket().

{
    // Current implementation does not support the configuration of multicast
    // MAC address groups. We rather accept all multicast frames (just like they were
    // broadcasts) and pass it up to the higher layer where they will be dropped
    // if not needed.
    // All frames must be passed to the upper layer if the interface is
    // in promiscuous mode.

    if (frame->getDest().equals(address))
        return false;

    if (frame->getDest().isBroadcast())
        return false;

    if (promiscuous || frame->getDest().isMulticast())
        return false;

    EV << "Frame `" << frame->getName() << "' not destined to us, discarding\n";
    emit(dropPkNotForUsSignal, frame);
    delete frame;
    return true;
}

IdealMacFrame * inet::IdealMac::encapsulate ( cPacket *  msg )

protectedvirtual

Referenced by startTransmitting().

{
    Ieee802Ctrl *ctrl = check_and_cast<Ieee802Ctrl *>(msg->removeControlInfo());
    IdealMacFrame *frame = new IdealMacFrame(msg->getName());
    frame->setByteLength(headerLength);
    frame->setSrc(ctrl->getSrc());
    frame->setDest(ctrl->getDest());
    frame->encapsulate(msg);
    frame->setSrcModuleId(getId());
    delete ctrl;
    return frame;
}

void inet::IdealMac::flushQueue ( )

protectedvirtual

implements MacBase functions

{
    ASSERT(queueModule);
    while (!queueModule->isEmpty()) {
        cMessage *msg = queueModule->pop();
        //TODO emit(dropPkIfaceDownSignal, msg); -- 'pkDropped' signals are missing in this module!
        delete msg;
    }
    queueModule->clear();    // clear request count
}

void inet::IdealMac::getNextMsgFromHL ( )

protectedvirtual

Referenced by acked(), handleSelfMessage(), initialize(), and receiveSignal().

{
    ASSERT(outStandingRequests >= queueModule->getNumPendingRequests());
    if (outStandingRequests == 0) {
        queueModule->requestPacket();
        outStandingRequests++;
    }
    ASSERT(outStandingRequests <= 1);
}

void inet::IdealMac::handleLowerPacket ( cPacket *  msg )

overrideprotectedvirtual

Implements inet::LayeredProtocolBase.

{
    IdealMacFrame *frame = check_and_cast<IdealMacFrame *>(msg);
    if (frame->hasBitError()) {
        EV << "Received " << frame << " contains bit errors or collision, dropping it\n";
        // TODO: add reason? emit(LayeredProtocolBase::packetFromLowerDroppedSignal, frame);
        delete frame;
        return;
    }

    if (!dropFrameNotForUs(frame)) {
        int senderModuleId = frame->getSrcModuleId();
        IdealMac *senderMac = dynamic_cast<IdealMac *>(getSimulation()->getModule(senderModuleId));
        // TODO: this whole out of bounds ack mechanism is fishy
        if (senderMac && senderMac->useAck)
            senderMac->acked(frame);
        // decapsulate and attach control info
        cPacket *higherlayerMsg = decapsulate(frame);
        EV << "Passing up contained packet `" << higherlayerMsg->getName() << "' to higher layer\n";
        sendUp(higherlayerMsg);
    }
}

void inet::IdealMac::handleSelfMessage ( cMessage *  message )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

{
    if (message == ackTimeoutMsg) {
        EV_DETAIL << "IdealMac: timeout: " << lastSentPk->getFullName() << " is lost\n";
        // packet lost
        emit(NF_LINK_BREAK, lastSentPk);
        delete lastSentPk;
        lastSentPk = nullptr;
        getNextMsgFromHL();
    }
    else {
        MACProtocolBase::handleSelfMessage(message);
    }
}

void inet::IdealMac::handleUpperPacket ( cPacket *  msg )

overrideprotectedvirtual

implements MACProtocolBase functions

Implements inet::LayeredProtocolBase.

{
    outStandingRequests--;
    if (radio->getTransmissionState() == IRadio::TRANSMISSION_STATE_TRANSMITTING) {
        // Logic error: we do not request packet from the external queue when radio is transmitting
        throw cRuntimeError("Received msg for transmission but transmitter is busy");
    }
    else {
        // We are idle, so we can start transmitting right away.
        EV << "Received " << msg << " for transmission\n";
        startTransmitting(msg);
    }
}

void inet::IdealMac::initialize ( int  stage )

overrideprotectedvirtual

Reimplemented from inet::MACProtocolBase.

{
    MACProtocolBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        outStandingRequests = 0;

        bitrate = par("bitrate").doubleValue();
        headerLength = par("headerLength").longValue();
        promiscuous = par("promiscuous");
        fullDuplex = par("fullDuplex");
        useAck = par("useAck");
        ackTimeout = par("ackTimeout");

        cModule *radioModule = gate("lowerLayerOut")->getPathEndGate()->getOwnerModule();
        radioModule->subscribe(IRadio::transmissionStateChangedSignal, this);
        radio = check_and_cast<IRadio *>(radioModule);
        transmissionState = IRadio::TRANSMISSION_STATE_UNDEFINED;

        // find queueModule
        cGate *queueOut = gate("upperLayerIn")->getPathStartGate();
        queueModule = dynamic_cast<IPassiveQueue *>(queueOut->getOwnerModule());
        if (!queueModule)
            throw cRuntimeError("Missing queueModule");

        initializeMACAddress();
    }
    else if (stage == INITSTAGE_LINK_LAYER) {
        radio->setRadioMode(fullDuplex ? IRadio::RADIO_MODE_TRANSCEIVER : IRadio::RADIO_MODE_RECEIVER);
        if (useAck)
            ackTimeoutMsg = new cMessage("link-break");
        getNextMsgFromHL();
        registerInterface();
    }
}

void inet::IdealMac::initializeMACAddress ( )

protectedvirtual

Referenced by initialize().

{
    const char *addrstr = par("address");

    if (!strcmp(addrstr, "auto")) {
        // assign automatic address
        address = MACAddress::generateAutoAddress();

        // change module parameter from "auto" to concrete address
        par("address").setStringValue(address.str().c_str());
    }
    else {
        address.setAddress(addrstr);
    }
}

virtual int inet::IdealMac::numInitStages ( ) const

inlineoverrideprotectedvirtual

Reimplemented from inet::OperationalBase.

{ return NUM_INIT_STAGES; }

void inet::IdealMac::receiveSignal ( cComponent *  src, simsignal_t  id, long  value, cObject *  details  )

overrideprotectedvirtual

{
    Enter_Method_Silent();
    if (signalID == IRadio::transmissionStateChangedSignal) {
        IRadio::TransmissionState newRadioTransmissionState = (IRadio::TransmissionState)value;
        if (transmissionState == IRadio::TRANSMISSION_STATE_TRANSMITTING && newRadioTransmissionState == IRadio::TRANSMISSION_STATE_IDLE) {
            radio->setRadioMode(fullDuplex ? IRadio::RADIO_MODE_TRANSCEIVER : IRadio::RADIO_MODE_RECEIVER);
            if (!lastSentPk)
                getNextMsgFromHL();
        }
        transmissionState = newRadioTransmissionState;
    }
}

void inet::IdealMac::startTransmitting ( cPacket *  msg )

protectedvirtual

Referenced by handleUpperPacket().

{
    // if there's any control info, remove it; then encapsulate the packet
    if (lastSentPk)
        throw cRuntimeError("Model error: unacked send");
    Ieee802Ctrl *ctrl = check_and_cast<Ieee802Ctrl *>(msg->getControlInfo());
    MACAddress dest = ctrl->getDestinationAddress();
    IdealMacFrame *frame = encapsulate(msg);

    if (!dest.isBroadcast() && !dest.isMulticast() && !dest.isUnspecified()) {    // unicast
        if (useAck) {
            lastSentPk = frame->dup();
            scheduleAt(simTime() + ackTimeout, ackTimeoutMsg);
        }
    }
    else
        frame->setSrcModuleId(-1);

    // send
    EV << "Starting transmission of " << frame << endl;
    radio->setRadioMode(fullDuplex ? IRadio::RADIO_MODE_TRANSCEIVER : IRadio::RADIO_MODE_TRANSMITTER);
    sendDown(frame);
}

Member Data Documentation

simtime_t inet::IdealMac::ackTimeout

protected

Referenced by initialize(), and startTransmitting().

cMessage* inet::IdealMac::ackTimeoutMsg = nullptr

protected

Referenced by acked(), handleSelfMessage(), initialize(), startTransmitting(), and ~IdealMac().

MACAddress inet::IdealMac::address

protected

Referenced by createInterfaceEntry(), dropFrameNotForUs(), and initializeMACAddress().

double inet::IdealMac::bitrate = 0

protected

Referenced by createInterfaceEntry(), and initialize().

simsignal_t inet::IdealMac::dropPkNotForUsSignal = registerSignal("dropPkNotForUs")

staticprotected

Referenced by dropFrameNotForUs().

bool inet::IdealMac::fullDuplex = false

protected

Referenced by initialize(), receiveSignal(), and startTransmitting().

int inet::IdealMac::headerLength = 0

protected

Referenced by encapsulate(), and initialize().

cPacket* inet::IdealMac::lastSentPk = nullptr

protected

Referenced by acked(), handleSelfMessage(), receiveSignal(), startTransmitting(), and ~IdealMac().

int inet::IdealMac::outStandingRequests = 0

protected

Referenced by getNextMsgFromHL(), handleUpperPacket(), and initialize().

bool inet::IdealMac::promiscuous = false

protected

Referenced by dropFrameNotForUs(), and initialize().

IPassiveQueue* inet::IdealMac::queueModule = nullptr

protected

Referenced by clearQueue(), flushQueue(), getNextMsgFromHL(), and initialize().

IRadio* inet::IdealMac::radio = nullptr

protected

Referenced by handleUpperPacket(), initialize(), receiveSignal(), and startTransmitting().

IRadio::TransmissionState inet::IdealMac::transmissionState = IRadio::TRANSMISSION_STATE_UNDEFINED

protected

Referenced by initialize(), and receiveSignal().

bool inet::IdealMac::useAck = true

protected

Referenced by acked(), handleLowerPacket(), initialize(), and startTransmitting().

---

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

• IdealMac.h
• IdealMac.cc