aodv-routing-protocol.h

Go to the documentation of this file.

/* -*- 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 <map>
 
namespace ns3 {
 
class WifiMacQueueItem;
enum WifiMacDropReason : uint8_t;  // opaque enum declaration
 
namespace aodv {
class RoutingProtocol : public Ipv4RoutingProtocol
{
public:
  static TypeId GetTypeId (void);
  static const uint32_t AODV_PORT;
 
  RoutingProtocol ();
  virtual ~RoutingProtocol ();
  virtual void DoDispose ();
 
  // Inherited from Ipv4RoutingProtocol
  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, Time::Unit unit = Time::S) const;
 
  // Handle protocol parameters
  Time GetMaxQueueTime () const
  {
    return m_maxQueueTime;
  }
  void SetMaxQueueTime (Time t);
  uint32_t GetMaxQueueLen () const
  {
    return m_maxQueueLen;
  }
  void SetMaxQueueLen (uint32_t len);
  bool GetDestinationOnlyFlag () const
  {
    return m_destinationOnly;
  }
  void SetDestinationOnlyFlag (bool f)
  {
    m_destinationOnly = f;
  }
  bool GetGratuitousReplyFlag () const
  {
    return m_gratuitousReply;
  }
  void SetGratuitousReplyFlag (bool f)
  {
    m_gratuitousReply = f;
  }
  void SetHelloEnable (bool f)
  {
    m_enableHello = f;
  }
  bool GetHelloEnable () const
  {
    return m_enableHello;
  }
  void SetBroadcastEnable (bool f)
  {
    m_enableBroadcast = f;
  }
  bool GetBroadcastEnable () const
  {
    return m_enableBroadcast;
  }
 
  int64_t AssignStreams (int64_t stream);
 
protected:
  virtual void DoInitialize (void);
private:
  void NotifyTxError (WifiMacDropReason reason, Ptr<const WifiMacQueueItem> mpdu);
 
  // Protocol parameters.
  uint32_t m_rreqRetries;             
  uint16_t m_ttlStart;                
  uint16_t m_ttlIncrement;            
  uint16_t m_ttlThreshold;            
  uint16_t m_timeoutBuffer;           
  uint16_t m_rreqRateLimit;           
  uint16_t m_rerrRateLimit;           
  Time m_activeRouteTimeout;          
  uint32_t m_netDiameter;             
  Time m_nodeTraversalTime;
  Time m_netTraversalTime;             
  Time m_pathDiscoveryTime;            
  Time m_myRouteTimeout;               
  Time m_helloInterval;
  uint32_t m_allowedHelloLoss;         
  Time m_deletePeriod;
  Time m_nextHopWait;                  
  Time m_blackListTimeout;             
  uint32_t m_maxQueueLen;              
  Time m_maxQueueTime;                 
  bool m_destinationOnly;              
  bool m_gratuitousReply;              
  bool m_enableHello;                  
  bool m_enableBroadcast;              
  //\}
 
  Ptr<Ipv4> m_ipv4;
  std::map< Ptr<Socket>, Ipv4InterfaceAddress > m_socketAddresses;
  std::map< Ptr<Socket>, Ipv4InterfaceAddress > m_socketSubnetBroadcastAddresses;
  Ptr<NetDevice> m_lo;
 
  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;
  Ptr<Socket> FindSubnetBroadcastSocketWithInterfaceAddress (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);
  void SendHello ();
  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);
 
  void SendTo (Ptr<Socket> socket, Ptr<Packet> packet, Ipv4Address destination);
 
  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;
  Time m_lastBcastTime;
};
 
} //namespace aodv
} //namespace ns3
 
#endif /* AODVROUTINGPROTOCOL_H */