inet::GenericRoutingTable Class Reference

A C++ interface to abstract the functionality of a routing table, regardless of address type. More...

#include <GenericRoutingTable.h>

Inheritance diagram for inet::GenericRoutingTable:

Public Member Functions
	GenericRoutingTable ()
virtual	~GenericRoutingTable ()
virtual IRoute *	createRoute () override
virtual void	printRoutingTable () const override
	Prints routing table. More...
Miscellaneous functions
virtual bool	isForwardingEnabled () const override
	Forwarding on/off. More...
virtual bool	isMulticastForwardingEnabled () const override
	Multicast forwarding on/off. More...
virtual L3Address	getRouterIdAsGeneric () const override
	Returns routerId. More...
virtual bool	isLocalAddress (const L3Address &dest) const override
	Checks if the address is a local one, i.e. More...
virtual InterfaceEntry *	getInterfaceByAddress (const L3Address &address) const override
	Returns an interface given by its address. More...
virtual void	routeChanged (GenericRoute *entry, int fieldCode)
	To be called from route objects whenever a field changes. More...
Routing functions (query the route table)
virtual GenericRoute *	findBestMatchingRoute (const L3Address &dest) const override
	The routing function. More...
virtual InterfaceEntry *	getOutputInterfaceForDestination (const L3Address &dest) const override
	Convenience function based on findBestMatchingRoute(). More...
virtual L3Address	getNextHopForDestination (const L3Address &dest) const override
	Convenience function based on findBestMatchingRoute(). More...
Multicast routing functions
virtual bool	isLocalMulticastAddress (const L3Address &dest) const override
	Checks if the address is in one of the local multicast group address list. More...
virtual IMulticastRoute *	findBestMatchingMulticastRoute (const L3Address &origin, const L3Address &group) const override
	Returns route for a multicast origin and group. More...
Route table manipulation
virtual int	getNumRoutes () const override
	Returns the total number of unicast routes. More...
virtual IRoute *	getRoute (int k) const override
	Returns the kth route. More...
virtual IRoute *	getDefaultRoute () const override
	Finds and returns the default route, or nullptr if it doesn't exist. More...
virtual void	addRoute (IRoute *entry) override
	Adds a route to the routing table. More...
virtual IRoute *	removeRoute (IRoute *entry) override
	Removes the given route from the routing table, and returns it. More...
virtual bool	deleteRoute (IRoute *entry) override
	Deletes the given route from the routing table. More...
virtual int	getNumMulticastRoutes () const override
	Returns the total number of multicast routes. More...
virtual IMulticastRoute *	getMulticastRoute (int k) const override
	Returns the kth multicast route. More...
virtual void	addMulticastRoute (IMulticastRoute *entry) override
	Adds a multicast route to the routing table. More...
virtual IMulticastRoute *	removeMulticastRoute (IMulticastRoute *entry) override
	Removes the given route from the routing table, and returns it. More...
virtual bool	deleteMulticastRoute (IMulticastRoute *entry) override
	Deletes the given multicast route from the routing table. More...
Public Member Functions inherited from inet::IRoutingTable
virtual	~IRoutingTable ()

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *) override
	Raises an error. More...
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
	Called by the signal handler whenever a change of a category occurs to which this client has subscribed. More...
virtual void	configureRouterId ()
virtual void	refreshDisplay () const override
virtual void	configureInterface (InterfaceEntry *ie)
virtual void	configureLoopback ()
void	internalAddRoute (GenericRoute *route)
GenericRoute *	internalRemoveRoute (GenericRoute *route)

Static Protected Member Functions
static bool	routeLessThan (const GenericRoute *a, const GenericRoute *b)

Private Types
typedef std::vector< GenericRoute * >	RouteVector
typedef std::vector< GenericMulticastRoute * >	MulticastRouteVector

Private Attributes
IInterfaceTable *	ift = nullptr
L3Address	routerId
L3Address::AddressType	addressType = L3Address::NONE
bool	forwarding = false
bool	multicastForwarding = false
RouteVector	routes
MulticastRouteVector	multicastRoutes

Detailed Description

A C++ interface to abstract the functionality of a routing table, regardless of address type.

Member Typedef Documentation

typedef std::vector<GenericMulticastRoute *> inet::GenericRoutingTable::MulticastRouteVector

private

typedef std::vector<GenericRoute *> inet::GenericRoutingTable::RouteVector

private

Constructor & Destructor Documentation

inet::GenericRoutingTable::GenericRoutingTable

(

)

{
}

inet::GenericRoutingTable::~GenericRoutingTable ( )

virtual

{
    for (auto & elem : routes)
        delete elem;
    for (auto & elem : multicastRoutes)
        delete elem;
}

Member Function Documentation

void inet::GenericRoutingTable::addMulticastRoute ( IMulticastRoute *  entry )

overridevirtual

Adds a multicast route to the routing table.

Routes are allowed to be modified while in the routing table. (There is a notification mechanism that allows routing table internals to be updated on a routing entry change.)

Implements inet::IRoutingTable.

{
    //TODO
}

void inet::GenericRoutingTable::addRoute ( IRoute *  entry )

overridevirtual

Adds a route to the routing table.

Routes are allowed to be modified while in the routing table. (There is a notification mechanism that allows routing table internals to be updated on a routing entry change.)

Implements inet::IRoutingTable.

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

{
    Enter_Method("addRoute(...)");

    GenericRoute *entry = check_and_cast<GenericRoute *>(route);

    // check that the interface exists
    if (!entry->getInterface())
        throw cRuntimeError("addRoute(): interface cannot be nullptr");

    internalAddRoute(entry);

    emit(NF_ROUTE_ADDED, entry);
}

void inet::GenericRoutingTable::configureInterface ( InterfaceEntry *  ie )

protectedvirtual

Referenced by initialize().

{
    int metric = (int)(ceil(2e9 / ie->getDatarate()));    // use OSPF cost as default
    int interfaceModuleId = ie->getInterfaceModule() ? ie->getInterfaceModule()->getId() : -1;
    // mac
    GenericNetworkProtocolInterfaceData *d = new GenericNetworkProtocolInterfaceData();
    d->setMetric(metric);
    if (addressType == L3Address::MAC)
        d->setAddress(ie->getMacAddress());
    else if (ie->getInterfaceModule() && addressType == L3Address::MODULEPATH)
        d->setAddress(ModulePathAddress(interfaceModuleId));
    else if (ie->getInterfaceModule() && addressType == L3Address::MODULEID)
        d->setAddress(ModuleIdAddress(interfaceModuleId));
    ie->setGenericNetworkProtocolData(d);
}

void inet::GenericRoutingTable::configureLoopback ( )

protectedvirtual

Referenced by initialize().

{
//TODO needed???
//    InterfaceEntry *ie = ift->getFirstLoopbackInterface()
//    // add IPv4 info. Set 127.0.0.1/8 as address by default --
//    // we may reconfigure later it to be the routerId
//    IPv4InterfaceData *d = new IPv4InterfaceData();
//    d->setIPAddress(IPv4Address::LOOPBACK_ADDRESS);
//    d->setNetmask(IPv4Address::LOOPBACK_NETMASK);
//    d->setMetric(1);
//    ie->setIPv4Data(d);
}

void inet::GenericRoutingTable::configureRouterId ( )

protectedvirtual

Referenced by initialize().

{
    if (routerId.isUnspecified()) {    // not yet configured
        const char *routerIdStr = par("routerId").stringValue();
        if (!strcmp(routerIdStr, "auto")) {    // non-"auto" cases already handled in earlier stage
            // choose highest interface address as routerId
            for (int i = 0; i < ift->getNumInterfaces(); ++i) {
                InterfaceEntry *ie = ift->getInterface(i);
                if (!ie->isLoopback()) {
                    L3Address interfaceAddr = ie->getGenericNetworkProtocolData()->getAddress();
                    if (routerId.isUnspecified() || routerId < interfaceAddr)
                        routerId = interfaceAddr;
                }
            }
        }
    }
//    else // already configured
//    {
//        // if there is no interface with routerId yet, assign it to the loopback address;
//        // TODO find out if this is a good practice, in which situations it is useful etc.
//        if (getInterfaceByAddress(routerId)==nullptr)
//        {
//            InterfaceEntry *lo0 = ift->getFirstLoopbackInterface();
//            lo0->getGenericNetworkProtocolData()->setAddress(routerId);
//        }
//    }
}

IRoute * inet::GenericRoutingTable::createRoute ( )

overridevirtual

Implements inet::IRoutingTable.

{
    return new GenericRoute();
}

bool inet::GenericRoutingTable::deleteMulticastRoute ( IMulticastRoute *  entry )

overridevirtual

Deletes the given multicast route from the routing table.

Returns true if the route was deleted, and false if it was not in the routing table.

Implements inet::IRoutingTable.

{
    return false;    //TODO
}

bool inet::GenericRoutingTable::deleteRoute ( IRoute *  entry )

overridevirtual

Deletes the given route from the routing table.

Returns true if the route was deleted, and false if it was not in the routing table.

Implements inet::IRoutingTable.

{
    IRoute *route = removeRoute(entry);
    delete route;
    return route != nullptr;
}

IMulticastRoute * inet::GenericRoutingTable::findBestMatchingMulticastRoute ( const L3Address &  origin, const L3Address &  group  ) const

overridevirtual

Returns route for a multicast origin and group.

Implements inet::IRoutingTable.

{
    return nullptr;    //TODO
}

GenericRoute * inet::GenericRoutingTable::findBestMatchingRoute ( const L3Address &  dest ) const

overridevirtual

The routing function.

Performs longest prefix match for the given destination address, and returns the resulting route. Returns nullptr if there is no matching route.

Implements inet::IRoutingTable.

Referenced by getNextHopForDestination(), getOutputInterfaceForDestination(), and inet::GenericNetworkProtocol::routePacket().

{
    //TODO Enter_Method("findBestMatchingRoute(%u.%u.%u.%u)", dest.getDByte(0), dest.getDByte(1), dest.getDByte(2), dest.getDByte(3)); // note: str().c_str() too slow here

    // find best match (one with longest prefix)
    // default route has zero prefix length, so (if exists) it'll be selected as last resort
    GenericRoute *bestRoute = nullptr;
    for (auto e : routes) {

        if (dest.matches(e->getDestinationAsGeneric(), e->getPrefixLength())) {
            bestRoute = const_cast<GenericRoute *>(e);
            break;
        }
    }
    return bestRoute;
}

IRoute * inet::GenericRoutingTable::getDefaultRoute ( ) const

overridevirtual

Finds and returns the default route, or nullptr if it doesn't exist.

Implements inet::IRoutingTable.

{
    // if there is a default route entry, it is the last valid entry
    auto i = routes.rbegin();
    if (i != routes.rend() && (*i)->getPrefixLength() == 0)
        return *i;
    return nullptr;
}

InterfaceEntry * inet::GenericRoutingTable::getInterfaceByAddress ( const L3Address &  address ) const

overridevirtual

Returns an interface given by its address.

Returns nullptr if not found.

Implements inet::IRoutingTable.

Referenced by inet::GenericNetworkProtocol::encapsulate().

{
    // collect interface addresses if not yet done
    for (int i = 0; i < ift->getNumInterfaces(); i++) {
        InterfaceEntry *ie = ift->getInterface(i);
        L3Address interfaceAddr = ie->getGenericNetworkProtocolData()->getAddress();
        if (interfaceAddr == address)
            return ie;
    }
    return nullptr;
}

IMulticastRoute * inet::GenericRoutingTable::getMulticastRoute ( int  k ) const

overridevirtual

Returns the kth multicast route.

Implements inet::IRoutingTable.

{
    return nullptr;    //TODO
}

L3Address inet::GenericRoutingTable::getNextHopForDestination ( const L3Address &  dest ) const

overridevirtual

Convenience function based on findBestMatchingRoute().

Returns the gateway for the destination address. Returns the unspecified address if the destination is not in routing table or the gateway field is not filled in in the route.

Implements inet::IRoutingTable.

{
    //TODO Enter_Method("getGatewayForDestAddr(%u.%u.%u.%u)", dest.getDByte(0), dest.getDByte(1), dest.getDByte(2), dest.getDByte(3)); // note: str().c_str() too slow here

    const IRoute *e = findBestMatchingRoute(dest);
    return e ? e->getNextHopAsGeneric() : L3Address();
}

int inet::GenericRoutingTable::getNumMulticastRoutes ( ) const

overridevirtual

Returns the total number of multicast routes.

Implements inet::IRoutingTable.

{
    return 0;    //TODO
}

int inet::GenericRoutingTable::getNumRoutes ( ) const

overridevirtual

Returns the total number of unicast routes.

Implements inet::IRoutingTable.

{
    return routes.size();
}

InterfaceEntry * inet::GenericRoutingTable::getOutputInterfaceForDestination ( const L3Address &  dest ) const

overridevirtual

Convenience function based on findBestMatchingRoute().

Returns the output interface for the packets with dest as destination address, or nullptr if the destination is not in routing table.

Implements inet::IRoutingTable.

{
    //TODO Enter_Method("getInterfaceForDestAddr(%u.%u.%u.%u)", dest.getDByte(0), dest.getDByte(1), dest.getDByte(2), dest.getDByte(3)); // note: str().c_str() too slow here

    const IRoute *e = findBestMatchingRoute(dest);
    return e ? e->getInterface() : nullptr;
}

IRoute * inet::GenericRoutingTable::getRoute ( int  k ) const

overridevirtual

Returns the kth route.

Implements inet::IRoutingTable.

{
    ASSERT(k >= 0 && (unsigned int)k < routes.size());
    return routes[k];
}

L3Address inet::GenericRoutingTable::getRouterIdAsGeneric ( ) const

overridevirtual

Returns routerId.

Implements inet::IRoutingTable.

{
    return routerId;
}

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

overrideprotectedvirtual

Raises an error.

{
    throw cRuntimeError("This module doesn't process messages");
}

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);

    if (stage == INITSTAGE_LOCAL) {
        // get a pointer to the IInterfaceTable
        ift = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);

        const char *addressTypeString = par("addressType");
        if (!strcmp(addressTypeString, "mac"))
            addressType = L3Address::MAC;
        else if (!strcmp(addressTypeString, "modulepath"))
            addressType = L3Address::MODULEPATH;
        else if (!strcmp(addressTypeString, "moduleid"))
            addressType = L3Address::MODULEID;
        else
            throw cRuntimeError("Unknown address type");
        forwarding = par("forwarding").boolValue();
        multicastForwarding = par("multicastForwarding");

        WATCH_PTRVECTOR(routes);
        WATCH_PTRVECTOR(multicastRoutes);
        WATCH(forwarding);
        WATCH(multicastForwarding);
        WATCH(routerId);

        cModule *host = getContainingNode(this);
        host->subscribe(NF_INTERFACE_CREATED, this);
        host->subscribe(NF_INTERFACE_DELETED, this);
        host->subscribe(NF_INTERFACE_STATE_CHANGED, this);
        host->subscribe(NF_INTERFACE_CONFIG_CHANGED, this);
        host->subscribe(NF_INTERFACE_IPv4CONFIG_CHANGED, this);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER) {
        // At this point, all L2 modules have registered themselves (added their
        // interface entries). Create the per-interface IPv4 data structures.
        IInterfaceTable *interfaceTable = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
        for (int i = 0; i < interfaceTable->getNumInterfaces(); ++i)
            configureInterface(interfaceTable->getInterface(i));
        configureLoopback();

//        // read routing table file (and interface configuration)
//        RoutingTableParser parser(ift, this);
//        if (*filename && parser.readRoutingTableFromFile(filename)==-1)
//            throw cRuntimeError("Error reading routing table file %s", filename);

//TODO
//        // set routerId if param is not "" (==no routerId) or "auto" (in which case we'll
//        // do it later in a later stage, after network configurators configured the interfaces)
//        const char *routerIdStr = par("routerId").stringValue();
//        if (strcmp(routerIdStr, "") && strcmp(routerIdStr, "auto"))
//            routerId = IPv4Address(routerIdStr);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER_3) {
        // routerID selection must be after network autoconfiguration assigned interface addresses
        configureRouterId();

//        // we don't use notifications during initialize(), so we do it manually.
//        updateNetmaskRoutes();

        //printRoutingTable();
    }
}

void inet::GenericRoutingTable::internalAddRoute ( GenericRoute *  route )

protected

Referenced by addRoute(), and routeChanged().

{
    ASSERT(route->getRoutingTableAsGeneric() == nullptr);

    // add to tables
    // we keep entries sorted, so that we can stop at the first match when doing the longest prefix matching
    auto pos = upper_bound(routes.begin(), routes.end(), route, routeLessThan);
    routes.insert(pos, route);

    route->setRoutingTable(this);
}

GenericRoute * inet::GenericRoutingTable::internalRemoveRoute ( GenericRoute *  route )

protected

Referenced by removeRoute(), and routeChanged().

{
    auto i = std::find(routes.begin(), routes.end(), route);
    if (i != routes.end()) {
        ASSERT(route->getRoutingTableAsGeneric() == this);
        routes.erase(i);
        route->setRoutingTable(nullptr);
        return route;
    }
    return nullptr;
}

bool inet::GenericRoutingTable::isForwardingEnabled ( ) const

overridevirtual

Forwarding on/off.

Implements inet::IRoutingTable.

Referenced by inet::GenericNetworkProtocol::routePacket().

{
    return forwarding;
}

bool inet::GenericRoutingTable::isLocalAddress ( const L3Address &  dest ) const

overridevirtual

Checks if the address is a local one, i.e.

one of the host's.

Implements inet::IRoutingTable.

Referenced by inet::GenericNetworkProtocol::routePacket().

{
    //TODO: Enter_Method("isLocalAddress(%s)", dest.str().c_str());

    // collect interface addresses if not yet done
    for (int i = 0; i < ift->getNumInterfaces(); i++) {
        L3Address interfaceAddr = ift->getInterface(i)->getGenericNetworkProtocolData()->getAddress();
        if (interfaceAddr == dest)
            return true;
    }
    return false;
}

bool inet::GenericRoutingTable::isLocalMulticastAddress ( const L3Address &  dest ) const

overridevirtual

Checks if the address is in one of the local multicast group address list.

Implements inet::IRoutingTable.

Referenced by inet::GenericNetworkProtocol::routeMulticastPacket().

{
    return dest.isMulticast();    //TODO
}

bool inet::GenericRoutingTable::isMulticastForwardingEnabled ( ) const

overridevirtual

Multicast forwarding on/off.

Implements inet::IRoutingTable.

{
    return multicastForwarding;
}

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

void inet::GenericRoutingTable::printRoutingTable ( ) const

overridevirtual

Prints routing table.

Implements inet::IRoutingTable.

{
    for (const auto & elem : routes)
        EV_INFO << (elem)->getInterface()->getFullPath() << " -> " << (elem)->getDestinationAsGeneric().str() << " as " << (elem)->info() << endl;
}

void inet::GenericRoutingTable::receiveSignal ( cComponent *  source, simsignal_t  signalID, cObject *  obj, cObject *  details  )

overrideprotectedvirtual

Called by the signal handler whenever a change of a category occurs to which this client has subscribed.

{
    // TODO:
}

void inet::GenericRoutingTable::refreshDisplay ( ) const

overrideprotectedvirtual

{
//TODO
//    char buf[80];
//    if (routerId.isUnspecified())
//        sprintf(buf, "%d+%d routes", (int)routes.size(), (int)multicastRoutes.size());
//    else
//        sprintf(buf, "routerId: %s\n%d+%d routes", routerId.str().c_str(), (int)routes.size(), (int)multicastRoutes.size());
//    getDisplayString().setTagArg("t", 0, buf);
}

IMulticastRoute * inet::GenericRoutingTable::removeMulticastRoute ( IMulticastRoute *  entry )

overridevirtual

Removes the given route from the routing table, and returns it.

nullptr is returned of the route was not in the routing table.

Implements inet::IRoutingTable.

{
    return nullptr;    //TODO
}

IRoute * inet::GenericRoutingTable::removeRoute ( IRoute *  entry )

overridevirtual

Removes the given route from the routing table, and returns it.

nullptr is returned if the route was not in the routing table.

Implements inet::IRoutingTable.

Referenced by deleteRoute().

{
    Enter_Method("removeRoute(...)");

    GenericRoute *entry = internalRemoveRoute(check_and_cast<GenericRoute *>(route));
    if (entry) {
        emit(NF_ROUTE_DELETED, entry);
    }

    return entry;
}

void inet::GenericRoutingTable::routeChanged ( GenericRoute *  entry, int  fieldCode  )

virtual

To be called from route objects whenever a field changes.

Used for maintaining internal data structures and firing "routing table changed" notifications.

Referenced by inet::GenericRoute::changed().

{
    if (fieldCode == IRoute::F_DESTINATION || fieldCode == IRoute::F_PREFIX_LENGTH || fieldCode == IRoute::F_METRIC) {    // our data structures depend on these fields
        entry = internalRemoveRoute(entry);
        ASSERT(entry != nullptr);    // failure means inconsistency: route was not found in this routing table
        internalAddRoute(entry);

        //invalidateCache();
    }
    emit(NF_ROUTE_CHANGED, entry);    // TODO include fieldCode in the notification
}

bool inet::GenericRoutingTable::routeLessThan ( const GenericRoute *  a, const GenericRoute *  b  )

staticprotected

Referenced by internalAddRoute().

{
    // helper for sort() in addRoute(). We want routes with longer
    // prefixes to be at front, so we compare them as "less".
    // For metric, a smaller value is better (we report that as "less").
    if (a->getPrefixLength() != b->getPrefixLength())
        return a->getPrefixLength() > b->getPrefixLength();

    if (a->getDestinationAsGeneric() != b->getDestinationAsGeneric())
        return a->getDestinationAsGeneric() < b->getDestinationAsGeneric();

    return a->getMetric() < b->getMetric();
}

Member Data Documentation

L3Address::AddressType inet::GenericRoutingTable::addressType = L3Address::NONE

private

Referenced by configureInterface(), and initialize().

bool inet::GenericRoutingTable::forwarding = false

private

Referenced by initialize(), and isForwardingEnabled().

IInterfaceTable* inet::GenericRoutingTable::ift = nullptr

private

Referenced by configureRouterId(), getInterfaceByAddress(), initialize(), and isLocalAddress().

bool inet::GenericRoutingTable::multicastForwarding = false

private

Referenced by initialize(), and isMulticastForwardingEnabled().

MulticastRouteVector inet::GenericRoutingTable::multicastRoutes

private

Referenced by initialize(), and ~GenericRoutingTable().

L3Address inet::GenericRoutingTable::routerId

private

Referenced by configureRouterId(), getRouterIdAsGeneric(), and initialize().

RouteVector inet::GenericRoutingTable::routes

private

Referenced by findBestMatchingRoute(), getDefaultRoute(), getNumRoutes(), getRoute(), initialize(), internalAddRoute(), internalRemoveRoute(), printRoutingTable(), and ~GenericRoutingTable().

---

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

• GenericRoutingTable.h
• GenericRoutingTable.cc