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

//

// Copyright (c) 2006 Georgia Tech Research Corporation

//

// 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: George F. Riley<riley@ece.gatech.edu>

//

#include "ns3/packet.h"

#include "ns3/log.h"

#include "ns3/callback.h"

#include "ns3/ipv4-address.h"

#include "ns3/ipv4-route.h"

#include "ns3/node.h"

#include "ns3/socket.h"

#include "ns3/net-device.h"

#include "ns3/uinteger.h"

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

#include "ns3/object-vector.h"

#include "ns3/ipv4-header.h"

#include "ns3/boolean.h"

#include "arp-l3-protocol.h"

#include "ipv4-l3-protocol.h"

#include "ipv4-l4-protocol.h"

#include "ipv4-interface.h"

#include "ipv4-loopback-interface.h"

#include "arp-ipv4-interface.h"

NS_LOG_COMPONENT_DEFINE ("Ipv4L3Protocol");

namespace ns3 {

const uint16_t Ipv4L3Protocol::PROT_NUMBER = 0x0800;

NS_OBJECT_ENSURE_REGISTERED (Ipv4L3Protocol);

TypeId 

Ipv4L3Protocol::GetTypeId (void)

{

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

    .SetParent<Object> ()

    .AddConstructor<Ipv4L3Protocol> ()

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

                   UintegerValue (64),

                   MakeUintegerAccessor (&Ipv4L3Protocol::m_defaultTtl),

                   MakeUintegerChecker<uint8_t> ())

    .AddAttribute ("CalcChecksum", "If true, we calculate the checksum of outgoing packets"

                   " and verify the checksum of incoming packets.",

                   BooleanValue (false),

                   MakeBooleanAccessor (&Ipv4L3Protocol::m_calcChecksum),

                   MakeBooleanChecker ())

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

                   MakeTraceSourceAccessor (&Ipv4L3Protocol::m_txTrace))

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

                     MakeTraceSourceAccessor (&Ipv4L3Protocol::m_rxTrace))

    .AddTraceSource ("Drop", "Drop ipv4 packet",

                     MakeTraceSourceAccessor (&Ipv4L3Protocol::m_dropTrace))

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

                   ObjectVectorValue (),

                   MakeObjectVectorAccessor (&Ipv4L3Protocol::m_interfaces),

                   MakeObjectVectorChecker<Ipv4Interface> ())

    ;

  return tid;

}

Ipv4L3Protocol::Ipv4L3Protocol()

  : m_nInterfaces (0),

    m_identification (0)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_staticRouting = CreateObject<Ipv4StaticRouting> ();

  AddRoutingProtocol (m_staticRouting, 0);

}

Ipv4L3Protocol::~Ipv4L3Protocol ()

{

  NS_LOG_FUNCTION (this);

}

void

Ipv4L3Protocol::Insert(Ptr<Ipv4L4Protocol> protocol)

{

  m_protocols.push_back (protocol);

}

Ptr<Ipv4L4Protocol>

{

    {

      if ((*i)->GetProtocolNumber () == protocolNumber)

	{

	  return *i;

	}

    }

  return 0;

}

void

Ipv4L3Protocol::Remove (Ptr<Ipv4L4Protocol> protocol)

{

  m_protocols.remove (protocol);

}

void

Ipv4L3Protocol::SetNode (Ptr<Node> node)

{

  m_node = node;

  SetupLoopback ();

}

void 

Ipv4L3Protocol::DoDispose (void)

{

  NS_LOG_FUNCTION (this);

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

    {

      (*i)->Dispose ();

      *i = 0;

    }

  m_protocols.clear ();

  for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); ++i)

    {

      Ptr<Ipv4Interface> interface = *i;

      interface->Dispose ();

    }

  m_interfaces.clear ();

  m_node = 0;

  m_staticRouting->Dispose ();

  m_staticRouting = 0;

  Object::DoDispose ();

}

void

Ipv4L3Protocol::SetupLoopback (void)

{

  NS_LOG_FUNCTION_NOARGS ();

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

  interface->SetNode (m_node);

  interface->SetAddress (Ipv4Address::GetLoopback ());

  interface->SetNetworkMask (Ipv4Mask::GetLoopback ());

  uint32_t index = AddIpv4Interface (interface);

  AddHostRouteTo (Ipv4Address::GetLoopback (), index);

  interface->SetUp ();

}

void 

Ipv4L3Protocol::SetDefaultTtl (uint8_t ttl)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_defaultTtl = ttl;

}

void 

Ipv4L3Protocol::AddHostRouteTo (Ipv4Address dest, 

                      Ipv4Address nextHop, 

                      uint32_t interface)

{

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

  m_staticRouting->AddHostRouteTo (dest, nextHop, interface);

}

void 

Ipv4L3Protocol::AddHostRouteTo (Ipv4Address dest, 

				uint32_t interface)

{

  NS_LOG_FUNCTION (this << dest << interface);

  m_staticRouting->AddHostRouteTo (dest, interface);

}

void 

Ipv4L3Protocol::AddNetworkRouteTo (Ipv4Address network, 

				   Ipv4Mask networkMask, 

				   Ipv4Address nextHop, 

				   uint32_t interface)

{

  NS_LOG_FUNCTION (this << network << networkMask << nextHop << interface);

  m_staticRouting->AddNetworkRouteTo (network, networkMask, nextHop, interface);

}

void 

Ipv4L3Protocol::AddNetworkRouteTo (Ipv4Address network, 

				   Ipv4Mask networkMask, 

				   uint32_t interface)

{

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

  m_staticRouting->AddNetworkRouteTo (network, networkMask, interface);

}

void 

Ipv4L3Protocol::SetDefaultRoute (Ipv4Address nextHop, 

				 uint32_t interface)

{

  NS_LOG_FUNCTION (this << nextHop << interface);

  m_staticRouting->SetDefaultRoute (nextHop, interface);

}

void

Ipv4L3Protocol::Lookup (

  Ipv4Header const &ipHeader,

  Ptr<Packet> packet,

  Ipv4RoutingProtocol::RouteReplyCallback routeReply)

{

  NS_LOG_FUNCTION (this << &ipHeader << packet << &routeReply);

  Lookup (Ipv4RoutingProtocol::IF_INDEX_ANY, ipHeader, packet, routeReply);

}

void

Ipv4L3Protocol::Lookup (

  uint32_t ifIndex,

  Ipv4Header const &ipHeader,

  Ptr<Packet> packet,

  Ipv4RoutingProtocol::RouteReplyCallback routeReply)

{

  NS_LOG_FUNCTION (this << ifIndex << &ipHeader << packet << &routeReply);

  for (Ipv4RoutingProtocolList::const_iterator rprotoIter = 

         m_routingProtocols.begin ();

       rprotoIter != m_routingProtocols.end (); 

       rprotoIter++)

    {

      NS_LOG_LOGIC ("Requesting route");

      if ((*rprotoIter).second->RequestRoute (ifIndex, ipHeader, packet, 

                                              routeReply))

        return;

    }

  if (ipHeader.GetDestination ().IsMulticast () && 

      ifIndex == Ipv4RoutingProtocol::IF_INDEX_ANY)

    {

      NS_LOG_LOGIC ("Multicast destination with local source");

//

// We have a multicast packet originating from the current node and were not

// able to send it using the usual RequestRoute process.  Since the usual

// process includes trying to use a default multicast route, this means that

// there was no specific route out of the node found, and there was no default

// multicast route set.

//

// The fallback position is to look for a default unicast route and use that

// to get the packet off the node if we have one.

//

      Ipv4Route *route = m_staticRouting->GetDefaultRoute ();

      if (route)

        {

          NS_LOG_LOGIC ("Local source. Using unicast default route for "

            "multicast packet");

          routeReply (true, *route, packet, ipHeader);

          return;

        }

    }

//

// No route found

//

  routeReply (false, Ipv4Route (), packet, ipHeader);

}

void

Ipv4L3Protocol::AddRoutingProtocol (Ptr<Ipv4RoutingProtocol> routingProtocol,

                                    int priority)

{

  NS_LOG_FUNCTION (this << &routingProtocol << priority);

  m_routingProtocols.push_back

    (std::pair<int, Ptr<Ipv4RoutingProtocol> > (-priority, routingProtocol));

  m_routingProtocols.sort ();

}

uint32_t 

Ipv4L3Protocol::GetNRoutes (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_staticRouting->GetNRoutes ();

}

Ipv4Route *

Ipv4L3Protocol::GetRoute (uint32_t index)

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_staticRouting->GetRoute (index);

}

void 

Ipv4L3Protocol::RemoveRoute (uint32_t index)

{

  NS_LOG_FUNCTION (this << index);

  m_staticRouting->RemoveRoute (index);

}

void 

Ipv4L3Protocol::AddMulticastRoute (Ipv4Address origin,

                                   Ipv4Address group,

                                   uint32_t inputInterface,

                                   std::vector<uint32_t> outputInterfaces)

{

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

  m_staticRouting->AddMulticastRoute (origin, group, inputInterface,

    outputInterfaces);

}

void 

Ipv4L3Protocol::SetDefaultMulticastRoute (uint32_t outputInterface)

{

  NS_LOG_FUNCTION (this << outputInterface);

  m_staticRouting->SetDefaultMulticastRoute (outputInterface);

}

uint32_t 

Ipv4L3Protocol::GetNMulticastRoutes (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_staticRouting->GetNMulticastRoutes ();

}

Ipv4MulticastRoute *

Ipv4L3Protocol::GetMulticastRoute (uint32_t index) const

{

  NS_LOG_FUNCTION (this << index);

  return m_staticRouting->GetMulticastRoute (index);

}

void 

Ipv4L3Protocol::RemoveMulticastRoute (Ipv4Address origin,

                                       Ipv4Address group,

                                       uint32_t inputInterface)

{

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

  m_staticRouting->RemoveMulticastRoute (origin, group, inputInterface);

}

void 

Ipv4L3Protocol::RemoveMulticastRoute (uint32_t index)

{

  NS_LOG_FUNCTION (this << index);

  m_staticRouting->RemoveMulticastRoute (index);

}

uint32_t 

Ipv4L3Protocol::AddInterface (Ptr<NetDevice> device)

{

  NS_LOG_FUNCTION (this << &device);

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

  node->RegisterProtocolHandler (MakeCallback (&Ipv4L3Protocol::Receive, this), 

                                 Ipv4L3Protocol::PROT_NUMBER, device);

  node->RegisterProtocolHandler (MakeCallback (&ArpL3Protocol::Receive, PeekPointer (GetObject<ArpL3Protocol> ())),

                                 ArpL3Protocol::PROT_NUMBER, device);

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

  interface->SetNode (m_node);

  interface->SetDevice (device);

  return AddIpv4Interface (interface);

}

uint32_t 

Ipv4L3Protocol::AddIpv4Interface (Ptr<Ipv4Interface>interface)

{

  NS_LOG_FUNCTION (this << interface);

  uint32_t index = m_nInterfaces;

  m_interfaces.push_back (interface);

  m_nInterfaces++;

  return index;

}

Ptr<Ipv4Interface>

Ipv4L3Protocol::GetInterface (uint32_t index) const

{

  NS_LOG_FUNCTION (this << index);

  uint32_t tmp = 0;

  for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)

    {

      if (index == tmp) 

	{

	  return *i;

	}

      tmp++;

    }

  return 0;

}

uint32_t 

Ipv4L3Protocol::GetNInterfaces (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_nInterfaces;

}

uint32_t 

Ipv4L3Protocol::FindInterfaceForAddr (Ipv4Address addr) const

{

  NS_LOG_FUNCTION (this << addr);

  uint32_t ifIndex = 0;

  for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin (); 

       i != m_interfaces.end (); 

       i++, ifIndex++)

    {

      if ((*i)->GetAddress () == addr)

        {

          return ifIndex;

        }

    }

  NS_FATAL_ERROR ("Ipv4L3Protocol::FindInterfaceForAddr (): "

                  "Interface not found for IP address " << addr);

  return 0;

}

uint32_t 

Ipv4L3Protocol::FindInterfaceForAddr (Ipv4Address addr, Ipv4Mask mask) const

{

  NS_LOG_FUNCTION (this << addr << mask);

  uint32_t ifIndex = 0;

  for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin (); 

       i != m_interfaces.end (); 

       i++, ifIndex++)

    {

      if ((*i)->GetAddress ().CombineMask (mask) == addr.CombineMask (mask))

        {

          return ifIndex;

        }

    }

  NS_ASSERT_MSG(false, "Ipv4L3Protocol::FindInterfaceForAddr (): "

    "Interface not found for masked IP address");

  return 0;

}

int32_t 

Ipv4L3Protocol::FindInterfaceIndexForDevice (Ptr<NetDevice> device) const

{

  NS_LOG_FUNCTION (this << device);

  uint32_t ifIndex = 0;

  for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin (); 

       i != m_interfaces.end (); 

       i++, ifIndex++)

    {

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

        {

          return ifIndex;

        }

    }

  return -1;

}

Ptr<Ipv4Interface>

Ipv4L3Protocol::FindInterfaceForDevice (Ptr<const NetDevice> device)

{

  NS_LOG_FUNCTION (this << &device);

  for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)

    {

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

        {

          return *i;

        }

    }

  return 0;

}  

void 

Ipv4L3Protocol::Receive( Ptr<NetDevice> device, Ptr<const Packet> p, uint16_t protocol, const Address &from,

                         const Address &to, NetDevice::PacketType packetType)

{

  NS_LOG_FUNCTION (this << &device << p << protocol <<  from);

  NS_LOG_LOGIC ("Packet from " << from << " received on node " << m_node->GetId ());