Attachment #2250 for bug #938

View | Details | Raw Unified | Return to bug 938
Collapse All | Expand All




 *
 */

//
// This script, adapted from examples/wireless/wifi-simple-adhoc illustrates
// the use of OLSR HNA.
//
// Network Topology:
//
//             |------ OLSR ------|   |---- non-OLSR ----|

  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
    {

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

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


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

      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.

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

  Simulator::ScheduleWithContext (source->GetNode ()->GetId (),
                                  Seconds (15.0), &GenerateTraffic,
                                  source, packetSize, numPackets, interPacketInterval);

  Simulator::Stop (Seconds (20.0));




// - CBR/UDP flows from n0 to n4, and from n3 to n1
// - UDP packet size of 210 bytes, with per-packet interval 0.00375 sec.
//   (i.e., DataRate of 448,000 bps)
// - DropTail queues
// - Tracing of queues and packet receptions to file "simple-point-to-point-olsr.tr"

#include <iostream>


NS_LOG_COMPONENT_DEFINE ("SimplePointToPointOlsrExample");

int
main (int argc, char *argv[])
{
  // Users may find it convenient to turn on explicit debugging
  // for selected modules; the below lines suggest how to do this
#if 0
  LogComponentEnable ("SimpleGlobalRoutingExample", LOG_LEVEL_INFO);
#endif

  // Set up some default values for the simulation.  Use the

  Config::SetDefault ("ns3::OnOffApplication::PacketSize", UintegerValue (210));
  Config::SetDefault ("ns3::OnOffApplication::DataRate", StringValue ("448kb/s"));

  NS_LOG_INFO ("Create Applications.");
  uint16_t port = 9;   // Discard port (RFC 863)

  OnOffHelper onoff ("ns3::UdpSocketFactory",
                     InetSocketAddress (i34.GetAddress (1), port));
  onoff.SetConstantRate (DataRate ("448kb/s"));





  m_interfaceExclusions = o.m_interfaceExclusions;
}

OlsrHelper*
OlsrHelper::Copy (void) const
{
  return new OlsrHelper (*this);
}

void

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

    }
}

Ptr<Ipv4RoutingProtocol>
OlsrHelper::Create (Ptr<Node> node) const
{
  Ptr<olsr::RoutingProtocol> agent = m_agentFactory.Create<olsr::RoutingProtocol> ();

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

  if (it != m_interfaceExclusions.end ())
    {
      agent->SetInterfaceExclusions (it->second);
    }

  return agent;
}

void
OlsrHelper::Set (std::string name, const AttributeValue &value)
{
  m_agentFactory.Set (name, value);
}

int64_t
OlsrHelper::AssignStreams (NodeContainer c, int64_t stream)
{
  int64_t currentStream = stream;

          int16_t priority;
          Ptr<Ipv4RoutingProtocol> listProto;
          Ptr<olsr::RoutingProtocol> listOlsr;
          for (uint32_t i = 0; i < list->GetNRoutingProtocols (); i++)
            {
              listProto = list->GetRoutingProtocol (i, priority);
              listOlsr = DynamicCast<olsr::RoutingProtocol> (listProto);




 *
 * \brief Helper class that adds OLSR routing to nodes.
 *
 * This class is expected to be used in conjunction with
 * ns3::InternetStackHelper::SetRoutingHelper
 */
class OlsrHelper : public Ipv4RoutingHelper

  OlsrHelper (const OlsrHelper &);

  /**
   * \returns pointer to clone of this OlsrHelper
   *
   * This method is mainly for internal use by the other helpers;
   * clients are expected to free the dynamic memory allocated by this method
   */

   */
  void Set (std::string name, const AttributeValue &value);

  /**
   * Assign a fixed random variable stream number to the random variables
   * used by this model.  Return the number of streams (possibly zero) that
   * have been assigned.  The Install() method of the InternetStackHelper
   * should have previously been called by the user.
   *
   * \param stream first stream index to use
   * \param c NodeContainer of the set of nodes for which the OlsrRoutingProtocol
   *          should be modified to use a fixed stream
   * \return the number of stream indices assigned by this helper
   */
  int64_t AssignStreams (NodeContainer c, int64_t stream);

private:




#define OLSR_PKT_HEADER_SIZE 4

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("OlsrHeader");

namespace olsr {

  int a, b = 0;

  // find the largest integer 'b' such that: T/C >= 2^b
  for (b = 0; (seconds / OLSR_C) >= (1 << b); ++b)
    {
    }
  NS_ASSERT ((seconds / OLSR_C) < (1 << b));
  b--;
  NS_ASSERT ((seconds / OLSR_C) >= (1 << b));

  // compute the expression 16*(T/(C*(2^b))-1), which may not be a integer
  double tmp = 16 * (seconds / (OLSR_C * (1 << b)) - 1);

  // round it up.  This results in the value for 'a'
  a = (int) std::ceil (tmp - 0.5);

  // if 'a' is equal to 16: increment 'b' by one, and set 'a' to 0
  if (a == 16)

  int a = (olsrFormat >> 4);
  int b = (olsrFormat & 0xf);
  // value = C*(1+a/16)*2^b [in seconds]
  return OLSR_C * (1 + a / 16.0) * (1 << b);
}



  return GetTypeId ();
}

uint32_t
PacketHeader::GetSerializedSize (void) const
{
  return OLSR_PKT_HEADER_SIZE;
}

void
PacketHeader::Print (std::ostream &os) const
{
  /// \todo

  return size;
}

void
MessageHeader::Print (std::ostream &os) const
{
  /// \todo


// ---------------- OLSR MID Message -------------------------------

uint32_t
MessageHeader::Mid::GetSerializedSize (void) const
{
  return this->interfaceAddresses.size () * IPV4_ADDRESS_SIZE;
}

void
MessageHeader::Mid::Print (std::ostream &os) const
{
  /// \todo

  this->interfaceAddresses.erase (this->interfaceAddresses.begin (),
                                  this->interfaceAddresses.end ());
  for (int n = 0; n < numAddresses; ++n)
    {
      this->interfaceAddresses.push_back (Ipv4Address (i.ReadNtohU32 ()));
    }
  return GetSerializedSize ();
}



// ---------------- OLSR HELLO Message -------------------------------

uint32_t
MessageHeader::Hello::GetSerializedSize (void) const
{
  uint32_t size = 4;

  return size;
}

void
MessageHeader::Hello::Print (std::ostream &os) const
{
  /// \todo


// ---------------- OLSR TC Message -------------------------------

uint32_t
MessageHeader::Tc::GetSerializedSize (void) const
{
  return 4 + this->neighborAddresses.size () * IPV4_ADDRESS_SIZE;
}

void
MessageHeader::Tc::Print (std::ostream &os) const
{
  /// \todo

  int numAddresses = (messageSize - 4) / IPV4_ADDRESS_SIZE;
  this->neighborAddresses.clear ();
  for (int n = 0; n < numAddresses; ++n)
    {
      this->neighborAddresses.push_back (Ipv4Address (i.ReadNtohU32 ()));
    }

  return messageSize;
}


// ---------------- OLSR HNA Message -------------------------------

uint32_t
MessageHeader::Hna::GetSerializedSize (void) const
{
  return 2 * this->associations.size () * IPV4_ADDRESS_SIZE;
}

void
MessageHeader::Hna::Print (std::ostream &os) const
{
  /// \todo

{
  Buffer::Iterator i = start;

  NS_ASSERT (messageSize % (IPV4_ADDRESS_SIZE * 2) == 0);
  int numAddresses = messageSize / IPV4_ADDRESS_SIZE / 2;
  this->associations.clear ();
  for (int n = 0; n < numAddresses; ++n)




class MessageHeader : public Header
{
public:

  /**
   * Message type
   */
  enum MessageType
  {
    HELLO_MESSAGE = 1,
    TC_MESSAGE    = 2,
    MID_MESSAGE   = 3,

     * \param messageSize the message size.
     * \returns the number of bytes read.
     */
    uint32_t Deserialize (Buffer::Iterator start, uint32_t messageSize);
  };

  /**

     (etc.)
  \endverbatim
  */
  struct Hello
  {
    /**
     * Link message item
     */
    struct LinkMessage
    {
      uint8_t linkCode;       //!< Link code
      std::vector<Ipv4Address> neighborInterfaceAddresses;  //!< Neighbor interface address container.
    };

    uint32_t Deserialize (Buffer::Iterator start, uint32_t messageSize);
  };

  /**
   * \ingroup olsr
   * TC Message Format
   *
   \verbatim
     0                   1                   2                   3
     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |              ANSN             |           Reserved            |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |               Advertised Neighbor Main Address                |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |               Advertised Neighbor Main Address                |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |                              ...                              |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   \endverbatim
   */
  struct Tc
  {
    std::vector<Ipv4Address> neighborAddresses; //!< Neighbor address container.
    uint16_t ansn;  //!< Advertised Neighbor Sequence Number.

     * \param messageSize the message size.
     * \returns the number of bytes read.
     */
    uint32_t Deserialize (Buffer::Iterator start, uint32_t messageSize);
  };


  /**
   * \ingroup olsr
   * HNA (Host Network Association) Message Format
   *
   \verbatim
     0                   1                   2                   3
     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |                         Network Address                       |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |                             Netmask                           |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |                         Network Address                       |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |                             Netmask                           |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |                              ...                              |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   \endverbatim
   */
  struct Hna
  {
    /**
     * Association item structure.
     */
    struct Association
    {
      Ipv4Address address; //!< IPv4 Address.

  };

private:

  /**
   * Structure holding the message content.
   */

  } m_message; //!< The actual message being carried.

public:

  /**
   * Set the message type to MID and return the message content.
   * \returns The MID message.

       messageIter != messages.end (); messageIter++)
    {
      messageIter->Print (os);
      if (messageIter + 1 != messages.end ())
        {
          os << ", ";
        }
    }
  os << "]";
  return os;




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

#include "ns3/ipv4-address.h"
#include "ns3/nstime.h"

namespace ns3 {
namespace olsr {


/// \ingroup olsr

operator == (const IfaceAssocTuple &a, const IfaceAssocTuple &b)
{
  return (a.ifaceAddr == b.ifaceAddr
          && a.mainAddr == b.mainAddr);
}

static inline std::ostream&
operator << (std::ostream &os, const IfaceAssocTuple &tuple)
{
  os << "IfaceAssocTuple(ifaceAddr=" << tuple.ifaceAddr
     << ", mainAddr=" << tuple.mainAddr
     << ", time=" << tuple.time << ")";
  return os;
}


operator == (const LinkTuple &a, const LinkTuple &b)
{
  return (a.localIfaceAddr == b.localIfaceAddr
          && a.neighborIfaceAddr == b.neighborIfaceAddr);
}

static inline std::ostream&
operator << (std::ostream &os, const LinkTuple &tuple)
{
  os << "LinkTuple(localIfaceAddr=" << tuple.localIfaceAddr
     << ", neighborIfaceAddr=" << tuple.neighborIfaceAddr
     << ", symTime=" << tuple.symTime
     << ", asymTime=" << tuple.asymTime
     << ", expTime=" << tuple.time
     << ")";
  return os;
}


  /// Main address of a neighbor node.
  Ipv4Address neighborMainAddr;
  /// Status of the link (Symmetric or not Symmetric).
  enum Status
  {
    STATUS_NOT_SYM = 0, // "not symmetric"
    STATUS_SYM = 1, // "symmetric"
  } status; //!< Status of the link.

operator == (const NeighborTuple &a, const NeighborTuple &b)
{
  return (a.neighborMainAddr == b.neighborMainAddr
          && a.status == b.status
          && a.willingness == b.willingness);
}

static inline std::ostream&
operator << (std::ostream &os, const NeighborTuple &tuple)
{
  os << "NeighborTuple(neighborMainAddr=" << tuple.neighborMainAddr
     << ", status=" << (tuple.status == NeighborTuple::STATUS_SYM ? "SYM" : "NOT_SYM")
     << ", willingness=" << (int) tuple.willingness << ")";
  return os;
}


operator << (std::ostream &os, const TwoHopNeighborTuple &tuple)
{
  os << "TwoHopNeighborTuple(neighborMainAddr=" << tuple.neighborMainAddr
     << ", twoHopNeighborAddr=" << tuple.twoHopNeighborAddr
     << ", expirationTime=" << tuple.expirationTime
     << ")";
  return os;
}


operator == (const TwoHopNeighborTuple &a, const TwoHopNeighborTuple &b)
{
  return (a.neighborMainAddr == b.neighborMainAddr
          && a.twoHopNeighborAddr == b.twoHopNeighborAddr);
}

/// \ingroup olsr

operator == (const DuplicateTuple &a, const DuplicateTuple &b)
{
  return (a.address == b.address
          && a.sequenceNumber == b.sequenceNumber);
}

/// \ingroup olsr

operator == (const TopologyTuple &a, const TopologyTuple &b)
{
  return (a.destAddr == b.destAddr
          && a.lastAddr == b.lastAddr
          && a.sequenceNumber == b.sequenceNumber);
}

static inline std::ostream&
operator << (std::ostream &os, const TopologyTuple &tuple)
{
  os << "TopologyTuple(destAddr=" << tuple.destAddr
     << ", lastAddr=" << tuple.lastAddr
     << ", sequenceNumber=" << (int) tuple.sequenceNumber
     << ", expirationTime=" << tuple.expirationTime
     << ")";
  return os;
}


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


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<Association>                Associations; //!< Association Set type.


}
}  // namespace ns3, olsr

#endif /* OLSR_REPOSITORIES_H */




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

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("OlsrRoutingProtocol");

namespace olsr {

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

NS_OBJECT_ENSURE_REGISTERED (RoutingProtocol);

TypeId
RoutingProtocol::GetTypeId (void)
{
  static TypeId tid = TypeId ("ns3::olsr::RoutingProtocol")


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_hnaTimer (Timer::CANCEL_ON_DESTROY),
  m_queuedMessagesTimer (Timer::CANCEL_ON_DESTROY)
{
  m_uniformRandomVariable = CreateObject<UniformRandomVariable> ();


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

  *os << "Node: " << m_ipv4->GetObject<Node> ()->GetId ()
      << ", Time: " << Now ().As (Time::S)
      << ", Local time: " << GetObject<Node> ()->GetLocalTime ().As (Time::S)
      << ", OLSR Routing table" << std::endl;


    {
      Ipv4Address addr = m_ipv4->GetAddress (i, 0).GetLocal ();
      if (addr == loopback)
        {
          continue;
        }

      if (addr != m_mainAddress)
        {

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

      canRunOlsr = true;
    }

  if (canRunOlsr)
    {
      HelloTimerExpire ();
      TcTimerExpire ();

    {
      MessageHeader messageHeader;
      if (packet->RemoveHeader (messageHeader) == 0)
        {
          NS_ASSERT (false);
        }

      sizeLeft -= messageHeader.GetSerializedSize ();


                            << "s OLSR node " << m_mainAddress
                            <<  " received HNA message of size " << messageHeader.GetSerializedSize ());
              ProcessHna (messageHeader, senderIfaceAddr);
              break;

            default:
              NS_LOG_DEBUG ("OLSR message type " <<

          const NeighborTuple *nb_tuple =
            m_state.FindNeighborTuple (nb2hop_tuple.neighborMainAddr);
          if (nb_tuple == NULL)
            {
              degree++;
            }
        }
    }
  return degree;

/// \param neighborMainAddr Neighbor main address.
/// \param N2 Reference to the 2-hop neighbor set.
///
void
CoverTwoHopNeighbors (Ipv4Address neighborMainAddr, TwoHopNeighborSet & N2)
{
  // first gather all 2-hop neighbors to be removed

        next++;
        os << iter->neighborMainAddr << "->" << iter->twoHopNeighborAddr;
        if (next != N2.end ())
          {
            os << ", ";
          }
      }
    os << "]";
    NS_LOG_DEBUG ("N2: " << os.str ());

    {
      if (coveredTwoHopNeighbors.find (twoHopNeigh->twoHopNeighborAddr) != coveredTwoHopNeighbors.end ())
        {
          // This works correctly only because it is known that twoHopNeigh is reachable by exactly one neighbor,
          // so only one record in N2 exists for each of them. This record is erased here.
          NS_LOG_LOGIC ("2-hop neigh. " << twoHopNeigh->twoHopNeighborAddr << " is already covered by an MPR.");
          twoHopNeigh = N2.erase (twoHopNeigh);

            next++;
            os << iter->neighborMainAddr << "->" << iter->twoHopNeighborAddr;
            if (next != N2.end ())
              {
                os << ", ";
              }
          }
        os << "]";
        NS_LOG_DEBUG ("Step 4 iteration: N2=" << os.str ());

            {
              TwoHopNeighborTuple const &nb2hop_tuple = *it2;
              if (nb_tuple.neighborMainAddr == nb2hop_tuple.neighborMainAddr)
                {
                  r++;
                }
            }
          rs.insert (r);
          reachability[r].push_back (&nb_tuple);

        next++;
        os << *iter;
        if (next != mprSet.end ())
          {
            os << ", ";
          }
      }
    os << "]";
    NS_LOG_DEBUG ("Computed MPR set for node " << m_mainAddress << ": " << os.str ());

    m_state.FindIfaceAssocTuple (iface_addr);

  if (tuple != NULL)
    {
      return tuple->mainAddr;
    }
  else
    {
      return iface_addr;
    }
}

void

        }

      if (!added)
        {
          break;
        }
    }

  // 4. For each entry in the multiple interface association base

      for (routeIndex = 0; routeIndex < m_hnaRoutingTable->GetNRoutes (); routeIndex++)
        {
          Ipv4RoutingTableEntry route = m_hnaRoutingTable->GetRoute (routeIndex);
          if (route.GetDestNetwork () == tuple.networkAddr
              && route.GetDestNetworkMask () == tuple.netmask)
            {
              break;
            }

        {
          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,

  // 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. If there exist some tuple in the topology set where:
  //    T_last_addr == originator address AND

  const TopologyTuple *topologyTuple =
    m_state.FindNewerTopologyTuple (msg.GetOriginatorAddress (), tc.ansn);
  if (topologyTuple != NULL)
    {
      return;
    }

  // 3. All tuples in the topology set where:
  //    T_last_addr == originator address AND

          //      T_last_addr = originator address,
          //      T_seq       = ANSN,
          //      T_time      = current time + validity time.
          TopologyTuple topologyTuple;
          topologyTuple.destAddr = addr;
          topologyTuple.lastAddr = msg.GetOriginatorAddress ();
          topologyTuple.sequenceNumber = tc.ansn;

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

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

  // 1-hop neighborhood the message must not be forwarded
  const LinkTuple *linkTuple = m_state.FindSymLinkTuple (senderAddress, now);
  if (linkTuple == NULL)
    {
      return;
    }

  // If the message has already been considered for forwarding,
  // it must not be retransmitted again

}

void
RoutingProtocol::SendPacket (Ptr<Packet> packet,
                             const MessageList &containedMessages)
{
  NS_LOG_DEBUG ("OLSR node " << m_mainAddress << " sending a OLSR packet");

    {
      Ipv4Address addr = m_ipv4->GetAddress (i, 0).GetLocal ();
      if (addr != m_mainAddress && addr != loopback && m_interfaceExclusions.find (i) == m_interfaceExclusions.end ())
        {
          mid.interfaceAddresses.push_back (addr);
        }
    }
  if (mid.interfaceAddresses.size () == 0)
    {
      return;
    }

  msg.SetVTime (OLSR_MID_HOLD_TIME);
  msg.SetOriginatorAddress (m_mainAddress);

      const char *linkTypeName;
      switch (lt)
        {
        case OLSR_UNSPEC_LINK:
          linkTypeName = "UNSPEC_LINK";
          break;
        case OLSR_ASYM_LINK:
          linkTypeName = "ASYM_LINK";
          break;
        case OLSR_SYM_LINK:
          linkTypeName = "SYM_LINK";
          break;
        case OLSR_LOST_LINK:
          linkTypeName = "LOST_LINK";
          break;
          /*  no default, since lt must be in 0..3, covered above
        default: linkTypeName = "(invalid value!)";
          */

      const char *neighborTypeName;
      switch (nt)
        {
        case OLSR_NOT_NEIGH:
          neighborTypeName = "NOT_NEIGH";
          break;
        case OLSR_SYM_NEIGH:
          neighborTypeName = "SYM_NEIGH";
          break;
        case OLSR_MPR_NEIGH:
          neighborTypeName = "MPR_NEIGH";
          break;
        default:
          neighborTypeName = "(invalid value!)";
        }

      NS_LOG_DEBUG ("Looking at HELLO link messages with Link Type "

#endif // NS3_LOG_ENABLE

      // We must not process invalid advertised links
      if ((lt == OLSR_SYM_LINK && nt == OLSR_NOT_NEIGH)
          || (nt != OLSR_SYM_NEIGH && nt != OLSR_MPR_NEIGH
              && nt != OLSR_NOT_NEIGH))
        {
          NS_LOG_LOGIC ("HELLO link code is invalid => IGNORING");
          continue;

/// \param p the packet which couldn't be delivered by the MAC layer.
///
void
OLSR::mac_failed (Ptr<Packet> p)
{
  double now              = Simulator::Now ();
  struct hdr_ip* ih       = HDR_IP (p);
  struct hdr_cmn* ch      = HDR_CMN (p);

         OLSR::node_id (ra_addr ()),
         OLSR::node_id (ch->next_hop ()));

  if ((u_int32_t)ih->daddr () == IP_BROADCAST)
    {
      drop (p, DROP_RTR_MAC_CALLBACK);
      return;
    }

  OLSR_link_tuple* link_tuple = state_.find_link_tuple (ch->next_hop ());
  if (link_tuple != NULL)
    {
      link_tuple->lost_time () = now + OLSR_NEIGHB_HOLD_TIME;
      link_tuple->time ()      = now + OLSR_NEIGHB_HOLD_TIME;
      nb_loss (link_tuple);

  else if (tuple->symTime < now)
    {
      if (m_linkTupleTimerFirstTime)
        {
          m_linkTupleTimerFirstTime = false;
        }
      else
        {
          NeighborLoss (*tuple);
        }

      m_events.Track (Simulator::Schedule (DELAY (tuple->time),
                                           &RoutingProtocol::LinkTupleTimerExpire, this,

    m_table.find (dest);
  // If there is no route to "dest", return NULL
  if (it == m_table.end ())
    {
      return false;
    }
  outEntry = it->second;
  return true;
}

  while (outEntry.destAddr != outEntry.nextAddr)
    {
      if (not Lookup (outEntry.nextAddr, outEntry))
        {
          return false;
        }
    }
  return true;
}

      if (oif && m_ipv4->GetInterfaceForDevice (oif) != static_cast<int> (interfaceIdx))
        {
          // We do not attempt to perform a constrained routing search
          // if the caller specifies the oif; we just enforce that
          // that the found route matches the requested outbound interface
          NS_LOG_DEBUG ("Olsr node " << m_mainAddress
                                     << ": RouteOutput for dest=" << header.GetDestination ()
                                     << " Route interface " << interfaceIdx
                                     << " does not match requested output interface "

      rtentry = Create<Ipv4Route> ();
      rtentry->SetDestination (header.GetDestination ());
      // the source address is the interface address that matches
      // the destination address (when multiple are present on the
      // outgoing interface, one is selected via scoping rules)
      NS_ASSERT (m_ipv4);
      uint32_t numOifAddresses = m_ipv4->GetNAddresses (interfaceIdx);
      NS_ASSERT (numOifAddresses > 0);
      Ipv4InterfaceAddress ifAddr;
      if (numOifAddresses == 1)
        {
          ifAddr = m_ipv4->GetAddress (interfaceIdx, 0);
        }
      else
        {
          /// \todo Implment IP aliasing and OLSR
          NS_FATAL_ERROR ("XXX Not implemented yet:  IP aliasing and OLSR");
        }

      rtentry->SetGateway (entry2.nextAddr);
      rtentry->SetOutputDevice (m_ipv4->GetNetDevice (interfaceIdx));
      sockerr = Socket::ERROR_NOTERROR;
      NS_LOG_DEBUG ("Olsr node " << m_mainAddress
                                 << ": RouteOutput for dest=" << header.GetDestination ()
                                 << " --> nextHop=" << entry2.nextAddr
                                 << " interface=" << entry2.interface);

      found = true;
    }
  else
    {
      rtentry = m_hnaRoutingTable->RouteOutput (p, header, oif, sockerr);

      if (rtentry)


  if (!found)
    {
      NS_LOG_DEBUG ("Olsr node " << m_mainAddress
                                 << ": RouteOutput for dest=" << header.GetDestination ()
                                 << " No route to host");
      sockerr = Socket::ERROR_NOROUTETOHOST;

  return rtentry;
}

bool RoutingProtocol::RouteInput  (Ptr<const Packet> p,
                                   const Ipv4Header &header, Ptr<const NetDevice> idev,
                                   UnicastForwardCallback ucb, MulticastForwardCallback mcb,
                                   LocalDeliverCallback lcb, ErrorCallback ecb)

  // Consume self-originated packets
  if (IsMyOwnAddress (origin) == true)
    {
      return true;
    }

  // Local delivery

      else
        {
          // The local delivery callback is null.  This may be a multicast
          // or broadcast packet, so return false so that another
          // multicast routing protocol can handle it.  It should be possible
          // to extend this to explicitly check whether it is a unicast
          // packet, and invoke the error callback if so


  // Forwarding
  Ptr<Ipv4Route> rtentry;
  RoutingTableEntry entry1, entry2;
  if (Lookup (header.GetDestination (), entry1))
    {
      bool foundSendEntry = FindSendEntry (entry1, entry2);
      if (!foundSendEntry)
        {
          NS_FATAL_ERROR ("FindSendEntry failure");
        }
      rtentry = Create<Ipv4Route> ();
      rtentry->SetDestination (header.GetDestination ());
      uint32_t interfaceIdx = entry2.interface;

      uint32_t numOifAddresses = m_ipv4->GetNAddresses (interfaceIdx);
      NS_ASSERT (numOifAddresses > 0);
      Ipv4InterfaceAddress ifAddr;
      if (numOifAddresses == 1)
        {
          ifAddr = m_ipv4->GetAddress (interfaceIdx, 0);
        }
      else
        {
          /// \todo Implment IP aliasing and OLSR
          NS_FATAL_ERROR ("XXX Not implemented yet:  IP aliasing and OLSR");
        }

    }
  else
    {
      if (m_hnaRoutingTable->RouteInput (p, header, idev, ucb, mcb, lcb, ecb))
        {
          return true;
        }

        {

#ifdef NS3_LOG_ENABLE
          NS_LOG_DEBUG ("Olsr node " << m_mainAddress
                                     << ": RouteInput for dest=" << header.GetDestination ()
                                     << " --> NOT FOUND; ** Dumping routing table...");


        }
    }
}
void
RoutingProtocol::NotifyInterfaceUp (uint32_t i)
{
}
void
RoutingProtocol::NotifyInterfaceDown (uint32_t i)
{
}
void
RoutingProtocol::NotifyAddAddress (uint32_t interface, Ipv4InterfaceAddress address)
{
}
void
RoutingProtocol::NotifyRemoveAddress (uint32_t interface, Ipv4InterfaceAddress address)
{
}


void

       iter != m_state.GetTwoHopNeighbors ().end (); iter++)
    {
      if (now < iter->expirationTime)
        {
          NS_LOG_DEBUG ("  " << *iter);
        }
    }

(-)a/src/olsr/model/olsr-routing-protocol.h (-17 / +21 lines)

Lines 51-57	Link Here

///

///

/// \defgroup olsr OLSR Routing

/// \defgroup olsr OLSR Routing

/// This section documents the API of the ns-3 OLSR module. For a generic

/// This section documents the API of the ns-3 OLSR module. For a generic

/// functional description, please refer to the ns-3 manual.

/// functional description, please refer to the ns-3 manual.

/// \ingroup olsr

/// \ingroup olsr

Lines 64-71	Link Here

  uint32_t distance; //!< Distance in hops to the destination.

  uint32_t distance; //!< Distance in hops to the destination.

  RoutingTableEntry () : // default values

  RoutingTableEntry () : // default values

                         destAddr (), nextAddr (),

    destAddr (), nextAddr (),

                         interface (0), distance (0) {};

    interface (0), distance (0)

};

};

class RoutingProtocol;

class RoutingProtocol;

Lines 108-121	Link Here

108

*/

110

*/

109

  std::vector<RoutingTableEntry> GetRoutingTableEntries () const;

111

  std::vector<RoutingTableEntry> GetRoutingTableEntries () const;

110

112

111

/**

113

/**

112

  * Assign a fixed random variable stream number to the random variables

114

   * Assign a fixed random variable stream number to the random variables

113

  * used by this model.  Return the number of streams (possibly zero) that

115

   * used by this model.  Return the number of streams (possibly zero) that

114

  * have been assigned.

116

   * have been assigned.

115

117

116

  * \param stream first stream index to use

118

   * \param stream first stream index to use

117

  * \return the number of stream indices assigned by this model

119

   * \return the number of stream indices assigned by this model

118

*/

120

*/

119

  int64_t AssignStreams (int64_t stream);

121

  int64_t AssignStreams (int64_t stream);

120

122

121

/**

123

/**

Lines 124-131	Link Here

124

   * \param [in] header

126

   * \param [in] header

125

   * \param [in] messages

127

   * \param [in] messages

126

*/

128

*/

127

  typedef void (* PacketTxRxTracedCallback)

129

  typedef void (* PacketTxRxTracedCallback)(const PacketHeader & header, const MessageList & messages);

128

    (const PacketHeader & header, const MessageList & messages);

129

130

/**

131

/**

131

   * TracedCallback signature for routing table computation.

132

   * TracedCallback signature for routing table computation.

Lines 200-206	Link Here

200

  Ptr<Ipv4StaticRouting> m_hnaRoutingTable; //!< Routing table for HNA routes

201

  Ptr<Ipv4StaticRouting> m_hnaRoutingTable; //!< Routing table for HNA routes

201

202

  EventGarbageCollector m_events; //!< Running events.

203

  EventGarbageCollector m_events; //!< Running events.

203

204

  uint16_t m_packetSequenceNumber;    //!< Packets sequence number counter.

205

  uint16_t m_packetSequenceNumber;    //!< Packets sequence number counter.

205

  uint16_t m_messageSequenceNumber;   //!< Messages sequence number counter.

206

  uint16_t m_messageSequenceNumber;   //!< Messages sequence number counter.

206

  uint16_t m_ansn;  //!< Advertised Neighbor Set sequence number.

207

  uint16_t m_ansn;  //!< Advertised Neighbor Set sequence number.

Lines 223-229	Link Here

223

   * Returns the routing table size.

224

   * Returns the routing table size.

224

   * \return The routing table size.

225

   * \return The routing table size.

225

*/

226

*/

226

  uint32_t GetSize () const { return m_table.size (); }

227

  uint32_t GetSize () const

228

229

    return m_table.size ();

230

227

231

228

/**

232

/**

229

   * \brief Deletes the entry whose destination address is given.

233

   * \brief Deletes the entry whose destination address is given.

Lines 500-506	Link Here

500

/**

504

/**

501

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

505

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

502

*/

506

*/

503

 void SendHello ();

507

  void SendHello ();

504

508

505

/**

509

/**

506

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

510

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

Lines 763-769	Link Here

763

  TracedCallback <uint32_t> m_routingTableChanged;

767

  TracedCallback <uint32_t> m_routingTableChanged;

764

768

765

  /// Provides uniform random variables.

769

  /// Provides uniform random variables.

766

  Ptr<UniformRandomVariable> m_uniformRandomVariable;

770

  Ptr<UniformRandomVariable> m_uniformRandomVariable;

767

771

768

};

772

};

769

773

(-)a/src/olsr/model/olsr-state.cc (-20 / +49 lines)

Lines 1-6	Link Here

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

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

/*

/*

 * Copyright (c) 2004 Francisco J. Ros

 * Copyright (c) 2004 Francisco J. Ros

 * Copyright (c) 2007 INESC Porto

 * Copyright (c) 2007 INESC Porto

 * This program is free software; you can redistribute it and/or modify

 * This program is free software; you can redistribute it and/or modify

Lines 41-47	Link Here

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

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

      if (it->mainAddr == mainAddr)

      if (it->mainAddr == mainAddr)

        return &(*it);

          return &(*it);

  return NULL;

  return NULL;

Lines 64-70	Link Here

OlsrState::EraseMprSelectorTuples (const Ipv4Address &mainAddr)

OlsrState::EraseMprSelectorTuples (const Ipv4Address &mainAddr)

  for (MprSelectorSet::iterator it = m_mprSelectorSet.begin ();

  for (MprSelectorSet::iterator it = m_mprSelectorSet.begin ();

       it != m_mprSelectorSet.end ();)

       it != m_mprSelectorSet.end (); )

      if (it->mainAddr == mainAddr)

      if (it->mainAddr == mainAddr)

Lines 95-101	Link Here

      next++;

      next++;

      os << iter->mainAddr;

      os << iter->mainAddr;

      if (next != m_mprSelectorSet.end ())

      if (next != m_mprSelectorSet.end ())

        os << ", ";

100

101

          os << ", ";

102

103

100

  os << "]";

104

  os << "]";

101

  return os.str ();

105

  return os.str ();

Lines 111-117	Link Here

111

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

115

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

112

116

113

      if (it->neighborMainAddr == mainAddr)

117

      if (it->neighborMainAddr == mainAddr)

114

        return &(*it);

118

119

          return &(*it);

120

115

121

116

  return NULL;

122

  return NULL;

117

123

Lines 123-129	Link Here

123

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

129

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

124

130

125

      if (it->neighborMainAddr == mainAddr && it->status == NeighborTuple::STATUS_SYM)

131

      if (it->neighborMainAddr == mainAddr && it->status == NeighborTuple::STATUS_SYM)

126

        return &(*it);

132

133

          return &(*it);

134

127

135

128

  return NULL;

136

  return NULL;

129

137

Lines 135-141	Link Here

135

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

143

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

136

144

137

      if (it->neighborMainAddr == mainAddr && it->willingness == willingness)

145

      if (it->neighborMainAddr == mainAddr && it->willingness == willingness)

138

        return &(*it);

146

147

          return &(*it);

148

139

149

140

  return NULL;

150

  return NULL;

141

151

Lines 221-227	Link Here

221

                                      const Ipv4Address &twoHopNeighborAddr)

231

                                      const Ipv4Address &twoHopNeighborAddr)

222

232

223

  for (TwoHopNeighborSet::iterator it = m_twoHopNeighborSet.begin ();

233

  for (TwoHopNeighborSet::iterator it = m_twoHopNeighborSet.begin ();

224

       it != m_twoHopNeighborSet.end ();)

234

       it != m_twoHopNeighborSet.end (); )

225

235

226

      if (it->neighborMainAddr == neighborMainAddr

236

      if (it->neighborMainAddr == neighborMainAddr

227

          && it->twoHopNeighborAddr == twoHopNeighborAddr)

237

          && it->twoHopNeighborAddr == twoHopNeighborAddr)

Lines 239-245	Link Here

239

OlsrState::EraseTwoHopNeighborTuples (const Ipv4Address &neighborMainAddr)

249

OlsrState::EraseTwoHopNeighborTuples (const Ipv4Address &neighborMainAddr)

240

250

241

  for (TwoHopNeighborSet::iterator it = m_twoHopNeighborSet.begin ();

251

  for (TwoHopNeighborSet::iterator it = m_twoHopNeighborSet.begin ();

242

       it != m_twoHopNeighborSet.end ();)

252

       it != m_twoHopNeighborSet.end (); )

243

253

244

      if (it->neighborMainAddr == neighborMainAddr)

254

      if (it->neighborMainAddr == neighborMainAddr)

245

255

Lines 287-293	Link Here

287

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

297

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

288

298

289

      if (it->address == addr && it->sequenceNumber == sequenceNumber)

299

      if (it->address == addr && it->sequenceNumber == sequenceNumber)

290

        return &(*it);

300

301

          return &(*it);

302

291

303

292

  return NULL;

304

  return NULL;

293

305

Lines 321-327	Link Here

321

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

333

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

322

334

323

      if (it->neighborIfaceAddr == ifaceAddr)

335

      if (it->neighborIfaceAddr == ifaceAddr)

324

        return &(*it);

336

337

          return &(*it);

338

325

339

326

  return NULL;

340

  return NULL;

327

341

Lines 335-343	Link Here

335

      if (it->neighborIfaceAddr == ifaceAddr)

349

      if (it->neighborIfaceAddr == ifaceAddr)

336

350

337

          if (it->symTime > now)

351

          if (it->symTime > now)

338

            return &(*it);

352

353

              return &(*it);

354

339

          else

355

          else

340

            break;

356

357

              break;

358

341

359

342

360

343

  return NULL;

361

  return NULL;

Lines 374-380	Link Here

374

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

392

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

375

393

376

      if (it->destAddr == destAddr && it->lastAddr == lastAddr)

394

      if (it->destAddr == destAddr && it->lastAddr == lastAddr)

377

        return &(*it);

395

396

          return &(*it);

397

378

398

379

  return NULL;

399

  return NULL;

380

400

Lines 386-392	Link Here

386

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

406

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

387

407

388

      if (it->lastAddr == lastAddr && it->sequenceNumber > ansn)

408

      if (it->lastAddr == lastAddr && it->sequenceNumber > ansn)

389

        return &(*it);

409

410

          return &(*it);

411

390

412

391

  return NULL;

413

  return NULL;

392

414

Lines 409-415	Link Here

409

OlsrState::EraseOlderTopologyTuples (const Ipv4Address &lastAddr, uint16_t ansn)

431

OlsrState::EraseOlderTopologyTuples (const Ipv4Address &lastAddr, uint16_t ansn)

410

432

411

  for (TopologySet::iterator it = m_topologySet.begin ();

433

  for (TopologySet::iterator it = m_topologySet.begin ();

412

       it != m_topologySet.end ();)

434

       it != m_topologySet.end (); )

413

435

414

      if (it->lastAddr == lastAddr && it->sequenceNumber < ansn)

436

      if (it->lastAddr == lastAddr && it->sequenceNumber < ansn)

415

437

Lines 437-443	Link Here

437

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

459

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

438

460

439

      if (it->ifaceAddr == ifaceAddr)

461

      if (it->ifaceAddr == ifaceAddr)

440

        return &(*it);

462

463

          return &(*it);

464

441

465

442

  return NULL;

466

  return NULL;

443

467

Lines 449-455	Link Here

449

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

473

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

450

474

451

      if (it->ifaceAddr == ifaceAddr)

475

      if (it->ifaceAddr == ifaceAddr)

452

        return &(*it);

476

477

          return &(*it);

478

453

479

454

  return NULL;

480

  return NULL;

455

481

Lines 482-488	Link Here

482

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

508

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

483

509

484

      if (it->mainAddr == neighborMainAddr)

510

      if (it->mainAddr == neighborMainAddr)

485

        retval.push_back (it->ifaceAddr);

511

512

          retval.push_back (it->ifaceAddr);

513

486

514

487

  return retval;

515

  return retval;

488

516

Lines 543-546	Link Here

543

  m_associations.push_back (tuple);

571

  m_associations.push_back (tuple);

544

572

545

573

546

}} // namespace olsr, ns3

574

575

}  // namespace olsr, ns3




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

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

public:

  OlsrState ()
  {
  }

  // MPR selector



};

}
}  // namespace olsr,ns3

#endif /* OLSR_STATE_H */





// OLSR was observed to not converge in simple 3-nodes varying topology.
// https://www.nsnam.org/bugzilla/show_bug.cgi?id=780
// tcpdump -r bug780-0-0.pcap -nn -tt icmp | wc
// should show about 395 packets; there is a ping outage from time
// 123-127 due to the mobility.


#include "ns3/icmpv4.h"
#include "bug780-test.h"

namespace ns3 {
namespace olsr {
namespace olsr
{

Bug780Test::Bug780Test () :
  TestCase ("Test OLSR bug 780"),
  m_time (Seconds (200.0)), m_seq (0), m_recvCount (0)
{
}

Bug780Test::~Bug780Test ()
{
}


      p->RemoveHeader (icmp);
      if (icmp.GetType () == Icmpv4Header::ECHO_REPLY)
        {
          m_recvCount++;
        }
    }
}




#include "ns3/nstime.h"
#include "ns3/node-container.h"

namespace ns3 {
namespace olsr {
/** See \bugid{780} */
{
  /** See \bugid{780} */
class Bug780Test : public TestCase
{
public:
  Bug780Test ();
  ~Bug780Test ();
private:
  /// Total simulation time




#include "ns3/udp-header.h"
#include "ns3/olsr-header.h"

namespace ns3 {
namespace olsr {
namespace olsr
{

HelloRegressionTest::HelloRegressionTest () :
  TestCase ("Test OLSR Hello messages generation"),
  m_time (Seconds (5)), m_countA (0), m_countB (0)
{
}

HelloRegressionTest::~HelloRegressionTest ()
{
}


    }

  std::vector<olsr::MessageHeader::Hello::LinkMessage>::const_iterator iter;
  for (iter = hello.linkMessages.begin (); iter != hello.linkMessages.end (); iter++)
    {
      if (m_countA == 1)
        {

      NS_TEST_EXPECT_MSG_EQ (iter->neighborInterfaceAddresses[0], Ipv4Address ("10.1.1.1"), "Only one neighbor.");
    }

  m_countA++;
}

void

    }

  std::vector<olsr::MessageHeader::Hello::LinkMessage>::const_iterator iter;
  for (iter = hello.linkMessages.begin (); iter != hello.linkMessages.end (); iter++)
    {
      if (m_countA == 1)
        {

      NS_TEST_EXPECT_MSG_EQ (iter->neighborInterfaceAddresses[0], Ipv4Address ("10.1.1.2"), "Only one neighbor.");
    }

  m_countB++;
}

}




#include "ns3/ipv4-raw-socket-impl.h"
#include "ns3/node-container.h"

namespace ns3 {
namespace olsr {
namespace olsr
{
/**
 * \ingroup olsr
 * \brief Trivial (still useful) test of OLSR operation
 *
 * This test creates 2 stations with point-to-point link and runs OLSR without any extra traffic.
 * It is expected that only HELLO messages will be sent.
 *
 * Expected trace (5 seconds):
   \verbatim
    1       2

    |<------|   HELLO (Link type: Asymmetric link, Neighbor address: 10.1.1.1) src = 10.1.1.2
    |------>|   HELLO (Link type: Symmetric link, Neighbor address: 10.1.1.2) src = 10.1.1.1
    |<------|   HELLO (Link type: Symmetric link, Neighbor address: 10.1.1.1) src = 10.1.1.2
   \endverbatim
 */
class HelloRegressionTest : public TestCase
{
public:
  HelloRegressionTest ();
  ~HelloRegressionTest ();
private:
  /// Total simulation time





using namespace ns3;

class OlsrEmfTestCase : public TestCase
{
public:
  OlsrEmfTestCase ();
  virtual void DoRun (void);

}


class OlsrMidTestCase : public TestCase
{
public:
  OlsrMidTestCase ();
  virtual void DoRun (void);

}


class OlsrHelloTestCase : public TestCase
{
public:
  OlsrHelloTestCase ();
  virtual void DoRun (void);


}

class OlsrTcTestCase : public TestCase
{
public:
  OlsrTcTestCase ();
  virtual void DoRun (void);


}

class OlsrHnaTestCase : public TestCase
{
public:
  OlsrHnaTestCase ();
  virtual void DoRun (void);

  OlsrTestSuite ();
} g_olsrTestSuite;

OlsrTestSuite::OlsrTestSuite ()
  : TestSuite ("routing-olsr-header", UNIT)
{
  AddTestCase (new OlsrHnaTestCase (), TestCase::QUICK);




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

using namespace olsr;

/// Testcase for MPR computation mechanism
class OlsrMprTestCase : public TestCase
{
public:
  OlsrMprTestCase ();
  ~OlsrMprTestCase ();
  /// \brief Run test case
  virtual void DoRun (void);
  ;
};



{
  Ptr<RoutingProtocol> protocol = CreateObject<RoutingProtocol> ();
  protocol->m_mainAddress = Ipv4Address ("10.0.0.1");
  OlsrState & state = protocol->m_state;

  /*
   *  1 -- 2
   *  |    |
   *  3 -- 4
   *

  neigbor.neighborMainAddr = Ipv4Address ("10.0.0.2");
  protocol->m_state.InsertNeighborTuple (neigbor);
  neigbor.neighborMainAddr = Ipv4Address ("10.0.0.3");
  protocol->m_state.InsertNeighborTuple (neigbor);
  TwoHopNeighborTuple tuple;
  tuple.expirationTime = Seconds (3600);
  tuple.neighborMainAddr = Ipv4Address ("10.0.0.2");

  protocol->MprComputation ();
  NS_TEST_EXPECT_MSG_EQ (state.GetMprSet ().size (), 1, "An only address must be chosen.");
  /*
   *  1 -- 2 -- 5
   *  |    |
   *  3 -- 4
   *

  NS_TEST_EXPECT_MSG_EQ (mpr.size (), 1, "An only address must be chosen.");
  NS_TEST_EXPECT_MSG_EQ ((mpr.find ("10.0.0.2") != mpr.end ()), true, "Node 1 must select node 2 as MPR");
  /*
   *  1 -- 2 -- 5
   *  |    |
   *  3 -- 4
   *  |

  /*
   *  7 (OLSR_WILL_ALWAYS)
   *  |
   *  1 -- 2 -- 5
   *  |    |
   *  3 -- 4
   *  |

  /*
   *                7 <- WILL_ALWAYS
   *                |
   *      9 -- 8 -- 1 -- 2 -- 5
   *                |    |
   *           ^    3 -- 4
   *           |    |

  OlsrProtocolTestSuite ();
} g_olsrProtocolTestSuite;

OlsrProtocolTestSuite::OlsrProtocolTestSuite ()
  : TestSuite ("routing-olsr", UNIT)
{
  AddTestCase (new OlsrMprTestCase (), TestCase::QUICK);

(-)a/src/olsr/test/regression-test-suite.cc (-1 / +1 lines)

Lines 28-34	Link Here

class RegressionTestSuite : public TestSuite

class RegressionTestSuite : public TestSuite

public:

public:

  RegressionTestSuite () : TestSuite ("routing-olsr-regression", SYSTEM)

  RegressionTestSuite () : TestSuite ("routing-olsr-regression", SYSTEM)

    SetDataDir (NS_TEST_SOURCEDIR);

    SetDataDir (NS_TEST_SOURCEDIR);

    AddTestCase (new HelloRegressionTest, TestCase::QUICK);

    AddTestCase (new HelloRegressionTest, TestCase::QUICK);




#include "ns3/simple-net-device-helper.h"
#include "ns3/simple-net-device.h"

namespace ns3 {
namespace olsr {
namespace olsr
{

TcRegressionTest::TcRegressionTest () :
  TestCase ("Test OLSR Topology Control message generation"),
  m_time (Seconds (20)),
  m_countA (0), m_countB (0), m_countC (0)
{
}

TcRegressionTest::~TcRegressionTest ()
{
}


          NS_TEST_EXPECT_MSG_EQ (hello.linkMessages[1].neighborInterfaceAddresses[0], Ipv4Address ("10.1.1.1"), int(m_countA) << " - Neighbor.");
        }
    }
  m_countA++;
}

void

  receivedPacketProbe->RemoveHeader (msgHdr);
  const olsr::MessageHeader::Hello &hello = msgHdr.GetHello ();

  if (m_countB == 0 || m_countB == 2 || m_countB == 5 || m_countB == 6 || m_countB == 8
      || m_countB == 10 || m_countB == 13 || m_countB == 15 || m_countB == 17 || m_countB == 19)
    {
      NS_TEST_EXPECT_MSG_EQ (msgHdr.GetOriginatorAddress (), Ipv4Address ("10.1.1.3"), "Originator address.");
    }

      NS_TEST_EXPECT_MSG_EQ (hello.linkMessages[0].neighborInterfaceAddresses[0], Ipv4Address ("10.1.1.2"), int(m_countC) << " - Neighbor.");
    }

  m_countB++;
}

// Note: this is identical to ReceivePktProbeA, but the packet counter needs to be different.

          NS_TEST_EXPECT_MSG_EQ (hello.linkMessages[1].neighborInterfaceAddresses[0], Ipv4Address ("10.1.1.1"), int(m_countC) << " - Neighbor.");
        }
    }
  m_countC++;
}

}




#include "ns3/ipv4-raw-socket-impl.h"
#include "ns3/node-container.h"

namespace ns3 {
namespace olsr {
namespace olsr
{
/**
 * \ingroup olsr
 * \brief Less trivial test of OLSR Topology Control message generation
 *
 * This test simulates 3 Wi-Fi stations with chain topology and runs OLSR without any extra traffic.
 * It is expected that only second station will send TC messages.
 *
 * Expected trace (20 seconds, note random b-cast jitter):
   \verbatim
         1       2       3

  <------|------>|       |              HELLO (Link Type: MPR Link, Neighbor: 10.1.1.2) src = 10.1.1.1
         |       |<------|------>       HELLO (Link Type: MPR Link, Neighbor: 10.1.1.2) src = 10.1.1.3
         |<------|------>|              HELLO (Link Type: Symmetric, Neighbor: 10.1.1.3; Link Type: Symmetric, Neighbor: 10.1.1.1) src = 10.1.1.2
   \endverbatim
 */
class TcRegressionTest : public TestCase
{
public:
  TcRegressionTest ();
  ~TcRegressionTest ();
private:
  /// Total simulation time
  const Time m_time;

Return to bug 938