// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// iface.cpp - IPv6/IPv4 interface and route manager

// Implementations of flows, routes and interfaces for IPv6.

// CIp6Manager

// |iInterfaceList 

// /         iFlowList\    /       iRouteList\  |

// V    iRoute           \ V    iInterface      \V

// CIp6Flow ------------> CIp6Route -----------> CIp6Interface  ---> NIF

// |iNext                  |iNext       iAddress/|iNext

// |                       |         CIp6Address |

// |                       |         (list) |    |

// V                       V                     |

// CIp6Flow               CIp6Route                 V

// |                       |                  CIp6Interface

// íAddress/|

// CIp6Address

// A sketch of the Interface state transitions from StartSending/Error/Send calls

// and the resulting return values for StartSending (UP, READY). Not

// shown, but NONE is returned when StartSending is called in READY

// (unless address is changed, in which case UP is returned regardless

// of previous state).

// / Error( <0 )         / Error( <0 )      |

// |                     |                   V

// PENDING ------------> READY --------------> DOWN

// StartSending   | ^  Error( <0 )      |

// ( == UP)    | |                  /

// Send| |( == READY)     /

// return| |StartSending  /

// V |            /

// HOLD --------->

// Error (<0)

// Define WEAK_ES, if you don't want STRONG ES model for

// the host.

//

/**

 @file iface.cpp

 @verbatim

 @endverbatim

 @verbatim

 @endverbatim

*/

#undef WEAK_ES

//#define WEAK_ES

// Support for IPv6 DNS Configuration based on Router Advertisement

#define SYMBIAN_NETWORKING_UPS

//

// In Epoc R6 nifman.h has been split, CNifIfBase definition has been moved

// into <comms-infras/nifif.h>.

//

#include <e32hal.h>

#include <e32math.h>

#include <nifman.h>

#include <comms-infras/nifif.h> // ..for CNifIfBase in Epoc R6 and later

#include <in6_opt.h>

#include <in_sock.h>

#include "inet6log.h"

#include "iface.h"

#include <icmp6_hdr.h>

#include <in_chk.h>

#include <ip6_hook.h>

#include "in_flow.h"

#include <timeout.h>

#include <inet6err.h>

#include "addr46.h"

#ifdef ARP

#include <arp_hdr.h>

#endif

#include <es_ini.h>

#ifdef SYMBIAN_NETWORKING_UPS

#include "in_trans.h"

#endif

#include "tcpip_ini.h"

#include "networkinfo.h"

#include <in6_event.h>

#include <in6_dstcache.h>

#include "in6_version.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <in_sock_internal.h>

#include <in6_dstcache_internal.h>

#endif

// Temporay backward portability definition, until

// KErrLinkConfigChanged is standard from some SDK

// version forward. For now, if a special version

// is installed, define LINK_CONFIG_CHANGED in MMP

// file. -- msa

#ifdef LINK_CONFIG_CHANGED

#   include <agenterrors.h>

#else

#   define  KErrLinkConfigChanged (-3060)

#endif

#include <comms-infras/nifif_internal.h>

#include <nifman_internal.h>

//

// DAEMON_USE_PROCESSES must be set in MMP file if required by SDK. It

// determines whether daemons are to be run on threads or on real

// processes. Only force here that processes are always used when

// compiling for target device.

//

/**

* The basic timer unit.

*

* To enable compile time optimization, the unit is

* defined as preprocessor constant. The value indicates

* the fraction of the second to be used as a basic unit

* of the timer. This can be from 1 to 1000000 (from 1

* second to 1 microsecond).

*/

#define TIMER_UNIT 100

#ifdef SYMBIAN_TCPIPDHCP_UPDATE

const TInt KRDNSSGranularity = 4; // Shall hold not more than 4 RDNSS Address

#endif //SYMBIAN_TCPIPDHCP_UPDATE

//

//lint -save -e708 stupid lint info

/**

* @name Well known multicast and other addresses of the neighbour discovery.

*

* @{

*/

/** Multicast to all receivers on this node. */

const TIp6Addr KInet6AddrNodeLocal  = {{{0xff,0x01,0,0,0,0,0,0,0,0,0,0,0,0,0,1}}};

/** Multicast to all hosts on the link. */

const TIp6Addr KInet6AddrAllNodes   = {{{0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,1}}};

/** Multicast to all routers on the link  */

const TIp6Addr KInet6AddrAllRouters = {{{0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,2}}};

/** @} */

//lint -restore

// speed optimisations

#ifdef __ARMCC__

#pragma push

#pragma arm

#endif

class TInetNdConfig

    /**

    * Neighbor Discovery (RFC-2461) Protocol Constants.

    *

    * The constants are defined as members of TInetNdConfig, because

    * in future it is possible that a link layer specific variations

    * will be defined and some control option is provided to access

    * them.

    *

    * (with some extras from RFC-2462).

    */

    {

public:

    // - router constants

    TUint iMaxInitialRtrAdvertInterval; //< seconds

    TUint iMaxInitialRtrAdvertisements; //< transmissions

    TUint iMaxFinalRtrAdvertisements;   //< transmissions

    TUint iMinDelayBetweenRas;          //< seconds

    // - host constants

    TUint iMaxRtrSolicitationDelay;     //< seconds

    TUint iRtrSolicitationInterval;     //< seconds

    TUint iMaxRouterSolicitations;      //< transmissions

    // - node constants

    TUint iMaxMulticastSolicit;         //< transmissions

    TUint iMaxUnicastSolicit;           //< transmissions

    TUint iMaxAnycastDelayTime;         //< seconds

    TUint iMaxNeighborAdvertisement;    //< transmissions

    TUint iReachableTime;               //< milliseconds

    TUint iRetransTimer;                //< milliseconds

    TUint iDelayFirstProbeTime;         //< seconds

    TReal iMinRandomFactor;             //

    TReal iMaxRandomFactor;

    // RFC-2462 additions

    TUint iDupAddrDetectTransmits;      //< transmissions

    // IPv4 (and IPv6?) (draft-ietf-zeroconf-ipv4-linklocal-05)

    TUint iMaxAddrRegenerations;        //< addresses generated

    TUint iDupAddrDefendTime;           //< seconds

    // IPv4 Linklocal Address specifications (draft-ietf-zeroconf-ipv4-linklocal-05)

    TUint iIPv4DupAddrDetectTransmits;  //< transmissions

    TUint iIPv4DupAddrAnnouncements;    //< announcements

    TUint iIPv4RetransTimer;            //< seconds (for Dup and Announce)

    // Router Reachability probing (draft-ietf-ipv6-router-selection-02.txt)

    TUint iRateLimitProbingTime;        //< seconds

    };

/** The current default values (from RFC-2461). */

const TInetNdConfig KInetNdConfig =

    {

    //- router constants

    /* MaxInitialRtrAdvertInterval */   16, // seconds

    /* MaxInitialRtrAdvertisements */   3,  // transmissions

    /* MaxFinalRtrAdvertisements */     3,  // transmissions

    /* MinDelayBetweenRas */            3,  // seconds

    // - host constants

    /* MaxRtrSolicitationDelay */       1,  // second

    /* RtrSolicitationInterval */       4,  // seconds

    /* MaxRouterSolicitations */        3,  // transmissions

    // - node constants

    /* MaxMulticastSolicit */           3,  // transmissions

    /* MaxUnicastSolicit */             3,  // transmissions

    /* MaxAnycastDelayTime */           1,  // second

    /* MaxNeighborAdvertisement */      3,  // transmissions

    /* ReachableTime */             30000,  // milliseconds

    /* RetransTimer */               1000,  // milliseconds

    /* DelayFirstProbeTime */           5,  // seconds

    /* MinRandomFactor */               0.5,

    /* MaxRandomFactor */               1.5,

    // - RFC-2462 additions

    /* DupAddrDetectTransmits */        1,  // transmissions

    // IPv4 (and IPv6?) (draft-ietf-zeroconf-ipv4-linklocal-05)

    /* MaxAddrRegenerations */          10, // max addresses generated

    /* DupAddrDefendTime */             10, // seconds

    // IPv4 Linklocal Address specifications (draft-ietf-zeroconf-ipv4-linklocal-07)

    /* IPv4DupAddrDetectTransmits */    3,  // transmissions

    /* IPv4DupAddrAnnouncements */      2,  // announcements

    /* IPv4RetransTimer */              1,  // seconds (for Dup and Announce)

    // Router Reachability probing (draft-ietf-ipv6-router-selection-02.txt)

    /* iRateLimitProbingTime */         60  // seconds

    };

/**

* @name Route Preference constants

*

* @{

*/

/** Route preference values. */

enum TRoutePreference

    {

    ERoutePreference_MEDIUM = 0,    //< Prf = 0

    ERoutePreference_HIGH   = 1,    //< Prf = 1

    ERoutePreference_INVALID= 2,    //< Prf = -0

    ERoutePreference_LOW    = 3     //< Prt = -1

    };

/** Translate TRoutePrefence value to route metric. */

const TInt KPreferenceMetric[4] =

    {

    1,  // 0 (medium) and the default for metric in all created routes.

    0,  // 1 (high)

    0,  // 2 (invalid)

    2,  // 3 (low)

    };

/** @} */

//

// TIcmpNdHeader

// *************

class TIcmpNdHeader

    /** 

    * Collection of the ICMP Messages relating to the

    * Neigbor Discovery (RFC 2461).

    */

    {

public:

    //

    // Basic

    //

    inline static TInt MinHeaderLength() {return 8; }

    inline static TInt MaxHeaderLength() {return 40; }  // Not much useful

    union

        {

        TInet6HeaderICMP iIcmp;

        TInet6HeaderICMP_RouterSol iRS;

        TInet6HeaderICMP_RouterAdv iRA;     

        TInet6HeaderICMP_NeighborSol iNS;

        TInet6HeaderICMP_NeighborAdv iNA;

        TInet6HeaderICMP_Redirect iRD;

        };

    };

//

// TIcmpNdOption

// *************

class TIcmpNdOption

    /**

    * Collection of the ICMP options relating to the

    * Neighbor Disovery (RFC 2461).

    */

    {

public:

    inline static TInt MinHeaderLength() {return 8; }

    inline static TInt MaxHeaderLength() {return 40; }  // Not much useful

    union

        {

        TInet6OptionICMP_LinkLayer iLink;

        TInet6OptionICMP_Prefix iPrefix;

        TInet6OptionICMP_Mtu iMtu;

#if 1

        // Experimental: draft-ietf-ipv6-router-selection-02.txt

        // Default Router Preferences, More-Specific Routes, and Load Sharing

        TInet6OptionICMP_RouteInformation iRouteInformation;

#endif

#ifdef SYMBIAN_TCPIPDHCP_UPDATE

        // IPv6 DNS Configuration based on Router Advertisement: RFC-5006

        TInet6OptionICMP_DnsInformationV1 iDnsInformation;

#else

        // Experimental: draft-jeong-dnsop-ipv6-discovery-03.txt

        // IPv6 DNS Configuration based on Router Advertisement

        TInet6OptionICMP_DnsInformation iDnsInformation;

#endif //SYMBIAN_TCPIPDHCP_UPDATE

        };

    };

// TRouteAddress

// *************

class TRouteAddress

    /**

    * Internal class to hold an address.

    *

    * Internal help class which can hold any address of the TSockAddr, but

    * does not inlude the port field or TBuf8 descriptor. Mainly required

    * to get rid of the TSockAddr constructor, which prevents it's use

    * inside union structure.

    *

    * If family is KAfInet6, then address is IPv6 or IPv4 address; otherwise

    * the address is assumed to be a link layer address.

    *

    * Only a raw addresses are handled. Port, Scope Id and Flow label are

    * not included.

    */

    {

public:

    inline TUint Family() const { return iFamily; }

    inline TPtrC8 Address() const

        /**

        * Get the raw address bytes.

        * @return descriptor for the raw address bytes.

        */

        {

        return TPtrC8(iBuf, iLength);

        }

    inline const TIp6Addr &Ip6Address() const

        /**

        * Get the raw IPv6 address.

        *

        * @return IPv6 address.

        */

        {

        return (TIp6Addr &)iBuf[0];

        }

    void SetAddress(const TIp6Addr &aAddr);

    void SetAddress(const TSockAddr &aAddr);

    void GetAddress(TSockAddr &aAddr) const;

    TBool Match(const TSockAddr& aAddr) const;

private:

    TUint iFamily;      //< Address family (0 = KAFUnspec)

    TUint iLength;      //< The length of the stored address

    // ..and enough space for any possible address used in TSockAddr

    TUint8 iBuf[KMaxSockAddrSize];//< Address bytes.

    };

void TRouteAddress::SetAddress(const TIp6Addr &aAddr)

    /**

    * Set address from raw IPv6 address.

    *

    * @param aAddr The Address.

    */

    {

    ASSERT(sizeof(iBuf) >= sizeof(TIp6Addr));

    *(TIp6Addr *)iBuf = aAddr;

    iFamily = KAfInet6;

    iLength = sizeof(TIp6Addr);

    }

void TRouteAddress::SetAddress(const TSockAddr &aAddr)

    /**

    * Set address from a TSockAddr.

    *

    * @param aAddr The Address

    */

    {

    TPtr8 ptr(iBuf, sizeof(iBuf));

    ptr = TLinkAddr::Cast(aAddr).Address();

    // Unfortunately, IPv6 addresses have to be treated specially,

    // the iLength must reflect the plain IPv6 address, and not the

    // TInetAddr user length. Otherwise, setting IPv6

    // from TInetAddr and TIp6Addr will not result matching

    // entries... (icky! Perhaps needs some other fix..)

    // Someone is bound to trip over this!! -- msa

    // [...to use TInetAddr Userlen() is *NOT* a solution. Comparisons

    // should only involve IPv6 address and not include scope/flow etc.]

    iFamily = aAddr.Family();

    iLength = iFamily == KAfInet6 ? sizeof(TIp6Addr) : ptr.Length();

    }

void TRouteAddress::GetAddress(TSockAddr &aAddr) const

    /**

    * Gets stored address into TSockAddr

    *

    * @retval aAddr The address.

    */

    {

    // Have to undo the trickery in SetAddress (yet another yechh!) -- msa

    if (iFamily == KAfInet6)

        TInetAddr::Cast(aAddr).SetAddress(Ip6Address());

    else

        {

        aAddr.SetFamily(iFamily);

        TLinkAddr::Cast(aAddr).SetAddress(Address());

        }

    }

TBool TRouteAddress::Match(const TSockAddr& aAddr) const

    /**

    * Tests if the stored address matches another address.

    *

    * @param aAddr Another address.

    *

    * @return ETrue, if addresses are same; otherwise EFalse.

    */

    {

    if (iFamily != aAddr.Family())

        return FALSE;

    if (iFamily == KAFUnspec)

        return TRUE;

    if (iFamily == KAfInet6)

        return Ip6Address().IsEqual(TInetAddr::Cast(aAddr).Ip6Address());

    else

        return Address() == TLinkAddr::Cast(aAddr).Address();

    }

// TSolicitedNodeAddr

// *******************

class TSolicitedNodeAddr : public TIp6Addr

    /**

    * Generates Solicited Node Multicast address.

    *

    * An class whose sole purpose is to construct an intialized

    * TIp6Address, which holds a solicited node multicast address

    */

    {

public:

    TSolicitedNodeAddr(const TIp6Addr &aAddress)

        {

        const union { TUint8 a[4]; TUint32 b; } mc_node = {{0xff, 0x02, 0, 0}};

        const union {TUint8 a[4]; TUint32 b;} one = { {0, 0, 0, 1} };

        const union {TUint8 a[4]; TUint32 b;} ff = { {0xff, 0, 0, 0} };

        u.iAddr32[0] = mc_node.b;

        u.iAddr32[1] = 0;

        u.iAddr32[2] = one.b;

        u.iAddr32[3] = ff.b | aAddress.u.iAddr32[3];

        }

    };

// Lifetime definitions

// ********************

// (values are seconds)

//

typedef TUint32 TLifetime;

const TUint32 KLifetimeForever = KMaxTUint32;

//

// The implementations of

//      CIp6Interface

//      CIp6Route

//      CIp6Flow

//      CIp6NifUser

//      CIp6Daemon

// are internal to this module and thus the class declaration do not need to

// be visible to any outsider.

//

// *NOTE*

//      The public/private/protected and friend designations are total mess

//      and should be cleaned up, if nothing else, then make all public, as

//      these classes cross reference each other too much... -- msa

//

class CIp6Flow;

class CIp6Route;

class CIp6Interface;

class CIp6NifUser;

class CIp6Daemon;

class MNifIfUser;

class CNifIfBase;

class MTimeoutManager;

//

//  CIp6Manager

//  ***********

//

class CIp6Manager : public CIfManager, public MNetworkInfo

    , public MProvdSecurityChecker

    {

    // ... lots of "friends", look into this later -- msa

    friend class CIp6Flow;

    friend class CIp6Interface;

    friend class CIp6Route;

    friend class CIp6NifUser;

    friend class CIp6ManagerTimeoutLinkage;

    //

    // Construct and InitL are only used from CIfManager::NewL()

    //