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

/*

 *

 * 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

 *

 */

// 

// This script, adapted from examples/wireless/wifi-simple-adhoc illustrates

// the use of OLSR HNA.

// 

// Network Topology:

//

//             |------ OLSR ------|   |---- non-OLSR ----|

//           A ))))            (((( B ------------------- C

//           10.1.1.1     10.1.1.2   172.16.1.2     172.16.1.1

//

// Node A needs to send a UDP packet to node C. This can be done only after

// A receives an HNA message from B, in which B announces 172.16.1.0/24

// as an associated network.

//

// If no HNA message is generated by B, a will not be able to form a route to C.

// This can be verified as follows:

//

// ./waf --run olsr-hna

//

// There are two ways to make a node to generate HNA messages.

//

// One way is to use olsr::RoutingProtocol::SetRoutingTableAssociation ()

// to use which you may run:

//

// ./waf --run "olsr-hna --assocMethod1=1"

//

// The other way is to use olsr::RoutingProtocol::AddHostNetworkAssociation ()

// to use which you may run:

//

// ./waf --run "olsr-hna --assocMethod2=1"

//

#include "ns3/core-module.h"

#include "ns3/common-module.h"

#include "ns3/node-module.h"

#include "ns3/helper-module.h"

#include "ns3/mobility-module.h"

#include "ns3/contrib-module.h"

#include "ns3/wifi-module.h"

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

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

#include <iostream>

#include <fstream>

#include <vector>

#include <string>

NS_LOG_COMPONENT_DEFINE ("OlsrHna");

using namespace ns3;

void ReceivePacket (Ptr<Socket> socket)

{

  NS_LOG_UNCOND ("Received one packet!");

}

static void GenerateTraffic (Ptr<Socket> socket, uint32_t pktSize, 

                             uint32_t pktCount, Time pktInterval )

{

  if (pktCount > 0)

    {

      socket->Send (Create<Packet> (pktSize));

      Simulator::Schedule (pktInterval, &GenerateTraffic, 

                                      socket, pktSize,pktCount-1, pktInterval);

    }

  else

    {

      socket->Close ();

    }

}

int main (int argc, char *argv[])

{

  std::string phyMode ("wifib-1mbs");

  double rss = -80;  // -dBm

  uint32_t packetSize = 1000; // bytes

  uint32_t numPackets = 1;

  double interval = 1.0; // seconds

  bool verbose = false;

  bool assocMethod1 = false;

  bool assocMethod2 = false;

  CommandLine cmd;

  cmd.AddValue ("phyMode", "Wifi Phy mode", phyMode);

  cmd.AddValue ("rss", "received signal strength", rss);

  cmd.AddValue ("packetSize", "size of application packet sent", packetSize);

  cmd.AddValue ("numPackets", "number of packets generated", numPackets);

  cmd.AddValue ("interval", "interval (seconds) between packets", interval);

  cmd.AddValue ("verbose", "turn on all WifiNetDevice log components", verbose);

  cmd.AddValue ("assocMethod1", "Use SetRoutingTableAssociation () method", assocMethod1);

  cmd.AddValue ("assocMethod2", "Use AddHostNetworkAssociation () method", assocMethod2);

  cmd.Parse (argc, argv);

  // Convert to time object

  Time interPacketInterval = Seconds (interval);

  // disable fragmentation for frames below 2200 bytes

  Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("2200"));

  // turn off RTS/CTS for frames below 2200 bytes

  Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue ("2200"));

  // Fix non-unicast data rate to be the same as that of unicast

  Config::SetDefault ("ns3::WifiRemoteStationManager::NonUnicastMode", 

                      StringValue (phyMode));

  NodeContainer olsrNodes;

  olsrNodes.Create (2);

  NodeContainer csmaNodes;

  csmaNodes.Create (1);

  // The below set of helpers will help us to put together the wifi NICs we want

  WifiHelper wifi;

  if (verbose)

    {

      wifi.EnableLogComponents ();  // Turn on all Wifi logging

    }

  wifi.SetStandard (WIFI_PHY_STANDARD_80211b);

  YansWifiPhyHelper wifiPhy =  YansWifiPhyHelper::Default ();

  // This is one parameter that matters when using FixedRssLossModel

  // set it to zero; otherwise, gain will be added

  wifiPhy.Set ("RxGain", DoubleValue (0) ); 

  // ns-3 supports RadioTap and Prism tracing extensions for 802.11b

  wifiPhy.SetPcapDataLinkType (YansWifiPhyHelper::DLT_IEEE802_11_RADIO);

  YansWifiChannelHelper wifiChannel ;

  wifiChannel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");

  // The below FixedRssLossModel will cause the rss to be fixed regardless

  // of the distance between the two stations, and the transmit power

  wifiChannel.AddPropagationLoss ("ns3::FixedRssLossModel","Rss",DoubleValue(rss));

  wifiPhy.SetChannel (wifiChannel.Create ());

  // Add a non-QoS upper mac, and disable rate control

  NqosWifiMacHelper wifiMac = NqosWifiMacHelper::Default ();

  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager",

                                "DataMode",StringValue(phyMode),

                                   "ControlMode",StringValue(phyMode));

  // Set it to adhoc mode

  wifiMac.SetType ("ns3::AdhocWifiMac");

  NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, olsrNodes);

  CsmaHelper csma;

  csma.SetChannelAttribute ("DataRate", DataRateValue (DataRate (5000000)));

  csma.SetChannelAttribute ("Delay", TimeValue (MilliSeconds (2)));

  NetDeviceContainer csmaDevices = csma.Install (NodeContainer (csmaNodes.Get(0), olsrNodes.Get(1)));

  // Note that with FixedRssLossModel, the positions below are not 

  // used for received signal strength. 

  MobilityHelper mobility;

  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();

  positionAlloc->Add (Vector (0.0, 0.0, 0.0));

  positionAlloc->Add (Vector (5.0, 0.0, 0.0));

  mobility.SetPositionAllocator (positionAlloc);

  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");

  mobility.Install (olsrNodes);

  OlsrHelper olsr;

  // Specify Node B's csma device as a non-OLSR device.

  olsr.ExcludeInterface (olsrNodes.Get (1), 2);

  Ipv4StaticRoutingHelper staticRouting;

  Ipv4ListRoutingHelper list;

  list.Add (staticRouting, 0);

  list.Add (olsr, 10);

  InternetStackHelper internet_olsr;

  internet_olsr.SetRoutingHelper (list);

  internet_olsr.Install (olsrNodes);

  InternetStackHelper internet_csma;

  internet_csma.Install (csmaNodes);

  Ipv4AddressHelper ipv4;

  NS_LOG_INFO ("Assign IP Addresses.");

  ipv4.SetBase ("10.1.1.0", "255.255.255.0");

  ipv4.Assign (devices);

  ipv4.SetBase ("172.16.1.0", "255.255.255.0");

  ipv4.Assign (csmaDevices);

  TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");

  Ptr<Socket> recvSink = Socket::CreateSocket (csmaNodes.Get(0), tid);

  InetSocketAddress local = InetSocketAddress (Ipv4Address::GetAny (), 80);

  recvSink->Bind (local);

  recvSink->SetRecvCallback (MakeCallback (&ReceivePacket));

  Ptr<Socket> source = Socket::CreateSocket (olsrNodes.Get (0), tid);

  InetSocketAddress remote = InetSocketAddress (Ipv4Address ("172.16.1.1"), 80);

  source->Connect (remote);

  // Obtain olsr::RoutingProtocol instance of gateway node

  // (namely, node B) and add the required association

  Ptr<Ipv4> stack = olsrNodes.Get (1) -> GetObject<Ipv4> ();

  Ptr<Ipv4RoutingProtocol> rp_Gw = (stack->GetRoutingProtocol ());

  Ptr<Ipv4ListRouting> lrp_Gw = DynamicCast<Ipv4ListRouting> (rp_Gw);

  Ptr<olsr::RoutingProtocol> olsrrp_Gw;

  for (uint32_t i = 0; i < lrp_Gw->GetNRoutingProtocols ();  i++)

    {

      int16_t priority;

      Ptr<Ipv4RoutingProtocol> temp = lrp_Gw->GetRoutingProtocol (i, priority);

      if (DynamicCast<olsr::RoutingProtocol> (temp))

        {

          olsrrp_Gw = DynamicCast<olsr::RoutingProtocol> (temp);

        }

    }

  // Create a special Ipv4StaticRouting instance for RoutingTableAssociation

  // Even the Ipv4StaticRouting instance added to list may be used

  Ptr<Ipv4StaticRouting> hnaEntries = Create<Ipv4StaticRouting> ();

  if (assocMethod1)

    {

      // Add the required routes into the Ipv4StaticRouting Protocol instance

      // and have the node generate HNA messages for all these routes

      // which are associated with non-OLSR interfaces specified above.

      hnaEntries->AddNetworkRouteTo (Ipv4Address ("172.16.1.0"), Ipv4Mask ("255.255.255.0"), uint32_t(2), uint32_t(1));

      olsrrp_Gw->SetRoutingTableAssociation (hnaEntries);

    }

  if (assocMethod2)

    {

      // Specify the required associations directly.

      olsrrp_Gw->AddHostNetworkAssociation (Ipv4Address ("172.16.1.0"), Ipv4Mask ("255.255.255.0"));

    }

  // Tracing

  wifiPhy.EnablePcap ("olsr-hna", devices);

  csma.EnablePcap ("olsr-hna", csmaDevices, false);

  Simulator::ScheduleWithContext (source->GetNode ()->GetId (),

                                  Seconds (15.0), &GenerateTraffic, 

                                  source, packetSize, numPackets, interPacketInterval);

  Simulator::Stop (Seconds (20.0));

  Simulator::Run ();

  Simulator::Destroy ();

  return 0;

}

    obj = bld.create_ns3_program('olsr-hna',

                                 ['core', 'simulator', 'mobility', 'wifi'])

    obj.source = 'olsr-hna.cc'

  m_interfaceExclusions = o.m_interfaceExclusions;

void

OlsrHelper::ExcludeInterface (Ptr<Node> node, uint32_t interface)

{

  std::map< Ptr<Node>, std::set<uint32_t> >::iterator it = m_interfaceExclusions.find (node);

  if(it == m_interfaceExclusions.end ())

    {

      std::set<uint32_t> interfaces;

      interfaces.insert (interface);

      m_interfaceExclusions.insert (std::make_pair (node, std::set<uint32_t> (interfaces) ));

    }

  else

    {

      it->second.insert (interface);

    }

}

  std::map<Ptr<Node>, std::set<uint32_t> >::const_iterator it = m_interfaceExclusions.find (node);

  if(it != m_interfaceExclusions.end ())

    {

      agent->SetInterfaceExclusions (it->second);

    }

#include <map>

#include <set>

 /**

   * \param node the node for which an exception is to be defined

   * \param interface an interface of node on which OLSR is not to be installed

   *

   * This method allows the user to specify an interface on which OLSR is not to be installed on

   */

  void ExcludeInterface (Ptr<Node> node, uint32_t interface);

  std::map< Ptr<Node>, std::set<uint32_t> > m_interfaceExclusions;

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

  m_routingTableAssociation = 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);

          std::set<uint32_t>::const_iterator ci = m_interfaceExclusions.find (route.GetInterface ());

          if (ci != m_interfaceExclusions.end ())

            {

              olsr::MessageHeader::Hna::Association assoc = {route.GetDestNetwork (), route.GetDestNetworkMask ()};

              associations.push_back(assoc);

            }

        }

    }

  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)

        {

          olsr::MessageHeader::Hna::Association assoc = {it->networkAddr,it->netmask};

          associations.push_back(assoc);

        }

    }

  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::SetRoutingTableAssociation (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 has associated hosts/networks) and reschedules the HNA timer.

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

///

void

RoutingProtocol::HnaTimerExpire ()

{

  if (m_state.GetAssociations ().size () > 0 || m_routingTableAssociation !=0)

    {

      SendHna ();

    }

  else

    {

      NS_LOG_DEBUG ("Not sending any HNA, no associations to advertise.");

    }

  m_hnaTimer.Schedule (m_hnaInterval);

}

///

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

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

      if (rtentry)

        {

          found = true;

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

        }

    }

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

  /// Inject Association to be sent in HNA message

  void AddHostNetworkAssociation (Ipv4Address networkAddr, Ipv4Mask netmask);

  /// Inject Associations from an Ipv4StaticRouting instance

  void SetRoutingTableAssociation (Ptr<Ipv4StaticRouting> routingTable);

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

/********** 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, section12.2). Associations obtained from HNA messages generated by other nodes.

  Associations m_associations;	///< The node's local Host Network Associations that will be advertised using HNA messages.

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