inet::L3NetworkConfiguratorBase Class Reference

#include <L3NetworkConfiguratorBase.h>

Inheritance diagram for inet::L3NetworkConfiguratorBase:

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::Link *linkOut, LinkInfo *linkInfo, std::map< int, NetworkInterface * > &interfacesSeen, std::vector< Node * > &nodesVisited)
virtual void	extractWirelessNeighbors (Topology &topology, const char *wirelessId, LinkInfo *linkInfo, std::map< int, NetworkInterface * > &interfacesSeen, std::vector< Node * > &nodesVisited)
virtual void	extractDeviceNeighbors (Topology &topology, Node *node, LinkInfo *linkInfo, std::map< int, NetworkInterface * > &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 (NetworkInterface *networkInterface)
virtual std::string	getWirelessId (NetworkInterface *networkInterface)
	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, NetworkInterface *networkInterface)
virtual Topology::Link *	findLinkOut (Node *node, int gateId)
virtual InterfaceInfo *	findInterfaceInfo (Node *node, NetworkInterface *networkInterface)
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, NetworkInterface *ie, bool mask)
virtual bool	getInterfaceIpv6Address (L3Address &ret, NetworkInterface *ie, bool mask)
virtual bool	getInterfaceMacAddress (L3Address &ret, NetworkInterface *ie, bool mask)
virtual bool	getInterfaceModulePathAddress (L3Address &ret, NetworkInterface *ie, bool mask)
virtual bool	getInterfaceModuleIdAddress (L3Address &ret, NetworkInterface *ie, bool mask)
virtual void	doCollectNetworkNodes (cModule *parent, std::vector< cModule * > &result)

Protected Attributes
double	minLinkWeight = NaN
bool	configureIsolatedNetworksSeparatly = false
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...
bool	tryParse (L3Address &result, const char *addr, int addrType=DEFAULT_ADDR_TYPE)
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 (NetworkInterface *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 *	getIpv4RoutingTableOf (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 *	getIpv6RoutingTableOf (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 NextHopRoutingTable *	findNextHopRoutingTableOf (cModule *host)
	Like interfaceTableOf(), but doesn't throw error if not found. More...
virtual std::vector< cModule * >	collectNetworkNodes ()
	Collect modules that represent network nodes, as denoted by the @networkNode(true) annotation. More...
virtual cModule *	findHostWithAddress (const L3Address &addr)
	Find the Host with the specified address. More...
virtual NetworkInterface *	findInterfaceWithMacAddress (const MacAddress &addr)
	Find the interface with the specified MAC address. More...
virtual cModule *	findHostWithMacAddress (const MacAddress &addr)
	Find the host with the specified MAC address. More...

Member Function Documentation

computeLinkWeight()

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

protectedvirtual

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

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

computeNodeWeight()

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

protectedvirtual

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

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

computeWiredLinkWeight()

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

protectedvirtual

{
    const char *costAttribute = parameters->getAttribute("cost");
    if (costAttribute != nullptr)
        return parseCostAttribute(costAttribute);
    else {
        Topology::Link *linkOut = static_cast<Topology::Link *>(static_cast<Topology::Link *>(link));
        if (!strcmp(metric, "hopCount"))
            return 1;
        else if (!strcmp(metric, "delay")) {
            cDatarateChannel *transmissionChannel = dynamic_cast<cDatarateChannel *>(linkOut->getLinkOutLocalGate()->findTransmissionChannel());
            if (transmissionChannel != nullptr)
                return transmissionChannel->getDelay().dbl();
            else
                return minLinkWeight;
        }
        else if (!strcmp(metric, "dataRate")) {
            cChannel *transmissionChannel = linkOut->getLinkOutLocalGate()->findTransmissionChannel();
            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->getLinkOutLocalGate()->findTransmissionChannel());
            if (transmissionChannel != nullptr) {
                InterfaceInfo *sourceInterfaceInfo = link->sourceInterfaceInfo;
                double bitErrorRate = transmissionChannel->getBitErrorRate();
                double packetErrorRate = 1.0 - pow(1.0 - bitErrorRate, sourceInterfaceInfo->networkInterface->getMtu());
                return minLinkWeight - log(1 - packetErrorRate);
            }
            else
                return minLinkWeight;
        }
        else
            throw cRuntimeError("Unknown metric");
    }
}

computeWirelessLinkWeight()

double inet::L3NetworkConfiguratorBase::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 INET_WITH_PHYSICALLAYERWIRELESSCOMMON
        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->networkInterface;
            cModule *receiverInterfaceModule = receiverInterfaceInfo->networkInterface;
            const IRadio *transmitterRadio = check_and_cast<IRadio *>(transmitterInterfaceModule->getSubmodule("radio"));
            const IRadio *receiverRadio = check_and_cast<IRadio *>(receiverInterfaceModule->getSubmodule("radio"));
            const Packet *macFrame = new Packet();
            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->networkInterface;
            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->networkInterface;
            cModule *receiverInterfaceModule = receiverInterfaceInfo->networkInterface;
            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();
            Packet *transmittedFrame = new Packet();
            auto byteCountChunk = makeShared<ByteCountChunk>(B(transmitterInterfaceInfo->networkInterface->getMtu()));
            transmittedFrame->insertAtBack(byteCountChunk);
 
            // KLUDGE
            transmittedFrame->addTag<PacketProtocolTag>()->setProtocol(&Protocol::ackingMac);
            check_and_cast<const Radio *>(transmitterRadio)->encapsulate(transmittedFrame);
 
            const ITransmission *transmission = transmitterRadio->getTransmitter()->createTransmission(transmitterRadio, transmittedFrame, 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();
            bool isReceptionPossible = receiver->computeIsReceptionPossible(listening, reception, IRadioSignal::SIGNAL_PART_WHOLE);
            double packetErrorRate;
            if (!isReceptionPossible)
                packetErrorRate = 1;
            else {
                const IReceptionDecision *receptionDecision = new ReceptionDecision(reception, IRadioSignal::SIGNAL_PART_WHOLE, isReceptionPossible, true, true);
                const std::vector<const IReceptionDecision *> *receptionDecisions = new std::vector<const IReceptionDecision *> { receptionDecision };
                const IReceptionResult *receptionResult = receiver->computeReceptionResult(listening, reception, interference, snir, receptionDecisions);
                Packet *receivedFrame = const_cast<Packet *>(receptionResult->getPacket());
                packetErrorRate = receivedFrame->getTag<ErrorRateInd>()->getPacketErrorRate();
                delete receptionResult;
                delete receptionDecision;
            }
            delete snir;
            delete interference;
            delete reception;
            delete listening;
            delete arrival;
            delete transmission;
            delete transmittedFrame;
            // 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");
    }
}

createInterfaceInfo()

L3NetworkConfiguratorBase::InterfaceInfo * inet::L3NetworkConfiguratorBase::createInterfaceInfo ( Topology &  topology, Node *  node, LinkInfo *  linkInfo, NetworkInterface *  networkInterface  )

protectedvirtual

Reimplemented in inet::Ipv4NetworkConfigurator.

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

determineGatewayForLink()

L3NetworkConfiguratorBase::InterfaceInfo * inet::L3NetworkConfiguratorBase::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;
}

dumpTopology()

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

protectedvirtual

{
    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::Link *linkOut = node->getLinkOut(j);
            ASSERT(linkOut->getLinkOutLocalNode() == node);
            Node *remoteNode = (Node *)linkOut->getLinkOutRemoteNode();
            EV_INFO << "     -> " << remoteNode->module->getFullPath() << endl;
        }
        for (int j = 0; j < node->getNumInLinks(); j++) {
            Topology::Link *linkIn = node->getLinkIn(j);
            ASSERT(linkIn->getLinkInLocalNode() == node);
            Node *remoteNode = (Node *)linkIn->getLinkInRemoteNode();
            EV_INFO << "     <- " << remoteNode->module->getFullPath() << endl;
        }
    }
}

Referenced by inet::Ipv4NetworkConfigurator::dumpConfiguration(), and inet::NextHopNetworkConfigurator::initialize().

extractDeviceNeighbors()

void inet::L3NetworkConfiguratorBase::extractDeviceNeighbors ( Topology &  topology, Node *  node, LinkInfo *  linkInfo, std::map< int, NetworkInterface * > &  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++) {
            NetworkInterface *networkInterface = interfaceTable->getInterface(i);
            if (!networkInterface->isLoopback() && !containsKey(interfacesSeen, networkInterface->getId())) {
                if (isWirelessInterface(networkInterface))
                    extractWirelessNeighbors(topology, getWirelessId(networkInterface).c_str(), linkInfo, interfacesSeen, deviceNodesVisited);
                else {
                    Topology::Link *linkOut = findLinkOut(node, networkInterface->getNodeOutputGateId());
                    if (linkOut)
                        extractWiredNeighbors(topology, linkOut, linkInfo, interfacesSeen, deviceNodesVisited);
                }
            }
        }
    }
    else {
        // hub and bus
        for (int i = 0; i < node->getNumOutLinks(); i++) {
            Topology::Link *linkOut = node->getLinkOut(i);
            extractWiredNeighbors(topology, linkOut, linkInfo, interfacesSeen, deviceNodesVisited);
        }
    }
}

extractTopology()

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

protectedvirtual

Extracts network topology by walking through the module hierarchy.

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

{
    // extract topology
    topology.extractByProperty("networkNode");
    EV_DEBUG << "Topology found " << topology.getNumNodes() << " nodes\n";
 
    // print isolated networks information
    std::map<int, std::vector<Node *>> isolatedNetworks;
    for (int i = 0; i < topology.getNumNodes(); i++) {
        Node *node = (Node *)topology.getNode(i);
        int networkId = node->getNetworkId();
        auto networkNodes = isolatedNetworks.find(networkId);
        if (networkNodes == isolatedNetworks.end()) {
            std::vector<Node *> collection = { node };
            isolatedNetworks[networkId] = collection;
        }
        else
            networkNodes->second.push_back(node);
    }
    if (isolatedNetworks.size() == 1)
        EV_DEBUG << "All network nodes belong to a connected network.\n";
    else
        EV_DEBUG << "There exists " << isolatedNetworks.size() << " isolated networks.\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::map<int, NetworkInterface *> 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++) {
                NetworkInterface *networkInterface = interfaceTable->getInterface(j);
                if (!networkInterface->isLoopback() && !containsKey(interfacesSeen, networkInterface->getId())) {
                    if (isBridgeNode(node))
                        createInterfaceInfo(topology, node, nullptr, networkInterface);
                    else {
                        interfacesSeen[networkInterface->getId()] = networkInterface;
                        // create a new network link
                        LinkInfo *linkInfo = new LinkInfo();
                        linkInfo->networkId = node->getNetworkId();
                        topology.linkInfos.push_back(linkInfo);
                        // store interface as belonging to the new network link
                        InterfaceInfo *interfaceInfo = createInterfaceInfo(topology, node, isBridgeNode(node) ? nullptr : linkInfo, networkInterface);
                        linkInfo->interfaceInfos.push_back(interfaceInfo);
                        // visit neighbors (and potentially the whole LAN, recursively)
                        if (isWirelessInterface(networkInterface)) {
                            std::vector<Node *> empty;
                            auto wirelessId = getWirelessId(networkInterface);
                            extractWirelessNeighbors(topology, wirelessId.c_str(), linkInfo, interfacesSeen, empty);
                        }
                        else {
                            Topology::Link *linkOut = findLinkOut(node, networkInterface->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::Link *linkOut = node->getLinkOut(j);
            Link *link = (Link *)linkOut;
            Node *localNode = (Node *)linkOut->getLinkOutLocalNode();
            if (localNode->interfaceTable)
                link->sourceInterfaceInfo = findInterfaceInfo(localNode, localNode->interfaceTable->findInterfaceByNodeOutputGateId(linkOut->getLinkOutLocalGateId()));
            Node *remoteNode = (Node *)linkOut->getLinkOutRemoteNode();
            if (remoteNode->interfaceTable)
                link->destinationInterfaceInfo = findInterfaceInfo(remoteNode, remoteNode->interfaceTable->findInterfaceByNodeInputGateId(linkOut->getLinkOutRemoteGateId()));
        }
    }
 
    // 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;
        NetworkInterface *networkInterface = interfaceInfo->networkInterface;
        if (!networkInterface->isLoopback() && isWirelessInterface(networkInterface)) {
            auto wirelessId = getWirelessId(networkInterface);
            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 (size_t i = 0; i < interfaceInfos.size(); i++) {
            InterfaceInfo *interfaceInfoI = interfaceInfos.at(i);
            for (size_t j = i + 1; j < 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);
}

Referenced by inet::Ipv4NetworkConfigurator::computeConfiguration(), and inet::NextHopNetworkConfigurator::initialize().

extractWiredNeighbors()

void inet::L3NetworkConfiguratorBase::extractWiredNeighbors ( Topology &  topology, Topology::Link *  linkOut, LinkInfo *  linkInfo, std::map< int, NetworkInterface * > &  interfacesSeen, std::vector< Node * > &  nodesVisited  )

protectedvirtual

{
    Node *node = (Node *)linkOut->getLinkOutRemoteNode();
    int inputGateId = linkOut->getLinkOutRemoteGateId();
    IInterfaceTable *interfaceTable = node->interfaceTable;
    if (!isBridgeNode(node)) {
        NetworkInterface *networkInterface = interfaceTable->findInterfaceByNodeInputGateId(inputGateId);
        if (!networkInterface) {
            // no such interface (node is probably down); we should probably get the information from our (future) internal database
        }
        else if (!containsKey(interfacesSeen, networkInterface->getId())) {
            InterfaceInfo *neighborInterfaceInfo = createInterfaceInfo(topology, node, linkInfo, networkInterface);
            linkInfo->interfaceInfos.push_back(neighborInterfaceInfo);
            interfacesSeen[networkInterface->getId()] = networkInterface;
        }
    }
    else {
        if (!contains(deviceNodesVisited, node))
            extractDeviceNeighbors(topology, node, linkInfo, interfacesSeen, deviceNodesVisited);
    }
}

extractWirelessNeighbors()

void inet::L3NetworkConfiguratorBase::extractWirelessNeighbors ( Topology &  topology, const char *  wirelessId, LinkInfo *  linkInfo, std::map< int, NetworkInterface * > &  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++) {
                NetworkInterface *networkInterface = interfaceTable->getInterface(j);
                if (!networkInterface->isLoopback() && !containsKey(interfacesSeen, networkInterface->getId()) && isWirelessInterface(networkInterface)) {
                    if (getWirelessId(networkInterface) == wirelessId) {
                        if (!isBridgeNode(node)) {
                            InterfaceInfo *interfaceInfo = createInterfaceInfo(topology, node, linkInfo, networkInterface);
                            linkInfo->interfaceInfos.push_back(interfaceInfo);
                            interfacesSeen[networkInterface->getId()] = networkInterface;
                        }
                        else {
                            if (!contains(deviceNodesVisited, node))
                                extractDeviceNeighbors(topology, node, linkInfo, interfacesSeen, deviceNodesVisited);
                        }
                    }
                }
            }
        }
    }
}

findInterfaceInfo()

L3NetworkConfiguratorBase::InterfaceInfo * inet::L3NetworkConfiguratorBase::findInterfaceInfo ( Node *  node, NetworkInterface *  networkInterface  )

protectedvirtual

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

findInterfaceTable()

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

protectedvirtual

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

findLinkOut()

Topology::Link * inet::L3NetworkConfiguratorBase::findLinkOut ( Node *  node, int  gateId  )

protectedvirtual

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

findRoutingTable()

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

protectedvirtual

Reimplemented in inet::NextHopNetworkConfigurator, and inet::Ipv4NetworkConfigurator.

{
    return nullptr;
}

getWirelessId()

std::string inet::L3NetworkConfiguratorBase::getWirelessId ( NetworkInterface *  networkInterface )

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 = networkInterface->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(networkInterface->getInterfaceName())))
            {
                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());
        }
    }
#if defined(INET_WITH_IEEE80211) || defined(INET_WITH_PHYSICALLAYERWIRELESSCOMMON)
    cModule *interfaceModule = networkInterface;
#ifdef INET_WITH_IEEE80211
    if (auto mibModule = dynamic_cast<ieee80211::Ieee80211Mib *>(interfaceModule->getSubmodule("mib"))) {
        auto ssid = mibModule->bssData.ssid;
        if (ssid.length() != 0)
            return ssid;
    }
    cModule *mgmtModule = interfaceModule->getSubmodule("mgmt");
    if (mgmtModule != nullptr && mgmtModule->hasPar("ssid")) {
        const char *value = mgmtModule->par("ssid");
        if (*value)
            return value;
    }
    cModule *agentModule = interfaceModule->getSubmodule("agent");
    if (agentModule != nullptr && agentModule->hasPar("defaultSsid")) {
        const char *value = agentModule->par("defaultSsid");
        if (*value)
            return value;
    }
#endif // INET_WITH_IEEE80211
#ifdef INET_WITH_PHYSICALLAYERWIRELESSCOMMON
    cModule *radioModule = interfaceModule->getSubmodule("radio");
    const IRadio *radio = dynamic_cast<const IRadio *>(radioModule);
    if (radio != nullptr) {
        const cModule *mediumModule = dynamic_cast<const cModule *>(radio->getMedium());
        if (mediumModule != nullptr)
            return mediumModule->getFullName();
    }
#endif // INET_WITH_PHYSICALLAYERWIRELESSCOMMON
#endif // defined(INET_WITH_IEEE80211) || defined(INET_WITH_PHYSICALLAYERWIRELESSCOMMON)
 
    // default: put all such wireless interfaces on the same LAN
    return "SSID";
}

handleMessage()

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

inlineoverrideprotectedvirtual

Reimplemented in inet::Ipv4NetworkConfigurator.

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

initialize()

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

overrideprotectedvirtual

Reimplemented in inet::Ipv4NetworkConfigurator, and inet::NextHopNetworkConfigurator.

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

Referenced by inet::NextHopNetworkConfigurator::initialize(), and inet::Ipv4NetworkConfigurator::initialize().

isBridgeNode()

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

protectedvirtual

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

Referenced by inet::NextHopNetworkConfigurator::addStaticRoutes(), and inet::Ipv4NetworkConfigurator::addStaticRoutes().

isWirelessInterface()

bool inet::L3NetworkConfiguratorBase::isWirelessInterface ( NetworkInterface *  networkInterface )

protectedvirtual

{
    return !strncmp(networkInterface->getInterfaceName(), "wlan", 4);
}

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

numInitStages()

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

inlineoverrideprotectedvirtual

Reimplemented in inet::Ipv4NetworkConfigurator.

{ return NUM_INIT_STAGES; }

Member Data Documentation

configuration

cXMLElement* inet::L3NetworkConfiguratorBase::configuration = nullptr

protected

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

configureIsolatedNetworksSeparatly

bool inet::L3NetworkConfiguratorBase::configureIsolatedNetworksSeparatly = false

protected

Referenced by inet::Ipv4NetworkConfigurator::assignAddresses().

minLinkWeight

double inet::L3NetworkConfiguratorBase::minLinkWeight = NaN

protected

---

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

• L3NetworkConfiguratorBase.h
• L3NetworkConfiguratorBase.cc