inet::NetworkConfiguratorBase Class Reference

#include <NetworkConfiguratorBase.h>

Inheritance diagram for inet::NetworkConfiguratorBase:

Classes
class	InterfaceInfo
	Represents an interface in the network. More...
class	InterfaceMatcher
class	Link
	Represents a connection (wired or wireless) in the network. More...
class	LinkInfo
	Represents a "link" in the network. More...
class	Matcher
class	Node
	Represents a node in the network. More...
class	Topology
	Represents the network topology. More...

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
virtual void	extractTopology (Topology &topology)
	Extracts network topology by walking through the module hierarchy. More...
virtual void	extractWiredNeighbors (Topology &topology, Topology::LinkOut *linkOut, LinkInfo *linkInfo, std::set< InterfaceEntry * > &interfacesSeen, std::vector< Node * > &nodesVisited)
virtual void	extractWirelessNeighbors (Topology &topology, const char *wirelessId, LinkInfo *linkInfo, std::set< InterfaceEntry * > &interfacesSeen, std::vector< Node * > &nodesVisited)
virtual void	extractDeviceNeighbors (Topology &topology, Node *node, LinkInfo *linkInfo, std::set< InterfaceEntry * > &interfacesSeen, std::vector< Node * > &deviceNodesVisited)
virtual InterfaceInfo *	determineGatewayForLink (LinkInfo *linkInfo)
	If this link has exactly one node that connects to other links as well, we can assume it is a "gateway" and return that (we'll use it in routing); otherwise return nullptr. More...
virtual double	computeNodeWeight (Node *node, const char *metric, cXMLElement *parameters)
virtual double	computeLinkWeight (Link *link, const char *metric, cXMLElement *parameters)
virtual double	computeWiredLinkWeight (Link *link, const char *metric, cXMLElement *parameters)
virtual double	computeWirelessLinkWeight (Link *link, const char *metric, cXMLElement *parameters)
virtual bool	isBridgeNode (Node *node)
virtual bool	isWirelessInterface (InterfaceEntry *interfaceEntry)
virtual const char *	getWirelessId (InterfaceEntry *interfaceEntry)
	If this function returns the same string for two wireless interfaces, they will be regarded as being in the same wireless network. More...
virtual InterfaceInfo *	createInterfaceInfo (Topology &topology, Node *node, LinkInfo *linkInfo, InterfaceEntry *interfaceEntry)
virtual Topology::LinkOut *	findLinkOut (Node *node, int gateId)
virtual InterfaceInfo *	findInterfaceInfo (Node *node, InterfaceEntry *interfaceEntry)
virtual IInterfaceTable *	findInterfaceTable (Node *node)
virtual IRoutingTable *	findRoutingTable (Node *node)
virtual void	dumpTopology (Topology &topology)
Protected Member Functions inherited from inet::L3AddressResolver
virtual bool	getIPv4AddressFrom (L3Address &retAddr, IInterfaceTable *ift, bool netmask)
virtual bool	getIPv6AddressFrom (L3Address &retAddr, IInterfaceTable *ift, bool netmask)
virtual bool	getMACAddressFrom (L3Address &retAddr, IInterfaceTable *ift, bool netmask)
virtual bool	getModulePathAddressFrom (L3Address &retAddr, IInterfaceTable *ift, bool netmask)
virtual bool	getModuleIdAddressFrom (L3Address &retAddr, IInterfaceTable *ift, bool netmask)
virtual bool	getInterfaceIPv4Address (L3Address &ret, InterfaceEntry *ie, bool mask)
virtual bool	getInterfaceIPv6Address (L3Address &ret, InterfaceEntry *ie, bool mask)
virtual bool	getInterfaceMACAddress (L3Address &ret, InterfaceEntry *ie, bool mask)
virtual bool	getInterfaceModulePathAddress (L3Address &ret, InterfaceEntry *ie, bool mask)
virtual bool	getInterfaceModuleIdAddress (L3Address &ret, InterfaceEntry *ie, bool mask)

Protected Attributes
double	minLinkWeight = NaN
cXMLElement *	configuration = nullptr

Additional Inherited Members
Public Types inherited from inet::L3AddressResolver
enum	{   ADDR_IPv4 = 1, ADDR_IPv6 = 2, ADDR_MAC = 4, ADDR_MODULEPATH = 8,   ADDR_MODULEID = 16, ADDR_MASK = 32 }
Public Member Functions inherited from inet::L3AddressResolver
	L3AddressResolver ()
virtual	~L3AddressResolver ()
virtual L3Address	resolve (const char *str, int addrType=DEFAULT_ADDR_TYPE)
	Accepts dotted decimal notation ("127.0.0.1"), module name of the host or router ("host[2]"), and empty string (""). More...
virtual std::vector< L3Address >	resolve (std::vector< std::string > strs, int addrType=DEFAULT_ADDR_TYPE)
	Utility function: Calls resolve() for each item in the string vector, and returns the result in an address vector. More...
virtual bool	tryResolve (const char *str, L3Address &result, int addrType=DEFAULT_ADDR_TYPE)
	Similar to resolve(), but returns false (instead of throwing an error) if the address cannot be resolved because the given host (or interface) doesn't have an address assigned yet. More...
virtual L3Address	addressOf (cModule *host, int addrType=DEFAULT_ADDR_TYPE)
	Returns IPv4 or IPv6 address of the given host or router. More...
virtual L3Address	addressOf (cModule *host, const char *ifname, int addrType=DEFAULT_ADDR_TYPE)
	Similar to addressOf(), but only looks at the given interface. More...
virtual L3Address	addressOf (cModule *host, cModule *destmod, int addrType=DEFAULT_ADDR_TYPE)
	Returns IPv4 or IPv6 address of the given host or router. More...
virtual L3Address	routerIdOf (cModule *host)
	Returns the router Id of the given router. More...
virtual L3Address	getAddressFrom (IInterfaceTable *ift, int addrType=DEFAULT_ADDR_TYPE)
	Returns the IPv4 or IPv6 address of the given host or router, given its IInterfaceTable module. More...
virtual L3Address	getAddressFrom (InterfaceEntry *ie, int addrType=DEFAULT_ADDR_TYPE)
	Returns the IPv4 or IPv6 address of the given interface (of a host or router). More...
virtual IInterfaceTable *	interfaceTableOf (cModule *host)
	The function tries to look up the IInterfaceTable module as submodule "interfaceTable" or "networkLayer.interfaceTable" within the host/router module. More...
virtual IIPv4RoutingTable *	routingTableOf (cModule *host)
	The function tries to look up the IIPv4RoutingTable module as submodule "routingTable" or "networkLayer.routingTable" within the host/router module. More...
virtual IPv6RoutingTable *	routingTable6Of (cModule *host)
	The function tries to look up the IPv6RoutingTable module as submodule "routingTable6" or "networkLayer.routingTable6" within the host/router module. More...
virtual IInterfaceTable *	findInterfaceTableOf (cModule *host)
	Like interfaceTableOf(), but doesn't throw error if not found. More...
virtual IIPv4RoutingTable *	findIPv4RoutingTableOf (cModule *host)
	Like routingTableOf(), but doesn't throw error if not found. More...
virtual IPv6RoutingTable *	findIPv6RoutingTableOf (cModule *host)
	Like interfaceTableOf(), but doesn't throw error if not found. More...
virtual GenericRoutingTable *	findGenericRoutingTableOf (cModule *host)
	Like interfaceTableOf(), but doesn't throw error if not found. More...
virtual cModule *	findHostWithAddress (const L3Address &addr)
	Find the Host with the specified address. More...

Member Function Documentation

double inet::NetworkConfiguratorBase::computeLinkWeight ( Link *  link, const char *  metric, cXMLElement *  parameters  )

protectedvirtual

Referenced by inet::IPv4NetworkConfigurator::addStaticRoutes().

{
    if ((link->sourceInterfaceInfo && isWirelessInterface(link->sourceInterfaceInfo->interfaceEntry)) ||
        (link->destinationInterfaceInfo && isWirelessInterface(link->destinationInterfaceInfo->interfaceEntry)))
        return computeWirelessLinkWeight(link, metric, parameters);
    else
        return computeWiredLinkWeight(link, metric, parameters);
}

double inet::NetworkConfiguratorBase::computeNodeWeight ( Node *  node, const char *  metric, cXMLElement *  parameters  )

protectedvirtual

Referenced by inet::IPv4NetworkConfigurator::addStaticRoutes().

{
    const char *costAttribute = parameters->getAttribute("cost");
    if (costAttribute != nullptr)
        return parseCostAttribute(costAttribute);
    else {
        if (node->routingTable && !node->routingTable->isForwardingEnabled())
            return INFINITY;
        else
            return 0;
    }
}

double inet::NetworkConfiguratorBase::computeWiredLinkWeight ( Link *  link, const char *  metric, cXMLElement *  parameters  )

protectedvirtual

{
    const char *costAttribute = parameters->getAttribute("cost");
    if (costAttribute != nullptr)
        return parseCostAttribute(costAttribute);
    else {
        Topology::LinkOut *linkOut = static_cast<Topology::LinkOut *>(static_cast<Topology::Link *>(link));
        if (!strcmp(metric, "hopCount"))
            return 1;
        else if (!strcmp(metric, "delay")) {
            cDatarateChannel *transmissionChannel = dynamic_cast<cDatarateChannel *>(linkOut->getLocalGate()->getTransmissionChannel());
            if (transmissionChannel != nullptr)
                return transmissionChannel->getDelay().dbl();
            else
                return minLinkWeight;
        }
        else if (!strcmp(metric, "dataRate")) {
            cChannel *transmissionChannel = linkOut->getLocalGate()->getTransmissionChannel();
            if (transmissionChannel != nullptr) {
                double dataRate = transmissionChannel->getNominalDatarate();
                return dataRate != 0 ? 1 / dataRate : minLinkWeight;
            }
            else
                return minLinkWeight;
        }
        else if (!strcmp(metric, "errorRate")) {
            cDatarateChannel *transmissionChannel = dynamic_cast<cDatarateChannel *>(linkOut->getLocalGate()->getTransmissionChannel());
            if (transmissionChannel) {
                InterfaceInfo *sourceInterfaceInfo = link->sourceInterfaceInfo;
                double bitErrorRate = transmissionChannel->getBitErrorRate();
                double packetErrorRate = 1.0 - pow(1.0 - bitErrorRate, sourceInterfaceInfo->interfaceEntry->getMTU());
                return minLinkWeight - log(1 - packetErrorRate);
            }
            else
                return minLinkWeight;
        }
        else
            throw cRuntimeError("Unknown metric");
    }
}

double inet::NetworkConfiguratorBase::computeWirelessLinkWeight ( Link *  link, const char *  metric, cXMLElement *  parameters  )

protectedvirtual

{
    const char *costAttribute = parameters->getAttribute("cost");
    if (costAttribute != nullptr)
        return parseCostAttribute(costAttribute);
    else {
        if (!strcmp(metric, "hopCount"))
            return 1;
#ifdef WITH_RADIO
        else if (!strcmp(metric, "delay")) {
            // compute the delay between the two interfaces using a dummy transmission
            const InterfaceInfo *transmitterInterfaceInfo = link->sourceInterfaceInfo;
            const InterfaceInfo *receiverInterfaceInfo = link->destinationInterfaceInfo;
            cModule *transmitterInterfaceModule = transmitterInterfaceInfo->interfaceEntry->getInterfaceModule();
            cModule *receiverInterfaceModule = receiverInterfaceInfo->interfaceEntry->getInterfaceModule();
            const IRadio *transmitterRadio = check_and_cast<IRadio *>(transmitterInterfaceModule->getSubmodule("radio"));
            const IRadio *receiverRadio = check_and_cast<IRadio *>(receiverInterfaceModule->getSubmodule("radio"));
            const cPacket *macFrame = new cPacket();
            const IRadioMedium *radioMedium = receiverRadio->getMedium();
            const ITransmission *transmission = transmitterRadio->getTransmitter()->createTransmission(transmitterRadio, macFrame, simTime());
            const IArrival *arrival = radioMedium->getPropagation()->computeArrival(transmission, receiverRadio->getAntenna()->getMobility());
            return arrival->getStartPropagationTime().dbl();
        }
        else if (!strcmp(metric, "dataRate")) {
            cModule *transmitterInterfaceModule = link->sourceInterfaceInfo->interfaceEntry->getInterfaceModule();
            IRadio *transmitterRadio = check_and_cast<IRadio *>(transmitterInterfaceModule->getSubmodule("radio"));
            const FlatTransmitterBase *transmitter = dynamic_cast<const FlatTransmitterBase *>(transmitterRadio->getTransmitter());
            double dataRate = transmitter ? transmitter->getBitrate().get() : 0;
            return dataRate != 0 ? 1 / dataRate : minLinkWeight;
        }
        else if (!strcmp(metric, "errorRate")) {
            // compute the packet error rate between the two interfaces using a dummy transmission
            const InterfaceInfo *transmitterInterfaceInfo = link->sourceInterfaceInfo;
            const InterfaceInfo *receiverInterfaceInfo = link->destinationInterfaceInfo;
            cModule *transmitterInterfaceModule = transmitterInterfaceInfo->interfaceEntry->getInterfaceModule();
            cModule *receiverInterfaceModule = receiverInterfaceInfo->interfaceEntry->getInterfaceModule();
            const IRadio *transmitterRadio = check_and_cast<IRadio *>(transmitterInterfaceModule->getSubmodule("radio"));
            const IRadio *receiverRadio = check_and_cast<IRadio *>(receiverInterfaceModule->getSubmodule("radio"));
            const IRadioMedium *medium = receiverRadio->getMedium();
            cPacket *macFrame = new cPacket();
            macFrame->setByteLength(transmitterInterfaceInfo->interfaceEntry->getMTU());
            const ITransmission *transmission = transmitterRadio->getTransmitter()->createTransmission(transmitterRadio, macFrame, simTime());
            const IArrival *arrival = medium->getPropagation()->computeArrival(transmission, receiverRadio->getAntenna()->getMobility());
            const IListening *listening = receiverRadio->getReceiver()->createListening(receiverRadio, arrival->getStartTime(), arrival->getEndTime(), arrival->getStartPosition(), arrival->getEndPosition());
            const INoise *noise = medium->getBackgroundNoise() != nullptr ? medium->getBackgroundNoise()->computeNoise(listening) : nullptr;
            const IReception *reception = medium->getAnalogModel()->computeReception(receiverRadio, transmission, arrival);
            const IInterference *interference = new Interference(noise, new std::vector<const IReception *>());
            const ISNIR *snir = medium->getAnalogModel()->computeSNIR(reception, noise);
            const IReceiver *receiver = receiverRadio->getReceiver();
            const ReceptionIndication *receptionIndication = receiver->computeReceptionIndication(snir);
            bool isReceptionPossible = receiver->computeIsReceptionPossible(listening, reception, IRadioSignal::SIGNAL_PART_WHOLE);
            double packetErrorRate = isReceptionPossible ? receptionIndication->getPacketErrorRate() : 1;
            delete receptionIndication;
            delete snir;
            delete interference;
            delete reception;
            delete listening;
            delete arrival;
            delete transmission;
            delete macFrame;
            // we want to have a maximum PER product along the path,
            // but still minimize the hop count if the PER is negligible
            return minLinkWeight - log(1 - packetErrorRate);
        }
#endif
        else
            throw cRuntimeError("Unknown metric");
    }
}

NetworkConfiguratorBase::InterfaceInfo * inet::NetworkConfiguratorBase::createInterfaceInfo ( Topology &  topology, Node *  node, LinkInfo *  linkInfo, InterfaceEntry *  interfaceEntry  )

protectedvirtual

Reimplemented in inet::IPv4NetworkConfigurator.

{
    InterfaceInfo *interfaceInfo = new InterfaceInfo(node, linkInfo, ie);
    node->interfaceInfos.push_back(interfaceInfo);
    topology.interfaceInfos[ie] = interfaceInfo;
    return interfaceInfo;
}

NetworkConfiguratorBase::InterfaceInfo * inet::NetworkConfiguratorBase::determineGatewayForLink ( LinkInfo *  linkInfo )

protectedvirtual

If this link has exactly one node that connects to other links as well, we can assume it is a "gateway" and return that (we'll use it in routing); otherwise return nullptr.

{
    InterfaceInfo *gatewayInterfaceInfo = nullptr;
    for (auto & interfaceInfo : linkInfo->interfaceInfos) {
        IInterfaceTable *interfaceTable = interfaceInfo->node->interfaceTable;
        IRoutingTable *routingTable = interfaceInfo->node->routingTable;

        // count how many (non-loopback) interfaces this node has
        int numInterfaces = 0;
        for (int i = 0; i < interfaceTable->getNumInterfaces(); i++)
            if (!interfaceTable->getInterface(i)->isLoopback())
                numInterfaces++;


        if (numInterfaces > 1 && routingTable && routingTable->isForwardingEnabled()) {
            // node has at least one more interface, supposedly connecting to another link
            if (gatewayInterfaceInfo)
                return nullptr; // we already found one gateway, this makes it ambiguous! report "no gateway"
            else
                gatewayInterfaceInfo = interfaceInfo; // remember gateway
        }
    }
    return gatewayInterfaceInfo;
}

void inet::NetworkConfiguratorBase::dumpTopology ( Topology &  topology )

protectedvirtual

Referenced by inet::IPv4NetworkConfigurator::dumpConfiguration(), and inet::GenericNetworkConfigurator::initialize().

{
    for (int i = 0; i < topology.getNumNodes(); i++) {
        Node *node = (Node *)topology.getNode(i);
        EV_INFO << "Node " << node->module->getFullPath() << endl;
        for (int j = 0; j < node->getNumOutLinks(); j++) {
            Topology::LinkOut *linkOut = node->getLinkOut(j);
            ASSERT(linkOut->getLocalNode() == node);
            Node *remoteNode = (Node *)linkOut->getRemoteNode();
            EV_INFO << "     -> " << remoteNode->module->getFullPath() << endl;
        }
        for (int j = 0; j < node->getNumInLinks(); j++) {
            Topology::LinkIn *linkIn = node->getLinkIn(j);
            ASSERT(linkIn->getLocalNode() == node);
            Node *remoteNode = (Node *)linkIn->getRemoteNode();
            EV_INFO << "     <- " << remoteNode->module->getFullPath() << endl;
        }
    }
}

void inet::NetworkConfiguratorBase::extractDeviceNeighbors ( Topology &  topology, Node *  node, LinkInfo *  linkInfo, std::set< InterfaceEntry * > &  interfacesSeen, std::vector< Node * > &  deviceNodesVisited  )

protectedvirtual

{
    deviceNodesVisited.push_back(node);
    IInterfaceTable *interfaceTable = node->interfaceTable;
    if (interfaceTable) {
        // switch and access point
        for (int i = 0; i < interfaceTable->getNumInterfaces(); i++) {
            InterfaceEntry *interfaceEntry = interfaceTable->getInterface(i);
            if (!interfaceEntry->isLoopback() && interfacesSeen.count(interfaceEntry) == 0) {
                if (isWirelessInterface(interfaceEntry))
                    extractWirelessNeighbors(topology, getWirelessId(interfaceEntry), linkInfo, interfacesSeen, deviceNodesVisited);
                else {
                    Topology::LinkOut *linkOut = findLinkOut(node, interfaceEntry->getNodeOutputGateId());
                    if (linkOut)
                        extractWiredNeighbors(topology, linkOut, linkInfo, interfacesSeen, deviceNodesVisited);
                }
            }
        }
    }
    else {
        // hub and bus
        for (int i = 0; i < node->getNumOutLinks(); i++) {
            Topology::LinkOut *linkOut = node->getLinkOut(i);
            extractWiredNeighbors(topology, linkOut, linkInfo, interfacesSeen, deviceNodesVisited);
        }
    }
}

void inet::NetworkConfiguratorBase::extractTopology ( Topology &  topology )

protectedvirtual

Extracts network topology by walking through the module hierarchy.

Creates vertices from modules having property. Creates edges from connections (wired and wireless) between network interfaces.

Referenced by inet::IPv4NetworkConfigurator::computeConfiguration(), and inet::GenericNetworkConfigurator::initialize().

{
    // extract topology
    topology.extractByProperty("networkNode");
    EV_DEBUG << "Topology found " << topology.getNumNodes() << " nodes\n";

    // extract nodes, fill in interfaceTable and routingTable members in node
    for (int i = 0; i < topology.getNumNodes(); i++) {
        Node *node = (Node *)topology.getNode(i);
        cModule *module = node->getModule();
        node->module = module;
        node->interfaceTable = findInterfaceTable(node);
        node->routingTable = findRoutingTable(node);
    }

    // extract links and interfaces
    std::set<InterfaceEntry *> interfacesSeen;
    for (int i = 0; i < topology.getNumNodes(); i++) {
        Node *node = (Node *)topology.getNode(i);
        IInterfaceTable *interfaceTable = node->interfaceTable;
        if (interfaceTable) {
            for (int j = 0; j < interfaceTable->getNumInterfaces(); j++) {
                InterfaceEntry *interfaceEntry = interfaceTable->getInterface(j);
                if (!interfaceEntry->isLoopback() && interfacesSeen.count(interfaceEntry) == 0) {
                    if (isBridgeNode(node))
                        createInterfaceInfo(topology, node, nullptr, interfaceEntry);
                    else {
                        interfacesSeen.insert(interfaceEntry);
                        // create a new network link
                        LinkInfo *linkInfo = new LinkInfo();
                        topology.linkInfos.push_back(linkInfo);
                        // store interface as belonging to the new network link
                        InterfaceInfo *interfaceInfo = createInterfaceInfo(topology, node, isBridgeNode(node) ? nullptr : linkInfo, interfaceEntry);
                        linkInfo->interfaceInfos.push_back(interfaceInfo);
                        // visit neighbors (and potentially the whole LAN, recursively)
                        if (isWirelessInterface(interfaceEntry)) {
                            std::vector<Node *> empty;
                            const char *wirelessId = getWirelessId(interfaceEntry);
                            extractWirelessNeighbors(topology, wirelessId, linkInfo, interfacesSeen, empty);
                        }
                        else {
                            Topology::LinkOut *linkOut = findLinkOut(node, interfaceEntry->getNodeOutputGateId());
                            if (linkOut) {
                                std::vector<Node *> empty;
                                extractWiredNeighbors(topology, linkOut, linkInfo, interfacesSeen, empty);
                            }
                        }
                    }
                }
            }
        }
    }

    // annotate links with interfaces
    for (int i = 0; i < topology.getNumNodes(); i++) {
        Node *node = (Node *)topology.getNode(i);
        for (int j = 0; j < node->getNumOutLinks(); j++) {
            Topology::LinkOut *linkOut = node->getLinkOut(j);
            Link *link = (Link *)linkOut;
            Node *localNode = (Node *)linkOut->getLocalNode();
            if (localNode->interfaceTable)
                link->sourceInterfaceInfo = findInterfaceInfo(localNode, localNode->interfaceTable->getInterfaceByNodeOutputGateId(linkOut->getLocalGateId()));
            Node *remoteNode = (Node *)linkOut->getRemoteNode();
            if (remoteNode->interfaceTable)
                link->destinationInterfaceInfo = findInterfaceInfo(remoteNode, remoteNode->interfaceTable->getInterfaceByNodeInputGateId(linkOut->getRemoteGateId()));
        }
    }

    // collect wireless LAN interface infos into a map
    std::map<std::string, std::vector<InterfaceInfo *> > wirelessIdToInterfaceInfosMap;
    for (auto & entry : topology.interfaceInfos) {
        InterfaceInfo *interfaceInfo = entry.second;
        InterfaceEntry *interfaceEntry = interfaceInfo->interfaceEntry;
        if (!interfaceEntry->isLoopback() && isWirelessInterface(interfaceEntry)) {
            const char *wirelessId = getWirelessId(interfaceEntry);
            wirelessIdToInterfaceInfosMap[wirelessId].push_back(interfaceInfo);
        }
    }

    // add extra links between all pairs of wireless interfaces within a LAN (full graph)
    for (auto & entry : wirelessIdToInterfaceInfosMap) {
        std::vector<InterfaceInfo *>& interfaceInfos = entry.second;
        for (int i = 0; i < (int)interfaceInfos.size(); i++) {
            InterfaceInfo *interfaceInfoI = interfaceInfos.at(i);
            for (int j = i + 1; j < (int)interfaceInfos.size(); j++) {
                // assume bidirectional links
                InterfaceInfo *interfaceInfoJ = interfaceInfos.at(j);
                Link *linkIJ = new Link();
                linkIJ->sourceInterfaceInfo = interfaceInfoI;
                linkIJ->destinationInterfaceInfo = interfaceInfoJ;
                topology.addLink(linkIJ, interfaceInfoI->node, interfaceInfoJ->node);
                Link *linkJI = new Link();
                linkJI->sourceInterfaceInfo = interfaceInfoJ;
                linkJI->destinationInterfaceInfo = interfaceInfoI;
                topology.addLink(linkJI, interfaceInfoJ->node, interfaceInfoI->node);
            }
        }
    }

    // determine gatewayInterfaceInfo for all linkInfos
    for (auto & linkInfo : topology.linkInfos)
        linkInfo->gatewayInterfaceInfo = determineGatewayForLink(linkInfo);
}

void inet::NetworkConfiguratorBase::extractWiredNeighbors ( Topology &  topology, Topology::LinkOut *  linkOut, LinkInfo *  linkInfo, std::set< InterfaceEntry * > &  interfacesSeen, std::vector< Node * > &  nodesVisited  )

protectedvirtual

{
    Node *node = (Node *)linkOut->getRemoteNode();
    int inputGateId = linkOut->getRemoteGateId();
    IInterfaceTable *interfaceTable = node->interfaceTable;
    if (!isBridgeNode(node)) {
        InterfaceEntry *interfaceEntry = interfaceTable->getInterfaceByNodeInputGateId(inputGateId);
        if (!interfaceEntry) {
            // no such interface (node is probably down); we should probably get the information from our (future) internal database
        }
        else if (interfacesSeen.count(interfaceEntry) == 0) {
            InterfaceInfo *neighborInterfaceInfo = createInterfaceInfo(topology, node, linkInfo, interfaceEntry);
            linkInfo->interfaceInfos.push_back(neighborInterfaceInfo);
            interfacesSeen.insert(interfaceEntry);
        }
    }
    else {
        if (!contains(deviceNodesVisited, node))
            extractDeviceNeighbors(topology, node, linkInfo, interfacesSeen, deviceNodesVisited);
    }
}

void inet::NetworkConfiguratorBase::extractWirelessNeighbors ( Topology &  topology, const char *  wirelessId, LinkInfo *  linkInfo, std::set< InterfaceEntry * > &  interfacesSeen, std::vector< Node * > &  nodesVisited  )

protectedvirtual

{
    for (int nodeIndex = 0; nodeIndex < topology.getNumNodes(); nodeIndex++) {
        Node *node = (Node *)topology.getNode(nodeIndex);
        IInterfaceTable *interfaceTable = node->interfaceTable;
        if (interfaceTable) {
            for (int j = 0; j < interfaceTable->getNumInterfaces(); j++) {
                InterfaceEntry *interfaceEntry = interfaceTable->getInterface(j);
                if (!interfaceEntry->isLoopback() && interfacesSeen.count(interfaceEntry) == 0 && isWirelessInterface(interfaceEntry)) {
                    if (!strcmp(getWirelessId(interfaceEntry), wirelessId)) {
                        if (!isBridgeNode(node)) {
                            InterfaceInfo *interfaceInfo = createInterfaceInfo(topology, node, linkInfo, interfaceEntry);
                            linkInfo->interfaceInfos.push_back(interfaceInfo);
                            interfacesSeen.insert(interfaceEntry);
                        }
                        else {
                            if (!contains(deviceNodesVisited, node))
                                extractDeviceNeighbors(topology, node, linkInfo, interfacesSeen, deviceNodesVisited);
                        }
                    }
                }
            }
        }
    }
}

NetworkConfiguratorBase::InterfaceInfo * inet::NetworkConfiguratorBase::findInterfaceInfo ( Node *  node, InterfaceEntry *  interfaceEntry  )

protectedvirtual

{
    for (auto & interfaceInfo : node->interfaceInfos)
        if (interfaceInfo->interfaceEntry == interfaceEntry)
            return interfaceInfo;

    return nullptr;
}

IInterfaceTable * inet::NetworkConfiguratorBase::findInterfaceTable ( Node *  node )

protectedvirtual

{
    return L3AddressResolver::findInterfaceTableOf(node->module);
}

Topology::LinkOut * inet::NetworkConfiguratorBase::findLinkOut ( Node *  node, int  gateId  )

protectedvirtual

{
    for (int i = 0; i < node->getNumOutLinks(); i++)
        if (node->getLinkOut(i)->getLocalGateId() == gateId)
            return node->getLinkOut(i);

    return nullptr;
}

IRoutingTable * inet::NetworkConfiguratorBase::findRoutingTable ( Node *  node )

protectedvirtual

Reimplemented in inet::IPv4NetworkConfigurator, and inet::GenericNetworkConfigurator.

{
    return nullptr;
}

const char * inet::NetworkConfiguratorBase::getWirelessId ( InterfaceEntry *  interfaceEntry )

protectedvirtual

If this function returns the same string for two wireless interfaces, they will be regarded as being in the same wireless network.

(The actual value of the string doesn't count.)

{
    // use the configuration
    cModule *hostModule = interfaceEntry->getInterfaceTable()->getHostModule();
    std::string hostFullPath = hostModule->getFullPath();
    std::string hostShortenedFullPath = hostFullPath.substr(hostFullPath.find('.') + 1);
    cXMLElementList wirelessElements = configuration->getChildrenByTagName("wireless");
    for (auto & wirelessElement : wirelessElements) {
        const char *hostAttr = wirelessElement->getAttribute("hosts");    // "host* router[0..3]"
        const char *interfaceAttr = wirelessElement->getAttribute("interfaces");    // i.e. interface names, like "eth* ppp0"
        try {
            // parse host/interface expressions
            Matcher hostMatcher(hostAttr);
            Matcher interfaceMatcher(interfaceAttr);

            // Note: "hosts", "interfaces" must ALL match on the interface for the rule to apply
            if ((hostMatcher.matchesAny() || hostMatcher.matches(hostShortenedFullPath.c_str()) || hostMatcher.matches(hostFullPath.c_str())) &&
                (interfaceMatcher.matchesAny() || interfaceMatcher.matches(interfaceEntry->getFullName())))
            {
                const char *idAttr = wirelessElement->getAttribute("id");    // identifier of wireless connection
                return idAttr ? idAttr : wirelessElement->getSourceLocation();
            }
        }
        catch (std::exception& e) {
            throw cRuntimeError("Error in XML <wireless> element at %s: %s", wirelessElement->getSourceLocation(), e.what());
        }
    }
    cModule *interfaceModule = interfaceEntry->getInterfaceModule();
    cModule *mgmtModule = interfaceModule->getSubmodule("mgmt");
    if (mgmtModule != nullptr) {
        if (mgmtModule->hasPar("ssid") && *mgmtModule->par("ssid").stringValue())
            return mgmtModule->par("ssid");
        else if (mgmtModule->hasPar("accessPointAddress") && *mgmtModule->par("accessPointAddress").stringValue())
            return mgmtModule->par("accessPointAddress");
    }
    cModule *agentModule = interfaceModule->getSubmodule("agent");
    if (agentModule != nullptr) {
        if (agentModule->hasPar("default_ssid") && *agentModule->par("default_ssid").stringValue())
            return agentModule->par("default_ssid");
    }
#ifdef WITH_RADIO
    cModule *radioModule = interfaceModule->getSubmodule("radio");
    const IRadio *radio = dynamic_cast<const IRadio *>(radioModule);
    if (radio != nullptr) {
        const cModule *mediumModule = check_and_cast<const cModule *>(radio->getMedium());
        return mediumModule->getFullName();
    }
#endif

    // default: put all such wireless interfaces on the same LAN
    return "SSID";
}

virtual void inet::NetworkConfiguratorBase::handleMessage ( cMessage *  msg )

inlineoverrideprotectedvirtual

Reimplemented in inet::IPv4NetworkConfigurator.

{ throw cRuntimeError("this module doesn't handle messages, it runs only in initialize()"); }

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

overrideprotectedvirtual

Reimplemented in inet::IPv4NetworkConfigurator, and inet::GenericNetworkConfigurator.

Referenced by inet::GenericNetworkConfigurator::initialize(), and inet::IPv4NetworkConfigurator::initialize().

{
    if (stage == INITSTAGE_LOCAL) {
        minLinkWeight = par("minLinkWeight");
        configuration = par("config");
    }
}

bool inet::NetworkConfiguratorBase::isBridgeNode ( Node *  node )

protectedvirtual

Referenced by inet::GenericNetworkConfigurator::addStaticRoutes(), and inet::IPv4NetworkConfigurator::addStaticRoutes().

{
    return !node->routingTable || !node->interfaceTable;
}

bool inet::NetworkConfiguratorBase::isWirelessInterface ( InterfaceEntry *  interfaceEntry )

protectedvirtual

Referenced by inet::IPv4NetworkConfigurator::dumpConfig().

{
    return !strncmp(interfaceEntry->getName(), "wlan", 4);
}

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

inlineoverrideprotectedvirtual

Reimplemented in inet::IPv4NetworkConfigurator.

{ return NUM_INIT_STAGES; }

Member Data Documentation

cXMLElement* inet::NetworkConfiguratorBase::configuration = nullptr

protected

Referenced by inet::IPv4NetworkConfigurator::computeConfiguration(), inet::IPv4NetworkConfigurator::readInterfaceConfiguration(), inet::IPv4NetworkConfigurator::readManualMulticastRouteConfiguration(), inet::IPv4NetworkConfigurator::readManualRouteConfiguration(), and inet::IPv4NetworkConfigurator::readMulticastGroupConfiguration().

double inet::NetworkConfiguratorBase::minLinkWeight = NaN

protected

---

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

• NetworkConfiguratorBase.h
• NetworkConfiguratorBase.cc