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

 */

#define NS_LOG_APPEND_CONTEXT                                   \

  if (GetObject<Node> ()) { std::clog << "[node " << GetObject<Node> ()->GetId () << "] "; }

#include <list>

#include <ctime>

#include <map>

#include "ns3/ptr.h"

#include "ns3/log.h"

#include "ns3/assert.h"

#include "ns3/fatal-error.h"

#include "ns3/node.h"

#include "ns3/uinteger.h"

#include "ns3/trace-source-accessor.h"

#include "ns3/udp-header.h"

#include "ns3/pointer.h"

#include "ns3/node-list.h"

#include "ns3/uinteger.h"

#include "ns3/object-vector.h"

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

#include "ns3/ipv4-interface.h"

#include "ns3/ipv4-header.h"

#include "ns3/ipv4-address.h"

#include "ns3/ipv4-route.h"

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

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

#include "dsr-option-header.h"

#include "dsr-options.h"

#include "dsr-rcache.h"

NS_LOG_COMPONENT_DEFINE ("DsrOptions");

namespace ns3 {

namespace dsr {

NS_OBJECT_ENSURE_REGISTERED (DsrOptions);

TypeId DsrOptions::GetTypeId ()

{

  static TypeId tid = TypeId ("ns3::dsr::DsrOptions")

    .SetParent<Object> ()

    .AddAttribute ("OptionNumber", "The Dsr option number.",

                   UintegerValue (0),

                   MakeUintegerAccessor (&DsrOptions::GetOptionNumber),

                   MakeUintegerChecker<uint8_t> ())

    .AddTraceSource ("Rx", "Receive DSR packet.",

                     MakeTraceSourceAccessor (&DsrOptions::m_rxPacketTrace))

  ;

  return tid;

}

DsrOptions::DsrOptions ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

DsrOptions::~DsrOptions ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

void DsrOptions::SetNode (Ptr<Node> node)

{

  NS_LOG_FUNCTION (this << node);

  m_node = node;

}

Ptr<Node> DsrOptions::GetNode () const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_node;

}

bool DsrOptions::ContainAddressAfter (Ipv4Address ipv4Address, Ipv4Address destAddress, std::vector<Ipv4Address> &nodeList)

{

  NS_LOG_FUNCTION (this << ipv4Address << destAddress);

  std::vector<Ipv4Address>::iterator it = find (nodeList.begin (), nodeList.end (), destAddress);

  for (std::vector<Ipv4Address>::iterator i = it; i != nodeList.end (); ++i)

    {

      if ((ipv4Address == (*i)) && ((*i) != nodeList.back ()))

        {

          return true;

        }

    }

  return false;

}

std::vector<Ipv4Address>

DsrOptions::CutRoute (Ipv4Address ipv4Address, std::vector<Ipv4Address> &nodeList)

{

  NS_LOG_FUNCTION (this << ipv4Address);

  std::vector<Ipv4Address>::iterator it = find (nodeList.begin (), nodeList.end (), ipv4Address);

  std::vector<Ipv4Address> cutRoute;

  for (std::vector<Ipv4Address>::iterator i = it; i != nodeList.end (); ++i)

    {

      cutRoute.push_back (*i);

    }

  return cutRoute;

}

Ptr<Ipv4Route> DsrOptions::SetRoute (Ipv4Address nextHop, Ipv4Address srcAddress)

{

  NS_LOG_FUNCTION (this << nextHop << srcAddress);

  m_ipv4Route = Create<Ipv4Route> ();

  m_ipv4Route->SetDestination (nextHop);

  m_ipv4Route->SetGateway (nextHop);

  m_ipv4Route->SetSource (srcAddress);

  return m_ipv4Route;

}

bool DsrOptions::ReverseRoutes (std::vector<Ipv4Address> & vec)

{

  NS_LOG_FUNCTION (this);

  std::vector<Ipv4Address> vec2 (vec);

  vec.clear ();    // To ensure vec is empty before start

  for (std::vector<Ipv4Address>::reverse_iterator ri = vec2.rbegin (); ri

       != vec2.rend (); ++ri)

    {

      vec.push_back (*ri);

    }

  if ((vec.size () == vec2.size ()) && (vec.front () == vec2.back ()))

    {

      return true;

    }

  return false;

}

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

{

  NS_LOG_FUNCTION (this << ipv4Address);

  Ipv4Address nextHop;

  NS_LOG_DEBUG ("the vector size " << vec.size ());

  if (vec.size () == 2)

    {

      NS_LOG_DEBUG ("The two nodes are neighbors");

      nextHop = vec[1];

      return nextHop;

    }

  else

    {

      if (ipv4Address == vec.back ())

        {

          NS_LOG_DEBUG ("We have reached to the final destination " << ipv4Address << " " << vec.back ());

          return ipv4Address;

        }

      for (std::vector<Ipv4Address>::const_iterator i = vec.begin (); i != vec.end (); ++i)

        {

          if (ipv4Address == (*i))

            {

              nextHop = *(++i);

              return nextHop;

            }

        }

    }

  NS_LOG_DEBUG ("next hop address not found, route corrupted");

  Ipv4Address none = "0.0.0.0";

  return none;

}

Ipv4Address DsrOptions::ReverseSearchNextHop (Ipv4Address ipv4Address, std::vector<Ipv4Address>& vec)

{

  NS_LOG_FUNCTION (this << ipv4Address);

  Ipv4Address nextHop;

  if (vec.size () == 2)

    {

      NS_LOG_DEBUG ("The two nodes are neighbors");

      nextHop = vec[0];

      return nextHop;

    }

  else

    {

      for (std::vector<Ipv4Address>::reverse_iterator ri = vec.rbegin (); ri != vec.rend (); ++ri)

        {

          if (ipv4Address == (*ri))

            {

              nextHop = *(++ri);

              return nextHop;

            }

        }

    }

  NS_LOG_DEBUG ("next hop address not found, route corrupted");

  Ipv4Address none = "0.0.0.0";

  return none;

}

Ipv4Address DsrOptions::ReverseSearchNextTwoHop  (Ipv4Address ipv4Address, std::vector<Ipv4Address>& vec)

{

  NS_LOG_FUNCTION (this << ipv4Address);

  Ipv4Address nextTwoHop;

  NS_LOG_DEBUG ("The vector size " << vec.size ());

  NS_ASSERT (vec.size () > 2);

  for (std::vector<Ipv4Address>::reverse_iterator ri = vec.rbegin (); ri != vec.rend (); ++ri)

    {

      if (ipv4Address == (*ri))

        {

          nextTwoHop = *(ri + 2);

          return nextTwoHop;

        }

    }

  NS_FATAL_ERROR ("next hop address not found, route corrupted");

  Ipv4Address none = "0.0.0.0";

  return none;

}

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

{

  NS_LOG_FUNCTION (this);

  /*

   * Check elements in a route vector

   */

  if (!vec.size ())

    {

      NS_LOG_DEBUG ("The vector is empty");

    }

  else

    {

      NS_LOG_DEBUG ("Print all the elements in a vector");

      for (std::vector<Ipv4Address>::const_iterator i = vec.begin (); i != vec.end (); ++i)

        {

          NS_LOG_DEBUG ("The ip address " << *i);

        }

    }

}

bool DsrOptions::IfDuplicates (std::vector<Ipv4Address>& vec, std::vector<Ipv4Address>& vec2)

{

  NS_LOG_FUNCTION (this);

  for (std::vector<Ipv4Address>::const_iterator i = vec.begin (); i != vec.end (); ++i)

    {

      for (std::vector<Ipv4Address>::const_iterator j = vec2.begin (); j != vec2.end (); ++j)

        {

          if ((*i) == (*j))

            {

              return true;

            }

          else

            {

              continue;

            }

        }

    }

  return false;

}

bool DsrOptions::CheckDuplicates (Ipv4Address ipv4Address, std::vector<Ipv4Address>& vec)

{

  NS_LOG_FUNCTION (this << ipv4Address);

  for (std::vector<Ipv4Address>::const_iterator i = vec.begin (); i != vec.end (); ++i)

    {

      if ((*i) == ipv4Address)

        {

          return true;

        }

      else

        {

          continue;

        }

    }

  return false;

}

void DsrOptions::RemoveDuplicates (std::vector<Ipv4Address>& vec)

{

  NS_LOG_FUNCTION (this);

  //Remove duplicate ip address from the route if any, should not happen with normal behavior nodes

  std::vector<Ipv4Address> vec2 (vec); // declare vec2 as a copy of the vec

  PrintVector (vec2); // Print all the ip address in the route

  vec.clear (); // clear vec

  for (std::vector<Ipv4Address>::const_iterator i = vec2.begin (); i != vec2.end (); ++i)

    {

      if (vec.empty ())

        {

          vec.push_back (*i);

          continue;

        }

      else

        {

          for (std::vector<Ipv4Address>::iterator j = vec.begin (); j != vec.end (); ++j)

            {

              if ((*i) == (*j))

                {

                  if ((j + 1) != vec.end ())

                    {

                      vec.erase (j + 1, vec.end ());   // Automatic shorten the route

                      break;

                    }

                  else

                    {

                      break;

                    }

                }

              else if (j == (vec.end () - 1))

                {

                  vec.push_back (*i);

                  break;

                }

              else

                {

                  continue;

                }

            }

        }

    }

}

uint32_t

DsrOptions::GetIDfromIP (Ipv4Address address)

{

  NS_LOG_FUNCTION (this << address);

  int32_t nNodes = NodeList::GetNNodes ();

  for (int32_t i = 0; i < nNodes; ++i)

    {

      Ptr<Node> node = NodeList::GetNode (i);

      Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();

      if (ipv4->GetAddress (1, 0).GetLocal () == address)

        {

          return i;

        }

    }

  return 255;

}

Ptr<Node> DsrOptions::GetNodeWithAddress (Ipv4Address ipv4Address)

{

  NS_LOG_FUNCTION (this << ipv4Address);

  int32_t nNodes = NodeList::GetNNodes ();

  for (int32_t i = 0; i < nNodes; ++i)

    {

      Ptr<Node> node = NodeList::GetNode (i);

      Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();

      int32_t ifIndex = ipv4->GetInterfaceForAddress (ipv4Address);

      if (ifIndex != -1)

        {

          return node;

        }

    }

  return 0;

}

NS_OBJECT_ENSURE_REGISTERED (DsrOptionPad1);

TypeId DsrOptionPad1::GetTypeId ()

{

  static TypeId tid = TypeId ("ns3::dsr::DsrOptionPad1")

    .SetParent<DsrOptions> ()

    .AddConstructor<DsrOptionPad1> ()

  ;

  return tid;

}

DsrOptionPad1::DsrOptionPad1 ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

DsrOptionPad1::~DsrOptionPad1 ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

uint8_t DsrOptionPad1::GetOptionNumber () const

{

  NS_LOG_FUNCTION_NOARGS ();

  return OPT_NUMBER;

}

uint8_t DsrOptionPad1::Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource)

{

  NS_LOG_FUNCTION (this << packet << dsrP << ipv4Address << source << ipv4Header << (uint32_t)protocol << isPromisc);

  Ptr<Packet> p = packet->Copy ();

  DsrOptionPad1Header pad1Header;

  p->RemoveHeader (pad1Header);

  isPromisc = false;

  return pad1Header.GetSerializedSize ();

}

NS_OBJECT_ENSURE_REGISTERED (DsrOptionPadn);

TypeId DsrOptionPadn::GetTypeId ()

{

  static TypeId tid = TypeId ("ns3::dsr::DsrOptionPadn")

    .SetParent<DsrOptions> ()

    .AddConstructor<DsrOptionPadn> ()

  ;

  return tid;

}

DsrOptionPadn::DsrOptionPadn ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

DsrOptionPadn::~DsrOptionPadn ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

uint8_t DsrOptionPadn::GetOptionNumber () const

{

  NS_LOG_FUNCTION_NOARGS ();

  return OPT_NUMBER;

}

uint8_t DsrOptionPadn::Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource)

{

  NS_LOG_FUNCTION (this << packet << dsrP << ipv4Address << source << ipv4Header << (uint32_t)protocol << isPromisc);

  Ptr<Packet> p = packet->Copy ();

  DsrOptionPadnHeader padnHeader;

  p->RemoveHeader (padnHeader);

  isPromisc = false;

  return padnHeader.GetSerializedSize ();

}

NS_OBJECT_ENSURE_REGISTERED (DsrOptionRreq);

TypeId DsrOptionRreq::GetTypeId ()

{

  static TypeId tid = TypeId ("ns3::dsr::DsrOptionRreq")

    .SetParent<DsrOptions> ()

    .AddConstructor<DsrOptionRreq> ()

  ;

  return tid;

}

TypeId DsrOptionRreq::GetInstanceTypeId () const

{

  return GetTypeId ();

}

DsrOptionRreq::DsrOptionRreq ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

DsrOptionRreq::~DsrOptionRreq ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

uint8_t DsrOptionRreq::GetOptionNumber () const

{

  NS_LOG_FUNCTION_NOARGS ();

  return OPT_NUMBER;

}

uint8_t DsrOptionRreq::Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource)

{

  NS_LOG_FUNCTION (this << packet << dsrP << ipv4Address << source << ipv4Header << (uint32_t)protocol << isPromisc);

  // Fields from IP header

  Ipv4Address srcAddress = ipv4Header.GetSource ();

  /*

   * \ when the ip source address is equal to the address of our own, this is request packet originated

   * \ by the node itself, discard it

   */

  if (srcAddress == ipv4Address)

    {

      NS_LOG_DEBUG ("Discard the packet");

      m_dropTrace (packet); // call the drop trace to show in the tracing

      return 0;

    }

  /*

   * Get the node associated with the ipv4 address and get several objects from the node and leave for further use

   */

  Ptr<Node> node = GetNodeWithAddress (ipv4Address);

  Ptr<dsr::DsrRouting> dsr = node->GetObject<dsr::DsrRouting> ();

  Ptr<Packet> p = packet->Copy (); // Note: The packet here doesn't contain the fixed size dsr header

  /*

   * \brief Get the number of routers' address field before removing the header

   * \peek the packet and get the value

   */

  uint8_t buf[2];

  p->CopyData (buf, sizeof(buf));

  uint8_t numberAddress = (buf[1] - 6) / 4;

  NS_LOG_DEBUG ("The number of Ip addresses " << (uint32_t)numberAddress);

  if (numberAddress >= 255)

    {

      NS_LOG_DEBUG ("Discard the packet, malformed header since two many ip addresses in route");

      m_dropTrace (packet); // call the drop trace to show in the tracing

      return 0;

    }