// 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 "panic.h"

#include "shrepos.h"

#include "srvrepos_noc.h"

#include "srvres.h"

#include "cachemgr.h"

#include "sessnotf.h"

#include "srvPerf.h"

#include "srvreqs.h" 

#include "rstrepos.h"

#ifdef SYMBIAN_BAFL_SYSUTIL

#include <bafl/sysutil.h>

#endif

#include <e32def_private.h>

void CServerRepository::OpenL(TUid aUid, MObserver& aObserver, TBool aFailIfNotFound)

	{

	iNotifier = &aObserver;

	iRepository = TServerResources::iObserver->AccessL(aUid, aFailIfNotFound);

	//store uid

	iUid = aUid;	

	TServerResources::iObserver->AddObserverL(aUid, this);

	TServerResources::iObserver->AddSharedRepositoryInfoL(aUid);

	}

void CServerRepository::Close()

	{

	iRepository = NULL;

	TInt index = TServerResources::iObserver->FindOpenRepository(iUid);

	if (index>=0)

		{

		iRepository = TServerResources::iObserver->GetOpenRepository(index);

		}

	// cancel to ensure any read/write locks are released and transaction settings cleaned up

    CancelTransaction();

	TServerResources::iObserver->RemoveObserver(iUid, this, index);

	iNotifier = NULL;			

	}

/**

Notify about all changed keys stored in the specified reference to the

CRestoredRepository.

@param aRstRepos The reference to CRestoredRepository which holds the list 

of the changed keys.

*/	

void CServerRepository::RestoreNotify(const CRestoredRepository& aRstRepos)

	{

	const RArray<TUint32>& keys = aRstRepos.ChangedKeys();

	TInt count=keys.Count();

	for(TInt i = 0; i < count; i++)

		{

		 iRepository->Notify(keys[i]);

		}

	}

/**

Attempt to reset a single key to it's value in the file in the given location. Routine

attempts to find a .cre file first. If ( and only if ) a cre file doesn't exist the 

routine attempts to find a txt file. In the presence of multi rofs, it needs to perform

merging of all the rom keyspaces first before doing a reset, hence we are not able to perform

the reading line by line for efficiency purpose.

*/

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	

void CServerRepository::ResetFromIniFileL(TUint32 aId, 

										  CIniFileIn::TIniFileOpenMode aIniFileOpenMode,

										  TBool& aKeyFound)

	{

	aKeyFound=EFalse;

	CSharedRepository* rep=NULL;

	// Attempt to reset key to the aLocation if exist

	//dont fail if repository not found

	TServerResources::iObserver->LoadRepositoryLC(iRepository->Uid(),EFalse,rep,aIniFileOpenMode);

	if (rep)

		{

		TServerSetting* s = rep->GetSettings().Find(aId);					

		if(s)

			{

			aKeyFound=ETrue;

			// Mark the setting as default again

			s->SetClean();

			iRepository->ResetAndPersistL(*s);

			s->SetAccessPolicy(GetFallbackAccessPolicy(aId));

			}

		}

	CleanupStack::PopAndDestroy(rep);

	}

#else

/**

Attempt to reset a single key to it's value in the file in the given location. Routine

attempts to find a .cre file first. If ( and only if ) a cre file doesn't exist the 

routine attempts to find a txt file.

Note that it would be possible to use LoadRepositoryLC here but for the txt file

that would take longer. This is because in LoadRepositoryLC the txt file is 

completely processed. The Reset specific txt file opening code below is quicker because 

it is just attempting to find the reset key.

*/

void CServerRepository::ResetFromIniFileL(TUint32 aId, 

										  TCentRepLocation aLocation,

										  TBool& aKeyFound)

	{

	aKeyFound=EFalse;

	// Attempt to reset key to value in cre file if it exists

	// Attempt to create a temporary repository from the cre file in aLocation

	CSharedRepository* rep = CSharedRepository::NewL(iRepository->Uid());

	CleanupStack::PushL(rep);

	TInt err = rep->CreateRepositoryFromCreFileL(aLocation);

	// Search for aId in the temporary repository

	if (err!=KErrNotFound)

		{		

		// Note that for all errors except KErrNotFound code leaves and doesn't

		// attempt to look for txt file. This is intentional. Code does not 

		// attempt to support coexisting cre and txt files.

		User::LeaveIfError(err);

		// Search for aId in the temporary repository

		TServerSetting* s = rep->GetSettings().Find(aId);					

		if(s)

			{

			aKeyFound=ETrue;

			// Mark the setting as default again

			s->SetClean();

			iRepository->ResetAndPersistL(*s);

			s->SetAccessPolicy(GetFallbackAccessPolicy(aId));

			}

		CleanupStack::PopAndDestroy(rep);

		return;

		}

	else

		{

		CleanupStack::PopAndDestroy(rep);

		}

	HBufC* fileName(NULL);	

	TServerResources::CreateRepositoryFileNameLC(fileName,iRepository->Uid(),aLocation,EIni);

	CIniFileIn* inputFile = 0;

	TInt r = CIniFileIn::NewLC(TServerResources::iFs,inputFile,*fileName);

	if(r==KErrNone)

		{

		//we don't want to read this stuff again... just skip over to get to settings!

		inputFile->SkipOwnerSectionL() ;

		inputFile->SkipTimeStampSectionL() ;

		inputFile->SkipDefaultMetaSectionL() ;

		inputFile->SkipPlatSecSectionL();

		// Find start of Main section

		inputFile->FindMainSectionL();

		TServerSetting s;

		TBool singleMetaFound=EFalse;

		TBool singleReadPolicyFound=EFalse;

		TBool singleWritePolicyFound=EFalse;

		TSecurityPolicy singleReadPolicy;

		TSecurityPolicy singleWritePolicy;

		// Note that calling CIniFile::ReadSettingL causes the single policy ( if it exists ) to be read from the

		// file being reset to, but doesn't update the single policy array, which is not required in the reset case. 

		while((r=inputFile->ReadSettingL(s,singleReadPolicy, singleWritePolicy, singleReadPolicyFound, singleWritePolicyFound, singleMetaFound)) == KErrNone)

			{	

			iRepository->SetMetaDataOnRead( s, singleMetaFound);			

			if(s.Key()==aId)

				{

				// Mark the setting as default again

				s.SetClean();

				iRepository->ResetAndPersistL(s);

				s.SetAccessPolicy(GetFallbackAccessPolicy(aId));

				aKeyFound = ETrue;

				break;

				}

			s.Reset();

			}

		}

	CleanupStack::PopAndDestroy(inputFile);	 // inputFile

	CleanupStack::PopAndDestroy(fileName);	 // filename

	}

#endif	

TInt CServerRepository::ResetL(TUint32 aId)

	{

	// not yet supported in transactions

	ASSERT(!IsInTransaction());

	// if setting has not changed, there nothing to do

	TServerSetting *targetSetting = GetSetting(aId) ;

	if (targetSetting)

		{

		if ((targetSetting->Meta() & KMetaDefaultValue))

			{

			return KErrNone;

			}

		}

	TInt error = KErrNone;

	TBool keyReset = EFalse;

	// Check for default value in any installed file first

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

	ResetFromIniFileL(aId, CIniFileIn::EInstallOnly, keyReset);

#else

	ResetFromIniFileL(aId, EInstall, keyReset);

#endif	

	if (keyReset)

		return KErrNone;

	// Either we couldn't find a matching key or

	// there wasn't an installed file - try for a ROM

	// file

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS	

	ResetFromIniFileL(aId, CIniFileIn::ERomOnly, keyReset);

#else

	ResetFromIniFileL(aId, ERom, keyReset);

#endif	

	if (keyReset)

		return KErrNone;

	// No default value found in install or ROM file

	// delete the key!

	error = iRepository->DeleteAndPersist(aId);

	return error ;

	}

void CServerRepository::CacheRomVersionL(const TDesC& aFilename,TDesC8& aVersion)

	{

	RFile file;

	TInt err = KErrNone; 

	_LIT(KTmpPersistedRomVersionFile, "_:\\private\\10202be9\\romversion\\romversion_info.tmp");	

	TBuf<KMaxFileName> tmpPersistedRomVersionFileName;

	tmpPersistedRomVersionFileName.Copy(KTmpPersistedRomVersionFile);

	tmpPersistedRomVersionFileName[0] = RFs::GetSystemDriveChar();

	//Create a new empty tmp file.

    err = file.Replace( TServerResources::iFs, tmpPersistedRomVersionFileName,

	                     EFileWrite | EFileStreamText );

	if (err != KErrNone)

	       {

	       file.Close();

	       User::Leave(err);

	       }

    err = file.Write(aVersion);

	if (err != KErrNone)

		{                                                                                                  

	       file.Close();

	       User::Leave(err);

	    }

    file.Close();

	User::LeaveIfError(TServerResources::iFs.Replace(tmpPersistedRomVersionFileName,aFilename));

	}

#ifdef SYMBIAN_BAFL_SYSUTIL

void CServerRepository::CheckROMReflashL()

	{

	TInt err=KErrNone;

	TBuf16<KSysUtilVersionTextLength> version;

	TBuf8<KSysUtilVersionTextLength*2> persistedCopyOfRomVersion;

	_LIT(KPersistedRomVersionFile, "_:\\private\\10202be9\\romversion\\romversion_info.txt");	

	TBuf<KMaxFileName> persistedRomVersionFileName;

	persistedRomVersionFileName.Copy(KPersistedRomVersionFile);

	persistedRomVersionFileName[0] = RFs::GetSystemDriveChar();

	TBuf8<KSysUtilVersionTextLength*2> eightBitVersion;

	if ((err = SysUtil::GetSWVersion(version)) == KErrNone )

		{

		eightBitVersion.Copy(version);//Converts to 8bit

		err = TServerResources::GetTextFromFile(persistedRomVersionFileName,persistedCopyOfRomVersion);		

        if(err == KErrNone)

        	{

        	if(eightBitVersion == persistedCopyOfRomVersion)//No rom update has occurred do nothing

        		{

        		return;

        		}

        	else //rom update detected process persists files.

        		{

        		//Call function with flag set to true causing Reflash merging activity.

        		ProcessPersistsRepositoriesL(ECenRepReflash);

        		}

        	}

		//create the persisted rom version file

		//if the persists files are successfully processed

		//if the persists file doesnt exist

		//if the persists file is corrupt

		//if the persists file is corrupt in such a way that its contents are too large.

		if (err == KErrNone || err == KErrNotFound || err == KErrPathNotFound || err == KErrCorrupt || err == KErrTooBig)

			{

			CServerRepository::CacheRomVersionL(persistedRomVersionFileName,eightBitVersion);

			}

		else

			{

			User::Leave(err);

			}

		}

	else

		{

		User::Leave(err);

		}

	}

#endif

void CServerRepository::RFSAllRepositoriesL()

	{

	ProcessPersistsRepositoriesL(ECenRepReset);	

	}

void CServerRepository::ProcessPersistsRepositoriesL(TPersistedRepActions aRomFlashOrReset)

	{

	// Read contents of persist directory to get a list of repositories

	TPtr dataDirectory = TServerResources::iDataDirectory->Des();

	RDir persistDir;

    CleanupClosePushL(persistDir);

	User::LeaveIfError(persistDir.Open(TServerResources::iFs, dataDirectory, KEntryAttNormal));

    TEntryArray dirEntries;

    TInt readError = KErrNone;

	while (readError != KErrEof)  

		{

	    readError = persistDir.Read(dirEntries);

	    if(readError != KErrNone && readError != KErrEof) 

	    	{

	    	User::Leave(readError);

	    	}

	    else

	    	{

	    	const TInt dirCount = dirEntries.Count();   

	    	for (TInt i=0; i<dirCount; i++)

	    		{

				// Attempt to extract a repository UID from directory entry

				TUid uid;

				if (!TServerResources::GetUid(const_cast<TEntry&>(dirEntries[i]), uid))

					{

					CSessionNotifier notifier;

					// Create shared repository

					CServerRepository *repository = new(ELeave) CServerRepository;

					CleanupStack::PushL(repository);

					repository->OpenL(uid, notifier);

					//Handle ROM re-flash

					TInt err = KErrNone;

					if(aRomFlashOrReset==ECenRepReflash)

						{

						TRAP(err, repository->HandleReflashofRepositoryL());

						}

					else if(aRomFlashOrReset==ECenRepReset)

						{

						// Restore settings

						TRAP(err,repository->RFSRepositoryL());	

						}

					if(err != KErrNone)

					  {

					  if(err == KErrNoMemory)

					    {

					    User::LeaveNoMemory();

					    }

				      else

					    {//Dont stop processing the rest of the persisted repositories becos one has a problem.

					     __CENTREP_TRACE1("CENTREP: CServerRepository::ProcessPersistsRepositoriesL - Error = %d", err);

					    }

				      }

					// delete repository.

					repository->Close();

					CleanupStack::PopAndDestroy(repository);

					}

	    		}

	    	}

		}

	CleanupStack::PopAndDestroy(&persistDir);

	}

TInt CServerRepository::RFSRepositoryL()

	{

	// for each key in combined ROM/Install restore

	TUid uid = iRepository->Uid();

	CSharedRepository* defaultRepository = 0;

	TInt err=KErrNone;

	//Determine if ROM and Install files exist

  	TBool romExists=TServerResources::RomFileExistsL(uid);

  	TBool installExists=TServerResources::InstallFileExistsL(uid);

	if(romExists)

		{

		// Create a rep using the ROM file

		TServerResources::iObserver->LoadRepositoryLC(uid, ETrue, defaultRepository, CIniFileIn::ERomOnly);

		if(installExists)

			{			

			CSharedRepository *installRep = 0;

			// Create install rep for merging

			TServerResources::iObserver->LoadRepositoryLC(uid, ETrue, installRep, CIniFileIn::EInstallOnly);

			// If install and ROM exist create a merged rep to Reset against

			defaultRepository->MergeL(*installRep, ESWIUpgradeMerge);

			//pop and destroy install repository as this has now been 

			//merged with repository

			CleanupStack::PopAndDestroy(installRep);

			}		

		}

	else if(installExists)

		{		

		// Reset against install repository if only the install file exists

		TServerResources::iObserver->LoadRepositoryLC(uid, ETrue, defaultRepository, CIniFileIn::EInstallOnly);		

		}

	else

		{

        // The repository must exist in the ROM or install directory (or both). 

        ASSERT(romExists || installExists);

		// Reset against empty repository if neither ROM or install file are found

		defaultRepository = CSharedRepository::NewL(uid);

		CleanupStack::PushL(defaultRepository);

		}

	for(TInt i = 0; i < iRepository->GetSettings().Count(); i++)

		{

		// setting in persists

		TServerSetting* persistedSetting = &iRepository->GetSettings()[i];

		// If the clean is set on setting in the persist, nothing to do			

		if (persistedSetting->Meta() & KMetaDefaultValue)

			{

			continue;

			}

		TUint32 key = persistedSetting->Key();		

		// setting in ROM/install

		TServerSetting* defaultSetting = defaultRepository->GetSettings().Find(key);

		if (defaultSetting)

			{

			if ((defaultSetting->Meta() & KMetaRfsValue))

				{

				iRepository->ResetNoPersistL(*defaultSetting);

				}

			//remove from Reset repository

			defaultRepository->GetSettings().Remove(key);

			}

		else

			{

			// if setting has no default value (i.e. doesn't exist in any default file but RFS meta is 

			// set (using pre-set default range meta),  delete the setting 

			if ((persistedSetting->Meta() & KMetaRfsValue))			

				{

				iRepository->DeleteNoPersist(key);				

				}

			}

		}

	// search for remaining items in default file, because previous loop has already removed all items 

	// from the persists file

	for(TInt i = 0; i < defaultRepository->GetSettings().Count(); i++)

		{

		TServerSetting* defaultSetting = &defaultRepository->GetSettings()[i];

		if ((defaultSetting->Meta() & KMetaRfsValue) != KMetaRfsValue)

			{

			continue;

			}

		iRepository->ResetNoPersistL(*defaultSetting);

		}

	// Persist settings

	iRepository->CommitChangesL();

	CleanupStack::PopAndDestroy(defaultRepository);

	return err;

	}

TInt CServerRepository::HandleReflashofRepositoryL()

	{

	// for each key in persists repository

	TUid uid = iRepository->Uid();