Flood.cc

/* -*- mode:c++ -*- ********************************************************
 * file:        Flood.cc
 *
 * author:      Daniel Willkomm
 *
 * copyright:   (C) 2004 Telecommunication Networks Group (TKN) at
 *              Technische Universitaet Berlin, Germany.
 *
 *              This program is free software; you can redistribute it 
 *              and/or modify it under the terms of the GNU General Public 
 *              License as published by the Free Software Foundation; either
 *              version 2 of the License, or (at your option) any later 
 *              version.
 *              For further information see file COPYING 
 *              in the top level directory
 *
 ***************************************************************************
 * part of:     framework implementation developed by tkn
 * description: a simple flooding protocol
 *              the user can decide whether to use plain flooding or not
 **************************************************************************/

#include "Flood.h"
#include <NetwPkt_m.h>
#include "NetwControlInfo.h"
#include "NetwToMacControlInfo.h"
#include <cassert>

Define_Module(Flood)
;

void Flood::initialize(int stage) {
  BaseNetwLayer::initialize(stage);

  if (stage == 0) {
    //initialize seqence number to 0
    seqNum = 0;
    nbDataPacketsReceived = 0;
    nbDataPacketsSent = 0;
    nbDataPacketsForwarded = 0;
    nbHops = 0;
    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") : bcDelTime = 3.0;
      EV <<"bcMaxEntries = "<<bcMaxEntries
      <<" bcDelTime = "<<bcDelTime<<endl;
    }
  }
}

void Flood::finish() {
  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 Flood::handleUpperMsg(cMessage* m) {

  assert(dynamic_cast<cPacket*> (m));
  NetwPkt *msg = encapsMsg(static_cast<cPacket*> (m));

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

  if (plainFlooding) {
    if (bcMsgs.size() >= bcMaxEntries) {
      cBroadcastList::iterator it;

      //serach the broadcast list of outdated entries and delete them
      for (it = bcMsgs.begin(); it != bcMsgs.end(); ++it) {
        if (it->delTime < simTime()) {
          bcMsgs.erase(it);
          it--;
          break;
        }
      }
      //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->getSrcAddr(), simTime() +bcDelTime));
    }
        //there is no routing so all messages are broadacst for the mac layer

        sendDown(msg);
        nbDataPacketsSent++;
      }

void Flood::handleLowerMsg(cMessage* m) {
  NetwPkt *msg = static_cast<NetwPkt *> (m);

  //msg not broadcastes yet
  if (notBroadcasted(msg)) {
    //msg is for me
    if (msg->getDestAddr() == myNetwAddr) {
      EV<<" data msg for me! send to Upper"<<endl;
      nbHops = nbHops + (defaultTtl + 1 - msg->getTtl());
      sendUp( decapsMsg(msg) );
      nbDataPacketsReceived++;
    }
    //broadcast message
    else if( msg->getDestAddr() == L3BROADCAST ) {
      //check ttl and rebroadcast
      if( msg->getTtl() > 1 ) {
        NetwPkt *dMsg;
        EV <<" data msg BROADCAST! ttl = "<<msg->getTtl()
        <<" > 1 -> rebroadcast msg & send to upper\n";
        msg->setTtl( msg->getTtl()-1 );
        dMsg = static_cast<NetwPkt*>(msg->dup());
        dMsg->setControlInfo(new NetwToMacControlInfo(L2BROADCAST));
        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) );
      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
        msg->removeControlInfo();
        msg->setControlInfo(new NetwToMacControlInfo(L2BROADCAST));
        //            EV << static_cast<NetwToMacControlInfo*>(msg->getControlInfo())->getNextHopMac() << "\n";
        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;
  }
}

bool Flood::notBroadcasted(NetwPkt* msg) {
  if (!plainFlooding)
    return true;

  cBroadcastList::iterator it;

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

  //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->getSrcAddr(), simTime() +bcDelTime));
    return true;
}

NetwPkt* Flood::encapsMsg(cPacket *appPkt) {
  int macAddr;
  int netwAddr;

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

  NetwPkt *pkt = new NetwPkt(appPkt->getName(), appPkt->getKind());
  pkt->setBitLength(headerLength);

  NetwControlInfo* cInfo = dynamic_cast<NetwControlInfo*>(appPkt->removeControlInfo());

    if(cInfo == 0){
  EV << "warning: Application layer did not specifiy a destination L3 address\n"
     << "\tusing broadcast address instead\n";
  netwAddr = L3BROADCAST;
    } else {
  EV <<"CInfo removed, netw addr="<< cInfo->getNetwAddr()<<endl;
        netwAddr = cInfo->getNetwAddr();
  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\n";
        macAddr = L2BROADCAST;


    pkt->setControlInfo(new NetwToMacControlInfo(macAddr));

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