// readwrite.cpp

// 

// Copyright (c) 2006 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include "server.h"

#include "pipe.h"

#include "console.h"

#include "readwrite.h"

#include "session.h"

#include "log.h"

#include "persistentconsole.h"

_LIT(KNewLine, "\r\n");

_LIT(KLf, "\n");

#ifdef IOSRV_LOGGING

#define OBJ_NAME(x) TName objName((x).Name())

#else

#define OBJ_NAME(x)

#endif

#define __ASSERT_RETURN(x, y) {if (!(x)) {{y;};return;}}

static void CleanupNullMessage(TAny* aMsgPtr)

	{

	*((RMsg*)aMsgPtr) = RMsg();

	}

static void CleanupNullMessagePushL(RMsg& aMsg)

	{

	CleanupStack::PushL(TCleanupItem(CleanupNullMessage, &aMsg));

	}

//

// MIoEndPoint.

//

TBool MIoEndPoint::IoepIsConsole() const

	{

	return IoepIsType(RIoHandle::EConsole);

	}

//

// MIoReadEndPoint.

//

void MIoReadEndPoint::IorepReadKeyL(MIoReader&)

	{

	User::Leave(KErrNotSupported);

	}

void MIoReadEndPoint::IorepSetConsoleModeL(RIoReadWriteHandle::TMode, MIoReader& aReader)

	{

	aReader.IorSetConsoleModeComplete(KErrNotSupported);

	}

TBool MIoReadEndPoint::AttachedToConsole(const MIoReadEndPoint* aEp)

	{

	if (!aEp) return EFalse;

	if (aEp->IoepIsType(RIoHandle::EPersistentConsole))

		{

		CIoPersistentConsole* pcons = (CIoPersistentConsole*)aEp;

		return AttachedToConsole(pcons->TransientReader());

		}

	else

		{

		return aEp->IoepIsConsole();

		}

	}

//

// MIoWriteEndPoint.

//

void MIoWriteEndPoint::IowepCursorPosL(MIoWriter& aWriter) const

	{

	TPoint pos = IowepCursorPos();

	aWriter.IowCursorPos(KErrNone, pos);

	}

void MIoWriteEndPoint::IowepSetCursorPosAbsL(const TPoint& aPoint, MIoWriter& aWriter)

	{

	IowepSetCursorPosAbs(aPoint);

	aWriter.IowSetCursorPosAbsComplete(KErrNone);

	}

void MIoWriteEndPoint::IowepSetCursorPosRelL(const TPoint& aPoint, MIoWriter& aWriter)

	{

	IowepSetCursorPosRel(aPoint);

	aWriter.IowSetCursorPosRelComplete(KErrNone);

	}

void MIoWriteEndPoint::IowepSetCursorHeightL(TInt aPercentage, MIoWriter& aWriter)

	{

	IowepSetCursorHeight(aPercentage);

	aWriter.IowSetCursorHeightComplete(KErrNone);

	}

void MIoWriteEndPoint::IowepSetTitleL(MIoWriter& aWriter)

	{

	HBufC* title = aWriter.IowTitleLC();

	IowepSetTitle(*title);

	CleanupStack::PopAndDestroy(title);

	aWriter.IowSetTitleComplete(KErrNone);

	}

void MIoWriteEndPoint::IowepClearScreenL(MIoWriter& aWriter)

	{

	IowepClearScreen();

	aWriter.IowClearScreenComplete(KErrNone);

	}

void MIoWriteEndPoint::IowepClearToEndOfLineL(MIoWriter& aWriter)

	{

	IowepClearToEndOfLine();

	aWriter.IowClearToEndOfLineComplete(KErrNone);

	}

void MIoWriteEndPoint::IowepScreenSizeL(MIoWriter& aWriter) const

	{

	TSize size = IowepScreenSize();

	aWriter.IowScreenSize(KErrNone, size);

	}

void MIoWriteEndPoint::IowepSetAttributesL(TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor, MIoWriter& aWriter)

	{

	IowepSetAttributes(aAttributes, aForegroundColor, aBackgroundColor);

	aWriter.IowSetAttributesComplete(KErrNone);

	}

TPoint MIoWriteEndPoint::IowepCursorPos() const

	{

	return TPoint(0, 0);

	}

void MIoWriteEndPoint::IowepSetCursorPosAbs(const TPoint&)

	{

	}

void MIoWriteEndPoint::IowepSetCursorPosRel(const TPoint&)

	{

	}

void MIoWriteEndPoint::IowepSetCursorHeight(TInt)

	{

	}

void MIoWriteEndPoint::IowepSetTitle(const TDesC&)

	{

	}

void MIoWriteEndPoint::IowepClearScreen()

	{

	}

void MIoWriteEndPoint::IowepClearToEndOfLine()

	{

	}

TSize MIoWriteEndPoint::IowepScreenSize() const

	{

	return TSize(0, 0);

	}

void MIoWriteEndPoint::IowepSetAttributes(TUint, ConsoleAttributes::TColor, ConsoleAttributes::TColor)

	{

	}

TBool MIoWriteEndPoint::AttachedToConsole(const MIoWriteEndPoint* aEp)

	{

	if (!aEp) return EFalse;

	if (aEp->IoepIsType(RIoHandle::EPersistentConsole))

		{

		CIoPersistentConsole* pcons = (CIoPersistentConsole*)aEp;

		return AttachedToConsole(pcons->TransientWriter());

		}

	else

		{

		return aEp->IoepIsConsole();

		}

	}

//

// CIoReadWriteObject.

//

TUint CIoReadWriteObject::Id() const

	{

	return iId;

	}

CIoReadWriteObject::CIoReadWriteObject(TUint aId)

	: iId(aId), iOwningThreadId(0)

	{

	}

void CIoReadWriteObject::SetOwnerL(TThreadId aOwningThread)

	{

	iOwningThreadId = aOwningThread;

	}

TInt CIoReadWriteObject::Open(TThreadId aOwningThread)

	{

	TInt err = CObject::Open();

	if ((err==KErrNone) && (IsOwner(aOwningThread)))

		{

		iOpenedByOwner = ETrue;

		}

	return err;

	}

void CIoReadWriteObject::SetModeL(const RMsg& aMessage)

	{

	TInt mode(aMessage.Int0());

	if ((mode >= RIoWriteHandle::EText) && (mode <= RIoWriteHandle::EBinary))

		{

		iMode = static_cast<RIoWriteHandle::TMode>(mode);

		Complete(aMessage, KErrNone);

		}

	else

		{

		Complete(aMessage, KErrNotSupported);

		}

	}

void CIoReadWriteObject::DoDuplicateL(const CIoReadWriteObject& aDuplicate)

	{

	iConsole = aDuplicate.iConsole;

	}

TBool CIoReadWriteObject::IsOwner(TThreadId aOwningThread) const

	{

	return iOwningThreadId == aOwningThread;

	}

TBool CIoReadWriteObject::OpenedByOwner() const

	{

	return iOpenedByOwner;

	}

void CIoReadWriteObject::SetConsole(CIoConsole& aConsole)

	{

	iConsole = &aConsole;

	}

CIoConsole* CIoReadWriteObject::Console()

	{

	return iConsole;

	}

MIoEndPoint* CIoReadWriteObject::EndPoint()

	{

	return iEndPoint;

	}

const CIoConsole* CIoReadWriteObject::Console() const

	{

	return iConsole;

	}

#ifndef IOSRV_LOGGING

void CIoReadWriteObject::Dump(const TDesC&) const

	{

	}

#else

void CIoReadWriteObject::Dump(const TDesC& aData) const

	{

	TBuf<80> out;

	TBuf<16> ascii;

	TInt dataIndex = 0;

	TInt pos = 0;

	do

		{

		out.Zero();

		ascii.Zero();

		out.AppendNumFixedWidthUC(pos, EHex, 8);

		out.Append(_L(": "));

		for (TInt i = 0; i < 16; ++i)

			{

			if (dataIndex < aData.Length())

				{

				TUint8 byte = (TUint8)aData[dataIndex++];

				out.AppendNumFixedWidthUC(byte, EHex, 2);

				out.Append(_L(" "));

				if ((byte < 0x20) || (byte >= 0x7f) || byte == '%')

					{

					byte = '.';

					}

				ascii.Append(TChar(byte));

				++pos;

				}

			else

				{

				out.Append(_L("   "));

				}

			}

		out.Append(ascii);

		CIoLog::Printf(out);

		}

		while (dataIndex < aData.Length());

	}

#endif

//

// CIoReadObject.

//

CIoReadObject* CIoReadObject::NewLC(TInt aId)

	{

	CIoReadObject* self = new(ELeave) CIoReadObject(aId);

	LOG(CIoLog::Printf(_L("Read object 0x%08x created"), self));

	CleanupClosePushL(*self);

	return self;

	}

CIoReadObject::~CIoReadObject()

	{

	OBJ_NAME(*this);

	LOG(CIoLog::Printf(_L("Read object \"%S\" (0x%08x) destroying"), &objName, this));

	if (iEndPoint)

		{

		ReadEndPoint()->IorepDetach(*this);

		}

	CompleteIfPending(iReadMessage, KErrSessionClosed);

	CompleteIfPending(iReadKeyMessage, KErrSessionClosed);

	CompleteIfPending(iChangeNotifyMessage, KErrSessionClosed);

	delete iBuf;

	delete iLineSeparator;

	iCapturedKeys.Close();

	iKeyBuffer.Close();

	}

void CIoReadObject::DuplicateL(const CIoReadObject& aDuplicate)

	{

	DoDuplicateL(aDuplicate);

	if (aDuplicate.iEndPoint)

		{

		AttachL(*aDuplicate.ReadEndPoint(), RIoEndPoint::EBackground);

		}

	}

void CIoReadObject::AttachL(MIoReadEndPoint& aEndPoint, RIoEndPoint::TReadMode aMode)

	{

	if (iEndPoint)

		{

		ReadEndPoint()->IorepDetach(*this);

		}

	aEndPoint.IorepAttachL(*this, aMode);

	iEndPoint = &aEndPoint;

	}

void CIoReadObject::SetReadMode(RIoReadHandle::TReadMode aMode)

	{

	iReadMode = aMode;

	}

void CIoReadObject::SetToForegroundL()

	{

	if (iEndPoint)

		{

		ReadEndPoint()->IorepSetForegroundReaderL(*this);

		}

	}

TBool CIoReadObject::IsForegroundL() const

	{

	if (iEndPoint)

		{

		return ReadEndPoint()->IorepIsForegroundL(*this);

		}

	return EFalse;

	}

void CIoReadObject::ReadL(const RMsg& aMessage)

	{

	__ASSERT_RETURN(iEndPoint, PanicClient(aMessage, EPanicReadWhenNotAttached));

	__ASSERT_RETURN(!MessagePending(iReadMessage) && !MessagePending(iReadKeyMessage), PanicClient(aMessage, EPanicReadAlreadyPending));

	const TInt maxReadLength = MaxDesLengthL(aMessage, 0);

	AllocateBufferL(maxReadLength);

	iReadMessage = aMessage;

	iMaxReadLength = maxReadLength;

	if (iCompleteErr)

		{

		if ((iCompleteErr == KErrEof) && (iBuf->Length() > 0))

			{

			// the end point has reached the end of the stream

			// but we haven't finished processing the data in our buffer yet

			TryToCompleteRead();

			}

		else

			{

			iReadMessage.Complete(iCompleteErr);

			}

		}

	else

		{

		ProcessRead();

		}

	}

void CIoReadObject::ReadCancel(const CIoSession& aSession)

	{

	if (MessagePending(iReadMessage) && (iReadMessage.Session() == static_cast<const CSession2*>(&aSession)))

		{

		Complete(iReadMessage, KErrCancel);

		iBuf->Des().Zero();

		}

	}

void CIoReadObject::ProcessRead()

	{

	ASSERT((MessagePending(iReadMessage) || MessagePending(iReadKeyMessage)) && !(MessagePending(iReadMessage) && MessagePending(iReadKeyMessage)));

	if (MessagePending(iReadMessage))

		{

		if (iCompleteErr)

			{

			iReadMessage.Complete(iCompleteErr);

			}

		else

			{

			TryToCompleteRead();

			if (IorReadPending())

				{

				TRAPD(err, ReadEndPoint()->IorepReadL(*this));

				if (err)

					{

					Complete(iReadMessage, err);

					}

				else if (IorReadPending())

					{

					TryToCompleteRead();

					}

				}

			}

		}

	else

		{

		if (iCompleteErr)

			{

			iReadKeyMessage.Complete(iCompleteErr);

			}

		else

			{

			if (iKeyBuffer.Count() > 0)

				{

				CompleteReadKey(KErrNone, iKeyBuffer[0]);

				iKeyBuffer.Remove(0);

				}

			else

				{

				TRAPD(err, ReadEndPoint()->IorepReadKeyL(*this));

				if (err)

					{

					Complete(iReadKeyMessage, err);

					}

				}

			}

		}

	}

void CIoReadObject::SetLineSeparatorL(const RMsg& aMessage)

	{

	HBufC* separator = HBufC::NewLC(DesLengthL(aMessage, 0));

	TPtr ptr(separator->Des());

	MessageReadL(aMessage, 0, ptr);

	delete iLineSeparator;

	iLineSeparator = separator;

	CleanupStack::Pop(separator);

	Complete(aMessage, KErrNone);

	}

void CIoReadObject::ReadKeyL(const RMsg& aMessage)

	{

	__ASSERT_RETURN(iEndPoint, PanicClient(aMessage, EPanicReadKeyWhenNotAttached));

	__ASSERT_RETURN(!MessagePending(iReadMessage) && !MessagePending(iReadKeyMessage), PanicClient(aMessage, EPanicReadAlreadyPending));

	iReadKeyMessage = aMessage;

	if (iCompleteErr)

		{

		iReadKeyMessage.Complete(iCompleteErr);

		}

	else

		{

		ProcessRead();

		}

	}

void CIoReadObject::ReadKeyCancel(const CIoSession& aSession)

	{

	if (MessagePending(iReadKeyMessage) && (iReadKeyMessage.Session() == &aSession))

		{

		Complete(iReadKeyMessage, KErrCancel);

		}

	}

void CIoReadObject::CaptureKeyL(const RMsg& aMessage)

	{

	User::LeaveIfError(iCapturedKeys.Append(TCapturedKey(aMessage.Int0(), aMessage.Int1(), aMessage.Int2())));

	Complete(aMessage, KErrNone);

	}

void CIoReadObject::CancelCaptureKey(const RMsg& aMessage)

	{

	TCapturedKey capturedKey(aMessage.Int0(), aMessage.Int1(), aMessage.Int2());

	const TInt numCapturedKeys = iCapturedKeys.Count();

	for (TInt i = 0; i < numCapturedKeys; ++i)