// 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:
// hostname.cpp - hostnames of the local node
//

#include "hostname.h"
#include "inet6log.h"

#if defined(TCPIP6_USE_COMMDB)
#	include <commdb.h>
#else
#	include <commsdattypesv1_1.h>
	using namespace CommsDat;
#endif

class CLocalHostName : public CBase
	/**
	* Stores a local hostname.
	*
	* The hostnames are stored in separate objects and reference counted.
	* The same hostname can be mapped to multiple network ids.
	*
	*/
	{
	/**
	* Constructor.
	* Private, only used from CLocalHostName::New method, due to somewhat
	* dubious tricks with TLitC class (to store the name).
	*/
	CLocalHostName(const THostName &aName, CLocalHostName *aNext) : iNext(aNext)
		{
		// See _LIT and TLitC for this initializer!!!
		iName.iTypeLength = aName.Length();
		TPtr((TText *)&iName.iBuf[0], aName.Length()).Copy(aName);
		}

public:
	static CLocalHostName *New(const THostName &aName, CLocalHostName *aNext);
	CLocalHostName *iNext;	//< Link to the next name.
	TInt iRefs;				//< The reference count (value 0 implies already one reference).
	TLitC<1> iName;			//< Host name (<1> is *FAKE*!)
	//
	// This is followed by the actual name characters.
	// CHostName class *CANNOT* be subclassed!!!!
	};


CLocalHostName *CLocalHostName::New(const THostName &aName, CLocalHostName *aNext)
	{
	// note: TLitC<1> causes extra allocation of sizeof(TInt) [depends on align
	// settings]. Could try to adjust the extra requested size down by that amount,
	// but it would result more complex code... -- msa
	return new (aName.Size()) CLocalHostName(aName, aNext);
	}

class TLocalHostMap
	{
public:
	TLocalHostMap(TUint32 aId, const CLocalHostName *aName) : iId(aId), iName(aName) {}
	const TUint32 iId;
	const CLocalHostName *iName;
	};

THostNames::~THostNames()
	{
	Cleanup();
	}



void THostNames::Cleanup()
	{
	// note: this does not need to worry about reference counts
	// in hostnames, because everything is cleaned.
	delete iMap;
	iMap = NULL;

	while (iNameList != NULL)
		{
		CLocalHostName *e = iNameList;
		iNameList = e->iNext;
		delete e;
		}
	}

void THostNames::ReferenceRemoved(const CLocalHostName *aName)
	{
	for (CLocalHostName **h = &iNameList, *p; (p = *h) != NULL; h = &p->iNext)
		{
		if (p == aName)
			{
			if (--p->iRefs < 0)
				{
				*h = p->iNext;
				delete p;
				}
			return;
			}
		}
	}


TInt THostNames::Map(TUint32 aId, const TDesC &aName)
	{
	//
	// Locate or create a hostname entry
	//
	TInt err = KErrNoMemory;

	CLocalHostName *name = iNameList;
	for (;;name = name->iNext)
		{
		if (name == NULL)
			{
			name = CLocalHostName::New(aName, iNameList);
			if (name == NULL)
				return KErrNoMemory;
			iNameList = name;
			// The initial iRefs = 0 is ok.
			break;
			}
		else if (aName.Compare(name->iName) == 0)
			{
			// Additional reference to an existing name.
			name->iRefs++;
			break;
			}
		}

	if (iMap != NULL || (iMap = new CArrayFixFlat<TLocalHostMap>(4)) != NULL)
		{
		//
		// Remove old mapping, if any
		//
		for (TInt i = iMap->Count(); i > 0; )
			{
			TLocalHostMap &m = iMap->At(--i);
			if (m.iId == aId)
				{
				// Id already present, just change the name reference (if changed).
				if (m.iName != name)
					{
					LOG(Log::Printf(_L("\tlocalhost unmapped: <%u, %S(%d)>"), m.iId, &m.iName->iName, m.iName->iRefs));
					ReferenceRemoved(m.iName);
					m.iName = name;
					}
				LOG(Log::Printf(_L("\tlocalhost mapped: <%u, %S(%d)>"), m.iId, &m.iName->iName, m.iName->iRefs));
				return KErrNone;
				}
			}
		// Id was not recorded before this, create a new entry.
		TRAP(err, iMap->AppendL(TLocalHostMap(aId, name)));
		if (err == KErrNone)
			{
			LOG(Log::Printf(_L("\tlocalhost mapped: <%u, %S(%d)>"), aId, &name->iName, name->iRefs));
			return KErrNone;
			}
		}
	ReferenceRemoved(name);
	return err;
	}


void THostNames::Unmap(TUint32 aId)
	{
	//
	// Remove old mapping, if any
	//
	if (iMap)
		{
		for (TInt i = iMap->Count(); i > 0; )
			{
			const TLocalHostMap &m = iMap->At(--i);
			if (m.iId == aId)
				{
				LOG(Log::Printf(_L("\tlocalhost unmapped: <%u, %S(%d)>"), m.iId, &m.iName->iName, m.iName->iRefs));
				ReferenceRemoved(m.iName);
				iMap->Delete(i);
				break;	// There can be only one matching id!
				}
			}
		iMap->Compress();
		}
	}

const TDesC &THostNames::Find(TUint32 aId) const
	{
	if (iMap)
		{
		for (TInt i = iMap->Count(); i > 0; )
			{
			const TLocalHostMap &m = iMap->At(--i);
			if (m.iId == aId)
				return m.iName->iName;
			}
		}
	return KNullDesC;
	}

TInt THostNames::Reset(const TDesC &aLocalHost)
	{
	Cleanup();

	// Define the return, when network id is not specified.

	Map(0, aLocalHost);

	// ----------------------------------------------
	// Insert here the code to scan the commdb and,
	// for each pair <nid, name>, call Map(id, name).
	// ----------------------------------------------
	TRAPD(err, GetCommDbDataL(0));

	return err;
	}
	
TInt THostNames::Refresh(TUint32 aId)
	{
	TRAPD(err, GetCommDbDataL(aId));
	return err;
	}


void THostNames::GetCommDbDataL(TUint32 aId)
	{
#if defined(TCPIP6_USE_COMMDB)
#	ifdef HOST_NAME
	CCommsDatabase* db = CCommsDatabase::NewL();
	CleanupStack::PushL(db);

	CCommsDbTableView* view = db->OpenTableLC(TPtrC(NETWORK));
	for (TInt ret = view->GotoFirstRecord(); ret == KErrNone; ret = view->GotoNextRecord())
		{
		THostName name;
		TUint32 nid = 0;
		TRAP(ret,
			view->ReadTextL(TPtrC(HOST_NAME), name);
			view->ReadUintL(TPtrC(COMMDB_ID), nid));
		if (ret == KErrNone)
			Map(nid, name);
		}
	CleanupStack::PopAndDestroy(2);
#endif
#else
	// . (not tested)
#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY
	CMDBSession *dB = CMDBSession::NewLC(KCDVersion1_2);
#else
	CMDBSession *dB = 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.
	dB->SetAttributeMask( ECDHidden | ECDPrivate );

	CMDBRecordSet<CCDNetworkRecord> *networkTable;
	networkTable = new (ELeave) CMDBRecordSet<CCDNetworkRecord>(KCDTIdNetworkRecord);
	CleanupStack::PushL(networkTable);
	networkTable->LoadL(*dB);
	const TInt totalRecords = networkTable->iRecords.Count();
	for (TInt i = 0; i < totalRecords; ++i)
		{
		const TUint32 nid = (*networkTable)[i]->RecordId();
		if (aId == 0 || nid == aId)
			Map(nid, (*networkTable)[i]->iHostName);	
		}
	CleanupStack::PopAndDestroy(2);		
#endif
	}