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

//

// Copyright (c) 2006 Georgia Tech Research Corporation

// All rights reserved.

//

// 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/debug.h"

#include "ns3/composite-trace-resolver.h"

#include "ns3/array-trace-resolver.h"

#include "ns3/callback.h"

#include "ns3/ipv4-address.h"

#include "ns3/ipv4-route.h"

#include "ns3/node.h"

#include "ns3/net-device.h"

#include "ipv4-l3-protocol.h"

#include "ipv4-l4-protocol.h"

#include "ipv4-header.h"

#include "ipv4-interface.h"

#include "ipv4-loopback-interface.h"

#include "arp-ipv4-interface.h"

#include "ipv4-l4-demux.h"

NS_DEBUG_COMPONENT_DEFINE ("Ipv4L3Protocol");

namespace ns3 {

const InterfaceId Ipv4L3Protocol::iid = MakeInterfaceId ("Ipv4L3Protocol", Object::iid);

const uint16_t Ipv4L3Protocol::PROT_NUMBER = 0x0800;

Ipv4L3ProtocolTraceContextElement::Ipv4L3ProtocolTraceContextElement ()

  : m_type (TX)

{}

Ipv4L3ProtocolTraceContextElement::Ipv4L3ProtocolTraceContextElement (enum Type type)

  : m_type (type)

{}

bool 

Ipv4L3ProtocolTraceContextElement::IsTx (void) const

{

  return m_type == TX;

}

bool 

Ipv4L3ProtocolTraceContextElement::IsRx (void) const

{

  return m_type == RX;

}

bool 

Ipv4L3ProtocolTraceContextElement::IsDrop (void) const

{

  return m_type == DROP;

}

void 

Ipv4L3ProtocolTraceContextElement::Print (std::ostream &os) const

{

  os << "ipv4=";

  switch (m_type)

    {

    case TX:

      os << "tx";

      break;

    case RX:

      os << "rx";

      break;

    case DROP:

      os << "drop";

      break;

    }

}

uint16_t 

Ipv4L3ProtocolTraceContextElement::GetUid (void)

{

  static uint16_t uid = AllocateUid<Ipv4L3ProtocolTraceContextElement> ("Ipv4L3ProtocolTraceContextElement");

  return uid;

}

Ipv4l3ProtocolInterfaceIndex::Ipv4l3ProtocolInterfaceIndex ()

  : m_index (0)

{}

Ipv4l3ProtocolInterfaceIndex::Ipv4l3ProtocolInterfaceIndex (uint32_t index)

  : m_index (index)

{}

uint32_t 

Ipv4l3ProtocolInterfaceIndex::Get (void) const

{

  return m_index;

}

void 

Ipv4l3ProtocolInterfaceIndex::Print (std::ostream &os) const

{

  os << "ipv4-interface=" << m_index;

}

uint16_t 

Ipv4l3ProtocolInterfaceIndex::GetUid (void)

{

  static uint16_t uid = AllocateUid<Ipv4l3ProtocolInterfaceIndex> ("Ipv4l3ProtocolInterfaceIndex");

  return uid;

}

Ipv4L3Protocol::Ipv4L3Protocol(Ptr<Node> node)

  : m_nInterfaces (0),

    m_defaultTtl (64),

    m_identification (0),

    m_node (node)

{

  NS_DEBUG("Ipv4L3Protocol::Ipv4L3Protocol ()");

  SetInterfaceId (Ipv4L3Protocol::iid);

  m_staticRouting = Create<Ipv4StaticRouting> ();

  AddRoutingProtocol (m_staticRouting, 0);

  SetupLoopback ();

}

Ipv4L3Protocol::~Ipv4L3Protocol ()

{

  NS_DEBUG("Ipv4L3Protocol::~Ipv4L3Protocol ()");

}

void 

Ipv4L3Protocol::DoDispose (void)

{

  NS_DEBUG("Ipv4L3Protocol::DoDispose ()");

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

       i != m_interfaces.end (); i++)

    {

      delete (*i);

    }

  m_interfaces.clear ();

  m_node = 0;

  m_staticRouting->Dispose ();

  m_staticRouting = 0;

  Object::DoDispose ();

}

void

Ipv4L3Protocol::SetupLoopback (void)

{

  NS_DEBUG("Ipv4L3Protocol::SetupLoopback ()");

  Ipv4LoopbackInterface * interface = new Ipv4LoopbackInterface (m_node);

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

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

  uint32_t index = AddIpv4Interface (interface);

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

  interface->SetUp ();

}

TraceResolver *

Ipv4L3Protocol::CreateTraceResolver (TraceContext const &context)

{

  NS_DEBUG("Ipv4L3Protocol::CreateTraceResolver ()");

  CompositeTraceResolver *resolver = new CompositeTraceResolver (context);

  resolver->Add ("tx", m_txTrace, Ipv4L3ProtocolTraceContextElement(Ipv4L3ProtocolTraceContextElement::TX));

  resolver->Add ("rx", m_rxTrace, Ipv4L3ProtocolTraceContextElement(Ipv4L3ProtocolTraceContextElement::RX));

  resolver->Add ("drop", m_dropTrace, Ipv4L3ProtocolTraceContextElement (Ipv4L3ProtocolTraceContextElement::DROP));

  resolver->Add ("interfaces", 

                 MakeCallback (&Ipv4L3Protocol::InterfacesCreateTraceResolver, this));

  return resolver;

}

TraceResolver *

Ipv4L3Protocol::InterfacesCreateTraceResolver (TraceContext const &context) const

{

  NS_DEBUG("Ipv4L3Protocol::InterfacesCreateTraceResolver ()");

  ArrayTraceResolver<Ipv4Interface *, Ipv4l3ProtocolInterfaceIndex> *resolver = 

    new ArrayTraceResolver<Ipv4Interface *,Ipv4l3ProtocolInterfaceIndex> 

    (context,

     MakeCallback (&Ipv4L3Protocol::GetNInterfaces, this),

     MakeCallback (&Ipv4L3Protocol::GetInterface, this));

  return resolver;

}

void 

Ipv4L3Protocol::SetDefaultTtl (uint8_t ttl)

{

  NS_DEBUG("Ipv4L3Protocol::SetDefaultTtl ()");

  m_defaultTtl = ttl;

}

void 

Ipv4L3Protocol::AddHostRouteTo (Ipv4Address dest, 

                      Ipv4Address nextHop, 

                      uint32_t interface)

{

  NS_DEBUG("Ipv4L3Protocol::AddHostRouteTo (" << dest << ", " << nextHop <<

    ", " << interface << ")");

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

}

void 

Ipv4L3Protocol::AddHostRouteTo (Ipv4Address dest, 

				uint32_t interface)

{

  NS_DEBUG("Ipv4L3Protocol::AddHostRouteTo (" << dest << ", " << 

    interface << ")");

  m_staticRouting->AddHostRouteTo (dest, interface);

}

void 

Ipv4L3Protocol::AddNetworkRouteTo (Ipv4Address network, 

				   Ipv4Mask networkMask, 

				   Ipv4Address nextHop, 

				   uint32_t interface)

{

  NS_DEBUG("Ipv4L3Protocol::AddNetworkRouteTo (" << network << ", " << 

    networkMask << ", " << nextHop << ", " << interface << ")");

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

}

void 

Ipv4L3Protocol::AddNetworkRouteTo (Ipv4Address network, 

				   Ipv4Mask networkMask, 

				   uint32_t interface)

{

  NS_DEBUG("Ipv4L3Protocol::AddNetworkRouteTo (" << network << ", " << 

    networkMask << ", " << interface << ")");

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

}

void 

Ipv4L3Protocol::SetDefaultRoute (Ipv4Address nextHop, 

				 uint32_t interface)

{

  NS_DEBUG("Ipv4L3Protocol::SetDefaultRoute (" << nextHop << ", " << 

    interface << ")");

  m_staticRouting->SetDefaultRoute (nextHop, interface);

}

void

Ipv4L3Protocol::Lookup (

  Ipv4Header const &ipHeader,

  Packet packet,

  Ipv4RoutingProtocol::RouteReplyCallback routeReply)

{

  NS_DEBUG("Ipv4L3Protocol::Lookup (" << &ipHeader << 

    ", " << &packet << &routeReply << ")");

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

}

void

Ipv4L3Protocol::Lookup (

  uint32_t ifIndex,

  Ipv4Header const &ipHeader,

  Packet packet,

  Ipv4RoutingProtocol::RouteReplyCallback routeReply)

{

  NS_DEBUG("Ipv4L3Protocol::Lookup (" << ifIndex << ", " << &ipHeader << 

    ", " << &packet << &routeReply << ")");

  for (Ipv4RoutingProtocolList::const_iterator rprotoIter = 

         m_routingProtocols.begin ();

       rprotoIter != m_routingProtocols.end (); 

       rprotoIter++)

    {

      NS_DEBUG("Ipv4L3Protocol::Lookup (): Requesting route");

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

                                              routeReply))

        return;

    }

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

      ifIndex == Ipv4RoutingProtocol::IF_INDEX_ANY)

    {

      NS_DEBUG ("Ipv4L3Protocol::Lookup (): "

        "Multicast destination with local source");

//

// We have a multicast packet originating from the current node.  We didn't

// want to force users to construct a route in order to get packets out of a

// node, so there will have been no route found and it is left to us to send

// the packet.  What we'll do is to send the multicast out all of the 

//

      NS_DEBUG ("Ipv4StaticRouting::Lookup (): "

        "Local source. Flooding multicast packet");

        {

          Packet p = packet;

          Ipv4Header h = ipHeader;

          Ipv4Route route = 

            Ipv4Route::CreateHostRouteTo(h.GetDestination (), i);

          NS_DEBUG ("Ipv4StaticRouting::Lookup (): "

            "Send via interface " << i);

          routeReply (true, route, p, h);

        }

      return;

    }

  // No route found

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

}

void

Ipv4L3Protocol::AddRoutingProtocol (Ptr<Ipv4RoutingProtocol> routingProtocol,

                                    int priority)

{

  NS_DEBUG("Ipv4L3Protocol::AddRoutingProtocol (" << &routingProtocol << 

    ", " << priority << ")");

  m_routingProtocols.push_back

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

  m_routingProtocols.sort ();

}

uint32_t 

Ipv4L3Protocol::GetNRoutes (void)

{

  NS_DEBUG("Ipv4L3Protocol::GetNRoutes ()");

  return m_staticRouting->GetNRoutes ();

}

Ipv4Route *

Ipv4L3Protocol::GetRoute (uint32_t index)

{

  NS_DEBUG("Ipv4L3Protocol::GetRoute ()");

  return m_staticRouting->GetRoute (index);

}

void 

Ipv4L3Protocol::RemoveRoute (uint32_t index)

{

  NS_DEBUG("Ipv4L3Protocol::RemoveRoute (" << index << ")");

  m_staticRouting->RemoveRoute (index);

}

void 

Ipv4L3Protocol::AddMulticastRoute (Ipv4Address origin,

                                   Ipv4Address group,

                                   uint32_t inputInterface,

                                   std::vector<uint32_t> outputInterfaces)

{

  NS_DEBUG("Ipv4L3Protocol::AddMulticastRoute (" << origin << ", " <<

    group << ", " << inputInterface << ", " << &outputInterfaces << ")");

  m_staticRouting->AddMulticastRoute (origin, group, inputInterface,

    outputInterfaces);

}

uint32_t 

Ipv4L3Protocol::GetNMulticastRoutes (void) const

{

  NS_DEBUG("Ipv4L3Protocol::GetNMulticastRoutes ()");

  return m_staticRouting->GetNMulticastRoutes ();

}

Ipv4MulticastRoute *

Ipv4L3Protocol::GetMulticastRoute (uint32_t index) const

{

  NS_DEBUG("Ipv4L3Protocol::GetMulticastRoute (" << index << ")");

  return m_staticRouting->GetMulticastRoute (index);

}

void 

Ipv4L3Protocol::RemoveMulticastRoute (Ipv4Address origin,

                                       Ipv4Address group,

                                       uint32_t inputInterface)

{

  NS_DEBUG("Ipv4L3Protocol::RemoveMulticastRoute (" << origin << ", " <<

    group << ", " << inputInterface << ")");

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

}

void 

Ipv4L3Protocol::RemoveMulticastRoute (uint32_t index)

{

  NS_DEBUG("Ipv4L3Protocol::RemoveMulticastRoute (" << index << ")");

  m_staticRouting->RemoveMulticastRoute (index);

}

uint32_t 

Ipv4L3Protocol::AddInterface (Ptr<NetDevice> device)

{

  NS_DEBUG("Ipv4L3Protocol::AddInterface (" << &device << ")");

  Ipv4Interface *interface = new ArpIpv4Interface (m_node, device);

  return AddIpv4Interface (interface);

}

uint32_t 

Ipv4L3Protocol::AddIpv4Interface (Ipv4Interface *interface)

{

  NS_DEBUG("Ipv4L3Protocol::AddIpv4Interface (" << interface << ")");

  uint32_t index = m_nInterfaces;

  m_interfaces.push_back (interface);

  m_nInterfaces++;

  return index;

}

Ipv4Interface *

Ipv4L3Protocol::GetInterface (uint32_t index) const

{

  NS_DEBUG("Ipv4L3Protocol::GetInterface (" << 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_DEBUG("Ipv4L3Protocol::GetNInterface ()");

  return m_nInterfaces;

}

uint32_t 

Ipv4L3Protocol::FindInterfaceForAddr (Ipv4Address addr) const

{

  NS_DEBUG("Ipv4L3Protocol::FindInterfaceForAddr (" << 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_ASSERT_MSG(false, "Ipv4L3Protocol::FindInterfaceForAddr (): "

    "Interface not found for IP address");

  return 0;

}

uint32_t 

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

{

  NS_DEBUG("Ipv4L3Protocol::FindInterfaceForAddr (" << 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;

}

Ipv4Interface *

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

{

  NS_DEBUG("Ipv4L3Protocol::FindInterfaceForDevice (" << &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, const Packet& p, uint16_t protocol, const Address &from)

{

  NS_DEBUG("Ipv4L3Protocol::Receive (" << &device << ", " << &p << ", " <<