Attachment #1921 for bug #2016

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

(-)a/examples/ipv6/radvd.cc (-1 / +6 lines)

Lines 115-124	Link Here

115

116

  /* radvd configuration */

116

  /* radvd configuration */

117

  RadvdHelper radvdHelper;

117

  RadvdHelper radvdHelper;

118

  /* R interface (n0 - R) */

119

  /* R interface (n0 - R) */

119

  radvdHelper.AddAnnouncedPrefix(iic1.GetInterfaceIndex (1), Ipv6Address("2001:1::0"), 64);

120

  /* n0 will receive unsolicited (periodic) RA */

121

  radvdHelper.AddAnnouncedPrefix (iic1.GetInterfaceIndex (1), Ipv6Address("2001:1::0"), 64);

122

120

  /* R interface (R - n1) */

123

  /* R interface (R - n1) */

124

  /* n1 will have to use RS, as RA are not sent automatically */

121

  radvdHelper.AddAnnouncedPrefix(iic2.GetInterfaceIndex (1), Ipv6Address("2001:2::0"), 64);

125

  radvdHelper.AddAnnouncedPrefix(iic2.GetInterfaceIndex (1), Ipv6Address("2001:2::0"), 64);

126

  radvdHelper.GetRadvdInterface (iic2.GetInterfaceIndex (1))->SetSendAdvert (false);

122

127

123

  ApplicationContainer radvdApps = radvdHelper.Install (r);

128

  ApplicationContainer radvdApps = radvdHelper.Install (r);

124

  radvdApps.Start (Seconds (1.0));

129

  radvdApps.Start (Seconds (1.0));




    return

def register_Ns3Int64x64_t_methods(root_module, cls):
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('!=')
    cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right'))
    cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right'))

    cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', u'right'))
    cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', u'right'))
    cls.add_output_stream_operator()
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('==')
    cls.add_binary_comparison_operator('>=')
    ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor]

    return

def register_Ns3Time_methods(root_module, cls):
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('!=')
    cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right'))
    cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right'))

    cls.add_binary_comparison_operator('>')
    cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', u'right'))
    cls.add_output_stream_operator()
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('==')
    cls.add_binary_comparison_operator('>=')
    ## nstime.h (module 'core'): ns3::Time::Time() [constructor]

    cls.add_constructor([param('ns3::EnumChecker const &', 'arg0')])
    ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker() [constructor]
    cls.add_constructor([])
    ## enum.h (module 'core'): void ns3::EnumChecker::Add(int value, std::string name) [member function]
    cls.add_method('Add', 
                   'void', 
                   [param('int', 'value'), param('std::string', 'name')])
    ## enum.h (module 'core'): void ns3::EnumChecker::AddDefault(int value, std::string name) [member function]
    cls.add_method('AddDefault', 
                   'void', 
                   [param('int', 'value'), param('std::string', 'name')])
    ## enum.h (module 'core'): bool ns3::EnumChecker::Check(ns3::AttributeValue const & value) const [member function]
    cls.add_method('Check', 
                   'bool', 

    cls.add_constructor([param('ns3::EnumValue const &', 'arg0')])
    ## enum.h (module 'core'): ns3::EnumValue::EnumValue() [constructor]
    cls.add_constructor([])
    ## enum.h (module 'core'): ns3::EnumValue::EnumValue(int value) [constructor]
    cls.add_constructor([param('int', 'value')])
    ## enum.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::EnumValue::Copy() const [member function]
    cls.add_method('Copy', 
                   'ns3::Ptr< ns3::AttributeValue >', 

                   'std::string', 
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                   is_const=True, is_virtual=True)
    ## enum.h (module 'core'): void ns3::EnumValue::Set(int value) [member function]
    cls.add_method('Set', 
                   'void', 
                   [param('int', 'value')])
    return

def register_Ns3ErlangRandomVariable_methods(root_module, cls):

                   'ns3::TypeId', 
                   [], 
                   is_static=True)
    ## radvd.h (module 'applications'): ns3::Radvd::MAX_INITIAL_RTR_ADVERTISEMENTS [variable]
    cls.add_static_attribute('MAX_INITIAL_RTR_ADVERTISEMENTS', 'uint32_t const', is_const=True)
    ## radvd.h (module 'applications'): ns3::Radvd::MAX_INITIAL_RTR_ADVERT_INTERVAL [variable]
    cls.add_static_attribute('MAX_INITIAL_RTR_ADVERT_INTERVAL', 'uint32_t const', is_const=True)
    ## radvd.h (module 'applications'): ns3::Radvd::MAX_RA_DELAY_TIME [variable]
    cls.add_static_attribute('MAX_RA_DELAY_TIME', 'uint32_t const', is_const=True)
    ## radvd.h (module 'applications'): ns3::Radvd::MIN_DELAY_BETWEEN_RAS [variable]
    cls.add_static_attribute('MIN_DELAY_BETWEEN_RAS', 'uint32_t const', is_const=True)
    ## radvd.h (module 'applications'): void ns3::Radvd::DoDispose() [member function]
    cls.add_method('DoDispose', 
                   'void', 

                   'uint32_t', 
                   [], 
                   is_const=True)
    ## radvd-interface.h (module 'applications'): ns3::Time ns3::RadvdInterface::GetLastRaTxTime() [member function]
    cls.add_method('GetLastRaTxTime', 
                   'ns3::Time', 
                   [])
    ## radvd-interface.h (module 'applications'): uint32_t ns3::RadvdInterface::GetLinkMtu() const [member function]
    cls.add_method('GetLinkMtu', 
                   'uint32_t', 

                   'bool', 
                   [], 
                   is_const=True)
    ## radvd-interface.h (module 'applications'): bool ns3::RadvdInterface::IsInitialRtrAdv() [member function]
    cls.add_method('IsInitialRtrAdv', 
                   'bool', 
                   [])
    ## radvd-interface.h (module 'applications'): bool ns3::RadvdInterface::IsIntervalOpt() const [member function]
    cls.add_method('IsIntervalOpt', 
                   'bool', 

    cls.add_method('SetIntervalOpt', 
                   'void', 
                   [param('bool', 'intervalOpt')])
    ## radvd-interface.h (module 'applications'): void ns3::RadvdInterface::SetLastRaTxTime(ns3::Time now) [member function]
    cls.add_method('SetLastRaTxTime', 
                   'void', 
                   [param('ns3::Time', 'now')])
    ## radvd-interface.h (module 'applications'): void ns3::RadvdInterface::SetLinkMtu(uint32_t linkMtu) [member function]
    cls.add_method('SetLinkMtu', 
                   'void', 




    return

def register_Ns3Int64x64_t_methods(root_module, cls):
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('!=')
    cls.add_inplace_numeric_operator('+=', param('ns3::int64x64_t const &', u'right'))
    cls.add_binary_numeric_operator('*', root_module['ns3::int64x64_t'], root_module['ns3::int64x64_t'], param('ns3::int64x64_t const &', u'right'))

    cls.add_inplace_numeric_operator('-=', param('ns3::int64x64_t const &', u'right'))
    cls.add_inplace_numeric_operator('/=', param('ns3::int64x64_t const &', u'right'))
    cls.add_output_stream_operator()
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('==')
    cls.add_binary_comparison_operator('>=')
    ## int64x64-double.h (module 'core'): ns3::int64x64_t::int64x64_t() [constructor]

    return

def register_Ns3Time_methods(root_module, cls):
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('!=')
    cls.add_inplace_numeric_operator('+=', param('ns3::Time const &', u'right'))
    cls.add_binary_numeric_operator('*', root_module['ns3::Time'], root_module['ns3::Time'], param('int64_t const &', u'right'))

    cls.add_binary_comparison_operator('>')
    cls.add_inplace_numeric_operator('-=', param('ns3::Time const &', u'right'))
    cls.add_output_stream_operator()
    cls.add_binary_comparison_operator('<=')
    cls.add_binary_comparison_operator('==')
    cls.add_binary_comparison_operator('>=')
    ## nstime.h (module 'core'): ns3::Time::Time() [constructor]

    cls.add_constructor([param('ns3::EnumChecker const &', 'arg0')])
    ## enum.h (module 'core'): ns3::EnumChecker::EnumChecker() [constructor]
    cls.add_constructor([])
    ## enum.h (module 'core'): void ns3::EnumChecker::Add(int value, std::string name) [member function]
    cls.add_method('Add', 
                   'void', 
                   [param('int', 'value'), param('std::string', 'name')])
    ## enum.h (module 'core'): void ns3::EnumChecker::AddDefault(int value, std::string name) [member function]
    cls.add_method('AddDefault', 
                   'void', 
                   [param('int', 'value'), param('std::string', 'name')])
    ## enum.h (module 'core'): bool ns3::EnumChecker::Check(ns3::AttributeValue const & value) const [member function]
    cls.add_method('Check', 
                   'bool', 

    cls.add_constructor([param('ns3::EnumValue const &', 'arg0')])
    ## enum.h (module 'core'): ns3::EnumValue::EnumValue() [constructor]
    cls.add_constructor([])
    ## enum.h (module 'core'): ns3::EnumValue::EnumValue(int value) [constructor]
    cls.add_constructor([param('int', 'value')])
    ## enum.h (module 'core'): ns3::Ptr<ns3::AttributeValue> ns3::EnumValue::Copy() const [member function]
    cls.add_method('Copy', 
                   'ns3::Ptr< ns3::AttributeValue >', 

                   'std::string', 
                   [param('ns3::Ptr< ns3::AttributeChecker const >', 'checker')], 
                   is_const=True, is_virtual=True)
    ## enum.h (module 'core'): void ns3::EnumValue::Set(int value) [member function]
    cls.add_method('Set', 
                   'void', 
                   [param('int', 'value')])
    return

def register_Ns3ErlangRandomVariable_methods(root_module, cls):

                   'ns3::TypeId', 
                   [], 
                   is_static=True)
    ## radvd.h (module 'applications'): ns3::Radvd::MAX_INITIAL_RTR_ADVERTISEMENTS [variable]
    cls.add_static_attribute('MAX_INITIAL_RTR_ADVERTISEMENTS', 'uint32_t const', is_const=True)
    ## radvd.h (module 'applications'): ns3::Radvd::MAX_INITIAL_RTR_ADVERT_INTERVAL [variable]
    cls.add_static_attribute('MAX_INITIAL_RTR_ADVERT_INTERVAL', 'uint32_t const', is_const=True)
    ## radvd.h (module 'applications'): ns3::Radvd::MAX_RA_DELAY_TIME [variable]
    cls.add_static_attribute('MAX_RA_DELAY_TIME', 'uint32_t const', is_const=True)
    ## radvd.h (module 'applications'): ns3::Radvd::MIN_DELAY_BETWEEN_RAS [variable]
    cls.add_static_attribute('MIN_DELAY_BETWEEN_RAS', 'uint32_t const', is_const=True)
    ## radvd.h (module 'applications'): void ns3::Radvd::DoDispose() [member function]
    cls.add_method('DoDispose', 
                   'void', 

                   'uint32_t', 
                   [], 
                   is_const=True)
    ## radvd-interface.h (module 'applications'): ns3::Time ns3::RadvdInterface::GetLastRaTxTime() [member function]
    cls.add_method('GetLastRaTxTime', 
                   'ns3::Time', 
                   [])
    ## radvd-interface.h (module 'applications'): uint32_t ns3::RadvdInterface::GetLinkMtu() const [member function]
    cls.add_method('GetLinkMtu', 
                   'uint32_t', 

                   'bool', 
                   [], 
                   is_const=True)
    ## radvd-interface.h (module 'applications'): bool ns3::RadvdInterface::IsInitialRtrAdv() [member function]
    cls.add_method('IsInitialRtrAdv', 
                   'bool', 
                   [])
    ## radvd-interface.h (module 'applications'): bool ns3::RadvdInterface::IsIntervalOpt() const [member function]
    cls.add_method('IsIntervalOpt', 
                   'bool', 

    cls.add_method('SetIntervalOpt', 
                   'void', 
                   [param('bool', 'intervalOpt')])
    ## radvd-interface.h (module 'applications'): void ns3::RadvdInterface::SetLastRaTxTime(ns3::Time now) [member function]
    cls.add_method('SetLastRaTxTime', 
                   'void', 
                   [param('ns3::Time', 'now')])
    ## radvd-interface.h (module 'applications'): void ns3::RadvdInterface::SetLinkMtu(uint32_t linkMtu) [member function]
    cls.add_method('SetLinkMtu', 
                   'void', 




  m_homeAgentPreference = 0;
  m_mobRtrSupportFlag = false;
  m_intervalOpt = false;
  m_initialRtrAdvertisementsLeft = 3;
}

RadvdInterface::RadvdInterface (uint32_t interface, uint32_t maxRtrAdvInterval, uint32_t minRtrAdvInterval)

  m_homeAgentPreference = 0;
  m_mobRtrSupportFlag = false;
  m_intervalOpt = false;
  m_initialRtrAdvertisementsLeft = 3;
}

RadvdInterface::~RadvdInterface ()

  NS_LOG_FUNCTION (this << intervalOpt);
  m_intervalOpt = intervalOpt;
}

Time RadvdInterface::GetLastRaTxTime ()
{
  return m_lastSendTime;
}

void RadvdInterface::SetLastRaTxTime (Time now)
{
  m_lastSendTime = now;
  if (m_initialRtrAdvertisementsLeft)
    {
      m_initialRtrAdvertisementsLeft --;
    }
}

bool RadvdInterface::IsInitialRtrAdv ()
{
  return m_initialRtrAdvertisementsLeft;
}

} /* namespace ns3 */






#include <list>
#include "ns3/simple-ref-count.h"
#include "ns3/nstime.h"
#include "radvd-prefix.h"

namespace ns3

   */
  void SetIntervalOpt (bool intervalOpt);

  /**
   * \brief Get the last time a RA has been sent.
   * \returns the last RA send time
   */
  Time GetLastRaTxTime ();

  /**
   * \brief Set the last RA send time. It also decrements the initial Rtr Advertisements counter.
   * \param the last RA send time
   */
  void SetLastRaTxTime (Time now);

  /**
   * \brief Checks if the interface is subject to the initial Rtr Advertisements rule.
   * \returns true if the initial Rtr Advertisements counter is greater than zero.
   */
  bool IsInitialRtrAdv ();

private:

  /**

   * \brief Flag to add Advertisement Interval option in RA.
   */
  bool m_intervalOpt;

  /**
   * \brief Last RA send time.
   */
  Time m_lastSendTime;

  /**
   * \brief Number of fast announcement to do
   */
  uint8_t m_initialRtrAdvertisementsLeft;

};

} /* namespace ns3 */

(-)a/src/applications/model/radvd.cc (-44 / +113 lines)

Lines 21-26	Link Here

*/

*/

#include "ns3/log.h"

#include "ns3/log.h"

#include "ns3/abort.h"

#include "ns3/ipv6-address.h"

#include "ns3/ipv6-address.h"

#include "ns3/nstime.h"

#include "ns3/nstime.h"

#include "ns3/simulator.h"

#include "ns3/simulator.h"

Lines 29-35	Link Here

#include "ns3/uinteger.h"

#include "ns3/uinteger.h"

#include "ns3/inet6-socket-address.h"

#include "ns3/inet6-socket-address.h"

#include "ns3/ipv6.h"

#include "ns3/ipv6.h"

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

#include "ns3/ipv6-interface.h"

#include "ns3/ipv6-raw-socket-factory.h"

#include "ns3/ipv6-raw-socket-factory.h"

#include "ns3/ipv6-packet-info-tag.h"

#include "ns3/ipv6-header.h"

#include "ns3/ipv6-header.h"

#include "ns3/icmpv6-header.h"

#include "ns3/icmpv6-header.h"

#include "ns3/string.h"

#include "ns3/string.h"

Lines 71-82	Link Here

      *it = 0;

      *it = 0;

  m_configurations.clear ();

  m_configurations.clear ();

  m_socket = 0;

  m_recvSocket = 0;

void Radvd::DoDispose ()

void Radvd::DoDispose ()

  NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

  m_recvSocket->Close ();

  m_recvSocket = 0;

  for (SocketMapI it = m_sendSockets.begin (); it != m_sendSockets.end (); ++it)

      it->second->Close ();

      it->second = 0;

  Application::DoDispose ();

  Application::DoDispose ();

Lines 84-106	Link Here

  NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

100

  if (!m_socket)

101

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

102

103

  if (!m_recvSocket)

104

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

105

      m_recvSocket = Socket::CreateSocket (GetNode (), tid);

      m_socket = Socket::CreateSocket (GetNode (), tid);

106

      NS_ASSERT (m_socket);

107

      NS_ASSERT (m_recvSocket);

108

      /*    m_socket->Bind (Inet6SocketAddress (m_localAddress, 0)); */

109

      m_recvSocket->Bind (Inet6SocketAddress (Ipv6Address::GetAllRoutersMulticast (), 0));

      /*    m_socket->Connect (Inet6SocketAddress (Ipv6Address::GetAllNodesMulticast (), 0)); */

110

      m_recvSocket->SetAttribute ("Protocol", UintegerValue (Ipv6Header::IPV6_ICMPV6));

      m_socket->SetAttribute ("Protocol", UintegerValue (Ipv6Header::IPV6_ICMPV6));

111

      m_recvSocket->SetRecvCallback (MakeCallback (&Radvd::HandleRead, this));

      m_socket->SetRecvCallback (MakeCallback (&Radvd::HandleRead, this));

112

      m_recvSocket->ShutdownSend ();

113

      m_recvSocket->SetRecvPktInfo (true);

114

115

100

  for (RadvdInterfaceListCI it = m_configurations.begin (); it != m_configurations.end (); it++)

116

  for (RadvdInterfaceListCI it = m_configurations.begin (); it != m_configurations.end (); it++)

101

117

102

      m_eventIds[(*it)->GetInterface ()] = EventId ();

118

      if ((*it)->IsSendAdvert ())

103

      ScheduleTransmit (Seconds (0.), (*it), m_eventIds[(*it)->GetInterface ()], Ipv6Address::GetAllNodesMulticast (), true);

119

120

          m_unsolicitedEventIds[(*it)->GetInterface ()] = Simulator::Schedule (Seconds (0.), &Radvd::Send,

121

                                                                               this, (*it), Ipv6Address::GetAllNodesMulticast (), true);

122

123

124

      if (m_sendSockets.find ((*it)->GetInterface ()) == m_sendSockets.end ())

125

126

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

127

          Ptr<Ipv6Interface> iFace = ipv6->GetInterface ((*it)->GetInterface ());

128

129

          m_sendSockets[(*it)->GetInterface ()] = Socket::CreateSocket (GetNode (), tid);

130

          m_sendSockets[(*it)->GetInterface ()]->Bind (Inet6SocketAddress (iFace->GetLinkLocalAddress ().GetAddress (), 0));

131

          m_sendSockets[(*it)->GetInterface ()]->SetAttribute ("Protocol", UintegerValue (Ipv6Header::IPV6_ICMPV6));

132

          m_sendSockets[(*it)->GetInterface ()]->ShutdownRecv ();

133

104

134

105

135

106

136

Lines 108-123	Link Here

108

138

109

  NS_LOG_FUNCTION (this);

139

  NS_LOG_FUNCTION (this);

110

140

111

  if (m_socket)

141

  if (m_recvSocket)

112

142

113

      m_socket->SetRecvCallback (MakeNullCallback<void, Ptr<Socket> > ());

143

      m_recvSocket->SetRecvCallback (MakeNullCallback<void, Ptr<Socket> > ());

114

144

115

145

116

  for (EventIdMapI it = m_eventIds.begin (); it != m_eventIds.end (); ++it)

146

  for (EventIdMapI it = m_unsolicitedEventIds.begin (); it != m_unsolicitedEventIds.end (); ++it)

117

147

118

      Simulator::Cancel ((*it).second);

148

      Simulator::Cancel ((*it).second);

119

149

120

  m_eventIds.clear ();

150

  m_unsolicitedEventIds.clear ();

151

152

  for (EventIdMapI it = m_solicitedEventIds.begin (); it != m_solicitedEventIds.end (); ++it)

153

154

      Simulator::Cancel ((*it).second);

155

156

  m_solicitedEventIds.clear ();

121

157

122

158

123

void Radvd::AddConfiguration (Ptr<RadvdInterface> routerInterface)

159

void Radvd::AddConfiguration (Ptr<RadvdInterface> routerInterface)

Lines 134-159	Link Here

134

  return 1;

170

  return 1;

135

171

136

172

137

void Radvd::ScheduleTransmit (Time dt, Ptr<RadvdInterface> config, EventId& eventId, Ipv6Address dst, bool reschedule)

138

139

  NS_LOG_FUNCTION (this << dt << config << &eventId << dst << reschedule);

140

  eventId = Simulator::Schedule (dt, &Radvd::Send, this, config, dst, reschedule);

141

142

143

void Radvd::Send (Ptr<RadvdInterface> config, Ipv6Address dst, bool reschedule)

173

void Radvd::Send (Ptr<RadvdInterface> config, Ipv6Address dst, bool reschedule)

144

174

145

  NS_LOG_FUNCTION (this << dst << reschedule);

175

  NS_LOG_FUNCTION (this << dst << reschedule);

146

  NS_ASSERT (m_eventIds[config->GetInterface ()].IsExpired ());

176

177

  if (reschedule == true)

178

179

      config->SetLastRaTxTime (Simulator::Now ());

180

181

147

  Icmpv6RA raHdr;

182

  Icmpv6RA raHdr;

148

  Icmpv6OptionLinkLayerAddress llaHdr;

183

  Icmpv6OptionLinkLayerAddress llaHdr;

149

  Icmpv6OptionMtu mtuHdr;

184

  Icmpv6OptionMtu mtuHdr;

150

  Icmpv6OptionPrefixInformation prefixHdr;

185

  Icmpv6OptionPrefixInformation prefixHdr;

151

186

152

  if (m_eventIds.size () == 0)

153

154

      return;

155

156

157

  std::list<Ptr<RadvdPrefix> > prefixes = config->GetPrefixes ();

187

  std::list<Ptr<RadvdPrefix> > prefixes = config->GetPrefixes ();

158

  Ptr<Packet> p = Create<Packet> ();

188

  Ptr<Packet> p = Create<Packet> ();

159

  Ptr<Ipv6> ipv6 = GetNode ()->GetObject<Ipv6> ();

189

  Ptr<Ipv6> ipv6 = GetNode ()->GetObject<Ipv6> ();

Lines 212-220	Link Here

212

      p->AddHeader (prefixHdr);

242

      p->AddHeader (prefixHdr);

213

243

214

244

215

  Ipv6Address src = ipv6->GetAddress (config->GetInterface (), 0).GetAddress ();

245

  Address sockAddr;

216

  m_socket->Bind (Inet6SocketAddress (src, 0));

246

  m_sendSockets[config->GetInterface ()]->GetSockName (sockAddr);

217

  m_socket->Connect (Inet6SocketAddress (dst, 0));

247

  Ipv6Address src = Inet6SocketAddress::ConvertFrom (sockAddr).GetIpv6 ();

218

248

219

  /* as we know interface index that will be used to send RA and

249

  /* as we know interface index that will be used to send RA and

220

   * we always send RA with router's link-local address, we can

250

   * we always send RA with router's link-local address, we can

Lines 231-245	Link Here

231

  p->AddPacketTag (ttl);

261

  p->AddPacketTag (ttl);

232

262

233

  /* send RA */

263

  /* send RA */

234

  NS_LOG_LOGIC ("Send RA");

264

  NS_LOG_LOGIC ("Send RA to " << dst);

235

  m_socket->Send (p, 0);

265

  m_sendSockets[config->GetInterface ()]->SendTo (p, 0, Inet6SocketAddress (dst, 0));

236

266

237

  if (reschedule)

267

  if (reschedule)

238

268

239

      uint64_t delay = static_cast<uint64_t> (m_jitter->GetValue (config->GetMinRtrAdvInterval (), config->GetMaxRtrAdvInterval ()) + 0.5);

269

      uint64_t delay = static_cast<uint64_t> (m_jitter->GetValue (config->GetMinRtrAdvInterval (), config->GetMaxRtrAdvInterval ()) + 0.5);

270

      if (config->IsInitialRtrAdv ())

271

272

          if (delay > MAX_INITIAL_RTR_ADVERT_INTERVAL)

273

            delay = MAX_INITIAL_RTR_ADVERT_INTERVAL;

274

275

240

      NS_LOG_INFO ("Reschedule in " << delay);

276

      NS_LOG_INFO ("Reschedule in " << delay);

241

      Time t = MilliSeconds (delay);

277

      Time t = MilliSeconds (delay);

242

      ScheduleTransmit (t, config, m_eventIds[config->GetInterface ()], Ipv6Address::GetAllNodesMulticast (), reschedule);

278

      m_unsolicitedEventIds[config->GetInterface ()] = Simulator::Schedule (t, &Radvd::Send, this, config, Ipv6Address::GetAllNodesMulticast (), true);

243

279

244

280

245

281

Lines 253-261	Link Here

253

289

254

      if (Inet6SocketAddress::IsMatchingType (from))

290

      if (Inet6SocketAddress::IsMatchingType (from))

255

291

292

          Ipv6PacketInfoTag interfaceInfo;

293

          if (!packet->RemovePacketTag (interfaceInfo))

294

295

              NS_ABORT_MSG ("No incoming interface on RADVD message, aborting.");

296

297

          uint32_t incomingIf = interfaceInfo.GetRecvIf ();

298

          Ptr<NetDevice> dev = GetNode ()->GetDevice (incomingIf);

299

          Ptr<Ipv6> ipv6 = GetNode ()->GetObject<Ipv6> ();

300

          uint32_t ipInterfaceIndex = ipv6->GetInterfaceForDevice (dev);

301

256

          Ipv6Header hdr;

302

          Ipv6Header hdr;

257

          Icmpv6RS rsHdr;

303

          Icmpv6RS rsHdr;

258

          Inet6SocketAddress address = Inet6SocketAddress::ConvertFrom (from);

259

          uint64_t delay = 0;

304

          uint64_t delay = 0;

260

          Time t;

305

          Time t;

261

306

Lines 269-288	Link Here

269

              packet->RemoveHeader (rsHdr);

314

              packet->RemoveHeader (rsHdr);

270

              NS_LOG_INFO ("Received ICMPv6 Router Solicitation from " << hdr.GetSourceAddress () << " code = " << (uint32_t)rsHdr.GetCode ());

315

              NS_LOG_INFO ("Received ICMPv6 Router Solicitation from " << hdr.GetSourceAddress () << " code = " << (uint32_t)rsHdr.GetCode ());

271

316

272

              /* XXX advertise just prefix(es) for the interface not all */

273

              for (RadvdInterfaceListCI it = m_configurations.begin (); it != m_configurations.end (); it++)

317

              for (RadvdInterfaceListCI it = m_configurations.begin (); it != m_configurations.end (); it++)

274

318

275

                  /* calculate minimum delay between RA */

319

                  if (ipInterfaceIndex == (*it)->GetInterface ())

276

                  delay = static_cast<uint64_t> (m_jitter->GetValue (0, MAX_RA_DELAY_TIME) + 0.5);

320

277

                  t = Simulator::Now () + MilliSeconds (delay); /* absolute time of solicited RA */

321

                      /* calculate minimum delay between RA */

322

                      delay = static_cast<uint64_t> (m_jitter->GetValue (0, MAX_RA_DELAY_TIME) + 0.5);

323

                      t = Simulator::Now () + MilliSeconds (delay); /* absolute time of solicited RA */

278

324

279

                  /* if our solicited RA is before the next periodic RA, we schedule it */

325

                      if (Simulator::Now () < (*it)->GetLastRaTxTime () + MilliSeconds (MIN_DELAY_BETWEEN_RAS) )

280

                  if (t.GetTimeStep () < static_cast<int64_t> (m_eventIds[(*it)->GetInterface ()].GetTs ()))

326

281

327

                          t += MilliSeconds (MIN_DELAY_BETWEEN_RAS);

282

                      NS_LOG_INFO ("schedule new RA");

328

283

                      EventId ei;

284

329

285

                      ScheduleTransmit (MilliSeconds (delay), (*it), ei, address.GetIpv6 (), false);

330

                      /* if our solicited RA is before the next periodic RA, we schedule it */

331

                      bool scheduleSingle = true;

332

333

                      if (m_solicitedEventIds.find ((*it)->GetInterface ()) != m_solicitedEventIds.end ())

334

335

                          if (m_solicitedEventIds[(*it)->GetInterface ()].IsRunning ())

336

337

                              scheduleSingle = false;

338

339

340

341

                      if (m_unsolicitedEventIds.find ((*it)->GetInterface ()) != m_unsolicitedEventIds.end ())

342

343

                          if (t.GetTimeStep () > static_cast<int64_t> (m_unsolicitedEventIds[(*it)->GetInterface ()].GetTs ()))

344

345

                              scheduleSingle = false;

346

347

348

349

                      if (scheduleSingle)

350

351

                          NS_LOG_INFO ("schedule new RA");

352

                          m_solicitedEventIds[(*it)->GetInterface ()] = Simulator::Schedule (MilliSeconds (delay), &Radvd::Send,

353

                                                                                             this, (*it), Ipv6Address::GetAllNodesMulticast (), false);

354

286

355

287

356

288

              break;

357

              break;

(-)a/src/applications/model/radvd.h (-13 / +32 lines)

Lines 67-72	Link Here

   * \brief Default value for maximum delay of RA (ms)

   * \brief Default value for maximum delay of RA (ms)

*/

*/

  static const uint32_t MAX_RA_DELAY_TIME = 500;

  static const uint32_t MAX_RA_DELAY_TIME = 500;

/**

   * \brief Default value for maximum initial RA advertisements

*/

  static const uint32_t MAX_INITIAL_RTR_ADVERTISEMENTS = 3;

/**

   * \brief Default value for maximum initial RA advertisements interval (ms)

*/

  static const uint32_t MAX_INITIAL_RTR_ADVERT_INTERVAL = 16000;

/**

   * \brief Default value for minimum delay between RA advertisements (ms)

*/

  static const uint32_t MIN_DELAY_BETWEEN_RAS = 3000;

/**

/**

   * \brief Add configuration for an interface;

   * \brief Add configuration for an interface;

Lines 105-110	Link Here

105

  /// Container Const Iterator: interface number, EventId

117

  /// Container Const Iterator: interface number, EventId

106

  typedef std::map<uint32_t, EventId>::const_iterator EventIdMapCI;

118

  typedef std::map<uint32_t, EventId>::const_iterator EventIdMapCI;

107

119

120

  /// Container: interface number, Socket

121

  typedef std::map<uint32_t, Ptr<Socket> > SocketMap;

122

  /// Container Iterator: interface number, Socket

123

  typedef std::map<uint32_t, Ptr<Socket> >::iterator SocketMapI;

124

  /// Container Const Iterator: interface number, Socket

125

  typedef std::map<uint32_t, Ptr<Socket> >::const_iterator SocketMapCI;

126

108

/**

127

/**

109

   * \brief Start the application.

128

   * \brief Start the application.

110

*/

129

*/

Lines 116-131	Link Here

116

  virtual void StopApplication ();

135

  virtual void StopApplication ();

117

136

118

/**

137

/**

119

   * \brief Schedule sending a packet.

120

   * \param dt interval between packet

121

   * \param config interface configuration

122

   * \param eventId event ID associated

123

   * \param dst IPv6 destination address

124

   * \param reschedule if true another send will be reschedule (periodic)

125

*/

126

  void ScheduleTransmit (Time dt, Ptr<RadvdInterface> config, EventId& eventId, Ipv6Address dst = Ipv6Address::GetAllNodesMulticast (), bool reschedule = false);

127

128

/**

129

   * \brief Send a packet.

138

   * \brief Send a packet.

130

   * \param config interface configuration

139

   * \param config interface configuration

131

   * \param dst destination address (default ff02::1)

140

   * \param dst destination address (default ff02::1)

Lines 140-148	Link Here

140

  void HandleRead (Ptr<Socket> socket);

149

  void HandleRead (Ptr<Socket> socket);

141

150

142

/**

151

/**

152

   * \brief Raw socket to receive RS.

153

*/

154

  Ptr<Socket> m_recvSocket;

155

156

/**

143

   * \brief Raw socket to send RA.

157

   * \brief Raw socket to send RA.

144

*/

158

*/

145

  Ptr<Socket> m_socket;

159

  SocketMap m_sendSockets;

146

160

147

/**

161

/**

148

   * \brief List of configuration for interface.

162

   * \brief List of configuration for interface.

Lines 150-158	Link Here

150

  RadvdInterfaceList m_configurations;

164

  RadvdInterfaceList m_configurations;

151

165

152

/**

166

/**

153

   * \brief Event ID map.

167

   * \brief Event ID map for unsolicited RAs.

154

*/

168

*/

155

  EventIdMap m_eventIds;

169

  EventIdMap m_unsolicitedEventIds;

170

171

/**

172

   * \brief Event ID map for solicited RAs.

173

*/

174

  EventIdMap m_solicitedEventIds;

156

175

157

/**

176

/**

158

   * \brief Variable to provide jitter in advertisement interval

177

   * \brief Variable to provide jitter in advertisement interval

Return to bug 2016