Attachment #2365 for bug #2057

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




    }
}

std::list<ArpCache::Entry *>
ArpCache::LookupInverse (Address to)
{
  NS_LOG_FUNCTION (this << to);

  std::list<ArpCache::Entry *> entryList;
  for (CacheI i = m_arpCache.begin (); i != m_arpCache.end (); i++)
    {
      ArpCache::Entry *entry = (*i).second;
      if (entry->GetMacAddress () == to)
        {
          entryList.push_back (entry);
        }
    }
  return entryList;
}


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

(-)a/src/internet/model/arp-cache.h (-5 / +12 lines)

Lines 148-153	Link Here

148

*/

148

*/

149

  ArpCache::Entry *Lookup (Ipv4Address destination);

149

  ArpCache::Entry *Lookup (Ipv4Address destination);

150

/**

150

/**

151

   * \brief Do lookup in the ARP cache against a MAC address

152

   * \param destination The destination MAC address to lookup

153

   * of

154

   * \return A std::list of ArpCache::Entry with info about layer 2

155

*/

156

  std::list<ArpCache::Entry *> LookupInverse (Address destination);

157

/**

151

   * \brief Add an Ipv4Address to this ARP cache

158

   * \brief Add an Ipv4Address to this ARP cache

152

*/

159

*/

153

  ArpCache::Entry *Add (Ipv4Address to);

160

  ArpCache::Entry *Add (Ipv4Address to);

Lines 269-274	Link Here

269

*/

276

*/

270

    void ClearRetries (void);

277

    void ClearRetries (void);

271

278

279

/**

280

     * \brief Update the entry when seeing a packet

281

*/

282

    void UpdateSeen (void);

283

272

private:

284

private:

273

/**

285

/**

274

     * \brief ARP cache entry states

286

     * \brief ARP cache entry states

Lines 281-291	Link Here

281

};

293

};

282

294

283

/**

295

/**

284

     * \brief Update the entry when seeing a packet

285

*/

286

    void UpdateSeen (void);

287

288

/**

289

     * \brief Returns the entry timeout

296

     * \brief Returns the entry timeout

290

     * \returns the entry timeout

297

     * \returns the entry timeout

291

*/

298

*/





#include "loopback-net-device.h"
#include "arp-l3-protocol.h"
#include "arp-cache.h"
#include "ipv4-l3-protocol.h"
#include "icmpv4-l4-protocol.h"
#include "ipv4-interface.h"

      return;
    }

  // the packet is valid, we update the ARP cache entry (if present)
  Ptr<ArpCache> arpCache = ipv4Interface->GetArpCache ();
  if (arpCache)
    {
      // case one, it's a a direct routing.
      ArpCache::Entry *entry = arpCache->Lookup (ipHeader.GetSource ());
      if (entry)
        {
          if (entry->IsAlive ())
            {
              entry->UpdateSeen ();
            }
        }
      else
        {
          // It's not in the direct routing, so it's the router, and it could have multiple IP addresses.
          // In doubt, update all of them.
          // Note: it's a confirmed behavior for Linux routers.
          std::list<ArpCache::Entry *> entryList = arpCache->LookupInverse (from);
          std::list<ArpCache::Entry *>::iterator iter;
          for (iter = entryList.begin (); iter != entryList.end (); iter ++)
            {
              if ((*iter)->IsAlive ())
                {
                  (*iter)->UpdateSeen ();
                }
            }
        }
    }

  for (SocketList::iterator i = m_sockets.begin (); i != m_sockets.end (); ++i)
    {
      NS_LOG_LOGIC ("Forwarding to raw socket"); 




      packet->RemoveAtEnd (packet->GetSize () - hdr.GetPayloadLength ());
    }

  // the packet is valid, we update the NDISC cache entry (if present)
  Ptr<NdiscCache> ndiscCache = ipv6Interface->GetNdiscCache ();
  if (ndiscCache)
    {
      // case one, it's a a direct routing.
      NdiscCache::Entry *entry = ndiscCache->Lookup (hdr.GetSourceAddress ());
      if (entry)
        {
          entry->UpdateReachableTimer ();
        }
      else
        {
          // It's not in the direct routing, so it's the router, and it could have multiple IP addresses.
          // In doubt, update all of them.
          // Note: it's a confirmed behavior for Linux routers.
          std::list<NdiscCache::Entry *> entryList = ndiscCache->LookupInverse (from);
          std::list<NdiscCache::Entry *>::iterator iter;
          for (iter = entryList.begin (); iter != entryList.end (); iter ++)
            {
              (*iter)->UpdateReachableTimer ();
            }
        }
    }



  /* forward up to IPv6 raw sockets */
  for (SocketList::iterator it = m_sockets.begin (); it != m_sockets.end (); ++it)
    {




  return 0;
}

std::list<NdiscCache::Entry*> NdiscCache::LookupInverse (Address dst)
{
  NS_LOG_FUNCTION (this << dst);

  std::list<NdiscCache::Entry *> entryList;
  for (CacheI i = m_ndCache.begin (); i != m_ndCache.end (); i++)
    {
      NdiscCache::Entry *entry = (*i).second;
      if (entry->GetMacAddress () == dst)
        {
          entryList.push_back (entry);
        }
    }
  return entryList;
}


NdiscCache::Entry* NdiscCache::Add (Ipv6Address to)
{
  NS_LOG_FUNCTION (this << to);

  return m_lastReachabilityConfirmation;
}

void NdiscCache::Entry::UpdateLastReachabilityconfirmation ()
{
  NS_LOG_FUNCTION_NOARGS ();
}

void NdiscCache::Entry::StartReachableTimer ()
{
  NS_LOG_FUNCTION_NOARGS ();

      m_nudTimer.Cancel ();
    }

  m_lastReachabilityConfirmation = Simulator::Now ();
  m_nudTimer.SetFunction (&NdiscCache::Entry::FunctionReachableTimeout, this);
  m_nudTimer.SetDelay (MilliSeconds (Icmpv6L4Protocol::REACHABLE_TIME));
  m_nudTimer.Schedule ();
}

void NdiscCache::Entry::UpdateReachableTimer ()
{
  NS_LOG_FUNCTION_NOARGS ();

  if (m_state == REACHABLE)
    {
      m_lastReachabilityConfirmation = Simulator::Now ();
      if (m_nudTimer.IsRunning ())
        {
          m_nudTimer.Cancel ();
        }
      m_nudTimer.Schedule ();
    }
}

void NdiscCache::Entry::StartProbeTimer ()
{
  NS_LOG_FUNCTION_NOARGS ();





  /**
   * \brief Lookup in the cache.
   * \param dst destination address.
   * \return the entry if found, 0 otherwise.
   */
  NdiscCache::Entry* Lookup (Ipv6Address dst);

  /**
   * \brief Lookup in the cache for a MAC address.
   * \param dst destination MAC address.
   * \return a list of matching entries.
   */
  std::list<NdiscCache::Entry*> LookupInverse (Address dst);

  /**
   * \brief Add an entry.
   * \param to address to add
   * \return an new Entry

    Time GetLastReachabilityConfirmation () const;

    /**
     * \brief Update the time of last reachability confirmation.
     */
    void UpdateLastReachabilityconfirmation ();

    /**
     * \brief Start the reachable timer.
     */
    void StartReachableTimer ();

    /**
     * \brief Update the reachable timer.
     */
    void UpdateReachableTimer ();

    /**
     * \brief Start retransmit timer.
     */
    void StartRetransmitTimer ();

Return to bug 2057