inet::Flood Class Reference

A simple flooding protocol. More...

#include <Flood.h>

Inheritance diagram for inet::Flood:

Classes
class	Bcast

Public Member Functions
	Flood ()
virtual int	numInitStages () const override
	Initialization of omnetpp.ini parameters. More...
virtual void	initialize (int) override
	Reads all parameters from the ini file. More...
virtual void	finish () override
Public Member Functions inherited from inet::OperationalBase
	OperationalBase ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::INetworkProtocol
virtual	~INetworkProtocol ()

Protected Types
typedef std::list< Bcast >	cBroadcastList

Protected Member Functions
virtual void	handleUpperPacket (cPacket *) override
	Handle messages from upper layer. More...
virtual void	handleLowerPacket (cPacket *) override
	Handle messages from lower layer. More...
bool	notBroadcasted (FloodDatagram *)
	Checks whether a message was already broadcasted. More...
cMessage *	decapsMsg (FloodDatagram *)
	Decapsulates the packet from the received Network packet. More...
FloodDatagram *	encapsMsg (cPacket *)
	Encapsulates the received ApplPkt into a NetwPkt and set all needed header fields. More...
virtual cObject *	setDownControlInfo (cMessage *const pMsg, const MACAddress &pDestAddr)
	Attaches a "control info" (NetwToMac) structure (object) to the message pMsg. More...
Protected Member Functions inherited from inet::NetworkProtocolBase
	NetworkProtocolBase ()
virtual void	handleUpperCommand (cMessage *message) override
virtual void	sendUp (cMessage *message, int transportProtocol)
virtual void	sendDown (cMessage *message, int interfaceId=-1)
virtual bool	isUpperMessage (cMessage *message) override
virtual bool	isLowerMessage (cMessage *message) override
virtual bool	isInitializeStage (int stage) override
virtual bool	isNodeStartStage (int stage) override
virtual bool	isNodeShutdownStage (int stage) override
Protected Member Functions inherited from inet::LayeredProtocolBase
virtual void	handleMessageWhenUp (cMessage *message) override
virtual void	handleSelfMessage (cMessage *message)
virtual void	handleLowerCommand (cMessage *message)
Protected Member Functions inherited from inet::OperationalBase
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual bool	handleNodeStart (IDoneCallback *doneCallback)
virtual bool	handleNodeShutdown (IDoneCallback *doneCallback)
virtual void	handleNodeCrash ()
virtual void	setOperational (bool isOperational)

Protected Attributes
unsigned long	seqNum = 0
	Network layer sequence number. More...
L3Address	myNetwAddr
	cached variable of my networ address More...
int	headerLength = 0
	Length of the header. More...
int	defaultTtl = 0
	Default time-to-live (ttl) used for this module. More...
bool	plainFlooding = false
	Defines whether to use plain flooding or not. More...
cBroadcastList	bcMsgs
	List of already broadcasted messages. More...
unsigned int	bcMaxEntries = 0
	Max number of entries in the list of already broadcasted messages. More...
simtime_t	bcDelTime
	Time after which an entry for an already broadcasted msg can be deleted. More...
long	nbDataPacketsReceived = 0
long	nbDataPacketsSent = 0
long	nbDataPacketsForwarded = 0
long	nbHops = 0
Protected Attributes inherited from inet::NetworkProtocolBase
ProtocolMapping	protocolMapping
IInterfaceTable *	interfaceTable
Protected Attributes inherited from inet::OperationalBase
bool	isOperational
simtime_t	lastChange

Additional Inherited Members
Static Public Attributes inherited from inet::LayeredProtocolBase
static simsignal_t	packetSentToUpperSignal = registerSignal("packetSentToUpper")
static simsignal_t	packetReceivedFromUpperSignal = registerSignal("packetReceivedFromUpper")
static simsignal_t	packetFromUpperDroppedSignal = registerSignal("packetFromUpperDropped")
static simsignal_t	packetSentToLowerSignal = registerSignal("packetSentToLower")
static simsignal_t	packetReceivedFromLowerSignal = registerSignal("packetReceivedFromLower")
static simsignal_t	packetFromLowerDroppedSignal = registerSignal("packetFromLowerDropped")

Detailed Description

A simple flooding protocol.

This implementation uses plain flooding, i.e. it "remembers" (stores) already broadcasted messages in a list and does not rebroadcast them again, if it gets another copy of that message.

The maximum number of entires for that list can be defined in the .ini file (bcMaxEntries) as well as the time after which an entry is deleted (bcDelTime).

If you prefere a memory-less version you can comment out the

#define PLAINFLOODING 

Author

Daniel Willkomm

ported to Mixim 2.0 by Theodoros Kapourniotis

Member Typedef Documentation

typedef std::list<Bcast> inet::Flood::cBroadcastList

protected

Constructor & Destructor Documentation

inet::Flood::Flood ( )

inline

{}

Member Function Documentation

cMessage * inet::Flood::decapsMsg ( FloodDatagram *  floodDatagram )

protected

Decapsulates the packet from the received Network packet.

Referenced by handleLowerPacket().

{
    SimpleNetworkProtocolControlInfo *controlInfo = new SimpleNetworkProtocolControlInfo();
    controlInfo->setSourceAddress(floodDatagram->getSourceAddress());
    controlInfo->setProtocol(floodDatagram->getTransportProtocol());
    cPacket *transportPacket = floodDatagram->decapsulate();
    transportPacket->setControlInfo(controlInfo);
    delete floodDatagram;
    return transportPacket;
}

FloodDatagram * inet::Flood::encapsMsg ( cPacket *  appPkt )

protected

Encapsulates the received ApplPkt into a NetwPkt and set all needed header fields.

Referenced by handleUpperPacket().

{
    L3Address netwAddr;

    EV << "in encaps...\n";

    INetworkProtocolControlInfo *cInfo = check_and_cast_nullable<INetworkProtocolControlInfo *>(appPkt->removeControlInfo());
    FloodDatagram *pkt = new FloodDatagram(appPkt->getName(), appPkt->getKind());
    pkt->setBitLength(headerLength);

    if (cInfo == nullptr) {
        EV << "warning: Application layer did not specifiy a destination L3 address\n"
           << "\tusing broadcast address instead\n";
        netwAddr = netwAddr.getAddressType()->getBroadcastAddress();
    }
    else {
        pkt->setTransportProtocol(cInfo->getTransportProtocol());
        netwAddr = cInfo->getDestinationAddress();
        EV << "CInfo removed, netw addr=" << netwAddr << endl;
        delete cInfo;
    }

    pkt->setSrcAddr(myNetwAddr);
    pkt->setDestAddr(netwAddr);
    EV << " netw " << myNetwAddr << " sending packet" << endl;

    EV << "sendDown: nHop=L3BROADCAST -> message has to be broadcasted"
       << " -> set destMac=L2BROADCAST" << endl;

    setDownControlInfo(pkt, MACAddress::BROADCAST_ADDRESS);

    //encapsulate the application packet
    pkt->encapsulate(appPkt);
    EV << " pkt encapsulated\n";
    return pkt;
}

void inet::Flood::finish ( )

overridevirtual

{
    if (plainFlooding) {
        bcMsgs.clear();
    }
    recordScalar("nbDataPacketsReceived", nbDataPacketsReceived);
    recordScalar("nbDataPacketsSent", nbDataPacketsSent);
    recordScalar("nbDataPacketsForwarded", nbDataPacketsForwarded);
    if (nbDataPacketsReceived > 0) {
        recordScalar("meanNbHops", (double)nbHops / (double)nbDataPacketsReceived);
    }
    else {
        recordScalar("meanNbHops", 0);
    }
}

void inet::Flood::handleLowerPacket ( cPacket *  m )

overrideprotectedvirtual

Handle messages from lower layer.

Messages from the mac layer will be forwarded to the application only if the are broadcast or destined for this node.

If the arrived message is a broadcast message it is also reflooded only if the tll field is bigger than one. Before the message is handed back to the mac layer the ttl field is reduced by one to account for this hop.

In the case of plain flooding the message will only be processed if there is no corresponding entry in the bcMsgs list (notBroadcasted). Otherwise the message will be deleted.

Implements inet::LayeredProtocolBase.

{
    FloodDatagram *msg = check_and_cast<FloodDatagram *>(m);
    int protocol = msg->getTransportProtocol();

    //msg not broadcasted yet
    if (notBroadcasted(msg)) {
        //msg is for me
        if (interfaceTable->isLocalAddress(msg->getDestinationAddress())) {
            EV << " data msg for me! send to Upper" << endl;
            nbHops = nbHops + (defaultTtl + 1 - msg->getTtl());
            sendUp(decapsMsg(msg), protocol);
            nbDataPacketsReceived++;
        }
        //broadcast message
        else if (msg->getDestinationAddress().isBroadcast()) {
            //check ttl and rebroadcast
            if (msg->getTtl() > 1) {
                FloodDatagram *dMsg;
                EV << " data msg BROADCAST! ttl = " << msg->getTtl()
                   << " > 1 -> rebroadcast msg & send to upper\n";
                msg->setTtl(msg->getTtl() - 1);
                dMsg = msg->dup();
                setDownControlInfo(dMsg, MACAddress::BROADCAST_ADDRESS);
                sendDown(dMsg);
                nbDataPacketsForwarded++;
            }
            else
                EV << " max hops reached (ttl = " << msg->getTtl() << ") -> only send to upper\n";

            // message has to be forwarded to upper layer
            nbHops = nbHops + (defaultTtl + 1 - msg->getTtl());
            sendUp(decapsMsg(msg), protocol);
            nbDataPacketsReceived++;
        }
        //not for me -> rebroadcast
        else {
            //check ttl and rebroadcast
            if (msg->getTtl() > 1) {
                EV << " data msg not for me! ttl = " << msg->getTtl()
                   << " > 1 -> forward\n";
                msg->setTtl(msg->getTtl() - 1);
                // needs to set the next hop address again to broadcast
                cObject *const pCtrlInfo = msg->removeControlInfo();
                if (pCtrlInfo != nullptr)
                    delete pCtrlInfo;
                setDownControlInfo(msg, MACAddress::BROADCAST_ADDRESS);
                sendDown(msg);
                nbDataPacketsForwarded++;
            }
            else {
                //max hops reached -> delete
                EV << " max hops reached (ttl = " << msg->getTtl() << ") -> delete msg\n";
                delete msg;
            }
        }
    }
    else {
        EV << " data msg already BROADCASTed! delete msg\n";
        delete msg;
    }
}

void inet::Flood::handleUpperPacket ( cPacket *  m )

overrideprotectedvirtual

Handle messages from upper layer.

All messages have to get a sequence number and the ttl filed has to be specified.

Afterwards the messages can be handed to the mac layer. The mac address is set to -1 (broadcast address) because the message is flooded (i.e. has to be send to all neighbors)

In the case of plain flooding the message sequence number and source address has also be stored in the bcMsgs list, so that this message will not be rebroadcasted, if a copy will be flooded back from the neigbouring nodes.

If the maximum number of entries is reached the first (oldest) entry is deleted.

Implements inet::LayeredProtocolBase.

{
    FloodDatagram *msg = encapsMsg(m);

    msg->setSeqNum(seqNum);
    seqNum++;
    msg->setTtl(defaultTtl);

    if (plainFlooding) {
        if (bcMsgs.size() >= bcMaxEntries) {
            //serach the broadcast list of outdated entries and delete them
            for (auto it = bcMsgs.begin(); it != bcMsgs.end(); ) {
                if (it->delTime < simTime())
                    it = bcMsgs.erase(it);
                else
                    ++it;
            }
            //delete oldest entry if max size is reached
            if (bcMsgs.size() >= bcMaxEntries) {
                EV << "bcMsgs is full, delete oldest entry" << endl;
                bcMsgs.pop_front();
            }
        }
        bcMsgs.push_back(Bcast(msg->getSeqNum(), msg->getSourceAddress(), simTime() + bcDelTime));
    }
    //there is no routing so all messages are broadcast for the mac layer
    sendDown(msg);
    nbDataPacketsSent++;
}

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

overridevirtual

Reads all parameters from the ini file.

If a parameter is not specified in the ini file a default value will be set.

Reimplemented from inet::NetworkProtocolBase.

{
    NetworkProtocolBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        //initialize seqence number to 0
        seqNum = 0;
        nbDataPacketsReceived = 0;
        nbDataPacketsSent = 0;
        nbDataPacketsForwarded = 0;
        nbHops = 0;
        headerLength = par("headerLength");
        hasPar("defaultTtl") ? defaultTtl = par("defaultTtl") : defaultTtl = 5;
        hasPar("plainFlooding") ? plainFlooding = par("plainFlooding")
            : plainFlooding = true;

        EV << "defaultTtl = " << defaultTtl
           << " plainFlooding = " << plainFlooding << endl;

        if (plainFlooding) {
            //these parameters are only needed for plain flooding
            hasPar("bcMaxEntries") ? bcMaxEntries = par("bcMaxEntries") : bcMaxEntries = 30;

            hasPar("bcDelTime") ? bcDelTime = par("bcDelTime").doubleValue() : bcDelTime = 3.0;
            EV << "bcMaxEntries = " << bcMaxEntries
               << " bcDelTime = " << bcDelTime << endl;
        }
    }
    else if (stage == INITSTAGE_NETWORK_LAYER_3) {
        myNetwAddr = interfaceTable->getInterface(1)->getNetworkAddress();
    }
}

bool inet::Flood::notBroadcasted ( FloodDatagram *  msg )

protected

Checks whether a message was already broadcasted.

The bcMsgs list is searched for the arrived message.

If the message is in the list, it was already broadcasted and the function returns false.

Concurrently all outdated (older than bcDelTime) are deleted. If the list is full and a new message has to be entered, the oldest entry is deleted.

Referenced by handleLowerPacket().

{
    if (!plainFlooding)
        return true;

    //serach the broadcast list of outdated entries and delete them
    for (auto it = bcMsgs.begin(); it != bcMsgs.end(); ) {
        if (it->delTime < simTime()) {
            it = bcMsgs.erase(it);
        }
        //message was already broadcasted
        else if ((it->srcAddr == msg->getSourceAddress()) && (it->seqNum == msg->getSeqNum())) {
            // update entry
            it->delTime = simTime() + bcDelTime;
            return false;
        }
        else
            ++it;
    }

    //delete oldest entry if max size is reached
    if (bcMsgs.size() >= bcMaxEntries) {
        EV << "bcMsgs is full, delete oldest entry\n";
        bcMsgs.pop_front();
    }

    bcMsgs.push_back(Bcast(msg->getSeqNum(), msg->getSourceAddress(), simTime() + bcDelTime));
    return true;
}

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

inlineoverridevirtual

Initialization of omnetpp.ini parameters.

Reimplemented from inet::OperationalBase.

{ return NUM_INIT_STAGES; }

cObject * inet::Flood::setDownControlInfo ( cMessage *const  pMsg, const MACAddress &  pDestAddr  )

protectedvirtual

Attaches a "control info" (NetwToMac) structure (object) to the message pMsg.

Attaches a "control info" structure (object) to the down message pMsg.

This is most useful when passing packets between protocol layers of a protocol stack, the control info will contain the destination MAC address.

The "control info" object will be deleted when the message is deleted. Only one "control info" structure can be attached (the second setL3ToL2ControlInfo() call throws an error).

Parameters

pMsg	The message where the "control info" shall be attached.
pDestAddr	The MAC address of the message receiver.

Referenced by encapsMsg(), and handleLowerPacket().

{
    SimpleLinkLayerControlInfo *const cCtrlInfo = new SimpleLinkLayerControlInfo();
    cCtrlInfo->setDest(pDestAddr);
    pMsg->setControlInfo(cCtrlInfo);
    return cCtrlInfo;
}

Member Data Documentation

simtime_t inet::Flood::bcDelTime

protected

Time after which an entry for an already broadcasted msg can be deleted.

Referenced by handleUpperPacket(), initialize(), and notBroadcasted().

unsigned int inet::Flood::bcMaxEntries = 0

protected

Max number of entries in the list of already broadcasted messages.

Referenced by handleUpperPacket(), initialize(), and notBroadcasted().

cBroadcastList inet::Flood::bcMsgs

protected

List of already broadcasted messages.

Referenced by finish(), handleUpperPacket(), and notBroadcasted().

int inet::Flood::defaultTtl = 0

protected

Default time-to-live (ttl) used for this module.

Referenced by handleLowerPacket(), handleUpperPacket(), and initialize().

int inet::Flood::headerLength = 0

protected

Length of the header.

Referenced by encapsMsg(), and initialize().

L3Address inet::Flood::myNetwAddr

protected

cached variable of my networ address

Referenced by encapsMsg(), and initialize().

long inet::Flood::nbDataPacketsForwarded = 0

protected

Referenced by finish(), handleLowerPacket(), and initialize().

long inet::Flood::nbDataPacketsReceived = 0

protected

Referenced by finish(), handleLowerPacket(), and initialize().

long inet::Flood::nbDataPacketsSent = 0

protected

Referenced by finish(), handleUpperPacket(), and initialize().

long inet::Flood::nbHops = 0

protected

Referenced by finish(), handleLowerPacket(), and initialize().

bool inet::Flood::plainFlooding = false

protected

Defines whether to use plain flooding or not.

Referenced by finish(), handleUpperPacket(), initialize(), and notBroadcasted().

unsigned long inet::Flood::seqNum = 0

protected

Network layer sequence number.

Referenced by handleUpperPacket(), and initialize().

---

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

• Flood.h
• Flood.cc