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

 // DBMS server-session and support classes - "DBMS security" related - full support

 // 

 //

 #include <s32file.h>

 #include "D32Strings.h"

 #include "SD_STD.H"

 #include "Sd_DbList.h"

 using namespace DBSC;

 CDbsSession::CDbsSession() :

 	iDbPolicyRqColl(TLinearOrder< TPair<TInt, TDbPolicyRequest> > (&Compare<TInt, TDbPolicyRequest>))

 	{

 	}

 /**

 New "DBMS security" related messages processed here!

 @param aMessage DBMS server message

 @param aDbsFunction DBMS server function code

 @return An error code (< 0) or a DBMS server session object handle (EDbsDatabase, EDbsIncremental,...).

 */

 TInt CDbsSession::ExtServiceL(const RMessage2& aMessage, TDbsFunction aDbsFunction)

 	{

 	TInt handle = 0;

 	switch(aDbsFunction)

 		{

 	case EDbsCreateDatabase:

 		handle=CreateDatabaseL(aMessage);

 		break;

 	case EDbsDatabaseList:

 		handle=GetDatabaseListL(aMessage);

 		break;

 	case EDbsCopyDatabase:

 		CopyDatabaseL(aMessage);

 		break;

 	case EDbsDeleteDatabase:

 		DeleteDatabaseL(aMessage);

 		break;

 	case EDbsGetSecurityPolicy:

 		GetSecurityPolicyL(aMessage);

 		break;

 	case EDbsGetBackupPath:

 		GetBackupPathL(aMessage);

 		break;

 	case EDbsGetBackupPaths:

 		handle=GetBackupPathsL(aMessage);

 		break;

 	default:

 		handle = KErrNotSupported;

 		break;

 		}

 	return handle;

 	}

 /**

 Extracts aMessage's "aIndex" argument (which is expected to be a file name) and

 stores it to CDbsServer::iFileName data member.

 @param aIndex The index of RMessage parameter

 @param aMessage

 @return A descriptor of the file name,extracted from aMessage and stored in CDbsServer::iFileName.

 */

 const TDesC& CDbsSession::ReadFileNameL(TInt aIndex, const RMessage2& aMessage)

 	{

 	TDes& name = Server().FileName();

 	aMessage.ReadL(aIndex, name);

 	return name;

 	}

 /**

 Extracts database name (aMessage's arg 0) and database format string (aMessage's arg 1)

 and use them to extract database properties, such as: database UID, access type (secure/non-secure),

 full database file path, database format string, drive number.

 @return A pointer to a TDbProps object, which contains some properties, extracted from the database name.

 */

 TDbProps* CDbsSession::ExtractDbPropsLC(const RMessage2& aMessage)

 	{

 	const TDesC& dbName = ReadFileNameL(0, aMessage);

 	const TDesC& dbFormat = ReadName0L(1, aMessage);

 	return Server().DbPropsFactory().ExtractLC(dbName, dbFormat);

 	}

 /**

 This method creates new EDbsDatabase type object.

 The related MPolicy interface will be retrieved and

 put together with the EDbsDatabase object in TEntry list.

 The initial contact for a database. Open a database source

 return the database handle for the client

 */

 TInt CDbsSession::OpenDatabaseL(const RMessage2& aMessage)

 	{

 	TDbProps* dbProps = ExtractDbPropsLC(aMessage);

 	const MPolicy* policy = Server().PolicyProxy().DbPolicyL(dbProps->iDbPolicyRequest);

 	Server().PolicyProxy().CheckL(aMessage, *policy);

 	TInt dbHandle = DoOpenDatabaseL(aMessage, *dbProps);

 	CleanupStack::PopAndDestroy(dbProps);

 	return dbHandle;

 	}

 /**

 SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version of the method.

 Opens a database. It is used by both: OpenDatabase() and CreateDatabase() methods.

 @param aMessage DBMS server message:EDbsCreateDatabase or EDbsOpenDatabase.

 @param aDbProps A TDbProps object created from the database name and format string.

 @return A handle to the opened/created database object.

 @leave One of the system-wide error codes.

 */

 TInt CDbsSession::DoOpenDatabaseL(const RMessage2& aMessage, const TDbProps& aDbProps)

 	{

 	CDbsConnection* dbConnection = Sources().OpenLC(Server().Fs(), aDbProps.iPath, aDbProps.iFormatStr);

 	CDbObject* dbObj = DoAuthenticateL(dbConnection, aMessage);

 	dbConnection->Attach(dbObj);

 	CleanupStack::Pop(dbConnection);

 	//dbObj does not have to be pushed in the cleanup stack!

 	//NewDbEntryL() will take care of its destruction, if the database entry cannot be created.

 	//NewDbEntryL() will destroy the connection also in this case.

 	TInt dbHandle = 0;

 	NewDbEntryL(dbObj, aDbProps.iDbPolicyRequest, dbHandle);

 	return dbHandle;

 	}

 //SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version of the method.

 //Authenticates a database.

 CDbObject* CDbsSession::DoAuthenticateL(CDbsConnection* aDbsConnection, const RMessage2&)

 	{

 	__ASSERT(aDbsConnection);

 	CDbSource& src = aDbsConnection->Source().Source();

 	return src.AuthenticateL();

 	}

 //Adds a new database entry to the session list of database session objects.

 void CDbsSession::NewDbEntryL(CDbObject* aDbObject, const TDbPolicyRequest& aDbPolicyRequest, TInt& aDbHandle)

 	{

 	__ASSERT(aDbObject);

 	const MPolicy* policy = Server().PolicyProxy().DbPolicyL(aDbPolicyRequest);

 	aDbHandle = DoAdd(aDbObject, EDbsDatabase, policy);

 	//Store the database uid for later use

 	TInt err = iDbPolicyRqColl.Insert(aDbHandle, aDbPolicyRequest);

 	if(err != KErrNone)

 		{//If iDbPolicyRqColl.Insert() fails, then remove the object from TEntry list and then return.

 		TEntry& e = Object(aDbHandle);

 		Free(e);

 		User::Leave(err);

 		}

 	}

 /**

 Converts RDbs::TPolicyType parameter value to the internally used DBSC::TPolicyType value.

 @param aPolicyType Security policy type - client side

 @return Security policy type used on the server side.

 @leave KErrArgument if it is an invalid security policy type

 */

 static TPolicyType ConvertPolicyTypeL(RDbs::TPolicyType aPolicyType)

 	{

 	TPolicyType policyType = static_cast <TPolicyType> (1 << aPolicyType);

 	if(policyType > EPTLast || policyType <= EPTNone)

 		{

 		__LEAVE(KErrArgument);

 		}

 	return policyType;

 	}

 /**

 Creates secure shared database.

 @param aMessage DBMS server message: EDbsCreateDatabase.

 @return A handle to the created database object.

 @leave One of the system-wide error codes, including:

        KErrNotSupported An attempt to create non-secure shared database

 	   KErrAlreadyExists The database with the supplied name already exists

 */

 TInt CDbsSession::CreateDatabaseL(const RMessage2& aMessage)

 	{

 	TDbProps* dbProps = ExtractDbPropsLC(aMessage);

 	if(dbProps->iDbPolicyRequest.iAccessType == EATNonSecure)

 		{//This method works only for secure shared databases

 		__LEAVE(KErrNotSupported);

 		}

 	const MPolicy* policy = Server().PolicyProxy().DbPolicyL(dbProps->iDbPolicyRequest);

 	Server().PolicyProxy().CheckL(aMessage, *policy);

 	//Leave if the file is already there

 	::TEntry fileEntry;

 	TBool dbFileExist = Server().Fs().Entry(dbProps->iPath, fileEntry) == KErrNone;

 	if(dbFileExist)

 		{

 		__LEAVE(KErrAlreadyExists);

 		}

 	TInt dbHandle = 0;

 	TRAPD(err, dbHandle = DoCreateDatabaseL(aMessage, *dbProps));

 	if(err != KErrNone)

 		{//Cleanup if the creation fails

 		// Although the file delete below could return at error since we are

 		// already on an error-path a design decision has been made to ignore the

 		// error in favor of the one returned by DoCreateDatabaseL()

 		// If a debug build - record error

 		TInt fileDeleteErr = Server().Fs().Delete(dbProps->iPath);

 		#ifdef _DEBUG

 			if (fileDeleteErr != KErrNone)

 			{

 				RDebug::Print(_L("CDbsSession::CreateDatabaseL - Failed to delete file. Error = %d"), fileDeleteErr);

 			}

 		#endif

 		__LEAVE(err);

 		}

 	CleanupStack::PopAndDestroy(dbProps);

 	return dbHandle;

 	}

 //Creates secure shared database.

 //Originaly, the database were always created on the client side, using ::CreateDatabaseL() call.

 //I am not very sure how this function works and prefer to call ::CreateDatabaseL() to create

 //the database on the server side, then delete it and the open it in the same way, as it 

 //worked before for opening/sharing databases on the server side.

 TInt CDbsSession::DoCreateDatabaseL(const RMessage2& aMessage, const TDbProps& aDbProps)

 	{

 	CDbDatabase* db = ::CreateDatabaseL(TDbFormat::ECreate, Server().Fs(), aDbProps.iPath, aDbProps.iFormatStr);

 	delete db;

 	TInt dbHandle = DoOpenDatabaseL(aMessage, aDbProps);

 	return dbHandle;

 	}

 /**

 Copies an existing secure shared database to a new database.

 The new database will have the same security policy as the old one.

 @param aMessage DBMS server message (EDbsCopyDatabase)

 @leave One of the system-wide error codes, including KErrArgument - a null uid supplied

        as an argument.

 */

 void CDbsSession::CopyDatabaseL(const RMessage2& aMessage)

 	{

 	RDbPropsFactory& dbPropsFactory = Server().DbPropsFactory();

 	TUid uid;

 	uid.iUid = aMessage.Int2();

 	if(uid == KNullUid)

 		{

 		__LEAVE(KErrArgument);

 		}

 	//Do not change the order, because ReadFileNameL() uses the same place to store the names.

 	const TDesC& srcDbName = ReadFileNameL(0, aMessage);

 	TDbProps* srcDbProps = dbPropsFactory.ExtractLC(srcDbName, uid);

 	const TDesC& destDbName = ReadFileNameL(1, aMessage);

 	TDbProps* destDbProps = dbPropsFactory.ExtractLC(destDbName, uid);

 	const MPolicy* policy = Server().PolicyProxy().DbPolicyL(srcDbProps->iDbPolicyRequest);

 	Server().PolicyProxy().CheckL(aMessage, *policy);

 	CFileMan* fileMan = CFileMan::NewL(Server().Fs());

 	CleanupStack::PushL(fileMan);

 	__LEAVE_IF_ERROR(fileMan->Copy(srcDbProps->iPath, destDbProps->iPath, 0));

 	//"Copy" operation executed without errors. Now it is a time to turn off the read-only

 	//flag of the target file (which may be on if the source files is on a read-only drive)

 	__LEAVE_IF_ERROR(Server().Fs().SetAtt(destDbProps->iPath, 0, KEntryAttReadOnly));

 	CleanupStack::PopAndDestroy(3);//srcDbProps, destDbProps, fileMan

 	}

 /**

 Deletes secure shared database

 @param aMessage DBMS server message (EDbsDeleteDatabase)

 @leave One of the system-wide error codes, including KErrArgument - a null uid supplied

        as an argument.

 */

 void CDbsSession::DeleteDatabaseL(const RMessage2& aMessage)

 	{

 	TUid uid;

 	uid.iUid = aMessage.Int1();

 	if(uid == KNullUid)

 		{

 		__LEAVE(KErrArgument);

 		}

 	const TDesC& dbName = ReadFileNameL(0, aMessage);

 	TDbProps* dbProps = Server().DbPropsFactory().ExtractLC(dbName, uid);

 	const MPolicy* policy = Server().PolicyProxy().DbPolicyL(dbProps->iDbPolicyRequest);

 	Server().PolicyProxy().CheckL(aMessage, *policy);

 	__LEAVE_IF_ERROR(Server().Fs().Delete(dbProps->iPath));

 	CleanupStack::PopAndDestroy(dbProps);

 	}

 /**

 Gets the list of names of datatbases, which have the same uid.

 @param aMessage DBMS server message (EDbsDatabaseList)

 @return A stream handle to a stream with the database names found.

 @leave One of the system-wide error codes, including KErrArgument - a null uid supplied

        as an argument.

 */

 TInt CDbsSession::GetDatabaseListL(const RMessage2& aMessage)

 	{

 	CDbNamesFactory* dbNamesFactory = CDbNamesFactory::NewLC();

 	TDriveNumber driveNumber;

 	TDbPolicyRequest dbPolicyRequest;

 	CDbNamesFactory::ExtractArgs(aMessage, driveNumber, dbPolicyRequest);

 	if(dbPolicyRequest.iUid == KNullUid)

 		{

 		__LEAVE(KErrArgument);

 		}

 	const MPolicy* policy = Server().PolicyProxy().DbPolicyL(dbPolicyRequest);

 	Server().PolicyProxy().CheckL(aMessage, *policy);

 	CDbDatabaseNames* dbNames = dbNamesFactory->DbNamesLC(driveNumber, dbPolicyRequest, Server().DbPropsFactory(), Server().Fs());

 	//NewStreamL() will take care about destroying dbNames.

 	TInt streamHandle = NewStreamL(dbNames, Externalizer(dbNames), aMessage, policy);

 	CleanupStack::PopAndDestroy(dbNamesFactory);

 	return streamHandle;

 	}

 /**

 Gets database/table security policy.

 @param aMessage DBMS server message (EDbsGetSecurityPolicy)

 @leave One of the system-wide error codes, including KErrArgument - a null uid supplied

        as an argument.

 */

 void CDbsSession::GetSecurityPolicyL(const RMessage2& aMessage)

 	{

 	//No security policy check.

 	TUid dbUid = TUid::Uid(aMessage.Int0());

 	if(dbUid == KNullUid)

 		{

 		__LEAVE(KErrArgument);

 		}

 	TPolicyType policyTypeRq = ::ConvertPolicyTypeL(static_cast <RDbs::TPolicyType> (aMessage.Int1() & ~KTablePolicyMaskBit));

 	TBool tblPolicyRq = aMessage.Int1() & KTablePolicyMaskBit;

 	if(tblPolicyRq)

 		{

 		ReadName0L(2, aMessage);

 		if(Server().Name0() == KNullDesC)

 			{

 			__LEAVE(KErrArgument);

 			}

 		}

 	TDbPolicyRequest dbPolicyRequest;

 	dbPolicyRequest.iUid = dbUid;

 	dbPolicyRequest.iAccessType = EATSecure;

 	const MPolicy* policy = tblPolicyRq ? Server().PolicyProxy().TblPolicyL(dbPolicyRequest, Server().Name0()) : 

 										  Server().PolicyProxy().DbPolicyL(dbPolicyRequest);

 	__ASSERT(policy);

 	TSecurityPolicy secPolicy;

 	__LEAVE_IF_ERROR(policy->Get(policyTypeRq, secPolicy));

 	aMessage.WriteL(3, secPolicy.Package());

 	}

 /**

 The function extracts backup&restore process SID from aMessage argument (parameter 0).

 @param aMessage DBMS server message - EDbsGetBackupPath or EDbsGetBackupPaths.

 @return Backup&restore process SID

 @leave KErrArgument 0 or ECapability_None backup&restore process SID

 @internalComponent

 */

 static TSecureId BackupSIDL(const RMessage2& aMessage)

 	{

 	TSecureId backupSID = TSecureId(aMessage.Int0());

 	if(backupSID.iId == 0 || backupSID.iId == (TUint32)ECapability_None)

 		{

 		__LEAVE(KErrArgument);

 		}

 	return backupSID;

 	}

 /**

 The function extracts database security policy UID from aMessage argument (parameter 1).

 @param aMessage DBMS server message - EDbsGetBackupPath or EDbsGetBackupPaths.

 @return Database security policy UID

 @leave KErrArgument Null database security policy UID

 @internalComponent

 */

 static TUid SecurityPolicyUidL(const RMessage2& aMessage)

 	{

 	TUid dbUid = TUid::Uid(aMessage.Int1());

 	if(dbUid == KNullUid)

 		{

 		__LEAVE(KErrArgument);

 		}

 	return dbUid;		

 	}

 /**

 The function gets the backup&restore process SID from the related database security policy,

 identified by aDbUid argument.

 @param aPolicyProxy A reference to CPolicyProxy object, which might be asked for particular 

                     database or table policy.

 @param aBackupSID Backup&restore process SID, extracted from RMessage2 object.

 @param aDbUid Database security policy UID, extracted from RMessage2 object.

 @return Backup&restore process SID, which is part of the database security policy.

 @leave KErrPermissionDenied - the supplied process SID does not match the database backup&

 						restore SID or the database backup&restore SID is 0 or ECapability_None. 

 @internalComponent

 */

 static TSecureId RegisteredBackupSIDL(CPolicyProxy& aPolicyProxy, TSecureId aBackupSID, TUid aDbUid)

 	{

 	TSecureId regBackupSID = aPolicyProxy.BackupSIDL(aDbUid);

 	if((regBackupSID == 0 || regBackupSID == (TUint32)ECapability_None) || aBackupSID != regBackupSID)

 		{

 		__LEAVE(KErrPermissionDenied);

 		}

 	return regBackupSID;

 	}

 /**

 The method will return via aMessage argument the full path to the secure shared database, 

 which name is packed in aMessage argument too.

 @param aMessage DBMS server message (EDbsGetBackupPath)

 @leave One of the system-wide error codes, including:

 		- KErrArgument - 0 or ECapability_None process SID, null UID, 

 						 null or invalid database name,

 						 the database is not secure shared database;

 		- KErrNotFound - the database file does not exist;

 		- KErrPermissionDenied - the supplied process SID does not match the database backup&

 						 restore SID or the database backup&restore SID is 0 or ECapability_None. 

 @deprecated

 */

 void CDbsSession::GetBackupPathL(const RMessage2& aMessage)

 	{

 	//Backup&restore process SID

 	TSecureId backupSID = ::BackupSIDL(aMessage);

 	//Security policy UID

 	TUid dbUid = ::SecurityPolicyUidL(aMessage);

 	//Database name and drive, format: <drive>:<name>.<ext>

 	ReadName0L(2, aMessage);

 	if(Server().Name0() == KNullDesC)

 		{

 		__LEAVE(KErrArgument);

 		}

 	//Database path

 	RDbPropsFactory& dbPropsFactory = Server().DbPropsFactory();

 	TDbProps* dbProps = dbPropsFactory.ExtractLC(Server().Name0(), dbUid);

 	if(dbProps->iDbPolicyRequest.iAccessType != EATSecure)

 		{

 		__LEAVE(KErrArgument);

 		}

 	//Check if the database file exists

 	::TEntry fileEntry;

 	TBool dbFileExist = Server().Fs().Entry(dbProps->iPath, fileEntry) == KErrNone;

 	if(!dbFileExist)

 		{

 		__LEAVE(KErrNotFound);

 		}

 	//Get and check backup&restore SID 

 	TSecureId regBackupSID = ::RegisteredBackupSIDL(Server().PolicyProxy(), backupSID, dbUid);

     //

 	aMessage.WriteL(3, dbProps->iPath);

 	//

 	CleanupStack::PopAndDestroy(dbProps);

 	}

 /**

 This function processes "aFileEntries" array, which is a result of TFindFile::FindWildByDir()

 or TFindFile::FindWild() calls. In a loop the function will get an element from "aFileEntries" 

 array, copy it to a temporary string adding the drive and the path, and will add that string

 to "aDatabasePaths" array.

 Note: If the created full file path length is bigger than KDbMaxStrLen characters, then the 

 	  string will not be added to "aDatabasePaths" array!

 @param aFileEntries An array of file names, result of TFindFile::FindWildByDir() or 

 					TFindFile::FindWild() calls.

 @param aFileSpec	A string, containing the drive and the directory of the file names in

 					aFileEntries array.

 @param aDatabasePaths  Output argument. Each file name from aFileEntries array will be "decorated"

 					with the drive and path and then the created new string will be added to 

 					aDatabasePaths array.

 @leave One of the system-wide error codes, including KErrNoMemory.

 @internalComponent

 */

 static void ProcessFileEntriesL(CDir& aFileEntries, const TDesC& aFileSpec, 

 								CDbStrings& aDatabasePaths)

 	{

 	TParse parse;

 	__LEAVE_IF_ERROR(parse.Set(aFileSpec, NULL, NULL));

 	TInt cnt = aFileEntries.Count();

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

 		{

 		TFileName fileName;

 		fileName.Copy(parse.DriveAndPath());

 		const ::TEntry& entry = aFileEntries[i];

 		fileName.Append(entry.iName);

 		if(fileName.Length() < KDbMaxStrLen)

 			{

 	    	aDatabasePaths.AddL(fileName);

 			}

 		}

 	}

 /**

 Gets a list of paths of the databases, which have the same security policy uid.

 @param aMessage DBMS server message (EDbsGetBackupPaths)

 @return A stream handle to a stream with the database names found.

 @leave One of the system-wide error codes, including:

 		- KErrArgument - 0 or ECapability_None process SID, null database security policy UID;

 		- KErrPermissionDenied - the supplied process SID does not match databases backup&

 						 restore SID or databases backup&restore SID is 0 or ECapability_None. 

 */

 TInt CDbsSession::GetBackupPathsL(const RMessage2& aMessage)

 	{

 	//Backup&restore process SID

 	TSecureId backupSID = ::BackupSIDL(aMessage);

 	//Security policy UID

 	TUid dbUid = ::SecurityPolicyUidL(aMessage);

 	//Get and check backup&restore SID 

 	TSecureId regBackupSID = ::RegisteredBackupSIDL(Server().PolicyProxy(), backupSID, dbUid);

 	//Get the related database security policy

 	TDbPolicyRequest dbPolicyRequest = {dbUid, EATSecure};

 	const MPolicy* policy = Server().PolicyProxy().DbPolicyL(dbPolicyRequest);

 	//

 	CDbStrings* dbPaths = CDbStrings::NewLC();

 	//DBMS server - private data path. CDbServer::iFileName used as a storage for the path.

 	__LEAVE_IF_ERROR(Server().Fs().PrivatePath(Server().FileName()));

 	//Construct search pattern. CDbServer::iName1 used as a storage for the search pattern.

 	RDbPropsFactory::ConstructCommonPart(dbUid, Server().Name1());

 	Server().Name1().Append('*');

 	//Search....

 	TFindFile findFile(Server().Fs());

 	CDir* fileEntries = NULL;

 	TInt err = findFile.FindWildByDir(Server().Name1(), Server().FileName(), fileEntries);

 	if(err == KErrNone)

 		{

 		do

 			{

 			__ASSERT(fileEntries);

 			CleanupStack::PushL(fileEntries);

 			::ProcessFileEntriesL(*fileEntries, findFile.File(), *dbPaths);

 			CleanupStack::PopAndDestroy(fileEntries);

 			fileEntries = NULL;

 			} while(findFile.FindWild(fileEntries) == KErrNone);

 		}

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

 		{

 		__LEAVE(err);

 		}

 	//NewStreamL() will take care about destroying dbPaths.

 	TInt streamHandle = NewStreamL(dbPaths, Externalizer(dbPaths), aMessage, policy);

 	return streamHandle;

 	}