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

 			r=NewStreamL(e.Cursor().ColumnSinkL(aMessage.Int0()),aMessage,e.iPolicy);

 			break;

 		case EDbsCursorOpenConstraint:

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

 			HBufC* sql=ReadHBufLC(0,aMessage);

 			CDbRowConstraint* ct=e.Cursor().ConstraintL(TDbQuery(*sql,TDbTextComparison(aMessage.Int1())));

 			CleanupStack::PopAndDestroy();	//sql

 			r=Add(ct, e.iPolicy);

 			}

 			break;

 		case EDbsCursorMatch:

 			r=e.Cursor().MatchL(Object(aMessage.Int0()).Constraint())?1:0;

 			break;

 		case EDbsCursorFind:

 			{

 			HBufC* sql=ReadHBufLC(0,aMessage);

 			TDbQuery q(*sql,TDbTextComparison(aMessage.Int1()));

 			r=e.Cursor().FindL(RDbRowSet::TDirection(aMessage.Int2()),q)-KErrNotFound;

 			CleanupStack::PopAndDestroy();	//sql

 			}

 			break;

 			// stream functions

 		case EDbsStreamRead:

 			{

 			r=e.Stream().ReadL(aMessage);

 			}

 			break;

 		case EDbsStreamWrite:

 			{

 			e.Stream().WriteL(aMessage);

 			}

 			break;

 		case EDbsStreamSize:

 			{

 			r=e.Stream().SizeL();

 			}

 			break;

 		case EDbsStreamSynch:

 			{

 			e.Stream().SynchL();

 			}

 			break;

 	// we don't know about any other functions

 		default:

 			r=KErrNotSupported;

 			break;

 			}

 		}

 	// don't complete message if we have paniced client, just reset variable;

 	if (!aMessage.IsNull())

 		aMessage.Complete(r);

 	}

 // Handle an error from CDbsSession::ServiceL()

 // A bad descriptor error implies a badly programmed client, so panic it;

 // otherwise use the default handling (report the error to the client)

 void CDbsSession::ServiceError(const RMessage2& aMessage,TInt aError)

  	{

 #ifdef __DBDUMP__

 	Dump();

 #endif//__DBDUMP__

  	if (aError==KErrBadDescriptor)

  		{

  		// this completes message as well so we have to handle it in

  		// ServiceL

  		_LIT(KCategory,"DBMS-server");

  		Server().Panic(KCategory,EDbsBadDescriptor);

  		}

  	CSession2::ServiceError(aMessage,aError);

    	}

 // Read aPtr as a name

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

 	{

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

 	aMessage.ReadL(aIndex,name);

 	return name;

 	}

 // Read Ptr1 as a name

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

 	{

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

 	aMessage.ReadL(aIndex,name);

 	return name;

 	}

 // Reads aPtr as a variable length 8-bit descriptor

 HBufC8* CDbsSession::ReadHBuf8LC(TInt aIndex,const RMessage2& aMessage)

 	{

 	TInt len= aMessage.GetDesLengthL(aIndex);

 	HBufC8* buf=HBufC8::NewLC(len);

 	TPtr8 read(buf->Des());

 	aMessage.ReadL(aIndex,read);

 	return buf;

 	}

 // Reads aPtr as a variable length build-width descriptor

 HBufC* CDbsSession::ReadHBufLC(TInt aIndex,const RMessage2& aMessage)

 	{

 	TInt len= aMessage.GetDesLengthL(aIndex);

 	HBufC* buf=HBufC::NewLC(len);

 	TPtr read(buf->Des());

 	aMessage.ReadL(aIndex,read);

 	return buf;

 	}

 // Pulls a column set from the client

 CDbColSet* CDbsSession::ColSetLC(TInt aIndex,const RMessage2& aMessage)

 	{

 	CDbColSet* set=CDbColSet::NewLC();

 	HBufC8* data=ReadHBuf8LC(aIndex,aMessage);

 	RDesReadStream strm(*data);

 	strm>>*set;

 	CleanupStack::PopAndDestroy();	// data

 	return set;

 	}

 // Pulls a key from the client

 CDbKey* CDbsSession::KeyLC(TInt aIndex,const RMessage2& aMessage)

 	{

 	CDbKey* key=CDbKey::NewLC();

 	HBufC8* data=ReadHBuf8LC(aIndex,aMessage);

 	RDesReadStream strm(*data);

 	strm>>*key;

 	CleanupStack::PopAndDestroy();	// data

 	return key;

 	}

 // Reconstructs a TDbLookupKey from the message parameter

 TDbLookupKey* CDbsSession::LookupKeyLC(TInt aIndex,TInt aSize,const RMessage2& aMessage)

 	{

 	TDbLookupKey* key=(TDbLookupKey*)User::AllocLC(aSize);

 	TPtr8 pckg((TUint8*)key,aSize);

 	aMessage.ReadL(aIndex,pckg); 

 	TDbLookupKey::SColumn* iter=CONST_CAST(TDbLookupKey::SColumn*,key->First());

 	const TDbLookupKey::SColumn* end=iter+key->Count();

 	if ((TUint8*)end-(TUint8*)key<aSize)

 		{	// there is some text data following...

 		do

 			{

 			switch (iter->iType)

 				{

 			default:

 				break;

 			case EDbColText8:

 				iter->iDes8.iPtr=(TUint8*)key+TInt(iter->iDes8.iPtr);

 				break;

 			case EDbColText16:

 				iter->iDes16.iPtr=(TUint16*)((TUint8*)key+TInt(iter->iDes8.iPtr));

 				break;

 				};

 			} while (++iter<end);

 		}

 	return key;

 	}

 // Reads the row from the client buffer into the server-side buffer

 void CDbsSession::ReadRowL(RDbRow& aRow,TInt aSize,const RMessage2& aMessage)

 	{

 	if (aSize)

 		{

 		aRow.GrowL(aSize);

 		TPtr8 buf((TUint8*)aRow.First(),aSize);

 		aMessage.ReadL(0,buf);

 		}

 	aRow.SetSize(aSize);

 	}

 // Writes a row from the client into the cursor

 // Any blobs which are modified must not be transferred into the cursor row buffer

 void CDbsSession::PutRowL(CDbCursor& aCursor,const RMessage2& aMessage)

 	{

 	RDbRow* pRow=aCursor.RowBuffer();

 	TInt size= aMessage.Int1();

 	const TBool omitBlobs=aMessage.Int2();

 	if (!omitBlobs && pRow)

 		{	// write straight into cursor row

 		ReadRowL(*pRow,size,aMessage);

 		return;

 		}

 	RDbRow row;

 	row.PushL();

 	ReadRowL(row,size,aMessage);

 	TInt max=aCursor.ColumnCount();

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

 		{

 		if (omitBlobs && TDbCol::IsLong(aCursor.ColumnType(ii)))

 			;

 		else

 			aCursor.Column(ii).SetL(row.ColCell(ii));

 		}

 	CleanupStack::PopAndDestroy();		// row

 	}

 // Writes the row buffer to the client row buffer, if big enough

 // If the client buffer is too small it will attempt a second retrieval

 TInt CDbsSession::WriteRowL(const RDbRow& aRow,const RMessage2& aMessage)

 	{

 	TInt size=aRow.Size();

 	if (size>0 && size<=aMessage.Int2())

 		aMessage.WriteL(3,TPtrC8((const TUint8*)aRow.First(),size));

 	return size+1;		// return 0 reserved for Goto

 	}

 // Returns a row to the client

 TInt CDbsSession::RetrieveRowL(CDbCursor& aCursor,const RMessage2& aMessage)

 	{

 	RDbRow* pRow=aCursor.RowBuffer();

 	if (pRow)	// direct row transfer

 		return WriteRowL(*pRow,aMessage);

 	// need to retrieve columns independantly

 	RDbRow row;

 	row.PushL();

 	TInt max=aCursor.ColumnCount();

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

 		TDbColumn(row,ii).SetL(aCursor.ColumnC(ii));

 	TInt size=WriteRowL(row,aMessage);

 	CleanupStack::PopAndDestroy();	// row

 	return size;

 	}

 //This method creates new EDbsCursor type object.

 //It is used at table level so it needs table object security policies.

 //The related table MPolicy interface will be 

 //put together with the EDbsCursor object in TEntry list.

 //

 //Complete the cursor construction

 TInt CDbsSession::NewCursorL(CDbCursor* aCursor,const RMessage2& aMessage, const MPolicy* aTblSecurityPolicy)

 	{

 	aCursor->PushL();		// it has a context: use safe cleanup

 	TPckgBuf<TDbsColumns> cols;

 	TInt ii=cols().iCount=aCursor->ColumnCount();

 	if (ii<=cols().EMax)

 		{

 		while (--ii>=0)

 			cols().iData[ii]=TUint8(aCursor->ColumnType(ii+1));

 		}

 	aMessage.WriteL(3,cols);

 	CleanupStack::Pop(aCursor);

 	return Add(aCursor, aTblSecurityPolicy);

 	}

 //This method creates new EDbsIncremental type object.

 //It is used either at database or  table level so it needs database or table object

 //security policies. The related database/table MPolicy interface will be

 //put together with the EDbsIncremental object in TEntry list.

 //

 //Complete a message which returns an incremental object by writing the step back

 //When there is no work to do, aIncremental may be 0: then return a null handle

 TInt CDbsSession::NewIncrementalL(CDbIncremental* aIncremental,

 								  TInt& aInit,const RMessage2& aMessage,

 								  const MPolicy* aPolicy)

 	{

 	aIncremental->PushL();		// it has a context: use safe cleanup

 	aMessage.WriteL(3,TPckgC<TInt>(aInit));

 	CleanupStack::Pop();

 	return aIncremental ? Add(aIncremental, aPolicy) : 0;

 	}

 //This method creates new EDbsStream type object.

 //It is used either at database or table level so it needs either 

 //database or table object security policies.

 //The related database/table MPolicy interface will be

 //put together with the EDbsStream object in TEntry list.

 //

 //Complete a stream based message return

 TInt CDbsSession::NewStreamL(MStreamBuf* aHost,const RMessage2& aMessage,

 							 const MPolicy* aPolicy,TInt aExtent)

 	{

 	aHost->PushL();

 	TPckgBuf<TDbsStreamBuf> buf;

 	if (aExtent>0)	// read the first buffer-full

 		aHost->ReadL(buf().iData,Min(aExtent,KDbsStreamBufSize));

 	TInt h=0;

 	if (aExtent<0 || aExtent>KDbsStreamBufSize)

 		{	// create the stream object

 		HDbsStream* stream = new(ELeave) HDbsStream(aHost,KDbsStreamBufSize);

 		h=Add(stream, aPolicy);

 		CleanupStack::Pop();		// aHost

 		}

 	else	// no more data to send

 		CleanupStack::PopAndDestroy();		// aHost

 	if (aExtent>=0)

 		{

 		buf().iExt=aExtent;

 		aMessage.WriteL(3,buf);

 		}

 	return h;

 	}

 //This method creates new EDbsStream type object.

 //It is used at database level so it needs the database object security policies.

 //The related database MPolicy interface will be 

 //put together with the EDbsStream object in TEntry list.

 //

 //Generic object passing code

 //aPtr should be on the cleanup stack, aExter can externalize it

 TInt CDbsSession::NewStreamL(TAny* aPtr,TExternalizeFunction aExter,

 							 const RMessage2& aMessage, const MPolicy* aDbSecurityPolicy)

 	{

 	RWriteStream strm(HBufBuf::NewLC());

 	aExter(aPtr,strm);

 	strm.CommitL();

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

 	CleanupStack::Pop();			// host

 	CleanupStack::PopAndDestroy();	// aPtr

 	TInt res = NewStreamL(strm.Sink(),aMessage,aDbSecurityPolicy,ext);

 	return res;

 	}

 //allocates a free entry if required

 void CDbsSession::AllocL()

 	{

 	__ASSERT(TUint(iFree)<=TUint(iSize));

 	if (iFree==iSize)

 		{

 		TInt size=iSize+EIndexGranularity;

 		if (size>KDbsIndexLimit)	// maximum number of objects reached

 			__LEAVE(KErrNoMemory);

 		TEntry* ix=iIx=(TEntry*)User::ReAllocL(iIx,size*sizeof(TEntry));

 		iSize=size;

 		for (TInt ii=iFree;ii<size;)

 			{

 			TEntry& e=ix[ii];

 			e.iNext=++ii;

 			e.iType=TUint8(EDbsFree);

 			e.iPolicy = NULL;

 			}

 		}

 	}

 // Sets the free entry and return a handle to it

 TInt CDbsSession::DoAdd(TAny* aObject,TDbsType aType, const MPolicy* aPolicy)

 	{

 	__ASSERT(TUint(iFree)<TUint(iSize));

 	__ASSERT(aType!=EDbsFree);

 	TInt ix=iFree;

 	TEntry& e=iIx[ix];

 	__ASSERT(e.Type()==EDbsFree);

 	iFree=e.iNext;

 	__ASSERT(TUint(iFree)<=TUint(iSize));

 	e.iObject=aObject;

 	e.iType=TUint8(aType);

 	e.iPolicy = aPolicy;

 	TInt magic=(e.iMagic+1)&KDbsMagicMask;

 	e.iMagic=TUint8(magic);

 	return DbsMakeHandle(ix,magic,aType);

 	}

 // releases the object and the entry to the free pool

 void CDbsSession::Free(TEntry& aEntry)

 	{

 	__ASSERT(TUint(iFree)<=TUint(iSize));

 	aEntry.Release();

 	aEntry.iNext=iFree;

 	iFree=&aEntry-&iIx[0];

 	__ASSERT(TUint(iFree)<TUint(iSize));

 	}

 CDbsSession::TEntry& CDbsSession::Object(TInt aHandle)

 	{

 	TEntry* e=0;

 	TInt ix=DbsObjectIndex(aHandle);

 	if (TUint(ix)<TUint(iSize))

 		{

 		e=&iIx[ix];

 		if (DbsMakeHandle(ix,e->iMagic,e->Type())!=aHandle)

 			e=0;

 		}

 	__ASSERT_ALWAYS(e && e->iPolicy,::Panic(EDbsBadHandle));

 	return *e;

 	}

 // Reports how many objects are allocated by the client

 TInt CDbsSession::CountResources()

 	{

 	TInt alloc=0;

 	const TEntry* const base=iIx;

 	if (base)

 		{

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

 			{

 			if (e->Type()!=EDbsFree)

 				++alloc;

 			}

 		}

 	return alloc;

 	}

 #ifdef __DBDUMP__

 //Using CDbsSession::Dump() method you can dump the session content

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

 void CDbsSession::Dump()

 	{

 	RFile dumpFile;

 	RFs fileSess;

 	TInt err = fileSess.Connect();

 	if(err == KErrNone)

 		{

 		_LIT(KDumpFileName, "_:\\PUBLIC\\DBMS\\DUMP%X.TXT");

 		TFileName dumpFileName(KDumpFileName);

 		dumpFileName[0] = 'A' + static_cast<TInt>(RFs::GetSystemDrive());

 		TBuf<40> buf;

 		buf.Format(dumpFileName, this);

 		err = fileSess.MkDirAll(buf);

 		if(err == KErrNone || err == KErrAlreadyExists)

 			{

 			err = dumpFile.Replace(fileSess, buf, EFileWrite);

 			if(err == KErrNone)

 				{

 				TEntry* const base = iIx;

 				if(base)

 					{

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

 						{

 						if(e->Type() != EDbsFree)

 							{

 							e->Dump(dumpFile);

 							}

 						}

 					}//end of - if(base)

 				}//end of - if(err == KErrNone)

 			}

 		}//end of - if(err == KErrNone)

 	dumpFile.Close();

 	fileSess.Close();

 	RDebug::Print(_L("CDbsSession::Dump() error=%d\n"), err);

 	__ASSERT_ALWAYS(err == KErrNone, User::Invariant());

 	}

 #endif//__DBDUMP__

 /**

 Reserves a prederfined amount of disk space on aDrive drive. 

 At the moment the max possible amount, allowed by the file server, is reserved on aDrive drive.

 Use this call to ensure that if your "delete records" transaction fails because of "out of

 disk space" circumstances, you can get an access to the already reserved disk space and

 complete your transaction successfully the second time.

 There is no strong, 100% guarantee, that the reserved disk space will always help the client

 in "low memory" situations.

 This method processes EDbsReserveDriveSpace message.

 @param aDrive Drive number to reserve space on

 @leave KErrArgument Invalid aDrive value.

 @leave CDbsSessDriveSpace::ReserveL() leaving error codes

 @see CDbsSessDriveSpace::ReserveL()

 */

 void CDbsSession::ReserveDriveSpaceL(TDriveNumber aDrive)

 	{

 	if(aDrive < EDriveA || aDrive > EDriveZ)

         {

         __LEAVE(KErrArgument);

         }

     iSessDriveSpace->ReserveL(aDrive);

 	}

 /**

 The method frees the reserved by the DBMS session disk space.

 This method processes EDbsFreeReservedSpace message.

 @param aDrive Drive number, which reserved space has to be freed.

 @see CDbsSessDriveSpace::Free()

 @panic Client side panic "DBMS-server 10" in debug mode, if the drive number is invalid.

 @panic In debug mode there will be a panic with the line number as an error code if 

        there is no reserved disk space for aDrive. 

 @panic In debug mode there will be a panic with the line number as an error code if 

        the reserved disk space is granted but not released.

 */

 void CDbsSession::FreeReservedSpace(TDriveNumber aDrive)

     {

     TBool valid = aDrive >= EDriveA && aDrive <= EDriveZ;

     __ASSERT_DEBUG(valid, ::Panic(EDbsInvalidDrive));

     if(valid)

         {

         iSessDriveSpace->Free(aDrive);

         }

     }

 /**

 Grants access to a given area on a given drive for CDbsSession session.

 Note this session must have reserved space on this particular drive in order to be 

 granted access to the reserved area.

 This method processes EDbsReserveGetAccess message.

 @param aDrive Drive number with a reserved disk space, an access to which is requested.

 @leave KErrArgument Invalid drive.

 @leave CDbsSessDriveSpace::GrantAccessL() leaving error codes

 @see CDbsSessDriveSpace::GrantAccessL()

 */

 void CDbsSession::GetReserveAccessL(TDriveNumber aDrive)

 	{

 	if(aDrive < EDriveA || aDrive > EDriveZ)

         {

         __LEAVE(KErrArgument);

         }

     iSessDriveSpace->GrantAccessL(aDrive);

 	}

 /**

 Revokes access on a given drive for CDbsSession session.

 This method processes EDbsReserveReleaseAccess message.

 @param aDrive Drive number with a reserved disk space, the access to which has to be released.

 @panic Client side panic "DBMS-server 10" in debug mode, if the drive number is invalid.

 @panic In debug mode there will be a panic with the line number as an error code if 

        there is no reserved disk space for aDrive. 

 @panic In debug mode there will be a panic with the line number as an error code if 

        there is no granted access to the reserved disk space. 

 */

 void CDbsSession::ReleaseReserveAccess(TDriveNumber aDrive)

 	{

     TBool valid = aDrive >= EDriveA && aDrive <= EDriveZ;

     __ASSERT_DEBUG(valid, ::Panic(EDbsInvalidDrive));

     if(valid)

         {

         iSessDriveSpace->ReleaseAccess(aDrive);

         }

 	}