IPv6NeighbourDiscovery.h

Go to the documentation of this file.

#ifndef IPV6NEIGHBOURDISCOVERY_H
#define IPV6NEIGHBOURDISCOVERY_H

#include <stdio.h>
#include <string.h>
#include <vector>
#include <set>
#include <omnetpp.h>
#include "IPv6Address.h"
#include "IPv6Datagram.h"
#include "IPv6NDMessage_m.h"
#include "IPv6ControlInfo.h"
#include "IPv6InterfaceData.h"
#include "InterfaceEntry.h"
#include "IInterfaceTable.h"
#include "InterfaceTableAccess.h"
#include "RoutingTable6.h"
#include "RoutingTable6Access.h"
#include "IPv6NeighbourCache.h"
#include "ICMPv6.h"
#include "ICMPv6Access.h"

class INET_API IPv6NeighbourDiscovery : public cSimpleModule
{
    public:
        typedef std::vector<cMessage*> MsgPtrVector;
        typedef IPv6NeighbourCache::Key Key;//for convenience
        typedef IPv6NeighbourCache::Neighbour Neighbour;  // for convenience

    public:
        IPv6NeighbourDiscovery();
        virtual ~IPv6NeighbourDiscovery();

    public:
        const MACAddress& resolveNeighbour(const IPv6Address& nextHop, int interfaceId);

        virtual void reachabilityConfirmed(const IPv6Address& neighbour, int interfaceId);

    protected:

        //Packets awaiting Address Resolution or Next-Hop Determination.
        cQueue pendingQueue;

        IInterfaceTable *ift;
        RoutingTable6 *rt6;
        ICMPv6 *icmpv6;
        IPv6NeighbourCache neighbourCache;
        typedef std::set<cMessage*> RATimerList;

        // stores information about a pending Duplicate Address Detection for
        // an interface
        struct DADEntry {
            int interfaceId;// interface on which DAD is performed
            IPv6Address address;// link-local address subject to DAD
            int numNSSent;// number of DAD solicitations sent since start of sim
            cMessage *timeoutMsg;// the message to cancel when NA is received
        };
        typedef std::set<DADEntry*> DADList; //FIXME why ptrs are stored?

        //stores information about Router Discovery for an interface
        struct RDEntry {
            int interfaceId; //interface on which Router Discovery is performed
            int numRSSent; //number of Router Solicitations sent since start of sim
            cMessage *timeoutMsg; //the message to cancel when RA is received
        };
        typedef std::set<RDEntry*> RDList; //FIXME why ptrs are stored?

        //An entry that stores information for an Advertising Interface
        struct AdvIfEntry {
            int interfaceId;
            int numRASent;//number of Router Advertisements sent since start of sim
            simtime_t nextScheduledRATime;//stores time when next RA will be sent.
            cMessage *raTimeoutMsg;//the message to cancel when resetting RA timer
        };
        typedef std::set<AdvIfEntry*> AdvIfList; //FIXME why ptrs are stored?

        //List of periodic RA msgs(used only for router interfaces)
        RATimerList raTimerList;
        //List of pending Duplicate Address Detections
        DADList dadList;
        //List of pending Router & Prefix Discoveries
        RDList rdList;
        //List of Advertising Interfaces
        AdvIfList advIfList;

    protected:
        /************************Miscellaneous Stuff***************************/
        virtual int numInitStages() const {return 4;}
        virtual void initialize(int stage);
        virtual void handleMessage(cMessage *msg);
        virtual void processNDMessage(ICMPv6Message *msg, IPv6ControlInfo *ctrlInfo);
        virtual void finish();

        virtual void processIPv6Datagram(IPv6Datagram *datagram);
        virtual IPv6NeighbourDiscovery::AdvIfEntry *fetchAdvIfEntry(InterfaceEntry *ie);
        virtual IPv6NeighbourDiscovery::RDEntry *fetchRDEntry(InterfaceEntry *ie);
        /************************End of Miscellaneous Stuff********************/

        virtual IPv6Address determineNextHop(const IPv6Address& destAddr, int& outIfID);
        virtual void initiateNeighbourUnreachabilityDetection(Neighbour *neighbour);
        virtual void processNUDTimeout(cMessage *timeoutMsg);
        virtual IPv6Address selectDefaultRouter(int& outIfID);
        virtual void timeoutPrefixEntry(const IPv6Address& destPrefix, int prefixLength);
        virtual void timeoutDefaultRouter(const IPv6Address& addr, int interfaceID);
        virtual void initiateAddressResolution(const IPv6Address& dgSrcAddr,
            Neighbour *nce);
        virtual void processARTimeout(cMessage *arTimeoutMsg);
        virtual void dropQueuedPacketsAwaitingAR(Neighbour *nce);
        virtual void sendPacketToIPv6Module(cMessage *msg, const IPv6Address& destAddr,
            const IPv6Address& srcAddr, int interfaceId);

        virtual void sendQueuedPacketsToIPv6Module(Neighbour *nce);

        virtual void initiateDAD(const IPv6Address& tentativeAddr, InterfaceEntry *ie);

        virtual void processDADTimeout(cMessage *msg);

        /************Address Autoconfiguration Stuff***************************/
        virtual void assignLinkLocalAddress(cMessage *timerMsg);

        /************End Of Address Autoconfiguration Stuff********************/

        /************Router Solicitation Stuff*********************************/
        virtual IPv6RouterSolicitation *createAndSendRSPacket(InterfaceEntry *ie);
        virtual void initiateRouterDiscovery(cMessage *msg);
        virtual void cancelRouterDiscovery(InterfaceEntry *ie);
        virtual void processRDTimeout(cMessage *msg);
        virtual void processRSPacket(IPv6RouterSolicitation *rs, IPv6ControlInfo *rsCtrlInfo);
        virtual bool validateRSPacket(IPv6RouterSolicitation *rs, IPv6ControlInfo *rsCtrlInfo);
        /************End of Router Solicitation Stuff**************************/

        /************Router Advertisment Stuff*********************************/
        virtual IPv6RouterAdvertisement *createAndSendRAPacket(const IPv6Address& destAddr,
            InterfaceEntry *ie);
        virtual void processRAPacket(IPv6RouterAdvertisement *ra, IPv6ControlInfo *raCtrlInfo);
        virtual void processRAForRouterUpdates(IPv6RouterAdvertisement *ra,
            IPv6ControlInfo *raCtrlInfo);
        //RFC 2461: Section 6.3.4
        /*Note: Implementations can choose to process the on-link aspects of the
        prefixes separately from the address autoconfiguration aspects of the
        prefixes by, e.g., passing a copy of each valid Router Advertisement message
        to both an "on-link" and an "addrconf" function. Each function can then
        operate independently on the prefixes that have the appropriate flag set.*/
        virtual void processRAPrefixInfo(IPv6RouterAdvertisement *ra, InterfaceEntry *ie);
        virtual void processRAPrefixInfoForAddrAutoConf(IPv6NDPrefixInformation& prefixInfo,
            InterfaceEntry *ie);
        virtual void createRATimer(InterfaceEntry *ie);
        virtual void resetRATimer(InterfaceEntry *ie);
        virtual void sendPeriodicRA(cMessage *msg);
        virtual void sendSolicitedRA(cMessage *msg);
        virtual bool validateRAPacket(IPv6RouterAdvertisement *ra, IPv6ControlInfo *raCtrlInfo);
        /************End of Router Advertisement Stuff*************************/

        /************Neighbour Solicitaton Stuff*******************************/
        virtual IPv6NeighbourSolicitation *createAndSendNSPacket(
            const IPv6Address& nsTargetAddr, const IPv6Address& dgDestAddr,
            const IPv6Address& dgSrcAddr, InterfaceEntry *ie);
        virtual void processNSPacket(IPv6NeighbourSolicitation *ns, IPv6ControlInfo *naCtrlInfo);
        virtual bool validateNSPacket(IPv6NeighbourSolicitation *ns, IPv6ControlInfo *nsCtrlInfo);
        virtual void processNSForTentativeAddress(IPv6NeighbourSolicitation *ns,
            IPv6ControlInfo *ctrlInfo);
        virtual void processNSForNonTentativeAddress(IPv6NeighbourSolicitation *ns,
            IPv6ControlInfo *ctrlInfo, InterfaceEntry *ie);
        virtual void processNSWithSpecifiedSrcAddr(IPv6NeighbourSolicitation *ns,
            IPv6ControlInfo *ctrlInfo, InterfaceEntry *ie);
        /************End Of Neighbour Solicitation Stuff***********************/

        /************Neighbour Advertisment Stuff)*****************************/
        virtual void sendSolicitedNA(IPv6NeighbourSolicitation *ns,
            IPv6ControlInfo *nsCtrlInfo, InterfaceEntry *ie);
        virtual void sendUnsolicitedNA(InterfaceEntry *ie);
        virtual void processNAPacket(IPv6NeighbourAdvertisement *na, IPv6ControlInfo *naCtrlInfo);
        virtual bool validateNAPacket(IPv6NeighbourAdvertisement *na, IPv6ControlInfo *naCtrlInfo);
        virtual void processNAForIncompleteNCEState(IPv6NeighbourAdvertisement *na,
            IPv6NeighbourCache::Neighbour *nce);
        virtual void processNAForOtherNCEStates(IPv6NeighbourAdvertisement *na,
            IPv6NeighbourCache::Neighbour *nce);
        /************End Of Neighbour Advertisement Stuff**********************/

        /************Redirect Message Stuff************************************/
        virtual IPv6Redirect *createAndSendRedirectPacket(InterfaceEntry *ie);
        virtual void processRedirectPacket(IPv6Redirect *redirect, IPv6ControlInfo *ctrlInfo);
        /************End Of Redirect Message Stuff*****************************/

        /*ICMPv6DestUnreachableMsg *createAndSendUnreachableMessage(
            const IPv6Address& destAddress, InterfaceEntry *ie);*/
};
#endif //IPV6NEIGHBOURDISCOVERY_H