inet::InterfaceMatcher Class Reference

Utility class for configuring interfaces. More...

#include <InterfaceMatcher.h>

Classes
class	Matcher
struct	Selector

Public Member Functions
	InterfaceMatcher (const cXMLElementList &selectors)
	~InterfaceMatcher ()
int	findMatchingSelector (const NetworkInterface *ie)
	Returns the index of the first selector that matches the interface. More...

Private Member Functions
bool	linkContainsMatchingHost (const NetworkInterface *ie, const Matcher &hostMatcher) const
void	collectNeighbors (cGate *outGate, std::vector< cModule * > &hostNodes, std::vector< cModule * > &deviceNodes, cModule *exludedNode) const

Private Attributes
std::vector< Selector * >	selectors

Detailed Description

Utility class for configuring interfaces.

It is assumed that the configuration is described by an xml document. Each element in the configuration applies parameters to a set of interfaces. These interfaces are selected by a set of selector attributes: @hosts, @names, @towards, and @among. The value of these attributes are space separated name patterns. ...

• @hosts: specifies the names of the host module of the interface. Qualified names are accepted, but not required.
• @names: specifies the names of the interfaces
• @towards: specifies the names of the hosts which the interface is connected to
• @among: specifies the names of hosts, and select the interfaces of those hosts that are connected to that hosts among="X Y Z" is the same as hosts="X Y Z" towards="X Y Z"

If there are more selector attributes in an element, all of them are required to match.

Constructor & Destructor Documentation

InterfaceMatcher()

inet::InterfaceMatcher::InterfaceMatcher

(

const cXMLElementList &

selectors

)

{
    for (auto& xmlSelector : xmlSelectors) {
        cXMLElement *interfaceElement = xmlSelector;
        const char *hostAttr = interfaceElement->getAttribute("hosts"); // "host* router[0..3]"
        const char *interfaceAttr = interfaceElement->getAttribute("names"); // i.e. interface names, like "eth* ppp0"
 
        const char *towardsAttr = interfaceElement->getAttribute("towards"); // neighbor host names, like "ap switch"
        const char *amongAttr = interfaceElement->getAttribute("among"); // neighbor host names, like "host[*] router1"
 
        if (amongAttr && *amongAttr) { // among="X Y Z" means hosts = "X Y Z" towards = "X Y Z"
            if ((hostAttr && *hostAttr) || (towardsAttr && *towardsAttr))
                throw cRuntimeError("The 'hosts'/'towards' and 'among' attributes are mutually exclusive, at %s", interfaceElement->getSourceLocation());
            towardsAttr = hostAttr = amongAttr;
        }
 
        try {
            selectors.push_back(new Selector(hostAttr, interfaceAttr, towardsAttr, this));
        }
        catch (std::exception& e) {
            throw cRuntimeError("Error in XML <interface> element at %s: %s", interfaceElement->getSourceLocation(), e.what());
        }
    }
}

~InterfaceMatcher()

inet::InterfaceMatcher::~InterfaceMatcher

(

)

{
    for (auto& elem : selectors)
        delete elem;
}

Member Function Documentation

collectNeighbors()

void inet::InterfaceMatcher::collectNeighbors ( cGate *  outGate, std::vector< cModule * > &  hostNodes, std::vector< cModule * > &  deviceNodes, cModule *  exludedNode  ) const

private

{
    cGate *neighborGate = findRemoteGate(outGate);
    if (!neighborGate)
        return;
 
    cModule *neighborNode = neighborGate->getOwnerModule();
    if (hasInterfaceTable(neighborNode)) {
        // neighbor is a host or router
        if (neighborNode != excludedNode && !contains(hostNodes, neighborNode))
            hostNodes.push_back(neighborNode);
    }
    else {
        // assume that neighbor is an L2 or L1 device (bus/hub/switch/bridge/access point/etc); visit all its output links
        if (!contains(deviceNodes, neighborNode)) {
            if (neighborNode != excludedNode)
                deviceNodes.push_back(neighborNode);
            for (cModule::GateIterator it(neighborNode); !it.end(); it++) {
                cGate *gate = *it;
                if (gate->getType() == cGate::OUTPUT)
                    collectNeighbors(gate, hostNodes, deviceNodes, excludedNode);
            }
        }
    }
}

Referenced by linkContainsMatchingHost().

findMatchingSelector()

int inet::InterfaceMatcher::findMatchingSelector

(

const NetworkInterface *

ie

)

Returns the index of the first selector that matches the interface.

{
    for (int i = 0; i < (int)selectors.size(); i++)
        if (selectors[i]->matches(ie))
            return i;
 
    return -1;
}

Referenced by inet::PimInterfaceTable::addInterface(), inet::PimInterfaceTable::configureInterfaces(), inet::Rip::receiveSignal(), and inet::Rip::startRIPRouting().

linkContainsMatchingHost()

bool inet::InterfaceMatcher::linkContainsMatchingHost ( const NetworkInterface *  ie, const Matcher &  hostMatcher  ) const

private

{
    int outGateId = ie->getNodeOutputGateId();
    cModule *node = ie->getInterfaceTable()->getHostModule();
    cGate *outGate = node->gate(outGateId);
 
    std::vector<cModule *> hostNodes;
    std::vector<cModule *> deviceNodes;
    collectNeighbors(outGate, hostNodes, deviceNodes, node);
 
    for (auto neighbour : hostNodes) {
 
        std::string hostFullPath = neighbour->getFullPath();
        std::string hostShortenedFullPath = hostFullPath.substr(hostFullPath.find('.') + 1);
        if (hostMatcher.matches(hostShortenedFullPath.c_str()) || hostMatcher.matches(hostFullPath.c_str()))
            return true;
    }
 
    return false;
}

Member Data Documentation

selectors

std::vector<Selector *> inet::InterfaceMatcher::selectors

private

Referenced by findMatchingSelector(), InterfaceMatcher(), and ~InterfaceMatcher().

---

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

• InterfaceMatcher.h
• InterfaceMatcher.cc