dsdv-rtable.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2010 Hemanth Narra
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Hemanth Narra <hemanth@ittc.ku.com>
 *
 * James P.G. Sterbenz <jpgs@ittc.ku.edu>, director
 * ResiliNets Research Group  http://wiki.ittc.ku.edu/resilinets
 * Information and Telecommunication Technology Center (ITTC)
 * and Department of Electrical Engineering and Computer Science
 * The University of Kansas Lawrence, KS USA.
 *
 * Work supported in part by NSF FIND (Future Internet Design) Program
 * under grant CNS-0626918 (Postmodern Internet Architecture),
 * NSF grant CNS-1050226 (Multilayer Network Resilience Analysis and Experimentation on GENI),
 * US Department of Defense (DoD), and ITTC at The University of Kansas.
 */

#ifndef DSDV_RTABLE_H
#define DSDV_RTABLE_H

#include <cassert>
#include <map>
#include <sys/types.h>
#include "ns3/ipv4.h"
#include "ns3/ipv4-route.h"
#include "ns3/timer.h"
#include "ns3/net-device.h"
#include "ns3/output-stream-wrapper.h"

namespace ns3 {
namespace dsdv {
enum RouteFlags
{
  VALID = 0,     // !< VALID
  INVALID = 1,     // !< INVALID
};

class RoutingTableEntry
{
public:
  RoutingTableEntry (Ptr<NetDevice> dev = 0, Ipv4Address dst = Ipv4Address (), u_int32_t m_seqNo = 0,
                     Ipv4InterfaceAddress iface = Ipv4InterfaceAddress (), u_int32_t hops = 0, Ipv4Address nextHop = Ipv4Address (),
                     Time lifetime = Simulator::Now (), Time SettlingTime = Simulator::Now (), bool changedEntries = false);

  ~RoutingTableEntry ();
  Ipv4Address
  GetDestination () const
  {
    return m_ipv4Route->GetDestination ();
  }
  Ptr<Ipv4Route>
  GetRoute () const
  {
    return m_ipv4Route;
  }
  void
  SetRoute (Ptr<Ipv4Route> route)
  {
    m_ipv4Route = route;
  }
  void
  SetNextHop (Ipv4Address nextHop)
  {
    m_ipv4Route->SetGateway (nextHop);
  }
  Ipv4Address
  GetNextHop () const
  {
    return m_ipv4Route->GetGateway ();
  }
  void
  SetOutputDevice (Ptr<NetDevice> device)
  {
    m_ipv4Route->SetOutputDevice (device);
  }
  Ptr<NetDevice>
  GetOutputDevice () const
  {
    return m_ipv4Route->GetOutputDevice ();
  }
  Ipv4InterfaceAddress
  GetInterface () const
  {
    return m_iface;
  }
  void
  SetInterface (Ipv4InterfaceAddress iface)
  {
    m_iface = iface;
  }
  void
  SetSeqNo (uint32_t sequenceNumber)
  {
    m_seqNo = sequenceNumber;
  }
  uint32_t
  GetSeqNo () const
  {
    return m_seqNo;
  }
  void
  SetHop (uint32_t hopCount)
  {
    m_hops = hopCount;
  }
  uint32_t
  GetHop () const
  {
    return m_hops;
  }
  void
  SetLifeTime (Time lifeTime)
  {
    m_lifeTime = lifeTime;
  }
  Time
  GetLifeTime () const
  {
    return (Simulator::Now () - m_lifeTime);
  }
  void
  SetSettlingTime (Time settlingTime)
  {
    m_settlingTime = settlingTime;
  }
  Time
  GetSettlingTime () const
  {
    return (m_settlingTime);
  }
  void
  SetFlag (RouteFlags flag)
  {
    m_flag = flag;
  }
  RouteFlags
  GetFlag () const
  {
    return m_flag;
  }
  void
  SetEntriesChanged (bool entriesChanged)
  {
    m_entriesChanged = entriesChanged;
  }
  bool
  GetEntriesChanged () const
  {
    return m_entriesChanged;
  }
  bool
  operator== (Ipv4Address const destination) const
  {
    return (m_ipv4Route->GetDestination () == destination);
  }
  void
  Print (Ptr<OutputStreamWrapper> stream) const;

private:
  // \{
  uint32_t m_seqNo;
  uint32_t m_hops;
  Time m_lifeTime;
  Ptr<Ipv4Route> m_ipv4Route;
  Ipv4InterfaceAddress m_iface;
  RouteFlags m_flag;
  Time m_settlingTime;
  uint32_t m_entriesChanged;
  //\}
};

class RoutingTable
{
public:
  RoutingTable ();
  bool
  AddRoute (RoutingTableEntry & r);
  bool
  DeleteRoute (Ipv4Address dst);
  bool
  LookupRoute (Ipv4Address dst, RoutingTableEntry & rt);
  bool
  LookupRoute (Ipv4Address id, RoutingTableEntry & rt, bool forRouteInput);
  bool
  Update (RoutingTableEntry & rt);
  void
  GetListOfDestinationWithNextHop (Ipv4Address nxtHp, std::map<Ipv4Address, RoutingTableEntry> & dstList);
  void
  GetListOfAllRoutes (std::map<Ipv4Address, RoutingTableEntry> & allRoutes);
  void
  DeleteAllRoutesFromInterface (Ipv4InterfaceAddress iface);
  void
  Clear ()
  {
    m_ipv4AddressEntry.clear ();
  }
  void
  Purge (std::map<Ipv4Address, RoutingTableEntry> & removedAddresses);
  void
  Print (Ptr<OutputStreamWrapper> stream) const;
  uint32_t
  RoutingTableSize ();
  bool
  AddIpv4Event (Ipv4Address address, EventId id);
  bool
  DeleteIpv4Event (Ipv4Address address);
  bool
  AnyRunningEvent (Ipv4Address address);
  bool
  ForceDeleteIpv4Event (Ipv4Address address);
  EventId
  GetEventId (Ipv4Address address);
  // \{
  Time Getholddowntime () const
  {
    return m_holddownTime;
  }
  void Setholddowntime (Time t)
  {
    m_holddownTime = t;
  }
  // \}

private:
  // \{
  std::map<Ipv4Address, RoutingTableEntry> m_ipv4AddressEntry;
  std::map<Ipv4Address, EventId> m_ipv4Events;
  Time m_holddownTime;
  // \}
};
}
}
#endif /* DSDV_RTABLE_H */