inet::Ipv4FlatNetworkConfigurator Class Reference

Configures Ipv4 addresses and routing tables for a "flat" network, "flat" meaning that all hosts and routers will have the same network address. More...

#include <Ipv4FlatNetworkConfigurator.h>

Inheritance diagram for inet::Ipv4FlatNetworkConfigurator:

Classes
class	NodeInfo

Protected Types
typedef std::vector< NodeInfo >	NodeInfoVector

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
virtual void	extractTopology (cTopology &topo, NodeInfoVector &nodeInfo)
virtual void	assignAddresses (cTopology &topo, NodeInfoVector &nodeInfo)
virtual void	addDefaultRoutes (cTopology &topo, NodeInfoVector &nodeInfo)
virtual void	fillRoutingTables (cTopology &topo, NodeInfoVector &nodeInfo)
virtual void	setDisplayString (cTopology &topo, NodeInfoVector &nodeInfo)

Detailed Description

Configures Ipv4 addresses and routing tables for a "flat" network, "flat" meaning that all hosts and routers will have the same network address.

For more info please see the NED file.

Member Typedef Documentation

NodeInfoVector

typedef std::vector<NodeInfo> inet::Ipv4FlatNetworkConfigurator::NodeInfoVector

protected

Member Function Documentation

addDefaultRoutes()

void inet::Ipv4FlatNetworkConfigurator::addDefaultRoutes ( cTopology &  topo, NodeInfoVector &  nodeInfo  )

protectedvirtual

{
    // add default route to nodes with exactly one (non-loopback) interface
    for (int i = 0; i < topo.getNumNodes(); i++) {
        cTopology::Node *node = topo.getNode(i);
 
        // skip bus types
        if (!nodeInfo[i].isIPNode)
            continue;
 
        IInterfaceTable *ift = nodeInfo[i].ift;
        IIpv4RoutingTable *rt = nodeInfo[i].rt;
 
        // count non-loopback interfaces
        int numIntf = 0;
        NetworkInterface *ie = nullptr;
        for (int k = 0; k < ift->getNumInterfaces(); k++)
            if (!ift->getInterface(k)->isLoopback()) {
                ie = ift->getInterface(k);
                numIntf++;
            }
 
        nodeInfo[i].usesDefaultRoute = (numIntf == 1);
        if (numIntf != 1)
            continue; // only deal with nodes with one interface plus loopback
 
        EV_INFO << "  " << node->getModule()->getFullName() << "=" << nodeInfo[i].address
                << " has only one (non-loopback) interface, adding default route\n";
 
        // add route
        Ipv4Route *e = new Ipv4Route();
        e->setDestination(Ipv4Address());
        e->setNetmask(Ipv4Address());
        e->setInterface(ie);
        e->setSourceType(IRoute::MANUAL);
//        e->getMetric() = 1;
        rt->addRoute(e);
    }
}

Referenced by initialize().

assignAddresses()

void inet::Ipv4FlatNetworkConfigurator::assignAddresses ( cTopology &  topo, NodeInfoVector &  nodeInfo  )

protectedvirtual

{
    // assign Ipv4 addresses
    uint32_t networkAddress = Ipv4Address(par("networkAddress").stringValue()).getInt();
    uint32_t netmask = Ipv4Address(par("netmask").stringValue()).getInt();
    int maxNodes = (~netmask) - 1; // 0 and ffff have special meaning and cannot be used
    if (topo.getNumNodes() > maxNodes)
        throw cRuntimeError("netmask too large, not enough addresses for all %d nodes", topo.getNumNodes());
 
    int numIPNodes = 0;
    for (int i = 0; i < topo.getNumNodes(); i++) {
        // skip bus types
        if (!nodeInfo[i].isIPNode)
            continue;
 
        uint32_t addr = networkAddress | uint32_t(++numIPNodes);
        nodeInfo[i].address.set(addr);
 
        // find interface table and assign address to all (non-loopback) interfaces
        IInterfaceTable *ift = nodeInfo[i].ift;
        for (int k = 0; k < ift->getNumInterfaces(); k++) {
            NetworkInterface *ie = ift->getInterface(k);
            if (!ie->isLoopback()) {
                auto ipv4Data = ie->getProtocolDataForUpdate<Ipv4InterfaceData>();
                ipv4Data->setIPAddress(Ipv4Address(addr));
                ipv4Data->setNetmask(Ipv4Address::ALLONES_ADDRESS); // full address must match for local delivery
            }
        }
    }
}

Referenced by initialize().

extractTopology()

void inet::Ipv4FlatNetworkConfigurator::extractTopology ( cTopology &  topo, NodeInfoVector &  nodeInfo  )

protectedvirtual

{
    // extract topology
    topo.extractByProperty("networkNode");
    EV_DEBUG << "cTopology found " << topo.getNumNodes() << " nodes\n";
 
    // fill in isIPNode, ift and rt members in nodeInfo[]
    nodeInfo.resize(topo.getNumNodes());
    for (int i = 0; i < topo.getNumNodes(); i++) {
        cModule *mod = topo.getNode(i)->getModule();
        nodeInfo[i].isIPNode = L3AddressResolver().findIpv4RoutingTableOf(mod) != nullptr && L3AddressResolver().findInterfaceTableOf(mod) != nullptr;
        if (nodeInfo[i].isIPNode) {
            nodeInfo[i].ift = L3AddressResolver().interfaceTableOf(mod);
            nodeInfo[i].rt = L3AddressResolver().getIpv4RoutingTableOf(mod);
            nodeInfo[i].ipForwardEnabled = mod->hasPar("forwarding") ? mod->par("forwarding") : false;
            topo.getNode(i)->setWeight(nodeInfo[i].ipForwardEnabled ? 0.0 : INFINITY);
        }
    }
}

Referenced by initialize().

fillRoutingTables()

void inet::Ipv4FlatNetworkConfigurator::fillRoutingTables ( cTopology &  topo, NodeInfoVector &  nodeInfo  )

protectedvirtual

{
    // fill in routing tables with static routes
    for (int i = 0; i < topo.getNumNodes(); i++) {
        cTopology::Node *destNode = topo.getNode(i);
 
        // skip bus types
        if (!nodeInfo[i].isIPNode)
            continue;
 
        Ipv4Address destAddr = nodeInfo[i].address;
        std::string destModName = destNode->getModule()->getFullName();
 
        // calculate shortest paths from everywhere towards destNode
        topo.calculateWeightedSingleShortestPathsTo(destNode);
 
        // add route (with host=destNode) to every routing table in the network
        // (excepting nodes with only one interface -- there we'll set up a default route)
        for (int j = 0; j < topo.getNumNodes(); j++) {
            if (i == j)
                continue;
            if (!nodeInfo[j].isIPNode)
                continue;
 
            cTopology::Node *atNode = topo.getNode(j);
            if (atNode->getNumPaths() == 0)
                continue; // not connected
            if (nodeInfo[j].usesDefaultRoute)
                continue; // already added default route here
 
            Ipv4Address atAddr = nodeInfo[j].address;
 
            IInterfaceTable *ift = nodeInfo[j].ift;
 
            int outputGateId = atNode->getPath(0)->getLocalGate()->getId();
            NetworkInterface *ie = ift->findInterfaceByNodeOutputGateId(outputGateId);
            if (!ie)
                throw cRuntimeError("%s has no interface for output gate id %d", ift->getFullPath().c_str(), outputGateId);
 
            EV_INFO << "  from " << atNode->getModule()->getFullName() << "=" << Ipv4Address(atAddr);
            EV_INFO << " towards " << destModName << "=" << Ipv4Address(destAddr) << " interface " << ie->getInterfaceName() << endl;
 
            // add route
            IIpv4RoutingTable *rt = nodeInfo[j].rt;
            Ipv4Route *e = new Ipv4Route();
            e->setDestination(destAddr);
            e->setNetmask(Ipv4Address(255, 255, 255, 255)); // full match needed
            e->setInterface(ie);
            e->setSourceType(IRoute::MANUAL);
//            e->getMetric() = 1;
            rt->addRoute(e);
        }
    }
}

Referenced by initialize().

handleMessage()

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

overrideprotectedvirtual

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

initialize()

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);
 
    if (stage == INITSTAGE_NETWORK_CONFIGURATION) {
        cTopology topo("topo");
        NodeInfoVector nodeInfo; // will be of size topo.nodes[]
 
        // extract topology into the cTopology object, then fill in
        // isIPNode, rt and ift members of nodeInfo[]
        extractTopology(topo, nodeInfo);
 
        // assign addresses to Ipv4 nodes, and also store result in nodeInfo[].address
        assignAddresses(topo, nodeInfo);
 
        // add default routes to hosts (nodes with a single attachment);
        // also remember result in nodeInfo[].usesDefaultRoute
        addDefaultRoutes(topo, nodeInfo);
 
        // calculate shortest paths, and add corresponding static routes
        fillRoutingTables(topo, nodeInfo);
 
        // update display string
        setDisplayString(topo, nodeInfo);
    }
}

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

setDisplayString()

void inet::Ipv4FlatNetworkConfigurator::setDisplayString ( cTopology &  topo, NodeInfoVector &  nodeInfo  )

protectedvirtual

{
    int numIPNodes = 0;
    for (int i = 0; i < topo.getNumNodes(); i++)
        if (nodeInfo[i].isIPNode)
            numIPNodes++;
 
    // update display string
    char buf[80];
    sprintf(buf, "%d Ipv4 nodes\n%d non-Ipv4 nodes", numIPNodes, topo.getNumNodes() - numIPNodes);
    getDisplayString().setTagArg("t", 0, buf);
}

Referenced by initialize().

---

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

• Ipv4FlatNetworkConfigurator.h
• Ipv4FlatNetworkConfigurator.cc