// 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:

// Implementation file for class CImStmpSession -- representing

// a connection to a remote SMTP server.

// 

//

#include <miutpars.h>           // TImMessageField

#include <imcvsend.h>			// CImSendConvert

#include <logwrap.h>

#include <logwraplimits.h>

#include "SMTS.H"

#include "IMSM.H"				// CImSmtpSession

#include "IMSMSEND.H"			// CImSmtpFile

#include "SMTSUTIL.H"			// forward declarations for utility fns

#include <imutcon.h>

#include "mobilitytestmtmapi.h"

const TInt KSmtpAuthCodeSuccessful=235;

const TInt KSmtpAuthCodeFailed=535;

const TInt KSmtpUnableToAuthAtPresent=435;

const TInt KSmtpAuthCodeReadyResponse=334;

const TInt KSmtpBadParameter=501;

/**

Factory constructor

@param aServerEntry Server entry

@param aSettings SMTP settings

@param aServ Socket server

@param aConnect Network connection

@return Constructed class

*/

CImSmtpSession* CImSmtpSession::NewL(CMsvServerEntry& aServerEntry, CSmtpSettings& aSettings, RSocketServ& aServ, CImConnect& aConnect, TMsvId aServiceId)

	{

	CImSmtpSession* self = new (ELeave) CImSmtpSession(aServerEntry, aSettings, aServiceId);

	CleanupStack::PushL(self);

	self->ConstructL(aServ, aConnect);

	CleanupStack::Pop(self);

	return self;

	}

/**

Connect the session to the server

@param aClientStatus Client status to be completed

*/

void CImSmtpSession::ConnectL(TRequestStatus& aClientStatus)

	{

	__ASSERT_DEBUG(!iSocketIsConnected, gPanic(EImsmSocketAlreadyConnected));

	if (!iSocketIsConnected)

		{

		if(iSettings.SecureSockets())

			iThisSession = ESecureSession;		 // if the user has chosen to use TLS then we have to use ESMTP+TLS

		else if(iSettings.SMTPAuth())

			iThisSession = EEnhancedSmtpSession; // if the user has chosen to use AUTH, when we have to use ESMTP

		else

			iThisSession = ESmtpSession;		 // use SMTP session for now

		iCompleted = KErrNone;

		iState = EConnectingToSmtp;		// Initialise to 1st state of state machine

		DoStateL();						// Here we go...

		Queue(aClientStatus);		

		}

	else

		{

		// Nothing to do so just complete the caller

		RequestComplete(aClientStatus, KErrNone);

		}

	}

/**

Send all the emails to the server

@param aSendFiles Files to send

@param aClientStatus Client status to be completed

*/

void CImSmtpSession::SendFilesL(CMsgImOutboxSend& aSendFiles, TRequestStatus& aClientStatus)

	{

	__ASSERT_DEBUG(iSocketIsConnected, gPanic(EImsmSocketNotConnected1));

	TInt error = aSendFiles.NextFile();

	if (iSocketIsConnected &&  error == KErrNone)

		{

		iSendFiles = &aSendFiles;

		iState = ESendingImail;

		DoStateL();

		Queue(aClientStatus);

		}

	else if(error == KErrNotFound)

		{

		// Nothing to do so just complete the caller

		RequestComplete(aClientStatus, KErrNotFound);

		}

	else

		{

		// Nothing to do so just complete the caller

		RequestComplete(aClientStatus, KErrNone);

		}

	}

/**

Quit from the server

@param aClientStatus Client status to be completed

*/

void CImSmtpSession::QuitL(TRequestStatus& aClientStatus)

	{

	__ASSERT_DEBUG(iSocketIsConnected, gPanic(EImsmSocketNotConnected2));

	if (iSocketIsConnected)

		{

		iState = EClosingSmtp;

		DoStateL();

		Queue(aClientStatus);

		}

	else

		{

		// Nothing to do so just complete the caller

		RequestComplete(aClientStatus, KErrNone);

		}

	}

/**

Constructor

@param aServerEntry Server entry

@param aSettings SMTP settings

*/

CImSmtpSession::CImSmtpSession(CMsvServerEntry& aServerEntry, CSmtpSettings& aSettings, TMsvId aServiceId)

			  :	CMsgActive(KImSmtpSessionPriority),

			    iServerEntry(aServerEntry),

				iSettings(aSettings),

				iServiceId(aServiceId),

				iCurrentAuthProfile(CSmtpAuthMechanismHelper::EUndefined) // always start with undefined

	{

	__DECLARE_NAME(_S("CImSmtpSession"));

	}

/**

Second phase constructor

@param aServ Socket server

@param aConnect Network connection

*/

void CImSmtpSession::ConstructL(RSocketServ& aServ, CImConnect& aConnect)

	{

	iSocket = CImTextServerSession::NewL(aServ, aConnect);

	//if log fails, ignore the error and continue.

	TRAP_IGNORE(iLogMessage = CImLogMessage::NewL(iServerEntry.FileSession()));

	CActiveScheduler::Add(this);					// Add SmtpSession to scheduler's queue

	}

/**

Destructor

*/

CImSmtpSession::~CImSmtpSession()

	{

	Cancel();

	if (iSocketIsConnected)

		{

		iSocket->Disconnect();

		}

	delete iSmtpFile;			// should be dead already

	delete iSocket;

	delete iSmtpAuthHelper;

	delete iLogMessage;

	}

//

//  CreateFormattedAddressL()

//

//  Creates a new HDesC* containing the concateneatd alias and address strings

//

HBufC* CImSmtpSession::CreateFormattedAddressLC(const TDesC& aString, const TDesC& aAlias)

    {

    TImMessageField msgField;

    //  Make a buffer..

    TInt strLen     = aString.Length();

    TInt aliasLen   = aAlias.Length();

    HBufC* outString = HBufC::NewLC(strLen+aliasLen+5);

    HBufC* buffer = HBufC::NewL(strLen);

    *buffer = msgField.GetValidInternetEmailAddressFromString(aString);

	if (aliasLen)

        {

		outString->Des().Format(KSmtpEmailAddressAndAliasFmtStr,&aAlias,buffer);

        }

    else

        {

        *outString = *buffer;	        // just copy email address; as there's no alias to be added

        }

	delete buffer;

    return outString;

    }

TImImailFileProgress CImSmtpSession::FileProgress()

	{

	// Return info about how much of message has been sent so far

	TImImailFileProgress progress;

	if (iSmtpFile && (iState==ESendingImail))

		{

		// get progress from CImSmtpFile object as it is doing the work at the moment

        iSmtpFile->GetProgress(progress);

		// If there is more than 1 message being sent(ie when sending to BCC's), then

		// update the Progress to take account of the Total Num of Messages sent

		if (iNumMsgsToSend > 1)

			{

			// Calc the Total number of Bytes to send

			TInt fileByteSize = iSmtpFile->BytesToSend();

			TInt bytesSentBefore = (iNumMsgsSent-1)*fileByteSize;  // iNumMsgsSent-1, as this msg is not yet complete

			TInt totalBytesSent = bytesSentBefore + progress.iBytesSent;

			// Update the Progress

			progress.iBytesToSend = iTotalBytesToSend;

			progress.iBytesSent = totalBytesSent;

			}

		}

	else

		{

		progress.iSessionState = EClosingSmtp;

		progress.iBytesSent = 0;

		progress.iBytesToSend = 0;

		}

	return progress;

	}

void CImSmtpSession::SendFileL()

	{

	// Start the 'file mailer' object

	__ASSERT_DEBUG(!iSmtpFile,gPanic(EImsmSmtpFileObjectAlreadyExists));

	// log the info of the message to be sent

	if (iLogMessage)

		iLogMessage->Reset();

	//  Update the header info for this message..

	CImHeader* header = CImHeader::NewLC();

	CMsvStore* store = iServerEntry.EditStoreL();

	CleanupStack::PushL(store);

	header->RestoreL(*store);

	TBool isBccRcpt = EFalse;

	CDesCArray* rcptArray = NULL;

	TBool sendBccNow = iToRcptHeaderUpdated;

	if(!iToRcptHeaderUpdated)

		{

		//  Set the new info...

		//set from address

		HBufC* formatedAddress = CreateFormattedAddressLC(iSettings.EmailAddress(), iSettings.EmailAlias());//Format the address fields

		header->SetFromL(*formatedAddress);

		CleanupStack::PopAndDestroy(formatedAddress);

		formatedAddress = NULL;

		// set ReceiptAddress if one exists in the settings

		if( header->ReceiptAddress().Length() == 0 && iSettings.ReceiptAddress().Length() > 0 )

			{

			formatedAddress=CreateFormattedAddressLC(iSettings.ReceiptAddress(),iSettings.EmailAlias());//Format the address fields

			header->SetReceiptAddressL(*formatedAddress);

			CleanupStack::PopAndDestroy(formatedAddress);

			formatedAddress = NULL;

			}

		if(header->ToRecipients().Count()==0 && header->CcRecipients().Count()==0)

			{

			sendBccNow=ETrue;

			}

		// ReplyToAddress

		if ((header->ReplyTo().Length() == 0 || header->ReplyTo() == iSettings.ReplyToAddress()) &&

		    (iSettings.ReplyToAddress().Length() > 0))

			{

			formatedAddress= CreateFormattedAddressLC(iSettings.ReplyToAddress(),iSettings.EmailAlias());//Format the address fields

			header->SetReplyToL(*formatedAddress);

			CleanupStack::PopAndDestroy(formatedAddress);

			formatedAddress = NULL;

			}

		//make a copy of 'Bcc' recipients then remove from Msg header

		rcptArray= &(header->BccRecipients());

		if (iSettings.SendCopyToSelf()==ESendCopyAsBccRecipient)

			{

			if ( header->ReceiptAddress().Length() )

				rcptArray->AppendL(header->ReceiptAddress());

			else if ( header->ReplyTo().Length() )

				rcptArray->AppendL(header->ReplyTo());

			}

		if(rcptArray->Count() > 0)

			{

			iBccRcptFound=ETrue; // 'Bcc' recipients exists

			iBccRcptIndex=0;	  //reset the counter

			iFinishedWithBccRcpts=EFalse;

			iSendFiles->ResetBccRcptArrayL();

			TInt numberRcpts = rcptArray->Count();

			if(numberRcpts)

			{

			iSendFiles->BccRcptArray().AppendL((*rcptArray)[0]);

			CDesCArray& tempArr = iSendFiles->BccRcptArray();

			for(TInt counter=1; counter<numberRcpts; counter++)

				{

				TInt aPos = 0;

				tempArr.Find((*rcptArray)[counter],aPos,ECmpFolded16);			

				if(aPos > 0)	

				iSendFiles->BccRcptArray().AppendL((*rcptArray)[counter]);

				}

				}

			rcptArray->Reset();

			}

		iToRcptHeaderUpdated=ETrue;

		isBccRcpt=EFalse;

		}

	// Reset the number of Sent Messages, if all previous messages have been sent

	if (iNumMsgsSent >= iNumMsgsToSend)

		{

		iNumMsgsSent = 0;

		}

	// Calc the num of messages we're sending. If there is a To or CC,

	// recipient then there will be a message sent

	if(header->ToRecipients().Count()>0 || header->CcRecipients().Count()>0)

		iNumMsgsToSend = 1;

	else

		iNumMsgsToSend = 0;

	// If there are BCC recipients, then we will be sending a message to each

	if (iBccRcptFound)

		iNumMsgsToSend += iSendFiles->BccRcptArray().Count();

	// Make sure there are recipients to send to.

	__ASSERT_ALWAYS(iNumMsgsToSend,gPanic(EImsmZeroRecipientsInMessage));

	// sending Msg to 'Bcc' recipients so update header

	if (sendBccNow && iBccRcptFound)

		{

		rcptArray= &(header->BccRecipients());

		rcptArray->Reset();

		header->BccRecipients().AppendL(iSendFiles->BccRcptArray()[iBccRcptIndex]);

		++iBccRcptIndex;//for the next recipient

		if(iBccRcptIndex < iSendFiles->BccRcptArray().Count())

			iFinishedWithBccRcpts=EFalse;

		else

			iFinishedWithBccRcpts=ETrue;

		isBccRcpt=ETrue;

		}

	header->StoreL(*store);

	store->CommitL();

	if (iLogMessage)

		{

		iLogMessage->LogEvent().SetEventType(KLogMailEventTypeUid);

		if ((header->ToRecipients().Count()

 			+ header->CcRecipients().Count()

 			+ header->BccRecipients().Count()) > 1)

 		// If there are multiple recipients then set the recipient to 'multiple'

 			{

 			TBuf<KLogMaxSharedStringLength> multipleRecipientsString;

 			iLogMessage->GetString(multipleRecipientsString, R_LOG_REMOTE_MULTIPLE);

 			iLogMessage->LogEvent().SetRemoteParty(multipleRecipientsString);

 			}

 		else

 		// If there is only one recipient then set the recipient name

 			{

			if (header->ToRecipients().Count())

				iLogMessage->LogEvent().SetRemoteParty(header->ToRecipients()[0]);

			else if (header->CcRecipients().Count())

				iLogMessage->LogEvent().SetRemoteParty(header->CcRecipients()[0]);

			else if (header->BccRecipients().Count())

				iLogMessage->LogEvent().SetRemoteParty(header->BccRecipients()[0]);

			}

		iLogMessage->LogEvent().SetSubject(header->Subject());

		TBuf<KLogMaxSharedStringLength> outString;

		iLogMessage->GetString(outString, R_LOG_DIR_OUT);

		iLogMessage->LogEvent().SetDirection(outString);

		iLogMessage->LogEvent().SetLink(iServerEntry.Entry().Id());

		}

	CleanupStack::PopAndDestroy(2, header);

	iTimeNow.UniversalTime();	// Set time/date of sending this message file

	if (iLogMessage)

		iLogMessage->LogEvent().SetTime(iTimeNow);

	TRAPD(error,iSmtpFile = CImSmtpFile::NewL(	*iSocket,

                                                iServerEntry,

												iTimeNow,

												iSmtpBuffer,

												iSettings,

												isBccRcpt)); // Create the file mailing object

	if(error == KErrNone)

		{

		// If this is the first message to send, then calc the total bytes to send

		if (iNumMsgsSent == 0)

			{

			iTotalBytesToSend =  iSmtpFile->TotalMsgSizeL() * iNumMsgsToSend;

			}

		// Tell the file how many bytes it will be sending.  This is just a

		// rough estimate for progress

		iSmtpFile->SetBytesToSend(iTotalBytesToSend/iNumMsgsToSend);

		// Increment the number of messages sent

		++iNumMsgsSent;

		iSmtpFile->StartL(iStatus);		// start sending the message

		MOBILITY_TEST_MTM_STATE(iServiceId, KMobilityTestMtmStateSmtpSendFile);

		}

	else

		{

		iCompleted=error;

		RequestComplete(iStatus,0-error);	// Failed to create File object, but don't want to stop session prematurely, so negate error code

		}

	}

void CImSmtpSession::DoCancel()

	{

	if (iSmtpFile)

		{

		iSmtpFile->Cancel();	//which calls iSocket->Cancel()

		delete iSmtpFile;		// this is expected to be deleted

		iSmtpFile=NULL;

		}

	else if (iSocket)

		{

		iSocket->Cancel();

		}

	if (iLogMessage)

		{

		iLogMessage->Cancel();

		}

	CMsgActive::DoCancel();		// this MUST be the last statement in this function

	}

void CImSmtpSession::DoRunL()

	{

	// Received a KErrNone signal completing last pending asynchronous operation.

	// So now decide what to do next...

	delete iSmtpFile;			// delete mailing object; (new one created later if need to mail another message)

	iSmtpFile=NULL;

	if (iStatus.Int() != KErrNone && iState!=ELogDataEvent)

		{

		iCompleted=iStatus.Int();	// retain any non-zero completion code for future reference when DoComplete() is called

		}

	iState = NextStateL();

	if (!iOperationComplete)

		{

		if (iSmtpMultiLineResponse)

			{

			// Don't change state, just read next line of multi-line

			// response from remote SMTP server...

			iSmtpLastMultiLineResponse=EFalse;

			iSocket->QueueReceiveNextTextLine(iStatus);

			SetActive();

			}

		else

			{

			DoStateL();		// move to state that was chosen by this function

			}

		}

	else

		{

		iOperationComplete = EFalse;

		}

	}

void CImSmtpSession::DoComplete(TInt& aStatus)

	{

	if (aStatus==KErrDisconnected && iState==EClosingSmtp)

		{

		// ignore sudden disconnect if in closing state

		aStatus = KErrNone;

		}

	if (iCompleted && aStatus==KErrNone)		// last non-zero error in aStatus takes preference over older error stored in iCompleted

		{

		aStatus = iCompleted;

		}

	if (aStatus>KErrNone)

		{

		switch (aStatus)

			{

			case ESmtpMailboxNoAccess:

			case ESmtpMailboxName:

			case ESmtpTransactionFailed:

				aStatus=KSmtpLoginRefused;

				break;

			case -KSmtpBadMailFromAddress:

			case -KSmtpBadRcptToAddress: