inet::Dsdv Class Reference

DSDV protocol implementation. More...

#include <Dsdv.h>

Inheritance diagram for inet::Dsdv:

Classes
struct	ForwardEntry

Public Member Functions
	Dsdv ()
	~Dsdv ()
Public Member Functions inherited from inet::RoutingProtocolBase
	RoutingProtocolBase ()
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessageWhenUp (cMessage *msg) override
void	handleSelfMessage (cMessage *msg)
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
void	start ()
void	stop ()
Protected Member Functions inherited from inet::RoutingProtocolBase
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()

Protected Attributes
simtime_t	helloInterval
ModuleRefByPar< IInterfaceTable >	ift
ModuleRefByPar< IIpv4RoutingTable >	rt
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Private Attributes
bool	isForwardHello = false
cMessage *	event = nullptr
cPar *	broadcastDelay = nullptr
std::list< ForwardEntry * > *	forwardList = nullptr
NetworkInterface *	interface80211ptr = nullptr
int	interfaceId = -1
unsigned int	sequencenumber = 0
simtime_t	routeLifetime
cModule *	host = nullptr

Additional Inherited Members
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Detailed Description

DSDV protocol implementation.

Constructor & Destructor Documentation

Dsdv()

inet::Dsdv::Dsdv

(

)

{
}

~Dsdv()

inet::Dsdv::~Dsdv

(

)

{
    stop();
    // Dispose of dynamically allocated the objects
    delete event;
    delete forwardList;
//    delete Hello;
}

Member Function Documentation

handleCrashOperation()

virtual void inet::Dsdv::handleCrashOperation ( LifecycleOperation *  operation )

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ stop(); }

handleMessageWhenUp()

void inet::Dsdv::handleMessageWhenUp ( cMessage *  msg )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    if (msg->isSelfMessage()) {
        handleSelfMessage(msg);
    }
    else if (check_and_cast<Packet *>(msg)->getTag<PacketProtocolTag>()->getProtocol() == &Protocol::manet) {
        auto packet = new Packet("Hello");
 
        // When DSDV module receives DsdvHello from other host
        // it adds/replaces the information in routing table for the one contained in the message
        // but only if it's useful/up-to-date. If not the DSDV module ignores the message.
        auto addressReq = packet->addTag<L3AddressReq>();
        addressReq->setDestAddress(Ipv4Address(255, 255, 255, 255)); // let's try the limited broadcast 255.255.255.255 but multicast goes from 224.0.0.0 to 239.255.255.255
        addressReq->setSrcAddress(interface80211ptr->getProtocolData<Ipv4InterfaceData>()->getIPAddress());
        packet->addTag<InterfaceReq>()->setInterfaceId(interface80211ptr->getInterfaceId());
        packet->addTag<PacketProtocolTag>()->setProtocol(&Protocol::manet);
        packet->addTag<DispatchProtocolReq>()->setProtocol(&Protocol::ipv4);
        ForwardEntry *fhp = nullptr;
        auto recHello = !isForwardHello ? staticPtrCast<DsdvHello>(check_and_cast<Packet *>(msg)->peekData<DsdvHello>()->dupShared()) : nullptr;
        if (isForwardHello) {
            fhp = new ForwardEntry();
            fhp->hello = check_and_cast<Packet *>(msg->dup());
        }
 
        if (msg->arrivedOn("ipIn")) {
            ASSERT((!isForwardHello && recHello) || (isForwardHello && fhp->hello));
            bubble("Received hello message");
            Ipv4Address source = interface80211ptr->getProtocolData<Ipv4InterfaceData>()->getIPAddress();
 
            // reads DSDV hello message fields
            Ipv4Address src;
            unsigned int msgsequencenumber;
            int numHops;
            Ipv4Address next;
            if (!isForwardHello) {
                src = recHello->getSrcAddress();
                msgsequencenumber = recHello->getSequencenumber();
                next = recHello->getNextAddress();
                numHops = recHello->getHopdistance();
 
                if (src == source) {
                    EV_INFO << "Hello msg dropped. This message returned to the original creator.\n";
                    delete packet;
                    delete fhp;
                    delete msg;
                    return;
                }
            }
            else {
                auto fhpHello = fhp->hello->peekData<DsdvHello>();
                src = fhpHello->getSrcAddress();
                msgsequencenumber = fhpHello->getSequencenumber();
                next = fhpHello->getNextAddress();
                numHops = fhpHello->getHopdistance();
 
                if (src == source) {
                    EV_INFO << "Hello msg dropped. This message returned to the original creator.\n";
                    delete packet;
                    delete fhp;
                    delete msg;
                    return;
                }
            }
 
            Ipv4Route *_entrada_routing = rt->findBestMatchingRoute(src);
            DsdvIpv4Route *entrada_routing = dynamic_cast<DsdvIpv4Route *>(_entrada_routing);
 
            // Tests if the DSDV hello message that arrived is useful
            if (_entrada_routing == nullptr
                || (_entrada_routing != nullptr && _entrada_routing->getNetmask() != Ipv4Address::ALLONES_ADDRESS)
                || (entrada_routing != nullptr && (msgsequencenumber > (entrada_routing->getSequencenumber()) || (msgsequencenumber == (entrada_routing->getSequencenumber()) && numHops < (entrada_routing->getMetric())))))
            {
 
                // remove old entry
                if (entrada_routing != nullptr)
                    rt->deleteRoute(entrada_routing);
 
                // adds new information to routing table according to information in hello message
                {
                    Ipv4Address netmask = Ipv4Address::ALLONES_ADDRESS; // Ipv4Address(par("netmask").stringValue());
                    DsdvIpv4Route *e = new DsdvIpv4Route();
                    e->setDestination(src);
                    e->setNetmask(netmask);
                    e->setGateway(next);
                    e->setInterface(interface80211ptr);
                    e->setSourceType(IRoute::MANET);
                    e->setMetric(numHops);
                    e->setSequencenumber(msgsequencenumber);
                    e->setExpiryTime(simTime() + routeLifetime);
                    rt->addRoute(e);
                }
                if (!isForwardHello) {
                    recHello->setNextAddress(source);
                    numHops++;
                    recHello->setHopdistance(numHops);
                    double waitTime = intuniform(1, 50);
                    waitTime = waitTime / 100;
                    EV_DETAIL << "waitime for forward before was " << waitTime << " And host is " << source << "\n";
//                    waitTime= SIMTIME_DBL (simTime())+waitTime;
                    EV_DETAIL << "waitime for forward is " << waitTime << " And host is " << source << "\n"; // FIXME unchanged waitTime showed twice!!!
                    packet->insertAtBack(recHello);
                    sendDelayed(packet, waitTime, "ipOut");
                    packet = nullptr;
                }
                else {
                    auto forwardHello = staticPtrCast<DsdvHello>(fhp->hello->peekData<DsdvHello>()->dupShared());
                    // forward useful message to other nodes
                    forwardHello->setNextAddress(source);
                    numHops++;
                    forwardHello->setHopdistance(numHops);
//                    send(HelloForward, "ipOut");
//                    HelloForward=nullptr;
                    double waitTime = intuniform(1, 50);
                    waitTime = waitTime / 100;
                    EV_DETAIL << "waitime for forward before was " << waitTime << " And host is " << source << "\n";
                    EV_DETAIL << "waitime for forward is " << waitTime << " And host is " << source << "\n";
                    fhp->event = new cMessage("event2");
                    scheduleAfter(waitTime, fhp->event);
                    forwardList->push_back(fhp);
                    fhp = nullptr;
                }
            }
            delete packet;
            delete fhp;
            delete msg;
        }
        else
            throw cRuntimeError("Message arrived on unknown gate %s", msg->getArrivalGate()->getName());
    }
    else
        throw cRuntimeError("Message not supported %s", msg->getName());
}

handleSelfMessage()

void inet::Dsdv::handleSelfMessage ( cMessage *  msg )

protected

size of Hello message in bits

{
    // When DSDV module receives selfmessage (scheduled event)
    // it means that it's time for Hello message broadcast event
    // i.e. Brodcast Hello messages to other nodes when selfmessage=event
    // But if selmessage!=event it means that it is time to forward useful Hello message to othert nodes
    if (msg == event) {
        auto hello = makeShared<DsdvHello>();
 
        rt->purge();
 
        // 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++; }
 
        // Filling the DsdvHello fields
//        Ipv4Address source = (ie->ipv4()->getIPAddress());
        Ipv4Address source = (interface80211ptr->getProtocolData<Ipv4InterfaceData>()->getIPAddress());
        hello->setChunkLength(b(128)); 
        hello->setSrcAddress(source);
        sequencenumber += 2;
        hello->setSequencenumber(sequencenumber);
        hello->setNextAddress(source);
        hello->setHopdistance(1);
 
        /*http://www.cs.ucsb.edu/~ebelding/txt/bc.txt
        The IPv4 address for "limited broadcast" is 255.255.255.255, and is not supposed to be forwarded.
        Since the nodes in an ad hoc network are asked to forward the flooded packets, the limited broadcast
        address is a poor choice.  The other available choice, the "directed broadcast" address, would presume a
        choice of routing prefix for the ad hoc network and thus is not a reasonable choice.
        (...)
        Limited Broadcast - Sent to all NICs on the some network segment as the source NIC. It is represented with
        the 255.255.255.255 TCP/IP address. This broadcast is not forwarded by routers so will only appear on one
        network segment.
        Direct broadcast - Sent to all hosts on a network. Routers may be configured to forward directed broadcasts
        on large networks. For network 192.168.0.0, the broadcast is 192.168.255.255.
        */
        // new control info for DsdvHello
        auto packet = new Packet("Hello", hello);
        auto addressReq = packet->addTag<L3AddressReq>();
        addressReq->setDestAddress(Ipv4Address(255, 255, 255, 255)); // let's try the limited broadcast 255.255.255.255 but multicast goes from 224.0.0.0 to 239.255.255.255
        addressReq->setSrcAddress(source); // let's try the limited broadcast
        packet->addTag<InterfaceReq>()->setInterfaceId(interface80211ptr->getInterfaceId());
        packet->addTag<PacketProtocolTag>()->setProtocol(&Protocol::manet);
        packet->addTag<DispatchProtocolReq>()->setProtocol(&Protocol::ipv4);
 
        // broadcast to other nodes the hello message
        send(packet, "ipOut");
        packet = nullptr;
        hello = nullptr;
 
        // schedule new brodcast hello message event
        scheduleAfter(helloInterval + broadcastDelay->doubleValue(), event);
        bubble("Sending new hello message");
    }
    else {
        for (auto it = forwardList->begin(); it != forwardList->end(); it++) {
            if ((*it)->event == msg) {
                EV << "Vou mandar forward do " << (*it)->hello->peekData<DsdvHello>()->getSrcAddress() << endl; // todo
                send((*it)->hello, "ipOut");
                (*it)->hello = nullptr;
                delete *it;
                forwardList->erase(it);
                break;
            }
        }
        delete msg;
    }
}

Referenced by handleMessageWhenUp().

handleStartOperation()

virtual void inet::Dsdv::handleStartOperation ( LifecycleOperation *  operation )

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ start(); }

handleStopOperation()

virtual void inet::Dsdv::handleStopOperation ( LifecycleOperation *  operation )

inlineoverrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{ stop(); }

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

{
    RoutingProtocolBase::initialize(stage);
 
    // reads from omnetpp.ini
    if (stage == INITSTAGE_LOCAL) {
        sequencenumber = 0;
        host = getContainingNode(this);
        ift.reference(this, "interfaceTableModule", true);
        rt.reference(this, "routingTableModule", true);
 
        routeLifetime = par("routeLifetime").doubleValue();
        helloInterval = par("helloInterval");
        forwardList = new std::list<ForwardEntry *>();
        event = new cMessage("event");
    }
    else if (stage == INITSTAGE_ROUTING_PROTOCOLS) {
        registerProtocol(Protocol::manet, gate("ipOut"), gate("ipIn"));
    }
}

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

start()

void inet::Dsdv::start ( )

protected

{
    /* Search the 80211 interface */
    int num_80211 = 0;
    NetworkInterface *ie;
    NetworkInterface *i_face;
    const char *name;
    broadcastDelay = &par("broadcastDelay");
    for (int i = 0; i < ift->getNumInterfaces(); i++) {
        ie = ift->getInterface(i);
        name = ie->getInterfaceName();
        if (strstr(name, "wlan") != nullptr) {
            i_face = ie;
            num_80211++;
            interfaceId = i;
        }
    }
 
    // One enabled network interface (in total)
    if (num_80211 == 1)
        interface80211ptr = i_face;
    else
        throw cRuntimeError("DSDV has found %i 80211 interfaces", num_80211);
    if (par("manetPurgeRoutingTables").boolValue()) {
        Ipv4Route *entry;
        // clean the route table wlan interface entry
        for (int i = rt->getNumRoutes() - 1; i >= 0; i--) {
            entry = rt->getRoute(i);
            const NetworkInterface *ie = entry->getInterface();
            if (strstr(ie->getInterfaceName(), "wlan") != nullptr)
                rt->deleteRoute(entry);
        }
    }
    CHK(interface80211ptr->getProtocolDataForUpdate<Ipv4InterfaceData>())->joinMulticastGroup(Ipv4Address::LL_MANET_ROUTERS);
 
    // schedules a random periodic event: the hello message broadcast from DSDV module
 
    // reads from omnetpp.ini
//    HelloForward = new DsdvHello("HelloForward");
    // schedules a random periodic event: the hello message broadcast from DSDV module
    scheduleAfter(uniform(0.0, par("maxVariance").doubleValue()), event);
}

stop()

void inet::Dsdv::stop ( )

protected

{
    cancelEvent(event);
    while (!forwardList->empty()) {
        ForwardEntry *fh = forwardList->front();
        if (fh->event)
            cancelAndDelete(fh->event);
        if (fh->hello)
            cancelAndDelete(fh->hello);
        fh->event = nullptr;
        fh->hello = nullptr;
        forwardList->pop_front();
        delete fh;
    }
}

Referenced by ~Dsdv().

Member Data Documentation

broadcastDelay

cPar* inet::Dsdv::broadcastDelay = nullptr

private

Referenced by handleSelfMessage(), and start().

event

cMessage* inet::Dsdv::event = nullptr

private

Referenced by handleSelfMessage(), start(), stop(), and ~Dsdv().

forwardList

std::list<ForwardEntry *>* inet::Dsdv::forwardList = nullptr

private

Referenced by handleMessageWhenUp(), handleSelfMessage(), initialize(), stop(), and ~Dsdv().

helloInterval

simtime_t inet::Dsdv::helloInterval

protected

Referenced by handleSelfMessage(), and initialize().

host

cModule* inet::Dsdv::host = nullptr

private

Referenced by initialize().

ift

ModuleRefByPar<IInterfaceTable> inet::Dsdv::ift

protected

Referenced by initialize(), and start().

interface80211ptr

NetworkInterface* inet::Dsdv::interface80211ptr = nullptr

private

Referenced by handleMessageWhenUp(), handleSelfMessage(), and start().

interfaceId

int inet::Dsdv::interfaceId = -1

private

Referenced by start().

isForwardHello

bool inet::Dsdv::isForwardHello = false

private

Referenced by handleMessageWhenUp().

routeLifetime

simtime_t inet::Dsdv::routeLifetime

private

Referenced by handleMessageWhenUp(), and initialize().

rt

ModuleRefByPar<IIpv4RoutingTable> inet::Dsdv::rt

protected

Referenced by handleMessageWhenUp(), handleSelfMessage(), initialize(), and start().

sequencenumber

unsigned int inet::Dsdv::sequencenumber = 0

private

Referenced by handleSelfMessage(), and initialize().

---

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

• Dsdv.h
• Dsdv.cc