// 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.h - IPv6/IPv4 interface and route manager

//

/**

 @internalComponent

*/

#ifndef __IFACE_H__

#define __IFACE_H__

// The preprocessor symbol: ARP

// ----------------------------

// Add code for doing IPv4 Address Resolution Protocol (ARP) on

// IPv4 interfaces that specify "NeedNd". (also needed in ip6.cpp)

//

#undef ARP

#define ARP	1		// include IPv4 ARP code always for now.

#ifdef SYMBIAN_TCPIPDHCP_UPDATE

//RFC 5006 definitions

#define RDNSS_REFRESH_TIMEOUT 30

#define RDNSS_NAMESERVER1 1

#define RDNSS_NAMESERVER2 2

#define RDNSSMINLEN 24 // Minimum Length is 3 for a single Address i.e (8 * 3 = 24 Octets)

#endif //SYMBIAN_TCPIPDHCP_UPDATE

#include <e32base.h>

#include <ip6_hook.h>

#include <in_bind.h>

#ifdef SYMBIAN_TCPIPDHCP_UPDATE

#include <icmp6_hdr.h>

#endif //SYMBIAN_TCPIPDHCP_UPDATE

//

// The special returns from StartSending and Error calls are

//

//	The generic rules are as follows:

//

//		returns > 0,	ready to send data out (was not possible previously)

//		returns = 0,	no further action required

//		returns < 0,	interface is down

//

const TInt KIfaceTransition_UP		= 2;	// Interface changed from PENDING/DOWN to READY

const TInt KIfaceTransition_READY	= 1;	// Interface changed from HOLD to READY

const TInt KIfaceTransition_NONE	= 0;	// No change in the interface state (only PENDING, READY or HOLD)

const TInt KIfaceTransition_DOWN	= KErrNotReady;	// (never compare return value against this directly!), only for < 0.

class TIcmpTypeCode

	/**

	* A help class to package both IPv4 and IPv6 ICMP type and code.

	*

	* This is just a parameter to MNetworkServiceExtension::IcmpWrap method.

	*/

	{

public:

	TIcmpTypeCode(TUint8 a4type, TUint8 a4code, TUint8 a6type, TUint8 a6code)

		: i4type(a4type), i4code(a4code), i6type(a6type), i6code(a6code) {}

	const TUint8 i4type;

	const TUint8 i4code;

	const TUint8 i6type;

	const TUint8 i6code;

	};

//	MNetworkServiceExtension

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

//	Extends the MNetworkService with additional private methods

//	which are only used betwen the interface manager and IP

//	protocol instance.

class CNifIfBase;

class MNetworkServiceExtension : public MNetworkService

	{

public:

	// InterfaceAtteched is called just after the CNifIfBase pointer has

	// been stored into the internal interface manager instance (CIp6Interface),

	// aIf->Open() has been called.

	virtual void InterfaceAttached(const TDesC &aName, CNifIfBase *aIf) = 0;

	// InterfaceDetached is called just before the CNifIfBase pointer is going

	// going to be removed from the internal interface managere instance

	// (CIp6Interface) and before the aIf->Close() is being called.

	virtual void InterfaceDetached(const TDesC &aName, CNifIfBase *aIf) = 0;

	// Wrap a packet into ICMP error reply

	virtual void IcmpWrap(RMBufChain &aPacket, const TIcmpTypeCode aIcmp, const TUint32 aParameter = 0, const TInt aMC = 0) = 0;

	// Fragment packet to specificied MTU

	virtual TBool Fragment(RMBufSendPacket &aPacket, RMBufSendInfo &aInfo, TInt aMtu, RMBufPktQ &aFragments) = 0;

	};

//

//	CIfManager

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

//

class MNifIfUser;

class MFlowManager;

class CFlowContext;

class RTimeout;

class CIfManager : public CBase, public MInterfaceManager

	{

	friend class CProtocolFamilyInet6;

	//

	// Construct and destruct (only used by the INET6 Family object)

	//

	static CIfManager *NewL();

protected:

	virtual ~CIfManager() {}

public:

	virtual CFlowContext *NewFlowL(const void *aOwner, MFlowManager *aManager, TUint aProtocol) = 0;

	virtual CFlowContext *NewFlowL(const void *aOwner, MFlowManager *aManager, CFlowContext &aFlow) = 0;

	virtual TInt SetChanged() const = 0;

	//

	//

	virtual TInt StartSending(CNifIfBase *aIface) = 0;

	virtual TInt Error(TInt aError, CNifIfBase *aIface) = 0;

	//

	// Protocol registering (iNifUsers list)

	//

	virtual MNifIfUser *Register(MNetworkServiceExtension *aService) = 0;	// Makes protocol visible to interfaces

	virtual void Unregister(MNetworkServiceExtension *aService) = 0;		// Removes protocol (called from protocol destructor)

	//

	//  IcmpError() is only intended to be used from the

	//	IcmpError() method of the IP protocol instance. The

	//	packet in the aHead is in "unpacked" state, and it

	//	begins with the returned IP header.

	//	Returns

	//	> 0,if packet has been released (not a normal

	//		situation, as this would prevent it reaching

	//		the upper layers)

	//	= 0,if ICMP noted and can be passed to the

	//		appropriate upper layer protocol

	//	> 0,NOT USED CURRENTLY! (treat as = 0)

	//	The first reason for this method is to get the

	//	path MTU mechanism implemented.

	//

	virtual TInt IcmpError(RMBufRecvPacket &aPacket, RMBufRecvInfo &aInfo) = 0;

	virtual TInt IcmpHandler(RMBufRecvPacket &aPacket, RMBufRecvInfo &aInfo) = 0;

#ifdef ARP

	virtual TInt ArpHandler(RMBufRecvPacket &aPacket, RMBufRecvInfo &aInfo) = 0;

#endif

	virtual TInt IsForMePacket(RMBufRecvInfo &aInfo) const = 0;

	virtual void SetTimer(RTimeout &aHandle, TUint32 aDelay) = 0;

	virtual TInt GetIniValue(const TDesC &aSection, const TDesC &aName, TInt aDefault = 0, TInt aMin = 0, TInt aMax = 1) = 0;

	};

static const TInt KLoopbackMcastMetric = 0xffff;

    //< Metric set for multicast routes on loopback interface

#ifdef _LOG

// Internal help function for logging only

//extern void PktLog(const TDesC &aFormat, const RMBufPktInfo &aInfo, const TDesC &aName);

extern void PktLog(const TDesC &aFormat, const RMBufPktInfo &aInfo, TUint aIndex, const TDesC &aName);

#endif

#ifdef SYMBIAN_TCPIPDHCP_UPDATE

//RFC-5006 Changes

typedef TUint32 TRdnssLifetime;

class TRdnssOptionData

//Class to read RDNSS option data from TInet6OptionICMP_DnsInformationV1

/*

@internalTechnology

*/

    {

public:

    TRdnssLifetime iStoredRdnssLifeTime; // (life time + system time) at which iRDNSS address becomes invalid   

    TInetAddr iRDNSSaddress;             //128 bit DNS address

    };

class TRdnssSortData

//Class to Sort RDNSS Server List data

/*

@internalTechnology

*/

    {

public:    

    TRdnssLifetime iStoredRdnssLifeTime; // (life time + system time) at which iRDNSS address becomes invalid   

    TInt iRdnssServerListIndex;          //index corresponds to iRdnssArrayList entries

    };

//Class to Manage RDNSS option data from TInet6OptionICMP_DnsInformationV1

class CManageRdnssServerList: public CBase

/*

@ internalTechnology

*/

    {

public:

    static CManageRdnssServerList *NewL();

    ~CManageRdnssServerList();

public:

    // Functions to Process RDNSS Option and Manage RDNSS server List

    void RdnssProcessOptionData(TInet6OptionICMP_DnsInformationV1 aRdnssOption, TUint8 aNumRdnssAddr);

    TBool RdnssParseOptionHdr(TInet6OptionICMP_DnsInformationV1 aRdnssOption, TUint8& aNumRdnssAddr );  

    void RdnssServerListUpdate(TInet6OptionICMP_DnsInformationV1 aRdnssIcmpOption, TUint8 aNumRdnssAddr);

    TBool RdnssServerListSync(TInetAddr& aNameSer1, TInetAddr& aNameSer2);

    // Functions to syncrhonise NameServer Entries

    void RdnssNameServerUpdate(TInetAddr& aNameSer, TUint8 aNameSerIndex);

    void RdnssNameServerSync(TInt aRdnssIndex, TInetAddr& aNameSer1, TInetAddr& aNameSer2 ); 

    void RdnssNameServerReset(TInetAddr& aNameSer, TInt& aDdnsflag);

    //RArray Wrapper Functions

    inline TInt CountRdnssEntry() {  return iRdnssArrayList.Count(); }

    inline TInt CountRdnssLifetimeEntry() { return iRdnssLifetimeArrayList.Count(); }

    TBool InsertRdnssEntryL(TRdnssOptionData& aRdnssEntry, TInt aIndex);    

    void DeleteRdnssEntry(TInt aRdnssArrayIndex);

    void DeleteRdnssLifetimeEntry(TInt aRdnssArrayIndex);

    //Miscallaneous Utitility Functions

    TRdnssOptionData& GetRdnssEntryRef(TInt aIndex);

    TRdnssSortData& GetRdnssLifetimeEntryRef(TInt aIndex);

    TBool RdnssEntryExists(const TIp6Addr& aRdnssAddr, TInt& aIndex);   

    TInt& GetRdnssFlag();

    void SetStoredLifeTime(TInt aIndex, TRdnssOptionData aRdnssData);    

    void RdnssExpireLeastEntry(TRdnssOptionData aRdnssRcvData);

    void RdnssServerListDelete();

    void RdnssServerListSort();

    void RdnssServerListCopyL();    

    void PrintRdnssServerList(TUint8 aIndex);

    void PrintRdnssLifetimeList(TUint8 aIndex);    

    void RdnssLifetimeListDelete();

    // Return the number of seconds between the given time (aStamp) and

    // the time when interface was activated (iTimeStamp). aStamp must

    // always be same of after iTimeStamp.      

    TRdnssLifetime Elapsed(const TTime &aStamp) const;

    TRdnssLifetime GetRemainingLifeTime(TInt aRdnssEntryindex);

    TRdnssLifetime ElapsedLifeTime(TRdnssOptionData aRdnssEntry);

private:

    CManageRdnssServerList();

    void ConstructL();                            // Two Phase construction

private:    

    TTime iCurrentTimeStamp;                      // TimeStamp at which RDNSS data is stored

    TInt  iRouterLifeTime;                        // Router lifetime

    TInt  iRdnssFlag;                              // RDNSS Flag associated with Resolver repository1 and Repository2

    RArray<TRdnssOptionData> iRdnssArrayList;     // RDNSS Server List [index 0 set to iNameserver1, index 1 set to iNameServer2]

    RArray<TRdnssSortData>   iRdnssLifetimeArrayList;// RDNSS Dummy Server List for sorting Lifetime

 };

#endif // SYMBIAN_TCPIPDHCP_UPDATE

#endif