inet::RoutingTableRecorder Class Reference

Records routing table changes into a file. More...

#include <RoutingTableRecorder.h>

Inheritance diagram for inet::RoutingTableRecorder:

Public Member Functions
	RoutingTableRecorder ()
virtual	~RoutingTableRecorder ()
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *) override
virtual void	finish () override
virtual void	hookListeners ()
virtual void	ensureRoutingLogFileOpen ()
virtual void	receiveChangeNotification (cComponent *source, simsignal_t signalID, cObject *details)
virtual void	recordInterfaceChange (cModule *host, const NetworkInterface *ie, simsignal_t signalID)
virtual void	recordRouteChange (cModule *host, const IRoute *route, simsignal_t signalID)

Private Attributes
FILE *	routingLogFile

Detailed Description

Records routing table changes into a file.

See also

Ipv4RoutingTable, Ipv4Route

Constructor & Destructor Documentation

RoutingTableRecorder()

inet::RoutingTableRecorder::RoutingTableRecorder

(

)

{
    routingLogFile = nullptr;
}

~RoutingTableRecorder()

inet::RoutingTableRecorder::~RoutingTableRecorder ( )

virtual

{
    if (routingLogFile != nullptr) {
        fclose(routingLogFile);
        routingLogFile = nullptr;
    }
}

Member Function Documentation

ensureRoutingLogFileOpen()

void inet::RoutingTableRecorder::ensureRoutingLogFileOpen ( )

protectedvirtual

{
    if (routingLogFile == nullptr) {
        std::string fname = getEnvir()->getConfig()->getAsFilename(CFGID_ROUTINGLOG_FILE);
        inet::utils::makePathForFile(fname.c_str());
        routingLogFile = fopen(fname.c_str(), "w");
        if (!routingLogFile)
            throw cRuntimeError("Cannot open file %s", fname.c_str());
    }
}

Referenced by recordInterfaceChange(), and recordRouteChange().

finish()

void inet::RoutingTableRecorder::finish ( )

overrideprotectedvirtual

{
}

handleMessage()

void inet::RoutingTableRecorder::handleMessage ( cMessage *  )

overrideprotectedvirtual

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

hookListeners()

void inet::RoutingTableRecorder::hookListeners ( )

protectedvirtual

{
    cModule *systemModule = getSimulation()->getSystemModule();
    systemModule->subscribe(interfaceCreatedSignal, this);
    systemModule->subscribe(interfaceDeletedSignal, this);
    systemModule->subscribe(interfaceConfigChangedSignal, this);
    systemModule->subscribe(interfaceIpv4ConfigChangedSignal, this);
//    systemModule->subscribe(interfaceIpv6ConfigChangedSignal, this);
//    systemModule->subscribe(interfaceStateChangedSignal, this);
 
    systemModule->subscribe(routeAddedSignal, this);
    systemModule->subscribe(routeDeletedSignal, this);
    systemModule->subscribe(routeChangedSignal, this);
}

Referenced by initialize().

initialize()

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);
 
    if (stage == INITSTAGE_NETWORK_LAYER) {
        if (par("enabled"))
            hookListeners();
    }
}

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

receiveChangeNotification()

void inet::RoutingTableRecorder::receiveChangeNotification ( cComponent *  source, simsignal_t  signalID, cObject *  details  )

protectedvirtual

{
    cModule *m = dynamic_cast<cModule *>(nsource);
    if (!m)
        m = nsource->getParentModule();
    cModule *host = getContainingNode(m);
    if (signalID == routeAddedSignal || signalID == routeDeletedSignal || signalID == routeChangedSignal)
        recordRouteChange(host, check_and_cast<const IRoute *>(obj), signalID);
    else if (signalID == interfaceCreatedSignal || signalID == interfaceDeletedSignal)
        recordInterfaceChange(host, check_and_cast<const NetworkInterface *>(obj), signalID);
    else if (signalID == interfaceConfigChangedSignal || signalID == interfaceIpv4ConfigChangedSignal)
        recordInterfaceChange(host, check_and_cast<const NetworkInterfaceChangeDetails *>(obj)->getNetworkInterface(), signalID);
}

receiveSignal()

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

inlineoverridevirtual

{ receiveChangeNotification(source, signalID, obj); }

recordInterfaceChange()

void inet::RoutingTableRecorder::recordInterfaceChange ( cModule *  host, const NetworkInterface *  ie, simsignal_t  signalID  )

protectedvirtual

{
    if (getSimulation()->getSimulationStage() == CTX_CLEANUP)
            return; // ignore notifications during cleanup
 
    // Note: ie->getInterfaceTable() may be nullptr (entry already removed from its table)
 
    const char *tag;
 
    if (signalID == interfaceCreatedSignal)
        tag = "+I";
    else if (signalID == interfaceDeletedSignal)
        tag = "-I";
    else if (signalID == interfaceConfigChangedSignal)
        tag = "*I";
    else if (signalID == interfaceIpv4ConfigChangedSignal)
        tag = "*I";
    else
        throw cRuntimeError("Unexpected signal: %s", getSignalName(signalID));
 
    // action, eventNo, simtime, moduleId, ifname, address
    ensureRoutingLogFileOpen();
    auto ipv4Data = ie->findProtocolData<Ipv4InterfaceData>();
    fprintf(routingLogFile, "%s  #%" PRId64 "  %ss  %s  %s %s\n",
            tag,
            getSimulation()->getEventNumber(),
            SIMTIME_STR(simTime()),
            host->getFullPath().c_str(),
            ie->getInterfaceName(),
            (ipv4Data != nullptr ? ipv4Data->getIPAddress().str().c_str() : Ipv4Address().str().c_str()));
    fflush(routingLogFile);
}

Referenced by receiveChangeNotification().

recordRouteChange()

void inet::RoutingTableRecorder::recordRouteChange ( cModule *  host, const IRoute *  route, simsignal_t  signalID  )

protectedvirtual

{
    IRoutingTable *rt = route->getRoutingTableAsGeneric(); // may be nullptr! (route already removed from its routing table)
 
    const char *tag;
    if (signalID == routeAddedSignal)
        tag = "+R";
    else if (signalID == routeChangedSignal)
        tag = "*R";
    else if (signalID == routeDeletedSignal)
        tag = "-R";
    else
        throw cRuntimeError("Unexpected signal: %s", getSignalName(signalID));
 
    // action, eventNo, simtime, moduleId, routerID, dest, dest netmask, nexthop
    ensureRoutingLogFileOpen();
    auto ie = route->getInterface();
    fprintf(routingLogFile, "%s #%" PRId64 "  %ss  %s  %s  %s/%d  %s  %s\n",
            tag,
            getSimulation()->getEventNumber(),
            SIMTIME_STR(simTime()),
            host->getFullPath().c_str(),
            (rt ? rt->getRouterIdAsGeneric().str().c_str() : "*"),
            route->getDestinationAsGeneric().str().c_str(),
            route->getPrefixLength(),
            route->getNextHopAsGeneric().str().c_str(),
            (ie ? ie->getInterfaceName() : "*"));
    fflush(routingLogFile);
}

Referenced by receiveChangeNotification().

Member Data Documentation

routingLogFile

FILE* inet::RoutingTableRecorder::routingLogFile

private

Referenced by ensureRoutingLogFileOpen(), recordInterfaceChange(), recordRouteChange(), RoutingTableRecorder(), and ~RoutingTableRecorder().

---

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

• RoutingTableRecorder.h
• RoutingTableRecorder.cc