// -*- 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 "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> ())

    .AddAttribute ("FragmentExpirationTimeout",

                   "When this timeout expires, the fragments will be cleared from the buffer.",

                   TimeValue (Seconds (30)),

                   MakeTimeAccessor (&Ipv4L3Protocol::m_fragmentExpirationTimeout),

                   MakeTimeChecker ())

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

    .AddTraceSource ("SendOutgoing", "A newly-generated packet by this node is about to be queued for transmission",

                     MakeTraceSourceAccessor (&Ipv4L3Protocol::m_sendOutgoingTrace))

    .AddTraceSource ("UnicastForward", "A unicast IPv4 packet was received by this node and is being forwarded to another node",

                     MakeTraceSourceAccessor (&Ipv4L3Protocol::m_unicastForwardTrace))

    .AddTraceSource ("LocalDeliver", "An IPv4 packet was received by/for this node, and it is being forward up the stack",

                     MakeTraceSourceAccessor (&Ipv4L3Protocol::m_localDeliverTrace))

  ;

  return tid;

}

Ipv4L3Protocol::Ipv4L3Protocol()

  : m_identification (0)

{

  NS_LOG_FUNCTION (this);

}

Ipv4L3Protocol::~Ipv4L3Protocol ()

{

  NS_LOG_FUNCTION (this);

}

void

Ipv4L3Protocol::Insert (Ptr<IpL4Protocol> protocol)

{

  m_protocols.push_back (protocol);

}

Ptr<IpL4Protocol>

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

  m_node = 0;

  m_routingProtocol = 0;

  for (MapFragments_t::iterator it = m_fragments.begin (); it != m_fragments.end (); it++)

    {

      it->second = 0;

    }

  for (MapFragmentsTimers_t::iterator it = m_fragmentsTimers.begin (); it != m_fragmentsTimers.end (); it++)

    {

      if (it->second.IsRunning ())

        {

          it->second.Cancel ();

        }

    }

  m_fragments.clear ();

  m_fragmentsTimers.clear ();

  Object::DoDispose ();

}

void

Ipv4L3Protocol::SetupLoopback (void)

{

  NS_LOG_FUNCTION (this);

  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)

{

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

  m_interfaces.push_back (interface);

  return index;

}

Ptr<Ipv4Interface>

Ipv4L3Protocol::GetInterface (uint32_t index) const

{

  if (index < m_interfaces.size ())

    {

      return m_interfaces[index];

    }

  return 0;

}

uint32_t 

Ipv4L3Protocol::GetNInterfaces (void) const

{

  return m_interfaces.size ();

}

int32_t 

Ipv4L3Protocol::GetInterfaceForAddress (

  Ipv4Address address) const

{

  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

{

  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

{

  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;

}

bool

Ipv4L3Protocol::IsDestinationAddress (Ipv4Address address, uint32_t iif) const

{

  // First check the incoming interface for a unicast address match

  for (uint32_t i = 0; i < GetNAddresses (iif); i++)

    {

      Ipv4InterfaceAddress iaddr = GetAddress (iif, i);

      if (address == iaddr.GetLocal ())

        {

          NS_LOG_LOGIC ("For me (destination " << address << " match)");

          return true;

        }

      if (address == iaddr.GetBroadcast ())

        {

          NS_LOG_LOGIC ("For me (interface broadcast address)");

          return true;

        }

    }

  if (address.IsMulticast ())

    {

#ifdef NOTYET

      if (MulticastCheckGroup (iif, address ))

#endif

      if (true)

        {

          NS_LOG_LOGIC ("For me (Ipv4Addr multicast address");

          return true;

        }

    }

  if (address.IsBroadcast ())

    {

      NS_LOG_LOGIC ("For me (Ipv4Addr broadcast address)");

      return true;

    }

  if (GetWeakEsModel ())  // Check other interfaces

    { 

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

        {

          if (j == uint32_t (iif)) continue;

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

            {

              Ipv4InterfaceAddress iaddr = GetAddress (j, i);

              if (address == iaddr.GetLocal ())

                {

                  NS_LOG_LOGIC ("For me (destination " << address << " match) on another interface");

                  return true;

                }

              //  This is a small corner case:  match another interface's broadcast address

              if (address == iaddr.GetBroadcast ())

                {

                  NS_LOG_LOGIC ("For me (interface broadcast address on another interface)");

                  return true;

                }

            }

        }

    }

  return false;

}

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 << to << packetType);

  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++, interface++)

    {

      ipv4Interface = *i;

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

        {

          if (ipv4Interface->IsUp ())

            {

              m_rxTrace (packet, m_node->GetObject<Ipv4> (), interface);

              break;

            }

          else

            {

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

              Ipv4Header ipHeader;

              packet->RemoveHeader (ipHeader);

              m_dropTrace (ipHeader, packet, DROP_INTERFACE_DOWN, m_node->GetObject<Ipv4> (), interface);

              return;

            }

        }

    }

  Ipv4Header ipHeader;

  if (Node::ChecksumEnabled ())

    {

      ipHeader.EnableChecksum ();

    }

  packet->RemoveHeader (ipHeader);

  // Trim any residual frame padding from underlying devices

  if (ipHeader.GetPayloadSize () < packet->GetSize ())

    {

      packet->RemoveAtEnd (packet->GetSize () - ipHeader.GetPayloadSize ());