IPv6NeighbourCache.h

Go to the documentation of this file.

#ifndef NEIGHBORCACHE_H
#define NEIGHBORCACHE_H

#include <map>
#include <vector>
#include <omnetpp.h>
#include "IPv6Address.h"
#include "MACAddress.h"


class INET_API IPv6NeighbourCache
{
  public:
    typedef std::vector<cMessage*> MsgPtrVector;  // TODO verify this is really needed --Andras

    enum ReachabilityState {INCOMPLETE, REACHABLE, STALE, DELAY, PROBE};

    struct Key
    {
        IPv6Address address;
        int interfaceID;
        Key(IPv6Address addr, int ifaceID) {address=addr; interfaceID=ifaceID;}
        bool operator<(const Key& b) const {
            return interfaceID==b.interfaceID ? address<b.address : interfaceID<b.interfaceID;
        }
    };

    struct Neighbour
    {
        // Neighbour info
        const Key *nceKey;//store a pointer back to the key that links to this NCE.-WEI
        MACAddress macAddress;
        bool isRouter;
        bool isDefaultRouter; // is it on the Default Router List?

        // Neighbour Unreachability Detection variables
        ReachabilityState reachabilityState;
        simtime_t reachabilityExpires; // reachabilityLastConfirmed+reachableTime
        short numProbesSent;
        cMessage *nudTimeoutEvent; // DELAY or PROBE timer

        //WEI-We could have a seperate AREntry in the ND module.
        //But we should merge those information in the neighbour cache for a
        //cleaner solution. if reachability state is INCOMPLETE, it means that
        //addr resolution is being performed for this NCE.
        int numOfARNSSent;
        cMessage *arTimer;//Address Resolution self-message timer
        MsgPtrVector pendingPackets; //ptrs to queued packets associated with this NCE
        IPv6Address nsSrcAddr;//the src addr that was used to send the previous NS

        // Router variables.
        // NOTE: we only store lifetime expiry. Other Router Advertisement
        // fields (reachableTime, retransTimer, MTU) update the interface
        // configuration (IPv6InterfaceData). We won't have a timer message
        // for router lifetime; instead, we'll check the expirytime every time
        // we bump into a router entry (as nexthop in dest cache, or during
        // default router selection
        simtime_t routerExpiryTime;   // time when router lifetime expires
    };

    // Design note: we could have polymorphic entries in the neighbour cache
    // (i.e. a separate Router class subclassed from Neighbour), but then
    // we'd have to store in the map pointers to dynamically allocated
    // Neighbour structs, instead of the data directly. As long as expiryTime
    // is the only router-specific field, polymorphic entries don't pay off
    // because of the overhead caused by 'new'.

    typedef std::map<Key,Neighbour> NeighbourMap;
    typedef NeighbourMap::iterator iterator;

  protected:
    NeighbourMap neighbourMap;

  public:
    IPv6NeighbourCache();
    virtual ~IPv6NeighbourCache() {}

    virtual Neighbour *lookup(const IPv6Address& addr, int interfaceID);

    virtual const Key *lookupKeyAddr(Key& key);

    iterator begin()  {return neighbourMap.begin();}

    iterator end()  {return neighbourMap.end();}

    //TODO merge into next one (using default arg)
    virtual Neighbour *addNeighbour(const IPv6Address& addr, int interfaceID);

    virtual Neighbour *addNeighbour(const IPv6Address& addr, int interfaceID,
                            MACAddress macAddress);

    //TODO merge into next one (using default arg)
    virtual Neighbour *addRouter(const IPv6Address& addr, int interfaceID,
                        simtime_t expiryTime);

    virtual Neighbour *addRouter(const IPv6Address& addr, int interfaceID,
                         MACAddress macAddress, simtime_t expiryTime);

    virtual void remove(const IPv6Address& addr, int interfaceID);

    virtual void remove(NeighbourMap::iterator it);

    static const char *stateName(ReachabilityState state);
};

#endif