inet::EthernetEncapsulation Class Reference

Performs Ethernet II encapsulation/decapsulation. More...

#include <EthernetEncapsulation.h>

Inheritance diagram for inet::EthernetEncapsulation:

Classes
struct	Socket

Protected Member Functions
virtual	~EthernetEncapsulation ()
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessageWhenUp (cMessage *message) override
virtual void	handleRegisterService (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocol (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterAnyProtocol (cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	processCommandFromHigherLayer (Request *msg)
virtual void	processPacketFromHigherLayer (Packet *msg)
virtual void	processPacketFromMac (Packet *packet)
virtual void	handleSendPause (cMessage *msg)
virtual void	refreshDisplay () const override
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
virtual void	clearSockets ()
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()

Protected Attributes
std::set< const Protocol * >	upperProtocols
FcsMode	fcsMode = FCS_MODE_UNDEFINED
int	seqNum
long	totalFromHigherLayer
long	totalFromMAC
long	totalPauseSent
NetworkInterface *	networkInterface = nullptr
std::map< int, Socket * >	socketIdToSocketMap
bool	anyUpperProtocols = false
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Static Protected Attributes
static simsignal_t	encapPkSignal = registerSignal("encapPk")
static simsignal_t	decapPkSignal = registerSignal("decapPk")
static simsignal_t	pauseSentSignal = registerSignal("pauseSent")

Friends
std::ostream &	operator<< (std::ostream &o, const Socket &t)

Additional Inherited Members
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::DefaultProtocolRegistrationListener
virtual void	handleRegisterServiceGroup (const ProtocolGroup &protocolGroup, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocolGroup (const ProtocolGroup &protocolGroup, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterAnyService (cGate *gate, ServicePrimitive servicePrimitive) override
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Detailed Description

Performs Ethernet II encapsulation/decapsulation.

More info in the NED file.

Constructor & Destructor Documentation

~EthernetEncapsulation()

inet::EthernetEncapsulation::~EthernetEncapsulation ( )

protectedvirtual

{
    for (auto it : socketIdToSocketMap)
        delete it.second;
}

Member Function Documentation

clearSockets()

void inet::EthernetEncapsulation::clearSockets ( )

protectedvirtual

{
    for (auto& elem : socketIdToSocketMap) {
        delete elem.second;
        elem.second = nullptr;
    }
    socketIdToSocketMap.clear();
}

Referenced by handleCrashOperation(), handleStartOperation(), and handleStopOperation().

handleCrashOperation()

void inet::EthernetEncapsulation::handleCrashOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    clearSockets();
}

handleMessageWhenUp()

void inet::EthernetEncapsulation::handleMessageWhenUp ( cMessage *  message )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    if (msg->arrivedOn("upperLayerIn")) {
        // from upper layer
        EV_INFO << "Received " << msg << " from upper layer." << endl;
        if (msg->isPacket())
            processPacketFromHigherLayer(check_and_cast<Packet *>(msg));
        else
            processCommandFromHigherLayer(check_and_cast<Request *>(msg));
    }
    else if (msg->arrivedOn("lowerLayerIn")) {
        EV_INFO << "Received " << msg << " from lower layer." << endl;
        processPacketFromMac(check_and_cast<Packet *>(msg));
    }
    else
        throw cRuntimeError("Unknown gate");
}

handleRegisterAnyProtocol()

void inet::EthernetEncapsulation::handleRegisterAnyProtocol ( cGate *  gate, ServicePrimitive  servicePrimitive  )

overrideprotectedvirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterAnyProtocol");
    if (!strcmp("upperLayerOut", gate->getBaseName()))
        anyUpperProtocols = true;
}

handleRegisterProtocol()

void inet::EthernetEncapsulation::handleRegisterProtocol ( const Protocol &  protocol, cGate *  gate, ServicePrimitive  servicePrimitive  )

overrideprotectedvirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterProtocol");
    // KLUDGE this should be here: if (!strcmp("upperLayerOut", gate->getBaseName()))
    // but then the register protocol calls are lost, because they can't go through the traffic conditioner
    upperProtocols.insert(&protocol);
}

handleRegisterService()

void inet::EthernetEncapsulation::handleRegisterService ( const Protocol &  protocol, cGate *  gate, ServicePrimitive  servicePrimitive  )

overrideprotectedvirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterService");
}

handleSendPause()

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

protectedvirtual

{
    Ieee802PauseCommand *etherctrl = dynamic_cast<Ieee802PauseCommand *>(msg->getControlInfo());
    if (!etherctrl)
        throw cRuntimeError("PAUSE command `%s' from higher layer received without Ieee802PauseCommand controlinfo", msg->getName());
    MacAddress dest = etherctrl->getDestinationAddress();
    int pauseUnits = etherctrl->getPauseUnits();
    delete msg;
 
    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++);
    auto packet = new Packet(framename);
    const auto& frame = makeShared<EthernetPauseFrame>();
    const auto& hdr = makeShared<EthernetMacHeader>();
    frame->setPauseTime(pauseUnits);
    if (dest.isUnspecified())
        dest = MacAddress::MULTICAST_PAUSE_ADDRESS;
    hdr->setDest(dest);
    packet->insertAtFront(frame);
    hdr->setTypeOrLength(ETHERTYPE_FLOW_CONTROL);
    packet->insertAtFront(hdr);
    const auto& ethernetFcs = makeShared<EthernetFcs>();
    ethernetFcs->setFcsMode(fcsMode);
    packet->insertAtBack(ethernetFcs);
    packet->addTagIfAbsent<PacketProtocolTag>()->setProtocol(&Protocol::ethernetMac);
 
    EV_INFO << "Sending " << frame << " to lower layer.\n";
    send(packet, "lowerLayerOut");
 
    emit(pauseSentSignal, pauseUnits);
    totalPauseSent++;
}

Referenced by processCommandFromHigherLayer().

handleStartOperation()

void inet::EthernetEncapsulation::handleStartOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    clearSockets();
}

handleStopOperation()

void inet::EthernetEncapsulation::handleStopOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    clearSockets();
}

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

{
    OperationalBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        fcsMode = parseFcsMode(par("fcsMode"));
        seqNum = 0;
        WATCH(seqNum);
        totalFromHigherLayer = totalFromMAC = totalPauseSent = 0;
        networkInterface = findContainingNicModule(this); // TODO or getContainingNicModule() ? or use a MacForwardingTable?
 
        WATCH_PTRSET(upperProtocols);
        WATCH_PTRMAP(socketIdToSocketMap);
        WATCH(totalFromHigherLayer);
        WATCH(totalFromMAC);
        WATCH(totalPauseSent);
    }
    else if (stage == INITSTAGE_LINK_LAYER) {
        if (par("registerProtocol").boolValue()) { // FIXME //KUDGE should redesign place of EthernetEncapsulation and LLC modules
            // register service and protocol
            registerService(Protocol::ethernetMac, gate("upperLayerIn"), gate("upperLayerOut"));
            registerProtocol(Protocol::ethernetMac, gate("lowerLayerOut"), gate("lowerLayerIn"));
        }
    }
}

isInitializeStage()

virtual bool inet::EthernetEncapsulation::isInitializeStage ( int  stage ) const

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == INITSTAGE_LINK_LAYER; }

isModuleStartStage()

virtual bool inet::EthernetEncapsulation::isModuleStartStage ( int  stage ) const

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == ModuleStartOperation::STAGE_LINK_LAYER; }

isModuleStopStage()

virtual bool inet::EthernetEncapsulation::isModuleStopStage ( int  stage ) const

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == ModuleStopOperation::STAGE_LINK_LAYER; }

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

processCommandFromHigherLayer()

void inet::EthernetEncapsulation::processCommandFromHigherLayer ( Request *  msg )

protectedvirtual

{
    msg->removeTagIfPresent<DispatchProtocolReq>();
    auto ctrl = msg->getControlInfo();
    if (dynamic_cast<Ieee802PauseCommand *>(ctrl) != nullptr)
        handleSendPause(msg);
    else if (auto bindCommand = dynamic_cast<EthernetBindCommand *>(ctrl)) {
        int socketId = check_and_cast<Request *>(msg)->getTag<SocketReq>()->getSocketId();
        Socket *socket = new Socket(socketId);
        socket->interfaceId = msg->getTag<InterfaceReq>()->getInterfaceId();
        socket->localAddress = bindCommand->getLocalAddress();
        socket->remoteAddress = bindCommand->getRemoteAddress();
        socket->protocol = bindCommand->getProtocol();
        socket->steal = bindCommand->getSteal();
        socketIdToSocketMap[socketId] = socket;
        delete msg;
    }
    else if (dynamic_cast<SocketCloseCommand *>(ctrl) != nullptr) {
        int socketId = check_and_cast<Request *>(msg)->getTag<SocketReq>()->getSocketId();
        auto it = socketIdToSocketMap.find(socketId);
        if (it != socketIdToSocketMap.end()) {
            delete it->second;
            socketIdToSocketMap.erase(it);
            auto indication = new Indication("closed", SOCKET_I_CLOSED);
            auto ctrl = new SocketClosedIndication();
            indication->setControlInfo(ctrl);
            indication->addTag<SocketInd>()->setSocketId(socketId);
            send(indication, "transportOut");
            delete msg;
        }
    }
    else if (dynamic_cast<SocketDestroyCommand *>(ctrl) != nullptr) {
        int socketId = check_and_cast<Request *>(msg)->getTag<SocketReq>()->getSocketId();
        auto it = socketIdToSocketMap.find(socketId);
        if (it != socketIdToSocketMap.end()) {
            delete it->second;
            socketIdToSocketMap.erase(it);
            delete msg;
        }
    }
    else
        throw cRuntimeError("Unknown command: '%s' with %s", msg->getName(), ctrl->getClassName());
}

Referenced by handleMessageWhenUp().

processPacketFromHigherLayer()

void inet::EthernetEncapsulation::processPacketFromHigherLayer ( Packet *  msg )

protectedvirtual

{
    if (packet->getDataLength() > MAX_ETHERNET_DATA_BYTES)
        throw cRuntimeError("packet length from higher layer (%s) exceeds maximum Ethernet payload length (%s)", packet->getDataLength().str().c_str(), MAX_ETHERNET_DATA_BYTES.str().c_str());
 
    totalFromHigherLayer++;
    emit(encapPkSignal, packet);
 
    // 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 `" << packet->getName() << "' for MAC\n";
 
    int typeOrLength = -1;
    const auto& protocolTag = packet->addTagIfAbsent<PacketProtocolTag>();
    const Protocol *protocol = protocolTag->getProtocol();
    if (protocol && *protocol != Protocol::ieee8022llc)
        typeOrLength = ProtocolGroup::ethertype.getProtocolNumber(protocol);
    else
        typeOrLength = packet->getByteLength();
 
    const auto& ethHeader = makeShared<EthernetMacHeader>();
    auto macAddressReq = packet->getTag<MacAddressReq>();
    auto srcAddr = macAddressReq->getSrcAddress();
    if (srcAddr.isUnspecified() && networkInterface != nullptr)
        srcAddr = networkInterface->getMacAddress();
    ethHeader->setSrc(srcAddr);
    ethHeader->setDest(macAddressReq->getDestAddress());
    ethHeader->setTypeOrLength(typeOrLength);
    packet->insertAtFront(ethHeader);
    const auto& ethernetFcs = makeShared<EthernetFcs>();
    ethernetFcs->setFcsMode(fcsMode);
    packet->insertAtBack(ethernetFcs);
    protocolTag->setProtocol(&Protocol::ethernetMac);
    packet->removeTagIfPresent<DispatchProtocolReq>();
    EV_INFO << "Sending " << packet << " to lower layer.\n";
    send(packet, "lowerLayerOut");
}

Referenced by handleMessageWhenUp().

processPacketFromMac()

void inet::EthernetEncapsulation::processPacketFromMac ( Packet *  packet )

protectedvirtual

{
    const Protocol *payloadProtocol = nullptr;
 
    int iface = packet->getTag<InterfaceInd>()->getInterfaceId();
    auto ethHeader = packet->popAtFront<EthernetMacHeader>();
    packet->popAtBack<EthernetFcs>(ETHER_FCS_BYTES);
 
    // add MacAddressInd to packet
    auto macAddressInd = packet->addTagIfAbsent<MacAddressInd>();
    macAddressInd->setSrcAddress(ethHeader->getSrc());
    macAddressInd->setDestAddress(ethHeader->getDest());
 
    // remove Padding if possible
    if (isIeee8023Header(*ethHeader)) {
        b payloadLength = B(ethHeader->getTypeOrLength());
        if (packet->getDataLength() < payloadLength)
            throw cRuntimeError("incorrect payload length in ethernet frame");      // TODO alternative: drop packet
        packet->setBackOffset(packet->getFrontOffset() + payloadLength);
        payloadProtocol = &Protocol::ieee8022llc;
    }
    else if (isEth2Header(*ethHeader)) {
        payloadProtocol = ProtocolGroup::ethertype.findProtocol(ethHeader->getTypeOrLength());
    }
    else
        throw cRuntimeError("Unknown ethernet header");
 
    if (payloadProtocol != nullptr) {
        packet->addTagIfAbsent<PacketProtocolTag>()->setProtocol(payloadProtocol);
        packet->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(payloadProtocol);
    }
    else {
        packet->removeTagIfPresent<PacketProtocolTag>();
        packet->removeTagIfPresent<DispatchProtocolReq>();
    }
    bool steal = false;
    for (auto it : socketIdToSocketMap) {
        auto socket = it.second;
        if (socket->matches(packet, iface, ethHeader)) {
            auto packetCopy = packet->dup();
            packetCopy->setKind(SOCKET_I_DATA);
            packetCopy->addTagIfAbsent<SocketInd>()->setSocketId(it.first);
            EV_INFO << "Sending " << packetCopy << " to socket " << it.first << ".\n";
            send(packetCopy, "upperLayerOut");
            steal |= socket->steal;
        }
    }
    if (steal)
        delete packet;
    else if (anyUpperProtocols || (payloadProtocol != nullptr && contains(upperProtocols, payloadProtocol))) {
        EV_DETAIL << "Decapsulating frame `" << packet->getName() << "', passing up contained packet `"
                  << packet->getName() << "' to higher layer\n";
 
        totalFromMAC++;
        emit(decapPkSignal, packet);
 
        // pass up to higher layers.
        EV_INFO << "Sending " << packet << " to upper layer.\n";
        send(packet, "upperLayerOut");
    }
    else {
        EV_WARN << "Unknown protocol, dropping packet\n";
        PacketDropDetails details;
        details.setReason(NO_PROTOCOL_FOUND);
        emit(packetDroppedSignal, packet, &details);
        delete packet;
    }
}

Referenced by handleMessageWhenUp().

refreshDisplay()

void inet::EthernetEncapsulation::refreshDisplay ( ) const

overrideprotectedvirtual

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

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  o, const Socket &  t  )

friend

{
    o << "(id:" << t.socketId
      << ",interfaceId:" << t.interfaceId
      << ",local:" << t.localAddress
      << ",remote:" << t.remoteAddress
      << ",protocol" << (t.protocol ? t.protocol->getName() : "<null>")
      << ",steal:" << (t.steal ? "on" : "off")
      << ")";
    return o;
}

Member Data Documentation

anyUpperProtocols

bool inet::EthernetEncapsulation::anyUpperProtocols = false

protected

Referenced by handleRegisterAnyProtocol(), and processPacketFromMac().

decapPkSignal

simsignal_t inet::EthernetEncapsulation::decapPkSignal = registerSignal("decapPk")

staticprotected

Referenced by processPacketFromMac().

encapPkSignal

simsignal_t inet::EthernetEncapsulation::encapPkSignal = registerSignal("encapPk")

staticprotected

Referenced by processPacketFromHigherLayer().

fcsMode

FcsMode inet::EthernetEncapsulation::fcsMode = FCS_MODE_UNDEFINED

protected

Referenced by handleSendPause(), initialize(), and processPacketFromHigherLayer().

networkInterface

NetworkInterface* inet::EthernetEncapsulation::networkInterface = nullptr

protected

Referenced by initialize(), and processPacketFromHigherLayer().

pauseSentSignal

simsignal_t inet::EthernetEncapsulation::pauseSentSignal = registerSignal("pauseSent")

staticprotected

Referenced by handleSendPause().

seqNum

int inet::EthernetEncapsulation::seqNum

protected

Referenced by handleSendPause(), and initialize().

socketIdToSocketMap

std::map<int, Socket *> inet::EthernetEncapsulation::socketIdToSocketMap

protected

Referenced by clearSockets(), initialize(), processCommandFromHigherLayer(), processPacketFromMac(), and ~EthernetEncapsulation().

totalFromHigherLayer

long inet::EthernetEncapsulation::totalFromHigherLayer

protected

Referenced by initialize(), processPacketFromHigherLayer(), and refreshDisplay().

totalFromMAC

long inet::EthernetEncapsulation::totalFromMAC

protected

Referenced by initialize(), processPacketFromMac(), and refreshDisplay().

totalPauseSent

long inet::EthernetEncapsulation::totalPauseSent

protected

Referenced by handleSendPause(), and initialize().

upperProtocols

std::set<const Protocol *> inet::EthernetEncapsulation::upperProtocols

protected

Referenced by handleRegisterProtocol(), initialize(), and processPacketFromMac().

---

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

• EthernetEncapsulation.h
• EthernetEncapsulation.cc