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

#include "ns3/log.h"

#include "ns3/node.h"

#include "ns3/packet.h"

#include "ns3/simulator.h"

#include "ns3/ipv6-route.h"

#include "ns3/net-device.h"

#include "ipv6-static-routing.h"

#include "ipv6-routing-table-entry.h"

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("Ipv6StaticRouting")

  ;

NS_OBJECT_ENSURE_REGISTERED (Ipv6StaticRouting)

  ;

TypeId Ipv6StaticRouting::GetTypeId ()

{

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

    .SetParent<Ipv6RoutingProtocol> ()

    .AddConstructor<Ipv6StaticRouting> ()

  ;

  return tid;

}

Ipv6StaticRouting::Ipv6StaticRouting ()

  : m_ipv6 (0)

{

  NS_LOG_FUNCTION_NOARGS ();

}

Ipv6StaticRouting::~Ipv6StaticRouting ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

void Ipv6StaticRouting::SetIpv6 (Ptr<Ipv6> ipv6)

{

  NS_LOG_FUNCTION (this << ipv6);

  NS_ASSERT (m_ipv6 == 0 && ipv6 != 0);

  uint32_t i = 0;

  m_ipv6 = ipv6;

  for (i = 0; i < m_ipv6->GetNInterfaces (); i++)

    {

      if (m_ipv6->IsUp (i))

        {

          NotifyInterfaceUp (i);

        }

      else

        {

          NotifyInterfaceDown (i);

        }

    }

}

// Formatted like output of "route -n" command

void

Ipv6StaticRouting::PrintRoutingTable (Ptr<OutputStreamWrapper> stream) const

{

  NS_LOG_FUNCTION (this);

  std::ostream* os = stream->GetStream ();

  if (GetNRoutes () > 0)

    {

      *os << "Node: " << m_ipv6->GetObject<Node> ()->GetId ()

          << " Time: " << Simulator::Now ().GetSeconds () << "s "

          << "Ipv6StaticRouting table" << std::endl;

      for (uint32_t j = 0; j < GetNRoutes (); j++)

        {

          Ipv6RoutingTableEntry route = GetRoute (j);

          *os << route << std::endl;

        }

    }

}

void Ipv6StaticRouting::AddHostRouteTo (Ipv6Address dst, Ipv6Address nextHop, uint32_t interface, Ipv6Address prefixToUse, uint32_t metric)

{

  NS_LOG_FUNCTION (this << dst << nextHop << interface << prefixToUse << metric);

  if (nextHop.IsLinkLocal())

    {

      NS_LOG_WARN ("Ipv6StaticRouting::AddHostRouteTo - Next hop should be link-local");

    }

  AddNetworkRouteTo (dst, Ipv6Prefix::GetOnes (), nextHop, interface, prefixToUse, metric);

}

void Ipv6StaticRouting::AddHostRouteTo (Ipv6Address dst, uint32_t interface, uint32_t metric)

{

  NS_LOG_FUNCTION (this << dst << interface << metric);

  AddNetworkRouteTo (dst, Ipv6Prefix::GetOnes (), interface, metric);

}

void Ipv6StaticRouting::AddNetworkRouteTo (Ipv6Address network, Ipv6Prefix networkPrefix, Ipv6Address nextHop, uint32_t interface, uint32_t metric)

{

  NS_LOG_FUNCTION (this << network << networkPrefix << nextHop << interface << metric);

  Ipv6RoutingTableEntry* route = new Ipv6RoutingTableEntry ();

  *route = Ipv6RoutingTableEntry::CreateNetworkRouteTo (network, networkPrefix, nextHop, interface);

  m_networkRoutes.push_back (std::make_pair (route, metric));

}

void Ipv6StaticRouting::AddNetworkRouteTo (Ipv6Address network, Ipv6Prefix networkPrefix, Ipv6Address nextHop, uint32_t interface, Ipv6Address prefixToUse, uint32_t metric)

{

  NS_LOG_FUNCTION (this << network << networkPrefix << nextHop << interface << prefixToUse << metric);

  if (nextHop.IsLinkLocal())

    {

      NS_LOG_WARN ("Ipv6StaticRouting::AddNetworkRouteTo - Next hop should be link-local");

    }

  Ipv6RoutingTableEntry* route = new Ipv6RoutingTableEntry ();

  *route = Ipv6RoutingTableEntry::CreateNetworkRouteTo (network, networkPrefix, nextHop, interface, prefixToUse);

  m_networkRoutes.push_back (std::make_pair (route, metric));

}

void Ipv6StaticRouting::AddNetworkRouteTo (Ipv6Address network, Ipv6Prefix networkPrefix, uint32_t interface, uint32_t metric)

{

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

  Ipv6RoutingTableEntry* route = new Ipv6RoutingTableEntry ();

  *route = Ipv6RoutingTableEntry::CreateNetworkRouteTo (network, networkPrefix, interface);

  m_networkRoutes.push_back (std::make_pair (route, metric));

}

void Ipv6StaticRouting::SetDefaultRoute (Ipv6Address nextHop, uint32_t interface, Ipv6Address prefixToUse, uint32_t metric)

{

  NS_LOG_FUNCTION (this << nextHop << interface << prefixToUse);

  AddNetworkRouteTo (Ipv6Address ("::"), Ipv6Prefix::GetZero (), nextHop, interface, prefixToUse, metric);

}

void Ipv6StaticRouting::AddMulticastRoute (Ipv6Address origin, Ipv6Address group, uint32_t inputInterface, std::vector<uint32_t> outputInterfaces)

{

  NS_LOG_FUNCTION (this << origin << group << inputInterface);

  Ipv6MulticastRoutingTableEntry* route = new Ipv6MulticastRoutingTableEntry ();

  *route = Ipv6MulticastRoutingTableEntry::CreateMulticastRoute (origin, group, inputInterface, outputInterfaces);

  m_multicastRoutes.push_back (route);

}

void Ipv6StaticRouting::SetDefaultMulticastRoute (uint32_t outputInterface)

{

  NS_LOG_FUNCTION (this << outputInterface);

  Ipv6RoutingTableEntry *route = new Ipv6RoutingTableEntry ();

  Ipv6Address network = Ipv6Address ("ff00::"); /* RFC 3513 */

  Ipv6Prefix networkMask = Ipv6Prefix (8);

  *route = Ipv6RoutingTableEntry::CreateNetworkRouteTo (network, networkMask, outputInterface);

  m_networkRoutes.push_back (std::make_pair (route, 0));

}

uint32_t Ipv6StaticRouting::GetNMulticastRoutes () const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_multicastRoutes.size ();

}

Ipv6MulticastRoutingTableEntry Ipv6StaticRouting::GetMulticastRoute (uint32_t index) const

{

  NS_LOG_FUNCTION (this << index);

  NS_ASSERT_MSG (index < m_multicastRoutes.size (), "Ipv6StaticRouting::GetMulticastRoute () : Index out of range");

  if (index < m_multicastRoutes.size ())

    {

      uint32_t tmp = 0;

      for (MulticastRoutesCI i = m_multicastRoutes.begin (); i != m_multicastRoutes.end (); i++)

        {

          if (tmp  == index)

            {

              return *i;

            }

          tmp++;

        }

    }

  return 0;

}

bool Ipv6StaticRouting::RemoveMulticastRoute (Ipv6Address origin, Ipv6Address group, uint32_t inputInterface)

{

  NS_LOG_FUNCTION (this << origin << group << inputInterface);

  for (MulticastRoutesI i = m_multicastRoutes.begin (); i != m_multicastRoutes.end (); i++)

    {

      Ipv6MulticastRoutingTableEntry *route = *i;

      if (origin == route->GetOrigin ()

          && group == route->GetGroup ()

          && inputInterface == route->GetInputInterface ())

        {

          delete *i;

          m_multicastRoutes.erase (i);

          return true;

        }

    }

  return false;

}

void Ipv6StaticRouting::RemoveMulticastRoute (uint32_t index)

{

  NS_LOG_FUNCTION (this << index);

  uint32_t tmp = 0;

  for (MulticastRoutesI i = m_multicastRoutes.begin (); i != m_multicastRoutes.end (); i++)

    {

      if (tmp == index)

        {

          delete *i;

          m_multicastRoutes.erase (i);

          return;

        }

      tmp++;

    }

}

bool Ipv6StaticRouting::HasNetworkDest (Ipv6Address network, uint32_t interfaceIndex)

{

  NS_LOG_FUNCTION (this << network << interfaceIndex);

  /* in the network table */

  for (NetworkRoutesI j = m_networkRoutes.begin (); j != m_networkRoutes.end (); j++)

    {

      Ipv6RoutingTableEntry* rtentry = j->first;

      Ipv6Prefix prefix = rtentry->GetDestNetworkPrefix ();

      Ipv6Address entry = rtentry->GetDestNetwork ();

      if (prefix.IsMatch (network, entry) && rtentry->GetInterface () == interfaceIndex)

        {

          return true;

        }

    }

  /* beuh!!! not route at all */

  return false;

}

Ptr<Ipv6Route> Ipv6StaticRouting::LookupStatic (Ipv6Address dst, Ptr<NetDevice> interface)

{

  NS_LOG_FUNCTION (this << dst << interface);

  Ptr<Ipv6Route> rtentry = 0;

  uint16_t longestMask = 0;

  uint32_t shortestMetric = 0xffffffff;

  /* when sending on link-local multicast, there have to be interface specified */

  if (dst == Ipv6Address::GetAllNodesMulticast () || dst.IsSolicitedMulticast ()

      || dst == Ipv6Address::GetAllRoutersMulticast () || dst == Ipv6Address::GetAllHostsMulticast ())

    {

      NS_ASSERT_MSG (interface, "Try to send on link-local multicast address, and no interface index is given!");

      rtentry = Create<Ipv6Route> ();

      rtentry->SetSource (SourceAddressSelection (m_ipv6->GetInterfaceForDevice (interface), dst));

      rtentry->SetDestination (dst);

      rtentry->SetGateway (Ipv6Address::GetZero ());

      rtentry->SetOutputDevice (interface);

      return rtentry;

    }

  for (NetworkRoutesI it = m_networkRoutes.begin (); it != m_networkRoutes.end (); it++)

    {

      Ipv6RoutingTableEntry* j = it->first;

      uint32_t metric = it->second;

      Ipv6Prefix mask = j->GetDestNetworkPrefix ();

      uint16_t maskLen = mask.GetPrefixLength ();

      Ipv6Address entry = j->GetDestNetwork ();

      NS_LOG_LOGIC ("Searching for route to " << dst << ", mask length " << maskLen << ", metric " << metric);

      if (mask.IsMatch (dst, entry))

        {

          NS_LOG_LOGIC ("Found global network route " << j << ", mask length " << maskLen << ", metric " << metric);

          /* if interface is given, check the route will output on this interface */

          if (!interface || interface == m_ipv6->GetNetDevice (j->GetInterface ()))

            {

              if (maskLen < longestMask)

                {

                  NS_LOG_LOGIC ("Previous match longer, skipping");

                  continue;

                }

              if (maskLen > longestMask)

                {

                  shortestMetric = 0xffffffff;

                }

              longestMask = maskLen;

              if (metric > shortestMetric)

                {

                  NS_LOG_LOGIC ("Equal mask length, but previous metric shorter, skipping");

                  continue;

                }

              shortestMetric = metric;

              Ipv6RoutingTableEntry* route = j;

              uint32_t interfaceIdx = route->GetInterface ();

              rtentry = Create<Ipv6Route> ();

              if (route->GetGateway ().IsAny ())

                {

                  rtentry->SetSource (SourceAddressSelection (interfaceIdx, route->GetDest ()));

                }

              else if (route->GetDest ().IsAny ()) /* default route */

                {

                  rtentry->SetSource (SourceAddressSelection (interfaceIdx, route->GetPrefixToUse ().IsAny () ? dst : route->GetPrefixToUse ()));

                }

              else

                {

                  rtentry->SetSource (SourceAddressSelection (interfaceIdx, route->GetGateway ()));

                }

              rtentry->SetDestination (route->GetDest ());

              rtentry->SetGateway (route->GetGateway ());

              rtentry->SetOutputDevice (m_ipv6->GetNetDevice (interfaceIdx));

            }

        }

    }

  if (rtentry)

    {

      NS_LOG_LOGIC ("Matching route via " << rtentry->GetDestination () << " (throught " << rtentry->GetGateway () << ") at the end");

    }

  return rtentry;

}

void Ipv6StaticRouting::DoDispose ()

{

  NS_LOG_FUNCTION_NOARGS ();

  for (NetworkRoutesI j = m_networkRoutes.begin ();  j != m_networkRoutes.end (); j = m_networkRoutes.erase (j))

    {

      delete j->first;

    }

  m_networkRoutes.clear ();

  for (MulticastRoutesI i = m_multicastRoutes.begin (); i != m_multicastRoutes.end (); i = m_multicastRoutes.erase (i))

    {

      delete (*i);

    }

  m_multicastRoutes.clear ();

  m_ipv6 = 0;

  Ipv6RoutingProtocol::DoDispose ();

}

Ptr<Ipv6MulticastRoute> Ipv6StaticRouting::LookupStatic (Ipv6Address origin, Ipv6Address group, uint32_t interface)

{

  NS_LOG_FUNCTION (this << origin << group << interface);

  Ptr<Ipv6MulticastRoute> mrtentry = 0;

  for (MulticastRoutesI i = m_multicastRoutes.begin (); i != m_multicastRoutes.end (); i++)

    {

      Ipv6MulticastRoutingTableEntry* route = *i;

      /*

         We've been passed an origin address, a multicast group address and an

         interface index.  We have to decide if the current route in the list is

         a match.

         The first case is the restrictive case where the origin, group and index

         matches.  This picks up exact routes during forwarded and exact routes from

         the local node (in which case the ifIndex is a wildcard).

         */

      if (origin == route->GetOrigin () && group == route->GetGroup ())

        {

          /* skipping SSM case */

          NS_LOG_LOGIC ("Find source specific multicast route" << *i);

        }

      if (group == route->GetGroup ())

        {

          if (interface == Ipv6::IF_ANY || interface == route->GetInputInterface ())

            {

              NS_LOG_LOGIC ("Found multicast route" << *i);

              mrtentry = Create<Ipv6MulticastRoute> ();

              mrtentry->SetGroup (route->GetGroup ());

              mrtentry->SetOrigin (route->GetOrigin ());

              mrtentry->SetParent (route->GetInputInterface ());

              for (uint32_t j = 0; j < route->GetNOutputInterfaces (); j++)

                {

                  if (route->GetOutputInterface (j))

                    {

                      NS_LOG_LOGIC ("Setting output interface index " << route->GetOutputInterface (j));

                      mrtentry->SetOutputTtl (route->GetOutputInterface (j), Ipv6MulticastRoute::MAX_TTL - 1);

                    }

                }

              return mrtentry;

            }

        }

    }

  return mrtentry;

}

uint32_t Ipv6StaticRouting::GetNRoutes () const

{

  return m_networkRoutes.size ();

}

Ipv6RoutingTableEntry Ipv6StaticRouting::GetDefaultRoute ()

{

  NS_LOG_FUNCTION_NOARGS ();

  Ipv6Address dst ("::");

  uint32_t shortestMetric = 0xffffffff;

  Ipv6RoutingTableEntry* result = 0;

  for (NetworkRoutesI it = m_networkRoutes.begin (); it != m_networkRoutes.end (); it++)

    {

      Ipv6RoutingTableEntry* j = it->first;

      uint32_t metric = it->second;

      Ipv6Prefix mask = j->GetDestNetworkPrefix ();

      uint16_t maskLen = mask.GetPrefixLength ();

      Ipv6Address entry = j->GetDestNetwork ();

      if (maskLen)

        {

          continue;

        }

      if (metric > shortestMetric)

        {

          continue;

        }

      shortestMetric = metric;

      result = j;

    }

  if (result)

    {

      return result;

    }

  else

    {

      return Ipv6RoutingTableEntry ();

    }

}

Ipv6RoutingTableEntry Ipv6StaticRouting::GetRoute (uint32_t index) const

{

  NS_LOG_FUNCTION (this << index);

  uint32_t tmp = 0;

  for (NetworkRoutesCI it = m_networkRoutes.begin (); it != m_networkRoutes.end (); it++)

    {

      if (tmp == index)

        {

          return it->first;

        }

      tmp++;

    }

  NS_ASSERT (false);

  // quiet compiler.

  return 0;

}

uint32_t Ipv6StaticRouting::GetMetric (uint32_t index) const

{

  NS_LOG_FUNCTION_NOARGS ();

  uint32_t tmp = 0;

  for (NetworkRoutesCI it = m_networkRoutes.begin (); it != m_networkRoutes.end (); it++)

    {

      if (tmp == index)

        {

          return it->second;

        }

      tmp++;

    }

  NS_ASSERT (false);

  // quiet compiler.

  return 0;

}

void Ipv6StaticRouting::RemoveRoute (uint32_t index)

{

  NS_LOG_FUNCTION (this << index);

  uint32_t tmp = 0;

  for (NetworkRoutesI it = m_networkRoutes.begin (); it != m_networkRoutes.end (); it++)

    {

      if (tmp == index)

        {

          delete it->first;

          m_networkRoutes.erase (it);

          return;

        }