// Copyright (c) 2006-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 <bautils.h>

#include <f32file.h>

#include <s32file.h>

#include "tmtptypeobjecthandle.h"

#include <mtp/cmtpobjectmetadata.h>

#include <mtp/cmtptypearray.h>

#include <mtp/mmtpobjectmgr.h>

#include <mtp/mtpdatatypeconstants.h>

#include <mtp/mtpobjectmgrquerytypes.h>

#include <mtp/mtpprotocolconstants.h>

#include <mtp/tmtptypeuint32.h>

#include "cmtphandleallocator.h"

#include "cmtpobjectstore.h"

#include "dbutility.h"

#include "cmtpdataprovidercontroller.h"

#include "cmtpdataprovider.h"

#include "cmtpdpidstore.h"

#include "cmtppkgidstore.h"

#include "cmtpdeltadatamgr.h"

#include <e32hashtab.h>

#include "cmtpstoragemgr.h"

#include "mtpdebug.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmtpobjectstoreTraces.h"

#endif

_LIT(KMTPDbDriveLocation, "c:");

_LIT(KMTPBackSlash, "\\");

_LIT(KMTPHandleObjectDbName, "MTPObjectStore.db");

_LIT(KMTPNoBackupFolderName, "nobackup");

_LIT(KSQLHandleTableName, "HandleStore");

_LIT(KSQLCreateHandleTableText, "CREATE TABLE HandleStore (HandleId UNSIGNED INTEGER, SuidHash UNSIGNED INTEGER, Suid LONG VARCHAR, DataProviderId UNSIGNED TINYINT, FormatCode UNSIGNED SMALLINT, FormatSubCode UNSIGNED SMALLINT, StorageId UNSIGNED INTEGER, Modes UNSIGNED TINYINT, POUID BIGINT, ParentHandle UNSIGNED INTEGER, DPFlag UNSIGNED TINYINT, NonConsumable UNSIGNED TINYINT, Name VARCHAR(255))");

_LIT(KSQLHandleId, "HandleIndex");

_LIT(KSQLCreateHandleIndexText,"CREATE UNIQUE INDEX HandleIndex on HandleStore (HandleId)");

_LIT(KSQLSuidHash, "SuidIndex");

_LIT(KSQLCreateSuidIndexText,"CREATE INDEX SuidIndex on HandleStore (SuidHash)");

_LIT(KSQLParentHandle, "ParentHandleIndex");

_LIT(KSQLCreateParentHandleText,"CREATE INDEX ParentHandleIndex on HandleStore (ParentHandle)");

_LIT(KMTPFormat, "MTP");

const TInt KMaxLimitCommitInEnumeration = 1024;

const TInt KMaxLimitCommitAfterEnumeration = 256;

const TInt KMaxLimitCompactInEnumeration = 2048;

const TInt KMaxLimitCompactAfterEnumeration = 1024;

const TInt KSnapshotGranularity = 128; 

const TInt KMaxLimitSnapshotSize = 50000;

CMTPObjectStore::CSnapshotWorker* CMTPObjectStore::CSnapshotWorker::NewL(CMTPObjectStore* aObjectStore, TBool aOnlyRoot)

    {

    CSnapshotWorker* self = new (ELeave) CMTPObjectStore::CSnapshotWorker(aObjectStore, aOnlyRoot);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CMTPObjectStore::CSnapshotWorker::~CSnapshotWorker()

    {

    Cancel();

    }

void CMTPObjectStore::CSnapshotWorker::RunL()

    {

    iObjectStore->CleanDBSnapshotL(iOnlyRoot);

    }

void CMTPObjectStore::CSnapshotWorker::DoCancel()

    {

    //nothing to do

    }

TInt CMTPObjectStore::CSnapshotWorker::RunErr()

    {

    return KErrNone;

    }

void CMTPObjectStore::CSnapshotWorker::ActiveSelf()

    {

    TRequestStatus *status = &iStatus;

    iStatus = KRequestPending;

    User::RequestComplete(status, KErrNone);

    SetActive();

    }

CMTPObjectStore::CSnapshotWorker::CSnapshotWorker(CMTPObjectStore* aObjectStore, TBool aOnlyRoot):

        CActive(EPriorityLow), iObjectStore(aObjectStore), iOnlyRoot(aOnlyRoot)

    {

    }

void CMTPObjectStore::CSnapshotWorker::ConstructL()

    {

    CActiveScheduler::Add(this);

    }

/**

 MTP object meta data store factory method. 

 @return A pointer to a new CMTPObjectStore instance, ownership IS transferred.

 @leave One of the system wide error codes, if a processing failure occurs.

 */

CMTPObjectStore* CMTPObjectStore::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

 Destructor.

 */

CMTPObjectStore::~CMTPObjectStore()

	{

	delete iCompactor;

	delete iReferenceMgr;

	delete iHandleAllocator;

	delete iMtpDeltaDataMgr;

	delete iDPIDStore;

	delete iPkgIDStore;

	delete iSentinal;

	delete iSnapshotWorker;

	iBatched.Close();

	iBatched_SuidHashID.Close();

	CloseDb();

	iSingletons.Close();

	iNonPersistentDPList.Close();

	iEnumeratingCacheObjList.ResetAndDestroy();

	}

/**

 Provides a reference to the object meta data store database.

 @return The object information store database.

 */

RDbDatabase& CMTPObjectStore::Database()

	{

	return iDatabase;

	}

/**

 Provides a reference to the DPID store object.

 @return The DPID store.

 */

CMTPDPIDStore& CMTPObjectStore::DPIDStore() const

	{

	return *iDPIDStore;

	}

CMTPPkgIDStore& CMTPObjectStore::PkgIDStore() const

	{

	return *iPkgIDStore;

	}

/**

 Provides a reference to the reference manager object.

 @return The reference manager.

 */

CMTPReferenceMgr& CMTPObjectStore::ReferenceMgr() const

	{

	return *iReferenceMgr;

	}

/**

Provides a reference to the MTP delta Data manager object.

@return The MTP delta data manager.

*/ 

CMtpDeltaDataMgr* CMTPObjectStore:: MtpDeltaDataMgr() const

	{

	return iMtpDeltaDataMgr;

	}

void CMTPObjectStore::RemoveNonPersistentObjectsL(TUint /*aDataProviderId*/)

	{

	}

void CMTPObjectStore::MarkNonPersistentObjectsL(TUint aDataProviderId, TUint32)

	{

	TInt result = iNonPersistentDPList.InsertInOrder(aDataProviderId);

	if(result != KErrAlreadyExists)

		{

		LEAVEIFERROR(result,

		        OstTrace1( TRACE_ERROR, CMTPOBJECTSTORE_MARKNONPERSISTENTOBJECTSL, "insert DpId %d into iNonPersistentDPList error!", aDataProviderId ));

		}

	}

void CMTPObjectStore::MarkDPLoadedL(TUint aDataProviderId, TBool aFlag)

	{

    OstTraceFunctionEntry0( CMTPOBJECTSTORE_MARKDPLOADEDL_ENTRY );

	if (!aFlag)

		{

		_LIT(KSQLMarkfalgDPFalse, "UPDATE HandleStore SET DPFlag = %u WHERE DataProviderId = %u");

		iSqlStatement.Format(KSQLMarkfalgDPFalse, aFlag, aDataProviderId);

		LEAVEIFERROR(iDatabase.Execute(iSqlStatement),

		        OstTrace0( TRACE_ERROR, CMTPOBJECTSTORE_MARKDPLOADEDL, "UPDATE HandleStore SET DPFlag error!" ));

		}

	OstTraceFunctionExit0( CMTPOBJECTSTORE_MARKDPLOADEDL_EXIT );

	}

TBool CMTPObjectStore::FilterObject(const RDbTable& aCurrRow,const TUint32 aStorageID,const TUint32 aFormatCode,const TUint32 aDpID) const

    {

    return  ( ((KMTPStorageAll==aStorageID) ||(aCurrRow.ColUint32(EObjectStoreStorageId)== aStorageID)) 

            &&((0 == aFormatCode)||(aCurrRow.ColUint16(EObjectStoreFormatCode) == aFormatCode)) 

            &&((aDpID==KMTPDataProviderAll)||(aCurrRow.ColUint8(EObjectStoreDataProviderId) == aDpID ))

            );

    }

void CMTPObjectStore::TraverseL(const TMTPObjectMgrQueryParams& aParams, MTraverseAction& action) const

	{

	RDbTable temp;

	CleanupClosePushL(temp);

	temp.Open(iDatabase, KSQLHandleTableName, RDbRowSet::EUpdatable);

	TUint32 tmpStorageID = 0;

	TBool bStorageAvailable = ETrue;

	if (aParams.iParentHandle == 0)

		{//ParentHandle is not used to filter the objects. Need to iterate throught all objects in the storage to filter based on format/dpid/storatgeid.

		//Do not using index to iterate through the whole storage is faster than index iteration.

		temp.FirstL();

		while (!temp.AtEnd())

			{

			temp.GetL();

			if ((MTraverseAction::EAllDP == action.Target()) || (temp.ColUint8(EObjectStoreDPFlag) == 1))//If the DP is loaded or ation for all dps.

				{

				if((aParams.iStorageId == KMTPStorageAll) &&(aParams.iFormatCode == 0)&&(iSingletons.DpController().DataProviderL(temp.ColUint8(EObjectStoreDataProviderId)).SupportedCodes( EServiceIDs ).Count() != 0))

				    {

				    temp.NextL();

				    continue;

				    }

				//check StorageID ,DPID and Formatcode

				if ( !FilterObject(temp,aParams.iStorageId,aParams.iFormatCode,aParams.iDpId) )

				    {

						temp.NextL();

						continue;

				    }

				//verify the whether the storageID is validated.   

				if(tmpStorageID != temp.ColUint32(EObjectStoreStorageId))

					{

					tmpStorageID = temp.ColUint32(EObjectStoreStorageId);

					bStorageAvailable = iSingletons.StorageMgr().ValidStorageId( tmpStorageID );

					}

				if(!bStorageAvailable)

					{

					temp.NextL();

					continue;

					}

				action.DoL(temp); 

				}

			temp.NextL();

			}

		}

	else

		{//Fetch the root directory

		temp.SetIndex(KSQLParentHandle);

		if (temp.SeekL((TUint) aParams.iParentHandle))

			{//every storageID has the same root directory handles.KMTPHandleNoParent, therefore, need to filter the storageID

			//if it is not KMTPStorageAll

			while (!temp.AtEnd())

				{

				temp.GetL();

				if (temp.ColUint32(EObjectStoreParentHandle) == aParams.iParentHandle)

					{

					if ((MTraverseAction::EAllDP == action.Target()) || (temp.ColUint8(EObjectStoreDPFlag) == 1))//If the DP is loaded or ation for all dps.

						{

            if((aParams.iStorageId == KMTPStorageAll) &&(aParams.iFormatCode == 0)&&(iSingletons.DpController().DataProviderL(temp.ColUint8(EObjectStoreDataProviderId)).SupportedCodes( EServiceIDs ).Count() != 0))

                {

                temp.NextL();

                continue;

                }

						//check StorageID ,DPID and Formatcode

						if ( !FilterObject(temp,aParams.iStorageId,aParams.iFormatCode,aParams.iDpId) )

						    {

								temp.NextL();

								continue;

						    }

						//verify the whether the storageID is validated.   

						if(tmpStorageID != temp.ColUint32(EObjectStoreStorageId))

							{

							tmpStorageID = temp.ColUint32(EObjectStoreStorageId);

							bStorageAvailable = iSingletons.StorageMgr().ValidStorageId( tmpStorageID );

							}

						if(!bStorageAvailable)

							{

							temp.NextL();

							continue;

							}

						action.DoL(temp);

						}

					temp.NextL();

					}

				else

					{

					break;//has jumped over the range of handles with the same parent handle

					}

				}

			}

		}

	CleanupStack::PopAndDestroy(&temp);

	//Since we fetch all handles as requested, therefore, we do not open aContext to indicate the query is completed.

	}

TUint CMTPObjectStore::CountL(const TMTPObjectMgrQueryParams& aParams) const

	{

	TUint i = 0;

	TCountAction action(i);

	TraverseL(aParams, action);

	return i;

	}

void CMTPObjectStore::CommitReservedObjectHandleL(CMTPObjectMetaData& aObject)

	{

	TFileName suid;

	suid.CopyLC(aObject.DesC(CMTPObjectMetaData::ESuid));

	TUint32 handle = HandleL(suid);

	if (handle != KMTPHandleNone)

	    {

	    OstTrace0(TRACE_ERROR, CMTPOBJECTSTORE_COMMITRESERVEDOBJECTHANDLEL,

	            "CommitReserverd leave for duplicate suid.");

	    User::Leave(KErrAlreadyExists);

	    }

	TUint32 suidHash = DefaultHash::Des16(suid);

	//After the PutL called the cursor's position is not well defined.

	iCachedHandle = 0;

	iCachedSuidHash = 0;

	TInt64 id = iHandleAllocator->NextPOUIDL();

	aObject.SetUint(CMTPObjectMetaData::EIdentifier, id);

	handle = aObject.Uint(CMTPObjectMetaData::EHandle);

	CleanupStack::PushL(TCleanupItem(CMTPObjectStore::DBUpdateFailRecover, &iBatched));

	iBatched.InsertL();

	iBatched.SetColL(EObjectStoreHandleId, handle);

	iBatched.SetColL(EObjectStoreSUIDHash, suidHash);

	DbColWriteStreamL(iBatched, EObjectStoreSUID, aObject.DesC(CMTPObjectMetaData::ESuid));	

	iBatched.SetColL(EObjectStoreDataProviderId, aObject.Uint(CMTPObjectMetaData::EDataProviderId));

	iBatched.SetColL(EObjectStoreFormatCode, aObject.Uint(CMTPObjectMetaData::EFormatCode));

	iBatched.SetColL(EObjectStoreFormatSubCode, aObject.Uint(CMTPObjectMetaData::EFormatSubCode));

	iBatched.SetColL(EObjectStoreStorageId, aObject.Uint(CMTPObjectMetaData::EStorageId));

	iBatched.SetColL(EObjectStoreModes,aObject.Uint(CMTPObjectMetaData::EModes));

	iBatched.SetColL(EObjectStorePOUID, id);

	iBatched.SetColL(EObjectStoreParentHandle, aObject.Uint(CMTPObjectMetaData::EParentHandle));

	iBatched.SetColL(EObjectStoreDPFlag, 1);

	iBatched.SetColL(EObjectStoreNonConsumable, aObject.Uint(CMTPObjectMetaData::ENonConsumable));

	iBatched.SetColL(EObjectStoreName, aObject.DesC(CMTPObjectMetaData::EName));

	iBatched.PutL();

	CleanupStack::Pop(&iBatched);

	IncTranOpsNumL();

	}

/*

 This API is designed intended for coping with the MTP operation GetObjectHandles which has 3 parameters.

 1. StorageID

 2. FormatCode

 3. ParentHandle.

 The first parameter contains the StorageID of the storage for which the list of Object Handles is desired. 

 A value of 0xFFFFFFFF may be used to indicate that a list of Object Handles of all objects on all storages 

 should be returned. If a storage is specified and the storage is unavailable, this operation should return Store_Not_Available.

 The second parameter is optional, and contains an Object Format datacode. Object Formats are described

 in section 4, "Object Formats". If the second parameter contains a non-0x00000000 value, it specifies that 

 a list of object handles referencing objects of a certain object format is desired. If the parameter is not used, 

 it should contain a value of 0x00000000 and objects should be included in the response dataset regardless 

 of their object format. If this parameter is not supported, the responder should return a response code of 

 Specification_By_Format_Unsupported.

 The third parameter may be used to restrict the list of objects that are returned by this operation to objects 

 directly contained in a particular folder (Association). If this parameter contains a non-0x00000000 value, 

 the responder should return a list of objects which have as their ParentObject the folder (Association) 

 that is identified by this parameter. If the number of objects that are contained in the root of a storage is desired, 

 a value of 0xFFFFFFFF may be passed in this operation, which indicates that only those objects with no ParentObject

 should be returned. If the first parameter indicates that all storages are included in this query, then a value of 0xFFFFFFFF

 should return a list of all objects at the root level of all storages. If this parameter is unused, it should contain a value of 0x00000000. 

 If the third parameter is unsupported and a non-0x00000000 value is sent in this operation, a response of 

 Parameter_Unsupported should be returned. If the use of the third parameter is supported, but the value 

 contained does not reference an actual object on the device, a response of Invalid_ObjectHandle should be returned. 

 If the use of the third parameter is supported and it contains a valid Object Handle, but the object referenced 

 is not of type Association, then a response of Invalid_ParentObject should be returned.

 */

void CMTPObjectStore::GetObjectHandlesL(const TMTPObjectMgrQueryParams& aParams, RMTPObjectMgrQueryContext& /*aContext*/, RArray<TUint>& aHandles) const

	{

	TGetHandlesAction action(aHandles);

	TraverseL(aParams, action);

	}

void CMTPObjectStore::GetObjectSuidsL(const TMTPObjectMgrQueryParams& aParams, RMTPObjectMgrQueryContext& /*aContext*/, CDesCArray& aSuids) const

	{

	//take the similar approach for GetObjectHandlesL, but need to pay attention for the memory usage, since every SUID might take

	//maximum 255 bytes, if there are totally 10K objects, the maximum memory usage will be 2.5M, consider to get it in multiple calls instead of one.

	TGetSuidsAction action(aSuids);

	TraverseL(aParams, action);

	}

TUint32 CMTPObjectStore::HandleL(const TDesC& aSuid) const

	{

	TUint32 handle = KMTPHandleNone;

	if (LocateBySuidL(aSuid))

		{

		handle = iBatched_SuidHashID.ColUint32(EObjectStoreHandleId);

		}

	return handle;

	}

void CMTPObjectStore::DBUpdateFailRecover(TAny* aTable)

	{

	reinterpret_cast<RDbTable*> (aTable)->Cancel();

	}

void CMTPObjectStore::InsertObjectL(CMTPObjectMetaData& aObject)

	{

    OstTraceFunctionEntry0( CMTPOBJECTSTORE_INSERTOBJECTL_ENTRY );

	iCachedHandle = 0;

	iCachedSuidHash = 0;

	TBool needToInsert = EFalse;

	TBool needUpdateOwner = EFalse;

	TUint dpId(aObject.Uint(CMTPObjectMetaData::EDataProviderId));

	if ((aObject.DesC(CMTPObjectMetaData::ESuid)).Length() > KMaxFileName)

	{

	// The length of object uid should not excceeds KMaxFileName

	OstTrace0( TRACE_ERROR, DUP4_CMTPOBJECTSTORE_INSERTOBJECTL, "The length of object uid excceeds KMaxFileName" );

	User::Leave( KErrBadName );

	}

	TFileName suid;

	suid.CopyLC(aObject.DesC(CMTPObjectMetaData::ESuid));

	TUint32 suidHash = DefaultHash::Des16(suid);

	TUint32 parentHandle = aObject.Uint(CMTPObjectMetaData::EParentHandle);

	TUint32 handle = KMTPHandleNone, handleInDB = KMTPHandleAll;

	TInt64 id = 0;

	// Check if the dp is enumerating

	if (iSingletons.DpController().EnumerateState() != CMTPDataProviderController::EEnumeratedFulllyCompleted && iCacheExist)

		{

		//it is in the object enumeration phase. 

		// if it's see if we have an object with the same SUID

		//When the MTP server startup the object enumeration, it will fetch all of the object's (SUIDHash and Handles) into in-memory ordered array.

		//this function is to try to match the handleID for the incoming suidHash/SUID/DPID, if matched in memory, it will return the handleID

		//considering the possible conflicting of the SUID for different file name, it need to consult the SUID in the table for eactly match.

		//Therefore, for each object matching, it need one table lookup and file name cope and match operation.

		//If it matched, do nothing for the table, but remove it from the in-memory ordered array.

		//if there is no match, it is a new object, insert it into table.

		iSentinal->iObjSuiIdHash = suidHash;

		iSentinal->iSuidPtr.Set(aObject.DesC(CMTPObjectMetaData::ESuid));

		TInt found = iEnumeratingCacheObjList.FindInOrder(iSentinal, TLinearOrder<CEnumertingCacheItem>(CEnumertingCacheItem::Compare));

		if (KErrNotFound != found)

			{//There is a match

			if(NULL == iEnumeratingCacheObjList[found]->iSuid)

				{//need extra check for hash collision

				handleInDB = HandleL(aObject.DesC(CMTPObjectMetaData::ESuid));

				}

			handle = iEnumeratingCacheObjList[found]->iObjHandleId;

			if((handleInDB != KMTPHandleAll) && (handleInDB != handle)) //hash collision

				{

				needToInsert = ETrue;

				}

			else

				{

				aObject.SetUint(CMTPObjectMetaData::EHandle, handle);

				id = iEnumeratingCacheObjList[found]->iPOUID;

				aObject.SetUint(CMTPObjectMetaData::EIdentifier, id);

				if(iEnumeratingCacheObjList[found]->iFormatcode != aObject.Uint(CMTPObjectMetaData::EFormatCode) ||

					 iEnumeratingCacheObjList[found]->iObjParentId != aObject.Uint(CMTPObjectMetaData::EParentHandle))

					{//have different owner

					needUpdateOwner = ETrue;

					}

				delete iEnumeratingCacheObjList[found];

				iEnumeratingCacheObjList.Remove(found);

				}

			OstTrace0(TRACE_NORMAL, CMTPOBJECTSTORE_INSERTOBJECTL, "Found in Snapshot");

			}

		else

			{//This is a totally new object. insert it after check the db to prevent user wrong operation

			handle = HandleL(aObject.DesC(CMTPObjectMetaData::ESuid));

			if (handle == KMTPHandleNone)

				{

				needToInsert = ETrue;