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

/*

 * Copyright (c) 2004 Francisco J. Ros 

 * Copyright (c) 2007 INESC Porto

 *

 * 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

 *

 * Authors: Francisco J. Ros  <fjrm@dif.um.es>

 *          Gustavo J. A. M. Carneiro <gjc@inescporto.pt>

 */

///

/// \file	OLSR.cc

/// \brief	Implementation of OLSR agent and related classes.

///

/// This is the main file of this software because %OLSR's behaviour is

/// implemented here.

///

#define NS_LOG_APPEND_CONTEXT                                   \

  if (GetObject<Node> ()) { std::clog << "[node " << GetObject<Node> ()->GetId () << "] "; }

#include "olsr-routing-protocol.h"

#include "ns3/socket-factory.h"

#include "ns3/udp-socket-factory.h"

#include "ns3/simulator.h"

#include "ns3/log.h"

#include "ns3/names.h"

#include "ns3/random-variable.h"

#include "ns3/inet-socket-address.h"

#include "ns3/ipv4-routing-protocol.h"

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

#include "ns3/ipv4-route.h"

#include "ns3/boolean.h"

#include "ns3/uinteger.h"

#include "ns3/enum.h"

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

#include "ns3/ipv4-header.h"

/********** Useful macros **********/

///

/// \brief Gets the delay between a given time and the current time.

///

/// If given time is previous to the current one, then this macro returns

/// a number close to 0. This is used for scheduling events at a certain moment.

///

#define DELAY(time) (((time) < (Simulator::Now ())) ? Seconds (0.000001) : \

                     (time - Simulator::Now () + Seconds (0.000001)))

///

/// \brief Period at which a node must cite every link and every neighbor.

///

/// We only use this value in order to define OLSR_NEIGHB_HOLD_TIME.

///

/********** Holding times **********/

/// Neighbor holding time.

/// Top holding time.

/// Dup holding time.

/// MID holding time.

/// HNA holding time.

#define OLSR_HNA_HOLD_TIME      Time (3 * m_hnaInterval)

/********** Link types **********/

/// Unspecified link type.

/// Asymmetric link type.

/// Symmetric link type.

/// Lost link type.

/********** Neighbor types **********/

/// Not neighbor type.

/// Symmetric neighbor type.

/// Asymmetric neighbor type.

/********** Willingness **********/

/// Willingness for forwarding packets from other nodes: never.

/// Willingness for forwarding packets from other nodes: low.

/// Willingness for forwarding packets from other nodes: medium.

/// Willingness for forwarding packets from other nodes: high.

/// Willingness for forwarding packets from other nodes: always.

/********** Miscellaneous constants **********/

/// Maximum allowed jitter.

/// Maximum allowed sequence number.

/// Random number between [0-OLSR_MAXJITTER] used to jitter OLSR packet transmission.

#define JITTER (Seconds (UniformVariable().GetValue (0, OLSR_MAXJITTER)))

#define OLSR_PORT_NUMBER 698

/// Maximum number of messages per packet.

/// Maximum number of hellos per message (4 possible link types * 3 possible nb types).

/// Maximum number of addresses advertised on a message.

namespace ns3 {

namespace olsr {

NS_LOG_COMPONENT_DEFINE ("OlsrRoutingProtocol");

/********** OLSR class **********/

NS_OBJECT_ENSURE_REGISTERED (RoutingProtocol);

TypeId 

RoutingProtocol::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::olsr::RoutingProtocol")

    .SetParent<Ipv4RoutingProtocol> ()

    .AddConstructor<RoutingProtocol> ()

    .AddAttribute ("HelloInterval", "HELLO messages emission interval.",

                   TimeValue (Seconds (2)),

                   MakeTimeAccessor (&RoutingProtocol::m_helloInterval),

                   MakeTimeChecker ())

    .AddAttribute ("TcInterval", "TC messages emission interval.",

                   TimeValue (Seconds (5)),

                   MakeTimeAccessor (&RoutingProtocol::m_tcInterval),

                   MakeTimeChecker ())

    .AddAttribute ("MidInterval", "MID messages emission interval.  Normally it is equal to TcInterval.",

                   TimeValue (Seconds (5)),

                   MakeTimeAccessor (&RoutingProtocol::m_midInterval),

                   MakeTimeChecker ())

    .AddAttribute ("HnaInterval", "HNA messages emission interval.  Normally it is equal to TcInterval.",

                   TimeValue (Seconds (5)),

                   MakeTimeAccessor (&RoutingProtocol::m_hnaInterval),

                   MakeTimeChecker ())

    .AddAttribute ("Willingness", "Willingness of a node to carry and forward traffic for other nodes.",

                   EnumValue (OLSR_WILL_DEFAULT),

                   MakeEnumAccessor (&RoutingProtocol::m_willingness),

                   MakeEnumChecker (OLSR_WILL_NEVER, "never",

                                    OLSR_WILL_LOW, "low",

                                    OLSR_WILL_DEFAULT, "default",

                                    OLSR_WILL_HIGH, "high",

                                    OLSR_WILL_ALWAYS, "always"))

    .AddTraceSource ("Rx", "Receive OLSR packet.",

                     MakeTraceSourceAccessor (&RoutingProtocol::m_rxPacketTrace))

    .AddTraceSource ("Tx", "Send OLSR packet.",

                     MakeTraceSourceAccessor (&RoutingProtocol::m_txPacketTrace))

    .AddTraceSource ("RoutingTableChanged", "The OLSR routing table has changed.",

  return tid;

}

RoutingProtocol::RoutingProtocol ()

  : m_routingTableAssociation (0),

    m_ipv4 (0),

    m_helloTimer (Timer::CANCEL_ON_DESTROY),

    m_tcTimer (Timer::CANCEL_ON_DESTROY),

    m_midTimer (Timer::CANCEL_ON_DESTROY),

    m_queuedMessagesTimer (Timer::CANCEL_ON_DESTROY)

{

  m_hnaRoutingTable = Create<Ipv4StaticRouting> ();

}

RoutingProtocol::~RoutingProtocol ()

void

RoutingProtocol::SetIpv4 (Ptr<Ipv4> ipv4)

{

  NS_ASSERT (ipv4 != 0);

  NS_ASSERT (m_ipv4 == 0);

  NS_LOG_DEBUG ("Created olsr::RoutingProtocol");

  m_helloTimer.SetFunction (&RoutingProtocol::HelloTimerExpire, this);

  m_tcTimer.SetFunction (&RoutingProtocol::TcTimerExpire, this);

  m_midTimer.SetFunction (&RoutingProtocol::MidTimerExpire, this);

  m_hnaTimer.SetFunction (&RoutingProtocol::HnaTimerExpire, this);

  m_queuedMessagesTimer.SetFunction (&RoutingProtocol::SendQueuedMessages, this);

  m_packetSequenceNumber = OLSR_MAX_SEQ_NUM;

  m_messageSequenceNumber = OLSR_MAX_SEQ_NUM;

  m_ansn = OLSR_MAX_SEQ_NUM;

  m_linkTupleTimerFirstTime = true;

  m_ipv4 = ipv4;

  m_hnaRoutingTable->SetIpv4 (ipv4);

}

void RoutingProtocol::DoDispose ()

{

  m_ipv4 = 0;

  m_hnaRoutingTable = 0;

  m_routingTableAssociation = 0;

  for (std::map< Ptr<Socket>, Ipv4InterfaceAddress >::iterator iter = m_socketAddresses.begin ();

       iter != m_socketAddresses.end (); iter++)

    {

      iter->first->Close ();

    }

  m_socketAddresses.clear ();

  Ipv4RoutingProtocol::DoDispose ();

}

void

RoutingProtocol::PrintRoutingTable (Ptr<OutputStreamWrapper> stream) const

{

  std::ostream* os = stream->GetStream ();

  *os << "Destination\t\tNextHop\t\tInterface\tDistance\n";

  for (std::map<Ipv4Address, RoutingTableEntry>::const_iterator iter = m_table.begin ();

    {

      *os << iter->first << "\t\t";

      *os << iter->second.nextAddr << "\t\t";

      if (Names::FindName (m_ipv4->GetNetDevice (iter->second.interface)) != "")

      *os << iter->second.distance << "\t";

      *os << "\n";

    }

}

void RoutingProtocol::DoStart ()

{

  if (m_mainAddress == Ipv4Address ())

    {

      Ipv4Address loopback ("127.0.0.1");

      for (uint32_t i = 0; i < m_ipv4->GetNInterfaces (); i++)

        {

          // Use primary address, if multiple

          Ipv4Address addr = m_ipv4->GetAddress (i, 0).GetLocal ();

          if (addr != loopback)

            {

              m_mainAddress = addr;

              break;

            }

        }

      NS_ASSERT (m_mainAddress != Ipv4Address ());

    }

  NS_LOG_DEBUG ("Starting OLSR on node " << m_mainAddress);

  Ipv4Address loopback ("127.0.0.1");

  bool canRunOlsr = false;

  for (uint32_t i = 0; i < m_ipv4->GetNInterfaces (); i++)

    {

      Ipv4Address addr = m_ipv4->GetAddress (i, 0).GetLocal ();

      if (addr == loopback)

        continue;

      if (addr != m_mainAddress)

        {

          // Create never expiring interface association tuple entries for our

          // own network interfaces, so that GetMainAddress () works to

          // translate the node's own interface addresses into the main address.

          IfaceAssocTuple tuple;

          tuple.ifaceAddr = addr;

          tuple.mainAddr = m_mainAddress;

          AddIfaceAssocTuple (tuple);

          NS_ASSERT (GetMainAddress (addr) == m_mainAddress);

        }

      if(m_interfaceExclusions.find (i) != m_interfaceExclusions.end ())

        continue;

      // Create a socket to listen only on this interface

      Ptr<Socket> socket = Socket::CreateSocket (GetObject<Node> (), 

                                                 UdpSocketFactory::GetTypeId());

      socket->SetAllowBroadcast (true);

      InetSocketAddress inetAddr (m_ipv4->GetAddress (i, 0).GetLocal (), OLSR_PORT_NUMBER);

      socket->SetRecvCallback (MakeCallback (&RoutingProtocol::RecvOlsr,  this));

      if (socket->Bind (inetAddr))

        {

          NS_FATAL_ERROR ("Failed to bind() OLSR socket");

        }

      socket->BindToNetDevice (m_ipv4->GetNetDevice (i));

      m_socketAddresses[socket] = m_ipv4->GetAddress (i, 0);

      canRunOlsr = true;

    }

  if(canRunOlsr)

      HelloTimerExpire ();

      TcTimerExpire ();

      MidTimerExpire ();

      NS_LOG_DEBUG ("OLSR on node " << m_mainAddress << " started");

}

void RoutingProtocol::SetMainInterface (uint32_t interface)

{

  m_mainAddress = m_ipv4->GetAddress (interface, 0).GetLocal ();

}

void RoutingProtocol::SetInterfaceExclusions (std::set<uint32_t> exceptions)

{

  m_interfaceExclusions = exceptions;

}

//

// \brief Processes an incoming %OLSR packet following RFC 3626 specification.

void

RoutingProtocol::RecvOlsr (Ptr<Socket> socket)

{

  Ptr<Packet> receivedPacket;

  Address sourceAddress;

  receivedPacket = socket->RecvFrom (sourceAddress);

  InetSocketAddress inetSourceAddr = InetSocketAddress::ConvertFrom (sourceAddress);

  Ipv4Address senderIfaceAddr = inetSourceAddr.GetIpv4 ();

  Ipv4Address receiverIfaceAddr = m_socketAddresses[socket].GetLocal ();

  NS_ASSERT (receiverIfaceAddr != Ipv4Address ());

  NS_LOG_DEBUG ("OLSR node " << m_mainAddress << " received a OLSR packet from "

  // All routing messages are sent from and to port RT_PORT,

  // so we check it.

  NS_ASSERT (inetSourceAddr.GetPort () == OLSR_PORT_NUMBER);

  Ptr<Packet> packet = receivedPacket;

  olsr::PacketHeader olsrPacketHeader;

  packet->RemoveHeader (olsrPacketHeader);

  NS_ASSERT (olsrPacketHeader.GetPacketLength () >= olsrPacketHeader.GetSerializedSize ());

  uint32_t sizeLeft = olsrPacketHeader.GetPacketLength () - olsrPacketHeader.GetSerializedSize ();

  MessageList messages;

  while (sizeLeft)

    {

      MessageHeader messageHeader;

      if (packet->RemoveHeader (messageHeader) == 0)

        NS_ASSERT (false);

      sizeLeft -= messageHeader.GetSerializedSize ();

      NS_LOG_DEBUG ("Olsr Msg received with type "

                << std::dec << int (messageHeader.GetMessageType ())

                << " TTL=" << int (messageHeader.GetTimeToLive ())

                << " origAddr=" << messageHeader.GetOriginatorAddress ());

      messages.push_back (messageHeader);

    }

  m_rxPacketTrace (olsrPacketHeader, messages);

  for (MessageList::const_iterator messageIter = messages.begin ();

       messageIter != messages.end (); messageIter++)

    {

      const MessageHeader &messageHeader = *messageIter;

      // If ttl is less than or equal to zero, or

      // the receiver is the same as the originator,

      // the message must be silently dropped

      if (messageHeader.GetTimeToLive () == 0

          || messageHeader.GetOriginatorAddress () == m_mainAddress)

        {

          packet->RemoveAtStart (messageHeader.GetSerializedSize ()

                                 - messageHeader.GetSerializedSize ());

          continue;

        }

      // If the message has been processed it must not be processed again

      bool do_forwarding = true;

      DuplicateTuple *duplicated = m_state.FindDuplicateTuple

      // Get main address of the peer, which may be different from the packet source address

//       const IfaceAssocTuple *ifaceAssoc = m_state.FindIfaceAssocTuple (inetSourceAddr.GetIpv4 ());

//       Ipv4Address peerMainAddress;

//       if (ifaceAssoc != NULL)

//         {

//           peerMainAddress = ifaceAssoc->mainAddr;

//         }

//       else

//         {

//           peerMainAddress = inetSourceAddr.GetIpv4 () ;

//         }

      if (duplicated == NULL)

        {

          switch (messageHeader.GetMessageType ())

            {

            case olsr::MessageHeader::HELLO_MESSAGE:

              NS_LOG_DEBUG (Simulator::Now ().GetSeconds ()

                            << "s OLSR node " << m_mainAddress

                            << " received HELLO message of size " << messageHeader.GetSerializedSize ());

              ProcessHello (messageHeader, receiverIfaceAddr, senderIfaceAddr);

              break;

            case olsr::MessageHeader::TC_MESSAGE:

              NS_LOG_DEBUG (Simulator::Now ().GetSeconds ()

                            << "s OLSR node " << m_mainAddress

                            << " received TC message of size " << messageHeader.GetSerializedSize ());

              ProcessTc (messageHeader, senderIfaceAddr);

              break;

            case olsr::MessageHeader::MID_MESSAGE:

              NS_LOG_DEBUG (Simulator::Now ().GetSeconds ()

                            << "s OLSR node " << m_mainAddress

                            <<  " received MID message of size " << messageHeader.GetSerializedSize ());

              ProcessMid (messageHeader, senderIfaceAddr);

              break;

            case olsr::MessageHeader::HNA_MESSAGE:

              NS_LOG_DEBUG (Simulator::Now ().GetSeconds ()

                            << "s OLSR node " << m_mainAddress

                            <<  " received HNA message of size " << messageHeader.GetSerializedSize ());

              ProcessHna (messageHeader, senderIfaceAddr);

              break; 

            default:

              NS_LOG_DEBUG ("OLSR message type " <<

            }

        }

      else

        {

          NS_LOG_DEBUG ("OLSR message is duplicated, not reading it.");

          // If the message has been considered for forwarding, it should

          // not be retransmitted again

          for (std::vector<Ipv4Address>::const_iterator it = duplicated->ifaceList.begin ();

               it != duplicated->ifaceList.end(); it++)

            {

              if (*it == receiverIfaceAddr)

                {

                  do_forwarding = false;

                  break;

                }

            }

        }

      if (do_forwarding)