// Copyright (c) 1998-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

// 

//

#include <s32file.h>

#include "SD_STD.H"

#include "Sd_DbList.h"

using namespace DBSC;

/*

CDbsSession class is updated now to with a support for DBMS security policies.

What idea sits behind the update:

1) DBMS server has a set of server side CDbsSession objects.

2) Each CDbsSession object has a list of CDbsSession::TEntry items.

   Each CDbsSession::TEntry item holds a server side DBMS object, which is

   used to perform client requests.

3) CDbsSession::TEntry object could be:

	- EDbsDatabase - database object. It operates at database level.

		OpenDatabaseL is the method, which creates it.

	- EDbsIncremental - incremental object. It operates either at database or table level.

		NewIncrementalL is the method, which creates it.

	- EDbsCursor - cursor object. It operates at table level.

		NewCursorL is the method, which creates it.

	- EDbsConstraint - constraint object. It is used at table level and needs the same

		security policy as its table.

	- EDbsStream - stream object. It operates either at database or table level.

		NewStreamL are the methods, which create it.

	- EDbsObserver - observer object. It operates at database level.

4) When DBMS server is used in a security environment, database/table security policies 

	describe allowed W/R operations for the database/tables.

5) Each database/table has a security policy object assiciated with it. It may be accessed

	using MPolicy interface.

6) There is a MPolicySpace interface, which holds a collection of MPolicy interfaces

	for the database/tables. MPolicy interfaces can be queried using MPolicySpace methods.

7) All DBMS server side objects, described in (3), operate at database/table level. In a

	security environment, the client's access rights has to be checked, before performing

	particular database/table operation.

	It is known at the moment of DBMS object creation, on which database/table it will operate.

	The database/table cannot be changed during the DBMS object life time.

	At the moment of DBMS object creation, the related database/table interface is queried and

	stored in CDbsSession::TEntry::iPolicy data member. 

	It is an error if CDbsSession::TEntry item exists without a security policy.

8) Every time, when a client needs particular DBMS server functionality and CDbsSession::ServiceL

	has been called, the session object will find which DBMS server object has to be used and

	asserts client's access rights against its security policy.

	If the client has not enough access rights to perform desired DBMS operation, the DBMS

	session will leave with KErrPermissionDenied error code.

	======================================================================================

	In one sentence - every time, when an object from CDbsSession::TEntry list is about to 

	perform particular operation at database/table level, the associated database/table 

	security policy will be checked and the opration may be rejected.

*/

// Class CDbsSession::TEntry

//

// release the object

//

void CDbsSession::TEntry::Release()

	{

	TDbsType t=Type();

	__ASSERT(t!=EDbsFree);

	if (t==EDbsObserver)

		delete STATIC_CAST(CDbsObserver::HObserver*,iObject);

	else if (t==EDbsStream)

		delete STATIC_CAST(HDbsStream*,iObject);

	else

		CDbObject::Destroy(STATIC_CAST(CDbObject*,iObject));

	iType=TUint8(EDbsFree);

	iPolicy = NULL;

	}

#ifdef __DBDUMP__

//Using CDbsSession::TEntry::Dump() method you can dump the TEntry's content

//into a stream. Note that the dump works only if you have __DBDUMP__ macro defined.

void CDbsSession::TEntry::Dump(RFile& aFile) const

	{

	_LIT8(KClassName, "CDbsSession::TEntry. this=%X");

	_LIT8(KType, "Type=%S");

	_LIT8(KMagic, "Magic=%d");

	_LIT8(KCrLf, "\r\n");

	_LIT8(KEnd, "====");

	TPtrC8 KDbsType[EDbsMaxType + 1] = {_L8("Free"), _L8("Database"), _L8("Incremental"), _L8("Cursor"), _L8("Constraint"), _L8("Stream"), _L8("Observer")};

	TBuf8<40> buf;

	buf.Format(KClassName, this);

	(void)aFile.Write(buf);

	(void)aFile.Write(KCrLf);

	buf.Format(KType, &KDbsType[iType]);

	(void)aFile.Write(buf);

	(void)aFile.Write(KCrLf);

	buf.Format(KMagic, iMagic);

	(void)aFile.Write(buf);

	(void)aFile.Write(KCrLf);

	__ASSERT(iPolicy);

	iPolicy->Dump(aFile);

	(void)aFile.Write(KEnd);

	(void)aFile.Write(KCrLf);

	}

#endif//__DBDUMP__

// Class CDbsSession

//

// Release all this clients resources

// Streams must be released before cursors, and everything before the connection

//

CDbsSession::~CDbsSession()

	{

	TEntry* const base=&iIx[0];

	if (base)

		{

		TInt type=EDbsMaxType;

		do	{

			for (TEntry* e=base+iSize;--e>=base;)

				{

				if (e->iType==type)

					e->Release();

				}

			} while (--type>EDbsFree);

		User::Free(base);

		}

	iDbPolicyRqColl.Close();

    delete iSessDriveSpace;

	Server().RemoveSession();

	}

/**

Overrides virtual CSession2::Create2().

Creates iSessDriveSpace instance.

*/

void CDbsSession::CreateL()

    {

    iSessDriveSpace = CDbsSessDriveSpace::NewL(Server().DriveSpaceCol());

    }

//

// provide for CSession

// If this leaves, we complete message through ServiceError(...)

//

void CDbsSession::ServiceL(const RMessage2& aMessage)

	{

	//set received message in server so it can be used in cleanup when server panics.

	CPolicyProxy& policyProxy = Server().PolicyProxy();

	TDbsFunction f=DbsFunction(aMessage.Function());

	if (f&KDbsObjectReturn)		// may return a derived object

		AllocL();	// ensure index space

	TInt r=0;//object handle

	TInt h=DbsHandle(aMessage.Function());

	if (h==KDbsSessionHandle)

		{	// session based requests

		switch (f&~KDbsObjectReturn)

			{

		case EDbsResourceMark:

			ResourceCountMarkStart();

			break;

		case EDbsResourceCheck:

			ResourceCountMarkEnd(aMessage);

			break;

		case EDbsResourceCount:

			r=CountResources();

			break;

		case EDbsSetHeapFailure:

			User::__DbgSetAllocFail(RHeap::EUser,RHeap::TAllocFail(aMessage.Int0()),aMessage.Int1());

			break;

		case EDbsOpenDatabase:

			r=OpenDatabaseL(aMessage);

			break;

		case EDbsReserveDriveSpace:

			ReserveDriveSpaceL(static_cast <TDriveNumber> (aMessage.Int0()));

			break;

        case EDbsFreeReservedSpace:

	        FreeReservedSpace(static_cast <TDriveNumber> (aMessage.Int0()));

			break;

		case EDbsReserveGetAccess:

			GetReserveAccessL(static_cast <TDriveNumber> (aMessage.Int0()));

			break;

		case EDbsReserveReleaseAccess:

			ReleaseReserveAccess(static_cast <TDriveNumber> (aMessage.Int0()));

			break;

		default:

			r=ExtServiceL(aMessage, static_cast <TDbsFunction> (f&~KDbsObjectReturn));

			break;

			}

		}

	else

		{	// object based requests

		TEntry& e=Object(h);

		__ASSERT(e.iPolicy);

		policyProxy.CheckL(aMessage, *e.iPolicy);

		TDbsFunction dbmsFuncNo = static_cast <TDbsFunction> (f & ~KDbsObjectReturn);

		switch (dbmsFuncNo)

			{

	// the common close function

		case EDbsClose:

			//If this is a database object, remove the related pair (handle, uid) from iDbPolicyRqColl collection.

			if(e.Type() == EDbsDatabase)

				{

				iDbPolicyRqColl.Remove(h);

				}

			Free(e);

			break;

	// database functions

		case EDbsDatabaseAuthenticate:

			{

            __LEAVE(KErrNotSupported);             

			}

			break;

		case EDbsDatabaseDestroy:

			r=e.Database().Destroy();

			break;

		case EDbsDatabaseBegin:

			r=e.Database().Begin();

			break;

		case EDbsDatabaseCommit:

			r=e.Database().Commit();

			break;

		case EDbsDatabaseRollback:

			e.Database().Rollback();

			break;

		case EDbsDatabaseProperty:

			r=e.Database().Property(CDbDatabase::TProperty(aMessage.Int0()));

			break;

		case EDbsDatabaseTables:

			{//The new stream object will have the same security policy as the database

			 //Read only stream

			CDbTableNames* names=CDbTableNames::NewLC();

			e.Database().TablesL(*names);

			r=NewStreamL(names,Externalizer(names),aMessage,e.iPolicy);

			}

			break;

		case EDbsDatabaseColumns:

			{//The new stream object will have the same security policy as the database

			 //Read only stream

			CDbColSet* set=CDbColSet::NewLC();

			e.Database().ColumnsL(*set,ReadName0L(0,aMessage));

			r=NewStreamL(set,Externalizer(set),aMessage,e.iPolicy);

			}

			break;

		case EDbsDatabaseIndexes:

			{//The new stream object will have the same security policy as the database

			 //Read only stream

			CDbIndexNames* names=CDbIndexNames::NewLC();

			e.Database().IndexesL(*names,ReadName0L(0,aMessage));

			r=NewStreamL(names,Externalizer(names),aMessage,e.iPolicy);

			}

			break;

		case EDbsDatabaseKeys:

			{//The new stream object will have the same security policy as the database

			 //Read only stream

			CDbKey* key=CDbKey::NewLC();

			e.Database().KeysL(*key,ReadName0L(0,aMessage),ReadName1L(1,aMessage));

			r=NewStreamL(key,Externalizer(key),aMessage,e.iPolicy);

			}

			break;

		case EDbsDatabaseCreateTable:

			{

			const TDesC& name=ReadName0L(0,aMessage);

			CDbColSet* set=ColSetLC(1,aMessage);

			CDbKey* primary=0;

			if (aMessage.Ptr2())

				primary=KeyLC(2,aMessage);

			e.Database().CreateTableL(name,*set,primary);

			if (primary)

				CleanupStack::PopAndDestroy();	// primary

			CleanupStack::PopAndDestroy();	// set

			}

			break;

		case EDbsDatabaseOpenObserver:

			//The new observer object will have the same security policy as the database

			r=Add(CDbsConnection::Source(e.Database()).ObserverL(),e.iPolicy);

			break;

		case EDbsDatabaseOpenUtility:

			{//The new incremental object will have the same security policy as the database

			TInt step;

			r=NewIncrementalL(e.Database().UtilityL(CDbDatabase::TUtility(aMessage.Int0()),step),step,aMessage,e.iPolicy);

			}

			break;

		case EDbsDatabaseOpenDropTable:

			{//The new incremental object will have the same security policy as the database

			TInt step;

			const TDesC& name=ReadName0L(0,aMessage);

			r=NewIncrementalL(e.Database().DropTableL(name,step),step,aMessage,e.iPolicy);

			}

			break;

		case EDbsDatabaseOpenAlterTable:

			{//The new incremental object will have the same security policy as the database

			TInt step;

			const TDesC& name=ReadName0L(0,aMessage);

			CDbColSet* set=ColSetLC(1,aMessage);

			r=NewIncrementalL(e.Database().AlterTableL(name,*set,step),step,aMessage,e.iPolicy);

			CleanupStack::PopAndDestroy();	// set

			}

			break;

		case EDbsDatabaseOpenCreateIndex:

			{//The new incremental object will have the same security policy as the database

			TInt step;

			const TDesC& name=ReadName0L(0,aMessage);

			const TDesC& table=ReadName1L(1,aMessage);

			CDbKey* key=KeyLC(2,aMessage);

			r=NewIncrementalL(e.Database().CreateIndexL(name,table,*key,step),step,aMessage,e.iPolicy);

			CleanupStack::PopAndDestroy();	// key

			}

			break;

		case EDbsDatabaseOpenDropIndex:

			{//The new incremental object will have the same security policy as the database

			TInt step;

			const TDesC& name=ReadName0L(0,aMessage);

			const TDesC& table=ReadName1L(1,aMessage);

			r=NewIncrementalL(e.Database().DropIndexL(name,table,step),step,aMessage,e.iPolicy);

			}

			break;

		case EDbsDatabaseExecute:

			{//The new incremental object will have the same security policy as the database or table - sql dependent.

			//In order EDbsDatabaseExecute request to be performed, the DBMS session has already

			//checked the client capabilities at the database level.

			//Now, the sql string will be parsed and the client capabilities will be checked

			//again at more specific database or table level.

			TInt init;

			HBufC* sql=ReadHBufLC(0,aMessage);

			const TDbPolicyRequest& rq = iDbPolicyRqColl[h];

			TPolicyType policyType = EPTNone;

			const MPolicy* policy = policyProxy.SqlPolicyL(rq, *sql, policyType);

			policyProxy.CheckL(policyType, aMessage, *policy);			

			r=NewIncrementalL(e.Database().ExecuteL(*sql,TDbTextComparison(aMessage.Int1()),init),init,aMessage,policy);

			CleanupStack::PopAndDestroy(sql);

			}

			break;

		case EDbsDatabasePrepareView:

			{//The new cursor object will have the same security policy as the table in the sql string.

			//In order EDbsDatabasePrepareView request to be performed, the DBMS session has already

			//checked the client capabilities at the database level.

			//Now, the sql string will be parsed and the client capabilities will be checked

			//again at table level.

			HBufC* sql=ReadHBufLC(0,aMessage);

			const TDbPolicyRequest& rq = iDbPolicyRqColl[h];

			TPolicyType policyType = EPTNone;

			const MPolicy* policy = policyProxy.SqlPolicyL(rq, *sql, policyType);

			policyProxy.CheckL(policyType, aMessage, *policy);			

			TPckgBuf<TDbWindow> window;

			aMessage.ReadL(2,window);

			TInt mode=aMessage.Int1();

			CDbCursor* cursor=e.Database().ViewL(TDbQuery(*sql,TDbTextComparison(mode&0xff)),window(),RDbRowSet::TAccess(mode>>8));

			r=NewCursorL(cursor,aMessage,policy);

			CleanupStack::PopAndDestroy(sql);

			}

			break;

		case EDbsDatabaseOpenTable:

			{//The new cursor object will have the same security policy as the table

			const TDesC& name=ReadName0L(0,aMessage);

			const TDbPolicyRequest& rq = iDbPolicyRqColl[h];

			const MPolicy* policy = policyProxy.TblPolicyL(rq, name);

			//Check caller capabilities against the table policy

			RDbRowSet::TAccess accessType = static_cast <RDbRowSet::TAccess> (aMessage.Int1());

			TPolicyType policyType = accessType == RDbRowSet::EReadOnly ? EPTRead : EPTWrite;

			policyProxy.CheckL(policyType, aMessage, *policy);

			//Create cursor

			r=NewCursorL(e.Database().TableL(name,accessType),aMessage,policy);

			}

			break;

	// Incremental functions

		case EDbsIncrementalNext:

			{

			TPckgBuf<TInt> step=aMessage.Int0();

			r=e.Incremental().NextL(step());

			aMessage.WriteL(1,step);

			}

			break;

	// Observer functions

		case EDbsObserverNotify:

			e.Observer().Notify(aMessage);

			return;		// deferred completion of the message!

		case EDbsObserverCancel:

			e.Observer().Cancel();

			break;

	// cursor functions

		case EDbsCursorColumnTypes:

			{

			TInt count=e.Cursor().ColumnCount();

			TUint8* types=(TUint8*)User::AllocLC(count);

			for (TInt ii=count;--ii>=0;)

				types[ii]=TUint8(e.Cursor().ColumnType(ii+1));

			aMessage.WriteL(3,TPtrC8(types,count));

			CleanupStack::PopAndDestroy();

			}

			break;

		case EDbsCursorReset:

			e.Cursor().Reset();

			break;

		case EDbsCursorEvaluate:

			r=e.Cursor().EvaluateL()?1:0;

			break;

		case EDbsCursorUnevaluated:

			r=e.Cursor().Unevaluated()?1:0;

			break;

		case EDbsCursorSetIndex:

			{

			const TDesC* name=0;

			if (aMessage.Ptr0())

				name=&ReadName0L(0,aMessage);

			e.Cursor().SetIndexL(name);

			}

			break;

		case EDbsCursorSeek:

			{

			TDbLookupKey* key=LookupKeyLC(0,aMessage.Int1(),aMessage);

			r=e.Cursor().SeekL(*key,RDbTable::TComparison(aMessage.Int2()))?1:0;

			CleanupStack::PopAndDestroy();		// key;

			}

			break;

		case EDbsCursorAtBeginning:

			r=e.Cursor().AtBeginning()?1:0;

			break;

		case EDbsCursorAtEnd:

			r=e.Cursor().AtEnd()?1:0;

			break;

		case EDbsCursorAtRow:

			r=e.Cursor().AtRow()?1:0;

			break;

		case EDbsCursorCount:

			r=e.Cursor().CountL(RDbRowSet::TAccuracy(aMessage.Int0()))+1;

			break;

		case EDbsCursorGotoPos:

			if (e.Cursor().GotoL(RDbRowSet::TPosition(aMessage.Int0())))

				{

				e.Cursor().GetL();

				r=RetrieveRowL(e.Cursor(),aMessage);

				}

			break;

		case EDbsCursorBookmark:

			{

			TPckgBuf<TDbBookmark::TMark> mark;

			e.Cursor().Bookmark(mark());

			aMessage.WriteL(3,mark);

			}

			break;

		case EDbsCursorGotoBookmark:

			{

			TPckgBuf<TDbBookmark::TMark> mark;

			aMessage.ReadL(0,mark);

			e.Cursor().GotoL(mark());

			}

			break;

		case EDbsCursorGet:

			e.Cursor().GetL();

			r=RetrieveRowL(e.Cursor(),aMessage);

			break;

		case EDbsCursorInsert:

			e.Cursor().InsertL(CDbCursor::TInsert(aMessage.Int0()));

			r=RetrieveRowL(e.Cursor(),aMessage);

			break;

		case EDbsCursorUpdate:

			e.Cursor().UpdateL();

			r=RetrieveRowL(e.Cursor(),aMessage);

			break;

		case EDbsCursorRetrieveRow:	// pass the row buffer back to the client

			r=RetrieveRowL(e.Cursor(),aMessage);

			break;

		case EDbsCursorCancel:

			e.Cursor().Cancel();

			break;

		case EDbsCursorPut:

			PutRowL(e.Cursor(),aMessage);

			e.Cursor().PutL();

			break;

		case EDbsCursorDelete:

			e.Cursor().DeleteL();

			break;

		case EDbsCursorColumns:

			{// reduce memory usage by extracting and stream columns individually

			 //Read only stream

			RWriteStream strm(HBufBuf::NewLC());

			TInt count=e.Cursor().ColumnCount();

			strm.WriteInt32L(count);

			TDbCol col;

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

				{

				e.Cursor().ColumnDef(col,ii);

				strm<<col;

				}

			strm.CommitL();

			TInt ext=strm.Sink()->SizeL();

			CleanupStack::Pop();			// stream

			r=NewStreamL(strm.Sink(),aMessage,e.iPolicy,ext);

			}

			break;

		case EDbsCursorColumnDef:

			{

			TPckgBuf<TDbCol> col;

			e.Cursor().ColumnDef(col(),aMessage.Int0());

			aMessage.WriteL(3,col);

			}

			break;

		case EDbsCursorSetNull:

			__ASSERT(TDbCol::IsLong(e.Cursor().ColumnType(aMessage.Int0())));

			e.Cursor().SetNullL(aMessage.Int0());

			break;

		case EDbsCursorColumnSize:

			__ASSERT(TDbCol::IsLong(e.Cursor().ColumnType(aMessage.Int0())));

			r=e.Cursor().ColumnSize(aMessage.Int0());

			break;

		case EDbsCursorColumnSource:

			__ASSERT(TDbCol::IsLong(e.Cursor().ColumnType(aMessage.Int0())));

			{//The new stream object will have the same security policy as the table

			 //Read only stream, used for large BLOB fields.

			TDbColNo col=aMessage.Int0();

			CDbCursor& cursor=e.Cursor();

			r=NewStreamL(cursor.ColumnSourceL(col),aMessage,e.iPolicy,cursor.ColumnSize(col));

			}

			break;

		case EDbsCursorColumnSink:

			//The new stream object will have the same security policy as the table

			//Write stream, used for large BLOB fields.