ndisc-cache.h

Go to the documentation of this file.

/*
 * Copyright (c) 2007-2009 Strasbourg University
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Sebastien Vincent <vincent@clarinet.u-strasbg.fr>
 */
 
#ifndef NDISC_CACHE_H
#define NDISC_CACHE_H
 
#include "ns3/ipv6-address.h"
#include "ns3/net-device.h"
#include "ns3/nstime.h"
#include "ns3/output-stream-wrapper.h"
#include "ns3/packet.h"
#include "ns3/ptr.h"
#include "ns3/timer.h"
 
#include <list>
#include <map>
#include <stdint.h>
 
namespace ns3
{
 
class NetDevice;
class Ipv6Interface;
class Ipv6Header;
class Icmpv6L4Protocol;
 
class NdiscCache : public Object
{
  public:
    class Entry;
 
    static TypeId GetTypeId();
 
    static const uint32_t DEFAULT_UNRES_QLEN = 3;
 
    NdiscCache();
 
    ~NdiscCache() override;
 
    // Delete default and copy constructor, and assignment operator to avoid misuse
    NdiscCache(const NdiscCache&) = delete;
    NdiscCache& operator=(const NdiscCache&) = delete;
 
    Ptr<NetDevice> GetDevice() const;
 
    Ptr<Ipv6Interface> GetInterface() const;
 
    virtual NdiscCache::Entry* Lookup(Ipv6Address dst);
 
    std::list<NdiscCache::Entry*> LookupInverse(Address dst);
 
    virtual NdiscCache::Entry* Add(Ipv6Address to);
 
    void Remove(NdiscCache::Entry* entry);
 
    void Flush();
 
    void SetUnresQlen(uint32_t unresQlen);
 
    uint32_t GetUnresQlen();
 
    void SetDevice(Ptr<NetDevice> device,
                   Ptr<Ipv6Interface> interface,
                   Ptr<Icmpv6L4Protocol> icmpv6);
 
    void PrintNdiscCache(Ptr<OutputStreamWrapper> stream);
 
    void RemoveAutoGeneratedEntries();
 
    typedef std::pair<Ptr<Packet>, Ipv6Header> Ipv6PayloadHeaderPair;
 
    class Entry
    {
      public:
        Entry(NdiscCache* nd);
 
        virtual ~Entry() = default;
 
        enum NdiscCacheEntryState_e
        {
            INCOMPLETE,          
            REACHABLE,           
            STALE,               
            DELAY,               
            PROBE,               
            PERMANENT,           
            STATIC_AUTOGENERATED 
        };
 
        NdiscCacheEntryState_e m_state;
 
        void MarkIncomplete(Ipv6PayloadHeaderPair p);
 
        std::list<Ipv6PayloadHeaderPair> MarkReachable(Address mac);
 
        void MarkProbe();
 
        std::list<Ipv6PayloadHeaderPair> MarkStale(Address mac);
 
        void MarkStale();
 
        void MarkReachable();
 
        void MarkDelay();
 
        void MarkPermanent();
 
        void MarkAutoGenerated();
 
        void AddWaitingPacket(Ipv6PayloadHeaderPair p);
 
        void ClearWaitingPacket();
 
        bool IsStale() const;
 
        bool IsReachable() const;
 
        bool IsDelay() const;
 
        bool IsIncomplete() const;
 
        bool IsProbe() const;
 
        bool IsPermanent() const;
 
        bool IsAutoGenerated() const;
 
        Address GetMacAddress() const;
 
        void SetMacAddress(Address mac);
 
        bool IsRouter() const;
 
        void SetRouter(bool router);
 
        Time GetLastReachabilityConfirmation() const;
 
        void StartReachableTimer();
 
        void UpdateReachableTimer();
 
        void StartRetransmitTimer();
 
        void StartProbeTimer();
 
        void StartDelayTimer();
 
        void StopNudTimer();
 
        void FunctionReachableTimeout();
 
        void FunctionRetransmitTimeout();
 
        void FunctionProbeTimeout();
 
        void FunctionDelayTimeout();
 
        void SetIpv6Address(Ipv6Address ipv6Address);
 
        Ipv6Address GetIpv6Address() const;
 
        NdiscCacheEntryState_e GetEntryState() const;
 
        void Print(std::ostream& os) const;
 
      protected:
        NdiscCache* m_ndCache;
 
      private:
        Ipv6Address m_ipv6Address;
 
        Address m_macAddress;
 
        std::list<Ipv6PayloadHeaderPair> m_waiting;
 
        bool m_router;
 
        Timer m_nudTimer;
 
        Time m_lastReachabilityConfirmation;
 
        uint8_t m_nsRetransmit;
    };
 
  protected:
    void DoDispose() override;
 
    typedef std::map<Ipv6Address, NdiscCache::Entry*> Cache;
    typedef std::map<Ipv6Address, NdiscCache::Entry*>::iterator CacheI;
 
    Cache m_ndCache;
 
  private:
    Ptr<NetDevice> m_device;
 
    Ptr<Ipv6Interface> m_interface;
 
    Ptr<Icmpv6L4Protocol> m_icmpv6;
 
    uint32_t m_unresQlen;
};
 
std::ostream& operator<<(std::ostream& os, const NdiscCache::Entry& entry);
 
} /* namespace ns3 */
 
#endif /* NDISC_CACHE_H */