inet::InterfaceTable Class Reference

Represents the interface table. More...

#include <InterfaceTable.h>

Inheritance diagram for inet::InterfaceTable:

Public Member Functions
	InterfaceTable ()
virtual	~InterfaceTable ()
virtual std::string	getFullPath () const override
	Module path name. More...
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
	Called by the signal handler whenever a change of a category occurs to which this client has subscribed. More...
virtual cModule *	getHostModule () const override
	Returns the host or router this interface table lives in. More...
virtual bool	isLocalAddress (const L3Address &address) const override
	Checks if the address is a local one, i.e. More...
virtual bool	isNeighborAddress (const L3Address &address) const override
	Checks if the address is on the network of one of the interfaces, but not local. More...
virtual NetworkInterface *	findInterfaceByAddress (const L3Address &address) const override
	Returns an interface given by its address. More...
virtual void	addInterface (NetworkInterface *entry) override
	Adds an interface. More...
virtual void	deleteInterface (NetworkInterface *entry) override
	Deletes the given interface from the table. More...
virtual int	getNumInterfaces () const override
	Returns the number of interfaces. More...
virtual NetworkInterface *	getInterface (int pos) const override
	Returns the NetworkInterface specified by an index 0..numInterfaces-1. More...
virtual NetworkInterface *	findInterfaceById (int id) const override
	Returns an interface by its Id. More...
virtual NetworkInterface *	getInterfaceById (int id) const override
	Returns an interface by its Id. More...
virtual int	getBiggestInterfaceId () const override
	Returns the biggest interface Id. More...
virtual NetworkInterface *	findInterfaceByNodeOutputGateId (int id) const override
	Returns an interface given by its getNodeOutputGateId(). More...
virtual NetworkInterface *	findInterfaceByNodeInputGateId (int id) const override
	Returns an interface given by its getNodeInputGateId(). More...
virtual NetworkInterface *	findInterfaceByInterfaceModule (cModule *ifmod) const override
	Returns an interface by one of its component module (e.g. More...
virtual NetworkInterface *	findInterfaceByName (const char *name) const override
	Returns an interface given by its name. More...
virtual NetworkInterface *	findFirstLoopbackInterface () const override
	Returns the first interface with the isLoopback flag set. More...
virtual NetworkInterface *	findFirstNonLoopbackInterface () const override
	Returns the first interface with the isLoopback flag unset. More...
virtual NetworkInterface *	findFirstMulticastInterface () const override
	Returns the first multicast capable interface. More...
virtual bool	isInitializeStage (int stage) const override
	Lifecycle method. More...
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
virtual MulticastGroupList	collectMulticastGroups () const override
	Returns all multicast group address, with it's interfaceId. More...
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::IInterfaceTable
virtual	~IInterfaceTable ()

Protected Types
typedef std::vector< NetworkInterface * >	InterfaceVector
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Protected Member Functions
virtual void	refreshDisplay () const override
virtual void	updateLinkDisplayString (NetworkInterface *entry) const
virtual void	discoverConnectingGates (NetworkInterface *entry)
virtual void	interfaceChanged (simsignal_t signalID, const NetworkInterfaceChangeDetails *details) override
virtual void	invalidateTmpInterfaceList ()
virtual void	resetInterfaces ()
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessageWhenUp (cMessage *) override
	Raises an error. More...
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
cModule *	host
InterfaceVector	idToInterface
int	tmpNumInterfaces
NetworkInterface **	tmpInterfaceList
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Detailed Description

Represents the interface table.

This object has one instance per host or router. It has methods to manage the interface table, so one can access functionality similar to the "ifconfig" command.

See the NED documentation for general overview.

This is a simple module without gates, it requires function calls to it (message handling does nothing). Methods are provided for reading and updating the interface table.

Interfaces are dynamically registered: at the start of the simulation, every L2 module adds its own NetworkInterface to the table; after that, Ipv4's IIpv4RoutingTable and Ipv6's Ipv6RoutingTable (an possibly, further L3 protocols) add protocol-specific data on each NetworkInterface (see Ipv4InterfaceData, Ipv6InterfaceData, and NetworkInterface::setIPv4Data(), NetworkInterface::setIPv6Data())

Interfaces are represented by NetworkInterface objects.

When interfaces need to be reliably and efficiently identified from other modules, interfaceIds should be used. They are better suited than pointers because when an interface gets removed (see deleteInterface()), it is often impossible/impractical to invalidate all pointers to it, and also because pointers are not necessarily unique (a new NetworkInterface may get allocated exactly at the address of a previously deleted one). Interface Ids are unique (Ids of removed interfaces are not issued again), stale Ids can be detected, and they are also invariant to insertion/deletion.

Clients can get notified about interface changes by subscribing to the following signals on host module: interfaceCreatedSignal, interfaceDeletedSignal, interfaceStateChangedSignal, interfaceConfigChangedSignal. State change gets fired for up/down events; all other changes fire as config change.

See also

NetworkInterface

Member Typedef Documentation

InterfaceVector

typedef std::vector<NetworkInterface *> inet::InterfaceTable::InterfaceVector

protected

Constructor & Destructor Documentation

InterfaceTable()

inet::InterfaceTable::InterfaceTable

(

)

{
    host = nullptr;
    tmpNumInterfaces = -1;
    tmpInterfaceList = nullptr;
}

~InterfaceTable()

inet::InterfaceTable::~InterfaceTable ( )

virtual

{
    delete[] tmpInterfaceList;
}

Member Function Documentation

addInterface()

void inet::InterfaceTable::addInterface ( NetworkInterface *  entry )

overridevirtual

Adds an interface.

The entry->getInterfaceModule() will be used to discover and fill in getNetworkLayerGateIndex(), getNodeOutputGateId(), and getNodeInputGateId() in NetworkInterface. It should be nullptr if this is a virtual interface (e.g. loopback).

Implements inet::IInterfaceTable.

{
    if (!host)
        throw cRuntimeError("InterfaceTable must precede all network interface modules in the node's NED definition");
    // check name is unique
    if (findInterfaceByName(entry->getInterfaceName()) != nullptr)
        throw cRuntimeError("addInterface(): interface '%s' already registered", entry->getInterfaceName());
 
    // insert
    entry->setInterfaceId(INTERFACEIDS_START + idToInterface.size());
    idToInterface.push_back(entry);
    invalidateTmpInterfaceList();
 
    // fill in networkLayerGateIndex, nodeOutputGateId, nodeInputGateId
    discoverConnectingGates(entry);
 
    emit(interfaceCreatedSignal, entry);
}

collectMulticastGroups()

MulticastGroupList inet::InterfaceTable::collectMulticastGroups ( ) const

overridevirtual

Returns all multicast group address, with it's interfaceId.

Implements inet::IInterfaceTable.

{
    MulticastGroupList mglist;
    for (int i = 0; i < getNumInterfaces(); ++i) {
#ifdef INET_WITH_IPv4
        NetworkInterface *ie = getInterface(i);
        int interfaceId = ie->getInterfaceId();
        auto ipv4Data = ie->findProtocolData<Ipv4InterfaceData>();
        if (ipv4Data) {
            int numOfMulticastGroups = ipv4Data->getNumOfJoinedMulticastGroups();
            for (int j = 0; j < numOfMulticastGroups; ++j) {
                mglist.push_back(MulticastGroup(ipv4Data->getJoinedMulticastGroup(j), interfaceId));
            }
        }
#endif // ifdef INET_WITH_IPv4
#ifdef INET_WITH_IPv6
        // TODO
#endif // ifdef INET_WITH_IPv6
    }
    return mglist;
}

deleteInterface()

void inet::InterfaceTable::deleteInterface ( NetworkInterface *  entry )

overridevirtual

Deletes the given interface from the table.

Indices of existing interfaces (see getInterface(int)) may change. It is an error if the given interface is not in the table.

Implements inet::IInterfaceTable.

{
    int id = entry->getInterfaceId();
    if (entry != getInterfaceById(id))
        throw cRuntimeError("deleteInterface(): interface '%s' not found in interface table", entry->getInterfaceName());
 
    emit(interfaceDeletedSignal, entry); // actually, only going to be deleted
 
    idToInterface[id - INTERFACEIDS_START] = nullptr;
    delete entry;
    invalidateTmpInterfaceList();
}

discoverConnectingGates()

void inet::InterfaceTable::discoverConnectingGates ( NetworkInterface *  entry )

protectedvirtual

{
    cModule *ifmod = entry;
    if (!ifmod)
        return; // virtual interface
 
    // ifmod is something like "host.eth[1].mac"; climb up to find "host.eth[1]" from it
    ASSERT(host != nullptr);
    while (ifmod && ifmod->getParentModule() != host)
        ifmod = ifmod->getParentModule();
    if (!ifmod)
        throw cRuntimeError("addInterface(): specified module (%s) is not in this host/router '%s'", entry->getInterfaceFullPath().c_str(), this->getFullPath().c_str());
 
    // ASSUMPTIONS:
    // 1. The NIC module (ifmod) may or may not be connected to a network layer module (e.g. Ipv4NetworkLayer or Mpls)
    // 2. If it *is* connected to a network layer, the network layer module's gates must be called
    //    ifIn[] and ifOut[], and NIC must be connected to identical gate indices in both vectors.
    // 3. If the NIC module is not connected to another modules ifIn[] and ifOut[] gates, we assume
    //    that it is NOT connected to a network layer, and leave networkLayerGateIndex
    //    in NetworkInterface unfilled.
    // 4. The NIC may or may not connect to gates of the containing host compound module.
    //
 
    // find gates connected to host / network layer
    cGate *nwlayerInGate = nullptr, *nwlayerOutGate = nullptr; // ifIn[] and ifOut[] gates in the network layer
    for (GateIterator i(ifmod); !i.end(); i++) {
        cGate *g = *i;
        if (!g)
            continue;
 
        // find the host/router's gates that internally connect to this interface
        if (g->getType() == cGate::OUTPUT && g->getNextGate() && g->getNextGate()->getOwnerModule() == host)
            entry->setNodeOutputGateId(g->getNextGate()->getId());
        if (g->getType() == cGate::INPUT && g->getPreviousGate() && g->getPreviousGate()->getOwnerModule() == host)
            entry->setNodeInputGateId(g->getPreviousGate()->getId());
 
        // TODO revise next code:
        // find the gate index of networkLayer/networkLayer6/mpls that connects to this interface
        if (g->getType() == cGate::OUTPUT && g->getNextGate() && g->getNextGate()->isName("ifIn")) // connected to ifIn in networkLayer?
            nwlayerInGate = g->getNextGate();
        if (g->getType() == cGate::INPUT && g->getPreviousGate() && g->getPreviousGate()->isName("ifOut")) // connected to ifOut in networkLayer?
            nwlayerOutGate = g->getPreviousGate();
    }
 
    // consistency checks and setting networkLayerGateIndex:
 
    // note: we don't check nodeOutputGateId/nodeInputGateId, because wireless interfaces
    // are not connected to the host
 
    // TODO revise next code:
    if (nwlayerInGate || nwlayerOutGate) { // connected to a network layer (i.e. to another module's ifIn/ifOut gates)
        if (!nwlayerInGate || !nwlayerOutGate)
            throw cRuntimeError("addInterface(): interface module '%s' is connected only to an 'ifOut' or an 'ifIn' gate, must connect to either both or neither", ifmod->getFullPath().c_str());
        if (nwlayerInGate->getOwnerModule() != nwlayerOutGate->getOwnerModule())
            throw cRuntimeError("addInterface(): interface module '%s' is connected to 'ifOut' and 'ifIn' gates in different modules", ifmod->getFullPath().c_str());
        if (nwlayerInGate->getIndex() != nwlayerOutGate->getIndex()) // if both are scalar, that's OK too (index==0)
            throw cRuntimeError("addInterface(): gate index mismatch: interface module '%s' is connected to different indices in 'ifOut[']/'ifIn[]' gates of the network layer module", ifmod->getFullPath().c_str());
//        entry->setNetworkLayerGateIndex(nwlayerInGate->getIndex());
    }
}

Referenced by addInterface().

findFirstLoopbackInterface()

NetworkInterface * inet::InterfaceTable::findFirstLoopbackInterface ( ) const

overridevirtual

Returns the first interface with the isLoopback flag set.

If there's no loopback, it returns nullptr.

Implements inet::IInterfaceTable.

{
    Enter_Method("findFirstLoopbackInterface");
    int n = idToInterface.size();
    for (int i = 0; i < n; i++)
        if (idToInterface[i] && idToInterface[i]->isLoopback())
            return idToInterface[i];
 
    return nullptr;
}

findFirstMulticastInterface()

NetworkInterface * inet::InterfaceTable::findFirstMulticastInterface ( ) const

overridevirtual

Returns the first multicast capable interface.

If there is no such interface, then returns nullptr.

Implements inet::IInterfaceTable.

{
    Enter_Method("findFirstMulticastInterface");
    int n = idToInterface.size();
    for (int i = 0; i < n; i++)
        if (idToInterface[i] && idToInterface[i]->isMulticast() && !idToInterface[i]->isLoopback())
            return idToInterface[i];
 
    return nullptr;
}

findFirstNonLoopbackInterface()

NetworkInterface * inet::InterfaceTable::findFirstNonLoopbackInterface ( ) const

overridevirtual

Returns the first interface with the isLoopback flag unset.

If there's no non-loopback, it returns nullptr.

Implements inet::IInterfaceTable.

{
    Enter_Method("findFirstNonLoopbackInterface");
    int n = idToInterface.size();
    for (int i = 0; i < n; i++)
        if (idToInterface[i] && !idToInterface[i]->isLoopback())
            return idToInterface[i];
 
    return nullptr;
}

findInterfaceByAddress()

NetworkInterface * inet::InterfaceTable::findInterfaceByAddress ( const L3Address &  address ) const

overridevirtual

Returns an interface given by its address.

Returns nullptr if not found.

Implements inet::IInterfaceTable.

{
    if (!address.isUnspecified()) {
        L3Address::AddressType addrType = address.getType();
        for (auto& elem : idToInterface) {
            NetworkInterface *ie = elem;
            if (ie) {
#ifdef INET_WITH_NEXTHOP
                if (auto nextHopData = ie->findProtocolData<NextHopInterfaceData>())
                    if (nextHopData->getAddress() == address)
                        return ie;
#endif // ifdef INET_WITH_NEXTHOP
                switch (addrType) {
#ifdef INET_WITH_IPv4
                    case L3Address::IPv4:
                        if (auto ipv4Data = ie->findProtocolData<Ipv4InterfaceData>())
                            if (ipv4Data->getIPAddress() == address.toIpv4())
                                return ie;
                        break;
#endif // ifdef INET_WITH_IPv4
 
#ifdef INET_WITH_IPv6
                    case L3Address::IPv6:
                        if (auto ipv6Data = ie->findProtocolData<Ipv6InterfaceData>())
                            if (ipv6Data->hasAddress(address.toIpv6()))
                                return ie;
                        break;
#endif // ifdef INET_WITH_IPv6
 
                    case L3Address::MAC:
                        if (ie->getMacAddress() == address.toMac())
                            return ie;
                        break;
 
                    case L3Address::MODULEID:
                        if (ie->getModuleIdAddress() == address.toModuleId())
                            return ie;
                        break;
 
                    case L3Address::MODULEPATH:
                        if (ie->getModulePathAddress() == address.toModulePath())
                            return ie;
                        break;
 
                    default:
                        throw cRuntimeError("Unknown address type");
                        break;
                }
            }
        }
    }
    return nullptr;
}

Referenced by isLocalAddress().

findInterfaceById()

NetworkInterface * inet::InterfaceTable::findInterfaceById ( int  id ) const

overridevirtual

Returns an interface by its Id.

Ids are guaranteed to be invariant to interface deletions/additions. Returns nullptr if there is no such interface (This allows detecting stale IDs without raising an error.)

Implements inet::IInterfaceTable.

{
    id -= INTERFACEIDS_START;
    return (id < 0 || id >= (int)idToInterface.size()) ? nullptr : idToInterface[id];
}

Referenced by getInterfaceById().

findInterfaceByInterfaceModule()

NetworkInterface * inet::InterfaceTable::findInterfaceByInterfaceModule ( cModule *  ifmod ) const

overridevirtual

Returns an interface by one of its component module (e.g.

PPP). Returns nullptr if not found.

Implements inet::IInterfaceTable.

{
    // ifmod is something like "host.eth[1].mac"; climb up to find "host.eth[1]" from it
    ASSERT(host != nullptr);
    cModule *_ifmod = ifmod;
    while (ifmod && ifmod->getParentModule() != host)
        ifmod = ifmod->getParentModule();
    if (!ifmod)
        throw cRuntimeError("Specified module (%s) is not in this host/router '%s'", _ifmod->getFullPath().c_str(), this->getFullPath().c_str());
 
    int nodeInputGateId = -1, nodeOutputGateId = -1;
    for (GateIterator i(ifmod); !i.end(); i++) {
        cGate *g = *i;
        if (!g)
            continue;
 
        // find the host/router's gates that internally connect to this interface
        if (g->getType() == cGate::OUTPUT && g->getNextGate() && g->getNextGate()->getOwnerModule() == host)
            nodeOutputGateId = g->getNextGate()->getId();
        if (g->getType() == cGate::INPUT && g->getPreviousGate() && g->getPreviousGate()->getOwnerModule() == host)
            nodeInputGateId = g->getPreviousGate()->getId();
    }
 
    NetworkInterface *ie = nullptr;
    if (nodeInputGateId >= 0)
        ie = findInterfaceByNodeInputGateId(nodeInputGateId);
    if (!ie && nodeOutputGateId >= 0)
        ie = findInterfaceByNodeOutputGateId(nodeOutputGateId);
 
    ASSERT(!ie || (ie->getNodeInputGateId() == nodeInputGateId && ie->getNodeOutputGateId() == nodeOutputGateId));
    return ie;
}

findInterfaceByName()

NetworkInterface * inet::InterfaceTable::findInterfaceByName ( const char *  name ) const

overridevirtual

Returns an interface given by its name.

Returns nullptr if not found.

Implements inet::IInterfaceTable.

{
    Enter_Method("findInterfaceByName");
    if (!name)
        return nullptr;
    int n = idToInterface.size();
    for (int i = 0; i < n; i++)
        if (idToInterface[i] && !strcmp(name, idToInterface[i]->getInterfaceName()))
            return idToInterface[i];
 
    return nullptr;
}

Referenced by addInterface().

findInterfaceByNodeInputGateId()

NetworkInterface * inet::InterfaceTable::findInterfaceByNodeInputGateId ( int  id ) const

overridevirtual

Returns an interface given by its getNodeInputGateId().

Returns nullptr if not found.

Implements inet::IInterfaceTable.

{
    // linear search is OK because normally we have don't have many interfaces and this func is rarely called
    Enter_Method("findInterfaceByNodeInputGateId");
    int n = idToInterface.size();
    for (int i = 0; i < n; i++)
        if (idToInterface[i] && idToInterface[i]->getNodeInputGateId() == id)
            return idToInterface[i];
 
    return nullptr;
}

Referenced by findInterfaceByInterfaceModule().

findInterfaceByNodeOutputGateId()

NetworkInterface * inet::InterfaceTable::findInterfaceByNodeOutputGateId ( int  id ) const

overridevirtual

Returns an interface given by its getNodeOutputGateId().

Returns nullptr if not found.

Implements inet::IInterfaceTable.

{
    // linear search is OK because normally we have don't have many interfaces and this func is rarely called
    Enter_Method("findInterfaceByNodeOutputGateId");
    int n = idToInterface.size();
    for (int i = 0; i < n; i++)
        if (idToInterface[i] && idToInterface[i]->getNodeOutputGateId() == id)
            return idToInterface[i];
 
    return nullptr;
}

Referenced by findInterfaceByInterfaceModule().

getBiggestInterfaceId()

int inet::InterfaceTable::getBiggestInterfaceId ( ) const

overridevirtual

Returns the biggest interface Id.

Implements inet::IInterfaceTable.

{
    return INTERFACEIDS_START + idToInterface.size() - 1;
}

getFullPath()

virtual std::string inet::InterfaceTable::getFullPath ( ) const

inlineoverridevirtual

Module path name.

Implements inet::IInterfaceTable.

{ return cSimpleModule::getFullPath(); }

getHostModule()

cModule * inet::InterfaceTable::getHostModule ( ) const

overridevirtual

Returns the host or router this interface table lives in.

Implements inet::IInterfaceTable.

{
    ASSERT(host != nullptr);
    return host;
}

getInterface()

NetworkInterface * inet::InterfaceTable::getInterface ( int  pos ) const

overridevirtual

Returns the NetworkInterface specified by an index 0..numInterfaces-1.

Throws an error if index is out of range.

Note that this index is NOT the same as interfaceId! Indices are not guaranteed to stay the same after interface addition/deletion, so cannot be used to reliably identify the interface. Use interfaceId to refer to interfaces from other modules or from messages/packets.

Implements inet::IInterfaceTable.

{
    int n = getNumInterfaces(); // also fills tmpInterfaceList
    if (pos < 0 || pos >= n)
        throw cRuntimeError("getInterface(): interface index %d out of range 0..%d", pos, n - 1);
 
    if (!tmpInterfaceList) {
        // collect non-nullptr elements into tmpInterfaceList[]
        tmpInterfaceList = new NetworkInterface *[n];
        int k = 0;
        int maxId = idToInterface.size();
        for (int i = 0; i < maxId; i++)
            if (idToInterface[i])
                tmpInterfaceList[k++] = idToInterface[i];
 
    }
 
    return tmpInterfaceList[pos];
}

Referenced by collectMulticastGroups().

getInterfaceById()

NetworkInterface * inet::InterfaceTable::getInterfaceById ( int  id ) const

overridevirtual

Returns an interface by its Id.

Ids are guaranteed to be invariant to interface deletions/additions. Throws an error if there is no such interface.

Implements inet::IInterfaceTable.

{
    NetworkInterface *ie = findInterfaceById(id);
    if (ie == nullptr)
        throw cRuntimeError("getInterfaceById(): no interface with ID=%d", id);
    return ie;
}

Referenced by deleteInterface().

getNumInterfaces()

int inet::InterfaceTable::getNumInterfaces ( ) const

overridevirtual

Returns the number of interfaces.

Implements inet::IInterfaceTable.

{
    if (tmpNumInterfaces == -1) {
        // count non-nullptr elements
        int n = 0;
        int maxId = idToInterface.size();
        for (int i = 0; i < maxId; i++)
            if (idToInterface[i])
                n++;
 
        tmpNumInterfaces = n;
    }
 
    return tmpNumInterfaces;
}

Referenced by collectMulticastGroups(), getInterface(), and refreshDisplay().

handleCrashOperation()

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

overridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    resetInterfaces();
}

handleMessageWhenUp()

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

overrideprotectedvirtual

Raises an error.

Implements inet::OperationalMixin< cSimpleModule >.

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

handleStartOperation()

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

overridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
}

handleStopOperation()

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

overridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    resetInterfaces();
}

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

{
    OperationalBase::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        // get a pointer to the host module
        host = getContainingNode(this);
        WATCH_PTRVECTOR(idToInterface);
    }
}

interfaceChanged()

void inet::InterfaceTable::interfaceChanged ( simsignal_t  signalID, const NetworkInterfaceChangeDetails *  details  )

overrideprotectedvirtual

Implements inet::IInterfaceTable.

{
    Enter_Method("interfaceChanged");
    emit(signalID, const_cast<NetworkInterfaceChangeDetails *>(details));
}

invalidateTmpInterfaceList()

void inet::InterfaceTable::invalidateTmpInterfaceList ( )

protectedvirtual

{
    tmpNumInterfaces = -1;
    delete[] tmpInterfaceList;
    tmpInterfaceList = nullptr;
}

Referenced by addInterface(), and deleteInterface().

isInitializeStage()

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

inlineoverridevirtual

Lifecycle method.

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == INITSTAGE_LINK_LAYER; }

isLocalAddress()

bool inet::InterfaceTable::isLocalAddress ( const L3Address &  address ) const

overridevirtual

Checks if the address is a local one, i.e.

one of the host's.

Implements inet::IInterfaceTable.

{
    return findInterfaceByAddress(address) != nullptr;
}

isModuleStartStage()

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

inlineoverridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == ModuleStartOperation::STAGE_LINK_LAYER; }

isModuleStopStage()

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

inlineoverridevirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ return stage == ModuleStopOperation::STAGE_LINK_LAYER; }

isNeighborAddress()

bool inet::InterfaceTable::isNeighborAddress ( const L3Address &  address ) const

overridevirtual

Checks if the address is on the network of one of the interfaces, but not local.

Implements inet::IInterfaceTable.

{
    if (address.isUnspecified())
        return false;
 
    switch (address.getType()) {
#ifdef INET_WITH_IPv4
        case L3Address::IPv4:
            for (auto& elem : idToInterface) {
                NetworkInterface *ie = elem;
                if (ie) {
                    if (auto ipv4Data = ie->findProtocolData<Ipv4InterfaceData>()) {
                        Ipv4Address ipv4Addr = ipv4Data->getIPAddress();
                        Ipv4Address netmask = ipv4Data->getNetmask();
                        if (Ipv4Address::maskedAddrAreEqual(address.toIpv4(), ipv4Addr, netmask))
                            return address != ipv4Addr;
                    }
                }
            }
            break;
 
#endif // ifdef INET_WITH_IPv4
#ifdef INET_WITH_IPv6
        case L3Address::IPv6:
            for (auto& elem : idToInterface) {
                NetworkInterface *ie = elem;
                if (ie) {
                    if (auto ipv6Data = ie->findProtocolData<Ipv6InterfaceData>()) {
                        for (int j = 0; j < ipv6Data->getNumAdvPrefixes(); j++) {
                            const Ipv6InterfaceData::AdvPrefix& advPrefix = ipv6Data->getAdvPrefix(j);
                            if (address.toIpv6().matches(advPrefix.prefix, advPrefix.prefixLength))
                                return address != advPrefix.prefix;
                        }
                    }
                }
            }
            break;
 
#endif // ifdef INET_WITH_IPv6
        case L3Address::MAC:
        case L3Address::MODULEPATH:
        case L3Address::MODULEID:
            // TODO
            break;
 
        default:
            throw cRuntimeError("Unknown address type");
    }
    return false;
}

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

receiveSignal()

void inet::InterfaceTable::receiveSignal ( cComponent *  source, simsignal_t  signalID, cObject *  obj, cObject *  details  )

overridevirtual

Called by the signal handler whenever a change of a category occurs to which this client has subscribed.

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    // nothing needed here at the moment
    printSignalBanner(signalID, obj, details);
}

refreshDisplay()

void inet::InterfaceTable::refreshDisplay ( ) const

overrideprotectedvirtual

{
    OperationalBase::refreshDisplay();
 
    char buf[80];
    sprintf(buf, "%d interfaces", getNumInterfaces());
    getDisplayString().setTagArg("t", 0, buf);
 
    if (par("displayAddresses")) {
        for (auto& elem : idToInterface) {
            NetworkInterface *ie = elem;
            if (ie)
                updateLinkDisplayString(ie);
        }
    }
}

resetInterfaces()

void inet::InterfaceTable::resetInterfaces ( )

protectedvirtual

{
    int n = idToInterface.size();
    for (int i = 0; i < n; i++)
        if (idToInterface[i])
            idToInterface[i]->resetInterface();
}

Referenced by handleCrashOperation(), and handleStopOperation().

updateLinkDisplayString()

void inet::InterfaceTable::updateLinkDisplayString ( NetworkInterface *  entry ) const

protectedvirtual

{
    int outputGateId = entry->getNodeOutputGateId();
    if (outputGateId != -1) {
        ASSERT(host != nullptr);
        cGate *outputGate = host->gate(outputGateId);
        if (!outputGate->getChannel())
            return;
        cDisplayString& displayString = outputGate->getDisplayString();
        std::stringstream buf;
        buf << entry->getFullName() << "\n";
#ifdef INET_WITH_IPv4
        auto ipv4Data = entry->findProtocolData<Ipv4InterfaceData>();
        if (ipv4Data && !(ipv4Data->getIPAddress().isUnspecified())) {
            buf << ipv4Data->getIPAddress().str() << "/" << ipv4Data->getNetmask().getNetmaskLength() << "\n";
        }
#endif // ifdef INET_WITH_IPv4
#ifdef INET_WITH_IPv6
        auto ipv6Data = entry->findProtocolData<Ipv6InterfaceData>();
        if (ipv6Data && ipv6Data->getNumAddresses() > 0) {
            for (int i = 0; i < ipv6Data->getNumAddresses(); i++) {
                if (ipv6Data->getAddress(i).isSolicitedNodeMulticastAddress()
                        //|| (ipv6Data->getAddress(i).isLinkLocal() && ipv6Data->getAddress(i).)
                        || ipv6Data->getAddress(i).isMulticast()) continue;
                buf << ipv6Data->getAddress(i).str() << "/64" << "\n";
            }
        }
#endif // ifdef INET_WITH_IPv6
        displayString.setTagArg("t", 0, buf.str().c_str());
        displayString.setTagArg("t", 1, "l");
    }
}

Referenced by refreshDisplay().

Member Data Documentation

host

cModule* inet::InterfaceTable::host

protected

Referenced by addInterface(), discoverConnectingGates(), findInterfaceByInterfaceModule(), getHostModule(), initialize(), InterfaceTable(), and updateLinkDisplayString().

idToInterface

InterfaceVector inet::InterfaceTable::idToInterface

protected

Referenced by addInterface(), deleteInterface(), findFirstLoopbackInterface(), findFirstMulticastInterface(), findFirstNonLoopbackInterface(), findInterfaceByAddress(), findInterfaceById(), findInterfaceByName(), findInterfaceByNodeInputGateId(), findInterfaceByNodeOutputGateId(), getBiggestInterfaceId(), getInterface(), getNumInterfaces(), initialize(), isNeighborAddress(), refreshDisplay(), and resetInterfaces().

tmpInterfaceList

NetworkInterface** inet::InterfaceTable::tmpInterfaceList

mutableprotected

Referenced by getInterface(), InterfaceTable(), invalidateTmpInterfaceList(), and ~InterfaceTable().

tmpNumInterfaces

int inet::InterfaceTable::tmpNumInterfaces

mutableprotected

Referenced by getNumInterfaces(), InterfaceTable(), and invalidateTmpInterfaceList().

---

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

• InterfaceTable.h
• InterfaceTable.cc