inet::MacForwardingTable Class Reference

This module handles the mapping between interface IDs and MAC addresses. More...

#include <MacForwardingTable.h>

Inheritance diagram for inet::MacForwardingTable:

Classes
struct	AddressEntry
struct	MacCompare
struct	MulticastAddressEntry

Public Member Functions
virtual int	getUnicastAddressForwardingInterface (const MacAddress &address, unsigned int vid=0) const override
virtual void	setUnicastAddressForwardingInterface (int interfaceId, const MacAddress &address, unsigned int vid=0) override
virtual void	removeUnicastAddressForwardingInterface (int interfaceId, const MacAddress &address, unsigned int vid=0) override
virtual void	learnUnicastAddressForwardingInterface (int interfaceId, const MacAddress &address, unsigned int vid=0) override
virtual std::vector< int >	getMulticastAddressForwardingInterfaces (const MacAddress &address, unsigned int vid=0) const override
virtual void	addMulticastAddressForwardingInterface (int interfaceId, const MacAddress &address, unsigned int vid=0) override
virtual void	removeMulticastAddressForwardingInterface (int interfaceId, const MacAddress &address, unsigned int vid=0) override
virtual void	removeForwardingInterface (int interfaceId) override
virtual void	replaceForwardingInterface (int oldInterfaceId, int newInterfaceId) override
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< unsigned int, MacAddress >	ForwardingTableKey
typedef std::map< ForwardingTableKey, AddressEntry >	ForwardingTable
typedef std::map< ForwardingTableKey, MulticastAddressEntry >	MulticastForwardingTable
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleParameterChange (const char *name) override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenUp (cMessage *msg) override
virtual void	refreshDisplay () const override
virtual void	updateDisplayString () const
virtual const char *	resolveDirective (char directive) const override
virtual void	parseForwardingTableParameter ()
virtual void	printState ()
	Prints cached data. More...
virtual void	removeAgedEntriesFromAllVlans ()
	Remove aged entries from all VLANs. More...
virtual void	removeAgedEntriesIfNeeded ()
virtual void	readForwardingTable (const char *fileName)
	Pre-reads in entries for Address Table during initialization. More...
virtual void	initializeTable ()
	For lifecycle: initialize entries for the vlanForwardingTable by reading them from a file (if specified by a parameter) More...
virtual void	clearTable ()
	For lifecycle: clears all entries from the vlanForwardingTable. More...
virtual void	setAgingTime (simtime_t agingTime) override
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) 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::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const 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
simtime_t	agingTime
simtime_t	lastPurge
ForwardingTable	forwardingTable
MulticastForwardingTable	multicastForwardingTable
ModuleRefByPar< IInterfaceTable >	ifTable
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Friends
std::ostream &	operator<< (std::ostream &os, const AddressEntry &entry)
std::ostream &	operator<< (std::ostream &os, const MulticastAddressEntry &entry)
std::ostream &	operator<< (std::ostream &os, const ForwardingTableKey &key)

Detailed Description

This module handles the mapping between interface IDs and MAC addresses.

See the NED definition for details. NOTE that interfaceIds (interfaceId parameters) are actually the corresponding ID of the port interface. i.e. this is an interfaceId and NOT an index of the some kind in a gate vector.

Member Typedef Documentation

ForwardingTable

typedef std::map<ForwardingTableKey, AddressEntry> inet::MacForwardingTable::ForwardingTable

protected

ForwardingTableKey

typedef std::pair<unsigned int, MacAddress> inet::MacForwardingTable::ForwardingTableKey

protected

MulticastForwardingTable

typedef std::map<ForwardingTableKey, MulticastAddressEntry> inet::MacForwardingTable::MulticastForwardingTable

protected

Member Function Documentation

addMulticastAddressForwardingInterface()

void inet::MacForwardingTable::addMulticastAddressForwardingInterface ( int  interfaceId, const MacAddress &  address, unsigned int  vid = 0  )

overridevirtual

Implements inet::IMacForwardingTable.

{
    Enter_Method("addMulticastAddressForwardingInterface");
    ASSERT(address.isMulticast());
    ForwardingTableKey key(vid, address);
    auto it = multicastForwardingTable.find(key);
    if (it == multicastForwardingTable.end())
        multicastForwardingTable[key] = MulticastAddressEntry(vid, {interfaceId});
    else {
        if (contains(it->second.interfaceIds, interfaceId))
            throw cRuntimeError("Already contains interface");
        it->second.interfaceIds.push_back(interfaceId);
    }
}

Referenced by parseForwardingTableParameter().

clearTable()

void inet::MacForwardingTable::clearTable ( )

protectedvirtual

For lifecycle: clears all entries from the vlanForwardingTable.

{
    forwardingTable.clear();
    multicastForwardingTable.clear();
}

Referenced by handleParameterChange(), and initializeTable().

getMulticastAddressForwardingInterfaces()

std::vector< int > inet::MacForwardingTable::getMulticastAddressForwardingInterfaces ( const MacAddress &  address, unsigned int  vid = 0  ) const

overridevirtual

Implements inet::IMacForwardingTable.

{
    Enter_Method("getMulticastAddressForwardingInterfaces");
    ASSERT(address.isMulticast());
    ForwardingTableKey key(vid, address);
    auto it = multicastForwardingTable.find(key);
    if (it == multicastForwardingTable.end())
        return std::vector<int>();
    else
        return it->second.interfaceIds;
}

getUnicastAddressForwardingInterface()

int inet::MacForwardingTable::getUnicastAddressForwardingInterface ( const MacAddress &  address, unsigned int  vid = 0  ) const

overridevirtual

Implements inet::IMacForwardingTable.

{
    Enter_Method("getUnicastAddressForwardingInterface");
    ASSERT(!address.isMulticast());
    ForwardingTableKey key(vid, address);
    auto it = forwardingTable.find(key);
    if (it == forwardingTable.end())
        return -1;
    else if (it->second.insertionTime <= simTime() - agingTime) {
        EV_TRACE << "Ignoring aged entry: " << it->first << " --> " << it->second << "\n";
        return -1;
    }
    else
        return it->second.interfaceId;
}

handleCrashOperation()

virtual void inet::MacForwardingTable::handleCrashOperation ( LifecycleOperation *  operation )

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ clearTable(); }

handleMessage()

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

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

{
    throw cRuntimeError("This module doesn't process messages");
}

handleMessageWhenUp()

void inet::MacForwardingTable::handleMessageWhenUp ( cMessage *  msg )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    throw cRuntimeError("This module doesn't process messages");
}

handleParameterChange()

void inet::MacForwardingTable::handleParameterChange ( const char *  name )

overrideprotectedvirtual

{
    if (name != nullptr) {
        if (!strcmp(name, "forwardingTable")) {
            clearTable();
            parseForwardingTableParameter();
        }
    }
}

handleStartOperation()

virtual void inet::MacForwardingTable::handleStartOperation ( LifecycleOperation *  operation )

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ initializeTable(); }

handleStopOperation()

virtual void inet::MacForwardingTable::handleStopOperation ( LifecycleOperation *  operation )

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ clearTable(); }

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

{
    OperationalBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        agingTime = par("agingTime");
        lastPurge = SIMTIME_ZERO;
        ifTable.reference(this, "interfaceTableModule", true);
        WATCH_MAP(forwardingTable);
        WATCH_MAP(multicastForwardingTable);
    }
}

initializeTable()

void inet::MacForwardingTable::initializeTable ( )

protectedvirtual

For lifecycle: initialize entries for the vlanForwardingTable by reading them from a file (if specified by a parameter)

{
    clearTable();
    parseForwardingTableParameter();
 
    // Option to pre-read in Address Table. To turn it off, set forwardingTableFile to empty string
    const char *forwardingTableFile = par("forwardingTableFile");
    if (forwardingTableFile && *forwardingTableFile)
        readForwardingTable(forwardingTableFile);
}

isInitializeStage()

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

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == INITSTAGE_LINK_LAYER; }

isModuleStartStage()

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

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == ModuleStartOperation::STAGE_LINK_LAYER; }

isModuleStopStage()

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

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == ModuleStopOperation::STAGE_LINK_LAYER; }

learnUnicastAddressForwardingInterface()

void inet::MacForwardingTable::learnUnicastAddressForwardingInterface ( int  interfaceId, const MacAddress &  address, unsigned int  vid = 0  )

overridevirtual

Implements inet::IMacForwardingTable.

{
    Enter_Method("learnUnicastAddressForwardingInterface");
    ASSERT(!address.isMulticast());
    removeAgedEntriesIfNeeded();
    ForwardingTableKey key(vid, address);
    auto it = forwardingTable.find(key);
    if (it == forwardingTable.end()) {
        EV << "Adding entry" << EV_FIELD(address) << EV_FIELD(interfaceId) << EV_FIELD(vid) << EV_ENDL;
        forwardingTable[key] = AddressEntry(vid, interfaceId, simTime());
    }
    else if (it->second.insertionTime != SimTime::getMaxTime()) {
        EV << "Updating entry" << EV_FIELD(address) << EV_FIELD(interfaceId) << EV_FIELD(vid) << EV_ENDL;
        AddressEntry& entry = it->second;
        entry.interfaceId = interfaceId;
        entry.insertionTime = simTime();
    }
    else
        EV << "Ignoring manually configured entry" << EV_FIELD(address) << EV_FIELD(interfaceId) << EV_FIELD(vid) << EV_ENDL;
}

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

parseForwardingTableParameter()

void inet::MacForwardingTable::parseForwardingTableParameter ( )

protectedvirtual

{
    auto forwardingTable = check_and_cast<cValueArray *>(par("forwardingTable").objectValue());
    for (int i = 0; i < forwardingTable->size(); i++) {
        cValueMap *entry = check_and_cast<cValueMap *>(forwardingTable->get(i).objectValue());
        auto vlan = entry->containsKey("vlan") ? entry->get("vlan").intValue() : 0;
        auto macAddressString = entry->get("address").stringValue();
        L3Address l3Address;
        if (!L3AddressResolver().tryResolve(macAddressString, l3Address, L3AddressResolver::ADDR_MAC))
            throw cRuntimeError("Cannot resolve MAC address of '%s'", macAddressString);
        MacAddress macAddress = l3Address.toMac();
        auto interfaceName = entry->get("interface").stringValue();
        auto networkInterface = ifTable->findInterfaceByName(interfaceName);
        if (networkInterface == nullptr)
            throw cRuntimeError("Cannot find network interface '%s'", interfaceName);
        if (macAddress.isMulticast())
            addMulticastAddressForwardingInterface(networkInterface->getInterfaceId(), macAddress, vlan);
        else
            setUnicastAddressForwardingInterface(networkInterface->getInterfaceId(), macAddress, vlan);
    }
}

Referenced by handleParameterChange(), and initializeTable().

printState()

void inet::MacForwardingTable::printState ( )

protectedvirtual

Prints cached data.

{
    EV << endl << "MAC Address Table" << endl;
    EV << "VLAN ID    MAC    IfId    Inserted" << endl;
    for (auto& elem : forwardingTable)
        EV << elem.first.first << "   " << elem.first.second << "   " << elem.second.interfaceId << "   " << elem.second.insertionTime << endl;
}

readForwardingTable()

void inet::MacForwardingTable::readForwardingTable ( const char *  fileName )

protectedvirtual

Pre-reads in entries for Address Table during initialization.

{
    FILE *fp = fopen(fileName, "r");
    if (fp == nullptr)
        throw cRuntimeError("cannot open address table file `%s'", fileName);
 
    // parse address table file:
    char *line;
    for (int lineno = 0; (line = fgetline(fp)) != nullptr; delete[] line) {
        lineno++;
 
        // lines beginning with '#' are treated as comments
        if (line[0] == '#')
            continue;
 
        // scan in VLAN ID
        char *vlanIdStr = strtok(line, " \t");
        // scan in MAC address
        char *macAddressStr = strtok(nullptr, " \t");
        // scan in interface name
        char *interfaceName = strtok(nullptr, " \t");
 
        char *endptr = nullptr;
 
        // empty line or comment?
        if (!vlanIdStr || *vlanIdStr == '#')
            continue;
 
        // broken line?
        if (!vlanIdStr || !macAddressStr || !interfaceName)
            throw cRuntimeError("line %d invalid in address table file `%s'", lineno, fileName);
 
        // parse columns:
 
        // parse VLAN ID:
        unsigned int vlanId = strtol(vlanIdStr, &endptr, 10);
        if (!endptr || *endptr)
            throw cRuntimeError("error in line %d in address table file `%s': VLAN ID '%s' unresolved", lineno, fileName, vlanIdStr);
 
        // parse MAC address:
        L3Address addr;
        if (!L3AddressResolver().tryResolve(macAddressStr, addr, L3AddressResolver::ADDR_MAC))
            throw cRuntimeError("error in line %d in address table file `%s': MAC address '%s' unresolved", lineno, fileName, macAddressStr);
        MacAddress macAddress = addr.toMac();
 
        // parse interface:
        int interfaceId = -1;
        auto ie = ifTable->findInterfaceByName(interfaceName);
        if (ie == nullptr) {
            long int num = strtol(interfaceName, &endptr, 10);
            if (endptr && *endptr == '\0')
                ie = ifTable->findInterfaceById(num);
        }
        if (ie == nullptr)
            throw cRuntimeError("error in line %d in address table file `%s': interface '%s' not found", lineno, fileName, interfaceName);
        interfaceId = ie->getInterfaceId();
 
        // Create an entry with address and interfaceId and insert into table
        AddressEntry entry(vlanId, interfaceId, 0);
        ForwardingTableKey key(vlanId, macAddress);
        forwardingTable[key] = entry;
    }
    fclose(fp);
}

Referenced by initializeTable().

refreshDisplay()

void inet::MacForwardingTable::refreshDisplay ( ) const

overrideprotectedvirtual

{
    updateDisplayString();
}

removeAgedEntriesFromAllVlans()

void inet::MacForwardingTable::removeAgedEntriesFromAllVlans ( )

protectedvirtual

Remove aged entries from all VLANs.

{
    for (auto cur = forwardingTable.begin(); cur != forwardingTable.end();) {
        AddressEntry& entry = cur->second;
        if (entry.insertionTime <= simTime() - agingTime) {
            EV << "Removing aged entry from Address Table: "
               << cur->first.first << " " << cur->first.second << " --> interfaceId " << cur->second.interfaceId << "\n";
            cur = forwardingTable.erase(cur);
        }
        else
            ++cur;
    }
}

Referenced by removeAgedEntriesIfNeeded().

removeAgedEntriesIfNeeded()

void inet::MacForwardingTable::removeAgedEntriesIfNeeded ( )

protectedvirtual

{
    simtime_t now = simTime();
 
    if (now >= lastPurge + SimTime(1, SIMTIME_S))
        removeAgedEntriesFromAllVlans();
 
    lastPurge = simTime();
}

Referenced by learnUnicastAddressForwardingInterface().

removeForwardingInterface()

void inet::MacForwardingTable::removeForwardingInterface ( int  interfaceId )

overridevirtual

Implements inet::IMacForwardingTable.

{
    Enter_Method("removeForwardingInterface");
    for (auto cur = forwardingTable.begin(); cur != forwardingTable.end();) {
        if (cur->second.interfaceId == interfaceId)
            cur = forwardingTable.erase(cur);
        else
            ++cur;
    }
}

removeMulticastAddressForwardingInterface()

void inet::MacForwardingTable::removeMulticastAddressForwardingInterface ( int  interfaceId, const MacAddress &  address, unsigned int  vid = 0  )

overridevirtual

Implements inet::IMacForwardingTable.

{
    Enter_Method("removeMulticastAddressForwardingInterface");
    ASSERT(address.isMulticast());
    ForwardingTableKey key(vid, address);
    auto it = multicastForwardingTable.find(key);
    if (it == multicastForwardingTable.end())
        throw cRuntimeError("Cannot find entry");
    if (contains(it->second.interfaceIds, interfaceId))
        throw cRuntimeError("Cannot find interface");
    remove(it->second.interfaceIds, interfaceId);
}

removeUnicastAddressForwardingInterface()

void inet::MacForwardingTable::removeUnicastAddressForwardingInterface ( int  interfaceId, const MacAddress &  address, unsigned int  vid = 0  )

overridevirtual

Implements inet::IMacForwardingTable.

{
    Enter_Method("removeUnicastAddressForwardingInterface");
    ASSERT(!address.isMulticast());
    ForwardingTableKey key(vid, address);
    auto it = forwardingTable.find(key);
    if (it == forwardingTable.end())
        throw cRuntimeError("Cannot find entry");
    forwardingTable.erase(it);
}

replaceForwardingInterface()

void inet::MacForwardingTable::replaceForwardingInterface ( int  oldInterfaceId, int  newInterfaceId  )

overridevirtual

Implements inet::IMacForwardingTable.

{
    Enter_Method("replaceForwardingInterface");
    for (auto& elem : forwardingTable) {
        if (elem.second.interfaceId == oldInterfaceId)
            elem.second.interfaceId = newInterfaceId;
    }
}

resolveDirective()

const char * inet::MacForwardingTable::resolveDirective ( char  directive ) const

overrideprotectedvirtual

Implements inet::StringFormat::IDirectiveResolver.

{
    static std::string result;
    switch (directive) {
        case 'a':
            result = std::to_string(forwardingTable.size());
            break;
        case 'v':
            break;
        default:
            throw cRuntimeError("Unknown directive: %c", directive);
    }
    return result.c_str();
}

setAgingTime()

void inet::MacForwardingTable::setAgingTime ( simtime_t  agingTime )

overrideprotectedvirtual

Implements inet::IMacForwardingTable.

{
    this->agingTime = agingTime == -1 ? par("agingTime") : agingTime;
}

setUnicastAddressForwardingInterface()

void inet::MacForwardingTable::setUnicastAddressForwardingInterface ( int  interfaceId, const MacAddress &  address, unsigned int  vid = 0  )

overridevirtual

Implements inet::IMacForwardingTable.

{
    Enter_Method("setUnicastAddressForwardingInterface");
    ASSERT(!address.isMulticast());
    ForwardingTableKey key(vid, address);
    auto it = forwardingTable.find(key);
    if (it == forwardingTable.end())
        forwardingTable[key] = AddressEntry(vid, interfaceId, -1);
    else {
        it->second.interfaceId = interfaceId;
        it->second.insertionTime = SimTime::getMaxTime();
    }
}

Referenced by parseForwardingTableParameter().

updateDisplayString()

void inet::MacForwardingTable::updateDisplayString ( ) const

protectedvirtual

{
    if (getEnvir()->isGUI()) {
        auto text = StringFormat::formatString(par("displayStringTextFormat"), this);
        getDisplayString().setTagArg("t", 0, text);
    }
}

Referenced by refreshDisplay().

Friends And Related Function Documentation

operator<< [1/3]

std::ostream& operator<< ( std::ostream &  os, const AddressEntry &  entry  )

friend

{
    return os << "{interfaceId=" << entry.interfaceId << ", insertionTime=" << entry.insertionTime << "}";
}

operator<< [2/3]

std::ostream& operator<< ( std::ostream &  os, const ForwardingTableKey &  key  )

friend

{
    return os << "{VID=" << key.first << ", addr=" << key.second << "}";
}

operator<< [3/3]

std::ostream& operator<< ( std::ostream &  os, const MulticastAddressEntry &  entry  )

friend

{
    return os << "{interfaceIds=" << entry.interfaceIds << "}";
}

Member Data Documentation

agingTime

simtime_t inet::MacForwardingTable::agingTime

protected

Referenced by getUnicastAddressForwardingInterface(), initialize(), removeAgedEntriesFromAllVlans(), and setAgingTime().

forwardingTable

ForwardingTable inet::MacForwardingTable::forwardingTable

protected

Referenced by clearTable(), getUnicastAddressForwardingInterface(), initialize(), learnUnicastAddressForwardingInterface(), parseForwardingTableParameter(), printState(), readForwardingTable(), removeAgedEntriesFromAllVlans(), removeForwardingInterface(), removeUnicastAddressForwardingInterface(), replaceForwardingInterface(), resolveDirective(), and setUnicastAddressForwardingInterface().

ifTable

ModuleRefByPar<IInterfaceTable> inet::MacForwardingTable::ifTable

protected

Referenced by initialize(), parseForwardingTableParameter(), and readForwardingTable().

lastPurge

simtime_t inet::MacForwardingTable::lastPurge

protected

Referenced by initialize(), and removeAgedEntriesIfNeeded().

multicastForwardingTable

MulticastForwardingTable inet::MacForwardingTable::multicastForwardingTable

protected

Referenced by addMulticastAddressForwardingInterface(), clearTable(), getMulticastAddressForwardingInterfaces(), initialize(), and removeMulticastAddressForwardingInterface().

---

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

• MacForwardingTable.h
• MacForwardingTable.cc