sl@0: // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // DBMS server-session and support classes
sl@0: // 
sl@0: //
sl@0: 
sl@0: #include <s32file.h>
sl@0: #include "SD_STD.H"
sl@0: #include "Sd_DbList.h"
sl@0: 
sl@0: using namespace DBSC;
sl@0: 
sl@0: /*
sl@0: CDbsSession class is updated now to with a support for DBMS security policies.
sl@0: What idea sits behind the update:
sl@0: 1) DBMS server has a set of server side CDbsSession objects.
sl@0: 2) Each CDbsSession object has a list of CDbsSession::TEntry items.
sl@0:    Each CDbsSession::TEntry item holds a server side DBMS object, which is
sl@0:    used to perform client requests.
sl@0: 3) CDbsSession::TEntry object could be:
sl@0: 	- EDbsDatabase - database object. It operates at database level.
sl@0: 		OpenDatabaseL is the method, which creates it.
sl@0: 	- EDbsIncremental - incremental object. It operates either at database or table level.
sl@0: 		NewIncrementalL is the method, which creates it.
sl@0: 	- EDbsCursor - cursor object. It operates at table level.
sl@0: 		NewCursorL is the method, which creates it.
sl@0: 	- EDbsConstraint - constraint object. It is used at table level and needs the same
sl@0: 		security policy as its table.
sl@0: 	- EDbsStream - stream object. It operates either at database or table level.
sl@0: 		NewStreamL are the methods, which create it.
sl@0: 	- EDbsObserver - observer object. It operates at database level.
sl@0: 4) When DBMS server is used in a security environment, database/table security policies 
sl@0: 	describe allowed W/R operations for the database/tables.
sl@0: 5) Each database/table has a security policy object assiciated with it. It may be accessed
sl@0: 	using MPolicy interface.
sl@0: 6) There is a MPolicySpace interface, which holds a collection of MPolicy interfaces
sl@0: 	for the database/tables. MPolicy interfaces can be queried using MPolicySpace methods.
sl@0: 7) All DBMS server side objects, described in (3), operate at database/table level. In a
sl@0: 	security environment, the client's access rights has to be checked, before performing
sl@0: 	particular database/table operation.
sl@0: 	It is known at the moment of DBMS object creation, on which database/table it will operate.
sl@0: 	The database/table cannot be changed during the DBMS object life time.
sl@0: 	At the moment of DBMS object creation, the related database/table interface is queried and
sl@0: 	stored in CDbsSession::TEntry::iPolicy data member. 
sl@0: 	It is an error if CDbsSession::TEntry item exists without a security policy.
sl@0: 8) Every time, when a client needs particular DBMS server functionality and CDbsSession::ServiceL
sl@0: 	has been called, the session object will find which DBMS server object has to be used and
sl@0: 	asserts client's access rights against its security policy.
sl@0: 	If the client has not enough access rights to perform desired DBMS operation, the DBMS
sl@0: 	session will leave with KErrPermissionDenied error code.
sl@0: 	======================================================================================
sl@0: 	In one sentence - every time, when an object from CDbsSession::TEntry list is about to 
sl@0: 	perform particular operation at database/table level, the associated database/table 
sl@0: 	security policy will be checked and the opration may be rejected.
sl@0: */
sl@0: 
sl@0: // Class CDbsSession::TEntry
sl@0: 
sl@0: //
sl@0: // release the object
sl@0: //
sl@0: void CDbsSession::TEntry::Release()
sl@0: 	{
sl@0: 	TDbsType t=Type();
sl@0: 	__ASSERT(t!=EDbsFree);
sl@0: 	if (t==EDbsObserver)
sl@0: 		delete STATIC_CAST(CDbsObserver::HObserver*,iObject);
sl@0: 	else if (t==EDbsStream)
sl@0: 		delete STATIC_CAST(HDbsStream*,iObject);
sl@0: 	else
sl@0: 		CDbObject::Destroy(STATIC_CAST(CDbObject*,iObject));
sl@0: 	iType=TUint8(EDbsFree);
sl@0: 	iPolicy = NULL;
sl@0: 	}
sl@0: 
sl@0: #ifdef __DBDUMP__
sl@0: //Using CDbsSession::TEntry::Dump() method you can dump the TEntry's content
sl@0: //into a stream. Note that the dump works only if you have __DBDUMP__ macro defined.
sl@0: void CDbsSession::TEntry::Dump(RFile& aFile) const
sl@0: 	{
sl@0: 	_LIT8(KClassName, "CDbsSession::TEntry. this=%X");
sl@0: 	_LIT8(KType, "Type=%S");
sl@0: 	_LIT8(KMagic, "Magic=%d");
sl@0: 	_LIT8(KCrLf, "\r\n");
sl@0: 	_LIT8(KEnd, "====");
sl@0: 	TPtrC8 KDbsType[EDbsMaxType + 1] = {_L8("Free"), _L8("Database"), _L8("Incremental"), _L8("Cursor"), _L8("Constraint"), _L8("Stream"), _L8("Observer")};
sl@0: 	TBuf8<40> buf;
sl@0: 
sl@0: 	buf.Format(KClassName, this);
sl@0: 	(void)aFile.Write(buf);
sl@0: 	(void)aFile.Write(KCrLf);
sl@0: 	buf.Format(KType, &KDbsType[iType]);
sl@0: 	(void)aFile.Write(buf);
sl@0: 	(void)aFile.Write(KCrLf);
sl@0: 	buf.Format(KMagic, iMagic);
sl@0: 	(void)aFile.Write(buf);
sl@0: 	(void)aFile.Write(KCrLf);
sl@0: 	__ASSERT(iPolicy);
sl@0: 	iPolicy->Dump(aFile);
sl@0: 	(void)aFile.Write(KEnd);
sl@0: 	(void)aFile.Write(KCrLf);
sl@0: 	}
sl@0: #endif//__DBDUMP__
sl@0: 
sl@0: // Class CDbsSession
sl@0: 
sl@0: //
sl@0: // Release all this clients resources
sl@0: // Streams must be released before cursors, and everything before the connection
sl@0: //
sl@0: CDbsSession::~CDbsSession()
sl@0: 	{
sl@0: 	TEntry* const base=&iIx[0];
sl@0: 	if (base)
sl@0: 		{
sl@0: 		TInt type=EDbsMaxType;
sl@0: 		do	{
sl@0: 			for (TEntry* e=base+iSize;--e>=base;)
sl@0: 				{
sl@0: 				if (e->iType==type)
sl@0: 					e->Release();
sl@0: 				}
sl@0: 			} while (--type>EDbsFree);
sl@0: 		User::Free(base);
sl@0: 		}
sl@0: 	iDbPolicyRqColl.Close();
sl@0:     delete iSessDriveSpace;
sl@0: 	Server().RemoveSession();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Overrides virtual CSession2::Create2().
sl@0: Creates iSessDriveSpace instance.
sl@0: */
sl@0: void CDbsSession::CreateL()
sl@0:     {
sl@0:     iSessDriveSpace = CDbsSessDriveSpace::NewL(Server().DriveSpaceCol());
sl@0:     }
sl@0: 
sl@0: //
sl@0: // provide for CSession
sl@0: // If this leaves, we complete message through ServiceError(...)
sl@0: //
sl@0: void CDbsSession::ServiceL(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	//set received message in server so it can be used in cleanup when server panics.
sl@0: 	CPolicyProxy& policyProxy = Server().PolicyProxy();
sl@0: 	TDbsFunction f=DbsFunction(aMessage.Function());
sl@0: 	if (f&KDbsObjectReturn)		// may return a derived object
sl@0: 		AllocL();	// ensure index space
sl@0: 	TInt r=0;//object handle
sl@0: 	TInt h=DbsHandle(aMessage.Function());
sl@0: 	if (h==KDbsSessionHandle)
sl@0: 		{	// session based requests
sl@0: 		switch (f&~KDbsObjectReturn)
sl@0: 			{
sl@0: 		case EDbsResourceMark:
sl@0: 			ResourceCountMarkStart();
sl@0: 			break;
sl@0: 		case EDbsResourceCheck:
sl@0: 			ResourceCountMarkEnd(aMessage);
sl@0: 			break;
sl@0: 		case EDbsResourceCount:
sl@0: 			r=CountResources();
sl@0: 			break;
sl@0: 		case EDbsSetHeapFailure:
sl@0: 			User::__DbgSetAllocFail(RHeap::EUser,RHeap::TAllocFail(aMessage.Int0()),aMessage.Int1());
sl@0: 			break;
sl@0: 		case EDbsOpenDatabase:
sl@0: 			r=OpenDatabaseL(aMessage);
sl@0: 			break;
sl@0: 		case EDbsReserveDriveSpace:
sl@0: 			ReserveDriveSpaceL(static_cast <TDriveNumber> (aMessage.Int0()));
sl@0: 			break;
sl@0:         case EDbsFreeReservedSpace:
sl@0: 	        FreeReservedSpace(static_cast <TDriveNumber> (aMessage.Int0()));
sl@0: 			break;
sl@0: 		case EDbsReserveGetAccess:
sl@0: 			GetReserveAccessL(static_cast <TDriveNumber> (aMessage.Int0()));
sl@0: 			break;
sl@0: 		case EDbsReserveReleaseAccess:
sl@0: 			ReleaseReserveAccess(static_cast <TDriveNumber> (aMessage.Int0()));
sl@0: 			break;
sl@0: 		default:
sl@0: 			r=ExtServiceL(aMessage, static_cast <TDbsFunction> (f&~KDbsObjectReturn));
sl@0: 			break;
sl@0: 			}
sl@0: 		}
sl@0: 	else
sl@0: 		{	// object based requests
sl@0: 		TEntry& e=Object(h);
sl@0: 		__ASSERT(e.iPolicy);
sl@0: 		policyProxy.CheckL(aMessage, *e.iPolicy);
sl@0: 		TDbsFunction dbmsFuncNo = static_cast <TDbsFunction> (f & ~KDbsObjectReturn);
sl@0: 		switch (dbmsFuncNo)
sl@0: 			{
sl@0: 	// the common close function
sl@0: 		case EDbsClose:
sl@0: 			//If this is a database object, remove the related pair (handle, uid) from iDbPolicyRqColl collection.
sl@0: 			if(e.Type() == EDbsDatabase)
sl@0: 				{
sl@0: 				iDbPolicyRqColl.Remove(h);
sl@0: 				}
sl@0: 			Free(e);
sl@0: 			break;
sl@0: 	// database functions
sl@0: 		case EDbsDatabaseAuthenticate:
sl@0: 			{
sl@0:             __LEAVE(KErrNotSupported);             
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsDatabaseDestroy:
sl@0: 			r=e.Database().Destroy();
sl@0: 			break;
sl@0: 		case EDbsDatabaseBegin:
sl@0: 			r=e.Database().Begin();
sl@0: 			break;
sl@0: 		case EDbsDatabaseCommit:
sl@0: 			r=e.Database().Commit();
sl@0: 			break;
sl@0: 		case EDbsDatabaseRollback:
sl@0: 			e.Database().Rollback();
sl@0: 			break;
sl@0: 		case EDbsDatabaseProperty:
sl@0: 			r=e.Database().Property(CDbDatabase::TProperty(aMessage.Int0()));
sl@0: 			break;
sl@0: 		case EDbsDatabaseTables:
sl@0: 			{//The new stream object will have the same security policy as the database
sl@0: 			 //Read only stream
sl@0: 			CDbTableNames* names=CDbTableNames::NewLC();
sl@0: 			e.Database().TablesL(*names);
sl@0: 			r=NewStreamL(names,Externalizer(names),aMessage,e.iPolicy);
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsDatabaseColumns:
sl@0: 			{//The new stream object will have the same security policy as the database
sl@0: 			 //Read only stream
sl@0: 			CDbColSet* set=CDbColSet::NewLC();
sl@0: 			e.Database().ColumnsL(*set,ReadName0L(0,aMessage));
sl@0: 			r=NewStreamL(set,Externalizer(set),aMessage,e.iPolicy);
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsDatabaseIndexes:
sl@0: 			{//The new stream object will have the same security policy as the database
sl@0: 			 //Read only stream
sl@0: 			CDbIndexNames* names=CDbIndexNames::NewLC();
sl@0: 			e.Database().IndexesL(*names,ReadName0L(0,aMessage));
sl@0: 			r=NewStreamL(names,Externalizer(names),aMessage,e.iPolicy);
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsDatabaseKeys:
sl@0: 			{//The new stream object will have the same security policy as the database
sl@0: 			 //Read only stream
sl@0: 			CDbKey* key=CDbKey::NewLC();
sl@0: 			e.Database().KeysL(*key,ReadName0L(0,aMessage),ReadName1L(1,aMessage));
sl@0: 			r=NewStreamL(key,Externalizer(key),aMessage,e.iPolicy);
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsDatabaseCreateTable:
sl@0: 			{
sl@0: 			const TDesC& name=ReadName0L(0,aMessage);
sl@0: 			CDbColSet* set=ColSetLC(1,aMessage);
sl@0: 			CDbKey* primary=0;
sl@0: 			if (aMessage.Ptr2())
sl@0: 				primary=KeyLC(2,aMessage);
sl@0: 
sl@0: 			e.Database().CreateTableL(name,*set,primary);
sl@0: 			if (primary)
sl@0: 				CleanupStack::PopAndDestroy();	// primary
sl@0: 			CleanupStack::PopAndDestroy();	// set
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsDatabaseOpenObserver:
sl@0: 			//The new observer object will have the same security policy as the database
sl@0: 			r=Add(CDbsConnection::Source(e.Database()).ObserverL(),e.iPolicy);
sl@0: 			break;
sl@0: 		case EDbsDatabaseOpenUtility:
sl@0: 			{//The new incremental object will have the same security policy as the database
sl@0: 			TInt step;
sl@0: 			r=NewIncrementalL(e.Database().UtilityL(CDbDatabase::TUtility(aMessage.Int0()),step),step,aMessage,e.iPolicy);
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsDatabaseOpenDropTable:
sl@0: 			{//The new incremental object will have the same security policy as the database
sl@0: 			TInt step;
sl@0: 			const TDesC& name=ReadName0L(0,aMessage);
sl@0: 			r=NewIncrementalL(e.Database().DropTableL(name,step),step,aMessage,e.iPolicy);
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsDatabaseOpenAlterTable:
sl@0: 			{//The new incremental object will have the same security policy as the database
sl@0: 			TInt step;
sl@0: 			const TDesC& name=ReadName0L(0,aMessage);
sl@0: 			CDbColSet* set=ColSetLC(1,aMessage);
sl@0: 			r=NewIncrementalL(e.Database().AlterTableL(name,*set,step),step,aMessage,e.iPolicy);
sl@0: 			CleanupStack::PopAndDestroy();	// set
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsDatabaseOpenCreateIndex:
sl@0: 			{//The new incremental object will have the same security policy as the database
sl@0: 			TInt step;
sl@0: 			const TDesC& name=ReadName0L(0,aMessage);
sl@0: 			const TDesC& table=ReadName1L(1,aMessage);
sl@0: 			CDbKey* key=KeyLC(2,aMessage);
sl@0: 			r=NewIncrementalL(e.Database().CreateIndexL(name,table,*key,step),step,aMessage,e.iPolicy);
sl@0: 			CleanupStack::PopAndDestroy();	// key
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsDatabaseOpenDropIndex:
sl@0: 			{//The new incremental object will have the same security policy as the database
sl@0: 			TInt step;
sl@0: 			const TDesC& name=ReadName0L(0,aMessage);
sl@0: 			const TDesC& table=ReadName1L(1,aMessage);
sl@0: 			r=NewIncrementalL(e.Database().DropIndexL(name,table,step),step,aMessage,e.iPolicy);
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsDatabaseExecute:
sl@0: 			{//The new incremental object will have the same security policy as the database or table - sql dependent.
sl@0: 			//In order EDbsDatabaseExecute request to be performed, the DBMS session has already
sl@0: 			//checked the client capabilities at the database level.
sl@0: 			//Now, the sql string will be parsed and the client capabilities will be checked
sl@0: 			//again at more specific database or table level.
sl@0: 			TInt init;
sl@0: 			HBufC* sql=ReadHBufLC(0,aMessage);
sl@0: 			const TDbPolicyRequest& rq = iDbPolicyRqColl[h];
sl@0: 			TPolicyType policyType = EPTNone;
sl@0: 			const MPolicy* policy = policyProxy.SqlPolicyL(rq, *sql, policyType);
sl@0: 			policyProxy.CheckL(policyType, aMessage, *policy);			
sl@0: 			r=NewIncrementalL(e.Database().ExecuteL(*sql,TDbTextComparison(aMessage.Int1()),init),init,aMessage,policy);
sl@0: 			CleanupStack::PopAndDestroy(sql);
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsDatabasePrepareView:
sl@0: 			{//The new cursor object will have the same security policy as the table in the sql string.
sl@0: 			//In order EDbsDatabasePrepareView request to be performed, the DBMS session has already
sl@0: 			//checked the client capabilities at the database level.
sl@0: 			//Now, the sql string will be parsed and the client capabilities will be checked
sl@0: 			//again at table level.
sl@0: 			HBufC* sql=ReadHBufLC(0,aMessage);
sl@0: 			const TDbPolicyRequest& rq = iDbPolicyRqColl[h];
sl@0: 			TPolicyType policyType = EPTNone;
sl@0: 			const MPolicy* policy = policyProxy.SqlPolicyL(rq, *sql, policyType);
sl@0: 			policyProxy.CheckL(policyType, aMessage, *policy);			
sl@0: 			TPckgBuf<TDbWindow> window;
sl@0: 			aMessage.ReadL(2,window);
sl@0: 			TInt mode=aMessage.Int1();
sl@0: 			CDbCursor* cursor=e.Database().ViewL(TDbQuery(*sql,TDbTextComparison(mode&0xff)),window(),RDbRowSet::TAccess(mode>>8));
sl@0: 			r=NewCursorL(cursor,aMessage,policy);
sl@0: 			CleanupStack::PopAndDestroy(sql);
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsDatabaseOpenTable:
sl@0: 			{//The new cursor object will have the same security policy as the table
sl@0: 			const TDesC& name=ReadName0L(0,aMessage);
sl@0: 			const TDbPolicyRequest& rq = iDbPolicyRqColl[h];
sl@0: 			const MPolicy* policy = policyProxy.TblPolicyL(rq, name);
sl@0: 			//Check caller capabilities against the table policy
sl@0: 			RDbRowSet::TAccess accessType = static_cast <RDbRowSet::TAccess> (aMessage.Int1());
sl@0: 			TPolicyType policyType = accessType == RDbRowSet::EReadOnly ? EPTRead : EPTWrite;
sl@0: 			policyProxy.CheckL(policyType, aMessage, *policy);
sl@0: 			//Create cursor
sl@0: 			r=NewCursorL(e.Database().TableL(name,accessType),aMessage,policy);
sl@0: 			}
sl@0: 			break;
sl@0: 	// Incremental functions
sl@0: 		case EDbsIncrementalNext:
sl@0: 			{
sl@0: 			TPckgBuf<TInt> step=aMessage.Int0();
sl@0: 			r=e.Incremental().NextL(step());
sl@0: 			aMessage.WriteL(1,step);
sl@0: 			}
sl@0: 			break;
sl@0: 	// Observer functions
sl@0: 		case EDbsObserverNotify:
sl@0: 			e.Observer().Notify(aMessage);
sl@0: 			return;		// deferred completion of the message!
sl@0: 		case EDbsObserverCancel:
sl@0: 			e.Observer().Cancel();
sl@0: 			break;
sl@0: 	// cursor functions
sl@0: 		case EDbsCursorColumnTypes:
sl@0: 			{
sl@0: 			TInt count=e.Cursor().ColumnCount();
sl@0: 			TUint8* types=(TUint8*)User::AllocLC(count);
sl@0: 			for (TInt ii=count;--ii>=0;)
sl@0: 				types[ii]=TUint8(e.Cursor().ColumnType(ii+1));
sl@0: 			aMessage.WriteL(3,TPtrC8(types,count));
sl@0: 			CleanupStack::PopAndDestroy();
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsCursorReset:
sl@0: 			e.Cursor().Reset();
sl@0: 			break;
sl@0: 		case EDbsCursorEvaluate:
sl@0: 			r=e.Cursor().EvaluateL()?1:0;
sl@0: 			break;
sl@0: 		case EDbsCursorUnevaluated:
sl@0: 			r=e.Cursor().Unevaluated()?1:0;
sl@0: 			break;
sl@0: 		case EDbsCursorSetIndex:
sl@0: 			{
sl@0: 			const TDesC* name=0;
sl@0: 			if (aMessage.Ptr0())
sl@0: 				name=&ReadName0L(0,aMessage);
sl@0: 			e.Cursor().SetIndexL(name);
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsCursorSeek:
sl@0: 			{
sl@0: 			TDbLookupKey* key=LookupKeyLC(0,aMessage.Int1(),aMessage);
sl@0: 			r=e.Cursor().SeekL(*key,RDbTable::TComparison(aMessage.Int2()))?1:0;
sl@0: 			CleanupStack::PopAndDestroy();		// key;
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsCursorAtBeginning:
sl@0: 			r=e.Cursor().AtBeginning()?1:0;
sl@0: 			break;
sl@0: 		case EDbsCursorAtEnd:
sl@0: 			r=e.Cursor().AtEnd()?1:0;
sl@0: 			break;
sl@0: 		case EDbsCursorAtRow:
sl@0: 			r=e.Cursor().AtRow()?1:0;
sl@0: 			break;
sl@0: 		case EDbsCursorCount:
sl@0: 			r=e.Cursor().CountL(RDbRowSet::TAccuracy(aMessage.Int0()))+1;
sl@0: 			break;
sl@0: 		case EDbsCursorGotoPos:
sl@0: 			if (e.Cursor().GotoL(RDbRowSet::TPosition(aMessage.Int0())))
sl@0: 				{
sl@0: 				e.Cursor().GetL();
sl@0: 				r=RetrieveRowL(e.Cursor(),aMessage);
sl@0: 				}
sl@0: 			break;
sl@0: 		case EDbsCursorBookmark:
sl@0: 			{
sl@0: 			TPckgBuf<TDbBookmark::TMark> mark;
sl@0: 			e.Cursor().Bookmark(mark());
sl@0: 			aMessage.WriteL(3,mark);
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsCursorGotoBookmark:
sl@0: 			{
sl@0: 			TPckgBuf<TDbBookmark::TMark> mark;
sl@0: 			aMessage.ReadL(0,mark);
sl@0: 			e.Cursor().GotoL(mark());
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsCursorGet:
sl@0: 			e.Cursor().GetL();
sl@0: 			r=RetrieveRowL(e.Cursor(),aMessage);
sl@0: 			break;
sl@0: 		case EDbsCursorInsert:
sl@0: 			e.Cursor().InsertL(CDbCursor::TInsert(aMessage.Int0()));
sl@0: 			r=RetrieveRowL(e.Cursor(),aMessage);
sl@0: 			break;
sl@0: 		case EDbsCursorUpdate:
sl@0: 			e.Cursor().UpdateL();
sl@0: 			r=RetrieveRowL(e.Cursor(),aMessage);
sl@0: 			break;
sl@0: 		case EDbsCursorRetrieveRow:	// pass the row buffer back to the client
sl@0: 			r=RetrieveRowL(e.Cursor(),aMessage);
sl@0: 			break;
sl@0: 		case EDbsCursorCancel:
sl@0: 			e.Cursor().Cancel();
sl@0: 			break;
sl@0: 		case EDbsCursorPut:
sl@0: 			PutRowL(e.Cursor(),aMessage);
sl@0: 			e.Cursor().PutL();
sl@0: 			break;
sl@0: 		case EDbsCursorDelete:
sl@0: 			e.Cursor().DeleteL();
sl@0: 			break;
sl@0: 		case EDbsCursorColumns:
sl@0: 			{// reduce memory usage by extracting and stream columns individually
sl@0: 			 //Read only stream
sl@0: 			RWriteStream strm(HBufBuf::NewLC());
sl@0: 			TInt count=e.Cursor().ColumnCount();
sl@0: 			strm.WriteInt32L(count);
sl@0: 			TDbCol col;
sl@0: 			for (TInt ii=0;++ii<=count;)
sl@0: 				{
sl@0: 				e.Cursor().ColumnDef(col,ii);
sl@0: 				strm<<col;
sl@0: 				}
sl@0: 			strm.CommitL();
sl@0: 			TInt ext=strm.Sink()->SizeL();
sl@0: 			CleanupStack::Pop();			// stream
sl@0: 			r=NewStreamL(strm.Sink(),aMessage,e.iPolicy,ext);
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsCursorColumnDef:
sl@0: 			{
sl@0: 			TPckgBuf<TDbCol> col;
sl@0: 			e.Cursor().ColumnDef(col(),aMessage.Int0());
sl@0: 			aMessage.WriteL(3,col);
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsCursorSetNull:
sl@0: 			__ASSERT(TDbCol::IsLong(e.Cursor().ColumnType(aMessage.Int0())));
sl@0: 			e.Cursor().SetNullL(aMessage.Int0());
sl@0: 			break;
sl@0: 		case EDbsCursorColumnSize:
sl@0: 			__ASSERT(TDbCol::IsLong(e.Cursor().ColumnType(aMessage.Int0())));
sl@0: 			r=e.Cursor().ColumnSize(aMessage.Int0());
sl@0: 			break;
sl@0: 		case EDbsCursorColumnSource:
sl@0: 			__ASSERT(TDbCol::IsLong(e.Cursor().ColumnType(aMessage.Int0())));
sl@0: 			{//The new stream object will have the same security policy as the table
sl@0: 			 //Read only stream, used for large BLOB fields.
sl@0: 			TDbColNo col=aMessage.Int0();
sl@0: 			CDbCursor& cursor=e.Cursor();
sl@0: 			r=NewStreamL(cursor.ColumnSourceL(col),aMessage,e.iPolicy,cursor.ColumnSize(col));
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsCursorColumnSink:
sl@0: 			//The new stream object will have the same security policy as the table
sl@0: 			//Write stream, used for large BLOB fields.
sl@0: 			r=NewStreamL(e.Cursor().ColumnSinkL(aMessage.Int0()),aMessage,e.iPolicy);
sl@0: 			break;
sl@0: 		case EDbsCursorOpenConstraint:
sl@0: 			{//The new constraint object will have the same security policy as the table
sl@0: 			HBufC* sql=ReadHBufLC(0,aMessage);
sl@0: 			CDbRowConstraint* ct=e.Cursor().ConstraintL(TDbQuery(*sql,TDbTextComparison(aMessage.Int1())));
sl@0: 			CleanupStack::PopAndDestroy();	//sql
sl@0: 			r=Add(ct, e.iPolicy);
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsCursorMatch:
sl@0: 			r=e.Cursor().MatchL(Object(aMessage.Int0()).Constraint())?1:0;
sl@0: 			break;
sl@0: 		case EDbsCursorFind:
sl@0: 			{
sl@0: 			HBufC* sql=ReadHBufLC(0,aMessage);
sl@0: 			TDbQuery q(*sql,TDbTextComparison(aMessage.Int1()));
sl@0: 			r=e.Cursor().FindL(RDbRowSet::TDirection(aMessage.Int2()),q)-KErrNotFound;
sl@0: 			CleanupStack::PopAndDestroy();	//sql
sl@0: 			}
sl@0: 			break;
sl@0: 			// stream functions
sl@0: 		case EDbsStreamRead:
sl@0: 			{
sl@0: 			r=e.Stream().ReadL(aMessage);
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsStreamWrite:
sl@0: 			{
sl@0: 			e.Stream().WriteL(aMessage);
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsStreamSize:
sl@0: 			{
sl@0: 			r=e.Stream().SizeL();
sl@0: 			}
sl@0: 			break;
sl@0: 		case EDbsStreamSynch:
sl@0: 			{
sl@0: 			e.Stream().SynchL();
sl@0: 			}
sl@0: 			break;
sl@0: 	// we don't know about any other functions
sl@0: 		default:
sl@0: 			r=KErrNotSupported;
sl@0: 			break;
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	// don't complete message if we have paniced client, just reset variable;
sl@0: 	if (!aMessage.IsNull())
sl@0: 		aMessage.Complete(r);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: // Handle an error from CDbsSession::ServiceL()
sl@0: // A bad descriptor error implies a badly programmed client, so panic it;
sl@0: // otherwise use the default handling (report the error to the client)
sl@0: void CDbsSession::ServiceError(const RMessage2& aMessage,TInt aError)
sl@0:  	{
sl@0: #ifdef __DBDUMP__
sl@0: 	Dump();
sl@0: #endif//__DBDUMP__
sl@0:  	if (aError==KErrBadDescriptor)
sl@0:  		{
sl@0:  		// this completes message as well so we have to handle it in
sl@0:  		// ServiceL
sl@0:  		_LIT(KCategory,"DBMS-server");
sl@0:  		Server().Panic(KCategory,EDbsBadDescriptor);
sl@0:  		}
sl@0:  	CSession2::ServiceError(aMessage,aError);
sl@0:    	}
sl@0: 
sl@0: // Read aPtr as a name
sl@0: const TDesC& CDbsSession::ReadName0L(TInt aIndex,const RMessage2& aMessage)
sl@0: 	{
sl@0: 	TDes& name=Server().Name0();
sl@0: 	aMessage.ReadL(aIndex,name);
sl@0: 	return name;
sl@0: 	}
sl@0: 
sl@0: // Read Ptr1 as a name
sl@0: const TDesC& CDbsSession::ReadName1L(TInt aIndex,const RMessage2& aMessage)
sl@0: 	{
sl@0: 	TDes& name=Server().Name1();
sl@0: 	aMessage.ReadL(aIndex,name);
sl@0: 	return name;
sl@0: 	}
sl@0: 
sl@0: // Reads aPtr as a variable length 8-bit descriptor
sl@0: HBufC8* CDbsSession::ReadHBuf8LC(TInt aIndex,const RMessage2& aMessage)
sl@0: 	{
sl@0: 	TInt len= aMessage.GetDesLengthL(aIndex);
sl@0: 	HBufC8* buf=HBufC8::NewLC(len);
sl@0: 	TPtr8 read(buf->Des());
sl@0: 	aMessage.ReadL(aIndex,read);
sl@0: 	return buf;
sl@0: 	}
sl@0: 
sl@0: // Reads aPtr as a variable length build-width descriptor
sl@0: HBufC* CDbsSession::ReadHBufLC(TInt aIndex,const RMessage2& aMessage)
sl@0: 	{
sl@0: 	TInt len= aMessage.GetDesLengthL(aIndex);
sl@0: 	HBufC* buf=HBufC::NewLC(len);
sl@0: 	TPtr read(buf->Des());
sl@0: 	aMessage.ReadL(aIndex,read);
sl@0: 	return buf;
sl@0: 	}
sl@0: 
sl@0: // Pulls a column set from the client
sl@0: CDbColSet* CDbsSession::ColSetLC(TInt aIndex,const RMessage2& aMessage)
sl@0: 	{
sl@0: 	CDbColSet* set=CDbColSet::NewLC();
sl@0: 	HBufC8* data=ReadHBuf8LC(aIndex,aMessage);
sl@0: 	RDesReadStream strm(*data);
sl@0: 	strm>>*set;
sl@0: 	CleanupStack::PopAndDestroy();	// data
sl@0: 	return set;
sl@0: 	}
sl@0: 
sl@0: // Pulls a key from the client
sl@0: CDbKey* CDbsSession::KeyLC(TInt aIndex,const RMessage2& aMessage)
sl@0: 	{
sl@0: 	CDbKey* key=CDbKey::NewLC();
sl@0: 	HBufC8* data=ReadHBuf8LC(aIndex,aMessage);
sl@0: 	RDesReadStream strm(*data);
sl@0: 	strm>>*key;
sl@0: 	CleanupStack::PopAndDestroy();	// data
sl@0: 	return key;
sl@0: 	}
sl@0: 
sl@0: // Reconstructs a TDbLookupKey from the message parameter
sl@0: TDbLookupKey* CDbsSession::LookupKeyLC(TInt aIndex,TInt aSize,const RMessage2& aMessage)
sl@0: 	{
sl@0: 	TDbLookupKey* key=(TDbLookupKey*)User::AllocLC(aSize);
sl@0: 	TPtr8 pckg((TUint8*)key,aSize);
sl@0: 	aMessage.ReadL(aIndex,pckg); 
sl@0: 	TDbLookupKey::SColumn* iter=CONST_CAST(TDbLookupKey::SColumn*,key->First());
sl@0: 	const TDbLookupKey::SColumn* end=iter+key->Count();
sl@0: 	if ((TUint8*)end-(TUint8*)key<aSize)
sl@0: 		{	// there is some text data following...
sl@0: 		do
sl@0: 			{
sl@0: 			switch (iter->iType)
sl@0: 				{
sl@0: 			default:
sl@0: 				break;
sl@0: 			case EDbColText8:
sl@0: 				iter->iDes8.iPtr=(TUint8*)key+TInt(iter->iDes8.iPtr);
sl@0: 				break;
sl@0: 			case EDbColText16:
sl@0: 				iter->iDes16.iPtr=(TUint16*)((TUint8*)key+TInt(iter->iDes8.iPtr));
sl@0: 				break;
sl@0: 				};
sl@0: 			} while (++iter<end);
sl@0: 		}
sl@0: 	return key;
sl@0: 	}
sl@0: 
sl@0: // Reads the row from the client buffer into the server-side buffer
sl@0: void CDbsSession::ReadRowL(RDbRow& aRow,TInt aSize,const RMessage2& aMessage)
sl@0: 	{
sl@0: 	if (aSize)
sl@0: 		{
sl@0: 		aRow.GrowL(aSize);
sl@0: 		TPtr8 buf((TUint8*)aRow.First(),aSize);
sl@0: 		aMessage.ReadL(0,buf);
sl@0: 		}
sl@0: 	aRow.SetSize(aSize);
sl@0: 	}
sl@0: 
sl@0: // Writes a row from the client into the cursor
sl@0: // Any blobs which are modified must not be transferred into the cursor row buffer
sl@0: void CDbsSession::PutRowL(CDbCursor& aCursor,const RMessage2& aMessage)
sl@0: 	{
sl@0: 	RDbRow* pRow=aCursor.RowBuffer();
sl@0: 	TInt size= aMessage.Int1();
sl@0: 	const TBool omitBlobs=aMessage.Int2();
sl@0: 
sl@0: 	if (!omitBlobs && pRow)
sl@0: 		{	// write straight into cursor row
sl@0: 		ReadRowL(*pRow,size,aMessage);
sl@0: 		return;
sl@0: 		}
sl@0: 	RDbRow row;
sl@0: 	row.PushL();
sl@0: 	ReadRowL(row,size,aMessage);
sl@0: 	TInt max=aCursor.ColumnCount();
sl@0: 	for (TInt ii=0;++ii<=max;)
sl@0: 		{
sl@0: 		if (omitBlobs && TDbCol::IsLong(aCursor.ColumnType(ii)))
sl@0: 			;
sl@0: 		else
sl@0: 			aCursor.Column(ii).SetL(row.ColCell(ii));
sl@0: 		}
sl@0: 	CleanupStack::PopAndDestroy();		// row
sl@0: 	}
sl@0: 
sl@0: // Writes the row buffer to the client row buffer, if big enough
sl@0: // If the client buffer is too small it will attempt a second retrieval
sl@0: TInt CDbsSession::WriteRowL(const RDbRow& aRow,const RMessage2& aMessage)
sl@0: 	{
sl@0: 	TInt size=aRow.Size();
sl@0: 	if (size>0 && size<=aMessage.Int2())
sl@0: 		aMessage.WriteL(3,TPtrC8((const TUint8*)aRow.First(),size));
sl@0: 	return size+1;		// return 0 reserved for Goto
sl@0: 	}
sl@0: 
sl@0: // Returns a row to the client
sl@0: TInt CDbsSession::RetrieveRowL(CDbCursor& aCursor,const RMessage2& aMessage)
sl@0: 	{
sl@0: 	RDbRow* pRow=aCursor.RowBuffer();
sl@0: 	if (pRow)	// direct row transfer
sl@0: 		return WriteRowL(*pRow,aMessage);
sl@0: 	// need to retrieve columns independantly
sl@0: 	RDbRow row;
sl@0: 	row.PushL();
sl@0: 	TInt max=aCursor.ColumnCount();
sl@0: 	for (TInt ii=0;++ii<=max;)
sl@0: 		TDbColumn(row,ii).SetL(aCursor.ColumnC(ii));
sl@0: 	TInt size=WriteRowL(row,aMessage);
sl@0: 	CleanupStack::PopAndDestroy();	// row
sl@0: 	return size;
sl@0: 	}
sl@0: 
sl@0: //This method creates new EDbsCursor type object.
sl@0: //It is used at table level so it needs table object security policies.
sl@0: //The related table MPolicy interface will be 
sl@0: //put together with the EDbsCursor object in TEntry list.
sl@0: //
sl@0: //Complete the cursor construction
sl@0: TInt CDbsSession::NewCursorL(CDbCursor* aCursor,const RMessage2& aMessage, const MPolicy* aTblSecurityPolicy)
sl@0: 	{
sl@0: 	aCursor->PushL();		// it has a context: use safe cleanup
sl@0: 	TPckgBuf<TDbsColumns> cols;
sl@0: 	TInt ii=cols().iCount=aCursor->ColumnCount();
sl@0: 	if (ii<=cols().EMax)
sl@0: 		{
sl@0: 		while (--ii>=0)
sl@0: 			cols().iData[ii]=TUint8(aCursor->ColumnType(ii+1));
sl@0: 		}
sl@0: 	aMessage.WriteL(3,cols);
sl@0: 	CleanupStack::Pop(aCursor);
sl@0: 	return Add(aCursor, aTblSecurityPolicy);
sl@0: 	}
sl@0: 
sl@0: //This method creates new EDbsIncremental type object.
sl@0: //It is used either at database or  table level so it needs database or table object
sl@0: //security policies. The related database/table MPolicy interface will be
sl@0: //put together with the EDbsIncremental object in TEntry list.
sl@0: //
sl@0: //Complete a message which returns an incremental object by writing the step back
sl@0: //When there is no work to do, aIncremental may be 0: then return a null handle
sl@0: TInt CDbsSession::NewIncrementalL(CDbIncremental* aIncremental,
sl@0: 								  TInt& aInit,const RMessage2& aMessage,
sl@0: 								  const MPolicy* aPolicy)
sl@0: 	{
sl@0: 	aIncremental->PushL();		// it has a context: use safe cleanup
sl@0: 	aMessage.WriteL(3,TPckgC<TInt>(aInit));
sl@0: 	CleanupStack::Pop();
sl@0: 	return aIncremental ? Add(aIncremental, aPolicy) : 0;
sl@0: 	}
sl@0: 
sl@0: //This method creates new EDbsStream type object.
sl@0: //It is used either at database or table level so it needs either 
sl@0: //database or table object security policies.
sl@0: //The related database/table MPolicy interface will be
sl@0: //put together with the EDbsStream object in TEntry list.
sl@0: //
sl@0: //Complete a stream based message return
sl@0: TInt CDbsSession::NewStreamL(MStreamBuf* aHost,const RMessage2& aMessage,
sl@0: 							 const MPolicy* aPolicy,TInt aExtent)
sl@0: 	{
sl@0: 	aHost->PushL();
sl@0: 	TPckgBuf<TDbsStreamBuf> buf;
sl@0: 	if (aExtent>0)	// read the first buffer-full
sl@0: 		aHost->ReadL(buf().iData,Min(aExtent,KDbsStreamBufSize));
sl@0: 	TInt h=0;
sl@0: 	if (aExtent<0 || aExtent>KDbsStreamBufSize)
sl@0: 		{	// create the stream object
sl@0: 		HDbsStream* stream = new(ELeave) HDbsStream(aHost,KDbsStreamBufSize);
sl@0: 		h=Add(stream, aPolicy);
sl@0: 		CleanupStack::Pop();		// aHost
sl@0: 		}
sl@0: 	else	// no more data to send
sl@0: 		CleanupStack::PopAndDestroy();		// aHost
sl@0: 	if (aExtent>=0)
sl@0: 		{
sl@0: 		buf().iExt=aExtent;
sl@0: 		aMessage.WriteL(3,buf);
sl@0: 		}
sl@0: 	return h;
sl@0: 	}
sl@0: 
sl@0: //This method creates new EDbsStream type object.
sl@0: //It is used at database level so it needs the database object security policies.
sl@0: //The related database MPolicy interface will be 
sl@0: //put together with the EDbsStream object in TEntry list.
sl@0: //
sl@0: //Generic object passing code
sl@0: //aPtr should be on the cleanup stack, aExter can externalize it
sl@0: TInt CDbsSession::NewStreamL(TAny* aPtr,TExternalizeFunction aExter,
sl@0: 							 const RMessage2& aMessage, const MPolicy* aDbSecurityPolicy)
sl@0: 	{
sl@0: 	RWriteStream strm(HBufBuf::NewLC());
sl@0: 	aExter(aPtr,strm);
sl@0: 	strm.CommitL();
sl@0: 	TInt ext=strm.Sink()->SizeL();
sl@0: 	CleanupStack::Pop();			// host
sl@0: 	CleanupStack::PopAndDestroy();	// aPtr
sl@0: 	TInt res = NewStreamL(strm.Sink(),aMessage,aDbSecurityPolicy,ext);
sl@0: 	return res;
sl@0: 	}
sl@0: 
sl@0: //allocates a free entry if required
sl@0: void CDbsSession::AllocL()
sl@0: 	{
sl@0: 	__ASSERT(TUint(iFree)<=TUint(iSize));
sl@0: 	if (iFree==iSize)
sl@0: 		{
sl@0: 		TInt size=iSize+EIndexGranularity;
sl@0: 		if (size>KDbsIndexLimit)	// maximum number of objects reached
sl@0: 			__LEAVE(KErrNoMemory);
sl@0: 		TEntry* ix=iIx=(TEntry*)User::ReAllocL(iIx,size*sizeof(TEntry));
sl@0: 		iSize=size;
sl@0: 		for (TInt ii=iFree;ii<size;)
sl@0: 			{
sl@0: 			TEntry& e=ix[ii];
sl@0: 			e.iNext=++ii;
sl@0: 			e.iType=TUint8(EDbsFree);
sl@0: 			e.iPolicy = NULL;
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: // Sets the free entry and return a handle to it
sl@0: TInt CDbsSession::DoAdd(TAny* aObject,TDbsType aType, const MPolicy* aPolicy)
sl@0: 	{
sl@0: 	__ASSERT(TUint(iFree)<TUint(iSize));
sl@0: 	__ASSERT(aType!=EDbsFree);
sl@0: 	TInt ix=iFree;
sl@0: 	TEntry& e=iIx[ix];
sl@0: 	__ASSERT(e.Type()==EDbsFree);
sl@0: 	iFree=e.iNext;
sl@0: 	__ASSERT(TUint(iFree)<=TUint(iSize));
sl@0: 	e.iObject=aObject;
sl@0: 	e.iType=TUint8(aType);
sl@0: 	e.iPolicy = aPolicy;
sl@0: 	TInt magic=(e.iMagic+1)&KDbsMagicMask;
sl@0: 	e.iMagic=TUint8(magic);
sl@0: 	return DbsMakeHandle(ix,magic,aType);
sl@0: 	}
sl@0: 
sl@0: // releases the object and the entry to the free pool
sl@0: void CDbsSession::Free(TEntry& aEntry)
sl@0: 	{
sl@0: 	__ASSERT(TUint(iFree)<=TUint(iSize));
sl@0: 	aEntry.Release();
sl@0: 	aEntry.iNext=iFree;
sl@0: 	iFree=&aEntry-&iIx[0];
sl@0: 	__ASSERT(TUint(iFree)<TUint(iSize));
sl@0: 	}
sl@0: 
sl@0: CDbsSession::TEntry& CDbsSession::Object(TInt aHandle)
sl@0: 	{
sl@0: 	TEntry* e=0;
sl@0: 	TInt ix=DbsObjectIndex(aHandle);
sl@0: 	if (TUint(ix)<TUint(iSize))
sl@0: 		{
sl@0: 		e=&iIx[ix];
sl@0: 		if (DbsMakeHandle(ix,e->iMagic,e->Type())!=aHandle)
sl@0: 			e=0;
sl@0: 		}
sl@0: 	__ASSERT_ALWAYS(e && e->iPolicy,::Panic(EDbsBadHandle));
sl@0: 	return *e;
sl@0: 	}
sl@0: 
sl@0: // Reports how many objects are allocated by the client
sl@0: TInt CDbsSession::CountResources()
sl@0: 	{
sl@0: 	TInt alloc=0;
sl@0: 	const TEntry* const base=iIx;
sl@0: 	if (base)
sl@0: 		{
sl@0: 		for (const TEntry* e=base+iSize;--e>=base;)
sl@0: 			{
sl@0: 			if (e->Type()!=EDbsFree)
sl@0: 				++alloc;
sl@0: 			}
sl@0: 		}
sl@0: 	return alloc;
sl@0: 	}
sl@0: 
sl@0: #ifdef __DBDUMP__
sl@0: //Using CDbsSession::Dump() method you can dump the session content
sl@0: //into a stream. Note that the dump works only if you have __DBDUMP__ macro defined.
sl@0: void CDbsSession::Dump()
sl@0: 	{
sl@0: 	RFile dumpFile;
sl@0: 	RFs fileSess;
sl@0: 	TInt err = fileSess.Connect();
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		_LIT(KDumpFileName, "_:\\PUBLIC\\DBMS\\DUMP%X.TXT");
sl@0: 		TFileName dumpFileName(KDumpFileName);
sl@0: 		dumpFileName[0] = 'A' + static_cast<TInt>(RFs::GetSystemDrive());
sl@0: 		
sl@0: 		TBuf<40> buf;
sl@0: 		buf.Format(dumpFileName, this);
sl@0: 		err = fileSess.MkDirAll(buf);
sl@0: 		if(err == KErrNone || err == KErrAlreadyExists)
sl@0: 			{
sl@0: 			err = dumpFile.Replace(fileSess, buf, EFileWrite);
sl@0: 			if(err == KErrNone)
sl@0: 				{
sl@0: 				TEntry* const base = iIx;
sl@0: 				if(base)
sl@0: 					{
sl@0: 					for(TEntry* e=base+iSize;--e>=base;)
sl@0: 						{
sl@0: 						if(e->Type() != EDbsFree)
sl@0: 							{
sl@0: 							e->Dump(dumpFile);
sl@0: 							}
sl@0: 						}
sl@0: 					}//end of - if(base)
sl@0: 				}//end of - if(err == KErrNone)
sl@0: 			}
sl@0: 		}//end of - if(err == KErrNone)
sl@0: 	dumpFile.Close();
sl@0: 	fileSess.Close();
sl@0: 	RDebug::Print(_L("CDbsSession::Dump() error=%d\n"), err);
sl@0: 	__ASSERT_ALWAYS(err == KErrNone, User::Invariant());
sl@0: 	}
sl@0: #endif//__DBDUMP__
sl@0: 
sl@0: /**
sl@0: Reserves a prederfined amount of disk space on aDrive drive. 
sl@0: At the moment the max possible amount, allowed by the file server, is reserved on aDrive drive.
sl@0: 
sl@0: Use this call to ensure that if your "delete records" transaction fails because of "out of
sl@0: disk space" circumstances, you can get an access to the already reserved disk space and
sl@0: complete your transaction successfully the second time.
sl@0: 
sl@0: There is no strong, 100% guarantee, that the reserved disk space will always help the client
sl@0: in "low memory" situations.
sl@0: 
sl@0: This method processes EDbsReserveDriveSpace message.
sl@0: 
sl@0: @param aDrive Drive number to reserve space on
sl@0: @leave KErrArgument Invalid aDrive value.
sl@0: @leave CDbsSessDriveSpace::ReserveL() leaving error codes
sl@0: @see CDbsSessDriveSpace::ReserveL()
sl@0: */
sl@0: void CDbsSession::ReserveDriveSpaceL(TDriveNumber aDrive)
sl@0: 	{
sl@0: 	if(aDrive < EDriveA || aDrive > EDriveZ)
sl@0:         {
sl@0:         __LEAVE(KErrArgument);
sl@0:         }
sl@0:     iSessDriveSpace->ReserveL(aDrive);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: The method frees the reserved by the DBMS session disk space.
sl@0: 
sl@0: This method processes EDbsFreeReservedSpace message.
sl@0: 
sl@0: @param aDrive Drive number, which reserved space has to be freed.
sl@0: @see CDbsSessDriveSpace::Free()
sl@0: @panic Client side panic "DBMS-server 10" in debug mode, if the drive number is invalid.
sl@0: @panic In debug mode there will be a panic with the line number as an error code if 
sl@0:        there is no reserved disk space for aDrive. 
sl@0: @panic In debug mode there will be a panic with the line number as an error code if 
sl@0:        the reserved disk space is granted but not released.
sl@0: */
sl@0: void CDbsSession::FreeReservedSpace(TDriveNumber aDrive)
sl@0:     {
sl@0:     TBool valid = aDrive >= EDriveA && aDrive <= EDriveZ;
sl@0:     __ASSERT_DEBUG(valid, ::Panic(EDbsInvalidDrive));
sl@0:     if(valid)
sl@0:         {
sl@0:         iSessDriveSpace->Free(aDrive);
sl@0:         }
sl@0:     }
sl@0: 
sl@0: /**
sl@0: Grants access to a given area on a given drive for CDbsSession session.
sl@0: Note this session must have reserved space on this particular drive in order to be 
sl@0: granted access to the reserved area.
sl@0: 
sl@0: This method processes EDbsReserveGetAccess message.
sl@0:   
sl@0: @param aDrive Drive number with a reserved disk space, an access to which is requested.
sl@0: @leave KErrArgument Invalid drive.
sl@0: @leave CDbsSessDriveSpace::GrantAccessL() leaving error codes
sl@0: @see CDbsSessDriveSpace::GrantAccessL()
sl@0: */
sl@0: void CDbsSession::GetReserveAccessL(TDriveNumber aDrive)
sl@0: 	{
sl@0: 	if(aDrive < EDriveA || aDrive > EDriveZ)
sl@0:         {
sl@0:         __LEAVE(KErrArgument);
sl@0:         }
sl@0:     iSessDriveSpace->GrantAccessL(aDrive);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Revokes access on a given drive for CDbsSession session.
sl@0: 
sl@0: This method processes EDbsReserveReleaseAccess message.
sl@0:   
sl@0: @param aDrive Drive number with a reserved disk space, the access to which has to be released.
sl@0: @panic Client side panic "DBMS-server 10" in debug mode, if the drive number is invalid.
sl@0: @panic In debug mode there will be a panic with the line number as an error code if 
sl@0:        there is no reserved disk space for aDrive. 
sl@0: @panic In debug mode there will be a panic with the line number as an error code if 
sl@0:        there is no granted access to the reserved disk space. 
sl@0: */
sl@0: void CDbsSession::ReleaseReserveAccess(TDriveNumber aDrive)
sl@0: 	{
sl@0:     TBool valid = aDrive >= EDriveA && aDrive <= EDriveZ;
sl@0:     __ASSERT_DEBUG(valid, ::Panic(EDbsInvalidDrive));
sl@0:     if(valid)
sl@0:         {
sl@0:         iSessDriveSpace->ReleaseAccess(aDrive);
sl@0:         }
sl@0: 	}