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 InterfaceEntry *ie)
	Returns the index of the first selector that matches the interface. More...

Private Member Functions
bool	linkContainsMatchingHost (const InterfaceEntry *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: , , , and . The value of these attributes are space separated name patterns. ...

• : specifies the names of the host module of the interface. Qualified names are accepted, but not required.
• : specifies the names of the interfaces
• : specifies the names of the hosts which the interface is connected to
• : 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

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

inet::InterfaceMatcher::~InterfaceMatcher

(

)

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

Member Function Documentation

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

private

Referenced by linkContainsMatchingHost().

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

int inet::InterfaceMatcher::findMatchingSelector

(

const InterfaceEntry *

ie

)

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

Referenced by inet::PIMInterfaceTable::addInterface(), inet::PIMInterfaceTable::configureInterfaces(), inet::RIPRouting::configureInterfaces(), and inet::RIPRouting::receiveSignal().

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

    return -1;
}

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

private

Referenced by inet::InterfaceMatcher::Selector::matches().

{
    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

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