Attachment #1877 for bug #652

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

(-)a/src/internet/helper/ipv4-routing-helper.cc (+79 lines)

Lines 23-28	Link Here

#include "ns3/simulator.h"

#include "ns3/simulator.h"

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

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

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

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

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

#include "ns3/ipv4-interface.h"

#include "ns3/arp-cache.h"

#include "ns3/names.h"

#include "ipv4-routing-helper.h"

#include "ipv4-routing-helper.h"

namespace ns3 {

namespace ns3 {

Lines 82-85	Link Here

  Simulator::Schedule (printInterval, &Ipv4RoutingHelper::PrintEvery, this, printInterval, node, stream);

  Simulator::Schedule (printInterval, &Ipv4RoutingHelper::PrintEvery, this, printInterval, node, stream);

void

Ipv4RoutingHelper::PrintNeighborCacheAllAt (Time printTime, Ptr<OutputStreamWrapper> stream) const

  for (uint32_t i = 0; i < NodeList::GetNNodes (); i++)

      Ptr<Node> node = NodeList::GetNode (i);

      Simulator::Schedule (printTime, &Ipv4RoutingHelper::PrintArpCache, this, node, stream);

void

100

Ipv4RoutingHelper::PrintNeighborCacheAllEvery (Time printInterval, Ptr<OutputStreamWrapper> stream) const

101

102

  for (uint32_t i = 0; i < NodeList::GetNNodes (); i++)

103

104

      Ptr<Node> node = NodeList::GetNode (i);

105

      Simulator::Schedule (printInterval, &Ipv4RoutingHelper::PrintArpCacheEvery, this, printInterval, node, stream);

106

107

108

109

void

110

Ipv4RoutingHelper::PrintNeighborCacheAt (Time printTime, Ptr<Node> node, Ptr<OutputStreamWrapper> stream) const

111

112

  Simulator::Schedule (printTime, &Ipv4RoutingHelper::PrintArpCache, this, node, stream);

113

114

115

void

116

Ipv4RoutingHelper::PrintNeighborCacheEvery (Time printInterval,Ptr<Node> node, Ptr<OutputStreamWrapper> stream) const

117

118

  Simulator::Schedule (printInterval, &Ipv4RoutingHelper::PrintArpCacheEvery, this, printInterval, node, stream);

119

120

121

void

122

Ipv4RoutingHelper::PrintArpCache (Ptr<Node> node, Ptr<OutputStreamWrapper> stream) const

123

124

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

125

126

  *os << "ARP Cache of node ";

127

  std::string found = Names::FindName (node);

128

  if (Names::FindName (node) != "")

129

130

      *os << found;

131

132

  else

133

134

      *os << static_cast<int> (node->GetId ());

135

136

  *os << " at time " << Simulator::Now ().GetSeconds () << "\n";

137

138

  Ptr<Ipv4L3Protocol> ipv4 = node->GetObject<Ipv4L3Protocol> ();

139

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

140

141

      Ptr<ArpCache> arpCache = ipv4->GetInterface (i)->GetArpCache ();

142

      if (arpCache)

143

144

          arpCache->PrintArpCache (stream);

145

146

147

148

149

void

150

Ipv4RoutingHelper::PrintArpCacheEvery (Time printInterval, Ptr<Node> node, Ptr<OutputStreamWrapper> stream) const

151

152

  Ptr<Ipv4L3Protocol> ipv4 = node->GetObject<Ipv4L3Protocol> ();

153

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

154

155

      Ptr<ArpCache> arpCache = ipv4->GetInterface (i)->GetArpCache ();

156

      if (arpCache)

157

158

          arpCache->PrintArpCache (stream);

159

160

161

  Simulator::Schedule (printInterval, &Ipv4RoutingHelper::PrintArpCacheEvery, this, printInterval, node, stream);

162

163

} // namespace ns3

164

} // namespace ns3




  void PrintRoutingTableEvery (Time printInterval, Ptr<Node> node, Ptr<OutputStreamWrapper> stream) const;

  /**
   * \brief prints the neighbor cache of all nodes at a particular time.
   * \param printTime the time at which the neighbor cache is supposed to be printed.
   * \param stream The output stream object to use
   *
   * This method calls the PrintArpCache() method of the
   * ArpCache associated with each Ipv4Interface stored in the Ipv4 object, for all nodes at the
   * specified time. The output format is similar to:
   * \verbatim
     10.1.1.2 dev 1 lladdr 00-06-00:00:00:00:00:02 REACHABLE
     \endverbatim
   * Note that the MAC address is printed as "type"-"size"-"actual address"
   */
  void PrintNeighborCacheAllAt (Time printTime, Ptr<OutputStreamWrapper> stream) const;

  /**
   * \brief prints the neighbor cache of all nodes at regular intervals specified by user.
   * \param printInterval the time interval for which the neighbor cache is supposed to be printed.
   * \param stream The output stream object to use
   *
   * This method calls the PrintArpCache() method of the
   * ArpCache associated with each Ipv4Interface stored in the Ipv4 object, for all nodes at the
   * specified time. The output format is similar to:
   * \verbatim
     10.1.1.2 dev 1 lladdr 00-06-00:00:00:00:00:02 REACHABLE
     \endverbatim
   * Note that the MAC address is printed as "type"-"size"-"actual address"
   */
  void PrintNeighborCacheAllEvery (Time printInterval, Ptr<OutputStreamWrapper> stream) const;

  /**
   * \brief prints the neighbor cache of a node at a particular time.
   * \param printTime the time at which the neighbor cache is supposed to be printed.
   * \param node The node ptr for which we need the neighbor cache to be printed
   * \param stream The output stream object to use
   *
   * This method calls the PrintArpCache() method of the
   * ArpCache associated with each Ipv4Interface stored in the Ipv4 object, for all nodes at the
   * specified time. The output format is similar to:
   * \verbatim
     10.1.1.2 dev 1 lladdr 00-06-00:00:00:00:00:02 REACHABLE
     \endverbatim
   * Note that the MAC address is printed as "type"-"size"-"actual address"
   */
  void PrintNeighborCacheAt (Time printTime, Ptr<Node> node, Ptr<OutputStreamWrapper> stream) const;

  /**
   * \brief prints the neighbor cache of a node at regular intervals specified by user.
   * \param printInterval the time interval for which the neighbor cache is supposed to be printed.
   * \param node The node ptr for which we need the neighbor cache to be printed
   * \param stream The output stream object to use
   *
   * This method calls the PrintArpCache() method of the
   * ArpCache associated with each Ipv4Interface stored in the Ipv4 object, for all nodes at the
   * specified time. The output format is similar to:
   * \verbatim
     10.1.1.2 dev 1 lladdr 00-06-00:00:00:00:00:02 REACHABLE
     \endverbatim
   * Note that the MAC address is printed as "type"-"size"-"actual address"
   */
   void PrintNeighborCacheEvery (Time printInterval, Ptr<Node> node, Ptr<OutputStreamWrapper> stream) const;

  /**
   * \brief Request a specified routing protocol &lt;T&gt; from Ipv4RoutingProtocol protocol
   *
   * If protocol is Ipv4ListRouting, then protocol will be searched in the list,

   * \param stream The output stream object to use
   *
   * This method calls the PrintRoutingTable() method of the
   * Ipv4RoutingProtocol stored in the Ipv4 object;
   * the output format is routing protocol-specific.
   */
  void Print (Ptr<Node> node, Ptr<OutputStreamWrapper> stream) const;

   * \param stream The output stream object to use
   *
   * This method calls the PrintRoutingTable() method of the
   * Ipv4RoutingProtocol stored in the Ipv4 object, for the selected node
   * at the specified interval; the output format is routing protocol-specific.
   */
  void PrintEvery (Time printInterval, Ptr<Node> node, Ptr<OutputStreamWrapper> stream) const;

  /**
   * \internal
   *
   * \brief prints the neighbor cache of a node.
   * \param node The node ptr for which we need the neighbor cache to be printed
   * \param stream The output stream object to use
   *
   * This method calls the PrintArpCache() method of the
   * ArpCache associated with each Ipv4Interface stored in the Ipv4 object, for all nodes at the
   * specified time. The output format is similar to:
   * \verbatim
     10.1.1.2 dev 1 lladdr 00-06-00:00:00:00:00:02 REACHABLE
     \endverbatim
   * Note that the MAC address is printed as "type"-"size"-"actual address"
   */
  void PrintArpCache (Ptr<Node> node, Ptr<OutputStreamWrapper> stream) const;

  /**
   * \internal
   *
   * \brief prints the neighbor cache of a node at regular intervals specified by user.
   * \param printInterval the time interval for which the neighbor cache is supposed to be printed.
   * \param node The node ptr for which we need the neighbor cache to be printed
   * \param stream The output stream object to use
   *
   * This method calls the PrintArpCache() method of the
   * ArpCache associated with each Ipv4Interface stored in the Ipv4 object, for all nodes at the
   * specified time. The output format is similar to:
   * \verbatim
     10.1.1.2 dev 1 lladdr 00-06-00:00:00:00:00:02 REACHABLE
     \endverbatim
   * Note that the MAC address is printed as "type"-"size"-"actual address"
   */
  void PrintArpCacheEvery (Time printInterval, Ptr<Node> node, Ptr<OutputStreamWrapper> stream) const;
};






#include "ns3/log.h"
#include "ns3/node.h"
#include "ns3/trace-source-accessor.h"
#include "ns3/names.h"

#include "arp-cache.h"
#include "arp-header.h"

    }
}

void
ArpCache::PrintArpCache (Ptr<OutputStreamWrapper> stream)
{
  NS_LOG_FUNCTION (this << stream);
  std::ostream* os = stream->GetStream ();

  for (CacheI i = m_arpCache.begin (); i != m_arpCache.end (); i++)
    {
      *os << i->first << " dev ";
      std::string found = Names::FindName (m_device);
      if (Names::FindName (m_device) != "")
        {
          *os << found;
        }
      else
        {
          *os << static_cast<int> (m_device->GetIfIndex ());
        }

      *os << " lladdr " << i->second->GetMacAddress ();

      if (i->second->IsAlive ())
        {
          *os << " REACHABLE\n";
        }
      else if (i->second->IsWaitReply ())
        {
          *os << " DELAY\n";
        }
      else
        {
          *os << " STALE\n";
        }
    }
}


ArpCache::Entry *
ArpCache::Lookup (Ipv4Address to)
{




#include "ns3/object.h"
#include "ns3/traced-callback.h"
#include "ns3/sgi-hashmap.h"
#include "ns3/output-stream-wrapper.h"

namespace ns3 {


  /**
   * \brief Set the NetDevice and Ipv4Interface associated with the ArpCache
   *
   * \param device The hardware NetDevice associated with this ARP cache
   * \param interface the Ipv4Interface associated with this ARP cache
   */
  void SetDevice (Ptr<NetDevice> device, Ptr<Ipv4Interface> interface);
  /**

  void Flush (void);

  /**
   * \brief Print the ARP cache entries
   *
   * \param stream the ostream the ARP cache entries is printed to
   */
  void PrintArpCache (Ptr<OutputStreamWrapper> stream);

  /**
   * \brief A record that that holds information about an ArpCache entry
   */
  class Entry {

Return to bug 652