// 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 database access
// 
//

/**
 @file
 @internalTechnology
*/

#include "DHCPDb.h"
#include "DHCPStateMachine.h"
#include <nifman.h>
#include <f32file.h>
#include <comms-infras/metabuffer.h>
#include <metadatabase.h>
#include <commsdattypesv1_1.h>
#include "DhcpIP6Msg.h"
using namespace CommsDat;


void CDHCPDb::OpenIAPViewLC(CMDBSession*& aSession, CCDIAPRecord*& aIapRecord)
	{
#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY
	aSession = CMDBSession::NewLC(KCDVersion1_2);
#else
	aSession = CMDBSession::NewLC(KCDVersion1_1);
#endif

	// Reveal hidden or private IAP records if a licensee has chosen to protect a record
	// using one of these flags - the API to do this is public so internal components
	// have to support the use of such records.
	aSession->SetAttributeMask(ECDHidden | ECDPrivate);
	
	aIapRecord = static_cast<CCDIAPRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));
	CleanupStack::PushL(aIapRecord);

    aIapRecord->SetRecordId(iIapId);
        	
	aIapRecord->LoadL(*aSession);
	}
	



void CDHCPDb::GetAddressFamiliesL(RArray<int> & results)
	{
	CMDBSession* session;
	CCDIAPRecord* iap;
	// next call leaves session and iap object on cleanupstack
	OpenIAPViewLC(session, iap);

	CCDServiceRecordBase* service;
	InitialServiceLinkL(session, iap);
	service = static_cast<CCDServiceRecordBase *>(iap->iService.iLinkedRecord);
	TInt ignoreThis;
	CMDBField<TDesC>* cdbLoadStr = static_cast<CMDBField<TDesC>*>(service->GetFieldByNameL(KCDTypeNameIfNetworks, ignoreThis));
	TPtrC readPtr(*cdbLoadStr);

	RSocketServ sockServ;
	User::LeaveIfError(sockServ.Connect());

	TLex lex(readPtr);
	while(!lex.Eos())
		{
		TPtrC token;
		lex.Mark();
		TChar ch;
		ch=lex.Peek();

		while(!lex.Eos() && (ch=lex.Peek())!=TChar(','))
			lex.Inc();
		
		token.Set(lex.MarkedToken());
		if(!token.Length())
			break;

		if(ch==TChar(','))
			lex.Inc();

		TServerProtocolDesc pinfo;
		User::LeaveIfError(sockServ.FindProtocol(token,pinfo));
		results.AppendL(pinfo.iAddrFamily);
		}
		
		
	CleanupStack::PopAndDestroy(iap);
	CleanupStack::PopAndDestroy(session);

	return;
	}

#ifdef SYMBIAN_NETWORKING_DHCPSERVER	
/** Checks if DHCP server implementation should be enabled.
  * Currently this is decided depending on if the NapServiceEnabled field is set 	 
  * to true in PAN NAP Service extension table.
  * PAN NAP is the only client for DHCP server implementation in DHCP component.
  * 
  * @internalTechnology
  */
TBool CDHCPDb::CheckIfDHCPServerImplEnabledL()
	{
	CMDBSession* session;
	CCDIAPRecord* iap;
	// next call leaves session and iap object on cleanupstack
	OpenIAPViewLC(session, iap);

	CCDServiceRecordBase* service;
	InitialServiceLinkL(session, iap);
	service = static_cast<CCDServiceRecordBase *>(iap->iService.iLinkedRecord);
	TInt ignoreThis;
	CMDBField<TDesC>* cdbLanServiceExtn = static_cast<CMDBField<TDesC>*>(service->GetFieldByNameL(KCDTypeNameServiceExtensionTableName, ignoreThis));
	CMDBField<TInt>* cdbLanServiceExtnRecId = static_cast<CMDBField<TInt>*>(service->GetFieldByNameL(KCDTypeNameServiceExtensionTableRecordId, ignoreThis));
	
	TInt recId = *cdbLanServiceExtnRecId;
	
	CCDPANServiceExtRecord* panServiceExtRecord = static_cast<CCDPANServiceExtRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdPANServiceExtRecord));
	CleanupStack::PushL(panServiceExtRecord);
	
	HBufC16* readBuffer = HBufC16::NewLC(KCommsDbSvrMaxFieldLength);
	TPtr16 readPtr = readBuffer->Des();
	
	readPtr.Copy(*cdbLanServiceExtn);
	iDHCPServerImpl = EFalse; // reset this, found it was set to some negative value by default though "this" is derived from CBase
	// DHCP server implementation at the moment is only used by PAN NAP imlpementation
	// Hence, check if the Lan service extension was PAN service extension 
	if(recId && ! readPtr.Compare(TPtrC(KCDTypeNamePANServiceExt))) 
		{
		panServiceExtRecord->SetRecordId(recId);
		panServiceExtRecord->LoadL(*session);
	
		// set the flag to indicate that this connection needs DHCP server implementation
		iDHCPServerImpl = panServiceExtRecord->iNapServiceEnabled;
		}

	CleanupStack::PopAndDestroy(readBuffer);
	CleanupStack::PopAndDestroy(panServiceExtRecord);	
	CleanupStack::PopAndDestroy(iap);
	CleanupStack::PopAndDestroy(session);
	
	return iDHCPServerImpl;
	}
#endif // SYMBIAN_NETWORKING_DHCPSERVER	
#ifdef SYMBIAN_DNS_PROXY	
void CDHCPDb::ReadHostNameL(CDHCPStateMachine& aDhcpStateMachine)
	{
	CMDBSession* session;
	CCDIAPRecord* iap;
	// next call leaves session and iap object on cleanupstack
	OpenIAPViewLC(session, iap);
	
	if(iap->iNetwork.iLinkedRecord == 0)
       {
       iap->iNetwork.iLinkedRecord= static_cast<CCDNetworkRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdNetworkRecord));       
       }
    iap->iNetwork.iLinkedRecord->SetRecordId(iap->iNetwork);      
 
    // load linked network record so we can get its id
    iap->iNetwork.iLinkedRecord->LoadL(*session); 
   
	CCDNetworkRecord* service;
    service = static_cast<CCDNetworkRecord *>(iap->iNetwork.iLinkedRecord);
    
	TInt ignoreThis;
	CMDBField<TDesC>* cdbHostName = static_cast<CMDBField<TDesC>*>(service->GetFieldByNameL(KCDTypeNameHostName, ignoreThis));
	
	HBufC16* readHostName = HBufC16::NewLC(KMaxName);
	TPtr16 hostPtr = readHostName->Des();
	hostPtr.Copy(*cdbHostName);
	if(hostPtr.Length()>1)
		{ 
		TInt index = hostPtr.Locate('.');
		TPtrC16 host = hostPtr.Left(index);
		TPtrC16 domain = hostPtr.Right((hostPtr.Length()-1)-index);
	 
		aDhcpStateMachine.iProxyHostName.Copy(hostPtr);
		aDhcpStateMachine.iProxyDomainName.Copy(domain);
		}
	 
	CleanupStack::PopAndDestroy(readHostName);
	CleanupStack::PopAndDestroy(iap);
	CleanupStack::PopAndDestroy(session);
	}
#endif // SYMBIAN_DNS_PROXY	


TBool CDHCPDb::ReadL( CDHCPStateMachine& aDhcpStateMachine, Meta::SMetaData& aPersistent )
/**
  * Read the relevant CommDB entries.
  *
  * Primarily we are looking at the service tables
  * and reading ip address, subnet mask, gateway, 
  * dns address from server fields.  Reading these
  * fields give us connection specific configuration
  * for how to proceed with dhcp negotions...e.g if
  * ipAddress field has a value, then this is the static
  * ip address used in an inform message broadcast across
  * the network...or if dns address from server is true, then
  * dhcp will set the dns servers into the stack once address
  * acquisition is over.
  *
  * @internalTechnology
  */
	{
	TBool addrFromServer=EFalse;
	HBufC16* readBuffer;

	CMDBSession* session;
	CCDIAPRecord* iap;

	// next call leaves session and iap object on cleanupstack
	OpenIAPViewLC(session, iap);

	CCDServiceRecordBase* service;
	InitialServiceLinkL(session, iap);
	service = static_cast<CCDServiceRecordBase *>(iap->iService.iLinkedRecord);
	
	readBuffer = HBufC16::NewLC(KCommsDbSvrMaxFieldLength);
	TPtr16 readPtr = readBuffer->Des();

	TInt ignoreThis;

	CMDBField<TBool>* cdbLoadBool = static_cast<CMDBField<TBool>*>(service->GetFieldByNameL(KCDTypeNameIpAddrFromServer, ignoreThis));
	addrFromServer = *cdbLoadBool;
	
	CMDBField<TDesC>* cdbLoadStr = 0;


	if (addrFromServer)
		{//don't really want to leave
#ifdef DHCP_PERSISTENTDATA_INFILE
		TRAPD(err,ReadPersistentL( aDhcpStateMachine.iClientId, aPersistent ));
#else
		//assumes flat memory and byte addressing mode
		HBufC8* persist = HBufC8::NewLC(KCommsDbSvrMaxFieldLength * 2 * sizeof(TUint16));
		TPtr8 des = persist->Des();

		cdbLoadStr = static_cast<CMDBField<TDesC>*>(service->GetFieldByNameL(KCDTypeNameIpAddrLeaseValidFrom, ignoreThis));
		des.Copy(*cdbLoadStr);
		cdbLoadStr = static_cast<CMDBField<TDesC>*>(service->GetFieldByNameL(KCDTypeNameIpAddrLeaseValidTo, ignoreThis));
		des.Append(*cdbLoadStr);

		TPtrC8 ptr(des);

		if ( aPersistent.GetTypeId().Check( ptr ) == KErrNone )
			{//whatever we read is assumed ok, since TID matches and if not the confirm or reboot will fail
			aPersistent.Load( ptr );
			}
		CleanupStack::PopAndDestroy(persist);
#endif
		}
	else
		{
// DHCP shouldn't look at these values.. if they're static, it's down to the driver below to set them, we'll pick that up later.
		}



	cdbLoadBool = static_cast<CMDBField<TBool>*>(service->GetFieldByNameL(iIpDNSAddressFromServer, ignoreThis));
	aDhcpStateMachine.iNameServerAddressesFromServer = (*cdbLoadBool);
	if( ! aDhcpStateMachine.iNameServerAddressesFromServer )
		{
#ifdef SYMBIAN_DNS_PROXY		
		CMDBField<TDesC>* cdbLoadDns = static_cast<CMDBField<TDesC>*>(service->GetFieldByNameL(KCDTypeNameIpNameServer1, ignoreThis));
		aDhcpStateMachine.iProxyDnsSrvAddr.Input(*cdbLoadDns);
#endif		
		}	

	// note the handling of cleanup here...as view and buffer swap positions on the cleanup
	// stack early in the function, forcing this pop and destroy, and the else...
	CleanupStack::PopAndDestroy(readBuffer);	
	CleanupStack::PopAndDestroy(iap);
	CleanupStack::PopAndDestroy(session);
	return addrFromServer;
	}

/* static */
void CDHCPDb::VerifyFieldReadSuccessL(TInetAddr& addr, const TDesC& input, TInt field)
	{
	TInt err;
	(void)field; // for UREL mode
	
	if(input.Length() == 0)
		{
		__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPDb: Can't find field %d - using null value"),field));
		TInetAddr nullAddr;  //creates unspecif. (null) address
		addr = nullAddr;
		}
	else if( (err=addr.Input(input)) != KErrNone)
		{
		__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPDb: Error %d: Can't read field %d as an IP address!"),err,field));
		User::Leave(err);
		}
	}

void CDHCPDb::WriteL( CDHCPStateMachine& aDhcpStateMachine, const Meta::SMetaData& aPersistent )
/**
  * Writes acquired settings into commDB.
  *
  * Stores the time the lease is valid from and to
  * and the configured IP address
  *
  * @internalTechnology
  */
	{
#ifdef DHCP_PERSISTENTDATA_INFILE
	WritePersistentL( aDhcpStateMachine.iClientId, aPersistent );
#else
	(void)aDhcpStateMachine;
	HBufC16* buffer;

	HBufC8* persist = HBufC8::NewLC(aPersistent.Length());
	TPtr8 des = persist->Des();
	aPersistent.Store( des );
#ifdef _DEBUG
	if ( (TUint)des.Length() > 2 * KCommsDbSvrMaxFieldLength * sizeof(TUint16) )
		{
	   __CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPDb::WriteL - persistent data length 3 * KDefaultTextColumnWidth %d"), des.Length()));
		}
#endif

	CMDBSession* session;
	CCDIAPRecord* iap;
	// next call leaves session and iap object on cleanupstack
	OpenIAPViewLC(session, iap);

	CCDServiceRecordBase* service;
	InitialServiceLinkL(session, iap);
	service = static_cast<CCDServiceRecordBase *>(iap->iService.iLinkedRecord);

	buffer = HBufC16::NewLC(KCommsDbSvrMaxFieldLength);
	
	TPtr16 readWritePtr = buffer->Des();

		{//assumes flat memory and byte addressing mode
		TInt nStored = readWritePtr.MaxLength() * sizeof(TUint16);
		TPtr8 writePtr8( (TUint8*)readWritePtr.Ptr(), readWritePtr.MaxLength() * sizeof(TUint16));
		writePtr8.Copy( des.Mid( 0, Min(nStored, des.Length() )) );
		readWritePtr.SetLength( writePtr8.Length() / sizeof(TUint16) );
		// write the first part of the persistent data
		TInt ignoreThis;
		CMDBField<TDesC>* cdbLoadStr = static_cast<CMDBField<TDesC>*>(service->GetFieldByNameL(KCDTypeNameIpAddrLeaseValidFrom, ignoreThis));
		cdbLoadStr->SetMaxLengthL(readWritePtr.Length());
		(*cdbLoadStr) = readWritePtr;
		if ( 	nStored < des.Length() )
			{
			writePtr8.Copy( des.Mid( nStored, Min(des.Length(), KCommsDbSvrMaxFieldLength * sizeof(TUint16)) ) );
			readWritePtr.SetLength( writePtr8.Length() / sizeof(TUint16) );
			// write the second part of the persistent data
			cdbLoadStr = static_cast<CMDBField<TDesC>*>(service->GetFieldByNameL(KCDTypeNameIpAddrLeaseValidTo, ignoreThis));
			cdbLoadStr->SetMaxLengthL(readWritePtr.Length());
			(*cdbLoadStr) = readWritePtr;
			}
		service->ModifyL(*session);
		}

	CleanupStack::PopAndDestroy(buffer);
	CleanupStack::PopAndDestroy(iap);
	CleanupStack::PopAndDestroy(session);
	CleanupStack::PopAndDestroy(persist);
#endif // DHCP_PERSISTENTDATA_INFILE
	}

#ifdef DHCP_PERSISTENTDATA_INFILE
void CDHCPDb::OpenFileLC( const TDesC8& aClientId, TAutoClose<RFs>& aFs, TAutoClose<RFile>& aFile, TBool aCreateNew )
	{
	User::LeaveIfError( aFs.iObj.Connect() );
	aFs.PushL();
	TInt result;
	if ( aCreateNew )
		{
		result = aFs.iObj.CreatePrivatePath (EDriveC);
		if ((result != KErrNone) && (result != KErrAlreadyExists)) 
			{
			User::Leave( result );
			}
		}
	Elements::TRBuf privatePath;
	privatePath.CreateL( 100 );
	CleanupClosePushL(privatePath);
	aFs.iObj.PrivatePath(privatePath);
	TInt toAdd = aClientId.Length() * 2 + 2 + 4;
	TInt space = privatePath.MaxLength() - privatePath.Length();
	if ( space < toAdd )
		{
		privatePath.ReAllocL(privatePath.Length() + toAdd);
		}

	// Get the correct system drive letter in a buffer.	
	TChar sysDriveLetter = RFs::GetSystemDriveChar();
	TBuf<2> sysDriveLetterBuf;
	sysDriveLetterBuf.Fill( sysDriveLetter, 1 );
	sysDriveLetterBuf.Append( _L( ":" ) );

 	privatePath.Insert (0, sysDriveLetterBuf);
	for (TInt n = 0; n < aClientId.Length(); n++)
		{
		privatePath.AppendNumFixedWidthUC( aClientId[n],EHex,2 );
		}
	privatePath.Append( _L(".dat") );
	result = aFile.iObj.Open(aFs.iObj,privatePath,EFileStream|EFileWrite);
	if ( result != KErrNone && aCreateNew )
		{
		result = aFile.iObj.Create (aFs.iObj, privatePath, EFileWrite);
		}
	User::LeaveIfError( result );
	CleanupStack::PopAndDestroy();
	aFile.PushL();
	}

#ifdef _DEBUG
const TInt KMaxPersistenDataLength = 512; //an arbitrarry nember to have some means to check the max store length
#endif

void CDHCPDb::WritePersistentL( const TDesC8& aClientId, const Meta::SMetaData& aPersistent )
	{
	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPDb::WritePersistentL")));
	TAutoClose<RFs> fs;
	TAutoClose<RFile> file;
	OpenFileLC( aClientId, fs, file, ETrue );

	HBufC8* persist = HBufC8::NewLC(aPersistent.Length());
	TPtr8 des = persist->Des();
#ifdef _DEBUG
	if ( des.MaxLength() > KMaxPersistenDataLength )
		{
	   __CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPDb::WriteL - persistent data suspiciously long %d"), des.MaxLength()));
		}
#endif
	aPersistent.Store( des );
	file.iObj.Write( des );
	CleanupStack::PopAndDestroy(persist);
	file.Pop();
	fs.Pop();
	}

void CDHCPDb::ReadPersistentL( const TDesC8& aClientId, Meta::SMetaData& aPersistent )
	{
	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPDb::ReadPersistentL")));
	TAutoClose<RFs> fs;
	TAutoClose<RFile> file;
	OpenFileLC( aClientId, fs, file, EFalse );
	TInt data_size;
	User::LeaveIfError(file.iObj.Size(data_size));
#ifdef _DEBUG
	if ( data_size > KMaxPersistenDataLength )
		{
	   __CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPDb::WriteL - persistent data suspiciously long %d"), data_size));
		}
#endif

	HBufC8* persist = HBufC8::NewLC(data_size);
	TPtr8 des = persist->Des();
	file.iObj.Read(des);
	TPtrC8 ptr( des );
	if ( aPersistent.GetTypeId().Check( ptr ) == KErrNone )
		{//whatever we read is assumed ok, since TID matches and if not the confirm or reboot will fail
		aPersistent.Load( ptr );
		}
	CleanupStack::PopAndDestroy(persist);
	file.Pop();
	fs.Pop();
	}
#endif

void CDHCPDb::InitialServiceLinkL(CMDBSession* aDbSession, CCDIAPRecord* aIapRecord)
	{
	__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPDb::InitialServiceLinkL()")));

	// This will be made more simple quite soon when commsdat supports linked records
	//
	if (aIapRecord->iService.iLinkedRecord == 0)
		{
		const TDesC& servType = aIapRecord->iServiceType;

			{
			// Convert the service type to ASCII.
			TBuf8<KMaxName> tempBuf;
			tempBuf.Copy( servType );

			__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CDHCPDb::InitialServiceLinkL() service type = \"%S\""), &tempBuf));
			}

		if (servType.CompareF(TPtrC(KCDTypeNameLANService))==0)
			{
			aIapRecord->iService.iLinkedRecord = static_cast<CCDLANServiceRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdLANServiceRecord));
			}
		else if (servType.CompareF(TPtrC(KCDTypeNameDialOutISP))==0)
			{
			aIapRecord->iService.iLinkedRecord = static_cast<CCDDialOutISPRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdDialOutISPRecord));
			}
		else if (servType.CompareF(TPtrC(KCDTypeNameDialInISP))==0)
			{
			aIapRecord->iService.iLinkedRecord = static_cast<CCDDialInISPRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdDialInISPRecord));
			}
		else if (servType.CompareF(TPtrC(KCDTypeNameVPNService))==0)
			{
			aIapRecord->iService.iLinkedRecord = static_cast<CCDVPNServiceRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdVPNServiceRecord));
			}
		else if (servType.CompareF(TPtrC(KCDTypeNameOutgoingWCDMA))==0)
			{
			aIapRecord->iService.iLinkedRecord = static_cast<CCDOutgoingGprsRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdOutgoingGprsRecord));
			}
		else if (servType.CompareF(TPtrC(KCDTypeNameIncomingWCDMA))==0)
			{
			aIapRecord->iService.iLinkedRecord = static_cast<CCDIncomingGprsRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdIncomingGprsRecord));
			}
		else
			{
			__CFLOG_VAR((KLogSubSysDHCP, KLogCode, _L8("CCDHCPDb::InitialServiceLinkL() Invalid Service Type!!!")));
			User::Leave(KErrBadName);	
			}
		
		aIapRecord->iService.iLinkedRecord->SetRecordId(aIapRecord->iService);
		}

	aIapRecord->iService.iLinkedRecord->LoadL(*aDbSession);
	}

