// -*- 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 "ns3/ipv4-routing-table-entry.h"

#include "loopback-net-device.h"

#include "arp-l3-protocol.h"

#include "ipv4-l3-protocol.h"

#include "ipv4-l4-protocol.h"

#include "icmpv4-l4-protocol.h"

#include "ipv4-interface.h"

#include "ipv4-raw-socket-impl.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<Ipv4> ()

    .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> ())

    .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 ();

}

Ipv4L3Protocol::~Ipv4L3Protocol ()

{

  NS_LOG_FUNCTION (this);

}

void

Ipv4L3Protocol::Insert(Ptr<Ipv4L4Protocol> protocol)

{

  m_protocols.push_back (protocol);

}

Ptr<Ipv4L4Protocol>

Ipv4L3Protocol::GetProtocol(int protocolNumber) const

{

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

    {

      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;

  // Add a LoopbackNetDevice if needed, and an Ipv4Interface on top of it

  SetupLoopback ();

}

Ptr<Socket> 

Ipv4L3Protocol::CreateRawSocket (void)

{

  NS_LOG_FUNCTION (this);

  Ptr<Ipv4RawSocketImpl> socket = CreateObject<Ipv4RawSocketImpl> ();

  socket->SetNode (m_node);

  m_sockets.push_back (socket);

  return socket;

}

void 

Ipv4L3Protocol::DeleteRawSocket (Ptr<Socket> socket)

{

  NS_LOG_FUNCTION (this << socket);

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

    {

      if ((*i) == socket)

        {

          m_sockets.erase (i);

          return;

        }

    }

  return;

}

/*

 * This method is called by AddAgregate and completes the aggregation

 * by setting the node in the ipv4 stack

 */

void

Ipv4L3Protocol::NotifyNewAggregate ()

{

  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 

Ipv4L3Protocol::SetRoutingProtocol (Ptr<Ipv4RoutingProtocol> routingProtocol)

{

  NS_LOG_FUNCTION (this);

  m_routingProtocol = routingProtocol;

  m_routingProtocol->SetIpv4 (this);

}

Ptr<Ipv4RoutingProtocol> 

Ipv4L3Protocol::GetRoutingProtocol (void) const

{

  return m_routingProtocol;

}

void 

Ipv4L3Protocol::DoDispose (void)

{

  NS_LOG_FUNCTION (this);

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

    {

      *i = 0;

    }

  m_protocols.clear ();

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

    {

      *i = 0;

    }

  m_interfaces.clear ();

  m_node = 0;

  m_routingProtocol = 0;

  Object::DoDispose ();

}

void

Ipv4L3Protocol::SetupLoopback (void)

{

  NS_LOG_FUNCTION_NOARGS ();

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

  Ptr<LoopbackNetDevice> device = 0;

  // First check whether an existing LoopbackNetDevice exists on the node

  for (uint32_t 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);

  Ipv4InterfaceAddress ifaceAddr = Ipv4InterfaceAddress (Ipv4Address::GetLoopback (), Ipv4Mask::GetLoopback ());

  interface->AddAddress (ifaceAddr);

  uint32_t index = AddIpv4Interface (interface);

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

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

                                 Ipv4L3Protocol::PROT_NUMBER, device);

  interface->SetUp ();

  if (m_routingProtocol != 0)

    {

      m_routingProtocol->NotifyInterfaceUp (index);

    }

}

void 

Ipv4L3Protocol::SetDefaultTtl (uint8_t ttl)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_defaultTtl = ttl;

}

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<Ipv4Interface> interface = CreateObject<Ipv4Interface> ();

  interface->SetNode (m_node);

  interface->SetDevice (device);

  interface->SetForwarding (m_ipForward);

  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;

}

int32_t 

Ipv4L3Protocol::GetInterfaceForAddress (

  Ipv4Address address) const

{

  NS_LOG_FUNCTION (this << address);

  int32_t interface = 0;

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

       i != m_interfaces.end (); 

       i++, interface++)

    {

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

        {

          if ((*i)->GetAddress (j).GetLocal () == address)

            {

              return interface;

            }

        }

    }

  return -1;

}

int32_t 

Ipv4L3Protocol::GetInterfaceForPrefix (

  Ipv4Address address, 

  Ipv4Mask mask) const

{

  NS_LOG_FUNCTION (this << address << mask);

  int32_t interface = 0;

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

       i != m_interfaces.end (); 

       i++, interface++)

    {

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

        {

          if ((*i)->GetAddress (j).GetLocal ().CombineMask (mask) == address.CombineMask (mask))

            {

              return interface;

            }

        }

    }

  return -1;

}

int32_t 

Ipv4L3Protocol::GetInterfaceForDevice (

  Ptr<const NetDevice> device) const

{

  NS_LOG_FUNCTION (this << device->GetIfIndex());

  int32_t interface = 0;

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

       i != m_interfaces.end (); 

       i++, interface++)

    {

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

        {

          return interface;

        }

    }

  return -1;

}

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 ());

  uint32_t interface = 0;

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

  Ptr<Ipv4Interface> ipv4Interface;

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

       i != m_interfaces.end (); 

       i++)

    {

      ipv4Interface = *i;

      if (ipv4Interface->GetDevice () == device)

        {

          if (ipv4Interface->IsUp ())

            {

              m_rxTrace (packet, interface);

              break;

            }

          else

            {

              NS_LOG_LOGIC ("Dropping received packet-- interface is down");

              m_dropTrace (packet);

              return;

            }

        }

      interface++;

    }

  Ipv4Header ipHeader;

  if (Node::ChecksumEnabled ())

    {

      ipHeader.EnableChecksum ();

    }

  packet->RemoveHeader (ipHeader);

  if (!ipHeader.IsChecksumOk ()) 

    {

      m_dropTrace (packet);

      return;

    }

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

    {

      Ptr<Ipv4RawSocketImpl> socket = *i;

      socket->ForwardUp (packet, ipHeader, device);

    }

  m_routingProtocol->RouteInput (packet, ipHeader, device, 

    MakeCallback (&Ipv4L3Protocol::IpForward, this),

    MakeCallback (&Ipv4L3Protocol::IpMulticastForward, this),

    MakeCallback (&Ipv4L3Protocol::LocalDeliver, this),

    MakeCallback (&Ipv4L3Protocol::RouteInputError, this)

  );

}

Ptr<Icmpv4L4Protocol> 

Ipv4L3Protocol::GetIcmp (void) const

{

  Ptr<Ipv4L4Protocol> prot = GetProtocol (Icmpv4L4Protocol::GetStaticProtocolNumber ());

  if (prot != 0)

    {

      return prot->GetObject<Icmpv4L4Protocol> ();

    }

  else

    {

      return 0;

    }

}

bool

Ipv4L3Protocol::IsUnicast (Ipv4Address ad, Ipv4Mask interfaceMask) const

{

  return !ad.IsMulticast () && !ad.IsSubnetDirectedBroadcast (interfaceMask);

}

void 

Ipv4L3Protocol::Send (Ptr<Packet> packet, 

            Ipv4Address source, 

            Ipv4Address destination,

            uint8_t protocol,

            Ptr<Ipv4Route> route)

{

  NS_LOG_FUNCTION (this << packet << source << destination << uint32_t(protocol) << route);

  Ipv4Header ipHeader;

  bool mayFragment = true;

  uint8_t ttl = m_defaultTtl;

  SocketIpTtlTag tag;

  bool found = packet->RemovePacketTag (tag);

  if (found)

    {

      ttl = tag.GetTtl ();

    }

  // Handle a few cases:

  // 1) packet is destined to limited broadcast address

  // 2) packet is destined to a subnet-directed broadcast address

  // 3) packet is not broadcast, and is passed in with a route entry

  // 4) packet is not broadcast, and is passed in with a route entry but route->GetGateway is not set (e.g., on-demand)

  // 5) packet is not broadcast, and route is NULL (e.g., a raw socket call, or ICMP)

  // 1) packet is destined to limited broadcast address

  if (destination.IsBroadcast ()) 

    {

      NS_LOG_LOGIC ("Ipv4L3Protocol::Send case 1:  limited broadcast");

      ttl = 1;

      ipHeader = BuildHeader (source, destination, protocol, packet->GetSize (), ttl, mayFragment);

      uint32_t ifaceIndex = 0;

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

           ifaceIter != m_interfaces.end (); ifaceIter++, ifaceIndex++)

        {

          Ptr<Ipv4Interface> outInterface = *ifaceIter;

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

          NS_ASSERT (packetCopy->GetSize () <= outInterface->GetDevice()->GetMtu ());

          packetCopy->AddHeader (ipHeader);

          m_txTrace (packetCopy, ifaceIndex);

          outInterface->Send (packetCopy, destination);

        }

      return;

    }