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

 * \brief Dsr Routing base

 */

class DsrRouting : public IpL4Protocol

{

public:

  /**

   * \brief Get the type identificator.

   * \return type identificator

   */

  static TypeId GetTypeId ();

  /**

    * \brief Define the dsr protocol number.

    */

  static const uint8_t PROT_NUMBER;

  /**

   * \brief Constructor.

   */

  DsrRouting ();

  /**

   * \brief Destructor.

   */

  virtual ~DsrRouting ();

  /**

   * \brief Get the node.

   * \return the node

   */

  Ptr<Node> GetNode () const;

  /**

   * \brief Set the node.

   * \param node the node to set

   */

  void SetNode (Ptr<Node> node);

  /**

   * \brief Set the route cache.

   * \param the route cache to set

   */

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

  /**

   * \brief Get the route cache.

   * \return the route cache

   */

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

  /**

   * \brief Set the node.

   * \param the request table to set

   */

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

  /**

    * \brief Get the request table.

    * \return the request table

    */

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

  /**

   * \brief Set the node.

   * \param the passive buffer to set

   */

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

  /**

    * \brief Get the passive buffer

    * \return the passive buffer

    */

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

  ///\functions used to direct to route cache

  //\{

  bool IsLinkCache ();

  void UseExtends (RouteCacheEntry::IP_VECTOR rt);

  bool LookupRoute (Ipv4Address id, RouteCacheEntry & rt);

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

  bool AddRoute (RouteCacheEntry & rt);

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

  bool UpdateRouteEntry (Ipv4Address dst);

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

  //\}

  /**

    * \brief Connect the callback for the tracing event.

    * \return void

    */

  void ConnectCallbacks ();

  /**

    * \brief Get the netdevice from the context.

    * \return the netdevice we are looking for

    */

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

  /**

    * \brief Get the elements from the tracing context.

    * \return the elements we are looking for

    */

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

  /**

    * \brief Get the node id from ip address.

    * \return the node id

    */

  uint16_t GetIDfromIP (Ipv4Address address);

  /**

    * \brief Get the ip address from id.

    * \return the ip address for the id

    */

  Ipv4Address GetIPfromID (uint16_t id);

  /**

    * \brief Get the Ip address from mac address.

    * \return the ip address

    */

  Ipv4Address GetIPfromMAC (Mac48Address address);

  /**

    * \brief Get the node with give ip address.

    * \return the node associated with the ip address

    */

  Ptr<Node> GetNodeWithAddress (Ipv4Address ipv4Address);

  /**

    * \brief Print the route vector.

    */

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

  /**

    * \brief Get the next hop of the route.

    * \return the next hop address of the route

    */

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

  /**

    * \brief Get the dsr protocol number.

    * \return protocol number

    */

  int GetProtocolNumber (void) const;

  /**

    * \brief The send buffer timer expire.

    */

  void SendBuffTimerExpire ();

  /**

    * \brief Check the send buffer of packets with route when send buffer timer expire.

    */

  void CheckSendBuffer ();

  /**

    * \brief When route vector corrupted, originate a new packet, normally not happening.

    */

  void PacketNewRoute (Ptr<Packet> packet,

                       Ipv4Address source,

                       Ipv4Address destination,

                       uint8_t protocol);

  /**

   * \brief Set the route to use for data packets

   * \return the route

   * \used by the option headers when sending data/control packets

   */

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

  /**

   * \brief Set the priority of the packet in network queue

   * \return the priority value

   */

  uint32_t GetPriority (DsrMessageType messageType);

  /**

   * \brief This function is responsible for sending error packets in case of break link to next hop

   */

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

  /**

   * \brief This function is responsible for forwarding error packets along the route

   */

  void ForwardErrPacket (DsrOptionRerrUnreachHeader &rerr,

                         DsrOptionSRHeader &sourceRoute,

                         Ipv4Address nextHop,

                         uint8_t protocol,

                         Ptr<Ipv4Route> route);

  /**

   * \brief This function is called by higher layer protocol when sending packets

   */

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

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

  /**

   * \brief This function is called to add ack request header for network acknowledgement

   */

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

  /**

   * \brief This function is called by when really sending out the packet

   */

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

  /**

   * \brief This function is called to schedule sending packets from the network queue

   */

  void Scheduler (uint32_t priority);

  /**

   * \brief This function is called to schedule sending packets from the network queue by priority

   */

  void PriorityScheduler (uint32_t priority, bool continueWithFirst);

  /**

   * \brief This function is called to increase the retransmission timer for data packet in the network queue

   */

  void IncreaseRetransTimer ();

  /**

   * \brief This function is called to send packets down stack

   */

  bool SendRealDown (DsrNetworkQueueEntry & newEntry);

  /**

   * \brief This function is responsible for sending out data packets when have route, if no route found, it will

   * cache the packet and send out route requests

   */

  void SendPacketFromBuffer (DsrOptionSRHeader const &sourceRoute,

                             Ipv4Address nextHop,

                             uint8_t protocol);

  /**

   * \brief Find the same passive entry

   */

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

                          uint16_t fragmentOffset, uint16_t identification, bool saveEntry);

  /**

   * \brief Cancel the passive timer

   */

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

  /**

   * \brief Call the cancel packet retransmission timer function

   */

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

  /**

   * \brief Cancel the network packet retransmission timer for a specific maintenance entry

   */

  void CancelNetworkPacketTimer (MaintainBuffEntry & mb);

  /**

   * \brief Cancel the passive packet retransmission timer for a specific maintenance entry

   */

  void CancelPassivePacketTimer (MaintainBuffEntry & mb);

  /**

   * \brief Cancel the link packet retransmission timer for a specific maintenance entry

   */

  void CancelLinkPacketTimer (MaintainBuffEntry & mb);

  /**

   * \brief Cancel the packet retransmission timer for a all maintenance entries with nextHop address

   */

  void CancelPacketTimerNextHop (Ipv4Address nextHop, uint8_t protocol);

  /**

   * \brief Salvage the packet which has been transmitted for 3 times

   */

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

  /**

   * \brief Schedule the packet retransmission based on link-layer acknowledgment

   * \param mb maintainenace buffer entry

   * \param protocol the protocol number

   */

  void ScheduleLinkPacketRetry   (MaintainBuffEntry & mb,

                                  uint8_t protocol);

  /**

   * \brief Schedule the packet retransmission based on passive acknowledgment

   * \param mb maintainenace buffer entry

   * \param protocol the protocol number

   */

  void SchedulePassivePacketRetry   (MaintainBuffEntry & mb,

                                     uint8_t protocol);

  /**

   * \brief Schedule the packet retransmission based on network layer acknowledgment

   * \param mb maintainenace buffer entry

   * \param isFirst see if this is the first packet retry or not

   * \param protocol the protocol number

   */

  void ScheduleNetworkPacketRetry   (MaintainBuffEntry & mb,

                                     bool isFirst,

                                     uint8_t protocol);

  /**

   * \brief This function deals with packet retransmission timer expire using link acknowledgment

   */

  void LinkScheduleTimerExpire  (MaintainBuffEntry & mb,

                                 uint8_t protocol);

  /**

   * \brief This function deals with packet retransmission timer expire using network acknowledgment

   */

  void NetworkScheduleTimerExpire  (MaintainBuffEntry & mb,

                                    uint8_t protocol);

  /**

   * \brief This function deals with packet retransmission timer expire using passive acknowledgment

   */

  void PassiveScheduleTimerExpire  (MaintainBuffEntry & mb,

                                    uint8_t protocol);

  /**

   * \brief Forward the packet using the route saved in the source route option header

   */

  void ForwardPacket (Ptr<const Packet> packet,

                      DsrOptionSRHeader &sourceRoute,

                      Ipv4Header const& ipv4Header,

                      Ipv4Address source,

                      Ipv4Address destination,

                      Ipv4Address targetAddress,

                      uint8_t protocol,

                      Ptr<Ipv4Route> route);

  /**

   * \brief Broadcast the route request packet in subnet

   */

  void SendInitialRequest (Ipv4Address source,

                           Ipv4Address destination,

                           uint8_t protocol);

  /**

   * \brief Send the error request packet

   * \param the route error header

   * \param the protocol number

   */

  void SendErrorRequest (DsrOptionRerrUnreachHeader &rerr, uint8_t protocol);

  /**

   * \brief Forward the route request if the node is not the destination

   * \param the original packet

   * \param source address

   */

  void SendRequest (Ptr<Packet> packet,

                    Ipv4Address source);

  /**

   * \brief Schedule the intermediate route request

   * \param the original packet

   * \param source The source address

   * \param destination The destination address

   */

  void ScheduleInterRequest (Ptr<Packet> packet);

  /**

   * \brief Send the gratuitous reply

   * \param replyTo The destination address to send the reply to

   * \param replyFrom The source address sending the reply

   */

  void SendGratuitousReply (Ipv4Address replyTo,

                            Ipv4Address replyFrom,

                            std::vector<Ipv4Address> &nodeList,

                            uint8_t protocol);

  /**

   * Send the route reply back to the request originator with the cumulated route

   */

  void SendReply (Ptr<Packet> packet,

                  Ipv4Address source,

                  Ipv4Address nextHop,

                  Ptr<Ipv4Route> route);

  /**

   * this is a generating the initial route reply from the destination address, a random delay time

   * [0, m_broadcastJitter] is used before unicasting back the route reply packet

   */

  void ScheduleInitialReply (Ptr<Packet> packet,

                             Ipv4Address source,

                             Ipv4Address nextHop,

                             Ptr<Ipv4Route> route);

  /**

   * Schedule the cached reply to a random start time to avoid possible route reply storm

   */

  void ScheduleCachedReply (Ptr<Packet> packet,

                            Ipv4Address source,

                            Ipv4Address destination,

                            Ptr<Ipv4Route> route,

                            double hops);

  /**

   * Send network layer acknowledgment back to the earlier hop to notify the receipt of data packet

   */

  void SendAck   (uint16_t ackId,

                  Ipv4Address destination,

                  Ipv4Address realSrc,

                  Ipv4Address realDst,

                  uint8_t protocol,

                  Ptr<Ipv4Route> route);

  /**

   * \param p packet to forward up

   * \param header IPv4 Header information

   * \param incomingInterface the Ipv4Interface on which the packet arrived

   *

   * Called from lower-level layers to send the packet up

   * in the stack.

   */

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

                                               Ipv4Header const &header,

                                               Ptr<Ipv4Interface> incomingInterface);

  /**

   * \param p packet to forward up

   * \param header IPv6 Header information

   * \param incomingInterface the Ipv6Interface on which the packet arrived

   *

   * Called from lower-level layers to send the packet up

   * in the stack.  Not implemented (IPv6).

   */

  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;

  /**

   * \brief Process method

   * Called from Ipv4L3Protocol::Receive.

   *

   * \param packet the packet

   * \param offset the offset of the extension to process

   * \param dst destination address of the packet received (i.e. us)

   * \param nextHeader the next header

   * \param isDropped if the packet must be dropped

   * \return the size processed

   */

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

  /**

   * \brief Insert a new Dsr Option.

   * \param option the option to insert

   */

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

  /**

   * \brief Get the option corresponding to optionNumber.

   * \param optionNumber the option number of the option to retrieve

   * \return a matching Dsr option

   */

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

  /**

   * \brief Cancel the route request timer.

   * \param dst The dst address of the route request timer

   * \param isRemove whether to remove the route request entry or not

   */

  void CancelRreqTimer (Ipv4Address dst, bool isRemove);

  /**

   * \brief Schedule the route request retry.

   * \param dst The dst address of the route request

   */

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

  // / Handle route discovery timer

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

 /**

  * Assign a fixed random variable stream number to the random variables

  * used by this model.  Return the number of streams (possibly zero) that

  * have been assigned.