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

 */

#include "ns3/log.h"

#include "ns3/node.h"

#include "ns3/uinteger.h"

#include "ns3/vector.h"

#include "ns3/callback.h"

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

#include "ns3/object-vector.h"

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

#include "ns3/ipv6-route.h"

#include "loopback-net-device.h"

#include "ipv6-l3-protocol.h"

#include "ipv6-l4-protocol.h"

#include "ipv6-interface.h"

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

#include "ipv6-autoconfigured-prefix.h"

#include "ipv6-extension-demux.h"

#include "ipv6-extension.h"

#include "ipv6-extension-header.h"

#include "ipv6-option-demux.h"

#include "ipv6-option.h"

#include "icmpv6-l4-protocol.h"

#include "ndisc-cache.h"

namespace ns3

{

NS_OBJECT_ENSURE_REGISTERED (Ipv6L3Protocol);

NS_LOG_COMPONENT_DEFINE ("Ipv6L3Protocol");

const uint16_t Ipv6L3Protocol::PROT_NUMBER = 0x86DD;

TypeId Ipv6L3Protocol::GetTypeId ()

{

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

    .SetParent<Ipv6> ()

    .AddConstructor<Ipv6L3Protocol> ()

    .AddAttribute ("DefaultTtl", "The TTL value set by default on all outgoing packets generated on this node.",

                   UintegerValue (64),

                   MakeUintegerAccessor (&Ipv6L3Protocol::m_defaultTtl),

                   MakeUintegerChecker<uint8_t> ())

    .AddAttribute ("InterfaceList", "The set of IPv6 interfaces associated to this IPv6 stack.",

                   ObjectVectorValue (),

                   MakeObjectVectorAccessor (&Ipv6L3Protocol::m_interfaces),

                   MakeObjectVectorChecker<Ipv6Interface> ())

    .AddTraceSource ("Tx", "Send IPv6 packet to outgoing interface.",

                   MakeTraceSourceAccessor (&Ipv6L3Protocol::m_txTrace))

    .AddTraceSource ("Rx", "Receive IPv6 packet from incoming interface.",

                     MakeTraceSourceAccessor (&Ipv6L3Protocol::m_rxTrace))

    .AddTraceSource ("Drop", "Drop IPv6 packet",

                     MakeTraceSourceAccessor (&Ipv6L3Protocol::m_dropTrace))

    ;

  return tid;

}

Ipv6L3Protocol::Ipv6L3Protocol ()

  : m_nInterfaces (0)

{

  NS_LOG_FUNCTION_NOARGS ();

}

Ipv6L3Protocol::~Ipv6L3Protocol ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

void Ipv6L3Protocol::DoDispose ()

{

  NS_LOG_FUNCTION_NOARGS ();

  /* clear protocol and interface list */

  for (L4List_t::iterator it = m_protocols.begin () ; it != m_protocols.end () ; ++it)

  {

    *it = 0;

  }

  m_protocols.clear ();

  /* remove interfaces */

  for (Ipv6InterfaceList::iterator it = m_interfaces.begin () ; it != m_interfaces.end (); ++it)

  {

    *it = 0;

  }

  m_interfaces.clear ();

  /* remove raw sockets */

  for (SocketList::iterator it = m_sockets.begin () ; it != m_sockets.end () ; ++it)

  {

    *it = 0;

  }

  m_sockets.clear ();

  /* remove list of prefix */

  for (Ipv6AutoconfiguredPrefixListI it = m_prefixes.begin () ; it != m_prefixes.end () ; ++it)

  {

    (*it)->StopValidTimer ();

    (*it)->StopPreferredTimer ();

    (*it) = 0;

  }

  m_prefixes.clear ();

  m_node = 0;

  m_routingProtocol = 0;

  Object::DoDispose ();

}

void Ipv6L3Protocol::SetRoutingProtocol (Ptr<Ipv6RoutingProtocol> routingProtocol)

{

  NS_LOG_FUNCTION (this << routingProtocol);

  m_routingProtocol = routingProtocol;

  m_routingProtocol->SetIpv6 (this);

}

Ptr<Ipv6RoutingProtocol> Ipv6L3Protocol::GetRoutingProtocol () const 

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_routingProtocol;

}

uint32_t Ipv6L3Protocol::AddInterface (Ptr<NetDevice> device)

{

  NS_LOG_FUNCTION (this << device);

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

  Ptr<Ipv6Interface> interface = CreateObject<Ipv6Interface> ();

  node->RegisterProtocolHandler (MakeCallback (&Ipv6L3Protocol::Receive, this), Ipv6L3Protocol::PROT_NUMBER, device);

  interface->SetNode (m_node);

  interface->SetDevice (device);

  interface->SetForwarding (m_ipForward);

  return AddIpv6Interface (interface);

}

uint32_t Ipv6L3Protocol::AddIpv6Interface (Ptr<Ipv6Interface> interface)

{

  NS_LOG_FUNCTION (this << interface);

  uint32_t index = m_nInterfaces;

  m_interfaces.push_back (interface);

  m_nInterfaces++;

  return index;

}

Ptr<Ipv6Interface> Ipv6L3Protocol::GetInterface (uint32_t index) const

{

  NS_LOG_FUNCTION (this << index);

  uint32_t tmp = 0;

  for (Ipv6InterfaceList::const_iterator it = m_interfaces.begin () ; it != m_interfaces.end () ; it++)

  {

    if (index == tmp)

    {

      return *it;

    }

    tmp++;

  }

  return 0;

}

uint32_t Ipv6L3Protocol::GetNInterfaces () const 

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_nInterfaces;

}

int32_t Ipv6L3Protocol::GetInterfaceForAddress (Ipv6Address address) const

{

  NS_LOG_FUNCTION (this << address); 

  int32_t index = 0;

  for (Ipv6InterfaceList::const_iterator it = m_interfaces.begin () ; it != m_interfaces.end () ; it++)

  {

    uint32_t j = 0;

    uint32_t max = (*it)->GetNAddresses ();

    for (j = 0 ; j < max ; j++)

    {

      if ((*it)->GetAddress (j).GetAddress () == address) 

      {

        return index;

      }

    }

    index++;

  }

  return -1;

}

int32_t Ipv6L3Protocol::GetInterfaceForPrefix (Ipv6Address address, Ipv6Prefix mask) const

{

  NS_LOG_FUNCTION (this << address << mask);

  int32_t index = 0;

  for (Ipv6InterfaceList::const_iterator it = m_interfaces.begin () ; it != m_interfaces.end () ; it++)

  {

    uint32_t j = 0;

    for (j = 0 ; j < (*it)->GetNAddresses () ; j++)

    {

      if ((*it)->GetAddress (j).GetAddress ().CombinePrefix (mask) == address.CombinePrefix (mask))

      {

        return index;

      }

    }

    index++;

  }

  return -1;

}

Ptr<NetDevice> Ipv6L3Protocol::GetNetDevice (uint32_t i)

{

  NS_LOG_FUNCTION (this << i);

  return GetInterface (i)->GetDevice ();

}

int32_t Ipv6L3Protocol::GetInterfaceForDevice (Ptr<const NetDevice> device) const

{

  NS_LOG_FUNCTION (this << device);

  int32_t index = 0;

  for (Ipv6InterfaceList::const_iterator it = m_interfaces.begin () ; it != m_interfaces.end () ; it++)

  {

    if ((*it)->GetDevice () == device)

    {

      return index;

    }

    index++;

  }

  return -1;

}

void Ipv6L3Protocol::AddAutoconfiguredAddress (uint32_t interface, Ipv6Address network, Ipv6Prefix mask, uint8_t flags, uint32_t validTime, uint32_t preferredTime, Ipv6Address defaultRouter)

{

  NS_LOG_FUNCTION (this << interface << network << mask << (uint32_t)flags << validTime << preferredTime);

  Ipv6InterfaceAddress address;

  Address addr = GetInterface (interface)->GetDevice ()->GetAddress ();

  if (flags & (1<< 6)) /* auto flag */

  {

    /* XXX : add other L2 address case */

    if (Mac48Address::IsMatchingType (addr))

    {

      address = Ipv6InterfaceAddress (Ipv6Address::MakeAutoconfiguredAddress (Mac48Address::ConvertFrom (addr), network));

    }

    else

    {

      NS_FATAL_ERROR ("Unknown method to make autoconfigured address for this kind of device.");

      return;

    }

    /* see if we have already the prefix */

    for (Ipv6AutoconfiguredPrefixListI it = m_prefixes.begin () ; it != m_prefixes.end () ; ++it)

    {

      if ((*it)->GetInterface () == interface && (*it)->GetPrefix () == network && (*it)->GetMask () == mask)

      {

        (*it)->StopPreferredTimer ();

        (*it)->StopValidTimer ();

        (*it)->StartPreferredTimer ();

        return;

      }

    }

    /* no prefix found, add autoconfigured address and the prefix */

    NS_LOG_INFO ("Autoconfigured address is :" << address.GetAddress ());

    AddAddress (interface, address);

    /* add default router

     * if a previous default route exists, the new ones is simply added 

     */

    GetRoutingProtocol ()->NotifyAddRoute (Ipv6Address::GetAny (), Ipv6Prefix ((uint8_t)0), defaultRouter, interface, network);

    Ptr<Ipv6AutoconfiguredPrefix> aPrefix = CreateObject<Ipv6AutoconfiguredPrefix> (m_node, interface, network, mask, preferredTime, validTime, defaultRouter);

    aPrefix->StartPreferredTimer ();

    m_prefixes.push_back (aPrefix);

  }

}

void Ipv6L3Protocol::RemoveAutoconfiguredAddress (uint32_t interface, Ipv6Address network, Ipv6Prefix mask, Ipv6Address defaultRouter)

{

  NS_LOG_FUNCTION (this << interface << network << mask);

  Ptr<Ipv6Interface> iface = GetInterface (interface);

  Address addr = iface->GetDevice ()->GetAddress ();

  uint32_t max = iface->GetNAddresses ();

  uint32_t i = 0;

  Ipv6Address toFound = Ipv6Address::MakeAutoconfiguredAddress (Mac48Address::ConvertFrom (addr), network);

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

  {

    if (iface->GetAddress (i).GetAddress () == toFound) 

    {

      RemoveAddress (interface, i);

      break;

    }

  }

  /* remove from list of autoconfigured address */

  for (Ipv6AutoconfiguredPrefixListI it = m_prefixes.begin () ; it != m_prefixes.end () ; ++it)

  {

    if ((*it)->GetInterface () == interface && (*it)->GetPrefix () == network && (*it)->GetMask () == mask)

    {

      *it = 0;

      m_prefixes.erase (it);

      break;

    }

  }

  GetRoutingProtocol ()->NotifyRemoveRoute (Ipv6Address::GetAny (), Ipv6Prefix ((uint8_t)0), defaultRouter, interface, network);

}

bool Ipv6L3Protocol::AddAddress (uint32_t i, Ipv6InterfaceAddress address)

{

  NS_LOG_FUNCTION (this << i << address);

  Ptr<Ipv6Interface> interface = GetInterface (i);

  bool ret = interface->AddAddress (address);

  if (m_routingProtocol != 0)

  {

    m_routingProtocol->NotifyAddAddress (i, address);

  }

  return ret;

}

uint32_t Ipv6L3Protocol::GetNAddresses (uint32_t i) const

{

  NS_LOG_FUNCTION (this << i);

  Ptr<Ipv6Interface> interface = GetInterface (i);

  return interface->GetNAddresses ();

}

Ipv6InterfaceAddress Ipv6L3Protocol::GetAddress (uint32_t i, uint32_t addressIndex) const

{

  NS_LOG_FUNCTION (this << i << addressIndex);

  Ptr<Ipv6Interface> interface = GetInterface (i);

  return interface->GetAddress (addressIndex);

}

bool Ipv6L3Protocol::RemoveAddress (uint32_t i, uint32_t addressIndex)

{

  NS_LOG_FUNCTION (this << i << addressIndex);

  Ptr<Ipv6Interface> interface = GetInterface (i);

  Ipv6InterfaceAddress address = interface->RemoveAddress (addressIndex);

  if (address != Ipv6InterfaceAddress ())

  {

    if (m_routingProtocol != 0)

    {

      m_routingProtocol->NotifyRemoveAddress (i, address);

    }

    return true;

  }

  return false;

}

void Ipv6L3Protocol::SetMetric (uint32_t i, uint16_t metric) 

{

  NS_LOG_FUNCTION (this << i << metric);

  Ptr<Ipv6Interface> interface = GetInterface (i);

  interface->SetMetric (metric);

}

uint16_t Ipv6L3Protocol::GetMetric (uint32_t i) const 

{

  NS_LOG_FUNCTION (this << i);

  Ptr<Ipv6Interface> interface = GetInterface (i);

  return interface->GetMetric ();

}

uint16_t Ipv6L3Protocol::GetMtu (uint32_t i) const

{

  NS_LOG_FUNCTION (this << i);

  Ptr<Ipv6Interface> interface = GetInterface (i);

  return interface->GetDevice ()->GetMtu ();

}

bool Ipv6L3Protocol::IsUp (uint32_t i) const

{

  NS_LOG_FUNCTION (this << i);

  Ptr<Ipv6Interface> interface = GetInterface (i);

  return interface->IsUp ();

}

void Ipv6L3Protocol::SetUp (uint32_t i)

{

  NS_LOG_FUNCTION (this << i);

  Ptr<Ipv6Interface> interface = GetInterface (i);

  interface->SetUp ();

  if (m_routingProtocol != 0)

  {

    m_routingProtocol->NotifyInterfaceUp (i);

  }

}

void Ipv6L3Protocol::SetDown (uint32_t i)

{

  NS_LOG_FUNCTION (this << i);

  Ptr<Ipv6Interface> interface = GetInterface (i);

  interface->SetDown ();

  if (m_routingProtocol != 0)

  {

    m_routingProtocol->NotifyInterfaceDown (i);

  }

}

void Ipv6L3Protocol::SetupLoopback ()

{

  NS_LOG_FUNCTION_NOARGS ();

  Ptr<Ipv6Interface> interface = CreateObject<Ipv6Interface> ();

  Ptr<LoopbackNetDevice> device = 0;

  uint32_t i = 0;

  /* see if we have already an loopback NetDevice */

  for (i = 0 ; i < m_node->GetNDevices () ; i++)

  {

    if (device = DynamicCast<LoopbackNetDevice> (m_node->GetDevice (i)))

    {

      break;

    }

  }

  if (device == 0)

  {

    device = CreateObject<LoopbackNetDevice> ();

    m_node->AddDevice (device);

  }

  interface->SetDevice (device);

  interface->SetNode (m_node);

  Ipv6InterfaceAddress ifaceAddr = Ipv6InterfaceAddress (Ipv6Address::GetLoopback (), Ipv6Prefix (128));

  interface->AddAddress (ifaceAddr);

  uint32_t index = AddIpv6Interface (interface);

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

  node->RegisterProtocolHandler (MakeCallback (&Ipv6L3Protocol::Receive, this), Ipv6L3Protocol::PROT_NUMBER, device);

  interface->SetUp ();

  if (m_routingProtocol != 0)

  {

    m_routingProtocol->NotifyInterfaceUp (index);

  }

}

bool Ipv6L3Protocol::IsForwarding (uint32_t i) const

{

  NS_LOG_FUNCTION (this << i);

  Ptr<Ipv6Interface> interface = GetInterface (i);

  NS_LOG_LOGIC ("Forwarding state: " << interface->IsForwarding ());

  return interface->IsForwarding ();

}

void Ipv6L3Protocol::SetForwarding (uint32_t i, bool val)

{

  NS_LOG_FUNCTION (this << i << val);

  Ptr<Ipv6Interface> interface = GetInterface (i);

  interface->SetForwarding (val);

}

void Ipv6L3Protocol::SetIpForward (bool forward)

{

  NS_LOG_FUNCTION (this << forward);

  m_ipForward = forward;

  for (Ipv6InterfaceList::const_iterator it = m_interfaces.begin () ; it != m_interfaces.end (); it++)

  {

    (*it)->SetForwarding (forward);

  }

}

bool Ipv6L3Protocol::GetIpForward () const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_ipForward;

}

void Ipv6L3Protocol::NotifyNewAggregate ()

{

  NS_LOG_FUNCTION_NOARGS ();

  if (m_node == 0)

  {

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

    // verify that it's a valid node and that

    // the node has not been set before

    if (node != 0)

    {

      this->SetNode (node);

    }

  }

  Object::NotifyNewAggregate ();

}

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

{

  NS_LOG_FUNCTION (this << node);

  m_node = node;

  /* add LoopbackNetDevice if needed, and an Ipv6Interface on top of it */

  SetupLoopback ();

}

void Ipv6L3Protocol::Insert (Ptr<Ipv6L4Protocol> protocol)

{

  NS_LOG_FUNCTION (this << protocol);

  m_protocols.push_back (protocol);

}