// Copyright (c) 2003-2009 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:
// Telnet Protocol API
// CIOBufferControl implementation
// 
//

/**
 @file
*/

#include "IOBUFFER.H"
#include "ACTIVEIO.H"
#include "TELDEBUG.H"

CIOBufferControl::CIOBufferControl()
/**
Constructor
*/
	{
	}

CIOBufferControl::~CIOBufferControl()
/**
Destructor
*/
	{
	Reset();
	__FLOG_STATIC(KTelnetLoggingCompnt(),KTelnetLoggingTag(),_L("CIOBufferControl::D'Tor"));
	}

CIOBufferControl* CIOBufferControl::NewL(MIONotifier* aNotifier)
	{
	CIOBufferControl* self = new(ELeave) CIOBufferControl;
	CleanupStack::PushL(self);
	self->ConstructL(aNotifier);
	CleanupStack::Pop();
	return self;
	}

void CIOBufferControl::ConstructL(MIONotifier* aNotifier)
	{
	iNotifier = aNotifier;

	iWriter = NULL;
	iReader = NULL;

	iQueueIndex = 0;
	iLiveIndex = 0;
	
	iUrgent = NULL;
	iWriteBuffers[0] = NULL;
	iWriteBuffers[1] = NULL;
	}

TInt CIOBufferControl::WriteUrgent(HBufC8* aBuffer)
/**
Caller requests to send data as TCP urgent
*/
	{
	TInt err = KErrNone;
	// Check to see if write is already outstanding
	if(iLiveIndex == iQueueIndex)
		{
		// No write outstanding
		// Just set the live index to point to the heap buffer
		iWriteBuffers[iLiveIndex] = aBuffer;
		// Make indexes different so if the next write call comes before completion of this one
		// then it can append to the queue buffer
		(iLiveIndex == 0) ? (iQueueIndex = 1) : (iQueueIndex = 0);
		iWriter->IssueUrgentWrite(*(iWriteBuffers[iLiveIndex]));
		err = KErrNone;
		}
	else
		{
		// Check for existing queued urgent
		if(iUrgent)
			// DON'T permit queued urgents
			err = KErrInUse;
		else
			{
			// Data will be sent on next write completion
			iUrgent = aBuffer;
			err = KErrNone;
			}
		}
	return(err);
	}

TInt CIOBufferControl::Write(HBufC8* aBuffer)
/**
Writes issued into this object send it to the active writer
Ownership of the buffer is transferred
*/
	{
	TInt ret = KErrNone;

	TPtr8 ptr = aBuffer->Des();

	// iLiveIndex = iQueueIndex means there are no outstanding writes on the socket
	if(iLiveIndex == iQueueIndex)
		{			
		iWriteBuffers[iLiveIndex] = aBuffer;
		// Make indexes different so if the next write call comes before completion of this one
		// then it can append to the queue buffer
		(iLiveIndex == 0) ? (iQueueIndex = 1) : (iQueueIndex = 0);
		iWriter->IssueWrite(*(iWriteBuffers[iLiveIndex]));
		}
	else
		{
		__FLOG_STATIC(KTelnetLoggingCompnt(),KTelnetLoggingTag(),_L("CIOBufferControl() Write Queue"));
		// There is already a buffer loaded on the socket
		if(iWriteBuffers[iQueueIndex])
			// Append this data to the iQueueIndex buffer
			// Overflow check first
			{
			HBufC8* qBuf = iWriteBuffers[iQueueIndex];
			TPtr8 qPtr = qBuf->Des();
			if((qPtr.MaxLength() - qPtr.Length()) < ptr.Length())
				// Not enough room to append
				{
				qBuf = iWriteBuffers[iQueueIndex]->ReAlloc(qPtr.Length() + ptr.Length());
				if(qBuf==NULL)
					return KErrNoMemory;		//Return error and don't take ownership of aBuffer
				iWriteBuffers[iQueueIndex] = qBuf;
				qPtr = qBuf->Des();
				}
			qPtr.Append(ptr);
			delete aBuffer;
			}
		else
			// Nothing queued just assign the pointer
			// Data will be sent on next write completion
			{
			iWriteBuffers[iQueueIndex] = aBuffer;
			}
		}
	return(ret);
	}


TInt CIOBufferControl::Read(TDes8& aBuffer)
	{
	return(iReader->IssueRead(aBuffer));
	}

void CIOBufferControl::SetWriter(CActiveWriter* aWriter)
	{
	iWriter = aWriter;
	}

void CIOBufferControl::SetReader(CActiveReader* aReader)
	{
	iReader = aReader;
	}


// MIONotifier 

void CIOBufferControl::Event(TInt aEvent,TInt aEventCode)
	{
	iNotifier->Event(aEvent,aEventCode);
	}

void CIOBufferControl::WriteComplete()
/**
Normal asynchronous completion to a write request to the active writer
The data we transmitted will always be pointed to by iLiveIndex
On completion there could be Urgent or ordinary data queued
Submit any queued urgent first
*/
	{
	// Free the HBufC8* we loaded for transmit the last time
	delete iWriteBuffers[iLiveIndex];
	iWriteBuffers[iLiveIndex] = NULL;
	// First check to see if we have any urgent data queued
	if(iUrgent)
		{
		// Urgent data queued, move the urgent pointer to the live index
		iWriteBuffers[iLiveIndex] = iUrgent;
		// Free the pointer
		iUrgent = NULL;
		// Send the queued urgent data
		iWriter->IssueUrgentWrite(*(iWriteBuffers[iLiveIndex]));
		}
	else if(iWriteBuffers[iQueueIndex])
		// Check to see if any data is on the normal queue
		{
		// Data queued
		// Swap the indexes
		iLiveIndex = iQueueIndex;
		(iLiveIndex == 0) ? (iQueueIndex = 1) : (iQueueIndex = 0); 		
		// Issue the next write
		__FLOG_STATIC(KTelnetLoggingCompnt(),KTelnetLoggingTag(),_L("CIOBufferControl() WriteComplete() Write Queue Data"));
		iWriter->IssueWrite(*(iWriteBuffers[iLiveIndex]));
		// complete the write
		}
	else
		{
		// No data queued, set the transmitter empty condition
		iLiveIndex = iQueueIndex;
		}
	iNotifier->WriteComplete();
	}

void CIOBufferControl::WriteError(TInt aError)
/**
Write completion with an error, just pass the code up in a notification
*/
	{
	Reset();
	iNotifier->WriteError(aError);
	}

void CIOBufferControl::ReadCompleteL()
	{
	iNotifier->ReadCompleteL();
	}

void CIOBufferControl::ReadComplete(TInt aError)
	{
	Reset();
	iNotifier->ReadComplete(aError);
	}

void CIOBufferControl::Reset()
	{
	delete iWriteBuffers[0];
	delete iWriteBuffers[1];
	delete	iUrgent;

	iUrgent = NULL;
	iWriteBuffers[0] = NULL;
	iWriteBuffers[1] = NULL;

	iQueueIndex = iLiveIndex = 0;
	iWriter = NULL;
	iReader = NULL;
	}