Attachment #1878 for bug #652

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

(-)a/src/internet/helper/ipv4-routing-helper.cc (+93 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

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

153

154

  *os << "ARP Cache of node ";

155

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

156

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

157

158

      *os << found;

159

160

  else

161

162

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

163

164

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

165

166

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

167

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

168

169

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

170

      if (arpCache)

171

172

          arpCache->PrintArpCache (stream);

173

174

175

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

176

177

} // namespace ns3

178

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



(-)a/src/internet/helper/ipv6-routing-helper.cc (+93 lines)

Lines 23-28	Link Here

#include "ns3/simulator.h"

#include "ns3/simulator.h"

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

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

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

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

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

#include "ns3/ipv6-interface.h"

#include "ns3/ndisc-cache.h"

#include "ns3/names.h"

#include "ipv6-routing-helper.h"

#include "ipv6-routing-helper.h"

namespace ns3 {

namespace ns3 {

Lines 82-85	Link Here

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

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

void

Ipv6RoutingHelper::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, &Ipv6RoutingHelper::PrintNdiscCache, this, node, stream);

void

100

Ipv6RoutingHelper::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, &Ipv6RoutingHelper::PrintNdiscCacheEvery, this, printInterval, node, stream);

106

107

108

109

void

110

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

111

112

  Simulator::Schedule (printTime, &Ipv6RoutingHelper::PrintNdiscCache, this, node, stream);

113

114

115

void

116

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

117

118

  Simulator::Schedule (printInterval, &Ipv6RoutingHelper::PrintNdiscCacheEvery, this, printInterval, node, stream);

119

120

121

void

122

Ipv6RoutingHelper::PrintNdiscCache (Ptr<Node> node, Ptr<OutputStreamWrapper> stream) const

123

124

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

125

126

  *os << "NDISC 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<Ipv6L3Protocol> ipv6 = node->GetObject<Ipv6L3Protocol> ();

139

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

140

141

      Ptr<NdiscCache> ndiscCache = ipv6->GetInterface (i)->GetNdiscCache ();

142

      if (ndiscCache)

143

144

          ndiscCache->PrintNdiscCache (stream);

145

146

147

148

149

void

150

Ipv6RoutingHelper::PrintNdiscCacheEvery (Time printInterval, Ptr<Node> node, Ptr<OutputStreamWrapper> stream) const

151

152

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

153

154

  *os << "NDISC Cache of node ";

155

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

156

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

157

158

      *os << found;

159

160

  else

161

162

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

163

164

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

165

166

  Ptr<Ipv6L3Protocol> ipv6 = node->GetObject<Ipv6L3Protocol> ();

167

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

168

169

      Ptr<NdiscCache> ndiscCache = ipv6->GetInterface (i)->GetNdiscCache ();

170

      if (ndiscCache)

171

172

          ndiscCache->PrintNdiscCache (stream);

173

174

175

  Simulator::Schedule (printInterval, &Ipv6RoutingHelper::PrintNdiscCacheEvery, this, printInterval, node, stream);

176

177

} // namespace ns3

178

} // 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 PrintNdiscCache() method of the
   * NdiscCache associated with each Ipv6Interface stored in the Ipv6 object, for all nodes at the
   * specified time. The output format is similar to:
   * \verbatim
     2001:db8::f00d:beef:cafe 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 PrintNdiscCache() method of the
   * NdiscCache associated with each Ipv6Interface stored in the Ipv6 object, for all nodes at the
   * specified time. The output format is similar to:
   * \verbatim
     2001:db8::f00d:beef:cafe 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 PrintNdiscCache() method of the
   * NdiscCache associated with each Ipv6Interface stored in the Ipv6 object, for all nodes at the
   * specified time. The output format is similar to:
   * \verbatim
     2001:db8::f00d:beef:cafe 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 PrintNdiscCache() method of the
   * NdiscCache associated with each Ipv6Interface stored in the Ipv6 object, for all nodes at the
   * specified time. The output format is similar to:
   * \verbatim
     2001:db8::f00d:beef:cafe 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 Ipv6RoutingProtocol protocol
   *
   * If protocol is Ipv6ListRouting, then protocol will be searched in the list,

   * 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 PrintNdiscCache() method of the
   * NdiscCache associated with each Ipv6Interface stored in the Ipv6 object, for all nodes at the
   * specified time. The output format is similar to:
   * \verbatim
     2001:db8::f00d:beef:cafe 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 PrintNdiscCache (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 PrintNdiscCache() method of the
   * NdiscCache associated with each Ipv6Interface stored in the Ipv6 object, for all nodes at the
   * specified time. The output format is similar to:
   * \verbatim
     2001:db8::f00d:beef:cafe 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 PrintNdiscCacheEvery (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 {

(-)a/src/internet/model/ipv4-interface.h (+1 lines)

Lines 78-83	Link Here

   * \returns the underlying NetDevice. This method cannot return zero.

   * \returns the underlying NetDevice. This method cannot return zero.

*/

*/

  Ptr<NetDevice> GetDevice (void) const;

  Ptr<NetDevice> GetDevice (void) const;

/**

/**

   * \return ARP cache used by this interface

   * \return ARP cache used by this interface

*/

*/

(-)a/src/internet/model/ipv6-interface.cc (+6 lines)

Lines 505-509	Link Here

505

  /* not found, maybe address has expired */

505

  /* not found, maybe address has expired */

506

507

508

Ptr<NdiscCache> Ipv6Interface::GetNdiscCache () const

509

510

  NS_LOG_FUNCTION (this);

511

  return m_ndCache;

512

513

508

} /* namespace ns3 */

514

} /* namespace ns3 */

509

515

(-)a/src/internet/model/ipv6-interface.h (+6 lines)

Lines 250-255	Link Here

250

*/

250

*/

251

  void SetNsDadUid (Ipv6Address address, uint32_t uid);

251

  void SetNsDadUid (Ipv6Address address, uint32_t uid);

252

253

/**

254

   * \return NDISC cache used by this interface

255

*/

256

  Ptr<NdiscCache> GetNdiscCache () const;

257

258

253

protected:

259

protected:

254

/**

260

/**

255

   * \brief Dispose this object.

261

   * \brief Dispose this object.




#include "ns3/log.h"
#include "ns3/uinteger.h"
#include "ns3/node.h"
#include "ns3/names.h"

#include "ipv6-l3-protocol.h" 
#include "icmpv6-l4-protocol.h"

  return m_unresQlen;
}

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

  for (CacheI i = m_ndCache.begin (); i != m_ndCache.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->IsReachable ())
        {
          *os << " REACHABLE\n";
        }
      else if (i->second->IsDelay ())
        {
          *os << " DELAY\n";
        }
      else if (i->second->IsIncomplete ())
        {
          *os << " INCOMPLETE\n";
        }
      else if (i->second->IsProbe ())
        {
          *os << " PROBE\n";
        }
      else
        {
          *os << " STALE\n";
        }
    }
}

NdiscCache::Entry::Entry (NdiscCache* nd)
  : m_ndCache (nd),
    m_waiting (),

(-)a/src/internet/model/ndisc-cache.h (-1 / +8 lines)

Lines 22-28	Link Here

#define NDISC_CACHE_H

#define NDISC_CACHE_H

#include <stdint.h>

#include <stdint.h>

#include <list>

#include <list>

#include "ns3/packet.h"

#include "ns3/packet.h"

Lines 32-37	Link Here

#include "ns3/ptr.h"

#include "ns3/ptr.h"

#include "ns3/timer.h"

#include "ns3/timer.h"

#include "ns3/sgi-hashmap.h"

#include "ns3/sgi-hashmap.h"

#include "ns3/output-stream-wrapper.h"

namespace ns3

namespace ns3

Lines 125-130	Link Here

125

  void SetDevice (Ptr<NetDevice> device, Ptr<Ipv6Interface> interface);

125

  void SetDevice (Ptr<NetDevice> device, Ptr<Ipv6Interface> interface);

126

127

/**

127

/**

128

   * \brief Print the NDISC cache entries

129

130

   * \param stream the ostream the NDISC cache entries is printed to

131

*/

132

  void PrintNdiscCache (Ptr<OutputStreamWrapper> stream);

133

134

/**

128

   * \class Entry

135

   * \class Entry

129

   * \brief A record that holds information about an NdiscCache entry.

136

   * \brief A record that holds information about an NdiscCache entry.

130

*/

137

*/

Return to bug 652