/*

* 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 the License "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: 

* CSisRegistryCache class implementation

*

*/

/**

 @file 

 @released

 @internalComponent

*/

#include "log.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "swi/sisregistrylogversion.h"

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

#include "arrayutils.h"

#include "sisregistrycache.h"

#include "sisregistrypackage.h"

#include "sisregistryserverconst.h"

#include "sisregistryfile.h"

#include "sisregistryobject.h"

#include "integrityservices.h"

#include "installtypes.h"

#include "dessisdataprovider.h"

#include "filesisdataprovider.h"

#include "controllerinfo.h"

#include "hashcontainer.h"

#include "sisregistryfiledescription.h"

#include "siscontroller.h"

#include "sistruststatus.h"

#include "sisregistryserver.h"

#include "sisregistrytoken.h"

#include "siscertificatechain.h"

#include "cleanuputils.h"

#include "sisregistryutil.h"

#include "swispubsubdefs.h"

#include <sacls.h>

#include <connect/sbdefs.h>

#include "securitypolicy.h"

#include "sislangchangemonitor.h"

using namespace Swi;

_LIT(KTempLog,"\\sys\\install\\templog.txt");

const TInt KUidHexLength = 8;

TUint CSisRegistryCache::iSubsessionId = 0;

CSisRegistryCache* CSisRegistryCache::NewL()

	{

	CSisRegistryCache* self = NewLC();

	CleanupStack::Pop(self);

	return self;

	}

CSisRegistryCache* CSisRegistryCache::NewLC()

	{

	CSisRegistryCache* self = new(ELeave) CSisRegistryCache;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CSisRegistryCache::~CSisRegistryCache()

	{

	TInt res;

	// General note: trap the error because this is not a leaving function

	// and generating an error will not help 

	// store the backup file out 

 	TRAP(res, StoreBackupL());

 	if (res != KErrNone)

 		{

 	DEBUG_PRINTF2(_L8("Sis Registry Server - Failed to store backup (failure code: %d.)"), res);

 		}

	// integrity service operation committing point 

	TRAP(res, iIntegrityService->CommitL());

	if (res != KErrNone)

 		{

	DEBUG_PRINTF2(_L8("Sis Registry Server - Failed to commit integrity services changes (failure code %d.)"), res);

 		}

	delete iBackupFile;

	delete iIntegrityService;

	delete iSisRegLangMonitor;

	CleanUp();

	iFs.Close();

	}

void CSisRegistryCache::ConstructL()

	//

	// 2nd phase construct 

	//

	{	

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

	RBuf backupFile;

	backupFile.CreateL(KMaxFileName);

	backupFile.CleanupClosePushL();

	backupFile.Append(KSysBackupFile);

	backupFile[0] = iFs.GetSystemDriveChar();

	iBackupFile = backupFile.AllocL();

	CleanupStack::PopAndDestroy(&backupFile); //backupFile

	iSystemDrive = iFs.GetSystemDrive();

	iUseIntegServices = ETrue;

	// private integrity service initialized by time 

	TTime currentTime;

	currentTime.UniversalTime(); 

	iIntegrityService = CIntegrityServices::NewL(currentTime.Int64(), KIntegrityServicesPath);

	// if backup file exists, read it and delete file - the short cut

	// otherwise revert to reading from registry directories and building registry from scratch

	TInt res = KErrNone;

	TRAP(res , res = IsFirmwareUpdatedL());

	if ( !res )

	    {

        DEBUG_PRINTF(_L8("Sis Registry Server - No Firware upgrade detected. Trying to intialize from cache "));

	    TRAP(res, InitFromBackupL());

	    isFwUpdated = EFalse;

	    }

	else

	    {

        DEBUG_PRINTF(_L8("Sis Registry Server - Firware upgrade detected. Initializing from registry/stub entries"));

        res = KErrGeneral;

        isFwUpdated = ETrue;

	    }

	// if the backup file has not been found or it was garbled or else

	if (res != KErrNone) 

		{

		DEBUG_PRINTF2(_L8("Sis Registry Server - Construction from backup failed (Error code %d). Proceeding with re-init."),

			res);

		// InitFromBackupL() failed, there might have some entries left on the cache

		CleanUp();

		InitStartUpL();

		UpdateLocalizedNamesL();

		}  

	//Start language change monitor.

	iSisRegLangMonitor = CSisLangChangeMonitor::NewL(*this);

		}

void CSisRegistryCache::CleanUp()

	{

	iTokens.ResetAndDestroy();

	iFiles.ResetAndDestroy();

	}

void CSisRegistryCache::UidListL(RArray<TUid>& aUids) const

	{

	aUids.Reset();

	for (TInt i = 0; i < iTokens.Count(); i++)

		{

		TInt err = aUids.InsertInUnsignedKeyOrder((iTokens[i])->Uid());

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

			{

			User::Leave(err);

			}

		}

	}

void CSisRegistryCache::PackageListL(RPointerArray<CSisRegistryPackage>& aPackages) const

	{

	aPackages.ResetAndDestroy();

	for (TInt i = 0; i < iTokens.Count(); i++)

		{

		CSisRegistryPackage *package = CSisRegistryPackage::NewLC(*iTokens[i]);

		aPackages.AppendL(package);

		CleanupStack::Pop(package);

		}

	}

RFs& CSisRegistryCache::RFsHandle()

	{ 

	return iFs;

	}

void CSisRegistryCache::BuildRomListL()

	{

	DEBUG_PRINTF(_L8("Sis Registry Server - Registering In-Rom controllers."));

	TDriveUnit romDrive(SystemRomDrive());

	RBuf romRegistryPath;

	romRegistryPath.CreateL(romDrive.Name(), KMaxPath);

	CleanupClosePushL(romRegistryPath);

	romRegistryPath.Append(KPreInstalledPath);

	// open the directory

	CDir* dir;

	TInt err = iFs.GetDir(romRegistryPath, KEntryAttMatchExclude | KEntryAttDir, ESortNone, dir);

	// check that all is correct but make sure to handle missing directory	

	DEBUG_PRINTF2(_L8("Sis Registry Server - Reading ROM stub directory returned %d."), err);

	if (err == KErrNone)

		{

		CleanupStack::PushL(dir);

		TInt count(dir->Count());

		RBuf controllerFileName;

		controllerFileName.CreateL(KMaxFileName);

		CleanupClosePushL(controllerFileName);

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

			{

			controllerFileName = romRegistryPath;

			controllerFileName.Append((*dir)[index].iName);

			TRAPD(res, RegisterInRomControllerL(controllerFileName));

			if (res != KErrNone)

				{

				// log it only, we cannot stop as the next might be ok

				DEBUG_PRINTF2(_L8("Sis Registry Server - Failed to register in ROM controller. Error code %d."), res);

				}

			}

		CleanupStack::PopAndDestroy(2, dir); // controllerFileName

		}

	else if(err != KErrPathNotFound)

		{

		User::Leave(err);

		}

	CleanupStack::PopAndDestroy(&romRegistryPath);

	}

void CSisRegistryCache::RegisterInRomControllerL(const TDesC& aFileName)

	{

	DEBUG_PRINTF2(_L("Sis Registry Server - Registering In-ROM controller file '%S'."), &aFileName);

	RFile romController;

	CleanupClosePushL(romController);

	// open file and read the data

	User::LeaveIfError(romController.Open(iFs, aFileName, EFileRead | EFileShareReadersOnly));

	// read the data from the file

	TInt fileSize;

	romController.Size(fileSize);

	HBufC8* controllerData = HBufC8::NewLC(fileSize);

	TPtr8 ptr(controllerData->Des());

	romController.Read(0, ptr, fileSize);

	CDesDataProvider* desProvider = CDesDataProvider::NewLC(*controllerData);

	// read the controller

	Swi::Sis::CController* controller = Swi::Sis::CController::NewLC(*desProvider);

	// create an object from the controller

	CSisRegistryObject* object = CSisRegistryObject::NewLC();

	// Discard the 4 byte type field for consistency with

	// all other registry entries

	TPtrC8 assumedTypeController(controllerData->Mid(4));

	object->ProcessInRomControllerL(*controller, assumedTypeController);

	TBool overwriteRegEntry = EFalse;

    TBool isStubRegistered = IsRegistered(*object);

    if ( isFwUpdated && isStubRegistered )

	    {

	    CSisRegistryObject* tmpObj = ObjectL(object->Uid(),object->Index());

        CleanupStack::PushL(tmpObj);

	    TSisPackageTrust trustStatus = tmpObj->Trust();

	    if ( ESisPackageBuiltIntoRom == trustStatus )

	        {

            DEBUG_PRINTF2(_L8("Sis Registry Server - Attempting to delete registry entry 0x%08x as a firmware update detected"), object->Uid().iUid);

            overwriteRegEntry = ETrue;

            HBufC* name = SisRegistryUtil::BuildEntryFileNameLC(tmpObj->Uid(), tmpObj->Index());

            //Delete in memory copy of Registry token as it is no longer valid

            // Before deleting the reg entry. Otherwise there may inconsistency

            for (TInt i = 0; i < iTokens.Count(); i++)

                {

                if (!(*iTokens[i] == *tmpObj))

                    continue;

                    // remove this token from the array

                    CleanupStack::PushL(iTokens[i]);

                    iTokens.Remove(i);

                    CleanupStack::PopAndDestroy(1); // iTokens[i]

                    break;

                }

            TEntry entry;

            TInt err = iFs.Entry(*name, entry);  

            if ( err==KErrNone )

               {

               iFs.Delete(*name);

               DEBUG_PRINTF2(_L8("Sis Registry Server - Successfully deleted registry entry 0x%08x. "), object->Uid().iUid);

	           }

			   CleanupStack::PopAndDestroy();

	        }

        CleanupStack::PopAndDestroy();

	    }

	// we cannot guess whether it is registered without opening it

    if (!isStubRegistered || overwriteRegEntry )

		{

		// update cache or just call refresh

		AddEntryL(*object, *iIntegrityService);

		// store a copy of the controller

		HBufC* name = SisRegistryUtil::BuildControllerFileNameLC(object->Uid(), object->Index(),

				0);

		SisRegistryUtil::EnsureDirExistsL(iFs, *name);

		RFile newController;

		// If stray .ctl files exist (for example, after phone was rebooted in the middle of registration), calling RFile::Create() will result a Leave.

		// Therefore, RFile::Replace() is rather ideal.

		User::LeaveIfError(newController.Replace(iFs, *name, EFileWrite | EFileShareExclusive));

		CleanupStack::PopAndDestroy(name);

		CleanupClosePushL(newController);

		// Write the controller, minus the 4 byte type field for consistency with

		// all other registry entries		

		newController.Write(assumedTypeController);

		CleanupStack::PopAndDestroy(&newController);

		}

	CleanupStack::PopAndDestroy(5, &romController); //controller, object, desProvider, controllerData

	}

void CSisRegistryCache::BuildUidListL()

	{

	DEBUG_PRINTF(_L8("Sis Registry Server - Reading registry files from disk."));

	TDriveUnit drive(iSystemDrive);

	RBuf registryPath;

	registryPath.CreateL(drive.Name(), KMaxPath);

	CleanupClosePushL(registryPath);

	registryPath.Append(KRegistryPath);

	CDir* dir;

	TInt err = iFs.GetDir(registryPath, KEntryAttDir, ESortNone, dir);

	DEBUG_PRINTF2(_L8("Sis Registry Server - Reading registry directory returned %d"), err);

	if(err == KErrNone)

		{

		CleanupStack::PushL(dir);

		TInt count(dir->Count());

		RBuf uidPath;

		uidPath.CreateL(KMaxFileName);

		CleanupClosePushL(uidPath);

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

			{

			const TEntry& entry = (*dir)[index];

			TPtrC ptr(entry.iName);

			// we expect uid directories to be 8 characters long, ignore others

			if (ptr.Length() == KUidHexLength)

				{

				TLex lex(ptr);

				TUint32 uid;

				// Convert the filename to a Uint32.

				User::LeaveIfError(lex.Val(uid, EHex));	

				uidPath = registryPath;

				uidPath.Append(entry.iName);

				uidPath.Append(KPathDelimiter);

				//for this uid				

				TRAPD(res, BuildFileListL(TUid::Uid(uid), uidPath););

				if (res != KErrNone )

					{

					// log it only, we cannot stop as the next might be ok

					DEBUG_PRINTF3(_L8("Sis Registry Server - Failed to read from registry entry 0x%08x. Error code %d"),

						uid, res);

					}

				}

			}

		CleanupStack::PopAndDestroy(2, dir); // uidPath

		}

	else

		{

		if (err != KErrPathNotFound)

			{

			User::Leave(err);

			}

		}

	CleanupStack::PopAndDestroy(&registryPath);

	}

void CSisRegistryCache::BuildFileListL(TUid aUid, const TDesC& aPath)

	{

	DEBUG_PRINTF2(_L8("Sis Registry Server - Attempting to read registry entry 0x%08x."), aUid.iUid);

	RBuf registryFileSpec;

	registryFileSpec.CreateL(aPath, KMaxFileName);

	CleanupClosePushL(registryFileSpec);

	registryFileSpec.Append(KRegFileFilter);

	CDir* dir;

	User::LeaveIfError(iFs.GetDir(registryFileSpec, KEntryAttMatchExclude | KEntryAttDir, ESortNone, dir));

	CleanupStack::PushL(dir);

	DEBUG_PRINTF2(_L8("Sis Registry Server - Registry entry contains %d registry files."), dir->Count());

	TInt count(dir->Count());

	RBuf fileName;

	fileName.CreateL(KMaxFileName);

	CleanupClosePushL(fileName);

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

		{

		fileName = aPath;

		fileName.Append((*dir)[index].iName);

		RFileReadStream fileStream;

		// open the file 

		User::LeaveIfError(fileStream.Open(iFs, fileName, EFileRead));

		CleanupClosePushL(fileStream); 

		CSisRegistryToken* token = CSisRegistryToken::NewLC(fileStream);

		DEBUG_PRINTF5(_L("Sis Registry Server - Entry at index %d, UID: 0x%08x, Name: %S, Vendor: %S."),

			index, token->Uid().iUid, &(token->Name()), &(token->Vendor()));

		if (token->Uid() != aUid)

			{

			DEBUG_PRINTF(_L8("Sis Registry Server - Registry file does not match entry directory. Corrupt."));

			User::Leave(KErrCorrupt);	

			}

		iTokens.Append(token);

		CleanupStack::Pop(token);

		CleanupStack::PopAndDestroy(&fileStream);

		}

	CleanupStack::PopAndDestroy(3, &registryFileSpec); // dir, filename

	}	

void CSisRegistryCache::InitFromBackupL()

	{

	// cleanup the list

	iTokens.ResetAndDestroy();

	RBuf backupFile;

	backupFile.CreateL(KMaxFileName);

	backupFile.CleanupClosePushL();

	backupFile.Append(KSysBackupFileBackup);

	backupFile[0] = iFs.GetSystemDriveChar();

	// if the backup of the cache backup file exists, the cache backup file may

	// be corrupt. Delete it and return immediately. The cache will be regenerated.

	TInt err = iFs.Delete(backupFile);

	if (err == KErrNone)

		{

		DEBUG_PRINTF2(_L("CSisRegistryCache::InitFromBackupL deleted %S. Corrupt file?"), &backupFile);

		User::LeaveIfError(KErrNotFound);	

		}

	else if (err != KErrNotFound)

	  	{

	  	User::LeaveIfError(err);

	  	}

	User::LeaveIfError(iFs.Rename(*iBackupFile, backupFile));

	// open file as a read stream and read data as a stream

	RFileReadStream stream;

	User::LeaveIfError(stream.Open(iFs, backupFile, EFileRead | EFileShareReadersOnly));

	CleanupClosePushL(stream);

	TLanguage currentLanguage = User::Language();

	TLanguage storedLanguage = static_cast<TLanguage>(stream.ReadUint32L());

	// Stored Language can't be greater than ELangMaximum

	// Hence Leave as the backupfile may be corrupted

	if ( storedLanguage > ELangMaximum)

		{

		User::Leave(KErrCorrupt);

		}

	InternalizePointerArrayL(iTokens, stream); 

	if ( currentLanguage != storedLanguage)

		{

		UpdateLocalizedNamesL();

		}

	CleanupStack::PopAndDestroy(&stream);

	// in the unlikely event that the CommitL() fails in ConstructL() 

	// when we remove this file, it needs to be the same as the original name.

	User::LeaveIfError(iFs.Rename(backupFile, *iBackupFile));

	CleanupStack::PopAndDestroy(&backupFile);

	// remove the file, all the information is in RAM

	// no need to maintain and syncronise the information in two places

	// so integrity services a scheduled to remove the file at next call to commit

	iIntegrityService->RemoveL(*iBackupFile); 

	iIntegrityService->CommitL();

	// only when all is processed one can check the package state		

	UpdatePackagePresentStateL();

	}

void CSisRegistryCache::InitStartUpL()

	{

	// else reinit lists- initial settings, esp at the first reboot

	BuildUidListL();

	iUseIntegServices = EFalse; // temporarily "turn off" integrity services. It is not needed to process ROM stubs

	BuildRomListL();

	iUseIntegServices = ETrue;

	// While building the UIDs and the ROM list, new files could've been generated, so we should commit the changes to the FS.

	iIntegrityService->CommitL();

	// only when all is processed one can check the package state		

	UpdatePackagePresentStateL();