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

//

#include "cimapsession.h"

#include "moutputstream.h"

#include "minputstream.h"

#include "cimapsessionconsts.h"

#include "cimapidle.h"

#include "cimapservereventwait.h"

#include "cimapservergreeting.h"

#include "cimapservergreetinginfo.h"

#include "cimapcapability.h"

#include "cimapcapabilityinfo.h"

#include "cimapnoop.h"

#include "cimaplogout.h"

#include "cimaplogin.h"

#include "cimapstarttls.h"

#include "cimapselect.h"

#include "cimapexamine.h"

#include "cimapcreate.h"

#include "cimapdelete.h"

#include "cimaprename.h"

#include "cimapsubscribe.h"

#include "cimapunsubscribe.h"

#include "cimaplist.h"

#include "cimaplsub.h"

#include "cimapstatus.h"

#include "cimapappend.h"

#include "cimapsearch.h"

#include "cimapclose.h"

#include "cimapstore.h"

#include "cimapcopy.h"

#include "cimapexpunge.h"

#include "cimapfetchflags.h"

#include "cimapfetchbody.h"

#include "cimapfetchsinglebodystructure.h"

#include "cimapfetchmultibodystructures.h"

#include "cimapfetchbodyresponse.h"

#include "cimaplogger.h"

#include "imappaniccodes.h"

#if (defined SYMBIAN_EMAIL_CAPABILITY_SUPPORT)

	#include "cimapauthhelpers.h"

#endif

/**

An RBuf buffer is used to create the sequence set string.

This specifies by how the buffer should grow each time it needs to be expanded.

*/

const TInt KSequenceSetGranularity = 32;

/**

A CBufFlat buffer is used to store incoming string data whenever incoming data needs to be spliced

together in order to form a contiguous line or literal block.

This specifies by how the buffer should grow each time it needs to be expanded.

*/

const TInt KInputCacheGranularity = 1024;

/**

During a flush (after cancelling a command),

time out if data is not received within 10 seconds of requesting it.

*/

const TInt KFlushTimeoutPeriod = 10*1000*1000;

#ifdef __IMAP_LOGGING

_LIT(KLogFileName, "imlog%d");

#endif //__IMAP_LOGGING

/**

The factory constructor. Part of two phased construction.

*/

EXPORT_C CImapSession* CImapSession::NewL(CImapSettings& aImapSettings, CImapMailStore& aImapMailStore, MInputStream& aInputStream, MOutputStream& aOutputStream)

// static method

	{

	CImapSession* self = new(ELeave) CImapSession(aImapSettings, aImapMailStore, aInputStream, aOutputStream);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CImapSession::CImapSession(CImapSettings& aImapSettings, CImapMailStore& aImapMailStore, MInputStream& aInputStream, MOutputStream& aOutputStream)

	: iImapSettings(aImapSettings), iImapMailStore(aImapMailStore) 

	, iInputStream(&aInputStream), iOutputStream(&aOutputStream)

	{}

void CImapSession::ConstructL()

	{

	__ASSERT_DEBUG(iInputStream != NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESessionNullInputStream));

	__ASSERT_DEBUG(iOutputStream != NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESessionNullOutputStream));

#ifdef __IMAP_LOGGING	

	//Getting the server port number for creating the IMAP log file

	TInt portNum = 143;

	TBuf<10> fileName;

	fileName.AppendFormat(KLogFileName, portNum);

	__LOG_CREATE_STANDARD(fileName, iLogId);

#endif //__IMAP_LOGGING	

	iServerGreetingInfo = CImapServerGreetingInfo::NewL();

	iCapabilityInfo = CImapCapabilityInfo::NewL();

	iInputCache = CBufFlat::NewL(KInputCacheGranularity);

	TCallBack callBack(CImapSession::AsyncCallBack, this);

	iAsyncCallBack = new(ELeave)CAsyncCallBack(callBack, CActive::EPriorityStandard);

	iFlushCommandTimeout = CImapObservableTimer::NewL(*this);

	iInputStream->Bind(*this, iLogId);

	iOutputStream->Bind(*this, iLogId);

	}

CImapSession::~CImapSession()

	{

	Cancel();

	// Close the streams if they are not already closed. Just closing the

	// output stream will also close the input stream.

	if (iOutputStream != NULL)

		{

		iOutputStream->Close();

		}

	delete iFlushCommandTimeout;

	delete iAsyncCallBack;

	delete iCurrentCommand;

	delete iSelectedFolderInfo;

	delete iCapabilityInfo;	

	delete iServerGreetingInfo;

	delete iInputCache;

	__LOG_CLOSE(iLogId);

	}

/**

Returns the current server state.

EServerStateNone indicates that the server greeting has not yet been received.

CImapSession will panic if an attempt is made to call invoke an IMAP command when the IMAP server is 

not in the correct state for the command.

This method can be called to check the state before invoking such a command.

@return The current server state.

*/

EXPORT_C CImapSession::TImapServerState CImapSession::ServerState()

	{

	return iServerState;

	}

/**

Returns inforamtion about the currently selected folder.

If no folder is currently selected, then NULL will be returned.

@return information about the currently selected folder or NULL if no folder is currently selected.

*/

EXPORT_C CImapFolderInfo* CImapSession::SelectedFolderInfo()

	{

	return iSelectedFolderInfo;

	}

/** 

Returns the server greeting information object.

The data in the object will only be valid after a greeting has been received from the server.

This must be requested using the ReadServerGreetingL() method immediately after connection has been made.

@return The server greeting information object.

*/

EXPORT_C const CImapServerGreetingInfo& CImapSession::ServerGreetingInfo()

	{

	return *iServerGreetingInfo;

	}

/** 

Returns the server capability information object.

The data in the object will only be valid after a capability response has been received from the server.

This can be requested using the CapabilityL() method.

@return The server capability information object.

*/

EXPORT_C const CImapCapabilityInfo& CImapSession::CapabilityInfo()

	{

	return *iCapabilityInfo;

	}

/** 

@return ETrue if IMAP IDLE mode is supported by the server.

*/

EXPORT_C TBool CImapSession::ImapIdleSupported() const

	{

	return iCapabilityInfo->QueryFlag(CImapCapabilityInfo::EIdle);

	}

/** 

Request to enter IMAP IDLE mode.

This method will complete when confirmation of entering IDLE mode has been received 

from the server, via the '+' continuation response.

The server may send untagged status information BEFORE sending the continuation response.

This will be recorded and can be accessed via SelectedFolderInfo().

Upon completion of EnterIdleL(), 

WaitForIdleEvent() should be called in order to wait for the next status information event, 

or DoneIdle() should be called to stop receiving further status information.

@param aStatus Signals the receipt of the continuation response.

*/

EXPORT_C void CImapSession::EnterIdleL(TRequestStatus& aStatus)

	{

	__LOG_TEXT(iLogId, "CImapSession::EnterIdleL()");

	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleWhenServerUnAuthenticated));

	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleWhenInvalidOperationPending));

	if (CompleteIfStreamsClosed(aStatus)) 

		{

		return;

		}

	StartCommandL(aStatus, CImapIdle::NewL(iSelectedFolderInfo, iLogId));

	SetPendingOperation(EOpIdleEnter);

	}

/**

Request to be notified of an IMAP IDLE event.

This method will complete when the next line of status information is received.

The updated information can be accessed via SelectedFolderInfo().

However, the information might not be complete as further lines of status information may 

have been sent but not yet received.

Upon completion of WaitForIdleEvent(), 

WaitForIdleEvent() should be called again in order to receive the next event

or DoneIdle() should be called to receive complete status information 

and to stop receiving further information.

This method will panic if the session is not currently in IDLE mode.

Use EnterIdleL() to enter IDLE mode.

@param aStatus Signals the receipt of a line of status information.

*/

EXPORT_C void CImapSession::WaitForIdleEvent(TRequestStatus& aStatus)

	{

	__LOG_TEXT(iLogId, "CImapSession::WaitForIdleEvent()");

	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleWaitWhenServerUnAuthenticated));

	__ASSERT_DEBUG(iPendingOperation == EOpIdleEnter || iPendingOperation == EOpIdleWait, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleWaitWhenOperationPendingNotIdle));

	__ASSERT_DEBUG(iSessionState == ESessionNormal, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleWaitWhenSessionNonNormal));

	if (CompleteIfStreamsClosed(aStatus)) 

		{

		return;

		}

	SetPendingOperation(EOpIdleWait);

	Queue(aStatus);

	// Restart the ProcessInputBufferL() loop asynchronously

	ProcessInputBufferAsync();

	}

/** 

Request to exit IMAP IDLE mode.

This will cause the session to send a DONE message to the server.

The method will complete when a tagged response is received.

Upon completion, up-to-date status information can be accessed via SelectedFolderInfo().

This method will panic if the session is not currently in IDLE mode.

Use EnterIdleL() to enter IDLE mode.

@param aStatus Signals completion of the request.

*/

EXPORT_C void CImapSession::DoneIdle(TRequestStatus& aStatus)

	{

	__LOG_TEXT(iLogId, "CImapSession::DoneIdle()");

	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleDoneWhenServerUnAuthenticated));

	__ASSERT_DEBUG(iPendingOperation == EOpIdleEnter || iPendingOperation == EOpIdleWait, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleDoneWhenWhenInvalidOperationPending));

	__ASSERT_DEBUG(iSessionState == ESessionNormal, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleDoneWhenSessionNonNormal));

	__ASSERT_DEBUG(iCurrentCommand != NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESessionNullCurrentCommand));

	if (CompleteIfStreamsClosed(aStatus)) 

		{

		return;

		}

	CImapIdle* idleCommand = static_cast<CImapIdle*>(iCurrentCommand);

	SetPendingOperation(EOpIdleDone); // Treat as a normal command.

	SetSessionState(ESessionNormal); // If called after cancel, then set the session back to normal state.

	// iOutputStream must be non-null because CompleteIfStreamsClosed() returned EFalse.

	idleCommand->SendDone(*iOutputStream);

	Queue(aStatus);

	// Restart the ProcessInputBufferL() loop asynchronously

	ProcessInputBufferAsync();

	}

/**

This method does not send a command to the server, 

but simply waits on the input stream for any unsolicited response message

that the server might decide to send.  See section 5.3 of RFC3501.

This method should be used in place of the IDLE methods when no command is

being processed.

To cancel this method, call Cancel() followed by FlushCancelledCommand() to 

ensure that partial responses are not left on the input stream before 

the issuing the next command

@param aStatus Signals that an unsolicited response has been received.

*/

EXPORT_C void CImapSession::WaitForServerEventL(TRequestStatus& aStatus)

	{

	__LOG_TEXT(iLogId, "CImapSession::WaitForServerEventL()");

	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EWaitForServerEventWhenServerUnAuthenticated));

	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EWaitForServerEventWhenInvalidOperationPending));

	if (CompleteIfStreamsClosed(aStatus)) 

		{

		return;

		}

	StartCommandL(aStatus, CImapServerEventWait::NewL(iSelectedFolderInfo, iLogId));

	}

/** 

Reads and parses the server greeting from the input stream.

This method must (and must only) be called immediately after making a connection to the server.

Once this method has completed succesfully, the server greeting information will be accessible 

from the ServerGreetingInfo() method of this object.

@return The server greeting information object.

*/

EXPORT_C void CImapSession::ReadServerGreetingL(TRequestStatus& aStatus)

	{

	__LOG_TEXT(iLogId, "CImapSession::ReadServerGreetingL()");

	__ASSERT_DEBUG(iServerState == EServerStateNone, TImapServerPanic::ImapPanic(TImapServerPanic::EReadServerGreetingWhenServerUnAuthenticated));

	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EReadServerGreetingWhenInvalidOperationPending));

	if (CompleteIfStreamsClosed(aStatus)) 

		{

		return;

		}

	SetPendingOperation(EOpServerGreeting); // Next server state depends on ServerGreeting result: could be PreAuth

	StartCommandL(aStatus, CImapServerGreeting::NewL(iSelectedFolderInfo, iLogId, *iServerGreetingInfo));

	}

/** 

Issue the IMAP capability command to gather IMAP capability information from the remote server.

Once this method has completed successfully, the capability information will be accessible 

from the CapabilityInfo() method of this object.

@param aStatus Signals completion of the request

@see CapabilityInfo()

*/

EXPORT_C void CImapSession::CapabilityL(TRequestStatus& aStatus)

	{

	__LOG_TEXT(iLogId, "CImapSession::CapabilityL()");

	__ASSERT_DEBUG(iServerState != EServerStateNone, TImapServerPanic::ImapPanic(TImapServerPanic::ECapabilityWhenServerStateUnknown));

	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ECapabilityWhenInvalidOperationPending));

	if (CompleteIfStreamsClosed(aStatus)) 

		{

		return;

		}

	StartCommandL(aStatus, CImapCapability::NewL(iSelectedFolderInfo, iLogId, *iCapabilityInfo));

	}

/** 

Issue the IMAP noop command.

When in selected state, and upon completions, the caller should 

check SelectedFolderInfo() for any updates.

@param aStatus 		Signals completion of the request

*/

EXPORT_C void CImapSession::NoopL(TRequestStatus& aStatus)

	{

	__LOG_TEXT(iLogId, "CImapSession::NoopL()");

	__ASSERT_DEBUG(iServerState != EServerStateNone, TImapServerPanic::ImapPanic(TImapServerPanic::ENoopWhenServerStateUnknown));

	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ENoopWhenInvalidOperationPending));

	if (CompleteIfStreamsClosed(aStatus)) 

		{

		return;

		}

	StartCommandL(aStatus, CImapNoop::NewL(iSelectedFolderInfo, iLogId));

	}

/**

Issue the IMAP logout command.

@param aStatus Signals completion of the request

*/

EXPORT_C void CImapSession::LogoutL(TRequestStatus& aStatus)

	{

	__LOG_TEXT(iLogId, "CImapSession::LogoutL()");

	__ASSERT_DEBUG(iServerState != EServerStateNone, TImapServerPanic::ImapPanic(TImapServerPanic::ELogOutWhenNotSelected));

	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ELogOutWhenInvalidOperationPending));

	if (CompleteIfStreamsClosed(aStatus)) 

		{

		return;

		}

	SetPendingOperation(EOpLogout); // Server state becomes None (i.e. disconnected)

	StartCommandL(aStatus, CImapLogout::NewL(iSelectedFolderInfo, iLogId));

	}

/**

Issue the IMAP login command.

@param aStatus Signals completion of the request

@param aUserName A user name supplied by the user

@param aPassword A password supplied by the user

*/

EXPORT_C void CImapSession::LoginL(TRequestStatus& aStatus, const TDesC8& aUserName, const TDesC8& aPassword)

	{

	__LOG_TEXT(iLogId, "CImapSession::LoginL()");

	__ASSERT_DEBUG(iServerState == EServerStateNotAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::ELoginWhenServerStateUnknown));

	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ELoginWhenInvalidOperationPending));

	if (CompleteIfStreamsClosed(aStatus)) 

		{

		return;

		}

	SetPendingOperation(EOpLogin); // << Server state becomes Authenticated

	StartCommandL(aStatus, CImapLogin::NewL(iSelectedFolderInfo, iLogId, aUserName, aPassword, *iCapabilityInfo));

	}

/** 

Issue the IMAP StartTLS command

@param aStatus Signals completion of the request

*/

EXPORT_C void CImapSession::StartTlsL(TRequestStatus& aStatus)

	{

	__LOG_TEXT(iLogId, "CImapSession::StartTlsL()");

	__ASSERT_DEBUG(iServerState == EServerStateNotAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EStartTLSWhenServerUnAuthenticated));

	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EStartTLSWhenInvalidOperationPending));

	if (CompleteIfStreamsClosed(aStatus)) 

		{

		return;

		}

	StartCommandL(aStatus, CImapStartTls::NewL(iSelectedFolderInfo, iLogId));

	}

/**

Issue the IMAP select command.

Opens the folder identified by aFolderInfo.Name() for read-write operations.

@param aStatus Signals completion of the request

@param aFolderInfo The folder object that represents the mailbox.  CImapSession takes ownership of this object.

The folder object initially contains the name of the folder to select.

The folder object will be updated upon successful completion of the command.

The folder object will be updated when any subsequent command receives folder information from the server.

*/

EXPORT_C void CImapSession::SelectL(TRequestStatus& aStatus, CImapFolderInfo* aFolderInfo, TBool aSelectBox)

	{

	__LOG_TEXT(iLogId, "CImapSession::SelectL()");

	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::ESelectWhenServerUnAuthenticated));

	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ESelectWhenInvalidOperationPending));

	__ASSERT_DEBUG(aFolderInfo != NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESessionImapFolderInfoIsNull));

	if (CompleteIfStreamsClosed(aStatus)) 

		{

		// Attempt to select while the stream is closed.

		// This failed select effectively puts us into the authenticated server state, 

		// where iSelectedFolderInfo should be NULL.

		delete iSelectedFolderInfo;

		iSelectedFolderInfo = NULL;		

		delete aFolderInfo; // No need to set to NULL as we're returning.

		return;

		}

			// Folder is already SELECTed so dont select again.. Hope this saves users bandwidth 

	if(aSelectBox)		

	{

		if(iSelectedFolderInfo && iSelectedFolderInfo->MsvId() == aFolderInfo->MsvId())

			{

			Queue(aStatus);

			Complete(KErrNone);

			delete aFolderInfo;

			return;

			}	

	}

	CleanupStack::PushL(aFolderInfo); // Take ownership but don't assign as a data member yet

	SetPendingOperation(EOpSelect); // Server state becomes Selected if successful, otherwise becomes Authenticated - and selected folder info becomes NULL

	StartCommandL(aStatus, CImapSelect::NewL(aFolderInfo, iLogId));

	// Overwrite any existing folder info, prior to performing the select

	// If select succeeds, iSelectedFolderInfo will be correct.

	// If select fails then iSelectedFolderInfo will be deleted and set to NULL later, as the state will 

	//   revert from Selected to Authenticated.

	CleanupStack::Pop(aFolderInfo); // Now we can assign aFolderInfo as a data member

	delete iSelectedFolderInfo;

	iSelectedFolderInfo = aFolderInfo;

	}

/**

Issue the IMAP examine command.

Opens the folder identified by aFolderInfo.Name() for read-only operations.

@param aStatus Signals completion of the request

@param aFolderInfo The folder object that represents the mailbox.  CImapSession takes ownership of this object.

The folder object initially contains the name of the folder to examine.

The folder object will be updated upon successful completion of the command.

The folder object will be updated when any subsequent command receives folder information from the server.

*/

EXPORT_C void CImapSession::ExamineL(TRequestStatus& aStatus, CImapFolderInfo* aFolderInfo)

	{

	__LOG_TEXT(iLogId, "CImapSession::ExamineL()");

	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EExamineWhenServerUnAuthenticated));

	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EExamineWhenInvalidOperationPending));

	__ASSERT_DEBUG(aFolderInfo != NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESessionImapFolderInfoIsNull));

	if (CompleteIfStreamsClosed(aStatus)) 

		{

		// Attempt to select while the stream is closed.

		// This failed select effectively puts us into the authenticated server state, 

		// where iSelectedFolderInfo should be NULL.

		delete iSelectedFolderInfo;

		iSelectedFolderInfo = NULL;		

		delete aFolderInfo; // No need to set to NULL as we're returning.		

		return;

		}

	CleanupStack::PushL(aFolderInfo); // Take ownership but don't assign as a data member yet

	SetPendingOperation(EOpSelect); // Server state becomes Selected if successful, otherwise becomes Authenticated - and selected folder info becomes NULL

	StartCommandL(aStatus, CImapExamine::NewL(aFolderInfo, iLogId));

	// Overwrite any existing folder info, prior to performing the select

	// If select succeeds, iSelectedFolderInfo will be correct.

	// If select fails then iSelectedFolderInfo will be deleted and set to NULL later, as the state will 

	//   revert from Selected to Authenticated.

	CleanupStack::Pop(aFolderInfo); // Now we can assign aFolderInfo as a data member