IPv6InterfaceData.h

Go to the documentation of this file.

//
// Copyright (C) 2005 Andras Varga
// Copyright (C) 2005 Wei Yang, Ng
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this program; if not, see <http://www.gnu.org/licenses/>.
//


#ifndef __IPv6INTERFACEDATA_H
#define __IPv6INTERFACEDATA_H


#include <vector>
#include <omnetpp.h>
#include "INETDefs.h"
#include "IPv6Address.h"
#include "InterfaceEntry.h"

#define IPv6_DEFAULT_DUPADDRDETECTTRANSMITS 1   // send NS once (RFC2462:Section 5.1)

#define IPv6_MIN_MTU                        1280// octets
#define IPv6_DEFAULT_ADVCURHOPLIMIT         30

#define IPv6_DEFAULT_MAX_RTR_ADV_INT        600 //seconds-decrease to enable more periodic RAs
#define IPv6_DEFAULT_ADV_REACHABLE_TIME     3600// seconds
#define IPv6_DEFAULT_ADV_RETRANS_TIMER      1   // seconds
#define IPv6__INET_DEFAULT_ROUTER_HOPLIMIT        64

/**************RFC 2461: Section 10 Protocol Constants*************************/
//Router Constants
#define IPv6_MAX_INITIAL_RTR_ADVERT_INTERVAL 16  // seconds
#define IPv6_MAX_INITIAL_RTR_ADVERTISEMENTS   3  // transmissions
#define IPv6_MAX_FINAL_RTR_ADVERTISEMENTS     3  // transmissions
#define IPv6_MIN_DELAY_BETWEEN_RAS            3  // seconds
#define IPv6_MAX_RA_DELAY_TIME               .5  // seconds

//Host Constants
#define IPv6_MAX_RTR_SOLICITATION_DELAY       1  // seconds
#define IPv6_RTR_SOLICITATION_INTERVAL        4  // seconds
#define IPv6_MAX_RTR_SOLICITATIONS            3  // transmissions

//Node Constants
#define IPv6_MAX_MULTICAST_SOLICIT            3  // transmissions
#define IPv6_MAX_UNICAST_SOLICIT              3  // transmissions
#define IPv6_MAX_ANYCAST_DELAY_TIME           1  // seconds
#define IPv6_MAX_NEIGHBOUR_ADVERTISEMENT      3  // transmissions
#define IPv6_REACHABLE_TIME                  30  // seconds
#define IPv6_RETRANS_TIMER                    1  // seconds
#define IPv6_DELAY_FIRST_PROBE_TIME           5  // seconds
#define IPv6_MIN_RANDOM_FACTOR              0.5
#define IPv6_MAX_RANDOM_FACTOR              1.5
/***************END of RFC 2461 Protocol Constants*****************************/

class INET_API IPv6InterfaceData : public InterfaceProtocolData
{
  public:
    struct AdvPrefix
    {
        IPv6Address prefix;
        short prefixLength;
        simtime_t advValidLifetime; // see comment above
        bool advOnLinkFlag;
        simtime_t advPreferredLifetime; // see comment above
        bool advAutonomousFlag;
        // USE_MOBILITY: bool advRtrAddr;
    };

    /*************RFC 2461: Section 10 Protocol Constants**********************/
    struct RouterConstants
    {
        simtime_t maxInitialRtrAdvertInterval;
        uint maxInitialRtrAdvertisements;
        uint maxFinalRtrAdvertisements;
        simtime_t minDelayBetweenRAs;
        simtime_t maxRADelayTime;
    };
    RouterConstants routerConstants;

    struct HostConstants
    {
        simtime_t maxRtrSolicitationDelay;
        simtime_t rtrSolicitationInterval;
        int maxRtrSolicitations;
    };
    HostConstants hostConstants;

    struct NodeConstants
    {
        uint maxMulticastSolicit;
        uint maxUnicastSolicit;
        simtime_t maxAnycastDelayTime;
        uint maxNeighbourAdvertisement;
        simtime_t reachableTime;
        simtime_t retransTimer;
        simtime_t delayFirstProbeTime;
        double minRandomFactor;
        double maxRandomFactor;
    };
    NodeConstants nodeConstants;
    /***************END of RFC 2461 Protocol Constants*************************/

  protected:
    // addresses
    struct AddressData
    {
        IPv6Address address;  // address itself
        bool tentative;       // true if currently undergoing Duplicate Address Detection
        simtime_t expiryTime; // end of valid lifetime; 0 means infinity
        simtime_t prefExpiryTime; // end of preferred lifetime; 0 means infinity
    };
    typedef std::vector<AddressData> AddressDataVector;
    // TBD should be std::map, so that isLocalAddress() is faster?

    AddressDataVector addresses;   // interface addresses
    IPv6Address preferredAddr; // cached result of preferred address selection
    simtime_t preferredAddrExpiryTime;

    /***************RFC 2462: Section 5.1 Node Configuration Variables*********/
    struct NodeVariables
    {
        int dupAddrDetectTransmits;
    };
    NodeVariables nodeVars;
    /***************END of RFC 2461 Node Configuration Variables***************/

    /***************RFC 2461: Section 6.3.2 Host Variables*********************/
    struct HostVariables
    {
        uint linkMTU;
        short curHopLimit;
        uint baseReachableTime;
        simtime_t reachableTime;
        uint retransTimer;
    };
    HostVariables hostVars;
    /***************END of RFC 2461 Host Variables*****************************/

    /***************RFC 2461: Section 6.2.1 Router Configuration Variables*****/
    typedef std::vector<AdvPrefix> AdvPrefixList;
    struct RouterVariables
    {
        bool advSendAdvertisements;
        simtime_t maxRtrAdvInterval;
        simtime_t minRtrAdvInterval;
        bool advManagedFlag;
        bool advOtherConfigFlag;// also false as not disseminating other config info from routers
        int advLinkMTU;
        int advReachableTime; // host BaseReachableTime?
        int advRetransTimer; // host RetransTimer?
        short advCurHopLimit; // host CurHopLimit
        simtime_t advDefaultLifetime; // integer seconds in ND rfc but for MIPv6 really need better granularity
        //bool fastRA;
        //uint maxFastRAS;
        //mutable uint fastRACounter;

        // These are either learned from routers or configured manually(router)
        AdvPrefixList advPrefixList;
    };
    RouterVariables rtrVars;
    /***************END of RFC 2461 Host Variables*****************************/

  protected:
    int findAddress(const IPv6Address& addr) const;
    void choosePreferredAddress();
    void changed1() {changed(NF_INTERFACE_IPv6CONFIG_CHANGED);}

    static bool addrLess(const AddressData& a, const AddressData& b);

  public:
    IPv6InterfaceData();
    virtual ~IPv6InterfaceData() {}
    std::string info() const;
    std::string detailedInfo() const;

    virtual void assignAddress(const IPv6Address& addr, bool tentative,
                               simtime_t expiryTime, simtime_t prefExpiryTime);

    virtual void updateMatchingAddressExpiryTimes(const IPv6Address& prefix, int length,
                                     simtime_t expiryTime=0, simtime_t prefExpiryTime=0);

    int getNumAddresses() const {return addresses.size();}

    const IPv6Address& getAddress(int i) const;

    bool isTentativeAddress(int i) const;

// FIXME address validity check missing. introduce hasValidAddress(addr, now) which would compare lifetimes too?

    bool hasAddress(const IPv6Address& addr) const;

    bool matchesSolicitedNodeMulticastAddress(const IPv6Address& solNodeAddr) const;

    bool isTentativeAddress(const IPv6Address& addr) const;

    virtual void permanentlyAssign(const IPv6Address& addr);

    const IPv6Address& getPreferredAddress() const {return preferredAddr;}  // FIXME TBD check expiry time!

    const IPv6Address& getLinkLocalAddress() const;

    virtual void removeAddress(const IPv6Address& address);

    /************Getters for Router Protocol Constants*************************/
    simtime_t _getMaxInitialRtrAdvertInterval() {return routerConstants.maxInitialRtrAdvertInterval;}
    uint _getMaxInitialRtrAdvertisements() {return routerConstants.maxInitialRtrAdvertisements;}
    uint _getMaxFinalRtrAdvertisements() {return routerConstants.maxFinalRtrAdvertisements;}
    simtime_t _getMinDelayBetweenRAs() {return routerConstants.minDelayBetweenRAs;}
    simtime_t _getMaxRADelayTime() {return routerConstants.maxRADelayTime;}
    /************Setters for Router Protocol Constants*************************/
    virtual void _setMaxInitialRtrAdvertInterval(simtime_t d) {routerConstants.maxInitialRtrAdvertInterval = d;}
    virtual void _setMaxInitialRtrAdvertisements(uint d) {routerConstants.maxInitialRtrAdvertisements = d;}
    virtual void _setMaxFinalRtrAdvertisements(uint d) {routerConstants.maxFinalRtrAdvertisements = d;}
    virtual void _setMinDelayBetweenRAs(simtime_t d) {routerConstants.minDelayBetweenRAs = d;}
    virtual void _setMaxRADelayTime(simtime_t d) {routerConstants.maxRADelayTime = d;}
    /************End of Router Protocol Constant getters and setters***********/

    /************Getters for Host Protocol Constants***************************/
    simtime_t _getMaxRtrSolicitationDelay() {return hostConstants.maxRtrSolicitationDelay;}
    simtime_t _getRtrSolicitationInterval() {return hostConstants.rtrSolicitationInterval;}
    uint _getMaxRtrSolicitations() {return hostConstants.maxRtrSolicitations;}
    /************Setters for Host Protocol Constants***************************/
    virtual void _setMaxRtrSolicitationDelay(simtime_t d) {hostConstants.maxRtrSolicitationDelay = d;}
    virtual void _setRtrSolicitationInterval(simtime_t d) {hostConstants.rtrSolicitationInterval = d;}
    virtual void _setMaxRtrSolicitations(uint d) {hostConstants.maxRtrSolicitations = d;}
    /************End of Host Protocol Constant getters and setters*************/

    /************Getters for Node Protocol Constants***************************/
    uint _getMaxMulticastSolicit() {return nodeConstants.maxMulticastSolicit;}
    uint _getMaxUnicastSolicit() {return nodeConstants.maxUnicastSolicit;}
    simtime_t _getMaxAnycastDelayTime() {return nodeConstants.maxAnycastDelayTime;}
    uint _getMaxNeighbourAdvertisement() {return nodeConstants.maxNeighbourAdvertisement;}
    simtime_t _getReachableTime() {return nodeConstants.reachableTime;}
    simtime_t _getRetransTimer() {return nodeConstants.retransTimer;}
    simtime_t _getDelayFirstProbeTime() {return nodeConstants.delayFirstProbeTime;}
    double _getMinRandomFactor() {return nodeConstants.minRandomFactor;}
    double _getMaxRandomFactor() {return nodeConstants.maxRandomFactor;}
    /************Setters for Node Protocol Constants***************************/
    virtual void _setMaxMulticastSolicit(uint d) {nodeConstants.maxMulticastSolicit = d;}
    virtual void _setMaxUnicastSolicit(uint d) {nodeConstants.maxUnicastSolicit = d;}
    virtual void _setMaxAnycastDelayTime(simtime_t d) {nodeConstants.maxAnycastDelayTime = d;}
    virtual void _setMaxNeighbourAdvertisement(uint d) {nodeConstants.maxNeighbourAdvertisement = d;}
    virtual void _setReachableTime(simtime_t d) {nodeConstants.reachableTime = d;}
    virtual void _setRetransTimer(simtime_t d) {nodeConstants.retransTimer = d;}
    virtual void _setDelayFirstProbeTime(simtime_t d) {nodeConstants.delayFirstProbeTime = d;}
    virtual void _setMinRandomFactor(double d) {nodeConstants.minRandomFactor = d;}
    virtual void _setMaxRandomFactor(double d) {nodeConstants.maxRandomFactor = d;}
    /************End of Node Protocol Constant getters and setters*************/

    /************Getters for Node Variables************************************/
    int dupAddrDetectTransmits() {return nodeVars.dupAddrDetectTransmits;}
    /************Setters for Node Variables************************************/
    virtual void setDupAddrDetectTransmits(int d) {nodeVars.dupAddrDetectTransmits = d;}
    /************End of Node Variables getters and setters*********************/

    /************Getters for Host Variables************************************/
    uint getLinkMTU() {return hostVars.linkMTU;}
    short getCurHopLimit() {return hostVars.curHopLimit;}
    uint getBaseReachableTime() {return hostVars.baseReachableTime;}
    simtime_t getReachableTime() {return hostVars.reachableTime;}
    uint getRetransTimer() {return hostVars.retransTimer;}
    /************Setters for Host Variables************************************/
    virtual void setLinkMTU(uint d) {hostVars.linkMTU = d;}
    virtual void setCurHopLimit(short d) {hostVars.curHopLimit = d;}
    virtual void setBaseReachableTime(uint d) {hostVars.baseReachableTime = d;}
    virtual void setReachableTime(simtime_t d) {hostVars.reachableTime = d;}
    virtual void setRetransTimer(uint d) {hostVars.retransTimer = d;}
    /************End of Host Variables getters and setters*********************/

    /************Getters for Router Configuration Variables********************/
    bool getAdvSendAdvertisements() {return rtrVars.advSendAdvertisements;}
    simtime_t getMaxRtrAdvInterval() {return rtrVars.maxRtrAdvInterval;}
    simtime_t getMinRtrAdvInterval() {return rtrVars.minRtrAdvInterval;}
    bool getAdvManagedFlag() {return rtrVars.advManagedFlag;}
    bool getAdvOtherConfigFlag() {return rtrVars.advOtherConfigFlag;}
    int getAdvLinkMTU() {return rtrVars.advLinkMTU;}
    int getAdvReachableTime() {return rtrVars.advReachableTime;}
    int getAdvRetransTimer() {return rtrVars.advRetransTimer;}
    short getAdvCurHopLimit() {return rtrVars.advCurHopLimit;}
    simtime_t getAdvDefaultLifetime()  {return rtrVars.advDefaultLifetime;}
    /************Setters for Router Configuration Variables********************/
    virtual void setAdvSendAdvertisements(bool d) {rtrVars.advSendAdvertisements = d;}
    virtual void setMaxRtrAdvInterval(simtime_t d) {rtrVars.maxRtrAdvInterval = d;}
    virtual void setMinRtrAdvInterval(simtime_t d) {rtrVars.minRtrAdvInterval = d;}
    virtual void setAdvManagedFlag(bool d) {rtrVars.advManagedFlag = d;}
    virtual void setAdvOtherConfigFlag(bool d) {rtrVars.advOtherConfigFlag = d;}
    virtual void setAdvLinkMTU(int d) {rtrVars.advLinkMTU = d;}
    virtual void setAdvReachableTime(int d) {rtrVars.advReachableTime = d;}
    virtual void setAdvRetransTimer(int d) {rtrVars.advRetransTimer = d;}
    virtual void setAdvCurHopLimit(short d) {rtrVars.advCurHopLimit = d;}
    virtual void setAdvDefaultLifetime(simtime_t d) {rtrVars.advDefaultLifetime = d;}
    /************End of Router Configuration Variables getters and setters*****/

    virtual void addAdvPrefix(const AdvPrefix& advPrefix);

    int getNumAdvPrefixes() const {return rtrVars.advPrefixList.size();}

    const AdvPrefix& getAdvPrefix(int i) const;

    virtual void setAdvPrefix(int i, const AdvPrefix& advPrefix);

    virtual void removeAdvPrefix(int i);

    virtual simtime_t generateReachableTime(double MIN_RANDOM_FACTOR, double MAX_RANDOM_FACTOR,
                                            uint baseReachableTime);

    virtual simtime_t generateReachableTime();
  };

#endif