Performs Ethernet II encapsulation/decapsulation. More...

#include <EtherEncap.h>

Inheritance diagram for inet::EtherEncap:

Protected Member Functions
virtual int	numInitStages () const override

virtual void	initialize (int stage) override

virtual void	handleMessage (cMessage *msg) override

virtual void	processPacketFromHigherLayer (cPacket *msg)

virtual void	processFrameFromMAC (EtherFrame *msg)

virtual void	handleSendPause (cMessage *msg)

virtual void	refreshDisplay () const override

Protected Attributes
int	seqNum

long	totalFromHigherLayer

long	totalFromMAC

long	totalPauseSent

int	interfaceId = -1

bool	useSNAP

Static Protected Attributes
static simsignal_t	encapPkSignal = registerSignal("encapPk")

static simsignal_t	decapPkSignal = registerSignal("decapPk")

static simsignal_t	pauseSentSignal = registerSignal("pauseSent")

Detailed Description

Performs Ethernet II encapsulation/decapsulation.

More info in the NED file.

Member Function Documentation

void inet::EtherEncap::handleMessage ( cMessage * msg )

overrideprotectedvirtual

 {
     if (msg->arrivedOn("lowerLayerIn")) {
         EV_INFO << "Received " << msg << " from lower layer." << endl;
         processFrameFromMAC(check_and_cast<EtherFrame *>(msg));
     }
     else {
         EV_INFO << "Received " << msg << " from upper layer." << endl;
         // from higher layer
         switch (msg->getKind()) {
             case IEEE802CTRL_DATA:
             case 0:    // default message kind (0) is also accepted
                 processPacketFromHigherLayer(PK(msg));
                 break;
 
             case IEEE802CTRL_SENDPAUSE:
                 // higher layer want MAC to send PAUSE frame
                 handleSendPause(msg);
                 break;
 
             default:
                 throw cRuntimeError("Received message `%s' with unknown message kind %d", msg->getName(), msg->getKind());
         }
     }
 }

void inet::EtherEncap::handleSendPause ( cMessage * msg )

protectedvirtual

Referenced by handleMessage().

 {
     Ieee802Ctrl *etherctrl = dynamic_cast<Ieee802Ctrl *>(msg->removeControlInfo());
     if (!etherctrl)
         throw cRuntimeError("PAUSE command `%s' from higher layer received without Ieee802Ctrl", msg->getName());
     int pauseUnits = etherctrl->getPauseUnits();
     MACAddress dest = etherctrl->getDest();
     delete etherctrl;
 
     EV_DETAIL << "Creating and sending PAUSE frame, with duration = " << pauseUnits << " units\n";
 
     // create Ethernet frame
     char framename[40];
     sprintf(framename, "pause-%d-%d", getId(), seqNum++);
     EtherPauseFrame *frame = new EtherPauseFrame(framename);
     frame->setPauseTime(pauseUnits);
     if (dest.isUnspecified())
         dest = MACAddress::MULTICAST_PAUSE_ADDRESS;
     frame->setDest(dest);
     frame->setByteLength(ETHER_PAUSE_COMMAND_PADDED_BYTES);
 
     EV_INFO << "Sending " << frame << " to lower layer.\n";
     send(frame, "lowerLayerOut");
     delete msg;
 
     emit(pauseSentSignal, pauseUnits);
     totalPauseSent++;
 }

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

overrideprotectedvirtual

 {
     if (stage == INITSTAGE_LOCAL) {
         seqNum = 0;
         WATCH(seqNum);
         totalFromHigherLayer = totalFromMAC = totalPauseSent = 0;
         useSNAP = par("useSNAP").boolValue();
         WATCH(totalFromHigherLayer);
         WATCH(totalFromMAC);
         WATCH(totalPauseSent);
     }
     else if (stage == INITSTAGE_LINK_LAYER_2) {
         IInterfaceTable *ift = findModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
         InterfaceEntry *myIface = ift != nullptr ? ift->getInterfaceByName(utils::stripnonalnum(findModuleUnderContainingNode(this)->getFullName()).c_str()) : nullptr;
         interfaceId = (myIface != nullptr) ? myIface->getInterfaceId() : -1;
     }
 }

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

inlineoverrideprotectedvirtual

49 { return NUM_INIT_STAGES; }

inet::NUM_INIT_STAGES

The number of initialization stages.

Definition: InitStages.h:116

void inet::EtherEncap::processFrameFromMAC ( EtherFrame * msg )

protectedvirtual

Referenced by handleMessage().

 {
     // decapsulate and attach control info
     cPacket *higherlayermsg = frame->decapsulate();
 
     // add Ieee802Ctrl to packet
     Ieee802Ctrl *etherctrl = new Ieee802Ctrl();
     etherctrl->setSrc(frame->getSrc());
     etherctrl->setDest(frame->getDest());
     etherctrl->setInterfaceId(interfaceId);
     if (dynamic_cast<EthernetIIFrame *>(frame) != nullptr)
         etherctrl->setEtherType(((EthernetIIFrame *)frame)->getEtherType());
     else if (dynamic_cast<EtherFrameWithSNAP *>(frame) != nullptr)
         etherctrl->setEtherType(((EtherFrameWithSNAP *)frame)->getLocalcode());
     higherlayermsg->setControlInfo(etherctrl);
 
     EV_DETAIL << "Decapsulating frame `" << frame->getName() << "', passing up contained packet `"
               << higherlayermsg->getName() << "' to higher layer\n";
 
     totalFromMAC++;
     emit(decapPkSignal, higherlayermsg);
 
     // pass up to higher layers.
     EV_INFO << "Sending " << higherlayermsg << " to upper layer.\n";
     send(higherlayermsg, "upperLayerOut");
     delete frame;
 }

void inet::EtherEncap::processPacketFromHigherLayer ( cPacket * msg )

protectedvirtual

Referenced by handleMessage().

 {
     if (msg->getByteLength() > MAX_ETHERNET_DATA_BYTES)
         throw cRuntimeError("packet from higher layer (%d bytes) exceeds maximum Ethernet payload length (%d)", (int)msg->getByteLength(), MAX_ETHERNET_DATA_BYTES);
 
     totalFromHigherLayer++;
     emit(encapPkSignal, msg);
 
     // Creates MAC header information and encapsulates received higher layer data
     // with this information and transmits resultant frame to lower layer
 
     // create Ethernet frame, fill it in from Ieee802Ctrl and encapsulate msg in it
     EV_DETAIL << "Encapsulating higher layer packet `" << msg->getName() << "' for MAC\n";
 
     IMACProtocolControlInfo *controlInfo = check_and_cast<IMACProtocolControlInfo *>(msg->removeControlInfo());
     Ieee802Ctrl *etherctrl = dynamic_cast<Ieee802Ctrl *>(controlInfo);
     EtherFrame *frame = nullptr;
 
     if (useSNAP) {
         EtherFrameWithSNAP *snapFrame = new EtherFrameWithSNAP(msg->getName());
 
         snapFrame->setSrc(controlInfo->getSourceAddress());    // if blank, will be filled in by MAC
         snapFrame->setDest(controlInfo->getDestinationAddress());
         snapFrame->setOrgCode(0);
         if (etherctrl)
             snapFrame->setLocalcode(etherctrl->getEtherType());
         frame = snapFrame;
     }
     else {
         EthernetIIFrame *eth2Frame = new EthernetIIFrame(msg->getName());
 
         eth2Frame->setSrc(controlInfo->getSourceAddress());    // if blank, will be filled in by MAC
         eth2Frame->setDest(controlInfo->getDestinationAddress());
         if (etherctrl)
             eth2Frame->setEtherType(etherctrl->getEtherType());
         frame = eth2Frame;
     }
     delete controlInfo;
 
     ASSERT(frame->getByteLength() > 0); // length comes from msg file
 
     frame->encapsulate(msg);
     if (frame->getByteLength() < MIN_ETHERNET_FRAME_BYTES)
         frame->setByteLength(MIN_ETHERNET_FRAME_BYTES); // "padding"
 
     EV_INFO << "Sending " << frame << " to lower layer.\n";
     send(frame, "lowerLayerOut");
 }

void inet::EtherEncap::refreshDisplay ( ) const

overrideprotectedvirtual

 {
     char buf[80];
     sprintf(buf, "passed up: %ld\nsent: %ld", totalFromMAC, totalFromHigherLayer);
     getDisplayString().setTagArg("t", 0, buf);
 }