// Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

// NTT DOCOMO, INC - Fix for Bug 1915 "SQL server panics when using long column type strings"

//

// Description:

//

#include "SqlSrvMain.h"			//CSqlServer

#include "SqlSrvSession.h"		//CSqlSrvSession

#include "SqlSrvStatement.h"	//CSqlSrvStatement, HSqlSrvStmtParamBuf

#include "SqlSecurityImpl.h"	//CSqlSecurityPolicy

#include "SqlSrvUtil.h"			//Global server functions

#include "SqlUtil.h"			// config length

#include "SqlSrvDriveSpace.h"	//CSqlDriveSpace, RSqlDriveSpaceCol

#include "SqlSrvBlob.h"

#include "SqlResourceProfiler.h"

#include "SqlCompact.h"

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

#pragma BullseyeCoverage off

#ifdef _DEBUG

const TInt KDelayedDbHeapFailureMask = 0x1000;

//Puts the database connection in a test mode

//Returns true if the heap failure simulation has to be delayed untill the database is opened

//Initialises iDbResourceTestMode and iFailedAllocNumber (if delayed simulation) data members

inline TBool CSqlSrvSession::ActivateDbTestMode(TInt aHeapFailureMode, TInt aFailedAllocNumber)

	{

	iDbResourceTestMode = aHeapFailureMode;

	if(aHeapFailureMode & KDelayedDbHeapFailureMask)

		{

		iFailedAllocNumber = aFailedAllocNumber;

		return ETrue;

		}

	return EFalse;

	}

//If the database connection is in a test mode then the macro will reset the heap allocation failure type.

//and stop the test mode.

inline void CSqlSrvSession::StopDbTestMode()

	{

	if(iDbResourceTestMode)

		{

		iDbResourceTestMode = 0;

		User::__DbgSetAllocFail(RHeap::EUser, RHeap::ENone, 0);

		}

	}

//If the database connection is in a test mode then the function will mark the allocated by the 

//server resources.

inline void CSqlSrvSession::DbResourceMark()

	{

	if(iDbResourceTestMode)

		{

		ResourceCountMarkStart();

		}

	}

//If the database connection is in a test mode then the macro will check the allocated by the server resources,

//comparing their count with the resource count at the moment DbResourceMark() has been called.

//The client will be panicked if the resource count now is different.

inline void CSqlSrvSession::DbResourceEnd(const RMessage2& aMessage)

	{

	if(iDbResourceTestMode)

		{

		ResourceCountMarkEnd(aMessage);

		}

	}

//Executes the heap simulation failure.

inline void CSqlSrvSession::DbSetAllocFail(TInt aHeapFailureMode, TInt aFailedAllocNumber)

	{

	TInt mode = aHeapFailureMode & (KDelayedDbHeapFailureMask - 1);

	if(mode >= RAllocator::EBurstRandom && mode <= RAllocator::EBurstFailNext)

	    {

	    const TUint KBurst = 50; 

	    User::__DbgSetBurstAllocFail(RHeap::EUser, static_cast <RHeap::TAllocFail> (mode), aFailedAllocNumber, KBurst);

	    }

	else

	    {

        User::__DbgSetAllocFail(RHeap::EUser, static_cast <RHeap::TAllocFail> (mode), aFailedAllocNumber);

	    }

	}

//Executes the delayed heap simulation failure, if the connection is in test mode

inline void CSqlSrvSession::DbSetDelayedAllocFail()

	{

	if(iDbResourceTestMode & KDelayedDbHeapFailureMask)

		{

	    TInt mode = iDbResourceTestMode & (KDelayedDbHeapFailureMask - 1);

	    if(mode >= RAllocator::EBurstRandom && mode <= RAllocator::EBurstFailNext)

	        {

	        const TUint KBurst = 50; 

	        User::__DbgSetBurstAllocFail(RHeap::EUser, static_cast <RHeap::TAllocFail> (mode), iFailedAllocNumber, KBurst);

	        }

	    else

	        {

	        User::__DbgSetAllocFail(RHeap::EUser, static_cast <RHeap::TAllocFail> (mode), iFailedAllocNumber);

	        }

		}

	}

#else //_DEBUG

inline TBool CSqlSrvSession::ActivateDbTestMode(TInt, TInt)

	{

	return EFalse;

	}

inline void CSqlSrvSession::StopDbTestMode()

	{

	}

inline void CSqlSrvSession::DbResourceMark()

	{

	}

inline void CSqlSrvSession::DbResourceEnd(const RMessage2&)

	{

	}

inline void CSqlSrvSession::DbSetAllocFail(TInt, TInt)

	{

	}

inline void CSqlSrvSession::DbSetDelayedAllocFail()

	{

	}

#endif//_DEBUG

#pragma BullseyeCoverage on

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

Searches aContainer for an object identified by aHandle.

If such object exists, a reference to it is returned.

If there is no object, the client gets a panic.

@panic SqlDb 4 Client panic. Invalid aHandle parameter value (zero, negative or out of range).

@internalComponent

*/

template <class T> T& SqlSessObjFind(RDbObjContainer<T>& aContainer, TInt aHandle, const RMessage2& aMessage)

	{

	T* obj = aContainer.Find(aHandle);

	return *obj;

	}

//This function return true, if there is free disk space on drive where the main database file is.

static TBool HasFreeDiskSpace(RFs& aFs, TDriveNumber aDrive)

	{

	TVolumeInfo volInfo;

	TInt err = aFs.Volume(volInfo, aDrive);

	if(err == KErrNone)

		{

		const TInt64 KDiskSpaceThreshold = 1024 * 4;

		return volInfo.iFree > KDiskSpaceThreshold;

		}

	return ETrue;

	}

//If aError is KSqlErrFull and  there is no free disk space, then KSqlErrFull is converted to KErrDiskFull

//and returned.

static TInt ConvertSqlFull2DiskFullErr(TInt aError, RFs& aFs, TDriveNumber aDrive)

	{

	if(aError == KSqlErrFull && !HasFreeDiskSpace(aFs, aDrive))

		{

		aError = KErrDiskFull;

		}

	return aError;

	}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

Creates a new instance of CSqlSrvSession class.

This function shall never be called directly.

It is CSqlServer responsibility to create a new server side session object as a responce to the criation of a

client side session instance.

@return A pointer to the created CSqlSrvSession instance.

@leave KErrNoMemory, an out of memory condition has occurred;

@see CSqlServer

@see CSqlServer::NewSessionL()

*/

CSqlSrvSession* CSqlSrvSession::NewL()

	{

	CSqlSrvSession* self = new (ELeave)	CSqlSrvSession;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Frees the allocated by CSqlSrvSession instance resources and memory.

*/

CSqlSrvSession::~CSqlSrvSession()

	{

	StopDbTestMode();

	DbFreeReservedSpace();

	iIpcStreams.Close();

	iStatements.Close();

	delete iDatabase;

	}

/**

Receives and dispatches all client side requests.

CSession2::ServiceL() implementation.

@param aMessage Client message containing the request (function code and data)

@leave The function may leave with some database specific 

	   errors categorised as ESqlDbError or system-wide error codes.

@see CSession2::ServiceL()

*/

void CSqlSrvSession::ServiceL(const RMessage2& aMessage)

	{

	TSqlSrvFunction funcCode = ESqlSrvTestBase;

	TInt handle = 0;

	Extract(aMessage, funcCode, handle);

	TInt retCode = KErrNone;

	if(funcCode >= ESqlSrvDbBase)

		{

		SQLPROFILER_REPORT_IPC(ESqlIpcRq, 0);

		}

	switch(funcCode)

		{

		//////////////////////  resource check operations  ///////////////////////////

		case ESqlSrvResourceMark:

			ResourceCountMarkStart();

			break;

		case ESqlSrvResourceCheck:

			ResourceCountMarkEnd(aMessage);

			break;

		case ESqlSrvResourceCount:

			retCode = CountResources();					//Returns the recourse count

			break;

		case ESqlSrvSetDbHeapFailure:

			if(ActivateDbTestMode(aMessage.Int0(), aMessage.Int1()))

				{

				break;	

				}

		case ESqlSrvSetHeapFailure:

			DbSetAllocFail(aMessage.Int0(), aMessage.Int1());

			break;

		//////////////////////   profiling operations  //////////////////////////////////

		case ESqlSrvProfilerStart:

			TSqlSrvResourceProfiler::StartL(aMessage);

			break;

		case ESqlSrvProfilerStop:

			TSqlSrvResourceProfiler::StopL(aMessage);

			break;

		case ESqlSrvProfilerReset:

			TSqlSrvResourceProfiler::ResetL(aMessage);

			break;

		case ESqlSrvProfilerQuery:

			ProfilerQueryL(aMessage);

			break;

		//////////////////////   database operations //////////////////////////////////

		case ESqlSrvDbCreate:

		case ESqlSrvDbCreateSecure:

		case ESqlSrvDbOpen:

			DbResourceMark();

			DbCreateObjectL(aMessage, funcCode);

			DbSetDelayedAllocFail();

			break;

		case ESqlSrvDbOpenFromHandle:

			DbResourceMark();

			DbCreateObjectFromHandleL(aMessage);

			DbSetDelayedAllocFail();

			break;

		case ESqlSrvDbAttach:

			DbAttachL(aMessage);

			break;

		case ESqlSrvDbAttachFromHandle:

			DbAttachFromHandleL(aMessage);

			break;

		case ESqlSrvDbDetach:

			DbDetachL(aMessage);

			break;

		case ESqlSrvDbClose:

			DbDestroyObject();

			DbResourceEnd(aMessage);

			StopDbTestMode();

			break;

		case ESqlSrvDbCopy:

			DbResourceMark();

			DbCopyFileL(aMessage);

			break;

		case ESqlSrvDbDelete:

			DbResourceMark();

			DbDeleteFileL(aMessage);

			break;

		case ESqlSrvLastErrorMsg:

			retCode = DbLastErrorMessageL(aMessage);//may return that the client buffer is not big enough for the message

			break;

		case ESqlSrvDbLastInsertedRowId:

			DbLastInsertedRowIdL(aMessage);

			break;

		case ESqlSrvDbExec8:

			retCode = DbExecSql8L(aMessage);		//returns the count of affected records

			break;

		case ESqlSrvDbExec16:

			retCode = DbExecSql16L(aMessage);	//returns the count of affected records

			break;

		case ESqlSrvDbSetIsolationLevel:

			DbSetIsolationLevelL(aMessage);

			break;

		case ESqlSrvDbGetSecurityPolicy:

			retCode = DbGetSecurityPolicyL(aMessage);//may return that the client buffer is not big enough for the security policy

			break;

		case ESqlSrvDbScalarFullSelect8:

			retCode = DbScalarFullSelectL(aMessage, EFalse);//may return that the client buffer is not big enough for the column value

			break;

		case ESqlSrvDbScalarFullSelect16:

			retCode = DbScalarFullSelectL(aMessage, ETrue);//may return that the client buffer is not big enough for the column value

			break;

		case ESqlSrvDbInTransaction:

			retCode = DbInTransaction(aMessage);	//Returns whether the database in in transaction or not - true/false

			break;

		case ESqlSrvDbSize:

			retCode = DbSizeL(aMessage);			//Returns the database size

			break;

		case ESqlSrvDbSize2:

			DbSize2L(aMessage);

			break;

		case ESqlSrvDbCompact:

			retCode = DbCompactL(aMessage);			//Returns the amount of the removed free database space

			break;

		//////////////////////   reserved drive space management ////////////////////////

		case ESqlSrvDbReserveDriveSpace:

			__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

			DbReserveDriveSpaceL();

			break;

		case ESqlSrvDbFreeReservedSpace:

			__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

			DbFreeReservedSpace();

			break;

		case ESqlSrvDbGetReserveAccess:

			__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

			DbGetReserveAccessL();

			break;

		case ESqlSrvDbReleaseReserveAccess:

			__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

			DbReleaseReserveAccess();

			break;

		//////////////////////   BLOB source ///////////////////////////////////////////

		case ESqlSrvDbBlobSource:

			retCode = DbBlobSourceL(aMessage);		//Returns the BLOB handle

			break;

		//////////////////////   statement operations //////////////////////////////////

		case ESqlSrvStmtPrepare8:

			retCode = StmtPrepareL(aMessage, EFalse);//returns the statement handle

			break;

		case ESqlSrvStmtPrepare16:

			retCode = StmtPrepareL(aMessage, ETrue);//returns the statement handle

			break;

		case ESqlSrvStmtClose:

			iStatements.Remove(handle);

			break;

		case ESqlSrvStmtReset:

			retCode = ::SqlSessObjFind(iStatements, handle, aMessage).Reset();//May return that the statement has expired

			break;

		case ESqlSrvStmtExec:

		case ESqlSrvStmtAsyncExec:

		case ESqlSrvStmtBindExec:

		case ESqlSrvStmtAsyncBindExec:

			retCode = StmtExecL(aMessage, handle, funcCode);//returns the count of affected records

			break;

		case ESqlSrvStmtNext:

		case ESqlSrvStmtBindNext:

			retCode = StmtNextL(aMessage, handle, funcCode);//returns a non-negative number if the client side buffer is too small

			break;

		case ESqlSrvStmtColumnNames:

		case ESqlSrvStmtParamNames:

			retCode = StmtNamesL(aMessage, handle, funcCode);//returns a non-negative number if the client side buffer is too small

			break;

		case ESqlSrvStmtColumnSource:

			retCode = StmtColumnSourceL(aMessage, handle);//returns an IPC stream handle

			break;

		case ESqlSrvStmtBinParamSink:

		case ESqlSrvStmtTxtParamSink16:

			retCode = StmtParamSinkL(aMessage, handle, funcCode);//returns an IPC stream handle

			break;

		case ESqlSrvStmtBufFlat:

			StmtGetBufFlatL(aMessage, handle);

			break;

		case ESqlSrvStmtColumnValue:

			StmtColumnValueL(aMessage, handle);

			break;

		case ESqlSrvStmtDeclColumnTypes:

			retCode = StmtDeclColumnTypesL(aMessage, handle);

			break;

		//////////////////////   stream operations //////////////////////////////////

		case ESqlSrvStreamRead:

			retCode = ::SqlSessObjFind(iIpcStreams, handle, aMessage).ReadL(aMessage);

			break;

		case ESqlSrvStreamWrite:

			::SqlSessObjFind(iIpcStreams, handle, aMessage).WriteL(aMessage);

			break;

		case ESqlSrvStreamSize:

			retCode = ::SqlSessObjFind(iIpcStreams, handle, aMessage).SizeL();

			break;

		case ESqlSrvStreamSynch:

			::SqlSessObjFind(iIpcStreams, handle, aMessage).SynchL();

			break;

		case ESqlSrvStreamClose:

			iIpcStreams.Remove(handle);

			break;

		//////////////////////                     //////////////////////////////////

		default:	

			retCode = KErrNotSupported;

			break;

		}

	Server().Compactor().RestartTimer();

	Server().MinimizeBuffers();		

	if(!aMessage.IsNull())

		{

		aMessage.Complete(retCode);

		}

	}

/**

If aError is KErrBadDescriptor, then panic the client, else - default error handling.

KErrBadDescriptor error may be thrown from "message write" operations, if the client supplied a bad

descriptor to the server.

*/

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

 	{

	Server().MinimizeBuffers();		

	aError = ::ConvertSqlFull2DiskFullErr(aError, Server().FileData().Fs(), iDrive);

 	if(aError == KErrBadDescriptor)

 		{

		//The __SQLPANIC_CLIENT() macro cannot be used here because it calls a leaving function. A leaving call

		//from a leaving call will terminate the server.

		_LIT(KPanicCategory, "SqlDb");

		aMessage.Panic(KPanicCategory, ESqlPanicBadDescriptor);

 		}

 	       iDatabase ? (TUint)iDatabase->RawDbHandle() : 0, aError);

 	CSession2::ServiceError(aMessage, aError);

   	}

///////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////          Profiler  operations           ///////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////

#pragma BullseyeCoverage off

/**

Retrieves the counter values for the specified profiling counter.

@leave  KErrNone, the operation completed successfully,

        KErrOverflow, the receiving buffer size is too small;

                  One of the other system-wide error codes may also be returned.

@see TSqlResourceProfiler

Usage of the IPC call arguments:

 - Arg 0: [in]  profiling counter type, one of the TSqlResourceProfiler::TSqlCounter enum item values.

 - Arg 1: [in]  the size of the buffer for the profiling counter values.

 - Arg 2: [out] the buffer for the profiling counter values.

@panic SqlDb 2 Client panic. iDatabase is NULL (the database object is not created yet).

*/

void CSqlSrvSession::ProfilerQueryL(const RMessage2& aMessage)

	{

	__SQLPANIC_CLIENT(iDatabase != NULL, aMessage, ESqlPanicInvalidObj);

	if(aMessage.Int0() == TSqlResourceProfiler::ESqlCounterConfig)

		{

		const TInt KConfigBufLen = 128;

		if(aMessage.Int1() < KConfigBufLen)

			{

			__SQLLEAVE(KErrOverflow);	

			}

		TBuf8<KConfigBufLen> res;

		iDatabase->QueryConfigL(res);

		aMessage.WriteL(2, res);

		}

	else

		{

		TSqlSrvResourceProfiler::QueryL(aMessage);