inet::LinkStateRouting Class Reference

Implements a minimalistic link state routing protocol that employs flooding. More...

#include <LinkStateRouting.h>

Inheritance diagram for inet::LinkStateRouting:

Public Member Functions
	LinkStateRouting ()
virtual	~LinkStateRouting ()

Protected Member Functions
virtual void	initialize (int stage) override
virtual int	numInitStages () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	processLINK_STATE_MESSAGE (LinkStateMsg *msg, IPv4Address sender)
virtual void	receiveSignal (cComponent *source, simsignal_t signalID, cObject *obj, cObject *details) override
virtual void	sendToPeers (const std::vector< TELinkStateInfo > &list, bool req, IPv4Address exceptPeer)
virtual void	sendToPeer (IPv4Address peer, const std::vector< TELinkStateInfo > &list, bool req)
virtual void	sendToIP (LinkStateMsg *msg, IPv4Address destAddr)

Protected Attributes
TED *	tedmod = nullptr
cMessage *	announceMsg = nullptr
IPv4Address	routerId
IPAddressVector	peerIfAddrs

Detailed Description

Implements a minimalistic link state routing protocol that employs flooding.

Flooding works like this:

When a router receives a link state packet, it merges the packet contents into its own link state database (ted). If the packet contained new information (ted got updated), the router broadcasts the ted contents to all its other neighbours; otherwise (when the packet didn't contain any new info), nothing happens.

Also: when the announceMsg timer expires, LinkStateRouting sends out an initial link state message. (Currently this happens only once, at the beginning of the simulation). The "request" bit in the message is set then, asking neighbours to send back their link state databases. (FIXME why's this? redundant messaging: same msg is often sent twice: both as reply and as voluntary "announce").

TODO discover peers by "hello". Peers are those from which the router has received a Hello in the last X seconds. Link info to all peers are maintained; links to ex-peers (those haven't heard of for more than X seconds) are assumed to be down.

See NED file for more info.

Constructor & Destructor Documentation

inet::LinkStateRouting::LinkStateRouting

(

)

{
}

inet::LinkStateRouting::~LinkStateRouting ( )

virtual

{
    cancelAndDelete(announceMsg);
}

Member Function Documentation

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

overrideprotectedvirtual

{
    if (msg == announceMsg) {
        delete announceMsg;
        announceMsg = nullptr;
        sendToPeers(tedmod->ted, true, IPv4Address());
    }
    else if (!strcmp(msg->getArrivalGate()->getName(), "ipIn")) {
        EV_INFO << "Processing message from IPv4: " << msg << endl;
        IPv4ControlInfo *controlInfo = check_and_cast<IPv4ControlInfo *>(msg->getControlInfo());
        IPv4Address sender = controlInfo->getSrcAddr();
        processLINK_STATE_MESSAGE(check_and_cast<LinkStateMsg *>(msg), sender);
    }
    else
        ASSERT(false);
}

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);

    if (stage == INITSTAGE_ROUTING_PROTOCOLS) {
        tedmod = getModuleFromPar<TED>(par("tedModule"), this);

        IIPv4RoutingTable *rt = getModuleFromPar<IIPv4RoutingTable>(par("routingTableModule"), this);
        routerId = rt->getRouterId();

        // listen for TED modifications
        cModule *host = getContainingNode(this);
        host->subscribe(NF_TED_CHANGED, this);

        // peers are given as interface names in the "peers" module parameter;
        // store corresponding interface addresses in peerIfAddrs[]
        cStringTokenizer tokenizer(par("peers"));
        IInterfaceTable *ift = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
        const char *token;
        while ((token = tokenizer.nextToken()) != nullptr) {
            ASSERT(ift->getInterfaceByName(token));
            peerIfAddrs.push_back(ift->getInterfaceByName(token)->ipv4Data()->getIPAddress());
        }

        // schedule start of flooding link state info
        announceMsg = new cMessage("announce");
        scheduleAt(simTime() + exponential(0.01), announceMsg);

        IPSocket socket(gate("ipOut"));
        socket.registerProtocol(IP_PROT_OSPF);
    }
}

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

void inet::LinkStateRouting::processLINK_STATE_MESSAGE ( LinkStateMsg *  msg, IPv4Address  sender  )

protectedvirtual

Referenced by handleMessage().

{
    EV_INFO << "received LINK_STATE message from " << sender << endl;

    TELinkStateInfoVector forward;

    unsigned int n = msg->getLinkInfoArraySize();

    bool change = false;    // in topology

    // loop through every link in the message
    for (unsigned int i = 0; i < n; i++) {
        const TELinkStateInfo& link = msg->getLinkInfo(i);

        TELinkStateInfo *match;

        // process link if we haven't seen this already and timestamp is newer
        if (tedmod->checkLinkValidity(link, match)) {
            ASSERT(link.sourceId == link.advrouter.getInt());

            EV_INFO << "new information found" << endl;

            if (!match) {
                // and we have no info on this link so far, store it as it is
                tedmod->ted.push_back(link);
                change = true;
            }
            else {
                // copy over the information from it
                if (match->state != link.state) {
                    match->state = link.state;
                    change = true;
                }
                match->messageId = link.messageId;
                match->sourceId = link.sourceId;
                match->timestamp = link.timestamp;
                for (int i = 0; i < 8; i++)
                    match->UnResvBandwidth[i] = link.UnResvBandwidth[i];
                match->MaxBandwidth = link.MaxBandwidth;
                match->metric = link.metric;
            }

            forward.push_back(link);
        }
    }

    if (change)
        tedmod->rebuildRoutingTable();

    if (msg->getRequest()) {
        sendToPeer(sender, tedmod->ted, false);
    }

    if (forward.size() > 0) {
        sendToPeers(forward, false, sender);
    }

    delete msg;
}

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

overrideprotectedvirtual

{
    Enter_Method_Silent();
    printNotificationBanner(signalID, obj);

    ASSERT(signalID == NF_TED_CHANGED);

    EV_INFO << "TED changed\n";

    const TEDChangeInfo *d = check_and_cast<const TEDChangeInfo *>(obj);

    unsigned int k = d->getTedLinkIndicesArraySize();

    ASSERT(k > 0);

    // build linkinfo list
    std::vector<TELinkStateInfo> links;
    for (unsigned int i = 0; i < k; i++) {
        unsigned int index = d->getTedLinkIndices(i);

        tedmod->updateTimestamp(&tedmod->ted[index]);
        links.push_back(tedmod->ted[index]);
    }

    sendToPeers(links, false, IPv4Address());
}

void inet::LinkStateRouting::sendToIP ( LinkStateMsg *  msg, IPv4Address  destAddr  )

protectedvirtual

Referenced by sendToPeer().

{
    // attach control info to packet
    IPv4ControlInfo *controlInfo = new IPv4ControlInfo();
    controlInfo->setDestAddr(destAddr);
    controlInfo->setSrcAddr(routerId);
    controlInfo->setProtocol(IP_PROT_OSPF);
    msg->setControlInfo(controlInfo);

    int length = msg->getLinkInfoArraySize() * 72;
    msg->setByteLength(length);

    msg->addPar("color") = TED_TRAFFIC;

    send(msg, "ipOut");
}

void inet::LinkStateRouting::sendToPeer ( IPv4Address  peer, const std::vector< TELinkStateInfo > &  list, bool  req  )

protectedvirtual

Referenced by processLINK_STATE_MESSAGE(), and sendToPeers().

{
    EV_INFO << "sending LINK_STATE message to " << peer << endl;

    LinkStateMsg *out = new LinkStateMsg("link state");

    out->setLinkInfoArraySize(list.size());
    for (unsigned int j = 0; j < list.size(); j++)
        out->setLinkInfo(j, list[j]);

    out->setRequest(req);

    sendToIP(out, peer);
}

void inet::LinkStateRouting::sendToPeers ( const std::vector< TELinkStateInfo > &  list, bool  req, IPv4Address  exceptPeer  )

protectedvirtual

Referenced by handleMessage(), processLINK_STATE_MESSAGE(), and receiveSignal().

{
    EV_INFO << "sending LINK_STATE message to peers" << endl;

    // send "list" to every peer (linkid in our ted[] entries???) in a LinkStateMsg
    for (auto & elem : tedmod->ted) {
        if (elem.advrouter != routerId)
            continue;

        if (elem.linkid == exceptPeer)
            continue;

        if (!elem.state)
            continue;

        if (find(peerIfAddrs.begin(), peerIfAddrs.end(), elem.local) == peerIfAddrs.end())
            continue;

        // send a copy
        sendToPeer(elem.linkid, list, req);
    }
}

Member Data Documentation

cMessage* inet::LinkStateRouting::announceMsg = nullptr

protected

Referenced by handleMessage(), initialize(), and ~LinkStateRouting().

IPAddressVector inet::LinkStateRouting::peerIfAddrs

protected

Referenced by initialize(), and sendToPeers().

IPv4Address inet::LinkStateRouting::routerId

protected

Referenced by initialize(), sendToIP(), and sendToPeers().

TED* inet::LinkStateRouting::tedmod = nullptr

protected

Referenced by handleMessage(), initialize(), processLINK_STATE_MESSAGE(), receiveSignal(), and sendToPeers().

---

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

• LinkStateRouting.h
• LinkStateRouting.cc