3.35/doxygen/dsr-routing_8h_source.html

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2011 Yufei Cheng

 *

 * 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: Yufei Cheng   <yfcheng@ittc.ku.edu>

 *

 * 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 DSR_ROUTING_H

#define DSR_ROUTING_H


#include <map>

#include <list>

#include <vector>

#include <stdint.h>

#include <cassert>

#include <sys/types.h>


#include "ns3/callback.h"

#include "ns3/object.h"

#include "ns3/node.h"

#include "ns3/ptr.h"

#include "ns3/buffer.h"

#include "ns3/packet.h"

#include "ns3/ipv4.h"

#include "ns3/ip-l4-protocol.h"

#include "ns3/ipv4-l3-protocol.h"

#include "ns3/icmpv4-l4-protocol.h"

#include "ns3/ipv4-interface.h"

#include "ns3/ipv4-header.h"

#include "ns3/ipv4-address.h"

#include "ns3/traced-callback.h"

#include "ns3/random-variable-stream.h"

#include "ns3/ipv4-route.h"

#include "ns3/timer.h"

#include "ns3/net-device.h"

#include "ns3/output-stream-wrapper.h"

#include "ns3/wifi-mac.h"

#include "ns3/socket.h"

#include "ns3/event-garbage-collector.h"

#include "ns3/test.h"


#include "dsr-network-queue.h"

#include "dsr-rcache.h"

#include "dsr-rreq-table.h"

#include "dsr-maintain-buff.h"

#include "dsr-passive-buff.h"

#include "dsr-option-header.h"

#include "dsr-fs-header.h"

#include "dsr-rsendbuff.h"

#include "dsr-errorbuff.h"

#include "dsr-gratuitous-reply-table.h"


namespace ns3 {


class Packet;

class Node;

class Ipv4;

class Ipv4Address;

class Ipv4Header;

class Ipv4Interface;

class Ipv4L3Protocol;

class Time;


namespace dsr {


class DsrOptions;

class DsrRouting : public IpL4Protocol

{

public:

  static TypeId GetTypeId ();

  static const uint8_t PROT_NUMBER;

  DsrRouting ();

  virtual ~DsrRouting ();

  Ptr<Node> GetNode () const;

  void SetNode (Ptr<Node> node);

  void SetRouteCache (Ptr<dsr::DsrRouteCache> r);

  Ptr<dsr::DsrRouteCache> GetRouteCache () const;

  void SetRequestTable (Ptr<dsr::DsrRreqTable> r);

  Ptr<dsr::DsrRreqTable> GetRequestTable () const;

  void SetPassiveBuffer (Ptr<dsr::DsrPassiveBuffer> r);

  Ptr<dsr::DsrPassiveBuffer> GetPassiveBuffer () const;


  bool IsLinkCache ();


  void UseExtends (DsrRouteCacheEntry::IP_VECTOR rt);


  bool LookupRoute (Ipv4Address id, DsrRouteCacheEntry & rt);


  bool AddRoute_Link (DsrRouteCacheEntry::IP_VECTOR nodelist, Ipv4Address source);


  bool AddRoute (DsrRouteCacheEntry & rt);


  void DeleteAllRoutesIncludeLink (Ipv4Address errorSrc, Ipv4Address unreachNode, Ipv4Address node);


  bool UpdateRouteEntry (Ipv4Address dst);


  bool FindSourceEntry (Ipv4Address src, Ipv4Address dst, uint16_t id);


  Ptr<NetDevice> GetNetDeviceFromContext (std::string context);

  std::vector<std::string> GetElementsFromContext (std::string context);

  uint16_t GetIDfromIP (Ipv4Address address);

  Ipv4Address GetIPfromID (uint16_t id);

  Ipv4Address GetIPfromMAC (Mac48Address address);

  Ptr<Node> GetNodeWithAddress (Ipv4Address ipv4Address);

  void PrintVector (std::vector<Ipv4Address>& vec);

  Ipv4Address SearchNextHop (Ipv4Address ipv4Address, std::vector<Ipv4Address>& vec);

  int GetProtocolNumber (void) const;

  void SendBuffTimerExpire ();

  void CheckSendBuffer ();

  void PacketNewRoute (Ptr<Packet> packet,

                       Ipv4Address source,

                       Ipv4Address destination,

                       uint8_t protocol);

  Ptr<Ipv4Route> SetRoute (Ipv4Address nextHop, Ipv4Address srcAddress);

  uint32_t GetPriority (DsrMessageType messageType);

  void SendUnreachError (Ipv4Address unreachNode, Ipv4Address destination, Ipv4Address originalDst, uint8_t salvage, uint8_t protocol);

  void ForwardErrPacket (DsrOptionRerrUnreachHeader &rerr,

                         DsrOptionSRHeader &sourceRoute,

                         Ipv4Address nextHop,

                         uint8_t protocol,

                         Ptr<Ipv4Route> route);

  void Send (Ptr<Packet> packet, Ipv4Address source,

             Ipv4Address destination, uint8_t protocol, Ptr<Ipv4Route> route);

  uint16_t AddAckReqHeader (Ptr<Packet> &packet, Ipv4Address nextHop);

  void SendPacket (Ptr<Packet> packet, Ipv4Address source, Ipv4Address nextHop, uint8_t protocol);

  void Scheduler (uint32_t priority);

  void PriorityScheduler (uint32_t priority, bool continueWithFirst);

  void IncreaseRetransTimer ();

  bool SendRealDown (DsrNetworkQueueEntry & newEntry);

  void SendPacketFromBuffer (DsrOptionSRHeader const &sourceRoute,

                             Ipv4Address nextHop,

                             uint8_t protocol);

  bool PassiveEntryCheck (Ptr<Packet> packet, Ipv4Address source, Ipv4Address destination, uint8_t segsLeft,

                          uint16_t fragmentOffset, uint16_t identification, bool saveEntry);


  void CancelPacketAllTimer (DsrMaintainBuffEntry & mb);

  bool CancelPassiveTimer (Ptr<Packet> packet, Ipv4Address source, Ipv4Address destination, uint8_t segsLeft);

  void CallCancelPacketTimer (uint16_t ackId, Ipv4Header const& ipv4Header, Ipv4Address realSrc, Ipv4Address realDst);

  void CancelNetworkPacketTimer (DsrMaintainBuffEntry & mb);

  void CancelPassivePacketTimer (DsrMaintainBuffEntry & mb);

  void CancelLinkPacketTimer (DsrMaintainBuffEntry & mb);

  void CancelPacketTimerNextHop (Ipv4Address nextHop, uint8_t protocol);

  void SalvagePacket (Ptr<const Packet> packet, Ipv4Address source, Ipv4Address dst, uint8_t protocol);

  void ScheduleLinkPacketRetry   (DsrMaintainBuffEntry & mb,

                                  uint8_t protocol);

  void SchedulePassivePacketRetry   (DsrMaintainBuffEntry & mb,

                                     uint8_t protocol);

  void ScheduleNetworkPacketRetry   (DsrMaintainBuffEntry & mb,

                                     bool isFirst,

                                     uint8_t protocol);

  void LinkScheduleTimerExpire  (DsrMaintainBuffEntry & mb,

                                 uint8_t protocol);

  void NetworkScheduleTimerExpire  (DsrMaintainBuffEntry & mb,

                                    uint8_t protocol);

  void PassiveScheduleTimerExpire  (DsrMaintainBuffEntry & mb,

                                    uint8_t protocol);

  void ForwardPacket (Ptr<const Packet> packet,

                      DsrOptionSRHeader &sourceRoute,

                      Ipv4Header const& ipv4Header,

                      Ipv4Address source,

                      Ipv4Address destination,

                      Ipv4Address targetAddress,

                      uint8_t protocol,

                      Ptr<Ipv4Route> route);

  void SendInitialRequest (Ipv4Address source,

                           Ipv4Address destination,

                           uint8_t protocol);

  void SendErrorRequest (DsrOptionRerrUnreachHeader &rerr, uint8_t protocol);

  void SendRequest (Ptr<Packet> packet,

                    Ipv4Address source);

  void ScheduleInterRequest (Ptr<Packet> packet);

  void SendGratuitousReply (Ipv4Address replyTo,

                            Ipv4Address replyFrom,

                            std::vector<Ipv4Address> &nodeList,

                            uint8_t protocol);

  void SendReply (Ptr<Packet> packet,

                  Ipv4Address source,

                  Ipv4Address nextHop,

                  Ptr<Ipv4Route> route);

  void ScheduleInitialReply (Ptr<Packet> packet,

                             Ipv4Address source,

                             Ipv4Address nextHop,

                             Ptr<Ipv4Route> route);

  void ScheduleCachedReply (Ptr<Packet> packet,

                            Ipv4Address source,

                            Ipv4Address destination,

                            Ptr<Ipv4Route> route,

                            double hops);

  void SendAck   (uint16_t ackId,

                  Ipv4Address destination,

                  Ipv4Address realSrc,

                  Ipv4Address realDst,

                  uint8_t protocol,

                  Ptr<Ipv4Route> route);

  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

                                               Ipv4Header const &header,

                                               Ptr<Ipv4Interface> incomingInterface);


  virtual enum IpL4Protocol::RxStatus Receive (Ptr<Packet> p,

                                               Ipv6Header const &header,

                                               Ptr<Ipv6Interface> incomingInterface);


  void SetDownTarget (IpL4Protocol::DownTargetCallback callback);

  void SetDownTarget6 (IpL4Protocol::DownTargetCallback6 callback);

  IpL4Protocol::DownTargetCallback GetDownTarget (void) const;

  IpL4Protocol::DownTargetCallback6 GetDownTarget6 (void) const;

  uint8_t Process (Ptr<Packet>& packet, Ipv4Header const& ipv4Header, Ipv4Address dst, uint8_t *nextHeader, uint8_t protocol, bool& isDropped);

  void Insert (Ptr<dsr::DsrOptions> option);

  Ptr<dsr::DsrOptions> GetOption (int optionNumber);

  void CancelRreqTimer (Ipv4Address dst, bool isRemove);

  void ScheduleRreqRetry (Ptr<Packet> packet, std::vector<Ipv4Address> address, bool nonProp, uint32_t requestId, uint8_t protocol);

  void RouteRequestTimerExpire (Ptr<Packet> packet, std::vector<Ipv4Address> address, uint32_t requestId, uint8_t protocol);


  int64_t AssignStreams (int64_t stream);


protected:

  /*

 *    * This function will notify other components connected to the node that a new stack member is now connected

 *       * This will be used to notify Layer 3 protocol of layer 4 protocol stack to connect them together.

 *          */

  virtual void NotifyNewAggregate ();

  virtual void DoDispose (void);

  TracedCallback<Ptr<const Packet> > m_dropTrace;

  TracedCallback <const DsrOptionSRHeader &> m_txPacketTrace;


private:

  void Start ();

  void SendRerrWhenBreaksLinkToNextHop (Ipv4Address nextHop, uint8_t protocol);

  bool PromiscReceive (Ptr<NetDevice> device, Ptr<const Packet> packet, uint16_t protocol, const Address &from,

                       const Address &to, NetDevice::PacketType packetType);

  typedef std::list<Ptr<DsrOptions> > DsrOptionList_t;

  DsrOptionList_t m_options;


  Ptr<Ipv4L3Protocol> m_ipv4;


  Ptr<Ipv4Route> m_ipv4Route;


  Ptr<Ipv4> m_ip;


  Ptr<Node> m_node;


  Ipv4Address m_mainAddress;


  uint8_t segsLeft;


  IpL4Protocol::DownTargetCallback m_downTarget;


  uint32_t m_maxNetworkSize;


  Time m_maxNetworkDelay;


  uint32_t m_discoveryHopLimit;


  uint8_t m_maxSalvageCount;


  Time  m_requestPeriod;


  Time m_nonpropRequestTimeout;


  uint32_t m_sendRetries;


  uint32_t m_passiveRetries;


  uint32_t m_linkRetries;


  uint32_t m_rreqRetries;


  uint32_t m_maxMaintRexmt;


  Time m_nodeTraversalTime;


  uint32_t m_maxSendBuffLen;


  Time  m_sendBufferTimeout;


  DsrSendBuffer m_sendBuffer;


  DsrErrorBuffer m_errorBuffer;


  uint32_t  m_maxMaintainLen;


  Time     m_maxMaintainTime;


  uint32_t m_maxCacheLen;


  Time   m_maxCacheTime;


  Time  m_maxRreqTime;


  uint32_t  m_maxEntriesEachDst;


  DsrMaintainBuffer m_maintainBuffer;


  uint32_t m_requestId;


  uint16_t m_ackId;


  uint32_t m_requestTableSize;


  uint32_t m_requestTableIds;


  uint32_t m_maxRreqId;


  Time  m_blacklistTimeout;


  Ipv4Address m_broadcast;


  uint32_t m_broadcastJitter;


  Time  m_passiveAckTimeout;


  uint32_t m_tryPassiveAcks;


  Time  m_linkAckTimeout;


  uint32_t m_tryLinkAcks;


  Timer m_sendBuffTimer;


  Time m_sendBuffInterval;


  Time  m_gratReplyHoldoff;


  Time m_maxRequestPeriod;


  uint32_t m_graReplyTableSize;


  std::string m_cacheType;


  std::string m_routeSortType;


  uint32_t m_stabilityDecrFactor;


  uint32_t m_stabilityIncrFactor;


  Time m_initStability;


  Time m_minLifeTime;


  Time m_useExtends;


  bool m_subRoute;


  Time m_retransIncr;


  std::vector<Ipv4Address> m_finalRoute;


  std::map<Ipv4Address, Timer> m_addressReqTimer;


  std::map<Ipv4Address, Timer> m_nonPropReqTimer;


  std::map<NetworkKey, Timer>  m_addressForwardTimer;


  std::map<NetworkKey, uint32_t> m_addressForwardCnt;


  std::map<PassiveKey, uint32_t> m_passiveCnt;


  std::map<PassiveKey, Timer> m_passiveAckTimer;


  std::map<LinkKey, uint32_t> m_linkCnt;


  std::map<LinkKey, Timer> m_linkAckTimer;


  Ptr<dsr::DsrRouteCache> m_routeCache;


  Ptr<dsr::DsrRreqTable> m_rreqTable;


  Ptr<dsr::DsrPassiveBuffer> m_passiveBuffer;


  uint32_t m_numPriorityQueues;


  bool m_linkAck;


  std::map<uint32_t, Ptr<dsr::DsrNetworkQueue> > m_priorityQueue;


  DsrGraReply m_graReply;


  DsrNetworkQueue m_networkQueue;


  std::vector<Ipv4Address> m_clearList;


  std::vector<Ipv4Address> m_addresses;


  std::map <std::string, uint32_t> m_macToNodeIdMap;


  Ptr<UniformRandomVariable> m_uniformRandomVariable;

};

}  /* namespace dsr */

}  /* namespace ns3 */


#endif /* DSR_ROUTING_H */