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

//

#include "srvres.h"

#include "cachemgr.h"

#include "obsrvr_noc.h"

#include <bautils.h> // BaflUtils::GetSystemDrive

#ifdef SYMBIAN_BAFL_SYSUTIL

#include <bafl/sysutil.h>

#endif

RFs TServerResources::iFs;

HBufC* TServerResources::iRomDirectory;

HBufC* TServerResources::iDataDirectory;

HBufC* TServerResources::iInstallDirectory;

HBufC* TServerResources::iBURDirectory;

HBufC* TServerResources::iIniExt;

HBufC* TServerResources::iCreExt;

HBufC* TServerResources::iTrnsExt;

TUint8 TServerResources::iPersistsVersion;

RArray<TOwnerIdMapping> TServerResources::iOwnerIdLookUpTable;

CRepositoryCacheManager* TServerResources::iCacheManager;

CObservable* TServerResources::iObserver;

#ifdef __CENTREP_SERVER_PERFTEST__

TCentRepPerfTest TServerResources::iPerfTestMgr;

#endif

#ifdef __CENTREP_SERVER_MEMTEST__

TInt32 TServerResources::iMemTestData[KMemBufMaxEntry];

TInt32 TServerResources::iMemTestDataCount = 0;

#endif //__CENTREP_SERVER_MEMTEST__

TTime TServerResources::CentrepFileTimeStampL(TUid aUid, TCentRepLocation aLocation)

	{

	TEntry entry;

	HBufC* fileName(NULL);

	TServerResources::CreateRepositoryFileNameLC(fileName,aUid,aLocation,ECre);

	TInt err=TServerResources::iFs.Entry(fileName->Des(), entry);

   	CleanupStack::PopAndDestroy(fileName);

	if(err==KErrNone)

		{

		return entry.iModified;

		}

	TServerResources::CreateRepositoryFileNameLC(fileName,aUid,aLocation,EIni);

	User::LeaveIfError(TServerResources::iFs.Entry(fileName->Des(), entry));

   	CleanupStack::PopAndDestroy(fileName);

	return entry.iModified;

	}

TBool TServerResources::CentrepFileExistsL(TUid aUid, TCentRepLocation aLocation, TCentRepFileType aType)

	{

	HBufC* fileName(NULL);

	TServerResources::CreateRepositoryFileNameLC(fileName,aUid,aLocation,aType);

	TEntry entry;

	TInt err=TServerResources::iFs.Entry(fileName->Des(), entry);

   	CleanupStack::PopAndDestroy(fileName);		   					  

 	TBool r=EFalse;

 	if(err==KErrNone)

 		{

 		r=ETrue;

 		}

 	else if(err==KErrNotFound)

 		{

 		r=EFalse;

 		}

 	// Looking for a file on a composite file system may return KErrPathNotFound when 

 	// the ROM file doesn't exist, so check for this return code as well.

 	else if((aLocation==ERom) && (err== KErrPathNotFound))

  		{

 		r=EFalse;

 		}

 	else

 		{

 		User::Leave(err);

 		}

 #ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	

 	//only for ROM we still have to consider for multiple ROFS presence	

	if (aLocation==ERom && r==EFalse)

		{

		//if not still have to check for multi rofs, it might be the case that first file is already mangled

		TMultiRofsList find(aUid);

		TLinearOrder<TMultiRofsList> sort_order(CObservable::CompareUid);		

		TInt index=iObserver->GetMultiRofsList().FindInOrder(find,sort_order);		

		if (index!=KErrNotFound)	

			r=ETrue;

		}

#endif		

  	return r;	 

	}

TBool TServerResources::CentrepFileExistsL(TUid aUid, TCentRepLocation aLocation)

	{

	return( CentrepFileExistsL( aUid, aLocation, EIni) || CentrepFileExistsL( aUid, aLocation, ECre));

	}

TBool TServerResources::InstallFileExistsL(TUid aUid)

	{

	return CentrepFileExistsL(aUid, EInstall);

	}

TBool TServerResources::RomFileExistsL(TUid aUid)

	{

	return CentrepFileExistsL(aUid, ERom);

	}

TBool TServerResources::PersistsFileExistsL(TUid aUid)

	{

	return CentrepFileExistsL(aUid, EPersists);

	}	

#ifdef SYMBIAN_BAFL_SYSUTIL

TInt TServerResources::GetTextFromFile( const TDesC& aFilename, TDes8& aValue)

    {

    TInt err = KErrNone;

    RFile file;

    err = file.Open( iFs, aFilename,

                     EFileRead | EFileStreamText | EFileShareReadersOnly );

    if (err != KErrNone)

        {

        return err;

        }

    err = file.Read(aValue);

    file.Close();

    return err;

    }

#endif		

void TServerResources::DeleteCentrepFileL(TUid aUid, TCentRepLocation aLocation, TCentRepFileType aType)

	{

	HBufC* fileName(NULL);

	TServerResources::CreateRepositoryFileNameLC(fileName,aUid,aLocation,aType);

	if(CentrepFileExistsL( aUid, aLocation, aType))	

		{

		User::LeaveIfError(TServerResources::iFs.Delete(fileName->Des()));

		}

	CleanupStack::PopAndDestroy(fileName);	 

	}	

void TServerResources::CreateRepositoryFileNameLC(HBufC*& aFullFileName,

												  TUid aUid,

                                                  TCentRepLocation aLocation,

                                                  TCentRepFileType aFileType)

    {

	TServerResources::CreateRepositoryFileNameL(aFullFileName,aUid,aLocation,aFileType);

	CleanupStack::PushL(aFullFileName);

    }

/**

Generic routine for creating a full repository file name.

aFullFileName is created on the heap and it is caller responsibility

to delete it. 

*/

void TServerResources::CreateRepositoryFileNameL(HBufC*& aFullFileName,

												  TUid aUid,

                                                  TCentRepLocation aLocation,

                                                  TCentRepFileType aFileType)

    {

    const TInt KExtLen = 4;

    const TInt KDirLen = 40;

    const TInt KUidLen = 8;

    TBuf<KDirLen> directory;

    TBuf<KExtLen> ext;

	//path

	switch (aLocation)

	    {

	    case EPersists:

	        {

	        directory.Copy(iDataDirectory->Des());

	        }

	    	break;

	    case EInstall:

	        {

	        directory.Copy(iInstallDirectory->Des());

	        }

	    	break;

	    case ERom:

	        {

	        if (iRomDirectory)

	        	{

	        	directory.Copy(iRomDirectory->Des());	        	

	        	}

			else

				{

				User::Leave(KErrNotFound); //CentRep ROM directory is empty or doesn't exist at all

				}

	        }

	    	break;

	    default:

	        User::Leave(KErrNotFound); //should never get here

	    }

    //file name	    

	TBuf<KUidLen> name;

	name.NumFixedWidth(aUid.iUid, EHex, KUidLen);

	//extension

    switch (aFileType)

        {

        case ECre:

            {

            ext.Copy(iCreExt->Des());

            }

            break;

        case EIni:

            {

            ext.Copy(iIniExt->Des());

            }

            break;

        case ETmp:

	    	{

	    	ext.Copy(iTrnsExt->Des());

	    	}

	    	break;

        default:

	        User::Leave(KErrNotFound); //should never get here

        }

    TBuf<KMaxFileName>  fullFileName;

    fullFileName.Append(directory);

    fullFileName.Append(name);

    fullFileName.Append(ext);

    //allocates memory on the heap. It is caller's resposibility to delete aFullFileName

    aFullFileName = fullFileName.AllocL(); 

    }

void TServerResources::InitialiseL()

	{

#ifndef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

	iPersistsVersion = KPersistFormatVersion;	// Version 0 of persists

#else

	iPersistsVersion = KPersistFormatSupportsIndMetaIndicator;

#endif	

	User::LeaveIfError(iFs.Connect());

	// get system drive

	_LIT(KDriveMask, "_:");

	TDriveName systemDrive(KDriveMask);

	systemDrive[0] = 'A' + static_cast<TInt>(RFs::GetSystemDrive());

	_LIT(KRomDrive, "z:");			// This may not always be z:

	_LIT(KPersistsDir, "persists\\");

	_LIT(KBURDir, "bur\\");

	// File extensions

	_LIT(KIniFileExtension, ".txt");

	_LIT(KExternalizedPersistsFileExt, ".cre");

	_LIT(KTransactFileExt, ".tmp");

	const TInt KMaxExtLength=4;

	iIniExt=HBufC::NewL(KMaxExtLength);

	iCreExt=HBufC::NewL(KMaxExtLength);

	iTrnsExt=HBufC::NewL(KMaxExtLength);

	iIniExt->Des().Copy(KIniFileExtension);

	iCreExt->Des().Copy(KExternalizedPersistsFileExt);

	iTrnsExt->Des().Copy(KTransactFileExt);

	TBuf<KMaxFileName> path;

	User::LeaveIfError(iFs.PrivatePath(path));

	const TInt pathLen = path.Length();

	//

	// ROM-drive cenrep directory

	//

	iRomDirectory = HBufC::NewL(KRomDrive().Length()+pathLen);

	TPtr ptr(iRomDirectory->Des());

	ptr.Append(KRomDrive);

	ptr.Append(path);

	// If the ROM directory does not exist (very unlikely) we set iRomDirectory to zero.

	TEntry fsEntry;

	if(iFs.Entry(*iRomDirectory, fsEntry)!=KErrNone || !fsEntry.IsDir())

		{

		delete iRomDirectory;

		iRomDirectory = NULL;

		}

	//

	// Cenrep install directory

	//

	iInstallDirectory = HBufC::NewL(systemDrive.Length()+pathLen);

	ptr.Set(iInstallDirectory->Des());

	ptr.Append(systemDrive);

	ptr.Append(path);

	TInt r = iFs.MkDirAll(*iInstallDirectory);

	if(r!=KErrNone && r!=KErrAlreadyExists)

		{

		User::Leave(r);		

		}

	//

	// Writeable-drive data directory

	//

	iDataDirectory = HBufC::NewL(systemDrive.Length()+pathLen+KPersistsDir().Length());

	ptr.Set(iDataDirectory->Des());

	ptr.Append(systemDrive);

	ptr.Append(path);

	ptr.Append(KPersistsDir);

	r = iFs.MkDirAll(*iDataDirectory);

	if(r!=KErrNone && r!=KErrAlreadyExists)

		User::Leave(r);

	//

	// Writeable-drive backup/restore directory

	//

	iBURDirectory = HBufC::NewL(systemDrive.Length()+pathLen+KBURDir().Length());

	ptr.Set(iBURDirectory->Des());

	ptr.Append(systemDrive);

	ptr.Append(path);

	ptr.Append(KBURDir);

	r = iFs.MkDirAll(*iBURDirectory);

	if(r!=KErrNone && r!=KErrAlreadyExists)

		User::Leave(r);

#ifdef SYMBIAN_BAFL_SYSUTIL	

	//

	// romversion directory

	//

	_LIT(KRomCache,"romversion\\");

	HBufC* romVersionDir = HBufC::NewLC(systemDrive.Length()+pathLen+KRomCache().Length());

	ptr.Set(romVersionDir->Des());

	ptr.Append(systemDrive);

	ptr.Append(path);

	ptr.Append(KRomCache);

	r = iFs.MkDirAll(*romVersionDir);

	if(r!=KErrNone && r!=KErrAlreadyExists)

		User::Leave(r);

	CleanupStack::PopAndDestroy();//romVersionDir

#endif

	//

	// Cache Manager 

	//

	iCacheManager = CRepositoryCacheManager::NewLC(iFs);

	CleanupStack::Pop();

	// Observer

	iObserver = CObservable::NewLC();

	CleanupStack::Pop();

	iOwnerIdLookUpTable.Reset();

	}

void TServerResources::Close()

	{

	delete iObserver;

	delete iCacheManager;

	delete iInstallDirectory;

	delete iDataDirectory;

	delete iRomDirectory;

	delete iBURDirectory;

	delete iIniExt;

	delete iCreExt;

	delete iTrnsExt;

	iFs.Close();

	iCacheManager=NULL;

	iInstallDirectory=NULL;

	iDataDirectory=NULL;

	iRomDirectory=NULL;

	iBURDirectory=NULL;	

	iIniExt=NULL;	

	iCreExt=NULL;	

	iTrnsExt=NULL;	

	iOwnerIdLookUpTable.Close() ;

	}

TInt TServerResources::GetUid(TEntry& aEntry, TUid& aUid)

	{

		const TInt KUidLen = 8;

		TPtrC uidPtr = aEntry.iName.Des().LeftTPtr(KUidLen);

		TLex  lex=uidPtr;

		TUint32 uidValue;

		if (lex.Val(uidValue, EHex) == KErrNone)

			{

			aUid = TUid::Uid(uidValue);

			}

		else

			{

			return KErrNotFound;

			}

	return KErrNone;

	}

TInt TOwnerIdMapping::CompareUids (const TOwnerIdMapping& aOwnerIdMapping1, const TOwnerIdMapping& aOwnerIdMapping2) 

	{

	if (aOwnerIdMapping1.iRepUid < aOwnerIdMapping2.iRepUid)

		return -1 ;

	else if (aOwnerIdMapping1.iRepUid > aOwnerIdMapping2.iRepUid)

		return 1 ;

	else

		return 0 ;

	}

#ifdef __CENTREP_SERVER_MEMTEST__

void TServerResources::StopRecordTimerResult()

	{

	iMemTestDataCount = KMemBufMaxEntry;

	}

//aLocation: location where the memory reading is done (a method specifier)

//aIdentifier: identifier of the memory reading (e.g. repository id, 10th reading etc)

void TServerResources::RecordTimerResult(TMemTestLocationIdentifier aLocation, TInt32 aIdentifier)

	{

	if(iMemTestDataCount+6 > KMemBufMaxEntry)

		{

		if(iMemTestDataCount+3 <= KMemBufMaxEntry)

			{

			iMemTestData[iMemTestDataCount++] = static_cast<TInt32>(KMagicMemTestOutOfBounds);

			iMemTestData[iMemTestDataCount++] = static_cast<TInt32>(KMagicMemTestOutOfBounds);

			iMemTestData[iMemTestDataCount++] = static_cast<TInt32>(KMagicMemTestOutOfBounds);

			}

		}

	else

		{

		RHeap& heap = User::Heap();

		TInt biggestBlock;

		iMemTestData[iMemTestDataCount++] = aLocation;

		iMemTestData[iMemTestDataCount++] = aIdentifier;

		iMemTestData[iMemTestDataCount++] = static_cast<TInt32>(heap.Size() - heap.Available(biggestBlock));

		}

	}

void TServerResources::StartRecordTimerResult()

	{

	iMemTestDataCount = 0;

	}

#endif //__CENTREP_SERVER_MEMTEST__