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

/*

 * Copyright (c) 2007-2009 Strasbourg University

 *

 * 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: Sebastien Vincent <vincent@clarinet.u-strasbg.fr>

 *         David Gross <gdavid.devel@gmail.com>

 *         Mehdi Benamor <benamor.mehdi@ensi.rnu.tn>

 */

#include "ns3/log.h"

#include "ns3/assert.h"

#include "ns3/packet.h"

#include "ns3/node.h"

#include "ns3/boolean.h"

#include "ns3/ipv6-routing-protocol.h"

#include "ns3/ipv6-route.h"

#include "ipv6-raw-socket-factory-impl.h"

#include "ipv6-l3-protocol.h"

#include "ipv6-interface.h"

#include "icmpv6-l4-protocol.h"

#include "ndisc-cache.h"

namespace ns3

{

NS_OBJECT_ENSURE_REGISTERED (Icmpv6L4Protocol);

NS_LOG_COMPONENT_DEFINE ("Icmpv6L4Protocol");

const uint8_t Icmpv6L4Protocol::PROT_NUMBER = 58;

const uint8_t Icmpv6L4Protocol::MAX_INITIAL_RTR_ADVERT_INTERVAL = 16;

const uint8_t Icmpv6L4Protocol::MAX_INITIAL_RTR_ADVERTISEMENTS = 3;

const uint8_t Icmpv6L4Protocol::MAX_FINAL_RTR_ADVERTISEMENTS = 3;

const uint8_t Icmpv6L4Protocol::MIN_DELAY_BETWEEN_RAS = 3;

const uint32_t Icmpv6L4Protocol::MAX_RA_DELAY_TIME = 500; /* millisecond */

const uint8_t Icmpv6L4Protocol::MAX_RTR_SOLICITATION_DELAY = 1;

const uint8_t Icmpv6L4Protocol::RTR_SOLICITATION_INTERVAL = 4;

const uint8_t Icmpv6L4Protocol::MAX_RTR_SOLICITATIONS = 3;

const uint8_t Icmpv6L4Protocol::MAX_MULTICAST_SOLICIT = 3;

const uint8_t Icmpv6L4Protocol::MAX_UNICAST_SOLICIT = 3;

const uint8_t Icmpv6L4Protocol::MAX_ANYCAST_DELAY_TIME = 1;

const uint8_t Icmpv6L4Protocol::MAX_NEIGHBOR_ADVERTISEMENT = 3;

const uint32_t Icmpv6L4Protocol::REACHABLE_TIME = 30000;

const uint32_t Icmpv6L4Protocol::RETRANS_TIMER = 1000;

const uint8_t Icmpv6L4Protocol::DELAY_FIRST_PROBE_TIME = 5;

const double Icmpv6L4Protocol::MIN_RANDOM_FACTOR = 0.5;

const double Icmpv6L4Protocol::MAX_RANDOM_FACTOR = 1.5;

TypeId Icmpv6L4Protocol::GetTypeId ()

{

  static TypeId tid = TypeId ("ns3::Icmpv6L4Protocol")

    .SetParent<Ipv6L4Protocol> ()

    .AddConstructor<Icmpv6L4Protocol> ()

    .AddAttribute ("DAD", "Always do DAD check.",

                   BooleanValue (true),

                   MakeBooleanAccessor (&Icmpv6L4Protocol::m_alwaysDad),

                   MakeBooleanChecker ())

  ;

  return tid;

}

Icmpv6L4Protocol::Icmpv6L4Protocol ()

  : m_node (0)

{

  NS_LOG_FUNCTION_NOARGS ();

}

Icmpv6L4Protocol::~Icmpv6L4Protocol ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

void Icmpv6L4Protocol::DoDispose ()

{

  NS_LOG_FUNCTION_NOARGS ();

  for (CacheList::const_iterator it = m_cacheList.begin (); it != m_cacheList.end (); it++)

    {

      Ptr<NdiscCache> cache = *it;

      cache->Dispose ();

      cache = 0;

    }

  m_cacheList.clear ();

  m_node = 0;

  Ipv6L4Protocol::DoDispose ();

}

void Icmpv6L4Protocol::NotifyNewAggregate ()

{

  NS_LOG_FUNCTION_NOARGS ();

  if (m_node == 0)

    {

      Ptr<Node> node = this->GetObject<Node> ();

      if (node != 0)

        {

          Ptr<Ipv6L3Protocol> ipv6 = this->GetObject<Ipv6L3Protocol> ();

          if (ipv6 != 0)

            {

              this->SetNode (node);

              ipv6->Insert (this);

              Ptr<Ipv6RawSocketFactoryImpl> rawFactory = CreateObject<Ipv6RawSocketFactoryImpl> ();

              ipv6->AggregateObject (rawFactory);

            }

        }

    }

  Object::NotifyNewAggregate ();

}

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

{

  NS_LOG_FUNCTION (this << node);

  m_node = node;

}

uint16_t Icmpv6L4Protocol::GetStaticProtocolNumber ()

{

  NS_LOG_FUNCTION_NOARGS ();

  return PROT_NUMBER;

}

int Icmpv6L4Protocol::GetProtocolNumber () const

{

  NS_LOG_FUNCTION_NOARGS ();

  return PROT_NUMBER;

}

int Icmpv6L4Protocol::GetVersion () const

{

  NS_LOG_FUNCTION_NOARGS ();

  return 1;

}

bool Icmpv6L4Protocol::IsAlwaysDad () const

{

  return m_alwaysDad;

}

void Icmpv6L4Protocol::DoDAD (Ipv6Address target, Ptr<Ipv6Interface> interface)

{

  NS_LOG_FUNCTION (this << target << interface);

  Ipv6Address addr;

  Ptr<Ipv6L3Protocol> ipv6 = m_node->GetObject<Ipv6L3Protocol> ();

  NS_ASSERT (ipv6);

  if(!m_alwaysDad)

    {

      return; 

    }

  /* TODO : disable multicast loopback to prevent NS probing to be received by the sender */

  Ptr<Packet> p = ForgeNS ("::",Ipv6Address::MakeSolicitedAddress (target), target, interface->GetDevice ()->GetAddress ());

  /* update last packet UID */

  interface->SetNsDadUid (target, p->GetUid ());

  interface->Send (p, Ipv6Address::MakeSolicitedAddress (target));

}

enum Ipv6L4Protocol::RxStatus_e Icmpv6L4Protocol::Receive (Ptr<Packet> packet, Ipv6Address const &src, Ipv6Address const &dst, Ptr<Ipv6Interface> interface)

{

  NS_LOG_FUNCTION (this << packet << src << dst << interface);

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

  Ptr<Ipv6> ipv6 = m_node->GetObject<Ipv6> ();

  /* very ugly! try to find something better in the future */

  uint8_t type;

  p->CopyData (&type, sizeof(type));

  switch (type) 

    {

    case Icmpv6Header::ICMPV6_ND_ROUTER_SOLICITATION:

      if (ipv6->IsForwarding (ipv6->GetInterfaceForDevice (interface->GetDevice ())))

        {

          HandleRS (p, src, dst, interface);

        }

      break;

    case Icmpv6Header::ICMPV6_ND_ROUTER_ADVERTISEMENT:

      if (!ipv6->IsForwarding (ipv6->GetInterfaceForDevice (interface->GetDevice ())))

        {

          HandleRA (p, src, dst, interface);

        }

      break;

    case Icmpv6Header::ICMPV6_ND_NEIGHBOR_SOLICITATION:

      HandleNS (p, src, dst, interface);

      break;

    case Icmpv6Header::ICMPV6_ND_NEIGHBOR_ADVERTISEMENT:

      HandleNA (p, src, dst, interface);

      break;

    case Icmpv6Header::ICMPV6_ND_REDIRECTION:

      HandleRedirection (p, src, dst, interface);

      break;

    case Icmpv6Header::ICMPV6_ECHO_REQUEST:

      HandleEchoRequest (p, src, dst, interface);

      break;

    case Icmpv6Header::ICMPV6_ECHO_REPLY:

      break;

    case Icmpv6Header::ICMPV6_ERROR_DESTINATION_UNREACHABLE:

      break;

    case Icmpv6Header::ICMPV6_ERROR_PACKET_TOO_BIG:

      break;

    case Icmpv6Header::ICMPV6_ERROR_TIME_EXCEEDED:

      break;

    case Icmpv6Header::ICMPV6_ERROR_PARAMETER_ERROR:

      break;

    default:

      NS_LOG_LOGIC ("Unknown ICMPv6 message type=" << type);

      break;

    }

  return Ipv6L4Protocol::RX_OK;

}

void Icmpv6L4Protocol::HandleEchoRequest (Ptr<Packet> packet, Ipv6Address const &src, Ipv6Address const &dst, Ptr<Ipv6Interface> interface)

{

  NS_LOG_FUNCTION (this << packet << src << dst << interface);

  Icmpv6Echo request;

  uint8_t* buf = new uint8_t[packet->GetSize ()];

  packet->RemoveHeader (request);

  /* XXX IPv6 extension: obtain a fresh copy of data otherwise it crash... */

  packet->CopyData (buf, packet->GetSize ());

  Ptr<Packet> p = Create<Packet> (buf, packet->GetSize ());

  /* if we send message from ff02::* (link-local multicast), we use our link-local address */

  SendEchoReply (dst.IsMulticast () ? interface->GetLinkLocalAddress ().GetAddress () : dst, src, request.GetId (), request.GetSeq (), p);

  delete[] buf;

}

void Icmpv6L4Protocol::HandleRA (Ptr<Packet> packet, Ipv6Address const &src, Ipv6Address const &dst, Ptr<Ipv6Interface> interface)

{ 

  NS_LOG_FUNCTION (this << packet << src << dst << interface);

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

  Icmpv6RA raHeader;

  Ptr<Ipv6L3Protocol> ipv6 = m_node->GetObject<Ipv6L3Protocol> ();

  Icmpv6OptionPrefixInformation prefixHdr;

  Icmpv6OptionMtu mtuHdr;

  Icmpv6OptionLinkLayerAddress llaHdr;

  bool next = true;

  bool hasLla = false;

  bool hasMtu = false;

  p->RemoveHeader (raHeader);

  while (next == true)

    {

      uint8_t type = 0;

      p->CopyData (&type, sizeof(type));

      switch (type)

        {

        case Icmpv6Header::ICMPV6_OPT_PREFIX:

          p->RemoveHeader (prefixHdr);

          ipv6->AddAutoconfiguredAddress (ipv6->GetInterfaceForDevice (interface->GetDevice ()), prefixHdr.GetPrefix (), prefixHdr.GetPrefixLength (), 

                                          prefixHdr.GetFlags (), prefixHdr.GetValidTime (), prefixHdr.GetPreferredTime (), src);

          break;

        case Icmpv6Header::ICMPV6_OPT_MTU:

          /* take in account the first MTU option */

          if (!hasMtu)

            {

              p->RemoveHeader (mtuHdr);

              hasMtu = true;

              /* XXX case of multiple prefix on single interface */

              /* interface->GetDevice ()->SetMtu (m.GetMtu ()); */

            }

          break;

        case Icmpv6Header::ICMPV6_OPT_LINK_LAYER_SOURCE:

          /* take in account the first LLA option */

          if (!hasLla)

            {

              p->RemoveHeader (llaHdr);

              ReceiveLLA (llaHdr, src, dst, interface);

              hasLla = true;

            }

          break;

        default:

          /* unknow option, quit */

          next = false;

        }

    }

}

void Icmpv6L4Protocol::ReceiveLLA (Icmpv6OptionLinkLayerAddress lla, Ipv6Address const &src, Ipv6Address const &dst, Ptr<Ipv6Interface> interface)

{

  NS_LOG_FUNCTION (this << lla << src << dst << interface);

  Address hardwareAddress;

  NdiscCache::Entry* entry = 0;

  Ptr<NdiscCache> cache = FindCache (interface->GetDevice ());

  /* check if we have this address in our cache */ 

  entry = cache->Lookup (src);

  if (!entry)

    {

      entry = cache->Add (src);

      entry->SetRouter (true);

      entry->SetMacAddress (lla.GetAddress ());

      entry->MarkReachable ();

      entry->StartReachableTimer ();

    }

  else

    {

      std::list<Ptr<Packet> > waiting;

      if (entry->IsIncomplete ())

        {

          entry->StopRetransmitTimer ();

          // mark it to reachable 

          waiting = entry->MarkReachable (lla.GetAddress ());

          entry->StopReachableTimer ();

          entry->StartReachableTimer ();

          // send out waiting packet 

          for (std::list<Ptr<Packet> >::const_iterator it = waiting.begin (); it != waiting.end (); it++)

            {

              cache->GetInterface ()->Send (*it, src);

            }

          entry->ClearWaitingPacket ();

        }

      else

        {

          if (entry->GetMacAddress ()!=lla.GetAddress ())

            {

              entry->SetMacAddress (lla.GetAddress ());

              entry->MarkStale ();

              entry->SetRouter (true);

            }

          else

            {

              if (!entry->IsReachable ())

                {

                  entry->StopProbeTimer ();

                  entry->StopDelayTimer ();

                  waiting = entry->MarkReachable (lla.GetAddress ());

                  if (entry->IsProbe ())

                    {

                      for (std::list<Ptr<Packet> >::const_iterator it = waiting.begin (); it != waiting.end (); it++)

                        {

                          cache->GetInterface ()->Send (*it, src);

                        }

                    }

                  entry->StopReachableTimer ();

                  entry->StartReachableTimer ();

                }

            }

        }

    }

}

void Icmpv6L4Protocol::HandleRS (Ptr<Packet> packet, Ipv6Address const &src, Ipv6Address const &dst, Ptr<Ipv6Interface> interface)

{

  NS_LOG_FUNCTION (this << packet << src << dst << interface);

  Ptr<Ipv6L3Protocol> ipv6 = m_node->GetObject<Ipv6L3Protocol> ();

  Icmpv6RS rsHeader;

  packet->RemoveHeader (rsHeader);

  Address hardwareAddress;

  Icmpv6OptionLinkLayerAddress lla (1);

  NdiscCache::Entry* entry = 0;

  Ptr<NdiscCache> cache = FindCache (interface->GetDevice ());

  if (src != Ipv6Address::GetAny ())

    {

      /* XXX search all options following the RS header */

      /* test if the next option is SourceLinkLayerAddress */

      uint8_t type;

      packet->CopyData (&type, sizeof(type));

      if (type != Icmpv6Header::ICMPV6_OPT_LINK_LAYER_SOURCE)

        {

          return;

        }

      packet->RemoveHeader (lla);

      NS_LOG_LOGIC ("Cache updated by RS");

      entry = cache->Lookup (src);

      if (!entry)

        {

          entry = cache->Add (src);

          entry->SetRouter (false);

          entry->MarkStale (lla.GetAddress ());

        }

      else if (entry->GetMacAddress () != lla.GetAddress ())

        {

          entry->MarkStale (lla.GetAddress ());

        }

    }

}

void Icmpv6L4Protocol::HandleNS (Ptr<Packet> packet, Ipv6Address const &src, Ipv6Address const &dst, Ptr<Ipv6Interface> interface)

{

  NS_LOG_FUNCTION (this << packet << src << dst << interface);

  Icmpv6NS nsHeader ("::");

  Ipv6InterfaceAddress ifaddr;

  uint32_t nb = interface->GetNAddresses ();

  uint32_t i = 0;

  bool found = false;

  packet->RemoveHeader (nsHeader);

  Ipv6Address target = nsHeader.GetIpv6Target ();

  for (i = 0; i < nb; i++)

    {

      ifaddr = interface->GetAddress (i);

      if (ifaddr.GetAddress () == target)

        {

          found = true;

          break;

        }

    }

  if (!found)

    {

      NS_LOG_LOGIC ("Not a NS for us");

      return;

    }

  if (packet->GetUid () == ifaddr.GetNsDadUid ())

    {

      /* don't process our own DAD probe */

      NS_LOG_LOGIC ("Hey we receive our DAD probe!");

      return;

    }

  Icmpv6OptionLinkLayerAddress lla (1);

  Address hardwareAddress;

  NdiscCache::Entry* entry = 0;

  Ptr<NdiscCache> cache = FindCache (interface->GetDevice ());

  uint8_t flags = 0;

  /* XXX search all options following the NS header */

  if (src != Ipv6Address::GetAny ())

    {

      uint8_t type;

      packet->CopyData (&type, sizeof(type));

      if (type != Icmpv6Header::ICMPV6_OPT_LINK_LAYER_SOURCE)

        {

          return;

        }

      /* Get LLA */

      packet->RemoveHeader (lla);

      entry = cache->Lookup (src);

      if (!entry)

        {

          entry = cache->Add (src);

          entry->SetRouter (false);

          entry->MarkStale (lla.GetAddress ());

        }

      else if (entry->GetMacAddress () != lla.GetAddress ())

        {

          entry->MarkStale (lla.GetAddress ());

        }

      flags = 3; /* S + O flags */

    }

  else

    {

      /* it means someone do a DAD */

      flags = 1; /* O flag */

    }

  /* send a NA to src */

  Ptr<Ipv6L3Protocol> ipv6 = m_node->GetObject<Ipv6L3Protocol> ();

  if (ipv6->IsForwarding (ipv6->GetInterfaceForDevice (interface->GetDevice ())))

    {

      flags += 4; /* R flag */

    }

  hardwareAddress = interface->GetDevice ()->GetAddress ();

  Ptr<Packet> p = ForgeNA (target.IsLinkLocal () ? interface->GetLinkLocalAddress ().GetAddress () : ifaddr.GetAddress (), src.IsAny () ? Ipv6Address::GetAllNodesMulticast () : src, &hardwareAddress, flags );

  interface->Send (p,  src.IsAny () ? Ipv6Address::GetAllNodesMulticast () : src); 

  /* not a NS for us discard it */

}

Ptr<Packet> Icmpv6L4Protocol::ForgeRS (Ipv6Address src, Ipv6Address dst, Address hardwareAddress)

{

  NS_LOG_FUNCTION (this << src << dst << hardwareAddress);

  Ptr<Packet> p = Create<Packet> ();

  Ipv6Header ipHeader;

  Icmpv6RS rs;

  Icmpv6OptionLinkLayerAddress llOption (1, hardwareAddress);  /* we give our mac address in response */

  NS_LOG_LOGIC ("Send RS ( from " << src << " to " << dst << ")");

  p->AddHeader (llOption);

  rs.CalculatePseudoHeaderChecksum (src, dst, p->GetSize () + rs.GetSerializedSize (), PROT_NUMBER);