diff -r 000000000000 -r af10295192d8 networkprotocols/tcpipv4v6prt/inc/iface.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/networkprotocols/tcpipv4v6prt/inc/iface.h Tue Jan 26 15:23:49 2010 +0200 @@ -0,0 +1,258 @@ +// 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 +#include +#include +#ifdef SYMBIAN_TCPIPDHCP_UPDATE +#include +#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 iRdnssArrayList; // RDNSS Server List [index 0 set to iNameserver1, index 1 set to iNameServer2] + RArray iRdnssLifetimeArrayList;// RDNSS Dummy Server List for sorting Lifetime + }; +#endif // SYMBIAN_TCPIPDHCP_UPDATE + +#endif