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 (Packet *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 (Packet *msg, Ipv4Address destAddr)

Protected Attributes
ModuleRefByPar< Ted >	tedmod
cMessage *	announceMsg = nullptr
Ipv4Address	routerId
Ipv4AddressVector	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

LinkStateRouting()

inet::LinkStateRouting::LinkStateRouting

(

)

{
}

~LinkStateRouting()

inet::LinkStateRouting::~LinkStateRouting ( )

virtual

{
    cancelAndDelete(announceMsg);
}

Member Function Documentation

handleMessage()

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;
        Ipv4Address sender = check_and_cast<Packet *>(msg)->getTag<L3AddressInd>()->getSrcAddress().toIpv4();
        processLINK_STATE_MESSAGE(check_and_cast<Packet *>(msg), sender);
    }
    else
        ASSERT(false);
}

initialize()

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);
    // TODO INITSTAGE
    if (stage == INITSTAGE_ROUTING_PROTOCOLS) {
        tedmod.reference(this, "tedModule", true);
 
        IIpv4RoutingTable *rt = getModuleFromPar<IIpv4RoutingTable>(par("routingTableModule"), this);
        routerId = rt->getRouterId();
 
        // listen for TED modifications
        cModule *host = getContainingNode(this);
        host->subscribe(tedChangedSignal, 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) {
            peerIfAddrs.push_back(CHK(ift->findInterfaceByName(token))->getProtocolData<Ipv4InterfaceData>()->getIPAddress());
        }
 
        // schedule start of flooding link state info
        announceMsg = new cMessage("announce");
        scheduleAt(simTime() + exponential(0.01), announceMsg);
        registerProtocol(Protocol::linkStateRouting, gate("ipOut"), gate("ipIn"));
    }
}

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

processLINK_STATE_MESSAGE()

void inet::LinkStateRouting::processLINK_STATE_MESSAGE ( Packet *  msg, Ipv4Address  sender  )

protectedvirtual

{
    EV_INFO << "received LINK_STATE message from " << sender << endl;
 
    const auto& msg = pk->peekAtFront<LinkStateMsg>();
    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 pk;
}

Referenced by handleMessage().

receiveSignal()

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

overrideprotectedvirtual

{
    Enter_Method("%s", cComponent::getSignalName(signalID));
 
    printSignalBanner(signalID, obj, details);
 
    ASSERT(signalID == tedChangedSignal);
 
    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());
}

sendToIP()

void inet::LinkStateRouting::sendToIP ( Packet *  msg, Ipv4Address  destAddr  )

protectedvirtual

{
    msg->addPar("color") = TED_TRAFFIC;
 
    msg->addTagIfAbsent<PacketProtocolTag>()->setProtocol(&Protocol::linkStateRouting);
    msg->addTagIfAbsent<DispatchProtocolInd>()->setProtocol(&Protocol::linkStateRouting);
    msg->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(&Protocol::ipv4);
    msg->addTagIfAbsent<L3AddressReq>()->setDestAddress(destAddr);
    msg->addTagIfAbsent<L3AddressReq>()->setSrcAddress(routerId);
    send(msg, "ipOut");
}

Referenced by sendToPeer().

sendToPeer()

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

protectedvirtual

{
    EV_INFO << "sending LINK_STATE message to " << peer << endl;
 
    Packet *pk = new Packet("link state");
    const auto& out = makeShared<LinkStateMsg>();
 
    out->setLinkInfoArraySize(list.size());
    for (unsigned int j = 0; j < list.size(); j++)
        out->setLinkInfo(j, list[j]);
 
    out->setRequest(req);
    B length = B(72) * out->getLinkInfoArraySize();
    out->setChunkLength(length);
    pk->insertAtBack(out);
 
    sendToIP(pk, peer);
}

Referenced by processLINK_STATE_MESSAGE(), and sendToPeers().

sendToPeers()

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

protectedvirtual

{
    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 (!contains(peerIfAddrs, elem.local))
            continue;
 
        // send a copy
        sendToPeer(elem.linkid, list, req);
    }
}

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

Member Data Documentation

announceMsg

cMessage* inet::LinkStateRouting::announceMsg = nullptr

protected

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

peerIfAddrs

Ipv4AddressVector inet::LinkStateRouting::peerIfAddrs

protected

Referenced by initialize(), and sendToPeers().

routerId

Ipv4Address inet::LinkStateRouting::routerId

protected

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

tedmod

ModuleRefByPar<Ted> inet::LinkStateRouting::tedmod

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