Base class for Ethernet MAC implementations. More...

#include <EtherMACBase.h>

Inheritance diagram for inet::EtherMACBase:

Classes
struct	EtherDescr

class	InnerQueue

class	MacQueue

Public Types
enum	MACTransmitState { TX_IDLE_STATE = 1, WAIT_IFG_STATE, SEND_IFG_STATE, TRANSMITTING_STATE, JAMMING_STATE, BACKOFF_STATE, PAUSE_STATE }

enum	MACReceiveState { RX_IDLE_STATE = 1, RECEIVING_STATE, RX_COLLISION_STATE, RX_RECONNECT_STATE }

Public Member Functions
	EtherMACBase ()

virtual	~EtherMACBase ()

virtual MACAddress	getMACAddress ()

double	getTxRate ()

bool	isActive ()

MACTransmitState	getTransmitState ()

MACReceiveState	getReceiveState ()

virtual bool	handleOperationStage (LifecycleOperation operation, int stage, IDoneCallback doneCallback) override
	Perform one stage of a lifecycle operation. More...

Public Member Functions inherited from inet::MACBase
	MACBase ()

virtual	~MACBase ()

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

Static Public Attributes
static const double	SPEED_OF_LIGHT_IN_CABLE = 200000000.0

static simsignal_t	dropPkIfaceDownSignal = registerSignal("dropPkIfaceDown")

static simsignal_t	dropPkFromHLIfaceDownSignal = registerSignal("dropPkFromHLIfaceDown")

Protected Types
enum	SelfMsgKindValues { ENDIFG = 100, ENDRECEPTION, ENDBACKOFF, ENDTRANSMISSION, ENDJAMMING, ENDPAUSE }

enum	{ NUM_OF_ETHERDESCRS = 6 }

Protected Member Functions
virtual void	initialize (int stage) override

virtual int	numInitStages () const override

virtual void	initializeFlags ()

virtual void	initializeMACAddress ()

virtual void	initializeQueueModule ()

virtual void	initializeStatistics ()

virtual void	finish () override

virtual bool	dropFrameNotForUs (EtherFrame *frame)
	Checks destination address and drops the frame when frame is not for us; returns true if frame is dropped. More...

virtual void	readChannelParameters (bool errorWhenAsymmetric)
	Calculates datarates, etc. More...

virtual void	printParameters ()

virtual void	getNextFrameFromQueue ()

virtual void	requestNextFrameFromExtQueue ()

virtual void	processConnectDisconnect ()

virtual EtherPhyFrame *	encapsulate (EtherFrame *phyFrame)

virtual EtherFrame *	decapsulate (EtherPhyFrame *phyFrame)

virtual InterfaceEntry *	createInterfaceEntry () override
	should create InterfaceEntry More...

virtual void	flushQueue () override
	should clear queue and emit signal "dropPkFromHLIfaceDown" with entire packets More...

virtual void	clearQueue () override
	should clear queue silently More...

virtual bool	isUpperMsg (cMessage *msg) override
	should return true if the msg arrived from upper layer, else return false More...

virtual void	refreshDisplay () const override

virtual void	receiveSignal (cComponent src, simsignal_t signalId, cObject obj, cObject *details) override

virtual void	refreshConnection ()

Protected Member Functions inherited from inet::MACBase
void	registerInterface ()

virtual void	updateOperationalFlag (bool isNodeUp)

virtual bool	isNodeUp ()

virtual void	handleMessageWhenDown (cMessage *msg)

Protected Attributes
const EtherDescr *	curEtherDescr = nullptr

MACAddress	address

bool	connected = false

bool	disabled = false

bool	promiscuous = false

bool	duplexMode = false

bool	frameBursting = false

MacQueue	txQueue

cChannel *	transmissionChannel = nullptr

cGate *	physInGate = nullptr

cGate *	physOutGate = nullptr

cGate *	upperLayerInGate = nullptr

bool	channelsDiffer = false

MACTransmitState	transmitState = (MACTransmitState)-1

MACReceiveState	receiveState = (MACReceiveState)-1

simtime_t	lastTxFinishTime

int	pauseUnitsRequested = 0

EtherFrame *	curTxFrame = nullptr

cMessage *	endTxMsg = nullptr

cMessage *	endIFGMsg = nullptr

cMessage *	endPauseMsg = nullptr

unsigned long	numFramesSent = 0

unsigned long	numFramesReceivedOK = 0

unsigned long	numBytesSent = 0

unsigned long	numBytesReceivedOK = 0

unsigned long	numFramesFromHL = 0

unsigned long	numDroppedPkFromHLIfaceDown = 0

unsigned long	numDroppedIfaceDown = 0

unsigned long	numDroppedBitError = 0

unsigned long	numDroppedNotForUs = 0

unsigned long	numFramesPassedToHL = 0

unsigned long	numPauseFramesRcvd = 0

unsigned long	numPauseFramesSent = 0

Protected Attributes inherited from inet::MACBase
cModule *	hostModule = nullptr

bool	isOperational = false

InterfaceEntry *	interfaceEntry = nullptr

Static Protected Attributes
static const EtherDescr	etherDescrs [NUM_OF_ETHERDESCRS]

static const EtherDescr	nullEtherDescr

static simsignal_t	txPkSignal = registerSignal("txPk")

static simsignal_t	rxPkOkSignal = registerSignal("rxPkOk")

static simsignal_t	txPausePkUnitsSignal = registerSignal("txPausePkUnits")

static simsignal_t	rxPausePkUnitsSignal = registerSignal("rxPausePkUnits")

static simsignal_t	rxPkFromHLSignal = registerSignal("rxPkFromHL")

static simsignal_t	dropPkNotForUsSignal = registerSignal("dropPkNotForUs")

static simsignal_t	dropPkBitErrorSignal = registerSignal("dropPkBitError")

static simsignal_t	packetSentToLowerSignal = registerSignal("packetSentToLower")

static simsignal_t	packetReceivedFromLowerSignal = registerSignal("packetReceivedFromLower")

static simsignal_t	packetSentToUpperSignal = registerSignal("packetSentToUpper")

static simsignal_t	packetReceivedFromUpperSignal = registerSignal("packetReceivedFromUpper")

static simsignal_t	transmitStateSignal = registerSignal("transmitState")

static simsignal_t	receiveStateSignal = registerSignal("receiveState")

Detailed Description

Base class for Ethernet MAC implementations.

Member Enumeration Documentation

anonymous enum

protected

Enumerator
NUM_OF_ETHERDESCRS

          {
         NUM_OF_ETHERDESCRS = 6
     };

enum inet::EtherMACBase::MACReceiveState

Enumerator
RX_IDLE_STATE
RECEIVING_STATE
RX_COLLISION_STATE
RX_RECONNECT_STATE

                              {
             RX_IDLE_STATE = 1,
             RECEIVING_STATE,
             RX_COLLISION_STATE,
             RX_RECONNECT_STATE
         };

enum inet::EtherMACBase::MACTransmitState

Enumerator
TX_IDLE_STATE
WAIT_IFG_STATE
SEND_IFG_STATE
TRANSMITTING_STATE
JAMMING_STATE
BACKOFF_STATE
PAUSE_STATE

                               {
             TX_IDLE_STATE = 1,
             WAIT_IFG_STATE,
             SEND_IFG_STATE,
             TRANSMITTING_STATE,
             JAMMING_STATE,
             BACKOFF_STATE,
             PAUSE_STATE
         };

enum inet::EtherMACBase::SelfMsgKindValues

protected

Enumerator
ENDIFG
ENDRECEPTION
ENDBACKOFF
ENDTRANSMISSION
ENDJAMMING
ENDPAUSE

                            {
         ENDIFG = 100,
         ENDRECEPTION,
         ENDBACKOFF,
         ENDTRANSMISSION,
         ENDJAMMING,
         ENDPAUSE
     };

Constructor & Destructor Documentation

inet::EtherMACBase::EtherMACBase ( )

 {
     lastTxFinishTime = -1.0;    // never equals to current simtime
     curEtherDescr = &nullEtherDescr;
 }

inet::EtherMACBase::~EtherMACBase ( )

virtual

 {
     delete curTxFrame;
 
     cancelAndDelete(endTxMsg);
     cancelAndDelete(endIFGMsg);
     cancelAndDelete(endPauseMsg);
 }

Member Function Documentation

void inet::EtherMACBase::clearQueue ( )

overrideprotectedvirtual

should clear queue silently

Implements inet::MACBase.

 {
     if (txQueue.innerQueue)
         txQueue.innerQueue->clear();
     else
         txQueue.extQueue->clear(); // clear request count
 }

InterfaceEntry * inet::EtherMACBase::createInterfaceEntry ( )

overrideprotectedvirtual

should create InterfaceEntry

Implements inet::MACBase.

 {
     InterfaceEntry *interfaceEntry = new InterfaceEntry(this);
 
     // generate a link-layer address to be used as interface token for IPv6
     interfaceEntry->setMACAddress(address);
     interfaceEntry->setInterfaceToken(address.formInterfaceIdentifier());
     //InterfaceToken token(0, getSimulation()->getUniqueNumber(), 64);
     //interfaceEntry->setInterfaceToken(token);
 
     // MTU: typical values are 576 (Internet de facto), 1500 (Ethernet-friendly),
     // 4000 (on some point-to-point links), 4470 (Cisco routers default, FDDI compatible)
     interfaceEntry->setMtu(par("mtu").longValue());
 
     // capabilities
     interfaceEntry->setMulticast(true);
     interfaceEntry->setBroadcast(true);
 
     return interfaceEntry;
 }

EtherFrame * inet::EtherMACBase::decapsulate ( EtherPhyFrame * phyFrame )

protectedvirtual

Referenced by inet::EtherMAC::frameReceptionComplete(), inet::EtherMACFullDuplex::processMsgFromNetwork(), and inet::EtherMAC::processMsgFromNetwork().

 {
     if (phyFrame->getSrcMacFullDuplex() != duplexMode)
         throw cRuntimeError("Ethernet misconfiguration: MACs on the same link must be all in full duplex mode, or all in half-duplex mode");
 
     cPacket *frame = phyFrame->decapsulate();
     delete phyFrame;
 
     if (RawPacket *rawPacket = dynamic_cast<RawPacket *>(frame)) {
         using namespace serializer;
         Buffer b(rawPacket->getByteArray().getDataPtr(), rawPacket->getByteArray().getDataArraySize());
         Context c;
         frame = SerializerBase::lookupAndDeserialize(b, c, LINKTYPE, LINKTYPE_ETHERNET);
         if (!frame)
             throw cRuntimeError("Could not deserialize RawPacket '%s' as Ethernet frame", rawPacket->getName());
         delete rawPacket;
     }
     return check_and_cast<EtherFrame *>(frame);
 }

bool inet::EtherMACBase::dropFrameNotForUs ( EtherFrame * frame )

protectedvirtual

Checks destination address and drops the frame when frame is not for us; returns true if frame is dropped.

Referenced by inet::EtherMAC::frameReceptionComplete(), and inet::EtherMACFullDuplex::processMsgFromNetwork().

 {
     // Current ethernet mac implementation does not support the configuration of multicast
     // ethernet 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.
     //
     // PAUSE frames must be handled a bit differently because they are processed at
     // this level. Multicast PAUSE frames should not be processed unless they have a
     // destination of MULTICAST_PAUSE_ADDRESS. We drop all PAUSE frames that have a
     // different muticast destination. (Note: Would the multicast ethernet addressing
     // implemented, we could also process the PAUSE frames destined to any of our
     // multicast adresses)
     // All NON-PAUSE 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;
 
     bool isPause = (dynamic_cast<EtherPauseFrame *>(frame) != nullptr);
 
     if (!isPause && (promiscuous || frame->getDest().isMulticast()))
         return false;
 
     if (isPause && frame->getDest().equals(MACAddress::MULTICAST_PAUSE_ADDRESS))
         return false;
 
     EV_WARN << "Frame `" << frame->getName() << "' not destined to us, discarding\n";
     numDroppedNotForUs++;
     emit(dropPkNotForUsSignal, frame);
     delete frame;
     return true;
 }

EtherPhyFrame * inet::EtherMACBase::encapsulate ( EtherFrame * phyFrame )

protectedvirtual

Referenced by inet::EtherMACFullDuplex::startFrameTransmission(), and inet::EtherMAC::startFrameTransmission().

 {
     EtherPhyFrame *phyFrame = new EtherPhyFrame(frame->getName());
     phyFrame->encapsulate(frame);
     phyFrame->setSrcMacFullDuplex(duplexMode);
     return phyFrame;
 }

void inet::EtherMACBase::finish ( )

overrideprotectedvirtual

Reimplemented in inet::EtherMAC, and inet::EtherMACFullDuplex.

Referenced by inet::EtherMACFullDuplex::finish(), and inet::EtherMAC::finish().

 {
     if (!disabled) {
         simtime_t t = simTime();
         recordScalar("simulated time", t);
         recordScalar("full-duplex", duplexMode);
 
         if (t > 0) {
             recordScalar("frames/sec sent", numFramesSent / t);
             recordScalar("frames/sec rcvd", numFramesReceivedOK / t);
             recordScalar("bits/sec sent", (8.0 * numBytesSent) / t);
             recordScalar("bits/sec rcvd", (8.0 * numBytesReceivedOK) / t);
         }
     }
 }

void inet::EtherMACBase::flushQueue ( )

overrideprotectedvirtual

should clear queue and emit signal "dropPkFromHLIfaceDown" with entire packets

Implements inet::MACBase.

 {
     // code would look slightly nicer with a pop() function that returns nullptr if empty
     if (txQueue.innerQueue) {
         while (!txQueue.innerQueue->isEmpty()) {
             cMessage *msg = (cMessage *)txQueue.innerQueue->pop();
             emit(dropPkFromHLIfaceDownSignal, msg);
             delete msg;
         }
     }
     else {
         while (!txQueue.extQueue->isEmpty()) {
             cMessage *msg = txQueue.extQueue->pop();
             emit(dropPkFromHLIfaceDownSignal, msg);
             delete msg;
         }
         txQueue.extQueue->clear();    // clear request count
     }
 }

virtual MACAddress inet::EtherMACBase::getMACAddress ( )

inlinevirtual

198 { return address; }

inet::EtherMACBase::address

MACAddress address

Definition: EtherMACBase.h:133

void inet::EtherMACBase::getNextFrameFromQueue ( )

protectedvirtual

Referenced by inet::EtherMACFullDuplex::handleEndIFGPeriod(), inet::EtherMACFullDuplex::handleEndPausePeriod(), inet::EtherMAC::handleEndTxPeriod(), and inet::EtherMAC::handleRetransmission().

 {
     ASSERT(nullptr == curTxFrame);
     if (txQueue.extQueue) {
         if (txQueue.extQueue->getNumPendingRequests() == 0)
             txQueue.extQueue->requestPacket();
     }
     else {
         if (!txQueue.innerQueue->isEmpty())
             curTxFrame = (EtherFrame *)txQueue.innerQueue->pop();
     }
 }

MACReceiveState inet::EtherMACBase::getReceiveState ( )

inline

204 { return receiveState; }

inet::EtherMACBase::receiveState

MACReceiveState receiveState

Definition: EtherMACBase.h:150

MACTransmitState inet::EtherMACBase::getTransmitState ( )

inline

203 { return transmitState; }

inet::EtherMACBase::transmitState

MACTransmitState transmitState

Definition: EtherMACBase.h:149

double inet::EtherMACBase::getTxRate ( )

inline

200 { return curEtherDescr->txrate; }

inet::EtherMACBase::curEtherDescr

const EtherDescr * curEtherDescr

Definition: EtherMACBase.h:132

inet::EtherMACBase::EtherDescr::txrate

double txrate

Definition: EtherMACBase.h:80

bool inet::EtherMACBase::handleOperationStage	(	LifecycleOperation *	operation,
		int	stage,
		IDoneCallback *	doneCallback
	)

overridevirtual

Perform one stage of a lifecycle operation.

Processing may be done entirely within this method, or may be a longer process that involves nonzero simulation time or several events, and is triggered by this method call.

Return value: true = "done"; false = "not yet done, will invoke doneCallback when done"

Reimplemented from inet::MACBase.

 {
     Enter_Method_Silent();
     if (dynamic_cast<NodeStartOperation *>(operation)) {
         if ((NodeStartOperation::Stage)stage == NodeStartOperation::STAGE_LINK_LAYER) {
             initializeFlags();
             initializeMACAddress();
             initializeQueueModule();
         }
     }
     else if (dynamic_cast<NodeShutdownOperation *>(operation)) {
         if ((NodeShutdownOperation::Stage)stage == NodeShutdownOperation::STAGE_LINK_LAYER) {
             connected = false;
             processConnectDisconnect();
         }
     }
     else if (dynamic_cast<NodeCrashOperation *>(operation)) {
         if ((NodeCrashOperation::Stage)stage == NodeCrashOperation::STAGE_CRASH) {
             connected = false;
             processConnectDisconnect();
         }
     }
     return MACBase::handleOperationStage(operation, stage, doneCallback);
 }

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

overrideprotectedvirtual

Reimplemented from inet::MACBase.

Reimplemented in inet::EtherMAC, and inet::EtherMACFullDuplex.

Referenced by inet::EtherMACFullDuplex::initialize(), and inet::EtherMAC::initialize().

 {
     MACBase::initialize(stage);
 
     if (stage == INITSTAGE_LOCAL) {
         physInGate = gate("phys$i");
         physOutGate = gate("phys$o");
         upperLayerInGate = gate("upperLayerIn");
         transmissionChannel = nullptr;
         curTxFrame = nullptr;
 
         initializeFlags();
 
         initializeMACAddress();
         initializeStatistics();
 
         lastTxFinishTime = -1.0;    // not equals with current simtime.
 
         // initialize self messages
         endTxMsg = new cMessage("EndTransmission", ENDTRANSMISSION);
         endIFGMsg = new cMessage("EndIFG", ENDIFG);
         endPauseMsg = new cMessage("EndPause", ENDPAUSE);
 
         // initialize states
         transmitState = TX_IDLE_STATE;
         receiveState = RX_IDLE_STATE;
         WATCH(transmitState);
         WATCH(receiveState);
 
         // initialize pause
         pauseUnitsRequested = 0;
         WATCH(pauseUnitsRequested);
 
         subscribe(POST_MODEL_CHANGE, this);
     }
     else if (stage == INITSTAGE_LINK_LAYER) {
         registerInterface();    // needs MAC address    //FIXME why not called in MACBase::initialize()?
         initializeQueueModule();
         readChannelParameters(true);
     }
 }

void inet::EtherMACBase::initializeFlags ( )

protectedvirtual

Reimplemented in inet::EtherMAC, and inet::EtherMACFullDuplex.

Referenced by handleOperationStage(), initialize(), inet::EtherMACFullDuplex::initializeFlags(), and inet::EtherMAC::initializeFlags().

 {
     duplexMode = true;
 
     // initialize connected flag
     connected = physOutGate->getPathEndGate()->isConnected() && physInGate->getPathStartGate()->isConnected();
 
     if (!connected)
         EV_WARN << "MAC not connected to a network.\n";
 
     WATCH(connected);
 
     // TODO: this should be set from the GUI
     // initialize disabled flag
     // Note: it is currently not supported to enable a disabled MAC at runtime.
     // Difficulties: (1) autoconfig (2) how to pick up channel state (free, tx, collision etc)
     disabled = false;
     WATCH(disabled);
 
     // initialize promiscuous flag
     promiscuous = par("promiscuous");
     WATCH(promiscuous);
 
     frameBursting = false;
     WATCH(frameBursting);
 }

void inet::EtherMACBase::initializeMACAddress ( )

protectedvirtual

Referenced by handleOperationStage(), and 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);
     }
 }

void inet::EtherMACBase::initializeQueueModule ( )

protectedvirtual

Referenced by handleOperationStage(), and initialize().

 {
     if (par("queueModule").stringValue()[0]) {
         cModule *module = getModuleFromPar<cModule>(par("queueModule"), this);
         IPassiveQueue *queueModule;
         if (module->isSimple())
             queueModule = check_and_cast<IPassiveQueue *>(module);
         else {
             cGate *queueOut = module->gate("out")->getPathStartGate();
             queueModule = check_and_cast<IPassiveQueue *>(queueOut->getOwnerModule());
         }
 
         EV_DETAIL << "Requesting first frame from queue module\n";
         txQueue.setExternalQueue(queueModule);
 
         if (txQueue.extQueue->getNumPendingRequests() == 0)
             txQueue.extQueue->requestPacket();
     }
     else {
         txQueue.setInternalQueue("txQueue", par("txQueueLimit").longValue());
     }
 }

void inet::EtherMACBase::initializeStatistics ( )

protectedvirtual

Reimplemented in inet::EtherMAC, and inet::EtherMACFullDuplex.

Referenced by initialize(), inet::EtherMACFullDuplex::initializeStatistics(), and inet::EtherMAC::initializeStatistics().

 {
     numFramesSent = numFramesReceivedOK = numBytesSent = numBytesReceivedOK = 0;
     numFramesPassedToHL = numDroppedBitError = numDroppedNotForUs = 0;
     numFramesFromHL = numDroppedIfaceDown = numDroppedPkFromHLIfaceDown = 0;
     numPauseFramesRcvd = numPauseFramesSent = 0;
 
     WATCH(numFramesSent);
     WATCH(numFramesReceivedOK);
     WATCH(numBytesSent);
     WATCH(numBytesReceivedOK);
     WATCH(numFramesFromHL);
     WATCH(numDroppedPkFromHLIfaceDown);
     WATCH(numDroppedIfaceDown);
     WATCH(numDroppedBitError);
     WATCH(numDroppedNotForUs);
     WATCH(numFramesPassedToHL);
     WATCH(numPauseFramesRcvd);
     WATCH(numPauseFramesSent);
 }

bool inet::EtherMACBase::isActive ( )

inline

201 { return connected && !disabled; }

inet::EtherMACBase::connected

bool connected

Definition: EtherMACBase.h:134

inet::EtherMACBase::disabled

bool disabled

Definition: EtherMACBase.h:135

virtual bool inet::EtherMACBase::isUpperMsg ( cMessage * msg )

inlineoverrideprotectedvirtual

should return true if the msg arrived from upper layer, else return false

Implements inet::MACBase.

241 { return msg->getArrivalGate() == upperLayerInGate; }

inet::EtherMACBase::upperLayerInGate

cGate * upperLayerInGate

Definition: EtherMACBase.h:145

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

inlineoverrideprotectedvirtual

Reimplemented from inet::MACBase.

Reimplemented in inet::EtherMAC, and inet::EtherMACFullDuplex.

211 { return NUM_INIT_STAGES; }

inet::NUM_INIT_STAGES

The number of initialization stages.

Definition: InitStages.h:116

void inet::EtherMACBase::printParameters ( )

protectedvirtual

 {
     // Dump parameters
     EV_DETAIL << "MAC address: " << address << (promiscuous ? ", promiscuous mode" : "") << endl
               << "txrate: " << curEtherDescr->txrate << ", "
               << (duplexMode ? "full-duplex" : "half-duplex") << endl;
 #if 1
     EV_DETAIL << "bitTime: " << 1.0 / curEtherDescr->txrate << endl;
     EV_DETAIL << "frameBursting: " << frameBursting << endl;
     EV_DETAIL << "slotTime: " << curEtherDescr->slotTime << endl;
     EV_DETAIL << "interFrameGap: " << INTERFRAME_GAP_BITS / curEtherDescr->txrate << endl;
     EV_DETAIL << endl;
 #endif // if 1
 }

void inet::EtherMACBase::processConnectDisconnect ( )

protectedvirtual

Reimplemented in inet::EtherMAC.

Referenced by handleOperationStage(), inet::EtherMAC::processConnectDisconnect(), and refreshConnection().

 {
     if (!connected) {
         cancelEvent(endTxMsg);
         cancelEvent(endIFGMsg);
         cancelEvent(endPauseMsg);
 
         if (curTxFrame) {
             delete curTxFrame;
             curTxFrame = nullptr;
             lastTxFinishTime = -1.0;    // so that it never equals to the current simtime, used for Burst mode detection.
         }
 
         if (txQueue.extQueue) {
             // Clear external queue: send a request, and received packet will be deleted in handleMessage()
             if (txQueue.extQueue->getNumPendingRequests() == 0)
                 txQueue.extQueue->requestPacket();
         }
         else {
             // Clear inner queue
             while (!txQueue.innerQueue->isEmpty()) {
                 cMessage *msg = check_and_cast<cMessage *>(txQueue.innerQueue->pop());
                 EV_DETAIL << "Interface is not connected, dropping packet " << msg << endl;
                 numDroppedPkFromHLIfaceDown++;
                 emit(dropPkIfaceDownSignal, msg);
                 delete msg;
             }
         }
 
         transmitState = TX_IDLE_STATE;
         emit(transmitStateSignal, TX_IDLE_STATE);
         receiveState = RX_IDLE_STATE;
         emit(receiveStateSignal, RX_IDLE_STATE);
     }
 }

void inet::EtherMACBase::readChannelParameters ( bool errorWhenAsymmetric )

protectedvirtual

Calculates datarates, etc.

Verifies the datarates on the incoming/outgoing channels, and throws error when they differ and the parameter errorWhenAsymmetric is true.

Reimplemented in inet::EtherMAC.

Referenced by inet::EtherMACFullDuplex::handleMessage(), initialize(), inet::EtherMAC::readChannelParameters(), and refreshConnection().

 {
     // When the connected channels change at runtime, we'll receive
     // two separate notifications (one for the rx channel and one for the tx one),
     // so we cannot immediately raise an error when they differ. Rather, we'll need
     // to verify at the next opportunity (event) that the two channels have eventually
     // been set to the same value.
 
     cDatarateChannel *outTrChannel = check_and_cast_nullable<cDatarateChannel *>(physOutGate->findTransmissionChannel());
     cDatarateChannel *inTrChannel = check_and_cast_nullable<cDatarateChannel *>(physInGate->findIncomingTransmissionChannel());
 
     connected = physOutGate->getPathEndGate()->isConnected() && physInGate->getPathStartGate()->isConnected();
 
     if (connected && ((!outTrChannel) || (!inTrChannel)))
         throw cRuntimeError("Ethernet phys gate must be connected using a transmission channel");
 
     double txRate = outTrChannel ? outTrChannel->getNominalDatarate() : 0.0;
     double rxRate = inTrChannel ? inTrChannel->getNominalDatarate() : 0.0;
 
     bool rxDisabled = !inTrChannel || inTrChannel->isDisabled();
     bool txDisabled = !outTrChannel || outTrChannel->isDisabled();
 
     if (errorWhenAsymmetric && (rxDisabled != txDisabled))
         throw cRuntimeError("The enablements of the input/output channels differ (rx=%s vs tx=%s)", rxDisabled ? "off" : "on", txDisabled ? "off" : "on");
 
     if (txDisabled)
         connected = false;
 
     bool dataratesDiffer;
     if (!connected) {
         curEtherDescr = &nullEtherDescr;
         dataratesDiffer = false;
         if (!outTrChannel)
             transmissionChannel = nullptr;
         if (interfaceEntry) {
             interfaceEntry->setCarrier(false);
             interfaceEntry->setDatarate(0);
         }
     }
     else {
         if (outTrChannel && !transmissionChannel)
             outTrChannel->subscribe(POST_MODEL_CHANGE, this);
         transmissionChannel = outTrChannel;
         dataratesDiffer = (txRate != rxRate);
     }
 
     channelsDiffer = dataratesDiffer || (rxDisabled != txDisabled);
 
     if (errorWhenAsymmetric && dataratesDiffer)
         throw cRuntimeError("The input/output datarates differ (rx=%g bps vs tx=%g bps)", rxRate, txRate);
 
     if (connected) {
         // Check valid speeds
         for (auto & etherDescr : etherDescrs) {
             if (txRate == etherDescr.txrate) {
                 curEtherDescr = &(etherDescr);
                 if (interfaceEntry) {
                     interfaceEntry->setCarrier(true);
                     interfaceEntry->setDatarate(txRate);
                 }
                 return;
             }
         }
         throw cRuntimeError("Invalid transmission rate %g bps on channel %s at module %s",
                 txRate, transmissionChannel->getFullPath().c_str(), getFullPath().c_str());
     }
 }

void inet::EtherMACBase::receiveSignal	(	cComponent *	src,
		simsignal_t	signalId,
		cObject *	obj,
		cObject *	details
	)

overrideprotectedvirtual

Reimplemented from inet::MACBase.

 {
     Enter_Method_Silent();
 
     MACBase::receiveSignal(source, signalID, obj, details);
 
     if (signalID != POST_MODEL_CHANGE)
         return;
 
     if (dynamic_cast<cPostPathCreateNotification *>(obj)) {
         cPostPathCreateNotification *gcobj = (cPostPathCreateNotification *)obj;
 
         if ((physOutGate == gcobj->pathStartGate) || (physInGate == gcobj->pathEndGate))
             refreshConnection();
     }
     else if (dynamic_cast<cPostPathCutNotification *>(obj)) {
         cPostPathCutNotification *gcobj = (cPostPathCutNotification *)obj;
 
         if ((physOutGate == gcobj->pathStartGate) || (physInGate == gcobj->pathEndGate))
             refreshConnection();
     }
     else if (transmissionChannel && dynamic_cast<cPostParameterChangeNotification *>(obj)) {    // note: we are subscribed to the channel object too
         cPostParameterChangeNotification *gcobj = (cPostParameterChangeNotification *)obj;
         if (transmissionChannel == gcobj->par->getOwner())
             refreshConnection();
     }
 }

void inet::EtherMACBase::refreshConnection ( )

protectedvirtual

Referenced by receiveSignal().

 {
     Enter_Method_Silent();
 
     bool oldConn = connected;
     readChannelParameters(false);
 
     if (oldConn != connected)
         processConnectDisconnect();
 }

void inet::EtherMACBase::refreshDisplay ( ) const

overrideprotectedvirtual

 {
     // icon coloring
     const char *color;
 
     if (receiveState == RX_COLLISION_STATE)
         color = "red";
     else if (transmitState == TRANSMITTING_STATE)
         color = "yellow";
     else if (transmitState == JAMMING_STATE)
         color = "red";
     else if (receiveState == RECEIVING_STATE)
         color = "#4040ff";
     else if (transmitState == BACKOFF_STATE)
         color = "white";
     else if (transmitState == PAUSE_STATE)
         color = "gray";
     else
         color = "";
 
     getDisplayString().setTagArg("i", 1, color);
 
     if (!strcmp(getParentModule()->getNedTypeName(), "inet.linklayer.ethernet.EthernetInterface"))
         getParentModule()->getDisplayString().setTagArg("i", 1, color);
 
 #if 0
     // this code works but didn't turn out to be very useful
     const char *txStateName;
 
     switch (transmitState) {
         case TX_IDLE_STATE:
             txStateName = "IDLE";
             break;
 
         case WAIT_IFG_STATE:
             txStateName = "WAIT_IFG";
             break;
 
         case SEND_IFG_STATE:
             txStateName = "SEND_IFG";
             break;
 
         case TRANSMITTING_STATE:
             txStateName = "TX";
             break;
 
         case JAMMING_STATE:
             txStateName = "JAM";
             break;
 
         case BACKOFF_STATE:
             txStateName = "BACKOFF";
             break;
 
         case PAUSE_STATE:
             txStateName = "PAUSE";
             break;
 
         default:
             throw cRuntimeError("wrong tx state");
     }
 
     const char *rxStateName;
 
     switch (receiveState) {
         case RX_IDLE_STATE:
             rxStateName = "IDLE";
             break;
 
         case RECEIVING_STATE:
             rxStateName = "RX";
             break;
 
         case RX_COLLISION_STATE:
             rxStateName = "COLL";
             break;
 
         default:
             throw cRuntimeError("wrong rx state");
     }
 
     char buf[80];
     sprintf(buf, "tx:%s rx: %s\n#boff:%d #cTx:%d",
             txStateName, rxStateName, backoffs, numConcurrentTransmissions);
     getDisplayString().setTagArg("t", 0, buf);
 #endif // if 0
 }

void inet::EtherMACBase::requestNextFrameFromExtQueue ( )

protectedvirtual

Referenced by inet::EtherMACFullDuplex::processFrameFromUpperLayer(), and inet::EtherMAC::processFrameFromUpperLayer().

 {
     ASSERT(nullptr == curTxFrame);
     if (txQueue.extQueue) {
         if (txQueue.extQueue->getNumPendingRequests() == 0)
             txQueue.extQueue->requestPacket();
     }
 }

Member Data Documentation

MACAddress inet::EtherMACBase::address

protected

Referenced by createInterfaceEntry(), dropFrameNotForUs(), initializeMACAddress(), printParameters(), inet::EtherMACFullDuplex::processFrameFromUpperLayer(), inet::EtherMAC::processFrameFromUpperLayer(), inet::EtherMACFullDuplex::startFrameTransmission(), and inet::EtherMAC::startFrameTransmission().

bool inet::EtherMACBase::channelsDiffer = false

protected

Referenced by inet::EtherMACFullDuplex::handleMessage(), inet::EtherMAC::handleMessage(), and readChannelParameters().

bool inet::EtherMACBase::connected = false

protected

Referenced by handleOperationStage(), initializeFlags(), inet::EtherMAC::processConnectDisconnect(), processConnectDisconnect(), inet::EtherMACFullDuplex::processFrameFromUpperLayer(), inet::EtherMAC::processFrameFromUpperLayer(), inet::EtherMACFullDuplex::processMsgFromNetwork(), inet::EtherMAC::processMsgFromNetwork(), inet::EtherMAC::readChannelParameters(), readChannelParameters(), and refreshConnection().

const EtherDescr* inet::EtherMACBase::curEtherDescr = nullptr

protected

Referenced by EtherMACBase(), inet::EtherMAC::fillIFGIfInBurst(), inet::EtherMAC::handleRetransmission(), printParameters(), inet::EtherMAC::processConnectDisconnect(), inet::EtherMAC::processMsgFromNetwork(), inet::EtherMAC::readChannelParameters(), readChannelParameters(), inet::EtherMACFullDuplex::scheduleEndIFGPeriod(), inet::EtherMAC::scheduleEndIFGPeriod(), inet::EtherMACFullDuplex::scheduleEndPausePeriod(), inet::EtherMAC::scheduleEndPausePeriod(), inet::EtherMACFullDuplex::startFrameTransmission(), and inet::EtherMAC::startFrameTransmission().

EtherFrame* inet::EtherMACBase::curTxFrame = nullptr

protected

Referenced by inet::EtherMACFullDuplex::beginSendFrames(), inet::EtherMAC::beginSendFrames(), inet::EtherMAC::fillIFGIfInBurst(), getNextFrameFromQueue(), inet::EtherMAC::handleEndBackoffPeriod(), inet::EtherMACFullDuplex::handleEndIFGPeriod(), inet::EtherMACFullDuplex::handleEndPausePeriod(), inet::EtherMACFullDuplex::handleEndTxPeriod(), inet::EtherMAC::handleEndTxPeriod(), inet::EtherMAC::handleRetransmission(), initialize(), processConnectDisconnect(), inet::EtherMACFullDuplex::processFrameFromUpperLayer(), inet::EtherMAC::processFrameFromUpperLayer(), requestNextFrameFromExtQueue(), inet::EtherMACFullDuplex::scheduleEndIFGPeriod(), inet::EtherMACFullDuplex::scheduleEndPausePeriod(), inet::EtherMACFullDuplex::startFrameTransmission(), inet::EtherMAC::startFrameTransmission(), and ~EtherMACBase().

bool inet::EtherMACBase::disabled = false

protected

Referenced by finish(), initializeFlags(), inet::EtherMACFullDuplex::processFrameFromUpperLayer(), inet::EtherMAC::processFrameFromUpperLayer(), inet::EtherMACFullDuplex::processMsgFromNetwork(), and inet::EtherMAC::processMsgFromNetwork().

simsignal_t inet::EtherMACBase::dropPkBitErrorSignal = registerSignal("dropPkBitError")

staticprotected

Referenced by inet::EtherMAC::frameReceptionComplete(), and inet::EtherMACFullDuplex::processMsgFromNetwork().

simsignal_t inet::EtherMACBase::dropPkFromHLIfaceDownSignal = registerSignal("dropPkFromHLIfaceDown")

static

Referenced by flushQueue(), inet::EtherMACFullDuplex::processFrameFromUpperLayer(), inet::EtherMAC::processFrameFromUpperLayer(), inet::visualizer::PacketDropVisualizerBase::receiveSignal(), inet::visualizer::PacketDropVisualizerBase::subscribe(), and inet::visualizer::PacketDropVisualizerBase::unsubscribe().

simsignal_t inet::EtherMACBase::dropPkIfaceDownSignal = registerSignal("dropPkIfaceDown")

static

Referenced by processConnectDisconnect(), inet::EtherMACFullDuplex::processMsgFromNetwork(), inet::EtherMAC::processMsgFromNetwork(), inet::visualizer::PacketDropVisualizerBase::receiveSignal(), inet::visualizer::PacketDropVisualizerBase::subscribe(), and inet::visualizer::PacketDropVisualizerBase::unsubscribe().

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

staticprotected

Referenced by dropFrameNotForUs().

bool inet::EtherMACBase::duplexMode = false

protected

Referenced by decapsulate(), encapsulate(), finish(), inet::EtherMAC::handleEndTxPeriod(), inet::EtherMAC::handleMessage(), inet::EtherMACFullDuplex::initializeFlags(), inet::EtherMAC::initializeFlags(), initializeFlags(), printParameters(), inet::EtherMAC::processConnectDisconnect(), inet::EtherMAC::processFrameFromUpperLayer(), inet::EtherMAC::processMsgFromNetwork(), inet::EtherMAC::readChannelParameters(), and inet::EtherMAC::startFrameTransmission().

cMessage * inet::EtherMACBase::endIFGMsg = nullptr

protected

Referenced by inet::EtherMAC::fillIFGIfInBurst(), inet::EtherMACFullDuplex::handleSelfMessage(), initialize(), processConnectDisconnect(), inet::EtherMAC::processMsgFromNetwork(), inet::EtherMACFullDuplex::scheduleEndIFGPeriod(), inet::EtherMAC::scheduleEndIFGPeriod(), and ~EtherMACBase().

cMessage * inet::EtherMACBase::endPauseMsg = nullptr

protected

Referenced by inet::EtherMACFullDuplex::handleSelfMessage(), initialize(), processConnectDisconnect(), inet::EtherMACFullDuplex::processPauseCommand(), inet::EtherMAC::processReceivedPauseFrame(), inet::EtherMACFullDuplex::scheduleEndPausePeriod(), inet::EtherMAC::scheduleEndPausePeriod(), and ~EtherMACBase().

cMessage* inet::EtherMACBase::endTxMsg = nullptr

protected

Referenced by inet::EtherMACFullDuplex::handleSelfMessage(), initialize(), processConnectDisconnect(), inet::EtherMAC::processMsgFromNetwork(), inet::EtherMAC::scheduleEndTxPeriod(), inet::EtherMACFullDuplex::startFrameTransmission(), and ~EtherMACBase().

const EtherMACBase::EtherDescr inet::EtherMACBase::etherDescrs

staticprotected

Referenced by readChannelParameters().

bool inet::EtherMACBase::frameBursting = false

protected

Referenced by inet::EtherMAC::fillIFGIfInBurst(), inet::EtherMAC::handleEndIFGPeriod(), inet::EtherMAC::initializeFlags(), initializeFlags(), printParameters(), inet::EtherMAC::scheduleEndTxPeriod(), and inet::EtherMAC::startFrameTransmission().

simtime_t inet::EtherMACBase::lastTxFinishTime

protected

Referenced by EtherMACBase(), inet::EtherMAC::fillIFGIfInBurst(), inet::EtherMACFullDuplex::handleEndTxPeriod(), inet::EtherMAC::handleEndTxPeriod(), initialize(), and processConnectDisconnect().

const EtherMACBase::EtherDescr inet::EtherMACBase::nullEtherDescr

staticprotected

Initial value:

Referenced by EtherMACBase(), and readChannelParameters().

unsigned long inet::EtherMACBase::numBytesReceivedOK = 0

protected

Referenced by finish(), initializeStatistics(), inet::EtherMACFullDuplex::processReceivedDataFrame(), and inet::EtherMAC::processReceivedDataFrame().

unsigned long inet::EtherMACBase::numBytesSent = 0

protected

Referenced by finish(), inet::EtherMACFullDuplex::handleEndTxPeriod(), inet::EtherMAC::handleEndTxPeriod(), and initializeStatistics().

unsigned long inet::EtherMACBase::numDroppedBitError = 0

protected

Referenced by inet::EtherMAC::frameReceptionComplete(), initializeStatistics(), and inet::EtherMACFullDuplex::processMsgFromNetwork().

unsigned long inet::EtherMACBase::numDroppedIfaceDown = 0

protected

Referenced by initializeStatistics(), inet::EtherMACFullDuplex::processMsgFromNetwork(), and inet::EtherMAC::processMsgFromNetwork().

unsigned long inet::EtherMACBase::numDroppedNotForUs = 0

protected

Referenced by dropFrameNotForUs(), and initializeStatistics().

unsigned long inet::EtherMACBase::numDroppedPkFromHLIfaceDown = 0

protected

Referenced by initializeStatistics(), processConnectDisconnect(), inet::EtherMACFullDuplex::processFrameFromUpperLayer(), and inet::EtherMAC::processFrameFromUpperLayer().

unsigned long inet::EtherMACBase::numFramesFromHL = 0

protected

Referenced by initializeStatistics(), inet::EtherMACFullDuplex::processFrameFromUpperLayer(), and inet::EtherMAC::processFrameFromUpperLayer().

unsigned long inet::EtherMACBase::numFramesPassedToHL = 0

protected

Referenced by initializeStatistics(), inet::EtherMACFullDuplex::processReceivedDataFrame(), and inet::EtherMAC::processReceivedDataFrame().

unsigned long inet::EtherMACBase::numFramesReceivedOK = 0

protected

Referenced by finish(), initializeStatistics(), inet::EtherMACFullDuplex::processReceivedDataFrame(), and inet::EtherMAC::processReceivedDataFrame().

unsigned long inet::EtherMACBase::numFramesSent = 0

protected

Referenced by finish(), inet::EtherMACFullDuplex::handleEndTxPeriod(), inet::EtherMAC::handleEndTxPeriod(), and initializeStatistics().

unsigned long inet::EtherMACBase::numPauseFramesRcvd = 0

protected

Referenced by initializeStatistics(), inet::EtherMACFullDuplex::processMsgFromNetwork(), and inet::EtherMAC::processReceivedPauseFrame().

unsigned long inet::EtherMACBase::numPauseFramesSent = 0

protected

Referenced by inet::EtherMACFullDuplex::handleEndTxPeriod(), inet::EtherMAC::handleEndTxPeriod(), and initializeStatistics().

simsignal_t inet::EtherMACBase::packetReceivedFromLowerSignal = registerSignal("packetReceivedFromLower")

staticprotected

Referenced by inet::EtherMAC::frameReceptionComplete(), and inet::EtherMACFullDuplex::processMsgFromNetwork().

simsignal_t inet::EtherMACBase::packetReceivedFromUpperSignal = registerSignal("packetReceivedFromUpper")

staticprotected

Referenced by inet::EtherMACFullDuplex::processFrameFromUpperLayer(), and inet::EtherMAC::processFrameFromUpperLayer().

simsignal_t inet::EtherMACBase::packetSentToLowerSignal = registerSignal("packetSentToLower")

staticprotected

Referenced by inet::EtherMACFullDuplex::handleEndTxPeriod(), and inet::EtherMAC::handleEndTxPeriod().

simsignal_t inet::EtherMACBase::packetSentToUpperSignal = registerSignal("packetSentToUpper")

staticprotected

Referenced by inet::EtherMACFullDuplex::processReceivedDataFrame(), and inet::EtherMAC::processReceivedDataFrame().

int inet::EtherMACBase::pauseUnitsRequested = 0

protected

Referenced by inet::EtherMACFullDuplex::handleEndTxPeriod(), inet::EtherMAC::handleEndTxPeriod(), initialize(), inet::EtherMACFullDuplex::processPauseCommand(), and inet::EtherMAC::processReceivedPauseFrame().

cGate* inet::EtherMACBase::physInGate = nullptr

protected

Referenced by inet::EtherMACFullDuplex::handleMessage(), inet::EtherMAC::handleMessage(), initialize(), inet::EtherMACFullDuplex::initializeFlags(), inet::EtherMAC::initializeFlags(), initializeFlags(), readChannelParameters(), and receiveSignal().

cGate* inet::EtherMACBase::physOutGate = nullptr

protected

Referenced by inet::EtherMAC::fillIFGIfInBurst(), initialize(), initializeFlags(), readChannelParameters(), receiveSignal(), inet::EtherMAC::sendJamSignal(), inet::EtherMACFullDuplex::startFrameTransmission(), and inet::EtherMAC::startFrameTransmission().

bool inet::EtherMACBase::promiscuous = false

protected

Referenced by dropFrameNotForUs(), initializeFlags(), and printParameters().

MACReceiveState inet::EtherMACBase::receiveState = (MACReceiveState)-1

protected

simsignal_t inet::EtherMACBase::receiveStateSignal = registerSignal("receiveState")

staticprotected

Referenced by inet::EtherMAC::handleEndRxPeriod(), inet::EtherMAC::processConnectDisconnect(), processConnectDisconnect(), inet::EtherMAC::processDetectedCollision(), inet::EtherMAC::processMsgFromNetwork(), inet::EtherMAC::scheduleEndRxPeriod(), and inet::EtherMAC::startFrameTransmission().

simsignal_t inet::EtherMACBase::rxPausePkUnitsSignal = registerSignal("rxPausePkUnits")

staticprotected

Referenced by inet::EtherMACFullDuplex::processMsgFromNetwork(), and inet::EtherMAC::processReceivedPauseFrame().

simsignal_t inet::EtherMACBase::rxPkFromHLSignal = registerSignal("rxPkFromHL")

staticprotected

Referenced by inet::EtherMACFullDuplex::processFrameFromUpperLayer(), and inet::EtherMAC::processFrameFromUpperLayer().

simsignal_t inet::EtherMACBase::rxPkOkSignal = registerSignal("rxPkOk")

staticprotected

Referenced by inet::EtherMACFullDuplex::processReceivedDataFrame(), and inet::EtherMAC::processReceivedDataFrame().

const double inet::EtherMACBase::SPEED_OF_LIGHT_IN_CABLE = 200000000.0

static

Referenced by inet::EtherMAC::processMsgFromNetwork().

cChannel* inet::EtherMACBase::transmissionChannel = nullptr

protected

Referenced by inet::EtherMAC::fillIFGIfInBurst(), initialize(), readChannelParameters(), receiveSignal(), inet::EtherMAC::scheduleEndTxPeriod(), inet::EtherMAC::sendJamSignal(), and inet::EtherMACFullDuplex::startFrameTransmission().

MACTransmitState inet::EtherMACBase::transmitState = (MACTransmitState)-1

protected

simsignal_t inet::EtherMACBase::transmitStateSignal = registerSignal("transmitState")

staticprotected

simsignal_t inet::EtherMACBase::txPausePkUnitsSignal = registerSignal("txPausePkUnits")

staticprotected

Referenced by inet::EtherMACFullDuplex::handleEndTxPeriod(), and inet::EtherMAC::handleEndTxPeriod().

simsignal_t inet::EtherMACBase::txPkSignal = registerSignal("txPk")

staticprotected

Referenced by inet::EtherMACFullDuplex::handleEndTxPeriod(), and inet::EtherMAC::handleEndTxPeriod().

MacQueue inet::EtherMACBase::txQueue

protected

Referenced by inet::EtherMACFullDuplex::beginSendFrames(), clearQueue(), flushQueue(), getNextFrameFromQueue(), inet::EtherMAC::handleEndTxPeriod(), initializeQueueModule(), inet::EtherMAC::printState(), processConnectDisconnect(), inet::EtherMACFullDuplex::processFrameFromUpperLayer(), inet::EtherMAC::processFrameFromUpperLayer(), and requestNextFrameFromExtQueue().

cGate* inet::EtherMACBase::upperLayerInGate = nullptr

protected

Referenced by inet::EtherMACFullDuplex::handleMessage(), inet::EtherMAC::handleMessage(), and initialize().

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

Classes

Public Types

Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation