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

/// HNA holding time.

#define OLSR_HNA_HOLD_TIME  (Scalar (3) * m_hnaInterval)

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

  HnaTimerExpire ();

            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 entry1, entry2;

      bool have_entry1 = Lookup (tuple.networkAddr.CombineMask (tuple.netmask), entry1);

      bool have_entry2 = Lookup (tuple.gatewayAddr, entry2);

      bool to_add = false;

      if (!have_entry1)

        {

          to_add = true;

        }

      else if(have_entry2 && entry1.distance > entry2.distance)

        {

           RemoveEntry(tuple.networkAddr.CombineMask (tuple.netmask));

           to_add = true;           

        }

      if(to_add == true)

        {

          AddEntry (tuple.networkAddr.CombineMask (tuple.netmask),

                    entry2.nextAddr,

                    entry2.interface,

                    entry2.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;

  // Pack all host-network associations into the packet's associations vector

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

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

    {

      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::InjectRoute (Ipv4Address networkAddr, Ipv4Mask netmask)

{

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

}

///

///

/// \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));

    }

}

///

  /// 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 Route to be sent in HNA message

  void InjectRoute (Ipv4Address networkAddr, Ipv4Mask netmask);

/********** 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::EraseHostNetAssociation (const Association &tuple)

{

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

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

    {

      if (*it == tuple)

        {

          m_hostNetAssocSet.erase (it);

          break;

        }

    }

}

void

OlsrState::InsertHostNetAssociation (const Association &tuple)

{

  m_hostNetAssocSet.push_back(tuple);

}

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

  Associations m_hostNetAssocSet;	///< The set of associations a node has

  // Host-Network Association

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

  {

    return m_associationSet;

  }

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

  {

    return m_hostNetAssocSet;

  }

  AssociationTuple* FindAssociationTuple (const Ipv4Address &gatewayAddr,\

					  const Ipv4Address &networkAddr,\

					  const Ipv4Mask &netmask);

  void EraseAssociationTuple (const AssociationTuple &tuple);

  void InsertAssociationTuple (const AssociationTuple &tuple);

  void EraseHostNetAssociation (const Association &tuple);

  void InsertHostNetAssociation (const Association &tuple);