sl@0: // Copyright (c) 2005-2010 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: // NTT DOCOMO, INC - Fix for Bug 1915 "SQL server panics when using long column type strings"
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include "SqlSrvMain.h"			//CSqlServer
sl@0: #include "SqlSrvSession.h"		//CSqlSrvSession
sl@0: #include "SqlSrvStatement.h"	//CSqlSrvStatement, HSqlSrvStmtParamBuf
sl@0: #include "SqlSecurityImpl.h"	//CSqlSecurityPolicy
sl@0: #include "SqlSrvUtil.h"			//Global server functions
sl@0: #include "SqlUtil.h"			// config length
sl@0: #include "SqlSrvDriveSpace.h"	//CSqlDriveSpace, RSqlDriveSpaceCol
sl@0: #include "SqlSrvBlob.h"
sl@0: #include "SqlResourceProfiler.h"
sl@0: #include "SqlCompact.h"
sl@0: #include "OstTraceDefinitions.h"
sl@0: #ifdef OST_TRACE_COMPILER_IN_USE
sl@0: #include "SqlSrvSessionTraces.h"
sl@0: #endif
sl@0: #include "SqlTraceDef.h"
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: #pragma BullseyeCoverage off
sl@0: 
sl@0: #ifdef _DEBUG
sl@0: 
sl@0: const TInt KDelayedDbHeapFailureMask = 0x1000;
sl@0: 
sl@0: //Puts the database connection in a test mode
sl@0: //Returns true if the heap failure simulation has to be delayed untill the database is opened
sl@0: //Initialises iDbResourceTestMode and iFailedAllocNumber (if delayed simulation) data members
sl@0: inline TBool CSqlSrvSession::ActivateDbTestMode(TInt aHeapFailureMode, TInt aFailedAllocNumber)
sl@0: 	{
sl@0: 	iDbResourceTestMode = aHeapFailureMode;
sl@0: 	if(aHeapFailureMode & KDelayedDbHeapFailureMask)
sl@0: 		{
sl@0: 		iFailedAllocNumber = aFailedAllocNumber;
sl@0: 		return ETrue;
sl@0: 		}
sl@0: 	return EFalse;
sl@0: 	}
sl@0: 
sl@0: //If the database connection is in a test mode then the macro will reset the heap allocation failure type.
sl@0: //and stop the test mode.
sl@0: inline void CSqlSrvSession::StopDbTestMode()
sl@0: 	{
sl@0: 	if(iDbResourceTestMode)
sl@0: 		{
sl@0: 		iDbResourceTestMode = 0;
sl@0: 		User::__DbgSetAllocFail(RHeap::EUser, RHeap::ENone, 0);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //If the database connection is in a test mode then the function will mark the allocated by the 
sl@0: //server resources.
sl@0: inline void CSqlSrvSession::DbResourceMark()
sl@0: 	{
sl@0: 	if(iDbResourceTestMode)
sl@0: 		{
sl@0: 		ResourceCountMarkStart();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //If the database connection is in a test mode then the macro will check the allocated by the server resources,
sl@0: //comparing their count with the resource count at the moment DbResourceMark() has been called.
sl@0: //The client will be panicked if the resource count now is different.
sl@0: inline void CSqlSrvSession::DbResourceEnd(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	if(iDbResourceTestMode)
sl@0: 		{
sl@0: 		ResourceCountMarkEnd(aMessage);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //Executes the heap simulation failure.
sl@0: inline void CSqlSrvSession::DbSetAllocFail(TInt aHeapFailureMode, TInt aFailedAllocNumber)
sl@0: 	{
sl@0: 	TInt mode = aHeapFailureMode & (KDelayedDbHeapFailureMask - 1);
sl@0: 	if(mode >= RAllocator::EBurstRandom && mode <= RAllocator::EBurstFailNext)
sl@0: 	    {
sl@0: 	    const TUint KBurst = 50; 
sl@0: 	    User::__DbgSetBurstAllocFail(RHeap::EUser, static_cast <RHeap::TAllocFail> (mode), aFailedAllocNumber, KBurst);
sl@0: 	    }
sl@0: 	else
sl@0: 	    {
sl@0:         User::__DbgSetAllocFail(RHeap::EUser, static_cast <RHeap::TAllocFail> (mode), aFailedAllocNumber);
sl@0: 	    }
sl@0: 	}
sl@0: 	
sl@0: //Executes the delayed heap simulation failure, if the connection is in test mode
sl@0: inline void CSqlSrvSession::DbSetDelayedAllocFail()
sl@0: 	{
sl@0: 	if(iDbResourceTestMode & KDelayedDbHeapFailureMask)
sl@0: 		{
sl@0: 	    TInt mode = iDbResourceTestMode & (KDelayedDbHeapFailureMask - 1);
sl@0: 	    if(mode >= RAllocator::EBurstRandom && mode <= RAllocator::EBurstFailNext)
sl@0: 	        {
sl@0: 	        const TUint KBurst = 50; 
sl@0: 	        User::__DbgSetBurstAllocFail(RHeap::EUser, static_cast <RHeap::TAllocFail> (mode), iFailedAllocNumber, KBurst);
sl@0: 	        }
sl@0: 	    else
sl@0: 	        {
sl@0: 	        User::__DbgSetAllocFail(RHeap::EUser, static_cast <RHeap::TAllocFail> (mode), iFailedAllocNumber);
sl@0: 	        }
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: #else //_DEBUG
sl@0: 
sl@0: inline TBool CSqlSrvSession::ActivateDbTestMode(TInt, TInt)
sl@0: 	{
sl@0: 	return EFalse;
sl@0: 	}
sl@0: 
sl@0: inline void CSqlSrvSession::StopDbTestMode()
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: inline void CSqlSrvSession::DbResourceMark()
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: inline void CSqlSrvSession::DbResourceEnd(const RMessage2&)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: inline void CSqlSrvSession::DbSetAllocFail(TInt, TInt)
sl@0: 	{
sl@0: 	}
sl@0: 	
sl@0: inline void CSqlSrvSession::DbSetDelayedAllocFail()
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: #endif//_DEBUG
sl@0: 
sl@0: #pragma BullseyeCoverage on
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: /**
sl@0: Searches aContainer for an object identified by aHandle.
sl@0: If such object exists, a reference to it is returned.
sl@0: If there is no object, the client gets a panic.
sl@0: 
sl@0: @panic SqlDb 4 Client panic. Invalid aHandle parameter value (zero, negative or out of range).
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: template <class T> T& SqlSessObjFind(RDbObjContainer<T>& aContainer, TInt aHandle, const RMessage2& aMessage)
sl@0: 	{
sl@0: 	T* obj = aContainer.Find(aHandle);
sl@0: 	__SQLPANIC_CLIENT2(obj != NULL, aMessage, ESqlPanicBadArgument);
sl@0: 	return *obj;
sl@0: 	}
sl@0: 
sl@0: //This function return true, if there is free disk space on drive where the main database file is.
sl@0: static TBool HasFreeDiskSpace(RFs& aFs, TDriveNumber aDrive)
sl@0: 	{
sl@0: 	TVolumeInfo volInfo;
sl@0: 	TInt err = aFs.Volume(volInfo, aDrive);
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		const TInt64 KDiskSpaceThreshold = 1024 * 4;
sl@0: 		return volInfo.iFree > KDiskSpaceThreshold;
sl@0: 		}
sl@0: 	return ETrue;
sl@0: 	}
sl@0: 	
sl@0: //If aError is KSqlErrFull and  there is no free disk space, then KSqlErrFull is converted to KErrDiskFull
sl@0: //and returned.
sl@0: static TInt ConvertSqlFull2DiskFullErr(TInt aError, RFs& aFs, TDriveNumber aDrive)
sl@0: 	{
sl@0: 	if(aError == KSqlErrFull && !HasFreeDiskSpace(aFs, aDrive))
sl@0: 		{
sl@0: 		aError = KErrDiskFull;
sl@0: 		SQL_TRACE_SESSION(OstTrace1(TRACE_INTERNALS, CONVERTSQLFULL2DISKFULLERRROR, "0;ConvertSqlFull2DiskFullErr;aError=KSqlErrFull;!HasFreeDiskSpace();aDrive=%d", (TInt)aDrive));
sl@0: 		}
sl@0: 	return aError;
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: /**
sl@0: Creates a new instance of CSqlSrvSession class.
sl@0: 
sl@0: This function shall never be called directly.
sl@0: It is CSqlServer responsibility to create a new server side session object as a responce to the criation of a
sl@0: client side session instance.
sl@0: 
sl@0: @return A pointer to the created CSqlSrvSession instance.
sl@0: 
sl@0: @leave KErrNoMemory, an out of memory condition has occurred;
sl@0: 
sl@0: @see CSqlServer
sl@0: @see CSqlServer::NewSessionL()
sl@0: */
sl@0: CSqlSrvSession* CSqlSrvSession::NewL()
sl@0: 	{
sl@0: 	SQL_TRACE_SESSION(OstTrace0(TRACE_INTERNALS, CSQLSRVSESSION_NEWL_ENTRY, "Entry;0;CSqlSrvSession::NewL"));
sl@0: 	CSqlSrvSession* self = new (ELeave)	CSqlSrvSession;
sl@0: 	CleanupStack::PushL(self);
sl@0: 	self->ConstructL();
sl@0: 	CleanupStack::Pop(self);
sl@0: 	SQL_TRACE_SESSION(OstTrace1(TRACE_INTERNALS, CSQLSRVSESSION_NEWL_EXIT, "Exit;0x%X;CSqlSrvSession::NewL", (TUint)self));
sl@0: 	return self;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Frees the allocated by CSqlSrvSession instance resources and memory.
sl@0: */
sl@0: CSqlSrvSession::~CSqlSrvSession()
sl@0: 	{
sl@0: 	SQL_TRACE_SESSION(OstTraceExt2(TRACE_INTERNALS, CSQLSRVSESSION_CSQLSRVSESSION2_ENTRY, "Entry;0x%X;CSqlSrvSession::~CSqlSrvSession;iDatabase=0x%X", (TUint)this, (TUint)iDatabase));
sl@0: 	StopDbTestMode();
sl@0: 	DbFreeReservedSpace();
sl@0: 	iIpcStreams.Close();
sl@0: 	iStatements.Close();
sl@0: 	delete iDatabase;
sl@0: 	SQL_TRACE_SESSION(OstTrace1(TRACE_INTERNALS, CSQLSRVSESSION_CSQLSRVSESSION2_EXIT, "Exit;0x%X;CSqlSrvSession::~CSqlSrvSession", (TUint)this));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Receives and dispatches all client side requests.
sl@0: 
sl@0: CSession2::ServiceL() implementation.
sl@0: 
sl@0: @param aMessage Client message containing the request (function code and data)
sl@0: 
sl@0: @leave The function may leave with some database specific 
sl@0: 	   errors categorised as ESqlDbError or system-wide error codes.
sl@0: 
sl@0: @see CSession2::ServiceL()
sl@0: */
sl@0: void CSqlSrvSession::ServiceL(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	TSqlSrvFunction funcCode = ESqlSrvTestBase;
sl@0: 	TInt handle = 0;
sl@0: 	Extract(aMessage, funcCode, handle);
sl@0: 	TInt retCode = KErrNone;
sl@0: 	if(funcCode >= ESqlSrvDbBase)
sl@0: 		{
sl@0: 		SQLPROFILER_REPORT_IPC(ESqlIpcRq, 0);
sl@0: 		}
sl@0: 	__SQLTRACE_SESSIONEXPR(++iIpcCallCounter);
sl@0:     SQL_TRACE_SESSION(OstTraceExt4(TRACE_INTERNALS, CSQLSRVSESSION_SERVICEL_ENTRY, "Entry;0x%X;CSqlSrvSession::ServiceL;aMessage.Handle()=0x%X;funcCode=0x%X;iIpcCallCounter=%u", (TUint)this, (TUint)aMessage.Handle(), (TUint)funcCode, iIpcCallCounter));
sl@0: 	SQLPROFILER_IPC_START(iIpcCallCounter, iDatabase ? (TUint)iDatabase->RawDbHandle() : 0);
sl@0: 	switch(funcCode)
sl@0: 		{
sl@0: 		//////////////////////  resource check operations  ///////////////////////////
sl@0: 		case ESqlSrvResourceMark:
sl@0: 			ResourceCountMarkStart();
sl@0: 			break;
sl@0: 		case ESqlSrvResourceCheck:
sl@0: 			ResourceCountMarkEnd(aMessage);
sl@0: 			break;
sl@0: 		case ESqlSrvResourceCount:
sl@0: 			retCode = CountResources();					//Returns the recourse count
sl@0: 			break;
sl@0: 		case ESqlSrvSetDbHeapFailure:
sl@0: 			if(ActivateDbTestMode(aMessage.Int0(), aMessage.Int1()))
sl@0: 				{
sl@0: 				break;	
sl@0: 				}
sl@0: 		case ESqlSrvSetHeapFailure:
sl@0: 			DbSetAllocFail(aMessage.Int0(), aMessage.Int1());
sl@0: 			break;
sl@0: 		//////////////////////   profiling operations  //////////////////////////////////
sl@0: 		case ESqlSrvProfilerStart:
sl@0: 			TSqlSrvResourceProfiler::StartL(aMessage);
sl@0: 			break;
sl@0: 		case ESqlSrvProfilerStop:
sl@0: 			TSqlSrvResourceProfiler::StopL(aMessage);
sl@0: 			break;
sl@0: 		case ESqlSrvProfilerReset:
sl@0: 			TSqlSrvResourceProfiler::ResetL(aMessage);
sl@0: 			break;
sl@0: 		case ESqlSrvProfilerQuery:
sl@0: 			ProfilerQueryL(aMessage);
sl@0: 			break;
sl@0: 		//////////////////////   database operations //////////////////////////////////
sl@0: 		case ESqlSrvDbCreate:
sl@0: 		case ESqlSrvDbCreateSecure:
sl@0: 		case ESqlSrvDbOpen:
sl@0: 			DbResourceMark();
sl@0: 			DbCreateObjectL(aMessage, funcCode);
sl@0: 			DbSetDelayedAllocFail();
sl@0: 			break;
sl@0: 		case ESqlSrvDbOpenFromHandle:
sl@0: 			DbResourceMark();
sl@0: 			DbCreateObjectFromHandleL(aMessage);
sl@0: 			DbSetDelayedAllocFail();
sl@0: 			break;
sl@0: 		case ESqlSrvDbAttach:
sl@0: 			DbAttachL(aMessage);
sl@0: 			break;
sl@0: 		case ESqlSrvDbAttachFromHandle:
sl@0: 			DbAttachFromHandleL(aMessage);
sl@0: 			break;
sl@0: 		case ESqlSrvDbDetach:
sl@0: 			DbDetachL(aMessage);
sl@0: 			break;
sl@0: 		case ESqlSrvDbClose:
sl@0: 			DbDestroyObject();
sl@0: 			DbResourceEnd(aMessage);
sl@0: 			StopDbTestMode();
sl@0: 			break;
sl@0: 		case ESqlSrvDbCopy:
sl@0: 			DbResourceMark();
sl@0: 			DbCopyFileL(aMessage);
sl@0: 			break;
sl@0: 		case ESqlSrvDbDelete:
sl@0: 			DbResourceMark();
sl@0: 			DbDeleteFileL(aMessage);
sl@0: 			break;
sl@0: 		case ESqlSrvLastErrorMsg:
sl@0: 			retCode = DbLastErrorMessageL(aMessage);//may return that the client buffer is not big enough for the message
sl@0: 			break;
sl@0: 		case ESqlSrvDbLastInsertedRowId:
sl@0: 			DbLastInsertedRowIdL(aMessage);
sl@0: 			break;
sl@0: 		case ESqlSrvDbExec8:
sl@0: 			retCode = DbExecSql8L(aMessage);		//returns the count of affected records
sl@0: 			break;
sl@0: 		case ESqlSrvDbExec16:
sl@0: 			retCode = DbExecSql16L(aMessage);	//returns the count of affected records
sl@0: 			break;
sl@0: 		case ESqlSrvDbSetIsolationLevel:
sl@0: 			DbSetIsolationLevelL(aMessage);
sl@0: 			break;
sl@0: 		case ESqlSrvDbGetSecurityPolicy:
sl@0: 			retCode = DbGetSecurityPolicyL(aMessage);//may return that the client buffer is not big enough for the security policy
sl@0: 			break;
sl@0: 		case ESqlSrvDbScalarFullSelect8:
sl@0: 			retCode = DbScalarFullSelectL(aMessage, EFalse);//may return that the client buffer is not big enough for the column value
sl@0: 			break;
sl@0: 		case ESqlSrvDbScalarFullSelect16:
sl@0: 			retCode = DbScalarFullSelectL(aMessage, ETrue);//may return that the client buffer is not big enough for the column value
sl@0: 			break;
sl@0: 		case ESqlSrvDbInTransaction:
sl@0: 			retCode = DbInTransaction(aMessage);	//Returns whether the database in in transaction or not - true/false
sl@0: 			break;
sl@0: 		case ESqlSrvDbSize:
sl@0: 			retCode = DbSizeL(aMessage);			//Returns the database size
sl@0: 			break;
sl@0: 		case ESqlSrvDbSize2:
sl@0: 			DbSize2L(aMessage);
sl@0: 			break;
sl@0: 		case ESqlSrvDbCompact:
sl@0: 			retCode = DbCompactL(aMessage);			//Returns the amount of the removed free database space
sl@0: 			break;
sl@0: 		//////////////////////   reserved drive space management ////////////////////////
sl@0: 		case ESqlSrvDbReserveDriveSpace:
sl@0: 			__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 			DbReserveDriveSpaceL();
sl@0: 			break;
sl@0: 		case ESqlSrvDbFreeReservedSpace:
sl@0: 			__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 			DbFreeReservedSpace();
sl@0: 			break;
sl@0: 		case ESqlSrvDbGetReserveAccess:
sl@0: 			__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 			DbGetReserveAccessL();
sl@0: 			break;
sl@0: 		case ESqlSrvDbReleaseReserveAccess:
sl@0: 			__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 			DbReleaseReserveAccess();
sl@0: 			break;
sl@0: 		//////////////////////   BLOB source ///////////////////////////////////////////
sl@0: 		case ESqlSrvDbBlobSource:
sl@0: 			retCode = DbBlobSourceL(aMessage);		//Returns the BLOB handle
sl@0: 			break;
sl@0: 		//////////////////////   statement operations //////////////////////////////////
sl@0: 		case ESqlSrvStmtPrepare8:
sl@0: 			retCode = StmtPrepareL(aMessage, EFalse);//returns the statement handle
sl@0: 			break;
sl@0: 		case ESqlSrvStmtPrepare16:
sl@0: 			retCode = StmtPrepareL(aMessage, ETrue);//returns the statement handle
sl@0: 			break;
sl@0: 		case ESqlSrvStmtClose:
sl@0: 			iStatements.Remove(handle);
sl@0: 			break;
sl@0: 		case ESqlSrvStmtReset:
sl@0: 			retCode = ::SqlSessObjFind(iStatements, handle, aMessage).Reset();//May return that the statement has expired
sl@0: 			break;
sl@0: 		case ESqlSrvStmtExec:
sl@0: 		case ESqlSrvStmtAsyncExec:
sl@0: 		case ESqlSrvStmtBindExec:
sl@0: 		case ESqlSrvStmtAsyncBindExec:
sl@0: 			retCode = StmtExecL(aMessage, handle, funcCode);//returns the count of affected records
sl@0: 			break;
sl@0: 		case ESqlSrvStmtNext:
sl@0: 		case ESqlSrvStmtBindNext:
sl@0: 			retCode = StmtNextL(aMessage, handle, funcCode);//returns a non-negative number if the client side buffer is too small
sl@0: 			break;
sl@0: 		case ESqlSrvStmtColumnNames:
sl@0: 		case ESqlSrvStmtParamNames:
sl@0: 			retCode = StmtNamesL(aMessage, handle, funcCode);//returns a non-negative number if the client side buffer is too small
sl@0: 			break;
sl@0: 		case ESqlSrvStmtColumnSource:
sl@0: 			retCode = StmtColumnSourceL(aMessage, handle);//returns an IPC stream handle
sl@0: 			break;
sl@0: 		case ESqlSrvStmtBinParamSink:
sl@0: 		case ESqlSrvStmtTxtParamSink16:
sl@0: 			retCode = StmtParamSinkL(aMessage, handle, funcCode);//returns an IPC stream handle
sl@0: 			break;
sl@0: 		case ESqlSrvStmtBufFlat:
sl@0: 			StmtGetBufFlatL(aMessage, handle);
sl@0: 			break;
sl@0: 		case ESqlSrvStmtColumnValue:
sl@0: 			StmtColumnValueL(aMessage, handle);
sl@0: 			break;
sl@0: 		case ESqlSrvStmtDeclColumnTypes:
sl@0: 			retCode = StmtDeclColumnTypesL(aMessage, handle);
sl@0: 			break;
sl@0: 		//////////////////////   stream operations //////////////////////////////////
sl@0: 		case ESqlSrvStreamRead:
sl@0: 			retCode = ::SqlSessObjFind(iIpcStreams, handle, aMessage).ReadL(aMessage);
sl@0: 			break;
sl@0: 		case ESqlSrvStreamWrite:
sl@0: 			::SqlSessObjFind(iIpcStreams, handle, aMessage).WriteL(aMessage);
sl@0: 			break;
sl@0: 		case ESqlSrvStreamSize:
sl@0: 			retCode = ::SqlSessObjFind(iIpcStreams, handle, aMessage).SizeL();
sl@0: 			break;
sl@0: 		case ESqlSrvStreamSynch:
sl@0: 			::SqlSessObjFind(iIpcStreams, handle, aMessage).SynchL();
sl@0: 			break;
sl@0: 		case ESqlSrvStreamClose:
sl@0: 			iIpcStreams.Remove(handle);
sl@0: 			break;
sl@0: 		//////////////////////                     //////////////////////////////////
sl@0: 		default:	
sl@0: 			retCode = KErrNotSupported;
sl@0: 			break;
sl@0: 		}
sl@0: 	Server().Compactor().RestartTimer();
sl@0: 	Server().MinimizeBuffers();		
sl@0: 	if(!aMessage.IsNull())
sl@0: 		{
sl@0: 		aMessage.Complete(retCode);
sl@0: 		}
sl@0: 	SQL_TRACE_SESSION(OstTraceExt4(TRACE_INTERNALS, CSQLSRVSESSION_SERVICEL_EXIT, "Exit;0x%X;CSqlSrvSession::ServiceL;funcCode=0x%X;retCode=%d;iIpcCallCounter=%u", (TUint)this, (TUint)funcCode, retCode, iIpcCallCounter));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: If aError is KErrBadDescriptor, then panic the client, else - default error handling.
sl@0: KErrBadDescriptor error may be thrown from "message write" operations, if the client supplied a bad
sl@0: descriptor to the server.
sl@0: */
sl@0: void CSqlSrvSession::ServiceError(const RMessage2& aMessage, TInt aError)
sl@0:  	{
sl@0: 	SQL_TRACE_SESSION(OstTraceExt4(TRACE_INTERNALS, CSQLSRVSESSION_SERVICEERROR_ENTRY, "Entry;0x%X;CSqlSrvSession::ServiceError;aMessage.Function()=0x%X;aError=%d;iIpcCallCounter=%u", (TUint)this, (TUint)aMessage.Function(), aError, iIpcCallCounter));
sl@0: 	Server().MinimizeBuffers();		
sl@0: 	aError = ::ConvertSqlFull2DiskFullErr(aError, Server().FileData().Fs(), iDrive);
sl@0:  	if(aError == KErrBadDescriptor)
sl@0:  		{
sl@0: 		//The __SQLPANIC_CLIENT() macro cannot be used here because it calls a leaving function. A leaving call
sl@0: 		//from a leaving call will terminate the server.
sl@0: 		_LIT(KPanicCategory, "SqlDb");
sl@0: 		aMessage.Panic(KPanicCategory, ESqlPanicBadDescriptor);
sl@0:  		}
sl@0:  	SQLPROFILER_IPC_ERROR(iIpcCallCounter, static_cast <TSqlSrvFunction> (KSqlSrvFunctionMask & aMessage.Function()), 
sl@0:  	       iDatabase ? (TUint)iDatabase->RawDbHandle() : 0, aError);
sl@0:  	CSession2::ServiceError(aMessage, aError);
sl@0:  	SQL_TRACE_SESSION(OstTraceExt3(TRACE_INTERNALS, CSQLSRVSESSION_SERVICEERROR_EXIT, "Exit;0x%X;CSqlSrvSession::ServiceError;aMessage.Function()=0x%X;iIpcCallCounter=%u", (TUint)this, (TUint)aMessage.Function(), iIpcCallCounter));
sl@0:    	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: ////////////////////////////          Profiler  operations           ///////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: #pragma BullseyeCoverage off
sl@0: 
sl@0: /**
sl@0: Retrieves the counter values for the specified profiling counter.
sl@0: 
sl@0: @leave  KErrNone, the operation completed successfully,
sl@0:         KErrOverflow, the receiving buffer size is too small;
sl@0:                   One of the other system-wide error codes may also be returned.
sl@0: 
sl@0: @see TSqlResourceProfiler
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0:  - Arg 0: [in]  profiling counter type, one of the TSqlResourceProfiler::TSqlCounter enum item values.
sl@0:  - Arg 1: [in]  the size of the buffer for the profiling counter values.
sl@0:  - Arg 2: [out] the buffer for the profiling counter values.
sl@0: 
sl@0: @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).
sl@0: */
sl@0: void CSqlSrvSession::ProfilerQueryL(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 	if(aMessage.Int0() == TSqlResourceProfiler::ESqlCounterConfig)
sl@0: 		{
sl@0: 		const TInt KConfigBufLen = 128;
sl@0: 		if(aMessage.Int1() < KConfigBufLen)
sl@0: 			{
sl@0: 			__SQLLEAVE(KErrOverflow);	
sl@0: 			}
sl@0: 		TBuf8<KConfigBufLen> res;
sl@0: 		iDatabase->QueryConfigL(res);
sl@0: 		aMessage.WriteL(2, res);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		TSqlSrvResourceProfiler::QueryL(aMessage);
sl@0: 		}				
sl@0: 	}
sl@0: 
sl@0: #pragma BullseyeCoverage on
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: ////////////////////////////          Database operations           ///////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: /**
sl@0: Processes the request for creating/opening a database.
sl@0: 
sl@0: The function initializes iDatabase and iDrive data members.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]  database file name length in 16-bit characters
sl@0: Arg 1: [in]  database file name
sl@0: Arg 2: [in]  PPPPCCCC, where PPPP is the security policy length, CCCC is the config string length.
sl@0: Arg 3: [in]  security policies buffer | config string
sl@0: 
sl@0: @panic SqlDb 1 Client panic. iDatabase is not NULL (it has been created already)
sl@0: @panic SqlDb 4 Client panic. Negative or too big config string length
sl@0: @panic SqlDb 4 Client panic. Negative security policy length, or zero length if the request is to create a secure database 
sl@0: */
sl@0: void CSqlSrvSession::DbCreateObjectL(const RMessage2& aMessage, TSqlSrvFunction aFunction)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(!iDatabase, aMessage, ESqlPanicObjExists);
sl@0: 	const TInt KSecurityPolicyLen = (aMessage.Int2() & 0x7fff0000) >> 16;
sl@0:     //If the security policy length is negative then this is a programming error.
sl@0:     __SQLPANIC_CLIENT(KSecurityPolicyLen >= 0, aMessage, ESqlPanicBadArgument);
sl@0: 	const TInt KConfigStringLen = aMessage.Int2() & 0xffff;
sl@0: 	//If KConfigStringLen is invalid then this is a programming error. 
sl@0: 	//If the client sends a too big config string - this is handled in the client side session.
sl@0:     __SQLPANIC_CLIENT((TUint)KConfigStringLen <= KSqlSrvMaxConfigStrLen, aMessage, ESqlPanicBadArgument);
sl@0: 	RBuf8 securityAndConfigBuf;
sl@0: 	CleanupClosePushL(securityAndConfigBuf);
sl@0: 	if((KSecurityPolicyLen + KConfigStringLen) > 0)
sl@0: 	    {
sl@0: 	    securityAndConfigBuf.CreateL(KSecurityPolicyLen + KConfigStringLen);
sl@0:         aMessage.ReadL(3, securityAndConfigBuf); 
sl@0:         SQLPROFILER_REPORT_IPC(ESqlIpcRead, (KSecurityPolicyLen + KConfigStringLen));
sl@0: 	    }
sl@0: 	TSqlSrvFileData& fileData = Server().FileData();
sl@0: 	TPtrC8 configStr(KNullDesC8);
sl@0: 	if(KConfigStringLen > 0)
sl@0: 	    {
sl@0: 	    configStr.Set(securityAndConfigBuf.Mid(KSecurityPolicyLen));//the first part of the buffer is for the security policies
sl@0: 	    }
sl@0: 	fileData.SetL(aMessage, aMessage.Int0(), 1, &configStr);
sl@0: 	iDrive = fileData.Drive();
sl@0: 	switch(aFunction)
sl@0: 		{
sl@0: 		case ESqlSrvDbCreate:
sl@0: 			if(fileData.IsSecureFileNameFmt())
sl@0: 				{
sl@0: 				__SQLLEAVE(KErrArgument);	
sl@0: 				}
sl@0: 			iDatabase = CSqlSrvDatabase::CreateL(fileData);
sl@0: 			break;
sl@0: 		case ESqlSrvDbCreateSecure:
sl@0: 			{
sl@0: 		    __SQLPANIC_CLIENT(KSecurityPolicyLen > 0, aMessage, ESqlPanicBadArgument);
sl@0: 			if(!fileData.IsSecureFileNameFmt())
sl@0: 				{
sl@0: 				__SQLLEAVE(KErrArgument);	
sl@0: 				}
sl@0: 			//The caller can create a secure database which secure UID matches his secure UID.
sl@0: 			if(fileData.SecureUid() != aMessage.SecureId())
sl@0: 				{
sl@0: 				__SQLLEAVE(KErrPermissionDenied);	
sl@0: 				}
sl@0: 			CSqlSecurityPolicy* policy = CreateSecurityPolicyL(securityAndConfigBuf.Left(KSecurityPolicyLen));
sl@0: 			iDatabase = CSqlSrvDatabase::CreateSecureL(fileData, policy);
sl@0: 			}
sl@0: 			break;
sl@0: 		case ESqlSrvDbOpen:
sl@0: 			iDatabase = CSqlSrvDatabase::OpenL(fileData);
sl@0: 			break;
sl@0: 		default:
sl@0: 			__SQLLEAVE(KErrArgument);	
sl@0: 			break;
sl@0: 		}
sl@0: 	CleanupStack::PopAndDestroy(&securityAndConfigBuf);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Processes the request for opening a database from file handle.
sl@0: The server expects that the database to be opened/created is in the applicatio's private data cage.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0:  - Arg 0: [in]  The 32 bits of the argument are used as follow:
sl@0:  @code
sl@0:  MSB                                                                                 LSB
sl@0:  31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
sl@0:  Ro Cr  C  C  C  C  C  C  C  C  C  C  C  C  C  C  F  F  F  F  F  F F F F F F F F F F F 
sl@0:  @endcode
sl@0:  Where:
sl@0:  @code
sl@0:   - "Ro" - read-only flag, true if the file is read-only;
sl@0:   - "Cr" - create/open flag, true if the file was created, false if the file was opened;
sl@0:   - "C"  - config string length in 16-bit characters;
sl@0:   - "F"  - database file name length in 16-bit characters;
sl@0:  @endcode
sl@0:  - Arg 1: [in]  database file name | config string
sl@0:  - Arg 2: [in]  file session handle
sl@0:  - Arg 3: [in]  database file handle
sl@0: 
sl@0: @panic SqlDb 1 Client panic. iDatabase is not NULL (it has been created already)
sl@0: */
sl@0: void CSqlSrvSession::DbCreateObjectFromHandleL(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(!iDatabase, aMessage, ESqlPanicObjExists);
sl@0: 	const TBool KReadOnly = (aMessage.Int0() & 0x80000000) != 0;
sl@0: 	const TBool KCreated = (aMessage.Int0() & 0x40000000) != 0;
sl@0: 	const TInt KDbFileNameLen = aMessage.Int0() & 0x0000FFFF;
sl@0: 	const TInt KConfigStringLen = (aMessage.Int0() & 0x3FFF0000) >> 16;
sl@0:     __SQLPANIC_CLIENT((TUint)KConfigStringLen <= KSqlSrvMaxConfigStrLen, aMessage, ESqlPanicBadArgument);
sl@0:     __SQLPANIC_CLIENT((TUint)KDbFileNameLen <= KMaxFileName, aMessage, ESqlPanicBadArgument);
sl@0: 	TDes16& buffer = Server().GetBuf16L(KDbFileNameLen + KConfigStringLen);
sl@0: 	aMessage.ReadL(1, buffer);
sl@0: 	SQLPROFILER_REPORT_IPC(ESqlIpcRead, ((KDbFileNameLen + KConfigStringLen) * sizeof(TText)));
sl@0: 	TFileName dbFileName;
sl@0: 	dbFileName.Copy(buffer.LeftTPtr(KDbFileNameLen));
sl@0: 	TBuf8<KSqlSrvMaxConfigStrLen> configStr;
sl@0: 	if(KConfigStringLen > 0)
sl@0: 		{
sl@0: 		configStr.Copy(buffer.MidTPtr(KDbFileNameLen, KConfigStringLen));
sl@0: 		}
sl@0: 	TSqlSrvFileData& fileData = Server().FileData();
sl@0: 	fileData.SetFromHandleL(aMessage, dbFileName, KCreated, KReadOnly, &configStr);
sl@0: 	iDrive = fileData.Drive();
sl@0: 	iDatabase = CSqlSrvDatabase::OpenL(fileData);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Processes the request for copying a database.
sl@0: 
sl@0: Only the database creator can copy the database if the database is a secure database.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]  source database file name length
sl@0: Arg 1: [in]  source database file name
sl@0: Arg 2: [in]  destination database file name length
sl@0: Arg 3: [in]  destination database file name
sl@0: */
sl@0: void CSqlSrvSession::DbCopyFileL(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	const TInt KDbCnt = 2;											//"2" - because we have 2 dbases: src and dest
sl@0: 	const TInt KSrcDbIdx = 0;
sl@0: 	const TInt KDestDbIdx = 1;
sl@0: 	TInt fileNameLen[KDbCnt] = {aMessage.Int0(), aMessage.Int2()};
sl@0: 	TSqlSrvFileData& fileData = Server().FileData();
sl@0: 	TUint dbSecureFlag[KDbCnt];
sl@0: 	TUid  dbSID[KDbCnt] = {KNullUid, KNullUid};
sl@0: 	TFileName dbFileName[KDbCnt];
sl@0: 	//Initialize dbSecureFlag[], dbSID[] and dbFileName[] array elements
sl@0: 	for(TInt i=0;i<KDbCnt;++i)									
sl@0: 		{
sl@0: 		fileData.SetL(aMessage, fileNameLen[i], i * KDbCnt + 1);	//"i * KDbCnt + 1" is the RMessage2 parameter number: 1 for src db, 3 for dest db
sl@0: 		dbSecureFlag[i] = fileData.IsSecureFileNameFmt() ? 1 : 0;
sl@0: 		if(dbSecureFlag[i])
sl@0: 			{
sl@0: 			dbSID[i] = fileData.SecureUid();
sl@0: 			}
sl@0: 		dbFileName[i].Copy(fileData.FileName());
sl@0: 		}
sl@0: 	//It is not allowed to copy non-secure to a secure or secure to a non-secure database.
sl@0: 	if(dbSecureFlag[KSrcDbIdx] ^ dbSecureFlag[KDestDbIdx])
sl@0: 		{
sl@0: 		__SQLLEAVE(KErrPermissionDenied);	
sl@0: 		}
sl@0: 	//If this is a secure database "copy" operation, then...
sl@0: 	if(dbSecureFlag[KSrcDbIdx])
sl@0: 		{
sl@0: 		TUid callerSid = aMessage.SecureId();
sl@0: 		//A secure database can be copied only by its owner (database SID matches caller SID).
sl@0: 		if(callerSid != dbSID[KSrcDbIdx] || callerSid != dbSID[KDestDbIdx])
sl@0: 			{
sl@0: 			__SQLLEAVE(KErrPermissionDenied);	
sl@0: 			}
sl@0: 		}
sl@0: 	//Copy the database
sl@0: 	CFileMan* fileMan = CFileMan::NewL(fileData.Fs());
sl@0: 	CleanupStack::PushL(fileMan);
sl@0: 	__SQLLEAVE_IF_ERROR(fileMan->Copy(dbFileName[KSrcDbIdx], dbFileName[KDestDbIdx]));
sl@0: 	//"Copy" operation executed without errors. Now it is a time to turn off the read-only
sl@0: 	//flag of the target file (which may be on if the source file is on a read-only drive)
sl@0: 	__SQLLEAVE_IF_ERROR(fileData.Fs().SetAtt(dbFileName[KDestDbIdx], 0, KEntryAttReadOnly));
sl@0: 	CleanupStack::PopAndDestroy(fileMan);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Processes the request for deleting a database.
sl@0: 
sl@0: Only the database creator can delete the database if the database is a secure database.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]  database file name length
sl@0: Arg 1: [in]  database file name
sl@0: */
sl@0: void CSqlSrvSession::DbDeleteFileL(const RMessage2& aMessage)
sl@0: 	{	
sl@0: 	TSqlSrvFileData& fileData = Server().FileData();
sl@0: 	fileData.SetL(aMessage, aMessage.Int0(), 1);
sl@0: 	if(fileData.IsSecureFileNameFmt())
sl@0: 		{
sl@0: 		//A secure database can be deleted only by its owner (database SID matches caller SID).
sl@0: 		if(fileData.SecureUid() != aMessage.SecureId())
sl@0: 			{
sl@0: 			__SQLLEAVE(KErrPermissionDenied);	
sl@0: 			}
sl@0: 		}
sl@0: 	__SQLTRACE_SESSIONVAR(TPtrC fname(fileData.FileName()));
sl@0: 	SQL_TRACE_SESSION(OstTraceExt2(TRACE_INTERNALS, CSQLSRVSESSION_DBDELETEFILEL, "0x%X;CSqlSrvSession::DbDeleteFileL;file='%S'", (TUint)this, __SQLPRNSTR(fname)));
sl@0: 	__SQLLEAVE_IF_ERROR(fileData.Fs().Delete(fileData.FileName()));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Processes the request for retrieving the last error message.
sl@0: 
sl@0: If the client side buffer size is not big enough, the function returns the needed 
sl@0: buffer size + KSqlClientBufOverflowCode.
sl@0: In this case the client must increase the buffer and try again to get the message.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]		Message buffer length in 16-bit characters
sl@0: Arg 1: [in/out]	Message buffer
sl@0: 
sl@0: @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).
sl@0: @panic SqlDb 4 Client panic. Negative client message buffer length (Arg 0).
sl@0: */
sl@0: TInt CSqlSrvSession::DbLastErrorMessageL(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 	TPtrC msg = iDatabase->LastErrorMessage();
sl@0: 	TInt msgLen = msg.Length();
sl@0: 	TInt bufSize = aMessage.Int0();
sl@0: 	__SQLPANIC_CLIENT(bufSize >= 0, aMessage, ESqlPanicBadArgument);
sl@0: 	if(msgLen <= bufSize)
sl@0: 		{
sl@0: 		aMessage.WriteL(1, msg);
sl@0: 		SQLPROFILER_REPORT_IPC(ESqlIpcWrite, (msgLen * sizeof(TText)));
sl@0: 		return 0;
sl@0: 		}
sl@0: 	return msgLen + KSqlClientBufOverflowCode;
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0: Processes the request for retrieving the last inserted ROWID of this database connection.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in/out]	Receiving buffer
sl@0: 
sl@0: @panic SqlDb 2 Client panic. The database object is not yet created yet (iDatabase is NULL).
sl@0: */
sl@0: void CSqlSrvSession::DbLastInsertedRowIdL(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 	TInt64 rowid = iDatabase->LastInsertedRowId();
sl@0: 	aMessage.WriteL(0, TPtrC8(reinterpret_cast <const TUint8*> (&rowid), sizeof(rowid)));
sl@0: 	SQLPROFILER_REPORT_IPC(ESqlIpcWrite, sizeof(rowid));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Processes the request for retrieving the database security policies.
sl@0: 
sl@0: The method leaves with KErrNotSupported if the database is not a secure database.
sl@0: 
sl@0: If the client side buffer size is not big enough, the function returns the needed 
sl@0: buffer size + KSqlClientBufOverflowCode.
sl@0: In this case the client must increase the buffer and try again to get the database security policy.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]		security policy buffer length in bytes
sl@0: Arg 1: [in/out]	buffer for the database security policies
sl@0: 
sl@0: @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).
sl@0: */
sl@0: TInt CSqlSrvSession::DbGetSecurityPolicyL(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 	const CSqlSecurityPolicy* securityPolicy = iDatabase->SecurityPolicy();
sl@0: 	if(!securityPolicy)
sl@0: 		{
sl@0: 		__SQLLEAVE(KErrNotSupported);
sl@0: 		}
sl@0: 	const RSqlBufFlat& bufFlat = securityPolicy->BufFlat();
sl@0: 	TInt size = bufFlat.Size();
sl@0: 	if(size <= aMessage.Int0())
sl@0: 		{
sl@0: 		aMessage.WriteL(1, bufFlat.BufDes());
sl@0: 		SQLPROFILER_REPORT_IPC(ESqlIpcWrite, size);
sl@0: 		return 0;
sl@0: 		}
sl@0: 	return size + KSqlClientBufOverflowCode;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: If an error occurs during the execution the function leaves with the error code.
sl@0: Possible non-leaving return values:
sl@0:  - KErrNone              - the function has completed successfully;
sl@0:  - Positive return value - the length of the column, which means - the destination buffer is too small.
sl@0:                            This return value is possible only with text or binary columns.
sl@0: 
sl@0: @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).
sl@0: 
sl@0: Usage of the IPC call arguments: 
sl@0: Arg 0: [in]		(8/16-bit character length of SQL statement) | (expected column value type << 24).
sl@0: Arg 1: [in]		SQL statement.
sl@0: Arg 2: [in]		Byte max length of the receiving buffer
sl@0: Arg 3: [in/out]	The receiving buffer
sl@0: */
sl@0: TInt CSqlSrvSession::DbScalarFullSelectL(const RMessage2& aMessage, TBool aIsText16)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 	TUint sqlLen = static_cast <TUint> (aMessage.Int0()) & 0x00FFFFFF;
sl@0: 	TSqlColumnType  colType = static_cast <TSqlColumnType> ((static_cast <TUint> (aMessage.Int0()) & 0xFF000000) >> 24);
sl@0: 	TInt columnCount = -1;
sl@0: 	TInt paramCount = -1;
sl@0: 	CSqlSrvStatement*  stmt = aIsText16 ? 
sl@0: 								CSqlSrvStatement::NewLC(iDatabase->RawDbHandle(), ReadString16ZL(aMessage, 1, sqlLen), columnCount, paramCount) :
sl@0: 								CSqlSrvStatement::NewLC(iDatabase->RawDbHandle(), ReadString8ZL(aMessage, 1, sqlLen), columnCount, paramCount);
sl@0: 	if(columnCount != 1 || paramCount != 0)
sl@0: 		{
sl@0: 		__SQLLEAVE(KErrArgument);	
sl@0: 		}
sl@0: 	TInt err = stmt->Next();
sl@0: 	if(err == KSqlAtRow)
sl@0: 		{
sl@0: 		err = GetColumnValueL(aMessage, *stmt, colType);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__SQLLEAVE(err == KSqlAtEnd ? KErrNotFound : err);
sl@0: 		}
sl@0: 	CleanupStack::PopAndDestroy(stmt);
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @return True, if the database is in transaction, false otherwise.
sl@0: 
sl@0: @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).
sl@0: */
sl@0: TBool CSqlSrvSession::DbInTransaction(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 	return iDatabase->InTransaction();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Main database size in bytes.
sl@0: 
sl@0: @return Main database size in bytes.
sl@0: 
sl@0: @leave KErrNoMemory, an out of memory condition has occurred,
sl@0:                      Note that the function may also leave with some other system wide errors or 
sl@0:                      database specific errors categorised as ESqlDbError,
sl@0: 	   KErrTooBig,   The database is very big and the size cannot fit in a 32-bit signed integer.
sl@0: 
sl@0: @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).
sl@0: */
sl@0: TInt CSqlSrvSession::DbSizeL(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 	TInt64 size = iDatabase->SizeL();
sl@0: 	if(size > KMaxTInt)
sl@0: 		{
sl@0: 		__SQLLEAVE(KErrTooBig);
sl@0: 		}
sl@0: 	return size;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Retrieves the database size and free space.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in/out]	Points to a RSqlDatabase::TSize object, where the database size and free space values
sl@0: 			    will be copied.
sl@0: Arg 1: [in]		The database name length in 16-bit characters
sl@0: Arg 2: [in]		The attached database name or KNullDesC for the main database
sl@0: 
sl@0: @leave KErrNoMemory, an out of memory condition has occurred,
sl@0:                      Note that the function may also leave with some other system wide errors or 
sl@0:                      database specific errors categorised as ESqlDbError.
sl@0:        KErrBadName, Invalid database name
sl@0: 
sl@0: @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).
sl@0: */
sl@0: void CSqlSrvSession::DbSize2L(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 	const TInt KDbNameLen = aMessage.Int1();
sl@0: 	if((TUint)KDbNameLen > KMaxFileName)
sl@0: 		{
sl@0: 		__SQLLEAVE(KErrBadName);
sl@0: 		}
sl@0: 	TPtrC dbName(KNullDesC);
sl@0: 	if(KDbNameLen > 0)
sl@0: 		{
sl@0: 		dbName.Set(ReadString16L(aMessage, 2, KDbNameLen));
sl@0: 		}
sl@0: 	TPckgBuf<RSqlDatabase::TSize> data;
sl@0: 	data().iSize = iDatabase->SizeL(dbName);
sl@0: 	data().iFree = iDatabase->FreeSpaceL(dbName);
sl@0: 	aMessage.WriteL(0, data);
sl@0: 	SQLPROFILER_REPORT_IPC(ESqlIpcWrite, sizeof(RSqlDatabase::TSize));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Runs database compaction.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]	    How much space in bytes should be compacted, all free pages should be removed if the
sl@0: 				parameter value is RSqlDatabase::EMaxCompaction.
sl@0: 				Note that the requested space to be compacted will be rounded up to the nearest page count,
sl@0: 				e.g. request for removing 1 byte will remove one free page from the database file. 
sl@0: Arg 1: [in]		The database name length in characters
sl@0: Arg 2: [in]		The attached database name or KNullDesC for the main database
sl@0: 
sl@0: @return The size of the removed free space
sl@0: 
sl@0: @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).
sl@0: */
sl@0: TInt CSqlSrvSession::DbCompactL(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 	const TInt KSize = aMessage.Int0();
sl@0: 	if(KSize < 0)
sl@0: 		{
sl@0: 		if(KSize != RSqlDatabase::EMaxCompaction)
sl@0: 			{
sl@0: 			__SQLLEAVE(KErrArgument);
sl@0: 			}
sl@0: 		}
sl@0: 	if(KSize == 0)
sl@0: 		{
sl@0: 		return 0;	
sl@0: 		}
sl@0: 	const TInt KDbNameLen = aMessage.Int1();
sl@0: 	if((TUint)KDbNameLen > KMaxFileName)
sl@0: 		{
sl@0: 		__SQLLEAVE(KErrBadName);
sl@0: 		}
sl@0: 	TPtrC dbName(KNullDesC);
sl@0: 	if(KDbNameLen > 0)
sl@0: 		{
sl@0: 		dbName.Set(ReadString16L(aMessage, 2, KDbNameLen));
sl@0: 		}
sl@0: 	return iDatabase->CompactL(KSize, dbName);
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]		requested size of the space to be reserved - not used
sl@0: 
sl@0: The function leaves with KErrAlreadyExists if a drive space has been reserved already by this session.
sl@0: */
sl@0: void CSqlSrvSession::DbReserveDriveSpaceL()
sl@0: 	{
sl@0: 	if(iDriveSpaceReserved)
sl@0: 		{
sl@0: 		__SQLLEAVE(KErrAlreadyExists);
sl@0: 		}
sl@0: 	RSqlDriveSpaceCol& driveSpaceCol = Server().DriveSpaceCol();
sl@0:     if(!driveSpaceCol.Find(iDrive))
sl@0:     	{
sl@0:     	(void)driveSpaceCol.AddL(iDrive);
sl@0:     	}
sl@0: 	
sl@0: 	iDriveSpaceReserved = ETrue;
sl@0: 	//Only iDriveSpaceReserved is set, nothing more needs to be done, because RSqlDriveSpaceCol::AddL() will
sl@0: 	//reserve a drive space on the specified drive.
sl@0: 	//Although it looks like that the implementation can ommit "iDriveSpaceReserved" flag, this flag plays important
sl@0: 	//role, because it is used to ensure that every "reserve drive space" request is matched by a "free drive space"
sl@0: 	//call.
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0: If the client has been given an access to the reserved drive space, that access will be released.
sl@0: */
sl@0: void CSqlSrvSession::DbFreeReservedSpace()
sl@0: 	{
sl@0: 	DbReleaseReserveAccess();
sl@0: 	iDriveSpaceReserved = EFalse;
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0: The function leaves with KErrInUse if an access to the reserved drive space has been given to the client.
sl@0: The function leaves with KErrNotFound if no drive space has been reserved for the drive, where the database file is.
sl@0: */
sl@0: void CSqlSrvSession::DbGetReserveAccessL()
sl@0: 	{
sl@0: 	if(iDriveSpaceInUse)
sl@0: 		{
sl@0: 		__SQLLEAVE(KErrInUse);	
sl@0: 		}
sl@0: 	if(!iDriveSpaceReserved)
sl@0: 		{
sl@0: 		__SQLLEAVE(KErrNotFound);
sl@0: 		}
sl@0: 	CSqlDriveSpace* driveSpace = Server().DriveSpaceCol().Find(iDrive);
sl@0:    	if(!driveSpace)
sl@0:    		{
sl@0: 		__SQLLEAVE(KErrNotFound);
sl@0:    		}
sl@0:    	driveSpace->GetAccessL();
sl@0:    	iDriveSpaceInUse = ETrue;
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0: Releases the drive space reserve if it has been in use by this session (resp. client).
sl@0: */
sl@0: void CSqlSrvSession::DbReleaseReserveAccess()
sl@0: 	{
sl@0: 	if(iDriveSpaceInUse)
sl@0: 		{
sl@0: 		CSqlDriveSpace* driveSpace = Server().DriveSpaceCol().Find(iDrive);
sl@0: 		if(driveSpace)
sl@0: 			{
sl@0:    			driveSpace->ReleaseAccess();
sl@0: 			}
sl@0:    		iDriveSpaceInUse = EFalse;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Processes the request for attaching a secure or non-secure database.
sl@0: 
sl@0: Usage of the IPC call arguments: 
sl@0: Arg 0: [in]	Database file name length (counted in 16-bit characters).
sl@0: Arg 1: [in]	Database file name.
sl@0: Arg 2: [in]	Logical database name length (counted in 16-bit characters).
sl@0: Arg 3: [in]	Logical database name.
sl@0: 
sl@0: @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).
sl@0: */
sl@0: void CSqlSrvSession::DbAttachL(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 	TSqlSrvFileData& fileData = Server().FileData();
sl@0: 	fileData.SetL(aMessage, aMessage.Int0(), 1);
sl@0: 	TInt logicalDbNameLen = aMessage.Int2();
sl@0: 	if(logicalDbNameLen < 1 || logicalDbNameLen > KMaxFileName)
sl@0: 		{
sl@0: 		__SQLLEAVE(KErrBadName);
sl@0: 		}
sl@0: 	iDatabase->AttachDbL(fileData, ReadString16L(aMessage, 3, logicalDbNameLen));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Processes the request for attaching a database using file session and file handles sent by the client.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0:  - Arg 0: [in]  The 32 bits of the argument are used as follow:
sl@0:  @code
sl@0:  MSB                                                                                 LSB
sl@0:  31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
sl@0:  Ro  F  F  F  F  F  F  F  F  F  F  F  F  F  F  F  F  F  F  F  F  F F F F F F F F F F F
sl@0:  @endcode
sl@0:  Where:
sl@0:  @code
sl@0:   - "Ro" - read-only flag, true if the file is read-only;
sl@0:   - "F"  - database file name length in 16-bit characters;
sl@0:  @endcode
sl@0: Arg 1: [in]  db names buffer
sl@0: Arg 2: [in]  file session handle
sl@0: Arg 3: [in]  database file handle
sl@0: 
sl@0: @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).
sl@0: @panic SqlDb 4 Client panic. Invalid IPC data, an indication of a problme in client side sql library.
sl@0: */
sl@0: void CSqlSrvSession::DbAttachFromHandleL(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 	//Read-only flag, buffer length, buffer allocation
sl@0: 	TBool readOnly = (aMessage.Int0() & 0x80000000) != 0;
sl@0: 	const TInt KBufLen = aMessage.Int0() & 0x7FFFFFFF;
sl@0:     __SQLPANIC_CLIENT(KBufLen > 0, aMessage, ESqlPanicBadArgument);
sl@0: 	HBufC8* buf = HBufC8::NewLC(KBufLen);
sl@0: 	TPtr8 bufPtr = buf->Des();
sl@0: 	aMessage.ReadL(1, bufPtr);
sl@0: 	SQLPROFILER_REPORT_IPC(ESqlIpcRead, KBufLen);
sl@0: 	if(KBufLen != bufPtr.Length())
sl@0: 		{
sl@0: 		__SQLLEAVE(KErrArgument);
sl@0: 		}
sl@0: 	RDesReadStream in(bufPtr);
sl@0: 	TDes& dbFileName = Server().FileNameBuf();
sl@0: 	TDes16& dbName = Server().GetBuf16L(KMaxFileName);
sl@0: 	in >> dbFileName;
sl@0: 	in >> dbName;
sl@0: 	CleanupStack::PopAndDestroy(buf);
sl@0: 	TSqlSrvFileData& fileData = Server().FileData();
sl@0: 	fileData.SetFromHandleL(aMessage, dbFileName, EFalse, readOnly);
sl@0: 	iDatabase->AttachDbL(fileData, dbName);
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0: Processes the request for detaching a secure or non-secure database.
sl@0: 
sl@0: Usage of the IPC call arguments: 
sl@0: Arg 0: [in]	Logical database name length (counted in 16-bit characters).
sl@0: Arg 1: [in]	Logical database name.
sl@0: 
sl@0: @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).
sl@0: */
sl@0: void CSqlSrvSession::DbDetachL(const RMessage2& aMessage)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 	TInt logicalDbNameLen = aMessage.Int0();
sl@0: 	if(logicalDbNameLen < 1 || logicalDbNameLen > KMaxFileName)
sl@0: 		{
sl@0: 		__SQLLEAVE(KErrBadName);
sl@0: 		}
sl@0: 	iDatabase->DetachDbL(ReadString16L(aMessage, 1, logicalDbNameLen));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Reads a 16-bit string from the specified stream and returns it in zero-terminated
sl@0: 8-bit format in aNameOut.
sl@0: If the string is of zero length then the substitute string provided will be used instead.
sl@0: 
sl@0: @param aStrm 				The read stream
sl@0: @param aNameOut 			The output parameter that will contain the string read
sl@0: @param aEmptyNameSubstitute The substitute string to use if the string to be read from
sl@0: 							the stream is zero length
sl@0: 
sl@0: @leave KErrNoMemory, 		 An out of memory condition has occurred;
sl@0: 	   KErrArgument, 		 The UTF-16 to UTF-8 string conversion failed;	
sl@0: 	   KErrBadName,	 		 The string has an invalid length;
sl@0: */
sl@0: void CSqlSrvSession::ExtractNameL(RDesReadStream& aStrm, TDes8& aNameOut, const TDesC& aEmptyNameSubstitute)
sl@0: 	{
sl@0: 	 TBool replace = EFalse;
sl@0: 	 TInt32 len;
sl@0: 	 aStrm >> len;
sl@0: 
sl@0: 	 if(len == 0)
sl@0: 	 	{
sl@0: 	   	if(aEmptyNameSubstitute.Length() > 0)
sl@0: 			{
sl@0: 		 	len = aEmptyNameSubstitute.Length();
sl@0: 	 	 	replace = ETrue;
sl@0: 			}
sl@0: 	 	else
sl@0: 			{
sl@0: 			__SQLLEAVE(KErrBadName);
sl@0: 			}
sl@0: 	  	}
sl@0: 	 __ASSERT_DEBUG(len > 0, __SQLPANIC2(ESqlPanicInternalError));//The "if" above should have hanled the case with "len == 0"
sl@0: 	 if((TUint)len > KMaxFileName)
sl@0: 	  {
sl@0: 	  __SQLLEAVE(KErrBadName);
sl@0: 	  }
sl@0: 
sl@0: 	 HBufC* buf = HBufC::NewLC(len + 1);
sl@0: 	 TPtr ptr = buf->Des();
sl@0: 	 if(replace)
sl@0: 	 	{
sl@0: 	  	ptr.Copy(aEmptyNameSubstitute);
sl@0: 	  	}
sl@0: 	 else
sl@0: 	 	{
sl@0: 	  	aStrm >> ptr;
sl@0: 	 	}
sl@0: 	 ptr.Append(0);
sl@0: 	 
sl@0: 	 if(!::UTF16ZToUTF8Z(ptr, aNameOut))
sl@0: 	  {
sl@0: 	  __SQLLEAVE(KErrArgument);
sl@0: 	  }
sl@0: 	  
sl@0: 	 CleanupStack::PopAndDestroy(buf);
sl@0: 	 }
sl@0: 
sl@0: /**
sl@0: Processes the request for creating an IPC stream for accessing the content of a blob column.
sl@0: 
sl@0: @param aMessage The client request wrapped in an IPC message
sl@0: 
sl@0: @return The blob stream handle
sl@0: 
sl@0: @leave KErrNoMemory, 		 An out of memory condition has occurred;
sl@0: 	   KErrArgument, 		 The ROWID is invalid or UTF-16 to UTF-8 string conversion failed;	
sl@0: 	   KErrBadDescriptor 	 The transferred data is bigger than the specified length;
sl@0: 	   KErrBadName,	 		 The table name, column name or database name has an invalid length;
sl@0:        KErrPermissionDenied, The client does not have the required security capabilites for this operation; 						 
sl@0:        						 Note that the function may also leave with some other system wide errors or 
sl@0:                      		 database specific errors categorised as ESqlDbError.
sl@0: 
sl@0: @panic SqlDb 2 Client panic. The database object is not yet created (iDatabase is NULL).
sl@0: @panic SqlDb 3 Client panic. Failed to create a blob stream handle.
sl@0: @panic SqlDb 4 Client panic. IPC buffer length is 0.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]	    The length of the IPC data buffer
sl@0: Arg 1: [in]	    IPC data buffer containing blob parameters: table name, column name, rowid, mode, database name.
sl@0: Arg 2: [out]	IPC buffer containing the blob stream handle
sl@0: */
sl@0: TInt CSqlSrvSession::DbBlobSourceL(const RMessage2& aMessage)
sl@0: 	{	
sl@0: 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 	
sl@0: 	TInt ipcPrmLen = aMessage.Int0();
sl@0: 	__SQLPANIC_CLIENT(ipcPrmLen > 0, aMessage, ESqlPanicBadArgument);
sl@0: 	
sl@0: 	iIpcStreams.AllocL();
sl@0: 	
sl@0: 	TDes8& ipcPrmDes = ReadString8ZL(aMessage, 1, ipcPrmLen);
sl@0: 	RDesReadStream strm(ipcPrmDes);
sl@0: 	
sl@0: 	TBuf8<KMaxFileName + 1> tblName;
sl@0: 	ExtractNameL(strm, tblName);
sl@0: 	
sl@0: 	TBuf8<KMaxFileName + 1> colName;
sl@0: 	ExtractNameL(strm, colName);
sl@0: 	
sl@0: 	TInt64 rowId;
sl@0: 	strm >> rowId;
sl@0: 	if(rowId == -1)
sl@0: 		{
sl@0: 		rowId = iDatabase->LastInsertedRowId();
sl@0: 		}
sl@0: 	if(rowId <= 0)
sl@0: 		{
sl@0: 		__SQLLEAVE(KErrArgument);
sl@0: 		}
sl@0: 
sl@0: 	TInt32 tmp;	
sl@0: 	strm >> tmp;
sl@0: 	TBool isReadOnly = tmp != 0;
sl@0: 	
sl@0: 	TBuf8<KMaxFileName + 1> dbName;
sl@0: 	ExtractNameL(strm, dbName, KMainDb16);
sl@0: 						
sl@0: 	strm.Close();
sl@0: 			 		
sl@0: 	// If the database is secure then check that the client has the required capabilities for the operation
sl@0: 	TInt dbOpType = isReadOnly ? SQLITE_READ : SQLITE_UPDATE;
sl@0: 	if(CSqlSrvDatabase::AuthorizeCallback(iDatabase, dbOpType, (char*)tblName.Ptr(), (char*)colName.Ptr(), (char*)dbName.Ptr(), '\0') != SQLITE_OK)	
sl@0: 		{
sl@0: 		__SQLLEAVE(KErrPermissionDenied);	
sl@0: 		}
sl@0: 
sl@0: 	// Create the stream buffer
sl@0: 	HBlobBuf* blobBuf = HBlobBuf::NewL(iDatabase->RawDbHandle(), dbName, tblName, colName, rowId, isReadOnly ? HBlobBuf::EReadOnly : HBlobBuf::EReadWrite);
sl@0: 	blobBuf->PushL();
sl@0: 		
sl@0: 	// Return the blob size to the client
sl@0: 	TPckgBuf<TIpcStreamBuf> ipcBuf;
sl@0: 	TInt size = blobBuf->SizeL();
sl@0: 	ipcBuf().iExt = size;
sl@0: 	
sl@0: 	// If this is a read stream then return the first client buffer-full of data
sl@0: 	TInt len = 0;
sl@0: 	if(isReadOnly && (size > 0))
sl@0: 		{
sl@0: 		len = Min(size, KIpcBufSize);
sl@0: 		blobBuf->ReadL(ipcBuf().iData, len);	
sl@0: 		}
sl@0: 	
sl@0: 	// Create the stream object
sl@0: 	HIpcStream* ipcStream = new (ELeave) HIpcStream(blobBuf, len);
sl@0: 	TInt strmHandle = iIpcStreams.Add(ipcStream);
sl@0: 	__SQLPANIC_CLIENT(strmHandle > 0, aMessage, ESqlPanicBadHandle);
sl@0: 	CleanupStack::Pop(blobBuf);
sl@0: 
sl@0: 	// Send the size and data to the client
sl@0: 	aMessage.WriteL(2, ipcBuf);
sl@0: 	SQLPROFILER_REPORT_IPC(ESqlIpcWrite, size);
sl@0: 
sl@0: 	return strmHandle;
sl@0: 	}
sl@0: 	
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: ////////////////////////////          Statement operations           //////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: /**
sl@0: Processes the request for preparing a 8/16-bit SQL statement.
sl@0: 
sl@0: @panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).
sl@0: @panic SqlDb 3 Client panic. Internal error - invalid statement handle.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [out]	Column count and parameter count
sl@0: Arg 1: [in]		8/16-bit character length of SQL statement
sl@0: Arg 2: [in]		SQL statement
sl@0: */
sl@0: TInt CSqlSrvSession::StmtPrepareL(const RMessage2& aMessage, TBool aIsText16)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 	iStatements.AllocL();
sl@0: 	TInt columnCount = -1;
sl@0: 	TInt paramCount = -1;
sl@0: 	TUint len = static_cast <TUint> (aMessage.Int1());
sl@0: 	CSqlSrvStatement*  stmt = aIsText16 ? 
sl@0: 						CSqlSrvStatement::NewLC(iDatabase->RawDbHandle(), ReadString16ZL(aMessage, 2, len), columnCount, paramCount) :
sl@0: 						CSqlSrvStatement::NewLC(iDatabase->RawDbHandle(), ReadString8ZL(aMessage, 2, len), columnCount, paramCount);
sl@0: 	TPckgBuf<TSqlIpcData> data;
sl@0: 	data().iPrm1 = static_cast <TUint32> (columnCount);
sl@0: 	data().iPrm2 = static_cast <TUint32> (paramCount);
sl@0: 	aMessage.WriteL(0, data);
sl@0: 	SQLPROFILER_REPORT_IPC(ESqlIpcWrite, sizeof(TSqlIpcData));
sl@0: 	TInt stmtHandle = iStatements.Add(stmt);
sl@0: 	__SQLPANIC_CLIENT(stmtHandle > 0, aMessage, ESqlPanicBadHandle);
sl@0: 	CleanupStack::Pop(stmt);
sl@0: 	return stmtHandle;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Processes the request for executing the SQL statement.
sl@0: 
sl@0: @param aFunction ESqlSrvStmtExec, ESqlSrvStmtAsyncExec, ESqlSrvStmtBindExec, ESqlSrvStmtBindExecRowId, ESqlSrvStmtAsyncBindExec
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]    parameter buffer length in bytes (if aFunction == ESqlSrvStmtBindExec || aFunction == ESqlSrvStmtAsyncBindExec)
sl@0: Arg 1: [in]    parameter buffer 		(if aFunction == ESqlSrvStmtBindExec || aFunction == ESqlSrvStmtAsyncBindExec)
sl@0: */
sl@0: TInt CSqlSrvSession::StmtExecL(const RMessage2& aMessage, TInt aStmtHandle, TSqlSrvFunction aFunction)
sl@0: 	{	
sl@0: 	CSqlSrvStatement& stmt = ::SqlSessObjFind(iStatements, aStmtHandle, aMessage);
sl@0: 	if(aFunction == ESqlSrvStmtBindExec || aFunction == ESqlSrvStmtAsyncBindExec)
sl@0: 		{
sl@0: 		DoStmtBindL(aMessage, stmt);
sl@0: 		}
sl@0: 	__SQLLEAVE_IF_ERROR(stmt.Exec());
sl@0: 	return iDatabase->LastChangesCount();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Processes the request for moving the SQL statement on the next record.
sl@0: 
sl@0: If the call does not fail, the only valid acceptable return codes should be KSqlAtRow and KSqlAtEnd.
sl@0: 
sl@0: @panic SqlDb 7 In _DEBUG mode. The call completed with no error but the return code is not KSqlAtRow or KSqlAtEnd.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]    parameter buffer length in bytes (if aFunction == ESqlSrvStmtBindNext)
sl@0: Arg 1: [in]    parameter buffer 		(if aFunction == ESqlSrvStmtBindNext)
sl@0: Arg 2: [in]    client side column buffer length in bytes
sl@0: Arg 3: [out]   column buffer
sl@0: */
sl@0: TInt CSqlSrvSession::StmtNextL(const RMessage2& aMessage, TInt aStmtHandle, TSqlSrvFunction aFunction)
sl@0: 	{
sl@0: 	CSqlSrvStatement& stmt = ::SqlSessObjFind(iStatements, aStmtHandle, aMessage);
sl@0: 	if(aFunction == ESqlSrvStmtBindNext)
sl@0: 		{
sl@0: 		DoStmtBindL(aMessage, stmt);
sl@0: 		}
sl@0: 	TInt err = stmt.Next();
sl@0: 	if(err == KSqlAtRow)
sl@0: 		{
sl@0: 		const RSqlBufFlat& bufFlat = stmt.ColumnValuesL();
sl@0: 		TInt size = bufFlat.Size();
sl@0: 		if(size > aMessage.Int2())
sl@0: 			{
sl@0: 			return size + KSqlClientBufOverflowCode;
sl@0: 			}
sl@0: 		aMessage.WriteL(3, bufFlat.BufDes());
sl@0: 		SQLPROFILER_REPORT_IPC(ESqlIpcWrite, size);
sl@0: 		}
sl@0: 	__SQLLEAVE_IF_ERROR(err);
sl@0: 	__ASSERT_DEBUG(err == KSqlAtRow || err == KSqlAtEnd, __SQLPANIC(ESqlPanicInternalError));
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Processes the request for retrieving the statement column or parameter names.
sl@0: 
sl@0: If the client side buffer size is not big enough, the function returns the size + KSqlClientBufOverflowCode.
sl@0: In this case the client must increase the buffer and try again to get the buffer only.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]		size of the client side buffer for the names (in bytes)
sl@0: Arg 1: [out]	ipc buffer, column or parameter names
sl@0: */
sl@0: TInt CSqlSrvSession::StmtNamesL(const RMessage2& aMessage, TInt aStmtHandle, TSqlSrvFunction aFunction)
sl@0: 	{
sl@0: 	CSqlSrvStatement& stmt = ::SqlSessObjFind(iStatements, aStmtHandle, aMessage);
sl@0: 	const RSqlBufFlat& namesBuf = aFunction == ESqlSrvStmtParamNames ? stmt.ParamNamesL() : stmt.ColumnNamesL();
sl@0: 	TInt size = namesBuf.Size();
sl@0: 	if(size <= aMessage.Int0())
sl@0: 		{
sl@0: 		aMessage.WriteL(1, namesBuf.BufDes());
sl@0: 		SQLPROFILER_REPORT_IPC(ESqlIpcWrite, size);
sl@0: 		return 0;
sl@0: 		}
sl@0: 	return size + KSqlClientBufOverflowCode;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Processes the request for accessing a large column value as a stream of bytes/characters.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]		column index (0 based)
sl@0: Arg 2: [out]	ipc buffer, column source
sl@0: */
sl@0: TInt CSqlSrvSession::StmtColumnSourceL(const RMessage2& aMessage, TInt aStmtHandle)
sl@0: 	{
sl@0: 	CSqlSrvStatement& stmt = ::SqlSessObjFind(iStatements, aStmtHandle, aMessage);
sl@0: 	TInt columnIndex = aMessage.Int0();
sl@0: 	TPtrC8 columnSource;
sl@0: 	TInt err = stmt.ColumnSource(columnIndex, columnSource);
sl@0: 	__SQLLEAVE_IF_ERROR(err);
sl@0: 	HIpcReadBuf* ipcBuf = HIpcReadBuf::NewL(columnSource);
sl@0: 	return NewOutputStreamL(aMessage, ipcBuf);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Processes the request for setting a large parameter value from a stream of bytes or 8/16-bit characters.
sl@0: 
sl@0: @panic SqlDb 3 Client panic. Internal error - invalid stream handle.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]		parameter index (0 based)
sl@0: Arg 2: [out]	ipc buffer, parameter source
sl@0: */
sl@0: TInt CSqlSrvSession::StmtParamSinkL(const RMessage2& aMessage, TInt aStmtHandle, TSqlSrvFunction aFunction)
sl@0: 	{
sl@0: 	iIpcStreams.AllocL();
sl@0: 	TInt parameterIndex = aMessage.Int0();
sl@0: 	CSqlSrvStatement& stmt = ::SqlSessObjFind(iStatements, aStmtHandle, aMessage);
sl@0: 	HSqlSrvStmtParamBuf::TDataType dataType = aFunction == ESqlSrvStmtBinParamSink ? HSqlSrvStmtParamBuf::EBinary : HSqlSrvStmtParamBuf::EText16;
sl@0: 	HSqlSrvStmtParamBuf* paramBuf = stmt.GetParamBufL(parameterIndex, dataType, HSqlSrvStmtParamBuf::EBufIpcStream);
sl@0: 	HIpcStream* ipcStream = new (ELeave) HIpcStream(paramBuf, 0);
sl@0: 	TInt strmHandle = iIpcStreams.Add(ipcStream);
sl@0: 	__SQLPANIC_CLIENT(strmHandle > 0, aMessage, ESqlPanicBadHandle);
sl@0: 	return strmHandle;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]		the client side buffer length in bytes
sl@0: Arg 1: [out]	refers to a place where the buffer data will be copied to.
sl@0: */
sl@0: void CSqlSrvSession::StmtGetBufFlatL(const RMessage2& aMessage, TInt aStmtHandle)
sl@0: 	{
sl@0: 	CSqlSrvStatement& stmt = ::SqlSessObjFind(iStatements, aStmtHandle, aMessage);
sl@0: 	const RSqlBufFlat& bufFlat = stmt.BufFlatL(static_cast <TSqlBufFlatType> (aMessage.Int0()));
sl@0: 	aMessage.WriteL(1, bufFlat.BufDes());
sl@0: 	SQLPROFILER_REPORT_IPC(ESqlIpcWrite, bufFlat.Size());
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]		column index
sl@0: Arg 1: [in]		column buffer length in bytes
sl@0: Arg 2: [in/out]	column buffer
sl@0: */
sl@0: void CSqlSrvSession::StmtColumnValueL(const RMessage2& aMessage, TInt aStmtHandle)
sl@0: 	{
sl@0: 	CSqlSrvStatement& stmt = ::SqlSessObjFind(iStatements, aStmtHandle, aMessage);
sl@0: 	TPtrC8 columnSource;
sl@0: 	TInt columnIndex = aMessage.Int0();
sl@0: 	TInt err = stmt.ColumnSource(columnIndex, columnSource);
sl@0: 	__SQLLEAVE_IF_ERROR(err);
sl@0: 	TInt len = aMessage.Int1();
sl@0: 	if(columnSource.Length() > len)
sl@0: 		{
sl@0: 		TPtr8 ptr(const_cast <TUint8*> (columnSource.Ptr()), columnSource.Length(), columnSource.Length());
sl@0: 		ptr.SetLength(len);
sl@0: 		aMessage.WriteL(2, ptr);
sl@0: 		SQLPROFILER_REPORT_IPC(ESqlIpcWrite, len);
sl@0: 		__SQLLEAVE(KErrOverflow);	
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		aMessage.WriteL(2, columnSource);
sl@0: 		SQLPROFILER_REPORT_IPC(ESqlIpcWrite, len);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]    parameter buffer length in bytes
sl@0: Arg 1: [in]    parameter buffer
sl@0: */
sl@0: void CSqlSrvSession::DoStmtBindL(const RMessage2& aMessage, CSqlSrvStatement& aStmt)
sl@0: 	{
sl@0: 	TInt prmLen = aMessage.Int0();
sl@0: 	RSqlBufFlat& prmBuf = Server().GetFlatBufL(prmLen);
sl@0: 	aMessage.ReadL(1, prmBuf.BufPtr());
sl@0: 	SQLPROFILER_REPORT_IPC(ESqlIpcRead, prmLen);
sl@0: 	aStmt.BindL(prmBuf);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Processes the request for retrieving the statement declared column type names.
sl@0: 
sl@0: If the client side buffer size is not big enough, the function returns the size + KSqlClientBufOverflowCode.
sl@0: In this case the client must increase the buffer and try again to get the buffer only
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 0: [in]    	input buffer max length in 16-bit characters
sl@0: Arg 1: [out]	ipc buffer, declared column type names
sl@0: */
sl@0: TInt CSqlSrvSession::StmtDeclColumnTypesL(const RMessage2& aMessage, TInt aStmtHandle)
sl@0: 	{	
sl@0: 	CSqlSrvStatement& stmt = ::SqlSessObjFind(iStatements, aStmtHandle, aMessage);
sl@0: 	const RSqlBufFlat& declColumnTypesBuf = stmt.GetDeclColumnTypesL();
sl@0: 	TInt size = declColumnTypesBuf.Size();
sl@0: 	if(size <= aMessage.Int0())
sl@0: 		{
sl@0: 		aMessage.WriteL(1, declColumnTypesBuf.BufDes());
sl@0: 		return 0;
sl@0: 		}
sl@0: 	return size + KSqlClientBufOverflowCode;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////////////	
sl@0: ////////////////////////              Helper methods                     /////////////////////////////////
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////////////	
sl@0: 
sl@0: /**
sl@0: Creates a new output IPC stream object using the aStreamBuf parameter as a stream buffer (stream data source).
sl@0: 
sl@0: This method immediately pushes aStreamBuf onto the cleanup stack before creating a new output IPC 
sl@0: stream and so callers of this method should ensure that aStreamBuf is not already on the cleanup stack.
sl@0: 
sl@0: Returns the handle of the created stream.
sl@0: 
sl@0: @panic SqlDb 3 Client panic. Internal error - invalid stream handle.
sl@0: 
sl@0: Usage of the IPC call arguments:
sl@0: Arg 2: [in/out]   IPC buffer
sl@0: */
sl@0: TInt CSqlSrvSession::NewOutputStreamL(const RMessage2& aMessage, MStreamBuf* aStreamBuf)
sl@0: 	{
sl@0: 	aStreamBuf->PushL();
sl@0: 	iIpcStreams.AllocL();
sl@0: 	TInt size = aStreamBuf->SizeL();
sl@0: 	__ASSERT_DEBUG(size >= 0, __SQLPANIC(ESqlPanicInternalError));
sl@0: 	TPckgBuf<TIpcStreamBuf> ipcBuf;
sl@0:     // read the first buffer-full
sl@0:     TInt len = Min(size, KIpcBufSize);
sl@0:     aStreamBuf->ReadL(ipcBuf().iData, len);
sl@0: 	TInt handle = 0;
sl@0: 	if(size > KIpcBufSize)
sl@0: 		{								// create the stream object
sl@0: 		HIpcStream* ipcStream = new (ELeave) HIpcStream(aStreamBuf, KIpcBufSize);
sl@0: 		handle = iIpcStreams.Add(ipcStream);
sl@0: 		__SQLPANIC_CLIENT(handle > 0, aMessage, ESqlPanicBadHandle);
sl@0: 		CleanupStack::Pop(aStreamBuf);
sl@0: 		}
sl@0: 	else								// no more data to send
sl@0: 		{
sl@0: 		CleanupStack::PopAndDestroy(aStreamBuf);
sl@0: 		}
sl@0:     ipcBuf().iExt = size;
sl@0:     aMessage.WriteL(2, ipcBuf);
sl@0:     SQLPROFILER_REPORT_IPC(ESqlIpcWrite, size);
sl@0: 	return handle;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Reads a 8-bit string with "aByteLen" bytes length, which is in "aArgNum" argument of aMessage.
sl@0: The string will be zero terminated after the "read" operation.
sl@0: Returns TDes8 reference pointing to the zero-terminated string.
sl@0: 
sl@0: @panic SqlDb 3 Client panic. The string length is not equal to aByteLen. If happens then it is an indication of a 
sl@0:                              problem inside client side sql library.
sl@0: @panic SqlDb 4 Client panic. Negative aByteLen value.
sl@0: */
sl@0: TDes8& CSqlSrvSession::ReadString8ZL(const RMessage2& aMessage, TInt aArgNum, TInt aByteLen)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(aByteLen >= 0, aMessage, ESqlPanicBadArgument);
sl@0: 	TDes8& buf = Server().GetBuf8L(aByteLen + 1);
sl@0: 	aMessage.ReadL(aArgNum, buf);
sl@0: 	SQLPROFILER_REPORT_IPC(ESqlIpcRead, aByteLen);
sl@0:     __SQLPANIC_CLIENT(buf.Length() == aByteLen, aMessage, ESqlPanicBadHandle);
sl@0: 	buf.Append(TChar(0));
sl@0: 	return buf;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Reads a 16-bit string with "aCharLen" character length, which is in "aArgNum" argument of aMessage.
sl@0: The string will be zero terminated after the "read" operation.
sl@0: Returns TDes16 reference pointing to the zero-terminated string.
sl@0: 
sl@0: @panic SqlDb 3 Client panic. The string length is not equal to aCharLen. If happens then it is an indication of a 
sl@0:                              problem inside client side sql library.
sl@0: @panic SqlDb 4 Client panic. Negative aCharLen value.
sl@0: */
sl@0: TDes16& CSqlSrvSession::ReadString16ZL(const RMessage2& aMessage, TInt aArgNum, TInt aCharLen)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(aCharLen >= 0, aMessage, ESqlPanicBadArgument);
sl@0: 	TDes16& buf = Server().GetBuf16L(aCharLen + 1);
sl@0: 	aMessage.ReadL(aArgNum, buf);
sl@0: 	SQLPROFILER_REPORT_IPC(ESqlIpcRead, (aCharLen * sizeof(TText)));
sl@0:     __SQLPANIC_CLIENT(buf.Length() == aCharLen, aMessage, ESqlPanicBadHandle);
sl@0: 	buf.Append(TChar(0));
sl@0: 	return buf;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Reads a 16-bit string with "aCharLen" character length, which is in "aArgNum" argument of aMessage.
sl@0: Returns TDes16 reference pointing to the string.
sl@0: 
sl@0: @panic SqlDb 3 Client panic. The string length is not equal to aCharLen. If happens then it is an indication of a 
sl@0:                              problem inside client side sql library.
sl@0: @panic SqlDb 4 Client panic. Negative aCharLen value.
sl@0: */
sl@0: TDes16& CSqlSrvSession::ReadString16L(const RMessage2& aMessage, TInt aArgNum, TInt aCharLen)
sl@0: 	{
sl@0: 	__SQLPANIC_CLIENT(aCharLen >= 0, aMessage, ESqlPanicBadArgument);
sl@0: 	TDes16& buf = Server().GetBuf16L(aCharLen);
sl@0: 	aMessage.ReadL(aArgNum, buf);
sl@0: 	SQLPROFILER_REPORT_IPC(ESqlIpcRead, (aCharLen * sizeof(TText)));
sl@0:     __SQLPANIC_CLIENT(buf.Length() == aCharLen, aMessage, ESqlPanicBadHandle);
sl@0: 	return buf;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: The method constructs a CSqlSecurityPolicy object from the passed as an argument descriptor.
sl@0: 
sl@0: @param aSecurityPolicyData A descriptor with the security policy data.
sl@0: 
sl@0: @return A pointer to the created CSqlSecurityPolicy instance.
sl@0: 
sl@0: @leave KErrNoMemory, out of memory condition has occured.
sl@0: */
sl@0: CSqlSecurityPolicy* CSqlSrvSession::CreateSecurityPolicyL(const TDesC8& aSecurityPolicyData)
sl@0: 	{
sl@0: 	TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysFail);
sl@0: 	CSqlSecurityPolicy* dbPolicy = CSqlSecurityPolicy::NewLC(defaultPolicy);
sl@0: 	RSqlBufFlat& bufFlat = dbPolicy->BufFlat();
sl@0:     __SQLLEAVE_IF_ERROR(bufFlat.ReAlloc(aSecurityPolicyData.Length()));
sl@0: 	bufFlat.BufPtr().Copy(aSecurityPolicyData);
sl@0: 	CleanupStack::Pop(dbPolicy);
sl@0: 	return dbPolicy;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Reports how many objects are allocated by the client.
sl@0: If the database connection is not in a test mode, the allocated memory cells count will be ignored.
sl@0: */
sl@0: TInt CSqlSrvSession::CountResources()
sl@0: 	{
sl@0: 	return iStatements.Count() + iIpcStreams.Count() + (iDbResourceTestMode ? User::CountAllocCells() : 0);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Extracts from aMessage:
sl@0: - function code;
sl@0: - stream or statement handle;
sl@0: The function will panic the client if aMessage contains bad function code or bad handle encoded in it.
sl@0: */
sl@0: void CSqlSrvSession::Extract(const RMessage2& aMessage, TSqlSrvFunction& aFunction, TInt& aHandle)
sl@0: 	{
sl@0: 	TInt msgCode = aMessage.Function();
sl@0: 	aFunction = static_cast <TSqlSrvFunction> (KSqlSrvFunctionMask & msgCode);
sl@0: 	//All operations with code > ESqlSrvDbDelete require valid iDatabase object.
sl@0: 	if(aFunction > ESqlSrvDbDelete)
sl@0: 		{
sl@0: 		__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);
sl@0: 		}
sl@0: 	if(aFunction >= ESqlSrvStmtClose)
sl@0: 		{
sl@0: 		//Extracting handle and handle type from the message code
sl@0: 		TSqlSrvHandleType handleType = static_cast <TSqlSrvHandleType> (msgCode & KSqlSrvHandleTypeMask);
sl@0: 		aHandle = (msgCode & KSqlSrvHandleMask) >> KSqlSrvHandleShiftBits;
sl@0: 		__SQLPANIC_CLIENT(aHandle > 0, aMessage, ESqlPanicBadArgument);
sl@0: 		if(aFunction < ESqlSrvStreamBase)
sl@0: 			{
sl@0: 			__SQLPANIC_CLIENT(handleType == ESqlSrvStatementHandle, aMessage, ESqlPanicBadArgument);
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			__SQLPANIC_CLIENT(handleType == ESqlSrvStreamHandle, aMessage, ESqlPanicBadArgument);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: The function reads aStmt column 0 value and copies it into the client buffer, accessed via aMessage argument.
sl@0: 
sl@0: If an error occurs during the execution the function leaves with the error code.
sl@0: Possible non-leaving return values:
sl@0:  - KErrNone              - the function has completed successfully;
sl@0:  - Positive return value - the length of the column, which means - the destination buffer is too small.
sl@0:                            This return value is possible only with text or binary columns.
sl@0: 
sl@0: Usage of the IPC call arguments: 
sl@0: Arg 0: [in]		(8/16-bit character length of SQL statement) | (expected column value type << 24).
sl@0: Arg 1: [in]		SQL statement.
sl@0: Arg 2: [in]		Byte max length of the receiving buffer
sl@0: Arg 3: [in/out]	The receiving buffer
sl@0: */
sl@0: TInt CSqlSrvSession::GetColumnValueL(const RMessage2& aMessage, CSqlSrvStatement& aStmt, TSqlColumnType aColType)
sl@0: 	{
sl@0: 	TInt rc = KErrNone;
sl@0: 	switch(aColType)
sl@0: 		{
sl@0: 		case ESqlInt:
sl@0: 			{
sl@0: 			TInt val = aStmt.ColumnInt(0);
sl@0: 			aMessage.WriteL(3, TPtrC8(reinterpret_cast <const TUint8*> (&val), sizeof(val)));
sl@0: 			SQLPROFILER_REPORT_IPC(ESqlIpcWrite, sizeof(val));
sl@0: 			}
sl@0: 			break;
sl@0: 		case ESqlInt64:
sl@0: 			{
sl@0: 			TInt64 val = aStmt.ColumnInt64(0);
sl@0: 			aMessage.WriteL(3, TPtrC8(reinterpret_cast <const TUint8*> (&val), sizeof(val)));
sl@0: 			SQLPROFILER_REPORT_IPC(ESqlIpcWrite, sizeof(val));
sl@0: 			}
sl@0: 			break;
sl@0: 		case ESqlReal:
sl@0: 			{
sl@0: 			TReal val = aStmt.ColumnReal(0);
sl@0: 			aMessage.WriteL(3, TPtrC8(reinterpret_cast <const TUint8*> (&val), sizeof(val)));
sl@0: 			SQLPROFILER_REPORT_IPC(ESqlIpcWrite, sizeof(val));
sl@0: 			}
sl@0: 			break;
sl@0: 		case ESqlText:
sl@0: 		case ESqlBinary:
sl@0: 		default:
sl@0: 			{
sl@0: 			TPtrC8 val;
sl@0: 			if(aColType == ESqlText)
sl@0: 				{
sl@0: 				TPtrC textVal = aStmt.ColumnTextL(0);
sl@0: 				val.Set(reinterpret_cast <const TUint8*> (textVal.Ptr()), textVal.Length() * sizeof(TUint16));
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				val.Set(aStmt.ColumnBinary(0));
sl@0: 				}
sl@0: 			TInt len = val.Length();
sl@0: 			if(len > aMessage.Int2())
sl@0: 				{
sl@0: 				rc = aColType == ESqlText ? (TUint)len / sizeof(TUint16) : len;
sl@0: 				len = aMessage.Int2();
sl@0: 				}
sl@0: 			aMessage.WriteL(3, val.Left(len));
sl@0: 			SQLPROFILER_REPORT_IPC(ESqlIpcWrite, len);
sl@0: 			}
sl@0: 			break;
sl@0: 		}
sl@0: 	return rc;
sl@0: 	}