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

//         Gustavo Carneiro <gjc@inescporto.pt>

#include "ns3/log.h"

#include "ns3/packet.h"

#include "ns3/node.h"

#include "ns3/ipv4-route.h"

#include "ipv4-static-routing.h"

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

NS_LOG_COMPONENT_DEFINE ("Ipv4StaticRouting");

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (Ipv4StaticRouting);

TypeId

Ipv4StaticRouting::GetTypeId (void)

{

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

    .SetParent<Ipv4RoutingProtocol> ()

    .AddConstructor<Ipv4StaticRouting> ()

    ;

  return tid;

}

Ipv4StaticRouting::Ipv4StaticRouting () 

{

  NS_LOG_FUNCTION_NOARGS ();

}

void 

Ipv4StaticRouting::AddNetworkRouteTo (Ipv4Address network, 

                                      Ipv4Mask networkMask, 

                                      Ipv4Address nextHop, 

{

  NS_LOG_FUNCTION_NOARGS ();

  Ipv4RoutingTableEntry *route = new Ipv4RoutingTableEntry ();

  *route = Ipv4RoutingTableEntry::CreateNetworkRouteTo (network,

                                            networkMask,

                                            nextHop,

                                            interface);

}

void 

Ipv4StaticRouting::AddNetworkRouteTo (Ipv4Address network, 

                                      Ipv4Mask networkMask, 

{

  NS_LOG_FUNCTION_NOARGS ();

  Ipv4RoutingTableEntry *route = new Ipv4RoutingTableEntry ();

  *route = Ipv4RoutingTableEntry::CreateNetworkRouteTo (network,

                                            networkMask,

                                            interface);

}

void 

Ipv4StaticRouting::SetDefaultRoute (Ipv4Address nextHop, 

{

  NS_LOG_FUNCTION_NOARGS ();

}

void 

Ipv4StaticRouting::AddMulticastRoute(Ipv4Address origin,

                                     Ipv4Address group,

                                     uint32_t inputInterface,

                                     std::vector<uint32_t> outputInterfaces)

{

  NS_LOG_FUNCTION_NOARGS ();

  Ipv4MulticastRoutingTableEntry *route = new Ipv4MulticastRoutingTableEntry ();

  *route = Ipv4MulticastRoutingTableEntry::CreateMulticastRoute (origin, group, 

    inputInterface, outputInterfaces);

  m_multicastRoutes.push_back (route);

}

// default multicast routes are stored as a network route

// these routes are _not_ consulted in the forwarding process-- only

// for originating packets

void 

Ipv4StaticRouting::SetDefaultMulticastRoute(uint32_t outputInterface)

{

  NS_LOG_FUNCTION_NOARGS ();

  Ipv4RoutingTableEntry *route = new Ipv4RoutingTableEntry ();

  Ipv4Address network = Ipv4Address ("224.0.0.0");

  Ipv4Mask networkMask = Ipv4Mask ("240.0.0.0");

  *route = Ipv4RoutingTableEntry::CreateNetworkRouteTo (network,

                                            networkMask,

                                            outputInterface);

}

uint32_t 

Ipv4StaticRouting::GetNMulticastRoutes (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_multicastRoutes.size ();

}

Ipv4MulticastRoutingTableEntry

Ipv4StaticRouting::GetMulticastRoute (uint32_t index) const

{

  NS_LOG_FUNCTION_NOARGS ();

  NS_ASSERT_MSG(index < m_multicastRoutes.size (),

    "Ipv4StaticRouting::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

Ipv4StaticRouting::RemoveMulticastRoute(Ipv4Address origin,

                                        Ipv4Address group,

                                        uint32_t inputInterface)

{

  NS_LOG_FUNCTION_NOARGS ();

  for (MulticastRoutesI i = m_multicastRoutes.begin (); 

       i != m_multicastRoutes.end (); 

       i++) 

    {

      Ipv4MulticastRoutingTableEntry *route = *i;

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

          group == route->GetGroup () &&

          inputInterface == route->GetInputInterface ())

        {

          delete *i;

          m_multicastRoutes.erase (i);

          return true;

        }

    }

  return false;

}

void 

Ipv4StaticRouting::RemoveMulticastRoute(uint32_t index)

{

  NS_LOG_FUNCTION_NOARGS ();

  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++;

    }

}

Ptr<Ipv4Route>

Ipv4StaticRouting::LookupStatic (Ipv4Address dest)

{

  NS_LOG_FUNCTION_NOARGS ();

  Ptr<Ipv4Route> rtentry = 0;

       i++) 

    {

        {

          rtentry = Create<Ipv4Route> ();

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

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

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

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

        }

    }

}

Ptr<Ipv4MulticastRoute>

Ipv4StaticRouting::LookupStatic (

  Ipv4Address origin, 

  Ipv4Address group,

  uint32_t    interface)

{

  NS_LOG_FUNCTION_NOARGS ();

  Ptr<Ipv4MulticastRoute> mrtentry = 0;

  for (MulticastRoutesI i = m_multicastRoutes.begin (); 

       i != m_multicastRoutes.end (); 

       i++) 

    {

      Ipv4MulticastRoutingTableEntry *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.  

//

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

        {

          // Skipping this case (SSM) for now

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

        }

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

        {

          if (interface == Ipv4::IF_ANY || 

              interface == route->GetInputInterface ())

            {

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

              mrtentry = Create<Ipv4MulticastRoute> ();

              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), Ipv4MulticastRoute::MAX_TTL - 1);

                    }

                }

              return mrtentry;

            }

        }

    }

  return mrtentry;

}

uint32_t 

Ipv4StaticRouting::GetNRoutes (void)

{

  NS_LOG_FUNCTION_NOARGS ();

}

Ipv4RoutingTableEntry

Ipv4StaticRouting::GetDefaultRoute ()

{

  NS_LOG_FUNCTION_NOARGS ();

    {

    }

  else

    {

      return Ipv4RoutingTableEntry ();

    }

}

Ipv4RoutingTableEntry 

Ipv4StaticRouting::GetRoute (uint32_t index)

{

  NS_LOG_FUNCTION_NOARGS ();

      uint32_t tmp = 0;

        {

          if (tmp  == index)

            {

            }

          tmp++;

        }

  uint32_t tmp = 0;

  for (NetworkRoutesI j = m_networkRoutes.begin (); 

       j != m_networkRoutes.end (); 

       j++) 

    {

      if (tmp == index)

        {

        }

      tmp++;

    }

  NS_ASSERT (false);

  // quiet compiler.

  return 0;

}

void 

Ipv4StaticRouting::RemoveRoute (uint32_t index)

{

  NS_LOG_FUNCTION_NOARGS ();

  uint32_t tmp = 0;

  for (NetworkRoutesI j = m_networkRoutes.begin (); 

       j != m_networkRoutes.end (); 

       j++) 

    {

      if (tmp == index)

        {

          m_networkRoutes.erase (j);

          return;

        }

      tmp++;

    }

  NS_ASSERT (false);

}

Ptr<Ipv4Route> 

Ipv4StaticRouting::RouteOutput (Ptr<Packet> p, const Ipv4Header &header, uint32_t oif, Socket::SocketErrno &sockerr)

{

  NS_LOG_FUNCTION (this << header << oif);

  Ipv4Address destination = header.GetDestination ();

  Ptr<Ipv4Route> rtentry = 0;

  // Multicast goes here

  if (destination.IsMulticast ())

    {

      // Note:  Multicast routes for outbound packets are stored in the

      // normal unicast table.  An implication of this is that it is not

      // possible to source multicast datagrams on multiple interfaces.

      // This is a well-known property of sockets implementation on 

      // many Unix variants.

      // So, we just log it and fall through to LookupStatic ()

      NS_LOG_LOGIC ("RouteOutput()::Multicast destination");

    }

  rtentry = LookupStatic (destination);

  if (rtentry)

    { 

      sockerr = Socket::ERROR_NOTERROR;

    }

  else

    { 

      sockerr = Socket::ERROR_NOROUTETOHOST;

    }

  return rtentry;

}

// XXX this method not robust enough to work outside of ListRouting context

// because it will not perform local delivery

bool 

Ipv4StaticRouting::RouteInput  (Ptr<const Packet> p, const Ipv4Header &ipHeader, Ptr<const NetDevice> idev,

                             UnicastForwardCallback ucb, MulticastForwardCallback mcb,

                             LocalDeliverCallback lcb, ErrorCallback ecb)

{

  NS_LOG_FUNCTION (this << p << ipHeader << ipHeader.GetSource () << ipHeader.GetDestination () << idev);

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

    {

      NS_LOG_LOGIC ("Multicast destination");

      Ptr<Ipv4MulticastRoute> mrtentry =  LookupStatic(ipHeader.GetSource (),

        ipHeader.GetDestination (), m_ipv4->GetInterfaceForDevice (idev));

      if (mrtentry)

        {

          NS_LOG_LOGIC ("Multicast route found");

          mcb (mrtentry, p, ipHeader); // multicast forwarding callback

          return true;

        }

      else

        {

          NS_LOG_LOGIC ("Multicast route not found");

          return false; // Let other routing protocols try to handle this

        }

    }

//

// This is a unicast packet.  Check to see if we have a route for it.

//

  NS_LOG_LOGIC ("Unicast destination");

  Ptr<Ipv4Route> rtentry = LookupStatic (ipHeader.GetDestination ());

  if (rtentry != 0)

    {

      NS_LOG_LOGIC ("Found unicast destination- calling unicast callback");

      ucb (rtentry, p, ipHeader);  // unicast forwarding callback

      return true;

    }

  else

    {

      NS_LOG_LOGIC ("Did not find unicast destination- returning false");

      return false; // Let other routing protocols try to handle this

    }

}

Ipv4StaticRouting::~Ipv4StaticRouting ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

void

Ipv4StaticRouting::DoDispose (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  for (NetworkRoutesI j = m_networkRoutes.begin (); 

       j != m_networkRoutes.end (); 

       j = m_networkRoutes.erase (j)) 

    {

    }

  for (MulticastRoutesI i = m_multicastRoutes.begin (); 

       i != m_multicastRoutes.end (); 

       i = m_multicastRoutes.erase (i)) 

    {

      delete (*i);

    }