/*

* 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 used to store and access registry entry information in RAM 

* serving as a "cache" alternative to reading/seaching from other storage media

*

*/

/**

 @file 

 @released

 @internalComponent

*/

#ifndef __SISREGISTRYCACHE_H__

#define __SISREGISTRYCACHE_H__

#include <e32base.h>

#include <f32file.h>

#include <swi/swiobserverclient.h>

#include <s32strm.h>

#include <s32mem.h>

#include "sisregistrylog.h"

class RReadStream;

class RWriteStream;

namespace Swi

{

class CIntegrityServices;

class CSisRegistryPackage;

class CSisRegistryFile;

class CSisRegistryObject;

class CSisRegistryToken;

class CHashContainer;

class CSisRegistryFileDescription;

class TSisTrustStatus;

/**

 * @internalComponent

 * @released

 */

class CSisRegistryCache : public CBase

	{

public:

	static CSisRegistryCache* NewL();

	static CSisRegistryCache* NewLC();

	~CSisRegistryCache();

	/**

	 * Returns the current list of registered Uids, even those on removable media

	 */

	void UidListL(RArray<TUid>& aUids) const;

	/**

	 * Returns the current list of registered packages, even those on removable media

	 */

	void PackageListL(RPointerArray<CSisRegistryPackage>& aPackages) const;

	/**

	 * Returns the current list of registered packages, even those on removable media

	 */

	void PackageAugmentationsL(const TUid aUid, RPointerArray<CSisRegistryPackage>& aPackages) const;

	/**

	 * Returns the number of augmentations of a registred package with the passed UID

	 *

	 * @param aUid the UID of the package

	 * @return the augmentations number of the package

	 */

	TInt PackageAugmentationsNumber(const TUid aUid) const;

	/**

	 * Returns the Rfs handle, serves as a central point for all RFs calls

	 */

	RFs& RFsHandle();

	/**

	 * Returns a number between 1 and 0xFFFFFFFF, which internally identifies  

	 * a subsession and the assocaited registry entry 

	 */

    static TUint AllocateSubsessionId();

	/**

	 * Perform search of whether a specific object has been registered

	 */

	TBool IsRegistered(const TUid aUid) const;

	TBool IsRegistered(const CSisRegistryPackage& aPackage) const;

	TBool IsRegistered(const CHashContainer& aHashContainer) const;

	/**

	 * Perform search of whether a specific object (package, token) 

	 * has been registered conforming to specific search arguments. If found returns 

	 * reference to the object in question leave if not found, or if error

	 */

    CSisRegistryPackage& PackageL(const TUid aUid) const;

    CSisRegistryPackage& PackageL(const TUid aUid, TInt aIndex) const;

	CSisRegistryPackage& PackageL(const TDesC& aName, const TDesC& aVendor) const;

	CSisRegistryToken& TokenL(const TUid aUid, const TDesC& aName, const TDesC& aVendor) const;

	CSisRegistryToken& TokenL(const TUid aUid, TInt aIndex) const;

	/**

	 * create an object from registry file

	 */

	CSisRegistryObject* ObjectL(TUid aUid, const TDesC& aName, const TDesC& aVendor);

	CSisRegistryObject* ObjectL(TUid aUid, TInt aIndex);

	CSisRegistryObject* ObjectL(const CSisRegistryToken& aToken);

	CSisRegistryPackage& SidToPackageL(const TUid aSid) const;

	void SidToPackageL(const TUid aSid, RArray<CSisRegistryPackage>& aListMatchingPackages ) const;

	/**

	 * Find the given filename from the list of all tokens.

	 * Return whether file is modifiable.

	 */

	TBool ModifiableL(const TDesC& aFileName);

	/**

	 * Find the given filename from the list of all tokens.

	 * Return its hash.

	 */

	CHashContainer* HashL(const TDesC& aFileName);	

	void OpenReadHandleL(const CSisRegistryPackage& aPackage, TUint& aId);

    void CloseReadHandleL(TUint aId);

    CSisRegistryFile& HandleEntryL(TUint aId);

	CSisRegistryObject& EntryObjectL(TUint aId);

    void DependentsPackagesL(const CSisRegistryObject& aObject,

						 RPointerArray<CSisRegistryPackage>& aDependents);

	void EmbeddingPackagesL(const CSisRegistryObject& aObject,

						 RPointerArray<CSisRegistryPackage>& aEmbedding);

   	void GenerateChainListL(const CSisRegistryObject& aObject, 

   							RPointerArray<HBufC8>& aChainList);	

	 /**

	 Loads a single controller belonging to the registry object and

	 places the controller buffer on the cleanup stack.

	 @param aObject The SIS registry object that owns the controller

	 @param aIndex The index of the controller

	 @return a pointer to the buffer containing the controller.

	 */

	 HBufC8* LoadControllerLC(const CSisRegistryObject& aObject, TUint aIndex);   							

	void GenerateControllersArrayL(const CSisRegistryObject& aObject, 

									RPointerArray<HBufC8>& aControllers);	

	// drive oriented functionality											 

	void AddDriveAndRefreshL(TInt aDrive);

	void RemoveDriveAndRefresh(TInt aDrive);

	inline TUint FixedDrives() const;

	void RemoveRegistryEntryL(const CSisRegistryObject& aObject, CIntegrityServices& aIntegrityService);

	void RemoveRegistryFilesL(const CSisRegistryObject& aObject, CIntegrityServices& aIntegrityService);

	void AddRegistryEntryL(CSisRegistryObject& aObject, CIntegrityServices& aIntegrityService, const TDesC8& aController);

 	/// Regenerates the cache to match the files on disk

	// Existing integrity services journal files will be committed.

 	void RegenerateCacheL();

    /** 

     * Updates the trust status settings in the registry for the 

     * package identified by uid. Note that this updates the registry's 

     * file system.

     *

     * @param uid The uid of the registry entry to be updated

     * @param status The new trust status values to assign to the entry

     *

     * @return KErrNone on success

     * @return KErrInUse if another process holds the registry file requiring the update

     */

    TUint UpdateTrustStatusL(const TUid& uid,

                             const TSisTrustStatus& status );

	TBool IsSidPresent(const TUid aSid) const;

	/** 

     * Sets the remove with last dependent flag in the registry for the 

     * package identified by uid. Note that this updates the registry's 

     * file system.

     *

     * @param uid The uid of the registry entry to be updated

     * @param status The new trust status values to assign to the entry

     *

     * @return KErrNone on success

     * @return KErrInUse if another process holds the registry file requiring the update

     */

	TUint SetRemoveWithLastDependentL(const TUid& uid);

	/**

	 * Returns an array of the currently installed packages which can be removed

	 * (including augmentations).

	 *

	 * @param aPackages The array of installed packages which are removable

	 */

	void RemovablePackageListL(RPointerArray<CSisRegistryPackage>& aPackages);

	/**

	 * Performs a roll back and then regenerates the cache to match the registry files on disk

	 */

	void RecoverL();

private:	

	void ConstructL();

    /**

	 *  Used to locate the index of a registry file index in iFiles, which corresponds to 

	 *  aId argument value

	 */    	

	TInt FindReadHandleIndx(TUint aSubsessionId);	

    /**

	 * Used to cleanup the object as a part of a reset. 

	 */    		

    void CleanUp();

	/**

	 * Builds the array of installed packages by scanning for UID directories

	 * within the SwiRegistry path.

	 *                                                   |-UID(hex)-|

	 * The path is in the form ...\sys\install\swiregistry\uuuuuuuu\

	 */

	void BuildUidListL();

	/**

	 * Builds the list with underlying files in a specific package directory

	 */

	void BuildFileListL(TUid aUid, const TDesC& aUidPath);

	void BuildRomListL();

	void RegisterInRomControllerL(const TDesC& aFileName);

	void DiscoverUidsL(TInt aDrive);

	void DiscoverStubsL(TInt aDrive);

	void RegisterControllerL(const TDesC& aFileName, CFileMan& aFileMan);

	void DiscoverControllersL(const TDesC& aRegistryPath, const TDesC& aDirectoryName);

	TBool IdentifyControllerL(TUid aUid, TInt aAugmentationIndex, const TDesC& aFileName);

	inline TBool UseIntegrityServices() const; // Integrity services is not needed during ROM stub processing

	/** 

	 * Cache internal state management

	 */

	// check whether last time SisRegistryServer closed down correctly

	TBool BackupExists();

	// use backup file to initialise internal information;

	// files are committed at the end of the process 

	void InitFromBackupL();

	// used after a SisRegistryServer crashed / at first start up

	// files are committed at the end of the process 

	void InitStartUpL();

	// creates a copy of registry internal state in a file 

	void StoreBackupL();

    /**

	 * Drive management oriented

	 */    		

    void InitDrivesL();

    void UpdatePackagePresentStateL();

    // create an array of the drives used by a specific installed package 

	void ControllerDriveListL(const CSisRegistryObject& aObject, RArray<TInt>& aDriveList);

	void AddEntryL(CSisRegistryObject& aObject, CIntegrityServices& aIntegrityService);				

	void RemoveEntryL(const CSisRegistryPackage& aPackage, CIntegrityServices& aIntegrityService);

 	void AddControllerL(const CSisRegistryObject& aObject, CIntegrityServices& aIntegrityService, const TDesC8& aBuffer, const TInt aDrive);

 	TBool RemoveControllerL(const CSisRegistryObject& aObject, CIntegrityServices& aIntegrityService, TInt aDrive);

 	void AddCleanupInfrastructureL(CSisRegistryObject& aObject, CIntegrityServices& aIntegrityServices, const TDesC8& aControllerBuffer);

 	void RemoveCleanupInfrastructureL(const CSisRegistryObject& aObject, CIntegrityServices& aIntegrityServices);

    /**

     * Persists the provided registry object into the specified file. Note all

     * other CSisRegistryFile objects refering to the specified file must have

     * their streams closed before calling this method.

     *

     * @param filename The file to write

     * @param obj The object to persist

     **/

    void UpdateRegistryFileL(const TFileName& filename,

                             const CSisRegistryObject& obj);

	void ReadSymbianHeaderL(RFile& aFile, TUid& aUid1, TUid& aUid2, TUid& aUid3);

	TUid IdentifyUidFromSisFileL(TDesC& aFilename);

	/**

	 * Resolves and sets the index value on embedded packages

	 */

	void ResolveEmbeddedPackage(CSisRegistryPackage* aPackage);

	/**

	 * Updates the localizedvendorname and packagenames as per the current

	 * language of the device

	 */

	void UpdateLocalizedNamesL();

	void CloseAllHandlesForUid(const TUid& aUId);

	void ReloadAllHandlesForUidL(const TUid& aUId, const HBufC *registryFilename);	

	TBool IsFirmwareUpdatedL();

	void  UpdateRecentFWVersionL(); 

private:

	// File system session which is used to make all requests to file server

	RFs iFs;

	// An array of 

	RPointerArray<CSisRegistryToken> iTokens;

	// Subsession id reference counter for currently open subsessions

	// it starts from 1 and increments with every subsession Open request

	// the counter rolls over when it reaches max value. It is assumed that 

	// this method reallistically would not suffer from id clash 

	static TUint iSubsessionId;	

	// files corresponding to subsessions

	// array of pointers to curenltly open registry objects 

	// the array index does not bear any relation to the id reference counter	

	RPointerArray<CSisRegistryFile> iFiles;

	// internal (sisregistryserver specific) object used to maintain the registry integrity 	

	CIntegrityServices* iIntegrityService;

	// Bitmap members which store currently present drives, one for all drives and one for 

	// permanent(fixed) drives.   

	TUint iPermDrives;  // stores just the fixed drives

	// Backup file

	HBufC* iBackupFile;

	// The registry is stored on the system drive

	TDriveNumber iSystemDrive;

	// ETrue if integrity services is needed for registry consistency

	TBool iUseIntegServices;

	//inner class of CSisRegistryCache

	class CSisLangChangeMonitor; 

	// Active Object used for language change monitoring.

	CSisLangChangeMonitor* iSisRegLangMonitor; 

	TBool isFwUpdated;

private:

	friend class CSisLangChangeMonitor;

public:

 	/**

 	 * Adds an entry to SWI Log for aObject.

 	 * 

 	 * @param aObject CSisRegistryObject 

     * @param Installinfo descriptor containing installation type

     */

  	void AddLogEntryL(const CSisRegistryObject& aObject, TSwiLogTypes aInstallinfo);

	};

inline TUint CSisRegistryCache::FixedDrives() const

	{

	return iPermDrives;

	}

inline TUint CSisRegistryCache::AllocateSubsessionId()

	{

	return (iSubsessionId < 0xFFFFFFFF)?(++iSubsessionId):(iSubsessionId = 1);	

	}

inline TBool CSisRegistryCache::UseIntegrityServices() const

	{

	return iUseIntegServices;

	}

} //namespace

#endif //__SISREGISTRYCACHE_H__