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

 //

 // Description:

 //

 #include <e32base.h>

 #include "IPCBuf.h"

 #include "SqlAssert.h"

 #include "SqlDbSession.h"

 #include "OstTraceDefinitions.h"

 #ifdef OST_TRACE_COMPILER_IN_USE

 #include "IPCBufTraces.h"

 #endif

 #include "SqlTraceDef.h"

 /**

 Standard, phase-one HIpcBuf factory method.

 Created HIpcBuf instance will be used for transfering large text or binary objects from/to SQL server.

 The created HIpcBuf instance will be placed in the cleanup stack.

 @param aSession A reference to RSqlDbSession instance.

 @param aFunction Prepared function code (with all statement handle bits set)

 @param aArgs A set of IPC arguments to be sent to the SQL server.

 @return A pointer to the created HIpcBuf instance

 @leave KErrNoMemory Out of memory.

 */

 HIpcBuf* HIpcBuf::NewLC(RSqlDbSession& aSession, TInt aFunction, TIpcArgs& aArgs)

 	{

 	HIpcBuf* self = new (ELeave) HIpcBuf(aSession);

 	self->PushL();

 	self->ConstructL(aFunction, aArgs);

 	return self;

 	}

 /**

 Standard, phase-one HIpcBuf factory method.

 Created HIpcBuf instance will be used for transfering large text or binary objects from/to SQL server.

 @param aSession A reference to RSqlDbSession instance.

 @param aFunction Prepared function code (with all statement handle bits set)

 @param aArgs A set of IPC arguments to be sent to the SQL server.

 @return A pointer to the created HIpcBuf instance

 @leave KErrNoMemory Out of memory.

 */

 HIpcBuf* HIpcBuf::NewL(RSqlDbSession& aSession, TInt aFunction, TIpcArgs& aArgs)

 	{

 	HIpcBuf* self = NewLC(aSession, aFunction, aArgs);

 	CleanupStack::Pop();

 	return self;

 	}

 /**

 Standard, phase-two HIpcBuf construction method.

 @param aFunction The command code which will be sent to the SQL server

 @param aArgs A set of IPC arguments to be sent to the SQL server.

 @leave KErrNoMemory Out of memory.

 Usage of the IPC call arguments:

 Arg 2: [in/out]  IPC buffer

 iBuf.iExt: [in]  stream size in bytes

 */

 void HIpcBuf::ConstructL(TInt aFunction, TIpcArgs& aArgs)

 	{

 	TPckg<TIpcStreamBuf> pckg(iBuf);

 	aArgs.Set(2, &pckg);

 	__SQLLEAVE_IF_ERROR(iHandle = iSession.SendReceive(aFunction, aArgs));

     SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, HIPCBUF_CONSTRUCTL, "0x%X;HIpcBuf::ConstructL;iHandle=%d", (TUint)this, iHandle));

 	TUint8* base = iBuf.iData;

 	// if reading we already have one buffer-full of data

 	TInt avail = Max(0, Min(iBuf.iExt, KIpcBufSize));

 	SetBuf(ERead, base, base + avail);

 	SetPos(ERead, avail);

 	SetBuf(EWrite, base, base);

 	SetPos(EWrite, 0);

 	}

 /**

 @param aSession A reference to a sesion object.

 */

 HIpcBuf::HIpcBuf(RSqlDbSession& aSession) :

 	iSession(aSession),

 	iHandle(0),

 	iRPos(0),

 	iWPos(0)

 	{

 	iBuf.iExt = -1;

 	}

 /**

 */

 HIpcBuf::~HIpcBuf()

 	{

     SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, HIPCBUF_HIPCBUFL2, "0x%X;HIpcBuf::~HIpcBuf;iHandle=%d", (TUint)this, iHandle));

 	if(iHandle > 0) //iHandle is valid only when > 0.

 		{

 		(void)iSession.SendReceive(::MakeMsgCode(ESqlSrvStreamClose, ESqlSrvStreamHandle, iHandle));

 		}

 	}

 /**

 Fill the buffer's read area.

 */

 TInt HIpcBuf::UnderflowL(TInt)

 	{

 	// when handle is null there is no data to read from server

 	if(!iHandle)

 		{

 		return 0;

 		}

 	__ASSERT_DEBUG(Avail(ERead) == 0, __SQLPANIC(ESqlPanicInternalError));

 	TUint8* base=iBuf.iData;

 	IpcWriteL(base,Lag(EWrite));

 	SetBuf(EWrite,base,base);

 	TInt len=IpcReadL(base,iBuf.ESize);

 	SetBuf(ERead,base,base+len);

 	return len;

 	}

 /**

 Set up the buffer's write area.

 */

 void HIpcBuf::OverflowL()

 	{

 	__ASSERT_DEBUG(Avail(EWrite) == 0, __SQLPANIC(ESqlPanicInternalError));

 	TUint8* base = iBuf.iData;

 	MovePos(ERead, Lag(ERead));

 	SetBuf(ERead, base, base);

 	IpcWriteL(base, Lag(EWrite));

 	SetBuf(EWrite, base, base + iBuf.ESize);

 	}

 /**

 Destroys HIpcBuf instance.

 */

 void HIpcBuf::DoRelease()

 	{

 	delete this;

 	}

 /**

 Synchronise this buffer with its file, giving up on outstanding writes in case of failure.

 */

 void HIpcBuf::DoSynchL()

 	{

 	TUint8* base = iBuf.iData;

 	MovePos(ERead, Lag(ERead));

 	TInt lag = Lag(EWrite);

 	SetBuf(ERead | EWrite, base, base);

 	iBuf.iExt = -1;

 	IpcWriteL(base, lag);

 	__SQLLEAVE_IF_ERROR(iSession.SendReceive(::MakeMsgCode(ESqlSrvStreamSynch, ESqlSrvStreamHandle, iHandle)));

 	}

 /**

 Read direct from ipc if asked to transfer more than a bufferful.

 */

 TInt HIpcBuf::DoReadL(TAny* aPtr, TInt aMaxLength)

 	{

 	__ASSERT_DEBUG(aMaxLength > 0, __SQLPANIC(ESqlPanicInternalError));

 	TInt avail = Avail(ERead);

 	__ASSERT_DEBUG(avail >= 0 && Avail(EWrite) >= 0, __SQLPANIC(ESqlPanicInternalError));

 	if(avail > 0)

 		{

 		TInt len = Min(aMaxLength, avail);

 		TUint8* ptr = Ptr(ERead);

 		aPtr = Mem::Copy(aPtr, ptr, len);

 		SetPtr(ERead, ptr + len);

 		aMaxLength -= len;

 		if(aMaxLength == 0)

 			return len; // that's it

 		}

 	__ASSERT_DEBUG(Avail(ERead) == 0, __SQLPANIC(ESqlPanicInternalError));

 	if(aMaxLength < iBuf.ESize)

 		return avail + TStreamBuf::DoReadL(aPtr, aMaxLength);

 	// when handle is null there is no more data to read from server

 	if(!iHandle)

 		{

 		return 0;

 		}

 	TUint8* base = iBuf.iData;

 	IpcWriteL(base, Lag(EWrite));

 	SetBuf(ERead | EWrite, base, base);

 	return avail + IpcReadL(aPtr, aMaxLength);

 	}

 /**

 Write direct to ipc if asked to transfer more than a bufferful.

 */

 void HIpcBuf::DoWriteL(const TAny* aPtr,TInt aLength)

 	{

 	__ASSERT_DEBUG(aLength > 0, __SQLPANIC(ESqlPanicInternalError));

 	TInt avail = Avail(EWrite);

 	__ASSERT_DEBUG(Avail(ERead) >= 0 && avail >= 0, __SQLPANIC(ESqlPanicInternalError));

 	if(avail > 0)

 		{

 		TInt len = Min(aLength, avail);

 		SetPtr(EWrite, Mem::Copy(Ptr(EWrite), aPtr, len));

 		aLength -= len;

 		if(aLength == 0)

 			return; // done

 		aPtr = (TUint8*)aPtr + len;

 		}

 	__ASSERT_DEBUG(Avail(EWrite) == 0, __SQLPANIC(ESqlPanicInternalError));

 	if(aLength < iBuf.ESize)

 		TStreamBuf::DoWriteL(aPtr, aLength);

 	else

 		{

 		TUint8* base = iBuf.iData;

 		IpcWriteL(base, Lag(EWrite));

 		MovePos(ERead, Lag(ERead));

 		SetBuf(ERead | EWrite, base, base);

 		IpcWriteL(aPtr, aLength);

 		}

 	}

 /**

 Position the mark(s) indicated by aMark at aOffset from aLocation.

 */

 TStreamPos HIpcBuf::DoSeekL(TMark aMark, TStreamLocation aLocation, TInt aOffset)

 	{

 	TUint8* base = iBuf.iData;

 	TInt end = EndL();

 	switch(aLocation)

 		{

 	case EStreamBeginning:

 		break;

 	case EStreamMark:

 		switch(aMark)

 			{

 		case ERead:

 			aOffset += Mark(ERead);

 			break;

 		case EWrite:

 			aOffset += Mark(EWrite);

 			break;

 		default:

 		    __ASSERT_ALWAYS(0, __SQLPANIC(ESqlPanicStreamMarkInvalid));

 			break;

 			}

 		break;

 	case EStreamEnd:

 		aOffset += end;

 		break;

 	default:

 	    __ASSERT_ALWAYS(0, __SQLPANIC(ESqlPanicStreamLocationInvalid));

 		break;

 		}

 	TInt r = KErrNone;

 	if(aOffset < 0)

 		{

 		aOffset = 0;

 		r = KErrEof;

 		}

 	else if(aOffset > end)

 		{

 		aOffset = end;

 		r = KErrEof;

 		}

 	__ASSERT_ALWAYS(!(aMark & ~(ERead | EWrite)), __SQLPANIC(ESqlPanicStreamMarkInvalid));

 	if(aMark & ERead)

 		{

 		TInt lag = aOffset - Pos(ERead);

 		if(lag >= base - End(ERead) && lag <= 0)

 			SetPtr(ERead, End(ERead) + lag);

 		else

 			{

 			SetPos(ERead, aOffset);

 			SetBuf(ERead, base, base);

 			}

 		}

 	if(aMark & EWrite && aOffset != Mark(EWrite))

 		{

 		IpcWriteL(base, Lag(EWrite));

 		SetPos(EWrite, aOffset);

 		SetBuf(EWrite, base, base);

 		}

 	__SQLLEAVE_IF_ERROR(r);

 	return TStreamPos(aOffset);

 	}

 /**

 Read from the server at the current read position.

 Arg 0:            not used

 Arg 1: [out]      from which position to read

 Arg 2: [in/out]   IPC buffer

 Arg 3: [out]      max length of the requested data

 */

 TInt HIpcBuf::IpcReadL(TAny* aPtr, TInt aMaxLength)

 	{

 	__ASSERT_DEBUG(aMaxLength >= 0, __SQLPANIC(ESqlPanicInternalError));

 	if(aMaxLength == 0)

 		return 0;

 	TPtr8 des((TUint8*)aPtr, aMaxLength);

 	TInt pos = Pos(ERead);

 	TInt len = __SQLLEAVE_IF_ERROR(iSession.SendReceive(::MakeMsgCode(ESqlSrvStreamRead, ESqlSrvStreamHandle, iHandle), TIpcArgs(0, pos, &des, aMaxLength)));

 	pos += len;

 	if(len < aMaxLength)

 		iBuf.iExt = pos; // end-of-file encountered

 	SetPos(ERead, pos);

 	return len;

 	}

 /**

 Write to the server at the current write position.

 Arg 0:            not used

 Arg 1: [out]      from which position to write

 Arg 2: [in/out]   IPC buffer

 */

 void HIpcBuf::IpcWriteL(const TAny* aPtr, TInt aLength)

 	{

 	__ASSERT_DEBUG(aLength >= 0, __SQLPANIC(ESqlPanicInternalError));

 	if(aLength == 0)

 		return;

 	TPtrC8 ptr((TUint8*)aPtr, aLength);

 	TInt ext = iBuf.iExt;

 	iBuf.iExt = -1;

 	TInt pos = Pos(EWrite);

 	__SQLLEAVE_IF_ERROR(iSession.SendReceive(::MakeMsgCode(ESqlSrvStreamWrite, ESqlSrvStreamHandle, iHandle), TIpcArgs(0, pos, &ptr)));

 	pos += aLength;

 	if(ext >=0 && pos > ext)

 		iBuf.iExt = pos;

 	SetPos(EWrite, pos);

 	}

 /**

 Determine the end of the stream

 */

 TInt HIpcBuf::EndL()

 	{

 	TInt ext = iBuf.iExt;

 	if(ext < 0)

 		{

 		iBuf.iExt = ext = __SQLLEAVE_IF_ERROR(iSession.SendReceive(::MakeMsgCode(ESqlSrvStreamSize, ESqlSrvStreamHandle, iHandle)));

 		}

 	return Max(ext, Mark(EWrite));

 	}