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

// Implementation of CDataOwnerManager

// 

//

/**

 @file

*/

#include "sbpackagedatatransfer.h"

#include "sbedataowner.h"

#include "sbedataownermanager.h"

#include "sbebufferhandler.h"

#include "abserver.h"

#include "sbecompressionandencryption.h"

#include <e32svr.h>

#include <arc4.h>

#include <babackup.h>

#include <ezcompressor.h>

#include <ezdecompressor.h>

#include <swi/sisregistrypackage.h>

#include <swi/sisregistryentry.h>

#include <swi/swispubsubdefs.h>

#include "OstTraceDefinitions.h"

#include "sbtrace.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "sbedataownermanagerTraces.h"

#endif

namespace conn

	{

	const TInt KSID = 0x10202D56;

	_LIT_SECURITY_POLICY_S0(KWritePolicy, KSID);

	_LIT_SECURITY_POLICY_PASS(KReadPolicy);

	_LIT_SECURE_ID(KDummyId,0x00000000);

	CDataOwnerContainer* CDataOwnerContainer::NewL(TSecureId aSecureId, CDataOwnerManager* apDataOwnerManager)

	/** Symbian OS static constructor

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNERCONTAINER_NEWL_ENTRY );

		CDataOwnerContainer* self = new(ELeave) CDataOwnerContainer(aSecureId);

		CleanupStack::PushL(self);

		self->ConstructL(apDataOwnerManager);			

		CleanupStack::Pop(self);

		OstTraceFunctionExit0( CDATAOWNERCONTAINER_NEWL_EXIT );

		return self;

		}

	CDataOwnerContainer::CDataOwnerContainer(TSecureId aSecureId) :

		iSecureId(aSecureId)

	/** Standard C++ constructor

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNERCONTAINER_CDATAOWNERCONTAINER_CONS_ENTRY );

		OstTraceFunctionExit0( CDATAOWNERCONTAINER_CDATAOWNERCONTAINER_CONS_EXIT );

		}

	CDataOwnerContainer::~CDataOwnerContainer()

		{

		OstTraceFunctionEntry0( CDATAOWNERCONTAINER_CDATAOWNERCONTAINER_DES_ENTRY );

		delete ipDataOwner;

		OstTraceFunctionExit0( CDATAOWNERCONTAINER_CDATAOWNERCONTAINER_DES_EXIT );

		}

	void CDataOwnerContainer::ConstructL(CDataOwnerManager* apDataOwnerManager)

	/* Symbian second phase constructor

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNERCONTAINER_CONSTRUCTL_ENTRY );

		ipDataOwner = CDataOwner::NewL(iSecureId, apDataOwnerManager);

		OstTraceFunctionExit0( CDATAOWNERCONTAINER_CONSTRUCTL_EXIT );

		}

	TSecureId CDataOwnerContainer::SecureId() const

	/** Secure Id accessor

	@return the secure id for the data owner container

	*/

		{

		return iSecureId;

		}

	CDataOwner& CDataOwnerContainer::DataOwner() const

	/** Data owner accessor

	@return the data owner

	*/

		{

		return (*ipDataOwner);

		}

	/**

	Method will be used for Sort on RPointerArray

	@param aFirst CDataOwnerContainer& data owner container to compare

	@param aSecond CDataOwnerContainer& data owner container to compare

	@see RArray::Sort()

	*/

	TInt CDataOwnerContainer::Compare(const CDataOwnerContainer& aFirst, const CDataOwnerContainer& aSecond)

		{

		OstTraceFunctionEntry0( CDATAOWNERCONTAINER_COMPARE_ENTRY );

		if (aFirst.SecureId() < aSecond.SecureId())

			{

			OstTraceFunctionExit0( CDATAOWNERCONTAINER_COMPARE_EXIT );

			return -1;

			}

 		else if (aFirst.SecureId() > aSecond.SecureId())

 			{

 			OstTraceFunctionExit0( DUP1_CDATAOWNERCONTAINER_COMPARE_EXIT );

 			return 1;

 			}

 		else 

 			{

 			OstTraceFunctionExit0( DUP2_CDATAOWNERCONTAINER_COMPARE_EXIT );

 			return 0;

 			}

		}

	/**

	Method will be used for Find on RPointerArray

	@param aFirst CDataOwnerContainer& data owner container to match

	@param aSecond CDataOwnerContainer& data owner container to match

	@see RArray::Find()

	*/

	TBool CDataOwnerContainer::Match(const CDataOwnerContainer& aFirst, const CDataOwnerContainer& aSecond)

		{

		return (aFirst.SecureId() == aSecond.SecureId());

		}

	CDataOwnerManager* CDataOwnerManager::NewLC()

	/** Symbian OS static constructor	

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNERMANAGER_NEWLC_ENTRY );

		CDataOwnerManager* self	= new(ELeave) CDataOwnerManager();

		CleanupStack::PushL(self);

		self->ConstructL();

		OstTraceFunctionExit0( CDATAOWNERMANAGER_NEWLC_EXIT );

		return self;

		}

	CDataOwnerManager::CDataOwnerManager() 

	/**

	Standard C++

	*/

	: ipABServer(NULL), iBufferFileReader(NULL), iDecompressor(NULL), 

	  iResetAfterRestore(EFalse), iJavaDOM(NULL), iSIDListForPartial(NULL),

	  iConfig(NULL), iBaBackupSession(NULL)

		{

		OstTraceFunctionEntry0( CDATAOWNERMANAGER_CDATAOWNERMANAGER_CONS_ENTRY );

		OstTraceFunctionExit0( CDATAOWNERMANAGER_CDATAOWNERMANAGER_CONS_EXIT );

		}

	void CDataOwnerManager::ConstructL()

	/** Symbian OS second phase contrutor

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNERMANAGER_CONSTRUCTL_ENTRY );

		TInt err = iFs.Connect();

		LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP4_CDATAOWNERMANAGER_CONSTRUCTL, "Leave: %d", err));

		err = RProperty::Define(TUid::Uid(KUidSystemCategoryValue), 

						  KUidBackupRestoreKey, 

						  RProperty::EInt, KReadPolicy, KWritePolicy, 0);

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

			{

		    OstTrace1(TRACE_ERROR, DUP3_CDATAOWNERMANAGER_CONSTRUCTL, "Leave: %d", err);

			User::Leave(err);

			}

		// Load a reference plugin with implementation Uid 0x2000D926

		const TUid aImplementationUid = { 0x2000D926 };

		iJavaDOM = CJavaManagerInterface::NewL( aImplementationUid );

		iDecompressor = CSBEDecompressAndEncrypt::NewL();

		iConfig = CSBEConfig::NewL(iFs);

		TRAP(err, iConfig->ParseL());

		if (err != KErrNone)

			{

		    OstTrace1(TRACE_NORMAL, CDATAOWNERMANAGER_CONSTRUCTL, "Error trying to parse sbeconfig.xml : %d", err);

		    OstTrace0(TRACE_NORMAL, DUP1_CDATAOWNERMANAGER_CONSTRUCTL, "Using Default Settings !");

			iConfig->SetDefault();

			}

		else

			{

		    OstTrace0(TRACE_NORMAL, DUP2_CDATAOWNERMANAGER_CONSTRUCTL, "sbeconfig.xml parsed sucessfully");

			}

		iBaBackupSession = CBaBackupSessionWrapper::NewL();

		iParserProxy = CSBEParserProxy::NewL(iFs);

		OstTraceFunctionExit0( CDATAOWNERMANAGER_CONSTRUCTL_EXIT );

		}

	CDataOwnerManager::~CDataOwnerManager()

	/** C++ Destructor

	Destructor functions are the inverse of constructor functions. They are called 

	when objects are destroyed (deallocated).

	The destructor is commonly used to "clean up" when an object is no longer necessary.

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNERMANAGER_CDATAOWNERMANAGER_DES_ENTRY );

		if(iJavaDOM)

			{

			delete iJavaDOM;

			}

		delete iParserProxy;

		delete iBufferFileReader;

		delete iDecompressor;

		iDataOwners.ResetAndDestroy();

		iDataOwners.Close();

		iPackageDataOwners.ResetAndDestroy();

		iPackageDataOwners.Close();

		iFs.Close();

		if (iSIDListForPartial != NULL)

			{

			iSIDListForPartial->Close();

			delete iSIDListForPartial;

			}

		delete iConfig;

		delete iBaBackupSession;

		OstTraceFunctionExit0( CDATAOWNERMANAGER_CDATAOWNERMANAGER_DES_EXIT );

		}

	void CDataOwnerManager::AllSystemFilesRestoredL()

	/**

	Handle send from the client informing us that the reg files have now all been supplied and 

	we can parse/start active data owners etc.

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL_ENTRY );

		if(iBURType == EBURRestoreFull || iBURType == EBURRestorePartial)

			{

		    OstTrace0(TRACE_NORMAL, CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "called, parse reg files & start active DO's");

			// Build the list of dataOwners

			TInt err;

			TRAP(err, FindDataOwnersL());

			if (err != KErrNone)

				{

			    OstTrace1(TRACE_NORMAL, DUP1_CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "Error while finding data owners: %d", err);

				}

			TInt doCount = iDataOwners.Count();

			// Loop throught the list

			for (TInt x = 0; x < doCount; x++)

				{

				CDataOwnerContainer* pContainer = iDataOwners[x];

				CDataOwner& dataOwner = pContainer->DataOwner();

				TRAP_IGNORE(dataOwner.ParseFilesL());

				}

			doCount = iDataOwners.Count();

			// update partial state of active data owners

			TRAP(err, UpdateDataOwnersPartialStateL());

			if (err != KErrNone)

				{

			    OstTrace1(TRACE_NORMAL, DUP2_CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "Error while updating state: %d", err);

				}

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

				{

				// Start data owning process if necessary for active data owners

				TRAP(err, iDataOwners[index]->DataOwner().StartProcessIfNecessaryL());

				if (err != KErrNone)

					{

				    OstTrace1(TRACE_NORMAL, DUP3_CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "Error while starting process if necessary: %d", err);

					}

				// Set up the internal state of the data owners now that all reg files and proxies are back

				TRAP(err, iDataOwners[index]->DataOwner().BuildDriveStateArrayL());

				if (err != KErrNone)

					{

				    OstTrace1(TRACE_NORMAL, DUP4_CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "Error while building drive array: %d", err);

					}

				}

			if(iJavaDOM)

				{				

				TRAP_IGNORE(iJavaDOM->AllSystemFilesRestored());

				}

			else

				{

			    OstTrace0(TRACE_NORMAL, DUP5_CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "Java Backup-Restore Plug-In not loaded, java files won't be backed or restored");

				}

			// now deal with special case packages

			CDesCArray* files = new(ELeave) CDesCArrayFlat(KDesCArrayGranularity);

			CleanupStack::PushL(files);

			TRAP_IGNORE(FindRegistrationFilesL(KImportDir, *files));

			const TInt count = files->Count();

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

				{

				// Strip the SID

				TSecureId sid;

				const TDesC& fileName = (*files)[x];

				TRAPD(err, StripSecureIdL(fileName, sid));

				if (err == KErrNone) // If there was an error then ignore it as it is probally not a dir

					{	

					CPackageDataTransfer* pDataTransfer = NULL;

					TRAPD(err, pDataTransfer = FindPackageDataContainerL(sid));

					if (err == KErrNone)

						{

						TRAP(err, pDataTransfer->SetRegistrationFileL(fileName));

						if (err == KErrNone)

							{

							TRAP(err, pDataTransfer->ParseL());

							}

						OstTraceExt2(TRACE_NORMAL, DUP6_CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "found reg file: %S for Package: 0x%08x", fileName, sid.iId);

						}

					if (err == KErrNoMemory)

						{

					    OstTrace0(TRACE_ERROR, DUP8_CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "Leave: KErrNoMemory");

						User::Leave(KErrNoMemory);

						}

					}

				} // for

			CleanupStack::PopAndDestroy(files);

			} // end if

		else

			{

		    OstTrace0(TRACE_NORMAL, DUP7_CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "*Error: called when device is not in Restore mode !");

			}

		OstTraceFunctionExit0( CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL_EXIT );

		}

	void CDataOwnerManager::SetBURModeL(const TDriveList& aDriveList, TBURPartType aBURType, 

						 		   	   TBackupIncType aBackupIncType)

	/** Sets the publish & subscribe backup flag

	@param aDriveList a list of drives involved in the backup

	@param aBURType the type

	@param aBackupIncType the incremental type

	@leave KErrInUse a Software install is in progress, plus system wide errors

	*/						 		  

		{

		OstTraceFunctionEntry0( CDATAOWNERMANAGER_SETBURMODEL_ENTRY );

		OstTraceExt2(TRACE_NORMAL, CDATAOWNERMANAGER_SETBURMODEL, "Request new BURType (0x%08x), IncType (0x%08x)", aBURType, aBackupIncType);

		OstTraceExt2(TRACE_NORMAL, DUP1_CDATAOWNERMANAGER_SETBURMODEL, "CDataOwnerManager::SetBURModeL() - Previous BURType (0x%08x), IncType (0x%08x)", iBURType, iIncType);

		// Ensure that the device can't transition directly from backup to restore mode. It must

		// go through a normal state first. Allow the state to be set to the same.

		switch(aBURType)

			{

			case EBURNormal:

			// allow to set Normal mode in any case. no need to do anything if previous mode was Normal

				if (iBURType == EBURNormal)

					{

					OstTraceFunctionExit0( CDATAOWNERMANAGER_SETBURMODEL_EXIT );

					return;

					}

				break;

			case EBURUnset:

			// don't do anything if previous modes were Normal or Unset

				if (iBURType == EBURNormal || iBURType == EBURUnset)

					{

					OstTraceFunctionExit0( DUP1_CDATAOWNERMANAGER_SETBURMODEL_EXIT );

					return;

					}

				break;

			case EBURBackupFull:

			case EBURBackupPartial:

			case EBURRestoreFull:

			case EBURRestorePartial:

			// don't allow mode change unless , device was put into normal mode before

				if (iBURType != EBURNormal && iBURType != EBURUnset)

					{

				    OstTraceExt2(TRACE_ERROR, DUP2_CDATAOWNERMANAGER_SETBURMODEL, "*Error: BUR type has not transitioned between modes correctly, %d became %d", iBURType, aBURType);

					User::Leave(KErrCorrupt);

					}

				break;

			} // switch

		TBURPartType previousBURType = iBURType;	 

		// Need to reset the list of data owners, and old style babackup

		if ((aBURType == EBURNormal) || (aBURType == EBURUnset))

			{

		    OstTrace1(TRACE_NORMAL, DUP3_CDATAOWNERMANAGER_SETBURMODEL, "Going Normal/Unset/NoBackup (%d)", aBURType);

			// If we've transitioned from a Restore to a Normal mode, we need to send a RestoreComplete

			if (previousBURType == EBURRestoreFull || previousBURType == EBURRestorePartial) 

				{

			    OstTrace0(TRACE_NORMAL, DUP4_CDATAOWNERMANAGER_SETBURMODEL, "Calling RestoreCompleteL on all active data owners");

				TInt restoreCompleteCount = iDataOwners.Count();

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

					{

					// Start data owning process if necessary for active data owners

					TRAP_IGNORE(iDataOwners[index]->DataOwner().RestoreCompleteL());

					}

				// Do we need to reset the device

				if (iResetAfterRestore)

					{

					//

					// Currently there is no Symbian wide way to reset a device. The below call

					// was intended to perform this function but has not been implemented. 

					//

					// When/If a Symbian way to reset a device comes into existance, or a licencee

					// has specific reset calls then this is the location to add such code.

					//

					//UserSvr::ResetMachine(EStartupWarmReset);

					} // if

				}

			iResetAfterRestore = EFalse;

			iDataOwners.ResetAndDestroy();

			iPackageDataOwners.ResetAndDestroy();

			OstTrace0(TRACE_NORMAL, DUP5_CDATAOWNERMANAGER_SETBURMODEL, "Restart All Non-System Applications");

			iBaBackupSession->NotifyBackupOperationL(TBackupOperationAttributes(MBackupObserver::ETakeLock, MBackupOperationObserver::EEnd));

			iBaBackupSession->RestartAll();

			}

		else

			{

			// Check that SWInstall are not doing anything.

			TInt value;

			TInt regErr = RProperty::Get(KUidSystemCategory, Swi::KUidSoftwareInstallKey, value);

			if (regErr == KErrNone && value != Swi::ESwisNone)

				{

			    OstTrace0(TRACE_ERROR, DUP6_CDATAOWNERMANAGER_SETBURMODEL, "*Error: Leave software Install in progress.");

				User::Leave(KErrInUse);

				} // if

			else if (regErr != KErrNotFound && regErr != KErrNone)

				{

			    OstTrace0(TRACE_ERROR, DUP7_CDATAOWNERMANAGER_SETBURMODEL, "*Error: Leave could not get KUidSoftwareInsallKey");

				User::Leave(regErr);

				} // else	

			// Clobber files that are locked open

			TRequestStatus status;

			OstTrace0(TRACE_NORMAL, DUP8_CDATAOWNERMANAGER_SETBURMODEL, "Calling CloseAll()");

			if(aBURType == EBURBackupFull || aBURType == EBURBackupPartial)

 				{

 				TBackupOperationAttributes atts(MBackupObserver::EReleaseLockReadOnly, MBackupOperationObserver::EStart);

 				iBaBackupSession->NotifyBackupOperationL(atts);		 		 		 

 				iBaBackupSession->CloseAll(MBackupObserver::EReleaseLockReadOnly, status);

 				}

 			else

 				{

 				TBackupOperationAttributes atts(MBackupObserver::EReleaseLockNoAccess, MBackupOperationObserver::EStart);

 				iBaBackupSession->NotifyBackupOperationL(atts);		 		 		 

 				iBaBackupSession->CloseAll(MBackupObserver::EReleaseLockNoAccess, status);

 				}

 		 	User::WaitForRequest(status);

 		 	OstTrace0(TRACE_NORMAL, DUP9_CDATAOWNERMANAGER_SETBURMODEL, "CloseAll() returned");

			// update partial state for active data owners

			if (aBURType == EBURBackupPartial)

				{

				UpdateDataOwnersPartialStateL();

				}

			if (aBURType == EBURBackupPartial || aBURType == EBURBackupFull)

				{

				TInt doCount = iDataOwners.Count();

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

					{

					// Start data owning process if necessary for active data owners

					TRAPD(err, iDataOwners[index]->DataOwner().StartProcessIfNecessaryL());

					if (err != KErrNone)

						{

					    OstTraceExt2(TRACE_NORMAL, DUP10_CDATAOWNERMANAGER_SETBURMODEL, "Data owner (or proxy) with SID 0x%08x errored (%d) whilst starting", iDataOwners[index]->SecureId().iId, static_cast<TInt32>(err));

						}

					}

				}

			}

		TInt setError = RProperty::Set(TUid::Uid(KUidSystemCategoryValue), KUidBackupRestoreKey, aBURType | aBackupIncType);

		OstTraceExt3(TRACE_NORMAL, DUP11_CDATAOWNERMANAGER_SETBURMODEL, "Setting P&S flag to BURType (0x%08x), IncType (0x%08x), err: %d", static_cast<TUint>(aBURType), static_cast<TUint>(aBackupIncType), setError);

		LEAVEIFERROR(setError, OstTrace1(TRACE_ERROR, DUP13_CDATAOWNERMANAGER_SETBURMODEL, "Leave: %d", setError));

		// This configurable delay allows extra time to close all non-system apps.

		TUint closeDelay = iConfig->AppCloseDelay();

	 	if((closeDelay>0) && (aBURType == EBURBackupFull || aBURType == EBURBackupPartial || 

	 	                      aBURType == EBURRestoreFull || aBURType == EBURRestorePartial))

			{

			User::After(closeDelay);

			}

		iDriveList = aDriveList;

		iBURType = aBURType;

		iIncType = aBackupIncType;

		//When we set back to normal mode, invalidate all current available

		//CABSessions,since they could not be used in sequent backup/restore event

		if (aBURType == EBURUnset || aBURType == EBURNormal) 

			{

		    OstTrace1(TRACE_NORMAL, DUP12_CDATAOWNERMANAGER_SETBURMODEL, "Invalidate all ABSessions after set Setting P&S flag to 0x%08x", aBURType);

			ipABServer->InvalidateABSessions();

			}