/// Association

struct Association

{

  Ipv4Address networkAddr;

  Ipv4Mask netmask;

};

static inline bool

operator == (const Association &a, const Association &b)

{

  return (a.networkAddr == b.networkAddr

          && a.netmask == b.netmask);

}

static inline std::ostream&

operator << (std::ostream &os, const Association &tuple)

{

  os << "Association(networkAddr=" << tuple.networkAddr

     << ", netmask=" << tuple.netmask

     << ")";

  return os;

}

/// An Association Tuple

struct AssociationTuple

{

  /// Main address of the gateway.

  Ipv4Address gatewayAddr;

  /// Network Address of network reachable through gatewayAddr

  Ipv4Address networkAddr;

  /// Netmask of network reachable through gatewayAddr

  Ipv4Mask netmask;

  /// Time at which this tuple expires and must be removed

  Time expirationTime;

};

static inline bool

operator == (const AssociationTuple &a, const AssociationTuple &b)

{

  return (a.gatewayAddr == b.gatewayAddr

          && a.networkAddr == b.networkAddr

          && a.netmask == b.netmask);

}

static inline std::ostream&

operator << (std::ostream &os, const AssociationTuple &tuple)

{

  os << "AssociationTuple(gatewayAddr=" << tuple.gatewayAddr

     << ", networkAddr=" << tuple.networkAddr

     << ", netmask=" << tuple.netmask

     << ", expirationTime=" << tuple.expirationTime

     << ")";

  return os;

}

typedef std::vector<AssociationTuple>		AssociationSet; ///< Association Set type.

typedef std::vector<Association>		Associations; ///< Association Set type.

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

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

                   TimeValue (Seconds (5)),

                   MakeTimeAccessor (&RoutingProtocol::m_hnaInterval),

                   MakeTimeChecker ())

    m_hnaTimer (Timer::CANCEL_ON_DESTROY),    

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

  m_hnaRoutingTable->SetIpv4 (ipv4);

  m_hnaRoutingTable = 0;

  bool canRunOlsr = false;

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

        continue;

      canRunOlsr = true;

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

{

  m_interfaceExclusions = exceptions;

}

            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; 

  // 5. For each tuple in the association set,

  //    If there is no entry in the routing table with:

  //        R_dest_addr     == A_network_addr/A_netmask

  //   then a new routing entry is created.

  const AssociationSet &associationSet = m_state.GetAssociationSet ();

  for (AssociationSet::const_iterator it = associationSet.begin ();

       it != associationSet.end (); it++)

    {

      AssociationTuple const &tuple = *it;

      RoutingTableEntry gatewayEntry;

      bool gatewayEntryExists = Lookup (tuple.gatewayAddr, gatewayEntry);

      bool addRoute = false;

      uint32_t routeIndex = 0;

      for (routeIndex = 0; routeIndex < m_hnaRoutingTable->GetNRoutes (); routeIndex++)

        {

          Ipv4RoutingTableEntry route = m_hnaRoutingTable->GetRoute (routeIndex);

          if (route.GetDestNetwork () == tuple.networkAddr &&

              route.GetDestNetworkMask () == tuple.netmask)

            {

              break;

            }

        }

      if (routeIndex == m_hnaRoutingTable->GetNRoutes ())

        {

          addRoute = true;

        }

      else if(gatewayEntryExists && m_hnaRoutingTable->GetMetric (routeIndex) > gatewayEntry.distance)

        {

          m_hnaRoutingTable->RemoveRoute(routeIndex);

          addRoute = true;

        }

      if(addRoute && gatewayEntryExists)

        {

          m_hnaRoutingTable->AddNetworkRouteTo (tuple.networkAddr,

                                                tuple.netmask,

                                                gatewayEntry.nextAddr,

                                                gatewayEntry.interface,

                                                gatewayEntry.distance);

        }

    }

///

/// \brief Processes a HNA message following RFC 3626 specification.

///

/// The Host Network Association Set is updated (if needed) with the information

/// of the received HNA message.

///

/// \param msg the %OLSR message which contains the HNA message.

/// \param sender_iface the address of the interface where the message was sent from.

///

void

RoutingProtocol::ProcessHna (const olsr::MessageHeader &msg,

                       const Ipv4Address &senderIface)

{

  const olsr::MessageHeader::Hna &hna = msg.GetHna ();

  Time now = Simulator::Now ();

  // 1. If the sender interface of this message is not in the symmetric

  // 1-hop neighborhood of this node, the message MUST be discarded.

  const LinkTuple *link_tuple = m_state.FindSymLinkTuple (senderIface, now);

  if (link_tuple == NULL)

    return;

  // 2. Otherwise, for each (network address, netmask) pair in the

  // message:

  for (std::vector<olsr::MessageHeader::Hna::Association>::const_iterator it = hna.associations.begin();

       it != hna.associations.end() ; it++)

    {

      AssociationTuple *tuple = m_state.FindAssociationTuple(msg.GetOriginatorAddress(),it->address,it->mask);

      // 2.1  if an entry in the association set already exists, where:

      //          A_gateway_addr == originator address

      //          A_network_addr == network address

      //          A_netmask      == netmask

      //      then the holding time for that tuple MUST be set to:

      //          A_time         =  current time + validity time

      if(tuple != NULL)

        {

          tuple->expirationTime = now + msg.GetVTime ();

        }

      // 2.2 otherwise, a new tuple MUST be recorded with:

      //          A_gateway_addr =  originator address

      //          A_network_addr =  network address

      //          A_netmask      =  netmask

      //          A_time         =  current time + validity time

      else

        {

          const AssociationTuple &assocTuple = (AssociationTuple){msg.GetOriginatorAddress(),it->address,it->mask,now + msg.GetVTime ()};

          AddAssociationTuple (assocTuple);

          //Schedule Association Tuple deletion

          Simulator::Schedule (DELAY (assocTuple.expirationTime),

                               &RoutingProtocol::AssociationTupleTimerExpire, this,

                               assocTuple.gatewayAddr,assocTuple.networkAddr,assocTuple.netmask);

        }

    }

}

/// \brief Creates a new %OLSR HNA message which is buffered for being sent later on.

///

void

RoutingProtocol::SendHna ()

{

  olsr::MessageHeader msg;

  msg.SetVTime (OLSR_HNA_HOLD_TIME);

  msg.SetOriginatorAddress (m_mainAddress);

  msg.SetTimeToLive (255);

  msg.SetHopCount (0);

  msg.SetMessageSequenceNumber (GetMessageSequenceNumber ());

  olsr::MessageHeader::Hna &hna = msg.GetHna ();

  std::vector<olsr::MessageHeader::Hna::Association>

    &associations = hna.associations;

  if (m_routingTableAssociation != 0)

    {

      // Add (NetworkAddr, Netmask) entries from Associated Routing Table to HNA message.

      for (uint32_t i = 0; i < m_routingTableAssociation->GetNRoutes (); i++)

        {

          Ipv4RoutingTableEntry route = m_routingTableAssociation->GetRoute (i);

          if (m_interfaceExclusions.find (route.GetInterface ()) != m_interfaceExclusions.end ())

            {

              associations.push_back((olsr::MessageHeader::Hna::Association){route.GetDestNetwork (), route.GetDestNetworkMask ()});

            }

        }

    }

  int size = associations.size ();

  // Add (NetworkAddr, Netmask) entries specified using AddHostNetworkAssociation () to HNA message.

  for (Associations::const_iterator it = m_state.GetAssociations ().begin ();

        it != m_state.GetAssociations ().end (); it++)

    {

      // Check if the entry has already been added from the Associated Routing Table

      std::vector<olsr::MessageHeader::Hna::Association>::const_iterator ci = associations.begin ();

      bool found = false;

      for (int i = 0; i < size; i++)

        {

          if (it->networkAddr == ci->address && it->netmask == ci->mask)

            {

              found = true;

              break;

            }

          ci++;

        }

      if(!found)

        associations.push_back((olsr::MessageHeader::Hna::Association){it->networkAddr,it->netmask});

    }

  if(associations.size () == 0)

    return;

  QueueMessage (msg, JITTER);

}

///

/// \brief Injects a (networkAddr, netmask) tuple for which the node

///        can generate an HNA message for

///

void

RoutingProtocol::AddHostNetworkAssociation (Ipv4Address networkAddr, Ipv4Mask netmask)

{

  m_state.InsertAssociation ((Association) {networkAddr, netmask});

}

///

/// \brief Adds an Ipv4StaticRouting protocol Association

///        can generate an HNA message for

///

void

RoutingProtocol::AddRoutingTableAssociation (Ptr<Ipv4StaticRouting> routingTable)

{

  m_routingTableAssociation = routingTable;

}

///

///

/// \brief Adds a host network association tuple to the Association Set.

///

/// \param tuple the host network association tuple to be added.

///

void

RoutingProtocol::AddAssociationTuple (const AssociationTuple &tuple)

{

  m_state.InsertAssociationTuple (tuple);

}

///

/// \brief Removes a host network association tuple from the Association Set.

///

/// \param tuple the host network association tuple to be removed.

///

void

RoutingProtocol::RemoveAssociationTuple (const AssociationTuple &tuple)

{

  m_state.EraseAssociationTuple (tuple);

}

/// \brief Sends an HNA message (if the node implements support for non-OLSR interfaces).

/// \warning Currently it does nothing because there is no support for mixed interfaces.

/// \param e The event which has expired.

///

void

RoutingProtocol::HnaTimerExpire ()

{

  SendHna ();

  m_hnaTimer.Schedule (m_hnaInterval);

}

/// \brief Removes tuple_ if expired. Else timer is rescheduled to expire at tuple_->time().

/// \warning Actually this is never invoked because there is no support for mixed interfaces.

/// \param e The event which has expired.

///

void

RoutingProtocol::AssociationTupleTimerExpire (Ipv4Address gatewayAddr, Ipv4Address networkAddr, Ipv4Mask netmask)

{

  AssociationTuple *tuple = m_state.FindAssociationTuple (gatewayAddr, networkAddr, netmask);

  if (tuple == NULL)

    {

      return;

    }

  if (tuple->expirationTime < Simulator::Now ())

    {

      RemoveAssociationTuple (*tuple);

    }

  else

    {

      m_events.Track (Simulator::Schedule (DELAY (tuple->expirationTime),

                                           &RoutingProtocol::AssociationTupleTimerExpire,

                                           this, gatewayAddr, networkAddr, netmask));

    }

}

  bool found = false;

      rtentry = m_hnaRoutingTable->RouteOutput (p, header, oif, sockerr);

      NS_LOG_DEBUG ("Found route to " << rtentry->GetDestination () << " via nh " << rtentry->GetGateway () << " with source addr " << rtentry->GetSource () << " and output dev " << rtentry->GetOutputDevice());

      if (rtentry)

        found = true;

    }

  if (!found)

    {

      if(m_hnaRoutingTable->RouteInput (p, header, idev, ucb, mcb, lcb, ecb))

        {

          return true;

        }

      else

        {

          }

          NS_LOG_DEBUG ("** Routing table dump end.");

#endif // NS3_LOG_ENABLE

          return false;

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

private:

  std::set<uint32_t> m_interfaceExclusions;

  Ptr<Ipv4StaticRouting> m_routingTableAssociation;

public:

  std::set<uint32_t> GetInterfaceExclusions () const

    {

      return m_interfaceExclusions;

    }

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

  Ptr<Ipv4StaticRouting> m_hnaRoutingTable;

  /// HNA messages' emission interval.

  Time m_hnaInterval;

  Timer m_hnaTimer;

  void HnaTimerExpire ();

  void AssociationTupleTimerExpire (Ipv4Address gatewayAddr, Ipv4Address networkAddr, Ipv4Mask netmask);

  void SendHna ();

  void AddAssociationTuple (const AssociationTuple &tuple);

  void RemoveAssociationTuple (const AssociationTuple &tuple);

  void ProcessHna (const olsr::MessageHeader &msg,

                   const Ipv4Address &senderIface);

  /// Inject Association to be sent in HNA message

  void AddHostNetworkAssociation (Ipv4Address networkAddr, Ipv4Mask netmask);

  /// Inject Associations from an Ipv4StaticRouting instance

  void AddRoutingTableAssociation (Ptr<Ipv4StaticRouting> routingTable);

/********** Host-Network Association Set Manipulation **********/

AssociationTuple*

OlsrState::FindAssociationTuple (const Ipv4Address &gatewayAddr, const Ipv4Address &networkAddr, const Ipv4Mask &netmask)

{

  for (AssociationSet::iterator it = m_associationSet.begin ();

	it != m_associationSet.end (); it++)

    {

      if (it->gatewayAddr == gatewayAddr and it->networkAddr == networkAddr and it->netmask == netmask)

        {

          return &(*it);

        }

    }

   return NULL;

}

void

OlsrState::EraseAssociationTuple (const AssociationTuple &tuple)

{

  for (AssociationSet::iterator it = m_associationSet.begin ();

       it != m_associationSet.end (); it++)

    {

      if (*it == tuple)

        {

          m_associationSet.erase (it);

          break;

        }

    }

}

void

OlsrState::InsertAssociationTuple (const AssociationTuple &tuple)

{

  m_associationSet.push_back (tuple);

}

void

OlsrState::EraseAssociation (const Association &tuple)

{

  for (Associations::iterator it = m_associations.begin ();

       it != m_associations.end (); it++)

    {

      if (*it == tuple)

        {

          m_associations.erase (it);

          break;

        }

    }

}

void

OlsrState::InsertAssociation (const Association &tuple)

{

  m_associations.push_back(tuple);

}

  AssociationSet m_associationSet;	///< Association Set (RFC 3626, section 12.2)

  Associations m_associations;	///< The Host Network Associations of the node

  // Host-Network Association

  const AssociationSet & GetAssociationSet () const  // Associations known to the node

  {

    return m_associationSet;

  }

  const Associations & GetAssociations () const  // Set of associations that the node has

  {

    return m_associations;

  }

  AssociationTuple* FindAssociationTuple (const Ipv4Address &gatewayAddr,\

					  const Ipv4Address &networkAddr,\

					  const Ipv4Mask &netmask);

  void EraseAssociationTuple (const AssociationTuple &tuple);

  void InsertAssociationTuple (const AssociationTuple &tuple);

  void EraseAssociation (const Association &tuple);

  void InsertAssociation (const Association &tuple);