inet::Ieee8021dRelay Class Reference

#include <Ieee8021dRelay.h>

Inheritance diagram for inet::Ieee8021dRelay:

Classes
struct	Comp

Public Member Functions
void	registerAddress (MacAddress mac)
	Register single MAC address that this switch supports. More...
void	registerAddresses (MacAddress startMac, MacAddress endMac)
	Register range of MAC addresses that this switch supports. More...
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Types
typedef std::pair< MacAddress, MacAddress >	MacAddressPair
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Protected Member Functions
bool	in_range (const std::set< MacAddressPair, Comp > &ranges, MacAddress value)
virtual void	initialize (int stage) override
virtual void	finish () override
virtual void	handleUpperPacket (Packet *packet) override
virtual void	handleLowerPacket (Packet *packet) override
virtual void	updatePeerAddress (NetworkInterface *incomingInterface, MacAddress sourceAddress, unsigned int vlanId) override
virtual void	sendUp (Packet *packet)
virtual bool	isForwardingInterface (NetworkInterface *networkInterface) const override
virtual NetworkInterface *	chooseBridgeInterface ()
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
Protected Member Functions inherited from inet::MacRelayUnitBase
virtual void	updateDisplayString () const
virtual const char *	resolveDirective (char directive) const override
virtual void	broadcastPacket (Packet *packet, const MacAddress &destinationAddress, NetworkInterface *incomingInterface)
virtual void	sendPacket (Packet *packet, const MacAddress &destinationAddress, NetworkInterface *outgoingInterface)
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)
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
MacAddress	bridgeAddress
NetworkInterface *	bridgeNetworkInterface = nullptr
std::set< MacAddressPair, Comp >	registeredMacAddresses
int	numReceivedNetworkFrames = 0
int	numReceivedBPDUsFromSTP = 0
int	numDeliveredBDPUsToSTP = 0
int	numDispatchedNonBPDUFrames = 0
int	numDispatchedBDPUFrames = 0
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 Typedef Documentation

MacAddressPair

typedef std::pair<MacAddress, MacAddress> inet::Ieee8021dRelay::MacAddressPair

protected

Member Function Documentation

chooseBridgeInterface()

NetworkInterface * inet::Ieee8021dRelay::chooseBridgeInterface ( )

protectedvirtual

{
    for (int i = 0; i < interfaceTable->getNumInterfaces(); i++) {
        NetworkInterface *interface = interfaceTable->getInterface(i);
        if (!interface->isLoopback())
            return interface;
    }
    return nullptr;
}

Referenced by handleStartOperation().

finish()

void inet::Ieee8021dRelay::finish ( )

overrideprotectedvirtual

Reimplemented from inet::MacRelayUnitBase.

{
    MacRelayUnitBase::finish();
    recordScalar("number of received BPDUs from STP module", numReceivedBPDUsFromSTP);
    recordScalar("number of received frames from network (including BPDUs)", numReceivedNetworkFrames);
    recordScalar("number of dropped frames (including BPDUs)", numDroppedFrames);
    recordScalar("number of delivered BPDUs to the STP module", numDeliveredBDPUsToSTP);
    recordScalar("number of dispatched BPDU frames to the network", numDispatchedBDPUFrames);
    recordScalar("number of dispatched non-BDPU frames to the network", numDispatchedNonBPDUFrames);
}

handleCrashOperation()

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

overrideprotectedvirtual

Reimplemented from inet::MacRelayUnitBase.

{
    bridgeNetworkInterface = nullptr;
}

handleLowerPacket()

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

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

{
    numReceivedNetworkFrames++;
    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);
 
    const auto& incomingInterfaceData = incomingInterface->findProtocolData<Ieee8021dInterfaceData>();
    // BPDU Handling
    if ((!incomingInterfaceData || incomingInterfaceData->getRole() != Ieee8021dInterfaceData::DISABLED)
            && (destinationAddress == bridgeAddress
                || in_range(registeredMacAddresses, destinationAddress)
                || incomingInterface->matchesMacAddress(destinationAddress))
            && !destinationAddress.isBroadcast())
    {
        EV_DETAIL << "Deliver to upper layer" << endl;
        sendUp(incomingPacket); // deliver to the STP/RSTP module
    }
    else if (incomingInterfaceData && !incomingInterfaceData->isForwarding()) {
        EV_INFO << "Dropping packet because the incoming interface is currently not forwarding" << EV_FIELD(incomingInterface) << EV_FIELD(incomingPacket) << endl;
        numDroppedFrames++;
        PacketDropDetails details;
        details.setReason(NO_INTERFACE_FOUND);
        emit(packetDroppedSignal, incomingPacket, &details);
        delete incomingPacket;
    }
    else {
        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);
 
        // TODO revise next "if"s: 2nd drops all packets for me if not forwarding port; 3rd sends up when dest==STP_MULTICAST_ADDRESS; etc.
        // reordering, merge 1st and 3rd, ...
 
        if (destinationAddress.isBroadcast())
            broadcastPacket(outgoingPacket, destinationAddress, incomingInterface);
        else if (destinationAddress.isMulticast()) {
            auto outgoingInterfaceIds = macForwardingTable->getMulticastAddressForwardingInterfaces(destinationAddress);
            if (outgoingInterfaceIds.size() == 0)
                broadcastPacket(outgoingPacket, destinationAddress, incomingInterface);
            else {
                for (auto outgoingInterfaceId : outgoingInterfaceIds) {
                    auto outgoingInterface = interfaceTable->getInterfaceById(outgoingInterfaceId);
                    if (outgoingInterfaceId != incomingInterfaceId) {
                        if (isForwardingInterface(outgoingInterface))
                            sendPacket(outgoingPacket->dup(), destinationAddress, outgoingInterface);
                        else {
                            EV_WARN << "Discarding packet because output interface is currently not forwarding" << EV_FIELD(outgoingInterface) << EV_FIELD(outgoingPacket) << endl;
                            numDroppedFrames++;
                            PacketDropDetails details;
                            details.setReason(NO_INTERFACE_FOUND);
                            emit(packetDroppedSignal, outgoingPacket, &details);
                        }
                    }
                    else {
                        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 {
            auto outgoingInterfaceId = macForwardingTable->getUnicastAddressForwardingInterface(destinationAddress);
            if (outgoingInterfaceId == -1)
                broadcastPacket(outgoingPacket, destinationAddress, incomingInterface);
            else {
                auto outgoingInterface = interfaceTable->getInterfaceById(outgoingInterfaceId);
                if (outgoingInterfaceId != incomingInterfaceId) {
                    if (isForwardingInterface(outgoingInterface))
                        sendPacket(outgoingPacket->dup(), destinationAddress, outgoingInterface);
                    else {
                        EV_WARN << "Discarding packet because output interface is currently not forwarding" << EV_FIELD(outgoingInterface) << EV_FIELD(outgoingPacket) << endl;
                        numDroppedFrames++;
                        PacketDropDetails details;
                        details.setReason(NO_INTERFACE_FOUND);
                        emit(packetDroppedSignal, outgoingPacket, &details);
                    }
                }
                else {
                    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;
            }
        }
        delete incomingPacket;
    }
    updateDisplayString();
}

handleStartOperation()

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

overrideprotectedvirtual

Reimplemented from inet::MacRelayUnitBase.

{
    bridgeNetworkInterface = chooseBridgeInterface();
    if (bridgeNetworkInterface) {
        bridgeAddress = bridgeNetworkInterface->getMacAddress(); // get the bridge's MAC address
        registerAddress(bridgeAddress); // register bridge's MAC address
    }
    else
        throw cRuntimeError("No non-loopback interface found!");
}

handleStopOperation()

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

overrideprotectedvirtual

Reimplemented from inet::MacRelayUnitBase.

{
    bridgeNetworkInterface = nullptr;
}

handleUpperPacket()

void inet::Ieee8021dRelay::handleUpperPacket ( Packet *  packet )

overrideprotectedvirtual

Reimplemented from inet::LayeredProtocolBase.

{
    EV_INFO << "Processing upper packet" << EV_FIELD(packet) << EV_ENDL;
    auto macAddressReq = packet->getTag<MacAddressReq>();
    auto destinationAddress = macAddressReq->getDestAddress();
    auto interfaceReq = packet->findTag<InterfaceReq>();
    if (interfaceReq != nullptr) {
        auto networkInterface = interfaceTable->getInterfaceById(interfaceReq->getInterfaceId());
        sendPacket(packet, destinationAddress, networkInterface);
    }
    else if (destinationAddress.isBroadcast())
        broadcastPacket(packet, destinationAddress, nullptr);
    else if (destinationAddress.isMulticast()) {
        auto outgoingInterfaceIds = macForwardingTable->getMulticastAddressForwardingInterfaces(destinationAddress);
        if (outgoingInterfaceIds.size() == 0)
            broadcastPacket(packet, destinationAddress, nullptr);
        else {
            for (auto outgoingInterfaceId : outgoingInterfaceIds) {
                auto outgoingInterface = interfaceTable->getInterfaceById(outgoingInterfaceId);
                sendPacket(packet->dup(), destinationAddress, outgoingInterface);
            }
            delete packet;
        }
    }
    else {
        int interfaceId = macForwardingTable->getUnicastAddressForwardingInterface(destinationAddress);
        if (interfaceId == -1)
            broadcastPacket(packet, destinationAddress, nullptr);
        else {
            auto networkInterface = interfaceTable->getInterfaceById(interfaceId);
            sendPacket(packet, destinationAddress, networkInterface);
        }
    }
}

in_range()

bool inet::Ieee8021dRelay::in_range ( const std::set< MacAddressPair, Comp > &  ranges, MacAddress  value  )

inlineprotected

    {
        return contains(ranges, MacAddressPair(value, value));
    }

Referenced by handleLowerPacket().

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::MacRelayUnitBase.

{
    MacRelayUnitBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        numDispatchedBDPUFrames = numDispatchedNonBPDUFrames = numDeliveredBDPUsToSTP = 0;
        numReceivedBPDUsFromSTP = numReceivedNetworkFrames = 0;
 
        WATCH(bridgeAddress);
        WATCH(numReceivedNetworkFrames);
        WATCH(numReceivedBPDUsFromSTP);
        WATCH(numDeliveredBDPUsToSTP);
        WATCH(numDispatchedNonBPDUFrames);
    }
    else if (stage == INITSTAGE_LINK_LAYER) {
        registerService(Protocol::ethernetMac, gate("upperLayerIn"), gate("upperLayerOut"));
    }
}

isForwardingInterface()

bool inet::Ieee8021dRelay::isForwardingInterface ( NetworkInterface *  networkInterface ) const

overrideprotectedvirtual

Reimplemented from inet::MacRelayUnitBase.

{
    if (!MacRelayUnitBase::isForwardingInterface(networkInterface))
        return false;
    const auto& interfaceData = networkInterface->findProtocolData<Ieee8021dInterfaceData>();
    return (interfaceData == nullptr || interfaceData->isForwarding());
}

Referenced by handleLowerPacket().

registerAddress()

void inet::Ieee8021dRelay::registerAddress

(

MacAddress

mac

)

Register single MAC address that this switch supports.

{
    registerAddresses(mac, mac);
}

Referenced by handleStartOperation().

registerAddresses()

void inet::Ieee8021dRelay::registerAddresses	(	MacAddress	startMac,
		MacAddress	endMac
	)

Register range of MAC addresses that this switch supports.

{
    registeredMacAddresses.insert(MacAddressPair(startMac, endMac));
}

Referenced by registerAddress().

sendUp()

void inet::Ieee8021dRelay::sendUp ( Packet *  packet )

protectedvirtual

{
    EV_INFO << "Sending frame to the upper layer" << EV_FIELD(packet) << EV_ENDL;
    send(packet, "upperLayerOut");
}

Referenced by handleLowerPacket().

updatePeerAddress()

void inet::Ieee8021dRelay::updatePeerAddress ( NetworkInterface *  incomingInterface, MacAddress  sourceAddress, unsigned int  vlanId  )

overrideprotectedvirtual

Reimplemented from inet::MacRelayUnitBase.

{
    const auto& interfaceData = incomingInterface->findProtocolData<Ieee8021dInterfaceData>();
    if (interfaceData == nullptr || interfaceData->isLearning())
        MacRelayUnitBase::updatePeerAddress(incomingInterface, sourceAddress, vlanId);
}

Referenced by handleLowerPacket().

Member Data Documentation

bridgeAddress

MacAddress inet::Ieee8021dRelay::bridgeAddress

protected

Referenced by handleLowerPacket(), handleStartOperation(), and initialize().

bridgeNetworkInterface

NetworkInterface* inet::Ieee8021dRelay::bridgeNetworkInterface = nullptr

protected

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

numDeliveredBDPUsToSTP

int inet::Ieee8021dRelay::numDeliveredBDPUsToSTP = 0

protected

Referenced by finish(), and initialize().

numDispatchedBDPUFrames

int inet::Ieee8021dRelay::numDispatchedBDPUFrames = 0

protected

Referenced by finish(), and initialize().

numDispatchedNonBPDUFrames

int inet::Ieee8021dRelay::numDispatchedNonBPDUFrames = 0

protected

Referenced by finish(), and initialize().

numReceivedBPDUsFromSTP

int inet::Ieee8021dRelay::numReceivedBPDUsFromSTP = 0

protected

Referenced by finish(), and initialize().

numReceivedNetworkFrames

int inet::Ieee8021dRelay::numReceivedNetworkFrames = 0

protected

Referenced by finish(), handleLowerPacket(), and initialize().

registeredMacAddresses

std::set<MacAddressPair, Comp> inet::Ieee8021dRelay::registeredMacAddresses

protected

Referenced by handleLowerPacket(), and registerAddresses().

---

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

• Ieee8021dRelay.h
• Ieee8021dRelay.cc