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 InterfaceEntry *	findInterfaceByAddress (const L3Address &address) const override
	Returns an interface given by its address. More...
virtual void	addInterface (InterfaceEntry *entry) override
	Adds an interface. More...
virtual void	deleteInterface (InterfaceEntry *entry) override
	Deletes the given interface from the table. More...
virtual int	getNumInterfaces () const override
	Returns the number of interfaces. More...
virtual InterfaceEntry *	getInterface (int pos) const override
	Returns the InterfaceEntry specified by an index 0..numInterfaces-1. More...
virtual InterfaceEntry *	getInterfaceById (int id) const override
	Returns an interface by its Id. More...
virtual int	getBiggestInterfaceId () const override
	Returns the biggest interface Id. More...
virtual InterfaceEntry *	getInterfaceByNodeOutputGateId (int id) const override
	Returns an interface given by its getNodeOutputGateId(). More...
virtual InterfaceEntry *	getInterfaceByNodeInputGateId (int id) const override
	Returns an interface given by its getNodeInputGateId(). More...
virtual InterfaceEntry *	getInterfaceByNetworkLayerGateIndex (int index) override
	Returns an interface given by its getNetworkLayerGateIndex(). More...
virtual InterfaceEntry *	getInterfaceByInterfaceModule (cModule *ifmod) const override
	Returns an interface by one of its component module (e.g. More...
virtual InterfaceEntry *	getInterfaceByName (const char *name) const override
	Returns an interface given by its name. More...
virtual InterfaceEntry *	getFirstLoopbackInterface () const override
	Returns the first interface with the isLoopback flag set. More...
virtual InterfaceEntry *	getFirstMulticastInterface () const override
	Returns the first multicast capable interface. More...
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	ILifecycle method. More...
virtual MulticastGroupList	collectMulticastGroups () const override
	Returns all multicast group address, with it's interfaceId. More...
Public Member Functions inherited from inet::IInterfaceTable
virtual	~IInterfaceTable ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Types
typedef std::vector< InterfaceEntry * >	InterfaceVector

Protected Member Functions
virtual void	refreshDisplay () const override
virtual void	updateLinkDisplayString (InterfaceEntry *entry) const
virtual void	discoverConnectingGates (InterfaceEntry *entry)
virtual void	interfaceChanged (simsignal_t signalID, const InterfaceEntryChangeDetails *details) override
virtual void	invalidateTmpInterfaceList ()
virtual void	resetInterfaces ()
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *) override
	Raises an error. More...

Protected Attributes
cModule *	host
InterfaceVector	idToInterface
int	tmpNumInterfaces
InterfaceEntry **	tmpInterfaceList

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 InterfaceEntry to the table; after that, IPv4's IIPv4RoutingTable and IPv6's IPv6RoutingTable (an possibly, further L3 protocols) add protocol-specific data on each InterfaceEntry (see IPv4InterfaceData, IPv6InterfaceData, and InterfaceEntry::setIPv4Data(), InterfaceEntry::setIPv6Data())

Interfaces are represented by InterfaceEntry 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 InterfaceEntry 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: NF_INTERFACE_CREATED, NF_INTERFACE_DELETED, NF_INTERFACE_STATE_CHANGED, NF_INTERFACE_CONFIG_CHANGED. State change gets fired for up/down events; all other changes fire as config change.

See also

InterfaceEntry

Member Typedef Documentation

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

protected

Constructor & Destructor Documentation

inet::InterfaceTable::InterfaceTable

(

)

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

inet::InterfaceTable::~InterfaceTable ( )

virtual

{
    for (auto & elem : idToInterface)
        delete elem;
    delete[] tmpInterfaceList;
}

Member Function Documentation

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

overridevirtual

Adds an interface.

The entry->getInterfaceModule() will be used to discover and fill in getNetworkLayerGateIndex(), getNodeOutputGateId(), and getNodeInputGateId() in InterfaceEntry. 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 (getInterfaceByName(entry->getName()) != nullptr)
        throw cRuntimeError("addInterface(): interface '%s' already registered", entry->getName());

    // insert
    entry->setInterfaceId(INTERFACEIDS_START + idToInterface.size());
    entry->setInterfaceTable(this);
    idToInterface.push_back(entry);
    invalidateTmpInterfaceList();

    // fill in networkLayerGateIndex, nodeOutputGateId, nodeInputGateId
    discoverConnectingGates(entry);

    emit(NF_INTERFACE_CREATED, entry);
}

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 WITH_IPv4
        InterfaceEntry *ie = getInterface(i);
        int interfaceId = ie->getInterfaceId();
        if (ie->ipv4Data()) {
            int numOfMulticastGroups = ie->ipv4Data()->getNumOfJoinedMulticastGroups();
            for (int j = 0; j < numOfMulticastGroups; ++j) {
                mglist.push_back(MulticastGroup(ie->ipv4Data()->getJoinedMulticastGroup(j), interfaceId));
            }
        }
#endif // ifdef WITH_IPv4
#ifdef WITH_IPv6
        // TODO
#endif // ifdef WITH_IPv6
    }
    return mglist;
}

void inet::InterfaceTable::deleteInterface ( InterfaceEntry *  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->getName());

    emit(NF_INTERFACE_DELETED, entry);    // actually, only going to be deleted

    idToInterface[id - INTERFACEIDS_START] = nullptr;
    delete entry;
    invalidateTmpInterfaceList();
}

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

protectedvirtual

Referenced by addInterface().

{
    cModule *ifmod = entry->getInterfaceModule();
    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->getInterfaceModule()->getFullPath().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 InterfaceEntry 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());

        // 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

    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());
    }
}

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

overridevirtual

Returns an interface given by its address.

Returns nullptr if not found.

Implements inet::IInterfaceTable.

Referenced by isLocalAddress().

{
    if (!address.isUnspecified()) {
        L3Address::AddressType addrType = address.getType();
        for (auto & elem : idToInterface) {
            InterfaceEntry *ie = elem;
            if (ie) {
#ifdef WITH_GENERIC
                if (ie->getGenericNetworkProtocolData() && ie->getGenericNetworkProtocolData()->getAddress() == address)
                    return ie;
#endif // ifdef WITH_GENERIC
                switch (addrType) {
#ifdef WITH_IPv4
                    case L3Address::IPv4:
                        if (ie->ipv4Data() && ie->ipv4Data()->getIPAddress() == address.toIPv4())
                            return ie;
                        break;
#endif // ifdef WITH_IPv4

#ifdef WITH_IPv6
                    case L3Address::IPv6:
                        if (ie->ipv6Data() && ie->ipv6Data()->hasAddress(address.toIPv6()))
                            return ie;
                        break;
#endif // ifdef 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;
}

int inet::InterfaceTable::getBiggestInterfaceId ( ) const

overridevirtual

Returns the biggest interface Id.

Implements inet::IInterfaceTable.

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

InterfaceEntry * inet::InterfaceTable::getFirstLoopbackInterface ( ) const

overridevirtual

Returns the first interface with the isLoopback flag set.

(If there's no loopback, it returns nullptr – but this should never happen because InterfaceTable itself registers a loopback interface on startup.)

Implements inet::IInterfaceTable.

{
    Enter_Method_Silent();
    int n = idToInterface.size();
    for (int i = 0; i < n; i++)
        if (idToInterface[i] && idToInterface[i]->isLoopback())
            return idToInterface[i];

    return nullptr;
}

InterfaceEntry * inet::InterfaceTable::getFirstMulticastInterface ( ) const

overridevirtual

Returns the first multicast capable interface.

If there is no such interface, then returns nullptr.

Implements inet::IInterfaceTable.

{
    Enter_Method_Silent();
    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;
}

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

inlineoverridevirtual

Module path name.

Implements inet::IInterfaceTable.

Referenced by discoverConnectingGates(), and getInterfaceByInterfaceModule().

{ return cSimpleModule::getFullPath(); }

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

overridevirtual

Returns the host or router this interface table lives in.

Implements inet::IInterfaceTable.

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

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

overridevirtual

Returns the InterfaceEntry 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.

Referenced by collectMulticastGroups().

{
    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 InterfaceEntry *[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];
}

InterfaceEntry * inet::InterfaceTable::getInterfaceById ( 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.

Referenced by deleteInterface().

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

InterfaceEntry * inet::InterfaceTable::getInterfaceByInterfaceModule ( 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("addInterface(): 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();
    }

    InterfaceEntry *ie = nullptr;
    if (nodeInputGateId >= 0)
        ie = getInterfaceByNodeInputGateId(nodeInputGateId);
    if (!ie && nodeOutputGateId >= 0)
        ie = getInterfaceByNodeOutputGateId(nodeOutputGateId);

    ASSERT(!ie || (ie->getNodeInputGateId() == nodeInputGateId && ie->getNodeOutputGateId() == nodeOutputGateId));
    return ie;
}

InterfaceEntry * inet::InterfaceTable::getInterfaceByName ( const char *  name ) const

overridevirtual

Returns an interface given by its name.

Returns nullptr if not found.

Implements inet::IInterfaceTable.

Referenced by addInterface().

{
    Enter_Method_Silent();
    if (!name)
        return nullptr;
    int n = idToInterface.size();
    for (int i = 0; i < n; i++)
        if (idToInterface[i] && !strcmp(name, idToInterface[i]->getName()))
            return idToInterface[i];

    return nullptr;
}

InterfaceEntry * inet::InterfaceTable::getInterfaceByNetworkLayerGateIndex ( int  index )

overridevirtual

Returns an interface given by its getNetworkLayerGateIndex().

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_Silent();
    int n = idToInterface.size();
    for (int i = 0; i < n; i++)
        if (idToInterface[i] && idToInterface[i]->getNetworkLayerGateIndex() == index)
            return idToInterface[i];

    return nullptr;
}

InterfaceEntry * inet::InterfaceTable::getInterfaceByNodeInputGateId ( int  id ) const

overridevirtual

Returns an interface given by its getNodeInputGateId().

Returns nullptr if not found.

Implements inet::IInterfaceTable.

Referenced by getInterfaceByInterfaceModule().

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

    return nullptr;
}

InterfaceEntry * inet::InterfaceTable::getInterfaceByNodeOutputGateId ( int  id ) const

overridevirtual

Returns an interface given by its getNodeOutputGateId().

Returns nullptr if not found.

Implements inet::IInterfaceTable.

Referenced by getInterfaceByInterfaceModule().

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

    return nullptr;
}

int inet::InterfaceTable::getNumInterfaces ( ) const

overridevirtual

Returns the number of interfaces.

Implements inet::IInterfaceTable.

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

{
    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;
}

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

overrideprotectedvirtual

Raises an error.

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

bool inet::InterfaceTable::handleOperationStage ( LifecycleOperation *  operation, int  stage, IDoneCallback *  doneCallback  )

overridevirtual

ILifecycle method.

Implements inet::ILifecycle.

{
    Enter_Method_Silent();
    if (dynamic_cast<NodeStartOperation *>(operation)) {
    }
    else if (dynamic_cast<NodeShutdownOperation *>(operation)) {
        if ((NodeShutdownOperation::Stage)stage == NodeShutdownOperation::STAGE_LINK_LAYER)
            resetInterfaces();
    }
    else if (dynamic_cast<NodeCrashOperation *>(operation)) {
        if ((NodeCrashOperation::Stage)stage == NodeCrashOperation::STAGE_CRASH)
            resetInterfaces();
    }
    return true;
}

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);

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

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

overrideprotectedvirtual

Implements inet::IInterfaceTable.

{
    Enter_Method_Silent();
    emit(signalID, const_cast<InterfaceEntryChangeDetails *>(details));
}

void inet::InterfaceTable::invalidateTmpInterfaceList ( )

protectedvirtual

Referenced by addInterface(), and deleteInterface().

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

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;
}

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 WITH_IPv4
        case L3Address::IPv4:
            for (auto & elem : idToInterface) {
                InterfaceEntry *ie = elem;
                if (ie && ie->ipv4Data()) {
                    IPv4Address ipv4Addr = ie->ipv4Data()->getIPAddress();
                    IPv4Address netmask = ie->ipv4Data()->getNetmask();
                    if (IPv4Address::maskedAddrAreEqual(address.toIPv4(), ipv4Addr, netmask))
                        return address != ipv4Addr;
                }
            }
            break;

#endif // ifdef WITH_IPv4
#ifdef WITH_IPv6
        case L3Address::IPv6:
            for (auto & elem : idToInterface) {
                InterfaceEntry *ie = elem;
                if (ie && ie->ipv6Data()) {
                    IPv6InterfaceData *ipv6Data = ie->ipv6Data();
                    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 WITH_IPv6
        case L3Address::MAC:
        case L3Address::MODULEPATH:
        case L3Address::MODULEID:
            // TODO
            break;

        default:
            throw cRuntimeError("Unknown address type");
    }
    return false;
}

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

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.

{
    // nothing needed here at the moment
    Enter_Method_Silent();
    printNotificationBanner(signalID, obj);
}

void inet::InterfaceTable::refreshDisplay ( ) const

overrideprotectedvirtual

{
    char buf[80];
    sprintf(buf, "%d interfaces", getNumInterfaces());
    getDisplayString().setTagArg("t", 0, buf);

    if (par("displayAddresses").boolValue()) {
        for (auto & elem : idToInterface) {
            InterfaceEntry *ie = elem;
            if (ie)
                updateLinkDisplayString(ie);
        }
    }

}

void inet::InterfaceTable::resetInterfaces ( )

protectedvirtual

Referenced by handleOperationStage().

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

}

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

protectedvirtual

Referenced by refreshDisplay().

{
    int outputGateId = entry->getNodeOutputGateId();
    if (outputGateId != -1) {
        ASSERT(host != nullptr);
        cGate *outputGate = host->gate(outputGateId);
        if (!outputGate->getChannel())
            return;
        cDisplayString& displayString = outputGate->getDisplayString();
        std::ostringstream buf;
        buf << entry->getFullName();
#ifdef WITH_IPv4
        if (entry->ipv4Data()) {
            buf << "\n" << entry->ipv4Data()->getIPAddress().str() << "/" << entry->ipv4Data()->getNetmask().getNetmaskLength();
        }
#endif // ifdef WITH_IPv4
#ifdef WITH_IPv6
        if (entry->ipv6Data() && entry->ipv6Data()->getNumAddresses() > 0) {
            buf << "\n" << entry->ipv6Data()->getPreferredAddress().str();
        }
#endif // ifdef WITH_IPv6
        displayString.setTagArg("t", 0, buf.str().c_str());
        displayString.setTagArg("t", 1, "l");
    }
}

Member Data Documentation

cModule* inet::InterfaceTable::host

protected

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

InterfaceVector inet::InterfaceTable::idToInterface

protected

Referenced by addInterface(), deleteInterface(), findInterfaceByAddress(), getBiggestInterfaceId(), getFirstLoopbackInterface(), getFirstMulticastInterface(), getInterface(), getInterfaceById(), getInterfaceByName(), getInterfaceByNetworkLayerGateIndex(), getInterfaceByNodeInputGateId(), getInterfaceByNodeOutputGateId(), getNumInterfaces(), initialize(), isNeighborAddress(), refreshDisplay(), resetInterfaces(), and ~InterfaceTable().

InterfaceEntry** inet::InterfaceTable::tmpInterfaceList

mutableprotected

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

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