// 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 "cimapsettings.h"

#include <miut_err.h>		// imap server error codes

#include <utf.h>

#include <imutcon.h>

#include "cimapsessionmanager.h"

#include "cimapsession.h"

#include "ctransportmanager.h"

#include "msocketfactory.h"

#include "cimapcapabilityinfo.h"

#include "cimaplistfolderinfo.h"

#include "cimapservergreetinginfo.h"

#include "moutputstream.h"

#include "minputstream.h"

#include "cimaplogger.h"

#include "msocketconnector.h"

#include "cimapsessionconsts.h"

#if (defined SYMBIAN_EMAIL_CAPABILITY_SUPPORT)

	#include "cimapauthhelpers.h"

#endif

/**

Static factory constructor. Part of two phased construction.

@param aImapSettings Settings for the Imap service

@param aImapMailStore Imap mail store

@return The constructed CImapSessionManager object

*/

EXPORT_C CImapSessionManager* CImapSessionManager::NewL(CImapSettings& aImapSettings, CImapMailStore& aImapMailStore)

	{

	CImapSessionManager* self = new (ELeave) CImapSessionManager(aImapSettings, aImapMailStore);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Class constructor

@param aImapSettings Settings for IMAP service

@param aImapMailStore Imap mail store

*/

CImapSessionManager::CImapSessionManager(CImapSettings& aImapSettings, CImapMailStore& aImapMailStore)

	: CMsgActive(EPriorityStandard)

	, iProgressState(TImap4GenericProgress::EIdle)

	, iImapSettings(aImapSettings)

	, iImapMailStore(aImapMailStore)

#if (defined SYMBIAN_EMAIL_CAPABILITY_SUPPORT)

	, iCurrentAuthProfile(CImapAuthMechanismHelper::EUndefined)

#endif

	{

	__LOG_TEXT(KDefaultLog, "CImapSessionManager::CImapSessionManager");

	}

/**

Class destructor

*/

CImapSessionManager::~CImapSessionManager()

	{

	__LOG_TEXT(KDefaultLog, "CImapSessionManager::~CImapSessionManager");

	Cancel();

	delete iTransportManager;

	delete iImConnect;

	iSocketServ.Close();

	delete iHostAddr8;

	iDisconnectList.Reset();

	iSeparatorFolderList.ResetAndDestroy();

	delete iImapSession;

	}

/**

Non-trival constructor. Part of two phased construction.

*/

void CImapSessionManager::ConstructL()

	{

	// We're an active object...

	CActiveScheduler::Add(this);

	}

/**

Requests construction of a connected, logged in CImapSession object

@param aStatus Signals completion of the request.

@param aSession Place to store the session once it is fully created.

*/

EXPORT_C void CImapSessionManager::GetSessionL(TRequestStatus& aStatus, CImapSession*& aSession)

	{

	__ASSERT_DEBUG(iState == EStateIdle,

	               TImapServerPanic::ImapPanic(TImapServerPanic::EUnexpectedStateForGetSession));

	__LOG_TEXT(KDefaultLog, "CImapSessionManager::GetSessionL");

	iStoreSession = &aSession;

	if (!iCreatedNetworkConnection)

		{

		CreateNetworkConnectionL();

		}

	else

		{

		CreateSocketL();

		}

	Queue(aStatus);

	}

/**

Requests logout and disconnect of a list of sessions.

@param aStatus Signals completion of the request.

@param aSessionList List of sessions to disconnect

*/

EXPORT_C void CImapSessionManager::Disconnect(TRequestStatus& aStatus, const RPointerArray<CImapSession>& aSessionList)

	{

	__ASSERT_DEBUG(iState == EStateIdle,

	               TImapServerPanic::ImapPanic(TImapServerPanic::EUnexpectedStateForDisConnect));

	__ASSERT_DEBUG(iDisconnectList.Count() == 0,

	               TImapServerPanic::ImapPanic(TImapServerPanic::EDisconnectWhenDisconnectListNotEmpty1));

	// Take a copy of the list of sessions to disconnect

	iDisconnectList.Reset();

	for (TInt session(0); session < aSessionList.Count(); ++session)

		{

		__LOG_TEXT(aSessionList[session]->LogId(), "CImapSessionManager::Disconnect (async, list)");

		TInt err = iDisconnectList.Append(aSessionList[session]);

		if(err != KErrNone)

			{

			break;

			}

		}

	iProgressState = TImap4GenericProgress::EDisconnecting;

	DisconnectFirstSessionInList();

	Queue(aStatus);

	}

/**

Requests immediate disconnect of a list of sessions. The logout command is not

sent.

@param aSessionList List of sessions to disconnect

*/

EXPORT_C void CImapSessionManager::Disconnect(const RPointerArray<CImapSession>& aSessionList)

	{

	__ASSERT_DEBUG(iDisconnectList.Count() == 0,

	               TImapServerPanic::ImapPanic(TImapServerPanic::EDisconnectWhenDisconnectListNotEmpty2));

	// Take a copy of the list of sessions to disconnect

	iDisconnectList.Reset();

	for (TInt session(0); session < aSessionList.Count(); ++session)

		{

		__LOG_TEXT(aSessionList[session]->LogId(), "CImapSessionManager::Disconnect (sync, list)");

		TInt err = iDisconnectList.Append(aSessionList[session]);

		if(KErrNone != err)

            {

		    CloseSessionStreams(aSessionList[session]);

            }

		}

	ImmediateDisconnect();

	}

/**

Requests immediate disconnect of a session. The logout command is not sent.

@param aSession Session to disconnect

*/

EXPORT_C void CImapSessionManager::Disconnect(const CImapSession& aSession)

	{

	__ASSERT_DEBUG(iDisconnectList.Count() == 0,

	               TImapServerPanic::ImapPanic(TImapServerPanic::EDisconnectWhenDisconnectListNotEmpty3));

	__LOG_TEXT(aSession.LogId(), "CImapSessionManager::Disconnect() - START - (sync, session)");

	// Create a disconnect list with just this one session

	iDisconnectList.Reset();

	TInt err = iDisconnectList.Append(&aSession);

	if(KErrNone != err)

        {

	    // remove contness of aSession

	    CImapSession& session = const_cast<CImapSession&>(aSession);

	    MOutputStream* outputStream = session.OutputStream();    

        if (outputStream != NULL)

            {

            outputStream->Close();

            }

        }

	ImmediateDisconnect();

    __LOG_TEXT(aSession.LogId(), "CImapSessionManager::Disconnect() - END - (sync, session)");

	}

/**

Gets LastSocketActivityTimeout value for the connection

@return LastSocketActivityTimeout value

*/

EXPORT_C TUint32 CImapSessionManager::LastSocketActivityTimeout()

	{

	return iLastSocketActivityTimeout;

	}

/**

Gets progress for an asynchronous operation

@param aProgress Holds progress information

*/

EXPORT_C void CImapSessionManager::Progress(TImap4GenericProgress& aProgress)

	{

	aProgress.iOperation = TImap4GenericProgress::EConnect;

	switch(iState)

		{

	case EStateCreatingNetworkConnection:

	case EStateConnectingSocket:

	case EStateGettingLastSocketActivityTimeout:

	case EStateUpgradingSSLWrappedSocket:

	case EStateGreetingWait:

	case EStateCapabilityWait:

	case EStateStartTLSWait:

	case EStateUpgradingTLSSocket:

	case EStateSecureCapabilityWait:

	case EStateLoginWait:

	case EStateSeparatorWait:

#if (defined SYMBIAN_EMAIL_CAPABILITY_SUPPORT)

	case EStateAuthenticateWait:

#endif

		{

		// We are connecting a session

		aProgress.iState = TImap4GenericProgress::EConnecting;

		aProgress.iImap4SubStateProgress = TImap4GenericProgress::EIdle;

		// iMsgsDone must contain the connection stage information

		aProgress.iMsgsDone = GetConnectionStage();

		TUint32 iap = 0;

		TInt err(KErrNotFound);

		// Get the IAP value to store in iMsgsToDo

		if (iImConnect != NULL)

			{

			err = iImConnect->GetIAPValue(iap);

			}

		if (err == KErrNone)

			{

			aProgress.iMsgsToDo = iap;

			}

		else

			{

			aProgress.iMsgsToDo = err;

			}

		break;

		}

	case EStateIdle:

	default:

		{

		aProgress.iState = iProgressState;

		aProgress.iImap4SubStateProgress = TImap4GenericProgress::EIdle;

		break;

		}

		}				

	}

/**

From MSocketConnectObserver - called when a connection to the remote server

has been successfully made.

@param aInputStream Created socket's input stream API

@param aOutputStream Created socket's output stream API

*/

void CImapSessionManager::ConnectionMadeL(MInputStream& aInputStream, MOutputStream& aOutputStream)

	{

	__LOG_TEXT(KDefaultLog, "CImapSessionManager::ConnectionMadeL");

	iInputStream = &aInputStream;

	iOutputStream = &aOutputStream;

	// Temporarily bind to the streams for close notifications.

	// Once the session is created, it will take over the binding.

	iInputStream->Bind(*this, KDefaultLog);

	iOutputStream->Bind(*this, KDefaultLog);

	// Store the current bearer type in the imap settings class

	TUint32 bearerType;

	iImConnect->GetIAPBearer(bearerType);

	iImapSettings.SetCurrentBearerType(bearerType);

	CompleteSelf(KErrNone);

	}

/**

From MSocketConnectObserver - Handle the Connection Error

Notification that an error has occured in the connecting service. The error 

code will have a value of KErrCancel if the observer has stopped the connect 

service via the MSocketConnectObserver::StopConnect() API. If a problem

does occur the socket connector will suicide after handling the error.

@param aError The error code.

@return A value of KErrNone if the error has been handled or any other 

        value if its has not been handled.

*/

TInt CImapSessionManager::HandleConnectError(TInt aError)

	{

	__LOG_FORMAT((KDefaultLog, "CImapSessionManager::HandleConnectError - %d", aError));

	// We should only get this while trying to connect the socket.

	// At any other time we can ignore it.

	// We can also get this after stopping a socket connect due to a

	// cancel. However we will have already self completed and we don't

	// want to complete again. If we have completed, then the iSocketConnector

	// will have been set to NULL, so check this.

	if ((iState == EStateConnectingSocket) && (iSocketConnector != NULL))

		{

		CompleteSelf(aError);

		}

	return KErrNone;

	}

/**

From MOutputStreamObserver - Indicates data has been sent successfully.

*/

void CImapSessionManager::SendDataCnf()

	{

	__LOG_TEXT(KDefaultLog, "CImapSessionManager::SendDataCnf");

	// No action required

	}

/**

From MOutputStreamObserver - Indicates that output stream has closed.

@param aError Error code that caused stream close.

*/

void CImapSessionManager::OutputStreamCloseInd(TInt aError)

	{

	__LOG_FORMAT((KDefaultLog, "CImapSessionManager::OutputStreamCloseInd - Error %d, State %d", aError, iState));

	// We can only get this when bound to the stream before the stream

	// binding is taken over by the session.

	__ASSERT_DEBUG(iState == EStateUpgradingSSLWrappedSocket,

	               TImapServerPanic::ImapPanic(TImapServerPanic::EUnexpectedOutputStreamCloseInd));

	if (iState == EStateUpgradingSSLWrappedSocket)

		{

		iOutputStream = NULL;

		// The only reason the socket should have closed is if a genuine error

		// has occured. However if for some reason we don't get an error

		// returned we need to complete with KErrDisconnected because the

		// socket has closed and we need to tell the caller that we are not

		// going to be able to finish creating the requested session.

		if (aError >= KErrNone)

			{

			aError = KErrDisconnected;

			}

		CompleteSelf(aError);

		}

	}

/**

From MOutputStreamSecureObserver - Indicates that a secure socket request

has completed on the output stream.

@param aError Error code from completed request.

*/

void CImapSessionManager::SecureClientCnf(TInt aError)

	{

	__LOG_FORMAT((LogId(), "CImapSessionManager::SecureClientCnf - Error %d, State %d", aError, iState));

	// Should only get this when we are upgrading to a secure socket

	__ASSERT_DEBUG((iState == EStateUpgradingSSLWrappedSocket ||

	                iState == EStateUpgradingTLSSocket),

	                TImapServerPanic::ImapPanic(TImapServerPanic::EUnexpectedSecureClientCnf));

	if ((iState == EStateUpgradingSSLWrappedSocket) ||

	    (iState == EStateUpgradingTLSSocket))

		{

		CompleteSelf(aError);

		}

	}

/**

From MInputStreamObserver - Indicates that the stream has received some data.

*/

void CImapSessionManager::ReceivedDataIndL(const TDesC8& /*aBuffer*/)

	{

	__LOG_TEXT(KDefaultLog, "CImapSessionManager::ReceivedDataIndL");

	// No action required

	}

/**

From MInputStreamObserver - Indicates that a secure socket request

has completed on the input stream.

*/

void CImapSessionManager::SecureServerCnf()

	{

	__LOG_TEXT(KDefaultLog, "CImapSessionManager::SecureServerCnf");

	// No action required

	}

/**

From MInputStreamObserver - Indicates that the input stream has been closed.

@param aError Error code that caused stream close.

*/

void CImapSessionManager::InputStreamCloseInd(TInt aError)

	{

	__LOG_FORMAT((KDefaultLog, "CImapSessionManager::InputStreamCloseInd - Error %d, State %d", aError, iState));

	// We can only get this when bound to the stream before the stream

	// binding is taken over by the session.

	__ASSERT_DEBUG(iState == EStateUpgradingSSLWrappedSocket,

	               TImapServerPanic::ImapPanic(TImapServerPanic::EUnexpectedInputStreamCloseInd));

	if (iState == EStateUpgradingSSLWrappedSocket)

		{

		iInputStream = NULL;

		// The only reason the socket should have closed is if a genuine error

		// has occured. However if for some reason we don't get an error

		// returned we need to complete with KErrDisconnected because the

		// socket has closed and we need to tell the caller that we are not

		// going to be able to finish creating the requested session.

		if (aError >= KErrNone)

			{

			aError = KErrDisconnected;

			}

		// Complete the request if there is no error while upgrading socket to SSL/TLS.

		if(!iErrorUpgradingSSLSocket)

		   {

		   CompleteSelf(aError);	

		   }

		}

	}

/**

Called when asynchronous IMAP Session events occur.

Manages the various steps necessary to log in to the IMAP Service, or to

logout from it.

*/

void CImapSessionManager::DoRunL()

	{

	iCompletedSelf = EFalse;

	// If we get a positive error code such as KErrImapNO, leave now

	// which will mean that DoComplete is called with that error code.

	// This is derived from CMsgActive, so we should not get any negative

	// error codes. They will go straight to DoComplete.

	if (iStatus.Int() > KErrNone)

		{

		User::Leave(iStatus.Int());

		}

	switch(iState)

		{

		case EStateCreatingNetworkConnection:

			{

			ProcessNetworkConnectionCreatedL();

			break;

			}

		case EStateConnectingSocket:

			{

			ProcessSocketConnectedL();

			break;

			}

		case EStateUpgradingSSLWrappedSocket:

			{

			ProcessUpgradedSSLWrappedSocketL();

			break;

			}

		case EStateGreetingWait:

			{

			ProcessGreetingResponseL();

			break;

			}

		case EStateCapabilityWait:

			{

			ProcessCapabilityResponseL();

			break;

			}

		case EStateStartTLSWait:

			{

			ProcessStartTLSResponse();

			break;

			}

		case EStateUpgradingTLSSocket:

			{

			ProcessUpgradedTLSSocketL();

			break;

			}

		case EStateSecureCapabilityWait:

			{

			ProcessSecureCapabilityResponseL();