// 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;
	}