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

//

#include "IMSK.H"

#include <imutcon.h>

#include "IMSKSCR.H"

#include "IMUTDLL.H"

#include "cimsocketidletimer.h"

#include <e32hal.h>

#include <securesocket.h>

#include <bautils.h>

#include <barsread.h>

#include <es_enum.h>

#include <ssl_internal.h>

/*************************************************************

* Notes:                                           

*                                                  

* GetIAPBearer won't work if a new bearer is added,

* it will return KImskUnknownBearer                 

*                                                  

*************************************************************/

_LIT8(KImCarriageReturn,"\r\n");

_LIT(KSSLProtocol,"tls1.0");

_LIT8(KNullSSLDomainName, "");

const TInt KImutMicroSecondsToMinutes = 60000000;

const TInt KImutMicroSecondsToSeconds = 1000000;

#if defined(__IMSK_SIMULATION)

_LIT(KGPRSConfigFile, "c:\\logs\\email\\imutconf\\gprs.cfg");

_LIT(KFailIAPConfigFile, "c:\\logs\\email\\imutconf\\iapfail.cfg");

_LIT8(KStart, "start:");

_LIT8(KDuration, "duration:");

_LIT8(KRepeat, "repeat:");

_LIT8(KLogGPRSSimSuspended, "GPRS simulated suspend (%d)");

_LIT8(KLogGPRSSimUnSuspended, "GPRS returned from suspend");

#endif 	// __IMSK_SIMULATION

#ifndef _NO_MSG_LOGGING

#define __IMSK_LOGGING

#endif

#if defined(__IMSK_LOGGING)

#define __LOG_IN(text) (iLog?iLog->AppendResponse(text):void(0))

#define __LOG_COMMENT_OUT(text) (iLog?iLog->AppendComment(text):void(0))

#define __LOG_OUT(text) (iLog?iLog->AppendOut(text):void(0))

#define __LOG_ERR(text,err) (iLog?iLog->AppendError(text,err):void(0))

#else

#define __LOG_IN(text) (void(0))

#define __LOG_COMMENT_OUT(text) (void(0))

#define __LOG_OUT(text) (void(0))

#define __LOG_ERR(text,err) (void(0))

#endif

#if defined(__IMSK_LOGGING)

// IMSK Logging

_LIT8(KLogResolveCompleted, "Resolve completed");

_LIT8(KLogResolveQueued, "Resolve queued");

_LIT8(KLogConnectQueued, "Connect queued on port ");

_LIT8(KLogConnectCompleted, "Connect completed");

_LIT8(KLogSendReceiveCompleted, "SendReceive/Receiving completed");

_LIT8(KLogSendReceiveBinaryCompleted, "SendReceive/ReceivingBinaryData completed");

_LIT8(KLogServerConnectionError, "Server Connection error");

_LIT8(KLogReadCancelled, "Read cancelled");

_LIT8(KLogWriteCancelled, "Write cancelled");

_LIT8(KLogOverridefailed, "Overide failed with"); 

_LIT8(KLogTLSHandShake, "TLS handshake Started"); 

_LIT8(KLogTLSHandShakeCompleted, "TLS handshake completed"); 

_LIT8(KLogSocketClosed, "Closed socket"); 

_LIT8(KLogTLSResponse, "SSL/TLS response should be '%S'");

_LIT8(KLogSendReceiveTimedOut, "SendReceive has timed out");

#endif

//*********************************************************************************************/

//*                                                                                           */

//*                           Construction/Destruction functions                              */

//*                                                                                           */

//*********************************************************************************************/

LOCAL_C void RequestComplete(TRequestStatus& aStatus,TInt aError)

	{

	TRequestStatus* pStatus=&aStatus;

	User::RequestComplete(pStatus,aError);

	}

EXPORT_C CImTextServerSession  *CImTextServerSession::NewL()

	{

	CImTextServerSession* self=new (ELeave) CImTextServerSession();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

/**

@internalTechnology

@released

*/

EXPORT_C CImTextServerSession  *CImTextServerSession::NewL(RSocketServ& aSocketServ, CImConnect& aConnect)

	{

	CImTextServerSession* self=new (ELeave) CImTextServerSession(aSocketServ, aConnect);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

/**

Factory constructor that allows setting of send and receive idle times.

An idle time of zero implies that no timer should be set.

@param	aSendIdleTime

The idle time in minutes allowed for sending. A value of zero indicates that no timer 

should be set.

@param	aReceiveIdleTime

The idle time in minutes allowed for receiving. A value of zero indicates that no timer 

should be set.

@return

A pointer to the newly created CImTextServerSession object. 

*/

EXPORT_C CImTextServerSession  *CImTextServerSession::NewL(TInt aSendIdleTime, TInt aReceiveIdleTime)

	{

	CImTextServerSession* self=new (ELeave) CImTextServerSession(aSendIdleTime, aReceiveIdleTime);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

/**

@internalTechnology

@released

*/

EXPORT_C CImTextServerSession* CImTextServerSession::NewL(TInt aSendIdleTime, TInt aReceiveIdleTime, RSocketServ& aSocketServ, CImConnect& aConnect)

	{

	CImTextServerSession* self=new (ELeave) CImTextServerSession(aSendIdleTime, aReceiveIdleTime, aSocketServ, aConnect);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CImTextServerSession::CImTextServerSession()

	: CMsgActive(EActivePriorityHigh), 

	  iState(EImClosed),

	  iPerformLogging(ETrue)

	{

	}

CImTextServerSession::CImTextServerSession(RSocketServ& aSocketServ, CImConnect& aConnect)

	: CMsgActive(EActivePriorityHigh), 

	  iServ(aSocketServ),

	  iState(EImClosed),

	  iConnect(&aConnect),

	  iPerformLogging(ETrue),

	  iClientOwnsConnection(ETrue)

	{

	}

/**

Constructor that allows setting of the send and receive idle times.

An idle time of zero implies that no timer should be set.

@param	aSendIdleTime

The idle time in minutes allowed for sending. A value of zero indicates that no timer 

should be set.

@param	aReceiveIdleTime

The idle time in minutes allowed for receiving. A value of zero indicates that no timer 

should be set.

*/

CImTextServerSession::CImTextServerSession(TInt aSendIdleTime, TInt aReceiveIdleTime)

	: CMsgActive(EActivePriorityHigh), 

	  iState(EImClosed),

	  iPerformLogging(ETrue),

	  iSendIdleTime(aSendIdleTime*KImutMicroSecondsToMinutes),

	  iReceiveIdleTime(aReceiveIdleTime*KImutMicroSecondsToMinutes),iPrimaryTextServerSession(NULL)

	{

	}

CImTextServerSession::CImTextServerSession(TInt aSendIdleTime, TInt aReceiveIdleTime, RSocketServ& aSocketServ, CImConnect& aConnect)

	: CMsgActive(EActivePriorityHigh), 

	  iServ(aSocketServ),

	  iState(EImClosed),

	  iConnect(&aConnect),

	  iPerformLogging(ETrue),

	  iSendIdleTime(aSendIdleTime*KImutMicroSecondsToMinutes),

	  iReceiveIdleTime(aReceiveIdleTime*KImutMicroSecondsToMinutes),

	  iClientOwnsConnection(ETrue)

	{

	}

//

// 2nd stage of construction

//

void CImTextServerSession::ConstructL()

	{

	if (!iClientOwnsConnection)

		{

		User::LeaveIfError(iServ.Connect());

		}

#if defined(__IMSK_SIMULATION)

	// if gprs suspension file exists - use its contents to determine

	// the the time to delay TCP/IP traffic

	User::LeaveIfError(iFs.Connect());

	TInt err = iGprsFile.Open(iFs,KGPRSConfigFile,EFileShareAny);

	if (err != KErrNone && err != KErrPathNotFound && err != KErrNotFound)

		User::Leave(err);

	if (err == KErrNone)

		{

		iGprsConfigExists=ETrue;

		// read the first delay period

		ReadNextPeriod();

		// get baseline time

		if (SuspendPeriodSet())

			iLastSuspend.UniversalTime();

		User::LeaveIfError(iSuspendTimer.CreateLocal());

		}

	else

		iGprsConfigExists=EFalse;

#endif	// __IMSK_SIMULATION

	iSocketIdleTimer = CImSocketIdleTimer::NewL(*this);

	CActiveScheduler::Add(this); 

	}

//

// Destruction

//

CImTextServerSession::~CImTextServerSession()

	{

	Disconnect();

	delete iBuffer;

	if (!iClientOwnsConnection)

		{

		delete iConnect;

		iServ.Close();

		}

	delete iSentData;

	delete iTLSResponse;

#if defined(__IMSK_SIMULATION)

	iGprsFile.Close();

	delete iSendData;

	iFs.Close();

#endif // __IMSK_SIMULATION

	delete iSocketIdleTimer;

	delete iSSLDomainName;

	}

//*********************************************************************************************/

//*                                                                                           */

//*                           Connect/Disconnect functions                                    */

//*                                                                                           */

//*********************************************************************************************/

//

// Queue a standard or wrapped SSL connect (depending on state of iWrappedSocket) assuming the 

//  socket is successfully opened- RunL called on completion

//

void CImTextServerSession::QueueGenericConnectL(TRequestStatus &aStatus,const TDesC& anAddressDesc, TInt aPortNum, const CImIAPPreferences& aIAPPreferences, const TDesC8& aSSLDomainName)

	{

#if defined(__IMSK_LOGGING)

	CreateLogFile(aPortNum);  // Attempt to create the log file

#endif

	Queue(aStatus);

	iIAPPreferences=&aIAPPreferences;

	iPortNum=aPortNum;

	iAddressDesc.Set(anAddressDesc);

	delete iSSLDomainName;

	iSSLDomainName = NULL;

	if (aSSLDomainName.Length() > 0)

		{

		iSSLDomainName = aSSLDomainName.AllocL();

		}

	else

		{

		iSSLDomainName = HBufC8::NewL(iAddressDesc.Length());

		TPtr8 addr8ptr = iSSLDomainName->Des();

		addr8ptr.Copy(iAddressDesc);

		}

	__ASSERT_ALWAYS(iState==EImClosed,gPanic(EImskSocketOpen));

	iState = EImDialUsingOverride;

#if defined(__IMSK_SCRIPTING)

	if (!iScript)

		OpenScriptFile(iPortNum); // open the relevant script file if it exists

	if(iScript)

		RequestComplete(iStatus,KErrNone);

	else

#endif //(__IMSK_SCRIPTING)

		{

		// If we are not using the clients connection, create our own one now

		if (!iClientOwnsConnection)

			{

			delete iConnect;

			iConnect = 0;

			iConnect = CImConnect::NewL(*iIAPPreferences,*this);

			}

#if defined(__IMSK_SIMULATION)

		iConnect->SetIAPsToFail(ReadConfigNum(KFailIAPConfigFile));

#endif //(__IMSK_SIMULATION)

		// if local textseversession is active, then connect the session using existing RConnection

		if(iPrimaryTextServerSession)

			{

			// Attaching the existing RConnection.

			iConnect->SecondaryStartL(iPrimaryTextServerSession);			

			// Queue the connection

			DoQueueConnect();

			return;			

			}

		else

			{

			// If we are using the clients connection then it should have already been

			// started, so just self complete to keep the state machine going. If it is

			// our own connection, start it now.

			if (iClientOwnsConnection)

				{

				RequestComplete(iStatus, KErrNone);

				}

			else

				{

				iConnect->StartL(iStatus);	

				}

			}

		}

	SetActive();

	}

//

// Queue a connect assuming the socket is successfully opened- RunL called on completion

//

EXPORT_C void CImTextServerSession::QueueConnectL(TRequestStatus &aStatus,const TDesC& anAddressDesc, TInt aPortNum, const CImIAPPreferences& aIAPPreferences, TBool /*aEnableTimeout*/)

	{

		iWrappedSocket=EFalse;

		QueueGenericConnectL(aStatus, anAddressDesc, aPortNum,  aIAPPreferences, KNullSSLDomainName);

	}

/**

Queue a connect on a socket assuming the socket is successfully opened.

@param aStatus Asynchronous completion status

@param aAddressDesc Address of the server to connect to

@param aIAPPreferences IAP connection preferences to be used		

@param aPortNum Port number eg. 993, 465, 995.

@param aSSLDomainName SSL domain name to use for the connection

@pre   None

@post  Connection is ready to send and receive data

@since 9.5

*/

EXPORT_C void CImTextServerSession::QueueConnectL(TRequestStatus &aStatus,const TDesC& anAddressDesc, TInt aPortNum, const CImIAPPreferences& aIAPPreferences, const TDesC8& aSSLDomainName)

	{

	iWrappedSocket=EFalse;

	QueueGenericConnectL(aStatus, anAddressDesc, aPortNum,  aIAPPreferences, aSSLDomainName);

	}

//

// Queue a wrapped SSL connect assuming the socket is successfully opened- RunL called on completion

//

EXPORT_C void CImTextServerSession::SSLQueueConnectL(TRequestStatus &aStatus,const TDesC& anAddressDesc, TInt aPortNum, const CImIAPPreferences& aIAPPreferences, TBool /*aEnableTimeout*/)

	{

		iWrappedSocket=ETrue;

		QueueGenericConnectL(aStatus, anAddressDesc, aPortNum,  aIAPPreferences, KNullSSLDomainName);

	}

/**

Queue a wrapped SSL connect on a socket assuming the socket is successfully opened.

@param aStatus Asynchronous completion status

@param aAddressDesc Address of the server to connect to

@param aIAPPreferences IAP connection preferences to be used		

@param aPortNum Port number eg. 993, 465, 995.

@param aSSLDomainName SSL domain name to use for the connection

@pre   None

@post  Connection is ready to send and receive data

@since 9.5

*/

EXPORT_C void CImTextServerSession::SSLQueueConnectL(TRequestStatus &aStatus,const TDesC& anAddressDesc, TInt aPortNum, const CImIAPPreferences& aIAPPreferences, const TDesC8& aSSLDomainName)

	{

	iWrappedSocket=ETrue;

	QueueGenericConnectL(aStatus, anAddressDesc, aPortNum, aIAPPreferences, aSSLDomainName);

	}

//

// Public socket disconnection

//	

EXPORT_C void CImTextServerSession::Disconnect()

	{

	iIAPCached=EFalse;

	Cancel();

	Close();

	}

EXPORT_C void CImTextServerSession::Disconnect(TRequestStatus& aStatus)

	{

	Disconnect();

	RequestComplete(aStatus,KErrNone);

	}

//*********************************************************************************************/

//*                                                                                           */

//*                           Send/Recieve/Query functions                                    */

//*                                                                                           */

//*********************************************************************************************/

//

// Async send functions

//

EXPORT_C void CImTextServerSession::Send(TRequestStatus &aStatus, const TDesC8& aDesc)

	{

	if (iState!=EImSendReceive)

		{

		RequestComplete(aStatus,KErrDisconnected);

		return;

		}

	iSendShortIdleTime		= 0;

	iReceiveShortIdleTime	= 0;

	Queue(aStatus);

	iSendReceive=EImSending;

	RealSend(aDesc);

	}

//

// Async send function, specifying short idle timeouts should be used.

// aIdleTime specifies the send and next receive timeout to be used in seconds

//

EXPORT_C void CImTextServerSession::SendWithTimeout(TRequestStatus &aStatus, TInt aIdleTime, const TDesC8& aDesc)

	{

	if (iState!=EImSendReceive)

		{

		RequestComplete(aStatus,KErrDisconnected);

		return;

		}

	iSendShortIdleTime    = aIdleTime*KImutMicroSecondsToSeconds;

	iReceiveShortIdleTime = aIdleTime*KImutMicroSecondsToSeconds;

	Queue(aStatus);

	iSendReceive=EImSending;

	RealSend(aDesc);

	}

EXPORT_C void CImTextServerSession::SendQueueReceiveWithTimeout(TRequestStatus& aStatus, TInt aIdleTime, const TDesC8& aDesc) 

	{ 

	if (iState!=EImSendReceive)      

		{ 

		RequestComplete(aStatus, KErrDisconnected);

		return;

		} 

		iSendShortIdleTime    = aIdleTime*KImutMicroSecondsToSeconds; 

		iReceiveShortIdleTime = aIdleTime*KImutMicroSecondsToSeconds; 

    	Queue(aStatus); 

		iSendReceive=EImSendingQueueReceive; 

		RealSend(aDesc);

	} 	

//

// async. Send

//

EXPORT_C void CImTextServerSession::Send(TRequestStatus &aStatus, TRefByValue<const TDesC8> aFmt,...)

	{

	VA_LIST list;

	VA_START(list,aFmt);

	aBuf.AppendFormatList(aFmt,list);

	Send(aStatus, aBuf);

	}

//

// async Send and receive operation

//

EXPORT_C void CImTextServerSession::SendQueueReceive(TRequestStatus &aStatus, const TDesC8& aDesc)