// 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:

// Implements the DHCP Message format

// 

//

/**

 @file DHCPIP6Msg.cpp

 @internalTechnology

*/

#include "DHCPIP6IA.h"

#include "DHCPAuthentication.h"

#include "DHCP_Std.h"

using namespace DHCPv6;

COptionNode::~COptionNode()

	{

	delete iNext;

	}

COptionNode* COptionNode::NewL()

	{

	return new(ELeave)COptionNode(NULL);

	}

COptionNode* CDHCPOptionAny::NewL()

	{

	return new(ELeave)CDHCPOptionAny(NULL);

	}

COptionNode* CDHCPOptionStatusCode::NewL()

	{

	return new(ELeave)CDHCPOptionStatusCode();

	}

COptionNode* CDHCPOptionRequestOption::NewL()

	{

	return new(ELeave)CDHCPOptionRequestOption();

	}

struct SOptionHeader

	{

	TInt iCode;

#ifdef __FLOG_ACTIVE

	const TText8* iName;

#endif

	};

#ifdef __FLOG_ACTIVE

const TInt KNumberOfSupportedOptions = 23;

const SOptionHeader KOptions[KNumberOfSupportedOptions + 1]= 

	{   //iCode,                     iName

		{EClientId,          _S8( "EClientId" )},

		{EServerId,          _S8( "EServerId" )},

		{EIaNa,              _S8( "EIaNa" )},

		{EIaTa,              _S8( "EIaTa" )},

		{EIaAddr,            _S8( "EIaAddr" )},

		{EOro,               _S8( "EOro" )},

		{EPreference,        _S8( "EPreference" )},

		{EElapsedTime,       _S8( "EElapsedTime" )},

		{ERelayMsg,          _S8( "ERelayMsg" )},

		{EAuthentication,    _S8( "EAuthentication" )},

		{EUnicast,           _S8( "EUnicast" )},

		{EStatusCode,        _S8( "EStatusCode" )},

		{ERapidCommit,       _S8( "ERapidCommit" )},

		{EUserClass,         _S8( "EUserClass" )},

		{EVendorClass,       _S8( "EVendorClass" )},

		{EVendorOpts,        _S8( "EVendorOpts" )},

		{EInterfaceId,       _S8( "EInterfaceId" )},

		{EReconfMsg,         _S8( "EReconfMsg" )},

		{EReconfAccept,      _S8( "EReconfAccept" )},

		{ESipServerD,        _S8( "ESipServerD" )},

		{ESipServerA,        _S8( "ESipServerA" )},

		{EDNSServers,        _S8( "EDNSServers" )},

		{EDomainList,        _S8( "EDomainList" )},

		{0,                          _S8( "EUnknown" )}

	};

void COptionNode::Dump(const TDesC& aTag, const TDesC& aFile)

	{

	RFileLogger f;

	if (f.Connect() == KErrNone)

		{

		f.CreateLog(aTag, aFile, EFileLoggingModeAppend);

		TInt i = 0;

      TInt nCode = OpCode();

		while (KOptions[i].iCode != nCode && ++i < KNumberOfSupportedOptions){/*do nothing*/}

		f.WriteFormat(_L8("Option Code: %s, length: %d"), KOptions[i].iName, nCode);

		if (GetItemLength() > KOptionHeaderLength)

			{

			f.HexDump(NULL, NULL, GetBodyPtr(), GetLength());

			}

		f.CloseLog();

		f.Close();

		}

	}

#endif

//simple static const mapping option id to the handling class constructor

//to simplify parsing

namespace DHCPv6

{

typedef COptionNode* (*TOptionCostructor)();

struct SMapOptionNumberToOption

{

   TUint iOption;

   TOptionCostructor iNewL;

};

static const SMapOptionNumberToOption mapOptionNumberToOption[] = {

    {EIaNa                  , CDHCPOptionIA_NA::NewL},       //Identity Association for Non-temporary Addresses 

    {EIaTa                  , CDHCPOptionIA_TA::NewL},          //Identity Association for Temporary Addresses

    {EOro                   , CDHCPOptionRequestOption::NewL},//Option Request - identify a list of options in a message

    {EAuthentication        , CDHCPOptionAuthentication::NewL},

    {EDNSServers		    , CDHCPOptionDNSServers::NewL},

    {ESipServerA			, CDHCPOptionSipServerAddrs::NewL},    	

    {EOptionAny             , COptionNode::NewL}

	};

//the rest of the options uses CDHCPOptionAny::NewL

}//namespace DHCPv6

void COptionList::ParseL(TPtr8& aDes8)

/**

  * Parse message to set pointers into descriptor buffer

  * at locations of each option supplied in a response msg

  *

  * @internalTechnology

  */

	{

	ASSERT(!iRecord.iFirst);

    COptionNode** ppNode = reinterpret_cast<COptionNode**>(&iRecord.iFirst);

	while(aDes8.Length())

        {

        User::LeaveIfError(aDes8.Length() < KOptionHeaderLength ? KErrBadDescriptor : KErrNone);

        TUint nOptCode = TBigEndian::GetValue(aDes8.Ptr(), KOptionLengthOffset);

		*ppNode = CreateNodeL(nOptCode);

		(*ppNode)->ParseL(aDes8);

		ppNode = reinterpret_cast<COptionNode**>(&(*ppNode)->iNext);

		}

	}

TUint32 COptionList::GetL( TInt aIndex, TUint aOpCode ) const

/**

  * Return a value from the message in big endian format

  *

  * @internalTechnology

  */

	{

	COptionNode* pNode = FindOption(aOpCode);

   if ( !pNode || pNode->GetLength() < aIndex * K32bitNumberOctets + K32bitNumberOctets )

      {

      User::Leave( KErrNotFound );

      }

   return TBigEndian::GetValue( pNode->Ptr() + aIndex * K32bitNumberOctets, K32bitNumberOctets );

	}

COptionNode* COptionList::CreateNodeL( TUint aOpCode )

   {

   TInt n = 0;

   while ( mapOptionNumberToOption[n].iOption != aOpCode && 

      mapOptionNumberToOption[n].iOption != EOptionAny )

      {

      n++;

      };

	return (*mapOptionNumberToOption[n].iNewL)();

   }

COptionNode* COptionList::AddNodeL(TOptionCodes aOpCode, TInt aInitialLength)

/**

  * Create a new node for an option in the message

  *

  * @internalTechnology

  */

   {

   COptionNode* pNode = CreateNodeL(aOpCode);

   AddNode(pNode);

   pNode->Header().SetInitialValue(aInitialLength);

   return pNode;

   }

COptionNode* COptionList::FindOption(TUint aOpCode, TInt& aPos) const

	{

	COptionNode* nodeCursor = static_cast<COptionNode*>(iRecord.iFirst);

	TInt counter = 0;

	while (nodeCursor)

		{

		if ( nodeCursor->OpCode() == aOpCode && ++counter > aPos )

			{

			aPos = counter;

			return nodeCursor;

			}

		nodeCursor = static_cast<COptionNode*>(nodeCursor->iNext);

		}

	return NULL;

	}

TUint32 CDHCPOptionStatusCode::GetStatusCode() const

    {

    __ASSERT_DEBUG( GetLength() >= KDHCPOptionStatusCodeLength, User::Panic( KDhcpv6, KErrBadDescriptor ) );

    return TBigEndian::GetValue(iPtr8 + KOptionHeaderLength, KDHCPOptionStatusCodeLength);

    }

void CDHCPOptionStatusCode::SetStatusCode( TUint32 aStatusCode )

    {

   __ASSERT_DEBUG( GetLength() >= KDHCPOptionStatusCodeLength, User::Panic( KDhcpv6, KErrBadDescriptor ) );

	TBigEndian::SetValue(iPtr8 + KOptionHeaderLength, KDHCPOptionStatusCodeLength, aStatusCode);

    }

void CDHCPOptionDNSServers::ParseL(TPtr8& aDes8)

	{

	COptionNode::ParseL(aDes8);

	TPtr8 ptr(GetBodyDes());

	User::LeaveIfError(ptr.Length() % KIp6AddressLength ? KErrBadDescriptor : KErrNone);

	}

TBool CDHCPOptionDNSServers::GetDomainNameServer( TInt aIndex, TInetAddr& addr )

	{

	TInt pos = aIndex * KIp6AddressLength;

	TBool ret = GetLength() >= pos + KIp6AddressLength;

	if ( ret )

		{

		// Must ensure IP6 address is word aligned! So declare it locally

		TIp6Addr ip6addr;

		Mem::Copy(&ip6addr,GetBodyPtr() + pos,KIp6AddressLength);

		addr.SetAddress(ip6addr);

		}

	return ret;

	}

void CDHCPOptionSipServerAddrs::ParseL(TPtr8& aDes8)

	{

	COptionNode::ParseL(aDes8);

	TPtr8 ptr(GetBodyDes());

	User::LeaveIfError(ptr.Length() % KIp6AddressLength ? KErrBadDescriptor : KErrNone);

	}

TBool CDHCPOptionSipServerAddrs::GetSipServerAddr(TInt aIndex, TInetAddr& addr)

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPOptionSipServerAddrs::GetSipServerAddr index = %d"),aIndex));

	TInt pos = aIndex * KIp6AddressLength;

	TInt len = GetLength();

	TBool ret = len >= pos + KIp6AddressLength;

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("pos = %d, len = %d, ret = %d"), pos, len, ret));

	if (ret)

		{

		// Must ensure IP6 address is word aligned! So declare it locally

		TIp6Addr ip6addr;

		Mem::Copy(&ip6addr,GetBodyPtr() + pos,KIp6AddressLength);  

		addr.SetAddress(ip6addr);

		}

	return ret;

	}

void CDHCPOptionSipServerDomains::ParseL(TPtr8& aDes8)

	{

	COptionNode::ParseL(aDes8);

	}

TBool CDHCPOptionSipServerDomains::GetSipServerDomains(TInt aIndex, THostName& aName)

	{

	TInt domainIdx = 0;

	TUint8* pChar = const_cast<TUint8*>(GetBodyDes().Ptr());

	TUint labelLength = 0;

	// Walk the list of domain names

	while(*pChar++ != NULL && domainIdx != aIndex)

		{

		labelLength = *(pChar - 1);

		*(pChar - 1) = '.';

		TBuf8<0x100> tmp;

		tmp.Copy(pChar, labelLength);

		aName.Copy(tmp);

		pChar += labelLength;

		}

	return EFalse;

	}

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

void CDHCPOptionRequestOption::AppendRequestedOptions()

   {

	// the array is in network byte order(big-endian) already => could be used as a descriptor

	// authentication option and IA for temporary addresses not involved so far

	TUint8 requestedOptions[KDHCPOptionRequestLen] = {0,EServerId, 0,EIaNa, 0,ESipServerD, 0,ESipServerA,

														0,EDNSServers, 0,EDomainList};

	TPtr8 ptr(requestedOptions, KDHCPOptionRequestLen, KDHCPOptionRequestLen );

	GetBodyDes().Copy(ptr);

   }

CDHCPMessageHeaderIP6::~CDHCPMessageHeaderIP6()

	{

	Close();

	}

COptionNode* CDHCPMessageHeaderIP6::AddOptionL(TOptionCodes aOpCode, TInt aLength)

/**

  * First stage of adding an option to the message. Calls AddNode to create space

  * for message.

  *

  * @param aOpCode The opcode of the options to be added

  * @param aLength The length of the option data

  * @return COptionNode* The pointer to the option in the message

  *

  * @internalTechnology

  */

	{

	COptionNode* pNode = iOptions.AddNodeL(aOpCode, aLength);

	TPtr8 ptr = iMsg->Des();

	pNode->iRecord.InitialiseL(ptr);

	pNode->SetOpCode(static_cast<TUint>(aOpCode));

	return pNode;

	}

TInt CDHCPMessageHeaderIP6::Parse(const TDhcpRnd& aXid, const TDesC8& aClientId, RBuf8& aServerId)

/**

  * When a response is received to a message

  * this function will unpack the response by creating

  * option objects which can be easily used to retrieve 

  * the values returned in these options.  Providing 

  * this functionality hides the nasty descriptor operations. 

  *

  * Each option class has a pointer set to the start point

  * of their data in the response message.

  *

  * There is no need to explicitly unpack the mandatory fields

  * of the DHCP message that has been returned.  Accessor functions

  * simply extract the data sraight out of the decsriptor.

  *

  * @internalTechnology

  */

	{

	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPMessageHeaderIP6::Parse")));

	iOptions.RemoveAllNodes();

	TPtr8 ptr = iMsg->Des();

	TRAPD(ret,iRecord.ParseL(ptr););

   if ( ret == KErrNone )

		{

		/* Reject the message if:

		 * 

		 * 1) Not an Advertise, Reply, or potentially a Reconfigure message. 

		 * 2) The server or client ID values are nonexistent

		 * 3) The client ID being advertised does not match ours

		 * 4) Bad status code

		 */

	   if (GetXid()!=aXid.Xid())

		   {

		   __CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPMessageHeaderIP6::Parse - non-matching xid")));

		   return KErrBadDescriptor;	// does not match so we are not interested in this message

		   }

      CDHCPOptionStatusCode* pStatus = static_cast<CDHCPOptionStatusCode*>(iOptions.FindOption( EStatusCode ));

      TInt code = pStatus ? pStatus->GetStatusCode() : ESuccess;

		if (code != ESuccess )

		   {

		   __CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPMessageHeaderIP6::Parse - status code %d"), code));

		   return KErrBadDescriptor;	// bad status code so we are not interested in this message

		   }

      TUint8 nType = GetMessageType();

      COptionNode* pServerId = iOptions.FindOption( EServerId );

      COptionNode* pClientId = iOptions.FindOption( EClientId );

		switch(nType)

			{

			case EAdvertise:

				if(pClientId == NULL || pServerId == NULL)

					{

					__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPMessageHeaderIP6::Parse - invalid message type %d or options"), nType));

					return KErrBadDescriptor;

					}

					break;			

			case EReply:

#if defined(DHCP_RECONFIGURE_NO_AUTHENTICATION)

			case EReconfigure:

#endif				

				if (pClientId == NULL || pServerId == NULL || 

				    (aServerId.Length() && pServerId->GetBodyDes() != aServerId))

					{

					__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPMessageHeaderIP6::Parse - invalid message type %d or options"), nType));

					return KErrBadDescriptor;

					}

				if ( nType == EReconfigure && !iOptions.FindOption( EReconfMsg ) )

				    {

					__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPMessageHeaderIP6::Parse - Reconfigure msg with no reconfigure option")));

					return KErrBadDescriptor;

				    }

				break;

			 default:

				__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPMessageHeaderIP6::Parse - invalid message type %d or options"), nType));

				return KErrBadDescriptor;

			}

		if(pClientId->GetBodyDes() != aClientId)

			{

			__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPMessageHeaderIP6::Parse - ClientIds don't match")));

			return KErrBadDescriptor;

			}

		if ( !aServerId.Length() )

		    {

            aServerId.Close();

            TRAP(ret, aServerId.CreateL( pServerId->GetBodyDes() ));

		    }

      }

   return ret;

	}

#ifdef SYMBIAN_TCPIPDHCP_UPDATE

void CDHCPOptionDomainSearchList::ParseL(TPtr8& aDes8)

	{

	COptionNode::ParseL(aDes8);

	}

TBool CDHCPOptionDomainSearchList::GetDomainSearchList(TInt aIndex, THostName& aName)

	{

	TInt domainIdx = 0;

	TUint8* pChar = const_cast<TUint8*>(GetBodyDes().Ptr());

	TUint labelLength = 0;

	TBuf8<0x100> tmp;

	if(*pChar)

		{

		// Walk the list of domain names

		while(*pChar++ != NULL && domainIdx != aIndex)

			{

			labelLength = *(pChar - 1);

			*(pChar - 1) = '.';

			tmp.Copy(pChar, labelLength);

			aName.Copy(tmp);

			pChar += labelLength;

			}

		return EFalse;

		}

	else

		{

		return ETrue;

		}

	}

#endif //SYMBIAN_TCPIPDHCP_UPDATE