inet::MacRelayUnit Class Reference

#include <MacRelayUnit.h>

Inheritance diagram for inet::MacRelayUnit:

Protected Member Functions
virtual void	handleLowerPacket (Packet *packet) override
Protected Member Functions inherited from inet::MacRelayUnitBase
virtual void	initialize (int stage) override
virtual void	finish () override
virtual void	updateDisplayString () const
virtual const char *	resolveDirective (char directive) const override
virtual bool	isForwardingInterface (NetworkInterface *networkInterface) const
virtual void	broadcastPacket (Packet *packet, const MacAddress &destinationAddress, NetworkInterface *incomingInterface)
virtual void	sendPacket (Packet *packet, const MacAddress &destinationAddress, NetworkInterface *outgoingInterface)
virtual void	updatePeerAddress (NetworkInterface *incomingInterface, MacAddress sourceAddress, unsigned int vlanId)
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
virtual bool	isUpperMessage (cMessage *message) const override
virtual bool	isLowerMessage (cMessage *message) const override
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
Protected Member Functions inherited from inet::LayeredProtocolBase
virtual void	handleMessageWhenUp (cMessage *message) override
virtual void	handleSelfMessage (cMessage *message)
virtual void	handleUpperMessage (cMessage *message)
virtual void	handleLowerMessage (cMessage *message)
virtual void	handleUpperCommand (cMessage *message)
virtual void	handleLowerCommand (cMessage *message)
virtual void	handleUpperPacket (Packet *packet)
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 ()

Additional Inherited Members
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State
Protected Attributes inherited from inet::MacRelayUnitBase
ModuleRefByPar< IInterfaceTable >	interfaceTable
ModuleRefByPar< IMacForwardingTable >	macForwardingTable
long	numProcessedFrames = 0
long	numDroppedFrames = 0
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Member Function Documentation

handleLowerPacket()

void inet::MacRelayUnit::handleLowerPacket ( Packet *  packet )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

{
    auto protocol = incomingPacket->getTag<PacketProtocolTag>()->getProtocol();
    auto macAddressInd = incomingPacket->getTag<MacAddressInd>();
    auto sourceAddress = macAddressInd->getSrcAddress();
    auto destinationAddress = macAddressInd->getDestAddress();
    auto interfaceInd = incomingPacket->getTag<InterfaceInd>();
    int incomingInterfaceId = interfaceInd->getInterfaceId();
    auto incomingInterface = interfaceTable->getInterfaceById(incomingInterfaceId);
    unsigned int vlanId = 0;
    if (auto vlanInd = incomingPacket->findTag<VlanInd>())
        vlanId = vlanInd->getVlanId();
    EV_INFO << "Processing packet from network" << EV_FIELD(incomingInterface) << EV_FIELD(incomingPacket) << EV_ENDL;
    updatePeerAddress(incomingInterface, sourceAddress, vlanId);
 
    auto outgoingPacket = incomingPacket->dup();
    outgoingPacket->trim();
    outgoingPacket->clearTags();
    outgoingPacket->addTag<PacketProtocolTag>()->setProtocol(protocol);
    if (auto vlanInd = incomingPacket->findTag<VlanInd>())
        outgoingPacket->addTag<VlanReq>()->setVlanId(vlanInd->getVlanId());
    if (auto userPriorityInd = incomingPacket->findTag<UserPriorityInd>())
        outgoingPacket->addTag<UserPriorityReq>()->setUserPriority(userPriorityInd->getUserPriority());
    auto& macAddressReq = outgoingPacket->addTag<MacAddressReq>();
    macAddressReq->setSrcAddress(sourceAddress);
    macAddressReq->setDestAddress(destinationAddress);
    if (destinationAddress.isBroadcast())
        broadcastPacket(outgoingPacket, destinationAddress, incomingInterface);
    else if (destinationAddress.isMulticast()) {
        auto outgoingInterfaceIds = macForwardingTable->getMulticastAddressForwardingInterfaces(destinationAddress, vlanId);
        if (outgoingInterfaceIds.size() == 0)
            broadcastPacket(incomingPacket, destinationAddress, incomingInterface);
        else {
            for (auto outgoingInterfaceId : outgoingInterfaceIds) {
                if (interfaceInd != nullptr && outgoingInterfaceId == interfaceInd->getInterfaceId())
                    EV_WARN << "Ignoring outgoing interface because it is the same as incoming interface" << EV_FIELD(destinationAddress) << EV_FIELD(incomingInterface) << EV_FIELD(incomingPacket) << EV_ENDL;
                else {
                    auto outgoingInterface = interfaceTable->getInterfaceById(outgoingInterfaceId);
                    sendPacket(incomingPacket->dup(), destinationAddress, outgoingInterface);
                }
            }
            delete incomingPacket;
        }
    }
    else {
        // Find output interface of destination address and send packet to output interface
        // if not found then broadcasts to all other interfaces instead
        int outgoingInterfaceId = macForwardingTable->getUnicastAddressForwardingInterface(destinationAddress);
        // should not send out the same packet on the same interface
        // (although wireless interfaces are ok to receive the same message)
        if (incomingInterfaceId == outgoingInterfaceId) {
            EV_WARN << "Discarding packet because outgoing interface is the same as incoming interface" << EV_FIELD(destinationAddress) << EV_FIELD(incomingInterface) << EV_FIELD(incomingPacket) << EV_ENDL;
            numDroppedFrames++;
            PacketDropDetails details;
            details.setReason(NO_INTERFACE_FOUND);
            emit(packetDroppedSignal, outgoingPacket, &details);
            delete outgoingPacket;
        }
        else if (outgoingInterfaceId != -1) {
            auto outgoingInterface = interfaceTable->getInterfaceById(outgoingInterfaceId);
            sendPacket(outgoingPacket, destinationAddress, outgoingInterface);
        }
        else
            broadcastPacket(outgoingPacket, destinationAddress, incomingInterface);
    }
    numProcessedFrames++;
    updateDisplayString();
    delete incomingPacket;
}

---

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

• MacRelayUnit.h
• MacRelayUnit.cc