Attachment #217 for bug #253

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

(-)a/src/internet-stack/arp-cache.cc (-3 / +121 lines)

Lines 22-27	Link Here

#include "ns3/simulator.h"

#include "ns3/simulator.h"

#include "ns3/uinteger.h"

#include "ns3/uinteger.h"

#include "ns3/log.h"

#include "ns3/log.h"

#include "ns3/node.h"

#include "ns3/trace-source-accessor.h"

#include "arp-cache.h"

#include "arp-cache.h"

#include "arp-header.h"

#include "arp-header.h"

Lines 47-61 ArpCache::GetTypeId (void)	Link Here

                   MakeTimeAccessor (&ArpCache::m_deadTimeout),

                   MakeTimeAccessor (&ArpCache::m_deadTimeout),

                   MakeTimeChecker ())

                   MakeTimeChecker ())

    .AddAttribute ("WaitReplyTimeout",

    .AddAttribute ("WaitReplyTimeout",

                   "When this timeout expires, the matching cache entry is marked dead",

                   "When this timeout expires, the cache entries will be scanned and entries in WaitReply state will resend ArpRequest unless MaxRetries has been exceeded, in which case the entry is marked dead",

                   TimeValue (Seconds (1)),

                   TimeValue (Seconds (1)),

                   MakeTimeAccessor (&ArpCache::m_waitReplyTimeout),

                   MakeTimeAccessor (&ArpCache::m_waitReplyTimeout),

                   MakeTimeChecker ())

                   MakeTimeChecker ())

    .AddAttribute ("MaxRetries",

                   "Number of retransmissions of ArpRequest before marking dead",

                   UintegerValue (3),

                   MakeUintegerAccessor (&ArpCache::m_maxRetries),

                   MakeUintegerChecker<uint32_t> ())

    .AddAttribute ("PendingQueueSize",

    .AddAttribute ("PendingQueueSize",

                   "The size of the queue for packets pending an arp reply.",

                   "The size of the queue for packets pending an arp reply.",

                   UintegerValue (3),

                   UintegerValue (3),

                   MakeUintegerAccessor (&ArpCache::m_pendingQueueSize),

                   MakeUintegerAccessor (&ArpCache::m_pendingQueueSize),

                   MakeUintegerChecker<uint32_t> ())

                   MakeUintegerChecker<uint32_t> ())

    .AddTraceSource ("Drop",

                     "Packet dropped due to ArpCache entry in WaitReply expiring.",

                     MakeTraceSourceAccessor (&ArpCache::m_dropTrace))

  return tid;

  return tid;

Lines 79-84 ArpCache::DoDispose (void)	Link Here

  Flush ();

  Flush ();

  m_device = 0;

  m_device = 0;

  m_interface = 0;

  m_interface = 0;

  if (!m_waitReplyTimer.IsRunning ())

      Simulator::Remove (m_waitReplyTimer);

  Object::DoDispose ();

  Object::DoDispose ();

Lines 143-148 ArpCache::GetWaitReplyTimeout (void) con	Link Here

143

157

144

158

145

void

159

void

160

ArpCache::SetArpRequestCallback (Callback<void, Ptr<const ArpCache>,

161

                             Ipv4Address> arpRequestCallback)

162

163

  NS_LOG_FUNCTION_NOARGS ();

164

  m_arpRequestCallback = arpRequestCallback;

165

166

167

void

168

ArpCache::StartWaitReplyTimer (void)

169

170

  NS_LOG_FUNCTION_NOARGS ();

171

  if (!m_waitReplyTimer.IsRunning ())

172

173

      NS_LOG_LOGIC ("Starting WaitReplyTimer at " << Simulator::Now ().GetSeconds ());

174

      m_waitReplyTimer = Simulator::Schedule (m_waitReplyTimeout,

175

        &ArpCache::HandleWaitReplyTimeout, this);

176

177

178

179

void

180

ArpCache::HandleWaitReplyTimeout (void)

181

182

  NS_LOG_FUNCTION_NOARGS ();

183

  ArpCache::Entry* entry;

184

  bool restartWaitReplyTimer = false;

185

  for (CacheI i = m_arpCache.begin (); i != m_arpCache.end (); i++)

186

187

      entry = (*i).second;

188

      if (entry != 0 && entry->IsWaitReply () && entry->IsExpired ())

189

190

          if (entry->GetRetries () < m_maxRetries)

191

192

              NS_LOG_LOGIC ("node="<< m_device->GetNode ()->GetId () <<

193

                ", ArpWaitTimeout for " << entry->GetIpv4Address () <<

194

                " expired -- retransmitting arp request since retries = " <<

195

                entry->GetRetries ());

196

              m_arpRequestCallback (this, entry->GetIpv4Address ());

197

              restartWaitReplyTimer = true;

198

              entry->IncrementRetries ();

199

200

          else

201

202

              NS_LOG_LOGIC ("node="<<m_device->GetNode ()->GetId () <<

203

                ", wait reply for " << entry->GetIpv4Address () <<

204

                " expired -- drop since max retries exceeded: " <<

205

                 entry->GetRetries ());

206

              entry->MarkDead ();

207

              entry->ClearRetries ();

208

              Ptr<Packet> pending = entry->DequeuePending();

209

              while (pending != 0)

210

211

                  m_dropTrace (pending);

212

                  pending = entry->DequeuePending();

213

214

215

216

217

218

  if (restartWaitReplyTimer)

219

220

      NS_LOG_LOGIC ("Restarting WaitReplyTimer at " << Simulator::Now ().GetSeconds ());

221

      m_waitReplyTimer = Simulator::Schedule (m_waitReplyTimeout,

222

        &ArpCache::HandleWaitReplyTimeout, this);

223

224

225

226

void

146

ArpCache::Flush (void)

227

ArpCache::Flush (void)

147

228

148

  NS_LOG_FUNCTION_NOARGS ();

229

  NS_LOG_FUNCTION_NOARGS ();

Lines 173-184 ArpCache::Add (Ipv4Address to)	Link Here

173

254

174

  ArpCache::Entry *entry = new ArpCache::Entry (this);

255

  ArpCache::Entry *entry = new ArpCache::Entry (this);

175

  m_arpCache[to] = entry;

256

  m_arpCache[to] = entry;

257

  entry->SetIpv4Address (to);

176

  return entry;

258

  return entry;

177

259

178

260

179

ArpCache::Entry::Entry (ArpCache *arp)

261

ArpCache::Entry::Entry (ArpCache *arp)

180

  : m_arp (arp),

262

  : m_arp (arp),

181

    m_state (ALIVE)

263

    m_state (ALIVE),

264

    m_retries (0)

182

265

183

  NS_LOG_FUNCTION_NOARGS ();

266

  NS_LOG_FUNCTION_NOARGS ();

184

267

Lines 209-214 ArpCache::Entry::MarkDead (void)	Link Here

209

292

210

  NS_LOG_FUNCTION_NOARGS ();

293

  NS_LOG_FUNCTION_NOARGS ();

211

  m_state = DEAD;

294

  m_state = DEAD;

295

  ClearRetries ();

212

  UpdateSeen ();

296

  UpdateSeen ();

213

297

214

void

298

void

Lines 218-223 ArpCache::Entry::MarkAlive (Address macA	Link Here

218

  NS_ASSERT (m_state == WAIT_REPLY);

302

  NS_ASSERT (m_state == WAIT_REPLY);

219

  m_macAddress = macAddress;

303

  m_macAddress = macAddress;

220

  m_state = ALIVE;

304

  m_state = ALIVE;

305

  ClearRetries ();

221

  UpdateSeen ();

306

  UpdateSeen ();

222

307

223

308

Lines 246-260 ArpCache::Entry::MarkWaitReply (Ptr<Pack	Link Here

246

  m_state = WAIT_REPLY;

331

  m_state = WAIT_REPLY;

247

  m_pending.push_back (waiting);

332

  m_pending.push_back (waiting);

248

  UpdateSeen ();

333

  UpdateSeen ();

334

  m_arp->StartWaitReplyTimer ();

249

335

250

336

251

Address

337

Address

252

ArpCache::Entry::GetMacAddress (void)

338

ArpCache::Entry::GetMacAddress (void) const

253

339

254

  NS_LOG_FUNCTION_NOARGS ();

340

  NS_LOG_FUNCTION_NOARGS ();

255

  NS_ASSERT (m_state == ALIVE);

341

  NS_ASSERT (m_state == ALIVE);

256

  return m_macAddress;

342

  return m_macAddress;

257

343

344

Ipv4Address

345

ArpCache::Entry::GetIpv4Address (void) const

346

347

  NS_LOG_FUNCTION_NOARGS ();

348

  return m_ipv4Address;

349

350

void

351

ArpCache::Entry::SetIpv4Address (Ipv4Address destination)

352

353

  NS_LOG_FUNCTION (this << destination);

354

  m_ipv4Address = destination;

355

356

258

bool

357

bool

259

ArpCache::Entry::IsExpired (void)

358

ArpCache::Entry::IsExpired (void)

260

359

Lines 307-312 ArpCache::Entry::UpdateSeen (void)	Link Here

307

  NS_LOG_FUNCTION_NOARGS ();

406

  NS_LOG_FUNCTION_NOARGS ();

308

  m_lastSeen = Simulator::Now ();

407

  m_lastSeen = Simulator::Now ();

309

408

409

uint32_t

410

ArpCache::Entry::GetRetries (void) const

411

412

  NS_LOG_FUNCTION_NOARGS ();

413

  return m_retries;

414

415

void

416

ArpCache::Entry::IncrementRetries (void)

417

418

  NS_LOG_FUNCTION_NOARGS ();

419

  m_retries++;

420

  UpdateSeen ();

421

422

void

423

ArpCache::Entry::ClearRetries (void)

424

425

  NS_LOG_FUNCTION_NOARGS ();

426

  m_retries = 0;

427

310

428

311

} // namespace ns3

429

} // namespace ns3

312

430

(-)a/src/internet-stack/arp-cache.h (-2 / +54 lines)

Lines 22-27	Link Here

#include <stdint.h>

#include <stdint.h>

#include <list>

#include <list>

#include "ns3/simulator.h"

#include "ns3/callback.h"

#include "ns3/packet.h"

#include "ns3/packet.h"

#include "ns3/nstime.h"

#include "ns3/nstime.h"

#include "ns3/net-device.h"

#include "ns3/net-device.h"

Lines 29-34	Link Here

#include "ns3/address.h"

#include "ns3/address.h"

#include "ns3/ptr.h"

#include "ns3/ptr.h"

#include "ns3/object.h"

#include "ns3/object.h"

#include "ns3/traced-callback.h"

#include "sgi-hashmap.h"

#include "sgi-hashmap.h"

namespace ns3 {

namespace ns3 {

Lines 72-78 public:	Link Here

  Time GetWaitReplyTimeout (void) const;

  Time GetWaitReplyTimeout (void) const;

/**

/**

   * \brief Do lookup in the ARP chache against an IP address

   * This callback is set when the ArpCache is set up and allows

   * the cache to generate an Arp request when the WaitReply

   * time expires and a retransmission must be sent

   * \param arpRequestCallback Callback for transmitting an Arp request.

*/

  void SetArpRequestCallback (Callback<void, Ptr<const ArpCache>,

                             Ipv4Address> arpRequestCallback);

/**

   * This method will schedule a timeout at WaitReplyTimeout interval

   * in the future, unless a timer is already running for the cache,

   * in which case this method does nothing.

*/

  void StartWaitReplyTimer (void);

/**

   * \brief Do lookup in the ARP cache against an IP address

   * \param destination The destination IPv4 address to lookup the MAC address

   * \param destination The destination IPv4 address to lookup the MAC address

   * of

   * of

   * \return An ArpCache::Entry with info about layer 2

   * \return An ArpCache::Entry with info about layer 2

Lines 131-137 public:	Link Here

131

/**

149

/**

132

     * \return The MacAddress of this entry

150

     * \return The MacAddress of this entry

133

*/

151

*/

134

    Address GetMacAddress (void);

152

    Address GetMacAddress (void) const;

153

/**

154

     * \return The Ipv4Address for this entry

155

*/

156

    Ipv4Address GetIpv4Address (void) const;

157

/**

158

     * \param The Ipv4Address for this entry

159

*/

160

    void SetIpv4Address (Ipv4Address destination);

135

/**

161

/**

136

     * \return True if this entry has timedout; false otherwise.

162

     * \return True if this entry has timedout; false otherwise.

137

*/

163

*/

Lines 142-147 public:	Link Here

142

     *            packets are pending.

168

     *            packets are pending.

143

*/

169

*/

144

    Ptr<Packet> DequeuePending (void);

170

    Ptr<Packet> DequeuePending (void);

171

/**

172

     * \returns number of retries that have been sent for an ArpRequest

173

     *  in WaitReply state.

174

*/

175

    uint32_t GetRetries (void) const;

176

/**

177

     * \brief Increment the counter of number of retries for an entry

178

*/

179

    void IncrementRetries (void);

180

/**

181

     * \brief Zero the counter of number of retries for an entry

182

*/

183

    void ClearRetries (void);

184

145

  private:

185

  private:

146

    enum ArpCacheEntryState_e {

186

    enum ArpCacheEntryState_e {

147

      ALIVE,

187

      ALIVE,

Lines 154-160 public:	Link Here

154

    ArpCacheEntryState_e m_state;

194

    ArpCacheEntryState_e m_state;

155

    Time m_lastSeen;

195

    Time m_lastSeen;

156

    Address m_macAddress;

196

    Address m_macAddress;

197

    Ipv4Address m_ipv4Address;

157

    std::list<Ptr<Packet> > m_pending;

198

    std::list<Ptr<Packet> > m_pending;

199

    uint32_t m_retries;

158

};

200

};

159

201

160

private:

202

private:

Lines 168-175 private:	Link Here

168

  Time m_aliveTimeout;

210

  Time m_aliveTimeout;

169

  Time m_deadTimeout;

211

  Time m_deadTimeout;

170

  Time m_waitReplyTimeout;

212

  Time m_waitReplyTimeout;

213

  EventId m_waitReplyTimer;

214

  Callback<void, Ptr<const ArpCache>, Ipv4Address> m_arpRequestCallback;

215

  uint32_t m_maxRetries;

216

/**

217

   * This function is an event handler for the event that the

218

   * ArpCache wants to check whether it must retry any Arp requests.

219

   * If there are no Arp requests pending, this event is not scheduled.

220

*/

221

  void HandleWaitReplyTimeout (void);

171

  uint32_t m_pendingQueueSize;

222

  uint32_t m_pendingQueueSize;

172

  Cache m_arpCache;

223

  Cache m_arpCache;

224

  TracedCallback<Ptr<const Packet> > m_dropTrace;

173

};

225

};

174

226

175

227




  cache->SetDevice (device, interface);
  NS_ASSERT (device->IsBroadcast ());
  device->SetLinkChangeCallback (MakeCallback (&ArpCache::Flush, cache));
  cache->SetArpRequestCallback (MakeCallback (&ArpL3Protocol::SendArpRequest, this));
  m_cacheList.push_back (cache);
  return cache;
}

            } 
          else if (entry->IsWaitReply ()) 
            {
              NS_FATAL_ERROR ("Test for possibly unreachable code-- please file a bug report if this is ever hit");
                        ", wait reply for " << destination << " expired -- drop");
              entry->MarkDead ();
              Ptr<Packet> pending = entry->DequeuePending();
              while (pending != 0)
                {
                  m_dropTrace (pending);
                  pending = entry->DequeuePending();
                }
              m_dropTrace (packet);
            }
        } 
      else 

(-)a/src/internet-stack/arp-l3-protocol.h (-1 / +1 lines)

Lines 52-58 public:	Link Here

  Ptr<ArpCache> CreateCache (Ptr<NetDevice> device, Ptr<Ipv4Interface> interface);

  Ptr<ArpCache> CreateCache (Ptr<NetDevice> device, Ptr<Ipv4Interface> interface);

/**

/**

   * \brief Recieve a packet

   * \brief Receive a packet

*/

*/

  void Receive(Ptr<NetDevice> device, Ptr<Packet> p, uint16_t protocol, const Address &from, const Address &to,

  void Receive(Ptr<NetDevice> device, Ptr<Packet> p, uint16_t protocol, const Address &from, const Address &to,

               NetDevice::PacketType packetType);

               NetDevice::PacketType packetType);

Return to bug 253