// Copyright (c) 1998-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:

// This deals with connection to the server, sending commands, and parsing the

// returned server data. The data returned is buffered in iBuffer: this is

// simply back-to-back data, with a tree which describes the structure

// containing TPtrC's which identify the data belonging to each atom.

// This class owns both the buffer and the tree, and deals with destroying them

// as necessary. The client can request the base of the tree for it to parse

// when a line has been received.

// 980708 - modified to store flavour of ([ in parent atom

// 980802 - partial read behavior modified (see release.txt)

// 990112 - added cancel debug printing

// 990304 - Tweaks to parsing of escape characters

// 990415 - Now happy with ('s in the middle on non-quoted atoms.

// This only generally happens with non-parsable text

// (eg, after an OK response).

// 

//

#include "imapio.h"

#include "impspan.h"

#include <imsk.h>

#include <imcvtext.h>

#include <msvstore.h>

#include "imapsess.h"

#define IMAPLOG

#ifdef _DEBUG

#define DBG(a) a

#else

#define DBG(a)

#endif

// Initial parser buffer size & granularity

const TInt KIOBufferSize=1280;

const TInt KIOBufferGranularity=256;

// Specifies how long a socket is allowed to be inactive before we close it

// down. This handles the situation where the mail server closes down the

// connection, but we don't receive any indication of that. It has been seen

// when connected using GPRS, and a long telephone call is then made.

const TInt KImapSendInactivityTimeMinutes = 30;

const TInt KImapReceiveInactivityTimeMinutes = 30;

// The CImapAtom class contains a TPtrC which points to the data 'owned' by 

// this atom in the buffer. It also contains next (sibling) and child pointers,

// with which the tree is constructed.

CImapAtom::CImapAtom()

	{

	__DECLARE_NAME(_S("CImapAtom"));

	}

CImapAtom::~CImapAtom()

	{

	}

void CImapAtom::Set(const TDesC8& aAtom)

	{

	// Save this atom in here

	iAtom.Set(aAtom);

	}

void CImapAtom::AddChild(CImapAtom *aNewChild)

	{

	// Set child pointer

	iChild=aNewChild;

	}

void CImapAtom::AddNext(CImapAtom *aNewNext)

	{

	// Set next pointer

	iNext=aNewNext;

	}

CImapAtom *CImapAtom::Child()

	{

	return(iChild);

	}

CImapAtom *CImapAtom::Next()

	{

	return(iNext);

	}

// ToChildL and ToNextL provide clients with a neat way of traversing the tree

// in a direction that *should* exist: if it doesn't, a Leave occurs.

CImapAtom *CImapAtom::ToChildL()

	{

	if (!iChild)

		User::Leave(KErrNotFound);

	return(iChild);

	}

CImapAtom *CImapAtom::ToNextL()

	{

	if (!iNext)

		User::Leave(KErrNotFound);

	return(iNext);

	}

// Makes things look neater: do a CompareF

TBool CImapAtom::Compare(const TDesC8& aVal)

	{

	// Compare and return result

	return(iAtom.CompareF(aVal)==0);

	}

// Compare the right hand side of the atom with the match string.

TBool CImapAtom::CompareTail(const TDesC8& aVal)

	{

	if (aVal.Length() > iAtom.Length())

		return EFalse;

	TPtrC8 ptr = iAtom.Right(aVal.Length());

	return(ptr.CompareF(aVal)==0);

	}

// Makes things look neater: lex a decimal atom to a TUint

TInt CImapAtom::Value(TUint& aVal)

	{

	// Turn it into a value

	TLex8 lex(iAtom);

	return(lex.Val(aVal));

	}

// Makes things look neater: lex a decimal atom to a TInt

TInt CImapAtom::Value(TInt& aVal)

	{

	// Turn it into a value

	TLex8 lex(iAtom);

	return(lex.Val(aVal));

	}

// Makes things look neater: lex a decimal atom to a TInt32

TInt CImapAtom::Value(TInt32& aVal)

	{

	// Turn it into a value

	TLex8 lex(iAtom);

	return(lex.Val(aVal));

	}

// Return descriptor

TPtrC8 CImapAtom::Atom()

	{

	return(iAtom);

	}

// Fixup descriptor pointers

void CImapAtom::FixupL(const HBufC8 *aNewBuffer, const TText8 *aOldBuffer)

	{

   // Fixup descriptor pointers

	CArrayFixFlat<CImapAtom*>* atomStack = new (ELeave) CArrayFixFlat<CImapAtom*>(10);

	CleanupStack::PushL(atomStack);

	atomStack->AppendL(this);

	CImapAtom* currentAtom;

	while (atomStack->Count() != 0)

   		{

		// Pop the top atom off of the stack

		currentAtom = (*atomStack)[atomStack->Count() - 1];

 		atomStack->ResizeL(atomStack->Count() - 1);

		// Fix up the current atom

		if (currentAtom->Atom().Length()>0)

			{

			// Find offset from start of old buffer

			TInt start=(currentAtom->Atom().Ptr()-aOldBuffer);

 			// Make new descriptor & assign it

			TPtrC8 bufptr(aNewBuffer->Ptr()+start,currentAtom->Atom().Length());

			currentAtom->iAtom.Set(bufptr); // Note that we are setting the real iAtom not the copy returned by Atom()

			}

		// Add the first sibling to the stack,

		// subsequent siblings are added when this sibling is visited

		CImapAtom* siblingAtom = currentAtom->Next();

		if (siblingAtom)

			atomStack->AppendL(siblingAtom);

		// Add child to the stack

		CImapAtom* childAtom = currentAtom->Child();

		if (childAtom)

			atomStack->AppendL(childAtom);

   		}

	CleanupStack::PopAndDestroy(atomStack);

   	}

// The IO processing class

CImapIO::CImapIO(TInt aId) : CMsgActive(1), iBufferSize(KIOBufferSize), iAtomStack(8), iID(aId),iPrimaryTextServerSession(NULL)

	{

	__DECLARE_NAME(_S("CImapIO"));

	}

CImapIO::~CImapIO()

	{

	// Make sure we're cancelled

	Disconnect();

	delete iSession;

	// Dispose of buffer

	delete iBuffer;

	// Delete any atom tree that may still exist

	delete iRootAtom;

	// Get rid of log

	delete iImapLog;

	// delete the atom array

	iAtomArray.ResetAndDestroy();

	}

// Create and call non-trivial contructor

CImapIO *CImapIO::NewLC(TInt aId)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CImapIO *CImapIO::NewL(TInt aId)

	{

	CImapIO* self=NewLC(aId);

	CleanupStack::Pop();

	return self;

	}

// The non-trivial constructor

void CImapIO::ConstructL()

	{

	// Get initial buffer

	iBuffer=HBufC8::NewL(iBufferSize);

	// We're an active object...

	CActiveScheduler::Add(this);

	}

// Called when an asynchronous child exits with status>=0

void CImapIO::DoRunL()

	{

	DBG((LogText(_L8("CImapIO::DoRunL(state=%d, status=%d)"),iState,iStatus.Int())));

	switch(iState)

		{

	case EIOStateConnectQueued:

		// Connect has finished: OK?

		if (iStatus.Int()==KErrNone)

			{

			// Done! We're connected

			iState=EIOStateConnected;

			}

		else

			{

			// Close connection and report fail

			iSession->Disconnect();

			}

		break;

	case EIOStateReadQueued:

		// Process it

		iState=EIOStateConnected;

		iRXbytes+=iReceive.Length();

		ProcessBufferL();

		break;

	case EIOStateWriteQueued:

		// Sent! Return error code directly

		iState=EIOStateConnected;

		break;

	case EIOStateConnected:

	case EIOStateDisconnected:

	case EIOStateDummyQueued:

		// Never happens, but pleases the compiler

		break;

		}

	}

// Called when an asynchronous child exits with status <KErrNone

void CImapIO::DoComplete(TInt& /*aStatus*/)

	{

	// note this message might not get reported if the socket has closed

	// pass all status codes up as given. KErrNone and KErrEOL (1)

	// will be ignored. All others will cause a disconnect either in

	// CImImap4Session's IdleReadError(), DummyComplete() or DoComplete().

	}	

// Called when parent wants to cancel an operation

void CImapIO::DoCancel()

	{

	DBG((LogText(_L8("CImapIO::DoCancel(state=%d)"),iState)));

	if (iSession)

		{

		// Cancel actions

		switch(iState)

			{

		case EIOStateConnectQueued:

			// Cancel session and disconnect

			iSession->Cancel();

			iState=EIOStateDisconnected;

			break;

		case EIOStateReadQueued:

		case EIOStateWriteQueued:

			// Cancel it at the session level: this will return the cancelled error

			// upwards, which should cause the above DoComplete to return

			iSession->Cancel();

			iState=EIOStateConnected;

			break;

		case EIOStateConnected:

		case EIOStateDisconnected:

			// Never happens, but pleases the compiler

			break;

		case EIOStateDummyQueued:

			break;

			}

		}

	else

		iState=EIOStateDisconnected;

	// Get msgactive to finish up

	CMsgActive::DoCancel();

	DBG((LogText(_L8("CImapIO::DoCancel done"))));

	}

// Return the root atom

CImapAtom *CImapIO::RootAtom()

	{

	// Return it

	return(iRootAtom);

	}

// Deal with the atom stack: this is used when building the atom tree

void CImapIO::PushL(CImapAtom *aAtom)

	{

	iAtomStack.AppendL(aAtom);

	}

CImapAtom *CImapIO::PopL()

	{

	// Check it isn't empty

	if (iAtomStack.Count()==0)

		User::Leave(KErrUnderflow);

	TInt count = iAtomStack.Count();

	CImapAtom* atom = iAtomStack[count-1];

	iAtomStack.Delete(count-1);

	return(atom);

	}

// Add to the parsed buffer

void CImapIO::BufferAppendL(const TChar aChar)

	{

	// Does buffer need extending?

	if (iBuffer->Length()==iBufferSize)

		{

		HBufC8 *oldbuffer=iBuffer;

		const TText8 *oldbufptr=iBuffer->Ptr();

		// Extend by granularity amount

		iBufferSize+=KIOBufferGranularity;

		iBuffer=iBuffer->ReAllocL(iBufferSize);

		// Buffer moved?

		if (iBuffer!=oldbuffer)

			{

			// Fixup buffer tree pointers

			iRootAtom->FixupL(iBuffer,oldbufptr);

			}

		}

	// Append the data

	iBuffer->Des().Append(aChar);

	}

// Add the last atom appended to the buffer to the tree.

void CImapIO::AddAtomL()

	{

	// Add it

	AddAtomL(iBuffer->Length()-iAtomStart);

	}

// Add the last atom, given a length

void CImapIO::AddAtomL(const TInt aLength)

	{

	// Note buffer position in an atom

	TPtrC8 bufptr(iBuffer->Ptr()+iAtomStart,aLength);

	// Make a new current atom

	CImapAtom *newAtom=new (ELeave) CImapAtom();

	iAtomArray.AppendL(newAtom);

	// Set pointers in it

	newAtom->Set(bufptr);

	// Add it as a child/sibling to the current atom

	if (iNextIsChild)

		iAtom->AddChild(newAtom);

	else

		iAtom->AddNext(newAtom);

	// The next item should be a sibling

	iNextIsChild=EFalse;

	// Make new current

	iAtom=newAtom;

	}

// Process the received buffer, creating atoms as we go

void CImapIO::ProcessBufferL()

	{

	// Process the buffer

	TChar byte;

	DBG((LogText(_L8("CImapIO::ProcessBuffer(iParserState=%d, Length=%d)"),iParserState,iReceive.Length())));

	for(TInt pos=0;pos<iReceive.Length();pos++)

		{

		// Note that we've processed stuff

		iBytesRead++;

		// Byte to process

		byte=iReceive[pos];

		switch(iParserState)

			{

		case EIOStateAtomWait:

			switch(byte)

				{

			case '(':

			case '[':

			case '<':

				{

				// Make a new current atom

				CImapAtom *newAtom=new (ELeave) CImapAtom();

				iAtomArray.AppendL(newAtom);

				// Add it as a sibling to the current atom

				if (iNextIsChild)

					iAtom->AddChild(newAtom);

				else

					iAtom->AddNext(newAtom);

				// The next item should be a child

				iNextIsChild=ETrue;

				// Push current atom onto atom stack, make new current

				iAtom=newAtom;

				PushL(iAtom);

				// Store the open bracket in the buffer, so we can tell what it is

				TPtrC8 bufptr(iBuffer->Ptr()+iBuffer->Length(),1);

				BufferAppendL(byte);

				iAtom->Set(bufptr);

				break;

				}

			case ')':

			case ']':

				// End of this nesting level: pop last atom off stack and

				// make it the new current one

				iAtom=PopL();

				// Any new atoms will be siblings, not children

				iNextIsChild=EFalse;

				break;

			case '{':

				// Start of a literal length

				iLiteralLength=0;

				iParserState=EIOStateLiteralLength;

				break;

			case ' ':

				// Whitespace. Ignore! This state only happens with whitespace

				// after a close )] or a endquote "

				break;

			case '\r':

				// Newline after a close )] or endquote "

				iParserState=EIOStateWaitLF;

				break;

			case '\"':

				// Quotes: we don't keep them, so the atom starts at the next

				// character.

				iAtomStart=iBuffer->Length();

				iParserState=EIOStateInAtom;

				iParserQuoted=ETrue;

				iGotEscape=EFalse;

				break;

			default:

				// Start new atom in buffer

				iAtomStart=iBuffer->Length();

				BufferAppendL(byte);

				iParserState=EIOStateInAtom;

				iParserQuoted=EFalse;

				break;

				}

			break;

		case EIOStateInAtom:

			if (iParserQuoted)