aodv-routing-protocol.h

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2009 IITP RAS
 *
 * 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
 *
 * Based on 
 *      NS-2 AODV model developed by the CMU/MONARCH group and optimized and
 *      tuned by Samir Das and Mahesh Marina, University of Cincinnati;
 * 
 *      AODV-UU implementation by Erik Nordström of Uppsala University
 *      http://core.it.uu.se/core/index.php/AODV-UU
 *
 * Authors: Elena Buchatskaia <borovkovaes@iitp.ru>
 *          Pavel Boyko <boyko@iitp.ru>
 */
#ifndef AODVROUTINGPROTOCOL_H
#define AODVROUTINGPROTOCOL_H

#include "aodv-rtable.h"
#include "aodv-rqueue.h"
#include "aodv-packet.h"
#include "aodv-neighbor.h"
#include "aodv-dpd.h"
#include "ns3/node.h"
#include "ns3/random-variable-stream.h"
#include "ns3/output-stream-wrapper.h"
#include "ns3/ipv4-routing-protocol.h"
#include "ns3/ipv4-interface.h"
#include "ns3/ipv4-l3-protocol.h"
#include "ns3/repository.h"
#include <map>

namespace ns3
{
namespace aodv
{
class RoutingProtocol : public Ipv4RoutingProtocol
{
public:
  static TypeId GetTypeId (void);
  static const uint32_t AODV_PORT;

  RoutingProtocol ();
  virtual ~RoutingProtocol();
  virtual void DoDispose ();

  //\{
  Ptr<Ipv4Route> RouteOutput (Ptr<Packet> p, const Ipv4Header &header, Ptr<NetDevice> oif, Socket::SocketErrno &sockerr);
  bool RouteInput (Ptr<const Packet> p, const Ipv4Header &header, Ptr<const NetDevice> idev,
                   UnicastForwardCallback ucb, MulticastForwardCallback mcb,
                   LocalDeliverCallback lcb, ErrorCallback ecb);
  virtual void NotifyInterfaceUp (uint32_t interface);
  virtual void NotifyInterfaceDown (uint32_t interface);
  virtual void NotifyAddAddress (uint32_t interface, Ipv4InterfaceAddress address);
  virtual void NotifyRemoveAddress (uint32_t interface, Ipv4InterfaceAddress address);
  virtual void SetIpv4 (Ptr<Ipv4> ipv4);
  virtual void PrintRoutingTable (Ptr<OutputStreamWrapper> stream) const;
  void SetRepository(Ptr<Repository> repo);
  void SendHello ();
  //\}

  //\{
  Time GetMaxQueueTime () const { return MaxQueueTime; }
  void SetMaxQueueTime (Time t);
  uint32_t GetMaxQueueLen () const { return MaxQueueLen; }
  void SetMaxQueueLen (uint32_t len);
  bool GetDesinationOnlyFlag () const { return DestinationOnly; }
  void SetDesinationOnlyFlag (bool f) { DestinationOnly = f; }
  bool GetGratuitousReplyFlag () const { return GratuitousReply; }
  void SetGratuitousReplyFlag (bool f) { GratuitousReply = f; }
  void SetHelloEnable (bool f) { EnableHello = f; }
  bool GetHelloEnable () const { return EnableHello; }
  void SetBroadcastEnable (bool f) { EnableBroadcast = f; }
  bool GetBroadcastEnable () const { return EnableBroadcast; }
  //\}

  int64_t AssignStreams (int64_t stream);

private:
  //\{
  uint32_t RreqRetries;             
  uint16_t RreqRateLimit;           
  uint16_t RerrRateLimit;           
  Time ActiveRouteTimeout;          
  uint32_t NetDiameter;             

  Time NodeTraversalTime;
  Time NetTraversalTime;             
  Time PathDiscoveryTime;            
  Time MyRouteTimeout;               

  Time HelloInterval;
  uint32_t AllowedHelloLoss;         

  Time DeletePeriod;
  Time NextHopWait;                  

  uint16_t TimeoutBuffer;
  Time BlackListTimeout;             
  uint32_t MaxQueueLen;              
  Time MaxQueueTime;                 
  bool DestinationOnly;              
  bool GratuitousReply;              
  bool EnableHello;                  
  bool EnableBroadcast;              
  //\}

  Ptr<Ipv4> m_ipv4;
  std::map< Ptr<Socket>, Ipv4InterfaceAddress > m_socketAddresses;
  Ptr<NetDevice> m_lo; 

  Ptr<Repository> m_crRepository;
  RoutingTable m_routingTable;
  RequestQueue m_queue;
  uint32_t m_requestId;
  uint32_t m_seqNo;
  IdCache m_rreqIdCache;
  DuplicatePacketDetection m_dpd;
  Neighbors m_nb;
  uint16_t m_rreqCount;
  uint16_t m_rerrCount;

private:
  void Start ();
  void DeferredRouteOutput (Ptr<const Packet> p, const Ipv4Header & header, UnicastForwardCallback ucb, ErrorCallback ecb);
  bool Forwarding (Ptr<const Packet> p, const Ipv4Header & header, UnicastForwardCallback ucb, ErrorCallback ecb);
  void ScheduleRreqRetry (Ipv4Address dst);
  bool UpdateRouteLifeTime (Ipv4Address addr, Time lt);
  void UpdateRouteToNeighbor (Ipv4Address sender, Ipv4Address receiver);
  bool IsMyOwnAddress (Ipv4Address src);
  Ptr<Socket> FindSocketWithInterfaceAddress (Ipv4InterfaceAddress iface) const;
  void ProcessHello (RrepHeader const & rrepHeader, Ipv4Address receiverIfaceAddr);
  Ptr<Ipv4Route> LoopbackRoute (const Ipv4Header & header, Ptr<NetDevice> oif) const;

  //\{
  void RecvAodv (Ptr<Socket> socket);
  void RecvRequest (Ptr<Packet> p, Ipv4Address receiver, Ipv4Address src);
  void RecvReply (Ptr<Packet> p, Ipv4Address my,Ipv4Address src);
  void RecvReplyAck (Ipv4Address neighbor);
  void RecvError (Ptr<Packet> p, Ipv4Address src);
  //\}

  //\{
  void SendPacketFromQueue (Ipv4Address dst, Ptr<Ipv4Route> route, uint16_t channel);
  void SendRequest (Ipv4Address dst);
  void SendReply (RreqHeader const & rreqHeader, RoutingTableEntry const & toOrigin);
  void SendReplyByIntermediateNode (RoutingTableEntry & toDst, RoutingTableEntry & toOrigin, bool gratRep);
  void SendReplyAck (Ipv4Address neighbor);
  void SendRerrWhenBreaksLinkToNextHop (Ipv4Address nextHop);
  void SendRerrMessage (Ptr<Packet> packet,  std::vector<Ipv4Address> precursors);
  void SendRerrWhenNoRouteToForward (Ipv4Address dst, uint32_t dstSeqNo, Ipv4Address origin);
  //\}

  Timer m_htimer;
  void HelloTimerExpire ();
  Timer m_rreqRateLimitTimer;
  void RreqRateLimitTimerExpire ();
  Timer m_rerrRateLimitTimer;
  void RerrRateLimitTimerExpire ();
  std::map<Ipv4Address, Timer> m_addressReqTimer;
  void RouteRequestTimerExpire (Ipv4Address dst);
  void AckTimerExpire (Ipv4Address neighbor,  Time blacklistTimeout);

  Ptr<UniformRandomVariable> m_uniformRandomVariable;  
};

}
}
#endif /* AODVROUTINGPROTOCOL_H */